pfSense

  -i             -- Display information about this PBI

  -l             -- Display LICENSE text

  -o outdir      -- Extract to target directory 

  -v             -- Enable verbose output

  --checkscript  -- Display any custom install / removal scripts

  --licagree     -- Agree to LICENSE terms for installation

  --genpatch   -- Generate patch files (*.pbp) from archived PBIs to current

  --keep <num> -- Keep <num> old versions in archive folder for each built PBI

  --prune      -- Remove files from 'outdir' that no longer have a module

  --sign key   -- Sign the PBI(s) with specified openssl key

EOF

  -p prefix    -- Specify alternate PBI Compile PREFIX

  --delbuild   -- Delete existing build dirs if they exist

  --mkdebug    -- Drop to debug shell if port make fails

  --no-prune   -- Do not prune non REQUIREDBY ports

  --sign key   -- Sign the PBI with specified openssl key

EOF

usage: `basename $0` [options] oldpbi newpbi

Options:

EOF

        exit_trap

                case "$1" in

                -v)     PBI_VERBOSE="YES" 

                        ;;

		esac

		shift

	done

            --sign)     if [ $# -eq 1 ]; then usage_makepatch_pbi; fi

                        shift; PBI_SSLPRIVKEY="$1"

                        ;;

                 *)	if [ $# -gt 2  ]; then usage_makepatch_pbi; fi

                       	PBI_OLDFILENAME="$1"

			shift

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

			exit_err "No such file ${PBI_IT_ADDINDEX}"

		     fi

			expr ${PBI_IT_ADDKEEP} + 1 >/dev/null 2>/dev/null

			if [ "$?" != "0" ] ; then

				exit_err "-k option must be a integer!"

        done

	# Get / check the repoid

		ls ${PBI_DBREPODIR}/${PBI_BROWSE_RID}.* >/dev/null 2>/dev/null

		if [ "$?" != "0" ] ; then

			exit_err "The specified repoid ${PBI_BROWSE_RID} does not exist!"

	if [ "${PBI_LISTREPO_DOWN}" = "YES" -a -z "${PBI_LISTREPO_ID}" ]; then

		exit_err "Missing Repo ID to move down in priority."

	fi

		exit_err "Missing Repo ID to change a specific mirror URL."

	fi

		ls ${PBI_DBREPODIR}/${PBI_LISTREPO_ID}.* >/dev/null 2>/dev/null

		if [ "$?" != "0" ] ; then

			exit_err "The specified repoid ${PBI_LISTREPO_ID} does not exist!"

        if [ -z "${PBI_MKREPO_URL}" ]; then usage_makerepo_pbi ; fi

        if [ -z "${PBI_MKREPO_OUTDIR}" ]; then PBI_MKREPO_OUTDIR="${HOME}"; fi

        if [ ! -f "${PBI_MKREPO_KEY}" ]; then exit_err "The key file ${PBI_MKREPO_KEY} does not exist." ; fi

}

                # If extracting to a alt-outdir, set it now

                PBI_PROGDIRPATH="`pwd`/${PBI_PROGDIRNAME}"

                        PBI_PROGDIRPATH="${PBI_ALTEXTRACT_DIR}/${PBI_PROGDIRNAME}"

                fi      

        else

                        ;;

                -r)     PBI_REMOTEFETCH="YES" 

			;;

                -v)     PBI_VERBOSE="YES" 

                        ;;

           --rArch)     

		# If extracting to a alt-outdir, set it now

		PBI_PROGDIRPATH="`pwd`/${PBI_PROGDIRNAME}"

			PBI_PROGDIRPATH="${PBI_ALTEXTRACT_DIR}/${PBI_PROGDIRNAME}"

		fi

	else

        while [ $# -gt 0 ]; do

                case "$1" in

                -c)     if [ $# -eq 1 ]; then usage_autob_pbi; fi

                        shift

                        get_abspath "$1"

                        PBI_AB_CONFDIR="$_ABSPATH"

        --genpatch)     PBI_AB_GENPATCH="YES" 

                        ;;

            --keep)     if [ $# -eq 1 ]; then usage_autob_pbi; fi

                        shift; PBI_AB_ARCHIVENUM="$1"

			expr $PBI_AB_ARCHIVENUM + 1 >/dev/null 2>/dev/null

                        ;;

           --prune)     PBI_AB_PRUNE="YES" 

                        ;;

            --sign)     if [ $# -eq 1 ]; then usage_autob_pbi; fi

                        shift; PBI_AB_SSLPRIVKEY="$1"

                        ;;

        done

	# Make sure this port exists

		exit_err "No port (${PORTSDIR}/${PBI_MAKEPORT})"

	fi

	# Load the name / version from specified port

		get_pbi_progversion

		get_pbi_progname

        fi

# Override any pbi.conf values with passed command-line values

parse_cmdline_overrides() {

}

# Parse the command line

                        ;;

                -c)

                        if [ $# -eq 1 ]; then usage_make_pbi; fi

                        shift

			get_abspath "$1"

			PBI_CONFDIR="$_ABSPATH"

                        ;;

                --mkdebug)	MKDEBUG="YES"

                        ;;

                -o)	if [ $# -eq 1 ]; then usage_make_pbi; fi

                        shift

			get_abspath "$1"

			PBI_CREATE_OUTDIR="$_ABSPATH"

                        ;;

                -p)	if [ $# -eq 1 ]; then usage_make_pbi; fi

                        shift; PBI_MAKEPREFIX="$1"

                        ;;

			shift

			get_abspath "$1"

			PBI_SSLPRIVKEY="$_ABSPATH"

	# Override some locations if working in chroot environment

	if [ "`basename $0`" = "pbi_makeport_chroot" ] ; then 

	fi

	# Make sure this port exists

	if [ ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ] ; then

		exit_err "No port (${PORTSDIR}/${PBI_MAKEPORT})"

	fi

	# Make sure we have a valid PBI_CONFDIR

		exit_err "Invalid confdir (${PBI_CONFDIR})"

	fi

	# Source the config file

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

                usage_make_pbi

     --enable-auto)	PBI_UPENABLEAUTO="YES" ;; 

      --update-all)	PBI_UPDATEAPP="ALL" ;; 

                 *)     if [ $# -gt 1 ]; then usage_update_pbi; fi

			if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then

                                exit_err "can't find installed pbi (${1})"

                        fi

                shift

        done

                usage_update_pbi

        fi

	# Make sure we aren't trying to enable auto-updating for ALL

                usage_update_pbi

        fi

                usage_update_pbi

        fi

	chmod 664 ${PBI_DBDIRTYFILE}

}

get_abspath() {

	D=`dirname "$1"`

	if [ "$D" = "/" ] ; then

		_ABSPATH="/$B"

	else

	FBSDMAJOR=`uname -r | cut -c 1`

        PROGBASE="/usr/local" 

	SYS_LOCALBASE="/usr/local"

	if [ `id -u` = "0" ] ; then 

		PBI_HASHDIR="${PBI_APPDIR}/.hashdir"

	else

	PBI_ETCCONF="${SYS_LOCALBASE}/etc/pbi.conf"

	PCBSD_ETCCONF="${SYS_LOCALBASE}/etc/pcbsd.conf"

	PBI_DEFAULT_ICON="${PROGBASE}/share/pbi-manager/icons/default.png"

	PBI_PATCH_ICON="${PROGBASE}/share/pbi-manager/icons/patch.png"

	PBI_LDCONFIGFILE="${PROGBASE}/etc/ldpbiconfig"

	PBI_LDCONFIGRC="${PROGBASE}/etc/rc.d/ldpbiconfig"

	PBI_APPDESK_DIR=".${MOD_XDGDESK_DIR}"

	PBI_APPMENU_DIR=".${MOD_XDGMENU_DIR}"

	PBI_APPMIME_DIR=".${MOD_XDGMIME_DIR}"

	PBI_DESKADD="NO"

	PBI_MENUADD="NO"

	PBI_MIMEADD="NO"

	PBI_PATHADD="NO"

	PBI_DESKDEL="NO"

	PBI_MENUDEL="NO"

	PBI_MIMEDEL="NO"

	PBI_PATHDEL="NO"

	PBI_PATCHVERSION=""

	PBI_PATCHTARGET=""

	PBI_REMOTEFETCH=""

	PBI_RESOURCE_DIR="resources"

	PBI_SS_ICON="__PBI_ICON__"

	PBI_SS_ARCHIVE="__PBI_ARCHIVE__"

        # User overridable variables

	MKDELBUILD=""

	MKDEBUG=""

	PBI_AB_ARCHIVENUM=""

	PBI_AB_CONFDIR=""

	PBI_AB_GENPATCH="NO"

	PBI_AB_OUTDIR=""

	PBI_AB_SSLPRIVKEY=""

	PBI_AB_PRUNE=""

	PBI_BUILDONLY="NO"

	PBI_CAUTHOR=""

	PBI_CBACKUP=""

		rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null

		chflags -R noschg "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null

		rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null

	fi

	if [ -z "$PBI_CHROOTDIR" ] ; then return ; fi

	chroot_make_cleanup

load_pbi_conffile() {

  	if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi

  	if [ -e "${PBI_CONFDIR}/${PBI_CONFFILE}" ] ; then

		. ${PBI_CONFDIR}/${PBI_CONFFILE}

	fi

}

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

		load_pbi_conffile

	else

		return 0

	fi

		PORTVER="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V DISTVERSION 2>/dev/null`"

  		# Check if we have a portrevision to use in version number

  		PORTREV=""

  		PORTREV="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V PORTREVISION 2>/dev/null`"

 		then

   			PORTVER="${PORTVER}_${PORTREV}"

		fi

		        echo "make -C ${PORTSDIR}/${PBI_MAKEPORT} -V DISTVERSION"

		fi

	else

		exit_err "Failed to locate PBI_PROGVERSION"

	fi

	# If we have a REVISION, use it as well

		PBI_PROGVERSION="${PBI_PROGVERSION}_${PBI_PROGREVISION}"

	fi

}

		return 0

	fi

		PBI_PROGNAME="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V PORTNAME`"

	else

		exit_err "Failed to locate PBI_PROGNAME"

	tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"

	ARCH="`uname -m`"

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

		PBI_PROGDIRNAME="${tmp}-${ARCH}"

	fi

		echo "Cleaning up patch data..."

	fi

	 	rm -rf "${_pbiNewDir}" >/dev/null 2>/dev/null

	 	chflags -R noschg "${_pbiNewDir}" >/dev/null 2>/dev/null

	 	rm -rf "${_pbiNewDir}" >/dev/null 2>/dev/null

	fi

	 	rm -rf "${_pbiOldDir}" >/dev/null 2>/dev/null

	 	chflags -R noschg "${_pbiOldDir}" >/dev/null 2>/dev/null

	 	rm -rf "${_pbiOldDir}" >/dev/null 2>/dev/null

	fi

	 	rm -rf "${_pbiPatchDir}" >/dev/null 2>/dev/null

	 	chflags -R noschg "${_pbiPatchDir}" >/dev/null 2>/dev/null

	 	rm -rf "${_pbiPatchDir}" >/dev/null 2>/dev/null

# Check if we need to delete a remotely dl'd file

clean_remote_dl() {

	# If this was a remote fetch, remove dl'd file

		rm "$PBI_FILENAME" >/dev/null 2>/dev/null

	fi

}

	echo "NO_IGNORE=yes" >> ${MAKE_CONF}

	echo "PACKAGE_BUILDING=yes" >> ${MAKE_CONF}

	fi

		# Check if we have custom make opts

		echo "${PBI_MAKEOPTS}" >> ${MAKE_CONF}

	fi

	# Make sure ldconfig is primed

	/etc/rc.d/ldconfig start

	PATH="${PATH}:/usr/local/bin:/usr/local/sbin:${LOCALBASE}/bin:${LOCALBASE}/sbin"

	export PATH

	mv "${PBI_IT_ADDINDEX}" "${PBI_TMPDIR}/.indextmp"

	local _date=`date '+%s'`

	local _sha256=`sha256 -q ${PBI_FILENAME}`

	sort ${PBI_TMPDIR}/.indextmp > "${PBI_IT_ADDINDEX}"

}

	_rArch=`uname -m`

	# Figure out which type of display we are doing

		echo "Using RepoID: $PBI_BROWSE_RID"

		echo "Listing all available PBIs"

		grep -i -e "^App=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$

		echo "Using RepoID: $PBI_BROWSE_RID"

		echo "Available PBIs for Category: $PBI_BROWSE_CAT"

		grep -i -e "^App=" -i -e ";${PBI_BROWSE_CAT};" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$

		echo "Using RepoID: $PBI_BROWSE_RID"

		echo "Searching for: $PBI_BROWSE_SEARCH"

		grep -i -e "^App=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$

		aName=`echo $line | cut -d ';' -f 1 2>/dev/null`

		# Make sure this is from the correct category

			_cCheck=`echo $catCheck | tr '[:lower:]' '[:upper:]'`

			_cCheck2=`echo $PBI_BROWSE_CAT | tr '[:lower:]' '[:upper:]'`

			if [ "$_cCheck" != "$_cCheck2" ]; then 

		# Check for a translation to the description

		get_meta_trans "App" "$cName" "${PBI_BROWSE_METAFILE}"

			aDesc="$MTRANS"

		fi

		# Search the description / keywords

			echo "$aName,$aDesc,$aKeywords,$MTRANS" | grep -i "$PBI_BROWSE_SEARCH" >/dev/null 2>/dev/null

			if [ "$?" != "0" ]; then continue ; fi

		fi

		echo "------------------------------------"

		echo "Application: $aName"

		echo "Version: $PBI_UPNVER"

			echo "Category: $catCheck"

		fi

		echo "Created: `echo $PBI_UPMDATE`"

		# Check for a translation to the description

		get_meta_trans "Cat" "$cName" "${PBI_BROWSE_METAFILE}"

			cDesc="$MTRANS"

		fi

	for l in $lCheck

	do

		catTrans=`grep "^${tag}\[$l\]=${name}" ${metaFile}`	

			MTRANS=`echo $catTrans | cut -d ";" -f 2`

			return

		fi

	if [ -z "$PBI_LISTREPO_ID" ] ; then

		list_all_pbi_repo

	else

			require_root

			move_repo_up "${PBI_LISTREPO_ID}" 

			list_all_pbi_repo

			require_root

			move_repo_down "${PBI_LISTREPO_ID}"

			list_all_pbi_repo

			require_root

			change_repo_mirror "${PBI_LISTREPO_ID}"

			listrepo_details "${PBI_LISTREPO_ID}"

        newDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHVERSION}-${PBI_APPARCH}"

	mv "$oldDir" "$newDir"

	rm ${newDir}/*.sha1 >/dev/null 2>/dev/null

	pbi_add_register_app	

	# Cleanup after our selves

	if [ -d "$PBI_EXTRACTDIR" ] ; then

		echo "Cleaning up..."

	if [ "$_pFbsdVer" != "$_sFbsdVer" ] ; then

     		exit_err "\"${_pbilow}\" patch is for FreeBSD ${_sFbsdVer}.X only!"

	fi

}

# Start the pbi_add process

	echo "-----------------------------------------------------"

	echo "Name: ${PBI_PROGNAME}"

		echo "PatchTarget: $PBI_PATCHTARGET"

	fi

		echo "InstalledBy: $PBI_INSTALLED_BY"

	fi

		*) echo "Signature: <Unknown>" ;;

	esac

		local _rDesc="`cat ${PBI_DBREPODIR}/*.${PBI_REPO} | grep "Desc:" | sed 's|Desc: ||g'`"

		local _rID="`ls ${PBI_DBREPODIR}/*.${PBI_REPO}`"

		_rID=`basename $_rID | cut -d '.' -f 1`

	# Extract the header files 

	tar xvf "${PBI_FILENAME}" -C "${PBI_HEADER_TMPDIR}" >/dev/null 2>/dev/null

}

	PBI_ENABLEAUTOUPDATE=""

        PBI_FBSDVER=""

	PBI_ORIGPROGDIRPATH=""

	PBI_PATCHVERSION=""

	PBI_PATCHTARGET=""

	PBI_PROGNAME=""

        	PBI_REPO=`cat ${1}/pbi_repo`

	fi

	# See if this PBI was signed

	if [ -e "${1}/pbi_archivesum.sha1" ] ; then

		check_valid_sigs "${1}"

	mk_pbi_extract_dir

	pbi_extract_archive

	pbi_add_run_script

	check_postinstall_script

	clean_remote_dl

}

add_hashdir_trigger() {

	get_dbdir

        _htrig=`echo ${APPDBDIR} | sed "s|${PBI_DBAPPDIR}|${PBI_DBHASHQUEUEDIR}|g"`

}

# Run the install script if exists

		file="`echo $hl | sed 's/:::.*$//g'`"

		# If we are trying to merge a PBI which was deleted, stop

			echo "HASHDONE - Deleted" 

			return

		fi

        open_header_tmp

	get_dbdir

	dir="${APPDBDIR}"

	mkdir -p "${dir}"

        tar cvf - -C "${PBI_HEADER_TMPDIR}" . 2>/dev/null | tar xvf - -C "$dir" 2>/dev/null

	# If this was a patch, use the original path

		echo "${PBI_ORIGPROGDIRPATH}" >${dir}/pbi_installedpath

	else

		echo "${PBI_PROGDIRPATH}" >${dir}/pbi_installedpath

	# See which repo / key this PBI associates to, if any

	check_valid_sigs "${dir}"

		_rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"

		echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${dir}/pbi_repo

	fi

	tar="xvf -"

	if [ "$PBI_VERBOSE" = "YES" ] ; then

		tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar ${tar} -C "${PBI_EXTRACTDIR}"

		err="$?"

	else

		exit_trap

	fi

	load_pbi_conffile

	parse_cmdline_overrides

# Start looping through and creating a hash-list of files

mk_hash_list() {

  	if [ "${PBI_CREATE_HASHLIST}" = "NO" ] ; then return 0 ; fi

	hashfile="${PBI_STAGEDIR}/${PBI_HASHLIST}"

		# Check if this hash file is excluded

		_hfound="0"

			for _hexcl in ${PBI_HASH_EXCLUDES}

			do

				if [ "$_hexcl" = "$line" ] ; then

		fi

	done < ${tmp_hashdir}

	rm ${tmp_hashdir}

}

# Parse any external link directives

mk_extlink_entries() {

	init_tmpdir

	_extf="${PBI_CONFDIR}/${MOD_EXTLINKFILE}"

	_autoextf="${PBI_STAGEDIR}/${MOD_AUTOEXTLINKFILE}"

		_wraponly="NO"

		_crashhandle="YES"

		_keep="YES"

                echo $line | tr '\t' ' ' | tr -s ' ' | grep "^#" >/dev/null 2>/dev/null

                if [ "$?" != "0" ] ; then

                        src="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 1`"

				       nocrash) _crashhandle="NO" ;;

				          keep) _keep="YES" ;;

				       replace) _keep="NO" ;;

					*) echo "Warning: Unknown option \"$i\" in ${MOD_EXTLINKFILE}";;

				esac

				if [ "$?" = "0" ] ; then continue ; fi

				# Make the binary wrapper

				# This binary is done, save it now so we don't duplicate later

				_donewrap="$_donewrap #${src}#"

	tar="${2}"

	ch="${3}"

	onlywrap="${4}"

	# Check if the fake-bin wrapper already exists, and if so use

	# a different name

		fbin=`echo $bin | sed 's|/|-|g'`

	fi

	# Make our link to the system localbase if its not a wrapper only

 	if [ "$onlywrap" != "YES" ] ; then	

		echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${fbin} \$SYS_LOCALBASE/${tar}" \

			>> "${dir}/${PBI_INS_PATHSCRIPT}"

	fi

}

# Create any XDG script for install / deinstall

mk_xdg_scripts() {

  	mk_xdg_desktop_script

  	mk_xdg_menu_script

  	mk_xdg_mime_script

# Create the install script for the PBI

mk_install_script() {

	if [ ! -d "${PBI_STAGEDIR}/${PBI_FAKEBIN_DIR}" ] ; then mkdir -p "${PBI_STAGEDIR}/${PBI_FAKEBIN_DIR}" ; fi

	insc="${PBI_STAGEDIR}/${PBI_FAKEBIN_DIR}/.pbi-install.sh"

	echo "#!/bin/sh" > "$insc"

		echo '	ln -fs "${SYS_LOCALBASE}/lib/X11/fonts" "${PBI_PROGDIRPATH}/lib/X11/fonts"' >> "$insc"

		echo '	rm "${PBI_PROGDIRPATH}/lib/X11/icons" >/dev/null 2>/dev/null' >> "$insc"

		echo '	ln -fs "${SYS_LOCALBASE}/lib/X11/icons" "${PBI_PROGDIRPATH}/lib/X11/icons"' >> "$insc"

		echo 'fi' >> "$insc"

	fi

	# Add the binary wrapper sym-links

        if [ -e "${PBI_STAGEDIR}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" ] ; then

		echo 'if [ `id -u` = "0" ] ; then ' >>${insc}

# Create the deinstall script for the PBI

mk_deinstall_script() {

	uisc="${PBI_STAGEDIR}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"

	echo "#!/bin/sh" > "$uisc"

	# Remove the binary wrapper sym-links

        if [ -e "${PBI_STAGEDIR}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" ] ; then

		echo "	$PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >>${uisc}

	fi

	# Look for any XDG scripts

# Create a dir for staging the final archive

mk_stage_dir() {

	PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"

	echo "Creating Stage Dir: ${PBI_STAGEDIR}"

	mkdir -p ${PBI_STAGEDIR}

	# Build module list of excludes

		for excl in $PBI_EXCLUDELIST

		do

			if [ -z "$_excOpts" ] ; then

		--exclude make.conf.bak --exclude .keepports \

		-C "${PBI_PROGDIRPATH}" . 2>/dev/null \

		| tar xvpf - -C ${PBI_STAGEDIR} 2>/dev/null

}

# Remove the stagedir

rm_stage_dir() {

	PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"

}

# See if we need to clean the stagedir

	if [ "${PBI_USESYSFONTS}" != "NO" ] ; then

		rm -rf ${PBI_STAGEDIR}/etc/fonts >/dev/null 2>/dev/null

		rm -rf ${PBI_STAGEDIR}/lib/X11/fonts >/dev/null 2>/dev/null

	fi

}

# Start copying pbi details into header file

save_pbi_details_to_header() {

	echo "${PBI_PROGNAME}" > "${PBI_HEADERDIR}/pbi_name"

	echo "${PBI_PROGVERSION}" > "${PBI_HEADERDIR}/pbi_version"

	echo "${PBI_PROGAUTHOR}" > "${PBI_HEADERDIR}/pbi_author"

	fi

	# Copy over our icon

		# Get the file extension

		_iconExt=`echo "$PBI_PROGICON" | awk -F . '{print $NF}'`

	else

	fi

	# Check for any gui images

	fi

	# Save the uname details

	echo "${PROGVERSION}" > "${PBI_HEADERDIR}/pbi_createver"

	# Get the total number of files in the STAGEDIR

# All the pieces are ready, spit out the final PBI file

mk_output_pbi() {

                icon="${PBI_STAGEDIR}/${PBI_PROGICON}"

        else

        fi

	_pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"

	mark1="${PBI_CREATE_OUTDIR}/.pbimark1.$$"

	mark2="${PBI_CREATE_OUTDIR}/.pbimark2.$$"

run_remove_script() {

	uisc="${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"

	if [ ! -e "$uisc" ] ; then return 0 ; fi

        export_script_vars

	if [ "$PBI_VERBOSE" = "YES" ] ; then

       		sh "${uisc}"

	fi

}

# Remove the pbi directory

remove_pbidir() {

	if [ -z "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi

	if [ "$PBI_VERBOSE" = "YES" ] ; then

		echo "Removing: ${PBI_PROGDIRPATH}"

	fi

	rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null

	# Do we have leftovers?

	# Running as user add to ~/bin

	init_tmpdir

	if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi

	while read lnk

	do

		/bin/sh -c "${lnk}"

# Start the PBID daemon

do_pbid() {

	# Set verbosity 

	_redir="&1"

		check_autoupdate_pbis "$_pbid_log" "$_redir"

		# Check if we need to merge files into the hashdir

			init_tmpdir

			for _hpbi in `ls ${PBI_DBHASHQUEUEDIR}`

			do

# Begins the port make

start_pbi_makeport()

{

}

# Prune any ports which aren't required for runtime

		if [ ! -d "/usr/ports/${port}" ] ; then

			exit_err "/usr/ports/${port} does not exist!"

		fi

	done

}

		if [ ! -d "/usr/ports/${port}" ] ; then

			exit_err "/usr/ports/${port} does not exist!"

		fi

	done

}

	check_enable_disable_auto

	# Stop here if we are just enabling / disabling auto-update

	start_update_checks

	if [ "$?" != "0" ] ; then rm_tmpdir ; exit 1 ; fi

	# Stop here if only doing update checks

  	require_root_or_group

        # See which repo / key this PBI associates to, if any

	check_valid_sigs "${1}"

		_rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"

		echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${1}/pbi_repo

	fi

		# Now fetch the file

		sFile="${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}"

		fetch -o "${sFile}" "${aIcon}" >/dev/null 2>/dev/null

	done < ${_repoMeta}

}

	PBI_UPCSUM=""

	PBI_UPMDATE=""

	PBI_UPREPO=""

	# If we are looking for the current app, set _uver accordingly

	if [ "$_uver" = "current" ] ; then

		PBI_UPPATCHES="`echo $_upLine | cut -d ':' -f 8`"

		PBI_UPCSUM="`echo $_upLine | cut -d ':' -f 4`"

		PBI_UPMDATE="`echo $_upLine | cut -d ':' -f 5`"

		PBI_UPMIRROR="`cat ${PBI_DBMIRRORDIR}/${_rMd5} 2>/dev/null`"

		PBI_UPREPO="${_rMd5}"

		if [ "${_urepo}" != "AUTO" ] ; then break; fi

	done

	if [ -z "$PBI_UPNVER" ] ; then return 1 ; fi

	# See if this update is newer than the installed date

		nDay=`echo $PBI_UPMDATE | cut -d ' ' -f 1`

		nHour=`echo $PBI_UPMDATE | cut -d ' ' -f 2`

		oDay=`echo $_omdate | cut -d ' ' -f 1`

# Start PBI update process

do_pbi_update() {

	if [ "$PBI_UPDATEAPP" = "ALL" ] ; then

		# Loop and check all PBIs for updates

pbi_add_fetch_remote() {

	# Set the target program we want to download

	_rtar="$PBI_FILENAME"

	# Check if the user overrode the arch / versions we want to install

	_rArch=`uname -m`

	_rVer="current"

	check_pbi_update "$_rtar" "nodisplay" \

	# Now overwrite the PBI_FILENAME and let us proceed to regular install

	PBI_FILENAME="$PBI_UPDLFILE"

}

# Update the targed PBI

	_dl_loc="${PBI_APPDIR}/.`basename $PBI_UPFILE`.$$"

	# Have a patch file to download instead, make that the active file to try

		_bDir=`dirname $PBI_UPFILE`

		_uFile="${_bDir}/${_tPatch}"

	else