UIPEthernet.cpp

/*
  UIPEthernet.cpp - Arduino implementation of a uIP wrapper class.
  Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
  All rights reserved.

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#if defined(ARDUINO)
  #include <Arduino.h>
#endif
#if defined(__MBED__)
  #include <mbed.h>
  #include "mbed/millis.h"
#endif
#include "UIPEthernet.h"
#include "utility/logging.h"
#include "utility/Enc28J60Network.h"

#include "UIPUdp.h"

extern "C"
{
#include "utility/uipopt.h"
#include "utility/uip.h"
#include "utility/uip_arp.h"
#include "utility/uip_timer.h"
}

#define ETH_HDR ((struct uip_eth_hdr *)&uip_buf[0])

memhandle UIPEthernetClass::in_packet(NOBLOCK);
memhandle UIPEthernetClass::uip_packet(NOBLOCK);
uint8_t UIPEthernetClass::uip_hdrlen(0);
uint8_t UIPEthernetClass::packetstate(0);

unsigned long UIPEthernetClass::periodic_timer;

IPAddress UIPEthernetClass::_dnsServerAddress;
#if UIP_UDP
  DhcpClass* UIPEthernetClass::_dhcp(NULL);
  static DhcpClass s_dhcp; // Placing this instance here is saving 40K to final *.bin (see bug below)
#endif

// Because uIP isn't encapsulated within a class we have to use global
// variables, so we can only have one TCP/IP stack per program.

UIPEthernetClass::UIPEthernetClass()
{
}

void UIPEthernetClass::init(const uint8_t pin)
{
  ENC28J60ControlCS = pin;
}

#if UIP_UDP
int
UIPEthernetClass::begin(const uint8_t* mac)
{
  // KH mod to work with new func void MACAddress(uint8_t *mac_address); and SinricPro v2.5.1+
  // Now store to private var _mac_address
  //uint8_t _mac_address[6] ={0,};
  memcpy(_mac_address, mac, sizeof(_mac_address));
  //////

#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::begin(const uint8_t* mac) DEBUG_V3:Function started"));
#endif
  //static DhcpClass s_dhcp; // <-- this is a bug !
  // I leave it there commented for history. It is bring all GCC "new" memory allocation code, making the *.bin almost 40K bigger. I've move it globally.
  _dhcp = &s_dhcp;
  // Initialise the basic info
  netInit(mac);

  // Now try to get our config info from a DHCP server
  int ret = _dhcp->beginWithDHCP((uint8_t*)mac);

  if (ret == 1)
  {
    // We've successfully found a DHCP server and got our configuration info, so set things
    // accordingly
    configure(_dhcp->getLocalIp(), _dhcp->getDnsServerIp(), _dhcp->getGatewayIp(), _dhcp->getSubnetMask());
  }

  return ret;
}
#endif

void
UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip)
{
  // KH mod to work with new func void MACAddress(uint8_t *mac_address); and SinricPro v2.5.1+
  // Now store to private var _mac_address
  //uint8_t _mac_address[6] ={0,};
  memcpy(_mac_address, mac, sizeof(_mac_address));
  //////

#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip) DEBUG_V3:Function started"));
#endif
  IPAddress dns = ip;
  dns[3] = 1;
  begin(mac, ip, dns);
}

void
UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns)
{
  // KH mod to work with new func void MACAddress(uint8_t *mac_address); and SinricPro v2.5.1+
  // Now store to private var _mac_address
  //uint8_t _mac_address[6] ={0,};
  memcpy(_mac_address, mac, sizeof(_mac_address));
  //////

#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(
    F("UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns) DEBUG_V3:Function started"));
#endif
  IPAddress gateway = ip;
  gateway[3] = 1;
  begin(mac, ip, dns, gateway);
}

void
UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway)
{
  // KH mod to work with new func void MACAddress(uint8_t *mac_address); and SinricPro v2.5.1+
  // Now store to private var _mac_address
  //uint8_t _mac_address[6] ={0,};
  memcpy(_mac_address, mac, sizeof(_mac_address));
  //////

#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(
    F("UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway) DEBUG_V3:Function started"));
#endif
  IPAddress subnet(255, 255, 255, 0);
  begin(mac, ip, dns, gateway, subnet);
}

void
UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet)
{
  // KH mod to work with new func void MACAddress(uint8_t *mac_address); and SinricPro v2.5.1+
  // Now store to private var _mac_address
  //uint8_t _mac_address[6] ={0,};
  memcpy(_mac_address, mac, sizeof(_mac_address));
  //////

#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(
    F("UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet) DEBUG_V3:Function started"));
#endif
  netInit(mac);
  configure(ip, dns, gateway, subnet);
}

int UIPEthernetClass::maintain()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::maintain() DEBUG_V3:Function started"));
#endif
  tick();
  int rc = DHCP_CHECK_NONE;
#if UIP_UDP

  if (_dhcp != NULL)
  {
    //we have a pointer to dhcp, use it
    rc = _dhcp->checkLease();

    switch ( rc )
    {
      case DHCP_CHECK_NONE:
        //nothing done
        break;

      case DHCP_CHECK_RENEW_OK:
      case DHCP_CHECK_REBIND_OK:
        //we might have got a new IP.
        configure(_dhcp->getLocalIp(), _dhcp->getDnsServerIp(), _dhcp->getGatewayIp(), _dhcp->getSubnetMask());
        break;

      default:
        //this is actually a error, it will retry though
        break;
    }
  }

  return rc;
#endif
}

EthernetLinkStatus UIPEthernetClass::linkStatus()
{
  if (!Enc28J60.geterevid())
    return Unknown;

  return Enc28J60.linkStatus() ? LinkON : LinkOFF;
}

IPAddress UIPEthernetClass::localIP()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::localIP() DEBUG_V3:Function started"));
#endif
  IPAddress ret;
  uip_ipaddr_t a;
  uip_gethostaddr(a);
  return ip_addr_uip(a);
}

IPAddress UIPEthernetClass::subnetMask()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::subnetMask() DEBUG_V3:Function started"));
#endif
  IPAddress ret;
  uip_ipaddr_t a;
  uip_getnetmask(a);
  return ip_addr_uip(a);
}

IPAddress UIPEthernetClass::gatewayIP()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::gatewayIP() DEBUG_V3:Function started"));
#endif
  IPAddress ret;
  uip_ipaddr_t a;
  uip_getdraddr(a);
  return ip_addr_uip(a);
}

IPAddress UIPEthernetClass::dnsServerIP()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::dnsServerIP() DEBUG_V3:Function started"));
#endif
  return _dnsServerAddress;
}

void
UIPEthernetClass::tick()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::tick() DEBUG_V3:Function started"));
#endif

  if (Enc28J60Network::geterevid() == 0)
  {
#if ACTLOGLEVEL>=LOG_ERR
    LogObject.uart_send_strln(
      F("UIPEthernetClass::tick() ERROR:EREVID=0 -> Not found ENC28j60 device !! Function ended !!"));
#endif
    return;
  }

#if defined(ESP8266)
  wdt_reset();
#endif

  if (in_packet == NOBLOCK)
  {
    in_packet = Enc28J60Network::receivePacket();
#if ACTLOGLEVEL>=LOG_DEBUG

    if (in_packet != NOBLOCK)
    {
      LogObject.uart_send_str(F("UIPEthernetClass::tick() DEBUG:receivePacket: "));
      LogObject.uart_send_decln(in_packet);
    }

#endif
  }

  if (in_packet != NOBLOCK)
  {
    packetstate = UIPETHERNET_FREEPACKET;
    uip_len = Enc28J60Network::blockSize(in_packet);

    if (uip_len > 0)
    {
      Enc28J60Network::readPacket(in_packet, 0, (uint8_t*)uip_buf, UIP_BUFSIZE);

      if (ETH_HDR ->type == HTONS(UIP_ETHTYPE_IP))
      {
        uip_packet = in_packet; //required for upper_layer_checksum of in_packet!
#if ACTLOGLEVEL>=LOG_DEBUG
        LogObject.uart_send_str(F("UIPEthernetClass::tick() DEBUG:readPacket type IP, uip_len: "));
        LogObject.uart_send_decln(uip_len);
#endif
        uip_arp_ipin();
        uip_input();

        if (uip_len > 0)
        {
          uip_arp_out();
          network_send();
        }
      }
      else if (ETH_HDR ->type == HTONS(UIP_ETHTYPE_ARP))
      {
#if ACTLOGLEVEL>=LOG_DEBUG
        LogObject.uart_send_str(F("UIPEthernetClass::tick() DEBUG:readPacket type ARP, uip_len: "));
        LogObject.uart_send_decln(uip_len);
#endif
        uip_arp_arpin();

        if (uip_len > 0)
        {
          network_send();
        }
      }
    }

    if (in_packet != NOBLOCK && (packetstate & UIPETHERNET_FREEPACKET))
    {
#if ACTLOGLEVEL>=LOG_DEBUG
      LogObject.uart_send_str(F("UIPEthernetClass::tick() DEBUG:freeing packet: "));
      LogObject.uart_send_decln(in_packet);
#endif
      Enc28J60Network::freePacket();
      in_packet = NOBLOCK;
    }
  }

  unsigned long now = millis();

#if UIP_CLIENT_TIMER >= 0
  bool periodic = (long)( now - periodic_timer ) >= 0;

  for (int i = 0; i < UIP_CONNS; i++)
  {
#else

  if ((long)( now - periodic_timer ) >= 0)
  {
    periodic_timer = now + UIP_PERIODIC_TIMER;

    for (int i = 0; i < UIP_CONNS; i++)
    {
#endif

    uip_conn = &uip_conns[i];

#if UIP_CLIENT_TIMER >= 0

    if (periodic)
    {
#endif

      uip_process(UIP_TIMER);

#if UIP_CLIENT_TIMER >= 0
    }
    else
    {
      if (uip_conn != NULL)
      {
        if (((uip_userdata_t*)uip_conn->appstate) != NULL)
        {
          if ((long)( now - ((uip_userdata_t*)uip_conn->appstate)->timer) >= 0)
          {
            uip_process(UIP_POLL_REQUEST);
          }
          else
          {
            continue;
          }
        }
        else
        {
#if ACTLOGLEVEL>=LOG_DEBUG_V3
          LogObject.uart_send_strln(F("UIPEthernetClass::tick() DEBUG_V3:((uip_userdata_t*)uip_conn->appstate) is NULL"));
#endif

          if ((long)( now - ((uip_userdata_t*)uip_conn)->timer) >= 0)
          {
            uip_process(UIP_POLL_REQUEST);
          }
          else
          {
            continue;
          }
        }
      }
      else
      {
#if ACTLOGLEVEL>=LOG_ERR
        LogObject.uart_send_strln(F("UIPEthernetClass::tick() ERROR:uip_conn is NULL"));
#endif
        continue;
      }
    }

#endif

    // If the above function invocation resulted in data that
    // should be sent out on the Enc28J60Network, the global variable
    // uip_len is set to a value > 0.
    if (uip_len > 0)
    {
      uip_arp_out();
      network_send();
    }
  }

#if UIP_CLIENT_TIMER >= 0

  if (periodic)
  {
    periodic_timer = now + UIP_PERIODIC_TIMER;
#endif
#if UIP_UDP

    for (int i = 0; i < UIP_UDP_CONNS; i++)
    {
      uip_udp_periodic(i);

      // If the above function invocation resulted in data that
      // should be sent out on the Enc28J60Network, the global variable
      // uip_len is set to a value > 0. */
      if (uip_len > 0)
      {
        UIPUDP::_send((uip_udp_userdata_t *)(uip_udp_conns[i].appstate));
      }
    }

#endif /* UIP_UDP */
  }
}

bool UIPEthernetClass::network_send()
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::network_send() DEBUG_V3:Function started"));
#endif

  if (packetstate & UIPETHERNET_SENDPACKET)
  {
#if ACTLOGLEVEL>=LOG_DEBUG
    LogObject.uart_send_str(F("UIPEthernetClass::network_send() DEBUG:uip_packet: "));
    LogObject.uart_send_dec(uip_packet);
    LogObject.uart_send_str(F(", hdrlen: "));
    LogObject.uart_send_decln(uip_hdrlen);
#endif
    Enc28J60Network::writePacket(uip_packet, 0, uip_buf, uip_hdrlen);
    packetstate &= ~ UIPETHERNET_SENDPACKET;
    goto sendandfree;
  }

  uip_packet = Enc28J60Network::allocBlock(uip_len);

  if (uip_packet != NOBLOCK)
  {
#if ACTLOGLEVEL>=LOG_DEBUG
    LogObject.uart_send_str(F("UIPEthernetClass::network_send() DEBUG:uip_buf (uip_len): "));
    LogObject.uart_send_dec(uip_len);
    LogObject.uart_send_str(F(", packet: "));
    LogObject.uart_send_decln(uip_packet);
#endif
    Enc28J60Network::writePacket(uip_packet, 0, uip_buf, uip_len);
    goto sendandfree;
  }

  return false;
sendandfree:
  Enc28J60Network::sendPacket(uip_packet);
  Enc28J60Network::freeBlock(uip_packet);
  uip_packet = NOBLOCK;
  return true;
}

void UIPEthernetClass::netInit(const uint8_t* mac)
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::netInit(const uint8_t* mac) DEBUG_V3:Function started"));
#endif
  periodic_timer = millis() + UIP_PERIODIC_TIMER;

  Enc28J60Network::init((uint8_t*)mac);
  uip_seteth_addr(mac);

  uip_init();
  uip_arp_init();
}

void UIPEthernetClass::configure(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet)
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(
    F("UIPEthernetClass::configure(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet) DEBUG_V3:Function started"));
#endif
  uip_ipaddr_t ipaddr;

  uip_ip_addr(ipaddr, ip);
  uip_sethostaddr(ipaddr);

  uip_ip_addr(ipaddr, gateway);
  uip_setdraddr(ipaddr);

  uip_ip_addr(ipaddr, subnet);
  uip_setnetmask(ipaddr);

  _dnsServerAddress = dns;
}

UIPEthernetClass UIPEthernet;

/*---------------------------------------------------------------------------*/
uint16_t
UIPEthernetClass::chksum(uint16_t sum, const uint8_t *data, uint16_t len)
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(
    F("UIPEthernetClass::chksum(uint16_t sum, const uint8_t *data, uint16_t len) DEBUG_V3:Function started"));
#endif
  uint16_t t;
  const uint8_t *dataptr;
  const uint8_t *last_byte;

  dataptr = data;
  last_byte = data + len - 1;

  while (dataptr < last_byte)   /* At least two more bytes */
  {
    t = (dataptr[0] << 8) + dataptr[1];
    sum += t;

    if (sum < t)
    {
      sum++;            /* carry */
    }

    dataptr += 2;
  }

  if (dataptr == last_byte)
  {
    t = (dataptr[0] << 8) + 0;
    sum += t;

    if (sum < t)
    {
      sum++;            /* carry */
    }
  }

  /* Return sum in host byte order. */
  return sum;
}

/*---------------------------------------------------------------------------*/

uint16_t
UIPEthernetClass::ipchksum(void)
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
  LogObject.uart_send_strln(F("UIPEthernetClass::ipchksum(void) DEBUG_V3:Function started"));
#endif
  uint16_t sum;

  sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
  return (sum == 0) ? 0xffff : htons(sum);
}

/*---------------------------------------------------------------------------*/
uint16_t
#if UIP_UDP
UIPEthernetClass::upper_layer_chksum(uint8_t proto)
#else
uip_tcpchksum(void)
#endif
{
#if ACTLOGLEVEL>=LOG_DEBUG_V3
#if UIP_UDP
  LogObject.uart_send_strln(F("UIPEthernetClass::upper_layer_chksum(uint8_t proto) DEBUG_V3:Function started"));
#else
  LogObject.uart_send_strln(F("uip_tcpchksum(void) INFO:Function started"));
#endif
#endif
  uint16_t upper_layer_len;
  uint16_t sum;

#if UIP_CONF_IPV6
  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]);
#else /* UIP_CONF_IPV6 */
  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
#endif /* UIP_CONF_IPV6 */

  /* First sum pseudoheader. */

  /* IP protocol and length fields. This addition cannot carry. */
#if UIP_UDP
  sum = upper_layer_len + proto;
#else
  sum = upper_layer_len + UIP_PROTO_TCP;
#endif
  /* Sum IP source and destination addresses. */
  sum = UIPEthernetClass::chksum(sum, (u8_t *)&BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t));

  uint8_t upper_layer_memlen;
#if UIP_UDP

  switch (proto)
  {
    //    case UIP_PROTO_ICMP:
    //    case UIP_PROTO_ICMP6:
    //      upper_layer_memlen = upper_layer_len;
    //      break;
    case UIP_PROTO_UDP:
      upper_layer_memlen = UIP_UDPH_LEN;
      break;

    default:
      //  case UIP_PROTO_TCP:
#endif
      upper_layer_memlen = (BUF->tcpoffset >> 4) << 2;
#if UIP_UDP
      break;
  }

#endif
  sum = UIPEthernetClass::chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_memlen);
#if ACTLOGLEVEL>=LOG_DEBUG
#if UIP_UDP
  LogObject.uart_send_str(F("UIPEthernetClass::upper_layer_chksum(uint8_t proto) DEBUG:uip_buf["));
#else
  LogObject.uart_send_str(F("uip_tcpchksum(void) DEBUG:uip_buf["));
#endif
  LogObject.uart_send_dec(UIP_IPH_LEN + UIP_LLH_LEN);
  LogObject.uart_send_str(F("-"));
  LogObject.uart_send_dec(UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_memlen);
  LogObject.uart_send_str(F("]: "));
  LogObject.uart_send_hexln(htons(sum));
#endif

  if (upper_layer_memlen < upper_layer_len)
  {
    sum = Enc28J60Network::chksum(
            sum,
            UIPEthernetClass::uip_packet,
            UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_memlen,
            upper_layer_len - upper_layer_memlen
          );
#if ACTLOGLEVEL>=LOG_DEBUG
#if UIP_UDP
    LogObject.uart_send_str(F("UIPEthernetClass::upper_layer_chksum(uint8_t proto) DEBUG:uip_packet("));
#else
    LogObject.uart_send_str(F("uip_tcpchksum(void) DEBUG:uip_packet("));
#endif
    LogObject.uart_send_dec(UIPEthernetClass::uip_packet);
    LogObject.uart_send_str(F(")["));
    LogObject.uart_send_dec(UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_memlen);
    LogObject.uart_send_str(F("-"));
    LogObject.uart_send_dec(UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_len);
    LogObject.uart_send_str(F("]: "));
    LogObject.uart_send_hexln(htons(sum));
#endif
  }

  return (sum == 0) ? 0xffff : htons(sum);
}

uint16_t
uip_ipchksum(void)
{
  return UIPEthernet.ipchksum();
}

#if UIP_UDP
uint16_t
uip_tcpchksum(void)
{
  uint16_t sum = UIPEthernet.upper_layer_chksum(UIP_PROTO_TCP);
  return sum;
}

uint16_t
uip_udpchksum(void)
{
  uint16_t sum = UIPEthernet.upper_layer_chksum(UIP_PROTO_UDP);
  return sum;
}
#endif