#!/bin/sh

DELAY100MS()
{
	myusleep=`which aaa 2>/dev/null`
	if [ "${myusleep}" != "" ]; then
		t=$(($1 * 100000))
		usleep $t
	else
		sleep .$1
	fi
}

if [ "$1" = "restore" ]; then
	. /etc/PG.conf
	
	echo -n "Are you sure to restore the original configuration[y/n]?"
	read answer
	if [ "${answer}" = "y" -o "${answer}" = "Y" ]; then
		echo "Begin to restore admin interface configuration...... "
		if [ "${DCN}" = "1" ]; then
			OSNAME="DCN"
			adminip="192.168.1.1"
			gatewayip="192.168.1.254"
		elif [ "${TOPSEC}" != "" ]; then
			OSNAME="panabit"
			adminip="192.168.1.254"
			gatewayip="192.168.1.1"
		else
			OSNAME="panabit"
			adminip="192.168.0.200"
			gatewayip="192.168.0.1"
		fi
		echo "ADMIN_IP=${adminip}
ADMIN_MASK=255.255.255.0
GATEWAY=${gatewayip}" > ${PGETC}/ifadmin.conf
		echo "New configuration is: "
		cat ${PGETC}/ifadmin.conf
		
		echo "******Begin to stop ${OSNAME}......"
		${PGPATH}/bin/ipectrl stop
		sleep 3
		echo "******${OSNAME} is stopped!"

		echo "******Remove current configuration of ${OSNAME}......"
		rm -rf ${PGETC}/panabit.conf
		echo "******Current configurations of ${OSNAME} is removed!"

		echo "******Begin to restart ${OSNAME}......"
		${PGPATH}/bin/ipectrl start
		sleep 3
		echo "******${OSNAME} is started!"

		echo "******Success!"
	fi

	exit 0
fi

curuser=`id -nu`
if [ "${curuser}" != "root" ]; then
	echo "ipectrl can only run as root user!"
	exit 1
fi

if [ ! -e /etc/PG.conf ]; then
	echo "/etc/PG.conf not exist!"
	exit 1
fi

exec 0</etc/PG.conf
while read tagvalue; do
	if [ "`echo ${tagvalue} | cut -d'=' -f1`" != "" ]; then
		eval "export ${tagvalue}"
	fi
done

if [ -f ${PGETC}/pabootenv.conf ]; then
	exec 0<${PGETC}/pabootenv.conf
	while read tagvalue; do
		if [ "`echo ${tagvalue} | cut -d'=' -f1`" != "" ]; then
			eval "export ${tagvalue}"
		fi
	done
fi

if [ -f ${PGETC}/httpd.conf ]; then
	my_httpd_port=`cat ${PGETC}/httpd.conf | grep "^port=" | cut -d'=' -f2`
	[ "${my_httpd_port}" = "" ] && my_httpd_port=${HTTPS_PORT}
	[ "${my_httpd_port}" = "" ] && my_httpd_port=443
	if [ ${my_httpd_port} -ne 443 ]; then
		eval "export XDP_HTTPS_PORT=${my_httpd_port}"
	fi
fi

if [ "${PGPATH}" = "" ]; then
	echo "/etc/PG.conf is corrupted, NO PGPATH!!!"
	cat /etc/PG.conf
	exit 0
fi

if [ ! -d ${PGPATH} ]; then
	echo "/etc/PG.conf is corrupted for ${PGPATH} not exist!"
	exit 0
fi

# Create RAM disk
RAMDISK=/usr/ramdisk
RAMLOG=/usr/ramdisk/datalog
rammd=`df | grep "${RAMDISK}"`
memtotal=`cat /proc/meminfo | grep MemTotal | awk '{print $2}'`
memtotal=$((${memtotal} / 1024))
if [ "${rammd}" = "" ]; then
	mkdir -p ${RAMDISK}
	ramdsz=100
	[ ${memtotal} -lt 500 ] && ramdsz=32
	mount -t tmpfs -o size=${ramdsz}M tmpfs ${RAMDISK}
	if [ "$?" != "0" ]; then
		echo "FAIL TO CREATE RAMDISK!"
		exit 1
	fi
fi

# Sync the ramdisk with original data
if [ "$2" = "" -o "$2" = "kernel" ]; then
	runtime_setup=1
else
	runtime_setup=0
fi
if [ "$1" = "start" -a ${runtime_setup} -eq 1 ]; then
	if [ ! -L /usr/bin/floweye ]; then
		[ -e /usr/bin/floweye ] && rm -f /usr/bin/floweye
		ln -s /usr/ramdisk/bin/floweye /usr/bin/floweye
		sync
	fi

	[ -e ${PGPATH}/etc/dns.dat ] && cp -f ${PGPATH}/etc/dns.dat ${PGETC}/
	sync

	# Login page
	mkdir -p ${RAMDISK}/login/cgi-bin/
	mkdir -p ${RAMDISK}/var/

	. ${PGPATH}/etc/panabit.inf
	if [ "${JOS_RELEASE}" = "2" ]; then
		# create memory disk for log
		mkdir -p ${RAMLOG}
		mount -t tmpfs -o size=100M tmpfs ${RAMLOG}
		if [ "$?" != "0" ]; then
			echo "FAIL TO CREATE RAMDISK FOR LOG!"
		else
			touch ${RAMLOG}/keepme
		fi
	fi

	# Huge Pages verify and setup
	echo "never" > /sys/kernel/mm/transparent_hugepage/enabled
	echo "never" > /sys/kernel/mm/transparent_hugepage/defrag
	mmdir="/sys/kernel/mm/hugepages/hugepages-1048576kB"
	memok=0
	if [ -d "${mmdir}" ]; then
		num=1
		if [ ${memtotal} -gt 60000 ]; then
			num=16
		elif [ ${memtotal} -gt 30000 ]; then
			num=12
		elif [ ${memtotal} -gt 20000 ]; then
			num=8
		elif [ ${memtotal} -gt 15000 ]; then
			num=5
		elif [ ${memtotal} -gt 7000 ]; then
			num=4
		fi
		
		echo $num > ${mmdir}/nr_hugepages
		freepages=`cat ${mmdir}/free_hugepages`
		if [ ${freepages} -lt ${num} ]; then
			while [ ${num} -ge 1 ]; do
				echo $num > ${mmdir}/nr_hugepages
				freepages=`cat ${mmdir}/free_hugepages`
				if [ ${freepages} -ge 1 ]; then
					memok=1
					break
				fi

				num=$(($num - 1))
				sleep .2
			done
		else
			memok=1
		fi
	fi

	# some times there are 512M hugepages in ARM
	if [ ${memok} -eq 0 ]; then
		mmdir="/sys/kernel/mm/hugepages/hugepages-524288kB"
		if [ -d "${mmdir}" ]; then
			num=2
			while [ ${num} -ge 1 ]; do
				echo $num > ${mmdir}/nr_hugepages
				freepages=`cat ${mmdir}/free_hugepages`
				if [ ${freepages} -ge 1 ]; then
					memok=1
					break
				fi

				num=$(($num - 1))
				sleep .2
			done
		fi
	fi

	if [ ${memok} -eq 0 ]; then
		# Get hardware model
		if [ -e /sbin/pasys ]; then
			hwmodel=`pasys show | grep product | cut -d'=' -f2`
		else
			hwmodel="UNKNOWN"
		fi

		if [ "${hwmodel}" = "AX100M" ]; then
			maxpages=70
			minpages=40
		elif [ "${hwmodel}" = "AX100S" ]; then
			maxpages=80
			minpages=40
		else
			if [ ${memtotal} -le 512 ]; then
				maxpages=32
				minpages=20
			elif [ ${memtotal} -le 1024 ]; then
				maxpages=128
				minpages=40
			elif [ ${memtotal} -le 2048 ]; then
				maxpages=192
				minpages=40
			elif [ ${memtotal} -le 4096 ]; then
				maxpages=256
				minpages=40
			else
				maxpages=512
				minpages=40
			fi
		fi

		mmdir="/sys/kernel/mm/hugepages/hugepages-2048kB"
		if [ ! -d "${mmdir}" ]; then
			echo "WARNNING: ${mmdir} not exist, 2M superpage not supported, use PANAOS_INCLOUD=1"
			export PANAOS_INCLOUD=1
		else	
			echo "1G hugepage can't be reserved, try to reserve 2M superpage instead!"
			pages=${maxpages}
			while [ ${pages} -ge ${minpages} ]; do
				freepages=`cat ${mmdir}/free_hugepages`
				if [ ${freepages} -ge ${pages} ]; then
					memok=1
					break
				fi

				pages=$((${pages} - 4))
				echo ${pages} > ${mmdir}/nr_hugepages
			done

			freepages=`cat ${mmdir}/free_hugepages`
			if [ ${freepages} -lt ${minpages} ]; then
				echo "WARNNING: left 2M superpage is not enough, at ${minpages} page need!"
			else
				echo "Use 2M size superpage, ${freepages} pages reserved!"
			fi
		fi
	fi

	if [ -e ${RAMLOG}/keepme ]; then
		export RAMLOG=/usr/ramdisk/datalog
		if [ ! -e ${RAMLOG}/panabit.raz ]; then
			if [ -e ${DATAPATH}/panabit.raz ]; then
				cp -f ${DATAPATH}/panabit.raz ${RAMLOG}
			fi
		fi
	else
		export RAMLOG=${DATAPATH}
	fi

	needsync=1
	if [ -e ${RAMDISK}/etc/panabit.inf ]; then
		oridata=`cat ${PGPATH}/etc/panabit.inf`
		ramdata=`cat ${RAMDISK}/etc/panabit.inf`
		[ "${oridata}" = "${ramdata}" ] && needsync=0
	fi

	if [ ${needsync} -ne 0 ]; then
		cp -Rf ${PGPATH}/* ${RAMDISK}/
		cp -f /etc/PG.conf ${RAMDISK}/
	else
		if [ "$2" = "" -o "$2" = "panaos" ]; then
			cp -f ${PGPATH}/bin/panaos  ${RAMDISK}/bin/
			cp -f ${PGPATH}/bin/floweye ${RAMDISK}/bin/
			[ -f /sbin/floweye ] && cp -f ${PGPATH}/bin/floweye /sbin/
			cp -f ${PGPATH}/admin/.htpasswd ${RAMDISK}/admin/
		fi
	fi

	# Sync SYSNAME
	sysname=""
	[ -f ${PGETC}/sysname.conf ] && sysname=`cat ${PGETC}/sysname.conf | cut -d'=' -f2-`
	echo "${sysname}" > ${RAMDISK}/etc/sysname.inf

	if [ ! -s ${PGETC}/account.conf ]; then
		echo "start merging accounts ..."
		${RAMDISK}/bin/acctmerge.sh
		echo "accounts mergation complete!"
		sync
	fi

	[ ! -e ${RAMDISK}/etc/sysname.inf ] && touch ${RAMDISK}/etc/sysname.inf

	if [ "${NTM}" = "1" ]; then
		# Create RAM disk
		NTMRAMDISK=/usr/ntmlog
		rammd=`df | grep "${NTMRAMDISK}"`
		if [ "${rammd}" = "" ]; then
			mkdir -p ${NTMRAMDISK}

			totalmem=`free -m | grep 'Mem:' | awk '{print $2}'`
			if [ ${totalmem} -ge 30000 ]; then
				ramsize=10G
			elif [ ${totalmem} -ge 16000 ]; then
				ramsize=4G
			else
				ramsize=1G
			fi

			mount -t tmpfs -o size=${ramsize} tmpfs ${NTMRAMDISK}
			if [ "$?" != "0" ]; then
				echo "FAIL TO CREATE NTMRAMDISK!"
				exit 1
			fi
		fi

		if [ ! -d /usr/ntmlog ]; then
			echo "Warning: ramdisk /usr/ntmlog not exist!"
		else
			[ "${NTMPCAP_BS}" = "" ] && NTMPCAP_BS=128
			[ "${NTMPCAP_COUNT}" = "" ] && NTMPCAP_COUNT=8
			if [ ! -e /usr/ntmlog/ntmpcap ]; then
				errmsg=`/usr/ramdisk/bin/floweye ntmpcap init file=/usr/ntmlog/ntmpcap bs=${NTMPCAP_BS} count=${NTMPCAP_COUNT}`
				[ "$?" != "0" ] && echo "FAIL to init ntmpcap: ${errmsg}"
			fi
		fi
	else
		# for unisase
		mkdir -p /usr/unisase
		chmod -R 777 /usr/unisase
	fi
fi

# New PGPATH
export PGPATH="${RAMDISK}"

FLOWEYE=${PGPATH}/bin/floweye
PGCFGPATH=${PGPATH}/etc
PGBIN=${PGPATH}/bin
HTTPD=${PGPATH}/bin/ipe_httpd
ADMIN=${PGPATH}/admin

# Create the log directory
mkdir -p ${PGETC}/log
mkdir -p ${DATAPATH}/config
mkdir -p ${DATAPATH}/tmp

sync

# Start netev_alarm.sh
start_netev_alarm()
{
	ps ax | grep netev_alarm.sh | grep -v grep | awk '{print $1}' | \
	while read pid; do
		if [ "${pid}" != "" ]; then
			kill -9 ${pid}
			echo "netev_alarm.sh is stopped!"
		fi
	done
	opened=`floweye nevt stat | grep -v MODULE_NEXIST | grep notify2user=1`
	[ "${opened}" != "" ] && ${PGPATH}/bin/netev_alarm.sh &
}

# Assign all interrupts to CPU0
irq_bind()
{
	# It's not necessary for irq bind on linux.
	# isolcpus has done this.
	echo "no need for irq_bind on linux"
}

# Start network
start_network()
{
	# Setup admin interface
	. ${PGETC}/ifadmin.conf
	if [ "${ADMIN_IP}" != "" -a "${ADMIN_MASK}" != "" ]; then
		ipaddr=`ip addr show ${ADMIN_PORT} | grep -v inet6 | grep "inet " | awk '{print $2}' | cut -d'/' -f1`
		if [ "${ipaddr}" != "${ADMIN_IP}" ]; then
			if [ "${ipaddr}" != "" ]; then
				ip addr del dev ${ADMIN_PORT} ${ipaddr}
			fi
			ip addr add dev ${ADMIN_PORT} ${ADMIN_IP}/${ADMIN_MASK}
			ip link set dev ${ADMIN_PORT} up
		fi
	fi

	# Setup gateway.
	gateway=`netstat -rn | grep "^0.0.0.0" | awk '{print $2}' 2>/dev/null`
	if [ "${gateway}" != "${GATEWAY}" ]; then
		ermsg=`ip route del default 2>&1`
		if [ "${ADMIN_MASK}" = "255.255.255.255" ]; then
			ipnet=`echo "${ADMIN_IP}" | awk -F"." '{printf "%s.%s.%s.0", $1, $2, $3}'`
			ip route add ${ipnet}/255.255.255.0 dev ${ADMIN_PORT}
		fi
		ip route add default via ${GATEWAY} dev ${ADMIN_PORT} onlink
		echo "Set default gateway to ${GATEWAY}"
	fi

	ip addr show ${ADMIN_PORT}
	echo "network is started!"
	return 0
}

# Start kernel
start_kernel()
{
	mkdir -p /var/tmp

	# setup loopback interface lo
	if [ "`uname -m`" = "aarch64" ]; then
		ip link set dev lo up
	fi

	###sysctl net.ipv4.ip_local_port_range="62001 65000"
	sysctl net.ipv4.tcp_fin_timeout=4
	sysctl net.ipv4.tcp_keepalive_intvl=3
	sysctl net.ipv4.tcp_keepalive_probes=3
	sysctl net.ipv4.tcp_keepalive_time=3
	num=`sysctl -n net.ipv4.tcp_max_syn_backlog`
	if [ ${num} -lt 256 ]; then
		sysctl net.ipv4.tcp_max_syn_backlog=256
	fi

	osver=`uname -r | cut -d'.' -f1`
	kernelpath="${PGPATH}/kernel"
	ramkernel="/usr/ramdisk/kernel"
	if [ "${osver}" = "5" ]; then
		[ -f ${kernelpath}/joskm5.ko ] && mv ${kernelpath}/joskm5.ko ${kernelpath}/joskm.ko
		[ -f ${ramkernel}/joskm5.ko  ] && mv ${ramkernel}/joskm5.ko ${ramkernel}/joskm.ko
	fi
	# try to load our joskm.ko
	if [ ! -e /dev/jos ]; then
		errmsg=`insmod ${PGPATH}/kernel/joskm.ko 2>&1`
	fi

	# for vMGT&bgp (not vMGT0&vMGT1)
	if [ ! -e /dev/joskni ]; then
		# try rom's kernel module first
		if [ -e /rom/usr/panabit/kernel/joskni.ko ]; then
			errmsg=`insmod /rom/usr/panabit/kernel/joskni.ko 2>&1`
		elif [ -e ${PGPATH}/kernel/joskni.ko ]; then
			errmsg=`insmod ${PGPATH}/kernel/joskni.ko 2>&1`
		fi
	fi

	# close cpufreq
	cpu=0
	while [ ${cpu} -le 64 ]
	do
		cfgfile=/sys/devices/system/cpu/cpu${cpu}/cpufreq/scaling_governor
		if [ -e ${cfgfile} ]; then
			echo performance > ${cfgfile} 2>/dev/null
		fi

		cpu=$((${cpu} + 1))
	done

	# clean firewall policies, let 443 be accessable.
	which iptables 1>/dev/null 2>&1

	if [ $? -eq 0 ]; then
		iptables -F
	fi

	MSGPIPE=/usr/msgpipe
	mkdir -p ${MSGPIPE}
	remount=""
	pipemd=`df | grep "${MSGPIPE}"`
        [ "${pipemd}" != "" ] && remount="-o remount"
	mount -t tmpfs ${remount} -o size=8M tmpfs ${MSGPIPE}
	if [ "$?" != "0" ]; then
		echo "FAIL TO CREATE MSGPIPE RAMDISK!"
		exit 1
	else
		echo "msgpipe ramdisk created!";
	fi

	# create dynrtd pipe
	if [ ! -e ${MSGPIPE}/dynrtd ]; then
		[ "${DYNRT_BLKSZ}" = "" ] && DYNRT_BLKSZ=64
		[ "${DYNRT_COUNT}" = "" ] && DYNRT_COUNT=6192
		errmsg=`${FLOWEYE} msgpipe init file=${MSGPIPE}/dynrtd bs=${DYNRT_BLKSZ} count=${DYNRT_COUNT}`
		[ "$?" != "0" ] && echo "dynrtd pipe fail: ${errmsg}"
	fi
	# create dynrtio pipe
	if [ ! -e ${MSGPIPE}/dynrtio ]; then
		errmsg=`${FLOWEYE} msgpipe init file=${MSGPIPE}/dynrtio bs=2048 count=192`
		[ "$?" != "0" ] && echo "dynrtio pipe fail: ${errmsg}"
	fi

	# create sslsvr pipe
	if [ ! -e ${MSGPIPE}/sslsvr ]; then
		errmsg=`${FLOWEYE} msgpipe init file=${MSGPIPE}/sslsvr bs=2048 count=256`
		[ "$?" != "0" ] && echo "sslsvr pipe fail: ${errmsg}"
	fi

	if [ ! -e ${MSGPIPE}/switch ]; then
		errmsg=`${FLOWEYE} msgpipe init file=${MSGPIPE}/switch bs=2048 count=256`
		[ "$?" != "0" ] && echo "switch pipe fail: ${errmsg}"
	fi

	if [ -f /lib/modules/$(uname -r)/stmmac_uio.ko ]; then
		insmod /lib/modules/$(uname -r)/stmmac_uio.ko
	fi

	return 0
}

stop_kernel()
{
	if [ -f /lib/modules/$(uname -r)/stmmac_uio.ko ]; then
		rmmod stmmac_uio
	fi
}

httpd_action()
{
	case "$1" in
	"start")
                rm -rf ${ADMIN}/tmp
                mkdir -p ${ADMIN}/tmp
                echo "Starting ipe_httpd ......"
                [ "${HTTPS_PORT}" = "" ] && HTTPS_PORT=443
                if [ ! -f "${PGETC}/httpd.conf" ]; then
                        echo "ssl=1" > ${PGETC}/httpd.conf
                        echo "port=${HTTPS_PORT}" >> ${PGETC}/httpd.conf
                        echo "user=root" >> ${PGETC}/httpd.conf
                        echo "max_age=1" >> ${PGETC}/httpd.conf
                        echo "maxchld=400" >> ${PGETC}/httpd.conf
                        echo "charset=gb2312" >> ${PGETC}/httpd.conf
                        echo "dir=/usr/ramdisk/admin" >> ${PGETC}/httpd.conf
                        echo "certfile=/usr/ramdisk/admin/admin.pem" >> ${PGETC}/httpd.conf
                fi
                ${HTTPD} -C "${PGETC}/httpd.conf"
                echo "ipe_httpd is started!"
                return 0
		;;

	"stop")
		pkill ipe_httpd
		echo "httpd is stopped!"
		return 0
		;;

	"*")
		echo "unknown action \"$1\""
		return 1
		;;
	esac
}

ntmlog_action()
{
	[ ! -e ${PGBIN}/ntmlogd ] && return 0

	case "$1" in
	"start")
		${PGBIN}/ntmlogd &
		echo "ntmlogd is started!"
		return 0
		;;

	"stop")
		killall ntmlogd
		echo "ntmlogd is stopped!"
		return 0
		;;

	"*")
		echo "unknown action \"$1\""
		return 1
		;;
	esac
}

monitor_action()
{
	case "$1" in
	"start")
		${PGBIN}/ipe_monitor &
		echo "ipe_monitor is started!"
		return 0
		;;

	"stop")
		# kill monitor if it exists
		ps ax | grep ipe_monitor | awk '{print $1, $6}' | \
		while read pid path; do
			if [ "${path}" = "${PGPATH}/bin/ipe_monitor" ]; then
				kill -9 ${pid}
				echo "monitor is stopped!"
			fi
		done

		return 0
		;;

	"*")
		echo "unknown action \"$1\""
		return 1
		;;

	esac
}

datamon_action()
{
	case "$1" in
	"start")
		if [ -e ${RAMLOG}/keepme ]; then
			${PGBIN}/ipe_datamon -d ${RAMLOG} &
		else
			${PGBIN}/ipe_datamon &
		fi
		echo "data monitor is started!"
		return 0
		;;

	"stop")
		# kill monitor if it exists
		pkill ipe_datamon
		return 0
		;;

	"*")
		echo "unknow action \"$1\""
		;;

	esac
}

xping_action()
{
	case "$1" in
	"start")
		${PGBIN}/ipe_xping &
		;;

	"stop")
		pkill ipe_xping
		;;

	"*")
		echo "unknown action \"$1\""
		;;

	esac
}

mgd_action()
{
	case "$1" in
	"start")
		${PGBIN}/ipe_mgd &
		;;

	"stop")
		pkill ipe_mgd
		;;

	"*")
		echo "unknown action \"$1\""
		;;

	esac
}

panaos_action()
{
	case "$1" in
	"start")
		if [ -f /lib/modules/$(uname -r)/stmmac_uio.ko ]; then
			res=`lsmod | grep stmmac_uio | awk '{print $1}'`
			if [ "$res" != "stmmac_uio" ]; then
				insmod /lib/modules/$(uname -r)/stmmac_uio.ko
			fi
		fi

		# let system create core file in ${DATAPATH}
		cd ${DATAPATH}
		[ "${ETHERMTU}" = "" ] && export ETHERMTU=1500
		if [ ! -e ${RAMDISK}/bin/dpi.so ]; then
			if [ -e ${RAMDISK}/bin/dpi.so.new ]; then
				mv ${RAMDISK}/bin/dpi.so.new ${RAMDISK}/bin/dpi.so
			elif [ -e ${PGPATH}/bin/dpi.so.new ]; then
				cp -f ${PGPATH}/bin/dpi.so.new ${RAMDISK}/bin/dpi.so
			fi
		fi

		${PGBIN}/panaos 
		
		# wait panaos to load configuration
		active=0
		count=60
		while [ ${count} -ge 0 ]; do
			active=`floweye config stat | grep "^cfgload=" | cut -d'=' -f2`
			[ "${active}" = "1" ] && break
			DELAY100MS 5
			count=$((${count} - 1))
		done
		if [ "${active}" = "1" ]; then
			echo "***PANAOS IS READY!***"
		else
			echo "WARNNING: PANAOS IS NOT READY!"
			DELAY100MS 5
		fi
		cd -
		[ -x /usr/bin/beep ] && beep -r 4
		;;

	"stop")
		pkill panaos 2>/dev/null
		DELAY100MS 1
		pkill panaos 2>/dev/null
		stop_kernel
		;;

	"*")
		echo "unknown action \"$1\""
		;;

	esac
}

sshd_stop()
{
	which service 1>/dev/null 2>&1

	if [ $? -eq 0 ]; then
		service sshd stop
	else
		/etc/rc.d/init.d/sshd stop
	fi
}

if [ "$1" = "help" ]; then
	echo "start network : start network"
	echo "start httpd: start httpd daemon"
	echo "start monitor: start monitor service"
	echo "start kernel: load kernel module"
	echo "start datamon: start data monitor"
	echo "start xping: start xping engine"
	echo "start all: start all above service"

	echo ""
	echo "stop httpd: stop httpd daemon"
	echo "stop monitor: stop monitor service"
	echo "stop datamon: stop data monitor"
	echo "stop xping: stop xping engine"
	echo "stop all: stop all above service"

	echo "restore: restore the original configuration"
	exit 0
fi

if [ "$1" = "start" ]; then
	target="$2"
	[ "${target}" = "" ] && target="all"

	case "${target}" in
	"httpd")
		httpd_action "start"
		;;

	"monitor")
		monitor_action "start"
		;;

	"datamon")
		datamon_action "start"
		;;

	"xping")
		xping_action "start"
		;;

	"mgd")
		mgd_action "start"
		;;

	"kernel")
		start_kernel
		;;

	"network")
		start_network
		;;

	"panaos")
		panaos_action "start"
		;;

	"ntmlogd")
		ntmlog_action "start"
		;;

	"all")
		start_kernel
		panaos_action  "start"
		start_network
		httpd_action   "start"
		monitor_action "start"
		datamon_action "start"
		xping_action   "start"
		mgd_action     "start"
		ntmlog_action  "start"
		irq_bind
		sshd_stop
		start_netev_alarm

		${PGBIN}/appctrl start
		;;

	*)
		${PGBIN}/appctrl start $2
		;;

	esac
fi

if [ "$1" = "stop" ]; then
	target="$2"
	[ "${target}" = "" ] && target="all"

	case "${target}" in
	"httpd")
		httpd_action "stop"
		;;

	"ntmlogd")
		ntmlog_action "stop"
		;;

	"monitor")
		monitor_action "stop"
		;;

	"datamon")
		datamon_action "stop"
		;;

	"xping")
		xping_action "stop"
		;;

	"mgd")
		mgd_action "stop"
		;;

	"iked")
		pkill iked
		;;

	"panaos")
		panaos_action "stop"
		;;

	"kernel")
		#kldunload if_em
		#kldunload joskm
		;;

	"all")
		monitor_action "stop"
		httpd_action   "stop"
		datamon_action "stop"
		xping_action   "stop"
		mgd_action     "stop"
		pkill iked
		ntmlog_action 	"stop"
		panaos_action  "stop"
		${PGBIN}/appctrl stop
		DELAY100MS 3
		stop_kernel
		;;

	*)
		${PGBIN}/appctrl stop $2
		;;
	
	esac
fi

