source: src-sh/pbi-manager/pbi-manager @ 603770d

releng/10.0.1releng/10.0.2
Last change on this file since 603770d was 603770d, checked in by Kris Moore <kris@…>, 6 months ago

Also run update-mime-database after installing new menu entries

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