pfSense

#!/bin/sh

#

# builder_common.sh

#

# Copyright (c) 2004-2015 Electric Sheep Fencing, LLC

# Copyright (C) 2014 Ermal Luçi

# All rights reserved.

#

# NanoBSD portions of the code

# Copyright (c) 2005 Poul-Henning Kamp.

# and copied from nanobsd.sh

# All rights reserved.

#

# FreeSBIE portions of the code

# Copyright (c) 2005 Dario Freni

# and copied from FreeSBIE project

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

# 1. Redistributions of source code must retain the above copyright

#    notice, this list of conditions and the following disclaimer.

#

# 2. Redistributions in binary form must reproduce the above copyright

#    notice, this list of conditions and the following disclaimer in the

#    documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE pfSense PROJECT ``AS IS'' AND ANY

# EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE pfSense PROJECT OR

# ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

# OF THE POSSIBILITY OF SUCH DAMAGE.

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

#

if [ -n "${IMAGES_FINAL_DIR}" -a "${IMAGES_FINAL_DIR}" != "/" ]; then

	mkdir -p ${IMAGES_FINAL_DIR}

else

	echo "IMAGES_FINAL_DIR is not defined"

	print_error_pfS

fi

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_PATH}/All

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

	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 _filter="${5}"

	[ -d "${CORE_PKG_TMP}" ] \

		&& rm -rf ${CORE_PKG_TMP}

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

	local _template_metadir=${_templates_path}/metadir

	local _metadir=${CORE_PKG_TMP}/${_template}_metadir

	if [ ! -d ${_template_metadir} ]; then

		echo "ERROR: Template dir not found for pkg ${_template}"

		exit

	fi

	mkdir -p ${CORE_PKG_TMP}

	cp -r ${_template_metadir} ${_metadir}

	local _manifest=${_metadir}/+MANIFEST

	local _plist=${CORE_PKG_TMP}/${_template}_plist

	local _exclude_plist=${CORE_PKG_TMP}/${_template}_exclude_plist

	if [ -f "${_templates_path}/pkg-plist" ]; then

		cp ${_templates_path}/pkg-plist ${_plist}

	else

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

			_filter="-name ${_filter}"

		fi

		(cd ${_root} && find . ${_filter} -type f -or -type l | sed 's,^.,,' | sort -u) > ${_plist}

	fi

	if [ -f "${_templates_path}/exclude_plist" ]; then

		cp ${_templates_path}/exclude_plist ${_exclude_plist}

	else

		touch ${_exclude_plist}

	fi

	sed \

		-i '' \

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

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

		-e "s,%%FLAVOR%%,${_flavor:+-}${_flavor},g" \

		-e "s,%%FLAVOR_DESC%%,${_flavor:+ (${_flavor})},g" \

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

		${_metadir}/* \

		${_plist} \

		${exclude_plist}

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

		sort -u ${_exclude_plist} > ${_plist}.exclude

		mv ${_plist} ${_plist}.tmp

		comm -23 ${_plist}.tmp ${_plist}.exclude > ${_plist}

		rm -f ${_plist}.tmp ${plist}.exclude

	fi

	# Add license information

	local _portname=$(sed '/^name: /!d; s,^[^"]*",,; s,",,' ${_metadir}/+MANIFEST)

	local _licenses_dir="/usr/local/share/licenses/${_portname}-${_version}"

	mkdir -p ${_root}${_licenses_dir}

	cp ${BUILDER_ROOT}/license.txt ${_root}${_licenses_dir}/ESF

	echo "This package has a single license: ESF (Electric Sheep Fencing License)." \

		> ${_root}${_licenses_dir}/LICENSE

	cat <<EOF >${_root}${_licenses_dir}/catalog.mk

_LICENSE=ESF

_LICENSE_NAME=Electric Sheep Fencing License

_LICENSE_PERMS=dist-mirror dist-sell pkg-mirror pkg-sell auto-accept

_LICENSE_GROUPS=

_LICENSE_DISTFILES=

EOF

	cat <<EOF >>${_plist}

${_licenses_dir}/catalog.mk

${_licenses_dir}/LICENSE

${_licenses_dir}/ESF

EOF

	mkdir -p ${CORE_PKG_REAL_PATH}/All

	if ! pkg create -o ${CORE_PKG_REAL_PATH}/All -p ${_plist} -r ${_root} -m ${_metadir}; then

		echo ">>> ERROR: Error building package ${_template} ${_flavor}"

		print_error_pfS

	fi

}

# 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

	if [ "$1" != "" ]; then

		echo $1

	fi

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

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

		tail -n20 ${LOGFILE} >&2

	echo

	kill $$

	exit 1

}

prestage_on_ram_setup() {

	# Do not use memory disks for release build

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

		return

	fi

	[ -d "${STAGE_CHROOT_DIR}" ] \

		|| mkdir -p ${STAGE_CHROOT_DIR}

	[ -d "${FINAL_CHROOT_DIR}" ] \

		|| mkdir -p ${FINAL_CHROOT_DIR}

	_AVAIL_MEM=$(($(sysctl -n hw.usermem) / 1024 / 1024))

	if [ $_AVAIL_MEM -lt 2000 ]; then

		echo ">>> Builder has less than 2GiB RAM skipping memory disks"

		return

	else

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

		echo

		echo ">>> Builder has more than 2GiB RAM enabling memory disks"

		echo ">>> WARNING: Remember to remove these memory disks by running $0 --disable-memorydisks"

		echo

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

	fi

	if df /dev/ufs/prestagebacking >/dev/null 2>&1; then

		echo ">>> Detected preexisting memory disk enabled for ${STAGE_CHROOT_DIR}."

	else

		mdconfig -a -t swap -u 10001 -s ${MEMORYDISK_SIZE}

		newfs -L prestagebacking -U /dev/md10001

		mount /dev/ufs/prestagebacking ${STAGE_CHROOT_DIR}

	fi

	if df /dev/ufs/finalstagebacking >/dev/null 2>&1; then

		echo ">>> Detected preexisting memory disk enabled for ${FINAL_CHROOT_DIR}."

	else

		mdconfig -a -t swap -u 10002 -s ${MEMORYDISK_SIZE}

		newfs -L finalstagebacking -U /dev/md10002

		mount /dev/ufs/finalstagebacking ${FINAL_CHROOT_DIR}

	fi

}

prestage_on_ram_cleanup() {

	if [ -c /dev/md10001 ]; then

		if [ -d ${STAGE_CHROOT_DIR} ]; then

			umount ${STAGE_CHROOT_DIR}

		fi

		mdconfig -d -u 10001

	fi

	if [ -c /dev/md10002 ]; then

		if [ -d ${FINAL_CHROOT_DIR} ]; then

			umount ${FINAL_CHROOT_DIR}

		fi

		mdconfig -d -u 10002

	fi

}

# 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 KERNELCONF

		unset KERNEL_NAME

		export KERNCONF=$BUILD_KERNEL

		export KERNEL_DESTDIR="$KERNEL_BUILD_PATH/$BUILD_KERNEL"

		export KERNELCONF="${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/$BUILD_KERNEL"

		export KERNEL_NAME=${BUILD_KERNEL}

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

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

		if [ ! -e "${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/${BUILD_KERNEL}" ]; then

			echo ">>> ERROR: Could not find $KERNELCONF"

			print_error_pfS

		fi

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

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

			continue

		fi

		export SRC_CONF=${SRC_CONF}

		buildkernel

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

		installkernel

		ensure_kernel_exists $KERNEL_DESTDIR

		echo -n ">>> 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} \*.symbols

		find ${KERNEL_DESTDIR} -name '*.symbols' -type f -delete

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

		core_pkg_create kernel ${KERNEL_NAME} ${CORE_PKG_VERSION} ${KERNEL_DESTDIR}

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

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

	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

	# Lock kernel to avoid user end up removing it for any reason

	pkg_chroot ${FINAL_CHROOT_DIR} lock -q -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_REAL_PATH}/All/$(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_REAL_PATH}/All/$(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

}

# Creates a full update file

create_Full_update_tarball() {

	mkdir -p $UPDATESDIR

	customize_stagearea_for_image "fullupdate"

	install_default_kernel ${DEFAULT_KERNEL}

	rm -rf ${FINAL_CHROOT_DIR}/cf

	rm -rf ${FINAL_CHROOT_DIR}/conf

	rm -f ${FINAL_CHROOT_DIR}/etc/dh-parameters.*

	rm -f ${FINAL_CHROOT_DIR}/etc/rc.conf

	rm -f ${FINAL_CHROOT_DIR}/etc/pwd.db 2>/dev/null

	rm -f ${FINAL_CHROOT_DIR}/etc/group 2>/dev/null

	rm -f ${FINAL_CHROOT_DIR}/etc/spwd.db 2>/dev/null

	rm -f ${FINAL_CHROOT_DIR}/etc/passwd 2>/dev/null

	rm -f ${FINAL_CHROOT_DIR}/etc/master.passwd 2>/dev/null

	rm -f ${FINAL_CHROOT_DIR}/etc/fstab 2>/dev/null

	rm -f ${FINAL_CHROOT_DIR}/etc/bogons 2>/dev/null

	# Remove loader.conf and friends.  Ticket #560

	rm ${FINAL_CHROOT_DIR}/boot/loader.conf 2>/dev/null

	rm ${FINAL_CHROOT_DIR}/boot/loader.conf.local 2>/dev/null

	# Old systems will run (pre|post)_upgrade_command from /tmp

	if [ -f ${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/pre_upgrade_command ]; then

		cp -p \

			${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/pre_upgrade_command \

			${FINAL_CHROOT_DIR}/tmp

	fi

	if [ -f ${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/post_upgrade_command ]; then

		cp -p \

			${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/post_upgrade_command \

			${FINAL_CHROOT_DIR}/tmp

	fi

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

	tar --exclude=./dev -czPf ${UPDATES_TARBALL_FILENAME} -C ${FINAL_CHROOT_DIR} .

}

# Outputs various set variables aka env

print_flags() {

	echo

	printf "             Product version: %s\n" $PRODUCT_VERSION

	printf "                   Stage DIR: %s\n" $STAGE_CHROOT_DIR

	printf "                 Updates dir: %s\n" $UPDATESDIR

	printf " Image Preparation Stage DIR: %s\n" $FINAL_CHROOT_DIR

	printf "                  Source DIR: %s\n" $FREEBSD_SRC_DIR

	printf "          FreeBSD repository: %s\n" $FREEBSD_REPO_BASE

	printf "          FreeBSD-src branch: %s\n" $FREEBSD_BRANCH

	printf "     FreeBSD original branch: %s\n" $FREEBSD_PARENT_BRANCH

	printf "               BUILD_KERNELS: %s\n" $BUILD_KERNELS

	printf "           Git Branch or Tag: %s\n" $GIT_REPO_BRANCH_OR_TAG

	printf "            MODULES_OVERRIDE: %s\n" $MODULES_OVERRIDE

	printf "    VMDK_DISK_CAPACITY_IN_GB: %s\n" $VMDK_DISK_CAPACITY_IN_GB

	printf "                 OVFTEMPLATE: %s\n" $OVFTEMPLATE

	printf "                     OVFVMDK: %s\n" $OVFVMDK

	printf "                    SRC_CONF: %s\n" $SRC_CONF

	printf "                     ISOPATH: %s\n" $ISOPATH

	printf "                MEMSTICKPATH: %s\n" $MEMSTICKPATH

	printf "    UPDATES_TARBALL_FILENAME: %s\n" $UPDATES_TARBALL_FILENAME

if [ -n "$SHOW_ENV" ]; then

	for LINE in $(env | egrep -v '(terminal|PASS|NAME|USER|SSH|GROUP|HOST)'); do

		echo "SHOW_ENV: $LINE"

	done

fi

	echo

}

# This builds FreeBSD (make buildworld)

# Imported from FreeSBIE

make_world() {

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

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

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

		return

	fi

	# Set SRC_CONF variable if it's not already set.

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

		echo ">>> SRC_CONF is unset make sure this is what you want!" | tee -a ${LOGFILE}

	else

		echo ">>> Setting SRC_CONF to $SRC_CONF" | tee -a ${LOGFILE}

	fi

	# Set default parameters

	export MAKE_ARGS="${MAKEJ_WORLD} __MAKE_CONF=${MAKE_CONF} SRCCONF=${SRC_CONF} TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH}"

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

	makeargs="${MAKE_ARGS}"

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

	echo ">>> Builder is running the command: env LOCAL_ITOOLS=\"${EXTRA_TOOLS}\" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_CLEAN ${makeargs} buildworld" | tee -a ${LOGFILE}

	(env LOCAL_ITOOLS="${EXTRA_TOOLS}" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_CLEAN ${makeargs} buildworld || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}

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

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

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

	# Create if cleaned up

	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR} WITHOUT_TOOLCHAIN=1"

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

	echo ">>> Builder is running the command: env LOCAL_ITOOLS=\"${EXTRA_TOOLS}\" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installworld" | tee -a ${LOGFILE}

	(env LOCAL_ITOOLS="${EXTRA_TOOLS}" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installworld || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}

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

	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR}"

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

	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} distribution " | tee -a ${LOGFILE}

	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} distribution  || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}

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

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

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

	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR}"

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

	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/crypto ${makeargs} clean all install " | 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}

	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} clean" | tee -a ${LOGFILE}

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

	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} all" | tee -a ${LOGFILE}

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

	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} install" | tee -a ${LOGFILE}

	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} 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}

	unset makeargs

}

nanobsd_image_filename() {

	local _size="$1"

	local _type="$2"

	local _upgrade="$3"

	if [ -z "$_upgrade" ]; then

		local _template=${NANOBSD_IMG_TEMPLATE}

	else

		local _template=${NANOBSD_UPGRADE_TEMPLATE}

	fi

	echo "$_template" | sed \

		-e "s,%%SIZE%%,${_size},g" \

		-e "s,%%TYPE%%,${_type},g"

	return 0

}

# This routine originated in nanobsd.sh

nanobsd_set_flash_details () {

	a1=$(echo $1 | tr '[:upper:]' '[:lower:]')

	# Source:

	#	SanDisk CompactFlash Memory Card

	#	Product Manual

	#	Version 10.9

	#	Document No. 20-10-00038

	#	April 2005

	# Table 2-7

	# NB: notice math error in SDCFJ-4096-388 line.

	#

	case "${a1}" in

		2048|2048m|2048mb|2g)

			NANO_MEDIASIZE=$((1989999616/512))

			;;

		4096|4096m|4096mb|4g)

			NANO_MEDIASIZE=$((3989999616/512))

			;;

		8192|8192m|8192mb|8g)

			NANO_MEDIASIZE=$((7989999616/512))

			;;

		16384|16384m|16384mb|16g)

			NANO_MEDIASIZE=$((15989999616/512))

			;;

		*)

			echo "Unknown Flash capacity"

			exit 2

			;;

	esac

	NANO_HEADS=16

	NANO_SECTS=63

	echo ">>> [nanoo] $1"

	echo ">>> [nanoo] NANO_MEDIASIZE: $NANO_MEDIASIZE"

	echo ">>> [nanoo] NANO_HEADS: $NANO_HEADS"

	echo ">>> [nanoo] NANO_SECTS: $NANO_SECTS"

	echo ">>> [nanoo] NANO_BOOT0CFG: $NANO_BOOT0CFG"

}

# This routine originated in nanobsd.sh

create_nanobsd_diskimage () {

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

		echo ">>> ERROR: Type of image has not been specified"

		print_error_pfS

	fi

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

		echo ">>> ERROR: Size of image has not been specified"

		print_error_pfS

	fi

	if [ "${1}" = "nanobsd" ]; then

		# It's serial

		export NANO_BOOTLOADER="boot/boot0sio"

	elif [ "${1}" = "nanobsd-vga" ]; then

		# It's vga

		export NANO_BOOTLOADER="boot/boot0"

	else

		echo ">>> ERROR: Type of image to create unknown"

		print_error_pfS

	fi

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

		echo ">>> ERROR: Media size(s) not specified."

		print_error_pfS

	fi

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

		echo ">>> ERROR: FLASH_SIZE is not set."

		print_error_pfS

	fi

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

	# Prepare folder to be put in image

	customize_stagearea_for_image "${1}"

	install_default_kernel ${DEFAULT_KERNEL} "no"

	echo ">>> Fixing up NanoBSD Specific items..." | tee -a ${LOGFILE}

	echo "nanobsd" > $FINAL_CHROOT_DIR/etc/platform

	local BOOTCONF=${FINAL_CHROOT_DIR}/boot.config

	local LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf

	if [ "${1}" = "nanobsd" ]; then

		# Tell loader to use serial console early.

		echo "-S115200 -h" >> ${BOOTCONF}

		# Remove old console options if present.

		[ -f "${LOADERCONF}" ] \

			&& sed -i "" -Ee "/(console|boot_multicons|boot_serial|hint.uart)/d" ${LOADERCONF}

		# Activate serial console+video console in loader.conf

		echo 'loader_color="NO"' >> ${LOADERCONF}

		echo 'beastie_disable="YES"' >> ${LOADERCONF}

		echo 'boot_serial="YES"' >> ${LOADERCONF}

		echo 'console="comconsole"' >> ${LOADERCONF}

		echo 'comconsole_speed="115200"' >> ${LOADERCONF}

	fi

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

	for _NANO_MEDIASIZE in ${2}; do

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

			continue;

		fi

		echo ">>> building NanoBSD(${1}) disk image with size ${_NANO_MEDIASIZE} for platform (${TARGET})..." | tee -a ${LOGFILE}

		echo "" > $BUILDER_LOGS/nanobsd_cmds.sh

		IMG="${IMAGES_FINAL_DIR}/$(nanobsd_image_filename ${_NANO_MEDIASIZE} ${1})"

		IMGUPDATE="${IMAGES_FINAL_DIR}/$(nanobsd_image_filename ${_NANO_MEDIASIZE} ${1} 1)"

		nanobsd_set_flash_details ${_NANO_MEDIASIZE}

		# These are defined in FlashDevice and on builder_default.sh

		echo $NANO_MEDIASIZE \

			$NANO_IMAGES \

			$NANO_SECTS \

			$NANO_HEADS \

			$NANO_CODESIZE \

			$NANO_CONFSIZE \

			$NANO_DATASIZE |

awk '

{

	printf "# %s\n", $0

	# size of cylinder in sectors

	cs = $3 * $4

	# number of full cylinders on media

	cyl = int ($1 / cs)

	# output fdisk geometry spec, truncate cyls to 1023

	if (cyl <= 1023)

		print "g c" cyl " h" $4 " s" $3

	else

		print "g c" 1023 " h" $4 " s" $3

	if ($7 > 0) {

		# size of data partition in full cylinders

		dsl = int (($7 + cs - 1) / cs)

	} else {

		dsl = 0;

	}

	# size of config partition in full cylinders

	csl = int (($6 + cs - 1) / cs)

	if ($5 == 0) {

		# size of image partition(s) in full cylinders

		isl = int ((cyl - dsl - csl) / $2)

	} else {

		isl = int (($5 + cs - 1) / cs)

	}

	# First image partition start at second track

	print "p 1 165 " $3, isl * cs - $3

	c = isl * cs;

	# Second image partition (if any) also starts offset one

	# track to keep them identical.

	if ($2 > 1) {

		print "p 2 165 " $3 + c, isl * cs - $3

		c += isl * cs;

	}

	# Config partition starts at cylinder boundary.

	print "p 3 165 " c, csl * cs

	c += csl * cs

	# Data partition (if any) starts at cylinder boundary.

	if ($7 > 0) {

		print "p 4 165 " c, dsl * cs

	} else if ($7 < 0 && $1 > c) {

		print "p 4 165 " c, $1 - c

	} else if ($1 < c) {

		print "Disk space overcommitted by", \

		    c - $1, "sectors" > "/dev/stderr"

		exit 2

	}

	# Force slice 1 to be marked active. This is necessary

	# for booting the image from a USB device to work.

	print "a 1"

}

	' > ${IMAGES_FINAL_DIR}/_.fdisk

		MNT=${IMAGES_FINAL_DIR}/_.mnt

		mkdir -p ${MNT}

		dd if=/dev/zero of=${IMG} bs=${NANO_SECTS}b \

			count=0 seek=$((${NANO_MEDIASIZE}/${NANO_SECTS})) 2>&1 >> ${LOGFILE}

		MD=$(mdconfig -a -t vnode -f ${IMG} -x ${NANO_SECTS} -y ${NANO_HEADS})

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

		fdisk -i -f ${IMAGES_FINAL_DIR}/_.fdisk ${MD} 2>&1 >> ${LOGFILE}

		fdisk ${MD} 2>&1 >> ${LOGFILE}

		boot0cfg -t 100 -B -b ${FINAL_CHROOT_DIR}/${NANO_BOOTLOADER} ${NANO_BOOT0CFG} ${MD} 2>&1 >> ${LOGFILE}

		# Create first image

		bsdlabel -m i386 -w -B -b ${FINAL_CHROOT_DIR}/boot/boot ${MD}s1 2>&1 >> ${LOGFILE}

		bsdlabel -m i386 ${MD}s1 2>&1 >> ${LOGFILE}

		local _label=$(lc ${PRODUCT_NAME})

		newfs -L ${_label}0 ${NANO_NEWFS} /dev/${MD}s1a 2>&1 >> ${LOGFILE}

		mount /dev/ufs/${_label}0 ${MNT}

		if [ $? -ne 0 ]; then

			echo ">>> ERROR: Something wrong happened during mount of first slice image creation. STOPPING!" | tee -a ${LOGFILE}

			print_error_pfS

		fi

		# Consider the unmounting as well

		trap "umount /dev/ufs/${_label}0; mdconfig -d -u ${MD}; return" 1 2 15 EXIT

		clone_directory_contents ${FINAL_CHROOT_DIR} ${MNT}

		# Set NanoBSD image size

		echo "${_NANO_MEDIASIZE}" > ${MNT}/etc/nanosize.txt

		echo "/dev/ufs/${_label}0 / ufs ro,sync,noatime 1 1" > ${MNT}/etc/fstab

		if [ $NANO_CONFSIZE -gt 0 ] ; then

			echo "/dev/ufs/cf /cf ufs ro,sync,noatime 1 1" >> ${MNT}/etc/fstab

		fi

		umount ${MNT}

		# Restore the original trap

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

		# Setting NANO_IMAGES to 1 and NANO_INIT_IMG2 will tell

		# NanoBSD to only create one partition.  We default to 2

		# partitions in case anything happens to the first the

		# operator can boot from the 2nd and should be OK.

		# Before just going to use dd for duplicate think!

		# The images are created as sparse so lets take advantage

		# of that by just exec some commands.

		if [ $NANO_IMAGES -gt 1 -a $NANO_INIT_IMG2 -gt 0 ] ; then

			# Duplicate to second image (if present)

			echo ">>> Creating NanoBSD second slice by duplicating first slice." | tee -a ${LOGFILE}

			# Create second image

			dd if=/dev/${MD}s1 of=/dev/${MD}s2 conv=sparse bs=64k 2>&1 >> ${LOGFILE}

			tunefs -L ${_label}1 /dev/${MD}s2a 2>&1 >> ${LOGFILE}

			mount /dev/ufs/${_label}1 ${MNT}

			if [ $? -ne 0 ]; then

				echo ">>> ERROR: Something wrong happened during mount of second slice image creation. STOPPING!" | tee -a ${LOGFILE}

				print_error_pfS

			fi

			# Consider the unmounting as well

			trap "umount /dev/ufs/${_label}1; mdconfig -d -u ${MD}; return" 1 2 15 EXIT

			echo "/dev/ufs/${_label}1 / ufs ro,sync,noatime 1 1" > ${MNT}/etc/fstab

			if [ $NANO_CONFSIZE -gt 0 ] ; then

				echo "/dev/ufs/cf /cf ufs ro,sync,noatime 1 1" >> ${MNT}/etc/fstab

			fi

			umount ${MNT}

			# Restore the trap back

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

		fi

		# Create Data slice, if any.

		# Note the changing of the variable to NANO_CONFSIZE

		# from NANO_DATASIZE.  We also added glabel support

		# and populate the Product configuration from the /cf

		# directory located in FINAL_CHROOT_DIR

		if [ $NANO_CONFSIZE -gt 0 ] ; then

			echo ">>> Creating /cf area to hold config.xml"

			newfs -L cf ${NANO_NEWFS} /dev/${MD}s3 2>&1 >> ${LOGFILE}

			# Mount data partition and copy contents of /cf

			# Can be used later to create custom default config.xml while building

			mount /dev/ufs/cf ${MNT}

			if [ $? -ne 0 ]; then

				echo ">>> ERROR: Something wrong happened during mount of cf slice image creation. STOPPING!" | tee -a ${LOGFILE}

				print_error_pfS

			fi

			# Consider the unmounting as well

			trap "umount /dev/ufs/cf; mdconfig -d -u ${MD}; return" 1 2 15 EXIT

			clone_directory_contents ${FINAL_CHROOT_DIR}/cf ${MNT}

			umount ${MNT}

			# Restore the trap back

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

		else

			">>> [nanoo] NANO_CONFSIZE is not set. Not adding a /conf partition.. You sure about this??" | tee -a ${LOGFILE}

		fi

		echo ">>> [nanoo] Creating NanoBSD upgrade file from first slice..." | tee -a ${LOGFILE}

		dd if=/dev/${MD}s1 of=$IMGUPDATE conv=sparse bs=64k 2>&1 >> ${LOGFILE}

		mdconfig -d -u $MD

		# Restore default action

		trap "-" 1 2 15 EXIT

		# Check each image and ensure that they are over

		# 3 megabytes.  If either image is under 20 megabytes

		# in size then error out.

		IMGSIZE=$(stat -f "%z" ${IMG})

		IMGUPDATESIZE=$(stat -f "%z" ${IMGUPDATE})

		CHECKSIZE="20040710"

		if [ "$IMGSIZE" -lt "$CHECKSIZE" ]; then

			echo ">>> ERROR: Something went wrong when building NanoBSD.  The image size is under 20 megabytes!" | tee -a ${LOGFILE}

			print_error_pfS

		fi

		if [ "$IMGUPDATESIZE" -lt "$CHECKSIZE" ]; then

			echo ">>> ERROR: Something went wrong when building NanoBSD upgrade image.  The image size is under 20 megabytes!" | tee -a ${LOGFILE}

			print_error_pfS

		fi

		# Wrap up the show, Johnny

		echo ">>> NanoBSD Image completed for size: $_NANO_MEDIASIZE." | tee -a ${LOGFILE}

		gzip -qf $IMG &

		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"

		gzip -qf $IMGUPDATE &

		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"

	done

	unset IMG

	unset IMGUPDATE

	unset IMGUPDATESIZE

	unset IMGSIZE

	ls -lah $IMAGES_FINAL_DIR

}

# 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

	[ -d "${OVA_TMP}" ] \

		&& rm -rf ${OVA_TMP}

	mkdir -p ${OVA_TMP}