pkgfs.sh

   1 #!/bin/sh
   2 #
   3 # pkgfs - A simple, minimal, fast and uncomplete build package system.
   4 #
   5 #-
   6 # Copyright (c) 2008 Juan Romero Pardines.
   7 # All rights reserved.
   8 #
   9 # Redistribution and use in source and binary forms, with or without
  10 # modification, are permitted provided that the following conditions
  11 # are met:
  12 # 1. Redistributions of source code must retain the above copyright
  13 #    notice, this list of conditions and the following disclaimer.
  14 # 2. Redistributions in binary form must reproduce the above copyright
  15 #    notice, this list of conditions and the following disclaimer in the
  16 #    documentation and/or other materials provided with the distribution.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 #-
  29 #
  30 # TODO
  31 #       - Implement support for packages that need personalized installation.
  32 #       - Implement a chroot target that builds packages as root on it, for
  33 #         packages that need it (setuid, setgid).
  34 #       - More robust and fast dependency checking.
  35 #       - Multiple distfiles in a package, personalized stuff to unpack them.
  36 #       - Multiple URLs to download source distribution files, aliases, etc.
  37 #
  38 # Default path to configuration file, can be overriden
  39 # via the environment or command line.
  40 #
  41 : ${PKGFS_CONFIG_FILE:=/usr/local/etc/pkgfs.conf}
  42
  43 : ${progname:=$(basename $0)}
  44 : ${topdir:=$(/bin/pwd -P 2>/dev/null)}
  45 : ${fetch_cmd:=/usr/bin/ftp -a}
  46 : ${cksum_cmd:=/usr/bin/cksum -a rmd160}
  47 : ${awk_cmd:=/usr/bin/awk}
  48 : ${mkdir_cmd:=/bin/mkdir -p}
  49 : ${tar_cmd:=/usr/bin/tar}
  50 : ${rm_cmd:=/bin/rm}
  51 : ${mv_cmd:=/bin/mv}
  52 : ${cp_cmd:=/bin/cp}
  53 : ${sed_cmd=/usr/bin/sed}
  54 : ${grep_cmd=/usr/bin/grep}
  55 : ${gunzip_cmd:=/usr/bin/gunzip}
  56 : ${bunzip2_cmd:=/usr/bin/bunzip2}
  57 : ${patch_cmd:=/usr/bin/patch}
  58 : ${find_cmd:=/usr/bin/find}
  59 : ${file_cmd:=/usr/bin/file}
  60 : ${ln_cmd:=/bin/ln}
  61 : ${chmod_cmd:=/bin/chmod}
  62 : ${db_cmd:=/usr/bin/db -q}
  63 : ${chmod_cmd:=/bin/chmod}
  64 : ${touch_cmd:=/usr/bin/touch}
  65
  66 : ${xstow_args:=-ap}
  67 : ${xstow_ignore_files:=perllocal.pod}  # XXX For now ignore them.
  68
  69 set_defvars()
  70 {
  71         # Directories
  72         : ${PKGFS_TEMPLATESDIR:=$PKGFS_DISTRIBUTIONDIR/templates}
  73         : ${PKGFS_DEPSDIR:=$PKGFS_DISTRIBUTIONDIR/dependencies}
  74         : ${PKGFS_BUILD_DEPS_DB:=$PKGFS_DEPSDIR/build-depends.db}
  75         : ${PKGFS_TMPLHELPDIR:=$PKGFS_DISTRIBUTIONDIR/helper-templates}
  76         : ${PKGFS_REGPKG_DB:=$PKGFS_DESTDIR/.pkgfs-registered-pkgs.db}
  77
  78         local DDIRS="PKGFS_DEPSDIR PKGFS_TEMPLATESDIR PKGFS_TMPLHELPDIR"
  79         for i in ${DDIRS}; do
  80                 eval val="\$$i"
  81                 if [ ! -d "$val" ]; then
  82                         echo "**** ERROR: cannot find $i, aborting ***"
  83                         exit 1
  84                 fi
  85         done
  86 }
  87
  88 usage()
  89 {
  90         cat << _EOF
  91 $progname: [-C] [-c <config_file>] <target> [package_name]
  92
  93 Targets:
  94         build           Builds a package, only build phase is done.
  95         configure       Configure a package, only configure phase is done.
  96         extract         Extract distribution file(s) into build directory.
  97         fetch           Download distribution file(s).
  98         info            Show information about <package_name>.
  99         install-destdir build + configure + install into destdir.
 100         install         Same than \`install-destdir´ but also stows package.
 101         list            Lists all currently \`stowned´ packages.
 102         remove          Remove package completely (unstow + remove data)
 103         listfiles       Lists files installed from <package_name>.
 104         stow            Create links in master directory.
 105         unstow          Remove links in master directory.
 106
 107 Options:
 108         -C      Do not remove build directory after successful installation.
 109         -c      Path to global configuration file:
 110                 if not specified /usr/local/etc/pkgfs.conf is used.
 111 _EOF
 112         exit 1
 113 }
 114
 115 check_path()
 116 {
 117         eval local orig="$1"
 118
 119         case "$orig" in
 120         /)
 121                 ;;
 122         /*)
 123                 orig="${orig%/}"
 124                 ;;
 125         *)
 126                 orig="$topdir/${orig%/}"
 127                 ;;
 128         esac
 129
 130         path_fixed="$orig"
 131 }
 132
 133 run_file()
 134 {
 135         local file="$1"
 136
 137         check_path "$file"
 138         . $path_fixed
 139 }
 140
 141 #
 142 # This function merges two GNU info dirs into one and puts the result
 143 # into PKGFS_MASTERDIR/share/info/dir.
 144 #
 145 merge_infodir_tmpl()
 146 {
 147         local pkgname="$1"
 148         local merge_info_cmd="$PKGFS_MASTERDIR/bin/merge-info"
 149
 150         [ -z "$pkgname" -o ! -r "$PKGFS_MASTERDIR/share/info/dir" \
 151              -o ! -r "$PKGFS_DESTDIR/$pkgname/share/info/dir" ] && return 1
 152
 153         $merge_info_cmd -d $PKGFS_MASTERDIR/share/info/dir      \
 154                 $PKGFS_DESTDIR/$pkgname/share/info/dir -o       \
 155                 $PKGFS_MASTERDIR/share/info/dir.new
 156         if [ $? -ne 0 ]; then
 157                 echo -n "*** WARNING: there was an error merging info dir from"
 158                 echo " $pkgname, aborting ***"
 159                 return 1
 160         fi
 161
 162         $mv_cmd -f $PKGFS_MASTERDIR/share/info/dir.new \
 163                 $PKGFS_MASTERDIR/share/info/dir
 164 }
 165
 166 #
 167 # Shows info about a template.
 168 #
 169 info_tmpl()
 170 {
 171         echo "pkgname:  $pkgname"
 172         echo "version:  $version"
 173         for i in "${distfiles}"; do
 174                 [ -n "$i" ] && echo "distfile:  $i"
 175         done
 176         echo "URL:              $url"
 177         echo "maintainer:       $maintainer"
 178         [ -n $checksum ] && echo "checksum:     $checksum"
 179         echo "build_style:      $build_style"
 180         echo "short_desc:       $short_desc"
 181         echo "$long_desc"
 182         echo
 183         check_build_depends_pkg $pkgname-$version
 184         if [ $? -eq 0 ]; then
 185                 local list="$($db_cmd -V btree $PKGFS_BUILD_DEPS_DB $pkgname)"
 186                 echo "This package requires the following dependencies to be built:"
 187                 for i in ${list}; do
 188                         echo " $i"
 189                 done
 190         fi
 191 }
 192
 193 #
 194 # Checks that all required variables specified in the configuration
 195 # file are properly working.
 196 #
 197 check_config_vars()
 198 {
 199         local cffound=
 200
 201         if [ -z "$config_file_specified" ]; then
 202                 config_file_paths="$PKGFS_CONFIG_FILE ./pkgfs.conf"
 203                 for f in $config_file_paths; do
 204                         [ -f $f ] && PKGFS_CONFIG_FILE=$f && \
 205                                 cffound=yes && break
 206                 done
 207                 if [ -z "$cffound" ]; then
 208                         echo -n "*** ERROR: config file not specified "
 209                         echo "and not in default location or current dir ***"
 210                         exit 1
 211                 fi
 212         fi
 213
 214         run_file ${PKGFS_CONFIG_FILE}
 215         PKGFS_CONFIG_FILE=$path_fixed
 216
 217         if [ ! -f "$PKGFS_CONFIG_FILE" ]; then
 218                 echo -n "*** ERROR: cannot find configuration file: "
 219                 echo    "'$PKGFS_CONFIG_FILE' ***"
 220                 exit 1
 221         fi
 222
 223         local PKGFS_VARS="PKGFS_MASTERDIR PKGFS_DESTDIR PKGFS_BUILDDIR \
 224                           PKGFS_SRCDISTDIR PKGFS_SYSCONFDIR"
 225
 226         for f in ${PKGFS_VARS}; do
 227                 eval val="\$$f"
 228                 if [ -z "$val" ]; then
 229                         echo -n "**** ERROR: '$f' not set in configuration "
 230                         echo "file, aborting ***"
 231                         exit 1
 232                 fi
 233
 234                 if [ ! -d "$val" ]; then
 235                         $mkdir_cmd "$val"
 236                         if [ "$?" -ne 0 ]; then
 237                                 echo -n "*** ERROR: couldn't create '$f'"
 238                                 echo "directory, aborting ***"
 239                                 exit 1
 240                         fi
 241                 fi
 242         done
 243 }
 244
 245 #
 246 # Resets all vars used by a template.
 247 #
 248 reset_tmpl_vars()
 249 {
 250         local TMPL_VARS="pkgname extract_sufx distfiles url configure_args \
 251                         make_build_args make_install_args build_style   \
 252                         short_desc maintainer long_desc checksum wrksrc \
 253                         patch_files configure_env make_cmd pkgconfig_override \
 254                         configure_env make_env make_build_target \
 255                         run_stuff_before_configure_cmd run_stuff_before_build_cmd \
 256                         run_stuff_before_install_cmd run_stuff_after_install_cmd \
 257                         make_install_target postinstall_helpers version \
 258                         ignore_files \
 259                         PKGFS_EXTRACT_DONE PKGFS_CONFIGURE_DONE \
 260                         PKGFS_BUILD_DONE PKGFS_INSTALL_DONE"
 261
 262         for i in ${TMPL_VARS}; do
 263                 eval unset "$i"
 264         done
 265
 266         unset_build_vars
 267 }
 268
 269 #
 270 # Reads a template file and setups required variables for operations.
 271 #
 272 setup_tmpl()
 273 {
 274         local pkg="$1"
 275
 276         if [ -f "$PKGFS_TEMPLATESDIR/$pkg.tmpl" ]; then
 277                 run_file $PKGFS_TEMPLATESDIR/$pkg.tmpl
 278                 prepare_tmpl
 279         else
 280                 echo "*** ERROR: cannot find \`$pkg´ template file ***"
 281                 exit 1
 282         fi
 283 }
 284
 285 #
 286 # Checks some vars used in templates and sets some of them required.
 287 #
 288 prepare_tmpl()
 289 {
 290         local dfile=""
 291
 292         #
 293         # There's nothing of interest if we are a meta template.
 294         #
 295         [ "$build_style" = "meta-template" ] && return 0
 296
 297         REQ_VARS="pkgname version extract_sufx url build_style"
 298
 299         # Check if required vars weren't set.
 300         for i in ${REQ_VARS}; do
 301                 eval val="\$$i"
 302                 if [ -z "$val" -o -z "$i" ]; then
 303                         echo -n "*** ERROR: $i not set (incomplete template"
 304                         echo    " build file), aborting ***"
 305                         exit 1
 306                 fi
 307         done
 308
 309         if [ -z "$distfiles" ]; then
 310                 dfile="$pkgname-$version$extract_sufx"
 311         elif [ -n "${distfiles}" ]; then
 312                 dfile="$distfiles$extract_sufx"
 313         else
 314                 echo "*** ERROR unsupported fetch state ***"
 315                 exit 1
 316         fi
 317
 318         dfile="$PKGFS_SRCDISTDIR/$dfile"
 319
 320         case "$extract_sufx" in
 321         .tar.bz2|.tar.gz|.tgz|.tbz)
 322                 extract_cmd="$tar_cmd xfz $dfile -C $PKGFS_BUILDDIR"
 323                 ;;
 324         .tar)
 325                 extract_cmd="$tar_cmd xf $dfile -C $PKGFS_BUILDDIR"
 326                 ;;
 327         .zip)
 328                 if [ -f "$PKGFS_TMPLHELPDIR/unzip-extraction.sh" ]; then
 329                         . $PKGFS_TMPLHELPDIR/unzip-extraction.sh
 330                         unset wrksrc
 331                 fi
 332                 # $extract_cmd set by the helper
 333                 ;;
 334         *)
 335                 echo -n "*** ERROR: unknown 'extract_sufx' argument in build "
 336                 echo    "file ***"
 337                 exit 1
 338                 ;;
 339         esac
 340
 341         unset PKGFS_EXTRACT_DONE PKGFS_APPLYPATCHES_DONE
 342         unset PKGFS_CONFIGURE_DONE PKGFS_BUILD_DONE PKGFS_INSTALL_DONE
 343
 344         if [ -n "$wrksrc" ]; then
 345                 wrksrc=$PKGFS_BUILDDIR/$wrksrc
 346         elif [ -z "$wrksrc" -a -z "$distfiles" ]; then
 347                 wrksrc=$PKGFS_BUILDDIR/$pkgname-$version
 348         elif [ -z "$wrksrc" -a -n "$distfiles" ]; then
 349                 wrksrc=$PKGFS_BUILDDIR/$distfiles
 350         else
 351                 echo "*** ERROR: can't guess what's the correct \$wrksrc! ***"
 352                 exit 1
 353         fi
 354
 355         PKGFS_EXTRACT_DONE="$wrksrc/.pkgfs_extract_done"
 356         PKGFS_APPLYPATCHES_DONE="$wrksrc/.pkgfs_applypatches_done"
 357         PKGFS_CONFIGURE_DONE="$wrksrc/.pkgfs_configure_done"
 358         PKGFS_BUILD_DONE="$wrksrc/.pkgfs_build_done"
 359         PKGFS_INSTALL_DONE="$wrksrc/.pkgfs_install_done"
 360
 361         export PATH="/bin:/sbin:/usr/bin:/usr/sbin:$PKGFS_MASTERDIR/bin:$PKGFS_MASTERDIR/sbin"
 362 }
 363
 364 #
 365 # Extracts contents of distfiles specified in a template into
 366 # the build directory.
 367 #
 368 extract_distfiles()
 369 {
 370         local pkg="$1"
 371
 372         #
 373         # If we are being called via the target, just extract and return.
 374         #
 375         [ -n "$pkg" -a -z "$pkgname" ] && return 1
 376
 377         #
 378         # There's nothing of interest if we are a meta template.
 379         #
 380         [ "$build_style" = "meta-template" ] && return 0
 381
 382         echo "==> Extracting \`$pkgname-$version' into $PKGFS_BUILDDIR."
 383
 384         $extract_cmd
 385         if [ "$?" -ne 0 ]; then
 386                 echo -n "*** ERROR: there was an error extracting the "
 387                 echo "distfile(s), aborting *** "
 388                 exit 1
 389         fi
 390
 391         unset extract_cmd
 392         $touch_cmd -f $PKGFS_EXTRACT_DONE
 393 }
 394
 395 #
 396 # Verifies that a checksum of a distfile is correct.
 397 #
 398 check_rmd160_cksum()
 399 {
 400         local file="$1"
 401         local dfile=
 402
 403         [ -z "$file" ] && return 1
 404
 405         if [ -z "${distfiles}" ]; then
 406                 dfile="$pkgname-$version$extract_sufx"
 407         elif [ -n "${distfiles}" ]; then
 408                 dfile="$distfiles$extract_sufx"
 409         else
 410                 dfile="$file$extract_sufx"
 411         fi
 412
 413         if [ -z "$checksum" ]; then
 414                 echo "*** ERROR: checksum unset in template file for \`$pkgname' ***"
 415                 exit 1
 416         fi
 417
 418         origsum="$checksum"
 419         dfile="$PKGFS_SRCDISTDIR/$dfile"
 420         filesum="$($cksum_cmd $dfile | $awk_cmd '{print $4}')"
 421         if [ "$origsum" != "$filesum" ]; then
 422                 echo "*** WARNING: RMD160 checksum doesn't match for \`$dfile' ***"
 423                 exit 1
 424         fi
 425
 426         echo "=> checksum (RMD160) OK for \`$pkgname-$version'."
 427 }
 428
 429 #
 430 # Downloads the distfiles for a template from $url.
 431 #
 432 fetch_distfiles()
 433 {
 434         local pkg="$1"
 435         local file=""
 436         local file2=""
 437         local only_fetch=
 438
 439         #
 440         # If we are being called by the target, just fetch distfiles
 441         # and return.
 442         #
 443         [ -n $pkg ] && only_fetch=yes
 444         [ -z $pkgname ] && exit 1
 445
 446         #
 447         # There's nothing of interest if we are a meta template.
 448         #
 449         [ "$build_style" = "meta-template" ] && return 0
 450
 451         if [ -z "$distfiles" ]; then
 452                 file="$pkgname-$version"
 453         else
 454                 file="$distfiles"
 455         fi
 456
 457         for f in "$file"; do
 458                 file2="$f$extract_sufx"
 459                 if [ -f "$PKGFS_SRCDISTDIR/$file2" ]; then
 460                         check_rmd160_cksum $f
 461                         [ $? -eq 0 ] && continue
 462                 fi
 463
 464                 echo "==> Fetching distfile: \`$file2'."
 465
 466                 cd $PKGFS_SRCDISTDIR && $fetch_cmd $url/$file2
 467                 if [ $? -ne 0 ]; then
 468                         if [ ! -f $PKGFS_SRCDISTDIR/$file2 ]; then
 469                                 echo -n "*** ERROR: couldn't fetch '$file2', "
 470                                 echo    "aborting ***"
 471                         else
 472                                 echo -n "*** ERROR: there was an error "
 473                                 echo    "fetching '$file2', aborting ***"
 474                         fi
 475                         exit 1
 476                 else
 477                         check_rmd160_cksum $f
 478                 fi
 479         done
 480 }
 481
 482 fixup_tmpl_libtool()
 483 {
 484         local lt_file="$wrksrc/libtool"
 485
 486         #
 487         # If package has a libtool file replace it with ours, so that
 488         # we use the master directory while relinking, all will be fine
 489         # once the package is stowned.
 490         #
 491         if [ -f "$lt_file" -a -f "$PKGFS_MASTERDIR/bin/libtool" ]; then
 492                 $rm_cmd -f $wrksrc/libtool
 493                 $rm_cmd -f $wrksrc/ltmain.sh
 494                 $ln_cmd -s $PKGFS_MASTERDIR/bin/libtool $lt_file
 495                 $ln_cmd -s $PKGFS_MASTERDIR/share/libtool/config/ltmain.sh \
 496                          $wrksrc/ltmain.sh
 497         elif [ -f "$PKGFS_MASTERDIR/bin/libtool" ]; then
 498                 $ln_cmd -s $PKGFS_MASTERDIR/bin/libtool $lt_file
 499         fi
 500 }
 501
 502 set_build_vars()
 503 {
 504         LDFLAGS="-L$PKGFS_MASTERDIR/lib -Wl,-R$PKGFS_MASTERDIR/lib $LDFLAGS"
 505         LDFLAGS="-L$PKGFS_DESTDIR/$pkgname-$version/lib $LDFLAGS"
 506         CFLAGS="$CFLAGS $PKGFS_CFLAGS"
 507         CXXFLAGS="$CXXFLAGS $PKGFS_CXXFLAGS"
 508         CPPFLAGS="-I$PKGFS_MASTERDIR/include $CPPFLAGS"
 509         PKG_CONFIG="$PKGFS_MASTERDIR/bin/pkg-config"
 510
 511         export LDFLAGS="$LDFLAGS" CFLAGS="$CFLAGS" CXXFLAGS="$CXXFLAGS"
 512         export CPPFLAGS="$CPPFLAGS" PKG_CONFIG="$PKG_CONFIG"
 513 }
 514
 515 unset_build_vars()
 516 {
 517         unset LDFLAGS CFLAGS CXXFLAGS CPPFLAGS PKG_CONFIG
 518 }
 519
 520 #
 521 # Applies to the build directory the patches specified by a template.
 522 #
 523 apply_tmpl_patches()
 524 {
 525         local patch=
 526
 527         #
 528         # If package needs some patches applied before building,
 529         # apply them now.
 530         #
 531         if [ -n "$patch_files" ]; then
 532                 for i in ${patch_files}; do
 533                         patch="$PKGFS_TEMPLATESDIR/$i"
 534                         if [ ! -f "$patch" ]; then
 535                                 echo "*** WARNING: unexistent patch '$i' ***"
 536                                 continue
 537                         fi
 538
 539                         $cp_cmd -f $patch $wrksrc
 540
 541                         # Try to guess if its a compressed patch.
 542                         if $(echo $patch|$grep_cmd -q .gz); then
 543                                 $gunzip_cmd $wrksrc/$i
 544                                 patch=${i%%.gz}
 545                         elif $(echo $patch|$grep_cmd -q .bz2); then
 546                                 $bunzip2_cmd $wrksrc/$i
 547                                 patch=${i%%.bz2}
 548                         elif $(echo $patch|$grep_cmd -q .diff); then
 549                                 patch=$i
 550                         else
 551                                 echo "*** WARNING: unknown patch type '$i' ***"
 552                                 continue
 553                         fi
 554
 555                         cd $wrksrc && $patch_cmd < $patch 2>/dev/null
 556                         if [ "$?" -eq 0 ]; then
 557                                 echo "=> Patch applied: \`$i'."
 558                         else
 559                                 echo -n "*** ERROR: couldn't apply patch '$i'"
 560                                 echo ", aborting ***"
 561                                 exit 1
 562                         fi
 563                 done
 564         fi
 565
 566         $touch_cmd -f $PKGFS_APPLYPATCHES_DONE
 567 }
 568
 569 #
 570 # Runs the "configure" phase for a pkg. This setups the Makefiles or any
 571 # other stuff required to be able to build binaries or such.
 572 #
 573 configure_src_phase()
 574 {
 575         local pkg="$1"
 576
 577         [ -z $pkg ] && [ -z $pkgname ] && return 1
 578
 579         #
 580         # There's nothing we can do if we are a meta template.
 581         #
 582         [ "$build_style" = "meta-template" ] && return 0
 583
 584         if [ ! -d $wrksrc ]; then
 585                 echo "*** ERROR: unexistent build directory \`$wrksrc' ***"
 586                 exit 1
 587         fi
 588
 589         echo "=> Running \`\`configure´´ phase for \`$pkgname-$version'."
 590
 591         # Apply patches if requested by template file
 592         [ ! -f $PKGFS_APPLYPATCHES_DONE ] && apply_tmpl_patches
 593
 594         # Run stuff before configure.
 595         local rbcf="$PKGFS_TEMPLATESDIR/$pkgname-runstuff-before-configure.sh"
 596         [ -f $rbcf ] && . $rbcf
 597         [ -n "$run_stuff_before_configure_cmd" ] && \
 598                 ${run_stuff_before_configure_cmd}
 599
 600         # Export configure_env vars.
 601         for f in ${configure_env}; do
 602                 export "$f"
 603         done
 604
 605         set_build_vars
 606
 607         #
 608         # Packages using GNU autoconf
 609         #
 610         if [ "$build_style" = "gnu_configure" ]; then
 611                 cd $wrksrc
 612                 #
 613                 # Pass consistent arguments to not have unexpected
 614                 # surprises later.
 615                 #
 616                 ./configure                                             \
 617                         --prefix="$PKGFS_MASTERDIR"                     \
 618                         --mandir="$PKGFS_DESTDIR/$pkgname-$version/man" \
 619                         --infodir="$PKGFS_DESTDIR/$pkgname-$version/share/info" \
 620                         --sysconfdir="$PKGFS_SYSCONFDIR"                \
 621                         ${configure_args}
 622
 623         #
 624         # Packages using propietary configure scripts.
 625         #
 626         elif [ "$build_style" = "configure" ]; then
 627                 cd $wrksrc
 628                 if [ -n "$configure_script" ]; then
 629                         ./$configure_script ${configure_args}
 630                 else
 631                         ./configure ${configure_args}
 632                 fi
 633         #
 634         # Packages that are perl modules and use Makefile.PL files.
 635         # They are all handled by the helper perl-module.sh.
 636         #
 637         elif [ "$build_style" = "perl_module" ]; then
 638                 . $PKGFS_TMPLHELPDIR/perl-module.sh
 639                 perl_module_build $pkgname
 640
 641         #
 642         # Packages with BSD or GNU Makefiles are easy, just skip
 643         # the configure stage and proceed.
 644         #
 645         elif [ "$build_style" = "bsd_makefile" -o \
 646                "$build_style" = "gnu_makefile" ]; then
 647
 648                cd $wrksrc
 649         #
 650         # Unknown build_style type won't work :-)
 651         #
 652         else
 653                 echo "*** ERROR unknown build_style \`$build_style' ***"
 654                 exit 1
 655         fi
 656
 657         if [ "$build_style" != "perl_module" -a "$?" -ne 0 ]; then
 658                 echo "*** ERROR building (configure state) \`$pkg' ***"
 659                 exit 1
 660         fi
 661
 662         # unset configure_env vars.
 663         for f in ${configure_env}; do
 664                 unset eval ${f%=*}
 665         done
 666
 667         $touch_cmd -f $PKGFS_CONFIGURE_DONE
 668 }
 669
 670 #
 671 # Runs the "build" phase for a pkg. This builds the binaries and other
 672 # related stuff.
 673 #
 674 build_src_phase()
 675 {
 676         local pkgparam="$1"
 677         local pkg="$pkgname-$version"
 678
 679         [ -z $pkgparam ] && [ -z $pkgname -o -z $version ] && return 1
 680
 681         #
 682         # There's nothing of interest if we are a meta template.
 683         #
 684         [ "$build_style" = "meta-template" ] && return 0
 685
 686         if [ ! -d $wrksrc ]; then
 687                 echo "*** ERROR: unexistent build directory \`$wrksrc' ***"
 688                 exit 1
 689         fi
 690
 691         cd $wrksrc || exit 1
 692
 693         echo "=> Running \`\`build´´ phase for \`$pkg'."
 694
 695         #
 696         # Assume BSD make if make_cmd not set in template.
 697         #
 698         if [ -z "$make_cmd" ]; then
 699                 make_cmd="/usr/bin/make"
 700         fi
 701
 702         # Fixup libtool script if necessary
 703         fixup_tmpl_libtool
 704
 705         #
 706         # Run template stuff before building.
 707         #
 708         local rbbf="$PKGFS_TEMPLATESDIR/$pkgname-runstuff-before-build.sh"a
 709         [ -f $rbbf ] && . $rbbf
 710         [ -n "$run_stuff_before_build_cmd" ] && ${run_stuff_before_build_cmd}
 711
 712
 713         [ -z "$make_build_target" ] && make_build_target=
 714         [ -n "$PKGFS_MAKEJOBS" ] && PKGFS_MAKEJOBS="-j$PKGFS_MAKEJOBS"
 715
 716         # Export make_env vars.
 717         for f in ${make_env}; do
 718                 export "$f"
 719         done
 720
 721         #
 722         # Build package via make.
 723         #
 724         ${make_cmd} ${PKGFS_MAKEJOBS} ${make_build_args} ${make_build_target}
 725         if [ "$?" -ne 0 ]; then
 726                 echo "*** ERROR building (make stage) \`$pkg' ***"
 727                 exit 1
 728         fi
 729
 730         #
 731         # Run template stuff before installing.
 732         #
 733         local rbif="$PKGFS_TEMPLATESDIR/$pkgname-runstuff-before-install.sh"
 734         [ -f $rbif ] && . $rbif
 735         [ -n "$run_stuff_before_install_cmd" ] && ${run_stuff_before_install_cmd}
 736
 737         $touch_cmd -f $PKGFS_BUILD_DONE
 738 }
 739
 740 #
 741 # Runs the "install" phase for a pkg. This consists in installing package
 742 # into the destination directory.
 743 #
 744 install_src_phase()
 745 {
 746         local pkg="$1"
 747
 748         [ -z $pkg ] && [ -z $pkgname ] && return 1
 749
 750         [ -z "$make_install_target" ] && make_install_target=install
 751
 752         #
 753         # There's nothing we can do if we are a meta template.
 754         #
 755         [ "$build_style" = "meta-template" ] && return 0
 756
 757         if [ ! -d $wrksrc ]; then
 758                 echo "*** ERROR: unexistent build directory \`$wrksrc' ***"
 759                 exit 1
 760         fi
 761
 762         cd $wrksrc || exit 1
 763
 764         echo "=> Running \`\`install´´ phase for: \`$pkgname-$version´."
 765
 766         #
 767         # Install package via make.
 768         #
 769         ${make_cmd} ${make_install_args} ${make_install_target} \
 770                 prefix="$PKGFS_DESTDIR/$pkgname-$version"
 771         if [ "$?" -ne 0 ]; then
 772                 echo "*** ERROR instaling \`$pkgname-$version' ***"
 773                 exit 1
 774         fi
 775
 776         # Unset make_env vars.
 777         for f in ${make_env}; do
 778                 unset eval ${f%=*}
 779         done
 780
 781         #
 782         # Run template stuff after installing.
 783         #
 784         local raif="$PKGFS_TEMPLATESDIR/$pkgname-runstuff-after-install.sh"
 785         [ -f $raif ] && . $raif
 786         [ -n "$run_stuff_after_install_cmd" ] && ${run_stuff_after_install_cmd}
 787
 788         #
 789         # Transform pkg-config files if requested by template.
 790         #
 791         for i in ${pkgconfig_override}; do
 792                 local tmpf="$PKGFS_DESTDIR/$pkgname-$version/lib/pkgconfig/$i"
 793                 [ -f "$tmpf" ] && \
 794                         [ -f $PKGFS_TMPLHELPDIR/pkg-config-transform.sh ] && \
 795                         . $PKGFS_TMPLHELPDIR/pkg-config-transform.sh && \
 796                         pkgconfig_transform_file $tmpf
 797         done
 798
 799         # Unset build vars.
 800         unset_build_vars
 801
 802         echo "==> Installed \`$pkgname-$version' into $PKGFS_DESTDIR."
 803
 804         $touch_cmd -f $PKGFS_INSTALL_DONE
 805
 806         #
 807         # Remove $wrksrc if -C not specified.
 808         #
 809         if [ -d "$wrksrc" -a -z "$dontrm_builddir" ]; then
 810                 $rm_cmd -rf $wrksrc
 811                 [ "$?" -eq 0 ] && \
 812                         echo "=> Removed \`$pkgname-$version' build directory."
 813         fi
 814
 815         cd $PKGFS_BUILDDIR
 816 }
 817
 818 #
 819 # Registers or unregisters a package from the db file.
 820 #
 821 register_pkg_handler()
 822 {
 823         local action="$1"
 824         local pkg="$2"
 825         local version="$3"
 826
 827         [ -z "$action" -o -z "$pkg" -o -z "$version" ] && return 1
 828
 829         if [ "$action" = "register" ]; then
 830                 $db_cmd -w btree $PKGFS_REGPKG_DB $pkg $version 2>&1 >/dev/null
 831                 if [ "$?" -ne  0 ]; then
 832                         echo -n "*** ERROR: couldn't register \`$pkg'"
 833                         echo " in db file ***"
 834                         exit 1
 835                 fi
 836         elif [ "$action" = "unregister" ]; then
 837                 $db_cmd -d btree $PKGFS_REGPKG_DB $pkg 2>&1 >/dev/null
 838                 if [ "$?" -ne 0 ]; then
 839                         echo -n "*** ERROR: \`$pkg' not registered "
 840                         echo "in db file? ***"
 841                         exit 1
 842                 fi
 843         else
 844                 return 1
 845         fi
 846 }
 847
 848 #
 849 # Recursive function that founds dependencies in all required
 850 # packages.
 851 #
 852 add_dependency_tolist()
 853 {
 854         local curpkg="$1"
 855
 856         [ -z "$curpkg" ] && return 1
 857         [ -n "$prev_pkg" ] && curpkg=$prev_pkg
 858
 859         for i in $($db_cmd -V btree $PKGFS_BUILD_DEPS_DB ${curpkg%-[0-9]*.*}); do
 860                 #
 861                 # Check if dep already installed.
 862                 #
 863                 if [ -r "$PKGFS_REGPKG_DB" ]; then
 864                         check_installed_pkg $i ${i##[aA-zZ]*-}
 865                         #
 866                         # If dep is already installed, put it on the
 867                         # installed deps list and continue.
 868                         #
 869                         if [ $? -eq 0 ]; then
 870                                 installed_deps_list="$i $installed_deps_list"
 871                                 continue
 872                         fi
 873
 874                         deps_list="$i $deps_list"
 875                         [ -n "$prev_pkg" ] && unset prev_pkg
 876                         #
 877                         # Check if dependency needs more deps.
 878                         #
 879                         check_build_depends_pkg ${i%-[0-9]*.*}
 880                         if [ $? -eq 0 ]; then
 881                                 add_dependency_tolist $i
 882                                 prev_pkg="$i"
 883                         fi
 884                 fi
 885         done
 886 }
 887
 888 #
 889 # Removes duplicate deps in the installed or not installed list.
 890 #
 891 find_dupdeps_inlist()
 892 {
 893         local action="$1"
 894         local tmp_list=
 895         local dup=
 896
 897         [ -z "$action" ] && return 1
 898
 899         case "$action" in
 900         installed)
 901                 list=$installed_deps_list
 902                 ;;
 903         notinstalled)
 904                 list=$deps_list
 905                 ;;
 906         *)
 907                 return 1
 908                 ;;
 909         esac
 910
 911         for f in $list; do
 912                 if [ -z "$tmp_list" ]; then
 913                         tmp_list="$f"
 914                 else
 915                         for i in $tmp_list; do
 916                                 [ "$f" = "$i" ] && dup=yes
 917                         done
 918
 919                         [ -z "$dup" ] && tmp_list="$tmp_list $f"
 920                         unset dup
 921                 fi
 922         done
 923
 924         case "$action" in
 925         installed)
 926                 installed_deps_list="$tmp_list"
 927                 ;;
 928         notinstalled)
 929                 deps_list="$tmp_list"
 930                 ;;
 931         *)
 932                 return 1
 933                 ;;
 934         esac
 935 }
 936
 937 #
 938 # Installs all dependencies required by a package.
 939 #
 940 install_dependencies_pkg()
 941 {
 942         local pkg="$1"
 943         deps_list=
 944         installed_deps_list=
 945
 946         [ -z "$pkg" ] && return 1
 947
 948         doing_deps=true
 949
 950         add_dependency_tolist $pkg
 951         find_dupdeps_inlist installed
 952         find_dupdeps_inlist notinstalled
 953
 954         [ -z "$deps_list" -a -z "$installed_deps_list" ] && return 0
 955
 956         echo "==> Required dependencies for $(basename $pkg):"
 957         for i in ${installed_deps_list}; do
 958                 fpkg="$($db_cmd -O '-' btree $PKGFS_REGPKG_DB ${i%-[0-9]*.*})"
 959                 echo "  $i: found $fpkg."
 960         done
 961
 962         for i in ${deps_list}; do
 963                 echo "  $i: not installed."
 964         done
 965
 966         for i in ${deps_list}; do
 967                 # skip dup deps
 968                 check_installed_pkg $i ${i##[aA-zZ]*-}
 969                 [ $? -eq 0 ] && continue
 970                 # continue installing deps
 971                 echo "==> Installing \`$pkg´ dependency: \`$i´."
 972                 install_pkg ${i%-[0-9]*.*}
 973         done
 974
 975         unset installed_deps_list
 976         unset deps_list
 977 }
 978
 979 install_builddeps_required_pkg()
 980 {
 981         local pkg="$1"
 982
 983         [ -z "$pkg" ] && return 1
 984
 985         for dep in $($db_cmd -V btree $PKGFS_BUILD_DEPS_DB ${pkg%-[0-9]*.*}); do
 986                 check_installed_pkg $dep ${dep##[aA-zZ]*-}
 987                 if [ $? -ne 0 ]; then
 988                         echo "==> Installing \`$pkg´ dependency: $dep."
 989                         install_pkg ${dep%-[0-9]*.*}
 990                 fi
 991         done
 992 }
 993
 994 #
 995 # Checks the registered pkgs db file and returns 0 if a pkg that satisfies
 996 # the minimal required version is there, or 1 otherwise.
 997 #
 998 check_installed_pkg()
 999 {
1000         local pkg="$1"
1001         local reqver="$2"
1002         local iver=
1003
1004         [ -z "$pkg" -o -z "$reqver" -o ! -r $PKGFS_REGPKG_DB ] && return 1
1005
1006         run_file $PKGFS_TEMPLATESDIR/${pkg%-[0-9]*.*}.tmpl
1007
1008         reqver="$(echo $reqver | $sed_cmd 's|[[:punct:]]||g;s|[[:alpha:]]||g')"
1009
1010         $db_cmd -K btree $PKGFS_REGPKG_DB $pkgname 2>&1 >/dev/null
1011         if [ $? -eq 0 ]; then
1012                 #
1013                 # Package is installed, let's check the version.
1014                 #
1015                 iver="$($db_cmd -V btree $PKGFS_REGPKG_DB $pkgname)"
1016                 if [ -n "$iver" ]; then
1017                         #
1018                         # As shell only supports decimal arith expressions,
1019                         # we simply remove anything except the numbers.
1020                         # It's not optimal and may fail, but it is enough
1021                         # for now.
1022                         #
1023                         iver="$(echo $iver | $sed_cmd 's|[[:punct:]]||g;s|[[:alpha:]]||g')"
1024                         if [ "$iver" -eq "$reqver" \
1025                              -o "$iver" -gt "$reqver" ]; then
1026                              return 0
1027                         fi
1028                 fi
1029         fi
1030
1031         return 1
1032 }
1033
1034 #
1035 # Checks the build depends db file and returns 0 if pkg has dependencies,
1036 # otherwise returns 1.
1037 #
1038 check_build_depends_pkg()
1039 {
1040         local pkg="$1"
1041
1042         [ -z $pkg -o ! -r $PKGFS_BUILD_DEPS_DB ] && return 1
1043
1044         $db_cmd -V btree $PKGFS_BUILD_DEPS_DB ${pkg%-[0-9]*.*} 2>&1 >/dev/null
1045         return $?
1046 }
1047
1048 #
1049 # Installs a pkg by reading its build template file.
1050 #
1051 install_pkg()
1052 {
1053         local pkg=
1054         local curpkgn="$1"
1055
1056         local cur_tmpl="$PKGFS_TEMPLATESDIR/$curpkgn.tmpl"
1057         if [ -z $cur_tmpl -o ! -f $cur_tmpl ]; then
1058                 echo "*** ERROR: cannot find \`$cur_tmpl´ template file ***"
1059                 exit 1
1060         fi
1061
1062         reset_tmpl_vars
1063         run_file $cur_tmpl
1064         pkg="$curpkgn-$version"
1065
1066         #
1067         # If we are the originator package save the path this template in
1068         # other var for future use.
1069         #
1070         [ -z "$origin_tmpl" ] && origin_tmpl=$pkgname
1071
1072         #
1073         # Install xstow if it's not there.
1074         #
1075         install_xstow_pkg
1076
1077         #
1078         # We are going to install a new package.
1079         #
1080         prepare_tmpl
1081
1082         #
1083         # Install dependencies required by this package.
1084         #
1085         if [ -z "$doing_deps" ]; then
1086                 install_dependencies_pkg $pkg
1087                 #
1088                 # At this point all required deps are installed, and
1089                 # only remaining is the origin template; install it.
1090                 #
1091                 unset doing_deps
1092                 reset_tmpl_vars
1093                 setup_tmpl $curpkgn
1094         fi
1095
1096         #
1097         # Fetch, extract, build and install into the destination directory.
1098         #
1099         fetch_distfiles
1100
1101         if [ ! -f "$PKGFS_EXTRACT_DONE" ]; then
1102                 extract_distfiles
1103         fi
1104
1105         if [ ! -f "$PKGFS_CONFIGURE_DONE" ]; then
1106                 configure_src_phase
1107         fi
1108
1109         if [ ! -f "$PKGFS_BUILD_DONE" ]; then
1110                 build_src_phase
1111         fi
1112
1113         install_src_phase
1114
1115         #
1116         # Just register meta-template and exit.
1117         #
1118         if [ "$build_style" = "meta-template" ]; then
1119                 register_pkg_handler register $pkgname $version
1120                 echo "==> Installed meta-template \`$pkg'."
1121                 return 0
1122         fi
1123
1124         #
1125         # Do not stow package if it wasn't requested.
1126         #
1127         [ -z "$install_destdir_target" ] && stow_pkg $pkg
1128 }
1129
1130 #
1131 # Installs and stows the "xstow" package.
1132 #
1133 install_xstow_pkg()
1134 {
1135         [ -x "$PKGFS_XSTOW_CMD" ] && return 0
1136
1137         echo "=> xstow application not found, will install it now."
1138
1139         reset_tmpl_vars
1140         setup_tmpl xstow
1141         fetch_distfiles
1142
1143         if [ ! -f "$PKGFS_EXTRACT_DONE" ]; then
1144                 extract_distfiles
1145         fi
1146
1147         if [ ! -f "$PKGFS_CONFIGURE_DONE" ]; then
1148                 configure_src_phase
1149         fi
1150
1151         if [ ! -f "$PKGFS_BUILD_DONE" ]; then
1152                 build_src_phase
1153         fi
1154
1155         install_src_phase
1156
1157         PKGFS_XSTOW_CMD="$PKGFS_DESTDIR/$pkgname-$version/bin/xstow"
1158         stow_pkg $pkgname-$version
1159
1160         #
1161         # Continue with package that called us.
1162         #
1163         run_file $PKGFS_TEMPLATESDIR/$origin_tmpl.tmpl
1164 }
1165
1166 #
1167 # Lists all currently installed packages.
1168 #
1169 list_pkgs()
1170 {
1171         if [ ! -r "$PKGFS_REGPKG_DB" ]; then
1172                 echo "=> No packages registered or missing register db file."
1173                 exit 0
1174         fi
1175
1176         for i in $($db_cmd -K btree $PKGFS_REGPKG_DB); do
1177                 # Run file to get short_desc and print something useful
1178                 run_file $PKGFS_TEMPLATESDIR/$i.tmpl
1179                 echo "$i-$version       $short_desc"
1180                 reset_tmpl_vars
1181         done
1182 }
1183
1184 #
1185 # Lists files installed by a package.
1186 #
1187 list_pkg_files()
1188 {
1189         local pkg="$1"
1190
1191         if [ -z $pkg ]; then
1192                 echo "*** ERROR: unexistent package, aborting ***"
1193                 exit 1
1194         fi
1195
1196         if [ ! -d "$PKGFS_DESTDIR/$pkg" ]; then
1197                 echo "*** ERROR: cannot find \`$pkg' in $PKGFS_DESTDIR ***"
1198                 exit 1
1199         fi
1200
1201         for f in $($find_cmd $PKGFS_DESTDIR/$pkg -type f -print | sort -u); do
1202                 echo "${f##$PKGFS_DESTDIR/$pkg/}"
1203         done
1204 }
1205
1206 #
1207 # Removes a currently installed package (unstow + removed from destdir).
1208 #
1209 remove_pkg()
1210 {
1211         local pkg="$1"
1212
1213         if [ -z "$pkg" ]; then
1214                 echo "*** ERROR: unexistent package, aborting ***"
1215                 exit 1
1216         fi
1217
1218         if [ ! -f "$PKGFS_TEMPLATESDIR/$pkg.tmpl" ]; then
1219                 echo "*** ERROR: cannot find template file ***"
1220                 exit 1
1221         fi
1222
1223         run_file $PKGFS_TEMPLATESDIR/$pkg.tmpl
1224
1225         #
1226         # If it's a meta-template, just unregister it from the db.
1227         #
1228         if [ "$build_style" = "meta-template" ]; then
1229                 register_pkg_handler unregister $pkgname $version
1230                 [ $? -eq 0 ] && \
1231                         echo "=> Removed meta-template \`$pkg'."
1232                 return $?
1233         fi
1234
1235         if [ ! -d "$PKGFS_DESTDIR/$pkg-$version" ]; then
1236                 echo "*** ERROR: cannot find package on $PKGFS_DESTDIR ***"
1237                 exit 1
1238         fi
1239
1240         unstow_pkg $pkg
1241         $rm_cmd -rf $PKGFS_DESTDIR/$pkg-$version
1242         return $?
1243 }
1244
1245 #
1246 # Stows a currently installed package, i.e creates the links
1247 # on the master directory.
1248 #
1249 stow_pkg()
1250 {
1251         local pkg="$1"
1252         local infodir_pkg="share/info/dir"
1253         local infodir_master="$PKGFS_MASTERDIR/share/info/dir"
1254         local real_xstowargs="$xstow_args"
1255         local real_xstow_ignore="$xstow_ignore_files"
1256
1257         [ -z "$pkg" ] && return 2
1258
1259         if [ -n "$stow_flag" ]; then
1260                 pkg=$PKGFS_TEMPLATESDIR/$pkg.tmpl
1261                 run_file $pkg
1262                 pkg=$pkgname-$version
1263                 #
1264                 # You cannot stow a meta-template.
1265                 #
1266                 [ "$build_style" = "meta-template" ] && return 0
1267         fi
1268
1269         if [ -r "$PKGFS_DESTDIR/$pkg/$infodir_pkg" ]; then
1270                 merge_infodir_tmpl $pkg
1271         fi
1272
1273         if [ -r "$PKGFS_DESTDIR/$pkg/$infodir_pkg" \
1274              -a -r "$infodir_master" ]; then
1275                 xstow_args="$xstow_args -i-file-in-dir $infodir_pkg"
1276         fi
1277
1278         if [ -n "$ignore_files" ]; then
1279                 xstow_ignore_files="$xstow_ignore_files $ignore_files"
1280         fi
1281
1282         $PKGFS_XSTOW_CMD -ignore "${xstow_ignore_files}" ${xstow_args} \
1283                 -pd-targets $PKGFS_MASTERDIR \
1284                 -dir $PKGFS_DESTDIR -target $PKGFS_MASTERDIR \
1285                 $PKGFS_DESTDIR/$pkg
1286         if [ "$?" -ne 0 ]; then
1287                 echo "*** ERROR: couldn't create symlinks for \`$pkg' ***"
1288                 exit 1
1289         else
1290                 echo "==> Created \`$pkg' symlinks into master directory."
1291         fi
1292
1293         register_pkg_handler register $pkgname $version
1294
1295         #
1296         # Run template postinstall helpers if requested.
1297         #
1298         if [ "$pkgname" != "${pkg%%-$version}" ]; then
1299                 run_file $PKGFS_TEMPLATESDIR/${pkg%%-$version}.tmpl
1300         fi
1301
1302         for i in ${postinstall_helpers}; do
1303                 local pihf="$PKGFS_TMPLHELPDIR/$i"
1304                 [ -f "$pihf" ] && . $pihf
1305         done
1306
1307         xstow_ignore_files="$real_xstow_ignore"
1308         xstow_args="$real_xstowargs"
1309 }
1310
1311 #
1312 # Unstows a currently stowned package, i.e removes its links
1313 # from the master directory.
1314 #
1315 unstow_pkg()
1316 {
1317         local pkg="$1"
1318         local real_xstow_ignore="$xstow_ignore_files"
1319
1320         if [ -z "$pkg" ]; then
1321                 echo "*** ERROR: template wasn't specified? ***"
1322                 exit 1
1323         fi
1324
1325         if [ "$pkg" = "xstow" ]; then
1326                 echo "*** INFO: You aren't allowed to unstow \`$pkg'."
1327                 exit 1
1328         fi
1329
1330         run_file $PKGFS_TEMPLATESDIR/$pkg.tmpl
1331
1332         #
1333         # You cannot unstow a meta-template.
1334         #
1335         [ "$build_style" = "meta-template" ] && return 0
1336
1337         if [ -n "$ignore_files" ]; then
1338                 xstow_ignore_files="$xstow_ignore_files $ignore_files"
1339         fi
1340
1341         $PKGFS_XSTOW_CMD -dir $PKGFS_DESTDIR -target $PKGFS_MASTERDIR \
1342                 -D -i-file-in-dir share/info/dir -ignore \
1343                 "${xstow_ignore_files}" $PKGFS_DESTDIR/$pkgname-$version
1344         if [ $? -ne 0 ]; then
1345                 exit 1
1346         else
1347                 $rm_cmd -f $PKGFS_DESTDIR/$pkgname-$version/share/info/dir
1348                 echo "==> Removed \`$pkg' symlinks from master directory."
1349         fi
1350
1351         register_pkg_handler unregister $pkgname $version
1352
1353         xstow_ignore_files="$real_xstow_ignore"
1354 }
1355
1356 #
1357 # main()
1358 #
1359 args=$(getopt Cc $*)
1360 [ "$?" -ne 0 ] && usage
1361
1362 set -- $args
1363 while [ "$#" -gt 0 ]; do
1364         case "$1" in
1365         -C)
1366                 dontrm_builddir=yes
1367                 ;;
1368         -c)
1369                 config_file_specified=yes
1370                 PKGFS_CONFIG_FILE="$2"
1371                 shift
1372                 ;;
1373         --)
1374                 shift
1375                 break
1376                 ;;
1377         esac
1378         shift
1379 done
1380
1381 [ "$#" -gt 2 ] && usage
1382
1383 target="$1"
1384 if [ -z "$target" ]; then
1385         echo "*** ERROR: missing target ***"
1386         usage
1387 fi
1388
1389 #
1390 # Check configuration vars before anyting else, and set defaults vars.
1391 #
1392 check_config_vars
1393 set_defvars
1394
1395 # Main switch
1396 case "$target" in
1397 build)
1398         setup_tmpl $2
1399         fetch_distfiles $2
1400         if [ ! -f "$PKGFS_EXTRACT_DONE" ]; then
1401                 extract_distfiles $2
1402         fi
1403
1404         if [ ! -f "$PKGFS_CONFIGURE_DONE" ]; then
1405                 configure_src_phase $2
1406         fi
1407         build_src_phase $2
1408         ;;
1409 configure)
1410         setup_tmpl $2
1411         fetch_distfiles $2
1412         if [ ! -f "$PKGFS_EXTRACT_DONE" ]; then
1413                 extract_distfiles $2
1414         fi
1415         configure_src_phase $2
1416         ;;
1417 extract)
1418         setup_tmpl $2
1419         fetch_distfiles $2
1420         extract_distfiles $2
1421         ;;
1422 fetch)
1423         setup_tmpl $2
1424         fetch_distfiles $2
1425         ;;
1426 info)
1427         setup_tmpl $2
1428         info_tmpl $2
1429         ;;
1430 install-destdir)
1431         install_destdir_target=yes
1432         install_pkg $2
1433         ;;
1434 install)
1435         install_pkg $2
1436         ;;
1437 list)
1438         list_pkgs
1439         ;;
1440 listfiles)
1441         list_pkg_files $2
1442         ;;
1443 remove)
1444         remove_pkg $2
1445         ;;
1446 stow)
1447         stow_flag=yes
1448         setup_tmpl $2
1449         stow_pkg $2
1450         ;;
1451 unstow)
1452         setup_tmpl $2
1453         unstow_pkg $2
1454         ;;
1455 *)
1456         echo "*** ERROR: invalid target \`$target' ***"
1457         usage
1458 esac
1459
1460 # Agur
1461 exit 0