tazlito: 0a92bd8e6486 tazlito

712 echo "Default urls for /iso/$(cat $TMP_DIR/initfs/etc/slitaz-release)/flavors/slitaz-loram-cdrom.iso /iso/$(cat $TMP_DIR/initfs/etc/slitaz-release)/flavors/slitaz-$(cat $TMP_DIR/initfs/etc/slitaz-release)-loram-cdrom.iso: $urliso"

713 echo -n "List of urls to insert: "

714 read -t 30 urliso2

715 urliso="$urliso2 $urliso"

716 fi

717 if ! $need_lib && [ -x /usr/share/boot/busybox-static ]; then

718 cp /usr/share/boot/busybox-static $TMP_DIR/initfs/bin/busybox

719 else

720 cp /bin/busybox $TMP_DIR/initfs/bin

721 need_lib=true

722 fi

723 for i in $($TMP_DIR/initfs/bin/busybox | awk \

724 '{ if (s) printf "%s",$0 } /Currently/ { s=1 }' | sed 's/,//g'); do

725 ln $TMP_DIR/initfs/bin/busybox $TMP_DIR/initfs/bin/$i

726 done

727 for i in /dev/console /dev/loop* /dev/null /dev/tty /dev/zero \

728 /dev/kmem /dev/mem /dev/random /dev/urandom; do

729 cp -a $i $TMP_DIR/initfs/dev

730 done

731 $need_lib && for i in /lib/ld-* /lib/lib[cm].so* /lib/lib[cm]-* ; do

732 cp -a $i $TMP_DIR/initfs/lib

733 done

734 cat > $TMP_DIR/initfs/init <<EOTEOT

735 #!/bin/sh

736

737 getarg()

738 {

739 grep -q " \$1=" /proc/cmdline || return 1

740 eval \$2=\$(sed "s/.* \$1=\\\$[^ ]*\\\$.*/\\\\1/" < /proc/cmdline)

741 return 0

742 }

743

744 copy_rootfs()

745 {

746 total=\$(grep MemTotal /proc/meminfo | sed 's/[^0-9]//g')

747 need=\$(du -c \${path}rootfs* | tail -n 1 | cut -f1)

748 [ \$(( \$total / \$need )) -gt 1 ] || return 1

749 if ! grep -q " keep-loram" /proc/cmdline && cp \${path}rootfs* /mnt; then

750 path=/mnt/

751 return 0

752 else

753 rm -f /mnt/rootfs*

754 return 1

755 fi

756 }

757

758 echo "Switching / to tmpfs..."

759 mount -t proc proc /proc

760 size="\$(grep rootfssize= < /proc/cmdline | \\

761 sed 's/.*rootfssize=\$[0-9]*[kmg%]\$.*/-o size=\\1/')"

762 [ -n "\$size" ] || size="-o size=90%"

763

764 if [ -x /bin/httpfs ]; then # loram-http

765

766 while read var default; do

767 eval \$var=\$default

768 getarg \$var \$var

769 done <<EOT

770 eth eth0

771 dns 208.67.222.222,208.67.220.220

772 netmask 255.255.255.0

773 gw

774 ip

775 EOT

776 if [ -n "\$ip" ]; then

777 ifconfig \$eth \$ip netmask \$netmask up

778 route add default gateway \$gw

779 for i in \$(echo \$dns | sed 's/,/ /g'); do

780 echo "nameserver \$i" >> /etc/resolv.conf

781 done

782 else

783 udhcpc -f -q -s /lib/udhcpc -i \$eth

784 fi

785 for i in $urliso ; do

786 [ -n "\$URLISO" ] && URLISO="\$URLISO,"

787 URLISO="\${URLISO}http://\$i/iso/\$(cat /etc/slitaz-release)/flavors/slitaz-loram-cdrom.iso,http://\$i/iso/\$(cat /etc/slitaz-release)/flavors/slitaz-\$(cat /etc/slitaz-release)-loram-cdrom.iso"

788 done

789 getarg urliso URLISO

790 DIR=fs

791 if getarg loram DIR; then

792 DEVICE=\${DIR%,*}

793 DIR=/\${DIR#*,}

794 fi

795 mount -t tmpfs \$size tmpfs /mnt

796 path2=/mnt/.httpfs/

797 path=/mnt/.cdrom/

798 mkdir -p /mnt/.rw \$path \$path2

799 while [ ! -d \$path/boot ]; do

800 for i in \$(echo \$URLISO | sed 's/,/ /g'); do

801 httpfs \$i \$path2 && break

802 done

803 mount -o loop,ro -t iso9660 \$path2/*.iso \$path

804 done

805 #copy_rootfs && umount -d \$path && umount -d \$path2

806

807 elif [ -f \$(echo /rootfs*.gz | cut -f1 -d' ') ]; then # loram-ram

808

809 total=\$(grep MemTotal /proc/meminfo | sed 's/[^0-9]//g')

810 free=\$(grep MemFree /proc/meminfo | sed 's/[^0-9]//g')

811 if [ \$(( \$total/\$free )) -gt 1 ] || ! mount -t tmpfs \$size tmpfs /mnt; then

812 echo "No tmpfs for /mnt"

813 mkdir -p /mnt/.rw

814 mount -t tmpfs tmpfs /mnt/.rw

815 mkdir -p /mnt/.rw/mnt/.rw

816 path=/

817 else

818 mkdir -p /mnt/.rw

819 path=/mnt/.

820 for i in rootfs* ; do

821 mv /\$i \$path\$i

822 done

823 fi

824

825 else # loram-cdrom

826

827 getarg cdrom DRIVE_NAME ||

828 DRIVE_NAME=\$(grep "drive name" < /proc/sys/dev/cdrom/info | cut -f 3)

829 DEVICE=/dev/\$DRIVE_NAME

830 DIR=fs

831 if getarg loram DIR; then

832 DEVICE=\${DIR%,*}

833 DIR=/\${DIR#*,}

834 fi

835 mount -t tmpfs \$size tmpfs /mnt

836 mkdir -p /mnt/.rw /mnt/.cdrom /mnt/mnt/.cdrom

837 i=0

838 while [ \$i -lt 5 ] && ! mount -r \$DEVICE /mnt/.cdrom; do

839 case "\$DEVICE" in

840 /dev/sd*|UUID=*|LABEL=*)

841 mount -t sysfs sysfs /sys

842 USBDELAY=\$(cat /sys/module/usb_storage/parameters/delay_use)

843 umount /sys

844 sleep \$((1+\$USBDELAY)) ;;

845 esac

846 i=\$((i+1))

847 done

848 path=/mnt/.cdrom/

849 copy_rootfs && umount -d /mnt/.cdrom

850

851 fi

852

853 memfree=\$(grep MemFree /proc/meminfo | sed 's/[^0-9]//g')

854 umount /proc

855 branch=br=/mnt/.rw:/mnt/.cdrom/\$DIR

856 if [ ! -d /mnt/.cdrom/fs/etc ]; then

857 branch=br=/mnt/.rw

858 for i in \${path}rootfs* ; do

859 fs=\${i#*root}

860 branch=\$branch:/mnt/.\$fs

861 mkdir -p /mnt/.rw/mnt/.\$fs /mnt/.\$fs /mnt/.rw/mnt/.cdrom

862 if [ -f /bin/cromfs-driver ]; then

863 cromfs-driver \${path}root\$fs /mnt/.\$fs -o ro,dev,suid,allow_other

864 else

865 insmod /lib/squashfs.ko.gz 2> /dev/null

866 mount -o loop,ro -t squashfs \${path}root\$fs /mnt/.\$fs

867 fi

868 done

869 else

870 mkdir -p /mnt/.rw/mnt/.httpfs

871 fi

872 insmod /lib/aufs.ko.gz

873 mount -t aufs -o \$branch none /mnt

874 [ -x /bin/httpfs ] && sed -i 's/DHCP="yes"/DHCP="no"/' /mnt/etc/network.conf

875 [ \$memfree -lt 30000 ] && sed -i 's/ slim//' /mnt/etc/rcS.conf

876 [ -x /mnt/sbin/init ] && exec /bin/switch_root mnt /sbin/init || sh

877 EOTEOT

878 chmod +x $TMP_DIR/initfs/init

879 ( cd $TMP_DIR/initfs ; find | busybox cpio -o -H newc 2> /dev/null) | \

880 lzma e $TMP_DIR/initfs.gz -si

881 rm -rf $TMP_DIR/initfs

882 rem=$(( $(stat -c "%s" $TMP_DIR/initfs.gz) % 4 ))

883 [ $rem -ne 0 ] &&

884 dd if=/dev/zero bs=1 count=$(( 4 - $rem )) >> $TMP_DIR/initfs.gz 2> /dev/null

885 return 0

886 }

887

888 # Move each initramfs to squashfs (or cromfs)

889 build_loram_rootfs()

890 {

891 rootfs_sizes=""

892 for i in $TMP_DIR/iso/boot/rootfs*.gz; do

893 mkdir -p $TMP_DIR/fs

894 cd $TMP_DIR/fs

895 ( zcat $i 2> /dev/null || unlzma -c $i) | cpio -idm

896 cd - > /dev/null

897 rootfs=$TMP_DIR/$(basename $i)

898 if [ -x /usr/bin/mkcromfs ]; then

899 /usr/bin/mkcromfs -qq -f 262144 -b 16384 $TMP_DIR/fs $rootfs

900 else

901 /usr/sbin/mksquashfs $TMP_DIR/fs $rootfs -comp xz -Xbcj x86

902 fi

903 cd $TMP_DIR

904 rootfs_sizes="$rootfs_sizes $(( $(du -s $TMP_DIR/fs | cut -f1) - $(du -s $rootfs | cut -f1) ))"

905 ( cd $(dirname $rootfs); echo $(basename $rootfs) | \

906 cpio -o -H newc ) > $rootfs.cpio

907 rm -f $rootfs

908 mv $rootfs.cpio $rootfs

909 cd - > /dev/null

910 rm -rf $TMP_DIR/fs

911 done

912 }

913

914 # Move each initramfs to squashfs (or cromfs)

915 build_loram_rootfs_cdrom()

916 {

917 mkdir -p $TMP_DIR/fs

918 cd $TMP_DIR/fs

919 for i in $TMP_DIR/iso/boot/rootfs*.gz; do

920 ( zcat $i 2> /dev/null || unlzma -c $i) | cpio -idm

921 done

922 rootfs=$TMP_DIR/rootfs.gz

923 if [ -x /usr/bin/mkcromfs ]; then

924 /usr/bin/mkcromfs -qq -f 262144 -b 16384 $TMP_DIR/fs $rootfs

925 else

926 /usr/sbin/mksquashfs $TMP_DIR/fs $rootfs -comp xz -Xbcj x86

927 fi

928 rm -rf $TMP_DIR/fs

929 cd $TMP_DIR

930 }

931

932 # Move meta boot configuration files to basic configuration files

933 # because meta loram flavor is useless when rootfs is not loaded in ram

934 unmeta_boot()

935 {

936 if [ -f $TMP_DIR/loramiso/boot/isolinux/noram.cfg ]; then

937 # We keep enough information to do unloram...

938 sed -i 's/label slitaz/label orgslitaz/' \

939 $TMP_DIR/loramiso/boot/isolinux/common.cfg

940 sed -i -e 's|=/boot/rootfs$.*$.gz |=/boot/rootfs.gz |' \

941 -e 's|label slitaz1|label slitaz|' \

942 -e '/label slitaz[1-9]/{NNNd}' \

943 $TMP_DIR/loramiso/boot/isolinux/*.cfg

944 fi

945 }

946

947 # Move rootfs to squashfs filesystem(s) to the cdrom writeable with aufs.

948 # These squashfs may be loaded in ram a boot time.

949 # Rootfs are also copied to cdrom for tiny ramsize systems.

950 # Meta flavors are converted to normal flavors.

951 build_loram_cdrom()

952 {

953 build_initfs cdrom || return 1

954 build_loram_rootfs_cdrom

955 cp -a $TMP_DIR/iso $TMP_DIR/loramiso

956 if [ "$1" == "small" ]; then

957 rm -f $TMP_DIR/loramiso/boot/root*

958 else

959 mkdir $TMP_DIR/loramiso/fs

960 cd $TMP_DIR/loramiso/fs

961 for i in $( ls ../boot/root* | sort -r ) ; do

962 ( zcat $i 2> /dev/null || unlzma -c $i ) | cpio -idmu

963 rm -f $i

964 done

965 mkdir -p $TMP_DIR/loramiso/fs/mnt/.cdrom

966 cd - > /dev/null

967 fi

968 mv $TMP_DIR/initfs.gz $TMP_DIR/loramiso/boot/rootfs.gz

969 mv $TMP_DIR/rootfs*.gz $TMP_DIR/loramiso

970 unmeta_boot

971 VOLUM_NAME="SliTaz_LoRAM_CDROM"

972 sed -i "s/root=/loram=LABEL=$VOLUM_NAME &/" \

973 $TMP_DIR/loramiso/boot/isolinux/*.cfg

974 create_iso $OUTPUT $TMP_DIR/loramiso

975 }

976

977 # Create http bootstrap to load and remove loram_cdrom

978 # Meta flavors are converted to normal flavors.

979 build_loram_http()

980 {

981 build_initfs http || return 1

982 cp -a $TMP_DIR/iso $TMP_DIR/loramiso

983 rm -f $TMP_DIR/loramiso/boot/rootfs*

984 mv $TMP_DIR/initfs.gz $TMP_DIR/loramiso/boot/rootfs.gz

985 unmeta_boot

986 create_iso $OUTPUT $TMP_DIR/loramiso

987 }

988

989 # Update meta flavor selection sizes.

990 # Reduce sizes with rootfs gains.

991 update_metaiso_sizes()

992 {

993 local append="$(grep append $TMP_DIR/loramiso/boot/isolinux/common.cfg)"

994 local new

995 [ -n "$append" ] || return

996 set -- $append

997 shift

998 new=""

999 while [ -n "$2" ]; do

1000 local s

1001 case "$1" in

1002 *G) s=$(( ${1%G} * 1024 * 1024 ));;

1003 *M) s=$(( ${1%M} * 1024 ));;

1004 *) s=${1%K};;

1005 esac

1006 rootfs_sizes=${rootfs_sizes#* }

1007 for i in $rootfs_sizes ; do

1008 s=$(( $s - $i ))

1009 done

1010 new="$new $s $2"

1011 shift 2

1012 done

1013 sed -i "s/append .*/append$new $1/" $TMP_DIR/loramiso/boot/isolinux/common.cfg

1014 }

1015

1016 # Move rootfs to a squashfs filesystem into the initramfs writeable with aufs.

1017 # Meta flavor selection sizes are updated.

1018 build_loram_ram()

1019 {

1020 build_initfs ram || return 1

1021 build_loram_rootfs

1022 cp -a $TMP_DIR/iso $TMP_DIR/loramiso

1023 rm -f $TMP_DIR/loramiso/boot/bzImage

1024 ln $TMP_DIR/loramiso/boot/vmlinuz* $TMP_DIR/loramiso/boot/bzImage

1025 rootfs=$(ls $TMP_DIR/rootfs* | sort | tail -n 1)

1026 cat $rootfs >> $TMP_DIR/initfs.gz

1027 mv $TMP_DIR/initfs.gz $rootfs

1028 cp $TMP_DIR/rootfs* $TMP_DIR/loramiso/boot

1029 update_metaiso_sizes

1030 create_iso $OUTPUT $TMP_DIR/loramiso

1031 }

1032

1033 # Remove files installed by packages

1034 find_flavor_rootfs()

1035 {

1036 for i in $1/etc/tazlito/*.extract; do

1037 [ -e $i ] || continue

1038 chroot $1 /bin/sh ${i#$1}

1039 done

1040

1041 # Clean hardlinks and files patched by genisofs in /boot

1042 for i in isolinux/isolinux.bin isolinux/boot.cat bzImage ; do

1043 rm -f $1/boot/$i

1044 done

1045

1046 # Clean files generated in post_install

1047 rm -f $1/lib/modules/*/modules.* $1/etc/mtab \

1048 $1/dev/core $1/dev/fd $1/dev/std*

1049

1050 # Verify md5

1051 cat $1/var/lib/tazpkg/installed/*/md5sum | \

1052 while read md5 file; do

1053 [ -e $1$file ] || continue

1054 [ "$(cat $1$file | md5sum)" == "$md5 -" ] &&

1055 rm -f $1$file

1056 done

1057

1058 # Check configuration files

1059 for i in $1/var/lib/tazpkg/installed/*/volatile.cpio.gz; do

1060 [ -e $i ] || continue

1061 mkdir /tmp/volatile$$

1062 zcat $i | ( cd /tmp/volatile$$ ; cpio -idmu > /dev/null )

1063 ( cd /tmp/volatile$$ ; find * -type f ) | while read file ; do

1064 [ -e $1/$file ] || continue

1065 cmp -s /tmp/volatile$$/$file $1/$file && rm -f $1/$file

1066 done

1067 rm -rf /tmp/volatile$$

1068 done

1069

1070 # Remove other files blindly

1071 for i in $1/var/lib/tazpkg/installed/*/files.list; do

1072 for file in $(cat $i); do

1073 [ $1$file -nt $i ] && continue

1074 [ -f $1$file -a ! -L $1$file ] && continue

1075 [ -d $1$file ] || rm -f $1$file

1076 done

1077 done

1078

1079 # Remove tazpkg files and tmp files

1080 rm -rf $1/var/lib/tazpkg/installed* $1/tmp $1/var/tmp

1081 rm -f $1/var/lib/tazpkg/*packages* $1/var/lib/tazpkg/files.list.lzma \

1082 $1/var/lib/tazpkg/mirror* $1/var/cache/*/* \

1083 $1/var/lock/* $1/var/log/* $1/var/run/* $1/var/run/*/* \

1084 $1/var/lib/* $1/var/lib/dbus/* 2> /dev/null

1085

1086 # Cleanup directory tree

1087 cd $1

1088 find * -type d | sort -r | while read dir; do

1089 rmdir $dir 2> /dev/null

1090 done

1091 cd - > /dev/null

1092 }

1093

1094 ####################

1095 # Tazlito commands #

1096 ####################

1097

1098 case "$COMMAND" in

1099 stats)

1100 # Tazlito general statistics from the config file.

1101 #

1102 echo ""

1103 echo -e "\033[1mTazlito statistics\033[0m

1104 ===============================================================================

1105 Config file : $CONFIG_FILE

1106 ISO name : $ISO_NAME.iso

1107 Volume name : $VOLUM_NAME

1108 Prepared : $PREPARED

1109 Packages repository : $PACKAGES_REPOSITORY

1110 Distro directory : $DISTRO"

1111 if [ ! "$ADDFILES" = "" ] ; then

1112 echo -e "Additional files : $ADDFILES"

1113 fi

1114 echo "================================================================================"

1115 echo ""

1116 ;;

1117 list-addfiles)

1118 # Simple list of additional files in the rootfs

1119 echo ""

1120 cd $ADDFILES

1121 find rootfs -type f

1122 echo "" ;;

1123 gen-config)

1124 # Generate a new config file in the current dir or the specified

1125 # directory by $2.

1126 #

1127 if [ -n "$2" ] ; then

1128 mkdir -p $2 && cd $2

1129 fi

1130 echo -n "Generating empty tazlito.conf..."

1131 empty_config_file

1132 status

1133 echo ""

1134 if [ -f "tazlito.conf" ] ; then

1135 echo "Configuration file is ready to edit."

1136 echo "File location : `pwd`/tazlito.conf"

1137 echo ""

1138 fi

1139 ;;

1140 configure)

1141 # Configure a tazlito.conf config file. Start by getting

1142 # a empty config file and sed it.

1143 #

1144 if [ -f "tazlito.conf" ] ; then

1145 rm tazlito.conf

1146 else

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

1148 cd /etc

1149 else

1150 echo "You must be root to configure the main config file or in"

1151 echo "the same directory of the file you want to configure."

1152 exit 0

1153 fi

1154 fi

1155 empty_config_file

1156 echo""

1157 echo -e "\033[1mConfiguring :\033[0m `pwd`/tazlito.conf"

1158 echo "================================================================================"

1159 # ISO name.

1160 echo -n "ISO name : " ; read answer

1161 sed -i s#'ISO_NAME=\"\"'#"ISO_NAME=\"$answer\""# tazlito.conf

1162 # Volume name.

1163 echo -n "Volume name : " ; read answer

1164 sed -i s/'VOLUM_NAME=\"SliTaz\"'/"VOLUM_NAME=\"$answer\""/ tazlito.conf

1165 # Packages repository.

1166 echo -n "Packages repository : " ; read answer

1167 sed -i s#'PACKAGES_REPOSITORY=\"\"'#"PACKAGES_REPOSITORY=\"$answer\""# tazlito.conf

1168 # Distro path.

1169 echo -n "Distro path : " ; read answer

1170 sed -i s#'DISTRO=\"\"'#"DISTRO=\"$answer\""# tazlito.conf

1171 echo "================================================================================"

1172 echo "Config file is ready to use."

1173 echo "You can now extract an ISO or generate a distro."

1174 echo ""

1175 ;;

1176 gen-iso)

1177 # Simply generate a new iso.

1178 #

1179 check_root

1180 verify_rootcd

1181 gen_livecd_isolinux

1182 distro_stats

1183 ;;

1184 gen-initiso)

1185 # Simply generate a new initramfs with a new iso.

1186 #

1187 check_root

1188 verify_rootcd

1189 gen_initramfs $ROOTFS

1190 gen_livecd_isolinux

1191 distro_stats

1192 ;;

1193 extract-distro)

1194 # Extract an ISO image to a directory and rebuild the LiveCD tree.

1195 #

1196 check_root

1197 ISO_IMAGE=$2

1198 if [ -z "$ISO_IMAGE" ] ; then

1199 echo -e "\nPlease specify the path to the ISO image."

1200 echo -e "Example : `basename $0` image.iso /path/target\n"

1201 exit 0

1202 fi

1203 # Set the distro path by checking for $3 on cmdline.

1204 if [ -n "$3" ] ; then

1205 TARGET=$3

1206 else

1207 TARGET=$DISTRO

1208 fi

1209 # Exit if existing distro is found.

1210 if [ -d "$TARGET/rootfs" ] ; then

1211 echo -e "\nA rootfs exists in : $TARGET"

1212 echo -e "Please clean the distro tree or change directory path.\n"

1213 exit 0

1214 fi

1215 echo ""

1216 echo -e "\033[1mTazlito extracting :\033[0m `basename $ISO_IMAGE`"

1217 echo "================================================================================"

1218 # Start to mount the ISO.

1219 echo ""

1220 echo "Mounting ISO image..."

1221 mkdir -p $TMP_DIR

1222 # Get ISO file size.

1223 isosize=`du -sh $ISO_IMAGE | cut -f1`

1224 mount -o loop $ISO_IMAGE $TMP_DIR

1225 sleep 2

1226 # Prepare target dir, copy the kernel and the rootfs.

1227 mkdir -p $TARGET/rootfs

1228 mkdir -p $TARGET/rootcd/boot

1229 echo -n "Copying the Linux kernel..."

1230 if cp $TMP_DIR/boot/vmlinuz* $TARGET/rootcd/boot 2> /dev/null; then

1231 ln $TARGET/rootcd/boot/vmlinuz* $TARGET/rootcd/boot/bzImage

1232 else

1233 cp $TMP_DIR/boot/bzImage $TARGET/rootcd/boot

1234 fi

1235 status

1236 echo -n "Copying isolinux files..."

1237 cp -a $TMP_DIR/boot/isolinux $TARGET/rootcd/boot

1238 for i in $(ls $TMP_DIR); do

1239 [ "$i" = "boot" ] && continue

1240 cp -a $TMP_DIR/$i $TARGET/rootcd

1241 done

1242 status

1243 if [ -d $TMP_DIR/boot/syslinux ]; then

1244 echo -n "Copying syslinux files..."

1245 cp -a $TMP_DIR/boot/syslinux $TARGET/rootcd/boot

1246 status

1247 fi

1248 if [ -d $TMP_DIR/boot/extlinux ]; then

1249 echo -n "Copying extlinux files..."

1250 cp -a $TMP_DIR/boot/extlinux $TARGET/rootcd/boot

1251 status

1252 fi

1253 if [ -d $TMP_DIR/boot/grub ]; then

1254 echo -n "Copying GRUB files..."

1255 cp -a $TMP_DIR/boot/grub $TARGET/rootcd/boot

1256 status

1257 fi

1258

1259 echo -n "Copying the rootfs..."

1260 cp $TMP_DIR/boot/rootfs.?z $TARGET/rootcd/boot

1261 status

1262 # Extract initramfs.

1263 cd $TARGET/rootfs

1264 echo -n "Extracting the rootfs... "

1265 extract_rootfs ../rootcd/boot/rootfs.gz $TARGET/rootfs

1266 # unpack /usr

1267 for i in etc/tazlito/*.extract; do

1268 [ -f "$i" ] && . $i ../rootcd

1269 done

1270 # Umount and remove temp directory and cd to $TARGET to get stats.

1271 umount $TMP_DIR && rm -rf $TMP_DIR

1272 cd ..

1273 echo ""

1274 echo "================================================================================"

1275 echo "Extracted : `basename $ISO_IMAGE` ($isosize)"

1276 echo "Distro tree : `pwd`"

1277 echo "Rootfs size : `du -sh rootfs`"

1278 echo "Rootcd size : `du -sh rootcd`"

1279 echo "================================================================================"

1280 echo ""

1281 ;;

1282 list-flavors)

1283 # Show available flavors.

1284 if [ ! -s /etc/tazlito/flavors.list -o "$2" == "--recharge" ]; then

1285 download flavors.list -O - > /etc/tazlito/flavors.list

1286 fi

1287 echo ""

1288 echo -e "\033[1mList of flavors\033[0m"

1289 echo "================================================================================"

1290 cat /etc/tazlito/flavors.list

1291 echo ""

1292 ;;

1293 show-flavor)

1294 # Show flavor description.

1295 FLAVOR=${2%.flavor}

1296 if [ ! -f "$FLAVOR.flavor" ]; then

1297 echo "File $FLAVOR.flavor not found."

1298 exit 1

1299 fi

1300 mkdir $TMP_DIR

1301 zcat $FLAVOR.flavor | ( cd $TMP_DIR; cpio -i > /dev/null)

1302 if [ "$3" = "--brief" ]; then

1303 if [ "$4" != "--noheader" ]; then

1304 echo "Name ISO Rootfs Description"

1305 echo "================================================================================"

1306 fi

1307 printf "%-16.16s %6.6s %6.6s %s\n" "$FLAVOR" \

1308 "$(field ISO $TMP_DIR/$FLAVOR.desc)" \

1309 "$(field 'Rootfs size' $TMP_DIR/$FLAVOR.desc)" \

1310 "$(grep ^Description $TMP_DIR/$FLAVOR.desc | cut -d: -f2)"

1311 else

1312 echo "================================================================================"

1313 cat $TMP_DIR/$FLAVOR.desc

1314 fi

1315 rm -Rf $TMP_DIR

1316 ;;

1317 gen-liveflavor)

1318 # Generate a new flavor from the live system.

1319 FLAVOR=${2%.flavor}

1320 DESC=""

1321 case "$FLAVOR" in

1322 '') echo -n "Flavor name : "

1323 read FLAVOR

1324 [ -z "$FLAVOR" ] && exit 1;;

1325 -?|-h*|--help) echo -e "

1326

1327 SliTaz Live Tool - Version: $VERSION

1328 \033[1mUsage: \033[0m `basename $0` gen-liveflavor flavor-name [flavor-patch-file]

1329 \033[1mflavor-patch-file format: \033[0m

1330 code data

1331 + package to add

1332 - package to remove

1333 ! non-free package to add

1334 ? display message

1335 @ flavor description

1336

1337 \033[1mExample: \033[0m

1338 @ Developer tools for slitaz maintainers

1339 + slitaz-toolchain

1340 + mercurial

1341 "

1342 exit 1;;

1343 esac

1344 mv /etc/tazlito/distro-packages.list \

1345 /etc/tazlito/distro-packages.list.$$ 2> /dev/null

1346 rm -f distro-packages.list non-free.list 2> /dev/null

1347 tazpkg recharge

1348 [ -n "$3" ] && while read action pkg; do

1349 case "$action" in

1350 +) yes | tazpkg get-install $pkg;;

1351 -) yes | tazpkg remove $pkg;;

1352 !) echo $pkg >> non-free.list;;

1353 @) DESC="$pkg";;

1354 \?) echo -en "$pkg"; read action;;

1355 esac

1356 done < $3

1357 yes '' | tazlito gen-distro

1358 echo "$DESC" | tazlito gen-flavor "$FLAVOR"

1359 mv /etc/tazlito/distro-packages.list.$$ \

1360 /etc/tazlito/distro-packages.list 2> /dev/null

1361 ;;

1362 gen-flavor)

1363 # Generate a new flavor from the last iso image generated.

1364 FLAVOR=${2%.flavor}

1365 echo ""

1366 echo -e "\033[1mFlavor generation\033[0m"

1367 echo "================================================================================"

1368 if [ -z "$FLAVOR" ]; then

1369 echo -n "Flavor name : "

1370 read FLAVOR

1371 [ -z "$FLAVOR" ] && exit 1

1372 fi

1373 check_rootfs

1374 FILES="$FLAVOR.pkglist"

1375 echo -n "Creating file $FLAVOR.flavor..."

1376 for i in rootcd rootfs; do

1377 if [ -d "$ADDFILES/$i" ] ; then

1378 FILES="$FILES\n$FLAVOR.$i"

1379 ( cd "$ADDFILES/$i"; find . | \

1380 cpio -o -H newc 2> /dev/null | gzip -9 ) > $FLAVOR.$i

1381 fi

1382 done

1383 status

1384 answer=`grep -s ^Description $FLAVOR.desc`

1385 answer=${answer#Description : }

1386 if [ -z "$answer" ]; then

1387 echo -n "Description : "

1388 read answer

1389 fi

1390 echo -n "Compressing flavor $FLAVOR..."

1391 echo "Flavor : $FLAVOR" > $FLAVOR.desc

1392 echo "Description : $answer" >> $FLAVOR.desc

1393 ( cd $DISTRO; distro_sizes) >> $FLAVOR.desc

1394 \rm -f $FLAVOR.pkglist $FLAVOR.nonfree 2> /dev/null

1395 for i in $(ls $ROOTFS$INSTALLED); do

1396 eval $(grep ^VERSION= $ROOTFS$INSTALLED/$i/receipt)

1397 EXTRAVERSION=""

1398 eval $(grep ^EXTRAVERSION= $ROOTFS$INSTALLED/$i/receipt)

1399 eval $(grep ^CATEGORY= $ROOTFS$INSTALLED/$i/receipt)

1400 if [ "$CATEGORY" = "non-free" -a "${i%%-*}" != "get" ]

1401 then

1402 echo "$i" >> $FLAVOR.nonfree

1403 else

1404 echo "$i-$VERSION$EXTRAVERSION" >> $FLAVOR.pkglist

1405 fi

1406 done

1407 [ -s $FLAVOR.nonfree ] && $FILES="$FILES\n$FLAVOR.nonfree"

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

1409 [ -s $i ] && cat $i >> $FLAVOR.mirrors

1410 done

1411 [ -s $FLAVOR.mirrors ] && $FILES="$FILES\n$FLAVOR.mirrors"

1412 echo -e "$FLAVOR.desc\n$FILES" | cpio -o -H newc 2>/dev/null | \

1413 gzip -9 > $FLAVOR.flavor

1414 rm `echo -e $FILES`

1415 status

1416 echo "================================================================================"

1417 echo "Flavor size : `du -sh $FLAVOR.flavor`"

1418 echo ""

1419 ;;

1420 upgrade-flavor)

1421 # Update package list to the latest versions available.

1422 FLAVOR=${2%.flavor}

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

1424 mkdir $TMP_DIR

1425 zcat $FLAVOR.flavor | ( cd $TMP_DIR; cpio -i >/dev/null )

1426 echo -n "Updating $FLAVOR package list..."

1427 [ -s /var/lib/tazpkg/packages.list ] || tazpkg recharge

1428 packed_size=0; unpacked_size=0

1429 while read org; do

1430 i=0

1431 pkg=$org

1432 while ! grep -q ^$pkg$ /var/lib/tazpkg/packages.txt; do

1433 pkg=${pkg%-*}

1434 i=$(($i + 1))

1435 [ $i -gt 5 ] && break;

1436 done

1437 set -- $(get_size $pkg)

1438 packed_size=$(( $packed_size + $1 ))

1439 unpacked_size=$(( $unpacked_size + $2 ))

1440 for i in $(grep ^$pkg /var/lib/tazpkg/packages.list); do

1441 echo $i

1442 break

1443 done

1444 done < $TMP_DIR/$FLAVOR.pkglist \

1445 > $TMP_DIR/$FLAVOR.pkglist.$$

1446 mv -f $TMP_DIR/$FLAVOR.pkglist.$$ $TMP_DIR/$FLAVOR.pkglist

1447 if [ -s $TMP_DIR/$FLAVOR.rootfs ]; then

1448 packed_size=$(($packed_size \

1449 + $(cat $TMP_DIR/$FLAVOR.rootfs | wc -c ) / 100 ))

1450 unpacked_size=$(($unpacked_size \

1451 + $(zcat $TMP_DIR/$FLAVOR.rootfs | wc -c ) / 100 ))

1452 fi

1453 # Estimate lzma

1454 packed_size=$(($packed_size * 2 / 3))

1455 iso_size=$(( $packed_size + 26000 ))

1456 if [ -s $TMP_DIR/$FLAVOR.rootcd ]; then

1457 iso_size=$(($iso_size \

1458 + $(zcat $TMP_DIR/$FLAVOR.rootcd | wc -c ) / 100 ))

1459 fi

1460 sed -i -e '/Image is ready/d' \

1461 -e "s/Rootfs size$ *:$ $.*$/Rootfs size\1 $(cent2human $unpacked_size) (estimated)/" \

1462 -e "s/Initramfs size$ *:$ $.*$/Initramfs size\1 $(cent2human $packed_size) (estimated)/" \

1463 -e "s/ISO image size$ *:$ $.*$/ISO image size\1 $(cent2human $iso_size) (estimated)/" \

1464 -e "s/date$ *:$ $.*$/date\1 $(date +%Y%m%d\ \at\ \%H:%M:%S)/" \

1465 $TMP_DIR/$FLAVOR.desc

1466 ( cd $TMP_DIR ; ls | cpio -o -H newc ) | gzip -9 > \

1467 $FLAVOR.flavor

1468 status

1469 rm -Rf $TMP_DIR

1470 fi

1471 ;;

1472 extract-flavor)

1473 # Extract a flavor into $FLAVORS_REPOSITORY.

1474 FLAVOR=${2%.flavor}

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

1476 mkdir $TMP_DIR

1477 zcat $FLAVOR.flavor | ( cd $TMP_DIR; cpio -i >/dev/null )

1478 echo -n "Extracting $FLAVOR..."

1479 rm -rf $FLAVORS_REPOSITORY/$FLAVOR 2> /dev/null

1480 mkdir -p $FLAVORS_REPOSITORY/$FLAVOR

1481 echo "FLAVOR=\"$FLAVOR\"" > $FLAVORS_REPOSITORY/$FLAVOR/receipt

1482 grep ^Description $TMP_DIR/$FLAVOR.desc | \

1483 sed 's/.*: $.*$$/SHORT_DESC="\1"/' >> \

1484 $FLAVORS_REPOSITORY/$FLAVOR/receipt

1485 grep -q '^Rootfs list' $TMP_DIR/$FLAVOR.desc && \

1486 grep '^Rootfs list' $TMP_DIR/$FLAVOR.desc | \

1487 sed 's/.*: $.*$$/ROOTFS_SELECTION="\1"/' >> \

1488 $FLAVORS_REPOSITORY/$FLAVOR/receipt

1489 grep '^Rootfs size' $TMP_DIR/$FLAVOR.desc | \

1490 sed 's/.*: $.*$$/ROOTFS_SIZE="\1"/' >> \

1491 $FLAVORS_REPOSITORY/$FLAVOR/receipt

1492 grep ^Initramfs $TMP_DIR/$FLAVOR.desc | \

1493 sed 's/.*: $.*$$/INITRAMFS_SIZE="\1"/' >> \

1494 $FLAVORS_REPOSITORY/$FLAVOR/receipt

1495 grep ^ISO $TMP_DIR/$FLAVOR.desc | \

1496 sed 's/.*: $.*$$/ISO_SIZE="\1"/' >> \

1497 $FLAVORS_REPOSITORY/$FLAVOR/receipt

1498 for i in rootcd rootfs; do

1499 [ -f $TMP_DIR/$FLAVOR.$i ] || continue

1500 mkdir $FLAVORS_REPOSITORY/$FLAVOR/$i

1501 zcat $TMP_DIR/$FLAVOR.$i | \

1502 (cd $FLAVORS_REPOSITORY/$FLAVOR/$i; \

1503 cpio -idm > /dev/null)

1504 done

1505 [ -s $TMP_DIR/$FLAVOR.mirrors ] &&

1506 cp $TMP_DIR/$FLAVOR.mirrors \

1507 $FLAVORS_REPOSITORY/$FLAVOR/mirrors

1508 [ -s /var/lib/tazpkg/packages.list ] || tazpkg recharge

1509 while read org; do

1510 i=0

1511 pkg=$org

1512 while ! grep -q ^$pkg$ /var/lib/tazpkg/packages.txt; do

1513 pkg=${pkg%-*}

1514 i=$(($i + 1))

1515 [ $i -gt 5 ] && break;

1516 done

1517 echo $pkg

1518 done < $TMP_DIR/$FLAVOR.pkglist \

1519 > $FLAVORS_REPOSITORY/$FLAVOR/packages.list

1520 status

1521 rm -Rf $TMP_DIR

1522 fi

1523 ;;

1524 pack-flavor)

1525 # Create a flavor from $FLAVORS_REPOSITORY.

1526 FLAVOR=${2%.flavor}

1527 if [ -s $FLAVORS_REPOSITORY/$FLAVOR/receipt ]; then

1528 mkdir $TMP_DIR

1529 echo -n "Creating flavor $FLAVOR..."

1530 [ -s /var/lib/tazpkg/packages.list ] || tazpkg recharge

1531 if [ -s $FLAVORS_REPOSITORY/$FLAVOR/mirrors ]; then

1532 cp $FLAVORS_REPOSITORY/$FLAVOR/mirrors \

1533 $TMP_DIR/$FLAVOR.mirrors

1534 for i in $(cat $TMP_DIR/$FLAVOR.mirrors); do

1535 wget -O - $i/packages.list >> $TMP_DIR/packages.list

1536 done

1537 fi

1538 [ -s $FLAVORS_REPOSITORY/$FLAVOR/packages.list ] &&

1539 get_pkglist $FLAVOR > $TMP_DIR/$FLAVOR.pkglist

1540 if grep -q ^ROOTFS_SELECTION \

1541 $FLAVORS_REPOSITORY/$FLAVOR/receipt; then

1542 . $FLAVORS_REPOSITORY/$FLAVOR/receipt

1543 set -- $ROOTFS_SELECTION

1544 [ -n "$FRUGAL_RAM" ] || FRUGAL_RAM=$1

1545 [ -f $FLAVORS_REPOSITORY/$2/packages.list ] ||

1546 tazlito extract-flavor $2

1547 get_pkglist $2 > $TMP_DIR/$FLAVOR.pkglist

1548 for i in rootcd rootfs; do

1549 mkdir $TMP_DIR/$i

1550 # Copy extra files from the first flavor

1551 [ -d $FLAVORS_REPOSITORY/$2/$i ] &&

1552 cp -a $FLAVORS_REPOSITORY/$2/$i $TMP_DIR

1553 # Overload extra files by meta flavor

1554 [ -d $FLAVORS_REPOSITORY/$FLAVOR/$i ] &&

1555 cp -a $FLAVORS_REPOSITORY/$FLAVOR/$i $TMP_DIR

1556 [ -n "$(ls $TMP_DIR/$i)" ] &&

1557 ( cd $TMP_DIR/$i ; find . | cpio -o -H newc 2> /dev/null ) | \

1558 gzip -9 >$TMP_DIR/$FLAVOR.$i

1559 rm -rf $TMP_DIR/$i

1560 done

1561 else

1562 for i in rootcd rootfs; do

1563 [ -d $FLAVORS_REPOSITORY/$FLAVOR/$i ] || \

1564 continue

1565 ( cd $FLAVORS_REPOSITORY/$FLAVOR/$i ; \

1566 find . | cpio -o -H newc 2> /dev/null ) | \

1567 gzip -9 >$TMP_DIR/$FLAVOR.$i

1568 done

1569 fi

1570 if [ -s $TMP_DIR/$FLAVOR.rootfs ]; then

1571 packed_size=$(($packed_size \

1572 + $(cat $TMP_DIR/$FLAVOR.rootfs | wc -c ) / 100 ))

1573 unpacked_size=$(($unpacked_size \

1574 + $(zcat $TMP_DIR/$FLAVOR.rootfs | wc -c ) / 100 ))

1575 fi

1576 # Estimate lzma

1577 packed_size=$(($packed_size * 2 / 3))

1578 iso_size=$(( $packed_size + 26000 ))

1579 if [ -s $TMP_DIR/$FLAVOR.rootcd ]; then

1580 iso_size=$(($iso_size \

1581 + $(zcat $TMP_DIR/$FLAVOR.rootcd | wc -c ) / 100 ))

1582 fi

1583 VERSION=""

1584 MAINTAINER=""

1585 ROOTFS_SELECTION=""

1586 ROOTFS_SIZE="$(cent2human $unpacked_size) (estimated)"

1587 INITRAMFS_SIZE="$(cent2human $packed_size) (estimated)"

1588 ISO_SIZE="$(cent2human $iso_size) (estimated)"

1589 . $FLAVORS_REPOSITORY/$FLAVOR/receipt

1590 cat > $TMP_DIR/$FLAVOR.desc <<EOT

1591 Flavor : $FLAVOR

1592 Description : $SHORT_DESC

1593 EOT

1594 [ -n "$VERSION" ] && cat >> $TMP_DIR/$FLAVOR.desc <<EOT

1595 Version : $VERSION

1596 EOT

1597 [ -n "$MAINTAINER" ] && cat >> $TMP_DIR/$FLAVOR.desc <<EOT

1598 Maintainer : $MAINTAINER

1599 EOT

1600 [ -n "$FRUGAL_RAM" ] && cat >> $TMP_DIR/$FLAVOR.desc <<EOT

1601 LiveCD RAM size : $FRUGAL_RAM

1602 EOT

1603 [ -n "$ROOTFS_SELECTION" ] && cat >> $TMP_DIR/$FLAVOR.desc <<EOT

1604 Rootfs list : $ROOTFS_SELECTION

1605 EOT

1606 cat >> $TMP_DIR/$FLAVOR.desc <<EOT

1607 Build date : $(date +%Y%m%d\ \at\ \%H:%M:%S)

1608 Packages : $(grep -v ^# $TMP_DIR/$FLAVOR.pkglist | wc -l)

1609 Rootfs size : $ROOTFS_SIZE

1610 Initramfs size : $INITRAMFS_SIZE

1611 ISO image size : $ISO_SIZE

1612 ================================================================================

1613

1614 EOT

1615 rm -f $TMP_DIR/packages.list

1616 ( cd $TMP_DIR ; ls | cpio -o -H newc 2> /dev/null) | \

1617 gzip -9 > $FLAVOR.flavor

1618 status

1619 rm -Rf $TMP_DIR

1620 else

1621 echo "No $FLAVOR flavor in $FLAVORS_REPOSITORY."

1622 fi

1623 ;;

1624 get-flavor)

1625 # Get a flavor's files and prepare for gen-distro.

1626 FLAVOR=${2%.flavor}

1627 echo ""

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

1629 echo -n "Cleaning $DISTRO..."

1630 rm -R $DISTRO 2> /dev/null

1631 mkdir -p $DISTRO

1632 status

1633 mkdir $TMP_DIR

1634 echo -n "Extracting flavor $FLAVOR.flavor... "

1635 zcat $FLAVOR.flavor | ( cd $TMP_DIR; cpio -i >/dev/null )

1636 echo -n "Creating distro-packages.list..."

1637 mv $TMP_DIR/$FLAVOR.nonfree non-free.list 2> /dev/null

1638 mv $TMP_DIR/$FLAVOR.pkglist distro-packages.list

1639 status

1640 infos="$FLAVOR.desc"

1641 for i in rootcd rootfs; do

1642 if [ -f $TMP_DIR/$FLAVOR.$i ]; then

1643 echo -n "Adding $i... "

1644 mkdir -p "$ADDFILES/$i"

1645 zcat $TMP_DIR/$FLAVOR.$i | \

1646 ( cd "$ADDFILES/$i"; cpio -id > /dev/null)

1647 zcat $TMP_DIR/$FLAVOR.$i | cpio -tv \

1648 > $TMP_DIR/$FLAVOR.list$i

1649 infos="$infos\n$FLAVOR.list$i"

1650 fi

1651 done

1652 if [ -s $TMP_DIR/$FLAVOR.mirrors ]; then

1653 n=""

1654 while read line; do

1655 mkdir -p $LOCALSTATE/undigest/$FLAVOR$n

1656 echo "$line" > $LOCALSTATE/undigest/$FLAVOR$n/mirror

1657 n=$(( $n + 1 ))

1658 done < $TMP_DIR/$FLAVOR.mirrors

1659 infos="$infos\n$FLAVOR.mirrors"

1660 tazpkg recharge

1661 fi

1662 rm -f /etc/tazlito/rootfs.list

1663 grep -q '^Rootfs list' $TMP_DIR/$FLAVOR.desc &&

1664 grep '^Rootfs list' $TMP_DIR/$FLAVOR.desc | \

1665 sed 's/.*: $.*$$/\1/' > /etc/tazlito/rootfs.list

1666 echo -n "Updating tazlito.conf..."

1667 [ -f tazlito.conf ] || cp /etc/tazlito/tazlito.conf .

1668 cat tazlito.conf | grep -v "^#VOLUM_NAME" | \

1669 sed "s/^VOLUM_NA/VOLUM_NAME=\"SliTaz $FLAVOR\"\\n#VOLUM_NA/" \

1670 > tazlito.conf.$$ && mv tazlito.conf.$$ tazlito.conf

1671 sed -i "s/ISO_NAME=.*/ISO_NAME=\"slitaz-$FLAVOR\"/" tazlito.conf

1672 status

1673 ( cd $TMP_DIR ; echo -e $infos | cpio -o -H newc ) | \

1674 gzip -9 > /etc/tazlito/info

1675 rm -Rf $TMP_DIR

1676 fi

1677 echo ""

1678 ;;

1679

1680 iso2flavor)

1681 if [ -z "$3" -o ! -s "$2" ]; then

1682 cat <<EOT

1683 Usage : tazlito iso2flavor image.iso flavor_name

1684

1685 Create a file flavor_name.flavor from the cdrom image file image.iso

1686 EOT

1687 exit 1

1688 fi

1689 FLAVOR=${3%.flavor}

1690 mkdir -p $TMP_DIR/iso $TMP_DIR/rootfs

1691 mount -o loop,ro $2 $TMP_DIR/iso

1692 if [ -s $TMP_DIR/iso/boot/rootfs1.gz ]; then

1693 echo "META flavors are not supported."

1694 umount -d $TMP_DIR/iso

1695 elif [ ! -s $TMP_DIR/iso/boot/rootfs.gz ]; then

1696 echo "No /boot/rootfs.gz in iso image. Need a SliTaz iso."

1697 umount -d $TMP_DIR/iso

1698 else

1699 ( unlzma -c $TMP_DIR/iso/boot/rootfs.gz || \

1700 zcat $TMP_DIR/iso/boot/rootfs.gz ) | \

1701 ( cd $TMP_DIR/rootfs ; cpio -idmu > /dev/null )

1702 if [ ! -s $TMP_DIR/rootfs/etc/slitaz-release ]; then

1703 echo "No file /etc/slitaz-release in /boot/rootfs.gz of iso image. Need a non loram SliTaz iso."

1704 umount -d $TMP_DIR/iso

1705 else

1706 ROOTFS_SIZE=$(du -hs $TMP_DIR/rootfs | awk '{ print $1 }')

1707 RAM_SIZE=$(du -s $TMP_DIR/rootfs | awk '{ print 32*int(($1+36000)/32768) "M" }')

1708 cp -a $TMP_DIR/iso $TMP_DIR/rootcd

1709 ISO_SIZE=$(df -h $TMP_DIR/iso | awk 'END { print $2 }')

1710 BUILD_DATE=$(date +%Y%m%d\ \at\ \%H:%M:%S -r $TMP_DIR/iso/md5sum)

1711 umount -d $TMP_DIR/iso

1712 INITRAMFS_SIZE=$(du -chs $TMP_DIR/rootcd/boot/rootfs.gz | awk '{ s=$1 } END { print $1 }')

1713 rm -f $TMP_DIR/rootcd/boot/rootfs.gz $TMP_DIR/rootcd/md5sum

1714 mv $TMP_DIR/rootcd/boot $TMP_DIR/rootfs

1715 sed 's/.* $.*$.tazpkg*/\1/' > $TMP_DIR/$FLAVOR.pkglist \

1716 < $TMP_DIR/rootfs/var/lib/tazpkg/installed.md5

1717 #[ -s $TMP_DIR/rootfs/etc/tazlito/distro-packages.list ] &&

1718 # mv $TMP_DIR/rootfs/etc/tazlito/distro-packages.list $TMP_DIR/$FLAVOR.pkglist

1719 PKGCNT=$(grep -v ^# $TMP_DIR/$FLAVOR.pkglist | wc -l | awk '{ print $1 }')

1720 find_flavor_rootfs $TMP_DIR/rootfs

1721 [ -d $TMP_DIR/rootfs/boot ] && mv $TMP_DIR/rootfs/boot $TMP_DIR/rootcd

1722 [ -n "$(ls $TMP_DIR/rootfs)" ] && ( cd $TMP_DIR/rootfs ; find * | cpio -o -H newc ) | gzip -9 > $TMP_DIR/$FLAVOR.rootfs

1723 [ -n "$(ls $TMP_DIR/rootcd)" ] && ( cd $TMP_DIR/rootcd ; find * | cpio -o -H newc ) | gzip -9 > $TMP_DIR/$FLAVOR.rootcd

1724 rm -rf $TMP_DIR/rootcd $TMP_DIR/rootfs

1725 VERSION=""; MAINTAINER=""

1726 echo -en "Flavor short description \007: "; read -t 30 DESCRIPTION

1727 if [ -n "$DESCRIPTION" ]; then

1728 echo -en "Flavor version : "; read -t 30 VERSION

1729 echo -en "Flavor maintainer (your email) : "; read -t 30 MAINTAINER

1730 fi

1731 [ -n "$DESCRIPTION" ] || DESCRIPTION="Slitaz $FLAVOR flavor"

1732 [ -n "$VERSION" ] || VERSION="1.0"

1733 [ -n "$MAINTAINER" ] || MAINTAINER="nobody@slitaz.org"

1734 cat > $TMP_DIR/$FLAVOR.desc <<EOT

1735 Flavor : $FLAVOR

1736 Description : $DESCRIPTION

1737 Version : $VERSION

1738 Maintainer : $MAINTAINER

1739 LiveCD RAM size : $RAM_SIZE

1740 Build date : $BUILD_DATE

1741 Packages : $PKGCNT

1742 Rootfs size : $ROOTFS_SIZE

1743 Initramfs size : $INITRAMFS_SIZE

1744 ISO image size : $ISO_SIZE

1745 ================================================================================

1746

1747 EOT

1748 ( cd $TMP_DIR ; ls $FLAVOR.* | cpio -o -H newc ) | gzip -9 > $FLAVOR.flavor

1749 cat <<EOT

1750 Tazlito can't detect each file installed during a package post_install.

1751 You should extract this flavor (tazlito extract-flavor $FLAVOR),

1752 check the files in /home/slitaz/flavors/$FLAVOR/rootfs tree and remove

1753 files generated by post_installs.

1754 Check /home/slitaz/flavors/$FLAVOR/receipt too and repack the flavor

1755 (tazlito pack-flavor $FLAVOR)

1756 EOT

1757 fi

1758 fi

1759 rm -rf $TMP_DIR

1760 ;;

1761

1762 check-list)

1763 # Use current packages list in $PWD by default.

1764 DISTRO_PKGS_LIST=distro-packages.list

1765 [ -d "$2" ] && DISTRO_PKGS_LIST=$2/distro-packages.list

1766 [ -f "$2" ] && DISTRO_PKGS_LIST=$2

1767 [ ! -f $DISTRO_PKGS_LIST ] && echo "No packages list found." && exit 0

1768 echo ""

1769 echo -e "\033[1mLiveCD packages list check\033[0m"

1770 echo "================================================================================"

1771 for pkg in `cat $DISTRO_PKGS_LIST`

1772 do

1773 if ! grep -q "$pkg" /var/lib/tazpkg/packages.list; then

1774 echo "Update: $pkg"

1775 up=$(($up + 1))

1776 fi

1777 done

1778 [ -z $up ] && echo -e "List is up-to-date\n" && exit 0

1779 echo "================================================================================"

1780 echo -e "Updates: $up\n" ;;

1781 gen-distro)

1782 # Generate a live distro tree with a set of packages.

1783 #

1784 check_root

1785

1786 # Check if a package list was specified on cmdline.

1787 LIST_NAME="distro-packages.list"

1788 CDROM=""

1789 while [ -n "$2" ]; do

1790 case "$2" in

1791 --iso=*)

1792 CDROM="-o loop ${2#--iso=}"

1793 ;;

1794 --cdrom)

1795 CDROM="/dev/cdrom"

1796 ;;

1797 --force)

1798 DELETE_ROOTFS="true"

1799 ;;

1800 *) if [ ! -f "$2" ] ; then

1801 echo -e "\nUnable to find the specified packages list."

1802 echo -e "List name : $2\n"

1803 exit 1

1804 fi

1805 LIST_NAME=$2

1806 ;;

1807 esac

1808 shift

1809 done

1810

1811 if [ -d $ROOTFS ] ; then

1812 # Delete $ROOTFS if --force is set on command line

1813 if [ ! -z $DELETE_ROOTFS ]; then

1814 rm -rf $ROOTFS

1815 unset $DELETE_ROOTFS

1816 else

1817 echo -e "\nA rootfs exists in : $DISTRO"

1818 echo -e "Please clean the distro tree or change directory path.\n"

1819 exit 0

1820 fi

1821 fi

1822 if [ ! -f "$LIST_NAME" -a -d $INSTALLED ] ; then

1823 # Build list with installed packages

1824 for i in $(ls $INSTALLED); do

1825 eval $(grep ^VERSION= $INSTALLED/$i/receipt)

1826 EXTRAVERSION=""

1827 eval $(grep ^EXTRAVERSION= $INSTALLED/$i/receipt)

1828 echo "$i-$VERSION$EXTRAVERSION" >> $LIST_NAME

1829 done

1830 fi

1831 # Exit if no list name.

1832 if [ ! -f "$LIST_NAME" ]; then

1833 echo -e "\nNo packages list found or specified. Please read the docs.\n"

1834 exit 0

1835 fi

1836 # Start generation.

1837 echo ""

1838 echo -e "\033[1mTazlito generating a distro\033[0m"

1839 echo "================================================================================"

1840 # Misc checks

1841 [ -n "$PACKAGES_REPOSITORY" ] || PACKAGES_REPOSITORY="."

1842 [ -d $PACKAGES_REPOSITORY ] || mkdir -p $PACKAGES_REPOSITORY

1843 # Get the list of packages using cat for a file list.

1844 LIST=`cat $LIST_NAME`

1845 # Verify if all packages in list are present in $PACKAGES_REPOSITORY.

1846 REPACK=""

1847 DOWNLOAD=""

1848 for pkg in $LIST

1849 do

1850 [ "$pkg" = "" ] && continue

1851 pkg=${pkg%.tazpkg}

1852 [ -f $PACKAGES_REPOSITORY/$pkg.tazpkg ] && continue

1853 PACKAGE=$(installed_package_name $pkg)

1854 [ -n "$PACKAGE" -a "$REPACK" = "y" ] && continue

1855 [ -z "$PACKAGE" -a -n "$DOWNLOAD" ] && continue

1856 echo -e "\nUnable to find $pkg in the repository."

1857 echo -e "Path : $PACKAGES_REPOSITORY\n"

1858 if [ -n "$PACKAGE" -a -z "$REPACK" ]; then

1859 yesorno "Repack packages from rootfs (y/N) ? "

1860 REPACK="$answer"

1861 [ "$answer" = "y" ] || REPACK="n"

1862 [ "$DOWNLOAD" = "y" ] && break

1863 fi

1864 if [ -f $MIRROR -a -z "$DOWNLOAD" ]; then

1865 yesorno "Download packages from mirror (Y/n) ? "

1866 DOWNLOAD="$answer"

1867 if [ "$answer" = "n" ]; then

1868 [ -z "$PACKAGE" ] && exit 1

1869 else

1870 DOWNLOAD="y"

1871 [ -n "$REPACK" ] && break

1872 fi

1873 fi

1874 [ "$REPACK" = "n" -a "$DOWNLOAD" = "n" ] && exit 1

1875 done

1876

1877 # Mount cdrom to be able to repack boot-loader packages

1878 if [ ! -e /boot -a -n "$CDROM" ]; then

1879 mkdir $TMP_MNT

1880 if mount -r $CDROM $TMP_MNT 2> /dev/null; then

1881 ln -s $TMP_MNT/boot /

1882 if [ ! -d "$ADDFILES/rootcd" ] ; then

1883 mkdir -p $ADDFILES/rootcd

1884 for i in $(ls $TMP_MNT); do

1885 [ "$i" = "boot" ] && continue

1886 cp -a $TMP_MNT/$i $ADDFILES/rootcd

1887 done

1888 fi

1889 else

1890 rmdir $TMP_MNT

1891 fi

1892 fi

1893

1894 # Root fs stuff.

1895 echo "Preparing the rootfs directory..."

1896 mkdir -p $ROOTFS

1897 sleep 2

1898 for pkg in $LIST

1899 do

1900 [ "$pkg" = "" ] && continue

1901 # First copy and extract the package in tmp dir.

1902 pkg=${pkg%.tazpkg}

1903 PACKAGE=$(installed_package_name $pkg)

1904 mkdir -p $TMP_DIR

1905 if [ ! -f $PACKAGES_REPOSITORY/$pkg.tazpkg ]; then

1906 # Look for package in cache

1907 if [ -f $CACHE_DIR/$pkg.tazpkg ]; then

1908 ln -s $CACHE_DIR/$pkg.tazpkg $PACKAGES_REPOSITORY

1909 # Look for package in running distribution

1910 elif [ -n "$PACKAGE" -a "$REPACK" = "y" ]; then

1911 tazpkg repack $PACKAGE && \

1912 mv $pkg.tazpkg $PACKAGES_REPOSITORY

1913 fi

1914 fi

1915 if [ ! -f $PACKAGES_REPOSITORY/$pkg.tazpkg ]; then

1916 # Get package from mirror

1917 [ "$DOWNLOAD" = "y" ] && \

1918 download $pkg.tazpkg && \

1919 mv $pkg.tazpkg $PACKAGES_REPOSITORY

1920 fi

1921 if [ ! -f $PACKAGES_REPOSITORY/$pkg.tazpkg ]; then

1922 echo "Missing package $pkg."

1923 cleanup

1924 exit 1

1925 fi

1926 done

1927 if [ -f non-free.list ]; then

1928 echo "Preparing non-free packages..."

1929 cp non-free.list $ROOTFS/etc/tazlito/non-free.list

1930 for pkg in $(cat non-free.list); do

1931 if [ ! -d $INSTALLED/$pkg ]; then

1932 if [ ! -d $INSTALLED/get-$pkg ]; then

1933 tazpkg get-install get-$pkg

1934 fi

1935 get-$pkg

1936 fi

1937 tazpkg repack $pkg

1938 pkg=$(ls $pkg*.tazpkg)

1939 grep -q "^$pkg$" $LIST_NAME || \

1940 echo $pkg >>$LIST_NAME

1941 mv $pkg $PACKAGES_REPOSITORY

1942 done

1943 fi

1944 echo ""

1945 cp $LIST_NAME $DISTRO/distro-packages.list

1946 sed 's/$.*$/\1.tazpkg/' < $DISTRO/distro-packages.list > $DISTRO/list-packages

1947 cd $PACKAGES_REPOSITORY

1948 yes y | tazpkg install-list \

1949 $DISTRO/list-packages --root=$ROOTFS

1950 cd $DISTRO

1951 cp distro-packages.list $ROOTFS/etc/tazlito

1952 # Copy all files from $ADDFILES/rootfs to the rootfs.

1953 if [ -d "$ADDFILES/rootfs" ] ; then

1954 echo -n "Copying addfiles content to the rootfs... "

1955 cp -a $ADDFILES/rootfs/* $ROOTFS

1956 status

1957 fi

1958 echo "Root file system is generated..."

1959 # Root CD part.

1960 echo -n "Preparing the rootcd directory..."

1961 mkdir -p $ROOTCD

1962 status

1963 # Move the boot dir with the Linux kernel from rootfs.

1964 # The boot dir goes directly on the CD.

1965 if [ -d "$ROOTFS/boot" ] ; then

1966 echo -n "Moving the boot directory..."

1967 mv $ROOTFS/boot $ROOTCD

1968 cd $ROOTCD/boot

1969 ln vmlinuz-* bzImage

1970 status

1971 fi

1972 cd $DISTRO

1973 # Copy all files from $ADDFILES/rootcd to the rootcd.

1974 if [ -d "$ADDFILES/rootcd" ] ; then

1975 echo -n "Copying addfiles content to the rootcd... "

1976 cp -a $ADDFILES/rootcd/* $ROOTCD

1977 status

1978 fi

1979 # Execute the distro script used to perform tasks in the rootfs

1980 # before compression. Give rootfs path in arg

1981 [ -z $DISTRO_SCRIPT ] && DISTRO_SCRIPT=$TOP_DIR/distro.sh

1982 if [ -x $DISTRO_SCRIPT ]; then

1983 echo "Executing distro script..."

1984 sh $DISTRO_SCRIPT $DISTRO

1985 fi

1986 if [ -s /etc/tazlito/rootfs.list ]; then

1987 FLAVOR_LIST="$(awk '{ for (i = 2; i <= NF; i+=2) \

1988 printf("%s ",$i) }' < /etc/tazlito/rootfs.list)"

1989 sed -i "s/ *//;s/)/), flavors $FLAVOR_LIST/" \

1990 $ROOTCD/boot/isolinux/isolinux.msg

1991 [ -f $ROOTCD/boot/isolinux/ifmem.c32 ] ||

1992 cp /boot/isolinux/ifmem.c32 $ROOTCD/boot/isolinux

1993 n=0

1994 last=$ROOTFS

1995 while read flavor; do

1996 n=$(($n+1))

1997 echo "Building $flavor rootfs..."

1998 download $flavor.flavor

1999 zcat $flavor.flavor | cpio -i \

2000 $flavor.pkglist $flavor.rootfs

2001 sed 's/.*/&.tazpkg/' < $flavor.pkglist \

2002 > $DISTRO/list-packages0$n

2003 mkdir ${ROOTFS}0$n

2004 cd $PACKAGES_REPOSITORY

2005 yes y | tazpkg install-list \

2006 $DISTRO/list-packages0$n --root=${ROOTFS}0$n

2007 rm -rf ${ROOTFS}0$n/boot

2008 status

2009 cd $DISTRO

2010 if [ -s $flavor.rootfs ]; then

2011 echo "Add $flavor rootfs extra files..."

2012 zcat $flavor.rootfs | \

2013 ( cd ${ROOTFS}0$n ; cpio -idmu )

2014 fi

2015 mv $flavor.pkglist ${ROOTFS}0$n/etc/tazlito/distro-packages.list

2016 rm -f $flavor.flavor install-list

2017 mergefs ${ROOTFS}0$n $last

2018 last=${ROOTFS}0$n

2019 done <<EOT

2020 $(awk '{ for (i = 4; i <= NF; i+=2) print $i; }' < /etc/tazlito/rootfs.list)

2021 EOT

2022 i=$(($n+1))

2023 while [ $n -gt 0 ]; do

2024 mv ${ROOTFS}0$n ${ROOTFS}$i

2025 echo "Compression ${ROOTFS}0$n ($(du -hs ${ROOTFS}$i | awk '{ print $1 }')) ..."

2026 gen_initramfs ${ROOTFS}$i

2027 n=$(($n-1))

2028 i=$(($i-1))

2029 done

2030 mv $ROOTFS ${ROOTFS}$i

2031 gen_initramfs ${ROOTFS}$i

2032 update_bootconfig $ROOTCD/boot/isolinux \

2033 "$(cat /etc/tazlito/rootfs.list)"

2034 else

2035 # Initramfs and ISO image stuff.

2036 gen_initramfs $ROOTFS

2037 fi

2038 gen_livecd_isolinux

2039 distro_stats

2040 cleanup

2041 ;;

2042 clean-distro)

2043 # Remove old distro tree.

2044 #

2045 check_root

2046 echo ""

2047 echo -e "\033[1mCleaning :\033[0m $DISTRO"

2048 echo "================================================================================"

2049 if [ -d "$DISTRO" ] ; then

2050 if [ -d "$ROOTFS" ] ; then

2051 echo -n "Removing the rootfs..."

2052 rm -f $DISTRO/$INITRAMFS

2053 rm -rf $ROOTFS

2054 status

2055 fi

2056 if [ -d "$ROOTCD" ] ; then

2057 echo -n "Removing the rootcd..."

2058 rm -rf $ROOTCD

2059 status

2060 fi

2061 echo -n "Removing eventual ISO image..."

2062 rm -f $DISTRO/$ISO_NAME.iso

2063 rm -f $DISTRO/$ISO_NAME.md5

2064 status

2065 fi

2066 echo "================================================================================"

2067 echo ""

2068 ;;

2069 check-distro)

2070 # Check for a few LiveCD needed files not installed by packages.

2071 #

2072 check_rootfs

2073 echo ""

2074 echo -e "\033[1mChecking distro :\033[0m $ROOTFS"

2075 echo "================================================================================"

2076 # SliTaz release info.

2077 if [ ! -f "$ROOTFS/etc/slitaz-release" ]; then

2078 echo "Missing release info : /etc/slitaz-release"

2079 else

2080 release=`cat $ROOTFS/etc/slitaz-release`

2081 echo -n "Release : $release"

2082 status

2083 fi

2084 # Tazpkg mirror.

2085 if [ ! -f "$ROOTFS/var/lib/tazpkg/mirror" ]; then

2086 echo -n "Mirror URL : Missing /var/lib/tazpkg/mirror"

2087 todomsg

2088 else

2089 echo -n "Mirror configuration exists..."

2090 status

2091 fi

2092 # Isolinux msg

2093 if grep -q "cooking-XXXXXXXX" /$ROOTCD/boot/isolinux/isolinux.msg; then

2094 echo -n "Isolinux msg : Missing cooking date XXXXXXXX (ex `date +%Y%m%d`)"

2095 todomsg

2096 else

2097 echo -n "Isolinux message seems good..."

2098 status

2099 fi

2100 echo "================================================================================"

2101 echo ""

2102 ;;

2103 writeiso)

2104 # Writefs to ISO image including /home unlike gen-distro we dont use

2105 # packages to generate a rootfs, we build a compressed rootfs with all

2106 # the current filesystem similar to 'tazusb writefs'.

2107 #

2108 DISTRO="/home/slitaz/distro"

2109 ROOTCD="$DISTRO/rootcd"

2110 if [ -z $2 ]; then

2111 COMPRESSION=none

2112 else

2113 COMPRESSION=$2

2114 fi

2115 if [ -z $3 ]; then

2116 ISO_NAME="slitaz"

2117 else

2118 ISO_NAME="$3"

2119 fi

2120 check_root

2121 # Start info

2122 echo ""

2123 echo -e "\033[1mWrite filesystem to ISO\033[0m

2124 ===============================================================================

2125 The command writeiso will write the current filesystem into a suitable cpio

2126 archive (rootfs.gz) and generate a bootable ISO image (slitaz.iso).

2127

2128 Archive compression: $COMPRESSION"

2129 echo ""

2130

2131 # Save some space

2132 rm /var/cache/tazpkg/* -r -f

2133 rm -rf /home/slitaz/distro

2134

2135 # Optionally remove sound card selection and screen resolution.

2136 echo "Do you wish to remove the sound card and screen configs ? "

2137 echo -n "Press ENTER to keep or answer (No|yes|exit): "

2138 read anser

2139 case $anser in

2140 e|E|"exit"|Exit)

2141 exit 0 ;;

2142 y|Y|yes|Yes)

2143 echo -n "Removing current sound card and screen configurations..."

2144 rm -f /var/lib/sound-card-driver

2145 rm -f /etc/asound.state

2146 rm -f /etc/X11/screen.conf

2147 rm -f /etc/X11/xorg.conf ;;

2148 *)

2149 echo -n "Keeping current sound card and screen configurations..." ;;

2150 esac

2151 status

2152

2153 cd /

2154 # Create list of files including default user files since it is defined in /etc/passwd

2155 # and some new users might have been added.

2156 find bin etc init sbin var dev lib root usr home >/tmp/list

2157

2158 for dir in proc sys tmp mnt media media/cdrom media/flash media/usbdisk

2159 do

2160 echo $dir >>/tmp/list

2161 done

2162

2163 # Generate initramfs with specified compression and display rootfs

2164 # size in realtime.

2165 rm -f /tmp/rootfs

2166 write_initramfs &

2167 sleep 2

2168 cd - > /dev/null

2169 echo -en "\nFilesystem size:"

2170 while [ ! -f /tmp/rootfs ]

2171 do

2172 sleep 1

2173 echo -en "\\033[18G`du -sh /rootfs.gz | awk '{print $1}'` "

2174 done

2175 echo -e "\n"

2176

2177 # Move freshly generated rootfs to the cdrom.

2178 mkdir -p $ROOTCD/boot

2179 mv -f /rootfs.gz $ROOTCD/boot

2180

2181 # Now we need the kernel and isolinux files.

2182 if mount /dev/cdrom /media/cdrom 2>/dev/null; then

2183 cp /media/cdrom/boot/bzImage $ROOTCD/boot

2184 cp -a /media/cdrom/boot/isolinux $ROOTCD/boot

2185 umount /media/cdrom

2186 else

2187 echo -e "

2188 Unable to mount the cdrom to copy the Kernel and needed files. When SliTaz

2189 is running in RAM the kernel and bootloader files are kept on the cdrom.

2190 Please insert a LiveCD or unmount the current cdrom to let Tazlito handle

2191 the media.\n"

2192 echo -en "----\nENTER to continue..."; read i

2193 exit 1

2194 fi

2195

2196 # Generate the iso image.

2197 cd $DISTRO

2198 echo "Generating ISO image..."

2199 genisoimage -R -o $ISO_NAME.iso -b boot/isolinux/isolinux.bin \

2200 -c boot/isolinux/boot.cat -no-emul-boot -boot-load-size 4 \

2201 -V "SliTaz" -input-charset iso8859-1 -boot-info-table $ROOTCD

2202 if [ -x /usr/bin/isohybrid ]; then

2203 echo -n "Creating hybrid ISO..."

2204 /usr/bin/isohybrid $ISO_NAME.iso 2> /dev/null

2205 status

2206 fi

2207 echo -n "Creating the ISO md5sum..."

2208 md5sum $ISO_NAME.iso > $ISO_NAME.md5

2209 status

2210

2211 echo "==============================================================================="

2212 echo "ISO image: `du -sh /home/slitaz/distro/$ISO_NAME.iso`"

2213 echo ""

2214 echo -n "Exit or burn ISO to cdrom (Exit|burn)? "; read anser

2215 case $anser in

2216 burn)

2217 eject

2218 echo -n "Please insert a blank cdrom and press ENTER..."

2219 read i && sleep 2

2220 tazlito burn-iso /home/slitaz/distro/$ISO_NAME.iso

2221 echo -en "----\nENTER to continue..."; read i ;;

2222 *)

2223 exit 0 ;;

2224 esac ;;

2225 burn-iso)

2226 # Guess cdrom device, ask user and burn the ISO.

2227 #

2228 check_root

2229 DRIVE_NAME=`cat /proc/sys/dev/cdrom/info | grep "drive name" | cut -f 3`

2230 DRIVE_SPEED=`cat /proc/sys/dev/cdrom/info | grep "drive speed" | cut -f 3`

2231 # We can specify an alternative ISO from the cmdline.

2232 if [ -n "$2" ] ; then

2233 iso=$2

2234 else

2235 iso=$DISTRO/$ISO_NAME.iso

2236 fi

2237 if [ ! -f "$iso" ]; then

2238 echo -e "\nUnable to find ISO : $iso\n"

2239 exit 0

2240 fi

2241 echo ""

2242 echo -e "\033[1mTazlito burn ISO\033[0m "

2243 echo "================================================================================"

2244 echo "Cdrom device : /dev/$DRIVE_NAME"

2245 echo "Drive speed : $DRIVE_SPEED"

2246 echo "ISO image : $iso"

2247 echo "================================================================================"

2248 echo ""

2249 yesorno "Burn ISO image (y/N) ? "

2250 if [ "$answer" == "y" ]; then

2251 echo ""

2252 echo "Starting Wodim to burn the iso..." && sleep 2

2253 echo "================================================================================"

2254 wodim speed=$DRIVE_SPEED dev=/dev/$DRIVE_NAME $iso

2255 echo "================================================================================"

2256 echo "ISO image is burned to cdrom."

2257 else

2258 echo -e "\nExiting. No ISO burned."

2259 fi

2260 echo ""

2261 ;;

2262 merge)

2263 # Merge multiple rootfs into one iso.

2264 #

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

2266 cat << EOT

2267 Usage: tazlito merge size1 iso size2 rootfs2 [sizeN rootfsN]...

2268

2269 Merge multiple rootfs into one iso. Rootfs are like russian dolls

2270 i.e: rootfsN is a subset of rootfsN-1

2271 rootfs1 is found in iso, sizeN is the RAM size need to launch rootfsN.

2272 The boot loader will select the rootfs according to the RAM size detected.

2273

2274 Example:

2275 $ tazlito merge 160M slitaz-core.iso 96M rootfs-justx.gz 32M rootfs-base.gz

2276

2277 Will start slitaz-core with 160M+ RAM, slitaz-justX with 96M-160M RAM,

2278 slitaz-base with 32M-96M RAM and display an error message if RAM < 32M.

2279 EOT

2280 exit 2

2281 fi

2282

2283 shift # skip merge

2284 append="$1 slitaz1"

2285 shift # skip size1

2286 mkdir -p $TMP_DIR/mnt $TMP_DIR/rootfs1

2287

2288 ISO=$1.merged

2289 # Extract filesystems

2290 echo -n "Mounting $1"

2291 mount -o loop,ro $1 $TMP_DIR/mnt 2> /dev/null

2292 status || cleanup_merge

2293 cp -a $TMP_DIR/mnt $TMP_DIR/iso

2294 rm -f $TMP_DIR/iso/boot/bzImage

2295 ln $TMP_DIR/iso/boot/vmlinuz* $TMP_DIR/iso/boot/bzImage

2296 umount -d $TMP_DIR/mnt

2297 if [ -f $TMP_DIR/iso/boot/rootfs1.gz ]; then

2298 echo "$1 is already a merged iso. Aborting."

2299 cleanup_merge

2300 fi

2301 if [ ! -f $TMP_DIR/iso/boot/isolinux/ifmem.c32 ]; then

2302 if [ ! -f /boot/isolinux/ifmem.c32 ]; then

2303 cat <<EOT

2304 No file /boot/isolinux/ifmem.c32

2305 Please install syslinux package !

2306 EOT

2307 rm -rf $TMP_DIR

2308 exit 1

2309 fi

2310 cp /boot/isolinux/ifmem.c32 $TMP_DIR/iso/boot/isolinux

2311 fi

2312

2313 echo -n "Extracting iso/rootfs.gz"

2314 extract_rootfs $TMP_DIR/iso/boot/rootfs.gz $TMP_DIR/rootfs1 &&

2315 [ -d $TMP_DIR/rootfs1/etc ]

2316 status || cleanup_merge

2317 n=1

2318 while [ -n "$2" ]; do

2319 shift # skip rootfs N-1

2320 p=$n

2321 n=$(($n + 1))

2322 append="$append $1 slitaz$n"

2323 shift # skip size N

2324 mkdir -p $TMP_DIR/rootfs$n

2325 echo -n "Extracting $1"

2326 extract_rootfs $1 $TMP_DIR/rootfs$n &&

2327 [ -d $TMP_DIR/rootfs$n/etc ]

2328 status || cleanup_merge

2329 mergefs $TMP_DIR/rootfs$n $TMP_DIR/rootfs$p

2330 echo "Creating rootfs$p.gz"

2331 pack_rootfs $TMP_DIR/rootfs$p $TMP_DIR/iso/boot/rootfs$p.gz

2332 status

2333 done

2334 echo "Creating rootfs$n.gz"

2335 pack_rootfs $TMP_DIR/rootfs$n $TMP_DIR/iso/boot/rootfs$n.gz

2336 status

2337 rm -f $TMP_DIR/iso/boot/rootfs.gz

2338 update_bootconfig $TMP_DIR/iso/boot/isolinux "$append"

2339 create_iso $ISO $TMP_DIR/iso

2340 rm -rf $TMP_DIR

2341 ;;

2342

2343 repack)

2344 # Repack an iso with maximum lzma compression ratio.

2345 #

2346

2347 ISO=$2

2348

2349 mkdir -p $TMP_DIR/mnt

2350 # Extract filesystems

2351 echo -n "Mounting $ISO"

2352 mount -o loop,ro $ISO $TMP_DIR/mnt 2> /dev/null

2353 status || cleanup_merge

2354 cp -a $TMP_DIR/mnt $TMP_DIR/iso

2355 umount -d $TMP_DIR/mnt

2356

2357 for i in $TMP_DIR/iso/boot/rootfs* ; do

2358 echo -n "Repacking $(basename $i)"

2359 (zcat $i 2> /dev/null || unlzma -c $i || cat $i) \

2360 2>/dev/null > $TMP_DIR/rootfs

2361 lzma e $TMP_DIR/rootfs $i \

2362 $(lzma_switches $TMP_DIR/rootfs)

2363 status

2364 done

2365

2366 create_iso $ISO $TMP_DIR/iso

2367 rm -rf $TMP_DIR ;;

2368

2369 build-loram)

2370 # Build a Live CD for low ram systems.

2371 #

2372

2373 ISO=$2

2374 OUTPUT=$3

2375 mkdir -p $TMP_DIR/iso

2376 mount -o loop,ro -t iso9660 $ISO $TMP_DIR/iso

2377 if ! check_iso_for_loram ; then

2378 echo "$2 is not a valid SliTaz live CD. Abort."

2379 umount -d $TMP_DIR/iso

2380 rm -rf $TMP_DIR

2381 exit 1

2382 fi

2383

2384 case "$4" in

2385 cdrom) build_loram_cdrom ;;

2386 smallcdrom) build_loram_cdrom small ;;

2387 http) build_loram_http ;;

2388 *) build_loram_ram ;;

2389 esac

2390 umount -d $TMP_DIR/iso

2391 rm -rf $TMP_DIR ;;

2392

2393

2394 frugal-install|-fi)

2395 ISO_IMAGE="$2"

2396 echo ""

2397 mkdir -p /boot/frugal

2398 if [ -f "$ISO_IMAGE" ]; then

2399 echo -n "Using ISO image: $ISO_IMAGE"

2400 mkdir -p /tmp/iso && mount -o loop $ISO_IMAGE /tmp/iso

2401 status

2402 echo -n "Installing the Kernel and rootfs..."

2403 cp -a /tmp/iso/boot/bzImage /boot/frugal

2404 cp -a /tmp/iso/boot/rootfs.gz /boot/frugal

2405 umount /tmp/iso

2406 status

2407 else

2408 echo -n "Using distro: $DISTRO"

2409 cd $DISTRO && status

2410 echo -n "Installing the Kernel and rootfs..."

2411 cp -a $DISTRO/rootcd/boot/bzImage /boot/frugal

2412 cp -a $DISTRO/rootcd/boot/rootfs.gz /boot/frugal

2413 status

2414 fi

2415 # Grub entry

2416 if ! grep -q "^kernel /boot/frugal/bzImage" /boot/grub/menu.lst; then

2417 echo -n "Configuring GRUB menu list..."

2418 cat >> /boot/grub/menu.lst << EOT

2419 title SliTaz GNU/Linux (frugal)

2420 root (hd0,0)

2421 kernel /boot/frugal/bzImage root=/dev/null

2422 initrd /boot/frugal/rootfs.gz

2423 EOT

2424 else

2425 echo -n "GRUB menu list is up-to-date..."

2426 fi

2427 status

2428 echo "" ;;

2429

2430 emu-iso)

2431 # Emulate an ISO image with Qemu.

2432 if [ -n "$2" ] ; then

2433 iso=$2

2434 else

2435 iso=$DISTRO/$ISO_NAME.iso

2436 fi

2437 if [ ! -f "$iso" ]; then

2438 echo -e "\nUnable to find ISO : $iso\n"

2439 exit 0

2440 fi

2441 if [ ! -x "/usr/bin/qemu" ]; then

2442 echo -e "\nUnable to find Qemu binary. Please install: qemu\n"

2443 exit 0

2444 fi

2445 echo -e "\nStarting Qemu emulator:\n"

2446 echo -e "qemu $QEMU_OPTS $iso\n"

2447 qemu $QEMU_OPTS $iso ;;

2448

2449 usage|*)

2450 # Clear and print usage also for all unknown commands.

2451 #

2452 clear

2453 usage ;;

2454 esac

2455

2456 exit 0

SliTaz Repositories

tazlito view tazlito @ rev 203