src/core/ipv6/ip6.c

   1 /**
   2  * @file
   3  *
   4  * IPv6 layer.
   5  */
   6
   7 /*
   8  * Copyright (c) 2010 Inico Technologies Ltd.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without modification,
  12  * are permitted provided that the following conditions are met:
  13  *
  14  * 1. Redistributions of source code must retain the above copyright notice,
  15  *    this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright notice,
  17  *    this list of conditions and the following disclaimer in the documentation
  18  *    and/or other materials provided with the distribution.
  19  * 3. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  23  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  25  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  26  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  27  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  31  * OF SUCH DAMAGE.
  32  *
  33  * This file is part of the lwIP TCP/IP stack.
  34  *
  35  * Author: Ivan Delamer <delamer@inicotech.com>
  36  *
  37  *
  38  * Please coordinate changes and requests with Ivan Delamer
  39  * <delamer@inicotech.com>
  40  */
  41
  42
  43 #include "lwip/opt.h"
  44
  45 #if LWIP_IPV6  /* don't build if not configured for use in lwipopts.h */
  46
  47 #include "lwip/def.h"
  48 #include "lwip/mem.h"
  49 #include "lwip/netif.h"
  50 #include "lwip/ip6.h"
  51 #include "lwip/ip6_addr.h"
  52 #include "lwip/ip6_frag.h"
  53 #include "lwip/icmp6.h"
  54 #include "lwip/raw.h"
  55 #include "lwip/udp.h"
  56 #include "lwip/tcp_impl.h"
  57 #include "lwip/dhcp6.h"
  58 #include "lwip/nd6.h"
  59 #include "lwip/mld6.h"
  60 #include "lwip/debug.h"
  61 #include "lwip/stats.h"
  62
  63
  64 /**
  65  * Finds the appropriate network interface for a given IPv6 address. It tries to select
  66  * a netif following a sequence of heuristics:
  67  * 1) if there is only 1 netif, return it
  68  * 2) if the destination is a link-local address, try to match the src address to a netif.
  69  *    this is a tricky case because with multiple netifs, link-local addresses only have
  70  *    meaning within a particular subnet/link.
  71  * 3) tries to match the destination subnet to a configured address
  72  * 4) tries to find a router
  73  * 5) tries to match the source address to the netif
  74  * 6) returns the default netif, if configured
  75  *
  76  * @param src the source IPv6 address, if known
  77  * @param dest the destination IPv6 address for which to find the route
  78  * @return the netif on which to send to reach dest
  79  */
  80 struct netif *
  81 ip6_route(struct ip6_addr *src, struct ip6_addr *dest)
  82 {
  83   struct netif *netif;
  84   s8_t i;
  85
  86   /* If single netif configuration, fast return. */
  87   if ((netif_list != NULL) && (netif_list->next == NULL)) {
  88     return netif_list;
  89   }
  90
  91   /* Special processing for link-local addresses. */
  92   if (ip6_addr_islinklocal(dest)) {
  93     if (ip6_addr_isany(src)) {
  94       /* Use default netif. */
  95       return netif_default;
  96     }
  97
  98     /* Try to find the netif for the source address. */
  99     for(netif = netif_list; netif != NULL; netif = netif->next) {
 100       for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 101         if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 102             ip6_addr_cmp(src, netif_ip6_addr(netif, i))) {
 103           return netif;
 104         }
 105       }
 106     }
 107
 108     /* netif not found, use default netif */
 109     return netif_default;
 110   }
 111
 112   /* See if the destination subnet matches a configured address. */
 113   for(netif = netif_list; netif != NULL; netif = netif->next) {
 114     for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 115       if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 116           ip6_addr_netcmp(dest, netif_ip6_addr(netif, i))) {
 117         return netif;
 118       }
 119     }
 120   }
 121
 122   /* Get the netif for a suitable router. */
 123   i = nd6_select_router(dest, NULL);
 124   if (i >= 0) {
 125     if (default_router_list[i].neighbor_entry != NULL) {
 126       if (default_router_list[i].neighbor_entry->netif != NULL) {
 127         return default_router_list[i].neighbor_entry->netif;
 128       }
 129     }
 130   }
 131
 132   /* try with the netif that matches the source address. */
 133   if (!ip6_addr_isany(src)) {
 134     for(netif = netif_list; netif != NULL; netif = netif->next) {
 135       for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 136         if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 137             ip6_addr_cmp(src, netif_ip6_addr(netif, i))) {
 138           return netif;
 139         }
 140       }
 141     }
 142   }
 143
 144   /* no matching netif found, use default netif */
 145   return netif_default;
 146 }
 147
 148 /**
 149  * Select the best IPv6 source address for a given destination
 150  * IPv6 address. Loosely follows RFC 3484. "Strong host" behavior
 151  * is assumed.
 152  *
 153  * @param netif the netif on which to send a packet
 154  * @param dest the destination we are trying to reach
 155  * @return the most suitable source address to use, or NULL if no suitable
 156  *         source address is found
 157  */
 158 ip6_addr_t *
 159 ip6_select_source_address(struct netif *netif, ip6_addr_t * dest)
 160 {
 161   ip6_addr_t * src = NULL;
 162   u8_t i;
 163
 164   /* If dest is link-local, choose a link-local source. */
 165   if (ip6_addr_islinklocal(dest) || ip6_addr_ismulticast_linklocal(dest) || ip6_addr_ismulticast_iflocal(dest)) {
 166     for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 167       if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 168           ip6_addr_islinklocal(netif_ip6_addr(netif, i))) {
 169         return netif_ip6_addr(netif, i);
 170       }
 171     }
 172   }
 173
 174   /* Choose a site-local with matching prefix. */
 175   if (ip6_addr_issitelocal(dest) || ip6_addr_ismulticast_sitelocal(dest)) {
 176     for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 177       if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 178           ip6_addr_issitelocal(netif_ip6_addr(netif, i)) &&
 179           ip6_addr_netcmp(dest, netif_ip6_addr(netif, i))) {
 180         return netif_ip6_addr(netif, i);
 181       }
 182     }
 183   }
 184
 185   /* Choose a unique-local with matching prefix. */
 186   if (ip6_addr_isuniquelocal(dest) || ip6_addr_ismulticast_orglocal(dest)) {
 187     for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 188       if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 189           ip6_addr_isuniquelocal(netif_ip6_addr(netif, i)) &&
 190           ip6_addr_netcmp(dest, netif_ip6_addr(netif, i))) {
 191         return netif_ip6_addr(netif, i);
 192       }
 193     }
 194   }
 195
 196   /* Choose a global with best matching prefix. */
 197   if (ip6_addr_isglobal(dest) || ip6_addr_ismulticast_global(dest)) {
 198     for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 199       if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 200           ip6_addr_isglobal(netif_ip6_addr(netif, i))) {
 201         if (src == NULL) {
 202           src = netif_ip6_addr(netif, i);
 203         }
 204         else {
 205           /* Replace src only if we find a prefix match. */
 206           /* TODO find longest matching prefix. */
 207           if ((!(ip6_addr_netcmp(src, dest))) &&
 208               ip6_addr_netcmp(netif_ip6_addr(netif, i), dest)) {
 209             src = netif_ip6_addr(netif, i);
 210           }
 211         }
 212       }
 213     }
 214     if (src != NULL) {
 215       return src;
 216     }
 217   }
 218
 219   /* Last resort: see if arbitrary prefix matches. */
 220   for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 221     if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 222         ip6_addr_netcmp(dest, netif_ip6_addr(netif, i))) {
 223       return netif_ip6_addr(netif, i);
 224     }
 225   }
 226
 227   return NULL;
 228 }
 229
 230 #if LWIP_IPV6_FORWARD
 231 /**
 232  * Forwards an IPv6 packet. It finds an appropriate route for the
 233  * packet, decrements the HL value of the packet, and outputs
 234  * the packet on the appropriate interface.
 235  *
 236  * @param p the packet to forward (p->payload points to IP header)
 237  * @param iphdr the IPv6 header of the input packet
 238  * @param inp the netif on which this packet was received
 239  */
 240 static void
 241 ip6_forward(struct pbuf *p, struct ip6_hdr *iphdr, struct netif *inp)
 242 {
 243   struct netif *netif;
 244
 245   /* do not forward link-local addresses */
 246   if (ip6_addr_islinklocal(ip6_current_dest_addr())) {
 247     LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not forwarding link-local address.\n"));
 248     IP6_STATS_INC(ip6.rterr);
 249     IP6_STATS_INC(ip6.drop);
 250     return;
 251   }
 252
 253   /* Find network interface where to forward this IP packet to. */
 254   netif = ip6_route(IP6_ADDR_ANY, ip6_current_dest_addr());
 255   if (netif == NULL) {
 256     LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n",
 257         IP6_ADDR_BLOCK1(ip6_current_dest_addr()),
 258         IP6_ADDR_BLOCK2(ip6_current_dest_addr()),
 259         IP6_ADDR_BLOCK3(ip6_current_dest_addr()),
 260         IP6_ADDR_BLOCK4(ip6_current_dest_addr()),
 261         IP6_ADDR_BLOCK5(ip6_current_dest_addr()),
 262         IP6_ADDR_BLOCK6(ip6_current_dest_addr()),
 263         IP6_ADDR_BLOCK7(ip6_current_dest_addr()),
 264         IP6_ADDR_BLOCK8(ip6_current_dest_addr())));
 265 #if LWIP_ICMP6
 266     /* Don't send ICMP messages in response to ICMP messages */
 267     if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) {
 268       icmp6_dest_unreach(p, ICMP6_DUR_NO_ROUTE);
 269     }
 270 #endif /* LWIP_ICMP6 */
 271     IP6_STATS_INC(ip6.rterr);
 272     IP6_STATS_INC(ip6.drop);
 273     return;
 274   }
 275   /* Do not forward packets onto the same network interface on which
 276    * they arrived. */
 277   if (netif == inp) {
 278     LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not bouncing packets back on incoming interface.\n"));
 279     IP6_STATS_INC(ip6.rterr);
 280     IP6_STATS_INC(ip6.drop);
 281     return;
 282   }
 283
 284   /* decrement HL */
 285   IP6H_HOPLIM_SET(iphdr, IP6H_HOPLIM(iphdr) - 1);
 286   /* send ICMP6 if HL == 0 */
 287   if (IP6H_HOPLIM(iphdr) == 0) {
 288 #if LWIP_ICMP6
 289     /* Don't send ICMP messages in response to ICMP messages */
 290     if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) {
 291       icmp6_time_exceeded(p, ICMP6_TE_HL);
 292     }
 293 #endif /* LWIP_ICMP6 */
 294     IP6_STATS_INC(ip6.drop);
 295     return;
 296   }
 297
 298   LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: forwarding packet to %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n",
 299       IP6_ADDR_BLOCK1(ip6_current_dest_addr()),
 300       IP6_ADDR_BLOCK2(ip6_current_dest_addr()),
 301       IP6_ADDR_BLOCK3(ip6_current_dest_addr()),
 302       IP6_ADDR_BLOCK4(ip6_current_dest_addr()),
 303       IP6_ADDR_BLOCK5(ip6_current_dest_addr()),
 304       IP6_ADDR_BLOCK6(ip6_current_dest_addr()),
 305       IP6_ADDR_BLOCK7(ip6_current_dest_addr()),
 306       IP6_ADDR_BLOCK8(ip6_current_dest_addr())));
 307
 308   /* transmit pbuf on chosen interface */
 309   netif->output_ip6(netif, p, ip6_current_dest_addr());
 310   IP6_STATS_INC(ip6.fw);
 311   IP6_STATS_INC(ip6.xmit);
 312   return;
 313 }
 314 #endif /* LWIP_IPV6_FORWARD */
 315
 316
 317 /**
 318  * This function is called by the network interface device driver when
 319  * an IPv6 packet is received. The function does the basic checks of the
 320  * IP header such as packet size being at least larger than the header
 321  * size etc. If the packet was not destined for us, the packet is
 322  * forwarded (using ip6_forward).
 323  *
 324  * Finally, the packet is sent to the upper layer protocol input function.
 325  *
 326  * @param p the received IPv6 packet (p->payload points to IPv6 header)
 327  * @param inp the netif on which this packet was received
 328  * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't
 329  *         processed, but currently always returns ERR_OK)
 330  */
 331 err_t
 332 ip6_input(struct pbuf *p, struct netif *inp)
 333 {
 334   struct ip6_hdr *ip6hdr;
 335   struct netif *netif;
 336   u8_t nexth;
 337   u16_t hlen; /* the current header length */
 338   u8_t i;
 339 #if IP_ACCEPT_LINK_LAYER_ADDRESSING
 340   int check_ip_src=1;
 341 #endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */
 342
 343   IP6_STATS_INC(ip6.recv);
 344
 345   /* identify the IP header */
 346   ip6hdr = (struct ip6_hdr *)p->payload;
 347   if (IP6H_V(ip6hdr) != 6) {
 348     LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IPv6 packet dropped due to bad version number %"U16_F"\n",
 349         IP6H_V(ip6hdr)));
 350     pbuf_free(p);
 351     IP6_STATS_INC(ip6.err);
 352     IP6_STATS_INC(ip6.drop);
 353     return ERR_OK;
 354   }
 355
 356   /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */
 357   if ((IP6_HLEN > p->len) || ((IP6H_PLEN(ip6hdr) + IP6_HLEN) > p->tot_len)) {
 358     if (IP6_HLEN > p->len) {
 359       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 360         ("IPv6 header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n",
 361             IP6_HLEN, p->len));
 362     }
 363     if ((IP6H_PLEN(ip6hdr) + IP6_HLEN) > p->tot_len) {
 364       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 365         ("IPv6 (plen %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n",
 366             IP6H_PLEN(ip6hdr) + IP6_HLEN, p->tot_len));
 367     }
 368     /* free (drop) packet pbufs */
 369     pbuf_free(p);
 370     IP6_STATS_INC(ip6.lenerr);
 371     IP6_STATS_INC(ip6.drop);
 372     return ERR_OK;
 373   }
 374
 375   /* Trim pbuf. This should have been done at the netif layer,
 376    * but we'll do it anyway just to be sure that its done. */
 377   pbuf_realloc(p, IP6_HLEN + IP6H_PLEN(ip6hdr));
 378
 379   /* copy IP addresses to aligned ip6_addr_t */
 380   ip6_addr_copy(ip_data.current_iphdr_dest.ip6, ip6hdr->dest);
 381   ip6_addr_copy(ip_data.current_iphdr_src.ip6, ip6hdr->src);
 382
 383   /* current header pointer. */
 384   ip_data.current_ip6_header = ip6hdr;
 385
 386   /* match packet against an interface, i.e. is this packet for us? */
 387   if (ip6_addr_ismulticast(ip6_current_dest_addr())) {
 388     /* Always joined to multicast if-local and link-local all-nodes group. */
 389     if (ip6_addr_isallnodes_iflocal(ip6_current_dest_addr()) ||
 390         ip6_addr_isallnodes_linklocal(ip6_current_dest_addr())) {
 391       netif = inp;
 392     }
 393 #if LWIP_IPV6_MLD
 394     else if (mld6_lookfor_group(inp, ip6_current_dest_addr())) {
 395       netif = inp;
 396     }
 397 #else /* LWIP_IPV6_MLD */
 398     else if (ip6_addr_issolicitednode(ip6_current_dest_addr())) {
 399       /* Accept all solicited node packets when MLD is not enabled
 400        * (for Neighbor discovery). */
 401       netif = inp;
 402     }
 403 #endif /* LWIP_IPV6_MLD */
 404     else {
 405       netif = NULL;
 406     }
 407   }
 408   else {
 409     /* start trying with inp. if that's not acceptable, start walking the
 410        list of configured netifs.
 411        'first' is used as a boolean to mark whether we started walking the list */
 412     int first = 1;
 413     netif = inp;
 414     do {
 415       /* interface is up? */
 416       if (netif_is_up(netif)) {
 417         /* unicast to this interface address? address configured? */
 418         for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 419           if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 420               ip6_addr_cmp(ip6_current_dest_addr(), netif_ip6_addr(netif, i))) {
 421             /* exit outer loop */
 422             goto netif_found;
 423           }
 424         }
 425       }
 426       if (first) {
 427         first = 0;
 428         netif = netif_list;
 429       } else {
 430         netif = netif->next;
 431       }
 432       if (netif == inp) {
 433         netif = netif->next;
 434       }
 435     } while(netif != NULL);
 436 netif_found:
 437     LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet accepted on interface %c%c\n",
 438         netif->name[0], netif->name[1]));
 439   }
 440
 441   /* "::" packet source address? (used in duplicate address detection) */
 442   if (ip6_addr_isany(ip6_current_src_addr()) &&
 443       (!ip6_addr_issolicitednode(ip6_current_dest_addr()))) {
 444     /* packet source is not valid */
 445     /* free (drop) packet pbufs */
 446     LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with src ANY_ADDRESS dropped\n"));
 447     pbuf_free(p);
 448     IP6_STATS_INC(ip6.drop);
 449     goto ip6_input_cleanup;
 450   }
 451
 452   /* packet not for us? */
 453   if (netif == NULL) {
 454     /* packet not for us, route or discard */
 455     LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_TRACE, ("ip6_input: packet not for us.\n"));
 456 #if LWIP_IPV6_FORWARD
 457     /* non-multicast packet? */
 458     if (!ip6_addr_ismulticast(ip6_current_dest_addr())) {
 459       /* try to forward IP packet on (other) interfaces */
 460       ip6_forward(p, ip6hdr, inp);
 461     }
 462 #endif /* LWIP_IPV6_FORWARD */
 463     pbuf_free(p);
 464     goto ip6_input_cleanup;
 465   }
 466
 467   /* current netif pointer. */
 468   ip_data.current_netif = inp;
 469
 470   /* Save next header type. */
 471   nexth = IP6H_NEXTH(ip6hdr);
 472
 473   /* Init header length. */
 474   hlen = ip_data.current_ip_header_tot_len = IP6_HLEN;
 475
 476   /* Move to payload. */
 477   pbuf_header(p, -IP6_HLEN);
 478
 479   /* Process known option extension headers, if present. */
 480   while (nexth != IP6_NEXTH_NONE)
 481   {
 482     switch (nexth) {
 483     case IP6_NEXTH_HOPBYHOP:
 484       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Hop-by-Hop options header\n"));
 485       /* Get next header type. */
 486       nexth = *((u8_t *)p->payload);
 487
 488       /* Get the header length. */
 489       hlen = 8 * (1 + *((u8_t *)p->payload) + 1);
 490       ip_data.current_ip_header_tot_len += hlen;
 491
 492       /* Skip over this header. */
 493       if (hlen > p->len) {
 494         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 495           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 496               hlen, p->len));
 497         /* free (drop) packet pbufs */
 498         pbuf_free(p);
 499         IP6_STATS_INC(ip6.lenerr);
 500         IP6_STATS_INC(ip6.drop);
 501         goto ip6_input_cleanup;
 502       }
 503
 504       pbuf_header(p, -hlen);
 505       break;
 506     case IP6_NEXTH_DESTOPTS:
 507       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Destination options header\n"));
 508       /* Get next header type. */
 509       nexth = *((u8_t *)p->payload);
 510
 511       /* Get the header length. */
 512       hlen = 8 * (1 + *((u8_t *)p->payload) + 1);
 513       ip_data.current_ip_header_tot_len += hlen;
 514
 515       /* Skip over this header. */
 516       if (hlen > p->len) {
 517         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 518           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 519               hlen, p->len));
 520         /* free (drop) packet pbufs */
 521         pbuf_free(p);
 522         IP6_STATS_INC(ip6.lenerr);
 523         IP6_STATS_INC(ip6.drop);
 524         goto ip6_input_cleanup;
 525       }
 526
 527       pbuf_header(p, -hlen);
 528       break;
 529     case IP6_NEXTH_ROUTING:
 530       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Routing header\n"));
 531       /* Get next header type. */
 532       nexth = *((u8_t *)p->payload);
 533
 534       /* Get the header length. */
 535       hlen = 8 * (1 + *((u8_t *)p->payload) + 1);
 536       ip_data.current_ip_header_tot_len += hlen;
 537
 538       /* Skip over this header. */
 539       if (hlen > p->len) {
 540         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 541           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 542               hlen, p->len));
 543         /* free (drop) packet pbufs */
 544         pbuf_free(p);
 545         IP6_STATS_INC(ip6.lenerr);
 546         IP6_STATS_INC(ip6.drop);
 547         goto ip6_input_cleanup;
 548       }
 549
 550       pbuf_header(p, -hlen);
 551       break;
 552
 553     case IP6_NEXTH_FRAGMENT:
 554     {
 555       struct ip6_frag_hdr * frag_hdr;
 556       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header\n"));
 557
 558       frag_hdr = (struct ip6_frag_hdr *)p->payload;
 559
 560       /* Get next header type. */
 561       nexth = frag_hdr->_nexth;
 562
 563       /* Fragment Header length. */
 564       hlen = 8;
 565       ip_data.current_ip_header_tot_len += hlen;
 566
 567       /* Make sure this header fits in current pbuf. */
 568       if (hlen > p->len) {
 569         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 570           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 571               hlen, p->len));
 572         /* free (drop) packet pbufs */
 573         pbuf_free(p);
 574         IP6_FRAG_STATS_INC(ip6_frag.lenerr);
 575         IP6_FRAG_STATS_INC(ip6_frag.drop);
 576         goto ip6_input_cleanup;
 577       }
 578
 579       /* Offset == 0 and more_fragments == 0? */
 580       if (((frag_hdr->_fragment_offset & IP6_FRAG_OFFSET_MASK) == 0) &&
 581           ((frag_hdr->_fragment_offset & IP6_FRAG_MORE_FLAG) == 0)) {
 582
 583         /* This is a 1-fragment packet, usually a packet that we have
 584          * already reassembled. Skip this header anc continue. */
 585         pbuf_header(p, -hlen);
 586       }
 587       else {
 588 #if LWIP_IPV6_REASS
 589
 590         /* reassemble the packet */
 591         p = ip6_reass(p);
 592         /* packet not fully reassembled yet? */
 593         if (p == NULL) {
 594           goto ip6_input_cleanup;
 595         }
 596
 597         /* Returned p point to IPv6 header.
 598          * Update all our variables and pointers and continue. */
 599         ip6hdr = (struct ip6_hdr *)p->payload;
 600         nexth = IP6H_NEXTH(ip6hdr);
 601         hlen = ip_data.current_ip_header_tot_len = IP6_HLEN;
 602         pbuf_header(p, -IP6_HLEN);
 603
 604 #else /* LWIP_IPV6_REASS */
 605         /* free (drop) packet pbufs */
 606         LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header dropped (with LWIP_IPV6_REASS==0)\n"));
 607         pbuf_free(p);
 608         IP6_STATS_INC(ip6.opterr);
 609         IP6_STATS_INC(ip6.drop);
 610         goto ip6_input_cleanup;
 611 #endif /* LWIP_IPV6_REASS */
 612       }
 613       break;
 614     }
 615     default:
 616       goto options_done;
 617       break;
 618     }
 619   }
 620 options_done:
 621
 622   /* p points to IPv6 header again. */
 623   pbuf_header(p, ip_data.current_ip_header_tot_len);
 624
 625   /* send to upper layers */
 626   LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: \n"));
 627   ip6_debug_print(p);
 628   LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len));
 629
 630 #if LWIP_RAW
 631   /* raw input did not eat the packet? */
 632   if (raw_input(p, inp) == 0)
 633 #endif /* LWIP_RAW */
 634   {
 635     switch (nexth) {
 636     case IP6_NEXTH_NONE:
 637       pbuf_free(p);
 638       break;
 639 #if LWIP_UDP
 640     case IP6_NEXTH_UDP:
 641 #if LWIP_UDPLITE
 642     case IP6_NEXTH_UDPLITE:
 643 #endif /* LWIP_UDPLITE */
 644       /* Point to payload. */
 645       pbuf_header(p, -ip_data.current_ip_header_tot_len);
 646       udp_input(p, inp);
 647       break;
 648 #endif /* LWIP_UDP */
 649 #if LWIP_TCP
 650     case IP6_NEXTH_TCP:
 651       /* Point to payload. */
 652       pbuf_header(p, -ip_data.current_ip_header_tot_len);
 653       tcp_input(p, inp);
 654       break;
 655 #endif /* LWIP_TCP */
 656 #if LWIP_ICMP6
 657     case IP6_NEXTH_ICMP6:
 658       /* Point to payload. */
 659       pbuf_header(p, -ip_data.current_ip_header_tot_len);
 660       icmp6_input(p, inp);
 661       break;
 662 #endif /* LWIP_ICMP */
 663     default:
 664 #if LWIP_ICMP6
 665       /* send ICMP parameter problem unless it was a multicast or ICMPv6 */
 666       if ((!ip6_addr_ismulticast(ip6_current_dest_addr())) &&
 667           (IP6H_NEXTH(ip6hdr) != IP6_NEXTH_ICMP6)) {
 668         icmp6_param_problem(p, ICMP6_PP_HEADER, ip_data.current_ip_header_tot_len - hlen);
 669       }
 670 #endif /* LWIP_ICMP */
 671       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_input: Unsupported transport protocol %"U16_F"\n", IP6H_NEXTH(ip6hdr)));
 672       pbuf_free(p);
 673       IP6_STATS_INC(ip6.proterr);
 674       IP6_STATS_INC(ip6.drop);
 675       break;
 676     }
 677   }
 678
 679 ip6_input_cleanup:
 680   ip_data.current_netif = NULL;
 681   ip_data.current_ip6_header = NULL;
 682   ip_data.current_ip_header_tot_len = 0;
 683   ip6_addr_set_any(&ip_data.current_iphdr_src.ip6);
 684   ip6_addr_set_any(&ip_data.current_iphdr_dest.ip6);
 685
 686   return ERR_OK;
 687 }
 688
 689
 690 /**
 691  * Sends an IPv6 packet on a network interface. This function constructs
 692  * the IPv6 header. If the source IPv6 address is NULL, the IPv6 "ANY" address is
 693  * used as source (usually during network startup). If the source IPv6 address it
 694  * IP6_ADDR_ANY, the most appropriate IPv6 address of the outgoing network
 695  * interface is filled in as source address. If the destination IPv6 address is
 696  * IP_HDRINCL, p is assumed to already include an IPv6 header and p->payload points
 697  * to it instead of the data.
 698  *
 699  * @param p the packet to send (p->payload points to the data, e.g. next
 700             protocol header; if dest == IP_HDRINCL, p already includes an
 701             IPv6 header and p->payload points to that IPv6 header)
 702  * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an
 703  *         IP address of the netif is selected and used as source address.
 704  *         if src == NULL, IP6_ADDR_ANY is used as source)
 705  * @param dest the destination IPv6 address to send the packet to
 706  * @param hl the Hop Limit value to be set in the IPv6 header
 707  * @param tc the Traffic Class value to be set in the IPv6 header
 708  * @param nexth the Next Header to be set in the IPv6 header
 709  * @param netif the netif on which to send this packet
 710  * @return ERR_OK if the packet was sent OK
 711  *         ERR_BUF if p doesn't have enough space for IPv6/LINK headers
 712  *         returns errors returned by netif->output
 713  */
 714 err_t
 715 ip6_output_if(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest,
 716              u8_t hl, u8_t tc,
 717              u8_t nexth, struct netif *netif)
 718 {
 719   struct ip6_hdr *ip6hdr;
 720   ip6_addr_t dest_addr;
 721
 722   /* pbufs passed to IP must have a ref-count of 1 as their payload pointer
 723      gets altered as the packet is passed down the stack */
 724   LWIP_ASSERT("p->ref == 1", p->ref == 1);
 725
 726   /* Should the IPv6 header be generated or is it already included in p? */
 727   if (dest != IP_HDRINCL) {
 728     /* generate IPv6 header */
 729     if (pbuf_header(p, IP6_HLEN)) {
 730       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: not enough room for IPv6 header in pbuf\n"));
 731       IP6_STATS_INC(ip6.err);
 732       return ERR_BUF;
 733     }
 734
 735     ip6hdr = (struct ip6_hdr *)p->payload;
 736     LWIP_ASSERT("check that first pbuf can hold struct ip6_hdr",
 737                (p->len >= sizeof(struct ip6_hdr)));
 738
 739     IP6H_HOPLIM_SET(ip6hdr, hl);
 740     IP6H_NEXTH_SET(ip6hdr, nexth);
 741
 742     /* dest cannot be NULL here */
 743     ip6_addr_copy(ip6hdr->dest, *dest);
 744
 745     IP6H_VTCFL_SET(ip6hdr, 6, tc, 0);
 746     IP6H_PLEN_SET(ip6hdr, p->tot_len - IP6_HLEN);
 747
 748     if (src == NULL) {
 749       src = IP6_ADDR_ANY;
 750     }
 751     else if (ip6_addr_isany(src)) {
 752       src = ip6_select_source_address(netif, dest);
 753       if ((src == NULL) || ip6_addr_isany(src)) {
 754         /* No appropriate source address was found for this packet. */
 755         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: No suitable source address for packet.\n"));
 756         IP6_STATS_INC(ip6.rterr);
 757         return ERR_RTE;
 758       }
 759     }
 760     /* src cannot be NULL here */
 761     ip6_addr_copy(ip6hdr->src, *src);
 762
 763   } else {
 764     /* IP header already included in p */
 765     ip6hdr = (struct ip6_hdr *)p->payload;
 766     ip6_addr_copy(dest_addr, ip6hdr->dest);
 767     dest = &dest_addr;
 768   }
 769
 770   IP6_STATS_INC(ip6.xmit);
 771
 772   LWIP_DEBUGF(IP6_DEBUG, ("ip6_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], netif->num));
 773   ip6_debug_print(p);
 774
 775 #if ENABLE_LOOPBACK
 776   /* TODO implement loopback for v6
 777   if (ip6_addr_cmp(dest, netif_ip6_addr(0))) {
 778     return netif_loop_output(netif, p, dest);
 779   }*/
 780 #endif /* ENABLE_LOOPBACK */
 781 #if LWIP_IPV6_FRAG
 782   /* don't fragment if interface has mtu set to 0 [loopif] */
 783   if (netif->mtu && (p->tot_len > nd6_get_destination_mtu(dest, netif))) {
 784     return ip6_frag(p, netif, dest);
 785   }
 786 #endif /* LWIP_IPV6_FRAG */
 787
 788   LWIP_DEBUGF(IP6_DEBUG, ("netif->output_ip6()"));
 789   return netif->output_ip6(netif, p, dest);
 790 }
 791
 792 /**
 793  * Simple interface to ip6_output_if. It finds the outgoing network
 794  * interface and calls upon ip6_output_if to do the actual work.
 795  *
 796  * @param p the packet to send (p->payload points to the data, e.g. next
 797             protocol header; if dest == IP_HDRINCL, p already includes an
 798             IPv6 header and p->payload points to that IPv6 header)
 799  * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an
 800  *         IP address of the netif is selected and used as source address.
 801  *         if src == NULL, IP6_ADDR_ANY is used as source)
 802  * @param dest the destination IPv6 address to send the packet to
 803  * @param hl the Hop Limit value to be set in the IPv6 header
 804  * @param tc the Traffic Class value to be set in the IPv6 header
 805  * @param nexth the Next Header to be set in the IPv6 header
 806  *
 807  * @return ERR_RTE if no route is found
 808  *         see ip_output_if() for more return values
 809  */
 810 err_t
 811 ip6_output(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest,
 812           u8_t hl, u8_t tc, u8_t nexth)
 813 {
 814   struct netif *netif;
 815
 816   /* pbufs passed to IPv6 must have a ref-count of 1 as their payload pointer
 817      gets altered as the packet is passed down the stack */
 818   LWIP_ASSERT("p->ref == 1", p->ref == 1);
 819
 820   if ((netif = ip6_route(src, dest)) == NULL) {
 821     LWIP_DEBUGF(IP6_DEBUG, ("ip6_output: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n",
 822         IP6_ADDR_BLOCK1(dest),
 823         IP6_ADDR_BLOCK2(dest),
 824         IP6_ADDR_BLOCK3(dest),
 825         IP6_ADDR_BLOCK4(dest),
 826         IP6_ADDR_BLOCK5(dest),
 827         IP6_ADDR_BLOCK6(dest),
 828         IP6_ADDR_BLOCK7(dest),
 829         IP6_ADDR_BLOCK8(dest)));
 830     IP6_STATS_INC(ip6.rterr);
 831     return ERR_RTE;
 832   }
 833
 834   return ip6_output_if(p, src, dest, hl, tc, nexth, netif);
 835 }
 836
 837
 838 #if LWIP_NETIF_HWADDRHINT
 839 /** Like ip6_output, but takes and addr_hint pointer that is passed on to netif->addr_hint
 840  *  before calling ip6_output_if.
 841  *
 842  * @param p the packet to send (p->payload points to the data, e.g. next
 843             protocol header; if dest == IP_HDRINCL, p already includes an
 844             IPv6 header and p->payload points to that IPv6 header)
 845  * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an
 846  *         IP address of the netif is selected and used as source address.
 847  *         if src == NULL, IP6_ADDR_ANY is used as source)
 848  * @param dest the destination IPv6 address to send the packet to
 849  * @param hl the Hop Limit value to be set in the IPv6 header
 850  * @param tc the Traffic Class value to be set in the IPv6 header
 851  * @param nexth the Next Header to be set in the IPv6 header
 852  * @param addr_hint address hint pointer set to netif->addr_hint before
 853  *        calling ip_output_if()
 854  *
 855  * @return ERR_RTE if no route is found
 856  *         see ip_output_if() for more return values
 857  */
 858 err_t
 859 ip6_output_hinted(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest,
 860           u8_t hl, u8_t tc, u8_t nexth, u8_t *addr_hint)
 861 {
 862   struct netif *netif;
 863   err_t err;
 864
 865   /* pbufs passed to IP must have a ref-count of 1 as their payload pointer
 866      gets altered as the packet is passed down the stack */
 867   LWIP_ASSERT("p->ref == 1", p->ref == 1);
 868
 869   if ((netif = ip6_route(src, dest)) == NULL) {
 870     LWIP_DEBUGF(IP6_DEBUG, ("ip6_output: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n",
 871         IP6_ADDR_BLOCK1(dest),
 872         IP6_ADDR_BLOCK2(dest),
 873         IP6_ADDR_BLOCK3(dest),
 874         IP6_ADDR_BLOCK4(dest),
 875         IP6_ADDR_BLOCK5(dest),
 876         IP6_ADDR_BLOCK6(dest),
 877         IP6_ADDR_BLOCK7(dest),
 878         IP6_ADDR_BLOCK8(dest)));
 879     IP6_STATS_INC(ip6.rterr);
 880     return ERR_RTE;
 881   }
 882
 883   NETIF_SET_HWADDRHINT(netif, addr_hint);
 884   err = ip6_output_if(p, src, dest, hl, tc, nexth, netif);
 885   NETIF_SET_HWADDRHINT(netif, NULL);
 886
 887   return err;
 888 }
 889 #endif /* LWIP_NETIF_HWADDRHINT*/
 890
 891 #if LWIP_IPV6_MLD
 892 /**
 893  * Add a hop-by-hop options header with a router alert option and padding.
 894  *
 895  * Used by MLD when sending a Multicast listener report/done message.
 896  *
 897  * @param p the packet to which we will prepend the options header
 898  * @param nexth the next header protocol number (e.g. IP6_NEXTH_ICMP6)
 899  * @param value the value of the router alert option data (e.g. IP6_ROUTER_ALERT_VALUE_MLD)
 900  * @return ERR_OK if hop-by-hop header was added, ERR_* otherwise
 901  */
 902 err_t
 903 ip6_options_add_hbh_ra(struct pbuf * p, u8_t nexth, u8_t value)
 904 {
 905   struct ip6_hbh_hdr * hbh_hdr;
 906
 907   /* Move pointer to make room for hop-by-hop options header. */
 908   if (pbuf_header(p, sizeof(struct ip6_hbh_hdr))) {
 909     LWIP_DEBUGF(IP6_DEBUG, ("ip6_options: no space for options header\n"));
 910     IP6_STATS_INC(ip6.err);
 911     return ERR_BUF;
 912   }
 913
 914   hbh_hdr = (struct ip6_hbh_hdr *)p->payload;
 915
 916   /* Set fields. */
 917   hbh_hdr->_nexth = nexth;
 918   hbh_hdr->_hlen = 0;
 919   hbh_hdr->_ra_opt_type = IP6_ROUTER_ALERT_OPTION;
 920   hbh_hdr->_ra_opt_dlen = 2;
 921   hbh_hdr->_ra_opt_data = value;
 922   hbh_hdr->_padn_opt_type = IP6_PADN_ALERT_OPTION;
 923   hbh_hdr->_padn_opt_dlen = 0;
 924
 925   return ERR_OK;
 926 }
 927 #endif /* LWIP_IPV6_MLD */
 928
 929 #if IP6_DEBUG
 930 /* Print an IPv6 header by using LWIP_DEBUGF
 931  * @param p an IPv6 packet, p->payload pointing to the IPv6 header
 932  */
 933 void
 934 ip6_debug_print(struct pbuf *p)
 935 {
 936   struct ip6_hdr *ip6hdr = (struct ip6_hdr *)p->payload;
 937
 938   LWIP_DEBUGF(IP6_DEBUG, ("IPv6 header:\n"));
 939   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 940   LWIP_DEBUGF(IP6_DEBUG, ("| %2"U16_F" |  %3"U16_F"  |      %7"U32_F"     | (ver, class, flow)\n",
 941                     IP6H_V(ip6hdr),
 942                     IP6H_TC(ip6hdr),
 943                     IP6H_FL(ip6hdr)));
 944   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 945   LWIP_DEBUGF(IP6_DEBUG, ("|     %5"U16_F"     |  %3"U16_F"  |  %3"U16_F"  | (plen, nexth, hopl)\n",
 946                     ntohs(IP6H_PLEN(ip6hdr)),
 947                     ntohs(IP6H_NEXTH(ip6hdr)),
 948                     ntohs(IP6H_HOPLIM(ip6hdr))));
 949   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 950   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" | (src)\n",
 951                     IP6_ADDR_BLOCK1(&(ip6hdr->src)),
 952                     IP6_ADDR_BLOCK2(&(ip6hdr->src)),
 953                     IP6_ADDR_BLOCK3(&(ip6hdr->src)),
 954                     IP6_ADDR_BLOCK4(&(ip6hdr->src))));
 955   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |\n",
 956                     IP6_ADDR_BLOCK5(&(ip6hdr->src)),
 957                     IP6_ADDR_BLOCK6(&(ip6hdr->src)),
 958                     IP6_ADDR_BLOCK7(&(ip6hdr->src)),
 959                     IP6_ADDR_BLOCK8(&(ip6hdr->src))));
 960   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 961   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" | (dest)\n",
 962                     IP6_ADDR_BLOCK1(&(ip6hdr->dest)),
 963                     IP6_ADDR_BLOCK2(&(ip6hdr->dest)),
 964                     IP6_ADDR_BLOCK3(&(ip6hdr->dest)),
 965                     IP6_ADDR_BLOCK4(&(ip6hdr->dest))));
 966   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |\n",
 967                     IP6_ADDR_BLOCK5(&(ip6hdr->dest)),
 968                     IP6_ADDR_BLOCK6(&(ip6hdr->dest)),
 969                     IP6_ADDR_BLOCK7(&(ip6hdr->dest)),
 970                     IP6_ADDR_BLOCK8(&(ip6hdr->dest))));
 971   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 972 }
 973 #endif /* IP6_DEBUG */
 974
 975 #endif /* LWIP_IPV6 */