source: src-sh/pbi-manager10/pbi-manager @ 4ca5a5e

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

Fix the pbi_metatool for 10.x, use a placeholder PNG image when using
the "syncpbi" option to auto-populate the metafile

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