ip.h File Reference

#include "lwip/opt.h"
#include "lwip/def.h"
#include "lwip/pbuf.h"
#include "lwip/ip_addr.h"
#include "lwip/err.h"
#include "lwip/netif.h"

Include dependency graph for ip.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ip_pcb
struct	ip_hdr

Macros
#define	IP_OPTIONS_SEND   LWIP_IGMP
#define	IP_HLEN   20
#define	IP_PROTO_ICMP   1
#define	IP_PROTO_IGMP   2
#define	IP_PROTO_UDP   17
#define	IP_PROTO_UDPLITE   136
#define	IP_PROTO_TCP   6
#define	IP_HDRINCL   NULL
#define	IP_PCB_ADDRHINT
#define	IP_PCB
#define	SOF_ACCEPTCONN   (u8_t)0x02U /* socket has had listen() */
#define	SOF_REUSEADDR   (u8_t)0x04U /* allow local address reuse */
#define	SOF_KEEPALIVE   (u8_t)0x08U /* keep connections alive */
#define	SOF_BROADCAST   (u8_t)0x20U /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */
#define	SOF_LINGER   (u8_t)0x80U /* linger on close if data present */
#define	SOF_INHERITED   (SOF_REUSEADDR|SOF_KEEPALIVE|SOF_LINGER/*|SOF_DEBUG|SOF_DONTROUTE|SOF_OOBINLINE*/)
#define	IP_RF   0x8000 /* reserved fragment flag */
#define	IP_DF   0x4000 /* dont fragment flag */
#define	IP_MF   0x2000 /* more fragments flag */
#define	IP_OFFMASK   0x1fff /* mask for fragmenting bits */
#define	IPH_V(hdr)   (ntohs((hdr)->_v_hl_tos) >> 12)
#define	IPH_HL(hdr)   ((ntohs((hdr)->_v_hl_tos) >> 8) & 0x0f)
#define	IPH_TOS(hdr)   (ntohs((hdr)->_v_hl_tos) & 0xff)
#define	IPH_LEN(hdr)   ((hdr)->_len)
#define	IPH_ID(hdr)   ((hdr)->_id)
#define	IPH_OFFSET(hdr)   ((hdr)->_offset)
#define	IPH_TTL(hdr)   ((hdr)->_ttl)
#define	IPH_PROTO(hdr)   ((hdr)->_proto)
#define	IPH_CHKSUM(hdr)   ((hdr)->_chksum)
#define	IPH_VHLTOS_SET(hdr, v, hl, tos)   (hdr)->_v_hl_tos = (htons(((v) << 12) | ((hl) << 8) | (tos)))
#define	IPH_LEN_SET(hdr, len)   (hdr)->_len = (len)
#define	IPH_ID_SET(hdr, id)   (hdr)->_id = (id)
#define	IPH_OFFSET_SET(hdr, off)   (hdr)->_offset = (off)
#define	IPH_TTL_SET(hdr, ttl)   (hdr)->_ttl = (u8_t)(ttl)
#define	IPH_PROTO_SET(hdr, proto)   (hdr)->_proto = (u8_t)(proto)
#define	IPH_CHKSUM_SET(hdr, chksum)   (hdr)->_chksum = (chksum)
#define	ip_init()   /* Compatibility define, not init needed. */
#define	ip_current_netif()   (current_netif)
#define	ip_current_header()   (current_header)
#define	ip_current_src_addr()   (&current_iphdr_src)
#define	ip_current_dest_addr()   (&current_iphdr_dest)
#define	ip_debug_print(p)

Functions
struct netif *	ip_route (ip_addr_t *dest) ICACHE_FLASH_ATTR
struct netif *	ip_router (ip_addr_t *dest, ip_addr_t *source)
err_t	ip_input (struct pbuf *p, struct netif *inp) ICACHE_FLASH_ATTR
err_t	ip_output (struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, u8_t ttl, u8_t tos, u8_t proto) ICACHE_FLASH_ATTR
err_t	ip_output_if (struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, u8_t ttl, u8_t tos, u8_t proto, struct netif *netif) ICACHE_FLASH_ATTR

Variables
PACK_STRUCT_BEGIN struct ip_hdr	PACK_STRUCT_STRUCT
struct netif *	current_netif
const struct ip_hdr *	current_header
ip_addr_t	current_iphdr_src
ip_addr_t	current_iphdr_dest

Macro Definition Documentation

ip_current_dest_addr

#define ip_current_dest_addr

(

)

(&current_iphdr_dest)

Destination IP address of current_header

Definition at line 201 of file ip.h.

ip_current_header

#define ip_current_header

(

)

(current_header)

Get the IP header of the current packet. This function must only be called from a receive callback (udp_recv, raw_recv, tcp_accept). It will return NULL otherwise.

Definition at line 197 of file ip.h.

ip_current_netif

#define ip_current_netif

(

)

(current_netif)

Get the interface that received the current packet. This function must only be called from a receive callback (udp_recv, raw_recv, tcp_accept). It will return NULL otherwise.

Definition at line 193 of file ip.h.

ip_current_src_addr

#define ip_current_src_addr

(

)

(&current_iphdr_src)

Source IP address of current_header

Definition at line 199 of file ip.h.

ip_debug_print

#define ip_debug_print

(

p

)

Definition at line 206 of file ip.h.

Referenced by ip_input(), ip_output(), and ip_output_if().

IP_DF

#define IP_DF   0x4000 /* dont fragment flag */

Definition at line 126 of file ip.h.

IP_HDRINCL

#define IP_HDRINCL   NULL

Definition at line 64 of file ip.h.

Referenced by ip_output_if().

IP_HLEN

#define IP_HLEN   20

Definition at line 50 of file ip.h.

Referenced by ip_input(), ip_output(), and ip_output_if().

ip_init

#define ip_init

(

)

/* Compatibility define, not init needed. */

Definition at line 171 of file ip.h.

Referenced by lwip_init().

IP_MF

#define IP_MF   0x2000 /* more fragments flag */

Definition at line 127 of file ip.h.

Referenced by ip_input().

IP_OFFMASK

#define IP_OFFMASK   0x1fff /* mask for fragmenting bits */

Definition at line 128 of file ip.h.

Referenced by ip_input(), and ip_output().

IP_OPTIONS_SEND

#define IP_OPTIONS_SEND   LWIP_IGMP

Currently, the function ip_output_if_opt() is only used with IGMP

Definition at line 48 of file ip.h.

IP_PCB

#define IP_PCB

Value:

/* ip addresses in network byte order */ \
  ip_addr_t local_ip; \
  ip_addr_t remote_ip; \
   /* Socket options */  \
  u8_t so_options;      \
   /* Type Of Service */ \
  u8_t tos;              \
  /* Time To Live */     \
  u8_t ttl               \
  /* link layer address resolution hint */ \
  IP_PCB_ADDRHINT

Definition at line 76 of file ip.h.

IP_PCB_ADDRHINT

#define IP_PCB_ADDRHINT

Definition at line 69 of file ip.h.

IP_PROTO_ICMP

#define IP_PROTO_ICMP   1

Definition at line 52 of file ip.h.

Referenced by acl_check_packet(), ip_input(), and ip_router().

IP_PROTO_IGMP

#define IP_PROTO_IGMP   2

Definition at line 53 of file ip.h.

Referenced by ip_input().

IP_PROTO_TCP

#define IP_PROTO_TCP   6

Definition at line 56 of file ip.h.

Referenced by acl_check_packet(), ip_input(), and ip_router().

IP_PROTO_UDP

#define IP_PROTO_UDP   17

Definition at line 54 of file ip.h.

Referenced by acl_check_packet(), ip_input(), and ip_router().

IP_PROTO_UDPLITE

#define IP_PROTO_UDPLITE   136

Definition at line 55 of file ip.h.

Referenced by ip_input().

IP_RF

#define IP_RF   0x8000 /* reserved fragment flag */

Definition at line 125 of file ip.h.

IPH_CHKSUM

#define IPH_CHKSUM

(

hdr

)

((hdr)->_chksum)

Definition at line 152 of file ip.h.

Referenced by ip_output(), and ip_router().

IPH_CHKSUM_SET

#define IPH_CHKSUM_SET	(		hdr,
			chksum
	)		(hdr)->_chksum = (chksum)

Definition at line 160 of file ip.h.

Referenced by ip_output_if(), and ip_router().

IPH_HL

#define IPH_HL

(

hdr

)

((ntohs((hdr)->_v_hl_tos) >> 8) & 0x0f)

Definition at line 145 of file ip.h.

Referenced by ip_input(), ip_output(), and ip_router().

IPH_ID

#define IPH_ID

(

hdr

)

((hdr)->_id)

Definition at line 148 of file ip.h.

Referenced by ip_input(), and ip_output().

IPH_ID_SET

#define IPH_ID_SET	(		hdr,
			id
	)		(hdr)->_id = (id)

Definition at line 156 of file ip.h.

Referenced by ip_output_if().

IPH_LEN

#define IPH_LEN

(

hdr

)

((hdr)->_len)

Definition at line 147 of file ip.h.

Referenced by ip_input(), and ip_output().

IPH_LEN_SET

#define IPH_LEN_SET	(		hdr,
			len
	)		(hdr)->_len = (len)

Definition at line 155 of file ip.h.

Referenced by ip_output_if().

IPH_OFFSET

#define IPH_OFFSET

(

hdr

)

((hdr)->_offset)

Definition at line 149 of file ip.h.

Referenced by ip_input(), and ip_output().

IPH_OFFSET_SET

#define IPH_OFFSET_SET	(		hdr,
			off
	)		(hdr)->_offset = (off)

Definition at line 157 of file ip.h.

Referenced by ip_output_if().

IPH_PROTO

#define IPH_PROTO

(

hdr

)

((hdr)->_proto)

Definition at line 151 of file ip.h.

Referenced by acl_check_packet(), ip_input(), ip_output(), and ip_router().

IPH_PROTO_SET

#define IPH_PROTO_SET	(		hdr,
			proto
	)		(hdr)->_proto = (u8_t)(proto)

Definition at line 159 of file ip.h.

Referenced by ip_output_if().

IPH_TOS

#define IPH_TOS

(

hdr

)

(ntohs((hdr)->_v_hl_tos) & 0xff)

Definition at line 146 of file ip.h.

Referenced by ip_output().

IPH_TTL

#define IPH_TTL

(

hdr

)

((hdr)->_ttl)

Definition at line 150 of file ip.h.

Referenced by ip_output(), and ip_router().

IPH_TTL_SET

#define IPH_TTL_SET	(		hdr,
			ttl
	)		(hdr)->_ttl = (u8_t)(ttl)

Definition at line 158 of file ip.h.

Referenced by ip_output_if(), and ip_router().

IPH_V

#define IPH_V

(

hdr

)

(ntohs((hdr)->_v_hl_tos) >> 12)

Definition at line 144 of file ip.h.

Referenced by ip_input(), and ip_output().

IPH_VHLTOS_SET

#define IPH_VHLTOS_SET	(		hdr,
			v,
			hl,
			tos
	)		(hdr)->_v_hl_tos = (htons(((v) << 12) | ((hl) << 8) | (tos)))

Definition at line 154 of file ip.h.

Referenced by ip_output_if().

SOF_ACCEPTCONN

#define SOF_ACCEPTCONN   (u8_t)0x02U /* socket has had listen() */

Definition at line 98 of file ip.h.

SOF_BROADCAST

#define SOF_BROADCAST   (u8_t)0x20U /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */

Definition at line 102 of file ip.h.

SOF_INHERITED

#define SOF_INHERITED   (SOF_REUSEADDR|SOF_KEEPALIVE|SOF_LINGER/*|SOF_DEBUG|SOF_DONTROUTE|SOF_OOBINLINE*/)

Definition at line 109 of file ip.h.

SOF_KEEPALIVE

#define SOF_KEEPALIVE   (u8_t)0x08U /* keep connections alive */

Definition at line 100 of file ip.h.

SOF_LINGER

#define SOF_LINGER   (u8_t)0x80U /* linger on close if data present */

Definition at line 104 of file ip.h.

SOF_REUSEADDR

#define SOF_REUSEADDR   (u8_t)0x04U /* allow local address reuse */

Definition at line 99 of file ip.h.

Function Documentation

ip_input()

err_t ip_input	(	struct pbuf *	p,
		struct netif *	inp
	)

This function is called by the network interface device driver when an IP packet is received. The function does the basic checks of the IP header such as packet size being at least larger than the header size etc. If the packet was not destined for us, the packet is forwarded (using ip_forward). The IP checksum is always checked.

Finally, the packet is sent to the upper layer protocol input function.

Parameters

p	the received IP packet (p->payload points to IP header)
inp	the netif on which this packet was received

Returns

ERR_OK if the packet was processed (could return ERR_* if it wasn't processed, but currently always returns ERR_OK)

Definition at line 923 of file ip.c.

References current_iphdr_dest, current_iphdr_src, ERR_OK, netif::flags, ICMP_DUR_PROTO, inet_chksum(), ip4_addr_get_u32, netif::ip_addr, ip_addr_cmp, ip_addr_copy, ip_addr_isany, ip_addr_isbroadcast, ip_addr_ismulticast, ip_addr_set_any, IP_DEBUG, ip_debug_print, IP_HLEN, IP_MF, IP_OFFMASK, IP_PROTO_ICMP, IP_PROTO_IGMP, IP_PROTO_TCP, IP_PROTO_UDP, IP_PROTO_UDPLITE, IP_STATS_INC, IPH_HL, IPH_ID, IPH_LEN, IPH_OFFSET, IPH_PROTO, IPH_V, pbuf::len, LWIP_DBG_LEVEL_SERIOUS, LWIP_DBG_LEVEL_WARNING, LWIP_DBG_TRACE, LWIP_DEBUGF, netif::name, NETIF_FLAG_IGMP, netif_is_up, netif_list, netif::netmask, netif::next, ntohs, NULL, pbuf::payload, pbuf_free(), pbuf_realloc(), PP_HTONS, snmp_inc_ipinaddrerrors, snmp_inc_ipindelivers, snmp_inc_ipindiscards, snmp_inc_ipinhdrerrors, snmp_inc_ipinreceives, snmp_inc_ipinunknownprotos, pbuf::tot_len, U16_F, X16_F, and X32_F.

Referenced by netif_init(), netif_set_link_down(), tcpip_input(), and tcpip_thread().

{
  struct ip_hdr *iphdr;
  struct netif *netif;
  u16_t iphdr_hlen;
  u16_t iphdr_len;
#if IP_ACCEPT_LINK_LAYER_ADDRESSING
  int check_ip_src=1;
#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */

  IP_STATS_INC(ip.recv);
  snmp_inc_ipinreceives();

  /* identify the IP header */
  iphdr = (struct ip_hdr *)p->payload;
  if (IPH_V(iphdr) != 4) {
    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IP packet dropped due to bad version number %"U16_F"\n", IPH_V(iphdr)));
    ip_debug_print(p);
    pbuf_free(p);
    IP_STATS_INC(ip.err);
    IP_STATS_INC(ip.drop);
    snmp_inc_ipinhdrerrors();
    return ERR_OK;
  }

  /* obtain IP header length in number of 32-bit words */
  iphdr_hlen = IPH_HL(iphdr);
  /* calculate IP header length in bytes */
  iphdr_hlen *= 4;
  /* obtain ip length in bytes */
  iphdr_len = ntohs(IPH_LEN(iphdr));

  /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */
  if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len)) {
    if (iphdr_hlen > p->len) {
      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
        ("IP header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n",
        iphdr_hlen, p->len));
    }
    if (iphdr_len > p->tot_len) {
      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
        ("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n",
        iphdr_len, p->tot_len));
    }
    /* free (drop) packet pbufs */
    pbuf_free(p);
    IP_STATS_INC(ip.lenerr);
    IP_STATS_INC(ip.drop);
    snmp_inc_ipindiscards();
    return ERR_OK;
  }

  /* verify checksum */
#if CHECKSUM_CHECK_IP
  if (inet_chksum(iphdr, iphdr_hlen) != 0) {

    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
      ("Checksum (0x%"X16_F") failed, IP packet dropped.\n", inet_chksum(iphdr, iphdr_hlen)));
    ip_debug_print(p);
    pbuf_free(p);
    IP_STATS_INC(ip.chkerr);
    IP_STATS_INC(ip.drop);
    snmp_inc_ipinhdrerrors();
    return ERR_OK;
  }
#endif

#if IP_NAPT
  /* for unicast packet, check NAPT table and modify dest if needed */
  if (!inp->napt && ip_addr_cmp(&iphdr->dest, &(inp->ip_addr)))
    ip_napt_recv(p, iphdr, netif);
#endif

  /* Trim pbuf. This should have been done at the netif layer,
   * but we'll do it anyway just to be sure that its done. */
  pbuf_realloc(p, iphdr_len);

  /* copy IP addresses to aligned ip_addr_t */
  ip_addr_copy(current_iphdr_dest, iphdr->dest);
  ip_addr_copy(current_iphdr_src, iphdr->src);

  /* match packet against an interface, i.e. is this packet for us? */
#if LWIP_IGMP
  if (ip_addr_ismulticast(&current_iphdr_dest)) {
    if ((inp->flags & NETIF_FLAG_IGMP) && (igmp_lookfor_group(inp, &current_iphdr_dest))) {
      netif = inp;
    } else {
      netif = NULL;
    }
  } else
#endif /* LWIP_IGMP */
  {
    /* start trying with inp. if that's not acceptable, start walking the
       list of configured netifs.
       'first' is used as a boolean to mark whether we started walking the list */
    int first = 1;
    netif = inp;
    do {
      LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%"X32_F" netif->ip_addr 0x%"X32_F" (0x%"X32_F", 0x%"X32_F", 0x%"X32_F")\n",
          ip4_addr_get_u32(&iphdr->dest), ip4_addr_get_u32(&netif->ip_addr),
          ip4_addr_get_u32(&iphdr->dest) & ip4_addr_get_u32(&netif->netmask),
          ip4_addr_get_u32(&netif->ip_addr) & ip4_addr_get_u32(&netif->netmask),
          ip4_addr_get_u32(&iphdr->dest) & ~ip4_addr_get_u32(&netif->netmask)));

      /* interface is up and configured? */
      if ((netif_is_up(netif)) && (!ip_addr_isany(&(netif->ip_addr)))) {
        /* unicast to this interface address? */
        if (ip_addr_cmp(&current_iphdr_dest, &(netif->ip_addr)) ||
            /* or broadcast on this interface network address? */
            ip_addr_isbroadcast(&current_iphdr_dest, netif)) {
          LWIP_DEBUGF(IP_DEBUG, ("ip_input: packet accepted on interface %c%c\n",
              netif->name[0], netif->name[1]));
          /* break out of for loop */
          break;
        }
#if LWIP_AUTOIP
        /* connections to link-local addresses must persist after changing
           the netif's address (RFC3927 ch. 1.9) */
        if ((netif->autoip != NULL) &&
            ip_addr_cmp(&current_iphdr_dest, &(netif->autoip->llipaddr))) {
          LWIP_DEBUGF(IP_DEBUG, ("ip_input: LLA packet accepted on interface %c%c\n",
              netif->name[0], netif->name[1]));
          /* break out of for loop */
          break;
        }
#endif /* LWIP_AUTOIP */
      }
      if (first) {
        first = 0;
        netif = netif_list;
      } else {
        netif = netif->next;
      }
      if (netif == inp) {
        netif = netif->next;
      }
    } while(netif != NULL);
  }

#if IP_ACCEPT_LINK_LAYER_ADDRESSING
  /* Pass DHCP messages regardless of destination address. DHCP traffic is addressed
   * using link layer addressing (such as Ethernet MAC) so we must not filter on IP.
   * According to RFC 1542 section 3.1.1, referred by RFC 2131).
   *
   * If you want to accept private broadcast communication while a netif is down,
   * define LWIP_IP_ACCEPT_UDP_PORT(dst_port), e.g.:
   *
   * #define LWIP_IP_ACCEPT_UDP_PORT(dst_port) ((dst_port) == PP_NTOHS(12345))
   */
  if (netif == NULL) {
    /* remote port is DHCP server? */
    if (IPH_PROTO(iphdr) == IP_PROTO_UDP) {
      struct udp_hdr *udphdr = (struct udp_hdr *)((u8_t *)iphdr + iphdr_hlen);
      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip_input: UDP packet to DHCP client port %"U16_F"\n",
        ntohs(udphdr->dest)));
      if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) {
        LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip_input: DHCP packet accepted.\n"));
        netif = inp;
        check_ip_src = 0;
      }
    }
  }
#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */

  /* broadcast or multicast packet source address? Compliant with RFC 1122: 3.2.1.3 */
#if IP_ACCEPT_LINK_LAYER_ADDRESSING
  /* DHCP servers need 0.0.0.0 to be allowed as source address (RFC 1.1.2.2: 3.2.1.3/a) */
  if (check_ip_src && !ip_addr_isany(&current_iphdr_src))
#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */
  {  if ((ip_addr_isbroadcast(&current_iphdr_src, inp)) ||
         (ip_addr_ismulticast(&current_iphdr_src))) {
      /* packet source is not valid */
      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("ip_input: packet source is not valid.\n"));
      /* free (drop) packet pbufs */
      pbuf_free(p);
      IP_STATS_INC(ip.drop);
      snmp_inc_ipinaddrerrors();
      snmp_inc_ipindiscards();
      return ERR_OK;
    }
  }

  /* packet not for us? */
  if (netif == NULL) {
    /* packet not for us, route or discard */
    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip_input: packet not for us.\n"));
#if IP_FORWARD
    /* non-broadcast packet? */
    if (!ip_addr_isbroadcast(&current_iphdr_dest, inp)) {
      /* try to forward IP packet on (other) interfaces */
      ip_forward(p, iphdr, inp);
    } else
#endif /* IP_FORWARD */
    {
      snmp_inc_ipinaddrerrors();
      snmp_inc_ipindiscards();
    }
    pbuf_free(p);
    return ERR_OK;
  }
  /* packet consists of multiple fragments? */
  if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) {
#if IP_REASSEMBLY /* packet fragment reassembly code present? */
    LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip_reass()\n",
      ntohs(IPH_ID(iphdr)), p->tot_len, ntohs(IPH_LEN(iphdr)), !!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)*8));
    /* reassemble the packet*/
    p = ip_reass(p);
    /* packet not fully reassembled yet? */
    if (p == NULL) {
      return ERR_OK;
    }
    iphdr = (struct ip_hdr *)p->payload;
#else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */
    pbuf_free(p);
    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n",
      ntohs(IPH_OFFSET(iphdr))));
    IP_STATS_INC(ip.opterr);
    IP_STATS_INC(ip.drop);
    /* unsupported protocol feature */
    snmp_inc_ipinunknownprotos();
    return ERR_OK;
#endif /* IP_REASSEMBLY */
  }

#if IP_OPTIONS_ALLOWED == 0 /* no support for IP options in the IP header? */

#if LWIP_IGMP
  /* there is an extra "router alert" option in IGMP messages which we allow for but do not police */
  if((iphdr_hlen > IP_HLEN) &&  (IPH_PROTO(iphdr) != IP_PROTO_IGMP)) {
#else
  if (iphdr_hlen > IP_HLEN) {
#endif /* LWIP_IGMP */
    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since there were IP options (while IP_OPTIONS_ALLOWED == 0).\n"));
    pbuf_free(p);
    IP_STATS_INC(ip.opterr);
    IP_STATS_INC(ip.drop);
    /* unsupported protocol feature */
    snmp_inc_ipinunknownprotos();
    return ERR_OK;
  }
#endif /* IP_OPTIONS_ALLOWED == 0 */

  /* send to upper layers */
  LWIP_DEBUGF(IP_DEBUG, ("ip_input: \n"));
  ip_debug_print(p);
  LWIP_DEBUGF(IP_DEBUG, ("ip_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len));

  current_netif = inp;
  current_header = iphdr;

#if LWIP_RAW
  /* raw input did not eat the packet? */
  if (raw_input(p, inp) == 0)
#endif /* LWIP_RAW */
  {

    switch (IPH_PROTO(iphdr)) {
#if LWIP_UDP
    case IP_PROTO_UDP:
#if LWIP_UDPLITE
    case IP_PROTO_UDPLITE:
#endif /* LWIP_UDPLITE */
      snmp_inc_ipindelivers();
      udp_input(p, inp);
      break;
#endif /* LWIP_UDP */
#if LWIP_TCP
    case IP_PROTO_TCP:
      snmp_inc_ipindelivers();
      tcp_input(p, inp);
      break;
#endif /* LWIP_TCP */
#if LWIP_ICMP
    case IP_PROTO_ICMP:
      snmp_inc_ipindelivers();
      icmp_input(p, inp);
      break;
#endif /* LWIP_ICMP */
#if LWIP_IGMP
    case IP_PROTO_IGMP:
      igmp_input(p, inp, &current_iphdr_dest);
      break;
#endif /* LWIP_IGMP */
    default:
#if LWIP_ICMP
      /* send ICMP destination protocol unreachable unless is was a broadcast */
      if (!ip_addr_isbroadcast(&current_iphdr_dest, inp) &&
          !ip_addr_ismulticast(&current_iphdr_dest)) {
        p->payload = iphdr;
        icmp_dest_unreach(p, ICMP_DUR_PROTO);
      }
#endif /* LWIP_ICMP */
      pbuf_free(p);

      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Unsupported transport protocol %"U16_F"\n", IPH_PROTO(iphdr)));

      IP_STATS_INC(ip.proterr);
      IP_STATS_INC(ip.drop);
      snmp_inc_ipinunknownprotos();
    }
  }

  current_netif = NULL;
  current_header = NULL;
  ip_addr_set_any(&current_iphdr_src);
  ip_addr_set_any(&current_iphdr_dest);

  return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_output()

err_t ip_output	(	struct pbuf *	p,
		ip_addr_t *	src,
		ip_addr_t *	dest,
		u8_t	ttl,
		u8_t	tos,
		u8_t	proto
	)

Simple interface to ip_output_if. It finds the outgoing network interface and calls upon ip_output_if to do the actual work.

Parameters

p	the packet to send (p->payload points to the data, e.g. next protocol header; if dest == IP_HDRINCL, p already includes an IP header and p->payload points to that IP header)
src	the source IP address to send from (if src == IP_ADDR_ANY, the IP address of the netif used to send is used as source address)
dest	the destination IP address to send the packet to
ttl	the TTL value to be set in the IP header
tos	the TOS value to be set in the IP header
proto	the PROTOCOL to be set in the IP header

Returns

ERR_RTE if no route is found see ip_output_if() for more return values

Definition at line 1435 of file ip.c.

References ERR_RTE, ip4_addr1_16, ip4_addr2_16, ip4_addr3_16, ip4_addr4_16, IP_DEBUG, ip_debug_print, IP_HLEN, IP_OFFMASK, ip_output_if(), ip_route(), IP_STATS_INC, IPH_CHKSUM, IPH_HL, IPH_ID, IPH_LEN, IPH_OFFSET, IPH_PROTO, IPH_TOS, IPH_TTL, IPH_V, LWIP_ASSERT, LWIP_DEBUGF, ntohs, NULL, pbuf::payload, pbuf::ref, S16_F, U16_F, and X16_F.

{
  struct netif *netif;

  /* pbufs passed to IP must have a ref-count of 1 as their payload pointer
     gets altered as the packet is passed down the stack */
  LWIP_ASSERT("p->ref == 1", p->ref == 1);

  if ((netif = ip_route(dest)) == NULL) {
    LWIP_DEBUGF(IP_DEBUG, ("ip_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
      ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));
    IP_STATS_INC(ip.rterr);
    return ERR_RTE;
  }

  return ip_output_if(p, src, dest, ttl, tos, proto, netif);
}

Here is the call graph for this function:

ip_output_if()

err_t ip_output_if	(	struct pbuf *	p,
		ip_addr_t *	src,
		ip_addr_t *	dest,
		u8_t	ttl,
		u8_t	tos,
		u8_t	proto,
		struct netif *	netif
	)

Sends an IP packet on a network interface. This function constructs the IP header and calculates the IP header checksum. If the source IP address is NULL, the IP address of the outgoing network interface is filled in as source address. If the destination IP address is IP_HDRINCL, p is assumed to already include an IP header and p->payload points to it instead of the data.

Parameters

p	the packet to send (p->payload points to the data, e.g. next protocol header; if dest == IP_HDRINCL, p already includes an IP header and p->payload points to that IP header)
src	the source IP address to send from (if src == IP_ADDR_ANY, the IP address of the netif used to send is used as source address)
dest	the destination IP address to send the packet to
ttl	the TTL value to be set in the IP header
tos	the TOS value to be set in the IP header
proto	the PROTOCOL to be set in the IP header
netif	the netif on which to send this packet

Returns

ERR_OK if the packet was sent OK ERR_BUF if p doesn't have enough space for IP/LINK headers returns errors returned by netif->output

Note

ip_id: RFC791 "some host may be able to simply use unique identifiers independent of destination"

Definition at line 1259 of file ip.c.

References ERR_BUF, pbuf::flags, htons, inet_chksum(), ip4_addr_get_u32, netif::ip_addr, ip_addr_cmp, ip_addr_copy, ip_addr_isany, IP_DEBUG, ip_debug_print, IP_HDRINCL, IP_HLEN, ip_id, IP_STATS_INC, IPH_CHKSUM_SET, IPH_ID_SET, IPH_LEN_SET, IPH_OFFSET_SET, IPH_PROTO_SET, IPH_TTL_SET, IPH_VHLTOS_SET, pbuf::len, LWIP_ASSERT, LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF, LWIP_MAKE_U16, MEMCPY, netif::mtu, netif::name, NULL, netif::num, os_memset, netif::output, pbuf::payload, PBUF_FLAG_MCASTLOOP, pbuf_header(), pbuf::ref, snmp_inc_ipoutdiscards, snmp_inc_ipoutrequests, pbuf::tot_len, and U16_F.

Referenced by ip_output().

{
#if IP_OPTIONS_SEND
  return ip_output_if_opt(p, src, dest, ttl, tos, proto, netif, NULL, 0);
}

/**
 * Same as ip_output_if() but with the possibility to include IP options:
 *
 * @ param ip_options pointer to the IP options, copied into the IP header
 * @ param optlen length of ip_options
 */
err_t ip_output_if_opt(struct pbuf *p, ip_addr_t *src, ip_addr_t *dest,
       u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options,
       u16_t optlen)
{
#endif /* IP_OPTIONS_SEND */
  struct ip_hdr *iphdr;
  ip_addr_t dest_addr;
#if CHECKSUM_GEN_IP_INLINE
  u32_t chk_sum = 0;
#endif /* CHECKSUM_GEN_IP_INLINE */

  /* pbufs passed to IP must have a ref-count of 1 as their payload pointer
     gets altered as the packet is passed down the stack */
  LWIP_ASSERT("p->ref == 1", p->ref == 1);

  snmp_inc_ipoutrequests();

  /* Should the IP header be generated or is it already included in p? */
  if (dest != IP_HDRINCL) {
    u16_t ip_hlen = IP_HLEN;
#if IP_OPTIONS_SEND
    u16_t optlen_aligned = 0;
    if (optlen != 0) {
#if CHECKSUM_GEN_IP_INLINE
      int i;
#endif /* CHECKSUM_GEN_IP_INLINE */
      /* round up to a multiple of 4 */
      optlen_aligned = ((optlen + 3) & ~3);
      ip_hlen += optlen_aligned;
      /* First write in the IP options */
      if (pbuf_header(p, optlen_aligned)) {
        LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip_output_if_opt: not enough room for IP options in pbuf\n"));
        IP_STATS_INC(ip.err);
        snmp_inc_ipoutdiscards();
        return ERR_BUF;
      }
      MEMCPY(p->payload, ip_options, optlen);
      if (optlen < optlen_aligned) {
        /* zero the remaining bytes */
        os_memset(((char*)p->payload) + optlen, 0, optlen_aligned - optlen);
      }
#if CHECKSUM_GEN_IP_INLINE
      for (i = 0; i < optlen_aligned/2; i++) {
        chk_sum += ((u16_t*)p->payload)[i];
      }
#endif /* CHECKSUM_GEN_IP_INLINE */
    }
#endif /* IP_OPTIONS_SEND */
    /* generate IP header */
    if (pbuf_header(p, IP_HLEN)) {
      LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip_output: not enough room for IP header in pbuf\n"));

      IP_STATS_INC(ip.err);
      snmp_inc_ipoutdiscards();
      return ERR_BUF;
    }

    iphdr = (struct ip_hdr *)p->payload;
    LWIP_ASSERT("check that first pbuf can hold struct ip_hdr",
               (p->len >= sizeof(struct ip_hdr)));

    IPH_TTL_SET(iphdr, ttl);
    IPH_PROTO_SET(iphdr, proto);
#if CHECKSUM_GEN_IP_INLINE
    chk_sum += LWIP_MAKE_U16(proto, ttl);
#endif /* CHECKSUM_GEN_IP_INLINE */

    /* dest cannot be NULL here */
    ip_addr_copy(iphdr->dest, *dest);
#if CHECKSUM_GEN_IP_INLINE
    chk_sum += ip4_addr_get_u32(&iphdr->dest) & 0xFFFF;
    chk_sum += ip4_addr_get_u32(&iphdr->dest) >> 16;
#endif /* CHECKSUM_GEN_IP_INLINE */

    IPH_VHLTOS_SET(iphdr, 4, ip_hlen / 4, tos);
#if CHECKSUM_GEN_IP_INLINE
    chk_sum += iphdr->_v_hl_tos;
#endif /* CHECKSUM_GEN_IP_INLINE */
    IPH_LEN_SET(iphdr, htons(p->tot_len));
#if CHECKSUM_GEN_IP_INLINE
    chk_sum += iphdr->_len;
#endif /* CHECKSUM_GEN_IP_INLINE */
    IPH_OFFSET_SET(iphdr, 0);
    IPH_ID_SET(iphdr, htons(ip_id));
#if CHECKSUM_GEN_IP_INLINE
    chk_sum += iphdr->_id;
#endif /* CHECKSUM_GEN_IP_INLINE */
    ++ip_id;

    if (ip_addr_isany(src)) {
      ip_addr_copy(iphdr->src, netif->ip_addr);
    } else {
      /* src cannot be NULL here */
      ip_addr_copy(iphdr->src, *src);
    }

#if CHECKSUM_GEN_IP_INLINE
    chk_sum += ip4_addr_get_u32(&iphdr->src) & 0xFFFF;
    chk_sum += ip4_addr_get_u32(&iphdr->src) >> 16;
    chk_sum = (chk_sum >> 16) + (chk_sum & 0xFFFF);
    chk_sum = (chk_sum >> 16) + chk_sum;
    chk_sum = ~chk_sum;
    iphdr->_chksum = chk_sum; /* network order */
#else /* CHECKSUM_GEN_IP_INLINE */
    IPH_CHKSUM_SET(iphdr, 0);
#if CHECKSUM_GEN_IP
    IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, ip_hlen));
#endif
#endif /* CHECKSUM_GEN_IP_INLINE */
  } else {
    /* IP header already included in p */
    iphdr = (struct ip_hdr *)p->payload;
    ip_addr_copy(dest_addr, iphdr->dest);
    dest = &dest_addr;
  }

  IP_STATS_INC(ip.xmit);

  LWIP_DEBUGF(IP_DEBUG, ("ip_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], netif->num));
  ip_debug_print(p);

#if ENABLE_LOOPBACK
  if (ip_addr_cmp(dest, &netif->ip_addr)) {
    /* Packet to self, enqueue it for loopback */
    LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()"));
    return netif_loop_output(netif, p, dest);
  }
#if LWIP_IGMP
  if ((p->flags & PBUF_FLAG_MCASTLOOP) != 0) {
    netif_loop_output(netif, p, dest);
  }
#endif /* LWIP_IGMP */
#endif /* ENABLE_LOOPBACK */
#if IP_FRAG
  /* don't fragment if interface has mtu set to 0 [loopif] */
  if (netif->mtu && (p->tot_len > netif->mtu)) {
    return ip_frag(p, netif, dest);
  }
#endif /* IP_FRAG */

  LWIP_DEBUGF(IP_DEBUG, ("netif->output()\n"));
  return netif->output(netif, p, dest);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_route()

struct netif* ip_route

(

ip_addr_t *

dest

)

Finds the appropriate network interface for a given IP address. It searches the list of network interfaces linearly. A match is found if the masked IP address of the network interface equals the masked IP address given to the function.

Parameters

dest	the destination IP address for which to find the route

Returns

the netif on which to send to reach dest

Definition at line 125 of file ip.c.

References eagle_lwip_getif(), ICACHE_FLASH_ATTR, ip4_addr1_16, ip4_addr2_16, ip4_addr3_16, ip4_addr4_16, netif::ip_addr, ip_addr_isbroadcast, ip_addr_netcmp, IP_DEBUG, IP_STATS_INC, LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF, netif_default, netif_is_up, netif_list, netif::netmask, netif::next, NULL, snmp_inc_ipoutnoroutes, and U16_F.

Referenced by ip_output(), and ip_router().

{
  struct netif *netif;

  /* iterate through netifs */
  for(netif = netif_list; netif != NULL; netif = netif->next) {
    /* network mask matches? */
    if (netif_is_up(netif)) {
      if (ip_addr_netcmp(dest, &(netif->ip_addr), &(netif->netmask))) {
        /* return netif on which to forward IP packet */
        return netif;
      }
    }
  }
  /* iterate through netifs */
  for(netif = netif_list; netif != NULL; netif = netif->next) {
    /* network mask matches? */
    if (netif_is_up(netif)) {
      if (!ip_addr_isbroadcast(dest, netif) && netif == (struct netif *)eagle_lwip_getif(0)) {
        return netif;
      }
    }
  }
  if ((netif_default == NULL) || (!netif_is_up(netif_default))) {
    LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
      ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));
    IP_STATS_INC(ip.rterr);
    snmp_inc_ipoutnoroutes();
    return NULL;
  }
  /* no matching netif found, use default netif */
  return netif_default;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_router()

struct netif* ip_router	(	ip_addr_t *	dest,
		ip_addr_t *	source
	)

Finds the appropriate network interface for a source IP address. It searches the list of network interfaces linearly. A match is found if the masked IP address of the network interface equals the masked IP address given to the function.

Parameters

source

the sourcination IP address for which to find the route

Returns

the netif on which to send to reach source

Definition at line 170 of file ip.c.

References current_iphdr_dest, ERR_OK, ERR_RTE, ICACHE_FLASH_ATTR, ICMP_DUR_PORT, ICMP_ECHO, ICMP_ER, ICMP_TE_TTL, ip4_addr1_16, ip4_addr2_16, ip4_addr3_16, ip4_addr4_16, netif::ip_addr, ip_addr_isany, ip_addr_islinklocal, ip_addr_netcmp, IP_DEBUG, IP_PROTO_ICMP, IP_PROTO_TCP, IP_PROTO_UDP, ip_route(), IP_STATS_INC, IPH_CHKSUM, IPH_CHKSUM_SET, IPH_HL, IPH_PROTO, IPH_TTL, IPH_TTL_SET, LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF, memcpy, netif_default, netif_is_up, netif_list, netif::netmask, netif::next, NULL, netif::num, os_printf, os_random(), os_zalloc, netif::output, pbuf::payload, PERF_START, PERF_STOP, PP_HTONS, PP_NTOHS, snmp_inc_ipforwdatagrams, snmp_inc_ipinhdrerrors, snmp_inc_ipoutnoroutes, sys_now(), and U16_F.

                                             {
    struct netif *netif;
    /* iterate through netifs */
    for(netif = netif_list; netif != NULL; netif = netif->next) {
        /* network mask matches? */
        
        if (netif_is_up(netif)) {
          if (ip_addr_netcmp(dest, &(netif->ip_addr), &(netif->netmask))) {
            /* return netif on which to forward IP packet */
            return netif;
          }
        }

        if (netif_is_up(netif)) {
          if (ip_addr_netcmp(source, &(netif->ip_addr), &(netif->netmask))) {
            /* return netif on which to forward IP packet */
            return netif;
          }
        }
    }

    if ((netif_default == NULL) || (!netif_is_up(netif_default))) {
        LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
          ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));
        IP_STATS_INC(ip.rterr);
        snmp_inc_ipoutnoroutes();
        return NULL;
    }
    /* no matching netif found, use default netif */
    os_printf("ip_router %d %p\n", __LINE__, netif_default);
    return netif_default;
}

Here is the call graph for this function:

Variable Documentation

current_header

const struct ip_hdr* current_header

Header of the input packet currently being processed.

Definition at line 106 of file ip.c.

current_iphdr_dest

ip_addr_t current_iphdr_dest

Destination IP address of current_header

Definition at line 110 of file ip.c.

Referenced by ip_input(), and ip_router().

current_iphdr_src

ip_addr_t current_iphdr_src

Source IP address of current_header

Definition at line 108 of file ip.c.

Referenced by ip_input().

current_netif

struct netif* current_netif

The interface that provided the packet for the current callback invocation.

Definition at line 101 of file ip.c.

PACK_STRUCT_STRUCT

PACK_STRUCT_BEGIN struct ip_hdr PACK_STRUCT_STRUCT