2862 lines
96 KiB
Bash
Executable File
2862 lines
96 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
export LC_ALL=C
|
|
|
|
# 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. Update os_homepages() - add a homepage for new OS
|
|
# 4. Create a releases_newos() generator (required) outputs the current supported release versions
|
|
# 5. Create a editions_newos() generator (optional) outputs the editions if new OS has multiple flavours/editions
|
|
# 6. Update make_vm_config() - add any *required* new OS tweaks
|
|
# 7. Create a get_newos() function - that does something like this:
|
|
#
|
|
#function get_newos() {
|
|
# local EDITION="${1:-}"
|
|
# local HASH=""
|
|
# local ISO="newos-${RELEASE}-${EDITION}-amd64.iso"
|
|
# local URL="https://www.newos.org/download/${RELEASE}/${EDITION}"
|
|
#
|
|
# HASH=$(wget -q -O- "${URL}/SHA512SUMS" | grep "${ISO}" | cut -d' ' -f1)
|
|
# echo "${URL}/${ISO} ${HASH}"
|
|
#}
|
|
|
|
function cleanup() {
|
|
if [ -n "$(jobs -p)" ]; then
|
|
kill "$(jobs -p)"
|
|
fi
|
|
}
|
|
|
|
if [ "${1}" == '--test-iso-url' ] || [ "${1}" == '-t' ]; then
|
|
test_iso_url="on"
|
|
if [ -n "$4" ]; then
|
|
set -- "$2" "$3" "$4"
|
|
elif [ -n "$3" ]; then
|
|
set -- "$2" "$3"
|
|
else
|
|
set -- "$2"
|
|
fi
|
|
elif [ "${1}" == '--show-iso-url' ] || [ "${1}" == '-s' ]; then
|
|
show_iso_url="on"
|
|
if [ -n "$4" ]; then
|
|
set -- "$2" "$3" "$4"
|
|
elif [ -n "$3" ]; then
|
|
set -- "$2" "$3"
|
|
else
|
|
set -- "$2"
|
|
fi
|
|
elif [ "${1}" == '--open-distro-homepage' ] || [ "${1}" == '-o' ]; then
|
|
open_distro_homepage="on"
|
|
set -- "$2"
|
|
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";;
|
|
archcraft) PRETTY_NAME="Archcraft";;
|
|
arcolinux) PRETTY_NAME="Arco Linux";;
|
|
blendos) PRETTY_NAME="BlendOS";;
|
|
cachyos) PRETTY_NAME="CachyOS";;
|
|
centos-stream) PRETTY_NAME="CentOS Stream";;
|
|
dragonflybsd) PRETTY_NAME="DragonFlyBSD";;
|
|
easyos) PRETTY_NAME="EasyOS";;
|
|
elementary) PRETTY_NAME="elementary OS";;
|
|
endeavouros) PRETTY_NAME="EndeavourOS";;
|
|
endless) PRETTY_NAME="Endless OS";;
|
|
freebsd) PRETTY_NAME="FreeBSD";;
|
|
freedos) PRETTY_NAME="FreeDOS";;
|
|
garuda) PRETTY_NAME="Garuda Linux";;
|
|
ghostbsd) PRETTY_NAME="GhostBSD";;
|
|
holoiso) PRETTY_NAME="SteamOS HoloISO";;
|
|
kdeneon) PRETTY_NAME="KDE Neon";;
|
|
kolibrios) PRETTY_NAME="KolibriOS";;
|
|
linuxlite) PRETTY_NAME="Linux Lite";;
|
|
linuxmint) PRETTY_NAME="Linux Mint";;
|
|
lmde) PRETTY_NAME="Linux Mint Debian Edition";;
|
|
mageia) PRETTY_NAME="Mageia";;
|
|
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";;
|
|
openindiana) PRETTY_NAME="OpenIndiana";;
|
|
opensuse) PRETTY_NAME="openSUSE";;
|
|
oraclelinux) PRETTY_NAME="Oracle Linux";;
|
|
peppermint) PRETTY_NAME="PeppermintOS";;
|
|
popos) PRETTY_NAME="Pop!_OS";;
|
|
reactos) PRETTY_NAME="ReactOS";;
|
|
rebornos) PRETTY_NAME="RebornOS";;
|
|
rockylinux) PRETTY_NAME="Rocky Linux";;
|
|
tinycore) PRETTY_NAME="Tiny Core Linux";;
|
|
truenas-core) PRETTY_NAME="TrueNAS Core";;
|
|
truenas-scale) PRETTY_NAME="TrueNAS Scale";;
|
|
ubuntu-budgie) PRETTY_NAME="Ubuntu Budgie";;
|
|
ubuntucinnamon) PRETTY_NAME="Ubuntu Cinnamon";;
|
|
ubuntukylin) PRETTY_NAME="Ubuntu Kylin";;
|
|
ubuntu-mate) PRETTY_NAME="Ubuntu MATE";;
|
|
ubuntu-server) PRETTY_NAME="Ubuntu Server";;
|
|
ubuntustudio) PRETTY_NAME="Ubuntu Studio";;
|
|
ubuntu-unity) PRETTY_NAME="Ubuntu Unity";;
|
|
vanillaos) PRETTY_NAME="Vanilla OS";;
|
|
void) PRETTY_NAME="Void Linux";;
|
|
vxlinux) PRETTY_NAME="VX Linux";;
|
|
xerolinux) PRETTY_NAME="XeroLinux";;
|
|
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-server*) RELEASE_GENERATOR="releases_ubuntu-server";;
|
|
*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}")"
|
|
|
|
case ${OS} in
|
|
*ubuntu-server*) FUNC="ubuntu-server";;
|
|
*ubuntu*) FUNC="ubuntu";;
|
|
*) FUNC="${OS}";;
|
|
esac
|
|
|
|
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}" | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
|
|
if [ "${OS}" == "macos" ]; then
|
|
DOWNLOADER="macrecovery"
|
|
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 \
|
|
antix \
|
|
archlinux \
|
|
archcraft \
|
|
arcolinux \
|
|
batocera \
|
|
blendos \
|
|
bodhi \
|
|
bunsenlabs \
|
|
cachyos \
|
|
centos-stream \
|
|
debian \
|
|
deepin \
|
|
devuan \
|
|
dragonflybsd \
|
|
easyos \
|
|
edubuntu \
|
|
elementary \
|
|
endeavouros \
|
|
endless \
|
|
fedora \
|
|
freebsd \
|
|
freedos \
|
|
garuda \
|
|
gentoo \
|
|
ghostbsd \
|
|
haiku \
|
|
holoiso \
|
|
kali \
|
|
kdeneon \
|
|
kolibrios \
|
|
kubuntu \
|
|
linuxlite \
|
|
linuxmint \
|
|
lmde \
|
|
mageia \
|
|
manjaro \
|
|
mxlinux \
|
|
netboot \
|
|
netbsd \
|
|
nixos \
|
|
lubuntu \
|
|
macos \
|
|
openbsd \
|
|
openindiana \
|
|
opensuse \
|
|
oraclelinux \
|
|
peppermint \
|
|
popos \
|
|
porteus \
|
|
reactos \
|
|
rebornos \
|
|
rockylinux \
|
|
siduction \
|
|
slackware \
|
|
solus \
|
|
spiral \
|
|
tails \
|
|
tinycore \
|
|
trisquel \
|
|
truenas-core \
|
|
truenas-scale \
|
|
ubuntu \
|
|
ubuntu-budgie \
|
|
ubuntucinnamon \
|
|
ubuntukylin \
|
|
ubuntu-mate \
|
|
ubuntu-server \
|
|
ubuntustudio \
|
|
ubuntu-unity \
|
|
vanillaos \
|
|
void \
|
|
vxlinux \
|
|
windows \
|
|
xerolinux \
|
|
xubuntu \
|
|
zorin
|
|
}
|
|
|
|
function os_homepages(){
|
|
local SIMPLE_NAME=""
|
|
local HOMEPAGE=""
|
|
SIMPLE_NAME="${1}"
|
|
case ${SIMPLE_NAME} in
|
|
alma) HOMEPAGE="https://almalinux.org/";;
|
|
alpine) HOMEPAGE="https://alpinelinux.org/";;
|
|
android) HOMEPAGE="https://www.android-x86.org/";;
|
|
antix) HOMEPAGE="https://antixlinux.com/";;
|
|
archlinux) HOMEPAGE="https://archlinux.org/";;
|
|
archcraft) HOMEPAGE="https://archcraft.io/";;
|
|
arcolinux) HOMEPAGE="https://arcolinux.com/";;
|
|
batocera) HOMEPAGE="https://batocera.org/";;
|
|
blendos) HOMEPAGE="https://blendos.co/";;
|
|
bodhi) HOMEPAGE="https://www.bodhilinux.com/";;
|
|
bunsenlabs) HOMEPAGE="https://www.bunsenlabs.org/";;
|
|
cachyos) HOMEPAGE="https://cachyos.org/";;
|
|
centos-stream) HOMEPAGE="https://www.centos.org/centos-stream/";;
|
|
debian) HOMEPAGE="https://www.debian.org/";;
|
|
deepin) HOMEPAGE="https://www.deepin.org/";;
|
|
devuan) HOMEPAGE="https://www.devuan.org/";;
|
|
dragonflybsd) HOMEPAGE="https://www.dragonflybsd.org/";;
|
|
easyos) HOMEPAGE="https://easyos.org/";;
|
|
edubuntu) HOMEPAGE="https://www.edubuntu.org/";;
|
|
elementary) HOMEPAGE="https://elementary.io/";;
|
|
endeavouros) HOMEPAGE="https://endeavouros.com/";;
|
|
endless) HOMEPAGE="https://www.endlessos.org/os";;
|
|
fedora) HOMEPAGE="https://www.fedoraproject.org/";;
|
|
freebsd) HOMEPAGE="https://www.freebsd.org/";;
|
|
freedos) HOMEPAGE="https://freedos.org/";;
|
|
garuda) HOMEPAGE="https://garudalinux.org/";;
|
|
gentoo) HOMEPAGE="https://www.gentoo.org/";;
|
|
ghostbsd) HOMEPAGE="https://www.ghostbsd.org/";;
|
|
haiku) HOMEPAGE="https://www.haiku-os.org/";;
|
|
holoiso) HOMEPAGE="https://github.com/HoloISO/holoiso";;
|
|
kali) HOMEPAGE="https://www.kali.org/";;
|
|
kdeneon) HOMEPAGE="https://neon.kde.org/";;
|
|
kolibrios) HOMEPAGE="http://kolibrios.org/en/";;
|
|
kubuntu) HOMEPAGE="https://kubuntu.org/";;
|
|
linuxlite) HOMEPAGE="https://www.linuxliteos.com/";;
|
|
linuxmint) HOMEPAGE="https://linuxmint.com/";;
|
|
lmde) HOMEPAGE="https://www.linuxmint.com/download_lmde.php";;
|
|
mageia) HOMEPAGE="https://www.mageia.org/";;
|
|
manjaro) HOMEPAGE="https://manjaro.org/";;
|
|
mxlinux) HOMEPAGE="https://mxlinux.org/";;
|
|
netboot) HOMEPAGE="https://netboot.xyz/";;
|
|
netbsd) HOMEPAGE="https://www.netbsd.org/";;
|
|
nixos) HOMEPAGE="https://nixos.org/";;
|
|
lubuntu) HOMEPAGE="https://lubuntu.me/";;
|
|
macos) HOMEPAGE="https://www.apple.com/macos/";;
|
|
openbsd) HOMEPAGE="https://www.openbsd.org/";;
|
|
openindiana) HOMEPAGE="https://www.openindiana.org/";;
|
|
opensuse) HOMEPAGE="https://www.opensuse.org/";;
|
|
oraclelinux) HOMEPAGE="https://www.oracle.com/linux/";;
|
|
peppermint) HOMEPAGE="https://peppermintos.com/";;
|
|
popos) HOMEPAGE="https://pop.system76.com/";;
|
|
porteus) HOMEPAGE="http://www.porteus.org/";;
|
|
reactos) HOMEPAGE="https://reactos.org/";;
|
|
rebornos) HOMEPAGE="https://rebornos.org/";;
|
|
rockylinux) HOMEPAGE="https://rockylinux.org/";;
|
|
siduction) HOMEPAGE="https://siduction.org/";;
|
|
slackware) HOMEPAGE="http://www.slackware.com/";;
|
|
solus) HOMEPAGE="https://getsol.us/";;
|
|
spiral) HOMEPAGE="https://spirallinux.github.io/";;
|
|
tails) HOMEPAGE="https://tails.net/";;
|
|
tinycore) HOMEPAGE="http://www.tinycorelinux.net/";;
|
|
trisquel) HOMEPAGE="https://trisquel.info/";;
|
|
truenas-core) HOMEPAGE="https://www.truenas.com/truenas-core/";;
|
|
truenas-scale) HOMEPAGE="https://www.truenas.com/truenas-scale/";;
|
|
ubuntu) HOMEPAGE="https://ubuntu.com/";;
|
|
ubuntu-budgie) HOMEPAGE="https://ubuntubudgie.org/";;
|
|
ubuntucinnamon) HOMEPAGE="https://ubuntucinnamon.org/";;
|
|
ubuntukylin) HOMEPAGE="https://ubuntukylin.com/";;
|
|
ubuntu-mate) HOMEPAGE="https://ubuntu-mate.org/";;
|
|
ubuntu-server) HOMEPAGE="https://ubuntu.com/server";;
|
|
ubuntustudio) HOMEPAGE="https://ubuntustudio.org/";;
|
|
ubuntu-unity) HOMEPAGE="https://ubuntuunity.org/";;
|
|
vanillaos) HOMEPAGE="https://vanillaos.org/";;
|
|
void) HOMEPAGE="https://voidlinux.org/";;
|
|
vxlinux) HOMEPAGE="https://vxlinux.org/";;
|
|
windows) HOMEPAGE="https://www.microsoft.com/en-us/windows/";;
|
|
xerolinux) HOMEPAGE="https://xerolinux.xyz/";;
|
|
xubuntu) HOMEPAGE="https://xubuntu.org/";;
|
|
zorin) HOMEPAGE="https://zorin.com/os/";;
|
|
esac
|
|
echo "${HOMEPAGE}"
|
|
}
|
|
|
|
function releases_alma() {
|
|
echo 8 9
|
|
}
|
|
|
|
function editions_alma() {
|
|
echo boot minimal dvd
|
|
}
|
|
|
|
function releases_alpine() {
|
|
echo 3.12 3.13 3.14 3.15 3.16 3.17 3.18 latest
|
|
}
|
|
|
|
function releases_android() {
|
|
echo 7.1 8.1 9.0
|
|
}
|
|
|
|
function editions_android() {
|
|
echo x86 x86_64
|
|
}
|
|
|
|
function releases_antix() {
|
|
echo 21 22 23
|
|
}
|
|
|
|
function editions_antix() {
|
|
echo net-sysv core-sysv base-sysv full-sysv net-runit core-runit base-runit full-runit
|
|
}
|
|
|
|
function releases_archlinux() {
|
|
echo latest
|
|
}
|
|
|
|
function releases_archcraft() {
|
|
echo latest
|
|
}
|
|
|
|
function releases_arcolinux() {
|
|
local RLIST
|
|
RLIST=$(curl -s https://ant.seedhost.eu/arcolinux/iso/ | grep -o -E ">v[[:digit:]]{2}.[[:digit:]]{2}.[[:digit:]]{2}" | sed -e "s/>//" | tr '\r\n' ' ')
|
|
echo ${RLIST}
|
|
}
|
|
|
|
function editions_arcolinux() {
|
|
echo large small
|
|
}
|
|
|
|
function releases_blendos() {
|
|
|
|
# Pull the rss feed
|
|
wget -q https://sourceforge.net/projects/blendos/rss?path=/ISOs/ -O- | grep -E -o 'https://.*blendOS\.iso.*</media:hash' >/tmp/blendos-isos.rss
|
|
|
|
local RLIST
|
|
RLIST=$(grep -E -o 'https://.*blendOS\.iso.*</media:hash' /tmp/blendos-isos.rss | cut -d/ -f 8-9 | sort -r -t/ --key=2 |grep -e '16878' -e '168[8-9]')
|
|
echo ${RLIST}
|
|
|
|
}
|
|
|
|
|
|
function releases_bunsenlabs() {
|
|
echo latest
|
|
}
|
|
|
|
function releases_bodhi() {
|
|
echo 7.0.0
|
|
}
|
|
|
|
function editions_bodhi() {
|
|
echo standard hwe s76
|
|
}
|
|
|
|
function releases_cachyos() {
|
|
echo 230813
|
|
}
|
|
|
|
function editions_cachyos() {
|
|
echo kde gnome
|
|
}
|
|
|
|
function releases_centos-stream() {
|
|
echo 8 9
|
|
}
|
|
|
|
function editions_centos-stream() {
|
|
echo dvd1 boot
|
|
}
|
|
|
|
function releases_debian() {
|
|
DEBCURRENT=$(wget -q https://cdimage.debian.org/debian-cd/ -O- |grep '\.[0-9]/'|cut -d\> -f9|cut -d\/ -f1)
|
|
local DEBOLD=$(wget -q https://cdimage.debian.org/cdimage/archive/ -O- |grep -e '>[1-9][0-9]\.'|grep -v 'live' | cut -d\> -f9|cut -d\/ -f1 )
|
|
|
|
echo ${DEBOLD} ${DEBCURRENT}
|
|
}
|
|
|
|
function editions_debian() {
|
|
echo standard cinnamon gnome kde lxde lxqt mate xfce netinst
|
|
}
|
|
|
|
function releases_deepin() {
|
|
echo 20 20.1 20.2 20.2.1 20.2.2 20.2.3 20.2.4 20.3 20.4 20.5 20.6 20.7
|
|
}
|
|
|
|
function releases_devuan() {
|
|
echo beowulf chimaera daedalus
|
|
}
|
|
|
|
function releases_dragonflybsd() {
|
|
# If you remove "".bz2" from the end of the searched URL, you will get only the current release - currently 6.4.0
|
|
# We could add a variable so this behaviour is optional/switchable (maybe from option or env)
|
|
DBSD_RELEASES=$(curl -sL http://mirror-master.dragonflybsd.org/iso-images/| grep -E -o '"dfly-x86_64-.*_REL.iso.bz2"' | grep -o -E '[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+' )
|
|
echo $DBSD_RELEASES
|
|
}
|
|
|
|
function releases_easyos() {
|
|
#local RLIST
|
|
#RLIST=$(curl -s https://distro.ibiblio.org/easyos/amd64/releases/kirkstone/2023/ | grep 'href="' | tail +2 | cut -d'/' -f1 | cut -d'"' -f6)
|
|
#RLIST=$(wget -q -O- 'https://distro.ibiblio.org/easyos/amd64/releases/kirkstone/2023/' | grep 'href="' | tail +2 | cut -d'/' -f1 | cut -d'"' -f6)
|
|
#echo ${RLIST}
|
|
# Not dynamic for now
|
|
echo 5.6.4 5.6.3 5.6.2 5.6.1 5.5.5 5.5.4
|
|
}
|
|
|
|
function releases_elementary() {
|
|
echo 7.0 7.1
|
|
}
|
|
|
|
function releases_endeavouros() {
|
|
echo apollo_22_1 \
|
|
artemis-22_6 \
|
|
artemis_neo_22_7 \
|
|
artemis_neo_22_8 \
|
|
artemis_nova_22_9 \
|
|
atlantis-21_4 \
|
|
atlantis_neo-21_5 \
|
|
cassini_22_12
|
|
}
|
|
|
|
function releases_endless() {
|
|
echo 5.0.0
|
|
}
|
|
|
|
function editions_endless() {
|
|
echo base en fr pt_BR es
|
|
}
|
|
|
|
function releases_fedora() {
|
|
echo 38 39
|
|
}
|
|
|
|
function releases_batocera() {
|
|
echo latest
|
|
}
|
|
|
|
function editions_fedora() {
|
|
echo Workstation \
|
|
Budgie \
|
|
Cinnamon \
|
|
i3 \
|
|
KDE \
|
|
LXDE \
|
|
LXQt \
|
|
Mate \
|
|
Xfce \
|
|
Silverblue \
|
|
Sericea \
|
|
Kinoite \
|
|
Sway \
|
|
Server \
|
|
Onyx
|
|
}
|
|
|
|
function releases_freebsd(){
|
|
local FBSD_RELEASES=$(curl -sL https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/|grep -e 'class="link"' |grep -v '\.\.'|cut -d\" -f4|tr -d '/')
|
|
echo ${FBSD_RELEASES}
|
|
}
|
|
|
|
function editions_freebsd(){
|
|
echo disc1 dvd1
|
|
}
|
|
|
|
function releases_freedos() {
|
|
echo 1.2 1.3
|
|
}
|
|
|
|
function releases_garuda() {
|
|
echo latest
|
|
}
|
|
|
|
function editions_garuda() {
|
|
echo cinnamon dr460nized dr460nized-gaming gnome i3 kde-git kde-lite 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 r1beta4
|
|
}
|
|
|
|
function editions_haiku() {
|
|
echo x86_64 x86_gcc2h
|
|
}
|
|
|
|
function releases_holoiso() {
|
|
wget -q https://github.com/HoloISO/holoiso/releases/latest -O- | grep -o -e 'releases/tag/[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]' | head -1 | cut -d/ -f3
|
|
}
|
|
|
|
function releases_kali() {
|
|
echo current kali-weekly
|
|
}
|
|
|
|
function releases_kdeneon() {
|
|
echo user testing unstable developer
|
|
}
|
|
|
|
function releases_kolibrios() {
|
|
echo latest
|
|
}
|
|
|
|
function releases_linuxlite() {
|
|
echo 6.0 6.2 6.4 6.6
|
|
}
|
|
|
|
function releases_linuxmint(){
|
|
echo 20.2 20.3 21 21.1 21.2
|
|
}
|
|
|
|
function editions_linuxmint(){
|
|
echo cinnamon mate xfce
|
|
}
|
|
|
|
function editions_lmde(){
|
|
echo cinnamon
|
|
}
|
|
|
|
function releases_lmde(){
|
|
echo 5
|
|
}
|
|
|
|
function releases_mageia(){
|
|
echo 8
|
|
}
|
|
|
|
function editions_mageia(){
|
|
echo Plasma GNOME Xfce
|
|
}
|
|
|
|
function releases_mxlinux(){
|
|
echo 21.3
|
|
}
|
|
|
|
function editions_mxlinux(){
|
|
echo Xfce KDE Fluxbox
|
|
}
|
|
|
|
function editions_manjaro(){
|
|
echo full minimal
|
|
}
|
|
|
|
function releases_macos() {
|
|
echo high-sierra mojave catalina big-sur monterey ventura
|
|
}
|
|
|
|
function releases_manjaro() {
|
|
echo xfce \
|
|
gnome \
|
|
plasma \
|
|
budgie \
|
|
cinnamon \
|
|
i3 \
|
|
mate \
|
|
sway
|
|
}
|
|
|
|
function releases_netboot() {
|
|
echo latest
|
|
}
|
|
|
|
function releases_netbsd() {
|
|
local NBSD_RELEASES=$(curl -sL http://cdn.netbsd.org/pub/NetBSD/iso/ | grep -o -E '"[[:digit:]]+\.[[:digit:]]+/"' |tr -d '"/' |sort -nr )
|
|
echo ${NBSD_RELEASES}
|
|
}
|
|
|
|
function releases_nixos(){
|
|
echo 21.05 21.11 22.05 22.11 23.05 23.11
|
|
}
|
|
|
|
function editions_nixos(){
|
|
echo gnome plasma5 minimal
|
|
}
|
|
|
|
function releases_openbsd(){
|
|
local OBSD_RELEASES=$(curl -sL https://mirror.leaseweb.com/pub/OpenBSD/|grep -e '6\.[8-9]/' -e '[7-9]\.'|cut -d\" -f4|tr -d '/')
|
|
echo ${OBSD_RELEASES}
|
|
}
|
|
|
|
function releases_openindiana(){
|
|
echo 20230421
|
|
}
|
|
|
|
function editions_openindiana(){
|
|
echo gui text minimal
|
|
}
|
|
|
|
function releases_opensuse(){
|
|
echo 15.0 15.1 15.2 15.3 15.4 microos tumbleweed
|
|
}
|
|
|
|
function releases_oraclelinux() {
|
|
echo 7.7 7.8 7.9 8.4 8.5 8.6 9.0
|
|
}
|
|
|
|
function releases_peppermint() {
|
|
echo latest
|
|
}
|
|
|
|
function editions_peppermint() {
|
|
echo devuan-xfce devuan-gnome debian-xfce debian-gnome
|
|
}
|
|
|
|
function releases_popos() {
|
|
echo 20.04 21.10 22.04
|
|
}
|
|
|
|
function editions_popos() {
|
|
echo intel nvidia
|
|
}
|
|
|
|
function releases_porteus() {
|
|
echo 5.0 5.01
|
|
}
|
|
|
|
function editions_porteus() {
|
|
echo cinnamon gnome kde lxde lxqt mate openbox xfce
|
|
}
|
|
|
|
function releases_reactos() {
|
|
echo latest
|
|
}
|
|
|
|
function releases_rebornos() {
|
|
echo latest
|
|
}
|
|
|
|
function get_rebornos() {
|
|
local ISO=$(wget -q -O- "https://meta.cdn.soulharsh007.dev/RebornOS-ISO?format=json" | jq -r ".url")
|
|
local HASH=$(wget -q -O- "https://meta.cdn.soulharsh007.dev/RebornOS-ISO?format=json" | jq -r ".md5")
|
|
echo "${ISO} ${HASH}"
|
|
}
|
|
|
|
function releases_rockylinux() {
|
|
echo 8.3 8.4 8.5 8.6 8.7 9.0 9.1
|
|
}
|
|
|
|
function editions_rockylinux() {
|
|
echo minimal dvd boot
|
|
}
|
|
|
|
function releases_siduction() {
|
|
echo latest
|
|
}
|
|
|
|
function editions_siduction() {
|
|
echo kde lxqt nox xfce xorg
|
|
}
|
|
|
|
function releases_slackware() {
|
|
echo 14.2 15.0
|
|
}
|
|
|
|
function releases_solus() {
|
|
echo 4.3
|
|
}
|
|
|
|
function editions_solus() {
|
|
echo Budgie GNOME MATE Plasma
|
|
}
|
|
|
|
function releases_spiral() {
|
|
echo latest
|
|
}
|
|
|
|
function editions_spiral() {
|
|
echo Plasma XFCE Mate LXQt Gnome Budgie Cinnamon Builder
|
|
}
|
|
|
|
function releases_tails() {
|
|
echo stable
|
|
}
|
|
|
|
function releases_tinycore() {
|
|
echo 14.0
|
|
}
|
|
|
|
function editions_tinycore() {
|
|
echo Core TinyCore CorePlus CorePure64 TinyCorePure64
|
|
}
|
|
|
|
function releases_trisquel() {
|
|
echo 10.0.1 11.0
|
|
}
|
|
|
|
function editions_trisquel() {
|
|
echo mate lxde kde sugar
|
|
}
|
|
|
|
function releases_truenas() {
|
|
if [[ $OS == truenas ]] ; then
|
|
echo "ERROR! The supported TrueNAS OS values are truenas-core or truenas-scale"
|
|
exit 1;
|
|
fi
|
|
}
|
|
|
|
function releases_truenas-core() {
|
|
echo 12.0 13.0
|
|
}
|
|
|
|
function releases_truenas-scale() {
|
|
echo 22.02 22.12
|
|
}
|
|
|
|
function releases_ubuntu() {
|
|
local VERSION_DATA="$(IFS=$'\n' wget -qO- https://api.launchpad.net/devel/ubuntu/series | jq -r '.entries[]')"
|
|
local SUPPORTED_VERSIONS=($(IFS=$'\n' jq -r 'select(.status=="Supported" or .status=="Current Stable Release") | .version' <<<${VERSION_DATA} | sort))
|
|
local EOL_VERSIONS=($(IFS=$'\n' jq -r 'select(.status=="Obsolete") | .version' <<<${VERSION_DATA} | sort))
|
|
local LTS_SUPPORT=()
|
|
local INTERIM_SUPPORT=()
|
|
|
|
for i in "${SUPPORTED_VERSIONS[@]}"; do
|
|
if [[ $(expr ${i%.*} % 2) == 0 && ${i#*.} == "04" ]]; then
|
|
LTS_SUPPORT+=($i)
|
|
else
|
|
INTERIM_SUPPORT+=($i)
|
|
fi
|
|
done
|
|
|
|
case "${OS}" in
|
|
edubuntu|ubuntu-unity|ubuntucinnamon)
|
|
echo ${INTERIM_SUPPORT[@]} daily-live
|
|
;;
|
|
kubuntu|lubuntu|ubuntukylin|ubuntu-mate|ubuntustudio|xubuntu)
|
|
## after 14.04
|
|
echo ${LTS_SUPPORT[@]:1} ${INTERIM_SUPPORT[@]} daily-live jammy-daily ${EOL_VERSIONS[@]/#/eol-}
|
|
;;
|
|
ubuntu-budgie)
|
|
#after 16.04
|
|
echo ${LTS_SUPPORT[@]:2} ${INTERIM_SUPPORT[@]} daily-live jammy-daily ${EOL_VERSIONS[@]/#/eol-}
|
|
;;
|
|
ubuntu)
|
|
echo ${LTS_SUPPORT[@]} ${INTERIM_SUPPORT[@]} daily-live ${EOL_VERSIONS[@]/#/eol-}
|
|
;;
|
|
esac
|
|
}
|
|
|
|
function releases_ubuntu-server() {
|
|
local ALL_VERSIONS=($(IFS=$'\n' wget -qO- http://releases.ubuntu.com/streams/v1/com.ubuntu.releases:ubuntu-server.json | jq -r '.products[] | select(.arch=="amd64") | .version'))
|
|
|
|
local LTS_SUPPORT=()
|
|
local INTERIM_SUPPORT=()
|
|
|
|
for i in "${!ALL_VERSIONS[@]}"; do
|
|
if [[ $i == 0 || ${ALL_VERSIONS[$i]} > ${ALL_VERSIONS[$(expr $i - 1)]} ]]; then
|
|
if [[ $(expr ${ALL_VERSIONS[${i}]%.*} % 2) == 0 && ${ALL_VERSIONS[${i}]#*.} == "04" ]]; then
|
|
LTS_SUPPORT+=(${ALL_VERSIONS[$i]})
|
|
else
|
|
INTERIM_SUPPORT+=(${ALL_VERSIONS[$i]})
|
|
fi
|
|
else
|
|
break
|
|
fi
|
|
done
|
|
|
|
echo ${LTS_SUPPORT[@]} ${INTERIM_SUPPORT[@]} daily-live
|
|
}
|
|
|
|
function releases_vanillaos() {
|
|
echo 22.10
|
|
}
|
|
|
|
function releases_void() {
|
|
echo current
|
|
}
|
|
|
|
function editions_void() {
|
|
echo glibc musl xfce-glibc xfce-musl
|
|
}
|
|
|
|
function releases_vxlinux() {
|
|
wget -q https://github.com/VX-Linux/main/releases/latest -O- | grep -o -e 'releases/tag/[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]' | head -1 | cut -d/ -f3
|
|
}
|
|
|
|
function releases_windows() {
|
|
echo 8 10 11
|
|
}
|
|
|
|
function releases_xerolinux() {
|
|
echo kde
|
|
}
|
|
|
|
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
|
|
|
|
# Test mode for ISO
|
|
if [ "${show_iso_url}" == 'on' ]; then
|
|
echo "${URL}"
|
|
exit 0
|
|
elif [ "${test_iso_url}" == 'on' ]; then
|
|
wget --spider "${URL}"
|
|
exit 0
|
|
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 --stderr -x16 --continue=true --summary-interval=0 --download-result=hide --console-log-level=error "${URL}" --dir "${DIR}" -o "${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
|
|
elif ! wget --quiet --continue --tries=3 --read-timeout=10 --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
|
|
}
|
|
|
|
function zsync_get() {
|
|
local DIR="${2}"
|
|
local FILE="${1##*/}"
|
|
local OUT=""
|
|
local URL="${1}"
|
|
|
|
# Test mode for ISO
|
|
if [ "${show_iso_url}" == 'on' ]; then
|
|
echo "${URL}"
|
|
exit 0
|
|
elif [ "${test_iso_url}" == 'on' ]; then
|
|
wget --spider "${URL}"
|
|
exit 0
|
|
elif 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
|
|
|
|
# Only force http for zsync - not earlier because we might fall through here
|
|
if ! zsync "${URL/https/http}.zsync" -i "${DIR}/${OUT}" -o "${DIR}/${OUT}" 2>/dev/null; then
|
|
echo "ERROR! Failed to download ${URL/https/http}.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
|
|
batocera)
|
|
GUEST="batocera"
|
|
IMAGE_TYPE="img";;
|
|
dragonflybsd)
|
|
GUEST="dragonflybsd"
|
|
IMAGE_TYPE="iso";;
|
|
freebsd|ghostbsd)
|
|
GUEST="freebsd"
|
|
IMAGE_TYPE="iso";;
|
|
haiku)
|
|
GUEST="haiku"
|
|
IMAGE_TYPE="iso";;
|
|
freedos)
|
|
GUEST="freedos"
|
|
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";;
|
|
openindiana)
|
|
GUEST="solaris"
|
|
IMAGE_TYPE="iso";;
|
|
reactos)
|
|
GUEST="reactos"
|
|
IMAGE_TYPE="iso";;
|
|
truenas*)
|
|
GUEST="truenas"
|
|
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}"
|
|
#!$(which quickemu) --vm
|
|
guest_os="${GUEST}"
|
|
disk_img="${VM_PATH}/disk.qcow2"
|
|
${IMAGE_TYPE}="${VM_PATH}/${IMAGE_FILE}"
|
|
EOF
|
|
echo "Giving user execute permissions on ${CONF_FILE},"
|
|
chmod u+x "${CONF_FILE}"
|
|
if [ -n "${ISO_FILE}" ]; then
|
|
echo "fixed_iso=\"${VM_PATH}/${ISO_FILE}\"" >> "${CONF_FILE}"
|
|
fi
|
|
|
|
# OS specific tweaks
|
|
case ${OS} in
|
|
alma|centos-stream|endless|garuda|nixos|oraclelinux|popos|rockylinux)
|
|
echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
|
|
openindiana)
|
|
echo "boot=\"legacy\"" >> "${CONF_FILE}"
|
|
echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
|
|
batocera)
|
|
echo "disk_size=\"8G\"" >> "${CONF_FILE}";;
|
|
dragonflybsd|haiku|openbsd|netbsd|slackware|tails|tinycore)
|
|
echo "boot=\"legacy\"" >> "${CONF_FILE}";;
|
|
deepin)
|
|
echo "disk_size=\"64G\"" >> "${CONF_FILE}"
|
|
echo "ram=\"4G\"" >> "${CONF_FILE}"
|
|
;;
|
|
freedos)
|
|
echo "boot=\"legacy\"" >> "${CONF_FILE}"
|
|
echo "disk_size=\"4G\"" >> "${CONF_FILE}"
|
|
echo "ram=\"256M\"" >> "${CONF_FILE}"
|
|
;;
|
|
kolibrios)
|
|
echo "boot=\"legacy\"" >> "${CONF_FILE}"
|
|
echo "disk_size=\"2G\"" >> "${CONF_FILE}"
|
|
echo "ram=\"128M\"" >> "${CONF_FILE}"
|
|
;;
|
|
truenas-scale|truenas-core)
|
|
echo "boot=\"legacy\"" >> "${CONF_FILE}"
|
|
# the rest is non-functional
|
|
# echo "bootdrive_size=\"5G\"" >> "${CONF_FILE}" # boot drive
|
|
# echo "1stdrive_size=\"20G\"" >> "${CONF_FILE}" # for testing
|
|
# echo "2nddrive_size=\"20G\"" >> "${CONF_FILE}" # again, for testing
|
|
;;
|
|
ubuntu-server)
|
|
# 22.04+ fails on LVM build if disk size is < 10G
|
|
# 22.04.1 fails on auto-install if TPM is disabled
|
|
echo "disk_size=\"10G\"" >> "${CONF_FILE}"
|
|
echo "ram=\"4G\"" >> "${CONF_FILE}"
|
|
if [[ "${RELEASE}" == *"22.04"* ]]; then
|
|
echo "tpm=\"on\"" >> "${CONF_FILE}"
|
|
fi
|
|
;;
|
|
vanillaos)
|
|
## Minimum is 50G for abroot, but a 64GB is allocated to give some headroom
|
|
echo "disk_size=\"64G\"" >> "${CONF_FILE}"
|
|
;;
|
|
zorin)
|
|
case ${EDITION} in
|
|
education64|edulite64)
|
|
echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
|
|
esac
|
|
;;
|
|
reactos)
|
|
echo "boot=\"legacy\"" >> "${CONF_FILE}"
|
|
echo "disk_size=\"12G\"" >> "${CONF_FILE}"
|
|
echo "ram=\"2048M\"" >> "${CONF_FILE}"
|
|
;;
|
|
macos)
|
|
echo "macos_release=\"${RELEASE}\"" >> "${CONF_FILE}"
|
|
# https://github.com/quickemu-project/quickemu/issues/438
|
|
if [ "${RELEASE}" == "monterey" ]; then
|
|
echo "cpu_cores=2" >> "${CONF_FILE}"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if [ "${OS}" == "ubuntu" ] && [[ ${RELEASE} == *"daily"* ]]; then
|
|
# Minimum to install lobster testing is 18GB but 32GB are allocated for headroom
|
|
echo "disk_size=\"32G\"" >> "${CONF_FILE}"
|
|
fi
|
|
# Enable TPM for Windows 11
|
|
if [ "${OS}" == "windows" ] && [ "${RELEASE}" -ge 11 ]; then
|
|
echo "tpm=\"on\"" >> "${CONF_FILE}"
|
|
echo "secureboot=\"off\"" >> "${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="AlmaLinux-${RELEASE}-latest-x86_64-${EDITION}.iso"
|
|
local URL="https://repo.almalinux.org/almalinux/${RELEASE}/isos/x86_64"
|
|
HASH="$(wget -q -O- "${URL}/CHECKSUM" | grep "(${ISO}" | cut -d' ' -f4)"
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_alpine() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
local VERSION=""
|
|
|
|
case ${RELEASE} in
|
|
latest) URL="https://dl-cdn.alpinelinux.org/alpine/latest-stable/releases/x86_64";;
|
|
*) URL="https://dl-cdn.alpinelinux.org/alpine/v${RELEASE}/releases/x86_64";;
|
|
esac
|
|
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"
|
|
HASH=$(wget -qO- "${URL}/latest-releases.yaml" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'sha256:' | awk '{print $2}')
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
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 -4 -q -O- "${URL}" | grep -o -E '[0-9]{5}' | sort -ur); do
|
|
if wget -4 -q -O- "${URL}/${DIR}" | grep "${ISO}" &>/dev/null; then
|
|
URL="${URL}/${DIR}"
|
|
break
|
|
fi
|
|
done
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_antix() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://sourceforge.net/projects/antix-linux/files/Final/antiX-${RELEASE}"
|
|
|
|
case ${RELEASE} in
|
|
21) URL_runit="${URL}/runit-bullseye";;
|
|
*) URL_runit="${URL}/runit-antiX-${RELEASE}";;
|
|
esac
|
|
|
|
case ${EDITION} in
|
|
net-sysv) ISO="antiX-${RELEASE}-net_x64-net.iso";;
|
|
core-sysv) ISO="antiX-${RELEASE}_x64-core.iso";;
|
|
base-sysv) ISO="antiX-${RELEASE}_x64-base.iso";;
|
|
full-sysv) ISO="antiX-${RELEASE}_x64-full.iso";;
|
|
net-runit) ISO="antiX-${RELEASE}-runit-net_x64-net.iso"
|
|
URL="${URL_runit}"
|
|
;;
|
|
core-runit) ISO="antiX-${RELEASE}-runit_x64-core.iso"
|
|
URL="${URL_runit}"
|
|
;;
|
|
base-runit) ISO="antiX-${RELEASE}-runit_x64-base.iso"
|
|
URL="${URL_runit}"
|
|
;;
|
|
full-runit) ISO="antiX-${RELEASE}-runit_x64-full.iso"
|
|
URL="${URL_runit}"
|
|
;;
|
|
esac
|
|
|
|
HASH=$(wget -q -O- ${URL}/README.txt | grep "${ISO}" | cut -d' ' -f1 | head -1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_archlinux() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://mirror.rackspace.com/archlinux"
|
|
ISO=$(wget -q -O- "https://archlinux.org/releng/releases/json/" | jq -r '.releases[0].iso_url')
|
|
HASH=$(wget -q -O- "https://archlinux.org/releng/releases/json/" | jq -r '.releases[0].sha1_sum')
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_archcraft() {
|
|
local HASH=""
|
|
local URL=""
|
|
local TMPURL=""
|
|
|
|
TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/archcraft/files/latest/download" 2>&1 | grep -i Location | cut -d' ' -f4)
|
|
URL=${TMPURL%\?*}
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_arcolinux() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="arcolinux${EDITION:0:1}-${RELEASE}-x86_64.iso"
|
|
local URL="https://ant.seedhost.eu/arcolinux/iso/${RELEASE}"
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha1" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_bunsenlabs() {
|
|
local HASH=""
|
|
local ISO="beryllium-1-amd64.hybrid.iso"
|
|
local URL="https://ddl.bunsenlabs.org/ddl"
|
|
HASH=$(wget -q -O- "${URL}/release.sha256.txt" | head -1 | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_blendos() {
|
|
|
|
local HASH=""
|
|
local URL=""
|
|
|
|
# BlendOS has more editions and releases but there's a tracker indirect and other issues
|
|
# so easier to use the rss feed
|
|
#
|
|
# We have to provide edition/release as RELEASE or have a major refactor
|
|
# But this works for now ... or does it ....
|
|
URL=$(grep ${RELEASE} /tmp/blendos-isos.rss | grep -E -o 'https://.*blendOS\.iso')
|
|
HASH=$(grep ${RELEASE} /tmp/blendos-isos.rss | grep -E -o '[[:alnum:]]{32}')
|
|
# ## fix up variables for path naming
|
|
EDITION=${RELEASE%%/*}
|
|
RELEASE=${RELEASE##*/}
|
|
# For UX maybe show the date of the release
|
|
#echo ${RELEASE##*/} "(" $(date -d @${RELEASE##*/}) ")"
|
|
# maybe $(date -d @${RELEASE##*/} '+%Y%m%d')
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_vanillaos() {
|
|
# maybe use github api and dynamism for R2.0 but for 22.10 just
|
|
# hit their CDN
|
|
#
|
|
# https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.md5.txt
|
|
# https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.sha256.txt
|
|
local HASH=$(curl -s "https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.sha256.txt" | cut -d' ' -f1)
|
|
local URL="https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.iso"
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_batocera() {
|
|
local HASH=""
|
|
local URL="https://mirrors.o2switch.fr/batocera/x86_64/stable/last"
|
|
local ISO="$(curl -sl ${URL}/ | grep -e 'batocera.*img.gz'|cut -d\" -f2)"
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_bodhi() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://sourceforge.net/projects/bodhilinux/files/${RELEASE}"
|
|
|
|
case ${EDITION} in
|
|
standard) ISO="bodhi-${RELEASE}-64.iso";;
|
|
*) ISO="bodhi-${RELEASE}-64-${EDITION}.iso";;
|
|
esac
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_cachyos() {
|
|
local HASH=""
|
|
local ISO="cachyos-${EDITION}-linux-${RELEASE}.iso"
|
|
local URL="https://mirror.cachyos.org/ISO/${EDITION}/${RELEASE}"
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_centos-stream() {
|
|
local HASH=""
|
|
local ISO=""
|
|
case ${RELEASE} in
|
|
8)
|
|
ISO="CentOS-Stream-${RELEASE}-x86_64-latest-${EDITION}.iso"
|
|
URL="https://mirrors.ocf.berkeley.edu/centos/8-stream/isos/x86_64"
|
|
HASH=$(wget -q -O- ${URL}/CHECKSUM | grep "SHA256 (${ISO}" | cut -d' ' -f4)
|
|
;;
|
|
9)
|
|
ISO="CentOS-Stream-${RELEASE}-latest-x86_64-${EDITION}.iso"
|
|
URL="https://mirrors.ocf.berkeley.edu/centos-stream/9-stream/BaseOS/x86_64/iso"
|
|
HASH=$(wget -q -O- ${URL}/${ISO}.SHA256SUM | grep "SHA256 (${ISO}" | cut -d' ' -f4)
|
|
;;
|
|
esac
|
|
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_debian() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="debian-live-${RELEASE}-amd64-${EDITION}.iso"
|
|
local URL=""
|
|
|
|
DEBCURRENT=$(wget -q https://cdimage.debian.org/debian-cd/ -O- |grep '\.[0-9]/'|cut -d\> -f9|cut -d\/ -f1)
|
|
case ${RELEASE} in
|
|
"${DEBCURRENT}") 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
|
|
|
|
if [ "${EDITION}" == "netinst" ]; then
|
|
URL="${URL/-live/}"
|
|
URL="${URL/hybrid/cd}"
|
|
ISO="${ISO/-live/}"
|
|
fi
|
|
|
|
HASH=$(wget -q -O- "${URL}/SHA512SUMS" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_deepin() {
|
|
local HASH=""
|
|
local EDITION=""
|
|
local ISO="deepin-desktop-community-${RELEASE}-amd64.iso"
|
|
# deepin-desktop-community-20.3-amd64.iso
|
|
local URL="https://cdimage.deepin.com/releases/"${RELEASE}
|
|
|
|
# fix iso name
|
|
if [[ "${RELEASE}" == *"20" ]] ; then
|
|
EDITION="1003"
|
|
ISO="deepin-desktop-community-${EDITION}-amd64.iso"
|
|
elif [[ "${RELEASE}" == *"20.1" ]]; then
|
|
EDITION="1010"
|
|
ISO="deepin-desktop-community-${EDITION}-amd64.iso"
|
|
fi
|
|
|
|
HASH=$(wget -q -O- "${URL}/SHA256SUMS" | grep "${ISO}" | cut -d' ' -f1)
|
|
|
|
#echo "${URL}/${ISO} ${HASH}"
|
|
web_get "${URL}/${ISO}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_devuan() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://files.devuan.org/devuan_${RELEASE}/desktop-live"
|
|
|
|
case ${RELEASE} in
|
|
beowulf) ISO="devuan_${RELEASE}_3.1.1_amd64_desktop-live.iso";;
|
|
chimaera) ISO="devuan_${RELEASE}_4.0.2_amd64_desktop-live.iso";;
|
|
daedalus) ISO="devuan_${RELEASE}_5.0.0_amd64_desktop-live.iso";;
|
|
esac
|
|
HASH=$(wget -q -O- "${URL}/SHASUMS.txt" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_dragonflybsd() {
|
|
local HASH=""
|
|
local ISO="dfly-x86_64-${RELEASE}_REL.iso.bz2"
|
|
local URL="http://mirror-master.dragonflybsd.org/iso-images"
|
|
|
|
HASH=$(wget -q -O- "${URL}/md5.txt" | grep "(${ISO})" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_easyos() {
|
|
local HASH=""
|
|
local URL="https://distro.ibiblio.org/easyos/amd64/releases/kirkstone/2023/${RELEASE}"
|
|
local ISO="easy-${RELEASE}-amd64.img"
|
|
|
|
HASH=$(wget -q -O- "${URL}/md5.sum.txt" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_elementary() {
|
|
local HASH=""
|
|
case ${RELEASE} in
|
|
7.0)
|
|
local ISO="elementaryos-${RELEASE}-stable.20230129rc.iso"
|
|
;;
|
|
7.1)
|
|
local ISO="elementaryos-${RELEASE}-stable.20230926rc.iso"
|
|
HASH="5c7f6b388e5787c366587985301ea05ab16e4cc0de3be2b3d6a559ce81a2f102"
|
|
;;
|
|
esac
|
|
local URL="https://ams3.dl.elementary.io/download"
|
|
echo "${URL}/$(date +%s | base64)/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_endeavouros() {
|
|
local HASH=""
|
|
# Endeavour release names are Capitalized and our $RELEASE is forced to lowercase so we have to revert it
|
|
local ISO="EndeavourOS_${RELEASE@u}.iso"
|
|
local URL="https://github.com/endeavouros-team/ISO/releases/download/1-EndeavourOS-ISO-releases-archive"
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha512sum" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_endless() {
|
|
local HASH="" # No hash - there is a signature in .asc signed by
|
|
#https://d1anzknqnc1kmb.cloudfront.net/eos-image-keyring.gpg
|
|
# (4096R: CB50 0F7B C923 3FAD 32B4 E720 9E0C 1250 587A 279C)
|
|
local FILE_TS=""
|
|
# https://support.endlessos.org/en/installation/direct-download gives the info but computes the URLS in js
|
|
# so parsing out the useful info is not happening tonight
|
|
# Endless edition names are "base" for the small minimal one or the Language for the large full release
|
|
# The isos are stamped as they are finished so ....
|
|
case ${EDITION} in
|
|
base)
|
|
FILE_TS="230127-211122";;
|
|
fr)
|
|
FILE_TS="230127-213415";;
|
|
en)
|
|
FILE_TS="230127-212436";;
|
|
es)
|
|
FILE_TS="230127-212646";;
|
|
pt_BR)
|
|
FILE_TS="230127-220328";;
|
|
esac
|
|
|
|
URL="https://images-dl.endlessm.com/release/${RELEASE}/eos-amd64-amd64/${EDITION}"
|
|
ISO="eos-eos${RELEASE:0:3}-amd64-amd64.${FILE_TS}.${EDITION}.iso"
|
|
|
|
echo "${URL}/${ISO}"
|
|
}
|
|
|
|
function get_fedora() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local JSON=""
|
|
local URL=""
|
|
local VARIANT=""
|
|
|
|
case ${EDITION} in
|
|
Server|Kinoite|Onyx|Silverblue|Sericea|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)
|
|
HASH=$(echo "${JSON}" | jq -r '.sha256' | head -n1)
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_freebsd() {
|
|
local EDITION="${1}"
|
|
local HASH=""
|
|
local ISO="FreeBSD-${RELEASE}-RELEASE-amd64-${EDITION}.iso"
|
|
local URL="https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}"
|
|
|
|
HASH=$(wget -q -O- "${URL}/CHECKSUM.SHA256-FreeBSD-${RELEASE}-RELEASE-amd64" | grep "${ISO}" | grep -v ".xz" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_freedos() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="http://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/distributions/${RELEASE}/official"
|
|
|
|
case ${RELEASE} in
|
|
1.2)
|
|
ISO="FD12CD.iso"
|
|
HASH=$(wget -q -O- "${URL}/FD12.sha" | grep "${ISO}" | cut -d' ' -f1)
|
|
;;
|
|
1.3)
|
|
ISO="FD13-LiveCD.zip"
|
|
HASH=$(wget -q -O- "${URL}/verify.txt" | grep -A 8 "sha256sum" | grep "${ISO}" | cut -d' ' -f1)
|
|
;;
|
|
esac
|
|
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_garuda() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://iso.builds.garudalinux.org/iso/latest/garuda"
|
|
|
|
ISO=${EDITION}/latest.iso
|
|
|
|
HASH="$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)"
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
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 -A 1 SHA512 | grep iso | grep -v CONTENTS | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_ghostbsd() {
|
|
local EDITION="${1:-}"
|
|
local ISO=""
|
|
local URL="https://download.ghostbsd.org/releases/amd64/${RELEASE}"
|
|
local HASH=""
|
|
|
|
case ${EDITION} in
|
|
mate) ISO="GhostBSD-${RELEASE}.iso";;
|
|
xfce) ISO="GhostBSD-${RELEASE}-XFCE.iso";;
|
|
esac
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_haiku() {
|
|
local EDITION="${1:-}"
|
|
local ISO="haiku-${RELEASE}-${EDITION}-anyboot.iso"
|
|
# local URL="https://cdn.haiku-os.org/haiku-release/${RELEASE}" # domain gone
|
|
local URL="http://mirror.rit.edu/haiku/${RELEASE}" # NY, USA
|
|
# local URL="https://mirrors.tnonline.net/haiku/haiku-release/${RELEASE}" # Sweden
|
|
# local URL="https://mirror.aarnet.edu.au/pub/haiku/${RELEASE}" # Aus
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_holoiso() {
|
|
#local HASH=""
|
|
local ISO=$(wget -q -O- "https://api.github.com/repos/HoloISO/holoiso/releases" | sed 's/ /\n/g' | grep "HoloISO_${RELEASES}" | cut -d'\' -f1 | cut -d'/' -f4)
|
|
local URL="https://cd2.holoiso.ru.eu.org"
|
|
# Can't find hash
|
|
#HASH=$(wget -q -O- "${URL}/${ISO}.sha256sum" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} #${HASH}"
|
|
}
|
|
|
|
function get_kali() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://cdimage.kali.org/${RELEASE}"
|
|
|
|
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)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_kdeneon() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local 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)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_kolibrios() {
|
|
local HASH=""
|
|
local ISO="kolibri.iso"
|
|
local URL="https://builds.kolibrios.org/eng"
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_linuxlite() {
|
|
local HASH=""
|
|
local ISO="linux-lite-${RELEASE}-64bit.iso"
|
|
local URL="https://sourceforge.net/projects/linux-lite/files/${RELEASE}"
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_linuxmint() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="linuxmint-${RELEASE}-${EDITION}-64bit.iso"
|
|
local URL="https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}"
|
|
|
|
HASH=$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_lmde() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="lmde-${RELEASE}-${EDITION}-64bit.iso"
|
|
local URL="https://mirror.bytemark.co.uk/linuxmint/debian"
|
|
|
|
HASH=$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_macos() {
|
|
local BOARD_ID=""
|
|
local CWD=""
|
|
local MACRECOVERY=""
|
|
local MLB="00000000000000000"
|
|
local OS_TYPE="default"
|
|
|
|
case ${RELEASE} in
|
|
lion) #10.7
|
|
BOARD_ID="Mac-2E6FAB96566FE58C"
|
|
MLB="00000000000F25Y00";;
|
|
mountainlion) #10.8
|
|
BOARD_ID="Mac-7DF2A3B5E5D671ED"
|
|
MLB="00000000000F65100";;
|
|
mavericks) #10.9
|
|
BOARD_ID="Mac-F60DEB81FF30ACF6"
|
|
MLB="00000000000FNN100";;
|
|
yosemite) #10.10
|
|
BOARD_ID="Mac-E43C1C25D4880AD6"
|
|
MLB="00000000000GDVW00";;
|
|
elcapitan) #10.11
|
|
BOARD_ID="Mac-FFE5EF870D7BA81A"
|
|
MLB="00000000000GQRX00";;
|
|
sierra) #10.12
|
|
BOARD_ID="Mac-77F17D7DA9285301"
|
|
MLB="00000000000J0DX00";;
|
|
high-sierra) #10.13
|
|
BOARD_ID="Mac-BE088AF8C5EB4FA2"
|
|
MLB="00000000000J80300";;
|
|
mojave) #10.14
|
|
BOARD_ID="Mac-7BA5B2DFE22DDD8C"
|
|
MLB="00000000000KXPG00";;
|
|
catalina) #10.15
|
|
BOARD_ID="Mac-00BE6ED71E35EB86";;
|
|
big-sur) #11
|
|
BOARD_ID="Mac-42FD25EABCABB274";;
|
|
monterey) #12
|
|
BOARD_ID="Mac-E43C1C25D4880AD6";;
|
|
ventura) #13
|
|
BOARD_ID="Mac-BE088AF8C5EB4FA2";;
|
|
*) 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-1920x1080.fd" ]; then
|
|
web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_VARS-1920x1080.fd" "${VM_PATH}"
|
|
fi
|
|
|
|
if [ ! -e "${VM_PATH}/RecoveryImage.chunklist" ]; then
|
|
echo "Downloading ${RELEASE}..."
|
|
${MACRECOVERY} \
|
|
--board-id "${BOARD_ID}" \
|
|
--mlb "${MLB}" \
|
|
--os-type "${OS_TYPE}" \
|
|
--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" 2>/dev/null
|
|
fi
|
|
|
|
make_vm_config RecoveryImage.img
|
|
}
|
|
|
|
function get_mageia() {
|
|
local EDITION="${1:-}"
|
|
local ISO=$(wget -q https://www.mageia.org/en/downloads/get/?q="Mageia-${RELEASE}-Live-${EDITION}-x86_64.iso" -O- | grep 'click here'| grep -o 'href=.*\.iso'|cut -d\" -f2)
|
|
local HASH=$(wget -q -O- "${ISO}.sha512" | cut -d' ' -f1)
|
|
echo "${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_manjaro() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local MANIFEST=""
|
|
local URL=""
|
|
local TYPE=""
|
|
|
|
case ${RELEASE} in
|
|
sway) MANIFEST="$( wget -qO- https://mirror.manjaro-sway.download/manjaro-sway/release.json )";;
|
|
gnome|xfce|plasma) TYPE="official";;
|
|
*) TYPE="community";;
|
|
esac
|
|
|
|
[[ ${RELEASE} != "sway" ]] && MANIFEST="$(wget -qO- https://gitlab.manjaro.org/web/iso-info/-/raw/master/file-info.json)"
|
|
|
|
[[ ${EDITION} == "minimal" && ${TYPE} != "sway" ]] && EDITION=".minimal" || EDITION=""
|
|
|
|
if [[ ${RELEASE} != "sway" ]]; then
|
|
URL="$(echo ${MANIFEST} | jq -r .${TYPE}.${RELEASE}${EDITION}.image)"
|
|
else
|
|
URL=$(echo ${MANIFEST} | jq -r '.[] | select(.name|test("^manjaro-sway-.*[.]iso$")) | select(.name|contains("unstable")|not) | .url')
|
|
fi
|
|
|
|
HASH=$(wget -qO- "${URL}.sha512" | cut -d' ' -f1)
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_mxlinux() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://sourceforge.net/projects/mx-linux/files/Final/${EDITION}"
|
|
|
|
case ${EDITION} in
|
|
Xfce) ISO="MX-${RELEASE}_x64.iso";;
|
|
KDE) ISO="MX-${RELEASE}_KDE_x64.iso";;
|
|
Fluxbox) ISO="MX-${RELEASE}_fluxbox_x64.iso";;
|
|
esac
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
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)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_netbsd() {
|
|
local HASH=""
|
|
local ISO="NetBSD-${RELEASE}-amd64.iso"
|
|
local URL="https://cdn.netbsd.org/pub/NetBSD/NetBSD-${RELEASE}/images/"
|
|
HASH=$(wget -q -O- "${URL}/MD5" | grep "${ISO}" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_nixos() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="latest-nixos-${EDITION}-x86_64-linux.iso"
|
|
local URL="https://channels.nixos.org/nixos-${RELEASE}"
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_openbsd() {
|
|
local HASH=""
|
|
local ISO="install${RELEASE//\./}.iso"
|
|
local URL="https://mirror.leaseweb.com/pub/OpenBSD/${RELEASE}/amd64"
|
|
HASH=$(wget -q -O- "${URL}/SHA256" | grep "${ISO}" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_openindiana(){
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
URL="https://dlc.openindiana.org/isos/hipster/${RELEASE}"
|
|
ISO="OI-hipster-${EDITION}-${RELEASE}.iso"
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" |cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
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"
|
|
elif [ "${RELEASE}" == "microos" ]; then
|
|
ISO="openSUSE-MicroOS-DVD-x86_64-Current.iso"
|
|
URL="https://download.opensuse.org/tumbleweed/iso"
|
|
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"
|
|
else
|
|
ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64-Current.iso"
|
|
URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso"
|
|
fi
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" |awk '{if(NR==4) print $0}'|cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_oraclelinux() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local VER_MAJ=${RELEASE::1}
|
|
local VER_MIN=${RELEASE:2:1}
|
|
local URL="https://yum.oracle.com/ISOS/OracleLinux/OL${VER_MAJ}/u${VER_MIN}/x86_64/"
|
|
|
|
case ${VER_MAJ} in
|
|
7) ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64-dvd.iso";;
|
|
*) ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-x86_64-dvd.iso";;
|
|
esac
|
|
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)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_peppermint() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://sourceforge.net/projects/peppermintos/files/isos"
|
|
|
|
case ${EDITION} in
|
|
devuan-xfce) ISO="PeppermintOS-devuan_64_xfce.iso"
|
|
URL="${URL}/XFCE"
|
|
;;
|
|
debian-xfce) ISO="PeppermintOS-Debian-64.iso"
|
|
URL="${URL}/XFCE"
|
|
;;
|
|
devuan-gnome) ISO="PeppermintOS-devuan_64_gfb.iso"
|
|
URL="${URL}/Gnome_FlashBack"
|
|
;;
|
|
debian-gnome) ISO="PeppermintOS-Debian_64_gfb.iso"
|
|
URL="${URL}/Gnome_FlashBack"
|
|
;;
|
|
esac
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}-sha512.checksum" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
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)
|
|
HASH=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .sha_sum)
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_porteus() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
edition="${EDITION~~}"
|
|
ISO="Porteus-${edition}-v${RELEASE}-x86_64.iso"
|
|
URL="https://mirrors.dotsrc.org/porteus/x86_64/Porteus-v${RELEASE}"
|
|
HASH=$(wget -q -O- "${URL}/sha256sums.txt" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_reactos() {
|
|
local HASH=""
|
|
local URL=""
|
|
local TMPURL=""
|
|
|
|
TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/reactos/files/latest/download" 2>&1 | grep -i Location | cut -d' ' -f4)
|
|
URL=${TMPURL%\?*}
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_rockylinux() {
|
|
local EDITION="${1:-}"
|
|
if [[ "${RELEASE}" =~ ^8. ]] && [[ "${EDITION}" == "dvd" ]]
|
|
then
|
|
EDITION="dvd1"
|
|
fi
|
|
local HASH=""
|
|
local ISO="Rocky-${RELEASE}-x86_64-${EDITION}.iso"
|
|
local URL=""
|
|
|
|
case ${RELEASE} in
|
|
9.1) URL="https://download.rockylinux.org/pub/rocky/9/isos/x86_64";;
|
|
8.7) URL="https://download.rockylinux.org/pub/rocky/8/isos/x86_64";;
|
|
*) URL="http://dl.rockylinux.org/vault/rocky/${RELEASE}/isos/x86_64";;
|
|
esac
|
|
HASH=$(wget -q -O- "${URL}/CHECKSUM" | grep "SHA256" | grep "${ISO})" | cut -d' ' -f4)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_siduction() {
|
|
local HASH=""
|
|
local DATE=""
|
|
local ISO=""
|
|
local URL="https://mirrors.dotsrc.org/siduction/iso/Standing_on_the_Shoulders_of_Giants/${EDITION}"
|
|
DATE=$(wget -q -O- "${URL}"| grep .iso.md5 | cut -d'-' -f6 | cut -d'.' -f1)
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.md5" | cut -d' ' -f1)
|
|
ISO="siduction-2023.1.1-Standing_on_the_Shoulders_of_Giants-${EDITION}-amd64-${DATE}.iso"
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_slackware() {
|
|
local HASH=""
|
|
local ISO="slackware64-${RELEASE}-install-dvd.iso"
|
|
local URL="https://slackware.nl/slackware/slackware-iso/slackware64-${RELEASE}-iso"
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.md5" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_solus() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="Solus-${RELEASE}-${EDITION}.iso"
|
|
local URL="https://mirrors.rit.edu/solus/images/${RELEASE}"
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256sum" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_spiral() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO="SpiralLinux_${EDITION}_12.231005_x86-64.iso"
|
|
local URL="https://sourceforge.net/projects/spirallinux/files/12.231005"
|
|
|
|
HASH=$(wget -q -O- 'https://sourceforge.net/projects/spirallinux/rss?path=/' | grep "${ISO}" | grep 'md5' | cut -d'<' -f3 | cut -d'>' -f2)
|
|
echo "${URL}/${ISO}" "${HASH}"
|
|
}
|
|
|
|
function get_tails() {
|
|
local ISO=""
|
|
local JSON=""
|
|
local HASH=""
|
|
local URL=""
|
|
|
|
JSON="$(wget -q -O- "https://tails.boum.org/install/v2/Tails/amd64/${RELEASE}/latest.json")"
|
|
URL=$(echo "${JSON}" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].url')
|
|
HASH=$(echo "${JSON}" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].sha256')
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_tinycore() {
|
|
local HASH=""
|
|
local ISO="${EDITION}-${RELEASE}.iso"
|
|
local URL=""
|
|
|
|
if [ "${EDITION}" == "Core" ] || [ "${EDITION}" == "TinyCore" ] || [ "${EDITION}" == "CorePlus" ]; then
|
|
URL="http://www.tinycorelinux.net/14.x/x86/release"
|
|
elif [ "${EDITION}" == "CorePure64" ] || [ "${EDITION}" == "TinyCorePure64" ]; then
|
|
URL="http://www.tinycorelinux.net/14.x/x86_64/release"
|
|
fi
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.md5.txt" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_trisquel() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL="https://mirrors.ocf.berkeley.edu/trisquel-images"
|
|
|
|
case ${EDITION} in
|
|
mate) ISO="trisquel_${RELEASE}_amd64.iso";;
|
|
lxde) ISO="trisquel-mini_${RELEASE}_amd64.iso";;
|
|
kde) ISO="triskel_${RELEASE}_amd64.iso";;
|
|
sugar) ISO="trisquel-sugar_${RELEASE}_amd64.iso";;
|
|
esac
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha1" | grep "${ISO}" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_truenas-scale() {
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
local DLINFO="https://www.truenas.com/download-truenas-scale/"
|
|
|
|
URL=$(wget -q ${DLINFO} -O- | grep -o "\"https://.*${RELEASE}.*\.iso\""|cut -d\" -f2)
|
|
HASH=$(wget -q ${URL}.sha256 -O- | cut -d' ' -f1 )
|
|
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_truenas-core() {
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
local DLINFO="https://www.truenas.com/download-truenas-core/"
|
|
URL=$(wget -q ${DLINFO} -O- | grep -o "\"https://.*${RELEASE}.*\.iso\""|cut -d\" -f2)
|
|
HASH=$(wget -q ${URL}.sha256 -O- | cut -d' ' -f1)
|
|
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
function get_ubuntu-server() {
|
|
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
[[ $RELEASE = daily ]] && RELEASE=daily-live
|
|
|
|
if [[ "${RELEASE}" == "daily"* ]]; then
|
|
URL="https://cdimage.ubuntu.com/${OS}/${RELEASE}/current"
|
|
else
|
|
URL="https://releases.ubuntu.com/${RELEASE}"
|
|
fi
|
|
|
|
if wget -q --spider "${URL}/SHA256SUMS"; then
|
|
DATA=$(wget -qO- "${URL}/SHA256SUMS" | grep 'live-server' | grep amd64 | grep iso)
|
|
ISO=$(cut -d'*' -f2 <<<${DATA})
|
|
HASH=$(cut -d' ' -f1 <<<${DATA})
|
|
else
|
|
DATA=$(wget -qO- "${URL}/MD5SUMS" | grep 'live-server' | grep amd64 | grep iso)
|
|
ISO=$(cut -d' ' -f3 <<<${DATA})
|
|
HASH=$(cut -d' ' -f1 <<<${DATA})
|
|
fi
|
|
|
|
if [ -z $ISO ] || [ -z $HASH ]; then
|
|
echo "$(pretty_name $OS) ${RELEASE} is currently unavailable. Please select other OS/Release combination"
|
|
exit 1
|
|
fi
|
|
|
|
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_ubuntu() {
|
|
local ISO=""
|
|
local HASH=""
|
|
local URL=""
|
|
local DATA=""
|
|
|
|
[[ $RELEASE = daily ]] && RELEASE=daily-live
|
|
|
|
if [[ "${RELEASE}" == "daily"* ]] && [ "${OS}" == "ubuntustudio" ]; then
|
|
# Ubuntu Studio daily-live images are in the dvd directory
|
|
RELEASE="dvd"
|
|
fi
|
|
|
|
if [[ "${RELEASE}" == "eol-"* ]]; then
|
|
URL="https://old-releases.ubuntu.com/releases/${RELEASE/eol-/}"
|
|
elif [[ "${RELEASE}" == "jammy-daily" ]]; then
|
|
if [[ "${OS}" == "ubuntustudio" ]]; then
|
|
URL="https://cdimage.ubuntu.com/${OS}/jammy/dvd/current"
|
|
else
|
|
URL="https://cdimage.ubuntu.com/${OS}/jammy/daily-live/current"
|
|
fi
|
|
VM_PATH="${OS}-jammy-live"
|
|
elif [[ "${RELEASE}" == "daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
|
|
URL="https://cdimage.ubuntu.com/${OS}/${RELEASE}/current"
|
|
VM_PATH="${OS}-${RELEASE}"
|
|
elif [ "${OS}" == "ubuntu" ]; then
|
|
URL="https://releases.ubuntu.com/${RELEASE}"
|
|
else
|
|
URL="https://cdimage.ubuntu.com/${OS}/releases/${RELEASE}/release"
|
|
fi
|
|
|
|
if wget -q --spider "${URL}/SHA256SUMS"; then
|
|
DATA=$(wget -qO- "${URL}/SHA256SUMS" | grep 'desktop\|dvd\|install' | grep amd64 | grep iso | grep -v "+mac")
|
|
ISO=$(cut -d'*' -f2 <<<${DATA} | sed '1q;d')
|
|
HASH=$(cut -d' ' -f1 <<<${DATA} | sed '1q;d')
|
|
else
|
|
DATA=$(wget -qO- "${URL}/MD5SUMS" | grep 'desktop\|dvd\|install' | grep amd64 | grep iso | grep -v "+mac")
|
|
ISO=$(cut -d'*' -f2 <<<${DATA})
|
|
HASH=$(cut -d' ' -f1 <<<${DATA})
|
|
fi
|
|
|
|
if [ -z $ISO ] || [ -z $HASH ]; then
|
|
echo "$(pretty_name $OS) ${RELEASE} is currently unavailable. Please select other OS/Release combination"
|
|
exit 1
|
|
fi
|
|
|
|
if [[ "${RELEASE}" == "daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
|
|
zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-devel.iso"
|
|
make_vm_config "${OS}-devel.iso"
|
|
elif [[ "${RELEASE}" == "jammy-daily" ]]; then
|
|
zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-jammy-live.iso"
|
|
make_vm_config "${OS}-jammy-live.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://repo-default.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}-base.iso";;
|
|
musl) ISO="void-live-x86_64-musl-${DATE}-base.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)"
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_vxlinux() {
|
|
local HASH=""
|
|
local ISO="vx-${RELEASE}.iso"
|
|
local URL="https://github.com/VX-Linux/main/releases/download/${RELEASE}"
|
|
|
|
HASH=$(wget -q -O- "${URL}/vx-${RELEASE}.md5" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_xerolinux() {
|
|
local HASH=""
|
|
local URL=""
|
|
local ISO="xerolinux-2022.12-x86_64.iso"
|
|
local URL="https://sourceforge.net/projects/xerolinux/files/Releases"
|
|
|
|
HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
|
|
echo "${URL}/${ISO} ${HASH}"
|
|
}
|
|
|
|
function get_zorin() {
|
|
local EDITION="${1:-}"
|
|
local HASH=""
|
|
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)
|
|
echo "${URL} ${HASH}"
|
|
}
|
|
|
|
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-LUA-Settings" 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">
|
|
<EnableLUA>false</EnableLUA>
|
|
</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>
|
|
</component>
|
|
</settings>
|
|
|
|
<settings pass="generalize">
|
|
<component name="Microsoft-Windows-PnPSysprep" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS">
|
|
<PersistAllDeviceInstalls>true</PersistAllDeviceInstalls>
|
|
</component>
|
|
<component name="Microsoft-Windows-Security-SPP" 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">
|
|
<SkipRearm>1</SkipRearm>
|
|
</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>
|
|
<ProductKey>W269N-WFGWX-YVC9B-4J6C9-T83GX</ProductKey>
|
|
</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>
|
|
<FullName>Quickemu</FullName>
|
|
<Organization>Quickemu Project</Organization>
|
|
<!-- https://docs.microsoft.com/en-us/windows-server/get-started/kms-client-activation-keys -->
|
|
<ProductKey>
|
|
<Key>W269N-WFGWX-YVC9B-4J6C9-T83GX</Key>
|
|
<WillShowUI>Never</WillShowUI>
|
|
</ProductKey>
|
|
</UserData>
|
|
</component>
|
|
|
|
<component name="Microsoft-Windows-PnpCustomizationsWinPE" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
|
|
<!--
|
|
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">
|
|
<AutoLogon>
|
|
<Password>
|
|
<Value>quickemu</Value>
|
|
<PlainText>true</PlainText>
|
|
</Password>
|
|
<Enabled>true</Enabled>
|
|
<Username>Quickemu</Username>
|
|
</AutoLogon>
|
|
<DisableAutoDaylightTimeSet>false</DisableAutoDaylightTimeSet>
|
|
<OOBE>
|
|
<HideEULAPage>true</HideEULAPage>
|
|
<HideLocalAccountScreen>true</HideLocalAccountScreen>
|
|
<HideOEMRegistrationScreen>true</HideOEMRegistrationScreen>
|
|
<HideOnlineAccountScreens>true</HideOnlineAccountScreens>
|
|
<HideWirelessSetupInOOBE>true</HideWirelessSetupInOOBE>
|
|
<NetworkLocation>Home</NetworkLocation>
|
|
<ProtectYourPC>3</ProtectYourPC>
|
|
<SkipUserOOBE>true</SkipUserOOBE>
|
|
<SkipMachineOOBE>true</SkipMachineOOBE>
|
|
<VMModeOptimizations>
|
|
<SkipWinREInitialization>true</SkipWinREInitialization>
|
|
</VMModeOptimizations>
|
|
</OOBE>
|
|
<UserAccounts>
|
|
<LocalAccounts>
|
|
<LocalAccount wcm:action="add">
|
|
<Password>
|
|
<Value>quickemu</Value>
|
|
<PlainText>true</PlainText>
|
|
</Password>
|
|
<Description>Quickemu</Description>
|
|
<DisplayName>Quickemu</DisplayName>
|
|
<Group>Administrators</Group>
|
|
<Name>Quickemu</Name>
|
|
</LocalAccount>
|
|
</LocalAccounts>
|
|
</UserAccounts>
|
|
<RegisteredOrganization>Quickemu Project</RegisteredOrganization>
|
|
<RegisteredOwner>Quickemu</RegisteredOwner>
|
|
<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
|
|
}
|
|
|
|
handle_curl_error() {
|
|
local error_code="$1"
|
|
|
|
local fatal_error_action=2
|
|
|
|
case "$error_code" in
|
|
6)
|
|
echo "Failed to resolve Microsoft servers! Is there an Internet connection? Exiting..."
|
|
return "$fatal_error_action"
|
|
;;
|
|
7)
|
|
echo "Failed to contact Microsoft servers! Is there an Internet connection or is the server down?"
|
|
;;
|
|
23)
|
|
echo "Failed at writing Windows media to disk! Out of disk space or permission error? Exiting..."
|
|
return "$fatal_error_action"
|
|
;;
|
|
26)
|
|
echo "Ran out of memory during download! Exiting..."
|
|
return "$fatal_error_action"
|
|
;;
|
|
36)
|
|
echo "Failed to continue earlier download!"
|
|
;;
|
|
22)
|
|
echo "Microsoft servers returned failing HTTP status code!"
|
|
;;
|
|
# POSIX defines exit statuses 1-125 as usable by us
|
|
# https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_08_02
|
|
$((error_code <= 125)))
|
|
# Must be some other server error (possibly with this specific request/file)
|
|
# This is when accounting for all possible errors in the curl manual assuming a correctly formed curl command and HTTP(S) request, using only the curl features we're using, and a sane build
|
|
echo "Server returned an error status!"
|
|
;;
|
|
126 | 127)
|
|
echo "Curl command not found! Please install curl and try again. Exiting..."
|
|
return "$fatal_error_action"
|
|
;;
|
|
# Exit statuses are undefined by POSIX beyond this point
|
|
*)
|
|
case "$(kill -l "$error_code")" in
|
|
# Signals defined to exist by POSIX:
|
|
# https://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
|
|
INT)
|
|
echo "Curl was interrupted!"
|
|
;;
|
|
# There could be other signals but these are most common
|
|
SEGV | ABRT)
|
|
echo "Curl crashed! Failed exploitation attempt? Please report any core dumps to curl developers. Exiting..."
|
|
return "$fatal_error_action"
|
|
;;
|
|
*)
|
|
echo "Curl terminated due to a fatal signal!"
|
|
;;
|
|
esac
|
|
esac
|
|
|
|
return 1
|
|
}
|
|
|
|
function download_windows() {
|
|
# Download newer consumer Windows versions from behind gated Microsoft API
|
|
# This function aims to precisely emulate what Fido does down to the URL requests and HTTP headers (exceptions: updated user agent and referer adapts to Windows version instead of always being "windows11") but written in POSIX sh (with coreutils) and curl instead of PowerShell (also simplified to greatly reduce attack surface)
|
|
# However, differences such as the order of HTTP headers and TLS stacks (could be used to do TLS fingerprinting) still exist
|
|
#
|
|
# Command translated: ./Fido -Win 10 -Lang English -Verbose
|
|
# "English" = "English (United States)" (as opposed to the default "English (International)")
|
|
# For testing Fido, replace all "https://" with "http://" and remove all instances of "-MaximumRedirection 0" (to allow redirection of HTTP traffic to HTTPS) so HTTP requests can easily be inspected in Wireshark
|
|
# Fido (command-line only) works under PowerShell for Linux if that makes it easier for you
|
|
# UPDATE: Fido v1.4.2+ no longer works without being edited on Linux due to these issues on the Fido GitHub repo (and possibly others after these): #56 and #58
|
|
#
|
|
# If this function in Mido fails to work for you then please test with the Fido script before creating an issue because we basically just copy what Fido does exactly:
|
|
# https://github.com/pbatard/Fido
|
|
|
|
# Either 8, 10, or 11
|
|
local windows_version="$1"
|
|
|
|
local url="https://www.microsoft.com/en-us/software-download/windows$windows_version"
|
|
case "$windows_version" in
|
|
8 | 10) url="${url}ISO";;
|
|
esac
|
|
|
|
local user_agent="Mozilla/5.0 (X11; Linux x86_64; rv:100.0) Gecko/20100101 Firefox/100.0"
|
|
# uuidgen: For MacOS (installed by default) and other systems (e.g. with no /proc) that don't have a kernel interface for generating random UUIDs
|
|
local session_id="$(cat /proc/sys/kernel/random/uuid 2> /dev/null || uuidgen --random)"
|
|
|
|
# Get product edition ID for latest release of given Windows version
|
|
# Product edition ID: This specifies both the Windows release (e.g. 22H2) and edition ("multi-edition" is default, either Home/Pro/Edu/etc., we select "Pro" in the answer files) in one number
|
|
# This is the *only* request we make that Fido doesn't. Fido manually maintains a list of all the Windows release/edition product edition IDs in its script (see: $WindowsVersions array). This is helpful for downloading older releases (e.g. Windows 10 1909, 21H1, etc.) but we always want to get the newest release which is why we get this value dynamically
|
|
# Also, keeping a "$WindowsVersions" array like Fido does would be way too much of a maintenance burden
|
|
# Remove "Accept" header that curl sends by default
|
|
local iso_download_page_html="$(curl --silent --user-agent "$user_agent" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "$url")" || {
|
|
handle_curl_error $?
|
|
return $?
|
|
}
|
|
|
|
# Limit untrusted size for input validation
|
|
iso_download_page_html="$(echo "$iso_download_page_html" | head -c 102400)"
|
|
# tr: Filter for only numerics to prevent HTTP parameter injection
|
|
# head -c was recently added to POSIX: https://austingroupbugs.net/view.php?id=407
|
|
local product_edition_id="$(echo "$iso_download_page_html" | grep -Eo '<option value="[0-9]+">Windows' | cut -d '"' -f 2 | head -n 1 | tr -cd '0-9' | head -c 16)"
|
|
echo " - Product edition ID: $product_edition_id"
|
|
|
|
# Permit Session ID
|
|
# "org_id" is always the same value
|
|
curl --silent --output /dev/null --user-agent "$user_agent" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "https://vlscppe.microsoft.com/tags?org_id=y6jn8c31&session_id=$session_id" || {
|
|
# This should only happen if there's been some change to how this API works (copy whatever fix Fido implements)
|
|
handle_curl_error $?
|
|
return $?
|
|
}
|
|
|
|
# Extract everything after the last slash
|
|
local url_segment_parameter="${url##*/}"
|
|
|
|
# Get language -> skuID association table
|
|
# SKU ID: This specifies the language of the ISO. We always use "English (United States)", however, the SKU for this changes with each Windows release
|
|
# We must make this request so our next one will be allowed
|
|
# --data "" is required otherwise no "Content-Length" header will be sent causing HTTP response "411 Length Required"
|
|
local language_skuid_table_html="$(curl --silent --request POST --user-agent "$user_agent" --data "" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "https://www.microsoft.com/en-US/api/controls/contentinclude/html?pageId=a8f8f489-4c7f-463a-9ca6-5cff94d8d041&host=www.microsoft.com&segments=software-download,$url_segment_parameter&query=&action=getskuinformationbyproductedition&sessionId=$session_id&productEditionId=$product_edition_id&sdVersion=2")" || {
|
|
handle_curl_error $?
|
|
return $?
|
|
}
|
|
|
|
# Limit untrusted size for input validation
|
|
language_skuid_table_html="$(echo "$language_skuid_table_html" | head -c 10240)"
|
|
# tr: Filter for only alphanumerics or "-" to prevent HTTP parameter injection
|
|
local sku_id="$(echo "$language_skuid_table_html" | grep "English (United States)" | sed 's/"//g' | cut -d ',' -f 1 | cut -d ':' -f 2 | tr -cd '[:alnum:]-' | head -c 16)"
|
|
echo " - SKU ID: $sku_id"
|
|
|
|
# Get ISO download link
|
|
# If any request is going to be blocked by Microsoft it's always this last one (the previous requests always seem to succeed)
|
|
# --referer: Required by Microsoft servers to allow request
|
|
local iso_download_link_html="$(curl --silent --request POST --user-agent "$user_agent" --data "" --referer "$url" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "https://www.microsoft.com/en-US/api/controls/contentinclude/html?pageId=6e2a1789-ef16-4f27-a296-74ef7ef5d96b&host=www.microsoft.com&segments=software-download,$url_segment_parameter&query=&action=GetProductDownloadLinksBySku&sessionId=$session_id&skuId=$sku_id&language=English&sdVersion=2")" || {
|
|
# This should only happen if there's been some change to how this API works
|
|
handle_curl_error $?
|
|
return $?
|
|
}
|
|
|
|
local failed=0
|
|
|
|
# Limit untrusted size for input validation
|
|
iso_download_link_html="$(echo "$iso_download_link_html" | head -c 4096)"
|
|
|
|
if ! [ "$iso_download_link_html" ]; then
|
|
# This should only happen if there's been some change to how this API works
|
|
echo " - Microsoft servers gave us an empty response to our request for an automated download."
|
|
failed=1
|
|
fi
|
|
|
|
if echo "$iso_download_link_html" | grep -q "We are unable to complete your request at this time."; then
|
|
echo " - Microsoft blocked the automated download request based on your IP address."
|
|
failed=1
|
|
fi
|
|
|
|
if [ ${failed} -eq 1 ]; then
|
|
echo " - Manually download the Windows ${windows_version} ISO using a web browser from: ${url}"
|
|
echo " - Save the downloaded ISO to: $(realpath ${VM_PATH})"
|
|
echo " - Update the config file to reference the downloaded ISO: ./${VM_PATH}.conf"
|
|
echo " - Continuing with the VM creation process..."
|
|
return 1
|
|
fi
|
|
|
|
# Filter for 64-bit ISO download URL
|
|
# sed: HTML decode "&" character
|
|
# tr: Filter for only alphanumerics or punctuation
|
|
local iso_download_link="$(echo "$iso_download_link_html" | grep -o "https://software.download.prss.microsoft.com.*IsoX64" | cut -d '"' -f 1 | sed 's/&/\&/g' | tr -cd '[:alnum:][:punct:]' | head -c 512)"
|
|
|
|
if ! [ "$iso_download_link" ]; then
|
|
# This should only happen if there's been some change to the download endpoint web address
|
|
echo " - Microsoft servers gave us no download link to our request for an automated download. Please manually download this ISO in a web browser: $url"
|
|
return 1
|
|
fi
|
|
|
|
echo " - Got latest ISO download link (valid for 24 hours): $iso_download_link"
|
|
|
|
# Download ISO
|
|
FILE_NAME="$(echo "$iso_download_link" | cut -d'?' -f1 | cut -d'/' -f5)"
|
|
web_get "$iso_download_link" "${VM_PATH}" "${FILE_NAME}"
|
|
}
|
|
|
|
function get_windows() {
|
|
echo "Downloading Windows ${RELEASE}..."
|
|
download_windows "${RELEASE}"
|
|
|
|
echo "Downloading VirtIO drivers..."
|
|
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
|
|
|
|
if [ -n "${FILE_NAME}" ]; then
|
|
make_vm_config "${FILE_NAME}" "virtio-win.iso"
|
|
else
|
|
make_vm_config "windows-${RELEASE}.iso" "virtio-win.iso"
|
|
fi
|
|
}
|
|
|
|
open_url() {
|
|
local URL="$1";
|
|
xdg-open $URL || sensible-browser $URL || x-www-browser $URL || gnome-open $URL;
|
|
}
|
|
|
|
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
|
|
|
|
if [ ${OS} == "freedos" ] && [[ $ISO =~ ".zip" ]]; then
|
|
unzip ${VM_PATH}/${ISO} -d ${VM_PATH}
|
|
ISO=$(ls ${VM_PATH} | grep -i '.iso')
|
|
fi
|
|
if [[ ${OS} == "batocera" ]] && [[ ${ISO} =~ ".gz" ]]; then
|
|
gzip -d "${VM_PATH}/${ISO}"
|
|
ISO="${ISO/.gz/}"
|
|
fi
|
|
|
|
# Could be other OS iso files compressed with bzip2 or gzip
|
|
# but for now we'll keep this to know cases
|
|
if [[ ${OS} == "dragonflybsd" ]] && [[ ${ISO} =~ ".bz2" ]]; then
|
|
bzip2 -d "${VM_PATH}/${ISO}"
|
|
ISO="${ISO/.bz2/}"
|
|
fi
|
|
|
|
if [ ${OS} == "reactos" ] && [[ $ISO =~ ".zip" ]]; then
|
|
unzip ${VM_PATH}/${ISO} -d ${VM_PATH}
|
|
ISO=$(ls ${VM_PATH} | grep -i '.iso' | grep -v '.zip')
|
|
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=()
|
|
|
|
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
|
|
echo "
|
|
You can also use this arguments:
|
|
Only show ISO download URL
|
|
--show-iso-url / -s {distro} {release} [edition]
|
|
Test if ISO is available
|
|
--test-iso-url / -t {distro} {release} [edition]
|
|
Open distro homepage
|
|
--open-distro-homepage / -o {distro}"
|
|
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
|
|
|
|
# Handle odd missing fedora cominations
|
|
if [[ $OS == fedora ]] ; then
|
|
if [[ ${RELEASE} = "33" && ${EDITION} = "i3" ]] || [[ ${RELEASE} = "34" && ${EDITION} = "Cinnamon" ]] || [[ "${RELEASE}" < "39" && ${EDITION} = "Onyx" ]]; then
|
|
echo "ERROR! Unsupported combination"
|
|
echo " Fedora ${RELEASE} ${EDITION} is not available, please choose another Release or Edition"
|
|
exit 1;
|
|
fi
|
|
fi
|
|
|
|
# Handle missing Mangaro Sway minimal
|
|
if [[ $OS == manjaro ]] ; then
|
|
if [[ ${RELEASE} == "sway" && ${EDITION} == "minimal" ]] ; then
|
|
echo "ERROR! Unsupported combination"
|
|
echo " Manjaro Sway does not have a minimal edition"
|
|
exit 1;
|
|
fi
|
|
fi
|
|
|
|
|
|
VM_PATH="${OS}-${RELEASE}-${EDITION}"
|
|
validate_release "releases_${OS}"
|
|
create_vm "$("get_${OS}" "${EDITION}")"
|
|
elif [ "${OS}" == "macos" ]; then
|
|
# macOS doesn't use create_vm()
|
|
validate_release releases_macos
|
|
get_macos
|
|
elif [[ "${OS}" == *"ubuntu-server"* ]]; then
|
|
# (Comes before regular Ubuntu, or the code tries to download the desktop) #
|
|
# Ubuntu doesn't use create_vm()
|
|
validate_release releases_ubuntu-server
|
|
get_ubuntu-server
|
|
elif [[ "${OS}" == *"ubuntu"* ]]; then
|
|
# Ubuntu doesn't use create_vm()
|
|
validate_release releases_ubuntu
|
|
get_ubuntu
|
|
elif [[ "${OS}" == *"deepin"* ]]; then
|
|
# deepin doesn't use create_vm()
|
|
validate_release releases_deepin
|
|
get_deepin
|
|
elif [ "${OS}" == "windows" ]; then
|
|
# Windows doesn't use create_vm()
|
|
validate_release releases_windows
|
|
get_windows
|
|
else
|
|
validate_release "releases_${OS}"
|
|
create_vm "$("get_${OS}")"
|
|
fi
|
|
else
|
|
if [ "${open_distro_homepage}" == 'on' ]; then
|
|
HOMEPAGE=$(os_homepages ${OS})
|
|
open_url "${HOMEPAGE}" && exit 0
|
|
fi
|
|
echo "ERROR! You must specify a release."
|
|
case ${OS} in
|
|
*ubuntu-server*)
|
|
echo -n " - Releases: "
|
|
releases_ubuntu-server | sed -Ee 's/eol-\S+//g' # hide eol releases
|
|
;;
|
|
*ubuntu*)
|
|
echo -n " - Releases: "
|
|
releases_ubuntu | sed -Ee 's/eol-\S+//g' # hide eol releases
|
|
;;
|
|
|
|
*)
|
|
echo -n " - Releases: "
|
|
releases_"${OS}"
|
|
if [[ $(type -t "editions_${OS}") == function ]]; then
|
|
echo -n " - Editions: "
|
|
editions_"${OS}"
|
|
fi
|
|
;;
|
|
esac
|
|
exit 1
|
|
fi
|
|
|
|
# vim:tabstop=4:shiftwidth=4:expandtab
|