[HD2 Android Q&A, Help & Troubleshooting and Genera] HypoTurtle:
Yea it's waiting for user input. I think if you run in while in the device shell rather than in command prompt "adb shell" so the script runs from # or from recovery terminal.

I added the wrong script earlier (there's only a few changes).

#!/sbin/sh
#set -u
set -o verbose
testing() {
busybox printf "%s\n" "TESTING MODE"
sdpart=/dev/block/mmcblk0p1
types="NAND DataOnExt NativeSD DirectSD porta-o "
optslist desc
if [ $# -gt 0 ]; then
typecheck=` echo "$types" | grep "$1 " `
if [ -z "${typecheck}" ]; then
echo "$1 is not a valid type - choices are $types"
echo "checking if $1 is a command"
optioncheck=` echo "$options" | grep "$1 " `
if [ -z "${optioncheck}" ]; then
busybox printf "%b\n" "${1} is not a valid option - choices are:"
for i in ${options}
do
opts="$i"
echo "$opts to $(eval echo \$$opts)"
done
echo "script stopping here"
exit 0
else
typecheck=` echo "$types" | grep "$2 " `
systemunzip=${5:-n}
if [ -n "${typecheck}" -a -n "${optioncheck}" ]; then
if echo ${2} | grep -q "porta"; then
systemunzip=${5:-y}
fi
type=${2}; ROM_NAME=${3}; data_NAME=${4:-$3}; install_type=` busybox expr index "Axvco" "${2}" `; systemunzip=${systemunzip}
printf "Install Type is $type\nRomName is $ROM_NAME\nDataName is $data_NAME\ninstall no is $install_type\nsystem install is $systemunzip\n"
optslist functs
if [ ${1} = "ins" ]; then
systemunzip=y
fi
eval "\$"${1} ${type} ${ROM_NAME} ${data_NAME:-$ROM_NAME} ${install_type} ${systemunzip}
else
printf "neither $1 or $2 is a valid install type"
fi
fi
else
systemunzip=${4:-n}
if echo ${1} | grep -q "porta"; then
systemunzip=${4:-y}
fi
type=${1}; ROM_NAME=${2}; data_NAME=${3:-$2}; install_type=` busybox expr index "Axvro" "${1}" `; systemunzip=${systemunzip}
runn ${type} ${ROM_NAME} ${data_NAME:-$ROM_NAME} ${install_type} ${systemunzip}
fi
else
printf "no commands sent to script\nchecking /sdcard/installtype.prop\n"
if [ ${checkprop:-false} = "false" ]; then
getpropfile
else
if [ ${userasked:-no} = "no" ]; then
echo "Requesting user input"

printf "Options are:\n"
for i in ${options};
do
opts="$i"
echo "$opts to $(eval echo \$$opts):"
done
printf "Enter an option if you want to do anything other than full script run:"
read optional

printf "Options are ${types}\nEnter install type:"
read type

ziplist=` ls /sdcard | grep .zip | cut -d "." -f "1" | tr '\n' ' ' `
printf "Possible options are: ${ziplist}\nEnter ROM-NAME:"
read ROM_NAME
printf "Leave blank to use ${ROM_NAME}\nEnter DATA-NAME:"
read data_NAME
printf "Do you want the script to install system y/n:"
read systemunzip
userasked=yes
testing ${optional:-runn} ${type} ${ROM_NAME} ${data_NAME:-$ROM_NAME} ${systemunzip}
else
echo "No conditions found or given\nNo installtype.prop on sdcard\nNo type or ROM name specified\nusage sh hytmb.sh {options} [type] [ROM_NAME]\ntype can be ${types}\nROM_NAME to be taken from ROM_NAMEadb123.zip"
for i in ${options}
do
opts="$i"
echo "$opts to $(eval echo \$$opts)"
done
exit 0
fi
fi
fi
}
optslist() {
options="m ins mr fb runn "
if [ $1 = "desc" ]; then
m="mount partitions"; ins="install system"; mr="modify the ramdisk"; fb="andthis"; runn="run full script"
else
m="mntstuff"; ins="installsystem"; mr="modifyramdisk"; fb="andthis"; runn="runn"
fi
}
cleanup() {
echo "cleaning"
rm -rf /tmp/zI.txt /tmp/bootimg.txt /tmp/umountloop.sh /tmp/6MB /tmp/initrd.gz
}
partnames() {
firstpart=/dev/block/mmcblk0p2
secondpart=/dev/block/mmcblk0p3
busybox printf "%b\n" "setting partitions with ` echo ${firstpart} | busybox cut -d "/" -f "4" ` format"
}
looppartnames() {
firstpart=/dev/block/loop1
secondpart=/dev/block/loop2
thirdpart=/dev/block/loop3
busybox printf "%b\n" "setting partitions with ` echo ${firstpart} | busybox cut -d "/" -f "4" ` format"
}
mkloopdev() {
echo "" >> /sdcard/porta.txt
fls=` cat /sdcard/porta.txt | busybox cut -d " " -f "1" `
syssize=` cat /sdcard/porta.txt | busybox cut -d " " -f "2" `
romsize=${romsize:-20000}
datasize=` cat /sdcard/porta.txt | busybox cut -d " " -f "3" `
#datasz=256000
datasz=20000
cachesize=` cat /sdcard/porta.txt | busybox cut -d " " -f "4" `
#cachesz=32000
cachesz=20000
if [ ! -f /sdcard/NativeSD/${ROM_NAME}_${type}/system.${fls:-ext4} ]; then
dd if=/dev/zero of=/sdcard/NativeSD/${ROM_NAME}_${type}/system.${fls:-ext4} bs=4096 count=${syssize:-$romsize}
newsys=yes
fi
if [ ! -f /sdcard/NativeSD/${ROM_NAME}_${type}/data.${fls:-ext4} ]; then
dd if=/dev/zero of=/sdcard/NativeSD/${ROM_NAME}_${type}/data.${fls:-ext4} bs=4096 count=${datasize:-$datasz}
newdata=yes
fi
if [ ! -f /sdcard/NativeSD/${ROM_NAME}_${type}/cache.${fls:-ext4} ]; then
dd if=/dev/zero of=/sdcard/NativeSD/${ROM_NAME}_${type}/cache.${fls:-ext4} bs=4096 count=${cachesize:-$cachesz}
newcache=yes
fi
losetup ${firstpart} /sdcard/NativeSD/${ROM_NAME}_${type}/system.${fls:-ext4}
losetup ${secondpart} /sdcard/NativeSD/${ROM_NAME}_${type}/data.${fls:-ext4}
losetup ${thirdpart} /sdcard/NativeSD/${ROM_NAME}_${type}/cache.${fls:-ext4}
if [ ${newsys:-no} = "yes" ]; then
mke2fs -T ${fls:-ext4} -O has_journal,ext_attr,resize_inode,filetype,extent,sparse_super,large_file,uninit_bg -I 256 ${firstpart}
fi
if [ ${newdata:-no} = "yes" ]; then
mke2fs -T ${fls:-ext4} -O has_journal,ext_attr,resize_inode,filetype,extent,sparse_super,large_file,uninit_bg -I 256 ${secondpart}
tune2fs -o journal_data_writeback ${secondpart}
fi
if [ ${newcache:-no} = "yes" ]; then
mke2fs -T ${fls:-ext4} -O has_journal,ext_attr,resize_inode,filetype,extent,sparse_super,large_file,uninit_bg -I 256 ${thirdpart}
tune2fs -o journal_data_writeback ${thirdpart}
fi
loopdevready=yes
}
getpropfile() {
checkprop=true
if [ -f "/tmp/installtype.prop" ]; then
echo "installtype.prop found"
testing "$(cat installtype.prop)"
else
echo "no prop file found - will need user input"
testing
fi

}
bootloadercheck() {
busybox printf "%b\n" "checking bootloader"
bootloader=MAGLDR
if grep -iq "clk" /proc/cmdline; then
bootloader=cLK
fi
if grep -iq "haret" /proc/cmdline; then
bootloader=haret
fi
####For testing
#bootloader=haret
}
bootloader() {
bootloader=MAGLDR
}
mkdirs() {
busybox printf "%b\n" "creating directories"
mkdir -p /NativeSD 2> /dev/null
mkdir -p /DirectSD 2> /dev/null
mkdir -p /boot_dir 2> /dev/null
mkdir -p /boot 2> /dev/null
mkdir -p /system 2> /dev/null
mkdir -p /data 2> /dev/null
mkdir -p /cache 2> /dev/null
mkdir -p /sdcard/NativeSD/"${2}"_"${1}" 2> /dev/null
}
mountpart() {
busybox printf "%s\n" "mounting files"
sdmounted=` mount | grep "${sdpart} on /sdcard" `
sdfile=` ls -la | grep "sdcard" `
if [ -z "${sdmounted:-$sdfile}" ]; then
mount -t auto ${sdpart} /sdcard
fi
if [ ${mountedalready:-nope} = "nope" ]; then
mount --bind /sdcard/NativeSD /boot_dir
mount --bind /sdcard/NativeSD/${2}_${1} /boot
mountedalready=yes
fi
if echo ${1} | grep -q porta; then
if [ ${loopdevready:-not} = "yes" ]; then
echo "loops ready to mount: ${loopdevready}"
mount ${firstpart} /system
mount ${secondpart} /data
mount ${thirdpart} /cache
printf "#!/sbin/sh\nlosetup -d ${firstpart}\nlosetup -d ${secondpart}\nlosetup -d ${thirdpart}\n" > /tmp/	umountloop.sh
fi
else
if [ -b "${firstpart}" ]; then
mount -t auto ${firstpart} /NativeSD
if [ ${1} = "NativeSD" -o ${1} = "DataOnExt" ]; then
mkdir -p /NativeSD/${2}/data 2> /dev/null
mount --bind /NativeSD/${3}/data /data
fi
if [ ${install_type} -gt '2' ]; then
mkdir -p /NativeSD/${2}/system 2> /dev/null
mount --bind /NativeSD/${2}/system /system
fi
fi
if [ -b "${secondpart}" ]; then
mount -t auto ${secondpart} /DirectSD
if [ ${1} = "DirectSD" ]; then
mkdir -p /DirectSD/${3}/data > /dev/null
mount --bind /DirectSD/${3}/data /data
fi
fi
fi
}
bootorig() {
busybox printf "%b\n" "saving original boot.img to boot-orig folder"
mkdir /boot_dir/boot-orig/
#chmod 0777 /tmp/dump_image
cd /tmp
./dump_image boot /boot/boot-orig/boot.img
cd /
}
systeminstall() {
#cp /tmp/inc.lst inc.lst > /dev/null
#cp /tmp/exc.lst exc.lst > /dev/null
local romzip=` ls /sdcard/${2}*.zip | busybox head -n1 `
busybox printf "Reading $romzip\n"
cd /
# rm -rf /system/*
local systemlocat=` mount | grep /system | busybox cut -d ' ' -f '1' `; local datalocat=` mount | grep /data | busybox cut -d ' ' -f '1' `
printf "system mounted at ... ${systemlocat}\ndata mounted at ... ${datalocat}\n"
if [ ${alreadyran:-no} = no ]; then
printf "ROM zip is found at ... ${romzip}\nDuplicating so the original remains untouched\nThis may take a while ...\n"
cp -rf ${romzip} /sdcard/${2}_${1}.zip
fi
chmod 0777 /tmp/7za
if [ -n "$systemlocat" ]; then
rm -rf /${2}_${1}
mkdir -p /${2}_${1}/META-INF/com/android/google/
echo META-INF/*aroma* > exc.lst
printf "initrd.gz\nzImage\nboot.img\n" > inc.lst
bootstuff=done
###### Including haret stuff ###
if [ ${bootloader} = "haret" ]; then
printf "haret.exe\nclrcad.exe\n" >> inc.lst
fi
/tmp/7za x /sdcard/${2}_${1}.zip META-INF -o/${2}_${1} '-xr@exc.lst' -y > /dev/null
/tmp/7za x /sdcard/${2}_${1}.zip '-ir@inc.lst' -o/inc -y > /dev/null
if [ ${5} = "y" ]; then
echo "installing system"
/tmp/7za x /sdcard/${2}_${1}.zip data -o/ -y > /dev/null
/tmp/7za x /sdcard/${2}_${1}.zip system -o/ -y > /dev/null
fi
local ubi=` find /${2}_${1} -name update-binary-installer -print0 `
local ub=` find /${2}_${1} -name update-binary -print0 `
local ups=` find /${2}_${1} -name updater-script -print0 `
echo "UBI location is ${ubi:-$ub} UPS is ${ups}"
cp /${ubi:-$ub} /${2}_${1}/META-INF/com/google/android/update-binary
printf "package_extract_file(\"multi\", \"/tmp/multi.sh\");\nset_perm(0, 0, 0777, \"/tmp/multi.sh\");\nrun_program(\"/tmp/multi.sh\", \"m\" \"${1}\" \"${2}\" \"${3}\")\n" > /${2}_${1}/META-INF/com/google/android/updater-script2
if [ ${5} = "y" ]; then
cat /$ups | busybox sed -e '/^symlink/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
else
printf "package_extract_dir(\"system\", \"/system\");\npackage_extract_dir(\"data\", \"/data\");\n" >> /${2}_${1}/META-INF/com/google/android/updater-script2
cat /$ups | busybox sed -e '/^symlink/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
fi
cat /$ups | busybox sed -e '/^set_perm/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
cat /$ups | busybox sed -e '/^setmetadata/,/);/!d' >> /${2}_${1}/META-INF/com/google/android/updater-script2
echo "modifying updater-script"
printf "unmount (\"/NativeSD\");\nunmount (\"/DirectSD\");\nunmount (\"/system\");\nunmount (\"/data\");\nunmount (\"/boot\");\nunmount (\"/boot_dir\");\n" >> /${2}_${1}/META-INF/com/google/android/updater-script2
if echo ${1} | grep -q porta; then
cp /tmp/umountloop.sh /${2}_${1}/umountloop.sh
printf "package_extract_file(\"umountloop.sh\", \"/tmp/umountloop.sh\");\nset_perm(0, 0, 0777, \"/tmp/multi.sh\");\nrun_program(\"/tmp/umountloop.sh\");\n" >> /${2}_${1}/META-INF/com/google/android/updater-script2
fi
cp /${2}_${1}/META-INF/com/google/android/updater-script2 /${2}_${1}/META-INF/com/google/android/updater-script
rm /${2}_${1}/META-INF/com/google/android/updater-script2; rm /${2}_${1}/META-INF/com/google/android/updater-script~
dd if=$0 of=/${2}_${1}/multi
/tmp/7za u /sdcard/${2}_${1}.zip /${2}_${1}/* > /dev/null
else
if echo ${type} | grep -q porta; then
echo "creating system, data and cache blocks on /sdcard first"
romsize=$((` /tmp/7za l /sdcard/${2}_${1}.zip | busybox tail -1 | busybox awk '{print $(NF-5)}' `/4096))
fls=` cat /sdcard/porta.txt | busybox cut -d " " -f "1" `
if [ ${5} = "y" ]; then
rm -rf /sdcard/NativeSD/${2}_${1}/system.${fls:-ext4}
fi
mntstuff "$@"
mt1=` blkid /sdcard/NativeSD/${2}_${1}/system.${fls:-ext4} | cut -d '"' -f '4' `
mt2=` blkid /sdcard/NativeSD/${2}_${1}/data.${fls:-ext4} | cut -d '"' -f '4' `
fi
if [ ${alreadyran:-no} != yes ]; then
alreadyran=yes
systeminstall "$@"
else
echo "system isn't mounted"
fi
fi
}
bootingred() {
busybox printf "%s\n" "obtaining an initrd.gz and zImage to work with"
local installsystem=` busybox find /sdcard -name *.zip | grep ${2} `
if [ -n "${installsystem}" -a ${bootstuff:-notdone} = "notdone" ]; then
local romzip=` ls /sdcard/${2}*.zip | busybox head -n1 `
cp -rf ${romzip} /sdcard/${2}_${1}.zip
chmod 0777 /tmp/7za
printf "initrd.gz\nzImage\nboot.img\n" > inc.lst
/tmp/7za x /sdcard/${2}_${1}.zip '-ir@inc.lst' -o/inc -y
rm -rf /sdcard/${2}_${1}.zip
###### Copying zImage and initrd.gz from /boot_dir when one wasn't in the zip
else
if [ ! -e "/tmp/boot.img" ]; then
local nandinitrd=` busybox find inc -name initrd.gz -print0 | busybox xargs -0 ls -s | busybox sort -nr | busybox awk '{print $(NF)}' | busybox tail -n 1 `
local zImagelocat=` busybox find /tmp -name zImage `
if [ -n "${zImagelocat}" ]; then
printf "%b\n" "zImage is at ... ${zImagelocat}"
cp ${zImagelocat} /tmp/zImage
fi
if [ -n "${nandinitrd}" ]; then
printf "%b\n" "nand ramdisk is at ... ${nandinitrd}"
cp ${nandinitrd} /tmp/initrd.gz
fi
else
chmod 0777 /tmp/unmkbootimg
cp /ramds/boot.img /tmp/boot.img
mkdir -p /tmp/boot 2> /dev/null
cd /tmp
./unmkbootimg /tmp/boot.img /tmp/boot
cd /
cp /tmp/boot/boot.img-ramdisk.gz /tmp/initrd.gz
cp /tmp/boot/boot.img-zImage /tmp/zImage
fi
fi
if [ ${runonce:-once} = "once" ]; then
if [ -f "/sdcard/zImage" ]; then
cp /sdcard/zImage /tmp/zImage
cp /sdcard/modules/* /system/lib/modules/ 2> /dev/null
fi
if [ -f "/sdcard/initrd.gz" ]; then
cp /sdcard/initrd.gz /tmp/initrd.gz
fi
local runonce=twice
if [ -f "/sdcard/useit/boot.img" ]; then
cp /sdcard/useit/boot.img /tmp/boot.img
bootstuff=notdone
bootingred "$@"
fi
fi
if [ ! -f "/tmp/initrd.gz" ]; then
echo "no ramdisk found - Exitting"
exit 0
fi
}
usecurrentboot() {
chmod 0777 /tmp/dump_image
cd /tmp
./dump_image boot /tmp/boot.img
./unpackbootimg /tmp/boot.img /tmp > /tmp/bootimg.txt
cd /
cp /tmp/boot.img-ramdisk.gz /tmp/initrd.gz
cp /tmp/boot.img-zImage /tmp/zImage
}
mkmountfsloop() {
if [ ${type} = "porta-o" ]; then
printf "#!/bin/busybox sh\n# mount\necho Mounting /proc\nmount -t proc proc /proc\necho Mounting /sys\nmount -t sysfs sys /sys\n# make devices\necho \"Making devices\"\nmkdir -m 0777 /dev/block\nmknod -m 0666 /dev/block/mmcblk0 b 179 0\nmknod -m 0666 /dev/block/mmcblk0p1 b 179 1\nmknod -m 0666 /dev/block/mmcblk0p2 b 179 2\nmknod -m 0666 /dev/block/mmcblk0p3 b 179 3\nmknod -m 0666 /dev/block/mmcblk0p4 b 179 4\nmkdir -m 0777 /dev/input\nmknod -m 0644 /dev/input/event0 c 13 64\nmknod -m 0644 /dev/input/event1 c 13 65\nmknod -m 0644 /dev/input/event2 c 13 66\nmknod -m 0644 /dev/input/event3 c 13 67\nmknod -m 0666 /dev/null c 1 3\nmknod -m 0444 /dev/zero c 1 5\nmknod -m 0644 /dev/ppp0 c 108 0\nmknod -m 0644 /dev/smd0 c 253 0\nmknod -m 0644 /dev/smd1 c 253 1\nwhile [ ! -b ${sdpart} ]; do\n/bin/busybox sleep 5\ndone\n/bin/busybox sleep 2\n/bin/e2fsck -p /sdcard/${ROM_NAME}/system.${fls:-ext4} > e2fsck.log\n/bin/e2fsck -p /sdcard/${ROM_NAME}/data.${fls:-ext4} >> e2fsck.log\n/bin/e2fsck -p /sdcard/${ROM_NAME}/cache.${fls:-ext4} >> e2fsck.log\nlosetup ${firstpart} /sdcard/${ROM_NAME}/system.${fls:-ext4}\nlosetup ${secondpart} /sdcard/${ROM_NAME}/data.${fls:-ext4}\nlosetup ${thirdpart} /sdcard/${ROM_NAME}/cache.${fls:-ext4}\n/bin/busybox mkdir /system\n/bin/busybox mkdir /data\n/bin/busybox mkdir /cache\n/bin/busybox mount ${firstpart} /system\n/bin/busybox mount ${secondpart} /data\n/bin/busybox mount ${thirdpart} /cache\n" > /tmp/mountfs-"${1}".sh
if [ ${fls:-ext4} = "ext4" ]; then
printf "tune2fs -O dir_index,has_journal,uninit_bg ${firstpart}\ntune2fs -O dir_index,has_journal,uninit_bg ${secondpart}\ntune2fs -O dir_index,has_journal,uninit_bg ${thirdpart}\n" >> /tmp/mountfs-"${1}".sh
else
printf "tune2fs -o journal_data_writeback ${secondpart}\ntune2fs -o journal_data_writeback ${thirdpart}\n" >> /tmp/mountfs-"${1}".sh
fi
printf "#by KAI 25.11.2011 always dual mount\necho /dev/block/mmcblk0 > /sys/devices/platform/usb_mass_storage/lun0/file\n# move init files to /system\ninit_files=\"init.rc init.htcleo.rc bootcomplete.htcleo.rc shutdown.htcleo.rc default.prop ueventd.rc\"\nfor init_file in \$init_files; do\nif [ -f /\$init_file ]; then\ncp -a /\$init_file /system/\$init_file\nfi\nif [ -f /system/\$init_file ]; then\n[ -f /\$init_file ] && rm -f /\$init_file\nln -s /system/\$init_file /\$init_file\nfi\ndone\n#cleanup - delete /bin to free ram\n/bin/busybox rm -rf /bin\n" >> /tmp/mountfs-"${1}".sh
fi
}
mkmountfs() {
busybox printf "%b\n" "creating mountfs.sh"
if [ ${4} -gt '1' ]; then
printf "#!/bin/busybox sh\nwhile [ ! -b ${firstpart} ]; do\n/bin/busybox sleep 5\ndone\n/bin/busybox sleep 2" > /tmp/mountfs-"${1}".sh
if [ ${1} = DirectSD ]; then
echo "Modifying for ${type}"
printf "while [ ! -b ${secondpart} ]; do\n/bin/busybox sleep 5\ndone\n/bin/busybox sleep 2" >> /tmp/mountfs-"${1}".sh
fi
mt1=` blkid ${firstpart} | cut -d '"' -f '4' `
mt2="${mt1}"
if [ ${mt1:-f2fs} = ext4 ]; then
printf "# check the ext4 fs\n/bin/e2fsck -p ${firstpart} > /e2fsck.log" >> /tmp/mountfs-"${1}".sh
else
printf "# check the f2fs fs\n/bin/fsck.f2fs -p ${firstpart} > /fsckf2fs.log" >> /tmp/mountfs-"${1}".sh
fi
if [ ${1} = DirectSD ]; then
if [ -b ${secondpart} ]; then
mt2=` blkid ${secondpart} | busybox cut -d '"' -f '4' `
else
echo "No 2nd ext partition present, format one and run script again"
fi
if [ ${mt2:-f2fs} = ext4 ]; then
printf "# check the ext4 fs\n/bin/e2fsck -p ${secondpart} > /e2fsck2.log\n" >> /tmp/mountfs-"${1}".sh
else
printf "# check the f2fs fs\n/bin/fsck.f2fs -p ${secondpart} > /fsckf2fs2.log\n" >> /tmp/mountfs-"${1}".sh
fi
fi
printf "/bin/busybox mkdir -p /NativeSD\n/bin/busybox mount -t ${mt1:-f2fs} -o noatime,nodiratime,barrier=0 ${firstpart} /NativeSD\n# mount the data dir\n" >> /tmp/mountfs-"${1}".sh
if [ ${1} = DataOnExt ]; then
echo "Modifying for ${1}"
printf "/bin/busybox mount --bind /NativeSD/${2}/data /data\n" >> /tmp/mountfs-"${1}".sh
fi
if [ ${4} -gt '2' ]; then
printf "/bin/busybox mount --bind /NativeSD/${2}/system /system\n" >> /tmp/mountfs-"${1}".sh
if [ ${1} = NativeSD ]; then
echo "Modifying for ${1}"
printf "/bin/busybox mount --bind /NativeSD/${3}/data /data\n" >> /tmp/mountfs-"${1}".sh
else
printf "/bin/busybox mkdir -p /DirectData\n/bin/busybox mount -t ${mt2:-f2fs} -o noatime,nodiratime,nosuid,nodev,discard ${secondpart} /DirectData\n/bin/busybox mount --bind /DirectData/${3}/data /data\n" >> /tmp/mountfs-"${1}".sh
fi
fi
printf "%b\n" "##/system/bin/logcat -d -f /sdcard/logcat.log *:V\n# cleanup deleting /bin to free ram\n## /bin/busybox rm -rf /bin\n" >> /tmp/mountfs-"${1}".sh
fi
}
mkinitrd() {
busybox printf "%b\n" "modifying ramdisk"
###### Setting up working directory
#cp /tmp/initrd.gz /tmp/initrd_"${2}".gz
mkdir -p /tmp/work
cd /tmp/work
cp /tmp/initrd.gz /tmp/initrd_o.gz
###### Unzipping nand kernel
gzip -d -c ../initrd.gz | busybox cpio -i -d
if [ ! -d bin ]; then
mkdir bin
fi
cp /tmp/busybox /tmp/work/bin/busybox
cp /tmp/e2fsck /tmp/work/bin/e2fsck
cp /tmp/mountfs-${1}.sh /tmp/work/mountfs-${1}.sh

if [ ${mt1:-f2fs} = f2fs -o ${mt2:-f2fs} = f2fs ]; then
busybox printf "%b\n" "copying fsck for f2fs"
cp /tmp/mkfs.f2fs /tmp/work/bin/mkfs.f2fs ; cp /tmp/mkfs.f2fs /system/bin/mkfs.f2fs
cp /tmp/fsck.f2fs /tmp/work/bin/fsck.f2fs ; cp /tmp/fsck.f2fs /system/bin/fsck.f2fs
chmod 0777 /tmp/work/bin/mkfs.f2fs; chmod 0777 /system/bin/mkfs.f2fs
chmod 0777 /tmp/work/bin/fsck.f2fs; chmod 0777 /system/bin/fsck.f2fs
fi
chmod 0777 /tmp/work/mountfs-${1}.sh
chmod 0777 /tmp/work/bin/busybox
chmod 0777 /tmp/work/bin/e2fsck

###### Modifying ramdisk to not use yaffs, and use sd partitions instead.
if [ "${4}" -gt '2' ]; then
busybox sed -i '/mtd@misc/s/^/#/' /tmp/work/ueventd.*.rc
busybox sed -i '/mount yaffs2/s/^/#/
s/# #/# /g' /tmp/work/*.rc
fi
###### Checking for anything other than nand is to be installed
if [ "${4}" -gt '1' ]; then
busybox sed -i "/on fs/ a exec /mountfs-${1}.sh" /tmp/work/*.rc
chmod 0750 /tmp/work/init*.rc
chmod 0644 /tmp/work/ueventd.*.rc
fi
###### Building new ramdisk
busybox find . | busybox cpio -o -H newc | gzip -9 > /tmp/initrd-done.gz
}
mkinitrdduo() {
mkdir -p /tmp/work/ing
mkdir -p /tmp/work/ramd
cd /tmp
./unpackbootimg /tmp/boot.img /tmp/work/
cd /tmp/work/ing
## Setting up working directory
cp /tmp/boot.img-ramdisk.gz /tmp/work/initrd.gz
## Unzipping nand kernel
gzip -d -c ../initrd.gz | busybox cpio -i -d
chmod 777 sbin
chmod 777 sbin/ramdisk.cpio
cp /tmp/work/ing/sbin/ramdisk.cpio /tmp/work/ramd
cd /tmp/work/ramd
busybox cpio -i -d < ramdisk.cpio
rm ramdisk.cpio
mkdir bin
cp /tmp/busybox bin/busybox
cp /tmp/e2fsck bin/e2fsck
cp /tmp/mountfs.sh /tmp/work/ramd/
chmod 0777 mountfs.sh
chmod 0777 bin/busybox
chmod 0777 bin/e2fsck
## Modifying ramdisk to not use fstab, and use mountfs.sh instead.
busybox sed -i '/mount_all/s/^/#/' init*.rc
busybox sed -i "s/rOm/$ROM_NAME/g" mountfs-${type}.sh
busybox sed -i '/on fs/ a exec /mountfs.sh' init*.rc
chmod 0750 init*.rc
busybox find .| busybox cpio -o -H newc > newramdisk.cpio
cp /tmp/ramd/newramdisk.cpio /tmp/work/ing/sbin/ramdisk.cpio
chmod 750 /tmp/work/ing/sbin/ramdisk.cpio
chmod 750 /tmp/work/ing/sbin
cd /tmp/work/ing
# Building new ramdisk
busybox find .| busybox cpio -o -H newc | gzip -9 > ../boot.img-ramd.gz
cd /
}
initrdcp() {
busybox printf "%b\n" "copying ramdisk"
###### Checking bootloader
if [ ${bootloader} != cLK ]; then
###### Checking zImage type
if [ -f /tmp/zImage ]; then
`hexdump /tmp/zImage | grep '1f 8b 08'` > /tmp/zI.txt
if grep -q 00003f80 "/tmp/zI.txt"; then
dd if=/dev/zero of=/tmp/6MB bs=1M count=6
fi
fi
cat /tmp/initrd-done.gz >> /tmp/6MB; cp /tmp/6MB /tmp/initrd.gz
else
cp /tmp/initrd-done.gz /tmp/initrd.gz
fi
cp /tmp/initrd.gz /boot/initrd.gz; cp /tmp/zImage /boot/zImage; cp /tmp/initrd.gz /boot_dir/initrd.gz; cp /tmp/zImage /boot_dir/zImage
}
bootflash() {
busybox printf "%b\n" "flashing boot"
chmod 0755 /tmp/mkbootimg
base=` cat /tmp/boot.img-base `
base=${base:-0x11800000}
cd /tmp
./mkbootimg --base "${base}" --cmdline "`cat /tmp/boot.img-cmdline`" --kernel /boot/zImage --ramdisk /boot/initrd.gz -o /tmp/boot.img
cd /
cp /tmp/boot.img /boot_dir/boot.img
if [ ${install_type} -gt '2' ] && [ -b /sboot ]; then
boot=sboot
else
boot=boot
fi
chmod 0777 /tmp/flash_image
cd /tmp
./flash_image "${boot}" /tmp/boot.img
cd /
}
revertinitrd() {
busybox printf "%b\n" "reverting ramdisk in /tmp"
cp /tmp/initrd_o.gz /tmp/initrd.gz
}
showresult() {
busybox printf "Ramdisk successfully modified for ${ROM_NAME} running as ${type}\non ${mt1:-f2fs} with data on ${mt2:-f2fs}\nThe install folder is ${2}_${1}\n"
if [ -f /tmp/zI.txt ]; then
if grep -q 00003f80 /tmp/zI.txt; then
busybox printf "%b\n" "Kernel is a 3.0.x kernel"
else
busybox printf "%b\n" "Kernel is a 2.x kernel"
fi
fi
if [ -f /sdcard/${2}_${1}.zip ]; then
busybox printf "%b\n" "Please flash ${2}_${1}.zip in recovery"
fi
}
exiterr() {
echo "command failed" ; exit 1;
}
runn() {
bootloadercheck || exiterr
mntstuff "$@"
if [ "${bootloader}" = cLK ]; then
bootorig || exiterr
fi
installsystem=` busybox find /sdcard -name *.zip | grep ${2}`
if [ -n "${installsystem}" ]; then
systeminstall "$@" || exiterr
fi
if [ "$bootloader" = "haret" ]; then
###not sure on this ###
haretstuff < clrcad.exe haret.exe || exiterr
fi
if [ ! -f /tmp/initrd.gz ]; then
bootingred "$@" || exiterr
fi
mkmountcheck "$@"
mkinitrd "$@" || exiterr
initrdcp || exiterr
if [ ${bootloader} = cLK ]; then
bootflash
fi
# revertinitrd || exiterr
showresult "$@" || exiterr
}
mkmountcheck() {
if [ ! -f /tmp/mountfs-"${1}".sh ]; then
echo "making mountfs.sh for $type"
if echo ${1} | grep -q porta; then
mkmountfsloop "$@" || exiterr
else
mkmountfs "$@" || exiterr
fi
fi
}
mntstuff() {
mkdirs $@
if echo ${1} | grep -q "porta"; then
looppartnames $@
mkloopdev $@
else
partnames $@
fi
if [ ${1} != "NAND" ]; then
mountpart $@
fi
}
modifyramdisk() {
if grep -q Ubuntu /proc/version; then
bootloader
else
bootloadercheck
fi
mntstuff $@
bootingred $@
mkmountcheck $@
mkinitrd $@
initrdcp $@
}
flashbootpart() {
bootingred $@
bootflash $@
}
findit() {
busybox find $1 -name $2
}
remtxt() {
rmfile=` cat /tmp/removerc.txt | busybox awk '{print $(NF)}' `
startrm=` cat /tmp/removerc.txt | busybox awk '{print $(NF-1)}' `
endrm=` cat /tmp/removerc.txt | busybox awk '{print $(NF-2)}' `
grep -lrIZ $p $currdir/$rmfile | busybox xargs -0 busybox sed --in-place "/$startrm/,/$endrm/d"
}
haretstuff() {
for i in $@; do zz=`findit inc $i`; sdsd=`findit tmp $i`
hrtstff=${zz:-$sdsd}
if [ -n ${hrtstff} ]; then
cp ${hrtstff} /boot_dir
fi
done
printf "set mtype 2524\nset ramaddr 0x11800000\nset ramsize 0x1e400000\nset initrd_offset 0x00a00000\nset KERNEL zImage\nset initrd initrd.gz\nset cmdline \"rel_path=NativeSD bootloader=haret\"\nboot\n" > /boot_dir/startup.txt
bootloader=MAGLDR
}
redir() {
if [ $# -gt 0 ]; then
nil="> /dev/null"; err="2> /dev/null"; logg=">> /tmp/` echo ${0} | busybox cut -d \".\" -f \"1\" `run.log"
eval ${1}
fi
}
installsystem() {
systeminstall ${@}
}
umountstuff() {
if [ ${alreadyranums:-no} = "no" ]; then
if echo ${@} | grep -q "porta"; then
umount /data
umount /system
umount /cache
looppartnames
losetup -d ${firstpart}
losetup -d ${secondpart}
losetup -d ${thirdpart}
alreadyranums=yes
fi
else
if [ ${systemunzip} != "y" ]; then
umount /boot
umount /boot_dir
umount /NativeSD
umount /DirectData
umount /system
umount /data
umount /cache
if echo ${type} | grep -q "porta"; then
losetup -d ${firstpart}
losetup -d ${secondpart}
losetup -d ${thirdpart}
fi
fi
fi
}
desktopcheck() {
if [ ${alreadyrandc:-no} = "no" ]; then
if grep -q Ubuntu /proc/version; then
ln -s ${currdir}/sdcard /
ln -s ${currdir}/tmp /
else
mkdir /tmp
fi
alreadyrandc=yes
else
if grep -q Ubuntu /proc/version; then
rm -rf /tmp/work/*
rm -rf /sdcard
fi
fi
}
currdir=$(pwd)
cd /
desktopcheck
cleanup "$@"
chmod 0777 /sdcard/bins/*
cp /sdcard/bins/* /tmp
umountstuff "$@"
testing "$@"
umountstuff "$@"
desktopcheck
exit 0

Edit are you sure you have the ROM_NAME right, the rom zip check which launches the systeminstall function was working earlier.

(I see your calling it Pixeldroid_4 when before it was Pixeldroid_LIQUID_4.4 - have you renamed the zip or is this a typo).

Just to list all the input methods implemented in processed order.

1. Command line arguments passed when running the script.

2. installtype.prop added to /sdcard/bins folder.

3. Asked for each argument individually in the shell.

Script is run:

multi {opts} {TYPE} {ROMNAME} {DATANAME} {SYSTEMUNZIP}

opts being mounting, modifying ramdisk, running fullscript, (and installing system)

with opts defaulting to run full script, DATANAME defaulting to ROMNAME, SYSTEMUNZIP defaulting to no (yes for porta-*)