RASCSI/easyinstall.sh

#!/usr/bin/env bash

# BSD 3-Clause License
# Author @sonique6784
# Copyright (c) 2020, sonique6784

function showRaSCSILogo(){
logo="""
    .~~.   .~~.\n
  '. \ ' ' / .'\n
   .╔═══════╗.\n
  : ║|¯¯¯¯¯|║ :\n
 ~ (║|_____|║) ~\n
( : ║ .  __ ║ : )\n
 ~ .╚╦═════╦╝. ~\n
  (  ¯¯¯¯¯¯¯  ) RaSCSI Assistant\n
   '~ .~~~. ~'\n
       '~'\n
"""
echo -e $logo
}

function showMacNetworkWired(){
logo="""
                              .-~-.-~~~-.~-.\n
 ╔═══════╗                  .(              )\n
 ║|¯¯¯¯¯|║                 /               \`.\n
 ║|_____|║>--------------<~               .   )\n
 ║ .  __ ║                 (              :'-'\n
 ╚╦═════╦╝                  ~-.________.:'\n
  ¯¯¯¯¯¯¯\n
"""
echo -e $logo
}

function showMacNetworkWireless(){
logo="""
                              .-~-.-~~~-.~-.\n
 ╔═══════╗        .(       .(              )\n
 ║|¯¯¯¯¯|║  .(  .(        /               \`.\n
 ║|_____|║ .o    o       ~               .   )\n
 ║ .  __ ║  '(  '(        (              :'-'\n
 ╚╦═════╦╝        '(       ~-.________.:'\n
  ¯¯¯¯¯¯¯\n
"""
echo -e $logo
}

USER=$(whoami)
BASE=$(dirname "$(readlink -f "${0}")")
VIRTUAL_DRIVER_PATH="$HOME/images"
CFG_PATH="$HOME/.config/rascsi"
WEB_INSTALL_PATH="$BASE/python/web"
OLED_INSTALL_PATH="$BASE/python/oled"
PYTHON_COMMON_PATH="$BASE/python/common"
SYSTEMD_PATH="/etc/systemd/system"
HFS_FORMAT=/usr/bin/hformat
HFDISK_BIN=/usr/bin/hfdisk
LIDO_DRIVER=$BASE/lido-driver.img
GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
GIT_REMOTE=${GIT_REMOTE:-origin}
TOKEN=""

set -e

# checks to run before entering the script main menu
function initialChecks() {
    if [ "root" == "$USER" ]; then
        echo "Do not run this script as $USER or with 'sudo'."
        exit 1
    fi
}

# checks that the current user has sudoers privileges
function sudoCheck() {
    echo "Input your password to allow this script to make the above changes."
    sudo -v
}

# install all dependency packages for RaSCSI Service
function installPackages() {
    sudo apt-get update && sudo apt-get install git libspdlog-dev libpcap-dev genisoimage python3 python3-venv python3-dev python3-pip nginx libpcap-dev protobuf-compiler bridge-utils libev-dev libevdev2 -y </dev/null
}

# compile the RaSCSI binaries
function compileRaScsi() {
    cd "$BASE/src/raspberrypi" || exit 1

    echo "Compiling with ${CORES:-1} simultaneous cores..."
    make clean </dev/null
    sudo -v
    make -j "${CORES:-1}" all CONNECT_TYPE="${CONNECT_TYPE:-FULLSPEC}" </dev/null
    sudo -v
}

function cleanupOutdatedManPage() {
    OUTDATED_MAN_PAGE_DIR=/usr/share/man/man1/
    if [ -f "${OUTDATED_MAN_PAGE_DIR}/$1" ]; then
      sudo rm "${OUTDATED_MAN_PAGE_DIR}/$1"
    fi
}

# install the RaSCSI binaries and modify the service configuration
function installRaScsi() {
    # clean up outdated man pages if they exist
    cleanupOutdatedManPage "rascsi.1"
    cleanupOutdatedManPage "rasctl.1"
    cleanupOutdatedManPage "scsimon.1"
    cleanupOutdatedManPage "rasdump.1"
    cleanupOutdatedManPage "sasidump.1"
    # install
    sudo make install CONNECT_TYPE="${CONNECT_TYPE:-FULLSPEC}" </dev/null
}

function preparePythonCommon() {
    if [ -f "$WEB_INSTALL_PATH/src/rascsi_interface_pb2.py" ]; then
        sudo rm "$WEB_INSTALL_PATH/src/rascsi_interface_pb2.py"
        echo "Deleting old Python protobuf library $WEB_INSTALL_PATH/src/rascsi_interface_pb2.py"
    fi
    if [ -f "$OLED_INSTALL_PATH/src/rascsi_interface_pb2.py" ]; then
        sudo rm "$OLED_INSTALL_PATH/src/rascsi_interface_pb2.py"
        echo "Deleting old Python protobuf library $OLED_INSTALL_PATH/src/rascsi_interface_pb2.py"
    fi
    if [ -f "$PYTHON_COMMON_PATH/src/rascsi_interface_pb2.py" ]; then
        sudo rm "$PYTHON_COMMON_PATH/src/rascsi_interface_pb2.py"
        echo "Deleting old Python protobuf library $PYTHON_COMMON_PATH/src/rascsi_interface_pb2.py"
    fi
    echo "Compiling the Python protobuf library rascsi_interface_pb2.py..."
    protoc -I="$BASE/src/raspberrypi/" --python_out="$PYTHON_COMMON_PATH/src" rascsi_interface.proto
}

# install everything required to run an HTTP server (Nginx + Python Flask App)
function installRaScsiWebInterface() {
    sudo cp -f "$WEB_INSTALL_PATH/service-infra/nginx-default.conf" /etc/nginx/sites-available/default
    sudo cp -f "$WEB_INSTALL_PATH/service-infra/502.html" /var/www/html/502.html

    sudo usermod -a -G $USER www-data

    sudo systemctl reload nginx || true
}

# Creates the dir that RaSCSI uses to store image files
function createImagesDir() {
    if [ -d "$VIRTUAL_DRIVER_PATH" ]; then
        echo "The $VIRTUAL_DRIVER_PATH directory already exists."
    else
        echo "The $VIRTUAL_DRIVER_PATH directory does not exist; creating..."
        mkdir -p "$VIRTUAL_DRIVER_PATH"
        chmod -R 775 "$VIRTUAL_DRIVER_PATH"
    fi
}

# Creates the dir that the Web Interface uses to store configuration files
function createCfgDir() {
    if [ -d "$CFG_PATH" ]; then
        echo "The $CFG_PATH directory already exists."
    else
        echo "The $CFG_PATH directory does not exist; creating..."
        mkdir -p "$CFG_PATH"
        chmod -R 775 "$CFG_PATH"
    fi
}

# Stops the rascsi-web and apache2 processes
function stopOldWebInterface() {
    stopRaScsiWeb

    APACHE_STATUS=$(sudo systemctl status apache2 &> /dev/null; echo $?)
    if [ "$APACHE_STATUS" -eq 0 ] ; then
        echo "Stopping old Apache2 RaSCSI Web..."
        sudo systemctl disable apache2
        sudo systemctl stop apache2
    fi
}

# Checks for upstream changes to the git repo and fast-forwards changes if needed
function updateRaScsiGit() {
    cd "$BASE" || exit 1

    set +e
    git rev-parse --is-inside-work-tree &> /dev/null
    if [[ $? -ge 1 ]]; then
        echo "Warning: This does not seem to be a valid clone of a git repository. I will not be able to pull the latest code."
        return 0
    fi
    set -e

    stashed=0
    if [[ $(git diff --stat) != '' ]]; then
        echo "There are local changes to the RaSCSI code; we will stash and reapply them."
        git -c user.name="${GIT_COMMITTER_NAME-rascsi}" -c user.email="${GIT_COMMITTER_EMAIL-rascsi@rascsi.com}" stash
        stashed=1
    fi

    if [[ `git for-each-ref --format='%(upstream:short)' "$(git symbolic-ref -q HEAD)"` != "" ]]; then
        echo "Updating checked out git branch $GIT_REMOTE/$GIT_BRANCH"
        git pull --ff-only
    else
        echo "Detected a local git working branch; skipping the remote update step."
    fi

    if [ $stashed -eq 1 ]; then
        echo "Reapplying local changes..."
        git stash apply
    fi
}

# Takes a backup copy of the rascsi.service file if it exists
function backupRaScsiService() {
    if [ -f "$SYSTEMD_PATH/rascsi.service" ]; then
        sudo mv "$SYSTEMD_PATH/rascsi.service" "$SYSTEMD_PATH/rascsi.service.old"
        SYSTEMD_BACKUP=true
        echo "Existing version of rascsi.service detected; Backing up to rascsi.service.old"
    else
        SYSTEMD_BACKUP=false
    fi
}

# Offers the choice of enabling token-based authentication for RaSCSI
function configureTokenAuth() {
    echo ""
    echo "Do you want to protect your RaSCSI installation with a password? [y/N]"
    read REPLY

    if [ "$REPLY" == "y" ] || [ "$REPLY" == "Y" ]; then
        echo -n "Enter the password that you want to use: "
        read -r TOKEN
        if [ -f "$HOME/.rascsi_secret" ]; then
            sudo rm "$HOME/.rascsi_secret"
            echo "Removed old RaSCSI token file"
        fi
        echo "$TOKEN" > "$HOME/.rascsi_secret"
        sudo chown root:root "$HOME/.rascsi_secret"
        sudo chmod 600 "$HOME/.rascsi_secret"
        echo ""
        echo "Configured RaSCSI to use $HOME/.rascsi_secret for authentication. This file is readable by root only."
        echo "Make note of your password: you will need it to use rasctl and other RaSCSI clients."
    fi
}

# Modifies and installs the rascsi service
function enableRaScsiService() {
    if [ ! -z "$TOKEN" ]; then
        sudo sed -i "s@^ExecStart.*@& -F $VIRTUAL_DRIVER_PATH -P $HOME/.rascsi_secret@" "$SYSTEMD_PATH/rascsi.service"
        sudo chmod 600 "$SYSTEMD_PATH/rascsi.service"
    else
        sudo sed -i "s@^ExecStart.*@& -F $VIRTUAL_DRIVER_PATH@" "$SYSTEMD_PATH/rascsi.service"
    fi
    echo "Configured rascsi.service to use $VIRTUAL_DRIVER_PATH as default image dir."

    sudo systemctl daemon-reload
    sudo systemctl restart rsyslog
    sudo systemctl enable rascsi # optional - start rascsi at boot
    sudo systemctl start rascsi

}

# Modifies and installs the rascsi-web service
function installWebInterfaceService() {
    echo "Installing the rascsi-web.service configuration..."
    sudo cp -f "$WEB_INSTALL_PATH/service-infra/rascsi-web.service" "$SYSTEMD_PATH/rascsi-web.service"
    sudo sed -i /^ExecStart=/d "$SYSTEMD_PATH/rascsi-web.service"
    echo "$TOKEN"
    if [ ! -z "$TOKEN" ]; then
        sudo sed -i "8 i ExecStart=$WEB_INSTALL_PATH/start.sh --password=$TOKEN" "$SYSTEMD_PATH/rascsi-web.service"
        sudo chmod 600 "$SYSTEMD_PATH/rascsi-web.service"
        echo "Granted access to the Web Interface with the token password that you configured for RaSCSI."
    else
        sudo sed -i "8 i ExecStart=$WEB_INSTALL_PATH/start.sh" "$SYSTEMD_PATH/rascsi-web.service"
    fi

    sudo systemctl daemon-reload
    sudo systemctl enable rascsi-web
    sudo systemctl start rascsi-web
}

# Stops the rascsi service if it is running
function stopRaScsi() {
    if [[ -f "$SYSTEMD_PATH/rascsi.service" ]]; then
        SERVICE_RASCSI_RUNNING=0
        sudo systemctl is-active --quiet rascsi.service >/dev/null 2>&1 || SERVICE_RASCSI_RUNNING=$?
        if [[ $SERVICE_RASCSI_RUNNING -eq 0 ]]; then
            sudo systemctl stop rascsi.service
        fi
    fi
}

# Stops the rascsi-web service if it is running
function stopRaScsiWeb() {
    if [[ -f "$SYSTEMD_PATH/rascsi-web.service" ]]; then
        SERVICE_RASCSI_WEB_RUNNING=0
        sudo systemctl is-active --quiet rascsi-web.service >/dev/null 2>&1 || SERVICE_RASCSI_WEB_RUNNING=$?
        if [[ $SERVICE_RASCSI_WEB_RUNNING -eq 0 ]]; then
            sudo systemctl stop rascsi-web.service
        fi
    fi
}

# Stops the rascsi-oled service if it is running
function stopRaScsiScreen() {
    if [[ -f "$SYSTEMD_PATH/monitor_rascsi.service" ]]; then
        SERVICE_MONITOR_RASCSI_RUNNING=0
        sudo systemctl is-active --quiet monitor_rascsi.service >/dev/null 2>&1 || SERVICE_MONITOR_RASCSI_RUNNING=$?
        if [[ $SERVICE_MONITOR_RASCSI_RUNNING -eq 0 ]]; then
          sudo systemctl stop monitor_rascsi.service
        fi
    fi
    if [[ -f "$SYSTEMD_PATH/rascsi-oled.service" ]]; then
        SERVICE_RASCSI_OLED_RUNNING=0
        sudo systemctl is-active --quiet rascsi-oled.service >/dev/null 2>&1 || SERVICE_RASCSI_OLED_RUNNING=$?
        if  [[ $SERVICE_RASCSI_OLED_RUNNING -eq 0 ]]; then
          sudo systemctl stop rascsi-oled.service
        fi
    fi
}

# disables and removes the old monitor_rascsi service
function disableOldRaScsiMonitorService() {
    if [ -f "$SYSTEMD_PATH/monitor_rascsi.service" ]; then
        SERVICE_MONITOR_RASCSI_RUNNING=0
        sudo systemctl is-active --quiet monitor_rascsi.service >/dev/null 2>&1 || SERVICE_MONITOR_RASCSI_RUNNING=$?
        if [[ $SERVICE_MONITOR_RASCSI_RUNNING -eq 0 ]]; then
          sudo systemctl stop monitor_rascsi.service
        fi

        SERVICE_MONITOR_RASCSI_ENABLED=0
        sudo systemctl is-enabled --quiet monitor_rascsi.service >/dev/null 2>&1 || SERVICE_MONITOR_RASCSI_ENABLED=$?
        if [[ $SERVICE_MONITOR_RASCSI_ENABLED -eq 0 ]]; then
          sudo systemctl disable monitor_rascsi.service
        fi
        sudo rm $SYSTEMD_PATH/monitor_rascsi.service
    fi
}

# Stops the macproxy service if it is running
function stopMacproxy() {
    if [ -f "$SYSTEMD_PATH/macproxy.service" ]; then
        sudo systemctl stop macproxy.service
    fi
}

# Starts the rascsi-oled service if installed
function isRaScsiScreenInstalled() {
    SERVICE_RASCSI_OLED_ENABLED=0
    if [[ -f "$SYSTEMD_PATH/rascsi-oled.service" ]]; then
        sudo systemctl is-enabled --quiet rascsi-oled.service >/dev/null 2>&1 || SERVICE_RASCSI_OLED_ENABLED=$?
    elif [[ -f "$SYSTEMD_PATH/monitor_rascsi.service" ]]; then
        sudo systemctl is-enabled --quiet monitor_rascsi.service >/dev/null 2>&1 || SERVICE_RASCSI_OLED_ENABLED=$?
    else
        SERVICE_RASCSI_OLED_ENABLED=1
    fi

    echo $SERVICE_RASCSI_OLED_ENABLED
}

# Starts the rascsi-oled service if installed
function isRaScsiScreenRunning() {
    SERVICE_RASCSI_OLED_RUNNING=0
    if [[ -f "$SYSTEMD_PATH/rascsi-oled.service" ]]; then
        sudo systemctl is-active --quiet rascsi-oled.service >/dev/null 2>&1 || SERVICE_RASCSI_OLED_RUNNING=$?
    elif [[ -f "$SYSTEMD_PATH/monitor_rascsi.service" ]]; then
        sudo systemctl is-active --quiet monitor_rascsi.service >/dev/null 2>&1 || SERVICE_RASCSI_OLED_RUNNING=$?
    else
        SERVICE_RASCSI_OLED_RUNNING=1
    fi

    echo $SERVICE_RASCSI_OLED_RUNNING
}

# Starts the rascsi-oled service if installed
function startRaScsiScreen() {
    if [[ $(isRaScsiScreenInstalled) -eq 0 ]] && [[ $(isRaScsiScreenRunning) -ne 1 ]]; then
        sudo systemctl start rascsi-oled.service
        showRaScsiScreenStatus
    fi
}

# Starts the macproxy service if installed
function startMacproxy() {
    if [ -f "$SYSTEMD_PATH/macproxy.service" ]; then
        sudo systemctl start macproxy.service
        showMacproxyStatus
    fi
}

# Shows status for the rascsi service
function showRaScsiStatus() {
    systemctl status rascsi | tee
}

# Shows status for the rascsi-web service
function showRaScsiWebStatus() {
    systemctl status rascsi-web | tee
}

# Shows status for the rascsi-oled service
function showRaScsiScreenStatus() {
    systemctl status rascsi-oled | tee
}

# Shows status for the macproxy service
function showMacproxyStatus() {
    systemctl status macproxy | tee
}

# Creates a drive image file with specific parameters
function createDrive600MB() {
    createDrive 600 "HD600"
}

# Creates a drive image file and prompts for parameters
function createDriveCustom() {
    driveSize=-1
    until [ $driveSize -ge "10" ] && [ $driveSize -le "4000" ]; do
        echo "What drive size would you like (in MB) (10-4000)"
        read driveSize

        echo "How would you like to name that drive?"
        read driveName
    done

    createDrive "$driveSize" "$driveName"
}

# Creates an HFS file system
function formatDrive() {
    diskPath="$1"
    volumeName="$2"

    if [ ! -x $HFS_FORMAT ]; then
        # Install hfsutils to have hformat to format HFS
        sudo apt-get install hfsutils --assume-yes </dev/null
    fi

    if [ ! -x $HFDISK_BIN ]; then
        # Clone, compile and install 'hfdisk', partition tool
        git clone git://www.codesrc.com/git/hfdisk.git
        cd hfdisk || exit 1
        make

        sudo cp hfdisk /usr/bin/hfdisk
    fi

    # Inject hfdisk commands to create Drive with correct partitions
    # https://www.codesrc.com/mediawiki/index.php/HFSFromScratch
    # i                         initialize partition map
    # continue with default first block
    # C                         Create 1st partition with type specified next) 
    # continue with default
    # 32                        32 blocks (required for HFS+)
    # Driver_Partition          Partition Name
    # Apple_Driver              Partition Type  (available types: Apple_Driver, Apple_Driver43, Apple_Free, Apple_HFS...)
    # C                         Create 2nd partition with type specified next
    # continue with default first block
    # continue with default block size (rest of the disk)
    # ${volumeName}             Partition name provided by user
    # Apple_HFS                 Partition Type
    # w                         Write partition map to disk
    # y                         Confirm partition table
    # p                         Print partition map
    (echo i; echo ; echo C; echo ; echo 32; echo "Driver_Partition"; echo "Apple_Driver"; echo C; echo ; echo ; echo "${volumeName}"; echo "Apple_HFS"; echo w; echo y; echo p;) | $HFDISK_BIN "$diskPath"
    partitionOk=$?

    if [ $partitionOk -eq 0 ]; then
        if [ ! -f "$LIDO_DRIVER" ];then
            echo "Lido driver couldn't be found. Make sure RaSCSI is up-to-date with git pull"
            return 1
        fi

        # Burn Lido driver to the disk
        dd if="$LIDO_DRIVER" of="$diskPath" seek=64 count=32 bs=512 conv=notrunc

        driverInstalled=$?
        if [ $driverInstalled -eq 0 ]; then
            # Format the partition with HFS file system
            $HFS_FORMAT -l "${volumeName}" "$diskPath" 1
            hfsFormattedOk=$?
            if [ $hfsFormattedOk -eq 0 ]; then
                echo "Disk created with success."
            else
                echo "Unable to format HFS partition."
                return 4
            fi
        else
            echo "Unable to install Lido Driver."
            return 3
        fi
    else
        echo "Unable to create the partition."
        return 2
    fi
}

# Creates an image file
function createDrive() {
    if [ $# -ne 2 ]; then
        echo "To create a Drive, volume size and volume name must be provided"
        echo "$ createDrive 600 \"RaSCSI Drive\""
        echo "Drive wasn't created."
        return
    fi

    driveSize=$1
    driveName=$2
    mkdir -p "$VIRTUAL_DRIVER_PATH"
    drivePath="${VIRTUAL_DRIVER_PATH}/${driveSize}MB.hda"

    if [ ! -f "$drivePath" ]; then
        echo "Creating a ${driveSize}MB Drive"
        truncate --size "${driveSize}m" "$drivePath"

        echo "Formatting drive with HFS"
        formatDrive "$drivePath" "$driveName"

    else
        echo "Error: drive already exists"
    fi
}

# Modifies system configurations for a wired network bridge