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

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

Update pbi-manager10, when doing -32bit PBI building fallback,
make sure we remove --pkgbuild

  • Property mode set to 100755
File size: 220.8 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        PBI_NAMEMATCH=""
404        for i in `ls -d ${PBI_DBAPPDIR}/* 2>/dev/null`
405        do
406                if [ ! -e "$i/pbi_name" ] ; then continue ; fi
407                if [ "`cat $i/pbi_name`" = "$1" ] ; then
408                        PBI_NAMEMATCH="`basename ${i}`"
409                        break
410                fi
411        done
412}
413
414# Parse the command line for icon
415parse_icon_pbi_cmdline() {
416        while [ $# -gt 0 ]; do
417                case "$1" in
418                add-desktop)    PBI_DESKADD="YES" ;;
419                add-menu)       PBI_MENUADD="YES" ;;
420                add-mime)       PBI_MIMEADD="YES" ;;
421                add-pathlnk)    PBI_PATHADD="YES" ;;
422                del-desktop)    PBI_DESKDEL="YES" ;;
423                del-menu)       PBI_MENUDEL="YES" ;;
424                del-mime)       PBI_MIMEDEL="YES" ;;
425                del-pathlnk)    PBI_PATHDEL="YES" ;;
426                 *)
427                        if [ $# -gt 1 ]; then usage_icon_pbi; fi
428                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
429                                find_pbi_namematch "$1"
430                                if [ -z "$PBI_NAMEMATCH" ] ; then
431                                        exit_err "can't find installed pbi (${1})"
432                                fi
433                                PBI_ICONTARGETAPP="${PBI_NAMEMATCH}"
434                        else
435                                PBI_ICONTARGETAPP="$1"
436                        fi
437                        ;;
438                esac
439                shift
440        done
441        if [ -z "${PBI_ICONTARGETAPP}" ] ; then
442                usage_icon_pbi
443        fi
444}
445
446# Parse the command line for pbid
447parse_pbid_cmdline() {
448        while [ $# -gt 0 ]; do
449                case "$1" in
450                -v)     PBI_VERBOSE="YES" 
451                        ;;
452         --refresh)     # Schedule us to refresh the index
453                        echo "Your meta and index files will begin refreshing in a moment..."
454                        echo "Details available in /var/log/pbid.log"
455                        rm ${PBI_DBINDEXDIR}/*.time >/dev/null 2>/dev/null
456                        if [ -e "${PROGBASE}/etc/rc.d/pbid" ]; then
457                           ${PROGBASE}/etc/rc.d/pbid restart >/dev/null 2>/dev/null
458                        fi
459                        exit 0
460                        ;;
461                esac
462                shift
463        done
464}
465
466# Parse the command line for info
467parse_info_pbi_cmdline() {
468        while [ $# -gt 0 ]; do
469                case "$1" in
470                -a)     PBI_INFONAME="--ALL--"
471                        ;;
472                -i)     PBI_INFOINDEX="YES"     
473                        ;;
474                -v)     PBI_VERBOSE="YES" 
475                        ;;
476                 *)
477                        if [ $# -gt 1 ]; then usage_info_pbi; fi
478                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
479                                find_pbi_namematch "$1"
480                                if [ -z "$PBI_NAMEMATCH" ] ; then
481                                        exit_err "can't find installed pbi (${1})"
482                                fi
483                                PBI_INFONAME="$PBI_NAMEMATCH"
484                        else
485                                PBI_INFONAME="$1"
486                        fi
487                        ;;
488                esac
489                shift
490        done
491        if [ -z "${PBI_INFONAME}" ] ; then
492                PBI_INFONAME="--ALL--" 
493        fi
494}
495
496# Parse the command line for patching
497parse_makepatch_pbi_cmdline() {
498        while [ $# -gt 0 ]; do
499                case "$1" in
500                -o)     if [ $# -eq 1 ]; then usage_makepatch_pbi; fi
501                        shift; PBI_PATCHOUTDIR="$1"
502                        ;;
503            --sign)     if [ $# -eq 1 ]; then usage_makepatch_pbi; fi
504                        shift; PBI_SSLPRIVKEY="$1"
505                        ;;
506           --tmpfs)     PBI_MP_TMPFS="YES" 
507                        ;;
508     --no-checksig)     PBI_SKIPSIGVERIFY="YES" ;;
509                 *)     if [ $# -gt 2  ]; then usage_makepatch_pbi; fi
510                        PBI_OLDFILENAME="$1"
511                        shift
512                        PBI_FILENAME="$1"
513                        ;;
514                esac
515                shift
516        done
517
518        if [ -z "${PBI_FILENAME}" ]; then usage_makepatch_pbi ; fi
519        if [ -z "${PBI_OLDFILENAME}" ]; then usage_makepatch_pbi ; fi
520        if [ -z "${PBI_PATCHOUTDIR}" ]; then PBI_PATCHOUTDIR=`pwd` ; fi
521
522        # Load all the information about this PBI / PBP
523        load_info_from_header
524}
525
526# Parse the command line for editing a meta file
527parse_mt_pbi_cmdline() {
528
529        case $1 in
530        syncpbi) PBI_MT_MODE="SYNCPBI" ; shift ;
531                PBI_MT_PBIFILE="$1"
532                PBI_MT_METAFILE="$2"
533                if [ -z "${PBI_MT_PBIFILE}" ] ; then usage_mt_syncpbi ; fi
534                if [ -z "${PBI_MT_METAFILE}" ] ; then usage_mt_syncpbi ; fi
535                return
536                ;;
537           add) PBI_MT_MODE="ADD" ; shift ;
538                while [ $# -gt 0 ]; do
539                        case "$1" in
540                      --cat) PBI_MT_TYPE="CAT" ;;
541                      --app) PBI_MT_TYPE="APP" ;;
542                        -n) if [ $# -eq 1  ]; then usage_mt_add; fi
543                            shift; PBI_MT_ADDNAME="$1"
544                            ;;
545                        -i) if [ $# -eq 1  ]; then usage_mt_add; fi
546                            shift; PBI_MT_ADDICON="$1"
547                            ;;
548                        -d) if [ $# -eq 1  ]; then usage_mt_add; fi
549                            shift; PBI_MT_ADDDESC="$1"
550                            ;;
551                        -c) if [ $# -eq 1  ]; then usage_mt_add; fi
552                            shift; PBI_MT_ADDCAT="$1"
553                            ;;
554                        -a) if [ $# -eq 1  ]; then usage_mt_add; fi
555                            shift; PBI_MT_ADDAUTHOR="$1"
556                            ;;
557                        -u) if [ $# -eq 1  ]; then usage_mt_add; fi
558                            shift; PBI_MT_ADDURL="$1"
559                            ;;
560                        -l) if [ $# -eq 1  ]; then usage_mt_add; fi
561                            shift; PBI_MT_ADDLIC="$1"
562                            ;;
563                        -t) if [ $# -eq 1  ]; then usage_mt_add; fi
564                            shift; PBI_MT_ADDTYPE="$1"
565                            ;;
566                        -k) if [ $# -eq 1  ]; then usage_mt_add; fi
567                            shift; PBI_MT_ADDKEYWORDS="$1"
568                            ;;
569                        -r) PBI_MT_REQUIRESROOT="YES"
570                            ;;
571                         *) if [ $# -gt 1  ]; then usage_mt_add; fi
572                            PBI_MT_METAFILE="$1"
573                            ;;
574                        esac
575                        shift
576                done
577                if [ -z "${PBI_MT_METAFILE}" ] ; then usage_mt_add ; fi
578                ;;
579           rem) PBI_MT_MODE="REM" ; shift ;
580                while [ $# -gt 0 ]; do
581                        case "$1" in
582                      --cat) PBI_MT_TYPE="CAT" ;;
583                      --app) PBI_MT_TYPE="APP" ;;
584                        -n) if [ $# -eq 1  ]; then usage_mt_rem; fi
585                            shift; PBI_MT_REMNAME="$1"
586                            ;;
587                         *) if [ $# -gt 1  ]; then usage_mt_rem; fi
588                            PBI_MT_METAFILE="$1"
589                            ;;
590                        esac
591                        shift
592                done
593                if [ -z "${PBI_MT_METAFILE}" ] ; then usage_mt_rem ; fi
594                ;;
595             *) usage_mt_unknown ;;
596        esac
597
598        if [ ! -f "${PBI_MT_METAFILE}" ] ; then
599                exit_err "No such file ${PBI_MT_METAFILE}"
600        fi
601
602        # Sanity check the values
603        case ${PBI_MT_MODE} in
604                ADD) # Check the common values
605                     if [ -z "${PBI_MT_ADDNAME}" ] ; then usage_mt_add ; fi
606                     if [ -z "${PBI_MT_ADDICON}" ] ; then usage_mt_add ; fi
607                     if [ -z "${PBI_MT_ADDDESC}" ] ; then usage_mt_add ; fi
608
609                     if [ "$PBI_MT_TYPE" = "CAT" ]; then             
610                     elif [ "$PBI_MT_TYPE" = "APP" ]; then
611                        if [ -z "${PBI_MT_ADDCAT}" ]; then usage_mt_add ; fi
612                        if [ -z "${PBI_MT_ADDAUTHOR}" ]; then usage_mt_add ; fi
613                        if [ -z "${PBI_MT_ADDURL}" ]; then usage_mt_add ; fi
614                        if [ -z "${PBI_MT_ADDLIC}" ]; then usage_mt_add ; fi
615                        if [ -z "${PBI_MT_ADDTYPE}" ]; then usage_mt_add ; fi
616                        if [ -z "${PBI_MT_ADDKEYWORDS}" ]; then usage_mt_add;fi
617                     else
618                       usage_mt_add
619                     fi
620                ;;
621                REM) if [ "$PBI_MT_TYPE" != "CAT" -a "$PBI_MT_TYPE" != "APP" ]
622                     then
623                        usage_mt_rem
624                     fi
625                     if [ -z "${PBI_MT_REMNAME}" ] ; then usage_mt_rem ; fi
626                ;;
627        esac
628
629}
630
631# Parse the command line for editing a index file
632parse_it_pbi_cmdline() {
633
634        case $1 in
635           add) PBI_IT_MODE="ADD" ; shift ;
636                while [ $# -gt 0 ]; do
637                        case "$1" in
638                        -b) if [ $# -eq 1  ]; then usage_it_add; fi
639                            shift; PBI_IT_ADDBPVERS="$1"
640                            ;;
641                        -f) if [ $# -eq 1  ]; then usage_it_add; fi
642                            shift; PBI_IT_ADDFILE="$1"
643                            ;;
644                        -k) if [ $# -eq 1  ]; then usage_it_add; fi
645                            shift; PBI_IT_ADDKEEP="$1"
646                            ;;
647                        -u) if [ $# -eq 1  ]; then usage_it_add; fi
648                            shift; PBI_IT_ADDURL="$1"
649                            ;;
650                         *) if [ $# -gt 1  ]; then usage_it_add; fi
651                            PBI_IT_ADDINDEX="$1"
652                            ;;
653                        esac
654                        shift
655                done
656                ;;
657           rem) PBI_IT_MODE="REM" ; shift ;
658                while [ $# -gt 0 ]; do
659                        case "$1" in
660                        -m) if [ $# -eq 1  ]; then usage_it_rem; fi
661                            shift; PBI_IT_REMARCH="$1"
662                            ;;
663                        -n) if [ $# -eq 1  ]; then usage_it_rem; fi
664                            shift; PBI_IT_REMNAME="$1"
665                            ;;
666                        -v) if [ $# -eq 1  ]; then usage_it_rem; fi
667                            shift; PBI_IT_REMVER="$1"
668                            ;;
669                         *) if [ $# -gt 1  ]; then usage_it_rem; fi
670                            PBI_IT_REMINDEX="$1"
671                            ;;
672                        esac
673                        shift
674                done
675                ;;
676             *) usage_it_unknown ;;
677        esac
678
679        # Sanity check the values
680        case ${PBI_IT_MODE} in
681                ADD) if [ -z "${PBI_IT_ADDFILE}" ] ; then usage_it_add ; fi
682                     if [ -z "${PBI_IT_ADDURL}" ] ; then usage_it_add ; fi
683                     if [ -z "${PBI_IT_ADDINDEX}" ] ; then usage_it_add ; fi
684                     if [ ! -f "${PBI_IT_ADDFILE}" ] ; then
685                        exit_err "No such file ${PBI_IT_ADDFILE}"
686                     fi
687                     if [ ! -f "${PBI_IT_ADDINDEX}" ] ; then
688                        exit_err "No such file ${PBI_IT_ADDINDEX}"
689                     fi
690                     if [ -n "${PBI_IT_ADDKEEP}" ] ; then
691                        expr ${PBI_IT_ADDKEEP} + 1 >/dev/null 2>/dev/null
692                        if [ "$?" != "0" ] ; then
693                                exit_err "-k option must be a integer!"
694                        fi
695                     fi
696                ;;
697                REM) if [ -z "${PBI_IT_REMNAME}" ] ; then usage_it_rem ; fi
698                     if [ -z "${PBI_IT_REMVER}" ] ; then usage_it_rem ; fi
699                     if [ -z "${PBI_IT_REMARCH}" ] ; then usage_it_rem ; fi
700                     if [ -z "${PBI_IT_REMINDEX}" ] ; then usage_it_rem ; fi
701                ;;
702        esac
703
704}
705
706# Parse the command line for browsing a repo
707parse_browse_pbi_cmdline() {
708        while [ $# -gt 0 ]; do
709                case "$1" in
710        --listcats)     PBI_BROWSE_LISTCATS="YES" ;;
711         --viewall)     PBI_BROWSE_LISTALLPBI="YES" ;;
712                -c)     if [ $# -eq 1  ]; then usage_browse_pbi; fi
713                        shift; PBI_BROWSE_CAT="$1"
714                        ;;
715                -s)     if [ $# -eq 1  ]; then usage_browse_pbi; fi
716                        shift; PBI_BROWSE_SEARCH="$1"
717                        ;;
718                 *)     if [ $# -gt 1  ]; then usage_browse_pbi; fi
719                        PBI_BROWSE_RID="$1"
720                        ;;
721                esac
722                shift
723        done
724
725        # Get / check the repoid
726        if [ -n "${PBI_BROWSE_RID}" ] ; then
727                ls ${PBI_DBREPODIR}/${PBI_BROWSE_RID}.* >/dev/null 2>/dev/null
728                if [ "$?" != "0" ] ; then
729                        exit_err "The specified repoid ${PBI_BROWSE_RID} does not exist!"
730                fi
731        else
732                for _repo in `ls ${PBI_DBREPODIR} 2>/dev/null`
733                do
734                        PBI_BROWSE_RID=`echo $_repo | cut -d '.' -f 1`
735                        break;
736                done
737                if [ -z "$PBI_BROWSE_RID" ] ; then exit_err "No available repos!" ; fi
738        fi
739
740        PBI_BROWSE_REPOMD5=`ls ${PBI_DBREPODIR}/${PBI_BROWSE_RID}.* 2>/dev/null | cut -d '.' -f 2`
741        PBI_BROWSE_METAFILE=`ls ${PBI_DBINDEXDIR}/${PBI_BROWSE_REPOMD5}*meta 2>/dev/null`
742        if [ -z "${PBI_BROWSE_METAFILE}" ] ; then
743                exit_err "The specified repo has no meta-file."
744        fi
745
746}
747
748# Parse the command line for listing repos
749parse_listrepo_pbi_cmdline() {
750        while [ $# -gt 0 ]; do
751                case "$1" in
752              --up)     PBI_LISTREPO_UP="YES" ;;
753            --down)     PBI_LISTREPO_DOWN="YES" ;;
754          --mirror)     if [ $# -eq 1  ]; then usage_listrepo_pbi; fi
755                        shift; PBI_LISTREPO_MIRROR="$1"
756                        ;;
757                 *)     if [ $# -gt 1  ]; then usage_listrepo_pbi; fi
758                        PBI_LISTREPO_ID="$1"
759                        ;;
760                esac
761                shift
762        done
763
764        if [ "${PBI_LISTREPO_UP}" = "YES" -a "${PBI_LISTREPO_DOWN}" = "YES" ]; then
765                exit_err "Options --up and --down can't both be used at once!"
766        fi
767        if [ "${PBI_LISTREPO_UP}" = "YES" -a -z "${PBI_LISTREPO_ID}" ]; then
768                exit_err "Missing Repo ID to move up in priority."
769        fi
770        if [ "${PBI_LISTREPO_DOWN}" = "YES" -a -z "${PBI_LISTREPO_ID}" ]; then
771                exit_err "Missing Repo ID to move down in priority."
772        fi
773        if [ -n "${PBI_LISTREPO_MIRROR}" -a -z "${PBI_LISTREPO_ID}" ]; then
774                exit_err "Missing Repo ID to change a specific mirror URL."
775        fi
776
777        if [ -n "${PBI_LISTREPO_ID}" ] ; then
778                ls ${PBI_DBREPODIR}/${PBI_LISTREPO_ID}.* >/dev/null 2>/dev/null
779                if [ "$?" != "0" ] ; then
780                        exit_err "The specified repoid ${PBI_LISTREPO_ID} does not exist!"
781                fi
782        fi
783}
784
785# Parse the command line for adding a new repo file
786parse_addrepo_pbi_cmdline() {
787        while [ $# -gt 0 ]; do
788                case "$1" in
789                 *)     if [ $# -gt 1  ]; then usage_addrepo_pbi; fi
790                        PBI_ADDREPO_FILE="$1"
791                        ;;
792                esac
793                shift
794        done
795
796        if [ -z "$PBI_ADDREPO_FILE" ] ; then
797                usage_addrepo_pbi
798        fi
799        if [ ! -f "$PBI_ADDREPO_FILE" ] ; then
800                exit_err "Repo file ${PBI_ADDREPO_FILE} does not exist!"
801        fi
802}
803
804# Parse the command line for deleting a repo
805parse_deleterepo_pbi_cmdline() {
806        while [ $# -gt 0 ]; do
807                case "$1" in
808                 *)     if [ $# -gt 1  ]; then usage_deleterepo_pbi; fi
809                        PBI_DELREPO_ID="$1"
810                        ;;
811                esac
812                shift
813        done
814
815        if [ -z "$PBI_DELREPO_ID" ] ; then
816                usage_deleterepo_pbi
817        fi
818}
819
820
821# Parse the command line for making a new repo file
822parse_makerepo_pbi_cmdline() {
823        while [ $# -gt 0 ]; do
824                case "$1" in
825             --key)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
826                        shift; PBI_MKREPO_KEY="$1"
827                        ;;
828             --url)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
829                        shift; PBI_MKREPO_URL="$1"
830                        ;;
831            --desc)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
832                        shift; PBI_MKREPO_DESC="$1"
833                        ;;
834          --mirror)     if [ $# -eq 1 ]; then usage_makerepo_pbi; fi
835                        shift; PBI_MKREPO_MIRROR="$1"
836                        ;;
837                 *)     if [ $# -gt 1  ]; then usage_makerepo_pbi; fi
838                        PBI_MKREPO_OUTDIR="$1"
839                        ;;
840                esac
841                shift
842        done
843
844        if [ -z "${PBI_MKREPO_DESC}" ]; then usage_makerepo_pbi ; fi
845        if [ -z "${PBI_MKREPO_KEY}" ]; then usage_makerepo_pbi ; fi
846        if [ -z "${PBI_MKREPO_MIRROR}" ]; then usage_makerepo_pbi ; fi
847        if [ -z "${PBI_MKREPO_URL}" ]; then usage_makerepo_pbi ; fi
848        if [ -z "${PBI_MKREPO_OUTDIR}" ]; then PBI_MKREPO_OUTDIR="${HOME}"; fi
849        if [ ! -f "${PBI_MKREPO_KEY}" ]; then exit_err "The key file ${PBI_MKREPO_KEY} does not exist." ; fi
850       
851        # Make sure we have a valid URL format
852        echo "${PBI_MKREPO_URL}" | grep -q -e "^http://" -e "^https://" -e "^ftp://"
853        if [ $? -ne 0 ] ; then
854                exit_err "Repo URL must begin with http://, https://, or ftp://"
855        fi
856       
857
858}
859
860# Parse the command line for patching
861parse_patch_pbi_cmdline() {
862        while [ $# -gt 0 ]; do
863                case "$1" in
864                -e)     PBI_EXTRACTONLY="YES"
865                        ;;
866                -g)     PBI_ADD_GUIDISPLAY="YES" 
867                        ;;
868                -i)     PBI_ADD_INFODISPLAY="YES" 
869                        ;;
870                -o)
871                        if [ $# -eq 1 ]; then usage_patch_pbi; fi
872                        shift; PBI_ALTEXTRACT_DIR="$1"
873                        ;;
874     --checkscript)     PBI_CHECKSCRIPTS="YES" ;;
875         --no-hash)     PBI_DISABLEHASHDIR="YES" ;;
876     --no-checksum)     PBI_SKIPCHECKSUM="YES" ;;
877     --no-checksig)     PBI_SKIPSIGVERIFY="YES" ;;
878                 *)     if [ $# -gt 1 ]; then usage_patch_pbi; fi
879                        PBI_FILENAME="$1"
880                        ;;
881                esac
882                shift
883        done
884
885        if [ -z "${PBI_FILENAME}" ]; then usage_patch_pbi ; fi
886
887        # Get the absolute patch to the file
888        get_abspath "$PBI_FILENAME"
889        PBI_FILENAME="$_ABSPATH"
890
891        if [ ! -e "${PBI_FILENAME}" ]; then usage_patch_pbi ; fi
892
893        # Load all the information about this PBI / PBP
894        load_info_from_header
895
896        # Make sure this isn't a patch file
897        is_pbi_patch
898        if [ "$?" = "1" ] ; then
899                exit_err "This is not a PBP patch file"
900        fi
901
902        if [ -z "${PBI_ORIGPROGDIRPATH}" ]; then usage_patch_pbi ; fi
903
904        # Lastly set PBI_PROGDIRNAME
905        PBI_PROGDIRNAME="`echo ${PBI_ORIGPROGDIRPATH} | rev | cut -d '/' -f 1 | rev`"
906                       
907        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then
908                # If extracting to a alt-outdir, set it now
909                PBI_PROGDIRPATH="`pwd`/${PBI_PROGDIRNAME}"
910       
911                if [ -n "${PBI_ALTEXTRACT_DIR}" ]; then
912                        PBI_PROGDIRPATH="${PBI_ALTEXTRACT_DIR}/${PBI_PROGDIRNAME}"
913                fi     
914        else
915                # Set the extraction dir
916                PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}-patch"
917        fi
918}
919
920# Parse the command line for adding
921parse_add_pbi_cmdline() {
922        while [ $# -gt 0 ]; do
923                case "$1" in
924                -e)     PBI_EXTRACTONLY="YES"
925                        ;;
926                -f)     PBI_FORCEADD="YES"
927                        ;;
928                -g)     PBI_ADD_GUIDISPLAY="YES" 
929                        ;;
930                -i)     PBI_ADD_INFODISPLAY="YES" 
931                        ;;
932            --meta)     PBI_ADD_METADISPLAY="YES" 
933                        ;;
934                -l)     PBI_ADD_LICDISPLAY="YES" 
935                        ;;
936                -o)     if [ $# -eq 1 ]; then usage_add_pbi; fi
937                        shift; PBI_ALTEXTRACT_DIR="$1"
938                        ;;
939                -r)     PBI_REMOTEFETCH="YES" 
940                        ;;
941                -R)     PBI_REMOTEFETCH="YES" 
942                        PBI_REMOTEFETCHONLY="YES"
943                        ;;
944                -v)     PBI_VERBOSE="YES" 
945                        ;;
946           --rArch)     
947                        if [ $# -eq 1 ]; then usage_add_pbi; fi
948                        shift; PBI_ADD_ALTARCH="$1"
949                        ;;
950           --rVer)     
951                        if [ $# -eq 1 ]; then usage_add_pbi; fi
952                        shift; PBI_ADD_ALTVER="$1"
953                        ;;
954     --checkscript)     PBI_CHECKSCRIPTS="YES" ;;
955        --licagree)     PBI_LICAGREE="YES" ;;
956         --no-hash)     PBI_DISABLEHASHDIR="YES" ;;
957     --no-checksum)     PBI_SKIPCHECKSUM="YES" ;;
958     --no-checksig)     PBI_SKIPSIGVERIFY="YES" ;;
959            --repo)     if [ $# -eq 1 ]; then usage_add_pbi; fi
960                        shift; PBI_ADDREPO_ID="$1"
961                        ;;
962                 *)
963                        if [ $# -gt 1 ]; then usage_add_pbi; fi
964                        # If there is no file, try fetching from repo
965                        if [ ! -e "${1}" ] ; then PBI_REMOTEFETCH="YES"; fi
966                        PBI_FILENAME="$1"
967                        ;;
968                esac
969                shift
970        done
971
972        if [ -z "${PBI_FILENAME}" ]; then usage_add_pbi ; fi
973
974        # If we are doing a remote fetch / install then do it now
975        if [ "$PBI_REMOTEFETCH" = "YES" ] ; then
976                if [ -z "${PBI_ADDREPO_ID}" ] ; then
977                        PBI_ADDREPO_ID="AUTO"
978                else
979                        ls ${PBI_DBREPODIR}/${PBI_ADDREPO_ID}.* >/dev/null 2>/dev/null
980                        if [ "$?" != "0" ] ; then
981                                exit_err "No such repo ID: ${PBI_DELREPO_ID}"
982                        fi
983                fi
984
985                # Start fetching file
986                pbi_add_fetch_remote
987       
988        fi
989
990        # Load all the information about this PBI
991        load_info_from_header
992
993        if [ -z "${PBI_ORIGPROGDIRPATH}" ]; then usage_add_pbi ; fi
994
995        # Make sure this isn't a patch file
996        is_pbi_patch
997        if [ "$?" = "0" ] ; then
998                exit_err "This is a PBP patch file, use 'pbi_patch' instead"
999        fi
1000
1001        # Lastly set PBI_PROGDIRNAME
1002        PBI_PROGDIRNAME="`echo ${PBI_ORIGPROGDIRPATH} | rev | cut -d '/' -f 1 | rev`"
1003
1004
1005        if [ "${PBI_EXTRACTONLY}" = "YES" ] ; then
1006                # If extracting to a alt-outdir, set it now
1007                PBI_PROGDIRPATH="`pwd`/${PBI_PROGDIRNAME}"
1008
1009                if [ -n "${PBI_ALTEXTRACT_DIR}" ]; then
1010                        PBI_PROGDIRPATH="${PBI_ALTEXTRACT_DIR}/${PBI_PROGDIRNAME}"
1011                fi
1012        else
1013                # Set the installation dir
1014                PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}"
1015        fi
1016}
1017
1018# Parse the command line
1019parse_autob_pbi_cmdline() {
1020        while [ $# -gt 0 ]; do
1021                case "$1" in
1022                -c)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1023                        if [ -n "${PBI_AB_CONFDIR}" ]; then usage_autob_pbi; fi
1024                        shift
1025                        get_abspath "$1"
1026                        PBI_AB_CONFDIR="$_ABSPATH"
1027                        if [ ! -d "${PBI_AB_CONFDIR}" ] ; then
1028                                exit_err "Invalid confdir (${PBI_AB_CONFDIR})"
1029                        fi
1030                        ;;
1031                -d)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1032                        shift
1033                        get_abspath "$1"
1034                        PORTSDIR="$_ABSPATH"
1035                        ;;
1036                -o)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1037                        shift
1038                        get_abspath "$1"
1039                        PBI_AB_OUTDIR="$_ABSPATH"
1040                        ;;
1041                -p)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1042                        shift
1043                        PBI_AB_BUILDERS="$1"
1044                        if [ ! $(is_num "$PBI_AB_BUILDERS") ] ; then
1045                                exit_err "Invalid process number specifed!"
1046                        fi
1047                        ;;
1048                -h)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1049                        shift
1050                        get_abspath "$1"
1051                        PBI_AB_HELPS="$_ABSPATH"
1052                        ;;
1053                -32)    if [ "$REALARCH" != "amd64" ] ; then
1054                                exit_err "-32 can only be used on amd64 host"
1055                        fi     
1056                        PBI_AB32="YES"
1057                        ARCH=i386
1058                        ;;
1059        -32fallback)    if [ "$REALARCH" != "amd64" ] ; then
1060                                exit_err "-32fallback can only be used on amd64 host"
1061                        fi     
1062                        PBI_ABFB32="YES"
1063                        ;;
1064
1065        --genpatch)     PBI_AB_GENPATCH="YES" 
1066                        ;;
1067        --pkgbuild)     PBI_AB_PKGBUILD="YES" 
1068                        ;;
1069            --keep)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1070                        shift; PBI_AB_ARCHIVENUM="$1"
1071                        expr $PBI_AB_ARCHIVENUM + 1 >/dev/null 2>/dev/null
1072                        if [ $? != 0 ] ; then usage_autob_pbi; fi
1073                        ;;
1074           --prune)     PBI_AB_PRUNE="YES" 
1075                        ;;
1076           --tmpfs)     PBI_AB_TMPFS="YES" 
1077                        ;;
1078            --sign)     if [ $# -eq 1 ]; then usage_autob_pbi; fi
1079                        shift; PBI_AB_SSLPRIVKEY="$1"
1080                        ;;
1081                 *)     usage_autob_pbi ;;
1082                esac
1083                shift
1084        done
1085
1086        if [ -z "$PBI_AB_OUTDIR" ] ; then usage_autob_pbi ; fi
1087        if [ -z "$PBI_AB_CONFDIR" ] ; then usage_autob_pbi ; fi
1088}
1089
1090
1091# Parse the command line
1092parse_create_pbi_cmdline() {
1093        while [ $# -gt 0 ]; do
1094                case "$1" in
1095                -a)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1096                        shift; PBI_CAUTHOR="$1"
1097                        ;;
1098                -b)     PBI_CBACKUP="YES"
1099                        ;;
1100                -c)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1101                        shift;
1102                        get_abspath "$1"
1103                        PBI_CONFDIR="$_ABSPATH"
1104                        if [ ! -d "${PBI_CONFDIR}" ] ; then
1105                                exit_err "Invalid confdir (${PBI_CONFDIR})"
1106                        fi
1107                        load_pbi_conffile
1108                        ;;
1109                -d)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1110                        shift; PORTSDIR="$1"
1111                        ;;
1112               --meta)  if [ $# -eq 1 ]; then usage_create_pbi; fi
1113                        shift; PBI_CREATE_USERMETA="$1"
1114                        if [ ! -e "$PBI_CREATE_USERMETA" ] ; then
1115                                exit_err "No such file: $PBI_CREATE_USERMETA"
1116                        fi
1117                        ;;
1118                -i)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1119                        shift; PBI_CICON="$1"
1120                        ;;
1121                -n)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1122                        shift; PBI_CNAME="$1"
1123                        ;;
1124                -o)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1125                        shift; PBI_CREATE_OUTDIR="$1"
1126                        ;;
1127                -p)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1128                        shift; PBI_MAKEPORT="$1"
1129                        ;;
1130                -r)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1131                        shift; PBI_CVERSION="$1"
1132                        ;;
1133                -w)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1134                        shift; PBI_CWEB="$1"
1135                        ;;
1136         --no-hash)     PBI_DISABLEHASHDIR="YES" ;;
1137            --sign)     if [ $# -eq 1 ]; then usage_create_pbi; fi
1138                        shift; PBI_SSLPRIVKEY="$1"
1139                        ;;
1140                 *)
1141                        if [ $# -gt 1 ]; then usage_create_pbi; fi
1142                        if [ "$PBI_CBACKUP" = "YES" ] ; then
1143                                if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
1144                                        find_pbi_namematch "$1"
1145                                        if [ -z "$PBI_NAMEMATCH" ] ; then
1146                                                exit_err "can't find installed pbi (${1})"
1147                                        fi
1148                                        PBI_CBACKUPTARGET="${PBI_NAMEMATCH}"
1149                                        PBI_PROGDIRPATH="${PBI_NAMEMATCH}"
1150                                else
1151                                        PBI_CBACKUPTARGET="${1}"
1152                                        PBI_PROGDIRPATH="${1}"
1153                                fi
1154                        else
1155                                get_abspath "$1"
1156                                PBI_PROGDIRPATH="$_ABSPATH"
1157                                if [ ! -d "${PBI_PROGDIRPATH}" ] ; then
1158                                        exit_err "Invalid pbidir (${1})"
1159                                fi
1160                        fi
1161                        ;;
1162                esac
1163                shift
1164        done
1165
1166        # Make sure this port exists
1167        if [ -n "${PBI_MAKEPORT}" -a ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ]; then
1168                exit_err "No port (${PORTSDIR}/${PBI_MAKEPORT})"
1169        fi
1170
1171        # Load the name / version from specified port
1172        if [ -n "${PBI_MAKEPORT}" ]; then
1173                get_pbi_progversion
1174                get_pbi_progname
1175        fi
1176
1177        if [ -z "${PBI_PROGDIRPATH}" ]; then usage_create_pbi ; fi
1178
1179        # Lastly set PBI_PROGDIRNAME
1180        PBI_PROGDIRNAME="`echo ${PBI_PROGDIRPATH} | rev | cut -d '/' -f 1 | rev`"
1181}
1182
1183# Override any pbi.conf values with passed command-line values
1184parse_cmdline_overrides() {
1185        if [ -n "${PBI_CNAME}" ] ; then PBI_PROGNAME="${PBI_CNAME}" ; fi
1186        if [ -n "${PBI_CVERSION}" ] ; then PBI_PROGVERSION="${PBI_CVERSION}" ; fi
1187        if [ -n "${PBI_CWEB}" ] ; then PBI_PROGWEB="${PBI_CWEB}" ; fi
1188        if [ -n "${PBI_CAUTHOR}" ] ; then PBI_PROGAUTHOR="${PBI_CAUTHOR}" ; fi
1189        if [ -n "${PBI_CICON}" ] ; then PBI_PROGICON="${PBI_CICON}" ; fi
1190}
1191
1192# Parse the command line
1193parse_make_pbi_cmdline() {
1194        while [ $# -gt 0 ]; do
1195                case "$1" in
1196                -B)     PBI_BUILDONLY="YES"
1197                        ;;
1198                -c)
1199                        if [ $# -eq 1 ]; then usage_make_pbi; fi
1200                        if [ -n "${PBI_CONFDIR}" ]; then usage_make_pbi; fi
1201                        shift
1202                        get_abspath "$1"
1203                        PBI_CONFDIR="$_ABSPATH"
1204                        ;;
1205                -d)
1206                        if [ $# -eq 1 ]; then usage_make_pbi; fi
1207                        shift; PORTSDIR="$1" ; export PORTSDIR
1208                        ;;
1209
1210                -32)    if [ "$REALARCH" != "amd64" -a "`basename $0`" != "pbi_makeport_chroot" ] ; then
1211                                exit_err "-32 can only be used on amd64 host"
1212                        fi     
1213                        ARCH=i386
1214                        ;;
1215
1216                -k)     PBI_KEEPBUILDFILES="YES"
1217                        ;;
1218
1219                --delbuild)     MKDELBUILD="YES"
1220                        ;;
1221                --no-prune)     PBI_PRUNEBUILDPORTS="NO"
1222                        ;;
1223                --mkdebug)      MKDEBUG="YES"
1224                        ;;
1225                --pkgbuild)     PBI_PKGNGBUILD="YES"
1226                        ;;
1227                --tmpfs)        MKTMPFS="YES"
1228                        ;;
1229               --meta)  if [ $# -eq 1 ]; then usage_make_pbi; fi
1230                        shift; PBI_CREATE_USERMETA="$1"
1231
1232                        # If running the chroot portion, reset the location
1233                        if [ "`basename $0`" = "pbi_makeport_chroot" ] ; then
1234                                PBI_CREATE_USERMETA="/user-meta"
1235                        fi
1236
1237                        # Check to ensure it exists
1238                        if [ ! -e "$PBI_CREATE_USERMETA" ] ; then
1239                                exit_err "No such file: $PBI_CREATE_USERMETA"
1240                        fi
1241                        ;;
1242                -o)     if [ $# -eq 1 ]; then usage_make_pbi; fi
1243                        shift
1244                        get_abspath "$1"
1245                        PBI_CREATE_OUTDIR="$_ABSPATH"
1246                        ;;
1247                -p)     if [ $# -eq 1 ]; then usage_make_pbi; fi
1248                        if [ -n "${PBI_MAKEPREFIX}" ]; then usage_make_pbi; fi
1249                        shift; PBI_MAKEPREFIX="$1"
1250                        ;;
1251            --sign)     if [ $# -eq 1 ]; then usage_make_pbi; fi
1252                        shift
1253                        get_abspath "$1"
1254                        PBI_SSLPRIVKEY="$_ABSPATH"
1255                        ;;
1256                 *)
1257                        if [ $# -gt 1 ]; then usage_make_pbi; fi
1258                        PBI_MAKEPORT="$1"
1259                        ;;
1260                esac
1261                shift
1262        done
1263
1264        # Override some locations if working in chroot environment
1265        if [ "`basename $0`" = "pbi_makeport_chroot" ] ; then
1266                if [ -n "${PBI_CONFDIR}" ] ; then PBI_CONFDIR="/pbimodule" ; fi
1267                if [ -n "${PBI_SSLPRIVKEY}" ] ; then PBI_SSLPRIVKEY="/privkey.pem" ; fi
1268                if [ -n "${PBI_CREATE_OUTDIR}" ] ; then PBI_CREATE_OUTDIR="/pbiout" ; fi
1269                if [ -n "${PORTSDIR}" ] ; then PORTSDIR="/usr/ports" ; fi
1270        fi
1271
1272
1273        # Make sure this port exists
1274        if [ ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ] ; then
1275                exit_err "No port (${PORTSDIR}/${PBI_MAKEPORT})"
1276        fi
1277
1278        # Make sure we have a valid PBI_CONFDIR
1279        if [ -n "${PBI_CONFDIR}" -a ! -d "${PBI_CONFDIR}" ] ; then
1280                exit_err "Invalid confdir (${PBI_CONFDIR})"
1281        fi
1282
1283        # Source the config file
1284        if [ -n "${PBI_CONFDIR}" ]; then load_pbi_conffile ; fi
1285
1286        if [ -z "${PBI_MAKEPORT}" ]; then
1287                usage_make_pbi
1288        fi
1289}
1290
1291# Parse the update command line
1292parse_update_pbi_cmdline() {
1293        while [ $# -gt 0 ]; do
1294                case "$1" in
1295                -c)     PBI_UPCHECK="YES" ;;
1296       --check-all)     PBI_UPCHECK="ALL" ;;
1297    --disable-auto)     PBI_UPENABLEAUTO="NO" ;;
1298     --enable-auto)     PBI_UPENABLEAUTO="YES" ;;
1299      --update-all)     PBI_UPDATEAPP="ALL" ;;
1300                 *)     if [ $# -gt 1 ]; then usage_update_pbi; fi
1301                        if [ -n "$PBI_UPDATEAPP" ] ; then usage_update_pbi ; fi
1302                        if [ ! -e "${PBI_DBAPPDIR}/${1}" ] ; then
1303                                find_pbi_namematch "$1"
1304                                if [ -z "$PBI_NAMEMATCH" ] ; then
1305                                        exit_err "can't find installed pbi (${1})"
1306                                fi
1307                                PBI_UPDATEAPP="$PBI_NAMEMATCH"
1308                        else
1309                                PBI_UPDATEAPP="$1"
1310                        fi
1311                        ;;
1312                esac
1313                shift
1314        done
1315
1316        if [ "${PBI_UPDATEAPP}" = "ALL" -a -n "${PBI_UPCHECK}" ] ; then
1317                usage_update_pbi
1318        fi
1319
1320        # Make sure we aren't trying to enable auto-updating for ALL
1321        if [ "${PBI_UPDATEAPP}" = "ALL" -a -n "${PBI_UPENABLEAUTO}" ] ; then
1322                usage_update_pbi
1323        fi
1324        if [ -z "${PBI_UPDATEAPP}" -a -n "${PBI_UPENABLEAUTO}" ] ; then
1325                usage_update_pbi
1326        fi
1327
1328        if [ -z "${PBI_UPDATEAPP}" -a "${PBI_UPCHECK}" != "ALL" ]; then
1329                usage_update_pbi
1330        fi
1331}
1332
1333# Make some of our required PBI dirs
1334mk_required_dirs() {
1335        if [ ! -d "${PBI_APPDIR}" ] ; then mkdir -p ${PBI_APPDIR} >/dev/null 2>/dev/null ; fi
1336        if [ ! -d "${PBI_XDGCFGDIR}" ] ; then mkdir -p ${PBI_XDGCFGDIR} >/dev/null 2>/dev/null ; fi
1337        if [ ! -d "${PBI_XDGAPPDIR}" ] ; then mkdir -p ${PBI_XDGAPPDIR} >/dev/null 2>/dev/null ; fi
1338        if [ ! -d "${PBI_XDGDIRDIR}" ] ; then mkdir -p ${PBI_XDGDIRDIR} >/dev/null 2>/dev/null ; fi
1339        if [ ! -d "${PBI_XDGICONDIR}" ] ; then mkdir -p ${PBI_XDGICONDIR} >/dev/null 2>/dev/null ; fi
1340        if [ ! -d "${PBI_XDGMIMEDIR}" ] ; then mkdir -p ${PBI_XDGMIMEDIR} >/dev/null 2>/dev/null ; fi
1341        if [ ! -d "${PBI_RCDIR}" ] ; then mkdir -p ${PBI_RCDIR} >/dev/null 2>/dev/null ; fi
1342        if [ ! -d "${PBI_BINDIR}" ] ; then mkdir -p ${PBI_BINDIR} >/dev/null 2>/dev/null ; fi
1343        if [ ! -d "${PBI_MANDIR}" ] ; then mkdir -p ${PBI_MANDIR} >/dev/null 2>/dev/null ; fi
1344        if [ ! -d "${PBI_HASHDIR}" ] ; then mkdir -p ${PBI_HASHDIR} >/dev/null 2>/dev/null ; fi
1345        if [ ! -d "${PBI_DBAPPDIR}" ] ; then mkdir -p ${PBI_DBAPPDIR} >/dev/null 2>/dev/null ; fi
1346        if [ ! -d "${PBI_DBKEYDIR}" ] ; then mkdir -p ${PBI_DBKEYDIR} >/dev/null 2>/dev/null ; fi
1347        if [ ! -d "${PBI_DBMIRRORDIR}" ] ; then mkdir -p ${PBI_DBMIRRORDIR} >/dev/null 2>/dev/null ; fi
1348        if [ ! -d "${PBI_DBICONDIR}" ] ; then mkdir -p ${PBI_DBICONDIR} >/dev/null 2>/dev/null ; fi
1349        if [ ! -d "${PBI_DBINDEXDIR}" ] ; then mkdir -p ${PBI_DBINDEXDIR} >/dev/null 2>/dev/null ; fi
1350        if [ ! -d "${PBI_DBREPODIR}" ] ; then mkdir -p ${PBI_DBREPODIR} >/dev/null 2>/dev/null ; fi
1351        if [ ! -d "${PBI_DBHASHQUEUEDIR}" ] ; then mkdir -p ${PBI_DBHASHQUEUEDIR} >/dev/null 2>/dev/null ; fi
1352
1353        # Set the permissions for directories if we are running as root
1354        if [ `id -u` != "0" ] ; then return ; fi
1355
1356        for cDir in $PBI_APPDIR $PBI_DBAPPDIR $PBI_DBHASHQUEUEDIR $PBI_XDGCFGDIR $PBI_XDGAPPDIR $PBI_XDGDIRDIR $PBI_XDGICONDIR $PBI_XDGMIMEDIR
1357        do     
1358                chown root:${PBI_INSTALLGROUP} ${cDir}
1359                chmod 775 ${cDir}
1360        done
1361
1362        # Make sure the hash-dirty file can be written to by all
1363        touch ${PBI_DBDIRTYFILE}
1364        chown root:${PBI_INSTALLGROUP} ${PBI_DBDIRTYFILE}
1365        chmod 664 ${PBI_DBDIRTYFILE}
1366}
1367
1368# Get the absolute path of a dir, even a realative dir. 'realpath' doesn't work here
1369get_abspath() {
1370        D=`dirname "$1"`
1371        B=`basename "$1"`
1372        if [ "$D" = "/" ] ; then
1373                _ABSPATH="/$B"
1374        else
1375                _ABSPATH="`cd \"$D\" 2>/dev/null && pwd || echo \"$D\"`/$B"
1376        fi
1377}
1378
1379
1380# Initialize some vars
1381init_vars() {
1382
1383        # Set sys vars
1384        REALARCH="`uname -m`"
1385        ARCH="$REALARCH"
1386
1387        # Where is pbi-manager installed?
1388        PROGBASE=/usr/local
1389        SYS_LOCALBASE=/usr/local
1390        PBI_SHARE_DIR="${PROGBASE}/share/pbi-manager"
1391        if [ -z "${PBI_APPDIR}" -o "`basename $0`" = "pbi_makeport_chroot" ] ; then
1392                PBI_APPDIR="/usr/pbi"
1393        fi
1394        # Set the FreeBSD Major & Release
1395        FBSDREL=`uname -r | cut -d "-" -f 1-2`
1396        FBSDMAJOR=`echo $FBSDREL | cut -d "-" -f 1 | cut -d '.' -f 1`
1397
1398        PBI_WORLDCHROOT="${PBI_APPDIR}/.pbi-world-$ARCH"
1399        if [ `id -u` = "0" ] ; then
1400                PBI_HASHDIR="${PBI_APPDIR}/.hashdir"
1401        else
1402                PBI_HASHDIR="${PBI_APPDIR}/.hashdir-`whoami`"
1403        fi
1404        PBI_AB_BUILDERS=1
1405        PBI_XDGCFGDIR="${PBI_APPDIR}/etc/xdg/menus"
1406        PBI_XDGAPPDIR="${PBI_APPDIR}/share/applications"
1407        PBI_XDGDIRDIR="${PBI_APPDIR}/share/desktop-directories"
1408        PBI_XDGICONDIR="${PBI_APPDIR}/share/icons/hicolor"
1409        PBI_XDGMIMEDIR="${PBI_APPDIR}/share/mime/packages"
1410        PBI_RCDIR="${PBI_APPDIR}/rc.d"
1411        PBI_BINDIR="${PBI_APPDIR}/bin"
1412        PBI_MANDIR="${PBI_APPDIR}/man"
1413        PBI_ETCCONF="${SYS_LOCALBASE}/etc/pbi.conf"
1414        PCBSD_ETCCONF="${SYS_LOCALBASE}/etc/pcbsd.conf"
1415        PBI_DEFAULT_ICON="${PROGBASE}/share/pbi-manager/icons/default.png"
1416        PBI_DEFAULT_ICON_CHROOT="/default.png"
1417        PBI_PATCH_ICON="${PROGBASE}/share/pbi-manager/icons/patch.png"
1418        PBI_LDCONFIGFILE="${PROGBASE}/etc/ldpbiconfig"
1419        PBI_LDCONFIGRC="${PROGBASE}/etc/rc.d/ldpbiconfig"
1420
1421        # Set the PBI DB dir
1422        if [ -z "${PBI_DBDIR}" ] ; then
1423                PBI_DBDIR="/var/db/pbi"
1424        fi
1425        PBI_DBKEYDIR="${PBI_DBDIR}/keys"
1426        PROGVERSION="1.0"
1427
1428        # Load the etc/pbi.conf file
1429        load_pbi_etcconf
1430
1431        # Overrides from pbi.conf
1432        if [ -z "$PBIDSLEEP" ] ; then
1433                PBIDSLEEP="300" # Amount of time to sleep before waking up pbid
1434        fi
1435        if [ -z "$PBI_INDEXREFRESH" ] ; then
1436                PBI_INDEXREFRESH="24" # Hours to wait until we re-download PBI indexes
1437        fi
1438        if [ -n "$PBI_MAJORVERSION" ] ; then
1439                FBSDMAJOR=${PBI_FBSDMAJOR}
1440        fi
1441
1442        PBI_LOG_LINES="500"
1443        PBI_INSTALLGROUP="operator"
1444
1445        # What dirs do we build hash-lists of
1446        HASH_SEARCH_DIRS="lib share include info man"
1447
1448        # What dbus dirs do we parse for setting up services
1449        DBUS_SEARCH_DIRS="share/dbus-1 kde4/share/dbus-1 gnome/share/dbus-1"
1450
1451        # Don't modify unless you know what your doing!
1452        MOD_PREINS="pre-install.sh"
1453        MOD_POSTINS="post-install.sh"
1454        MOD_PREREM="pre-remove.sh"
1455        MOD_XDGDESK_DIR="xdg-desktop"
1456        MOD_XDGMENU_DIR="xdg-menu"
1457        MOD_XDGMIME_DIR="xdg-mime"
1458        MOD_EXTLINKFILE="external-links"
1459        MOD_AUTOEXTLINKFILE=".auto-external-links"
1460        PBI_ADD_GUIDISPLAY="NO"
1461        PBI_ADD_INFODISPLAY="NO"
1462        PBI_ADD_METADISPLAY="NO"
1463        PBI_ADD_LICDISPLAY="NO"
1464        PBI_APPDESK_DIR=".${MOD_XDGDESK_DIR}"
1465        PBI_APPMENU_DIR=".${MOD_XDGMENU_DIR}"
1466        PBI_APPMIME_DIR=".${MOD_XDGMIME_DIR}"
1467        PBI_BUILD_USERS=""
1468        PBI_BUILD_GROUPS=""
1469        PBI_INS_USERSFILE=".pbi-uids"
1470        PBI_INS_GROUPSFILE=".pbi-gids"
1471        PBI_DESKADD="NO"
1472        PBI_MENUADD="NO"
1473        PBI_MIMEADD="NO"
1474        PBI_PATHADD="NO"
1475        PBI_DESKDEL="NO"
1476        PBI_MAKECONF="/etc/pbi-make.conf"
1477        PBI_MENUDEL="NO"
1478        PBI_MIMEDEL="NO"
1479        PBI_PATHDEL="NO"
1480        PBI_DELETENAME=""
1481        PBI_FAKEBIN_DIR="bin"
1482        PBI_FAKERC_DIR="rc.d"
1483        PBI_FILENAME=""
1484        PBI_FORCEADD="NO"
1485        PBI_HASHLIST=".pbi-hash-list"
1486        PBI_INDEXUPFILE="pbi-index-$FBSDMAJOR"
1487        PBI_METAUPFILE="pbi-meta-$FBSDMAJOR"
1488        PBI_INFONAME=""
1489        PBI_INS_DESKSCRIPT="install-desktop-icons.sh"
1490        PBI_INS_MENUSCRIPT="install-menu-icons.sh"
1491        PBI_INS_MIMESCRIPT="install-mime.sh"
1492        PBI_INS_PATHSCRIPT="install-pathlinks.sh"
1493        PBI_ICDIR="pbi-shared-icons"
1494        PBI_LISTREPO_UP=""
1495        PBI_LISTREPO_DOWN=""
1496        PBI_LISTREPO_MIRROR=""
1497        PBI_LICAGREE="NO"
1498        PBI_LICENSEFILE="LICENSE"
1499        PBI_USERMETAFILE="metafile"
1500        PBI_PATCHVERSION=""
1501        PBI_PATCHTARGET=""
1502        PBI_REMOTEFETCH=""
1503        PBI_REMOTEFETCHONLY=""
1504        PBI_RESOURCE_DIR="resources"
1505        PBI_SS_ICON="__PBI_ICON__"
1506        PBI_SS_ARCHIVE="__PBI_ARCHIVE__"
1507        PBI_SSLPRIVKEY=""
1508        PBI_TMPDIR="/tmp/.PBI.$$"
1509        PBI_TMPHASHLIST=""
1510        PBI_UPCHECK=""
1511        PBI_UPDATEAPP=""
1512        PBI_UNINS_DESKSCRIPT="uninstall-desktop-icons.sh"
1513        PBI_UNINS_MENUSCRIPT="uninstall-menu-icons.sh"
1514        PBI_UNINS_MIMESCRIPT="uninstall-mime.sh"
1515        PBI_UNINS_PATHSCRIPT="uninstall-pathlinks.sh"
1516
1517        # User overridable variables
1518        MKDELBUILD=""
1519        MKDEBUG=""
1520        MKTMPFS=""
1521        PBI_AB_ARCHIVENUM=""
1522        PBI_AB_CONFDIR=""
1523        PBI_AB_GENPATCH="NO"
1524        PBI_AB_HELPS=""
1525        PBI_AB_OUTDIR=""
1526        PBI_AB_SSLPRIVKEY=""
1527        PBI_AB_PRUNE=""
1528        PBI_AB_TMPFS=""
1529        PBI_BUILDONLY="NO"
1530        PBI_CAUTHOR=""
1531        PBI_CBACKUP=""
1532        PBI_CBACKUPTARGET=""
1533        PBI_CHECKSCRIPTS=""
1534        PBI_CICON=""
1535        PBI_CNAME=""
1536        PBI_CONFDIR=""
1537        PBI_CONFFILE="pbi.conf"
1538        PBI_CONF_SCRIPTSDIR="scripts/"
1539        PBI_CREATE_OUTDIR="$HOME"
1540        PBI_CREATE_HASHLIST="YES"
1541        PBI_CUPDATE=""
1542        PBI_CWEB=""
1543        PBI_DBAPPDIR="${PBI_DBDIR}/installed"
1544        PBI_DBDIRTYFILE="${PBI_DBDIR}/.hashdirty"
1545        PBI_DBHASHQUEUEDIR="${PBI_DBDIR}/.hashqueue"
1546        PBI_DBICONDIR="${PBI_DBDIR}/repo-icons"
1547        PBI_DBINDEXDIR="${PBI_DBDIR}/index"
1548        PBI_DBMIRRORDIR="${PBI_DBDIR}/mirrors"
1549        PBI_DBREPODIR="${PBI_DBDIR}/repos"
1550        PBI_DISABLEHASHDIR="NO"
1551        PBI_GUITOPBANNER="gui_banner.png"
1552        PBI_GUISIDEBANNER="gui_sidebanner.png"
1553        PBI_KEEPBUILDFILES="NO"
1554        PBI_MAKEPORT=""
1555        PBI_MAKEPREFIX=""
1556        PBI_MAKEOPTS=""
1557        PBI_MKPORTBEFORE=""
1558        PBI_MKPORTAFTER=""
1559        PBI_PORTSDIR=""
1560        PBI_PROGAUTHOR=""
1561        PBI_PROGMDATE=""
1562        PBI_PROGEPOCH=""
1563        PBI_PROGNAME=""
1564        PBI_PROGDIRNAME=""
1565        PBI_PROGDIRPATH=""
1566        PBI_PROGICON=""
1567        PBI_PROGREVISION=""
1568        PBI_PROGVERSION=""
1569        PBI_PROGWEB=""
1570        PBI_PRUNEBUILDPORTS="YES"
1571        PBI_SKIPCHECKSUM=""
1572        PBI_SKIPSIGVERIFY=""
1573        PBI_USESYSGL="YES"
1574        PBI_USESYSFONTS="YES"
1575        PBI_VERBOSE="NO"
1576        PORTSDIR="/usr/ports"
1577
1578}
1579
1580detect_pkgng()
1581{
1582        export PKG_ADD="pkg add"
1583        export PKG_DELETE="pkg delete -y -f"
1584}
1585
1586# Set and export vars used by module scripts
1587export_script_vars() {
1588        # Load some initial values
1589        get_pbi_progdir
1590        get_pbi_progversion
1591
1592        export PBI_PROGNAME PBI_PROGDIRNAME PBI_PROGDIRPATH PBI_PROGVERSION PBI_RCDIR PBI_MANDIR PBI_BINDIR
1593        export SYS_LOCALBASE PBI_FAKEBIN_DIR PBI_FAKERC_DIR
1594}
1595
1596# init tmpdir
1597init_tmpdir() {
1598        if [ -d "${PBI_TMPDIR}" ] ; then return; fi
1599        if [ -z "${PBI_TMPDIR}" ] ; then return ; fi
1600        if [ "${PBI_TMPDIR}" = "/" ] ; then return ; fi
1601        if [ -e "${PBI_TMPDIR}" ] ; then rm -rf "${PBI_TMPDIR}" ; fi
1602        mkdir -p "${PBI_TMPDIR}"
1603}
1604
1605# rm tmpdir
1606rm_tmpdir() {
1607        if [ -z "${PBI_TMPDIR}" -o "${PBI_TMPDIR}" = "/" ] ; then return 0; fi
1608        if [ -e "${PBI_TMPDIR}" ] ; then rm -rf "${PBI_TMPDIR}" ; fi
1609}
1610
1611# rm tmpdir
1612rm_buildfiles() {
1613        if [ "${PBI_KEEPBUILDFILES}" = "YES" ] ; then return ; fi
1614        if [ -z "$PBI_CHROOTDIR" ] ; then return ; fi
1615        chroot_make_cleanup
1616}
1617
1618# Load PBI conf options
1619load_pbi_conffile() {
1620        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
1621        if [ -e "${PBI_CONFDIR}/${PBI_CONFFILE}" ] ; then
1622                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
1623                . ${PBI_CONFDIR}/${PBI_CONFFILE}
1624        fi
1625}
1626
1627# Get the PBI_PROGVERSION
1628get_pbi_progversion() {
1629
1630        if [ -z "${PBI_PROGVERSION}" ] ; then
1631                load_pbi_conffile
1632
1633                # If we have PBI_PROGVERSION now set
1634                if [ -n "${PBI_PROGVERSION}" ] ; then return 0 ; fi
1635        else
1636                # Check first if we have this pkg in PKGNG
1637                if [ -e "/usr/local/sbin/pkg-static" ] ; then
1638                        local testPkgVer="`pkg info -O ${PBI_MAKEPORT} | awk '{print $1}' | rev | cut -d '-' -f 1 | rev`"
1639                        if [ -n "$testPkgVer" ] ; then
1640                                export PBI_PROGVERSION="$testPkgVer"
1641                                return 0
1642                        fi
1643                fi
1644
1645                return 0
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          #PBI_STAGEDIR="/usr/local"
3676          # KPM REMOVE ME
3677          mk_stage_dir "/usr/local" "move"
3678
3679          # Check if we created a linux app, and need to copy files for it
3680          auto_copy_linuxbase
3681        else
3682          mk_stage_dir
3683        fi
3684
3685        copy_resource_dir
3686        clean_stage_dir
3687
3688        mk_extlink_entries
3689        clean_icons_dir
3690        mk_xdg_scripts
3691
3692        run_pbi_prepkgscript
3693
3694        mk_install_script
3695        mk_deinstall_script
3696
3697        mk_hash_list
3698
3699        mk_archive_file
3700
3701        mk_header_dir
3702        save_pbi_details_to_header
3703        mk_header_file
3704
3705        mk_output_pbi
3706
3707        rm_stage_dir
3708        exit 0
3709}
3710
3711# Start looping through and creating a hash-list of files
3712mk_hash_list() {
3713        if [ "${PBI_CREATE_HASHLIST}" = "NO" ] ; then return 0 ; fi
3714        echo "Creating hash list..."
3715
3716        hashfile="${PBI_STAGEDIR}/${PBI_HASHLIST}"
3717
3718        if [ -e "${hashfile}" ] ; then rm "${hashfile}" ; fi
3719
3720        for hdir in ${HASH_SEARCH_DIRS}
3721        do
3722                if [ ! -d "${PBI_STAGEDIR}/${hdir}" ] ; then continue ; fi
3723                save_dir_hash_list "${hdir}" "${hashfile}"     
3724        done
3725}
3726
3727#  Read the specified directory and save hashsums of each file
3728save_dir_hash_list() {
3729        cd ${PBI_STAGEDIR}
3730        tmp_hashdir="${PBI_STAGEDIR}/.tmp-hash.$$"
3731        find "${1}" -type f > ${tmp_hashdir}
3732        while read line
3733        do
3734                if [ ! -f "$line" -o -h "$line" ] ; then continue ; fi
3735               
3736                # Check if this hash file is excluded
3737                _hfound="0"
3738                if [ -n "${PBI_HASH_EXCLUDES}" ] ; then
3739                        for _hexcl in ${PBI_HASH_EXCLUDES}
3740                        do
3741                                if [ "$_hexcl" = "$line" ] ; then
3742                                        _hfound="1"
3743                                fi
3744                        done
3745                        if [ "$_hfound" = "1" ] ; then
3746                                continue
3747                        fi
3748                fi     
3749
3750                # Add to the hash-dir
3751                sha=`sha256 -q "$line"`
3752                echo "${line}:::${sha}" >> ${2}
3753
3754        done < ${tmp_hashdir}
3755        rm ${tmp_hashdir}
3756        cd /
3757}
3758
3759# Parse any external link directives
3760mk_extlink_entries() {
3761        echo "Creating external link entries..."
3762        init_tmpdir
3763        _extf="${PBI_CONFDIR}/${MOD_EXTLINKFILE}"
3764        _autoextf="${PBI_TMPDIR}/${MOD_AUTOEXTLINKFILE}"
3765        _tmpextf="${PBI_TMPDIR}/${MOD_AUTOEXTLINKFILE}.$$"
3766        if [ ! -e "${_extf}" -a ! -e "${_autoextf}" ] ; then return 0 ; fi
3767
3768        dir="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}"
3769        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3770
3771        # Create the headers for the PATH link scripts
3772        echo "#!/bin/sh" >"${dir}/${PBI_INS_PATHSCRIPT}"
3773        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_PATHSCRIPT}"
3774
3775        # Make sure we also set SYS_LOCALBASE in case user runs these stand-alone at some point
3776        echo "if [ -z \"\$SYS_LOCALBASE\" ]; then SYS_LOCALBASE=\"${SYS_LOCALBASE}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3777        echo "if [ -z \"\$SYS_LOCALBASE\" ]; then SYS_LOCALBASE=\"${SYS_LOCALBASE}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3778        echo "if [ -z \"\$PBI_RCDIR\" ]; then PBI_RCDIR=\"${PBI_RCDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3779        echo "if [ -z \"\$PBI_RCDIR\" ]; then PBI_RCDIR=\"${PBI_RCDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3780        echo "if [ -z \"\$PBI_MANDIR\" ]; then PBI_MANDIR=\"${PBI_MANDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3781        echo "if [ -z \"\$PBI_MANDIR\" ]; then PBI_MANDIR=\"${PBI_MANDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3782        echo "if [ -z \"\$PBI_BINDIR\" ]; then PBI_BINDIR=\"${PBI_BINDIR}\" ; fi" >>"${dir}/${PBI_INS_PATHSCRIPT}"
3783        echo "if [ -z \"\$PBI_BINDIR\" ]; then PBI_BINDIR=\"${PBI_BINDIR}\" ; fi" >>"${dir}/${PBI_UNINS_PATHSCRIPT}"
3784
3785        touch "$_tmpextf"
3786        if [ -e "$_autoextf" ]; then cat "${_autoextf}" >> "${_tmpextf}" ; fi
3787        if [ -e "$_extf" ]; then cat "${_extf}" >> "${_tmpextf}" ; fi
3788
3789        while read line
3790        do
3791                _bin="NO"
3792                _wraponly="NO"
3793                _crashhandle="YES"
3794                _keep="YES"
3795                _linux="NO"
3796                echo $line | tr '\t' ' ' | tr -s ' ' | grep "^#" >/dev/null 2>/dev/null
3797                if [ "$?" != "0" ] ; then
3798                        src="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 1`"
3799                        tar="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 2`"
3800                        act="`echo $line | tr '\t' ' ' | tr -s ' ' | cut -d ' ' -f 3`"
3801
3802                        if [ -z "$src" -o -z "$tar" ] ; then continue ; fi
3803
3804                        # Check if this is an icon we need to preserve
3805                        echo $src | grep -q "^share/icons/"
3806                        if [ $? -eq 0 -a "${PBI_USESYSFONTS}" != "NO" ] ; then
3807                                iDir=`dirname $src`
3808                                if [ ! -d "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}" ] ; then
3809                                        mkdir -p "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}"
3810                                fi
3811                                cp "${PBI_STAGEDIR}/${src}" "${PBI_STAGEDIR}/${PBI_ICDIR}/${iDir}"
3812                                src="${PBI_ICDIR}/${src}"
3813                        fi
3814
3815                        if [ ! -e "${PBI_STAGEDIR}/$src" ] ; then
3816                                echo "WARN: external_link target: \"$src -> $tar $act\" does not exist!"
3817                                continue
3818                        fi
3819
3820                        # Check for act directives
3821                        for i in `echo ${act} | sed 's|,| |g'`
3822                        do
3823                                case ${i} in
3824                                        binary) _bin="YES" ;;
3825                                    binwrapper) _bin="YES" ; _wraponly="YES" ;;
3826                                       nocrash) _crashhandle="NO" ;;
3827                                          keep) _keep="YES" ;;
3828                                       replace) _keep="NO" ;;
3829                                         linux) _bin="YES" ; _linux="YES" ;;
3830                                        *) echo "Warning: Unknown option \"$i\" in ${MOD_EXTLINKFILE}";;
3831                                esac
3832                               
3833                        done
3834
3835
3836                        # If we are doing a binary, run special function to make wrapper
3837                        if [ "$_bin" = "YES" ] ; then
3838
3839                                # Make sure we don't create any duplicates
3840                                echo "$_donewrap" | grep "#${src}#" >/dev/null 2>/dev/null
3841                                if [ "$?" = "0" ] ; then continue ; fi
3842                               
3843                                # Make the binary wrapper
3844                                mk_path_wrappers "$src" "$tar" "$_crashhandle" "$_wraponly" "$_linux"
3845
3846                                # This binary is done, save it now so we don't duplicate later
3847                                _donewrap="$_donewrap #${src}#"
3848                        else
3849                                # Make our link commands
3850                                if [ "$_keep" = "YES" ] ; then _lop="-fs"; else _lop="-s"; fi
3851                                echo $tar | grep -q "^man/"
3852                                if [ $? -eq 0 ] ; then
3853                                        # Strip off the man/ path
3854                                        _mTar=`echo $tar | sed 's|^man/||g'`
3855                                        _dTar="\$PBI_MANDIR/${_mTar}"
3856                                        echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3857                                        echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3858                                        echo "ln ${_lop} $PBI_PROGDIRPATH/local/${src} \$PBI_MANDIR/${_mTar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3859                                else
3860                                        _dTar="\$SYS_LOCALBASE/${tar}"
3861                                        echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3862                                        echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3863                                        echo "ln ${_lop} $PBI_PROGDIRPATH/local/${src} \$SYS_LOCALBASE/${tar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3864
3865                                fi
3866                        fi
3867
3868                        # Make the uninstall command
3869                        echo "ls -al \"${_dTar}\" | grep \"> $PBI_PROGDIRPATH\" >/dev/null 2>/dev/null " \
3870                                >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3871                        echo "if [ \"\$?\" = \"0\" ] ; then" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3872                        echo "  rm \"${_dTar}\"" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3873                        echo "fi" >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3874
3875                        echo " " >> "${dir}/${PBI_INS_PATHSCRIPT}"
3876                        echo " " >> "${dir}/${PBI_UNINS_PATHSCRIPT}"
3877
3878                fi
3879
3880        done < "${_tmpextf}"
3881        rm "${_tmpextf}"
3882
3883        chmod 755 "${dir}/${PBI_INS_PATHSCRIPT}"
3884        chmod 755 "${dir}/${PBI_UNINS_PATHSCRIPT}"
3885}
3886
3887
3888# Create the wrapper scripts for the specified binaries
3889mk_path_wrappers() {
3890        dir="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}"
3891        rcdir="${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}"
3892        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3893
3894        bin="${1}"
3895        fbin="`basename ${bin}`"
3896        tar="${2}"
3897        ch="${3}"
3898        onlywrap="${4}"
3899        linwrap="${5}"
3900
3901        # Check if the fake-bin wrapper already exists, and if so use
3902        # a different name
3903        if [ -e "${dir}/${fbin}" ] ; then
3904                fbin=`echo $bin | sed 's|/|-|g'`
3905        fi
3906
3907        # If this is an rc.d script, add it to the PBI_RCDIR
3908        if [ "`dirname $tar`" = "etc/rc.d" ] ; then
3909                        >> "${dir}/${PBI_INS_PATHSCRIPT}"
3910                _dTar="\$PBI_RCDIR/`basename ${tar}`"
3911                echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3912                echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3913                echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKERC_DIR}/${fbin} \$PBI_RCDIR/`basename ${tar}`" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3914
3915                # Copy the wrapper binary
3916                PBI_WRAPPERFILE="/.pbiwrapper-$ARCH"
3917                cp ${PBI_WRAPPERFILE} ${rcdir}/${fbin}
3918                chmod 755 ${rcdir}/${fbin}
3919
3920                # Create the wrapper .pbiopt
3921                echo "PROGDIR: ${PBI_PROGDIRPATH}" >${rcdir}/${fbin}.pbiopt
3922                echo "TARGET: ${bin}" >>${rcdir}/${fbin}.pbiopt
3923                return
3924        fi
3925
3926        # Make our link to the system localbase if its not a wrapper only
3927        if [ "$onlywrap" != "YES" ] ; then     
3928                _mTar=`echo $tar | sed "s|^bin/||g" | sed "s|^sbin/||g"`
3929                _dTar="\$PBI_BINDIR/${_mTar}"
3930
3931                        >> "${dir}/${PBI_INS_PATHSCRIPT}"
3932                echo "_bd=\"\`dirname ${_dTar}\`\"" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3933                echo "if [ ! -d \"\$_bd\" ] ; then mkdir -p \"\${_bd}\"; fi" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3934                echo "ln -fs $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${fbin} \$PBI_BINDIR/${_mTar}" >> "${dir}/${PBI_INS_PATHSCRIPT}"
3935        fi
3936
3937
3938        # Copy the wrapper binary
3939        PBI_WRAPPERFILE="/.pbiwrapper-$ARCH"
3940        cp ${PBI_WRAPPERFILE} ${dir}/${fbin}
3941        chmod 755 ${dir}/${fbin}
3942
3943        # Create the wrapper .pbiopt
3944        echo "PROGDIR: ${PBI_PROGDIRPATH}" >${dir}/${fbin}.pbiopt
3945        echo "TARGET: ${bin}" >>${dir}/${fbin}.pbiopt
3946}
3947
3948# Create any XDG script for install / deinstall
3949mk_xdg_scripts() {
3950        echo "Creating xdg scripts..."
3951        mk_xdg_desktop_script
3952        mk_xdg_menu_script
3953        mk_xdg_mime_script
3954}
3955
3956# Create any XDG script for desktop icons
3957mk_xdg_desktop_script() {
3958        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGDESK_DIR}" ] ; then return 0 ; fi
3959        _dFound=0
3960
3961        dir="${PBI_STAGEDIR}/${PBI_APPDESK_DIR}"
3962        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
3963        echo "#!/bin/sh" >"${dir}/${PBI_INS_DESKSCRIPT}"
3964        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_DESKSCRIPT}"
3965
3966        cd "${PBI_CONFDIR}/${MOD_XDGDESK_DIR}"
3967        for i in `ls *.desktop 2>/dev/null`
3968        do
3969                _dFound=1
3970
3971                # Copy over the .desktop file, modifying any variables within
3972                cat "${i}" \
3973                | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
3974                | sed "s|%%PBI_APPDIR%%|$PBI_PROGDIRPATH|g" \
3975                > "${dir}/PBI-${i}"
3976
3977                # Set the correct permissions on the desktop file
3978                chmod 744 "${dir}/PBI-${i}"
3979
3980                ifi="$PBI_PROGDIRPATH/${PBI_APPDESK_DIR}/PBI-${i}"
3981
3982                echo "xdg-desktop-icon install --novendor ${ifi}" \
3983                         >> "${dir}/${PBI_INS_DESKSCRIPT}"
3984                echo "xdg-desktop-icon uninstall ${ifi}" \
3985                         >> "${dir}/${PBI_UNINS_DESKSCRIPT}"
3986               
3987        done
3988
3989        chmod 755 "${dir}/${PBI_INS_DESKSCRIPT}"
3990        chmod 755 "${dir}/${PBI_UNINS_DESKSCRIPT}"
3991
3992        # No desktop entries
3993        if [ "$_dFound" = "0" ] ; then
3994                rm "${dir}/${PBI_INS_DESKSCRIPT}"
3995                rm "${dir}/${PBI_UNINS_DESKSCRIPT}"
3996        fi
3997}
3998
3999# Create any XDG script for menu icons
4000mk_xdg_menu_script() {
4001        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGMENU_DIR}" ] ; then return 0 ; fi
4002
4003        _mFound=0
4004
4005        dir="${PBI_STAGEDIR}/${PBI_APPMENU_DIR}"
4006        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4007        echo "#!/bin/sh" >"${dir}/${PBI_INS_MENUSCRIPT}"
4008        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_MENUSCRIPT}"
4009
4010        cd "${PBI_CONFDIR}/${MOD_XDGMENU_DIR}"
4011        for i in `ls *.desktop 2>/dev/null`
4012        do
4013                _mFound=1
4014
4015                # Copy the desktop file, changing any included vars
4016                cat "${i}" \
4017                | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4018                | sed "s|%%PBI_APPDIR%%|$PBI_PROGDIRPATH|g" \
4019                > "${dir}/PBI-${i}"
4020
4021                # Set the correct permissions on the menu file
4022                chmod 744 "${dir}/PBI-${i}"
4023
4024                ifi="$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/PBI-${i}"
4025
4026                # Check for a .directory file associated with this .desktop
4027                ifd=""
4028                dirfile="`basename -s .desktop ${i}`"
4029                if [ -e "${dirfile}.directory" ] ; then
4030                        cat "${dirfile}.directory" \
4031                        | sed "s|%%PBI_EXEDIR%%|$PBI_PROGDIRPATH/$PBI_FAKEBIN_DIR|g" \
4032                        | sed "s|%%PBI_APPDIR%%|$PBI_PROGDIRPATH|g" \
4033                        > "${dir}/PBI-${dirfile}.directory"
4034                        #cp "${dirfile}.directory" "${dir}/PBI-${dirfile}.directory"
4035                        ifd="$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/PBI-${dirfile}.directory "     
4036                fi
4037
4038                echo "xdg-desktop-menu install --novendor ${ifd}${ifi}" \
4039                         >> "${dir}/${PBI_INS_MENUSCRIPT}"
4040                echo "xdg-desktop-menu uninstall ${ifd}${ifi}" \
4041                         >> "${dir}/${PBI_UNINS_MENUSCRIPT}"
4042
4043        done
4044
4045        chmod 755 "${dir}/${PBI_INS_MENUSCRIPT}"
4046        chmod 755 "${dir}/${PBI_UNINS_MENUSCRIPT}"
4047
4048        # No mime entries
4049        if [ "$_mFound" = "0" ] ; then
4050                rm "${dir}/${PBI_INS_MENUSCRIPT}"
4051                rm "${dir}/${PBI_UNINS_MENUSCRIPT}"
4052        fi
4053}
4054
4055# Create any XDG script for mime types
4056mk_xdg_mime_script() {
4057        if [ ! -d "${PBI_CONFDIR}/${MOD_XDGMIME_DIR}" ] ; then return 0 ; fi
4058        _mFound=0
4059
4060        dir="${PBI_STAGEDIR}/${PBI_APPMIME_DIR}"
4061        if [ ! -d "${dir}" ] ; then mkdir -p "${dir}" ; fi
4062        echo "#!/bin/sh" >"${dir}/${PBI_INS_MIMESCRIPT}"
4063        echo "#!/bin/sh" >"${dir}/${PBI_UNINS_MIMESCRIPT}"
4064
4065
4066        cd "${PBI_CONFDIR}/${MOD_XDGMIME_DIR}"
4067        for i in `ls *.xml 2>/dev/null`
4068        do
4069                _mFound=1
4070                cp "${i}" "${dir}/PBI-${i}"
4071                ifi="$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/PBI-${i}"
4072
4073                # Check for a .directory file associated with this .desktop
4074                ifp=""
4075                iconfile="`basename -s .xml ${i}`"
4076                if [ -e "${iconfile}.png" ] ; then
4077                        cp "${iconfile}.png" "${dir}/${iconfile}.png"
4078                        ifp="$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${iconfile}.png"
4079                        mi=`cat "$i" | grep '<mime-type' | cut -d '"' -f 2 | sed 's|/|-|g'`
4080                        echo "xdg-icon-resource install --novendor --context mimetypes ${ifp} --size 64 $mi" \
4081                                 >> "${dir}/${PBI_INS_MIMESCRIPT}"
4082                        echo "xdg-icon-resource uninstall --context mimetypes ${ifp} --size 64" \
4083                                 >> "${dir}/${PBI_UNINS_MIMESCRIPT}"
4084                fi
4085
4086                echo "xdg-mime install --novendor ${ifi}" \
4087                         >> "${dir}/${PBI_INS_MIMESCRIPT}"
4088                echo "xdg-mime uninstall ${ifi}" \
4089                         >> "${dir}/${PBI_UNINS_MIMESCRIPT}"
4090        done
4091
4092        chmod 755 "${dir}/${PBI_INS_MIMESCRIPT}"
4093        chmod 755 "${dir}/${PBI_UNINS_MIMESCRIPT}"
4094
4095        # No mime entries
4096        if [ "$_mFound" = "0" ] ; then
4097                rm "${dir}/${PBI_INS_MIMESCRIPT}"
4098                rm "${dir}/${PBI_UNINS_MIMESCRIPT}"
4099        fi
4100}
4101
4102
4103# Create the install script for the PBI
4104mk_install_script() {
4105        echo "Creating install script..."
4106        if [ ! -d "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}" ] ; then mkdir -p "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}" ; fi
4107        if [ ! -d "${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}" ] ; then mkdir -p "${PBI_STAGEDIRMNT}/${PBI_FAKERC_DIR}" ; fi
4108        insc="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/.pbi-install.sh"
4109        echo "#!/bin/sh" > "$insc"
4110        echo "PBI_WRAPPERBIN=\"${PBI_FAKEBIN_DIR}\"" >> "$insc"
4111        echo "PBI_PROGDIRPATH=\"${PBI_PROGDIRPATH}\"" >> "$insc"
4112        echo "SYS_LOCALBASE=\"${SYS_LOCALBASE}\"" >> "$insc"
4113        echo "cd \"\$PBI_PROGDIRPATH\"" >> "$insc"
4114
4115        # Add the binary wrapper sym-links
4116        if [ -e "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" ] ; then
4117                echo 'if [ `id -u` = "0" ] ; then ' >>${insc}
4118                echo "  $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" >>${insc}
4119                echo "fi" >>${insc}
4120        fi
4121
4122        # Look for any XDG scripts
4123        if [ -e "${PBI_STAGEDIR}/${PBI_APPMIME_DIR}/${PBI_INS_MIMESCRIPT}" ] ; then
4124                echo "$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${PBI_INS_MIMESCRIPT}" >>${insc}
4125        fi
4126        if [ -e "${PBI_STAGEDIR}/${PBI_APPMENU_DIR}/${PBI_INS_MENUSCRIPT}" ] ; then
4127                echo "$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/${PBI_INS_MENUSCRIPT}" >>${insc}
4128        fi
4129
4130        chmod 755 "${insc}"
4131       
4132}
4133
4134# Create the deinstall script for the PBI
4135mk_deinstall_script() {
4136        echo "Creating deinstall script..."
4137        uisc="${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"
4138
4139        echo "#!/bin/sh" > "$uisc"
4140        echo "PBI_PROGDIRPATH=\"${PBI_PROGDIRPATH}\"" >> "$uisc"
4141        echo "SYS_LOCALBASE=\"${SYS_LOCALBASE}\"" >> "$uisc"
4142
4143        # Remove the binary wrapper sym-links
4144        if [ -e "${PBI_STAGEDIRMNT}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" ] ; then
4145                echo 'if [ `id -u` = "0" ] ; then ' >>${uisc}
4146                echo "  $PBI_PROGDIRPATH/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >>${uisc}
4147                echo "fi" >>${uisc}
4148        fi
4149
4150        # Look for any XDG scripts
4151        if [ -e "${PBI_STAGEDIR}/${PBI_APPMIME_DIR}/${PBI_UNINS_MIMESCRIPT}" ] ; then
4152                echo "$PBI_PROGDIRPATH/${PBI_APPMIME_DIR}/${PBI_UNINS_MIMESCRIPT}" >>${uisc}
4153        fi
4154        if [ -e "${PBI_STAGEDIR}/${PBI_APPMENU_DIR}/${PBI_UNINS_MENUSCRIPT}" ] ; then
4155                echo "$PBI_PROGDIRPATH/${PBI_APPMENU_DIR}/${PBI_UNINS_MENUSCRIPT}" >>${uisc}
4156        fi
4157        chmod 755 "${uisc}"
4158}
4159
4160# Create a dir for manipulating header info
4161mk_header_dir() {
4162        PBI_HEADERDIR="${PBI_STAGEDIRMNT}/pbimeta"
4163        if [ -e "${PBI_HEADERDIR}" ] ; then rm -rf "${PBI_HEADERDIR}" ; fi
4164        mkdir -p ${PBI_HEADERDIR}
4165}
4166
4167# Create a dir for staging the final archive
4168mk_stage_dir() {
4169        if [ -n "$1" ] ; then
4170                cpDir="$1"
4171        else
4172                cpDir="${PBI_PROGDIRPATH}"
4173        fi
4174
4175        PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"
4176        echo "Creating Stage Dir: ${PBI_STAGEDIR}"
4177        if [ -e "${PBI_STAGEDIR}" ] ; then
4178                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4179                chflags -R noschg ${PBI_STAGEDIR} 2>/dev/null
4180                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4181        fi
4182        mkdir -p ${PBI_STAGEDIR}
4183
4184        mkdir -p ${PBI_STAGEDIR}/local
4185        mkdir -p ${PBI_STAGEDIR}/etc
4186        mkdir -p ${PBI_STAGEDIR}/rc.d
4187        mkdir -p ${PBI_STAGEDIR}/pbimeta
4188        mkdir -p ${PBI_STAGEDIR}/virtbase
4189        mkdir -p ${PBI_STAGEDIR}/linux
4190        mkdir -p ${PBI_STAGEDIR}/run
4191
4192        # If we built with a module / conf directory, lets include it
4193        if [ -d "${PBI_CONFDIR}" ] ; then cp -r ${PBI_CONFDIR} ${PBI_STAGEDIR}/pbiconf; fi
4194
4195        local _excOpts=""
4196
4197        # Build module list of excludes
4198        if [ -n "$PBI_EXCLUDELIST" ] ; then
4199                for excl in $PBI_EXCLUDELIST
4200                do
4201                        if [ -z "$_excOpts" ] ; then
4202                                _excOpts="--exclude ${excl}"
4203                        else
4204                                _excOpts="$_excOpts --exclude ${excl}"
4205                        fi
4206                done
4207        fi
4208
4209        if [ "$2" = "move" ] ; then
4210                rmdir ${PBI_STAGEDIR}/local
4211                mv ${cpDir} ${PBI_STAGEDIR}/local
4212                ln -s ${PBI_STAGEDIR}/local /usr/local
4213        else
4214                # Now copy the stagedir
4215                tar cvf - ${_excOpts} --exclude .stagedir \
4216                --exclude .pkgdb --exclude .ld-elf.hints --exclude make.conf \
4217                --exclude make.conf.bak --exclude .keepports \
4218                -C "${cpDir}" . 2>/dev/null \
4219                | tar xvpf - -C ${PBI_STAGEDIR}/local 2>/dev/null
4220        fi
4221
4222        cd ${PBI_PROGDIRPATH}
4223        PBI_STAGEDIRMNT="${PBI_STAGEDIR}"
4224        PBI_STAGEDIR="${PBI_STAGEDIR}/local"
4225}
4226
4227# Remove the stagedir
4228rm_stage_dir() {
4229        # If this is in the chroot we can exit and let the parent cleanup
4230        if [ "$0" = "pbi_makeport_chroot" ] ; then return; fi
4231
4232        cd /
4233        PBI_STAGEDIR="${PBI_PROGDIRPATH}/.stagedir"
4234        if [ -e "${PBI_STAGEDIR}" ] ; then
4235                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4236                chflags -R noschg ${PBI_STAGEDIR} 2>/dev/null
4237                rm -rf "${PBI_STAGEDIR}" 2>/dev/null
4238        fi
4239}
4240
4241# See if we need to clean the icons dir
4242clean_icons_dir() {
4243        if [ "${PBI_USESYSFONTS}" != "NO" ] ; then
4244                rm -rf ${PBI_STAGEDIR}/share/icons >/dev/null 2>/dev/null
4245                mkdir ${PBI_STAGEDIR}/share/icons >/dev/null 2>/dev/null
4246        fi
4247}
4248
4249# See if we need to clean the stagedir
4250clean_stage_dir() {
4251
4252        if [ "${PBI_USESYSGL}" != "NO" ] ; then
4253                rm ${PBI_STAGEDIR}/lib/libGl.* >/dev/null 2>/dev/null
4254                rm ${PBI_STAGEDIR}/lib/libGL.* >/dev/null 2>/dev/null
4255                rm ${PBI_STAGEDIR}/lib/libGLU.* >/dev/null 2>/dev/null
4256        fi
4257        if [ "${PBI_USESYSFONTS}" != "NO" ] ; then
4258                rm -rf ${PBI_STAGEDIR}/etc/fonts/* >/dev/null 2>/dev/null
4259                rm -rf ${PBI_STAGEDIR}/lib/X11/fonts/* >/dev/null 2>/dev/null
4260                rm -rf ${PBI_STAGEDIR}/lib/X11/icons/* >/dev/null 2>/dev/null
4261        fi
4262        if [ -e "${PBI_STAGEDIR}/lib/X11" ] ; then
4263                mkdir -p ${PBI_STAGEDIR}/lib/X11/icons/ >/dev/null 2>/dev/null
4264                mkdir -p ${PBI_STAGEDIR}/lib/X11/fonts/ >/dev/null 2>/dev/null
4265                mkdir -p ${PBI_STAGEDIR}/etc/fonts/ >/dev/null 2>/dev/null
4266        fi
4267}
4268
4269# Copy over any resource files into the PBI dir
4270copy_resource_dir() {
4271        if [ -d "${PBI_CONFDIR}/${PBI_RESOURCE_DIR}" ] ; then
4272                echo "Copying ${PBI_CONFDIR}/${PBI_RESOURCE_DIR} -> ${PBI_STAGEDIR}"
4273                tar cvf - -C ${PBI_CONFDIR}/${PBI_RESOURCE_DIR} --exclude .svn . 2>/dev/null \
4274                | tar xvpf - -C ${PBI_STAGEDIR} 2>/dev/null
4275        fi
4276}
4277
4278# Check if tar supports lzma compression
4279test_tar_lzma() {
4280        touch /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4281        tar cvJf /tmp/.pbilzma.tar.$$ /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4282        _exitcode=$?
4283        rm /tmp/.pbilzma.$$ >/dev/null 2>/dev/null
4284        rm /tmp/.pbilzma.tar.$$ >/dev/null 2>/dev/null
4285        return $_exitcode
4286}
4287
4288# Start creating the application archive
4289mk_archive_file() {
4290        # Build module list of excludes
4291        if [ -n "$PBI_EXCLUDELIST" ] ; then
4292                for excl in $PBI_EXCLUDELIST
4293                do
4294                        if [ -z "$_excOpts" ] ; then
4295                                _excOpts="--exclude ${excl}"
4296                        else
4297                                _excOpts="$_excOpts --exclude ${excl}"
4298                        fi
4299                done
4300        fi
4301        PBI_CREATE_ARCHIVE="${PBI_CREATE_OUTDIR}/.PBI.$$.tbz"
4302        if test_tar_lzma ; then _tcmp="J" ; else _tcmp="j" ; fi
4303        echo "Creating compressed archive..."
4304        tar cv${_tcmp}f "${PBI_CREATE_ARCHIVE}" ${_excOpts} -C ${PBI_STAGEDIRMNT} . 2>/dev/null
4305}
4306
4307# Start creating the header archive
4308mk_header_file() {
4309        PBI_HEADER_ARCHIVE="${PBI_CREATE_OUTDIR}/.PBI-header.$$.tbz"
4310        tar cvjf ${PBI_HEADER_ARCHIVE} -C ${PBI_HEADERDIR} . >/dev/null 2>/dev/null
4311}
4312
4313# Start copying pbi details into header file
4314save_pbi_details_to_header() {
4315        local _osArch="$ARCH"
4316        local _osRel="$FBSDREL"
4317        if [ -n "${PBI_OSREL}" ] ; then
4318                _osRel="${PBI_OSREL}"
4319        fi
4320
4321        if [ "${PBI_CREATEONLY}" = "YES" ] ; then
4322                _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
4323                echo "${PBI_APPDIR}/${_pbilow}-${_osArch}" > "${PBI_HEADERDIR}/pbi_defaultpath"
4324        else   
4325                echo "${PBI_PROGDIRPATH}" > "${PBI_HEADERDIR}/pbi_defaultpath"
4326        fi
4327        echo "${PBI_PROGNAME}" > "${PBI_HEADERDIR}/pbi_name"
4328        echo "${PBI_PROGVERSION}" > "${PBI_HEADERDIR}/pbi_version"
4329        echo "${PBI_PROGAUTHOR}" > "${PBI_HEADERDIR}/pbi_author"
4330        echo "${PBI_PROGWEB}" > "${PBI_HEADERDIR}/pbi_web"
4331        date "+%Y%m%d %H%M%S" > "${PBI_HEADERDIR}/pbi_mdate"
4332
4333        if [ "${PBI_REQUIRESROOT}" = "YES" ] ; then
4334                touch ${PBI_HEADERDIR}/pbi_requiresroot
4335        fi
4336
4337        # Do we have a license to accept?
4338        if [ -e "${PBI_CONFDIR}/${PBI_LICENSEFILE}" ] ; then
4339                cp "${PBI_CONFDIR}/${PBI_LICENSEFILE}" "${PBI_HEADERDIR}/${PBI_LICENSEFILE}"
4340        fi
4341
4342        # Do we have a conf-supplied meta-file to copy?
4343        if [ -e "${PBI_CONFDIR}/${PBI_USERMETAFILE}" ] ; then
4344                cp "${PBI_CONFDIR}/${PBI_USERMETAFILE}" "${PBI_HEADERDIR}/${PBI_USERMETAFILE}"
4345        fi
4346        # Do we have a user-supplied meta-file to copy?
4347        if [ -n "$PBI_CREATE_USERMETA" ] ; then
4348                cp "$PBI_CREATE_USERMETA" "${PBI_HEADERDIR}/${PBI_USERMETAFILE}"
4349        fi
4350
4351        # Check for additional meta-data
4352        if [ -n "$PBI_LICENSE" ] ; then
4353                echo "$PBI_LICENSE" > ${PBI_HEADERDIR}/pbi_license
4354        fi
4355        if [ -n "$PBI_TAGS" ] ; then
4356                echo "$PBI_TAGS" > ${PBI_HEADERDIR}/pbi_tags
4357        fi
4358        if [ -n "$PBI_PROGTYPE" ] ; then
4359                echo "$PBI_PROGTYPE" > ${PBI_HEADERDIR}/pbi_type
4360        fi
4361        if [ -n "$PBI_CATEGORY" ] ; then
4362                echo "$PBI_CATEGORY" > ${PBI_HEADERDIR}/pbi_category
4363        fi
4364        if [ -n "$PBI_ICONURL" ] ; then
4365                echo "$PBI_ICONURL" > ${PBI_HEADERDIR}/pbi_iconurl
4366        fi
4367        if [ -n "$PBI_DESC" ] ; then
4368                echo "$PBI_DESC" > ${PBI_HEADERDIR}/pbi_desc
4369        fi
4370        if [ -n "$PBI_SHORTDESC" ] ; then
4371                echo "$PBI_SHORTDESC" > ${PBI_HEADERDIR}/pbi_shortdesc
4372        fi
4373
4374        # Custom install / remove scripts
4375        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREINS}" ] ; then
4376                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREINS}" \
4377                        "${PBI_HEADERDIR}/${MOD_PREINS}"
4378        else
4379                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_PREINS}
4380        fi
4381        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_POSTINS}" ] ; then
4382                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_POSTINS}" \
4383                        "${PBI_HEADERDIR}/${MOD_POSTINS}"
4384        else
4385                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_POSTINS}
4386        fi
4387        if [ -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREREM}" ] ; then
4388                cp "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/${MOD_PREREM}" \
4389                        "${PBI_HEADERDIR}/${MOD_PREREM}"
4390        else
4391                echo "#!/bin/sh" > ${PBI_HEADERDIR}/${MOD_PREREM}
4392        fi
4393
4394        # Copy over our icon
4395        if [ -n "${PBI_PROGICON}" -a -e "${PBI_STAGEDIR}/${PBI_PROGICON}" ] ; then
4396                # Get the file extension
4397                _iconExt=`echo "$PBI_PROGICON" | awk -F . '{print $NF}'`
4398                cp "${PBI_STAGEDIR}/${PBI_PROGICON}" "${PBI_HEADERDIR}/pbi_icon.${_iconExt}" >/dev/null 2>/dev/null
4399        else
4400                _iconExt=`echo "$PBI_DEFAULT_ICON_CHROOT" | awk -F . '{print $NF}'`
4401                cp "${PBI_DEFAULT_ICON_CHROOT}" "${PBI_HEADERDIR}/pbi_icon.${_iconExt}" >/dev/null 2>/dev/null
4402        fi
4403
4404        # Check for any gui images
4405        if [ -e "${PBI_STAGEDIR}/${PBI_GUITOPBANNER}" ] ; then
4406                cp "${PBI_STAGEDIR}/${PBI_GUITOPBANNER}" "${PBI_HEADERDIR}/top-banner.png"
4407        fi
4408        if [ -e "${PBI_STAGEDIR}/${PBI_GUISIDEBANNER}" ] ; then
4409                cp "${PBI_STAGEDIR}/${PBI_GUISIDEBANNER}" "${PBI_HEADERDIR}/side-banner.png"
4410        fi
4411
4412        # Save the uname details
4413        echo "${_osArch}" > "${PBI_HEADERDIR}/pbi_arch"
4414        echo "${_osRel}" > "${PBI_HEADERDIR}/pbi_fbsdver"
4415        echo "${PROGVERSION}" > "${PBI_HEADERDIR}/pbi_createver"
4416
4417        # Get the total number of files in the STAGEDIR
4418        get_filetotal_dir "${PBI_STAGEDIR}"
4419        echo "${FILETOTAL}" > "${PBI_HEADERDIR}/pbi_archivecount"
4420
4421        # Save a checksum of archive file
4422        sha256 -q "${PBI_CREATE_ARCHIVE}" > "${PBI_HEADERDIR}/pbi_archivesum"
4423
4424        sign_pbi_files "$PBI_HEADERDIR"
4425}
4426
4427# Use openssl to sign parts of the pbi header structure and archive
4428sign_pbi_files() {
4429        if [ -z "${PBI_SSLPRIVKEY}" ] ; then return 0 ; fi
4430        _sf="${1}/pbi_archivesum ${1}/${MOD_PREINS} ${1}/${MOD_POSTINS} ${1}/${MOD_PREREM}"
4431        for i in $_sf
4432        do
4433                openssl dgst -sha1 \
4434                        -sign ${PBI_SSLPRIVKEY} \
4435                        -out ${i}.sha1 \
4436                        ${i} >/dev/null 2>/dev/null
4437        done
4438}
4439
4440# All the pieces are ready, spit out the final PBI file
4441mk_output_pbi() {
4442        if [ -n "${PBI_PROGICON}" -a -e "${PBI_STAGEDIR}/${PBI_PROGICON}" ] ; then
4443                icon="${PBI_STAGEDIR}/${PBI_PROGICON}"
4444        else
4445                icon="${PBI_DEFAULT_ICON_CHROOT}"
4446        fi
4447
4448        # Set PBI name all lower-case
4449        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
4450        outfile="${PBI_CREATE_OUTDIR}/${_pbilow}-${PBI_PROGVERSION}-${ARCH}.pbi"
4451
4452        mark1="${PBI_CREATE_OUTDIR}/.pbimark1.$$"
4453        mark2="${PBI_CREATE_OUTDIR}/.pbimark2.$$"
4454        echo "
4455${PBI_SS_ICON}" >$mark1
4456        echo "
4457${PBI_SS_ARCHIVE}" >$mark2
4458
4459
4460        # DO IT, DO IT NOW!!!
4461        cat ${PBI_HEADER_ARCHIVE} $mark1 ${icon} $mark2 ${PBI_CREATE_ARCHIVE} > ${outfile}
4462        sha256 -q ${outfile} > ${outfile}.sha256
4463
4464        echo "Created PBI: ${outfile}"
4465
4466        rm $mark1
4467        rm $mark2
4468        rm ${PBI_HEADER_ARCHIVE}
4469        rm ${PBI_CREATE_ARCHIVE}
4470}
4471
4472get_filetotal_dir() {
4473        FILETOTAL="`find ${1} | wc -l | tr -d ' '`"
4474}
4475
4476pbi_delete_init() {
4477        require_root_or_group
4478        init_tmpdir
4479        parse_delete_pbi_cmdline "$@"
4480        do_pbi_delete
4481}
4482
4483# Delete this PBI
4484do_pbi_delete() {
4485        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4486        PBI_PROGDIRPATH="${PBI_ORIGPROGDIRPATH}"
4487
4488        # Unmount the PBI if its mounted
4489        /usr/pbi/.pbime umount "/usr/pbi/.mounts/`basename $PBI_PROGDIRPATH`"
4490
4491        get_username_from_file "${PBI_DBAPPDIR}/${PBI_DELETENAME}/pbi_name"
4492        if [ "$FILEUSER" != `whoami` -a `id -u` != "0" ] ; then
4493                exit_err "Permission denied to modify PBI installed by: $FILEUSER"
4494        fi
4495
4496        # Set the dirty flag that we are removing this PBI
4497        touch ${PBI_DBAPPDIR}/${PBI_DELETENAME}/.pbiDeleted
4498
4499        check_preremove_script
4500        run_remove_script
4501        remove_pbidir
4502        unregister_pbi
4503       
4504        # Mark the hashdir as dirty
4505        make_hashdir_dirty
4506}
4507
4508# Save the hash-list to run a cleanup afterwards
4509pbirm_save_hashlist() {
4510        if [ "${PBI_DISABLEHASHDIR}" = "YES" ] ; then return 0 ; fi
4511        if [ -e "${PBI_PROGDIRPATH}/${PBI_HASHLIST}" ] ; then
4512                PBI_TMPHASHLIST="${PBI_TMPDIR}/.pbi-hash.$$"
4513                cp ${PBI_PROGDIRPATH}/${PBI_HASHLIST} ${PBI_TMPHASHLIST}
4514        fi
4515}
4516
4517# Function which removes all empty dirs from the hash-dir
4518pbi_clean_emptyhdirs() {
4519        if [ ! -d "${PBI_HASHDIR}" ] ; then return 0 ; fi
4520        cd ${PBI_HASHDIR}
4521        found="0"
4522        for i in `find . -empty -type d 2>/dev/null`
4523        do
4524                if [ "${i}" = "." ] ; then continue ; fi
4525                if [ -d "${PBI_HASHDIR}/${i}" ] ; then
4526                        rmdir "${PBI_HASHDIR}/${i}"
4527                        found="1"
4528                fi     
4529        done
4530
4531        # Run recursively
4532        if [ "$found" = "1" ];then pbi_clean_emptyhdirs ; fi
4533}
4534
4535# Read through and clean the given hash-list
4536pbi_clean_hashlist() {
4537        if [ -z "${PBI_TMPHASHLIST}" ] ; then return 0 ; fi
4538        while read hl
4539        do
4540                file="`echo $hl | sed 's/:::.*$//g'`"
4541                hash="`echo $hl | sed 's/^.*::://g'`"
4542                tfile="${file}:::${hash}"
4543                if [ -f "${PBI_HASHDIR}/${tfile}" ] ; then
4544                        check_remove_hashfile "${tfile}"
4545                fi
4546
4547        done < ${PBI_TMPHASHLIST}
4548        rm ${PBI_TMPHASHLIST}
4549}
4550
4551# Read through and clean the entire hashdir
4552pbi_clean_hashdir() {
4553        if [ ! -d "${PBI_HASHDIR}" ] ; then return 0 ; fi
4554        echo "Cleaning shared-hash dir..."
4555        cd ${PBI_HASHDIR}
4556        tmphashlist="${PBI_TMPDIR}/.pbi-hashdir.$$"
4557        find * -type f -links 1 > "${tmphashlist}" 2>/dev/null
4558        while read hl
4559        do
4560                if [ ! -f "$hl" -o -h "$hl" ] ; then continue ; fi
4561                if [ -f "${PBI_HASHDIR}/${hl}" ] ; then
4562                        check_remove_hashfile "${hl}"
4563                fi
4564
4565        done < $tmphashlist
4566        rm "$tmphashlist"
4567        pbi_clean_emptyhdirs
4568}
4569
4570# Check if this hash-file is ready to be removed from the hash-dir
4571check_remove_hashfile() {
4572        tfile="${PBI_HASHDIR}/${1}"
4573        get_hard_link_count "${tfile}"
4574        if [ "$HLINKS" = "1" ] ; then
4575                if [ "${PBI_VERBOSE}" = "YES" ] ; then
4576                        echo "Removing unused hashfile: $tfile"
4577                fi
4578                rm -f "${tfile}"
4579        fi
4580}
4581
4582# Run the removal script for this PBI
4583run_remove_script() {
4584        uisc="${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/.pbi-uninstall.sh"
4585        if [ ! -e "$uisc" ] ; then return 0 ; fi
4586
4587        # If not running as root, be sure to cleanup path links
4588        if [ "`id -u`" != "0" ]; then
4589                cat ${PBI_PROGDIRPATH}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT} | grep 'rm "$SYS_LOCALBASE/bin' | sed 's|$SYS_LOCALBASE|${HOME}|g' >${PBI_TMPDIR}/.binlnks
4590                while read lnk
4591                do
4592                        /bin/sh -c "${lnk}"
4593                done <${PBI_TMPDIR}/.binlnks
4594                rm ${PBI_TMPDIR}/.binlnks
4595        fi
4596        export_script_vars
4597        if [ "$PBI_VERBOSE" = "YES" ] ; then
4598                sh "${uisc}"
4599        else
4600                sh "${uisc}" >/dev/null 2>/dev/null
4601        fi
4602}
4603
4604# Function to check the supplied $1 dir for any mounts before we
4605# do a rm -rf
4606umount_before_rm()
4607{
4608        if [ -z "${1}" ] ; then return 0 ; fi
4609
4610        local _ddir="$1"
4611        echo "$_ddir" | rev | grep -q '^/'     
4612        if [ $? -ne 0 ] ; then
4613           _ddir="${_ddir}/"
4614        fi
4615       
4616        mount | grep -q "on ${_ddir}"
4617        if [ $? -ne 0 ] ; then return 0; fi
4618
4619        for i in `mount | grep "on ${_ddir}" | awk '{print $3}'`
4620        do
4621           umount -f ${i} >/dev/null 2>/dev/null
4622           if [ $? -ne 0 ] ; then
4623                exit_err "Could not umount ${i} before rm -rf, bailing!"
4624           fi
4625        done
4626        return 0
4627}
4628
4629# Remove the pbi directory
4630remove_pbidir() {
4631        if [ -z "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi
4632        if [ ! -d "${PBI_PROGDIRPATH}" ] ; then return 0 ; fi
4633        if [ "${PBI_PROGDIRPATH}" = "/" ] ; then return 0 ; fi
4634        if [ "$PBI_VERBOSE" = "YES" ] ; then
4635                echo "Removing: ${PBI_PROGDIRPATH}"
4636        fi
4637
4638        # Make sure we are unmounted
4639        umount_before_rm "${PBI_PROGDIRPATH}"
4640       
4641        rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4642
4643        # Do we have leftovers?
4644        if [ -d "${PBI_PROGDIRPATH}" ] ; then
4645                chflags -R noschg "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4646                chmod -R 777 "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4647                rm -rf "${PBI_PROGDIRPATH}" >/dev/null 2>/dev/null
4648        fi
4649}
4650
4651# Remove this PBI registration
4652unregister_pbi() {
4653        if [ -z "${PBI_DBAPPDIR}" ] ; then return 0 ; fi
4654        if [ -z "${PBI_DELETENAME}" ] ; then return 0 ; fi
4655        if [ ! -d "${PBI_DBAPPDIR}/${PBI_DELETENAME}" ] ; then return 0 ; fi
4656        if [ "$PBI_VERBOSE" = "YES" ] ; then
4657                echo "Removing: ${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4658        fi
4659        rm -rf "${PBI_DBAPPDIR}/${PBI_DELETENAME}"
4660
4661}
4662
4663# Check if we have a preinstall script we need to use
4664check_preremove_script() {
4665        if [ ! -e "${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}" ] ; then return 0 ; fi
4666
4667        if [ "$PBI_VERBOSE" = "YES" ] ; then
4668                echo "Running pre-removal script: ${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}"
4669        fi
4670        export_script_vars
4671        sh "${PBI_DBAPPDIR}/${PBI_DELETENAME}/${MOD_PREREM}"
4672}
4673
4674add_app_path_links()
4675{
4676        # If root, run the regular path script
4677        if [ `id -u` = "0" ] ; then
4678                sh "${1}/${PBI_FAKEBIN_DIR}/${PBI_INS_PATHSCRIPT}" >/dev/null 2>/dev/null
4679                return
4680        fi
4681
4682        # Running as user add to ~/bin
4683        init_tmpdir
4684        if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi
4685        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
4686        while read lnk
4687        do
4688                /bin/sh -c "${lnk}"
4689               
4690        done <${PBI_TMPDIR}/.binlnks
4691        rm ${PBI_TMPDIR}/.binlnks
4692       
4693}
4694
4695del_app_path_links()
4696{
4697        # If root, run the regular path script
4698        if [ `id -u` = "0" ] ; then
4699                sh "${1}/${PBI_FAKEBIN_DIR}/${PBI_UNINS_PATHSCRIPT}" >/dev/null 2>/dev/null
4700                return
4701        fi
4702
4703        # Running as user remove from ~/bin
4704        if [ ! -d "${HOME}/bin" ] ; then mkdir -p "${HOME}/bin"; fi
4705        for lnk in `ls ${1}/${PBI_FAKEBIN_DIR}`
4706        do
4707                if [ "$lnk" = "$PBI_INS_PATHSCRIPT" -o "$lnk" = "$PBI_UNINS_PATHSCRIPT" ]
4708                then
4709                        continue
4710                fi
4711
4712                if [ ! -e "${HOME}/bin/$lnk" ] ; then continue ; fi
4713                if [ ! -h "${HOME}/bin/$lnk" ] ; then continue ; fi
4714                       
4715                ls -al "${HOME}/bin/$lnk" | awk '{print $11}' | grep $1 >/dev/null 2>/dev/null
4716                if [ "$?" = "0" ] ; then
4717                        rm ${HOME}/bin/$lnk
4718                fi
4719        done
4720       
4721}
4722
4723pbi_icon_init() {
4724        parse_icon_pbi_cmdline "$@"
4725       
4726        do_pbi_icon
4727}
4728
4729# Start the PBI icon process
4730do_pbi_icon() {
4731        # Get the dir for this PBI
4732        _appDir=`cat ${PBI_DBAPPDIR}/${PBI_ICONTARGETAPP}/pbi_installedpath`
4733
4734        if [ "${PBI_PATHADD}" = "YES" ] ; then
4735                add_app_path_links "$_appDir"
4736        fi
4737        if [ "${PBI_PATHDEL}" = "YES" ] ; then
4738                del_app_path_links "$_appDir"
4739        fi
4740
4741        if [ "${PBI_DESKADD}" = "YES" ] ; then
4742                if [ ! -e "${_appDir}/.xdg-desktop/${PBI_INS_DESKSCRIPT}" ] ; then
4743                        exit_err "No desktop icons for this PBI"
4744                fi
4745                sh "${_appDir}/.xdg-desktop/${PBI_INS_DESKSCRIPT}"
4746        fi
4747        if [ "${PBI_DESKDEL}" = "YES" ] ; then
4748                if [ ! -e "${_appDir}/.xdg-desktop/${PBI_UNINS_DESKSCRIPT}" ] ; then
4749                        exit_err "No desktop icons for this PBI"
4750                fi
4751                sh "${_appDir}/.xdg-desktop/${PBI_UNINS_DESKSCRIPT}"
4752        fi
4753        if [ "${PBI_MENUADD}" = "YES" ] ; then
4754                require_root_or_group
4755                if [ ! -e "${_appDir}/.xdg-menu/${PBI_INS_MENUSCRIPT}" ] ; then
4756                        exit_err "No menu icons for this PBI"
4757                fi
4758                sh "${_appDir}/.xdg-menu/${PBI_INS_MENUSCRIPT}"
4759        fi
4760        if [ "${PBI_MENUDEL}" = "YES" ] ; then
4761                require_root_or_group
4762                if [ ! -e "${_appDir}/.xdg-menu/${PBI_UNINS_MENUSCRIPT}" ] ; then
4763                        exit_err "No menu icons for this PBI"
4764                fi
4765                sh "${_appDir}/.xdg-menu/${PBI_UNINS_MENUSCRIPT}"
4766        fi
4767        if [ "${PBI_MIMEADD}" = "YES" ] ; then
4768                require_root_or_group
4769                if [ ! -e "${_appDir}/.xdg-mime/${PBI_INS_MIMESCRIPT}" ] ; then
4770                        exit_err "No mime registration for this PBI"
4771                fi
4772                sh "${_appDir}/.xdg-mime/${PBI_INS_MIMESCRIPT}"
4773        fi
4774        if [ "${PBI_MIMEDEL}" = "YES" ] ; then
4775                require_root_or_group
4776                if [ ! -e "${_appDir}/.xdg-mime/${PBI_UNINS_MIMESCRIPT}" ] ; then
4777                        exit_err "No mime registration for this PBI"
4778                fi
4779                sh "${_appDir}/.xdg-mime/${PBI_UNINS_MIMESCRIPT}"
4780        fi
4781}
4782
4783pbid_init() {
4784        require_root
4785
4786        parse_pbid_cmdline "$@"
4787
4788        do_pbid
4789}
4790
4791# Start the PBID daemon
4792do_pbid() {
4793
4794        # Start by sourcing /etc/profile
4795        # This grabs any HTTP_ / FTP_ PROXY variables
4796        . /etc/profile
4797
4798        # Allow user supplied logfile
4799        if [ -z "${PBID_LOGFILE}" ] ; then
4800          _pbid_log="/var/log/pbid.log"
4801        else
4802          _pbid_log="${PBID_LOGFILE}"
4803        fi
4804
4805        # Set verbosity
4806        _redir="&1"
4807        if [ "${PBI_VERBOSE}" != "YES" ] ; then _redir="/dev/null" ; fi
4808        echo "Started pbid: `date`" > ${_pbid_log}
4809
4810        while
4811        i=1
4812        do
4813                # Do regular sleeps
4814                qslp=0
4815
4816                # Check if we have any out of date index files to update
4817                for _dbIndex in `ls ${PBI_DBREPODIR}`
4818                do
4819                        _iMd5=`echo ${_dbIndex} | cut -d '.' -f 2`
4820                        check_update_index "${_iMd5}"
4821
4822                        # If we failed to get an index try again sooner
4823                        # This is useful if the user has just installed and has not setup
4824                        # the network yet. We want to fetch indexes quickly after net
4825                        # comes up so they dont need to wait 15 min or whatever its set to
4826                        if [ ! -e "${PBI_DBINDEXDIR}/${_iMd5}-index" ] ; then qslp=1; fi
4827                done
4828
4829                # Check if we have a dirty hash-dir to cleanup
4830                check_clean_hashdir "$_pbid_log" "$_redir"
4831
4832                # Check if we have any PBIs to auto-update
4833                check_autoupdate_pbis "$_pbid_log" "$_redir"
4834
4835                # Check if we need to merge files into the hashdir
4836                if [ -n "`ls ${PBI_DBHASHQUEUEDIR}`" ] ; then
4837                        init_tmpdir
4838                        for _hpbi in `ls ${PBI_DBHASHQUEUEDIR}`
4839                        do
4840                                if [ ! -e "${PBI_DBAPPDIR}/${_hpbi}/pbi_installedpath" ] ; then
4841                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4842                                        continue
4843                                fi
4844
4845                                _hpbipath=""
4846                                _hpbipath=`cat ${PBI_DBAPPDIR}/${_hpbi}/pbi_installedpath`
4847                                if [ ! -e "${_hpbipath}/${PBI_HASHLIST}" ] ; then
4848                                        rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4849                                        continue
4850                                fi
4851
4852                                # Get the username this PBI was installed as
4853                                get_username_from_file "${_hpbipath}"
4854
4855                                # Lets start this hash merge
4856                                echo "Adding ${_hpbipath} to hash-dir ($FILEUSER): `date`" >> ${_pbid_log}
4857
4858                                if [ "$FILEUSER" = "root" ];then
4859                                        pbi_add_update_hashdir "${_hpbipath}" "${PBI_DBAPPDIR}/${_hpbi}/.pbiDeleted" >${_redir} 2>${_redir}
4860                                else
4861                                        # Run hashdir command as a user
4862                                        su $FILEUSER -c "pbi_update_hashdir \"${_hpbipath}\" \"${PBI_DBAPPDIR}/${_hpbi}/.pbiDeleted\"" >${_redir} 2>${_redir}
4863                                fi
4864                                echo "Finished adding ${_hpbipath} to hash-dir: `date`" >> ${_pbid_log}
4865                               
4866                                # Now remove the trigger file
4867                                rm ${PBI_DBHASHQUEUEDIR}/${_hpbi}
4868
4869                        done
4870                        rm_tmpdir
4871
4872                fi
4873               
4874                # Check if we should rotate the logfile
4875                _pbidLines=`wc -l ${_pbid_log} | awk '{ print $1 }'`
4876                if [ $(is_num "$_pbidLines") ] ; then
4877                        if [ $_pbidLines -gt $PBI_LOG_LINES ] ; then
4878                                echo "Logfile turnover: `date`" >${_pbid_log}
4879                        fi
4880                fi
4881               
4882
4883                # Done with our check, lets go back to sleep now
4884                if [ $qslp -eq 1 ] ; then
4885                        sleep 60
4886                else
4887                        sleep ${PBIDSLEEP}
4888                fi
4889        done
4890
4891}
4892
4893# Check if there are any PBIs which are flagged for auto-updates
4894check_autoupdate_pbis() {
4895
4896        for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
4897        do
4898                if [ ! -e "${PBI_DBAPPDIR}/${i}/autoupdate-enable" ] ; then
4899                        continue
4900                fi
4901
4902                # Check if this app is already updating
4903                if [ -e "${PBI_DBAPPDIR}/${i}/.updating" ] ; then
4904                        ps -p `cat ${PBI_DBAPPDIR}/${i}/.updating` >/dev/null 2>/dev/null
4905                        if [ "$?" != "0" ] ; then
4906                                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
4907                        else
4908                                continue
4909                        fi
4910                fi
4911
4912                # Found an auto-update enabled APP, see if it needs upping
4913                PBI_UPDATEAPP="$i"
4914
4915                # Load the details about this app
4916                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4917                if [ -z "${PBI_REPO}" ]; then
4918                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4919                fi
4920                if [ -z "${PBI_REPO}" ]; then continue ; fi
4921                local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
4922
4923                # Does this need an update?
4924                check_pbi_update "$PBI_UPDATEAPP" "nodisplay" \
4925                        "$PBI_PROGNAME" "current" \
4926                        "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
4927                if [ "$?" != "0" ] ; then
4928                        continue
4929                fi
4930               
4931                # Get the username this PBI was installed as
4932                get_username_from_file "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
4933
4934                # Its Update Time!
4935                echo "Starting Auto-Update of ${PBI_UPDATEAPP} ($FILEUSER): `date`" >>${_pbid_log}
4936
4937                su ${FILEUSER} -c "pbi_update ${PBI_UPDATEAPP}" >>${_pbid_log} 2>>${_pbid_log}
4938                if [ "$?" = "0" ] ; then
4939                        echo "Success! Update of ${PBI_UPDATEAPP}: `date`" >>${_pbid_log}
4940                else
4941                        echo "Failed! Update of ${PBI_UPDATEAPP}: `date`" >>${_pbid_log}
4942                fi
4943
4944                rm "${PBI_DBAPPDIR}/${i}/.updating" >/dev/null 2>/dev/null
4945        done
4946}
4947
4948check_clean_hashdir() {
4949        if [ ! -e "${PBI_DBDIRTYFILE}" ] ; then return ; fi
4950
4951        # Get the date of the last hash-cleaning done
4952        local _curDate="`cat ${PBI_DBDIRTYFILE}`"
4953        if [ -e "${PBI_DBDIRTYFILE}.last" ] ; then
4954                local _lastDate="`cat ${PBI_DBDIRTYFILE}.last`"
4955        else
4956                local _lastDate="0"
4957        fi
4958
4959        # See if we have a new date trigger to do a cleaning
4960        if [ "$_curDate" = "${_lastDate}" ]; then return; fi
4961
4962        # Loop through and clean any hash-dirs as the appropriate user
4963        for cHdir in `ls -d ${PBI_HASHDIR}*`
4964        do
4965                get_username_from_file "${cHdir}"
4966                echo "Cleaning hash-dir ($FILEUSER): `date`" >> ${1}
4967                su ${FILEUSER} -c "pbi_delete --clean-hdir" >>${2} 2>>${2}
4968                echo "Finished cleaning hash-dir ($FILEUSER): `date`" >> ${1}
4969                echo "$_curDate" > ${PBI_DBDIRTYFILE}.last 2>/dev/null
4970        done
4971}
4972
4973pbi_info_init() {
4974        parse_info_pbi_cmdline "$@"
4975       
4976        do_pbi_info
4977}
4978
4979# Display information on the PBI / PBIs
4980do_pbi_info() {
4981
4982        # If we are listing available PBIs via the index file
4983        if [ "$PBI_INFOINDEX" = "YES" ] ; then
4984               
4985                # List the available PBIs from the index
4986                do_index_listing
4987               
4988                exit_trap
4989        fi
4990
4991        if [ "$PBI_INFONAME" = "--ALL--" ] ; then
4992                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
4993                do
4994                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
4995                                if [ "$PBI_VERBOSE" = "YES" ] ; then
4996                                        load_info_from_dir "${PBI_DBAPPDIR}/${i}"
4997                                        get_username_from_file "${PBI_DBAPPDIR}/${i}"
4998                                        PBI_INSTALLED_BY=$FILEUSER
4999                                        pbi_display_info
5000                                        pbi_display_gui "${PBI_DBAPPDIR}/${i}" ""
5001                                        echo " "
5002                                else
5003                                        echo "${i}"
5004                                fi
5005                        fi
5006                done
5007        else
5008                # Start loading our variables
5009                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_INFONAME}"
5010                get_username_from_file "${PBI_DBAPPDIR}/${PBI_INFONAME}"
5011                PBI_INSTALLED_BY=$FILEUSER
5012                pbi_display_info
5013        fi
5014}
5015
5016# Read through the master index file and provide listing of available PBIs for installation
5017do_index_listing()
5018{
5019        # Make sure we have a master index
5020        ls ${PBI_DBINDEXDIR}/* >/dev/null 2>/dev/null
5021        if [ "$?" != "0" ] ; then return ; fi
5022
5023        for _rIndex in `ls ${PBI_DBINDEXDIR}/*index* | grep -v '.time'`
5024        do
5025                _rMd5=`basename ${_rIndex} | sed 's|-index||g'`
5026                _rDesc=`cat ${PBI_DBREPODIR}/*.${_rMd5} | grep 'Desc: ' | sed 's|Desc: ||g'`
5027                echo "Current and available PBIs. * = current"
5028                echo "Repository: $_rDesc"
5029                echo "----------------------------------------------------------------"
5030
5031                sort "${_rIndex}" | while read _iLine
5032                do
5033                        PBI_UPNAME="`echo $_iLine | cut -d ':' -f 1`"
5034                        PBI_UPARCH="`echo $_iLine | cut -d ':' -f 2`"
5035                        PBI_UPNVER="`echo $_iLine | cut -d ':' -f 3`"
5036                        PBI_UPSTATUS="`echo $_iLine | cut -d ':' -f 9`"
5037                        pad_var "${PBI_UPNAME}" "30"
5038                        PBI_UPNAME="${PAD_VAR}"
5039                        pad_var "${PBI_UPNVER}" "15"
5040                        PBI_UPNVER="${PAD_VAR}"
5041                        pad_var "${PBI_UPARCH}" "6"
5042                        PBI_UPARCH="${PAD_VAR}"
5043       
5044                        if [ "$PBI_UPSTATUS" = "current" ] ; then
5045                                echo "$PBI_UPNAME   $PBI_UPNVER $PBI_UPARCH *"
5046                        fi
5047                        if [ "$PBI_UPSTATUS" = "active" ] ; then
5048                                echo "$PBI_UPNAME   $PBI_UPNVER $PBI_UPARCH"
5049                        fi
5050                done
5051        done
5052
5053}
5054
5055# Function to pad a variable to X spaces
5056pad_var() {
5057        local _pVar="$1"
5058        local _pNum="$2"
5059        PAD_VAR="`echo \"$_pVar                                                                                    x\" | cut -c 1-$_pNum`"
5060}
5061
5062# Checks if we have a custom script to run prior to port make
5063run_pbi_preportmake()
5064{
5065        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5066        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5067        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-portmake.sh" ] ; then return 0 ; fi
5068
5069        export_script_vars
5070
5071        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-portmake.sh"
5072        if [ "$?" != "0" ] ; then
5073                exit_err "pre-portmake.sh failed!"
5074        fi
5075}
5076
5077# Checks if we have a custom script to run prior to port make
5078run_pbi_postportmake()
5079{
5080        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5081        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5082        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/post-portmake.sh" ] ; then return 0 ; fi
5083
5084        export_script_vars
5085
5086        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/post-portmake.sh"
5087        if [ "$?" != "0" ] ; then
5088                echo "Warning: post-portmake.sh returned non-0 status!"
5089        fi
5090}
5091
5092# Checks if we have a custom script to run prior to pbi create
5093run_pbi_prepkgscript()
5094{
5095        if [ ! -d "${PBI_CONFDIR}" ] ; then return 0 ; fi
5096        if [ ! -d "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}" ] ; then return 0 ; fi
5097        if [ ! -e "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-pbicreate.sh" ] ; then return 0 ; fi
5098
5099        export_script_vars
5100
5101        sh "${PBI_CONFDIR}/${PBI_CONF_SCRIPTSDIR}/pre-pbicreate.sh"
5102        if [ "$?" != "0" ] ; then
5103                echo "Warning: post-portmake.sh returned non-0 status!"
5104        fi
5105}
5106
5107# Begins the port make
5108start_pbi_makeport()
5109{
5110        do_port_build "${PBI_MAKEPORT}"
5111}
5112
5113# Prune any ports which aren't required for runtime
5114start_pbi_prune_ports()
5115{
5116        if [ "${PBI_PRUNEBUILDPORTS}" = "NO" ] ; then return ; fi
5117
5118        get_pkgname "${PBI_MAKEPORT}"
5119        echo "${PKGNAME}" > /.keepports
5120        make -C "${PORTSDIR}/${PBI_MAKEPORT}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5121
5122        # Do the same for any OTHERPORTS
5123        for port in ${PBI_MKPORTBEFORE}
5124        do
5125                if [ ! -d "${PORTSDIR}/${port}" ] ; then continue ; fi
5126                get_pkgname "${port}"
5127                echo "${PKGNAME}" >> /.keepports
5128                make -C "${PORTSDIR}/${port}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5129        done
5130
5131        for port in ${PBI_MKPORTAFTER}
5132        do
5133                if [ ! -d "${PORTSDIR}/${port}" ] ; then continue ; fi
5134                get_pkgname "${port}"
5135                echo "${PKGNAME}" >> /.keepports
5136                make -C "${PORTSDIR}/${port}" PORTSDIR=${PORTSDIR} package-depends | cut -d: -f1 >> /.keepports
5137        done
5138
5139        # Don't strip out pkgng
5140        pkg info pkg >> /.keepports
5141       
5142        # Sort and clean the ports
5143        cat /.keepports | sort | uniq > /.keepports.tmp
5144        mv /.keepports.tmp /.keepports
5145
5146        # Now remove any unused ports
5147        for j in `pkg info -a | cut -d " " -f 1`
5148        do
5149                grep -q "^${j}" "/.keepports"
5150                if [ $? -ne 0 ] ; then
5151                        echo "Removing non-required port: ${j}"
5152                        $PKG_DELETE ${j} 
5153                fi
5154        done
5155}
5156
5157# Get the full package-name for a target port
5158get_pkgname() {
5159        name="`pkg info -O ${1} | awk '{print $1}'`"
5160        PKGNAME="${name}"
5161}
5162
5163# Make any additional required ports
5164start_pbi_mkportbefore()
5165{
5166        if [ -z "${PBI_MKPORTBEFORE}" ] ; then return ; fi
5167       
5168        for port in ${PBI_MKPORTBEFORE}
5169        do
5170                if [ ! -d "/usr/ports/${port}" ] ; then
5171                        exit_err "/usr/ports/${port} does not exist!"
5172                fi
5173                do_port_build "${port}"
5174        done
5175
5176}
5177
5178# Make any additional required ports
5179start_pbi_mkportafter()
5180{
5181        if [ -z "${PBI_MKPORTAFTER}" ] ; then return ; fi
5182       
5183        for port in ${PBI_MKPORTAFTER}
5184        do
5185                if [ ! -d "/usr/ports/${port}" ] ; then
5186                        exit_err "/usr/ports/${port} does not exist!"
5187                fi
5188                do_port_build "${port}"
5189        done
5190
5191}
5192
5193# Start pbi_update_hashdir
5194pbi_update_hashdir_init() {
5195        pbi_add_update_hashdir "$1" "$2"
5196}
5197
5198# Start pbi_update processing
5199pbi_update_init() {
5200
5201        parse_update_pbi_cmdline "$@"
5202
5203        check_enable_disable_auto
5204
5205        # Stop here if we are just enabling / disabling auto-update
5206        if [ -n "$PBI_UPENABLEAUTO" ] ; then return 0 ; fi
5207
5208        start_update_checks
5209        if [ "$?" != "0" ] ; then rm_tmpdir ; exit 1 ; fi
5210
5211        # Stop here if only doing update checks
5212        if [ -n "${PBI_UPCHECK}" ]; then return 0 ; fi
5213
5214        require_root_or_group
5215
5216        do_pbi_update
5217}
5218
5219# Check if we are enabling / disabling auto-updating
5220check_enable_disable_auto()
5221{
5222        if [ -z "$PBI_UPENABLEAUTO" ] ; then return ; fi
5223        if [ ! -d "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}" ] ; then return ; fi
5224
5225        # Enable / disable auto-updating now
5226        if [ "$PBI_UPENABLEAUTO" = "YES" ]; then
5227                touch ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable
5228        else
5229                rm ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable >/dev/null 2>/dev/null
5230        fi
5231}
5232
5233# Function which checks the digital signature of a PBI to match it to a particular repo
5234pbi_checksig_repomatch() {
5235        if [ `id -u` != "0" ] ; then return ; fi
5236
5237        # See which repo / key this PBI associates to, if any
5238        check_valid_sigs "${1}"
5239        if [ "$?" = "0" -a -n "$PBI_VALIDKEYSIG" ] ; then
5240                _rMd5="`echo ${PBI_VALIDKEYSIG} | cut -d '.' -f 1`"
5241                echo "$_rMd5" | sed "s|${PBI_DBKEYDIR}/||g" > ${1}/pbi_repo
5242        fi
5243}
5244
5245# See if we are checking for updates and do it
5246start_update_checks() {
5247        if [ "${PBI_UPCHECK}" != "YES" -a "${PBI_UPCHECK}" != "ALL" ]; then return 0; fi
5248
5249        # Open up the tmpdir
5250        init_tmpdir
5251
5252        if [ "${PBI_UPCHECK}" = "YES" ] ; then
5253                load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5254                if [ -z "${PBI_REPO}" ]; then
5255                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5256                fi
5257                if [ -z "${PBI_REPO}" ]; then
5258                        return 1
5259                else
5260                        local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5261                fi
5262
5263                check_pbi_update "$PBI_UPDATEAPP" "display" \
5264                 "$PBI_PROGNAME" "current" \
5265                 "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5266                return $?
5267        else
5268                # Loop and check all PBIs for updates
5269                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5270                do
5271                        PBI_REPO=""
5272                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5273                                load_info_from_dir "${PBI_DBAPPDIR}/${i}"
5274                                if [ -z "${PBI_REPO}" ]; then
5275                                        pbi_checksig_repomatch "${PBI_DBAPPDIR}/${i}"
5276                                fi
5277                                if [ -z "${PBI_REPO}" ]; then
5278                                        continue
5279                                else
5280                                        local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5281                                fi
5282
5283                                check_pbi_update "$i" "display" \
5284                                 "$PBI_PROGNAME" "current" \
5285                                 "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5286                        fi
5287                done
5288                return 0
5289        fi
5290
5291}
5292
5293# Check if we need to pull down the updated INDEX file
5294check_update_index() {
5295
5296        init_tmpdir
5297       
5298        local _repoMd5="$1"
5299        local _rURL=`cat ${PBI_DBREPODIR}/*${_repoMd5} | grep URL: | sed 's|URL: ||g'`
5300
5301        _pbiIndex="${PBI_DBINDEXDIR}/${_repoMd5}-index"
5302        _pbiMeta="${PBI_DBINDEXDIR}/${_repoMd5}-meta"
5303        _pbiIndexTime="${_pbiIndex}.time"
5304        _tmpPbiIndex="${PBI_TMPDIR}/.upcheck$$"
5305        _tmpPbiMeta="${PBI_TMPDIR}/.upcheck$$"
5306               
5307        # Check if its been greater than $PBI_INDEXREFRESH hours since the last update
5308        if [ -e "${_pbiIndexTime}" ] ; then
5309                _curTime=`date +%s`
5310                _oTime=`cat ${_pbiIndexTime}`
5311                _trigTime=`expr ${PBI_INDEXREFRESH} \* 60 \* 60`
5312                expr $_curTime - $_oTime >/dev/null 2>/dev/null
5313                if [ "$?" = "0" ] ; then
5314                        _passed=`expr $_curTime - $_oTime`
5315                        if [ "$_passed" -lt "$_trigTime" ] ; then
5316                                return;
5317                        fi
5318                fi
5319               
5320        fi
5321
5322        if [ "${PBI_VERBOSE}" = "YES" ] ; then
5323                echo "Updating index ${_pbiIndex}"
5324                echo "Updating index ${_pbiIndex}: `date`" >> ${_pbid_log}
5325        fi
5326
5327        # Check that the last char isn't a '/'
5328        _tmp=`echo ${_rURL} | wc -m | tr -s ' ' | tr -d ' '`
5329        _tmp2=`expr $_tmp - 1`
5330        _lastC=`echo ${_tmp} | cut -c ${_tmp2}-${_tmp}`
5331        if [ "${_lastC}" = "/" ] ; then
5332                _upURL="`echo ${_rURL} | sed 's|\(.*\).|\1|'`"
5333        else
5334                _upURL="${_rURL}"
5335        fi
5336
5337        fetch -o "${_tmpPbiIndex}.bz2" "${_upURL}/${PBI_INDEXUPFILE}.bz2" >/dev/null 2>/dev/null
5338        if [ "$?" != "0" ] ; then
5339                return
5340        fi
5341
5342        bzip2 -d "${_tmpPbiIndex}.bz2" >/dev/null 2>/dev/null
5343        if [ "$?" != "0" ] ; then
5344                return
5345        fi
5346
5347        # Move the uncompressed file
5348        mv "${_tmpPbiIndex}" "${_pbiIndex}" >/dev/null 2>/dev/null
5349
5350        # Wait a sec
5351        sleep 1
5352
5353        # Now check for an optional meta file update
5354        fetch -o "${_tmpPbiMeta}.bz2" "${_upURL}/${PBI_METAUPFILE}.bz2" >/dev/null 2>/dev/null
5355        if [ "$?" = "0" ] ; then
5356                bzip2 -d "${_tmpPbiMeta}.bz2" >/dev/null 2>/dev/null
5357                if [ "$?" = "0" ] ; then
5358                        mv "${_tmpPbiMeta}" "${_pbiMeta}" >/dev/null 2>/dev/null
5359                fi
5360        fi
5361
5362        # Update the icons for this repos meta file
5363        update_repo_icons "${_repoMd5}" "${_pbiMeta}"
5364
5365        echo "Finished updating index ${_pbiIndex}: `date`" >> ${_pbid_log}
5366        if [ "${PBI_VERBOSE}" = "YES" ] ; then
5367                echo "Finished updating index ${_pbiIndex}"
5368        fi
5369
5370        # Save the time that we are done
5371        date +%s > ${_pbiIndexTime}
5372
5373}
5374
5375# Check if we need to update any repository icons
5376update_repo_icons() {
5377        _repoMd5="$1"
5378        _repoMeta="$2"
5379
5380        echo "Updating meta-icons for $_repoMeta: `date`" >> ${_pbid_log}
5381
5382        # Loop through, downloading icons we find
5383        while read mLine
5384        do
5385                # Make sure this is an app / cat
5386                echo "$mLine" | grep -e "^App=" -e "^Cat=" >/dev/null 2>/dev/null
5387                if [ "$?" != "0" ] ; then continue ; fi
5388
5389                # Get the icon URL
5390                echo "$mLine" | grep "^App=" >/dev/null 2>/dev/null
5391                if [ "$?" = "0" ] ; then
5392                        line=`echo $mLine | sed 's|^App=||g'`
5393                        aIcon=`echo $line | cut -d ';' -f 3`
5394                else
5395                        line=`echo $mLine | sed 's|^Cat=||g'`
5396                        aIcon=`echo $line | cut -d ';' -f 2`
5397                fi
5398                iName=`echo $line | cut -d ';' -f 1`
5399                ext=`echo $aIcon | sed 's/.*\.//'`
5400       
5401                # If we already have this icon, we can skip
5402                if [ -e "${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}" ] ; then
5403                        continue
5404                fi
5405
5406                # Now fetch the file
5407                sFile="${PBI_DBICONDIR}/${_repoMd5}-${iName}.${ext}"
5408                fetch -o "${sFile}" "${aIcon}" >/dev/null 2>/dev/null
5409                if [ $? -ne 0 ]; then
5410                  # Wait a moment before trying the next
5411                  sleep 40
5412                fi
5413               
5414        done < ${_repoMeta}
5415}
5416
5417# Check a specific PBI for updates
5418check_pbi_update() {
5419
5420        # Init the tmpdir
5421        init_tmpdir
5422
5423        # Set the vars
5424        _upbi="${1}"
5425        _udisp="${2}"
5426        _uprog="${3}"
5427        _uver="${4}"
5428        _ufbsdver="${5}"
5429        _uarch="${6}"
5430        _urepo="${7}"
5431        _omdate="${8}"
5432
5433        _uprog="`echo ${_uprog} | tr -d ' '`"
5434        appname="`echo ${_uprog} | tr '[:lower:]' '[:upper:]'`"
5435
5436        PBI_UPNVER=""
5437        PBI_UPFILE=""
5438        PBI_UPPATCHES=""
5439        PBI_UPCSUM=""
5440        PBI_UPMDATE=""
5441        PBI_UPREPO=""
5442        PBI_UPSIZE=""
5443
5444        # If we are looking for the current app, set _uver accordingly
5445        if [ "$_uver" = "current" ] ; then
5446                _uver=":current"
5447        else
5448                _uver=":${_uver}:"
5449        fi
5450
5451
5452        for _repo in `ls ${PBI_DBINDEXDIR}`
5453        do
5454
5455                if [ "$_urepo" = "AUTO" ] ; then
5456                        _pbiIndex="${PBI_DBINDEXDIR}/${_repo}"
5457                        _rMd5="`echo ${_repo} | sed 's|-index||g'`"
5458                else
5459                        _rMd5=`ls ${PBI_DBREPODIR}/${_urepo}.* | cut -d '.' -f 2`
5460                        _pbiIndex="${PBI_DBINDEXDIR}/${_rMd5}-index"
5461                fi
5462
5463                if [ ! -e "${_pbiIndex}" ] ; then continue ; fi
5464
5465                # Search the update index for the specified PBI
5466                _upLine=`grep -i -e "^$_uprog:" ${_pbiIndex} | grep ":$_uarch:" | grep "$_uver" | head -n 1`
5467
5468                PBI_UPNVER="`echo $_upLine | cut -d ':' -f 3`"
5469                PBI_UPFILE="`echo $_upLine | cut -d ':' -f 6`"
5470                PBI_UPPATCHES="`echo $_upLine | cut -d ':' -f 8`"
5471                PBI_UPCSUM="`echo $_upLine | cut -d ':' -f 4`"
5472                PBI_UPMDATE="`echo $_upLine | cut -d ':' -f 5`"
5473                PBI_UPSIZE="`echo $_upLine | cut -d ':' -f 8`"
5474                PBI_UPMIRROR="`cat ${PBI_DBMIRRORDIR}/${_rMd5} 2>/dev/null`"
5475                PBI_UPREPO="${_rMd5}"
5476
5477                if [ -n "${PBI_UPNVER}" ] ; then break; fi
5478                if [ "${_urepo}" != "AUTO" ] ; then break; fi
5479
5480        done
5481
5482        # If no new version
5483        if [ -z "$PBI_UPNVER" ] ; then return 1 ; fi
5484
5485        # See if this update is newer than the installed date
5486        if [ -n "$_omdate" ] ; then
5487                nDay=`echo $PBI_UPMDATE | cut -d ' ' -f 1`
5488                nHour=`echo $PBI_UPMDATE | cut -d ' ' -f 2`
5489                oDay=`echo $_omdate | cut -d ' ' -f 1`
5490                oHour=`echo $_omdate | cut -d ' ' -f 2`
5491         
5492                # Make sure we have all legit numbers
5493                if [ $(is_num "$nDay") -a $(is_num "$nHour") \
5494                        -a $(is_num "$oDay") -a $(is_num "$oHour") ] ; then
5495                        if [ $oDay -gt $nDay ] ; then return 1 ; fi
5496                        if [ "$oDay" = "$nDay" -a $oHour -gt $nHour ] ; then return 1 ; fi
5497                fi
5498        fi
5499
5500        if [ "$PBI_UPNVER" != "$PBI_PROGVERSION" ] ; then
5501                if [ "$_udisp" = "display" ] ; then
5502                        echo "${_upbi} - Available: ${PBI_UPNVER}"
5503                fi
5504                return 0
5505        else
5506                return 1
5507        fi
5508}
5509
5510# Start PBI update process
5511do_pbi_update() {
5512        if [ -n "${PBI_UPCHECK}" ]; then return 0 ; fi
5513
5514        if [ "$PBI_UPDATEAPP" = "ALL" ] ; then
5515                # Loop and check all PBIs for updates
5516                for i in `ls ${PBI_DBAPPDIR}/ 2>/dev/null`
5517                do
5518                        if [ -e "${PBI_DBAPPDIR}/${i}/.updating" ] ; then
5519                                ps -p `cat ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating` >/dev/null 2>/dev/null
5520                                if [ "$?" = "0" ] ; then
5521                                        continue
5522                                fi
5523                                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5524                        fi
5525                        if [ -e "${PBI_DBAPPDIR}/${i}/pbi_name" ] ; then
5526                                PBI_UPDATEAPP="${i}"
5527                                start_pbi_updateapp "all"
5528                        fi
5529                done
5530        else
5531                if [ -e "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" ] ; then
5532                        ps -p `cat ${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating` >/dev/null 2>/dev/null
5533                        if [ "$?" = "0" ] ; then
5534                                exit_err "This application is currently updating."
5535                        fi
5536                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5537                fi
5538                start_pbi_updateapp "single"
5539                exit $?
5540        fi
5541}
5542
5543# Attempt to download a PBI from the update server for "pbi_add -r"
5544pbi_add_fetch_remote() {
5545        # Set the target program we want to download
5546        _rtar="$PBI_FILENAME"
5547        unset PBI_FILENAME
5548
5549        # Check if the user overrode the arch / versions we want to install
5550        _rArch=`uname -m`
5551        if [ -n "$PBI_ADD_ALTARCH" ] ; then _rArch=$PBI_ADD_ALTARCH ; fi
5552
5553        _rVer="current"
5554        if [ -n "$PBI_ADD_ALTVER" ] ; then _rVer=$PBI_ADD_ALTVER ; fi
5555
5556        check_pbi_update "$_rtar" "nodisplay" \
5557         "$_rtar" "$_rVer" \
5558         "$FBSDMAJOR" "$_rArch" "${PBI_ADDREPO_ID}"
5559        if [ "$?" != "0" ] ; then 
5560                # If we are on amd64, do a fallback check to i386 for this PBI
5561                # This catches apps like wine / skype and others
5562                if [ "$_rArch" = "amd64" ] ; then
5563                        _rArch="i386"
5564                        check_pbi_update "$_rtar" "nodisplay" \
5565                        "$_rtar" "$_rVer" \
5566                        "$FBSDMAJOR" "$_rArch" "${PBI_ADDREPO_ID}"
5567                        if [ "$?" != "0" ] ; then
5568                                exit_err "Could not find \"$_rtar\" in any indexes" 
5569                        fi
5570                else
5571                        exit_err "Could not find \"$_rtar\" in any indexes" 
5572                fi
5573        fi
5574
5575        # We've gotten this far, now download the updated PBI
5576        pbi_update_dl
5577        if [ "$?" != "0" ] ; then
5578                exit_err "Failed downloading PBI"
5579        fi
5580
5581        # Now overwrite the PBI_FILENAME and let us proceed to regular install
5582        PBI_FILENAME="$PBI_UPDLFILE"
5583
5584        # If we are only fetching, finish up now
5585        if [ "$PBI_REMOTEFETCHONLY" = "YES" ] ; then
5586                mv $PBI_FILENAME ./`basename ${PBI_UPFILE}`
5587                echo "PBI saved to ./`basename ${PBI_UPFILE}`"
5588                exit_trap
5589        fi
5590
5591}
5592
5593# Update the targed PBI
5594start_pbi_updateapp() {
5595        _upact="${1}"
5596        if [ "$2" = "pbid" ] ; then
5597                _pbidlog="$2"
5598        else
5599                _pbidlog=""
5600        fi
5601
5602        echo "$$" > "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5603
5604        # Check for update to this app, and exit or return if not available
5605        load_info_from_dir "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5606        if [ -z "${PBI_REPO}" ]; then
5607                pbi_checksig_repomatch "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}"
5608        fi
5609        if [ -z "${PBI_REPO}" ]; then
5610                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5611                return 1
5612        else
5613                local _repoID=`ls ${PBI_DBREPODIR}/*.${PBI_REPO} | cut -d '.' -f 1 | sed "s|${PBI_DBREPODIR}/||g"`
5614        fi
5615
5616        check_pbi_update "$PBI_UPDATEAPP" "nodisplay" \
5617         "$PBI_PROGNAME" "current" \
5618         "$PBI_FBSDVER" "$PBI_APPARCH" "$_repoID" "$PBI_PROGMDATE"
5619        if [ "$?" != "0" ] ; then
5620                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5621                if [ "$_upact" = "single" ] ; then
5622                        exit_err "$PBI_UPDATEAPP - no update available!"
5623                else
5624                        return 1
5625                fi
5626        fi
5627       
5628       
5629        echo "Starting update of ${PBI_UPDATEAPP} to ${PBI_UPNVER}..."
5630        _pbilow="`echo ${PBI_PROGNAME} | tr '[:upper:]' '[:lower:]' | sed 's| ||g'`"
5631
5632        # Check if there is a possible patch file for this update
5633        # new filename to download
5634        _pFile="${_pbilow}-${PBI_PROGVERSION}_to_${PBI_UPNVER}-${PBI_APPARCH}.pbp"
5635
5636        # Try downloading the patch file
5637        echo "Trying update via patchfile..."
5638        pbi_update_dl "$_pFile" "OFF"
5639        if [ "$?" = "0" ] ; then
5640                # We had a good patch download, try applying it now
5641                echo "Updating via patch file..."
5642                pbi_patch "$PBI_UPDLFILE" #>/dev/null 2>/dev/null
5643                if [ "$?" != "0" ] ; then
5644                        # Patching failed, we'll grab a fresh copy next
5645                        echo "Failed to patch with ${_pFile}"
5646                        echo "Will try full file update"
5647                else
5648                        echo "Patch successful!"
5649                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" >/dev/null 2>/dev/null
5650                        rm "${PBI_UPDLFILE}" >/dev/null 2>/dev/null
5651                        return 0
5652                fi
5653                       
5654        fi
5655
5656        # No patch file, grab the full app
5657        echo "Trying update via full-file..."
5658        pbi_update_dl
5659        if [ "$?" != "0" ] ; then
5660                if [ "$_upact" = "single" ] ; then
5661                        rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating"
5662                        exit_err "Failed downloading update!"
5663                fi
5664        fi
5665
5666        echo " "
5667
5668        # Save the auto-update status
5669        if [ -e "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/autoupdate-enable" ] ; then
5670                _autoUpEnable="YES"
5671        else
5672                _autoUpEnable="NO"
5673        fi
5674       
5675        echo -e "Removing old version...\c"
5676        pbi_delete "${PBI_UPDATEAPP}"
5677        echo "Done"
5678
5679        # Now install new PBI
5680        echo -e "Installing new version...\c"
5681        pbi_add --licagree -f "$PBI_UPDLFILE" >/dev/null 2>/dev/null
5682        if [ "$?" != "0" ] ; then
5683                echo "Failed to install PBI: ${PBI_UPDLFILE}"
5684                rm "${PBI_UPDLFILE}"
5685                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" 2>/dev/null
5686                return 1
5687        else
5688                if [ "$_autoUpEnable" = "YES" ] ; then
5689                        touch "${PBI_DBAPPDIR}/${_pbilow}-${PBI_UPNVER}-${PBI_APPARCH}/autoupdate-enable"
5690                fi
5691                echo "Done"
5692                rm "${PBI_UPDLFILE}"
5693                rm "${PBI_DBAPPDIR}/${PBI_UPDATEAPP}/.updating" 2>/dev/null
5694                return 0
5695        fi     
5696}
5697
5698# Start downloading the update
5699pbi_update_dl() {
5700
5701        _tPatch=$1
5702        local _CKSUM="$2"
5703       
5704        # Set local download location
5705        _dl_loc="${PBI_APPDIR}/.`basename $PBI_UPFILE`"
5706
5707        # Have a patch file to download instead, make that the active file to try
5708        if [ -n "$_tPatch" ] ; then
5709                _bDir=`dirname $PBI_UPFILE`
5710                _uFile="${_bDir}/${_tPatch}"
5711        else
5712                _uFile="${PBI_UPFILE}"
5713        fi
5714
5715        _mirrorList=`echo $PBI_UPMIRROR | sed 's|\n| |g'`
5716
5717        # Start download from repos mirror(s) in order
5718        for _cMirror in $_mirrorList
5719        do
5720                if [ "$_cMirror" = "PCBSDCDN" -o "$_cMirror" = "http://pbi.cdn.pcbsd.org" ] ; then
5721
5722                        # Strip the /PBI from the mirror URL
5723                        _uFile="`echo ${_uFile} | sed 's|^/PBI||g'`"
5724                        if [ -e "$_dl_loc" ] ; then rm "$_dl_loc" ; fi 
5725
5726                        get_file_from_mirrors "${_uFile}" "$_dl_loc" "pbi"
5727                        if [ "$?" != "0" ]  ; then
5728                                rm "${_dl_loc}" >/dev/null 2>/dev/null
5729                                echo "Download Failed: ${_furl}"
5730                                continue
5731                        fi
5732                else
5733                        _furl="`echo $_cMirror | sed 's/\/*$//'`${_uFile}"
5734                        if [ -e "$_dl_loc" ] ; then rm "${_dl_loc}" ; fi       
5735
5736                        echo "Downloading ${_furl}"
5737                        pbi_get_file "$_furl" "$_dl_loc"
5738                        if [ "$?" != "0" ]  ; then
5739                                rm "${_dl_loc}" >/dev/null 2>/dev/null
5740                                echo "Download Failed: ${_furl}"
5741                                continue
5742                        fi
5743                fi
5744                sync
5745                sleep 1
5746                _upcsum=`sha256 -q "$_dl_loc"`
5747                if [ "$_CKSUM" != "OFF" -a "$_upcsum" != "$PBI_UPCSUM" ] ; then
5748                        rm "${_dl_loc}" >/dev/null 2>/dev/null
5749                        echo "Download fails checksum: ${_furl}"
5750                        continue
5751                fi
5752
5753                # If we get this far, we have a good file!
5754                PBI_UPDLFILE="$_dl_loc"
5755                sync
5756                return 0
5757        done
5758
5759        return 1
5760}
5761
5762# Function to download a file from remote using fetch
5763pbi_get_file() {
5764        _rf="${1}"
5765        _lf="${2}"
5766
5767        init_tmpdir
5768        if [ -e "${_lf}" ] ; then
5769                echo "Resuming download of: ${_lf}"
5770        fi
5771
5772        if [ "$PBI_FETCH_PARSING" != "YES" ] ; then
5773                fetch -r -o "${_lf}" "${_rf}"
5774                _err=$?
5775        else
5776                # Doing a front-end download, parse the output of fetch
5777                _eFile="${PBI_TMPDIR}/.fetch-exit.$$"
5778                fetch -s "${_rf}" > ${PBI_TMPDIR}/.fetch-size.$$ 2>/dev/null
5779                _fSize=`cat ${PBI_TMPDIR}/.fetch-size.$$ 2>/dev/null`
5780                _fSize="`expr ${_fSize} / 1024 2>/dev/null`"
5781                rm "${PBI_TMPDIR}/.fetch-size.$$" 2>/dev/null
5782                _time=1
5783
5784                ( fetch -r -o "${_lf}" "${_rf}" >/dev/null 2>/dev/null ; echo "$?" > ${_eFile} ) &
5785                FETCH_PID=`ps -auwwwx | grep -v grep | grep "fetch -r -o ${_lf}" | awk '{print $2}'`
5786                while :
5787                do
5788                        if [ -e "${_lf}" ] ; then
5789                                _dSize=`du -k ${_lf} | tr -d '\t' | cut -d '/' -f 1`
5790                                if [ $(is_num "$_dSize") ] ; then
5791                                        if [ ${_fSize} -lt ${_dSize} ] ; then _dSize="$_fSize" ; fi
5792                                        _kbs=`expr ${_dSize} \/ $_time`
5793                                        echo "SIZE: ${_fSize} DOWNLOADED: ${_dSize} SPEED: ${_kbs} KB/s"
5794                                fi
5795                        fi
5796
5797                        # Make sure download isn't finished
5798                        ps -p $FETCH_PID >/dev/null 2>/dev/null
5799                        if [ "$?" != "0" ] ; then break ; fi
5800                        sleep 2
5801                        _time=`expr $_time + 2`
5802                done
5803
5804                _err="`cat ${_eFile}`"
5805                if [ "$_err" = "0" ]; then echo "FETCHDONE" ; fi
5806                unset FETCH_PID
5807        fi
5808
5809        echo ""
5810        return $_err
5811}
5812
5813is_num()
5814{
5815        expr $1 + 1 2>/dev/null
5816        return $?
5817}
5818
5819# Function to check if the port is flagged to only build on specific arch
5820# Returns 0 for OK, 1 for invalid arch
5821check_port_compat_arch()
5822{
5823        local sPort=$1
5824        have32="false";
5825        local cValues="`make -C $sPort -V ONLY_FOR_ARCHS PORTSDIR=${PORTSDIR}`"
5826        if [ -z "$cValues" ] ; then return 0 ; fi
5827
5828        for cArch in $cValues
5829        do
5830                if [ "$cArch" = "$ARCH" ] ; then return 0; fi
5831                if [ "$cArch" = "i386" ] ; then have32="true" ; fi
5832        done
5833        return 1
5834}
5835
5836# start processing autobuild
5837pbi_autob_init() {
5838
5839        require_root
5840
5841        parse_autob_pbi_cmdline "$@"
5842
5843        do_pbi_autob
5844}
5845
5846check_zfs_ab_destroy()
5847{
5848        local bNum=$1
5849        if [ -e "${PBI_TMPDIR}/${bNum}.zmnt" ] ; then
5850                zDir=`cat ${PBI_TMPDIR}/${bNum}.zmnt`
5851                # Make sure this zfs dataset is in the PBI_APPDIR directory
5852                echo $zDir | grep -q "${PBI_APPDIR}/" 
5853                if [ $? -eq 0 ] ; then
5854                  # Make sure all is unmounted
5855                  umount -f ${PBI_CHROOTDIR}/dev >/dev/null 2>/dev/null
5856                  umount -f ${PBI_CHROOTDIR}/compat/linux/proc >/dev/null 2>/dev/null
5857                  umount -f ${PBI_CHROOTDIR}/usr/ports >/dev/null 2>/dev/null
5858                  umount -f ${PBI_CHROOTDIR}/pkgs >/dev/null 2>/dev/null
5859                  umount -f ${PBI_CHROOTDIR}/.ccache >/dev/null 2>/dev/null
5860                  umount -f ${PBI_CHROOTDIR}/usr/wrkdirprefix >/dev/null 2>/dev/null
5861                  sleep 3
5862                  umount -f ${PBI_CHROOTDIR}/dev >/dev/null 2>/dev/null
5863                  sync
5864                  sleep 3
5865                  zfs destroy ${zDir}
5866                  rmdir ${zDir} >/dev/null 2>/dev/null
5867                fi
5868        fi
5869}
5870
5871ab_clean_build_tmpfiles()
5872{
5873        local build=$1
5874
5875        # Cleanup
5876        rm ${PBI_TMPDIR}/${build}.result 2>/dev/null
5877        rm ${PBI_TMPDIR}/${build}.pid 2>/dev/null
5878        rm ${PBI_TMPDIR}/${build}.bPort 2>/dev/null
5879        rm ${PBI_TMPDIR}/${build}.od 2>/dev/null
5880        rm ${PBI_TMPDIR}/${build}.mp 2>/dev/null
5881        rm ${PBI_TMPDIR}/${build}.cd 2>/dev/null
5882        rm ${PBI_TMPDIR}/${build}.pv 2>/dev/null
5883        rm ${PBI_TMPDIR}/${build}.zmnt 2>/dev/null
5884}
5885
5886# Start the auto-build traversal process
5887do_pbi_autob() {
5888
5889        echo "`basename ${0}` started: `date`"
5890
5891        # Prune any outdir files which we don't have modules for
5892        do_pbi_autob_prune
5893
5894        cd "${PBI_AB_CONFDIR}"
5895        init_tmpdir
5896
5897        # Get this runs timestamp
5898        PBI_AB_TIMESTAMP=`date | md5`
5899
5900
5901        # Build our list of targets first
5902        echo "=> Creating build queue list..."
5903        ab_get_build_list
5904
5905        done=0
5906        rebuildlist=0
5907        while :; do
5908          activity=0
5909          # Start checking each job
5910          for build in ${JOBS-$(jot -w %02d ${PBI_AB_BUILDERS})}; do
5911                # Is this builder running?
5912                if [ -e "${PBI_TMPDIR}/${build}.pid" ] ; then
5913                        if pgrep -qF "${PBI_TMPDIR}/${build}.pid" >/dev/null 2>&1; then
5914                                activity=1
5915                                continue;
5916                        else
5917                                # Do the ZFS destroy here if necessary
5918                                check_zfs_ab_destroy "$build"
5919                               
5920                                # Run the post-build process
5921                                ab_post_build ${build}
5922
5923                                # Cleanup
5924                                ab_clean_build_tmpfiles ${build}
5925                        fi
5926                fi
5927                if [ $done -eq 1 ] ; then continue ; fi
5928
5929                # Builder idle, lets figure out the next build
5930                echo "==> Finding target for build process [$build]"
5931                start_next_ab_target "$build"
5932                if [ $? -eq 0 ] ; then 
5933                        # Nothing left to build, lets wait for any existing build to finish before exiting
5934                        done=1
5935                fi
5936                activity=1
5937          done
5938
5939          # Every 2 hours, we can re-scan the modules directory, catch any ones which may have been added / changed
5940          if [ $rebuildlist -eq 7200 ] ; then
5941             rebuildlist=0
5942             ab_get_build_list
5943          else
5944             rebuildlist=`expr $rebuildlist + 1`
5945          fi
5946
5947          # Wait before checking again
5948          [ $activity -eq 1 ] && sleep 1
5949          # Nothing to do? We can end now
5950          [ $activity -eq 0 ] && break
5951        done
5952
5953        echo "`basename ${0}` Finished: `date`"
5954};
5955
5956ab_get_build_list()
5957{
5958
5959   AB_FOUND="0"
5960   unset CUR_PRIORITY_PBI CUR_WORKING_PBI
5961
5962   # Clear the tmp build list
5963   rm ${PBI_TMPDIR}/.ablist 2>/dev/null
5964               
5965   cd "${PBI_AB_CONFDIR}"
5966   for pbi in `find . -type f -name "${PBI_CONFFILE}" | grep -v '\.svn' | sort`
5967   do
5968        # Figure out the target port for this build
5969        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
5970        . ${pbi}
5971
5972        _cd=$(dirname $pbi | sed 's|./||')
5973        PBI_CONFDIR="$_cd"
5974
5975        # Make sure PBI_MAKEPORT is set
5976        if [ -z "${PBI_MAKEPORT}" ] ; then
5977                PBI_MAKEPORT=`echo $pbi | sed 's|./||'`
5978                export PBI_MAKEPORT
5979        fi     
5980
5981        if [ ! -d "${PORTSDIR}/${PBI_MAKEPORT}" ] ; then 
5982                #echo "Skipping invalid port ${PORTSDIR}/${PBI_MAKEPORT}"
5983                continue
5984        fi
5985       
5986        # Check if this port can be built on this architecture
5987        check_port_compat_arch "${PORTSDIR}/${PBI_MAKEPORT}"
5988        if [ "$?" = "1" ] ; then
5989           if [ "$PBI_ABFB32" != "YES" ] ; then
5990                echo "${PBI_MAKEPORT} - Skipping for invalid system arch"
5991                continue
5992           fi
5993           if [ "$have32" != "true" ] ; then
5994                echo "${PBI_MAKEPORT} - Skipping for invalid system arch"
5995                continue
5996           fi
5997        fi
5998       
5999        # Check for missing port target
6000        if [ -z "$PBI_MAKEPORT" ] ; then
6001                #echo "Warning: Missing PBI_MAKEPORT for ${pbi}"
6002                continue
6003        fi
6004
6005        # Check if another builder is already doing this port
6006        pBuilding=0
6007        for p in `ls ${PBI_TMPDIR}/*.bPort 2>/dev/null`
6008        do
6009                if [ "`cat $p`" = "$PBI_MAKEPORT" ] ; then
6010                        pBuilding=1
6011                        break
6012                fi
6013        done
6014        if [ $pBuilding -eq 1 ] ; then
6015                continue
6016        fi
6017
6018        check_ab_needed "$PBI_MAKEPORT" "${PBI_BUILDKEY}" "$_cd" "$PBI_AB_TIMESTAMP"
6019        if [ "$?" = "0" ] ; then       
6020           AB_FOUND="1"
6021
6022                   # Unset the priority if set to 00 / 0
6023           if [ "${PBI_AB_PRIORITY}" = "00" -o "${PBI_AB_PRIORITY}" = "0" ] ; then
6024                unset PBI_AB_PRIORITY
6025           fi
6026
6027           # Check the priority of this PBI, see if it rises to the top
6028           if [ -z "${CUR_PRIORITY_PBI}" ] ; then
6029             CUR_WORKING_PBI="${pbi}"
6030             if [ -z "$PBI_AB_PRIORITY" ] ; then
6031                     CUR_PRIORITY_PBI="$internal_ab_priority"
6032             else
6033                     CUR_PRIORITY_PBI=`expr $PBI_AB_PRIORITY + 10`
6034             fi
6035             #echo "Setting higher priority target: ${pbi} - Priority: ${CUR_PRIORITY_PBI}"
6036             echo "${CUR_PRIORITY_PBI} $pbi" >> ${PBI_TMPDIR}/.abtmp
6037             continue
6038           fi
6039
6040           # Bump up the supplied AB priority
6041           if [ -n "${PBI_AB_PRIORITY}" ] ; then
6042              internal_ab_priority=`expr $PBI_AB_PRIORITY + 10`
6043           fi
6044
6045           # Check if this PBI is a higher priority
6046           if [ $CUR_PRIORITY_PBI -lt $internal_ab_priority ] ; then
6047             #echo "Setting higher priority target: ${pbi} - Priority: ${internal_ab_priority}"
6048             CUR_WORKING_PBI="${pbi}"
6049             CUR_PRIORITY_PBI="$internal_ab_priority"
6050             echo "${internal_ab_priority} $pbi" >> ${PBI_TMPDIR}/.abtmp
6051             continue
6052           else
6053             echo "${internal_ab_priority} $pbi" >> ${PBI_TMPDIR}/.abtmp
6054           fi
6055           continue
6056         fi
6057
6058  done
6059
6060  # Sort the list
6061  if [ -e "${PBI_TMPDIR}/.abtmp" ] ; then
6062    sort -n -r ${PBI_TMPDIR}/.abtmp > ${PBI_TMPDIR}/.ablist
6063    rm ${PBI_TMPDIR}/.abtmp
6064  fi
6065}
6066
6067start_next_ab_target()
6068{
6069  local curBuilder="$1"
6070  # No list to parse?
6071  if [ ! -e "${PBI_TMPDIR}/.ablist" ] ; then return 0; fi
6072
6073  # Get the last on the list
6074  CUR_WORKING_PBI=`cat ${PBI_TMPDIR}/.ablist | head -1 | cut -d ' ' -f 2`
6075  if [ -z "${CUR_WORKING_PBI}" ] ; then return 0; fi
6076
6077  cd "${PBI_AB_CONFDIR}"
6078
6079  # We have something to build lets do it!
6080  pbi="$CUR_WORKING_PBI"
6081  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
6082  . ${pbi}
6083
6084  _cd=$(dirname $pbi | sed 's|./||')
6085  PBI_CONFDIR="$_cd"
6086
6087  # Get the prog version
6088  get_pbi_progversion
6089
6090  if [ -z "${PBI_MAKEPORT}" ] ; then
6091     PBI_MAKEPORT=$(dirname $pbi | sed 's|./||')
6092  fi   
6093
6094  echo "==> Starting build process [$curBuilder]: $PBI_MAKEPORT"
6095  echo "$PBI_MAKEPORT" >${PBI_TMPDIR}/${curBuilder}.bPort
6096
6097  # Remove this from the queue
6098  cat ${PBI_TMPDIR}/.ablist | tail -n +2 > ${PBI_TMPDIR}/.abtmp
6099  mv ${PBI_TMPDIR}/.abtmp ${PBI_TMPDIR}/.ablist
6100
6101  # Start the build now
6102  start_ext_ab "$PBI_MAKEPORT" \
6103  "${PBI_BUILDKEY}" "${PBI_PROGVERSION}" \
6104  "${_cd}" "${PBI_AB_OUTDIR}" "${PBI_AB_TIMESTAMP}" "${curBuilder}"
6105
6106  return 1
6107};
6108
6109# Prune any outdir files which don't have matching modules
6110do_pbi_autob_prune() {
6111        if [ "${PBI_AB_PRUNE}" != "YES" ] ; then return 0 ; fi
6112
6113        echo "=> Cleaning outgoing directory..."
6114        # Prune outgoing dirs which don't have matching modules anymore
6115        cd "${PBI_AB_OUTDIR}"
6116        for i in `find . -type d | grep -v '\.svn'`
6117        do
6118                if [ "${i}" = "." -o "${i}" = ".." ] ; then continue ; fi
6119                _pDir=`dirname ${i}`
6120                if [ -d "${i}" -a -n "${i}" ] ; then
6121                        if [ ! -e "${PBI_AB_CONFDIR}/${_pDir}" ] ; then
6122                        # Not in our module tree anymore, remove it
6123                        echo "Auto-Prune: ${PBI_AB_OUTDIR}/${_pDir}"
6124                        rm -rf "${PBI_AB_OUTDIR}/${_pDir}"
6125                        fi
6126                fi
6127        done
6128        cd
6129}
6130
6131# Start the pbi_makeport process
6132start_ext_ab() {
6133        _mp="${1}"
6134        _bk="${2}"
6135        _pv="${3}"
6136        _cd="${4}"
6137        _od="${5}/${_cd}"
6138        local _abkey="$6"
6139        local eBuilder="$7"
6140        _flags=""
6141        _flags="-c ${_cd} -d ${PORTSDIR} -o ${_od} --delbuild"
6142        if [ -n "${PBI_AB_SSLPRIVKEY}" ] ; then
6143                _flags="${_flags} --sign ${PBI_AB_SSLPRIVKEY}"
6144        fi
6145
6146        # Check if we need to enable tmpfs
6147        if [ "$PBI_AB_TMPFS" = "YES" ] ; then
6148                if [ -z "${PBI_AB_NOTMPFS}" -o "$PBI_AB_NOTMPFS" != "YES" ] ; then
6149                        _flags="${_flags} --tmpfs"
6150                fi
6151        fi
6152
6153        # Check if we need to enable pkgbuilding
6154        if [ "$PBI_AB_PKGBUILD" = "YES" -a -z "$PBI_AB_NOPKGBUILD"  ] ; then
6155                _flags="${_flags} --pkgbuild"
6156        fi
6157
6158        # Are we doing 32bit builds?
6159        if [ "$PBI_AB32" = "YES" ] ; then _flags="${_flags} -32"; fi
6160
6161        # Check if this port can be built on this architecture
6162        check_port_compat_arch "${PORTSDIR}/${_mp}"
6163        if [ $? -ne 0 ] ; then
6164           if [ "$PBI_ABFB32" = "YES" -a "$have32" = "true" ] ; then
6165              _flags="${_flags} -32"
6166              _flags="`echo ${_flags} | sed 's| --pkgbuild||g'`"
6167           fi
6168        fi
6169
6170        get_pbi_progversion
6171
6172        #echo "Starting build of ${_mp} - ${_pv}"
6173        #echo "pbi_makeport ${_flags} ${_mp}"
6174
6175        if [ ! -d "${_od}" ] ; then mkdir -p "${_od}" ; fi
6176
6177        # Save the autobuild hash key
6178        echo "$_abkey" > ${_od}/.abkey
6179       
6180        # Save the build key for this PBI
6181        if [ -n "$_bk" ] ; then
6182                echo "$_bk" > "${_od}/pbi-buildkey"
6183        else
6184                echo "__NONE__" > "${_od}/pbi-buildkey"
6185        fi
6186
6187        # Clean old log files
6188        if [ -e "${_od}/build.log" ] ; then
6189                rm "${_od}/build.log"
6190        fi
6191        if [ -e "${_od}/build.log.bz2" ] ; then
6192                rm "${_od}/build.log.bz2"
6193        fi
6194        if [ -e "${_od}/.failed-csum" ] ; then
6195                rm ${_od}/.failed-csum
6196        fi
6197
6198        # Move old PBIs to archived folder
6199        oldVersion=`cat ${_od}/pbi-version 2>/dev/null`
6200        if [ "$oldVersion" != "$PBI_PROGVERSION" ]; then
6201                #echo "Archiving old PBIs..."
6202                archive_old_pbis "${_od}" "$PBI_AB_ARCHIVENUM"
6203        fi
6204
6205        # Set some variables we can call in pbi_makeport
6206        PBI_AB_TMPDIR="${PBI_TMPDIR}"
6207        PBI_AB_BUILDER="$eBuilder"
6208        export PBI_AB_TMPDIR PBI_AB_BUILDER
6209
6210        # Add some header info to log file
6211        echo "Starting build: `date`" >${_od}/build.log
6212        echo "Build Command:" >>${_od}/build.log
6213        echo "pbi_makeport ${_flags} ${_mp}" >>${_od}/build.log
6214        echo "------------------------------------------------------" >>${_od}/build.log
6215       
6216        echo "${_od}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.od"
6217        echo "${_mp}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.mp"
6218        echo "${_cd}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.cd"
6219        echo "${PBI_PROGVERSION}" > "${PBI_TMPDIR}/${PBI_AB_BUILDER}.pv"
6220        pbi_makeport ${_flags} ${_mp} >>${_od}/build.log 2>>${_od}/build.log &
6221        echo "$!" > ${PBI_TMPDIR}/${eBuilder}.pid
6222
6223}
6224
6225ab_post_build() 
6226{
6227        local build=$1
6228        _od="`cat ${PBI_TMPDIR}/${build}.od`"
6229        _mp="`cat ${PBI_TMPDIR}/${build}.mp`"
6230        _cd="`cat ${PBI_TMPDIR}/${build}.cd`"
6231        _pv="`cat ${PBI_TMPDIR}/${build}.pv`"
6232        sleep 1
6233
6234        if [ -e "${PBI_TMPDIR}/${build}.result" -a "`cat ${PBI_TMPDIR}/${build}.result`" = "0" ] ; then
6235                echo "$_pv" > "${_od}/pbi-version"
6236                echo "OK" > "${_od}/pbi-result"
6237
6238                # Save the mdate file
6239                date "+%Y%m%d %H%M%S" >${_od}/pbi-mdate
6240
6241                if [ -n "${PBI_AB_HELPS}" ] ; then
6242                        ${PBI_AB_HELPS} "OK" "${_od}"
6243                fi
6244
6245                # Copy over a description file
6246                if [ -e "${PORTSDIR}/${_mp}/pkg-descr" ] ; then
6247                        cp "${PORTSDIR}/${_mp}/pkg-descr" "${_od}/pbi-descr"
6248                fi
6249                if [ -e "${PBI_AB_CONFDIR}/${_cd}/pbi-descr" ] ; then
6250                        cp "${PBI_AB_CONFDIR}/${_cd}/pbi-descr" "${_od}/pbi-descr"
6251                fi
6252
6253                # Check if we need to rebuild patches
6254                if [ "$PBI_AB_GENPATCH" = "YES" -a -d "${_od}/archived" ] ; then
6255                        echo "===> Generating patches for [$build]"
6256                        gen_pbi_patches "${_od}" "${_od}/archived"
6257                fi
6258
6259                rm "${_od}/build.log.bz2" >/dev/null 2>/dev/null
6260                bzip2 "${_od}/build.log"
6261
6262        else
6263                # Save the md5sum of the ports directory
6264                tar cvf - -C "${PORTSDIR}/${_mp}" . 2>/dev/null | md5 -q >${_od}/.failed-csum
6265
6266                echo "Failed" > "${_od}/pbi-result"
6267                if [ -n "${PBI_AB_HELPS}" ] ; then
6268                        ${PBI_AB_HELPS} "FAILED" "${_od}"
6269                fi
6270        fi
6271
6272}
6273
6274# Function which begins to generate patch files from archived PBIs to current
6275gen_pbi_patches()
6276{
6277        _curPBIdir="$1"
6278        _oldPBIdir="$2"
6279
6280        _curPBI=`ls ${_curPBIdir}/*.pbi 2>/dev/null`
6281
6282        # First remove any old patches
6283        rm ${_curPBIdir}/*.pbp 2>/dev/null
6284        rm ${_curPBIdir}/*.pbp.sha256 2>/dev/null
6285
6286        # Make sure to enable signing of the patch files
6287        if [ -n "${PBI_AB_SSLPRIVKEY}" ] ; then
6288                local _mpflags="-o $_curPBIdir --sign ${PBI_AB_SSLPRIVKEY}"
6289        else
6290                local _mpflags="-o $_curPBIdir"
6291        fi
6292
6293        # Check if we need to enable tmpfs
6294        if [ "$PBI_AB_TMPFS" = "YES" ] ; then _mpflags="${_mpflags} --tmpfs" ; fi
6295
6296        # Build a list of old PBIs we need to make patches from
6297        for _oPBI in `ls ${_oldPBIdir}/*.pbi 2>/dev/null`
6298        do
6299                # Make sure we don't try to make a patch of identical files
6300                if [ "`basename $_oPBI`" != "`basename $_curPBI`" ] ; then     
6301                        #echo "Building pbp patch of ${_oPBI} -> ${_curPBI}"
6302                        pbi_makepatch $_mpflags "$_oPBI" "$_curPBI" >/dev/null 2>/dev/null
6303                        if [ "$?" != "0" ] ; then
6304                                echo "pbi_makepatch: Failed creating patchfile for $_oPBI -> $_curPBI"
6305                        fi
6306                       
6307                fi
6308        done
6309}
6310
6311# Function which compares two PBIs, and creates a .pbp file from the differences
6312make_pbi_patchfile()
6313{
6314        _pbiNew="$1"
6315        _pbiOld="$2"
6316        _cDir="$3"
6317
6318        init_tmpdir
6319
6320        # Load all the information about this PBI / PBP
6321        PBI_FILENAME="$1"
6322        load_info_from_header
6323
6324        _pbiNewDir="${PBI_APPDIR}/.newPBI-$$"
6325        _pbiOldDir="${PBI_APPDIR}/.oldPBI-$$"
6326        _pbiPatchDir="${PBI_APPDIR}/.patchPBI-$$"
6327        _pbiPatchHeaderDir="${PBI_APPDIR}/.patchPBIHeaderDir-$$"
6328        _pbiPatchArchiveFile="${PBI_APPDIR}/.patchPBIArchive-$$"
6329        _pbiPatchHeaderFile="${PBI_APPDIR}/.patchPBIHeaderFile-$$"
6330
6331        # Get the PBI Versions
6332        get_ver_from_pbi_file "$_pbiNew"
6333        _pbiNewVer="$VAL"
6334        get_ver_from_pbi_file "$_pbiOld"
6335        _pbiOldVer="$VAL"
6336
6337        # Get the PBI directory names
6338        get_prefix_from_pbi_file "$_pbiNew"
6339        _pbiNewPrefix="`basename $VAL`"
6340        get_prefix_from_pbi_file "$_pbiOld"
6341        _pbiOldPrefix="`basename $VAL`"
6342
6343        # Get the mdate of the old PBI
6344        get_mdate_from_pbi_file "$_pbiOld"
6345        _pbiOldMDate="$VAL"
6346
6347        # Sanity check these prefixes
6348        if [ "${_pbiNewPrefix}" != "${_pbiOldPrefix}" ] ; then
6349                echo "Error: Prefix mismatch between $_pbiNew and $_pbiOld"
6350                return
6351        fi
6352
6353        # Get the arch type
6354        get_arch_from_pbi_file "$_pbiNew"
6355        _pbiNewArch="$VAL"
6356        get_arch_from_pbi_file "$_pbiOld"
6357        _pbiOldArch="$VAL"
6358
6359        # Sanity check these system types
6360        if [ "${_pbiNewArch}" != "${_pbiOldArch}" ] ; then
6361                echo "Error: Arch mismatch between $_pbiNew and $_pbiOld"
6362                return
6363        fi
6364
6365        # Make our extraction directories
6366        if [ -e "$_pbiNewDir" ] ; then rm -rf "$_pbiNewDir"; fi
6367        if [ -e "$_pbiOldDir" ] ; then rm -rf "$_pbiOldDir"; fi
6368        if [ -e "$_pbiPatchDir" ] ; then rm -rf "$_pbiPatchDir"; fi
6369        mkdir -p "$_pbiNewDir"
6370        mkdir -p "$_pbiOldDir"
6371        mkdir -p "$_pbiPatchDir"
6372
6373        # If using tmpfs to speed up patch process
6374        if [ "$PBI_MP_TMPFS" = "YES" ] ; then
6375                mount -t tmpfs tmpfs "${_pbiNewDir}"
6376                mount -t tmpfs tmpfs "${_pbiOldDir}"
6377                mount -t tmpfs tmpfs "${_pbiPatchDir}"
6378        fi
6379
6380        local _opts="-e --licagree"
6381        if [ "${PBI_SKIPSIGVERIFY}" = "YES" ] ; then
6382                _opts="${_opts} --no-checksig"
6383        fi
6384
6385        # Extract the two PBIs
6386        echo "Extracting PBI: $_pbiNew"
6387        pbi_add ${_opts} -o "${_pbiNewDir}" "${_pbiNew}" >/dev/null 2>/dev/null
6388        echo "Extracting PBI: $_pbiOld"
6389        pbi_add ${_opts} -o "${_pbiOldDir}" "${_pbiOld}" >/dev/null 2>/dev/null
6390
6391        if [ ! -d "${_pbiNewDir}/${_pbiNewPrefix}" -o ! -d "${_pbiOldDir}/${_pbiOldPref