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   if (netif->mtu && (p->tot_len > netif->mtu)) {
 299 #if LWIP_ICMP6
 300     /* Don't send ICMP messages in response to ICMP messages */
 301     if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) {
 302       icmp6_packet_too_big(p, netif->mtu);
 303     }
 304 #endif /* LWIP_ICMP6 */
 305     IP6_STATS_INC(ip6.drop);
 306     return;
 307   }
 308
 309   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",
 310       IP6_ADDR_BLOCK1(ip6_current_dest_addr()),
 311       IP6_ADDR_BLOCK2(ip6_current_dest_addr()),
 312       IP6_ADDR_BLOCK3(ip6_current_dest_addr()),
 313       IP6_ADDR_BLOCK4(ip6_current_dest_addr()),
 314       IP6_ADDR_BLOCK5(ip6_current_dest_addr()),
 315       IP6_ADDR_BLOCK6(ip6_current_dest_addr()),
 316       IP6_ADDR_BLOCK7(ip6_current_dest_addr()),
 317       IP6_ADDR_BLOCK8(ip6_current_dest_addr())));
 318
 319   /* transmit pbuf on chosen interface */
 320   netif->output_ip6(netif, p, ip6_current_dest_addr());
 321   IP6_STATS_INC(ip6.fw);
 322   IP6_STATS_INC(ip6.xmit);
 323   return;
 324 }
 325 #endif /* LWIP_IPV6_FORWARD */
 326
 327
 328 /**
 329  * This function is called by the network interface device driver when
 330  * an IPv6 packet is received. The function does the basic checks of the
 331  * IP header such as packet size being at least larger than the header
 332  * size etc. If the packet was not destined for us, the packet is
 333  * forwarded (using ip6_forward).
 334  *
 335  * Finally, the packet is sent to the upper layer protocol input function.
 336  *
 337  * @param p the received IPv6 packet (p->payload points to IPv6 header)
 338  * @param inp the netif on which this packet was received
 339  * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't
 340  *         processed, but currently always returns ERR_OK)
 341  */
 342 err_t
 343 ip6_input(struct pbuf *p, struct netif *inp)
 344 {
 345   struct ip6_hdr *ip6hdr;
 346   struct netif *netif;
 347   u8_t nexth;
 348   u16_t hlen; /* the current header length */
 349   u8_t i;
 350 #if 0 /*IP_ACCEPT_LINK_LAYER_ADDRESSING*/
 351   @todo
 352   int check_ip_src=1;
 353 #endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */
 354
 355   IP6_STATS_INC(ip6.recv);
 356
 357   /* identify the IP header */
 358   ip6hdr = (struct ip6_hdr *)p->payload;
 359   if (IP6H_V(ip6hdr) != 6) {
 360     LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IPv6 packet dropped due to bad version number %"U16_F"\n",
 361         IP6H_V(ip6hdr)));
 362     pbuf_free(p);
 363     IP6_STATS_INC(ip6.err);
 364     IP6_STATS_INC(ip6.drop);
 365     return ERR_OK;
 366   }
 367
 368   /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */
 369   if ((IP6_HLEN > p->len) || ((IP6H_PLEN(ip6hdr) + IP6_HLEN) > p->tot_len)) {
 370     if (IP6_HLEN > p->len) {
 371       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 372         ("IPv6 header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n",
 373             IP6_HLEN, p->len));
 374     }
 375     if ((IP6H_PLEN(ip6hdr) + IP6_HLEN) > p->tot_len) {
 376       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 377         ("IPv6 (plen %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n",
 378             IP6H_PLEN(ip6hdr) + IP6_HLEN, p->tot_len));
 379     }
 380     /* free (drop) packet pbufs */
 381     pbuf_free(p);
 382     IP6_STATS_INC(ip6.lenerr);
 383     IP6_STATS_INC(ip6.drop);
 384     return ERR_OK;
 385   }
 386
 387   /* Trim pbuf. This should have been done at the netif layer,
 388    * but we'll do it anyway just to be sure that its done. */
 389   pbuf_realloc(p, IP6_HLEN + IP6H_PLEN(ip6hdr));
 390
 391   /* copy IP addresses to aligned ip6_addr_t */
 392   ip6_addr_copy(ip_data.current_iphdr_dest.ip6, ip6hdr->dest);
 393   ip6_addr_copy(ip_data.current_iphdr_src.ip6, ip6hdr->src);
 394
 395   /* current header pointer. */
 396   ip_data.current_ip6_header = ip6hdr;
 397
 398   /* match packet against an interface, i.e. is this packet for us? */
 399   if (ip6_addr_ismulticast(ip6_current_dest_addr())) {
 400     /* Always joined to multicast if-local and link-local all-nodes group. */
 401     if (ip6_addr_isallnodes_iflocal(ip6_current_dest_addr()) ||
 402         ip6_addr_isallnodes_linklocal(ip6_current_dest_addr())) {
 403       netif = inp;
 404     }
 405 #if LWIP_IPV6_MLD
 406     else if (mld6_lookfor_group(inp, ip6_current_dest_addr())) {
 407       netif = inp;
 408     }
 409 #else /* LWIP_IPV6_MLD */
 410     else if (ip6_addr_issolicitednode(ip6_current_dest_addr())) {
 411       /* Accept all solicited node packets when MLD is not enabled
 412        * (for Neighbor discovery). */
 413       netif = inp;
 414     }
 415 #endif /* LWIP_IPV6_MLD */
 416     else {
 417       netif = NULL;
 418     }
 419   }
 420   else {
 421     /* start trying with inp. if that's not acceptable, start walking the
 422        list of configured netifs.
 423        'first' is used as a boolean to mark whether we started walking the list */
 424     int first = 1;
 425     netif = inp;
 426     do {
 427       /* interface is up? */
 428       if (netif_is_up(netif)) {
 429         /* unicast to this interface address? address configured? */
 430         for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
 431           if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) &&
 432               ip6_addr_cmp(ip6_current_dest_addr(), netif_ip6_addr(netif, i))) {
 433             /* exit outer loop */
 434             goto netif_found;
 435           }
 436         }
 437       }
 438       if (first) {
 439         first = 0;
 440         netif = netif_list;
 441       } else {
 442         netif = netif->next;
 443       }
 444       if (netif == inp) {
 445         netif = netif->next;
 446       }
 447     } while(netif != NULL);
 448 netif_found:
 449     LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet accepted on interface %c%c\n",
 450         netif->name[0], netif->name[1]));
 451   }
 452
 453   /* "::" packet source address? (used in duplicate address detection) */
 454   if (ip6_addr_isany(ip6_current_src_addr()) &&
 455       (!ip6_addr_issolicitednode(ip6_current_dest_addr()))) {
 456     /* packet source is not valid */
 457     /* free (drop) packet pbufs */
 458     LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with src ANY_ADDRESS dropped\n"));
 459     pbuf_free(p);
 460     IP6_STATS_INC(ip6.drop);
 461     goto ip6_input_cleanup;
 462   }
 463
 464   /* packet not for us? */
 465   if (netif == NULL) {
 466     /* packet not for us, route or discard */
 467     LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_TRACE, ("ip6_input: packet not for us.\n"));
 468 #if LWIP_IPV6_FORWARD
 469     /* non-multicast packet? */
 470     if (!ip6_addr_ismulticast(ip6_current_dest_addr())) {
 471       /* try to forward IP packet on (other) interfaces */
 472       ip6_forward(p, ip6hdr, inp);
 473     }
 474 #endif /* LWIP_IPV6_FORWARD */
 475     pbuf_free(p);
 476     goto ip6_input_cleanup;
 477   }
 478
 479   /* current netif pointer. */
 480   ip_data.current_netif = inp;
 481
 482   /* Save next header type. */
 483   nexth = IP6H_NEXTH(ip6hdr);
 484
 485   /* Init header length. */
 486   hlen = ip_data.current_ip_header_tot_len = IP6_HLEN;
 487
 488   /* Move to payload. */
 489   pbuf_header(p, -IP6_HLEN);
 490
 491   /* Process known option extension headers, if present. */
 492   while (nexth != IP6_NEXTH_NONE)
 493   {
 494     switch (nexth) {
 495     case IP6_NEXTH_HOPBYHOP:
 496       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Hop-by-Hop options header\n"));
 497       /* Get next header type. */
 498       nexth = *((u8_t *)p->payload);
 499
 500       /* Get the header length. */
 501       hlen = 8 * (1 + *((u8_t *)p->payload) + 1);
 502       ip_data.current_ip_header_tot_len += hlen;
 503
 504       /* Skip over this header. */
 505       if (hlen > p->len) {
 506         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 507           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 508               hlen, p->len));
 509         /* free (drop) packet pbufs */
 510         pbuf_free(p);
 511         IP6_STATS_INC(ip6.lenerr);
 512         IP6_STATS_INC(ip6.drop);
 513         goto ip6_input_cleanup;
 514       }
 515
 516       pbuf_header(p, -hlen);
 517       break;
 518     case IP6_NEXTH_DESTOPTS:
 519       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Destination options header\n"));
 520       /* Get next header type. */
 521       nexth = *((u8_t *)p->payload);
 522
 523       /* Get the header length. */
 524       hlen = 8 * (1 + *((u8_t *)p->payload) + 1);
 525       ip_data.current_ip_header_tot_len += hlen;
 526
 527       /* Skip over this header. */
 528       if (hlen > p->len) {
 529         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 530           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 531               hlen, p->len));
 532         /* free (drop) packet pbufs */
 533         pbuf_free(p);
 534         IP6_STATS_INC(ip6.lenerr);
 535         IP6_STATS_INC(ip6.drop);
 536         goto ip6_input_cleanup;
 537       }
 538
 539       pbuf_header(p, -hlen);
 540       break;
 541     case IP6_NEXTH_ROUTING:
 542       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Routing header\n"));
 543       /* Get next header type. */
 544       nexth = *((u8_t *)p->payload);
 545
 546       /* Get the header length. */
 547       hlen = 8 * (1 + *((u8_t *)p->payload) + 1);
 548       ip_data.current_ip_header_tot_len += hlen;
 549
 550       /* Skip over this header. */
 551       if (hlen > p->len) {
 552         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 553           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 554               hlen, p->len));
 555         /* free (drop) packet pbufs */
 556         pbuf_free(p);
 557         IP6_STATS_INC(ip6.lenerr);
 558         IP6_STATS_INC(ip6.drop);
 559         goto ip6_input_cleanup;
 560       }
 561
 562       pbuf_header(p, -hlen);
 563       break;
 564
 565     case IP6_NEXTH_FRAGMENT:
 566     {
 567       struct ip6_frag_hdr * frag_hdr;
 568       LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header\n"));
 569
 570       frag_hdr = (struct ip6_frag_hdr *)p->payload;
 571
 572       /* Get next header type. */
 573       nexth = frag_hdr->_nexth;
 574
 575       /* Fragment Header length. */
 576       hlen = 8;
 577       ip_data.current_ip_header_tot_len += hlen;
 578
 579       /* Make sure this header fits in current pbuf. */
 580       if (hlen > p->len) {
 581         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
 582           ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n",
 583               hlen, p->len));
 584         /* free (drop) packet pbufs */
 585         pbuf_free(p);
 586         IP6_FRAG_STATS_INC(ip6_frag.lenerr);
 587         IP6_FRAG_STATS_INC(ip6_frag.drop);
 588         goto ip6_input_cleanup;
 589       }
 590
 591       /* Offset == 0 and more_fragments == 0? */
 592       if (((frag_hdr->_fragment_offset & IP6_FRAG_OFFSET_MASK) == 0) &&
 593           ((frag_hdr->_fragment_offset & IP6_FRAG_MORE_FLAG) == 0)) {
 594
 595         /* This is a 1-fragment packet, usually a packet that we have
 596          * already reassembled. Skip this header anc continue. */
 597         pbuf_header(p, -hlen);
 598       }
 599       else {
 600 #if LWIP_IPV6_REASS
 601
 602         /* reassemble the packet */
 603         p = ip6_reass(p);
 604         /* packet not fully reassembled yet? */
 605         if (p == NULL) {
 606           goto ip6_input_cleanup;
 607         }
 608
 609         /* Returned p point to IPv6 header.
 610          * Update all our variables and pointers and continue. */
 611         ip6hdr = (struct ip6_hdr *)p->payload;
 612         nexth = IP6H_NEXTH(ip6hdr);
 613         hlen = ip_data.current_ip_header_tot_len = IP6_HLEN;
 614         pbuf_header(p, -IP6_HLEN);
 615
 616 #else /* LWIP_IPV6_REASS */
 617         /* free (drop) packet pbufs */
 618         LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header dropped (with LWIP_IPV6_REASS==0)\n"));
 619         pbuf_free(p);
 620         IP6_STATS_INC(ip6.opterr);
 621         IP6_STATS_INC(ip6.drop);
 622         goto ip6_input_cleanup;
 623 #endif /* LWIP_IPV6_REASS */
 624       }
 625       break;
 626     }
 627     default:
 628       goto options_done;
 629       break;
 630     }
 631   }
 632 options_done:
 633
 634   /* p points to IPv6 header again. */
 635   pbuf_header(p, ip_data.current_ip_header_tot_len);
 636
 637   /* send to upper layers */
 638   LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: \n"));
 639   ip6_debug_print(p);
 640   LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len));
 641
 642 #if LWIP_RAW
 643   /* raw input did not eat the packet? */
 644   if (raw_input(p, inp) == 0)
 645 #endif /* LWIP_RAW */
 646   {
 647     switch (nexth) {
 648     case IP6_NEXTH_NONE:
 649       pbuf_free(p);
 650       break;
 651 #if LWIP_UDP
 652     case IP6_NEXTH_UDP:
 653 #if LWIP_UDPLITE
 654     case IP6_NEXTH_UDPLITE:
 655 #endif /* LWIP_UDPLITE */
 656       /* Point to payload. */
 657       pbuf_header(p, -ip_data.current_ip_header_tot_len);
 658       udp_input(p, inp);
 659       break;
 660 #endif /* LWIP_UDP */
 661 #if LWIP_TCP
 662     case IP6_NEXTH_TCP:
 663       /* Point to payload. */
 664       pbuf_header(p, -ip_data.current_ip_header_tot_len);
 665       tcp_input(p, inp);
 666       break;
 667 #endif /* LWIP_TCP */
 668 #if LWIP_ICMP6
 669     case IP6_NEXTH_ICMP6:
 670       /* Point to payload. */
 671       pbuf_header(p, -ip_data.current_ip_header_tot_len);
 672       icmp6_input(p, inp);
 673       break;
 674 #endif /* LWIP_ICMP */
 675     default:
 676 #if LWIP_ICMP6
 677       /* send ICMP parameter problem unless it was a multicast or ICMPv6 */
 678       if ((!ip6_addr_ismulticast(ip6_current_dest_addr())) &&
 679           (IP6H_NEXTH(ip6hdr) != IP6_NEXTH_ICMP6)) {
 680         icmp6_param_problem(p, ICMP6_PP_HEADER, ip_data.current_ip_header_tot_len - hlen);
 681       }
 682 #endif /* LWIP_ICMP */
 683       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_input: Unsupported transport protocol %"U16_F"\n", IP6H_NEXTH(ip6hdr)));
 684       pbuf_free(p);
 685       IP6_STATS_INC(ip6.proterr);
 686       IP6_STATS_INC(ip6.drop);
 687       break;
 688     }
 689   }
 690
 691 ip6_input_cleanup:
 692   ip_data.current_netif = NULL;
 693   ip_data.current_ip6_header = NULL;
 694   ip_data.current_ip_header_tot_len = 0;
 695   ip6_addr_set_any(&ip_data.current_iphdr_src.ip6);
 696   ip6_addr_set_any(&ip_data.current_iphdr_dest.ip6);
 697
 698   return ERR_OK;
 699 }
 700
 701
 702 /**
 703  * Sends an IPv6 packet on a network interface. This function constructs
 704  * the IPv6 header. If the source IPv6 address is NULL, the IPv6 "ANY" address is
 705  * used as source (usually during network startup). If the source IPv6 address it
 706  * IP6_ADDR_ANY, the most appropriate IPv6 address of the outgoing network
 707  * interface is filled in as source address. If the destination IPv6 address is
 708  * IP_HDRINCL, p is assumed to already include an IPv6 header and p->payload points
 709  * to it instead of the data.
 710  *
 711  * @param p the packet to send (p->payload points to the data, e.g. next
 712             protocol header; if dest == IP_HDRINCL, p already includes an
 713             IPv6 header and p->payload points to that IPv6 header)
 714  * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an
 715  *         IP address of the netif is selected and used as source address.
 716  *         if src == NULL, IP6_ADDR_ANY is used as source)
 717  * @param dest the destination IPv6 address to send the packet to
 718  * @param hl the Hop Limit value to be set in the IPv6 header
 719  * @param tc the Traffic Class value to be set in the IPv6 header
 720  * @param nexth the Next Header to be set in the IPv6 header
 721  * @param netif the netif on which to send this packet
 722  * @return ERR_OK if the packet was sent OK
 723  *         ERR_BUF if p doesn't have enough space for IPv6/LINK headers
 724  *         returns errors returned by netif->output
 725  */
 726 err_t
 727 ip6_output_if(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest,
 728              u8_t hl, u8_t tc,
 729              u8_t nexth, struct netif *netif)
 730 {
 731   struct ip6_hdr *ip6hdr;
 732   ip6_addr_t dest_addr;
 733
 734   /* pbufs passed to IP must have a ref-count of 1 as their payload pointer
 735      gets altered as the packet is passed down the stack */
 736   LWIP_ASSERT("p->ref == 1", p->ref == 1);
 737
 738   /* Should the IPv6 header be generated or is it already included in p? */
 739   if (dest != IP_HDRINCL) {
 740     /* generate IPv6 header */
 741     if (pbuf_header(p, IP6_HLEN)) {
 742       LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: not enough room for IPv6 header in pbuf\n"));
 743       IP6_STATS_INC(ip6.err);
 744       return ERR_BUF;
 745     }
 746
 747     ip6hdr = (struct ip6_hdr *)p->payload;
 748     LWIP_ASSERT("check that first pbuf can hold struct ip6_hdr",
 749                (p->len >= sizeof(struct ip6_hdr)));
 750
 751     IP6H_HOPLIM_SET(ip6hdr, hl);
 752     IP6H_NEXTH_SET(ip6hdr, nexth);
 753
 754     /* dest cannot be NULL here */
 755     ip6_addr_copy(ip6hdr->dest, *dest);
 756
 757     IP6H_VTCFL_SET(ip6hdr, 6, tc, 0);
 758     IP6H_PLEN_SET(ip6hdr, p->tot_len - IP6_HLEN);
 759
 760     if (src == NULL) {
 761       src = IP6_ADDR_ANY;
 762     }
 763     else if (ip6_addr_isany(src)) {
 764       src = ip6_select_source_address(netif, dest);
 765       if ((src == NULL) || ip6_addr_isany(src)) {
 766         /* No appropriate source address was found for this packet. */
 767         LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: No suitable source address for packet.\n"));
 768         IP6_STATS_INC(ip6.rterr);
 769         return ERR_RTE;
 770       }
 771     }
 772     /* src cannot be NULL here */
 773     ip6_addr_copy(ip6hdr->src, *src);
 774
 775   } else {
 776     /* IP header already included in p */
 777     ip6hdr = (struct ip6_hdr *)p->payload;
 778     ip6_addr_copy(dest_addr, ip6hdr->dest);
 779     dest = &dest_addr;
 780   }
 781
 782   IP6_STATS_INC(ip6.xmit);
 783
 784   LWIP_DEBUGF(IP6_DEBUG, ("ip6_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], netif->num));
 785   ip6_debug_print(p);
 786
 787 #if ENABLE_LOOPBACK
 788   /* TODO implement loopback for v6
 789   if (ip6_addr_cmp(dest, netif_ip6_addr(0))) {
 790     return netif_loop_output(netif, p, dest);
 791   }*/
 792 #endif /* ENABLE_LOOPBACK */
 793 #if LWIP_IPV6_FRAG
 794   /* don't fragment if interface has mtu set to 0 [loopif] */
 795   if (netif->mtu && (p->tot_len > nd6_get_destination_mtu(dest, netif))) {
 796     return ip6_frag(p, netif, dest);
 797   }
 798 #endif /* LWIP_IPV6_FRAG */
 799
 800   LWIP_DEBUGF(IP6_DEBUG, ("netif->output_ip6()"));
 801   return netif->output_ip6(netif, p, dest);
 802 }
 803
 804 /**
 805  * Simple interface to ip6_output_if. It finds the outgoing network
 806  * interface and calls upon ip6_output_if to do the actual work.
 807  *
 808  * @param p the packet to send (p->payload points to the data, e.g. next
 809             protocol header; if dest == IP_HDRINCL, p already includes an
 810             IPv6 header and p->payload points to that IPv6 header)
 811  * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an
 812  *         IP address of the netif is selected and used as source address.
 813  *         if src == NULL, IP6_ADDR_ANY is used as source)
 814  * @param dest the destination IPv6 address to send the packet to
 815  * @param hl the Hop Limit value to be set in the IPv6 header
 816  * @param tc the Traffic Class value to be set in the IPv6 header
 817  * @param nexth the Next Header to be set in the IPv6 header
 818  *
 819  * @return ERR_RTE if no route is found
 820  *         see ip_output_if() for more return values
 821  */
 822 err_t
 823 ip6_output(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest,
 824           u8_t hl, u8_t tc, u8_t nexth)
 825 {
 826   struct netif *netif;
 827
 828   /* pbufs passed to IPv6 must have a ref-count of 1 as their payload pointer
 829      gets altered as the packet is passed down the stack */
 830   LWIP_ASSERT("p->ref == 1", p->ref == 1);
 831
 832   if ((netif = ip6_route(src, dest)) == NULL) {
 833     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",
 834         IP6_ADDR_BLOCK1(dest),
 835         IP6_ADDR_BLOCK2(dest),
 836         IP6_ADDR_BLOCK3(dest),
 837         IP6_ADDR_BLOCK4(dest),
 838         IP6_ADDR_BLOCK5(dest),
 839         IP6_ADDR_BLOCK6(dest),
 840         IP6_ADDR_BLOCK7(dest),
 841         IP6_ADDR_BLOCK8(dest)));
 842     IP6_STATS_INC(ip6.rterr);
 843     return ERR_RTE;
 844   }
 845
 846   return ip6_output_if(p, src, dest, hl, tc, nexth, netif);
 847 }
 848
 849
 850 #if LWIP_NETIF_HWADDRHINT
 851 /** Like ip6_output, but takes and addr_hint pointer that is passed on to netif->addr_hint
 852  *  before calling ip6_output_if.
 853  *
 854  * @param p the packet to send (p->payload points to the data, e.g. next
 855             protocol header; if dest == IP_HDRINCL, p already includes an
 856             IPv6 header and p->payload points to that IPv6 header)
 857  * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an
 858  *         IP address of the netif is selected and used as source address.
 859  *         if src == NULL, IP6_ADDR_ANY is used as source)
 860  * @param dest the destination IPv6 address to send the packet to
 861  * @param hl the Hop Limit value to be set in the IPv6 header
 862  * @param tc the Traffic Class value to be set in the IPv6 header
 863  * @param nexth the Next Header to be set in the IPv6 header
 864  * @param addr_hint address hint pointer set to netif->addr_hint before
 865  *        calling ip_output_if()
 866  *
 867  * @return ERR_RTE if no route is found
 868  *         see ip_output_if() for more return values
 869  */
 870 err_t
 871 ip6_output_hinted(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest,
 872           u8_t hl, u8_t tc, u8_t nexth, u8_t *addr_hint)
 873 {
 874   struct netif *netif;
 875   err_t err;
 876
 877   /* pbufs passed to IP must have a ref-count of 1 as their payload pointer
 878      gets altered as the packet is passed down the stack */
 879   LWIP_ASSERT("p->ref == 1", p->ref == 1);
 880
 881   if ((netif = ip6_route(src, dest)) == NULL) {
 882     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",
 883         IP6_ADDR_BLOCK1(dest),
 884         IP6_ADDR_BLOCK2(dest),
 885         IP6_ADDR_BLOCK3(dest),
 886         IP6_ADDR_BLOCK4(dest),
 887         IP6_ADDR_BLOCK5(dest),
 888         IP6_ADDR_BLOCK6(dest),
 889         IP6_ADDR_BLOCK7(dest),
 890         IP6_ADDR_BLOCK8(dest)));
 891     IP6_STATS_INC(ip6.rterr);
 892     return ERR_RTE;
 893   }
 894
 895   NETIF_SET_HWADDRHINT(netif, addr_hint);
 896   err = ip6_output_if(p, src, dest, hl, tc, nexth, netif);
 897   NETIF_SET_HWADDRHINT(netif, NULL);
 898
 899   return err;
 900 }
 901 #endif /* LWIP_NETIF_HWADDRHINT*/
 902
 903 #if LWIP_IPV6_MLD
 904 /**
 905  * Add a hop-by-hop options header with a router alert option and padding.
 906  *
 907  * Used by MLD when sending a Multicast listener report/done message.
 908  *
 909  * @param p the packet to which we will prepend the options header
 910  * @param nexth the next header protocol number (e.g. IP6_NEXTH_ICMP6)
 911  * @param value the value of the router alert option data (e.g. IP6_ROUTER_ALERT_VALUE_MLD)
 912  * @return ERR_OK if hop-by-hop header was added, ERR_* otherwise
 913  */
 914 err_t
 915 ip6_options_add_hbh_ra(struct pbuf * p, u8_t nexth, u8_t value)
 916 {
 917   struct ip6_hbh_hdr * hbh_hdr;
 918
 919   /* Move pointer to make room for hop-by-hop options header. */
 920   if (pbuf_header(p, sizeof(struct ip6_hbh_hdr))) {
 921     LWIP_DEBUGF(IP6_DEBUG, ("ip6_options: no space for options header\n"));
 922     IP6_STATS_INC(ip6.err);
 923     return ERR_BUF;
 924   }
 925
 926   hbh_hdr = (struct ip6_hbh_hdr *)p->payload;
 927
 928   /* Set fields. */
 929   hbh_hdr->_nexth = nexth;
 930   hbh_hdr->_hlen = 0;
 931   hbh_hdr->_ra_opt_type = IP6_ROUTER_ALERT_OPTION;
 932   hbh_hdr->_ra_opt_dlen = 2;
 933   hbh_hdr->_ra_opt_data = value;
 934   hbh_hdr->_padn_opt_type = IP6_PADN_ALERT_OPTION;
 935   hbh_hdr->_padn_opt_dlen = 0;
 936
 937   return ERR_OK;
 938 }
 939 #endif /* LWIP_IPV6_MLD */
 940
 941 #if IP6_DEBUG
 942 /* Print an IPv6 header by using LWIP_DEBUGF
 943  * @param p an IPv6 packet, p->payload pointing to the IPv6 header
 944  */
 945 void
 946 ip6_debug_print(struct pbuf *p)
 947 {
 948   struct ip6_hdr *ip6hdr = (struct ip6_hdr *)p->payload;
 949
 950   LWIP_DEBUGF(IP6_DEBUG, ("IPv6 header:\n"));
 951   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 952   LWIP_DEBUGF(IP6_DEBUG, ("| %2"U16_F" |  %3"U16_F"  |      %7"U32_F"     | (ver, class, flow)\n",
 953                     IP6H_V(ip6hdr),
 954                     IP6H_TC(ip6hdr),
 955                     IP6H_FL(ip6hdr)));
 956   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 957   LWIP_DEBUGF(IP6_DEBUG, ("|     %5"U16_F"     |  %3"U16_F"  |  %3"U16_F"  | (plen, nexth, hopl)\n",
 958                     ntohs(IP6H_PLEN(ip6hdr)),
 959                     ntohs(IP6H_NEXTH(ip6hdr)),
 960                     ntohs(IP6H_HOPLIM(ip6hdr))));
 961   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 962   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" | (src)\n",
 963                     IP6_ADDR_BLOCK1(&(ip6hdr->src)),
 964                     IP6_ADDR_BLOCK2(&(ip6hdr->src)),
 965                     IP6_ADDR_BLOCK3(&(ip6hdr->src)),
 966                     IP6_ADDR_BLOCK4(&(ip6hdr->src))));
 967   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |\n",
 968                     IP6_ADDR_BLOCK5(&(ip6hdr->src)),
 969                     IP6_ADDR_BLOCK6(&(ip6hdr->src)),
 970                     IP6_ADDR_BLOCK7(&(ip6hdr->src)),
 971                     IP6_ADDR_BLOCK8(&(ip6hdr->src))));
 972   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 973   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" | (dest)\n",
 974                     IP6_ADDR_BLOCK1(&(ip6hdr->dest)),
 975                     IP6_ADDR_BLOCK2(&(ip6hdr->dest)),
 976                     IP6_ADDR_BLOCK3(&(ip6hdr->dest)),
 977                     IP6_ADDR_BLOCK4(&(ip6hdr->dest))));
 978   LWIP_DEBUGF(IP6_DEBUG, ("|  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |  %4"X32_F" |\n",
 979                     IP6_ADDR_BLOCK5(&(ip6hdr->dest)),
 980                     IP6_ADDR_BLOCK6(&(ip6hdr->dest)),
 981                     IP6_ADDR_BLOCK7(&(ip6hdr->dest)),
 982                     IP6_ADDR_BLOCK8(&(ip6hdr->dest))));
 983   LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n"));
 984 }
 985 #endif /* IP6_DEBUG */
 986
 987 #endif /* LWIP_IPV6 */