mirror of
https://github.com/oSoWoSo/DistroHopper.git
synced 2024-08-14 22:46:53 +00:00
584c855ec3
This will inform frontend GUIs what download mechanism will be used to get the requested OS.
1067 lines
32 KiB
Bash
Executable file
1067 lines
32 KiB
Bash
Executable file
#!/usr/bin/env bash
|
|
|
|
# Here the quick 'n dirty guide to adding a new OS to quickget
|
|
#
|
|
# 1. Add the new OS, all lowercase, to os_support()
|
|
# 2. Add a "pretty name" display name to pretty_name()
|
|
# 3. Create a releases_newos() generator that outputs the currently supported release versions
|
|
# 4. Add the new OS to make_vm_config()
|
|
# 5. Create a get_newos() function that does something like this:
|
|
# function get_newos() {
|
|
# local HASH=""
|
|
# local ISO=""
|
|
# local URL=""
|
|
#
|
|
# validate_release "releases_newos"
|
|
# ISO="newos-${RELEASE}-amd64.iso"
|
|
# URL="https://www.newos.org/download/${ISO}"
|
|
# web_get "${URL}" "${VM_PATH}"
|
|
# web_get "${URL}/SHA256SUMS" "${VM_PATH}"
|
|
# HASH=$(cat "${VM_PATH}/SHA256SUMS" | cut -d' ' -f1)
|
|
# check_hash "${ISO}" "${HASH}"
|
|
# make_vm_config "${ISO}"
|
|
# }
|
|
# 6. Add new OS to the argument parser at the bottom of the script
|
|
|
|
if ((BASH_VERSINFO[0] < 4))
|
|
then
|
|
echo "Sorry, you need bash 4.0 or newer to run this script."
|
|
exit 1
|
|
fi
|
|
|
|
function pretty_name() {
|
|
local SIMPLE_NAME=""
|
|
local PRETTY_NAME=""
|
|
SIMPLE_NAME="${1}"
|
|
case ${SIMPLE_NAME} in
|
|
elementary) PRETTY_NAME="elementary OS";;
|
|
freebsd) PRETTY_NAME="FreeBSD";;
|
|
linuxmint-cinnamon) PRETTY_NAME="Linux Mint Cinnamon";;
|
|
linuxmint-mate) PRETTY_NAME="Linux Mint MATE";;
|
|
linuxmint-xfce) PRETTY_NAME="Linux Mint XFCE";;
|
|
nixos-gnome) PRETTY_NAME="NixOS Gnome";;
|
|
nixos-plasma5) PRETTY_NAME="NixOS KDE";;
|
|
nixos-minimal) PRETTY_NAME="NixOS Minimal";;
|
|
macos) PRETTY_NAME="macOS";;
|
|
openbsd) PRETTY_NAME="OpenBSD";;
|
|
opensuse) PRETTY_NAME="openSUSE";;
|
|
popos) PRETTY_NAME="Pop!_OS";;
|
|
ubuntu-budgie) PRETTY_NAME="Ubuntu Budgie";;
|
|
ubuntu-kylin) PRETTY_NAME="Ubuntu Kylin";;
|
|
ubuntu-mate) PRETTY_NAME="Ubuntu MATE";;
|
|
ubuntu-studio) PRETTY_NAME="Ubuntu Studio";;
|
|
*) PRETTY_NAME="${SIMPLE_NAME^}";;
|
|
esac
|
|
echo "${PRETTY_NAME}"
|
|
}
|
|
|
|
function validate_release() {
|
|
local DISPLAY_NAME=""
|
|
local RELEASE_GENERATOR="${1}"
|
|
local RELEASES=""
|
|
|
|
DISPLAY_NAME="$(pretty_name "${OS}")"
|
|
RELEASES=$(${RELEASE_GENERATOR})
|
|
if [[ "${RELEASES}" != *"${RELEASE}"* ]]; then
|
|
echo "ERROR! ${DISPLAY_NAME} ${RELEASE} is not a supported release."
|
|
echo "${RELEASES}"
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
function list_json() {
|
|
# Reference: https://stackoverflow.com/a/67359273
|
|
list_csv | jq -R 'split(",") as $h|reduce inputs as $in ([]; . += [$in|split(",")|. as $a|reduce range(0,length) as $i ({};.[$h[$i]]=$a[$i])])'
|
|
exit 0
|
|
}
|
|
|
|
function list_csv() {
|
|
local DISPLAY_NAME
|
|
local DOWNLOADER
|
|
local FUNC
|
|
local LANG
|
|
local OS
|
|
local RELEASE
|
|
echo "Display Name,OS,Release,Option,Downloader"
|
|
for OS in $(os_support); do
|
|
DISPLAY_NAME="$(pretty_name "${OS}")"
|
|
if [[ "${OS}" == *"ubuntu"* ]]; then
|
|
FUNC="ubuntu"
|
|
elif [[ "${OS}" == *"linuxmint"* ]]; then
|
|
FUNC="linuxmint"
|
|
else
|
|
FUNC="${OS}"
|
|
fi
|
|
|
|
for RELEASE in $("releases_${FUNC}"); do
|
|
|
|
if [ "${OS}" == "macos" ]; then
|
|
DOWNLOADER="macrecovery"
|
|
elif [ "${OS}" == "ubuntu" ] && [ ${RELEASE} == "canary" ]; then
|
|
DOWNLOADER="zsync"
|
|
elif [[ "${OS}" == *"ubuntu"* ]] && [ ${RELEASE} == "devel" ]; then
|
|
DOWNLOADER="zsync"
|
|
else
|
|
DOWNLOADER="wget"
|
|
fi
|
|
|
|
if [ "${OS}" == "windows" ]; then
|
|
for LANG in "${LANGS[@]}"; do
|
|
echo "${DISPLAY_NAME},${OS},${RELEASE},${LANG},${DOWNLOADER}"
|
|
done
|
|
elif [ "${OS}" == "popos" ]; then
|
|
for DRIVER in intel nvidia; do
|
|
echo "${DISPLAY_NAME},${OS},${RELEASE},${DRIVER},${DOWNLOADER}"
|
|
done
|
|
else
|
|
echo "${DISPLAY_NAME},${OS},${RELEASE},,${DOWNLOADER}"
|
|
fi
|
|
done
|
|
done
|
|
exit 0
|
|
}
|
|
|
|
function os_support() {
|
|
echo elementary \
|
|
freebsd \
|
|
fedora \
|
|
kali \
|
|
kubuntu \
|
|
linuxmint-cinnamon \
|
|
linuxmint-mate \
|
|
linuxmint-xfce \
|
|
nixos-gnome \
|
|
nixos-plasma5 \
|
|
nixos-minimal \
|
|
lubuntu \
|
|
macos \
|
|
openbsd \
|
|
opensuse \
|
|
popos \
|
|
ubuntu \
|
|
ubuntu-budgie \
|
|
ubuntu-kylin \
|
|
ubuntu-mate \
|
|
ubuntu-studio \
|
|
windows \
|
|
xubuntu
|
|
}
|
|
|
|
function releases_elementary() {
|
|
echo 6.0
|
|
}
|
|
|
|
function releases_freebsd(){
|
|
echo 12.2 \
|
|
13.0
|
|
}
|
|
|
|
function releases_fedora(){
|
|
echo 33 \
|
|
34 \
|
|
35_beta
|
|
}
|
|
|
|
function releases_kali() {
|
|
echo latest \
|
|
weekly
|
|
}
|
|
|
|
function releases_linuxmint(){
|
|
echo 20.2
|
|
}
|
|
|
|
function releases_nixos(){
|
|
echo 21.05
|
|
}
|
|
|
|
function releases_openbsd(){
|
|
echo 7.0
|
|
}
|
|
|
|
function releases_opensuse(){
|
|
echo 15.0 \
|
|
15.1 \
|
|
15.2 \
|
|
15.3 \
|
|
microos \
|
|
tumbleweed
|
|
}
|
|
|
|
function releases_macos() {
|
|
echo high-sierra \
|
|
mojave \
|
|
catalina \
|
|
big-sur \
|
|
monterey
|
|
}
|
|
|
|
function releases_popos() {
|
|
echo 20.04 \
|
|
21.04
|
|
}
|
|
|
|
function releases_ubuntu() {
|
|
echo bionic \
|
|
focal \
|
|
hirsute \
|
|
impish \
|
|
devel \
|
|
canary
|
|
}
|
|
|
|
function languages_windows() {
|
|
LANGS=(Arabic
|
|
"Brazilian Portuguese"
|
|
Bulgarian
|
|
"Chinese (Simplified)"
|
|
"Chinese (Traditional)"
|
|
Croatian
|
|
Czech
|
|
Danish
|
|
Dutch
|
|
English
|
|
"English International"
|
|
Estonian
|
|
Finnish
|
|
French
|
|
"French Canadian"
|
|
German
|
|
Greek
|
|
Hebrew
|
|
Hungarian
|
|
Italian
|
|
Japanese
|
|
Korean
|
|
Latvian
|
|
Lithuanian
|
|
Norwegian
|
|
Polish
|
|
Portuguese
|
|
Romanian
|
|
Russian
|
|
"Serbian Latin"
|
|
Slovak
|
|
Slovenian
|
|
Spanish
|
|
"Spanish (Mexico)"
|
|
Swedish
|
|
Thai
|
|
Turkish
|
|
Ukrainian)
|
|
}
|
|
|
|
|
|
function releases_windows() {
|
|
echo 8 \
|
|
10 \
|
|
11
|
|
}
|
|
|
|
function 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:
|
|
http://technet.microsoft.com/en-us/library/ff699038.aspx
|
|
-->
|
|
|
|
<settings pass="generalize">
|
|
<!--
|
|
The PersistAllDeviceInstalls setting indicates whether all plug and
|
|
play devices on the destination computer remain installed during the
|
|
generalize configuration pass.
|
|
-->
|
|
<component name="Microsoft-Windows-PnPSysprep"
|
|
processorArchitecture="amd64"
|
|
publicKeyToken="31bf3856ad364e35"
|
|
language="neutral"
|
|
versionScope="nonSxS">
|
|
<PersistAllDeviceInstalls>true</PersistAllDeviceInstalls>
|
|
</component>
|
|
</settings>
|
|
|
|
<settings pass="windowsPE">
|
|
<component name="Microsoft-Windows-Setup" processorArchitecture="amd64"
|
|
publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS">
|
|
<DiskConfiguration>
|
|
<Disk wcm:action="add">
|
|
<DiskID>0</DiskID>
|
|
<WillWipeDisk>true</WillWipeDisk>
|
|
<CreatePartitions>
|
|
<CreatePartition wcm:action="add">
|
|
<Order>1</Order>
|
|
<Type>EFI</Type>
|
|
<Size>100</Size>
|
|
</CreatePartition>
|
|
<CreatePartition wcm:action="add">
|
|
<Order>2</Order>
|
|
<Type>MSR</Type>
|
|
<Size>512</Size>
|
|
</CreatePartition>
|
|
<CreatePartition wcm:action="add">
|
|
<Order>3</Order>
|
|
<Type>Primary</Type>
|
|
<Extend>true</Extend>
|
|
</CreatePartition>
|
|
</CreatePartitions>
|
|
<ModifyPartitions>
|
|
<ModifyPartition wcm:action="add">
|
|
<Order>1</Order>
|
|
<PartitionID>1</PartitionID>
|
|
<Label>System</Label>
|
|
<Format>FAT32</Format>
|
|
</ModifyPartition>
|
|
<ModifyPartition wcm:action="add">
|
|
<Order>2</Order>
|
|
<PartitionID>3</PartitionID>
|
|
<Label>Windows</Label>
|
|
<Letter>C</Letter>
|
|
<Format>NTFS</Format>
|
|
</ModifyPartition>
|
|
</ModifyPartitions>
|
|
</Disk>
|
|
<WillShowUI>OnError</WillShowUI>
|
|
</DiskConfiguration>
|
|
<ImageInstall>
|
|
<OSImage>
|
|
<WillShowUI>OnError</WillShowUI>
|
|
<InstallTo>
|
|
<DiskID>0</DiskID>
|
|
<PartitionID>3</PartitionID>
|
|
</InstallTo>
|
|
</OSImage>
|
|
</ImageInstall>
|
|
<UserData>
|
|
<AcceptEula>true</AcceptEula>
|
|
<ProductKey>
|
|
<key>VK7JG-NPHTM-C97JM-9MPGT-3V66T</key>
|
|
<WillShowUI>Never</WillShowUI>
|
|
</ProductKey>
|
|
</UserData>
|
|
<DynamicUpdate>
|
|
<Enable>true</Enable>
|
|
<WillShowUI>Never</WillShowUI>
|
|
</DynamicUpdate>
|
|
</component>
|
|
|
|
<component name="Microsoft-Windows-PnpCustomizationsWinPE"
|
|
publicKeyToken="31bf3856ad364e35" language="neutral"
|
|
versionScope="nonSxS" processorArchitecture="amd64">
|
|
|
|
<!--
|
|
This makes the VirtIO drivers available to Windows, assuming that
|
|
the VirtIO driver disk
|
|
(https://github.com/virtio-win/virtio-win-pkg-scripts/blob/master/README.md)
|
|
is available as drive E:
|
|
-->
|
|
<DriverPaths>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="1">
|
|
<Path>E:\qemufwcfg\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="2">
|
|
<Path>E:\vioinput\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="3">
|
|
<Path>E:\vioscsi\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="4">
|
|
<Path>E:\viostor\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="5">
|
|
<Path>E:\vioserial\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="6">
|
|
<Path>E:\qxldod\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="7">
|
|
<Path>E:\amd64\w10</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="8">
|
|
<Path>E:\viogpudo\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="9">
|
|
<Path>E:\viorng\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="10">
|
|
<Path>E:\NetKVM\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="11">
|
|
<Path>E:\viofs\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
<PathAndCredentials wcm:action="add" wcm:keyValue="12">
|
|
<Path>E:\Balloon\w10\amd64</Path>
|
|
</PathAndCredentials>
|
|
</DriverPaths>
|
|
</component>
|
|
</settings>
|
|
|
|
<settings pass="specialize">
|
|
<component name="Microsoft-Windows-Shell-Setup" processorArchitecture="amd64"
|
|
publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS">
|
|
<ComputerName>*</ComputerName>
|
|
<OEMInformation>
|
|
<Manufacturer>Wimpys World</Manufacturer>
|
|
<Model>Quickemu</Model>
|
|
<SupportHours>24/7</SupportHours>
|
|
<SupportPhone></SupportPhone>
|
|
<SupportProvider>Wimpys World</SupportProvider>
|
|
<SupportURL>https://github.com/wimpysworld/quickemu/issues</SupportURL>
|
|
</OEMInformation>
|
|
<OEMName>Wimpys World</OEMName>
|
|
</component>
|
|
</settings>
|
|
|
|
<settings pass="oobeSystem">
|
|
<component name="Microsoft-Windows-Shell-Setup" processorArchitecture="amd64"
|
|
publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS">
|
|
<OOBE>
|
|
<HideOEMRegistrationScreen>true</HideOEMRegistrationScreen>
|
|
<HideWirelessSetupInOOBE>true</HideWirelessSetupInOOBE>
|
|
</OOBE>
|
|
<FirstLogonCommands>
|
|
<SynchronousCommand wcm:action="add">
|
|
<CommandLine>msiexec /i E:\guest-agent\qemu-ga-x86_64.msi /quiet /passive /qn</CommandLine>
|
|
<Description>Install Virtio Guest Agent</Description>
|
|
<Order>1</Order>
|
|
</SynchronousCommand>
|
|
<SynchronousCommand wcm:action="add">
|
|
<CommandLine>msiexec /i F:\spice-webdavd-x64-latest.msi /quiet /passive /qn</CommandLine>
|
|
<Description>Install spice-webdavd file sharing agent</Description>
|
|
<Order>2</Order>
|
|
</SynchronousCommand>
|
|
<SynchronousCommand wcm:action="add">
|
|
<CommandLine>msiexec /i F:\UsbDk_1.0.22_x64.msi /quiet /passive /qn</CommandLine>
|
|
<Description>Install usbdk USB sharing agent</Description>
|
|
<Order>3</Order>
|
|
</SynchronousCommand>
|
|
<SynchronousCommand wcm:action="add">
|
|
<CommandLine>msiexec /i F:\spice-vdagent-x64-0.10.0.msi /quiet /passive /qn</CommandLine>
|
|
<Description>Install spice-vdagent SPICE agent</Description>
|
|
<Order>4</Order>
|
|
</SynchronousCommand>
|
|
</FirstLogonCommands>
|
|
</component>
|
|
</settings>
|
|
</unattend>
|
|
EOF
|
|
}
|
|
|
|
function check_hash() {
|
|
local iso=""
|
|
local hash=""
|
|
local hash_algo=""
|
|
iso="${VM_PATH}/${1}"
|
|
hash="${2}"
|
|
|
|
# Guess the hash algorithm by the hash length
|
|
case ${#hash} in
|
|
32) hash_algo=md5sum;;
|
|
40) hash_algo=sha1sum;;
|
|
64) hash_algo=sha256sum;;
|
|
128) hash_algo=sha512sum;;
|
|
*) echo "WARNING! Can't guess hash algorithm, not checking ${iso} hash."
|
|
return;;
|
|
esac
|
|
|
|
echo -n "Checking ${iso} with ${hash_algo}... "
|
|
if ! echo "${hash} ${iso}" | ${hash_algo} --check --status; then
|
|
echo "ERROR!"
|
|
echo "${iso} doesn't match ${hash}. Try running 'quickget' again."
|
|
exit 1
|
|
else
|
|
echo "Good!"
|
|
fi
|
|
}
|
|
|
|
function web_get() {
|
|
local DIR="${2}"
|
|
local FILE=""
|
|
local URL="${1}"
|
|
|
|
if [ -n "${3}" ]; then
|
|
FILE="${3}"
|
|
else
|
|
FILE="${URL##*/}"
|
|
fi
|
|
|
|
if ! mkdir -p "${DIR}" 2>/dev/null; then
|
|
echo "ERROR! Unable to create directory ${DIR}"
|
|
exit 1
|
|
fi
|
|
|
|
if ! wget --quiet --continue --show-progress --progress=bar:force:noscroll "${URL}" -O "${DIR}/${FILE}"; then
|
|
echo "ERROR! Failed to download ${URL}. Try running 'quickget' again."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
function zsync_get() {
|
|
local DIR="${2}"
|
|
local FILE=""
|
|
local OUT=""
|
|
local URL="${1}"
|
|
FILE="${URL##*/}"
|
|
if [ -n "${3}" ]; then
|
|
OUT="${3}"
|
|
else
|
|
OUT="${FILE}"
|
|
fi
|
|
|
|
if ! mkdir -p "${DIR}" 2>/dev/null; then
|
|
echo "ERROR! Unable to create directory ${DIR}"
|
|
exit 1
|
|
fi
|
|
|
|
if ! zsync "${URL}.zsync" -i "${DIR}/${OUT}" -o "${DIR}/${OUT}" 2>/dev/null; then
|
|
echo "ERROR! Failed to download ${URL}.zsync"
|
|
exit 1
|
|
fi
|
|
|
|
if [ -e "${DIR}/${OUT}.zs-old" ]; then
|
|
rm "${DIR}/${OUT}.zs-old"
|
|
fi
|
|
}
|
|
|
|
function start_vm_info() {
|
|
echo
|
|
echo "To start your ${OS} ${RELEASE} virtual machine run:"
|
|
echo " quickemu --vm ${OS}-${RELEASE}.conf"
|
|
echo
|
|
}
|
|
|
|
function make_vm_config() {
|
|
local IMAGE_FILE=""
|
|
local ISO_FILE=""
|
|
local IMAGE_TYPE=""
|
|
local GUEST=""
|
|
local SEC_BOOT=""
|
|
|
|
IMAGE_FILE="${1}"
|
|
ISO_FILE="${2}"
|
|
if [ "${OS}" == "elementary" ]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "freebsd" ]; then
|
|
GUEST="freebsd"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "fedora" ]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "kali" ]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [[ "${OS}" == *"linuxmint"* ]]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [[ "${OS}" == *"nixos"* ]]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "openbsd" ]; then
|
|
GUEST="openbsd"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "opensuse" ]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "popos" ]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [[ "${OS}" == *"ubuntu"* ]]; then
|
|
GUEST="linux"
|
|
IMAGE_TYPE="iso"
|
|
elif [ "${OS}" == "macos" ]; then
|
|
GUEST="macos"
|
|
IMAGE_TYPE="img"
|
|
elif [ "${OS}" == "windows" ]; then
|
|
GUEST="windows"
|
|
IMAGE_TYPE="iso"
|
|
fi
|
|
|
|
if [ ! -e "${OS}-${RELEASE}.conf" ]; then
|
|
echo "Making VM configuration for ${OS}-${RELEASE}..."
|
|
cat << EOF > "${OS}-${RELEASE}.conf"
|
|
guest_os="${GUEST}"
|
|
disk_img="${VM_PATH}/disk.qcow2"
|
|
${IMAGE_TYPE}="${VM_PATH}/${IMAGE_FILE}"
|
|
EOF
|
|
if [ -n "${ISO_FILE}" ]; then
|
|
echo "fixed_iso=\"${VM_PATH}/${ISO_FILE}\"" >> "${OS}-${RELEASE}.conf"
|
|
fi
|
|
|
|
if [ "${OS}" == "openbsd" ]; then
|
|
echo "boot=\"legacy\"" >> "${OS}-${RELEASE}.conf"
|
|
fi
|
|
|
|
if [ "${OS}" == "macos" ]; then
|
|
echo "macos_release=\"${RELEASE}\"" >> "${OS}-${RELEASE}.conf"
|
|
fi
|
|
|
|
# Enable TPM for Windows 11
|
|
if [ "${OS}" == "windows" ] && [ "${RELEASE}" -ge 11 ]; then
|
|
echo "tpm=\"on\"" >> "${OS}-${RELEASE}.conf"
|
|
# Only force SecureBoot on for non-Debian/Ubuntu distros.
|
|
if [ -e "/usr/share/OVMF/OVMF_CODE_4M.fd" ] && [ -e "/usr/share/OVMF/OVMF_VARS_4M.fd" ]; then
|
|
SEC_BOOT="off"
|
|
else
|
|
SEC_BOOT="on"
|
|
fi
|
|
echo "secureboot=\"${SEC_BOOT}\"" >> "${OS}-${RELEASE}.conf"
|
|
fi
|
|
fi
|
|
start_vm_info
|
|
}
|
|
|
|
function get_elementary() {
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
validate_release "releases_elementary"
|
|
ISO="elementaryos-${RELEASE}-stable.20211005.iso"
|
|
URL="https://ams3.dl.elementary.io/download/MTYzNTM1NDc4OQ==/${ISO}"
|
|
web_get "${URL}" "${VM_PATH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_freebsd() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
validate_release "releases_freebsd"
|
|
ISO="FreeBSD-${RELEASE}-RELEASE-amd64-dvd1.iso"
|
|
HASH=$(wget -q -O- "https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}/CHECKSUM.SHA512-FreeBSD-${RELEASE}-RELEASE-amd64" | grep '('"${ISO}"')' | cut -d' ' -f4)
|
|
URL="https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}/${ISO}"
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_fedora() {
|
|
local FEDORA_RELEASE=""
|
|
local FEDORA_VERSIONS=""
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
local VERSION_NUM=""
|
|
|
|
validate_release "releases_fedora"
|
|
|
|
FEDORA_VERSIONS=$(wget -q -O- "https://getfedora.org/releases.json" | jq '.[] | select((.variant=="Workstation" or .variant=="Spins") and .arch=="x86_64")')
|
|
if [[ "${RELEASE}" == *"beta"* ]]; then
|
|
VERSION_NUM=${RELEASE%"_beta"}
|
|
FEDORA_RELEASE=$(echo "${FEDORA_VERSIONS}" | jq -c '. | select(.version | contains("Beta"))' | jq '. | select(.variant=="Workstation")')
|
|
ISO="Fedora-Workstation-Live-x86_64-${VERSION_NUM}_Beta-1.2.iso"
|
|
else
|
|
FEDORA_RELEASE=$(echo "${FEDORA_VERSIONS}" | jq '. | select(.variant=="Workstation" and .version=="'${RELEASE}'")')
|
|
ISO="Fedora-Workstation-Live-x86_64-${RELEASE}-1.2.iso"
|
|
fi
|
|
|
|
URL=$(echo "${FEDORA_RELEASE}" | jq -r '.link')
|
|
HASH=$(echo "${FEDORA_RELEASE}" | jq -r '.sha256')
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_kali() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
local SUBDIR=""
|
|
validate_release "releases_kali"
|
|
|
|
if [[ "${RELEASE}" == "latest" ]]; then
|
|
SUBDIR="current"
|
|
else
|
|
SUBDIR="kali-weeekly"
|
|
fi
|
|
|
|
ISO=$(wget -q -O- "https://cdimage.kali.org/${SUBDIR}/?C=M;O=D" |grep -o ">kali-linux-.*-installer-amd64.iso"|head -n 1|cut -c 2-)
|
|
HASH=$(wget -q -O- "https://cdimage.kali.org/${SUBDIR}/SHA256SUMS" | grep "${ISO}" | cut -d' ' -f1)
|
|
URL="https://cdimage.kali.org/${SUBDIR}/${ISO}"
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_linuxmint() {
|
|
local FLAVOR=""
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
validate_release "releases_linuxmint"
|
|
FLAVOR=$(echo "${OS}" | cut -d'-' -f2)
|
|
ISO="linuxmint-${RELEASE}-${FLAVOR}-64bit.iso"
|
|
HASH=$(wget -q -O- "https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f1)
|
|
URL="https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}/${ISO}"
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
function get_nixos() {
|
|
local FLAVOR=""
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
validate_release "releases_nixos"
|
|
FLAVOR=$(echo "${OS}" | cut -d'-' -f2)
|
|
ISO="latest-nixos-${FLAVOR}-x86_64-linux.iso"
|
|
URL="https://channels.nixos.org/nixos-${RELEASE}/${ISO}"
|
|
HASH=$(wget -q -O- "https://channels.nixos.org/nixos-${RELEASE}/${ISO}.sha256" | cut -d' ' -f1)
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
function get_openbsd() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
validate_release "releases_openbsd"
|
|
ISO="install${RELEASE//\./}.iso"
|
|
URL="https://cdn.openbsd.org/pub/OpenBSD/${RELEASE}/amd64/${ISO}"
|
|
HASH=$(wget -q -O- "https://cdn.openbsd.org/pub/OpenBSD/${RELEASE}/amd64/SHA256" | grep "${ISO}" | cut -d' ' -f4)
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_opensuse() {
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
validate_release "releases_opensuse"
|
|
if [ "${RELEASE}" == "tumbleweed" ]; then
|
|
ISO="openSUSE-Tumbleweed-DVD-x86_64-Current.iso"
|
|
URL="https://download.opensuse.org/tumbleweed/iso/${ISO}"
|
|
HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
|
|
elif [ "${RELEASE}" == "microos" ]; then
|
|
ISO="openSUSE-MicroOS-DVD-x86_64-Current.iso"
|
|
URL="https://download.opensuse.org/tumbleweed/iso/${ISO}"
|
|
HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
|
|
else
|
|
ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64.iso"
|
|
URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso/${ISO}"
|
|
HASH=$(wget -q -O- "${URL}.sha256" | cut -d' ' -f1)
|
|
fi
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_macos() {
|
|
local BOARD_ID=""
|
|
local CWD=""
|
|
local MACRECOVERY=""
|
|
local MLB=""
|
|
|
|
case ${RELEASE} in
|
|
high-sierra)
|
|
BOARD_ID="Mac-7BA5B2D9E42DDD94"
|
|
MLB="00000000000J80300";;
|
|
mojave)
|
|
BOARD_ID="Mac-7BA5B2DFE22DDD8C"
|
|
MLB="00000000000KXPG00";;
|
|
catalina)
|
|
BOARD_ID="Mac-CFF7D910A743CAAF"
|
|
MLB="00000000000PHCD00";;
|
|
big-sur)
|
|
BOARD_ID="Mac-35C1E88140C3E6CF"
|
|
MLB="00000000000000000";;
|
|
monterey)
|
|
BOARD_ID="Mac-06F11F11946D27C5"
|
|
MLB="00000000000000000";;
|
|
*) echo "ERROR! Unknown release: ${RELEASE}"
|
|
releases_macos
|
|
exit 1;;
|
|
esac
|
|
|
|
# Use a bundled macrecovery if possible
|
|
CWD="$(dirname "${0}")"
|
|
if [ -x "${CWD}/macrecovery" ]; then
|
|
MACRECOVERY="${CWD}/macrecovery"
|
|
elif [ -x /usr/bin/macrecovery ]; then
|
|
MACRECOVERY="/usr/bin/macrecovery"
|
|
else
|
|
web_get "https://raw.githubusercontent.com/wimpysworld/quickemu/master/macrecovery" "${HOME}/.quickemu"
|
|
MACRECOVERY="python3 ${HOME}/.quickemu/macrecovery"
|
|
fi
|
|
|
|
if [ -z "${MACRECOVERY}" ]; then
|
|
echo "ERROR! Can not find a usable macrecovery."
|
|
exit 1
|
|
fi
|
|
|
|
# Get firmware
|
|
web_get "https://github.com/kholia/OSX-KVM/raw/master/OpenCore/OpenCore.qcow2" "${VM_PATH}"
|
|
web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_CODE.fd" "${VM_PATH}"
|
|
if [ ! -e "${VM_PATH}/OVMF_VARS-1024x768.fd" ]; then
|
|
web_get "https://github.com/kholia/OSX-KVM/raw/master/OVMF_VARS-1024x768.fd" "${VM_PATH}"
|
|
fi
|
|
|
|
if [ ! -e "${VM_PATH}/RecoveryImage.chunklist" ]; then
|
|
echo "Downloading ${RELEASE}..."
|
|
${MACRECOVERY} \
|
|
--board-id "${BOARD_ID}" \
|
|
--mlb "${MLB}" \
|
|
--basename RecoveryImage \
|
|
--outdir "${VM_PATH}" \
|
|
download
|
|
fi
|
|
|
|
if [ -e "${VM_PATH}/RecoveryImage.dmg" ] && [ ! -e "${VM_PATH}/RecoveryImage.img" ]; then
|
|
echo "Converting RecoveryImage..."
|
|
qemu-img convert "${VM_PATH}/RecoveryImage.dmg" -O raw "${VM_PATH}/RecoveryImage.img"
|
|
fi
|
|
|
|
make_vm_config RecoveryImage.img
|
|
}
|
|
|
|
function get_popos() {
|
|
local DRIVER="intel"
|
|
local HASH=""
|
|
local ISO=""
|
|
local URL=""
|
|
|
|
if [ -n "${1}" ]; then
|
|
DRIVER="${1}"
|
|
fi
|
|
|
|
validate_release "releases_popos"
|
|
|
|
URL=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${DRIVER}" | jq ".url")
|
|
URL="${URL//\"/}"
|
|
ISO=$(echo "${URL}" | sed -e "s/.*\/\([^\/]*\)$/\1/")
|
|
HASH=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${DRIVER}" | jq ".sha_sum")
|
|
HASH="${HASH//\"/}"
|
|
web_get "${URL}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
}
|
|
|
|
function get_ubuntu() {
|
|
local DEVEL="daily-live"
|
|
local ISO=""
|
|
local HASH=""
|
|
local PROJECT=""
|
|
local URL=""
|
|
|
|
case ${OS} in
|
|
kubuntu|lubuntu|ubuntu|ubuntu-budgie|ubuntu-mate|xubuntu)
|
|
PROJECT="${OS}";;
|
|
ubuntu-kylin)
|
|
PROJECT="ubuntukylin";;
|
|
ubuntu-studio)
|
|
PROJECT="ubuntustudio"
|
|
DEVEL="dvd";;
|
|
*) echo "ERROR! ${OS} is not a recognised Ubuntu flavour."
|
|
exit 1;;
|
|
esac
|
|
|
|
if [ "${RELEASE}" == "canary" ] && [ "${OS}" != "ubuntu" ]; then
|
|
echo "ERROR! Canary is currently only available for Ubuntu."
|
|
exit 1
|
|
else
|
|
validate_release "releases_ubuntu"
|
|
fi
|
|
|
|
if [ "${RELEASE}" == "canary" ]; then
|
|
DEVEL="daily-canary"
|
|
URL="http://cdimage.ubuntu.com/${PROJECT}/${DEVEL}/current"
|
|
elif [ "${RELEASE}" == "devel" ]; then
|
|
URL="http://cdimage.ubuntu.com/${PROJECT}/${DEVEL}/current"
|
|
elif [ "${PROJECT}" == "ubuntu" ]; then
|
|
URL="http://releases.ubuntu.com/${RELEASE}"
|
|
else
|
|
URL="http://cdimage.ubuntu.com/${PROJECT}/releases/${RELEASE}/release"
|
|
fi
|
|
|
|
HASH=$(wget -q -O- "${URL}/SHA256SUMS" | cut -d' ' -f1)
|
|
ISO=$(wget -q -O- "${URL}/SHA256SUMS" | grep 'desktop\|dvd' | grep amd64 | cut -d' ' -f2 | sed 's|*||g')
|
|
if [ "${RELEASE}" == "canary" ] || [ "${RELEASE}" == "devel" ]; then
|
|
zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-${RELEASE}.iso"
|
|
make_vm_config "${OS}-${RELEASE}.iso"
|
|
else
|
|
web_get "${URL}/${ISO}" "${VM_PATH}"
|
|
check_hash "${ISO}" "${HASH}"
|
|
make_vm_config "${ISO}"
|
|
fi
|
|
}
|
|
|
|
# Adapted from https://gist.github.com/hongkongkiwi/15a5bf16437315df256c118c163607cb
|
|
function get_windows() {
|
|
local ARCH="x64"
|
|
local LANG_CODE="en"
|
|
local LATEST_WINDOWS_VERSION=""
|
|
local WINDOWS_NAME=""
|
|
local VERSION_ID=""
|
|
local EDITION_ID=""
|
|
local LANGUAGE_ID=""
|
|
local FILE_NAME=""
|
|
local ARCH_ID=""
|
|
local DOWNLOAD_INFO=""
|
|
local DOWNLOAD_ID=""
|
|
local DOWNLOAD_URL=""
|
|
|
|
validate_release "releases_windows"
|
|
|
|
echo "Getting Windows ${RELEASE} URL..."
|
|
WINDOWS_VERSIONS=$(wget -q -O- "https://tb.rg-adguard.net/php/get_version.php?type_id=1" | jq '.versions | sort_by(-(.version_id | tonumber))')
|
|
LATEST_WINDOWS_VERSION=$(echo "${WINDOWS_VERSIONS}" | jq -c 'map(select(.name | contains("Windows '${RELEASE}'")))[0]')
|
|
|
|
WINDOWS_NAME=$(echo "${LATEST_WINDOWS_VERSION}" | jq -r .name)
|
|
VERSION_ID=$(echo "${LATEST_WINDOWS_VERSION}" | jq -r .version_id)
|
|
|
|
case ${RELEASE} in
|
|
8) EDITION_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_edition.php?version_id=${VERSION_ID}&lang=name_${LANG_CODE}" | jq -r '.editions[] | select(.name_'${LANG_CODE}'=="Windows 8.1 Pro + Core").edition_id');;
|
|
10|11) EDITION_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_edition.php?version_id=${VERSION_ID}&lang=name_${LANG_CODE}" | jq -r '.editions[] | select(.name_'${LANG_CODE}'=="Windows '${RELEASE}'").edition_id');;
|
|
esac
|
|
|
|
LANGUAGE_ID=$(wget -q -O- "https://tb.rg-adguard.net/php/get_language.php?edition_id=${EDITION_ID}&lang=name_${LANG_CODE}" | jq -r '.languages[] | select(.name_'${LANG_CODE}'=="'"${LANG_NAME}"'").language_id')
|
|
ARCH_INFO=$(wget -q -O- "https://tb.rg-adguard.net/php/get_arch.php?language_id=${LANGUAGE_ID}")
|
|
FILE_NAME=$(echo "${ARCH_INFO}" | jq -r '.archs[] | select(.name | contains("'${ARCH}'")).name')
|
|
ARCH_ID=$(echo "${ARCH_INFO}" | jq -r '.archs[] | select(.name | contains("'${ARCH}'")).arch_id')
|
|
DOWNLOAD_INFO=$(wget -q -O- "https://tb.rg-adguard.net/dl.php?fileName=${ARCH_ID}&lang=en")
|
|
DOWNLOAD_SHA1=$(echo "${DOWNLOAD_INFO}" | sed -e 's/<[^>]*>//g' | grep -o -P '(?<=SHA1: ).*(?= expire)' | sed 's/Link//')
|
|
DOWNLOAD_ID=$(echo "${DOWNLOAD_INFO}" | grep -oP '(?<=https:\/\/tb\.rg-adguard\.net/dl\.php\?go=)[0-9a-z]+')
|
|
DOWNLOAD_URL="https://tb.rg-adguard.net/dl.php?go=${DOWNLOAD_ID}"
|
|
|
|
echo "Downloading ${WINDOWS_NAME}..."
|
|
web_get "${DOWNLOAD_URL}" "${VM_PATH}" "${FILE_NAME}"
|
|
|
|
# Windows 10 doesn't include a SHA1, so only check the integrity if the SHA1 is available.
|
|
if [ -n "${DOWNLOAD_SHA1}" ]; then
|
|
check_hash "${FILE_NAME}" "${DOWNLOAD_SHA1}"
|
|
fi
|
|
|
|
web_get "https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso" "${VM_PATH}"
|
|
|
|
rm -f "${VM_PATH}/unattended.iso"
|
|
case ${RELEASE} in
|
|
10|11)
|
|
echo "Making unattended.iso"
|
|
mkdir -p "${VM_PATH}/unattended" 2>/dev/null
|
|
web_get https://www.spice-space.org/download/windows/spice-webdavd/spice-webdavd-x64-latest.msi "${VM_PATH}/unattended"
|
|
web_get https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.10.0/spice-vdagent-x64-0.10.0.msi "${VM_PATH}/unattended"
|
|
web_get https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.22_x64.msi "${VM_PATH}/unattended"
|
|
unattended_windows "${VM_PATH}/unattended/autounattend.xml"
|
|
mkisofs -quiet -l -o "${VM_PATH}/unattended.iso" "${VM_PATH}/unattended/"
|
|
;;
|
|
esac
|
|
make_vm_config "${FILE_NAME}" "virtio-win.iso"
|
|
}
|
|
|
|
LANGS=()
|
|
languages_windows
|
|
|
|
if [ -n "${1}" ]; then
|
|
OS="${1,,}"
|
|
if [ "${OS}" == "list" ] || [ "${OS}" == "list_csv" ]; then
|
|
list_csv
|
|
elif [ "${OS}" == "list_json" ]; then
|
|
list_json
|
|
fi
|
|
else
|
|
echo "ERROR! You must specify an operating system:"
|
|
os_support
|
|
exit 1
|
|
fi
|
|
|
|
if [ -n "${2}" ]; then
|
|
RELEASE="${2,,}"
|
|
VM_PATH="${OS}-${RELEASE}"
|
|
|
|
if [ "${OS}" == "elementary" ]; then
|
|
get_elementary
|
|
elif [ "${OS}" == "macos" ]; then
|
|
get_macos
|
|
elif [ "${OS}" == "freebsd" ]; then
|
|
get_freebsd
|
|
elif [ "${OS}" == "fedora" ]; then
|
|
get_fedora
|
|
elif [ "${OS}" == "kali" ]; then
|
|
get_kali
|
|
elif [[ "${OS}" == *"linuxmint-"* ]]; then
|
|
get_linuxmint
|
|
elif [[ "${OS}" == *"nixos-"* ]]; then
|
|
get_nixos
|
|
elif [ "${OS}" == "openbsd" ]; then
|
|
get_openbsd
|
|
elif [ "${OS}" == "opensuse" ]; then
|
|
get_opensuse
|
|
elif [ "${OS}" == "popos" ]; then
|
|
if [ -n "${3}" ]; then
|
|
DRIVER="${3}"
|
|
DRIVERS=(intel nvidia)
|
|
if [[ ! ${DRIVERS[*]} =~ ${DRIVER} ]]; then
|
|
echo "ERROR! ${DRIVER} is not a supported driver:"
|
|
for DRIVER in "${DRIVERS[@]}"; do
|
|
echo "${DRIVER}"
|
|
done
|
|
exit 1
|
|
fi
|
|
else
|
|
DRIVER="intel"
|
|
fi
|
|
VM_PATH="${OS}-${RELEASE}-${DRIVER}"
|
|
get_popos "${DRIVER}"
|
|
elif [[ "${OS}" == *"ubuntu"* ]]; then
|
|
get_ubuntu
|
|
elif [ "${OS}" == "windows" ]; then
|
|
if [ -n "${3}" ]; then
|
|
LANG_NAME="${3}"
|
|
if [[ ! ${LANGS[*]} =~ ${LANG_NAME} ]]; then
|
|
echo "ERROR! ${LANG_NAME} is not a supported language:"
|
|
for LANG in "${LANGS[@]}"; do
|
|
echo "${LANG}"
|
|
done
|
|
exit 1
|
|
fi
|
|
else
|
|
LANG_NAME="English International"
|
|
fi
|
|
get_windows "${LANG_NAME}"
|
|
else
|
|
echo "ERROR! ${OS} is unknown:"
|
|
os_support
|
|
exit 1
|
|
fi
|
|
else
|
|
echo -n "ERROR! You must specify a release: "
|
|
if [ "${OS}" == "elementary" ]; then
|
|
releases_elementary
|
|
elif [ "${OS}" == "freebsd" ]; then
|
|
releases_freebsd
|
|
elif [ "${OS}" == "fedora" ]; then
|
|
releases_fedora
|
|
elif [ "${OS}" == "kali" ]; then
|
|
releases_kali
|
|
elif [[ "${OS}" == *"linuxmint-"* ]]; then
|
|
releases_linuxmint
|
|
elif [[ "${OS}" == *"nixos-"* ]]; then
|
|
releases_nixos
|
|
elif [ "${OS}" == "opensuse" ]; then
|
|
releases_opensuse
|
|
elif [ "${OS}" == "openbsd" ]; then
|
|
releases_openbsd
|
|
elif [ "${OS}" == "macos" ]; then
|
|
releases_macos
|
|
elif [ "${OS}" == "popos" ]; then
|
|
releases_popos
|
|
elif [[ "${OS}" == *"ubuntu"* ]]; then
|
|
releases_ubuntu
|
|
elif [ "${OS}" == "windows" ]; then
|
|
releases_windows
|
|
else
|
|
echo "${OS} is unknown"
|
|
os_support
|
|
fi
|
|
exit 1
|
|
fi
|