source: src-sh/pbi-manager10/pbi-manager @ 44335dc

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

Update pbi-manager10:

  • add PATH links to /usr/pbi/bin
  • add MAN links to /usr/pbi/man
  • add rc.d entries to /usr/pbi/rc.d
  • add MANPATH file to /usr/local/etc/man.d/pbi.conf

This will keep PBIs out of the /usr/local namespace, while still
keeping manpage / rc.d / path functionality intact

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