URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP_130/] [src/] [core/] [ipv6/] [ip6.c] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * This file is part of the lwIP TCP/IP stack.
 *
 * Author: Adam Dunkels <adam@sics.se>
 *
 */
 
 
 
/* ip.c
 *
 * This is the code for the IP layer for IPv6.
 *
 */
 
 
#include "lwip/opt.h"
 
#include "lwip/def.h"
#include "lwip/mem.h"
#include "lwip/ip.h"
#include "lwip/inet.h"
#include "lwip/netif.h"
#include "lwip/icmp.h"
#include "lwip/udp.h"
#include "lwip/tcp.h"
 
#include "lwip/stats.h"
 
#include "arch/perf.h"
 
/* ip_init:
 *
 * Initializes the IP layer.
 */
 
void
ip_init(void)
{
}
 
/* ip_route:
 *
 * 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.
 */
 
struct netif *
ip_route(struct ip_addr *dest)
{
  struct netif *netif;
 
  for(netif = netif_list; netif != NULL; netif = netif->next) {
    if (ip_addr_netcmp(dest, &(netif->ip_addr), &(netif->netmask))) {
      return netif;
    }
  }
 
  return netif_default;
}
 
/* ip_forward:
 *
 * Forwards an IP packet. It finds an appropriate route for the packet, decrements
 * the TTL value of the packet, adjusts the checksum and outputs the packet on the
 * appropriate interface.
 */
 
static void
ip_forward(struct pbuf *p, struct ip_hdr *iphdr)
{
  struct netif *netif;
 
  PERF_START;
 
  if ((netif = ip_route((struct ip_addr *)&(iphdr->dest))) == NULL) {
 
    LWIP_DEBUGF(IP_DEBUG, ("ip_input: no forwarding route found for "));
#if IP_DEBUG
    ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));
#endif /* IP_DEBUG */
    LWIP_DEBUGF(IP_DEBUG, ("\n"));
    pbuf_free(p);
    return;
  }
  /* Decrement TTL and send ICMP if ttl == 0. */
  if (--iphdr->hoplim == 0) {
#if LWIP_ICMP
    /* Don't send ICMP messages in response to ICMP messages */
    if (iphdr->nexthdr != IP_PROTO_ICMP) {
      icmp_time_exceeded(p, ICMP_TE_TTL);
    }
#endif /* LWIP_ICMP */
    pbuf_free(p);
    return;
  }
 
  /* Incremental update of the IP checksum. */
  /*  if (iphdr->chksum >= htons(0xffff - 0x100)) {
    iphdr->chksum += htons(0x100) + 1;
  } else {
    iphdr->chksum += htons(0x100);
    }*/
 
 
  LWIP_DEBUGF(IP_DEBUG, ("ip_forward: forwarding packet to "));
#if IP_DEBUG
  ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));
#endif /* IP_DEBUG */
  LWIP_DEBUGF(IP_DEBUG, ("\n"));
 
  IP_STATS_INC(ip.fw);
  IP_STATS_INC(ip.xmit);
 
  PERF_STOP("ip_forward");
 
  netif->output(netif, p, (struct ip_addr *)&(iphdr->dest));
}
 
/* ip_input:
 *
 * 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.
 */
 
void
ip_input(struct pbuf *p, struct netif *inp) {
  struct ip_hdr *iphdr;
  struct netif *netif;
 
 
  PERF_START;
 
#if IP_DEBUG
  ip_debug_print(p);
#endif /* IP_DEBUG */
 
 
  IP_STATS_INC(ip.recv);
 
  /* identify the IP header */
  iphdr = p->payload;
 
 
  if (iphdr->v != 6) {
    LWIP_DEBUGF(IP_DEBUG, ("IP packet dropped due to bad version number\n"));
#if IP_DEBUG
    ip_debug_print(p);
#endif /* IP_DEBUG */
    pbuf_free(p);
    IP_STATS_INC(ip.err);
    IP_STATS_INC(ip.drop);
    return;
  }
 
  /* is this packet for us? */
  for(netif = netif_list; netif != NULL; netif = netif->next) {
#if IP_DEBUG
    LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest "));
    ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));
    LWIP_DEBUGF(IP_DEBUG, ("netif->ip_addr "));
    ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));
    LWIP_DEBUGF(IP_DEBUG, ("\n"));
#endif /* IP_DEBUG */
    if (ip_addr_cmp(&(iphdr->dest), &(netif->ip_addr))) {
      break;
    }
  }
 
 
  if (netif == NULL) {
    /* packet not for us, route or discard */
#if IP_FORWARD
    ip_forward(p, iphdr);
#endif
    pbuf_free(p);
    return;
  }
 
  pbuf_realloc(p, IP_HLEN + ntohs(iphdr->len));
 
  /* send to upper layers */
#if IP_DEBUG
  /*  LWIP_DEBUGF("ip_input: \n");
  ip_debug_print(p);
  LWIP_DEBUGF("ip_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len);*/
#endif /* IP_DEBUG */
 
  if(pbuf_header(p, -IP_HLEN)) {
    LWIP_ASSERT("Can't move over header in packet", 0);
    return;
  }
 
  switch (iphdr->nexthdr) {
  case IP_PROTO_UDP:
    udp_input(p, inp);
    break;
  case IP_PROTO_TCP:
    tcp_input(p, inp);
    break;
#if LWIP_ICMP
  case IP_PROTO_ICMP:
    icmp_input(p, inp);
    break;
#endif /* LWIP_ICMP */
  default:
#if LWIP_ICMP
    /* send ICMP destination protocol unreachable */
    icmp_dest_unreach(p, ICMP_DUR_PROTO);
#endif /* LWIP_ICMP */
    pbuf_free(p);
    LWIP_DEBUGF(IP_DEBUG, ("Unsupported transport protocol %"U16_F"\n",
          iphdr->nexthdr));
 
    IP_STATS_INC(ip.proterr);
    IP_STATS_INC(ip.drop);
  }
  PERF_STOP("ip_input");
}
 
 
/* ip_output_if:
 *
 * 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.
 */
 
err_t
ip_output_if (struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
       u8_t ttl,
       u8_t proto, struct netif *netif)
{
  struct ip_hdr *iphdr;
 
  PERF_START;
 
  LWIP_DEBUGF(IP_DEBUG, ("len %"U16_F" tot_len %"U16_F"\n", p->len, p->tot_len));
  if (pbuf_header(p, IP_HLEN)) {
    LWIP_DEBUGF(IP_DEBUG, ("ip_output: not enough room for IP header in pbuf\n"));
    IP_STATS_INC(ip.err);
 
    return ERR_BUF;
  }
  LWIP_DEBUGF(IP_DEBUG, ("len %"U16_F" tot_len %"U16_F"\n", p->len, p->tot_len));
 
  iphdr = p->payload;
 
 
  if (dest != IP_HDRINCL) {
    LWIP_DEBUGF(IP_DEBUG, ("!IP_HDRLINCL\n"));
    iphdr->hoplim = ttl;
    iphdr->nexthdr = proto;
    iphdr->len = htons(p->tot_len - IP_HLEN);
    ip_addr_set(&(iphdr->dest), dest);
 
    iphdr->v = 6;
 
    if (ip_addr_isany(src)) {
      ip_addr_set(&(iphdr->src), &(netif->ip_addr));
    } else {
      ip_addr_set(&(iphdr->src), src);
    }
 
  } else {
    dest = &(iphdr->dest);
  }
 
  IP_STATS_INC(ip.xmit);
 
  LWIP_DEBUGF(IP_DEBUG, ("ip_output_if: %c%c (len %"U16_F")\n", netif->name[0], netif->name[1], p->tot_len));
#if IP_DEBUG
  ip_debug_print(p);
#endif /* IP_DEBUG */
 
  PERF_STOP("ip_output_if");
  return netif->output(netif, p, dest);
}
 
/* ip_output:
 *
 * Simple interface to ip_output_if. It finds the outgoing network interface and
 * calls upon ip_output_if to do the actual work.
 */
 
err_t
ip_output(struct pbuf *p, struct ip_addr *src, struct ip_addr *dest,
    u8_t ttl, u8_t proto)
{
  struct netif *netif;
  if ((netif = ip_route(dest)) == NULL) {
    LWIP_DEBUGF(IP_DEBUG, ("ip_output: No route to 0x%"X32_F"\n", dest->addr));
    IP_STATS_INC(ip.rterr);
    return ERR_RTE;
  }
 
  return ip_output_if (p, src, dest, ttl, proto, netif);
}
 
#if IP_DEBUG
void
ip_debug_print(struct pbuf *p)
{
  struct ip_hdr *iphdr = p->payload;
 
  LWIP_DEBUGF(IP_DEBUG, ("IP header:\n"));
  LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
  LWIP_DEBUGF(IP_DEBUG, ("|%2"S16_F" |  %"X16_F"%"X16_F"  |      %"X16_F"%"X16_F"           | (v, traffic class, flow label)\n",
        iphdr->v,
        iphdr->tclass1, iphdr->tclass2,
        iphdr->flow1, iphdr->flow2));
  LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
  LWIP_DEBUGF(IP_DEBUG, ("|    %5"U16_F"      | %2"U16_F"  |  %2"U16_F"   | (len, nexthdr, hoplim)\n",
        ntohs(iphdr->len),
        iphdr->nexthdr,
        iphdr->hoplim));
  LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (src)\n",
        (ntohl(iphdr->src.addr[0]) >> 16) & 0xffff,
        ntohl(iphdr->src.addr[0]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (src)\n",
        (ntohl(iphdr->src.addr[1]) >> 16) & 0xffff,
        ntohl(iphdr->src.addr[1]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (src)\n",
        (ntohl(iphdr->src.addr[2]) >> 16) & 0xffff,
        ntohl(iphdr->src.addr[2]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (src)\n",
        (ntohl(iphdr->src.addr[3]) >> 16) & 0xffff,
        ntohl(iphdr->src.addr[3]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (dest)\n",
        (ntohl(iphdr->dest.addr[0]) >> 16) & 0xffff,
        ntohl(iphdr->dest.addr[0]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (dest)\n",
        (ntohl(iphdr->dest.addr[1]) >> 16) & 0xffff,
        ntohl(iphdr->dest.addr[1]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (dest)\n",
        (ntohl(iphdr->dest.addr[2]) >> 16) & 0xffff,
        ntohl(iphdr->dest.addr[2]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("|       %4"X32_F"      |       %4"X32_F"     | (dest)\n",
        (ntohl(iphdr->dest.addr[3]) >> 16) & 0xffff,
        ntohl(iphdr->dest.addr[3]) & 0xffff));
  LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
}
#endif /* IP_DEBUG */

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP_130/] [src/] [core/] [ipv6/] [ip6.c] - Blame information for rev 841

Line No.	Rev	Author	Line
1	606	jeremybenn	`/*`
2			`* Copyright (c) 2001-2004 Swedish Institute of Computer Science.`
3			`* All rights reserved.`
4			`*`
5			`* Redistribution and use in source and binary forms, with or without modification,`
6			`* are permitted provided that the following conditions are met:`
7			`*`
8			`* 1. Redistributions of source code must retain the above copyright notice,`
9			`* this list of conditions and the following disclaimer.`
10			`* 2. Redistributions in binary form must reproduce the above copyright notice,`
11			`* this list of conditions and the following disclaimer in the documentation`
12			`* and/or other materials provided with the distribution.`
13			`* 3. The name of the author may not be used to endorse or promote products`
14			`* derived from this software without specific prior written permission.`
15			`*`
16			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17			`* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF`
18			`* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT`
19			`* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,`
20			`* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT`
21			`* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS`
22			`* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN`
23			`* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING`
24			`* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY`
25			`* OF SUCH DAMAGE.`
26			`*`
27			`* This file is part of the lwIP TCP/IP stack.`
28			`*`
29			`* Author: Adam Dunkels <adam@sics.se>`
30			`*`
31			`*/`
32
33
34
35			`/* ip.c`
36			`*`
37			`* This is the code for the IP layer for IPv6.`
38			`*`
39			`*/`
40
41
42			`#include "lwip/opt.h"`
43
44			`#include "lwip/def.h"`
45			`#include "lwip/mem.h"`
46			`#include "lwip/ip.h"`
47			`#include "lwip/inet.h"`
48			`#include "lwip/netif.h"`
49			`#include "lwip/icmp.h"`
50			`#include "lwip/udp.h"`
51			`#include "lwip/tcp.h"`
52
53			`#include "lwip/stats.h"`
54
55			`#include "arch/perf.h"`
56
57			`/* ip_init:`
58			`*`
59			`* Initializes the IP layer.`
60			`*/`
61
62			`void`
63			`ip_init(void)`
64			`{`
65			`}`
66
67			`/* ip_route:`
68			`*`
69			`* Finds the appropriate network interface for a given IP address. It searches the`
70			`* list of network interfaces linearly. A match is found if the masked IP address of`
71			`* the network interface equals the masked IP address given to the function.`
72			`*/`
73
74			`struct netif *`
75			`ip_route(struct ip_addr *dest)`
76			`{`
77			`struct netif *netif;`
78
79			`for(netif = netif_list; netif != NULL; netif = netif->next) {`
80			`if (ip_addr_netcmp(dest, &(netif->ip_addr), &(netif->netmask))) {`
81			`return netif;`
82			`}`
83			`}`
84
85			`return netif_default;`
86			`}`
87
88			`/* ip_forward:`
89			`*`
90			`* Forwards an IP packet. It finds an appropriate route for the packet, decrements`
91			`* the TTL value of the packet, adjusts the checksum and outputs the packet on the`
92			`* appropriate interface.`
93			`*/`
94
95			`static void`
96			`ip_forward(struct pbuf p, struct ip_hdr iphdr)`
97			`{`
98			`struct netif *netif;`
99
100			`PERF_START;`
101
102			`if ((netif = ip_route((struct ip_addr *)&(iphdr->dest))) == NULL) {`
103
104			`LWIP_DEBUGF(IP_DEBUG, ("ip_input: no forwarding route found for "));`
105			`#if IP_DEBUG`
106			`ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));`
107			`#endif /* IP_DEBUG */`
108			`LWIP_DEBUGF(IP_DEBUG, ("\n"));`
109			`pbuf_free(p);`
110			`return;`
111			`}`
112			`/* Decrement TTL and send ICMP if ttl == 0. */`
113			`if (--iphdr->hoplim == 0) {`
114			`#if LWIP_ICMP`
115			`/* Don't send ICMP messages in response to ICMP messages */`
116			`if (iphdr->nexthdr != IP_PROTO_ICMP) {`
117			`icmp_time_exceeded(p, ICMP_TE_TTL);`
118			`}`
119			`#endif /* LWIP_ICMP */`
120			`pbuf_free(p);`
121			`return;`
122			`}`
123
124			`/* Incremental update of the IP checksum. */`
125			`/* if (iphdr->chksum >= htons(0xffff - 0x100)) {`
126			`iphdr->chksum += htons(0x100) + 1;`
127			`} else {`
128			`iphdr->chksum += htons(0x100);`
129			`}*/`
130
131
132			`LWIP_DEBUGF(IP_DEBUG, ("ip_forward: forwarding packet to "));`
133			`#if IP_DEBUG`
134			`ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));`
135			`#endif /* IP_DEBUG */`
136			`LWIP_DEBUGF(IP_DEBUG, ("\n"));`
137
138			`IP_STATS_INC(ip.fw);`
139			`IP_STATS_INC(ip.xmit);`
140
141			`PERF_STOP("ip_forward");`
142
143			`netif->output(netif, p, (struct ip_addr *)&(iphdr->dest));`
144			`}`
145
146			`/* ip_input:`
147			`*`
148			`* This function is called by the network interface device driver when an IP packet is`
149			`* received. The function does the basic checks of the IP header such as packet size`
150			`* being at least larger than the header size etc. If the packet was not destined for`
151			`* us, the packet is forwarded (using ip_forward). The IP checksum is always checked.`
152			`*`
153			`* Finally, the packet is sent to the upper layer protocol input function.`
154			`*/`
155
156			`void`
157			`ip_input(struct pbuf p, struct netif inp) {`
158			`struct ip_hdr *iphdr;`
159			`struct netif *netif;`
160
161
162			`PERF_START;`
163
164			`#if IP_DEBUG`
165			`ip_debug_print(p);`
166			`#endif /* IP_DEBUG */`
167
168
169			`IP_STATS_INC(ip.recv);`
170
171			`/* identify the IP header */`
172			`iphdr = p->payload;`
173
174
175			`if (iphdr->v != 6) {`
176			`LWIP_DEBUGF(IP_DEBUG, ("IP packet dropped due to bad version number\n"));`
177			`#if IP_DEBUG`
178			`ip_debug_print(p);`
179			`#endif /* IP_DEBUG */`
180			`pbuf_free(p);`
181			`IP_STATS_INC(ip.err);`
182			`IP_STATS_INC(ip.drop);`
183			`return;`
184			`}`
185
186			`/* is this packet for us? */`
187			`for(netif = netif_list; netif != NULL; netif = netif->next) {`
188			`#if IP_DEBUG`
189			`LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest "));`
190			`ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));`
191			`LWIP_DEBUGF(IP_DEBUG, ("netif->ip_addr "));`
192			`ip_addr_debug_print(IP_DEBUG, ((struct ip_addr *)&(iphdr->dest)));`
193			`LWIP_DEBUGF(IP_DEBUG, ("\n"));`
194			`#endif /* IP_DEBUG */`
195			`if (ip_addr_cmp(&(iphdr->dest), &(netif->ip_addr))) {`
196			`break;`
197			`}`
198			`}`
199
200
201			`if (netif == NULL) {`
202			`/* packet not for us, route or discard */`
203			`#if IP_FORWARD`
204			`ip_forward(p, iphdr);`
205			`#endif`
206			`pbuf_free(p);`
207			`return;`
208			`}`
209
210			`pbuf_realloc(p, IP_HLEN + ntohs(iphdr->len));`
211
212			`/* send to upper layers */`
213			`#if IP_DEBUG`
214			`/* LWIP_DEBUGF("ip_input: \n");`
215			`ip_debug_print(p);`
216			`LWIP_DEBUGF("ip_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len);*/`
217			`#endif /* IP_DEBUG */`
218
219			`if(pbuf_header(p, -IP_HLEN)) {`
220			`LWIP_ASSERT("Can't move over header in packet", 0);`
221			`return;`
222			`}`
223
224			`switch (iphdr->nexthdr) {`
225			`case IP_PROTO_UDP:`
226			`udp_input(p, inp);`
227			`break;`
228			`case IP_PROTO_TCP:`
229			`tcp_input(p, inp);`
230			`break;`
231			`#if LWIP_ICMP`
232			`case IP_PROTO_ICMP:`
233			`icmp_input(p, inp);`
234			`break;`
235			`#endif /* LWIP_ICMP */`
236			`default:`
237			`#if LWIP_ICMP`
238			`/* send ICMP destination protocol unreachable */`
239			`icmp_dest_unreach(p, ICMP_DUR_PROTO);`
240			`#endif /* LWIP_ICMP */`
241			`pbuf_free(p);`
242			`LWIP_DEBUGF(IP_DEBUG, ("Unsupported transport protocol %"U16_F"\n",`
243			`iphdr->nexthdr));`
244
245			`IP_STATS_INC(ip.proterr);`
246			`IP_STATS_INC(ip.drop);`
247			`}`
248			`PERF_STOP("ip_input");`
249			`}`
250
251
252			`/* ip_output_if:`
253			`*`
254			`* Sends an IP packet on a network interface. This function constructs the IP header`
255			`* and calculates the IP header checksum. If the source IP address is NULL,`
256			`* the IP address of the outgoing network interface is filled in as source address.`
257			`*/`
258
259			`err_t`
260			`ip_output_if (struct pbuf p, struct ip_addr src, struct ip_addr *dest,`
261			`u8_t ttl,`
262			`u8_t proto, struct netif *netif)`
263			`{`
264			`struct ip_hdr *iphdr;`
265
266			`PERF_START;`
267
268			`LWIP_DEBUGF(IP_DEBUG, ("len %"U16_F" tot_len %"U16_F"\n", p->len, p->tot_len));`
269			`if (pbuf_header(p, IP_HLEN)) {`
270			`LWIP_DEBUGF(IP_DEBUG, ("ip_output: not enough room for IP header in pbuf\n"));`
271			`IP_STATS_INC(ip.err);`
272
273			`return ERR_BUF;`
274			`}`
275			`LWIP_DEBUGF(IP_DEBUG, ("len %"U16_F" tot_len %"U16_F"\n", p->len, p->tot_len));`
276
277			`iphdr = p->payload;`
278
279
280			`if (dest != IP_HDRINCL) {`
281			`LWIP_DEBUGF(IP_DEBUG, ("!IP_HDRLINCL\n"));`
282			`iphdr->hoplim = ttl;`
283			`iphdr->nexthdr = proto;`
284			`iphdr->len = htons(p->tot_len - IP_HLEN);`
285			`ip_addr_set(&(iphdr->dest), dest);`
286
287			`iphdr->v = 6;`
288
289			`if (ip_addr_isany(src)) {`
290			`ip_addr_set(&(iphdr->src), &(netif->ip_addr));`
291			`} else {`
292			`ip_addr_set(&(iphdr->src), src);`
293			`}`
294
295			`} else {`
296			`dest = &(iphdr->dest);`
297			`}`
298
299			`IP_STATS_INC(ip.xmit);`
300
301			`LWIP_DEBUGF(IP_DEBUG, ("ip_output_if: %c%c (len %"U16_F")\n", netif->name[0], netif->name[1], p->tot_len));`
302			`#if IP_DEBUG`
303			`ip_debug_print(p);`
304			`#endif /* IP_DEBUG */`
305
306			`PERF_STOP("ip_output_if");`
307			`return netif->output(netif, p, dest);`
308			`}`
309
310			`/* ip_output:`
311			`*`
312			`* Simple interface to ip_output_if. It finds the outgoing network interface and`
313			`* calls upon ip_output_if to do the actual work.`
314			`*/`
315
316			`err_t`
317			`ip_output(struct pbuf p, struct ip_addr src, struct ip_addr *dest,`
318			`u8_t ttl, u8_t proto)`
319			`{`
320			`struct netif *netif;`
321			`if ((netif = ip_route(dest)) == NULL) {`
322			`LWIP_DEBUGF(IP_DEBUG, ("ip_output: No route to 0x%"X32_F"\n", dest->addr));`
323			`IP_STATS_INC(ip.rterr);`
324			`return ERR_RTE;`
325			`}`
326
327			`return ip_output_if (p, src, dest, ttl, proto, netif);`
328			`}`
329
330			`#if IP_DEBUG`
331			`void`
332			`ip_debug_print(struct pbuf *p)`
333			`{`
334			`struct ip_hdr *iphdr = p->payload;`
335
336			`LWIP_DEBUGF(IP_DEBUG, ("IP header:\n"));`
337			`LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));`
338			`LWIP_DEBUGF(IP_DEBUG, ("\|%2"S16_F" \| %"X16_F"%"X16_F" \| %"X16_F"%"X16_F" \| (v, traffic class, flow label)\n",`
339			`iphdr->v,`
340			`iphdr->tclass1, iphdr->tclass2,`
341			`iphdr->flow1, iphdr->flow2));`
342			`LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));`
343			`LWIP_DEBUGF(IP_DEBUG, ("\| %5"U16_F" \| %2"U16_F" \| %2"U16_F" \| (len, nexthdr, hoplim)\n",`
344			`ntohs(iphdr->len),`
345			`iphdr->nexthdr,`
346			`iphdr->hoplim));`
347			`LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));`
348			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (src)\n",`
349			`(ntohl(iphdr->src.addr[0]) >> 16) & 0xffff,`
350			`ntohl(iphdr->src.addr[0]) & 0xffff));`
351			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (src)\n",`
352			`(ntohl(iphdr->src.addr[1]) >> 16) & 0xffff,`
353			`ntohl(iphdr->src.addr[1]) & 0xffff));`
354			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (src)\n",`
355			`(ntohl(iphdr->src.addr[2]) >> 16) & 0xffff,`
356			`ntohl(iphdr->src.addr[2]) & 0xffff));`
357			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (src)\n",`
358			`(ntohl(iphdr->src.addr[3]) >> 16) & 0xffff,`
359			`ntohl(iphdr->src.addr[3]) & 0xffff));`
360			`LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));`
361			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (dest)\n",`
362			`(ntohl(iphdr->dest.addr[0]) >> 16) & 0xffff,`
363			`ntohl(iphdr->dest.addr[0]) & 0xffff));`
364			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (dest)\n",`
365			`(ntohl(iphdr->dest.addr[1]) >> 16) & 0xffff,`
366			`ntohl(iphdr->dest.addr[1]) & 0xffff));`
367			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (dest)\n",`
368			`(ntohl(iphdr->dest.addr[2]) >> 16) & 0xffff,`
369			`ntohl(iphdr->dest.addr[2]) & 0xffff));`
370			`LWIP_DEBUGF(IP_DEBUG, ("\| %4"X32_F" \| %4"X32_F" \| (dest)\n",`
371			`(ntohl(iphdr->dest.addr[3]) >> 16) & 0xffff,`
372			`ntohl(iphdr->dest.addr[3]) & 0xffff));`
373			`LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));`
374			`}`
375			`#endif /* IP_DEBUG */`