pfSense

#!/bin/sh

#

# builder_common.sh

#

# part of pfSense (https://www.pfsense.org)

# Copyright (c) 2004-2020 Rubicon Communications, LLC (Netgate)

# All rights reserved.

#

# FreeSBIE portions of the code

# Copyright (c) 2005 Dario Freni

# and copied from FreeSBIE project

# All rights reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

if [ -z "${IMAGES_FINAL_DIR}" -o "${IMAGES_FINAL_DIR}" = "/" ]; then

	echo "IMAGES_FINAL_DIR is not defined"

	print_error_pfS

fi

kldload filemon >/dev/null 2>&1

lc() {

	echo "${1}" | tr '[[:upper:]]' '[[:lower:]]'

}

git_last_commit() {

	export CURRENT_COMMIT=$(git -C ${BUILDER_ROOT} log -1 --format='%H')

	export CURRENT_AUTHOR=$(git -C ${BUILDER_ROOT} log -1 --format='%an')

	echo ">>> Last known commit $CURRENT_AUTHOR - $CURRENT_COMMIT"

	echo "$CURRENT_COMMIT" > $SCRATCHDIR/build_commit_info.txt

}

# Create core pkg repository

core_pkg_create_repo() {

	if [ ! -d "${CORE_PKG_REAL_PATH}/All" ]; then

		return

	fi

	############ ATTENTION ##############

	#

	# For some reason pkg-repo fail without / in the end of directory name

	# so removing it will break command

	#

	# https://github.com/freebsd/pkg/issues/1364

	#

	echo -n ">>> Creating core packages repository... "

	if pkg repo -q "${CORE_PKG_REAL_PATH}/"; then

		echo "Done!"

	else

		echo "Failed!"

		print_error_pfS

	fi

	# Use the same directory structure as poudriere does to avoid

	# breaking snapshot repositories during rsync

	ln -sf $(basename ${CORE_PKG_REAL_PATH}) ${CORE_PKG_PATH}/.latest

	ln -sf .latest/All ${CORE_PKG_ALL_PATH}

	ln -sf .latest/digests.txz ${CORE_PKG_PATH}/digests.txz

	ln -sf .latest/meta.conf ${CORE_PKG_PATH}/meta.conf

	ln -sf .latest/meta.txz ${CORE_PKG_PATH}/meta.txz

	ln -sf .latest/packagesite.txz ${CORE_PKG_PATH}/packagesite.txz

}

# Create core pkg (base, kernel)

core_pkg_create() {

	local _template="${1}"

	local _flavor="${2}"

	local _version="${3}"

	local _root="${4}"

	local _findroot="${5}"

	local _filter="${6}"

	local _template_path=${BUILDER_TOOLS}/templates/core_pkg/${_template}

	# Use default pkg repo to obtain ABI and ALTABI

	local _abi=$(sed -e "s/%%ARCH%%/${TARGET_ARCH}/g" \

	    ${PKG_REPO_DEFAULT%%.conf}.abi)

	local _altabi_arch=$(get_altabi_arch ${TARGET_ARCH})

	local _altabi=$(sed -e "s/%%ARCH%%/${_altabi_arch}/g" \

	    ${PKG_REPO_DEFAULT%%.conf}.altabi)

	${BUILDER_SCRIPTS}/create_core_pkg.sh \

		-t "${_template_path}" \

		-f "${_flavor}" \

		-v "${_version}" \

		-r "${_root}" \

		-s "${_findroot}" \

		-F "${_filter}" \

		-d "${CORE_PKG_REAL_PATH}/All" \

		-a "${_abi}" \

		-A "${_altabi}" \

		|| print_error_pfS

}

# This routine will output that something went wrong

print_error_pfS() {

	echo

	echo "####################################"

	echo "Something went wrong, check errors!" >&2

	echo "####################################"

	echo

	echo "NOTE: a lot of times you can run './build.sh --clean-builder' to resolve."

	echo

	[ -n "${LOGFILE}" -a -f "${LOGFILE}" ] && \

		echo "Log saved on ${LOGFILE}" && \

	echo

	kill $$

	exit 1

}

# This routine will verify that the kernel has been

# installed OK to the staging area.

ensure_kernel_exists() {

	if [ ! -f "$1/boot/kernel/kernel.gz" ]; then

		echo ">>> ERROR: Could not locate $1/boot/kernel.gz"

		print_error_pfS

	fi

	KERNEL_SIZE=$(stat -f "%z" $1/boot/kernel/kernel.gz)

	if [ "$KERNEL_SIZE" -lt 3500 ]; then

		echo ">>> ERROR: Kernel $1/boot/kernel.gz appears to be smaller than it should be: $KERNEL_SIZE"

		print_error_pfS

	fi

}

get_pkg_name() {

	echo "${PRODUCT_NAME}-${1}-${CORE_PKG_VERSION}"

}

# This routine builds all related kernels

build_all_kernels() {

	# Set KERNEL_BUILD_PATH if it has not been set

	if [ -z "${KERNEL_BUILD_PATH}" ]; then

		KERNEL_BUILD_PATH=$SCRATCHDIR/kernels

		echo ">>> KERNEL_BUILD_PATH has not been set. Setting to ${KERNEL_BUILD_PATH}!"

	fi

	[ -d "${KERNEL_BUILD_PATH}" ] \

		&& rm -rf ${KERNEL_BUILD_PATH}

	# Build embedded kernel

	for BUILD_KERNEL in $BUILD_KERNELS; do

		unset KERNCONF

		unset KERNEL_DESTDIR

		unset KERNEL_NAME

		export KERNCONF=$BUILD_KERNEL

		export KERNEL_DESTDIR="$KERNEL_BUILD_PATH/$BUILD_KERNEL"

		export KERNEL_NAME=${BUILD_KERNEL}

		LOGFILE="${BUILDER_LOGS}/kernel.${KERNCONF}.${TARGET}.log"

		echo ">>> Building $BUILD_KERNEL kernel."  | tee -a ${LOGFILE}

		if [ -n "${NO_BUILDKERNEL}" -a -f "${CORE_PKG_ALL_PATH}/$(get_pkg_name kernel-${KERNEL_NAME}).txz" ]; then

			echo ">>> NO_BUILDKERNEL set, skipping build" | tee -a ${LOGFILE}

			continue

		fi

		buildkernel

		echo ">>> Staging $BUILD_KERNEL kernel..." | tee -a ${LOGFILE}

		installkernel

		ensure_kernel_exists $KERNEL_DESTDIR

		echo ">>> Creating pkg of $KERNEL_NAME-debug kernel to staging area..."  | tee -a ${LOGFILE}

		core_pkg_create kernel-debug ${KERNEL_NAME} ${CORE_PKG_VERSION} ${KERNEL_DESTDIR} \

		    "./usr/lib/debug/boot" \*.debug

		rm -rf ${KERNEL_DESTDIR}/usr

		echo ">>> Creating pkg of $KERNEL_NAME kernel to staging area..."  | tee -a ${LOGFILE}

		core_pkg_create kernel ${KERNEL_NAME} ${CORE_PKG_VERSION} ${KERNEL_DESTDIR} "./boot/kernel ./boot/modules"

		rm -rf $KERNEL_DESTDIR 2>&1 1>/dev/null

	done

}

install_default_kernel() {

	if [ -z "${1}" ]; then

		echo ">>> ERROR: install_default_kernel called without a kernel config name"| tee -a ${LOGFILE}

		print_error_pfS

	fi

	export KERNEL_NAME="${1}"

	echo -n ">>> Installing kernel to be used by image ${KERNEL_NAME}..." | tee -a ${LOGFILE}

	# Copy kernel package to chroot, otherwise pkg won't find it to install

	if ! pkg_chroot_add ${FINAL_CHROOT_DIR} kernel-${KERNEL_NAME}; then

		echo ">>> ERROR: Error installing kernel package $(get_pkg_name kernel-${KERNEL_NAME}).txz" | tee -a ${LOGFILE}

		print_error_pfS

	fi

	# Set kernel pkg as vital to avoid user end up removing it for any reason

	pkg_chroot ${FINAL_CHROOT_DIR} set -v 1 -y $(get_pkg_name kernel-${KERNEL_NAME})

	if [ ! -f $FINAL_CHROOT_DIR/boot/kernel/kernel.gz ]; then

		echo ">>> ERROR: No kernel installed on $FINAL_CHROOT_DIR and the resulting image will be unusable. STOPPING!" | tee -a ${LOGFILE}

		print_error_pfS

	fi

	mkdir -p $FINAL_CHROOT_DIR/pkgs

	if [ -z "${2}" -o -n "${INSTALL_EXTRA_KERNELS}" ]; then

		cp ${CORE_PKG_ALL_PATH}/$(get_pkg_name kernel-${KERNEL_NAME}).txz $FINAL_CHROOT_DIR/pkgs

		if [ -n "${INSTALL_EXTRA_KERNELS}" ]; then

			for _EXTRA_KERNEL in $INSTALL_EXTRA_KERNELS; do

				_EXTRA_KERNEL_PATH=${CORE_PKG_ALL_PATH}/$(get_pkg_name kernel-${_EXTRA_KERNEL}).txz

				if [ -f "${_EXTRA_KERNEL_PATH}" ]; then

					echo -n ". adding ${_EXTRA_KERNEL_PATH} on image /pkgs folder"

					cp ${_EXTRA_KERNEL_PATH} $FINAL_CHROOT_DIR/pkgs

				else

					echo ">>> ERROR: Requested kernel $(get_pkg_name kernel-${_EXTRA_KERNEL}).txz was not found to be put on image /pkgs folder!"

					print_error_pfS

				fi

			done

		fi

	fi

	echo "Done." | tee -a ${LOGFILE}

	unset KERNEL_NAME

}

# This builds FreeBSD (make buildworld)

# Imported from FreeSBIE

make_world() {

	LOGFILE=${BUILDER_LOGS}/buildworld.${TARGET}

	echo ">>> LOGFILE set to $LOGFILE." | tee -a ${LOGFILE}

	if [ -n "${NO_BUILDWORLD}" ]; then

		echo ">>> NO_BUILDWORLD set, skipping build" | tee -a ${LOGFILE}

		return

	fi

	echo ">>> $(LC_ALL=C date) - Starting build world for ${TARGET} architecture..." | tee -a ${LOGFILE}

	script -aq $LOGFILE ${BUILDER_SCRIPTS}/build_freebsd.sh -K -s ${FREEBSD_SRC_DIR} \

		|| print_error_pfS

	echo ">>> $(LC_ALL=C date) - Finished build world for ${TARGET} architecture..." | tee -a ${LOGFILE}

	LOGFILE=${BUILDER_LOGS}/installworld.${TARGET}

	echo ">>> LOGFILE set to $LOGFILE." | tee -a ${LOGFILE}

	[ -d "${INSTALLER_CHROOT_DIR}" ] \

		|| mkdir -p ${INSTALLER_CHROOT_DIR}

	echo ">>> Installing world with bsdinstall for ${TARGET} architecture..." | tee -a ${LOGFILE}

	script -aq $LOGFILE ${BUILDER_SCRIPTS}/install_freebsd.sh -i -K \

		-s ${FREEBSD_SRC_DIR} \

		-d ${INSTALLER_CHROOT_DIR} \

		|| print_error_pfS

	# Copy additional installer scripts

	install -o root -g wheel -m 0755 ${BUILDER_TOOLS}/installer/*.sh \

		${INSTALLER_CHROOT_DIR}/root

	# XXX set root password since we don't have nullok enabled

	pw -R ${INSTALLER_CHROOT_DIR} usermod root -w yes

	echo ">>> Installing world without bsdinstall for ${TARGET} architecture..." | tee -a ${LOGFILE}

	script -aq $LOGFILE ${BUILDER_SCRIPTS}/install_freebsd.sh -K \

		-s ${FREEBSD_SRC_DIR} \

		-d ${STAGE_CHROOT_DIR} \

		|| print_error_pfS

	# Use the builder cross compiler from obj to produce the final binary.

	if [ "${TARGET_ARCH}" == "$(uname -p)" ]; then

		BUILD_CC="${MAKEOBJDIRPREFIX}/${FREEBSD_SRC_DIR}/tmp/usr/bin/cc"

	else

		BUILD_CC="${MAKEOBJDIRPREFIX}/${TARGET}.${TARGET_ARCH}${FREEBSD_SRC_DIR}/tmp/usr/bin/cc"

	fi

	[ -f "${BUILD_CC}" ] || print_error_pfS

	# XXX It must go to the scripts

	[ -d "${STAGE_CHROOT_DIR}/usr/local/bin" ] \

		|| mkdir -p ${STAGE_CHROOT_DIR}/usr/local/bin

	makeargs="CC=${BUILD_CC} DESTDIR=${STAGE_CHROOT_DIR}"

	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}

	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/crypto ${makeargs} clean all install || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}

	# XXX FIX IT

#	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} clean all install || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}

	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}

	if [ "${PRODUCT_NAME}" = "pfSense" -a -n "${GNID_REPO_BASE}" ]; then

		echo ">>> Building gnid... " | tee -a ${LOGFILE}

		(\

			cd ${GNID_SRC_DIR} && \

			make \

				CC=${BUILD_CC} \

				INCLUDE_DIR=${GNID_INCLUDE_DIR} \

				LIBCRYPTO_DIR=${GNID_LIBCRYPTO_DIR} \

			clean gnid \

		) || print_error_pfS

		install -o root -g wheel -m 0700 ${GNID_SRC_DIR}/gnid \

			${STAGE_CHROOT_DIR}/usr/sbin \

			|| print_error_pfS

		install -o root -g wheel -m 0700 ${GNID_SRC_DIR}/gnid \

			${INSTALLER_CHROOT_DIR}/usr/sbin \

			|| print_error_pfS

	fi

	unset makeargs

}

# This routine creates a ova image that contains

# a ovf and vmdk file. These files can be imported

# right into vmware or virtual box.

# (and many other emulation platforms)

# http://www.vmware.com/pdf/ovf_whitepaper_specification.pdf

create_ova_image() {

	# XXX create a .ovf php creator that you can pass:

	#     1. populatedSize

	#     2. license

	#     3. product name

	#     4. version

	#     5. number of network interface cards

	#     6. allocationUnits

	#     7. capacity

	#     8. capacityAllocationUnits

	LOGFILE=${BUILDER_LOGS}/ova.${TARGET}.log

	local _mntdir=${OVA_TMP}/mnt

	if [ -d "${_mntdir}" ]; then

		local _dev

		# XXX Root cause still didn't found but it doesn't umount

		#     properly on looped builds and then require this extra

		#     check

		while true; do

			_dev=$(mount -p ${_mntdir} 2>/dev/null | awk '{print $1}')

			[ $? -ne 0 -o -z "${_dev}" ] \

				&& break

			umount -f ${_mntdir}

			mdconfig -d -u ${_dev#/dev/}

		done

		chflags -R noschg ${OVA_TMP}

		rm -rf ${OVA_TMP}

	fi

	mkdir -p $(dirname ${OVAPATH})

	mkdir -p ${_mntdir}

	if [ -z "${OVA_SWAP_PART_SIZE_IN_GB}" -o "${OVA_SWAP_PART_SIZE_IN_GB}" = "0" ]; then

		# first partition size (freebsd-ufs)

		local OVA_FIRST_PART_SIZE_IN_GB=${VMDK_DISK_CAPACITY_IN_GB}

		# Calculate real first partition size, removing 256 blocks (131072 bytes) beginning/loader

		local OVA_FIRST_PART_SIZE=$((${OVA_FIRST_PART_SIZE_IN_GB}*1024*1024*1024-131072))

		# Unset swap partition size variable

		unset OVA_SWAP_PART_SIZE

		# Parameter used by mkimg

		unset OVA_SWAP_PART_PARAM

	else

		# first partition size (freebsd-ufs)

		local OVA_FIRST_PART_SIZE_IN_GB=$((VMDK_DISK_CAPACITY_IN_GB-OVA_SWAP_PART_SIZE_IN_GB))

		# Use first partition size in g

		local OVA_FIRST_PART_SIZE="${OVA_FIRST_PART_SIZE_IN_GB}g"

		# Calculate real swap size, removing 256 blocks (131072 bytes) beginning/loader

		local OVA_SWAP_PART_SIZE=$((${OVA_SWAP_PART_SIZE_IN_GB}*1024*1024*1024-131072))

		# Parameter used by mkimg

		local OVA_SWAP_PART_PARAM="-p freebsd-swap/swap0::${OVA_SWAP_PART_SIZE}"

	fi

	# Prepare folder to be put in image

	customize_stagearea_for_image "ova"

	install_default_kernel ${DEFAULT_KERNEL} "no"

	# Fill fstab

	echo ">>> Installing platform specific items..." | tee -a ${LOGFILE}

	echo "/dev/gpt/${PRODUCT_NAME}	/	ufs		rw	1	1" > ${FINAL_CHROOT_DIR}/etc/fstab

	if [ -n "${OVA_SWAP_PART_SIZE}" ]; then

		echo "/dev/gpt/swap0	none	swap	sw	0	0" >> ${FINAL_CHROOT_DIR}/etc/fstab

	fi

	# Create / partition

	echo -n ">>> Creating / partition... " | tee -a ${LOGFILE}

	truncate -s ${OVA_FIRST_PART_SIZE} ${OVA_TMP}/${OVFUFS}

	local _md=$(mdconfig -a -f ${OVA_TMP}/${OVFUFS})

	trap "mdconfig -d -u ${_md}; return" 1 2 15 EXIT

	newfs -L ${PRODUCT_NAME} -j /dev/${_md} 2>&1 >>${LOGFILE}

	if ! mount /dev/${_md} ${_mntdir} 2>&1 >>${LOGFILE}; then

		echo "Failed!" | tee -a ${LOGFILE}

		echo ">>> ERROR: Error mounting temporary vmdk image. STOPPING!" | tee -a ${LOGFILE}

		print_error_pfS

	fi

	trap "sync; sleep 3; umount ${_mntdir} || umount -f ${_mntdir}; mdconfig -d -u ${_md}; return" 1 2 15 EXIT

	echo "Done!" | tee -a ${LOGFILE}

	clone_directory_contents ${FINAL_CHROOT_DIR} ${_mntdir}

	sync

	sleep 3

	umount ${_mntdir} || umount -f ${_mntdir} >>${LOGFILE} 2>&1

	mdconfig -d -u ${_md}

	trap "-" 1 2 15 EXIT

	# Create raw disk

	echo -n ">>> Creating raw disk... " | tee -a ${LOGFILE}

	mkimg \

		-s gpt \

		-f raw \

		-b ${FINAL_CHROOT_DIR}/boot/pmbr \

		-p freebsd-boot:=${FINAL_CHROOT_DIR}/boot/gptboot \

		-p freebsd-ufs/${PRODUCT_NAME}:=${OVA_TMP}/${OVFUFS} \

		${OVA_SWAP_PART_PARAM} \

		-o ${OVA_TMP}/${OVFRAW} 2>&1 >> ${LOGFILE}

	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFRAW} ]; then

		if [ -f ${OVA_TMP}/${OVFUFS} ]; then

			rm -f ${OVA_TMP}/${OVFUFS}

		fi

		if [ -f ${OVA_TMP}/${OVFRAW} ]; then

			rm -f ${OVA_TMP}/${OVFRAW}

		fi

		echo "Failed!" | tee -a ${LOGFILE}

		echo ">>> ERROR: Error creating temporary vmdk image. STOPPING!" | tee -a ${LOGFILE}

		print_error_pfS

	fi

	echo "Done!" | tee -a ${LOGFILE}

	# We don't need it anymore

	rm -f ${OVA_TMP}/${OVFUFS} >/dev/null 2>&1

	# Convert raw to vmdk

	echo -n ">>> Creating vmdk disk... " | tee -a ${LOGFILE}

	vmdktool -z9 -v ${OVA_TMP}/${OVFVMDK} ${OVA_TMP}/${OVFRAW}

	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFVMDK} ]; then

		if [ -f ${OVA_TMP}/${OVFRAW} ]; then

			rm -f ${OVA_TMP}/${OVFRAW}

		fi

		if [ -f ${OVA_TMP}/${OVFVMDK} ]; then

			rm -f ${OVA_TMP}/${OVFVMDK}

		fi

		echo "Failed!" | tee -a ${LOGFILE}

		echo ">>> ERROR: Error creating vmdk image. STOPPING!" | tee -a ${LOGFILE}

		print_error_pfS

	fi

	echo "Done!" | tee -a ${LOGFILE}

	rm -f ${OVA_TMP}/${OVFRAW}

	ova_setup_ovf_template

	echo -n ">>> Writing final ova image... " | tee -a ${LOGFILE}

	# Create OVA file for vmware

	gtar -C ${OVA_TMP} -cpf ${OVAPATH} ${PRODUCT_NAME}.ovf ${OVFVMDK}

	echo "Done!" | tee -a ${LOGFILE}

	rm -f ${OVA_TMP}/${OVFVMDK} >/dev/null 2>&1

	echo ">>> OVA created: $(LC_ALL=C date)" | tee -a ${LOGFILE}

}

# called from create_ova_image

ova_setup_ovf_template() {

	if [ ! -f ${OVFTEMPLATE} ]; then

		echo ">>> ERROR: OVF template file (${OVFTEMPLATE}) not found."

		print_error_pfS

	fi

	#  OperatingSystemSection (${PRODUCT_NAME}.ovf)

	#  42   FreeBSD 32-Bit

	#  78   FreeBSD 64-Bit

	if [ "${TARGET}" = "amd64" ]; then

		local _os_id="78"

		local _os_type="freebsd64Guest"

		local _os_descr="FreeBSD 64-Bit"

	else

		echo ">>> ERROR: Platform not supported for OVA (${TARGET})"

		print_error_pfS

	fi

	local POPULATED_SIZE=$(du -d0 -k $FINAL_CHROOT_DIR | cut -f1)

	local POPULATED_SIZE_IN_BYTES=$((${POPULATED_SIZE}*1024))

	local VMDK_FILE_SIZE=$(stat -f "%z" ${OVA_TMP}/${OVFVMDK})

	sed \

		-e "s,%%VMDK_FILE_SIZE%%,${VMDK_FILE_SIZE},g" \

		-e "s,%%VMDK_DISK_CAPACITY_IN_GB%%,${VMDK_DISK_CAPACITY_IN_GB},g" \

		-e "s,%%POPULATED_SIZE_IN_BYTES%%,${POPULATED_SIZE_IN_BYTES},g" \

		-e "s,%%OS_ID%%,${_os_id},g" \

		-e "s,%%OS_TYPE%%,${_os_type},g" \

		-e "s,%%OS_DESCR%%,${_os_descr},g" \

		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \

		-e "s,%%PRODUCT_NAME_SUFFIX%%,${PRODUCT_NAME_SUFFIX},g" \

		-e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION},g" \

		-e "s,%%PRODUCT_URL%%,${PRODUCT_URL},g" \

		-e "s#%%VENDOR_NAME%%#${VENDOR_NAME}#g" \

		-e "s#%%OVF_INFO%%#${OVF_INFO}#g" \

		-e "/^%%PRODUCT_LICENSE%%/r ${BUILDER_ROOT}/LICENSE" \

		-e "/^%%PRODUCT_LICENSE%%/d" \

		${OVFTEMPLATE} > ${OVA_TMP}/${PRODUCT_NAME}.ovf

}

# Cleans up previous builds

clean_builder() {

	# Clean out directories

	echo ">>> Cleaning up previous build environment...Please wait!"

	staginareas_clean_each_run

	if [ -d "${STAGE_CHROOT_DIR}" ]; then

		echo -n ">>> Cleaning ${STAGE_CHROOT_DIR}... "

		chflags -R noschg ${STAGE_CHROOT_DIR} 2>&1 >/dev/null

		rm -rf ${STAGE_CHROOT_DIR}/* 2>/dev/null

		echo "Done."

	fi

	if [ -d "${INSTALLER_CHROOT_DIR}" ]; then

		echo -n ">>> Cleaning ${INSTALLER_CHROOT_DIR}... "

		chflags -R noschg ${INSTALLER_CHROOT_DIR} 2>&1 >/dev/null

		rm -rf ${INSTALLER_CHROOT_DIR}/* 2>/dev/null

		echo "Done."

	fi

	if [ -z "${NO_CLEAN_FREEBSD_OBJ}" -a -d "${FREEBSD_SRC_DIR}" ]; then

		OBJTREE=$(make -C ${FREEBSD_SRC_DIR} -V OBJTREE)

		if [ -d "${OBJTREE}" ]; then

			echo -n ">>> Cleaning FreeBSD objects dir staging..."

			echo -n "."

			chflags -R noschg ${OBJTREE} 2>&1 >/dev/null

			echo -n "."

			rm -rf ${OBJTREE}/*

			echo "Done!"

		fi

		if [ -d "${KERNEL_BUILD_PATH}" ]; then

			echo -n ">>> Cleaning previously built kernel stage area..."

			rm -rf $KERNEL_BUILD_PATH/*

			echo "Done!"

		fi

	fi

	mkdir -p $KERNEL_BUILD_PATH

	echo -n ">>> Cleaning previously built images..."

	rm -rf $IMAGES_FINAL_DIR/*

	echo "Done!"

	echo -n ">>> Cleaning previous builder logs..."

	if [ -d "$BUILDER_LOGS" ]; then

		rm -rf ${BUILDER_LOGS}

	fi

	mkdir -p ${BUILDER_LOGS}

	echo "Done!"

	echo ">>> Cleaning of builder environment has finished."

}

clone_directory_contents() {

	if [ ! -e "$2" ]; then

		mkdir -p "$2"

	fi

	if [ ! -d "$1" -o ! -d "$2" ]; then

		if [ -z "${LOGFILE}" ]; then

			echo ">>> ERROR: Argument $1 supplied is not a directory!"

		else

			echo ">>> ERROR: Argument $1 supplied is not a directory!" | tee -a ${LOGFILE}

		fi

		print_error_pfS

	fi

	echo -n ">>> Using TAR to clone $1 to $2 ..."

	tar -C ${1} -c -f - . | tar -C ${2} -x -p -f -

	echo "Done!"

}

clone_to_staging_area() {

	# Clone everything to the final staging area

	echo -n ">>> Cloning everything to ${STAGE_CHROOT_DIR} staging area..."

	LOGFILE=${BUILDER_LOGS}/cloning.${TARGET}.log

	tar -C ${PRODUCT_SRC} -c -f - . | \

		tar -C ${STAGE_CHROOT_DIR} -x -p -f -

	if [ "${PRODUCT_NAME}" != "pfSense" ]; then

		mv ${STAGE_CHROOT_DIR}/usr/local/sbin/pfSense-upgrade \

			${STAGE_CHROOT_DIR}/usr/local/sbin/${PRODUCT_NAME}-upgrade

	fi

	mkdir -p ${STAGE_CHROOT_DIR}/etc/mtree

	mtree -Pcp ${STAGE_CHROOT_DIR}/var > ${STAGE_CHROOT_DIR}/etc/mtree/var.dist

	mtree -Pcp ${STAGE_CHROOT_DIR}/etc > ${STAGE_CHROOT_DIR}/etc/mtree/etc.dist

	if [ -d ${STAGE_CHROOT_DIR}/usr/local/etc ]; then

		mtree -Pcp ${STAGE_CHROOT_DIR}/usr/local/etc > ${STAGE_CHROOT_DIR}/etc/mtree/localetc.dist

	fi

	## Add buildtime and lastcommit information

	# This is used for detecting updates.

	echo "$BUILTDATESTRING" > $STAGE_CHROOT_DIR/etc/version.buildtime

	# Record last commit info if it is available.

	if [ -f $SCRATCHDIR/build_commit_info.txt ]; then

		cp $SCRATCHDIR/build_commit_info.txt $STAGE_CHROOT_DIR/etc/version.lastcommit

	fi

	local _exclude_files="${SCRATCHDIR}/base_exclude_files"

	sed \

		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \

		-e "s,%%VERSION%%,${_version},g" \

		${BUILDER_TOOLS}/templates/core_pkg/base/exclude_files \

		> ${_exclude_files}

	mkdir -p ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR} >/dev/null 2>&1

	# Include a sample pkg stable conf to base

	setup_pkg_repo \

		${PKG_REPO_DEFAULT} \

		${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/${PRODUCT_NAME}-repo.conf \

		${TARGET} \

		${TARGET_ARCH}

	mtree \

		-c \

		-k uid,gid,mode,size,flags,sha256digest \

		-p ${STAGE_CHROOT_DIR} \

		-X ${_exclude_files} \

		> ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/base.mtree

	tar \

		-C ${STAGE_CHROOT_DIR} \

		-cJf ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/base.txz \

		-X ${_exclude_files} \

		.

	core_pkg_create rc "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}

	core_pkg_create base "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}

	core_pkg_create default-config "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}

	local DEFAULTCONF=${STAGE_CHROOT_DIR}/conf.default/config.xml

	# Save current WAN and LAN if value

	local _old_wan_if=$(xml sel -t -v "${XML_ROOTOBJ}/interfaces/wan/if" ${DEFAULTCONF})

	local _old_lan_if=$(xml sel -t -v "${XML_ROOTOBJ}/interfaces/lan/if" ${DEFAULTCONF})

	# Change default interface names to match vmware driver

	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/wan/if" -v "vmx0" ${DEFAULTCONF}

	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/lan/if" -v "vmx1" ${DEFAULTCONF}

	core_pkg_create default-config "vmware" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}

	# Restore default values to be used by serial package

	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/wan/if" -v "${_old_wan_if}" ${DEFAULTCONF}

	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/lan/if" -v "${_old_lan_if}" ${DEFAULTCONF}

	# Activate serial console in config.xml

	xml ed -L -P -d "${XML_ROOTOBJ}/system/enableserial" ${DEFAULTCONF}

	xml ed -P -s "${XML_ROOTOBJ}/system" -t elem -n "enableserial" \

		${DEFAULTCONF} > ${DEFAULTCONF}.tmp

	xml fo -t ${DEFAULTCONF}.tmp > ${DEFAULTCONF}

	rm -f ${DEFAULTCONF}.tmp

	echo force > ${STAGE_CHROOT_DIR}/cf/conf/enableserial_force

	core_pkg_create default-config-serial "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}

	rm -f ${STAGE_CHROOT_DIR}/cf/conf/enableserial_force

	rm -f ${STAGE_CHROOT_DIR}/cf/conf/config.xml

	# Make sure pkg is present

	pkg_bootstrap ${STAGE_CHROOT_DIR}

	# Make sure correct repo is available on tmp dir

	mkdir -p ${STAGE_CHROOT_DIR}/tmp/pkg/pkg-repos

	setup_pkg_repo \

		${PKG_REPO_BUILD} \

		${STAGE_CHROOT_DIR}/tmp/pkg/pkg-repos/repo.conf \

		${TARGET} \

		${TARGET_ARCH} \

		staging \

		${STAGE_CHROOT_DIR}/tmp/pkg/pkg.conf

	echo "Done!"

}

create_final_staging_area() {

	if [ -z "${FINAL_CHROOT_DIR}" ]; then

		echo ">>> ERROR: FINAL_CHROOT_DIR is not set, cannot continue!" | tee -a ${LOGFILE}

		print_error_pfS

	fi

	if [ -d "${FINAL_CHROOT_DIR}" ]; then

		echo -n ">>> Previous ${FINAL_CHROOT_DIR} detected cleaning up..." | tee -a ${LOGFILE}

		chflags -R noschg ${FINAL_CHROOT_DIR} 2>&1 1>/dev/null

		rm -rf ${FINAL_CHROOT_DIR}/* 2>&1 1>/dev/null

		echo "Done." | tee -a ${LOGFILE}

	fi

	echo ">>> Preparing Final image staging area: $(LC_ALL=C date)" 2>&1 | tee -a ${LOGFILE}

	echo ">>> Cloning ${STAGE_CHROOT_DIR} to ${FINAL_CHROOT_DIR}" 2>&1 | tee -a ${LOGFILE}

	clone_directory_contents ${STAGE_CHROOT_DIR} ${FINAL_CHROOT_DIR}

	if [ ! -f $FINAL_CHROOT_DIR/sbin/init ]; then

		echo ">>> ERROR: Something went wrong during cloning -- Please verify!" 2>&1 | tee -a ${LOGFILE}

		print_error_pfS

	fi

}

customize_stagearea_for_image() {

	local _image_type="$1"

	local _default_config="" # filled with $2 below

	local _image_variant="$3"

	if [ -n "$2" ]; then

		_default_config="$2"

	elif [ "${_image_type}" = "memstickserial" -o \

	     "${_image_type}" = "memstickadi" ]; then

		_default_config="default-config-serial"

	elif [ "${_image_type}" = "ova" ]; then

		_default_config="default-config-vmware"

	else

		_default_config="default-config"

	fi

	# Prepare final stage area

	create_final_staging_area

	pkg_chroot_add ${FINAL_CHROOT_DIR} rc

	pkg_chroot_add ${FINAL_CHROOT_DIR} base

	# Set base/rc pkgs as vital to avoid user end up removing it for any reason

	pkg_chroot ${FINAL_CHROOT_DIR} set -v 1 -y $(get_pkg_name rc)

	pkg_chroot ${FINAL_CHROOT_DIR} set -v 1 -y $(get_pkg_name base)

	if [ "${_image_type}" = "iso" -o \

	     "${_image_type}" = "memstick" -o \

	     "${_image_type}" = "memstickserial" -o \

	     "${_image_type}" = "memstickadi" ]; then

		mkdir -p ${FINAL_CHROOT_DIR}/pkgs

		cp ${CORE_PKG_ALL_PATH}/*default-config*.txz ${FINAL_CHROOT_DIR}/pkgs

	fi

	pkg_chroot_add ${FINAL_CHROOT_DIR} ${_default_config}

	# XXX: Workaround to avoid pkg to complain regarding release

	#      repo on first boot since packages are installed from

	#      staging server during build phase

	if [ -n "${USE_PKG_REPO_STAGING}" ]; then

		_read_cmd="select value from repodata where key='packagesite'"

		if [ -n "${_IS_RELEASE}" -o -n "${_IS_RC}" ]; then

			local _tgt_server="${PKG_REPO_SERVER_RELEASE}"

		else

			local _tgt_server="${PKG_REPO_SERVER_DEVEL}"

		fi

		for _db in ${FINAL_CHROOT_DIR}/var/db/pkg/repo-*sqlite; do

			_cur=$(/usr/local/bin/sqlite3 ${_db} "${_read_cmd}")

			_new=$(echo "${_cur}" | sed -e "s,^${PKG_REPO_SERVER_STAGING},${_tgt_server},")

			/usr/local/bin/sqlite3 ${_db} "update repodata set value='${_new}' where key='packagesite'"

		done

	fi

	if [ -n "$_image_variant" -a \

	    -d ${BUILDER_TOOLS}/templates/custom_logos/${_image_variant} ]; then

		mkdir -p ${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/custom_logos

		cp -f \

			${BUILDER_TOOLS}/templates/custom_logos/${_image_variant}/*.svg \

			${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/custom_logos

		cp -f \

			${BUILDER_TOOLS}/templates/custom_logos/${_image_variant}/*.css \

			${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/custom_logos

	fi

	# Remove temporary repo conf

	rm -rf ${FINAL_CHROOT_DIR}/tmp/pkg

}

create_distribution_tarball() {

	mkdir -p ${INSTALLER_CHROOT_DIR}/usr/freebsd-dist

	echo -n ">>> Creating distribution tarball... " | tee -a ${LOGFILE}

	tar -C ${FINAL_CHROOT_DIR} --exclude ./pkgs \

		-cJf ${INSTALLER_CHROOT_DIR}/usr/freebsd-dist/base.txz .

	echo "Done!" | tee -a ${LOGFILE}

	echo -n ">>> Creating manifest... " | tee -a ${LOGFILE}

	(cd ${INSTALLER_CHROOT_DIR}/usr/freebsd-dist && \

		sh ${FREEBSD_SRC_DIR}/release/scripts/make-manifest.sh base.txz) \

		> ${INSTALLER_CHROOT_DIR}/usr/freebsd-dist/MANIFEST

	echo "Done!" | tee -a ${LOGFILE}

}

create_iso_image() {

	local _variant="$1"

	LOGFILE=${BUILDER_LOGS}/isoimage.${TARGET}

	if [ -z "${ISOPATH}" ]; then

		echo ">>> ISOPATH is empty skipping generation of ISO image!" | tee -a ${LOGFILE}

		return

	fi

	echo ">>> Building bootable ISO image for ${TARGET}" | tee -a ${LOGFILE}

	mkdir -p $(dirname ${ISOPATH})

	local _image_path=${ISOPATH}

	if [ -n "${_variant}" ]; then

		_image_path=$(echo "$_image_path" | \

			sed "s/${PRODUCT_NAME_SUFFIX}-/&${_variant}-/")

		VARIANTIMAGES="${VARIANTIMAGES}${VARIANTIMAGES:+ }${_image_path}"

	fi

	customize_stagearea_for_image "iso" "" $_variant

	install_default_kernel ${DEFAULT_KERNEL}

	BOOTCONF=${INSTALLER_CHROOT_DIR}/boot.config

	LOADERCONF=${INSTALLER_CHROOT_DIR}/boot/loader.conf

	rm -f ${LOADERCONF} ${BOOTCONF} >/dev/null 2>&1

	echo 'autoboot_delay="3"' > ${LOADERCONF}

	echo 'kern.cam.boot_delay=10000' >> ${LOADERCONF}

	cat ${LOADERCONF} > ${FINAL_CHROOT_DIR}/boot/loader.conf

	create_distribution_tarball

	FSLABEL=$(echo ${PRODUCT_NAME} | tr '[:lower:]' '[:upper:]')

	sh ${FREEBSD_SRC_DIR}/release/${TARGET}/mkisoimages.sh -b \

		${FSLABEL} \

		${_image_path} \

		${INSTALLER_CHROOT_DIR}

	if [ ! -f "${_image_path}" ]; then

		echo "ERROR! ISO image was not built"

		print_error_pfS

	fi