source: src-sh/pbi-manager10/pbi-manager @ 393790b

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

Started hacking on the PBI10 format, switch to storing data in
a geom_uzip container for starts

This will eventually allow us to "run" apps directly from the
downloaded PBI file, without going through the installation process

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