source: src-sh/pbi-manager10/pbi-manager @ a497938

9.2-releasereleng/10.0releng/10.0.1
Last change on this file since a497938 was a497938, checked in by Kris Moore <kris@…>, 5 months ago

Add new maintainer field to pbi metafile

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