LFSPkg/LFSMakePkg.main

#!/bin/bash -e

#
#LFSMakePkg
#

###CUT###

if [ X"$THISTTY" = "X" ];then
	export THISTTY=$(tty)
fi

if [ "X$LOCAL" != "X" ];then
	FINDHELPER=$(pwd)/finddepends
	. $(pwd)/LFSFunctions
	LFSSETUP=$(pwd)/LFSPkgSetUp
	LFSMAKETEMPLATE=$(pwd)/LFSMakeTemplate
else
	. /usr/share/LFSPkg/LFSFunctions
	FINDHELPER=/usr/bin/finddepends
	LFSSETUP=/usr/share/LFSPkg/LFSPkgSetUp
	LFSMAKETEMPLATE=/usr/share/LFSPkg/LFSMakeTemplate
fi

cleanFolderPath ()
{
	local path="$1"
	local cleanpath=""
	local lastwasslash=false

	for ((arg=0;arg<${#path};arg++))
		do
			if [ ${path:$arg:1} != "/" ];then
				cleanpath="${cleanpath}${path:$arg:1}"
				lastwasslash=false
			else
				if [ $lastwasslash = false ];then
					cleanpath="${cleanpath}/"
					lastwasslash=true
				fi
			fi
		done

	if [ ${cleanpath:${#cleanpath}-1:1} = "/" ];then
		echo "$cleanpath"
	else
		echo "${cleanpath}/"
	fi
}

init ()
{
	TMP=${TMP:-/tmp}
	if [ ! -d "$TMP" ];then mkdir -p "$TMP" &>/dev/null||true;fi
	SUFFIX=${SUFFIX:-"LFSPKG"}
	SECTION=${SECTION:-"SYS"}
	BUILD=${BUILD:-1}
	VERSION="${VERSION:-0.0.1}"
	OUTPUT=${OUTPUT:-"$TMP"}
	ROOTDIR=${ROOTDIR:-"/"}
	BUILDSCRIPTS=${BUILDSCRIPTS:-"./"}
	EXITONFAIL=${EXITONFAIL:-1}
	CONFIGOPTIONS=${CONFIGOPTIONS:-"--prefix=/usr"}
	NOASKROOT=${NOASKROOT:-0}
	ANSWER=${TMP}/reply$$
	BUILTTARBALL=""
	SELECTEDPKG=""
	CURRENTSTDINSAVE=2
	USESTABLE=${USESTABLE:-1}
	LFSPKGFOLDER=${ROOTDIR}/var/lib/lfspkg
	PKGFOLDER=${LFSPKGFOLDER}/packages
	DATABASEFOLDER=${LFSPKGFOLDER}/database
	DATABASE=${DATABASEFOLDER}/db.txt
	SIMPLEUPDATE=${SIMPLEUPDATE:-1}
	RETURNCODE=0
	mkdir -vp "$PKGFOLDER" "$DATABASEFOLDER" ||true
	ROOTDIR=$(cleanFolderPath $ROOTDIR)
	BUILDSCRIPTS=$(cleanFolderPath $BUILDSCRIPTS)
	DRYRUN=${DRYRUN:-0}
	RUNINSTALLSCRIPTS=${RUNINSTALLSCRIPTS:-1}

	export ROOTDIR BUILDSCRIPTS
}

savestdin ()
{
	((CURRENTSTDINSAVE++))
	eval "exec $CURRENTSTDINSAVE<&0"
	exec 0<"$THISTTY"
}

restorestdin ()
{
	eval "exec 0<&$CURRENTSTDINSAVE $CURRENTSTDINSAVE<&-"
	((CURRENTSTDINSAVE--))
}

reruninstallscripts ()
{
	local scriptname
	local folder

	if [ $PREINSTALL -eq 1 ];then
		scriptname="preinstall"
	else
		scriptname="postinstall"
	fi

	folder=${1%-?*}
	if [ -e ${PKGFOLDER}/${folder}/${scriptname} ];then
		cp ${PKGFOLDER}/${folder}/${scriptname} ${ROOTDIR}
		pushd ${ROOTDIR}
			./$scriptname
			rm ./$scriptname||true
		popd
	else
		echo "No ${scriptname} found for ${1} :("
	fi
}

listcontents ()
{
	local folder

	if [ "X$1" != "X" ];then
		folder=${1%-?*}
		if [ $LESS -eq 1 ];then
			tar -O -xvf ${PKGFOLDER}/${folder}/${1}.tar.gz 2>/dev/null|less
		else
			tar -O -xvf ${PKGFOLDER}/${folder}/${1}.tar.gz 2>/dev/null
		fi
		return
	fi
}

findfile ()
{
	local found

	find $PKGFOLDER -type f| while read
		do
			found=
			found=$(tar -O -xvf "$REPLY" 2>/dev/null|grep --text -i "$FIND")
			if [ "X$found" != "X" ];then
				echo "$FIND Found in package: $(basename "${REPLY/.tar.gz/}")"
				echo -e "At these locations:\n$found"
			fi
		done
}

selectmultipkg ()
{
	local arraydata array arraycnt dialogdata
	local instruction="$1"
	local nodialogarray pkg cnt

	arraydata=( $(for ((cnt=0;cnt<$OPTCOUNT;cnt++));do ls -1 --quoting-style=shell "$PKGFOLDER"|grep -i ${OPTS[$cnt]};done) )

	if [ ${#arraydata} -eq 0 ];then
		echo "Nothing by that name :("
		return
	fi

	dialogdata=""
	arraycnt=${#arraydata[@]}
	nodialogarray=""
	for (( cnt=0;cnt<$arraycnt;cnt++ ))
		do
			nodialogarray="$nodialogarray ${arraydata[$cnt]%.tar.gz}"
			dialogdata="${dialogdata} \"${arraydata[$cnt]%.tar.gz}\" \"\" off "
		done

	if type dialog &>/dev/null && [ $MENUQUERY -eq 0 ];then
		echo $dialogdata|xargs dialog  --checklist "What package do you want to $instruction?" 0 100 0 2>$ANSWER
	else
		select pkg in $nodialogarray "EXIT"
			do
				break
			done
		echo $pkg>$ANSWER
	fi

	if [ "X$(cat $ANSWER)" != "X" ];then
		SELECTEDPKG=( $(cat $ANSWER) )
		return
	fi
}

selectsinglepkg ()
{
	local arraydata array arraycnt dialogdata
	local instruction="$1"
	local nodialogarray pkg
	local searchname="$2"
	local transform

	if [ -z "$searchname" ];then
		echo "Please provide package name ..."
		exit 100
	fi

	arraydata=$(find "${PKGFOLDER}"/* -type f -exec basename '{}' \;|grep -i $searchname|sort)
	if [ ${#arraydata} -eq 0 ];then
		echo "Nothing by that name :("
		return
	fi

	eval array=( $arraydata )
	dialogdata=""
	arraycnt=${#array[@]}

	if [ $JUSTLIST = 1 ];then
		transform="${array[@]}"
		transform="${transform//'.tar.gz'/}"
		echo -e "${transform// /\\n}"
		return
	fi	

	if ((arraycnt==1));then
		echo ${array[$cnt]%.tar.gz}>$ANSWER
		SELECTEDPKG=${array[$cnt]%.tar.gz}
		return
	fi
	nodialogarray=""
	for (( cnt=0;cnt<$arraycnt;cnt++ ))
		do
			nodialogarray="$nodialogarray ${array[$cnt]%.tar.gz}"
			dialogdata="${dialogdata} \"${array[$cnt]%.tar.gz}\" \"\" off "
		done

	if type dialog &>/dev/null && [ $MENUQUERY -eq 0 ];then
#	if  type dialog &>/dev/null;then
		echo $dialogdata|xargs dialog --radiolist "What package do you want to $instruction?" 0 100 0 2>$ANSWER
	else
		select pkg in $nodialogarray "CANCEL"
			do
				break
			done
			if [ X"$pkg" = X"CANCEL" ];then return;fi
		echo $pkg>$ANSWER
	fi

	if [ "X$(cat $ANSWER)" != "X" ];then
		SELECTEDPKG=$(cat $ANSWER)
		return
	fi
}

removelfspkg ()
{
	local cnt flag
	local pkgname="$1"
	local pkgfolder
	pkgfolder="$(basename "${pkgname%-?*}")"

	if [ "X$pkgname" != "X" ];then
		flag=true
		while $flag
			do
				flag=false
				while read
					do
						REPLY=${REPLY#.}
						if [ -f "${ROOTDIR}$REPLY" ] || [ -L "${ROOTDIR}$REPLY" ];then
							rm "${ROOTDIR}$REPLY" 2>/dev/null
							echo "Deleted ${ROOTDIR}$REPLY..."
							flag=true
						fi
						if [ -d "${ROOTDIR}$REPLY" ];then
							if rmdir "${ROOTDIR}$REPLY" 2>/dev/null;then
								echo "Deleted ${ROOTDIR}$REPLY..."
								flag=true
							fi
						fi
					done < <(listcontents "$pkgname")
			done
		rm "${PKGFOLDER}/${pkgfolder}/${pkgname}.tar.gz"
		if ! ls -1 "${PKGFOLDER}/${pkgfolder}"|grep -i .tar.gz &>/dev/null;then
			rm "${PKGFOLDER}/${pkgfolder}"/*
			rmdir "${PKGFOLDER}/${pkgfolder}"
		fi

		echo -e "${RED}Un-Installing $pkgname ...${NORMAL}\n" >&2
		updatedatabase
	else
		exit 0
	fi
}

doinstall ()
{
	local pkgpath="$1"
	local pkgname
	local callingfolder

	pkgfolder="$(basename "${pkgpath%-?*}")"
	pkgname="$(basename "${pkgpath/.tar.gz/}")"

	if [ $DRYRUN -eq 1 ];then
		echo -e "Installing (Simultated) ${GREEN}${pkgname}${NORMAL} To ${RED}${ROOTDIR} ...\n" >&2
		return
	fi

	pushd "$ROOTDIR"
		tar --keep-directory-symlink  -xpf "$1" ./preinstall &>/dev/null||true

		if [[ $RUNINSTALLSCRIPTS -eq 1 ]];then
			if [ -e ./preinstall ];then
				savestdin
					echo -e "${GREEN}Running pre-install for $pkgname ...${NORMAL}\n" >&2
					./preinstall
				restorestdin
			fi
		fi

		echo -e "${GREEN}Installing $pkgname ...${NORMAL}\n" >&2

		tar --keep-directory-symlink  -xvpf "$1"

		if [[ $RUNINSTALLSCRIPTS -eq 1 ]];then
			if [ -e ./postinstall ];then
				savestdin
					echo -e "${GREEN}Running post-install for $pkgname ...${NORMAL}\n" >&2
					./postinstall
				restorestdin
			fi
		fi

#database
		pushd "${PKGFOLDER}"
			mkdir "$pkgfolder" &>/dev/null||true
			cd "$pkgfolder"
			:>"$pkgname"
			tar --list -f "${pkgpath}" >  "$pkgname"
			sed -i -r '/^\.\/preinstall$/d;/^\.\/postinstall$/d;/^\.\/info$/d;/^\.\/$/d' "$pkgname"
			tar -czvf "${pkgname}.tar.gz" "$pkgname"
			rm "$pkgname"
			mv $ROOTDIR/preinstall . &>/dev/null||true
			mv $ROOTDIR/postinstall . &>/dev/null||true
			mv $ROOTDIR/info . &>/dev/null||true
			mv $ROOTDIR/buildscript.txt . &>/dev/null||true
		popd
	popd
}

installlfspkg ()
{
	if [ "X$BUILTTARBALL" != "X" ];then
		doinstall "$BUILTTARBALL"
	else
		for ((cnt=0;cnt<$OPTCOUNT;cnt++))
			do
				doinstall "${OPTS[$cnt]}"
			done
	fi
	updatedatabase ||true
}

makelfspkg ()
{
	local outdir="${PKGARCHIVES:-"$OUTPUT"}"
	local tarfile="${PKGARCHIVES}/${SECTION}/${NAME}-${PKGVERSION}-${BUILD}_${SECTION}_${SUFFIX}.tar.gz"

	mkdir -vp "${PKGARCHIVES}/${SECTION}" 2>/dev/null||true

	tar -cvzf "$tarfile" .
	echo "Package ${NAME}-${PKGVERSION} has been built here:$tarfile"
	BUILTTARBALL="$tarfile"
}

updatelfspkg ()
{
	local searchname="${OPTS[0]}"
	local newpkg="${OPTS[1]}"
	local installedname="$(basename ${newpkg} .tar.gz)"
	local togo
	local updated
	local flag
	local oldsearchname="${OPTS[0]}"
	SELECTEDPKG=

	selectsinglepkg "update" "$searchname"

	if [ "X$SELECTEDPKG" = "X" ];then
		return
	else
		x=$(basename "${SELECTEDPKG%-?*}")
		searchname="${x%-?*}"
	fi

	if [ "$oldsearchname" != "$searchname" ];then
		rm -rf /var/lib/lfspkg/packages/${oldsearchname}-*
	fi
	tar -Oxf /var/lib/lfspkg/packages/${searchname}-*/*_LFSPKG.tar.gz|sort -r >/tmp/old.$$
	rm /var/lib/lfspkg/packages/${searchname}-*/*_LFSPKG.tar.gz

	doinstall "$newpkg"
	pkgfolder="$(basename "${SELECTEDPKG%-?*}")"
	tar --list -f "$newpkg"|sort -r >/tmp/newp.$$

	echo -e "Removing orphaned files from ${GREEN}${pkgfolder}${NORMAL} From ${RED}${ROOTDIR}${NORMAL} ...\n" >&2
	if [ $DRYRUN -eq 1 ];then
		pushd $ROOTDIR &>/dev/null
			while read togo
				do
					if [ "$(grep "^${togo}$" /tmp/newp.$$)" = "" ];then
						if echo "$togo"|grep -i "/etc/" &>/dev/null;then
							echo -e "Removing (Simultated) "${RED}${togo}${NORMAL}" ..."
						fi
					fi
				done < <(cat /tmp/old.$$)
		popd
		if [ ! "$(basename ${newpkg%-?*})" = "${pkgfolder}" ];then
			echo -e "(Simultated) ${GREEN}rm -rvf ${RED}/var/lib/lfspkg/packages/${pkgfolder}${NORMAL}"
		fi
		echo -e "(Simultated) ${RED}updatedatabase${NORMAL}"
	else
		pushd $ROOTDIR &>/dev/null
			while read togo
				do
					if [ "$(grep "^${togo}$" /tmp/newp.$$)" = "" ];then
						if echo "$togo"|grep -vi "/etc/" &>/dev/null;then
							echo -e "Removing "${RED}${togo}${NORMAL}" ..."
							rm -f "${togo}" &>/dev/null||true
							rmdir "${togo}" &>/dev/null||true
						fi
					fi
				done < <(cat /tmp/old.$$)
		popd
		if [ ! "$(basename ${newpkg%-?*})" = "${pkgfolder}" ];then
			rm -rvf ${ROOTDIR}/var/lib/lfspkg/packages/${pkgfolder}
		fi
		updatedatabase
	fi
	rm /tmp/newp.$$ /tmp/old.$$
}

listlfspkg ()
{
	selectsinglepkg "list" "${OPTS[0]}"
	listcontents "$SELECTEDPKG"
}

remakepkg ()
{
	local filetype buidtmp filedir filename fromfile
	local folder

	selectsinglepkg "list" "${OPTS[0]}"

	buildtmp="/tmp/remake$$"
	mkdir -p $buildtmp
	folder=${SELECTEDPKG%-?*}

	if [ -e ${PKGFOLDER}/${folder}/preinstall ];then
		cp ${PKGFOLDER}/${folder}/preinstall ${ROOTDIR}preinstall
	fi

	if [ -e ${PKGFOLDER}/${folder}/postinstall ];then
		cp ${PKGFOLDER}/${folder}/postinstall ${ROOTDIR}postinstall
	fi

	while read
		do
			fromfile="${REPLY/./}"
			filename=$(basename "$fromfile")
			filedir=$(dirname "$fromfile")
			filetype=$(stat ${ROOTDIR}"$fromfile" --format="%F")
			echo "Adding ${ROOTDIR}$fromfile ..."
			case $filetype in

				"directory")
					mkdir -p "$buildtmp/$filedir"
					;;
				*)
					#should be irellevent
					mkdir -p "$buildtmp/$filedir"
					cp -pP ${ROOTDIR}"$fromfile" "$buildtmp/$filedir"
					;;
			esac
		done < <(listcontents "$SELECTEDPKG")

	pushd $buildtmp
		tar -cvzf "/tmp/${SELECTEDPKG}.tar.gz" .
	popd

	rm -rf "$buildtmp"
	if [ -e ${ROOTDIR}preinstall ];then
		rm ${ROOTDIR}preinstall
	fi

	if [ -e ${ROOTDIR}postinstall ];then
		rm ${ROOTDIR}postinstall
	fi
}

builddeps()
{
	local what=""
	local buildtype="B"

	if [ X"$NODEPS" != "X" ];then return;fi
	#if [ X"$ANYVERSION" != "X" ];then buildtype="Z";fi
	if [[ $ANYVERSION -eq 1 ]];then buildtype="Z";fi

	while read SCRIPT
		do
			if [ "X$SCRIPT" = "XERROR" ];then
				exit 100
			fi
			if [ "X$SCRIPT" != "X" ];then
				if [ "X${SCRIPT:7:5}" = "XERROR" ];then
					echo $SCRIPT
					echo -e "${RED}ABORTING !!!${NORMAL}"
					exit 100
				fi

				if [ $DRYRUN -eq 1 ];then
					echo -e "${NORMAL}Running (Simultated) ${GREEN}./$(basename $SCRIPT) ${SCRIPT##?* }${NORMAL} To ${RED}${ROOTDIR}${NORMAL} ..." >&2
					continue
				else
					pushd "$(dirname "$SCRIPT")"
						savestdin
							what=${SCRIPT##?* }

							if ! NODEPS=true ./$(basename $SCRIPT) $what;then
								echo -e "${RED}Build error with $SCRIPT...${NORMAL}"
								restorestdin
								exit -1
							fi
						restorestdin
					popd
				fi
			fi
		done < <($FINDHELPER ${BUILDSCRIPTS} ${ROOTDIR} $buildtype "$BUILDDEPS")
}

updatedatabase ()
{
	mkdir -vp "$PKGFOLDER" "$DATABASEFOLDER" &>/dev/null||true
	pushd "${DATABASEFOLDER}" &>/dev/null
		if [ $SIMPLEUPDATE -eq 0 ];then
			rm *.html *.gz *.info *-info *.txt||true
			echo -e "${GREEN}Getting index pages from (B)LFS...${NORMAL}" 1>&2
			wget http://www.linuxfromscratch.org/blfs/view/stable/longindex.html -O blfsindex1.html
			wget http://www.linuxfromscratch.org/lfs/view/stable/longindex.html -O lfsindex1.html
			wget http://www.linuxfromscratch.org/blfs/view/svn/longindex.html -O blfsindex0.html
			wget http://www.linuxfromscratch.org/lfs/view/development/longindex.html -O lfsindex0.html
			for vers in "15.0" "14.2" "14.1" "14.0" "13.37" "13.1"
				do
					echo -e "${GREEN}Getting index pages from Slackbuilds $vers ...${NORMAL}" 1>&2
					wget -c http://slackbuilds.org/slackbuilds/${vers}/SLACKBUILDS.TXT.gz -O ${vers}.txt.gz
					gunzip -c ${vers}.txt.gz > ${vers}.txt
					rm ${vers}.txt.gz
				done
		else
			echo -e "${GREEN}Checking for index pages from (B)LFS...${NORMAL}" 1>&2
			if [ ! -e blfsindex1.html ];then
				wget http://www.linuxfromscratch.org/blfs/view/stable/longindex.html -O blfsindex1.html
			fi
			if [ ! -e lfsindex1.html ];then
				wget http://www.linuxfromscratch.org/lfs/view/stable/longindex.html -O lfsindex1.html
			fi
			if [ ! -e blfsindex0.html ];then
				wget http://www.linuxfromscratch.org/blfs/view/svn/longindex.html -O blfsindex0.html
			fi
			if [ ! -e lfsindex0.html ];then
				wget http://www.linuxfromscratch.org/lfs/view/development/longindex.html -O lfsindex0.html
			fi
			for vers in "15.0" "14.2" "14.1" "14.0" "13.37" "13.1"
				do
					echo -e "${GREEN}Checking for index pages from Slackbuilds $vers ...${NORMAL}" 1>&2
					if [ ! -e ${vers}.txt ];then
						wget -c http://slackbuilds.org/slackbuilds/${vers}/SLACKBUILDS.TXT.gz -O ${vers}.txt.gz
						gunzip -c ${vers}.txt.gz > ${vers}.txt
						rm ${vers}.txt.gz
					fi
				done
		fi
	popd &>/dev/null
	if [ $SIMPLEUPDATE -lt 2 ];then
		$FINDHELPER "${BUILDSCRIPTS}" "${ROOTDIR}" L> "${DATABASE}"
	fi
}

setupLfspkgRCFile ()
{
	$LFSSETUP
}

finddependants ()
{
	local dep="$1"
	local name
	local version
	local pathtoscript
	local matches

	readarray matches < <(grep -sni "\b${dep}\b-[0-9].*" "$DATABASE"|awk -F ':' '{print $1}')
	echo -e "${BLUE}Dependencies for ${GREEN}${dep}${NORMAL}:" >&2
	for j in ${matches[@]}
		do
			name=$(sed -n "$((j-3))p" "$DATABASE"|awk -F= '{print $2}')
			version=$(sed -n "$((j-2))p" "$DATABASE"|awk -F= '{print $2}')
			pathtoscript=$(sed -n "$((j-1))p" "$DATABASE"|awk -F= '{print $2}')
			echo "${name}-${version} - $(cleanFolderPath "${ROOTDIR}$pathtoscript")"
		done
}

getData ()
{
	case $2 in
		1)
			sed -n "/^Package name="$1"$/I,/Installed version=/s/Package name=//p" "$DATABASE"
			;;
		2)
			sed -n "/^Package name="$1"$/I,/Installed version=/s/Script version=//p" "$DATABASE"
			;;
		3)
			sed -n "/^Package name="$1"$/I,/Installed version=/s/Path to script=//p" "$DATABASE"
			;;
		4)
			sed -n "/^Package name="$1"$/I,/Installed version=/s/Depends=\(.*\)/'\1'/p" "$DATABASE"
			;;
		5)
			sed -n "/^Package name="$1"$/I,/Installed version=/s/Installed=//p" "$DATABASE"
			;;
		6)
			sed -n "/^Package name="$1"$/I,/Installed version=/s/Installed version=//p" "$DATABASE"
			;;
		esac
}

main ()
{
	local defaultdata pkgs scrvers scrpath deps installed instvers que j arg quearry quelen quecnt searchtweak

	if [ X$FINDBUILDSCRIPT != "X" ];then
		findScriptFromWeb "$FINDBUILDSCRIPT"
		return
	fi

	if [ $SETUP -eq 1 ];then
		setupLfspkgRCFile
		return
	fi

	if [ $NOCOLOUR -eq 1 ];then
		RED=""
		GREEN=""
		BLACK=""
		NORMAL=""
		BLUE=""
	fi

	if [ X"$FINDDEPENDS" != "X" ];then
		$FINDHELPER ${BUILDSCRIPTS} ${ROOTDIR} D "$FINDDEPENDS"
		return
	fi

	if [ X"$BUILDDEPS" != "X" ];then
		builddeps "$BUILDDEPS"
		return
	fi

	if [ $REMAKE -eq 1 ];then
		remakepkg
		return
	fi

	if [ "X$FIND" != "X" ];then
		findfile
		return
	fi

	if [ "X$INFO" != "X" ];then
		makepkginfo "$INFO"
		return
	fi

	if [ "X$WEBPAGE" != "X" ];then
		showwebpage "$WEBPAGE"
		return
	fi

	if [ "$PKGINFO" -eq 1 ];then
		selectsinglepkg "see the info for" "${OPTS[0]}"
		if ! cat ${PKGFOLDER}/${SELECTEDPKG%-?*}/info 2>/dev/null;then
			echo "No info available ... :("
		fi
		return
	fi

	if [ $MAKE -eq 1 ];then
		makelfspkg
		return
	fi

	if [ $LIST -eq 1 ];then
		listlfspkg
		return
	fi

	if [ $INSTALL -eq 1 ];then
		installlfspkg
		return
	fi

	if [ $COMMIT -eq 1 ];then
		makelfspkg
		installlfspkg
		return
	fi

	if [ $REMOVE -eq 1 ];then
		if [ $OPTCOUNT -eq 1 ];then
			selectsinglepkg "remove" "${OPTS[0]}"
			if [ $DRYRUN -eq 1 ];then
				echo "[SIMULATED] removelfspkg $SELECTEDPKG"
			else
				removelfspkg "$SELECTEDPKG"
			fi
		else
			selectmultipkg "remove"
			localselectedpkgs=( ${SELECTEDPKG[@]} )
			for arg in ${SELECTEDPKG[@]}
				do
					selectsinglepkg "remove" $arg
					if [ $DRYRUN -eq 1 ];then
						echo "[SIMULATED]removelfspkg $SELECTEDPKG"
					else
						removelfspkg "$SELECTEDPKG"
					fi
				done
		fi
		return
	fi

	if [ $UPGRADE -eq 1 ];then
		if [ $OPTCOUNT -eq 2 ] && [ -e "${OPTS[1]}" ];then
			updatelfspkg
		else
			echo "Must supply update file"
		fi
		return
	fi

	if [ "X$TEMPLATE" != "X" ];then
		export NAME PKGVERSION
		$LFSMAKETEMPLATE $TEMPLATE ${OPTS[@]}
		return
	fi

	if [ $PREINSTALL -eq 1 ] || [ $POSTINSTALL -eq 1 ];then
		if [ $OPTCOUNT -eq 1 ];then
			selectsinglepkg "re-run the pre/post install scripts for" "${OPTS[0]}"
			reruninstallscripts "$SELECTEDPKG"
		fi
		return
	fi

	if [ $CHECK -eq 1 ];then
		checkforversion
		return
	fi

	if [ $REBUILD -eq 1 ];then
		updatedatabase
		return
	fi

	if [ $NOTINSTALLED -eq 1 ];then
		$FINDHELPER ${BUILDSCRIPTS} ${ROOTDIR} U
		return
	fi

	if [ $INSTALLED -eq 1 ];then
		$FINDHELPER ${BUILDSCRIPTS} ${ROOTDIR} I
		return
	fi

	if [ $DEPENDSON -eq 1 ];then
		finddependants ${OPTS[0]}
		return
	fi

	if [ $CHECKALL -eq 1 ];then
		cat $DATABASE |grep -i name|awk -F= '{print $2}'|xargs -I '{}' lfspkg -C '{}'
		return
	fi

	if [ "X$EXPLAIN" != "X" ];then
		printBuildInfo "$EXPLAIN"
		return
	fi

	if [[ -n "${SEARCH+1}" ]] || [[ -n "${FUZZY+1}" ]];then
		if [ ! -e "$DATABASE" ];then
			lfspkg -U
		fi
		what=( "Package name" "Script version" "Path to script" "Depends" "Installed" "Installed version" )
		
		if [[ -n "${FUZZY+1}" ]];then
			searchtweak=".*${OPTS[0]}.*"
		else
			searchtweak="${OPTS[0]}"
		fi

		if [ "$SEARCH" = "" ] && [ "$FUZZY" = "" ];then
			sed -n "/^Package name=${searchtweak}$/I,/Installed version=/p" "$DATABASE"
			return
		else
			if [[ -n "${SEARCH+1}" ]];then
				que="$SEARCH"
			else
				que="$FUZZY"
			fi
		fi

		pkgs=( $(getData ${searchtweak} 1) )
		scrvers=( $(getData ${searchtweak} 2) )
		scrpath=( $(getData ${searchtweak} 3) )
		eval deps=( $(getData ${searchtweak} 4) )
		installed=( $(getData ${searchtweak} 5) )
		instvers=( $(getData ${searchtweak} 6) )

		quearry=( $que )
		quelen=( ${#quearry[@]} )
		for ((j=0;j<${#pkgs[@]};j++))
			do
				quecnt=1
				for arg in $que
					do
						case $arg in
							1)
								echo -n "${pkgs[$j]}"
								;;
							2)
								echo -n "${scrvers[$j]}"
								;;
							3)
								echo -n "${scrpath[$j]}"
								;;
							4)
								echo -n "${deps[$j]}"
								;;
							5)
								echo -n "${installed[$j]}"
								;;
							6)
								echo -n "${instvers[$j]}"
								;;
						esac
						if ((quecnt < quelen));then
							echo -n ":"
						fi
						((quecnt++))
					done
				echo
			done
		return		
	fi

	for ((cnt=0;cnt<OPTCOUNT;cnt++))
		do
			pkgnameandvers=${OPTS[cnt]}
			if [[ $ANYVERSION -eq 1 ]];then
				pkgnameandvers=${OPTS[cnt]%%-?*}
			fi
			found=( $(find "${PKGFOLDER}"/* -type f -exec basename '{}' \;|grep -i "${pkgnameandvers}") )
			echo "Matches for:${pkgnameandvers}"
			for name in ${found[@]}
				do
					echo ${name/.tar.gz/}
				done
			echo
		done
	if [ ${#found[@]} -eq 0 ];then
		RETURNCODE=1
	fi
	
	return $RETURNCODE
} 

checkforoot ()
{
	if [ $SETUP -eq 1 ] || [ $INSTALL -eq 1 ] || [ $REMOVE -eq 1 ] || [ $UPGRADE -eq 1 ] || [ $COMMIT -eq 1 ] || [ $PREINSTALL -eq 1 ] || [ $POSTINSTALL -eq 1 ];then
		if [ $UID -ne 0 ];then
			echo "You need to be ROOT to make file system changes ..."
			exit 1
		fi
	fi
}

lfspkgargs "$@"
set -- "${OPTS[@]}"

init
if [ $NOASKROOT -eq 0 ] && [ $DRYRUN -eq 0 ];then
	checkforoot
fi
main
rm $ANSWER &>/dev/null
exit $RETURNCODE