#!/bin/bash
# /usr/sbin/do-hotmnt

LOG_FILE=/var/log/usbwatch

if ! [[ "$CALLER" = "USBWATCH" ]] ; then
 echo "Whoa! Don't call me directly. I'm used by the usbwatch program."
 exit 0
else
 echo "" >> $LOG_FILE
 echo "### Handling event with do-hotmnt" >> $LOG_FILE
fi

BASE_MOUNT_POINT=/mnt/usbwatch
INITIAL_WAIT_TIME=6

GRID_INTERVAL=64
PRG_CMD="usbwatch"
REQUESTER="Xusbconnect"
MESSAGER="xmessage"

getparam(){
case "$PARSE_LINE" in *\ $1=*) ;; *) return 1; ;; esac
result="${PARSE_LINE##*$1=}"
result="${result%%[     ]*}"
echo "$result"
return 0
}

checkparam(){
case "$PARSE_LINE" in *\ $1*) return 0;; esac
return 1
}

if [[ `pgrep $REQUESTER` ]] ; then
 RQ_PID="`pgrep -o $REQUESTER`"
 RQ_USER=`cat /proc/$RQ_PID/environ | tr "\000" "\n" |grep USER |tail -n 1 |cut -f2 -d=`
 ALL_PRG_PIDS=`pgrep -n -u $RQ_USER $PRG_CMD`
else
 ALL_PRG_PIDS=`pgrep Xusb-hotmount`
fi

if [[ $ACTION = "add" ]] ; then
        echo -en "" >> $LOG_FILE
	if [[ `pgrep $REQUESTER` ]] ; then
	 # we use a 'requester' to signal that a user wants to connect a device (usbwatch.requester) xmessage
	 RQ_PID="`pgrep $REQUESTER`"
	 RQ_USER=`cat /proc/$RQ_PID/environ | tr "\000" "\n" |grep USER |tail -n 1 |cut -f2 -d=`
	 # ALL_PRG_PIDS=`pgrep -n -u $RQ_USER $PRG_CMD`
	 PRG_PID=`pgrep -n -u $RQ_USER $REQUESTER`
	else
	 PRG_PID=`pgrep -n Xusb-hotmount`
	fi
	
	echo ALL_PRG_PIDS=$ALL_PRG_PIDS >> $LOG_FILE
	
	#for PRG_PID in $ALL_PRG_PIDS; do
	 PRG_USER=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep USER |tail -n 1 |cut -f2 -d=`
	 PRG_USER_HOME=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep HOME |tail -n 1 |cut -f2 -d=`
	 PRG_DISPLAY=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep DISPLAY |cut -f2 -d=`
	 echo " Connecting $DEVICE to $PRG_USER from $PRG_USER_HOME on $PRG_DISPLAY" >> $LOG_FILE
	 # save what we can from the environment of the original process
	 ENVIRON_VALUES=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep -v LS_OPTIONS |grep -v LESSOPEN`
	 
	 MESSAGER_PID=`pgrep -u $PRG_USER xmessage`
	 PARENT_PID=`pgrep -u $PRG_USER Xusb-hotmount`
	 CHILD_PID=`pgrep -u $PRG_USER $PRG_CMD`
	 
	 rm -f $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	 cp /etc/X11/usbwatch/links/usbwatch-blue.lnk $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	 [[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	 
	 TIMEOUT=$INITIAL_WAIT_TIME
	 MESSAGE="Waiting $INITIAL_WAIT_TIME seconds"
	 ( 
	 cd $PRG_USER_HOME
	 export $ENVIRON_VALUES 
	 unset XAUTHORITY
	 if [[ "$PRG_USER" = "root" ]] ; then
	  PATH=$PATH DISPLAY=$DISPLAY kill -9 $MESSAGER_PID
	  PATH=$PATH DISPLAY=$DISPLAY kill -2 $CHILD_PID
	  PATH=$PATH DISPLAY=$DISPLAY $MESSAGER -buttons '' -timeout $TIMEOUT $MESSAGE &> /dev/null &
	 else
	  su - $PRG_USER -c "kill -9 $MESSAGER_PID"
	  su - $PRG_USER -c "kill -2 $CHILD_PID"
	  su - $PRG_USER -c "PATH=$PATH DISPLAY=$DISPLAY $MESSAGER -buttons '' -timeout $TIMEOUT $MESSAGE &> /dev/null &"
	 fi
	 )
	#done
	
        sleep "$INITIAL_WAIT_TIME"
	
	# superfluous status update
	 update_yellow() {
	 MESSAGER_PID=`pgrep -u $PRG_USER xmessage`
	 CHILD_PID=`pgrep -n -u $PRG_USER $PRG_CMD`
	 
	 rm -f $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	 cp /etc/X11/usbwatch/links/usbwatch-yellow.lnk $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	 [[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	 ( 
	 cd $PRG_USER_HOME
	 export $ENVIRON_VALUES 
	 unset XAUTHORITY
	 if [[ "$PRG_USER" = "root" ]] ; then
	  PATH=$PATH DISPLAY=$DISPLAY kill -9 $MESSAGER_PID
	  PATH=$PATH DISPLAY=$DISPLAY kill -2 $CHILD_PID
	  PATH=$PATH DISPLAY=$DISPLAY $MESSAGER -buttons '' -timeout $TIMEOUT $MESSAGE &> /dev/null &
	 else
	  su - $PRG_USER -c "kill -9 $MESSAGER_PID"
	  su - $PRG_USER -c "kill -2 $CHILD_PID"
	  su - $PRG_USER -c "PATH=$PATH DISPLAY=$DISPLAY $MESSAGER -buttons '' -timeout $TIMEOUT $MESSAGE &> /dev/null &"
	 fi
	 )
	 }
	 TIMEOUT=1
	 MESSAGE="Mounting devices"
	 #update_yellow
	 
	#Waste as much time as possible. We don't use DMESG_DEVICE anyway as we can't depend on it
	# If the system has other processes writing to the logs it's hard to tell which device is right
	if [[ `dmesg | tail -n 10 | grep "USB Mass Storage device found"` != ""  ]] ; then
	 DMESG_DEVICE=`dmesg | tail -n 10 | grep "USB Mass Storage device found" |tail -n 1 |rev |cut -f1 -d' ' |rev`
	fi
	if [[ "$DMESG_DEVICE" = "" ]] ; then
	 echo "Waiting 5 seconds for DMESG_DEVICE" >> $LOG_FILE ; sleep 5
	DMESG_DEVICE=`dmesg | tail -n 10 | grep "USB Mass Storage device found" |tail -n 1 |rev |cut -f1 -d' ' |rev`
	fi
	echo DMESG_DEVICE=$DMESG_DEVICE >> $LOG_FILE
	if [[ `echo $DEVICE |grep $DMESG_DEVICE` ]] ; then
	 echo "Found a match between $DEVICE and $DMESG_DEVICE" >> $LOG_FILE
	fi
	# we don't really need MAIN_DEVICES either, but it wastes a little time
	if [[ `dmesg | tail -n 20 | grep "SCSI device"` != "" ]] ; then
	 MAIN_DEVICES=`dmesg | tail -n 20 | grep "SCSI device" |tail -n 1 |cut -f1 -d: |rev |cut -f1 -d' ' |rev`
	fi
	if [ "$MAIN_DEVICES" = "" ] ; then
	 echo "Waiting 5 seconds for MAIN_DEVICES" >> $LOG_FILE ; sleep 5
	 MAIN_DEVICES=`dmesg | tail -n 20 | grep "SCSI device" |tail -n 1 |cut -f1 -d: |rev |cut -f1 -d' ' |rev`
	fi
	if [[ "$MAIN_DEVICES" = "" ]] ; then
	 echo "Using alternate method for MAIN_DEVICES" >> $LOG_FILE ; sleep 5
	 MAIN_DEVICES=`cat /proc/partitions | grep sd |rev |cut -f1 -d' ' |rev |grep -v [0-9]`
	else
	 echo "Found MAIN_DEVICES $MAIN_DEVICES" >> $LOG_FILE
	fi
	if [[ "$MAIN_DEVICES" = "" ]] ; then
	 echo "Waiting another 5 seconds for MAIN_DEVICES" >> $LOG_FILE ; sleep 5
	 echo "Trying alternate method again for MAIN_DEVICES" >> $LOG_FILE
	 MAIN_DEVICES=`cat /proc/partitions | grep sd |rev |cut -f1 -d' ' |rev |grep -v [0-9]`
	fi
	# SCSI_DEVICES is what we want and use. We try to use blkid to get the partitions
	# IMPORTANT -start with a new /etc/blkid.tab each time or you will be sorry
	
	rm -f /etc/blkid.tab
	
	if [[ "$MAIN_DEVICES" != "" ]] ; then
		echo MAIN_DEVICES=$MAIN_DEVICES >> $LOG_FILE
		for MAIN_DEVICE in $MAIN_DEVICES ; do
			SCSI_DEVICES=`/sbin/blkid | grep "$MAIN_DEVICE" |cut -f1 -d:`
			if [[ "$SCSI_DEVICES" != "" ]] ; then
			 echo "Found SCSI_DEVICES with blkid" >> $LOG_FILE
			 break
			fi
		done
	else
		# SCSI_DEVICES=`/sbin/blkid | grep /dev/sd |cut -f1 -d:`
		for MAIN_DEVICE in $MAIN_DEVICES ; do
			SCSI_DEVICES=`/sbin/fdisk -l | grep "$MAIN_DEVICE" |grep -v Disk |cut -f1 -d' '`
			if [[ "$SCSI_DEVICES" = "" ]] ; then
			 echo "Found SCSI_DEVICES with fdisk" >> $LOG_FILE
			 break
			fi
		done
	fi
	
	# if there's more than one MAIN_DEVICE start all over for the most dependable results
	if [[ `echo $MAIN_DEVICES |grep ' '` != "" ]] ; then
	 rm -f /etc/blkid.tab
	 SCSI_DEVICES=`/sbin/blkid | grep "/dev/sd" |cut -f1 -d:`
	 echo "Recalculating SCSI_DEVICES" >> $LOG_FILE
	fi
	
	#BAIL OUT  if we have no devices
	if [[ "$SCSI_DEVICES" = "" ]] ; then
	 echo "NO devices were found!" >> $LOG_FILE
	 exit 0
	elif [[ `echo $SCSI_DEVICES |grep such` != "" ]] ; then
	 echo "Error retrieving SCSI_DEVICES=$SCSI_DEVICES --exiting" >> $LOG_FILE
	 exit 0
	else
	 echo SCSI_DEVICES=$SCSI_DEVICES >> $LOG_FILE
	fi
	
	# specific to icons for usbwatch
	X_COUNTER=0
	Y_COUNTER=1
	
	######
	for disk in $SCSI_DEVICES ; do
		NOT_MOUNTED=1
		part=`echo $disk |rev |cut -f1 -d/ |rev`
		PARSE_LINE=`blkid $disk`
		PART_TYPE=`getparam TYPE 2> /dev/null |tr -d '"'`
		
		echo "Partition type $PART_TYPE..." >> $LOG_FILE
		
		# we use mount -s (sloppy) &> /dev/null
		if [[ "$PART_TYPE" = "reiserfs" ]] ; then
		 MOUNT_OPTIONS="noauto,users,noexec,sync,rw"
		elif [[ "$PART_TYPE" = "ext2" ]] || [[ "$PART_TYPE" = "ext3" ]] ; then
		 MOUNT_OPTIONS="noauto,users,suid,sync,rw"
		elif [[ "$PART_TYPE" = "vfat" ]] || [[ "$PART_TYPE" = "msdos" ]] ; then
		 MOUNT_OPTIONS="noauto,users,noexec,sync,umask=000,rw"
		elif [[ "$PART_TYPE" = "ntfs" ]] ; then
		 MOUNT_OPTIONS="noauto,users,noexec,sync,umask=000,rw"
		fi
		
		echo "Checking $disk..." >> $LOG_FILE
		
		if [[ "$PART_TYPE" = "swap" ]] ; then
		 echo "Skipping swap partition." >> $LOG_FILE
		elif [[ `cat /proc/mounts |grep $disk` != "" ]] ; then
			# avoid using the 'mount' command to check
			echo "Partition $part is already mounted" >> $LOG_FILE
		else
			echo "Partition $part is not mounted." >> $LOG_FILE
			PRODUCT_LABEL=`echo "$PRODUCT" | sed -e 's;/;_;g'`
			MOUNT_LABEL=$PRODUCT_LABEL/$part 
			
			if [[ `cat /etc/fstab |grep $disk |grep -v '#'` = "" ]] ; then
			  if [[ `blkid |grep $disk` ]] ; then
				echo "No entry found in /etc/fstab for $part " >> $LOG_FILE
				if [[ ! -d $BASE_MOUNT_POINT/$MOUNT_LABEL ]] ; then 
				 echo "Creating mount-point: $BASE_MOUNT_POINT/$MOUNT_LABEL" >> $LOG_FILE
				 mkdir -p $BASE_MOUNT_POINT/$part
				else
				 echo "Mount-point already exists: $BASE_MOUNT_POINT/$MOUNT_LABEL" >> $LOG_FILE
				fi
			  fi
			else
			 echo "Found an entry already in /etc/fstab for $part " >> $LOG_FILE
			 mkdir -p $BASE_MOUNT_POINT/$part
			 mount -s -t $PART_TYPE -o $MOUNT_OPTIONS $disk $BASE_MOUNT_POINT/$part &> /dev/null
			 NOT_MOUNTED=$?
			fi
			
			PARSE_LINE=`cat $PRG_USER_HOME/.usbwatch/prog.prefs`
			if [[ `checkparam $PART_TYPE-START_STATUS` ]] ; then
			START_STATUS=`getparam $PART_TYPE-START_STATUS |tr -d '"'`
			else
			 # by default don't mount journalled file systems -they are slow to mount
			 if [[ "$PART_TYPE" = "reiserfs" ]] || [[ "$PART_TYPE" = "ext3" ]]; then
			  START_STATUS=unmounted
			 else
			  START_STATUS=mounted
			 fi
			fi
			
			# START_STATUS could be set
			if [[ "$START_STATUS" = "unmounted" ]] ;then 
			 true
			 NOT_MOUNTED=0
			elif [ $NOT_MOUNTED -ne 0 ] ; then
			 mount -s -t $PART_TYPE -o $MOUNT_OPTIONS $disk $BASE_MOUNT_POINT/$part &> /dev/null
			 NOT_MOUNTED=$?
			fi
			
			if [ $NOT_MOUNTED -ne 0 ]; then
			 sleep 2
			 mount -s -t auto -o users,nodev,noexec,rw $disk $BASE_MOUNT_POINT/$part
			 NOT_MOUNTED=$?	
			fi
			if [ $NOT_MOUNTED -eq 0 ]; then
			 echo "Mount successful!" >> $LOG_FILE
			 mkdir -p $BASE_MOUNT_POINT/$PRODUCT_LABEL
			 ln -sf $BASE_MOUNT_POINT/$part $BASE_MOUNT_POINT/$PRODUCT_LABEL/$part 
			 # sync
			 REMOVER=/var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g')_$part
			 HANDLER=/var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g')_$part.menu
			 DEVICE_NAME=$(echo "$DEVICE" | sed -e 's;/;_;g')
			 # this controller is for the whole device, but we only create it if mount succeeds
			 DEVICE_CTL=/var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g').ctl
			 echo "REMOVER is: $REMOVER" >> $LOG_FILE
			 
			 let "X_POS=$X_COUNTER * $GRID_INTERVAL"
			 let "Y_POS=$Y_COUNTER * $GRID_INTERVAL"
			 echo "COUNTERS: $X_COUNTER $Y_COUNTER" >> $LOG_FILE
			 
			 #export disk part BASE_MOUNT_POINT MOUNT_LABEL X_POS Y_POS REMOVER \
			  #DEVICE_NAME PRODUCT_LABEL PART_TYPE START_STATUS HANDLER CAPTION
			 sed \
				-e "s:@CAPTION\@:$part:" \
				-e "s'@disk\@'$disk'g" \
				-e "s'@part\@'$part'g" \
				-e "s'@PART_TYPE\@'$PART_TYPE'g" \
				-e "s'@MOUNT_OPTIONS\@'$MOUNT_OPTIONS'g" \
				-e "s'@BASE_MOUNT_POINT\@'$BASE_MOUNT_POINT'g" \
				-e "s'@MOUNT_LABEL\@'$MOUNT_LABEL'g" \
				-e "s:@X_POS\@:$X_POS:" \
				-e "s:@Y_POS\@:$Y_POS:" \
				-e "s'@HANDLER\@'$HANDLER'g" \
				/etc/X11/usbwatch/links/$PART_TYPE-mounted.lnk > /var/run/usb/$part-mounted.lnk
			 
			 sed \
				-e "s:@CAPTION\@:$part:" \
				-e "s'@disk\@'$disk'g" \
				-e "s'@part\@'$part'g" \
				-e "s'@PART_TYPE\@'$PART_TYPE'g" \
				-e "s'@MOUNT_OPTIONS\@'$MOUNT_OPTIONS'g" \
				-e "s'@BASE_MOUNT_POINT\@'$BASE_MOUNT_POINT'g" \
				-e "s'@MOUNT_LABEL\@'$MOUNT_LABEL'g" \
				-e "s:@X_POS\@:$X_POS:" \
				-e "s:@Y_POS\@:$Y_POS:" \
				-e "s'@HANDLER\@'$HANDLER'g" \
				/etc/X11/usbwatch/links/$PART_TYPE-unmounted.lnk > /var/run/usb/$part-unmounted.lnk
			 
			 cp /var/run/usb/$part-$START_STATUS.lnk $PRG_USER_HOME/.usbwatch/$part.lnk
			 [[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $PRG_USER_HOME/.usbwatch/$part.lnk
			 
			 # write the remover for this partition
			 sed \
				-e "s'@part\@'$part'g" \
				-e "s'@PRG_USER_HOME\@'$PRG_USER_HOME'g" \
				-e "s'@BASE_MOUNT_POINT\@'$BASE_MOUNT_POINT'g" \
				-e "s'@MOUNT_LABEL\@'$MOUNT_LABEL'g" \
				-e "s'@PRODUCT_LABEL\@'$PRODUCT_LABEL'g" \
				-e "s'@LOG_FILE\@'$LOG_FILE'" \
				-e "s'@DESKTOP_LINK\@'/etc/X11/usbwatch/$(echo "$DEVICE" | sed -e 's;/;_;g')_$PRODUCT_LABEL_$part.lnk'" \
				/etc/X11/usbwatch/removers/$PART_TYPE.remover > $REMOVER
			 chmod 755 $REMOVER
			 
			 # write the handler for the icon menu for this partition
			 sed \
				-e "s'@disk\@'$disk'g" \
				-e "s'@part\@'$part'g" \
				-e "s'@PRG_USER\@'$PRG_USER'g" \
				-e "s'@PRG_USER_HOME\@'$PRG_USER_HOME'g" \
				-e "s'@DEVICE_NAME\@'$DEVICE_NAME'g" \
				-e "s'@PART_TYPE\@'$PART_TYPE'g" \
				-e "s'@MOUNT_OPTIONS\@'$MOUNT_OPTIONS'g" \
				-e "s'@BASE_MOUNT_POINT\@'$BASE_MOUNT_POINT'g" \
				-e "s'@MOUNT_LABEL\@'$MOUNT_LABEL'g" \
				/etc/X11/usbwatch/handlers/$PART_TYPE.handler > $HANDLER
			 chmod 755 $HANDLER
			 
			 MESSAGER_PID=`pgrep -u $PRG_USER xmessage`
			 CHILD_PID=`pgrep -n -u $PRG_USER $PRG_CMD`
			 MESSAGE="Mounted /dev/$part"
			 TIMEOUT=2
			 
			 rm -f $PRG_USER_HOME/.usbwatch/usbwatch.lnk
			 sed -e "s'@part\@'$part'g" \
			 /etc/X11/usbwatch/links/usbwatch-mount.lnk > $PRG_USER_HOME/.usbwatch/usbwatch.lnk
			 
			 [[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $PRG_USER_HOME/.usbwatch/usbwatch.lnk
			 (
			 cd $PRG_USER_HOME
			 export $ENVIRON_VALUES 
			 unset XAUTHORITY
			 if [[ "$PRG_USER" = "root" ]] ; then
			  PATH=$PATH DISPLAY=$DISPLAY kill -9 $MESSAGER_PID
			  PATH=$PATH DISPLAY=$DISPLAY kill -2 $CHILD_PID
			  PATH=$PATH DISPLAY=$DISPLAY $MESSAGER -buttons '' -timeout $TIMEOUT $MESSAGE &> /dev/null &
			 else
			  su - $PRG_USER -c "kill -9 $MESSAGER_PID"
			  su - $PRG_USER -c "kill -2 $CHILD_PID"
			  su - $PRG_USER -c "PATH=$PATH DISPLAY=$DISPLAY $MESSAGER -buttons '' -timeout $TIMEOUT $MESSAGE &> /dev/null &"
			 fi
			 )
			 
			 let "Y_COUNTER=$Y_COUNTER + 1"
			 if [ $Y_COUNTER -gt 9 ] ; then
			  X_COUNTER=`expr ${X_COUNTER} + 1`
			  Y_COUNTER=1
			 fi
			 
			 #sleep 1
			 
			else
			 echo "Failed to mount partition: /dev/$part" >> $LOG_FILE
			 
			 pkill -SIGHUP -u $PRG_USER $MESSAGER
			 kill -2 -u $PRG_USER $PRG_CMD
			 #sleep .5
			 f_update_status orange 1 "Mount failed"
			 sleep 1
			fi
		fi
	done
	
	# write the whole-device handler
	DEVICE_CTL=/var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g').ctl
	sed \
		-e "s'@disk\@'$disk'g" \
		-e "s'@part\@'$part'g" \
		-e "s'@DEVICE_NAME\@'$DEVICE_NAME'g" \
		-e "s'@PRG_USER\@'$PRG_USER'g" \
		-e "s'@PRG_USER_HOME\@'$PRG_USER_HOME'g" \
		-e "s'@DEVICE_CTL\@'$DEVICE_CTL'g" \
		-e "s'@PART_TYPE\@'$PART_TYPE'g" \
		-e "s'@MOUNT_OPTIONS\@'$MOUNT_OPTIONS'g" \
		-e "s'@BASE_MOUNT_POINT\@'$BASE_MOUNT_POINT'g" \
		-e "s'@MOUNT_LABEL\@'$MOUNT_LABEL'g" \
		/etc/X11/usbwatch/handlers/device.ctl > $DEVICE_CTL
	# make it belong to the USER and be executable
	[[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $DEVICE_CTL
	chmod 700 $DEVICE_CTL
	
	###### here's the exit signal to Xusb-hotmount to refresh usbwatch the last time
	rm -f $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	sed \
		-e "s'@DEVICE_CTL\@'$DEVICE_CTL'g" \
		/etc/X11/usbwatch/links/usbwatch-active.lnk > $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	[[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	
	# kill the messager and icon display on the users desktop for the last time
	pkill -SIGHUP -u $PRG_USER $MESSAGER
	PARENT_PID=`pgrep -n -u $PRG_USER Xusb-hotmount`
	CHILD_PID=`pgrep -n -u $PRG_USER $PRG_CMD`
	#su - $PRG_USER -c "kill -2 $PARENT_PID"
	su - $PRG_USER -c "kill -2 $CHILD_PID"
	
	# The program Xusbconnect is polling for this every 2 seconds before letting Xusb-hotmount restart usbwatch
	echo "Device READY: $DEVICE" >> $LOG_FILE
	
  else
	if [[ $ACTION = "remove" ]] ; then
	 echo "Removing device: $DEVICE" >> $LOG_FILE
	 HANDLERS=/var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g')_*.menu
	 REMOVERS=`ls /var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g')* |sort -r`
	 DEVICE_CTL=/var/run/usb/$(echo "$DEVICE" | sed -e 's;/;_;g').ctl
	 
	 if [[ `pgrep $REQUESTER` ]] ; then
	  RQ_PID="`pgrep -o $REQUESTER`"
	  RQ_USER=`cat /proc/$RQ_PID/environ | tr "\000" "\n" |grep USER |tail -n 1 |cut -f2 -d=`
	  PRG_PID=`pgrep -n -u $RQ_USER Xusb-hotmount`
	 else
	  PRG_PID=`pgrep -n Xusb-hotmount`
	 fi
	 
	 # stop the users running usbwatch first, as running the removers can take awhile
	 #for PRG_PID in $ALL_PRG_PIDS; do
	 
	  PRG_USER=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep USER |tail -n 1 |cut -f2 -d=`
	  PRG_USER_HOME=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep HOME |tail -n 1 |cut -f2 -d=`
	  PRG_DISPLAY=`cat /proc/$PRG_PID/environ | tr "\000" "\n" |grep DISPLAY |cut -f2 -d=`
	  echo " Disconnecting $DEVICE from $USER ($PRG_USER_HOME) on Display $PRG_DISPLAY" >> $LOG_FILE
	  rm -f $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	  cp /etc/X11/usbwatch/links/usbwatch-white.lnk $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	  [[ "$PRG_USER" != "root" ]] && chown $PRG_USER.users $PRG_USER_HOME/.usbwatch/usbwatch.lnk
	  MESSAGER_PID=`pgrep -u $PRG_USER xmessage`
	  PARENT_PID=`pgrep -u $PRG_USER Xusb-hotmount`
	  CHILD_PID=`pgrep -u $PRG_USER $PRG_CMD`
	  kill -9 $MESSAGER_PID
	  kill -9 $PARENT_PID
	  kill -2 $CHILD_PID
	 #done
	 # remove the whole-device controller
	 rm -f $DEVICE_CTL
	 # execute and remove each REMOVER
	 for rem in $REMOVERS ; do
	  [[ -x $rem ]] && $rem && rm $rem
	  # rm -f /etc/X11/usbwatch/$part.lnk
	 done
	 # remove the icon-menu handlers
	 for handler in $HANDLERS ; do
	  rm $handler
	 done
	 rmdir $BASE_MOUNT_POINT/`echo "$PRODUCT" | sed -e 's;/;_;g'`
	 echo "Removed directory $BASE_MOUNT_POINT/`echo "$PRODUCT" | sed -e 's;/;_;g'`" >> $LOG_FILE
	fi
	# removing the module if unused makes things more dependable. this fails safely if the module is busy
	rmmod usb-storage 2> /dev/null
  fi
# fi
echo "exiting do-hotmnt" >> $LOG_FILE
exit 0