{

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

{

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;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

{

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;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

{

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

{

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 [ -e ./preinstall ];then

savestdin

echo -e "${GREEN}Running pre-install for $pkgname ...${NORMAL}\n" >&2

./preinstall

restorestdin

fi

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

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

if [ -e ./postinstall ];then

savestdin

echo -e "${GREEN}Running post-install for $pkgname ...${NORMAL}\n" >&2

./postinstall

restorestdin

fi

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

{

if [ "X$BUILTTARBALL" != "X" ];then

doinstall "$BUILTTARBALL"

else

for ((cnt=0;cnt<$OPTCOUNT;cnt++))

do

doinstall "${OPTS[$cnt]}"

done

fi

updatedatabase ||true

{

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"

{

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.$$

{

local pkgpath pkgname pkgdir

local lfsname lfsversion

local suffix

local upperdir

local infodata

for pkgpath in ${OPTS[@]}

do

pkgname="$(basename "${pkgpath/.tar.*/}")"

pkgdir="$(dirname "${pkgpath/.tar.*/}")"

lfsname=${pkgname%-?*}

lfsversion=${pkgname##?*-}

if [ "X$pkgpath" = "X$pkgname" ];then

suffix=".${pkgpath##*.}"

else

suffix=$(basename ${pkgpath/"${pkgname}"/})

fi

upperdir="$(echo "$(basename "$(pwd)")"|tr a-z A-Z)"

mkdir $lfsname||true

echo -e "#!/bin/bash\n#©$USER $(date)\n\n. /usr/share/LFSPkg/LFSFunctions\n">${lfsname}/preinstall

echo -e "#!/bin/bash\n#©$USER $(date)\n\n. /usr/share/LFSPkg/LFSFunctions\n">${lfsname}/postinstall

infodata=$(makepkginfo ${lfsname}||true)

if [ "X$infodata" != X ];then

echo "$infodata" > ${lfsname}/info

fi

cat >"${lfsname}/$lfsname.LFSBuild"<< EOF

case ${TEMPLATE^^} in

"CONFIGURE")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

;;

"MESON")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

;;

"CMAKE")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

;;

"PYTHON2")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

;;

"PYTHON3")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

;;

"PYTHON")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

;;

"PERL")

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

esac

cat >>"${lfsname}/$lfsname.LFSBuild"<< EOF

chmod +x "${lfsname}/$lfsname.LFSBuild"

chmod +x "${lfsname}/preinstall"

chmod +x "${lfsname}/postinstall"

done

{

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

listcontents "$SELECTEDPKG"

{

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

{

local what=""

local buildtype="B"

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

if [ X"$ANYVERSION" != "X" ];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")

{

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 "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 "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

{

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

{

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

{

local defaultdata pkgs scrvers scrpath deps installed instvers que j arg quearry quelen quecnt searchtweak

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

maketemplate

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