tazpkg: 85863536aef6 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 [ "$(busybox 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 saved=$PACKAGE

743 unset_receipt

744 PACKAGE=$saved

745

746 set -e

747 . $SCRIPT

748 set +e

749

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

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

752 # SliTaz package receipt.

753

754 PACKAGE="$PACKAGE"

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

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

757 WEB_SITE="$WEB_SITE"

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

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

760 EOT

761 for i in LICENSE TARBALL WGET_URL CONFIG_FILES SUGGESTED \

762 PROVIDE DEPENDS HOST_ARCH TAGS ; do

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

764 done >> $PACKAGE-$VERSION/receipt

765 fi

766

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

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

769 case " $DEPENDS " in

770 *\ $i\ *) continue;;

771 esac

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

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

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

775 done

776

777 tazpkg pack $PACKAGE-$VERSION

778

779 # Clean to save RAM memory before installation

780 rm -rf $PACKAGE-$VERSION

781

782 # Install pseudo package

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

784 mv $PACKAGE-$VERSION.tazpkg $CACHE_DIR

785

786 # Clean

787 cd $TOP_DIR

788 rm -rf $TMP_DIR

789 }

790

791 # Check for loop in deps tree.

792 check_for_deps_loop()

793 {

794 local list

795 local pkg

796 local deps

797 pkg=$1

798 shift

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

800 list=""

801 # Filter out already processed deps

802 for i in $@; do

803 case " $ALL_DEPS" in

804 *\ $i\ *);;

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

806 esac

807 done

808 ALL_DEPS="$ALL_DEPS$list "

809 for i in $list; do

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

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

812 case " $deps " in

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

814 *) check_for_deps_loop $pkg $deps;;

815 esac

816 done

817 }

818

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

820 check_for_deps()

821 {

822 local saved;

823 saved=$PACKAGE

824 mkdir -p $TMP_DIR

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

826 . $TMP_DIR/receipt

827 PACKAGE=$saved

828 rm -rf $TMP_DIR

829

830 num=0

831 for pkgorg in $DEPENDS

832 do

833 i=$(equivalent_pkg $pkgorg $1)

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

835 MISSING_PACKAGE=$i

836 num=$(($num+1))

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

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

839 fi

840 done

841

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

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

844 for pkgorg in $DEPENDS

845 do

846 i=$(equivalent_pkg $pkgorg $1)

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

848 MISSING_PACKAGE=$i

849 eval_gettext "Missing: \$MISSING_PACKAGE"; echo

850 fi

851 done

852 separator

853 eval_ngettext \

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

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

856 fi

857 }

858

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

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

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

862 install_deps()

863 {

864 local root

865 root=""

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

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

868 answer=0

869 else

870 newline

871 gettext "Install all missing dependencies" && confirm

872 answer=$?

873 newline

874 fi

875 if [ $answer = 0 ]; then

876 for pkgorg in $DEPENDS

877 do

878 pkg=$(equivalent_pkg $pkgorg $1)

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

880 local list

881 list="$INSTALL_LIST"

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

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

884 # the TAZPKG_BASENAME in the local packages.list.

885 found=0

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

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

888 mkdir $TMP_DIR

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

890 [ -f $i ] || continue

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

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

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

894 then

895 found=1

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

897 break

898 fi

899 done

900 rm -rf $TMP_DIR

901 fi

902 # Install deps from the mirror.

903 if [ $found -eq 0 ]; then

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

905 tazpkg recharge

906 fi

907 tazpkg get-install $pkg $root

908 fi

909 fi

910 done

911 else

912 newline

913 eval_gettext \

914 "Leaving dependencies for \$PACKAGE unresolved.

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

916 newline

917 fi

918 }

919

920 # Search pattern in installed packages.

921 search_in_installed_packages()

922 {

923 gettext "Installed packages"; echo

924 separator

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

926 num=0

927 for pkg in $list

928 do

929 EXTRAVERSION=""

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

931 . $INSTALLED/$pkg/receipt

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

933 num=$(($num+1))

934 done

935 # Set correct ending messages.

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

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

938 newline

939 else

940 footer "$(eval_ngettext \

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

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

943 fi

944 }

945

946 # Search in packages.list for available pkgs.

947 search_in_packages_list()

948 {

949 gettext "Available packages name-version"; echo

950 separator

951 num=0

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

953 grep -is "$PATTERN" $i

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

955 done

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

957 newline

958 gettext \

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

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

961 newline

962 fi

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

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

965 newline

966 else

967 footer "$(eval_ngettext \

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

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

970 fi

971 }

972

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

974 # info than --list or default.

975 search_in_packages_txt()

976 {

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

978 separator

979 num=0

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

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

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

983 done

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

985 newline

986 gettext \

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

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

989 newline

990 fi

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

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

993 newline

994 else

995 footer "$(eval_ngettext \

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

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

998 fi

999 }

1000

1001 # Install package-list from a flavor

1002 install_flavor()

1003 {

1004 check_root $@

1005

1006 # Get repositories priority list.

1007 look_for_priority

1008

1009 FLAVOR=$1

1010 ARG=$2

1011 mkdir -p $TMP_DIR

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

1013 cd $TMP_DIR

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

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

1016 while read file; do

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

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

1019 EXTRAVERSION=""

1020 . $pkg/receipt

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

1022 done

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

1024 cd $CACHE_DIR

1025 download $file.tazpkg

1026 cd $TMP_DIR

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

1028 done < $FLAVOR.pkglist

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

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

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

1032 get-$pkg

1033 done < $FLAVOR.nonfree

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

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

1036 EXTRAVERSION=""

1037 . $INSTALLED/$pkg/receipt

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

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

1040 tazpkg remove $PACKAGE

1041 done

1042 else

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

1044 fi

1045 cd $TOP_DIR

1046 rm -rf $TMP_DIR

1047 }

1048

1049 # Update mirror urls

1050 setup_mirror()

1051 {

1052 # Backup old list.

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

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

1055 fi

1056 title 'Current mirror(s)'

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

1058 gettext \

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

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

1061 newline

1062 gettext "New mirror(s) URL: "

1063 NEW_MIRROR_URL=$2

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

1065 echo $NEW_MIRROR_URL

1066 else

1067 read NEW_MIRROR_URL

1068 fi

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

1070 gettext "Nothing has been changed."; echo

1071 else

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

1073 rm -f $1/mirror

1074 for i in $NEW_MIRROR_URL; do

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

1076 done

1077 fi

1078 newline

1079 }

1080

1081 # recursive dependencies scan

1082 dep_scan()

1083 {

1084 for i in $1; do

1085 case " $ALL_DEPS " in

1086 *\ $i\ *) continue;;

1087 esac

1088 ALL_DEPS="$ALL_DEPS $i"

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

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

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

1092 DEPENDS=""

1093 . $i/receipt

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

1095 done

1096 }

1097

1098 # recursive reverse dependencies scan

1099 rdep_scan()

1100 {

1101 SEARCH=$1

1102

1103 for i in * ; do

1104 DEPENDS=""

1105 . $i/receipt

1106 echo "$i $(echo $DEPENDS)"

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

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

1109 {

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

1111 all_deps[pkg] = 1

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

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

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

1115 }

1116 }

1117

1118 {

1119 all_deps[$1] = 0

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

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

1122 }

1123

1124 END {

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

1126 }

1127 ' | while read spc pkg; do

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

1129 echo -n $pkg

1130 echo -n ' ('

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

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

1133 done

1134 }

1135

1136 # Check for ELF file

1137 is_elf()

1138 {

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

1140 }

1141

1142 # Print shared library dependencies

1143 ldd()

1144 {

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

1146 }

1147

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

1149 find_depends()

1150 {

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

1152

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

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

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

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

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

1158 done

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

1160 is_elf $chkfile || continue

1161 case "$chkfile" in

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

1163 esac

1164 ldd $chkfile | while read lib rem; do

1165 case "$lib" in

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

1167 continue;;

1168 esac

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

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

1171 case " $DEFAULT_DEPENDS " in

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

1173 esac

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

1175 done

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

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

1178 else

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

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

1181 fi

1182 done

1183 done

1184 spc=""

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

1186 echo -n "$spc$file"

1187 spc=" "

1188 done

1189 }

1190

1191 show_unresolved_lib()

1192 {

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

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

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

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

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

1198 done

1199 echo "\"" >> $1

1200 fi

1201 }

1202

1203 # convert a .ipk package to .tazpkg

1204 convert_ipk()

1205 {

1206 mkdir -p $TMP_DIR

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

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

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

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

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

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

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

1214 case "$target" in

1215 i386|all)

1216 file=$package-$version

1217 mkdir -p $TMP_DIR/$file/fs

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

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

1220 cd $TMP_DIR

1221 cat > $file/receipt <<EOT

1222 # SliTaz package receipt.

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

1224 PACKAGE="$package"

1225 VERSION="$version"

1226 CATEGORY="misc"

1227 SHORT_DESC="$descrip"

1228 WEB_SITE="$url"

1229 MAINTAINER="$maintainer"

1230 DEPENDS="$(find_depends)"

1231 EOT

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

1233 CONFIG_FILES="$(cat conffiles)"

1234 EOT

1235 show_unresolved_lib $file/receipt

1236 while read script func; do

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

1238

1239 $func()

1240 {

1241 $(cat $script)

1242 }

1243 EOT

1244 done <<EOT

1245 preinst pre_install

1246 postinst post_install

1247 prerm pre_remove

1248 postrm post_remove

1249 EOT

1250 awk '

1251 {

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

1253 else show=0;

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

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

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

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

1258 tazpkg pack $file

1259 cd $TOP_DIR

1260 mv $TMP_DIR/$file.tazpkg .

1261 ;;

1262 *)

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

1264 ;;

1265 esac

1266 rm -rf $TMP_DIR

1267 }

1268

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

1270 convert_arch()

1271 {

1272 mkdir -p $TMP_DIR/fs

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

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

1275 cd $TMP_DIR

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

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

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

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

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

1281 file=$package-$version

1282 mkdir $file

1283 mv fs $file

1284 cat > $file/receipt <<EOT

1285 # SliTaz package receipt.

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

1287 PACKAGE="$package"

1288 VERSION="$version"

1289 CATEGORY="misc"

1290 SHORT_DESC="$descrip"

1291 WEB_SITE="$url"

1292 MAINTAINER="$maintainer"

1293 DEPENDS="$(find_depends)"

1294 EOT

1295 show_unresolved_lib $file/receipt

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

1297 tazpkg pack $file

1298 mv $file.tazpkg $TOP_DIR

1299 else

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

1301 fi

1302 cd $TOP_DIR

1303 rm -rf $TMP_DIR

1304 }

1305

1306 # get package and version from PACKAGE_FILE

1307 parse_pkgname()

1308 {

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

1310 IFS='-'

1311 set -- $package

1312 unset IFS

1313 package=$1

1314 version=$2

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

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

1317 version=${1#$package}

1318 fi

1319 file="$package-$version"

1320 mkdir $file

1321 }

1322

1323 finish_convert_puppy()

1324 {

1325 rm -f fs/*.specs

1326 mv fs $file

1327 cat > $file/receipt <<EOT

1328 # SliTaz package receipt.

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

1330 PACKAGE="$package"

1331 VERSION="$version"

1332 CATEGORY="misc"

1333 SHORT_DESC="$desc"

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

1335 MAINTAINER="nobody@slitaz.org"

1336 DEPENDS="$(find_depends)"

1337 EOT

1338 show_unresolved_lib $file/receipt

1339 for i in install uninstall ; do

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

1341

1342 post_$i()

1343 {

1344 chroot \$1/ sh - << EOT

1345 cd /

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

1347 EOT

1348 }

1349 EOM

1350 done

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

1352 tazpkg pack $file

1353 mv $file.tazpkg $TOP_DIR

1354 cd $TOP_DIR

1355 rm -rf $TMP_DIR

1356 }

1357

1358 # convert a .sfs package to .tazpkg

1359 convert_sfs()

1360 {

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

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

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

1364 return 1

1365 fi

1366 mkdir -p $TMP_DIR

1367 cd $TMP_DIR

1368 parse_pkgname .sfs

1369 unsquashfs $PACKAGE_FILE

1370 mv squashfs-root fs

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

1372 desc="$10"

1373 finish_convert_puppy

1374 }

1375

1376 # convert a .pet package to .tazpkg

1377 convert_pet()

1378 {

1379 mkdir -p $TMP_DIR

1380 cd $TMP_DIR

1381 parse_pkgname .pet

1382 tar xzf $PACKAGE_FILE 2> /dev/null

1383 . $package*/*.specs

1384 desc="$PETMENUDESCR"

1385 mv $package*/ fs

1386 finish_convert_puppy

1387 }

1388

1389 # convert a .sb package to .tazpkg

1390 convert_sb()

1391 {

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

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

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

1395 return 1

1396 fi

1397 mkdir -p $TMP_DIR

1398 cd $TMP_DIR

1399 unsquashfs $PACKAGE_FILE

1400 mv squashfs-root fs

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

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

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

1404 mv fs $file

1405 cat > $file/receipt <<EOT

1406 # SliTaz package receipt.

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

1408 PACKAGE="$package"

1409 VERSION="$version"

1410 CATEGORY="misc"

1411 SHORT_DESC="$desc"

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

1413 MAINTAINER="nobody@slitaz.org"

1414 DEPENDS="$(find_depends)"

1415 EOT

1416 show_unresolved_lib $file/receipt

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

1418

1419 post_install()

1420 {

1421 chroot \$1/ sh - << EOT

1422 cd /

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

1424 EOT

1425 }

1426 EOM

1427 tazpkg pack $file

1428 mv $file.tazpkg $TOP_DIR

1429 cd $TOP_DIR

1430 rm -rf $TMP_DIR

1431 }

1432

1433 # convert a .tgz package to .tazpkg

1434 convert_tgz()

1435 {

1436 parse_pkgname

1437 mkdir -p $TMP_DIR/$file/fs

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

1439 cd $TMP_DIR

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

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

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

1443 cat > $file/receipt <<EOT

1444 # SliTaz package receipt.

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

1446 PACKAGE="$package"

1447 VERSION="$version"

1448 CATEGORY="misc"

1449 SHORT_DESC="$descrip"

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

1451 MAINTAINER="nobody@slitaz.org"

1452 DEPENDS="$(find_depends)"

1453 EOT

1454 show_unresolved_lib $file/receipt

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

1456

1457 post_install()

1458 {

1459 chroot \$1/ sh - << EOT

1460 cd /

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

1462 EOT

1463 }

1464 EOM

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

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

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

1468 rm -rf $file/fs/install

1469 tazpkg pack $file

1470 mv $file.tazpkg $TOP_DIR

1471 else

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

1473 fi

1474 cd $TOP_DIR

1475 rm -rf $TMP_DIR

1476 }

1477

1478 # convert a .deb package to .tazpkg

1479 convert_deb()

1480 {

1481 mkdir -p $TMP_DIR

1482 dpkg-deb -e $PACKAGE_FILE $TMP_DIR

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

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

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

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

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

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

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

1490 case "$target" in

1491 i386|all)

1492 file="$package-$version"

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

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

1495 cd $TMP_DIR

1496 cat > $file/receipt <<EOT

1497 # SliTaz package receipt.

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

1499 PACKAGE="$package"

1500 VERSION="$version"

1501 CATEGORY="misc"

1502 SHORT_DESC="$descrip"

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

1504 MAINTAINER="nobody@slitaz.org"

1505 EOT

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

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

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

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

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

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

1512 CONFIG_FILES="$(cat conffiles)"

1513 EOT

1514 show_unresolved_lib $file/receipt

1515 awk '

1516 {

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

1518 else show=0;

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

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

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

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

1523 tazpkg pack $file

1524 mv $file.tazpkg $TOP_DIR

1525 ;;

1526 *)

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

1528 ;;

1529 esac

1530 cd $TOP_DIR

1531 rm -rf $TMP_DIR

1532 }

1533

1534 # convert a .rpm package to .tazpkg

1535 convert_rpm()

1536 {

1537 mkdir -p $TMP_DIR

1538 cp $PACKAGE_FILE $TMP_DIR

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

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

1541 BEGIN {

1542 goturl=0;

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

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

1545 }

1546 {

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

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

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

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

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

1552 }

1553 END {

1554 if (goturl == 0)

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

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

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

1558 }

1559 ' > $TMP_DIR/receipt

1560 . $TMP_DIR/receipt

1561 file=$PACKAGE-$VERSION

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

1563 mv $TMP_DIR/receipt $TMP_DIR/$file

1564 rpm -qip $PACKAGE_FILE | awk '

1565 BEGIN { show=0 }

1566 {

1567 if (show) print;

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

1569 }

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

1571 cd $TMP_DIR/$file/fs/

1572 rpm2cpio $PACKAGE_FILE | cpio -idm --quiet

1573 # rpm2cpio can't extract some new RPMs

1574 if [ $? == 1 ]; then

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

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

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

1578 if [ $? = 0 ]; then

1579 tazpkg -gi p7zip-full

1580 else

1581 rm -rf $TMP_DIR

1582 exit 1

1583 fi

1584 fi

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

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

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

1588 fi

1589 fi

1590 cd ../..

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

1592 show_unresolved_lib $TMP_DIR/$file/receipt

1593 tazpkg pack $file

1594 mv $file.tazpkg $TOP_DIR

1595 cd $TOP_DIR

1596 rm -rf $TMP_DIR

1597 }

1598

1599 update_desktop_database()

1600 {

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

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

1603 fi

1604 }

1605

1606 update_mime_database()

1607 {

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

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

1610 fi

1611 }

1612

1613 update_icon_database()

1614 {

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

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

1617 fi

1618 }

1619

1620 compile_glib_schemas()

1621 {

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

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

1624 fi

1625 }

1626

1627 update_kernel_modules()

1628 {

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

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

1631 fi

1632 }

1633

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

1635 # TazPKG commands #

1636 ###################

1637

1638 case "$COMMAND" in

1639 list|-l)

1640 shift

1641 # List all installed packages or a specific category.

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

1643 title 'Blocked packages'

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

1645 cat $BLOCKED

1646 else

1647 gettext "No blocked packages found."; echo

1648 fi

1649 newline && exit 0

1650 fi

1651 # Display the list of categories.

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

1653 title 'Packages categories'

1654 num=0

1655 for i in $PKGS_CATEGORIES

1656 do

1657 gettext $i; echo

1658 num=$(($num+1))

1659 done

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

1661 exit 0

1662 fi

1663 # Check for an asked category.

1664 ASKED_CATEGORY_I18N="$@"

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

1666 ASKED_CATEGORY=$(reverse_translate_category "$ASKED_CATEGORY_I18N")

1667 title 'Installed packages of category: $ASKED_CATEGORY_I18N'

1668 for pkg in $INSTALLED/*

1669 do

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

1671 EXTRAVERSION=""

1672 . $pkg/receipt

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

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

1675 packages=$(($packages+1))

1676 fi

1677 done

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

1679 footer "$(emsg $(eval_ngettext \

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

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

1682 $packages))"; echo

1683 else

1684 # By default list all packages and versions.

1685 title 'List of all installed packages'

1686 for pkg in $INSTALLED/*

1687 do

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

1689 EXTRAVERSION=""

1690 . $pkg/receipt

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

1692 packages=$(($packages+1))

1693 done

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

1695 footer "$(emsg $(eval_ngettext \

1696 '$num package installed.' \

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

1698 fi ;;

1699 list-mirror|-lm)

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

1701 # last mirrored packages diff (see recharge).

1702 check_for_packages_list

1703 case $2 in

1704 --diff)

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

1706 title 'Mirrored packages diff'

1707 cat $LOCALSTATE/packages.diff

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

1709 footer "$(eval_ngettext \

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

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

1712 else

1713 newline

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

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

1716 newline

1717 fi && exit 0 ;;

1718 --text|--txt|--raw|*)

1719 title 'List of available packages on the mirror'

1720 cat $LOCALSTATE/packages.txt ;;

1721 esac

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

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

1724 footer "$(eval_ngettext \

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

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

1727 ;;

1728 list-files|-lf)

1729 # List files installed with the package.

1730 check_for_package_on_cmdline

1731 check_for_receipt

1732 title 'Installed files by: $PACKAGE'

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

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

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

1736 footer "$(eval_ngettext \

1737 '$num file installed with $PACKAGE' \

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

1739 ;;

1740 info)

1741 # Information about package.

1742 check_for_package_on_cmdline

1743 check_for_receipt

1744 EXTRAVERSION=""

1745 . $INSTALLED/$PACKAGE/receipt

1746 title 'TazPKG information'

1747 # Display localized short description

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

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

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

1751 fi

1752 emsg "\

1753 $(gettext 'Package :') $PACKAGE

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

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

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

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

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

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

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

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

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

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

1764 footer ;;

1765

1766 desc)

1767 # Display package description.txt if available.

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

1769 title 'Description of: $PACKAGE'

1770 cat $INSTALLED/$PACKAGE/description.txt

1771 footer

1772 else

1773 newline

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

1775 newline

1776 fi ;;

1777

1778 activity|log|-a)

1779 # Show activity log

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

1781 title 'TazPKG Activity'

1782 IFS=" "

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

1784 do

1785 case "$action" in

1786 Installed)

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

1788 Removed)

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

1790 *)

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

1792 esac

1793 done

1794 unset IFS

1795 separator && newline ;;

1796

1797 search|-s)

1798 # Search for a package by pattern or name.

1799 PATTERN="$2"

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

1801 newline

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

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

1804 newline

1805 exit 0

1806 fi

1807 title 'Search result for: $PATTERN'

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

1809 case "$3" in

1810 -i|--installed)

1811 search_in_installed_packages ;;

1812 -l|--list)

1813 search_in_packages_list ;;

1814 -m|--mirror)

1815 search_in_packages_txt ;;

1816 *)

1817 search_in_installed_packages

1818 search_in_packages_list ;;

1819 esac ;;

1820

1821 search-file|-sf)

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

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

1824 newline

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

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

1827 newline

1828 exit 0

1829 fi

1830 s_file="$2"

1831 title 'Search result for file $s_file'

1832

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

1834

1835 match=0

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

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

1838 [ -f $i ] || continue

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

1840 BEGIN { last="" }

1841 {

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

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

1844 if (last != pkg) {

1845 last = pkg;

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

1847 }

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

1849 }'

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

1851 done

1852

1853 else

1854

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

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

1857 for pkg in $INSTALLED/*

1858 do

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

1860 . $pkg/receipt

1861 newline

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

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

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

1865 match=$(($match+$files))

1866 fi

1867 done

1868

1869 fi

1870 pkg=$2

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

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

1873 else

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

1875 footer "$(eval_ngettext \

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

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

1878 fi

1879 ;;

1880 search-pkgname)

1881 # Search for a package name

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

1883 newline

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

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

1886 newline

1887 exit 0

1888 fi

1889 s_pkg="$2"

1890 title 'Search result for package $s_pkg'

1891

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

1893 match=0

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

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

1896 [ -f $i ] || continue

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

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

1899 done

1900 file=$2

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

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

1903 newline

1904 else

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

1906 footer "$(eval_ngettext \

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

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

1909 fi

1910 ;;

1911 install|-i)

1912 # Install .tazpkg packages.

1913 check_root $@

1914 check_for_package_on_cmdline

1915 check_for_package_file

1916

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

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

1919 if [ "$rootconfig" ]; then

1920 if [ "$root" ]; then

1921 CACHE_DIR=$root/$CACHE_DIR

1922 SAVE_CACHE_DIR=$CACHE_DIR

1923 LOCALSTATE=$root/$LOCALSTATE

1924 else

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

1926 exit 1

1927 fi

1928 fi

1929

1930 # Get repositories priority list.

1931 look_for_priority

1932

1933 # Check if forced install.

1934 if ! [ "$forced" ]; then

1935 check_for_installed_package $ROOT

1936 fi

1937 install_package $ROOT

1938 update_desktop_database $ROOT

1939 update_mime_database $ROOT

1940 update_icon_database $ROOT

1941 compile_glib_schemas $ROOT ;;

1942 install-list|get-install-list)

1943 # Install a set of packages from a list.

1944 check_root $@

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

1946 newline

1947 gettext \

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

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

1950 newline && exit 0

1951 fi

1952 # Check if the packages list exist.

1953 list_file=$2

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

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

1956 exit 0

1957 else

1958 LIST=`cat $2`

1959 fi

1960

1961 # Remember processed list

1962 export INSTALL_LIST="$2"

1963

1964 # Set $COMMAND and install all packages.

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

1966 COMMAND=get-install

1967 else

1968 COMMAND=install

1969 fi

1970 touch $2-processed

1971

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

1973 # then upgrade essential packages early

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

1975 slitaz-base-files tazpkg ; do

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

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

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

1979 LIST="$pkg

1980 $LIST"

1981 done

1982

1983 for pkg in $LIST

1984 do

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

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

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

1988 done

1989 rm -f $2-processed ;;

1990 add-flavor)

1991 # Install a set of packages from a flavor.

1992 install_flavor $2 ;;

1993 install-flavor)

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

1995 install_flavor $2 --purge ;;

1996 set-release)

1997 # Change current release and upgrade packages.

1998 RELEASE=$2

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

2000 newline

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

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

2003 newline

2004 exit 0

2005 fi

2006 rm $LOCALSTATE/mirror

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

2008 tazpkg recharge && tazpkg upgrade

2009

2010 # Install missing depends

2011 cd $INSTALLED

2012 for i in * ; do

2013 DEPENDS=""

2014 . $i/receipt

2015 for j in $DEPENDS ; do

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

2017 done

2018 done ;;

2019 remove|-r)

2020 # Remove packages.

2021 check_root $@

2022 check_for_package_on_cmdline

2023

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

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

2026 newline

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

2028 exit 0

2029 else

2030 ALTERED=""

2031 THE_PACKAGE=$PACKAGE # altered by receipt

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

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

2034 DEPENDS=""

2035 . $ROOT$INSTALLED/$i/receipt

2036 case " $(echo $DEPENDS) " in

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

2038 esac

2039 done

2040 EXTRAVERSION=""

2041 . $ROOT$INSTALLED/$THE_PACKAGE/receipt

2042 fi

2043 newline

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

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

2046 for i in $ALTERED; do

2047 echo " $i"

2048 done

2049 fi

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

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

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

2053 for i in $REFRESH; do

2054 echo " ${i%/modifiers}"

2055 done

2056 fi

2057 if [ "$auto" ]; then

2058 answer=0

2059 else

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

2061 answer=$?

2062 fi

2063 if [ $answer = 0 ]; then

2064 title 'Removing: $PACKAGE'

2065 # Pre remove commands.

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

2067 pre_remove $ROOT

2068 fi

2069 action "Removing all files installed..."

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

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

2072 do

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

2074 do

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

2076 done

2077 remove_with_path $ROOT$file

2078 done

2079 else

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

2081 do

2082 remove_with_path $ROOT$file

2083 done

2084 fi

2085 status

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

2087 post_remove $ROOT

2088 fi

2089 # Remove package receipt.

2090 action "Removing package receipt..."

2091 rm -rf $ROOT$INSTALLED/$PACKAGE

2092 status

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

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

2095 # Log this activity

2096 log_pkg Removed

2097 if [ "$ALTERED" ]; then

2098 if [ "$auto" ]; then

2099 answer=0

2100 else

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

2102 answer=$?

2103 fi

2104 if [ $answer = 0 ]; then

2105 for i in $ALTERED; do

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

2107 tazpkg remove $i $ROOTOPTS

2108 fi

2109 done

2110 fi

2111 fi

2112 if [ "$REFRESH" ]; then

2113 if [ "$auto" ]; then

2114 answer=0

2115 else

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

2117 answer=$?

2118 fi

2119 if [ $answer = 0 ]; then

2120 for i in $REFRESH; do

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

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

2123 continue

2124 fi

2125 rm -r $ROOT$INSTALLED/$i

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

2127 done

2128 fi

2129 fi

2130 else

2131 newline

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

2133 fi

2134 newline ;;

2135 extract|-e)

2136 # Extract .tazpkg cpio archive into a directory.

2137 check_for_package_on_cmdline

2138 check_for_package_file

2139 title 'Extracting: $PACKAGE'

2140 # If no directory destination is found on the cmdline

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

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

2143 DESTDIR=$TARGET_DIR/$PACKAGE

2144 else

2145 DESTDIR=$PACKAGE

2146 fi

2147 mkdir -p $DESTDIR

2148 action "Copying original package..."

2149 cp $PACKAGE_FILE $DESTDIR

2150 status

2151 cd $DESTDIR

2152 extract_package

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

2154 ;;

2155 recompress)

2156 # Recompress .tazpkg cpio archive with lzma.

2157 check_for_package_on_cmdline

2158 check_for_package_file

2159 title 'Recompressing: $PACKAGE'

2160 mkdir -p $TMP_DIR

2161 action "Copying original package..."

2162 cp $PACKAGE_FILE $TMP_DIR

2163 status

2164 cd $TMP_DIR

2165 extract_package

2166 action "Recompressing the fs..."

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

2168 rm -rf fs

2169 status

2170 action "Creating new package..."

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

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

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

2174 $TOP_DIR/$(basename $PACKAGE_FILE)

2175 status

2176 cd $TOP_DIR

2177 rm -rf $TMP_DIR

2178 separator; newline ;;

2179 list-config)

2180 # List configuration files installed.

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

2182 mkdir -p $TMP_DIR && cd $TMP_DIR

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

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

2185 for i in $FILES; do

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

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

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

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

2190 else

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

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

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

2194 fi

2195 echo "|/$file"

2196 done

2197 rm -rf *

2198 done

2199 cd $TOP_DIR

2200 rm -rf $TMP_DIR

2201 else

2202 title 'Configuration files'

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

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

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

2206 zcat $i | cpio -t --quiet

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

2208 separator

2209 newline

2210 fi ;;

2211 repack-config)

2212 # Create SliTaz package archive from configuration files.

2213 mkdir -p $TMP_DIR && cd $TMP_DIR

2214 CONFIG_VERSION=1.0

2215 mkdir config-$CONFIG_VERSION

2216 cd config-$CONFIG_VERSION

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

2218 zcat $i | cpio -t --quiet

2219 done > files.list

2220 mkdir fs

2221 cd fs

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

2223 mkdir -p etc/tazlito

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

2225 EXTRAVERSION=""

2226 . $i

2227 echo "$PACKAGE-$VERSION$EXTRAVERSION"

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

2229 cd ..

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

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

2232 cat > receipt <<EOT

2233 # SliTaz package receipt.

2234

2235 PACKAGE="config"

2236 VERSION="$CONFIG_VERSION"

2237 CATEGORY="base-system"

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

2239 DEPENDS="$(ls $INSTALLED)"

2240 EOT

2241 cd ..

2242 tazpkg pack config-$CONFIG_VERSION

2243 cp config-$CONFIG_VERSION.tazpkg $TOP_DIR

2244 cd $TOP_DIR

2245 rm -rf $TMP_DIR

2246 ;;

2247 repack)

2248 # Create SliTaz package archive from an installed package.

2249 check_for_package_on_cmdline

2250 check_for_receipt

2251 EXTRAVERSION=""

2252 . $INSTALLED/$PACKAGE/receipt

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

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

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

2256 exit 1

2257 fi

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

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

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

2261 echo " $i"

2262 done

2263 exit 1

2264 fi

2265 MISSING=""

2266 while read i; do

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

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

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

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

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

2272 echo -e "$MISSING"

2273 exit 1

2274 fi

2275 mkdir -p $TMP_DIR && cd $TMP_DIR

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

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

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

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

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

2281 done

2282 ln -s / rootfs

2283 mkdir tmp

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

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

2286 mv tmp/rootfs fs

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

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

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

2290 fi

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

2292 . $INSTALLED/$PACKAGE/receipt

2293 repack_cleanup fs

2294 fi

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

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

2297 $CHECKSUM -s -c || {

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

2299 cd $TOP_DIR

2300 rm -rf $TMP_DIR

2301 exit 1

2302 }

2303 fi

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

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

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

2307 cd $TOP_DIR

2308 \rm -R $TMP_DIR

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

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

2311 eval_gettext "Size: \$pkg_size"; echo

2312 newline ;;

2313 pack)

2314 # Create SliTaz package archive using cpio and lzma.

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

2316 check_for_package_on_cmdline

2317 cd $PACKAGE

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

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

2320 exit 0

2321 else

2322 title 'Packing: $PACKAGE'

2323 # Create files.list with redirecting find outpout.

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

2325 cd fs

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

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

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

2329 status

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

2331 while read file; do

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

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

2334 case "$file" in

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

2336 esac

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

2338 done < files.list > $CHECKSUM

2339 status

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

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

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

2343 # Build cpio archives.

2344 action "Compressing the fs..."

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

2346 rm -rf fs

2347 status

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

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

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

2351 action "Updating receipt sizes..."

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

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

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

2355 status

2356 action "Creating full cpio archive..."

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

2358 status

2359 action "Restoring original package tree..."

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

2361 status

2362 rm fs.cpio.lzma && cd ..

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

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

2365 eval_gettext "Size: \$pkg_size"; echo

2366 newline

2367 fi ;;

2368 recharge)

2369 # Recharge packages.list from a mirror.

2370 #

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

2372 # must have only the chosen main mirror.

2373 #

2374 check_root $@

2375

2376 ARG=$2

2377 if [ "$root" ]; then

2378 LOCALSTATE=$root$LOCALSTATE

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

2380 fi

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

2382 repository_to_recharge=$LOCALSTATE

2383 elif [ "$ARG" ]; then

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

2385 repository_to_recharge=$LOCALSTATE/undigest/$ARG

2386 else

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

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

2389 echo >&2

2390 exit 1

2391 fi

2392 else

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

2394 fi

2395 for path in $repository_to_recharge; do

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

2397 cd $path

2398

2399 # Quietly check if recharging is needed.

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

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

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

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

2404 repository_name=Main

2405 else

2406 base_path="$(basename $path)"

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

2408 fi

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

2410 rm ID.bak

2411 continue

2412 fi

2413

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

2415 if [ -f ID ]; then

2416 mv -f ID ID.bak

2417 cat ID.bak > ID

2418 rm ID.bak

2419 fi

2420

2421 newline

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

2423 base_path="$(basename $path)"

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

2425 fi

2426

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

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

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

2430 packages.list packages.equiv files.list.lzma \

2431 mirrors

2432 do

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

2434 done

2435 status

2436 fi

2437

2438 for i in desc md5 txt list equiv; do

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

2440 done

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

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

2443

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

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

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

2447 title 'Mirrored packages diff'

2448 cat packages.diff

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

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

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

2452 footer "$(eval_ngettext \

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

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

2455 else

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

2457 newline

2458 fi

2459 else

2460 footer "$(gettext \

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

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

2463 packages.')"

2464 fi

2465 done ;;

2466 help-up)

2467 # Options available for the command: up

2468 newline; usage_up; newline

2469 exit 1 ;;

2470 up|upgrade)

2471 #

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

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

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

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

2476 #

2477 for opt in $@

2478 do

2479 case "$opt" in

2480 --recharge|-r)

2481 tazpkg recharge ;;

2482 --install|-i)

2483 install="y" ;;

2484 --check|-c)

2485 install="n" ;;

2486 esac

2487 done

2488 time=$(date +%s)

2489 installed_sum=$LOCALSTATE/installed.$SUM

2490 look_for_priority

2491 for repo in $priority; do

2492 pkg_list=$repo/packages.list

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

2494 if [ "$mtime" ]; then

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

2496 repo_name=main

2497 else

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

2499 fi

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

2501 tazpkg recharge $repo_name

2502 fi

2503 done

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

2505 cd $INSTALLED

2506 newline > $UP_LIST

2507 blocked_count=0

2508 for pkg in *

2509 do

2510 unset VERSION EXTRAVERSION

2511 . $pkg/receipt

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

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

2514 for repo in $priority; do

2515 pkg_desc=$repo/packages.desc

2516 pkg_list=$repo/packages.list

2517 pkg_sum=$repo/packages.$SUM

2518

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

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

2521 # in this one.

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

2523

2524 emsg -n "$PACKAGE $VERSION"

2525

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

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

2528 blocked_count=$(($blocked_count + 1))

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

2530 break

2531 fi

2532

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

2534

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

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

2537 else

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

2539 fi

2540 echo "$PACKAGE" >> $UP_LIST

2541 break

2542 fi

2543 done

2544 done

2545 sed -i /^$/d $UP_LIST

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

2547 pkgs=$(ls | wc -l)

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

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

2550 install="n"

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

2552 fi

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

2554 footer "$(eval_ngettext \

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

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

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

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

2559 num=$blocked_count

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

2561 else

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

2563 fi

2564 num=$upnb

2565 boldify "$(eval_ngettext \

2566 'You have $num available upgrade ($blocked)' \

2567 'You have $num available upgrades ($blocked)' $num)"

2568 newline

2569 fi

2570 # Pkgs to upgrade ? Skip, let install them all or ask user

2571 [ "$install" == "n" ] && exit 0

2572 if [ "$upnb" -gt 0 ]; then

2573 if [ "$install" == "y" ]; then

2574 continue

2575 else

2576 gettext "Do you wish to install them now: y/n ? "

2577 read install

2578 fi

2579 case "$install" in

2580 y|Y|yes|YES|Yes)

2581 for pkg in $(cat $UP_LIST)

2582 do

2583 echo 'y' | tazpkg get-install $pkg --forced

2584 done

2585 # List is generated each time and must be cleaned so

2586 # tazpkg-notify doesn't find upgrades anymore.

2587 rm $UP_LIST && touch $UP_LIST ;;

2588 *)

2589 gettext "Leaving without any upgrades installed."; echo

2590 newline

2591 exit 0 ;;

2592 esac

2593 fi

2594 newline ;;

2595 bugs)

2596 # Show known bugs in package(s)

2597 cd $INSTALLED

2598 shift

2599 LIST=$@

2600 [ -n "$LIST" ] || LIST=`ls`

2601 MSG=$(gettext "No known bugs.")

2602 for PACKAGE in $LIST; do

2603 BUGS=""

2604 EXTRAVERSION=""

2605 . $PACKAGE/receipt

2606 if [ -n "$BUGS" ]; then

2607 MSG=$(gettext "Bug list completed")

2608 newline

2609 eval_gettext "Bugs in package \$PACKAGE version \$VERSION\$EXTRAVERSION:"; echo

2610 cat <<EOT

2611 $BUGS

2612 EOT

2613 fi

2614 done

2615 echo "$MSG" ;;

2616 check)

2617 # Check installed packages set.

2618 check_root $@

2619

2620 # Get repositories priority list.

2621 look_for_priority

2622

2623 cd $INSTALLED

2624 for PACKAGE in `ls`; do

2625 if [ ! -f $PACKAGE/receipt ]; then

2626 eval_gettext "The package \$PACKAGE installation has not completed"; echo

2627 continue

2628 fi

2629 DEPENDS=""

2630 EXTRAVERSION=""

2631 . $PACKAGE/receipt

2632 if [ -s $PACKAGE/modifiers ]; then

2633 eval_gettext \

2634 "The package \$PACKAGE-\$VERSION\$EXTRAVERSION has been modified by:"; echo

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

2636 echo " $i"

2637 done

2638 fi

2639 MSG="$(eval_gettext 'Files lost from $PACKAGE-$VERSION$EXTRAVERSION:')\n"

2640 while read file; do

2641 [ -e "$file" ] && continue

2642 if [ -L "$file" ]; then

2643 MSG="$MSG $(gettext 'target of symlink')"

2644 fi

2645 echo -e "$MSG $file"

2646 MSG=""

2647 done < $PACKAGE/files.list

2648 MSG="$(eval_gettext 'Missing dependencies for $PACKAGE-$VERSION$EXTRAVERSION:')\n"

2649 for i in $DEPENDS; do

2650 [ -d $i ] && continue

2651 [ -d $(equivalent_pkg $i) ] && continue

2652 echo -e "$MSG $i"

2653 MSG=""

2654 done

2655 MSG="$(eval_gettext 'Dependencies loop between $PACKAGE and:')\n"

2656 ALL_DEPS=""

2657 check_for_deps_loop $PACKAGE $DEPENDS

2658 done

2659 gettext "Looking for known bugs..."; echo

2660 tazpkg bugs

2661 if [ "$PACKAGE_FILE" = "--full" ]; then

2662 for file in */$CHECKSUM; do

2663 CONFIG_FILES=""

2664 . $(dirname "$file")/receipt

2665 [ -s "$file" ] || continue

2666 while read md5 f; do

2667 [ -f $f ] || continue

2668 for i in $CONFIG_FILES; do

2669 case "$f" in

2670 $i|$i/*) continue 2;;

2671 esac

2672 done

2673 echo "$md5 $f"

2674 done < "$file" | $CHECKSUM -c - 2> /dev/null | \

2675 grep -v OK$ | sed 's/FAILED$/$CHECKSUM MISMATCH/'

2676 done

2677 FILES=" "

2678 for file in $(cat */files.list); do

2679 [ -d "$file" ] && continue

2680 case "$FILES" in *\ $file\ *) continue;; esac

2681 [ $(grep "^$(echo $file | grepesc)$" */files.list 2> /dev/null | \

2682 wc -l) -gt 1 ] || continue

2683 FILES="$FILES$file "

2684 eval_gettext "The following packages provide \$file:"; echo

2685 grep -l "^$(echo $file | grepesc)$" */files.list | while read f

2686 do

2687 pkg=${f%/files.list}

2688 if [ -f $pkg/modifiers ]; then

2689 pkg_list="$(cat $pkg/modifiers)"

2690 overriders=$(eval_gettext '(overridden by $pkg_list)')

2691 else

2692 overriders=''

2693 fi

2694 echo -n " $pkg $overriders"

2695 newline

2696 done

2697 done

2698 MSG="$(gettext 'No package has installed the following files:')\n"

2699 find /etc /bin /sbin /lib /usr /var/www \

2700 -not -type d 2> /dev/null | while read file; do

2701 case "$file" in *\[*) continue;; esac

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

2703 echo -e "$MSG $file"

2704 MSG=""

2705 done

2706 fi

2707 gettext "Check completed."; echo ;;

2708 block)

2709 # Add a pkg name to the list of blocked packages.

2710 check_root $@

2711 check_for_package_on_cmdline

2712 newline

2713 if grep -qs "^$PACKAGE" $BLOCKED; then

2714 eval_gettext "\$PACKAGE is already in the blocked packages list."; echo

2715 newline

2716 exit 0

2717 else

2718 action "Add \$PACKAGE to: \$BLOCKED..."

2719 echo $PACKAGE >> $BLOCKED

2720 status

2721 # Log this activity

2722 . $INSTALLED/$PACKAGE/receipt

2723 log_pkg Blocked

2724 fi

2725 newline ;;

2726 unblock)

2727 # Remove a pkg name from the list of blocked packages.

2728 check_root $@

2729 check_for_package_on_cmdline

2730 newline

2731 if grep -qs "^$PACKAGE" $BLOCKED; then

2732 action "Removing \$PACKAGE from: \$BLOCKED..."

2733 sed -i s/$PACKAGE/''/ $BLOCKED

2734 sed -i '/^$/d' $BLOCKED

2735 status

2736 # Log this activity

2737 . $INSTALLED/$PACKAGE/receipt

2738 log_pkg Unblocked

2739 else

2740 eval_gettext "\$PACKAGE is not in the blocked packages list."; echo

2741 newline

2742 exit 0

2743 fi

2744 newline ;;

2745 get)

2746 # Download a package with wget.

2747 check_root $@

2748 check_for_package_on_cmdline

2749 check_for_packages_list

2750

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

2752 if [ "$rootconfig" ]; then

2753 if [ "$root" ]; then

2754 CACHE_DIR=$root/$CACHE_DIR

2755 SAVE_CACHE_DIR=$CACHE_DIR

2756 LOCALSTATE=$root/$LOCALSTATE

2757 else

2758 gettext "rootconfig needs --root= option used." >&2

2759 echo >&2

2760 exit 1

2761 fi

2762 fi

2763

2764 # Get repositories priority list.

2765 look_for_priority

2766

2767 CURRENT_DIR=$PWD

2768 check_for_package_in_list

2769 cd $CACHE_DIR

2770 if [ -f "$PACKAGE.tazpkg" ]; then

2771 eval_gettext "\$PACKAGE already in the cache"; echo

2772 # Check package download was finished

2773 tail -c 2k $PACKAGE.tazpkg | fgrep -q 00000000TRAILER || {

2774 eval_gettext "Continuing \$PACKAGE download"; echo

2775 download $PACKAGE.tazpkg

2776 }

2777 if [ "$($CHECKSUM $PACKAGE.tazpkg)" != "$(fgrep " $PACKAGE.tazpkg" $rep/packages.$SUM)" ]; then

2778 rm -f $PACKAGE.tazpkg

2779 download $PACKAGE.tazpkg

2780 fi

2781 else

2782 download $PACKAGE.tazpkg

2783 fi

2784 PACKAGE_FILE=$CACHE_DIR/$PACKAGE.tazpkg

2785 cp -a $PACKAGE_FILE $CURRENT_DIR ;;

2786

2787 get-install|-gi)

2788 # Download and install a package.

2789 check_root $@

2790 check_for_package_on_cmdline

2791 check_for_packages_list

2792

2793 DO_CHECK=""

2794 [ "$forced" ] && DO_CHECK=no

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

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

2797 if [ "$rootconfig" ]; then

2798 if [ "$root" ]; then

2799 CACHE_DIR=$root/$CACHE_DIR

2800 SAVE_CACHE_DIR=$CACHE_DIR

2801 LOCALSTATE=$root/$LOCALSTATE

2802 else

2803 gettext "rootconfig needs --root= option used." >&2

2804 echo >&2

2805 exit 1

2806 fi

2807 fi

2808

2809 # Get repositories priority list.

2810 look_for_priority

2811

2812 AUTOEXEC="no"

2813 if ! check_for_package_in_list check; then

2814 CACHE_DIR="${CACHE_DIR%/*}/get"

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

2816 if download_get_script $PACKAGE /tmp/$PACKAGE.$$ ; then

2817 install_package_from_get_script /tmp/$PACKAGE.$$ $ROOT

2818 exit 0

2819 else

2820 PACKAGE=get-$PACKAGE

2821 AUTOEXEC=$PACKAGE

2822 check_for_package_in_list

2823 if [ -n "$(get_installed_package_pathname $PACKAGE $ROOT)" ]; then

2824 $AUTOEXEC $ROOT

2825 exit 0

2826 fi

2827 fi

2828 fi

2829 # Check if forced install.

2830 if ! [ "$forced" ]; then

2831 check_for_installed_package $ROOT

2832 fi

2833 cd $CACHE_DIR

2834 if [ -f "$PACKAGE.tazpkg" ]; then

2835 eval_gettext "\$PACKAGE already in the cache: \$CACHE_DIR"; echo

2836 # Check package download was finished

2837 tail -c 2k $PACKAGE.tazpkg | fgrep -q 00000000TRAILER || {

2838 eval_gettext "Continuing \$PACKAGE download"; echo

2839 download $PACKAGE.tazpkg

2840 }

2841 if [ "$($CHECKSUM $PACKAGE.tazpkg)" != "$(fgrep " $PACKAGE.tazpkg" $rep/packages.$SUM)" ]; then

2842 rm -f $PACKAGE.tazpkg

2843 download $PACKAGE.tazpkg

2844 fi

2845 else

2846 newline

2847 download $PACKAGE.tazpkg

2848 fi

2849 PACKAGE_FILE=$CACHE_DIR/$PACKAGE.tazpkg

2850 [ "$rootconfig" ] && LOCALSTATE=${LOCALSTATE#$root}

2851 install_package $ROOT

2852 [ "$AUTOEXEC" != "no" ] && $PACKAGE $ROOT

2853 update_desktop_database $ROOT

2854 update_mime_database $ROOT ;;

2855

2856 clean-cache|-cc)

2857 # Remove all downloaded packages.

2858 check_root $@

2859 files=$(find $CACHE_DIR -name *.tazpkg | wc -l)

2860 title 'Path: $CACHE_DIR'

2861 action "Cleaning cache directory..."

2862 rm -rf $CACHE_DIR/*

2863 status

2864 num=$(colorize 32 "$files")

2865 if [ "$files" == 0 ]; then

2866 footer "$(eval_gettext '$num file removed from cache.')"

2867 else

2868 footer "$(eval_gettext '$num files removed from cache.')"

2869 fi ;;

2870

2871 list-undigest)

2872 # list undigest URLs.

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

2874 for i in $LOCALSTATE/undigest/*/mirror; do

2875 [ -f $i ] || continue

2876 echo "$(basename $(dirname $i))|$(cat $i)"

2877 done

2878 else

2879 title 'Current undigest(s)'

2880 for i in $LOCALSTATE/undigest/*/mirror; do

2881 if [ ! -f $i ]; then

2882 gettext "No undigest mirror found."; echo

2883 exit 1

2884 fi

2885 echo "$(basename $(dirname $i)) $(cat $i)"

2886 done

2887 newline

2888 fi ;;

2889 remove-undigest)

2890 # remove undigest URL.

2891 check_root $@

2892 undigest="$2"

2893 if [ -d $LOCALSTATE/undigest/$2 ]; then

2894 eval_gettext "Remove \$undigest undigest" && confirm

2895 if [ $? = 0 ]; then

2896 action "Removing \$undigest undigest..."

2897 rm -rf $LOCALSTATE/undigest/$2

2898 status

2899 rmdir $LOCALSTATE/undigest 2> /dev/null

2900 fi

2901 else

2902 eval_gettext "Undigest \$undigest not found"; echo

2903 fi ;;

2904 add-undigest|setup-undigest)

2905 # Add undigest URL.

2906 check_root $@

2907 undigest=$2

2908 [ -d $LOCALSTATE/undigest ] || mkdir $LOCALSTATE/undigest

2909 if [ -z "$undigest" ]; then

2910 i=1

2911 while [ -d $LOCALSTATE/undigest/$i ]; do

2912 i=$(($i+1))

2913 done

2914 undigest=$i

2915 fi

2916 if [ ! -d $LOCALSTATE/undigest/$undigest ]; then

2917 eval_gettext "Creating new undigest \$undigest."; echo

2918 mkdir $LOCALSTATE/undigest/$undigest

2919 fi

2920 setup_mirror $LOCALSTATE/undigest/$undigest $3 ;;

2921 setup-mirror|-sm)

2922 # Change mirror URL.

2923 check_root $@

2924 setup_mirror $LOCALSTATE $2 ;;

2925 reconfigure)

2926 # Replay post_install from receipt

2927 check_for_package_on_cmdline

2928 check_root $@

2929 ROOT=""

2930 while [ -n "$3" ]; do

2931 case "$3" in

2932 --root=*)

2933 ROOT="${3#--root=}/" ;;

2934 *) shift 2

2935 u_opt="$*"

2936 echo -e "\n$(gettext 'Unknown option $u_opt.')\n" >&2

2937 exit 1 ;;

2938 esac

2939 shift

2940 done

2941 if [ -d "$ROOT$INSTALLED/$PACKAGE" ]; then

2942 check_for_receipt $ROOT

2943 # Check for post_install

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

2945 . $ROOT$INSTALLED/$PACKAGE/receipt

2946 post_install $ROOT

2947 # Log this activity

2948 [ -n "$ROOT" ] || log_pkg Reconfigured

2949 else

2950 newline

2951 eval_gettext "Nothing to do for \$PACKAGE."; echo

2952 fi

2953 else

2954 newline

2955 eval_gettext "Package \$PACKAGE is not installed."; echo

2956 gettext "Install package with 'tazpkg install' or 'tazpkg get-install'"; echo

2957 newline

2958 fi ;;

2959 shell)

2960 # TazPKG SHell

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

2962 PROMPT="\\033[1;33mtazpkg\\033[0;39m# "

2963 else

2964 PROMPT="\\033[1;33mtazpkg\\033[0;39m> "

2965 fi

2966 if [ ! "$2" = "--noheader" ]; then

2967 clear

2968 title 'TazPKG SHell.'

2969 gettext "Type 'usage' to list all available commands or 'quit' or 'q' to exit."; echo

2970 newline

2971 fi

2972 while true

2973 do

2974 echo -en "$PROMPT"; read cmd

2975 case $cmd in

2976 q|quit)

2977 break ;;

2978 shell)

2979 gettext "You are already running a TazPKG SHell."; echo ;;

2980 su)

2981 su -c 'exec tazpkg shell --noheader' && break ;;

2982 "")

2983 continue ;;

2984 *)

2985 tazpkg $cmd ;;

2986 esac

2987 done ;;

2988 depends)

2989 # Display dependencies tree

2990 cd $INSTALLED

2991 ALL_DEPS=""

2992 if [ -f $2/receipt ]; then

2993 dep_scan $2 ""

2994 fi ;;

2995 rdepends)

2996 # Display reverse dependencies tree

2997 cd $INSTALLED

2998 ALL_DEPS=""

2999 if [ -f $2/receipt ]; then

3000 rdep_scan $2

3001 fi ;;

3002 convert|-c)

3003 # convert misc package format to .tazpkg

3004 check_for_package_file

3005 [ -n "$TARGET_DIR" -a -s "$TARGET_DIR/files.list.lzma" ] &&

3006 TMPLOCALSTATE="$TARGET_DIR"

3007 if [ "$(dd if=$PACKAGE_FILE bs=8 count=1 skip=1 2> /dev/null)" \

3008 == "debian-b" ]; then

3009 convert_deb

3010 else

3011 case "$PACKAGE_FILE" in

3012 *.deb|*.udeb)

3013 convert_deb;;

3014 *.rpm)

3015 convert_rpm;;

3016 *.sb)

3017 convert_sb;;

3018 *.sfs)

3019 convert_sfs;;

3020 *.pet)

3021 convert_pet;;

3022 *.tgz)

3023 convert_tgz;;

3024 *.apk|*.pkg.tar.gz|*.pkg.tar.xz)

3025 convert_arch;;

3026 *.ipk|*.opk)

3027 convert_ipk;;

3028 *)

3029 gettext "Unsupported format"; echo ;;

3030 esac

3031 fi ;;

3032 link)

3033 # link a package from another slitaz installation

3034 PACKAGE=$2

3035 if [ ! -d "$TARGET_DIR" -o \

3036 ! -d "$TARGET_DIR$INSTALLED/$PACKAGE" ]; then

3037 gettext "

3038 usage: tazpkg link package_name slitaz_root

3039 example: 'tazpkg link openoffice /mnt' will use less than 100k in

3040 your running system ram.

3041 "

3042 exit 1

3043 fi

3044 if [ -e "$INSTALLED/$PACKAGE" ]; then

3045 eval_gettext "\$PACKAGE is already installed."; echo

3046 exit 1

3047 fi

3048 ln -s $TARGET_DIR$INSTALLED/$PACKAGE $INSTALLED

3049 DEPENDS="$(. $INSTALLED/$PACKAGE/receipt ; echo $DEPENDS)"

3050 MISSING=""

3051 for i in $DEPENDS; do

3052 [ -e $INSTALLED/$i ] && continue

3053 MISSING="$MISSING$i "

3054 eval_gettext "Missing: \$i"; echo

3055 done

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

3057 newline

3058 gettext "Link all missing dependencies" && confirm

3059 answer=$?

3060 newline

3061 if [ $answer = 0 ]; then

3062 for i in $MISSING; do

3063 tazpkg link $i $TARGET_DIR

3064 done

3065 else

3066 newline

3067 eval_gettext "Leaving dependencies unresolved for: \$PACKAGE"; echo

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

3069 newline

3070 fi

3071 fi

3072 . $INSTALLED/$PACKAGE/receipt

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

3074 pre_install

3075 fi

3076 while read path; do

3077 [ -e $path ] && continue

3078 while true; do

3079 dir=$(dirname $path)

3080 [ -e $dir ] && break

3081 path=$dir

3082 done

3083 ln -s $TARGET_DIR$path $dir

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

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

3086 post_install

3087 fi ;;

3088 usage|*)

3089 # Print a short help or give usage for an unknown or empty command.

3090 usage ;;

3091 esac

3092

3093 exit 0

SliTaz Repositories

tazpkg view tazpkg @ rev 681