source: src-sh/pbi-manager/pbi-manager @ f5af732

releng/10.0
Last change on this file since f5af732 was f5af732, checked in by Kris Moore <kris@…>, 9 months ago

When using VERBOSE mode in pbi_add, show tar content / extraction

Conflicts:

src-sh/pbi-manager/pbi-manager

  • Property mode set to 100755
File size: 225.3 KB
Line 
1#!/bin/sh
2#
3# Copyright 2013 iXsystems (Kris Moore)
4# All rights reserved
5#
6# Redistribution and use in source and binary forms, with or without
7# modification, are permitted providing that the following conditions
8# are met:
9# 1. Redistributions of source code must retain the above copyright
10#    notice, this list of conditions and the following disclaimer.
11# 2. Redistributions in binary form must reproduce the above copyright
12#    notice, this list of conditions and the following disclaimer in the
13#    documentation and/or other materials provided with the distribution.
14#
15# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
19# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
23# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
24# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25# POSSIBILITY OF SUCH DAMAGE.
26
27usage_add_pbi() {
28        cat <<EOF
29usage: `basename $0` [options] pbi
30
31Options:
32  -e             -- Extract Only
33  -f             -- Force install, overwriting existing installation
34  -g             -- Get and show path to icon / images for gui installer
35  -i             -- Display information about this PBI
36  -l             -- Display LICENSE text
37  -o outdir      -- Extract to target directory
38  -r             -- Fetch and install PBI
39  -R             -- Fetch install file and save to disk (Do not install)
40  -v             -- Enable verbose output
41  --checkscript  -- Display any custom install / removal scripts
42  --licagree     -- Agree to LICENSE terms for installation
43  --meta         -- Display any custom meta-file supplied with the PBI
44  --no-checksum  -- Skip the checksum verification during installation
45  --no-checksig  -- Ignore signature verification and force install
46  --no-hash      -- Disable using shared hash folder for PBI
47  --rArch arch   -- Used with -r to specify the specific PBI machine type
48  --rVer ver     -- Used with -r to specify the specific PBI version
49  --repo repoid  -- Used with -r to specify the specific repo to pull from
50
51EOF
52        exit_trap
53}
54
55usage_autob_pbi() {
56        cat <<EOF
57usage: `basename $0` [options]
58
59Options:
60  -c confdir   -- Directory to traverse looking for meta-data modules <required>
61  -d portdir   -- Use different ports dir (Default: /usr/ports)
62  -h script    -- Call the following helper script after each build
63  -o outdir    -- Where to place the finished PBI file(s) <required>
64  -p <num>     -- Number of PBI builds to run concurrently (Defaults to 1)
65  -32          -- Build i386 PBIs on amd64 host
66  -32fallback  -- On amd64 host, build 32bit PBIs if only i386 can be built
67  --genpatch   -- Generate patch files (*.pbp) from archived PBIs to current
68  --keep <num> -- Keep <num> old versions in archive folder for each built PBI
69  --prune      -- Remove files from 'outdir' that no longer have a module
70  --pkgbuild   -- Build the PBIs using packages from PKGNG
71  --tmpfs      -- Use TMPFS for port WRKDIRPREFIX
72  --sign key   -- Sign the PBI(s) with specified openssl key
73
74EOF
75        exit_trap
76}
77
78
79usage_create_pbi() {
80        cat <<EOF
81usage: `basename $0` [options] pbidir
82
83Options:
84  -a author    -- Application Author
85  -b           -- Make a backup of an already installed PBI
86  -c confdir   -- PBI configuration meta-data directory
87  -d portdir   -- Use different ports dir (Default: /usr/ports)
88  -i icon      -- Application Icon, relative to pbidir/
89  -n name      -- Application Name
90  -o outdir    -- Output directory for finished .pbi file
91  -p port      -- Pull name / version from FreeBSD Port
92  -r version   -- Application Version
93  -w url       -- Application Website
94  --meta file  -- Include the specified <file> inside the PBI header
95                  for display with "pbi_add --meta"
96  --no-hash    -- Disable using shared hash folder for PBI
97  --sign key   -- Sign the PBI with specified openssl key
98
99EOF
100        exit_trap
101}
102
103usage_delete_pbi() {
104        cat <<EOF
105usage: `basename $0` [options] pbi
106
107Options:
108  -v             -- Enable verbose output
109  --clean-hdir   -- Perform a full cleaning of hash dir (Does not remove any PBIs)
110
111EOF
112        exit_trap
113}
114
115usage_make_pbi() {
116        cat <<EOF
117usage: `basename $0` [options] port
118
119Options:
120  -B           -- Build-only, do not run pbi_create when finished
121  -c confdir   -- PBI configuration meta-data directory
122  -d portdir   -- Use different ports dir (Default: /usr/ports)
123  -k           -- Keep build files, don't delete when finished
124  -o outdir    -- Where to place the finished PBI file
125  -p prefix    -- Specify alternate PBI Compile PREFIX
126  -32          -- Build i386 PBI on amd64 host
127  --delbuild   -- Delete existing build dirs if they exist
128  --meta file  -- Include the specified meta file in the PBI header
129  --mkdebug    -- Drop to debug shell if port make fails
130  --pkgbuild   -- Build PBI from PKGNG package repo
131  --tmpfs      -- Use TMPFS for port WRKDIRPREFIX
132  --no-prune   -- Do not prune non REQUIREDBY ports
133  --sign key   -- Sign the PBI with specified openssl key
134
135EOF
136        exit_trap
137}
138
139usage_icon_pbi() {
140        cat <<EOF
141usage: `basename $0` [options] pbi
142
143Options:
144  add-desktop          -- Add desktop icons
145  add-menu             -- Add menu icons
146  add-mime             -- Add mime registration
147  add-pathlnk          -- Add PATH links
148  del-desktop          -- Remove desktop icons
149  del-menu             -- Remove menu icons
150  del-mime             -- Remove mime registration
151  del-pathlnk          -- Remove PATH links
152
153EOF
154        exit_trap
155}
156
157usage_info_pbi() {
158        cat <<EOF
159usage: `basename $0` [options] pbi
160
161Options:
162  -a             -- Show all installed PBIs
163  -v             -- Enable verbose output
164
165EOF
166        exit_trap
167}
168
169usage_makepatch_pbi() {
170        cat <<EOF
171usage: `basename $0` [options] oldpbi newpbi
172               
173Options:
174  -o outdir      -- Save the .PBP file to outdir
175  --tmpfs        -- Use TMPFS for extracting PBIs
176  --sign key     -- Sign the PBI with specified openssl key
177  --no-checksig  -- Ignore signature verification and force install
178
179
180EOF
181        exit_trap
182}
183
184usage_addrepo_pbi() {
185        cat <<EOF
186usage: `basename $0` <Repo File>
187               
188EOF
189        exit_trap
190}
191
192usage_deleterepo_pbi() {
193        cat <<EOF
194usage: `basename $0` <Repo ID>
195               
196EOF
197        exit_trap
198}
199
200usage_mt_add() {
201        cat <<EOF
202usage: `basename $0` add [options] metafile
203               
204Options:
205  --cat         -- Adding a new category metadata
206  --app         -- Adding a new application metadata
207  -a author     -- Application author
208  -c category   -- Application category
209  -d desc       -- Description for application / category (Required)
210  -i icon       -- URL pointing to 64x64 PNG application / category icon (Required)
211  -k keywords   -- Application keywords for searching
212  -l license    -- Application license type
213                   Example: BSD, GPL, Commercial
214  -m email      -- Port / Application Maintainer
215  -n name       -- Application / category name (Required)
216  -t type       -- Application interface type
217                   Example; Graphical, Text, Service
218  -u url        -- Application homepage URL
219  -r            -- Application must be installed as root
220  -s shortdesc  -- Short description for application
221
222EOF
223        exit_trap
224}
225
226usage_it_add() {
227        cat <<EOF
228usage: `basename $0` add [options] indexfile
229               
230Options:
231  -b vers       -- Mark previous versions as having binary diff patches available
232                   I.E. (2.7.3,2.8.1,2.8.2)
233  -f pbifile    -- The PBI file we are adding to the index (Required)
234  -k num        -- The number of previous versions of this PBI to keep in the index
235  -u fileurl    -- The URL to this PBI on the mirror server(s) (Required)
236
237EOF
238        exit_trap
239}
240
241usage_mt_rem() {
242        cat <<EOF
243usage: `basename $0` rem [options] metafile
244               
245Options:
246  --cat         -- Removing category metadata
247  --app         -- Removing application metadata
248  -n name       -- The name we are removing from the metafile (Required)
249
250EOF
251        exit_trap
252}
253
254usage_mt_syncpbi() {
255        cat <<EOF
256usage: `basename $0` syncpbi pbifile metafile
257
258This command will sync the meta-data from a PBI into the repo metafile
259               
260EOF
261        exit_trap
262}
263
264usage_it_rem() {
265        cat <<EOF
266usage: `basename $0` rem [options] indexfile
267               
268Options:
269  -m arch       -- The PBI architecture to remove (Required)
270                   I.E. (i386,amd64,etc)
271  -n pbiname    -- The PBI name we are removing from the index (Required)
272  -v version    -- The version of the PBI to remove (Required)
273
274EOF
275        exit_trap
276}
277
278usage_mt_unknown() {
279        cat <<EOF
280usage: `basename $0` [options] metafile
281               
282Options:
283  add           -- Add a new entry to the specified metafile
284  rem           -- Remove an entry in the metafile
285  syncpbi       -- Sync meta-data from a PBI file
286
287EOF
288        exit_trap
289}
290
291usage_it_unknown() {
292        cat <<EOF
293usage: `basename $0` [options] indexfile
294               
295Options:
296  add           -- Add a new entry to the specified indexfile
297  rem           -- Remove an entry in the indexfile
298
299EOF
300        exit_trap
301}
302
303usage_browse_pbi() {
304        cat <<EOF
305usage: `basename $0` [options] [repoid]
306               
307Options:
308  -c category   -- List PBIs from the specified category
309  -s search     -- Search for the specified string
310  --listcats    -- List the available categories in this repository
311
312EOF
313        exit_trap
314}
315
316usage_listrepo_pbi() {
317        cat <<EOF
318usage: `basename $0` [options] [repoid]
319               
320Options:
321  --down        -- Move the specified repoid down in priority
322  --mirror url  -- Change the target repoid's mirror url
323  --up          -- Move the specified repoid up in priority
324
325EOF
326        exit_trap
327}
328
329usage_makerepo_pbi() {
330        cat <<EOF
331usage: `basename $0` [options] [outdir]
332               
333Options:
334  --desc description    -- Description for this new repo
335  --key key             -- Path to the public key file for this repo
336  --url url             -- Base URL for fetching the INDEX files
337  --mirror mirrorurl    -- Mirror url(s) for fetching PBIs, use ',' as
338                           seperator for multiple
339
340EOF
341        exit_trap
342}
343
344usage_patch_pbi() {
345        cat <<EOF
346usage: `basename $0` [options] pbp
347               
348Options:
349  -e             -- Extract Only
350  -g             -- Get and show path to icon / images for gui installer
351  -i             -- Display information about this PBI
352  -o outdir      -- Extract to target directory
353  --checkscript  -- Display any custom install / removal scripts
354  --no-checksig  -- Ignore signature verification and force install
355  --no-hash      -- Disable using shared hash folder for PBI
356
357EOF
358        exit_trap
359}
360
361# update usage
362usage_update_pbi() {
363        cat <<EOF
364usage: `basename $0` [options] pbi
365
366Options:
367  -c              -- Check-only, do not update target PBI
368  --check-all     -- Perform a full check of all PBIs for updates
369  --disable-auto  -- Disable auto-updating for the target PBI
370  --enable-auto   -- Enable auto-updating for the target PBI
371  --update-all    -- Update all PBIs to latest versions
372
373EOF
374        exit_trap
375}
376
377# Parse the command line for info
378parse_delete_pbi_cmdline() {
379        while [ $# -gt 0 ]; do
380                case "$1" in
381                -v)     PBI_VERBOSE="YES" 
382                        ;;
383      --clean-hdir)     pbi_clean_hashdir
384                        exit_trap
385                        ;;
386                 *)     if [ $# -gt 1 ]; then usage_delete_pbi; fi
387                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
388                                find_pbi_namematch "$1"
389                                if [ -z "$PBI_NAMEMATCH" ] ; then
390                                        exit_err "can't find installed pbi (${1})"
391                                fi
392                                PBI_DELETENAME="$PBI_NAMEMATCH"
393                        else
394                                PBI_DELETENAME="$1"
395                        fi
396                        ;;
397                esac
398                shift
399        done
400        if [ -z "${PBI_DELETENAME}" ];then usage_delete_pbi; fi
401}
402
403find_pbi_namematch()
404{
405        _fLow="`echo ${1} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
406        PBI_NAMEMATCH=""
407        for i in `ls -d ${PBI_DBAPPDIR}/* 2>/dev/null`
408        do
409                if [ ! -e "$i/pbi_name" ] ; then continue ; fi
410                _tLow="`cat $i/pbi_name | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
411                if [ "$_tLow" = "$_fLow" ] ; then
412                        PBI_NAMEMATCH="`basename ${i}`"
413                        break
414                fi
415        done
416}
417
418# Parse the command line for icon
419parse_icon_pbi_cmdline() {
420        while [ $# -gt 0 ]; do
421                case "$1" in
422                add-desktop)    PBI_DESKADD="YES" ;;
423                add-menu)       PBI_MENUADD="YES" ;;
424                add-mime)       PBI_MIMEADD="YES" ;;
425                add-pathlnk)    PBI_PATHADD="YES" ;;
426                del-desktop)    PBI_DESKDEL="YES" ;;
427                del-menu)       PBI_MENUDEL="YES" ;;
428                del-mime)       PBI_MIMEDEL="YES" ;;
429                del-pathlnk)    PBI_PATHDEL="YES" ;;
430                 *)
431                        if [ $# -gt 1 ]; then usage_icon_pbi; fi
432                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
433                                find_pbi_namematch "$1"
434                                if [ -z "$PBI_NAMEMATCH" ] ; then
435                                        exit_err "can't find installed pbi (${1})"
436                                fi
437                                PBI_ICONTARGETAPP="${PBI_NAMEMATCH}"
438                        else
439                                PBI_ICONTARGETAPP="$1"
440                        fi
441                        ;;
442                esac
443                shift
444        done
445        if [ -z "${PBI_ICONTARGETAPP}" ] ; then
446                usage_icon_pbi
447        fi
448}
449
450# Parse the command line for pbid
451parse_pbid_cmdline() {
452        while [ $# -gt 0 ]; do
453                case "$1" in
454                -v)     PBI_VERBOSE="YES" 
455                        ;;
456         --refresh)     # Schedule us to refresh the index
457                        echo "Your meta and index files will begin refreshing in a moment..."
458                        echo "Details available in /var/log/pbid.log"
459                        rm ${PBI_DBINDEXDIR}/*.time >/dev/null 2>/dev/null
460                        if [ -e "${PROGBASE}/etc/rc.d/pbid" ]; then
461                           ${PROGBASE}/etc/rc.d/pbid restart >/dev/null 2>/dev/null
462                        fi
463                        exit 0
464                        ;;
465                esac
466                shift
467        done
468}
469
470# Parse the command line for info
471parse_info_pbi_cmdline() {
472        while [ $# -gt 0 ]; do
473                case "$1" in
474                -a)     PBI_INFONAME="--ALL--"
475                        ;;
476                -i)     PBI_INFOINDEX="YES"     
477                        ;;
478                -v)     PBI_VERBOSE="YES" 
479                        ;;
480                 *)
481                        if [ $# -gt 1 ]; then usage_info_pbi; fi
482                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
483                                find_pbi_namematch "$1"
484                                if [ -z "$PBI_NAMEMATCH" ] ; then
485                                        exit_err "can't find installed pbi (${1})"
486                                fi
487                                PBI_INFONAME="$PBI_NAMEMATCH"
488                        else
489                                PBI_INFONAME="$1"
490                        fi
491                        ;;
492                esac
493                shift
494        done
495        if [ -z "${PBI_INFONAME}" ] ; then
496                PBI_INFONAME="--ALL--" 
497        fi
498}
499
500# Parse the command line for patching
501parse_makepatch_pbi_cmdline() {
502        while [ $# -gt 0 ]; do
503                case "$1" in
504                -o)     if [ $# -eq 1 ]; then usage_makepatch_pbi; fi
505                        shift; PBI_PATCHOUTDIR="$1"
506                        ;;
507            --sign)     if [ $# -eq 1 ]; then usage_makepatch_pbi; fi
508                        shift; PBI_SSLPRIVKEY="$1"
509                        ;;
510           --tmpfs)     PBI_MP_TMPFS="YES" 
511                        ;;
512     --no-checksig)     PBI_SKIPSIGVERIFY="YES" ;;
513                 *)     if [ $# -gt 2  ]; then usage_makepatch_pbi; fi
514                        PBI_OLDFILENAME="$1"
515                        shift
516                        PBI_FILENAME="$1"
517                        ;;
518                esac
519                shift
520        done
521
522        if [ -z "${PBI_FILENAME}" ]; then usage_makepatch_pbi ; fi
523        if [ -z "${PBI_OLDFILENAME}" ]; then usage_makepatch_pbi ; fi
524        if [ -z "${PBI_PATCHOUTDIR}" ]; then PBI_PATCHOUTDIR=`pwd` ; fi
525
526        # Load all the information about this PBI / PBP
527        load_info_from_header
528}
529
530# Parse the command line for editing a meta file
531parse_mt_pbi_cmdline() {
532
533        case $1 in
534        syncpbi) PBI_MT_MODE="SYNCPBI" ; shift ;
535                PBI_MT_PBIFILE="$1"
536                PBI_MT_METAFILE="$2"
537                if [ -z "${PBI_MT_PBIFILE}" ] ; then usage_mt_syncpbi ; fi
538                if [ -z "${PBI_MT_METAFILE}" ] ; then usage_mt_syncpbi ; fi
539                return
540                ;;
541           add) PBI_MT_MODE="ADD" ; shift ;
542                while [ $# -gt 0 ]; do
543                        case "$1" in
544                      --cat) PBI_MT_TYPE="CAT" ;;
545                      --app) PBI_MT_TYPE="APP" ;;
546                        -m) if [ $# -eq 1  ]; then usage_mt_add; fi
547                            shift; PBI_MT_MAINTAINER="$1"
548                            ;;
549                        -n) if [ $# -eq 1  ]; then usage_mt_add; fi
550                            shift; PBI_MT_ADDNAME="$1"
551                            ;;
552                        -i) if [ $# -eq 1  ]; then usage_mt_add; fi
553                            shift; PBI_MT_ADDICON="$1"
554                            ;;
555                        -d) if [ $# -eq 1  ]; then usage_mt_add; fi
556                            shift; PBI_MT_ADDDESC="$1"
557                            ;;
558                        -s) if [ $# -eq 1  ]; then usage_mt_add; fi
559                            shift; PBI_MT_ADDSHORTDESC="$1"
560                            ;;
561                        -c) if [ $# -eq 1  ]; then usage_mt_add; fi
562                            shift; PBI_MT_ADDCAT="$1"
563                            ;;
564                        -a) if [ $# -eq 1  ]; then usage_mt_add; fi
565                            shift; PBI_MT_ADDAUTHOR="$1"
566                            ;;
567                        -u) if [ $# -eq 1  ]; then usage_mt_add; fi
568                            shift; PBI_MT_ADDURL="$1"
569                            ;;
570                        -l) if [ $# -eq 1  ]; then usage_mt_add; fi
571                            shift; PBI_MT_ADDLIC="$1"
572                            ;;
573                        -t) if [ $# -eq 1  ]; then usage_mt_add; fi
574                            shift; PBI_MT_ADDTYPE="$1"
575                            ;;
576                        -k) if [ $# -eq 1  ]; then usage_mt_add; fi
577                            shift; PBI_MT_ADDKEYWORDS="$1"
578                            ;;
579                        -r) PBI_MT_REQUIRESROOT="YES"
580                            ;;
581                         *) if [ $# -gt 1  ]; then usage_mt_add; fi
582                            PBI_MT_METAFILE="$1"
583                            ;;
584                        esac
585                        shift
586                done
587                if [ -z "${PBI_MT_METAFILE}" ] ; then usage_mt_add ; fi
588                ;;
589           rem) PBI_MT_MODE="REM" ; shift ;
590                while [ $# -gt 0 ]; do
591                        case "$1" in
592                      --cat) PBI_MT_TYPE="CAT" ;;
593                      --app) PBI_MT_TYPE="APP" ;;
594                        -n) if [ $# -eq 1  ]; then usage_mt_rem; fi
595                            shift; PBI_MT_REMNAME="$1"
596                            ;;
597                         *) if [ $# -gt 1  ]; then usage_mt_rem; fi
598                            PBI_MT_METAFILE="$1"
599                            ;;
600                        esac
601                        shift
602                done
603                if [ -z "${PBI_MT_METAFILE}" ] ; then usage_mt_rem ; fi
604                ;;
605             *) usage_mt_unknown ;;
606        esac
607
608        if [ ! -f "${PBI_MT_METAFILE}" ] ; then
609                exit_err "No such file ${PBI_MT_METAFILE}"
610        fi
611
612        # Sanity check the values
613        case ${PBI_MT_MODE} in
614                ADD) # Check the common values
615                     if [ -z "${PBI_MT_ADDNAME}" ] ; then usage_mt_add ; fi
616                     if [ -z "${PBI_MT_ADDDESC}" ] ; then usage_mt_add ; fi
617                     if [ -z "${PBI_MT_ADDICON}" ] ; then usage_mt_add ; fi
618
619                     if [ "$PBI_MT_TYPE" = "CAT" ]; then             
620                     elif [ "$PBI_MT_TYPE" = "APP" ]; then
621                        if [ -z "${PBI_MT_ADDCAT}" ]; then usage_mt_add ; fi
622                        if [ -z "${PBI_MT_ADDAUTHOR}" ]; then usage_mt_add ; fi
623                        if [ -z "${PBI_MT_ADDURL}" ]; then usage_mt_add ; fi
624                        if [ -z "${PBI_MT_ADDLIC}" ]; then usage_mt_add ; fi
625                        if [ -z "${PBI_MT_ADDTYPE}" ]; then usage_mt_add ; fi
626                     else
627                       usage_mt_add
628                     fi
629                ;;
630                REM) if [ "$PBI_MT_TYPE" != "CAT" -a "$PBI_MT_TYPE" != "APP" ]
631                     then
632                        usage_mt_rem
633                     fi
634                     if [ -z "${PBI_MT_REMNAME}" ] ; then usage_mt_rem ; fi
635                ;;
636        esac
637
638}
639
640# Parse the command line for editing a index file
641parse_it_pbi_cmdline() {
642
643        case $1 in
644           add) PBI_IT_MODE="ADD" ; shift ;
645                while [ $# -gt 0 ]; do
646                        case "$1" in
647                        -b) if [ $# -eq 1  ]; then usage_it_add; fi
648                            shift; PBI_IT_ADDBPVERS="$1"
649                            ;;
650                        -f) if [ $# -eq 1  ]; then usage_it_add; fi
651                            shift; PBI_IT_ADDFILE="$1"
652                            ;;
653                        -k) if [ $# -eq 1  ]; then usage_it_add; fi
654                            shift; PBI_IT_ADDKEEP="$1"
655                            ;;
656                        -u) if [ $# -eq 1  ]; then usage_it_add; fi
657                            shift; PBI_IT_ADDURL="$1"
658                            ;;
659                         *) if [ $# -gt 1  ]; then usage_it_add; fi
660                            PBI_IT_ADDINDEX="$1"
661                            ;;
662                        esac
663                        shift
664                done
665                ;;
666           rem) PBI_IT_MODE="REM" ; shift ;
667                while [ $# -gt 0 ]; do
668                        case "$1" in
669                        -m) if [ $# -eq 1  ]; then usage_it_rem; fi
670                            shift; PBI_IT_REMARCH="$1"
671                            ;;
672                        -n) if [ $# -eq 1  ]; then usage_it_rem; fi
673                            shift; PBI_IT_REMNAME="$1"
674                            ;;
675                        -v) if [ $# -eq 1  ]; then usage_it_rem; fi
676                            shift; PBI_IT_REMVER="$1"
677                            ;;
678                         *) if [ $# -gt 1  ]; then usage_it_rem; fi
679                            PBI_IT_REMINDEX="$1"
680                            ;;
681                        esac
682                        shift
683                done
684                ;;
685             *) usage_it_unknown ;;
686        esac
687
688        # Sanity check the values
689        case ${PBI_IT_MODE} in
690                ADD) if [ -z "${PBI_IT_ADDFILE}" ] ; then usage_it_add ; fi
691                     if [ -z "${PBI_IT_ADDURL}" ] ; then usage_it_add ; fi
692                     if [ -z "${PBI_IT_ADDINDEX}" ] ; then usage_it_add ; fi
693                     if [ ! -f "${PBI_IT_ADDFILE}" ] ; then
694                        exit_err "No such file ${PBI_IT_ADDFILE}"
695                     fi
696                     if [ ! -f "${PBI_IT_ADDINDEX}" ] ; then
697                        exit_err "No such file ${PBI_IT_ADDINDEX}"
698                     fi
699                     if [ -n "${PBI_IT_ADDKEEP}" ] ; then
700                        expr ${PBI_IT_ADDKEEP} + 1 >/dev/null 2>/dev/null
701                        if [ "$?" != "0" ] ; then
702                                exit_err "-k option must be a integer!"
703                        fi
704                     fi
705                ;;
706                REM) if [ -z "${PBI_IT_REMNAME}" ] ; then usage_it_rem ; fi
707                     if [ -z "${PBI_IT_REMVER}" ] ; then usage_it_rem ; fi
708                     if [ -z "${PBI_IT_REMARCH}" ] ; then usage_it_rem ; fi
709                     if [ -z "${PBI_IT_REMINDEX}" ] ; then usage_it_rem ; fi
710                ;;
711        esac
712
713}
714
715# Parse the command line for browsing a repo
716parse_browse_pbi_cmdline() {
717        while [ $# -gt 0 ]; do
718                case "$1" in
719        --listcats)     PBI_BROWSE_LISTCATS="YES" ;;
720         --viewall)     PBI_BROWSE_LISTALLPBI="YES" ;;
721                -c)     if [ $# -eq 1  ]; then usage_browse_pbi; fi
722                        shift; PBI_BROWSE_CAT="$1"
723                        ;;
724                -s)     if [ $# -eq 1  ]; then usage_browse_pbi; fi
725                        shift; PBI_BROWSE_SEARCH="$1"
726                        ;;
727                 *)     if [ $# -gt 1  ]; then usage_browse_pbi; fi
728                        PBI_BROWSE_RID="$1"
729                        ;;
730                esac
731                shift
732        done
733
734        # Get / check the repoid
735        if [ -n "${PBI_BROWSE_RID}" ] ; then
736                ls ${PBI_DBREPODIR}/${PBI_BROWSE_RID}.* >/dev/null 2>/dev/null
737                if [ "$?" != "0" ] ; then
738                        exit_err "The specified repoid ${PBI_BROWSE_RID} does not exist!"
739                fi
740        else
741                for _repo in `ls ${PBI_DBREPODIR} 2>/dev/null`
742                do
743                        PBI_BROWSE_RID=`echo $_repo | cut -d '.' -f 1`
744                        break;
745                done
746                if [ -z "$PBI_BROWSE_RID" ] ; then exit_err "No available repos!" ; fi
747        fi
748
749        PBI_BROWSE_REPOMD5=`ls ${PBI_DBREPODIR}/${PBI_BROWSE_RID}.* 2>/dev/null | cut -d '.' -f 2`
750        PBI_BROWSE_METAFILE=`ls ${PBI_DBINDEXDIR}/${PBI_BROWSE_REPOMD5}*meta 2>/dev/null`
751        if [ -z "${PBI_BROWSE_METAFILE}" ] ; then
752                exit_err "The specified repo has no meta-file."
753        fi
754
755}
756
757# Parse the command line for listing repos
758parse_listrepo_pbi_cmdline() {
759        while [ $# -gt 0 ]; do
760                case "$1" in
761              --up)     PBI_LISTREPO_UP="YES" ;;
762            --down)     PBI_LISTREPO_DOWN="YES" ;;
763          --mirror)     if [ $# -eq 1  ]; then usage_listrepo_pbi; fi
764                        shift; PBI_LISTREPO_MIRROR="$1"
765                        ;;
766                 *)     if [ $# -gt 1  ]; then usage_listrepo_pbi; fi
767                        PBI_LISTREPO_ID="$1"
768                        ;;
769                esac
770                shift
771        done
772
773        if [ "${PBI_LISTREPO_UP}" = "YES" -a "${PBI_LISTREPO_DOWN}" = "YES" ]; then
774                exit_err "Options --up and --down can't both be used at once!"
775        fi
776        if [ "${PBI_LISTREPO_UP}" = "YES" -a -z "${PBI_LISTREPO_ID}" ]; then
777                exit_err "Missing Repo ID to move up in priority."
778        fi
779        if [ "${PBI_LISTREPO_DOWN}" = "YES" -a -z "${PBI_LISTREPO_ID}" ]; then
780                exit_err "Missing Repo ID to move down in priority."
781        fi
782        if [ -n "${PBI_LISTREPO_MIRROR}" -a -z "${PBI_LISTREPO_ID}" ]; then
783                exit_err "Missing Repo ID to change a specific mirror URL."
784        fi
785
786        if [ -n "${PBI_LISTREPO_ID}" ] ; then
787                ls ${PBI_DBREPODIR}/${PBI_LISTREPO_ID}.* >/dev/null 2>/dev/null
788                if [ "$?" != "0" ] ; then
789                        exit_err "The specified repoid ${PBI_LISTREPO_ID} does not exist!"
790                fi
791        fi
792}
793
794# Parse the command line for adding a new repo file
795parse_addrepo_pbi_cmdline() {
796        while [ $# -gt 0 ]; do
797                case "$1" in
798                 *)     if [ $# -gt 1  ]; then usage_addrepo_pbi; fi
799                        PBI_ADDREPO_FILE="$1"
800                        ;;
801                esac
802                shift
803        done
804
805        if [ -z "$PBI_ADDREPO_FILE" ] ; then
806                usage_addrepo_pbi
807        fi
808        if [ ! -f "$PBI_ADDREPO_FILE" ] ; then
809                exit_err "Repo file ${PBI_ADDREPO_FILE} does not exist!"
810        fi
811}
812
813# Parse the command line for deleting a repo
814parse_deleterepo_pbi_cmdline() {
815        while [ $# -gt 0 ]; do
816                case "$1" in
817                 *)     if [ $# -gt 1  ]; then usage_deleterepo_pbi; fi
818                        PBI_DELREPO_ID="$1"
819                        ;;
820                esac
821                shift
822        done
823
824        if [ -z "$PBI_DELREPO_ID" ] ; then
825                usage_deleterepo_pbi
826        fi
827}
828
829
830# Parse the command line for making a new repo file
831parse_makerepo_pbi_cmdline() {
832        while [ $# -gt 0 ]; do
833                case "$1" in
834             --key)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
835                        shift; PBI_MKREPO_KEY="$1"
836                        ;;
837             --url)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
838                        shift; PBI_MKREPO_URL="$1"
839                        ;;
840            --desc)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
841                        shift; PBI_MKREPO_DESC="$1"
842                        ;;
843          --mirror)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
844                        shift; PBI_MKREPO_MIRROR="$1"
845                        ;;
846                 *)     if [ $# -gt 1  ]; then usage_makerepo_pbi; fi
847                        PBI_MKREPO_OUTDIR="$1"
848                        ;;
849                esac
850                shift
851        done
852
853        if [ -z "${PBI_MKREPO_DESC}" ]; then usage_makerepo_pbi ; fi
854        if [ -z "${PBI_MKREPO_KEY}" ]; then usage_makerepo_pbi ; fi
855        if [ -z "${PBI_MKREPO_MIRROR}" ]; then usage_makerepo_pbi ; fi
856        if [ -z "${PBI_MKREPO_URL}" ]; then usage_makerepo_pbi ; fi
857        if [ -z "${PBI_MKREPO_OUTDIR}" ]; then PBI_MKREPO_OUTDIR="${HOME}"; fi
858        if [ ! -f "${PBI_MKREPO_KEY}" ]; then exit_err "The key file ${PBI_MKREPO_KEY} does not exist." ; fi
859       
860        # Make sure we have a valid URL format
861        echo "${PBI_MKREPO_URL}" | grep -q -e "^http://" -e "^https://" -e "^ftp://"
862        if [ $? -ne 0 ] ; then
863                exit_err "Repo URL must begin with http://, https://, or ftp://"
864        fi
865       
866
867}
868
869# Parse the command line for patching
870parse_patch_pbi_cmdline() {
871        while [ $# -gt 0 ]; do
872                case "$1" in
873                -e)     PBI_EXTRACTONLY="YES"
874                        ;;
875                -g)     PBI_ADD_GUIDISPLAY="YES" 
876                        ;;
877                -i)     PBI_ADD_INFODISPLAY="YES" 
878                        ;;
879                -o)
880                        if [ $# -eq 1 ]; then usage_patch_pbi; fi
881                        shift; PBI_ALTEXTRACT_DIR="$1"
882                        ;;
883     --checkscript)     PBI_CHECKSCRIPTS="YES" ;;
884         --no-hash)     PBI_DISABLEHASHDIR="YES" ;;
885     --no-checksum)     PBI_SKIPCHECKSUM="YES" ;;
886     --no-checksig)     PBI_SKIPSIGVERIFY="YES" ;;
887                 *)     if [ $# -gt 1 ]; then usage_patch_pbi; fi
888                        PBI_FILENAME="$1"
889                        ;;
890                esac
891                shift
892        done
893
894        if [ -z "${PBI_FILENAME}" ]; then usage_patch_pbi ; fi
895
896        # Get the absolute patch to the file
897        get_abspath "$PBI_FILENAME"
898        PBI_FILENAME="$_ABSPATH"
899
900        if [ ! -e "${PBI_FILENAME}" ]; then usage_patch_pbi ; fi
901
902        # Load all the information about this PBI / PBP
903        load_info_from_header
904
905        # Make sure this isn't a patch file
906        is_pbi_patch
907        if [ "$?" = "1" ] ; then
908                exit_err "This is not a PBP patch file"
909        fi
910
911        if [ -z "${PBI_ORIGPROGDIRPATH}" ]; then usage_patch_pbi ; fi
912
913        # Lastly set PBI_PROGDIRNAME
914        PBI_PROGDIRNAME="`echo ${PBI_ORIGPROGDIRPATH} | rev | cut -d '/' -f 1 | rev`"
915                       
916        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then
917                # If extracting to a alt-outdir, set it now
918                PBI_PROGDIRPATH="`pwd`/${PBI_PROGDIRNAME}"
919       
920                if [ -n "${PBI_ALTEXTRACT_DIR}" ]; then
921                        PBI_PROGDIRPATH="${PBI_ALTEXTRACT_DIR}/${PBI_PROGDIRNAME}"
922                fi     
923        else
924                # Set the extraction dir
925                PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}-patch"
926        fi
927}
928
929# Parse the command line for adding
930parse_add_pbi_cmdline() {
931        while [ $# -gt 0 ]; do
932                case "$1" in
933                -e)     PBI_EXTRACTONLY="YES"
934                        ;;
935                -f)     PBI_FORCEADD="YES"
936                        ;;
937                -g)     PBI_ADD_GUIDISPLAY="YES" 
938                        ;;
939                -i)     PBI_ADD_INFODISPLAY="YES" 
940                        ;;
941            --meta)     PBI_ADD_METADISPLAY="YES" 
942                        ;;
943                -l)     PBI_ADD_LICDISPLAY="YES" 
944                        ;;
945                -o)     if [ $# -eq 1 ]; then usage_add_pbi; fi
946                        shift; PBI_ALTEXTRACT_DIR="$1"
947                        ;;
948                -r)     PBI_REMOTEFETCH="YES" 
949                        ;;
950                -R)     PBI_REMOTEFETCH="YES" 
951                        PBI_REMOTEFETCHONLY="YES"
952                        ;;
953                -v)     PBI_VERBOSE="YES" 
954                        ;;
955           --rArch)     
956                        if [ $# -eq 1 ]; then usage_add_pbi; fi
957                        shift; PBI_ADD_ALTARCH="$1"
958                        ;;
959           --rVer)     
960                        if [ $# -eq 1 ]; then usage_add_pbi; fi
961                        shift; PBI_ADD_ALTVER="$1"
962                        ;;
963     --checkscript)     PBI_CHECKSCRIPTS="YES" ;;
964        --licagree)     PBI_LICAGREE="YES" ;;
965         --no-hash)     PBI_DISABLEHASHDIR="YES" ;;
966     --no-checksum)     PBI_SKIPCHECKSUM="YES" ;;
967     --no-checksig)     PBI_SKIPSIGVERIFY="YES" ;;
968            --repo)     if [ $# -eq 1 ]; then usage_add_pbi; fi
969                        shift; PBI_ADDREPO_ID="$1"
970                        ;;
971                 *)
972                        if [ $# -gt 1 ]; then usage_add_pbi; fi
973                        # If there is no file, try fetching from repo
974                        if [ ! -e "${1}" ] ; then PBI_REMOTEFETCH="YES"; fi
975                        PBI_FILENAME="$1"
976                        ;;
977                esac
978                shift
979        done
980
981        if [ -z "${PBI_FILENAME}" ]; then usage_add_pbi ; fi
982
983        # If we are doing a remote fetch / install then do it now
984        if [ "$PBI_REMOTEFETCH" = "YES" ] ; then
985                if [ -z "${PBI_ADDREPO_ID}" ] ; then
986                        PBI_ADDREPO_ID="AUTO"
987                else
988                        ls ${PBI_DBREPODIR}/${PBI_ADDREPO_ID}.* >/dev/null 2>/dev/null
989                        if [ "$?" != "0" ] ; then
990                                exit_err "No such repo ID: ${PBI_DELREPO_ID}"
991                        fi
992                fi
993
994                # Start fetching file
995                pbi_add_fetch_remote
996       
997        fi
998
999        # Load all the information about this PBI
1000        load_info_from_header
1001
1002        if [ -z "${PBI_ORIGPROGDIRPATH}" ]; then usage_add_pbi ; fi
1003
1004        # Make sure this isn't a patch file
1005        is_pbi_patch
1006        if [ "$?" = "0" ] ; then
1007                exit_err "This is a PBP patch file, use 'pbi_patch' instead"
1008        fi
1009
1010        # Lastly set PBI_PROGDIRNAME
1011        PBI_PROGDIRNAME="`echo ${PBI_ORIGPROGDIRPATH} | rev | cut -d '/' -f 1 | rev`"
1012
1013
1014        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then
1015                # If extracting to a alt-outdir, set it now
1016                PBI_PROGDIRPATH="`pwd`/${PBI_PROGDIRNAME}"
1017
1018                if [ -n "${PBI_ALTEXTRACT_DIR}" ]; then
1019                        PBI_PROGDIRPATH="${PBI_ALTEXTRACT_DIR}/${PBI_PROGDIRNAME}"
1020                fi
1021        else
1022                # Set the installation dir
1023                PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}"
1024        fi
1025}
1026
1027# Parse the command line
1028parse_autob_pbi_cmdline() {
1029        while [ $# -gt 0 ]; do
1030                case "$1" in
1031                -c)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1032                        if [ -n "${PBI_AB_CONFDIR}" ]; then usage_autob_pbi; fi
1033                        shift
1034                        get_abspath "$1"
1035                        PBI_AB_CONFDIR="$_ABSPATH"
1036                        if [ ! -d "${PBI_AB_CONFDIR}" ] ; then
1037                                exit_err "Invalid confdir (${PBI_AB_CONFDIR})"
1038                        fi
1039                        ;;
1040                -d)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1041                        shift
1042                        get_abspath "$1"
1043                        PORTSDIR="$_ABSPATH"
1044                        ;;
1045                -o)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1046                        shift
1047                        get_abspath "$1"
1048                        PBI_AB_OUTDIR="$_ABSPATH"
1049                        ;;
1050                -p)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1051                        shift
1052                        PBI_AB_BUILDERS="$1"
1053                        if [ ! $(is_num "$PBI_AB_BUILDERS") ] ; then
1054                                exit_err "Invalid process number specifed!"
1055                        fi
1056                        ;;
1057                -h)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1058                        shift
1059                        get_abspath "$1"
1060                        PBI_AB_HELPS="$_ABSPATH"
1061                        ;;
1062                -32)    if [ "$REALARCH" != "amd64" ] ; then
1063                                exit_err "-32 can only be used on amd64 host"
1064                        fi     
1065                        PBI_AB32="YES"
1066                        ARCH=i386
1067                        ;;
1068        -32fallback)    if [ "$REALARCH" != "amd64" ] ; then
1069                                exit_err "-32fallback can only be used on amd64 host"
1070                        fi     
1071                        PBI_ABFB32="YES"
1072                        ;;
1073
1074        --genpatch)     PBI_AB_GENPATCH="YES" 
1075                        ;;
1076        --pkgbuild)     PBI_AB_PKGBUILD="YES" 
1077                        ;;
1078            --keep)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1079                        shift; PBI_AB_ARCHIVENUM="$1"
1080                        expr $PBI_AB_ARCHIVENUM + 1 >/dev/null 2>/dev/null
1081                        if [ $? != 0 ] ; then usage_autob_pbi; fi
1082                        ;;
1083           --prune)     PBI_AB_PRUNE="YES" 
1084                        ;;
1085           --tmpfs)     PBI_AB_TMPFS="YES" 
1086                        ;;
1087            --sign)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1088                        shift; PBI_AB_SSLPRIVKEY="$1"
1089                        ;;
1090                 *)     usage_autob_pbi ;;
1091                esac
1092                shift
1093        done
1094
1095        if [ -z "$PBI_AB_OUTDIR" ] ; then usage_autob_pbi ; fi
1096        if [ -z "$PBI_AB_CONFDIR" ] ; then usage_autob_pbi ; fi
1097}
1098
1099
1100# Parse the command line
1101parse_create_pbi_cmdline() {
1102        while [ $# -gt 0 ]; do
1103                case "$1" in
1104                -a)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1105                        shift; PBI_CAUTHOR="$1"
1106                        ;;
1107                -b)     PBI_CBACKUP="YES"
1108                        ;;
1109                -c)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1110                        shift;
1111                        get_abspath "$1"
1112                        PBI_CONFDIR="$_ABSPATH"
1113                        if [ ! -d "${PBI_CONFDIR}" ] ; then
1114                                exit_err "Invalid confdir (${PBI_CONFDIR})"
1115                        fi
1116                        load_pbi_conffile
1117                        ;;
1118                -d)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1119                        shift; PORTSDIR="$1"
1120                        ;;
1121               --meta)  if [ $# -eq 1 ]; then usage_create_pbi; fi
1122                        shift; PBI_CREATE_USERMETA="$1"
1123                        if [ ! -e "$PBI_CREATE_USERMETA" ] ; then
1124                                exit_err "No such file: $PBI_CREATE_USERMETA"
1125                        fi
1126                        ;;
1127                -i)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1128                        shift; PBI_CICON="$1"
1129                        ;;
1130                -n)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1131                        shift; PBI_CNAME="$1"
1132                        ;;
1133                -o)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1134                        shift; PBI_CREATE_OUTDIR="$1"
1135                        ;;
1136                -p)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1137                        shift; PBI_MAKEPORT="$1"
1138                        ;;
1139                -r)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1140                        shift; PBI_CVERSION="$1"
1141                        ;;
1142                -w)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1143                        shift; PBI_CWEB="$1"
1144                        ;;
1145         --no-hash)     PBI_DISABLEHASHDIR="YES" ;;
1146            --sign)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1147                        shift; PBI_SSLPRIVKEY="$1"
1148                        ;;
1149                 *)
1150                        if [ $# -gt 1 ]; then usage_create_pbi; fi
1151                        if [ "$PBI_CBACKUP" = "YES" ] ; then
1152                                if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
1153                                        find_pbi_namematch "$1"
1154                                        if [ -z "$PBI_NAMEMATCH" ] ; then
1155                                                exit_err "can't find installed pbi (${1})"
1156                                        fi
1157                                        PBI_CBACKUPTARGET="${PBI_NAMEMATCH}"
1158                                        PBI_PROGDIRPATH="${PBI_NAMEMATCH}"
1159                                else
1160                                        PBI_CBACKUPTARGET="${1}"
1161                                        PBI_PROGDIRPATH="${1}"
1162                                fi
1163                        else
1164                                get_abspath "$1"
1165                                PBI_PROGDIRPATH="$_ABSPATH"
1166                                if [ ! -d "${PBI_PROGDIRPATH}" ] ; then
1167                                        exit_err "Invalid pbidir (${1})"
1168                                fi
1169                        fi
1170                        ;;
1171                esac
1172                shift
1173        done
1174
1175        # Make sure this port exists
1176        if [ -n "${PBI_MAKEPORT}" -a ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ]; then
1177                exit_err "No port (${PORTSDIR}/${PBI_MAKEPORT})"
1178        fi
1179
1180        # Load the name / version from specified port
1181        if [ -n "${PBI_MAKEPORT}" ]; then
1182                get_pbi_progversion
1183                get_pbi_progname
1184        fi
1185
1186        if [ -z "${PBI_PROGDIRPATH}" ]; then usage_create_pbi ; fi
1187
1188        # Remove any trailing '/' from PBI_MAKEPORT
1189        echo $PBI_MAKEPORT | grep -q "/$"
1190        if [ $? -eq 0 ] ; then
1191                PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
1192        fi
1193
1194        # Lastly set PBI_PROGDIRNAME
1195        PBI_PROGDIRNAME="`echo ${PBI_PROGDIRPATH} | rev | cut -d '/' -f 1 | rev`"
1196}
1197
1198# Override any pbi.conf values with passed command-line values
1199parse_cmdline_overrides() {
1200        if [ -n "${PBI_CNAME}" ] ; then PBI_PROGNAME="${PBI_CNAME}" ; fi
1201        if [ -n "${PBI_CVERSION}" ] ; then PBI_PROGVERSION="${PBI_CVERSION}" ; fi
1202        if [ -n "${PBI_CWEB}" ] ; then PBI_PROGWEB="${PBI_CWEB}" ; fi
1203        if [ -n "${PBI_CAUTHOR}" ] ; then PBI_PROGAUTHOR="${PBI_CAUTHOR}" ; fi
1204        if [ -n "${PBI_CICON}" ] ; then PBI_PROGICON="${PBI_CICON}" ; fi
1205}
1206
1207# Parse the command line
1208parse_make_pbi_cmdline() {
1209        while [ $# -gt 0 ]; do
1210                case "$1" in
1211                -B)     PBI_BUILDONLY="YES"
1212                        ;;
1213                -c)
1214                        if [ $# -eq 1 ]; then usage_make_pbi; fi
1215                        if [ -n "${PBI_CONFDIR}" ]; then usage_make_pbi; fi
1216                        shift
1217                        get_abspath "$1"
1218                        PBI_CONFDIR="$_ABSPATH"
1219                        ;;
1220                -d)
1221                        if [ $# -eq 1 ]; then usage_make_pbi; fi
1222                        shift; PORTSDIR="$1" ; export PORTSDIR
1223                        ;;
1224
1225                -32)    if [ "$REALARCH" != "amd64" -a "`basename $0`" != "pbi_makeport_chroot" ] ; then
1226                                exit_err "-32 can only be used on amd64 host"
1227                        fi     
1228                        ARCH=i386
1229                        ;;
1230
1231                -k)     PBI_KEEPBUILDFILES="YES"
1232                        ;;
1233
1234                --delbuild)     MKDELBUILD="YES"
1235                        ;;
1236                --no-prune)     PBI_PRUNEBUILDPORTS="NO"
1237                        ;;
1238                --mkdebug)      MKDEBUG="YES"
1239                        ;;
1240                --pkgbuild)     PBI_PKGNGBUILD="YES"
1241                        ;;
1242                --tmpfs)        MKTMPFS="YES"
1243                        ;;
1244               --meta)  if [ $# -eq 1 ]; then usage_make_pbi; fi
1245                        shift; PBI_CREATE_USERMETA="$1"
1246
1247                        # If running the chroot portion, reset the location
1248                        if [ "`basename $0`" = "pbi_makeport_chroot" ] ; then
1249                                PBI_CREATE_USERMETA="/user-meta"
1250                        fi
1251
1252                        # Check to ensure it exists
1253                        if [ ! -e "$PBI_CREATE_USERMETA" ] ; then
1254                                exit_err "No such file: $PBI_CREATE_USERMETA"
1255                        fi
1256                        ;;
1257                -o)     if [ $# -eq 1 ]; then usage_make_pbi; fi
1258                        shift
1259                        get_abspath "$1"
1260                        PBI_CREATE_OUTDIR="$_ABSPATH"
1261                        ;;
1262                -p)     if [ $# -eq 1 ]; then usage_make_pbi; fi
1263                        if [ -n "${PBI_MAKEPREFIX}" ]; then usage_make_pbi; fi
1264                        shift; PBI_MAKEPREFIX="$1"
1265                        ;;
1266            --sign)     if [ $# -eq 1 ]; then usage_make_pbi; fi
1267                        shift
1268                        get_abspath "$1"
1269                        PBI_SSLPRIVKEY="$_ABSPATH"
1270                        ;;
1271                 *)
1272                        if [ $# -gt 1 ]; then usage_make_pbi; fi
1273                        PBI_MAKEPORT="$1"
1274                        ;;
1275                esac
1276                shift
1277        done
1278
1279        # Override some locations if working in chroot environment
1280        if [ "`basename $0`" = "pbi_makeport_chroot" ] ; then
1281                if [ -n "${PBI_CONFDIR}" ] ; then PBI_CONFDIR="/pbimodule" ; fi
1282                if [ -n "${PBI_SSLPRIVKEY}" ] ; then PBI_SSLPRIVKEY="/privkey.pem" ; fi
1283                if [ -n "${PBI_CREATE_OUTDIR}" ] ; then PBI_CREATE_OUTDIR="/pbiout" ; fi
1284                if [ -n "${PORTSDIR}" ] ; then PORTSDIR="/usr/ports" ; fi
1285        fi
1286
1287
1288        # Make sure this port exists
1289        if [ ! -d "${PORTSDIR}/${PBI_MAKEPORT}" -a "$PBI_PKGNGBUILD" != "YES" ] ; then
1290                exit_err "No port (${PORTSDIR}/${PBI_MAKEPORT})"
1291        fi
1292
1293        # Remove any trailing '/' from PBI_MAKEPORT
1294        echo $PBI_MAKEPORT | grep -q "/$"
1295        if [ $? -eq 0 ] ; then
1296                PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
1297        fi
1298
1299        # Make sure we have a valid PBI_CONFDIR
1300        if [ -n "${PBI_CONFDIR}" -a ! -d "${PBI_CONFDIR}" ] ; then
1301                exit_err "Invalid confdir (${PBI_CONFDIR})"
1302        fi
1303
1304        # Source the config file
1305        if [ -n "${PBI_CONFDIR}" ]; then load_pbi_conffile ; fi
1306
1307        if [ -z "${PBI_MAKEPORT}" ]; then
1308                usage_make_pbi
1309        fi
1310}
1311
1312# Parse the update command line
1313parse_update_pbi_cmdline() {
1314        while [ $# -gt 0 ]; do
1315                case "$1" in
1316                -c)     PBI_UPCHECK="YES" ;;
1317       --check-all)     PBI_UPCHECK="ALL" ;;
1318    --disable-auto)     PBI_UPENABLEAUTO="NO" ;;
1319     --enable-auto)     PBI_UPENABLEAUTO="YES" ;;
1320      --update-all)     PBI_UPDATEAPP="ALL" ;;
1321                 *)     if [ $# -gt 1 ]; then usage_update_pbi; fi
1322                        if [ -n "$PBI_UPDATEAPP" ] ; then usage_update_pbi ; fi
1323                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
1324                                find_pbi_namematch "$1"
1325                                if [ -z "$PBI_NAMEMATCH" ] ; then
1326                                        exit_err "can't find installed pbi (${1})"
1327                                fi
1328                                PBI_UPDATEAPP="$PBI_NAMEMATCH"
1329                        else
1330                                PBI_UPDATEAPP="$1"
1331                        fi
1332                        ;;
1333                esac
1334                shift
1335        done
1336
1337        if [ "${PBI_UPDATEAPP}" = "ALL" -a -n "${PBI_UPCHECK}" ] ; then
1338                usage_update_pbi
1339        fi
1340
1341        # Make sure we aren't trying to enable auto-updating for ALL
1342        if [ "${PBI_UPDATEAPP}" = "ALL" -a -n "${PBI_UPENABLEAUTO}" ] ; then
1343                usage_update_pbi
1344        fi
1345        if [ -z "${PBI_UPDATEAPP}" -a -n "${PBI_UPENABLEAUTO}" ] ; then
1346                usage_update_pbi
1347        fi
1348
1349        if [ -z "${PBI_UPDATEAPP}" -a "${PBI_UPCHECK}" != "ALL" ]; then
1350                usage_update_pbi
1351        fi
1352}
1353
1354# Make some of our required PBI dirs
1355mk_required_dirs() {
1356        if [ ! -d "${PBI_APPDIR}" ] ; then mkdir -p ${PBI_APPDIR} >/dev/null 2>/dev/null ; fi
1357        if [ ! -d "${PBI_XDGCFGDIR}" ] ; then mkdir -p ${PBI_XDGCFGDIR} >/dev/null 2>/dev/null ; fi
1358        if [ ! -d "${PBI_XDGAPPDIR}" ] ; then mkdir -p ${PBI_XDGAPPDIR} >/dev/null 2>/dev/null ; fi
1359        if [ ! -d "${PBI_XDGDIRDIR}" ] ; then mkdir -p ${PBI_XDGDIRDIR} >/dev/null 2>/dev/null ; fi
1360        if [ ! -d "${PBI_XDGICONDIR}" ] ; then mkdir -p ${PBI_XDGICONDIR} >/dev/null 2>/dev/null ; fi
1361        if [ ! -d "${PBI_XDGMIMEDIR}" ] ; then mkdir -p ${PBI_XDGMIMEDIR} >/dev/null 2>/dev/null ; fi
1362        if [ ! -d "${PBI_RCDIR}" ] ; then mkdir -p ${PBI_RCDIR} >/dev/null 2>/dev/null ; fi
1363        if [ ! -d "${PBI_BINDIR}" ] ; then mkdir -p ${PBI_BINDIR} >/dev/null 2>/dev/null ; fi
1364        if [ ! -d "${PBI_MANDIR}" ] ; then mkdir -p ${PBI_MANDIR} >/dev/null 2>/dev/null ; fi
1365        if [ ! -d "${PBI_HASHDIR}" ] ; then mkdir -p ${PBI_HASHDIR} >/dev/null 2>/dev/null ; fi
1366        if [ ! -d "${PBI_DBAPPDIR}" ] ; then mkdir -p ${PBI_DBAPPDIR} >/dev/null 2>/dev/null ; fi
1367        if [ ! -d "${PBI_DBKEYDIR}" ] ; then mkdir -p ${PBI_DBKEYDIR} >/dev/null 2>/dev/null ; fi
1368        if [ ! -d "${PBI_DBMIRRORDIR}" ] ; then mkdir -p ${PBI_DBMIRRORDIR} >/dev/null 2>/dev/null ; fi
1369        if [ ! -d "${PBI_DBICONDIR}" ] ; then mkdir -p ${PBI_DBICONDIR} >/dev/null 2>/dev/null ; fi
1370        if [ ! -d "${PBI_DBINDEXDIR}" ] ; then mkdir -p ${PBI_DBINDEXDIR} >/dev/null 2>/dev/null ; fi
1371        if [ ! -d "${PBI_DBREPODIR}" ] ; then mkdir -p ${PBI_DBREPODIR} >/dev/null 2>/dev/null ; fi
1372        if [ ! -d "${PBI_DBHASHQUEUEDIR}" ] ; then mkdir -p ${PBI_DBHASHQUEUEDIR} >/dev/null 2>/dev/null ; fi
1373
1374        # Set the permissions for directories if we are running as root
1375        if [ `id -u` != "0" ] ; then return ; fi
1376
1377        for cDir in $PBI_APPDIR $PBI_DBAPPDIR $PBI_DBHASHQUEUEDIR $PBI_XDGCFGDIR $PBI_XDGAPPDIR $PBI_XDGDIRDIR $PBI_XDGICONDIR $PBI_XDGMIMEDIR
1378        do     
1379                chown root:${PBI_INSTALLGROUP} ${cDir}
1380                chmod 775 ${cDir}
1381        done
1382
1383        # Make sure the hash-dirty file can be written to by all
1384        touch ${PBI_DBDIRTYFILE}
1385        chown root:${PBI_INSTALLGROUP} ${PBI_DBDIRTYFILE}
1386        chmod 664 ${PBI_DBDIRTYFILE}
1387}
1388
1389# Get the absolute path of a dir, even a realative dir. 'realpath' doesn't work here
1390get_abspath() {
1391        D=`dirname "$1"`
1392        B=`basename "$1"`
1393        if [ "$D" = "/" ] ; then
1394                _ABSPATH="/$B"
1395        else
1396                _ABSPATH="`cd \"$D\" 2>/dev/null && pwd || echo \"$D\"`/$B"
1397        fi
1398}
1399
1400
1401# Initialize some vars
1402init_vars() {
1403
1404        # Set sys vars
1405        REALARCH="`uname -m`"
1406        ARCH="$REALARCH"
1407
1408        # Where is pbi-manager installed?
1409        PROGBASE=/usr/local
1410        SYS_LOCALBASE=/usr/local
1411        PBI_SHARE_DIR="${PROGBASE}/share/pbi-manager"
1412        if [ -z "${PBI_APPDIR}" -o "`basename $0`" = "pbi_makeport_chroot" ] ; then
1413                PBI_APPDIR="/usr/pbi"
1414        fi
1415        # Set the FreeBSD Major & Release
1416        FBSDREL=`uname -r | cut -d "-" -f 1-2`
1417        FBSDMAJOR=`echo $FBSDREL | cut -d "-" -f 1 | cut -d '.' -f 1`
1418
1419        PBI_WORLDCHROOT="${PBI_APPDIR}/.pbi-world-$ARCH"
1420        if [ `id -u` = "0" ] ; then
1421                PBI_HASHDIR="${PBI_APPDIR}/.hashdir"
1422        else
1423                PBI_HASHDIR="${PBI_APPDIR}/.hashdir-`whoami`"
1424        fi
1425        PBI_AB_BUILDERS=1
1426        PBI_XDGCFGDIR="${PBI_APPDIR}/etc/xdg/menus"
1427        PBI_XDGAPPDIR="${PBI_APPDIR}/share/applications"
1428        PBI_XDGDIRDIR="${PBI_APPDIR}/share/desktop-directories"
1429        PBI_XDGICONDIR="${PBI_APPDIR}/share/icons/hicolor"
1430        PBI_XDGMIMEDIR="${PBI_APPDIR}/share/mime/packages"
1431        PBI_RCDIR="${PBI_APPDIR}/rc.d"
1432        PBI_BINDIR="${PBI_APPDIR}/bin"
1433        PBI_MANDIR="${PBI_APPDIR}/man"
1434        PBI_ETCCONF="${SYS_LOCALBASE}/etc/pbi.conf"
1435        PCBSD_ETCCONF="${SYS_LOCALBASE}/etc/pcbsd.conf"
1436        PBI_DEFAULT_ICON="${PROGBASE}/share/pbi-manager/icons/default.png"
1437        PBI_DEFAULT_ICON_CHROOT="/default.png"
1438        PBI_PATCH_ICON="${PROGBASE}/share/pbi-manager/icons/patch.png"
1439        PBI_LDCONFIGFILE="${PROGBASE}/etc/ldpbiconfig"
1440        PBI_LDCONFIGRC="${PROGBASE}/etc/rc.d/ldpbiconfig"
1441
1442        # Set the PBI DB dir
1443        if [ -z "${PBI_DBDIR}" ] ; then
1444                PBI_DBDIR="/var/db/pbi"
1445        fi
1446        PBI_DBKEYDIR="${PBI_DBDIR}/keys"
1447        PROGVERSION="1.0"
1448
1449        # Load the etc/pbi.conf file
1450        load_pbi_etcconf
1451
1452        # Overrides from pbi.conf
1453        if [ -z "$PBIDSLEEP" ] ; then
1454                PBIDSLEEP="300" # Amount of time to sleep before waking up pbid
1455        fi
1456        if [ -z "$PBI_INDEXREFRESH" ] ; then
1457                PBI_INDEXREFRESH="24" # Hours to wait until we re-download PBI indexes
1458        fi
1459        if [ -n "$PBI_MAJORVERSION" ] ; then
1460                FBSDMAJOR=${PBI_FBSDMAJOR}
1461        fi
1462
1463        PBI_LOG_LINES="500"
1464        PBI_INSTALLGROUP="operator"
1465
1466        # What dirs do we build hash-lists of
1467        HASH_SEARCH_DIRS="lib share include info man"
1468
1469        # What dbus dirs do we parse for setting up services
1470        DBUS_SEARCH_DIRS="share/dbus-1 kde4/share/dbus-1 gnome/share/dbus-1"
1471
1472        # Don't modify unless you know what your doing!
1473        MOD_PREINS="pre-install.sh"
1474        MOD_POSTINS="post-install.sh"
1475        MOD_PREREM="pre-remove.sh"
1476        MOD_XDGDESK_DIR="xdg-desktop"
1477        MOD_XDGMENU_DIR="xdg-menu"
1478        MOD_XDGMIME_DIR="xdg-mime"
1479        MOD_EXTLINKFILE="external-links"
1480        MOD_AUTOEXTLINKFILE=".auto-external-links"
1481        PBI_ADD_GUIDISPLAY="NO"
1482        PBI_ADD_INFODISPLAY="NO"
1483        PBI_ADD_METADISPLAY="NO"
1484        PBI_ADD_LICDISPLAY="NO"
1485        PBI_APPDESK_DIR=".${MOD_XDGDESK_DIR}"
1486        PBI_APPMENU_DIR=".${MOD_XDGMENU_DIR}"
1487        PBI_APPMIME_DIR=".${MOD_XDGMIME_DIR}"
1488        PBI_BUILD_USERS=""
1489        PBI_BUILD_GROUPS=""
1490        PBI_INS_USERSFILE=".pbi-uids"
1491        PBI_INS_GROUPSFILE=".pbi-gids"
1492        PBI_DESKADD="NO"
1493        PBI_MENUADD="NO"
1494        PBI_MIMEADD="NO"
1495        PBI_PATHADD="NO"
1496        PBI_DESKDEL="NO"
1497        PBI_MAKECONF="/etc/pbi-make.conf"
1498        PBI_MENUDEL="NO"
1499        PBI_MIMEDEL="NO"
1500        PBI_PATHDEL="NO"
1501        PBI_DELETENAME=""
1502        PBI_FAKEBIN_DIR="bin"
1503        PBI_FAKERC_DIR="rc.d"
1504        PBI_FILENAME=""
1505        PBI_FORCEADD="NO"
1506        PBI_HASHLIST=".pbi-hash-list"
1507        PBI_INDEXUPFILE="pbi-index-$FBSDMAJOR"
1508        PBI_METAUPFILE="pbi-meta-$FBSDMAJOR"
1509        PBI_INFONAME=""
1510        PBI_INS_DESKSCRIPT="install-desktop-icons.sh"
1511        PBI_INS_MENUSCRIPT="install-menu-icons.sh"
1512        PBI_INS_MIMESCRIPT="install-mime.sh"
1513        PBI_INS_PATHSCRIPT="install-pathlinks.sh"
1514        PBI_ICDIR="pbi-shared-icons"
1515        PBI_LISTREPO_UP=""
1516        PBI_LISTREPO_DOWN=""
1517        PBI_LISTREPO_MIRROR=""
1518        PBI_LICAGREE="NO"
1519        PBI_LICENSEFILE="LICENSE"
1520        PBI_USERMETAFILE="metafile"
1521        PBI_PATCHVERSION=""
1522        PBI_PATCHTARGET=""
1523        PBI_REMOTEFETCH=""
1524        PBI_REMOTEFETCHONLY=""
1525        PBI_RESOURCE_DIR="resources"
1526        PBI_SS_ICON="__PBI_ICON__"
1527        PBI_SS_ARCHIVE="__PBI_ARCHIVE__"
1528        PBI_SSLPRIVKEY=""
1529        PBI_TMPDIR="/tmp/.PBI.$$"
1530        PBI_TMPHASHLIST=""
1531        PBI_UPCHECK=""
1532        PBI_UPDATEAPP=""
1533        PBI_UNINS_DESKSCRIPT="uninstall-desktop-icons.sh"
1534        PBI_UNINS_MENUSCRIPT="uninstall-menu-icons.sh"
1535        PBI_UNINS_MIMESCRIPT="uninstall-mime.sh"
1536        PBI_UNINS_PATHSCRIPT="uninstall-pathlinks.sh"
1537
1538        # User overridable variables
1539        MKDELBUILD=""
1540        MKDEBUG=""
1541        MKTMPFS=""
1542        PBI_AB_ARCHIVENUM=""
1543        PBI_AB_CONFDIR=""
1544        PBI_AB_GENPATCH="NO"
1545        PBI_AB_HELPS=""
1546        PBI_AB_OUTDIR=""
1547        PBI_AB_SSLPRIVKEY=""
1548        PBI_AB_PRUNE=""
1549        PBI_AB_TMPFS=""
1550        PBI_BUILDONLY="NO"
1551        PBI_CAUTHOR=""
1552        PBI_CBACKUP=""
1553        PBI_CBACKUPTARGET=""
1554        PBI_CHECKSCRIPTS=""
1555        PBI_CICON=""
1556        PBI_CNAME=""
1557        PBI_CONFDIR=""
1558        PBI_CONFFILE="pbi.conf"
1559        PBI_CONF_SCRIPTSDIR="scripts/"
1560        PBI_CREATE_OUTDIR="$HOME"
1561        PBI_CREATE_HASHLIST="YES"
1562        PBI_CUPDATE=""
1563        PBI_CWEB=""
1564        PBI_DBAPPDIR="${PBI_DBDIR}/installed"
1565        PBI_DBDIRTYFILE="${PBI_DBDIR}/.hashdirty"
1566        PBI_DBHASHQUEUEDIR="${PBI_DBDIR}/.hashqueue"
1567        PBI_DBICONDIR="${PBI_DBDIR}/repo-icons"
1568        PBI_DBINDEXDIR="${PBI_DBDIR}/index"
1569        PBI_DBMIRRORDIR="${PBI_DBDIR}/mirrors"
1570        PBI_DBREPODIR="${PBI_DBDIR}/repos"
1571        PBI_DISABLEHASHDIR="NO"
1572        PBI_GUITOPBANNER="gui_banner.png"
1573        PBI_GUISIDEBANNER="gui_sidebanner.png"
1574        PBI_KEEPBUILDFILES="NO"
1575        PBI_MAKEPORT=""
1576        PBI_MAKEPREFIX=""
1577        PBI_MAKEOPTS=""
1578        PBI_MKPORTBEFORE=""
1579        PBI_MKPORTAFTER=""
1580        PBI_PORTSDIR=""
1581        PBI_PROGAUTHOR=""
1582        PBI_PROGMDATE=""
1583        PBI_PROGEPOCH=""
1584        PBI_PROGNAME=""
1585        PBI_PROGDIRNAME=""
1586        PBI_PROGDIRPATH=""
1587        PBI_PROGICON=""
1588        PBI_PROGREVISION=""
1589        PBI_PROGVERSION=""
1590        PBI_PROGWEB=""
1591        PBI_PRUNEBUILDPORTS="YES"
1592        PBI_SKIPCHECKSUM=""
1593        PBI_SKIPSIGVERIFY=""
1594        PBI_USESYSGL="YES"
1595        PBI_USESYSFONTS="YES"
1596        PBI_VERBOSE="NO"
1597        PORTSDIR="/usr/ports"
1598
1599}
1600
1601detect_pkgng()
1602{
1603        export PKG_ADD="pkg add"
1604        export PKG_DELETE="pkg delete -y -f"
1605}
1606
1607# Set and export vars used by module scripts
1608export_script_vars() {
1609        # Load some initial values
1610        get_pbi_progdir
1611        get_pbi_progversion
1612
1613        export PBI_PROGNAME PBI_PROGDIRNAME PBI_PROGDIRPATH PBI_PROGVERSION PBI_RCDIR PBI_MANDIR PBI_BINDIR
1614        export SYS_LOCALBASE PBI_FAKEBIN_DIR PBI_FAKERC_DIR
1615}
1616
1617# init tmpdir
1618init_tmpdir() {
1619        if [ -d "${PBI_TMPDIR}" ] ; then return; fi
1620        if [ -z "${PBI_TMPDIR}" ] ; then return ; fi
1621        if [ "${PBI_TMPDIR}" = "/" ] ; then return ; fi
1622        if [ -e "${PBI_TMPDIR}" ] ; then rm -rf "${PBI_TMPDIR}" ; fi
1623        mkdir -p "${PBI_TMPDIR}"
1624}
1625
1626# rm tmpdir
1627rm_tmpdir() {
1628        if [ -z "${PBI_TMPDIR}" -o "${PBI_TMPDIR}" = "/" ] ; then return 0; fi
1629        if [ -e "${PBI_TMPDIR}" ] ; then rm -rf "${PBI_TMPDIR}" ; fi
1630}
1631
1632# rm tmpdir
1633rm_buildfiles() {
1634        if [ "${PBI_KEEPBUILDFILES}" = "YES" ] ; then return ; fi
1635        if [ -z "$PBI_CHROOTDIR" ] ; then return ; fi
1636        chroot_make_cleanup
1637}
1638
1639# Load PBI conf options
1640load_pbi_conffile() {
1641        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
1642        if [ -e "${PBI_CONFDIR}/${PBI_CONFFILE}" ] ; then
1643                unset PBI_MAKEPORT PBI_BUILDKEY PBI_REQUIRESROOT PBI_PROGNAME PBI_PROGWEB PBI_PROGAUTHOR PBI_PROGICON PBI_MKPORTBEFORE PBI_MKPORTAFTER PBI_MAKEOPTS PBI_EXCLUDELIST PBI_AB_PRIORITY PBI_HASH_EXCLUDES PBI_AB_NOTMPFS PBI_PROGREVISION PBI_PROGREVISION PBI_AB_NOPKGBUILD
1644                . ${PBI_CONFDIR}/${PBI_CONFFILE}
1645
1646                # Remove any trailing '/' from PBI_MAKEPORT
1647                echo $PBI_MAKEPORT | grep -q "/$"
1648                if [ $? -eq 0 ] ; then
1649                        PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
1650                fi
1651        fi
1652}
1653
1654# Get the PBI_PROGVERSION
1655get_pbi_progversion() {
1656
1657        if [ -n "${PBI_PROGVERSION}" ] ; then return 0 ; fi
1658
1659        load_pbi_conffile
1660
1661        # If we have PBI_PROGVERSION now set
1662        if [ -n "${PBI_PROGVERSION}" ] ; then return 0 ; fi
1663
1664        # Remove any trailing '/'
1665        echo $PBI_MAKEPORT | grep -q "/$"
1666        if [ $? -eq 0 ] ; then
1667                PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
1668        fi
1669
1670        # Check first if we have this pkg in PKGNG
1671        if [ -n "$PBI_PKGNGBUILD" -a -z "$PBI_AB_NOPKGBUILD" ] ; then
1672                testPkgVer="`pkg-static rquery '%v' ${PBI_MAKEPORT}`"
1673                if [ -n "$testPkgVer" ] ; then
1674                        PBI_PROGVERSION="$testPkgVer"
1675                        # If we have a REVISION, use it as well
1676                        if [ -n "$PBI_PROGREVISION" ] ; then
1677                                PBI_PROGVERSION="${PBI_PROGVERSION}_${PBI_PROGREVISION}"
1678                        fi
1679                        export PBI_PROGVERSION
1680                        return 0
1681                fi
1682                exit_err "Failed to get PBI_PROGVERSION for ${PBI_MAKEPORT}"
1683        fi
1684
1685        # Get the version from ports
1686        if [ -z "${PBI_PROGVERSION}" -a -n "${PORTSDIR}" -a -n "${PBI_MAKEPORT}" ] ; then
1687                PORTVER="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V DISTVERSION PORTSDIR=${PORTSDIR} 2>/dev/null`"
1688
1689                # Check if we have a portrevision to use in version number
1690                PORTREV=""
1691                PORTREV="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V PORTREVISION PORTSDIR=${PORTSDIR} 2>/dev/null`"
1692                if [ -n "${PORTREV}" -a "${PORTREV}" != "0" ]
1693                then
1694                        PBI_PROGVERSION="${PORTVER}_${PORTREV}"
1695                else
1696                        PBI_PROGVERSION="${PORTVER}"
1697                fi
1698
1699                if [ -z "${PBI_PROGVERSION}" ] ; then
1700                        echo "Warning: Unable to set PBI_PROGVERSION with:"
1701                        echo "make -C ${PORTSDIR}/${PBI_MAKEPORT} -V DISTVERSION PORTSDIR=${PORTSDIR}"
1702                fi
1703        else
1704                echo "PBI_PROGVERSION - $PBI_PROGVERSION - PORTSDIR - ${PORTSDIR} - $PBI_MAKEPORT - $PBI_MAKE_PORT - pbi - $pbi"
1705                exit_err "Failed to locate PBI_PROGVERSION"
1706        fi
1707
1708        # If we have a REVISION, use it as well
1709        if [ -n "$PBI_PROGREVISION" ] ; then
1710                PBI_PROGVERSION="${PBI_PROGVERSION}_${PBI_PROGREVISION}"
1711        fi
1712}
1713
1714
1715# Get the PBI_PROGNAME
1716get_pbi_progname() {
1717        if [ -z "${PBI_PROGNAME}" -o "${PBI_PROGNAME}" = " " ] ; then
1718                load_pbi_conffile
1719        else
1720                return 0
1721        fi
1722
1723        if [ -z "${PBI_PROGNAME}" -a -n "${PORTSDIR}" -a -n "${PBI_MAKEPORT}" ] ; then
1724                # Get the proper package name from the prefix + name + suffix
1725                local pkgPrefix="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V PKGNAMEPREFIX PORTSDIR=${PORTSDIR}`"
1726                local pkgName="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V PORTNAME PORTSDIR=${PORTSDIR}`"
1727                local pkgSuffix="`make -C ${PORTSDIR}/${PBI_MAKEPORT} -V PKGNAMESUFFIX PORTSDIR=${PORTSDIR}`"
1728                PBI_PROGNAME="${pkgPrefix}${pkgName}${pkgSuffix}"
1729        else
1730                exit_err "Failed to locate PBI_PROGNAME"
1731        fi
1732}
1733
1734# Get the PBI PROGDIR Name
1735get_pbi_progdir() {
1736        if [ -z "${PBI_PROGNAME}" ] ; then
1737                get_pbi_progname
1738        fi
1739
1740        tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]' | sed 's|+||g'`"
1741        if [ -z "${PBI_PROGDIRNAME}" ] ; then
1742                PBI_PROGDIRNAME="${tmp}-${ARCH}"
1743        fi
1744        if [ -z "${PBI_PROGDIRPATH}" ] ; then
1745                PBI_PROGDIRPATH="${PBI_APPDIR}/${PBI_PROGDIRNAME}"
1746        fi
1747}
1748
1749# Helper function to exit after a error, and do some cleanup
1750exit_err() {
1751        echo -e "`basename ${0}`: ${1}"
1752        rm_tmpdir
1753        rm_buildfiles
1754        rm_pbipatchfiles
1755        chroot_make_cleanup
1756        clean_remote_dl
1757        exit 255
1758}
1759
1760# Check if we need to cleanup patch files
1761rm_pbipatchfiles() {
1762        if [ -z "${_pbiNewDir}${_pbiOldDir}${_pbiPatchDir}" ] ; then
1763                return
1764        else
1765                echo "Cleaning up patch data..."
1766        fi
1767
1768        # If we used tmpfs, unmount the dirs
1769        if [ "$PBI_MP_TMPFS" = "YES" ] ; then
1770                umount "${_pbiNewDir}" 2>/dev/null
1771                umount "${_pbiOldDir}" 2>/dev/null
1772                umount "${_pbiPatchDir}" 2>/dev/null
1773        fi
1774
1775        if [ -n "${_pbiNewDir}" -a -d "${_pbiNewDir}" -a "${_pbiNewDir}" != "/" ] ; then
1776                rm -rf "${_pbiNewDir}" >/dev/null 2>/dev/null
1777                chflags -R noschg "${_pbiNewDir}" >/dev/null 2>/dev/null
1778                rm -rf "${_pbiNewDir}" >/dev/null 2>/dev/null
1779        fi
1780        if [ -n "${_pbiOldDir}" -a -d "${_pbiOldDir}" -a "${_pbiOldDir}" != "/" ] ; then
1781                rm -rf "${_pbiOldDir}" >/dev/null 2>/dev/null
1782                chflags -R noschg "${_pbiOldDir}" >/dev/null 2>/dev/null
1783                rm -rf "${_pbiOldDir}" >/dev/null 2>/dev/null
1784        fi
1785        if [ -n "${_pbiPatchDir}" -a -d "${_pbiPatchDir}" -a "${_pbiPatchDir}" != "/" ] ; then
1786                rm -rf "${_pbiPatchDir}" >/dev/null 2>/dev/null
1787                chflags -R noschg "${_pbiPatchDir}" >/dev/null 2>/dev/null
1788                rm -rf "${_pbiPatchDir}" >/dev/null 2>/dev/null
1789        fi
1790}
1791
1792# Check if we need to delete a remotely dl'd file
1793clean_remote_dl() {
1794        # If this was a remote fetch, remove dl'd file
1795        if [ "$PBI_REMOTEFETCH" = "YES" -a -n "$PBI_FILENAME" ]; then
1796                rm "$PBI_FILENAME" >/dev/null 2>/dev/null
1797        fi
1798}
1799
1800# Set port make options from config
1801set_make_options() {
1802
1803        local MAKE_CONF="/etc/make.conf"
1804
1805        echo "PACKAGE_BUILDING=yes" >> ${MAKE_CONF}
1806        echo "BATCH=yes" >> ${MAKE_CONF}
1807        echo "NO_IGNORE=yes" >> ${MAKE_CONF}
1808        echo "PACKAGE_BUILDING=yes" >> ${MAKE_CONF}
1809        echo "WITH_PKGNG=yes" >> ${MAKE_CONF}
1810
1811        echo "WRKDIRPREFIX=/usr/wrkdirprefix" >> ${MAKE_CONF}
1812        echo "DEPENDS_CLEAN=YES" >> ${MAKE_CONF}
1813
1814        if [ -n "$PBI_MAKEOPTS" ] ; then
1815                # Check if we have custom make opts
1816                echo "${PBI_MAKEOPTS}" >> ${MAKE_CONF}
1817        fi
1818
1819        if [ ! -d "/usr/local" ] ; then
1820                mkdir -p /usr/local
1821        fi 
1822
1823        # Make sure ldconfig is primed
1824        /etc/rc.d/ldconfig start
1825
1826        if [ -z "$PBI_PKGNGBUILD" ] ; then
1827                echo "Building pkgng..."
1828                cd /usr/ports/ports-mgmt/pkg
1829                make install clean
1830                if [ $? -ne 0 ] ; then exit_err "Failed building pkgng!" ; fi
1831        fi
1832
1833        # Check if using ccache directory
1834        if [ -d "/.ccache" ] ; then
1835                echo "Enabling ccache..."
1836                cd /usr/ports/devel/ccache
1837                make install clean
1838                if [ $? -eq 0 ] ; then
1839                        # Setup environment variables
1840                        CCACHE_PATH="/usr/bin:/usr/local/bin"
1841                        export CCACHE_PATH
1842                        CCACHE_DIR="/.ccache"
1843                        export CCACHE_DIR
1844                        PATH="/usr/local/libexec/ccache:${PATH}"
1845                        export PATH
1846
1847                        # Setup make configuration
1848                        echo ".if !defined(NO_CCACHE)" >> ${MAKE_CONF}
1849                        echo "  CC=/usr/local/libexec/ccache/world/cc" >> ${MAKE_CONF}
1850                        echo "  CXX=/usr/local/libexec/ccache/world/c++" >> ${MAKE_CONF}
1851                        echo ".endif" >> ${MAKE_CONF}
1852                else
1853                        echo "Failed installing ccache! Continuing without it..."
1854                fi
1855        fi
1856
1857        PATH="${PATH}:/usr/local/bin:/usr/local/sbin"
1858        export PATH
1859
1860        FORCE_PKG_REGISTER="Y"
1861        export FORCE_PKG_REGISTER
1862
1863}
1864
1865# Confirm we are running as root
1866require_root() {
1867  if [ `id -u` != "0" ] ; then
1868     exit_err "Must be run as root!"
1869  fi 
1870}
1871
1872# Confirm we are running as root or the proper group for installation
1873require_root_or_group() {
1874  if [ `id -u` = "0" ] ; then return 0 ; fi
1875  touch ${PBI_APPDIR}/.ptest.$$ >/dev/null 2>/dev/null
1876  if [ "$?" = "0" ] ; then
1877        rm ${PBI_APPDIR}/.ptest.$$ >/dev/null 2>/dev/null
1878        return 0
1879  fi
1880  exit_err "Must be run as root or a member of the $PBI_INSTALLGROUP group!"
1881}
1882
1883# Function to get the username from a file
1884get_username_from_file() {
1885        if [ -f "${1}" ] ; then
1886                FILEUSER=`ls -al ${1} | awk '{print $3}'`
1887                export FILEUSER
1888                return 0
1889        fi
1890        if [ -d "${1}" ] ; then
1891                FILEUSER=`ls -al ${1} | grep -v "total" | head -n 1 | awk '{print $3}'`
1892                export FILEUSER
1893                return 0
1894        fi
1895        exit_err "Invalid file for usercheck!"
1896}
1897
1898# Start the make patch process
1899pbi_makepatch_init() {
1900        require_root
1901        init_tmpdir
1902        parse_makepatch_pbi_cmdline "$@"
1903
1904        # Create a new patch file from the two PBIs specified
1905        make_pbi_patchfile "${PBI_FILENAME}" "${PBI_OLDFILENAME}" "${PBI_PATCHOUTDIR}"
1906}
1907
1908# Remove a repo from the DB
1909pbi_deleterepo_init() {
1910        require_root
1911        parse_deleterepo_pbi_cmdline "$@"
1912
1913        delete_pbi_repo
1914}
1915
1916# Do the removal of a PBI repo
1917delete_pbi_repo() {
1918        # Make sure this repo exists
1919        ls ${PBI_DBREPODIR}/${PBI_DELREPO_ID}.* >/dev/null 2>/dev/null
1920        if [ "$?" != "0" ] ; then
1921                exit_err "No such repo ID: ${PBI_DELREPO_ID}"
1922        fi
1923       
1924        _md5=`ls ${PBI_DBREPODIR}/${PBI_DELREPO_ID}.* | sed "s|^${PBI_DBREPODIR}/${PBI_DELREPO_ID}.||g"`
1925        if [ -e "${PBI_DBREPODIR}/${PBI_DELREPO_ID}.${_md5}" ] ; then
1926                rm "${PBI_DBREPODIR}/${PBI_DELREPO_ID}.${_md5}"
1927        else
1928                echo "Warning: ${PBI_DELREPO_ID}.${_md5} does not exist in the database."
1929        fi
1930        if [ -e "${PBI_DBKEYDIR}/${_md5}.ssl" ] ; then
1931                rm "${PBI_DBKEYDIR}/${_md5}.ssl"
1932        else
1933                echo "Warning: ${_md5}.ssl does not exist in the keys database."
1934        fi
1935        if [ -e "${PBI_DBMIRRORDIR}/${_md5}" ] ; then
1936                rm "${PBI_DBMIRRORDIR}/${_md5}"
1937        else
1938                echo "Warning: ${_md5} does not exist in the mirror database."
1939        fi
1940       
1941        # See if we need to remove a downloaded index file
1942        if [ -e "${PBI_DBINDEXDIR}/${_md5}-index" ] ; then
1943                rm "${PBI_DBINDEXDIR}/${_md5}-index"
1944                rm "${PBI_DBINDEXDIR}/${_md5}-index.time"
1945        fi
1946
1947        # Make sure we renumber the repos
1948        renumber_repos
1949
1950        echo "Deleted Repository ${PBI_DELREPO_ID}."
1951
1952}
1953
1954# After deleting a repo, this can be run to renumber the IDs
1955renumber_repos() {
1956        _rNum="1"
1957        for i in `ls ${PBI_DBREPODIR} | sort`
1958        do
1959                case `echo ${_rNum} | wc -m | tr -d ' '` in
1960                        2) _rNum="00${_rNum}" ;;
1961                        3) _rNum="0${_rNum}" ;;
1962                        *) ;;
1963                esac
1964
1965                _md5=`echo ${i} | cut -d '.' -f 2`
1966                mv "${PBI_DBREPODIR}/${i}" "${PBI_DBREPODIR}/${_rNum}.${_md5}"
1967
1968                _rNum=`expr ${_rNum} + 1`
1969        done
1970}
1971
1972# Add a new repo to the db
1973pbi_addrepo_init() {
1974        require_root
1975        parse_addrepo_pbi_cmdline "$@"
1976
1977        # Create a new repo file
1978        add_pbi_repo
1979}
1980
1981# Extract the repo and add it to the DB
1982add_pbi_repo() {
1983        init_tmpdir
1984        tar xvf "${PBI_ADDREPO_FILE}" -C ${PBI_TMPDIR} >/dev/null 2>/dev/null
1985        if [ "$?" != "0" ] ; then
1986                exit_err "Failed to read ${PBI_ADDREPO_FILE}"
1987        fi
1988        if [ ! -f "${PBI_TMPDIR}/repokey.ssl" -o ! -f "${PBI_TMPDIR}/repo-url" -o ! -f "${PBI_TMPDIR}/repo-desc" -o ! -f "${PBI_TMPDIR}/repo-mirror" ] ; then
1989                exit_err "Improperly packaged repo file!"
1990        fi
1991
1992        # Make sure we don't have a duplicate repo key
1993        for tr in ${PBI_PUBKEYS}
1994        do
1995                diff -q ${tr} ${PBI_TMPDIR}/repokey.ssl >/dev/null 2>/dev/null
1996                if [ "$?" = "0" ] ; then
1997                        exit_err "Repo with identical key already registered!"
1998                fi
1999        done
2000
2001        # Figure out the next repo number
2002        get_next_repo_num
2003
2004        _md5=`md5 -q ${PBI_TMPDIR}/repo-url`
2005        _url=`cat ${PBI_TMPDIR}/repo-url`
2006        _desc=`cat ${PBI_TMPDIR}/repo-desc`
2007        echo "URL: ${_url}" > ${PBI_DBREPODIR}/${_rNum}.${_md5}
2008        echo "Desc: ${_desc}" >> ${PBI_DBREPODIR}/${_rNum}.${_md5}
2009        cp ${PBI_TMPDIR}/repo-mirror ${PBI_DBMIRRORDIR}/${_md5}
2010        cp "${PBI_TMPDIR}/repokey.ssl" "${PBI_DBKEYDIR}/${_md5}.ssl"
2011        chmod 755 "${PBI_DBKEYDIR}/${_md5}.ssl"
2012       
2013        rm_tmpdir
2014
2015        echo "Added new repo: \"${_desc}\" to the database."
2016
2017}
2018
2019# Function to do listing of installed repos, and return next available number
2020get_next_repo_num() {
2021        _rNum="0"
2022        for i in `ls ${PBI_DBREPODIR} | sort`
2023        do
2024                _rNum=`expr ${_rNum} + 1`
2025        done
2026
2027        _rNum=`expr ${_rNum} + 1`
2028
2029        case `echo ${_rNum} | wc -m | tr -d ' '` in
2030                2) _rNum="00${_rNum}" ;;
2031                3) _rNum="0${_rNum}" ;;
2032                *) ;;
2033        esac
2034
2035        export _rNum
2036}
2037
2038# Start the make patch process
2039pbi_makerepo_init() {
2040        require_root
2041        parse_makerepo_pbi_cmdline "$@"
2042
2043        # Create a new repo file
2044        make_pbi_repo
2045}
2046
2047# Create the repo .rpo file
2048make_pbi_repo() {
2049        init_tmpdir
2050
2051        mkdir ${PBI_TMPDIR}/.mkrepo
2052        cp ${PBI_MKREPO_KEY} ${PBI_TMPDIR}/.mkrepo/repokey.ssl
2053        echo "${PBI_MKREPO_URL}" >  ${PBI_TMPDIR}/.mkrepo/repo-url
2054        echo "${PBI_MKREPO_DESC}" >  ${PBI_TMPDIR}/.mkrepo/repo-desc
2055        echo "${PBI_MKREPO_MIRROR}" | sed 's|,|\
2056|g' > ${PBI_TMPDIR}/.mkrepo/repo-mirror
2057
2058
2059        tar cvzf ${PBI_MKREPO_OUTDIR}/pbi-repo.rpo -C ${PBI_TMPDIR}/.mkrepo . >/dev/null 2>/dev/null
2060        echo "New PBI Repo created: ${PBI_MKREPO_OUTDIR}/pbi-repo.rpo"
2061
2062        rm_tmpdir
2063}
2064
2065do_pbi_mt_syncpbi()
2066{
2067        # First load values from the target PBI
2068        PBI_FILENAME="${PBI_MT_PBIFILE}"
2069        load_info_from_header
2070
2071        if [ "$PBI_REQUIRESROOT" = "YES" ] ; then
2072                PBI_MT_REQUIRESROOT="YES"
2073        fi
2074
2075        PBI_MT_MAINTAINER="${PBI_MAINTAINER}"
2076        PBI_MT_ADDNAME="$PBI_PROGNAME"
2077        PBI_MT_ADDDESC="`echo ${PBI_DESC} | sed 's|;||g' | sed 's|\"||g'`"
2078        PBI_MT_ADDSHORTDESC="`echo ${PBI_SHORTDESC} | sed 's|;||g' | sed 's|\"||g'`"
2079        PBI_MT_ADDTYPE="$PBI_PROGTYPE"
2080        PBI_MT_ADDLIC="$PBI_LICENSE"
2081        PBI_MT_ADDCAT="$PBI_CATEGORY"
2082        PBI_MT_ADDAUTHOR="$PBI_PROGAUTHOR"
2083        PBI_MT_ADDURL="$PBI_PROGWEB"
2084        PBI_MT_ADDKEYWORDS="$PBI_TAGS"
2085        if [ -n "$PBI_ICONURL" ] ; then
2086                PBI_MT_ADDICON="$PBI_ICONURL"
2087        else
2088                PBI_MT_ADDICON="http://images.pbidir.com/progicons/generic.png"
2089        fi
2090
2091        do_pbi_mt_add_app
2092}
2093
2094# Init the metatool
2095pbi_mt_init() {
2096        parse_mt_pbi_cmdline "$@"
2097        case $PBI_MT_MODE in
2098            SYNCPBI) do_pbi_mt_syncpbi ;;
2099                ADD) if [ "$PBI_MT_TYPE" = "CAT" ] ; then
2100                        do_pbi_mt_add_cat
2101                     else
2102                        do_pbi_mt_add_app
2103                     fi ;;
2104                REM) if [ "$PBI_MT_TYPE" = "CAT" ] ; then
2105                        do_pbi_mt_rem_cat "${PBI_MT_REMNAME}" "${PBI_MT_METAFILE}"
2106                     else
2107                        do_pbi_mt_rem_app "${PBI_MT_REMNAME}" "${PBI_MT_METAFILE}"
2108                     fi ;;
2109                  *) ;;
2110        esac
2111}
2112
2113do_pbi_mt_add_cat() {
2114        init_tmpdir
2115
2116        # Remove any duplicate name
2117        do_pbi_mt_rem_cat "${PBI_MT_ADDNAME}" "${PBI_MT_METAFILE}"
2118
2119        cp ${PBI_MT_METAFILE} ${PBI_TMPDIR}/.meta.$$
2120        echo "Cat=${PBI_MT_ADDNAME};${PBI_MT_ADDICON};${PBI_MT_ADDDESC};" \
2121        >> ${PBI_TMPDIR}/.meta.$$
2122        sort ${PBI_TMPDIR}/.meta.$$ > "${PBI_MT_METAFILE}"
2123        rm ${PBI_TMPDIR}/.meta.$$
2124       
2125}
2126
2127do_pbi_mt_add_app() {
2128        init_tmpdir
2129        # Remove any duplicate name
2130        do_pbi_mt_rem_app "${PBI_MT_ADDNAME}" "${PBI_MT_METAFILE}"
2131
2132        local _date=`date '+%s'`
2133
2134        cp ${PBI_MT_METAFILE} ${PBI_TMPDIR}/.meta.$$
2135        echo "App=${PBI_MT_ADDNAME};${PBI_MT_ADDCAT};${PBI_MT_ADDICON};${PBI_MT_ADDAUTHOR};${PBI_MT_ADDURL};${PBI_MT_ADDLIC};${PBI_MT_ADDTYPE};${PBI_MT_ADDKEYWORDS};${PBI_MT_ADDDESC};$PBI_MT_REQUIRESROOT;${_date};${PBI_MT_MAINTAINER};${PBI_MT_ADDSHORTDESC};" \
2136        >> ${PBI_TMPDIR}/.meta.$$
2137        sort ${PBI_TMPDIR}/.meta.$$ > "${PBI_MT_METAFILE}"
2138        rm ${PBI_TMPDIR}/.meta.$$
2139}
2140
2141do_pbi_mt_rem_cat() {
2142        sed -i '' "\|^Cat=${1};|d" "${2}"
2143}
2144
2145do_pbi_mt_rem_app() {
2146        sed -i '' "\|^App=${1};|d" "${2}"
2147}
2148
2149# Init the indextool
2150pbi_it_init() {
2151        parse_it_pbi_cmdline "$@"
2152        case $PBI_IT_MODE in
2153                ADD) do_pbi_it_add ;;
2154                REM) do_pbi_it_rem ;;
2155                  *) ;;
2156        esac
2157}
2158
2159# Remove a target PBI from an index
2160do_pbi_it_rem() {
2161        init_tmpdir
2162        _pbilow="`echo ${PBI_IT_REMNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2163
2164        cat "${PBI_IT_REMINDEX}" | grep -v "^${_pbilow}:${PBI_IT_REMARCH}:${PBI_IT_REMVER}" \
2165                > "${PBI_TMPDIR}/.indextmp"
2166        sort ${PBI_TMPDIR}/.indextmp > "${PBI_IT_REMINDEX}"
2167
2168        rm_tmpdir
2169}
2170
2171# Add a new PBI to the specified INDEX file
2172do_pbi_it_add() {
2173        init_tmpdir
2174
2175        # First load values from the target PBI
2176        PBI_FILENAME="$PBI_IT_ADDFILE"
2177        load_info_from_header
2178
2179        # Get the name in lower-case
2180        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2181       
2182        # Prune any old copies of this app from the index
2183        prune_from_index "$_pbilow" "$PBI_APPARCH"
2184       
2185        # Prune any old copies of this app from the index
2186        mark_current_active_index "$_pbilow" "$PBI_APPARCH"
2187
2188        # Add the new index entry
2189        add_to_index
2190        rm_tmpdir
2191}
2192
2193# Mark any current versions of this PBI as active in the index
2194mark_current_active_index() {
2195
2196        while read iLine
2197        do
2198                echo "$iLine" | grep "^${1}:${2}:" >/dev/null 2>/dev/null
2199                if [ "$?" != "0" ] ; then
2200                        echo "$iLine" >> ${PBI_TMPDIR}/.indextmp       
2201                        continue
2202                fi
2203                echo "$iLine" | sed 's|:current|:active|' >> ${PBI_TMPDIR}/.indextmp   
2204
2205        done < $PBI_IT_ADDINDEX 
2206        mv "${PBI_TMPDIR}/.indextmp" "${PBI_IT_ADDINDEX}"
2207}
2208
2209# Add the specified PBI to the index
2210add_to_index() {
2211        mv "${PBI_IT_ADDINDEX}" "${PBI_TMPDIR}/.indextmp"
2212        local _date=`date '+%s'`
2213        local _sha256=`sha256 -q ${PBI_FILENAME}`
2214        local _psize=`du -k ${PBI_FILENAME} | cut -f 1`
2215        echo "${_pbilow}:${PBI_APPARCH}:${PBI_PROGVERSION}:${_sha256}:${PBI_PROGMDATE}:${PBI_IT_ADDURL}:$_date:${PBI_IT_ADDBPVERS}:current:${_psize}:" >>"${PBI_TMPDIR}/.indextmp"
2216        sort ${PBI_TMPDIR}/.indextmp > "${PBI_IT_ADDINDEX}"
2217}
2218
2219
2220# Remove a set number of PBIs from the index
2221prune_from_index() {
2222        if [ -z "$PBI_IT_ADDKEEP" ]; then return ; fi
2223
2224        local found="0"
2225        local added="0"
2226        while read iLine
2227        do
2228                echo "$iLine" | grep "^${1}:${2}:" >/dev/null 2>/dev/null
2229                if [ "$?" != "0" ] ; then
2230                        # Ready to add back the saved lines
2231                        if [ $found -ne 0 ] ; then
2232                                while read fLine
2233                                do
2234                                  if [ $found -le $PBI_IT_ADDKEEP ] ; then
2235                                     echo "$fLine" >> ${PBI_TMPDIR}/.indextmp   
2236                                  fi
2237                                  found=`expr $found - 1`
2238                                done < ${PBI_TMPDIR}/.foundtmp
2239                        fi
2240                        echo "$iLine" >> ${PBI_TMPDIR}/.indextmp       
2241                        continue
2242                fi
2243                found=`expr $found + 1`
2244                echo "$iLine" >> ${PBI_TMPDIR}/.foundtmp       
2245        done < $PBI_IT_ADDINDEX 
2246        mv "${PBI_TMPDIR}/.indextmp" "${PBI_IT_ADDINDEX}"
2247}
2248
2249# Add a new repo to the db
2250pbi_browser_init() {
2251        parse_browse_pbi_cmdline "$@"
2252        init_tmpdir
2253
2254        # Check if we are doing a category listing, the default if no options
2255        if [ "$PBI_BROWSE_LISTCATS" = "YES" -o -z "${PBI_BROWSE_LISTALLPBI}${PBI_BROWSE_CAT}${PBI_BROWSE_SEARCH}" ] ; then
2256                pbi_browse_listcats
2257        else
2258                pbi_browse_listpbi
2259        fi
2260
2261}
2262
2263# List PBIs from a repo
2264pbi_browse_listpbi() {
2265        _rArch=`uname -m`
2266
2267        # Figure out which type of display we are doing
2268        if [ -n "$PBI_BROWSE_LISTALLPBI" ] ; then
2269                echo "Using RepoID: $PBI_BROWSE_RID"
2270                echo "Listing all available PBIs"
2271                grep -i -e "^App=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2272        elif [ -n "$PBI_BROWSE_CAT" ] ; then
2273                echo "Using RepoID: $PBI_BROWSE_RID"
2274                echo "Available PBIs for Category: $PBI_BROWSE_CAT"
2275                grep -i -e "^App=" -i -e ";${PBI_BROWSE_CAT};" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2276        elif [ -n "$PBI_BROWSE_SEARCH" ] ; then
2277                echo "Using RepoID: $PBI_BROWSE_RID"
2278                echo "Searching for: $PBI_BROWSE_SEARCH"
2279                grep -i -e "^App=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2280        else
2281                exit_err "No valid search variable set!"
2282        fi
2283
2284        while read app
2285        do
2286                line=`echo $app | sed 's|^App=||g'`
2287                catCheck=`echo $line | cut -d ';' -f 2 2>/dev/null`
2288                aName=`echo $line | cut -d ';' -f 1 2>/dev/null`
2289
2290                # Make sure this is from the correct category
2291                if [ -n "$PBI_BROWSE_CAT" ] ; then
2292                        _cCheck=`echo $catCheck | tr '[:lower:]' '[:upper:]'`
2293                        _cCheck2=`echo $PBI_BROWSE_CAT | tr '[:lower:]' '[:upper:]'`
2294                        if [ "$_cCheck" != "$_cCheck2" ]; then
2295                        continue
2296                        fi
2297                fi
2298
2299                # Set the displayed arch type
2300                aArch="$_rArch"
2301
2302                # Make sure this application has an associated PBI available
2303                check_pbi_update "$aName" "nodisplay" \
2304                 "$aName" "current" \
2305                 "$FBSDMAJOR" "$_rArch" "${PBI_BROWSE_RID}"
2306                if [ "$?" != "0" ] ; then
2307                        # On amd64, see if 32bit version exists
2308                        if [ "$_rArch" = "amd64" ] ; then
2309                                check_pbi_update "$aName" "nodisplay" \
2310                                "$aName" "current" \
2311                                "$FBSDMAJOR" "i386" "${PBI_BROWSE_RID}"
2312                                if [ "$?" != "0" ] ; then
2313                                        continue
2314                                else
2315                                        # Found a 32bit version of the app
2316                                        aArch="i386"
2317                                fi
2318                        else
2319                                # Not on amd64, continue on
2320                                continue
2321                        fi
2322                fi
2323
2324                aIcon=`echo $line | cut -d ';' -f 3`
2325                aAuthor=`echo $line | cut -d ';' -f 4`
2326                aUrl=`echo $line | cut -d ';' -f 5`
2327                aLic=`echo $line | cut -d ';' -f 6`
2328                aType=`echo $line | cut -d ';' -f 7`
2329                aKeywords=`echo $line | cut -d ';' -f 8`
2330                aDesc=`echo $line | cut -d ';' -f 9`
2331                aRoot=`echo $line | cut -d ';' -f 10`
2332
2333                # Check for a translation to the description
2334                get_meta_trans "App" "$cName" "${PBI_BROWSE_METAFILE}"
2335                if [ -n "$MTRANS" ] ; then
2336                        aDesc="$MTRANS"
2337                fi
2338
2339                # Search the description / keywords
2340                if [ -n "$PBI_BROWSE_SEARCH" ] ; then
2341                        echo "$aName,$aDesc,$aKeywords,$MTRANS" | grep -i "$PBI_BROWSE_SEARCH" >/dev/null 2>/dev/null
2342                        if [ "$?" != "0" ]; then continue ; fi
2343                fi
2344
2345                # Get the local icon file
2346                ext=`echo $aIcon | sed 's/.*\.//'`
2347                aIcon="${PBI_DBICONDIR}/${PBI_BROWSE_REPOMD5}-${aName}.${ext}"
2348
2349                echo "------------------------------------"
2350                echo "Application: $aName"
2351                echo "Version: $PBI_UPNVER"
2352                if [ -n "$PBI_UPSIZE" ] ; then
2353                        echo "Size: $PBI_UPSIZE"
2354                fi
2355                if [ -n "$PBI_BROWSE_LISTALLPBI" ] ; then
2356                        echo "Category: $catCheck"
2357                fi
2358                echo "Created: `echo $PBI_UPMDATE`"
2359                if [ "$aRoot" = "YES" ] ; then
2360                        echo "RootInstall: YES"
2361                else
2362                        echo "RootInstall: NO"
2363                fi
2364                echo "Arch: $aArch"
2365                echo "Author: $aAuthor"
2366                echo "URL: $aUrl"
2367                echo "License: $aLic"
2368                echo "Type: $aType"
2369                echo "Keywords: $aKeywords"
2370                echo "Icon: $aIcon"
2371                echo "Description: $aDesc"
2372                echo ""
2373                if [ "$aRoot" = "YES" ] ; then
2374                        echo "To install this PBI (As Root):"
2375                else
2376                        echo "To install this PBI:"
2377                fi
2378                echo "# pbi_add --rArch $aArch --repo $PBI_BROWSE_RID -r $aName"
2379                echo ""
2380
2381               
2382        done < ${PBI_TMPDIR}/.meta.$$
2383
2384}
2385
2386# List available categories for this repository
2387pbi_browse_listcats() {
2388
2389        echo "Using RepoID: $PBI_BROWSE_RID"
2390        echo "Available Categories:"
2391        grep "^Cat=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2392        while read cat
2393        do
2394                line=`echo $cat | sed 's|^Cat=||g'`
2395                cName=`echo $line | cut -d ';' -f 1`
2396                cIcon=`echo $line | cut -d ';' -f 2`
2397                cDesc=`echo $line | cut -d ';' -f 3`
2398               
2399                # Check for a translation to the description
2400                get_meta_trans "Cat" "$cName" "${PBI_BROWSE_METAFILE}"
2401                if [ -n "$MTRANS" ] ; then
2402                        cDesc="$MTRANS"
2403                fi
2404
2405                # Get the local icon file
2406                ext=`echo $cIcon | sed 's/.*\.//'`
2407                cIcon="${PBI_DBICONDIR}/${PBI_BROWSE_REPOMD5}-${cName}.${ext}"
2408
2409                echo "------------------------------------"
2410                echo "Category: $cName"
2411                echo "Icon: $cIcon"
2412                echo "Description: $cDesc"
2413                echo ""
2414
2415        done < ${PBI_TMPDIR}/.meta.$$
2416
2417        echo "To view available PBIs for a particular category:"
2418        echo " % pbi_browser -c <category> <repoid>"
2419}
2420
2421# Function to check if we have a translated description
2422get_meta_trans() {
2423        local tag="$1"
2424        local name="$2"
2425        local metaFile="$3"
2426
2427        # Check if we have a translation to overwrite with
2428        MTRANS=""
2429        if [ -z "$LANG" ] ; then return; fi
2430
2431        lCheck="`echo $LANG | cut -d '_' -f 1` `echo $LANG | cut -d '.' -f 1`"
2432        for l in $lCheck
2433        do
2434                catTrans=`grep "^${tag}\[$l\]=${name}" ${metaFile}`     
2435                if [ -n "$catTrans" ] ; then
2436                        MTRANS=`echo $catTrans | cut -d ";" -f 2`
2437                        return
2438                fi
2439        done
2440}
2441
2442# List repos in the db
2443pbi_listrepo_init() {
2444        require_root_or_group
2445        parse_listrepo_pbi_cmdline "$@"
2446
2447        # List the repos
2448        if [ -z "$PBI_LISTREPO_ID" ] ; then
2449                list_all_pbi_repo
2450        else
2451                if [ -n "${PBI_LISTREPO_UP}" ]; then
2452                        require_root
2453                        move_repo_up "${PBI_LISTREPO_ID}" 
2454                        list_all_pbi_repo
2455                elif [ -n "${PBI_LISTREPO_DOWN}" ] ; then
2456                        require_root
2457                        move_repo_down "${PBI_LISTREPO_ID}"
2458                        list_all_pbi_repo
2459                elif [ -n "${PBI_LISTREPO_MIRROR}" ] ; then
2460                        require_root
2461                        change_repo_mirror "${PBI_LISTREPO_ID}"
2462                        listrepo_details "${PBI_LISTREPO_ID}"
2463                else
2464                        listrepo_details "${PBI_LISTREPO_ID}"
2465                fi
2466        fi
2467}
2468
2469# Function to change a specific repos mirror URL
2470change_repo_mirror() {
2471        local _rMd5=`ls ${PBI_DBREPODIR}/${1}.* | cut -d '.' -f 2`
2472        echo "$PBI_LISTREPO_MIRROR" | sed 's|,|\
2473|g' > "${PBI_DBMIRRORDIR}/${_rMd5}"
2474}
2475
2476# Move a repo down in priority
2477move_repo_down() {
2478        _rFile=`ls ${PBI_DBREPODIR}/${1}.*`
2479        _uNum=`expr ${1} + 1`
2480
2481        case `echo ${_uNum} | wc -m | tr -d ' '` in
2482                2) _uNum="00${_uNum}" ;;
2483                3) _uNum="0${_uNum}" ;;
2484                *) ;;
2485        esac
2486        _uFile=`ls ${PBI_DBREPODIR}/${_uNum}.* 2>/dev/null`
2487        if [ -z "$_uFile" ] ; then exit_err "This repo is already at the lowest priority!" ; fi
2488
2489        _umd5=`echo $_uFile | cut -d '.' -f 2`
2490        mv "${_uFile}" "${PBI_DBREPODIR}/${1}.${_umd5}"
2491        _rmd5=`echo $_rFile | cut -d '.' -f 2`
2492        mv "${_rFile}" "${PBI_DBREPODIR}/${_uNum}.${_rmd5}"
2493}
2494
2495# Move a repo up in priority
2496move_repo_up() {
2497        _rFile=`ls ${PBI_DBREPODIR}/${1}.*`
2498        _uNum=`expr ${1} - 1`
2499
2500        case `echo ${_uNum} | wc -m | tr -d ' '` in
2501                2) _uNum="00${_uNum}" ;;
2502                3) _uNum="0${_uNum}" ;;
2503                *) ;;
2504        esac
2505        _uFile=`ls ${PBI_DBREPODIR}/${_uNum}.* 2>/dev/null`
2506        if [ -z "$_uFile" ] ; then exit_err "This repo is already at the highest priority!" ; fi
2507
2508        _umd5=`echo $_uFile | cut -d '.' -f 2`
2509        mv "${_uFile}" "${PBI_DBREPODIR}/${1}.${_umd5}"
2510        _rmd5=`echo $_rFile | cut -d '.' -f 2`
2511        mv "${_rFile}" "${PBI_DBREPODIR}/${_uNum}.${_rmd5}"
2512}
2513
2514# List all PBI repos
2515listrepo_details() {
2516        _rFile=`ls ${PBI_DBREPODIR}/${1}.*`
2517        _md5=`ls ${PBI_DBREPODIR}/${1}.* | cut -d '.' -f 2`
2518        _desc=`cat ${_rFile} | grep "Desc: " | sed "s|Desc: ||g"` 
2519        _url=`cat ${_rFile} | grep "URL: " | sed "s|URL: ||g"` 
2520        _mirror=`cat ${PBI_DBMIRRORDIR}/$_md5` 
2521        echo "Repo ID: ${1}"
2522        echo "Description: ${_desc}"
2523        echo "IndexURL: ${_url}"
2524        echo "MD5: ${_md5}"
2525        echo "LocalMeta: `ls ${PBI_DBINDEXDIR}/${_md5}*meta 2>/dev/null`"
2526        echo "LocalIndex: `ls ${PBI_DBINDEXDIR}/${_md5}*index 2>/dev/null`"
2527        echo "Mirror(s):"
2528        echo "$_mirror"
2529}
2530
2531# List all PBI repos
2532list_all_pbi_repo() {
2533        echo "[ID]      [Description]"
2534        echo "-----------------------------------------------------"
2535        for repo in `ls ${PBI_DBREPODIR} | sort `
2536        do
2537                _id=`echo $repo | cut -d '.' -f 1`
2538                _desc=`cat ${PBI_DBREPODIR}/${repo} | grep "Desc: " | sed "s|Desc: ||g"` 
2539                echo "${_id}    ${_desc}"
2540        done
2541}
2542
2543# Start the patch process
2544pbi_patch_init() {
2545        require_root_or_group
2546        init_tmpdir
2547        parse_patch_pbi_cmdline "$@"
2548
2549        # Check if we are only displaying information
2550        check_pbi_info_display
2551        check_pbi_gui_display
2552        check_pbi_scripts_display
2553        check_pbi_license_display
2554        if [ "$PBI_ADD_GUIDISPLAY" = "YES" -o "$PBI_ADD_INFODISPLAY" = "YES" -o "$PBI_CHECKSCRIPTS" = "YES" -o "${PBI_ADD_LICDISPLAY}" = "YES" -o "${PBI_ADD_METADISPLAY}" = "YES" ] 
2555        then
2556                exit_trap
2557        fi
2558
2559        # Try to apply this patch file
2560        do_pbi_patch
2561}
2562
2563# Start the PBI patch process
2564do_pbi_patch() {
2565       
2566        # Verify the target PBI is installed
2567        verify_pbi_update_target
2568
2569        pbi_verify_signatures
2570        pbi_verify_archivesum
2571       
2572        # Extract the archive contents
2573        mk_pbi_extract_dir
2574        pbi_extract_archive
2575
2576        set_patch_wrkdir
2577
2578        init_tmpdir
2579
2580        # Run the uninstall script
2581        if [ -e "${PBI_PATCHWRKDIR}/.sbin/.pbi-uninstall.sh" ] ; then
2582                echo "Removing old xdg data..."
2583                sh "${PBI_PATCHWRKDIR}/.sbin/.pbi-uninstall.sh" >/dev/null 2>/dev/null
2584        fi
2585
2586        # Remove old files from the installed PBI
2587        patch_rm_old_files
2588       
2589        # Extract the new files
2590        patch_extract_new_files
2591
2592        # Merge in the bsdiffs
2593        patch_merge_bsdiffs
2594
2595        # Make sure we have good permissions on this PBI
2596        patch_apply_chmod
2597
2598        # Run the install script
2599        if [ -e "${PBI_PATCHWRKDIR}/.sbin/.pbi-install.sh" ] ; then
2600                echo "Adding new xdg data..."
2601                sh "${PBI_PATCHWRKDIR}/.sbin/.pbi-install.sh"   >/dev/null 2>/dev/null
2602        fi
2603
2604        # If running as user, add bin path-links
2605        if [ "`id -u`" != "0" ] ; then add_app_path_links "${PBI_PATCHWRKDIR}" ; fi
2606
2607        # Update the registered version of the PBI
2608        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2609        oldDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHTARGET}-${PBI_APPARCH}"
2610        newDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHVERSION}-${PBI_APPARCH}"
2611        mv "$oldDir" "$newDir"
2612        rm ${newDir}/*.sha1 >/dev/null 2>/dev/null
2613
2614        # Register the app
2615        pbi_add_register_app   
2616
2617        # Check if we need to run a post-install.sh script again
2618        if [ -e "${newDir}/${MOD_POSTINS}" ] ; then
2619          export_script_vars
2620          sh "${newDir}/${MOD_POSTINS}"
2621        fi
2622
2623        # Cleanup after our selves
2624        if [ -d "$PBI_EXTRACTDIR" ] ; then
2625                echo "Cleaning up..."
2626                rm -rf "$PBI_EXTRACTDIR"
2627        fi
2628
2629        # Update the hashdir
2630        add_hashdir_trigger
2631
2632        # Mark the hash-dir as dirty as well
2633        make_hashdir_dirty
2634
2635        echo "Finished patching ${_pbilow}: $PBI_PATCHTARGET -> $PBI_PATCHVERSION"
2636}
2637
2638# Mark the hashdir as dirty
2639make_hashdir_dirty() {
2640        date "+%s" > "${PBI_DBDIRTYFILE}"
2641}
2642
2643# Do any chmod stuff after patching
2644patch_apply_chmod()
2645{
2646        if [ ! -e "${PBI_EXTRACTDIR}/PBI-permList" ] ; then return; fi
2647
2648        cuDir=`pwd`
2649
2650        cd "${PBI_PATCHWRKDIR}"
2651        echo "Applying updated permissions..."
2652        while read chLine
2653        do
2654                $chLine >/dev/null 2>/dev/null
2655        done < "${PBI_EXTRACTDIR}/PBI-permList"
2656
2657        cd "$cuDir"
2658}
2659
2660# Function which does the merge of bsdiff files
2661patch_merge_bsdiffs()
2662{
2663        echo "Applying patch data..."
2664        find ${PBI_EXTRACTDIR} | grep '.bsdiff' | sed "s|${PBI_EXTRACTDIR}/||g" > ${PBI_TMPDIR}/.PBI.bspatch.$$
2665
2666        while read pLine
2667        do
2668                if [ -z "$pLine" ] ; then continue; fi
2669                _tFile="`echo $pLine | sed 's|.bsdiff$||g'`"
2670               
2671                if [ ! -e "${PBI_EXTRACTDIR}/${_tFile}.sha256" ] ; then
2672                        exit_err "Missing checksums for \"${_tFile}\" this patch is corrupt"
2673                fi
2674
2675                if [ ! -e "${PBI_PATCHWRKDIR}/${_tFile}" ] ; then
2676                        echo "Warning: Missing target file for patching: $_tFile"
2677                        continue
2678                fi
2679               
2680                # Make sure we really are trying to patch the same file
2681                sha1="`sha256 -q ${PBI_PATCHWRKDIR}/${_tFile}`"
2682                sha2="`cat ${PBI_EXTRACTDIR}/${_tFile}.sha256`"
2683                if [ "$sha1" != "$sha2" ] ; then
2684                        exit_err "Error: Checksum failed for ${_tFile}, you may need to re-install this PBI."
2685                fi
2686
2687                _fPerm=`stat -f %Op "${PBI_PATCHWRKDIR}/${_tFile}"  | cut -c 3-6`
2688
2689                # See if we have a hard-link to take care of first
2690                get_hard_link_count "${PBI_PATCHWRKDIR}/${_tFile}"
2691                if [ "$HLINKS" != "1" ] ; then
2692                        mv "${PBI_PATCHWRKDIR}/${_tFile}" "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2693                        cp "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$" "${PBI_PATCHWRKDIR}/${_tFile}"
2694                        rm -f "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2695                fi
2696               
2697                # Now do the patching
2698                #echo "Patching $_tFile"       
2699                mv "${PBI_PATCHWRKDIR}/${_tFile}" "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2700                bspatch "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$" \
2701                        "${PBI_PATCHWRKDIR}/${_tFile}" \
2702                        "${PBI_EXTRACTDIR}/$pLine" >/dev/null 2>/dev/null
2703                if [ "$?" != "0" ] ; then
2704                        echo "Warning: Failed to apply patch to \"$_tFile\""
2705                fi
2706
2707                # Re-apply the same permissions to the new file
2708                chmod $_fPerm "${PBI_PATCHWRKDIR}/${_tFile}"
2709
2710                # Remove the old file
2711                rm "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2712
2713        done < "${PBI_TMPDIR}/.PBI.bspatch.$$"
2714
2715        rm "${PBI_TMPDIR}/.PBI.bspatch.$$"
2716}
2717
2718# Function which does the new file extraction for this PBI
2719patch_extract_new_files()
2720{
2721        if [ ! -e "${PBI_EXTRACTDIR}/PBI-newFiles.tar" ] ; then return; fi
2722        echo "Installing new files..."
2723        tar xvf "${PBI_EXTRACTDIR}/PBI-newFiles.tar" -C "${PBI_PATCHWRKDIR}" >/dev/null 2>/dev/null
2724        if [ "$?" != "0" ] ; then
2725                echo "Warning: Error during new file extraction, PBI may not function correctly."
2726        fi
2727}
2728
2729# Function which removes files that no longer exist in this updated PBI
2730patch_rm_old_files()
2731{
2732        if [ ! -e "${PBI_EXTRACTDIR}/PBI-rmList" ] ; then return; fi
2733       
2734        echo "Removing old files..."
2735        while read rmLine
2736        do
2737                if [ -z "$rmLine" ] ; then continue ; fi
2738                if [ ! -e "${PBI_PATCHWRKDIR}/$rmLine" ] ; then
2739                        continue
2740                fi
2741
2742                rm -rf "${PBI_PATCHWRKDIR}/${rmLine}"
2743        done < "${PBI_EXTRACTDIR}/PBI-rmList"
2744
2745}
2746
2747# Sets the workdir of the target PBI we are patching
2748set_patch_wrkdir()
2749{
2750        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2751        oldDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHTARGET}-${PBI_APPARCH}"
2752
2753        if [ ! -e "${oldDir}/pbi_defaultpath" ] ; then
2754                exit_err "Can not fild default path for \"$PBI_PROGNAME\"!"
2755        fi
2756
2757        PBI_PATCHWRKDIR="`cat ${oldDir}/pbi_defaultpath`"
2758
2759        if [ ! -d "$PBI_PATCHWRKDIR" ] ; then
2760                exit_err "Path for \"$PBI_PROGNAME\" does not exist!"
2761        fi
2762}
2763
2764# Confirms that the target PBI for this patch is installed
2765# Exits if not and we are not doing a extract only
2766verify_pbi_update_target()
2767{
2768        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then return ; fi
2769       
2770        # Make sure the target PBI is installed
2771        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2772        oldDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHTARGET}-${PBI_APPARCH}"
2773
2774        if [ ! -e "${oldDir}" ] ; then
2775                exit_err "\"${_pbilow}\" does not appear to be installed!"
2776        fi
2777
2778        # Check the arch type
2779        if [ "`cat ${oldDir}/pbi_arch`" != "$PBI_APPARCH" ] ; then
2780                exit_err "Installed \"${PBI_PROGNAME}\" is not compiled for $PBI_APPARCH"
2781        fi
2782
2783        # Check the taret version
2784        if [ "`cat ${oldDir}/pbi_version`" != "$PBI_PATCHTARGET" ] ; then
2785                exit_err "\"${_pbilow}\" patch is for \"$PBI_PROGVERSION\" only!"
2786        fi
2787
2788        # Check the fbsd version
2789        _pFbsdVer="`cat ${oldDir}/pbi_fbsdver | cut -c 1`"
2790        _sFbsdVer="`echo $PBI_FBSDVER | cut -c 1`"
2791        if [ "$_pFbsdVer" != "$_sFbsdVer" ] ; then
2792                exit_err "\"${_pbilow}\" patch is for FreeBSD ${_sFbsdVer}.X only!"
2793        fi
2794
2795        # Check the mdate of the pbi
2796        _pMDate="`cat ${oldDir}/pbi_mdate`"
2797        _sMDate="$PBI_PATCHMDATE"
2798        if [ "$_pMDate" != "$_sMDate" ] ; then
2799                exit_err "\"${_pbilow}\" patch is for the $PBI_PATCHMDATE build!"
2800        fi
2801}
2802
2803# Start the pbi_add process
2804pbi_add_init() {
2805        init_tmpdir
2806        parse_add_pbi_cmdline "$@"
2807
2808
2809        # Check if we are only displaying information
2810        check_pbi_info_display
2811        check_pbi_gui_display
2812        check_pbi_scripts_display
2813        check_pbi_license_display
2814        check_pbi_meta_display
2815        if [ "$PBI_ADD_GUIDISPLAY" = "YES" -o "$PBI_ADD_INFODISPLAY" = "YES" -o "$PBI_CHECKSCRIPTS" = "YES" -o "${PBI_ADD_LICDISPLAY}" = "YES" -o "${PBI_ADD_METADISPLAY}" = "YES" ] 
2816        then
2817                clean_remote_dl
2818                exit_trap
2819        fi
2820
2821        require_root_or_group
2822
2823        # If this app can only be installed as root
2824        if [ "$PBI_REQUIRESROOT" = "YES" ] ; then require_root ; fi
2825
2826        check_agree_lic
2827        check_existing_pbi
2828        do_pbi_add
2829}
2830
2831# Check if this PBI exists and exit if so
2832check_existing_pbi() {
2833        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then return 0; fi
2834        get_dbdir
2835        dir="${APPDBDIR}"
2836
2837        # See if this PBI is already installed
2838        if [ -d "$dir" ]; then
2839                get_username_from_file "${APPDBDIR}/pbi_name"
2840                if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
2841                        exit_err "Permission denied to modify PBI installed by: $FILEUSER"     
2842                fi
2843
2844                if [ "${PBI_FORCEADD}" = "YES" ] ; then return 0; fi
2845                exit_err "${PBI_PROGNAME} ${PBI_PROGVERSION} is already installed! Use -f to force installation."
2846        fi
2847
2848        if [ -e "${PBI_PROGDIRPATH}" ]; then
2849                get_username_from_file "${PBI_PROGDIRPATH}"
2850                if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
2851                        exit_err "Permission denied to modify PBI installed by: $FILEUSER"     
2852                fi
2853                if [ "${PBI_FORCEADD}" = "YES" ] ; then return 0; fi
2854                exit_err "${PBI_PROGDIRPATH} already exists! Use -f to force installation."
2855        fi
2856
2857
2858}
2859
2860# Check if we have a license to agree to, and if we've provided the flag to do so
2861check_agree_lic() {
2862        open_header_tmp
2863        if [ -f "${PBI_HEADER_TMPDIR}/${PBI_LICENSEFILE}" -a "${PBI_LICAGREE}" = "NO" ] ; then
2864                delete_header_tmp
2865                exit_err "LICENSE must be agreed to (--licagree) before this PBI can be installed."
2866        fi
2867        delete_header_tmp
2868}
2869
2870# See if we need to display pbi meta file
2871check_pbi_meta_display() {
2872        if [ "$PBI_ADD_METADISPLAY" != "YES" ] ; then return 0 ; fi
2873        open_header_tmp
2874       
2875        if [ -f "${PBI_HEADER_TMPDIR}/${PBI_USERMETAFILE}" ] ; then
2876                cat "${PBI_HEADER_TMPDIR}/${PBI_USERMETAFILE}" 
2877        else
2878                echo "`basename $0`: No user metafile included with this PBI"
2879        fi
2880        delete_header_tmp
2881}
2882
2883# See if we need to display pbi license
2884check_pbi_license_display() {
2885        if [ "$PBI_ADD_LICDISPLAY" != "YES" ] ; then return 0 ; fi
2886        open_header_tmp
2887       
2888        if [ -f "${PBI_HEADER_TMPDIR}/${PBI_LICENSEFILE}" ] ; then
2889                echo "LICENSE:"
2890                cat "${PBI_HEADER_TMPDIR}/${PBI_LICENSEFILE}"   
2891        else
2892                echo "`basename $0`: No LICENSE included with this PBI"
2893        fi
2894        delete_header_tmp
2895}
2896
2897# See if we need to display pbi info
2898check_pbi_info_display() {
2899        if [ "$PBI_ADD_INFODISPLAY" != "YES" ] ; then return 0 ; fi
2900        pbi_display_info
2901}
2902
2903# Display pbi information to stdout
2904pbi_display_info() {
2905
2906        tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"
2907        _appname="${tmp}-${PBI_PROGVERSION}-${PBI_APPARCH}"
2908
2909        if [ -z "$PBI_PATCHVERSION" ] ; then
2910                echo "PBI Information for: $_appname"
2911        else
2912                echo "PBP Information for: $_appname"
2913        fi
2914        echo "-----------------------------------------------------"
2915        echo "Name: ${PBI_PROGNAME}"
2916
2917        if [ -n "$PBI_PATCHVERSION" ] ; then
2918                echo "PatchTarget: $PBI_PATCHTARGET"
2919        fi
2920
2921        if [ -n "$PBI_INSTALLED_BY" ] ; then
2922                echo "InstalledBy: $PBI_INSTALLED_BY"
2923        fi
2924
2925        # Does this PBI need root to install?
2926        if [ "$PBI_REQUIRESROOT" = "YES" ] ; then
2927                echo "RootInstall: YES"
2928        else
2929                echo "RootInstall: NO"
2930        fi
2931
2932        echo "Version: ${PBI_PROGVERSION}"
2933        echo "Built: ${PBI_PROGMDATE}"
2934        echo "Prefix: ${PBI_ORIGPROGDIRPATH}"
2935        echo "Author: ${PBI_PROGAUTHOR}"
2936        echo "Website: ${PBI_PROGWEB}"
2937        echo "Arch: ${PBI_APPARCH}"
2938        echo "FbsdVer: ${PBI_FBSDVER}"
2939        echo "CreatorVer: ${PBI_APPCREATEVER}"
2940        echo "ArchiveCount: ${PBI_ARCHIVE_COUNT}"
2941        echo "ArchiveSum: ${PBI_ARCHIVE_CHECKSUM}"
2942        case ${PBI_SIGVALID} in
2943                0) echo "Signature: Verified" ;;
2944               -1) echo "Signature: Not Signed" ;;
2945                1) echo "Signature: Bad" ;;
2946                *) echo "Signature: <Unknown>" ;;
2947        esac
2948
2949        if [ -n "$PBI_LICENSE" ] ; then
2950                echo "License: $PBI_LICENSE"
2951        fi
2952
2953        if [ -n "${PBI_REPO}" ] ; then
2954                local _rDesc="`cat ${PBI_DBREPODIR}/*.${PBI_REPO} | grep "Desc:" | sed 's|Desc: ||g'`"
2955                local _rID="`ls ${PBI_DBREPODIR}/*.${PBI_REPO}`"
2956                _rID=`basename $_rID | cut -d '.' -f 1`
2957                echo "Associated Repo: ${_rID} (${_rDesc})"
2958        fi
2959       
2960        # Check if autoupdate is enable or not
2961        if [ "${PBI_ENABLEAUTOUPDATE}" = "YES" ] ; then
2962                echo "AutoUpdate: YES"
2963        else
2964                echo "AutoUpdate: NO"
2965        fi
2966
2967        # See if we have any XDG stuff
2968        if [ -e "${PBI_ORIGPROGDIRPATH}/.xdg-desktop/install-desktop-icons.sh" ] ; then
2969                echo "DesktopIcons: YES"
2970        fi
2971        if [ -e "${PBI_ORIGPROGDIRPATH}/.xdg-menu/install-menu-icons.sh" ] ; then
2972                echo "MenuIcons: YES"
2973        fi
2974        if [ -e "${PBI_ORIGPROGDIRPATH}/.xdg-mime/install-mime.sh" ] ; then
2975                echo "MimeRegistration: YES"
2976        fi
2977
2978        # If verbose mode, show file contents
2979        if [ "$PBI_VERBOSE" = "YES" ] ; then
2980                if [ -n "${PBI_FILENAME}" -a -e "${PBI_FILENAME}" ] ; then
2981                        pbi_find_archive_header
2982                        echo "TOTALFILES: ${PBI_ARCHIVE_COUNT}"
2983                        echo "Archive Contents:"
2984                        echo "--------------------------------------"
2985                        tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar tvf -
2986                fi
2987        fi
2988}
2989
2990# See if we need to display gui header info
2991check_pbi_gui_display() {
2992        if [ "$PBI_ADD_GUIDISPLAY" != "YES" ] ; then return 0 ; fi
2993        open_header_tmp
2994       
2995        pbi_display_gui "$PBI_HEADER_TMPDIR" "COPY"
2996
2997        delete_header_tmp
2998
2999}
3000
3001# Display location of PBI graphics
3002pbi_display_gui() {
3003        dir="$1"
3004        copy="$2"
3005        if [ -e "${dir}/top-banner.png" ] ; then
3006                if [ "$copy" = "COPY" ] ; then
3007                        pbi_guitop="/tmp/.PBI-top.$$.png"
3008                        cp "${dir}/top-banner.png" "$pbi_guitop"
3009                else
3010                        pbi_guitop="${dir}/top-banner.png"
3011                fi
3012                echo "TopBanner: ${pbi_guitop}"
3013        fi
3014        if [ -e "${dir}/side-banner.png" ] ; then
3015                if [ "$copy" = "COPY" ] ; then
3016                        pbi_guiside="/tmp/.PBI-side.$$.png"
3017                        cp "${dir}/side-banner.png" "$pbi_guiside"
3018                else
3019                        pbi_guiside="${dir}/side-banner.png"
3020                fi
3021                echo "SideBanner: ${pbi_guiside}"
3022        fi
3023
3024        # Try to find an icon
3025        ls ${dir}/pbi_icon.* >/dev/null 2>/dev/null
3026        if [ "$?" = "0" ] ; then
3027                _iconExt=`ls ${dir}/pbi_icon.* | head -n 1 | awk -F . '{print $NF}'`
3028                if [ "$copy" = "COPY" ] ; then
3029                        pbi_guiicon="/tmp/.PBI-icon.$$.${_iconExt}"
3030                        cp "${dir}/pbi_icon.${_iconExt}" "$pbi_guiicon"
3031                else
3032                        pbi_guiicon="${dir}/pbi_icon.${_iconExt}"
3033                fi
3034                echo "Icon: ${pbi_guiicon}"
3035        fi
3036
3037}
3038
3039open_header_tmp() {
3040        init_tmpdir
3041
3042        # If we have a custom extract dir, use it
3043        if [ -z "$1" ] ; then
3044                PBI_HEADER_TMPDIR="${PBI_TMPDIR}/.PBI-header.$$"
3045        else
3046                PBI_HEADER_TMPDIR="${1}/.PBI-header.$$"
3047        fi
3048
3049        if [ -e "${PBI_HEADER_TMPDIR}" ] ; then rm -rf "${PBI_HEADER_TMPDIR}" ; fi
3050        mkdir -p "${PBI_HEADER_TMPDIR}"
3051       
3052        # Extract the header files
3053        tar xvf "${PBI_FILENAME}" -C "${PBI_HEADER_TMPDIR}" >/dev/null 2>/dev/null
3054        if [ "$?" != "0" ] ; then exit_err "Failed to read PBI header! Possible corrupt PBI, or wrong PBI version for this OS." ; fi
3055
3056}
3057
3058delete_header_tmp() {
3059        if [ -z "${PBI_HEADER_TMPDIR}" ] ; then return 0 ; fi
3060        if [ -d "${PBI_HEADER_TMPDIR}" ] ; then rm -rf "${PBI_HEADER_TMPDIR}" ; fi
3061}
3062
3063# Load in all the configuration data from the header
3064load_info_from_header() {
3065        open_header_tmp
3066
3067        # Start loading our variables
3068        load_info_from_dir "${PBI_HEADER_TMPDIR}"
3069
3070        delete_header_tmp
3071}
3072
3073# See if we need to display scripts
3074check_pbi_scripts_display() {
3075        if [ "$PBI_CHECKSCRIPTS" != "YES" ] ; then return 0 ; fi
3076
3077        # Display our scripts
3078        open_header_tmp
3079        if [ -e "${PBI_HEADER_TMPDIR}/${MOD_PREINS}" ] ; then
3080                echo -e "\n${MOD_PREINS}:"
3081                echo "--------------------------------"
3082                cat "${PBI_HEADER_TMPDIR}/${MOD_PREINS}"
3083        fi
3084        if [ -e "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}" ] ; then
3085                echo -e "\n${MOD_POSTINS}:"
3086                echo "--------------------------------"
3087                cat "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}"
3088        fi
3089        if [ -e "${PBI_HEADER_TMPDIR}/${MOD_PREREM}" ] ; then
3090                echo -e "\n${MOD_PREREM}:"
3091                echo "--------------------------------"
3092                cat "${PBI_HEADER_TMPDIR}/${MOD_PREREM}"
3093        fi
3094        delete_header_tmp
3095}
3096
3097# Load pbi information from the specified directory
3098load_info_from_dir() {
3099        REQUIRED_FILES="pbi_defaultpath pbi_name pbi_version pbi_author pbi_web pbi_arch pbi_fbsdver pbi_createver"
3100        for f in $REQUIRED_FILES
3101        do
3102                if [ ! -e "${1}/${f}" ] ; then echo "Warning: Missing file: ${f}" ; fi
3103        done
3104        PBI_APPARCH=""
3105        PBI_APPCREATEVER=""
3106        PBI_ARCHIVE_CHECKSUM=""
3107        PBI_ARCHIVE_COUNT=""
3108        PBI_ENABLEAUTOUPDATE=""
3109        PBI_FBSDVER=""
3110        PBI_ORIGPROGDIRPATH=""
3111        PBI_PATCHMDATE=""
3112        PBI_PATCHVERSION=""
3113        PBI_PATCHTARGET=""
3114        PBI_PROGNAME=""
3115        PBI_PROGVERSION=""
3116        PBI_PROGAUTHOR=""
3117        PBI_PROGMDATE=""
3118        PBI_PROGWEB=""
3119        PBI_REPO=""
3120        PBI_REQUIRESROOT=""
3121        PBI_SIGVALID=""
3122        PBI_DESC=""
3123        PBI_SHORTDESC=""
3124        PBI_MAINTAINER=""
3125        PBI_TAGS=""
3126        PBI_PROGTYPE=""
3127        PBI_CATEGORY=""
3128        PBI_ICONURL=""
3129        PBI_LICENSE=""
3130
3131        PBI_ORIGPROGDIRPATH="`cat ${1}/pbi_defaultpath`"
3132        PBI_PROGNAME="`cat ${1}/pbi_name`"
3133        PBI_PROGVERSION="`cat ${1}/pbi_version`"
3134        PBI_PROGAUTHOR="`cat ${1}/pbi_author`"
3135        PBI_PROGWEB="`cat ${1}/pbi_web 2>/dev/null`"
3136        PBI_PROGMDATE="`cat ${1}/pbi_mdate 2>/dev/null`"
3137        PBI_APPARCH="`cat ${1}/pbi_arch 2>/dev/null`"
3138        PBI_FBSDVER="`cat ${1}/pbi_fbsdver 2>/dev/null`"
3139        PBI_APPCREATEVER="`cat ${1}/pbi_createver 2>/dev/null`"
3140        PBI_ARCHIVE_COUNT="`cat ${1}/pbi_archivecount 2>/dev/null`"
3141        PBI_ARCHIVE_CHECKSUM="`cat ${1}/pbi_archivesum 2>/dev/null`"
3142
3143        if [ -e "${1}/pbi_license" ] ; then
3144                PBI_LICENSE="`cat ${1}/pbi_license`"
3145        fi
3146        if [ -e "${1}/pbi_tags" ] ; then
3147                PBI_TAGS="`cat ${1}/pbi_tags`"
3148        fi
3149        if [ -e "${1}/pbi_type" ] ; then
3150                PBI_PROGTYPE="`cat ${1}/pbi_type`"
3151        fi
3152        if [ -e "${1}/pbi_category" ] ; then
3153                PBI_CATEGORY="`cat ${1}/pbi_category`"
3154        fi
3155        if [ -e "${1}/pbi_iconurl" ] ; then
3156                PBI_ICONURL="`cat ${1}/pbi_iconurl`"
3157        fi
3158        if [ -e "${1}/pbi_desc" ] ; then
3159                PBI_DESC="`cat ${1}/pbi_desc | awk 1 ORS=' ' | sed 's|  |<br>|g' | sed 's|*|-|g'`"
3160        fi
3161        if [ -e "${1}/pbi_shortdesc" ] ; then
3162                PBI_SHORTDESC="`cat ${1}/pbi_shortdesc | awk 1 ORS=' ' | sed 's|  |<br>|g' | sed 's|*|-|g'`"
3163        fi
3164        if [ -e "${1}/pbi_maintainer" ] ; then
3165                PBI_MAINTAINER="`cat ${1}/pbi_maintainer`"
3166        fi
3167
3168        # Check if auto-update is enabled
3169        if [ -e "${1}/autoupdate-enable" ] ; then
3170                PBI_ENABLEAUTOUPDATE="YES"
3171        fi
3172
3173        # Does this PBI need to be installed as root
3174        if [ -e "${1}/pbi_requiresroot" ] ; then
3175                PBI_REQUIRESROOT="YES"
3176        fi
3177       
3178        # Check if this is a patch file
3179        if [ -e "${1}/pbi_patchfile" ] ; then
3180                PBI_PATCHVERSION=`cat ${1}/pbi_patchfile | cut -d ':' -f 2`
3181                PBI_PATCHTARGET=`cat ${1}/pbi_patchfile | cut -d ':' -f 1`
3182        fi
3183       
3184        # Check if this associates with a particular repo
3185        if [ -e "${1}/pbi_repo" ] ; then
3186                PBI_REPO=`cat ${1}/pbi_repo`
3187        fi
3188
3189        # See if this patch is for a particular mdate
3190        if [ -e "${1}/pbi_patchmdate" ] ; then
3191                PBI_PATCHMDATE=`cat ${1}/pbi_patchmdate`
3192        fi
3193
3194        # See if this PBI was signed
3195        if [ -e "${1}/pbi_archivesum.sha1" ] ; then
3196                check_valid_sigs "${1}"
3197                if [ "$?" = "0" ] ; then
3198                        PBI_SIGVALID="0"
3199                else
3200                        PBI_SIGVALID="1"
3201                fi
3202        else
3203                PBI_SIGVALID="-1"
3204        fi
3205}
3206
3207# Start installing the PBI
3208do_pbi_add() {
3209        pbi_verify_signatures
3210        pbi_verify_archivesum
3211
3212        check_preinstall_script
3213
3214        mk_pbi_extract_dir
3215        pbi_extract_archive
3216       
3217        pbi_add_check_uids
3218        pbi_add_check_gids
3219
3220        pbi_add_run_script
3221        check_postinstall_script
3222
3223        pbi_add_register_app
3224
3225        # Be sure to let the pbid know we have a new hash-dir to register
3226        add_hashdir_trigger
3227
3228        # Flush to disk
3229        sleep 0.5
3230        sync
3231
3232        clean_remote_dl
3233}
3234
3235# Check for any GIDs we need to create
3236pbi_add_check_gids() {
3237        if [ ! -e "${PBI_PROGDIRPATH}/${PBI_INS_GROUPSFILE}" ] ; then return ; fi
3238        runUID=`id -u`
3239
3240        while read gidLine
3241        do
3242                gName=`echo $gidLine | cut -d ':' -f 1`
3243                gID=`echo $gidLine | cut -d ':' -f 3`
3244                gUsers=`echo $gidLine | cut -d ':' -f 4`
3245
3246                # Is this group already on the system?
3247                pw groupshow $gName >/dev/null 2>/dev/null
3248                if [ $? -eq 0 ] ; then
3249                        echo "Using existing group: $gName"
3250                else
3251                        # Are we installing as root?
3252                        if [ "$runUID" != "0" ] ; then
3253                                echo "Please create group \"$gName\" manually or re-install PBI as root."
3254                        else
3255                                echo "Adding group: $gName"
3256                                pw groupadd $gName -g $gID;
3257                        fi
3258                fi
3259
3260                if [ -n "$gUsers" ] ; then
3261                        for gUser in `echo $gUsers | sed 's|,| |g'`
3262                        do
3263                                pw groupshow ${gName} | grep -qw ${gUser}
3264                                if [ $? -ne 0 ] ; then
3265                                        # Are we installing as root?
3266                                        if [ "$runUID" != "0" ] ; then
3267                                                echo "Please add user \"$gUser\" to group \"$gName\" manually or re-install PBI as root."
3268                                                continue
3269                                        fi
3270
3271                                        echo "Adding user ${gUser} to group ${gName}"
3272                                        pw groupmod ${gName} -m ${gUser}
3273                                fi
3274                        done
3275                fi
3276        done < ${PBI_PROGDIRPATH}/${PBI_INS_GROUPSFILE}
3277}
3278
3279# Check for any UIDs we need to create
3280pbi_add_check_uids() {
3281        if [ ! -e "${PBI_PROGDIRPATH}/${PBI_INS_USERSFILE}" ] ; then return ; fi
3282        runUID=`id -u`
3283
3284        while read uidLine
3285        do
3286                uName=`echo $uidLine | cut -d ':' -f 1`
3287
3288                # Is this user already on the system?
3289                pw usershow $uName >/dev/null 2>/dev/null
3290                if [ $? -eq 0 ] ; then echo "Using existing user: $uName"; continue ; fi
3291
3292                # Are we installing as root?
3293                if [ "$runUID" != "0" ] ; then
3294                        echo "Please create user \"$uName\" manually or re-install PBI as root."
3295                        continue
3296                fi
3297
3298                uID=`echo $uidLine | cut -d ':' -f 3`
3299                gID=`echo $uidLine | cut -d ':' -f 4`
3300                uClass=`echo $uidLine | cut -d ':' -f 5`
3301                uGecos=`echo $uidLine | cut -d ':' -f 8`
3302                uHomedir=`echo $uidLine | cut -d ':' -f 9 | sed "s|^/usr/local|${PBI_PROGDIRPATH}|"`
3303                uShell=`echo $uidLine | cut -d ':' -f 10`
3304
3305                echo "Adding user: $uName"
3306                pw useradd $uName -u $uID -g $gID $uClass -c "$uGecos" -d $uHomedir -s $uShell;
3307
3308                # Create homedir
3309                case $uHomedir in
3310                        /nonexistent|/var/empty) ;;
3311                        *) install -d -g $gID -o $uID $uHomedir ;;
3312                esac
3313        done < ${PBI_PROGDIRPATH}/${PBI_INS_USERSFILE}
3314}
3315
3316add_hashdir_trigger() {
3317        get_dbdir
3318        _htrig=`echo ${APPDBDIR} | sed "s|${PBI_DBAPPDIR}|${PBI_DBHASHQUEUEDIR}|g"`
3319        if [ ! -e "${_htrig}" ] ; then
3320                touch "${_htrig}"
3321        fi
3322}
3323
3324# Run the install script if exists
3325pbi_add_run_script() {
3326
3327        # If running as user, add bin path-links
3328        if [ "`id -u`" != "0" ] ; then add_app_path_links "${PBI_PROGDIRPATH}" ; fi
3329
3330        insc="${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/.pbi-install.sh"
3331        if [ ! -e "${insc}" ] ; then return 0 ; fi
3332        export_script_vars
3333        if [ "$PBI_VERBOSE" = "YES" ] ; then
3334                ${insc}
3335        else
3336                ${insc} >/dev/null 2>/dev/null
3337        fi
3338
3339}
3340
3341# If we need to, update the hashdir
3342pbi_add_update_hashdir() {
3343        if [ "${PBI_NOHASHDIR}" = "YES" ] ; then return 0 ; fi
3344        if [ ! -e "${1}/${PBI_HASHLIST}" ] ; then return 0; fi
3345        local hDir="${1}/local"
3346
3347        if [ "$PBI_VERBOSE" = "YES" ] ; then
3348                echo "HASHCOUNT: `wc -l ${1}/${PBI_HASHLIST} | tr -d ' ' | cut -d '/' -f 1`"
3349        else
3350       
3351                echo -e "Merging with hashdir...\c"
3352        fi
3353       
3354        inUseDir="/usr/pbi/.mounts/`basename $1`/virtbase/dev"
3355
3356        # Read the hashfile, and start making links to identical files
3357        while read hl
3358        do
3359                # Is this PBI running?
3360                if [ -d "$inUseDir" ] ; then
3361                        echo "hASHBUSY - Canceled"
3362                        return
3363                fi
3364
3365                file="`echo $hl | sed 's/:::.*$//g'`"
3366
3367                # If we are trying to merge a PBI which was deleted, stop
3368                if [ -n "${2}" -a -e "${2}" ] ; then
3369                        echo "HASHDONE - Deleted" 
3370                        return
3371                fi
3372
3373                # Make sure the target file hasnt been removed
3374                if [ ! -e "${hDir}/${file}" ] ; then continue ; fi
3375
3376                # We dont need no stinking sym-links
3377                if [ -h "${hDir}/${file}" ] ; then continue ; fi
3378
3379                if [ -f "${PBI_HASHDIR}/${hl}" ] ; then
3380                        use_hashfile "$hl" "${hDir}/$file"
3381                else
3382                        mv_ln_hashfile "$hl" "${hDir}/$file"
3383                fi
3384        done < "${1}/${PBI_HASHLIST}"
3385
3386        if [ "$PBI_VERBOSE" = "YES" ] ; then
3387                echo "HASHDONE"
3388        else
3389                echo -e "Done!" 
3390        fi
3391}
3392
3393# Use an existing hashfile
3394use_hashfile() {
3395        tfile="$1"
3396        file="$2"
3397        dir="`dirname ${tfile}`"
3398        if [ ! -d "${PBI_HASHDIR}/${dir}" ] ; then
3399                mkdir -p ${PBI_HASHDIR}/${dir}
3400        fi
3401
3402        # We have a match!
3403        ln -f "${PBI_HASHDIR}/${tfile}" "${file}"
3404        if [ $? -ne 0 ] ; then
3405                echo "Warning: Unable to make hash-link ${PBI_HASHDIR}/${tfile} -> ${file}"
3406                return
3407        fi
3408       
3409        # Make sure the hard-linked file doesn't get changed
3410        chmod u-w,g-w,o-w "${file}"
3411        if [ $? -ne 0 ] ; then
3412                echo "Warning: Unable to chmod ${file}"
3413                return
3414        fi
3415       
3416}
3417
3418# New file we can save to hashdir
3419mv_ln_hashfile() {
3420        tfile="$1"
3421        file="$2"
3422        dir="`dirname ${tfile}`"
3423        if [ ! -d "${PBI_HASHDIR}/${dir}" ] ; then
3424                mkdir -p ${PBI_HASHDIR}/${dir}
3425        fi
3426
3427        ln -f "${file}" "${PBI_HASHDIR}/${tfile}"
3428        if [ $? -ne 0 ] ; then
3429                echo "Warning: Unable to make hash-link ${file} -> ${PBI_HASHDIR}/${tfile}"
3430                return
3431        fi
3432
3433        # Make sure the hard-linked file doesn't get changed
3434        chmod u-w,g-w,o-w "${file}"
3435        if [ $? -ne 0 ] ; then
3436                echo "Warning: Unable to chmod ${file}"
3437                return
3438        fi
3439
3440        # Make sure the hard-linked file doesn't get changed
3441        chmod u-w,g-w,o-w "${PBI_HASHDIR}/${tfile}"
3442        if [ $? -ne 0 ] ; then
3443                echo "Warning: Unable to chmod ${PBI_HASHDIR}/${tfile}"
3444                return
3445        fi
3446
3447        if [ "$PBI_VERBOSE" = "YES" ] ; then echo "L" ; fi
3448}
3449
3450# Return the dbdir for this PBI
3451get_dbdir() {
3452        tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"
3453        APPDBDIR="${PBI_DBAPPDIR}/${tmp}-${PBI_PROGVERSION}-${PBI_APPARCH}"
3454}
3455
3456# Register this app as installed
3457pbi_add_register_app() {
3458        if [ ! -d "$PBI_DBAPPDIR" ] ; then mkdir -p ${PBI_DBAPPDIR} ; fi
3459        open_header_tmp
3460        get_dbdir
3461        dir="${APPDBDIR}"
3462
3463        # Make sure we remove any existing meta-data if forcing an installation
3464        if [ "$PBI_FORCEADD" = "YES" ] ; then
3465                tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"
3466                rm -rf ${PBI_DBAPPDIR}/${tmp}-*-${PBI_APPARCH}
3467        fi
3468
3469        mkdir -p "${dir}"
3470       
3471        tar cvf - -C "${PBI_HEADER_TMPDIR}" . 2>/dev/null | tar xvf - -C "$dir" 2>/dev/null
3472
3473        # If this was a patch, use the original path
3474        if [ -n "${PBI_ORIGPROGDIRPATH}" ] ; then
3475                echo "${PBI_ORIGPROGDIRPATH}" >${dir}/pbi_installedpath
3476        else
3477                echo "${PBI_PROGDIRPATH}" >${dir}/pbi_installedpath
3478        fi
3479
3480        # See which repo / key this PBI associates to, if any
3481        check_valid_sigs "${dir}"
3482        if [ -n "$PBI_VALIDKEYSIG" ] ; then
3483                _rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"
3484                echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${dir}/pbi_repo
3485        fi
3486
3487        # Dont need any patch version info
3488        if [ -e "${dir}/pbi_patchfile" ] ; then
3489                rm "${dir}/pbi_patchfile"
3490        fi
3491
3492        delete_header_tmp
3493
3494        echo "Installed: ${PBI_PROGNAME}-${PBI_PROGVERSION}"
3495}
3496
3497# Check if we have a postinstall script we need to use
3498check_postinstall_script() {
3499        open_header_tmp
3500
3501        if [ ! -e "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}" ] ; then
3502                delete_header_tmp
3503                return 0
3504        fi
3505
3506        export_script_vars
3507        sh "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}"
3508        delete_header_tmp
3509}
3510
3511# Check if we have a preinstall script we need to use
3512check_preinstall_script() {
3513        open_header_tmp
3514
3515        if [ ! -e "${PBI_HEADER_TMPDIR}/${MOD_PREINS}" ] ; then
3516                delete_header_tmp
3517                return 0
3518        fi
3519
3520        export_script_vars
3521        sh "${PBI_HEADER_TMPDIR}/${MOD_PREINS}"
3522        if [ "$?" != "0" ] ; then
3523                delete_header_tmp
3524                exit_err "${MOD_PREINS} returned error status"
3525        fi
3526        delete_header_tmp
3527}
3528
3529# Verify if we have valid openssl signatures on important parts of PBI
3530pbi_verify_signatures() {
3531        if [ "${PBI_SKIPSIGVERIFY}" = "YES" ] ; then return 0 ; fi
3532        if [ "$PBI_SIGVALID" = "0" ] ; then return ; fi
3533        if [ "$PBI_SIGVALID" = "1" ] ; then kw="Invalid" ; else kw="No" ; fi
3534        exit_err "$kw digital signature! If you are *SURE* you trust this PBI, re-install with --no-checksig option. "
3535
3536}
3537
3538# Check if we have valid signatures, and return "0" if success, "1" if failure
3539check_valid_sigs() {
3540        PBI_VALIDKEYSIG=""
3541
3542        for _pk in ${PBI_PUBKEYS}
3543        do
3544                good="true"
3545                _sf="${1}/pbi_archivesum ${1}/${MOD_PREINS} ${1}/${MOD_POSTINS} ${1}/${MOD_PREREM}"
3546                for _ts in $_sf
3547                do
3548                        openssl dgst -sha1 \
3549                        -verify ${_pk} \
3550                        -signature ${_ts}.sha1 \
3551                        ${_ts} >/dev/null 2>/dev/null
3552                        if [ "$?" != "0" ] ; then
3553                                good="false" ; break
3554                        fi
3555                        PBI_VALIDKEYSIG="$_pk"
3556                done
3557                if [ "$good" = "true" ] ; then return 0 ; fi
3558        done
3559        return 1       
3560}
3561
3562# Verify if the archive checksum is good
3563pbi_verify_archivesum() {
3564        if [ "${PBI_SKIPCHECKSUM}" = "YES" ] ; then return 0 ; fi
3565        echo -e "Verifying Checksum...\c"
3566
3567        pbi_find_archive_header
3568        sum=`tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | sha256 -q`
3569        if [ "$PBI_VERBOSE" = "YES" ] ; then
3570                echo "Archive checksum: ${sum}"
3571                echo "Saved checksum: ${PBI_ARCHIVE_CHECKSUM}"
3572        fi
3573        if [ "$sum" != "$PBI_ARCHIVE_CHECKSUM" ] ; then
3574                exit_err "${PBI_FILENAME} failed checksum, the archive may be corrupt."
3575        fi
3576        echo -e "OK"
3577
3578}
3579
3580# Make our PBI extraction dir
3581mk_pbi_extract_dir() {
3582        PBI_EXTRACTDIR="${PBI_PROGDIRPATH}"
3583        if [ -e "${PBI_EXTRACTDIR}" ] ; then
3584               rm -rf "$PBI_EXTRACTDIR"
3585        fi
3586        mkdir -p "${PBI_EXTRACTDIR}" >/dev/null 2>/dev/null
3587        if [ "$?" != "0" ] ; then
3588                exit_err "Failed to create directory: ${PBI_PROGDIRPATH}"
3589        fi
3590}
3591
3592pbi_find_archive_header() {
3593        # Find the header for the archive
3594        # SEARCH FOR: $PBI_SS_ARCHIVE
3595        PBI_SKIP_ARCHLINES=`awk "/^${PBI_SS_ARCHIVE}/ { print NR + 1; exit 0; }" "${PBI_FILENAME}"`
3596        if [ "$PBI_VERBOSE" = "YES" ] ; then
3597                echo "SKIP_ARCHLINES: $PBI_SKIP_ARCHLINES"
3598        fi
3599}
3600
3601# Extract the PBI archive file
3602pbi_extract_archive() {
3603        pbi_find_archive_header
3604
3605        echo "Extracting to: ${PBI_EXTRACTDIR}"
3606
3607        if [ "$PBI_VERBOSE" = "YES" ] ; then
3608                tar="xvf -"
3609                echo "TOTALFILES: ${PBI_ARCHIVE_COUNT}"
3610                tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar ${tar} -C "${PBI_EXTRACTDIR}"
3611                err="$?"
3612        else
3613                tar="xf -"
3614                tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar ${tar} -C "${PBI_EXTRACTDIR}" 2>/dev/null
3615                err="$?"
3616        fi
3617       
3618        if [ "$err" != "0" ] ; then exit_err "Failed extracting ${PBI_FILENAME}" ; fi
3619
3620        if [ "$PBI_VERBOSE" = "YES" ] ; then echo "Extraction Finished!" ; fi
3621
3622        # If this is an extract only, do it and exit
3623        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then exit_trap ; fi
3624}
3625       
3626
3627# Starting pbi_create
3628pbi_create_init() {
3629
3630        require_root
3631
3632        parse_create_pbi_cmdline "$@"
3633
3634        # If we are making a backup copy of an installed PBI
3635        if [ "$PBI_CBACKUP" = "YES" ] ; then
3636                init_tmpdir
3637                do_pbi_create_backup
3638                exit_trap
3639        fi
3640
3641        load_pbi_conffile
3642
3643        parse_cmdline_overrides
3644
3645        # Copy over the application to the correct location
3646        echo ${PBI_PROGDIRPATH} | grep -q "^${PBI_APPDIR}/"
3647        if [ $? -ne 0 ] ; then
3648           _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
3649           newPDP="${PBI_APPDIR}/${_pbilow}-${ARCH}"
3650           if [ -d "${newPDP}" ] ; then exit_err "Error: ${newPDP} already exists!" ; fi       
3651           cp -r ${PBI_PROGDIRPATH} ${newPDP}
3652           PBI_PROGDIRPATH="${newPDP}"
3653           export PBI_PROGDIRPATH
3654        fi
3655
3656        PBI_CREATEONLY="YES"
3657
3658        check_create_required_vars
3659
3660        do_pbi_create
3661
3662        # Cleanup the copy dir
3663        if [ -n "$newPDP" ] ; then
3664                if [ "${newPDP}" != "/" -a "${newPDP}" != "${PBI_APPDIR}/-" ] ; then
3665                        rm -rf "${newPDP}"
3666                fi
3667        fi
3668}
3669
3670# Start the pbi_create backup process
3671do_pbi_create_backup() {
3672
3673        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_CBACKUPTARGET}"
3674        echo "Creating backup PBI: ${PBI_PROGNAME}-${PBI_PROGVERSION}"
3675
3676        # Start by making a fresh archive of the installed PBI
3677        PBI_STAGEDIR="$PBI_ORIGPROGDIRPATH"
3678        mk_archive_file
3679
3680        # Now make the header dir
3681        _hDir="${PBI_TMPDIR}/.header.$$"
3682        PBI_HEADERDIR="${_hDir}"
3683        mkdir -p "${_hDir}"
3684        cp ${PBI_DBAPPDIR}/${PBI_CBACKUPTARGET}/* "${_hDir}"
3685        rm ${_hDir}/*.sha1 >/dev/null 2>/dev/null
3686
3687        # Get the total number of files in the STAGEDIR
3688        get_filetotal_dir "${PBI_STAGEDIR}"
3689        echo "${FILETOTAL}" > "${PBI_HEADERDIR}/pbi_archivecount"
3690
3691        # Save a checksum of archive file
3692        sha256 -q "${PBI_CREATE_ARCHIVE}" > "${PBI_HEADERDIR}/pbi_archivesum"
3693
3694        # Sign any header files
3695        sign_pbi_files "$PBI_HEADERDIR"
3696
3697        # Make the header archive
3698        mk_header_file
3699
3700        # Now finish up and make the resulting PBI file
3701        mk_output_pbi
3702
3703}
3704
3705
3706# Vars required for creation
3707check_create_required_vars() {
3708        if [ -z "${PBI_PROGNAME}" ] ; then exit_err "Missing PBI_PROGNAME"; fi
3709        if [ -z "${PBI_PROGVERSION}" ] ; then exit_err "Missing PBI_PROGVERSION"; fi
3710        if [ -z "${PBI_PROGAUTHOR}" ] ; then exit_err "Missing PBI_PROGAUTHOR"; fi
3711        if [ -z "${PBI_PROGWEB}" ] ; then exit_err "Missing PBI_PROGWEB"; fi
3712}
3713
3714# Start the pbi_create process
3715do_pbi_create() {
3716        get_pbi_progname
3717        echo "Creating PBI: ${PBI_PROGNAME}-${PBI_PROGVERSION}"
3718
3719
3720        if [ "`basename $0`" = "pbi_makeport" -o "`basename $0`" = "pbi_makeport_chroot" ] ; then
3721          mk_stage_dir "/usr/local" "move"
3722
3723          # Check if we created a linux app, and need to copy files for it
3724          auto_copy_linuxbase
3725        else
3726          mk_stage_dir
3727        fi
3728
3729        copy_resource_dir
3730        clean_stage_dir
3731
3732        mk_extlink_entries
3733        clean_icons_dir
3734        mk_xdg_scripts
3735
3736        # Check for any users / groups we need to save for install time
3737        mk_pbi_users_file
3738        mk_pbi_groups_file
3739
3740        run_pbi_prepkgscript
3741
3742        mk_install_script
3743        mk_deinstall_script
3744
3745        mk_hash_list
3746
3747        mk_archive_file
3748
3749        mk_header_dir
3750        save_pbi_details_to_header
3751        mk_header_file
3752
3753        mk_output_pbi
3754
3755        rm_stage_dir
3756        exit 0
3757}
3758
3759# Start looping through and creating a hash-list of files
3760mk_hash_list() {
3761        if [ "${PBI_CREATE_HASHLIST}" = "NO" ] ; then return 0 ; fi
3762        echo "Creating hash list..."
3763
3764        hashfile="${PBI_STAGEDIRMNT}/${PBI_HASHLIST}"
3765
3766        if [ -e "${hashfile}" ] ; then rm "${hashfile}" ; fi
3767
3768        for hdir in ${HASH_SEARCH_DIRS}
3769        do
3770                if [ ! -d "${PBI_STAGEDIR}/${hdir}" ] ; then continue ; fi
3771                save_dir_hash_list "${hdir}" "${hashfile}"     
3772        done
3773}
3774
3775#  Read the specified directory and save hashsums of each file
3776save_dir_hash_list() {
3777        cd ${PBI_STAGEDIR}
3778        tmp_hashdir="${PBI_STAGEDIR}/.tmp-hash.$$"
3779        find "${1}" -type f > ${tmp_hashdir}
3780        while read line
3781        do
3782                if [ ! -f "$line" -o -h "$line" ] ; then continue ; fi
3783               
3784                # Check if this hash file is excluded
3785                _hfound="0"
3786                if [ -n "${PBI_HASH_EXCLUDES}" ] ; then
3787                        for _hexcl in ${PBI_HASH_EXCLUDES}
3788                        do
3789                                if [ "$_hexcl" = "$line" ] ; then
3790                                        _hfound="1"
3791                                fi
3792                        done
3793                        if [ "$_hfound" = "1" ] ; then
3794                                continue
3795                        fi
3796                fi     
3797
3798                # Add to the hash-dir
3799                sha=`sha256 -q "$line"`
3800                echo "${line}:::${sha}" >> ${2}
3801
3802        done < ${tmp_hashdir}
3803        rm ${tmp_hashdir}
3804        cd /
3805}
3806
3807# Parse any external link directives
3808mk_extlink_entries() {
3809        echo "Creating external link entries..."
3810        init_tmpdir
3811        _extf="${PBI_CONFDIR}/${MOD_EXTLINKFILE}"
3812        _autoextf="${PBI_TMPDIR}/${MOD_AUTOEXTLINKFILE}"
3813        _tmpextf="${PBI_TMPDIR}/${MOD_AUTOEXTLINKFILE}.$$"
3814        if [ ! -e "${_extf}" -a ! -e "${_autoextf}" ] ; then return 0 ; fi
3815
3816        dir="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}"
3817        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3818
3819        # Create the headers for the PATH link scripts
3820        echo "#!/bin/sh" >"${dir}/${PBI_INS_PATHSCRIPT}"
3821        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_PATHSCRIPT}"
3822
3823        # Make sure we also set SYS_LOCALBASE in case user runs these stand-alone at some point
3824        echo "if [ -z \"\$SYS_LOCALBASE\" ]; then SYS_LOCALBASE=\"${SYS_LOCALBASE}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3825        echo "if [ -z \"\$SYS_LOCALBASE\" ]; then SYS_LOCALBASE=\"${SYS_LOCALBASE}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3826        echo "if [ -z \"\$PBI_RCDIR\" ]; then PBI_RCDIR=\"${PBI_RCDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3827        echo "if [ -z \"\$PBI_RCDIR\" ]; then PBI_RCDIR=\"${PBI_RCDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3828        echo "if [ -z \"\$PBI_MANDIR\" ]; then PBI_MANDIR=\"${PBI_MANDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3829        echo "if [ -z \"\$PBI_MANDIR\" ]; then PBI_MANDIR=\"${PBI_MANDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3830        echo "if [ -z \"\$PBI_BINDIR\" ]; then PBI_BINDIR=\"${PBI_BINDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3831        echo "if [ -z \"\$PBI_BINDIR\" ]; then PBI_BINDIR=\"${PBI_BINDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3832
3833        touch "$_tmpextf"
3834        if [ -e "$_autoextf" ]; then cat "${_autoextf}" >> "${_tmpextf}" ; fi
3835        if [ -e "$_extf" ]; then cat "${_extf}" >> "${_tmpextf}" ; fi
3836
3837        while read line
3838        do
3839                _bin="NO"
3840                _wraponly="NO"
3841                _crashhandle="YES"
3842                _keep="YES"
3843                _linux="NO"
3844                echo $line | tr '\t' ' ' | tr -s ' ' | grep "^#" >/dev/null 2>/dev/null
3845                if [ "$?" != "0" ] ; then
3846                        src="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 1`"
3847                        tar="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 2`"
3848                        act="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 3`"
3849
3850                        if [ -z "$src" -o -z "$tar" ] ; then continue ; fi
3851
3852                        # Check if this is an icon we need to preserve
3853                        echo $src | grep -q "^share/icons/"
3854                        if [ $? -eq 0 -a "${PBI_USESYSFONTS}" != "NO" ] ; then
3855                                iDir=`dirname $src`
3856                                if [ ! -d "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}" ] ; then
3857                                        mkdir -p "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}"
3858                                fi
3859                                cp "${PBI_STAGEDIR}/${src}" "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}"
3860                                src="${PBI_ICDIR}/${src}"
3861                        fi
3862
3863                        if [ ! -e "${PBI_STAGEDIR}/$src" ] ; then
3864                                echo "WARN: external_link target: \"$src -> $tar $act\" does not exist!"
3865                                continue
3866                        fi
3867
3868                        # Check for act directives
3869                        for i in `echo ${act} | sed 's|,| |g'`
3870                        do
3871                                case ${i} in
3872                                        binary) _bin="YES" ;;
3873                                    binwrapper) _bin="YES" ; _wraponly="YES" ;;
3874                                       nocrash) _crashhandle="NO" ;;
3875                                          keep) _keep="YES" ;;
3876                                       replace) _keep="NO" ;;
3877                                         linux) _bin="YES" ; _linux="YES" ;;
3878                                        *) echo "Warning: Unknown option \"$i\" in ${MOD_EXTLINKFILE}";;
3879                                esac
3880                               
3881                        done
3882
3883
3884                        # If we are doing a binary, run special function to make wrapper
3885                        if [ "$_bin" = "YES" ] ; then
3886
3887                                # Make sure we don't create any duplicates
3888                                echo "$_donewrap" | grep "#${src}#" >/dev/null 2>/dev/null
3889                                if [ "$?" = "0" ] ; then continue ; fi
3890                               
3891                                # Make the binary wrapper
3892                                mk_path_wrappers "$src" "$tar" "$_crashhandle" "$_wraponly" "$_linux"
3893
3894                                # This binary is done, save it now so we don't duplicate later
3895                                _donewrap="$_donewrap #${src}#"
3896                        else
3897                                # Make our link commands
3898                                if [ "$_keep" = "YES" ] ; then _lop="-fs"; else _lop="-s"; fi
3899                                echo $tar | grep -q "^man/"
3900                                if [ $? -eq 0 ] ; then
3901                                        # Strip off the man/ path
3902                                        _mTar=`echo $tar | sed 's|^man/||g'`
3903                                        _dTar="\$PBI_MANDIR/${_mTar}"
3904                                        echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3905                                        echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3906                                        echo "ln ${_lop} $PBI_PROGDIRPATH/local/${src} \$PBI_MANDIR/${_mTar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3907                                else
3908                                        _dTar="\$SYS_LOCALBASE/${tar}"
3909                                        echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3910                                        echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3911                                        echo "ln ${_lop} $PBI_PROGDIRPATH/local/${src} \$SYS_LOCALBASE/${tar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3912
3913                                fi
3914                        fi
3915
3916                        # Make the uninstall command
3917                        echo "ls -al \"${_dTar}\" | grep \"> $PBI_PROGDIRPATH\" >/dev/null 2>/dev/null " \
3918                                >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3919                        echo "if [ \"\$?\" = \"0\" ] ; then" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3920                        echo "  rm \"${_dTar}\"" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3921                        echo "fi" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3922
3923                        echo " " >> "${dir}/${PBI_INS_PATHSCRIPT}"
3924                        echo " " >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3925
3926                fi
3927
3928        done < "${_tmpextf}"
3929        rm "${_tmpextf}"
3930
3931        chmod 755 "${dir}/${PBI_INS_PATHSCRIPT}"
3932        chmod 755 "${dir}/${PBI_UNINS_PATHSCRIPT}"
3933}
3934
3935
3936# Create the wrapper scripts for the specified binaries
3937mk_path_wrappers() {
3938        dir="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}"
3939        rcdir="${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}"
3940        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3941
3942        bin="${1}"
3943        fbin="`basename ${bin}`"
3944        tar="${2}"
3945        ch="${3}"
3946        onlywrap="${4}"
3947        linwrap="${5}"
3948
3949        # Check if the fake-bin wrapper already exists, and if so use
3950        # a different name
3951        if [ -e "${dir}/${fbin}" ] ; then
3952                fbin=`echo $bin | sed 's|/|-|g'`
3953        fi
3954
3955        # If this is an rc.d script, add it to the PBI_RCDIR
3956        if [ "`dirname $tar`" = "etc/rc.d" ] ; then
3957                        >> "${dir}/${PBI_INS_PATHSCRIPT}"
3958                _dTar="\$PBI_RCDIR/`basename ${tar}`"
3959                echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3960                echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3961                echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKERC_DIR}/${fbin} \$PBI_RCDIR/`basename ${tar}`" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3962
3963                # Copy the wrapper binary
3964                PBI_WRAPPERFILE="/.pbiwrapper-$ARCH"
3965                cp ${PBI_WRAPPERFILE} ${rcdir}/${fbin}
3966                chmod 755 ${rcdir}/${fbin}
3967
3968                # Create the wrapper .pbiopt
3969                echo "PROGDIR: ${PBI_PROGDIRPATH}" >${rcdir}/${fbin}.pbiopt
3970                echo "TARGET: ${bin}" >>${rcdir}/${fbin}.pbiopt
3971                return
3972        fi
3973
3974        # Make our link to the system localbase if its not a wrapper only
3975        if [ "$onlywrap" != "YES" ] ; then     
3976                _mTar=`echo $tar | sed "s|^bin/||g" | sed "s|^sbin/||g"`
3977                _dTar="\$PBI_BINDIR/${_mTar}"
3978
3979                        >> "${dir}/${PBI_INS_PATHSCRIPT}"
3980                echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3981                echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3982                echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${fbin} \$PBI_BINDIR/${_mTar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3983        fi
3984
3985
3986        # Copy the wrapper binary
3987        PBI_WRAPPERFILE="/.pbiwrapper-$ARCH"
3988        cp ${PBI_WRAPPERFILE} ${dir}/${fbin}
3989        chmod 755 ${dir}/${fbin}
3990
3991        # Create the wrapper .pbiopt
3992        echo "PROGDIR: ${PBI_PROGDIRPATH}" >${dir}/${fbin}.pbiopt
3993        echo "TARGET: ${bin}" >>${dir}/${fbin}.pbiopt
3994}
3995
3996# Create any XDG script for install / deinstall
3997mk_xdg_scripts() {
3998        echo "Creating xdg scripts..."
3999        mk_xdg_desktop_script
4000        mk_xdg_menu_script
4001        mk_xdg_mime_script
4002}
4003
4004# Create any XDG script for desktop icons
4005mk_xdg_desktop_script() {
4006        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGDESK_DIR}" ] ; then return 0 ; fi
4007        _dFound=0
4008
4009        dir="${PBI_STAGEDIRMNT}/${PBI_APPDESK_DIR}"
4010        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4011        echo "#!/bin/sh" >"${dir}/${PBI_INS_DESKSCRIPT}"
4012        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_DESKSCRIPT}"
4013
4014        cd "${PBI_CONFDIR}/${MOD_XDGDESK_DIR}"
4015        for i in `ls *.desktop 2>/dev/null`
4016        do
4017                _dFound=1
4018
4019                # Copy over the .desktop file, modifying any variables within
4020                cat "${i}" \
4021                | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4022                | sed "s|%%PBI_APPDIR%%|${PBI_PROGDIRPATH}/local|g" \
4023                > "${dir}/PBI-${i}"
4024
4025                # Set the correct permissions on the desktop file
4026                chmod 744 "${dir}/PBI-${i}"
4027
4028                ifi="$PBI_PROGDIRPATH/${PBI_APPDESK_DIR}/PBI-${i}"
4029
4030                echo "xdg-desktop-icon install --novendor ${ifi}" \
4031                         >> "${dir}/${PBI_INS_DESKSCRIPT}"
4032                echo "xdg-desktop-icon uninstall ${ifi}" \
4033                         >> "${dir}/${PBI_UNINS_DESKSCRIPT}"
4034               
4035        done
4036
4037        chmod 755 "${dir}/${PBI_INS_DESKSCRIPT}"
4038        chmod 755 "${dir}/${PBI_UNINS_DESKSCRIPT}"
4039
4040        # No desktop entries
4041        if [ "$_dFound" = "0" ] ; then
4042                rm "${dir}/${PBI_INS_DESKSCRIPT}"
4043                rm "${dir}/${PBI_UNINS_DESKSCRIPT}"
4044        fi
4045}
4046
4047# Create any XDG script for menu icons
4048mk_xdg_menu_script() {
4049        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGMENU_DIR}" ] ; then return 0 ; fi
4050
4051        _mFound=0
4052
4053        dir="${PBI_STAGEDIRMNT}/${PBI_APPMENU_DIR}"
4054        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4055        echo "#!/bin/sh" >"${dir}/${PBI_INS_MENUSCRIPT}"
4056        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_MENUSCRIPT}"
4057
4058        cd "${PBI_CONFDIR}/${MOD_XDGMENU_DIR}"
4059        for i in `ls *.desktop 2>/dev/null`
4060        do
4061                _mFound=1
4062
4063                # Copy the desktop file, changing any included vars
4064                cat "${i}" \
4065                | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4066                | sed "s|%%PBI_APPDIR%%|${PBI_PROGDIRPATH}/local|g" \
4067                > "${dir}/PBI-${i}"
4068
4069                # Set the correct permissions on the menu file
4070                chmod 744 "${dir}/PBI-${i}"
4071
4072                ifi="$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/PBI-${i}"
4073
4074                # Check for a .directory file associated with this .desktop
4075                ifd=""
4076                dirfile="`basename -s .desktop ${i}`"
4077                if [ -e "${dirfile}.directory" ] ; then
4078                        cat "${dirfile}.directory" \
4079                        | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4080                        | sed "s|%%PBI_APPDIR%%|${PBI_PROGDIRPATH}/local|g" \
4081                        > "${dir}/PBI-${dirfile}.directory"
4082                        #cp "${dirfile}.directory" "${dir}/PBI-${dirfile}.directory"
4083                        ifd="$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/PBI-${dirfile}.directory "     
4084                fi
4085
4086                echo "xdg-desktop-menu install --novendor ${ifd}${ifi}" \
4087                         >> "${dir}/${PBI_INS_MENUSCRIPT}"
4088                echo "xdg-desktop-menu uninstall ${ifd}${ifi}" \
4089                         >> "${dir}/${PBI_UNINS_MENUSCRIPT}"
4090
4091        done
4092
4093        chmod 755 "${dir}/${PBI_INS_MENUSCRIPT}"
4094        chmod 755 "${dir}/${PBI_UNINS_MENUSCRIPT}"
4095
4096        # No mime entries
4097        if [ "$_mFound" = "0" ] ; then
4098                rm "${dir}/${PBI_INS_MENUSCRIPT}"
4099                rm "${dir}/${PBI_UNINS_MENUSCRIPT}"
4100        fi
4101}
4102
4103# Create any XDG script for mime types
4104mk_xdg_mime_script() {
4105        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGMIME_DIR}" ] ; then return 0 ; fi
4106        _mFound=0
4107
4108        dir="${PBI_STAGEDIRMNT}/${PBI_APPMIME_DIR}"
4109        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4110        echo "#!/bin/sh" >"${dir}/${PBI_INS_MIMESCRIPT}"
4111        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_MIMESCRIPT}"
4112
4113
4114        cd "${PBI_CONFDIR}/${MOD_XDGMIME_DIR}"
4115        for i in `ls *.xml 2>/dev/null`
4116        do
4117                _mFound=1
4118                cp "${i}" "${dir}/PBI-${i}"
4119                ifi="$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/PBI-${i}"
4120
4121                # Check for a .directory file associated with this .desktop
4122                ifp=""
4123                iconfile="`basename -s .xml ${i}`"
4124                if [ -e "${iconfile}.png" ] ; then
4125                        cp "${iconfile}.png" "${dir}/${iconfile}.png"
4126                        ifp="$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${iconfile}.png"
4127                        mi=`cat "$i" | grep '<mime-type' | cut -d '"' -f 2 | sed 's|/|-|g'`
4128                        echo "xdg-icon-resource install --novendor --context mimetypes ${ifp} --size 64 $mi" \
4129                                 >> "${dir}/${PBI_INS_MIMESCRIPT}"
4130                        echo "xdg-icon-resource uninstall --context mimetypes ${ifp} --size 64" \
4131                                 >> "${dir}/${PBI_UNINS_MIMESCRIPT}"
4132                fi
4133
4134                echo "xdg-mime install --novendor ${ifi}" \
4135                         >> "${dir}/${PBI_INS_MIMESCRIPT}"
4136                echo "xdg-mime uninstall ${ifi}" \
4137                         >> "${dir}/${PBI_UNINS_MIMESCRIPT}"
4138        done
4139
4140        chmod 755 "${dir}/${PBI_INS_MIMESCRIPT}"
4141        chmod 755 "${dir}/${PBI_UNINS_MIMESCRIPT}"
4142
4143        # No mime entries
4144        if [ "$_mFound" = "0" ] ; then
4145                rm "${dir}/${PBI_INS_MIMESCRIPT}"
4146                rm "${dir}/${PBI_UNINS_MIMESCRIPT}"
4147        fi
4148}
4149
4150
4151# Create the install script for the PBI
4152mk_install_script() {
4153        echo "Creating install script..."
4154        if [ ! -d "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}" ] ; then mkdir -p "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}" ; fi
4155        if [ ! -d "${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}" ] ; then mkdir -p "${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}" ; fi
4156        insc="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/.pbi-install.sh"
4157        echo "#!/bin/sh" > "$insc"
4158        echo "PBI_WRAPPERBIN=\"${PBI_FAKEBIN_DIR}\"" >> "$insc"
4159        echo "PBI_PROGDIRPATH=\"${PBI_PROGDIRPATH}\"" >> "$insc"
4160        echo "SYS_LOCALBASE=\"${SYS_LOCALBASE}\"" >> "$insc"
4161        echo "cd \"\$PBI_PROGDIRPATH\"" >> "$insc"
4162
4163        # Add the binary wrapper sym-links
4164        if [ -e "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" ] ; then
4165                echo 'if [ `id -u` = "0" ] ; then ' >>${insc}
4166                echo "  $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" >>${insc}
4167                echo "fi" >>${insc}
4168        fi
4169
4170        # Look for any XDG scripts
4171        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMIME_DIR}/${PBI_INS_MIMESCRIPT}" ] ; then
4172                echo "$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${PBI_INS_MIMESCRIPT}" >>${insc}
4173        fi
4174        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMENU_DIR}/${PBI_INS_MENUSCRIPT}" ] ; then
4175                echo "$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/${PBI_INS_MENUSCRIPT}" >>${insc}
4176        fi
4177
4178        chmod 755 "${insc}"
4179       
4180}
4181
4182# Create the deinstall script for the PBI
4183mk_deinstall_script() {
4184        echo "Creating deinstall script..."
4185        uisc="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"
4186
4187        echo "#!/bin/sh" > "$uisc"
4188        echo "PBI_PROGDIRPATH=\"${PBI_PROGDIRPATH}\"" >> "$uisc"
4189        echo "SYS_LOCALBASE=\"${SYS_LOCALBASE}\"" >> "$uisc"
4190
4191        # Remove the binary wrapper sym-links
4192        if [ -e "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" ] ; then
4193                echo 'if [ `id -u` = "0" ] ; then ' >>${uisc}
4194                echo "  $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >>${uisc}
4195                echo "fi" >>${uisc}
4196        fi
4197
4198        # Look for any XDG scripts
4199        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMIME_DIR}/${PBI_UNINS_MIMESCRIPT}" ] ; then
4200                echo "$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${PBI_UNINS_MIMESCRIPT}" >>${uisc}
4201        fi
4202        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMENU_DIR}/${PBI_UNINS_MENUSCRIPT}" ] ; then
4203                echo "$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/${PBI_UNINS_MENUSCRIPT}" >>${uisc}
4204        fi
4205        chmod 755 "${uisc}"
4206}
4207
4208# Create a dir for manipulating header info
4209mk_header_dir() {
4210        PBI_HEADERDIR="${PBI_STAGEDIRMNT}/pbimeta"
4211        if [ -e "${PBI_HEADERDIR}" ] ; then rm -rf "${PBI_HEADERDIR}" ; fi
4212        mkdir -p ${PBI_HEADERDIR}
4213}
4214
4215# Create a dir for staging the final archive
4216mk_stage_dir() {
4217        if [ -n "$1" ] ; then
4218                cpDir="$1"
4219        else
4220                cpDir="${PBI_PROGDIRPATH}"
4221        fi
4222
4223        PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"
4224        echo "Creating Stage Dir: ${PBI_STAGEDIR}"
4225        if [ -e "${PBI_STAGEDIR}" ] ; then
4226                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4227                chflags -R noschg ${PBI_STAGEDIR} 2>/dev/null
4228                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4229        fi
4230        mkdir -p ${PBI_STAGEDIR}
4231
4232        mkdir -p ${PBI_STAGEDIR}/local
4233        mkdir -p ${PBI_STAGEDIR}/etc
4234        mkdir -p ${PBI_STAGEDIR}/rc.d
4235        mkdir -p ${PBI_STAGEDIR}/pbimeta
4236        mkdir -p ${PBI_STAGEDIR}/virtbase
4237        mkdir -p ${PBI_STAGEDIR}/linux
4238        mkdir -p ${PBI_STAGEDIR}/run
4239
4240        # If we built with a module / conf directory, lets include it
4241        if [ -d "${PBI_CONFDIR}" ] ; then cp -r ${PBI_CONFDIR} ${PBI_STAGEDIR}/pbiconf; fi
4242
4243        local _excOpts=""
4244
4245        # Build module list of excludes
4246        if [ -n "$PBI_EXCLUDELIST" ] ; then
4247                for excl in $PBI_EXCLUDELIST
4248                do
4249                        if [ -z "$_excOpts" ] ; then
4250                                _excOpts="--exclude ${excl}"
4251                        else
4252                                _excOpts="$_excOpts --exclude ${excl}"
4253                        fi
4254                done
4255        fi
4256
4257        if [ "$2" = "move" ] ; then
4258                rmdir ${PBI_STAGEDIR}/local
4259                mv ${cpDir} ${PBI_STAGEDIR}/local
4260                ln -s ${PBI_STAGEDIR}/local /usr/local
4261        else
4262                # Now copy the stagedir
4263                tar cvf - ${_excOpts} --exclude .stagedir \
4264                --exclude .pkgdb --exclude .ld-elf.hints --exclude make.conf \
4265                --exclude make.conf.bak --exclude .keepports \
4266                -C "${cpDir}" . 2>/dev/null \
4267                | tar xvpf - -C ${PBI_STAGEDIR}/local 2>/dev/null
4268        fi
4269
4270        cd ${PBI_PROGDIRPATH}
4271        PBI_STAGEDIRMNT="${PBI_STAGEDIR}"
4272        PBI_STAGEDIR="${PBI_STAGEDIR}/local"
4273}
4274
4275# Remove the stagedir
4276rm_stage_dir() {
4277        # If this is in the chroot we can exit and let the parent cleanup
4278        if [ "$0" = "pbi_makeport_chroot" ] ; then return; fi
4279
4280        cd /
4281        PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"
4282        if [ -e "${PBI_STAGEDIR}" ] ; then
4283                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4284                chflags -R noschg ${PBI_STAGEDIR} 2>/dev/null
4285                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4286        fi
4287}
4288
4289# See if we need to clean the icons dir
4290clean_icons_dir() {
4291        if [ "${PBI_USESYSFONTS}" != "NO" ] ; then
4292                rm -rf ${PBI_STAGEDIR}/share/icons >/dev/null 2>/dev/null
4293                mkdir ${PBI_STAGEDIR}/share/icons >/dev/null 2>/dev/null
4294        fi
4295}
4296
4297# See if we need to clean the stagedir
4298clean_stage_dir() {
4299
4300        if [ "${PBI_USESYSGL}" != "NO" ] ; then
4301                rm ${PBI_STAGEDIR}/lib/libGl.* >/dev/null 2>/dev/null
4302                rm ${PBI_STAGEDIR}/lib/libGL.* >/dev/null 2>/dev/null
4303                rm ${PBI_STAGEDIR}/lib/libGLU.* >/dev/null 2>/dev/null
4304        fi
4305        if [ "${PBI_USESYSFONTS}" != "NO" ] ; then
4306                rm -rf ${PBI_STAGEDIR}/etc/fonts/* >/dev/null 2>/dev/null
4307                rm -rf ${PBI_STAGEDIR}/lib/X11/fonts/* >/dev/null 2>/dev/null
4308                rm -rf ${PBI_STAGEDIR}/lib/X11/icons/* >/dev/null 2>/dev/null
4309        fi
4310        if [ -e "${PBI_STAGEDIR}/lib/X11" ] ; then
4311                mkdir -p ${PBI_STAGEDIR}/lib/X11/icons/ >/dev/null 2>/dev/null
4312                mkdir -p ${PBI_STAGEDIR}/lib/X11/fonts/ >/dev/null 2>/dev/null
4313                mkdir -p ${PBI_STAGEDIR}/etc/fonts/ >/dev/null 2>/dev/null
4314        fi
4315}
4316
4317# Copy over any resource files into the PBI dir
4318copy_resource_dir() {
4319        if [ -d "${PBI_CONFDIR}/${PBI_RESOURCE_DIR}" ] ; then
4320                echo "Copying ${PBI_CONFDIR}/${PBI_RESOURCE_DIR} -> ${PBI_STAGEDIR}"
4321                tar cvf - -C ${PBI_CONFDIR}/${PBI_RESOURCE_DIR} --exclude .svn . 2>/dev/null \
4322                | tar xvpf - -C ${PBI_STAGEDIR} 2>/dev/null
4323        fi
4324}
4325
4326# Check if tar supports lzma compression
4327test_tar_lzma() {
4328        touch /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4329        tar cvJf /tmp/.pbilzma.tar.$$ /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4330        _exitcode=$?
4331        rm /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4332        rm /tmp/.pbilzma.tar.$$ >/dev/null 2>/dev/null
4333        return $_exitcode
4334}
4335
4336# Start creating the application archive
4337mk_archive_file() {
4338        # Build module list of excludes
4339        if [ -n "$PBI_EXCLUDELIST" ] ; then
4340                for excl in $PBI_EXCLUDELIST
4341                do
4342                        if [ -z "$_excOpts" ] ; then
4343                                _excOpts="--exclude ${excl}"
4344                        else
4345                                _excOpts="$_excOpts --exclude ${excl}"
4346                        fi
4347                done
4348        fi
4349        PBI_CREATE_ARCHIVE="${PBI_CREATE_OUTDIR}/.PBI.$$.tbz"
4350        if test_tar_lzma ; then _tcmp="J" ; else _tcmp="j" ; fi
4351        echo "Creating compressed archive..."
4352        tar cv${_tcmp}f "${PBI_CREATE_ARCHIVE}" ${_excOpts} -C ${PBI_STAGEDIRMNT} . 2>/dev/null
4353}
4354
4355# Start creating the header archive
4356mk_header_file() {
4357        PBI_HEADER_ARCHIVE="${PBI_CREATE_OUTDIR}/.PBI-header.$$.tbz"
4358        tar cvjf ${PBI_HEADER_ARCHIVE} -C ${PBI_HEADERDIR} . >/dev/null 2>/dev/null
4359}
4360
4361# Start copying pbi details into header file
4362save_pbi_details_to_header() {
4363        local _osArch="$ARCH"
4364        local _osRel="$FBSDREL"
4365        if [ -n "${PBI_OSREL}" ] ; then
4366                _osRel="${PBI_OSREL}"
4367        fi
4368
4369        if [ "${PBI_CREATEONLY}" = "YES" ] ; then
4370                _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
4371                echo "${PBI_APPDIR}/${_pbilow}-${_osArch}" > "${PBI_HEADERDIR}/pbi_defaultpath"
4372        else   
4373                echo "${PBI_PROGDIRPATH}" > "${PBI_HEADERDIR}/pbi_defaultpath"
4374        fi
4375        echo "${PBI_PROGNAME}" > "${PBI_HEADERDIR}/pbi_name"
4376        echo "${PBI_PROGVERSION}" > "${PBI_HEADERDIR}/pbi_version"
4377        echo "${PBI_PROGAUTHOR}" > "${PBI_HEADERDIR}/pbi_author"
4378        echo "${PBI_PROGWEB}" > "${PBI_HEADERDIR}/pbi_web"
4379        date "+%Y%m%d %H%M%S" > "${PBI_HEADERDIR}/pbi_mdate"
4380
4381        if [ "${PBI_REQUIRESROOT}" = "YES" ] ; then
4382                touch ${PBI_HEADERDIR}/pbi_requiresroot
4383        fi
4384
4385        # Do we have a license to accept?
4386        if [ -e "${PBI_CONFDIR}/${PBI_LICENSEFILE}" ] ; then
4387                cp "${PBI_CONFDIR}/${PBI_LICENSEFILE}" "${PBI_HEADERDIR}/${PBI_LICENSEFILE}"
4388        fi
4389
4390        # Do we have a conf-supplied meta-file to copy?
4391        if [ -e "${PBI_CONFDIR}/${PBI_USERMETAFILE}" ] ; then
4392                cp "${PBI_CONFDIR}/${PBI_USERMETAFILE}" "${PBI_HEADERDIR}/${PBI_USERMETAFILE}"
4393        fi
4394        # Do we have a user-supplied meta-file to copy?
4395        if [ -n "$PBI_CREATE_USERMETA" ] ; then
4396                cp "$PBI_CREATE_USERMETA" "${PBI_HEADERDIR}/${PBI_USERMETAFILE}"
4397        fi
4398
4399        # Check for additional meta-data
4400        if [ -n "$PBI_LICENSE" ] ; then
4401                echo "$PBI_LICENSE" > ${PBI_HEADERDIR}/pbi_license
4402        fi
4403        if [ -n "$PBI_TAGS" ] ; then
4404                echo "$PBI_TAGS" > ${PBI_HEADERDIR}/pbi_tags
4405        fi
4406        if [ -n "$PBI_PROGTYPE" ] ; then
4407                echo "$PBI_PROGTYPE" > ${PBI_HEADERDIR}/pbi_type
4408        fi
4409        if [ -n "$PBI_CATEGORY" ] ; then
4410                echo "$PBI_CATEGORY" > ${PBI_HEADERDIR}/pbi_category
4411        fi
4412        if [ -n "$PBI_ICONURL" ] ; then
4413                echo "$PBI_ICONURL" > ${PBI_HEADERDIR}/pbi_iconurl
4414        fi
4415        if [ -n "$PBI_DESC" ] ; then
4416                echo "$PBI_DESC" > ${PBI_HEADERDIR}/pbi_desc
4417        fi
4418        if [ -n "$PBI_SHORTDESC" ] ; then
4419                echo "$PBI_SHORTDESC" > ${PBI_HEADERDIR}/pbi_shortdesc
4420        fi
4421        if [ -n "$PBI_MAINTAINER" ] ; then
4422                echo "$PBI_MAINTAINER" > ${PBI_HEADERDIR}/pbi_maintainer
4423        fi
4424
4425        # Custom install / remove scripts
4426        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREINS}" ] ; then
4427                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREINS}" \
4428                        "${PBI_HEADERDIR}/${MOD_PREINS}"
4429        else
4430                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_PREINS}
4431        fi
4432        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_POSTINS}" ] ; then
4433                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_POSTINS}" \
4434                        "${PBI_HEADERDIR}/${MOD_POSTINS}"
4435        else
4436                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_POSTINS}
4437        fi
4438        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREREM}" ] ; then
4439                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREREM}" \
4440                        "${PBI_HEADERDIR}/${MOD_PREREM}"
4441        else
4442                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_PREREM}
4443        fi
4444
4445        # Copy over our icon
4446        if [ -n "${PBI_PROGICON}" -a -e "${PBI_STAGEDIR}/${PBI_PROGICON}" ] ; then
4447                # Get the file extension
4448                _iconExt=`echo "$PBI_PROGICON" | awk -F . '{print $NF}'`
4449                cp "${PBI_STAGEDIR}/${PBI_PROGICON}" "${PBI_HEADERDIR}/pbi_icon.${_iconExt}" >/dev/null 2>/dev/null
4450        else
4451                _iconExt=`echo "$PBI_DEFAULT_ICON_CHROOT" | awk -F . '{print $NF}'`
4452                cp "${PBI_DEFAULT_ICON_CHROOT}" "${PBI_HEADERDIR}/pbi_icon.${_iconExt}" >/dev/null 2>/dev/null
4453        fi
4454
4455        # Check for any gui images
4456        if [ -e "${PBI_STAGEDIR}/${PBI_GUITOPBANNER}" ] ; then
4457                cp "${PBI_STAGEDIR}/${PBI_GUITOPBANNER}" "${PBI_HEADERDIR}/top-banner.png"
4458        fi
4459        if [ -e "${PBI_STAGEDIR}/${PBI_GUISIDEBANNER}" ] ; then
4460                cp "${PBI_STAGEDIR}/${PBI_GUISIDEBANNER}" "${PBI_HEADERDIR}/side-banner.png"
4461        fi
4462
4463        # Save the uname details
4464        echo "${_osArch}" > "${PBI_HEADERDIR}/pbi_arch"
4465        echo "${_osRel}" > "${PBI_HEADERDIR}/pbi_fbsdver"
4466        echo "${PROGVERSION}" > "${PBI_HEADERDIR}/pbi_createver"
4467
4468        # Get the total number of files in the STAGEDIR
4469        get_filetotal_dir "${PBI_STAGEDIR}"
4470        echo "${FILETOTAL}" > "${PBI_HEADERDIR}/pbi_archivecount"
4471
4472        # Save a checksum of archive file
4473        sha256 -q "${PBI_CREATE_ARCHIVE}" > "${PBI_HEADERDIR}/pbi_archivesum"
4474
4475        sign_pbi_files "$PBI_HEADERDIR"
4476}
4477
4478# Use openssl to sign parts of the pbi header structure and archive
4479sign_pbi_files() {
4480        if [ -z "${PBI_SSLPRIVKEY}" ] ; then return 0 ; fi
4481        _sf="${1}/pbi_archivesum ${1}/${MOD_PREINS} ${1}/${MOD_POSTINS} ${1}/${MOD_PREREM}"
4482        for i in $_sf
4483        do
4484                openssl dgst -sha1 \
4485                        -sign ${PBI_SSLPRIVKEY} \
4486                        -out ${i}.sha1 \
4487                        ${i} >/dev/null 2>/dev/null
4488        done
4489}
4490
4491# All the pieces are ready, spit out the final PBI file
4492mk_output_pbi() {
4493        if [ -n "${PBI_PROGICON}" -a -e "${PBI_STAGEDIR}/${PBI_PROGICON}" ] ; then
4494                icon="${PBI_STAGEDIR}/${PBI_PROGICON}"
4495        else
4496                icon="${PBI_DEFAULT_ICON_CHROOT}"
4497        fi
4498
4499        # Set PBI name all lower-case
4500        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
4501        outfile="${PBI_CREATE_OUTDIR}/${_pbilow}-${PBI_PROGVERSION}-${ARCH}.pbi"
4502
4503        mark1="${PBI_CREATE_OUTDIR}/.pbimark1.$$"
4504        mark2="${PBI_CREATE_OUTDIR}/.pbimark2.$$"
4505        echo "
4506${PBI_SS_ICON}" >$mark1
4507        echo "
4508${PBI_SS_ARCHIVE}" >$mark2
4509
4510
4511        # DO IT, DO IT NOW!!!
4512        cat ${PBI_HEADER_ARCHIVE} $mark1 ${icon} $mark2 ${PBI_CREATE_ARCHIVE} > ${outfile}
4513        sha256 -q ${outfile} > ${outfile}.sha256
4514
4515        echo "Created PBI: ${outfile}"
4516
4517        rm $mark1
4518        rm $mark2
4519        rm ${PBI_HEADER_ARCHIVE}
4520        rm ${PBI_CREATE_ARCHIVE}
4521}
4522
4523get_filetotal_dir() {
4524        FILETOTAL="`find ${1} | wc -l | tr -d ' '`"
4525}
4526
4527pbi_delete_init() {
4528        require_root_or_group
4529        init_tmpdir
4530        parse_delete_pbi_cmdline "$@"
4531        do_pbi_delete
4532}
4533
4534# Delete this PBI
4535do_pbi_delete() {
4536        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4537        PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}"
4538
4539        # Unmount the PBI if its mounted
4540        /usr/pbi/.pbime umount "/usr/pbi/.mounts/`basename $PBI_PROGDIRPATH`"
4541
4542        # Give a few seconds before we nuke the dirs
4543        sleep 5
4544
4545        get_username_from_file "${PBI_DBAPPDIR}/${PBI_DELETENAME}/pbi_name"
4546        if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
4547                exit_err "Permission denied to modify PBI installed by: $FILEUSER"
4548        fi
4549
4550        # Set the dirty flag that we are removing this PBI
4551        touch ${PBI_DBAPPDIR}/${PBI_DELETENAME}/.pbiDeleted
4552
4553        check_preremove_script
4554        run_remove_script
4555        remove_pbidir
4556        unregister_pbi
4557       
4558        # Mark the hashdir as dirty
4559        make_hashdir_dirty
4560}
4561
4562# Save the hash-list to run a cleanup afterwards
4563pbirm_save_hashlist() {
4564        if [ "${PBI_DISABLEHASHDIR}" = "YES" ] ; then return 0 ; fi
4565        if [ -e "${PBI_PROGDIRPATH}/${PBI_HASHLIST}" ] ; then
4566                PBI_TMPHASHLIST="${PBI_TMPDIR}/.pbi-hash.$$"
4567                cp ${PBI_PROGDIRPATH}/${PBI_HASHLIST} ${PBI_TMPHASHLIST}
4568        fi
4569}
4570
4571# Function which removes all empty dirs from the hash-dir
4572pbi_clean_emptyhdirs() {
4573        if [ ! -d "${PBI_HASHDIR}" ] ; then return 0 ; fi
4574        cd ${PBI_HASHDIR}
4575        found="0"
4576        for i in `find . -empty -type d 2>/dev/null`
4577        do
4578                if [ "${i}" = "." ] ; then continue ; fi
4579                if [ -d "${PBI_HASHDIR}/${i}" ] ; then
4580                        rmdir "${PBI_HASHDIR}/${i}"
4581                        found="1"
4582                fi     
4583        done
4584
4585        # Run recursively
4586        if [ "$found" = "1" ];then pbi_clean_emptyhdirs ; fi
4587}
4588
4589# Read through and clean the given hash-list
4590pbi_clean_hashlist() {
4591        if [ -z "${PBI_TMPHASHLIST}" ] ; then return 0 ; fi
4592        while read hl
4593        do
4594                file="`echo $hl | sed 's/:::.*$//g'`"
4595                hash="`echo $hl | sed 's/^.*::://g'`"
4596                tfile="${file}:::${hash}"
4597                if [ -f "${PBI_HASHDIR}/${tfile}" ] ; then
4598                        check_remove_hashfile "${tfile}"
4599                fi
4600
4601        done < ${PBI_TMPHASHLIST}
4602        rm ${PBI_TMPHASHLIST}
4603}
4604
4605# Read through and clean the entire hashdir
4606pbi_clean_hashdir() {
4607        if [ ! -d "${PBI_HASHDIR}" ] ; then return 0 ; fi
4608        echo "Cleaning shared-hash dir..."
4609        cd ${PBI_HASHDIR}
4610        tmphashlist="${PBI_TMPDIR}/.pbi-hashdir.$$"
4611        find * -type f -links 1 > "${tmphashlist}" 2>/dev/null
4612        while read hl
4613        do
4614                if [ ! -f "$hl" -o -h "$hl" ] ; then continue ; fi
4615                if [ -f "${PBI_HASHDIR}/${hl}" ] ; then
4616                        check_remove_hashfile "${hl}"
4617                fi
4618
4619        done < $tmphashlist
4620        rm "$tmphashlist"
4621        pbi_clean_emptyhdirs
4622}
4623
4624# Check if this hash-file is ready to be removed from the hash-dir
4625check_remove_hashfile() {
4626        tfile="${PBI_HASHDIR}/${1}"
4627        get_hard_link_count "${tfile}"
4628        if [ "$HLINKS" = "1" ] ; then
4629                if [ "${PBI_VERBOSE}" = "YES" ] ; then
4630                        echo "Removing unused hashfile: $tfile"
4631                fi
4632                rm -f "${tfile}"
4633        fi
4634}
4635
4636# Run the removal script for this PBI
4637run_remove_script() {
4638        uisc="${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"
4639        if [ ! -e "$uisc" ] ; then return 0 ; fi
4640
4641        # If not running as root, be sure to cleanup path links
4642        if [ "`id -u`" != "0" ]; then
4643                cat ${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT} | grep 'rm "$SYS_LOCALBASE/bin' | sed 's|$SYS_LOCALBASE|${HOME}|g' >${PBI_TMPDIR}/.binlnks
4644                while read lnk
4645                do
4646                        /bin/sh -c "${lnk}"
4647                done <${PBI_TMPDIR}/.binlnks
4648                rm ${PBI_TMPDIR}/.binlnks
4649        fi
4650        export_script_vars
4651        if [ "$PBI_VERBOSE" = "YES" ] ; then
4652                sh "${uisc}"
4653        else
4654                sh "${uisc}" >/dev/null 2>/dev/null
4655        fi
4656}
4657
4658# Function to check the supplied $1 dir for any mounts before we
4659# do a rm -rf
4660umount_before_rm()
4661{
4662        if [ -z "${1}" ] ; then return 0 ; fi
4663
4664        local _ddir="$1"
4665        echo "$_ddir" | rev | grep -q '^/'     
4666        if [ $? -ne 0 ] ; then
4667           _ddir="${_ddir}/"
4668        fi
4669       
4670        mount | grep -q "on ${_ddir}"
4671        if [ $? -ne 0 ] ; then return 0; fi
4672
4673        for i in `mount | grep "on ${_ddir}" | awk '{print $3}'`
4674        do
4675           umount -f ${i} >/dev/null 2>/dev/null
4676           if [ $? -ne 0 ] ; then
4677                exit_err "Could not umount ${i} before rm -rf, bailing!"
4678           fi
4679        done
4680        return 0
4681}
4682
4683# Remove the pbi directory
4684remove_pbidir() {
4685        if [ -z "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi
4686        if [ ! -d "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi
4687        if [ "${PBI_PROGDIRPATH}" = "/" ] ; then return 0 ; fi
4688        if [ "$PBI_VERBOSE" = "YES" ] ; then
4689                echo "Removing: ${PBI_PROGDIRPATH}"
4690        fi
4691
4692        # Make sure we are unmounted
4693        umount_before_rm "${PBI_PROGDIRPATH}"
4694       
4695        rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4696
4697        # Do we have leftovers?
4698        if [ -d "${PBI_PROGDIRPATH}" ] ; then
4699                chflags -R noschg "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4700                chmod -R 777 "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4701                rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4702        fi
4703}
4704
4705# Remove this PBI registration
4706unregister_pbi() {
4707        if [ -z "${PBI_DBAPPDIR}" ] ; then return 0 ; fi
4708        if [ -z "${PBI_DELETENAME}" ] ; then return 0 ; fi
4709        if [ ! -d "${PBI_DBAPPDIR}/${PBI_DELETENAME}" ] ; then return 0 ; fi
4710        if [ "$PBI_VERBOSE" = "YES" ] ; then
4711                echo "Removing: ${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4712        fi
4713        rm -rf "${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4714
4715}
4716
4717# Check if we have a preinstall script we need to use
4718check_preremove_script() {
4719        if [ ! -e "${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}" ] ; then return 0 ; fi
4720
4721        if [ "$PBI_VERBOSE" = "YES" ] ; then
4722                echo "Running pre-removal script: ${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}"
4723        fi
4724        export_script_vars
4725        sh "${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}"
4726}
4727
4728add_app_path_links()
4729{
4730        # If root, run the regular path script
4731        if [ `id -u` = "0" ] ; then
4732                sh "${1}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" >/dev/null 2>/dev/null
4733                return
4734        fi
4735
4736        # Running as user add to ~/bin
4737        init_tmpdir
4738        if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi
4739        cat ${1}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT} | grep "${1}/${PBI_FAKEBIN_DIR}" | grep '$PBI_BINDIR' | sed 's|$PBI_BINDIR|${HOME}/bin|g' >${PBI_TMPDIR}/.binlnks
4740        while read lnk
4741        do
4742                /bin/sh -c "${lnk}"
4743               
4744        done <${PBI_TMPDIR}/.binlnks
4745        rm ${PBI_TMPDIR}/.binlnks
4746       
4747}
4748
4749del_app_path_links()
4750{
4751        # If root, run the regular path script
4752        if [ `id -u` = "0" ] ; then
4753                sh "${1}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >/dev/null 2>/dev/null
4754                return
4755        fi
4756
4757        # Running as user remove from ~/bin
4758        if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi
4759        for lnk in `ls ${1}/${PBI_FAKEBIN_DIR}`
4760        do
4761                if [ "$lnk" = "$PBI_INS_PATHSCRIPT" -o "$lnk" = "$PBI_UNINS_PATHSCRIPT" ]
4762                then
4763                        continue
4764                fi
4765
4766                if [ ! -e "${HOME}/bin/$lnk" ] ; then continue ; fi
4767                if [ ! -h "${HOME}/bin/$lnk" ] ; then continue ; fi
4768                       
4769                ls -al "${HOME}/bin/$lnk" | awk '{print $11}' | grep $1 >/dev/null 2>/dev/null
4770                if [ "$?" = "0" ] ; then
4771                        rm ${HOME}/bin/$lnk
4772                fi
4773        done
4774       
4775}
4776
4777pbi_icon_init() {
4778        parse_icon_pbi_cmdline "$@"
4779       
4780        do_pbi_icon
4781}
4782
4783# Start the PBI icon process
4784do_pbi_icon() {
4785        # Get the dir for this PBI
4786        _appDir=`cat ${PBI_DBAPPDIR}/${PBI_ICONTARGETAPP}/pbi_installedpath`
4787
4788        if [ "${PBI_PATHADD}" = "YES" ] ; then
4789                add_app_path_links "$_appDir"
4790        fi
4791        if [ "${PBI_PATHDEL}" = "YES" ] ; then
4792                del_app_path_links "$_appDir"
4793        fi
4794
4795        if [ "${PBI_DESKADD}" = "YES" ] ; then
4796                if [ ! -e "${_appDir}/.xdg-desktop/${PBI_INS_DESKSCRIPT}" ] ; then
4797                        exit_err "No desktop icons for this PBI"
4798                fi
4799                sh "${_appDir}/.xdg-desktop/${PBI_INS_DESKSCRIPT}"
4800        fi
4801        if [ "${PBI_DESKDEL}" = "YES" ] ; then
4802                if [ ! -e "${_appDir}/.xdg-desktop/${PBI_UNINS_DESKSCRIPT}" ] ; then
4803                        exit_err "No desktop icons for this PBI"
4804                fi
4805                sh "${_appDir}/.xdg-desktop/${PBI_UNINS_DESKSCRIPT}"
4806        fi
4807        if [ "${PBI_MENUADD}" = "YES" ] ; then
4808                require_root_or_group
4809                if [ ! -e "${_appDir}/.xdg-menu/${PBI_INS_MENUSCRIPT}" ] ; then
4810                        exit_err "No menu icons for this PBI"
4811                fi
4812                sh "${_appDir}/.xdg-menu/${PBI_INS_MENUSCRIPT}"
4813        fi
4814        if [ "${PBI_MENUDEL}" = "YES" ] ; then
4815                require_root_or_group
4816                if [ ! -e "${_appDir}/.xdg-menu/${PBI_UNINS_MENUSCRIPT}" ] ; then
4817                        exit_err "No menu icons for this PBI"
4818                fi
4819                sh "${_appDir}/.xdg-menu/${PBI_UNINS_MENUSCRIPT}"
4820        fi
4821        if [ "${PBI_MIMEADD}" = "YES" ] ; then
4822                require_root_or_group
4823                if [ ! -e "${_appDir}/.xdg-mime/${PBI_INS_MIMESCRIPT}" ] ; then
4824                        exit_err "No mime registration for this PBI"
4825                fi
4826                sh "${_appDir}/.xdg-mime/${PBI_INS_MIMESCRIPT}"
4827        fi
4828        if [ "${PBI_MIMEDEL}" = "YES" ] ; then
4829                require_root_or_group
4830                if [ ! -e "${_appDir}/.xdg-mime/${PBI_UNINS_MIMESCRIPT}" ] ; then
4831                        exit_err "No mime registration for this PBI"
4832                fi
4833                sh "${_appDir}/.xdg-mime/${PBI_UNINS_MIMESCRIPT}"
4834        fi
4835}
4836
4837pbid_init() {
4838        require_root
4839
4840        parse_pbid_cmdline "$@"
4841
4842        do_pbid
4843}
4844
4845# This is a crude hack, but we need to copy libGL* to a location outside
4846# of /usr/local for PBIs to be able to access them
4847check_populate_opengl()
4848{
4849  local lG
4850  for i in `ls /usr/local/lib/libGl.* /usr/local/lib/libGL.* /usr/local/lib/libGLU.* /usr/local/lib/libnvidia-* 2>/dev/null`
4851  do
4852    lG=`basename $i`
4853    cp ${i} /usr/lib/${lG}
4854  done
4855}
4856
4857# Start the PBID daemon
4858do_pbid() {
4859
4860        # Start by sourcing /etc/profile
4861        # This grabs any HTTP_ / FTP_ PROXY variables
4862        . /etc/profile
4863
4864        # Allow user supplied logfile
4865        if [ -z "${PBID_LOGFILE}" ] ; then
4866          _pbid_log="/var/log/pbid.log"
4867        else
4868          _pbid_log="${PBID_LOGFILE}"
4869        fi
4870
4871        # Set verbosity
4872        _redir="&1"
4873        if [ "${PBI_VERBOSE}" != "YES" ] ; then _redir="/dev/null" ; fi
4874        echo "Started pbid: `date`" > ${_pbid_log}
4875
4876        # Check for opengl libs to link
4877        check_populate_opengl
4878
4879        while
4880        i=1
4881        do
4882                # Do regular sleeps
4883                qslp=0
4884
4885                # Check if we have any out of date index files to update
4886                for _dbIndex in `ls ${PBI_DBREPODIR}`
4887                do
4888                        _iMd5=`echo ${_dbIndex} | cut -d '.' -f 2`
4889                        check_update_index "${_iMd5}"
4890
4891                        # If we failed to get an index try again sooner
4892                        # This is useful if the user has just installed and has not setup
4893                        # the network yet. We want to fetch indexes quickly after net
4894                        # comes up so they dont need to wait 15 min for the next check
4895                        if [ ! -e "${PBI_DBINDEXDIR}/${_iMd5}-index" ] ; then qslp=1; fi
4896                done
4897
4898                # Check if we have a dirty hash-dir to cleanup
4899                check_clean_hashdir "$_pbid_log" "$_redir"
4900
4901                # Check if we have any PBIs to auto-update
4902                check_autoupdate_pbis "$_pbid_log" "$_redir"
4903
4904                # Check if we need to merge files into the hashdir
4905                if [ -n "`ls ${PBI_DBHASHQUEUEDIR}`" ] ; then
4906                        init_tmpdir
4907                        for _hpbi in `ls ${PBI_DBHASHQUEUEDIR}`
4908                        do
4909                                if [ ! -e "${PBI_DBAPPDIR}/${_hpbi}/pbi_installedpath" ] ; then
4910                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4911                                        continue
4912                                fi
4913
4914                                _hpbipath=""
4915                                _hpbipath=`cat ${PBI_DBAPPDIR}/${_hpbi}/pbi_installedpath`
4916                                if [ ! -e "${_hpbipath}/${PBI_HASHLIST}" ] ; then
4917                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4918                                        continue
4919                                fi
4920
4921                                # Get the username this PBI was installed as
4922                                get_username_from_file "${_hpbipath}"
4923
4924                                # Lets start this hash merge
4925                                echo "Adding ${_hpbipath} to hash-dir ($FILEUSER): `date`" >> ${_pbid_log}
4926
4927                                if [ "$FILEUSER" = "root" ];then
4928                                        pbi_add_update_hashdir "${_hpbipath}" "${PBI_DBAPPDIR}/${_hpbi}/.pbiDeleted" >${_redir} 2>${_redir}
4929                                else
4930                                        # Run hashdir command as a user
4931                                        su $FILEUSER -c "pbi_update_hashdir \"${_hpbipath}\" \"${PBI_DBAPPDIR}/${_hpbi}/.pbiDeleted\"" >${_redir} 2>${_redir}
4932                                fi
4933                                echo "Finished adding ${_hpbipath} to hash-dir: `date`" >> ${_pbid_log}
4934                               
4935
4936                                inUseDir="/usr/pbi/.mounts/`basename $_hpbipath`/virtbase/dev"
4937                                # If the PBI isn't running, we can remove trigger
4938                                if [ ! -d "$inUseDir" ] ; then
4939                                        # Now remove the trigger file
4940                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4941                                fi
4942
4943                        done
4944                        rm_tmpdir
4945
4946                fi
4947               
4948                # Check if we should rotate the logfile
4949                _pbidLines=`wc -l ${_pbid_log} | awk '{ print $1 }'`
4950                if [ $(is_num "$_pbidLines") ] ; then
4951                        if [ $_pbidLines -gt $PBI_LOG_LINES ] ; then
4952                                echo "Logfile turnover: `date`" >${_pbid_log}
4953                        fi
4954                fi
4955               
4956
4957                # Done with our check, lets go back to sleep now
4958                if [ $qslp -eq 1 ] ; then
4959                        sleep 10
4960                else
4961                        sleep ${PBIDSLEEP}
4962                fi
4963        done
4964
4965}
4966
4967# Check if there are any PBIs which are flagged for auto-updates
4968check_autoupdate_pbis() {
4969
4970        for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
4971        do
4972                if [ ! -e "${PBI_DBAPPDIR}/${i}/autoupdate-enable" ] ; then
4973                        continue
4974                fi
4975
4976                # Check if this app is already updating
4977                if [ -e "${PBI_DBAPPDIR}/${i}/.updating" ] ; then
4978                        ps -p `cat ${PBI_DBAPPDIR}/${i}/.updating` >/dev/null 2>/dev/null
4979                        if [ "$?" != "0" ] ; then
4980                                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
4981                        else
4982                                continue
4983                        fi
4984                fi
4985
4986                # Found an auto-update enabled APP, see if it needs upping
4987                PBI_UPDATEAPP="$i"
4988
4989                # Load the details about this app
4990                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4991                if [ -z "${PBI_REPO}" ]; then
4992                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4993                fi
4994                if [ -z "${PBI_REPO}" ]; then continue ; fi
4995                local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
4996
4997                # Does this need an update?
4998                check_pbi_update "$PBI_UPDATEAPP" "nodisplay" \
4999                        "$PBI_PROGNAME" "current" \
5000                        "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5001                if [ "$?" != "0" ] ; then
5002                        continue
5003                fi
5004               
5005                # Get the username this PBI was installed as
5006                get_username_from_file "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5007
5008                # Its Update Time!
5009                echo "Starting Auto-Update of ${PBI_UPDATEAPP} ($FILEUSER): `date`" >>${_pbid_log}
5010
5011                su ${FILEUSER} -c "pbi_update ${PBI_UPDATEAPP}" >>${_pbid_log} 2>>${_pbid_log}
5012                if [ "$?" = "0" ] ; then
5013                        echo "Success! Update of ${PBI_UPDATEAPP}: `date`" >>${_pbid_log}
5014                else
5015                        echo "Failed! Update of ${PBI_UPDATEAPP}: `date`" >>${_pbid_log}
5016                fi
5017
5018                rm "${PBI_DBAPPDIR}/${i}/.updating" >/dev/null 2>/dev/null
5019        done
5020}
5021
5022check_clean_hashdir() {
5023        if [ ! -e "${PBI_DBDIRTYFILE}" ] ; then return ; fi
5024
5025        # Get the date of the last hash-cleaning done
5026        local _curDate="`cat ${PBI_DBDIRTYFILE}`"
5027        if [ -e "${PBI_DBDIRTYFILE}.last" ] ; then
5028                local _lastDate="`cat ${PBI_DBDIRTYFILE}.last`"
5029        else
5030                local _lastDate="0"
5031        fi
5032
5033        # See if we have a new date trigger to do a cleaning
5034        if [ "$_curDate" = "${_lastDate}" ]; then return; fi
5035
5036        # Loop through and clean any hash-dirs as the appropriate user
5037        for cHdir in `ls -d ${PBI_HASHDIR}*`
5038        do
5039                get_username_from_file "${cHdir}"
5040                echo "Cleaning hash-dir ($FILEUSER): `date`" >> ${1}
5041                su ${FILEUSER} -c "pbi_delete --clean-hdir" >>${2} 2>>${2}
5042                echo "Finished cleaning hash-dir ($FILEUSER): `date`" >> ${1}
5043                echo "$_curDate" > ${PBI_DBDIRTYFILE}.last 2>/dev/null
5044        done
5045}
5046
5047pbi_info_init() {
5048        parse_info_pbi_cmdline "$@"
5049       
5050        do_pbi_info
5051}
5052
5053# Display information on the PBI / PBIs
5054do_pbi_info() {
5055
5056        # If we are listing available PBIs via the index file
5057        if [ "$PBI_INFOINDEX" = "YES" ] ; then
5058               
5059                # List the available PBIs from the index
5060                do_index_listing
5061               
5062                exit_trap
5063        fi
5064
5065        if [ "$PBI_INFONAME" = "--ALL--" ] ; then
5066                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5067                do
5068                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5069                                if [ "$PBI_VERBOSE" = "YES" ] ; then
5070                                        load_info_from_dir "${PBI_DBAPPDIR}/${i}"
5071                                        get_username_from_file "${PBI_DBAPPDIR}/${i}"
5072                                        PBI_INSTALLED_BY=$FILEUSER
5073                                        pbi_display_info
5074                                        pbi_display_gui "${PBI_DBAPPDIR}/${i}" ""
5075                                        echo " "
5076                                else
5077                                        echo "${i}"
5078                                fi
5079                        fi
5080                done
5081        else
5082                # Start loading our variables
5083                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_INFONAME}"
5084                get_username_from_file "${PBI_DBAPPDIR}/${PBI_INFONAME}"
5085                PBI_INSTALLED_BY=$FILEUSER
5086                pbi_display_info
5087        fi
5088}
5089
5090# Read through the master index file and provide listing of available PBIs for installation
5091do_index_listing()
5092{
5093        # Make sure we have a master index
5094        ls ${PBI_DBINDEXDIR}/* >/dev/null 2>/dev/null
5095        if [ "$?" != "0" ] ; then return ; fi
5096
5097        for _rIndex in `ls ${PBI_DBINDEXDIR}/*index* | grep -v '.time'`
5098        do
5099                _rMd5=`basename ${_rIndex} | sed 's|-index||g'`
5100                _rDesc=`cat ${PBI_DBREPODIR}/*.${_rMd5} | grep 'Desc: ' | sed 's|Desc: ||g'`
5101                echo "Current and available PBIs. * = current"
5102                echo "Repository: $_rDesc"
5103                echo "----------------------------------------------------------------"
5104
5105                sort "${_rIndex}" | while read _iLine
5106                do
5107                        PBI_UPNAME="`echo $_iLine | cut -d ':' -f 1`"
5108                        PBI_UPARCH="`echo $_iLine | cut -d ':' -f 2`"
5109                        PBI_UPNVER="`echo $_iLine | cut -d ':' -f 3`"
5110                        PBI_UPSTATUS="`echo $_iLine | cut -d ':' -f 9`"
5111                        pad_var "${PBI_UPNAME}" "30"
5112                        PBI_UPNAME="${PAD_VAR}"
5113                        pad_var "${PBI_UPNVER}" "15"
5114                        PBI_UPNVER="${PAD_VAR}"
5115                        pad_var "${PBI_UPARCH}" "6"
5116                        PBI_UPARCH="${PAD_VAR}"
5117       
5118                        if [ "$PBI_UPSTATUS" = "current" ] ; then
5119                                echo "$PBI_UPNAME   $PBI_UPNVER $PBI_UPARCH *"
5120                        fi
5121                        if [ "$PBI_UPSTATUS" = "active" ] ; then
5122                                echo "$PBI_UPNAME   $PBI_UPNVER $PBI_UPARCH"
5123                        fi
5124                done
5125        done
5126
5127}
5128
5129# Function to pad a variable to X spaces
5130pad_var() {
5131        local _pVar="$1"
5132        local _pNum="$2"
5133        PAD_VAR="`echo \"$_pVar                                                                                    x\" | cut -c 1-$_pNum`"
5134}
5135
5136# Checks if we have a custom script to run prior to port make
5137run_pbi_preportmake()
5138{
5139        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5140        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5141        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-portmake.sh" ] ; then return 0 ; fi
5142
5143        export_script_vars
5144
5145        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-portmake.sh"
5146        if [ "$?" != "0" ] ; then
5147                exit_err "pre-portmake.sh failed!"
5148        fi
5149}
5150
5151# Checks if we have a custom script to run prior to port make
5152run_pbi_postportmake()
5153{
5154        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5155        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5156        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/post-portmake.sh" ] ; then return 0 ; fi
5157
5158        export_script_vars
5159
5160        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/post-portmake.sh"
5161        if [ "$?" != "0" ] ; then
5162                echo "Warning: post-portmake.sh returned non-0 status!"
5163        fi
5164}
5165
5166# Checks if we have a custom script to run prior to pbi create
5167run_pbi_prepkgscript()
5168{
5169        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5170        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5171        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-pbicreate.sh" ] ; then return 0 ; fi
5172
5173        export_script_vars
5174
5175        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-pbicreate.sh"
5176        if [ "$?" != "0" ] ; then
5177                echo "Warning: post-portmake.sh returned non-0 status!"
5178        fi
5179}
5180
5181# Begins the port make
5182start_pbi_makeport()
5183{
5184        # Remove any trailing '/'
5185        echo $PBI_MAKEPORT | grep -q "/$"
5186        if [ $? -eq 0 ] ; then
5187                PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
5188        fi
5189
5190        do_port_build "${PBI_MAKEPORT}"
5191}
5192
5193# Prune any ports which aren't required for runtime
5194start_pbi_prune_ports()
5195{
5196        if [ "${PBI_PRUNEBUILDPORTS}" = "NO" ] ; then return ; fi
5197
5198        get_pkgname "${PBI_MAKEPORT}"
5199        echo "${PKGNAME}" > /.keepports
5200        make -C "${PORTSDIR}/${PBI_MAKEPORT}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5201
5202        # Do the same for any OTHERPORTS
5203        for port in ${PBI_MKPORTBEFORE}
5204        do
5205                if [ ! -d "${PORTSDIR}/${port}" ] ; then continue ; fi
5206                get_pkgname "${port}"
5207                echo "${PKGNAME}" >> /.keepports
5208                make -C "${PORTSDIR}/${port}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5209        done
5210
5211        for port in ${PBI_MKPORTAFTER}
5212        do
5213                if [ ! -d "${PORTSDIR}/${port}" ] ; then continue ; fi
5214                get_pkgname "${port}"
5215                echo "${PKGNAME}" >> /.keepports
5216                make -C "${PORTSDIR}/${port}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5217        done
5218
5219        # Don't strip out pkgng
5220        pkg info pkg >> /.keepports
5221       
5222        # Sort and clean the ports
5223        cat /.keepports | sort | uniq > /.keepports.tmp
5224        mv /.keepports.tmp /.keepports
5225
5226        # Now remove any unused ports
5227        for j in `pkg info -a | cut -d " " -f 1`
5228        do
5229                grep -q "^${j}" "/.keepports"
5230                if [ $? -ne 0 ] ; then
5231                        echo "Removing non-required port: ${j}"
5232                        $PKG_DELETE ${j} 
5233                fi
5234        done
5235}
5236
5237# Get the full package-name for a target port
5238get_pkgname() {
5239        name="`pkg info -O ${1} | awk '{print $1}'`"
5240        PKGNAME="${name}"
5241}
5242
5243# Make any additional required ports
5244start_pbi_mkportbefore()
5245{
5246        if [ -z "${PBI_MKPORTBEFORE}" ] ; then return ; fi
5247       
5248        for port in ${PBI_MKPORTBEFORE}
5249        do
5250                if [ -n "$PBI_PKGNGBUILD" ] ; then
5251                        pkg-static rquery '%v' ${port} >/dev/null 2>/dev/null
5252                        if [ $? -ne 0 ] ; then
5253                                exit_err "No package exists for: ${port}"
5254                        fi
5255                        do_port_build "${port}"
5256                        continue
5257                fi
5258
5259                if [ ! -d "/usr/ports/${port}" ] ; then
5260                        exit_err "/usr/ports/${port} does not exist!"
5261                fi
5262                do_port_build "${port}"
5263        done
5264
5265}
5266
5267# Make any additional required ports
5268start_pbi_mkportafter()
5269{
5270        if [ -z "${PBI_MKPORTAFTER}" ] ; then return ; fi
5271       
5272        for port in ${PBI_MKPORTAFTER}
5273        do
5274                if [ -n "$PBI_PKGNGBUILD" ] ; then
5275                        pkg-static rquery '%v' ${port} >/dev/null 2>/dev/null
5276                        if [ $? -ne 0 ] ; then
5277                                exit_err "No package exists for: ${port}"
5278                        fi
5279                        do_port_build "${port}"
5280                        continue
5281                fi
5282
5283                # Doing a regular port build
5284                if [ ! -d "/usr/ports/${port}" ] ; then
5285                        exit_err "/usr/ports/${port} does not exist!"
5286                fi
5287                do_port_build "${port}"
5288        done
5289
5290}
5291
5292# Start pbi_update_hashdir
5293pbi_update_hashdir_init() {
5294        pbi_add_update_hashdir "$1" "$2"
5295}
5296
5297# Start pbi_update processing
5298pbi_update_init() {
5299
5300        parse_update_pbi_cmdline "$@"
5301
5302        check_enable_disable_auto
5303
5304        # Stop here if we are just enabling / disabling auto-update
5305        if [ -n "$PBI_UPENABLEAUTO" ] ; then return 0 ; fi
5306
5307        start_update_checks
5308        if [ "$?" != "0" ] ; then rm_tmpdir ; exit 1 ; fi
5309
5310        # Stop here if only doing update checks
5311        if [ -n "${PBI_UPCHECK}" ]; then return 0 ; fi
5312
5313        require_root_or_group
5314
5315        do_pbi_update
5316}
5317
5318# Check if we are enabling / disabling auto-updating
5319check_enable_disable_auto()
5320{
5321        if [ -z "$PBI_UPENABLEAUTO" ] ; then return ; fi
5322        if [ ! -d "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}" ] ; then return ; fi
5323
5324        # Enable / disable auto-updating now
5325        if [ "$PBI_UPENABLEAUTO" = "YES" ]; then
5326                touch ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable
5327        else
5328                rm ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable >/dev/null 2>/dev/null
5329        fi
5330}
5331
5332# Function which checks the digital signature of a PBI to match it to a particular repo
5333pbi_checksig_repomatch() {
5334        if [ `id -u` != "0" ] ; then return ; fi
5335
5336        # See which repo / key this PBI associates to, if any
5337        check_valid_sigs "${1}"
5338        if [ "$?" = "0" -a -n "$PBI_VALIDKEYSIG" ] ; then
5339                _rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"
5340                echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${1}/pbi_repo
5341        fi
5342}
5343
5344# See if we are checking for updates and do it
5345start_update_checks() {
5346        if [ "${PBI_UPCHECK}" != "YES" -a "${PBI_UPCHECK}" != "ALL" ]; then return 0; fi
5347
5348        # Open up the tmpdir
5349        init_tmpdir
5350
5351        if [ "${PBI_UPCHECK}" = "YES" ] ; then
5352                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5353                if [ -z "${PBI_REPO}" ]; then
5354                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5355                fi
5356                if [ -z "${PBI_REPO}" ]; then
5357                        return 1
5358                else
5359                        local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5360                fi
5361
5362                check_pbi_update "$PBI_UPDATEAPP" "display" \
5363                 "$PBI_PROGNAME" "current" \
5364                 "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5365                return $?
5366        else
5367                # Loop and check all PBIs for updates
5368                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5369                do
5370                        PBI_REPO=""
5371                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5372                                load_info_from_dir "${PBI_DBAPPDIR}/${i}"
5373                                if [ -z "${PBI_REPO}" ]; then
5374                                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${i}"
5375                                fi
5376                                if [ -z "${PBI_REPO}" ]; then
5377                                        continue
5378                                else
5379                                        local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5380                                fi
5381
5382                                check_pbi_update "$i" "display" \
5383                                 "$PBI_PROGNAME" "current" \
5384                                 "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5385                        fi
5386                done
5387                return 0
5388        fi
5389
5390}
5391
5392# Check if we need to pull down the updated INDEX file
5393check_update_index() {
5394
5395        init_tmpdir
5396       
5397        local _repoMd5="$1"
5398        local _rURL=`cat ${PBI_DBREPODIR}/*${_repoMd5} | grep URL: | sed 's|URL: ||g'`
5399
5400        _pbiIndex="${PBI_DBINDEXDIR}/${_repoMd5}-index"
5401        _pbiMeta="${PBI_DBINDEXDIR}/${_repoMd5}-meta"
5402        _pbiIndexTime="${_pbiIndex}.time"
5403        _tmpPbiIndex="${PBI_TMPDIR}/.upcheck$$"
5404        _tmpPbiMeta="${PBI_TMPDIR}/.upcheck$$"
5405               
5406        # Check if its been greater than $PBI_INDEXREFRESH hours since the last update
5407        if [ -e "${_pbiIndexTime}" ] ; then
5408                _curTime=`date +%s`
5409                _oTime=`cat ${_pbiIndexTime}`
5410                _trigTime=`expr ${PBI_INDEXREFRESH} \* 60 \* 60`
5411                expr $_curTime - $_oTime >/dev/null 2>/dev/null
5412                if [ "$?" = "0" ] ; then
5413                        _passed=`expr $_curTime - $_oTime`
5414                        if [ "$_passed" -lt "$_trigTime" ] ; then
5415                                return;
5416                        fi
5417                fi
5418               
5419        fi
5420
5421        if [ "${PBI_VERBOSE}" = "YES" ] ; then
5422                echo "Updating index ${_pbiIndex}"
5423                echo "Updating index ${_pbiIndex}: `date`" >> ${_pbid_log}
5424        fi
5425
5426        # Check that the last char isn't a '/'
5427        _tmp=`echo ${_rURL} | wc -m | tr -s ' ' | tr -d ' '`
5428        _tmp2=`expr $_tmp - 1`
5429        _lastC=`echo ${_tmp} | cut -c ${_tmp2}-${_tmp}`
5430        if [ "${_lastC}" = "/" ] ; then
5431                _upURL="`echo ${_rURL} | sed 's|\(.*\).|\1|'`"
5432        else
5433                _upURL="${_rURL}"
5434        fi
5435
5436        fetch -o "${_tmpPbiIndex}.bz2" "${_upURL}/${PBI_INDEXUPFILE}.bz2" >/dev/null 2>/dev/null
5437        if [ "$?" != "0" ] ; then
5438                return
5439        fi
5440
5441        bzip2 -d "${_tmpPbiIndex}.bz2" >/dev/null 2>/dev/null
5442        if [ "$?" != "0" ] ; then
5443                return
5444        fi
5445
5446        # Move the uncompressed file
5447        mv "${_tmpPbiIndex}" "${_pbiIndex}" >/dev/null 2>/dev/null
5448
5449        # Wait a sec
5450        sleep 1
5451
5452        # Now check for an optional meta file update
5453        fetch -o "${_tmpPbiMeta}.bz2" "${_upURL}/${PBI_METAUPFILE}.bz2" >/dev/null 2>/dev/null
5454        if [ "$?" = "0" ] ; then
5455                bzip2 -d "${_tmpPbiMeta}.bz2" >/dev/null 2>/dev/null
5456                if [ "$?" = "0" ] ; then
5457                        mv "${_tmpPbiMeta}" "${_pbiMeta}" >/dev/null 2>/dev/null
5458                fi
5459        fi
5460
5461        # Update the icons for this repos meta file
5462        update_repo_icons "${_repoMd5}" "${_pbiMeta}"
5463
5464        echo "Finished updating index ${_pbiIndex}: `date`" >> ${_pbid_log}
5465        if [ "${PBI_VERBOSE}" = "YES" ] ; then
5466                echo "Finished updating index ${_pbiIndex}"
5467        fi
5468
5469        # Save the time that we are done
5470        date +%s > ${_pbiIndexTime}
5471
5472}
5473
5474# Check if we need to update any repository icons
5475update_repo_icons() {
5476        _repoMd5="$1"
5477        _repoMeta="$2"
5478
5479        echo "Updating meta-icons for $_repoMeta: `date`" >> ${_pbid_log}
5480
5481        # Loop through, downloading icons we find
5482        while read mLine
5483        do
5484                # Make sure this is an app / cat
5485                echo "$mLine" | grep -e "^App=" -e "^Cat=" >/dev/null 2>/dev/null
5486                if [ "$?" != "0" ] ; then continue ; fi
5487
5488                # Get the icon URL
5489                echo "$mLine" | grep "^App=" >/dev/null 2>/dev/null
5490                if [ "$?" = "0" ] ; then
5491                        line=`echo $mLine | sed 's|^App=||g'`
5492                        aIcon=`echo $line | cut -d ';' -f 3`
5493                else
5494                        line=`echo $mLine | sed 's|^Cat=||g'`
5495                        aIcon=`echo $line | cut -d ';' -f 2`
5496                fi
5497                iName=`echo $line | cut -d ';' -f 1`
5498                ext=`echo $aIcon | sed 's/.*\.//'`
5499       
5500                # If we already have this icon, we can skip
5501                if [ -e "${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}" ] ; then
5502                        continue
5503                fi
5504
5505                # Now fetch the file
5506                sFile="${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}"
5507                fetch -o "${sFile}" "${aIcon}" >/dev/null 2>/dev/null
5508                if [ $? -ne 0 ]; then
5509                  # Wait a moment before trying the next
5510                  sleep 40
5511                fi
5512               
5513        done < ${_repoMeta}
5514}
5515
5516# Check a specific PBI for updates
5517check_pbi_update() {
5518
5519        # Init the tmpdir
5520        init_tmpdir
5521
5522        # Set the vars
5523        _upbi="${1}"
5524        _udisp="${2}"
5525        _uprog="${3}"
5526        _uver="${4}"
5527        _ufbsdver="${5}"
5528        _uarch="${6}"
5529        _urepo="${7}"
5530        _omdate="${8}"
5531
5532        _uprog="`echo ${_uprog} | tr -d ' '`"
5533        appname="`echo ${_uprog} | tr '[:lower:]' '[:upper:]'`"
5534
5535        PBI_UPNVER=""
5536        PBI_UPFILE=""
5537        PBI_UPPATCHES=""
5538        PBI_UPCSUM=""
5539        PBI_UPMDATE=""
5540        PBI_UPREPO=""
5541        PBI_UPSIZE=""
5542
5543        # If we are looking for the current app, set _uver accordingly
5544        if [ "$_uver" = "current" ] ; then
5545                _uver=":current"
5546        else
5547                _uver=":${_uver}:"
5548        fi
5549
5550
5551        for _repo in `ls ${PBI_DBINDEXDIR}`
5552        do
5553
5554                if [ "$_urepo" = "AUTO" ] ; then
5555                        _pbiIndex="${PBI_DBINDEXDIR}/${_repo}"
5556                        _rMd5="`echo ${_repo} | sed 's|-index||g'`"
5557                else
5558                        _rMd5=`ls ${PBI_DBREPODIR}/${_urepo}.* | cut -d '.' -f 2`
5559                        _pbiIndex="${PBI_DBINDEXDIR}/${_rMd5}-index"
5560                fi
5561
5562                if [ ! -e "${_pbiIndex}" ] ; then continue ; fi
5563
5564                # Search the update index for the specified PBI
5565                _upLine=`grep -i -e "^$_uprog:" ${_pbiIndex} | grep ":$_uarch:" | grep "$_uver" | head -n 1`
5566
5567                PBI_UPNVER="`echo $_upLine | cut -d ':' -f 3`"
5568                PBI_UPFILE="`echo $_upLine | cut -d ':' -f 6`"
5569                PBI_UPPATCHES="`echo $_upLine | cut -d ':' -f 8`"
5570                PBI_UPCSUM="`echo $_upLine | cut -d ':' -f 4`"
5571                PBI_UPMDATE="`echo $_upLine | cut -d ':' -f 5`"
5572                PBI_UPSIZE="`echo $_upLine | cut -d ':' -f 8`"
5573                PBI_UPMIRROR="`cat ${PBI_DBMIRRORDIR}/${_rMd5} 2>/dev/null`"
5574                PBI_UPREPO="${_rMd5}"
5575
5576                if [ -n "${PBI_UPNVER}" ] ; then break; fi
5577                if [ "${_urepo}" != "AUTO" ] ; then break; fi
5578
5579        done
5580
5581        # If no new version
5582        if [ -z "$PBI_UPNVER" ] ; then return 1 ; fi
5583
5584        # See if this update is newer than the installed date
5585        if [ -n "$_omdate" ] ; then
5586                nDay=`echo $PBI_UPMDATE | cut -d ' ' -f 1`
5587                nHour=`echo $PBI_UPMDATE | cut -d ' ' -f 2`
5588                oDay=`echo $_omdate | cut -d ' ' -f 1`
5589                oHour=`echo $_omdate | cut -d ' ' -f 2`
5590         
5591                # Make sure we have all legit numbers
5592                if [ $(is_num "$nDay") -a $(is_num "$nHour") \
5593                        -a $(is_num "$oDay") -a $(is_num "$oHour") ] ; then
5594                        if [ $oDay -gt $nDay ] ; then return 1 ; fi
5595                        if [ "$oDay" = "$nDay" -a $oHour -gt $nHour ] ; then return 1 ; fi
5596                fi
5597        fi
5598
5599        if [ "$PBI_UPNVER" != "$PBI_PROGVERSION" ] ; then
5600                if [ "$_udisp" = "display" ] ; then
5601                        echo "${_upbi} - Available: ${PBI_UPNVER}"
5602                fi
5603                return 0
5604        else
5605                return 1
5606        fi
5607}
5608
5609# Start PBI update process
5610do_pbi_update() {
5611        if [ -n "${PBI_UPCHECK}" ]; then return 0 ; fi
5612
5613        if [ "$PBI_UPDATEAPP" = "ALL" ] ; then
5614                # Loop and check all PBIs for updates
5615                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5616                do
5617                        if [ -e "${PBI_DBAPPDIR}/${i}/.updating" ] ; then
5618                                ps -p `cat ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating` >/dev/null 2>/dev/null
5619                                if [ "$?" = "0" ] ; then
5620                                        continue
5621                                fi
5622                                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5623                        fi
5624                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5625                                PBI_UPDATEAPP="${i}"
5626                                start_pbi_updateapp "all"
5627                        fi
5628                done
5629        else
5630                if [ -e "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" ] ; then
5631                        ps -p `cat ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating` >/dev/null 2>/dev/null
5632                        if [ "$?" = "0" ] ; then
5633                                exit_err "This application is currently updating."
5634                        fi
5635                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5636                fi
5637                start_pbi_updateapp "single"
5638                exit $?
5639        fi
5640}
5641
5642# Attempt to download a PBI from the update server for "pbi_add -r"
5643pbi_add_fetch_remote() {
5644        # Set the target program we want to download
5645        _rtar="$PBI_FILENAME"
5646        unset PBI_FILENAME
5647
5648        # Check if the user overrode the arch / versions we want to install
5649        _rArch=`uname -m`
5650        if [ -n "$PBI_ADD_ALTARCH" ] ; then _rArch=$PBI_ADD_ALTARCH ; fi
5651
5652        _rVer="current"
5653        if [ -n "$PBI_ADD_ALTVER" ] ; then _rVer=$PBI_ADD_ALTVER ; fi
5654
5655        check_pbi_update "$_rtar" "nodisplay" \
5656         "$_rtar" "$_rVer" \
5657         "$FBSDMAJOR" "$_rArch" "${PBI_ADDREPO_ID}"
5658        if [ "$?" != "0" ] ; then 
5659                # If we are on amd64, do a fallback check to i386 for this PBI
5660                # This catches apps like wine / skype and others
5661                if [ "$_rArch" = "amd64" ] ; then
5662                        _rArch="i386"
5663                        check_pbi_update "$_rtar" "nodisplay" \
5664                        "$_rtar" "$_rVer" \
5665                        "$FBSDMAJOR" "$_rArch" "${PBI_ADDREPO_ID}"
5666                        if [ "$?" != "0" ] ; then
5667                                exit_err "Could not find \"$_rtar\" in any indexes" 
5668                        fi
5669                else
5670                        exit_err "Could not find \"$_rtar\" in any indexes" 
5671                fi
5672        fi
5673
5674        # We've gotten this far, now download the updated PBI
5675        pbi_update_dl
5676        if [ "$?" != "0" ] ; then
5677                exit_err "Failed downloading PBI"
5678        fi
5679
5680        # Now overwrite the PBI_FILENAME and let us proceed to regular install
5681        PBI_FILENAME="$PBI_UPDLFILE"
5682
5683        # If we are only fetching, finish up now
5684        if [ "$PBI_REMOTEFETCHONLY" = "YES" ] ; then
5685                mv $PBI_FILENAME ./`basename ${PBI_UPFILE}`
5686                echo "PBI saved to ./`basename ${PBI_UPFILE}`"
5687                exit_trap
5688        fi
5689
5690}
5691
5692# Update the targed PBI
5693start_pbi_updateapp() {
5694        _upact="${1}"
5695        if [ "$2" = "pbid" ] ; then
5696                _pbidlog="$2"
5697        else
5698                _pbidlog=""
5699        fi
5700
5701        echo "$$" > "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5702
5703        # Check for update to this app, and exit or return if not available
5704        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5705        if [ -z "${PBI_REPO}" ]; then
5706                pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5707        fi
5708        if [ -z "${PBI_REPO}" ]; then
5709                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5710                return 1
5711        else
5712                local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5713        fi
5714
5715        check_pbi_update "$PBI_UPDATEAPP" "nodisplay" \
5716         "$PBI_PROGNAME" "current" \
5717         "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5718        if [ "$?" != "0" ] ; then
5719                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5720                if [ "$_upact" = "single" ] ; then
5721                        exit_err "$PBI_UPDATEAPP - no update available!"
5722                else
5723                        return 1
5724                fi
5725        fi
5726       
5727       
5728        echo "Starting update of ${PBI_UPDATEAPP} to ${PBI_UPNVER}..."
5729        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
5730
5731        # Check if there is a possible patch file for this update
5732        # new filename to download
5733        _pFile="${_pbilow}-${PBI_PROGVERSION}_to_${PBI_UPNVER}-${PBI_APPARCH}.pbp"
5734
5735        # Try downloading the patch file
5736        echo "Trying update via patchfile..."
5737        pbi_update_dl "$_pFile" "OFF"
5738        if [ "$?" = "0" ] ; then
5739                # We had a good patch download, try applying it now
5740                echo "Updating via patch file..."
5741                pbi_patch "$PBI_UPDLFILE" #>/dev/null 2>/dev/null
5742                if [ "$?" != "0" ] ; then
5743                        # Patching failed, we'll grab a fresh copy next
5744                        echo "Failed to patch with ${_pFile}"
5745                        echo "Will try full file update"
5746                else
5747                        echo "Patch successful!"
5748                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" >/dev/null 2>/dev/null
5749                        rm "${PBI_UPDLFILE}" >/dev/null 2>/dev/null
5750                        return 0
5751                fi
5752                       
5753        fi
5754
5755        # No patch file, grab the full app
5756        echo "Trying update via full-file..."
5757        pbi_update_dl
5758        if [ "$?" != "0" ] ; then
5759                if [ "$_upact" = "single" ] ; then
5760                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5761                        exit_err "Failed downloading update!"
5762                fi
5763        fi
5764
5765        echo " "
5766
5767        # Save the auto-update status
5768        if [ -e "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable" ] ; then
5769                _autoUpEnable="YES"
5770        else
5771                _autoUpEnable="NO"
5772        fi
5773       
5774        echo -e "Removing old version...\c"
5775        pbi_delete "${PBI_UPDATEAPP}"
5776        echo "Done"
5777
5778        # Now install new PBI
5779        echo -e "Installing new version...\c"
5780        pbi_add --licagree -f "$PBI_UPDLFILE" >/dev/null 2>/dev/null
5781        if [ "$?" != "0" ] ; then
5782                echo "Failed to install PBI: ${PBI_UPDLFILE}"
5783                rm "${PBI_UPDLFILE}"
5784                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" 2>/dev/null
5785                return 1
5786        else
5787                if [ "$_autoUpEnable" = "YES" ] ; then
5788                        touch "${PBI_DBAPPDIR}/${_pbilow}-${PBI_UPNVER}-${PBI_APPARCH}/autoupdate-enable"
5789                fi
5790                echo "Done"
5791                rm "${PBI_UPDLFILE}"
5792                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" 2>/dev/null
5793                return 0
5794        fi     
5795}
5796
5797# Start downloading the update
5798pbi_update_dl() {
5799
5800        _tPatch=$1
5801        local _CKSUM="$2"
5802       
5803        # Set local download location
5804        _dl_loc="${PBI_APPDIR}/.`basename $PBI_UPFILE`"
5805
5806        # Have a patch file to download instead, make that the active file to try
5807        if [ -n "$_tPatch" ] ; then
5808                _bDir=`dirname $PBI_UPFILE`
5809                _uFile="${_bDir}/${_tPatch}"
5810        else
5811                _uFile="${PBI_UPFILE}"
5812        fi
5813
5814        _mirrorList=`echo $PBI_UPMIRROR | sed 's|\n| |g'`
5815
5816        # Start download from repos mirror(s) in order
5817        for _cMirror in $_mirrorList
5818        do
5819                if [ "$_cMirror" = "PCBSDCDN" -o "$_cMirror" = "http://pbi.cdn.pcbsd.org" ] ; then
5820
5821                        # Strip the /PBI from the mirror URL
5822                        _uFile="`echo ${_uFile} | sed 's|^/PBI||g'`"
5823                        if [ -e "$_dl_loc" ] ; then rm "$_dl_loc" ; fi 
5824
5825                        get_file_from_mirrors "${_uFile}" "$_dl_loc" "pbi"
5826                        if [ "$?" != "0" ]  ; then
5827                                rm "${_dl_loc}" >/dev/null 2>/dev/null
5828                                echo "Download Failed: ${_furl}"
5829                                continue
5830                        fi
5831                else
5832                        _furl="`echo $_cMirror | sed 's/\/*$//'`${_uFile}"
5833                        if [ -e "$_dl_loc" ] ; then rm "${_dl_loc}" ; fi       
5834
5835                        echo "Downloading ${_furl}"
5836                        pbi_get_file "$_furl" "$_dl_loc"
5837                        if [ "$?" != "0" ]  ; then
5838                                rm "${_dl_loc}" >/dev/null 2>/dev/null
5839                                echo "Download Failed: ${_furl}"
5840                                continue
5841                        fi
5842                fi
5843                sync
5844                sleep 1
5845                _upcsum=`sha256 -q "$_dl_loc"`
5846                if [ "$_CKSUM" != "OFF" -a "$_upcsum" != "$PBI_UPCSUM" ] ; then
5847                        rm "${_dl_loc}" >/dev/null 2>/dev/null
5848                        echo "Download fails checksum: ${_furl}"
5849                        continue
5850                fi
5851
5852                # If we get this far, we have a good file!
5853                PBI_UPDLFILE="$_dl_loc"
5854                sync
5855                return 0
5856        done
5857
5858        return 1
5859}
5860
5861# Function to download a file from remote using fetch
5862pbi_get_file() {
5863        _rf="${1}"
5864        _lf="${2}"
5865
5866        init_tmpdir
5867        if [ -e "${_lf}" ] ; then
5868                echo "Resuming download of: ${_lf}"
5869        fi
5870
5871        if [ "$PBI_FETCH_PARSING" != "YES" ] ; then
5872                fetch -r -o "${_lf}" "${_rf}"
5873                _err=$?
5874        else
5875                # Doing a front-end download, parse the output of fetch
5876                _eFile="${PBI_TMPDIR}/.fetch-exit.$$"
5877                fetch -s "${_rf}" > ${PBI_TMPDIR}/.fetch-size.$$ 2>/dev/null
5878                _fSize=`cat ${PBI_TMPDIR}/.fetch-size.$$ 2>/dev/null`
5879                _fSize="`expr ${_fSize} / 1024 2>/dev/null`"
5880                rm "${PBI_TMPDIR}/.fetch-size.$$" 2>/dev/null
5881                _time=1
5882
5883                ( fetch -r -o "${_lf}" "${_rf}" >/dev/null 2>/dev/null ; echo "$?" > ${_eFile} ) &
5884                FETCH_PID=`ps -auwwwx | grep -v grep | grep "fetch -r -o ${_lf}" | awk '{print $2}'`
5885                while :
5886                do
5887                        if [ -e "${_lf}" ] ; then
5888                                _dSize=`du -k ${_lf} | tr -d '\t' | cut -d '/' -f 1`
5889                                if [ $(is_num "$_dSize") ] ; then
5890                                        if [ ${_fSize} -lt ${_dSize} ] ; then _dSize="$_fSize" ; fi
5891                                        _kbs=`expr ${_dSize} \/ $_time`
5892                                        echo "SIZE: ${_fSize} DOWNLOADED: ${_dSize} SPEED: ${_kbs} KB/s"
5893                                fi
5894                        fi
5895
5896                        # Make sure download isn't finished
5897                        ps -p $FETCH_PID >/dev/null 2>/dev/null
5898                        if [ "$?" != "0" ] ; then break ; fi
5899                        sleep 2
5900                        _time=`expr $_time + 2`
5901                done
5902
5903                _err="`cat ${_eFile}`"
5904                if [ "$_err" = "0" ]; then echo "FETCHDONE" ; fi
5905                unset FETCH_PID
5906        fi
5907
5908        echo ""
5909        return $_err
5910}
5911
5912is_num()
5913{
5914        expr $1 + 1 2>/dev/null
5915        return $?
5916}
5917
5918# Function to check if the port is flagged to only build on specific arch
5919# Returns 0 for OK, 1 for invalid arch
5920check_port_compat_arch()
5921{
5922        local sPort=$1
5923        have32="false";
5924        local cValues="`make -C $sPort -V ONLY_FOR_ARCHS PORTSDIR=${PORTSDIR}`"
5925        if [ -z "$cValues" ] ; then return 0 ; fi
5926
5927        for cArch in $cValues
5928        do
5929                if [ "$cArch" = "$ARCH" ] ; then return 0; fi
5930                if [ "$cArch" = "i386" ] ; then have32="true" ; fi
5931        done
5932        return 1
5933}
5934
5935# start processing autobuild
5936pbi_autob_init() {
5937
5938        require_root
5939
5940        parse_autob_pbi_cmdline "$@"
5941
5942        do_pbi_autob
5943}
5944
5945check_zfs_ab_destroy()
5946{
5947        local bNum=$1
5948        if [ -e "${PBI_TMPDIR}/${bNum}.zmnt" ] ; then
5949                zDir=`cat ${PBI_TMPDIR}/${bNum}.zmnt`
5950                # Make sure this zfs dataset is in the PBI_APPDIR directory
5951                echo $zDir | grep -q "${PBI_APPDIR}/" 
5952                if [ $? -eq 0 ] ; then
5953                  # Make sure all is unmounted
5954                  umount -f ${PBI_CHROOTDIR}/dev >/dev/null 2>/dev/null
5955                  umount -f ${PBI_CHROOTDIR}/compat/linux/proc >/dev/null 2>/dev/null
5956                  umount -f ${PBI_CHROOTDIR}/usr/ports >/dev/null 2>/dev/null
5957                  umount -f ${PBI_CHROOTDIR}/pkgs >/dev/null 2>/dev/null
5958                  umount -f ${PBI_CHROOTDIR}/.ccache >/dev/null 2>/dev/null
5959                  umount -f ${PBI_CHROOTDIR}/usr/wrkdirprefix >/dev/null 2>/dev/null
5960                  sleep 3
5961                  umount -f ${PBI_CHROOTDIR}/dev >/dev/null 2>/dev/null
5962                  sync
5963                  sleep 3
5964                  zfs destroy -r "${zDir}"
5965                  rmdir "${zDir}" >/dev/null 2>/dev/null
5966                fi
5967        fi
5968}
5969
5970ab_clean_build_tmpfiles()
5971{
5972        local build=$1
5973
5974        # Cleanup
5975        rm ${PBI_TMPDIR}/${build}.result 2>/dev/null
5976        rm ${PBI_TMPDIR}/${build}.pid 2>/dev/null
5977        rm ${PBI_TMPDIR}/${build}.bPort 2>/dev/null
5978        rm ${PBI_TMPDIR}/${build}.od 2>/dev/null
5979        rm ${PBI_TMPDIR}/${build}.mp 2>/dev/null
5980        rm ${PBI_TMPDIR}/${build}.cd 2>/dev/null
5981        rm ${PBI_TMPDIR}/${build}.pv 2>/dev/null
5982        rm ${PBI_TMPDIR}/${build}.zmnt 2>/dev/null
5983}
5984
5985# Start the auto-build traversal process
5986do_pbi_autob() {
5987
5988        echo "`basename ${0}` started: `date`"
5989
5990        # Prune any outdir files which we don't have modules for
5991        do_pbi_autob_prune
5992
5993        cd "${PBI_AB_CONFDIR}"
5994        init_tmpdir
5995
5996        # Get this runs timestamp
5997        PBI_AB_TIMESTAMP=`date | md5`
5998
5999
6000        # Build our list of targets first
6001        echo "=> Creating build queue list..."
6002        ab_get_build_list
6003
6004        done=0
6005        rebuildlist=0
6006        while :; do
6007          activity=0
6008          # Start checking each job
6009          for build in ${JOBS-$(jot -w %02d ${PBI_AB_BUILDERS})}; do
6010                # Is this builder running?
6011                if [ -e "${PBI_TMPDIR}/${build}.pid" ] ; then
6012                        if pgrep -qF "${PBI_TMPDIR}/${build}.pid" >/dev/null 2>&1; then
6013                                activity=1
6014                                continue;
6015                        else
6016                                # Do the ZFS destroy here if necessary
6017                                check_zfs_ab_destroy "$build"
6018                               
6019                                # Run the post-build process
6020                                ab_post_build ${build}
6021
6022                                # Cleanup
6023                                ab_clean_build_tmpfiles ${build}
6024                        fi
6025                fi
6026                if [ $done -eq 1 ] ; then continue ; fi
6027
6028                # Builder idle, lets figure out the next build
6029                #echo "==> Finding target for build process [$build]"
6030                start_next_ab_target "$build"
6031                if [ $? -eq 0 ] ; then 
6032                        # Nothing left to build, lets wait for any existing build to finish before exiting
6033                        done=1
6034                fi
6035                activity=1
6036          done
6037
6038          # Every 2 hours, we can re-scan the modules directory, catch any ones which may have been added / changed
6039          if [ $rebuildlist -eq 7200 ] ; then
6040             rebuildlist=0
6041             ab_get_build_list
6042          else
6043             rebuildlist=`expr $rebuildlist + 1`
6044          fi
6045
6046          # Wait before checking again
6047          [ $activity -eq 1 ] && sleep 1
6048          # Nothing to do? We can end now
6049          [ $activity -eq 0 ] && break
6050        done
6051
6052        echo "`basename ${0}` Finished: `date`"
6053};
6054
6055ab_get_build_list()
6056{
6057
6058   AB_FOUND="0"
6059   unset CUR_PRIORITY_PBI CUR_WORKING_PBI
6060
6061   # Clear the tmp build list
6062   rm ${PBI_TMPDIR}/.ablist 2>/dev/null
6063               
6064   cd "${PBI_AB_CONFDIR}"
6065   for pbi in `find . -type f -name "${PBI_CONFFILE}" | grep -v '\.svn' | sort`
6066   do
6067        # Figure out the target port for this build
6068        unset PBI_MAKEPORT PBI_BUILDKEY PBI_PROGVERSION PBI_REQUIRESROOT PBI_PROGNAME PBI_PROGWEB PBI_PROGAUTHOR PBI_PROGICON PBI_MKPORTBEFORE PBI_MKPORTAFTER PBI_MAKEOPTS PBI_EXCLUDELIST PBI_AB_PRIORITY PBI_HASH_EXCLUDES PBI_AB_NOTMPFS PBI_PROGREVISION PBI_AB_NOPKGBUILD
6069
6070        . ${pbi}
6071
6072        _cd=$(dirname $pbi | sed 's|./||')
6073        PBI_CONFDIR="$_cd"
6074
6075        # Make sure PBI_MAKEPORT is set
6076        if [ -z "${PBI_MAKEPORT}" ] ; then
6077                PBI_MAKEPORT=`echo $pbi | sed 's|./||'`
6078                export PBI_MAKEPORT
6079        fi     
6080
6081        # Remove any trailing '/'
6082        echo $PBI_MAKEPORT | grep -q "/$"
6083        if [ $? -eq 0 ] ; then
6084                PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
6085        fi
6086       
6087        # Check for missing port target
6088        if [ -z "$PBI_MAKEPORT" ] ; then
6089                #echo "Warning: Missing PBI_MAKEPORT for ${pbi}"
6090                continue
6091        fi
6092
6093        if [ "$PBI_AB_PKGBUILD" = "YES" -a -z "$PBI_AB_NOPKGBUILD"  ] ; then
6094                # Doing a package build for this PBI
6095                pkg-static rquery "%v" ${PBI_MAKEPORT} >/dev/null 2>/dev/null
6096                if [ $? -ne 0 ] ; then
6097                        echo "No package found for: ${PBI_MAKEPORT}"
6098                        continue
6099                fi
6100                PBI_PKGNGBUILD="YES" ; export PBI_PKGNGBUILD
6101
6102        else
6103
6104                # Doing a port build for this PBI
6105                if [ ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ] ; then 
6106                        #echo "Skipping invalid port ${PORTSDIR}/${PBI_MAKEPORT}"
6107                        continue
6108                fi
6109
6110                # Check if this port can be built on this architecture
6111                check_port_compat_arch "${PORTSDIR}/${PBI_MAKEPORT}"
6112                if [ "$?" = "1" ] ; then
6113                        if [ "$PBI_ABFB32" != "YES" ] ; then
6114                                echo "${PBI_MAKEPORT} - Skipping for invalid system arch"
6115                                continue
6116                        fi
6117                        if [ "$have32" != "true" ] ; then
6118                                echo "${PBI_MAKEPORT} - Skipping for invalid system arch"
6119                                continue
6120                        fi
6121                fi
6122                unset PBI_PKGNGBUILD
6123
6124        fi
6125
6126        # Check if another builder is already doing this port
6127        pBuilding=0
6128        for p in `ls ${PBI_TMPDIR}/*.bPort 2>/dev/null`
6129        do
6130                if [ "`cat $p`" = "$PBI_MAKEPORT" ] ; then
6131                        pBuilding=1
6132                        break
6133                fi
6134        done
6135        if [ $pBuilding -eq 1 ] ; then
6136                continue
6137        fi
6138
6139        check_ab_needed "$PBI_MAKEPORT" "${PBI_BUILDKEY}" "$_cd" "$PBI_AB_TIMESTAMP"
6140        if [ "$?" = "0" ] ; then       
6141           AB_FOUND="1"
6142
6143           # Unset the priority if set to 00 / 0
6144           if [ "${PBI_AB_PRIORITY}" = "00" -o "${PBI_AB_PRIORITY}" = "0" ] ; then
6145                unset PBI_AB_PRIORITY
6146           fi
6147
6148           # Check the priority of this PBI, see if it rises to the top
6149           if [ -z "${CUR_PRIORITY_PBI}" ] ; then
6150             CUR_WORKING_PBI="${pbi}"
6151             if [ -z "$PBI_AB_PRIORITY" ] ; then
6152                     CUR_PRIORITY_PBI="$internal_ab_priority"
6153             else
6154                     CUR_PRIORITY_PBI=`expr $PBI_AB_PRIORITY + 10`
6155             fi
6156             #echo "Setting higher priority target: ${pbi} - Priority: ${CUR_PRIORITY_PBI}"
6157             echo "${CUR_PRIORITY_PBI} $pbi" >> ${PBI_TMPDIR}/.abtmp
6158             continue
6159           fi
6160
6161           # Bump up the supplied AB priority
6162           if [ -n "${PBI_AB_PRIORITY}" ] ; then
6163              internal_ab_priority=`expr $PBI_AB_PRIORITY + 10`
6164           fi
6165
6166           # Check if this PBI is a higher priority
6167           if [ $CUR_PRIORITY_PBI -lt $internal_ab_priority ] ; then
6168             #echo "Setting higher priority target: ${pbi} - Priority: ${internal_ab_priority}"
6169             CUR_WORKING_PBI="${pbi}"
6170             CUR_PRIORITY_PBI="$internal_ab_priority"
6171             echo "${internal_ab_priority} $pbi" >> ${PBI_TMPDIR}/.abtmp
6172             continue
6173           else
6174             echo "${internal_ab_priority} $pbi" >> ${PBI_TMPDIR}/.abtmp
6175           fi
6176           continue
6177         fi
6178
6179  done
6180
6181  # Sort the list
6182  if [ -e "${PBI_TMPDIR}/.abtmp" ] ; then
6183    sort -n -r ${PBI_TMPDIR}/.abtmp > ${PBI_TMPDIR}/.ablist
6184    rm ${PBI_TMPDIR}/.abtmp
6185  fi
6186}
6187
6188start_next_ab_target()
6189{
6190  local curBuilder="$1"
6191  # No list to parse?
6192  if [ ! -e "${PBI_TMPDIR}/.ablist" ] ; then return 0; fi
6193
6194  # Get the last on the list
6195  CUR_WORKING_PBI=`cat ${PBI_TMPDIR}/.ablist | head -1 | cut -d ' ' -f 2`
6196  if [ -z "${CUR_WORKING_PBI}" ] ; then return 0; fi
6197
6198  cd "${PBI_AB_CONFDIR}"
6199
6200  # We have something to build lets do it!
6201  pbi="$CUR_WORKING_PBI"
6202  unset PBI_MAKEPORT PBI_BUILDKEY PBI_PROGVERSION PBI_REQUIRESROOT PBI_PROGNAME PBI_PROGWEB PBI_PROGAUTHOR PBI_PROGICON PBI_MKPORTBEFORE PBI_MKPORTAFTER PBI_MAKEOPTS PBI_EXCLUDELIST PBI_AB_PRIORITY PBI_HASH_EXCLUDES PBI_AB_NOTMPFS PBI_PROGREVISION PBI_AB_NOPKGBUILD PBI_PKGNGBUILD
6203  . ${pbi}
6204
6205  _cd=$(dirname $pbi | sed 's|./||')
6206  PBI_CONFDIR="$_cd"
6207
6208  if [ -z "${PBI_MAKEPORT}" ] ; then
6209     PBI_MAKEPORT=$(dirname $pbi | sed 's|./||')
6210  fi   
6211
6212  # Remove any trailing '/'
6213  echo $PBI_MAKEPORT | grep -q "/$"
6214  if [ $? -eq 0 ] ; then
6215    PBI_MAKEPORT="`echo $PBI_MAKEPORT | sed 's|/$||g'`"
6216  fi
6217
6218  # Get the prog version
6219  get_pbi_progversion
6220
6221  if [ "$PBI_AB_PKGBUILD" = "YES" -a -z "$PBI_AB_NOPKGBUILD"  ] ; then
6222     ttag="package"
6223  else
6224     ttag="source"
6225  fi
6226
6227  echo "==> Starting $ttag build [$curBuilder]: $PBI_MAKEPORT"
6228  echo "$PBI_MAKEPORT" >${PBI_TMPDIR}/${curBuilder}.bPort
6229
6230  # Remove this from the queue
6231  cat ${PBI_TMPDIR}/.ablist | tail -n +2 > ${PBI_TMPDIR}/.abtmp
6232  mv ${PBI_TMPDIR}/.abtmp ${PBI_TMPDIR}/.ablist
6233
6234  # Start the build now
6235  start_ext_ab "$PBI_MAKEPORT" \
6236  "${PBI_BUILDKEY}" "${PBI_PROGVERSION}" \
6237  "${_cd}" "${PBI_AB_OUTDIR}" "${PBI_AB_TIMESTAMP}" "${curBuilder}"
6238
6239  return 1
6240};
6241
6242# Prune any outdir files which don't have matching modules
6243do_pbi_autob_prune() {
6244        if [ "${PBI_AB_PRUNE}" != "YES" ] ; then return 0 ; fi
6245
6246        echo "=> Cleaning outgoing directory..."
6247        # Prune outgoing dirs which don't have matching modules anymore
6248        cd "${PBI_AB_OUTDIR}"
6249        for i in `find . -type d | grep -v '\.svn'`
6250        do
6251                if [ "${i}" = "." -o "${i}" = ".." ] ; then continue ; fi
6252                _pDir=`dirname ${i}`
6253                if [ -d "${i}" -a -n "${i}" ] ; then
6254                        if [ ! -e "${PBI_AB_CONFDIR}/${_pDir}" ] ; then
6255                        # Not in our module tree anymore, remove it
6256                        echo "Auto-Prune: ${PBI_AB_OUTDIR}/${_pDir}"
6257                        rm -rf "${PBI_AB_OUTDIR}/${_pDir}"
6258                        fi
6259                fi
6260        done
6261        cd
6262}
6263
6264# Start the pbi_makeport process
6265start_ext_ab() {
6266        _mp="${1}"
6267        _bk="${2}"
6268        _pv="${3}"
6269        _cd="${4}"
6270        _od="${5}/${_cd}"
6271        local _abkey="$6"
6272        local eBuilder="$7"
6273        _flags=""
6274        _flags="-c ${_cd} -d ${PORTSDIR} -o ${_od} --delbuild"
6275        if [ -n "${PBI_AB_SSLPRIVKEY}" ] ; then
6276                _flags="${_flags} --sign ${PBI_AB_SSLPRIVKEY}"
6277        fi
6278
6279        # Check if we need to enable tmpfs
6280        if [ "$PBI_AB_TMPFS" = "YES" ] ; then
6281                if [ -z "${PBI_AB_NOTMPFS}" -o "$PBI_AB_NOTMPFS" != "YES" ] ; then
6282                        _flags="${_flags} --tmpfs"
6283                fi
6284        fi
6285
6286        # Check if we need to enable pkgbuilding
6287        if [ "$PBI_AB_PKGBUILD" = "YES" -a -z "$PBI_AB_NOPKGBUILD"  ] ; then
6288                _flags="${_flags} --pkgbuild"
6289        fi
6290
6291        # Are we doing 32bit builds?
6292        if [ "$PBI_AB32" = "YES" ] ; then _flags="${_flags} -32"; fi
6293
6294        # Check if this port can be built on this architecture
6295        check_port_compat_arch "${PORTSDIR}/${_mp}"
6296        if [ $? -ne 0 ] ; then
6297           if [ "$PBI_ABFB32" = "YES" -a "$have32" = "true" ] ; then
6298              _flags="${_flags} -32"
6299           fi
6300        fi
6301
6302        get_pbi_progversion
6303
6304        #echo "Starting build of ${_mp} - ${_pv}"
6305        #echo "pbi_makeport ${_flags} ${_mp}"
6306
6307        if [ ! -d "${_od}" ] ; then mkdir -p "${_od}" ; fi
6308
6309        # Save the autobuild hash key
6310        echo "$_abkey" > ${_od}/.abkey
6311       
6312        # Save the build key for this PBI
6313        if [ -n "$_bk" ] ; then
6314                echo "$_bk" > "${_od}/pbi-buildkey"
6315        else
6316                echo "__NONE__" > "${_od}/pbi-buildkey"
6317        fi
6318
6319        # Clean old log files
6320        if [ -e "${_od}/build.log" ] ; then
6321                rm "${_od}/build.log"
6322        fi
6323        if [ -e "${_od}/build.log.bz2" ] ; then
6324                rm "${_od}/build.log.bz2"
6325        fi
6326
6327        # Move old PBIs to archived folder
6328        oldVersion=`cat ${_od}/pbi-version 2>/dev/null`
6329        if [ "$oldVersion" != "$PBI_PROGVERSION" ]; then
6330                #echo "Archiving old PBIs..."
6331                archive_old_pbis "${_od}" "$PBI_AB_ARCHIVENUM"
6332        fi
6333
6334        # Set some variables we can call in pbi_makeport
6335        PBI_AB_TMPDIR="${PBI_TMPDIR}"
6336        PBI_AB_BUILDER="$eBuilder"
6337        export PBI_AB_TMPDIR PBI_AB_BUILDER
6338
6339        # Add some header info to log file
6340        echo "Starting build: `date`" >${_od}/build.log
6341        echo "Build Command:" >>${_od}/build.log
6342        echo "pbi_makeport ${_flags} ${_mp}" >>${_od}/build.log
6343        echo "------------------------------------------------------" >>${_od}/build.log
6344       
6345        echo "${_od}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.od"
6346        echo "${_mp}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.mp"
6347        echo "${_cd}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.cd"
6348        echo "${PBI_PROGVERSION}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.pv"
6349        pbi_makeport ${_flags} ${_mp} >>${_od}/build.log 2>>${_od}/build.log &
6350        echo "$!" > ${PBI_TMPDIR}/${eBuilder}.pid
6351
6352}
6353
6354ab_post_build() 
6355{
6356        local build=$1
6357        _od="`cat ${PBI_TMPDIR}/${build}.od`"
6358        _mp="`cat ${PBI_TMPDIR}/${build}.mp`"
6359        _cd="`cat ${PBI_TMPDIR}/${build}.cd`"
6360        _pv="`cat ${PBI_TMPDIR}/${build}.pv`"
6361        sleep 1
6362
6363        if [ -e "${PBI_TMPDIR}/${build}.result" -a "`cat ${PBI_TMPDIR}/${build}.result`" = "0" ] ; then
6364
6365                echo "===> Build of ${_mp} was successfull! [$build]"
6366
6367                echo "$_pv" > "${_od}/pbi-version"
6368                echo "OK" > "${_od}/pbi-result"
6369
6370                # Save the mdate file
6371                date "+%Y%m%d %H%M%S" >${_od}/pbi-mdate
6372
6373                if [ -n "${PBI_AB_HELPS}" ] ; then
6374                        ${PBI_AB_HELPS} "OK" "${_od}"
6375                fi
6376
6377                # Copy over a description file
6378                if [ -e "${PORTSDIR}/${_mp}/pkg-descr" ] ; then
6379                        cp "${PORTSDIR}/${_mp}/pkg-descr" "${_od}/pbi-descr"
6380                fi
6381                if [ -e "${PBI_AB_CONFDIR}/${_cd}/pbi-descr" ] ; then
6382                        cp "${PBI_AB_CONFDIR}/${_cd}/pbi-descr" "${_od}/pbi-descr"
6383                fi
6384
6385                # Check if we need to rebuild patches
6386                if [ "$PBI_AB_GENPATCH" = "YES" -a -d "${_od}/archived" ] ; then
6387                        echo "===> Generating patches for [$build]"
6388                        gen_pbi_patches "${_od}" "${_od}/archived"
6389                fi
6390
6391                rm "${_od}/build.log.bz2" >/dev/null 2>/dev/null
6392                bzip2 "${_od}/build.log"
6393
6394        else
6395                echo "===> Build of ${_mp} failed! [$build]"
6396