#!/bin/sh
##############################################################################
#         $Id: checkinstall,v 1.5.3.7 2002/09/11 04:30:11 izto Exp $ 
#                           ########################                         
#                                                                            
#
#                             CheckInstall v1.5.3
#
#  Installs a compiled program from the program's source directory using     
#  "make install" or any other command supplied on checkinstall's command  
#  line. checkinstall will create a Slackware, RPM or Debian compatible package
#  named after the source directory's name and install it using your standard  
#  package administration utilities.                                      
#                                                                            
#  This version of checkinstall needs enough free space on the partition     
#  holding the temp dir (see BASE_TEMP_DIR below) to write there a temporary 
#  copy of the package.              
#                                                                            
#  Copyright (C) 2001 Felipe Eduardo Sanchez Diaz Duran <izto@asic-linux.com.mx>
#  
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
############################################################################


# Trap the INT signal (ctrl-c, for example)
trap trapint 2

CHECKINSTALL_VERSION=1.5.3


#############################################################################
                           # Function definitions #
                           ########################


function ckversion {
   echo
   echo "checkinstall $CHECKINSTALL_VERSION, Copyright 2001 Felipe Eduardo Sanchez Diaz Duran"
   echo "           This software is released under the GNU GPL."
}



function usage() {

# If the user has a default pager defined in the PAGER environment variable,
# we'll use that. If not, we'll use "more".

! [ "$PAGER" ] && PAGER=more


   (
   ckversion
   echo
   echo "Usage: checkinstall [options] [command [command arguments]]"
   echo "Options:"
   echo
   echo "*Package type selection*"
   echo
   echo "-t,--type=<slackware|rpm|debian> Choose packaging system"
   echo "-S                               Build a Slackware package"
   echo "-R                               Build a RPM package"
   echo "-D                               Build a Debian package"
   echo
   echo "*Scripting options*"
   echo
   echo "-y, --default                  Accept default answers to all questions"
   echo "--pkgname=<name>               Set name"
   echo "--pkgversion=<version>         Set version"
   echo "-A, --arch, --pkgarch=<arch>   Set architecture"
   echo "--pkgrelease=<release>         Set release"
   echo "--pkglicense=<license>         Set license"
   echo "--pkggroup=<group>             Set software group"
   echo "--pkgsource=<source>           Set source location"
   echo "--pkgaltsource=<altsource>     Set alternate source location"
   echo "--pakdir=<directory>           The new package will be saved here"
   echo "--maintainer=<email addr>      The package maintainer (.deb)"
   echo "--provides=<list>              Features provided by this package (.rpm)"
   echo "--rpmflags=<flags>             Pass this flags to the rpm installer"
   echo "--dpkgflags=<flags>            Pass this flags to the dpkg installer"
   echo "--spec=<path>                  .spec file location"
   echo "--nodoc                        Do not include documentacion files"
   echo
   echo "*Info display options*"
   echo
   echo "-d<0|1|2>                      Set debug level"
   echo "-si                            Run an interactive install command"
   echo "--showinstall=<yes|no>         Toggle interactive install command"
   echo "-ss                            Run an interactive Slackware installation script"	
   echo "--showslack=<yes|no>           Toggle interactive Slackware installation script"
   echo "--exclude=<file|dir[,...]>     Exclude files/directtories from the package"
   echo
   echo "*Package tuning options*"
   echo
   echo "--autodoinst=<yes|no>          Toggle the creation of a doinst.sh script"
   echo "--strip=<yes|no>               Strip any ELF binaries found inside the package"
   echo "--stripso=<yes|no>             Strip any ELF binary libraries (.so files)" 
   echo "--gzman=<yes|no>               Compress any man pages found inside the package"
   echo "--docdir=<path>                Where to put documentation files"
   echo "--umask=<mask>                 Set the umask value"
   echo "--newslack                     Use the new (8.1+) Slackware description format"
   echo "                               (\"--newslack\" implies \"-S\")"
   echo
   echo "*Cleanup options*"
   echo
   echo "--deldoc=<yes|no>              Delete doc-pak upon termination"
   echo "--deldesc=<yes|no>             Delete description-pak upon termination"
   echo "--delspec=<yes|no>             Delete spec file upon termination"
   echo "--bk                           Backup any overwritten files"
   echo "--backup=<yes|no>              Toggle backup"
   echo
   echo "*About CheckInstall*"
   echo
   echo "--help, -h                     Show this message"
   echo "--copyright                    Show Copyright information"
   echo "--version                      Show version information"
   echo
   ) | $PAGER
   exit 1
}

function help_notice() {
 
echo
echo "Use --help or -h to get more information"
echo
exit 1 

}

function boolean_usage() {
   echo
   echo "$2 is an invalid value for $1" 
   help_notice
   exit 1
}


# 001117-BaP: Define a function or two

function yorn {


   if [ "$1" ]; then     # If there is no default value specified
       DEFAULTYN="$1"     # then the default is "y"
    else
       DEFAULTYN="y"
    fi
    DEFAULTYN=`echo $DEFAULTYN | tr 'A-Z' 'a-z'`

    if [ "$DEFAULTYN" = "y" ]; then  
       echo -n " [y]: "              # Print the default option
    else
       echo -n " [n]: "
    fi
    
if [ $ACCEPT_DEFAULT -eq 0 ]; then     # Should we accept all the defaults?

    read YN
    YN=`echo $YN | tr 'A-Z' 'a-z'`
    ! [ "$YN" ] && YN=$DEFAULTYN          # If the user pressed ENTER then 

else
   YN=$DEFAULTYN
   echo $YN
fi

    if [ "$YN" = "y" ] ;then    # We return something useful for a 
       return 0                 # simpler sintax ahead (12/dic/2000-Izto)
    else
       return 1
    fi


}



# dec/10/2000-Izto
# Prints OK or FAILED! depending on previous command return value

function okfail () {
 if [ $? -gt 0 ]; then
    echo ' FAILED!'
    return 1
 else
    echo 'OK'
    return 0
 fi
}

function restore_backup {
 ls ${TMP_DIR}/backup/*  &> /dev/null
 if [ $? -eq 0 ]; then
    echo -n "Restoring overwritten files from backup..."
    cd ${TMP_DIR}/backup
       tar -cpf - . | tar -f - -xvpC / &> /dev/null
    okfail
    echo
 fi
} 


function trapint {
 echo
 echo
 echo "*** SIGINT received ***"
 cleanup
}

function cleanup {
 echo
 restore_backup
 echo -n "Cleaning up..."
 cd "$DIRECTORIO_FUENTE"
 rm -rf ${TMP_DIR}
 rm -f "$BUILDROOT"
 rm -f checkinstall-debug*
 true; okfail
 echo
 echo "Bye."
 echo
 exit 1
}

                      #################################
                      # Function definition ends here #
#############################################################################

# Show the version information
ckversion
echo

if ! [ -f /etc/checkinstall/checkinstallrc ]; then
   echo "The checkinstallrc file was not found at:"
   echo "/etc/checkinstall/checkinstallrc"
   echo
   echo "Assuming default values."
else
# Get our default settings from the rc file
source /etc/checkinstall/checkinstallrc
fi


# Arguments parsing

CKNAME=`basename $0`
PARAMS=`getopt -a -n $CKNAME -o +d:DA:t:RShHy -l arch:,type:,si,showinstall::,ss,showslack::,deldoc::,delspec::,deldesc::,strip::,stripso::,gzman::,bk,backup::,autodoinst::,spec:,exclude:,pkgname:,pkgversion:,pkgrelease:,pkglicense:,pkggroup:,pkgsource:,pkgaltsource:,pakdir:,docdir:,provides:,maintainer:,dpkgflags:,rpmflags:,pkgarch:,umask:,newslack,help,nodoc,version,copyright,default -- "$@"`

[ $? -gt 0 ] && help_notice

eval set -- $PARAMS

while [ "$1" != "--" ]; do
   case "$1" in
      -h|-H|--help)
         usage;;
      -d)
         shift
         case `eval echo $1` in
            0) DEBUG=0;;
            1|'') DEBUG=1;;
            2) DEBUG=2;;
            *)
               boolean_usage "-D" $1
         esac
         ;;
      -A|--arch|--pkgarch)
         shift
         ARCHITECTURE=`eval echo $1`
         ;;
      --umask)
         shift
         CKUMASK=`eval echo $1`
         ;;
      --pkgname)
         shift
         NAME=`eval echo $1`
         ;;
      --pkgversion)
         shift
         VERSION=`eval echo $1`
         ;;
      --pkgrelease)
         shift
         RELEASE=`eval echo $1`
         ;;
      --pkglicense)
         shift
         LICENSE=`eval echo $1`
         ;;
      --pkggroup)
         shift
	 # note: we use PKG_GROUP instead of GROUP since (t)csh sets GROUP.
         PKG_GROUP=`eval echo $1`
         ;;
      --pkgsource)
         shift
         SOURCE=`eval echo $1`
         ;;
      --pkgaltsource)
         shift
         ALTSOURCE=`eval echo $1`
         ;;
      --pakdir)
         shift
         PAK_DIR=`eval echo $1`
         ;;
      --docdir)
         shift
         DOC_DIR=`eval echo $1`
         ;;
      --provides)
         shift
         PROVIDES=`eval echo $1`
         ;;
      --maintainer)
         shift
         MAINTAINER=`eval echo $1`
         ;;
      --dpkgflags)
         shift
         DPKG_FLAGS=`eval echo $1`
         ;;
      --rpmflags)
         shift
         RPM_FLAGS=`eval echo $1`
         ;;
      -t|--type)
         shift
         INSTYPE=`echo $1 | tr 'a-z' 'A-Z'`
         case `eval echo $INSTYPE` in
            RPM|R)
               INSTYPE=R;;
            SLACKWARE|S)
               INSTYPE=S;;
            DEBIAN|D)
               INSTYPE=D;;
            *)
               echo
               echo $1 is not a valid packaging system. Please use \'rpm\', \'slackware\' or \'debian\'
               echo 
               echo
               exit 1
          esac
          ;;
       -R)
          INSTYPE=R;;
       -S)
          INSTYPE=S;;
       -D)
          INSTYPE=D;;
       --si)
          SHOW_INSTALL=1;;
       --showinstall)
          shift
          case `eval echo $1` in
             1|yes|'')
                SHOW_INSTALL=1;;
             0|no)
                SHOW_INSTALL=0;;
             *)
                boolean_usage "--showinstall" $1
          esac
          ;;
       --ss)
          SHOW_SLACK_INSTALL=1;;
       --showslack)
          shift
          case `eval echo $1` in
             1|yes|'')
                SHOW_SLACK_INSTALL=1;;
             0|no)
                SHOW_SLACK_INSTALL=0;;
             *)
                boolean_usage "--showslack" $1
          esac
          ;;
       --deldoc)
          shift
          case `eval echo $1` in
             1|yes|'')
                DEL_DOCPAK=1;;
             0|no)
                DEL_DOCPAK=0;;
             *)
                boolean_usage "--deldoc" $1
          esac
          ;;
       --delspec)
          shift
          case `eval echo $1` in
             1|yes|'')
                DEL_SPEC=1;;
             0|no)
                DEL_SPEC=0;;
             *)
                boolean_usage "--delspec" $1
          esac
          ;;
       --deldesc)
          shift
          case `eval echo $1` in
             1|yes|'')
                DEL_DESC=1;;
             0|no)
                DEL_DESC=0;;
             *)
                boolean_usage "--deldesc" $1
          esac
          ;;
       --strip)
          shift
          case `eval echo $1` in
             1|yes|'')
                STRIP_ELF=1;;
             0|no)
                STRIP_ELF=0;;
             *)
                boolean_usage "--strip" $1
          esac
          ;;
       --stripso)
          shift
          case `eval echo $1` in
             1|yes|'')
                STRIP_SO_ELF=1
                ;;
             0|no)
                STRIP_SO_ELF=0;;
             *)
                boolean_usage "--stripso" $1
             esac
          ;;
       --gzman)
          shift
          case `eval echo $1` in
             1|yes|'')
                COMPRESS_MAN=1;;
             0|no)
                COMPRESS_MAN=0;;
             *)
                boolean_usage "--gzman" $1
          esac
          ;;
       --bk)
          BACKUP=1;;
       --backup)
          shift
          case `eval echo $1` in
             1|yes|'')
                BACKUP=1;;
             0|no)
                BACKUP=0;;
             *)
                boolean_usage "--backup" $1
          esac
          ;;
       --default)
          ACCEPT_DEFAULT=1;;
       -y)
          ACCEPT_DEFAULT=1;;
       --nodoc)
          NODOC=1;;
       --newslack)
          NEW_SLACK=1;;
       --spec)
	  shift
	  SPEC_PATH=`eval echo $1`
          ;;
       --copyright|--version)
          cat << EOF

Copyright (C) 2001 Felipe Eduardo Sanchez Diaz Duran <izto@asic-linux.com.mx>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

EOF
         exit 0;;
       --autodoinst)
          shift
          case `eval echo $1` in
             1|yes|'')
                AUTODOINST=1;;
             0|no)
                AUTODOINST=0;;
             *)
                boolean_usage "--autodoinst" $1
          esac
          ;;
      --exclude)
         shift
         EXCLUDE=`eval echo $1`
         ;;
   esac
   shift
done

# See if we have and install command
shift

[ "$1" = "" ] && set -- "make install"

# End of argument parsing

#############################################################################
                   # We initialize some useful variables #
                   #######################################

################################################################
# User-configurable variables were moved to the checkinstallrc #
# file which is probably found at /etc/checkinstall            #          
#                                                              #
#                  DO NOT modify them here!!                   #
################################################################


# Debug level
! [ "$DEBUG" ] && DEBUG=0

INSTALLWATCH_PREFIX="/usr"
INSTALLWATCH=${INSTALLWATCH_PREFIX}/bin/installwatch

# Default architecture type
! [ "$ARCHITECTURE" ] && ARCHITECTURE=""

# Default package type
! [ "$INSTYPE" ] && INSTYPE=""

# Interactively show the results of the install command
# This is useful for interactive installation commands
! [ "$SHOW_INSTALL" ] && SHOW_INSTALL=1

# Show Slackware package installation script while it runs? Again, useful if
# it's an interactive script
! [ "$SHOW_SLACK_INSTALL" ] && SHOW_SLACK_INSTALL=0

# Automatic deletion of "doc-pak" upon termination
! [ "$DEL_DOCPAK" ] && DEL_DOCPAK=1

# Automatic deletion of the spec file
! [ "$DEL_SPEC" ] && DEL_SPEC=1

# Automatic deletion of "description-pak" 
! [ "$DEL_DESC" ] && DEL_DESC=1


# Automatically strip all ELF binaries
! [ "$STRIP_ELF" ] && STRIP_ELF=1

# Don't automatically strip all ELF binaries
! [ "$STRIP_SO_ELF" ] && STRIP_SO_ELF=0

# Automatically compress all man pages
! [ "$COMPRESS_MAN" ] && COMPRESS_MAN=1

# Backup all files modified by the install command supplied by the user
! [ "$BACKUP" ] && BACKUP=1 

# Write description installing code to doinst.sh
! [ "$AUTODOINST" ] && AUTODOINST=1 

# We won't include anything under this directories
! [ "$EXCLUDE" ] && EXCLUDE=""

# Accept the default answer for all the questions
! [ "$ACCEPT_DEFAULT" ] && ACCEPT_DEFAULT=0

# Use the default doc directory of /usr/doc
! [ "$DOC_DIR" ] && DOC_DIR=/usr/doc

# Do not include common documentation
! [ "$NODOC" ] && NODOC=0

# Use the new (8.1+) Slackware description format
! [ "$NEW_SLACK" ] && NEW_SLACK=0

# Set the umask
! [ "$CKUMASK" ] && CKUMASK=0022

####################
# Non-configurable #
####################

# Existing configuration files are always preserved
[ -f description-pak ] && DEL_DESC=0
[ -d doc-pak ] && DEL_DOCPAK=0


DIRECTORIO_FUENTE=`pwd`
PKG_BASENAME="`basename $DIRECTORIO_FUENTE`"


MAKEPKG=/sbin/makepkg
INSTALLCMD="$@"
: ${INSTALLCMD:='make install'}


                      #################################
                      # Variable definition ends here #
#############################################################################



if [ ! -x $INSTALLWATCH ]; then
   echo
   echo "I can't find $INSTALLWATCH."
   echo
   echo "I can't continue. Either install installwatch or"
   echo "modify the INSTALLWATCH variable in this script,"
   echo "then run checkinstall again."
   echo
   exit 1
fi

echo

# If the user asked "--newslack" then we also set "-S"
[ $NEW_SLACK -gt 0 ] && INSTYPE="S"

# Set the umask. If not specified with "--umask" then we'll use 0022, a 
# standard, non-paranoid reasonable value.

if [ $DEBUG -gt 0 ] ;then 
   echo "debug: Setting umask => $CKUMASK"
fi
umask $CKUMASK


# Find a safe TMP_DIR

TMP_DIR=${BASE_TMP_DIR}/`awk 'BEGIN { srand(); for (i=1;i<21;i++) { a=95; while (a > 90 && a < 97) { a=65+int(50*rand())}; printf("%c", a) } }'`
[ -e "$TMP_DIR" ] && rm -rf $TMP_DIR
if [ -e "$TMP_DIR" ]; then 
   echo
   echo "My temp dir exists already."
   echo "This looks like a symlink attack!"
   echo 
   echo "*** Aborting"
   echo
   exit 1
fi

if [ "$TMP_DIR" = "$BASE_TMP_DIR" -o "$TMP_DIR" = "/" ]; then
  echo 
  echo "\"$TMP_DIR\" is an unacceptable value for the temp dir. Please"
  echo "edit the variable definition for $TMP_DIR and try again."
  echo
  echo "*** Aborting"
  echo
  exit 1
fi


mkdir $TMP_DIR
chmod 700 $TMP_DIR
RETURN=$?

if [ $RETURN -gt 0 ]; then
   echo
   echo "**** Failed to create temp dir!"
   echo "**** Do you have write permission for ${BASE_TMP_DIR}?"
   echo
   echo '**** Aborting installation.'
   echo
   exit  $RETURN
fi

BUILD_DIR=${TMP_DIR}/package
mkdir $BUILD_DIR

if [ $DEBUG -gt 0 ] ;then 
   echo "debug: The temporary directory is: [ $TMP_DIR ]"
   echo
fi


# 001117-BaP: We can create a default set of docs on the fly . . .
#   The list I've included should cover most packages adequately. If not,
#   then you should really create the package doc set *manually*


# Check if --nodoc was specified
if [ "$NODOC" = "0" ]; then 

if  ! [ -d "$DIRECTORIO_FUENTE/doc-pak" ]; then
    echo "The package documentation directory ./doc-pak does not exist."
    echo -n "Should I create a default set of package docs? "
    if  yorn ; then
        echo
        echo -n "Preparing package documentation..."
        mkdir doc-pak
         for f in ABOUT ABOUT-NLS ANNOUNCE AUTHORS *BUGS* CHANGES CONFIGURATION *COPYING* *COPYRIGHT* CREDITS ChangeLog Changelog CHANGELOG CONTRIBUTORS *FAQ* FEATURES FILES HACKING History HISTORY INSTALL* LICENSE LSM MANIFEST NEWS *README* *Readme* SITES *RELEASE* RELNOTES THANKS TIPS TODO VERSION CONFIGURATION* GPL License ; do
            if [ -f $f ]; then                                                 
                cp -a $f doc-pak
            fi
        done
        okfail
        DOCS=`ls doc-pak`
        if ! [ "$DOCS" ]; then
           echo
           echo "*** No known documentation files were found. The new package"
           echo "*** won't include a documentation directory."
           rm -rf doc-pak                 # If doc-pak is empty then we
        fi                                # don't need it
    fi                                    
    
fi

fi # End of NODOC



#
# We run the program installation from the source directory       
#

# Write a small script to run the install command. This way the LD_PRELOAD
# environment variable will be available to it, wich among other things
# will allow proper detection of new symbolic links and files created by
# subshells.

TMP_SCRIPT=${TMP_DIR}/installscript.sh

cat << EOF > $TMP_SCRIPT
#!/bin/sh

# Copy the documentation files           

if [ -d "$DIRECTORIO_FUENTE/doc-pak" ]; then             # Are there any files? 
   echo
   echo "Copying documentation directory..."
   mkdir -p "${DOC_DIR}/`basename $DIRECTORIO_FUENTE`"
   cd "$DIRECTORIO_FUENTE/doc-pak"
   tar -cpf - . | tar -f - -xvpC "${DOC_DIR}/`basename $DIRECTORIO_FUENTE`" &> /dev/null
   [ \$? -gt 0 ] && exit 1
   chown -R root.root "${DOC_DIR}/`basename $DIRECTORIO_FUENTE`"
fi

cd "$DIRECTORIO_FUENTE"
$INSTALLCMD

# Report success or failure
if [ \$? -eq 0 ]; then
   exit 0
else
   exit 1
fi

EOF

# No one needs to see what we are doing. It's safer this way.
chmod 700 $TMP_SCRIPT


echo
echo -n "Installing with \"$INSTALLCMD\"..."


# Are we going to do the backup?

if [ "$BACKUP" = "1" ]; then 
    export INSTALLWATCH_BACKUP_PATH=${TMP_DIR}/backup
else
    unset INSTALLWATCH_BACKUP_PATH
fi

export LD_PRELOAD=${INSTALLWATCH_PREFIX}/lib/installwatch.so

# Run the install command, showing the results interactively if we were asked
# to do so in the configuration section (see the SHOW_INSTALL switch above)
INSTALL_FAILED=0
if [ $SHOW_INSTALL -eq 0 ]; then
   $INSTALLWATCH -o /${TMP_DIR}/newfiles.tmp $TMP_SCRIPT &> /${TMP_DIR}/install.log
   okfail
   INSTALL_FAILED=$?
   unset INSTALLWATCH_BACKUP_PATH
else
   echo
   echo
   echo "========================= Installation results ==========================="
   $INSTALLWATCH -o /${TMP_DIR}/newfiles.tmp $TMP_SCRIPT 2>&1 
   if [ $? -eq 0 ]; then 
      echo
      echo "======================== Installation succesful =========================="
   else        
      INSTALL_FAILED=1
   fi
fi

unset INSTALLWATCH_BACKUP_PATH

unset LD_PRELOAD


VIEWLOG="n"
if [ $INSTALL_FAILED -gt 0 ]; then 
   echo
   echo "****  Installation failed. Aborting package creation."
   VIEWLOG="y"
fi

if [ $SHOW_INSTALL -eq 0 ]; then
   echo
   echo -n "Do you want to view the installation log file? "

   if  yorn $VIEWLOG ; then

      (echo
       echo ' ***************************************************************'
       echo '         Installation results. You can find them in'
       echo "       ${TMP_DIR}/install.log"
       echo ' ***************************************************************'
       echo
       cat /${TMP_DIR}/install.log)  | less
   fi
fi

if [ $INSTALL_FAILED -gt 0 ]; then 
   cleanup
   exit $INSTALL_FAILED
fi


#
# Extract the relevant files from the modified files list
#

# Find regular files first
cat /${TMP_DIR}/newfiles.tmp | cut -f 3 | egrep -v "^(/dev|$BASE_TMP_DIR|/tmp)" | sort -u > /${TMP_DIR}/newfiles

# symlinks are next
cat /${TMP_DIR}/newfiles.tmp | cut -f 4 | egrep -v "^(/dev|$BASE_TMP_DIR|/tmp)" | grep -v "#success" | sort -u  >> /${TMP_DIR}/newfiles

# OK, now we clean it up a bit
mv /${TMP_DIR}/newfiles.tmp /${TMP_DIR}/newfiles.installwatch
sort -u <  /${TMP_DIR}/newfiles | uniq  | while read file; do
   ! [ -d "$file" ] && [ -e "$file" ] && echo $file >> /${TMP_DIR}/newfiles.tmp
done

cp /${TMP_DIR}/newfiles.tmp /${TMP_DIR}/newfiles

# Don't include anything under the directories specified with "--exclude"

[ $DEBUG -gt 0 ] && echo "debug: EXCLUDE=$EXCLUDE"

for exclude in `echo $EXCLUDE | awk '{ split ($0, files,","); for(i=1; files[i] != ""; i++) print files[i];}'`; do
   if [ -d $exclude ]; then  # If it's a directory, ignore everything below it
      egrep -v "^$exclude" < /${TMP_DIR}/newfiles > /${TMP_DIR}/newfiles.tmp
   else
      if [ -f $exclude ]; then  # If it's a file, ignore just this one
         egrep -v "^$exclude$" < /${TMP_DIR}/newfiles > /${TMP_DIR}/newfiles.tmp
      fi
   fi
   cp /${TMP_DIR}/newfiles.tmp /${TMP_DIR}/newfiles
done


## Find any files created in `pwd`. We probably don't want them here

grep "`pwd`" ${TMP_DIR}/newfiles > /${TMP_DIR}/unwanted 
if [ $? = 0 ]; then 
   echo
   echo "Some of the files created by the installation are inside the build"
   echo "directory: `pwd`"
   echo
   echo "You probably don't want them to be included in the package,"
   echo "especially if they are inside your home directory."
   echo -n "Do you want me to list them? "
   if  yorn "n"; then
      less ${TMP_DIR}/unwanted
   fi
   echo -n "Should I exclude them from the package? (Saying yes is a good idea) "
   if  yorn ; then
      grep -v `pwd` ${TMP_DIR}/newfiles > /${TMP_DIR}/newfiles.tmp
      mv /${TMP_DIR}/newfiles.tmp /${TMP_DIR}/newfiles
   fi
fi
   
#
# Copy the files to the temporary directory
#

echo
echo -n "Copying files to the temporary directory..."

cd /

cat /${TMP_DIR}/newfiles | while read i; do 
   if ! [ -d "$i" -a -e "$i" ]; then 
      (tar -cpf - "$i"| tar -f - -xvpC ${BUILD_DIR}) >> /${TMP_DIR}/checkinstall.log 2>&1
   fi
done
okfail

##############################################################################
                            # Strip ELF binaries # 
                            ######################


#
# Note: The code in this section was taken from the brp-strip script included 
# in rpm-4.0.2, which is distributed under the GNU GPL. The copyright
# for this code belongs to its owner. See the file COPYING for details.
#

if [ $STRIP_ELF -eq 1 ]; then
   echo
   if [ $STRIP_SO_ELF -eq 1 ]; then
       echo -n "Striping ELF binaries and libraries..."
   else
       echo -n "Striping ELF binaries..."
   fi
   for f in `find ${BUILD_DIR} -type f \( -perm -0100 -or -perm -0010 -or -perm -0001 \)` ; do

       if [ $STRIP_SO_ELF -eq "0" -a "`file $f | grep -v ' shared object,'`" = "" ]; then
       #if this is a *.so* file and we don't have to strip it, then filter 'em
           continue
       fi
       if [ "`file $f | sed -n -e 's/^\(.*\):[  ]*ELF.*, not stripped/\1/p'`" = "" ]; then
           continue
       fi
       strip -p $f || :
   done
   okfail
fi
                             ###################
                             # End of striping #
##############################################################################



##############################################################################
                            # Compress man pages #
                            ######################

#
# Note: The code in this section was taken from the brp-compress script
# included in rpm-4.0.2, which is distributed under the GNU GPL. The
# copyright for this code belongs to its owner. See the file COPYING for
# details.
#

if [ $COMPRESS_MAN -eq 1 ]; then
 echo
 echo -n "Compressing man pages..."
 cd $BUILD_DIR
 
 # Compress man pages
 COMPRESS="gzip -9"
 COMPRESS_EXT=.gz
 
 for d in ./usr/local/man/man* ./usr/local/man/*/man* ./usr/local/info \
 	./usr/local/share/man/man* ./usr/local/share/man/*/man* \
 	./usr/local/share/info \
 	./usr/local/kerberos/man \
 	./usr/local/share/doc/*/man/man* ./usr/local/lib/*/man/man* \
 	././usr/man/man* ./usr/man/*/man* ./usr/info \
 	./usr/share/man/man* ./usr/share/man/*/man* ./usr/share/info \
 	./usr/kerberos/man ./usr/X11R6/man/man* ./usr/lib/perl5/man/man* \
 	./usr/share/doc/*/man/man* ./usr/lib/*/man/man*
 do
     [ -d $d ] || continue
     for f in `find $d -type f`
     do
         [ -f "$f" ] || continue
 	[ "`basename $f`" = "dir" ] && continue
 
 	case "$f" in
 	 *.Z) gunzip $f; b=`echo $f | sed -e 's/\.Z$//'`;;
 	 *.gz) gunzip $f; b=`echo $f | sed -e 's/\.gz$//'`;;
 	 *.bz2) bunzip2 $f; b=`echo $f | sed -e 's/\.bz2$//'`;;
 	 *) b=$f;;
 	esac
 
 	$COMPRESS $b </dev/null 2>/dev/null || {
 	    inode=`ls -i $b | awk '{ print $1 }'`
 	    others=`find $d -type f -inum $inode`
 	    if [ -n "$others" ]; then
 		for afile in $others ; do
 		    [ "$afile" != "$b" ] && rm -f $afile
 		done
 		$COMPRESS -f $b
 		for afile in $others ; do
 		    [ "$afile" != "$b" ] && ln $b$COMPRESS_EXT $afile$COMPRESS_EXT
 		done
 	    else
 		$COMPRESS -f $b
 	    fi
 	}
     done
 
     for f in `find $d -type l`
     do
 	l=`ls -l $f | awk '{ print $11 }' | sed -e 's/\.gz$//' -e 's/\.bz2$//' -e 's/\.Z$//'`
 	rm -f $f
 	b=`echo $f | sed -e 's/\.gz$//' -e 's/\.bz2$//' -e 's/\.Z$//'`
 	ln -sf $l$COMPRESS_EXT $b$COMPRESS_EXT
     done
 done
 okfail
fi

                       ################################
                       # End of man pages compressing #
##############################################################################


# Now we get the TRUE list of files from the directory listing (kind of)
# of the BUILD_DIR. This is the true one simply because THESE are the files
# that will actually get packaged.


echo
echo -n  "Building file list..."
rm ${TMP_DIR}/newfiles
cd $BUILD_DIR
tar -cpf -  . | tar -f - -t 2>&1 > ${TMP_DIR}/newfiles.tmp
okfail

# Remove the directories from the listing (RPM doesn't like directories listed
# inside the spec file)

cat ${TMP_DIR}/newfiles.tmp | while read line; do
   ! [ -d "${BUILD_DIR}/${line}" ] && echo /${line} >> ${TMP_DIR}/newfiles
done


#
# Find out the packaging method to use
#

if ! [ "$INSTYPE" ]; then
   echo
   echo "Please choose the packaging method you want to use."
   echo -n "Slackware [S], RPM [R] or Debian [D]? "
   read INSTYPE
fi
echo

       case $INSTYPE in
         S|s) 
            INSTYPE=S
            CK_SLACKWARE=1
            ;;
         R|r)
            INSTYPE=R
            CK_REDHAT=1
            ;;
         D|d)
            INSTYPE=D
            CK_DEBIAN=1
            ;;
         *)
           echo Invalid type.
           exit 1
           ;;
       esac


## Do we have a package description file? If we don't then 
## we should write one

cd "$DIRECTORIO_FUENTE"


if [ $ACCEPT_DEFAULT -eq 0 ]; then  # If --default is given, we skip this 
 if ! [ -r description-pak ]; then
   DESCRIPTION="Package created with checkinstall $CHECKINSTALL_VERSION"
   echo
   echo -n "Please write a description for the package."

   # If we selected Slackware, then give the pkgtool warning

   if [ "$CK_SLACKWARE" ]; then 
      echo " Remember that pkgtool shows"
      echo -n  "only the first one when listing packages so make that one descriptive."
   fi
   echo
   echo "End your description with an empty line or EOF."
   while [ "$DESCRIPTION" ]; do
      echo -n ">> " 
   INSTYPE=`echo $INSTYPE | tr a-z A-Z`
      read DESCRIPTION
      [ "$DESCRIPTION" ] && echo "$DESCRIPTION" >> description-pak
   done
 fi
fi

# We still don't have it??
! [ -r description-pak ] && echo "Package created with checkinstall $CHECKINSTALL_VERSION" > description-pak


# Warn the user if we're using the new Slackware description format
# and the description is bigger than 11 lines

if [ $NEW_SLACK -gt 0 ]; then
   if [ `wc -l < description-pak` -gt 11 ]; then
      echo
      echo "Warning: Your package description is bigger than 11 lines."
      echo "Warning: The Slackware 8.1+ pkgtools might not like it."
      echo
   fi
fi



########## Acquire some info about the package ##########


# Figure out what kind of machine are we running on

if ! [ "$ARCHITECTURE" ]; then
   ARCHITECTURE=`uname -m`
   echo $ARCHITECTURE | grep -e "i[3456]86" &> /dev/null
   [ $? -eq 0 ] && ARCHITECTURE=i386  # Arch will be "i386" for any of
fi                                    # i386, i486, i586 or i686.
                                      # You can change this with "--arch"

   # Fix the PowerPC architecture description if we're on Debian
   
   if [ "$CK_DEBIAN" = "1" ] && [ "$ARCHITECTURE" = "ppc" ]; then
      ARCHITECTURE="powerpc"
   fi
      

   OPTION=junk
   while [ "$OPTION" ]; do

      # Some sanity checks
      ! [ "$SUMMARY" ] && SUMMARY=`head -1 description-pak`
      ! [ "$NAME" ] && NAME=`echo "$PKG_BASENAME" | rev | cut -f2- -d"-" | rev`

      if [ "$CK_DEBIAN" ]; then       # Convert name to lower case
         echo $NAME | grep -e "[A-Z]" &> /dev/null
         if [ $? -eq 0 ]; then
            echo
            echo "*** Warning: The package name \"${NAME}\" contains upper case"
            echo "*** Warning: letters. dpkg might not like that so I changed"
            echo "*** Warning: them to lower case."
            NAME=`echo $NAME | tr 'A-Z' 'a-z'`
         fi
      fi


      ! [ "$VERSION" ] && VERSION=`echo "$PKG_BASENAME" | rev | cut -f1 -d"-" | rev`
      if [ "$CK_DEBIAN" ]; then       # Check for a valid version for dpkg
         echo $VERSION | grep -e "[0-9]" &> /dev/null
         if [ $? -gt 0 ]; then
            echo
            echo "*** Warning: The package version \"${VERSION}\" does not"
            echo "*** Warning: contain any digits. dpkg might not like that."
         fi
      fi
      ! [ "$RELEASE" ] && RELEASE="1"
      ! [ "$LICENSE" ] && LICENSE="GPL"
      ! [ "$PKG_GROUP" ] && [ "$CK_REDHAT" ] && PKG_GROUP="Applications/System"
      ! [ "$PKG_GROUP" ] && [ "$CK_DEBIAN" ] && PKG_GROUP="checkinstall"
      ! [ "$PKG_GROUP" ] && [ "$CK_SLACKWARE" ] && PKG_GROUP="Applications/System"

      ! [ "$ARCHITECTURE" ] && ARCHITECTURE="i386"
      ! [ "$SOURCE" ] && SOURCE="$PKG_BASENAME"
      ! [ "$ALTSOURCE" ] && ALTSOURCE=""
      ! [ "$PROVIDES" ] && PROVIDES="$NAME"
      # bond: added this so it is easy to change the Maintainer: field
      # just by setting the MAINTAINER environment variable
      ! [ "$MAINTAINER" ] && MAINTAINER=${LOGNAME:-root}@`hostname -f`
      
      
      echo
      echo "This package will be built according to these values: "
      echo
      # Debian maintainers use the Maintainer: field and want to be able
      # to change it. If we are not on debian we don't need the field...
      [ "$CK_DEBIAN" ] && echo "0 -  Maintainer: [ $MAINTAINER ]"

      echo "1 -  Summary: [ $SUMMARY ]"
      echo "2 -  Name:    [ $NAME ]"
      echo "3 -  Version: [ $VERSION ]"
      echo "4 -  Release: [ $RELEASE ]"
      echo "5 -  License: [ $LICENSE ]"
      echo "6 -  Group:   [ $PKG_GROUP ]"
      echo "7 -  Architecture: [ $ARCHITECTURE ]"
      echo "8 -  Source location: [ $SOURCE ]"
      echo "9 -  Alternate source location: [ $ALTSOURCE ]"
      [ "$CK_REDHAT" ] && echo "10 - Provides: [ $PROVIDES ]"
      echo
      echo -n "Enter a number to change any of them or press ENTER to continue: "
      if [ $ACCEPT_DEFAULT -eq 1 ]; then
         echo
         OPTION=""
      else
         read OPTION
      fi

      case $OPTION in
         1)
            echo "Enter new summary: "
            echo -n ">> "
            read SUMMARY
            ;;
         2)
            echo "Enter new name: "
            echo -n ">> "
            read NAME
            ;;
         3)
            echo "Enter new version: "
            echo -n ">> "
            read VERSION
            ;;
         4)
            echo "Enter new release number: "
            echo -n ">> "
            read RELEASE
            ;;
         5)
            echo "Enter the license type: "
            echo -n ">> "
            read LICENSE
            ;;
         6)
            echo "Enter the new software group: "
            echo -n ">> "
            read PKG_GROUP
            ;;
         7)
            echo "Enter the architecture type: "
            echo -n ">> "
            read ARCHITECTURE
            ;;
         8)
            echo "Enter the source location: "
            echo -n ">> "
            read SOURCE
            ;;
         9)
            echo "Enter the alternate source location: "
            echo -n ">> "
            read ALTSOURCE
            ;;
         0) # bond: again, debian-specific
	    [ "CK_DEBIAN" ] && {
            echo "Enter the maintaner's name and e-mail address: "
            echo -n ">> "
            read MAINTAINER
	    }
            ;;
         10)
            # 01-12-06 UKo: new feature
            echo "Enter the provided features: "
            echo -n ">> "
            read PROVIDES
            ;;
 
      esac
   done
   
   # The PKG_BASENAME is adjusted to reflect any changes
   # in the NAME and VERSION of the package
   # NOTE: on debian we use NAME alone, instead - see below

   PKG_BASENAME="$NAME-$VERSION" 

FAILED=0

case $INSTYPE in

##############################################################################
                    # Create Slackware compatible tarball #
                    #######################################


s|S)  


echo
echo "********************************************"
echo "**** Slackware package creation selected ***"
echo "********************************************"
echo

# The new Slackware naming scheme
SLACK_PKG_BASENAME="${PKG_BASENAME}-${ARCHITECTURE}-${RELEASE}"

FAILED=0

# Verify that we have the "installpkg" command in our path

INSTALLPKG_PATH=`which installpkg 2> /dev/null`

if ! [ -x "$INSTALLPKG_PATH" ]; then
   echo
   echo "*** The \"installpkg\" program is not in your PATH!"
   echo
   echo "*** Slackware package creation aborted"
   FAILED=1
fi
   
if ! [ $FAILED -gt 0 ]; then

# Create the Slackware installation script

echo -n "Preparing Slackware install directory..."
mkdir -p ${BUILD_DIR}/install
touch ${BUILD_DIR}/install/doinst.sh
okfail

echo
echo -n "Writing package description..."

# If we're building for Slackware 8.1+, then we use the new description
# file format

if [ $NEW_SLACK -gt 0 ]; then

cat << EOF > ${BUILD_DIR}/install/slack-desc
# HOW TO EDIT THIS FILE:
# The "handy ruler" below makes it easier to edit a package description.  Line
# up the first '|' above the ':' following the base package name, and the '|' on
# the right side marks the last column you can put a character in. You must make
# exactly 11 lines for the formatting to be correct.  It's also customary to
# leave one space after the ':'.

EOF

# Calculate the spaces before the "handy-ruler"
HR_SPACES=`echo $NAME | wc -c| awk '{ for (i=1;substr ($0,i,1) ~ /[[:blank:]]/ ;i++); print substr ($0,i);}'`


awk -v S=$HR_SPACES 'BEGIN {ORS=""; for (i=1; i < S; i++) print " ";}' >> ${BUILD_DIR}/install/slack-desc

echo "|-----handy-ruler------------------------------------------------------|" >> ${BUILD_DIR}/install/slack-desc


# Add the prefixed description
 cat description-pak | while read line; do
    echo "$NAME: $line" >> ${BUILD_DIR}/install/slack-desc
 done

okfail

# End of NEW_SLACK block

else 

#
# Generate the description-installing doinst.sh
#

if [ $AUTODOINST -eq 1 ]; then
   echo "PACKAGE DESCRIPTION:" > ${BUILD_DIR}/install/description
   cat description-pak | while read line; do
      echo $line >> ${BUILD_DIR}/install/description
   done
   okfail 

   echo
   echo -n "Writing Slackware install script..."
   cat << EOF >> ${BUILD_DIR}/install/doinst.sh
# 
# doinst.sh, auto-generated by checkinstall-${CHECKINSTALL_VERSION}
#

echo 
cat /install/description

sed '/PACKAGE LOCATION/r /install/description' < "/var/log/packages/$SLACK_PKG_BASENAME" > description.tmp
mv description.tmp "/var/log/packages/${SLACK_PKG_BASENAME}"
rm /install/description

EOF
   okfail
fi

fi # End of description creation

# If we have a Slackware install script already, add it to this one
if [ -f install-pak ]; then
   echo -n "Appending your script to the main install script..."
   cat install-pak >> ${BUILD_DIR}/install/doinst.sh
   okfail
fi


echo
echo -n "Creating package ${SLACK_PKG_BASENAME}..."

cd $BUILD_DIR
chmod 755 $BUILD_DIR


$MAKEPKG -l y -c n "${SLACK_PKG_BASENAME}.tgz" &> /dev/null
okfail
mv "${SLACK_PKG_BASENAME}.tgz" "$DIRECTORIO_FUENTE"

#
# Install the package to register it in Slackware's installed packages list    
# so we can list it's contents with pkgtool o remove it with removepkg
#

# Go back to where we started
cd "$DIRECTORIO_FUENTE"

echo

if [ $SHOW_SLACK_INSTALL -eq 0 ]; then
   echo -n "Installing package..."
   installpkg "${SLACK_PKG_BASENAME}.tgz" &> ${TMP_DIR}/slackinstall.log
   okfail
   [ $? -gt 0 ] && FAILED=1

else
   echo ========================= Installation results ===========================
   echo
   installpkg "${SLACK_PKG_BASENAME}.tgz" 
   if [ $? -gt 0 ]; then
      FAILED=1
   else
      echo
      echo ======================== Installation succesful ==========================
   fi
fi

if [ $FAILED -eq 1 ]; then
   echo
   echo "*** Failed to install the package"
   echo
   if [ $SHOW_SLACK_INSTALL -eq 0 ]; then
      echo -n "Do you want to see the log file? " 
      if yorn ; then
         less ${TMP_DIR}/slackinstall.log
         cleanup
         exit 1
      fi
   fi
fi
 

PKG_LOCATION="${DIRECTORIO_FUENTE}/${SLACK_PKG_BASENAME}.tgz"
REMOVESTRING="removepkg ${SLACK_PKG_BASENAME}"

fi
;;


                       #################################
                       # End Slackware package section #
##############################################################################


##############################################################################
                          # RPM package installation #
                          ############################


r|R)

echo
echo "**************************************"
echo "**** RPM package creation selected ***"
echo "**************************************"

FAILED=0

# Verify that we have the rpm command in our path

RPM_PATH=`which rpm 2> /dev/null`

if ! [ -x "$RPM_PATH" ]; then
   echo
   echo "*** The \"rpm\" program is not in your PATH!"
   echo
   echo "*** RPM package creation aborted"
   FAILED=1
fi
   
if ! [ $FAILED -gt 0 ]; then

# Identify the rpm version

RPM_VERSION=`rpm --version | awk '{ print $3 }'`
RPM_MAJOR_VERSION=`echo $RPM_VERSION | cut -f1 -d"."`
RPM_MINOR_VERSION=`echo $RPM_VERSION | cut -f2 -d"."`
RPM_PATCH_LEVEL=`echo $RPM_VERSION | cut -f3 -d"."`

if [ "$RPM_PATCH_LEVEL" = "" ]; then 
   RPM_PATCH_LEVEL=0
fi


if [ $DEBUG -gt 0 ]; then
   echo "debug: RPM_VERSION=${RPM_VERSION}"
   echo "debug: RPM_MAJOR_VERSION=$RPM_MAJOR_VERSION"
   echo "debug: RPM_MINOR_VERSION=$RPM_MINOR_VERSION"
   echo "debug: RPM_PATCH_LEVEL=$RPM_PATCH_LEVEL"
fi

# AFAIK, the only rpm versions that accept
# "--target=arch" instead of "--target arch"
# are 3.x < version < 4.0.3

if [ $RPM_MAJOR_VERSION -eq 4 -a $RPM_PATCH_LEVEL -lt 3 ]; then
   RPM_TARGET_FLAG="--target="
else
   RPM_TARGET_FLAG="--target "
fi

# Find out the RPM source directory path

if ! [ "$RPMSOURCEDIR" ]; then
   RPMSOURCEDIR="NOT-FOUND"
   for directory in packages OpenLinux redhat RedHat rpm RPM "" ; do
    [ -d /usr/src/${directory}/SOURCES ] && RPMSOURCEDIR="/usr/src/${directory}"
   done
fi

[ $DEBUG -gt 0 ] && echo "debug: RPMSOURCEDIR=$RPMSOURCEDIR"


while ! [ -d "$RPMSOURCEDIR/SOURCES" ]; do
   echo
   echo "$RPMSOURCEDIR has no SOURCES directory. Please write the path to"
   echo -n "the RPM source directory tree: "
   read RPMSOURCEDIR
   ! [ "$RPMSOURCEDIR" ] && RPMSOURCEDIR="NOT-FOUND"
done

   
# We'll write a basic spec file

if ! [ -f "$PKG_BASENAME.spec" ]; then

# If the buildroot path has spaces then we'll use the BUILD_DIR instead.
# rpm can't have a buildroot path with spaces in it (Bug?)
#
# This is obviously a hack, I hope we can do it the right way when rpm is
# fixed.

if ( echo $DIRECTORIO_FUENTE | grep " " &> /dev/null ); then
   BROOTPATH=$BUILD_DIR
else
   BROOTPATH="${DIRECTORIO_FUENTE}/buildroot"
fi

# Here comes the .spec file:

   cat > "$PKG_BASENAME.spec" << EOF
Summary:   $SUMMARY
Name:      $NAME
Version:   $VERSION
Release:   $RELEASE
Copyright: $LICENSE
Packager:  checkinstall-$CHECKINSTALL_VERSION
Group:     $PKG_GROUP          
BuildRoot: $BROOTPATH
Provides:  $PROVIDES

%description
EOF
   cat description-pak >> "$PKG_BASENAME.spec"

   cat >> "$PKG_BASENAME.spec" << EOF

%files
EOF

# Append the file list to the .spec file
cat ${TMP_DIR}/newfiles | while read line; do 
                             echo "\"${line}\""  >> "$PKG_BASENAME.spec"
                          done
fi

BUILDROOT=`egrep '^[Bb]uild[Rr]oot' < "$PKG_BASENAME.spec" | cut -f2 -d:| sed 's/^ *//g'| sed 's/ *$//g'` # The sed commands remove leading/trailing whitespaces

# We make sure that we have a valid RELEASE number

! [ "$RELEASE" ] && RELEASE=`egrep '^Release:' < "$PKG_BASENAME.spec"|cut -f2 -d: | awk '{ for (i=1;substr ($0,i,1) ~ /[[:blank:]]/ ;i++); print substr ($0,i); }'`

[ $DEBUG -gt 0 ] && echo "debug: BUILDROOT=$BUILDROOT"

! [ -d "$BUILDROOT" ] &&  ln -s "$BUILD_DIR" "$BUILDROOT"

# We make sure that the architecture directory exists

! [ -d ${RPMSOURCEDIR}/RPMS/${ARCHITECTURE} ] && mkdir -p ${RPMSOURCEDIR}/RPMS/${ARCHITECTURE}


mkdir "${TMP_DIR}/$PKG_BASENAME"
cd $TMP_DIR
tar -cz "$PKG_BASENAME" -f "${RPMSOURCEDIR}/SOURCES/${PKG_BASENAME}.tgz"
rm -rf "${TMP_DIR}/$PKG_BASENAME"
cd "$DIRECTORIO_FUENTE"

echo
echo -n "Building RPM package..."
rpmbuild -bb ${RPM_TARGET_FLAG}${ARCHITECTURE} "$PKG_BASENAME.spec" &> ${TMP_DIR}/rpmbuild.log
okfail

if [ $? -gt 0 ]; then
   echo
   echo "*** Failed to build the package"
   echo
   echo -n "Do you want to see the log file? " 
   if yorn ; then
      less ${TMP_DIR}/rpmbuild.log
   fi
   FAILED=1
fi
 
RPMPKG="${RPMSOURCEDIR}/RPMS/${ARCHITECTURE}/${PKG_BASENAME}-${RELEASE}.${ARCHITECTURE}.rpm"

# Check for the old RPMFLAGS
if [ "$RPMFLAGS" ]; then
   echo
   echo "Warning: the use of RPMFLAGS is deprecated."
   echo "Warning: You should now use RPM_FLAGS,"
   echo "Warning: please update your checkinstallrc file."
fi

if ! [ $FAILED -gt 0 ]; then 
   echo
   echo -n "Installing RPM package..."
   rpm -U $RPM_FLAGS ${RPMPKG} &>  ${TMP_DIR}/rpminstall.log
   okfail
   if [ $? -gt 0 ]; then
      echo
      echo "*** Failed to install the package"
      echo
      echo -n "Do you want to see the log file? " 
      if yorn ; then
         less ${TMP_DIR}/rpminstall.log
      fi
      FAILED=1
   fi
fi
   
if ! [ $FAILED -gt 0 ]; then
   PKG_LOCATION=$RPMPKG
   REMOVESTRING="rpm -e ${PKG_BASENAME}-${RELEASE}"
fi


fi  # End of the "no rpm in the path" if

;;

                       #################################
                       #    End RPM package section    #
##############################################################################



##############################################################################
                        # Debian  package installation #
                        ################################


d|D)

# as we said before:
PKG_BASENAME=$NAME
# maybe PKG_BASENAME should be defined locally for all the install
# types, and not only on debian...

echo
echo "*****************************************"
echo "**** Debian package creation selected ***"
echo "*****************************************"

FAILED=0


# Verify that we have the dpkg command in our path

DPKG_PATH=`which dpkg 2> /dev/null`

if ! [ -x "$DPKG_PATH" ]; then
   echo
   echo "*** The \"dpkg\" program is not in your PATH!"
   echo
   echo "*** Debian package creation aborted"
   FAILED=1
fi
   
if ! [ $FAILED -gt 0 ]; then

cd "$DIRECTORIO_FUENTE"

# We'll write a basic Debian control file


mkdir $BUILD_DIR/DEBIAN

cat << EOF >> $BUILD_DIR/DEBIAN/control
Package: $PKG_BASENAME
Priority: extra
Section: $PKG_GROUP
Installed-Size: `du -s $BUILD_DIR | awk '{print $1}'`
Maintainer: $MAINTAINER
Architecture: $ARCHITECTURE
Version: ${VERSION}-${RELEASE}
Description: $SUMMARY
EOF

# Add the description
cat "$DIRECTORIO_FUENTE/description-pak"| egrep -v "$SUMMARY|^[ 	]*$" | while read line; do
   echo " "$line >> $BUILD_DIR/DEBIAN/control
done


# The package will be saved here:
DEBPKG="${DIRECTORIO_FUENTE}/${NAME}_${VERSION}-${RELEASE}_${ARCHITECTURE}.deb"
# This one is for 2.2 "Potato" (or older) style packages
#DEBPKG="${DIRECTORIO_FUENTE}/${NAME}_${VERSION}-${RELEASE}.deb"

if [ $DEBUG -gt 0 ]; then
  echo
  echo debug: PKG_BASENAME=${PKG_BASENAME}
  echo debug: BUILD_DIR=${BUILD_DIR}
  echo debug: DEBPKG=${DEBPKG}
  echo debug: dpkg command:
  echo "   \"dpkg-deb -b $BUILD_DIR $DEBPKG &> ${TMP_DIR}/dpkgbuild.log\""
fi
echo
echo -n "Building Debian package..."
dpkg-deb -b $BUILD_DIR "$DEBPKG" &> ${TMP_DIR}/dpkgbuild.log
okfail
      
if [ $? -gt 0 ]; then
   echo
   echo "*** Failed to build the package"
   echo
   echo -n "Do you want to see the log file? " 
   if yorn ; then
      less ${TMP_DIR}/dpkgbuild.log
   fi
   FAILED=1
fi


if ! [ $FAILED -gt 0 ]; then
   echo
   echo -n "Installing Debian package..."
   dpkg -i $DPKG_FLAGS "$DEBPKG" &>  ${TMP_DIR}/dpkginstall.log
   okfail
   if [ $? -gt 0 ]; then
      echo
      echo "*** Failed to install the package"
      echo
      echo -n "Do you want to see the log file? "
      if yorn ; then
         less ${TMP_DIR}/dpkginstall.log
      fi
      FAILED=1
   fi
fi
 
if ! [ $FAILED -gt 0 ]; then
   PKG_LOCATION=$DEBPKG
   REMOVESTRING="dpkg -r ${PKG_BASENAME}"
fi


fi

;;


                       ################################
                       #  End Debian package section  #
##############################################################################


*)
   echo
   echo "*** No method was selected, I won't build any package."
   echo "*** The installation command \"$INSTALLCMD\""
   echo "*** has already been executed."
   restore_backup
   FAILED=1
;;

esac

# If we have a package repository set, move the package there

if ! [ $FAILED -gt 0 ]; then

   if [ "$PAK_DIR" ]; then
      if ! [ -d "$PAK_DIR" ]; then
         echo
         echo "The package storage directory [ $PAK_DIR ]"
         echo -n "doesn't exist. Do you want to create it?"
         if yorn ; then
            echo
            echo -n "Creating package storage directory..."
            mkdir -p "$PAK_DIR" &> ${TMP_DIR}/mkpakdir.log
            okfail 
            if [ $? -gt 0 ]; then
               echo 
               echo "*** Unable to create $PAK_DIR"
               echo "*** `cat ${TMP_DIR}/mkpakdir.log`"
               echo
            fi
         fi
      fi
      if [ -d "$PAK_DIR" ]; then 
         echo
         echo -n "Transferring package to $PAK_DIR..."
         mv $PKG_LOCATION ${PAK_DIR} &> $TMP_DIR/transfer.log
         okfail
         if [ $? -gt 0 ]; then
            echo
            echo "*** Transfer failed: `cat $TMP_DIR/transfer.log`"
            echo
         else
            # Update the package location
            PKG_LOCATION=${PAK_DIR}/`basename $PKG_LOCATION`
         fi
      else 
         echo
         echo "There's no package storage directory, the package"
         echo "will be stored at the default location."
      fi
   fi
fi

#
# Remove trash from TMP_DIR
#

echo 
echo -n "Erasing temporary files..."

# Preserve the Debian control file if debug is on
if [ $DEBUG -gt 0 ]; then
   if [ -d ${BUILD_DIR}/DEBIAN ]; then
       mv ${BUILD_DIR}/DEBIAN $TMP_DIR
   fi
fi

[ $DEBUG -lt 2 ] && rm -rf ${BUILD_DIR}
rm -f checkinstall-debug*
rm -f "$BUILDROOT"
okfail


# Delete doc-pak directory
if [ $DEL_DOCPAK -gt 0 ]; then
   echo
   echo -n "Deleting doc-pak directory..."
   rm -rf doc-pak
   okfail
fi


# Preserve the spec file if debugging is on
[ $DEBUG -gt 0 ] && [ -f "${PKG_BASENAME}.spec" ] && cp "${PKG_BASENAME}.spec" $TMP_DIR

# Delete spec file
 [ $DEL_SPEC -gt 0 ] && rm -f "$PKG_BASENAME.spec"

# Delete the package description file
 [ $DEL_DESC -gt 0 ] && rm -f description-pak

# If we have a backup, pack it up

ls ${TMP_DIR}/backup/* &> /dev/null
if [ $? -eq 0 ]; then
   cd ${TMP_DIR}/backup
   echo
   echo -n "Writing backup package..."
   tar -cpf - . | gzip -9 > "${DIRECTORIO_FUENTE}/backup-`date +%m%d%Y%H%M`-pre-${PKG_BASENAME}.tgz"
   okfail
fi


if [ $DEBUG -eq 0 ]; then
   echo
   echo -n "Deleting temp dir..."
   rm -rf ${TMP_DIR}
   okfail
   echo
else
   echo
   echo -n "Building debug information package..."
   cd ${TMP_DIR}
   echo `uname -a` > sysinfo
   echo `rpm --version` >> sysinfo
   tar -cpzvf "${DIRECTORIO_FUENTE}/checkinstall-debug.$$.tgz" * &> /dev/null
   okfail
fi


if ! [ $FAILED -gt 0 ]; then
   echo
   echo '**********************************************************************'
   echo
   echo " Done. The new package has been installed and saved to"
   echo " $PKG_LOCATION"
   echo
   echo " You can remove it from your system anytime using: "
   echo
   echo "      $REMOVESTRING"
   echo
   echo '**********************************************************************'
   echo
fi




