ndp.c

00001 /**
00002  * @file ndp.c
00003  * @brief NDP (Neighbor Discovery Protocol)
00004  *
00005  * @section License
00006  *
00007  * Copyright (C) 2010-2017 Oryx Embedded SARL. All rights reserved.
00008  *
00009  * This file is part of CycloneTCP Open.
00010  *
00011  * This program is free software; you can redistribute it and/or
00012  * modify it under the terms of the GNU General Public License
00013  * as published by the Free Software Foundation; either version 2
00014  * of the License, or (at your option) any later version.
00015  *
00016  * This program is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  * GNU General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU General Public License
00022  * along with this program; if not, write to the Free Software Foundation,
00023  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00024  *
00025  * @section Description
00026  *
00027  * The Neighbor Discovery Protocol is responsible for address autoconfiguration
00028  * of nodes, discovery of the link-layer addresses of other nodes, duplicate
00029  * address detection, finding available routers and address prefix discovery.
00030  * Refer to RFC 4861 for more details
00031  *
00032  * @author Oryx Embedded SARL (www.oryx-embedded.com)
00033  * @version 1.7.6
00034  **/
00035 
00036 //Switch to the appropriate trace level
00037 #define TRACE_LEVEL NDP_TRACE_LEVEL
00038 
00039 //Dependencies
00040 #include <limits.h>
00041 #include <string.h>
00042 #include "core/net.h"
00043 #include "ipv6/ipv6.h"
00044 #include "ipv6/ipv6_misc.h"
00045 #include "ipv6/icmpv6.h"
00046 #include "ipv6/ndp.h"
00047 #include "ipv6/ndp_cache.h"
00048 #include "ipv6/ndp_misc.h"
00049 #include "ipv6/slaac.h"
00050 #include "debug.h"
00051 
00052 //Check TCP/IP stack configuration
00053 #if (IPV6_SUPPORT == ENABLED && NDP_SUPPORT == ENABLED)
00054 
00055 //Tick counter to handle periodic operations
00056 systime_t ndpTickCounter;
00057 
00058 
00059 /**
00060  * @brief Neighbor cache initialization
00061  * @param[in] interface Underlying network interface
00062  * @return Error code
00063  **/
00064 
00065 error_t ndpInit(NetInterface *interface)
00066 {
00067    NdpContext *context;
00068 
00069    //Point to the NDP context
00070    context = &interface->ndpContext;
00071 
00072    //Clear the NDP context
00073    memset(context, 0, sizeof(NdpContext));
00074 
00075    //Initialize interface specific variables
00076    context->reachableTime = NDP_REACHABLE_TIME;
00077    context->retransTimer = NDP_RETRANS_TIMER;
00078    context->dupAddrDetectTransmits = NDP_DUP_ADDR_DETECT_TRANSMITS;
00079    context->minRtrSolicitationDelay = NDP_MIN_RTR_SOLICITATION_DELAY;
00080    context->maxRtrSolicitationDelay = NDP_MAX_RTR_SOLICITATION_DELAY;
00081    context->rtrSolicitationInterval = NDP_RTR_SOLICITATION_INTERVAL;
00082    context->maxRtrSolicitations = NDP_MAX_RTR_SOLICITATIONS;
00083 
00084    //Successful initialization
00085    return NO_ERROR;
00086 }
00087 
00088 
00089 /**
00090  * @brief Address resolution using Neighbor Discovery protocol
00091  * @param[in] interface Underlying network interface
00092  * @param[in] ipAddr IPv6 address
00093  * @param[in] macAddr Physical address matching the specified IPv6 address
00094  * @return Error code
00095  **/
00096 
00097 error_t ndpResolve(NetInterface *interface, const Ipv6Addr *ipAddr, MacAddr *macAddr)
00098 {
00099    error_t error;
00100    NdpNeighborCacheEntry *entry;
00101 
00102    //Search the ndpCacheMutex cache for the specified IPv6 address
00103    entry = ndpFindNeighborCacheEntry(interface, ipAddr);
00104 
00105    //Check whether a matching entry has been found
00106    if(entry != NULL)
00107    {
00108       //Check the state of the Neighbor cache entry
00109       if(entry->state == NDP_STATE_INCOMPLETE)
00110       {
00111          //The address resolution is already in progress
00112          error = ERROR_IN_PROGRESS;
00113       }
00114       else if(entry->state == NDP_STATE_STALE)
00115       {
00116          //Copy the MAC address associated with the specified IPv6 address
00117          *macAddr = entry->macAddr;
00118 
00119          //Start delay timer
00120          entry->timestamp = osGetSystemTime();
00121          //Delay before sending the first probe
00122          entry->timeout = NDP_DELAY_FIRST_PROBE_TIME;
00123          //Switch to the DELAY state
00124          entry->state = NDP_STATE_DELAY;
00125 
00126          //Successful address resolution
00127          error = NO_ERROR;
00128       }
00129       else
00130       {
00131          //Copy the MAC address associated with the specified IPv6 address
00132          *macAddr = entry->macAddr;
00133 
00134          //Successful address resolution
00135          error = NO_ERROR;
00136       }
00137    }
00138    else
00139    {
00140       //If no entry exists, then create a new one
00141       entry = ndpCreateNeighborCacheEntry(interface);
00142 
00143       //Neighbor Cache entry successfully created?
00144       if(entry != NULL)
00145       {
00146          //Record the IPv6 address whose MAC address is unknown
00147          entry->ipAddr = *ipAddr;
00148 
00149          //Reset retransmission counter
00150          entry->retransmitCount = 0;
00151          //No packet are pending in the transmit queue
00152          entry->queueSize = 0;
00153 
00154          //Send a multicast Neighbor Solicitation message
00155          ndpSendNeighborSol(interface, ipAddr, TRUE);
00156 
00157          //Save the time at which the message was sent
00158          entry->timestamp = osGetSystemTime();
00159          //Set timeout value
00160          entry->timeout = interface->ndpContext.retransTimer;
00161          //Enter INCOMPLETE state
00162          entry->state = NDP_STATE_INCOMPLETE;
00163 
00164          //The address resolution is in progress
00165          error = ERROR_IN_PROGRESS;
00166       }
00167       else
00168       {
00169          //Failed to create Neighbor Cache entry...
00170          error = ERROR_OUT_OF_RESOURCES;
00171       }
00172    }
00173 
00174    //Return status code
00175    return error;
00176 }
00177 
00178 
00179 /**
00180  * @brief Enqueue an IPv6 packet waiting for address resolution
00181  * @param[in] srcInterface Interface from which the packet has been received
00182  * @param[in] destInterface Interface on which the packet should be sent
00183  * @param[in] ipAddr IPv6 address of the destination host
00184  * @param[in] buffer Multi-part buffer containing the packet to be enqueued
00185  * @param[in] offset Offset to the first byte of the packet
00186  * @return Error code
00187  **/
00188 
00189 error_t ndpEnqueuePacket(NetInterface *srcInterface, NetInterface *destInterface,
00190    const Ipv6Addr *ipAddr, NetBuffer *buffer, size_t offset)
00191 {
00192    error_t error;
00193    uint_t i;
00194    size_t length;
00195    NdpNeighborCacheEntry *entry;
00196 
00197    //Retrieve the length of the multi-part buffer
00198    length = netBufferGetLength(buffer);
00199 
00200    //Search the Neighbor cache for the specified IPv6 address
00201    entry = ndpFindNeighborCacheEntry(destInterface, ipAddr);
00202 
00203    //Check whether a matching entry exists
00204    if(entry != NULL)
00205    {
00206       //Check current state
00207       if(entry->state == NDP_STATE_INCOMPLETE)
00208       {
00209          //Check whether the packet queue is full
00210          if(entry->queueSize >= NDP_MAX_PENDING_PACKETS)
00211          {
00212             //When the queue overflows, the new arrival should replace the oldest entry
00213             netBufferFree(entry->queue[0].buffer);
00214 
00215             //Make room for the new packet
00216             for(i = 1; i < NDP_MAX_PENDING_PACKETS; i++)
00217                entry->queue[i - 1] = entry->queue[i];
00218 
00219             //Adjust the number of pending packets
00220             entry->queueSize--;
00221          }
00222 
00223          //Index of the entry to be filled in
00224          i = entry->queueSize;
00225          //Allocate a memory buffer to store the packet
00226          entry->queue[i].buffer = netBufferAlloc(length);
00227 
00228          //Successful memory allocation?
00229          if(entry->queue[i].buffer != NULL)
00230          {
00231             //If the IPv6 packet has been forwarded, record the network
00232             //interface from which the packet has been received
00233             entry->queue[i].srcInterface = srcInterface;
00234 
00235             //Copy the contents of the IPv6 packet
00236             netBufferCopy(entry->queue[i].buffer, 0, buffer, 0, length);
00237             //Offset to the first byte of the IPv6 header
00238             entry->queue[i].offset = offset;
00239 
00240             //Increment the number of queued packets
00241             entry->queueSize++;
00242             //The packet was successfully enqueued
00243             error = NO_ERROR;
00244          }
00245          else
00246          {
00247             //Failed to allocate memory
00248             error = ERROR_OUT_OF_MEMORY;
00249          }
00250       }
00251       else
00252       {
00253          //The address is already resolved
00254          error = ERROR_UNEXPECTED_STATE;
00255       }
00256    }
00257    else
00258    {
00259       //No matching entry in Neighbor Cache
00260       error = ERROR_NOT_FOUND;
00261    }
00262 
00263    //Return status code
00264    return error;
00265 }
00266 
00267 
00268 /**
00269  * @brief NDP timer handler
00270  * @param[in] interface Underlying network interface
00271  **/
00272 
00273 void ndpTick(NetInterface *interface)
00274 {
00275    systime_t time;
00276    NdpContext *context;
00277 
00278    //Point to the NDP context
00279    context = &interface->ndpContext;
00280 
00281    //Get current time
00282    time = osGetSystemTime();
00283 
00284    //When an interface becomes enabled, a host may send some Router
00285    //Solicitation messages to obtain Router Advertisements quickly
00286    if(interface->linkState && !interface->ipv6Context.isRouter)
00287    {
00288       //Make sure that a valid link-local address has been assigned to the interface
00289       if(ipv6GetLinkLocalAddrState(interface) == IPV6_ADDR_STATE_PREFERRED)
00290       {
00291          //The host should transmit up to MAX_RTR_SOLICITATIONS Router
00292          //Solicitation messages
00293          if(context->rtrSolicitationCount == 0)
00294          {
00295             //Set time stamp
00296             context->timestamp = time;
00297 
00298             //Check whether the host has already performed Duplicate Address
00299             //Detection for the link-local address
00300             if(context->dupAddrDetectTransmits > 0)
00301             {
00302                //If a host has already performed a random delay since the interface
00303                //became enabled, there is no need to delay again before sending the
00304                //first Router Solicitation message
00305                context->timeout = 0;
00306             }
00307             else
00308             {
00309                //Before a host sends an initial solicitation, it should delay the
00310                //transmission for a random amount of time in order to alleviate
00311                //congestion when many hosts start up on a link at the same time
00312                context->timeout = netGetRandRange(context->minRtrSolicitationDelay,
00313                   context->maxRtrSolicitationDelay);
00314             }
00315 
00316             //Prepare to send the first Router Solicitation message
00317             context->rtrSolicitationCount = 1;
00318          }
00319          else if(context->rtrSolicitationCount <= context->maxRtrSolicitations)
00320          {
00321             //Once the host sends a Router Solicitation, and receives a valid
00322             //Router Advertisement with a non-zero Router Lifetime, the host must
00323             //desist from sending additional solicitations on that interface
00324             if(!context->rtrAdvReceived)
00325             {
00326                //Check current time
00327                if(timeCompare(time, context->timestamp + context->timeout) >= 0)
00328                {
00329                   //Send Router Solicitation message
00330                   ndpSendRouterSol(interface);
00331 
00332                   //Save the time at which the message was sent
00333                   context->timestamp = time;
00334                   //Set timeout value
00335                   context->timeout = context->rtrSolicitationInterval;
00336                   //Increment retransmission counter
00337                   context->rtrSolicitationCount++;
00338                }
00339             }
00340          }
00341       }
00342    }
00343 
00344    //Periodically update the Neighbor Cache
00345    ndpUpdateNeighborCache(interface);
00346 
00347    //Manage the lifetime of IPv6 addresses
00348    ndpUpdateAddrList(interface);
00349 
00350    //Periodically update the Prefix List
00351    ndpUpdatePrefixList(interface);
00352 
00353    //Periodically update the Default Router List
00354    ndpUpdateDefaultRouterList(interface);
00355 }
00356 
00357 
00358 /**
00359  * @brief Callback function for link change event
00360  * @param[in] interface Underlying network interface
00361  **/
00362 
00363 void ndpLinkChangeEvent(NetInterface *interface)
00364 {
00365    NdpContext *context;
00366 
00367    //Point to the NDP context
00368    context = &interface->ndpContext;
00369 
00370    //Restore default parameters
00371    context->reachableTime = NDP_REACHABLE_TIME;
00372    context->retransTimer = NDP_RETRANS_TIMER;
00373    context->dupAddrDetectTransmits = NDP_DUP_ADDR_DETECT_TRANSMITS;
00374    context->minRtrSolicitationDelay = NDP_MIN_RTR_SOLICITATION_DELAY;
00375    context->maxRtrSolicitationDelay = NDP_MAX_RTR_SOLICITATION_DELAY;
00376    context->rtrSolicitationInterval = NDP_RTR_SOLICITATION_INTERVAL;
00377    context->maxRtrSolicitations = NDP_MAX_RTR_SOLICITATIONS;
00378 
00379    //Reset retransmission counter for RS messages
00380    context->rtrSolicitationCount = 0;
00381    //Valid RA message not yet received
00382    context->rtrAdvReceived = FALSE;
00383 
00384    //Flush the Neighbor Cache
00385    ndpFlushNeighborCache(interface);
00386    //Flush the Destination Cache
00387    ndpFlushDestCache(interface);
00388 }
00389 
00390 
00391 /**
00392  * @brief Router Advertisement message processing
00393  * @param[in] interface Underlying network interface
00394  * @param[in] pseudoHeader IPv6 pseudo header
00395  * @param[in] buffer Multi-part buffer containing the Router Advertisement message
00396  * @param[in] offset Offset to the first byte of the message
00397  * @param[in] hopLimit Hop Limit field from IPv6 header
00398  **/
00399 
00400 void ndpProcessRouterAdv(NetInterface *interface, Ipv6PseudoHeader *pseudoHeader,
00401    const NetBuffer *buffer, size_t offset, uint8_t hopLimit)
00402 {
00403    error_t error;
00404    uint32_t n;
00405    size_t length;
00406    NdpRouterAdvMessage *message;
00407    NdpMtuOption *mtuOption;
00408    NdpPrefixInfoOption *prefixInfoOption;
00409 #if (ETH_SUPPORT == ENABLED)
00410    NdpLinkLayerAddrOption *linkLayerAddrOption;
00411    NdpNeighborCacheEntry *entry;
00412 #endif
00413 
00414    //Retrieve the length of the message
00415    length = netBufferGetLength(buffer) - offset;
00416 
00417    //Check the length of the Router Advertisement message
00418    if(length < sizeof(NdpRouterAdvMessage))
00419       return;
00420 
00421    //Point to the beginning of the message
00422    message = netBufferAt(buffer, offset);
00423    //Sanity check
00424    if(message == NULL)
00425       return;
00426 
00427    //Debug message
00428    TRACE_INFO("Router Advertisement message received (%" PRIuSIZE " bytes)...\r\n", length);
00429    //Dump message contents for debugging purpose
00430    ndpDumpRouterAdvMessage(message);
00431 
00432    //Routers must use their link-local address as the source for the
00433    //Router Advertisement so that hosts can uniquely identify routers
00434    if(!ipv6IsLinkLocalUnicastAddr(&pseudoHeader->srcAddr))
00435       return;
00436 
00437    //The IPv6 Hop Limit field must have a value of 255 to ensure
00438    //that the packet has not been forwarded by a router
00439    if(hopLimit != NDP_HOP_LIMIT)
00440       return;
00441 
00442    //ICMPv6 Code must be 0. An advertisement that passes the validity
00443    //checks is called a valid advertisement
00444    if(message->code)
00445       return;
00446 
00447    //Calculate the length of the Options field
00448    length -= sizeof(NdpRouterAdvMessage);
00449 
00450    //Parse Options field
00451    error = ndpCheckOptions(message->options, length);
00452    //All included options must have a length that is greater than zero
00453    if(error)
00454       return;
00455 
00456    //Check the Router Lifetime value
00457    if(ntohs(message->routerLifetime) != 0)
00458    {
00459       //Add a new entry in the Default Router List
00460       ipv6AddDefaultRouter(interface, &pseudoHeader->srcAddr,
00461          ntohs(message->routerLifetime));
00462 
00463       //The host should send at least one solicitation in the case where
00464       //an advertisement is received prior to having sent a solicitation
00465       if(interface->ndpContext.rtrSolicitationCount > 1)
00466       {
00467          //Once the host sends a Router Solicitation, and receives a valid
00468          //Router Advertisement with a non-zero Router Lifetime, the host must
00469          //desist from sending additional solicitations on that interface
00470          interface->ndpContext.rtrAdvReceived = TRUE;
00471       }
00472    }
00473    else
00474    {
00475       //Immediately time-out the entry
00476       ipv6RemoveDefaultRouter(interface, &pseudoHeader->srcAddr);
00477    }
00478 
00479    //6LoWPAN interface?
00480    if(interface->nicDriver->type == NIC_TYPE_6LOWPAN)
00481    {
00482       //In all cases, the Router Solicitation retransmissions are terminated
00483       //when a Router Advertisement is received (refer to RFC 6675 5.3)
00484       interface->ndpContext.rtrAdvReceived = TRUE;
00485    }
00486 
00487    //A Router Advertisement field (Cur Hop Limit, Reachable Time, and
00488    //Retrans Timer) may contain a value denoting that it is unspecified.
00489    //In such cases, the parameter should be ignored and the host should
00490    //continue using whatever value it is already using
00491    if(message->curHopLimit != 0)
00492    {
00493       //Get the default value that should be placed in the Hop Count
00494       //field of the IP header for outgoing IP packets
00495       interface->ipv6Context.curHopLimit = message->curHopLimit;
00496    }
00497 
00498    //A value of zero means unspecified...
00499    if(message->reachableTime != 0)
00500    {
00501       //The Reachable Time field holds the time, in milliseconds, that
00502       //a node assumes a neighbor is reachable after having received a
00503       //reachability confirmation
00504       interface->ndpContext.reachableTime = ntohl(message->reachableTime);
00505    }
00506 
00507    //A value of zero means unspecified...
00508    if(message->retransTimer != 0)
00509    {
00510       //The Retrans Timer field holds the time, in milliseconds,
00511       //between retransmitted Neighbor Solicitation messages
00512       interface->ndpContext.retransTimer = ntohl(message->retransTimer);
00513    }
00514 
00515 #if (ETH_SUPPORT == ENABLED)
00516    //Search for the Source Link-Layer Address option
00517    linkLayerAddrOption = ndpGetOption(message->options,
00518       length, NDP_OPT_SOURCE_LINK_LAYER_ADDR);
00519 
00520    //Source Link-Layer Address option found?
00521    if(linkLayerAddrOption != NULL && linkLayerAddrOption->length == 1)
00522    {
00523       //Debug message
00524       TRACE_DEBUG("  Source Link-Layer Address = %s\r\n",
00525          macAddrToString(&linkLayerAddrOption->linkLayerAddr, NULL));
00526    }
00527    else
00528    {
00529       //No valid Source Link-Layer Address option...
00530       linkLayerAddrOption = NULL;
00531    }
00532 
00533    //Search the Neighbor cache for the router
00534    entry = ndpFindNeighborCacheEntry(interface, &pseudoHeader->srcAddr);
00535 
00536    //No matching entry has been found?
00537    if(!entry)
00538    {
00539       //If the advertisement contains a Source Link-Layer Address option,
00540       //the link-layer address should be recorded in the Neighbor cache
00541       if(linkLayerAddrOption)
00542       {
00543          //Create an entry for the router
00544          entry = ndpCreateNeighborCacheEntry(interface);
00545 
00546          //Neighbor cache entry successfully created?
00547          if(entry)
00548          {
00549             //Record the IPv6 address and the corresponding MAC address
00550             entry->ipAddr = pseudoHeader->srcAddr;
00551             entry->macAddr = linkLayerAddrOption->linkLayerAddr;
00552             //The IsRouter flag must be set to TRUE
00553             entry->isRouter = TRUE;
00554             //Save current time
00555             entry->timestamp = osGetSystemTime();
00556             //The reachability state must be set to STALE
00557             entry->state = NDP_STATE_STALE;
00558          }
00559       }
00560    }
00561    else
00562    {
00563       //The sender of a Router Advertisement is implicitly assumed to be a router
00564       entry->isRouter = TRUE;
00565 
00566       //Check if the advertisement contains a Source Link-Layer Address option
00567       if(linkLayerAddrOption)
00568       {
00569          //INCOMPLETE state?
00570          if(entry->state == NDP_STATE_INCOMPLETE)
00571          {
00572             //Record link-layer address
00573             entry->macAddr = linkLayerAddrOption->linkLayerAddr;
00574             //Send all the packets that are pending for transmission
00575             n = ndpSendQueuedPackets(interface, entry);
00576             //Save current time
00577             entry->timestamp = osGetSystemTime();
00578 
00579             //Check whether any packets have been sent
00580             if(n > 0)
00581             {
00582                //Start delay timer
00583                entry->timeout = NDP_DELAY_FIRST_PROBE_TIME;
00584                //Switch to the DELAY state
00585                entry->state = NDP_STATE_DELAY;
00586             }
00587             else
00588             {
00589                //Enter the STALE state
00590                entry->state = NDP_STATE_STALE;
00591             }
00592          }
00593          //REACHABLE, STALE, DELAY or PROBE state?
00594          else
00595          {
00596             //Different link-layer address than cached?
00597             if(!macCompAddr(&entry->macAddr, &linkLayerAddrOption->linkLayerAddr))
00598             {
00599                //Update link-layer address
00600                entry->macAddr = linkLayerAddrOption->linkLayerAddr;
00601                //Save current time
00602                entry->timestamp = osGetSystemTime();
00603                //The reachability state must be set to STALE
00604                entry->state = NDP_STATE_STALE;
00605             }
00606          }
00607       }
00608    }
00609 #endif
00610 
00611    //Search for the MTU option
00612    mtuOption = ndpGetOption(message->options, length, NDP_OPT_MTU);
00613 
00614    //MTU option found?
00615    if(mtuOption != NULL && mtuOption->length == 1)
00616    {
00617       //This option specifies the recommended MTU for the link
00618       n = ntohl(mtuOption->mtu);
00619 
00620       //The host should copy the option's value so long as the value is greater
00621       //than or equal to the minimum IPv6 MTU and does not exceed the maximum
00622       //MTU of the interface
00623       if(n >= IPV6_DEFAULT_MTU && n <= interface->nicDriver->mtu)
00624       {
00625          //Save the MTU value
00626          interface->ipv6Context.linkMtu = n;
00627       }
00628    }
00629 
00630    //Point to the beginning of the Options field
00631    n = 0;
00632 
00633    //Parse Options field
00634    while(1)
00635    {
00636       //Search the Options field for any Prefix Information options
00637       prefixInfoOption = ndpGetOption(message->options + n,
00638          length - n, NDP_OPT_PREFIX_INFORMATION);
00639 
00640       //No more option of the specified type?
00641       if(prefixInfoOption == NULL)
00642          break;
00643 
00644       //Hosts use the advertised on-link prefixes to build and maintain
00645       //a list that is used in deciding when a packet's destination is
00646       //on-link or beyond a router
00647       ndpParsePrefixInfoOption(interface, prefixInfoOption);
00648 
00649       //Retrieve the offset to the current position
00650       n = (uint8_t *) prefixInfoOption - message->options;
00651       //Jump to the next option
00652       n += prefixInfoOption->length * 8;
00653    }
00654 
00655 #if (SLAAC_SUPPORT == ENABLED)
00656    //Stateless Address Autoconfiguration is currently used?
00657    if(interface->slaacContext != NULL)
00658    {
00659       //Process the valid advertisement
00660       slaacParseRouterAdv(interface->slaacContext, message,
00661          length + sizeof(NdpRouterAdvMessage));
00662    }
00663 #endif
00664 }
00665 
00666 
00667 /**
00668  * @brief Neighbor Solicitation message processing
00669  * @param[in] interface Underlying network interface
00670  * @param[in] pseudoHeader IPv6 pseudo header
00671  * @param[in] buffer Multi-part buffer containing the Neighbor Solicitation message
00672  * @param[in] offset Offset to the first byte of the message
00673  * @param[in] hopLimit Hop Limit field from IPv6 header
00674  **/
00675 
00676 void ndpProcessNeighborSol(NetInterface *interface, Ipv6PseudoHeader *pseudoHeader,
00677    const NetBuffer *buffer, size_t offset, uint8_t hopLimit)
00678 {
00679 #if (ETH_SUPPORT == ENABLED)
00680    error_t error;
00681    uint_t i;
00682    uint_t n;
00683    size_t length;
00684    bool_t validTarget;
00685    NdpNeighborSolMessage *message;
00686    NdpLinkLayerAddrOption *option;
00687    NdpNeighborCacheEntry *neighborCacheEntry;
00688    Ipv6AddrEntry *addrEntry;
00689 
00690    //Retrieve the length of the message
00691    length = netBufferGetLength(buffer) - offset;
00692 
00693    //Check the length of the Neighbor Solicitation message
00694    if(length < sizeof(NdpNeighborSolMessage))
00695       return;
00696 
00697    //Point to the beginning of the message
00698    message = netBufferAt(buffer, offset);
00699    //Sanity check
00700    if(message == NULL)
00701       return;
00702 
00703    //Debug message
00704    TRACE_INFO("Neighbor Solicitation message received (%" PRIuSIZE " bytes)...\r\n", length);
00705    //Dump message contents for debugging purpose
00706    ndpDumpNeighborSolMessage(message);
00707 
00708    //The IPv6 Hop Limit field must have a value of 255 to ensure
00709    //that the packet has not been forwarded by a router
00710    if(hopLimit != NDP_HOP_LIMIT)
00711       return;
00712 
00713    //ICMPv6 Code must be 0
00714    if(message->code)
00715       return;
00716 
00717    //If the IP source address is the unspecified address, the IP
00718    //destination address must be a solicited-node multicast address
00719    if(ipv6CompAddr(&pseudoHeader->srcAddr, &IPV6_UNSPECIFIED_ADDR) &&
00720       !ipv6IsSolicitedNodeAddr(&pseudoHeader->destAddr))
00721    {
00722       //Debug message
00723       TRACE_WARNING("Destination address must be a solicited-node address!\r\n");
00724       //Exit immediately
00725       return;
00726    }
00727 
00728    //Calculate the length of the Options field
00729    length -= sizeof(NdpNeighborSolMessage);
00730 
00731    //Parse Options field
00732    error = ndpCheckOptions(message->options, length);
00733    //All included options must have a length that is greater than zero
00734    if(error)
00735       return;
00736 
00737    //Search for the Source Link-Layer Address option
00738    option = ndpGetOption(message->options,
00739       length, NDP_OPT_SOURCE_LINK_LAYER_ADDR);
00740 
00741    //The target address must a valid unicast or anycast address assigned to
00742    //the interface or a tentative address on which DAD is being performed
00743    validTarget = FALSE;
00744 
00745    //Loop through the IPv6 addresses assigned to the interface
00746    for(i = 0; i < IPV6_ADDR_LIST_SIZE; i++)
00747    {
00748       //Point to the current entry
00749       addrEntry = &interface->ipv6Context.addrList[i];
00750 
00751       //Compare target address
00752       if(ipv6CompAddr(&addrEntry->addr, &message->targetAddr))
00753       {
00754          //Check address state
00755          if(addrEntry->state == IPV6_ADDR_STATE_TENTATIVE)
00756          {
00757             //If the source address of the Neighbor Solicitation is the
00758             //unspecified address, the solicitation is from a node
00759             //performing Duplicate Address Detection
00760             if(ipv6CompAddr(&pseudoHeader->srcAddr, &IPV6_UNSPECIFIED_ADDR))
00761             {
00762                //The source link-layer address must not be included when the
00763                //source IP address is the unspecified address...
00764                if(option == NULL)
00765                {
00766                   //Debug message
00767                   TRACE_WARNING("The tentative address %s is a duplicate!\r\n",
00768                      ipv6AddrToString(&addrEntry->addr, NULL));
00769 
00770                   //The tentative address is a duplicate and should not be used
00771                   addrEntry->duplicate = TRUE;
00772                }
00773             }
00774 
00775             //In all cases, a node must not respond to a Neighbor Solicitation
00776             //for a tentative address
00777             return;
00778          }
00779          else if(addrEntry->state != IPV6_ADDR_STATE_INVALID)
00780          {
00781             //The target address is a valid address assigned to the interface
00782             validTarget = TRUE;
00783             //We are done
00784             break;
00785          }
00786       }
00787    }
00788 
00789    //Invalid target address?
00790    if(!validTarget)
00791    {
00792       //The Neighbor Solicitation must be discarded if the target address
00793       //is not a valid anycast address assigned to the interface
00794       if(!ipv6IsAnycastAddr(interface, &message->targetAddr))
00795       {
00796          //Debug message
00797          TRACE_WARNING("Wrong target address!\r\n");
00798          //Exit immediately
00799          return;
00800       }
00801    }
00802 
00803    //Source Link-Layer Address option found?
00804    if(option != NULL && option->length == 1)
00805    {
00806       //Debug message
00807       TRACE_DEBUG("  Source Link-Layer Address = %s\r\n",
00808          macAddrToString(&option->linkLayerAddr, NULL));
00809 
00810       //The Source Link-Layer Address option must not be included when the
00811       //source IP address is the unspecified address
00812       if(ipv6CompAddr(&pseudoHeader->srcAddr, &IPV6_UNSPECIFIED_ADDR))
00813          return;
00814 
00815       //Search the Neighbor Cache for the source address of the solicitation
00816       neighborCacheEntry = ndpFindNeighborCacheEntry(interface, &pseudoHeader->srcAddr);
00817 
00818       //No matching entry has been found?
00819       if(!neighborCacheEntry)
00820       {
00821          //Create an entry
00822          neighborCacheEntry = ndpCreateNeighborCacheEntry(interface);
00823 
00824          //Neighbor Cache entry successfully created?
00825          if(neighborCacheEntry)
00826          {
00827             //Record the IPv6 and the corresponding MAC address
00828             neighborCacheEntry->ipAddr = pseudoHeader->srcAddr;
00829             neighborCacheEntry->macAddr = option->linkLayerAddr;
00830             //Save current time
00831             neighborCacheEntry->timestamp = osGetSystemTime();
00832             //Enter the STALE state
00833             neighborCacheEntry->state = NDP_STATE_STALE;
00834          }
00835       }
00836       else
00837       {
00838          //INCOMPLETE state?
00839          if(neighborCacheEntry->state == NDP_STATE_INCOMPLETE)
00840          {
00841             //Record link-layer address
00842             neighborCacheEntry->macAddr = option->linkLayerAddr;
00843             //Send all the packets that are pending for transmission
00844             n = ndpSendQueuedPackets(interface, neighborCacheEntry);
00845             //Save current time
00846             neighborCacheEntry->timestamp = osGetSystemTime();
00847 
00848             //Check whether any packets have been sent
00849             if(n > 0)
00850             {
00851                //Start delay timer
00852                neighborCacheEntry->timeout = NDP_DELAY_FIRST_PROBE_TIME;
00853                //Switch to the DELAY state
00854                neighborCacheEntry->state = NDP_STATE_DELAY;
00855             }
00856             else
00857             {
00858                //Enter the STALE state
00859                neighborCacheEntry->state = NDP_STATE_STALE;
00860             }
00861          }
00862          //REACHABLE, STALE, DELAY or PROBE state?
00863          else
00864          {
00865             //Different link-layer address than cached?
00866             if(!macCompAddr(&neighborCacheEntry->macAddr, &option->linkLayerAddr))
00867             {
00868                //Update link-layer address
00869                neighborCacheEntry->macAddr = option->linkLayerAddr;
00870                //Save current time
00871                neighborCacheEntry->timestamp = osGetSystemTime();
00872                //Enter the STALE state
00873                neighborCacheEntry->state = NDP_STATE_STALE;
00874             }
00875          }
00876       }
00877    }
00878    //Source Link-Layer Address option not found?
00879    else
00880    {
00881       //The Source Link-Layer Address option must not be included when the
00882       //source IP address is the unspecified address. Otherwise, this option
00883       //must be included in multicast solicitations
00884       if(!ipv6CompAddr(&pseudoHeader->srcAddr, &IPV6_UNSPECIFIED_ADDR) &&
00885          ipv6IsMulticastAddr(&pseudoHeader->destAddr))
00886       {
00887          //Debug message
00888          TRACE_WARNING("The Source Link-Layer Address must be included!\r\n");
00889          //Exit immediately
00890          return;
00891       }
00892    }
00893 
00894    //After any updates to the Neighbor cache, the node sends a Neighbor
00895    //Advertisement response as described in RFC 4861 7.2.4
00896    ndpSendNeighborAdv(interface, &message->targetAddr, &pseudoHeader->srcAddr);
00897 #endif
00898 }
00899 
00900 
00901 /**
00902  * @brief Neighbor Advertisement message processing
00903  * @param[in] interface Underlying network interface
00904  * @param[in] pseudoHeader IPv6 pseudo header
00905  * @param[in] buffer Multi-part buffer containing the Neighbor Advertisement message
00906  * @param[in] offset Offset to the first byte of the message
00907  * @param[in] hopLimit Hop Limit field from IPv6 header
00908  **/
00909 
00910 void ndpProcessNeighborAdv(NetInterface *interface, Ipv6PseudoHeader *pseudoHeader,
00911    const NetBuffer *buffer, size_t offset, uint8_t hopLimit)
00912 {
00913 #if (ETH_SUPPORT == ENABLED)
00914    error_t error;
00915    uint_t i;
00916    uint_t n;
00917    size_t length;
00918    bool_t differentLinkLayerAddr;
00919    NdpNeighborAdvMessage *message;
00920    NdpLinkLayerAddrOption *option;
00921    NdpNeighborCacheEntry *neighborCacheEntry;
00922    Ipv6AddrEntry *addrEntry;
00923 
00924    //Retrieve the length of the message
00925    length = netBufferGetLength(buffer) - offset;
00926 
00927    //Check the length of the Neighbor Advertisement message
00928    if(length < sizeof(NdpNeighborAdvMessage))
00929       return;
00930 
00931    //Point to the beginning of the message
00932    message = netBufferAt(buffer, offset);
00933    //Sanity check
00934    if(message == NULL)
00935       return;
00936 
00937    //Debug message
00938    TRACE_INFO("Neighbor Advertisement message received (%" PRIuSIZE " bytes)...\r\n", length);
00939    //Dump message contents for debugging purpose
00940    ndpDumpNeighborAdvMessage(message);
00941 
00942    //The IPv6 Hop Limit field must have a value of 255 to ensure
00943    //that the packet has not been forwarded by a router
00944    if(hopLimit != NDP_HOP_LIMIT)
00945       return;
00946 
00947    //ICMPv6 Code must be 0
00948    if(message->code)
00949       return;
00950 
00951    //The target address must not be a multicast address
00952    if(ipv6IsMulticastAddr(&message->targetAddr))
00953    {
00954       //Debug message
00955       TRACE_WARNING("Target address must not be a multicast address!\r\n");
00956       //Exit immediately
00957       return;
00958    }
00959 
00960    //If the destination address is a multicast address
00961    //then the Solicited flag must be zero
00962    if(ipv6IsMulticastAddr(&pseudoHeader->destAddr) && message->s)
00963    {
00964       //Debug message
00965       TRACE_WARNING("Solicited flag must be zero!\r\n");
00966       //Exit immediately
00967       return;
00968    }
00969 
00970    //Calculate the length of the Options field
00971    length -= sizeof(NdpNeighborAdvMessage);
00972 
00973    //Parse Options field
00974    error = ndpCheckOptions(message->options, length);
00975    //All included options must have a length that is greater than zero
00976    if(error)
00977       return;
00978 
00979    //Duplicate address detection
00980    for(i = 0; i < IPV6_ADDR_LIST_SIZE; i++)
00981    {
00982       //Point to the current entry
00983       addrEntry = &interface->ipv6Context.addrList[i];
00984 
00985       //Valid entry?
00986       if(addrEntry->state != IPV6_ADDR_STATE_INVALID)
00987       {
00988          //Check whether the target address is tentative or matches
00989          //a unicast address assigned to the interface
00990          if(ipv6CompAddr(&addrEntry->addr, &message->targetAddr))
00991          {
00992             //Debug message
00993             TRACE_WARNING("The address %s is a duplicate!\r\n",
00994                ipv6AddrToString(&addrEntry->addr, NULL));
00995 
00996             //The address is a duplicate and should not be used
00997             addrEntry->duplicate = TRUE;
00998             //Exit immediately
00999             return;
01000          }
01001       }
01002    }
01003 
01004    //Search the Neighbor cache for the specified target address
01005    neighborCacheEntry = ndpFindNeighborCacheEntry(interface, &message->targetAddr);
01006 
01007    //If no entry exists, the advertisement should be silently discarded
01008    if(neighborCacheEntry)
01009    {
01010       //This flag tells whether the supplied link-layer
01011       //address differs from that in the cache
01012       differentLinkLayerAddr = FALSE;
01013 
01014       //Search for the Target Link-Layer Address option
01015       option = ndpGetOption(message->options,
01016          length, NDP_OPT_TARGET_LINK_LAYER_ADDR);
01017 
01018       //Target Link-Layer Address option found?
01019       if(option != NULL && option->length == 1)
01020       {
01021          //Debug message
01022          TRACE_DEBUG("  Target Link-Layer Address = %s\r\n",
01023             macAddrToString(&option->linkLayerAddr, NULL));
01024 
01025          //Different link-layer address than cached?
01026          if(!macCompAddr(&neighborCacheEntry->macAddr, &option->linkLayerAddr))
01027             differentLinkLayerAddr = TRUE;
01028       }
01029 
01030       //INCOMPLETE state?
01031       if(neighborCacheEntry->state == NDP_STATE_INCOMPLETE)
01032       {
01033          //If no Target Link-Layer Address option is included, the receiving
01034          //node should silently discard the received advertisement
01035          if(option != NULL && option->length == 1)
01036          {
01037             //Record the link-layer address
01038             neighborCacheEntry->macAddr = option->linkLayerAddr;
01039             //Send all the packets that are pending for transmission
01040             n = ndpSendQueuedPackets(interface, neighborCacheEntry);
01041             //Save current time
01042             neighborCacheEntry->timestamp = osGetSystemTime();
01043 
01044             //Solicited flag is set?
01045             if(message->s)
01046             {
01047                //Computing the random ReachableTime value
01048                neighborCacheEntry->timeout = interface->ndpContext.reachableTime;
01049                //Switch to the REACHABLE state
01050                neighborCacheEntry->state = NDP_STATE_REACHABLE;
01051             }
01052             else
01053             {
01054                //Check whether any packets have been sent
01055                if(n > 0)
01056                {
01057                   //Start delay timer
01058                   neighborCacheEntry->timeout = NDP_DELAY_FIRST_PROBE_TIME;
01059                   //Switch to the DELAY state
01060                   neighborCacheEntry->state = NDP_STATE_DELAY;
01061                }
01062                else
01063                {
01064                   //Enter the STALE state
01065                   neighborCacheEntry->state = NDP_STATE_STALE;
01066                }
01067             }
01068          }
01069       }
01070       //REACHABLE, STALE, DELAY or PROBE state?
01071       else
01072       {
01073          //Check whether the Override flag is clear and the supplied
01074          //link-layer address differs from that in the cache
01075          if(!message->o && differentLinkLayerAddr)
01076          {
01077             //REACHABLE state?
01078             if(neighborCacheEntry->state == NDP_STATE_REACHABLE)
01079             {
01080                //Save current time
01081                neighborCacheEntry->timestamp = osGetSystemTime();
01082                //Enter the STALE state
01083                neighborCacheEntry->state = NDP_STATE_STALE;
01084             }
01085          }
01086          else
01087          {
01088             //Solicited flag is set?
01089             if(message->s)
01090             {
01091                //Different link-layer address than cached?
01092                if(differentLinkLayerAddr)
01093                {
01094                   //The link-layer address must be inserted in the cache
01095                   neighborCacheEntry->macAddr = option->linkLayerAddr;
01096                }
01097 
01098                //Save current time
01099                neighborCacheEntry->timestamp = osGetSystemTime();
01100                //Computing the random ReachableTime value
01101                neighborCacheEntry->timeout = interface->ndpContext.reachableTime;
01102                //Switch to the REACHABLE state
01103                neighborCacheEntry->state = NDP_STATE_REACHABLE;
01104             }
01105             else
01106             {
01107                //Different link-layer address than cached?
01108                if(differentLinkLayerAddr)
01109                {
01110                   //The link-layer address must be inserted in the cache
01111                   neighborCacheEntry->macAddr = option->linkLayerAddr;
01112                   //Save current time
01113                   neighborCacheEntry->timestamp = osGetSystemTime();
01114                   //The state must be set to STALE
01115                   neighborCacheEntry->state = NDP_STATE_STALE;
01116                }
01117             }
01118          }
01119       }
01120 
01121       //The IsRouter flag in the cache entry must be set based
01122       //on the Router flag in the received advertisement
01123       if(message->r)
01124       {
01125          //The neighbor is a router
01126          neighborCacheEntry->isRouter = TRUE;
01127       }
01128       else
01129       {
01130          //Check whether the IsRouter flag changes from TRUE to FALSE
01131          //as a result of this update
01132          if(neighborCacheEntry->isRouter)
01133          {
01134             //The node must remove that router from the Default Router list
01135             //and update the Destination cache entries for all destinations
01136             //using that neighbor as a router
01137             ipv6RemoveDefaultRouter(interface, &neighborCacheEntry->ipAddr);
01138          }
01139 
01140          //The neighbor is a host
01141          neighborCacheEntry->isRouter = FALSE;
01142       }
01143    }
01144 #endif
01145 }
01146 
01147 
01148 /**
01149  * @brief Redirect message processing
01150  * @param[in] interface Underlying network interface
01151  * @param[in] pseudoHeader IPv6 pseudo header
01152  * @param[in] buffer Multi-part buffer containing the Redirect message
01153  * @param[in] offset Offset to the first byte of the message
01154  * @param[in] hopLimit Hop Limit field from IPv6 header
01155  **/
01156 
01157 void ndpProcessRedirect(NetInterface *interface, Ipv6PseudoHeader *pseudoHeader,
01158    const NetBuffer *buffer, size_t offset, uint8_t hopLimit)
01159 {
01160 #if (ETH_SUPPORT == ENABLED)
01161    error_t error;
01162    uint_t n;
01163    size_t length;
01164    NdpRedirectMessage *message;
01165    NdpLinkLayerAddrOption *option;
01166    NdpNeighborCacheEntry *neighborCacheEntry;
01167    NdpDestCacheEntry *destCacheEntry;
01168 
01169    //Retrieve the length of the message
01170    length = netBufferGetLength(buffer) - offset;
01171 
01172    //Check the length of the Redirect message
01173    if(length < sizeof(NdpRedirectMessage))
01174       return;
01175 
01176    //Point to the beginning of the message
01177    message = netBufferAt(buffer, offset);
01178    //Sanity check
01179    if(message == NULL)
01180       return;
01181 
01182    //Debug message
01183    TRACE_INFO("Redirect message received (%" PRIuSIZE " bytes)...\r\n", length);
01184    //Dump message contents for debugging purpose
01185    ndpDumpRedirectMessage(message);
01186 
01187    //The IPv6 Hop Limit field must have a value of 255 to ensure
01188    //that the packet has not been forwarded by a router
01189    if(hopLimit != NDP_HOP_LIMIT)
01190       return;
01191 
01192    //ICMPv6 Code must be 0
01193    if(message->code)
01194       return;
01195 
01196    //Routers must use their link-local address as the source for Redirect
01197    //messages so that hosts can uniquely identify routers
01198    if(!ipv6IsLinkLocalUnicastAddr(&pseudoHeader->srcAddr))
01199       return;
01200 
01201    //The IP source address of the Redirect must be the same as the current
01202    //first-hop router for the specified Destination address
01203    if(!ndpIsFirstHopRouter(interface, &message->destAddr, &pseudoHeader->srcAddr))
01204       return;
01205 
01206    //The Destination Address field in the Redirect message must not
01207    //contain a multicast address
01208    if(ipv6IsMulticastAddr(&message->destAddr))
01209       return;
01210 
01211    //The Target Address must be either a link-local address (when redirected
01212    //to a router) or the same as the Destination Address (when redirected to
01213    //the on-link destination)
01214    if(!ipv6IsLinkLocalUnicastAddr(&message->targetAddr) &&
01215       !ipv6CompAddr(&message->targetAddr, &message->destAddr))
01216    {
01217       //Silently discard the received Redirect message
01218       return;
01219    }
01220 
01221    //Calculate the length of the Options field
01222    length -= sizeof(NdpNeighborAdvMessage);
01223 
01224    //Parse Options field
01225    error = ndpCheckOptions(message->options, length);
01226    //All included options must have a length that is greater than zero
01227    if(error)
01228       return;
01229 
01230    //Search the Destination cache for the specified address
01231    destCacheEntry = ndpFindDestCacheEntry(interface, &message->destAddr);
01232 
01233    //Check whether a corresponding Destination cache entry exists
01234    if(destCacheEntry)
01235    {
01236       //The entry is updated with information learned from Redirect messages
01237       destCacheEntry->nextHop = message->targetAddr;
01238       //Save current time
01239       destCacheEntry->timestamp = osGetSystemTime();
01240    }
01241    else
01242    {
01243       //If no Destination Cache entry exists for the destination, an
01244       //implementation should create such an entry
01245       destCacheEntry = ndpCreateDestCacheEntry(interface);
01246 
01247       //Destination cache entry successfully created?
01248       if(destCacheEntry)
01249       {
01250          //Destination address
01251          destCacheEntry->destAddr = message->destAddr;
01252          //Address of the next hop
01253          destCacheEntry->nextHop = message->targetAddr;
01254 
01255          //Initially, the PMTU value for a path is assumed to be
01256          //the MTU of the first-hop link
01257          destCacheEntry->pathMtu = interface->ipv6Context.linkMtu;
01258 
01259          //Save current time
01260          destCacheEntry->timestamp = osGetSystemTime();
01261       }
01262    }
01263 
01264    //Search for the Target Link-Layer Address option
01265    option = ndpGetOption(message->options,
01266       length, NDP_OPT_TARGET_LINK_LAYER_ADDR);
01267 
01268    //If the Redirect contains a Target Link-Layer Address option, the host
01269    //either creates or updates the Neighbor Cache entry for the target
01270    if(option != NULL && option->length == 1)
01271    {
01272       //Debug message
01273       TRACE_DEBUG("  Target Link-Layer Address = %s\r\n",
01274          macAddrToString(&option->linkLayerAddr, NULL));
01275 
01276       //Search the Neighbor cache for the specified target address
01277       neighborCacheEntry = ndpFindNeighborCacheEntry(interface, &message->targetAddr);
01278 
01279       //No matching entry has been found?
01280       if(!neighborCacheEntry)
01281       {
01282          //Create an entry for the target
01283          neighborCacheEntry = ndpCreateNeighborCacheEntry(interface);
01284 
01285          //Neighbor cache entry successfully created?
01286          if(neighborCacheEntry)
01287          {
01288             //Record the Target address
01289             neighborCacheEntry->ipAddr = message->targetAddr;
01290             //The cached link-layer address is copied from the option
01291             neighborCacheEntry->macAddr = option->linkLayerAddr;
01292             //Newly created Neighbor Cache entries should set the IsRouter flag to FALSE
01293             neighborCacheEntry->isRouter = FALSE;
01294             //Save current time
01295             neighborCacheEntry->timestamp = osGetSystemTime();
01296             //The reachability state must be set to STALE
01297             neighborCacheEntry->state = NDP_STATE_STALE;
01298          }
01299       }
01300       else
01301       {
01302          //If the Target Address is not the same as the Destination Address,
01303          //the host must set IsRouter to TRUE for the target
01304          if(!ipv6CompAddr(&message->targetAddr, &message->destAddr))
01305             neighborCacheEntry->isRouter = TRUE;
01306 
01307          //INCOMPLETE state?
01308          if(neighborCacheEntry->state == NDP_STATE_INCOMPLETE)
01309          {
01310             //Record link-layer address
01311             neighborCacheEntry->macAddr = option->linkLayerAddr;
01312             //Send all the packets that are pending for transmission
01313             n = ndpSendQueuedPackets(interface, neighborCacheEntry);
01314             //Save current time
01315             neighborCacheEntry->timestamp = osGetSystemTime();
01316 
01317             //Check whether any packets have been sent
01318             if(n > 0)
01319             {
01320                //Start delay timer
01321                neighborCacheEntry->timeout = NDP_DELAY_FIRST_PROBE_TIME;
01322                //Switch to the DELAY state
01323                neighborCacheEntry->state = NDP_STATE_DELAY;
01324             }
01325             else
01326             {
01327                //Enter the STALE state
01328                neighborCacheEntry->state = NDP_STATE_STALE;
01329             }
01330          }
01331          //REACHABLE, STALE, DELAY or PROBE state?
01332          else
01333          {
01334             //Different link-layer address than cached?
01335             if(!macCompAddr(&neighborCacheEntry->macAddr, &option->linkLayerAddr))
01336             {
01337                //Update link-layer address
01338                neighborCacheEntry->macAddr = option->linkLayerAddr;
01339                //Save current time
01340                neighborCacheEntry->timestamp = osGetSystemTime();
01341                //The reachability state must be set to STALE
01342                neighborCacheEntry->state = NDP_STATE_STALE;
01343             }
01344          }
01345       }
01346    }
01347 #endif
01348 }
01349 
01350 
01351 /**
01352  * @brief Send a Router Solicitation message
01353  * @param[in] interface Underlying network interface
01354  * @return Error code
01355  **/
01356 
01357 error_t ndpSendRouterSol(NetInterface *interface)
01358 {
01359    error_t error;
01360    size_t offset;
01361    size_t length;
01362    NetBuffer *buffer;
01363    NdpRouterSolMessage *message;
01364    Ipv6PseudoHeader pseudoHeader;
01365 
01366    //The destination address is typically the all-routers multicast address
01367    pseudoHeader.destAddr = IPV6_LINK_LOCAL_ALL_ROUTERS_ADDR;
01368 
01369    //Select the most appropriate source address to be used when
01370    //sending the Router Solicitation message
01371    error = ipv6SelectSourceAddr(&interface,
01372       &pseudoHeader.destAddr, &pseudoHeader.srcAddr);
01373 
01374    //No address assigned to the interface?
01375    if(error)
01376    {
01377       //Use the unspecified address if no address is assigned
01378       //to the sending interface
01379       pseudoHeader.srcAddr = IPV6_UNSPECIFIED_ADDR;
01380    }
01381 
01382    //The only defined option that may appear in a Router Solicitation
01383    //message is the Source Link-Layer Address option
01384    length = sizeof(NdpRouterSolMessage) + sizeof(NdpLinkLayerAddrOption);
01385 
01386    //Allocate a memory buffer to hold the Router Solicitation message
01387    buffer = ipAllocBuffer(length, &offset);
01388    //Failed to allocate memory?
01389    if(buffer == NULL)
01390       return ERROR_OUT_OF_MEMORY;
01391 
01392    //Point to the beginning of the message
01393    message = netBufferAt(buffer, offset);
01394 
01395    //Format Router Solicitation message
01396    message->type = ICMPV6_TYPE_ROUTER_SOL;
01397    message->code = 0;
01398    message->checksum = 0;
01399    message->reserved = 0;
01400 
01401    //Length of the message, excluding any option
01402    length = sizeof(NdpRouterSolMessage);
01403 
01404    //The Source Link-Layer Address option must not be included
01405    //when the source IPv6 address is the unspecified address
01406    if(!ipv6CompAddr(&pseudoHeader.srcAddr, &IPV6_UNSPECIFIED_ADDR))
01407    {
01408 #if (ETH_SUPPORT == ENABLED)
01409       //Check whether a MAC address has been assigned to the interface
01410       if(!macCompAddr(&interface->macAddr, &MAC_UNSPECIFIED_ADDR))
01411       {
01412          //Add Source Link-Layer Address option
01413          ndpAddOption(message, &length, NDP_OPT_SOURCE_LINK_LAYER_ADDR,
01414             &interface->macAddr, sizeof(MacAddr));
01415       }
01416 #endif
01417    }
01418 
01419    //Adjust the length of the multi-part buffer
01420    netBufferSetLength(buffer, offset + length);
01421 
01422    //Format IPv6 pseudo header
01423    pseudoHeader.length = htonl(length);
01424    pseudoHeader.reserved = 0;
01425    pseudoHeader.nextHeader = IPV6_ICMPV6_HEADER;
01426 
01427    //Calculate ICMPv6 header checksum
01428    message->checksum = ipCalcUpperLayerChecksumEx(&pseudoHeader,
01429       sizeof(Ipv6PseudoHeader), buffer, offset, length);
01430 
01431    //Debug message
01432    TRACE_INFO("Sending Router Solicitation message (%" PRIuSIZE " bytes)...\r\n", length);
01433    //Dump message contents for debugging purpose
01434    ndpDumpRouterSolMessage(message);
01435 
01436    //Send Router Solicitation message
01437    error = ipv6SendDatagram(interface, &pseudoHeader, buffer, offset, NDP_HOP_LIMIT);
01438 
01439    //Free previously allocated memory
01440    netBufferFree(buffer);
01441    //Return status code
01442    return error;
01443 }
01444 
01445 
01446 /**
01447  * @brief Send a Neighbor Solicitation message
01448  * @param[in] interface Underlying network interface
01449  * @param[in] targetIpAddr Target IPv6 address
01450  * @param[in] multicast Unicast or unicast Neighbor Solicitation message
01451  * @return Error code
01452  **/
01453 
01454 error_t ndpSendNeighborSol(NetInterface *interface,
01455    const Ipv6Addr *targetIpAddr, bool_t multicast)
01456 {
01457    error_t error;
01458    size_t offset;
01459    size_t length;
01460    NetBuffer *buffer;
01461    NdpNeighborSolMessage *message;
01462    Ipv6PseudoHeader pseudoHeader;
01463 
01464    //Multicast Neighbor Solicitation message?
01465    if(multicast)
01466    {
01467       //Compute the solicited-node multicast address that
01468       //corresponds to the target IPv6 address
01469       ipv6ComputeSolicitedNodeAddr(targetIpAddr, &pseudoHeader.destAddr);
01470    }
01471    else
01472    {
01473       //Unicast Neighbor Solicitation message
01474       pseudoHeader.destAddr = *targetIpAddr;
01475    }
01476 
01477    //Check whether the target address is a tentative address
01478    if(ipv6IsTentativeAddr(interface, targetIpAddr))
01479    {
01480       //The IPv6 source is set to the unspecified address
01481       pseudoHeader.srcAddr = IPV6_UNSPECIFIED_ADDR;
01482    }
01483    else
01484    {
01485       //Select the most appropriate source address to be used
01486       //when sending the Neighbor Solicitation message
01487       error = ipv6SelectSourceAddr(&interface,
01488          targetIpAddr, &pseudoHeader.srcAddr);
01489 
01490       //No address assigned to the interface?
01491       if(error)
01492          return error;
01493    }
01494 
01495    //The only defined option that may appear in a Neighbor Solicitation
01496    //message is the Source Link-Layer Address option
01497    length = sizeof(NdpNeighborSolMessage) + sizeof(NdpLinkLayerAddrOption);
01498 
01499    //Allocate a memory buffer to hold the Neighbor Solicitation message
01500    buffer = ipAllocBuffer(length, &offset);
01501    //Failed to allocate memory?
01502    if(buffer == NULL)
01503       return ERROR_OUT_OF_MEMORY;
01504 
01505    //Point to the beginning of the message
01506    message = netBufferAt(buffer, offset);
01507 
01508    //Format Neighbor Solicitation message
01509    message->type = ICMPV6_TYPE_NEIGHBOR_SOL;
01510    message->code = 0;
01511    message->checksum = 0;
01512    message->reserved = 0;
01513    message->targetAddr = *targetIpAddr;
01514 
01515    //Length of the message, excluding any option
01516    length = sizeof(NdpNeighborSolMessage);
01517 
01518    //The Source Link-Layer Address option must not be included
01519    //when the source IPv6 address is the unspecified address
01520    if(!ipv6CompAddr(&pseudoHeader.srcAddr, &IPV6_UNSPECIFIED_ADDR))
01521    {
01522 #if (ETH_SUPPORT == ENABLED)
01523       //Add Source Link-Layer Address option
01524       ndpAddOption(message, &length, NDP_OPT_SOURCE_LINK_LAYER_ADDR,
01525          &interface->macAddr, sizeof(MacAddr));
01526 #endif
01527    }
01528 
01529    //Adjust the length of the multi-part buffer
01530    netBufferSetLength(buffer, offset + length);
01531 
01532    //Format IPv6 pseudo header
01533    pseudoHeader.length = htonl(length);
01534    pseudoHeader.reserved = 0;
01535    pseudoHeader.nextHeader = IPV6_ICMPV6_HEADER;
01536 
01537    //Calculate ICMPv6 header checksum
01538    message->checksum = ipCalcUpperLayerChecksumEx(&pseudoHeader,
01539       sizeof(Ipv6PseudoHeader), buffer, offset, length);
01540 
01541    //Debug message
01542    TRACE_INFO("Sending Neighbor Solicitation message (%" PRIuSIZE " bytes)...\r\n", length);
01543    //Dump message contents for debugging purpose
01544    ndpDumpNeighborSolMessage(message);
01545 
01546    //Send Neighbor Solicitation message
01547    error = ipv6SendDatagram(interface, &pseudoHeader, buffer, offset, NDP_HOP_LIMIT);
01548 
01549    //Free previously allocated memory
01550    netBufferFree(buffer);
01551    //Return status code
01552    return error;
01553 }
01554 
01555 
01556 /**
01557  * @brief Send a Neighbor Advertisement message
01558  * @param[in] interface Underlying network interface
01559  * @param[in] targetIpAddr Target IPv6 address
01560  * @param[in] destIpAddr Destination IPv6 address
01561  * @return Error code
01562  **/
01563 
01564 error_t ndpSendNeighborAdv(NetInterface *interface,
01565    const Ipv6Addr *targetIpAddr, const Ipv6Addr *destIpAddr)
01566 {
01567    error_t error;
01568    size_t offset;
01569    size_t length;
01570    NetBuffer *buffer;
01571    NdpNeighborAdvMessage *message;
01572    Ipv6PseudoHeader pseudoHeader;
01573 
01574    //Destination IP address is the unspecified address?
01575    if(ipv6CompAddr(destIpAddr, &IPV6_UNSPECIFIED_ADDR))
01576    {
01577       //If the destination is the unspecified address, the node must
01578       //multicast the advertisement to the all-nodes address
01579       pseudoHeader.destAddr = IPV6_LINK_LOCAL_ALL_NODES_ADDR;
01580    }
01581    else
01582    {
01583       //Otherwise, the node must unicast the advertisement to
01584       //the destination IP address
01585       pseudoHeader.destAddr = *destIpAddr;
01586    }
01587 
01588    //Check whether the target address is a valid anycast address
01589    //assigned to the interface
01590    if(ipv6IsAnycastAddr(interface, targetIpAddr))
01591    {
01592       //Select the most appropriate source address to be used
01593       //when sending the Neighbor Advertisement message
01594       error = ipv6SelectSourceAddr(&interface,
01595          targetIpAddr, &pseudoHeader.srcAddr);
01596 
01597       //No address assigned to the interface?
01598       if(error)
01599          return error;
01600    }
01601    else
01602    {
01603       //Set the source IP address
01604       pseudoHeader.srcAddr = *targetIpAddr;
01605    }
01606 
01607    //The only defined option that may appear in a Neighbor Advertisement
01608    //message is the Target Link-Layer Address option
01609    length = sizeof(NdpNeighborAdvMessage) + sizeof(NdpLinkLayerAddrOption);
01610 
01611    //Allocate a memory buffer to hold the Neighbor Advertisement message
01612    buffer = ipAllocBuffer(length, &offset);
01613    //Failed to allocate memory?
01614    if(buffer == NULL)
01615       return ERROR_OUT_OF_MEMORY;
01616 
01617    //Point to the beginning of the message
01618    message = netBufferAt(buffer, offset);
01619 
01620    //Format Neighbor Advertisement message
01621    message->type = ICMPV6_TYPE_NEIGHBOR_ADV;
01622    message->code = 0;
01623    message->checksum = 0;
01624    message->reserved1 = 0;
01625    message->reserved2 = 0;
01626    message->targetAddr = *targetIpAddr;
01627 
01628    //The Router flag indicates that the sender is a router
01629    if(interface->ipv6Context.isRouter)
01630       message->r = TRUE;
01631    else
01632       message->r = FALSE;
01633 
01634    //If the destination is the unspecified address, the node must set
01635    //the Solicited flag to zero
01636    if(ipv6CompAddr(destIpAddr, &IPV6_UNSPECIFIED_ADDR))
01637       message->s = FALSE;
01638    else
01639       message->s = TRUE;
01640 
01641    //The Override flag should not be set in solicited advertisements
01642    //for anycast addresses
01643    if(ipv6IsAnycastAddr(interface, targetIpAddr))
01644       message->o = FALSE;
01645    else
01646       message->o = TRUE;
01647 
01648    //Length of the message, excluding any option
01649    length = sizeof(NdpNeighborAdvMessage);
01650 
01651 #if (ETH_SUPPORT == ENABLED)
01652    //Add Target Link-Layer Address option
01653    ndpAddOption(message, &length, NDP_OPT_TARGET_LINK_LAYER_ADDR,
01654       &interface->macAddr, sizeof(MacAddr));
01655 #endif
01656 
01657    //Adjust the length of the multi-part buffer
01658    netBufferSetLength(buffer, offset + length);
01659 
01660    //Format IPv6 pseudo header
01661    pseudoHeader.length = htonl(length);
01662    pseudoHeader.reserved = 0;
01663    pseudoHeader.nextHeader = IPV6_ICMPV6_HEADER;
01664 
01665    //Calculate ICMPv6 header checksum
01666    message->checksum = ipCalcUpperLayerChecksumEx(&pseudoHeader,
01667       sizeof(Ipv6PseudoHeader), buffer, offset, length);
01668 
01669    //Debug message
01670    TRACE_INFO("Sending Neighbor Advertisement message (%" PRIuSIZE " bytes)...\r\n", length);
01671    //Dump message contents for debugging purpose
01672    ndpDumpNeighborAdvMessage(message);
01673 
01674    //Send Neighbor Advertisement message
01675    error = ipv6SendDatagram(interface, &pseudoHeader, buffer, offset, NDP_HOP_LIMIT);
01676 
01677    //Free previously allocated memory
01678    netBufferFree(buffer);
01679    //Return status code
01680    return error;
01681 }
01682 
01683 
01684 /**
01685  * @brief Send a Redirect message
01686  * @param[in] interface Underlying network interface
01687  * @param[in] targetAddr IPv6 address that is a better first hop to use
01688  *   for the destination address
01689  * @param[in] ipPacket Multi-part buffer that holds the IPv6 packet that
01690  *   triggered the sending of the Redirect
01691  * @param[in] ipPacketOffset Offset to the first byte of the IPv6 packet
01692  * @return Error code
01693  **/
01694 
01695 error_t ndpSendRedirect(NetInterface *interface, const Ipv6Addr *targetAddr,
01696    const NetBuffer *ipPacket, size_t ipPacketOffset)
01697 {
01698    error_t error;
01699    size_t offset;
01700    size_t length;
01701    size_t ipPacketLength;
01702    size_t optionLength;
01703    size_t paddingLength;
01704    NetBuffer *buffer;
01705    NdpRedirectMessage *message;
01706    NdpRedirectedHeaderOption *option;
01707    NdpNeighborCacheEntry *entry;
01708    Ipv6Header *ipHeader;
01709    Ipv6PseudoHeader pseudoHeader;
01710    uint8_t padding[8];
01711 
01712    //Retrieve the length of the forwarded IPv6 packet
01713    ipPacketLength = netBufferGetLength(ipPacket) - ipPacketOffset;
01714 
01715    //Check the length of the IPv6 packet
01716    if(ipPacketLength < sizeof(Ipv6Header))
01717       return ERROR_INVALID_LENGTH;
01718 
01719    //Point to the header of the invoking packet
01720    ipHeader = netBufferAt(ipPacket, ipPacketOffset);
01721    //Sanity check
01722    if(ipHeader == NULL)
01723       return ERROR_FAILURE;
01724 
01725    //The only defined options that may appear in a Redirect message are the
01726    //Target Link-Layer Address option and the Redirected Header option
01727    length = sizeof(NdpRedirectMessage) + sizeof(NdpLinkLayerAddrOption) +
01728       sizeof(NdpRedirectedHeaderOption);
01729 
01730    //Allocate a memory buffer to hold the Redirect message
01731    buffer = ipAllocBuffer(length, &offset);
01732    //Failed to allocate memory?
01733    if(buffer == NULL)
01734       return ERROR_OUT_OF_MEMORY;
01735 
01736    //Point to the beginning of the message
01737    message = netBufferAt(buffer, offset);
01738 
01739    //Format Redirect message
01740    message->type = ICMPV6_TYPE_REDIRECT;
01741    message->code = 0;
01742    message->checksum = 0;
01743    message->reserved = 0;
01744    message->targetAddr = *targetAddr;
01745    message->destAddr = ipHeader->destAddr;
01746 
01747    //Length of the message, excluding any option
01748    length = sizeof(NdpRedirectMessage);
01749 
01750    //Search the Neighbor cache for the specified target address
01751    entry = ndpFindNeighborCacheEntry(interface, targetAddr);
01752 
01753    //Include the link-layer address of the target, if known
01754    if(entry != NULL)
01755    {
01756       //Add Target Link-Layer Address option
01757       ndpAddOption(message, &length, NDP_OPT_TARGET_LINK_LAYER_ADDR,
01758          &entry->macAddr, sizeof(MacAddr));
01759    }
01760 
01761    //Retrieve the length of the IPv6 packet that triggered the sending
01762    //of the Redirect
01763    ipPacketLength = netBufferGetLength(ipPacket) - ipPacketOffset;
01764 
01765    //Return as much of the forwarded IPv6 packet as can fit without
01766    //the redirect packet exceeding the minimum IPv6 MTU
01767    ipPacketLength = MIN(ipPacketLength, IPV6_DEFAULT_MTU -
01768       sizeof(NdpRedirectedHeaderOption) - length);
01769 
01770    //Length of the Redirected Header option in units of 8 bytes including
01771    //the type and length fields
01772    optionLength = (ipPacketLength + sizeof(NdpOption) + 7) / 8;
01773 
01774    //Add Redirected Header option
01775    option = (NdpRedirectedHeaderOption *) ((uint8_t *) message + length);
01776 
01777    //Format Redirected Header option
01778    option->type = NDP_OPT_REDIRECTED_HEADER;
01779    option->length = (uint8_t) optionLength;
01780    option->reserved1 = 0;
01781    option->reserved2 = 0;
01782 
01783    //Update the length of Redirect message
01784    length += sizeof(NdpRedirectedHeaderOption);
01785 
01786    //Adjust the length of the multi-part buffer
01787    netBufferSetLength(buffer, offset + length);
01788 
01789    //Copy the contents of the forwarded IPv6 packet
01790    error = netBufferConcat(buffer, ipPacket, ipPacketOffset, ipPacketLength);
01791 
01792    //Check status code
01793    if(!error)
01794    {
01795       //Options should be padded when necessary to ensure that they end on
01796       //their natural 64-bit boundaries
01797       if((ipPacketLength + sizeof(NdpRedirectedHeaderOption)) < (optionLength * 8))
01798       {
01799          //Determine the amount of padding data to append
01800          paddingLength = (optionLength * 8) - ipPacketLength -
01801             sizeof(NdpRedirectedHeaderOption);
01802 
01803          //Prepare padding data
01804          memset(padding, 0, paddingLength);
01805          //Append padding bytes
01806          error = netBufferAppend(buffer, padding, paddingLength);
01807       }
01808    }
01809 
01810    //Check status code
01811    if(!error)
01812    {
01813       //Get the length of the resulting message
01814       length = netBufferGetLength(buffer) - offset;
01815 
01816       //Format IPv6 pseudo header
01817       pseudoHeader.srcAddr = interface->ipv6Context.addrList[0].addr;
01818       pseudoHeader.destAddr = ipHeader->srcAddr;
01819       pseudoHeader.length = htonl(length);
01820       pseudoHeader.reserved = 0;
01821       pseudoHeader.nextHeader = IPV6_ICMPV6_HEADER;
01822 
01823       //Message checksum calculation
01824       message->checksum = ipCalcUpperLayerChecksumEx(&pseudoHeader,
01825          sizeof(Ipv6PseudoHeader), buffer, offset, length);
01826 
01827       //Debug message
01828       TRACE_INFO("Sending Redirect message (%" PRIuSIZE " bytes)...\r\n", length);
01829       //Dump message contents for debugging purpose
01830       ndpDumpRedirectMessage(message);
01831 
01832       //Send Redirect message
01833       error = ipv6SendDatagram(interface, &pseudoHeader, buffer, offset, NDP_HOP_LIMIT);
01834    }
01835 
01836    //Free previously allocated memory
01837    netBufferFree(buffer);
01838 
01839    //Return status code
01840    return error;
01841 }
01842 
01843 
01844 /**
01845  * @brief Dump Router Solicitation message for debugging purpose
01846  * @param[in] message Router Solicitation message
01847  **/
01848 
01849 void ndpDumpRouterSolMessage(const NdpRouterSolMessage *message)
01850 {
01851    //Dump Router Solicitation message
01852    TRACE_DEBUG("  Type = %" PRIu8 "\r\n", message->type);
01853    TRACE_DEBUG("  Code = %" PRIu8 "\r\n", message->code);
01854    TRACE_DEBUG("  Checksum = 0x%04" PRIX16 "\r\n", ntohs(message->checksum));
01855 }
01856 
01857 
01858 /**
01859  * @brief Dump Router Advertisement message for debugging purpose
01860  * @param[in] message Router Advertisement message
01861  **/
01862 
01863 void ndpDumpRouterAdvMessage(const NdpRouterAdvMessage *message)
01864 {
01865    //Dump Router Advertisement message
01866    TRACE_DEBUG("  Type = %" PRIu8 "\r\n", message->type);
01867    TRACE_DEBUG("  Code = %" PRIu8 "\r\n", message->code);
01868    TRACE_DEBUG("  Checksum = 0x%04" PRIX16 "\r\n", ntohs(message->checksum));
01869    TRACE_DEBUG("  Cur Hop Limit = %" PRIu8 "\r\n", message->curHopLimit);
01870    TRACE_DEBUG("  M = %" PRIu8 "\r\n", message->m);
01871    TRACE_DEBUG("  O = %" PRIu8 "\r\n", message->o);
01872    TRACE_DEBUG("  Router Lifetime = %" PRIu16 "\r\n", ntohs(message->routerLifetime));
01873    TRACE_DEBUG("  Reachable Time = %" PRIu32 "\r\n", ntohl(message->reachableTime));
01874    TRACE_DEBUG("  Retrans Timer = %" PRIu32 "\r\n", ntohl(message->retransTimer));
01875 }
01876 
01877 
01878 /**
01879  * @brief Dump Neighbor Solicitation message for debugging purpose
01880  * @param[in] message Neighbor Solicitation message
01881  **/
01882 
01883 void ndpDumpNeighborSolMessage(const NdpNeighborSolMessage *message)
01884 {
01885    //Dump Neighbor Solicitation message
01886    TRACE_DEBUG("  Type = %" PRIu8 "\r\n", message->type);
01887    TRACE_DEBUG("  Code = %" PRIu8 "\r\n", message->code);
01888    TRACE_DEBUG("  Checksum = 0x%04" PRIX16 "\r\n", ntohs(message->checksum));
01889    TRACE_DEBUG("  Target Address = %s\r\n", ipv6AddrToString(&message->targetAddr, NULL));
01890 }
01891 
01892 
01893 /**
01894  * @brief Dump Neighbor Advertisement message for debugging purpose
01895  * @param[in] message Neighbor Advertisement message
01896  **/
01897 
01898 void ndpDumpNeighborAdvMessage(const NdpNeighborAdvMessage *message)
01899 {
01900    //Dump Neighbor Advertisement message
01901    TRACE_DEBUG("  Type = %" PRIu8 "\r\n", message->type);
01902    TRACE_DEBUG("  Code = %" PRIu8 "\r\n", message->code);
01903    TRACE_DEBUG("  Checksum = 0x%04" PRIX16 "\r\n", ntohs(message->checksum));
01904    TRACE_DEBUG("  R = %" PRIu8 "\r\n", message->r);
01905    TRACE_DEBUG("  S = %" PRIu8 "\r\n", message->s);
01906    TRACE_DEBUG("  O = %" PRIu8 "\r\n", message->o);
01907    TRACE_DEBUG("  Target Address = %s\r\n", ipv6AddrToString(&message->targetAddr, NULL));
01908 }
01909 
01910 
01911 /**
01912  * @brief Dump Redirect message for debugging purpose
01913  * @param[in] message Redirect message
01914  **/
01915 
01916 void ndpDumpRedirectMessage(const NdpRedirectMessage *message)
01917 {
01918    //Dump Neighbor Advertisement message
01919    TRACE_DEBUG("  Type = %" PRIu8 "\r\n", message->type);
01920    TRACE_DEBUG("  Code = %" PRIu8 "\r\n", message->code);
01921    TRACE_DEBUG("  Checksum = 0x%04" PRIX16 "\r\n", ntohs(message->checksum));
01922    TRACE_DEBUG("  Target Address = %s\r\n", ipv6AddrToString(&message->targetAddr, NULL));
01923    TRACE_DEBUG("  Destination Address = %s\r\n", ipv6AddrToString(&message->destAddr, NULL));
01924 }
01925 
01926 #endif
01927