#!/bin/bash
# License: Unspecified

#!/hint/bash
# This may be included with or without `set -euE`

# License: Unspecified

[[ -z ${_INCLUDE_COMMON_SH:-} ]] || return 0
_INCLUDE_COMMON_SH="$(set +o|grep nounset)"

set +u +o posix
# shellcheck disable=1091
. /usr/share/makepkg/util.sh
$_INCLUDE_COMMON_SH

# Avoid any encoding problems
export LANG=C

shopt -s extglob

# check if messages are to be printed using color
if [[ -t 2 ]]; then
	colorize
else
	# shellcheck disable=2034
	declare -gr ALL_OFF='' BOLD='' BLUE='' GREEN='' RED='' YELLOW=''
fi

stat_busy() {
	local mesg=$1; shift
	# shellcheck disable=2059
	printf "${GREEN}==>${ALL_OFF}${BOLD} ${mesg}...${ALL_OFF}" "$@" >&2
}

stat_done() {
	# shellcheck disable=2059
	printf "${BOLD}done${ALL_OFF}\n" >&2
}

_setup_workdir=false
setup_workdir() {
	[[ -z ${WORKDIR:-} ]] && WORKDIR=$(mktemp -d --tmpdir "${0##*/}.XXXXXXXXXX")
	_setup_workdir=true
	trap 'trap_abort' INT QUIT TERM HUP
	trap 'trap_exit' EXIT
}

cleanup() {
	if [[ -n ${WORKDIR:-} ]] && $_setup_workdir; then
		rm -rf "$WORKDIR"
	fi
	exit "${1:-0}"
}

abort() {
	error 'Aborting...'
	cleanup 255
}

trap_abort() {
	trap - EXIT INT QUIT TERM HUP
	abort
}

trap_exit() {
	local r=$?
	trap - EXIT INT QUIT TERM HUP
	cleanup $r
}

die() {
	(( $# )) && error "$@"
	cleanup 255
}

##
#  usage : lock( $fd, $file, $message, [ $message_arguments... ] )
##
lock() {
	# Only reopen the FD if it wasn't handed to us
	if ! [[ "/dev/fd/$1" -ef "$2" ]]; then
		mkdir -p -- "$(dirname -- "$2")"
		eval "exec $1>"'"$2"'
	fi

	if ! flock -n "$1"; then
		stat_busy "${@:3}"
		flock "$1"
		stat_done
	fi
}

##
#  usage : slock( $fd, $file, $message, [ $message_arguments... ] )
##
slock() {
	# Only reopen the FD if it wasn't handed to us
	if ! [[ "/dev/fd/$1" -ef "$2" ]]; then
		mkdir -p -- "$(dirname -- "$2")"
		eval "exec $1>"'"$2"'
	fi

	if ! flock -sn "$1"; then
		stat_busy "${@:3}"
		flock -s "$1"
		stat_done
	fi
}

##
#  usage : lock_close( $fd )
##
lock_close() {
	local fd=$1
	# https://github.com/koalaman/shellcheck/issues/862
	# shellcheck disable=2034
	exec {fd}>&-
}

##
# usage: pkgver_equal( $pkgver1, $pkgver2 )
##
pkgver_equal() {
	if [[ $1 = *-* && $2 = *-* ]]; then
		# if both versions have a pkgrel, then they must be an exact match
		[[ $1 = "$2" ]]
	else
		# otherwise, trim any pkgrel and compare the bare version.
		[[ ${1%%-*} = "${2%%-*}" ]]
	fi
}

##
#  usage: find_cached_package( $pkgname, $pkgver, $arch )
#
#    $pkgver can be supplied with or without a pkgrel appended.
#    If not supplied, any pkgrel will be matched.
##
find_cached_package() {
	local searchdirs=("$PWD" "$PKGDEST") results=()
	local targetname=$1 targetver=$2 targetarch=$3
	local dir pkg pkgbasename name ver rel arch r results

	for dir in "${searchdirs[@]}"; do
		[[ -d $dir ]] || continue

		for pkg in "$dir"/*.pkg.tar?(.?z); do
			[[ -f $pkg ]] || continue

			# avoid adding duplicates of the same inode
			for r in "${results[@]}"; do
				[[ $r -ef $pkg ]] && continue 2
			done

			# split apart package filename into parts
			pkgbasename=${pkg##*/}
			pkgbasename=${pkgbasename%.pkg.tar?(.?z)}

			arch=${pkgbasename##*-}
			pkgbasename=${pkgbasename%-"$arch"}

			rel=${pkgbasename##*-}
			pkgbasename=${pkgbasename%-"$rel"}

			ver=${pkgbasename##*-}
			name=${pkgbasename%-"$ver"}

			if [[ $targetname = "$name" && $targetarch = "$arch" ]] &&
					pkgver_equal "$targetver" "$ver-$rel"; then
				results+=("$pkg")
			fi
		done
	done

	case ${#results[*]} in
		0)
			return 1
			;;
		1)
			printf '%s\n' "${results[0]}"
			return 0
			;;
		*)
			error 'Multiple packages found:'
			printf '\t%s\n' "${results[@]}" >&2
			return 1
	esac
}

#!/hint/bash
# License: Unspecified
:

# shellcheck disable=2034
CHROOT_VERSION='v4'

##
#  usage : check_root $keepenv
##
orig_argv=("${BASH_SOURCE[0]}" "$@")
check_root() {
	local keepenv=$1

	(( EUID == 0 )) && return
	if type -P sudo >/dev/null; then
		exec sudo --preserve-env=$keepenv -- "${orig_argv[@]}"
	else
		exec su root -c "$(printf ' %q' "${orig_argv[@]}")"
	fi
}

##
#  usage : is_btrfs( $path )
# return : whether $path is on a btrfs
##
is_btrfs() {
	[[ -e "$1" && "$(stat -f -c %T "$1")" == btrfs ]]
}

##
#  usage : is_subvolume( $path )
# return : whether $path is a the root of a btrfs subvolume (including
#          the top-level subvolume).
##
is_subvolume() {
	[[ -e "$1" && "$(stat -f -c %T "$1")" == btrfs && "$(stat -c %i "$1")" == 256 ]]
}

##
#  usage : subvolume_delete_recursive( $path )
#
#    Find all btrfs subvolumes under and including $path and delete them.
##
subvolume_delete_recursive() {
	local subvol

	is_subvolume "$1" || return 0

	while IFS= read -d $'\0' -r subvol; do
		if ! subvolume_delete_recursive "$subvol"; then
			return 1
		fi
	done < <(find "$1" -mindepth 1 -xdev -depth -inum 256 -print0)
	if ! btrfs subvolume delete "$1" &>/dev/null; then
		error "Unable to delete subvolume %s" "$subvol"
		return 1
	fi

	return 0
}


base_packages=(base-devel)
makechrootpkg_args=(-c -n -C)

cmd="${0##*/}"
if [[ "${cmd%%-*}" == 'multilib' ]]; then
	repo="${cmd%-build}"
	arch='x86_64'
	base_packages+=(multilib-devel)
else
	tag="${cmd%-build}"
	repo=${tag%-*}
	arch=${tag##*-}
fi
chroots='/var/lib/archbuild'
clean_first=false

pacman_config="/usr/share/devtools/pacman-${repo}.conf"
if [[ -f /usr/share/devtools/pacman-${repo}-${arch}.conf ]]; then
    pacman_config="/usr/share/devtools/pacman-${repo}-${arch}.conf"
fi
makepkg_config="/usr/share/devtools/makepkg-${arch}.conf"
if [[ -f /usr/share/devtools/makepkg-${repo}-${arch}.conf ]]; then
    makepkg_config="/usr/share/devtools/makepkg-${repo}-${arch}.conf"
fi

usage() {
	echo "Usage: $cmd [options] -- [makechrootpkg args]"
	echo '    -h         This help'
	echo '    -c         Recreate the chroot before building'
	echo '    -r <dir>   Create chroots in this directory'
	echo ''
	echo "Default makechrootpkg args: ${makechrootpkg_args[*]}"
	echo ''
	exit 1
}

while getopts 'hcr:' arg; do
	case "${arg}" in
		c) clean_first=true ;;
		r) chroots="$OPTARG" ;;
		*) usage ;;
	esac
done

check_root SOURCE_DATE_EPOCH,SRCDEST,SRCPKGDEST,PKGDEST,LOGDEST,MAKEFLAGS,PACKAGER,GNUPGHOME

# Pass all arguments after -- right to makepkg
makechrootpkg_args+=("${@:$OPTIND}")

if ${clean_first} || [[ ! -d "${chroots}/${repo}-${arch}" ]]; then
	msg "Creating chroot for [%s] (%s)..." "${repo}" "${arch}"

	for copy in "${chroots}/${repo}-${arch}"/*; do
		[[ -d $copy ]] || continue
		msg2 "Deleting chroot copy '%s'..." "$(basename "${copy}")"

		lock 9 "$copy.lock" "Locking chroot copy '%s'" "$copy"

		subvolume_delete_recursive "${copy}"
		rm -rf --one-file-system "${copy}"
	done
	lock_close 9

	rm -rf --one-file-system "${chroots}/${repo}-${arch}"
	mkdir -m755 -p "${chroots}/${repo}-${arch}"
	setarch "${arch}" mkarchroot \
		-C "${pacman_config}" \
		-M "${makepkg_config}" \
		"${chroots}/${repo}-${arch}/root" \
		"${base_packages[@]}" || abort
else
	lock 9 "${chroots}/${repo}-${arch}/root.lock" "Locking clean chroot"
	arch-nspawn \
		-C "${pacman_config}" \
		-M "${makepkg_config}" \
		"${chroots}/${repo}-${arch}/root" \
		pacman -Syuu --noconfirm || abort
fi

# Always build official packages reproducibly
if [[ ! -v SOURCE_DATE_EPOCH ]]; then
	export SOURCE_DATE_EPOCH=$(date +%s)
fi

msg "Building in chroot for [%s] (%s)..." "${repo}" "${arch}"
exec makechrootpkg -r "${chroots}/${repo}-${arch}" "${makechrootpkg_args[@]}"
