Knight KE / Mbed OS Game_Master
Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers rpl_data.c Source File

rpl_data.c

00001 /*
00002  * Copyright (c) 2015-2017, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 /* rpl_data.c deals with handling of the packet data (hop-by-hop header)
00019  * and Source Routing headers in RPL-routed packets.
00020  *
00021  * rpl_domain_t is accessible, but not normally manipulated - all routines in
00022  * this file works on a specific instance.
00023  *
00024  * rpl_instance_t, rpl_dodag_t, rpl_dodag_version_t, rpl_neighbour_t are all accessible.
00025  */
00026 
00027 #include "nsconfig.h"
00028 
00029 #ifdef HAVE_RPL
00030 
00031 #include "common_functions.h"
00032 #include "nsdynmemLIB.h"
00033 #include "ns_trace.h"
00034 #include <string.h>
00035 
00036 #include "Core/include/ns_buffer.h"
00037 #include "NWK_INTERFACE/Include/protocol.h"
00038 #include "NWK_INTERFACE/Include/protocol_stats.h"
00039 #include "Common_Protocols/ipv6.h"
00040 #include "Common_Protocols/ipv6_resolution.h"
00041 #include "Common_Protocols/icmpv6.h"
00042 
00043 #include "RPL/rpl_protocol.h"
00044 #include "RPL/rpl_upward.h"
00045 #include "RPL/rpl_downward.h"
00046 #include "RPL/rpl_structures.h"
00047 #include "RPL/rpl_policy.h"
00048 #include "RPL/rpl_data.h"
00049 
00050 #define TRACE_GROUP "RPLa"
00051 
00052 #define RPL_DATA_SR_INIT_SIZE (16*4)
00053 
00054 #ifdef HAVE_RPL_ROOT
00055 typedef struct rpl_data_sr {
00056     rpl_dao_target_t *target;   /* Target - note may be a prefix */
00057     uint16_t iaddr_size;
00058     uint8_t ihops;          /* Number of intermediate hops (= addresses in SRH) */
00059     uint8_t final_dest[16]; /* Final destination (used only temporarily during header construction) */
00060     uint8_t iaddr[];        /* Intermediate address list is built backwards, contiguous with final_dest */
00061 } rpl_data_sr_t;
00062 
00063 static rpl_data_sr_t *rpl_data_sr;
00064 #endif
00065 
00066 static const uint8_t *rpl_data_get_dodagid(const buffer_t *buf);
00067 
00068 bool rpl_data_is_rpl_route(ipv6_route_src_t source) {
00069     switch (source) {
00070         case ROUTE_RPL_DAO:
00071         case ROUTE_RPL_DAO_SR:
00072         case ROUTE_RPL_SRH:
00073         case ROUTE_RPL_DIO:
00074         case ROUTE_RPL_INSTANCE:
00075         case ROUTE_RPL_ROOT:
00076         case ROUTE_RPL_FWD_ERROR:
00077             return true;
00078         default:
00079             return false;
00080     }
00081 }
00082 
00083 bool rpl_data_is_rpl_parent_route(ipv6_route_src_t source) {
00084     switch (source) {
00085         case ROUTE_RPL_DIO:
00086         case ROUTE_RPL_INSTANCE:
00087         case ROUTE_RPL_ROOT:
00088             return true;
00089         default:
00090             return false;
00091     }
00092 }
00093 
00094 static bool rpl_data_is_rpl_downward_route(ipv6_route_src_t source) {
00095     switch (source) {
00096         case ROUTE_RPL_DAO:
00097         case ROUTE_RPL_DAO_SR:
00098         case ROUTE_RPL_SRH:
00099             return true;
00100         default:
00101             return false;
00102     }
00103 }
00104 
00105 static bool rpl_data_handle_fwd_error(buffer_t *buf, protocol_interface_info_entry_t *cur, uint8_t *opt, const sockaddr_t *ll_src)
00106 {
00107     if (!ll_src) {
00108         tr_warn("Forwarding-Error - dst=%s, neighbour unknown", trace_ipv6(buf->dst_sa .address ));
00109         return false;
00110     } else {
00111         tr_warn("Forwarding-Error - dst=%s, neighbour=%s", trace_ipv6(buf->dst_sa .address ), trace_sockaddr(ll_src, true));
00112     }
00113 
00114     rpl_instance_t *instance = rpl_lookup_instance(cur->rpl_domain, opt[1], rpl_data_get_dodagid(buf));
00115     if (!instance) {
00116         return false;
00117     }
00118 
00119 #if 1
00120     return false;
00121 #else
00122     /* Work needed */
00123     if (rpl_instance_am_root(instance)) {
00124         /* We are looking for a target that has us as its transit */
00125     }
00126     bool deleted = ipv6_route_delete_by_info_and_ll(buf->dst_sa .address , ROUTE_RPL_DAO, ll_src);
00127     deleted |= ipv6_route_delete_by_info_and_ll(buf->dst_sa .address , ROUTE_RPL_DAO_SR, ll_src);
00128     opt[0] &=~ RPL_OPT_FWD_ERROR;
00129 
00130     return true;
00131 #endif
00132 }
00133 
00134 bool rpl_data_process_hbh(buffer_t *buf, protocol_interface_info_entry_t *cur, uint8_t *opt, const sockaddr_t *ll_src)
00135 {
00136     buf->rpl_instance = opt[1];
00137     buf->rpl_instance_known = true;
00138 
00139     /* Act on the forwarding error */
00140     if (opt[0] & RPL_OPT_FWD_ERROR) {
00141         if (!rpl_data_handle_fwd_error(buf, cur, opt, ll_src)) {
00142             return false;
00143         }
00144      }
00145 
00146     /* We don't actually do much now. If the packet is addressed
00147      * to us, we don't need really need much (or any) info.
00148      *
00149      * If we are going to forward forwarding_down will find the option
00150      * manually. If we come to unwrap the tunnel, then we need to take a
00151      * copy before the outer IP header is stripped.
00152      */
00153     buf->options .ip_extflags  |= IPEXT_HBH_RPL;
00154     buf->options .need_predecessor  = true;
00155     buf->rpl_flag_error = opt[0];
00156 
00157     return true;
00158 }
00159 
00160 /* We assume the packet is basically well-formed, as it will have either
00161  * cleared initial input parsing, or we formed it ourselves. hbh and srh
00162  * are set to point to the RPL Hop-by-Hop option and/or RPL Source Routing
00163  * Header, if present.
00164  */
00165 static void rpl_data_locate_info(buffer_t *buf, uint8_t **hbh, uint8_t **srh)
00166 {
00167     uint8_t *ptr = buffer_data_pointer(buf);
00168     uint16_t len = buffer_data_length(buf);
00169 
00170     if (hbh) {
00171         *hbh = NULL;
00172     }
00173     if (srh) {
00174         *srh = NULL;
00175     }
00176 
00177     if (len < IPV6_HDRLEN) {
00178         return;
00179     }
00180     uint16_t ip_len = common_read_16_bit(ptr + IPV6_HDROFF_PAYLOAD_LENGTH);
00181     uint8_t nh = ptr[6];
00182     ptr += IPV6_HDRLEN;
00183     len -= IPV6_HDRLEN;
00184     if (ip_len > len) {
00185         return;
00186     }
00187     len = ip_len;
00188     while (len) {
00189         uint16_t hdrlen;
00190         switch (nh) {
00191             case IPV6_NH_HOP_BY_HOP:
00192             {
00193                 if (len < 8) {
00194                     return;
00195                 }
00196                 nh = ptr[0];
00197                 hdrlen = (ptr[1] + 1) * 8;
00198                 /* Move on if they're not interested in HbH (looking for SRH) */
00199                 if (!hbh) {
00200                     break;
00201                 }
00202                 if (hdrlen > len) {
00203                     return;
00204                 }
00205                 uint8_t *opt_ptr = ptr + 2;
00206                 uint8_t *opt_end = ptr + hdrlen;
00207                 while (opt_ptr < opt_end) {
00208                     switch (opt_ptr[0]) {
00209                         case IPV6_OPTION_PAD1:
00210                             opt_ptr++;
00211                             break;
00212                         case IPV6_OPTION_RPL:
00213                             *hbh = opt_ptr;
00214                             goto found_option;
00215                         default:
00216                             opt_ptr += 2 + opt_ptr[1];
00217                             break;
00218                     }
00219                 }
00220             found_option:
00221                 /* If they're not looking for SRH, finish now */
00222                 if (!srh) {
00223                     return;
00224                 }
00225                 break;
00226             }
00227             case IPV6_NH_DEST_OPT:
00228                 // Destination option permitted to appear before routing
00229                 if (len < 8) {
00230                     return;
00231                 }
00232                 nh = ptr[0];
00233                 hdrlen = (ptr[1] + 1) * 8;
00234                 /* If they're not looking for SRH, finish now - past HbH */
00235                 if (!srh) {
00236                     return;
00237                 }
00238                 break;
00239             case IPV6_NH_ROUTING:
00240                 if (!srh) {
00241                     return;
00242                 }
00243                 if (ptr[2] == IPV6_ROUTING_TYPE_RPL) {
00244                     *srh = ptr;
00245                 }
00246                 // No need to examine past routing header
00247                 return;
00248             default:
00249                 // No other headers can appear before routing - last we care about
00250                 return;
00251         }
00252         if (hdrlen > len) {
00253             return;
00254         }
00255         ptr += hdrlen;
00256         len -= hdrlen;
00257     }
00258     return;
00259 }
00260 
00261 bool rpl_data_remember_outer(buffer_t *buf)
00262 {
00263     /* We're stripping the IP header - need the HBH header for future reference */
00264      uint8_t *hbh;
00265      rpl_data_locate_info(buf, &hbh, NULL);
00266      if (hbh) {
00267          uint8_t instance_id = hbh[3];
00268          /* For local instances, also need to extract the DODAG ID from src/dst */
00269          bool local = rpl_instance_id_is_local(instance_id);
00270          /* Copy the length byte and the option data (and optionally DODAG ID) */
00271          buf->rpl_option = ns_dyn_mem_temporary_alloc(hbh[1] + 1 + (local ? 16 : 0));
00272          if (buf->rpl_option) {
00273              memcpy(buf->rpl_option, hbh + 1, hbh[1] + 1);
00274              if (local) {
00275                  uint8_t *dodagid = instance_id & RPL_INSTANCE_DEST ? buf->dst_sa .address  : buf->src_sa .address ;
00276                  memcpy(buf->rpl_option + hbh[1] + 1, dodagid, 16);
00277              }
00278          }
00279      }
00280 
00281      if ((buf->options .ip_extflags  & IPEXT_HBH_RPL) && !buf->rpl_option) {
00282          tr_warn("RPL tunnel exit HbH fail");
00283          return false;
00284      }
00285 
00286      return true;
00287 }
00288 
00289 /* Get the DODAG ID if it's a local DODAG packet */
00290 static const uint8_t *rpl_data_get_dodagid(const buffer_t *buf)
00291 {
00292     if (!buf->rpl_instance_known || rpl_instance_id_is_global(buf->rpl_instance)) {
00293         return NULL;
00294     }
00295     /* rpl_data_remember_outer() stores it in the rpl_option metatdata */
00296     if (buf->rpl_option) {
00297         return buf->rpl_option + 1 + buf->rpl_option[1];
00298     }
00299     else {
00300         return buf->rpl_instance & RPL_INSTANCE_DEST ? buf->dst_sa .address 
00301                                                      : buf->src_sa .address ;
00302     }
00303 }
00304 
00305 /*
00306  *   0                   1                   2                   3
00307  *   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
00308  *                                  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00309  *                                  |  Option Type  |  Opt Data Len |
00310  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00311  *  |O|R|F|0|0|0|0|0| RPLInstanceID |          SenderRank           |
00312  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00313  *  |                         (sub-TLVs)                            |
00314  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00315  *
00316  *                     Figure 1: RPL Option
00317  */
00318 static buffer_t *rpl_data_exthdr_provider_hbh_2(buffer_t *buf, rpl_instance_t *instance, rpl_neighbour_t *neighbour, ipv6_exthdr_stage_t stage, int16_t *result)
00319 {
00320     ipv6_route_info_t *route_info = &buf->route->route_info;
00321 
00322     /* This can be called both for routes which only use HbH headers (eg DIO)
00323      * as well as one-hop DAO_SR routes which would normally use source routing
00324      * headers, if there was more than one hop. For DAO_SR, neighbour will be
00325      * NULL.
00326      */
00327 
00328     rpl_dodag_t *dodag = rpl_instance_current_dodag(instance);
00329     if (!dodag) {
00330         *result = -1;
00331         return buf;
00332     }
00333 
00334     bool destination_in_instance = false;
00335     uint16_t ext_size = 0;
00336     if (addr_ipv6_equal(route_info->next_hop_addr, buf->dst_sa .address ) ||
00337         addr_ipv6_equal(buf->dst_sa .address , dodag->id)) {
00338         destination_in_instance = true;
00339 
00340         if (buf->rpl_option) {
00341             /* Forwarding an existing option - preserve it */
00342             uint8_t opt_size = buf->rpl_option[0];
00343             ext_size = 2 + opt_size;
00344             ext_size = (ext_size + 7) &~ 7;
00345         } else {
00346             /* Generating our own option - fixed size, no TLVs */
00347             ext_size = 8;
00348         }
00349     }
00350 
00351     switch (stage) {
00352         case IPV6_EXTHDR_SIZE:
00353             *result = ext_size;
00354             return buf;
00355 
00356         case IPV6_EXTHDR_INSERT: {
00357             if (!destination_in_instance) {
00358                 /* We don't add a header - we'll do it on the tunnel */
00359                 *result = 0;
00360                 return buf;
00361             }
00362             buf = buffer_headroom(buf, ext_size);
00363             if (!buf) {
00364                 return NULL;
00365             }
00366             uint8_t *ext = buffer_data_reserve_header(buf, ext_size);
00367             ext[0] = buf->options .type ;
00368             buf->options .type  = IPV6_NH_HOP_BY_HOP;
00369             ext[1] = ext_size / 8 - 1;
00370             uint8_t *opt = ext + 2;
00371             opt[0] = IPV6_OPTION_RPL;
00372             if (buf->rpl_option) {
00373                 /* Get back the RPL option we stripped off an outer IP header */
00374                 memcpy(opt + 1, buf->rpl_option, 1 + buf->rpl_option[0]);
00375                 ns_dyn_mem_free(buf->rpl_option);
00376                 buf->rpl_option = NULL;
00377             } else {
00378                 opt[1] = 4; // option length
00379                 opt[2] = 0; // placeholder
00380                 opt[3] = instance->id;
00381                 /* For upwards routes we can deduce that DODAGID must be
00382                  * the destination, so set the D flag.
00383                  */
00384                 if (rpl_instance_id_is_local(instance->id) && !rpl_data_is_rpl_downward_route(route_info->source)) {
00385                     opt[3] |= RPL_INSTANCE_DEST;
00386                 }
00387                 common_write_16_bit(RPL_RANK_INFINITE, opt + 4); // SenderRank (placeholder)
00388             }
00389             /* Pad HbH header if necessary. */
00390             uint8_t pad_len = ext + ext_size - (opt + 2 + opt[1]);
00391             if (pad_len == 1) {
00392                 opt[0] = IPV6_OPTION_PAD1;
00393             } else if (pad_len > 1) {
00394                 opt[0] = IPV6_OPTION_PADN;
00395                 opt[1] = pad_len - 2;
00396                 memset(opt + 2, 0, pad_len - 2);
00397             }
00398             // don't forget to set the "RPL option present" marker
00399             buf->options .ip_extflags  |= IPEXT_HBH_RPL;
00400             *result = 0;
00401             return buf;
00402         }
00403 
00404         case IPV6_EXTHDR_MODIFY: {
00405             uint8_t *opt;
00406             uint16_t sender_rank;
00407 
00408             rpl_data_locate_info(buf, &opt, NULL);
00409             if (!opt) {
00410                 *result = IPV6_EXTHDR_MODIFY_TUNNEL;
00411                 // Tunnel to next hop in general case, but if going to DODAGID,
00412                 // it can tunnel all the way (and it HAS to if it is a local
00413                 // DODAG).
00414                 if (!addr_ipv6_equal(buf->dst_sa .address , dodag->id)) {
00415                     memcpy(buf->dst_sa .address , route_info->next_hop_addr, 16);
00416                 }
00417                 buf->src_sa .addr_type  = ADDR_NONE ; // force auto-selection
00418                 return buf;
00419             }
00420 
00421             if (buf->ip_routed_up) {
00422                 /* Check for rank errors - RFC 6550 11.2.2.2. */
00423                 /* Note that RPL spec does not say that packets from nodes of
00424                  * equal rank are errors, but we treat them as such to get
00425                  * reliable sibling loop detection - we require sender rank to be
00426                  * strictly less for Down packets and strictly greater for Up.
00427                  */
00428                 sender_rank = common_read_16_bit(opt + 4);
00429                 rpl_cmp_t cmp = rpl_rank_compare_dagrank_rank(dodag, sender_rank, instance->current_rank);
00430                 rpl_cmp_t expected_cmp = (opt[2] & RPL_OPT_DOWN) ? RPL_CMP_LESS : RPL_CMP_GREATER;
00431                 if (cmp != expected_cmp) {
00432                     /* Set the Rank-Error bit; if already set, drop */
00433                     if (opt[2] & RPL_OPT_RANK_ERROR) {
00434                         protocol_stats_update(STATS_RPL_ROUTELOOP, 1);
00435                         tr_info("Forwarding inconsistency R");
00436                         rpl_instance_inconsistency(instance);
00437                         *result = -1;
00438                         return buf;
00439                     } else {
00440                         opt[2] |= RPL_OPT_RANK_ERROR;
00441                     }
00442                 }
00443             }
00444 
00445             if (buf->rpl_flag_error & RPL_OPT_FWD_ERROR) {
00446                 opt[2] |= RPL_OPT_FWD_ERROR;
00447             } else if (rpl_data_is_rpl_downward_route(route_info->source)) {
00448                 opt[2] |= RPL_OPT_DOWN;
00449             } else {
00450                 opt[2] &= ~RPL_OPT_DOWN;
00451             }
00452 
00453             /* Set the D flag for local instances */
00454             if (rpl_instance_id_is_local(instance->id)) {
00455                 if (addr_ipv6_equal(dodag->id, buf->dst_sa .address )) {
00456                     opt[3] |= RPL_INSTANCE_DEST;
00457                 } else if (addr_ipv6_equal(dodag->id, buf->src_sa .address )) {
00458                     opt[3] &=~ RPL_INSTANCE_DEST;
00459                 } else {
00460                     tr_error("Local instance invalid %s[%d]: %s -> %s", trace_ipv6(dodag->id), instance->id, trace_ipv6(buf->src_sa .address ), trace_ipv6(buf->dst_sa .address ));
00461                     *result = -1;
00462                     return buf;
00463                 }
00464             }
00465 
00466             /* RPL 11.2.2.2. says we set SenderRank to infinite when forwarding
00467              * across a version discontinuity. (Must be up - we don't know versions
00468              * of downward routes).
00469              */
00470             if ((buf->rpl_flag_error & RPL_OPT_FWD_ERROR) || rpl_data_is_rpl_downward_route(route_info->source) || !neighbour || neighbour->dodag_version == instance->current_dodag_version) {
00471                 sender_rank = nrpl_dag_rank(dodag, instance->current_rank);
00472             } else {
00473                 sender_rank = RPL_RANK_INFINITE;
00474             }
00475             common_write_16_bit(sender_rank, opt + 4);
00476             *result = 0;
00477             return buf;
00478         }
00479         default:
00480             return buffer_free(buf);
00481     }
00482 }
00483 
00484 static buffer_t *rpl_data_exthdr_provider_hbh(buffer_t *buf, ipv6_exthdr_stage_t stage, int16_t *result)
00485 {
00486     ipv6_route_info_t *route_info = &buf->route->route_info;
00487     rpl_neighbour_t *neighbour = route_info->info;
00488 
00489     rpl_instance_t *instance = rpl_neighbour_instance(neighbour);
00490     if (!instance) {
00491         *result = -1;
00492         return buf;
00493     }
00494 
00495     return rpl_data_exthdr_provider_hbh_2(buf, instance, neighbour, stage, result);
00496 }
00497 
00498 static buffer_t *rpl_data_exthdr_provider_fwd_error_hbh(buffer_t *buf, ipv6_exthdr_stage_t stage, int16_t *result)
00499 {
00500     ipv6_route_info_t *route_info = &buf->route->route_info;
00501     rpl_instance_t *instance =route_info->info;
00502 
00503     return rpl_data_exthdr_provider_hbh_2(buf, instance, NULL, stage, result);
00504 
00505 }
00506 
00507 /* This could live in address.c or ipv6.c */
00508 /* Can get false negatives if we don't already have a neighbour cache entry, but in practice
00509  * will be solid as we are basically matching link-local 6LoWPAN addresses, which can be mapped
00510  * to link-layer without an existing entry. Could conceivably get a false positive if we have
00511  * a stale entry and MAC addresses have been reassigned, but very unlikely.
00512  */
00513 static bool rpl_downward_ip_addr_matches_ll_addr(protocol_interface_info_entry_t *cur, const uint8_t ip_addr_a[static 16], const sockaddr_t *ll_addr_b)
00514 {
00515     if (!ll_addr_b) {
00516         return false;
00517     }
00518     addrtype_t ll_type_a;
00519     const uint8_t *ll_addr_a;
00520     if (!ipv6_map_ip_to_ll(cur, NULL, ip_addr_a, &ll_type_a, &ll_addr_a)) {
00521         return false;
00522     }
00523 
00524     return ll_type_a == ll_addr_b->addr_type  &&
00525            memcmp(ll_addr_a, ll_addr_b->address , addr_len_from_type(ll_type_a)) == 0;
00526 }
00527 
00528 /* ROUTE_RPL_INSTANCE routes are the default for the instance - not valid, unless
00529  * instance is already known.
00530  */
00531 static bool rpl_data_route_predicate_instance_default(const ipv6_route_info_t *route, bool valid)
00532 {
00533     (void)route;
00534     (void)valid;
00535 
00536     return false;
00537 }
00538 
00539 static rpl_instance_t *predicate_instance;
00540 static bool predicate_down;
00541 static const sockaddr_t *predicate_predecessor;
00542 
00543 /* Override predicate for choosing routes given a specific instance (ie when
00544  * forwarding a packet that had a specified instance ID). That instance is
00545  * loaded into the static predicate_instance above.
00546  */
00547 static bool rpl_data_route_predicate_specific_instance(const ipv6_route_info_t *route, bool valid)
00548 {
00549     /* We will permit forwarding out of RPL into a non-RPL interface (eg border routers) */
00550     /* XXX - what if we're the boundary between two RPL domains? */
00551     protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(route->interface_id);
00552     if (!cur || !cur->rpl_domain) {
00553         return valid;
00554     }
00555 
00556     /* If forwarding onto the same interface, think more */
00557     switch (route->source) {
00558         /* These are the type of routes we will forward onto out of RPL - they
00559          * must include all types of non-owned routes that could be advertised
00560          * through a DAO.
00561          */
00562         case ROUTE_ARO:
00563             return valid;
00564 
00565         /* Upward routes */
00566         case ROUTE_RPL_DIO:
00567         case ROUTE_RPL_INSTANCE:
00568         case ROUTE_RPL_ROOT: {
00569             /* Packets going down can't go back up */
00570             if (predicate_down) {
00571                 return false;
00572             }
00573             /* Never route to predecessor */
00574             if (rpl_downward_ip_addr_matches_ll_addr(cur, route->next_hop_addr, predicate_predecessor)) {
00575                 return false;
00576             }
00577             /* Info for these upward routes is a back pointer to the neighbour */
00578             rpl_neighbour_t *neighbour = route->info;
00579             /* From there, we can get the instance info */
00580             rpl_instance_t *instance = rpl_neighbour_instance(neighbour);
00581             /* Note that this overrides the default "false" for INSTANCE routes */
00582             return instance == predicate_instance;
00583         }
00584 
00585         /* Downward routes */
00586         case ROUTE_RPL_DAO:
00587         case ROUTE_RPL_DAO_SR: {
00588             /* Info for these downward routes is a back pointer to the target */
00589             rpl_dao_target_t *target = route->info;
00590             /* Going to predecessor is fine if it was going up - we are reversing to down. Otherwise block */
00591             if (predicate_down) {
00592                 if (rpl_downward_ip_addr_matches_ll_addr(cur, route->next_hop_addr, predicate_predecessor)) {
00593                     return false;
00594                 }
00595             }
00596             return target->instance == predicate_instance;
00597         }
00598         /* Unknown */
00599         default:
00600             return false;
00601     }
00602 }
00603 
00604 ipv6_route_predicate_fn_t *rpl_data_get_route_predicate(rpl_domain_t *domain, const buffer_t *buf)
00605 {
00606     const uint8_t *dodagid = rpl_data_get_dodagid(buf);
00607 
00608     predicate_instance = rpl_lookup_instance(domain, buf->rpl_instance, dodagid);
00609     predicate_down = buf->rpl_flag_error & RPL_OPT_DOWN;
00610     predicate_predecessor = buf->predecessor ;
00611 
00612     return rpl_data_route_predicate_specific_instance;
00613 }
00614 
00615 /* Returns true if we are going to pass this back with the 'F' bit set */
00616 /* If we return false, a "no route" ICMP error will occur as normal */
00617 /* For the ICMP error case, we may treat as a DIO Trickle inconsistency, as
00618  * suggested by RFC 6550 11.1(8)  */
00619 bool rpl_data_forwarding_error(buffer_t *buf)
00620 {
00621     /* This is called when we have no route to send a packet - first check
00622      * if we were forwarding it for RPL - indicated by rpl_instance_known.
00623      */
00624     if (!buf->rpl_instance_known) {
00625         return false;
00626     }
00627 
00628     protocol_interface_info_entry_t *cur = buf->interface ;
00629     if (!cur) {
00630         return false;
00631     }
00632 
00633     rpl_instance_t *instance = rpl_lookup_instance(cur->rpl_domain, buf->rpl_instance, rpl_data_get_dodagid(buf));
00634     if (!instance) {
00635         tr_err("rpl_data_forwarding_error: unknown instance");
00636         return false;
00637     }
00638 
00639     /* To use Forwarding-Error, packet must be Down, and must know predecessor */
00640     if (!((buf->rpl_flag_error & RPL_OPT_DOWN) && buf->predecessor )) {
00641         goto not_forwarding_error;
00642     }
00643 
00644     /* Must then be able to map predecessor to IP address */
00645     uint8_t predecessor_ip[16];
00646     if (!ipv6_map_ll_to_ip_link_local(cur, buf->predecessor ->addr_type , buf->predecessor ->address , predecessor_ip)) {
00647         return false;
00648     }
00649 
00650     buf->rpl_flag_error |= RPL_OPT_FWD_ERROR;
00651     buffer_free_route(buf);
00652     if (!ipv6_buffer_route_to(buf, predecessor_ip, buf->interface )) {
00653         return false;
00654     }
00655 
00656     buf->route->route_info.info = instance;
00657     buf->route->route_info.source = ROUTE_RPL_FWD_ERROR;
00658 
00659     return true;
00660 
00661 not_forwarding_error:
00662     /* If we're not signalling a Forwarding-Error, we will be sending
00663      * an ICMP Destination Unreachable to the source as normal. But we
00664      * may still want to attempt some sort of RPL repair. If it was coming
00665      * upwards, and we're _not_ the root of the instance, a failure to
00666      * pass it on can only mean some sort of RPL routing problem (eg refusing
00667      * to pass to the predecessor), as we should normally be able to send
00668      * towards the DODAG root. We attempt to aid repair by triggering
00669      * a DIO inconsistency.
00670      *
00671      * If we are the root, then it will just be a perfectly normal
00672      * "destination unreachable" - it doesn't suggest a RPL repair is needed.
00673      */
00674     if (!(buf->rpl_flag_error & RPL_OPT_DOWN) && !rpl_instance_am_root(instance)) {
00675         protocol_stats_update(STATS_RPL_ROUTELOOP, 1);
00676         tr_info("Forwarding inconsistency 2");
00677         rpl_instance_inconsistency(instance);
00678     }
00679     return false;
00680 }
00681 
00682 #ifdef HAVE_RPL_ROOT
00683 /* TODO - every target involved here should be non-External. Add checks */
00684 static bool rpl_data_compute_source_route(const uint8_t *final_dest, rpl_dao_target_t * const target)
00685 {
00686     if (!rpl_data_sr) {
00687         rpl_data_sr = rpl_alloc(sizeof(rpl_data_sr_t) + RPL_DATA_SR_INIT_SIZE);
00688         if (!rpl_data_sr) {
00689             return false;
00690         }
00691         rpl_data_sr->iaddr_size = RPL_DATA_SR_INIT_SIZE;
00692         rpl_data_sr->target = NULL;
00693     } else if (rpl_data_sr->target == target && addr_ipv6_equal(rpl_data_sr->final_dest, final_dest)) {
00694         return true;
00695     }
00696 
00697     /* This does all the heavy lifting - after running, the optimum path from
00698      * every target node is at the front of the transit list, and the connected
00699      * flag is set if we've any prospect.
00700      */
00701     rpl_downward_compute_paths(target->instance);
00702     if (!target->connected) {
00703         return false;
00704     }
00705 
00706     /* Wipe the "data valid" marker */
00707     rpl_data_sr->target = NULL;
00708     rpl_data_sr->ihops = 0;
00709 
00710     /* Final destination written explicitly (last target could be a prefix) */
00711     memcpy(rpl_data_sr->final_dest, final_dest, 16);
00712 
00713     /* We just work backwards from the target, following the first transit
00714      * each time, which is the shortest path after the compute_paths call.
00715      */
00716     rpl_dao_target_t *t = target;
00717     for (;;) {
00718         /* First transit is best path, thanks to root computation above */
00719         rpl_dao_root_transit_t *transit = ns_list_get_first(&t->info.root.transits);
00720         rpl_dao_target_t *parent = transit->parent;
00721         /* Finished if we hit NULL - ourselves */
00722         if (parent == NULL) {
00723             /* Mark "valid" */
00724             rpl_data_sr->target = target;
00725             return true;
00726         }
00727         if (!parent->connected) {
00728             tr_err("Parent %s disconnected", trace_ipv6_prefix(parent->prefix, parent->prefix_len));
00729             return false;
00730         }
00731         /* Check transit address isn't already in table. Should not be possible */
00732         for (int i = 16 * rpl_data_sr->ihops; i >= 0; i -= 16){
00733             if (addr_ipv6_equal(rpl_data_sr->final_dest + i, transit->transit)) {
00734                 protocol_stats_update(STATS_RPL_ROUTELOOP, 1);
00735                 tr_err("SR loop %s->%s", trace_ipv6_prefix(t->prefix, t->prefix_len), trace_ipv6(transit->transit));
00736                 return false;
00737             }
00738         }
00739         /* Increase size of table if necessary */
00740         if (16 * (rpl_data_sr->ihops + 1) > rpl_data_sr->iaddr_size) {
00741             rpl_data_sr = rpl_realloc(rpl_data_sr, sizeof(rpl_data_sr_t) + rpl_data_sr->iaddr_size, sizeof(rpl_data_sr_t) + 2 * rpl_data_sr->iaddr_size);
00742             if (!rpl_data_sr) {
00743                 return false;
00744             }
00745             rpl_data_sr->iaddr_size *= 2;
00746         }
00747         memcpy(rpl_data_sr->iaddr + 16 * rpl_data_sr->ihops, transit->transit, 16);
00748         rpl_data_sr->ihops += 1;
00749 
00750         t = parent;
00751     }
00752 }
00753 
00754 /* Return the next hop, if there is an intermediate. If it's direct, NULL
00755  * is returned. This call must follow a successful call to
00756  * rpl_data_compute_source_route().
00757  */
00758 const uint8_t *rpl_data_sr_next_hop(void)
00759 {
00760     if (rpl_data_sr->ihops == 0) {
00761         return NULL;
00762     }
00763     return rpl_data_sr->iaddr + 16 * (rpl_data_sr->ihops - 1);
00764 }
00765 
00766 static bool rpl_data_route_next_hop(const uint8_t *dest, ipv6_route_info_t *route)
00767 {
00768     rpl_dao_target_t *target = route->info;
00769 
00770     if (!rpl_data_compute_source_route(dest, target)) {
00771         return false;
00772     }
00773 
00774     const uint8_t *next_hop = rpl_data_sr_next_hop();
00775     if (next_hop) {
00776         memcpy(route->next_hop_addr, next_hop, 16);
00777     } else {
00778         memcpy(route->next_hop_addr, dest, 16);
00779     }
00780 
00781     return true;
00782 }
00783 
00784 void rpl_data_sr_invalidate(void)
00785 {
00786     if (rpl_data_sr) {
00787         rpl_data_sr->target = NULL;
00788         rpl_data_sr->ihops = 0;
00789     }
00790     /* We could invalidate the next hops remembered in the system routing table.
00791      * but it's not necessary - recomputation happens every time. Does mean that
00792      * the routing table printout may contain stale info, though.
00793      */
00794 }
00795 
00796 typedef struct rpl_srh_info
00797 {
00798     uint8_t hlen;
00799     uint8_t segments;
00800     uint8_t cmprI;
00801     uint8_t cmprE;
00802     uint8_t pad;
00803 } rpl_srh_info_t;
00804 
00805 /* Count matching bytes (max 15) for SRH compression */
00806 static uint_fast8_t rpl_data_matching_addr_bytes(const uint8_t *a, const uint8_t *b, uint_fast8_t len)
00807 {
00808     uint_fast8_t m = 0;
00809     while (m < len && a[m] == b[m]) {
00810         m++;
00811     }
00812     return m;
00813 }
00814 
00815 static const rpl_srh_info_t *rpl_data_sr_compute_header_size(const uint8_t final_dest[16], uint8_t hop_limit)
00816 {
00817     static rpl_srh_info_t info;
00818     uint8_t hops = 1 + rpl_data_sr->ihops;
00819     if (hops > hop_limit) {
00820         hops = hop_limit;
00821     }
00822     if (hops <= 1) {
00823         return NULL;
00824     }
00825     memcpy(rpl_data_sr->final_dest, final_dest, 16);
00826     /* first_hop is the address that will go into the IP destination */
00827     const uint8_t *first_hop = rpl_data_sr->iaddr + 16 * (rpl_data_sr->ihops - 1);
00828     /* addr is the first address for the SRH */
00829     const uint8_t *addr = first_hop - 16;
00830 
00831     /* Must be at least 2 hops, so at least 1 segment in the SRH */
00832     info.segments = hops - 1;
00833 
00834     /* First, scan for compression of all except last against initial destination */
00835     /* (CmprI bytes will remain unchanged at each hop, rest can change) */
00836     info.cmprI = 15;
00837     for (uint8_t seg = 0; seg < info.segments - 1; seg++) {
00838         info.cmprI = rpl_data_matching_addr_bytes(addr, first_hop, info.cmprI);
00839         hops--;
00840         addr -= 16;
00841     }
00842 
00843     /* Compress last hop against previous destination */
00844     /* Debatable whether we should let cmprE be > cmprI - it means the final
00845      * address won't be IP_dest[0:cmprI)+Address_n[cmprI:64) until the final
00846      * hop (segments left = 1):
00847      *
00848      *      CmprI = 14, CmprE = 15
00849      *      IP dest  Segs Left    Addresses
00850      *      x:1234      3            2345, 3456, 22 <- meaning "3422", not "1222"
00851      *      x:2345      2            1234, 3456, 22
00852      *      x:3456      1            1234, 2345, 22
00853      *      x:3422      0            1234, 2345, 56
00854      *
00855      * But then similar issues arise if cmprE < cmprI:
00856      *
00857      *      CmprI = 15, CmprE = 14
00858      *      IP dest  Segs Left    Addresses
00859      *      x:1234      3            45, 56, ABCD
00860      *      x:1245      2            34, 56, ABCD
00861      *      x:1256      1            34, 45, ABCD
00862      *      x:ABCD      0            34, 45, 1256  <- "45" means "1245", not "AB45"
00863      *
00864      * Basically, there's no loss of information, but it's not as straightforward
00865      * as RFC 6554 says. If cmprI != cmprE, not all Address entries represent
00866      * addresses with the same prefix as the IP destination at any given
00867      * instant. (But the next address to process does line up with the current
00868      * IP destination).
00869      *
00870      */
00871     info.cmprE = rpl_data_matching_addr_bytes(addr, addr + 16, 15 /* info.cmprI */);
00872 
00873     uint16_t total_size;
00874 
00875     total_size = (16 - info.cmprE) + (16 - info.cmprI) * (info.segments - 1);
00876     if (total_size & 7) {
00877         info.pad = 8 - (total_size & 7);
00878         total_size += info.pad;
00879     } else {
00880         info.pad = 0;
00881     }
00882     info.hlen = total_size >> 3;
00883 
00884     return &info;
00885 }
00886 
00887 /*
00888  *    0                   1                   2                   3
00889  *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
00890  *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00891  *   |  Next Header  |  Hdr Ext Len  | Routing Type  | Segments Left |
00892  *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00893  *   | CmprI | CmprE |  Pad  |               Reserved                |
00894  *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00895  *   |                                                               |
00896  *   .                                                               .
00897  *   .                        Addresses[1..n]                        .
00898  *   .                                                               .
00899  *   |                                                               |
00900  *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
00901  */
00902 static uint8_t *rpl_data_sr_write_header(const rpl_srh_info_t *info, uint8_t *ptr, uint8_t nh)
00903 {
00904     ptr[0] = nh;
00905     ptr[1] = info->hlen;
00906     ptr[2] = IPV6_ROUTING_TYPE_RPL;
00907     ptr[3] = info->segments;
00908     ptr[4] = (info->cmprI << 4) | info->cmprE;
00909     ptr[5] = (info->pad << 4);
00910     common_write_16_bit(0, ptr + 6);
00911     ptr += 8;
00912     const uint8_t *addr = rpl_data_sr->iaddr + 16 * (rpl_data_sr->ihops - 2);
00913     for (int n = 0; n < info->segments - 1; n++) {
00914         memcpy(ptr, addr + info->cmprI, 16 - info->cmprI);
00915         ptr += 16 - info->cmprI;
00916         addr -= 16;
00917     }
00918     memcpy(ptr, addr + info->cmprE, 16 - info->cmprE);
00919     ptr += 16 - info->cmprE;
00920     if (info->pad) {
00921         memset(ptr, 0, info->pad);
00922         ptr += info->pad;
00923     }
00924     return ptr;
00925 }
00926 
00927 static buffer_t *rpl_data_exthdr_provider_srh(buffer_t *buf, ipv6_exthdr_stage_t stage, int16_t *result)
00928 {
00929     ipv6_route_info_t *route_info = &buf->route->route_info;
00930     rpl_dao_target_t *target = route_info->info;
00931     rpl_instance_t *instance = target->instance;
00932     if (!instance) {
00933         *result = -1;
00934         return buf;
00935     }
00936 
00937     uint16_t ext_size = 0;
00938     const rpl_srh_info_t *srh_info = NULL;
00939 
00940     const uint8_t *final_rpl_dest = buf->dst_sa .address ;
00941 
00942     if (target->external) {
00943         /* If we haven't yet tunnelled, then there's no insertion */
00944         if (!buf->options .tunnelled ) {
00945             if (stage == IPV6_EXTHDR_SIZE || stage == IPV6_EXTHDR_INSERT) {
00946                 *result = 0;
00947                 return buf;
00948             }
00949         }
00950 
00951         /* If it's an external target, we need to only go as far as its transit */
00952         /* Modify target to point to that instead */
00953         rpl_dao_root_transit_t *transit = ns_list_get_first(&target->info.root.transits);
00954         if (!transit) {
00955             *result = -1;
00956             return buf;
00957         }
00958         final_rpl_dest = transit->transit;
00959         target = rpl_instance_match_dao_target(instance, final_rpl_dest, 128);
00960         if (!target) {
00961             *result = -1;
00962             return buf;
00963         }
00964     }
00965 
00966     if (!rpl_data_compute_source_route(final_rpl_dest, target)) {
00967         *result = -1;
00968         return buf;
00969     }
00970 
00971     /* When tunnelling (only), we truncate the route in the outer packet,
00972      * according to the hop limit, so it exits the tunnel at the hop limit -
00973      * that router will then generate "time exceeded" on the inner packet.
00974      * (RFC 6554 4.1). When not tunnelling, we include all hops regardless,
00975      * which means the final destination is there as needed.
00976      */
00977     srh_info = rpl_data_sr_compute_header_size(final_rpl_dest, buf->options .tunnelled  && buf->options .type  == IPV6_NH_IPV6 ? buf->options .hop_limit  : 0xFF);
00978     if (!srh_info) {
00979         /* No source routing header required - this must be because it's one hop. */
00980         /* In this case, we do need to add a HbH option header */
00981         return rpl_data_exthdr_provider_hbh_2(buf, instance, NULL, stage, result);
00982     }
00983     ext_size = 8 * (srh_info->hlen + 1);
00984 
00985     switch (stage) {
00986         case IPV6_EXTHDR_SIZE:
00987             *result = ext_size;
00988             return buf;
00989 
00990         case IPV6_EXTHDR_INSERT: {
00991             buf = buffer_headroom(buf, ext_size);
00992             if (!buf) {
00993                 return NULL;
00994             }
00995             uint8_t *ext = buffer_data_reserve_header(buf, ext_size);
00996             rpl_data_sr_write_header(srh_info, ext, buf->options .type );
00997             buf->route->ip_dest = rpl_data_sr_next_hop();
00998             buf->options .type  = IPV6_NH_ROUTING;
00999             // don't forget to set the "RPL option present" marker
01000             buf->options .ip_extflags  |= IPEXT_SRH_RPL;
01001             *result = 0;
01002             return buf;
01003         }
01004 
01005         case IPV6_EXTHDR_MODIFY:
01006             if (buf->options .ip_extflags  & IPEXT_SRH_RPL) {
01007                 *result = 0;
01008                 return buf;
01009             }
01010             if (final_rpl_dest != buf->dst_sa .address ) {
01011                 memcpy(buf->dst_sa .address , final_rpl_dest, 16);
01012             }
01013             *result = IPV6_EXTHDR_MODIFY_TUNNEL;
01014             buf->src_sa .addr_type  = ADDR_NONE ; // force auto-selection
01015             return buf;
01016 
01017         default:
01018             return buffer_free(buf);
01019     }
01020 }
01021 #endif // HAVE_RPL_ROOT
01022 
01023 buffer_t *rpl_data_process_routing_header(buffer_t *buf, protocol_interface_info_entry_t *cur, uint8_t *ptr, uint16_t *hdrlen_out, bool *forward_out)
01024 {
01025     /* Handling procedures based on RFC 6554 4.2 */
01026 
01027     /* Do not process RPL source routing headers unless they arrive on a RPL interface */
01028     if (!cur->rpl_domain) {
01029         tr_warn("SRH RX non-RPL if");
01030     drop:
01031         protocol_stats_update(STATS_IP_RX_DROP, 1);
01032         return buffer_free(buf);
01033     }
01034 
01035     buf->options .ip_extflags  |= IPEXT_SRH_RPL;
01036 
01037     uint16_t hlen = (ptr[1] + 1) * 8;
01038     uint8_t segs_left = ptr[3];
01039 
01040     if (segs_left == 0) {
01041         *hdrlen_out = hlen;
01042         return buf;
01043     }
01044     uint8_t cmprI = ptr[4] >> 4;
01045     uint8_t cmprE = ptr[4] & 0xF;
01046     uint8_t pad = ptr[5] >> 4;
01047 
01048 
01049     /* Should really be more rigorous here */
01050     uint_fast16_t n_addrs = ((hlen - 8 - pad - (16 - cmprE)) / (16 - cmprI)) + 1;
01051     if (segs_left > n_addrs) {
01052         return icmpv6_error(buf, cur, ICMPV6_TYPE_ERROR_PARAMETER_PROBLEM, ICMPV6_CODE_PARAM_PRB_HDR_ERR, (ptr + 3) - buffer_data_pointer(buf));
01053     }
01054 
01055     uint8_t *ip_dst = buffer_data_pointer(buf) + 24;
01056 
01057     /* Decrement segments left */
01058     segs_left = --ptr[3];
01059 
01060     if (addr_is_ipv6_multicast(buf->dst_sa .address )) {
01061         goto drop;
01062     }
01063 
01064     /* Next address index (starting at 1, as per RFC 6554) */
01065     uint_fast16_t next_addr_i = n_addrs - segs_left;
01066 
01067     /* Locate next address: aptr -> Address[i] */
01068     uint8_t *aptr = ptr + 8 + (next_addr_i - 1) * (16 - cmprI);
01069     uint8_t cmpr = next_addr_i == n_addrs ? cmprE : cmprI;
01070     uint8_t asize = 16 - cmpr;
01071 
01072     /* Next address can only be multicast if compression is 0, otherwise
01073      * it inherits an already-checked non-0xFF start byte from IP destination
01074      */
01075     if (cmpr == 0 && addr_is_ipv6_multicast(aptr)) {
01076         goto drop;
01077     }
01078 
01079     /* Look for a loop. Scanning all addresses 1..n would be a pain, given
01080      * the possibility of weird cmprI/E combinations. But there's logically
01081      * no need to look at _previous_ addresses. And we know the packet was
01082      * addressed to us to reach us - Address[i-1] must have been ours. So
01083      * to ensure we do the test in RFC 6554:
01084      *
01085      *    if 2 or more entries in Address[1..n] are assigned to
01086      *           local interface and are separated by at least one
01087      *           address not assigned to local interface
01088      *
01089      * We just check Address[i..n], knowing that i-1 was ours. It's impossible
01090      * for anything older than i-1 to be ours, as we would have failed the
01091      * check previously...
01092      *
01093      * There need to be at least 2 more addresses (i and i+1) for this check
01094      * to be useful.
01095      */
01096     if (next_addr_i + 1 <= n_addrs) {
01097         uint8_t addr[16];
01098         /* We know Address[i-1] was ours */
01099         bool prev_was_local = true;
01100         /* Initialise pointers to examine Address[i] */
01101         memcpy(addr, ip_dst, 16);
01102         const uint8_t *a = aptr;
01103         /* Then scan remaining */
01104         for (uint_fast16_t i = next_addr_i; i <= n_addrs; i++) {
01105             uint8_t cpr = i == n_addrs ? cmprE : cmprI;
01106             uint8_t asz = 16 - cpr;
01107             memcpy(addr + cpr, a, asz);
01108             a += asz;
01109             bool local_addr = addr_interface_address_compare(cur, addr) == 0;
01110             if (local_addr) {
01111                 if (!prev_was_local) {
01112                     protocol_stats_update(STATS_RPL_ROUTELOOP, 1);
01113                     tr_warn("SRH loop");
01114                     return icmpv6_error(buf, cur, ICMPV6_TYPE_ERROR_PARAMETER_PROBLEM, ICMPV6_CODE_PARAM_PRB_HDR_ERR, aptr - buffer_data_pointer(buf));
01115                 }
01116             }
01117             prev_was_local = local_addr;
01118         }
01119     }
01120 
01121     /* Swap the destination and Address[i]  */
01122     memswap(ip_dst + cmpr, aptr, asize);
01123 
01124     /* And update the metadata */
01125     memcpy(buf->dst_sa .address , ip_dst, 16);
01126 
01127     /* Need to fake up routing here. Basically, for the common (shared-prefix)
01128      * case, we have to assume that the destination is on-link, on an assumed
01129      * interface. We have no direct record of the people trying to use us
01130      * as DAO parents, so we will get totally unknown addresses in SRHs.
01131      * We add routing info to the buffer to say that the IP destination is
01132      * the next hop, and the source being "SRH" is the IP layer's cue to send
01133      * "Error in Source Routing Header" codes instead of "Address Unreachable".
01134      */
01135     buffer_free_route(buf);
01136 
01137     /* THINK: May want to check to see if the address is already known to be on-link on
01138      * an interface.  Won't be the usual 6LoWPAN case though.
01139      */
01140 
01141     /* Policy gets to decide whether we will take this - it can do neighbour state checks */
01142     protocol_interface_info_entry_t *next_if =
01143             protocol_stack_interface_info_get_by_id(
01144                     rpl_policy_srh_next_hop_interface(cur->rpl_domain, cur->id,
01145                                                       buf->dst_sa .address ));
01146     if (!next_if) {
01147         goto error;
01148     }
01149 
01150     buffer_routing_info_t *route = ipv6_buffer_route_to(buf, buf->dst_sa .address , next_if);
01151     if (!route) {
01152         /* Shouldn't happen here? Out of memory case? */
01153         goto error;
01154     }
01155     route->route_info.source = ROUTE_RPL_SRH;
01156 
01157     *forward_out = true;
01158     return buf;
01159 
01160 error:
01161     return icmpv6_error(buf, cur, ICMPV6_TYPE_ERROR_DESTINATION_UNREACH, ICMPV6_CODE_DST_UNREACH_SRC_RTE_HDR_ERR, 0);
01162 }
01163 
01164 bool rpl_data_get_srh_last_address(const uint8_t *rh, uint8_t *addr_out)
01165 {
01166     uint_fast8_t len = rh[1];
01167     uint_fast8_t segs_left = rh[3];
01168     uint_fast8_t cmpr_i = rh[4] >> 4;
01169     uint_fast8_t cmpr_e = rh[4] & 0xF;
01170     uint_fast8_t pad = rh[5] >> 4;
01171 
01172     const uint8_t *last_addr_ptr = rh + 8 + (len * 8) - pad - (16 - cmpr_e);
01173 
01174     if (segs_left == 0) {
01175         return true;
01176     }
01177 
01178     if (segs_left > 1) {
01179         /* Get last "I" destination in */
01180         memcpy(addr_out + cmpr_i, last_addr_ptr - (16 - cmpr_i), 16 - cmpr_i);
01181     }
01182 
01183     /* Then modify "E" destination */
01184     memcpy(addr_out + cmpr_e, last_addr_ptr, 16 - cmpr_e);
01185     return true;
01186 }
01187 
01188 /* Set up handlers for general RPL nodes (hop-by-hop headers, DIO routes) */
01189 void rpl_data_init(void)
01190 {
01191     ipv6_route_table_set_predicate_fn(ROUTE_RPL_INSTANCE, rpl_data_route_predicate_instance_default);
01192     ipv6_set_exthdr_provider(ROUTE_RPL_INSTANCE, rpl_data_exthdr_provider_hbh);
01193     ipv6_set_exthdr_provider(ROUTE_RPL_DIO, rpl_data_exthdr_provider_hbh);
01194     ipv6_set_exthdr_provider(ROUTE_RPL_ROOT, rpl_data_exthdr_provider_hbh);
01195     ipv6_set_exthdr_provider(ROUTE_RPL_FWD_ERROR, rpl_data_exthdr_provider_fwd_error_hbh);
01196 }
01197 
01198 #ifdef HAVE_RPL_ROOT
01199 /* Set up handlers for DODAG root (creation of source routing headers) */
01200 void rpl_data_init_root(void)
01201 {
01202     ipv6_set_exthdr_provider(ROUTE_RPL_DAO_SR, rpl_data_exthdr_provider_srh);
01203     ipv6_route_table_set_next_hop_fn(ROUTE_RPL_DAO_SR, rpl_data_route_next_hop);
01204 }
01205 #endif
01206 
01207 #endif /* HAVE_RPL */