mkarchiso 42.4 KB
Newer Older
1
#!/usr/bin/env bash
2
3
#
# SPDX-License-Identifier: GPL-3.0-or-later
4

5
6
set -e -u

7
8
9
10
# Control the environment
umask 0022
export LANG="C"
export SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-"$(date +%s)"}"
11

12
# Set application name from the script's file name
13
app_name="${0##*/}"
14
15

# Define global variables. All of them will be overwritten later
16
pkg_list=()
17
18
19
20
quiet=""
work_dir=""
out_dir=""
img_name=""
21
gpg_key=""
22
23
24
25
iso_name=""
iso_label=""
iso_publisher=""
iso_application=""
26
iso_version=""
27
28
29
30
install_dir=""
arch=""
pacman_conf=""
packages=""
31
bootmodes=()
32
33
airootfs_image_type=""
airootfs_image_tool_options=()
34
declare -A file_permissions=()
35
36


37
38
39
40
# Show an INFO message
# $1: message string
_msg_info() {
    local _msg="${1}"
41
    [[ "${quiet}" == "y" ]] || printf '[%s] INFO: %s\n' "${app_name}" "${_msg}"
42
43
}

44
45
46
47
# Show a WARNING message
# $1: message string
_msg_warning() {
    local _msg="${1}"
48
    printf '[%s] WARNING: %s\n' "${app_name}" "${_msg}" >&2
49
50
}

51
52
53
54
55
56
# Show an ERROR message then exit with status
# $1: message string
# $2: exit code number (with 0 does not exit)
_msg_error() {
    local _msg="${1}"
    local _error=${2}
57
    printf '[%s] ERROR: %s\n' "${app_name}" "${_msg}" >&2
58
    if (( _error > 0 )); then
59
        exit "${_error}"
60
61
62
    fi
}

63
64
_mount_airootfs() {
    trap "_umount_airootfs" EXIT HUP INT TERM
65
66
    install -d -m 0755 -- "${work_dir}/mnt/airootfs"
    _msg_info "Mounting '${airootfs_dir}.img' on '${work_dir}/mnt/airootfs'..."
67
    mount -- "${airootfs_dir}.img" "${work_dir}/mnt/airootfs"
68
    _msg_info "Done!"
69
70
}

71
_umount_airootfs() {
72
    _msg_info "Unmounting '${work_dir}/mnt/airootfs'..."
73
    umount -d -- "${work_dir}/mnt/airootfs"
74
    _msg_info "Done!"
75
    rmdir -- "${work_dir}/mnt/airootfs"
76
77
78
79
80
    trap - EXIT HUP INT TERM
}

# Show help usage, with an exit status.
# $1: exit status number.
81
_usage() {
82
    IFS='' read -r -d '' usagetext <<ENDUSAGETEXT || true
83
usage: ${app_name} [options] <profile_dir>
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
  options:
     -A <application> Set an application name for the ISO
                      Default: '${iso_application}'
     -C <file>        pacman configuration file.
                      Default: '${pacman_conf}'
     -D <install_dir> Set an install_dir. All files will by located here.
                      Default: '${install_dir}'
                      NOTE: Max 8 characters, use only [a-z0-9]
     -L <label>       Set the ISO volume label
                      Default: '${iso_label}'
     -P <publisher>   Set the ISO publisher
                      Default: '${iso_publisher}'
     -g <gpg_key>     Set the GPG key to be used for signing the sqashfs image
     -h               This message
     -o <out_dir>     Set the output directory
                      Default: '${out_dir}'
100
101
     -p PACKAGE(S)    Package(s) to install.
                      Multiple packages are provided as quoted, space delimited list.
102
103
104
105
106
     -v               Enable verbose output
     -w <work_dir>    Set the working directory
                      Default: '${work_dir}'

  profile_dir:        Directory of the archiso profile to build
107
ENDUSAGETEXT
108
    printf '%s' "${usagetext}"
109
    exit "${1}"
110
111
}

112
# Shows configuration options.
113
_show_config() {
114
    local build_date
115
    build_date="$(date --utc --iso-8601=seconds -d "@${SOURCE_DATE_EPOCH}")"
116
    _msg_info "${app_name} configuration settings"
117
118
119
    _msg_info "             Architecture:   ${arch}"
    _msg_info "        Working directory:   ${work_dir}"
    _msg_info "   Installation directory:   ${install_dir}"
120
121
122
123
124
125
126
127
128
129
130
    _msg_info "               Build date:   ${build_date}"
    _msg_info "         Output directory:   ${out_dir}"
    _msg_info "                  GPG key:   ${gpg_key:-None}"
    _msg_info "                  Profile:   ${profile}"
    _msg_info "Pacman configuration file:   ${pacman_conf}"
    _msg_info "          Image file name:   ${img_name}"
    _msg_info "         ISO volume label:   ${iso_label}"
    _msg_info "            ISO publisher:   ${iso_publisher}"
    _msg_info "          ISO application:   ${iso_application}"
    _msg_info "               Boot modes:   ${bootmodes[*]}"
    _msg_info "                 Packages:   ${pkg_list[*]}"
131
132
}

133
# Cleanup airootfs
134
_cleanup_airootfs() {
135
    _msg_info "Cleaning up what we can on airootfs..."
136

137
    # Delete all files in /boot
138
    [[ -d "${airootfs_dir}/boot" ]] && find "${airootfs_dir}/boot" -mindepth 1 -delete
139
    # Delete pacman database sync cache files (*.tar.gz)
140
    [[ -d "${airootfs_dir}/var/lib/pacman" ]] && find "${airootfs_dir}/var/lib/pacman" -maxdepth 1 -type f -delete
141
    # Delete pacman database sync cache
142
    [[ -d "${airootfs_dir}/var/lib/pacman/sync" ]] && find "${airootfs_dir}/var/lib/pacman/sync" -delete
143
    # Delete pacman package cache
144
    [[ -d "${airootfs_dir}/var/cache/pacman/pkg" ]] && find "${airootfs_dir}/var/cache/pacman/pkg" -type f -delete
145
    # Delete all log files, keeps empty dirs.
146
    [[ -d "${airootfs_dir}/var/log" ]] && find "${airootfs_dir}/var/log" -type f -delete
147
    # Delete all temporary files and dirs
148
    [[ -d "${airootfs_dir}/var/tmp" ]] && find "${airootfs_dir}/var/tmp" -mindepth 1 -delete
149
    # Delete package pacman related files.
150
    find "${work_dir}" \( -name '*.pacnew' -o -name '*.pacsave' -o -name '*.pacorig' \) -delete
151
    # Create an empty /etc/machine-id
152
    rm -f -- "${airootfs_dir}/etc/machine-id"
153
    printf '' > "${airootfs_dir}/etc/machine-id"
154
155

    _msg_info "Done!"
156
}
157

158
159
160
161
_run_mksquashfs() {
    local image_path="${isofs_dir}/${install_dir}/${arch}/airootfs.sfs"
    if [[ "${quiet}" == "y" ]]; then
        mksquashfs "$@" "${image_path}" -noappend "${airootfs_image_tool_options[@]}" -no-progress > /dev/null
162
    else
163
        mksquashfs "$@" "${image_path}" -noappend "${airootfs_image_tool_options[@]}"
164
165
166
    fi
}

167
# Makes a ext4 filesystem inside a SquashFS from a source directory.
168
169
_mkairootfs_ext4+squashfs() {
    [[ -e "${airootfs_dir}" ]] || _msg_error "The path '${airootfs_dir}' does not exist" 1
170

171
    _msg_info "Creating ext4 image of 32 GiB..."
172
    if [[ "${quiet}" == "y" ]]; then
173
        mkfs.ext4 -q -O '^has_journal,^resize_inode' -E 'lazy_itable_init=0' -m 0 -F -- "${airootfs_dir}.img" 32G
174
    else
175
        mkfs.ext4 -O '^has_journal,^resize_inode' -E 'lazy_itable_init=0' -m 0 -F -- "${airootfs_dir}.img" 32G
176
    fi
177
    tune2fs -c 0 -i 0 -- "${airootfs_dir}.img" > /dev/null
178
    _msg_info "Done!"
179
    _mount_airootfs
180
181
    _msg_info "Copying '${airootfs_dir}/' to '${work_dir}/mnt/airootfs/'..."
    cp -aT -- "${airootfs_dir}/" "${work_dir}/mnt/airootfs/"
182
    chown -- 0:0 "${work_dir}/mnt/airootfs/"
183
    _msg_info "Done!"
184
    _umount_airootfs
185
    install -d -m 0755 -- "${isofs_dir}/${install_dir}/${arch}"
186
    _msg_info "Creating SquashFS image, this may take some time..."
187
    _run_mksquashfs "${airootfs_dir}.img"
188
    _msg_info "Done!"
189
    rm -- "${airootfs_dir}.img"
190
191
}

192
# Makes a SquashFS filesystem from a source directory.
193
194
_mkairootfs_squashfs() {
    [[ -e "${airootfs_dir}" ]] || _msg_error "The path '${airootfs_dir}' does not exist" 1
195

196
    install -d -m 0755 -- "${isofs_dir}/${install_dir}/${arch}"
197
    _msg_info "Creating SquashFS image, this may take some time..."
198
    _run_mksquashfs "${airootfs_dir}"
nl6720's avatar
nl6720 committed
199
200
201
202
203
204
205
206
207
208
209
210
211
}

# Makes an EROFS file system from a source directory.
_mkairootfs_erofs() {
    local fsuuid
    [[ -e "${airootfs_dir}" ]] || _msg_error "The path '${airootfs_dir}' does not exist" 1

    install -d -m 0755 -- "${isofs_dir}/${install_dir}/${arch}"
    local image_path="${isofs_dir}/${install_dir}/${arch}/airootfs.erofs"
    # Generate reproducible file system UUID from SOURCE_DATE_EPOCH
    fsuuid="$(uuidgen --sha1 --namespace 93a870ff-8565-4cf3-a67b-f47299271a96 --name "${SOURCE_DATE_EPOCH}")"
    _msg_info "Creating EROFS image, this may take some time..."
    mkfs.erofs -U "${fsuuid}" "${airootfs_image_tool_options[@]}" -- "${image_path}" "${airootfs_dir}"
212
213
214
    _msg_info "Done!"
}

215
_mkchecksum() {
216
    _msg_info "Creating checksum file for self-test..."
217
    cd -- "${isofs_dir}/${install_dir}/${arch}"
nl6720's avatar
nl6720 committed
218
219
220
221
222
    if [[ -e "${isofs_dir}/${install_dir}/${arch}/airootfs.sfs" ]]; then
        sha512sum airootfs.sfs > airootfs.sha512
    elif [[ -e "${isofs_dir}/${install_dir}/${arch}/airootfs.erofs" ]]; then
        sha512sum airootfs.erofs > airootfs.sha512
    fi
223
    cd -- "${OLDPWD}"
224
    _msg_info "Done!"
225
226
}

227
228
_mksignature() {
    _msg_info "Signing SquashFS image..."
229
    cd -- "${isofs_dir}/${install_dir}/${arch}"
230
    # always use the .sig file extension, as that is what mkinitcpio-archiso's hooks expect
nl6720's avatar
nl6720 committed
231
    if [[ -e "${isofs_dir}/${install_dir}/${arch}/airootfs.sfs" ]]; then
232
        gpg --output airootfs.sfs.sig --detach-sign --default-key "${gpg_key}" airootfs.sfs
nl6720's avatar
nl6720 committed
233
    elif [[ -e "${isofs_dir}/${install_dir}/${arch}/airootfs.erofs" ]]; then
234
        gpg --output airootfs.erofs.sig --detach-sign --default-key "${gpg_key}" airootfs.erofs
nl6720's avatar
nl6720 committed
235
    fi
236
    cd -- "${OLDPWD}"
237
238
239
    _msg_info "Done!"
}

240
241
242
243
244
245
246
# Helper function to run functions only one time.
_run_once() {
    if [[ ! -e "${work_dir}/build.${1}" ]]; then
        "$1"
        touch "${work_dir}/build.${1}"
    fi
}
247

248
# Set up custom pacman.conf with custom cache and pacman hook directories
249
_make_pacman_conf() {
250
251
252
253
254
255
256
257
258
259
260
261
262
263
    local _cache_dirs _system_cache_dirs _profile_cache_dirs
    _system_cache_dirs="$(pacman-conf CacheDir| tr '\n' ' ')"
    _profile_cache_dirs="$(pacman-conf --config "${pacman_conf}" CacheDir| tr '\n' ' ')"

    # only use the profile's CacheDir, if it is not the default and not the same as the system cache dir
    if [[ "${_profile_cache_dirs}" != "/var/cache/pacman/pkg" ]] && \
        [[ "${_system_cache_dirs}" != "${_profile_cache_dirs}" ]]; then
        _cache_dirs="${_profile_cache_dirs}"
    else
        _cache_dirs="${_system_cache_dirs}"
    fi

    _msg_info "Copying custom pacman.conf to work directory..."
    _msg_info "Using pacman CacheDir: ${_cache_dirs}"
264
    # take the profile pacman.conf and strip all settings that would break in chroot when using pacman -r
265
266
    # append CacheDir and HookDir to [options] section
    # HookDir is *always* set to the airootfs' override directory
267
268
269
270
    # see `man 8 pacman` for further info
    pacman-conf --config "${pacman_conf}" | \
        sed "/CacheDir/d;/DBPath/d;/HookDir/d;/LogFile/d;/RootDir/d;/\[options\]/a CacheDir = ${_cache_dirs}
        /\[options\]/a HookDir = ${airootfs_dir}/etc/pacman.d/hooks/" > "${work_dir}/pacman.conf"
271
272
273
274
275
}

# Prepare working directory and copy custom airootfs files (airootfs)
_make_custom_airootfs() {
    local passwd=()
276
    local filename permissions
277
278
279

    install -d -m 0755 -o 0 -g 0 -- "${airootfs_dir}"

280
    if [[ -d "${profile}/airootfs" ]]; then
281
282
283
284
285
        _msg_info "Copying custom airootfs files..."
        cp -af --no-preserve=ownership,mode -- "${profile}/airootfs/." "${airootfs_dir}"
        # Set ownership and mode for files and directories
        for filename in "${!file_permissions[@]}"; do
            IFS=':' read -ra permissions <<< "${file_permissions["${filename}"]}"
286
            # Prevent file path traversal outside of $airootfs_dir
287
            if [[ "$(realpath -q -- "${airootfs_dir}${filename}")" != "${airootfs_dir}"* ]]; then
288
289
290
                _msg_error "Failed to set permissions on '${airootfs_dir}${filename}'. Outside of valid path." 1
            # Warn if the file does not exist
            elif [[ ! -e "${airootfs_dir}${filename}" ]]; then
291
                _msg_warning "Cannot change permissions of '${airootfs_dir}${filename}'. The file or directory does not exist."
292
            else
293
294
295
296
297
298
299
                if [[ "${filename: -1}" == "/" ]]; then
                    chown -fhR -- "${permissions[0]}:${permissions[1]}" "${airootfs_dir}${filename}"
                    chmod -fR -- "${permissions[2]}" "${airootfs_dir}${filename}"
                else
                    chown -fh -- "${permissions[0]}:${permissions[1]}" "${airootfs_dir}${filename}"
                    chmod -f -- "${permissions[2]}" "${airootfs_dir}${filename}"
                fi
300
301
            fi
        done
302
        _msg_info "Done!"
303
304
305
    fi
}

306
# Install desired packages to airootfs
307
_make_packages() {
308
309
    _msg_info "Installing packages to '${airootfs_dir}/'..."

310
311
312
313
    if [[ -n "${gpg_key}" ]]; then
        exec {ARCHISO_GNUPG_FD}<>"${work_dir}/pubkey.gpg"
        export ARCHISO_GNUPG_FD
    fi
314
315
316
317
318
319
320

    if [[ "${quiet}" = "y" ]]; then
        pacstrap -C "${work_dir}/pacman.conf" -c -G -M -- "${airootfs_dir}" "${pkg_list[@]}" &> /dev/null
    else
        pacstrap -C "${work_dir}/pacman.conf" -c -G -M -- "${airootfs_dir}" "${pkg_list[@]}"
    fi

321
322
323
324
    if [[ -n "${gpg_key}" ]]; then
        exec {ARCHISO_GNUPG_FD}<&-
        unset ARCHISO_GNUPG_FD
    fi
325
326

    _msg_info "Done! Packages installed successfully."
327
328
329
330
331
}

# Customize installation (airootfs)
_make_customize_airootfs() {
    local passwd=()
332

333
    if [[ -e "${profile}/airootfs/etc/passwd" ]]; then
334
        _msg_info "Copying /etc/skel/* to user homes..."
335
        while IFS=':' read -a passwd -r; do
336
            # Only operate on UIDs in range 1000–59999
337
            (( passwd[2] >= 1000 && passwd[2] < 60000 )) || continue
338
            # Skip invalid home directories
339
340
            [[ "${passwd[5]}" == '/' ]] && continue
            [[ -z "${passwd[5]}" ]] && continue
341
342
343
344
345
346
347
348
349
350
            # Prevent path traversal outside of $airootfs_dir
            if [[ "$(realpath -q -- "${airootfs_dir}${passwd[5]}")" == "${airootfs_dir}"* ]]; then
                if [[ ! -d "${airootfs_dir}${passwd[5]}" ]]; then
                    install -d -m 0750 -o "${passwd[2]}" -g "${passwd[3]}" -- "${airootfs_dir}${passwd[5]}"
                fi
                cp -dnRT --preserve=mode,timestamps,links -- "${airootfs_dir}/etc/skel/." "${airootfs_dir}${passwd[5]}"
                chmod -f 0750 -- "${airootfs_dir}${passwd[5]}"
                chown -hR -- "${passwd[2]}:${passwd[3]}" "${airootfs_dir}${passwd[5]}"
            else
                _msg_error "Failed to set permissions on '${airootfs_dir}${passwd[5]}'. Outside of valid path." 1
351
            fi
352
        done < "${profile}/airootfs/etc/passwd"
353
        _msg_info "Done!"
354
355
356
    fi

    if [[ -e "${airootfs_dir}/root/customize_airootfs.sh" ]]; then
357
        _msg_info "Running customize_airootfs.sh in '${airootfs_dir}' chroot..."
358
        _msg_warning "customize_airootfs.sh is deprecated! Support for it will be removed in a future archiso version."
359
        chmod -f -- +x "${airootfs_dir}/root/customize_airootfs.sh"
360
        eval -- arch-chroot "${airootfs_dir}" "/root/customize_airootfs.sh"
361
        rm -- "${airootfs_dir}/root/customize_airootfs.sh"
362
        _msg_info "Done! customize_airootfs.sh run successfully."
363
364
365
    fi
}

366
367
368
369
# Set up boot loaders
_make_bootmodes() {
    local bootmode
    for bootmode in "${bootmodes[@]}"; do
370
        _run_once "_make_bootmode_${bootmode}"
371
372
373
    done
}

374
# Prepare kernel/initramfs ${install_dir}/boot/
375
_make_boot_on_iso9660() {
376
    local ucode_image
Christian Hesse's avatar
Christian Hesse committed
377
    _msg_info "Preparing kernel and initramfs for the ISO 9660 file system..."
378
    install -d -m 0755 -- "${isofs_dir}/${install_dir}/boot/${arch}"
379
380
381
382
383
384
385
386
387
388
389
390
391
    install -m 0644 -- "${airootfs_dir}/boot/initramfs-"*".img" "${isofs_dir}/${install_dir}/boot/${arch}/"
    install -m 0644 -- "${airootfs_dir}/boot/vmlinuz-"* "${isofs_dir}/${install_dir}/boot/${arch}/"

    for ucode_image in {intel-uc.img,intel-ucode.img,amd-uc.img,amd-ucode.img,early_ucode.cpio,microcode.cpio}; do
        if [[ -e "${airootfs_dir}/boot/${ucode_image}" ]]; then
            install -m 0644 -- "${airootfs_dir}/boot/${ucode_image}" "${isofs_dir}/${install_dir}/boot/"
            if [[ -e "${airootfs_dir}/usr/share/licenses/${ucode_image%.*}/" ]]; then
                install -d -m 0755 -- "${isofs_dir}/${install_dir}/boot/licenses/${ucode_image%.*}/"
                install -m 0644 -- "${airootfs_dir}/usr/share/licenses/${ucode_image%.*}/"* \
                    "${isofs_dir}/${install_dir}/boot/licenses/${ucode_image%.*}/"
            fi
        fi
    done
392
    _msg_info "Done!"
393
394
}

nl6720's avatar
nl6720 committed
395
# Prepare /syslinux for booting from MBR
396
_make_bootmode_bios.syslinux.mbr() {
397
    _msg_info "Setting up SYSLINUX for BIOS booting from a disk..."
nl6720's avatar
nl6720 committed
398
    install -d -m 0755 -- "${isofs_dir}/syslinux"
399
400
    for _cfg in "${profile}/syslinux/"*.cfg; do
        sed "s|%ARCHISO_LABEL%|${iso_label}|g;
401
402
             s|%INSTALL_DIR%|${install_dir}|g;
             s|%ARCH%|${arch}|g" \
nl6720's avatar
nl6720 committed
403
             "${_cfg}" > "${isofs_dir}/syslinux/${_cfg##*/}"
404
    done
405
    if [[ -e "${profile}/syslinux/splash.png" ]]; then
nl6720's avatar
nl6720 committed
406
        install -m 0644 -- "${profile}/syslinux/splash.png" "${isofs_dir}/syslinux/"
407
    fi
nl6720's avatar
nl6720 committed
408
409
410
    install -m 0644 -- "${airootfs_dir}/usr/lib/syslinux/bios/"*.c32 "${isofs_dir}/syslinux/"
    install -m 0644 -- "${airootfs_dir}/usr/lib/syslinux/bios/lpxelinux.0" "${isofs_dir}/syslinux/"
    install -m 0644 -- "${airootfs_dir}/usr/lib/syslinux/bios/memdisk" "${isofs_dir}/syslinux/"
411

412
    _run_once _make_boot_on_iso9660
413

nl6720's avatar
nl6720 committed
414
415
    if [[ -e "${isofs_dir}/syslinux/hdt.c32" ]]; then
        install -d -m 0755 -- "${isofs_dir}/syslinux/hdt"
416
        if [[ -e "${airootfs_dir}/usr/share/hwdata/pci.ids" ]]; then
417
            gzip -cn9 "${airootfs_dir}/usr/share/hwdata/pci.ids" > \
nl6720's avatar
nl6720 committed
418
                "${isofs_dir}/syslinux/hdt/pciids.gz"
419
        fi
420
        find "${airootfs_dir}/usr/lib/modules" -name 'modules.alias' -print -exec gzip -cn9 '{}' ';' -quit > \
nl6720's avatar
nl6720 committed
421
            "${isofs_dir}/syslinux/hdt/modalias.gz"
422
    fi
423
424
425
426
427

    # Add other aditional/extra files to ${install_dir}/boot/
    if [[ -e "${airootfs_dir}/boot/memtest86+/memtest.bin" ]]; then
        # rename for PXE: https://wiki.archlinux.org/index.php/Syslinux#Using_memtest
        install -m 0644 -- "${airootfs_dir}/boot/memtest86+/memtest.bin" "${isofs_dir}/${install_dir}/boot/memtest"
428
        install -d -m 0755 -- "${isofs_dir}/${install_dir}/boot/licenses/memtest86+/"
429
430
431
        install -m 0644 -- "${airootfs_dir}/usr/share/licenses/common/GPL2/license.txt" \
            "${isofs_dir}/${install_dir}/boot/licenses/memtest86+/"
    fi
432
    _msg_info "Done! SYSLINUX set up for BIOS booting from a disk successfully."
433
434
}

nl6720's avatar
nl6720 committed
435
# Prepare /syslinux for El-Torito booting
436
_make_bootmode_bios.syslinux.eltorito() {
437
    _msg_info "Setting up SYSLINUX for BIOS booting from an optical disc..."
nl6720's avatar
nl6720 committed
438
439
440
    install -d -m 0755 -- "${isofs_dir}/syslinux"
    install -m 0644 -- "${airootfs_dir}/usr/lib/syslinux/bios/isolinux.bin" "${isofs_dir}/syslinux/"
    install -m 0644 -- "${airootfs_dir}/usr/lib/syslinux/bios/isohdpfx.bin" "${isofs_dir}/syslinux/"
441

nl6720's avatar
nl6720 committed
442
    # ISOLINUX and SYSLINUX installation is shared
443
    _run_once _make_bootmode_bios.syslinux.mbr
444
445

    _msg_info "Done! SYSLINUX set up for BIOS booting from an optical disc successfully."
446
447
448
}

# Prepare /EFI on ISO-9660
449
_make_efi_dir_on_iso9660() {
450
451
    _msg_info "Preparing an /EFI directory for the ISO 9660 file system..."
    install -d -m 0755 -- "${isofs_dir}/EFI/BOOT"
452
453
454
    install -m 0644 -- "${airootfs_dir}/usr/lib/systemd/boot/efi/systemd-bootx64.efi" \
        "${isofs_dir}/EFI/BOOT/BOOTx64.EFI"

455
    install -d -m 0755 -- "${isofs_dir}/loader/entries"
456
457
    install -m 0644 -- "${profile}/efiboot/loader/loader.conf" "${isofs_dir}/loader/"

458
459
460
461
462
463
    for _conf in "${profile}/efiboot/loader/entries/"*".conf"; do
        sed "s|%ARCHISO_LABEL%|${iso_label}|g;
             s|%INSTALL_DIR%|${install_dir}|g;
             s|%ARCH%|${arch}|g" \
            "${_conf}" > "${isofs_dir}/loader/entries/${_conf##*/}"
    done
464
465
466

    # edk2-shell based UEFI shell
    # shellx64.efi is picked up automatically when on /
467
468
469
    if [[ -e "${airootfs_dir}/usr/share/edk2-shell/x64/Shell_Full.efi" ]]; then
        install -m 0644 -- "${airootfs_dir}/usr/share/edk2-shell/x64/Shell_Full.efi" "${isofs_dir}/shellx64.efi"
    fi
470
    _msg_info "Done!"
471
472
}

473
474
# Prepare kernel/initramfs on efiboot.img
_make_boot_on_fat() {
475
    local ucode_image all_ucode_images=()
Christian Hesse's avatar
Christian Hesse committed
476
    _msg_info "Preparing kernel and initramfs for the FAT file system..."
477
    mmd -i "${work_dir}/efiboot.img" \
478
        "::/${install_dir}" "::/${install_dir}/boot" "::/${install_dir}/boot/${arch}"
479
    mcopy -i "${work_dir}/efiboot.img" "${airootfs_dir}/boot/vmlinuz-"* \
480
481
482
483
484
485
486
487
488
        "${airootfs_dir}/boot/initramfs-"*".img" "::/${install_dir}/boot/${arch}/"
    for ucode_image in \
        "${airootfs_dir}/boot/"{intel-uc.img,intel-ucode.img,amd-uc.img,amd-ucode.img,early_ucode.cpio,microcode.cpio}
    do
        if [[ -e "${ucode_image}" ]]; then
            all_ucode_images+=("${ucode_image}")
        fi
    done
    if (( ${#all_ucode_images[@]} )); then
489
        mcopy -i "${work_dir}/efiboot.img" "${all_ucode_images[@]}" "::/${install_dir}/boot/"
490
    fi
491
    _msg_info "Done!"
492
493
494
}

# Prepare efiboot.img::/EFI for EFI boot mode
495
_make_bootmode_uefi-x64.systemd-boot.esp() {
496
    local efiboot_imgsize="0"
497
    _msg_info "Setting up systemd-boot for UEFI booting..."
498

499
500
    # the required image size in KiB (rounded up to the next full MiB with an additional MiB for reserved sectors)
    efiboot_imgsize="$(du -bc \
501
502
503
504
505
506
        "${airootfs_dir}/usr/lib/systemd/boot/efi/systemd-bootx64.efi" \
        "${airootfs_dir}/usr/share/edk2-shell/x64/Shell_Full.efi" \
        "${profile}/efiboot/" \
        "${airootfs_dir}/boot/vmlinuz-"* \
        "${airootfs_dir}/boot/initramfs-"*".img" \
        "${airootfs_dir}/boot/"{intel-uc.img,intel-ucode.img,amd-uc.img,amd-ucode.img,early_ucode.cpio,microcode.cpio} \
507
508
509
510
511
        2>/dev/null | awk 'function ceil(x){return int(x)+(x>int(x))}
            function byte_to_kib(x){return x/1024}
            function mib_to_kib(x){return x*1024}
            END {print mib_to_kib(ceil((byte_to_kib($1)+1024)/1024))}'
        )"
512
513
    # The FAT image must be created with mkfs.fat not mformat, as some systems have issues with mformat made images:
    # https://lists.gnu.org/archive/html/grub-devel/2019-04/msg00099.html
514
    [[ -e "${work_dir}/efiboot.img" ]] && rm -f -- "${work_dir}/efiboot.img"
515
    _msg_info "Creating FAT image of size: ${efiboot_imgsize} KiB..."
516
    mkfs.fat -C -n ARCHISO_EFI "${work_dir}/efiboot.img" "$efiboot_imgsize"
517

518
519
    mmd -i "${work_dir}/efiboot.img" ::/EFI ::/EFI/BOOT
    mcopy -i "${work_dir}/efiboot.img" \
520
        "${airootfs_dir}/usr/lib/systemd/boot/efi/systemd-bootx64.efi" ::/EFI/BOOT/BOOTx64.EFI
521

522
523
    mmd -i "${work_dir}/efiboot.img" ::/loader ::/loader/entries
    mcopy -i "${work_dir}/efiboot.img" "${profile}/efiboot/loader/loader.conf" ::/loader/
524
525
526
527
    for _conf in "${profile}/efiboot/loader/entries/"*".conf"; do
        sed "s|%ARCHISO_LABEL%|${iso_label}|g;
             s|%INSTALL_DIR%|${install_dir}|g;
             s|%ARCH%|${arch}|g" \
528
            "${_conf}" | mcopy -i "${work_dir}/efiboot.img" - "::/loader/entries/${_conf##*/}"
529
    done
530
531

    # shellx64.efi is picked up automatically when on /
532
    if [[ -e "${airootfs_dir}/usr/share/edk2-shell/x64/Shell_Full.efi" ]]; then
533
        mcopy -i "${work_dir}/efiboot.img" \
534
            "${airootfs_dir}/usr/share/edk2-shell/x64/Shell_Full.efi" ::/shellx64.efi
535
536
537
    fi

    # Copy kernel and initramfs
538
    _make_boot_on_fat
539

540
    _msg_info "Done! systemd-boot set up for UEFI booting successfully."
541
542
}

543
# Prepare efiboot.img::/EFI for "El Torito" EFI boot mode
544
545
546
547
_make_bootmode_uefi-x64.systemd-boot.eltorito() {
    _run_once _make_bootmode_uefi-x64.systemd-boot.esp
    # Set up /EFI on ISO-9660 to allow preparing an installation medium by manually copying files
    _run_once _make_efi_dir_on_iso9660
548
549
}

550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
_validate_requirements_bootmode_bios.syslinux.mbr() {
    # bios.syslinux.mbr requires bios.syslinux.eltorito
    # shellcheck disable=SC2076
    if [[ ! " ${bootmodes[*]} " =~ ' bios.syslinux.eltorito ' ]]; then
        (( validation_error=validation_error+1 ))
        _msg_error "Using 'bios.syslinux.mbr' boot mode without 'bios.syslinux.eltorito' is not supported." 0
    fi

    # Check if the syslinux package is in the package list
    # shellcheck disable=SC2076
    if [[ ! " ${pkg_list[*]} " =~ ' syslinux ' ]]; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${bootmode}': The 'syslinux' package is missing from the package list!" 0
    fi

    # Check if syslinux configuration files exist
    if [[ ! -d "${profile}/syslinux" ]]; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${bootmode}': The '${profile}/syslinux' directory is missing!" 0
569
    else
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
        local cfgfile
        for cfgfile in "${profile}/syslinux/"*'.cfg'; do
            if [[ -e "${cfgfile}" ]]; then
                break
            else
                (( validation_error=validation_error+1 ))
                _msg_error "Validating '${bootmode}': No configuration file found in '${profile}/syslinux/'!" 0
            fi
        done
    fi

    # Check for optional packages
    # shellcheck disable=SC2076
    if [[ ! " ${pkg_list[*]} " =~ ' memtest86+ ' ]]; then
        _msg_info "Validating '${bootmode}': 'memtest86+' is not in the package list. Memmory testing will not be available from syslinux."
585
    fi
586
}
587

588
_validate_requirements_bootmode_bios.syslinux.eltorito() {
nl6720's avatar
nl6720 committed
589
    _validate_requirements_bootmode_bios.syslinux.mbr
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
}

_validate_requirements_bootmode_uefi-x64.systemd-boot.esp() {
    # Check if mkfs.fat is available
    if ! command -v mkfs.fat &> /dev/null; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${bootmode}': mkfs.fat is not available on this host. Install 'dosfstools'!" 0
    fi

    # Check if mmd and mcopy are available
    if ! { command -v mmd &> /dev/null && command -v mcopy &> /dev/null; }; then
        _msg_error "Validating '${bootmode}': mmd and/or mcopy are not available on this host. Install 'mtools'!" 0
    fi

    # Check if systemd-boot configuration files exist
    if [[ ! -d "${profile}/efiboot/loader/entries" ]]; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${bootmode}': The '${profile}/efiboot/loader/entries' directory is missing!" 0
    else
        if [[ ! -e "${profile}/efiboot/loader/loader.conf" ]]; then
            (( validation_error=validation_error+1 ))
            _msg_error "Validating '${bootmode}': File '${profile}/efiboot/loader/loader.conf' not found!" 0
        fi
        local conffile
        for conffile in "${profile}/efiboot/loader/entries/"*'.conf'; do
            if [[ -e "${conffile}" ]]; then
                break
            else
                (( validation_error=validation_error+1 ))
                _msg_error "Validating '${bootmode}': No configuration file found in '${profile}/efiboot/loader/entries/'!" 0
            fi
        done
    fi

    # Check for optional packages
    # shellcheck disable=SC2076
    if [[ ! " ${pkg_list[*]} " =~ ' edk2-shell ' ]]; then
        _msg_info "'edk2-shell' is not in the package list. The ISO will not contain a bootable UEFI shell."
    fi
}

_validate_requirements_bootmode_uefi-x64.systemd-boot.eltorito() {
    # uefi-x64.systemd-boot.eltorito has the exact same requirements as uefi-x64.systemd-boot.esp
    _validate_requirements_bootmode_uefi-x64.systemd-boot.esp
}

# Build airootfs filesystem image
_prepare_airootfs_image() {
    _run_once "_mkairootfs_${airootfs_image_type}"
639
    _mkchecksum
David Runge's avatar
David Runge committed
640
641
642
    if [[ -n "${gpg_key}" ]]; then
        _mksignature
    fi
643
644
}

645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
_validate_requirements_airootfs_image_type_squashfs() {
    if ! command -v mksquashfs &> /dev/null; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${airootfs_image_type}': mksquashfs is not available on this host. Install 'squashfs-tools'!" 0
    fi
}

_validate_requirements_airootfs_image_type_ext4+squashfs() {
    if ! { command -v mkfs.ext4 &> /dev/null && command -v tune2fs &> /dev/null; }; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${airootfs_image_type}': mkfs.ext4 and/or tune2fs is not available on this host. Install 'e2fsprogs'!" 0
    fi
    _validate_requirements_airootfs_image_type_squashfs
}

nl6720's avatar
nl6720 committed
660
661
662
663
664
665
666
_validate_requirements_airootfs_image_type_erofs() {
    if ! command -v mkfs.erofs; then
        (( validation_error=validation_error+1 ))
        _msg_error "Validating '${airootfs_image_type}': mkfs.erofs is not available on this host. Install 'erofs-utils'!" 0
    fi
}

667
668
669
670
# SYSLINUX El Torito
_add_xorrisofs_options_bios.syslinux.eltorito() {
    xorrisofs_options+=(
        # El Torito boot image for x86 BIOS
nl6720's avatar
nl6720 committed
671
        '-eltorito-boot' 'syslinux/isolinux.bin'
672
        # El Torito boot catalog file
nl6720's avatar
nl6720 committed
673
        '-eltorito-catalog' 'syslinux/boot.cat'
674
675
676
677
678
679
680
681
        # Required options to boot with ISOLINUX
        '-no-emul-boot' '-boot-load-size' '4' '-boot-info-table'
    )
}

# SYSLINUX MBR
_add_xorrisofs_options_bios.syslinux.mbr() {
    xorrisofs_options+=(
nl6720's avatar
nl6720 committed
682
683
        # SYSLINUX MBR bootstrap code; does not work without "-eltorito-boot syslinux/isolinux.bin"
        '-isohybrid-mbr' "${isofs_dir}/syslinux/isohdpfx.bin"
684
685
        # When GPT is used, create an additional partition in the MBR (besides 0xEE) for sectors 0–1 (MBR
        # bootstrap code area) and mark it as bootable
686
        # May allow booting on some systems
687
688
        # https://wiki.archlinux.org/index.php/Partitioning#Tricking_old_BIOS_into_booting_from_GPT
        '--mbr-force-bootable'
689
        # Move the first partition away from the start of the ISO to match the expectations of partition editors
690
691
692
693
694
695
696
697
698
699
700
701
        # May allow booting on some systems
        # https://dev.lovelyhq.com/libburnia/libisoburn/src/branch/master/doc/partition_offset.wiki
        '-partition_offset' '16'
    )
}

# systemd-boot in an attached EFI system partition
_add_xorrisofs_options_uefi-x64.systemd-boot.esp() {
    # Move the first partition away from the start of the ISO, otherwise the GPT will not be valid and ISO 9660
    # partition will not be mountable
    # shellcheck disable=SC2076
    [[ " ${xorrisofs_options[*]} " =~ ' -partition_offset ' ]] || xorrisofs_options+=('-partition_offset' '16')
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
    # Attach efiboot.img as a second partition and set its partition type to "EFI system partition"
    xorrisofs_options+=('-append_partition' '2' 'C12A7328-F81F-11D2-BA4B-00A0C93EC93B' "${work_dir}/efiboot.img")
    # Ensure GPT is used as some systems do not support UEFI booting without it
    # shellcheck disable=SC2076
    if [[ " ${bootmodes[*]} " =~ ' bios.syslinux.mbr ' ]]; then
        # A valid GPT prevents BIOS booting on some systems, instead use an invalid GPT (without a protective MBR).
        # The attached partition will have the EFI system partition type code in MBR, but in the invalid GPT it will
        # have a Microsoft basic partition type code.
        if [[ ! " ${bootmodes[*]} " =~ ' uefi-x64.systemd-boot.eltorito ' ]]; then
            # If '-isohybrid-gpt-basdat' is specified before '-e', then the appended EFI system partition will have the
            # EFI system partition type ID/GUID in both MBR and GPT. If '-isohybrid-gpt-basdat' is specified after '-e',
            # the appended EFI system partition will have the Microsoft basic data type GUID in GPT.
            if [[ ! " ${xorrisofs_options[*]} " =~ ' -isohybrid-gpt-basdat ' ]]; then
                xorrisofs_options+=('-isohybrid-gpt-basdat')
            fi
        fi
    else
        # Use valid GPT if BIOS booting support will not be required
        xorrisofs_options+=('-appended_part_as_gpt')
    fi
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
}

# systemd-boot via El Torito
_add_xorrisofs_options_uefi-x64.systemd-boot.eltorito() {
    # shellcheck disable=SC2076
    if [[ " ${bootmodes[*]} " =~ ' uefi-x64.systemd-boot.esp ' ]]; then
        # systemd-boot in an attached EFI system partition via El Torito
        xorrisofs_options+=(
            # Start a new El Torito boot entry for UEFI
            '-eltorito-alt-boot'
            # Set the second partition as the El Torito UEFI boot image
            '-e' '--interval:appended_partition_2:all::'
            # Boot image is not emulating floppy or hard disk; required for all known boot loaders
            '-no-emul-boot'
        )
737
738
739
740
741
742
743
744
745
        # A valid GPT prevents BIOS booting on some systems, use an invalid GPT instead.
        if [[ " ${bootmodes[*]} " =~ ' bios.syslinux.mbr ' ]]; then
            # If '-isohybrid-gpt-basdat' is specified before '-e', then the appended EFI system partition will have the
            # EFI system partition type ID/GUID in both MBR and GPT. If '-isohybrid-gpt-basdat' is specified after '-e',
            # the appended EFI system partition will have the Microsoft basic data type GUID in GPT.
            if [[ ! " ${xorrisofs_options[*]} " =~ ' -isohybrid-gpt-basdat ' ]]; then
                xorrisofs_options+=('-isohybrid-gpt-basdat')
            fi
        fi
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
    else
        # The ISO will not contain a GPT partition table, so to be able to reference efiboot.img, place it as a
        # file inside the ISO 9660 file system
        install -d -m 0755 -- "${isofs_dir}/EFI/archiso"
        cp -a -- "${work_dir}/efiboot.img" "${isofs_dir}/EFI/archiso/efiboot.img"
        # systemd-boot in an embedded efiboot.img via El Torito
        xorrisofs_options+=(
            # Start a new El Torito boot entry for UEFI
            '-eltorito-alt-boot'
            # Set efiboot.img as the El Torito UEFI boot image
            '-e' 'EFI/archiso/efiboot.img'
            # Boot image is not emulating floppy or hard disk; required for all known boot loaders
            '-no-emul-boot'
        )
    fi
    # Specify where to save the El Torito boot catalog file in case it is not already set by bios.syslinux.eltorito
    # shellcheck disable=SC2076
    [[ " ${bootmodes[*]} " =~ ' bios.' ]] || xorrisofs_options+=('-eltorito-catalog' 'EFI/boot.cat')
}

766
# Build ISO
767
_build_iso() {
768
    local xorrisofs_options=()
769
    local bootmode
770

771
772
    [[ -d "${out_dir}" ]] || install -d -- "${out_dir}"

773
    [[ "${quiet}" == "y" ]] && xorrisofs_options+=('-quiet')
774

775
776
777
778
    # Add required xorrisofs options for each boot mode
    for bootmode in "${bootmodes[@]}"; do
        typeset -f "_add_xorrisofs_options_${bootmode}" &> /dev/null && "_add_xorrisofs_options_${bootmode}"
    done
779
780
781
782
783

    _msg_info "Creating ISO image..."
    xorriso -as mkisofs \
            -iso-level 3 \
            -full-iso9660-filenames \
nl6720's avatar
nl6720 committed
784
785
            -joliet \
            -joliet-long \
786
787
788
789
790
791
792
793
            -rational-rock \
            -volid "${iso_label}" \
            -appid "${iso_application}" \
            -publisher "${iso_publisher}" \
            -preparer "prepared by ${app_name}" \
            "${xorrisofs_options[@]}" \
            -output "${out_dir}/${img_name}" \
            "${isofs_dir}/"
794
795
    _msg_info "Done!"
    du -h -- "${out_dir}/${img_name}"
796
797
798
}

# Read profile's values from profiledef.sh
799
_read_profile() {
800
801
802
803
804
805
806
807
    if [[ -z "${profile}" ]]; then
        _msg_error "No profile specified!" 1
    fi
    if [[ ! -d "${profile}" ]]; then
        _msg_error "Profile '${profile}' does not exist!" 1
    elif [[ ! -e "${profile}/profiledef.sh" ]]; then
        _msg_error "Profile '${profile}' is missing 'profiledef.sh'!" 1
    else
808
809
        cd -- "${profile}"

810
811
812
813
        # Source profile's variables
        # shellcheck source=configs/releng/profiledef.sh
        . "${profile}/profiledef.sh"

814
815
816
        # Resolve paths of files that are expected to reside in the profile's directory
        [[ -n "$packages" ]] || packages="${profile}/packages.${arch}"
        packages="$(realpath -- "${packages}")"
817
818
819
        pacman_conf="$(realpath -- "${pacman_conf}")"

        cd -- "${OLDPWD}"
820
821
    fi
}
822

823
824
825
826
827
828
829
830
831
832
# Validate set options
_validate_options() {
    local validation_error=0 bootmode
    local pkg_list_from_file=()
    _msg_info "Validating options..."
    # Check if the package list file exists and read packages from it
    if [[ -e "${packages}" ]]; then
        mapfile -t pkg_list_from_file < <(sed '/^[[:blank:]]*#.*/d;s/#.*//;/^[[:blank:]]*$/d' "${packages}")
        pkg_list+=("${pkg_list_from_file[@]}")
        if (( ${#pkg_list_from_file} < 1 )); then
833
            (( validation_error=validation_error+1 ))
834
            _msg_error "No package specified in '${packages}'." 0
835
        fi
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
    else
        (( validation_error=validation_error+1 ))
        _msg_error "File '${packages}' does not exist." 0

    fi

    # Check if pacman configuration file exists
    if [[ ! -e "${pacman_conf}" ]]; then
        (( validation_error=validation_error+1 ))
        _msg_error "File '${pacman_conf}' does not exist." 0
    fi
    # Check if the specified bootmodes are supported
    for bootmode in "${bootmodes[@]}"; do
        if typeset -f "_make_bootmode_${bootmode}" &> /dev/null; then
            if typeset -f "_validate_requirements_bootmode_${bootmode}" &> /dev/null; then
                "_validate_requirements_bootmode_${bootmode}"
852
            else
853
                _msg_warning "Function '_validate_requirements_bootmode_${bootmode}' does not exist. Validating the requirements of '${bootmode}' boot mode will not be possible."
854
855
856
            fi
        else
            (( validation_error=validation_error+1 ))
857
            _msg_error "${bootmode} is not a valid boot mode!" 0
858
        fi
859
860
861
862
863
864
865
    done
    # Check if the specified airootfs_image_type is supported
    if typeset -f "_mkairootfs_${airootfs_image_type}" &> /dev/null; then
        if typeset -f "_validate_requirements_airootfs_image_type_${airootfs_image_type}" &> /dev/null; then
            "_validate_requirements_airootfs_image_type_${airootfs_image_type}"
        else
            _msg_warning "Function '_validate_requirements_airootfs_image_type_${airootfs_image_type}' does not exist. Validating the requirements of '${airootfs_image_type}' airootfs image type will not be possible."
866
        fi
867
868
869
870
871
872
    else
        (( validation_error=validation_error+1 ))
        _msg_error "Unsupported image type: '${airootfs_image_type}'" 0
    fi
    if (( validation_error )); then
        _msg_error "${validation_error} errors were encountered while validating the profile. Aborting." 1
873
    fi
David Runge's avatar
David Runge committed
874
    _msg_info "Done!"
875
876
}

877
# Set defaults and, if present, overrides from mkarchiso command line option parameters
878
_set_overrides() {
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
    # Set variables that have command line overrides
    if [[ -v override_work_dir ]]; then
        work_dir="$override_work_dir"
    elif [[ -z "$work_dir" ]]; then
        work_dir='./work'
    fi
    work_dir="$(realpath -- "$work_dir")"
    if [[ -v override_out_dir ]]; then
        out_dir="$override_out_dir"
    elif [[ -z "$out_dir" ]]; then
        out_dir='./out'
    fi
    out_dir="$(realpath -- "$out_dir")"
    if [[ -v override_pacman_conf ]]; then
        pacman_conf="$override_pacman_conf"
    elif [[ -z "$pacman_conf" ]]; then
        pacman_conf="/etc/pacman.conf"
    fi
    pacman_conf="$(realpath -- "$pacman_conf")"
    [[ ! -v override_pkg_list ]] || pkg_list+=("${override_pkg_list[@]}")
    if [[ -v override_iso_label ]]; then
        iso_label="$override_iso_label"
    elif [[ -z "$iso_label" ]]; then
        iso_label="${app_name^^}"
    fi
    if [[ -v override_iso_publisher ]]; then
        iso_publisher="$override_iso_publisher"
    elif [[ -z "$iso_publisher" ]]; then
        iso_publisher="${app_name}"
    fi
    if [[ -v override_iso_application ]]; then
        iso_application="$override_iso_application"
    elif [[ -z "$iso_application" ]]; then
        iso_application="${app_name} iso"
    fi
    if [[ -v override_install_dir ]]; then
        install_dir="$override_install_dir"
    elif [[ -z "$install_dir" ]]; then
        install_dir="${app_name}"
    fi
    [[ ! -v override_gpg_key ]] || gpg_key="$override_gpg_key"
    if [[ -v override_quiet ]]; then
        quiet="$override_quiet"
    elif [[ -z "$quiet" ]]; then
        quiet="y"
    fi

    # Set variables that do not have overrides
    [[ -n "$arch" ]] || arch="$(uname -m)"
    [[ -n "$airootfs_image_type" ]] || airootfs_image_type="squashfs"
    [[ -n "$iso_name" ]] || iso_name="${app_name}"
    [[ -n "$img_name" ]] || img_name="${iso_name}-${iso_version}-${arch}.iso"
931
932
}

933
_export_gpg_publickey() {
934
    gpg --batch --output "${work_dir}/pubkey.gpg" --export "${gpg_key}"
935
936
}

937
_make_version() {
938
    local osrelease
939
940
    install -d -m 0755 -- "${isofs_dir}/${install_dir}"
    _msg_info "Creating files with iso version..."
941
942
    # Write version file to airootfs
    rm -f -- "${airootfs_dir}/version"
943
    printf '%s\n' "${iso_version}" > "${airootfs_dir}/version"
944
    # Write version file to ISO 9660
945
    printf '%s\n' "${iso_version}" > "${isofs_dir}/${install_dir}/version"
946
    # Write grubenv with version information to ISO 9660
947
948
949
    printf '%.1024s' "$(printf '# GRUB Environment Block\nNAME=%s\nVERSION=%s\n%s' \
        "${iso_name}" "${iso_version}" "$(printf '%0.1s' "#"{1..1024})")" \
        > "${isofs_dir}/${install_dir}/grubenv"
950
951
952
953
954
955
956
957
958
959
960
    # Append IMAGE_ID & IMAGE_VERSION to os-release
    osrelease="$(realpath -- "${airootfs_dir}/etc/os-release")"
    if [[ ! -e "${airootfs_dir}/etc/os-release" && -e "${airootfs_dir}/usr/lib/os-release" ]]; then
        osrelease="$(realpath -- "${airootfs_dir}/usr/lib/os-release")"
    fi
    if [[ "${osrelease}" != "${airootfs_dir}"* ]]; then
        _msg_warning "os-release file '${osrelease}' is outside of valid path."
    else
        [[ ! -e "${osrelease}" ]] || sed -i '/^IMAGE_ID=/d;/^IMAGE_VERSION=/d' "${osrelease}"
        printf 'IMAGE_ID=%s\nIMAGE_VERSION=%s\n' "${iso_name}" "${iso_version}" >> "${osrelease}"
    fi
961
962
    _msg_info "Done!"
}
963
964

_make_pkglist() {
965
    install -d -m 0755 -- "${isofs_dir}/${install_dir}"
966
    _msg_info "Creating a list of installed packages on live-enviroment..."
967
    pacman -Q --sysroot "${airootfs_dir}" > "${isofs_dir}/${install_dir}/pkglist.${arch}.txt"
968
    _msg_info "Done!"
969
}
970

971
_build_profile() {
972
973
    # Set up essential directory paths
    airootfs_dir="${work_dir}/${arch}/airootfs"
974
    isofs_dir="${work_dir}/iso"
975
976
    # Create working directory
    [[ -d "${work_dir}" ]] || install -d -- "${work_dir}"
977
978
979
980
981
982
    # Write build date to file or if the file exists, read it from there
    if [[ -e "${work_dir}/build_date" ]]; then
        SOURCE_DATE_EPOCH="$(<"${work_dir}/build_date")"
    else
        printf '%s\n' "$SOURCE_DATE_EPOCH" > "${work_dir}/build_date"
    fi
983

984
    [[ "${quiet}" == "y" ]] || _show_config
985
    _run_once _make_pacman_conf
986
    [[ -z "${gpg_key}" ]] || _run_once _export_gpg_publickey
987
988
    _run_once _make_custom_airootfs
    _run_once _make_packages
989
    _run_once _make_version
990
991
    _run_once _make_customize_airootfs
    _run_once _make_pkglist
992
    _make_bootmodes
993
994
995
    _run_once _cleanup_airootfs
    _run_once _prepare_airootfs_image
    _run_once _build_iso
996
997
}

998
while getopts 'p:C:L:P:A:D:w:o:g:vh?' arg; do
999
    case "${arg}" in
1000
        p) read -r -a override_pkg_list <<< "${OPTARG}" ;;