/tools/builder_common.sh - Annotate - pfSense - pfSense bugtracker

| Branch: | Tag: | Revision:

root/tools/builder_common.sh @ a9ae8dac

-f73c362
+#!/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:
+#
-be2
+if [ -n "${IMAGES_FINAL_DIR}" -a "${IMAGES_FINAL_DIR}" != "/" ]; then
 	mkdir -p ${IMAGES_FINAL_DIR}
-f73c362
+else
-be2
+	echo "IMAGES_FINAL_DIR is not defined"
-f73c362
+	print_error_pfS
 fi
 lc() {
 	echo "${1}" | tr '[[:upper:]]' '[[:lower:]]'
+}
 git_last_commit() {
-b0ef57e
+	export CURRENT_COMMIT=$(git -C ${BUILDER_ROOT} log -1 --format='%H')
 	export CURRENT_AUTHOR=$(git -C ${BUILDER_ROOT} log -1 --format='%an')
-b0f246
+	echo ">>> Last known commit $CURRENT_AUTHOR - $CURRENT_COMMIT"
 	echo "$CURRENT_COMMIT" > $SCRATCHDIR/build_commit_info.txt
-f73c362
+            Renato Botelho
-a36
+# Create core pkg repository
 core_pkg_create_repo() {
 	if [ ! -d "${CORE_PKG_PATH}/All" ]; then
 		return
 	fi
 	echo -n ">>> Creating core packages repository... "
-f6
+	if pkg repo -q "${CORE_PKG_PATH}"; then
-a36
+		echo "Done!"
 	else
 		echo "Failed!"
 		print_error_pfS
 	fi
+}
-f73c362
+# Create core pkg (base, kernel)
 core_pkg_create() {
 	local _template="${1}"
 	local _flavor="${2}"
 	local _version="${3}"
 	local _root="${4}"
-            a9ae8dac
+	local _filter="${5}"
-f73c362
+            Renato Botelho
 	[ -d "${CORE_PKG_TMP}" ] \
 		&& rm -rf ${CORE_PKG_TMP}
-ce2a7f3
+	local _templates_path=${BUILDER_TOOLS}/templates/core_pkg/${_template}
-f73c362
+	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
-            a9ae8dac
+		if [ -n "${_filter}" ]; then
 			_filter="-name ${_filter}"
 		fi
 		(cd ${_root} && find . ${_filter} -type f -or -type l | sed 's,^.,,' | sort -u) > ${_plist}
-f73c362
+	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},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
-            a7a00341
+	mkdir -p ${CORE_PKG_PATH}/All
 	if ! pkg create -o ${CORE_PKG_PATH}/All -p ${_plist} -r ${_root} -m ${_metadir}; then
-f73c362
+		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
-            d4c6029e
+	[ -n "${LOGFILE}" -a -f "${LOGFILE}" ] && \
-f73c362
+		echo "Log saved on ${LOGFILE}" && \
 		tail -n20 ${LOGFILE} >&2
 	echo
 	kill $$
 	exit 1
+}
 prestage_on_ram_setup() {
-            f546e6ca
+	[ -d "${STAGE_CHROOT_DIR}" ] \
 		|| mkdir -p ${STAGE_CHROOT_DIR}
 	[ -d "${FINAL_CHROOT_DIR}" ] \
 		|| mkdir -p ${FINAL_CHROOT_DIR}
-f73c362
+	_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
-c6f31a
+		echo ">>> Builder has more than 2GiB RAM enabling memory disks"
-f73c362
+		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"
-f27203
+		export KERNELCONF="${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/$BUILD_KERNEL"
-f73c362
+		export KERNEL_NAME=${BUILD_KERNEL}
 		LOGFILE="${BUILDER_LOGS}/kernel.${KERNCONF}.${TARGET}.log"
 		echo ">>> Building $BUILD_KERNEL kernel."  | tee -a ${LOGFILE}
-f27203
+		if [ ! -e "${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/${BUILD_KERNEL}" ]; then
-f73c362
+			echo ">>> ERROR: Could not find $KERNELCONF"
 			print_error_pfS
 		fi
-            d4c6029e
+		if [ -n "${NO_BUILDKERNEL}" -a -f "${CORE_PKG_PATH}/All/$(get_pkg_name kernel-${KERNEL_NAME}).txz" ]; then
-f73c362
+			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
-            a9ae8dac
+		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
-f73c362
+		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
-            a7a00341
+		cp ${CORE_PKG_PATH}/All/$(get_pkg_name kernel-${KERNEL_NAME}).txz $FINAL_CHROOT_DIR/pkgs
-f73c362
+		if [ -n "${INSTALL_EXTRA_KERNELS}" ]; then
 			for _EXTRA_KERNEL in $INSTALL_EXTRA_KERNELS; do
-            a7a00341
+				_EXTRA_KERNEL_PATH=${CORE_PKG_PATH}/All/$(get_pkg_name kernel-${_EXTRA_KERNEL}).txz
-f73c362
+				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/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
-            f3fff72f
+	# Old systems will run (pre|post)_upgrade_command from /tmp
-ab0
+	if [ -f ${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/pre_upgrade_command ]; then
 		cp -p \
 			${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/pre_upgrade_command \
 			${FINAL_CHROOT_DIR}/tmp
 	fi
-            f3fff72f
+	if [ -f ${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/post_upgrade_command ]; then
 		cp -p \
 			${FINAL_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/post_upgrade_command \
 			${FINAL_CHROOT_DIR}/tmp
 	fi
-ab0
+            Renato Botelho
-f73c362
+	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
-f27203
+	printf "                  Source DIR: %s\n" $FREEBSD_SRC_DIR
-f73c362
+	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
-db0bd
+	printf "    VMDK_DISK_CAPACITY_IN_GB: %s\n" $VMDK_DISK_CAPACITY_IN_GB
-            e74b64a1
+	printf "   OVA_FIRST_PART_SIZE_IN_GB: %s\n" $OVA_FIRST_PART_SIZE_IN_GB
-            beb07890
+	printf "    OVA_SWAP_PART_SIZE_IN_GB: %s\n" $OVA_SWAP_PART_SIZE_IN_GB
-fa93f
+	printf "                 OVFTEMPLATE: %s\n" $OVFTEMPLATE
-f73c362
+	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}
-            d4c6029e
+	if [ -n "${NO_BUILDWORLD}" ]; then
-f73c362
+		echo ">>> NO_BUILDWORLD set, skipping build" | tee -a ${LOGFILE}
 		return
 	fi
 	# Set SRC_CONF variable if it's not already set.
-            d4c6029e
+	if [ -z "${SRC_CONF}" ]; then
-f73c362
+		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
-            d4c6029e
+	export MAKE_ARGS="${MAKEJ_WORLD} __MAKE_CONF=${MAKE_CONF} SRCCONF=${SRC_CONF} TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH}"
-f73c362
+            Renato Botelho
 	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}
-            d4c6029e
+	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}
-f73c362
+	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}
-            d4c6029e
+	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}
-f73c362
+	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}
-            d4c6029e
+	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}
-f73c362
+	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}
-            d4c6029e
+	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}
-f73c362
+	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
 	unset makeargs
+}
 # 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
 |1024m|1024mb|1g)
 			NANO_MEDIASIZE=$((997129216/512))
 			;;
 |2048m|2048mb|2g)
 			NANO_MEDIASIZE=$((1989999616/512))
 			;;
 |4096m|4096mb|4g)
 			NANO_MEDIASIZE=$((3989999616/512))
 			;;
 |8192m|8192mb|8g)
 			NANO_MEDIASIZE=$((7989999616/512))
 			;;
 |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"
-bfd
+	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}
-dcb68a4
+		# 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
-            a9ba7be8
+	echo 'autoboot_delay="5"' >> ${LOADERCONF}
-f73c362
+            Renato Botelho
 	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
-            f48a09c7
+		IMG="${IMAGES_FINAL_DIR}/${PRODUCT_NAME}-${PRODUCT_VERSION}-${_NANO_MEDIASIZE}-${TARGET}-${1}${TIMESTAMP_SUFFIX}.img"
 		IMGUPDATE="${IMAGES_FINAL_DIR}/${PRODUCT_NAME}-${PRODUCT_VERSION}-${_NANO_MEDIASIZE}-${TARGET}-${1}-upgrade${TIMESTAMP_SUFFIX}.img"
-f73c362
+            Renato Botelho
 		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"
+}
-be2
+	' > ${IMAGES_FINAL_DIR}/_.fdisk
-f73c362
+            Renato Botelho
-be2
+		MNT=${IMAGES_FINAL_DIR}/_.mnt
-f73c362
+		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
-be2
+		fdisk -i -f ${IMAGES_FINAL_DIR}/_.fdisk ${MD} 2>&1 >> ${LOGFILE}
-f73c362
+		fdisk ${MD} 2>&1 >> ${LOGFILE}
 		boot0cfg -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
 		rm -f $MNT/cf/conf/* 2>/dev/null
 		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}
-ef49f6
+		gzip -qf $IMG &
 		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
 		gzip -qf $IMGUPDATE &
 		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
-f73c362
+	done
 	unset IMG
 	unset IMGUPDATE
 	unset IMGUPDATESIZE
 	unset IMGSIZE
-be2
+	ls -lah $IMAGES_FINAL_DIR
-f73c362
+            Renato Botelho
 # 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
-a72b59
+	[ -d "${OVA_TMP}" ] \
 		&& rm -rf ${OVA_TMP}
 	mkdir -p ${OVA_TMP}
-f73c362
+	# Prepare folder to be put in image
 	customize_stagearea_for_image "ova"
 	install_default_kernel ${DEFAULT_KERNEL} "no"
-a72b59
+	# Fill fstab
 	echo ">>> Installing platform specific items..." | tee -a ${LOGFILE}
-d23e26
+	echo "/dev/gpt/${PRODUCT_NAME}	/	ufs		rw	0	0" > ${FINAL_CHROOT_DIR}/etc/fstab
 	echo "/dev/gpt/swap0	none	swap	sw	0	0" >> ${FINAL_CHROOT_DIR}/etc/fstab
-a72b59
+            Renato Botelho
 	# Create / partition
-b4bd
+	echo -n ">>> Creating / partition... " | tee -a ${LOGFILE}
-a72b59
+	makefs \
 		-B little \
 		-o label=${PRODUCT_NAME} \
-            e74b64a1
+		-s ${OVA_FIRST_PART_SIZE_IN_GB}g \
-a72b59
+		${OVA_TMP}/${OVFUFS} \
 		${FINAL_CHROOT_DIR} 2>&1 >> ${LOGFILE}
 	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFUFS} ]; then
 		if [ -f ${OVA_TMP}/${OVFUFS} ]; then
 			rm -f ${OVA_TMP}/${OVFUFS}
 		fi
-b4bd
+		echo "Failed!" | tee -a ${LOGFILE}
-a72b59
+		echo ">>> ERROR: Error creating vmdk / partition. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
-f73c362
+	fi
-b4bd
+	echo "Done!" | tee -a ${LOGFILE}
-a72b59
+            Renato Botelho
-b4bd
+	# Create raw disk
 	echo -n ">>> Creating raw disk... " | tee -a ${LOGFILE}
-a72b59
+	mkimg \
 		-s gpt \
-b5a66
+		-f raw \
-a72b59
+		-b /boot/pmbr \
 		-p freebsd-boot:=/boot/gptboot \
 		-p freebsd-ufs/${PRODUCT_NAME}:=${OVA_TMP}/${OVFUFS} \
 		-p freebsd-swap/swap0::${OVA_SWAP_PART_SIZE} \
-b5a66
+		-o ${OVA_TMP}/${OVFRAW} 2>&1 >> ${LOGFILE}
-a72b59
+            Renato Botelho
-b5a66
+	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFRAW} ]; then
-a72b59
+		if [ -f ${OVA_TMP}/${OVFUFS} ]; then
 			rm -f ${OVA_TMP}/${OVFUFS}
 		fi
-b5a66
+		if [ -f ${OVA_TMP}/${OVFRAW} ]; then
 			rm -f ${OVA_TMP}/${OVFRAW}
-db0bd
+		fi
-b4bd
+		echo "Failed!" | tee -a ${LOGFILE}
-db0bd
+		echo ">>> ERROR: Error creating temporary vmdk image. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
-b4bd
+	echo "Done!" | tee -a ${LOGFILE}
-db0bd
+            Renato Botelho
 	# We don't need it anymore
 	rm -f ${OVA_TMP}/${OVFUFS} >/dev/null 2>&1
-b5a66
+	# Convert raw to vmdk
-b4bd
+	echo -n ">>> Creating vmdk disk... " | tee -a ${LOGFILE}
-            beb07890
+	vmdktool -z9 -v ${OVA_TMP}/${OVFVMDK} ${OVA_TMP}/${OVFRAW}
-db0bd
+            Renato Botelho
-dc195f9
+	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFVMDK} ]; then
-b5a66
+		if [ -f ${OVA_TMP}/${OVFRAW} ]; then
 			rm -f ${OVA_TMP}/${OVFRAW}
-db0bd
+		fi
-a72b59
+		if [ -f ${OVA_TMP}/${OVFVMDK} ]; then
 			rm -f ${OVA_TMP}/${OVFVMDK}
 		fi
-b4bd
+		echo "Failed!" | tee -a ${LOGFILE}
-a72b59
+		echo ">>> ERROR: Error creating vmdk image. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
-f73c362
+	fi
-b4bd
+	echo "Done!" | tee -a ${LOGFILE}
-f73c362
+            Renato Botelho
-b5a66
+	rm -f ${OVA_TMP}/i${OVFRAW}
-f73c362
+            Renato Botelho
-a72b59
+	ova_setup_ovf_template
-f73c362
+            Renato Botelho
-b4bd
+	echo -n ">>> Writing final ova image... " | tee -a ${LOGFILE}
 	# Create OVA file for vmware
-a72b59
+	gtar -C ${OVA_TMP} -cpf ${OVAPATH} ${PRODUCT_NAME}.ovf ${OVFVMDK}
-b4bd
+	echo "Done!" | tee -a ${LOGFILE}
-a72b59
+	rm -f ${OVA_TMP}/${OVFVMDK} >/dev/null 2>&1
 	echo ">>> OVA created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
-f73c362
+            Renato Botelho
 # called from create_ova_image
-            a82b9f43
+ova_setup_ovf_template() {
-            fc48ef54
+	if [ ! -f ${OVFTEMPLATE} ]; then
-fa93f
+		echo ">>> ERROR: OVF template file (${OVFTEMPLATE}) not found."
 		print_error_pfS
-f73c362
+	fi
-            fc48ef54
+	#  OperatingSystemSection (${PRODUCT_NAME}.ovf)
 	#  42   FreeBSD 32-Bit
 	#  78   FreeBSD 64-Bit
 	if [ "${TARGET}" = "amd64" ]; then
 		local _os_id="78"
-db0bd
+		local _os_type="freebsd64Guest"
 		local _os_descr="FreeBSD 64-Bit"
-            fc48ef54
+	elif [ "${TARGET}" = "i386" ]; then
 		local _os_id="42"
-db0bd
+		local _os_type="freebsdGuest"
 		local _os_descr="FreeBSD"
-            fc48ef54
+	else
 		echo ">>> ERROR: Platform not supported for OVA (${TARGET})"
 		print_error_pfS
 	fi
-dcadff
+            Renato Botelho
-db0bd
+	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})
-f73c362
+            Renato Botelho
-            fc48ef54
+	sed \
-db0bd
+		-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" \
-            fc48ef54
+		-e "s,%%OS_ID%%,${_os_id},g" \
 		-e "s,%%OS_TYPE%%,${_os_type},g" \
-db0bd
+		-e "s,%%OS_DESCR%%,${_os_descr},g" \
-            fc48ef54
+		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
 		-e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION},g" \
 		-e "s,%%PRODUCT_URL%%,${PRODUCT_URL},g" \
-e35e0bd
+		-e "/^%%PRODUCT_LICENSE%%/r ${BUILDER_ROOT}/license.txt" \
-            fc48ef54
+		-e "/^%%PRODUCT_LICENSE%%/d" \
 		${OVFTEMPLATE} > ${OVA_TMP}/${PRODUCT_NAME}.ovf
-f73c362
+            Renato Botelho
 # Cleans up previous builds
-e6ab3ed
+clean_builder() {
-f73c362
+	# Clean out directories
 	echo ">>> Cleaning up previous build environment...Please wait!"
 	staginareas_clean_each_run
 	if [ -d "${STAGE_CHROOT_DIR}" ]; then
 		BASENAME=$(basename ${STAGE_CHROOT_DIR})
 		echo -n ">>> Cleaning ${STAGE_CHROOT_DIR} ..."
 		chflags -R noschg ${STAGE_CHROOT_DIR} 2>&1 >/dev/null
-            f546e6ca
+		rm -rf ${STAGE_CHROOT_DIR}/* 2>/dev/null
-f73c362
+		echo "Done."
 	fi
-abc3e80
+	if [ -z "${NO_CLEAN_FREEBSD_OBJ}" -a -d "${FREEBSD_SRC_DIR}" ]; then
-f27203
+		OBJTREE=$(env TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} make -C ${FREEBSD_SRC_DIR} -V OBJTREE)
-f73c362
+		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
-e6ab3ed
+		if [ -d "${KERNEL_BUILD_PATH}" ]; then
-f73c362
+			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..."
-be2
+	rm -rf $IMAGES_FINAL_DIR/*
-            ab943fc9
+	rm -rf $STAGINGAREA/*
-f73c362
+	echo "Done!"
-abc3e80
+	if [ -z "${NO_CLEAN_FREEBSD_SRC}" ]; then
-f27203
+		if [ -d "$FREEBSD_SRC_DIR" ]; then
 			echo -n ">>> Ensuring $FREEBSD_SRC_DIR is clean..."
 			rm -rf ${FREEBSD_SRC_DIR}
-f73c362
+			echo "Done!"
 		fi
 	fi
 	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 [ ! -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
-d6
+	tar -C ${PRODUCT_SRC} -c -f - . | \
-f73c362
+		tar -C ${STAGE_CHROOT_DIR} -x -p -f -
 	if [ -f ${STAGE_CHROOT_DIR}/etc/master.passwd ]; then
 		chroot ${STAGE_CHROOT_DIR} cap_mkdb /etc/master.passwd
 		chroot ${STAGE_CHROOT_DIR} pwd_mkdb /etc/master.passwd
 	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="${CORE_PKG_TMP}/base_exclude_files"
 	sed \
 		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
 		-e "s,%%FLAVOR%%,${_flavor},g" \
 		-e "s,%%VERSION%%,${_version},g" \
-ce2a7f3
+		${BUILDER_TOOLS}/templates/core_pkg/base/exclude_files \
-f73c362
+		> ${_exclude_files}
 	mkdir -p ${STAGE_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME} >/dev/null 2>&1
 	mtree \
 		-c \
 		-k uid,gid,mode,size,flags,sha256digest \
 		-p ${STAGE_CHROOT_DIR} \
 		-X ${_exclude_files} \
 		> ${STAGE_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/base.mtree
 	tar \
 		-C ${STAGE_CHROOT_DIR} \
 		-cJf ${STAGE_CHROOT_DIR}/usr/local/share/${PRODUCT_NAME}/base.txz \
 		-X ${_exclude_files} \
+		.
 	core_pkg_create base "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
-f5207bc
+	core_pkg_create base-nanobsd "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
-f73c362
+	core_pkg_create default-config "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
 	local DEFAULTCONF=${STAGE_CHROOT_DIR}/conf.default/config.xml
-            c4968f42
+            Renato Botelho
 	# Change default interface names to match vmware driver
 	sed -i '' -e 's,em0,vmx0,' -e 's,em1,vmx1,' ${DEFAULTCONF}
 	core_pkg_create default-config-vmware "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
 	# Restore default values to be used by serial package
 	sed -i '' -e 's,vmx0,em0,' -e 's,vmx1,em1,' ${DEFAULTCONF}
-f73c362
+	# Activate serial console in config.xml
 	# If it was there before, clear the setting to be sure we don't add it twice.
 	sed -i "" -e "/		<enableserial\/>/d" ${DEFAULTCONF}
 	# Enable serial in the config
 	sed -i "" -e "s/	<\/system>/		<enableserial\/>\\$(echo -e \\\n)	<\/system>/" ${DEFAULTCONF}
 	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}
 	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() {
 	# Prepare final stage area
 	create_final_staging_area
-f5207bc
+	if [ "${1}" = "nanobsd" -o \
 	     "${1}" = "nanobsd-vga" ]; then
-b79a60
+            Renato Botelho
 		mkdir -p ${FINAL_CHROOT_DIR}/root/var/db \
 			 ${FINAL_CHROOT_DIR}/root/var/cache \
 			 ${FINAL_CHROOT_DIR}/var/db/pkg \
 			 ${FINAL_CHROOT_DIR}/var/cache/pkg
 		mv -f ${FINAL_CHROOT_DIR}/var/db/pkg ${FINAL_CHROOT_DIR}/root/var/db
 		mv -f ${FINAL_CHROOT_DIR}/var/cache/pkg ${FINAL_CHROOT_DIR}/root/var/cache
 		ln -sf ../../root/var/db/pkg ${FINAL_CHROOT_DIR}/var/db/pkg
 		ln -sf ../../root/var/cache/pkg ${FINAL_CHROOT_DIR}/var/cache/pkg
-f5207bc
+		pkg_chroot_add ${FINAL_CHROOT_DIR} base-nanobsd
 	else
 		pkg_chroot_add ${FINAL_CHROOT_DIR} base
 	fi
-ee167de
+            Renato Botelho
-f73c362
+	if [ "${1}" = "iso" -o \
 	     "${1}" = "memstick" -o \
 	     "${1}" = "memstickserial" -o \
 	     "${1}" = "memstickadi" ]; then
 		install_bsdinstaller
 		mkdir -p ${FINAL_CHROOT_DIR}/pkgs
-            a7a00341
+		cp ${CORE_PKG_PATH}/All/*default-config*.txz ${FINAL_CHROOT_DIR}/pkgs
-f73c362
+	fi
 	if [ "${1}" = "nanobsd" -o \
 	     "${1}" = "memstickserial" -o \
 	     "${1}" = "memstickadi" ]; then
 		pkg_chroot_add ${FINAL_CHROOT_DIR} default-config-serial
-            c4968f42
+	elif [ "${1}" = "ova" ]; then
 		pkg_chroot_add ${FINAL_CHROOT_DIR} default-config-vmware
-f73c362
+	else
 		pkg_chroot_add ${FINAL_CHROOT_DIR} default-config
 	fi
+}
 create_distribution_tarball() {
 	mkdir -p ${FINAL_CHROOT_DIR}/install
 	tar -C ${FINAL_CHROOT_DIR} --exclude ./install --exclude ./pkgs -cJf ${FINAL_CHROOT_DIR}/install/${PRODUCT_NAME}.txz .
+}
 create_iso_image() {
 	LOGFILE=${BUILDER_LOGS}/isoimage.${TARGET}
 	echo ">>> Building bootable ISO image for ${TARGET}" | tee -a ${LOGFILE}
 	if [ -z "${DEFAULT_KERNEL}" ]; then
 		echo ">>> ERROR: Could not identify DEFAULT_KERNEL to install on image!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	customize_stagearea_for_image "iso"
 	install_default_kernel ${DEFAULT_KERNEL}
 	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
 	FSLABEL=$(echo ${PRODUCT_NAME} | tr '[:lower:]' '[:upper:]')
 	echo "/dev/iso9660/${FSLABEL} / cd9660 ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
 	# This check is for supporting create memstick/ova images
 	echo -n ">>> Running command: script -aq $LOGFILE makefs -t cd9660 -o bootimage=\"i386;${FINAL_CHROOT_DIR}/boot/cdboot \"-o no-emul-boot -o rockridge " | tee -a ${LOGFILE}
 	echo "-o label=${FSLABEL} -o publisher=\"${PRODUCT_NAME} project.\" $ISOPATH ${FINAL_CHROOT_DIR}" | tee -a ${LOGFILE}
 	create_distribution_tarball
 	# Remove /rescue from iso since cd9660 cannot deal with hardlinks
 	rm -rf ${FINAL_CHROOT_DIR}/rescue
 	makefs -t cd9660 -o bootimage="i386;${FINAL_CHROOT_DIR}/boot/cdboot" -o no-emul-boot -o rockridge \
 		-o label=${FSLABEL} -o publisher="${PRODUCT_NAME} project." $ISOPATH ${FINAL_CHROOT_DIR} 2>&1 >> ${LOGFILE}
 	if [ $? -ne 0 -o ! -f $ISOPATH ]; then
 		if [ -f ${ISOPATH} ]; then
 			rm -f $ISOPATH
 		fi
 		echo ">>> ERROR: Something wrong happened during ISO image creation. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	gzip -qf $ISOPATH &
-ef49f6
+	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
-f73c362
+            Renato Botelho
 	echo ">>> ISO created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
+}
 create_memstick_image() {
 	LOGFILE=${BUILDER_LOGS}/memstick.${TARGET}
 	if [ "${MEMSTICKPATH}" = "" ]; then
 		echo ">>> MEMSTICKPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
 		return
 	fi
 	if [ ! -d ${FINAL_CHROOT_DIR}/boot ]; then
 		customize_stagearea_for_image "memstick"
 		install_default_kernel ${DEFAULT_KERNEL}
 	fi
 	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
 	echo ">>> Creating memstick to ${MEMSTICKPATH}." 2>&1 | tee -a ${LOGFILE}
 	echo "/dev/ufs/${PRODUCT_NAME} / ufs ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
 	echo "kern.cam.boot_delay=10000" >> ${FINAL_CHROOT_DIR}/boot/loader.conf.local
 	create_distribution_tarball
 	makefs -B little -o label=${PRODUCT_NAME} ${MEMSTICKPATH} ${FINAL_CHROOT_DIR}
 	if [ $? -ne 0 ]; then
 		if [ -f ${MEMSTICKPATH} ]; then
 			rm -f $MEMSTICKPATH
 		fi
 		echo ">>> ERROR: Something wrong happened during MEMSTICK image creation. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	MD=$(mdconfig -a -t vnode -f $MEMSTICKPATH)
 	# Just in case
 	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
 	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}|
 	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
 	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
 	trap "-" 1 2 15 EXIT
 	mdconfig -d -u ${MD} 2>&1 | tee -a ${LOGFILE}
 	gzip -qf $MEMSTICKPATH &
-ef49f6
+	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
-f73c362
+            Renato Botelho
 	echo ">>> MEMSTICK created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
+}
 create_memstick_serial_image() {
 	LOGFILE=${BUILDER_LOGS}/memstickserial.${TARGET}
 	if [ "${MEMSTICKSERIALPATH}" = "" ]; then
 		echo ">>> MEMSTICKSERIALPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
 		return
 	fi
 	if [ ! -d ${FINAL_CHROOT_DIR}/boot ]; then
 		customize_stagearea_for_image "memstickserial"
 		install_default_kernel ${DEFAULT_KERNEL}
 	fi
 	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
 	echo "/dev/ufs/${PRODUCT_NAME} / ufs ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
 	echo "kern.cam.boot_delay=10000" >> ${FINAL_CHROOT_DIR}/boot/loader.conf.local
 	echo ">>> Creating serial memstick to ${MEMSTICKSERIALPATH}." 2>&1 | tee -a ${LOGFILE}
 	BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
 	LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
-b6
+	echo ">>> Activating serial console..." 2>&1 | tee -a ${LOGFILE}
-f73c362
+	# Activate serial console in boot.config
 	if [ -f ${BOOTCONF} ]; then
 		sed -i "" '/-D$/d' ${BOOTCONF}
 	fi
 	echo "-S115200 -D" >> ${BOOTCONF}
 	# Remove old console options if present.
 	[ -f "${LOADERCONF}" ] \
 		&& sed -i "" -Ee "/(console|boot_multicons|boot_serial)/d" ${LOADERCONF}
 	# Activate serial console+video console in loader.conf
 	echo 'boot_multicons="YES"' >>  ${LOADERCONF}
 	echo 'boot_serial="YES"' >> ${LOADERCONF}
 	echo 'console="comconsole,vidconsole"' >> ${LOADERCONF}
 	echo 'comconsole_speed="115200"' >> ${LOADERCONF}
 	create_distribution_tarball
 	makefs -B little -o label=${PRODUCT_NAME} ${MEMSTICKSERIALPATH} ${FINAL_CHROOT_DIR}
 	if [ $? -ne 0 ]; then
 		if [ -f ${MEMSTICKSERIALPATH} ]; then
 			rm -f $MEMSTICKSERIALPATH
 		fi
 		echo ">>> ERROR: Something wrong happened during MEMSTICKSERIAL image creation. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	MD=$(mdconfig -a -t vnode -f $MEMSTICKSERIALPATH)
 	# Just in case
 	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
 	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}
 	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
 	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
 	trap "-" 1 2 15 EXIT
 	mdconfig -d -u ${MD} 2>&1 >> ${LOGFILE}
 	gzip -qf $MEMSTICKSERIALPATH &
-ef49f6
+	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
-f73c362
+            Renato Botelho
 	echo ">>> MEMSTICKSERIAL created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
+}
 create_memstick_adi_image() {
 	LOGFILE=${BUILDER_LOGS}/memstickadi${TARGET}
 	if [ "${MEMSTICKADIPATH}" = "" ]; then
 		echo ">>> MEMSTICKADIPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
 		return
 	fi
 	if [ ! -d ${FINAL_CHROOT_DIR}/boot ]; then
 		customize_stagearea_for_image "memstickadi"
 		install_default_kernel ${DEFAULT_KERNEL}
 	fi
 	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
 	echo "/dev/ufs/${PRODUCT_NAME} / ufs ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
 	echo "kern.cam.boot_delay=10000" >> ${FINAL_CHROOT_DIR}/boot/loader.conf.local
 	echo ">>> Creating serial memstick to ${MEMSTICKADIPATH}." 2>&1 | tee -a ${LOGFILE}
 	BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
 	LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
-b6
+	echo ">>> Activating serial console..." 2>&1 | tee -a ${LOGFILE}
-f73c362
+	# Activate serial console in boot.config
 	if [ -f ${BOOTCONF} ]; then
 		sed -i "" '/-[Dh]$/d' ${BOOTCONF}
 	fi
 	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 'boot_serial="YES"' >> ${LOADERCONF}
 	echo 'console="comconsole"' >> ${LOADERCONF}
 	echo 'comconsole_speed="115200"' >> ${LOADERCONF}
 	echo 'comconsole_port="0x2F8"' >> ${LOADERCONF}
 	echo 'hint.uart.0.flags="0x00"' >> ${LOADERCONF}
 	echo 'hint.uart.1.flags="0x10"' >> ${LOADERCONF}
 	create_distribution_tarball
 	makefs -B little -o label=${PRODUCT_NAME} ${MEMSTICKADIPATH} ${FINAL_CHROOT_DIR}
 	if [ $? -ne 0 ]; then
 		if [ -f ${MEMSTICKADIPATH} ]; then
 			rm -f $MEMSTICKADIPATH
 		fi
 		echo ">>> ERROR: Something wrong happened during MEMSTICKADI image creation. STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	MD=$(mdconfig -a -t vnode -f $MEMSTICKADIPATH)
 	# Just in case
 	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
 	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}
 	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
 	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
 	trap "-" 1 2 15 EXIT
 	mdconfig -d -u ${MD} 2>&1 >> ${LOGFILE}
 	gzip -qf $MEMSTICKADIPATH &
-ef49f6
+	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
-f73c362
+            Renato Botelho
 	echo ">>> MEMSTICKADI created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
+}
 # Create pkg conf on desired place with desired arch/branch
 setup_pkg_repo() {
 	if [ -z "${4}" ]; then
 		return
 	fi
 	local _target="${1}"
 	local _arch="${2}"
 	local _target_arch="${3}"
 	local _branch="${4}"
 	mkdir -p $(dirname ${_target}) >/dev/null 2>&1
 	sed \
 		-e "s/%%ARCH%%/${_arch}_${_target_arch}/" \
 		-e "s/%%GIT_REPO_BRANCH_OR_TAG%%/${_branch}/g" \
 		-e "s,%%PKG_REPO_SERVER%%,${PKG_REPO_SERVER},g" \
 		-e "s/%%PRODUCT_NAME%%/${PRODUCT_NAME}/g" \
-f27203
+		${FREEBSD_SRC_DIR}/release/pkg_repos/${PRODUCT_NAME}.conf.template \
-f73c362
+		> ${_target}
+}
 # This routine ensures any ports / binaries that the builder
 # system needs are on disk and ready for execution.
 builder_setup() {
 	# If Product-builder is already installed, just leave
 	if pkg info -e -q ${PRODUCT_NAME}-builder; then
 		return
 	fi
 	if [ ! -f /usr/local/etc/pkg/repos/${PRODUCT_NAME}.conf ]; then
 		[ -d /usr/local/etc/pkg/repos ] \
 			|| mkdir -p /usr/local/etc/pkg/repos
-            d2f163a6
+		update_freebsd_sources
-f73c362
+		local _arch=$(uname -m)
 		setup_pkg_repo /usr/local/etc/pkg/repos/${PRODUCT_NAME}.conf ${_arch} ${_arch} ${PKG_REPO_CONF_BRANCH}
 	fi
 	pkg install ${PRODUCT_NAME}-builder
+}
 # Updates FreeBSD sources
 update_freebsd_sources() {
 	if [ "${1}" = "full" ]; then
 		local _full=1
 		local _clone_params=""
 	else
 		local _full=0
 		local _clone_params="--depth 1 --single-branch"
 	fi
-f27203
+	if [ ! -d "${FREEBSD_SRC_DIR}" ]; then
 		mkdir -p ${FREEBSD_SRC_DIR}
-f73c362
+	fi
-            d4c6029e
+	if [ -n "${NO_BUILDWORLD}" -a -n "${NO_BUILDKERNEL}" ]; then
-f73c362
+		echo ">>> NO_BUILDWORLD and NO_BUILDKERNEL set, skipping update of freebsd sources" | tee -a ${LOGFILE}
 		return
 	fi
 	echo -n ">>> Obtaining FreeBSD sources ${FREEBSD_BRANCH}..."
 	local _FREEBSD_BRANCH=${FREEBSD_BRANCH:-"devel"}
 	local _CLONE=1
-f27203
+	if [ -d "${FREEBSD_SRC_DIR}/.git" ]; then
 		CUR_BRANCH=$(cd ${FREEBSD_SRC_DIR} && git branch | grep '^\*' | cut -d' ' -f2)
-f73c362
+		if [ ${_full} -eq 0 -a "${CUR_BRANCH}" = "${_FREEBSD_BRANCH}" ]; then
 			_CLONE=0
-d26baf3
+			( cd ${FREEBSD_SRC_DIR} && git clean -fd; git fetch origin; git reset --hard origin/${_FREEBSD_BRANCH} ) 2>&1 | grep -C3 -i -E 'error|fatal'
-f73c362
+		else
-f27203
+			rm -rf ${FREEBSD_SRC_DIR}
-f73c362
+		fi
 	fi
 	if [ ${_CLONE} -eq 1 ]; then
-f27203
+		( git clone --branch ${_FREEBSD_BRANCH} ${_clone_params} ${FREEBSD_REPO_BASE} ${FREEBSD_SRC_DIR} ) 2>&1 | grep -C3 -i -E 'error|fatal'
-f73c362
+	fi
-f27203
+	if [ ! -d "${FREEBSD_SRC_DIR}/.git" ]; then
-f73c362
+		echo ">>> ERROR: It was not possible to clone FreeBSD src repo"
 		print_error_pfS
 	fi
 	if [ -n "${GIT_FREEBSD_COSHA1}" ]; then
-f27203
+		( cd ${FREEBSD_SRC_DIR} && git checkout ${GIT_FREEBSD_COSHA1} ) 2>&1 | grep -C3 -i -E 'error|fatal'
-f73c362
+	fi
 	echo "Done!"
+}
 pkg_chroot() {
 	local _root="${1}"
 	shift
 	if [ $# -eq 0 ]; then
 		return -1
 	fi
 	if [ -z "${_root}" -o "${_root}" = "/" -o ! -d "${_root}" ]; then
 		return -1
 	fi
 	mkdir -p \
 		${SCRATCHDIR}/pkg_cache \
 		${_root}/var/cache/pkg \
 		${_root}/dev
 	/sbin/mount -t nullfs ${SCRATCHDIR}/pkg_cache ${_root}/var/cache/pkg
 	/sbin/mount -t devfs devfs ${_root}/dev
 	cp -f /etc/resolv.conf ${_root}/etc/resolv.conf
 	touch ${BUILDER_LOGS}/install_pkg_install_ports.txt
 	script -aq ${BUILDER_LOGS}/install_pkg_install_ports.txt pkg -c ${_root} $@ >/dev/null 2>&1
 	rm -f ${_root}/etc/resolv.conf
 	/sbin/umount -f ${_root}/dev
 	/sbin/umount -f ${_root}/var/cache/pkg
+}
 pkg_chroot_add() {
 	if [ -z "${1}" -o -z "${2}" ]; then
 		return 1
 	fi
 	local _target="${1}"
 	local _pkg="$(get_pkg_name ${2}).txz"
 	if [ ! -d "${_target}" ]; then
 		echo ">>> ERROR: Target dir ${_target} not found"
 		print_error_pfS
 	fi
-            a7a00341
+	if [ ! -f ${CORE_PKG_PATH}/All/${_pkg} ]; then
-f73c362
+		echo ">>> ERROR: Package ${_pkg} not found"
 		print_error_pfS
 	fi
-            a7a00341
+	cp ${CORE_PKG_PATH}/All/${_pkg} ${_target}
-f73c362
+	pkg_chroot ${_target} add /${_pkg}
 	rm -f ${_target}/${_pkg}
+}
 pkg_bootstrap() {
 	local _root=${1:-"${STAGE_CHROOT_DIR}"}
 	setup_pkg_repo ${_root}/usr/local/etc/pkg/repos/${PRODUCT_NAME}.conf ${TARGET} ${TARGET_ARCH} ${PKG_REPO_CONF_BRANCH}
 	pkg_chroot ${_root} bootstrap -f
+}
 # This routine assists with installing various
 # freebsd ports files into the pfsenese-fs staging
 # area.
 install_pkg_install_ports() {
 	local MAIN_PKG="${1}"
 	if [ -z "${MAIN_PKG}" ]; then
 		MAIN_PKG=${PRODUCT_NAME}
 	fi
 	echo ">>> Installing pkg repository in chroot (${STAGE_CHROOT_DIR})..."
 	[ -d ${STAGE_CHROOT_DIR}/var/cache/pkg ] || \
 		mkdir -p ${STAGE_CHROOT_DIR}/var/cache/pkg
 	[ -d ${SCRATCHDIR}/pkg_cache ] || \
 		mkdir -p ${SCRATCHDIR}/pkg_cache
 	echo ">>> Installing built ports (packages) in chroot (${STAGE_CHROOT_DIR})... (starting)"
 	pkg_chroot ${STAGE_CHROOT_DIR} install ${MAIN_PKG} ${custom_package_list}
 	pkg_chroot ${STAGE_CHROOT_DIR} autoremove
 	echo ">>> Installing built ports (packages) in chroot (${STAGE_CHROOT_DIR})... (finshied)"
+}
 install_bsdinstaller() {
 	echo ">>> Installing BSDInstaller in chroot (${FINAL_CHROOT_DIR})... (starting)"
-ec1134
+	pkg_chroot ${FINAL_CHROOT_DIR} install -f bsdinstaller
-ef
+	sed -i '' -e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME}," \
 		  -e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION}," \
 		  -e "s,%%ARCH%%,${TARGET}," \
 		  ${FINAL_CHROOT_DIR}/usr/local/share/dfuibe_lua/conf/pfSense.lua \
 		  ${FINAL_CHROOT_DIR}/usr/local/share/dfuibe_lua/conf/pfSense_rescue.lua
-f73c362
+	echo ">>> Installing BSDInstaller in chroot (${FINAL_CHROOT_DIR})... (finished)"
+}
 staginareas_clean_each_run() {
 	echo -n ">>> Cleaning build directories: "
 	if [ -d "${FINAL_CHROOT_DIR}" ]; then
 		BASENAME=$(basename ${FINAL_CHROOT_DIR})
 		echo -n "$BASENAME "
 		chflags -R noschg ${FINAL_CHROOT_DIR} 2>&1 >/dev/null
-            f546e6ca
+		rm -rf ${FINAL_CHROOT_DIR}/* 2>/dev/null
-f73c362
+	fi
 	echo "Done!"
+}
 # Imported from FreeSBIE
 buildkernel() {
-            d4c6029e
+	if [ -n "${NO_BUILDKERNEL}" ]; then
-f73c362
+		echo ">>> NO_BUILDKERNEL set, skipping build" | tee -a ${LOGFILE}
 		return
 	fi
-            d4c6029e
+	if [ -z "${KERNCONF}" ]; then
-f73c362
+		echo ">>> ERROR: No kernel configuration defined probably this is not what you want! STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
-            d4c6029e
+	if [ -n "${KERNELCONF}" ]; then
-f73c362
+		export KERNCONFDIR=$(dirname ${KERNELCONF})
 		export KERNCONF=$(basename ${KERNELCONF})
 	fi
 	SRCCONFBASENAME=$(basename ${SRC_CONF})
 	echo ">>> KERNCONFDIR: ${KERNCONFDIR}"
 	echo ">>> ARCH:        ${TARGET}"
 	echo ">>> SRC_CONF:    ${SRCCONFBASENAME}"
-            d4c6029e
+	makeargs="${MAKEJ_KERNEL} SRCCONF=${SRC_CONF} __MAKE_CONF=${MAKE_CONF} TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET}"
-f73c362
+	echo ">>> Builder is running the command: script -aq $LOGFILE make -DNO_KERNELCLEAN $makeargs buildkernel KERNCONF=${KERNCONF}" | tee -a $LOGFILE
-f27203
+	(script -q $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_KERNELCLEAN $makeargs buildkernel KERNCONF=${KERNCONF} || print_error_pfS;) | egrep '^>>>'
-f73c362
+            Renato Botelho
 # Imported from FreeSBIE
 installkernel() {
-            d4c6029e
+	if [ -z "${KERNCONF}" ]; then
-f73c362
+		echo ">>> ERROR: No kernel configuration defined probably this is not what you want! STOPPING!" | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
-            d4c6029e
+	if [ -n "${KERNELCONF}" ]; then
-f73c362
+		export KERNCONFDIR=$(dirname ${KERNELCONF})
 		export KERNCONF=$(basename ${KERNELCONF})
 	fi
 	mkdir -p ${STAGE_CHROOT_DIR}/boot
-            d4c6029e
+	makeargs="${MAKEJ_KERNEL} SRCCONF=${SRC_CONF} __MAKE_CONF=${MAKE_CONF} TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET} DESTDIR=${KERNEL_DESTDIR}"
 	echo ">>> Builder is running the command: script -aq $LOGFILE make ${makeargs} installkernel KERNCONF=${KERNCONF}"  | tee -a $LOGFILE
 	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installkernel KERNCONF=${KERNCONF} || print_error_pfS;) | egrep '^>>>'
-f73c362
+	gzip -f9 $KERNEL_DESTDIR/boot/kernel/kernel
+}
 # Launch is ran first to setup a few variables that we need
 # Imported from FreeSBIE
 launch() {
 	if [ "$(id -u)" != "0" ]; then
 		echo "Sorry, this must be done as root."
 	fi
 	echo ">>> Operation $0 has started at $(date)"
+}
 finish() {
 	echo ">>> Operation $0 has ended at $(date)"
+}
-b39e1
+pkg_repo_rsync() {
 	local _repo_path="${1}"
-            d7972440
+	if [ -n "${DO_NOT_UPLOAD}" -o -z "${_repo_path}" -o ! -d "${_repo_path}" ]; then
-b39e1
+		return
 	fi
 	if [ -z "${LOGFILE}" ]; then
 		local _logfile="/dev/null"
 	else
 		local _logfile="${LOGFILE}"
 	fi
 	echo -n ">>> Sending updated repository to ${PKG_RSYNC_HOSTNAME}... " | tee -a ${_logfile}
 	if script -aq ${_logfile} rsync -ave "ssh -p ${PKG_RSYNC_SSH_PORT}" \
 		--timeout=60 --delete-delay ${_repo_path} \
 		${PKG_RSYNC_USERNAME}@${PKG_RSYNC_HOSTNAME}:${PKG_RSYNC_DESTDIR} >/dev/null 2>&1
 	then
 		echo "Done!" | tee -a ${_logfile}
 	else
 		echo "Failed!" | tee -a ${_logfile}
 		echo ">>> ERROR: An error occurred sending repo to remote hostname"
 		print_error_pfS
 	fi
+}
-f73c362
+poudriere_create_patch() {
 	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${GIT_REPO_BRANCH_OR_TAG}.patch"
 	if [ -z "${FREEBSD_PARENT_BRANCH}" ]; then
 		echo ">>> ERROR: FREEBSD_PARENT_BRANCH is not set"
 	fi
 	LOGFILE=${BUILDER_LOGS}/poudriere.log
 	# Get FreeBSD source and apply patches
 	update_freebsd_sources full
 	[ -f "${_jail_patch}" ] && \
 		rm -f "${_jail_patch}"
 	# Create a big patch with all our changes to use on jail
 	( \
-f27203
+		cd ${FREEBSD_SRC_DIR} && \
-f73c362
+		git diff $(git merge-base origin/${FREEBSD_PARENT_BRANCH} ${FREEBSD_BRANCH}) > ${_jail_patch}
 	) >/dev/null 2>&1
 	# Check if patch was created
 	if [ ! -s "${_jail_patch}" ]; then
 		echo ">>> ERROR: Patch does not exist or is empty, aborting..." | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
+}
 poudriere_possible_archs() {
 	local _arch=$(uname -m)
 	local _archs="i386.i386"
 	# IF host is amd64, we'll create both repos, and if possible armv6
 	if [ "${_arch}" = "amd64" ]; then
 		_archs="amd64.amd64 ${_archs}"
 		if [ -f /usr/local/bin/qemu-arm-static ]; then
 			# Make sure binmiscctl is ok
 			/usr/local/etc/rc.d/qemu_user_static forcestart >/dev/null 2>&1
 			if binmiscctl lookup armv6 >/dev/null 2>&1; then
 				_archs="${_archs} arm.armv6"
 			fi
 		fi
 	fi
-            fb192227
+	if [ -n "${ARCH_LIST}" ]; then
 		local _found=0
-            4010811b
+		for _desired_arch in ${ARCH_LIST}; do
-            fb192227
+			_found=0
-            4010811b
+			for _possible_arch in ${_archs}; do
-            fb192227
+				if [ "${_desired_arch}" = "${_possible_arch}" ]; then
 					_found=1
 					break
 				fi
 			done
 			if [ ${_found} -eq 0 ]; then
 				echo ">>> ERROR: Impossible to build for arch: ${_desired_arch}"
 				print_error_pfS
 			fi
 		done
 		_archs="${ARCH_LIST}"
 	fi
-f73c362
+	echo ${_archs}
+}
 poudriere_jail_name() {
 	local _jail_arch="${1}"
 	if [ -z "${_jail_arch}" ]; then
 		return 1
 	fi
 	# Poudriere doesn't like periods in jail names
 	_jail_arch=$(echo "${_jail_arch}" | tr '.' '_')
 	echo "${PRODUCT_NAME}_${GIT_REPO_BRANCH_OR_TAG}_${_jail_arch}"
+}
 poudriere_create_ports_tree() {
 	LOGFILE=${BUILDER_LOGS}/poudriere.log
 	if ! poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
 		local _branch=""
 		if [ -z "${POUDRIERE_PORTS_GIT_URL}" ]; then
 			echo ">>> ERROR: POUDRIERE_PORTS_GIT_URL is not defined"
 			print_error_pfS
 		fi
 		if [ -n "${POUDRIERE_PORTS_GIT_BRANCH}" ]; then
 			_branch="-B ${POUDRIERE_PORTS_GIT_BRANCH}"
 		fi
 		echo -n ">>> Creating poudriere ports tree, it may take some time... " | tee -a ${LOGFILE}
 		if ! script -aq ${LOGFILE} poudriere ports -c -p "${POUDRIERE_PORTS_NAME}" -m git ${_branch} >/dev/null 2>&1; then
 			echo "" | tee -a ${LOGFILE}
 			echo ">>> ERROR: Error creating poudriere ports tree, aborting..." | tee -a ${LOGFILE}
 			print_error_pfS
 		fi
 		echo "Done!" | tee -a ${LOGFILE}
 	fi
+}
 poudriere_init() {
 	local _error=0
 	local _archs=$(poudriere_possible_archs)
 	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${GIT_REPO_BRANCH_OR_TAG}.patch"
 	LOGFILE=${BUILDER_LOGS}/poudriere.log
 	# Sanity checks
 	if [ -z "${ZFS_TANK}" ]; then
 		echo ">>> ERROR: \$ZFS_TANK is empty" | tee -a ${LOGFILE}
 		error=1
 	fi
 	if [ -z "${ZFS_ROOT}" ]; then
 		echo ">>> ERROR: \$ZFS_ROOT is empty" | tee -a ${LOGFILE}
 		error=1
 	fi
 	if [ -z "${POUDRIERE_PORTS_NAME}" ]; then
 		echo ">>> ERROR: \$POUDRIERE_PORTS_NAME is empty" | tee -a ${LOGFILE}
 		error=1
 	fi
 	if [ ${_error} -eq 1 ]; then
 		print_error_pfS
 	fi
 	# Check if zpool exists
 	if ! zpool list ${ZFS_TANK} >/dev/null 2>&1; then
 		echo ">>> ERROR: ZFS tank ${ZFS_TANK} not found, please create it and try again..." | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	# Check if zfs rootfs exists
 	if ! zfs list ${ZFS_TANK}${ZFS_ROOT} >/dev/null 2>&1; then
 		echo ">>> ERROR: ZFS filesystem ${ZFS_TANK}${ZFS_ROOT} not found, please create it and try again..." | tee -a ${LOGFILE}
 		print_error_pfS
 	fi
 	# Make sure poudriere is installed
 	if ! pkg info --quiet poudriere; then
 		echo ">>> Installing poudriere..." | tee -a ${LOGFILE}
 		if ! pkg install poudriere >/dev/null 2>&1; then
 			echo ">>> ERROR: poudriere was not installed, aborting..." | tee -a ${LOGFILE}
 			print_error_pfS
 		fi
 	fi
 	# Create poudriere.conf
 	if [ -z "${POUDRIERE_PORTS_GIT_URL}" ]; then
 		echo ">>> ERROR: POUDRIERE_PORTS_GIT_URL is not defined"
 		print_error_pfS
 	fi
 	echo ">>> Creating poudriere.conf" | tee -a ${LOGFILE}
 	cat <<EOF >/usr/local/etc/poudriere.conf
 ZPOOL=${ZFS_TANK}
 ZROOTFS=${ZFS_ROOT}
 RESOLV_CONF=/etc/resolv.conf
 BASEFS=/usr/local/poudriere
 USE_PORTLINT=no
 USE_TMPFS=yes
 NOLINUX=yes
 DISTFILES_CACHE=/usr/ports/distfiles
 CHECK_CHANGED_OPTIONS=yes
 CHECK_CHANGED_DEPS=yes
 ATOMIC_PACKAGE_REPOSITORY=yes
 COMMIT_PACKAGES_ON_FAILURE=no
 GIT_URL="${POUDRIERE_PORTS_GIT_URL}"
 EOF
 	# Remove old jails
 	for jail_arch in ${_archs}; do
 		jail_name=$(poudriere_jail_name ${jail_arch})
 		if poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
 			echo ">>> Poudriere jail ${jail_name} already exists, deleting it..." | tee -a ${LOGFILE}
 			poudriere jail -d -j "${jail_name}" >/dev/null 2>&1
 		fi
 	done
 	# Remove old ports tree
 	if poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
 		echo ">>> Poudriere ports tree ${POUDRIERE_PORTS_NAME} already exists, deleting it..." | tee -a ${LOGFILE}
 		poudriere ports -d -p "${POUDRIERE_PORTS_NAME}"
 	fi
 	poudriere_create_patch
 	local native_xtools=""
 	# Now we are ready to create jails
 	for jail_arch in ${_archs}; do
 		jail_name=$(poudriere_jail_name ${jail_arch})
 		if [ "${jail_arch}" = "arm.armv6" ]; then
 			native_xtools="-x"
 		else
 			native_xtools=""
 		fi
 		echo -n ">>> Creating jail ${jail_name}, it may take some time... " | tee -a ${LOGFILE}
 		# XXX: Change -m to git when it's available in poudriere
 		if ! script -aq ${LOGFILE} poudriere jail -c -j "${jail_name}" -v ${FREEBSD_PARENT_BRANCH} \
 				-a ${jail_arch} -m svn -P ${_jail_patch} ${native_xtools} >/dev/null 2>&1; then
 			echo "" | tee -a ${LOGFILE}
 			echo ">>> ERROR: Error creating jail ${jail_name}, aborting..." | tee -a ${LOGFILE}
 			print_error_pfS
 		fi
 		echo "Done!" | tee -a ${LOGFILE}
 	done
 	poudriere_create_ports_tree
 	echo ">>> Poudriere is now configured!" | tee -a ${LOGFILE}
+}
 poudriere_update_jails() {
 	local _archs=$(poudriere_possible_archs)
 	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${GIT_REPO_BRANCH_OR_TAG}.patch"
 	LOGFILE=${BUILDER_LOGS}/poudriere.log
 	poudriere_create_patch
 	local native_xtools=""
 	for jail_arch in ${_archs}; do
 		jail_name=$(poudriere_jail_name ${jail_arch})
 		if ! poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
 			echo ">>> Poudriere jail ${jail_name} not found, skipping..." | tee -a ${LOGFILE}
 			continue
 		fi
 		if [ "${jail_arch}" = "arm.armv6" ]; then
 			native_xtools="-x"
 		else
 			native_xtools=""
 		fi
 		echo -n ">>> Updating jail ${jail_name}, it may take some time... " | tee -a ${LOGFILE}
 		if ! script -aq ${LOGFILE} poudriere jail -u -j "${jail_name}" -P ${_jail_patch} ${native_xtools} >/dev/null 2>&1; then
 			echo "" | tee -a ${LOGFILE}
 			echo ">>> ERROR: Error updating jail ${jail_name}, aborting..." | tee -a ${LOGFILE}
 			print_error_pfS
 		fi
 		echo "Done!" | tee -a ${LOGFILE}
 	done
+}
 poudriere_update_ports() {
 	LOGFILE=${BUILDER_LOGS}/poudriere.log
 	# Create ports tree if necessary
 	if ! poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
 		poudriere_create_ports_tree
 	else
-            d94da298
+		echo -n ">>> Reseting local changes on ports tree ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
 		script -aq ${LOGFILE} git -C "/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}" reset --hard >/dev/null 2>&1
-d26baf3
+		script -aq ${LOGFILE} git -C "/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}" clean -fd >/dev/null 2>&1
-            d94da298
+		echo "Done!" | tee -a ${LOGFILE}
-f73c362
+		echo -n ">>> Updating ports tree ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
 		script -aq ${LOGFILE} poudriere ports -u -p "${POUDRIERE_PORTS_NAME}" >/dev/null 2>&1
 		echo "Done!" | tee -a ${LOGFILE}
 	fi
+}
 poudriere_bulk() {
 	local _archs=$(poudriere_possible_archs)
 	LOGFILE=${BUILDER_LOGS}/poudriere.log
-            e295b113
+	if [ -z "${DO_NOT_UPLOAD}" -a -z "${PKG_RSYNC_HOSTNAME}" ]; then
 		echo ">>> ERROR: PKG_RSYNC_HOSTNAME is not set"
 		print_error_pfS
 	fi
-f73c362
+	poudriere_create_ports_tree
 	[ -d /usr/local/etc/poudriere.d ] || \
 		mkdir -p /usr/local/etc/poudriere.d
-            edef37f6
+	if [ -f "${BUILDER_TOOLS}/conf/pfPorts/make.conf" ]; then
-ce2a7f3
+		cp -f "${BUILDER_TOOLS}/conf/pfPorts/make.conf" /usr/local/etc/poudriere.d/${POUDRIERE_PORTS_NAME}-make.conf
-f73c362
+	fi
-            d94da298
+	# Change version of pfSense meta ports for snapshots
 	if [ -z "${_IS_RELEASE}" ]; then
 		for meta_pkg in ${PRODUCT_NAME} ${PRODUCT_NAME}-vmware; do
 			local _meta_pkg_version="$(echo "${PRODUCT_VERSION}" | sed 's,DEVELOPMENT,ALPHA,')-${DATESTRING}"
 			sed -i '' -e "/^DISTVERSION/ s,^.*,DISTVERSION=	${_meta_pkg_version}," \
 				/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}/security/${meta_pkg}/Makefile
 		done
 	fi
-f73c362
+	for jail_arch in ${_archs}; do
 		jail_name=$(poudriere_jail_name ${jail_arch})
 		if ! poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
 			echo ">>> Poudriere jail ${jail_name} not found, skipping..." | tee -a ${LOGFILE}
 			continue
 		fi
 		if [ -f "${POUDRIERE_BULK}.${jail_arch}" ]; then
 			_ref_bulk="${POUDRIERE_BULK}.${jail_arch}"
 		else
 			_ref_bulk="${POUDRIERE_BULK}"
 		fi
 		_bulk=${SCRATCHDIR}/poudriere_bulk.${GIT_REPO_BRANCH_OR_TAG}
 		sed -e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" ${_ref_bulk} > ${_bulk}
 		if ! poudriere bulk -f ${_bulk} -j ${jail_name} -p ${POUDRIERE_PORTS_NAME}; then
 			echo ">>> ERROR: Something went wrong..."
 			print_error_pfS
 		fi
 		echo ">>> Cleaning up old packages from repo..."
 		if ! poudriere pkgclean -f ${_bulk} -j ${jail_name} -p ${POUDRIERE_PORTS_NAME} -y; then
 			echo ">>> ERROR: Something went wrong..."
 			print_error_pfS
 		fi
 		# ./ is intentional, it's a rsync trick to make it chdir to directory before send it
-b39e1
+		pkg_repo_rsync "/usr/local/poudriere/data/packages/./${jail_name}-${POUDRIERE_PORTS_NAME}"
-f73c362
+	done
+}
-            ab943fc9
+            Renato Botelho
 # This routine is called to write out to stdout
 # a string. The string is appended to $SNAPSHOTSLOGFILE
 # and we scp the log file to the builder host if
 # needed for the real time logging functions.
 snapshots_update_status() {
 	if [ -z "${SNAPSHOTS}" -o -z "$1" ]; then
 		return
 	fi
 	echo $1
 	echo "`date` -|- $1" >> $SNAPSHOTSLOGFILE
 	if [ -z "${DO_NOT_UPLOAD}" -a -n "${RSYNCIP}" ]; then
 		LU=`cat $SNAPSHOTSLASTUPDATE`
 		CT=`date "+%H%M%S"`
 		# Only update every minute
 		if [ "$LU" != "$CT" ]; then
 			ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCLOGS}"
-ef
+			scp -q $SNAPSHOTSLOGFILE ${RSYNCUSER}@${RSYNCIP}:${RSYNCLOGS}/build.log
-            ab943fc9
+			date "+%H%M%S" > $SNAPSHOTSLASTUPDATE
 		fi
 	fi
+}
 # Copy the current log file to $filename.old on
 # the snapshot www server (real time logs)
 snapshots_rotate_logfile() {
-            ce96c131
+	if [ -z "${DO_NOT_UPLOAD}" -a -n "${RSYNCIP}" ]; then
-ef
+		scp -q $SNAPSHOTSLOGFILE ${RSYNCUSER}@${RSYNCIP}:${RSYNCLOGS}/build.log.old
-            ab943fc9
+	fi
 	# Cleanup log file
-            ce96c131
+	rm -f $SNAPSHOTSLOGFILE;    touch $SNAPSHOTSLOGFILE
 	rm -f $SNAPSHOTSLASTUPDATE; touch $SNAPSHOTSLASTUPDATE
-            ab943fc9
+            Renato Botelho
-            e28305f4
+snapshots_create_latest_symlink() {
 	local _image="${1}"
 	if [ -z "${_image}" ]; then
 		return
 	fi
 	if [ -z "${TIMESTAMP_SUFFIX}" ]; then
 		return
 	fi
 	if [ -f "${_image}.gz" ]; then
 		local _image_fixed="${_image}.gz"
-            a4a336b2
+	elif [ -f "${_image}" ]; then
-            e28305f4
+		local _image_fixed=${_image}
-            a4a336b2
+	else
 		return
-            e28305f4
+	fi
 	local _symlink=$(echo ${_image_fixed} | sed "s,${TIMESTAMP_SUFFIX},-latest,")
 	ln -sf $(basename ${_image_fixed}) ${_symlink}
 	ln -sf $(basename ${_image}).sha256 ${_symlink}.sha256
+}
-            ab943fc9
+snapshots_copy_to_staging_nanobsd() {
 	for NANOTYPE in nanobsd nanobsd-vga; do
 		for FILESIZE in ${1}; do
 			FILENAMEFULL="${PRODUCT_NAME}-${PRODUCT_VERSION}-${FILESIZE}-${TARGET}-${NANOTYPE}${TIMESTAMP_SUFFIX}.img.gz"
 			FILENAMEUPGRADE="${PRODUCT_NAME}-${PRODUCT_VERSION}-${FILESIZE}-${TARGET}-${NANOTYPE}-upgrade${TIMESTAMP_SUFFIX}.img.gz"
 			mkdir -p $STAGINGAREA/nanobsd
 			mkdir -p $STAGINGAREA/nanobsdupdates
-d811f63
+			cp -l $IMAGES_FINAL_DIR/$FILENAMEFULL $STAGINGAREA/nanobsd/ 2>/dev/null
 			cp -l $IMAGES_FINAL_DIR/$FILENAMEUPGRADE $STAGINGAREA/nanobsdupdates 2>/dev/null
-            ab943fc9
+            Renato Botelho
 			if [ -f $STAGINGAREA/nanobsd/$FILENAMEFULL ]; then
 				sha256 $STAGINGAREA/nanobsd/$FILENAMEFULL > $STAGINGAREA/nanobsd/$FILENAMEFULL.sha256 2>/dev/null
 			fi
 			if [ -f $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE ]; then
 				sha256 $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE > $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE.sha256 2>/dev/null
 			fi
 			# Copy NanoBSD auto update:
 			if [ -f $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE ]; then
-d811f63
+				cp -l $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz 2>/dev/null
-            ab943fc9
+				sha256 $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz > $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz.sha256 2>/dev/null
 				# NOTE: Updates need a file with output similar to date output
 				# Use the file generated at start of snapshots_dobuilds() to be consistent on times
 				cp $BUILTDATESTRINGFILE $STAGINGAREA/version-${NANOTYPE}-$FILESIZE
 			fi
 		done
 	done
+}
 snapshots_copy_to_staging_iso_updates() {
-fd1
+	local _img=""
-            ab943fc9
+            Renato Botelho
-fd1
+	for _img in ${ISOPATH} ${MEMSTICKPATH} ${MEMSTICKSERIALPATH} ${UPDATES_TARBALL_FILENAME}; do
 		if [ ! -f "${_img}.gz" ]; then
 			continue
 		fi
 		sha256 ${_img}.gz > ${_img}.sha256
-d811f63
+		cp -l ${_img}* $STAGINGAREA/ 2>/dev/null
-fd1
+		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${_img})
 	done
 	if [ "${TARGET}" = "amd64" -a -f "${MEMSTICKADIPATH}.gz" ]; then
-            d137967b
+		sha256 ${MEMSTICKADIPATH}.gz > ${MEMSTICKADIPATH}.sha256
-d811f63
+		cp -l ${MEMSTICKADIPATH}* $STAGINGAREA/ 2>/dev/null
-            e28305f4
+		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${MEMSTICKADIPATH})
-            d137967b
+	fi
-            ab943fc9
+            Renato Botelho
 	# NOTE: Updates need a file with output similar to date output
 	# Use the file generated at start of snapshots_dobuilds() to be consistent on times
 	if [ -z "${_IS_RELEASE}" ]; then
 		cp $BUILTDATESTRINGFILE $STAGINGAREA/version 2>/dev/null
 	fi
+}
 snapshots_scp_files() {
-            d4c6029e
+	if [ -z "${RSYNC_COPY_ARGUMENTS}" ]; then
-            ab943fc9
+		RSYNC_COPY_ARGUMENTS="-ave ssh --timeout=60 --bwlimit=${RSYNCKBYTELIMIT}" #--bwlimit=50
 	fi
-            48396120
+            Renato Botelho
 	snapshots_update_status ">>> Copying core pkg repo to ${PKG_RSYNC_HOSTNAME}"
 	# Add ./ before last directory, it's rsync trick to make it chdir to parent directory before send
 	pkg_repo_rsync $(echo "${CORE_PKG_PATH}" | sed -E 's,/$,,; s,/([^/]*)$,/./\1,')
 	snapshots_update_status ">>> Finished copying core pkg repo"
-            ab943fc9
+	snapshots_update_status ">>> Copying files to ${RSYNCIP}"
 	# Ensure directory(s) are available
 	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/livecd_installer"
 	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/updates"
 	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/nanobsd"
 	if [ -d $STAGINGAREA/virtualization ]; then
 		ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/virtualization"
 	fi
 	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/.updaters"
 	# ensure permissions are correct for r+w
 	ssh ${RSYNCUSER}@${RSYNCIP} "chmod -R ug+rw ${RSYNCPATH}/."
 	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}-*iso* \
 		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/livecd_installer/
 	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}-memstick* \
 		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/livecd_installer/
 	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}-*Update* \
 		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/updates/
 	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/nanobsd/* \
 		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/nanobsd/
 	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/nanobsdupdates/* \
 		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/updates/
 	if [ -d $STAGINGAREA/virtualization ]; then
 		rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/virtualization/* \
 			${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/virtualization/
 	fi
 	# Rather than copy these twice, use ln to link to the latest one.
 	ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest.tgz"
 	ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest.tgz.sha256"
-e4f6768
+	LATESTFILENAME=$(basename ${UPDATES_TARBALL_FILENAME})
-            ab943fc9
+	ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${LATESTFILENAME} \
 		${RSYNCPATH}/.updaters/latest.tgz"
 	ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${LATESTFILENAME}.sha256 \
 		${RSYNCPATH}/.updaters/latest.tgz.sha256"
-ba34
+	for i in ${FLASH_SIZE}
-            ab943fc9
+	do
 		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz"
 		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz.sha256"
 		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz"
 		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz.sha256"
 		FILENAMEUPGRADE="${PRODUCT_NAME}-${PRODUCT_VERSION}-${i}-${TARGET}-nanobsd-upgrade${TIMESTAMP_SUFFIX}.img.gz"
 		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE} \
 			${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz"
 		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE}.sha256 \
 			${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz.sha256"
 		FILENAMEUPGRADE="${PRODUCT_NAME}-${PRODUCT_VERSION}-${i}-${TARGET}-nanobsd-vga-upgrade${TIMESTAMP_SUFFIX}.img.gz"
 		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE} \
 			${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz"
 		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE}.sha256 \
 			${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz.sha256"
 	done
 	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/version* \
 		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/.updaters
 	snapshots_update_status ">>> Finished copying files."
+}

Project

General

Profile

pfSense