#! /bin/sh
DEBUG_NETWORK_FLAG="/var/tvip/log/debug_network"
DEBUG_NETWORK_FILE="/tmp/network.log"
DEVICE_ID=`cat /etc/tvip_deviceid`
DNSMASQ_CONF="/tmp/dnsmasq.conf"
PID=$$

# default network config dir
NETWORK_CONFIGS_DIR=/var/tvip

# Need for factory image
if [ -f /tmp/netconfdir ]; then
  NETWORK_CONFIGS_DIR=`cat /tmp/netconfdir`
fi


# Check new wireless iw tools
if [ -f /usr/sbin/iw ]; then
  IW_WIRELESS="1"
fi


log_net() {
  echo "NETWORK[${PID}]: $@"
  echo "NETWORK[${PID}]: $@" | logger
  if [ -f ${DEBUG_NETWORK_FLAG} ]; then
    echo `date` "NETWORK[${PID}]: $@" >> ${DEBUG_NETWORK_FILE}
  fi
}

log_int() {
  IFACE=$1
  shift
  echo "NETWORK [${IFACE}]: $@"
  echo "NETWORK [${IFACE}]: $@" | logger
  if [ -f ${DEBUG_NETWORK_FLAG} ]; then
    echo `date` "NETWORK [${IFACE}]: $@" >> ${DEBUG_NETWORK_FILE}
  fi
}

runonstart() {
  ########################
  # NFS portmapper will not work without loopback!
  log_net "Configuring loopback..."
  ifconfig lo 127.0.0.1 netmask 255.0.0.0

  #Making dir tmp-config - need for some reasons
  if [ ! -d /tmp/config ];then
    mkdir /tmp/config
  fi

  if [ -f /etc/hostname ]; then
    HOSTNAME=`cat /etc/hostname`
    log_net "Setting hostname to ${HOSTNAME}"
    hostname ${HOSTNAME}
  fi

  #
  # Legacy - convert ${NETWORK_CONFIGS_DIR}/network to network.eth0
  # this really don't needed
  if [[ -f "${NETWORK_CONFIGS_DIR}/network" && ! -f ${NETWORK_CONFIGS_DIR}/network.eth0 ]]; then
    log_net "Legacy: Moving ${NETWORK_CONFIGS_DIR}/network to ${NETWORK_CONFIGS_DIR}/network.eth0"
    mv ${NETWORK_CONFIGS_DIR}/network ${NETWORK_CONFIGS_DIR}/network.eth0
    sync
  fi

}




get_interface_type() {
  if [ -n "`echo $1 | grep wlan`" ]; then
    echo "wireless"
  else
    echo "wired"
  fi
}

is_interface_running() {
  if [ -n "`ifconfig $1 | grep "RUNNING"`" ]; then
    echo "1"
  else
    echo ""
  fi
}


kill_pids() {
  REGEXP=$1

  PIDS=`ps ax | grep -v grep | grep -E "${REGEXP}" | awk '{print $1}'`
  for PID in ${PIDS} ; do
    CMD=`cat /proc/${PID}/comm`
    log_net "Killing ${CMD} (pid ${PID})"
    kill ${PID}
  done
}

kill_pids_interface() {
  INTERFACE=$1
  REGEXP=$2

  PIDS=`ps ax | grep -v grep | grep -E "${REGEXP}" | grep ${INTERFACE} | awk '{print $1}'`
  for PID in ${PIDS} ; do
    CMD=`cat /proc/${PID}/comm`
    log_int ${INTERFACE} "Killing ${CMD} (pid ${PID})"
    kill ${PID}
  done
}

get_config_param() {
  CONFIG_FILE=$1
  CONFIG_PARAM=$2
#  echo `cat ${CONFIG_FILE} | grep -vE "^#" | grep ${CONFIG_PARAM} | cut -f2 -d'='`
echo "$(cat ${CONFIG_FILE} | grep -vE "^#" | grep ${CONFIG_PARAM} | sed "s/${CONFIG_PARAM}=//")"
}

#
# Set variables according interface config nad defaults
#
export_interface_vars() {
  INTERFACE=$1

  export INTERFACE_TYPE=`get_interface_type ${INTERFACE}`
  export INTERFACE_RUNNING=`is_interface_running ${INTERFACE}`

  STATIC_CONFIG_FILENAME="${NETWORK_CONFIGS_DIR}/network.${INTERFACE}"
  if [ -f ${STATIC_CONFIG_FILENAME} ]; then
      log_int ${INTERFACE} "Using config from ${STATIC_CONFIG_FILENAME}"
  else
      STATIC_CONFIG_FILENAME="/dev/null" #empty vars
  fi

  NETWORK_TYPE="DHCP"

  export IPADDR=`get_config_param ${STATIC_CONFIG_FILENAME} IPADDR`
  export NETMASK=`get_config_param ${STATIC_CONFIG_FILENAME} NETMASK`
  export GATEWAY=`get_config_param ${STATIC_CONFIG_FILENAME} GATEWAY`
  export METRIC=`get_config_param ${STATIC_CONFIG_FILENAME} METRIC`
  export DNSSTATIC=`get_config_param ${STATIC_CONFIG_FILENAME} DNSSTATIC`
  export DISABLED=`get_config_param ${STATIC_CONFIG_FILENAME} DISABLED`
  export ROUTER=`get_config_param ${STATIC_CONFIG_FILENAME} ROUTER`
  export NAT=`get_config_param ${STATIC_CONFIG_FILENAME} NAT`

  export WIFI_SSID=`get_config_param ${STATIC_CONFIG_FILENAME} WIFI_SSID`
  export WIFI_WEP_PASSPHRASE=`get_config_param ${STATIC_CONFIG_FILENAME} WIFI_WEP_PASSPHRASE`
  export WIFI_WPA_PASSPHRASE=`get_config_param ${STATIC_CONFIG_FILENAME} WIFI_WPA_PASSPHRASE`
  export WIFI_CHANNEL=`get_config_param ${STATIC_CONFIG_FILENAME} WIFI_CHANNEL`
  export WIFI_COUNTRY=`get_config_param ${STATIC_CONFIG_FILENAME} WIFI_COUNTRY`
  export WIFI_AP_MAX_STATIONS=`get_config_param ${STATIC_CONFIG_FILENAME} WIFI_AP_MAX_STATIONS`

  # if interface has ip and netmask then set it to statuc
  if [[ -n "${IPADDR}" && -n "${NETMASK}" ]]; then
      NETWORK_TYPE="STATIC"
  fi

  # set default metric
  if [ -z "${METRIC}" ]; then
      if [ "${INTERFACE_TYPE}" = "wireless" ]; then
          METRIC="5"
      else
          METRIC="1"
      fi
  fi

  export NETWORK_TYPE
  export METRIC

}

make_resolv_conf() {
  log_net "[RESOLV.CONF] Begin"

  MAKE_RESOLVCONF_LOCK_FILE="/tmp/make_resolv_conf"
  TMP_RESOLVCONF="/tmp/resolv.conf-tmp.${PID}" # should be not match "/tmp/resolv.conf.*" to avoid recursion

  #
  # This function will merge ALL /tmp/resolv.conf.{INTERFACE} files
  #
  while [ 1 ]; do
    if [ -f ${MAKE_RESOLVCONF_LOCK_FILE} ]; then
      LOCKED_BY_PID=`cat ${MAKE_RESOLVCONF_LOCK_FILE}`
      log_net "[RESOLV.CONF] Locked by ${LOCKED_BY_PID}, waiting..."
      sleep 1;
    else
      echo ${PID} > ${MAKE_RESOLVCONF_LOCK_FILE}
      log_net "[RESOLV.CONF] Lock ok..."
      break;
    fi
    log_net "[RESOLV.CONF] Staring without lock..."
    break;
  done

  echo > ${TMP_RESOLVCONF}

  log_net "[RESOLV.CONF] Making new resolv.conf"

  for INTERFACE_RESOLV_CONF_FILE in `ls /tmp/resolv.conf.*`; do
      cat ${INTERFACE_RESOLV_CONF_FILE} >> ${TMP_RESOLVCONF}
  done

  #fix timeout with parallel resolving ipv4 and ipv6
  echo "options single-request" >> ${TMP_RESOLVCONF}

  if [[ -n "${BOOT_FROM_NFS}" ]]; then
    log_net "[RESOLV.CONF] NFS boot detected, adding 8.8.8.8"
    echo "nameserver 8.8.8.8" >> ${TMP_RESOLVCONF}
  fi

  cat ${TMP_RESOLVCONF} > /etc/resolv.conf

  log_net "[RESOLV.CONF] New resolv.conf done"

  rm -f ${MAKE_RESOLVCONF_LOCK_FILE}
  rm -f ${TMP_RESOLVCONF}
}

stopnetwork() {
    for INTERFACE in ${INTERFACES_LIST}; do

      export_interface_vars ${INTERFACE}

      log_int ${INTERFACE} "Stopping, type: ${INTERFACE_TYPE}"

      kill_pids_interface ${INTERFACE} "dhclient" # After kill all dhclient instances

      kill_pids_interface ${INTERFACE} "hostapd"

      kill_pids_interface ${INTERFACE} "startwifi"

      if [ "${INTERFACE_TYPE}" = "wireless" ]; then
        log_int ${INTERFACE} "Resetting WiFi SSID"
        #if [ -n "${IW_WIRELESS}" ]; then
        #  iw ${INTERFACE} disconnect > /dev/null 2>&1 # ingore error
        #else
        #  iwconfig ${INTERFACE} ap 00:00:00:00:00:01
        #fi
        wpa_cli -p /tmp/wpa-supplicant -i ${INTERFACE} disconnect
      fi
      kill_pids_interface ${INTERFACE} "wpa_supplicant"

      log_int ${INTERFACE} "Removing NAT"
      iptables -t nat -D POSTROUTING -o ${INTERFACE} -j MASQUERADE > /dev/null 2>&1 # ingore error

      if [[ -n "${BOOT_FROM_NFS}" && "${INTERFACE}" == "eth0" ]]; then
        log_int ${INTERFACE} "Booted from NFS, keep original IP (stopnetwork)"
        continue
      fi
      log_int ${INTERFACE} "Checking for default routes"

      if [ -n "`route -n | grep default | grep ${INTERFACE}`" ]; then
        log_int ${INTERFACE} "Deleting default route"
        route del default dev ${INTERFACE}
      fi

      log_int ${INTERFACE} "Removing all IP addresses"
      ifconfig ${INTERFACE} inet 0.0.0.0

      log_int ${INTERFACE} "Stopped"
      #ifconfig ${INTERFACE} down # Never shutdown interface. We need to keet it up if want to get it state (RUNNING)
    done

    #################################################################

    log_net "Stopping dnsmasq"
    kill_pids "startdnsmasq" #first kill wrapper
    kill_pids "dnsmasq"      #after kill instances

}

write_static_dns_servers() {
  #
  # Write DNS servers to /tmp/resolv.conf.${INTERFACE}
  #
  DNS_SERVERS=`cat ${STATIC_CONFIG_FILENAME} | grep -e "^DNS=" | cut -f2 -d'='`

  if [ -n "${DNS_SERVERS}" ]; then
      echo > ${INTERFACE_RESOLV_CONF_FILE}
      for DNS in ${DNS_SERVERS}; do
          log_net "[RESOLV.CONF] Adding DNS ${DNS} from ${STATIC_CONFIG_FILENAME}"
          echo "nameserver ${DNS}" >> ${INTERFACE_RESOLV_CONF_FILE}
      done
  else
      log_net "[RESOLV.CONF] Interface ${INTERFACE} has STATIC config but no DNS server found, removing ${INTERFACE_RESOLV_CONF_FILE}"
      rm -f ${INTERFACE_RESOLV_CONF_FILE}
  fi

}

#
# IP address of interface manage
#
perform_interface_ip_address_reconfiguring() {
  INTERFACE=$1
  INTERFACE_RESOLV_CONF_FILE=/tmp/resolv.conf.${INTERFACE}

  export_interface_vars ${INTERFACE}

  if [[ -n "${BOOT_FROM_NFS}" && "${INTERFACE}" == "eth0" ]]; then
    log_int ${INTERFACE} "Booted from NFS, keep original IP (perform_interface_ip_address_reconfiguring)"
    continue
  fi

  log_int ${INTERFACE} "Checking IP addreses configuration, INTERFACE_RUNNING: ${INTERFACE_RUNNING}"

  if [[ -z "${INTERFACE_RUNNING}" || -n "${DISABLED}" ]]; then
      log_int ${INTERFACE} "Interface is not running or disabled, removing any IP addresses"
      ifconfig ${INTERFACE} 0.0.0.0

      if [ "${NETWORK_TYPE}" = "DHCP" ]; then
          kill_pids_interface ${INTERFACE} "dhclient" # After kill all dhclient instances
      fi

      rm -f /tmp/resolv.conf.${INTERFACE} # Remove resolv.conf for interface

      return 0
  fi

  if [ "${NETWORK_TYPE}" = "STATIC" ]; then

      log_int ${INTERFACE} "Network type: STATIC, ip: ${IPADDR} mask: ${NETMASK} gw: ${GATEWAY}, metric: ${METRIC}"

      #
      # make sure that dhcp is not running for this interface
      #
      kill_pids_interface ${INTERFACE} "dhclient" # After kill all dhclient instances

      #
      # We can check if current IP and netmask != required but seems it is no needed
      #
      ifconfig ${INTERFACE} ${IPADDR} netmask ${NETMASK}

      RET=$?
      if [ "${RET}" -ne "0" ]; then
          log_int ${INTERFACE} "ifconfig error: code ${RET}"
          continue
      fi

      #
      # Gateway - change if differenet, delete if not set
      #
      CURRENT_GATEWAY=`route -n | grep default | grep ${INTERFACE} | awk '{print $2}'`

      if [ "${CURRENT_GATEWAY}" != "${GATEWAY}" ]; then
          if [ -n "${CURRENT_GATEWAY}" ]; then
              log_int ${INTERFACE} "Deleting default route ${CURRENT_GATEWAY}"
              route del default dev ${INTERFACE}
          fi

          if [ -n "${GATEWAY}" ]; then
              log_int ${INTERFACE} "Adding default route ${GATEWAY}"
              route add default gw ${GATEWAY} dev ${INTERFACE} metric ${METRIC}
          fi
      fi

      write_static_dns_servers


  else
      DHCP_PIDS=`ps ax | grep -v grep | grep -E "dhclient" | grep ${INTERFACE} | awk '{print $1}'`

      if [[ -n "${DHCP_PIDS}" ]]; then
          log_int ${INTERFACE} "Network type: DHCP, dhclient already runing, PID: ${DHCP_PIDS}"
      else
          log_int ${INTERFACE} "Network type: DHCP, starting dhclient"

          rm -f /tmp/resolv.conf.${INTERFACE} # Remove OLD resolv.conf for interface before starting dhclient

          #
          # Since 10.11.2015 we dont use wrapper for dhcp
          # Because netplug
          #
          DHCP_PIDFILE="/tmp/dhclient-${INTERFACE}.pid"

          if [ "${DNSSTATIC}" = "1" ]; then
            #In that case, use values from config file and mark dhclient not set dns from dhcp
            write_static_dns_servers
          fi
          dhclient -d -pf ${DHCP_PIDFILE} -e IF_METRIC=${METRIC} -lf /tmp/dhclient-${INTERFACE}.leases -sf /etc/dhcp/dhclient-script -cf /etc/dhcp/dhclient.conf ${INTERFACE} -e DNSSTATIC=${DNSSTATIC} &
      fi
  fi

}



startnetwork() {
    #################################################################
    # DNSMASQ
    #################################################################
    DNSMASQ_ENABLED=""
    DNSMASQ_CONF_TMP=${DNSMASQ_CONF}.tmp
    echo bind-interfaces > ${DNSMASQ_CONF_TMP}

    #################################################################
    # Configuring interfaces
    #################################################################
    for INTERFACE in ${INTERFACES_LIST}; do

      INTERFACE_TYPE=`get_interface_type ${INTERFACE}`

      log_int ${INTERFACE} "Starting, type: ${INTERFACE_TYPE}"

      export_interface_vars ${INTERFACE}

      if [ -n "${DISABLED}" ]; then
        log_int ${INTERFACE} "Interface disabled by config"
        ifconfig ${INTERFACE} inet 0.0.0.0
        #ifconfig ${INTERFACE} down # Never shutdown interface. We need to keet it up if want to get it state (RUNNING)
        if [[ "${INTERFACE_TYPE}" = "wireless" && -f "/etc/init.d/S30wireless" ]]; then
            #Switch wifi to Client mode, to be able to search for networks
            sh /etc/init.d/S30wireless changemode ${INTERFACE}
        fi
        #Clear resolv.conf
        rm -f /tmp/resolv.conf.${INTERFACE}
        continue
      else
        ifconfig ${INTERFACE} up
      fi


      if [ -n "${NAT}" ]; then
          log_int ${INTERFACE} "Enabling NAT"
          iptables -t nat -A POSTROUTING -o ${INTERFACE} -j MASQUERADE
      fi

      if [ -n "${ROUTER}" ]; then
          if [[ -z "${IPADDR}" || -z "${NETMASK}" ]]; then
              ROUTER=""
              log_int ${INTERFACE} "ERROR: Router mode was set but not IP address or netmask. Ignoring router mode"
          else
              #
              IPADDR_SUBNET_C=`echo ${IPADDR} | awk -F "." '{print $1"."$2"."$3}'`
              DHCP_HOURS="12h"
              log_int ${INTERFACE} "Adding interface to ${DNSMASQ_CONF_TMP}"
              echo interface=${INTERFACE} >> ${DNSMASQ_CONF_TMP}
              echo dhcp-range=${IPADDR_SUBNET_C}.100,${IPADDR_SUBNET_C}.254,${DHCP_HOURS} >> ${DNSMASQ_CONF_TMP} #

              DNSMASQ_ENABLED=1 # set flag to indicate that dnsmasq should be run
          fi
      fi


      ##############################################################################
      # Wireless
      ##############################################################################
      if [[ "${INTERFACE_TYPE}" = "wireless" ]]; then
          #
          # Common WIFI
          #

          if [ -f "/etc/init.d/S30wireless" ]; then
              sh /etc/init.d/S30wireless changemode ${INTERFACE} "${ROUTER}"
          fi

	  if [ -z "${WIFI_SSID}" ]; then
            log_int ${INTERFACE} "Wi-Fi: WIFI_SSID not specified for wireless interface. Ignoring"
            continue
          fi


          if [ -n "${ROUTER}" ]; then
              #
              # WIFI router
              #
              log_int ${INTERFACE} "Wi-Fi: configuring as access point"

              if [ -z "${WIFI_CHANNEL}" ]; then
                  WIFI_CHANNEL=6
                  log_int ${INTERFACE} "Wi-Fi: channel not set, Using default channel: ${WIFI_CHANNEL}"
              fi

              if [ ${WIFI_CHANNEL} -gt 20 ]; then
                  WIFI_HWMODE=a
              else
                  WIFI_HWMODE=g
              fi

              if [ -z "${WIFI_COUNTRY}" ]; then
                  WIFI_COUNTRY="AU"
                  log_int ${INTERFACE} "Wi-Fi: country not set, Using default country: ${WIFI_COUNTRY}"
              fi


              HOSTAPD_CONFIG="/tmp/hostapd-${INTERFACE}.conf"

              #
              # https://w1.fi/cgit/hostap/plain/hostapd/hostapd.conf
              #
              echo interface=${INTERFACE} > ${HOSTAPD_CONFIG}
              echo driver=nl80211 >> ${HOSTAPD_CONFIG}
              echo ssid=${WIFI_SSID} >> ${HOSTAPD_CONFIG}
              echo hw_mode=${WIFI_HWMODE} >> ${HOSTAPD_CONFIG}
              echo channel=${WIFI_CHANNEL} >> ${HOSTAPD_CONFIG}
              echo country_code=${WIFI_COUNTRY} >> ${HOSTAPD_CONFIG}
              #
              echo ctrl_interface=/tmp/hostapd-ctrl.${INTERFACE} >> ${HOSTAPD_CONFIG}
              echo ctrl_interface_group=0 >> ${HOSTAPD_CONFIG}

              # next parameters need to enable 802.11n
              echo wmm_enabled=1 >> ${HOSTAPD_CONFIG}
              echo ieee80211d=1 >> ${HOSTAPD_CONFIG}
              echo ieee80211n=1 >> ${HOSTAPD_CONFIG}
              echo ieee80211ac=1 >> ${HOSTAPD_CONFIG}

              if [ -n "${WIFI_AP_MAX_STATIONS}" ]; then
                  echo max_num_sta=${WIFI_AP_MAX_STATIONS} >> ${HOSTAPD_CONFIG}
              fi

              if [ -z "${WIFI_WPA_PASSPHRASE}" ]; then
                  # open
                  log_int ${INTERFACE} "Wi-Fi using unprotected access point"
                  #echo auth_algs=0 >> ${HOSTAPD_CONFIG}
                  #echo wpa=0 >> ${HOSTAPD_CONFIG}
                  echo macaddr_acl=0 >> ${HOSTAPD_CONFIG}
              else
                  # wpa
                  log_int ${INTERFACE} "Wi-Fi: using WPA2 access point"
                  echo wpa=2 >> ${HOSTAPD_CONFIG} # Enable WPA2 only (1 for WPA, 2 for WPA2, 3 for WPA + WPA2)
                  echo wpa_passphrase=${WIFI_WPA_PASSPHRASE} >> ${HOSTAPD_CONFIG}
                  echo wpa_pairwise=TKIP CCMP >> ${HOSTAPD_CONFIG}
                  echo rsn_pairwise=CCMP >> ${HOSTAPD_CONFIG}
              fi


              log_int ${INTERFACE} "Wi-Fi: Starting hostapd"
              /usr/sbin/hostapd -B -d ${HOSTAPD_CONFIG}

          else
              #
              # Just wifi client
              #
              log_int ${INTERFACE} "Configuring as WiFi client"

              WPA_DIR="/tmp/wpa-supplicant"
              mkdir -p ${WPA_DIR}

              WPA_CONFIG_FILE="/tmp/network-wpa-${INTERFACE}.conf"
              rm -f ${WPA_CONFIG_FILE}

              #if [ -n "${WIFI_WPA_PASSPHRASE}" ]; then
              #  log_int ${INTERFACE} "Wi-Fi: Encryption: WPA (${WPA_CONFIG_FILE})"
              #
              #  echo "ctrl_interface=DIR=${WPA_DIR} GROUP=root" > ${WPA_CONFIG_FILE}
              #  wpa_passphrase "${WIFI_SSID}" "${WIFI_WPA_PASSPHRASE}" >> ${WPA_CONFIG_FILE}
              #
              #  log_int ${INTERFACE} "Wi-Fi: Starting wpa_supplicant"
              #  if [[ "${DEVICE_ID}" == "s300" ]]; then
              #      wpa_supplicant -B -Dwext -i ${INTERFACE} -c ${WPA_CONFIG_FILE}
              #  else
              #      wpa_supplicant -B -Dnl80211,wext -i ${INTERFACE} -c ${WPA_CONFIG_FILE}
              #  fi
              #
              #elif [ -n "${WIFI_WEP_PASSPHRASE}" ]; then
              #  log_int ${INTERFACE} "Wi-Fi: Encryption: WEP "
              #
              #  if [ -n "${IW_WIRELESS}" ]; then
              #    iw ${INTERFACE} connect ${WIFI_SSID} keys 0:"${WIFI_WEP_PASSPHRASE}"
              #  else
              #    iwconfig ${INTERFACE} key s:"${WIFI_WEP_PASSPHRASE}"
              #  fi
              #
              #else
              #  log_int ${INTERFACE} "Wi-Fi: No encryption "
              #fi

              #if [ -n "${WIFI_WEP_PASSPHRASE}" ]; then
              #  log_int ${INTERFACE} "Wi-Fi: Starting startwifi with SSID: ${WIFI_SSID} and WEP_PASSPHRASE: ${WIFI_WEP_PASSPHRASE}"
              #  iw ${INTERFACE} set type managed
              #  startwifi ${INTERFACE} "${WIFI_SSID}" "${WIFI_WEP_PASSPHRASE}" & # Start auto-reconnecting script with WEP
              #else
              #  log_int ${INTERFACE} "Wi-Fi: Starting startwifi with SSID: ${WIFI_SSID}"
              #  iw ${INTERFACE} set type managed
              #  startwifi ${INTERFACE} "${WIFI_SSID}" & # Start auto-reconnecting script
              #fi

              log_int ${INTERFACE} "Wi-Fi: Starting supplicant (${WPA_CONFIG_FILE})"
              echo "ctrl_interface=DIR=${WPA_DIR} GROUP=root" > ${WPA_CONFIG_FILE}

              if [ -n "${WIFI_WPA_PASSPHRASE}" ]; then
                wpa_passphrase "${WIFI_SSID}" "${WIFI_WPA_PASSPHRASE}" >> ${WPA_CONFIG_FILE}
              else
                echo "network={" >> ${WPA_CONFIG_FILE}
                echo "ssid=\"${WIFI_SSID}\"" >> ${WPA_CONFIG_FILE}
                if [ -n "${WIFI_WEP_PASSPHRASE}" ]; then
                  echo "wep_key0=\"${WIFI_WEP_PASSPHRASE}\"" >> ${WPA_CONFIG_FILE}
                  echo wep_tx_keyidx=0 >> ${WPA_CONFIG_FILE}
                else
                  echo key_mgmt=NONE >> ${WPA_CONFIG_FILE}
                fi
                echo "}" >> ${WPA_CONFIG_FILE}
              fi

              if [[ "${DEVICE_ID}" == "s300" ]]; then
                wpa_supplicant -B -Dwext -i ${INTERFACE} -c ${WPA_CONFIG_FILE}
              else
                wpa_supplicant -B -Dnl80211,wext -i ${INTERFACE} -c ${WPA_CONFIG_FILE}
              fi
          fi
      fi

      #
      # Try to bring up IP address if interface is UP
      #
      perform_interface_ip_address_reconfiguring ${INTERFACE}
      /usr/sbin/easycwmp_scripts/set_local_interface.sh ${INTERFACE}

      log_int ${INTERFACE} "Started"

    done # EOF foreach INTERFACE

    if [ -n "${DNSMASQ_ENABLED}" ]; then
      log_net "Starting startdnsmasq with config ${DNSMASQ_CONF}"
      mv ${DNSMASQ_CONF_TMP} ${DNSMASQ_CONF}

      sysctl -w net.ipv4.ip_forward=1 #enable forwarding

      startdnsmasq ${DNSMASQ_CONF} &
    else
      log_net "DNSMASQ: dnsmasq not needed"
      rm ${DNSMASQ_CONF_TMP}

      kill_pids "startdnsmasq"
      kill_pids "dnsmasq"

      sysctl -w net.ipv4.ip_forward=0 # disable forwarding
    fi
}

######################################################################################
#
# Main script
#
######################################################################################

INTERFACES_LIST_ALL=`ifconfig -a | grep Link | grep -E "(eth|wlan|usbnet)" | awk '{print $1}'`

INTERFACES_LIST=${INTERFACES_LIST-${INTERFACES_LIST_ALL}}

# Check boot from NFS
if [ "`cat /proc/mounts | grep nfs | grep ' \/ '`" != "" ]; then
  BOOT_FROM_NFS="1"
fi

#Replace \n with spaces
INTERFACES_LIST=`echo ${INTERFACES_LIST} | sed "s/\n/ /"`

log_net "############ NFS: ${BOOT_FROM_NFS} NETPLUG: ${RUN_UNDER_NETPLUG} LIST: ${INTERFACES_LIST} DIR: ${NETWORK_CONFIGS_DIR} PARAMS: $@"

if [ -n "${RUN_UNDER_NETPLUG}" ]; then
  #
  # UNDER NETPLUG
  #
  log_net "############ NETPLUG run detected, reconfigure IP addresses only, interfaces: ${INTERFACES_LIST}"

  for INTERFACE in ${INTERFACES_LIST}; do
    perform_interface_ip_address_reconfiguring ${INTERFACE}
  done

  make_resolv_conf # always remake resolv.conf

else
  # NORMAL, NO NETPLUG
  case "$1" in
    start)
        runonstart
        startnetwork
        make_resolv_conf
        ;;

    stop)
        stopnetwork
        echo > /etc/resolv.conf # clear resolv.conf
        ;;

    restart|reload)
        $0 stop
        $0 start
        ;;

    make_resolv_conf)
        make_resolv_conf
        ;;

    *)
        echo "Usage: $0 {start|stop|restart}"
        exit 1
  esac

fi

log_net "############ Exiting"

exit $?
