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

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

Remove the old .failed-csum checks from pbi-manager10, not needed anymore

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