source: src-sh/pbi-manager/pbi-manager @ 1620346

9.1-release9.2-releasereleng/10.0releng/10.0.1releng/10.0.2
Last change on this file since 1620346 was 1620346, checked in by Kris Moore <kris@…>, 15 months ago

Initial import of PC-BSD /current/ SVN repo

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