pkgfs.sh

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