tazpkg view tazpkg @ rev 811

Update documentation (attempt to describe all the commands both with all options). Strongly need to review and update translations and docs! Add TazPkg help system for commandline (based on the HTML docs). Attempt to drop all package lists but "packages.info". Small improvements and code prettify.
author Aleksej Bobylev <al.bobylev@gmail.com>
date Thu Jun 04 00:15:13 2015 +0300 (2015-06-04)
parents 941baf789cb7
children a41fb2cbc248
line source
1 #!/bin/sh
2 #
3 # TazPkg - Tiny autonomous zone packages manager.
4 #
5 # This is a lightweight packages manager for *.tazpkg files written in SHell
6 # script. It works well with Busybox ash shell and bash. TazPkg lets you
7 # list, install, remove, download or get information about a package. You
8 # can use 'tazpkg usage' to get a list of commands with short descriptions.
9 # TazPkg also resolves dependencies and can upgrade packages from a mirror.
10 #
11 # (C) 2007-2015 SliTaz - GNU General Public License v3.
12 #
13 # Authors: See the AUTHORS files
14 #
15
16
17 ####################
18 # Script variables #
19 ####################
20
21 . /etc/slitaz/slitaz.conf
22 . /etc/slitaz/tazpkg.conf
23
24 . /lib/libtaz.sh
25 . /usr/lib/slitaz/libpkg.sh
26 . /usr/lib/tazpkg/tazpkg-find-depends
27
28 # Internationalization.
29 export TEXTDOMAIN='tazpkg'
30 _() { local T="$1"; shift; printf "$(gettext "$T")" "$@"; echo; }
31 _n() { local T="$1"; shift; printf "$(gettext "$T")" "$@"; }
32 _p() {
33 local S="$1" P="$2" N="$3"; shift 3;
34 printf "$(ngettext "$S" "$P" "$N")" "$@"; }
35
36
37 #
38 # Functions set for translate categories
39 #
40
41
42 # Make array of pre-translated categories
43
44 cat_i18n=''
45 for c in 'base-system' 'x-window' 'utilities' 'network' 'graphics' \
46 'multimedia' 'office' 'development' 'system-tools' 'security' 'games' \
47 'misc' 'meta' 'non-free'; do
48 cat_i18n="$cat_i18n
49 $(gettext "$c") $c"
50 done
51
52
53 # Translate category names (must be last in line)
54
55 translate_category() {
56 sed "s|base-system$|$(_ base-system)|g; s|x-window$|$(_ x-window)|g;
57 s|utilities$|$(_ utilities)|g; s|network$|$(_ network)|g;
58 s|graphics$|$(_ graphics)|g; s|multimedia$|$(_ multimedia)|g;
59 s|office$|$(_ office)|g; s|development$|$(_ development)|g;
60 s|system-tools$|$(_ system-tools)|g; s|security$|$(_ security)|g;
61 s|games$|$(_ games)|g; s|misc$|$(_ misc)|g; s|meta$|$(_ meta)|g;
62 s|non-free$|$(_ non-free)|g"
63 }
64
65
66 # If category is not one of those translated in native language, keep it
67 # untranslated. This allows both native and English language support.
68 # This also supports custom categories.
69 # And now we support spaces in translated categories
70
71 reverse_translate_category() {
72 echo "$cat_i18n" | awk "BEGIN{FS=\" \"}{if (/^$@ /) a=\$2}END{if (a==\"\") a=\"$@\"; print a}"
73 }
74
75
76
77
78 # Initialize some variables to use words rather than numbers for functions
79 # and actions.
80
81 COMMAND="$1"
82 PACKAGE="${2%/}"
83 PACKAGE_DIR="$(cd $(dirname $PACKAGE 2>/dev/null) 2>/dev/null; pwd)"
84 [ -n "$PACKAGE" ] && PACKAGE_FILE="$PACKAGE_DIR/${PACKAGE##*/}"
85 if [ -f "$PACKAGE" ]; then
86 # Set pkg basename for install, extract
87 PACKAGE="$(basename $PACKAGE .tazpkg 2>/dev/null)"
88 else
89 # Pkg name for remove, search and all other cmds
90 PACKAGE="${PACKAGE%.tazpkg}"
91 fi
92 TARGET_DIR="$3"
93 TOP_DIR="$(pwd)"
94 TMP_DIR="/tmp/$RANDOM"
95 INSTALL_LIST=''
96 SAVE_CACHE_DIR="$CACHE_DIR"
97
98 # Path to tazpkg used dir and configuration files
99 MIRROR="$PKGS_DB/mirror"
100 BLOCKED="$PKGS_DB/blocked-packages.list"
101 UP_LIST="$PKGS_DB/packages.up"
102 DEFAULT_MIRROR="$ONLINE_PKGS"
103
104 # TazPkg version
105 VERSION=$(awk -F$'\t' '$1=="tazpkg"{print $2}' $PKGS_DB/installed.info)
106 # User Agent
107 UA="TazPkg-$VERSION"
108
109
110
111
112 ####################
113 # Script functions #
114 ####################
115
116
117 # Interactive mode
118
119 im() { tty -s; }
120
121
122 # Print the usage.
123
124 usage () {
125 cat <<EOT
126
127 $(_ 'SliTaz package manager - Version: %s' $(colorize 34 $VERSION))
128
129 $(boldify "$(_ 'Usage:')")
130 $(_ 'tazpkg [command] [package|dir|pattern|list|cat|--opt] [dir|--opt]')
131
132 $(boldify "$(_ 'SHell:')") tazpkg shell
133
134 $(boldify "$(_ 'Commands:')")
135 $(optlist "\
136 usage $(_ 'Print this short usage')
137 -h help $(_ 'Show help on the TazPkg commands')
138 -a activity $(_ 'Show TazPkg activity log')
139 -cc clean-cache $(_ 'Clean all packages downloaded in cache directory')
140 shell $(_ 'Run interactive TazPkg shell')
141
142 -l list $(_ 'List installed packages on the system')
143 -lm list-mirror $(_ 'List all available packages on the mirror')
144 list-config $(_ 'List the configuration files')
145
146 -s search $(_ 'Search for a package by pattern or name')
147 -sp search-pkgname $(_ 'Search on mirror for package having a particular file')
148 -sf search-file $(_ 'Search for file in all installed packages files')
149
150 -g get $(_ 'Download a package into the current directory')
151 -i install $(_ 'Install a local package')
152 -gi get-install $(_ 'Download and install a package from the mirror')
153 install-list $(_ 'Install all packages from a list of packages')
154 get-install-list $(_ 'Download and install a list of packages from the mirror')
155 -r remove $(_ 'Remove the specified package and all installed files')
156 reconfigure $(_ 'Replay post install script from package')
157 link $(_ 'Link a package from another SliTaz installation')
158 set-release $(_ 'Change release and update packages')
159 add-flavor $(_ 'Install the flavor list of packages')
160 install-flavor $(_ 'Install the flavor list of packages and remove other ones')
161
162 info $(_ 'Print information about a package')
163 -d desc $(_ 'Print description of a package')
164 -lf list-files $(_ 'List the files installed with a package')
165 -b|u block|unblock $(_ 'Block an installed package version or unblock it for upgrade')
166 check $(_ 'Verify consistency of installed packages')
167 bugs $(_ 'Show known bugs in packages')
168 depends $(_ 'Display dependencies tree')
169 rdepends $(_ 'Display reverse dependencies tree')
170 -e extract $(_ 'Extract a (*.tazpkg) package into a directory')
171 pack $(_ 'Pack an unpacked or prepared package tree')
172 repack $(_ 'Create a package archive from an installed package')
173 repack-config $(_ 'Create a package archive with configuration files')
174 recompress $(_ 'Rebuild a package with a better compression ratio')
175 convert $(_ 'Convert alien package to tazpkg')
176 list-suggested $(_ 'Print list of suggested packages')
177
178 recharge $(_ 'Recharge your packages.list from the mirror')
179 up|help-up $(_ 'Check packages %s to list and install latest upgrades' $CHECKSUM)
180 -sm setup-mirror $(_ 'Change the mirror URL configuration')
181 setup-undigest $(_ 'Update an undigest mirror')
182 list-undigest $(_ 'List undigest mirrors')
183 add-undigest $(_ 'Add an undigest mirror')
184 remove-undigest $(_ 'Remove an undigest mirror')
185 ")
186 EOT
187 }
188
189
190 usage_up() {
191 cat <<EOT
192 $(emsg "<b>$(_ 'Usage for command up:')</b>") tazpkg up [$(_ 'option')]
193
194 * $(longline "$(_ 'Without options run in interactive mode and ask before install')")
195
196 $(boldify "$(_ 'Where options are:')")
197 $(optlist "\
198 -c --check $(_ 'Check only for available upgrades')
199 -r --recharge $(_ 'Force recharge of packages list and check')
200 -i --install $(_ 'Check for upgrades and install them all')
201 ")
202
203 $(boldify "$(_ 'Example:')")
204 tazpkg up --recharge --install
205 tazpkg up -c -r
206 EOT
207 }
208
209
210 # Check if dir exists
211
212 check_dir() {
213 if [ ! -d "$1" ]; then
214 action 'Creating folder "%s"...' "$1"
215 mkdir -p "$1"
216 status
217 return 1
218 fi
219 }
220
221
222 # Check if the directories and files used by TazPkg exist.
223 # If not and user is root we create them.
224
225 check_base_dir() {
226 if [ "$(id -u)" == '0' ]; then
227 check_dir $1$CACHE_DIR
228 check_dir $1$INSTALLED
229 check_dir $1$SLITAZ_LOGS
230 if [ ! -f "$1$PKGS_DB/mirror" ]; then
231 echo "${DEFAULT_MIRROR%/}/" > $1$PKGS_DB/mirror
232 [ -n "$1" ] && cp $PKGS_DB/packages.* $1$PKGS_DB/
233 fi
234 fi
235 }
236 check_base_dir
237
238
239 # Check for a package name on cmdline.
240
241 check_for_package_on_cmdline() {
242 if [ -z "$PACKAGE" ]; then
243 newline
244 _ 'Please specify a package name on the command line.'
245 newline
246 exit 1
247 fi
248 }
249
250
251 # Check if the package (*.tazpkg) exists before installing or extracting.
252
253 check_for_package_file() {
254 if [ ! -f "$PACKAGE_FILE" ]; then
255 newline
256 _ 'Unable to find file "%s"' $PACKAGE_FILE
257 newline
258 exit 1
259 fi
260 }
261
262
263 # Check for the receipt of an installed package.
264
265 check_for_receipt() {
266 if [ ! -f "$1$INSTALLED/$PACKAGE/receipt" ]; then
267 newline
268 _ 'Unable to find the receipt "%s"' "$1$INSTALLED/$PACKAGE/receipt"
269 newline
270 exit 1
271 fi
272 }
273
274
275 # Get repositories priority using $PKGS_DB/priority.
276 # In this file undigest repos are called by their names and main mirror
277 # by 'main'. Sort order: priority
278
279 look_for_priority() {
280 [ -s "$PKGS_DB/priority" ] && priority=$(cat $PKGS_DB/priority)
281
282 for rep in main $(ls $PKGS_DB/undigest 2>/dev/null); do
283 if [ ! -s "$PKGS_DB/priority" ] || ! grep -q ^$rep$ $PKGS_DB/priority; then
284 priority=$(echo -e "$priority\n$rep")
285 fi
286 done
287 priority=$(echo "$priority" | sed '/^$/d' | \
288 while read line; do
289 case $line in
290 main) echo $PKGS_DB;;
291 *) echo $PKGS_DB/undigest/$line;;
292 esac
293 done)
294 }
295
296
297 # Get package name in a directory
298
299 package_fullname_in_dir() {
300 [ ! -f "$1/receipt" ] && return
301 EXTRAVERSION=''
302 . $1/receipt
303 echo "$PACKAGE-$VERSION$EXTRAVERSION"
304 }
305
306
307 # Get package name that is already installed.
308
309 get_installed_package_pathname() {
310 for i in $2$INSTALLED/${1%%-*}*; do
311 [ ! -d $i ] && continue
312 if [ "$1" == "$(package_fullname_in_dir $i)" ]; then
313 echo "$i"
314 return
315 fi
316 done
317 }
318
319
320 # Check if a package is already installed.
321
322 check_for_installed_package() {
323 if [ -n "$(get_installed_package_pathname $PACKAGE $1)" ]; then
324 newline
325 _ '"%s" package is already installed.' $(colorize 34 $PACKAGE)
326 longline "$(_ 'You can use the --forced option to force installation.')"
327 newline
328 exit 0
329 fi
330 }
331
332
333 # Check for packages.list to download and install packages.
334
335 check_for_packages_list() {
336 list_path="$PKGS_DB/packages.list"
337 if [ ! -f "$list_path" ]; then
338 if [ $(id -u) == 0 ]; then
339 tazpkg recharge
340 else
341 newline
342 _ 'Unable to find the list "%s"' $list_path
343 _ \
344 "You must probably run 'tazpkg recharge' as root to get the latest list of
345 packages available on the mirror."
346 newline
347 exit 0
348 fi
349 fi
350 }
351
352
353 # Check for installed.info - local file with format of packages.info
354 # "installed.info" is absent on not clean installs; check it and re-generate if needed.
355
356 check_for_installed_info() {
357 info_path="$ROOT$PKGS_DB/installed.info"
358 if [ ! -f "$info_path" ]; then
359 if [ "$(id -u)" == '0' ]; then
360 _ 'File "%s" generated. Please wait...' installed.info
361 for pkg in $ROOT$PKGS_DB/installed/*/receipt; do
362 unset_receipt
363 . $pkg
364 SIZES=$(echo $PACKED_SIZE $UNPACKED_SIZE | sed 's|\.0||g')
365 DEPENDS=$(echo $DEPENDS) # remove newlines from some receipts
366 MD5="$(fgrep " $PACKAGE-$VERSION$EXTRAVERSION.tazpkg" \
367 $ROOT$PKGS_DB/installed.md5 | awk '{print $1}')"
368 cat >> $info_path << EOT
369 $PACKAGE $VERSION$EXTRAVERSION $CATEGORY $SHORT_DESC $WEB_SITE $TAGS $SIZES $DEPENDS $MD5
370 EOT
371 done
372 else
373 _ 'Unable to find file "%s"' installed.info
374 _ 'Please run tazpkg as root.'
375 exit 1
376 fi
377 fi
378
379 # Check for md5 field in the installed.info
380
381 }
382
383
384 get_cache_dir() {
385 echo $rep > $tmp/rep
386 if [ "$rep" == "$PKGS_DB" ]; then
387 CACHE_DIR="$SAVE_CACHE_DIR/$SLITAZ_RELEASE/packages"
388 elif [ "${rep%-incoming}" == "$rep" ]; then
389 CACHE_DIR="$SAVE_CACHE_DIR/${rep##*/}/packages"
390 else
391 rep="${rep%-incoming}"
392 CACHE_DIR="$SAVE_CACHE_DIR/${rep##*/}/packages-incoming"
393 fi
394 [ ! -d "$CACHE_DIR" ] && mkdir -p $CACHE_DIR
395 echo $CACHE_DIR > $tmp/cachedir
396 }
397
398
399 # get an already installed package from packages.equiv
400
401 equivalent_pkg() {
402 for i in $(grep -hs "^$1=" $PKGS_DB/packages.equiv \
403 $PKGS_DB/undigest/*/packages.equiv | sed "s/^$1=//"); do
404 if echo $i | fgrep -q : ; then
405 # format 'alternative:newname'
406 # if alternative is installed then substitute newname
407 if [ -f "$2$INSTALLED/${i%:*}/receipt" ]; then
408 # substitute package dependency
409 echo "${i#*:}"
410 return
411 fi
412 else
413 # if alternative is installed then nothing to install
414 if [ -f "$2$INSTALLED/$i/receipt" ]; then
415 # substitute installed package
416 echo "$i"
417 return
418 fi
419 fi
420 done
421 # if not found in packages.equiv then no substitution
422 echo "$1"
423 }
424
425
426 # get a virtual package from packages.equiv
427
428 virtual_pkg() {
429 for i in $(for rep in $priority; do
430 grep -hs "^$1=" $rep/packages.equiv
431 done | sed "s/^$1=//"); do
432 if echo $i | fgrep -q : ; then
433 # format 'alternative:newname'
434 # if alternative is installed then substitute newname
435 if [ -f "$2$INSTALLED/${i%:*}/receipt" ]; then
436 # substitute package dependency
437 echo "${i#*:}"
438 return
439 fi
440 else
441 # unconditional substitution
442 echo "$i"
443 return
444 fi
445 done
446 }
447
448
449 # Get package filename available on the mirror
450
451 get_package_filename() {
452 # input: "<package_name>" or "<package_name>-<version>" (ex. "nano" or "nano-2.4.0")
453 local pkg equiv
454 for rep in $priority; do
455 pkg=$(awk -F$'\t' -vp="$1" 'p==$1||p==$1"-"$2{print $1"-"$2}' $rep/packages.info)
456
457 if [ -n "$pkg" ]; then
458 get_cache_dir; break
459 fi
460 done
461 if [ -z "$pkg" ]; then
462 # Check for virtual package
463 equiv=$(virtual_pkg $1)
464 if [ "$equiv" != "$1" ]; then
465 PACKAGE="$equiv"
466 get_package_filename $PACKAGE
467 return
468 fi
469 fi
470 echo "$pkg"
471 }
472
473
474 # Check for a package in packages DB. Used by get and get-install to grep
475 # package basename.
476
477 check_for_package_in_list() {
478 local filename check_only
479 check_only="$1"
480 filename=$(get_package_filename $PACKAGE)
481 if [ -n "$filename" ]; then
482 PACKAGE="$filename"
483 CACHE_DIR="$(cat $tmp/cachedir)"
484 rep="$(cat $tmp/rep)"
485 rm -f $tmp/rep $tmp/cachedir
486 else
487 newline
488 _ 'Unable to find package "%s" in the mirrored packages list.' $PACKAGE
489 newline
490 [ -n "$check_only" ] && return 1
491 exit 0
492 fi
493 }
494
495
496 # Log this activity
497 # (there log_pkg because we have log() in libtaz.sh)
498
499 log_pkg() {
500 local extra
501
502 [ "$1" == 'Installed' ] && \
503 extra=" - $(fgrep $PACKAGE-$VERSION $PKGS_DB/installed.$SUM | awk '{ print $1 }')"
504
505 [ -e "$LOG" ] || touch $LOG
506
507 [ -w "$LOG" ] &&
508 echo "$(date +'%F %T') - $1 - $PACKAGE ($VERSION$EXTRAVERSION)$extra" >> $LOG
509 }
510
511
512 # Download a get-package script from this mirror
513
514 download_get_script() {
515 local p i
516 for p in $priority ; do
517 for i in $(cat $p/mirror) ; do
518 case "$i" in
519 http://*|https://*|ftp://*)
520 busybox wget -q -T 30 -U $UA -O $2 \
521 ${i%packages/*}packages/get/$1 && return 0 ;;
522 esac
523 done
524 done
525 return 1
526 }
527
528
529 # Download a file from this mirror
530
531 download_from() {
532 # input: "<mirror_url>+" "<package_name>-<version>.tazpkg"
533 local i
534 for i in $1; do
535 case "$i" in
536 # Mirror URL can have a trailing slash or not.
537 http://* | https://* | ftp://*)
538 busybox wget -c -q -T 30 -U $UA ${i%/}/$2 2>/dev/null && break ;;
539 *)
540 ln -sf ${i%/}/$2 . && break ;;
541 esac
542 done
543 }
544
545
546 # Download a file trying all mirrors
547
548 download() {
549 # input: <package_name>-<version>.tazpkg
550 local i
551 case "$1" in
552 *.tazpkg)
553 for i in $priority; do
554 if [ -n "$(awk -F$'\t' -vp="$1" 'p==$1"-"$2".tazpkg"{print $1}' \
555 $i/packages.info)" ]; then
556 download_from "$(cat $i/mirror)" "$@" && return
557 fi
558 done
559 ;;
560 esac
561
562 for i in $(cat $(for rep in $priority; do echo $rep/mirror; done) 2>/dev/null); do
563 download_from "$i" "$@" && break
564 done
565 }
566
567
568 # Extract a package with cpio and gzip/lzma.
569
570 extract_package() {
571 action 'Extracting package...'
572 cpio -idm --quiet < ${PACKAGE_FILE##*/} && rm -f ${PACKAGE_FILE##*/}
573 status
574 if [ -f fs.cpio.lzma ]; then
575 unlzma -c fs.cpio.lzma | cpio -idm --quiet && rm fs.cpio.lzma
576 elif [ -f fs.cpio.gz ]; then
577 zcat fs.cpio.gz | cpio -idm --quiet && rm fs.cpio.gz
578 fi
579 }
580
581
582 remove_with_path() {
583 # Avoid dirname errors by checking for argument.
584 [ "$1" ] || return
585
586 local dir
587 rm -f $1 2>/dev/null
588 dir="$1"
589 while [ "$dir" != "/" ]; do
590 dir="$(dirname $dir)"
591 rmdir $dir 2> /dev/null || break
592 done
593 }
594
595
596 grepesc() {
597 sed 's/\[/\\[/g'
598 }
599
600
601 # Print short package description
602 print_short_description() {
603 local short_desc=''
604 for LC in $LANG ${LANG%_*}; do
605 if [ -e "$PKGS_DB/packages-desc.$LC" ]; then
606 short_desc=$(grep -e "^$1 " $PKGS_DB/packages-desc.$LC | cut -d' ' -f2)
607 fi
608 done
609 [ -z "$short_desc" -a -s $PKGS_DB/packages.info ] &&
610 short_desc="$(awk -F$'\t' -vp="$PACKAGE" '{if($1==p){print $4;exit}}' $PKGS_DB/packages.info)"
611 longline "$short_desc"
612 }
613
614
615 # This function installs a package in the rootfs.
616
617 install_package() {
618 ROOT=$1
619 if [ -n "$ROOT" ]; then
620 # Get absolute path
621 ROOT=$(realpath $ROOT)
622 fi
623 {
624 # Create package path early to avoid dependencies loop
625 mkdir -p $TMP_DIR
626 { cd $TMP_DIR ; cpio --quiet -i receipt > /dev/null 2>&1; } < $PACKAGE_FILE
627 . $TMP_DIR/receipt
628 # FIXME: legacy?
629 if grep -q ^pre_depends $TMP_DIR/receipt; then
630 pre_depends $ROOT
631 fi
632
633 # Keep modifiers and file list on upgrade
634 cp $ROOT$INSTALLED/$PACKAGE/modifiers \
635 $ROOT$INSTALLED/$PACKAGE/files.list $TMP_DIR 2> /dev/null
636 rm -rf $ROOT$INSTALLED/$PACKAGE 2> /dev/null
637
638 # Make the installed package data dir to store
639 # the receipt and the files list.
640 mkdir -p $ROOT$INSTALLED/$PACKAGE
641 cp $TMP_DIR/modifiers $ROOT$INSTALLED/$PACKAGE 2> /dev/null
642 cp $TMP_DIR/files.list $ROOT$INSTALLED/$PACKAGE 2> /dev/null
643 rm -rf $TMP_DIR 2> /dev/null
644 sed -i "/ $(basename $PACKAGE_FILE)$/d" \
645 $ROOT$PKGS_DB/installed.$SUM 2> /dev/null
646 cd $(dirname $PACKAGE_FILE)
647 $CHECKSUM $(basename $PACKAGE_FILE) >> $ROOT$PKGS_DB/installed.$SUM
648 }
649
650 # Resolve package deps.
651 check_for_deps $ROOT
652 if [ -n "$MISSING_PACKAGE" ]; then
653 install_deps $ROOT
654 fi
655 mkdir -p $TMP_DIR
656 [ -n "$INSTALL_LIST" ] && echo "$PACKAGE_FILE" >> $ROOT$PKGS_DB/$INSTALL_LIST-processed
657
658 title 'Installation of package "%s"' $PACKAGE
659
660 print_short_description $PACKAGE
661 separator '-'
662
663 action 'Copying package...'
664 cp $PACKAGE_FILE $TMP_DIR
665 status
666
667 cd $TMP_DIR
668 extract_package
669 SELF_INSTALL=0
670 EXTRAVERSION=""
671 CONFIG_FILES=""
672
673 # Include temporary receipt to get the right variables.
674 . $PWD/receipt
675 cd $ROOT$INSTALLED
676
677 # FIXME: legacy?
678 if [ $SELF_INSTALL -ne 0 -a -n "$ROOT" ]; then
679 action "Checking post install dependencies..."
680 [ -f $INSTALLED/$PACKAGE/receipt ]
681 if ! status; then
682 _ 'Please run "%s" in / and retry.' "tazpkg install $PACKAGE_FILE"
683 rm -rf $TMP_DIR
684 exit 1
685 fi
686 fi
687
688 # Get files to remove if upgrading
689 if [ -f $PACKAGE/files.list ]; then
690 while read file; do
691 grep -q "^$(echo $file | grepesc)$" $TMP_DIR/files.list && continue
692 for i in $(cat $PACKAGE/modifiers 2> /dev/null ;
693 fgrep -sl $PACKAGE */modifiers | cut -d/ -f1 ); do
694 grep -qs "^$(echo $file | grepesc)$" $i/files.list && continue 2
695 done
696 echo $file
697 done < $PACKAGE/files.list > $TMP_DIR/files2remove.list
698 fi
699
700 # Remember modified packages
701 {
702 check=false
703 for i in $(fgrep -v [ $TMP_DIR/files.list); do
704 [ -e "$ROOT$i" ] || continue
705 [ -d "$ROOT$i" ] && continue
706 echo "- $i"
707 check=true
708 done ;
709 $check && \
710 for i in *; do
711 [ "$i" == "$PACKAGE" ] && continue
712 [ -s $i/files.list ] || continue
713 awk "{ printf \"$i %s\\n\",\$1 }" < $i/files.list
714 done;
715 } | awk '
716 {
717 if ($1 == "-" || file[$2] != "") {
718 file[$2] = file[$2] " " $1
719 if ($1 != "-") {
720 if (pkg[$1] == "") all = all " " $1
721 pkg[$1] = pkg[$1] " " $2
722 }
723 }
724 }
725 END {
726 for (i = split(all, p, " "); i > 0; i--)
727 for (j = split(pkg[p[i]], f, " "); j > 0; j--)
728 printf "%s %s\n",p[i],f[j];
729 }
730 ' | while read dir file; do
731 if grep -qs ^$dir$ $PACKAGE/modifiers; then
732 # Do not overload an overloaded file !
733 rm $TMP_DIR$file 2> /dev/null
734 continue
735 fi
736 grep -qs ^$PACKAGE$ $dir/modifiers && continue
737 if [ -s "$dir/volatile.cpio.gz" ]; then
738 # We can modify backed up files without notice
739 zcat $dir/volatile.cpio.gz | cpio -t --quiet | \
740 grep -q "^${file#/}$" && continue
741 fi
742 echo "$PACKAGE" >> $dir/modifiers
743 done
744
745 cd $TMP_DIR
746 cp receipt files.list $ROOT$INSTALLED/$PACKAGE
747
748 # Copy the description if found.
749 if [ -f "description.txt" ]; then
750 cp description.txt $ROOT$INSTALLED/$PACKAGE
751 fi
752
753 # Copy the md5sum if found.
754 if [ -f "$CHECKSUM" ]; then
755 cp $CHECKSUM $ROOT$INSTALLED/$PACKAGE
756 fi
757
758 # Pre install commands.
759 if grep -q ^pre_install $ROOT$INSTALLED/$PACKAGE/receipt; then
760 pre_install $ROOT
761 fi
762
763 if [ -n "$CONFIG_FILES" ]; then
764 # save 'official' configuration files
765 action 'Saving configuration files...'
766 for i in $CONFIG_FILES; do
767 { cd fs ; find ${i#/} -type f 2> /dev/null; cd ..; }
768 done | { cd fs ; cpio -o -H newc --quiet | gzip -9; cd ..; } > \
769 $ROOT$INSTALLED/$PACKAGE/volatile.cpio.gz
770
771 if [ -z "$newconf" ]; then
772 # keep user configuration files
773 for i in $CONFIG_FILES; do
774 { cd fs ; find ${i#/} -type f 2> /dev/null; cd ..; }
775 done | while read i; do
776 [ -e $ROOT/$i ] || continue
777 cp -a $ROOT/$i fs/$i
778 done
779 fi
780 status
781 fi
782
783 action 'Installing package...'
784 [ "$(busybox ls fs/* 2>/dev/null)" ] && cp -af fs/* $ROOT/
785 status
786
787 if [ -s files2remove.list ]; then
788 action 'Removing old package...'
789 while read file; do
790 remove_with_path $ROOT$file
791 done < files2remove.list
792 true
793 status
794 fi
795
796 # Remove the temporary random directory.
797 action "Removing all tmp files..."
798 cd ..; rm -rf $TMP_DIR
799 status
800
801 # Post install commands.
802 if grep -q ^post_install $ROOT$INSTALLED/$PACKAGE/receipt; then
803 action "Execute post-install commands..."
804 post_install $ROOT
805 status
806 fi
807
808 # Update-desktop-database if needed.
809 if [ "$(fgrep .desktop $ROOT$INSTALLED/$PACKAGE/files.list | fgrep /usr/share/applications/)" ]; then
810 updatedesktopdb=yes
811 fi
812
813 # Update-mime-database if needed.
814 if [ "$(fgrep /usr/share/mime $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then
815 updatemimedb=yes
816 fi
817
818 # Update-icon-database
819 if [ "$(fgrep /usr/share/icon/hicolor $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then
820 updateicondb=yes
821 fi
822
823 # Compile glib schemas if needed.
824 if [ "$(fgrep /usr/share/glib-2.0/schemas $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then
825 compile_schemas=yes
826 fi
827
828 # Update depmod list
829 if [ "$(fgrep /lib/modules $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then
830 updatedepmod=yes
831 fi
832
833 # Update installed.info
834 check_for_installed_info
835 SIZES=$(echo $PACKED_SIZE $UNPACKED_SIZE | sed 's|\.0||g')
836 DEPENDS=$(echo $DEPENDS) # remove newlines from some receipts
837 II=$ROOT$PKGS_DB/installed.info
838 sed -i "/^$PACKAGE /d" $II # remove old entry
839 cat >> $II << EOT
840 $PACKAGE $VERSION$EXTRAVERSION $CATEGORY $SHORT_DESC $WEB_SITE $TAGS $SIZES $DEPENDS
841 EOT
842 TEMP_FILE=$(mktemp)
843 sort $II > $TEMP_FILE; mv -f $TEMP_FILE $II; chmod a+r $II; unset II
844
845 cd $TOP_DIR
846 footer "$(_ 'Package "%s" (%s) is installed.' $PACKAGE $VERSION$EXTRAVERSION)"
847
848 # Log this activity
849 [ -n "$ROOT" ] || log_pkg Installed
850
851 # Remove package from upgrade list
852 [ -s $UP_LIST ] && sed -i "/^$PACKAGE\$/d" $UP_LIST
853 }
854
855
856 # This function may be called by a get script.
857
858 abort_package() {
859 cd $CUR_DIR
860 rm -rf $TMP_DIR
861 echo "${1:-Abort $PACKAGE.}"
862 exit 1
863 }
864
865
866 # This function installs a package from a get script in the rootfs.
867
868 install_package_from_get_script() {
869 SCRIPT="$1"
870 ROOT="$2"
871 [ -d "$ROOT$INSTALLED/$PACKAGE" ] && exit 1
872
873 grep -q no-check-certificate $SCRIPT &&
874 [ ! -d "$INSTALLED/wget" ] && tazpkg get-install wget
875
876 mkdir -p $TMP_DIR && cd $TMP_DIR
877 saved="$PACKAGE"
878 unset_receipt
879 PACKAGE="$saved"
880
881 set -e
882 . $SCRIPT
883 set +e
884 [ -d "$PACKAGE-$VERSION" ] || cd $TMP_DIR
885 [ -d "$PACKAGE-$VERSION" ] || abort_package \
886 "$(_ 'Could not download "%s" from "%s". Exiting.' ${TARBALL:-$PACKAGE} ${WGET_URL:-$WEB_SITE})"
887
888 if [ ! -s "$PACKAGE-$VERSION/receipt" ]; then
889 cat > $PACKAGE-$VERSION/receipt <<EOT
890 # SliTaz package receipt.
891
892 PACKAGE="$PACKAGE"
893 VERSION="${VERSION:-unknown}"
894 CATEGORY="${CATEGORY:-non-free}"
895 WEB_SITE="$WEB_SITE"
896 SHORT_DESC="${SHORT_DESC:-$PACKAGE}"
897 MAINTAINER="${MAINTAINER:-nobody@slitaz.org}"
898 EOT
899 for i in LICENSE TARBALL WGET_URL CONFIG_FILES SUGGESTED \
900 PROVIDE DEPENDS HOST_ARCH TAGS EXTRA_SOURCE_FILES ; do
901 eval "[ -n \"\$$i\" ] && echo \"$i=\\\"\$$i\\\"\""
902 done >> $PACKAGE-$VERSION/receipt
903 fi
904
905 DEPENDS="$(unset DEPENDS; . $PACKAGE-$VERSION/receipt ; echo $DEPENDS)"
906 for i in $(find_depends $PACKAGE-$VERSION/fs); do
907 case " $DEPENDS " in
908 *\ $i\ *) continue;;
909 esac
910 grep -q '^DEPENDS="' $PACKAGE-$VERSION/receipt ||
911 echo 'DEPENDS=""' >> $PACKAGE-$VERSION/receipt
912 sed -i "s/^DEPENDS=\"/&$i /" $PACKAGE-$VERSION/receipt
913 done
914
915 TAZPKG_PACK=gzip
916 tazpkg pack $PACKAGE-$VERSION
917
918 # Clean to save RAM memory before installation
919 rm -rf $PACKAGE-$VERSION
920
921 if [ "$3" == '--get' ]; then
922 mv $PACKAGE-$VERSION.tazpkg $TOP_DIR
923 else
924 # Install pseudo package
925 tazpkg install $PACKAGE-$VERSION.tazpkg --root=$ROOT
926 mv $PACKAGE-$VERSION.tazpkg $CACHE_DIR
927 fi
928
929 # Clean
930 cd $TOP_DIR
931 rm -rf $TMP_DIR
932 }
933
934
935 # Check for loop in deps tree.
936
937 check_for_deps_loop() {
938 local list pkg="$1" deps
939 shift
940 [ -n "$1" ] || return
941 list=''
942
943 # Filter out already processed deps
944 for i in $@; do
945 case " $ALL_DEPS" in
946 *\ $i\ *) ;;
947 *) list="$list $i";;
948 esac
949 done
950 ALL_DEPS="$ALL_DEPS$list "
951 for i in $list; do
952 [ -f $i/receipt ] || continue
953 deps="$(DEPENDS=""; . $i/receipt; echo $DEPENDS)"
954 case " $deps " in
955 *\ $pkg\ *)
956 print_pkgname
957 echo -e "$MSG $i"; MSG='';;
958 *)
959 check_for_deps_loop $pkg $deps;;
960 esac
961 done
962 }
963
964
965 # Check for missing deps listed in a receipt packages.
966
967 check_for_deps() {
968 local saved;
969 saved="$PACKAGE"
970 mkdir -p $TMP_DIR
971 { cd $TMP_DIR ; cpio --quiet -i receipt >/dev/null 2>&1; } < $PACKAGE_FILE
972 . $TMP_DIR/receipt
973 PACKAGE="$saved"
974 rm -rf $TMP_DIR
975
976 num=0
977 for pkgorg in $DEPENDS; do
978 i=$(equivalent_pkg $pkgorg $1)
979 if [ ! -d "$1$INSTALLED/$i" ]; then
980 MISSING_PACKAGE=$i
981 num=$(($num+1))
982 elif [ ! -f "$1$INSTALLED/$i/receipt" ]; then
983 _ 'WARNING! Dependency loop between "%s" and "%s".' $PACKAGE $i
984 fi
985 done
986
987 if [ -n "$MISSING_PACKAGE" ]; then
988 title "$(_ 'Tracking dependencies for package "%s"' $PACKAGE)"
989 for pkgorg in $DEPENDS; do
990 i=$(equivalent_pkg $pkgorg $1)
991 if [ ! -d "$1$INSTALLED/$i" ]; then
992 MISSING_PACKAGE="$i"
993 _ 'Missing package "%s"' $MISSING_PACKAGE
994 fi
995 done
996 footer "$(_p \
997 '%s missing package to install.' \
998 '%s missing packages to install.' $num \
999 $num)"
1000 fi
1001 }
1002
1003
1004 # Install all missing deps. Auto install or ask user then install all missing
1005 # deps from local dir, CD-ROM, media or from the mirror. In case we want to
1006 # install packages from local, we need a packages.list to find the version.
1007
1008 install_deps() {
1009 local root=''
1010 [ -n "$1" ] && root="--root=$1"
1011
1012 if [ "$AUTO_INSTALL_DEPS" == 'yes' ]; then
1013 answer=0
1014 else
1015 newline
1016 confirm "$(_ 'Install all missing dependencies? (y/N)')"
1017 answer=$?
1018 newline
1019 fi
1020
1021 if [ "$answer" == 0 ] && [ -z "$nodeps" ]; then
1022 for pkgorg in $DEPENDS; do
1023 pkg=$(equivalent_pkg $pkgorg $1)
1024 if [ ! -d "$1$INSTALLED/$pkg" ]; then
1025 local list="$INSTALL_LIST"
1026 [ -n "$list" ] || list="$TOP_DIR/packages.list"
1027 # We can install packages from a local dir by greping
1028 # the TAZPKG_BASENAME in the local packages.list.
1029 found=0
1030 if [ -f "$list" ]; then
1031 _ 'Checking if package "%s" exists in local list...' $pkg
1032 mkdir $TMP_DIR
1033 for i in $pkg-*.tazpkg; do
1034 [ -f $i ] || continue
1035 { cd $TMP_DIR ; cpio --quiet -i receipt > /dev/null 2>&1; } < $i
1036 [ "$(. $TMP_DIR/receipt; echo $PACKAGE)" == "$pkg" ] || continue
1037 if grep -q ^$(package_fullname_in_dir $TMP_DIR).tazpkg$ $list
1038 then
1039 found=1
1040 tazpkg install $i $root --list=$list
1041 break
1042 fi
1043 done
1044 rm -rf $TMP_DIR
1045 fi
1046 # Install deps from the mirror.
1047 if [ $found -eq 0 ]; then
1048 if [ ! -f "$PKGS_DB/packages.list" ]; then
1049 tazpkg recharge
1050 fi
1051 tazpkg get-install $pkg $root
1052 fi
1053 fi
1054 done
1055 else
1056 newline
1057 _ 'Leaving dependencies for package "%s" unresolved.' $PACKAGE
1058 _ 'The package is installed but will probably not work.'
1059 newline
1060 fi
1061 }
1062
1063
1064 # Search pattern in installed packages.
1065
1066 search_in_installed_packages() {
1067 _ 'Installed packages'
1068 separator '-'
1069 num='0'
1070 for pkg in $(ls -1 $INSTALLED | grep -i "$PATTERN"); do
1071 EXTRAVERSION=''
1072 [ -f $INSTALLED/$pkg/receipt ] || continue
1073 . $INSTALLED/$pkg/receipt
1074 emsg "$PACKAGE<i 24> $VERSION$EXTRAVERSION<i 42> $(_n $CATEGORY)"
1075 num=$(($num+1))
1076 done
1077
1078 footer "$(_p \
1079 '%s installed package found for "%s"' \
1080 '%s installed packages found for "%s"' $num \
1081 $num "$PATTERN")"
1082 }
1083
1084
1085 # Search in packages.list for available pkgs.
1086
1087 search_in_packages_list() {
1088 _ 'Available packages'; separator '-'
1089 num='0'
1090 TMPLIST="$(mktemp)"
1091 BPATTERN="$(emsg "<b>$PATTERN</b>")"
1092
1093 for i in $PKGS_DB/packages.info $PKGS_DB/undigest/*/packages.info; do
1094 [ -e "$i" ] && awk -F$'\t' -vpattern="$PATTERN" -vbpattern="$BPATTERN" \
1095 -vt="$TMPLIST" '
1096 BEGIN { IGNORECASE = 1 }
1097 index($1 "-" $2, pattern) {
1098 pv = $1 "-" $2; gsub(pattern, bpattern, pv); print pv;
1099 printf "1" >> t
1100 }' $i
1101 done
1102
1103 for i in $PKGS_DB/extra.list $PKGS_DB/undigest/*/extra.list; do
1104 [ -e "$i" ] && awk -F'|' -vpattern="$PATTERN" -vbpattern="$BPATTERN" \
1105 -vt="$TMPLIST" '
1106 BEGIN { IGNORECASE = 1 }
1107 index($1 "-" $5, pattern) {
1108 if ($5) pv = $1 "-" $5; else pv = $1;
1109 gsub(pattern, bpattern, pv); print pv " (extra)";
1110 printf "1" >> t
1111 }' $i
1112 done
1113
1114 if [ ! -f "$PKGS_DB/packages.info" ]; then
1115 newline
1116 longline "$(_ \
1117 "No \"%s\" found to check for mirrored packages. For more results, please run \
1118 \"%s\" once as root before searching." 'packages.info' 'tazpkg recharge')"
1119 newline
1120 fi
1121
1122 num="$(wc -m < $TMPLIST)"; rm $TMPLIST
1123 footer "$(_p \
1124 '%s available package found for "%s"' \
1125 '%s available packages found for "%s"' $num \
1126 $num $PATTERN)"
1127 }
1128
1129
1130 # search --mirror: Search in packages.txt for available pkgs and give more
1131 # info than --list or default.
1132
1133 search_in_packages_txt() {
1134 _ 'Matching packages name with version and desc'
1135 separator
1136 num='0'
1137 for i in \
1138 $PKGS_DB/packages.txt \
1139 $PKGS_DB/undigest/*/packages.txt; do
1140
1141 grep -is -A 2 "^$PATTERN" $i
1142 num=$(($num + $(grep -is "^$PATTERN" $i | wc -l)))
1143 done
1144
1145 if [ ! -f "$PKGS_DB/packages.txt" ]; then
1146 newline
1147 longline "$(_ \
1148 "No \"%s\" found to check for mirrored packages. For more results, please run \
1149 \"%s\" once as root before searching." 'packages.txt' 'tazpkg recharge')"
1150 newline
1151 fi
1152
1153 footer "$(_p \
1154 '%s available package found for "%s"' \
1155 '%s available packages found for "%s"' $num \
1156 $num $PATTERN)"
1157 }
1158
1159
1160 # Install package-list from a flavor
1161
1162 install_flavor() {
1163 check_root $@
1164
1165 # Get repositories priority list.
1166 look_for_priority
1167
1168 FLAVOR="$1"
1169 mkdir -p $TMP_DIR
1170 [ -f $FLAVOR.flavor ] && cp $FLAVOR.flavor $TMP_DIR
1171 cd $TMP_DIR
1172 if [ -f $FLAVOR.flavor ] || download $FLAVOR.flavor; then
1173 zcat < $FLAVOR.flavor | cpio --quiet -i >/dev/null
1174
1175 while read file; do
1176 for pkg in $(ls -d $INSTALLED/${file%%-*}*); do
1177 [ -f $pkg/receipt ] || continue
1178 EXTRAVERSION=''
1179 . $pkg/receipt
1180 [ "$PACKAGE-$VERSION$EXTRAVERSION" == "$file" ] && break
1181 done
1182 [ "$PACKAGE-$VERSION$EXTRAVERSION" == "$file" ] && continue
1183 cd $CACHE_DIR
1184 download $file.tazpkg
1185 cd $TMP_DIR
1186 tazpkg install $CACHE_DIR/$file.tazpkg --forced
1187 done < $FLAVOR.pkglist
1188
1189 [ -f $FLAVOR.nonfree ] && while read pkg; do
1190 [ -d $INSTALLED/$pkg ] || continue
1191 [ -d $INSTALLED/get-$pkg ] && tazpkg get-install get-$pkg
1192 get-$pkg
1193 done < $FLAVOR.nonfree
1194
1195 # option "--purge"
1196 [ -n "$purge" ] && for pkg in $(ls $INSTALLED); do
1197 [ -f $INSTALLED/$pkg/receipt ] || continue
1198 EXTRAVERSION=''
1199 . $INSTALLED/$pkg/receipt
1200 grep -q ^$PACKAGE-$VERSION$EXTRAVERSION$ $FLAVOR.pkglist && continue
1201 grep -qs ^$PACKAGE$ $FLAVOR.nonfree && continue
1202 tazpkg remove $PACKAGE
1203 done
1204 else
1205 _ "Can't find flavor \"%s\". Abort." $FLAVOR
1206 fi
1207 cd $TOP_DIR
1208 rm -rf $TMP_DIR
1209 }
1210
1211
1212 # Update mirror URLs
1213
1214 setup_mirror() {
1215 # Backup old list.
1216 if [ -f "$1/mirror" ]; then
1217 cp -f $1/mirror $1/mirror.bak
1218 fi
1219 title 'Current mirror(s)'
1220 echo " $(cat $1/mirror 2> /dev/null)"
1221 longline "$(_ \
1222 "Please enter URL of the new mirror (http, ftp or local path). You must specify \
1223 the complete address to the directory of the packages and packages.list file.")"
1224 newline
1225
1226 _n 'New mirror(s) URL: '
1227 NEW_MIRROR_URL="$2"
1228 if [ -n "$NEW_MIRROR_URL" ]; then
1229 echo $NEW_MIRROR_URL
1230 else
1231 read NEW_MIRROR_URL
1232 fi
1233
1234 if [ -z "$NEW_MIRROR_URL" ]; then
1235 _ 'Nothing has been changed.'
1236 else
1237 _ 'Setting mirror(s) to: "%s"' $NEW_MIRROR_URL
1238 rm -f $1/mirror
1239 for i in $NEW_MIRROR_URL; do
1240 echo "${i%/}/" >> $1/mirror
1241 done
1242 fi
1243 newline
1244 }
1245
1246
1247 # recursive dependencies scan
1248
1249 dep_scan() {
1250 for i in $1; do
1251 case " $ALL_DEPS " in
1252 *\ $i\ *) continue;;
1253 esac
1254 ALL_DEPS="$ALL_DEPS $i"
1255 [ -n "$2" ] && echo "$2$i ($(fgrep -A 3 $i $PKGS_DB/packages.txt | \
1256 tail -1 | sed 's/.*(\([^ ]*\).*/\1/'))"
1257 [ -f $i/receipt ] || continue
1258 DEPENDS=""
1259 . $i/receipt
1260 [ -n "$DEPENDS" ] && dep_scan "$DEPENDS" "$2 "
1261 done
1262 }
1263
1264
1265 # recursive reverse dependencies scan
1266
1267 rdep_scan() {
1268 SEARCH="$1"
1269
1270 for i in * ; do
1271 DEPENDS=''
1272 . $i/receipt
1273 echo "$i $(echo $DEPENDS)"
1274 done | busybox awk -v search=$SEARCH '
1275 function show_deps(deps, all_deps, pkg, space)
1276 {
1277 if (all_deps[pkg] == 1) return
1278 all_deps[pkg] = 1
1279 if (space != "") printf "%s %s\n",space,pkg
1280 for (i = 1, n = split(deps[pkg], mydeps, " "); i <= n; i++) {
1281 show_deps(deps, all_deps, mydeps[i],"==" space)
1282 }
1283 }
1284
1285 {
1286 all_deps[$1] = 0
1287 for (i = 2; i <= NF; i++)
1288 deps[$i] = deps[$i] " " $1
1289 }
1290
1291 END {
1292 show_deps(deps, all_deps, search, "")
1293 }
1294 ' | while read spc pkg; do
1295 echo -n $spc | sed 's/=/ /g'
1296 echo -n $pkg
1297 echo -n ' ('
1298 fgrep -A 3 $pkg $PKGS_DB/packages.txt | tail -1 | \
1299 sed 's/.*(\([^ ]*\).*/\1)/'
1300 done
1301 }
1302
1303
1304 update_desktop_database() {
1305 if [ -f "$1/usr/bin/update-desktop-database" ] && [ -n "$updatedesktopdb" ]; then
1306 chroot "$1/" /usr/bin/update-desktop-database /usr/share/applications 2>/dev/null
1307 fi
1308 }
1309
1310
1311 update_mime_database() {
1312 if [ -f "$1/usr/bin/update-mime-database" ] && [ -n "$updatemimedb" ]; then
1313 chroot "$1/" /usr/bin/update-mime-database /usr/share/mime
1314 fi
1315 }
1316
1317
1318 update_icon_database() {
1319 if [ -f "$1/usr/bin/gtk-update-icon-cache" ] && [ -n "$updateicondb" ]; then
1320 chroot "$1/" /usr/bin/gtk-update-icon-cache /usr/share/icons/hicolor
1321 fi
1322 }
1323
1324
1325 compile_glib_schemas() {
1326 if [ -f "$1/usr/bin/glib-compile-schemas" ] && [ -n "$compile_schemas" ]; then
1327 chroot "$1/" /usr/bin/glib-compile-schemas /usr/share/glib-2.0/schemas
1328 fi
1329 }
1330
1331
1332 update_kernel_modules() {
1333 if [ -f "$1/sbin/depmod" ] && [ -n "$updatedepmod" ]; then
1334 chroot "$1/" /sbin/depmod -a
1335 fi
1336 }
1337
1338
1339 # When recharging errors occur
1340
1341 recharging_failed() {
1342 # Restore database from bak files
1343 action 'Restoring database files...'
1344 [ -e 'ID' -a ! -e 'ID.bak' ] && rm ID
1345 [ -e 'IDs' -a ! -e 'IDs.bak' ] && rm IDs
1346 for file in $(ls $1/*.bak); do
1347 mv -f $file ${file%.bak}
1348 done
1349 status
1350
1351 footer "$(colorize 31 "$(_ 'Recharging failed')")"
1352 }
1353
1354
1355 # Print package name if not printed yet
1356 print_pkgname() {
1357 if [ "$PACKAGE" != "$PACKAGE_PRINTED" ]; then
1358 [ -n "$PACKAGE_PRINTED" ] && footer
1359 title 'Package %s' "$PACKAGE-$VERSION$EXTRAVERSION"
1360 PACKAGE_PRINTED="$PACKAGE"
1361 fi
1362 }
1363
1364
1365
1366 ###################
1367 # TazPkg commands #
1368 ###################
1369
1370 case "$COMMAND" in
1371 list|-l)
1372 # List all installed packages or a specific category.
1373 shift
1374 check_for_installed_info
1375
1376 case $1 in
1377 b|blocked)
1378 # Display the list of blocked packages.
1379 title 'Blocked packages'
1380 if [ -s "$BLOCKED" ];then
1381 cat $BLOCKED
1382 num=$(wc -l < $BLOCKED)
1383 footer "$(_p '%s package' '%s packages' "$num" \
1384 "$(colorize 31 $num)")"
1385 else
1386 _ 'No blocked packages found.'
1387 fi
1388 newline
1389 ;;
1390
1391 c|cat|categories)
1392 # Display the list of categories.
1393 title 'Packages categories'
1394
1395 echo "$PKGS_CATEGORIES" | sed 's|[^a-z-]|\n|g; /^$/d' | \
1396 sed 's|\(.*\)|\1\t\1|' | translate_category | awk -F$'\t' '{
1397 if ($1==$2) print $1; else printf "%-14s %s\n", $1, $2}'
1398
1399 num=$(echo -n "$PKGS_CATEGORIES" | wc -l)
1400 footer "$(_p '%s category' '%s categories' "$num" \
1401 "$(colorize 33 $num)")"
1402 ;;
1403
1404 '')
1405 # By default list all packages and versions.
1406 title 'List of all installed packages'
1407 awk -F$'\t' '{printf "%-34s %-17s %s\n", $1, $2, $3}' \
1408 $PKGS_DB/installed.info | translate_category
1409
1410 num=$(wc -l < $PKGS_DB/installed.info)
1411 footer "$(_p '%s package installed.' '%s packages installed.' "$num" \
1412 "$(colorize 32 $num)")"
1413 ;;
1414
1415 *)
1416 # Check for an asked category.
1417 ASKED_CATEGORY_I18N="$@"
1418 ASKED_CATEGORY=$(reverse_translate_category "$ASKED_CATEGORY_I18N")
1419 title 'Installed packages of category "%s"' $ASKED_CATEGORY_I18N
1420 TMPLIST=$(mktemp)
1421 awk -F$'\t' -vcat="$ASKED_CATEGORY" \
1422 '{ if ($3 == cat) printf "%-34s %s\n", $1, $2; }' \
1423 $PKGS_DB/installed.info | tee $TMPLIST | translate_category
1424
1425 num=$(wc -l < $TMPLIST); rm $TMPLIST
1426 footer "$(emsg $(_p \
1427 '%s package installed of category "%s".' \
1428 '%s packages installed of category "%s".' $num \
1429 "<c 32>$num</c>" "<c 34>$ASKED_CATEGORY_I18N</c>"))"
1430 ;;
1431 esac ;;
1432
1433
1434 list-mirror|-lm)
1435 # List all available packages on the mirror. Option --diff displays
1436 # last mirrored packages diff (see recharge).
1437 check_for_packages_list
1438 case $2 in
1439 --diff)
1440 if [ -f "$PKGS_DB/packages.diff" ]; then
1441 title 'Mirrored packages diff'
1442 cat $PKGS_DB/packages.diff
1443 num=$(wc -l < $PKGS_DB/packages.diff)
1444 footer "$(_p \
1445 '%s new package listed on the mirror.' \
1446 '%s new packages listed on the mirror.' "$num" \
1447 "$(colorize 32 $num)")"
1448 else
1449 newline
1450 _ 'Unable to list anything, no packages.diff found.'
1451 _ 'Recharge your current list to create a first diff.'
1452 newline
1453 fi
1454 ;;
1455 *)
1456 title 'List of available packages on the mirror'
1457 awk -F$'\t' '{
1458 split($7, s, " ");
1459 printf "%s\n%s\n%s\n%s (%s installed)\n\n", $1, $2, $4, s[1], s[2];
1460 }' $PKGS_DB/packages.info
1461 num=$(wc -l < $PKGS_DB/packages.info)
1462 footer "$(_p \
1463 '%s package in the last recharged list.' \
1464 '%s packages in the last recharged list.' "$num" \
1465 "$(colorize 32 $num)")"
1466 ;;
1467 esac
1468 ;;
1469
1470
1471 list-files|-lf)
1472 # List files installed with the package.
1473 check_for_package_on_cmdline
1474 if [ -d "$INSTALLED/$PACKAGE" ]; then
1475 # installed package
1476 title 'Installed files by "%s"' $PACKAGE
1477 sort < $INSTALLED/$PACKAGE/files.list
1478 num=$(wc -l < $INSTALLED/$PACKAGE/files.list)
1479 footer "$(_p '%s file' '%s files' $num \
1480 "$(colorize 32 $num)")"
1481 elif [ -n "$(grep "^$PACKAGE"$'\t' $PKGS_DB/packages.info)" ]; then
1482 # available package
1483 title 'Installed files by "%s"' $PACKAGE
1484 TMPLIST=$(mktemp)
1485 lzcat $PKGS_DB/files.list.lzma | sed -n "/^$PACKAGE: / s|^[^:]*: ||p" | tee $TMPLIST
1486 num=$(wc -l < $TMPLIST); rm $TMPLIST
1487 footer "$(_p '%s file' '%s files' $num \
1488 "$(colorize 32 $num)")"
1489 else
1490 newline
1491 _ 'Package "%s" not available.' "$PACKAGE"
1492 newline
1493 fi
1494 ;;
1495
1496
1497 info)
1498 # Information about package.
1499 check_for_package_on_cmdline
1500 check_for_receipt
1501 EXTRAVERSION=''
1502 . $INSTALLED/$PACKAGE/receipt
1503 im && title 'TazPkg information'
1504 # Display localized short description
1505 for LC in $LANG ${LANG%_*}; do
1506 PDL="$PKGS_DB/packages-desc.$LC"
1507 if [ -e "$PDL" ]; then
1508 LOCDESC=$(awk -F$'\t' -vp="$PACKAGE" '$1==p{print $2}' $PDL)
1509 [ -n "$LOCDESC" ] && SHORT_DESC="$LOCDESC"
1510 fi
1511 done
1512 SIZES=$(echo $PACKED_SIZE/$UNPACKED_SIZE | sed 's|\.0||g' | sed 's|^/$||')
1513
1514 emsg "$(
1515 {
1516 _ 'Package : %s' "$PACKAGE"
1517 _ 'Version : %s' "$VERSION$EXTRAVERSION"
1518 _ 'Category : %s' "$(_ $CATEGORY)"
1519 itemize "$(_ 'Short desc : %s' "$SHORT_DESC")"
1520 _ 'Maintainer : %s' "$MAINTAINER"
1521 _ 'License : %s' "$LICENSE"
1522 itemize "$(_ 'Depends : %s' "$DEPENDS")"
1523 itemize "$(_ 'Suggested : %s' "$SUGGESTED")"
1524 itemize "$(_ 'Build deps : %s' "$BUILD_DEPENDS")"
1525 itemize "$(_ 'Wanted src : %s' "$WANTED")"
1526 _ 'Web site : %s' "$WEB_SITE"
1527 _ 'Size : %s' "$SIZES"
1528 itemize "$(_ 'Tags : %s' "$TAGS")"
1529 } | sed '/: $/d; s|^\([^:]*\):|<b>\1:</b>|')"
1530 im && footer
1531 ;;
1532
1533
1534 desc|-d)
1535 # Display package description
1536 if [ -n "$(grep -e "^$PACKAGE"$'\t' $PKGS_DB/installed.info)" ]; then
1537 im && title 'Description of package "%s"' $PACKAGE
1538 if [ -s "$INSTALLED/$PACKAGE/description.txt" ]; then
1539 cat $INSTALLED/$PACKAGE/description.txt
1540 else
1541 im && awk -F$'\t' -vp="$PACKAGE" '{
1542 if ($1 == p) print $4 }' $PKGS_DB/installed.info
1543 fi
1544 im && footer
1545 else
1546 im && _ 'Package "%s" is not installed.' "$PACKAGE"
1547 fi
1548 ;;
1549
1550
1551 activity|log|-a)
1552 # Show activity log
1553 [ -n "$nb" ] || nb='18'
1554 title 'TazPkg Activity'
1555 IFS=' '
1556 tail -n $nb $LOG | tac | \
1557 while read date hour none action none pkg vers none; do
1558 case $action in
1559 Installed)
1560 action=$(colorize 32 $action) ;;
1561 Removed)
1562 action=$(colorize 31 $action) ;;
1563 *)
1564 action=$(boldify $action) ;;
1565 esac
1566 date_locale="$(date -d "$date $hour" '+%x %X')"
1567 echo "$date_locale : $action $pkg $vers"
1568 done
1569 unset IFS
1570 footer ;;
1571
1572
1573 search|-s)
1574 # Search for a package by pattern or name.
1575 PATTERN="$2"
1576 if [ -z "$PATTERN" ]; then
1577 newline
1578 _ 'Please specify a pattern or package name to search for.'
1579 echo "$(_ 'Example:') 'tazpkg search paint'"
1580 newline
1581 exit 0
1582 fi
1583 title 'Search result for "%s"' $PATTERN
1584 # Default is to search in installed pkgs and the raw list.
1585 case "$3" in
1586 -i|--installed) search_in_installed_packages ;;
1587 -l|--list) search_in_packages_list ;;
1588 #buggy -m|--mirror) search_in_packages_txt ;;
1589 *)
1590 search_in_installed_packages
1591 search_in_packages_list ;;
1592 esac ;;
1593
1594
1595 search-file|-sf)
1596 # Search for a file by pattern or name in all files.list.
1597 if [ -z "$2" ]; then
1598 newline
1599 _ 'Please specify a pattern or file name to search for.'
1600 echo "$(_ 'Example:') 'tazpkg search-file libnss'"
1601 newline
1602 exit 0
1603 fi
1604 title 'Search result for file "%s"' $2
1605 TMPLIST=$(mktemp)
1606
1607 if [ -n "$mirror" ]; then
1608 TMPDIR=$(mktemp -d)
1609 for i in $PKGS_DB/files.list.lzma $PKGS_DB/undigest/*/files.list.lzma; do
1610 [ -f $i ] || continue
1611 lzcat $i | awk -F: -vtmp="$TMPLIST" -vdir="$TMPDIR" \
1612 -vfile="$2" -vcfile="$(colorize 32 $2)" '
1613 BEGIN { efile = gensub("\+", "\\\+", "g", file); }
1614 index($2, file) {
1615 gsub(efile, cfile, $2);
1616 print $2 >> dir"/"$1;
1617 printf "1" >> tmp;
1618 }'
1619 done
1620
1621 for pkg in $(cd $TMPDIR; ls); do
1622 newline
1623 emsg "<c 33>$(_ 'Package %s:' $pkg)</c>"
1624 cat $TMPDIR/$pkg
1625 done
1626
1627 rm -r $TMPDIR
1628
1629 else
1630
1631 # Check all pkg files.list in search match which specify the package
1632 # name and the full path to the file(s).
1633 for pkg in $INSTALLED/*; do
1634 if grep -qs "$2" $pkg/files.list; then
1635 . $pkg/receipt
1636 newline
1637 emsg "<c 33>$(_ 'Package %s:' $PACKAGE)</c>"
1638 awk -vtmp="$TMPLIST" -vfile="$2" -vcfile="$(colorize 32 $2)" '
1639 BEGIN { efile = gensub("\+", "\\\+", "g", file); }
1640 index($0, file) {
1641 gsub(efile, cfile);
1642 print " "$0;
1643 printf "1" >> tmp;
1644 }
1645 ' $pkg/files.list
1646 fi
1647 done
1648
1649 fi
1650
1651 num=$(wc -m < $TMPLIST); rm $TMPLIST
1652 footer "$(_p '%s file' '%s files' "$num" \
1653 "$(colorize 32 $num)")"
1654 ;;
1655
1656
1657 search-pkgname|-sp)
1658 # Search for a package name
1659 if [ -z "$2" ]; then
1660 newline
1661 _ 'Please specify a pattern or file name to search for.'
1662 echo "$(_ 'Example:') 'tazpkg search-pkgname libnss'"
1663 newline
1664 exit 0
1665 fi
1666 title 'Search result for package "%s"' $2
1667
1668 # Search for a file on mirror and output only the package name
1669 TMPLIST=$(mktemp)
1670 for i in $PKGS_DB/files.list.lzma $PKGS_DB/undigest/*/files.list.lzma; do
1671 [ -f "$i" ] || continue
1672 lzcat $i | awk -F: -vT=$TMPLIST -vterm="$2" '
1673 BEGIN { P = "" }
1674 index($2, term) {
1675 if ($1 != P) {
1676 print $1;
1677 printf "1" >> T;
1678 P = $1
1679 }
1680 }'
1681 done
1682 match=$(wc -m < $TMPLIST)
1683 rm $TMPLIST
1684
1685 footer "$(emsg "$(_p \
1686 '%s package' '%s packages' $match \
1687 "<c 32>$match</c>")")"
1688 ;;
1689
1690
1691 install|-i)
1692 # Install .tazpkg packages.
1693 check_root $@
1694 check_for_package_on_cmdline
1695 check_for_package_file
1696 check_for_installed_info
1697
1698 if [ -n "$root" ]; then
1699 ROOT="$root";
1700 check_base_dir "$root"
1701 fi
1702
1703 [ -n "$list" ] && INSTALL_LIST="$list"
1704
1705 if [ -n "$rootconfig" ]; then # What about this parameter? Is it obsolete?
1706 if [ -n "$root" ]; then
1707 CACHE_DIR="$root/$CACHE_DIR"
1708 SAVE_CACHE_DIR="$CACHE_DIR"
1709 PKGS_DB="$root/$PKGS_DB"
1710 else
1711 echo "rootconfig needs --root= option used." >&2
1712 exit 1
1713 fi
1714 fi
1715
1716 # Get repositories priority list.
1717 look_for_priority
1718
1719 # Check if forced install.
1720 if [ -z "$forced" ]; then
1721 check_for_installed_package $ROOT
1722 fi
1723 install_package $ROOT
1724 update_desktop_database $ROOT
1725 update_mime_database $ROOT
1726 update_icon_database $ROOT
1727 compile_glib_schemas $ROOT
1728 ;;
1729
1730
1731 install-list|get-install-list)
1732 # Install a set of packages from a list.
1733 check_root $@
1734
1735 if [ -z "$2" ]; then
1736 newline
1737 longline "$(_ \
1738 "Please change directory (cd) to the packages repository and specify the \
1739 list of packages to install.")"
1740 echo "$(_ 'Example:') $(emsg '<b>tazpkg install-list</b> <c 33>packages.list</c>')"
1741 exit 0
1742 fi
1743
1744 # Check if the packages list exist.
1745 if [ ! -f "$2" ]; then
1746 _ 'Unable to find list "%s"' "$2"
1747 exit 0
1748 fi
1749
1750 LIST=$(cat $2)
1751
1752 # Remember processed list
1753 export INSTALL_LIST="$2"
1754
1755 # Set $COMMAND and install all packages.
1756 COMMAND=${1%-list}
1757
1758 touch $2-processed
1759
1760 # Upgrade tazpkg first. It may handle new features/formats...
1761 # then upgrade essential packages early
1762 for pkg in busybox-pam busybox gcc-lib-base glibc-base \
1763 slitaz-base-files tazpkg ; do
1764 pkg=$(egrep $pkg-[0-9] $INSTALL_LIST)
1765 [ -z "$pkg" ] && continue
1766 _ 'Adding implicit depends "%s"...' $pkg
1767 LIST="$pkg"$'\n'"$LIST"
1768 done
1769
1770 for pkg in $LIST; do
1771 grep -qs ^$pkg$ $2-processed && continue
1772 [ -d "$root/var/lib/tazpkg/installed" ] &&
1773 tazpkg $COMMAND $pkg --list="$2" "$3" "$4" "$5"
1774 done
1775 rm -f $2-processed ;;
1776
1777
1778 add-flavor)
1779 # Install a set of packages from a flavor.
1780 install_flavor $2 ;;
1781
1782
1783 install-flavor)
1784 # Install a set of packages from a flavor and purge other ones.
1785 install_flavor $2 --purge ;;
1786
1787
1788 set-release)
1789 # Change current release and upgrade packages.
1790 RELEASE="$2"
1791 if [ -z "$RELEASE" ]; then
1792 newline
1793 _ 'Please specify the release you want on the command line.'
1794 echo "$(_ 'Example:') tazpkg set-release cooking"
1795 newline
1796 exit 0
1797 fi
1798 rm $PKGS_DB/mirror
1799 echo "$RELEASE" > /etc/slitaz-release
1800 tazpkg recharge && tazpkg upgrade
1801
1802 # Install missing depends
1803 cd $INSTALLED
1804 for i in * ; do
1805 DEPENDS=''
1806 . $i/receipt
1807 for j in $DEPENDS ; do
1808 [ -d $j ] || tazpkg get-install $j
1809 done
1810 done ;;
1811
1812
1813 remove|-r)
1814 # Remove packages.
1815 check_root $@
1816 check_for_package_on_cmdline
1817 check_for_installed_info
1818
1819 [ -n "$root" ] && ROOT="$root"
1820
1821 if [ ! -f "$ROOT$INSTALLED/$PACKAGE/receipt" ]; then
1822 newline; _ 'Package "%s" is not installed.' $PACKAGE
1823 exit 0
1824 fi
1825
1826 . $ROOT$INSTALLED/$PACKAGE/receipt
1827
1828 # Info #1: dependent packages (to be processed later)
1829 ALTERED="$(awk -F$'\t' -vp=" $PACKAGE " '
1830 index(" " $8 " ", p) { printf " %s\n", $1 }
1831 ' $ROOT/$PKGS_DB/installed.info)"
1832
1833 if [ -n "$ALTERED" ]; then
1834 _ 'The following packages depend on package "%s":' $PACKAGE
1835 echo "$ALTERED"
1836 fi
1837
1838 # Info #2: changed packages (to be processed later)
1839 REFRESH=$(cd $ROOT$INSTALLED ; grep -sl ^$PACKAGE$ */modifiers)
1840
1841 if [ -n "$REFRESH" ]; then
1842 _ 'The following packages have been modified by package "%s":' $PACKAGE
1843 for i in $REFRESH; do
1844 echo " ${i%/modifiers}"
1845 done
1846 fi
1847
1848 # Confirmation
1849 if im && [ -z "$auto" ]; then
1850 confirm "$(_ 'Remove package "%s" (%s)? (y/N)' $PACKAGE $VERSION$EXTRAVERSION)"
1851 if [ $? != 0 ]; then
1852 newline; _ 'Uninstallation of package "%s" cancelled.' $PACKAGE
1853 exit 0
1854 fi
1855 fi
1856 # We are here: non-interactive mode, or --auto, or answer 'y'
1857
1858 # Removing package
1859 title 'Removing package "%s"' $PACKAGE
1860
1861 # [1/4] Pre-remove commands
1862 if grep -q ^pre_remove $ROOT$INSTALLED/$PACKAGE/receipt; then
1863 action "Execution of pre-remove commands..."
1864 pre_remove $ROOT
1865 status
1866 fi
1867
1868 # [2/4] Removing files
1869 action "Removing all files installed..."
1870 if [ -f $ROOT$INSTALLED/$PACKAGE/modifiers ]; then
1871 for file in $(cat $ROOT$INSTALLED/$PACKAGE/files.list); do
1872 for mod in $(cat $ROOT$INSTALLED/$PACKAGE/modifiers); do
1873 [ -f $ROOT$INSTALLED/$mod/files.list ] && \
1874 [ $(grep "^$(echo $file | grepesc)$" $ROOT$INSTALLED/$mod/files.list | wc -l) -gt 1 ] && \
1875 continue 2
1876 done
1877 remove_with_path $ROOT$file
1878 done
1879 else
1880 for file in $(cat $ROOT$INSTALLED/$PACKAGE/files.list); do
1881 remove_with_path $ROOT$file
1882 done
1883 fi
1884 status
1885
1886 # [3/4] Post-remove commands
1887 if grep -q ^post_remove $ROOT$INSTALLED/$PACKAGE/receipt; then
1888 action "Execution of post-remove commands..."
1889 post_remove $ROOT
1890 status
1891 fi
1892
1893 # [4/4] Remove package receipt and remove it from databases
1894 action "Removing package receipt..."
1895 rm -rf $ROOT$INSTALLED/$PACKAGE
1896 sed -i "/ $PACKAGE-$VERSION$EXTRAVERSION.tazpkg$/d" $PKGS_DB/installed.$SUM
1897 sed -i "/^$PACKAGE /d" $PKGS_DB/installed.info
1898 status
1899
1900 footer "$(_ 'Package "%s" (%s) removed.' $PACKAGE $VERSION$EXTRAVERSION)"
1901
1902 # Log this activity
1903 log_pkg Removed
1904
1905 # Stop if non-interactive mode and no --auto option
1906 if ! im && [ -z "$auto" ]; then exit 0; fi
1907
1908 # Process dependent packages
1909 if [ -n "$ALTERED" ]; then
1910 if [ -n "$auto" ]; then
1911 answer=0
1912 else
1913 confirm "$(_ 'Remove packages depending on package "%s"? (y/N)' $PACKAGE)"
1914 answer=$?
1915 fi
1916 if [ "$answer" == '0' ]; then
1917 for i in $ALTERED; do
1918 if [ -d "$ROOT$INSTALLED/$i" ]; then
1919 echo "tazpkg remove $i $ROOTOPTS"
1920 fi
1921 done
1922 fi
1923 fi
1924
1925 # Process changed packages
1926 if [ -n "$REFRESH" ]; then
1927 if [ -n "$auto" ]; then
1928 answer=0
1929 else
1930 confirm "$(_ 'Reinstall packages modified by package "%s"? (y/N)' $PACKAGE)"
1931 answer=$?
1932 fi
1933 if [ "$answer" == '0' ]; then
1934 for i in $REFRESH; do
1935 if [ $(wc -l < $ROOT$INSTALLED/$i) -gt 1 ]; then
1936 _ 'Check %s for reinstallation' "$INSTALLED/$i"
1937 continue
1938 fi
1939 rm -r $ROOT$INSTALLED/$i
1940 tazpkg get-install ${i%/modifiers} $ROOTOPTS --forced
1941 done
1942 fi
1943 fi
1944
1945 ;;
1946
1947
1948 extract|-e)
1949 # Extract .tazpkg cpio archive into a directory.
1950 check_for_package_on_cmdline
1951 check_for_package_file
1952 title 'Extracting package "%s"' "$PACKAGE"
1953
1954 # If no directory destination is found on the cmdline
1955 # we create one in the current dir using the package name.
1956 if [ -n "$TARGET_DIR" ]; then
1957 DESTDIR="$TARGET_DIR/$PACKAGE"
1958 else
1959 DESTDIR="$PACKAGE"
1960 fi
1961 mkdir -p $DESTDIR
1962
1963 action "Copying original package..."
1964 cp $PACKAGE_FILE $DESTDIR
1965 status
1966
1967 cd $DESTDIR
1968 extract_package
1969 [ -e "receipt" ] && \
1970 footer "$(_ 'Package "%s" is extracted to "%s"' $PACKAGE $DESTDIR)"
1971 ;;
1972
1973
1974 recompress)
1975 # Recompress .tazpkg cpio archive with lzma.
1976 check_for_package_on_cmdline
1977 check_for_package_file
1978 title 'Recompressing package "%s"' "$PACKAGE"
1979 mkdir -p $TMP_DIR
1980
1981 action "Copying original package..."
1982 cp $PACKAGE_FILE $TMP_DIR
1983 status
1984
1985 cd $TMP_DIR
1986 extract_package
1987
1988 action "Recompressing the FS..."
1989 find fs | cpio -o -H newc --quiet | lzma e fs.cpio.lzma -si
1990 rm -rf fs
1991 status
1992
1993 action "Creating new package..."
1994 find . -print | cpio -o -H newc --quiet > \
1995 $TOP_DIR/$(basename $PACKAGE_FILE).$$ && mv -f \
1996 $TOP_DIR/$(basename $PACKAGE_FILE).$$ \
1997 $TOP_DIR/$(basename $PACKAGE_FILE)
1998 status
1999
2000 cd $TOP_DIR
2001 rm -rf $TMP_DIR
2002 separator; newline ;;
2003
2004
2005 list-config)
2006 # List configuration files installed.
2007 if [ -n "$box" ]; then
2008 mkdir -p $TMP_DIR; cd $TMP_DIR
2009 FILES="$INSTALLED/*/volatile.cpio.gz"
2010 [ -n "$3" ] && FILES="$INSTALLED/$3/volatile.cpio.gz"
2011 for i in $FILES; do
2012 zcat $i | cpio -idm --quiet > /dev/null
2013 find * -type f 2>/dev/null | while read file; do
2014 if [ ! -e /$file ]; then
2015 echo -n "----------|----|----|$(_n 'File lost')"
2016 else
2017 echo -n "$(stat -c "%A|%U|%G|%s|" /$file)"
2018 cmp $file /$file > /dev/null 2>&1 || \
2019 echo -n "$(stat -c "%.16y" /$file)"
2020 fi
2021 echo "|/$file"
2022 done
2023 rm -rf *
2024 done
2025 cd $TOP_DIR
2026 rm -rf $TMP_DIR
2027 else
2028 im && title 'Configuration files'
2029 for i in $INSTALLED/*/volatile.cpio.gz; do
2030 [ -n "$2" -a "$i" != "$INSTALLED/$2/volatile.cpio.gz" ] && continue
2031 [ -f "$i" ] || continue
2032 zcat $i | cpio -t --quiet
2033 done | sed 's|^|/|' | sort
2034 im && footer
2035 fi ;;
2036
2037
2038 repack-config)
2039 check_root $@
2040 # Create SliTaz package archive from configuration files.
2041 mkdir -p $TMP_DIR; cd $TMP_DIR
2042 CONFIG_VERSION='1.0'
2043 mkdir config-$CONFIG_VERSION
2044 cd config-$CONFIG_VERSION
2045 for i in $INSTALLED/*/volatile.cpio.gz; do
2046 zcat $i | cpio -t --quiet
2047 done > files.list
2048 mkdir fs
2049 cd fs
2050 ( cd / ; cpio -o -H newc --quiet ) < ../files.list | cpio -idm --quiet > /dev/null
2051 mkdir -p etc/tazlito
2052 for i in $INSTALLED/*/receipt; do
2053 EXTRAVERSION=''
2054 . $i
2055 echo "$PACKAGE-$VERSION$EXTRAVERSION"
2056 done > etc/tazlito/config-packages.list
2057 cd ..
2058 echo "etc/tazlito/config-packages.list" >> files.list
2059 pkg_date=$(date +"%x %X")
2060 cat > receipt <<EOT
2061 # SliTaz package receipt.
2062
2063 PACKAGE="config"
2064 VERSION="$CONFIG_VERSION"
2065 CATEGORY="base-system"
2066 SHORT_DESC="$(_n 'User configuration backup on date %s' $pkg_date)"
2067 DEPENDS="$(ls $INSTALLED)"
2068 EOT
2069 cd ..
2070 tazpkg pack config-$CONFIG_VERSION
2071 cp config-$CONFIG_VERSION.tazpkg $TOP_DIR
2072 cd $TOP_DIR
2073 rm -rf $TMP_DIR
2074 ;;
2075
2076
2077 repack)
2078 # Create SliTaz package archive from an installed package.
2079 check_for_package_on_cmdline
2080 check_for_receipt
2081 EXTRAVERSION=''
2082 . $INSTALLED/$PACKAGE/receipt
2083 title 'Repacking "%s"' "$PACKAGE-$VERSION$EXTRAVERSION.tazpkg"
2084
2085 if grep -qs ^NO_REPACK= $INSTALLED/$PACKAGE/receipt; then
2086 _ "Can't repack package \"%s\"" $PACKAGE
2087 exit 1
2088 fi
2089
2090 if [ -s $INSTALLED/$PACKAGE/modifiers ]; then
2091 _ "Can't repack, \"%s\" files have been modified by:" $PACKAGE
2092 for i in $(cat $INSTALLED/$PACKAGE/modifiers); do
2093 echo " $i"
2094 done
2095 exit 1
2096 fi
2097
2098 MISSING=''
2099 while read i; do
2100 [ -e "$i" ] && continue
2101 [ -L "$i" ] || MISSING="$MISSING\n $i"
2102 done < $INSTALLED/$PACKAGE/files.list
2103 if [ -n "$MISSING" ]; then
2104 _n "Can't repack, the following files are lost:"
2105 echo -e "$MISSING"
2106 exit 1
2107 fi
2108
2109 mkdir -p $TMP_DIR; cd $TMP_DIR
2110 FILES="fs.cpio.lzma\n"
2111 for i in $(ls $INSTALLED/$PACKAGE); do
2112 case $i in
2113 volatile.cpio.gz|modifiers) ;;
2114 *) cp $INSTALLED/$PACKAGE/$i .; FILES="$FILES$i\n" ;;
2115 esac
2116 done
2117
2118 ln -s / rootfs
2119 mkdir tmp
2120 sed 's/^/rootfs/' < files.list | cpio -o -H newc --quiet | \
2121 { cd tmp ; cpio -idm --quiet >/dev/null; cd ..; }
2122 mv tmp/rootfs fs
2123
2124 if [ -f $INSTALLED/$PACKAGE/volatile.cpio.gz ]; then
2125 zcat $INSTALLED/$PACKAGE/volatile.cpio.gz | \
2126 { cd fs; cpio -idm --quiet; cd ..; }
2127 fi
2128
2129 if fgrep -q repack_cleanup $INSTALLED/$PACKAGE/receipt; then
2130 . $INSTALLED/$PACKAGE/receipt
2131 repack_cleanup fs
2132 fi
2133
2134 if [ -f $INSTALLED/$PACKAGE/$CHECKSUM ]; then
2135 sed 's, , fs,' < $INSTALLED/$PACKAGE/$CHECKSUM | \
2136 $CHECKSUM -s -c || {
2137 _ "Can't repack, %s error." "$CHECKSUM"
2138 cd $TOP_DIR
2139 rm -rf $TMP_DIR
2140 exit 1
2141 }
2142 fi
2143
2144 find fs | cpio -o -H newc --quiet | lzma e fs.cpio.lzma -si
2145 echo -e "$FILES" | cpio -o -H newc --quiet > \
2146 $TOP_DIR/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg
2147 cd $TOP_DIR
2148 \rm -R $TMP_DIR
2149 _ 'Package "%s" repacked successfully.' $PACKAGE
2150 _ 'Size: %s' "$(du -sh $PACKAGE-$VERSION$EXTRAVERSION.tazpkg)"
2151 newline ;;
2152
2153
2154 pack)
2155 # Create SliTaz package archive using cpio and lzma.
2156 # TODO: Cook also pack packages, we should share code in libpkg.sh
2157 check_for_package_on_cmdline
2158 cd $PACKAGE
2159 if [ ! -f 'receipt' ]; then
2160 _ 'Receipt is missing. Please read the documentation.'
2161 exit 0
2162 fi
2163
2164 title 'Packing package "%s"' $PACKAGE
2165 # Create files.list with redirecting find outpout.
2166
2167 action 'Creating the list of files...'
2168 cd fs
2169 find . -type f -print > ../files.list
2170 find . -type l -print >> ../files.list
2171 cd ..; sed -i s/'^.'/''/ files.list
2172 status
2173
2174 action 'Creating %s of files...' $CHECKSUM
2175 while read file; do
2176 [ -L "fs$file" ] && continue
2177 [ -f "fs$file" ] || continue
2178 case "$file" in
2179 /lib/modules/*/modules.*|*.pyc) continue;;
2180 esac
2181 $CHECKSUM "fs$file" | sed 's/ fs/ /'
2182 done < files.list > $CHECKSUM
2183 status
2184
2185 UNPACKED_SIZE=$(du -chs fs receipt files.list $CHECKSUM \
2186 description.txt 2>/dev/null | awk 'END { print $1 }')
2187
2188 # Build cpio archives.
2189 action "Compressing the FS..."
2190 find fs | cpio -o -H newc --quiet | case "$TAZPKG_PACK" in
2191 gzip) gzip -9 > fs.cpio.gz ;;
2192 *) lzma e fs.cpio.lzma -si ;;
2193 esac
2194 rm -rf fs
2195 status
2196
2197 PACKED_SIZE=$(du -chs fs.cpio.lzma receipt files.list \
2198 $CHECKSUM description.txt 2>/dev/null | awk 'END { print $1 }')
2199
2200 action "Updating receipt sizes..."
2201 sed -i s/^PACKED_SIZE.*$// receipt
2202 sed -i s/^UNPACKED_SIZE.*$// receipt
2203 sed -i "s/^PACKAGE=/PACKED_SIZE=\"$PACKED_SIZE\"\nUNPACKED_SIZE=\"$UNPACKED_SIZE\"\nPACKAGE=/" receipt
2204 status
2205
2206 action "Creating full cpio archive..."
2207 find . -print | cpio -o -H newc --quiet > ../$PACKAGE.tazpkg
2208 status
2209
2210 action "Restoring original package tree..."
2211 unlzma -c fs.cpio.lzma | cpio -idm --quiet
2212 status
2213
2214 rm fs.cpio.lzma && cd ..
2215 footer "$(_ 'Package "%s" compressed successfully.' $PACKAGE)"
2216 _ 'Size: %s' "$(ls -lh $PACKAGE.tazpkg | awk '{print $5}')"
2217 ;;
2218
2219
2220 recharge)
2221 # Recharge packages databases from a mirror.
2222 #
2223 # WARNING: The 'mirrors' file has all SliTaz mirrors but 'mirror'
2224 # must have only the chosen main mirror.
2225 #
2226 check_root $@
2227
2228 # usage: tazpkg recharge [--root=path] [main|<repository>]
2229
2230 ARG="$2"
2231 if [ -n "$root" ]; then
2232 PKGS_DB="$root$PKGS_DB"
2233 [ "${2#--}" != "$2" ] && ARG="$3"
2234 fi
2235
2236 case "$ARG" in
2237 main) repo_to_recharge="$PKGS_DB";;
2238 '') repo_to_recharge="$PKGS_DB $PKGS_DB/undigest/*";;
2239 *) repo_to_recharge="$PKGS_DB/undigest/$ARG"
2240 if [ ! -d "$repo_to_recharge" ]; then
2241 _ "Repository \"%s\" doesn't exist." "$repo_to_recharge" >&2
2242 exit 1
2243 fi
2244 ;;
2245 esac
2246
2247 for path in $repo_to_recharge; do
2248 [ ! -f $path/mirror ] && continue # skip
2249 cd $path
2250 mirror="$(cat mirror)"
2251
2252 # Repository name
2253 if [ "$path" == "$PKGS_DB" ]; then
2254 repo_name='Main'
2255 else
2256 repo_name="$(_n 'Undigest %s' "$(basename $path)")"
2257 fi
2258
2259 title 'Recharging repository "%s"' "$repo_name"
2260
2261 # Don't let ID be a symlink when using local repository.
2262 if [ -h ID ]; then mv -f ID ID.lnk; cat ID.lnk > ID; rm ID.lnk; fi
2263 if [ -h IDs ]; then mv -f IDs IDs.lnk; cat IDs.lnk > IDs; rm IDs.lnk; fi
2264
2265 [ -f ID ] && mv ID ID.bak # Compatibility with "old" ID
2266 [ -f IDs ] && mv IDs IDs.bak
2267 download_from "$mirror" IDs
2268 [ -e 'IDs' ] && awk '{print $1}' IDs > ID # Compatibility with "old" ID
2269
2270 # Check if recharging is needed
2271 if [ -f 'IDs' ] && cmp -s IDs IDs.bak; then
2272 action 'Checking...'; status # "Fake" message
2273 footer "$(_ 'Repository "%s" is up to date.' "$repo_name")"
2274 rm IDs.bak ID.bak
2275 continue
2276 fi
2277 rm IDs.bak ID.bak 2>/dev/null
2278
2279 [ -e 'IDs' ] && _ 'Database timestamp: %s' "$(date -d "@$(awk '{print $2}' IDs)" "+%x %R")"
2280
2281 action 'Creating backup of the last packages list...'
2282 for i in packages.desc packages.$SUM packages.txt packages.list \
2283 packages.equiv files.list.lzma extra.list mirrors packages.info; do
2284 [ -f "$i" ] && mv -f $i $i.bak 2>/dev/null
2285 done
2286 status
2287
2288 # Download and extract bundle: extra.list, mirrors, files-list.md5,
2289 # packages.{info,desc,md5,txt,list,equiv}
2290 bundle='bundle.tar.lzma'
2291 action 'Getting "%s"...' $bundle
2292 download_from "$mirror" $bundle
2293 status
2294 if [ -f "$bundle" ]; then
2295 busybox tar -xaf $bundle; rm $bundle
2296 else
2297 recharging_failed $path; continue
2298 fi
2299
2300 # Download files.list.lzma
2301 files_local='files.list.lzma'; files_remote='files-list.lzma'
2302 if [ -e "$files_local.bak" ]; then
2303 md5sum $files_local.bak | awk '{printf $1}' > files-list.md5.bak
2304 if cmp -s files-list.md5 files-list.md5.bak; then
2305 mv $files_local.bak $files_remote
2306 else
2307 action 'Getting "%s"...' $files_remote
2308 download_from "$mirror" $files_remote
2309 status
2310 fi
2311 else
2312 action 'Getting "%s"...' $files_remote
2313 download_from "$mirror" $files_remote
2314 status
2315 fi
2316
2317 if [ ! -e "$files_remote" ]; then
2318 recharging_failed $path; continue
2319 fi
2320 mv -f $files_remote $files_local
2321
2322 # Remove old database files (but packages.list.bak, extra.list.bak)
2323 for i in packages.desc packages.$SUM packages.txt packages.equiv \
2324 files.list.lzma mirrors packages.info files-list.md5; do
2325 [ -f "$i.bak" ] && rm $i.bak 2>/dev/null
2326 done
2327
2328 footer "$(_ 'Last database is ready to use.')"
2329
2330 # Check diff
2331 if [ -f 'packages.list.bak' ]; then
2332 diff -u packages.list.bak packages.list | grep ^+[a-z] > packages.diff
2333 rm packages.list.bak
2334 if [ -f 'extra.list.bak' ]; then
2335 if [ -f 'extra.list' ]; then
2336 awk -F'|' '{print $1 " (extra)"}' extra.list > extra.list1
2337 awk -F'|' '{print $1 " (extra)"}' extra.list.bak > extra.list1.bak
2338 diff -u extra.list1.bak extra.list1 | grep ^+[a-z] >> packages.diff
2339 rm extra.list.bak extra.list1 extra.list1.bak
2340 else
2341 mv extra.list.bak extra.list
2342 fi
2343 fi
2344 sed -i s/+// packages.diff
2345
2346 new_pkgs=$(wc -l < packages.diff)
2347 if [ "$new_pkgs" -gt 0 ]; then
2348 title 'Mirrored packages diff'
2349 cat packages.diff
2350 footer "$(emsg "$(_p \
2351 '%s new package on the mirror.' \
2352 '%s new packages on the mirror.' $new_pkgs \
2353 "<c 32>$new_pkgs</c>")")"
2354 fi
2355 else
2356 longline "$(_ "Note that next time you recharge the \
2357 list, a list of differences will be displayed to show new and upgradeable \
2358 packages.")"
2359 fi
2360 done
2361 newline ;;
2362
2363
2364 help-up)
2365 # Options available for the command: up
2366 newline; usage_up; newline
2367 exit 1 ;;
2368
2369
2370 up|upgrade)
2371 check_root
2372 #
2373 # This is the new way to upgrade packages making 'upgrade' and
2374 # upgradeable out-of-date. This new way is much, much more faster!
2375 # Look into installed packages and get data from receipt, it is fast
2376 # and easy to handle vars after using only md5sum to compare packages
2377 #
2378 for opt in $@; do
2379 case "$opt" in
2380 --recharge|-r) tazpkg recharge ;;
2381 --install|-i) install="y" ;;
2382 --check|-c) install="n" ;;
2383 esac
2384 done
2385 time="$(date +%s)"
2386
2387 look_for_priority
2388 for repo in $priority; do
2389 pkg_list="$repo/packages.list"
2390 mtime=$(find $pkg_list -mtime +7)
2391 if [ -n "$mtime" ]; then
2392 if [ "$repo" == "$PKGS_DB" ]; then
2393 repo_name='main'
2394 else
2395 repo_name="${repo##*/}"
2396 fi
2397 _ 'List "%s" is older than one week... Recharging.' $pkg_list
2398 tazpkg recharge $repo_name
2399 fi
2400 done
2401
2402 emsg "<n>$(_ 'Package')<i 28> $(_ 'Version')<i 48> $(_ 'Status')<->"
2403
2404 cd $INSTALLED
2405 echo -n > $UP_LIST
2406 blocked_count=0
2407 installed_sum="$PKGS_DB/installed.$SUM"
2408
2409 for pkg in *; do
2410 [ ! -d $pkg ] && continue
2411 unset VERSION EXTRAVERSION
2412 . $pkg/receipt
2413 md5=$(fgrep " $PACKAGE-$VERSION$EXTRAVERSION.tazpkg" \
2414 $installed_sum | awk '{print $1}')
2415 for repo in $priority; do
2416 pkg_desc="$repo/packages.desc"
2417 pkg_list="$repo/packages.list"
2418 pkg_sum="$repo/packages.$SUM"
2419
2420 if ! fgrep -q "$md5 $PACKAGE-" $pkg_sum; then
2421 # Jump to next repository in priority if pkg doesn't exist
2422 # in this one.
2423 grep -q ^$PACKAGE- $pkg_list || continue
2424
2425 emsg -n "$PACKAGE<i 28> $VERSION"
2426
2427 # Skip pkgs listed in $PKGS_DB/blocked-packages.list
2428 if $(grep -qs "^$PACKAGE" $BLOCKED); then
2429 blocked_count=$(($blocked_count + 1))
2430 emsg "<i 48><c 31> $(_ 'Blocked')</c>"
2431 break
2432 fi
2433
2434 new=$(grep "^$PACKAGE |" $pkg_desc | awk '{print $3}')
2435
2436 if [ "$VERSION" == "$new" ]; then
2437 emsg "<i 48><c 34> $(_ 'New build')</c>"
2438 else
2439 emsg "<i 48><c 32> $(_ 'New version %s' $new)</c>"
2440 fi
2441 echo "$PACKAGE" >> $UP_LIST
2442 break
2443 fi
2444 done
2445 done
2446 sed -i /^$/d $UP_LIST
2447 upnb=$(wc -l < $UP_LIST)
2448 pkgs=$(ls | wc -l)
2449 time=$(($(date +%s) - $time))
2450 if [ "$upnb" == 0 ]; then
2451 install="n"
2452 _ 'System is up-to-date...'
2453 fi
2454
2455 footer "$(emsg "$(_p \
2456 '%s installed package scanned in %ds' \
2457 '%s installed packages scanned in %ds' $pkgs \
2458 "<c 32>$pkgs</c>" $time)")"
2459
2460 if [ "$upnb" != 0 ]; then
2461 blocked="$(_p \
2462 '%s blocked' \
2463 '%s blocked' $blocked_count \
2464 $blocked_count)"
2465
2466 boldify "$(_p \
2467 'You have %s available upgrade (%s)' \
2468 'You have %s available upgrades (%s)' $upnb \
2469 $upnb "$blocked")"
2470 newline
2471 fi
2472
2473 # Pkgs to upgrade ? Skip, let install them all or ask user
2474 [ "$install" == 'n' ] && exit 0
2475 if [ "$upnb" -gt 0 ]; then
2476 if [ "$install" == 'y' ]; then
2477 answer=0
2478 else
2479 confirm "$(_ 'Do you wish to install them now? (y/N)')"
2480 answer=$?
2481 fi
2482 case "$answer" in
2483 0)
2484 for pkg in $(cat $UP_LIST); do
2485 echo 'y' | tazpkg get-install $pkg --forced
2486 done
2487 # List is generated each time and must be cleaned so
2488 # tazpkg-notify doesn't find upgrades anymore.
2489 rm $UP_LIST; touch $UP_LIST ;;
2490 *)
2491 _ 'Leaving without any upgrades installed.'
2492 newline
2493 exit 0 ;;
2494 esac
2495 fi
2496 newline ;;
2497
2498
2499 bugs)
2500 # Show known bugs in package(s)
2501 cd $INSTALLED
2502 shift
2503 LIST=$@
2504 [ -z "$LIST" ] && LIST=$(ls)
2505 MSG=$(_n 'No known bugs.')
2506
2507 title 'Known bugs in packages'
2508 for PACKAGE in $LIST; do
2509 BUGS=''
2510 EXTRAVERSION=''
2511 . $PACKAGE/receipt
2512 if [ -n "$BUGS" ]; then
2513 MSG=$(_n 'Bug list completed')
2514 newline
2515 _ 'Bugs in package "%s" version %s:' $PACKAGE $VERSION$EXTRAVERSION
2516 cat <<EOT
2517 $BUGS
2518 EOT
2519 fi
2520 done
2521 footer "$MSG" ;;
2522
2523
2524 check)
2525 # Check installed packages set.
2526 #check_root $@
2527
2528 # Get repositories priority list.
2529 look_for_priority
2530
2531 cd $INSTALLED
2532 if [ -z "$2" -o "$2" == '--full' ]; then PACKAGES="$(ls)"; else PACKAGES="$2"; fi
2533 PACKAGE_PRINTED=''
2534
2535 for PACKAGE in $PACKAGES; do
2536
2537 if [ ! -f "$PACKAGE/receipt" ]; then
2538 print_pkgname
2539 _ 'The package installation has not completed'
2540 continue
2541 fi
2542
2543 DEPENDS=''
2544 EXTRAVERSION=''
2545 . $PACKAGE/receipt
2546 if [ -s $PACKAGE/modifiers ]; then
2547 print_pkgname
2548 _ 'The package has been modified by:'
2549 awk '{print " " $0}' $PACKAGE/modifiers
2550 fi
2551
2552 MSG="$(_n 'Files lost from package:')\n"
2553 while read file; do
2554 [ -e "$file" ] && continue
2555 if [ -L "$file" ]; then
2556 MSG="$MSG $(_n 'target of symlink')"
2557 fi
2558 print_pkgname
2559 echo -e "$MSG $file"
2560 MSG=''
2561 done < $PACKAGE/files.list
2562
2563 MSG="$(_n 'Missing dependencies for package:')\n"
2564 for i in $DEPENDS; do
2565 [ -d $i ] && continue
2566 [ -d $(equivalent_pkg $i) ] && continue
2567 print_pkgname
2568 echo -e "$MSG $i"
2569 MSG=''
2570 done
2571
2572 MSG="$(_n 'Dependencies loop between package and:')\n"
2573 ALL_DEPS=''
2574 check_for_deps_loop $PACKAGE $DEPENDS
2575 done
2576 [ -n "$PACKAGE_PRINTED" ] && footer
2577
2578 _ 'Looking for known bugs...'
2579 if [ -z "$2" -o "$2" == '--full' ]; then tazpkg bugs; else tazpkg bugs "$2"; fi
2580
2581
2582 if [ -n "$full" ]; then
2583 separator
2584
2585 title 'Mismatch checksum of installed files:'
2586
2587 for PACKAGE in $PACKAGES; do
2588 file="$PACKAGE/$CHECKSUM"
2589 CONFIG_FILES=''
2590 . $PACKAGE/receipt
2591 [ -s "$file" ] || continue
2592 while read md5 f; do
2593 [ -f $f ] || continue
2594 for i in $CONFIG_FILES; do
2595 case "$f" in
2596 $i|$i/*) continue 2;;
2597 esac
2598 done
2599 echo "$md5 $f"
2600 done < "$file" | busybox $CHECKSUM -c - 2>/dev/null | \
2601 grep -v OK$ | sed "s/: FAILED$//"
2602 done
2603 footer
2604
2605 title 'Check file providers:'
2606 FILES=' '
2607 for PACKAGE in $PACKAGES; do
2608 for file in $(cat $PACKAGE/files.list); do
2609 [ -d "$file" ] && continue
2610 case "$FILES" in
2611 *\ $file\ *) continue;;
2612 esac
2613 [ $(grep "^$(echo $file | grepesc)$" */files.list 2> /dev/null | \
2614 wc -l) -gt 1 ] || continue
2615 FILES="$FILES$file "
2616 newline
2617 _ 'The following packages provide file "%s":' $file
2618 grep -l "^$(echo $file | grepesc)$" */files.list | \
2619 while read f; do
2620 pkg=${f%/files.list}
2621 if [ -f $pkg/modifiers ]; then
2622 overriders=$(_n '(overridden by %s)' "$(tr '\n' ' ' < $pkg/modifiers | sed 's| $||')")
2623 else
2624 overriders=''
2625 fi
2626 echo -n " * $pkg $overriders"
2627 newline
2628 done
2629 done
2630 done
2631 footer
2632
2633 if [ "$2" == '--full' ]; then
2634 title 'Alien files:'
2635 MSG="$(_n 'No package has installed the following files:')\n"
2636 find /etc /bin /sbin /lib /usr /var/www -not -type d 2>/dev/null | \
2637 while read file; do
2638 case "$file" in *\[*) continue;; esac
2639 grep -q "^$(echo $file | grepesc)$" */files.list && continue
2640 echo -e "$MSG $file"
2641 MSG=''
2642 done
2643 footer
2644 fi
2645 fi
2646 _ 'Check completed.'; newline ;;
2647
2648
2649 block|-b)
2650 # Add a pkg name to the list of blocked packages.
2651 check_root $@
2652 check_for_package_on_cmdline
2653 newline
2654 if [ ! -d $INSTALLED/$PACKAGE ]; then
2655 _ 'Package "%s" is not installed.' $PACKAGE; exit
2656 fi
2657 if grep -qs "^$PACKAGE" $BLOCKED; then
2658 _ 'Package "%s" is already blocked.' $PACKAGE
2659 else
2660 echo $PACKAGE >> $BLOCKED
2661 # Log this activity
2662 . $INSTALLED/$PACKAGE/receipt; log_pkg Blocked
2663 _ 'Package "%s" blocked.' $PACKAGE
2664 fi
2665 newline ;;
2666
2667
2668 unblock|-u)
2669 # Remove a pkg name from the list of blocked packages.
2670 check_root $@
2671 check_for_package_on_cmdline
2672 newline
2673 if [ ! -d $INSTALLED/$PACKAGE ]; then
2674 _ 'Package "%s" is not installed.' $PACKAGE; exit
2675 fi
2676 if grep -qs "^$PACKAGE" $BLOCKED; then
2677 sed -i "/^$PACKAGE\$/d" $BLOCKED
2678 # Log this activity
2679 . $INSTALLED/$PACKAGE/receipt; log_pkg Unblocked
2680 _ 'Package "%s" unblocked.' $PACKAGE
2681 else
2682 _ 'Package "%s" is not blocked.' $PACKAGE
2683 fi
2684 newline ;;
2685
2686
2687 chblock)
2688 # Change package's blocked status.
2689 check_root $@
2690 check_for_package_on_cmdline
2691 newline
2692 if [ ! -d $INSTALLED/$PACKAGE ]; then
2693 _ 'Package "%s" is not installed.' $PACKAGE; exit
2694 fi
2695 if grep -qs "^$PACKAGE" $BLOCKED; then
2696 sed -i "/^$PACKAGE\$/d" $BLOCKED
2697 # Log this activity
2698 . $INSTALLED/$PACKAGE/receipt; log_pkg Unblocked
2699 _ 'Package "%s" unblocked.' $PACKAGE
2700 else
2701 echo $PACKAGE >> $BLOCKED
2702 # Log this activity
2703 . $INSTALLED/$PACKAGE/receipt; log_pkg Blocked
2704 _ 'Package "%s" blocked.' $PACKAGE
2705 fi
2706 newline ;;
2707
2708
2709 get|-g)
2710 # Download a package with wget.
2711 check_root $@
2712 check_for_package_on_cmdline
2713 check_for_packages_list
2714
2715 [ -n "$root" ] && ROOT="$root" && check_base_dir "$root"
2716 if [ -n "$rootconfig" ]; then
2717 if [ -n "$root" ]; then
2718 CACHE_DIR="$root/$CACHE_DIR"
2719 SAVE_CACHE_DIR="$CACHE_DIR"
2720 PKGS_DB="$root/$PKGS_DB"
2721 else
2722 _ 'rootconfig needs --root= option used.' >&2
2723 exit 1
2724 fi
2725 fi
2726
2727 # Get repositories priority list.
2728 look_for_priority
2729
2730 CURRENT_DIR="$PWD"
2731 cd $CACHE_DIR
2732 if check_for_package_in_list check ; then
2733 cd $CACHE_DIR
2734 if [ -f "$PACKAGE.tazpkg" ]; then
2735 _ 'Package "%s" already in the cache' $PACKAGE
2736 # Check package download was finished
2737 tail -c 2k $PACKAGE.tazpkg | fgrep -q 00000000TRAILER || {
2738 _ 'Continuing package "%s" download' $PACKAGE
2739 download $PACKAGE.tazpkg
2740 }
2741 if [ "$($CHECKSUM $PACKAGE.tazpkg)" != "$(fgrep " $PACKAGE.tazpkg" $rep/packages.$SUM)" ]; then
2742 rm -f $PACKAGE.tazpkg
2743 download $PACKAGE.tazpkg
2744 fi
2745 else
2746 download $PACKAGE.tazpkg
2747 fi
2748 PACKAGE_FILE="$CACHE_DIR/$PACKAGE.tazpkg"
2749 elif download_get_script $PACKAGE /tmp/$PACKAGE.$$ ; then
2750 install_package_from_get_script /tmp/$PACKAGE.$$ "$ROOT" --get
2751 PACKAGE_FILE=$(ls $PWD/$PACKAGE-*.tazpkg)
2752 fi
2753 [ "$PWD" != "$CURRENT_DIR" ] &&
2754 cp -a $PACKAGE_FILE $CURRENT_DIR
2755 ;;
2756
2757
2758 get-install|-gi)
2759 # Download and install a package.
2760 check_root $@
2761 check_for_package_on_cmdline
2762 check_for_packages_list
2763
2764 DO_CHECK=''
2765 [ -n "$forced" ] && DO_CHECK='no'
2766 [ -n "$root" ] && ROOT="$root" && check_base_dir "$root"
2767 [ -n "$list" ] && INSTALL_LIST="$list" # internal option
2768
2769 if [ -n "$rootconfig" ]; then # outdated?
2770 if [ -n "$root" ]; then
2771 CACHE_DIR="$root/$CACHE_DIR"
2772 SAVE_CACHE_DIR="$CACHE_DIR"
2773 PKGS_DB="$root/$PKGS_DB"
2774 else
2775 _ 'rootconfig needs --root= option used.' >&2
2776 exit 1
2777 fi
2778 fi
2779
2780 # Get repositories priority list.
2781 look_for_priority
2782
2783 AUTOEXEC='no'
2784 if ! check_for_package_in_list check; then
2785 CACHE_DIR="${CACHE_DIR%/*}/get"
2786 [ -d "$CACHE_DIR" ] || mkdir -p $CACHE_DIR
2787 if download_get_script $PACKAGE /tmp/$PACKAGE.$$ ; then
2788 install_package_from_get_script /tmp/$PACKAGE.$$ $ROOT
2789 exit 0
2790 else
2791 PACKAGE="get-$PACKAGE"
2792 AUTOEXEC="$PACKAGE"
2793 check_for_package_in_list
2794 if [ -n "$(get_installed_package_pathname $PACKAGE $ROOT)" ]; then
2795 $AUTOEXEC $ROOT
2796 exit 0
2797 fi
2798 fi
2799 fi
2800 # Check if no forced install.
2801 if [ -z "$forced" ]; then
2802 check_for_installed_package $ROOT
2803 fi
2804 cd $CACHE_DIR
2805 if [ -f "$PACKAGE.tazpkg" ]; then
2806 _ 'Package "%s" already in the cache' $PACKAGE
2807 # Check package download was finished
2808 tail -c 2k $PACKAGE.tazpkg | fgrep -q 00000000TRAILER || {
2809 _ 'Continuing package "%s" download' $PACKAGE
2810 download $PACKAGE.tazpkg
2811 }
2812 if [ "$($CHECKSUM $PACKAGE.tazpkg)" != "$(fgrep " $PACKAGE.tazpkg" $rep/packages.$SUM)" ]; then
2813 rm -f $PACKAGE.tazpkg
2814 download $PACKAGE.tazpkg
2815 fi
2816 else
2817 newline
2818 download $PACKAGE.tazpkg
2819 fi
2820 PACKAGE_FILE="$CACHE_DIR/$PACKAGE.tazpkg"
2821 [ -n "$rootconfig" ] && PKGS_DB="${PKGS_DB#$root}"
2822 install_package "$ROOT"
2823 [ "$AUTOEXEC" != "no" ] && $PACKAGE $ROOT
2824 update_desktop_database $ROOT
2825 update_mime_database $ROOT ;;
2826
2827
2828 clean-cache|-cc)
2829 # Remove all downloaded packages.
2830 check_root $@
2831 files=$(find $CACHE_DIR -name *.tazpkg | wc -l)
2832 size=$(du -hs $CACHE_DIR | cut -f1 | sed 's|\.0||'); [ "$files" == '0' ] && size="0K"
2833
2834 title "Cleaning cache directory..."
2835 action 'Path: %s' $CACHE_DIR
2836 rm -rf $CACHE_DIR/*
2837 status
2838
2839 footer "$(_p \
2840 '%s file removed from cache (%s).' \
2841 '%s files removed from cache (%s).' $files \
2842 "$(colorize 32 "$files")" $size)"
2843 ;;
2844
2845
2846 list-undigest)
2847 # list undigest URLs.
2848 if [ -n "$box" ]; then
2849 for i in $PKGS_DB/undigest/*/mirror; do
2850 [ -f "$i" ] || continue
2851 echo "$(basename $(dirname $i))|$(cat $i)"
2852 done
2853 else
2854 title 'Current undigest(s)'
2855 for i in $PKGS_DB/undigest/*/mirror; do
2856 if [ ! -f "$i" ]; then
2857 _ 'No undigest mirror found.'
2858 exit 1
2859 fi
2860 echo "$(basename $(dirname $i))"$'\t'"$(cat $i)"
2861 done
2862 newline
2863 fi
2864 ;;
2865
2866
2867 remove-undigest)
2868 # remove undigest URL.
2869 check_root $@
2870 undigest="$2"
2871 if [ -d "$PKGS_DB/undigest/$2" ]; then
2872 confirm "$(_ 'Remove "%s" undigest? (y/N)' $undigest)"
2873 if [ $? == 0 ]; then
2874 action 'Removing "%s" undigest...' $undigest
2875 rm -rf $PKGS_DB/undigest/$2
2876 status
2877 rmdir $PKGS_DB/undigest 2>/dev/null
2878 fi
2879 else
2880 _ 'Undigest "%s" not found' $undigest
2881 fi
2882 ;;
2883
2884
2885 add-undigest|setup-undigest)
2886 # Add undigest URL.
2887 check_root $@
2888
2889 [ ! -d "$PKGS_DB/undigest" ] && mkdir "$PKGS_DB/undigest"
2890
2891 undigest="$2"
2892 if [ -z "$undigest" ]; then
2893 i='1'
2894 while [ -d "$PKGS_DB/undigest/$i" ]; do
2895 i=$(($i+1))
2896 done
2897 undigest="$i"
2898 fi
2899 if [ ! -d "$PKGS_DB/undigest/$undigest" ]; then
2900 _ 'Creating new undigest "%s".' "$undigest"
2901 mkdir "$PKGS_DB/undigest/$undigest"
2902 fi
2903 setup_mirror "$PKGS_DB/undigest/$undigest" "$3"
2904 ;;
2905
2906
2907 setup-mirror|-sm)
2908 # Change mirror URL.
2909 check_root $@
2910 setup_mirror $PKGS_DB $2 ;;
2911
2912
2913 reconfigure)
2914 # Replay post_install from receipt
2915 check_for_package_on_cmdline
2916 check_root $@
2917
2918 ROOT="$root"
2919 if [ -d "$ROOT$INSTALLED/$PACKAGE" ]; then
2920 check_for_receipt $ROOT
2921 # Check for post_install
2922 if grep -q ^post_install $ROOT$INSTALLED/$PACKAGE/receipt; then
2923 . $ROOT$INSTALLED/$PACKAGE/receipt
2924 post_install $ROOT
2925 # Log this activity
2926 [ -z "$ROOT" ] && log_pkg Reconfigured
2927 else
2928 newline
2929 _ 'Nothing to do for package "%s".' $PACKAGE
2930 fi
2931 else
2932 newline
2933 _ 'Package "%s" is not installed.' $PACKAGE
2934 _ 'Install package with "%s" or "%s"' 'tazpkg install' 'tazpkg get-install'
2935 newline
2936 fi ;;
2937
2938
2939 shell)
2940 # TazPkg SHell
2941 if [ "$(id -u)" -eq 0 ]; then
2942 PROMPT="\\033[1;33mtazpkg\\033[0;39m# "
2943 else
2944 PROMPT="\\033[1;33mtazpkg\\033[0;39m> "
2945 fi
2946 if [ "$2" != "--noheader" ]; then
2947 clear
2948 title 'TazPkg SHell.'
2949 _ "Type 'usage' to list all available commands or 'quit' or 'q' to exit."
2950 newline
2951 fi
2952 while true; do
2953 echo -en "$PROMPT"; read cmd
2954 case $cmd in
2955 q|quit)
2956 break ;;
2957 shell)
2958 _ 'You are already running a TazPkg SHell.' ;;
2959 su)
2960 su -c 'exec tazpkg shell --noheader' && break ;;
2961 "")
2962 continue ;;
2963 *)
2964 tazpkg $cmd ;;
2965 esac
2966 done ;;
2967
2968
2969 depends)
2970 # Display dependencies tree
2971 cd $INSTALLED
2972 ALL_DEPS=''
2973 if [ -f "$2/receipt" ]; then
2974 dep_scan $2 ''
2975 fi ;;
2976
2977
2978 rdepends)
2979 # Display reverse dependencies tree
2980 cd $INSTALLED
2981 ALL_DEPS=''
2982 if [ -f "$2/receipt" ]; then
2983 rdep_scan $2
2984 fi
2985 ;;
2986
2987
2988 list-suggested)
2989 for i in $(ls -d $INSTALLED/*); do
2990 SUGGESTED=''
2991 . $i/receipt
2992 if [ -n "$SUGGESTED" ]; then
2993 if [ -z "$all" ]; then
2994 for s in $SUGGESTED; do
2995 [ -d "$INSTALLED/$s" ] && \
2996 SUGGESTED="$(echo -n $SUGGESTED | sed "s/$s//")"
2997 done
2998 fi
2999 cat <<EOT
3000 $(boldify $(echo $PACKAGE):) $SUGGESTED
3001 EOT
3002 fi
3003 done
3004 ;;
3005
3006
3007 convert|-c)
3008 # convert misc package format to .tazpkg
3009 check_for_package_file
3010 shift
3011 tazpkg-convert $@
3012 ;;
3013
3014
3015 link)
3016 # link a package from another slitaz installation
3017 PACKAGE=$2
3018 if [ ! -d "$TARGET_DIR" -o \
3019 ! -d "$TARGET_DIR$INSTALLED/$PACKAGE" ]; then
3020 _ 'Usage: tazpkg link package_name slitaz_root'
3021 longline "$(
3022 _n 'Example:'
3023 echo -n ' '
3024 _ '"%s" will use less than 100k in your running system RAM.' \
3025 'tazpkg link openoffice /mnt')"
3026 exit 1
3027 fi
3028 if [ -e "$INSTALLED/$PACKAGE" ]; then
3029 _ 'Package "%s" is already installed.' $PACKAGE
3030 exit 1
3031 fi
3032 ln -s $TARGET_DIR$INSTALLED/$PACKAGE $INSTALLED
3033 DEPENDS="$(. $INSTALLED/$PACKAGE/receipt ; echo $DEPENDS)"
3034 MISSING=''
3035 for i in $DEPENDS; do
3036 [ -e $INSTALLED/$i ] && continue
3037 MISSING="$MISSING$i "
3038 _ 'Missing: %s' $i
3039 done
3040 if [ -n "$MISSING" ]; then
3041 newline
3042 confirm "$(_ 'Link all missing dependencies? (y/N)')"
3043 answer=$?
3044 newline
3045 if [ "$answer" == 0 ]; then
3046 for i in $MISSING; do
3047 tazpkg link $i $TARGET_DIR
3048 done
3049 else
3050 newline
3051 _ 'Leaving dependencies unresolved for package "%s"' $PACKAGE
3052 _ 'The package is installed but probably will not work.'
3053 newline
3054 fi
3055 fi
3056 . $INSTALLED/$PACKAGE/receipt
3057 if grep -q ^pre_install $INSTALLED/$PACKAGE/receipt; then
3058 pre_install
3059 fi
3060 while read path; do
3061 [ -e "$path" ] && continue
3062 while true; do
3063 dir="$(dirname $path)"
3064 [ -e "$dir" ] && break
3065 path="$dir"
3066 done
3067 ln -s "$TARGET_DIR$path" "$dir"
3068 done < $INSTALLED/$PACKAGE/files.list
3069 if grep -q ^post_install $INSTALLED/$PACKAGE/receipt; then
3070 post_install
3071 fi ;;
3072
3073
3074 help|-h)
3075 # TazPkg help system
3076 shift; tazpkg-help $@ ;;
3077
3078
3079 usage|*)
3080 # Print a short help or give usage for an unknown or empty command.
3081 usage ;;
3082 esac
3083
3084 exit 0