mirror of
https://github.com/oSoWoSo/DistroHopper.git
synced 2024-08-14 22:46:53 +00:00
86068f039a
Quotes needed to allow bracketed langs to match. User still needs to wrap the LANG parameter in quotes.
2232 lines
No EOL
67 KiB
Bash
Executable file
2232 lines
No EOL
67 KiB
Bash
Executable file
#!/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://mirror.fit.cvut.cz/voidlinux/live/current/sha256sum.txt" | awk 'NR == 1' |cut -d'.' -f1| cut -d'-' -f4)
|
|
URL="http://mirror.fit.cvut.cz/voidlinux/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://mirror.fit.cvut.cz/voidlinux/live/current/sha256sum.txt" | grep "void-live-x86_64-${DATE}.iso" | cut -d' ' -f4)";;
|
|
musl)
|
|
HASH="$(wget -q -O- "https://mirror.fit.cvut.cz/voidlinux/live/current/sha256sum.txt" | grep "void-live-x86_64-musl-${DATE}.iso" | cut -d' ' -f4)";;
|
|
xfce)
|
|
HASH="$(wget -q -O- "https://mirror.fit.cvut.cz/voidlinux/live/current/sha256sum.txt" | grep "void-live-x86_64-${DATE}-xfce.iso" | cut -d' ' -f4)";;
|
|
xfce-musl)
|
|
HASH="$(wget -q -O- "https://mirror.fit.cvut.cz/voidlinux/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>false</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
|
|
(https://github.com/virtio-win/virtio-win-pkg-scripts/blob/master/README.md)
|
|
is available as drive E:
|
|
-->
|
|
<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 |