path: root/packages/altboot/files/altboot.func

#! /bin/sh

C_RED="\033[31m"
C_YELLOW="\033[35m"
C_BLUE="\033[34m"
C_WHITE="\033[38m"
C_RESET="\033[0m"


# This function checks for the presence of a real filesystem and loop-images on the target
# $1 = folder of rootfs, $2 = runlevel (defaults to 5)
# $2 = name of calling module
check_target() {
	# Check if there is a /sbin/init or /sbin/init.sysvinit on the card
	if test -x $1/sbin/init -o -x $1/$REAL_INIT
	then
		real_fs_found=1
	else
		echo -e "Note: No INIT [$REAL_INIT] found on target"
	fi
	
	# Check for loop-images
	if (ls $1/$IMAGE_PATH/*rootfs.bin) >/dev/null 2>&1
	then
		image_found=1
	else
		echo "Note: No boot-images found in [$1/$IMAGE_PATH]"
	fi
	
	# Check if we have both, a real fs and boot-images. If so, ask the user what to boot
	if test "$real_fs_found" = 1 -a "$image_found" = 1
	then
		echo -e "\nI have found a real filesystem and boot-images on the target"
		echo -e "What do you want to boot?\n"
		
		echo -e "\t[1] The real filesystem"
		echo -e "\t[2] A loop-image"
		echo ""
		
		while test -z "$ans"
		do
			echo -n "Your choice: "
			
			if test "$AUTOBOOT" != "yes"
			then
				read junk < "$OUT_TTY"
			else
				if test -e /etc/.altboot-real-or-loop.last
				then
					junk="`cat /etc/.altboot-real-or-loop.last`"
					test -z "$junk" && read junk < "$OUT_TTY" || echo "$junk (autoboot)"
				else
					read junk < "$OUT_TTY"
				fi
			fi	
			
			if test "$junk" = 1 -o "$junk" = 2
			then
				ans="$junk"
				echo "$junk" > /etc/.altboot-real-or-loop.last
			fi
		done
		
		case "$ans" in
		1)	pivot_realfs "$1" "$2">"$OUT_TTY";;
		2)	pivot_image "$1" "$2">"$OUT_TTY";;
		esac
				
		exit 0
	fi

	# Boot a real filesystem	
	test "$real_fs_found" = 1 && pivot_realfs "$1" >"$OUT_TTY"
	
	# Boot a loop-image
	test "$image_found" = 1 && pivot_image "$1" >"$OUT_TTY"
		
	if test "$real_fs_found" != 1 -a "$image_found" != 1
	then
		mdie "No direct-install or loop-images found. Nothing to do!"
	fi
}

boot_new_rootfs_splash() {
C_RED="\033[37;44m"
C_RESET="\033[0m"

	echo -e "${C_RED}+----------------------------------------------------------+${C_RESET}"
	echo -e "${C_RED}|                                                          |${C_RESET}"
	echo -e "${C_RED}|               Booting the selected rootfs...             |${C_RESET}"
	echo -e "${C_RED}|                                                          |${C_RESET}"
	echo -e "${C_RED}+----------------------------------------------------------+${C_RESET}"	

}

# This function pivot_root's into a real filesystem calling $newrootfs/sbin/init
# $1 = The new rootfs
pivot_realfs() {
	#test -z "$2" && RL="5" || RL="$2"
	mkdir -p $1/media/ROM || die "mkdir -p $1/media/ROM failed"

	mount -o remount,ro / >/dev/null 2>&1

	test "$ENABLE_IMAGECONF" = yes && image_conf $1

	do_pivot "$1" "$RL"
}

# This function loop-mounts an image-file and pivot_root's into it
# $1: The new rootfs
pivot_image() {
	#test -z "$2" && RL="5" || RL="$2"
	cd $1/$IMAGE_PATH

	# Check for rootfs images on the card
	if test "`ls *rootfs.bin | wc -l | tr -d " "`" -gt 1
	then
		echo -e "\n\nPlease select a rootfs:\n"

		# Show all available images
		x=0
		for file in `ls *rootfs.bin`
		do
			let x=$x+1
			echo -e "\t\t[$x] $file"
		done

		echo ""			

		IMAGE_NAME=""
		while test -z "$IMAGE_NAME"
		do
			echo -en "Please choose one of the above: "
			if test "$AUTOBOOT" != "yes"
			then
				read junk < "$OUT_TTY"
			else
				if test -e /etc/.altboot-loopimage.last
				then
					junk="`cat /etc/.altboot-loopimage.last`"
					test -z "$junk" && read junk < "$OUT_TTY" || echo "$junk (autoboot)"
				else
					read junk < "$OUT_TTY"
				fi
			fi	

			x=0
			for file in `ls *rootfs.bin`
			do
				let x=$x+1
				if test "$x" = "$junk"
				then
					IMAGE_NAME="$file"
					echo "$junk" > /etc/.altboot-loopimage.last						
				fi
			done	
		done
	else
		IMAGE_NAME="`ls *rootfs.bin`"		
		test -z "$IMAGE_NAME" && die "No rootfs found (*rootfs.bin) in $1/$IMAGE_PATH"
	fi
	
	
	echo ""

	mkdir -p /media/image || die "mkdir -p /media/image failed"

	losetup /dev/loop0 $1/$IMAGE_PATH/$IMAGE_NAME || die "losetup /dev/loop0 $1/$IMAGE_PATH/$IMAGE_NAME failed!"
	check_fs /dev/loop0 $IMAGE_TYPE
	
	echo -e "\n* * * Mounting rootfs image * * *\n"

	# Busybox's "mount" doesn't seem to like "-o loop" for some reason
	# It works on collie and b0rks on poodle.
	if [ "$IMAGE_TYPE" = "" ]; then
		IMAGE_TYPE="auto"
	fi
	
	# If mount fails it has the tendency to spew out a _lot_ of error messages.
	# We direct the output to /dev/null so the user can see which step actually failed.	
	mount /dev/loop0 -t $IMAGE_TYPE /media/image >/dev/null 2>&1 || die "mount -t $IMAGE_TYPE /dev/loop0 /media/image failed!"	

	mkdir -p /media/image/media/ROM || die "mkdir -p /media/image/media/ROM failed"

	test "$ENABLE_IMAGECONF" = yes && image_conf /media/image
	
	do_pivot /media/image "$RL"
}

#$1=mountpoint of the soon-to-be rootfs, $2=Runlevel
do_pivot(){	

	if test "$USE_KEXEC_ON_NEXT_BOOT" = yes
	then
		if test -e "$KEXEC_SELECTED_KERNEL.kexec.cfg"
		then
			CMDLINE="--append=\"`cat $KEXEC_SELECTED_KERNEL.kexec.cfg`\""
		else
			CMDLINE=""
			echo "WARNING: This kernel has not been configured!"
			echo "Trying to boot anyway..."
		fi
		
		echo "$KEXEC_BIN -l $KEXEC_SELECTED_KERNEL $CMDLINE"
		$KEXEC_BIN -l $KEXEC_SELECTED_KERNEL $CMDLINE
		sync
		
		read junk
		$KEXEC_BIN -e
		exit 0
	fi	


	echo -n "Pivoting root..."
	if (/sbin/pivot_root "$1" "$1/media/ROM") 
	then
		echo "Success"

		# This is important since we are still cd'ed into the old root
		cd /
		
		! test -d "$1" && mkdir -p "$1"
		
		# Move mountpoints from the old rootfs into the new one.
		# The *real* mount is kinda touchy feely about that
 		/bin/busybox mount -o move /media/ROM/proc /proc >/dev/null 2>&1

		for mpt in ` mount | grep "/media/ROM/" | awk '{print $3}'`
		do
			new_mpt="`echo "$mpt" | sed -n "s/\/media\/ROM//p"`"
			
			echo "Moving mountpoint [$mpt] -> [$new_mpt]" >"$OUT_TTY" 2>&1
			
			! test -d "$new_mpt" && mkdir -p "$new_mpt" 
			/bin/busybox mount -o move "$mpt" "$new_mpt"
		done

		clear		
		boot_new_rootfs_splash		
		echo "Calling INIT"
			
		exec /usr/sbin/chroot . $REAL_INIT $2 >"$OUT_TTY" 2>&1
		#exec /usr/sbin/chroot . /sbin/init $2 >/dev/tty0 2>&1
	else
		echo "FAILED"
		die "* * * pivot_root failed! * * *" 
	fi

}

# $1: Path to mounted rootfs
image_conf(){
	! test -d "$1" && die "image_conf: [$1] not found / no directory"	
	
	test -e "$1/etc/.image_conf.done" && return
	
	echo -e "\n\n* * * rootfs configuration * * *\n"
	echo -e "This setup lets you reconfigure your new rootfs."
	echo "Most probably the rootfs is configured with"
	echo "defaults based on a flash installation."
	echo "If unsure, go with the defaults by pressing <ENTER>."
	echo ""
	
	if ( cat $1/etc/fstab | grep -v "^#" | grep -q "/home " )		
	then						
		while true
		do
			echo "Usually your /home directory is located on another flash partition."
			echo -n "Do you want me to move /home inside the loop-image? [N|y] "
			read junk
			
			if test "$junk" = "y" -o "$junk" = "Y"
			then
			 	cat $1/etc/fstab | sed "/.*\/home.*/s/\/home/\/home.flash/" > $1/etc/fstab_
				mv $1/etc/fstab_ $1/etc/fstab

				mkdir -p $1/home.flash
				break
			fi
			
			test "$junk" = "" -o "$junk" = n -o "$junk" = N && break
		done
		
	fi		
				
	echo ""

	if ( cat $1/etc/ipkg.conf | grep -q ^lists_dir )		
	then						
		while true
		do
			echo -e "Wasting RAM is never a good idea.\nOnly say Y if your rootfs is very small in size"
			echo -en "Do you want to store ipkg package data\nin RAM? [N|y] "
			read junk
			
			if test "$junk" = "" -o "$junk" = n -o "$junk" = N
			then
				cat $1/etc/ipkg.conf | sed "/^lists_dir.*/s/\(.*\)/#\ \1/"> $1/etc/ipkg.conf_			 	
				mv $1/etc/ipkg.conf_ $1/etc/ipkg.conf
				break
			fi
			
			test "$junk" = "y" -o "$junk" = "Y" && break
		done
	fi		

	echo ""

	if ( cat $1/etc/ipkg.conf | grep -q "^dest sd" )		
	then						
		while true
		do
			echo -en "Do you want to keep the SD, CF and /home\nipkg install targets? [N|y] "
			read junk
			
			if test "$junk" = "" -o "$junk" = n -o "$junk" = N
			then
				cat $1/etc/ipkg.conf | sed "/^dest\ \(sd\|cf\|home\).*/s/\(.*\)/#\ \1/"	> $1/etc/ipkg.conf_		 	
				mv $1/etc/ipkg.conf_ $1/etc/ipkg.conf
				break
			fi
			
			test "$junk" = "y" -o "$junk" = "Y" && break
		done
	fi	
		
	
	touch "$1/etc/.image_conf.done"	
}

# This functions configures the master password for altboot if none is set
set_password() {
	mount -o remount,rw /
	if test -z "$MASTER_PASSWORD" -a "$ENABLE_DEBUG" != yes
	then
		echo -e "\nAltboot is a boot-manager which allows to boot from SD,\nCF, USB-Storage and NFS"
		echo -e "\nFor security reasons altboot requires a password\nto boot into init=/bin/sh."
		echo -e "${C_RED}This is *not* your root password!\nIt is used by altboot alone!${C_RESET}\n"

		while true
		do
			echo -en "\nNew password: "

			stty -echo <"$OUT_TTY" >"$OUT_TTY" 2>&1
			read junk1 < "$OUT_TTY"
			stty echo <"$OUT_TTY" >"$OUT_TTY" 2>&1

			if ! test -z "$junk1"
			then
				echo -en "\nRepeat: "
				
				stty -echo <"$OUT_TTY" >"$OUT_TTY" 2>&1
				read junk2  < "$OUT_TTY"
				stty echo <"$OUT_TTY" >"$OUT_TTY" 2>&1
				echo ""
				
				if test "$junk1" = "$junk2"
				then
					crypt_pw="`echo "$junk1" | md5sum | awk '{print $1}'`"
					
					if test -e "${ALTBOOT_CFG_FILE}"
					then
						sed "/^MASTER_PASSWORD/s/\(.*\=\).*/\1\"$crypt_pw\"/" "${ALTBOOT_CFG_FILE}" > ${ALTBOOT_CFG_FILE}_
						mv ${ALTBOOT_CFG_FILE}_ ${ALTBOOT_CFG_FILE}
						MASTER_PASSWORD="$crypt_pw"
						echo "Password changed."
					else
						echo "${ALTBOOT_CFG_FILE} is missing, no password saved"
					fi
					
					break
				else
					echo -e "Passwords didn't match, try again\n"
				fi
			fi	
		done
	fi
	
}

# This function asks for altboots master password. It only returns if the correct password was supplied
verify_master_pw() {
	if ! test -z "$MASTER_PASSWORD"
	then
		auth_timeout="3"

		echo -e "\nPlease enter your altboot master password"

		cnt=0
		while true
		do
			let cnt=$cnt+$auth_timeout
			echo -n "Password: "
			stty -echo  <"$OUT_TTY" >"$OUT_TTY" 2>&1
			read junk < "$OUT_TTY"
			stty echo  <"$OUT_TTY" >"$OUT_TTY" 2>&1

			if test "`echo "$junk" | md5sum | awk '{print $1}'`" = "$MASTER_PASSWORD"
			then
				break
			else
				echo "[`echo "$junk" | md5sum | awk '{print $1}'`]"
				echo "[$MASTER_PASSWORD]"
				echo "Wrong password, sleeping $cnt seconds..."
				sleep $cnt

#				if test "$cnt" -gt 10
#				then
#					break
#				fi
			fi
		done
		
		echo ""
	fi
}


check_fs() {
	if [ "$FSCK_IMAGES" = "yes" ]
	then
                FSCK=""
		if [ "$2" = "" ]; then
			FSTYPE="ext2"
		else
			FSTYPE="$2"
		fi
		case "$FSTYPE" in
		ext2 | ext3)
	        	if [ -e /sbin/fsck.ext3 ]; then
		       		FSCK="/sbin/fsck.ext3"
			elif [ -e /sbin/e3fsck ]; then
		       		FSCK="/sbin/e3fsck"
			elif [ -e /sbin/fsck.ext2 ]; then
		       		FSCK="/sbin/fsck.ext2"
			elif [ -e /sbin/e2fsck ]; then
		       		FSCK="/sbin/e2fsck"
			fi
			test -n "$FSCK" && FSCK="$FSCK -p"
		;;
		vfat)
		    if [ -e /sbin/dosfsck ]; then
			FSCK="/sbin/dosfsck -a"
		    fi
		;;
		esac
		if [ "$FSCK" = "" ]; then
		        echo "Could not find fsck for $FSTYPE!"
		else
			echo "Checking file system on $1"
			$FSCK $1 || sleep 2
		fi
	fi
}

# Make the initial rootfs a bit more usable
init_rootfs(){
#	echo -n "Mounting rootfs rw..." 
	mount -o remount,rw / || die "mount -o remount,rw / failed"

	mount | grep -q "/proc " >/dev/null 2>&1 || mount proc -t proc /proc >"$OUT_TTY" 2>&1
	
	if ( uname -r | grep -q "2.6." )
	then
		mount | grep -q "/sys " >/dev/null 2>&1 || mount sys -t sysfs /sys >"$OUT_TTY" 2>&1
	fi
		
	/etc/init.d/devices start || die "FAILED"
}

mount_sd(){
	if mount | grep -q "/media/card"
	then
		echo "Note: /media/card is already mounted"
	else
		# We can't trust that the SD device file is there when running kernel 2.6 w/ udev
		# and starting udev at this point may not be the best idea...	
		if `uname -r | grep -q "2.6"`
		then
			#Let's just assume the device file name never changes...
			dev_no="`echo "$SD_DEVICE" | sed -n "s/\/dev\/mmcblk\(.*\)p\(.*\)/\1/p"`"
			part_no="`echo "$SD_DEVICE" | sed -n "s/\/dev\/mmcblk\(.*\)p\(.*\)/\2/p"`"
			! test -e /dev/mmcblk${dev_no} && mknod /dev/mmcblk${dev_no} b 254 0
			! test -e /dev/mmcblk${dev_no}p${part_no} && mknod /dev/mmcblk${dev_no}p${part_no} b 254 $part_no				
		fi

		# Kernel 2.6 has the SD driver compiled into the kernel
		if test -n "$SD_KERNEL_MODULE"	
		then
			echo -n "Loading SD kernel module..."
			/sbin/insmod $SD_KERNEL_MODULE >/dev/null 2>&1 && echo ok || die "insmod failed"
		fi
		
		check_fs "$SD_DEVICE"

		echo -n "Mounting $SD_MOUNTPOINT..."  >"$OUT_TTY"
		
		if test "$1" = ingore_errors
		then
			/bin/mount -t auto -o defaults,noatime $SD_DEVICE $SD_MOUNTPOINT >/dev/null 2>&1 && echo ok  >"$OUT_TTY" || echo "Could not mount SD card"
		else
			/bin/mount -t auto -o defaults,noatime $SD_DEVICE $SD_MOUNTPOINT >/dev/null 2>&1 && echo ok  >"$OUT_TTY"|| die "/bin/mount -t auto -o defaults,noatime $SD_DEVICE $SD_MOUNTPOINT failed"
		fi		
	fi
	echo ""	
	
	  # Give the SD and CF mounting some time. This is a must for SD			
	  sleep 2	
}

mount_cf(){
	if mount | grep -q "/media/cf "
	then
		echo "Note: /media/cf is already mounted"
	else	
		if ( cat /etc/fstab | grep -v "^#" | grep -q "/media/cf" )
		then
			# As of kernel 2.6.16, /e/i/pcmcia is replaced by udev
			if test -x /etc/init.d/pcmcia
			then
				/etc/init.d/pcmcia status | grep -q running || /etc/init.d/pcmcia start && echo "Note: cardmgr is already active"
			else
				for n in 1 2 3
				do
					! test -e "/dev/hda$n" && mknod /dev/hda$n b 3 $n
				done
			fi			

			# Give the SD and CF mounting some time. This is a must for SD			
			sleep 2

			mount /media/cf -o async
		else
			echo "Note: Your system's fstab does not include an entry for /media/cf"
		fi
	fi
}

mount_home(){
	if mount | grep -q "/home "
	then
		echo "Note: /home is already mounted"
	else

		if ( cat /etc/fstab | grep -v "^#" | grep -q "/home " )
		then
			echo "Mounting /home"
			home_fstab="`grep "/home " /etc/fstab`"
			home_dev="`echo "$home_fstab" | awk '{print $1}'`"
			home_fs="`echo "$home_fstab" | awk '{print $3}'`"		
			home_options="`echo "$home_fstab" | awk '{print $4}'`"

			mount -t "$home_fs" -o $home_options "$home_dev" /home
		else
			echo "Note: Your system's fstab does not include an entry for /home"
		fi
	fi
}

show_menu() {	
	
	echo -e "\nPress <ENTER> to return to the menu"
	read junk
	
	test "$junk" = x && exec /bin/sh || exec /sbin/init.altboot -force<"$OUT_TTY" >"$OUT_TTY" 2>&1
}

mdie() {
	echo -e "${C_RED}ERROR:${C_RESET}${C_WHITE} $1${C_RESET}" >"$OUT_TTY"
	
	echo -e "\nPress <ENTER> to return to the menu"
	read junk
	
	test "$junk" = x && exec /bin/sh || exec /sbin/init.altboot -force<"$OUT_TTY" >"$OUT_TTY" 2>&1
}

# $1: uniq name, $2 identifier, $3 value
set_pref() {
	data_name="$1"
	data_id="$2"
	data_value="$3"
	
	#debug_echo "[$1] [$2] [$3]"
	#export "${data_name}"="`eval echo -e \\$${data_name} | sed "s/\#\#\#/\#\#\#\\n/g"|sed s/^\ // | sed s/^$data_id.*//`"

	if test -z "$3"
	then
		debug_echo "set_pref(): WARNING, writing empty value to $data_name / $data_id! THIS WILL BREAK THINGS"
		#data_value=" "
	fi
	export "${data_name}"="`eval echo -e \\$${data_name} `$data_id##$data_value###"		
}

# $1: uniq name
reset_pref() {
	data_name="$1"
	export "${data_name}"=""	
}

echo_pref() {
	data_name="$1"
	echo "****** $1 ******"
	echo "`eval echo -e \\$${data_name} | sed "s/\#\#\#/\#\#\#\\n/g"|sed s/^\ // `"
	echo "******"
}

dump_pref() {
	data_name="$1"	
	echo "`eval echo -e \\$${data_name} | sed "s/\#\#\#/\#\#\#\\n/g"|sed s/^\ // `"
	
	#echo "-- `eval echo ${data_name}` --" 
	#debug_echo "[$menu_fileflags]"
}

# $1 = name, $2 = cache_file
export_pref() {
	data_name="$1"
	echo "`eval echo -e ${data_name}`" > "$2"
}

# $1 = name, $2 = cache_file
import_pref() {
	data_name="$1"
	data_id="$2"
	
	#debug_echo "[$1] [$2] [$3]"

	if test -z "$3"
	then
		debug_echo "set_pref(): WARNING, writing empty value to $data_name / $data_id! THIS WILL BREAK THINGS"
		#data_value=" "
	fi
	export "${data_name}"="`cat "$2"`"		

}

# $1: uniq name, $2 identifier, $3 out var
get_pref() {
	data_name="$1"
	data_id="$2"
	data_out="$3"
	data_list="`eval echo -e \\$${data_name}`"
	
	#echo "data_list: [$data_list]"
	#data_value="`echo "$data_list"| sed "s/\#\#\#/\\n/g"|sed s/^\ // | grep "^$data_id##" | sed -n "s/.*\#\(.*\)$/\1/p"`"
	#data_value="`echo "$data_list"| sed "s/\#\#\#/\\n/g"|sed s/^\ // |  sed -n "/^$data_id/s/.*\#\(.*\)$/\1/p"`"
	data_value="`echo "$data_list"| sed "s/\#\#\#/\\n/g" | sed -n "s/^\ //;/^$data_id\#/s/.*\#\(.*\)$/\1/p"`"
	#echo "WERT: [$data_value]"
	
	export "${data_out}"="$data_value"
	test -n "$data_value" && return 0
}

debug_echo() {
	test "$ENABLE_DEBUG" = "yes" && echo -e "${C_YELLOW}DEBUG:${C_RESET}${C_WHITE} $1 ${C_RESET}" >"$OUT_TTY" 2>&1
}

start_networking() {

	test -z "$1" && mdie "No remote host configured, check /etc/fstab for NFS hosts"
	
	if test "$USB_NETWORKING_AVAILABLE" = "yes"
	then
		echo ""
		echo "Select the type of your network connection:"
		echo ""
		echo -e "\t[1] LAN or WLAN NIC"
		echo -e "\t[2] USB Connection"
		echo ""
		
		if test "$AUTOBOOT" != "yes" -o ! -e /etc/.altboot-lanselect.last
		then
			while true
			do
				echo -n "Connection Type: "
				read junk
				
				test "$junk" = 1 -o "$junk" = 2 && break
			done
		else
			junk="`cat /etc/.altboot-lanselect.last`"
			test -z "$junk" && junk=1
			
			echo "Connection Type: $junk (autoboot)"
		fi
			
		case "$junk" in
		1)	NW_TYPE="NIC"
			;;
		2)	NW_TYPE="USB"
			;;
		esac
		
		echo "$junk" > /etc/.altboot-lanselect.last
	else
		NW_TYPE=NIC
	fi


	
	# Needed for NFS
	/etc/init.d/portmap start >/dev/null 2>&1 || die "/etc/init.d/portmap start failed!"
	
	# For some reason NFS mounts hang if /e/i/networking is not run.
	# For the time beeing I'm too lazy to investigate ;)
	/etc/init.d/networking start >/dev/null 2>&1 || die "/etc/init.d/networking start failed!"
	
	sleep 2

	if test "$NW_TYPE" = "NIC"
	then	
		# After the PCMCIA service is started, an inserted WLAN card should automatically
		# activate itself.

		if test -x /etc/init.d/pcmcia
		then
			echo -e "\nRunning cardctl to setup networking..."
			/etc/init.d/pcmcia start >/dev/null 2>&1 || die "/etc/init.d/pcmcia start failed!"
			sleep 3
		else	
			# With kernel 2.6.16+ udev is used 
			echo -e "\nRunning udevd to setup networking..."
			ps ax | grep -v grep | grep -q udevd || /etc/init.d/udev start >/dev/null 2>&1 || die "/etc/init.d/udev start failed!"

			# Stop udev to work around some very ugly (yet harmless) error messages on boot
			/etc/init.d/udev stop >/dev/null 2>&1
		fi
	fi
	
	if test "$NW_TYPE" = "USB"
	then
		echo ""
		for module in $USB_NW_MODULES
		do
			echo "modprobing [$module]"
			modprobe $module || die "modprobe $module FAILED"
		done
	
		ifdown "$USB_NW_DEVICE" >/dev/null 2>&1
	
		
		echo -e "\nPlease make sure that usb0 is up on your PC and hit <ENTER>."
		read junk
			
		ifup "$USB_NW_DEVICE"
	fi

	WLAN_NIC="`iwconfig 2>/dev/null | grep ESSID | grep -v wifi | awk '{print $1}'`"

	if test -z "$WLAN_NIC"
	then
		# cardctl needs some time....
		echo -n "Waiting for WLAN card.."
		timeout=0
		while test "$timeout" -lt 10
		do
			WLAN_NIC="`iwconfig 2>/dev/null | grep ESSID | grep -v wifi | awk '{print $1}'`"
			test -n "$WLAN_NIC" && break			
			echo -n "."
			let timeout=$timeout+1
			sleep 1
		done	
		
		if test -z  "$WLAN_NIC"
		then
			debug_echo "WARNING: WLAN_NIC is empty!\n" 
			debug_echo "Filter result: [$WLAN_NIC]"
			debug_echo "iwconfig: [`iwconfig`]"
			mdie "No network interface found"
		fi			
	fi
	
	# WLAN with DHCP needs some time to get a lease, set up the routing, etc.	
	echo -n "Waiting for host [$1] on [$WLAN_NIC]."
	cnt=0
	while true
	do
		if (ping -c 1 $1) >/dev/null 2>&1
		then
			echo " found"
			break
		else
			if test "$cnt" = 30 -o "$cnt" = 60
			then
				echo ""
				echo "WARNING: $NW_TYPE didn't activate in $cnt seconds!"
				
				if test "$cnt" = 30
				then
					let cnt=$cnt+1
			
					if test "$NW_TYPE" = "NIC"
					then
						echo "Restarting udhcpc for [$WLAN_NIC]"
						killall udhcpc
					
						udhcpc -i "$WLAN_NIC" -H `cat /etc/hostname` >"$OUT_TTY" 2>&1
					fi
					
					if test "$NW_TYPE" = "USB"
					then
						echo "ifdown/up $USB_NW_DEVICE..."
						ifdown "$USB_NW_DEVICE" 
						sleep 1
						ifup "$USB_NW_DEVICE"
					fi			
					
				else
					mdie "Failed to activate $NW_TYPE!"
					break			
				fi
			else
				echo -n "."
				let cnt=$cnt+1
			fi
		fi
		sleep 1
	done				
	
	
}