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

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

Fixed an issue cleaning up PBI ZFS mounts:

Trac Ticket: http://trac.pcbsd.org/ticket/686

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