#!/usr/bin/env bash
# Here the quick 'n dirty guide to adding a new OS to quickget
#
# 1. Update os_support() - add new OS, all lowercase
# 2. Update pretty_name() - add a pretty name for new OS *only if the catch all is not suitable*
# 3. Create a releases_newos() generator (required) outputs the current supported release versions
# 4. Create a editions_newos() generator (optional) outputs the editions if new OS has multiple flavours/editions
# 5. Update make_vm_config() - add any *required* new OS tweaks
# 6. Create a get_newos() function - that does something like this:
# function get_newos() {
# local EDITION="${1:-}"
# local HASH=""
# local ISO=""
# local URL=""
#
# URL="https://www.newos.org/download/${RELEASE}/${EDITION}"
# ISO="newos-${RELEASE}-${EDITION}-amd64.iso"
# web_get "${URL}/${ISO}" "${VM_PATH}"
# web_get "${URL}/SHA256SUMS" "${VM_PATH}"
# HASH=$(cut -d' ' -f1 < "${VM_PATH}/SHA256SUMS")
# check_hash "${ISO}" "${HASH}"
# make_vm_config "${ISO}"
# }
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";;
garuda) PRETTY_NAME="Garuda Linux";;
ghostbsd) PRETTY_NAME="GhostBSD";;
kdeneon) PRETTY_NAME="KDE Neon";;
kolibrios) PRETTY_NAME="KolibriOS";;
linuxmint) PRETTY_NAME="Linux Mint";;
mxlinux) PRETTY_NAME="MX Linux";;
netboot) PRETTY_NAME="netboot.xyz";;
netbsd) PRETTY_NAME="NetBSD";;
nixos) PRETTY_NAME="NixOS";;
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";;
slackware) PRETTY_NAME="Slackware 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=""
local RELEASES=""
DISPLAY_NAME="$(pretty_name "${OS}")"
case ${OS} in
*ubuntu*) RELEASE_GENERATOR="releases_ubuntu";;
*) RELEASE_GENERATOR="${1}";;
esac
RELEASES=$(${RELEASE_GENERATOR})
if [[ "${RELEASES}" != *"${RELEASE}"* ]]; then
echo -e "ERROR! ${DISPLAY_NAME} ${RELEASE} is not a supported release.\n"
echo -n "${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 DL=""
local DOWNLOADER
local FUNC
local OPTION
local OS
local PNG
local RELEASE
local SVG
local HAS_ZSYNC=0
# Check if zsync is available
if command -v zsync &>/dev/null; then
HAS_ZSYNC=1
fi
if command -v aria2c &>/dev/null; then
DL="aria2c"
elif command -v wget &>/dev/null; then
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"
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" ] && [ ${HAS_ZSYNC} -eq 1 ]; then
DOWNLOADER="zsync"
elif [[ "${OS}" == *"ubuntu"* ]] && [ "${RELEASE}" == "devel" ] && [ ${HAS_ZSYNC} -eq 1 ]; then
DOWNLOADER="zsync"
else
DOWNLOADER="${DL}"
fi
# If the OS has an editions_() function, use it.
if [[ $(type -t "editions_${OS}") == function ]]; then
for OPTION in $(editions_"${OS}"); do
echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
done
elif [ "${OS}" == "windows" ]; then
for OPTION in "${LANGS[@]}"; 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 \
devuan \
elementary \
fedora \
freebsd \
garuda \
gentoo \
ghostbsd \
haiku \
kali \
kdeneon \
kolibrios \
kubuntu \
linuxmint \
manjaro \
mxlinux \
netboot \
netbsd \
nixos \
lubuntu \
macos \
openbsd \
opensuse \
oraclelinux \
popos \
regolith \
rockylinux \
slackware \
solus \
tails \
ubuntu \
ubuntu-budgie \
ubuntukylin \
ubuntu-mate \
ubuntustudio \
void \
windows \
xubuntu \
zorin
}
function releases_alma() {
echo 8.4 8.5
}
function editions_alma() {
echo minimal dvd
}
function releases_alpine() {
echo 3.12 3.13 3.14 3.15 latest
}
function releases_android() {
echo 7.1 8.1 9.0
}
function editions_android() {
echo x86 x86_64
}
function releases_archlinux() {
echo latest
}
function releases_arcolinux() {
echo v21.09.11 v21.11.05 v22.01.10
}
function editions_arcolinux() {
echo large small
}
function releases_cachyos() {
echo 2022.01.09 2022.02.11
}
function releases_debian() {
echo 10.11.0 11.2.0
}
function editions_debian() {
echo standard cinnamon gnome kde lxde lxqt mate xfce
}
function releases_devuan() {
echo beowulf chimaera
}
function releases_elementary() {
echo 6.1
}
function releases_fedora() {
echo 33 34 35
}
function editions_fedora() {
echo Workstation \
Cinnamon \
i3 \
KDE \
LXDE \
LXQt \
Mate \
Xfce \
Silverblue \
Server
}
function releases_freebsd(){
echo 12.2 12.3 13.0
}
function releases_garuda() {
echo 220131
}
function editions_garuda() {
echo dr460nized \
dr460nized-blackarch \
dr460nized-gaming \
bspwm \
cinnamon \
gnome \
i3 \
kde-barebones \
lxqt-kwin \
mate \
qtile \
sway \
wayfire \
xfce
}
function releases_gentoo() {
echo latest
}
function releases_ghostbsd() {
echo 21.10.16 21.11.24 22.01.12
}
function editions_ghostbsd() {
echo mate xfce
}
function releases_haiku() {
echo r1beta3
}
function editions_haiku() {
echo x86_64 x86_gcc2h
}
function releases_kali() {
echo current kali-weekly
}
function releases_kdeneon() {
echo user testing unstable developer
}
function releases_kolibrios() {
echo latest
}
function releases_linuxmint(){
echo 20.2
}
function editions_linuxmint(){
echo cinnamon mate xfce
}
function releases_mxlinux(){
echo 21
}
function editions_mxlinux(){
echo Xfce KDE Fluxbox
}
function releases_macos() {
echo high-sierra mojave catalina big-sur monterey
}
function releases_manjaro() {
echo xfce \
gnome \
kde \
budgie \
cinnamon \
deepin \
i3 \
mate
}
function releases_netboot() {
echo latest
}
function releases_netbsd() {
echo 9.0 9.1 9.2
}
function releases_nixos(){
echo 21.05 21.11
}
function editions_nixos(){
echo gnome plasma5 minimal
}
function releases_openbsd(){
echo 6.7 6.8 6.9 7.0
}
function releases_opensuse(){
echo 15.0 15.1 15.2 15.3 microos tumbleweed
}
function releases_oraclelinux() {
echo 7.7 7.8 7.9 8.2 8.3 8.4 8.5
}
function releases_popos() {
echo 20.04 21.10
}
function editions_popos() {
echo intel nvidia
}
function releases_regolith() {
echo focal impish
}
function editions_regolith() {
echo 1.6.0 2.0.0
}
function releases_rockylinux() {
echo 8.3 8.4 8.5
}
function editions_rockylinux() {
echo minimal \
dvd1
}
function releases_slackware() {
echo 14.2 15.0
}
function releases_solus() {
echo 4.3
}
function editions_solus() {
echo Budgie GNOME MATE Plasma
}
function releases_tails() {
echo stable
}
function releases_ubuntu() {
echo 18.04 20.04 21.10 daily-live daily-canary
}
function releases_void() {
echo current
}
function editions_void() {
echo glibc musl xfce-glibc xfce-musl
}
function releases_windows() {
echo 8 10 11
}
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_zorin() {
echo 16
}
function editions_zorin() {
echo core64 lite64 education64 edulite64
}
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 web_get() {
local DIR="${2}"
local FILE=""
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 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 does not have new lines
echo "ERROR! Failed to download ${URL} with aria2c. Try running 'quickget' again."
exit 1
fi
echo #Necessary as aria2c in suppressed mode does not 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} with wget. Try running 'quickget' again."
exit 1
fi
fi
}
function zsync_get() {
local DIR="${2}"
local FILE="${1##*/}"
local OUT=""
local URL="${1}"
if command -v zsync &>/dev/null; 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 ! 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/aria2c"
if [ -n "${3}" ]; then
web_get "${1}" "${2}" "${3}"
else
web_get "${1}" "${2}"
fi
fi
}
function make_vm_config() {
local CONF_FILE=""
local IMAGE_FILE=""
local ISO_FILE=""
local IMAGE_TYPE=""
local GUEST=""
local SEC_BOOT=""
IMAGE_FILE="${1}"
ISO_FILE="${2}"
case "${OS}" in
freebsd|ghostbsd)
GUEST="freebsd"
IMAGE_TYPE="iso";;
haiku)
GUEST="haiku"
IMAGE_TYPE="iso";;
kolibrios)
GUEST="kolibrios"
IMAGE_TYPE="iso";;
macos)
GUEST="macos"
IMAGE_TYPE="img";;
netbsd)
GUEST="netbsd"
IMAGE_TYPE="iso";;
openbsd)
GUEST="openbsd"
IMAGE_TYPE="iso";;
windows)
GUEST="windows"
IMAGE_TYPE="iso";;
*)
GUEST="linux"
IMAGE_TYPE="iso";;
esac
if [ -n "${EDITION}" ]; then
CONF_FILE="${OS}-${RELEASE}-${EDITION}.conf"
else
CONF_FILE="${OS}-${RELEASE}.conf"
fi
if [ ! -e "${CONF_FILE}" ]; then
echo "Making ${CONF_FILE}"
cat << EOF > "${CONF_FILE}"
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}\"" >> "${CONF_FILE}"
fi
# OS specific tweaks
case ${OS} in
alma|oraclelinux|rockylinux) echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
haiku|openbsd|netbsd|slackware|tails) echo "boot=\"legacy\"" >> "${CONF_FILE}";;
kolibrios)
echo "boot=\"legacy\"" >> "${CONF_FILE}"
echo "disk_size=\"2G\"" >> "${CONF_FILE}"
echo "ram=\"128M\"" >> "${CONF_FILE}"
;;
macos) echo "macos_release=\"${RELEASE}\"" >> "${CONF_FILE}";;
esac
# Enable TPM for Windows 11
if [ "${OS}" == "windows" ] && [ "${RELEASE}" -ge 11 ]; then
echo "tpm=\"on\"" >> "${CONF_FILE}"
# 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}\"" >> "${CONF_FILE}"
fi
fi
echo
echo "To start your $(pretty_name "${OS}") virtual machine run:"
echo " quickemu --vm ${CONF_FILE}"
echo
exit 0
}
function get_alma() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
URL="http://lon.mirror.rackspace.com/almalinux/${RELEASE}/isos/x86_64/"
ISO="AlmaLinux-${RELEASE}-x86_64-${EDITION}.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=""
case ${RELEASE} in
latest) BRANCH="latest-stable";;
*) BRANCH="v${RELEASE}";;
esac
URL="https://dl-cdn.alpinelinux.org/alpine/${BRANCH}/releases/x86_64"
VERSION=$(wget -qO- "${URL}/latest-releases.yaml" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'version:' | awk '{print $2}')
ISO="alpine-virt-${VERSION}-x86_64.iso"
web_get "${URL}/${ISO}" "${VM_PATH}"
HASH=$(wget -qO- "${URL}/latest-releases.yaml" | 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_android() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local JSON_ALL=""
local JSON_REL=""
local URL="https://mirrors.gigenet.com/OSDN/android-x86"
JSON_ALL=$(wget -q -O- "https://www.fosshub.com/Android-x86-old.html" | grep "var settings =" | cut -d'=' -f2-)
JSON_REL=$(echo "${JSON_ALL}" | jq --arg ver "${OS}-${EDITION}-${RELEASE}" 'first(.pool.f[] | select((.n | startswith($ver)) and (.n | endswith(".iso"))))')
ISO=$(echo "${JSON_REL}" | jq -r .n)
HASH=$(echo "${JSON_REL}" | jq -r .hash.sha256)
# Traverse the directories to find the .iso location
for DIR in $(wget -q -O- ${URL} | grep -o -E '[0-9]{5}' | sort -ur); do
if wget -q -O- "${URL}/${DIR}" | grep "${ISO}" &>/dev/null; then
URL="${URL}/${DIR}"
break
fi
done
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_archlinux() {
local HASH=""
local ISO=""
local URL=""
local VERSION=""
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 EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
URL="https://ant.seedhost.eu/arcolinux/iso/${RELEASE}"
ISO="arcolinux${EDITION:0:1}-${RELEASE}-x86_64.iso"
HASH=$(wget -q -O- "${URL}/${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="https://mirror.cachyos.org/ISO"
ISO="cachyos-${RELEASE}-x86_64.iso"
web_get "${URL}/${ISO}" "${VM_PATH}"
make_vm_config "${ISO}"
}
function get_debian() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
case ${RELEASE} in
11.2.0) URL="https://cdimage.debian.org/debian-cd/${RELEASE}-live/amd64/iso-hybrid";;
*) URL="https://cdimage.debian.org/cdimage/archive/${RELEASE}-live/amd64/iso-hybrid/"
esac
ISO="debian-live-${RELEASE}-amd64-${EDITION}.iso"
HASH=$(wget -q -O- "${URL}/SHA512SUMS" | grep "${ISO}" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_devuan() {
local HASH=""
local ISO=""
local URL=""
local VERSION=""
case ${RELEASE} in
beowulf) VERSION="3.1.1";;
chimaera) VERSION="4.0.0";;
esac
URL="https://files.devuan.org/devuan_${RELEASE}/desktop-live"
ISO="devuan_${RELEASE}_${VERSION}_amd64_desktop-live.iso"
HASH=$(wget -q -O- "${URL}/SHASUMS.txt" | grep "${ISO}" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_elementary() {
local ISO=""
local ISOTAG="20211218-rc"
local URL=""
ISO="elementaryos-${RELEASE}-stable.${ISOTAG}.iso"
URL="https://ams3.dl.elementary.io/download/$(date +%s | base64)=/${ISO}"
web_get "${URL}" "${VM_PATH}"
make_vm_config "${ISO}"
}
function get_fedora() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local JSON=""
local URL=""
local VARIANT=""
case ${EDITION} in
Server|Silverblue|Workstation) VARIANT="${EDITION}";;
*) VARIANT="Spins";;
esac
JSON=$(wget -q -O- "https://getfedora.org/releases.json" | jq '.[] | select(.variant=="'${VARIANT}'" and .subvariant=="'"${EDITION}"'" and .arch=="x86_64" and .version=="'"${RELEASE}"'")')
URL=$(echo "${JSON}" | jq -r '.link' | head -n1)
ISO="${URL##*/}"
HASH=$(echo "${JSON}" | jq -r '.sha256' | head -n1)
web_get "${URL}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_freebsd() {
local HASH=""
local ISO=""
local URL=""
URL="https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}"
ISO="FreeBSD-${RELEASE}-RELEASE-amd64-dvd1.iso"
HASH=$(wget -q -O- "${URL}/CHECKSUM.SHA512-FreeBSD-${RELEASE}-RELEASE-amd64" | grep "${ISO}" | cut -d' ' -f4)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_garuda() {
local BRANCH=""
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
case ${EDITION} in
cinnamon|mate) BRANCH="community";;
*) BRANCH="garuda";;
esac
URL="http://mirrors.fossho.st/garuda/iso/${BRANCH}/${EDITION}/${RELEASE}"
ISO="${OS}-${EDITION}-linux-zen-${RELEASE}.iso"
HASH="$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)"
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_gentoo() {
local HASH=""
local ISO=""
local URL="https://mirror.bytemark.co.uk/gentoo/releases/amd64/autobuilds/"
ISO=$(wget -q -O- "${URL}/${RELEASE}-iso.txt" | grep install | cut -d' ' -f1)
HASH=$( wget -q -O- "${URL}/${ISO}.DIGESTS" | grep iso | grep -v CONTENTS | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "$(basename "${ISO}")" "${HASH}"
make_vm_config "${ISO}"
}
function get_ghostbsd() {
local EDITION="${1:-}"
local ISO=""
local URL=""
local HASH=""
case ${EDITION} in
mate) ISO="GhostBSD-${RELEASE}.iso";;
xfce) ISO="GhostBSD-${RELEASE}-XFCE.iso";;
esac
URL="https://download.ghostbsd.org/releases/amd64/${RELEASE}"
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f3)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_haiku() {
local EDITION="${1:-}"
local ISO=""
local URL=""
local HASH=""
URL="https://cdn.haiku-os.org/haiku-release/${RELEASE}"
ISO="haiku-${RELEASE}-${EDITION}-anyboot.iso"
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f4)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_kali() {
local HASH=""
local ISO=""
local URL=""
local SUBDIR=""
case ${RELEASE} in
latest) SUBDIR="current";;
*) SUBDIR="kali-weekly";;
esac
URL="https://cdimage.kali.org/${SUBDIR}"
ISO=$(wget -q -O- "${URL}/?C=M;O=D" | grep -o ">kali-linux-.*-installer-amd64.iso" | head -n 1 | cut -c 2-)
HASH=$(wget -q -O- "${URL}/SHA256SUMS" | grep -v torrent | grep "${ISO}" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_kdeneon() {
local HASH=""
local ISO=""
local URL=""
URL="https://files.kde.org/neon/images/${RELEASE}/current"
ISO=$(wget -q -O- "${URL}/neon-${RELEASE}-current.sha256sum" | cut -d' ' -f3-)
HASH=$(wget -q -O- "${URL}/neon-${RELEASE}-current.sha256sum" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_kolibrios() {
local HASH=""
local ISO="kolibri.iso"
local URL="https://builds.kolibrios.org/eng"
web_get "${URL}/${ISO}" "${VM_PATH}"
make_vm_config "${ISO}"
}
function get_linuxmint() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
URL="https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}"
ISO="linuxmint-${RELEASE}-${EDITION}-64bit.iso"
HASH=$(wget -q -O- "${URL}/${RELEASE}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${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_manjaro() {
local BRANCH=""
local HASH=""
local ISO=""
local KEY_ISO="Download_x64 ="
local KEY_HASH="Download_x64_Checksum ="
local MANIFESTURL=""
local URL=""
case ${RELEASE} in
gnome|kde|xfce) BRANCH="official";;
budgie|cinnamon|deepin|i3|mate) BRANCH="community";;
esac
MANIFESTURL="https://gitlab.manjaro.org/webpage/manjaro-homepage/-/raw/master/site/content/downloads/${BRANCH}/${RELEASE}.md"
URL="$(wget -qO- "${MANIFESTURL}" | grep "${KEY_ISO}" | cut -d'"' -f2)"
ISO="${URL##*/}"
HASH=$(wget -qO- "${MANIFESTURL}" | grep "${KEY_HASH}" | cut -d'"' -f2)
web_get "${URL}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_mxlinux() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
case ${EDITION} in
xfce)
URL="https://sourceforge.net/projects/mx-linux/files/Final/Xfce"
ISO="MX-${RELEASE}_x64.iso"
;;
kde)
URL="https://sourceforge.net/projects/mx-linux/files/Final/KDE"
ISO="MX-${RELEASE}_KDE_x64.iso"
;;
fluxbox)
URL="https://sourceforge.net/projects/mx-linux/files/Final/Fluxbox"
ISO="MX-${RELEASE}_fluxbox_x64.iso"
;;
esac
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_netboot() {
local ISO="netboot.xyz.iso"
local HASH=""
local URL="https://boot.netboot.xyz/ipxe"
HASH=$(wget -q -O- "${URL}/netboot.xyz-sha256-checksums.txt" | grep "${ISO}" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_netbsd() {
local HASH=""
local ISO=""
local URL=""
URL="https://cdn.netbsd.org/pub/NetBSD/NetBSD-${RELEASE}/images/"
ISO="NetBSD-${RELEASE}-amd64.iso"
HASH=$(wget -q -O- "${URL}/MD5" | grep "${ISO}" | cut -d' ' -f4)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_nixos() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
URL="https://channels.nixos.org/nixos-${RELEASE}"
ISO="latest-nixos-${EDITION}-x86_64-linux.iso"
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_openbsd() {
local HASH=""
local ISO=""
local URL=""
URL="https://cdn.openbsd.org/pub/OpenBSD/${RELEASE}/amd64"
ISO="install${RELEASE//\./}.iso"
HASH=$(wget -q -O- "${URL}/SHA256" | grep "${ISO}" | cut -d' ' -f4)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_opensuse() {
local HASH=""
local ISO=""
local URL=""
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 VER_MAJ=""
local VER_MIN=""
VER_MAJ=${RELEASE::1}
VER_MIN=${RELEASE:2:1}
URL="https://yum.oracle.com/ISOS/OracleLinux/OL${VER_MAJ}/u${VER_MIN}/x86_64/"
if [ "${VER_MAJ}" == "8" ]; then
ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-x86_64-dvd.iso"
else
ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64-dvd.iso"
fi
HASH=$(wget -q -O- "https://linux.oracle.com/security/gpg/checksum/OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64.checksum" | grep "${ISO}" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_popos() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
URL=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .url)
ISO="${URL##*/}"
HASH=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .sha_sum)
web_get "${URL}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_regolith() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local SUBDIR=""
local URL=""
case ${EDITION} in
1.6.0) SUBDIR="release-release-${RELEASE}-${RELEASE}_standard-${EDITION}";;
2.0.0) SUBDIR="regolith-linux-2.0-${RELEASE}-latest";;
esac
URL="https://github.com/regolith-linux/regolith-ubuntu-iso-builder/releases/download/${SUBDIR}"
ISO="Regolith_${EDITION}_${RELEASE}.iso"
HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
if [ -n "${HASH}" ]; then
check_hash "${ISO}" "${HASH}"
fi
make_vm_config "${ISO}"
}
function get_rockylinux() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
URL="https://download.rockylinux.org/pub/rocky/${RELEASE}/isos/x86_64"
ISO="Rocky-${RELEASE}-x86_64-${EDITION}.iso"
HASH=$(wget -q -O- "${URL}/CHECKSUM" | grep "SHA256" | grep "${ISO}" | cut -d' ' -f4)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_slackware() {
local HASH=""
local ISO=""
local URL=""
case ${RELEASE} in
current)
URL="https://slackware.nl/slackware/slackware64-current-iso"
ISO="slackware64-current-install-dvd.iso"
;;
*)
URL="https://mirrors.slackware.com/slackware/slackware-iso/slackware64-${RELEASE}-iso"
ISO="slackware64-${RELEASE}-install-dvd.iso"
;;
esac
HASH=$(wget -q -O- "${URL}/${ISO}.md5" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_solus() {
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL=""
case ${EDITION} in
mate|gnome)
EDITION=${EDITION^^};;
*)
EDITION=${EDITION^};;
esac
URL="https://mirrors.rit.edu/solus/images/${RELEASE}"
ISO="Solus-${RELEASE}-${EDITION}.iso"
HASH=$(wget -q -O- "${URL}.sha256sum" | cut -d' ' -f1)
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_tails() {
local ISO=""
local HASH=""
local RELEASE_JSON_URL=""
local RELEASE_JSON=""
local URL=""
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="${URL##*/}"
web_get "${URL}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_ubuntu() {
local ISO=""
local HASH=""
local URL=""
if [[ "${RELEASE}" == *"daily"* ]] && [ "${OS}" == "ubuntustudio" ]; then
# Ubuntu Studio daily-live images are in the dvd directory
RELEASE="dvd"
elif [ "${RELEASE}" == "daily-canary" ] && [ "${OS}" != "ubuntu" ]; then
# daily-canary is only available for Ubuntu, switch flavours to daily-live
RELEASE="daily-live"
fi
if [[ "${RELEASE}" == *"daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
URL="http://cdimage.ubuntu.com/${OS}/${RELEASE}/current"
VM_PATH="${OS}-devel"
elif [ "${OS}" == "ubuntu" ]; then
URL="http://releases.ubuntu.com/${RELEASE}"
else
URL="http://cdimage.ubuntu.com/${OS}/releases/${RELEASE}/release"
fi
ISO=$(wget -q -O- "${URL}/SHA256SUMS" | grep 'desktop\|dvd' | grep amd64 | cut -d'*' -f2)
HASH=$(wget -q -O- "${URL}/SHA256SUMS" | grep 'desktop\|dvd' | grep amd64 | cut -d' ' -f1)
#echo "${URL}/${ISO} ${HASH}"
if [[ "${RELEASE}" == *"daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-devel.iso"
make_vm_config "${OS}-devel.iso"
else
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
fi
}
function get_void() {
local DATE=""
local EDITION="${1:-}"
local HASH=""
local ISO=""
local URL="https://alpha.de.repo.voidlinux.org/live/current"
DATE=$(wget -q -O- "${URL}/sha256sum.txt" | head -n1 | cut -d'.' -f1 | cut -d'-' -f4)
case ${EDITION} in
glibc) ISO="void-live-x86_64-${DATE}.iso";;
musl) ISO="void-live-x86_64-musl-${DATE}.iso";;
xfce-glibc) ISO="void-live-x86_64-${DATE}-xfce.iso";;
xfce-musl) ISO="void-live-x86_64-musl-${DATE}-xfce.iso";;
esac
HASH="$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f4)"
web_get "${URL}/${ISO}" "${VM_PATH}"
check_hash "${ISO}" "${HASH}"
make_vm_config "${ISO}"
}
function get_zorin() {
local EDITION="${1:-}"
local ISO=""
local URL=""
# Parse out the iso URL from the redirector
URL=$(wget -q -S -O- --max-redirect=0 "https://zrn.co/${RELEASE}${EDITION}" 2>&1 | grep Location | cut -d' ' -f4)
ISO="${URL##*/}"
web_get "${URL}" "${VM_PATH}"
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 LANG_EDITION="${1}"
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=""
# Ignore the most recent Windows 10 release for now.
case ${RELEASE} in
10) INDEX=0;;
11) INDEX=0;;
esac
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_EDITION}"'").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"
}
create_vm() {
# shellcheck disable=SC2206
local URL_HASH=(${1// / })
local URL="${URL_HASH[0]}"
local HASH="${URL_HASH[1]}"
local ISO="${URL##*/}"
#echo "${URL}"
#echo "${ISO}"
#echo "${HASH}"
web_get "${URL}" "${VM_PATH}"
if [ -n "${HASH}" ]; then
check_hash "${ISO}" "${HASH}"
fi
make_vm_config "${ISO}"
}
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
if [ -n "${1}" ]; then
OS="${1,,}"
if [ "${OS}" == "list" ] || [ "${OS}" == "list_csv" ]; then
list_csv
elif [ "${OS}" == "list_json" ]; then
list_json
elif [ "${OS}" == "--version" ] || [ "${OS}" == "-version" ] || [ "${OS}" == "version" ]; then
WHERE=$(dirname "${BASH_SOURCE[0]}")
"${WHERE}/quickemu" --version
exit 0
fi
else
echo "ERROR! You must specify an operating system."
echo -n " - Operating Systems: "
os_support
exit 1
fi
if [[ ! $(os_support) =~ ${OS} ]]; then
echo -e "ERROR! ${OS} is not a supported OS.\n"
os_support
exit 1
fi
if [ -n "${2}" ]; then
RELEASE="${2,,}"
VM_PATH="${OS}-${RELEASE}"
# If the OS has an editions_() function, use it.
if [[ $(type -t "editions_${OS}") == function ]]; then
EDITIONS=($(editions_${OS}))
EDITION=${EDITIONS[0]}
if [ -n "${3}" ]; then
EDITION="${3}"
if [[ ! ${EDITIONS[*]} =~ ${EDITION} ]]; then
echo -e "ERROR! ${EDITION} is not a supported $(pretty_name "${OS}") edition:\n"
for EDITION in "${EDITIONS[@]}"; do
echo -n "${EDITION} "
done
exit 1
fi
fi
# Workaround for Regolith
if [ "${OS}" == "regolith" ]; then
if [ "${RELEASE}" == "focal" ] && [ "${EDITION}" == "2.0.0" ]; then
echo "WARNING! $(pretty_name "${OS}") ${EDITION} is not available for ${RELEASE}"
EDITION="1.6.0"
echo " - Setting edition to: ${EDITION}"
elif [ "${RELEASE}" == "impish" ] && [ "${EDITION}" == "1.6.0" ]; then
echo "WARNING! $(pretty_name "${OS}") ${EDITION} is not available for ${RELEASE}"
EDITION="2.0.0"
echo " - Setting edition to: ${EDITION}"
fi
fi
VM_PATH="${OS}-${RELEASE}-${EDITION}"
validate_release releases_"${OS}"
get_"${OS}" "${EDITION}"
elif [ "${OS}" == "macos" ]; then
# macOS doesn't use create_vm()
validate_release releases_macos
get_macos
elif [[ "${OS}" == *"ubuntu"* ]]; then
# Ubuntu doesn't use create_vm()
validate_release releases_ubuntu
get_ubuntu
elif [ "${OS}" == "windows" ]; then
LANG="English International"
if [ -n "${3}" ]; then
LANG="${3}"
if [[ ! ${LANGS[*]} =~ "${LANG}" ]]; then
echo -e "ERROR! ${LANG} is not a supported Windows language:\n"
for LANG in "${LANGS[@]}"; do
echo -n "${LANG} "
done
exit 1
fi
fi
# Windows doesn't use create_vm()
validate_release releases_windows
get_windows "${LANG}"
else
validate_release releases_"${OS}"
get_"${OS}"
fi
else
echo "ERROR! You must specify a release."
case ${OS} in
*ubuntu*)
echo -n " - Releases: "
releases_ubuntu
;;
*)
echo -n " - Releases: "
releases_"${OS}"
if [[ $(type -t "editions_${OS}") == function ]]; then
echo -n " - Editions: "
editions_"${OS}"
fi
;;
esac
exit 1
fi