Contiki-NG
rpl-ext-header.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2009, Swedish Institute of Computer Science.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the Institute nor the names of its contributors
14  * may be used to endorse or promote products derived from this software
15  * without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * This file is part of the Contiki operating system.
30  */
31 
32 /**
33  * \addtogroup rpl-lite
34  * @{
35  *
36  * \file
37  * Management of extension headers for ContikiRPL.
38  *
39  * \author Vincent Brillault <vincent.brillault@imag.fr>,
40  * Joakim Eriksson <joakime@sics.se>,
41  * Niclas Finne <nfi@sics.se>,
42  * Nicolas Tsiftes <nvt@sics.se>,
43  * Simon Duquennoy <simon.duquennoy@inria.fr>
44  */
45 
46 #include "net/routing/routing.h"
47 #include "net/routing/rpl-lite/rpl.h"
48 #include "net/ipv6/uip-sr.h"
49 #include "net/packetbuf.h"
50 
51 /* Log configuration */
52 #include "sys/log.h"
53 #define LOG_MODULE "RPL"
54 #define LOG_LEVEL LOG_LEVEL_RPL
55 
56 /*---------------------------------------------------------------------------*/
57 int
59 {
60  struct uip_routing_hdr *rh_header;
61  uip_sr_node_t *dest_node;
62  uip_sr_node_t *root_node;
63 
64  /* Look for routing ext header */
65  rh_header = (struct uip_routing_hdr *)uipbuf_search_header(uip_buf, uip_len, UIP_PROTO_ROUTING);
66 
67  if(!rpl_is_addr_in_our_dag(&UIP_IP_BUF->destipaddr)) {
68  return 0;
69  }
70 
71  root_node = uip_sr_get_node(NULL, &curr_instance.dag.dag_id);
72  dest_node = uip_sr_get_node(NULL, &UIP_IP_BUF->destipaddr);
73 
74  if((rh_header != NULL && rh_header->routing_type == RPL_RH_TYPE_SRH) ||
75  (dest_node != NULL && root_node != NULL &&
76  dest_node->parent == root_node)) {
77  /* Routing header found or the packet destined for a direct child of the root.
78  * The next hop should be already copied as the IPv6 destination
79  * address, via rpl_ext_header_srh_update. We turn this address into a link-local to enable
80  * forwarding to next hop */
81  uip_ipaddr_copy(ipaddr, &UIP_IP_BUF->destipaddr);
82  uip_create_linklocal_prefix(ipaddr);
83  return 1;
84  }
85 
86  LOG_DBG("no SRH found\n");
87  return 0;
88 }
89 /*---------------------------------------------------------------------------*/
90 int
92 {
93  struct uip_routing_hdr *rh_header;
94  struct uip_rpl_srh_hdr *srh_header;
95  uint8_t cmpri, cmpre;
96  uint8_t ext_len;
97  uint8_t padding;
98  uint8_t path_len;
99  uint8_t segments_left;
100  uip_ipaddr_t current_dest_addr;
101 
102  /* Look for routing ext header */
103  rh_header = (struct uip_routing_hdr *)uipbuf_search_header(uip_buf, uip_len, UIP_PROTO_ROUTING);
104 
105  if(rh_header == NULL || rh_header->routing_type != RPL_RH_TYPE_SRH) {
106  LOG_INFO("SRH not found\n");
107  return 0;
108  }
109 
110  /* Parse SRH */
111  srh_header = (struct uip_rpl_srh_hdr *)(((uint8_t *)rh_header) + RPL_RH_LEN);
112  segments_left = rh_header->seg_left;
113  ext_len = rh_header->len * 8 + 8;
114  cmpri = srh_header->cmpr >> 4;
115  cmpre = srh_header->cmpr & 0x0f;
116  padding = srh_header->pad >> 4;
117  path_len = ((ext_len - padding - RPL_RH_LEN - RPL_SRH_LEN - (16 - cmpre)) / (16 - cmpri)) + 1;
118  (void)path_len;
119 
120  LOG_INFO("read SRH, path len %u, segments left %u, Cmpri %u, Cmpre %u, ext len %u (padding %u)\n",
121  path_len, segments_left, cmpri, cmpre, ext_len, padding);
122 
123  /* Update SRH in-place */
124  if(segments_left == 0) {
125  /* We are the final destination, do nothing */
126  } else if(segments_left > path_len) {
127  /* Discard the packet because of a parameter problem. */
128  LOG_ERR("SRH with too many segments left (%u > %u)\n",
129  segments_left, path_len);
130  return 0;
131  } else {
132  uint8_t i = path_len - segments_left; /* The index of the next address to be visited */
133  uint8_t cmpr = segments_left == 1 ? cmpre : cmpri;
134  ptrdiff_t rh_offset = (uint8_t *)rh_header - uip_buf;
135  size_t addr_offset = RPL_RH_LEN + RPL_SRH_LEN + (i * (16 - cmpri));
136 
137  if(rh_offset + addr_offset + 16 - cmpr > UIP_BUFSIZE) {
138  LOG_ERR("Invalid SRH address pointer\n");
139  return 0;
140  }
141 
142  uint8_t *addr_ptr = ((uint8_t *)rh_header) + addr_offset;
143 
144  /* As per RFC6554: swap the IPv6 destination address with address[i] */
145 
146  /* First, copy the current IPv6 destination address */
147  uip_ipaddr_copy(&current_dest_addr, &UIP_IP_BUF->destipaddr);
148  /* Second, update the IPv6 destination address with addresses[i] */
149  memcpy(((uint8_t *)&UIP_IP_BUF->destipaddr) + cmpr, addr_ptr, 16 - cmpr);
150  /* Third, write current_dest_addr to addresses[i] */
151  memcpy(addr_ptr, ((uint8_t *)&current_dest_addr) + cmpr, 16 - cmpr);
152 
153  /* Update segments left field */
154  rh_header->seg_left--;
155 
156  LOG_INFO("SRH next hop ");
157  LOG_INFO_6ADDR(&UIP_IP_BUF->destipaddr);
158  LOG_INFO_("\n");
159  }
160 
161  return 1;
162 }
163 /*---------------------------------------------------------------------------*/
164 /* Utility function for SRH. Counts the number of bytes in common between
165  * two addresses at p1 and p2. */
166 static int
167 count_matching_bytes(const void *p1, const void *p2, size_t n)
168 {
169  int i = 0;
170  for(i = 0; i < n; i++) {
171  if(((uint8_t *)p1)[i] != ((uint8_t *)p2)[i]) {
172  return i;
173  }
174  }
175  return n;
176 }
177 /*---------------------------------------------------------------------------*/
178 /* Used by rpl_ext_header_update to insert a RPL SRH extension header. This
179  * is used at the root, to initiate downward routing. Returns 1 on success,
180  * 0 on failure.
181 */
182 static int
183 insert_srh_header(void)
184 {
185  /* Implementation of RFC6554 */
186  uint8_t path_len;
187  uint8_t ext_len;
188  uint8_t cmpri, cmpre; /* ComprI and ComprE fields of the RPL Source Routing Header */
189  uint8_t *hop_ptr;
190  uint8_t padding;
191  uip_sr_node_t *dest_node;
192  uip_sr_node_t *root_node;
193  uip_sr_node_t *node;
194  uip_ipaddr_t node_addr;
195 
196  /* Always insest SRH as first extension header */
197  struct uip_routing_hdr *rh_hdr = (struct uip_routing_hdr *)UIP_IP_PAYLOAD(0);
198  struct uip_rpl_srh_hdr *srh_hdr = (struct uip_rpl_srh_hdr *)(UIP_IP_PAYLOAD(0) + RPL_RH_LEN);
199 
200  LOG_INFO("SRH creating source routing header with destination ");
201  LOG_INFO_6ADDR(&UIP_IP_BUF->destipaddr);
202  LOG_INFO_(" \n");
203 
204  /* Construct source route. We do not do this recursively to keep the runtime stack usage constant. */
205 
206  /* Get link of the destination and root */
207 
208  if(!rpl_is_addr_in_our_dag(&UIP_IP_BUF->destipaddr)) {
209  /* The destination is not in our DAG, skip SRH insertion */
210  LOG_INFO("SRH destination not in our DAG, skip SRH insertion\n");
211  return 1;
212  }
213 
214  dest_node = uip_sr_get_node(NULL, &UIP_IP_BUF->destipaddr);
215  if(dest_node == NULL) {
216  /* The destination is not found, skip SRH insertion */
217  LOG_INFO("SRH node not found, skip SRH insertion\n");
218  return 1;
219  }
220 
221  root_node = uip_sr_get_node(NULL, &curr_instance.dag.dag_id);
222  if(root_node == NULL) {
223  LOG_ERR("SRH root node not found\n");
224  return 0;
225  }
226 
227  if(!uip_sr_is_addr_reachable(NULL, &UIP_IP_BUF->destipaddr)) {
228  LOG_ERR("SRH no path found to destination\n");
229  return 0;
230  }
231 
232  /* Compute path length and compression factors (we use cmpri == cmpre) */
233  path_len = 0;
234  node = dest_node->parent;
235  /* For simplicity, we use cmpri = cmpre */
236  cmpri = 15;
237  cmpre = 15;
238 
239  /* Note that in case of a direct child (node == root_node), we insert
240  SRH anyway, as RFC 6553 mandates that routed datagrams must include
241  SRH or the RPL option (or both) */
242 
243  while(node != NULL && node != root_node) {
244 
245  NETSTACK_ROUTING.get_sr_node_ipaddr(&node_addr, node);
246 
247  /* How many bytes in common between all nodes in the path? */
248  cmpri = MIN(cmpri, count_matching_bytes(&node_addr, &UIP_IP_BUF->destipaddr, 16));
249  cmpre = cmpri;
250 
251  LOG_INFO("SRH Hop ");
252  LOG_INFO_6ADDR(&node_addr);
253  LOG_INFO_("\n");
254  node = node->parent;
255  path_len++;
256  }
257 
258  /* Extension header length: fixed headers + (n-1) * (16-ComprI) + (16-ComprE)*/
259  ext_len = RPL_RH_LEN + RPL_SRH_LEN
260  + (path_len - 1) * (16 - cmpre)
261  + (16 - cmpri);
262 
263  padding = ext_len % 8 == 0 ? 0 : (8 - (ext_len % 8));
264  ext_len += padding;
265 
266  LOG_INFO("SRH path len: %u, ComprI %u, ComprE %u, ext len %u (padding %u)\n",
267  path_len, cmpri, cmpre, ext_len, padding);
268 
269  /* Check if there is enough space to store the extension header */
270  if(uip_len + ext_len > UIP_LINK_MTU) {
271  LOG_ERR("packet too long: impossible to add source routing header (%u bytes)\n", ext_len);
272  return 0;
273  }
274 
275  /* Move existing ext headers and payload ext_len further */
276  memmove(uip_buf + UIP_IPH_LEN + uip_ext_len + ext_len,
277  uip_buf + UIP_IPH_LEN + uip_ext_len, uip_len - UIP_IPH_LEN);
278  memset(uip_buf + UIP_IPH_LEN + uip_ext_len, 0, ext_len);
279 
280  /* Insert source routing header (as first ext header) */
281  rh_hdr->next = UIP_IP_BUF->proto;
282  UIP_IP_BUF->proto = UIP_PROTO_ROUTING;
283 
284  /* Initialize IPv6 Routing Header */
285  rh_hdr->len = (ext_len - 8) / 8;
286  rh_hdr->routing_type = RPL_RH_TYPE_SRH;
287  rh_hdr->seg_left = path_len;
288 
289  /* Initialize RPL Source Routing Header */
290  srh_hdr->cmpr = (cmpri << 4) + cmpre;
291  srh_hdr->pad = padding << 4;
292 
293  /* Initialize addresses field (the actual source route).
294  * From last to first. */
295  node = dest_node;
296  hop_ptr = ((uint8_t *)rh_hdr) + ext_len - padding; /* Pointer where to write the next hop compressed address */
297 
298  while(node != NULL && node->parent != root_node) {
299  NETSTACK_ROUTING.get_sr_node_ipaddr(&node_addr, node);
300 
301  hop_ptr -= (16 - cmpri);
302  memcpy(hop_ptr, ((uint8_t*)&node_addr) + cmpri, 16 - cmpri);
303 
304  node = node->parent;
305  }
306 
307  /* The next hop (i.e. node whose parent is the root) is placed as the current IPv6 destination */
308  NETSTACK_ROUTING.get_sr_node_ipaddr(&node_addr, node);
309  uip_ipaddr_copy(&UIP_IP_BUF->destipaddr, &node_addr);
310 
311  /* Update the IPv6 length field */
312  uipbuf_add_ext_hdr(ext_len);
313  uipbuf_set_len_field(UIP_IP_BUF, uip_len - UIP_IPH_LEN);
314 
315  return 1;
316 }
317 /*---------------------------------------------------------------------------*/
318 int
319 rpl_ext_header_hbh_update(uint8_t *ext_buf, int opt_offset)
320 {
321  int down;
322  int rank_error_signaled;
323  int loop_detected;
324  uint16_t sender_rank;
325  uint8_t sender_closer;
326  rpl_nbr_t *sender;
327  struct uip_hbho_hdr *hbh_hdr = (struct uip_hbho_hdr *)ext_buf;
328  struct uip_ext_hdr_opt_rpl *rpl_opt = (struct uip_ext_hdr_opt_rpl *)(ext_buf + opt_offset);
329 
330  if(hbh_hdr->len != ((RPL_HOP_BY_HOP_LEN - 8) / 8)
331  || rpl_opt->opt_type != UIP_EXT_HDR_OPT_RPL
332  || rpl_opt->opt_len != RPL_HDR_OPT_LEN) {
333  LOG_ERR("hop-by-hop extension header has wrong size or type (%u %u %u)\n",
334  hbh_hdr->len, rpl_opt->opt_type, rpl_opt->opt_len);
335  return 0; /* Drop */
336  }
337 
338  if(!curr_instance.used || curr_instance.instance_id != rpl_opt->instance) {
339  LOG_ERR("unknown instance: %u\n", rpl_opt->instance);
340  return 0; /* Drop */
341  }
342 
343  if(rpl_opt->flags & RPL_HDR_OPT_FWD_ERR) {
344  LOG_ERR("forward error!\n");
345  return 0; /* Drop */
346  }
347 
348  down = (rpl_opt->flags & RPL_HDR_OPT_DOWN) ? 1 : 0;
349  sender_rank = UIP_HTONS(rpl_opt->senderrank);
350  sender = nbr_table_get_from_lladdr(rpl_neighbors, packetbuf_addr(PACKETBUF_ADDR_SENDER));
351  rank_error_signaled = (rpl_opt->flags & RPL_HDR_OPT_RANK_ERR) ? 1 : 0;
352  sender_closer = sender_rank < curr_instance.dag.rank;
353  loop_detected = (down && !sender_closer) || (!down && sender_closer);
354 
355  LOG_INFO("ext hdr: packet from ");
356  LOG_INFO_6ADDR(&UIP_IP_BUF->srcipaddr);
357  LOG_INFO_(" to ");
358  LOG_INFO_6ADDR(&UIP_IP_BUF->destipaddr);
359  LOG_INFO_(" going %s, sender closer %d (%d < %d), rank error %u, loop detected %u\n",
360  down == 1 ? "down" : "up", sender_closer, sender_rank,
361  curr_instance.dag.rank, rank_error_signaled, loop_detected);
362 
363  if(loop_detected) {
364  /* Set forward error flag */
365  rpl_opt->flags |= RPL_HDR_OPT_RANK_ERR;
366  }
367 
368  return rpl_process_hbh(sender, sender_rank, loop_detected, rank_error_signaled);
369 }
370 /*---------------------------------------------------------------------------*/
371 /* In-place update of the RPL HBH extension header, when already present
372  * in the uIP packet. Used by insert_hbh_header and rpl_ext_header_update.
373  * Returns 1 on success, 0 on failure. */
374 static int
375 update_hbh_header(void)
376 {
377  struct uip_hbho_hdr *hbh_hdr = (struct uip_hbho_hdr *)UIP_IP_PAYLOAD(0);
378  struct uip_ext_hdr_opt_rpl *rpl_opt = (struct uip_ext_hdr_opt_rpl *)(UIP_IP_PAYLOAD(2));
379 
380  if(UIP_IP_BUF->proto == UIP_PROTO_HBHO && rpl_opt->opt_type == UIP_EXT_HDR_OPT_RPL) {
381  if(hbh_hdr->len != ((RPL_HOP_BY_HOP_LEN - 8) / 8)
382  || rpl_opt->opt_len != RPL_HDR_OPT_LEN) {
383 
384  LOG_ERR("hop-by-hop extension header has wrong size (%u)\n", rpl_opt->opt_len);
385  return 0; /* Drop */
386  }
387 
388  if(!curr_instance.used || curr_instance.instance_id != rpl_opt->instance) {
389  LOG_ERR("unable to add/update hop-by-hop extension header: incorrect instance\n");
390  return 0; /* Drop */
391  }
392 
393  /* Update sender rank and instance, will update flags next */
394  rpl_opt->senderrank = UIP_HTONS(curr_instance.dag.rank);
395  rpl_opt->instance = curr_instance.instance_id;
396  }
397 
398  return 1;
399 }
400 /*---------------------------------------------------------------------------*/
401 /* Used by rpl_ext_header_update on packets without an HBH extension header,
402  * for packets initated by non-root nodes.
403  * Inserts and initalizes (via update_hbh_header) a RPL HBH ext header.
404  * Returns 1 on success, 0 on failure. */
405 static int
406 insert_hbh_header(void)
407 {
408  struct uip_hbho_hdr *hbh_hdr = (struct uip_hbho_hdr *)UIP_IP_PAYLOAD(0);
409  struct uip_ext_hdr_opt_rpl *rpl_opt = (struct uip_ext_hdr_opt_rpl *)(UIP_IP_PAYLOAD(2));
410 
411  /* Insert hop-by-hop header */
412  LOG_INFO("creating hop-by-hop option\n");
413  if(uip_len + RPL_HOP_BY_HOP_LEN > UIP_LINK_MTU) {
414  LOG_ERR("packet too long: impossible to add hop-by-hop option\n");
415  return 0;
416  }
417 
418  /* Move existing ext headers and payload RPL_HOP_BY_HOP_LEN further */
419  memmove(UIP_IP_PAYLOAD(RPL_HOP_BY_HOP_LEN), UIP_IP_PAYLOAD(0), uip_len - UIP_IPH_LEN);
420  memset(UIP_IP_PAYLOAD(0), 0, RPL_HOP_BY_HOP_LEN);
421 
422  /* Insert HBH header (as first ext header) */
423  hbh_hdr->next = UIP_IP_BUF->proto;
424  UIP_IP_BUF->proto = UIP_PROTO_HBHO;
425 
426  /* Initialize HBH option */
427  hbh_hdr->len = (RPL_HOP_BY_HOP_LEN - 8) / 8;
428  rpl_opt->opt_type = UIP_EXT_HDR_OPT_RPL;
429  rpl_opt->opt_len = RPL_HDR_OPT_LEN;
430  rpl_opt->flags = 0;
431  rpl_opt->senderrank = UIP_HTONS(curr_instance.dag.rank);
432  rpl_opt->instance = curr_instance.instance_id;
433 
434  uipbuf_add_ext_hdr(RPL_HOP_BY_HOP_LEN);
435  uipbuf_set_len_field(UIP_IP_BUF, uip_len - UIP_IPH_LEN);
436 
437  /* Update header before returning */
438  return update_hbh_header();
439 }
440 /*---------------------------------------------------------------------------*/
441 int
443 {
444  if(!curr_instance.used
445  || uip_is_addr_linklocal(&UIP_IP_BUF->destipaddr)
446  || uip_is_addr_mcast(&UIP_IP_BUF->destipaddr)) {
447  return 1;
448  }
449 
450  if(rpl_dag_root_is_root()) {
451  /* At the root, remove headers if any, and insert SRH or HBH
452  * (SRH is inserted only if the destination is down the DODAG) */
454  /* Insert SRH (if needed) */
455  return insert_srh_header();
456  } else {
457  if(uip_ds6_is_my_addr(&UIP_IP_BUF->srcipaddr)
458  && UIP_IP_BUF->ttl == uip_ds6_if.cur_hop_limit) {
459  /* Insert HBH option at source. Checking the address is not sufficient because
460  * in non-storing mode, a packet may go up and then down the same path again */
461  return insert_hbh_header();
462  } else {
463  /* Update HBH option at forwarders */
464  return update_hbh_header();
465  }
466  }
467 }
468 /*---------------------------------------------------------------------------*/
469 bool
471 {
472  uint8_t *prev_proto_ptr;
473  uint8_t protocol;
474  uint16_t ext_len;
475  uint8_t *next_header;
476  struct uip_ext_hdr *ext_ptr;
477  struct uip_ext_hdr_opt *opt_ptr;
478 
479  next_header = uipbuf_get_next_header(uip_buf, uip_len, &protocol, true);
480  if(next_header == NULL) {
481  return true;
482  }
483  ext_ptr = (struct uip_ext_hdr *)next_header;
484  prev_proto_ptr = &UIP_IP_BUF->proto;
485 
486  while(uip_is_proto_ext_hdr(protocol)) {
487  opt_ptr = (struct uip_ext_hdr_opt *)(next_header + 2);
488  if(protocol == UIP_PROTO_ROUTING ||
489  (protocol == UIP_PROTO_HBHO && opt_ptr->type == UIP_EXT_HDR_OPT_RPL)) {
490  /* Remove ext header */
491  *prev_proto_ptr = ext_ptr->next;
492  ext_len = ext_ptr->len * 8 + 8;
493  if(uipbuf_add_ext_hdr(-ext_len) == false) {
494  return false;
495  }
496 
497  /* Update length field and move rest of packet to the "left" */
498  uipbuf_set_len_field(UIP_IP_BUF, uip_len - UIP_IPH_LEN);
499  if(uip_len <= next_header - uip_buf) {
500  /* No more data to move. */
501  return false;
502  }
503  memmove(next_header, next_header + ext_len,
504  uip_len - (next_header - uip_buf));
505 
506  /* Update loop variables */
507  protocol = *prev_proto_ptr;
508  } else {
509  /* move to the ext hdr */
510  next_header = uipbuf_get_next_header(next_header,
511  uip_len - (next_header - uip_buf),
512  &protocol, false);
513  if(next_header == NULL) {
514  /* Processing finished. */
515  break;
516  }
517  ext_ptr = (struct uip_ext_hdr *)next_header;
518  prev_proto_ptr = &ext_ptr->next;
519  }
520  }
521 
522  return true;
523 }
524 /** @}*/
static uip_ipaddr_t ipaddr
Pointer to prefix information option in uip_buf.
Definition: uip-nd6.c:116
#define UIP_IP_BUF
Direct access to IPv6 header.
Definition: uip.h:71
uint16_t uip_len
The length of the packet in the uip_buf buffer.
Definition: uip6.c:159
#define UIP_PROTO_HBHO
extension headers types
Definition: uip.h:1764
#define UIP_BUFSIZE
The size of the uIP packet buffer.
Definition: uipopt.h:134
int rpl_is_addr_in_our_dag(const uip_ipaddr_t *addr)
Tells whether a given global IPv6 address is in our current DAG.
Definition: rpl-dag.c:158
int rpl_ext_header_srh_get_next_hop(uip_ipaddr_t *ipaddr)
Look for next hop from SRH of current uIP packet.
int rpl_ext_header_update(void)
Adds/updates all RPL extension headers to current uIP packet.
#define UIP_LINK_MTU
The maximum transmission unit at the IP Layer.
Definition: uipopt.h:228
int rpl_dag_root_is_root(void)
Tells whether we are DAG root or not.
Definition: rpl-dag-root.c:153
int rpl_ext_header_hbh_update(uint8_t *ext_buf, int opt_offset)
Process and update the RPL hop-by-hop extension headers of the current uIP packet.
Source routing support.
uint16_t uip_ext_len
The length of the extension headers.
Definition: uip6.c:122
Routing driver header file
#define uip_buf
Macro to access uip_aligned_buf as an array of bytes.
Definition: uip.h:510
All information related to a RPL neighbor.
Definition: rpl-types.h:136
#define uip_ipaddr_copy(dest, src)
Copy an IP address from one place to another.
Definition: uip.h:1015
uip_sr_node_t * uip_sr_get_node(void *graph, const uip_ipaddr_t *addr)
Looks up for a source routing node from its IPv6 global address.
Definition: uip-sr.c:81
#define uip_is_addr_mcast(a)
is address a multicast address, see RFC 4291 a is of type uip_ipaddr_t*
Definition: uip.h:1961
bool rpl_ext_header_remove(void)
Removes all RPL extension headers.
#define UIP_HTONS(n)
Convert 16-bit quantity from host byte order to network byte order.
Definition: uip.h:1223
uip_ds6_netif_t uip_ds6_if
The single interface.
Definition: uip-ds6.c:75
int rpl_process_hbh(rpl_nbr_t *sender, uint16_t sender_rank, int loop_detected, int rank_error_signaled)
Processes Hop-by-Hop (HBH) Extension Header of a packet currently being forwrded. ...
Definition: rpl-dag.c:680
int(* get_sr_node_ipaddr)(uip_ipaddr_t *addr, const uip_sr_node_t *node)
Returns the global IPv6 address of a source routing node.
Definition: routing.h:97
Header file for the Packet buffer (packetbuf) management
#define uip_is_addr_linklocal(a)
is addr (a) a link local unicast address, see RFC 4291 i.e.
Definition: uip.h:1877
Header file for the logging system
int uip_sr_is_addr_reachable(void *graph, const uip_ipaddr_t *addr)
Telle whether an address is reachable, i.e.
Definition: uip-sr.c:94
A node in a source routing graph, stored at the root and representing all child-parent relationship...
Definition: uip-sr.h:92
int rpl_ext_header_srh_update(void)
Process and update SRH in-place, i.e.