#! /bin/sh
#package-builder
#This utility is used to assist the developers to build a complete
#Bad Penguin package

# HISTORY
# 1.0.0 - 19990826 by AGX : Finally the beast entered into the cage !
# 1.0.3 - 19990929 by AGX : Added some new policy
# 1.0.4 - 19991031 by AGX : A lot of small fixes
# 1.6.0 - 19991118 by AGX : Full revision, almost completed
# 1.6.1 - 19991120 by AGX : Remove MAJOR/MINOR in favor of CONFLICTS
# 1.6.2 - 19991205 by AGX : Aggiunto "ANNOUNCE"
# 1.6.3 - 20000125 by AGX : Rimosso obbligo di "/usr/doc/$FULLNAME" + strip .a fix


# -------- CONFIGURE -------
DVERSION="Bad Penguin 0.6.0pre1"
PVERSION="1.6.3"
PKG_SPOOL="/var/spool/badpenguin"
DIST_DIR="/DOSF"	# Where usually the distribution is mounted
# --------------------------



# ----- Init ------------------------------------------------------
TEMPDIR="$HOME/tmp"
[ ! -d $TEMPDIR ] && mkdir -p $TEMPDIR
TEMPDATA=$TEMPDIR/tempdata.$$
TEMPA=$TEMPDIR/pbuild1.$$
TEMPB=$TEMPDIR/pbuild2.$$
TEMPC=$TEMPDIR/pbuild3.$$
trap 'rm -f $TEMPDATA ${TEMPA} ${TEMPB} ${TEMPC} ; exit $USCITA' 0
USCITA=0

PKG_MODE=""		# What we are doing
PKG_DIR=""		# Where we are doing that
FULLNAME=""		# Full name with version
AUTOBUILD=0		# Whenever autobuild is enabled or not

DEPS_SHELL="# base		bash_1"			# Dependencie for shell script
DEPS_PERL="# development-gnu		perl_"		# Dependencie for perl script
DEPS_INFO="# documentation		texinfo_"	# Dependencie for info files
DEPS_MAN="# documentation		man_"		# Dependencie for man pages

# --- Package Internals ---
SONAME=""		# Package Name
CATEGORY=""		# Categoria
VERSION=""
ARCH=""
OS=""
DISTRIBUTION=""
DISKUSAGE=""
DISKNAME=1
OPTIM=""
STATUS=""
AUTHOR=""
COPYRIGHT=""
DESCRIPTION=""
MANTAINER=""
URL=""
FTPURL=""
BUILDTIME=""


# ----- Parameters Checking ---------------------------------------

# Banner
clear
echoc PURPLE "AGX Package Builder - $PVERSION"
if [ "$1" = "" -o "$1" = "-h" -o "$1" = "--help" ]; then
  	echo
	echoc GREEN -n "  --create      "
	echo  "Prepare the environment for a new package"
	echoc GREEN -n "  --configure   "
	echo  "(optional) front-end to the ./configure script"
	echoc GREEN -n "  --build       "
	echo  "(optional) compile and check the program"
	echoc GREEN -n "  --scan        "
	echo  "install the program and search for installed files"
	echoc GREEN -n "  --rescan      "
	echo  "search only for new installed files"
	echoc GREEN -n "  --check       "
	echo  "perform a consistent cecking upon the package"
	echoc GREEN -n "  --request     "
	echo  "create and find dependencie"
	echoc GREEN -n "  --prepare     "
	echo  "build the .bpp package"
	echoc GREEN -n "  --announce    "
	echo  "move the package into the distribution tree"
	echo
	echoc GREEN -n "  --autobuild   "
	echo  "run any steps until an error occurs"
	echoc GREEN -n "  --permissions "
	echo  "apply permissions to the package dir"
	echo
	USCITA=1 ; exit 1
fi


# Option
case $1 in
	--create)	PKG_MODE="CREATE"	;;
	--configure)	PKG_MODE="CONFIGURE"	;;
	--build)	PKG_MODE="BUILD"	;;
	--scan)		PKG_MODE="SCAN"		;;
	--rescan)	PKG_MODE="RESCAN"	;;
	--check)	PKG_MODE="CHECK"	;;
	--permissions)	PKG_MODE="PERMISSIONS"	;;
	--request)	PKG_MODE="REQUEST"	;;
	--prepare)	PKG_MODE="PREPARE"	;;
	--announce)	PKG_MODE="ANNOUNCE"	;;
	--autobuild)	PKG_MODE="AUTOBUILD"	;;
	*)
		echoc RED    -n "Sorry, "
		echoc YELLOW -n "$1"
		echoc RED       " is not a valid parameter"
		USCITA=1 ; exit 1
		;;
esac

# Target Dir
if [ "$2" = "" ]; then
	PKG_DIR="/pkg-build"
else
	PKG_DIR="/$2"
fi
PKG_INSTALL="${PKG_DIR}/install"
PKG_INFO="${PKG_INSTALL}/INFO"
MILESTONE="${PKG_INSTALL}/MILESTONE"
FAUTOBUILD="${PKG_INSTALL}/AUTOBUILD"

# Autobuild
if [ "$PKG_MODE" = "AUTOBUILD" ]; then
  if [ -f $FAUTOBUILD ]; then
    AUTOBUILD=`cat $FAUTOBUILD`
    [ $AUTOBUILD -lt 1 ] && AUTOBUILD=1
  else
    AUTOBUILD=1
  fi
  echoc CYAN "Resuming package-builder at step nr. $AUTOBUILD"
fi



# ----- (0) CONVERTING ---------------------------------------
if [ -f $PKG_INSTALL/SONAME ] ; then
  echoc YELLOW "- Conversione di SONAME"
  echo "SONAME=\"`cat $PKG_INSTALL/SONAME`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/SONAME
fi
if [ -f $PKG_INSTALL/VERSION ] ; then
  echoc YELLOW "- Conversione di VERSION"
  echo "VERSION=\"`cat $PKG_INSTALL/VERSION`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/VERSION
fi
if [ -f $PKG_INSTALL/MAJOR ] ; then
  echoc YELLOW "- Conversione di MAJOR"
  TEMP_MAJOR=`cat $PKG_INSTALL/MAJOR`
  echo "VERSION=$TEMP_MAJOR" >>$PKG_INFO
  rm -f $PKG_INSTALL/MAJOR
fi
if [ -f $PKG_INSTALL/MINOR ] ; then
  echoc YELLOW "- Conversione di MINOR"
  [ "$TEMP_MAJOR" != "" ] && echo "VERSION=\"$TEMP_MAJOR.`cat $PKG_INSTALL/MINOR`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/MINOR
fi
if [ -f $PKG_INSTALL/ARCH ] ; then
  echoc YELLOW "- Eliminazione di ARCH"
  echo "ARCH=\"\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/ARCH
fi
if [ -f $PKG_INSTALL/SUMMARY ] ; then
  echoc YELLOW "- Conversione di SUMMARY"
  echo "SUMMARY=\"`cat $PKG_INSTALL/SUMMARY`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/SUMMARY
fi
if [ -f $PKG_INSTALL/DISKUSAGE ] ; then
  echoc YELLOW "- Conversione di DISKUSAGE"
  echo "DISKUSAGE=`cat $PKG_INSTALL/DISKUSAGE`" >>$PKG_INFO
  rm -f $PKG_INSTALL/DISKUSAGE
fi
if [ -f $PKG_INSTALL/CATEGORY ] ; then
  echoc YELLOW "- Conversione di CATEGORY"
  echo "CATEGORY=\"`cat $PKG_INSTALL/CATEGORY`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/CATEGORY
  # Category Dir
  if [ ! -d  "$DIST_DIR/agxlinux/packages/$CATEGORY" ]; then
    echoc YELLOW "La categoria del pacchetto: $CATEGORY non e' piu' valida !"
    CATEGORY=""
  fi
fi
if [ -f $PKG_INSTALL/DISKNAME ] ; then
  echoc YELLOW "- Conversione di DISKNAME"
  echo "DISKNAME=1" >>$PKG_INFO
  rm -f $PKG_INSTALL/DISKNAME
fi
if [ -f $PKG_INSTALL/OPTIM ] ; then
  echoc YELLOW "- Eliminazione OPTIM"
  echo "OPTIM=\"\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/OPTIM
fi
if [ -f $PKG_INSTALL/STATUS ] ; then
  echoc YELLOW "- Eliminazione di STATUS"
  echo "STATUS=\"\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/STATUS
fi
if [ -f $PKG_INSTALL/AUTHOR ] ; then
  echoc YELLOW "- Conversione di AUTHOR"
  echo "AUTHOR=\"`cat $PKG_INSTALL/AUTHOR`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/AUTHOR
fi
if [ -f $PKG_INSTALL/COPYRIGHT ] ; then
  echoc YELLOW "- Conversione di COPYRIGHT"
  echo "COPYRIGHT=\"`cat $PKG_INSTALL/COPYRIGHT`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/COPYRIGHT
fi
if [ -f $PKG_INSTALL/DESCRIPTION ] ; then
  echoc YELLOW "- Conversione di DESCRIPTION"
  echo "DESCRIPTION=\"`cat $PKG_INSTALL/DESCRIPTION`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/DESCRIPTION
fi
if [ -f $PKG_INSTALL/MANTAINER ] ; then
  echoc YELLOW "- Conversione di MANTAINER"
  echo "MANTAINER=\"`cat $PKG_INSTALL/MANTAINER`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/MANTAINER
fi
if [ -f $PKG_INSTALL/URL ] ; then
  echoc YELLOW "- Conversione di URL"
  echo "URL=\"`cat $PKG_INSTALL/URL`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/URL
fi
if [ -f $PKG_INSTALL/FTPURL ] ; then
  echoc YELLOW "- Conversione di FTPURL"
  echo "FTPURL=\"`cat $PKG_INSTALL/FTPURL`\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/FTPURL
fi
if [ -f $PKG_INSTALL/BUILDTIME ] ; then
  echoc YELLOW "- Eliminazione di BUILDTIME"
  echo "BUILDTIME=\"\"" >>$PKG_INFO
  rm -f $PKG_INSTALL/BUILDTIME
fi



# ----- (1) CREATE  ---------------------------------------
if [ "$PKG_MODE" = "CREATE" -o $AUTOBUILD -eq 1 ]; then
  # Title
  echo
  echoc CYAN "(1) Creating a new package"
  # Exclusive directory
  if [ -f $MILESTONE ]; then
    echoc YELLOW "The MILESTONE already exist, remove them manualy if you need"
  fi
  # Prepare directory
  mkdir -p -m 750 $PKG_DIR
  mkdir -p -m 750 ${PKG_INSTALL}
  # read INFO
  if [ -f "$PKG_INFO" ]; then
    echoc YELLOW "Lettura informazioni pacchetto"
    . "$PKG_INFO"
  fi
  
  # Ask Package Name
  if [ "$SONAME" != "" ]; then
    echoc BLUE "Package Name is $SONAME"
  else    
    echoc GREEN "Please, enter the package name without any version number"
    read SONAME
    if [ "$SONAME" = "" ]; then
      echoc RED "No name specified, giving up."
      USCITA=1 ; exit 1
    fi
  fi
  # Ask category
  if [ "$CATEGORY" != "" ]; then
    echoc BLUE "Category is $CATEGORY"
  else
    echoc GREEN Please, enter in which category the package should be placed
    read CATEGORY
    if [ "$CATEGORY" = "" ]; then
      echoc RED "No category specified, giving up."
      USCITA=1 ; exit 1
    fi
  fi
  if [ ! -d $DIST_DIR/agxlinux/packages/$CATEGORY ]; then
    echoc RED "The category you specified does not exists."
    echo
    echo "Here you are a list of valid categories"
    for i in $DIST_DIR/agxlinux/packages/* ; do
      [ -d $i ] && echo "   `basename $i`"
    done
    echo
    USCITA=1 ; exit 1
  fi
  
  # Ask Binary
  if [ "$VERSION" != "" ]; then
    echoc BLUE "Version is $VERSION"
  else
    echoc GREEN "Please, enter the 'complete' package's version number"
    read VERSION
    if [ "$VERSION" = "" ]; then
      echoc RED "No version was specified, giving up."
      USCITA=1 ; exit 1
    fi
  fi

  
  # -----------------------------------------
  echoc GREEN "Writing package informations"
  echo "SONAME=\"$SONAME\"" >>$PKG_INFO
  echo "CATEGORY=\"$CATEGORY\"" >>$PKG_INFO
  echo "VERSION=\"$VERSION\"" >>$PKG_INFO
  [ "$DISKNAME" = "" ] && DISKNAME=1
  echo "DISKNAME=$DISKNAME"  >>$PKG_INFO
  # =========================================

  
  # Touching the flag
  echoc GREEN "Touching the flag (require 5 seconds) ..."
  touch $MILESTONE
  sync
  sleep 5

  # Next
  [ $AUTOBUILD -gt 0 ] && AUTOBUILD=2
  echo 2 > $FAUTOBUILD
fi




# ----- PRE-REQUISITE ---------------------------------------

# Main dir
if [ ! -d $PKG_DIR ]; then
  echoc RED    "The main package dir ($PKG_DIR) does not exist"
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi
# Install dir
if [ ! -d $PKG_INSTALL ]; then
  echoc RED    "The dir $PKG_INSTALL does not exist"
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi

# INFO
if [ ! -f $PKG_INFO ]; then
  echoc RED    "NO INFO !"
  echoc RED    "Maybe the package initialization have not been completed."
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi
# Lettura informazioni
. "$PKG_INFO"

# Soname
if [ "$SONAME" != "" ]; then
  echoc BLUE "Package Name is $SONAME"
else
  echoc RED    "The SONAME does not exist"
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi
# Category
if [ "$CATEGORY" != "" ]; then
  echoc BLUE "Category Name is $CATEGORY"
else
  echoc RED    "The CATEGORY does not exist"
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi

# Category Dir
if [ ! -d  "$DIST_DIR/agxlinux/packages/$CATEGORY" ]; then
  echoc RED    "La categoria del pacchetto: $CATEGORY non e' piu' valida !"
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi

# Binary/Library/Versions
if [ "$VERSION" != "" ]; then
  echoc BLUE "Version is $VERSION"
else
  echoc RED    "The VERSION does not exist"
  echoc YELLOW "Use --create to fix the problem"
  USCITA=1 ; exit 1
fi
echoc BLUE "Full version is $VERSION"
FULLNAME="${SONAME}_${VERSION}"
echoc BLUE "Full name is $FULLNAME"



# ----- (2) CONFIGURE ---------------------------------------

# Skip compiling if not a GNU program in autobuild mode
if [ $AUTOBUILD -eq 2 ]; then
  if [ ! -x ./configure ]; then
    echoc YELLOW "Package seems not be a GNU program"
    echoc YELLOW "Skipping to step 5 ... (scan)"
    AUTOBUILD=5
  fi
fi

# Go on ...
if [ "$PKG_MODE" = "CONFIGURE" -o $AUTOBUILD -eq 2 ]; then
	# Title
	echo
	echoc CYAN "(2) Configure the source"
	# Checks
	if [ -x ./configure ]; then
		echoc BLUE "Packages is from a GNU source"
	else
		echoc YELLOW "Packages seem not a GNU program"
		USCITA=1 ; exit 1
	fi

	# Decompressing
	[ -f $PKG_INSTALL/COMPILE.gz ] && gunzip -v $PKG_INSTALL/COMPILE.gz



	echo
	echoc GREEN "Did you read README, INSTALL and the output from ./configure --help ?"
	echoc GREEN "Type YES to continue"
	read IAGREE
	if [ "$IAGREE" != "YES" ]; then
		for i in ./[A-Z]*; do
			case "`basename $i`" in
				COPYING*) continue ;;
				Makefile*) continue ;;
			esac
			clear
			echoc CYAN $i
			more $i
			echoc GREEN "Press ENTER to display the next file"
			read x
		done
		clear
		echoc CYAN "Configure help"
		configure --help | more
	fi


# ---- Fill in ----------
	if [ ! -f $PKG_INSTALL/COMPILE ]; then
		echoc GREEN "Preparing COMPILE ..."
		cat > $PKG_INSTALL/COMPILE <<EOF
#! /bin/sh
set -e
export CFLAGS="-O6 -mcpu=pentium -malign-loops=2 -malign-jumps=2 -malign-functions=2 -D_REENTRANT"
export LDFLAGS="-s"
./configure  --prefix=/usr  --cache-file=/dev/null 
EOF
	fi

	# Configure
	echo
	echoc GREEN "We filled up a compile script with some optimizations turned on"
	color GREY
	cat $PKG_INSTALL/COMPILE
	echo
	echoc GREEN "Edit ? Type NO to skip editing this file"
	read NOEDIT
	if [ "$NOEDIT" != "NO" ]; then
		joe $PKG_INSTALL/COMPILE
		sleep 2
		clear
	fi

	# Clean Up
	echo ; echo
	echoc CYAN "Cleaning Up your source distribution (make distclean)"
	make distclean
	echo ; echoc GREEN "done." ; echo
	sleep 2

	# Configure
	echo ; echo
	echoc CYAN "Configuring the source"
	sh $PKG_INSTALL/COMPILE
	REPLICA=$?
	if [ $REPLICA -eq 0 ]; then
		echo ; echoc GREEN "done." ; echo
		sleep 2
	else
		echo ; echoc RED "Configure ha ritornato l'errore $REPLICA"
		USCITA=$REPLICA
		exit $REPLICA
	fi

	# Next
	[ $AUTOBUILD -gt 0 ] && AUTOBUILD=3
	echo 3 > $FAUTOBUILD
fi




# ----- (3) BUILD ---------------------------------------
if [ "$PKG_MODE" = "BUILD" -o $AUTOBUILD -eq 3 ]; then
	# Title
	echo
	echoc CYAN "(3) Building/Compiling the source"

	# Decompressing
	[ -f $PKG_INSTALL/COMPILE.gz ] && gunzip -v $PKG_INSTALL/COMPILE.gz


	# Checks
	if [ ! -f ./[mM]akefile ]; then
		echoc YELLOW "Hey, dov'e' il Makefile ? Hai usato --configure ??"
		USCITA=1 ; exit 1
	elif [ ! -f $PKG_INSTALL/COMPILE ]; then
		echoc YELLOW "Il file COMPILE non esiste. Hai usato --configure ??"
		USCITA=1 ; exit 1
	fi

	# Make
	echo ; echo
	echoc CYAN "Compiling the program"
	make
	REPLICA=$?
	if [ $REPLICA -eq 0 ]; then
		echo ; echoc GREEN "done." ; echo
		sleep 2
	else
		echo ; echoc RED "Make ha riportato l'errore nr. $REPLICA"
		USCITA=$REPLICA
		exit $REPLICA
	fi

	# Make Check
	echo ; echo
	echoc CYAN "Test del programma (make check)"
	make check
	REPLICA=$?
	if [ $REPLICA -eq 0 ]; then
		echo ; echoc GREEN "done." ; echo
		sleep 2
	elif [ $REPLICA -eq 2 ]; then
		echo ; echoc YELLOW "Check ha riportato l'errore nr. $REPLICA"
	else
		echo ; echoc RED "Check ha riportato l'errore nr. $REPLICA"
		read x
	fi

	# Next
	[ $AUTOBUILD -gt 0 ] && AUTOBUILD=4
	echo 4 > $FAUTOBUILD

fi




# ----- (4) SCAN ---------------------------------------
if [ "$PKG_MODE" = "SCAN" -o "$PKG_MODE" = "RESCAN" -o $AUTOBUILD -eq 4 ]; then

	# Milestone
	if [ ! -f $MILESTONE ]; then
	  echoc RED    "NO MILESTONE !"
	  echoc RED    "Maybe the package initialization have not been completed."
	  echoc YELLOW "Use --create to fix the problem"
	  USCITA=1 ; exit 1
	fi

	# Title
	echo
	echoc CYAN "(4) Installing and analyzing the program"
	if [ "$PKG_MODE" = "SCAN" -o $AUTOBUILD -eq 4 ]; then
	# SCAN ...
		# Make Uninstall
		echoc GREEN "Uninstalling the previous source"
		make uninstall
		REPLICA=$?
		if [ $REPLICA -eq 0 ]; then
			echo ; echoc GREEN "done." ; echo
			sleep 2
		elif [ $REPLICA -eq 2 ]; then
			echo ; echoc YELLOW "Uninstall ha riportato l'errore nr. $REPLICA"
		else
			echo ; echoc RED "Uninstall ha riportato l'errore nr. $REPLICA"
			USCITA=$REPLICA
			exit $REPLICA
		fi

		# Make
		echoc GREEN "Make sure there is nothing to compile"
		make
		REPLICA=$?
		if [ $REPLICA -eq 0 ]; then
			echo ; echoc GREEN "done." ; echo
			sleep 2
		else
			echo ; echoc RED "Make ha riportato l'errore nr. $REPLICA"
			USCITA=$REPLICA
			exit $REPLICA
		fi

		# Make install
		echoc GREEN "Make install ..."
		make install
		REPLICA=$?
		if [ $REPLICA -eq 0 ]; then
			echo ; echoc GREEN "done." ; echo
			sleep 2
		else
			echo ; echoc RED "Install ha riportato l'errore nr. $REPLICA"
			USCITA=$REPLICA
			exit $REPLICA
		fi

		# Ldconfig
		echoc GREEN "Running ldconfig ..."
		ldconfig
		echoc GREEN "Syncing ..."
		sync
		echoc GREEN "Wait 5 seconds, please."
        	sleep 5
	fi

	# Rescan ...
	echo
	echoc GREEN "Finding changes (at the end you can edit them) ... "
	echo "# AGX Package Builder on `date` " > ${TEMPA}
	echo "# Please, edit this file removing comment and unwanted entries " >> ${TEMPA}
	echo -n " var "  ; find /var  -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	echo -n " bin "  ; find /bin  -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	echo -n " etc "  ; find /etc  -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	echo -n " lib "  ; find /lib  -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	echo -n " root " ; find /root -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	echo -n " sbin " ; find /sbin -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	echo -n " usr "  ; find /usr  -xdev -cnewer $MILESTONE -newer $MILESTONE >> ${TEMPA}
	sort ${TEMPA} > ${TEMPC}
	rm -f ${TEMPA}

	# (EDIT)
	joe ${TEMPC}

	# Transfer
	clear
	echoc GREEN "Populating the package directory ..."
	while read x ; do
		if [ ! -d "$x" -a -e "$x" ]; then
			echo "- copying $x"
			rm -f "$PKG_DIR/$x"
			cp -aP "$x"  $PKG_DIR
		fi
	done < ${TEMPC}
	rm -f ${TEMPC}
	echoc GREEN "completed."
	# Next
	[ $AUTOBUILD -gt 0 ] && AUTOBUILD=5
	echo 5 > $FAUTOBUILD 
fi



# ----- (5) CHECK ---------------------------------------
if [ "$PKG_MODE" = "CHECK" -o $AUTOBUILD -eq 5 ]; then
	# Title
	echo
	echoc CYAN "(5) Checking package consistency"

	# ----- Squeeze  ----------------------
	echoc GREEN "[SQUEEZE] Squeezing $PKG_DIR ..."
	find  $PKG_DIR \( -name \*~ -or -name \*\# \) -exec rm -vf {} \;

	# ----- /usr/doc -----------------------
	# Avoid a lot of unusefull docs
	#echo
	#echoc GREEN "[DOC] Checking docs dir ..."
	#mkdir -p $PKG_DIR/usr/doc
	DOCDIR="$PKG_DIR/usr/doc/$FULLNAME"
	mkdir -p "$DOCDIR"
        #if [ ! -d $DOCDIR ]; then
        #  SCRAMBLE=`find $PKG_DIR/usr/doc/ -type d -name "$SONAME*" 2>/dev/null | head -1`
        #  if [ -d "$SCRAMBLE" ]; then
        #    echoc YELLOW "Moving previous doc dir $SCRAMBLE"
        #    mv $SCRAMBLE  $DOCDIR
        #
        #  fi
	#fi

	# Copia tutti i documenti in maiuscolo dalla rootdir
	# dove stai installando il source
        #if [ -f ./configure -a -f ./[mM]akefile ]; then
  	#  echoc GREEN "[DOC] Checking docs from source ..."
        #  DOCDIR="$PKG_DIR/usr/doc/$FULLNAME"
	#  mkdir -p $DOCDIR
	#  for i in ./[A-Z]* ; do
	#	if [ -f "$i" ]; then
	#		TEMPDOC="`basename $i`"
	#		# Exclude
	#		case $TEMPDOC in
	#			Makefile*)	continue ;;
	#			MILESTON*)	continue ;;
	#		esac
	#		# Copy
	#		if [ ! -f "${DOCDIR}/${TEMPDOC}*" ]; then
	#			echo "Copying doc $TEMPDOC"
	#			cp -a "$i" "$DOCDIR"
	#		fi
	#	fi
	#  done
        #fi
        #
	echoc GREEN "[DOC] Compressing docs ..."
        # Ignore HTML document and already compressed image
	# Ignore apache's .conf needed by apacheconfig
	find $DOCDIR \
		-not -iname "*.conf" -not -iname "*.htm*" -not -iname "*.gif" -not -iname "*.jpg" -not -iname "*.png" \
		-type f -exec gzip -9f {} 2>/dev/null \;

	echoc GREEN "[DOC] Changing mode to docs ..."
	find $DOCDIR -type f -exec chmod 644 {} \;
        # Remove if unused
	rmdir $DOCDIR          2>/dev/null
	rmdir $PKG_DIR/usr/doc 2>/dev/null
	rmdir $PKG_DIR/usr     2>/dev/null


	# ----- /usr/info -----------------------
	if [ -d "$PKG_DIR/usr/info" ]; then

		echo
		echoc GREEN "[INFO] Adding textinfo to the deps"
		echo $DEPS_INFO >> $PKG_INSTALL/REQUEST

		echoc GREEN "[INFO] Compressing infoes ..."
		find "$PKG_DIR/usr/info" -type f -exec gzip -9f {} 2>/dev/null \;

		echoc GREEN "[INFO] Changing mode to infoes ..."
		find "$PKG_DIR/usr/info" -type f -exec chmod 644 {} \;

		touch $PKG_INSTALL/POST-INSTALL
		touch $PKG_INSTALL/PRE-REMOVE

		grep -q "install-info" $PKG_INSTALL/PRE-REMOVE
		if [ $? -ne 0 ]; then
			echoc YELLOW "You are not handling info files in PRE-REMOVE"
			echo "Press ENTER to continue"
			read x
		fi

		grep -q "install-info" $PKG_INSTALL/POST-INSTALL
		if [ $? -ne 0 ]; then
			echoc YELLOW "You are not handling info files in POST-INSTALL"
			echo "Press ENTER to continue"
			read x
		fi
	fi

	# ----- /usr/man -----------------------
	if [ -d "$PKG_DIR/usr/man" ]; then

		echo
		echoc GREEN "[MAN] Adding man to the deps"
		echo $DEPS_MAN >> $PKG_INSTALL/REQUEST

		echoc GREEN "[MAN] Compressing manpages ..."
		find $PKG_DIR/usr/man -type f -exec gzip -v9f {} 2>/dev/null \;

		echoc GREEN "[MAN] Changing mode to manpages ..."
		find $PKG_DIR/usr/man -type f -exec chmod 644 {} \;
	fi

	# ----- Stripping ----------------------
	echo
	echoc GREEN "Stripping binaries ..."
	for i in  "bin"  "sbin"  "usr/bin"  "usr/X11R6/bin"  "usr/sbin"  "usr/local/bin"  "usr/local/sbin" ; do
		if [ -d $PKG_DIR/$i ]; then
			echo "$i"
			find "$PKG_DIR/$i"  -type f -exec strip --strip-unneeded {} 2>/dev/null \;
		fi
		if [ -d $PKG_DIR/incoming/$i ]; then
			echo "incoming/$i"
			find "$PKG_DIR/incoming/$i" -type f -exec strip --strip-unneeded {} 2>/dev/null \;
		fi
	done

	# Lib strip
	echo
	echoc GREEN "Stripping libraries ..."
	for i in  "lib"  "sbin"  "usr/lib"  "usr/X11R6/lib"  "usr/local/lib" ; do
		if [ -d $PKG_DIR/$i ]; then
			echo "$i"
			find "$PKG_DIR/$i" -type f -iname "lib*so*"  -not -name "*.a" -exec strip --strip-unneeded {} \;
		fi
		if [ -d $PKG_DIR/incoming/$i ]; then
			echo "incoming/$i"
			find "$PKG_DIR/incoming/$i"  -type f  -iname "lib*so*"  -not -name "*.a" -exec strip --strip-unneeded {} \;
		fi
	done

	# ----- DEPS FOR SHELLS, PERLS, MANS, INFOES -----------------
	echo
	echoc GREEN "Building Temporary manifest ..."
	find $PKG_DIR -type f | grep -v "\/install\/" > ${TEMPA}

	echoc GREEN "Seaching shell's scripts ..."
	while read x ; do
		[ ! -x $x ] && continue
		file $x | grep -q "Bourne"
		if [ $? -eq 0 ]; then
			echo "Found at least one shell script ($x)"
			echo $DEPS_SHELL >> $PKG_INSTALL/REQUEST
			break
		fi
	done < ${TEMPA}

	echoc GREEN "Seaching perl's scripts ..."
	while read x ; do
		[ ! -x "$x" ] && continue
		file "$x" | grep -q "perl"
		if [ $? -eq 0 ]; then
			echo "Found at least one perl script ($x)"
			echo $DEPS_PERL >> $PKG_INSTALL/REQUEST
			break
		fi
	done < ${TEMPA}
	rm -f ${TEMPA}

	# ----- INSTALL-SCRIPTS -----------------------------------
	echo
	echoc GREEN "Adjusting scripts : "
	[ -f $PKG_INSTALL/COMPILE ] && gzip -v9f $PKG_INSTALL/COMPILE
	[ -f $PKG_INSTALL/NOTES ]   && gzip -v9f $PKG_INSTALL/NOTES
	#
	for i in  MANIFEST  MD5SUM* REQUEST COMPILE* NOTES*  CONFLICTS
	do
		TEMPSCRIPT="$PKG_INSTALL/$i"
		if [ -f $TEMPSCRIPT ]; then
			echo $i
			chmod 640 $TEMPSCRIPT
			chown root.root $TEMPSCRIPT
		fi
	done
	
	# Move old scripts
	if [ -f $PKG_INSTALL/PRE-DELETE ]; then
	  echoc YELLOW "Appending PRE-DELETE to PRE-REMOVE"
	  cat $PKG_INSTALL/PRE-DELETE >> $PKG_INSTALL/PRE-REMOVE
	  rm -f $PKG_INSTALL/PRE-DELETE
	  read x
	fi
	if [ -f $PKG_INSTALL/DELETE ]; then
	  echoc YELLOW "Appending DELETE to REMOVE"
	  cat $PKG_INSTALL/DELETE >> $PKG_INSTALL/REMOVE
	  rm -f $PKG_INSTALL/DELETE
	  read x
	fi
	if [ -f $PKG_INSTALL/POST-DELETE ]; then
	  echoc YELLOW "Appending POST-DELETE to POST-REMOVE"
	  cat $PKG_INSTALL/POST-DELETE >> $PKG_INSTALL/POST-REMOVE
	  rm -f $PKG_INSTALL/POST-DELETE
	  read x
	fi
	if [ -f $PKG_INSTALL/PRUNE ]; then
	  echoc YELLOW "Appending PRUNE to PURGE"
	  cat $PKG_INSTALL/PRUNE >> $PKG_INSTALL/PURGE
	  rm -f $PKG_INSTALL/PRUNE
	  read x
	fi
	if [ -f $PKG_INSTALL/CONFIGURE ]; then
	  echoc YELLOW "Appending CONFIGURE to INSTALL"
	  cat $PKG_INSTALL/CONFIGURE >> $PKG_INSTALL/INSTALL
	  rm -f $PKG_INSTALL/CONFIGURE
	  read x
	fi
	
	for i in PRE-INSTALL  INSTALL  POST-INSTALL X-POST-INSTALL \
		PRE-REMOVE REMOVE POST-REMOVE PURGE
	do
		TEMPSCRIPT="$PKG_INSTALL/$i"
		if [ -f $TEMPSCRIPT ]; then
			echo $i
			chmod 700 $TEMPSCRIPT
			chown root.root $TEMPSCRIPT

			grep -q "^set -e" $TEMPSCRIPT
			if [ $? -ne 0 ]; then
				echoc YELLOW "You are not using 'set -e' into this script"
				echo "Press ENTER to continue"
				read x
			fi

			grep -q "^set -x" $TEMPSCRIPT
			if [ $? -eq 0 ]; then
				echoc YELLOW "You are using 'set -x' into this script"
				echo "Press ENTER to continue"
				read x
			fi
		fi
	done

	# Se c'e' incoming ci deve essere anche PURGE
	if [ -d $PKG_DIR/incoming ]; then
          if [ ! -f $PKG_INSTALL/PURGE ]; then
            echoc YELLOW "directoy 'incoming' is present, you should write a PURGE script !"
            read x
          fi
        fi

	# ----- ICON -------------------------------------------
	if [ ! -d $PKG_DIR/usr/share/gnome/apps ]; then
		echoc YELLOW "There are no icons under /usr/share/gnome/apps"
		echo "Press ENTER to continue"
		read x
	fi

	# ---- LIBRARY NAME ------------------------------------
	echo
	echoc CYAN "Preparazione dei link delle librerie ..."
	for i in `find $PKG_DIR -type f -iname "lib*.so.*.*"` ; do
		LDIR="`dirname $i`"
		LNAME="`basename $i`"
		LSO="`echo $LNAME | cut -f 1 -d '.' `"
		LVER="`echo $LNAME | cut -f 3- -d '.' `"
		LX=`echo $LVER | cut -f 1 -d '.' `
		LY=`echo $LVER | cut -f 2 -d '.' `
		LZ=`echo $LVER | cut -f 3 -d '.' `
		echoc PURPLE "SONAME=$LSO   V=$LVER   X=$LX   Y=$LY   Z=$LZ"
		if [ "$LSO" = "" -o "$LVER" = "" -o "$LX" = "" -o "$LY" = "" ]; then
			echoc YELLOW "There's a blank value ... skipping"
			continue
		fi
		( 
			cd $LDIR
			ln -s $LNAME   $LSO.so.$LX
			ln -s $LNAME   $LSO.so
			ln -s $LNAME   ${LSO}${LX}.so
			grep -q "#SIMLINK:$LNAME" $PKG_INSTALL/INSTALL
			if [ $? -eq 0 ]; then
			  echoc YELLOW "Aggiungo del codice ad INSTALL ..."
  			  echo ""                    >>$PKG_INSTALL/INSTALL
			  echo "#SIMLINK:$LNAME"    >>$PKG_INSTALL/INSTALL
			  echo "( cd $LDIR"          >>$PKG_INSTALL/INSTALL
			  echo "rm $LSO.so.$LX    ; ln -s $LNAME $LSO.so.$LX" >>$PKG_INSTALL/INSTALL
			  echo "rm $LSO.so        ; ln -s $LNAME $LSO.so"     >>$PKG_INSTALL/INSTALL
			  echo "rm ${LSO}${LX}.so ; ln -s $LNAME ${LSO}${LX}.so" >>$PKG_INSTALL/INSTALL
			  echo ")" >>$PKG_INSTALL/INSTALL
		        fi
		)
	done

	# ---- MD5 ----
	echo
	echoc GREEN "Calculating MD5 Checksums ..."
	cd $PKG_DIR
	find -type f -perm +111 1>$TEMPDATA
        >$PKG_INSTALL/MD5SUM
        for item in $TEMPDATA ; do
          md5sum "$item" >>$PKG_INSTALL/MD5SUM
        done
	gzip -v9f $PKG_INSTALL/MD5SUM


	# ---- DIRECTORY PERMISSION
	echo
	echoc GREEN "Applying directory permissions (press ENTER at the end)..."
	OLD_DIR=$PWD
	cd $PKG_DIR
	echo | badpenguin-permissions.sh 2>/dev/null
	cd $OLD_DIR
	echo

	# ---- DIRECTORY PERMISSION INCOMING
        if [ -d $PKG_DIR/incoming ]; then
  	  echo
	  echoc GREEN "Applying permissions to incoming (press ENTER at the end)..."
	  OLD_DIR=$PWD
	  cd $PKG_DIR/incoming
	  echo | badpenguin-permissions.sh 2>/dev/null
	  cd $OLD_DIR
	  echo
        fi
	# Next
	[ $AUTOBUILD -gt 0 ] && AUTOBUILD=6
	echo 6 > $FAUTOBUILD
fi





# ----- (?) PERMISSIONS ---------------------------------------
if [ "$PKG_MODE" = "PERMISSIONS" ]; then
	# Title
	echo
	echoc CYAN "(?) Permissions ..."

	# ---- DIRECTORY PERMISSION
	echo
	echoc GREEN "Applying directory permissions."
	OLD_DIR=$PWD
	cd $PKG_DIR
	echo | badpenguin-permissions.sh 2>/dev/null
	cd $OLD_DIR
	echo

	# ---- DIRECTORY PERMISSION INCOMING
        if [ -d $PKG_DIR/incoming ]; then
  	  echo
	  echoc GREEN "Applying permissions to incoming (press ENTER at the end)..."
	  OLD_DIR=$PWD
	  cd $PKG_DIR/incoming
	  echo | badpenguin-permissions.sh 2>/dev/null
	  cd $OLD_DIR
	  echo
        fi
fi



# ----- (6) REQUEST ---------------------------------------
if [ "$PKG_MODE" = "REQUEST" -o $AUTOBUILD -eq 6 ]; then
	# Title
	echo
	echoc CYAN "(6) Dependencies wizard ..."

	echoc GREEN "Analizing files ..."
	> ${TEMPA}
        # Avoid sig11 on static libs
	find $PKG_DIR -type f -perm +111 -exec ldd {} >>${TEMPA} 2>/dev/null \;
	find $PKG_DIR -type f -iname "lib*so*" -exec ldd {} >>${TEMPA} 2>/dev/null \;

	echoc GREEN "Checking for missed librarians : "
	cat ${TEMPA} | grep "not found"
	if [ $? -eq 0 ]; then
		echoc RED "There are missed libraries !"
		echoc YELLOW "We suggest you to NOT continue and check the problem."
		echoc YELLOW "Press Enter to continue or CTRL+C to exit"
		read x
	fi

	echo "Parsing ldd output"
	cat ${TEMPA} | grep -v "not found" | grep "=>" >${TEMPB}

	echo "Stripping libraries name"
	> ${TEMPA}
	while read a b libs d; do
		[ "$libs" = "" ] && continue
		echo $libs | cut -b 2- >> ${TEMPA}
	done < ${TEMPB}

	echo "Sorting names"
	sort ${TEMPA} > ${TEMPB}

	echo "Stripping Unique names"
	> ${TEMPA}
	uniq -d ${TEMPB} >> ${TEMPA}
	uniq -u ${TEMPB} >> ${TEMPA}
        echo >> ${TEMPA}

	echoc GREEN "Looking libraries for deps ..."
	echo "##### Added by package-builder at `date` #####" >> $PKG_INSTALL/REQUEST
  ( cat ${TEMPA} ; echo ) | while read libs ; do
    [ "$libs" = "" ] && continue

    case "$libs" in
      lib/ld-linux.so.2)
        echo "# internal: ld-2.0.7.so"
        echo "base	libc6-shared_2	ld-2.0.7.so" >> $PKG_INSTALL/REQUEST
        continue
        ;;
      lib/libc.so.6)
        echoc GREEN "# internal: libc-2.0.7.so"
        echo "base	libc6-shared_2	libc-2.0.7.so" >> $PKG_INSTALL/REQUEST
        continue
        ;;
      lib/libm.so.6)
        echoc GREEN "# internal: libm-2.0.7.so"
        echo "base	libc6-shared_2	libm-2.0.7.so" >> $PKG_INSTALL/REQUEST
        continue
        ;;
      lib/libdl.so.2)
        echoc GREEN "# internal: libdl-2.0.7.so"
        echo "base	libc6-shared_2	libdl-2.0.7.so" >> $PKG_INSTALL/REQUEST
        continue
        ;;
    esac

    echo "- Searching $libs"
    DEPFOUND=0
    for i in $PKG_SPOOL/*; do			
      if [ -f $i/MANIFEST ]; then
        grep -h  "$libs"  "$i/MANIFEST"  >${TEMPB}
        REPLY=$?
        if [ $REPLY -eq 0 ]; then
          SHORTPKG="`basename $i | cut -f 1-2 -d '.'`"
          echoc GREEN "- Found into $i"
          if [ -f $i/INFO ]; then
            rm -f /tmp/CATEGORY
            grep "^CATEGORY" $f > /tmp/CATEGORY
            OLDCATEGORY=$CATEGORY
            . /tmp/CATEGORY
            PCATEGORY=$CATEGORY
            CATEGORY=$OLDCATEGORY
          elif [ -f $i/CATEGORY ]; then
            PCATEGORY="`cat $i/CATEGORY`"
          else
            PCATEGORY="#???"
          fi
          #
          ( cat ${TEMPB} ; echo ) | while read baselib; do
            [ "$baselib" = "" ] && continue 
            if [ -L /$baselib ]; then
            echo "    Skipping symlinks $baselib"
              continue
            else
              echo "    Adding $baselib"
            fi						
            echo "$PCATEGORY	$SHORTPKG	`basename $baselib`" >> $PKG_INSTALL/REQUEST
          done
          DEPFOUND=1
        fi
      fi
    done
    if [ $DEPFOUND -eq 0 ]; then
      echoc RED "No dependencie found for $libs"
      echo "# $libs - the dependent package was NOT found" >> $PKG_INSTALL/REQUEST
    fi
  done
  rm -f ${TEMPA} ${TEMPB}

	echoc GREEN "completed, press ENTER to edit the REQUEST file"
	read x
	joe $PKG_INSTALL/REQUEST



	# === CONFLICTS ===
	echoc YELLOW "Adesso devi editare il file CONFLICTS !"
	sleep 2
	if [ ! -f "$PKG_INSTALL/CONFLICTS" ]; then
		echo -n "${SONAME}" > "$PKG_INSTALL/CONFLICTS"
		echo -n '_'        >> "$PKG_INSTALL/CONFLICTS"
		echo "`echo $VERSION | cut -f 1 -d'.'`" >> "$PKG_INSTALL/CONFLICTS"
	fi
	joe "$PKG_INSTALL/CONFLICTS"

	# Next
	[ $AUTOBUILD -gt 0 ] && AUTOBUILD=7
	echo 7 > $FAUTOBUILD
fi




# ----- (7) PREPARE ---------------------------------------
if [ "$PKG_MODE" = "PREPARE" -o $AUTOBUILD -eq 7 ]; then
	# Title
	echo
	echoc CYAN "(7) Preparing the .bpp package ..."
	OLD_PWD=`pwd`
	cd $PKG_DIR
	# Clean-up
	rm -f *.tar *.gz *.tgz *.bpp install/MANIFEST* install/AUTOBUILD *.lsm


        # ARCH
        if [ "$ARCH" = "" ]; then
          echo
          echoc YELLOW "L'architettura di questo pacchetto non e' stata specificata"
	  echo "Per piacere inserisci l'architettura minima (i386) per la quale il"
	  echo "pacchetto e' stato preparato. Se si tratta solo di script e di"
	  echo "eseguibili puoi utilizzare il codice 'ANY'."
          SUGGESTED="i386"
          echo "SUGGERIMENTO: $SUGGESTED"
          echo
          read xARCH
          if [ "$xARCH" = "" ]; then
            echoc YELLOW "Uso il valore suggerito."
            xARCH="$SUGGESTED"	  
          fi
        else
          echoc BLUE "Architecture: $ARCH"
        fi
        [ "$xARCH" != "" ] && ARCH=$xARCH


        # OPTIM
        if [ "$OPTIM" = "" ]; then
          echo
          echoc YELLOW "L'ottimizzazione di questo pacchetto non e' stata specificata"
	  echo "Per piacere inserisci l'architettura massima (i586) per la quale il"
	  echo "pacchetto e' stato preparato. Se si tratta solo di script e di"
	  echo "eseguibili puoi utilizzare il codice 'ANY', oppure lo stesso valore"
	  echo "specificato per ARCH (i.e. $ARCH) se non sono state effettuate"
	  echo "ottimizzazioni."
          SUGGESTED="$ARCH"
          echo "SUGGERIMENTO: $SUGGESTED"
          echo
          read xOPTIM
          if [ "$xOPTIM" = "" ]; then
            echoc YELLOW "Uso il valore suggerito."
            xOPTIM="$SUGGESTED"
          fi
        else
          echoc BLUE "Optimized for : $OPTIM"
        fi
        [ "$xOPTIM" != "" ] && OPTIM=$xOPTIM


        # Summary
        if [ "$SUMMARY" = "" ]; then
          echo
          echoc YELLOW "The Summary of this package was not specified"
          echo "Please enter a ONE-LINE description of this package"
          read xSUMMARY
        else
          echoc BLUE "Summary: $SUMMARY"
        fi
        [ "$xSUMMARY" != "" ] && SUMMARY=$xSUMMARY


        # DISKNAME
        if [ "$DISKNAME" = "" ]; then
          echo
          echoc YELLOW "Il disco su cui verra' distributo questo pacchetto non e' stato specificato"
	  echo "Per piacere inserisci il nr. del disco che contterra questo pacchetto"
          read xDISKNAME
          if [ "$xDISKNAME" = "" ]; then
            echoc YELLOW "Devi specificare un valore ! Assumo 1 ..."
	    DISKNAME=1
          fi
        else
          echoc BLUE "Diskname: $DISKNAME"
        fi
	[ "$xDISKNAME" != "" ] && DISKNAME=$xDISKNAME


        # STATUS
        if [ "$STATUS" = "" ]; then
	  echoc YELLOW "Impostazione dello stato del pacchetto a NUOVO"
	  STATUS="NUOVO"
	else
	  echoc BLUE "Status: $STATUS"
        fi


        # AUTHOR
        if [ "$AUTHOR" = "" ]; then
          echo
          echoc YELLOW "The author of this software was not specified"
          echo "Please enter his name and e-mail address"
          read xAUTHOR
        else
          echoc BLUE "Author: $AUTHOR"
        fi
        [ "$xAUTHOR" != "" ] && AUTHOR=$xAUTHOR


        # Copyright
        if [ "$COPYRIGHT" = "" ]; then
          echo
          echoc YELLOW "The Copyright of this package was not specified"
          echo "Please enter GPL, LGPL, COMMERCIAL or other license type"
          echo "Enter=GPL"
          read xCOPYRIGHT
          if [ "$xCOPYRIGHT" != "" ]; then
            COPYRIGHT=$xCOPYRIGHT
          else
            COPYRIGHT="GPL"
          fi

        else
          echoc BLUE "Copyright: $COPYRIGHT"
        fi


	# Description
        if [ "$DESCRIPTION" = "" ]; then
          echo
          echoc YELLOW "The Description of this package was not specified"
          echo "Please enter a long description for this package"
          echo "NOTE: use '\' to go to the next line before to press ENTER !"
          echo
          read xDESCRIPTION
        else
          echoc BLUE "Description: $DESCRIPTION"
        fi
        [ "$xDESCRIPTION" != "" ] && DESCRIPTION=$xDESCRIPTION


        # Mantainer
        if [ "$MANTAINER" = "" ]; then
          echo
          echoc YELLOW "The Mantainer of this package was not specified"
          echo "Please enter his name and e-mail address"
          read xMANTAINER
        else
          echoc BLUE "Mantainer: $MANTAINER"
        fi
        [ "$xMANTAINER" != "" ] && MANTAINER=$xMANTAINER


	# URL
        if [ "$URL" = "" ]; then
          echo
          echoc YELLOW "The Home page's URL of this package was not specified"
          echo "Please enter the URL of the package's home page"
          read xURL
        else
          echoc BLUE "WWW URL: $URL"
        fi
        [ "$xURL" != "" ] && URL=$xURL

        # FTPURL
        if [ "$FTPURL" = "" ]; then
          echo
          echoc YELLOW "The FTP URL of this package was not specified"
          echo "Please enter the FTP URL from where you get this package's source"
          read xFTPURL
        else
          echoc BLUE "FTP URL: $FTPURL"
        fi
        [ "$xFTPURL" != "" ] && FTPURL=$xFTPURL



	# ================= CLEAN - UP  ====================

	# Squeeze ./install
	echo "Cleaning up files before counting disk-usage ..."
	find  $PKG_INSTALL \( -name \*~ -or -name \*\# \) -exec rm -vf {} \;
        rm -v -f $PKG_DIR/$FULLNAME*

	# ================= O V E R W R I T E ====================
	# DISKUSAGE
	echo
	echo "Computing package size ..."
	DISKUSAGE=`du $PKG_DIR -s -b | cut -d / -f 1`
	echoc PURPLE "Disk usage of this package is $DISKUSAGE bytes"
	# ----------
	>$PKG_INFO
        echo "SONAME=\"$SONAME\"" >>$PKG_INFO
        echo "CATEGORY=\"$CATEGORY\"" >>$PKG_INFO
        echo "VERSION=\"$VERSION\"" >>$PKG_INFO
	echo "DISKNAME=\"$DISKNAME\""  >>$PKG_INFO
	>>$PKG_INFO
        echo "ARCH=\"$ARCH\"" >>$PKG_INFO
        echo "OPTIM=\"$OPTIM\"" >>$PKG_INFO
        echo "SUMMARY=\"$SUMMARY\"" >>$PKG_INFO
	echo "DISKUSAGE=$DISKUSAGE" >>$PKG_INFO
        echo "STATUS=\"$STATUS\"" >>$PKG_INFO
	>>$PKG_INFO
        echo "AUTHOR=\"$AUTHOR\"" >>$PKG_INFO
	echo "COPYRIGHT=\"$COPYRIGHT\"" >>$PKG_INFO
        echo "DESCRIPTION=\"$DESCRIPTION\"" >>$PKG_INFO
        echo "MANTAINER=\"$MANTAINER\"" >>$PKG_INFO
        echo "URL=\"$URL\"" >>$PKG_INFO
        echo "FTPURL=\"$FTPURL\"" >>$PKG_INFO
	# Build Time
	echo "OS='Linux'" >>$PKG_INFO
	echo "DISTRIBUTION=\"$DVERSION\"" >>$PKG_INFO
        echo "BUILDHOST=\"`hostname`\"" >>$PKG_INFO
        echo "BUILDTIME=\"`date`\"" >>$PKG_INFO
        echo "BPPVERSION=\"$PVERSION\"" >>$PKG_INFO

	# =========================================================

	case "$ARCH" in
          #ignore ANY+i386
          ANY|i386)       : ;;
          i486|i586|i686) FULLNAME="$FULLNAME_$ARCH" ;;          
        esac


	# Preparing TAR archive
	echo "Tarring ..."
	tar  --sparse  --verify  -p  -f $FULLNAME  -c *
	[ $? -ne 0 ] && echo " * * *  T A R - E R R O R  * * *"

	# Creating Manifest
	echo "Creating MANIFEST file"
	rm -f $PKG_INSTALL/MANIFEST
	tar -tf "$FULLNAME" > "$PKG_INSTALL/MANIFEST"

	# Adding Manifest
	echo "Appending MANIFEST ..."
	tar -f $FULLNAME -u install/MANIFEST
	[ $? -ne 0 ] && echo " * * *  T A R (u) - E R R O R  * * *"

	# Compressing Package
	echo "Gzipping ..."
	gzip -v9 -S .bpp $FULLNAME
	[ $? -ne 0 ] && echo " * * *  G Z I P - E R R O R  * * *"
	
	cd $OLD_PWD
	echoc GREEN "Package has been successfully updated." 
	# Next
	rm  -f  $FAUTOBUILD  $MILESTONE
fi



# ----- (8) ANNOUNCE ---------------------------------------
if [ "$PKG_MODE" = "ANNOUNCE" ]; then
	# Title
	echo
	echoc CYAN "Announcing the package $FULLNAME ..."

        if [ ! -f "${PKG_DIR}/${FULLNAME}.bpp" ]; then
          echoc RED "Il pacchetto $SONAME non e' stato costruito !"
          exit 1
        fi

	# Rimuove obsoleti
	for i in $DIST_DIR/agxlinux/packages/$CATEGORY/$SONAME[_-]*
	do
	  [ ! -f $i ] && continue
	  BASENAME=`basename $i`
	  echo -n "Vuoi spostare $BASENAME ? (s/n)"
	  #echo -n "Vuoi ELIMINARE $BASENAME ? (s/n)"
	  CHOICE="Z"
	  while [ 0 ]; do
	    read CHOICE
	    if [ "$CHOICE" = "S" -o "$CHOICE" = "s" ]; then
              mv -i "$DIST_DIR/agxlinux/packages/$CATEGORY/$BASENAME"  "$DIST_DIR/agxlinux/packages/z-removed/"
	      #rm -v "$DIST_DIR/agxlinux/packages/$CATEGORY/$BASENAME"
	      break
            fi
	    if [ "$CHOICE" = "N" -o "$CHOICE" = "n" ]; then
	      break
            fi
            echo "carattere non valido"
          done
        done

        # Sposto il pacchetto 
        mv -i "${PKG_DIR}/${FULLNAME}.bpp" "$DIST_DIR/agxlinux/packages/$CATEGORY/"

fi


# ///// END /////////////////////////////////////////////
exit 0
