#!/bin/sh
#
# knet:
# description: Starts and stops the monitored knet
#


# Source function library.
if [ -f /etc/init.d/functions ] ; then
  . /etc/init.d/functions
elif [ -f /etc/rc.d/init.d/functions ] ; then
  . /etc/rc.d/init.d/functions
else
  exit 0
fi

. /etc/profile

# Avoid using root's TMPDIR
unset TMPDIR

KNETD=/knet/knetd
KNETD_TRACEDIR=/mnt/fsuser-1/
KNETD_CFGFILE=/knet/knetd.xml
KNETD_CFGFILE_WANESY=/knet/system.xml
EXE_DIR=/knet
BACKUP_DIR=/.knet.bak
KNET_LOCK="/tmp/knet.ok"

KIND=KNET

RETVAL=0


test_knetd()
{
	# File presence verification
	[ -x ${KNETD} ] || return 1
	[ -f ${EXE_DIR}/knetd.xml ] || return 1
	[ -f ${EXE_DIR}/licence.dat ] || return 1

	# Quick Test
	${KNETD} -v | grep "WAN" > /dev/null 2>&1
	[ $? -ne 0 ] && return 1

	return 0
}

open_firewall()
{
	WANESY_PORT=$(sed -n -r -e '/knet_port/ s;.*="(.*)".*;\1;p' ${KNETD_CFGFILE_WANESY})
	WANESY_IP=$(sed -n -r -e '/address/ s;.*="(.*)".*;\1;p' ${KNETD_CFGFILE_WANESY})

	iptables -L -n | grep "${WANESY_IP}" | grep -q "${WANESY_PORT}"
	if [ $? -ne 0 ]
	then
		iptables -A INPUT -p tcp -m tcp -s ${WANESY_IP} --sport ${WANESY_PORT} -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
		iptables -A OUTPUT -p tcp -m tcp -d ${WANESY_IP} --dport ${WANESY_PORT} -m conntrack --ctstate ESTABLISHED -j ACCEPT
	fi
}


start() {
	# PR4304: Create klk-version if not exist
	if ! [ -f /etc/klk-version ]
	then
		get_version -u > /dev/null
	fi

	# check if not already started
	pid=`ps |grep  knetd | grep -v grep|awk '{print $1;}'`
	if [ -n "${pid}" ] ; then
	  echo 'knetd already started'
	  return
	fi

	# remove lock
	if test -f $KNET_LOCK
	then
	rm $KNET_LOCK
	fi

	# now verify owner and mode (can be bad after a dota)
	for i in ${EXE_DIR}/*
	do
	  if test -f $i
	  then
	    chown root:root $i
	    chmod +x $i
	  fi
	done

	# If first boot, select right knetd.xml
	if ! [ -f ${EXE_DIR}/knetd.xml ]
	then
		cp -L ${EXE_DIR}/.configs/knetd_`get_product`.xml ${EXE_DIR}/knetd.xml
	fi

	test_knetd
	[ $? -ne 0 ] && backup

	# Deactivate Led trigger
	if test -f "/sys/class/leds/leds:status-red/trigger"
	then
	    echo none > "/sys/class/leds/leds:status-red/trigger"
	fi

	open_firewall

	monitor -n 5 -w -c '/knet/knetd -a -f /knet/knetd.xml -t1 /mnt/fsuser-1/' 2>&1 >>/dev/null
	echo_success
	RETVAL=$?
	echo
	return $RETVAL
}

stop_monitor()
{
	# be sure monitor is dead cause of watchdog
	for VAR in 1 2 3 4 5; do
 	  pid=`ps |grep monitor |grep knetd | grep -v grep|awk '{print $1;}'`
	  if [ -n "${pid}" ] ; then
	    kill -9 ${pid}
	  else
	    return
	  fi
	  sleep 1
	done

}

stop() {
	echo "Shutting down $KIND services: "
	stop_monitor

	RUNLEVEL=`runlevel | awk '{print $NF}'`
	case ${RUNLEVEL} in
	  0)
	    # Launch a softdog to be sure we halt
	    echo "Launch softdog"
	    wirma2hw softdog timeout 60
	    echo "Keep watchdog"
	    wirma2hw wd timeout 90
	    ;;
	  6)
	    # keep watchog because of poweroff or reboot
	    echo "Keep watchdog"
	    wirma2hw wd timeout 60
	    ;;
	  *)
	    # stop wdt because it is a manual stop
	    echo "Stop watchdog"
	    echo "V" > /dev/watchdog
	    ;;
	esac

        # kill knet now
	killproc $KNETD

	# paranoia
	pid=`ps |grep knetd | grep -v grep|awk '{print $1;}'`
	if [ -n "${pid}" ] ; then
	  kill -9 ${pid}
	fi

        # stop gprs if started to free gsm com port
        /etc/rc.d/init.d/gprs stop

	#stop cmux if needed
 	if [ -f /etc/rc.d/init.d/cmux ]; then
    		/etc/rc.d/init.d/cmux stop
  	fi

	RETVAL=$?
	echo
	return $RETVAL
}

exit_knet() {
        echo "Exiting $KIND services: "
        stop_monitor

        # stop wdt
        echo "V" > /dev/watchdog

        # exit knetd
        pid=`ps |grep knetd | grep -v grep|awk '{print $1;}'`
        if [ -n "${pid}" ] ; then
          kill -SIGUSR1 ${pid}
        fi

        RETVAL=$?
        echo
        return $RETVAL
}

off() {
        echo "Powering off $KIND services: "
        stop_monitor

        # stop wdt
        echo "V" > /dev/watchdog

        # exit knetd
        pid=`ps |grep knetd | grep -v grep|awk '{print $1;}'`
        if [ -n "${pid}" ] ; then
          kill -SIGUSR2 ${pid}
        fi

        RETVAL=$?
        echo
        return $RETVAL
}

restart() {
	stop
	start
}

reload() {
        echo -n "Reloading $PROGRAM file: "
	killproc $KNETD
	RETVAL=$?
	echo
	return $RETVAL
}

rhstatus() {
	status $KNETD
}

backup() {
	if [ -d ${BACKUP_DIR} ]
	then
	    echo "Restoring backup ..."
	    rm -rf ${EXE_DIR}
 	    cp -a ${BACKUP_DIR} ${EXE_DIR}

	    test_knetd
	    if [ $? -ne 0 ]
	    then
		    # Backup failed ... system restore is the only solution
		    fw_setenv bootfail $(fw_printenv max_bootfail | awk -F\= '{print $2}')
		    reboot
	    fi
	else
		# Backup is necessary but there is no backup available ... system restore is the only solution
		fw_setenv bootfail $(fw_printenv max_bootfail | awk -F\= '{print $2}')
		reboot
    	fi
}

clean() {
    	if ! [ -d ${BACKUP_DIR} ]
	then
		echo "First execution, create backup !"
		cp -a ${EXE_DIR} ${BACKUP_DIR}
	else
		diff -rNq ${BACKUP_DIR} ${EXE_DIR}
		if [ $? -ne 0 ]
		then
			echo "KNETD file(s) were updated ... backup them"
			rm -rf ${BACKUP_DIR}
			cp -a ${EXE_DIR} ${BACKUP_DIR}
		fi
	fi
}

case "$1" in
  start)
        echo -n "Starting knetd: "
  	start
	;;
  stop)
  	stop
	;;
  restart)
  	restart
	;;
  reload)
  	restart
	;;
  status)
  	rhstatus
	;;
  backup)
        backup
	;;
  clean)
        clean
	;;
  exit)
        exit_knet
        ;;
  off)
        off
        ;;
  *)
	echo $"Usage: $0 {start|stop|restart|reload|status|backup|clean|exit|off}"
	exit 1
esac

exit $?
