tazlito: 0893d0f643b9 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/.* loram=\$[^ ]*\$.*/\\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 if [ "$1" != "cdrom" ]; then

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

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

908 rm -f $rootfs

909 mv $rootfs.cpio $rootfs

910 fi

911 cd - > /dev/null

912 rm -rf $TMP_DIR/fs

913 done

914 }

915

916 # Move meta boot configuration files to basic configuration files

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

918 unmeta_boot()

919 {

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

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

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

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

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

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

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

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

928 fi

929 }

930

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

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

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

934 # Meta flavors are converted to normal flavors.

935 build_loram_cdrom()

936 {

937 build_initfs cdrom || return 1

938 build_loram_rootfs cdrom

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

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

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

942 else

943 mkdir $TMP_DIR/loramiso/fs

944 cd $TMP_DIR/loramiso/fs

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

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

947 rm -f $i

948 done

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

950 cd - > /dev/null

951 fi

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

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

954 unmeta_boot

955 create_iso $OUTPUT $TMP_DIR/loramiso

956 }

957

958 # Create http bootstrap to load and remove loram_cdrom

959 # Meta flavors are converted to normal flavors.

960 build_loram_http()

961 {

962 build_initfs http || return 1

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

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

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

966 unmeta_boot

967 create_iso $OUTPUT $TMP_DIR/loramiso

968 }

969

970 # Update meta flavor selection sizes.

971 # Reduce sizes with rootfs gains.

972 update_metaiso_sizes()

973 {

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

975 local new

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

977 set -- $append

978 shift

979 new=""

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

981 local s

982 case "$1" in

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

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

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

986 esac

987 rootfs_sizes=${rootfs_sizes#* }

988 for i in $rootfs_sizes ; do

989 s=$(( $s - $i ))

990 done

991 new="$new $s $2"

992 shift 2

993 done

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

995 }

996

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

998 # Meta flavor selection sizes are updated.

999 build_loram_ram()

1000 {

1001 build_initfs ram || return 1

1002 build_loram_rootfs

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

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

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

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

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

1008 mv $TMP_DIR/initfs.gz $rootfs

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

1010 update_metaiso_sizes

1011 create_iso $OUTPUT $TMP_DIR/loramiso

1012 }

1013

1014 # Remove files installed by packages

1015 find_flavor_rootfs()

1016 {

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

1018 [ -e $i ] || continue

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

1020 done

1021

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

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

1024 rm -f $1/boot/$i

1025 done

1026

1027 # Clean files generated in post_install

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

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

1030

1031 # Verify md5

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

1033 while read md5 file; do

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

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

1036 rm -f $1$file

1037 done

1038

1039 # Check configuration files

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

1041 [ -e $i ] || continue

1042 mkdir /tmp/volatile$$

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

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

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

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

1047 done

1048 rm -rf /tmp/volatile$$

1049 done

1050

1051 # Remove other files blindly

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

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

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

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

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

1057 done

1058 done

1059

1060 # Remove tazpkg files and tmp files

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

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

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

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

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

1066

1067 # Cleanup directory tree

1068 cd $1

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

1070 rmdir $dir 2> /dev/null

1071 done

1072 cd - > /dev/null

1073 }

1074

1075 ####################

1076 # Tazlito commands #

1077 ####################

1078

1079 case "$COMMAND" in

1080 stats)

1081 # Tazlito general statistics from the config file.

1082 #

1083 echo ""

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

1085 ===============================================================================

1086 Config file : $CONFIG_FILE

1087 ISO name : $ISO_NAME.iso

1088 Volume name : $VOLUM_NAME

1089 Prepared : $PREPARED

1090 Packages repository : $PACKAGES_REPOSITORY

1091 Distro directory : $DISTRO"

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

1093 echo -e "Additional files : $ADDFILES"

1094 fi

1095 echo "================================================================================"

1096 echo ""

1097 ;;

1098 list-addfiles)

1099 # Simple list of additional files in the rootfs

1100 echo ""

1101 cd $ADDFILES

1102 find rootfs -type f

1103 echo "" ;;

1104 gen-config)

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

1106 # directory by $2.

1107 #

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

1109 mkdir -p $2 && cd $2

1110 fi

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

1112 empty_config_file

1113 status

1114 echo ""

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

1116 echo "Configuration file is ready to edit."

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

1118 echo ""

1119 fi

1120 ;;

1121 configure)

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

1123 # a empty config file and sed it.

1124 #

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

1126 rm tazlito.conf

1127 else

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

1129 cd /etc

1130 else

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

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

1133 exit 0

1134 fi

1135 fi

1136 empty_config_file

1137 echo""

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

1139 echo "================================================================================"

1140 # ISO name.

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

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

1143 # Volume name.

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

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

1146 # Packages repository.

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

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

1149 # Distro path.

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

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

1152 echo "================================================================================"

1153 echo "Config file is ready to use."

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

1155 echo ""

1156 ;;

1157 gen-iso)

1158 # Simply generate a new iso.

1159 #

1160 check_root

1161 verify_rootcd

1162 gen_livecd_isolinux

1163 distro_stats

1164 ;;

1165 gen-initiso)

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

1167 #

1168 check_root

1169 verify_rootcd

1170 gen_initramfs $ROOTFS

1171 gen_livecd_isolinux

1172 distro_stats

1173 ;;

1174 extract-distro)

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

1176 #

1177 check_root

1178 ISO_IMAGE=$2

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

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

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

1182 exit 0

1183 fi

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

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

1186 TARGET=$3

1187 else

1188 TARGET=$DISTRO

1189 fi

1190 # Exit if existing distro is found.

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

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

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

1194 exit 0

1195 fi

1196 echo ""

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

1198 echo "================================================================================"

1199 # Start to mount the ISO.

1200 echo ""

1201 echo "Mounting ISO image..."

1202 mkdir -p $TMP_DIR

1203 # Get ISO file size.

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

1205 mount -o loop $ISO_IMAGE $TMP_DIR

1206 sleep 2

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

1208 mkdir -p $TARGET/rootfs

1209 mkdir -p $TARGET/rootcd/boot

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

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

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

1213 else

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

1215 fi

1216 status

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

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

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

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

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

1222 done

1223 status

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

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

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

1227 status

1228 fi

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

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

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

1232 status

1233 fi

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

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

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

1237 status

1238 fi

1239

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

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

1242 status

1243 # Extract initramfs.

1244 cd $TARGET/rootfs

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

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

1247 # unpack /usr

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

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

1250 done

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

1252 umount $TMP_DIR && rm -rf $TMP_DIR

1253 cd ..

1254 echo ""

1255 echo "================================================================================"

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

1257 echo "Distro tree : `pwd`"

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

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

1260 echo "================================================================================"

1261 echo ""

1262 ;;

1263 list-flavors)

1264 # Show available flavors.

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

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

1267 fi

1268 echo ""

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

1270 echo "================================================================================"

1271 cat /etc/tazlito/flavors.list

1272 echo ""

1273 ;;

1274 show-flavor)

1275 # Show flavor description.

1276 FLAVOR=${2%.flavor}

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

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

1279 exit 1

1280 fi

1281 mkdir $TMP_DIR

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

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

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

1285 echo "Name ISO Rootfs Description"

1286 echo "================================================================================"

1287 fi

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

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

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

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

1292 else

1293 echo "================================================================================"

1294 cat $TMP_DIR/$FLAVOR.desc

1295 fi

1296 rm -Rf $TMP_DIR

1297 ;;

1298 gen-liveflavor)

1299 # Generate a new flavor from the live system.

1300 FLAVOR=${2%.flavor}

1301 DESC=""

1302 case "$FLAVOR" in

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

1304 read FLAVOR

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

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

1307

1308 SliTaz Live Tool - Version: $VERSION

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

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

1311 code data

1312 + package to add

1313 - package to remove

1314 ! non-free package to add

1315 ? display message

1316 @ flavor description

1317

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

1319 @ Developer tools for slitaz maintainers

1320 + slitaz-toolchain

1321 + mercurial

1322 "

1323 exit 1;;

1324 esac

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

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

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

1328 tazpkg recharge

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

1330 case "$action" in

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

1332 -) yes | tazpkg remove $pkg;;

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

1334 @) DESC="$pkg";;

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

1336 esac

1337 done < $3

1338 yes '' | tazlito gen-distro

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

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

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

1342 ;;

1343 gen-flavor)

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

1345 FLAVOR=${2%.flavor}

1346 echo ""

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

1348 echo "================================================================================"

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

1350 echo -n "Flavor name : "

1351 read FLAVOR

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

1353 fi

1354 check_rootfs

1355 FILES="$FLAVOR.pkglist"

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

1357 for i in rootcd rootfs; do

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

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

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

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

1362 fi

1363 done

1364 status

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

1366 answer=${answer#Description : }

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

1368 echo -n "Description : "

1369 read answer

1370 fi

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

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

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

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

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

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

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

1378 EXTRAVERSION=""

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

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

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

1382 then

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

1384 else

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

1386 fi

1387 done

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

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

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

1391 done

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

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

1394 gzip -9 > $FLAVOR.flavor

1395 rm `echo -e $FILES`

1396 status

1397 echo "================================================================================"

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

1399 echo ""

1400 ;;

1401 upgrade-flavor)

1402 # Update package list to the latest versions available.

1403 FLAVOR=${2%.flavor}

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

1405 mkdir $TMP_DIR

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

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

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

1409 packed_size=0; unpacked_size=0

1410 while read org; do

1411 i=0

1412 pkg=$org

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

1414 pkg=${pkg%-*}

1415 i=$(($i + 1))

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

1417 done

1418 set -- $(get_size $pkg)

1419 packed_size=$(( $packed_size + $1 ))

1420 unpacked_size=$(( $unpacked_size + $2 ))

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

1422 echo $i

1423 break

1424 done

1425 done < $TMP_DIR/$FLAVOR.pkglist \

1426 > $TMP_DIR/$FLAVOR.pkglist.$$

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

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

1429 packed_size=$(($packed_size \

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

1431 unpacked_size=$(($unpacked_size \

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

1433 fi

1434 # Estimate lzma

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

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

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

1438 iso_size=$(($iso_size \

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

1440 fi

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

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

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

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

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

1446 $TMP_DIR/$FLAVOR.desc

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

1448 $FLAVOR.flavor

1449 status

1450 rm -Rf $TMP_DIR

1451 fi

1452 ;;

1453 extract-flavor)

1454 # Extract a flavor into $FLAVORS_REPOSITORY.

1455 FLAVOR=${2%.flavor}

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

1457 mkdir $TMP_DIR

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

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

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

1461 mkdir -p $FLAVORS_REPOSITORY/$FLAVOR

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

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

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

1465 $FLAVORS_REPOSITORY/$FLAVOR/receipt

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

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

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

1469 $FLAVORS_REPOSITORY/$FLAVOR/receipt

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

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

1472 $FLAVORS_REPOSITORY/$FLAVOR/receipt

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

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

1475 $FLAVORS_REPOSITORY/$FLAVOR/receipt

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

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

1478 $FLAVORS_REPOSITORY/$FLAVOR/receipt

1479 for i in rootcd rootfs; do

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

1481 mkdir $FLAVORS_REPOSITORY/$FLAVOR/$i

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

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

1484 cpio -idm > /dev/null)

1485 done

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

1487 cp $TMP_DIR/$FLAVOR.mirrors \

1488 $FLAVORS_REPOSITORY/$FLAVOR/mirrors

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

1490 while read org; do

1491 i=0

1492 pkg=$org

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

1494 pkg=${pkg%-*}

1495 i=$(($i + 1))

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

1497 done

1498 echo $pkg

1499 done < $TMP_DIR/$FLAVOR.pkglist \

1500 > $FLAVORS_REPOSITORY/$FLAVOR/packages.list

1501 status

1502 rm -Rf $TMP_DIR

1503 fi

1504 ;;

1505 pack-flavor)

1506 # Create a flavor from $FLAVORS_REPOSITORY.

1507 FLAVOR=${2%.flavor}

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

1509 mkdir $TMP_DIR

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

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

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

1513 cp $FLAVORS_REPOSITORY/$FLAVOR/mirrors \

1514 $TMP_DIR/$FLAVOR.mirrors

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

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

1517 done

1518 fi

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

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

1521 if grep -q ^ROOTFS_SELECTION \

1522 $FLAVORS_REPOSITORY/$FLAVOR/receipt; then

1523 . $FLAVORS_REPOSITORY/$FLAVOR/receipt

1524 set -- $ROOTFS_SELECTION

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

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

1527 tazlito extract-flavor $2

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

1529 for i in rootcd rootfs; do

1530 mkdir $TMP_DIR/$i

1531 # Copy extra files from the first flavor

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

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

1534 # Overload extra files by meta flavor

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

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

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

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

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

1540 rm -rf $TMP_DIR/$i

1541 done

1542 else

1543 for i in rootcd rootfs; do

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

1545 continue

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

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

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

1549 done

1550 fi

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

1552 packed_size=$(($packed_size \

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

1554 unpacked_size=$(($unpacked_size \

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

1556 fi

1557 # Estimate lzma

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

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

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

1561 iso_size=$(($iso_size \

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

1563 fi

1564 VERSION=""

1565 MAINTAINER=""

1566 ROOTFS_SELECTION=""

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

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

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

1570 . $FLAVORS_REPOSITORY/$FLAVOR/receipt

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

1572 Flavor : $FLAVOR

1573 Description : $SHORT_DESC

1574 EOT

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

1576 Version : $VERSION

1577 EOT

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

1579 Maintainer : $MAINTAINER

1580 EOT

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

1582 LiveCD RAM size : $FRUGAL_RAM

1583 EOT

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

1585 Rootfs list : $ROOTFS_SELECTION

1586 EOT

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

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

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

1590 Rootfs size : $ROOTFS_SIZE

1591 Initramfs size : $INITRAMFS_SIZE

1592 ISO image size : $ISO_SIZE

1593 ================================================================================

1594

1595 EOT

1596 rm -f $TMP_DIR/packages.list

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

1598 gzip -9 > $FLAVOR.flavor

1599 status

1600 rm -Rf $TMP_DIR

1601 else

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

1603 fi

1604 ;;

1605 get-flavor)

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

1607 FLAVOR=${2%.flavor}

1608 echo ""

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

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

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

1612 mkdir -p $DISTRO

1613 status

1614 mkdir $TMP_DIR

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

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

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

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

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

1620 status

1621 infos="$FLAVOR.desc"

1622 for i in rootcd rootfs; do

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

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

1625 mkdir -p "$ADDFILES/$i"

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

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

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

1629 > $TMP_DIR/$FLAVOR.list$i

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

1631 fi

1632 done

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

1634 n=""

1635 while read line; do

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

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

1638 n=$(( $n + 1 ))

1639 done < $TMP_DIR/$FLAVOR.mirrors

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

1641 tazpkg recharge

1642 fi

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

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

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

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

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

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

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

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

1651 > tazlito.conf.$$ && mv tazlito.conf.$$ tazlito.conf

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

1653 status

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

1655 gzip -9 > /etc/tazlito/info

1656 rm -Rf $TMP_DIR

1657 fi

1658 echo ""

1659 ;;

1660

1661 iso2flavor)

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

1663 cat <<EOT

1664 Usage : tazlito iso2flavor image.iso flavor_name

1665

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

1667 EOT

1668 exit 1

1669 fi

1670 FLAVOR=${3%.flavor}

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

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

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

1674 echo "META flavors are not supported."

1675 umount -d $TMP_DIR/iso

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

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

1678 umount -d $TMP_DIR/iso

1679 else

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

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

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

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

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

1685 umount -d $TMP_DIR/iso

1686 else

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

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

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

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

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

1692 umount -d $TMP_DIR/iso

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

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

1695 mv $TMP_DIR/rootcd/boot $TMP_DIR/rootfs

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

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

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

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

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

1701 find_flavor_rootfs $TMP_DIR/rootfs

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

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

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

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

1706 VERSION=""; MAINTAINER=""

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

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

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

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

1711 fi

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

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

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

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

1716 Flavor : $FLAVOR

1717 Description : $DESCRIPTION

1718 Version : $VERSION

1719 Maintainer : $MAINTAINER

1720 LiveCD RAM size : $RAM_SIZE

1721 Build date : $BUILD_DATE

1722 Packages : $PKGCNT

1723 Rootfs size : $ROOTFS_SIZE

1724 Initramfs size : $INITRAMFS_SIZE

1725 ISO image size : $ISO_SIZE

1726 ================================================================================

1727

1728 EOT

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

1730 cat <<EOT

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

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

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

1734 files generated by post_installs.

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

1736 (tazlito pack-flavor $FLAVOR)

1737 EOT

1738 fi

1739 fi

1740 rm -rf $TMP_DIR

1741 ;;

1742

1743 check-list)

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

1745 DISTRO_PKGS_LIST=distro-packages.list

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

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

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

1749 echo ""

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

1751 echo "================================================================================"

1752 for pkg in `cat $DISTRO_PKGS_LIST`

1753 do

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

1755 echo "Update: $pkg"

1756 up=$(($up + 1))

1757 fi

1758 done

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

1760 echo "================================================================================"

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

1762 gen-distro)

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

1764 #

1765 check_root

1766

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

1768 LIST_NAME="distro-packages.list"

1769 CDROM=""

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

1771 case "$2" in

1772 --iso=*)

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

1774 ;;

1775 --cdrom)

1776 CDROM="/dev/cdrom"

1777 ;;

1778 --force)

1779 DELETE_ROOTFS="true"

1780 ;;

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

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

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

1784 exit 1

1785 fi

1786 LIST_NAME=$2

1787 ;;

1788 esac

1789 shift

1790 done

1791

1792 if [ -d $ROOTFS ] ; then

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

1794 if [ ! -z $DELETE_ROOTFS ]; then

1795 rm -rf $ROOTFS

1796 unset $DELETE_ROOTFS

1797 else

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

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

1800 exit 0

1801 fi

1802 fi

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

1804 # Build list with installed packages

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

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

1807 EXTRAVERSION=""

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

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

1810 done

1811 fi

1812 # Exit if no list name.

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

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

1815 exit 0

1816 fi

1817 # Start generation.

1818 echo ""

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

1820 echo "================================================================================"

1821 # Misc checks

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

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

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

1825 LIST=`cat $LIST_NAME`

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

1827 REPACK=""

1828 DOWNLOAD=""

1829 for pkg in $LIST

1830 do

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

1832 pkg=${pkg%.tazpkg}

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

1834 PACKAGE=$(installed_package_name $pkg)

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

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

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

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

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

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

1841 REPACK="$answer"

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

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

1844 fi

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

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

1847 DOWNLOAD="$answer"

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

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

1850 else

1851 DOWNLOAD="y"

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

1853 fi

1854 fi

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

1856 done

1857

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

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

1860 mkdir $TMP_MNT

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

1862 ln -s $TMP_MNT/boot /

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

1864 mkdir -p $ADDFILES/rootcd

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

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

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

1868 done

1869 fi

1870 else

1871 rmdir $TMP_MNT

1872 fi

1873 fi

1874

1875 # Root fs stuff.

1876 echo "Preparing the rootfs directory..."

1877 mkdir -p $ROOTFS

1878 sleep 2

1879 for pkg in $LIST

1880 do

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

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

1883 pkg=${pkg%.tazpkg}

1884 PACKAGE=$(installed_package_name $pkg)

1885 mkdir -p $TMP_DIR

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

1887 # Look for package in cache

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

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

1890 # Look for package in running distribution

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

1892 tazpkg repack $PACKAGE && \

1893 mv $pkg.tazpkg $PACKAGES_REPOSITORY

1894 fi

1895 fi

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

1897 # Get package from mirror

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

1899 download $pkg.tazpkg && \

1900 mv $pkg.tazpkg $PACKAGES_REPOSITORY

1901 fi

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

1903 echo "Missing package $pkg."

1904 cleanup

1905 exit 1

1906 fi

1907 done

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

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

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

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

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

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

1914 tazpkg get-install get-$pkg

1915 fi

1916 get-$pkg

1917 fi

1918 tazpkg repack $pkg

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

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

1921 echo $pkg >>$LIST_NAME

1922 mv $pkg $PACKAGES_REPOSITORY

1923 done

1924 fi

1925 echo ""

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

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

1928 cd $PACKAGES_REPOSITORY

1929 yes y | tazpkg install-list \

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

1931 cd $DISTRO

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

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

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

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

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

1937 status

1938 fi

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

1940 # Root CD part.

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

1942 mkdir -p $ROOTCD

1943 status

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

1945 # The boot dir goes directly on the CD.

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

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

1948 mv $ROOTFS/boot $ROOTCD

1949 cd $ROOTCD/boot

1950 ln vmlinuz-* bzImage

1951 status

1952 fi

1953 cd $DISTRO

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

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

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

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

1958 status

1959 fi

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

1961 # before compression. Give rootfs path in arg

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

1963 if [ -x $DISTRO_SCRIPT ]; then

1964 echo "Executing distro script..."

1965 sh $DISTRO_SCRIPT $DISTRO

1966 fi

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

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

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

1970 n=0

1971 last=$ROOTFS

1972 while read flavor; do

1973 n=$(($n+1))

1974 echo "Building $flavor rootfs..."

1975 download $flavor.flavor

1976 zcat $flavor.flavor | cpio -i \

1977 $flavor.pkglist $flavor.rootfs

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

1979 > $DISTRO/list-packages0$n

1980 mkdir ${ROOTFS}0$n

1981 cd $PACKAGES_REPOSITORY

1982 yes y | tazpkg install-list \

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

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

1985 status

1986 cd $DISTRO

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

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

1989 zcat $flavor.rootfs | \

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

1991 fi

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

1993 rm -f $flavor.flavor install-list

1994 mergefs ${ROOTFS}0$n $last

1995 last=${ROOTFS}0$n

1996 done <<EOT

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

1998 EOT

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

2000 while [ $n -gt 0 ]; do

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

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

2003 gen_initramfs ${ROOTFS}$i

2004 n=$(($n-1))

2005 i=$(($i-1))

2006 done

2007 mv $ROOTFS ${ROOTFS}$i

2008 gen_initramfs ${ROOTFS}$i

2009 update_bootconfig $ROOTCD/boot/isolinux \

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

2011 else

2012 # Initramfs and ISO image stuff.

2013 gen_initramfs $ROOTFS

2014 fi

2015 gen_livecd_isolinux

2016 distro_stats

2017 cleanup

2018 ;;

2019 clean-distro)

2020 # Remove old distro tree.

2021 #

2022 check_root

2023 echo ""

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

2025 echo "================================================================================"

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

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

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

2029 rm -f $DISTRO/$INITRAMFS

2030 rm -rf $ROOTFS

2031 status

2032 fi

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

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

2035 rm -rf $ROOTCD

2036 status

2037 fi

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

2039 rm -f $DISTRO/$ISO_NAME.iso

2040 rm -f $DISTRO/$ISO_NAME.md5

2041 status

2042 fi

2043 echo "================================================================================"

2044 echo ""

2045 ;;

2046 check-distro)

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

2048 #

2049 check_rootfs

2050 echo ""

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

2052 echo "================================================================================"

2053 # SliTaz release info.

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

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

2056 else

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

2058 echo -n "Release : $release"

2059 status

2060 fi

2061 # Tazpkg mirror.

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

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

2064 todomsg

2065 else

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

2067 status

2068 fi

2069 # Isolinux msg

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

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

2072 todomsg

2073 else

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

2075 status

2076 fi

2077 echo "================================================================================"

2078 echo ""

2079 ;;

2080 writeiso)

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

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

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

2084 #

2085 DISTRO="/home/slitaz/distro"

2086 ROOTCD="$DISTRO/rootcd"

2087 if [ -z $2 ]; then

2088 COMPRESSION=none

2089 else

2090 COMPRESSION=$2

2091 fi

2092 if [ -z $3 ]; then

2093 ISO_NAME="slitaz"

2094 else

2095 ISO_NAME="$3"

2096 fi

2097 check_root

2098 # Start info

2099 echo ""

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

2101 ===============================================================================

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

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

2104

2105 Archive compression: $COMPRESSION"

2106 echo ""

2107

2108 # Save some space

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

2110 rm -rf /home/slitaz/distro

2111

2112 # Optionally remove sound card selection and screen resolution.

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

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

2115 read anser

2116 case $anser in

2117 e|E|"exit"|Exit)

2118 exit 0 ;;

2119 y|Y|yes|Yes)

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

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

2122 rm -f /etc/asound.state

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

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

2125 *)

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

2127 esac

2128 status

2129

2130 cd /

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

2132 # and some new users might have been added.

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

2134

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

2136 do

2137 echo $dir >>/tmp/list

2138 done

2139

2140 # Generate initramfs with specified compression and display rootfs

2141 # size in realtime.

2142 rm -f /tmp/rootfs

2143 write_initramfs &

2144 sleep 2

2145 cd - > /dev/null

2146 echo -en "\nFilesystem size:"

2147 while [ ! -f /tmp/rootfs ]

2148 do

2149 sleep 1

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

2151 done

2152 echo -e "\n"

2153

2154 # Move freshly generated rootfs to the cdrom.

2155 mkdir -p $ROOTCD/boot

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

2157

2158 # Now we need the kernel and isolinux files.

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

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

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

2162 umount /media/cdrom

2163 else

2164 echo -e "

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

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

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

2168 the media.\n"

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

2170 exit 1

2171 fi

2172

2173 # Generate the iso image.

2174 cd $DISTRO

2175 echo "Generating ISO image..."

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

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

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

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

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

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

2182 status

2183 fi

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

2185 md5sum $ISO_NAME.iso > $ISO_NAME.md5

2186 status

2187

2188 echo "==============================================================================="

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

2190 echo ""

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

2192 case $anser in

2193 burn)

2194 eject

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

2196 read i && sleep 2

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

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

2199 *)

2200 exit 0 ;;

2201 esac ;;

2202 burn-iso)

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

2204 #

2205 check_root

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

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

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

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

2210 iso=$2

2211 else

2212 iso=$DISTRO/$ISO_NAME.iso

2213 fi

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

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

2216 exit 0

2217 fi

2218 echo ""

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

2220 echo "================================================================================"

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

2222 echo "Drive speed : $DRIVE_SPEED"

2223 echo "ISO image : $iso"

2224 echo "================================================================================"

2225 echo ""

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

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

2228 echo ""

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

2230 echo "================================================================================"

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

2232 echo "================================================================================"

2233 echo "ISO image is burned to cdrom."

2234 else

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

2236 fi

2237 echo ""

2238 ;;

2239 merge)

2240 # Merge multiple rootfs into one iso.

2241 #

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

2243 cat << EOT

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

2245

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

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

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

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

2250

2251 Example:

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

2253

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

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

2256 EOT

2257 exit 2

2258 fi

2259

2260 shift # skip merge

2261 append="$1 slitaz1"

2262 shift # skip size1

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

2264

2265 ISO=$1.merged

2266 # Extract filesystems

2267 echo -n "Mounting $1"

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

2269 status || cleanup_merge

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

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

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

2273 umount -d $TMP_DIR/mnt

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

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

2276 cleanup_merge

2277 fi

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

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

2280 cat <<EOT

2281 No file /boot/isolinux/ifmem.c32

2282 Please install syslinux package !

2283 EOT

2284 rm -rf $TMP_DIR

2285 exit 1

2286 fi

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

2288 fi

2289

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

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

2292 [ -d $TMP_DIR/rootfs1/etc ]

2293 status || cleanup_merge

2294 n=1

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

2296 shift # skip rootfs N-1

2297 p=$n

2298 n=$(($n + 1))

2299 append="$append $1 slitaz$n"

2300 shift # skip size N

2301 mkdir -p $TMP_DIR/rootfs$n

2302 echo -n "Extracting $1"

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

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

2305 status || cleanup_merge

2306 mergefs $TMP_DIR/rootfs$n $TMP_DIR/rootfs$p

2307 echo "Creating rootfs$p.gz"

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

2309 status

2310 done

2311 echo "Creating rootfs$n.gz"

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

2313 status

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

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

2316 create_iso $ISO $TMP_DIR/iso

2317 rm -rf $TMP_DIR

2318 ;;

2319

2320 repack)

2321 # Repack an iso with maximum lzma compression ratio.

2322 #

2323

2324 ISO=$2

2325

2326 mkdir -p $TMP_DIR/mnt

2327 # Extract filesystems

2328 echo -n "Mounting $ISO"

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

2330 status || cleanup_merge

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

2332 umount -d $TMP_DIR/mnt

2333

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

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

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

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

2338 lzma e $TMP_DIR/rootfs $i \

2339 $(lzma_switches $TMP_DIR/rootfs)

2340 status

2341 done

2342

2343 create_iso $ISO $TMP_DIR/iso

2344 rm -rf $TMP_DIR ;;

2345

2346 build-loram)

2347 # Build a Live CD for low ram systems.

2348 #

2349

2350 ISO=$2

2351 OUTPUT=$3

2352 mkdir -p $TMP_DIR/iso

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

2354 if ! check_iso_for_loram ; then

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

2356 umount -d $TMP_DIR/iso

2357 rm -rf $TMP_DIR

2358 exit 1

2359 fi

2360

2361 case "$4" in

2362 cdrom) build_loram_cdrom ;;

2363 smallcdrom) build_loram_cdrom small ;;

2364 http) build_loram_http ;;

2365 *) build_loram_ram ;;

2366 esac

2367 umount -d $TMP_DIR/iso

2368 rm -rf $TMP_DIR ;;

2369

2370

2371 frugal-install|-fi)

2372 ISO_IMAGE="$2"

2373 echo ""

2374 mkdir -p /boot/frugal

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

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

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

2378 status

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

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

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

2382 umount /tmp/iso

2383 status

2384 else

2385 echo -n "Using distro: $DISTRO"

2386 cd $DISTRO && status

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

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

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

2390 status

2391 fi

2392 # Grub entry

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

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

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

2396 title SliTaz GNU/Linux (frugal)

2397 root (hd0,0)

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

2399 initrd /boot/frugal/rootfs.gz

2400 EOT

2401 else

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

2403 fi

2404 status

2405 echo "" ;;

2406

2407 emu-iso)

2408 # Emulate an ISO image with Qemu.

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

2410 iso=$2

2411 else

2412 iso=$DISTRO/$ISO_NAME.iso

2413 fi

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

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

2416 exit 0

2417 fi

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

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

2420 exit 0

2421 fi

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

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

2424 qemu $QEMU_OPTS $iso ;;

2425

2426 usage|*)

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

2428 #

2429 clear

2430 usage ;;

2431 esac

2432

2433 exit 0

SliTaz Repositories

tazlito view tazlito @ rev 198