quickemu/quickget

#!/usr/bin/env bash


# Here the quick 'n dirty guide to adding a new OS to quickget
#
#  1. Add the new OS, all lowercase, to os_support()
#  2. Add a "pretty name" display name to pretty_name()
#  3. Create a releases_newos() generator that outputs the currently supported release versions
#  4. Add the new OS to make_vm_config()
#  5. Create a get_newos() function that does something like this:
#     function get_newos() {
#         local HASH=""
#         local ISO=""
#         local URL=""
#
#         validate_release "releases_newos"
#         ISO="newos-${RELEASE}-amd64.iso"
#         URL="https://www.newos.org/download/${ISO}"
#         web_get "${URL}" "${VM_PATH}"
#         web_get "${URL}/SHA256SUMS" "${VM_PATH}"
#         HASH=$(cat "${VM_PATH}/SHA256SUMS" | cut -d' ' -f1)
#         check_hash "${ISO}" "${HASH}"
#         make_vm_config "${ISO}"
#     }
#  6. Add new OS to the argument parser at the bottom of the script

function cleanup() {
  if [ -n "$(jobs -p)" ]; then
    kill "$(jobs -p)"
  fi
}

function pretty_name() {
  local SIMPLE_NAME=""
  local PRETTY_NAME=""
  SIMPLE_NAME="${1}"
  case ${SIMPLE_NAME} in
    alma)               PRETTY_NAME="Alma Linux";;
    alpine)             PRETTY_NAME="Alpine Linux";;
    android)            PRETTY_NAME="Android x86";;
    archlinux)          PRETTY_NAME="Arch Linux";;
    arcolinux)          PRETTY_NAME="Arco Linux";;
    cachyos)            PRETTY_NAME="CachyOS";;
    elementary)         PRETTY_NAME="elementary OS";;
    freebsd)            PRETTY_NAME="FreeBSD";;
    gentoo)             PRETTY_NAME="Gentoo";;
    garuda)             PRETTY_NAME="Garuda Linux";;
    haiku)              PRETTY_NAME="Haiku";;
    kdeneon)            PRETTY_NAME="KDE Neon";;
    kolibrios)          PRETTY_NAME="KolibriOS";;
    linuxmint-cinnamon) PRETTY_NAME="Linux Mint Cinnamon";;
    linuxmint-mate)     PRETTY_NAME="Linux Mint MATE";;
    linuxmint-xfce)     PRETTY_NAME="Linux Mint XFCE";;
    manjaro-xfce)       PRETTY_NAME="Manjaro XFCE";;
    manjaro-kde)        PRETTY_NAME="Manjaro KDE";;
    manjaro-gnome)      PRETTY_NAME="Manjaro Gnome";;
    manjaro-budgie)     PRETTY_NAME="Manjaro Budgie";;
    manjaro-cinnamon)   PRETTY_NAME="Manjaro Cinnamon";;
    manjaro-deepin)     PRETTY_NAME="Manjaro Deepin";;
    manjaro-i3)         PRETTY_NAME="Manjaro i3";;
    manjaro-mate)       PRETTY_NAME="Manjaro MATE";;
    mxlinux-xfce)       PRETTY_NAME="MX Linux XFCE";;
    mxlinux-kde)        PRETTY_NAME="MX Linux KDE";;
    mxlinux-fluxbox)    PRETTY_NAME="MX Linux Fluxbox";;
    nixos-gnome)        PRETTY_NAME="NixOS Gnome";;
    nixos-plasma5)      PRETTY_NAME="NixOS KDE";;
    nixos-minimal)      PRETTY_NAME="NixOS Minimal";;
    macos)              PRETTY_NAME="macOS";;
    openbsd)            PRETTY_NAME="OpenBSD";;
    opensuse)           PRETTY_NAME="openSUSE";;
    oraclelinux)        PRETTY_NAME="Oracle Linux";;
    popos)              PRETTY_NAME="Pop!_OS";;
    regolith)           PRETTY_NAME="Regolith Linux";;
    rockylinux)         PRETTY_NAME="Rocky Linux";;
    ubuntu-budgie)      PRETTY_NAME="Ubuntu Budgie";;
    ubuntu-kylin)       PRETTY_NAME="Ubuntu Kylin";;
    ubuntu-mate)        PRETTY_NAME="Ubuntu MATE";;
    ubuntu-studio)      PRETTY_NAME="Ubuntu Studio";;
    void)               PRETTY_NAME="Void Linux";;
    zorin)              PRETTY_NAME="Zorin OS";;
    *)                  PRETTY_NAME="${SIMPLE_NAME^}";;
  esac
  echo "${PRETTY_NAME}"
}

function validate_release() {
  local DISPLAY_NAME=""
  local RELEASE_GENERATOR="${1}"
  local RELEASES=""

  DISPLAY_NAME="$(pretty_name "${OS}")"
  RELEASES=$(${RELEASE_GENERATOR})
  if [[ "${RELEASES}" != *"${RELEASE}"* ]]; then
      echo "ERROR! ${DISPLAY_NAME} ${RELEASE} is not a supported release."
      echo "${RELEASES}"
      exit 1
  fi
}

function list_json() {
  # Reference: https://stackoverflow.com/a/67359273
  list_csv | jq -R 'split(",") as $h|reduce inputs as $in ([]; . += [$in|split(",")|. as $a|reduce range(0,length) as $i ({};.[$h[$i]]=$a[$i])])'
  exit 0
}

function list_csv() {
  local DISPLAY_NAME
  local DOWNLOADER
  local FUNC
  local OPTION
  local OS
  local PNG
  local RELEASE
  local SVG
  local ZS=""
  local DL=""

# check if we have a zsync installed somewhere
  ZS="$(which zsync)"
  if  [ -x "${ZS}" ]; then
    DL="zsync"
  else
    DL="wget"
  fi
  echo "Display Name,OS,Release,Option,Downloader,PNG,SVG"
  for OS in $(os_support); do
    DISPLAY_NAME="$(pretty_name "${OS}")"
    if [[ "${OS}" == *"ubuntu"* ]]; then
      FUNC="ubuntu"
    elif [[ "${OS}" == *"linuxmint"* ]]; then
      FUNC="linuxmint"
    elif [[ "${OS}" == *"manjaro"* ]]; then
      FUNC="manjaro"
    elif [[ "${OS}" == *"mxlinux"* ]]; then
      FUNC="mxlinux"
    elif [[ "${OS}" == *"nixos"* ]]; then
      FUNC="nixos"
    else
      FUNC="${OS}"
    fi
    PNG="https://quickemu-project.github.io/quickemu-icons/png/${FUNC}/${FUNC}-quickemu-white-pinkbg.png"
    SVG="https://quickemu-project.github.io/quickemu-icons/svg/${FUNC}/${FUNC}-quickemu-white-pinkbg.svg"


    for RELEASE in $("releases_${FUNC}"); do
      if [ "${OS}" == "macos" ]; then
        DOWNLOADER="macrecovery"
      elif [ "${OS}" == "ubuntu" ] && [ "${RELEASE}" == "canary" ]; then
        DOWNLOADER="${DL}"
      elif [[ "${OS}" == *"ubuntu"* ]] && [ "${RELEASE}" == "devel" ]; then
        DOWNLOADER="${DL}"
      elif [ "${OS}" == "cachyos" ]; then
        DOWNLOADER="${DL}"
      elif [ "${OS}" == "garuda" ]; then
        DOWNLOADER="${DL}"
      elif [ "${OS}" == "gentoo" ]; then
        DOWNLOADER="${DL}"
      elif [[ "${OS}" == *"kdeneon"* ]]; then
        DOWNLOADER="${DL}"
      else
        DOWNLOADER="wget"
      fi

      if [ "${OS}" == "windows" ]; then
        for OPTION in "${LANGS[@]}"; do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      elif [ "${OS}" == "popos" ]; then
        for OPTION in intel nvidia; do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      elif [ "${OS}" == "debian" ]; then
        for OPTION in standard nonfree; do
         echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      elif [ "${OS}" == "alma" ]; then
        for OPTION in minimal dvd; do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      else
        echo "${DISPLAY_NAME},${OS},${RELEASE},,${DOWNLOADER},${PNG},${SVG}"
      fi
    done
  done
  exit 0
}

function os_support() {
    echo alma \
    alpine \
    android \
    archlinux \
    arcolinux \
    cachyos \
    debian \
    elementary \
    freebsd \
    fedora \
    garuda \
    gentoo \
    haiku \
    kali \
    kdeneon \
    kolibrios \
    kubuntu \
    linuxmint-cinnamon \
    linuxmint-mate \
    linuxmint-xfce \
    manjaro-xfce \
    manjaro-kde \
    manjaro-gnome \
    manjaro-budgie \
    manjaro-cinnamon \
    manjaro-deepin \
    manjaro-i3 \
    manjaro-mate \
    mxlinux-xfce \
    mxlinux-kde \
    mxlinux-fluxbox \
    nixos-gnome \
    nixos-plasma5 \
    nixos-minimal \
    lubuntu \
    macos \
    openbsd \
    opensuse \
    oraclelinux \
    popos \
    regolith \
    rockylinux \
    solus \
    tails \
    ubuntu \
    ubuntu-budgie \
    ubuntu-kylin \
    ubuntu-mate \
    ubuntu-studio \
    void \
    windows \
    xubuntu \
    zorin
}

function releases_alma() {
    # consider flavours for boot and dvd as well as
    echo 8.4 \
    8.5
}

function releases_alpine() {
    echo latest \
    3.12 \
    3.13 \
    3.14 \
    3.15
}

function releases_android() {
  echo 9.0 \
  8.1 \
  7.1 \
  6.0 \
  5.1 \
  4.4 \
  4.0 \
  2.2
}

function releases_archlinux() {
    echo latest
}

function releases_arcolinux() {
    echo latest
}

# later refactor these DE variants like languages and avoid the arch ?
# all these are available with a "nonfree" option too
function releases_debian() {
    echo cinnamon \
    gnome \
    kde \
    lxde \
    lxqt \
    mate \
    standard \
    xfce
}

function releases_cachyos() {
    echo 2022.01.09
}

function releases_elementary() {
    echo 6.1
}

function releases_freebsd(){
    echo 12.2 \
    13.0
}

function releases_fedora(){
    echo 33 \
    34 \
    35
}

function releases_gentoo(){
    echo latest
}

function releases_garuda() {
    echo bspwm \
    dr460nized \
    dr460nized-blackarch \
    dr460nized-gaming \
    gnome \
    i3 \
    kde-barebones \
    lxqt-kwin \
    qtile \
    sway \
    wayfire \
    xfce \
    mate \
    cinnamon
}

function releases_haiku() {
    echo r1beta3-x86_64 \
        r1beta3-x86_gcc2h
}

function releases_kali() {
    echo latest \
    weekly
}

function releases_kdeneon() {
    echo user \
    testing \
    unstable \
    developer
}

function releases_kolibrios() {
    echo latest
}

function releases_linuxmint(){
    echo 20.2
}

function releases_mxlinux(){
    echo 21
}

function releases_nixos(){
    echo 21.05 \
    21.11
}

function releases_openbsd(){
    echo 7.0
}

function releases_opensuse(){
    echo 15.0 \
    15.1 \
    15.2 \
    15.3 \
    microos \
    tumbleweed
}

function releases_oraclelinux() {
    echo 8.5 \
    8.4 \
    8.3 \
    8.2 \
    7.9 \
    7.8 \
    7.7
}

function releases_macos() {
    echo high-sierra \
    mojave \
    catalina \
    big-sur \
    monterey
}

function releases_manjaro() {
    case ${OS} in
    *xfce|*kde|*gnome) echo full \
    minimal \
    minimal-lts;;
    *budgie|*cinnamon|*deepin|*i3|*mate) echo full \
    minimal;;
    esac
}

function releases_popos() {
    echo 20.04 \
    21.04 \
    21.10
}

function releases_regolith() {
    echo 1.6.0_hirsute \
    1.6.0_focal \
    2.0.0_impish \
    2.0.0_hirsute
}


function releases_rockylinux() {
    echo 8.5 \
    8.4 \
    8.3 \
    8.2 \
    8.1 \
    8.0
}

function releases_solus() {
    echo 4.3-budgie \
    4.3-gnome \
    4.3-mate \
    4.3-plasma
}

function releases_tails() {
    echo stable
}

function releases_ubuntu() {
    echo bionic \
    focal \
    hirsute \
    impish \
    devel \
    canary
}

function releases_void() {
    echo base \
    musl \
    xfce \
    xfce-musl
}

function languages_windows() {
    LANGS=(Arabic
    "Brazilian Portuguese"
    Bulgarian
    "Chinese (Simplified)"
    "Chinese (Traditional)"
    Croatian
    Czech
    Danish
    Dutch
    English
    "English International"
    Estonian
    Finnish
    French
    "French Canadian"
    German
    Greek
    Hebrew
    Hungarian
    Italian
    Japanese
    Korean
    Latvian
    Lithuanian
    Norwegian
    Polish
    Portuguese
    Romanian
    Russian
    "Serbian Latin"
    Slovak
    Slovenian
    Spanish
    "Spanish (Mexico)"
    Swedish
    Thai
    Turkish
    Ukrainian)
}


function releases_windows() {
    echo 8 \
    10 \
    11
}

function releases_zorin() {
    echo 16core64 \
    15lite64 \
    15lite32 \
    15education64 \
    15edulite64 \
    15edulite32
}

function check_hash() {
    local iso=""
    local hash=""
    local hash_algo=""
    iso="${VM_PATH}/${1}"
    hash="${2}"

    # Guess the hash algorithm by the hash length
    case ${#hash} in
      32) hash_algo=md5sum;;
      40) hash_algo=sha1sum;;
      64) hash_algo=sha256sum;;
      128) hash_algo=sha512sum;;
       *) echo "WARNING! Can't guess hash algorithm, not checking ${iso} hash."
          return;;
    esac

    echo -n "Checking ${iso} with ${hash_algo}... "
    if ! echo "${hash} ${iso}" | ${hash_algo} --check --status; then
        echo "ERROR!"
        echo "${iso} doesn't match ${hash}. Try running 'quickget' again."
        exit 1
    else
        echo "Good!"
    fi
}

function copy_local(){
  case $OS in
    windows)
      echo "${OS} not (yet?)  supported for local isos" ;;
    macos)
      # echo "${OS} not (yet?)  supported for local isos" ;;
      if [ -n "${ISODIR}" ]; then
      for macfile in RecoveryImage.dmg RecoveryImage.chunklist
      do
        find "${ISODIR}" -type f -name "${macfile}" -exec cp -pv \{\} "$DIR"/ \;
      done
      fi;;
    *)
      if [ -n "${ISODIR}" ]; then
        # use supplied filename or default to original distro ISO name
          if [ -z "${LOCALISO}" ]; then
            LOCALISO=${FILE}
          fi
          LOCALFILE=$(find "${ISODIR}" -type f -name "${LOCALISO}" -print -quit )
          if [ -f "${DIR}/${FILE}" ]; then
            echo "ERROR! File Exists - not copying over local file"
            echo "Move it out of the way to replace it with a local file"
            exit 1
          else
            cp -pv "${LOCALFILE}" "${DIR}"/"${FILE}"
          # if ! ; then echo ERROR! Failed to copy ${LOCALFILE}" to ${DIR}/${FILE}"
          fi
        fi
      esac
}

function web_get() {
    local DIR="${2}"
    local FILE=""
    local LOCALFILE=""
    local URL="${1}"

    if [ -n "${3}" ]; then
        FILE="${3}"
    else
        FILE="${URL##*/}"
    fi

    if ! mkdir -p "${DIR}" 2>/dev/null; then
      echo "ERROR! Unable to create directory ${DIR}"
      exit 1
    fi

    if [ -n "${LOCALISO}" ] || [ -n "${ISODIR}" ] ; then
    copy_local
    # you only get one shot
    LOCALISO=""
    ISODIR=""
    fi


    if command -v aria2c > /dev/null; then
        if ! aria2c -x16 --continue=true --summary-interval=0 --download-result=hide --console-log-level=error "${URL}" -o "${DIR}/${FILE}"; then
          echo #Necessary as aria2c in suppressed mode doesnot have new lines
          echo "ERROR! Failed to download ${URL}. Try running 'quickget' again."
          exit 1
        fi
        echo #Necessary as aria2c in suppressed mode doesnot have new lines
    else
        if ! wget --quiet --continue --show-progress --progress=bar:force:noscroll "${URL}" -O "${DIR}/${FILE}"; then
          echo "ERROR! Failed to download ${URL}. Try running 'quickget' again."
          exit 1
        fi
    fi

}

function zsync_get() {
    local DIR="${2}"
    local FILE=""
    local LOCALFILE=""
    local OUT=""
    local URL="${1}"
    FILE="${URL##*/}"
    local ZS=""

# check if we have a zsync installed somewhere
  ZS="$(which zsync)"
    if  [ -x "${ZS}" ]; then
      if [ -n "${3}" ]; then
          OUT="${3}"
      else
          OUT="${FILE}"
      fi

      if ! mkdir -p "${DIR}" 2>/dev/null; then
        echo "ERROR! Unable to create directory ${DIR}"
        exit 1
      fi

    if [ -n "${LOCALISO}" ] || [ -n "${ISODIR}" ] ; then
    copy_local
    # you only get one shot
    LOCALISO=""
    ISODIR=""
    fi

      if ! zsync "${URL}.zsync" -i "${DIR}/${OUT}" -o "${DIR}/${OUT}" 2>/dev/null; then
          echo "ERROR! Failed to download ${URL}.zsync"
          exit 1
      fi

      if [ -e "${DIR}/${OUT}.zs-old" ]; then
          rm "${DIR}/${OUT}.zs-old"
      fi
    else
      echo "INFO: zsync not found, falling back to wget"
      web_get "${ISO}" "${DIR}"
    fi
}

function start_vm_info() {
    echo
    echo "To start your ${OS} ${RELEASE} virtual machine run:"
    echo "    quickemu --vm ${OS}-${RELEASE}.conf"
    echo
    exit 0
}

function make_vm_config() {
    local IMAGE_FILE=""
    local ISO_FILE=""
    local IMAGE_TYPE=""
    local GUEST=""
    local SEC_BOOT=""

    IMAGE_FILE="${1}"
    ISO_FILE="${2}"
    case "${OS}" in
        freebsd )
            GUEST="freebsd"
            IMAGE_TYPE="iso";;
        haiku)
            GUEST="haiku"
            IMAGE_TYPE="iso";;
        kolibrios)
            GUEST="kolibrios"
            IMAGE_TYPE="iso";;
        openbsd )
            GUEST="openbsd"
            IMAGE_TYPE="iso";;
        macos )
            GUEST="macos"
            IMAGE_TYPE="img";;
        windows )
            GUEST="windows"
            IMAGE_TYPE="iso";;
        *)
            GUEST="linux"
            IMAGE_TYPE="iso";;
    esac

    if [ -n "${ISOTYPE}" ]; then
        RELEASE=${RELEASE}-${ISOTYPE}
    fi

    if [ ! -e "${OS}-${RELEASE}.conf" ]; then
        echo "Making VM configuration for ${OS}-${RELEASE}..."
        cat << EOF > "${OS}-${RELEASE}.conf"
guest_os="${GUEST}"
disk_img="${VM_PATH}/disk.qcow2"
${IMAGE_TYPE}="${VM_PATH}/${IMAGE_FILE}"
EOF
        if [ -n "${ISO_FILE}" ]; then
            echo "fixed_iso=\"${VM_PATH}/${ISO_FILE}\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "alma"  ] && [ "${ISOTYPE}" == "dvd" ]; then
            echo "disk_size=\"32G\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "kolibrios" ]; then
            echo "boot=\"legacy\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "openbsd" ]; then
            echo "boot=\"legacy\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "tails" ]; then
            echo "boot=\"legacy\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "macos" ]; then
            echo "macos_release=\"${RELEASE}\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "cachyos"  ]; then
            echo "disk_size=\"32G\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "garuda"  ]; then
            echo "disk_size=\"32G\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "haiku" ]; then
            echo "boot=\"legacy\"" >> "${OS}-${RELEASE}.conf"
            echo "disk_size=\"32G\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "oraclelinux"  ]; then
            echo "disk_size=\"20G\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "void"  ]; then
            echo "disk_size=\"20G\"" >> "${OS}-${RELEASE}.conf"
        fi

        if [ "${OS}" == "zorin"  ]; then
            case  ${RELEASE} in
              15education64|15edulite64|15edulite32)
                echo "disk_size=\"32G\"" >> "${OS}-${RELEASE}.conf";;
            esac
        fi

        # Enable TPM for Windows 11
        if [ "${OS}" == "windows" ] && [ "${RELEASE}" -ge 11 ]; then
            echo "tpm=\"on\"" >> "${OS}-${RELEASE}.conf"
            # Only force SecureBoot on for non-Debian/Ubuntu distros.
            if [ -e "/usr/share/OVMF/OVMF_CODE_4M.fd" ] && [ -e "/usr/share/OVMF/OVMF_VARS_4M.fd" ]; then
              SEC_BOOT="off"
            else
              SEC_BOOT="on"
            fi
            echo "secureboot=\"${SEC_BOOT}\"" >> "${OS}-${RELEASE}.conf"
        fi
    fi
    start_vm_info
}

function get_android() {
  local HASH=""
  local ISO=""
  local URL=""

  validate_release "releases_android"
  fosshubVersionInfo=$(wget -O - -q "https://www.fosshub.com/Android-x86-old.html" | grep "var settings =")
  version="android-x86-${RELEASE}"
  releaseJson=$(echo "${fosshubVersionInfo:16}" | jq --arg ver "${version}" 'first(.pool.f[] | select((.n | startswith($ver)) and (.n | endswith(".iso"))))')

  HASH=$(echo "${releaseJson}" | jq -r .hash.sha256)
  ISO=$(echo "${releaseJson}" | jq -r .n)

  baseurl="https://mirrors.gigenet.com/OSDN/android-x86/"

  releaseFolders=$(wget -q -O - ${baseurl} | grep -o -E '[0-9]{5}' | uniq)
  for item in $releaseFolders; do
    file=$(wget -O - -q "${baseurl}${item}" | grep "${ISO}")
    if [[ $file != "" ]]; then
      URL="${baseurl}${item}/${ISO}"
      break
    fi
  done
  web_get "${URL}" "${VM_PATH}"
  check_hash "${ISO}" "${HASH}"
  make_vm_config "${ISO}"
}

function get_alma() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""
    #local isotype=""

    validate_release "releases_alma"

    ISOTYPE="minimal" # boot is a step too far for now - needs setting install source to mirror tree ... nope
    if [ -n "${1}" ]; then
      ISOTYPE="${1}"
    fi


    # The mirror url returns 10 or so local mirrors with some kind or RR rotation/load balancing
    # We'll just grab the first

    URL=$(wget -qq -O- "https://mirrors.almalinux.org/isos/x86_64/${RELEASE}.html" | awk -F"<li>|</li>" '{for(i=2;i<=NF;i+=2) {print $i}}' RS=""  |grep href|cut -d\" -f2|head -1)

    #VM_PATH="${VM_PATH}"-${ISOTYPE}
    ISO=AlmaLinux-${RELEASE}-x86_64-${ISOTYPE}.iso
    HASH="$(wget -q -O- "${URL}/CHECKSUM" | grep \(${ISO} | cut -d\   -f4)"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_alpine() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""
    local BRANCH=""

    validate_release "releases_alpine"
    if [[ "${RELEASE}" == "latest" ]]; then
      BRANCH="latest-stable"
    else
      BRANCH="v${RELEASE}"
    fi
    MANIFESTURL="https://dl-cdn.alpinelinux.org/alpine/${BRANCH}/releases/x86_64/latest-releases.yaml"
    VERSION=$(wget -qO- "${MANIFESTURL}" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'version:' | awk '{print $2}')
    ISO="alpine-virt-${VERSION}-x86_64.iso"
    URL="https://dl-cdn.alpinelinux.org/alpine/${BRANCH}/releases/x86_64/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    HASH=$(wget -qO- "${MANIFESTURL}" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'sha256:' | awk '{print $2}')
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_archlinux() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""

    validate_release "releases_archlinux"
    VERSION=$(wget -q -O- 'https://archlinux.org/releng/releases/json/' | jq '.latest_version' | cut -d "\"" -f 2)
    URL="https://mirror.rackspace.com/archlinux/iso/${VERSION}"
    ISO="archlinux-${VERSION}-x86_64.iso"
    HASH=$(wget -q -O- 'https://archlinux.org/releng/releases/json/' | jq '.releases[0].sha1_sum' | cut -d "\"" -f 2)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_arcolinux() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""

    validate_release "releases_arcolinux"
    VERSION=$(wget -q -O- 'https://ant.seedhost.eu/arcolinux/.quick/info' | cut -d " " -f 2)
    URL="https://ant.seedhost.eu/arcolinux/.quick/"
    ISO="arcolinuxl-${VERSION}-x86_64.iso"
    HASH=$(wget -q -O- 'https://ant.seedhost.eu/arcolinux/.quick/arcolinuxl-'${VERSION}'-x86_64.iso.sha1' | cut -d " " -f 1)
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}


function get_cachyos() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""

    validate_release "releases_cachyos"
    #ISO="cachyos-cli-${RELEASE}-x86_64.iso"
    ISO="cachyos-${RELEASE}-x86_64.iso"
    URL="https://mirror.cachyos.org/ISO"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function get_debian() {
    local HASH=""
    local ISO=""
    local URL=""
    local HASHLINE=""
    local FREEDOM=""


    validate_release "releases_debian"

    if [ "${1}" == "nonfree" ]; then
      RELEASE="${RELEASE}+nonfree"
    fi
    case $RELEASE in
      *+nonfree)  URL="http://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/amd64/iso-hybrid" ;;
      *)          URL="https://cdimage.debian.org/debian-cd/current-live/amd64/iso-hybrid";;
    esac


    HASHLINE=$(wget -q -O- ${URL}/SHA512SUMS |grep ${RELEASE}.iso)
    ISO="$(echo ${HASHLINE} | awk '{print $NF}' )"
    HASH=$(echo ${HASHLINE} | cut -d\  -f1)

    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_elementary() {
    local ISO=""
    local URL=""
    local B66tim=""
    local isotag="20211218-rc"

    validate_release "releases_elementary"
    B66tim=$(date +%s | base64 )
    ISO="elementaryos-${RELEASE}-stable.${isotag}.iso"
    # TODO:  derive region from geoIP
    URL="https://ams3.dl.elementary.io/download/${B66tim}=/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function get_freebsd() {
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_freebsd"
    ISO="FreeBSD-${RELEASE}-RELEASE-amd64-dvd1.iso"
    HASH=$(wget -q -O- "https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}/CHECKSUM.SHA512-FreeBSD-${RELEASE}-RELEASE-amd64" | grep '('"${ISO}"')' | cut -d' ' -f4)
    URL="https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_fedora() {
    local FEDORA_RELEASE=""
    local FEDORA_VERSIONS=""
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION_NUM=""

    validate_release "releases_fedora"

    FEDORA_VERSIONS=$(wget -q -O- "https://getfedora.org/releases.json" | jq '.[] | select((.variant=="Workstation" or .variant=="Spins") and .arch=="x86_64")')
    if [[ "${RELEASE}" == *"beta"* ]]; then
        VERSION_NUM=${RELEASE%"_beta"}
        FEDORA_RELEASE=$(echo "${FEDORA_VERSIONS}" | jq -c '. | select(.version | contains("Beta"))' | jq '. | select(.variant=="Workstation")')
        ISO="Fedora-Workstation-Live-x86_64-${VERSION_NUM}_Beta-1.2.iso"
    else
        FEDORA_RELEASE=$(echo "${FEDORA_VERSIONS}" | jq '. | select(.variant=="Workstation" and .version=="'${RELEASE}'")')
        ISO="Fedora-Workstation-Live-x86_64-${RELEASE}-1.2.iso"
    fi

    URL=$(echo "${FEDORA_RELEASE}" | jq -r '.link')
    HASH=$(echo "${FEDORA_RELEASE}" | jq -r '.sha256')
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_gentoo() {
    local HASH=""
    local ISO=""
    local URL=""
    local LOCAT=""
    local INSTALLMIN=""

    validate_release "releases_gentoo"
    eval $( wget  -O/tmp/gentoolatest https://bouncer.gentoo.org/fetch/root/all/releases/amd64/autobuilds/${RELEASE}-iso.txt 2>&1 |grep Location | awk '{print "LOCAT="$2}' )
    LOCAT=$(dirname ${LOCAT})
    eval $( awk '/admincd-amd64/ {print "ADMIN="$1}; /install-amd64-minimal/ {print "INSTALLMIN="$1}' /tmp/gentoolatest )
    URL="${LOCAT}/${INSTALLMIN}"
    ISO=$(basename "${INSTALLMIN}" )


    web_get "${URL}" "${VM_PATH}"
    HASH=$(wget -q -O- ${LOCAT}/${INSTALLMIN}.DIGESTS|grep -e iso|grep  -v -e CONT -e catalyst|cut -d\  -f1)
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_kali() {
    local HASH=""
    local ISO=""
    local URL=""
    local SUBDIR=""
    validate_release "releases_kali"

    if [[ "${RELEASE}" == "latest" ]]; then
        SUBDIR="current"
    else
        SUBDIR="kali-weekly"
    fi

    ISO=$(wget -q -O- "https://cdimage.kali.org/${SUBDIR}/?C=M;O=D" |grep -o ">kali-linux-.*-installer-amd64.iso"|head -n 1|cut -c 2-)
    HASH=$(wget -q -O- "https://cdimage.kali.org/${SUBDIR}/SHA256SUMS" | grep "${ISO}" | cut -d' ' -f1)
    URL="https://cdimage.kali.org/${SUBDIR}/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_kdeneon() {
    local ISO=""
    local URL=""

    validate_release "releases_kdeneon"
    ISO="neon-${RELEASE}-current.iso"
    # Get the URL of the mirror closest to the user's location
    URL=$(wget -q -O- "https://files.kde.org/neon/images/${RELEASE}/current/neon-${RELEASE}-current.iso.zsync.mirrorlist" | \
          grep "neon-${RELEASE}-current.iso.zsync" | grep '>1.<' | cut -d\" -f 6 | sed 's/https/http/g' | xargs dirname)
    zsync_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "$(wget -q -O- "https://files.kde.org/neon/images/${RELEASE}/current/neon-${RELEASE}-current.sha256sum" | cut -d' ' -f1)"
    make_vm_config "${ISO}"
}

function get_kolibrios() {
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_kolibrios"
    #URL="https://builds.kolibrios.org/eng/${RELEASE}.7z"
    ISO="kolibri.iso"
    URL="https://builds.kolibrios.org/eng/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    #7z e "${VM_PATH}/${RELEASE}.7z" "kolibri.iso"
    #ISO="kolibrios-${RELEASE}.iso"
    #mv "kolibri.iso" "${VM_PATH}/${ISO}"
    #rm "${VM_PATH}/${RELEASE}.7z"
    make_vm_config "${ISO}"
}

function get_linuxmint() {
    local FLAVOR=""
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_linuxmint"
    FLAVOR=$(echo "${OS}" | cut -d'-' -f2)
    ISO="linuxmint-${RELEASE}-${FLAVOR}-64bit.iso"
    HASH=$(wget -q -O- "https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f1)
    URL="https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"

}

function get_manjaro() {
    local FLAVOR=""
    local MANIFESTURL=""
#    local ISOKEY=""
    local HASHKEY=""
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_manjaro"
    FLAVOR=$(echo "${OS}" | cut -d'-' -f2)
    case ${FLAVOR} in
      xfce|kde|gnome) BRANCH="official";;
      budgie|cinnamon|deepin|i3|mate) BRANCH="community";;
    esac

    if [[ ${RELEASE} == "full" ]]; then
      KEY="Download_x64 = "
      HASHKEY="Download_x64_Checksum = "
    elif [[ ${RELEASE} == "minimal" ]]; then
      KEY="Download_Minimal_x64 = "
      HASHKEY="Download_Minimal_x64_Checksum = "
    elif [[ ${RELEASE} == "minimal" ]]; then
      KEY="Download_Minimal_lts = "
      HASHKEY="Download_Minimal_x64_Checksum_lts = "
    fi

    MANIFESTURL="https://gitlab.manjaro.org/webpage/manjaro-homepage/-/raw/master/site/content/downloads/${BRANCH}/${FLAVOR}.md"
    URL="$(wget -qO- ${MANIFESTURL} | grep "${KEY}" | awk '{print $3}' | tr -d '"')"
    ISO="$(echo $URL | awk -F "/" '{print $6}')"
    HASH=$(wget -qO- ${MANIFESTURL} | grep "${HASHKEY}" | awk '{print $3}' | tr -d '"')
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_mxlinux() {
    local FLAVOR=""
    local HASH=""
    local ISO=""
    local URL=""
    local BASE_URL=""

    validate_release "releases_mxlinux"
    FLAVOR=$(echo "${OS}" | cut -d'-' -f2)

    if [[ "$FLAVOR" == "xfce" ]]; then
        ISO="MX-${RELEASE}_x64.iso"
        BASE_URL="https://sourceforge.net/projects/mx-linux/files/Final/Xfce/"
    elif [[ "$FLAVOR" == "kde" ]]; then
        ISO="MX-${RELEASE}_KDE_x64.iso"
        BASE_URL="https://sourceforge.net/projects/mx-linux/files/Final/KDE/"
    elif [[ "$FLAVOR" == "fluxbox" ]]; then
        ISO="MX-${RELEASE}_fluxbox_x64.iso"
        BASE_URL="https://sourceforge.net/projects/mx-linux/files/Final/Fluxbox/"
    fi

    URL="${BASE_URL}/${ISO}"
    web_get "${URL}" "${VM_PATH}"
    web_get "${URL}.sha256" "${VM_PATH}"
    HASH=$(cat "${VM_PATH}/${ISO}.sha256" | cut -d' ' -f1)
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_nixos() {
    local FLAVOR=""
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_nixos"
    FLAVOR=$(echo "${OS}" | cut -d'-' -f2)
    ISO="latest-nixos-${FLAVOR}-x86_64-linux.iso"
    URL="https://channels.nixos.org/nixos-${RELEASE}/${ISO}"
    HASH=$(wget -q -O- "https://channels.nixos.org/nixos-${RELEASE}/${ISO}.sha256" |  cut -d' ' -f1)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"

}
function get_openbsd() {
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_openbsd"
    ISO="install${RELEASE//\./}.iso"
    URL="https://cdn.openbsd.org/pub/OpenBSD/${RELEASE}/amd64/${ISO}"
    HASH=$(wget -q -O- "https://cdn.openbsd.org/pub/OpenBSD/${RELEASE}/amd64/SHA256" | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_void() {
    local HASH=""
    local ISO=""
    local URL=""
    local HASH_URL=""

    validate_release "releases_void"
    DATE=$(wget -q -O- "https://alpha.de.repo.voidlinux.org/live/current/sha256sum.txt" | awk 'NR == 1' |cut -d'.' -f1| cut -d'-' -f4)
    URL="https://alpha.de.repo.voidlinux.org/live/current"
    case ${RELEASE} in
      base)
        ISO="void-live-x86_64-${DATE}.iso";;
      musl)
        ISO="void-live-x86_64-musl-${DATE}.iso";;
      xfce)
        ISO="void-live-x86_64-${DATE}-xfce.iso";;
      xfce-musl)
        ISO="void-live-x86_64-musl-${DATE}-xfce.iso";;
    esac
    case ${RELEASE} in
      base)
        HASH="$(wget -q -O- "https://alpha.de.repo.voidlinux.org/live/current/sha256sum.txt" | grep "void-live-x86_64-${DATE}.iso" | cut -d' ' -f4)";;
      musl)
        HASH="$(wget -q -O- "https://alpha.de.repo.voidlinux.org/live/current/sha256sum.txt" | grep "void-live-x86_64-musl-${DATE}.iso" | cut -d' ' -f4)";;
      xfce)
        HASH="$(wget -q -O- "https://alpha.de.repo.voidlinux.org/live/current/sha256sum.txt" | grep "void-live-x86_64-${DATE}-xfce.iso" | cut -d' ' -f4)";;
      xfce-musl)
        HASH="$(wget -q -O- "https://alpha.de.repo.voidlinux.org/live/current/sha256sum.txt" | grep "void-live-x86_64-musl-${DATE}.iso" | cut -d' ' -f4)";;
    esac
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_zorin() {
    local ISO=""
    local URL=""

    validate_release "releases_zorin"
    # their redirector returns an href so we need to get that and parse out the iso
    URL=$(curl -s "https://zrn.co/${RELEASE}" |cut -d\" -f2)
    ISO=$(echo "${URL}"| awk -F\/ ' {print $NF}')
    web_get "${URL}" "${VM_PATH}"
    make_vm_config "${ISO}"
}

function get_rocky() {
    local HASH=""
    local ISO=""
    local URL=""

    local arch="x86_64"
    local baseurl="https://download.rockylinux.org/pub/rocky/${RELEASE}/isos/${arch}"

    validate_release "releases_rockylinux"
    ISO="Rocky-${RELEASE}-${arch}-${ISOTYPE}.iso"
    URL="${baseurl}/${ISO}"
    HASH=$(wget -q -O- "${baseurl}/CHECKSUM" | grep "SHA256 (${ISO})" | grep -E -i -w -o '[0-9a-z]{64}')

    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_solus() {
    local RELNUM=""
    local RELTYPE=""
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_solus"
    RELNUM=$(echo "${RELEASE}" | cut -d'-' -f1)
    RELTYPE=$(echo "${RELEASE}" | cut -d'-' -f2)
    case ${RELTYPE} in
      mate|gnome)
        RELTYPE=${RELTYPE^^};;
      *)
        RELTYPE=${RELTYPE^};;
    esac

    ISO="Solus-${RELNUM}-${RELTYPE}.iso"
    URL="https://mirrors.rit.edu/solus/images/${RELNUM}/${ISO}"
    HASH=$(wget -q -O- "${URL}.sha256sum" |  cut -d' ' -f1)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_opensuse() {
    local HASH=""
    local ISO=""
    local URL=""

    validate_release "releases_opensuse"
    if [ "${RELEASE}" == "tumbleweed" ]; then
        ISO="openSUSE-Tumbleweed-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/tumbleweed/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    elif [ "${RELEASE}" == "microos" ]; then
        ISO="openSUSE-MicroOS-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/tumbleweed/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    elif [ "$RELEASE" == 15.0 ] || [ "$RELEASE" == 15.1 ]; then
        ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64.iso"
        URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    else
        ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso/${ISO}"
        HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
    fi
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_oraclelinux() {
    local HASH=""
    local ISO=""
    local URL=""

    local arch="x86_64"

    validate_release "releases_oraclelinux"

    local majorver=${RELEASE::1}
    local minorver=${RELEASE:2:1}

    local baseurl="https://yum.oracle.com/ISOS/OracleLinux/OL${majorver}/u${minorver}/${arch}/"
    local hashurl="https://linux.oracle.com/security/gpg/checksum/OracleLinux-R${majorver}-U${minorver}-Server-x86_64.checksum"

    if [ "${majorver}" == "8" ]; then
        ISO="OracleLinux-R${majorver}-U${minorver}-${arch}-dvd.iso"
    else
        ISO="OracleLinux-R${majorver}-U${minorver}-Server-${arch}-dvd.iso"
    fi

    URL="${baseurl}/${ISO}"
    HASH=$(wget -q -O- "${hashurl}" | grep "${ISO}" | cut -d' ' -f1)

    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_macos() {
    local BOARD_ID=""
    local CWD=""
    local MACRECOVERY=""
    local MLB=""

    case ${RELEASE} in
        high-sierra)
            BOARD_ID="Mac-7BA5B2D9E42DDD94"
            MLB="00000000000J80300";;
        mojave)
            BOARD_ID="Mac-7BA5B2DFE22DDD8C"
            MLB="00000000000KXPG00";;
        catalina)
            BOARD_ID="Mac-CFF7D910A743CAAF"
            MLB="00000000000PHCD00";;
        big-sur)
            BOARD_ID="Mac-35C1E88140C3E6CF"
            MLB="00000000000000000";;
        monterey)
            BOARD_ID="Mac-06F11F11946D27C5"
            MLB="00000000000000000";;
        *) echo "ERROR! Unknown release: ${RELEASE}"
           releases_macos
           exit 1;;
    esac

    # Use a bundled macrecovery if possible
    CWD="$(dirname "${0}")"
    if [ -x "${CWD}/macrecovery" ]; then
        MACRECOVERY="${CWD}/macrecovery"
    elif [ -x /usr/bin/macrecovery ]; then
        MACRECOVERY="/usr/bin/macrecovery"
    else
        web_get "https://raw.githubusercontent.com/wimpysworld/quickemu/master/macrecovery" "${HOME}/.quickemu"
        MACRECOVERY="python3 ${HOME}/.quickemu/macrecovery"
    fi

    if [ -z "${MACRECOVERY}" ]; then
        echo "ERROR! Can not find a usable macrecovery."
        exit 1
    fi

    # Get firmware
    web_get "https://github.com/kholia/OSX-KVM/raw/master/OpenCore/OpenCore.qcow2" "${VM_PATH}"
    web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_CODE.fd" "${VM_PATH}"
    if [ ! -e "${VM_PATH}/OVMF_VARS-1024x768.fd" ]; then
        web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_VARS-1024x768.fd" "${VM_PATH}"
    fi

    if [ ! -e "${VM_PATH}/RecoveryImage.chunklist" ]; then
        echo "Downloading ${RELEASE}..."
        ${MACRECOVERY} \
            --board-id "${BOARD_ID}" \
            --mlb "${MLB}" \
            --basename RecoveryImage \
            --outdir "${VM_PATH}" \
            download
    fi

    if [ -e "${VM_PATH}/RecoveryImage.dmg" ] && [ ! -e "${VM_PATH}/RecoveryImage.img" ]; then
        echo "Converting RecoveryImage..."
        qemu-img convert "${VM_PATH}/RecoveryImage.dmg" -O raw "${VM_PATH}/RecoveryImage.img"
    fi

    make_vm_config RecoveryImage.img
}

function get_popos() {
    local DRIVER="intel"
    local HASH=""
    local ISO=""
    local URL=""

    if [ -n "${1}" ]; then
      DRIVER="${1}"
    fi

    validate_release "releases_popos"

    URL=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${DRIVER}" | jq ".url")
    URL="${URL//\"/}"
    ISO=$(echo "${URL}" | sed -e "s/.*\/\([^\/]*\)$/\1/")
    HASH=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${DRIVER}" | jq ".sha_sum")
    HASH="${HASH//\"/}"
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}


function get_regolith() {
    local HASH=""
    local ISO=""
    local URL=""
    local GHDL="https://github.com/regolith-linux/regolith-ubuntu-iso-builder/releases/download/"

    validate_release "releases_regolith"

    URL="${GHDL}"
    case ${RELEASE} in
      1.6.0_focal)
        URL="${URL}release-release-focal-focal_standard-1.6.0"
        HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1);;
      1.6.0_hirsute)
        URL="${URL}release-release-hirsute-hirsute_standard-1.6.0"
        HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1);;
      2.0.0_impish)
        URL="${URL}regolith-linux-2.0-impish-latest";;
      2.0.0_hirsute)
        URL="${URL}regolith-linux-2.0-hirsute-latest";;
    esac
    ISO="Regolith_${RELEASE}.iso"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    if [ -n "${HASH}" ]; then
      check_hash "${ISO}" "${HASH}"
    fi
    make_vm_config "${ISO}"
}

function get_tails() {
    validate_release "releases_tails"

    RELEASE_JSON_URL="https://tails.boum.org/install/v2/Tails/amd64/${RELEASE}/latest.json"
    RELEASE_JSON="$(wget -q -O- "$RELEASE_JSON_URL")"
    URL=$(echo "$RELEASE_JSON" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].url')
    HASH=$(echo "$RELEASE_JSON" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].sha256')
    ISO=$(echo "${URL}" | sed -e "s/.*\/\([^\/]*\)$/\1/")
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_ubuntu() {
    local DEVEL="daily-live"
    local ISO=""
    local HASH=""
    local PROJECT=""
    local URL=""

    case ${OS} in
      kubuntu|lubuntu|ubuntu|ubuntu-budgie|ubuntu-mate|xubuntu)
        PROJECT="${OS}";;
      ubuntu-kylin)
        PROJECT="ubuntukylin";;
      ubuntu-studio)
        PROJECT="ubuntustudio"
        DEVEL="dvd";;
      *) echo "ERROR! ${OS} is not a recognised Ubuntu flavour."
         exit 1;;
    esac

    if [ "${RELEASE}" == "canary" ] && [ "${OS}" != "ubuntu" ]; then
      echo "ERROR! Canary is currently only available for Ubuntu."
      exit 1
    else
      validate_release "releases_ubuntu"
    fi

    if [ "${RELEASE}" == "canary" ]; then
        DEVEL="daily-canary"
        URL="http://cdimage.ubuntu.com/${PROJECT}/${DEVEL}/current"
    elif [ "${RELEASE}" == "devel" ]; then
        URL="http://cdimage.ubuntu.com/${PROJECT}/${DEVEL}/current"
    elif [ "${PROJECT}" == "ubuntu" ]; then
        URL="http://releases.ubuntu.com/${RELEASE}"
    else
        URL="http://cdimage.ubuntu.com/${PROJECT}/releases/${RELEASE}/release"
    fi

    HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1)
    ISO=$(wget -q -O- "${URL}/SHA256SUMS" | grep 'desktop\|dvd' | grep amd64 | cut -d' ' -f2 | sed 's|*||g')
    if [ "${RELEASE}" == "canary" ] || [ "${RELEASE}" == "devel" ]; then
        zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-${RELEASE}.iso"
        make_vm_config "${OS}-${RELEASE}.iso"
    else
        web_get "${URL}/${ISO}" "${VM_PATH}"
        check_hash "${ISO}" "${HASH}"
        make_vm_config "${ISO}"
    fi
}

function get_garuda() {
    local HASH=""
    local ISO=""
    local URL=""
    local REL_TYPE=""
    local LATEST_URL=""
    local HASH_URL=""
    local GLDL="http://mirrors.fossho.st/garuda/iso"

    validate_release "releases_garuda"

    # Part of the path is different for a couple of community releases vs the supported garuda ones
    case ${RELEASE} in
      mate|cinnamon)
        REL_TYPE="community";;
      *)
        REL_TYPE="garuda";;
    esac

    # need to follow daily releases and use contents of SHA sums file
    # to derive the filename and date
    LATEST_URL="${GLDL}/latest/${REL_TYPE}/${RELEASE}/latest.iso.sha256"
    HASH_URL="$(wget -q -O- ${LATEST_URL})"
    ISO="$(echo ${HASH_URL} | awk '{print $NF}' )"
    HASH=$(echo "${HASH_URL}" | cut -d\  -f1)
    LDATE=$(echo "${ISO}" | awk -F'-' '{print $NF}' |cut -d'.' -f1) #
    URL="${GLDL}/${REL_TYPE}/${RELEASE}/${LDATE}"

    #web_get "${URL}/${ISO}" "${VM_PATH}"
    zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-${RELEASE}.iso"
    #if [ -n "${HASH}" ]; then
    #  check_hash "${ISO}" "${HASH}"
    #fi
    make_vm_config "${OS}-${RELEASE}.iso"
}

function get_haiku() {
    local ISO=""
    local URL=""
    local HASH=""

    validate_release "releases_haiku"

    ISO="haiku-${RELEASE}-anyboot.iso"
    URL="https://cdn.haiku-os.org/haiku-release/$(echo $RELEASE | awk -F '-' '{print $1}')/${ISO}"
    HASH=$(wget -q -O- ${URL}.sha256 | grep "${ISO}" | cut -d' ' -f4)
    web_get "${URL}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function unattended_windows() {
    cat << 'EOF' > "${1}"
<?xml version="1.0" encoding="utf-8"?>
<unattend xmlns="urn:schemas-microsoft-com:unattend"
  xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!--
       For documentation on components:
       https://docs.microsoft.com/en-us/windows-hardware/customize/desktop/unattend/
  -->
  <settings pass="offlineServicing">
    <component name="Microsoft-Windows-Shell-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <ComputerName>*</ComputerName>
    </component>
  </settings>

  <settings pass="generalize">
    <component name="Microsoft-Windows-PnPSysprep"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS">
      <PersistAllDeviceInstalls>true</PersistAllDeviceInstalls>
    </component>
  </settings>

  <settings pass="specialize">
    <component name="Microsoft-Windows-Security-SPP-UX"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <SkipAutoActivation>true</SkipAutoActivation>
    </component>
    <component name="Microsoft-Windows-Shell-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <ComputerName>*</ComputerName>
      <OEMInformation>
        <Manufacturer>Quickemu Project</Manufacturer>
        <Model>Quickemu</Model>
        <SupportHours>24/7</SupportHours>
        <SupportPhone></SupportPhone>
        <SupportProvider>Quickemu Project</SupportProvider>
        <SupportURL>https://github.com/quickemu-project/quickemu/issues</SupportURL>
      </OEMInformation>
      <OEMName>Quickemu Project</OEMName>
    </component>
    <component name="Microsoft-Windows-SQMApi"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <CEIPEnabled>0</CEIPEnabled>
    </component>
  </settings>

  <settings pass="windowsPE">
    <component name="Microsoft-Windows-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <Diagnostics>
        <OptIn>false</OptIn>
      </Diagnostics>
      <DiskConfiguration>
        <Disk wcm:action="add">
          <DiskID>0</DiskID>
          <WillWipeDisk>true</WillWipeDisk>
          <CreatePartitions>
            <!-- Windows RE Tools partition -->
            <CreatePartition wcm:action="add">
              <Order>1</Order>
              <Type>Primary</Type>
              <Size>256</Size>
            </CreatePartition>
            <!-- System partition (ESP) -->
            <CreatePartition wcm:action="add">
              <Order>2</Order>
              <Type>EFI</Type>
              <Size>128</Size>
            </CreatePartition>
            <!-- Microsoft reserved partition (MSR) -->
            <CreatePartition wcm:action="add">
              <Order>3</Order>
              <Type>MSR</Type>
              <Size>128</Size>
            </CreatePartition>
            <!-- Windows partition -->
            <CreatePartition wcm:action="add">
              <Order>4</Order>
              <Type>Primary</Type>
              <Extend>true</Extend>
            </CreatePartition>
          </CreatePartitions>
          <ModifyPartitions>
            <!-- Windows RE Tools partition -->
            <ModifyPartition wcm:action="add">
              <Order>1</Order>
              <PartitionID>1</PartitionID>
              <Label>WINRE</Label>
              <Format>NTFS</Format>
              <TypeID>DE94BBA4-06D1-4D40-A16A-BFD50179D6AC</TypeID>
            </ModifyPartition>
            <!-- System partition (ESP) -->
            <ModifyPartition wcm:action="add">
              <Order>2</Order>
              <PartitionID>2</PartitionID>
              <Label>System</Label>
              <Format>FAT32</Format>
            </ModifyPartition>
            <!-- MSR partition does not need to be modified -->
            <ModifyPartition wcm:action="add">
              <Order>3</Order>
              <PartitionID>3</PartitionID>
            </ModifyPartition>
            <!-- Windows partition -->
              <ModifyPartition wcm:action="add">
              <Order>4</Order>
              <PartitionID>4</PartitionID>
              <Label>Windows</Label>
              <Letter>C</Letter>
              <Format>NTFS</Format>
            </ModifyPartition>
          </ModifyPartitions>
        </Disk>
      </DiskConfiguration>
      <DynamicUpdate>
        <Enable>true</Enable>
        <WillShowUI>Never</WillShowUI>
      </DynamicUpdate>
      <ImageInstall>
        <OSImage>
          <InstallTo>
            <DiskID>0</DiskID>
            <PartitionID>4</PartitionID>
          </InstallTo>
          <InstallToAvailablePartition>false</InstallToAvailablePartition>
        </OSImage>
      </ImageInstall>
      <RunSynchronous>
        <RunSynchronousCommand wcm:action="add">
          <Order>1</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassCPUCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>2</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassRAMCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>3</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassSecureBootCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>4</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassTPMCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
      </RunSynchronous>
      <UpgradeData>
        <Upgrade>false</Upgrade>
        <WillShowUI>Never</WillShowUI>
      </UpgradeData>
      <UserData>
        <AcceptEula>true</AcceptEula>
        <ProductKey>
          <Key>VK7JG-NPHTM-C97JM-9MPGT-3V66T</Key>
          <WillShowUI>Never</WillShowUI>
        </ProductKey>
      </UserData>
    </component>

    <component name="Microsoft-Windows-PnpCustomizationsWinPE"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      processorArchitecture="amd64">
      <!--
           This makes the VirtIO drivers available to Windows, assuming that
           the VirtIO driver disk is available as drive E:
           https://github.com/virtio-win/virtio-win-pkg-scripts/blob/master/README.md
      -->
      <DriverPaths>
        <PathAndCredentials wcm:action="add" wcm:keyValue="1">
          <Path>E:\qemufwcfg\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="2">
          <Path>E:\vioinput\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="3">
          <Path>E:\vioscsi\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="4">
          <Path>E:\viostor\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="5">
          <Path>E:\vioserial\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="6">
          <Path>E:\qxldod\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="7">
          <Path>E:\amd64\w10</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="8">
          <Path>E:\viogpudo\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="9">
          <Path>E:\viorng\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="10">
          <Path>E:\NetKVM\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="11">
          <Path>E:\viofs\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="12">
          <Path>E:\Balloon\w10\amd64</Path>
        </PathAndCredentials>
      </DriverPaths>
    </component>
  </settings>

  <settings pass="oobeSystem">
    <component name="Microsoft-Windows-Shell-Setup"
      processorArchitecture="amd64"
      publicKeyToken="31bf3856ad364e35"
      language="neutral"
      versionScope="nonSxS"
      xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <OOBE>
        <HideEULAPage>true</HideEULAPage>
        <HideLocalAccountScreen>false</HideLocalAccountScreen>
        <HideOEMRegistrationScreen>true</HideOEMRegistrationScreen>
        <HideOnlineAccountScreens>false</HideOnlineAccountScreens>
        <HideWirelessSetupInOOBE>true</HideWirelessSetupInOOBE>
        <ProtectYourPC>3</ProtectYourPC>
        <SkipUserOOBE>false</SkipUserOOBE>
        <SkipMachineOOBE>false</SkipMachineOOBE>
        <VMModeOptimizations>
          <SkipWinREInitialization>true</SkipWinREInitialization>
        </VMModeOptimizations>
      </OOBE>
      <FirstLogonCommands>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i E:\guest-agent\qemu-ga-x86_64.msi /quiet /passive /qn</CommandLine>
          <Description>Install Virtio Guest Agent</Description>
          <Order>1</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\spice-webdavd-x64-latest.msi /quiet /passive /qn</CommandLine>
          <Description>Install spice-webdavd file sharing agent</Description>
          <Order>2</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\UsbDk_1.0.22_x64.msi /quiet /passive /qn</CommandLine>
          <Description>Install usbdk USB sharing agent</Description>
          <Order>3</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\spice-vdagent-x64-0.10.0.msi /quiet /passive /qn</CommandLine>
          <Description>Install spice-vdagent SPICE agent</Description>
          <Order>4</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>Cmd /c POWERCFG -H OFF</CommandLine>
          <Description>Disable Hibernation</Description>
          <Order>5</Order>
        </SynchronousCommand>
      </FirstLogonCommands>
    </component>
  </settings>
</unattend>
EOF
}

function dbg_windows() {
  local DEBUG=0
  if [ ${DEBUG} -eq 1 ]; then
    echo "${1}"
  fi
}

# Adapted from https://gist.github.com/hongkongkiwi/15a5bf16437315df256c118c163607cb
function get_windows() {
    local ARCH="x64"
    local INDEX=0
    local LANG_CODE="en"
    local LATEST_WINDOWS_VERSION=""
    local WINDOWS_NAME=""
    local VERSION_ID=""
    local EDITION_ID=""
    local LANGUAGE_ID=""
    local FILE_NAME=""
    local ARCH_ID=""
    local DOWNLOAD_INFO=""
    local DOWNLOAD_ID=""
    local DOWNLOAD_URL=""

    validate_release "releases_windows"

    # Ignore the most recent Windows 10 release for now.
    if [ "${RELEASE}" -eq 10 ]; then
      INDEX=0
    fi

    if [ "${RELEASE}" -eq 11 ]; then
      INDEX=0
    fi

    echo "Getting Windows ${RELEASE} URL..."
    WINDOWS_VERSIONS=$(wget -q -O- "https://tb.rg-adguard.net/php/get_version.php?type_id=1" | jq '.versions | sort_by(-(.version_id | tonumber))')
    dbg_windows "${WINDOWS_VERSIONS}"
    LATEST_WINDOWS_VERSION=$(echo "${WINDOWS_VERSIONS}" | jq -c 'map(select(.name | contains("Windows '${RELEASE}'")))['${INDEX}']')
    dbg_windows "${LATEST_WINDOWS_VERSION}"

    WINDOWS_NAME=$(echo "${LATEST_WINDOWS_VERSION}" | jq -r .name)
    dbg_windows "${WINDOWS_NAME}"
    VERSION_ID=$(echo "${LATEST_WINDOWS_VERSION}" | jq -r .version_id)
    dbg_windows "${VERSION_ID}"

    case ${RELEASE} in
        8) EDITION_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_edition.php?version_id=${VERSION_ID}&lang=name_${LANG_CODE}" | jq -r '.editions[] | select(.name_'${LANG_CODE}'=="Windows 8.1 Pro + Core").edition_id');;
        10|11) EDITION_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_edition.php?version_id=${VERSION_ID}&lang=name_${LANG_CODE}" | jq -r '.editions[] | select(.name_'${LANG_CODE}'=="Windows '${RELEASE}'").edition_id');;
    esac
    dbg_windows "${EDITION_ID}"

    LANGUAGE_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_language.php?edition_id=${EDITION_ID}&lang=name_${LANG_CODE}" | jq -r '.languages[] | select(.name_'${LANG_CODE}'=="'"${LANG_NAME}"'").language_id')
    dbg_windows "${LANGUAGE_ID}"
    ARCH_INFO=$(wget -q -O- "https://tb.rg-adguard.net/php/get_arch.php?language_id=${LANGUAGE_ID}")
    dbg_windows "${ARCH_INFO}"
    FILE_NAME=$(echo "${ARCH_INFO}" | jq -r '.archs[] | select(.name | contains("'${ARCH}'")).name')
    dbg_windows "${FILE_NAME}"
    ARCH_ID=$(echo "${ARCH_INFO}" | jq -r '.archs[] | select(.name | contains("'${ARCH}'")).arch_id')
    dbg_windows "${ARCH_ID}"
    DOWNLOAD_INFO=$(wget -q -O- "https://tb.rg-adguard.net/dl.php?fileName=${ARCH_ID}&lang=en")
    dbg_windows "${DOWNLOAD_INFO}"
    DOWNLOAD_SHA1=$(echo "${DOWNLOAD_INFO}" | sed -e 's/<[^>]*>//g' | grep -o -P '(?<=SHA1: ).*(?= expire)' | sed 's/Link//')
    dbg_windows "${DOWNLOAD_SHA1}"
    DOWNLOAD_ID=$(echo "${DOWNLOAD_INFO}" | grep -oP '(?<=https:\/\/tb\.rg-adguard\.net/dl\.php\?go=)[0-9a-z]+')
    dbg_windows "${DOWNLOAD_ID}"
    DOWNLOAD_URL="https://tb.rg-adguard.net/dl.php?go=${DOWNLOAD_ID}"
    dbg_windows "${DOWNLOAD_URL}"

    echo "Downloading ${WINDOWS_NAME}..."
    web_get "${DOWNLOAD_URL}" "${VM_PATH}" "${FILE_NAME}"

    # Windows 10 doesn't include a SHA1, so only check the integrity if the SHA1 is available.
    if [ -n "${DOWNLOAD_SHA1}" ]; then
      check_hash "${FILE_NAME}" "${DOWNLOAD_SHA1}"
    fi

    web_get "https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso" "${VM_PATH}"

    rm -f "${VM_PATH}/unattended.iso"
    case ${RELEASE} in
        10|11)
            echo "Making unattended.iso"
            mkdir -p "${VM_PATH}/unattended" 2>/dev/null
            web_get https://www.spice-space.org/download/windows/spice-webdavd/spice-webdavd-x64-latest.msi "${VM_PATH}/unattended"
            web_get https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.10.0/spice-vdagent-x64-0.10.0.msi "${VM_PATH}/unattended"
            web_get https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.22_x64.msi "${VM_PATH}/unattended"
            unattended_windows "${VM_PATH}/unattended/autounattend.xml"
            mkisofs -quiet -l -o "${VM_PATH}/unattended.iso" "${VM_PATH}/unattended/"
            ;;
    esac
    make_vm_config "${FILE_NAME}" "virtio-win.iso"
}
function usage() {
  echo
  echo "Usage"
  echo "  $0 [--isodir] [--localiso] [--list | --json] <OS> <Release> (<Option>)"
  echo
  echo If you omit parameters a list of supported OS options will be provided.
  echo If you omit a Release a list of supported releases for the selected OS will be  given.
  echo
  echo "You can also pass optional parameters"
  echo
  echo "  --list                  : print a csv list of supported guest"
  echo "  --json                  : print a json list of supported guest"
  echo "  --isodir                : base path beneath which to find local ISO copy
                                       if a matching file is found it will be copied to the VM directory"
  echo "  --localiso              : local ISO filename - defaults to target filename"
  echo "  --help                  : Print usage (this)"
  echo "  --version               : Print version"
  exit 1
}
trap cleanup EXIT

if ((BASH_VERSINFO[0] < 4))
then
  echo "Sorry, you need bash 4.0 or newer to run this script."
  exit 1
fi

LANGS=()
languages_windows

# handle parameters

# Take command line arguments
if [ $# -lt 1 ]; then
    usage
    exit 0
fi
    while [ $# -gt 0 ]; do
        case "${1}" in
          -isodir|--isodir)
            ISODIR="${2}"
            shift
            shift;;
          -localiso|--localiso)
            LOCALISO="${2}"
            shift
            shift;;
         -h|--h|-help|--help)
            usage
            exit 0;;
         -l|--l|-list|--list|list|list_csv)
            list_csv;;
          -j|--j|-json|--json|list_json)
            list_json;;
          -v|--v|-version|--version|version )
             whereIam=$(dirname "${BASH_SOURCE[0]}")
              quickemu_version=$( "${whereIam}"/quickemu --version)
              echo "Quickemu Version: ${quickemu_version}"
              exit 0;;
          -t|--t|-test|--test)
             echo "you are just testing
             ISODIR:  ${ISODIR}
             LOCALISO: ${LOCALISO}"
             ls -lh "${ISODIR}/${LOCALISO}"
             exit 0;;
          *)

if [ -n "${1}" ]; then
    OS="${1,,}"
else
    echo "ERROR! You must specify an operating system:"
    os_support
    exit 1
fi

if [ -n "${2}" ]; then
    RELEASE="${2,,}"
    VM_PATH="${OS}-${RELEASE}"

    if [ "${OS}" == "alma" ]; then
     if [ -n "${3}" ]; then
            ISOTYPE="${3,,}"
            ISOTYPES=(minimal dvd ) # boot) # a step too far
            if [[ ! ${ISOTYPES[*]} =~ ${ISOTYPE} ]]; then
                echo "iso ${ISOTYPE} is not supported:"
                for ISOTYPE in "${ISOTYPES[@]}"; do
                  echo "${ISOTYPE}"
                done
                exit 1
            fi
        else
            ISOTYPE="minimal"
        fi
        VM_PATH="${OS}-${RELEASE}-${ISOTYPE}"
        get_alma "${ISOTYPE}"
    elif [ "${OS}" == "alpine" ]; then
        get_alpine
    elif [ "${OS}" == "android" ]; then
        get_android
    elif [ "${OS}" == "archlinux" ]; then
        get_archlinux
    elif [ "${OS}" == "arcolinux" ]; then
        get_arcolinux
    elif [ "${OS}" == "void" ]; then
        get_void
    elif [ "${OS}" == "debian" ]; then
     if [ -n "${3}" ]; then
            FREEDOM="${3}"
            FREEDOMS=(standard nonfree)
            if [[ ! ${FREEDOMS[*]} =~ ${FREEDOM} ]]; then
                echo "ERROR! ${FREEDOM} is not a supported freedom:"
                for DRIVER in "${FREEDOMS[@]}"; do
                  echo "${FREEDOM}"
                done
                exit 1
            fi
        else
            FREEDOM="standard"
        fi
        VM_PATH="${OS}-${RELEASE}-${FREEDOM}"
        get_debian  "${FREEDOM}"
    elif [ "${OS}" == "elementary" ]; then
        get_elementary
    elif [ "${OS}" == "macos" ]; then
        get_macos
    elif [ "${OS}" == "freebsd" ]; then
        get_freebsd
    elif [ "${OS}" == "fedora" ]; then
        get_fedora
    elif [ "${OS}" == "garuda" ]; then
        get_garuda
    elif [ "${OS}" == "cachyos" ]; then
        get_cachyos
    elif [ "${OS}" == "gentoo" ]; then
        get_gentoo
    elif [ "${OS}" == "haiku" ]; then
        get_haiku
    elif [ "${OS}" == "kali" ]; then
        get_kali
    elif [ "${OS}" == "kdeneon" ]; then
        get_kdeneon
    elif [ "${OS}" == "kolibrios" ]; then
        get_kolibrios
    elif [[ "${OS}" == *"linuxmint-"* ]]; then
        get_linuxmint
    elif [[ "${OS}" == *"manjaro-"* ]]; then
        get_manjaro
    elif [[ "${OS}" == *"mxlinux-"* ]]; then
        get_mxlinux
    elif [[ "${OS}" == *"nixos-"* ]]; then
        get_nixos
    elif [ "${OS}" == "openbsd" ]; then
        get_openbsd
    elif [ "${OS}" == "opensuse" ]; then
        get_opensuse
    elif [ "${OS}" == "oraclelinux" ]; then
        get_oraclelinux
    elif [ "${OS}" == "popos" ]; then
        if [ -n "${3}" ]; then
            DRIVER="${3}"
            DRIVERS=(intel nvidia)
            if [[ ! ${DRIVERS[*]} =~ ${DRIVER} ]]; then
                echo "ERROR! ${DRIVER} is not a supported driver:"
                for DRIVER in "${DRIVERS[@]}"; do
                  echo "${DRIVER}"
                done
                exit 1
            fi
        else
            DRIVER="intel"
        fi
        VM_PATH="${OS}-${RELEASE}-${DRIVER}"
        get_popos "${DRIVER}"
    elif  [ "${OS}" == "regolith" ]; then
        get_regolith
    elif [ "${OS}" == "rockylinux" ]; then
        if [ -n "${3}" ]; then
            ISOTYPE="${3}"
            ISOTYPES=(minimal dvd1 boot)
            if [[ ! ${ISOTYPES[*]} =~ ${ISOTYPE} ]]; then
                echo "iso ${ISOTYPE} is not supported:"
                for ISOTYPE in "${ISOTYPES[@]}"; do
                  echo "${ISOTYPE}"
                done
                exit 1
            fi
        else
            ISOTYPE="dvd1"
        fi
        VM_PATH="${OS}-${RELEASE}-${ISOTYPE}"
        get_rocky "${ISOTYPE}"
    elif [ "${OS}" == "solus" ]; then
        get_solus
    elif [[ "${OS}" == "tails"* ]]; then
        get_tails
    elif [[ "${OS}" == *"ubuntu"* ]]; then
        get_ubuntu
    elif [ "${OS}" == "windows" ]; then
        if [ -n "${3}" ]; then
            LANG_NAME="${3}"
            if [[ ! ${LANGS[*]} =~ "${LANG_NAME}" ]]; then
                echo "ERROR! ${LANG_NAME} is not a supported language:"
                for LANG in "${LANGS[@]}"; do
                  echo "${LANG}"
                done
                exit 1
            fi
        else
            LANG_NAME="English International"
        fi
        get_windows "${LANG_NAME}"
    elif [ "${OS}" == "zorin" ]; then
        get_zorin
    else
        echo "ERROR! ${OS} is unknown:"
        os_support
        exit 1
    fi
else
    echo -n "ERROR! You must specify a release: "
    if [ "${OS}" == "alma" ]; then
        releases_alma
    elif [ "${OS}" == "alpine" ]; then
        releases_alpine
    elif [ "${OS}" == "android" ]; then
        releases_android
    elif [ "${OS}" == "archlinux" ]; then
        releases_archlinux
    elif [ "${OS}" == "arcolinux" ]; then
        releases_arcolinux
    elif [ "${OS}" == "debian" ]; then
        releases_debian
    elif [ "${OS}" == "elementary" ]; then
        releases_elementary
    elif [ "${OS}" == "freebsd" ]; then
        releases_freebsd
    elif [ "${OS}" == "fedora" ]; then
        releases_fedora
    elif [ "${OS}" == "garuda" ]; then
        releases_garuda
    elif [ "${OS}" == "cachyos" ]; then
        releases_cachyos
    elif [ "${OS}" == "gentoo" ]; then
        releases_gentoo
    elif [ "${OS}" == "haiku" ]; then
        releases_haiku
    elif [ "${OS}" == "kali" ]; then
        releases_kali
    elif [ "${OS}" == "kolibrios" ]; then
        releases_kolibrios
    elif [[ "${OS}" == *"linuxmint-"* ]]; then
        releases_linuxmint
    elif [[ "${OS}" == *"manjaro-"* ]]; then
        releases_manjaro
    elif [[ "${OS}" == *"mxlinux-"* ]]; then
        releases_mxlinux
    elif [[ "${OS}" == *"nixos-"* ]]; then
        releases_nixos
    elif [ "${OS}" == "opensuse" ]; then
        releases_opensuse
    elif [ "${OS}" == "oraclelinux" ]; then
        releases_oraclelinux
    elif [ "${OS}" == "openbsd" ]; then
        releases_openbsd
    elif [ "${OS}" == "macos" ]; then
        releases_macos
    elif [ "${OS}" == "popos" ]; then
        releases_popos
    elif [ "${OS}" == "regolith" ]; then
        releases_regolith
    elif [ "${OS}" == "rockylinux" ]; then
        releases_rockylinux
    elif [ "${OS}" == "solus" ]; then
        releases_solus
    elif [[ "${OS}" == "tails"* ]]; then
        releases_tails
    elif [[ "${OS}" == *"ubuntu"* ]]; then
        releases_ubuntu
    elif [ "${OS}" == "void" ]; then
        releases_void
    elif [ "${OS}" == "windows" ]; then
        releases_windows
    elif [ "${OS}" == "zorin" ]; then
        releases_zorin
    else
        echo "${OS} is unknown"
        os_support
    fi
    exit 1
fi
;;
   esac
    done
    if [ $# == 0 ]; then
      echo "Error: You must supply an OS!"
      os_support
      exit 1
fi