source: src-sh/pbi-manager10/pbi-manager @ 191425d

9.2-releasereleng/10.0releng/10.0.1releng/10.0.2releng/10.0.3
Last change on this file since 191425d was 191425d, checked in by Kris Moore <kris@…>, 10 months ago

Use the PBI_ICONURL variable in a PBI, if it exists, when updating meta-file

  • Property mode set to 100755
File size: 222.9 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"
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        # Set the icon URL, or make it generic if it doesn't exist
2065        if [ -n "$PBI_ICONURL" ] ; then
2066                mFlags="$mFlags -i \"${PBI_ICONURL}\""
2067        else
2068                mFlags="$mFlags -i \"http://images.pbidir.com/progicons/generic.png\""
2069        fi
2070
2071        # Add the app
2072        echo "${0} ${mFlags} -n \"${PBI_PROGNAME}\" `realpath ${PBI_MT_METAFILE}`" >/tmp/.pbiCmd.$$
2073        chmod 755 /tmp/.pbiCmd.$$
2074        /tmp/.pbiCmd.$$
2075        err=$?
2076        rm /tmp/.pbiCmd.$$
2077        exit $err
2078}
2079
2080# Init the metatool
2081pbi_mt_init() {
2082        parse_mt_pbi_cmdline "$@"
2083        case $PBI_MT_MODE in
2084            SYNCPBI) do_pbi_mt_syncpbi ;;
2085                ADD) if [ "$PBI_MT_TYPE" = "CAT" ] ; then
2086                        do_pbi_mt_add_cat
2087                     else
2088                        do_pbi_mt_add_app
2089                     fi ;;
2090                REM) if [ "$PBI_MT_TYPE" = "CAT" ] ; then
2091                        do_pbi_mt_rem_cat "${PBI_MT_REMNAME}" "${PBI_MT_METAFILE}"
2092                     else
2093                        do_pbi_mt_rem_app "${PBI_MT_REMNAME}" "${PBI_MT_METAFILE}"
2094                     fi ;;
2095                  *) ;;
2096        esac
2097}
2098
2099do_pbi_mt_add_cat() {
2100        init_tmpdir
2101
2102        # Remove any duplicate name
2103        do_pbi_mt_rem_cat "${PBI_MT_ADDNAME}" "${PBI_MT_METAFILE}"
2104
2105        cp ${PBI_MT_METAFILE} ${PBI_TMPDIR}/.meta.$$
2106        echo "Cat=${PBI_MT_ADDNAME};${PBI_MT_ADDICON};${PBI_MT_ADDDESC};" \
2107        >> ${PBI_TMPDIR}/.meta.$$
2108        sort ${PBI_TMPDIR}/.meta.$$ > "${PBI_MT_METAFILE}"
2109        rm ${PBI_TMPDIR}/.meta.$$
2110       
2111}
2112
2113do_pbi_mt_add_app() {
2114        init_tmpdir
2115        # Remove any duplicate name
2116        do_pbi_mt_rem_app "${PBI_MT_ADDNAME}" "${PBI_MT_METAFILE}"
2117
2118        local _date=`date '+%s'`
2119
2120        cp ${PBI_MT_METAFILE} ${PBI_TMPDIR}/.meta.$$
2121        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};" \
2122        >> ${PBI_TMPDIR}/.meta.$$
2123        sort ${PBI_TMPDIR}/.meta.$$ > "${PBI_MT_METAFILE}"
2124        rm ${PBI_TMPDIR}/.meta.$$
2125}
2126
2127do_pbi_mt_rem_cat() {
2128        sed -i '' "\|^Cat=${1};|d" "${2}"
2129}
2130
2131do_pbi_mt_rem_app() {
2132        sed -i '' "\|^App=${1};|d" "${2}"
2133}
2134
2135# Init the indextool
2136pbi_it_init() {
2137        parse_it_pbi_cmdline "$@"
2138        case $PBI_IT_MODE in
2139                ADD) do_pbi_it_add ;;
2140                REM) do_pbi_it_rem ;;
2141                  *) ;;
2142        esac
2143}
2144
2145# Remove a target PBI from an index
2146do_pbi_it_rem() {
2147        init_tmpdir
2148        _pbilow="`echo ${PBI_IT_REMNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2149
2150        cat "${PBI_IT_REMINDEX}" | grep -v "^${_pbilow}:${PBI_IT_REMARCH}:${PBI_IT_REMVER}" \
2151                > "${PBI_TMPDIR}/.indextmp"
2152        sort ${PBI_TMPDIR}/.indextmp > "${PBI_IT_REMINDEX}"
2153
2154        rm_tmpdir
2155}
2156
2157# Add a new PBI to the specified INDEX file
2158do_pbi_it_add() {
2159        init_tmpdir
2160
2161        # First load values from the target PBI
2162        PBI_FILENAME="$PBI_IT_ADDFILE"
2163        load_info_from_header
2164
2165        # Get the name in lower-case
2166        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2167       
2168        # Prune any old copies of this app from the index
2169        prune_from_index "$_pbilow" "$PBI_APPARCH"
2170       
2171        # Prune any old copies of this app from the index
2172        mark_current_active_index "$_pbilow" "$PBI_APPARCH"
2173
2174        # Add the new index entry
2175        add_to_index
2176        rm_tmpdir
2177}
2178
2179# Mark any current versions of this PBI as active in the index
2180mark_current_active_index() {
2181
2182        while read iLine
2183        do
2184                echo "$iLine" | grep "^${1}:${2}:" >/dev/null 2>/dev/null
2185                if [ "$?" != "0" ] ; then
2186                        echo "$iLine" >> ${PBI_TMPDIR}/.indextmp       
2187                        continue
2188                fi
2189                echo "$iLine" | sed 's|:current|:active|' >> ${PBI_TMPDIR}/.indextmp   
2190
2191        done < $PBI_IT_ADDINDEX 
2192        mv "${PBI_TMPDIR}/.indextmp" "${PBI_IT_ADDINDEX}"
2193}
2194
2195# Add the specified PBI to the index
2196add_to_index() {
2197        mv "${PBI_IT_ADDINDEX}" "${PBI_TMPDIR}/.indextmp"
2198        local _date=`date '+%s'`
2199        local _sha256=`sha256 -q ${PBI_FILENAME}`
2200        local _psize=`du -k ${PBI_FILENAME} | cut -f 1`
2201        echo "${_pbilow}:${PBI_APPARCH}:${PBI_PROGVERSION}:${_sha256}:${PBI_PROGMDATE}:${PBI_IT_ADDURL}:$_date:${PBI_IT_ADDBPVERS}:current:${_psize}:" >>"${PBI_TMPDIR}/.indextmp"
2202        sort ${PBI_TMPDIR}/.indextmp > "${PBI_IT_ADDINDEX}"
2203}
2204
2205
2206# Remove a set number of PBIs from the index
2207prune_from_index() {
2208        if [ -z "$PBI_IT_ADDKEEP" ]; then return ; fi
2209
2210        local found="0"
2211        local added="0"
2212        while read iLine
2213        do
2214                echo "$iLine" | grep "^${1}:${2}:" >/dev/null 2>/dev/null
2215                if [ "$?" != "0" ] ; then
2216                        # Ready to add back the saved lines
2217                        if [ $found -ne 0 ] ; then
2218                                while read fLine
2219                                do
2220                                  if [ $found -le $PBI_IT_ADDKEEP ] ; then
2221                                     echo "$fLine" >> ${PBI_TMPDIR}/.indextmp   
2222                                  fi
2223                                  found=`expr $found - 1`
2224                                done < ${PBI_TMPDIR}/.foundtmp
2225                        fi
2226                        echo "$iLine" >> ${PBI_TMPDIR}/.indextmp       
2227                        continue
2228                fi
2229                found=`expr $found + 1`
2230                echo "$iLine" >> ${PBI_TMPDIR}/.foundtmp       
2231        done < $PBI_IT_ADDINDEX 
2232        mv "${PBI_TMPDIR}/.indextmp" "${PBI_IT_ADDINDEX}"
2233}
2234
2235# Add a new repo to the db
2236pbi_browser_init() {
2237        parse_browse_pbi_cmdline "$@"
2238        init_tmpdir
2239
2240        # Check if we are doing a category listing, the default if no options
2241        if [ "$PBI_BROWSE_LISTCATS" = "YES" -o -z "${PBI_BROWSE_LISTALLPBI}${PBI_BROWSE_CAT}${PBI_BROWSE_SEARCH}" ] ; then
2242                pbi_browse_listcats
2243        else
2244                pbi_browse_listpbi
2245        fi
2246
2247}
2248
2249# List PBIs from a repo
2250pbi_browse_listpbi() {
2251        _rArch=`uname -m`
2252
2253        # Figure out which type of display we are doing
2254        if [ -n "$PBI_BROWSE_LISTALLPBI" ] ; then
2255                echo "Using RepoID: $PBI_BROWSE_RID"
2256                echo "Listing all available PBIs"
2257                grep -i -e "^App=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2258        elif [ -n "$PBI_BROWSE_CAT" ] ; then
2259                echo "Using RepoID: $PBI_BROWSE_RID"
2260                echo "Available PBIs for Category: $PBI_BROWSE_CAT"
2261                grep -i -e "^App=" -i -e ";${PBI_BROWSE_CAT};" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2262        elif [ -n "$PBI_BROWSE_SEARCH" ] ; then
2263                echo "Using RepoID: $PBI_BROWSE_RID"
2264                echo "Searching for: $PBI_BROWSE_SEARCH"
2265                grep -i -e "^App=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2266        else
2267                exit_err "No valid search variable set!"
2268        fi
2269
2270        while read app
2271        do
2272                line=`echo $app | sed 's|^App=||g'`
2273                catCheck=`echo $line | cut -d ';' -f 2 2>/dev/null`
2274                aName=`echo $line | cut -d ';' -f 1 2>/dev/null`
2275
2276                # Make sure this is from the correct category
2277                if [ -n "$PBI_BROWSE_CAT" ] ; then
2278                        _cCheck=`echo $catCheck | tr '[:lower:]' '[:upper:]'`
2279                        _cCheck2=`echo $PBI_BROWSE_CAT | tr '[:lower:]' '[:upper:]'`
2280                        if [ "$_cCheck" != "$_cCheck2" ]; then
2281                        continue
2282                        fi
2283                fi
2284
2285                # Set the displayed arch type
2286                aArch="$_rArch"
2287
2288                # Make sure this application has an associated PBI available
2289                check_pbi_update "$aName" "nodisplay" \
2290                 "$aName" "current" \
2291                 "$FBSDMAJOR" "$_rArch" "${PBI_BROWSE_RID}"
2292                if [ "$?" != "0" ] ; then
2293                        # On amd64, see if 32bit version exists
2294                        if [ "$_rArch" = "amd64" ] ; then
2295                                check_pbi_update "$aName" "nodisplay" \
2296                                "$aName" "current" \
2297                                "$FBSDMAJOR" "i386" "${PBI_BROWSE_RID}"
2298                                if [ "$?" != "0" ] ; then
2299                                        continue
2300                                else
2301                                        # Found a 32bit version of the app
2302                                        aArch="i386"
2303                                fi
2304                        else
2305                                # Not on amd64, continue on
2306                                continue
2307                        fi
2308                fi
2309
2310                aIcon=`echo $line | cut -d ';' -f 3`
2311                aAuthor=`echo $line | cut -d ';' -f 4`
2312                aUrl=`echo $line | cut -d ';' -f 5`
2313                aLic=`echo $line | cut -d ';' -f 6`
2314                aType=`echo $line | cut -d ';' -f 7`
2315                aKeywords=`echo $line | cut -d ';' -f 8`
2316                aDesc=`echo $line | cut -d ';' -f 9`
2317                aRoot=`echo $line | cut -d ';' -f 10`
2318
2319                # Check for a translation to the description
2320                get_meta_trans "App" "$cName" "${PBI_BROWSE_METAFILE}"
2321                if [ -n "$MTRANS" ] ; then
2322                        aDesc="$MTRANS"
2323                fi
2324
2325                # Search the description / keywords
2326                if [ -n "$PBI_BROWSE_SEARCH" ] ; then
2327                        echo "$aName,$aDesc,$aKeywords,$MTRANS" | grep -i "$PBI_BROWSE_SEARCH" >/dev/null 2>/dev/null
2328                        if [ "$?" != "0" ]; then continue ; fi
2329                fi
2330
2331                # Get the local icon file
2332                ext=`echo $aIcon | sed 's/.*\.//'`
2333                aIcon="${PBI_DBICONDIR}/${PBI_BROWSE_REPOMD5}-${aName}.${ext}"
2334
2335                echo "------------------------------------"
2336                echo "Application: $aName"
2337                echo "Version: $PBI_UPNVER"
2338                if [ -n "$PBI_UPSIZE" ] ; then
2339                        echo "Size: $PBI_UPSIZE"
2340                fi
2341                if [ -n "$PBI_BROWSE_LISTALLPBI" ] ; then
2342                        echo "Category: $catCheck"
2343                fi
2344                echo "Created: `echo $PBI_UPMDATE`"
2345                if [ "$aRoot" = "YES" ] ; then
2346                        echo "RootInstall: YES"
2347                else
2348                        echo "RootInstall: NO"
2349                fi
2350                echo "Arch: $aArch"
2351                echo "Author: $aAuthor"
2352                echo "URL: $aUrl"
2353                echo "License: $aLic"
2354                echo "Type: $aType"
2355                echo "Keywords: $aKeywords"
2356                echo "Icon: $aIcon"
2357                echo "Description: $aDesc"
2358                echo ""
2359                if [ "$aRoot" = "YES" ] ; then
2360                        echo "To install this PBI (As Root):"
2361                else
2362                        echo "To install this PBI:"
2363                fi
2364                echo "# pbi_add --rArch $aArch --repo $PBI_BROWSE_RID -r $aName"
2365                echo ""
2366
2367               
2368        done < ${PBI_TMPDIR}/.meta.$$
2369
2370}
2371
2372# List available categories for this repository
2373pbi_browse_listcats() {
2374
2375        echo "Using RepoID: $PBI_BROWSE_RID"
2376        echo "Available Categories:"
2377        grep "^Cat=" $PBI_BROWSE_METAFILE > ${PBI_TMPDIR}/.meta.$$
2378        while read cat
2379        do
2380                line=`echo $cat | sed 's|^Cat=||g'`
2381                cName=`echo $line | cut -d ';' -f 1`
2382                cIcon=`echo $line | cut -d ';' -f 2`
2383                cDesc=`echo $line | cut -d ';' -f 3`
2384               
2385                # Check for a translation to the description
2386                get_meta_trans "Cat" "$cName" "${PBI_BROWSE_METAFILE}"
2387                if [ -n "$MTRANS" ] ; then
2388                        cDesc="$MTRANS"
2389                fi
2390
2391                # Get the local icon file
2392                ext=`echo $cIcon | sed 's/.*\.//'`
2393                cIcon="${PBI_DBICONDIR}/${PBI_BROWSE_REPOMD5}-${cName}.${ext}"
2394
2395                echo "------------------------------------"
2396                echo "Category: $cName"
2397                echo "Icon: $cIcon"
2398                echo "Description: $cDesc"
2399                echo ""
2400
2401        done < ${PBI_TMPDIR}/.meta.$$
2402
2403        echo "To view available PBIs for a particular category:"
2404        echo " % pbi_browser -c <category> <repoid>"
2405}
2406
2407# Function to check if we have a translated description
2408get_meta_trans() {
2409        local tag="$1"
2410        local name="$2"
2411        local metaFile="$3"
2412
2413        # Check if we have a translation to overwrite with
2414        MTRANS=""
2415        if [ -z "$LANG" ] ; then return; fi
2416
2417        lCheck="`echo $LANG | cut -d '_' -f 1` `echo $LANG | cut -d '.' -f 1`"
2418        for l in $lCheck
2419        do
2420                catTrans=`grep "^${tag}\[$l\]=${name}" ${metaFile}`     
2421                if [ -n "$catTrans" ] ; then
2422                        MTRANS=`echo $catTrans | cut -d ";" -f 2`
2423                        return
2424                fi
2425        done
2426}
2427
2428# List repos in the db
2429pbi_listrepo_init() {
2430        require_root_or_group
2431        parse_listrepo_pbi_cmdline "$@"
2432
2433        # List the repos
2434        if [ -z "$PBI_LISTREPO_ID" ] ; then
2435                list_all_pbi_repo
2436        else
2437                if [ -n "${PBI_LISTREPO_UP}" ]; then
2438                        require_root
2439                        move_repo_up "${PBI_LISTREPO_ID}" 
2440                        list_all_pbi_repo
2441                elif [ -n "${PBI_LISTREPO_DOWN}" ] ; then
2442                        require_root
2443                        move_repo_down "${PBI_LISTREPO_ID}"
2444                        list_all_pbi_repo
2445                elif [ -n "${PBI_LISTREPO_MIRROR}" ] ; then
2446                        require_root
2447                        change_repo_mirror "${PBI_LISTREPO_ID}"
2448                        listrepo_details "${PBI_LISTREPO_ID}"
2449                else
2450                        listrepo_details "${PBI_LISTREPO_ID}"
2451                fi
2452        fi
2453}
2454
2455# Function to change a specific repos mirror URL
2456change_repo_mirror() {
2457        local _rMd5=`ls ${PBI_DBREPODIR}/${1}.* | cut -d '.' -f 2`
2458        echo "$PBI_LISTREPO_MIRROR" | sed 's|,|\
2459|g' > "${PBI_DBMIRRORDIR}/${_rMd5}"
2460}
2461
2462# Move a repo down in priority
2463move_repo_down() {
2464        _rFile=`ls ${PBI_DBREPODIR}/${1}.*`
2465        _uNum=`expr ${1} + 1`
2466
2467        case `echo ${_uNum} | wc -m | tr -d ' '` in
2468                2) _uNum="00${_uNum}" ;;
2469                3) _uNum="0${_uNum}" ;;
2470                *) ;;
2471        esac
2472        _uFile=`ls ${PBI_DBREPODIR}/${_uNum}.* 2>/dev/null`
2473        if [ -z "$_uFile" ] ; then exit_err "This repo is already at the lowest priority!" ; fi
2474
2475        _umd5=`echo $_uFile | cut -d '.' -f 2`
2476        mv "${_uFile}" "${PBI_DBREPODIR}/${1}.${_umd5}"
2477        _rmd5=`echo $_rFile | cut -d '.' -f 2`
2478        mv "${_rFile}" "${PBI_DBREPODIR}/${_uNum}.${_rmd5}"
2479}
2480
2481# Move a repo up in priority
2482move_repo_up() {
2483        _rFile=`ls ${PBI_DBREPODIR}/${1}.*`
2484        _uNum=`expr ${1} - 1`
2485
2486        case `echo ${_uNum} | wc -m | tr -d ' '` in
2487                2) _uNum="00${_uNum}" ;;
2488                3) _uNum="0${_uNum}" ;;
2489                *) ;;
2490        esac
2491        _uFile=`ls ${PBI_DBREPODIR}/${_uNum}.* 2>/dev/null`
2492        if [ -z "$_uFile" ] ; then exit_err "This repo is already at the highest priority!" ; fi
2493
2494        _umd5=`echo $_uFile | cut -d '.' -f 2`
2495        mv "${_uFile}" "${PBI_DBREPODIR}/${1}.${_umd5}"
2496        _rmd5=`echo $_rFile | cut -d '.' -f 2`
2497        mv "${_rFile}" "${PBI_DBREPODIR}/${_uNum}.${_rmd5}"
2498}
2499
2500# List all PBI repos
2501listrepo_details() {
2502        _rFile=`ls ${PBI_DBREPODIR}/${1}.*`
2503        _md5=`ls ${PBI_DBREPODIR}/${1}.* | cut -d '.' -f 2`
2504        _desc=`cat ${_rFile} | grep "Desc: " | sed "s|Desc: ||g"` 
2505        _url=`cat ${_rFile} | grep "URL: " | sed "s|URL: ||g"` 
2506        _mirror=`cat ${PBI_DBMIRRORDIR}/$_md5` 
2507        echo "Repo ID: ${1}"
2508        echo "Description: ${_desc}"
2509        echo "IndexURL: ${_url}"
2510        echo "MD5: ${_md5}"
2511        echo "LocalMeta: `ls ${PBI_DBINDEXDIR}/${_md5}*meta 2>/dev/null`"
2512        echo "LocalIndex: `ls ${PBI_DBINDEXDIR}/${_md5}*index 2>/dev/null`"
2513        echo "Mirror(s):"
2514        echo "$_mirror"
2515}
2516
2517# List all PBI repos
2518list_all_pbi_repo() {
2519        echo "[ID]      [Description]"
2520        echo "-----------------------------------------------------"
2521        for repo in `ls ${PBI_DBREPODIR} | sort `
2522        do
2523                _id=`echo $repo | cut -d '.' -f 1`
2524                _desc=`cat ${PBI_DBREPODIR}/${repo} | grep "Desc: " | sed "s|Desc: ||g"` 
2525                echo "${_id}    ${_desc}"
2526        done
2527}
2528
2529# Start the patch process
2530pbi_patch_init() {
2531        require_root_or_group
2532        init_tmpdir
2533        parse_patch_pbi_cmdline "$@"
2534
2535        # Check if we are only displaying information
2536        check_pbi_info_display
2537        check_pbi_gui_display
2538        check_pbi_scripts_display
2539        check_pbi_license_display
2540        if [ "$PBI_ADD_GUIDISPLAY" = "YES" -o "$PBI_ADD_INFODISPLAY" = "YES" -o "$PBI_CHECKSCRIPTS" = "YES" -o "${PBI_ADD_LICDISPLAY}" = "YES" -o "${PBI_ADD_METADISPLAY}" = "YES" ] 
2541        then
2542                exit_trap
2543        fi
2544
2545        # Try to apply this patch file
2546        do_pbi_patch
2547}
2548
2549# Start the PBI patch process
2550do_pbi_patch() {
2551       
2552        # Verify the target PBI is installed
2553        verify_pbi_update_target
2554
2555        pbi_verify_signatures
2556        pbi_verify_archivesum
2557       
2558        # Extract the archive contents
2559        mk_pbi_extract_dir
2560        pbi_extract_archive
2561
2562        set_patch_wrkdir
2563
2564        init_tmpdir
2565
2566        # Run the uninstall script
2567        if [ -e "${PBI_PATCHWRKDIR}/.sbin/.pbi-uninstall.sh" ] ; then
2568                echo "Removing old xdg data..."
2569                sh "${PBI_PATCHWRKDIR}/.sbin/.pbi-uninstall.sh" >/dev/null 2>/dev/null
2570        fi
2571
2572        # Remove old files from the installed PBI
2573        patch_rm_old_files
2574       
2575        # Extract the new files
2576        patch_extract_new_files
2577
2578        # Merge in the bsdiffs
2579        patch_merge_bsdiffs
2580
2581        # Make sure we have good permissions on this PBI
2582        patch_apply_chmod
2583
2584        # Run the install script
2585        if [ -e "${PBI_PATCHWRKDIR}/.sbin/.pbi-install.sh" ] ; then
2586                echo "Adding new xdg data..."
2587                sh "${PBI_PATCHWRKDIR}/.sbin/.pbi-install.sh"   >/dev/null 2>/dev/null
2588        fi
2589
2590        # If running as user, add bin path-links
2591        if [ "`id -u`" != "0" ] ; then add_app_path_links "${PBI_PATCHWRKDIR}" ; fi
2592
2593        # Update the registered version of the PBI
2594        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2595        oldDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHTARGET}-${PBI_APPARCH}"
2596        newDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHVERSION}-${PBI_APPARCH}"
2597        mv "$oldDir" "$newDir"
2598        rm ${newDir}/*.sha1 >/dev/null 2>/dev/null
2599
2600        # Register the app
2601        pbi_add_register_app   
2602
2603        # Check if we need to run a post-install.sh script again
2604        if [ -e "${newDir}/${MOD_POSTINS}" ] ; then
2605          export_script_vars
2606          sh "${newDir}/${MOD_POSTINS}"
2607        fi
2608
2609        # Cleanup after our selves
2610        if [ -d "$PBI_EXTRACTDIR" ] ; then
2611                echo "Cleaning up..."
2612                rm -rf "$PBI_EXTRACTDIR"
2613        fi
2614
2615        # Update the hashdir
2616        add_hashdir_trigger
2617
2618        # Mark the hash-dir as dirty as well
2619        make_hashdir_dirty
2620
2621        echo "Finished patching ${_pbilow}: $PBI_PATCHTARGET -> $PBI_PATCHVERSION"
2622}
2623
2624# Mark the hashdir as dirty
2625make_hashdir_dirty() {
2626        date "+%s" > "${PBI_DBDIRTYFILE}"
2627}
2628
2629# Do any chmod stuff after patching
2630patch_apply_chmod()
2631{
2632        if [ ! -e "${PBI_EXTRACTDIR}/PBI-permList" ] ; then return; fi
2633
2634        cuDir=`pwd`
2635
2636        cd "${PBI_PATCHWRKDIR}"
2637        echo "Applying updated permissions..."
2638        while read chLine
2639        do
2640                $chLine >/dev/null 2>/dev/null
2641        done < "${PBI_EXTRACTDIR}/PBI-permList"
2642
2643        cd "$cuDir"
2644}
2645
2646# Function which does the merge of bsdiff files
2647patch_merge_bsdiffs()
2648{
2649        echo "Applying patch data..."
2650        find ${PBI_EXTRACTDIR} | grep '.bsdiff' | sed "s|${PBI_EXTRACTDIR}/||g" > ${PBI_TMPDIR}/.PBI.bspatch.$$
2651
2652        while read pLine
2653        do
2654                if [ -z "$pLine" ] ; then continue; fi
2655                _tFile="`echo $pLine | sed 's|.bsdiff$||g'`"
2656               
2657                if [ ! -e "${PBI_EXTRACTDIR}/${_tFile}.sha256" ] ; then
2658                        exit_err "Missing checksums for \"${_tFile}\" this patch is corrupt"
2659                fi
2660
2661                if [ ! -e "${PBI_PATCHWRKDIR}/${_tFile}" ] ; then
2662                        echo "Warning: Missing target file for patching: $_tFile"
2663                        continue
2664                fi
2665               
2666                # Make sure we really are trying to patch the same file
2667                sha1="`sha256 -q ${PBI_PATCHWRKDIR}/${_tFile}`"
2668                sha2="`cat ${PBI_EXTRACTDIR}/${_tFile}.sha256`"
2669                if [ "$sha1" != "$sha2" ] ; then
2670                        exit_err "Error: Checksum failed for ${_tFile}, you may need to re-install this PBI."
2671                fi
2672
2673                _fPerm=`stat -f %Op "${PBI_PATCHWRKDIR}/${_tFile}"  | cut -c 3-6`
2674
2675                # See if we have a hard-link to take care of first
2676                get_hard_link_count "${PBI_PATCHWRKDIR}/${_tFile}"
2677                if [ "$HLINKS" != "1" ] ; then
2678                        mv "${PBI_PATCHWRKDIR}/${_tFile}" "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2679                        cp "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$" "${PBI_PATCHWRKDIR}/${_tFile}"
2680                        rm -f "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2681                fi
2682               
2683                # Now do the patching
2684                #echo "Patching $_tFile"       
2685                mv "${PBI_PATCHWRKDIR}/${_tFile}" "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2686                bspatch "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$" \
2687                        "${PBI_PATCHWRKDIR}/${_tFile}" \
2688                        "${PBI_EXTRACTDIR}/$pLine" >/dev/null 2>/dev/null
2689                if [ "$?" != "0" ] ; then
2690                        echo "Warning: Failed to apply patch to \"$_tFile\""
2691                fi
2692
2693                # Re-apply the same permissions to the new file
2694                chmod $_fPerm "${PBI_PATCHWRKDIR}/${_tFile}"
2695
2696                # Remove the old file
2697                rm "${PBI_PATCHWRKDIR}/${_tFile}.patch.$$"
2698
2699        done < "${PBI_TMPDIR}/.PBI.bspatch.$$"
2700
2701        rm "${PBI_TMPDIR}/.PBI.bspatch.$$"
2702}
2703
2704# Function which does the new file extraction for this PBI
2705patch_extract_new_files()
2706{
2707        if [ ! -e "${PBI_EXTRACTDIR}/PBI-newFiles.tar" ] ; then return; fi
2708        echo "Installing new files..."
2709        tar xvf "${PBI_EXTRACTDIR}/PBI-newFiles.tar" -C "${PBI_PATCHWRKDIR}" >/dev/null 2>/dev/null
2710        if [ "$?" != "0" ] ; then
2711                echo "Warning: Error during new file extraction, PBI may not function correctly."
2712        fi
2713}
2714
2715# Function which removes files that no longer exist in this updated PBI
2716patch_rm_old_files()
2717{
2718        if [ ! -e "${PBI_EXTRACTDIR}/PBI-rmList" ] ; then return; fi
2719       
2720        echo "Removing old files..."
2721        while read rmLine
2722        do
2723                if [ -z "$rmLine" ] ; then continue ; fi
2724                if [ ! -e "${PBI_PATCHWRKDIR}/$rmLine" ] ; then
2725                        continue
2726                fi
2727
2728                rm -rf "${PBI_PATCHWRKDIR}/${rmLine}"
2729        done < "${PBI_EXTRACTDIR}/PBI-rmList"
2730
2731}
2732
2733# Sets the workdir of the target PBI we are patching
2734set_patch_wrkdir()
2735{
2736        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2737        oldDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHTARGET}-${PBI_APPARCH}"
2738
2739        if [ ! -e "${oldDir}/pbi_defaultpath" ] ; then
2740                exit_err "Can not fild default path for \"$PBI_PROGNAME\"!"
2741        fi
2742
2743        PBI_PATCHWRKDIR="`cat ${oldDir}/pbi_defaultpath`"
2744
2745        if [ ! -d "$PBI_PATCHWRKDIR" ] ; then
2746                exit_err "Path for \"$PBI_PROGNAME\" does not exist!"
2747        fi
2748}
2749
2750# Confirms that the target PBI for this patch is installed
2751# Exits if not and we are not doing a extract only
2752verify_pbi_update_target()
2753{
2754        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then return ; fi
2755       
2756        # Make sure the target PBI is installed
2757        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
2758        oldDir="${PBI_DBAPPDIR}/${_pbilow}-${PBI_PATCHTARGET}-${PBI_APPARCH}"
2759
2760        if [ ! -e "${oldDir}" ] ; then
2761                exit_err "\"${_pbilow}\" does not appear to be installed!"
2762        fi
2763
2764        # Check the arch type
2765        if [ "`cat ${oldDir}/pbi_arch`" != "$PBI_APPARCH" ] ; then
2766                exit_err "Installed \"${PBI_PROGNAME}\" is not compiled for $PBI_APPARCH"
2767        fi
2768
2769        # Check the taret version
2770        if [ "`cat ${oldDir}/pbi_version`" != "$PBI_PATCHTARGET" ] ; then
2771                exit_err "\"${_pbilow}\" patch is for \"$PBI_PROGVERSION\" only!"
2772        fi
2773
2774        # Check the fbsd version
2775        _pFbsdVer="`cat ${oldDir}/pbi_fbsdver | cut -c 1`"
2776        _sFbsdVer="`echo $PBI_FBSDVER | cut -c 1`"
2777        if [ "$_pFbsdVer" != "$_sFbsdVer" ] ; then
2778                exit_err "\"${_pbilow}\" patch is for FreeBSD ${_sFbsdVer}.X only!"
2779        fi
2780
2781        # Check the mdate of the pbi
2782        _pMDate="`cat ${oldDir}/pbi_mdate`"
2783        _sMDate="$PBI_PATCHMDATE"
2784        if [ "$_pMDate" != "$_sMDate" ] ; then
2785                exit_err "\"${_pbilow}\" patch is for the $PBI_PATCHMDATE build!"
2786        fi
2787}
2788
2789# Start the pbi_add process
2790pbi_add_init() {
2791        init_tmpdir
2792        parse_add_pbi_cmdline "$@"
2793
2794
2795        # Check if we are only displaying information
2796        check_pbi_info_display
2797        check_pbi_gui_display
2798        check_pbi_scripts_display
2799        check_pbi_license_display
2800        check_pbi_meta_display
2801        if [ "$PBI_ADD_GUIDISPLAY" = "YES" -o "$PBI_ADD_INFODISPLAY" = "YES" -o "$PBI_CHECKSCRIPTS" = "YES" -o "${PBI_ADD_LICDISPLAY}" = "YES" -o "${PBI_ADD_METADISPLAY}" = "YES" ] 
2802        then
2803                clean_remote_dl
2804                exit_trap
2805        fi
2806
2807        require_root_or_group
2808
2809        # If this app can only be installed as root
2810        if [ "$PBI_REQUIRESROOT" = "YES" ] ; then require_root ; fi
2811
2812        check_agree_lic
2813        check_existing_pbi
2814        do_pbi_add
2815}
2816
2817# Check if this PBI exists and exit if so
2818check_existing_pbi() {
2819        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then return 0; fi
2820        get_dbdir
2821        dir="${APPDBDIR}"
2822
2823        # See if this PBI is already installed
2824        if [ -d "$dir" ]; then
2825                get_username_from_file "${APPDBDIR}/pbi_name"
2826                if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
2827                        exit_err "Permission denied to modify PBI installed by: $FILEUSER"     
2828                fi
2829
2830                if [ "${PBI_FORCEADD}" = "YES" ] ; then return 0; fi
2831                exit_err "${PBI_PROGNAME} ${PBI_PROGVERSION} is already installed! Use -f to force installation."
2832        fi
2833
2834        if [ -e "${PBI_PROGDIRPATH}" ]; then
2835                get_username_from_file "${PBI_PROGDIRPATH}"
2836                if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
2837                        exit_err "Permission denied to modify PBI installed by: $FILEUSER"     
2838                fi
2839                if [ "${PBI_FORCEADD}" = "YES" ] ; then return 0; fi
2840                exit_err "${PBI_PROGDIRPATH} already exists! Use -f to force installation."
2841        fi
2842
2843
2844}
2845
2846# Check if we have a license to agree to, and if we've provided the flag to do so
2847check_agree_lic() {
2848        open_header_tmp
2849        if [ -f "${PBI_HEADER_TMPDIR}/${PBI_LICENSEFILE}" -a "${PBI_LICAGREE}" = "NO" ] ; then
2850                delete_header_tmp
2851                exit_err "LICENSE must be agreed to (--licagree) before this PBI can be installed."
2852        fi
2853        delete_header_tmp
2854}
2855
2856# See if we need to display pbi meta file
2857check_pbi_meta_display() {
2858        if [ "$PBI_ADD_METADISPLAY" != "YES" ] ; then return 0 ; fi
2859        open_header_tmp
2860       
2861        if [ -f "${PBI_HEADER_TMPDIR}/${PBI_USERMETAFILE}" ] ; then
2862                cat "${PBI_HEADER_TMPDIR}/${PBI_USERMETAFILE}" 
2863        else
2864                echo "`basename $0`: No user metafile included with this PBI"
2865        fi
2866        delete_header_tmp
2867}
2868
2869# See if we need to display pbi license
2870check_pbi_license_display() {
2871        if [ "$PBI_ADD_LICDISPLAY" != "YES" ] ; then return 0 ; fi
2872        open_header_tmp
2873       
2874        if [ -f "${PBI_HEADER_TMPDIR}/${PBI_LICENSEFILE}" ] ; then
2875                echo "LICENSE:"
2876                cat "${PBI_HEADER_TMPDIR}/${PBI_LICENSEFILE}"   
2877        else
2878                echo "`basename $0`: No LICENSE included with this PBI"
2879        fi
2880        delete_header_tmp
2881}
2882
2883# See if we need to display pbi info
2884check_pbi_info_display() {
2885        if [ "$PBI_ADD_INFODISPLAY" != "YES" ] ; then return 0 ; fi
2886        pbi_display_info
2887}
2888
2889# Display pbi information to stdout
2890pbi_display_info() {
2891
2892        tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"
2893        _appname="${tmp}-${PBI_PROGVERSION}-${PBI_APPARCH}"
2894
2895        if [ -z "$PBI_PATCHVERSION" ] ; then
2896                echo "PBI Information for: $_appname"
2897        else
2898                echo "PBP Information for: $_appname"
2899        fi
2900        echo "-----------------------------------------------------"
2901        echo "Name: ${PBI_PROGNAME}"
2902
2903        if [ -n "$PBI_PATCHVERSION" ] ; then
2904                echo "PatchTarget: $PBI_PATCHTARGET"
2905        fi
2906
2907        if [ -n "$PBI_INSTALLED_BY" ] ; then
2908                echo "InstalledBy: $PBI_INSTALLED_BY"
2909        fi
2910
2911        # Does this PBI need root to install?
2912        if [ "$PBI_REQUIRESROOT" = "YES" ] ; then
2913                echo "RootInstall: YES"
2914        else
2915                echo "RootInstall: NO"
2916        fi
2917
2918        echo "Version: ${PBI_PROGVERSION}"
2919        echo "Built: ${PBI_PROGMDATE}"
2920        echo "Prefix: ${PBI_ORIGPROGDIRPATH}"
2921        echo "Author: ${PBI_PROGAUTHOR}"
2922        echo "Website: ${PBI_PROGWEB}"
2923        echo "Arch: ${PBI_APPARCH}"
2924        echo "FbsdVer: ${PBI_FBSDVER}"
2925        echo "CreatorVer: ${PBI_APPCREATEVER}"
2926        echo "ArchiveCount: ${PBI_ARCHIVE_COUNT}"
2927        echo "ArchiveSum: ${PBI_ARCHIVE_CHECKSUM}"
2928        case ${PBI_SIGVALID} in
2929                0) echo "Signature: Verified" ;;
2930               -1) echo "Signature: Not Signed" ;;
2931                1) echo "Signature: Bad" ;;
2932                *) echo "Signature: <Unknown>" ;;
2933        esac
2934
2935        if [ -n "$PBI_LICENSE" ] ; then
2936                echo "License: $PBI_LICENSE"
2937        fi
2938
2939        if [ -n "${PBI_REPO}" ] ; then
2940                local _rDesc="`cat ${PBI_DBREPODIR}/*.${PBI_REPO} | grep "Desc:" | sed 's|Desc: ||g'`"
2941                local _rID="`ls ${PBI_DBREPODIR}/*.${PBI_REPO}`"
2942                _rID=`basename $_rID | cut -d '.' -f 1`
2943                echo "Associated Repo: ${_rID} (${_rDesc})"
2944        fi
2945       
2946        # Check if autoupdate is enable or not
2947        if [ "${PBI_ENABLEAUTOUPDATE}" = "YES" ] ; then
2948                echo "AutoUpdate: YES"
2949        else
2950                echo "AutoUpdate: NO"
2951        fi
2952
2953        # See if we have any XDG stuff
2954        if [ -e "${PBI_ORIGPROGDIRPATH}/.xdg-desktop/install-desktop-icons.sh" ] ; then
2955                echo "DesktopIcons: YES"
2956        fi
2957        if [ -e "${PBI_ORIGPROGDIRPATH}/.xdg-menu/install-menu-icons.sh" ] ; then
2958                echo "MenuIcons: YES"
2959        fi
2960        if [ -e "${PBI_ORIGPROGDIRPATH}/.xdg-mime/install-mime.sh" ] ; then
2961                echo "MimeRegistration: YES"
2962        fi
2963
2964        # If verbose mode, show file contents
2965        if [ "$PBI_VERBOSE" = "YES" ] ; then
2966                if [ -n "${PBI_FILENAME}" -a -e "${PBI_FILENAME}" ] ; then
2967                        pbi_find_archive_header
2968                        echo "TOTALFILES: ${PBI_ARCHIVE_COUNT}"
2969                        echo "Archive Contents:"
2970                        echo "--------------------------------------"
2971                        tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar tvf -
2972                fi
2973        fi
2974}
2975
2976# See if we need to display gui header info
2977check_pbi_gui_display() {
2978        if [ "$PBI_ADD_GUIDISPLAY" != "YES" ] ; then return 0 ; fi
2979        open_header_tmp
2980       
2981        pbi_display_gui "$PBI_HEADER_TMPDIR" "COPY"
2982
2983        delete_header_tmp
2984
2985}
2986
2987# Display location of PBI graphics
2988pbi_display_gui() {
2989        dir="$1"
2990        copy="$2"
2991        if [ -e "${dir}/top-banner.png" ] ; then
2992                if [ "$copy" = "COPY" ] ; then
2993                        pbi_guitop="/tmp/.PBI-top.$$.png"
2994                        cp "${dir}/top-banner.png" "$pbi_guitop"
2995                else
2996                        pbi_guitop="${dir}/top-banner.png"
2997                fi
2998                echo "TopBanner: ${pbi_guitop}"
2999        fi
3000        if [ -e "${dir}/side-banner.png" ] ; then
3001                if [ "$copy" = "COPY" ] ; then
3002                        pbi_guiside="/tmp/.PBI-side.$$.png"
3003                        cp "${dir}/side-banner.png" "$pbi_guiside"
3004                else
3005                        pbi_guiside="${dir}/side-banner.png"
3006                fi
3007                echo "SideBanner: ${pbi_guiside}"
3008        fi
3009
3010        # Try to find an icon
3011        ls ${dir}/pbi_icon.* >/dev/null 2>/dev/null
3012        if [ "$?" = "0" ] ; then
3013                _iconExt=`ls ${dir}/pbi_icon.* | head -n 1 | awk -F . '{print $NF}'`
3014                if [ "$copy" = "COPY" ] ; then
3015                        pbi_guiicon="/tmp/.PBI-icon.$$.${_iconExt}"
3016                        cp "${dir}/pbi_icon.${_iconExt}" "$pbi_guiicon"
3017                else
3018                        pbi_guiicon="${dir}/pbi_icon.${_iconExt}"
3019                fi
3020                echo "Icon: ${pbi_guiicon}"
3021        fi
3022
3023}
3024
3025open_header_tmp() {
3026        init_tmpdir
3027
3028        # If we have a custom extract dir, use it
3029        if [ -z "$1" ] ; then
3030                PBI_HEADER_TMPDIR="${PBI_TMPDIR}/.PBI-header.$$"
3031        else
3032                PBI_HEADER_TMPDIR="${1}/.PBI-header.$$"
3033        fi
3034
3035        if [ -e "${PBI_HEADER_TMPDIR}" ] ; then rm -rf "${PBI_HEADER_TMPDIR}" ; fi
3036        mkdir -p "${PBI_HEADER_TMPDIR}"
3037       
3038        # Extract the header files
3039        tar xvf "${PBI_FILENAME}" -C "${PBI_HEADER_TMPDIR}" >/dev/null 2>/dev/null
3040        if [ "$?" != "0" ] ; then exit_err "Failed to read PBI header! Possible corrupt PBI, or wrong PBI version for this OS." ; fi
3041
3042}
3043
3044delete_header_tmp() {
3045        if [ -z "${PBI_HEADER_TMPDIR}" ] ; then return 0 ; fi
3046        if [ -d "${PBI_HEADER_TMPDIR}" ] ; then rm -rf "${PBI_HEADER_TMPDIR}" ; fi
3047}
3048
3049# Load in all the configuration data from the header
3050load_info_from_header() {
3051        open_header_tmp
3052
3053        # Start loading our variables
3054        load_info_from_dir "${PBI_HEADER_TMPDIR}"
3055
3056        delete_header_tmp
3057}
3058
3059# See if we need to display scripts
3060check_pbi_scripts_display() {
3061        if [ "$PBI_CHECKSCRIPTS" != "YES" ] ; then return 0 ; fi
3062
3063        # Display our scripts
3064        open_header_tmp
3065        if [ -e "${PBI_HEADER_TMPDIR}/${MOD_PREINS}" ] ; then
3066                echo -e "\n${MOD_PREINS}:"
3067                echo "--------------------------------"
3068                cat "${PBI_HEADER_TMPDIR}/${MOD_PREINS}"
3069        fi
3070        if [ -e "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}" ] ; then
3071                echo -e "\n${MOD_POSTINS}:"
3072                echo "--------------------------------"
3073                cat "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}"
3074        fi
3075        if [ -e "${PBI_HEADER_TMPDIR}/${MOD_PREREM}" ] ; then
3076                echo -e "\n${MOD_PREREM}:"
3077                echo "--------------------------------"
3078                cat "${PBI_HEADER_TMPDIR}/${MOD_PREREM}"
3079        fi
3080        delete_header_tmp
3081}
3082
3083# Load pbi information from the specified directory
3084load_info_from_dir() {
3085        REQUIRED_FILES="pbi_defaultpath pbi_name pbi_version pbi_author pbi_web pbi_arch pbi_fbsdver pbi_createver"
3086        for f in $REQUIRED_FILES
3087        do
3088                if [ ! -e "${1}/${f}" ] ; then echo "Warning: Missing file: ${f}" ; fi
3089        done
3090        PBI_APPARCH=""
3091        PBI_APPCREATEVER=""
3092        PBI_ARCHIVE_CHECKSUM=""
3093        PBI_ARCHIVE_COUNT=""
3094        PBI_ENABLEAUTOUPDATE=""
3095        PBI_FBSDVER=""
3096        PBI_ORIGPROGDIRPATH=""
3097        PBI_PATCHMDATE=""
3098        PBI_PATCHVERSION=""
3099        PBI_PATCHTARGET=""
3100        PBI_PROGNAME=""
3101        PBI_PROGVERSION=""
3102        PBI_PROGAUTHOR=""
3103        PBI_PROGMDATE=""
3104        PBI_PROGWEB=""
3105        PBI_REPO=""
3106        PBI_REQUIRESROOT=""
3107        PBI_SIGVALID=""
3108        PBI_DESC=""
3109        PBI_SHORTDESC=""
3110        PBI_MAINTAINER=""
3111        PBI_TAGS=""
3112        PBI_PROGTYPE=""
3113        PBI_CATEGORY=""
3114        PBI_ICONURL=""
3115        PBI_LICENSE=""
3116
3117        PBI_ORIGPROGDIRPATH="`cat ${1}/pbi_defaultpath`"
3118        PBI_PROGNAME="`cat ${1}/pbi_name`"
3119        PBI_PROGVERSION="`cat ${1}/pbi_version`"
3120        PBI_PROGAUTHOR="`cat ${1}/pbi_author`"
3121        PBI_PROGWEB="`cat ${1}/pbi_web 2>/dev/null`"
3122        PBI_PROGMDATE="`cat ${1}/pbi_mdate 2>/dev/null`"
3123        PBI_APPARCH="`cat ${1}/pbi_arch 2>/dev/null`"
3124        PBI_FBSDVER="`cat ${1}/pbi_fbsdver 2>/dev/null`"
3125        PBI_APPCREATEVER="`cat ${1}/pbi_createver 2>/dev/null`"
3126        PBI_ARCHIVE_COUNT="`cat ${1}/pbi_archivecount 2>/dev/null`"
3127        PBI_ARCHIVE_CHECKSUM="`cat ${1}/pbi_archivesum 2>/dev/null`"
3128
3129        if [ -e "${1}/pbi_license" ] ; then
3130                PBI_LICENSE="`cat ${1}/pbi_license`"
3131        fi
3132        if [ -e "${1}/pbi_tags" ] ; then
3133                PBI_TAGS="`cat ${1}/pbi_tags`"
3134        fi
3135        if [ -e "${1}/pbi_type" ] ; then
3136                PBI_PROGTYPE="`cat ${1}/pbi_type`"
3137        fi
3138        if [ -e "${1}/pbi_category" ] ; then
3139                PBI_CATEGORY="`cat ${1}/pbi_category`"
3140        fi
3141        if [ -e "${1}/pbi_iconurl" ] ; then
3142                PBI_ICONURL="`cat ${1}/pbi_iconurl`"
3143        fi
3144        if [ -e "${1}/pbi_desc" ] ; then
3145                PBI_DESC="`cat ${1}/pbi_desc`"
3146        fi
3147        if [ -e "${1}/pbi_shortdesc" ] ; then
3148                PBI_SHORTDESC="`cat ${1}/pbi_shortdesc`"
3149        fi
3150        if [ -e "${1}/pbi_maintainer" ] ; then
3151                PBI_MAINTAINER="`cat ${1}/pbi_maintainer`"
3152        fi
3153
3154        # Check if auto-update is enabled
3155        if [ -e "${1}/autoupdate-enable" ] ; then
3156                PBI_ENABLEAUTOUPDATE="YES"
3157        fi
3158
3159        # Does this PBI need to be installed as root
3160        if [ -e "${1}/pbi_requiresroot" ] ; then
3161                PBI_REQUIRESROOT="YES"
3162        fi
3163       
3164        # Check if this is a patch file
3165        if [ -e "${1}/pbi_patchfile" ] ; then
3166                PBI_PATCHVERSION=`cat ${1}/pbi_patchfile | cut -d ':' -f 2`
3167                PBI_PATCHTARGET=`cat ${1}/pbi_patchfile | cut -d ':' -f 1`
3168        fi
3169       
3170        # Check if this associates with a particular repo
3171        if [ -e "${1}/pbi_repo" ] ; then
3172                PBI_REPO=`cat ${1}/pbi_repo`
3173        fi
3174
3175        # See if this patch is for a particular mdate
3176        if [ -e "${1}/pbi_patchmdate" ] ; then
3177                PBI_PATCHMDATE=`cat ${1}/pbi_patchmdate`
3178        fi
3179
3180        # See if this PBI was signed
3181        if [ -e "${1}/pbi_archivesum.sha1" ] ; then
3182                check_valid_sigs "${1}"
3183                if [ "$?" = "0" ] ; then
3184                        PBI_SIGVALID="0"
3185                else
3186                        PBI_SIGVALID="1"
3187                fi
3188        else
3189                PBI_SIGVALID="-1"
3190        fi
3191}
3192
3193# Start installing the PBI
3194do_pbi_add() {
3195        pbi_verify_signatures
3196        pbi_verify_archivesum
3197
3198        check_preinstall_script
3199
3200        mk_pbi_extract_dir
3201        pbi_extract_archive
3202       
3203        pbi_add_check_uids
3204        pbi_add_check_gids
3205
3206        pbi_add_run_script
3207        check_postinstall_script
3208
3209        pbi_add_register_app
3210
3211        # Be sure to let the pbid know we have a new hash-dir to register
3212        add_hashdir_trigger
3213
3214        # Flush to disk
3215        sleep 0.5
3216        sync
3217
3218        clean_remote_dl
3219}
3220
3221# Check for any GIDs we need to create
3222pbi_add_check_gids() {
3223        if [ ! -e "${PBI_PROGDIRPATH}/${PBI_INS_GROUPSFILE}" ] ; then return ; fi
3224        runUID=`id -u`
3225
3226        while read gidLine
3227        do
3228                gName=`echo $gidLine | cut -d ':' -f 1`
3229                gID=`echo $gidLine | cut -d ':' -f 3`
3230                gUsers=`echo $gidLine | cut -d ':' -f 4`
3231
3232                # Is this group already on the system?
3233                pw groupshow $gName >/dev/null 2>/dev/null
3234                if [ $? -eq 0 ] ; then
3235                        echo "Using existing group: $gName"
3236                else
3237                        # Are we installing as root?
3238                        if [ "$runUID" != "0" ] ; then
3239                                echo "Please create group \"$gName\" manually or re-install PBI as root."
3240                        else
3241                                echo "Adding group: $gName"
3242                                pw groupadd $gName -g $gID;
3243                        fi
3244                fi
3245
3246                if [ -n "$gUsers" ] ; then
3247                        for gUser in `echo $gUsers | sed 's|,| |g'`
3248                        do
3249                                pw groupshow ${gName} | grep -qw ${gUser}
3250                                if [ $? -ne 0 ] ; then
3251                                        # Are we installing as root?
3252                                        if [ "$runUID" != "0" ] ; then
3253                                                echo "Please add user \"$gUser\" to group \"$gName\" manually or re-install PBI as root."
3254                                                continue
3255                                        fi
3256
3257                                        echo "Adding user ${gUser} to group ${gName}"
3258                                        pw groupmod ${gName} -m ${gUser}
3259                                fi
3260                        done
3261                fi
3262        done < ${PBI_PROGDIRPATH}/${PBI_INS_GROUPSFILE}
3263}
3264
3265# Check for any UIDs we need to create
3266pbi_add_check_uids() {
3267        if [ ! -e "${PBI_PROGDIRPATH}/${PBI_INS_USERSFILE}" ] ; then return ; fi
3268        runUID=`id -u`
3269
3270        while read uidLine
3271        do
3272                uName=`echo $uidLine | cut -d ':' -f 1`
3273
3274                # Is this user already on the system?
3275                pw usershow $uName >/dev/null 2>/dev/null
3276                if [ $? -eq 0 ] ; then echo "Using existing user: $uName"; continue ; fi
3277
3278                # Are we installing as root?
3279                if [ "$runUID" != "0" ] ; then
3280                        echo "Please create user \"$uName\" manually or re-install PBI as root."
3281                        continue
3282                fi
3283
3284                uID=`echo $uidLine | cut -d ':' -f 3`
3285                gID=`echo $uidLine | cut -d ':' -f 4`
3286                uClass=`echo $uidLine | cut -d ':' -f 5`
3287                uGecos=`echo $uidLine | cut -d ':' -f 8`
3288                uHomedir=`echo $uidLine | cut -d ':' -f 9 | sed "s|^/usr/local|${PBI_PROGDIRPATH}|"`
3289                uShell=`echo $uidLine | cut -d ':' -f 10`
3290
3291                echo "Adding user: $uName"
3292                pw useradd $uName -u $uID -g $gID $uClass -c "$uGecos" -d $uHomedir -s $uShell;
3293
3294                # Create homedir
3295                case $uHomedir in
3296                        /nonexistent|/var/empty) ;;
3297                        *) install -d -g $gID -o $uID $uHomedir ;;
3298                esac
3299        done < ${PBI_PROGDIRPATH}/${PBI_INS_USERSFILE}
3300}
3301
3302add_hashdir_trigger() {
3303        get_dbdir
3304        _htrig=`echo ${APPDBDIR} | sed "s|${PBI_DBAPPDIR}|${PBI_DBHASHQUEUEDIR}|g"`
3305        if [ ! -e "${_htrig}" ] ; then
3306                touch "${_htrig}"
3307        fi
3308}
3309
3310# Run the install script if exists
3311pbi_add_run_script() {
3312
3313        # If running as user, add bin path-links
3314        if [ "`id -u`" != "0" ] ; then add_app_path_links "${PBI_PROGDIRPATH}" ; fi
3315
3316        insc="${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/.pbi-install.sh"
3317        if [ ! -e "${insc}" ] ; then return 0 ; fi
3318        export_script_vars
3319        if [ "$PBI_VERBOSE" = "YES" ] ; then
3320                ${insc}
3321        else
3322                ${insc} >/dev/null 2>/dev/null
3323        fi
3324
3325}
3326
3327# If we need to, update the hashdir
3328pbi_add_update_hashdir() {
3329        if [ "${PBI_NOHASHDIR}" = "YES" ] ; then return 0 ; fi
3330        if [ ! -e "${1}/${PBI_HASHLIST}" ] ; then return 0; fi
3331
3332        if [ "$PBI_VERBOSE" = "YES" ] ; then
3333                echo "HASHCOUNT: `wc -l ${1}/${PBI_HASHLIST} | tr -d ' ' | cut -d '/' -f 1`"
3334        else
3335       
3336                echo -e "Merging with hashdir...\c"
3337        fi
3338       
3339        # Read the hashfile, and start making links to identical files
3340        while read hl
3341        do
3342                file="`echo $hl | sed 's/:::.*$//g'`"
3343
3344                # If we are trying to merge a PBI which was deleted, stop
3345                if [ -n "${2}" -a -e "${2}" ] ; then
3346                        echo "HASHDONE - Deleted" 
3347                        return
3348                fi
3349
3350                # Make sure the target file hasnt been removed
3351                if [ ! -e "${1}/${file}" ] ; then continue ; fi
3352
3353                # We dont need no stinking sym-links
3354                if [ -h "${1}/${file}" ] ; then continue ; fi
3355
3356                if [ -f "${PBI_HASHDIR}/${hl}" ] ; then
3357                        use_hashfile "$hl" "${1}/$file"
3358                else
3359                        mv_ln_hashfile "$hl" "${1}/$file"
3360                fi
3361        done < "${1}/${PBI_HASHLIST}"
3362
3363        if [ "$PBI_VERBOSE" = "YES" ] ; then
3364                echo "HASHDONE"
3365        else
3366                echo -e "Done!" 
3367        fi
3368}
3369
3370# Use an existing hashfile
3371use_hashfile() {
3372        tfile="$1"
3373        file="$2"
3374        dir="`dirname ${tfile}`"
3375        if [ ! -d "${PBI_HASHDIR}/${dir}" ] ; then
3376                mkdir -p ${PBI_HASHDIR}/${dir}
3377        fi
3378
3379        # We have a match!
3380        ln -f "${PBI_HASHDIR}/${tfile}" "${file}"
3381        if [ $? -ne 0 ] ; then
3382                echo "Warning: Unable to make hash-link ${PBI_HASHDIR}/${tfile} -> ${file}"
3383                return
3384        fi
3385       
3386        # Make sure the hard-linked file doesn't get changed
3387        chmod u-w,g-w,o-w "${file}"
3388        if [ $? -ne 0 ] ; then
3389                echo "Warning: Unable to chmod ${file}"
3390                return
3391        fi
3392       
3393}
3394
3395# New file we can save to hashdir
3396mv_ln_hashfile() {
3397        tfile="$1"
3398        file="$2"
3399        dir="`dirname ${tfile}`"
3400        if [ ! -d "${PBI_HASHDIR}/${dir}" ] ; then
3401                mkdir -p ${PBI_HASHDIR}/${dir}
3402        fi
3403
3404        ln -f "${file}" "${PBI_HASHDIR}/${tfile}"
3405        if [ $? -ne 0 ] ; then
3406                echo "Warning: Unable to make hash-link ${file} -> ${PBI_HASHDIR}/${tfile}"
3407                return
3408        fi
3409
3410        # Make sure the hard-linked file doesn't get changed
3411        chmod u-w,g-w,o-w "${file}"
3412        if [ $? -ne 0 ] ; then
3413                echo "Warning: Unable to chmod ${file}"
3414                return
3415        fi
3416
3417        # Make sure the hard-linked file doesn't get changed
3418        chmod u-w,g-w,o-w "${PBI_HASHDIR}/${tfile}"
3419        if [ $? -ne 0 ] ; then
3420                echo "Warning: Unable to chmod ${PBI_HASHDIR}/${tfile}"
3421                return
3422        fi
3423
3424        if [ "$PBI_VERBOSE" = "YES" ] ; then echo "L" ; fi
3425}
3426
3427# Return the dbdir for this PBI
3428get_dbdir() {
3429        tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"
3430        APPDBDIR="${PBI_DBAPPDIR}/${tmp}-${PBI_PROGVERSION}-${PBI_APPARCH}"
3431}
3432
3433# Register this app as installed
3434pbi_add_register_app() {
3435        if [ ! -d "$PBI_DBAPPDIR" ] ; then mkdir -p ${PBI_DBAPPDIR} ; fi
3436        open_header_tmp
3437        get_dbdir
3438        dir="${APPDBDIR}"
3439
3440        # Make sure we remove any existing meta-data if forcing an installation
3441        if [ "$PBI_FORCEADD" = "YES" ] ; then
3442                tmp="`echo ${PBI_PROGNAME} | tr -d ' ' | tr '[A-Z]' '[a-z]'`"
3443                rm -rf ${PBI_DBAPPDIR}/${tmp}-*-${PBI_APPARCH}
3444        fi
3445
3446        mkdir -p "${dir}"
3447       
3448        tar cvf - -C "${PBI_HEADER_TMPDIR}" . 2>/dev/null | tar xvf - -C "$dir" 2>/dev/null
3449
3450        # If this was a patch, use the original path
3451        if [ -n "${PBI_ORIGPROGDIRPATH}" ] ; then
3452                echo "${PBI_ORIGPROGDIRPATH}" >${dir}/pbi_installedpath
3453        else
3454                echo "${PBI_PROGDIRPATH}" >${dir}/pbi_installedpath
3455        fi
3456
3457        # See which repo / key this PBI associates to, if any
3458        check_valid_sigs "${dir}"
3459        if [ -n "$PBI_VALIDKEYSIG" ] ; then
3460                _rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"
3461                echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${dir}/pbi_repo
3462        fi
3463
3464        # Dont need any patch version info
3465        if [ -e "${dir}/pbi_patchfile" ] ; then
3466                rm "${dir}/pbi_patchfile"
3467        fi
3468
3469        delete_header_tmp
3470
3471        echo "Installed: ${PBI_PROGNAME}-${PBI_PROGVERSION}"
3472}
3473
3474# Check if we have a postinstall script we need to use
3475check_postinstall_script() {
3476        open_header_tmp
3477
3478        if [ ! -e "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}" ] ; then
3479                delete_header_tmp
3480                return 0
3481        fi
3482
3483        export_script_vars
3484        sh "${PBI_HEADER_TMPDIR}/${MOD_POSTINS}"
3485        delete_header_tmp
3486}
3487
3488# Check if we have a preinstall script we need to use
3489check_preinstall_script() {
3490        open_header_tmp
3491
3492        if [ ! -e "${PBI_HEADER_TMPDIR}/${MOD_PREINS}" ] ; then
3493                delete_header_tmp
3494                return 0
3495        fi
3496
3497        export_script_vars
3498        sh "${PBI_HEADER_TMPDIR}/${MOD_PREINS}"
3499        if [ "$?" != "0" ] ; then
3500                delete_header_tmp
3501                exit_err "${MOD_PREINS} returned error status"
3502        fi
3503        delete_header_tmp
3504}
3505
3506# Verify if we have valid openssl signatures on important parts of PBI
3507pbi_verify_signatures() {
3508        if [ "${PBI_SKIPSIGVERIFY}" = "YES" ] ; then return 0 ; fi
3509        if [ "$PBI_SIGVALID" = "0" ] ; then return ; fi
3510        if [ "$PBI_SIGVALID" = "1" ] ; then kw="Invalid" ; else kw="No" ; fi
3511        exit_err "$kw digital signature! If you are *SURE* you trust this PBI, re-install with --no-checksig option. "
3512
3513}
3514
3515# Check if we have valid signatures, and return "0" if success, "1" if failure
3516check_valid_sigs() {
3517        PBI_VALIDKEYSIG=""
3518
3519        for _pk in ${PBI_PUBKEYS}
3520        do
3521                good="true"
3522                _sf="${1}/pbi_archivesum ${1}/${MOD_PREINS} ${1}/${MOD_POSTINS} ${1}/${MOD_PREREM}"
3523                for _ts in $_sf
3524                do
3525                        openssl dgst -sha1 \
3526                        -verify ${_pk} \
3527                        -signature ${_ts}.sha1 \
3528                        ${_ts} >/dev/null 2>/dev/null
3529                        if [ "$?" != "0" ] ; then
3530                                good="false" ; break
3531                        fi
3532                        PBI_VALIDKEYSIG="$_pk"
3533                done
3534                if [ "$good" = "true" ] ; then return 0 ; fi
3535        done
3536        return 1       
3537}
3538
3539# Verify if the archive checksum is good
3540pbi_verify_archivesum() {
3541        if [ "${PBI_SKIPCHECKSUM}" = "YES" ] ; then return 0 ; fi
3542        echo -e "Verifying Checksum...\c"
3543
3544        pbi_find_archive_header
3545        sum=`tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | sha256 -q`
3546        if [ "$PBI_VERBOSE" = "YES" ] ; then
3547                echo "Archive checksum: ${sum}"
3548                echo "Saved checksum: ${PBI_ARCHIVE_CHECKSUM}"
3549        fi
3550        if [ "$sum" != "$PBI_ARCHIVE_CHECKSUM" ] ; then
3551                exit_err "${PBI_FILENAME} failed checksum, the archive may be corrupt."
3552        fi
3553        echo -e "OK"
3554
3555}
3556
3557# Make our PBI extraction dir
3558mk_pbi_extract_dir() {
3559        PBI_EXTRACTDIR="${PBI_PROGDIRPATH}"
3560        if [ -e "${PBI_EXTRACTDIR}" ] ; then
3561               rm -rf "$PBI_EXTRACTDIR"
3562        fi
3563        mkdir -p "${PBI_EXTRACTDIR}" >/dev/null 2>/dev/null
3564        if [ "$?" != "0" ] ; then
3565                exit_err "Failed to create directory: ${PBI_PROGDIRPATH}"
3566        fi
3567}
3568
3569pbi_find_archive_header() {
3570        # Find the header for the archive
3571        # SEARCH FOR: $PBI_SS_ARCHIVE
3572        PBI_SKIP_ARCHLINES=`awk "/^${PBI_SS_ARCHIVE}/ { print NR + 1; exit 0; }" "${PBI_FILENAME}"`
3573        if [ "$PBI_VERBOSE" = "YES" ] ; then
3574                echo "SKIP_ARCHLINES: $PBI_SKIP_ARCHLINES"
3575        fi
3576}
3577
3578# Extract the PBI archive file
3579pbi_extract_archive() {
3580        pbi_find_archive_header
3581
3582        echo "Extracting to: ${PBI_EXTRACTDIR}"
3583        tar="xvf -"
3584
3585        if [ "$PBI_VERBOSE" = "YES" ] ; then
3586                echo "TOTALFILES: ${PBI_ARCHIVE_COUNT}"
3587                tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar ${tar} -C "${PBI_EXTRACTDIR}"
3588                err="$?"
3589        else
3590                tail +$PBI_SKIP_ARCHLINES "${PBI_FILENAME}" | tar ${tar} -C "${PBI_EXTRACTDIR}" >/dev/null 2>/dev/null
3591                err="$?"
3592        fi
3593       
3594        if [ "$err" != "0" ] ; then exit_err "Failed extracting ${PBI_FILENAME}" ; fi
3595
3596        if [ "$PBI_VERBOSE" = "YES" ] ; then echo "Extraction Finished!" ; fi
3597
3598        # If this is an extract only, do it and exit
3599        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then exit_trap ; fi
3600}
3601       
3602
3603# Starting pbi_create
3604pbi_create_init() {
3605
3606        require_root
3607
3608        parse_create_pbi_cmdline "$@"
3609
3610        # If we are making a backup copy of an installed PBI
3611        if [ "$PBI_CBACKUP" = "YES" ] ; then
3612                init_tmpdir
3613                do_pbi_create_backup
3614                exit_trap
3615        fi
3616
3617        load_pbi_conffile
3618
3619        parse_cmdline_overrides
3620
3621        # Copy over the application to the correct location
3622        echo ${PBI_PROGDIRPATH} | grep -q "^${PBI_APPDIR}/"
3623        if [ $? -ne 0 ] ; then
3624           _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
3625           newPDP="${PBI_APPDIR}/${_pbilow}-${ARCH}"
3626           if [ -d "${newPDP}" ] ; then exit_err "Error: ${newPDP} already exists!" ; fi       
3627           cp -r ${PBI_PROGDIRPATH} ${newPDP}
3628           PBI_PROGDIRPATH="${newPDP}"
3629           export PBI_PROGDIRPATH
3630        fi
3631
3632        PBI_CREATEONLY="YES"
3633
3634        check_create_required_vars
3635
3636        do_pbi_create
3637
3638        # Cleanup the copy dir
3639        if [ -n "$newPDP" ] ; then
3640                if [ "${newPDP}" != "/" -a "${newPDP}" != "${PBI_APPDIR}/-" ] ; then
3641                        rm -rf "${newPDP}"
3642                fi
3643        fi
3644}
3645
3646# Start the pbi_create backup process
3647do_pbi_create_backup() {
3648
3649        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_CBACKUPTARGET}"
3650        echo "Creating backup PBI: ${PBI_PROGNAME}-${PBI_PROGVERSION}"
3651
3652        # Start by making a fresh archive of the installed PBI
3653        PBI_STAGEDIR="$PBI_ORIGPROGDIRPATH"
3654        mk_archive_file
3655
3656        # Now make the header dir
3657        _hDir="${PBI_TMPDIR}/.header.$$"
3658        PBI_HEADERDIR="${_hDir}"
3659        mkdir -p "${_hDir}"
3660        cp ${PBI_DBAPPDIR}/${PBI_CBACKUPTARGET}/* "${_hDir}"
3661        rm ${_hDir}/*.sha1 >/dev/null 2>/dev/null
3662
3663        # Get the total number of files in the STAGEDIR
3664        get_filetotal_dir "${PBI_STAGEDIR}"
3665        echo "${FILETOTAL}" > "${PBI_HEADERDIR}/pbi_archivecount"
3666
3667        # Save a checksum of archive file
3668        sha256 -q "${PBI_CREATE_ARCHIVE}" > "${PBI_HEADERDIR}/pbi_archivesum"
3669
3670        # Sign any header files
3671        sign_pbi_files "$PBI_HEADERDIR"
3672
3673        # Make the header archive
3674        mk_header_file
3675
3676        # Now finish up and make the resulting PBI file
3677        mk_output_pbi
3678
3679}
3680
3681
3682# Vars required for creation
3683check_create_required_vars() {
3684        if [ -z "${PBI_PROGNAME}" ] ; then exit_err "Missing PBI_PROGNAME"; fi
3685        if [ -z "${PBI_PROGVERSION}" ] ; then exit_err "Missing PBI_PROGVERSION"; fi
3686        if [ -z "${PBI_PROGAUTHOR}" ] ; then exit_err "Missing PBI_PROGAUTHOR"; fi
3687        if [ -z "${PBI_PROGWEB}" ] ; then exit_err "Missing PBI_PROGWEB"; fi
3688}
3689
3690# Start the pbi_create process
3691do_pbi_create() {
3692        get_pbi_progname
3693        echo "Creating PBI: ${PBI_PROGNAME}-${PBI_PROGVERSION}"
3694
3695
3696        if [ "`basename $0`" = "pbi_makeport" -o "`basename $0`" = "pbi_makeport_chroot" ] ; then
3697          mk_stage_dir "/usr/local" "move"
3698
3699          # Check if we created a linux app, and need to copy files for it
3700          auto_copy_linuxbase
3701        else
3702          mk_stage_dir
3703        fi
3704
3705        copy_resource_dir
3706        clean_stage_dir
3707
3708        mk_extlink_entries
3709        clean_icons_dir
3710        mk_xdg_scripts
3711
3712        run_pbi_prepkgscript
3713
3714        mk_install_script
3715        mk_deinstall_script
3716
3717        mk_hash_list
3718
3719        mk_archive_file
3720
3721        mk_header_dir
3722        save_pbi_details_to_header
3723        mk_header_file
3724
3725        mk_output_pbi
3726
3727        rm_stage_dir
3728        exit 0
3729}
3730
3731# Start looping through and creating a hash-list of files
3732mk_hash_list() {
3733        if [ "${PBI_CREATE_HASHLIST}" = "NO" ] ; then return 0 ; fi
3734        echo "Creating hash list..."
3735
3736        hashfile="${PBI_STAGEDIRMNT}/${PBI_HASHLIST}"
3737
3738        if [ -e "${hashfile}" ] ; then rm "${hashfile}" ; fi
3739
3740        for hdir in ${HASH_SEARCH_DIRS}
3741        do
3742                if [ ! -d "${PBI_STAGEDIR}/${hdir}" ] ; then continue ; fi
3743                save_dir_hash_list "${hdir}" "${hashfile}"     
3744        done
3745}
3746
3747#  Read the specified directory and save hashsums of each file
3748save_dir_hash_list() {
3749        cd ${PBI_STAGEDIR}
3750        tmp_hashdir="${PBI_STAGEDIR}/.tmp-hash.$$"
3751        find "${1}" -type f > ${tmp_hashdir}
3752        while read line
3753        do
3754                if [ ! -f "$line" -o -h "$line" ] ; then continue ; fi
3755               
3756                # Check if this hash file is excluded
3757                _hfound="0"
3758                if [ -n "${PBI_HASH_EXCLUDES}" ] ; then
3759                        for _hexcl in ${PBI_HASH_EXCLUDES}
3760                        do
3761                                if [ "$_hexcl" = "$line" ] ; then
3762                                        _hfound="1"
3763                                fi
3764                        done
3765                        if [ "$_hfound" = "1" ] ; then
3766                                continue
3767                        fi
3768                fi     
3769
3770                # Add to the hash-dir
3771                sha=`sha256 -q "$line"`
3772                echo "${line}:::${sha}" >> ${2}
3773
3774        done < ${tmp_hashdir}
3775        rm ${tmp_hashdir}
3776        cd /
3777}
3778
3779# Parse any external link directives
3780mk_extlink_entries() {
3781        echo "Creating external link entries..."
3782        init_tmpdir
3783        _extf="${PBI_CONFDIR}/${MOD_EXTLINKFILE}"
3784        _autoextf="${PBI_TMPDIR}/${MOD_AUTOEXTLINKFILE}"
3785        _tmpextf="${PBI_TMPDIR}/${MOD_AUTOEXTLINKFILE}.$$"
3786        if [ ! -e "${_extf}" -a ! -e "${_autoextf}" ] ; then return 0 ; fi
3787
3788        dir="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}"
3789        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3790
3791        # Create the headers for the PATH link scripts
3792        echo "#!/bin/sh" >"${dir}/${PBI_INS_PATHSCRIPT}"
3793        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_PATHSCRIPT}"
3794
3795        # Make sure we also set SYS_LOCALBASE in case user runs these stand-alone at some point
3796        echo "if [ -z \"\$SYS_LOCALBASE\" ]; then SYS_LOCALBASE=\"${SYS_LOCALBASE}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3797        echo "if [ -z \"\$SYS_LOCALBASE\" ]; then SYS_LOCALBASE=\"${SYS_LOCALBASE}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3798        echo "if [ -z \"\$PBI_RCDIR\" ]; then PBI_RCDIR=\"${PBI_RCDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3799        echo "if [ -z \"\$PBI_RCDIR\" ]; then PBI_RCDIR=\"${PBI_RCDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3800        echo "if [ -z \"\$PBI_MANDIR\" ]; then PBI_MANDIR=\"${PBI_MANDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3801        echo "if [ -z \"\$PBI_MANDIR\" ]; then PBI_MANDIR=\"${PBI_MANDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3802        echo "if [ -z \"\$PBI_BINDIR\" ]; then PBI_BINDIR=\"${PBI_BINDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3803        echo "if [ -z \"\$PBI_BINDIR\" ]; then PBI_BINDIR=\"${PBI_BINDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3804
3805        touch "$_tmpextf"
3806        if [ -e "$_autoextf" ]; then cat "${_autoextf}" >> "${_tmpextf}" ; fi
3807        if [ -e "$_extf" ]; then cat "${_extf}" >> "${_tmpextf}" ; fi
3808
3809        while read line
3810        do
3811                _bin="NO"
3812                _wraponly="NO"
3813                _crashhandle="YES"
3814                _keep="YES"
3815                _linux="NO"
3816                echo $line | tr '\t' ' ' | tr -s ' ' | grep "^#" >/dev/null 2>/dev/null
3817                if [ "$?" != "0" ] ; then
3818                        src="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 1`"
3819                        tar="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 2`"
3820                        act="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 3`"
3821
3822                        if [ -z "$src" -o -z "$tar" ] ; then continue ; fi
3823
3824                        # Check if this is an icon we need to preserve
3825                        echo $src | grep -q "^share/icons/"
3826                        if [ $? -eq 0 -a "${PBI_USESYSFONTS}" != "NO" ] ; then
3827                                iDir=`dirname $src`
3828                                if [ ! -d "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}" ] ; then
3829                                        mkdir -p "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}"
3830                                fi
3831                                cp "${PBI_STAGEDIR}/${src}" "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}"
3832                                src="${PBI_ICDIR}/${src}"
3833                        fi
3834
3835                        if [ ! -e "${PBI_STAGEDIR}/$src" ] ; then
3836                                echo "WARN: external_link target: \"$src -> $tar $act\" does not exist!"
3837                                continue
3838                        fi
3839
3840                        # Check for act directives
3841                        for i in `echo ${act} | sed 's|,| |g'`
3842                        do
3843                                case ${i} in
3844                                        binary) _bin="YES" ;;
3845                                    binwrapper) _bin="YES" ; _wraponly="YES" ;;
3846                                       nocrash) _crashhandle="NO" ;;
3847                                          keep) _keep="YES" ;;
3848                                       replace) _keep="NO" ;;
3849                                         linux) _bin="YES" ; _linux="YES" ;;
3850                                        *) echo "Warning: Unknown option \"$i\" in ${MOD_EXTLINKFILE}";;
3851                                esac
3852                               
3853                        done
3854
3855
3856                        # If we are doing a binary, run special function to make wrapper
3857                        if [ "$_bin" = "YES" ] ; then
3858
3859                                # Make sure we don't create any duplicates
3860                                echo "$_donewrap" | grep "#${src}#" >/dev/null 2>/dev/null
3861                                if [ "$?" = "0" ] ; then continue ; fi
3862                               
3863                                # Make the binary wrapper
3864                                mk_path_wrappers "$src" "$tar" "$_crashhandle" "$_wraponly" "$_linux"
3865
3866                                # This binary is done, save it now so we don't duplicate later
3867                                _donewrap="$_donewrap #${src}#"
3868                        else
3869                                # Make our link commands
3870                                if [ "$_keep" = "YES" ] ; then _lop="-fs"; else _lop="-s"; fi
3871                                echo $tar | grep -q "^man/"
3872                                if [ $? -eq 0 ] ; then
3873                                        # Strip off the man/ path
3874                                        _mTar=`echo $tar | sed 's|^man/||g'`
3875                                        _dTar="\$PBI_MANDIR/${_mTar}"
3876                                        echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3877                                        echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3878                                        echo "ln ${_lop} $PBI_PROGDIRPATH/local/${src} \$PBI_MANDIR/${_mTar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3879                                else
3880                                        _dTar="\$SYS_LOCALBASE/${tar}"
3881                                        echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3882                                        echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3883                                        echo "ln ${_lop} $PBI_PROGDIRPATH/local/${src} \$SYS_LOCALBASE/${tar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3884
3885                                fi
3886                        fi
3887
3888                        # Make the uninstall command
3889                        echo "ls -al \"${_dTar}\" | grep \"> $PBI_PROGDIRPATH\" >/dev/null 2>/dev/null " \
3890                                >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3891                        echo "if [ \"\$?\" = \"0\" ] ; then" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3892                        echo "  rm \"${_dTar}\"" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3893                        echo "fi" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3894
3895                        echo " " >> "${dir}/${PBI_INS_PATHSCRIPT}"
3896                        echo " " >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3897
3898                fi
3899
3900        done < "${_tmpextf}"
3901        rm "${_tmpextf}"
3902
3903        chmod 755 "${dir}/${PBI_INS_PATHSCRIPT}"
3904        chmod 755 "${dir}/${PBI_UNINS_PATHSCRIPT}"
3905}
3906
3907
3908# Create the wrapper scripts for the specified binaries
3909mk_path_wrappers() {
3910        dir="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}"
3911        rcdir="${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}"
3912        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3913
3914        bin="${1}"
3915        fbin="`basename ${bin}`"
3916        tar="${2}"
3917        ch="${3}"
3918        onlywrap="${4}"
3919        linwrap="${5}"
3920
3921        # Check if the fake-bin wrapper already exists, and if so use
3922        # a different name
3923        if [ -e "${dir}/${fbin}" ] ; then
3924                fbin=`echo $bin | sed 's|/|-|g'`
3925        fi
3926
3927        # If this is an rc.d script, add it to the PBI_RCDIR
3928        if [ "`dirname $tar`" = "etc/rc.d" ] ; then
3929                        >> "${dir}/${PBI_INS_PATHSCRIPT}"
3930                _dTar="\$PBI_RCDIR/`basename ${tar}`"
3931                echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3932                echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3933                echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKERC_DIR}/${fbin} \$PBI_RCDIR/`basename ${tar}`" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3934
3935                # Copy the wrapper binary
3936                PBI_WRAPPERFILE="/.pbiwrapper-$ARCH"
3937                cp ${PBI_WRAPPERFILE} ${rcdir}/${fbin}
3938                chmod 755 ${rcdir}/${fbin}
3939
3940                # Create the wrapper .pbiopt
3941                echo "PROGDIR: ${PBI_PROGDIRPATH}" >${rcdir}/${fbin}.pbiopt
3942                echo "TARGET: ${bin}" >>${rcdir}/${fbin}.pbiopt
3943                return
3944        fi
3945
3946        # Make our link to the system localbase if its not a wrapper only
3947        if [ "$onlywrap" != "YES" ] ; then     
3948                _mTar=`echo $tar | sed "s|^bin/||g" | sed "s|^sbin/||g"`
3949                _dTar="\$PBI_BINDIR/${_mTar}"
3950
3951                        >> "${dir}/${PBI_INS_PATHSCRIPT}"
3952                echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3953                echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3954                echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${fbin} \$PBI_BINDIR/${_mTar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3955        fi
3956
3957
3958        # Copy the wrapper binary
3959        PBI_WRAPPERFILE="/.pbiwrapper-$ARCH"
3960        cp ${PBI_WRAPPERFILE} ${dir}/${fbin}
3961        chmod 755 ${dir}/${fbin}
3962
3963        # Create the wrapper .pbiopt
3964        echo "PROGDIR: ${PBI_PROGDIRPATH}" >${dir}/${fbin}.pbiopt
3965        echo "TARGET: ${bin}" >>${dir}/${fbin}.pbiopt
3966}
3967
3968# Create any XDG script for install / deinstall
3969mk_xdg_scripts() {
3970        echo "Creating xdg scripts..."
3971        mk_xdg_desktop_script
3972        mk_xdg_menu_script
3973        mk_xdg_mime_script
3974}
3975
3976# Create any XDG script for desktop icons
3977mk_xdg_desktop_script() {
3978        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGDESK_DIR}" ] ; then return 0 ; fi
3979        _dFound=0
3980
3981        dir="${PBI_STAGEDIRMNT}/${PBI_APPDESK_DIR}"
3982        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3983        echo "#!/bin/sh" >"${dir}/${PBI_INS_DESKSCRIPT}"
3984        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_DESKSCRIPT}"
3985
3986        cd "${PBI_CONFDIR}/${MOD_XDGDESK_DIR}"
3987        for i in `ls *.desktop 2>/dev/null`
3988        do
3989                _dFound=1
3990
3991                # Copy over the .desktop file, modifying any variables within
3992                cat "${i}" \
3993                | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
3994                | sed "s|%%PBI_APPDIR%%|${PBI_PROGDIRPATH}/local|g" \
3995                > "${dir}/PBI-${i}"
3996
3997                # Set the correct permissions on the desktop file
3998                chmod 744 "${dir}/PBI-${i}"
3999
4000                ifi="$PBI_PROGDIRPATH/${PBI_APPDESK_DIR}/PBI-${i}"
4001
4002                echo "xdg-desktop-icon install --novendor ${ifi}" \
4003                         >> "${dir}/${PBI_INS_DESKSCRIPT}"
4004                echo "xdg-desktop-icon uninstall ${ifi}" \
4005                         >> "${dir}/${PBI_UNINS_DESKSCRIPT}"
4006               
4007        done
4008
4009        chmod 755 "${dir}/${PBI_INS_DESKSCRIPT}"
4010        chmod 755 "${dir}/${PBI_UNINS_DESKSCRIPT}"
4011
4012        # No desktop entries
4013        if [ "$_dFound" = "0" ] ; then
4014                rm "${dir}/${PBI_INS_DESKSCRIPT}"
4015                rm "${dir}/${PBI_UNINS_DESKSCRIPT}"
4016        fi
4017}
4018
4019# Create any XDG script for menu icons
4020mk_xdg_menu_script() {
4021        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGMENU_DIR}" ] ; then return 0 ; fi
4022
4023        _mFound=0
4024
4025        dir="${PBI_STAGEDIRMNT}/${PBI_APPMENU_DIR}"
4026        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4027        echo "#!/bin/sh" >"${dir}/${PBI_INS_MENUSCRIPT}"
4028        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_MENUSCRIPT}"
4029
4030        cd "${PBI_CONFDIR}/${MOD_XDGMENU_DIR}"
4031        for i in `ls *.desktop 2>/dev/null`
4032        do
4033                _mFound=1
4034
4035                # Copy the desktop file, changing any included vars
4036                cat "${i}" \
4037                | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4038                | sed "s|%%PBI_APPDIR%%|${PBI_PROGDIRPATH}/local|g" \
4039                > "${dir}/PBI-${i}"
4040
4041                # Set the correct permissions on the menu file
4042                chmod 744 "${dir}/PBI-${i}"
4043
4044                ifi="$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/PBI-${i}"
4045
4046                # Check for a .directory file associated with this .desktop
4047                ifd=""
4048                dirfile="`basename -s .desktop ${i}`"
4049                if [ -e "${dirfile}.directory" ] ; then
4050                        cat "${dirfile}.directory" \
4051                        | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4052                        | sed "s|%%PBI_APPDIR%%|${PBI_PROGDIRPATH}/local|g" \
4053                        > "${dir}/PBI-${dirfile}.directory"
4054                        #cp "${dirfile}.directory" "${dir}/PBI-${dirfile}.directory"
4055                        ifd="$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/PBI-${dirfile}.directory "     
4056                fi
4057
4058                echo "xdg-desktop-menu install --novendor ${ifd}${ifi}" \
4059                         >> "${dir}/${PBI_INS_MENUSCRIPT}"
4060                echo "xdg-desktop-menu uninstall ${ifd}${ifi}" \
4061                         >> "${dir}/${PBI_UNINS_MENUSCRIPT}"
4062
4063        done
4064
4065        chmod 755 "${dir}/${PBI_INS_MENUSCRIPT}"
4066        chmod 755 "${dir}/${PBI_UNINS_MENUSCRIPT}"
4067
4068        # No mime entries
4069        if [ "$_mFound" = "0" ] ; then
4070                rm "${dir}/${PBI_INS_MENUSCRIPT}"
4071                rm "${dir}/${PBI_UNINS_MENUSCRIPT}"
4072        fi
4073}
4074
4075# Create any XDG script for mime types
4076mk_xdg_mime_script() {
4077        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGMIME_DIR}" ] ; then return 0 ; fi
4078        _mFound=0
4079
4080        dir="${PBI_STAGEDIRMNT}/${PBI_APPMIME_DIR}"
4081        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4082        echo "#!/bin/sh" >"${dir}/${PBI_INS_MIMESCRIPT}"
4083        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_MIMESCRIPT}"
4084
4085
4086        cd "${PBI_CONFDIR}/${MOD_XDGMIME_DIR}"
4087        for i in `ls *.xml 2>/dev/null`
4088        do
4089                _mFound=1
4090                cp "${i}" "${dir}/PBI-${i}"
4091                ifi="$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/PBI-${i}"
4092
4093                # Check for a .directory file associated with this .desktop
4094                ifp=""
4095                iconfile="`basename -s .xml ${i}`"
4096                if [ -e "${iconfile}.png" ] ; then
4097                        cp "${iconfile}.png" "${dir}/${iconfile}.png"
4098                        ifp="$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${iconfile}.png"
4099                        mi=`cat "$i" | grep '<mime-type' | cut -d '"' -f 2 | sed 's|/|-|g'`
4100                        echo "xdg-icon-resource install --novendor --context mimetypes ${ifp} --size 64 $mi" \
4101                                 >> "${dir}/${PBI_INS_MIMESCRIPT}"
4102                        echo "xdg-icon-resource uninstall --context mimetypes ${ifp} --size 64" \
4103                                 >> "${dir}/${PBI_UNINS_MIMESCRIPT}"
4104                fi
4105
4106                echo "xdg-mime install --novendor ${ifi}" \
4107                         >> "${dir}/${PBI_INS_MIMESCRIPT}"
4108                echo "xdg-mime uninstall ${ifi}" \
4109                         >> "${dir}/${PBI_UNINS_MIMESCRIPT}"
4110        done
4111
4112        chmod 755 "${dir}/${PBI_INS_MIMESCRIPT}"
4113        chmod 755 "${dir}/${PBI_UNINS_MIMESCRIPT}"
4114
4115        # No mime entries
4116        if [ "$_mFound" = "0" ] ; then
4117                rm "${dir}/${PBI_INS_MIMESCRIPT}"
4118                rm "${dir}/${PBI_UNINS_MIMESCRIPT}"
4119        fi
4120}
4121
4122
4123# Create the install script for the PBI
4124mk_install_script() {
4125        echo "Creating install script..."
4126        if [ ! -d "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}" ] ; then mkdir -p "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}" ; fi
4127        if [ ! -d "${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}" ] ; then mkdir -p "${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}" ; fi
4128        insc="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/.pbi-install.sh"
4129        echo "#!/bin/sh" > "$insc"
4130        echo "PBI_WRAPPERBIN=\"${PBI_FAKEBIN_DIR}\"" >> "$insc"
4131        echo "PBI_PROGDIRPATH=\"${PBI_PROGDIRPATH}\"" >> "$insc"
4132        echo "SYS_LOCALBASE=\"${SYS_LOCALBASE}\"" >> "$insc"
4133        echo "cd \"\$PBI_PROGDIRPATH\"" >> "$insc"
4134
4135        # Add the binary wrapper sym-links
4136        if [ -e "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" ] ; then
4137                echo 'if [ `id -u` = "0" ] ; then ' >>${insc}
4138                echo "  $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" >>${insc}
4139                echo "fi" >>${insc}
4140        fi
4141
4142        # Look for any XDG scripts
4143        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMIME_DIR}/${PBI_INS_MIMESCRIPT}" ] ; then
4144                echo "$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${PBI_INS_MIMESCRIPT}" >>${insc}
4145        fi
4146        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMENU_DIR}/${PBI_INS_MENUSCRIPT}" ] ; then
4147                echo "$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/${PBI_INS_MENUSCRIPT}" >>${insc}
4148        fi
4149
4150        chmod 755 "${insc}"
4151       
4152}
4153
4154# Create the deinstall script for the PBI
4155mk_deinstall_script() {
4156        echo "Creating deinstall script..."
4157        uisc="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"
4158
4159        echo "#!/bin/sh" > "$uisc"
4160        echo "PBI_PROGDIRPATH=\"${PBI_PROGDIRPATH}\"" >> "$uisc"
4161        echo "SYS_LOCALBASE=\"${SYS_LOCALBASE}\"" >> "$uisc"
4162
4163        # Remove the binary wrapper sym-links
4164        if [ -e "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" ] ; then
4165                echo 'if [ `id -u` = "0" ] ; then ' >>${uisc}
4166                echo "  $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >>${uisc}
4167                echo "fi" >>${uisc}
4168        fi
4169
4170        # Look for any XDG scripts
4171        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMIME_DIR}/${PBI_UNINS_MIMESCRIPT}" ] ; then
4172                echo "$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${PBI_UNINS_MIMESCRIPT}" >>${uisc}
4173        fi
4174        if [ -e "${PBI_STAGEDIRMNT}/${PBI_APPMENU_DIR}/${PBI_UNINS_MENUSCRIPT}" ] ; then
4175                echo "$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/${PBI_UNINS_MENUSCRIPT}" >>${uisc}
4176        fi
4177        chmod 755 "${uisc}"
4178}
4179
4180# Create a dir for manipulating header info
4181mk_header_dir() {
4182        PBI_HEADERDIR="${PBI_STAGEDIRMNT}/pbimeta"
4183        if [ -e "${PBI_HEADERDIR}" ] ; then rm -rf "${PBI_HEADERDIR}" ; fi
4184        mkdir -p ${PBI_HEADERDIR}
4185}
4186
4187# Create a dir for staging the final archive
4188mk_stage_dir() {
4189        if [ -n "$1" ] ; then
4190                cpDir="$1"
4191        else
4192                cpDir="${PBI_PROGDIRPATH}"
4193        fi
4194
4195        PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"
4196        echo "Creating Stage Dir: ${PBI_STAGEDIR}"
4197        if [ -e "${PBI_STAGEDIR}" ] ; then
4198                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4199                chflags -R noschg ${PBI_STAGEDIR} 2>/dev/null
4200                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4201        fi
4202        mkdir -p ${PBI_STAGEDIR}
4203
4204        mkdir -p ${PBI_STAGEDIR}/local
4205        mkdir -p ${PBI_STAGEDIR}/etc
4206        mkdir -p ${PBI_STAGEDIR}/rc.d
4207        mkdir -p ${PBI_STAGEDIR}/pbimeta
4208        mkdir -p ${PBI_STAGEDIR}/virtbase
4209        mkdir -p ${PBI_STAGEDIR}/linux
4210        mkdir -p ${PBI_STAGEDIR}/run
4211
4212        # If we built with a module / conf directory, lets include it
4213        if [ -d "${PBI_CONFDIR}" ] ; then cp -r ${PBI_CONFDIR} ${PBI_STAGEDIR}/pbiconf; fi
4214
4215        local _excOpts=""
4216
4217        # Build module list of excludes
4218        if [ -n "$PBI_EXCLUDELIST" ] ; then
4219                for excl in $PBI_EXCLUDELIST
4220                do
4221                        if [ -z "$_excOpts" ] ; then
4222                                _excOpts="--exclude ${excl}"
4223                        else
4224                                _excOpts="$_excOpts --exclude ${excl}"
4225                        fi
4226                done
4227        fi
4228
4229        if [ "$2" = "move" ] ; then
4230                rmdir ${PBI_STAGEDIR}/local
4231                mv ${cpDir} ${PBI_STAGEDIR}/local
4232                ln -s ${PBI_STAGEDIR}/local /usr/local
4233        else
4234                # Now copy the stagedir
4235                tar cvf - ${_excOpts} --exclude .stagedir \
4236                --exclude .pkgdb --exclude .ld-elf.hints --exclude make.conf \
4237                --exclude make.conf.bak --exclude .keepports \
4238                -C "${cpDir}" . 2>/dev/null \
4239                | tar xvpf - -C ${PBI_STAGEDIR}/local 2>/dev/null
4240        fi
4241
4242        cd ${PBI_PROGDIRPATH}
4243        PBI_STAGEDIRMNT="${PBI_STAGEDIR}"
4244        PBI_STAGEDIR="${PBI_STAGEDIR}/local"
4245}
4246
4247# Remove the stagedir
4248rm_stage_dir() {
4249        # If this is in the chroot we can exit and let the parent cleanup
4250        if [ "$0" = "pbi_makeport_chroot" ] ; then return; fi
4251
4252        cd /
4253        PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"
4254        if [ -e "${PBI_STAGEDIR}" ] ; then
4255                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4256                chflags -R noschg ${PBI_STAGEDIR} 2>/dev/null
4257                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4258        fi
4259}
4260
4261# See if we need to clean the icons dir
4262clean_icons_dir() {
4263        if [ "${PBI_USESYSFONTS}" != "NO" ] ; then
4264                rm -rf ${PBI_STAGEDIR}/share/icons >/dev/null 2>/dev/null
4265                mkdir ${PBI_STAGEDIR}/share/icons >/dev/null 2>/dev/null
4266        fi
4267}
4268
4269# See if we need to clean the stagedir
4270clean_stage_dir() {
4271
4272        if [ "${PBI_USESYSGL}" != "NO" ] ; then
4273                rm ${PBI_STAGEDIR}/lib/libGl.* >/dev/null 2>/dev/null
4274                rm ${PBI_STAGEDIR}/lib/libGL.* >/dev/null 2>/dev/null
4275                rm ${PBI_STAGEDIR}/lib/libGLU.* >/dev/null 2>/dev/null
4276        fi
4277        if [ "${PBI_USESYSFONTS}" != "NO" ] ; then
4278                rm -rf ${PBI_STAGEDIR}/etc/fonts/* >/dev/null 2>/dev/null
4279                rm -rf ${PBI_STAGEDIR}/lib/X11/fonts/* >/dev/null 2>/dev/null
4280                rm -rf ${PBI_STAGEDIR}/lib/X11/icons/* >/dev/null 2>/dev/null
4281        fi
4282        if [ -e "${PBI_STAGEDIR}/lib/X11" ] ; then
4283                mkdir -p ${PBI_STAGEDIR}/lib/X11/icons/ >/dev/null 2>/dev/null
4284                mkdir -p ${PBI_STAGEDIR}/lib/X11/fonts/ >/dev/null 2>/dev/null
4285                mkdir -p ${PBI_STAGEDIR}/etc/fonts/ >/dev/null 2>/dev/null
4286        fi
4287}
4288
4289# Copy over any resource files into the PBI dir
4290copy_resource_dir() {
4291        if [ -d "${PBI_CONFDIR}/${PBI_RESOURCE_DIR}" ] ; then
4292                echo "Copying ${PBI_CONFDIR}/${PBI_RESOURCE_DIR} -> ${PBI_STAGEDIR}"
4293                tar cvf - -C ${PBI_CONFDIR}/${PBI_RESOURCE_DIR} --exclude .svn . 2>/dev/null \
4294                | tar xvpf - -C ${PBI_STAGEDIR} 2>/dev/null
4295        fi
4296}
4297
4298# Check if tar supports lzma compression
4299test_tar_lzma() {
4300        touch /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4301        tar cvJf /tmp/.pbilzma.tar.$$ /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4302        _exitcode=$?
4303        rm /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4304        rm /tmp/.pbilzma.tar.$$ >/dev/null 2>/dev/null
4305        return $_exitcode
4306}
4307
4308# Start creating the application archive
4309mk_archive_file() {
4310        # Build module list of excludes
4311        if [ -n "$PBI_EXCLUDELIST" ] ; then
4312                for excl in $PBI_EXCLUDELIST
4313                do
4314                        if [ -z "$_excOpts" ] ; then
4315                                _excOpts="--exclude ${excl}"
4316                        else
4317                                _excOpts="$_excOpts --exclude ${excl}"
4318                        fi
4319                done
4320        fi
4321        PBI_CREATE_ARCHIVE="${PBI_CREATE_OUTDIR}/.PBI.$$.tbz"
4322        if test_tar_lzma ; then _tcmp="J" ; else _tcmp="j" ; fi
4323        echo "Creating compressed archive..."
4324        tar cv${_tcmp}f "${PBI_CREATE_ARCHIVE}" ${_excOpts} -C ${PBI_STAGEDIRMNT} . 2>/dev/null
4325}
4326
4327# Start creating the header archive
4328mk_header_file() {
4329        PBI_HEADER_ARCHIVE="${PBI_CREATE_OUTDIR}/.PBI-header.$$.tbz"
4330        tar cvjf ${PBI_HEADER_ARCHIVE} -C ${PBI_HEADERDIR} . >/dev/null 2>/dev/null
4331}
4332
4333# Start copying pbi details into header file
4334save_pbi_details_to_header() {
4335        local _osArch="$ARCH"
4336        local _osRel="$FBSDREL"
4337        if [ -n "${PBI_OSREL}" ] ; then
4338                _osRel="${PBI_OSREL}"
4339        fi
4340
4341        if [ "${PBI_CREATEONLY}" = "YES" ] ; then
4342                _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
4343                echo "${PBI_APPDIR}/${_pbilow}-${_osArch}" > "${PBI_HEADERDIR}/pbi_defaultpath"
4344        else   
4345                echo "${PBI_PROGDIRPATH}" > "${PBI_HEADERDIR}/pbi_defaultpath"
4346        fi
4347        echo "${PBI_PROGNAME}" > "${PBI_HEADERDIR}/pbi_name"
4348        echo "${PBI_PROGVERSION}" > "${PBI_HEADERDIR}/pbi_version"
4349        echo "${PBI_PROGAUTHOR}" > "${PBI_HEADERDIR}/pbi_author"
4350        echo "${PBI_PROGWEB}" > "${PBI_HEADERDIR}/pbi_web"
4351        date "+%Y%m%d %H%M%S" > "${PBI_HEADERDIR}/pbi_mdate"
4352
4353        if [ "${PBI_REQUIRESROOT}" = "YES" ] ; then
4354                touch ${PBI_HEADERDIR}/pbi_requiresroot
4355        fi
4356
4357        # Do we have a license to accept?
4358        if [ -e "${PBI_CONFDIR}/${PBI_LICENSEFILE}" ] ; then
4359                cp "${PBI_CONFDIR}/${PBI_LICENSEFILE}" "${PBI_HEADERDIR}/${PBI_LICENSEFILE}"
4360        fi
4361
4362        # Do we have a conf-supplied meta-file to copy?
4363        if [ -e "${PBI_CONFDIR}/${PBI_USERMETAFILE}" ] ; then
4364                cp "${PBI_CONFDIR}/${PBI_USERMETAFILE}" "${PBI_HEADERDIR}/${PBI_USERMETAFILE}"
4365        fi
4366        # Do we have a user-supplied meta-file to copy?
4367        if [ -n "$PBI_CREATE_USERMETA" ] ; then
4368                cp "$PBI_CREATE_USERMETA" "${PBI_HEADERDIR}/${PBI_USERMETAFILE}"
4369        fi
4370
4371        # Check for additional meta-data
4372        if [ -n "$PBI_LICENSE" ] ; then
4373                echo "$PBI_LICENSE" > ${PBI_HEADERDIR}/pbi_license
4374        fi
4375        if [ -n "$PBI_TAGS" ] ; then
4376                echo "$PBI_TAGS" > ${PBI_HEADERDIR}/pbi_tags
4377        fi
4378        if [ -n "$PBI_PROGTYPE" ] ; then
4379                echo "$PBI_PROGTYPE" > ${PBI_HEADERDIR}/pbi_type
4380        fi
4381        if [ -n "$PBI_CATEGORY" ] ; then
4382                echo "$PBI_CATEGORY" > ${PBI_HEADERDIR}/pbi_category
4383        fi
4384        if [ -n "$PBI_ICONURL" ] ; then
4385                echo "$PBI_ICONURL" > ${PBI_HEADERDIR}/pbi_iconurl
4386        fi
4387        if [ -n "$PBI_DESC" ] ; then
4388                echo "$PBI_DESC" > ${PBI_HEADERDIR}/pbi_desc
4389        fi
4390        if [ -n "$PBI_SHORTDESC" ] ; then
4391                echo "$PBI_SHORTDESC" > ${PBI_HEADERDIR}/pbi_shortdesc
4392        fi
4393        if [ -n "$PBI_MAINTAINER" ] ; then
4394                echo "$PBI_MAINTAINER" > ${PBI_HEADERDIR}/pbi_maintainer
4395        fi
4396
4397        # Custom install / remove scripts
4398        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREINS}" ] ; then
4399                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREINS}" \
4400                        "${PBI_HEADERDIR}/${MOD_PREINS}"
4401        else
4402                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_PREINS}
4403        fi
4404        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_POSTINS}" ] ; then
4405                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_POSTINS}" \
4406                        "${PBI_HEADERDIR}/${MOD_POSTINS}"
4407        else
4408                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_POSTINS}
4409        fi
4410        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREREM}" ] ; then
4411                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREREM}" \
4412                        "${PBI_HEADERDIR}/${MOD_PREREM}"
4413        else
4414                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_PREREM}
4415        fi
4416
4417        # Copy over our icon
4418        if [ -n "${PBI_PROGICON}" -a -e "${PBI_STAGEDIR}/${PBI_PROGICON}" ] ; then
4419                # Get the file extension
4420                _iconExt=`echo "$PBI_PROGICON" | awk -F . '{print $NF}'`
4421                cp "${PBI_STAGEDIR}/${PBI_PROGICON}" "${PBI_HEADERDIR}/pbi_icon.${_iconExt}" >/dev/null 2>/dev/null
4422        else
4423                _iconExt=`echo "$PBI_DEFAULT_ICON_CHROOT" | awk -F . '{print $NF}'`
4424                cp "${PBI_DEFAULT_ICON_CHROOT}" "${PBI_HEADERDIR}/pbi_icon.${_iconExt}" >/dev/null 2>/dev/null
4425        fi
4426
4427        # Check for any gui images
4428        if [ -e "${PBI_STAGEDIR}/${PBI_GUITOPBANNER}" ] ; then
4429                cp "${PBI_STAGEDIR}/${PBI_GUITOPBANNER}" "${PBI_HEADERDIR}/top-banner.png"
4430        fi
4431        if [ -e "${PBI_STAGEDIR}/${PBI_GUISIDEBANNER}" ] ; then
4432                cp "${PBI_STAGEDIR}/${PBI_GUISIDEBANNER}" "${PBI_HEADERDIR}/side-banner.png"
4433        fi
4434
4435        # Save the uname details
4436        echo "${_osArch}" > "${PBI_HEADERDIR}/pbi_arch"
4437        echo "${_osRel}" > "${PBI_HEADERDIR}/pbi_fbsdver"
4438        echo "${PROGVERSION}" > "${PBI_HEADERDIR}/pbi_createver"
4439
4440        # Get the total number of files in the STAGEDIR
4441        get_filetotal_dir "${PBI_STAGEDIR}"
4442        echo "${FILETOTAL}" > "${PBI_HEADERDIR}/pbi_archivecount"
4443
4444        # Save a checksum of archive file
4445        sha256 -q "${PBI_CREATE_ARCHIVE}" > "${PBI_HEADERDIR}/pbi_archivesum"
4446
4447        sign_pbi_files "$PBI_HEADERDIR"
4448}
4449
4450# Use openssl to sign parts of the pbi header structure and archive
4451sign_pbi_files() {
4452        if [ -z "${PBI_SSLPRIVKEY}" ] ; then return 0 ; fi
4453        _sf="${1}/pbi_archivesum ${1}/${MOD_PREINS} ${1}/${MOD_POSTINS} ${1}/${MOD_PREREM}"
4454        for i in $_sf
4455        do
4456                openssl dgst -sha1 \
4457                        -sign ${PBI_SSLPRIVKEY} \
4458                        -out ${i}.sha1 \
4459                        ${i} >/dev/null 2>/dev/null
4460        done
4461}
4462
4463# All the pieces are ready, spit out the final PBI file
4464mk_output_pbi() {
4465        if [ -n "${PBI_PROGICON}" -a -e "${PBI_STAGEDIR}/${PBI_PROGICON}" ] ; then
4466                icon="${PBI_STAGEDIR}/${PBI_PROGICON}"
4467        else
4468                icon="${PBI_DEFAULT_ICON_CHROOT}"
4469        fi
4470
4471        # Set PBI name all lower-case
4472        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
4473        outfile="${PBI_CREATE_OUTDIR}/${_pbilow}-${PBI_PROGVERSION}-${ARCH}.pbi"
4474
4475        mark1="${PBI_CREATE_OUTDIR}/.pbimark1.$$"
4476        mark2="${PBI_CREATE_OUTDIR}/.pbimark2.$$"
4477        echo "
4478${PBI_SS_ICON}" >$mark1
4479        echo "
4480${PBI_SS_ARCHIVE}" >$mark2
4481
4482
4483        # DO IT, DO IT NOW!!!
4484        cat ${PBI_HEADER_ARCHIVE} $mark1 ${icon} $mark2 ${PBI_CREATE_ARCHIVE} > ${outfile}
4485        sha256 -q ${outfile} > ${outfile}.sha256
4486
4487        echo "Created PBI: ${outfile}"
4488
4489        rm $mark1
4490        rm $mark2
4491        rm ${PBI_HEADER_ARCHIVE}
4492        rm ${PBI_CREATE_ARCHIVE}
4493}
4494
4495get_filetotal_dir() {
4496        FILETOTAL="`find ${1} | wc -l | tr -d ' '`"
4497}
4498
4499pbi_delete_init() {
4500        require_root_or_group
4501        init_tmpdir
4502        parse_delete_pbi_cmdline "$@"
4503        do_pbi_delete
4504}
4505
4506# Delete this PBI
4507do_pbi_delete() {
4508        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4509        PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}"
4510
4511        # Unmount the PBI if its mounted
4512        /usr/pbi/.pbime umount "/usr/pbi/.mounts/`basename $PBI_PROGDIRPATH`"
4513
4514        get_username_from_file "${PBI_DBAPPDIR}/${PBI_DELETENAME}/pbi_name"
4515        if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
4516                exit_err "Permission denied to modify PBI installed by: $FILEUSER"
4517        fi
4518
4519        # Set the dirty flag that we are removing this PBI
4520        touch ${PBI_DBAPPDIR}/${PBI_DELETENAME}/.pbiDeleted
4521
4522        check_preremove_script
4523        run_remove_script
4524        remove_pbidir
4525        unregister_pbi
4526       
4527        # Mark the hashdir as dirty
4528        make_hashdir_dirty
4529}
4530
4531# Save the hash-list to run a cleanup afterwards
4532pbirm_save_hashlist() {
4533        if [ "${PBI_DISABLEHASHDIR}" = "YES" ] ; then return 0 ; fi
4534        if [ -e "${PBI_PROGDIRPATH}/${PBI_HASHLIST}" ] ; then
4535                PBI_TMPHASHLIST="${PBI_TMPDIR}/.pbi-hash.$$"
4536                cp ${PBI_PROGDIRPATH}/${PBI_HASHLIST} ${PBI_TMPHASHLIST}
4537        fi
4538}
4539
4540# Function which removes all empty dirs from the hash-dir
4541pbi_clean_emptyhdirs() {
4542        if [ ! -d "${PBI_HASHDIR}" ] ; then return 0 ; fi
4543        cd ${PBI_HASHDIR}
4544        found="0"
4545        for i in `find . -empty -type d 2>/dev/null`
4546        do
4547                if [ "${i}" = "." ] ; then continue ; fi
4548                if [ -d "${PBI_HASHDIR}/${i}" ] ; then
4549                        rmdir "${PBI_HASHDIR}/${i}"
4550                        found="1"
4551                fi     
4552        done
4553
4554        # Run recursively
4555        if [ "$found" = "1" ];then pbi_clean_emptyhdirs ; fi
4556}
4557
4558# Read through and clean the given hash-list
4559pbi_clean_hashlist() {
4560        if [ -z "${PBI_TMPHASHLIST}" ] ; then return 0 ; fi
4561        while read hl
4562        do
4563                file="`echo $hl | sed 's/:::.*$//g'`"
4564                hash="`echo $hl | sed 's/^.*::://g'`"
4565                tfile="${file}:::${hash}"
4566                if [ -f "${PBI_HASHDIR}/${tfile}" ] ; then
4567                        check_remove_hashfile "${tfile}"
4568                fi
4569
4570        done < ${PBI_TMPHASHLIST}
4571        rm ${PBI_TMPHASHLIST}
4572}
4573
4574# Read through and clean the entire hashdir
4575pbi_clean_hashdir() {
4576        if [ ! -d "${PBI_HASHDIR}" ] ; then return 0 ; fi
4577        echo "Cleaning shared-hash dir..."
4578        cd ${PBI_HASHDIR}
4579        tmphashlist="${PBI_TMPDIR}/.pbi-hashdir.$$"
4580        find * -type f -links 1 > "${tmphashlist}" 2>/dev/null
4581        while read hl
4582        do
4583                if [ ! -f "$hl" -o -h "$hl" ] ; then continue ; fi
4584                if [ -f "${PBI_HASHDIR}/${hl}" ] ; then
4585                        check_remove_hashfile "${hl}"
4586                fi
4587
4588        done < $tmphashlist
4589        rm "$tmphashlist"
4590        pbi_clean_emptyhdirs
4591}
4592
4593# Check if this hash-file is ready to be removed from the hash-dir
4594check_remove_hashfile() {
4595        tfile="${PBI_HASHDIR}/${1}"
4596        get_hard_link_count "${tfile}"
4597        if [ "$HLINKS" = "1" ] ; then
4598                if [ "${PBI_VERBOSE}" = "YES" ] ; then
4599                        echo "Removing unused hashfile: $tfile"
4600                fi
4601                rm -f "${tfile}"
4602        fi
4603}
4604
4605# Run the removal script for this PBI
4606run_remove_script() {
4607        uisc="${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"
4608        if [ ! -e "$uisc" ] ; then return 0 ; fi
4609
4610        # If not running as root, be sure to cleanup path links
4611        if [ "`id -u`" != "0" ]; then
4612                cat ${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT} | grep 'rm "$SYS_LOCALBASE/bin' | sed 's|$SYS_LOCALBASE|${HOME}|g' >${PBI_TMPDIR}/.binlnks
4613                while read lnk
4614                do
4615                        /bin/sh -c "${lnk}"
4616                done <${PBI_TMPDIR}/.binlnks
4617                rm ${PBI_TMPDIR}/.binlnks
4618        fi
4619        export_script_vars
4620        if [ "$PBI_VERBOSE" = "YES" ] ; then
4621                sh "${uisc}"
4622        else
4623                sh "${uisc}" >/dev/null 2>/dev/null
4624        fi
4625}
4626
4627# Function to check the supplied $1 dir for any mounts before we
4628# do a rm -rf
4629umount_before_rm()
4630{
4631        if [ -z "${1}" ] ; then return 0 ; fi
4632
4633        local _ddir="$1"
4634        echo "$_ddir" | rev | grep -q '^/'     
4635        if [ $? -ne 0 ] ; then
4636           _ddir="${_ddir}/"
4637        fi
4638       
4639        mount | grep -q "on ${_ddir}"
4640        if [ $? -ne 0 ] ; then return 0; fi
4641
4642        for i in `mount | grep "on ${_ddir}" | awk '{print $3}'`
4643        do
4644           umount -f ${i} >/dev/null 2>/dev/null
4645           if [ $? -ne 0 ] ; then
4646                exit_err "Could not umount ${i} before rm -rf, bailing!"
4647           fi
4648        done
4649        return 0
4650}
4651
4652# Remove the pbi directory
4653remove_pbidir() {
4654        if [ -z "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi
4655        if [ ! -d "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi
4656        if [ "${PBI_PROGDIRPATH}" = "/" ] ; then return 0 ; fi
4657        if [ "$PBI_VERBOSE" = "YES" ] ; then
4658                echo "Removing: ${PBI_PROGDIRPATH}"
4659        fi
4660
4661        # Make sure we are unmounted
4662        umount_before_rm "${PBI_PROGDIRPATH}"
4663       
4664        rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4665
4666        # Do we have leftovers?
4667        if [ -d "${PBI_PROGDIRPATH}" ] ; then
4668                chflags -R noschg "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4669                chmod -R 777 "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4670                rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4671        fi
4672}
4673
4674# Remove this PBI registration
4675unregister_pbi() {
4676        if [ -z "${PBI_DBAPPDIR}" ] ; then return 0 ; fi
4677        if [ -z "${PBI_DELETENAME}" ] ; then return 0 ; fi
4678        if [ ! -d "${PBI_DBAPPDIR}/${PBI_DELETENAME}" ] ; then return 0 ; fi
4679        if [ "$PBI_VERBOSE" = "YES" ] ; then
4680                echo "Removing: ${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4681        fi
4682        rm -rf "${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4683
4684}
4685
4686# Check if we have a preinstall script we need to use
4687check_preremove_script() {
4688        if [ ! -e "${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}" ] ; then return 0 ; fi
4689
4690        if [ "$PBI_VERBOSE" = "YES" ] ; then
4691                echo "Running pre-removal script: ${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}"
4692        fi
4693        export_script_vars
4694        sh "${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}"
4695}
4696
4697add_app_path_links()
4698{
4699        # If root, run the regular path script
4700        if [ `id -u` = "0" ] ; then
4701                sh "${1}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" >/dev/null 2>/dev/null
4702                return
4703        fi
4704
4705        # Running as user add to ~/bin
4706        init_tmpdir
4707        if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi
4708        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
4709        while read lnk
4710        do
4711                /bin/sh -c "${lnk}"
4712               
4713        done <${PBI_TMPDIR}/.binlnks
4714        rm ${PBI_TMPDIR}/.binlnks
4715       
4716}
4717
4718del_app_path_links()
4719{
4720        # If root, run the regular path script
4721        if [ `id -u` = "0" ] ; then
4722                sh "${1}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >/dev/null 2>/dev/null
4723                return
4724        fi
4725
4726        # Running as user remove from ~/bin
4727        if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi
4728        for lnk in `ls ${1}/${PBI_FAKEBIN_DIR}`
4729        do
4730                if [ "$lnk" = "$PBI_INS_PATHSCRIPT" -o "$lnk" = "$PBI_UNINS_PATHSCRIPT" ]
4731                then
4732                        continue
4733                fi
4734
4735                if [ ! -e "${HOME}/bin/$lnk" ] ; then continue ; fi
4736                if [ ! -h "${HOME}/bin/$lnk" ] ; then continue ; fi
4737                       
4738                ls -al "${HOME}/bin/$lnk" | awk '{print $11}' | grep $1 >/dev/null 2>/dev/null
4739                if [ "$?" = "0" ] ; then
4740                        rm ${HOME}/bin/$lnk
4741                fi
4742        done
4743       
4744}
4745
4746pbi_icon_init() {
4747        parse_icon_pbi_cmdline "$@"
4748       
4749        do_pbi_icon
4750}
4751
4752# Start the PBI icon process
4753do_pbi_icon() {
4754        # Get the dir for this PBI
4755        _appDir=`cat ${PBI_DBAPPDIR}/${PBI_ICONTARGETAPP}/pbi_installedpath`
4756
4757        if [ "${PBI_PATHADD}" = "YES" ] ; then
4758                add_app_path_links "$_appDir"
4759        fi
4760        if [ "${PBI_PATHDEL}" = "YES" ] ; then
4761                del_app_path_links "$_appDir"
4762        fi
4763
4764        if [ "${PBI_DESKADD}" = "YES" ] ; then
4765                if [ ! -e "${_appDir}/.xdg-desktop/${PBI_INS_DESKSCRIPT}" ] ; then
4766                        exit_err "No desktop icons for this PBI"
4767                fi
4768                sh "${_appDir}/.xdg-desktop/${PBI_INS_DESKSCRIPT}"
4769        fi
4770        if [ "${PBI_DESKDEL}" = "YES" ] ; then
4771                if [ ! -e "${_appDir}/.xdg-desktop/${PBI_UNINS_DESKSCRIPT}" ] ; then
4772                        exit_err "No desktop icons for this PBI"
4773                fi
4774                sh "${_appDir}/.xdg-desktop/${PBI_UNINS_DESKSCRIPT}"
4775        fi
4776        if [ "${PBI_MENUADD}" = "YES" ] ; then
4777                require_root_or_group
4778                if [ ! -e "${_appDir}/.xdg-menu/${PBI_INS_MENUSCRIPT}" ] ; then
4779                        exit_err "No menu icons for this PBI"
4780                fi
4781                sh "${_appDir}/.xdg-menu/${PBI_INS_MENUSCRIPT}"
4782        fi
4783        if [ "${PBI_MENUDEL}" = "YES" ] ; then
4784                require_root_or_group
4785                if [ ! -e "${_appDir}/.xdg-menu/${PBI_UNINS_MENUSCRIPT}" ] ; then
4786                        exit_err "No menu icons for this PBI"
4787                fi
4788                sh "${_appDir}/.xdg-menu/${PBI_UNINS_MENUSCRIPT}"
4789        fi
4790        if [ "${PBI_MIMEADD}" = "YES" ] ; then
4791                require_root_or_group
4792                if [ ! -e "${_appDir}/.xdg-mime/${PBI_INS_MIMESCRIPT}" ] ; then
4793                        exit_err "No mime registration for this PBI"
4794                fi
4795                sh "${_appDir}/.xdg-mime/${PBI_INS_MIMESCRIPT}"
4796        fi
4797        if [ "${PBI_MIMEDEL}" = "YES" ] ; then
4798                require_root_or_group
4799                if [ ! -e "${_appDir}/.xdg-mime/${PBI_UNINS_MIMESCRIPT}" ] ; then
4800                        exit_err "No mime registration for this PBI"
4801                fi
4802                sh "${_appDir}/.xdg-mime/${PBI_UNINS_MIMESCRIPT}"
4803        fi
4804}
4805
4806pbid_init() {
4807        require_root
4808
4809        parse_pbid_cmdline "$@"
4810
4811        do_pbid
4812}
4813
4814# This is a crude hack, but we need to copy libGL* to a location outside
4815# of /usr/local for PBIs to be able to access them
4816check_populate_opengl()
4817{
4818  local lG
4819  for i in `ls /usr/local/lib/libGl.* /usr/local/lib/libGL.* /usr/local/lib/libGLU.* 2>/dev/null`
4820  do
4821    lG=`basename $i`
4822    cp ${i} /usr/lib/${lG}
4823  done
4824}
4825
4826# Start the PBID daemon
4827do_pbid() {
4828
4829        # Start by sourcing /etc/profile
4830        # This grabs any HTTP_ / FTP_ PROXY variables
4831        . /etc/profile
4832
4833        # Allow user supplied logfile
4834        if [ -z "${PBID_LOGFILE}" ] ; then
4835          _pbid_log="/var/log/pbid.log"
4836        else
4837          _pbid_log="${PBID_LOGFILE}"
4838        fi
4839
4840        # Set verbosity
4841        _redir="&1"
4842        if [ "${PBI_VERBOSE}" != "YES" ] ; then _redir="/dev/null" ; fi
4843        echo "Started pbid: `date`" > ${_pbid_log}
4844
4845        # Check for opengl libs to link
4846        check_populate_opengl
4847
4848        while
4849        i=1
4850        do
4851                # Do regular sleeps
4852                qslp=0
4853
4854                # Check if we have any out of date index files to update
4855                for _dbIndex in `ls ${PBI_DBREPODIR}`
4856                do
4857                        _iMd5=`echo ${_dbIndex} | cut -d '.' -f 2`
4858                        check_update_index "${_iMd5}"
4859
4860                        # If we failed to get an index try again sooner
4861                        # This is useful if the user has just installed and has not setup
4862                        # the network yet. We want to fetch indexes quickly after net
4863                        # comes up so they dont need to wait 15 min or whatever its set to
4864                        if [ ! -e "${PBI_DBINDEXDIR}/${_iMd5}-index" ] ; then qslp=1; fi
4865                done
4866
4867                # Check if we have a dirty hash-dir to cleanup
4868                check_clean_hashdir "$_pbid_log" "$_redir"
4869
4870                # Check if we have any PBIs to auto-update
4871                check_autoupdate_pbis "$_pbid_log" "$_redir"
4872
4873                # Check if we need to merge files into the hashdir
4874                if [ -n "`ls ${PBI_DBHASHQUEUEDIR}`" ] ; then
4875                        init_tmpdir
4876                        for _hpbi in `ls ${PBI_DBHASHQUEUEDIR}`
4877                        do
4878                                if [ ! -e "${PBI_DBAPPDIR}/${_hpbi}/pbi_installedpath" ] ; then
4879                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4880                                        continue
4881                                fi
4882
4883                                _hpbipath=""
4884                                _hpbipath=`cat ${PBI_DBAPPDIR}/${_hpbi}/pbi_installedpath`
4885                                if [ ! -e "${_hpbipath}/${PBI_HASHLIST}" ] ; then
4886                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4887                                        continue
4888                                fi
4889
4890                                # Get the username this PBI was installed as
4891                                get_username_from_file "${_hpbipath}"
4892
4893                                # Lets start this hash merge
4894                                echo "Adding ${_hpbipath} to hash-dir ($FILEUSER): `date`" >> ${_pbid_log}
4895
4896                                if [ "$FILEUSER" = "root" ];then
4897                                        pbi_add_update_hashdir "${_hpbipath}" "${PBI_DBAPPDIR}/${_hpbi}/.pbiDeleted" >${_redir} 2>${_redir}
4898                                else
4899                                        # Run hashdir command as a user
4900                                        su $FILEUSER -c "pbi_update_hashdir \"${_hpbipath}\" \"${PBI_DBAPPDIR}/${_hpbi}/.pbiDeleted\"" >${_redir} 2>${_redir}
4901                                fi
4902                                echo "Finished adding ${_hpbipath} to hash-dir: `date`" >> ${_pbid_log}
4903                               
4904                                # Now remove the trigger file
4905                                rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4906
4907                        done
4908                        rm_tmpdir
4909
4910                fi
4911               
4912                # Check if we should rotate the logfile
4913                _pbidLines=`wc -l ${_pbid_log} | awk '{ print $1 }'`
4914                if [ $(is_num "$_pbidLines") ] ; then
4915                        if [ $_pbidLines -gt $PBI_LOG_LINES ] ; then
4916                                echo "Logfile turnover: `date`" >${_pbid_log}
4917                        fi
4918                fi
4919               
4920
4921                # Done with our check, lets go back to sleep now
4922                if [ $qslp -eq 1 ] ; then
4923                        sleep 60
4924                else
4925                        sleep ${PBIDSLEEP}
4926                fi
4927        done
4928
4929}
4930
4931# Check if there are any PBIs which are flagged for auto-updates
4932check_autoupdate_pbis() {
4933
4934        for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
4935        do
4936                if [ ! -e "${PBI_DBAPPDIR}/${i}/autoupdate-enable" ] ; then
4937                        continue
4938                fi
4939
4940                # Check if this app is already updating
4941                if [ -e "${PBI_DBAPPDIR}/${i}/.updating" ] ; then
4942                        ps -p `cat ${PBI_DBAPPDIR}/${i}/.updating` >/dev/null 2>/dev/null
4943                        if [ "$?" != "0" ] ; then
4944                                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
4945                        else
4946                                continue
4947                        fi
4948                fi
4949
4950                # Found an auto-update enabled APP, see if it needs upping
4951                PBI_UPDATEAPP="$i"
4952
4953                # Load the details about this app
4954                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4955                if [ -z "${PBI_REPO}" ]; then
4956                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4957                fi
4958                if [ -z "${PBI_REPO}" ]; then continue ; fi
4959                local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
4960
4961                # Does this need an update?
4962                check_pbi_update "$PBI_UPDATEAPP" "nodisplay" \
4963                        "$PBI_PROGNAME" "current" \
4964                        "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
4965                if [ "$?" != "0" ] ; then
4966                        continue
4967                fi
4968               
4969                # Get the username this PBI was installed as
4970                get_username_from_file "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4971
4972                # Its Update Time!
4973                echo "Starting Auto-Update of ${PBI_UPDATEAPP} ($FILEUSER): `date`" >>${_pbid_log}
4974
4975                su ${FILEUSER} -c "pbi_update ${PBI_UPDATEAPP}" >>${_pbid_log} 2>>${_pbid_log}
4976                if [ "$?" = "0" ] ; then
4977                        echo "Success! Update of ${PBI_UPDATEAPP}: `date`" >>${_pbid_log}
4978                else
4979                        echo "Failed! Update of ${PBI_UPDATEAPP}: `date`" >>${_pbid_log}
4980                fi
4981
4982                rm "${PBI_DBAPPDIR}/${i}/.updating" >/dev/null 2>/dev/null
4983        done
4984}
4985
4986check_clean_hashdir() {
4987        if [ ! -e "${PBI_DBDIRTYFILE}" ] ; then return ; fi
4988
4989        # Get the date of the last hash-cleaning done
4990        local _curDate="`cat ${PBI_DBDIRTYFILE}`"
4991        if [ -e "${PBI_DBDIRTYFILE}.last" ] ; then
4992                local _lastDate="`cat ${PBI_DBDIRTYFILE}.last`"
4993        else
4994                local _lastDate="0"
4995        fi
4996
4997        # See if we have a new date trigger to do a cleaning
4998        if [ "$_curDate" = "${_lastDate}" ]; then return; fi
4999
5000        # Loop through and clean any hash-dirs as the appropriate user
5001        for cHdir in `ls -d ${PBI_HASHDIR}*`
5002        do
5003                get_username_from_file "${cHdir}"
5004                echo "Cleaning hash-dir ($FILEUSER): `date`" >> ${1}
5005                su ${FILEUSER} -c "pbi_delete --clean-hdir" >>${2} 2>>${2}
5006                echo "Finished cleaning hash-dir ($FILEUSER): `date`" >> ${1}
5007                echo "$_curDate" > ${PBI_DBDIRTYFILE}.last 2>/dev/null
5008        done
5009}
5010
5011pbi_info_init() {
5012        parse_info_pbi_cmdline "$@"
5013       
5014        do_pbi_info
5015}
5016
5017# Display information on the PBI / PBIs
5018do_pbi_info() {
5019
5020        # If we are listing available PBIs via the index file
5021        if [ "$PBI_INFOINDEX" = "YES" ] ; then
5022               
5023                # List the available PBIs from the index
5024                do_index_listing
5025               
5026                exit_trap
5027        fi
5028
5029        if [ "$PBI_INFONAME" = "--ALL--" ] ; then
5030                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5031                do
5032                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5033                                if [ "$PBI_VERBOSE" = "YES" ] ; then
5034                                        load_info_from_dir "${PBI_DBAPPDIR}/${i}"
5035                                        get_username_from_file "${PBI_DBAPPDIR}/${i}"
5036                                        PBI_INSTALLED_BY=$FILEUSER
5037                                        pbi_display_info
5038                                        pbi_display_gui "${PBI_DBAPPDIR}/${i}" ""
5039                                        echo " "
5040                                else
5041                                        echo "${i}"
5042                                fi
5043                        fi
5044                done
5045        else
5046                # Start loading our variables
5047                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_INFONAME}"
5048                get_username_from_file "${PBI_DBAPPDIR}/${PBI_INFONAME}"
5049                PBI_INSTALLED_BY=$FILEUSER
5050                pbi_display_info
5051        fi
5052}
5053
5054# Read through the master index file and provide listing of available PBIs for installation
5055do_index_listing()
5056{
5057        # Make sure we have a master index
5058        ls ${PBI_DBINDEXDIR}/* >/dev/null 2>/dev/null
5059        if [ "$?" != "0" ] ; then return ; fi
5060
5061        for _rIndex in `ls ${PBI_DBINDEXDIR}/*index* | grep -v '.time'`
5062        do
5063                _rMd5=`basename ${_rIndex} | sed 's|-index||g'`
5064                _rDesc=`cat ${PBI_DBREPODIR}/*.${_rMd5} | grep 'Desc: ' | sed 's|Desc: ||g'`
5065                echo "Current and available PBIs. * = current"
5066                echo "Repository: $_rDesc"
5067                echo "----------------------------------------------------------------"
5068
5069                sort "${_rIndex}" | while read _iLine
5070                do
5071                        PBI_UPNAME="`echo $_iLine | cut -d ':' -f 1`"
5072                        PBI_UPARCH="`echo $_iLine | cut -d ':' -f 2`"
5073                        PBI_UPNVER="`echo $_iLine | cut -d ':' -f 3`"
5074                        PBI_UPSTATUS="`echo $_iLine | cut -d ':' -f 9`"
5075                        pad_var "${PBI_UPNAME}" "30"
5076                        PBI_UPNAME="${PAD_VAR}"
5077                        pad_var "${PBI_UPNVER}" "15"
5078                        PBI_UPNVER="${PAD_VAR}"
5079                        pad_var "${PBI_UPARCH}" "6"
5080                        PBI_UPARCH="${PAD_VAR}"
5081       
5082                        if [ "$PBI_UPSTATUS" = "current" ] ; then
5083                                echo "$PBI_UPNAME   $PBI_UPNVER $PBI_UPARCH *"
5084                        fi
5085                        if [ "$PBI_UPSTATUS" = "active" ] ; then
5086                                echo "$PBI_UPNAME   $PBI_UPNVER $PBI_UPARCH"
5087                        fi
5088                done
5089        done
5090
5091}
5092
5093# Function to pad a variable to X spaces
5094pad_var() {
5095        local _pVar="$1"
5096        local _pNum="$2"
5097        PAD_VAR="`echo \"$_pVar                                                                                    x\" | cut -c 1-$_pNum`"
5098}
5099
5100# Checks if we have a custom script to run prior to port make
5101run_pbi_preportmake()
5102{
5103        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5104        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5105        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-portmake.sh" ] ; then return 0 ; fi
5106
5107        export_script_vars
5108
5109        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-portmake.sh"
5110        if [ "$?" != "0" ] ; then
5111                exit_err "pre-portmake.sh failed!"
5112        fi
5113}
5114
5115# Checks if we have a custom script to run prior to port make
5116run_pbi_postportmake()
5117{
5118        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5119        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5120        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/post-portmake.sh" ] ; then return 0 ; fi
5121
5122        export_script_vars
5123
5124        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/post-portmake.sh"
5125        if [ "$?" != "0" ] ; then
5126                echo "Warning: post-portmake.sh returned non-0 status!"
5127        fi
5128}
5129
5130# Checks if we have a custom script to run prior to pbi create
5131run_pbi_prepkgscript()
5132{
5133        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5134        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5135        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-pbicreate.sh" ] ; then return 0 ; fi
5136
5137        export_script_vars
5138
5139        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-pbicreate.sh"
5140        if [ "$?" != "0" ] ; then
5141                echo "Warning: post-portmake.sh returned non-0 status!"
5142        fi
5143}
5144
5145# Begins the port make
5146start_pbi_makeport()
5147{
5148        do_port_build "${PBI_MAKEPORT}"
5149}
5150
5151# Prune any ports which aren't required for runtime
5152start_pbi_prune_ports()
5153{
5154        if [ "${PBI_PRUNEBUILDPORTS}" = "NO" ] ; then return ; fi
5155
5156        get_pkgname "${PBI_MAKEPORT}"
5157        echo "${PKGNAME}" > /.keepports
5158        make -C "${PORTSDIR}/${PBI_MAKEPORT}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5159
5160        # Do the same for any OTHERPORTS
5161        for port in ${PBI_MKPORTBEFORE}
5162        do
5163                if [ ! -d "${PORTSDIR}/${port}" ] ; then continue ; fi
5164                get_pkgname "${port}"
5165                echo "${PKGNAME}" >> /.keepports
5166                make -C "${PORTSDIR}/${port}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5167        done
5168
5169        for port in ${PBI_MKPORTAFTER}
5170        do
5171                if [ ! -d "${PORTSDIR}/${port}" ] ; then continue ; fi
5172                get_pkgname "${port}"
5173                echo "${PKGNAME}" >> /.keepports
5174                make -C "${PORTSDIR}/${port}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5175        done
5176
5177        # Don't strip out pkgng
5178        pkg info pkg >> /.keepports
5179       
5180        # Sort and clean the ports
5181        cat /.keepports | sort | uniq > /.keepports.tmp
5182        mv /.keepports.tmp /.keepports
5183
5184        # Now remove any unused ports
5185        for j in `pkg info -a | cut -d " " -f 1`
5186        do
5187                grep -q "^${j}" "/.keepports"
5188                if [ $? -ne 0 ] ; then
5189                        echo "Removing non-required port: ${j}"
5190                        $PKG_DELETE ${j} 
5191                fi
5192        done
5193}
5194
5195# Get the full package-name for a target port
5196get_pkgname() {
5197        name="`pkg info -O ${1} | awk '{print $1}'`"
5198        PKGNAME="${name}"
5199}
5200
5201# Make any additional required ports
5202start_pbi_mkportbefore()
5203{
5204        if [ -z "${PBI_MKPORTBEFORE}" ] ; then return ; fi
5205       
5206        for port in ${PBI_MKPORTBEFORE}
5207        do
5208                if [ ! -d "/usr/ports/${port}" ] ; then
5209                        exit_err "/usr/ports/${port} does not exist!"
5210                fi
5211                do_port_build "${port}"
5212        done
5213
5214}
5215
5216# Make any additional required ports
5217start_pbi_mkportafter()
5218{
5219        if [ -z "${PBI_MKPORTAFTER}" ] ; then return ; fi
5220       
5221        for port in ${PBI_MKPORTAFTER}
5222        do
5223                if [ ! -d "/usr/ports/${port}" ] ; then
5224                        exit_err "/usr/ports/${port} does not exist!"
5225                fi
5226                do_port_build "${port}"
5227        done
5228
5229}
5230
5231# Start pbi_update_hashdir
5232pbi_update_hashdir_init() {
5233        pbi_add_update_hashdir "$1" "$2"
5234}
5235
5236# Start pbi_update processing
5237pbi_update_init() {
5238
5239        parse_update_pbi_cmdline "$@"
5240
5241        check_enable_disable_auto
5242
5243        # Stop here if we are just enabling / disabling auto-update
5244        if [ -n "$PBI_UPENABLEAUTO" ] ; then return 0 ; fi
5245
5246        start_update_checks
5247        if [ "$?" != "0" ] ; then rm_tmpdir ; exit 1 ; fi
5248
5249        # Stop here if only doing update checks
5250        if [ -n "${PBI_UPCHECK}" ]; then return 0 ; fi
5251
5252        require_root_or_group
5253
5254        do_pbi_update
5255}
5256
5257# Check if we are enabling / disabling auto-updating
5258check_enable_disable_auto()
5259{
5260        if [ -z "$PBI_UPENABLEAUTO" ] ; then return ; fi
5261        if [ ! -d "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}" ] ; then return ; fi
5262
5263        # Enable / disable auto-updating now
5264        if [ "$PBI_UPENABLEAUTO" = "YES" ]; then
5265                touch ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable
5266        else
5267                rm ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable >/dev/null 2>/dev/null
5268        fi
5269}
5270
5271# Function which checks the digital signature of a PBI to match it to a particular repo
5272pbi_checksig_repomatch() {
5273        if [ `id -u` != "0" ] ; then return ; fi
5274
5275        # See which repo / key this PBI associates to, if any
5276        check_valid_sigs "${1}"
5277        if [ "$?" = "0" -a -n "$PBI_VALIDKEYSIG" ] ; then
5278                _rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"
5279                echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${1}/pbi_repo
5280        fi
5281}
5282
5283# See if we are checking for updates and do it
5284start_update_checks() {
5285        if [ "${PBI_UPCHECK}" != "YES" -a "${PBI_UPCHECK}" != "ALL" ]; then return 0; fi
5286
5287        # Open up the tmpdir
5288        init_tmpdir
5289
5290        if [ "${PBI_UPCHECK}" = "YES" ] ; then
5291                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5292                if [ -z "${PBI_REPO}" ]; then
5293                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5294                fi
5295                if [ -z "${PBI_REPO}" ]; then
5296                        return 1
5297                else
5298                        local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5299                fi
5300
5301                check_pbi_update "$PBI_UPDATEAPP" "display" \
5302                 "$PBI_PROGNAME" "current" \
5303                 "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5304                return $?
5305        else
5306                # Loop and check all PBIs for updates
5307                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5308                do
5309                        PBI_REPO=""
5310                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5311                                load_info_from_dir "${PBI_DBAPPDIR}/${i}"
5312                                if [ -z "${PBI_REPO}" ]; then
5313                                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${i}"
5314                                fi
5315                                if [ -z "${PBI_REPO}" ]; then
5316                                        continue
5317                                else
5318                                        local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5319                                fi
5320
5321                                check_pbi_update "$i" "display" \
5322                                 "$PBI_PROGNAME" "current" \
5323                                 "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5324                        fi
5325                done
5326                return 0
5327        fi
5328
5329}
5330
5331# Check if we need to pull down the updated INDEX file
5332check_update_index() {
5333
5334        init_tmpdir
5335       
5336        local _repoMd5="$1"
5337        local _rURL=`cat ${PBI_DBREPODIR}/*${_repoMd5} | grep URL: | sed 's|URL: ||g'`
5338
5339        _pbiIndex="${PBI_DBINDEXDIR}/${_repoMd5}-index"
5340        _pbiMeta="${PBI_DBINDEXDIR}/${_repoMd5}-meta"
5341        _pbiIndexTime="${_pbiIndex}.time"
5342        _tmpPbiIndex="${PBI_TMPDIR}/.upcheck$$"
5343        _tmpPbiMeta="${PBI_TMPDIR}/.upcheck$$"
5344               
5345        # Check if its been greater than $PBI_INDEXREFRESH hours since the last update
5346        if [ -e "${_pbiIndexTime}" ] ; then
5347                _curTime=`date +%s`
5348                _oTime=`cat ${_pbiIndexTime}`
5349                _trigTime=`expr ${PBI_INDEXREFRESH} \* 60 \* 60`
5350                expr $_curTime - $_oTime >/dev/null 2>/dev/null
5351                if [ "$?" = "0" ] ; then
5352                        _passed=`expr $_curTime - $_oTime`
5353                        if [ "$_passed" -lt "$_trigTime" ] ; then
5354                                return;
5355                        fi
5356                fi
5357               
5358        fi
5359
5360        if [ "${PBI_VERBOSE}" = "YES" ] ; then
5361                echo "Updating index ${_pbiIndex}"
5362                echo "Updating index ${_pbiIndex}: `date`" >> ${_pbid_log}
5363        fi
5364
5365        # Check that the last char isn't a '/'
5366        _tmp=`echo ${_rURL} | wc -m | tr -s ' ' | tr -d ' '`
5367        _tmp2=`expr $_tmp - 1`
5368        _lastC=`echo ${_tmp} | cut -c ${_tmp2}-${_tmp}`
5369        if [ "${_lastC}" = "/" ] ; then
5370                _upURL="`echo ${_rURL} | sed 's|\(.*\).|\1|'`"
5371        else
5372                _upURL="${_rURL}"
5373        fi
5374
5375        fetch -o "${_tmpPbiIndex}.bz2" "${_upURL}/${PBI_INDEXUPFILE}.bz2" >/dev/null 2>/dev/null
5376        if [ "$?" != "0" ] ; then
5377                return
5378        fi
5379
5380        bzip2 -d "${_tmpPbiIndex}.bz2" >/dev/null 2>/dev/null
5381        if [ "$?" != "0" ] ; then
5382                return
5383        fi
5384
5385        # Move the uncompressed file
5386        mv "${_tmpPbiIndex}" "${_pbiIndex}" >/dev/null 2>/dev/null
5387
5388        # Wait a sec
5389        sleep 1
5390
5391        # Now check for an optional meta file update
5392        fetch -o "${_tmpPbiMeta}.bz2" "${_upURL}/${PBI_METAUPFILE}.bz2" >/dev/null 2>/dev/null
5393        if [ "$?" = "0" ] ; then
5394                bzip2 -d "${_tmpPbiMeta}.bz2" >/dev/null 2>/dev/null
5395                if [ "$?" = "0" ] ; then
5396                        mv "${_tmpPbiMeta}" "${_pbiMeta}" >/dev/null 2>/dev/null
5397                fi
5398        fi
5399
5400        # Update the icons for this repos meta file
5401        update_repo_icons "${_repoMd5}" "${_pbiMeta}"
5402
5403        echo "Finished updating index ${_pbiIndex}: `date`" >> ${_pbid_log}
5404        if [ "${PBI_VERBOSE}" = "YES" ] ; then
5405                echo "Finished updating index ${_pbiIndex}"
5406        fi
5407
5408        # Save the time that we are done
5409        date +%s > ${_pbiIndexTime}
5410
5411}
5412
5413# Check if we need to update any repository icons
5414update_repo_icons() {
5415        _repoMd5="$1"
5416        _repoMeta="$2"
5417
5418        echo "Updating meta-icons for $_repoMeta: `date`" >> ${_pbid_log}
5419
5420        # Loop through, downloading icons we find
5421        while read mLine
5422        do
5423                # Make sure this is an app / cat
5424                echo "$mLine" | grep -e "^App=" -e "^Cat=" >/dev/null 2>/dev/null
5425                if [ "$?" != "0" ] ; then continue ; fi
5426
5427                # Get the icon URL
5428                echo "$mLine" | grep "^App=" >/dev/null 2>/dev/null
5429                if [ "$?" = "0" ] ; then
5430                        line=`echo $mLine | sed 's|^App=||g'`
5431                        aIcon=`echo $line | cut -d ';' -f 3`
5432                else
5433                        line=`echo $mLine | sed 's|^Cat=||g'`
5434                        aIcon=`echo $line | cut -d ';' -f 2`
5435                fi
5436                iName=`echo $line | cut -d ';' -f 1`
5437                ext=`echo $aIcon | sed 's/.*\.//'`
5438       
5439                # If we already have this icon, we can skip
5440                if [ -e "${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}" ] ; then
5441                        continue
5442                fi
5443
5444                # Now fetch the file
5445                sFile="${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}"
5446                fetch -o "${sFile}" "${aIcon}" >/dev/null 2>/dev/null
5447                if [ $? -ne 0 ]; then
5448                  # Wait a moment before trying the next
5449                  sleep 40
5450                fi
5451               
5452        done < ${_repoMeta}
5453}
5454
5455# Check a specific PBI for updates
5456check_pbi_update() {
5457
5458        # Init the tmpdir
5459        init_tmpdir
5460
5461        # Set the vars
5462        _upbi="${1}"
5463        _udisp="${2}"
5464        _uprog="${3}"
5465        _uver="${4}"
5466        _ufbsdver="${5}"
5467        _uarch="${6}"
5468        _urepo="${7}"
5469        _omdate="${8}"
5470
5471        _uprog="`echo ${_uprog} | tr -d ' '`"
5472        appname="`echo ${_uprog} | tr '[:lower:]' '[:upper:]'`"
5473
5474        PBI_UPNVER=""
5475        PBI_UPFILE=""
5476        PBI_UPPATCHES=""
5477        PBI_UPCSUM=""
5478        PBI_UPMDATE=""
5479        PBI_UPREPO=""
5480        PBI_UPSIZE=""
5481
5482        # If we are looking for the current app, set _uver accordingly
5483        if [ "$_uver" = "current" ] ; then
5484                _uver=":current"
5485        else
5486                _uver=":${_uver}:"
5487        fi
5488
5489
5490        for _repo in `ls ${PBI_DBINDEXDIR}`
5491        do
5492
5493                if [ "$_urepo" = "AUTO" ] ; then
5494                        _pbiIndex="${PBI_DBINDEXDIR}/${_repo}"
5495                        _rMd5="`echo ${_repo} | sed 's|-index||g'`"
5496                else
5497                        _rMd5=`ls ${PBI_DBREPODIR}/${_urepo}.* | cut -d '.' -f 2`
5498                        _pbiIndex="${PBI_DBINDEXDIR}/${_rMd5}-index"
5499                fi
5500
5501                if [ ! -e "${_pbiIndex}" ] ; then continue ; fi
5502
5503                # Search the update index for the specified PBI
5504                _upLine=`grep -i -e "^$_uprog:" ${_pbiIndex} | grep ":$_uarch:" | grep "$_uver" | head -n 1`
5505
5506                PBI_UPNVER="`echo $_upLine | cut -d ':' -f 3`"
5507                PBI_UPFILE="`echo $_upLine | cut -d ':' -f 6`"
5508                PBI_UPPATCHES="`echo $_upLine | cut -d ':' -f 8`"
5509                PBI_UPCSUM="`echo $_upLine | cut -d ':' -f 4`"
5510                PBI_UPMDATE="`echo $_upLine | cut -d ':' -f 5`"
5511                PBI_UPSIZE="`echo $_upLine | cut -d ':' -f 8`"
5512                PBI_UPMIRROR="`cat ${PBI_DBMIRRORDIR}/${_rMd5} 2>/dev/null`"
5513                PBI_UPREPO="${_rMd5}"
5514
5515                if [ -n "${PBI_UPNVER}" ] ; then break; fi
5516                if [ "${_urepo}" != "AUTO" ] ; then break; fi
5517
5518        done
5519
5520        # If no new version
5521        if [ -z "$PBI_UPNVER" ] ; then return 1 ; fi
5522
5523        # See if this update is newer than the installed date
5524        if [ -n "$_omdate" ] ; then
5525                nDay=`echo $PBI_UPMDATE | cut -d ' ' -f 1`
5526                nHour=`echo $PBI_UPMDATE | cut -d ' ' -f 2`
5527                oDay=`echo $_omdate | cut -d ' ' -f 1`
5528                oHour=`echo $_omdate | cut -d ' ' -f 2`
5529         
5530                # Make sure we have all legit numbers
5531                if [ $(is_num "$nDay") -a $(is_num "$nHour") \
5532                        -a $(is_num "$oDay") -a $(is_num "$oHour") ] ; then
5533                        if [ $oDay -gt $nDay ] ; then return 1 ; fi
5534                        if [ "$oDay" = "$nDay" -a $oHour -gt $nHour ] ; then return 1 ; fi
5535                fi
5536        fi
5537
5538        if [ "$PBI_UPNVER" != "$PBI_PROGVERSION" ] ; then
5539                if [ "$_udisp" = "display" ] ; then
5540                        echo "${_upbi} - Available: ${PBI_UPNVER}"
5541                fi
5542                return 0
5543        else
5544                return 1
5545        fi
5546}
5547
5548# Start PBI update process
5549do_pbi_update() {
5550        if [ -n "${PBI_UPCHECK}" ]; then return 0 ; fi
5551
5552        if [ "$PBI_UPDATEAPP" = "ALL" ] ; then
5553                # Loop and check all PBIs for updates
5554                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5555                do
5556                        if [ -e "${PBI_DBAPPDIR}/${i}/.updating" ] ; then
5557                                ps -p `cat ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating` >/dev/null 2>/dev/null
5558                                if [ "$?" = "0" ] ; then
5559                                        continue
5560                                fi
5561                                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5562                        fi
5563                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5564                                PBI_UPDATEAPP="${i}"
5565                                start_pbi_updateapp "all"
5566                        fi
5567                done
5568        else
5569                if [ -e "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" ] ; then
5570                        ps -p `cat ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating` >/dev/null 2>/dev/null
5571                        if [ "$?" = "0" ] ; then
5572                                exit_err "This application is currently updating."
5573                        fi
5574                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5575                fi
5576                start_pbi_updateapp "single"
5577                exit $?
5578        fi
5579}
5580
5581# Attempt to download a PBI from the update server for "pbi_add -r"
5582pbi_add_fetch_remote() {
5583        # Set the target program we want to download
5584        _rtar="$PBI_FILENAME"
5585        unset PBI_FILENAME
5586
5587        # Check if the user overrode the arch / versions we want to install
5588        _rArch=`uname -m`
5589        if [ -n "$PBI_ADD_ALTARCH" ] ; then _rArch=$PBI_ADD_ALTARCH ; fi
5590
5591        _rVer="current"
5592        if [ -n "$PBI_ADD_ALTVER" ] ; then _rVer=$PBI_ADD_ALTVER ; fi
5593
5594        check_pbi_update "$_rtar" "nodisplay" \
5595         "$_rtar" "$_rVer" \
5596         "$FBSDMAJOR" "$_rArch" "${PBI_ADDREPO_ID}"
5597        if [ "$?" != "0" ] ; then 
5598                # If we are on amd64, do a fallback check to i386 for this PBI
5599                # This catches apps like wine / skype and others
5600                if [ "$_rArch" = "amd64" ] ; then
5601                        _rArch="i386"
5602                        check_pbi_update "$_rtar" "nodisplay" \
5603                        "$_rtar" "$_rVer" \
5604                        "$FBSDMAJOR" "$_rArch" "${PBI_ADDREPO_ID}"
5605                        if [ "$?" != "0" ] ; then
5606                                exit_err "Could not find \"$_rtar\" in any indexes" 
5607                        fi
5608                else
5609                        exit_err "Could not find \"$_rtar\" in any indexes" 
5610                fi
5611        fi
5612
5613        # We've gotten this far, now download the updated PBI
5614        pbi_update_dl
5615        if [ "$?" != "0" ] ; then
5616                exit_err "Failed downloading PBI"
5617        fi
5618
5619        # Now overwrite the PBI_FILENAME and let us proceed to regular install
5620        PBI_FILENAME="$PBI_UPDLFILE"
5621
5622        # If we are only fetching, finish up now
5623        if [ "$PBI_REMOTEFETCHONLY" = "YES" ] ; then
5624                mv $PBI_FILENAME ./`basename ${PBI_UPFILE}`
5625                echo "PBI saved to ./`basename ${PBI_UPFILE}`"
5626                exit_trap
5627        fi
5628
5629}
5630
5631# Update the targed PBI
5632start_pbi_updateapp() {
5633        _upact="${1}"
5634        if [ "$2" = "pbid" ] ; then
5635                _pbidlog="$2"
5636        else
5637                _pbidlog=""
5638        fi
5639
5640        echo "$$" > "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5641
5642        # Check for update to this app, and exit or return if not available
5643        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5644        if [ -z "${PBI_REPO}" ]; then
5645                pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5646        fi
5647        if [ -z "${PBI_REPO}" ]; then
5648                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5649                return 1
5650        else
5651                local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5652        fi
5653
5654        check_pbi_update "$PBI_UPDATEAPP" "nodisplay" \
5655         "$PBI_PROGNAME" "current" \
5656         "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5657        if [ "$?" != "0" ] ; then
5658                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5659                if [ "$_upact" = "single" ] ; then
5660                        exit_err "$PBI_UPDATEAPP - no update available!"
5661                else
5662                        return 1
5663                fi
5664        fi
5665       
5666       
5667        echo "Starting update of ${PBI_UPDATEAPP} to ${PBI_UPNVER}..."
5668        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
5669
5670        # Check if there is a possible patch file for this update
5671        # new filename to download
5672        _pFile="${_pbilow}-${PBI_PROGVERSION}_to_${PBI_UPNVER}-${PBI_APPARCH}.pbp"
5673
5674        # Try downloading the patch file
5675        echo "Trying update via patchfile..."
5676        pbi_update_dl "$_pFile" "OFF"
5677        if [ "$?" = "0" ] ; then
5678                # We had a good patch download, try applying it now
5679                echo "Updating via patch file..."
5680                pbi_patch "$PBI_UPDLFILE" #>/dev/null 2>/dev/null
5681                if [ "$?" != "0" ] ; then
5682                        # Patching failed, we'll grab a fresh copy next
5683                        echo "Failed to patch with ${_pFile}"
5684                        echo "Will try full file update"
5685                else
5686                        echo "Patch successful!"
5687                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" >/dev/null 2>/dev/null
5688                        rm "${PBI_UPDLFILE}" >/dev/null 2>/dev/null
5689                        return 0
5690                fi
5691                       
5692        fi
5693
5694        # No patch file, grab the full app
5695        echo "Trying update via full-file..."
5696        pbi_update_dl
5697        if [ "$?" != "0" ] ; then
5698                if [ "$_upact" = "single" ] ; then
5699                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5700                        exit_err "Failed downloading update!"
5701                fi
5702        fi
5703
5704        echo " "
5705
5706        # Save the auto-update status
5707        if [ -e "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable" ] ; then
5708                _autoUpEnable="YES"
5709        else
5710                _autoUpEnable="NO"
5711        fi
5712       
5713        echo -e "Removing old version...\c"
5714        pbi_delete "${PBI_UPDATEAPP}"
5715        echo "Done"
5716
5717        # Now install new PBI
5718        echo -e "Installing new version...\c"
5719        pbi_add --licagree -f "$PBI_UPDLFILE" >/dev/null 2>/dev/null
5720        if [ "$?" != "0" ] ; then
5721                echo "Failed to install PBI: ${PBI_UPDLFILE}"
5722                rm "${PBI_UPDLFILE}"
5723                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" 2>/dev/null
5724                return 1
5725        else
5726                if [ "$_autoUpEnable" = "YES" ] ; then
5727                        touch "${PBI_DBAPPDIR}/${_pbilow}-${PBI_UPNVER}-${PBI_APPARCH}/autoupdate-enable"
5728                fi
5729                echo "Done"
5730                rm "${PBI_UPDLFILE}"
5731                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" 2>/dev/null
5732                return 0
5733        fi     
5734}
5735
5736# Start downloading the update
5737pbi_update_dl() {
5738
5739        _tPatch=$1
5740        local _CKSUM="$2"
5741       
5742        # Set local download location
5743        _dl_loc="${PBI_APPDIR}/.`basename $PBI_UPFILE`"
5744
5745        # Have a patch file to download instead, make that the active file to try
5746        if [ -n "$_tPatch" ] ; then
5747                _bDir=`dirname $PBI_UPFILE`
5748                _uFile="${_bDir}/${_tPatch}"
5749        else
5750                _uFile="${PBI_UPFILE}"
5751        fi
5752
5753        _mirrorList=`echo $PBI_UPMIRROR | sed 's|\n| |g'`
5754
5755        # Start download from repos mirror(s) in order
5756        for _cMirror in $_mirrorList
5757        do
5758                if [ "$_cMirror" = "PCBSDCDN" -o "$_cMirror" = "http://pbi.cdn.pcbsd.org" ] ; then
5759
5760                        # Strip the /PBI from the mirror URL
5761                        _uFile="`echo ${_uFile} | sed 's|^/PBI||g'`"
5762                        if [ -e "$_dl_loc" ] ; then rm "$_dl_loc" ; fi 
5763
5764                        get_file_from_mirrors "${_uFile}" "$_dl_loc" "pbi"
5765                        if [ "$?" != "0" ]  ; then
5766                                rm "${_dl_loc}" >/dev/null 2>/dev/null
5767                                echo "Download Failed: ${_furl}"
5768                                continue
5769                        fi
5770                else
5771                        _furl="`echo $_cMirror | sed 's/\/*$//'`${_uFile}"
5772                        if [ -e "$_dl_loc" ] ; then rm "${_dl_loc}" ; fi       
5773
5774                        echo "Downloading ${_furl}"
5775                        pbi_get_file "$_furl" "$_dl_loc"
5776                        if [ "$?" != "0" ]  ; then
5777                                rm "${_dl_loc}" >/dev/null 2>/dev/null
5778                                echo "Download Failed: ${_furl}"
5779                                continue
5780                        fi
5781                fi
5782                sync
5783                sleep 1
5784                _upcsum=`sha256 -q "$_dl_loc"`
5785                if [ "$_CKSUM" != "OFF" -a "$_upcsum" != "$PBI_UPCSUM" ] ; then
5786                        rm "${_dl_loc}" >/dev/null 2>/dev/null
5787                        echo "Download fails checksum: ${_furl}"
5788                        continue
5789                fi
5790
5791                # If we get this far, we have a good file!
5792                PBI_UPDLFILE="$_dl_loc"
5793                sync
5794                return 0
5795        done
5796
5797        return 1
5798}
5799
5800# Function to download a file from remote using fetch
5801pbi_get_file() {
5802        _rf="${1}"
5803        _lf="${2}"
5804
5805        init_tmpdir
5806        if [ -e "${_lf}" ] ; then
5807                echo "Resuming download of: ${_lf}"
5808        fi
5809
5810        if [ "$PBI_FETCH_PARSING" != "YES" ] ; then
5811                fetch -r -o "${_lf}" "${_rf}"
5812                _err=$?
5813        else
5814                # Doing a front-end download, parse the output of fetch
5815                _eFile="${PBI_TMPDIR}/.fetch-exit.$$"
5816                fetch -s "${_rf}" > ${PBI_TMPDIR}/.fetch-size.$$ 2>/dev/null
5817                _fSize=`cat ${PBI_TMPDIR}/.fetch-size.$$ 2>/dev/null`
5818                _fSize="`expr ${_fSize} / 1024 2>/dev/null`"
5819                rm "${PBI_TMPDIR}/.fetch-size.$$" 2>/dev/null
5820                _time=1
5821
5822                ( fetch -r -o "${_lf}" "${_rf}" >/dev/null 2>/dev/null ; echo "$?" > ${_eFile} ) &
5823                FETCH_PID=`ps -auwwwx | grep -v grep | grep "fetch -r -o ${_lf}" | awk '{print $2}'`
5824                while :
5825                do
5826                        if [ -e "${_lf}" ] ; then
5827                                _dSize=`du -k ${_lf} | tr -d '\t' | cut -d '/' -f 1`
5828                                if [ $(is_num "$_dSize") ] ; then
5829                                        if [ ${_fSize} -lt ${_dSize} ] ; then _dSize="$_fSize" ; fi
5830                                        _kbs=`expr ${_dSize} \/ $_time`
5831                                        echo "SIZE: ${_fSize} DOWNLOADED: ${_dSize} SPEED: ${_kbs} KB/s"
5832                                fi
5833                        fi
5834
5835                        # Make sure download isn't finished
5836                        ps -p $FETCH_PID >/dev/null 2>/dev/null
5837                        if [ "$?" != "0" ] ; then break ; fi
5838                        sleep 2
5839                        _time=`expr $_time + 2`
5840                done
5841
5842                _err="`cat ${_eFile}`"
5843                if [ "$_err" = "0" ]; then echo "FETCHDONE" ; fi
5844                unset FETCH_PID
5845        fi
5846
5847        echo ""
5848        return $_err
5849}
5850
5851is_num()
5852{
5853        expr $1 + 1 2>/dev/null
5854        return $?
5855}
5856
5857# Function to check if the port is flagged to only build on specific arch
5858# Returns 0 for OK, 1 for invalid arch
5859check_port_compat_arch()
5860{
5861        local sPort=$1
5862        have32="false";
5863        local cValues="`make -C $sPort -V ONLY_FOR_ARCHS PORTSDIR=${PORTSDIR}`"
5864        if [ -z "$cValues" ] ; then return 0 ; fi
5865
5866        for cArch in $cValues
5867        do
5868                if [ "$cArch" = "$ARCH" ] ; then return 0; fi
5869                if [ "$cArch" = "i386" ] ; then have32="true" ; fi
5870        done
5871        return 1
5872}
5873
5874# start processing autobuild
5875pbi_autob_init() {
5876
5877        require_root
5878
5879        parse_autob_pbi_cmdline "$@"
5880
5881        do_pbi_autob
5882}
5883
5884check_zfs_ab_destroy()
5885{
5886        local bNum=$1
5887        if [ -e "${PBI_TMPDIR}/${bNum}.zmnt" ] ; then
5888                zDir=`cat ${PBI_TMPDIR}/${bNum}.zmnt`
5889                # Make sure this zfs dataset is in the PBI_APPDIR directory
5890                echo $zDir | grep -q "${PBI_APPDIR}/" 
5891                if [ $? -eq 0 ] ; then
5892                  # Make sure all is unmounted
5893                  umount -f ${PBI_CHROOTDIR}/dev >/dev/null 2>/dev/null
5894                  umount -f ${PBI_CHROOTDIR}/compat/linux/proc >/dev/null 2>/dev/null
5895                  umount -f ${PBI_CHROOTDIR}/usr/ports >/dev/null 2>/dev/null
5896                  umount -f ${PBI_CHROOTDIR}/pkgs >/dev/null 2>/dev/null
5897                  umount -f ${PBI_CHROOTDIR}/.ccache >/dev/null 2>/dev/null
5898                  umount -f ${PBI_CHROOTDIR}/usr/wrkdirprefix >/dev/null 2>/dev/null
5899                  sleep 3
5900                  umount -f ${PBI_CHROOTDIR}/dev >/dev/null 2>/dev/null
5901                  sync
5902                  sleep 3
5903                  zfs destroy -r ${zDir}
5904                  rmdir "${zDir}" >/dev/null 2>/dev/null
5905                fi
5906        fi
5907}
5908
5909ab_clean_build_tmpfiles()
5910{
5911        local build=$1
5912
5913        # Cleanup
5914        rm ${PBI_TMPDIR}/${build}.result 2>/dev/null
5915        rm ${PBI_TMPDIR}/${build}.pid 2>/dev/null
5916        rm ${PBI_TMPDIR}/${build}.bPort 2>/dev/null
5917        rm ${PBI_TMPDIR}/${build}.od 2>/dev/null
5918        rm ${PBI_TMPDIR}/${build}.mp 2>/dev/null
5919        rm ${PBI_TMPDIR}/${build}.cd 2>/dev/null
5920        rm ${PBI_TMPDIR}/${build}.pv 2>/dev/null
5921        rm ${PBI_TMPDIR}/${build}.zmnt 2>/dev/null
5922}
5923
5924# Start the auto-build traversal process
5925do_pbi_autob() {
5926
5927        echo "`basename ${0}` started: `date`"
5928
5929        # Prune any outdir files which we don't have modules for
5930        do_pbi_autob_prune
5931
5932        cd "${PBI_AB_CONFDIR}"
5933        init_tmpdir
5934
5935        # Get this runs timestamp
5936        PBI_AB_TIMESTAMP=`date | md5`
5937
5938
5939        # Build our list of targets first
5940        echo "=> Creating build queue list..."
5941        ab_get_build_list
5942
5943        done=0
5944        rebuildlist=0
5945        while :; do
5946          activity=0
5947          # Start checking each job
5948          for build in ${JOBS-$(jot -w %02d ${PBI_AB_BUILDERS})}; do
5949                # Is this builder running?
5950                if [ -e "${PBI_TMPDIR}/${build}.pid" ] ; then
5951                        if pgrep -qF "${PBI_TMPDIR}/${build}.pid" >/dev/null 2>&1; then
5952                                activity=1
5953                                continue;
5954                        else
5955                                # Do the ZFS destroy here if necessary
5956                                check_zfs_ab_destroy "$build"
5957                               
5958                                # Run the post-build process
5959                                ab_post_build ${build}
5960
5961                                # Cleanup
5962                                ab_clean_build_tmpfiles ${build}
5963                        fi
5964                fi
5965                if [ $done -eq 1 ] ; then continue ; fi
5966
5967                # Builder idle, lets figure out the next build
5968                echo "==> Finding target for build process [$build]"
5969                start_next_ab_target "$build"
5970                if [ $? -eq 0 ] ; then 
5971                        # Nothing left to build, lets wait for any existing build to finish before exiting
5972                        done=1
5973                fi
5974                activity=1
5975          done
5976
5977          # Every 2 hours, we can re-scan the modules directory, catch any ones which may have been added / changed
5978          if [ $rebuildlist -eq 7200 ] ; then
5979             rebuildlist=0
5980             ab_get_build_list
5981          else
5982             rebuildlist=`expr $rebuildlist + 1`
5983          fi
5984
5985          # Wait before checking again
5986          [ $activity -eq 1 ] && sleep 1
5987          # Nothing to do? We can end now
5988          [ $activity -eq 0 ] && break
5989        done
5990
5991        echo "`basename ${0}` Finished: `date`"
5992};
5993
5994ab_get_build_list()
5995{
5996
5997   AB_FOUND="0"
5998   unset CUR_PRIORITY_PBI CUR_WORKING_PBI
5999
6000   # Clear the tmp build list
6001   rm ${PBI_TMPDIR}/.ablist 2>/dev/null
6002               
6003   cd "${PBI_AB_CONFDIR}"
6004   for pbi in `find . -type f -name "${PBI_CONFFILE}" | grep -v '\.svn' | sort`
6005   do
6006        # Figure out the target port for this build
6007        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
6008        . ${pbi}
6009
6010        _cd=$(dirname $pbi | sed 's|./||')
6011        PBI_CONFDIR="$_cd"
6012
6013        # Make sure PBI_MAKEPORT is set
6014        if [ -z "${PBI_MAKEPORT}" ] ; then
6015                PBI_MAKEPORT=`echo $pbi | sed 's|./||'`
6016                export PBI_MAKEPORT
6017        fi     
6018
6019        if [ ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ] ; then 
6020                #echo "Skipping invalid port ${PORTSDIR}/${PBI_MAKEPORT}"
6021                continue
6022        fi
6023       
6024        # Check if this port can be built on this architecture
6025        check_port_compat_arch "${PORTSDIR}/${PBI_MAKEPORT}"
6026        if [ "$?" = "1" ] ; then
6027           if [ "$PBI_ABFB32" != "YES" ] ; then
6028                echo "${PBI_MAKEPORT} - Skipping for invalid system arch"
6029                continue
6030           fi
6031           if [ "$have32" != "true" ] ; then
6032                echo "${PBI_MAKEPORT} - Skipping for invalid system arch"
6033                continue
6034           fi
6035        fi
6036       
6037        # Check for missing port target
6038        if [ -z "$PBI_MAKEPORT" ] ; then
6039                #echo "Warning: Missing PBI_MAKEPORT for ${pbi}"
6040                continue
6041        fi
6042
6043        # Check if another builder is already doing this port
6044        pBuilding=0
6045        for p in `ls ${PBI_TMPDIR}/*.bPort 2>/dev/null`
6046        do
6047                if [ "`cat $p`" = "$PBI_MAKEPORT" ] ; then
6048                        pBuilding=1
6049                        break
6050                fi
6051        done
6052        if [ $pBuilding -eq 1 ] ; then
6053                continue
6054        fi
6055
6056        check_ab_needed "$PBI_MAKEPORT" "${PBI_BUILDKEY}" "$_cd" "$PBI_AB_TIMESTAMP"
6057        if [ "$?" = "0" ] ; then       
6058           AB_FOUND="1"
6059
6060                   # Unset the priority if set to 00 / 0
6061           if [ "${PBI_AB_PRIORITY}" = "00" -o "${PBI_AB_PRIORITY}" = "0" ] ; then
6062                unset PBI_AB_PRIORITY
6063           fi
6064
6065           # Check the priority of this PBI, see if it rises to the top
6066           if [ -z "${CUR_PRIORITY_PBI}" ] ; then
6067             CUR_WORKING_PBI="${pbi}"
6068             if [ -z "$PBI_AB_PRIORITY" ] ; then
6069                     CUR_PRIORITY_PBI="$internal_ab_priority"
6070             else
6071                     CUR_PRIORITY_PBI=`expr $PBI_AB_PRIORITY + 10`
6072             fi
6073             #echo "Setting higher priority target: ${pbi} - Priority: ${CUR_PRIORITY_PBI}"
6074             echo "${CUR_PRIORITY_PBI} $pbi" >> ${PBI_TMPDIR}/.abtmp
6075             continue
6076           fi
6077
6078           # Bump up the supplied AB priority
6079           if [ -n "${PBI_AB_PRIORITY}" ] ; then
6080              internal_ab_priority=`expr $PBI_AB_PRIORITY + 10`
6081           fi
6082
6083           # Check if this PBI is a higher priority
6084           if [ $CUR_PRIORITY_PBI -lt $internal_ab_priority ] ; then
6085             #echo "Setting higher priority target: ${pbi} - Priority: ${internal_ab_priority}"
6086             CUR_WORKING_PBI="${pbi}"
6087             CUR_PRIORITY_PBI="$internal_ab_priority"
6088             echo "${internal_ab_priority} $pbi" >> ${PBI_TMPDIR}/.abtmp
6089             continue
6090           else
6091             echo "${internal_ab_priority} $pbi" >> ${PBI_TMPDIR}/.abtmp
6092           fi
6093           continue
6094         fi
6095
6096  done
6097
6098  # Sort the list
6099  if [ -e "${PBI_TMPDIR}/.abtmp" ] ; then
6100    sort -n -r ${PBI_TMPDIR}/.abtmp > ${PBI_TMPDIR}/.ablist
6101    rm ${PBI_TMPDIR}/.abtmp
6102  fi
6103}
6104
6105start_next_ab_target()
6106{
6107  local curBuilder="$1"
6108  # No list to parse?
6109  if [ ! -e "${PBI_TMPDIR}/.ablist" ] ; then return 0; fi
6110
6111  # Get the last on the list
6112  CUR_WORKING_PBI=`cat ${PBI_TMPDIR}/.ablist | head -1 | cut -d ' ' -f 2`
6113  if [ -z "${CUR_WORKING_PBI}" ] ; then return 0; fi
6114
6115  cd "${PBI_AB_CONFDIR}"
6116
6117  # We have something to build lets do it!
6118  pbi="$CUR_WORKING_PBI"
6119  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
6120  . ${pbi}
6121
6122  _cd=$(dirname $pbi | sed 's|./||')
6123  PBI_CONFDIR="$_cd"
6124
6125  # Get the prog version
6126  get_pbi_progversion
6127
6128  if [ -z "${PBI_MAKEPORT}" ] ; then
6129     PBI_MAKEPORT=$(dirname $pbi | sed 's|./||')
6130  fi   
6131
6132  echo "==> Starting build process [$curBuilder]: $PBI_MAKEPORT"
6133  echo "$PBI_MAKEPORT" >${PBI_TMPDIR}/${curBuilder}.bPort
6134
6135  # Remove this from the queue
6136  cat ${PBI_TMPDIR}/.ablist | tail -n +2 > ${PBI_TMPDIR}/.abtmp
6137  mv ${PBI_TMPDIR}/.abtmp ${PBI_TMPDIR}/.ablist
6138
6139  # Start the build now
6140  start_ext_ab "$PBI_MAKEPORT" \
6141  "${PBI_BUILDKEY}" "${PBI_PROGVERSION}" \
6142  "${_cd}" "${PBI_AB_OUTDIR}" "${PBI_AB_TIMESTAMP}" "${curBuilder}"
6143
6144  return 1
6145};
6146
6147# Prune any outdir files which don't have matching modules
6148do_pbi_autob_prune() {
6149        if [ "${PBI_AB_PRUNE}" != "YES" ] ; then return 0 ; fi
6150
6151        echo "=> Cleaning outgoing directory..."
6152        # Prune outgoing dirs which don't have matching modules anymore
6153        cd "${PBI_AB_OUTDIR}"
6154        for i in `find . -type d | grep -v '\.svn'`
6155        do
6156                if [ "${i}" = "." -o "${i}" = ".." ] ; then continue ; fi
6157                _pDir=`dirname ${i}`
6158                if [ -d "${i}" -a -n "${i}" ] ; then
6159                        if [ ! -e "${PBI_AB_CONFDIR}/${_pDir}" ] ; then
6160                        # Not in our module tree anymore, remove it
6161                        echo "Auto-Prune: ${PBI_AB_OUTDIR}/${_pDir}"
6162                        rm -rf "${PBI_AB_OUTDIR}/${_pDir}"
6163                        fi
6164                fi
6165        done
6166        cd
6167}
6168
6169# Start the pbi_makeport process
6170start_ext_ab() {
6171        _mp="${1}"
6172        _bk="${2}"
6173        _pv="${3}"
6174        _cd="${4}"
6175        _od="${5}/${_cd}"
6176        local _abkey="$6"
6177        local eBuilder="$7"
6178        _flags=""
6179        _flags="-c ${_cd} -d ${PORTSDIR} -o ${_od} --delbuild"
6180        if [ -n "${PBI_AB_SSLPRIVKEY}" ] ; then
6181                _flags="${_flags} --sign ${PBI_AB_SSLPRIVKEY}"
6182        fi
6183
6184        # Check if we need to enable tmpfs
6185        if [ "$PBI_AB_TMPFS" = "YES" ] ; then
6186                if [ -z "${PBI_AB_NOTMPFS}" -o "$PBI_AB_NOTMPFS" != "YES" ] ; then
6187                        _flags="${_flags} --tmpfs"
6188                fi
6189        fi
6190
6191        # Check if we need to enable pkgbuilding
6192        if [ "$PBI_AB_PKGBUILD" = "YES" -a -z "$PBI_AB_NOPKGBUILD"  ] ; then
6193                _flags="${_flags} --pkgbuild"
6194        fi
6195
6196        # Are we doing 32bit builds?
6197        if [ "$PBI_AB32" = "YES" ] ; then _flags="${_flags} -32"; fi
6198
6199        # Check if this port can be built on this architecture
6200        check_port_compat_arch "${PORTSDIR}/${_mp}"
6201        if [ $? -ne 0 ] ; then
6202           if [ "$PBI_ABFB32" = "YES" -a "$have32" = "true" ] ; then
6203              _flags="${_flags} -32"
6204           fi
6205        fi
6206
6207        get_pbi_progversion
6208
6209        #echo "Starting build of ${_mp} - ${_pv}"
6210        #echo "pbi_makeport ${_flags} ${_mp}"
6211
6212        if [ ! -d "${_od}" ] ; then mkdir -p "${_od}" ; fi
6213
6214        # Save the autobuild hash key
6215        echo "$_abkey" > ${_od}/.abkey
6216       
6217        # Save the build key for this PBI
6218        if [ -n "$_bk" ] ; then
6219                echo "$_bk" > "${_od}/pbi-buildkey"
6220        else
6221                echo "__NONE__" > "${_od}/pbi-buildkey"
6222        fi
6223
6224        # Clean old log files
6225        if [ -e "${_od}/build.log" ] ; then
6226                rm "${_od}/build.log"
6227        fi
6228        if [ -e "${_od}/build.log.bz2" ] ; then
6229                rm "${_od}/build.log.bz2"
6230        fi
6231
6232        # Move old PBIs to archived folder
6233        oldVersion=`cat ${_od}/pbi-version 2>/dev/null`
6234        if [ "$oldVersion" != "$PBI_PROGVERSION" ]; then
6235                #echo "Archiving old PBIs..."
6236                archive_old_pbis "${_od}" "$PBI_AB_ARCHIVENUM"
6237        fi
6238
6239        # Set some variables we can call in pbi_makeport
6240        PBI_AB_TMPDIR="${PBI_TMPDIR}"
6241        PBI_AB_BUILDER="$eBuilder"
6242        export PBI_AB_TMPDIR PBI_AB_BUILDER
6243
6244        # Add some header info to log file
6245        echo "Starting build: `date`" >${_od}/build.log
6246        echo "Build Command:" >>${_od}/build.log
6247        echo "pbi_makeport ${_flags} ${_mp}" >>${_od}/build.log
6248        echo "------------------------------------------------------" >>${_od}/build.log
6249       
6250        echo "${_od}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.od"
6251        echo "${_mp}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.mp"
6252        echo "${_cd}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.cd"
6253        echo "${PBI_PROGVERSION}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.pv"
6254        pbi_makeport ${_flags} ${_mp} >>${_od}/build.log 2>>${_od}/build.log &
6255        echo "$!" > ${PBI_TMPDIR}/${eBuilder}.pid
6256
6257}
6258
6259ab_post_build() 
6260{
6261        local build=$1
6262        _od="`cat ${PBI_TMPDIR}/${build}.od`"
6263        _mp="`cat ${PBI_TMPDIR}/${build}.mp`"
6264        _cd="`cat ${PBI_TMPDIR}/${build}.cd`"
6265        _pv="`cat ${PBI_TMPDIR}/${build}.pv`"
6266        sleep 1
6267
6268        if [ -e "${PBI_TMPDIR}/${build}.result" -a "`cat ${PBI_TMPDIR}/${build}.result`" = "0" ] ; then
6269                echo "$_pv" > "${_od}/pbi-version"
6270                echo "OK" > "${_od}/pbi-result"
6271
6272                # Save the mdate file
6273                date "+%Y%m%d %H%M%S" >${_od}/pbi-mdate
6274
6275                if [ -n "${PBI_AB_HELPS}" ] ; then
6276                        ${PBI_AB_HELPS} "OK" "${_od}"
6277                fi
6278
6279                # Copy over a description file
6280                if [ -e "${PORTSDIR}/${_mp}/pkg-descr" ] ; then
6281                        cp "${PORTSDIR}/${_mp}/pkg-descr" "${_od}/pbi-descr"
6282                fi
6283                if [ -e "${PBI_AB_CONFDIR}/${_cd}/pbi-descr" ] ; then
6284                        cp "${PBI_AB_CONFDIR}/${_cd}/pbi-descr" "${_od}/pbi-descr"
6285                fi
6286
6287                # Check if we need to rebuild patches
6288                if [ "$PBI_AB_GENPATCH" = "YES" -a -d "${_od}/archived" ] ; then
6289                        echo "===> Generating patches for [$build]"
6290                        gen_pbi_patches "${_od}" "${_od}/archived"
6291                fi
6292
6293                rm "${_od}/build.log.bz2" >/dev/null 2>/dev/null
6294                bzip2 "${_od}/build.log"
6295
6296        else
6297                echo "Failed" > "${_od}/pbi-result"
6298                if [ -n "${PBI_AB_HELPS}" ] ; then
6299                        ${PBI_AB_HELPS} "FAILED" "${_od}"
6300                fi
6301        fi
6302
6303}
6304
6305# Function which begins to generate patch files from archived PBIs to current
6306gen_pbi_patches()
6307{
6308        _curPBIdir="$1"
6309        _oldPBIdir="$2"
6310
6311        _curPBI=`ls ${_curPBIdir}/*.pbi 2>/dev/null`
6312
6313        # First remove any old patches
6314        rm ${_curPBIdir}/*.pbp 2>/dev/null
6315        rm ${_curPBIdir}/*.pbp.sha256 2>/dev/null
6316
6317        # Make sure to enable signing of the patch files
6318        if [ -n "${PBI_AB_SSLPRIVKEY}" ] ; then
6319                local _mpflags="-o $_curPBIdir --sign ${PBI_AB_SSLPRIVKEY}"
6320        else
6321                local _mpflags="-o $_curPBIdir"
6322        fi
6323
6324        # Check if we need to enable tmpfs
6325        if [ "$PBI_AB_TMPFS" = "YES" ] ; then _mpflags="${_mpflags} --tmpfs" ; fi
6326
6327        # Build a list of old PBIs we need to make patches from
6328        for _oPBI in `ls ${_oldPBIdir}/*.pbi 2>/dev/null`
6329        do
6330                # Make sure we don't try to make a patch of identical files
6331                if [ "`basename $_oPBI`" != "`basename $_curPBI`" ] ; then     
6332                        #echo "Building pbp patch of ${_oPBI} -> ${_curPBI}"
6333                        pbi_makepatch $_mpflags "$_oPBI" "$_curPBI" >/dev/null 2>/dev/null
6334                        if [ "$?" != "0" ] ; then
6335                                echo "pbi_makepatch: Failed creating patchfile for $_oPBI -> $_curPBI"
6336                        fi
6337                       
6338                fi
6339        done
6340}
6341
6342# Function which compares two PBIs, and creates a .pbp file from the differences
6343make_pbi_patchfile()
6344{
6345        _pbiNew="$1"
6346        _pbiOld="$2"
6347        _cDir="$3"
6348
6349        init_tmpdir
6350
6351        # Load all the information about this PBI / PBP
6352        PBI_FILENAME="$1"
6353        load_info_from_header
6354
6355        _pbiNewDir="${PBI_APPDIR}/.newPBI-$$"
6356        _pbiOldDir="${PBI_APPDIR}/.oldPBI-$$"
6357        _pbiPatchDir="${PBI_APPDIR}/.patchPBI-$$"
6358        _pbiPatchHeaderDir="${PBI_APPDIR}/.patchPBIHeaderDir-$$"
6359        _pbiPatchArchiveFile="${PBI_APPDIR}/.patchPBIArchive-$$"
6360        _pbiPatchHeaderFile="${PBI_APPDIR}/.patchPBIHeaderFile-$$"
6361
6362        # Get the PBI Versions
6363        get_ver_from_pbi_file "$_pbiNew"
6364        _pbiNewVer="$VAL"
6365        get_ver_from_pbi_file "$_pbiOld"
6366        _pbiOldVer="$VAL"
6367
6368        # Get the PBI directory names
6369        get_prefix_from_pbi_file "$_pbiNew"
6370        _pbiNewPrefix="`basename $VAL`"
6371        get_prefix_from_pbi_file "$_pbiOld"
6372        _pbiOldPrefix="`basename $VAL`"
6373
6374        # Get the mdate of the old PBI
6375        get_mdate_from_pbi_file "$_pbiOld"
6376        _pbiOldMDate="$VAL"
6377
6378        # Sanity check these prefixes
6379        if [ "${_pbiNewPrefix}" != "${_pbiOldPrefix}" ] ; then
6380                echo "Error: Prefix mismatch between $_pbiNew and $_pbiOld"
6381                return
6382        fi
6383
6384        # Get the arch type
6385        get_arch_from_pbi_file "$_pbiNew"
6386        _pbiNewArch="$VAL"
6387        get_arch_from_pbi_file "$_pbiOld"
6388        _pbiOldArch="$VAL"
6389
6390        # Sanity check these system types
6391        if [ "${_pbiNewArch}" != "${_pbiOldArch}" ] ; then
6392                echo "Error: Arch mismatch between $_pbiNew and $_pbiOld"
6393                return