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

releng/10.0
Last change on this file since acf7a97 was acf7a97, checked in by Kris Moore <kris@…>, 10 months ago

When we do pbi builds, cleanup any leftover pkgng cruft

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