tazpkg: b08425cbbb2c tazpkg

48 for c in "base-system" "x-window" "utilities" "network" "graphics" "multimedia" "office" "development" "system-tools" "security" "games" "misc" "meta" "non-free"; do

49 cat_i18n="$cat_i18n

50 $(gettext "$c") $c"

51 done

52 # If category is not one of those translated in native language, keep it

53 # untranslated. This allows both native and english language support.

54 # This also supports custom categories.

55 # And now we support spaces in translated categories

56 reverse_translate_category()

57 {

58 echo "$cat_i18n" | awk "BEGIN{FS=\" \"}{if (/^$@ /) a=\$2}END{if (a==\"\") a=\"$@\"; print a}"

59 }

61 #

62 # TazPKG output functions

63 #

64 # Print localized title

65 title() { newline; boldify "$(eval_gettext "$1")"; separator; }

66 # Print footer

67 footer() { separator; echo "$1"; newline; }

68 # Print current action in brown color (separate from any other msgs)

69 action() {

70 case $output in

71 raw|gtk|html) eval_gettext "$@" ;;

72 *) echo -ne "\033[0;33m"$(eval_gettext "$@")"\033[0m" ;;

73 esac

74 }

76 # Initialize some variables to use words rather than numbers for functions

77 # and actions.

78 COMMAND=$1

79 PACKAGE=${2%/}

80 PACKAGE_DIR="$(cd $(dirname $PACKAGE 2>/dev/null) 2>/dev/null; pwd)"

81 [ -n "$PACKAGE" ] &&

82 PACKAGE_FILE="$PACKAGE_DIR/${PACKAGE##*/}"

83 if [ -f "$PACKAGE" ]; then

84 # Set pkg basename for install, extract

85 PACKAGE=$(basename ${PACKAGE%.tazpkg} 2>/dev/null)

86 else

87 # Pkg name for remove, search and all other cmds

88 PACKAGE=${PACKAGE%.tazpkg}

89 fi

90 TARGET_DIR=$3

91 TOP_DIR=`pwd`

92 TMP_DIR=/tmp/$RANDOM

93 INSTALL_LIST=""

94 SAVE_CACHE_DIR="$CACHE_DIR"

96 # Path to tazpkg used dir and configuration files

97 MIRROR=$LOCALSTATE/mirror

98 BLOCKED=$LOCALSTATE/blocked-packages.list

99 UP_LIST=$LOCALSTATE/packages.up

100 DEFAULT_MIRROR="$ONLINE_PKGS"

101

102 # Need by check_depends

103 TMPLOCALSTATE=

104

105 ####################

106 # Script functions #

107 ####################

108

109 # Print the usage.

110 usage () {

111 cat << EOT

112

113 $(eval_gettext 'SliTaz package manager - Version:') $(colorize 34 $VERSION)

114

115 $(boldify "$(gettext 'Usage:')")

116 $(gettext 'tazpkg [command] [package|dir|pattern|list|cat|--opt] [dir|--opt]')

117

118 $(boldify "$(gettext 'SHell:')") tazpkg shell

119

120 $(boldify "$(gettext 'Commands:')")

121 usage $(gettext 'Print this short usage')

122 bugs $(gettext 'Show known bugs in packages')

123 activity|-a $(gettext 'Show TazPKG activity log')

124 list|-l $(gettext 'List installed packages on the system by category or all')

125 list-mirror|-lm $(gettext 'List all available packages on the mirror (--diff for new)')

126 info $(gettext 'Print information about a package')

127 desc $(gettext 'Print description of a package (if it exists)')

128 list-files|-lf $(gettext 'List the files installed with a package')

129 list-config $(gettext 'List the configuration files')

130 search|-s $(gettext 'Search for a package by pattern or name (options: -i|-l|-m)')

131 search-pkgname $(gettext 'Search on mirror for package having a particular file')

132 search-file|-sf $(gettext 'Search for file(s) in all installed packages files')

133 install|-i $(gettext 'Install a local (*.tazpkg) package (--forced to force)')

134 install-list $(gettext 'Install all packages from a list of packages.')

135 remove|-r $(gettext 'Remove the specified package and all installed files')

136 extract|-e $(gettext 'Extract a (*.tazpkg) package into a directory')

137 pack $(gettext 'Pack an unpacked or prepared package tree')

138 recharge $(gettext 'Recharge your packages.list from the mirror')

139 up|help-up $(eval_gettext 'Check packages $CHECKSUM to list and install latest upgrades')

140 repack $(gettext 'Create a package archive from an installed package')

141 repack-config $(gettext 'Create a package archive with configuration files')

142 recompress $(gettext 'Rebuild a package with a better compression ratio')

143 block|unblock $(gettext 'Block an installed package version or unblock it for upgrade')

144 get $(gettext 'Download a package into the current directory')

145 get-install|-gi $(gettext 'Download and install a package from the mirror')

146 get-install-list $(gettext 'Download and install a list of packages from the mirror')

147 check $(gettext 'Verify consistency of installed packages')

148 add-flavor $(gettext 'Install the flavor list of packages')

149 install-flavor $(gettext 'Install the flavor list of packages and remove other ones')

150 set-release $(gettext 'Change release and update packages')

151 clean-cache|-cc $(gettext 'Clean all packages downloaded in cache directory')

152 depends $(gettext 'Display dependencies tree')

153 rdepends $(gettext 'Display reverse dependencies tree')

154 convert $(gettext 'Convert deb/rpm/tgz/pet/sfs/sb/arch/ipk package to tazpkg)')

155 link $(gettext 'Link a package from another slitaz installation')

156 setup-mirror|-sm $(gettext 'Change the mirror url configuration')

157 list-undigest $(gettext 'List undigest mirrors')

158 remove-undigest $(gettext 'Remove an undigest mirror')

159 add-undigest $(gettext 'Add an undigest mirror')

160 setup-undigest $(gettext 'Update an undigest mirror')

161 reconfigure $(gettext 'Replay post install script from package')

162

163 EOT

164 }

165

166 usage_up() {

167 cat << EOT

168 $(emsg "$(gettext 'Usage for command up:')") tazpkg up [$(gettext 'option')]

169

170 * $(gettext 'Without options run in interactive mode and ask before install')

171

172 $(boldify "$(gettext 'Where options are:')")

173 --check |-c $(gettext 'Check only for available upgrades')

174 --recharge |-r $(gettext 'Force recharge of packages list and check')

175 --install |-i $(gettext 'Check for upgrades and install them all')

176

177 $(boldify "$(gettext 'Example:')")

178 tazpkg up --recharge --install

179 tazpkg up -c -r

180 EOT

181 }

182

183 # Check if dir exists

184 check_dir()

185 {

186 if ! [ -d "$1" ]; then

187 FOLDER=$1

188 action 'Creating $FOLDER...'

189 mkdir -p "$FOLDER"

190 status

191 return 1

192 fi

193 }

194

195 # Check if the directories and files used by TazPKG

196 # exist. If not and user is root we create them.

197 check_base_dir()

198 {

199 if [ "$(id -u)" = "0" ]; then

200 check_dir $1$CACHE_DIR

201 check_dir $1$INSTALLED

202 check_dir $1$SLITAZ_LOGS

203 if [ ! -f "$1$LOCALSTATE/mirror" ]; then

204 echo "$DEFAULT_MIRROR" > $1$LOCALSTATE/mirror

205 [ -n "$1" ] && cp $LOCALSTATE/packages.* $1$LOCALSTATE/

206 fi

207 fi

208 }

209 check_base_dir

210

211 # Check for a package name on cmdline.

212 check_for_package_on_cmdline()

213 {

214 if [ -z "$PACKAGE" ]; then

215 newline

216 gettext "Please specify a package name on the command line."; echo

217 newline

218 exit 0

219 fi

220 }

221

222 # Check if the package (*.tazpkg) exists before installing or extracting.

223 check_for_package_file()

224 {

225 if [ ! -f "$PACKAGE_FILE" ]; then

226 newline

227 eval_gettext "Unable to find: \$PACKAGE_FILE"; echo

228 newline

229 exit 0

230 fi

231 }

232

233 # Check for the receipt of an installed package.

234 check_for_receipt()

235 {

236 receipt_path="$1$INSTALLED/$PACKAGE/receipt"

237 if [ ! -f $receipt_path ]; then

238 newline

239 eval_gettext 'Unable to find the receipt: $receipt_path'; echo

240 newline

241 exit 0

242 fi

243 }

244

245 # Get repositories priority using $LOCALSTATE/priority.

246 # In this files, undigest are called by their name and main mirror

247 # by main. Sort order: priority

248 look_for_priority()

249 {

250 [ -s $LOCALSTATE/priority ] && priority=$(cat $LOCALSTATE/priority)

251 for rep in main $(ls $LOCALSTATE/undigest 2>/dev/null); do

252 if [ ! -s $LOCALSTATE/priority ] || \

253 ! grep -q ^$rep$ $LOCALSTATE/priority; then

254 priority=$(echo -e "$priority\n$rep")

255 fi

256 done

257 priority=$(echo "$priority" | sed '/^$/d' | \

258 while read line; do

259 if [ "$line" = main ]; then

260 echo $LOCALSTATE

261 else

262 echo $LOCALSTATE/undigest/$line

263 fi

264 done)

265 }

266

267 # Get package name in a directory

268 package_fullname_in_dir()

269 {

270 [ -f $1/receipt ] || return

271 EXTRAVERSION=""

272 . $1/receipt

273 echo $PACKAGE-$VERSION$EXTRAVERSION

274 }

275

276 # Get package name that is already installed.

277 get_installed_package_pathname()

278 {

279 for i in $2$INSTALLED/${1%%-*}*; do

280 [ -d $i ] || continue

281 if [ "$1" = "$(package_fullname_in_dir $i)" ]; then

282 echo $i

283 return

284 fi

285 done

286 }

287

288 # Check if a package is already installed.

289 check_for_installed_package()

290 {

291 if [ -n "$(get_installed_package_pathname $PACKAGE $1)" ]; then

292 newline

293 cat << EOT

294 $(colorize 34 $PACKAGE) $(gettext "package is already installed.

295 You can use the --forced option to force installation.")

296 EOT

297 newline

298 exit 0

299 fi

300 }

301

302 # Check for packages.list to download and install packages.

303 check_for_packages_list()

304 {

305 list_path="$LOCALSTATE/packages.list"

306 if [ ! -f "$list_path" ]; then

307 if test $(id -u) = 0 ; then

308 tazpkg recharge

309 else

310 newline

311 eval_gettext 'Unable to find the list: $list_path'; echo

312 gettext \

313 "You must probably run 'tazpkg recharge' as root to get the latest list of

314 packages available on the mirror."; echo

315 newline

316 exit 0

317 fi

318 fi

319 }

320

321 get_cache_dir()

322 {

323 echo $rep > $tmp/rep

324 if [ "$rep" = "$LOCALSTATE" ]; then

325 CACHE_DIR="$SAVE_CACHE_DIR/$SLITAZ_RELEASE/packages"

326 elif [ "${rep%-incoming}" = "$rep" ]; then

327 CACHE_DIR="$SAVE_CACHE_DIR/${rep##*/}/packages"

328 else

329 rep="${rep%-incoming}"

330 CACHE_DIR="$SAVE_CACHE_DIR/${rep##*/}/packages-incoming"

331 fi

332 [ -d "$CACHE_DIR" ] || mkdir -p $CACHE_DIR

333 echo $CACHE_DIR > $tmp/cachedir

334 }

335

336 # get an already installed package from packages.equiv

337 equivalent_pkg()

338 {

339 for i in $(grep -hs "^$1=" $LOCALSTATE/packages.equiv \

340 $LOCALSTATE/undigest/*/packages.equiv | sed "s/^$1=//"); do

341 if echo $i | fgrep -q : ; then

342 # format 'alternative:newname'

343 # if alternative is installed then substitute newname

344 if [ -f $2$INSTALLED/${i%:*}/receipt ]; then

345 # substitute package dependency

346 echo ${i#*:}

347 return

348 fi

349 else

350 # if alternative is installed then nothing to install

351 if [ -f $2$INSTALLED/$i/receipt ]; then

352 # substitute installed package

353 echo $i

354 return

355 fi

356 fi

357 done

358 # if not found in packages.equiv then no substitution

359 echo $1

360 }

361

362 # get a virtual package from packages.equiv

363 virtual_pkg()

364 {

365 for i in $(for rep in $priority; do

366 grep -hs "^$1=" $rep/packages.equiv

367 done | sed "s/^$1=//"); do

368 if echo $i | fgrep -q : ; then

369 # format 'alternative:newname'

370 # if alternative is installed then substitute newname

371 if [ -f $2$INSTALLED/${i%:*}/receipt ]; then

372 # substitute package dependency

373 echo ${i#*:}

374 return

375 fi

376 else

377 # unconditional substitution

378 echo $i

379 return

380 fi

381 done

382 }

383

384 # Get package filename available on the mirror

385 get_package_filename()

386 {

387 local pkg

388 for rep in $priority; do

389 pkg=$(grep -A 1 -sh "^$1$" $rep/packages.txt | tail -1 | \

390 sed 's/^ *//')

391 [ "$pkg" ] && pkg=$(grep -sh "^$1-$pkg" \

392 $rep/packages.list | head -1)

393

394 # Allow user to call a package with his version number.

395 [ "$pkg" ] || pkg=$(grep -sh "^$1$" $rep/packages.list | head -1)

396

397 [ "$pkg" ] || pkg=$(grep -sh "^$1-[0-9]" \

398 $rep/packages.list | head -1)

399 [ "$pkg" ] || pkg=$(grep -sh "^$1-.[\.0-9]" \

400 $rep/packages.list | head -1)

401 [ "$pkg" ] && get_cache_dir && break

402 done

403 if [ -z "$pkg" ]; then

404 # Check for virtual package

405 local equiv

406 equiv=$(virtual_pkg $1)

407 if [ "$equiv" != "$1" ]; then

408 PACKAGE=$equiv

409 get_package_filename $PACKAGE

410 return

411 fi

412 fi

413 echo $pkg

414 }

415

416 # Check for a package in packages.list. Used by get and get-install to grep

417 # package basename.

418 check_for_package_in_list()

419 {

420 local filename

421 local check_only

422 check_only="$1"

423 filename=$(get_package_filename $PACKAGE)

424 if [ "$filename" ]; then

425 PACKAGE=$filename

426 CACHE_DIR=$(cat $tmp/cachedir)

427 rep=$(cat $tmp/rep)

428 rm -f $tmp/rep $tmp/cachedir

429 else

430 newline

431 eval_gettext "Unable to find: \$PACKAGE in the mirrored packages list."; echo

432 newline

433 [ -n "$check_only" ] && return 1

434 exit 0

435 fi

436 }

437

438 # Log this activity

439 # (there log_pkg because we have log() in libtaz.sh)

440 log_pkg()

441 {

442 local extra

443 [ "$1" = "Installed" ] && \

444 extra=" - $(fgrep $PACKAGE-$VERSION $LOCALSTATE/installed.$SUM | awk '{ print $1 }')"

445 [ -e $LOG ] || touch $LOG

446 DATE=`date +'%F %T'`

447 [ -w $LOG ] &&

448 echo "$DATE - $1 - $PACKAGE ($VERSION$EXTRAVERSION)$extra" >> $LOG

449 }

450

451 # Download a get-package script from this mirror

452 download_get_script()

453 {

454 local p

455 for p in $priority ; do

456 local i

457 for i in $(cat $p/mirror) ; do

458 case "$i" in

459 http://*|ftp://*)

460 wget -O $2 ${i%packages/*}packages/get/$1 &&

461 return 0 ;;

462 esac

463 done

464 done

465 return 1

466 }

467

468 # Download a file from this mirror

469 download_from()

470 {

471 local i

472 local mirrors

473 mirrors="$1"

474 shift

475 for i in $mirrors; do

476 case "$i" in

477 # Mirror URL can have a trailing slash or not.

478 http://*|ftp://*) busybox wget -c ${i%/}/$@ && break ;;

479 *) ln -sf $i/$1 . && break ;;

480 esac

481 done

482 }

483

484 # Download a file trying all mirrors

485 download()

486 {

487 local i

488 case "$1" in

489 *.tazpkg)

490 for i in $priority ; do

491 grep -q "^${1%.tazpkg}$" $i/packages.list 2>/dev/null || continue

492 download_from "$(cat $i/mirror)" "$@" && return

493 done

494 esac

495 for i in $(cat `for rep in $priority; do echo $rep/mirror; done` \

496 2> /dev/null); do

497 download_from "$i" "$@" && break

498 done

499 }

500

501 # Extract a package with cpio and gzip/lzma.

502 extract_package()

503 {

504 action "Extracting \$PACKAGE..."

505 cpio -idm --quiet < ${PACKAGE_FILE##*/} && rm -f ${PACKAGE_FILE##*/}

506 status

507 if [ -f fs.cpio.lzma ]; then

508 unlzma -c fs.cpio.lzma | cpio -idm --quiet && rm fs.cpio.lzma

509 elif [ -f fs.cpio.gz ]; then

510 zcat fs.cpio.gz | cpio -idm --quiet && rm fs.cpio.gz

511 fi

512 }

513

514 remove_with_path()

515 {

516 # Avoid dirname errors by checking for argument.

517 [ "$1" ] || return

518

519 local dir

520 rm -f $1 2>/dev/null

521 dir="$1"

522 while [ "$dir" != "/" ]; do

523 dir="$(dirname $dir)"

524 rmdir $dir 2> /dev/null || break

525 done

526 }

527

528 grepesc()

529 {

530 sed 's/\[/\\[/g'

531 }

532

533 # This function installs a package in the rootfs.

534 install_package()

535 {

536 ROOT=$1

537 if [ -n "$ROOT" ]; then

538 # Get absolute path

539 ROOT=$(cd $ROOT; pwd)

540 fi

541 {

542 # Create package path early to avoid dependencies loop

543 mkdir -p $TMP_DIR

544 { cd $TMP_DIR ; cpio --quiet -i receipt > /dev/null 2>&1; } < $PACKAGE_FILE

545 . $TMP_DIR/receipt

546 if grep -q ^pre_depends $TMP_DIR/receipt; then

547 pre_depends $ROOT

548 fi

549 # Keep modifiers and file list on upgrade

550 cp $ROOT$INSTALLED/$PACKAGE/modifiers \

551 $ROOT$INSTALLED/$PACKAGE/files.list $TMP_DIR 2> /dev/null

552 rm -rf $ROOT$INSTALLED/$PACKAGE 2> /dev/null

553 # Make the installed package data dir to store

554 # the receipt and the files list.

555 mkdir -p $ROOT$INSTALLED/$PACKAGE

556 cp $TMP_DIR/modifiers $ROOT$INSTALLED/$PACKAGE 2> /dev/null

557 cp $TMP_DIR/files.list $ROOT$INSTALLED/$PACKAGE 2> /dev/null

558 rm -rf $TMP_DIR 2> /dev/null

559 sed -i "/ $(basename $PACKAGE_FILE)$/d" \

560 $ROOT$LOCALSTATE/installed.$SUM 2> /dev/null

561 cd $(dirname $PACKAGE_FILE)

562 $CHECKSUM $(basename $PACKAGE_FILE) >> $ROOT$LOCALSTATE/installed.$SUM

563 }

564 # Resolve package deps.

565 check_for_deps $ROOT

566 if [ ! "$MISSING_PACKAGE" = "" ]; then

567 install_deps $ROOT

568 fi

569 mkdir -p $TMP_DIR

570 [ -n "$INSTALL_LIST" ] && echo "$PACKAGE_FILE" >> $ROOT$LOCALSTATE/$INSTALL_LIST-processed

571 title 'Installation of: $PACKAGE'

572 action "Copying \$PACKAGE..."

573 cp $PACKAGE_FILE $TMP_DIR

574 status

575 cd $TMP_DIR

576 extract_package

577 SELF_INSTALL=0

578 EXTRAVERSION=""

579 CONFIG_FILES=""

580 # Include temporary receipt to get the right variables.

581 . $PWD/receipt

582 cd $ROOT$INSTALLED

583 if [ $SELF_INSTALL -ne 0 -a -n "$ROOT" ]; then

584 action "Checking post install dependencies..."

585 [ -f $INSTALLED/$PACKAGE/receipt ]

586 if ! status; then

587 command="tazpkg install $PACKAGE_FILE"

588 eval_gettext "Please run '\$command' in / and retry."; echo

589 rm -rf $TMP_DIR

590 exit 1

591 fi

592 fi

593 # Get files to remove if upgrading

594 if [ -f $PACKAGE/files.list ]; then

595 while read file; do

596 grep -q "^$(echo $file | grepesc)$" $TMP_DIR/files.list && continue

597 for i in $(cat $PACKAGE/modifiers 2> /dev/null ;

598 fgrep -sl $PACKAGE */modifiers | cut -d/ -f1 ); do

599 grep -qs "^$(echo $file | grepesc)$" $i/files.list && continue 2

600 done

601 echo $file

602 done < $PACKAGE/files.list > $TMP_DIR/files2remove.list

603 fi

604 # Remember modified packages

605 { check=false

606 for i in $(fgrep -v [ $TMP_DIR/files.list); do

607 [ -e "$ROOT$i" ] || continue

608 [ -d "$ROOT$i" ] && continue

609 echo "- $i"

610 check=true

611 done ;

612 $check && for i in *; do

613 [ "$i" == "$PACKAGE" ] && continue

614 [ -s $i/files.list ] || continue

615 awk "{ printf \"$i %s\\n\",\$1 }" < $i/files.list

616 done; } | awk '

617 {

618 if ($1 == "-" || file[$2] != "") {

619 file[$2] = file[$2] " " $1

620 if ($1 != "-") {

621 if (pkg[$1] == "") all = all " " $1

622 pkg[$1] = pkg[$1] " " $2

623 }

624 }

625 }

626 END {

627 for (i = split(all, p, " "); i > 0; i--)

628 for (j = split(pkg[p[i]], f, " "); j > 0; j--)

629 printf "%s %s\n",p[i],f[j];

630 }

631 ' | while read dir file; do

632 if grep -qs ^$dir$ $PACKAGE/modifiers; then

633 # Do not overload an overloaded file !

634 rm $TMP_DIR$file 2> /dev/null

635 continue

636 fi

637 grep -qs ^$PACKAGE$ $dir/modifiers && continue

638 if [ -s "$dir/volatile.cpio.gz" ]; then

639 # We can modify backed up files without notice

640 zcat $dir/volatile.cpio.gz | cpio -t --quiet | \

641 grep -q "^${file#/}$" && continue

642 fi

643 echo "$PACKAGE" >> $dir/modifiers

644 done

645

646 cd $TMP_DIR

647 cp receipt files.list $ROOT$INSTALLED/$PACKAGE

648 # Copy the description if found.

649 if [ -f "description.txt" ]; then

650 cp description.txt $ROOT$INSTALLED/$PACKAGE

651 fi

652 # Copy the md5sum if found.

653 if [ -f "$CHECKSUM" ]; then

654 cp $CHECKSUM $ROOT$INSTALLED/$PACKAGE

655 fi

656 # Pre install commands.

657 if grep -q ^pre_install $ROOT$INSTALLED/$PACKAGE/receipt; then

658 pre_install $ROOT

659 fi

660 if [ -n "$CONFIG_FILES" ]; then

661 # save 'official' configuration files

662 action "Saving configuration files for \$PACKAGE..."

663 for i in $CONFIG_FILES; do

664 { cd fs ; find ${i#/} -type f 2> /dev/null; cd ..; }

665 done | { cd fs ; cpio -o -H newc --quiet | gzip -9; cd ..; } > \

666 $ROOT$INSTALLED/$PACKAGE/volatile.cpio.gz

667 # keep user configuration files

668 for i in $CONFIG_FILES; do

669 { cd fs ; find ${i#/} -type f 2> /dev/null; cd ..; }

670 done | while read i; do

671 [ -e $ROOT/$i ] || continue

672 cp -a $ROOT/$i fs/$i

673 done

674 status

675 fi

676 action "Installing \$PACKAGE..."

677 [ "$(ls fs/* 2> /dev/null)" ] && cp -a fs/* $ROOT/

678 status

679 if [ -s files2remove.list ]; then

680 action "Removing old \$PACKAGE..."

681 while read file; do

682 remove_with_path $ROOT$file

683 done < files2remove.list

684 true

685 status

686 fi

687 # Remove the temporary random directory.

688 action "Removing all tmp files..."

689 cd .. && rm -rf $TMP_DIR

690 status

691 # Post install commands.

692 if grep -q ^post_install $ROOT$INSTALLED/$PACKAGE/receipt; then

693 post_install $ROOT

694 fi

695 # Update-desktop-database if needed.

696 if [ "$(fgrep .desktop $ROOT$INSTALLED/$PACKAGE/files.list | fgrep /usr/share/applications/)" ]; then

697 updatedesktopdb=yes

698 fi

699 # Update-mime-database if needed.

700 if [ "$(fgrep /usr/share/mime $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then

701 updatemimedb=yes

702 fi

703 # Update-icon-database

704 if [ "$(fgrep /usr/share/icon/hicolor $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then

705 updateicondb=yes

706 fi

707 # Compile glib schemas if needed.

708 if [ "$(fgrep /usr/share/glib-2.0/schemas $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then

709 compile_schemas=yes

710 fi

711 # Update depmod list

712 if [ "$(fgrep /lib/modules $ROOT$INSTALLED/$PACKAGE/files.list)" ]; then

713 updatedepmod=yes

714 fi

715 cd $TOP_DIR

716 pkg_name="$PACKAGE ($VERSION$EXTRAVERSION)"

717 footer "$(eval_gettext '$pkg_name is installed.')"

718 # Log this activity

719 [ -n "$ROOT" ] || log_pkg Installed

720 }

721

722 # This function may be called by a get script.

723 abort_package()

724 {

725 cd $CUR_DIR

726 rm -rf $TMP_DIR

727 echo "${1:-Abort $PACKAGE.}"

728 exit 1

729 }

730

731 # This function installs a package from a get script in the rootfs.

732 install_package_from_get_script()

733 {

734 SCRIPT="$1"

735 ROOT="$2"

736 [ -d $ROOT$INSTALLED/$PACKAGE ] && exit 1

737

738 grep -q no-check-certificate $SCRIPT &&

739 [ ! -d $INSTALLED/wget ] && tazpkg get-install wget

740

741 mkdir -p $TMP_DIR && cd $TMP_DIR

742 unset_receipt

743

744 set -e

745 . $SCRIPT

746 set +e

747

748 if [ ! -s $PACKAGE-$VERSION/receipt ]; then

749 cat > $PACKAGE-$VERSION/receipt <<EOT

750 # SliTaz package receipt.

751

752 PACKAGE="$PACKAGE"

753 VERSION="${VERSION:-unknown}"

754 CATEGORY="${CATEGORY:-non-free}"

755 WEB_SITE="$WEB_SITE"

756 SHORT_DESC="${SHORT_DESC:-$PACKAGE}"

757 MAINTAINER="${MAINTAINER:-nobody@slitaz.org}"

758 EOT

759 for i in LICENSE TARBALL WGET_URL CONFIG_FILES SUGGESTED \

760 PROVIDE DEPENDS HOST_ARCH ; do

761 eval "[ -n \"\$$i\" ] && echo \"$i=\\\"\$$i\\\"\""

762 done >> $PACKAGE-$VERSION/receipt

763 fi

764

765 DEPENDS="$(unset DEPENDS; . $PACKAGE-$VERSION/receipt ; echo $DEPENDS)"

766 for i in $(find_depends $PACKAGE-$VERSION/fs); do

767 case " $DEPENDS " in

768 *\ $i\ *) continue;;

769 esac

770 grep -q '^DEPENDS="' $PACKAGE-$VERSION/receipt ||

771 echo 'DEPENDS=""' >> $PACKAGE-$VERSION/receipt

772 sed -i "s/^DEPENDS=\"/&$i /" $PACKAGE-$VERSION/receipt

773 done

774

775 tazpkg pack $PACKAGE-$VERSION

776

777 # Clean to save RAM memory before installation

778 rm -rf $PACKAGE-$VERSION

779

780 # Install pseudo package

781 tazpkg install $PACKAGE-$VERSION.tazpkg --root=$ROOT

782 mv $PACKAGE-$VERSION.tazpkg $CACHE_DIR

783

784 # Clean

785 cd $TOP_DIR

786 rm -rf $TMP_DIR

787 }

788

789 # Check for loop in deps tree.

790 check_for_deps_loop()

791 {

792 local list

793 local pkg

794 local deps

795 pkg=$1

796 shift

797 [ -n "$1" ] || return

798 list=""

799 # Filter out already processed deps

800 for i in $@; do

801 case " $ALL_DEPS" in

802 *\ $i\ *);;

803 *) list="$list $i";;

804 esac

805 done

806 ALL_DEPS="$ALL_DEPS$list "

807 for i in $list; do

808 [ -f $i/receipt ] || continue

809 deps="$(DEPENDS=""; . $i/receipt; echo $DEPENDS)"

810 case " $deps " in

811 *\ $pkg\ *) echo -e "$MSG $i"; MSG="";;

812 *) check_for_deps_loop $pkg $deps;;

813 esac

814 done

815 }

816

817 # Check for missing deps listed in a receipt packages.

818 check_for_deps()

819 {

820 local saved;

821 saved=$PACKAGE

822 mkdir -p $TMP_DIR

823 { cd $TMP_DIR ; cpio --quiet -i receipt > /dev/null 2>&1; } < $PACKAGE_FILE

824 . $TMP_DIR/receipt

825 PACKAGE=$saved

826 rm -rf $TMP_DIR

827

828 num=0

829 for pkgorg in $DEPENDS

830 do

831 i=$(equivalent_pkg $pkgorg $1)

832 if [ ! -d "$1$INSTALLED/$i" ]; then

833 MISSING_PACKAGE=$i

834 num=$(($num+1))

835 elif [ ! -f "$1$INSTALLED/$i/receipt" ]; then

836 eval_gettext "WARNING Dependency loop between \$PACKAGE and \$i."; echo

837 fi

838 done

839

840 if [ ! "$MISSING_PACKAGE" = "" ]; then

841 title "$(eval_gettext 'Tracking dependencies for: $PACKAGE')"

842 for pkgorg in $DEPENDS

843 do

844 i=$(equivalent_pkg $pkgorg $1)

845 if [ ! -d "$1$INSTALLED/$i" ]; then

846 MISSING_PACKAGE=$i

847 eval_gettext "Missing: \$MISSING_PACKAGE"; echo

848 fi

849 done

850 separator

851 eval_ngettext \

852 "\$num missing package to install." \

853 "\$num missing packages to install." $num; echo

854 fi

855 }

856

857 # Install all missing deps. Auto install or ask user then install all missing

858 # deps from local dir, cdrom, media or from the mirror. In case we want to

859 # install packages from local, we need a packages.list to find the version.

860 install_deps()

861 {

862 local root

863 root=""

864 [ -n "$1" ] && root="--root=$1"

865 if [ "$AUTO_INSTALL_DEPS" == "yes" ]; then

866 answer=0

867 else

868 newline

869 gettext "Install all missing dependencies" && confirm

870 answer=$?

871 newline

872 fi

873 if [ $answer = 0 ]; then

874 for pkgorg in $DEPENDS

875 do

876 pkg=$(equivalent_pkg $pkgorg $1)

877 if [ ! -d "$1$INSTALLED/$pkg" ]; then

878 local list

879 list="$INSTALL_LIST"

880 [ -n "$list" ] || list="$TOP_DIR/packages.list"

881 # We can install packages from a local dir by greping

882 # the TAZPKG_BASENAME in the local packages.list.

883 found=0

884 if [ -f "$list" ]; then

885 eval_gettext "Checking if \$pkg exists in local list..."; echo

886 mkdir $TMP_DIR

887 for i in $pkg-*.tazpkg; do

888 [ -f $i ] || continue

889 { cd $TMP_DIR ; cpio --quiet -i receipt > /dev/null 2>&1; } < $i

890 [ "$(. $TMP_DIR/receipt; echo $PACKAGE)" = "$pkg" ] || continue

891 if grep -q ^$(package_fullname_in_dir $TMP_DIR).tazpkg$ $list

892 then

893 found=1

894 tazpkg install $i $root --list=$list

895 break

896 fi

897 done

898 rm -rf $TMP_DIR

899 fi

900 # Install deps from the mirror.

901 if [ $found -eq 0 ]; then

902 if [ ! -f "$LOCALSTATE/packages.list" ]; then

903 tazpkg recharge

904 fi

905 tazpkg get-install $pkg $root

906 fi

907 fi

908 done

909 else

910 newline

911 eval_gettext \

912 "Leaving dependencies for \$PACKAGE unresolved.

913 The package is installed but will probably not work."; echo

914 newline

915 fi

916 }

917

918 # Search pattern in installed packages.

919 search_in_installed_packages()

920 {

921 gettext "Installed packages"; echo

922 separator

923 list=`ls -1 $INSTALLED | grep -i "$PATTERN"`

924 num=0

925 for pkg in $list

926 do

927 EXTRAVERSION=""

928 [ -f $INSTALLED/$pkg/receipt ] || continue

929 . $INSTALLED/$pkg/receipt

930 emsg "$PACKAGE $VERSION$EXTRAVERSION $(gettext $CATEGORY)"

931 num=$(($num+1))

932 done

933 # Set correct ending messages.

934 if [ x$num == x ]; then

935 eval_gettext "No installed packages found for: \$PATTERN"; echo

936 newline

937 else

938 footer "$(eval_ngettext \

939 '$num installed package found for: $PATTERN' \

940 '$num installed packages found for: $PATTERN' $num)"

941 fi

942 }

943

944 # Search in packages.list for available pkgs.

945 search_in_packages_list()

946 {

947 gettext "Available packages name-version"; echo

948 separator

949 num=0

950 for i in $LOCALSTATE/packages.list $LOCALSTATE/undigest/*/packages.list; do

951 grep -is "$PATTERN" $i

952 num=$(($num + `grep -is "$PATTERN" $i | wc -l`))

953 done

954 if [ ! -f "$LOCALSTATE/packages.list" ]; then

955 newline

956 gettext \

957 "No 'packages.list' found to check for mirrored packages. For more results,

958 please run 'tazpkg recharge' once as root before searching."; echo

959 newline

960 fi

961 if [ "$num" = "0" ]; then

962 eval_gettext "No available packages found for: \$PATTERN"; echo

963 newline

964 else

965 footer "$(eval_ngettext \

966 '$num available package found for: $PATTERN' \

967 '$num available packages found for: $PATTERN' $packages)"

968 fi

969 }

970

971 # search --mirror: Search in packages.txt for available pkgs and give more

972 # info than --list or default.

973 search_in_packages_txt()

974 {

975 gettext "Matching packages name with version and desc"; echo

976 separator

977 num=0

978 for i in $LOCALSTATE/packages.txt $LOCALSTATE/undigest/*/packages.txt; do

979 grep -is -A 2 "^$PATTERN" $i

980 num=$(($num + `grep -is "^$PATTERN" $i | wc -l`))

981 done

982 if [ ! -f "$LOCALSTATE/packages.txt" ]; then

983 newline

984 gettext \

985 "No 'packages.txt' found to check for mirrored packages. For more results,

986 please run 'tazpkg recharge' once as root before searching."; echo

987 newline

988 fi

989 if [ "$num" = "0" ]; then

990 eval_gettext "No available packages found for: \$PATTERN"; echo

991 newline

992 else

993 footer "$(eval_ngettext \

994 '$num available package found for: $PATTERN' \

995 '$num available packages found for: $PATTERN' $packages)"

996 fi

997 }

998

999 # Install package-list from a flavor

1000 install_flavor()

1001 {

1002 check_root $@

1003

1004 # Get repositories priority list.

1005 look_for_priority

1006

1007 FLAVOR=$1

1008 ARG=$2

1009 mkdir -p $TMP_DIR

1010 [ -f $FLAVOR.flavor ] && cp $FLAVOR.flavor $TMP_DIR

1011 cd $TMP_DIR

1012 if [ -f $FLAVOR.flavor ] || download $FLAVOR.flavor; then

1013 zcat < $FLAVOR.flavor | cpio --quiet -i >/dev/null

1014 while read file; do

1015 for pkg in $(ls -d $INSTALLED/${file%%-*}*); do

1016 [ -f $pkg/receipt ] || continue

1017 EXTRAVERSION=""

1018 . $pkg/receipt

1019 [ "$PACKAGE-$VERSION$EXTRAVERSION" = "$file" ] && break

1020 done

1021 [ "$PACKAGE-$VERSION$EXTRAVERSION" = "$file" ] && continue

1022 cd $CACHE_DIR

1023 download $file.tazpkg

1024 cd $TMP_DIR

1025 tazpkg install $CACHE_DIR/$file.tazpkg --forced

1026 done < $FLAVOR.pkglist

1027 [ -f $FLAVOR.nonfree ] && while read pkg; do

1028 [ -d $INSTALLED/$pkg ] || continue

1029 [ -d $INSTALLED/get-$pkg ] && tazpkg get-install get-$pkg

1030 get-$pkg

1031 done < $FLAVOR.nonfree

1032 [ "$ARG" == "--purge" ] && for pkg in $(ls $INSTALLED); do

1033 [ -f $INSTALLED/$pkg/receipt ] || continue

1034 EXTRAVERSION=""

1035 . $INSTALLED/$pkg/receipt

1036 grep -q ^$PACKAGE-$VERSION$EXTRAVERSION$ $FLAVOR.pkglist && continue

1037 grep -qs ^$PACKAGE$ $FLAVOR.nonfree && continue

1038 tazpkg remove $PACKAGE

1039 done

1040 else

1041 eval_gettext "Can't find flavor \$FLAVOR. Abort."; echo

1042 fi

1043 cd $TOP_DIR

1044 rm -rf $TMP_DIR

1045 }

1046

1047 # Update mirror urls

1048 setup_mirror()

1049 {

1050 # Backup old list.

1051 if [ -f "$1/mirror" ]; then

1052 cp -f $1/mirror $1/mirror.bak

1053 fi

1054 title 'Current mirror(s)'

1055 echo " `cat $1/mirror 2> /dev/null`"

1056 gettext \

1057 "Please enter URL of the new mirror (http, ftp or local path). You must specify

1058 the complete address to the directory of the packages and packages.list file."; echo

1059 newline

1060 gettext "New mirror(s) URL: "

1061 NEW_MIRROR_URL=$2

1062 if [ -n "$NEW_MIRROR_URL" ]; then

1063 echo $NEW_MIRROR_URL

1064 else

1065 read NEW_MIRROR_URL

1066 fi

1067 if [ "$NEW_MIRROR_URL" = "" ]; then

1068 gettext "Nothing has been changed."; echo

1069 else

1070 eval_gettext "Setting mirror(s) to: \$NEW_MIRROR_URL"; echo

1071 rm -f $1/mirror

1072 for i in $NEW_MIRROR_URL; do

1073 echo "$i" >> $1/mirror

1074 done

1075 fi

1076 newline

1077 }

1078

1079 # recursive dependencies scan

1080 dep_scan()

1081 {

1082 for i in $1; do

1083 case " $ALL_DEPS " in

1084 *\ $i\ *) continue;;

1085 esac

1086 ALL_DEPS="$ALL_DEPS $i"

1087 [ -n "$2" ] && echo "$2$i ($(fgrep -A 3 $i $LOCALSTATE/packages.txt \

1088 | tail -1 | sed 's/.*($[^ ]*$.*/\1/'))"

1089 [ -f $i/receipt ] || continue

1090 DEPENDS=""

1091 . $i/receipt

1092 [ -n "$DEPENDS" ] && dep_scan "$DEPENDS" "$2 "

1093 done

1094 }

1095

1096 # recursive reverse dependencies scan

1097 rdep_scan()

1098 {

1099 SEARCH=$1

1100

1101 for i in * ; do

1102 DEPENDS=""

1103 . $i/receipt

1104 echo "$i $(echo $DEPENDS)"

1105 done | busybox awk -v search=$SEARCH '

1106 function show_deps(deps, all_deps, pkg, space)

1107 {

1108 if (all_deps[pkg] == 1) return

1109 all_deps[pkg] = 1

1110 if (space != "") printf "%s %s\n",space,pkg

1111 for (i = 1, n = split(deps[pkg], mydeps, " "); i <= n; i++) {

1112 show_deps(deps, all_deps, mydeps[i],"==" space)

1113 }

1114 }

1115

1116 {

1117 all_deps[$1] = 0

1118 for (i = 2; i <= NF; i++)

1119 deps[$i] = deps[$i] " " $1

1120 }

1121

1122 END {

1123 show_deps(deps, all_deps, search, "")

1124 }

1125 ' | while read spc pkg; do

1126 echo -n $spc | sed 's/=/ /g'

1127 echo -n $pkg

1128 echo -n ' ('

1129 fgrep -A 3 $pkg $LOCALSTATE/packages.txt | tail -1 | \

1130 sed 's/.*($[^ ]*$.*/\1)/'

1131 done

1132 }

1133

1134 # Check for ELF file

1135 is_elf()

1136 {

1137 [ "$(dd if=$1 bs=1 skip=1 count=3 2> /dev/null)" = "ELF" ]

1138 }

1139

1140 # Print shared library dependencies

1141 ldd()

1142 {

1143 LD_TRACE_LOADED_OBJECTS=1 /lib/ld*.so $1 2> /dev/null

1144 }

1145

1146 # search dependencies for files in $TMP_DIR/$file/fs

1147 find_depends()

1148 {

1149 DEFAULT_DEPENDS="glibc-base gcc-lib-base"

1150

1151 [ -n "$TMPLOCALSTATE" ] || TMPLOCALSTATE=$LOCALSTATE

1152 [ -f $TMPLOCALSTATE/files.list.lzma ] || tazpkg recharge > /dev/null

1153 for i in $TMPLOCALSTATE/files.list.lzma \

1154 $TMPLOCALSTATE/undigest/*/files.list.lzma ; do

1155 [ -f $i ] && lzma d $i -so >> $TMP_DIR/files.list

1156 done

1157 find ${1:-$TMP_DIR/$file/fs} -type f | while read chkfile ; do

1158 is_elf $chkfile || continue

1159 case "$chkfile" in

1160 *.o|*.ko|*.ko.gz) continue;;

1161 esac

1162 ldd $chkfile | while read lib rem; do

1163 case "$lib" in

1164 statically|linux-gate.so*|ld-*.so|*/ld-*.so)

1165 continue;;

1166 esac

1167 find ${1:-$TMP_DIR/$file/fs} | grep -q /$lib$ && continue

1168 for dep in $(fgrep $lib files.list | cut -d: -f1); do

1169 case " $DEFAULT_DEPENDS " in

1170 *\ $dep\ *) continue 2;;

1171 esac

1172 grep -qs "^$dep$" $TMP_DIR/depends && continue 2

1173 done

1174 if [ -n "$dep" ]; then

1175 echo "$dep" >> $TMP_DIR/depends

1176 else

1177 grep -qs ^$lib$ $TMP_DIR/unresolved ||

1178 echo "$lib" >> $TMP_DIR/unresolved

1179 fi

1180 done

1181 done

1182 spc=""

1183 sort < $TMP_DIR/depends 2> /dev/null | uniq | while read file; do

1184 echo -n "$spc$file"

1185 spc=" "

1186 done

1187 }

1188

1189 show_unresolved_lib()

1190 {

1191 if [ -s $TMP_DIR/unresolved ]; then

1192 echo -e "BUGS=\"`gettext \"No dependency for\"`" >> $1

1193 sort < $TMP_DIR/unresolved | uniq | while read file; do

1194 eval_gettext "WARNING: unknown dependency for \$lib"; echo

1195 echo -n " $file" >> $1

1196 done

1197 echo "\"" >> $1

1198 fi

1199 }

1200

1201 # convert a .ipk package to .tazpkg

1202 convert_ipk()

1203 {

1204 mkdir -p $TMP_DIR

1205 tar xOzf $PACKAGE_FILE ./control.tar.gz | tar xzf - -C $TMP_DIR

1206 package="$(grep ^Package $TMP_DIR/control | sed 's/.*: //')"

1207 version="$(grep ^Version $TMP_DIR/control | sed 's/.*: //')"

1208 maintainer="$(grep ^Maintainer $TMP_DIR/control | sed 's/.*: //')"

1209 target="$(grep ^Architecture $TMP_DIR/control | sed 's/.*: //')"

1210 descrip="$(grep ^Description $TMP_DIR/control | sed 's/.*: //')"

1211 url="http://openwrt.org/"

1212 case "$target" in

1213 i386|all)

1214 file=$package-$version

1215 mkdir -p $TMP_DIR/$file/fs

1216 tar xOzf $PACKAGE_FILE ./data.tar.gz | \

1217 tar xzf - -C $TMP_DIR/$file/fs

1218 cd $TMP_DIR

1219 cat > $file/receipt <<EOT

1220 # SliTaz package receipt.

1221 # generated by tazpkg from package $(basename $PACKAGE_FILE)

1222 PACKAGE="$package"

1223 VERSION="$version"

1224 CATEGORY="misc"

1225 SHORT_DESC="$descrip"

1226 WEB_SITE="$url"

1227 MAINTAINER="$maintainer"

1228 DEPENDS="$(find_depends)"

1229 EOT

1230 [ -s conffiles ] && cat >> $file/receipt <<EOT

1231 CONFIG_FILES="$(cat conffiles)"

1232 EOT

1233 show_unresolved_lib $file/receipt

1234 while read script func; do

1235 [ -s $script ] && cat >> $file/receipt <<EOT

1236

1237 $func()

1238 {

1239 $(cat $script)

1240 }

1241 EOT

1242 done <<EOT

1243 preinst pre_install

1244 postinst post_install

1245 prerm pre_remove

1246 postrm post_remove

1247 EOT

1248 awk '

1249 {

1250 if (/^ / && show) print substr($0,2);

1251 else show=0;

1252 if (/^Description/) show=1;

1253 }' < $TMP_DIR/control > $file/description.txt

1254 sed -i 's/^\.$//' $file/description.txt

1255 [ -s $file/description.txt ] || rm -f $file/description.txt

1256 tazpkg pack $file

1257 cd $TOP_DIR

1258 mv $TMP_DIR/$file.tazpkg .

1259 ;;

1260 *)

1261 eval_gettext "Invalid target: \$target (expected i386)"; echo

1262 ;;

1263 esac

1264 rm -rf $TMP_DIR

1265 }

1266

1267 # convert a .pkg.tar.gz/.pkg.tar.xz/.apk package to .tazpkg

1268 convert_arch()

1269 {

1270 mkdir -p $TMP_DIR/fs

1271 busybox tar xf $PACKAGE_FILE -C $TMP_DIR/fs

1272 if [ -f $TMP_DIR/fs/.PKGINFO ]; then

1273 cd $TMP_DIR

1274 package="$(grep ^pkgname fs/.PKGINFO | sed 's/.*= //')"

1275 version="$(grep ^pkgver fs/.PKGINFO | sed 's/.*= //')"

1276 descrip="$(grep ^pkgdesc fs/.PKGINFO | sed 's/.*= //')"

1277 url="$(grep ^url fs/.PKGINFO | sed 's/.*= //')"

1278 maintainer="$(grep ^packager fs/.PKGINFO | sed 's/.*= //')"

1279 file=$package-$version

1280 mkdir $file

1281 mv fs $file

1282 cat > $file/receipt <<EOT

1283 # SliTaz package receipt.

1284 # generated by tazpkg from Archlinux package $(basename $PACKAGE_FILE)

1285 PACKAGE="$package"

1286 VERSION="$version"

1287 CATEGORY="misc"

1288 SHORT_DESC="$descrip"

1289 WEB_SITE="$url"

1290 MAINTAINER="$maintainer"

1291 DEPENDS="$(find_depends)"

1292 EOT

1293 show_unresolved_lib $file/receipt

1294 rm -f $file/fs/.[A-Z]*

1295 tazpkg pack $file

1296 mv $file.tazpkg $TOP_DIR

1297 else

1298 eval_gettext "\$PACKAGE_FILE does not look like an Archlinux/Alpine package!"; echo

1299 fi

1300 cd $TOP_DIR

1301 rm -rf $TMP_DIR

1302 }

1303

1304 # get package and version from PACKAGE_FILE

1305 parse_pkgname()

1306 {

1307 package=$(basename ${2:-$PACKAGE_FILE} $1)

1308 IFS='-'

1309 set -- $package

1310 unset IFS

1311 package=$1

1312 version=$2

1313 if [ -z "$version" ]; then

1314 package=${1%%[0-9\.]*}

1315 version=${1#$package}

1316 fi

1317 file="$package-$version"

1318 mkdir $file

1319 }

1320

1321 finish_convert_puppy()

1322 {

1323 rm -f fs/*.specs

1324 mv fs $file

1325 cat > $file/receipt <<EOT

1326 # SliTaz package receipt.

1327 # generated by tazpkg from puppy package $(basename $PACKAGE_FILE)

1328 PACKAGE="$package"

1329 VERSION="$version"

1330 CATEGORY="misc"

1331 SHORT_DESC="$desc"

1332 WEB_SITE="http://puppylinux.org/"

1333 MAINTAINER="nobody@slitaz.org"

1334 DEPENDS="$(find_depends)"

1335 EOT

1336 show_unresolved_lib $file/receipt

1337 for i in install uninstall ; do

1338 [ -f $file/fs/p$i.sh ] && cat >> $file/receipt <<EOM

1339

1340 post_$i()

1341 {

1342 chroot \$1/ sh - << EOT

1343 cd /

1344 $(sed -e 's/\\/\\\\/g' -e 's/\$/\\$/g' < $file/fs/p$i.sh ; rm -f $file/fs/p$i.sh)

1345 EOT

1346 }

1347 EOM

1348 done

1349 sed -i 's/post_uninstall/post_remove/' $file/receipt

1350 tazpkg pack $file

1351 mv $file.tazpkg $TOP_DIR

1352 cd $TOP_DIR

1353 rm -rf $TMP_DIR

1354 }

1355

1356 # convert a .sfs package to .tazpkg

1357 convert_sfs()

1358 {

1359 [ -n "$(which unsquashfs)" ] || tazpkg get-install squashfs

1360 if ! unsquashfs -l $PACKAGE_FILE | grep -q squashfs-root/pet.specs$ ; then

1361 eval_gettext "\$PACKAGE_FILE does not look like a Puppy package!"; echo

1362 return 1

1363 fi

1364 mkdir -p $TMP_DIR

1365 cd $TMP_DIR

1366 parse_pkgname .sfs

1367 unsquashfs $PACKAGE_FILE

1368 mv squashfs-root fs

1369 set -- $(cat fs/pet.specs)

1370 desc="$10"

1371 finish_convert_puppy

1372 }

1373

1374 # convert a .pet package to .tazpkg

1375 convert_pet()

1376 {

1377 mkdir -p $TMP_DIR

1378 cd $TMP_DIR

1379 parse_pkgname .pet

1380 tar xzf $PACKAGE_FILE 2> /dev/null

1381 . $package*/*.specs

1382 desc="$PETMENUDESCR"

1383 mv $package*/ fs

1384 finish_convert_puppy

1385 }

1386

1387 # convert a .sb package to .tazpkg

1388 convert_sb()

1389 {

1390 [ -n "$(which unsquashfs)" ] || tazpkg get-install squashfs

1391 if ! unsquashfs -l $PACKAGE_FILE | grep -q squashfs-root/var/log/removed_scripts ; then

1392 eval_gettext "\$PACKAGE_FILE does not look like a Slax package!"; echo

1393 return 1

1394 fi

1395 mkdir -p $TMP_DIR

1396 cd $TMP_DIR

1397 unsquashfs $PACKAGE_FILE

1398 mv squashfs-root fs

1399 parse_pkgname '' $(cat fs/var/log/packages/* | sed '/PACKAGE NAME:/!d;s/.*: *//')

1400 desc="$(cat fs/var/log/packages/* | sed '/^PACKAGE DESCRIPTION:/,$!d;N;s/.*: //;q')"

1401 cat fs/var/log/packages/* | sed '/^PACKAGE DESCRIPTION:/,/FILE LIST/!d;s/.*://;/^$/d' > $file/description.txt

1402 mv fs $file

1403 cat > $file/receipt <<EOT

1404 # SliTaz package receipt.

1405 # generated by tazpkg from slax package $(basename $PACKAGE_FILE)

1406 PACKAGE="$package"

1407 VERSION="$version"

1408 CATEGORY="misc"

1409 SHORT_DESC="$desc"

1410 WEB_SITE="http://www.slax.org/"

1411 MAINTAINER="nobody@slitaz.org"

1412 DEPENDS="$(find_depends)"

1413 EOT

1414 show_unresolved_lib $file/receipt

1415 [ -f $file/fs/var/log/scripts/$package* ] && cat >> $file/receipt <<EOM

1416

1417 post_install()

1418 {

1419 chroot \$1/ sh - << EOT

1420 cd /

1421 $(cat $file/fs/var/log/scripts/$package* | sed -e 's/\\/\\\\/g' | sed -e 's/\$/\\$/g')

1422 EOT

1423 }

1424 EOM

1425 tazpkg pack $file

1426 mv $file.tazpkg $TOP_DIR

1427 cd $TOP_DIR

1428 rm -rf $TMP_DIR

1429 }

1430

1431 # convert a .tgz package to .tazpkg

1432 convert_tgz()

1433 {

1434 parse_pkgname

1435 mkdir -p $TMP_DIR/$file/fs

1436 tar xzf $PACKAGE_FILE -C $TMP_DIR/$file/fs

1437 cd $TMP_DIR

1438 if [ -d $file/fs/install ]; then

1439 descrip=$(grep ^$package $file/fs/install/slack-desc | \

1440 head -1 | sed 's/.*($.*$).*/\1/')

1441 cat > $file/receipt <<EOT

1442 # SliTaz package receipt.

1443 # generated by tazpkg from slackware package $(basename $PACKAGE_FILE)

1444 PACKAGE="$package"

1445 VERSION="$version"

1446 CATEGORY="misc"

1447 SHORT_DESC="$descrip"

1448 WEB_SITE="http://www.slackware.com/packages/"

1449 MAINTAINER="nobody@slitaz.org"

1450 DEPENDS="$(find_depends)"

1451 EOT

1452 show_unresolved_lib $file/receipt

1453 [ -f $file/fs/install/doinst.sh ] && cat >> $file/receipt <<EOM

1454

1455 post_install()

1456 {

1457 chroot \$1/ sh - << EOT

1458 cd /

1459 $(sed -e 's/\\/\\\\/g' -e 's/\$/\\$/g' < $file/fs/install/doinst.sh)

1460 EOT

1461 }

1462 EOM

1463 grep ^$package $file/fs/install/slack-desc | \

1464 sed "s/^$package://" > $file/description.txt

1465 [ -s $file/description.txt ] || rm -f $file/description.txt

1466 rm -rf $file/fs/install

1467 tazpkg pack $file

1468 mv $file.tazpkg $TOP_DIR

1469 else

1470 eval_gettext "\$PACKAGE_FILE does not look like a Slackware package!"; echo

1471 fi

1472 cd $TOP_DIR

1473 rm -rf $TMP_DIR

1474 }

1475

1476 # convert a .deb package to .tazpkg

1477 convert_deb()

1478 {

1479 mkdir -p $TMP_DIR

1480 dpkg-deb -e $PACKAGE_FILE $TMP_DIR

1481 package=$(grep '^ *Package:' $TMP_DIR/control)

1482 package=$(echo ${package##*:})

1483 version=$(grep '^ *Version:' $TMP_DIR/control)

1484 version=$(echo ${version##*:})

1485 descrip=$(grep '^ *Description:' $TMP_DIR/control)

1486 descrip=$(echo ${descrip##*:})

1487 target="$(grep ^Architecture $TMP_DIR/control | sed 's/.*: //')"

1488 case "$target" in

1489 i386|all)

1490 file="$package-$version"

1491 mkdir -p $TMP_DIR/$file/fs/

1492 dpkg-deb -x $PACKAGE_FILE $TMP_DIR/$file/fs

1493 cd $TMP_DIR

1494 cat > $file/receipt <<EOT

1495 # SliTaz package receipt.

1496 # generated by tazpkg from debian package $(basename $PACKAGE_FILE)

1497 PACKAGE="$package"

1498 VERSION="$version"

1499 CATEGORY="misc"

1500 SHORT_DESC="$descrip"

1501 WEB_SITE="http://packages.debian.org/search?keywords=$package"

1502 MAINTAINER="nobody@slitaz.org"

1503 EOT

1504 LICENSE="$(grep /usr/share/common-licenses/ \

1505 $PACKAGE_FILE $TMP_DIR/$file/fs/usr/share/doc/*/copyright | \

1506 sed 's|.*common-licenses/$[-\.A-Za-z0-9]*$.*|\1|;s|[-\.]$||q')"

1507 [ -n "$LICENSE" ] && echo "LICENSE=\"$LICENSE\"" >> $file/receipt

1508 echo "DEPENDS=\"$(find_depends)\"" >> $file/receipt

1509 [ -s conffiles ] && cat >> $file/receipt <<EOT

1510 CONFIG_FILES="$(cat conffiles)"

1511 EOT

1512 show_unresolved_lib $file/receipt

1513 awk '

1514 {

1515 if (/^ / && show) print substr($0,2);

1516 else show=0;

1517 if (/^Description/) show=1;

1518 }' < $TMP_DIR/control > $file/description.txt

1519 sed -i 's/^\.$//' $file/description.txt

1520 [ -s $file/description.txt ] || rm -f $file/description.txt

1521 tazpkg pack $file

1522 mv $file.tazpkg $TOP_DIR

1523 ;;

1524 *)

1525 eval_gettext "Invalid target: \$target (expected i386)"; echo

1526 ;;

1527 esac

1528 cd $TOP_DIR

1529 rm -rf $TMP_DIR

1530 }

1531

1532 # convert a .rpm package to .tazpkg

1533 convert_rpm()

1534 {

1535 mkdir -p $TMP_DIR

1536 cp $PACKAGE_FILE $TMP_DIR

1537 PACKAGE_FILE=$TMP_DIR/$(basename $PACKAGE_FILE)

1538 rpm -qip $PACKAGE_FILE | awk -v pkg=$(basename $PACKAGE_FILE) '

1539 BEGIN {

1540 goturl=0;

1541 printf "# SliTaz package receipt.\n";

1542 printf "# generated by tazpkg from rpm package %s\n",pkg;

1543 }

1544 {

1545 if (/^Name/) { name=$3; printf "PACKAGE=\"%s\"\n",$3; }

1546 if (/^Version/) printf "VERSION=\"%s-",$3;

1547 if (/^Release/) printf "%s\"\n",$3;

1548 if (/^Summary/) printf "SHORT_DESC=\"%s\"\n",substr($0,15);

1549 if (/^URL/) { goturl=1; printf "WEB_SITE=\"%s\"\n",$3; }

1550 }

1551 END {

1552 if (goturl == 0)

1553 printf "WEB_SITE=\"http://rpmfind.net/linux/rpm2html/search.php?query=%s\"\n",name;

1554 printf "CATEGORY=\"misc\"\n";

1555 printf "MAINTAINER=\"nobody@slitaz.org\"\n";

1556 }

1557 ' > $TMP_DIR/receipt

1558 . $TMP_DIR/receipt

1559 file=$PACKAGE-$VERSION

1560 mkdir -p $TMP_DIR/$file/fs/

1561 mv $TMP_DIR/receipt $TMP_DIR/$file

1562 rpm -qip $PACKAGE_FILE | awk '

1563 BEGIN { show=0 }

1564 {

1565 if (show) print;

1566 if (/^Description/) show=1;

1567 }

1568 ' > $TMP_DIR/$file/description.txt

1569 cd $TMP_DIR/$file/fs/

1570 rpm2cpio $PACKAGE_FILE | cpio -idm --quiet

1571 # rpm2cpio can't extract some new RPMs

1572 if [ $? == 1 ]; then

1573 if [ ! -e $INSTALLED/p7zip-full/receipt ]; then

1574 boldify $(gettext "Unable to extract the RPM using standard tools (rpm2cpio).")

1575 gettext "Do you want to install 'p7zip-full' package" && confirm

1576 if [ $? = 0 ]; then

1577 tazpkg -gi p7zip-full

1578 else

1579 rm -rf $TMP_DIR

1580 exit 1

1581 fi

1582 fi

1583 # we may already have 7z or may have just installed it in the step above

1584 if [ -e $INSTALLED/p7zip-full/receipt ]; then

1585 7z x -so $PACKAGE_FILE | cpio -idm --quiet

1586 fi

1587 fi

1588 cd ../..

1589 echo "DEPENDS=\"$(find_depends)\"" >> $TMP_DIR/$file/receipt

1590 show_unresolved_lib $TMP_DIR/$file/receipt

1591 tazpkg pack $file

1592 mv $file.tazpkg $TOP_DIR

1593 cd $TOP_DIR

1594 rm -rf $TMP_DIR

1595 }

1596

1597 update_desktop_database()

1598 {

1599 if [ -f $1/usr/bin/update-desktop-database ] && [ -n "$updatedesktopdb" ]; then

1600 chroot "$1/" /usr/bin/update-desktop-database /usr/share/applications 2>/dev/null

1601 fi

1602 }

1603

1604 update_mime_database()

1605 {

1606 if [ -f $1/usr/bin/update-mime-database ] && [ -n "$updatemimedb" ]; then

1607 chroot "$1/" /usr/bin/update-mime-database /usr/share/mime

1608 fi

1609 }

1610

1611 update_icon_database()

1612 {

1613 if [ -f $1/usr/bin/gtk-update-icon-cache ] && [ -n "$updateicondb" ]; then

1614 chroot "$1/" /usr/bin/gtk-update-icon-cache /usr/share/icons/hicolor

1615 fi

1616 }

1617

1618 compile_glib_schemas()

1619 {

1620 if [ -f $1/usr/bin/glib-compile-schemas ] && [ -n "$compile_schemas" ]; then

1621 chroot "$1/" /usr/bin/glib-compile-schemas /usr/share/glib-2.0/schemas

1622 fi

1623 }

1624

1625 update_kernel_modules()

1626 {

1627 if [ -f $1/sbin/depmod ] && [ -n "$updatedepmod" ]; then

1628 chroot "$1/" /sbin/depmod -a

1629 fi

1630 }

1631

1632 ###################

1633 # TazPKG commands #

1634 ###################

1635

1636 case "$COMMAND" in

1637 list|-l)

1638 shift

1639 # List all installed packages or a specific category.

1640 if [ "$1" = "blocked" ]; then

1641 title 'Blocked packages'

1642 if [ -s "$BLOCKED" ];then

1643 cat $BLOCKED

1644 else

1645 gettext "No blocked packages found."; echo

1646 fi

1647 newline && exit 0

1648 fi

1649 # Display the list of categories.

1650 if [ "$1" = "cat" -o "$1" = "categories" ]; then

1651 title 'Packages categories'

1652 num=0

1653 for i in $PKGS_CATEGORIES

1654 do

1655 gettext $i; echo

1656 num=$(($num+1))

1657 done

1658 footer "$(eval_ngettext '$num category' '$num categories' $num)"; echo

1659 exit 0

1660 fi

1661 # Check for an asked category.

1662 ASKED_CATEGORY_I18N="$@"

1663 if [ -n "$ASKED_CATEGORY_I18N" ]; then

1664 ASKED_CATEGORY=$(reverse_translate_category "$ASKED_CATEGORY_I18N")

1665 title 'Installed packages of category: $ASKED_CATEGORY_I18N'

1666 for pkg in $INSTALLED/*

1667 do

1668 [ -f $pkg/receipt ] || continue

1669 EXTRAVERSION=""

1670 . $pkg/receipt

1671 if [ "$CATEGORY" == "$ASKED_CATEGORY" ]; then

1672 echo -e "$PACKAGE\033[24G $VERSION$EXTRAVERSION"

1673 packages=$(($packages+1))

1674 fi

1675 done

1676 num="<c 32>$packages</c>"; cat_name="<c 34>$ASKED_CATEGORY_I18N</c>"

1677 footer "$(emsg $(eval_ngettext \

1678 '$num package installed of category $cat_name.' \

1679 '$num packages installed of category $cat_name.' \

1680 $packages))"; echo

1681 else

1682 # By default list all packages and versions.

1683 title 'List of all installed packages'

1684 for pkg in $INSTALLED/*

1685 do

1686 [ -f $pkg/receipt ] || continue

1687 EXTRAVERSION=""

1688 . $pkg/receipt

1689 echo -e "$PACKAGE\033[35G $VERSION$EXTRAVERSION\033[53G $(gettext $CATEGORY)"

1690 packages=$(($packages+1))

1691 done

1692 num="<c 32>$packages</c>"

1693 footer "$(emsg $(eval_ngettext \

1694 '$num package installed.' \

1695 '$num packages installed.' $packages))"

1696 fi ;;

1697 list-mirror|-lm)

1698 # List all available packages on the mirror. Option --diff displays

1699 # last mirrored packages diff (see recharge).

1700 check_for_packages_list

1701 case $2 in

1702 --diff)

1703 if [ -f "$LOCALSTATE/packages.diff" ]; then

1704 title 'Mirrored packages diff'

1705 cat $LOCALSTATE/packages.diff

1706 num=$(wc -l < $LOCALSTATE/packages.diff)

1707 footer "$(eval_ngettext \

1708 '$num new package listed on the mirror.' \

1709 '$num new packages listed on the mirror.' $num)"

1710 else

1711 newline

1712 gettext "Unable to list anything, no packages.diff found."; echo

1713 gettext "Recharge your current list to create a first diff."; echo

1714 newline

1715 fi && exit 0 ;;

1716 --text|--txt|--raw|*)

1717 title 'List of available packages on the mirror'

1718 cat $LOCALSTATE/packages.txt ;;

1719 esac

1720 pkgs=$(wc -l < $LOCALSTATE/packages.list)

1721 num=$(emsg "<c 32>$pkgs</c>")

1722 footer "$(eval_ngettext \

1723 '$num package in the last recharged list.' \

1724 '$num packages in the last recharged list.' $pkgs)"

1725 ;;

1726 list-files|-lf)

1727 # List files installed with the package.

1728 check_for_package_on_cmdline

1729 check_for_receipt

1730 title 'Installed files by: $PACKAGE'

1731 sort < $INSTALLED/$PACKAGE/files.list

1732 files=$(wc -l < $INSTALLED/$PACKAGE/files.list)

1733 num=$(emsg "<c 32>$files</c>")

1734 footer "$(eval_ngettext \

1735 '$num file installed with $PACKAGE' \

1736 '$num files installed with $PACKAGE' $files)"

1737 ;;

1738 info)

1739 # Information about package.

1740 check_for_package_on_cmdline

1741 check_for_receipt

1742 EXTRAVERSION=""

1743 . $INSTALLED/$PACKAGE/receipt

1744 title 'TazPKG information'

1745 # Display localized short description

1746 if [ -e "$LOCALSTATE/packages-desc.$LANG" ]; then

1747 LOCDESC=$(grep -e "^$PACKAGE " $LOCALSTATE/packages-desc.$LANG | cut -d' ' -f2)

1748 [ "x$LOCDESC" != "x" ] && SHORT_DESC="$LOCDESC"

1749 fi

1750 emsg "\

1751 $(gettext 'Package :') $PACKAGE

1752 $(gettext 'Version :') $VERSION$EXTRAVERSION

1753 $(gettext 'Category :') $(gettext $CATEGORY)

1754 $(gettext 'Short desc :') $SHORT_DESC

1755 $(gettext 'Maintainer :') $MAINTAINER"

1756 [ "$LICENSE" ] && emsg "$(gettext 'License :') $LICENSE"

1757 [ "$DEPENDS" ] && emsg "$(gettext 'Depends :') $DEPENDS"

1758 [ "$SUGGESTED" ] && emsg "$(gettext 'Suggested :') $SUGGESTED"

1759 [ "$BUILD_DEPENDS" ] && emsg "$(gettext 'Build deps :') $BUILD_DEPENDS"

1760 [ "$WANTED" ] && emsg "$(gettext 'Wanted src :') $WANTED"

1761 [ "$WEB_SITE" ] && emsg "$(gettext 'Web site :') $WEB_SITE"

1762 footer ;;

1763

1764 desc)

1765 # Display package description.txt if available.

1766 if [ -f "$INSTALLED/$PACKAGE/description.txt" ]; then

1767 title 'Description of: $PACKAGE'

1768 cat $INSTALLED/$PACKAGE/description.txt

1769 footer

1770 else

1771 newline

1772 gettext "Sorry, no description available for this package."; echo

1773 newline

1774 fi ;;

1775

1776 activity|log|-a)

1777 # Show activity log

1778 [ "$nb" ] || nb=18

1779 title 'TazPKG Activity'

1780 IFS=" "

1781 tail -n ${nb} ${LOG} | while read date hour none action none pkg vers none

1782 do

1783 case "$action" in

1784 Installed)

1785 echo "$date $hour : $(colorize 32 $action) $pkg $vers" ;;

1786 Removed)

1787 echo "$date $hour : $(colorize 31 $action) $pkg $vers" ;;

1788 *)

1789 echo "$date $hour : $(boldify $action) $pkg $vers" ;;

1790 esac

1791 done

1792 unset IFS

1793 separator && newline ;;

1794

1795 search|-s)

1796 # Search for a package by pattern or name.

1797 PATTERN="$2"

1798 if [ -z "$PATTERN" ]; then

1799 newline

1800 gettext "Please specify a pattern or package name to search for."; echo

1801 echo "$(gettext 'Example:') 'tazpkg search paint'"

1802 newline

1803 exit 0

1804 fi

1805 title 'Search result for: $PATTERN'

1806 # Default is to search in installed pkgs and the raw list.

1807 case "$3" in

1808 -i|--installed)

1809 search_in_installed_packages ;;

1810 -l|--list)

1811 search_in_packages_list ;;

1812 -m|--mirror)

1813 search_in_packages_txt ;;

1814 *)

1815 search_in_installed_packages

1816 search_in_packages_list ;;

1817 esac ;;

1818

1819 search-file|-sf)

1820 # Search for a file by pattern or name in all files.list.

1821 if [ -z "$2" ]; then

1822 newline

1823 gettext "Please specify a pattern or file name to search for."; echo

1824 echo "$(gettext 'Example:') 'tazpkg search-file libnss'"

1825 newline

1826 exit 0

1827 fi

1828 s_file="$2"

1829 title 'Search result for file $s_file'

1830

1831 if [ "$3" == "--mirror" ]; then

1832

1833 match=0

1834 for i in $LOCALSTATE/files.list.lzma \

1835 $LOCALSTATE/undigest/*/files.list.lzma; do

1836 [ -f $i ] || continue

1837 unlzma -c $i | grep -- ".*:.*$2" | awk '

1838 BEGIN { last="" }

1839 {

1840 pkg=substr($0,0,index($0,":")-1);

1841 file=substr($0,index($0,":")+2);

1842 if (last != pkg) {

1843 last = pkg;

1844 printf("\n%c[1mPackage %s:%c[0m\n",27,pkg,27);

1845 }

1846 printf("%s\n",file);

1847 }'

1848 match=$(($match + `unlzma -c $i | grep -- ".*:.*$2" | wc -l`))

1849 done

1850

1851 else

1852

1853 # Check all pkg files.list in search match which specify the package

1854 # name and the full path to the file(s).

1855 for pkg in $INSTALLED/*

1856 do

1857 if grep -qs "$2" $pkg/files.list; then

1858 . $pkg/receipt

1859 newline

1860 boldify "$(eval_gettext 'Package $PACKAGE:')"

1861 grep "$2" $pkg/files.list

1862 files=`grep $2 $pkg/files.list | wc -l`

1863 match=$(($match+$files))

1864 fi

1865 done

1866

1867 fi

1868 pkg=$2

1869 if [ "$match" = "" ]; then

1870 eval_gettext "0 file found for: \$pkg"; echo

1871 else

1872 num=$(emsg "<c 32>$files</c>")

1873 footer "$(eval_ngettext \

1874 '$num file found for: $pkg' \

1875 '$num files found for: $pkg' $match)"

1876 fi

1877 ;;

1878 search-pkgname)

1879 # Search for a package name

1880 if [ -z "$2" ]; then

1881 newline

1882 gettext "Please specify a pattern or file name to search for."; echo

1883 echo "$(gettext 'Example:') 'tazpkg search-pkgname libnss'"

1884 newline

1885 exit 0

1886 fi

1887 s_pkg="$2"

1888 title 'Search result for package $s_pkg'

1889

1890 # Search for a file on mirror and output only the package name

1891 match=0

1892 for i in $LOCALSTATE/files.list.lzma \

1893 $LOCALSTATE/undigest/*/files.list.lzma; do

1894 [ -f $i ] || continue

1895 unlzma -c $i | grep -- ".*:.*$2" | cut -d: -f1 | uniq | awk '{ print $1 }'

1896 match=$(($match + `unlzma -c $i | grep -- ".*:.*$2" | cut -d: -f1 | uniq | wc -l`))

1897 done

1898 file=$2

1899 if [ "$match" = "0" ]; then

1900 eval_gettext "No file found for: \$file"; echo

1901 newline

1902 else

1903 num=$(emsg "<c 32>$files</c>")

1904 footer "$(eval_ngettext \

1905 '$num package found with file: $file' \

1906 '$num packages found with file: $file' $match)"

1907 fi

1908 ;;

1909 install|-i)

1910 # Install .tazpkg packages.

1911 check_root $@

1912 check_for_package_on_cmdline

1913 check_for_package_file

1914

1915 [ "$root" ] && ROOT="$root" && check_base_dir "$root"

1916 [ "$list" ] && INSTALL_LIST="$list"

1917 if [ "$rootconfig" ]; then

1918 if [ "$root" ]; then

1919 CACHE_DIR=$root/$CACHE_DIR

1920 SAVE_CACHE_DIR=$CACHE_DIR

1921 LOCALSTATE=$root/$LOCALSTATE

1922 else

1923 echo "rootconfig needs --root= option used." >&2

1924 exit 1

1925 fi

1926 fi

1927

1928 # Get repositories priority list.

1929 look_for_priority

1930

1931 # Check if forced install.

1932 if ! [ "$forced" ]; then

1933 check_for_installed_package $ROOT

1934 fi

1935 install_package $ROOT

1936 update_desktop_database $ROOT

1937 update_mime_database $ROOT

1938 update_icon_database $ROOT

1939 compile_glib_schemas $ROOT ;;

1940 install-list|get-install-list)

1941 # Install a set of packages from a list.

1942 check_root $@

1943 if [ -z "$2" ]; then

1944 newline

1945 gettext \

1946 "Please change directory (cd) to the packages repository and specify the

1947 list of packages to install. Example: tazpkg install-list packages.list"

1948 newline && exit 0

1949 fi

1950 # Check if the packages list exist.

1951 list_file=$2

1952 if [ ! -f "$list_file" ]; then

1953 eval_gettext "Unable to find: \$list_file"; echo

1954 exit 0

1955 else

1956 LIST=`cat $2`

1957 fi

1958

1959 # Remember processed list

1960 export INSTALL_LIST="$2"

1961

1962 # Set $COMMAND and install all packages.

1963 if [ "$1" = "get-install-list" ]; then

1964 COMMAND=get-install

1965 else

1966 COMMAND=install

1967 fi

1968 touch $2-processed

1969

1970 # Upgrade tazpkg first. It may handle new features/formats...

1971 # then upgrade essential packages early

1972 for pkg in busybox-pam busybox gcc-lib-base glibc-base \

1973 slitaz-base-files tazpkg ; do

1974 pkg=$(egrep $pkg-[0-9] $INSTALL_LIST)

1975 [ -n "$pkg" ] || continue

1976 eval_gettext "Adding implicit depends \$pkg..."; echo

1977 LIST="$pkg

1978 $LIST"

1979 done

1980

1981 for pkg in $LIST

1982 do

1983 grep -qs ^$pkg$ $2-processed && continue

1984 [ -d "$root/var/lib/tazpkg/installed" ] && continue

1985 tazpkg $COMMAND $pkg --list="$2" "$3" "$4" "$5"

1986 done

1987 rm -f $2-processed ;;

1988 add-flavor)

1989 # Install a set of packages from a flavor.

1990 install_flavor $2 ;;

1991 install-flavor)

1992 # Install a set of packages from a flavor and purge other ones.

1993 install_flavor $2 --purge ;;

1994 set-release)

1995 # Change current release and upgrade packages.

1996 RELEASE=$2

1997 if [ -z "$RELEASE" ]; then

1998 newline

1999 gettext "Please specify the release you want on the command line."; echo

2000 echo "$(gettext 'Example:') tazpkg set-release cooking"

2001 newline

2002 exit 0

2003 fi

2004 rm $LOCALSTATE/mirror

2005 echo "$RELEASE" > /etc/slitaz-release

2006 tazpkg recharge && tazpkg upgrade

2007

2008 # Install missing depends

2009 cd $INSTALLED

2010 for i in * ; do

2011 DEPENDS=""

2012 . $i/receipt

2013 for j in $DEPENDS ; do

2014 [ -d $j ] || tazpkg get-install $j

2015 done

2016 done ;;

2017 remove|-r)

2018 # Remove packages.

2019 check_root $@

2020 check_for_package_on_cmdline

2021

2022 [ "$root" ] && ROOT="$root"

2023 if [ ! -f "$ROOT$INSTALLED/$PACKAGE/receipt" ]; then

2024 newline

2025 eval_gettext "\$PACKAGE is not installed."; echo

2026 exit 0

2027 else

2028 ALTERED=""

2029 THE_PACKAGE=$PACKAGE # altered by receipt

2030 for i in $(cd $ROOT$INSTALLED ; ls); do

2031 [ -f $ROOT$INSTALLED/$i/receipt ] || continue

2032 DEPENDS=""

2033 . $ROOT$INSTALLED/$i/receipt

2034 case " $(echo $DEPENDS) " in

2035 *\ $THE_PACKAGE\ *) ALTERED="$ALTERED $i";;

2036 esac

2037 done

2038 EXTRAVERSION=""

2039 . $ROOT$INSTALLED/$THE_PACKAGE/receipt

2040 fi

2041 newline

2042 if [ -n "$ALTERED" ]; then

2043 eval_gettext "The following packages depend on \$PACKAGE:"; echo

2044 for i in $ALTERED; do

2045 echo " $i"

2046 done

2047 fi

2048 REFRESH=$(cd $ROOT$INSTALLED ; grep -sl ^$PACKAGE$ */modifiers)

2049 if [ -n "$REFRESH" ]; then

2050 eval_gettext "The following packages have been modified by \$PACKAGE:"; echo

2051 for i in $REFRESH; do

2052 echo " ${i%/modifiers}"

2053 done

2054 fi

2055 if [ "$auto" ]; then

2056 answer=0

2057 else

2058 eval_gettext "Remove \$PACKAGE (\$VERSION\$EXTRAVERSION)" && confirm

2059 answer=$?

2060 fi

2061 if [ $answer = 0 ]; then

2062 title 'Removing: $PACKAGE'

2063 # Pre remove commands.

2064 if grep -q ^pre_remove $ROOT$INSTALLED/$PACKAGE/receipt; then

2065 pre_remove $ROOT

2066 fi

2067 action "Removing all files installed..."

2068 if [ -f $ROOT$INSTALLED/$PACKAGE/modifiers ]; then

2069 for file in `cat $ROOT$INSTALLED/$PACKAGE/files.list`

2070 do

2071 for mod in `cat $ROOT$INSTALLED/$PACKAGE/modifiers`

2072 do

2073 [ -f $ROOT$INSTALLED/$mod/files.list ] && [ $(grep "^$(echo $file | grepesc)$" $ROOT$INSTALLED/$mod/files.list | wc -l) -gt 1 ] && continue 2

2074 done

2075 remove_with_path $ROOT$file

2076 done

2077 else

2078 for file in `cat $ROOT$INSTALLED/$PACKAGE/files.list`

2079 do

2080 remove_with_path $ROOT$file

2081 done

2082 fi

2083 status

2084 if grep -q ^post_remove $ROOT$INSTALLED/$PACKAGE/receipt; then

2085 post_remove $ROOT

2086 fi

2087 # Remove package receipt.

2088 action "Removing package receipt..."

2089 rm -rf $ROOT$INSTALLED/$PACKAGE

2090 status

2091 sed -i "/ $PACKAGE-$VERSION$EXTRAVERSION$/d" \

2092 $LOCALSTATE/installed.$SUM 2> /dev/null

2093 # Log this activity

2094 log_pkg Removed

2095 if [ "$ALTERED" ]; then

2096 if [ "$auto" ]; then

2097 answer=0

2098 else

2099 eval_gettext "Remove packages depending on \$PACKAGE" && confirm

2100 answer=$?

2101 fi

2102 if [ $answer = 0 ]; then

2103 for i in $ALTERED; do

2104 if [ -d "$ROOT$INSTALLED/$i" ]; then

2105 tazpkg remove $i $ROOTOPTS

2106 fi

2107 done

2108 fi

2109 fi

2110 if [ "$REFRESH" ]; then

2111 if [ "$auto" ]; then

2112 answer=0

2113 else

2114 eval_gettext "Reinstall packages modified by \$PACKAGE" && confirm

2115 answer=$?

2116 fi

2117 if [ $answer = 0 ]; then

2118 for i in $REFRESH; do

2119 if [ $(wc -l < $ROOT$INSTALLED/$i) -gt 1 ]; then

2120 eval_gettext "Check \$INSTALLED/\$i for reinstallation"; echo

2121 continue

2122 fi

2123 rm -r $ROOT$INSTALLED/$i

2124 tazpkg get-install ${i%/modifiers} $ROOTOPTS --forced

2125 done

2126 fi

2127 fi

2128 else

2129 newline

2130 eval_gettext "Uninstallation of \$PACKAGE cancelled."; echo

2131 fi

2132 newline ;;

2133 extract|-e)

2134 # Extract .tazpkg cpio archive into a directory.

2135 check_for_package_on_cmdline

2136 check_for_package_file

2137 title 'Extracting: $PACKAGE'

2138 # If no directory destination is found on the cmdline

2139 # we create one in the current dir using the package name.

2140 if [ -n "$TARGET_DIR" ]; then

2141 DESTDIR=$TARGET_DIR/$PACKAGE

2142 else

2143 DESTDIR=$PACKAGE

2144 fi

2145 mkdir -p $DESTDIR

2146 action "Copying original package..."

2147 cp $PACKAGE_FILE $DESTDIR

2148 status

2149 cd $DESTDIR

2150 extract_package

2151 [ -e "receipt" ] && footer "$(eval_gettext '$PACKAGE is extracted to: $DESTDIR')"

2152 ;;

2153 recompress)

2154 # Recompress .tazpkg cpio archive with lzma.

2155 check_for_package_on_cmdline

2156 check_for_package_file

2157 title 'Recompressing: $PACKAGE'

2158 mkdir -p $TMP_DIR

2159 action "Copying original package..."

2160 cp $PACKAGE_FILE $TMP_DIR

2161 status

2162 cd $TMP_DIR

2163 extract_package

2164 action "Recompressing the fs..."

2165 find fs | cpio -o -H newc --quiet | lzma e fs.cpio.lzma -si

2166 rm -rf fs

2167 status

2168 action "Creating new package..."

2169 find . -print | cpio -o -H newc --quiet > \

2170 $TOP_DIR/$(basename $PACKAGE_FILE).$$ && mv -f \

2171 $TOP_DIR/$(basename $PACKAGE_FILE).$$ \

2172 $TOP_DIR/$(basename $PACKAGE_FILE)

2173 status

2174 cd $TOP_DIR

2175 rm -rf $TMP_DIR

2176 separator; newline ;;

2177 list-config)

2178 # List configuration files installed.

2179 if [ "$2" = "--box" ]; then

2180 mkdir -p $TMP_DIR && cd $TMP_DIR

2181 FILES="$INSTALLED/*/volatile.cpio.gz"

2182 [ -n "$3" ] && FILES="$INSTALLED/$3/volatile.cpio.gz"

2183 for i in $FILES; do

2184 zcat $i | cpio -idm --quiet > /dev/null

2185 find * -type f 2>/dev/null | while read file; do

2186 if [ ! -e /$file ]; then

2187 echo -en "----------|----|----|`gettext \"File lost\"`"

2188 else

2189 echo -n "$(stat -c "%A|%U|%G|%s|" /$file)"

2190 cmp $file /$file > /dev/null 2>&1 || \

2191 echo -n "$(stat -c "%.16y" /$file)"

2192 fi

2193 echo "|/$file"

2194 done

2195 rm -rf *

2196 done

2197 cd $TOP_DIR

2198 rm -rf $TMP_DIR

2199 else

2200 title 'Configuration files'

2201 for i in $INSTALLED/*/volatile.cpio.gz; do

2202 [ -n "$2" -a "$i" != "$INSTALLED/$2/volatile.cpio.gz" ] && continue

2203 [ -f "$i" ] || continue

2204 zcat $i | cpio -t --quiet

2205 done | sed 's|^|/|' | sort

2206 separator

2207 newline

2208 fi ;;

2209 repack-config)

2210 # Create SliTaz package archive from configuration files.

2211 mkdir -p $TMP_DIR && cd $TMP_DIR

2212 CONFIG_VERSION=1.0

2213 mkdir config-$CONFIG_VERSION

2214 cd config-$CONFIG_VERSION

2215 for i in $INSTALLED/*/volatile.cpio.gz; do

2216 zcat $i | cpio -t --quiet

2217 done > files.list

2218 mkdir fs

2219 cd fs

2220 ( cd / ; cpio -o -H newc --quiet ) < ../files.list | cpio -idm --quiet > /dev/null

2221 mkdir -p etc/tazlito

2222 for i in $INSTALLED/*/receipt; do

2223 EXTRAVERSION=""

2224 . $i

2225 echo "$PACKAGE-$VERSION$EXTRAVERSION"

2226 done > etc/tazlito/config-packages.list

2227 cd ..

2228 echo "etc/tazlito/config-packages.list" >> files.list

2229 pkg_date=$(date +"%x %X")

2230 cat > receipt <<EOT

2231 # SliTaz package receipt.

2232

2233 PACKAGE="config"

2234 VERSION="$CONFIG_VERSION"

2235 CATEGORY="base-system"

2236 SHORT_DESC="$(eval_gettext 'User configuration backup on $pkg_date')"

2237 DEPENDS="$(ls $INSTALLED)"

2238 EOT

2239 cd ..

2240 tazpkg pack config-$CONFIG_VERSION

2241 cp config-$CONFIG_VERSION.tazpkg $TOP_DIR

2242 cd $TOP_DIR

2243 rm -rf $TMP_DIR

2244 ;;

2245 repack)

2246 # Create SliTaz package archive from an installed package.

2247 check_for_package_on_cmdline

2248 check_for_receipt

2249 EXTRAVERSION=""

2250 . $INSTALLED/$PACKAGE/receipt

2251 title 'Repacking: $PACKAGE-$VERSION$EXTRAVERSION.tazpkg'

2252 if grep -qs ^NO_REPACK= $INSTALLED/$PACKAGE/receipt; then

2253 eval_gettext "Can't repack \$PACKAGE"; echo

2254 exit 1

2255 fi

2256 if [ -s $INSTALLED/$PACKAGE/modifiers ]; then

2257 eval_gettext "Can't repack, \$PACKAGE files have been modified by:"; echo

2258 for i in $(cat $INSTALLED/$PACKAGE/modifiers); do

2259 echo " $i"

2260 done

2261 exit 1

2262 fi

2263 MISSING=""

2264 while read i; do

2265 [ -e "$i" ] && continue

2266 [ -L "$i" ] || MISSING="$MISSING\n $i"

2267 done < $INSTALLED/$PACKAGE/files.list

2268 if [ -n "$MISSING" ]; then

2269 gettext "Can't repack, the following files are lost:"

2270 echo -e "$MISSING"

2271 exit 1

2272 fi

2273 mkdir -p $TMP_DIR && cd $TMP_DIR

2274 FILES="fs.cpio.lzma\n"

2275 for i in $(ls $INSTALLED/$PACKAGE) ; do

2276 [ "$i" = "volatile.cpio.gz" ] && continue

2277 [ "$i" = "modifiers" ] && continue

2278 cp $INSTALLED/$PACKAGE/$i . && FILES="$FILES$i\n"

2279 done

2280 ln -s / rootfs

2281 mkdir tmp

2282 sed 's/^/rootfs/' < files.list | cpio -o -H newc --quiet |\

2283 { cd tmp ; cpio -idm --quiet >/dev/null; cd ..; }

2284 mv tmp/rootfs fs

2285 if [ -f $INSTALLED/$PACKAGE/volatile.cpio.gz ]; then

2286 zcat $INSTALLED/$PACKAGE/volatile.cpio.gz | \

2287 { cd fs; cpio -idm --quiet; cd ..; }

2288 fi

2289 if fgrep -q repack_cleanup $INSTALLED/$PACKAGE/receipt; then

2290 . $INSTALLED/$PACKAGE/receipt

2291 repack_cleanup fs

2292 fi

2293 if [ -f $INSTALLED/$PACKAGE/$CHECKSUM ]; then

2294 sed 's, , fs,' < $INSTALLED/$PACKAGE/$CHECKSUM | \

2295 $CHECKSUM -s -c || {

2296 eval_gettext "Can't repack, \$CHECKSUM error."; echo

2297 cd $TOP_DIR

2298 rm -rf $TMP_DIR

2299 exit 1

2300 }

2301 fi

2302 find fs | cpio -o -H newc --quiet | lzma e fs.cpio.lzma -si

2303 echo -e "$FILES" | cpio -o -H newc --quiet > \

2304 $TOP_DIR/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg

2305 cd $TOP_DIR

2306 \rm -R $TMP_DIR

2307 eval_gettext "Package \$PACKAGE repacked successfully."; echo

2308 pkg_size=$(du -sh $PACKAGE-$VERSION$EXTRAVERSION.tazpkg)

2309 eval_gettext "Size: \$pkg_size"; echo

2310 newline ;;

2311 pack)

2312 # Create SliTaz package archive using cpio and lzma.

2313 # TODO: Cook also pack packages, we should share code in libpkg.sh

2314 check_for_package_on_cmdline

2315 cd $PACKAGE

2316 if [ ! -f "receipt" ]; then

2317 gettext "Receipt is missing. Please read the documentation."; echo

2318 exit 0

2319 else

2320 title 'Packing: $PACKAGE'

2321 # Create files.list with redirecting find outpout.

2322 action "Creating the list of files..."

2323 cd fs

2324 find . -type f -print > ../files.list

2325 find . -type l -print >> ../files.list

2326 cd .. && sed -i s/'^.'/''/ files.list

2327 status

2328 action "Creating \$CHECKSUM of files..."

2329 while read file; do

2330 [ -L "fs$file" ] && continue

2331 [ -f "fs$file" ] || continue

2332 case "$file" in

2333 /lib/modules/*/modules.*|*.pyc) continue;;

2334 esac

2335 $CHECKSUM "fs$file" | sed 's/ fs/ /'

2336 done < files.list > $CHECKSUM

2337 status

2338 UNPACKED_SIZE=$(du -chs fs receipt files.list $CHECKSUM \

2339 description.txt 2> /dev/null | awk \

2340 '{ sz=$1 } END { print sz }')

2341 # Build cpio archives.

2342 action "Compressing the fs..."

2343 find fs | cpio -o -H newc --quiet | lzma e fs.cpio.lzma -si

2344 rm -rf fs

2345 status

2346 PACKED_SIZE=$(du -chs fs.cpio.lzma receipt files.list \

2347 $CHECKSUM description.txt 2> /dev/null | awk \

2348 '{ sz=$1 } END { print sz }')

2349 action "Updating receipt sizes..."

2350 sed -i s/^PACKED_SIZE.*$// receipt

2351 sed -i s/^UNPACKED_SIZE.*$// receipt

2352 sed -i "s/^PACKAGE=/PACKED_SIZE=\"$PACKED_SIZE\"\nUNPACKED_SIZE=\"$UNPACKED_SIZE\"\nPACKAGE=/" receipt

2353 status

2354 action "Creating full cpio archive..."

2355 find . -print | cpio -o -H newc --quiet > ../$PACKAGE.tazpkg

2356 status

2357 action "Restoring original package tree..."

2358 unlzma -c fs.cpio.lzma | cpio -idm --quiet

2359 status

2360 rm fs.cpio.lzma && cd ..

2361 footer "$(eval_gettext 'Package $PACKAGE compressed successfully.')"

2362 pkg_size=$(du -sh $PACKAGE.tazpkg)

2363 eval_gettext "Size: \$pkg_size"; echo

2364 newline

2365 fi ;;

2366 recharge)

2367 # Recharge packages.list from a mirror.

2368 #

2369 # WARNING: The mirrors file has all SliTaz mirrors but mirror

2370 # must have only the chosen main mirror.

2371 #

2372 check_root $@

2373

2374 ARG=$2

2375 if [ "$root" ]; then

2376 LOCALSTATE=$root$LOCALSTATE

2377 [ "${2#--}" != "$2" ] && ARG=$3

2378 fi

2379 if [ "$ARG" = main ]; then

2380 repository_to_recharge=$LOCALSTATE

2381 elif [ "$ARG" ]; then

2382 if [ -d "$LOCALSTATE/undigest/$ARG" ]; then

2383 repository_to_recharge=$LOCALSTATE/undigest/$ARG

2384 else

2385 repo="$LOCALSTATE/undigest/$ARG"

2386 eval_gettext "\$repo doesn't exist." >&2

2387 echo >&2

2388 exit 1

2389 fi

2390 else

2391 repository_to_recharge="$LOCALSTATE $LOCALSTATE/undigest/*"

2392 fi

2393 for path in $repository_to_recharge; do

2394 [ -f $path/mirror ] || continue

2395 cd $path

2396

2397 # Quietly check if recharging is needed.

2398 [ -f ID ] && mv ID ID.bak

2399 download_from "$(cat mirror)" ID >/dev/null 2>/dev/null

2400 if [ -f ID ] && fgrep -q `cat ID.bak 2>/dev/null || echo "null"` ID; then

2401 if [ "$path" = "$LOCALSTATE" ]; then

2402 repository_name=Main

2403 else

2404 base_path="$(basename $path)"

2405 repository_name="$(eval_gettext 'Undigest $base_path')"

2406 fi

2407 eval_gettext "\$repository_name is up to date."; echo

2408 rm ID.bak

2409 continue

2410 fi

2411

2412 # Don't let ID be a symlink when using local repository.

2413 if [ -f ID ]; then

2414 mv -f ID ID.bak

2415 cat ID.bak > ID

2416 rm ID.bak

2417 fi

2418

2419 newline

2420 if [ "$path" != "$LOCALSTATE" ]; then

2421 base_path="$(basename $path)"

2422 eval_gettext "Recharging undigest \$base_path:"; echo

2423 fi

2424

2425 if [ -f "packages.list" ]; then

2426 action "Creating backup of the last packages list..."

2427 for i in packages.desc packages.$SUM packages.txt \

2428 packages.list packages.equiv files.list.lzma \

2429 mirrors

2430 do

2431 mv -f $i $i.bak 2>/dev/null

2432 done

2433 status

2434 fi

2435

2436 for i in desc md5 txt list equiv; do

2437 download_from "$(cat mirror)" packages.$i

2438 done

2439 download_from "$(cat mirror)" files.list.lzma

2440 download_from "$(sed 's|packages/.*||' < mirror)" mirrors

2441

2442 if [ -f "packages.list.bak" ]; then

2443 diff -u packages.list.bak packages.list | grep ^+[a-z] > packages.diff

2444 sed -i s/+// packages.diff

2445 title 'Mirrored packages diff'

2446 cat packages.diff

2447 new_pkgs=$(wc -l < packages.diff)

2448 if [ "$new_pkgs" != 0 ]; then

2449 num=$(emsg "<c 32>$new_pkgs</c>")

2450 footer "$(eval_ngettext \

2451 '$num new package on the mirror.' \

2452 '$num new packages on the mirror.' $new_pkgs)"

2453 else

2454 gettext "No new packages on the mirror."; echo

2455 newline

2456 fi

2457 else

2458 footer "$(gettext \

2459 'Last packages.list is ready to use. Note that next time you recharge the

2460 list, a list of differences will be displayed to show new and upgradeable

2461 packages.')"

2462 fi

2463 done ;;

2464 help-up)

2465 # Options available for the command: up

2466 newline; usage_up; newline

2467 exit 1 ;;

2468 up|upgrade)

2469 #

2470 # This is the new way to upgrade packages making 'upgrade' and

2471 # upgradeable out-of-date. This new way is much, much more faster!

2472 # Look into installed packages and get data from receipt, it is fast

2473 # and easy to handle vars after using only md5sum to compare packages

2474 #

2475 for opt in $@

2476 do

2477 case "$opt" in

2478 --recharge|-r)

2479 tazpkg recharge ;;

2480 --install|-i)

2481 install="y" ;;

2482 --check|-c)

2483 install="n" ;;

2484 esac

2485 done

2486 time=$(date +%s)

2487 installed_sum=$LOCALSTATE/installed.$SUM

2488 look_for_priority

2489 for repo in $priority; do

2490 pkg_list=$repo/packages.list

2491 mtime=`find $pkg_list -mtime +7`

2492 if [ "$mtime" ]; then

2493 if [ "$repo" = "$LOCALSTATE" ]; then

2494 repo_name=main

2495 else

2496 repo_name="${repo##*/}"

2497 fi

2498 eval_gettext "\$pkg_list is older than one week... recharging"; echo

2499 tazpkg recharge $repo_name

2500 fi

2501 done

2502 emsg "<n>$(gettext 'Package') $(gettext 'Version') $(gettext 'Status')<->"

2503 cd $INSTALLED

2504 newline > $UP_LIST

2505 blocked_count=0

2506 for pkg in *

2507 do

2508 unset VERSION EXTRAVERSION

2509 . $pkg/receipt

2510 md5=$(fgrep " $PACKAGE-${VERSION}$EXTRAVERSION.tazpkg" \

2511 $installed_sum | awk '{print $1}')

2512 for repo in $priority; do

2513 pkg_desc=$repo/packages.desc

2514 pkg_list=$repo/packages.list

2515 pkg_sum=$repo/packages.$SUM

2516

2517 if ! fgrep -q "$md5 $PACKAGE-" $pkg_sum; then

2518 # Jump to next repository in priority if pkg doesn't exist

2519 # in this one.

2520 grep -q ^$PACKAGE- $pkg_list || continue

2521

2522 emsg -n "$PACKAGE $VERSION"

2523

2524 # Skip pkgs listed in $LOCALSTATE/blocked-packages.list

2525 if $(grep -qs "^$PACKAGE" $BLOCKED); then

2526 blocked_count=$(($blocked_count + 1))

2527 emsg "<c 31> $(gettext 'Blocked')</c>"

2528 break

2529 fi

2530

2531 new=$(grep "^$PACKAGE |" $pkg_desc | awk '{print $3}')

2532

2533 if [ "$VERSION" == "$new" ]; then

2534 emsg "<c 34> $(gettext 'New build')</c>"

2535 else

2536 emsg "<c 32> $(eval_gettext 'New version $new')</c>"

2537 fi

2538 echo "$PACKAGE" >> $UP_LIST

2539 break

2540 fi

2541 done

2542 done

2543 sed -i /^$/d $UP_LIST

2544 upnb=$(wc -l < $UP_LIST)

2545 pkgs=$(ls | wc -l)

2546 time=$(($(date +%s) - $time))

2547 if [ "$upnb" = 0 ]; then

2548 install="n"

2549 gettext "System is up-to-date..."; echo

2550 fi

2551 num=$(emsg "<c 32>$pkgs</c>")

2552 footer "$(eval_ngettext \

2553 '$num installed package scanned in ${time}s' \

2554 '$num installed packages scanned in ${time}s' $pkgs)"

2555 if [ "$upnb" != 0 ]; then

2556 if [ "$blocked_count" -gt 0 ]; then

2557 num=$blocked_count

2558 blocked=$(eval_ngettext '$num blocked' '$num blocked' $num)

2559 else

2560 blocked="$(gettext '0 blocked')"

2561 fi

2562 num=$upnb

2563 boldify "$(eval_ngettext \

2564 'You have $num available upgrade ($blocked)' \

2565 'You have $num available upgrades ($blocked)' $num)"

2566 newline

2567 fi

2568 # Pkgs to upgrade ? Skip, let install them all or ask user

2569 [ "$install" == "n" ] && exit 0

2570 if [ "$upnb" -gt 0 ]; then

2571 if [ "$install" == "y" ]; then

2572 continue

2573 else

2574 gettext "Do you wish to install them now: y/n ? "

2575 read install

2576 fi

2577 case "$install" in

2578 y|Y|yes|YES|Yes)

2579 for pkg in $(cat $UP_LIST)

2580 do

2581 echo 'y' | tazpkg get-install $pkg --forced

2582 done

2583 # List is generated each time and must be cleaned so

2584 # tazpkg-notify doesn't find upgrades anymore.

2585 rm $UP_LIST && touch $UP_LIST ;;

2586 *)

2587 gettext "Leaving without any upgrades installed."; echo

2588 newline

2589 exit 0 ;;

2590 esac

2591 fi

2592 newline ;;

2593 bugs)

2594 # Show known bugs in package(s)

2595 cd $INSTALLED

2596 shift

2597 LIST=$@

2598 [ -n "$LIST" ] || LIST=`ls`

2599 MSG=$(gettext "No known bugs.")

2600 for PACKAGE in $LIST; do

2601 BUGS=""

2602 EXTRAVERSION=""

2603 . $PACKAGE/receipt

2604 if [ -n "$BUGS" ]; then

2605 MSG=$(gettext "Bug list completed")

2606 newline

2607 eval_gettext "Bugs in package \$PACKAGE version \$VERSION\$EXTRAVERSION:"; echo

2608 cat <<EOT

2609 $BUGS

2610 EOT

2611 fi

2612 done

2613 echo "$MSG" ;;

2614 check)

2615 # Check installed packages set.

2616 check_root $@

2617

2618 # Get repositories priority list.

2619 look_for_priority

2620

2621 cd $INSTALLED

2622 for PACKAGE in `ls`; do

2623 if [ ! -f $PACKAGE/receipt ]; then

2624 eval_gettext "The package \$PACKAGE installation has not completed"; echo

2625 continue

2626 fi

2627 DEPENDS=""

2628 EXTRAVERSION=""

2629 . $PACKAGE/receipt

2630 if [ -s $PACKAGE/modifiers ]; then

2631 eval_gettext \

2632 "The package \$PACKAGE-\$VERSION\$EXTRAVERSION has been modified by:"; echo

2633 for i in $(cat $PACKAGE/modifiers); do

2634 echo " $i"

2635 done

2636 fi

2637 MSG="$(eval_gettext 'Files lost from $PACKAGE-$VERSION$EXTRAVERSION:')\n"

2638 while read file; do

2639 [ -e "$file" ] && continue

2640 if [ -L "$file" ]; then

2641 MSG="$MSG $(gettext 'target of symlink')"

2642 fi

2643 echo -e "$MSG $file"

2644 MSG=""

2645 done < $PACKAGE/files.list

2646 MSG="$(eval_gettext 'Missing dependencies for $PACKAGE-$VERSION$EXTRAVERSION:')\n"

2647 for i in $DEPENDS; do

2648 [ -d $i ] && continue

2649 [ -d $(equivalent_pkg $i) ] && continue

2650 echo -e "$MSG $i"

2651 MSG=""

2652 done

2653 MSG="$(eval_gettext 'Dependencies loop between $PACKAGE and:')\n"

2654 ALL_DEPS=""

2655 check_for_deps_loop $PACKAGE $DEPENDS

2656 done

2657 gettext "Looking for known bugs..."; echo

2658 tazpkg bugs

2659 if [ "$PACKAGE_FILE" = "--full" ]; then

2660 for file in */$CHECKSUM; do

2661 CONFIG_FILES=""

2662 . $(dirname "$file")/receipt

2663 [ -s "$file" ] || continue

2664 while read md5 f; do

2665 [ -f $f ] || continue

2666 for i in $CONFIG_FILES; do

2667 case "$f" in

2668 $i|$i/*) continue 2;;

2669 esac

2670 done

2671 echo "$md5 $f"

2672 done < "$file" | $CHECKSUM -c - 2> /dev/null | \

2673 grep -v OK$ | sed 's/FAILED$/$CHECKSUM MISMATCH/'

2674 done

2675 FILES=" "

2676 for file in $(cat */files.list); do

2677 [ -d "$file" ] && continue

2678 case "$FILES" in *\ $file\ *) continue;; esac

2679 [ $(grep "^$(echo $file | grepesc)$" */files.list 2> /dev/null | \

2680 wc -l) -gt 1 ] || continue

2681 FILES="$FILES$file "

2682 eval_gettext "The following packages provide \$file:"; echo

2683 grep -l "^$(echo $file | grepesc)$" */files.list | while read f

2684 do

2685 pkg=${f%/files.list}

2686 if [ -f $pkg/modifiers ]; then

2687 pkg_list="$(cat $pkg/modifiers)"

2688 overriders=$(eval_gettext '(overridden by $pkg_list)')

2689 else

2690 overriders=''

2691 fi

2692 echo -n " $pkg $overriders"

2693 newline

2694 done

2695 done

2696 MSG="$(gettext 'No package has installed the following files:')\n"

2697 find /etc /bin /sbin /lib /usr /var/www \

2698 -not -type d 2> /dev/null | while read file; do

2699 case "$file" in *\[*) continue;; esac

2700 grep -q "^$(echo $file | grepesc)$" */files.list && continue

2701 echo -e "$MSG $file"

2702 MSG=""

2703 done

2704 fi

2705 gettext "Check completed."; echo ;;

2706 block)

2707 # Add a pkg name to the list of blocked packages.

2708 check_root $@

2709 check_for_package_on_cmdline

2710 newline

2711 if grep -qs "^$PACKAGE" $BLOCKED; then

2712 eval_gettext "\$PACKAGE is already in the blocked packages list."; echo

2713 newline

2714 exit 0

2715 else

2716 action "Add \$PACKAGE to: \$BLOCKED..."

2717 echo $PACKAGE >> $BLOCKED

2718 status

2719 # Log this activity

2720 . $INSTALLED/$PACKAGE/receipt

2721 log_pkg Blocked

2722 fi

2723 newline ;;

2724 unblock)

2725 # Remove a pkg name from the list of blocked packages.

2726 check_root $@

2727 check_for_package_on_cmdline

2728 newline

2729 if grep -qs "^$PACKAGE" $BLOCKED; then

2730 action "Removing \$PACKAGE from: \$BLOCKED..."

2731 sed -i s/$PACKAGE/''/ $BLOCKED

2732 sed -i '/^$/d' $BLOCKED

2733 status

2734 # Log this activity

2735 . $INSTALLED/$PACKAGE/receipt

2736 log_pkg Unblocked

2737 else

2738 eval_gettext "\$PACKAGE is not in the blocked packages list."; echo

2739 newline

2740 exit 0

2741 fi

2742 newline ;;

2743 get)

2744 # Download a package with wget.

2745 check_root $@

2746 check_for_package_on_cmdline

2747 check_for_packages_list

2748

2749 [ "$root" ] && ROOT="$root" && check_base_dir "$root"

2750 if [ "$rootconfig" ]; then

2751 if [ "$root" ]; then

2752 CACHE_DIR=$root/$CACHE_DIR

2753 SAVE_CACHE_DIR=$CACHE_DIR

2754 LOCALSTATE=$root/$LOCALSTATE

2755 else

2756 gettext "rootconfig needs --root= option used." >&2

2757 echo >&2

2758 exit 1

2759 fi

2760 fi

2761

2762 # Get repositories priority list.

2763 look_for_priority

2764

2765 CURRENT_DIR=$PWD

2766 check_for_package_in_list

2767 cd $CACHE_DIR

2768 if [ -f "$PACKAGE.tazpkg" ]; then

2769 eval_gettext "\$PACKAGE already in the cache"; echo

2770 # Check package download was finished

2771 tail -c 2k $PACKAGE.tazpkg | fgrep -q 00000000TRAILER || {

2772 eval_gettext "Continuing \$PACKAGE download"; echo

2773 download $PACKAGE.tazpkg

2774 }

2775 if [ "$($CHECKSUM $PACKAGE.tazpkg)" != "$(fgrep " $PACKAGE.tazpkg" $rep/packages.$SUM)" ]; then

2776 rm -f $PACKAGE.tazpkg

2777 download $PACKAGE.tazpkg

2778 fi

2779 else

2780 download $PACKAGE.tazpkg

2781 fi

2782 PACKAGE_FILE=$CACHE_DIR/$PACKAGE.tazpkg

2783 cp -a $PACKAGE_FILE $CURRENT_DIR ;;

2784

2785 get-install|-gi)

2786 # Download and install a package.

2787 check_root $@

2788 check_for_package_on_cmdline

2789 check_for_packages_list

2790

2791 DO_CHECK=""

2792 [ "$forced" ] && DO_CHECK=no

2793 [ "$root" ] && ROOT="$root" && check_base_dir "$root"

2794 [ "$list" ] && INSTALL_LIST="$list"

2795 if [ "$rootconfig" ]; then

2796 if [ "$root" ]; then

2797 CACHE_DIR=$root/$CACHE_DIR

2798 SAVE_CACHE_DIR=$CACHE_DIR

2799 LOCALSTATE=$root/$LOCALSTATE

2800 else

2801 gettext "rootconfig needs --root= option used." >&2

2802 echo >&2

2803 exit 1

2804 fi

2805 fi

2806

2807 # Get repositories priority list.

2808 look_for_priority

2809

2810 AUTOEXEC="no"

2811 if ! check_for_package_in_list check; then

2812 CACHE_DIR="${CACHE_DIR%/*}/get"

2813 [ -d "$CACHE_DIR" ] || mkdir -p $CACHE_DIR

2814 if download_get_script $PACKAGE /tmp/$PACKAGE.$$ ; then

2815 install_package_from_get_script /tmp/$PACKAGE.$$ $ROOT

2816 exit 0

2817 else

2818 PACKAGE=get-$PACKAGE

2819 AUTOEXEC=$PACKAGE

2820 check_for_package_in_list

2821 if [ -n "$(get_installed_package_pathname $PACKAGE $ROOT)" ]; then

2822 $AUTOEXEC $ROOT

2823 exit 0

2824 fi

2825 fi

2826 fi

2827 # Check if forced install.

2828 if ! [ "$forced" ]; then

2829 check_for_installed_package $ROOT

2830 fi

2831 cd $CACHE_DIR

2832 if [ -f "$PACKAGE.tazpkg" ]; then

2833 eval_gettext "\$PACKAGE already in the cache: \$CACHE_DIR"; echo

2834 # Check package download was finished

2835 tail -c 2k $PACKAGE.tazpkg | fgrep -q 00000000TRAILER || {

2836 eval_gettext "Continuing \$PACKAGE download"; echo

2837 download $PACKAGE.tazpkg

2838 }

2839 if [ "$($CHECKSUM $PACKAGE.tazpkg)" != "$(fgrep " $PACKAGE.tazpkg" $rep/packages.$SUM)" ]; then

2840 rm -f $PACKAGE.tazpkg

2841 download $PACKAGE.tazpkg

2842 fi

2843 else

2844 newline

2845 download $PACKAGE.tazpkg

2846 fi

2847 PACKAGE_FILE=$CACHE_DIR/$PACKAGE.tazpkg

2848 [ "$rootconfig" ] && LOCALSTATE=${LOCALSTATE#$root}

2849 install_package $ROOT

2850 [ "$AUTOEXEC" != "no" ] && $PACKAGE $ROOT

2851 update_desktop_database $ROOT

2852 update_mime_database $ROOT ;;

2853

2854 clean-cache|-cc)

2855 # Remove all downloaded packages.

2856 check_root $@

2857 files=$(find $CACHE_DIR -name *.tazpkg | wc -l)

2858 title 'Path: $CACHE_DIR'

2859 action "Cleaning cache directory..."

2860 rm -rf $CACHE_DIR/*

2861 status

2862 num=$(colorize 32 "$files")

2863 if [ "$files" == 0 ]; then

2864 footer "$(eval_gettext '$num file removed from cache.')"

2865 else

2866 footer "$(eval_gettext '$num files removed from cache.')"

2867 fi ;;

2868

2869 list-undigest)

2870 # list undigest URLs.

2871 if [ "$2" = "--box" ]; then

2872 for i in $LOCALSTATE/undigest/*/mirror; do

2873 [ -f $i ] || continue

2874 echo "$(basename $(dirname $i))|$(cat $i)"

2875 done

2876 else

2877 title 'Current undigest(s)'

2878 for i in $LOCALSTATE/undigest/*/mirror; do

2879 if [ ! -f $i ]; then

2880 gettext "No undigest mirror found."; echo

2881 exit 1

2882 fi

2883 echo "$(basename $(dirname $i)) $(cat $i)"

2884 done

2885 newline

2886 fi ;;

2887 remove-undigest)

2888 # remove undigest URL.

2889 check_root $@

2890 undigest="$2"

2891 if [ -d $LOCALSTATE/undigest/$2 ]; then

2892 eval_gettext "Remove \$undigest undigest" && confirm

2893 if [ $? = 0 ]; then

2894 action "Removing \$undigest undigest..."

2895 rm -rf $LOCALSTATE/undigest/$2

2896 status

2897 rmdir $LOCALSTATE/undigest 2> /dev/null

2898 fi

2899 else

2900 eval_gettext "Undigest \$undigest not found"; echo

2901 fi ;;

2902 add-undigest|setup-undigest)

2903 # Add undigest URL.

2904 check_root $@

2905 undigest=$2

2906 [ -d $LOCALSTATE/undigest ] || mkdir $LOCALSTATE/undigest

2907 if [ -z "$undigest" ]; then

2908 i=1

2909 while [ -d $LOCALSTATE/undigest/$i ]; do

2910 i=$(($i+1))

2911 done

2912 undigest=$i

2913 fi

2914 if [ ! -d $LOCALSTATE/undigest/$undigest ]; then

2915 eval_gettext "Creating new undigest \$undigest."; echo

2916 mkdir $LOCALSTATE/undigest/$undigest

2917 fi

2918 setup_mirror $LOCALSTATE/undigest/$undigest $3 ;;

2919 setup-mirror|-sm)

2920 # Change mirror URL.

2921 check_root $@

2922 setup_mirror $LOCALSTATE $2 ;;

2923 reconfigure)

2924 # Replay post_install from receipt

2925 check_for_package_on_cmdline

2926 check_root $@

2927 ROOT=""

2928 while [ -n "$3" ]; do

2929 case "$3" in

2930 --root=*)

2931 ROOT="${3#--root=}/" ;;

2932 *) shift 2

2933 u_opt="$*"

2934 echo -e "\n$(gettext 'Unknown option $u_opt.')\n" >&2

2935 exit 1 ;;

2936 esac

2937 shift

2938 done

2939 if [ -d "$ROOT$INSTALLED/$PACKAGE" ]; then

2940 check_for_receipt $ROOT

2941 # Check for post_install

2942 if grep -q ^post_install $ROOT$INSTALLED/$PACKAGE/receipt; then

2943 . $ROOT$INSTALLED/$PACKAGE/receipt

2944 post_install $ROOT

2945 # Log this activity

2946 [ -n "$ROOT" ] || log_pkg Reconfigured

2947 else

2948 newline

2949 eval_gettext "Nothing to do for \$PACKAGE."; echo

2950 fi

2951 else

2952 newline

2953 eval_gettext "Package \$PACKAGE is not installed."; echo

2954 gettext "Install package with 'tazpkg install' or 'tazpkg get-install'"; echo

2955 newline

2956 fi ;;

2957 shell)

2958 # TazPKG SHell

2959 if test $(id -u) = 0 ; then

2960 PROMPT="\\033[1;33mtazpkg\\033[0;39m# "

2961 else

2962 PROMPT="\\033[1;33mtazpkg\\033[0;39m> "

2963 fi

2964 if [ ! "$2" = "--noheader" ]; then

2965 clear

2966 title 'TazPKG SHell.'

2967 gettext "Type 'usage' to list all available commands or 'quit' or 'q' to exit."; echo

2968 newline

2969 fi

2970 while true

2971 do

2972 echo -en "$PROMPT"; read cmd

2973 case $cmd in

2974 q|quit)

2975 break ;;

2976 shell)

2977 gettext "You are already running a TazPKG SHell."; echo ;;

2978 su)

2979 su -c 'exec tazpkg shell --noheader' && break ;;

2980 "")

2981 continue ;;

2982 *)

2983 tazpkg $cmd ;;

2984 esac

2985 done ;;

2986 depends)

2987 # Display dependencies tree

2988 cd $INSTALLED

2989 ALL_DEPS=""

2990 if [ -f $2/receipt ]; then

2991 dep_scan $2 ""

2992 fi ;;

2993 rdepends)

2994 # Display reverse dependencies tree

2995 cd $INSTALLED

2996 ALL_DEPS=""

2997 if [ -f $2/receipt ]; then

2998 rdep_scan $2

2999 fi ;;

3000 convert|-c)

3001 # convert misc package format to .tazpkg

3002 check_for_package_file

3003 [ -n "$TARGET_DIR" -a -s "$TARGET_DIR/files.list.lzma" ] &&

3004 TMPLOCALSTATE="$TARGET_DIR"

3005 if [ "$(dd if=$PACKAGE_FILE bs=8 count=1 skip=1 2> /dev/null)" \

3006 == "debian-b" ]; then

3007 convert_deb

3008 else

3009 case "$PACKAGE_FILE" in

3010 *.deb|*.udeb)

3011 convert_deb;;

3012 *.rpm)

3013 convert_rpm;;

3014 *.sb)

3015 convert_sb;;

3016 *.sfs)

3017 convert_sfs;;

3018 *.pet)

3019 convert_pet;;

3020 *.tgz)

3021 convert_tgz;;

3022 *.apk|*.pkg.tar.gz|*.pkg.tar.xz)

3023 convert_arch;;

3024 *.ipk|*.opk)

3025 convert_ipk;;

3026 *)

3027 gettext "Unsupported format"; echo ;;

3028 esac

3029 fi ;;

3030 link)

3031 # link a package from another slitaz installation

3032 PACKAGE=$2

3033 if [ ! -d "$TARGET_DIR" -o \

3034 ! -d "$TARGET_DIR$INSTALLED/$PACKAGE" ]; then

3035 gettext "

3036 usage: tazpkg link package_name slitaz_root

3037 example: 'tazpkg link openoffice /mnt' will use less than 100k in

3038 your running system ram.

3039 "

3040 exit 1

3041 fi

3042 if [ -e "$INSTALLED/$PACKAGE" ]; then

3043 eval_gettext "\$PACKAGE is already installed."; echo

3044 exit 1

3045 fi

3046 ln -s $TARGET_DIR$INSTALLED/$PACKAGE $INSTALLED

3047 DEPENDS="$(. $INSTALLED/$PACKAGE/receipt ; echo $DEPENDS)"

3048 MISSING=""

3049 for i in $DEPENDS; do

3050 [ -e $INSTALLED/$i ] && continue

3051 MISSING="$MISSING$i "

3052 eval_gettext "Missing: \$i"; echo

3053 done

3054 if [ -n "$MISSING" ]; then

3055 newline

3056 gettext "Link all missing dependencies" && confirm

3057 answer=$?

3058 newline

3059 if [ $answer = 0 ]; then

3060 for i in $MISSING; do

3061 tazpkg link $i $TARGET_DIR

3062 done

3063 else

3064 newline

3065 eval_gettext "Leaving dependencies unresolved for: \$PACKAGE"; echo

3066 gettext "The package is installed but probably will not work."; echo

3067 newline

3068 fi

3069 fi

3070 . $INSTALLED/$PACKAGE/receipt

3071 if grep -q ^pre_install $INSTALLED/$PACKAGE/receipt; then

3072 pre_install

3073 fi

3074 while read path; do

3075 [ -e $path ] && continue

3076 while true; do

3077 dir=$(dirname $path)

3078 [ -e $dir ] && break

3079 path=$dir

3080 done

3081 ln -s $TARGET_DIR$path $dir

3082 done < $INSTALLED/$PACKAGE/files.list

3083 if grep -q ^post_install $INSTALLED/$PACKAGE/receipt; then

3084 post_install

3085 fi ;;

3086 usage|*)

3087 # Print a short help or give usage for an unknown or empty command.

3088 usage ;;

3089 esac

3090

3091 exit 0

SliTaz Repositories

tazpkg view tazpkg @ rev 673