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/*---------------------------------------------------------------------------*/
57int
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/*---------------------------------------------------------------------------*/
90int
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. */
166static int
167count_matching_bytes(const void *p1, const void *p2, size_t n)
168{
169 for(size_t i = 0; i < n; i++) {
170 if(((uint8_t *)p1)[i] != ((uint8_t *)p2)[i]) {
171 return i;
172 }
173 }
174 return n;
175}
176/*---------------------------------------------------------------------------*/
177/* Used by rpl_ext_header_update to insert a RPL SRH extension header. This
178 * is used at the root, to initiate downward routing. Returns 1 on success,
179 * 0 on failure.
180*/
181static int
182insert_srh_header(void)
183{
184 /* Implementation of RFC6554 */
185 uint8_t path_len;
186 uint8_t ext_len;
187 uint8_t cmpri, cmpre; /* ComprI and ComprE fields of the RPL Source Routing Header */
188 uint8_t *hop_ptr;
189 uint8_t padding;
190 uip_sr_node_t *dest_node;
191 uip_sr_node_t *root_node;
192 uip_sr_node_t *node;
193 uip_ipaddr_t node_addr;
194
195 /* Always insest SRH as first extension header */
196 struct uip_routing_hdr *rh_hdr = (struct uip_routing_hdr *)UIP_IP_PAYLOAD(0);
197 struct uip_rpl_srh_hdr *srh_hdr = (struct uip_rpl_srh_hdr *)(UIP_IP_PAYLOAD(0) + RPL_RH_LEN);
198
199 LOG_INFO("SRH creating source routing header with destination ");
200 LOG_INFO_6ADDR(&UIP_IP_BUF->destipaddr);
201 LOG_INFO_(" \n");
202
203 /* Construct source route. We do not do this recursively to keep the runtime stack usage constant. */
204
205 /* Get link of the destination and root */
206
207 if(!rpl_is_addr_in_our_dag(&UIP_IP_BUF->destipaddr)) {
208 /* The destination is not in our DAG, skip SRH insertion */
209 LOG_INFO("SRH destination not in our DAG, skip SRH insertion\n");
210 return 1;
211 }
212
213 dest_node = uip_sr_get_node(NULL, &UIP_IP_BUF->destipaddr);
214 if(dest_node == NULL) {
215 /* The destination is not found, skip SRH insertion */
216 LOG_INFO("SRH node not found, skip SRH insertion\n");
217 return 1;
218 }
219
220 root_node = uip_sr_get_node(NULL, &curr_instance.dag.dag_id);
221 if(root_node == NULL) {
222 LOG_ERR("SRH root node not found\n");
223 return 0;
224 }
225
226 if(!uip_sr_is_addr_reachable(NULL, &UIP_IP_BUF->destipaddr)) {
227 LOG_ERR("SRH no path found to destination\n");
228 return 0;
229 }
230
231 /* Compute path length and compression factors (we use cmpri == cmpre) */
232 path_len = 0;
233 node = dest_node->parent;
234 /* For simplicity, we use cmpri = cmpre */
235 cmpri = 15;
236 cmpre = 15;
237
238 /* Note that in case of a direct child (node == root_node), we insert
239 SRH anyway, as RFC 6553 mandates that routed datagrams must include
240 SRH or the RPL option (or both) */
241
242 while(node != NULL && node != root_node) {
243
244 NETSTACK_ROUTING.get_sr_node_ipaddr(&node_addr, node);
245
246 /* How many bytes in common between all nodes in the path? */
247 cmpri = MIN(cmpri, count_matching_bytes(&node_addr, &UIP_IP_BUF->destipaddr, 16));
248 cmpre = cmpri;
249
250 LOG_INFO("SRH Hop ");
251 LOG_INFO_6ADDR(&node_addr);
252 LOG_INFO_("\n");
253 node = node->parent;
254 path_len++;
255 }
256
257 /* Extension header length: fixed headers + (n-1) * (16-ComprI) + (16-ComprE)*/
258 ext_len = RPL_RH_LEN + RPL_SRH_LEN
259 + (path_len - 1) * (16 - cmpre)
260 + (16 - cmpri);
261
262 padding = ext_len % 8 == 0 ? 0 : (8 - (ext_len % 8));
263 ext_len += padding;
264
265 LOG_INFO("SRH path len: %u, ComprI %u, ComprE %u, ext len %u (padding %u)\n",
266 path_len, cmpri, cmpre, ext_len, padding);
267
268 /* Check if there is enough space to store the extension header */
269 if(uip_len + ext_len > UIP_LINK_MTU) {
270 LOG_ERR("packet too long: impossible to add source routing header (%u bytes)\n", ext_len);
271 return 0;
272 }
273
274 /* Move existing ext headers and payload ext_len further */
275 memmove(uip_buf + UIP_IPH_LEN + uip_ext_len + ext_len,
276 uip_buf + UIP_IPH_LEN + uip_ext_len, uip_len - UIP_IPH_LEN);
277 memset(uip_buf + UIP_IPH_LEN + uip_ext_len, 0, ext_len);
278
279 /* Insert source routing header (as first ext header) */
280 rh_hdr->next = UIP_IP_BUF->proto;
281 UIP_IP_BUF->proto = UIP_PROTO_ROUTING;
282
283 /* Initialize IPv6 Routing Header */
284 rh_hdr->len = (ext_len - 8) / 8;
285 rh_hdr->routing_type = RPL_RH_TYPE_SRH;
286 rh_hdr->seg_left = path_len;
287
288 /* Initialize RPL Source Routing Header */
289 srh_hdr->cmpr = (cmpri << 4) + cmpre;
290 srh_hdr->pad = padding << 4;
291
292 /* Initialize addresses field (the actual source route).
293 * From last to first. */
294 node = dest_node;
295 hop_ptr = ((uint8_t *)rh_hdr) + ext_len - padding; /* Pointer where to write the next hop compressed address */
296
297 while(node != NULL && node->parent != root_node) {
298 NETSTACK_ROUTING.get_sr_node_ipaddr(&node_addr, node);
299
300 hop_ptr -= (16 - cmpri);
301 memcpy(hop_ptr, ((uint8_t*)&node_addr) + cmpri, 16 - cmpri);
302
303 node = node->parent;
304 }
305
306 /* The next hop (i.e. node whose parent is the root) is placed as the current IPv6 destination */
307 NETSTACK_ROUTING.get_sr_node_ipaddr(&node_addr, node);
308 uip_ipaddr_copy(&UIP_IP_BUF->destipaddr, &node_addr);
309
310 /* Update the IPv6 length field */
311 uipbuf_add_ext_hdr(ext_len);
312 uipbuf_set_len_field(UIP_IP_BUF, uip_len - UIP_IPH_LEN);
313
314 return 1;
315}
316/*---------------------------------------------------------------------------*/
317int
318rpl_ext_header_hbh_update(uint8_t *ext_buf, int opt_offset)
319{
320 int down;
321 int rank_error_signaled;
322 int loop_detected;
323 uint16_t sender_rank;
324 uint8_t sender_closer;
325 rpl_nbr_t *sender;
326 struct uip_hbho_hdr *hbh_hdr = (struct uip_hbho_hdr *)ext_buf;
327 struct uip_ext_hdr_opt_rpl *rpl_opt = (struct uip_ext_hdr_opt_rpl *)(ext_buf + opt_offset);
328
329 if(hbh_hdr->len != ((RPL_HOP_BY_HOP_LEN - 8) / 8)
330 || rpl_opt->opt_type != UIP_EXT_HDR_OPT_RPL
331 || rpl_opt->opt_len != RPL_HDR_OPT_LEN) {
332 LOG_ERR("hop-by-hop extension header has wrong size or type (%u %u %u)\n",
333 hbh_hdr->len, rpl_opt->opt_type, rpl_opt->opt_len);
334 return 0; /* Drop */
335 }
336
337 if(!curr_instance.used || curr_instance.instance_id != rpl_opt->instance) {
338 LOG_ERR("unknown instance: %u\n", rpl_opt->instance);
339 return 0; /* Drop */
340 }
341
342 if(rpl_opt->flags & RPL_HDR_OPT_FWD_ERR) {
343 LOG_ERR("forward error!\n");
344 return 0; /* Drop */
345 }
346
347 down = (rpl_opt->flags & RPL_HDR_OPT_DOWN) ? 1 : 0;
348 sender_rank = UIP_HTONS(rpl_opt->senderrank);
349 sender = nbr_table_get_from_lladdr(rpl_neighbors, packetbuf_addr(PACKETBUF_ADDR_SENDER));
350 rank_error_signaled = (rpl_opt->flags & RPL_HDR_OPT_RANK_ERR) ? 1 : 0;
351 sender_closer = sender_rank < curr_instance.dag.rank;
352 loop_detected = (down && !sender_closer) || (!down && sender_closer);
353
354 LOG_INFO("ext hdr: packet from ");
355 LOG_INFO_6ADDR(&UIP_IP_BUF->srcipaddr);
356 LOG_INFO_(" to ");
357 LOG_INFO_6ADDR(&UIP_IP_BUF->destipaddr);
358 LOG_INFO_(" going %s, sender closer %d (%d < %d), rank error %u, loop detected %u\n",
359 down == 1 ? "down" : "up", sender_closer, sender_rank,
360 curr_instance.dag.rank, rank_error_signaled, loop_detected);
361
362 if(loop_detected) {
363 /* Set forward error flag */
364 rpl_opt->flags |= RPL_HDR_OPT_RANK_ERR;
365 }
366
367 return rpl_process_hbh(sender, sender_rank, loop_detected, rank_error_signaled);
368}
369/*---------------------------------------------------------------------------*/
370/* In-place update of the RPL HBH extension header, when already present
371 * in the uIP packet. Used by insert_hbh_header and rpl_ext_header_update.
372 * Returns 1 on success, 0 on failure. */
373static int
374update_hbh_header(void)
375{
376 struct uip_hbho_hdr *hbh_hdr = (struct uip_hbho_hdr *)UIP_IP_PAYLOAD(0);
377 struct uip_ext_hdr_opt_rpl *rpl_opt = (struct uip_ext_hdr_opt_rpl *)(UIP_IP_PAYLOAD(2));
378
379 if(UIP_IP_BUF->proto == UIP_PROTO_HBHO && rpl_opt->opt_type == UIP_EXT_HDR_OPT_RPL) {
380 if(hbh_hdr->len != ((RPL_HOP_BY_HOP_LEN - 8) / 8)
381 || rpl_opt->opt_len != RPL_HDR_OPT_LEN) {
382
383 LOG_ERR("hop-by-hop extension header has wrong size (%u)\n", rpl_opt->opt_len);
384 return 0; /* Drop */
385 }
386
387 if(!curr_instance.used || curr_instance.instance_id != rpl_opt->instance) {
388 LOG_ERR("unable to add/update hop-by-hop extension header: incorrect instance\n");
389 return 0; /* Drop */
390 }
391
392 /* Update sender rank and instance, will update flags next */
393 rpl_opt->senderrank = UIP_HTONS(curr_instance.dag.rank);
394 rpl_opt->instance = curr_instance.instance_id;
395 }
396
397 return 1;
398}
399/*---------------------------------------------------------------------------*/
400/* Used by rpl_ext_header_update on packets without an HBH extension header,
401 * for packets initated by non-root nodes.
402 * Inserts and initalizes (via update_hbh_header) a RPL HBH ext header.
403 * Returns 1 on success, 0 on failure. */
404static int
405insert_hbh_header(void)
406{
407 struct uip_hbho_hdr *hbh_hdr = (struct uip_hbho_hdr *)UIP_IP_PAYLOAD(0);
408 struct uip_ext_hdr_opt_rpl *rpl_opt = (struct uip_ext_hdr_opt_rpl *)(UIP_IP_PAYLOAD(2));
409
410 /* Insert hop-by-hop header */
411 LOG_INFO("creating hop-by-hop option\n");
412 if(uip_len + RPL_HOP_BY_HOP_LEN > UIP_LINK_MTU) {
413 LOG_ERR("packet too long: impossible to add hop-by-hop option\n");
414 return 0;
415 }
416
417 /* Move existing ext headers and payload RPL_HOP_BY_HOP_LEN further */
418 memmove(UIP_IP_PAYLOAD(RPL_HOP_BY_HOP_LEN), UIP_IP_PAYLOAD(0), uip_len - UIP_IPH_LEN);
419 memset(UIP_IP_PAYLOAD(0), 0, RPL_HOP_BY_HOP_LEN);
420
421 /* Insert HBH header (as first ext header) */
422 hbh_hdr->next = UIP_IP_BUF->proto;
423 UIP_IP_BUF->proto = UIP_PROTO_HBHO;
424
425 /* Initialize HBH option */
426 hbh_hdr->len = (RPL_HOP_BY_HOP_LEN - 8) / 8;
427 rpl_opt->opt_type = UIP_EXT_HDR_OPT_RPL;
428 rpl_opt->opt_len = RPL_HDR_OPT_LEN;
429 rpl_opt->flags = 0;
430 rpl_opt->senderrank = UIP_HTONS(curr_instance.dag.rank);
431 rpl_opt->instance = curr_instance.instance_id;
432
433 uipbuf_add_ext_hdr(RPL_HOP_BY_HOP_LEN);
434 uipbuf_set_len_field(UIP_IP_BUF, uip_len - UIP_IPH_LEN);
435
436 /* Update header before returning */
437 return update_hbh_header();
438}
439/*---------------------------------------------------------------------------*/
440int
442{
443 if(!curr_instance.used
444 || uip_is_addr_linklocal(&UIP_IP_BUF->destipaddr)
445 || uip_is_addr_mcast(&UIP_IP_BUF->destipaddr)) {
446 return 1;
447 }
448
450 /* At the root, remove headers if any, and insert SRH or HBH
451 * (SRH is inserted only if the destination is down the DODAG) */
453 /* Insert SRH (if needed) */
454 return insert_srh_header();
455 } else {
456 if(uip_ds6_is_my_addr(&UIP_IP_BUF->srcipaddr)
457 && UIP_IP_BUF->ttl == uip_ds6_if.cur_hop_limit) {
458 /* Insert HBH option at source. Checking the address is not sufficient because
459 * in non-storing mode, a packet may go up and then down the same path again */
460 return insert_hbh_header();
461 } else {
462 /* Update HBH option at forwarders */
463 return update_hbh_header();
464 }
465 }
466}
467/*---------------------------------------------------------------------------*/
468bool
470{
471 uint8_t *prev_proto_ptr;
472 uint8_t protocol;
473 uint16_t ext_len;
474 uint8_t *next_header;
475 struct uip_ext_hdr *ext_ptr;
476 struct uip_ext_hdr_opt *opt_ptr;
477
478 next_header = uipbuf_get_next_header(uip_buf, uip_len, &protocol, true);
479 if(next_header == NULL) {
480 return true;
481 }
482 ext_ptr = (struct uip_ext_hdr *)next_header;
483 prev_proto_ptr = &UIP_IP_BUF->proto;
484
485 while(uip_is_proto_ext_hdr(protocol)) {
486 opt_ptr = (struct uip_ext_hdr_opt *)(next_header + 2);
487 if(protocol == UIP_PROTO_ROUTING ||
488 (protocol == UIP_PROTO_HBHO && opt_ptr->type == UIP_EXT_HDR_OPT_RPL)) {
489 /* Remove ext header */
490 *prev_proto_ptr = ext_ptr->next;
491 ext_len = ext_ptr->len * 8 + 8;
492 if(uipbuf_add_ext_hdr(-ext_len) == false) {
493 return false;
494 }
495
496 /* Update length field and move rest of packet to the "left" */
497 uipbuf_set_len_field(UIP_IP_BUF, uip_len - UIP_IPH_LEN);
498 if(uip_len <= next_header - uip_buf) {
499 /* No more data to move. */
500 return false;
501 }
502 memmove(next_header, next_header + ext_len,
503 uip_len - (next_header - uip_buf));
504
505 /* Update loop variables */
506 protocol = *prev_proto_ptr;
507 } else {
508 /* move to the ext hdr */
509 next_header = uipbuf_get_next_header(next_header,
510 uip_len - (next_header - uip_buf),
511 &protocol, false);
512 if(next_header == NULL) {
513 /* Processing finished. */
514 break;
515 }
516 ext_ptr = (struct uip_ext_hdr *)next_header;
517 prev_proto_ptr = &ext_ptr->next;
518 }
519 }
520
521 return true;
522}
523/** @}*/
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 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
uip_sr_node_t * uip_sr_get_node(const void *graph, const uip_ipaddr_t *addr)
Looks up for a source routing node from its IPv6 global address.
Definition: uip-sr.c:82
int rpl_dag_root_is_root(void)
Tells whether we are DAG root or not.
Definition: rpl-dag-root.c:152
int rpl_ext_header_update(void)
Adds/updates all RPL extension headers to current uIP packet.
int uip_sr_is_addr_reachable(const void *graph, const uip_ipaddr_t *addr)
Telle whether an address is reachable, i.e.
Definition: uip-sr.c:95
#define uip_is_addr_mcast(a)
is address a multicast address, see RFC 4291 a is of type uip_ipaddr_t*
Definition: uip.h:1869
int rpl_ext_header_srh_get_next_hop(uip_ipaddr_t *ipaddr)
Look for next hop from SRH of current uIP packet.
#define uip_is_addr_linklocal(a)
is addr (a) a link local unicast address, see RFC 4291 i.e.
Definition: uip.h:1775
int rpl_ext_header_srh_update(void)
Process and update SRH in-place, i.e.
bool rpl_ext_header_remove(void)
Removes all RPL extension headers.
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.
uip_ds6_netif_t uip_ds6_if
The single interface.
Definition: uip-ds6.c:75
#define UIP_PROTO_HBHO
extension headers types
Definition: uip.h:1672
#define UIP_IP_BUF
Direct access to IPv6 header.
Definition: uip.h:71
#define UIP_HTONS(n)
Convert 16-bit quantity from host byte order to network byte order.
Definition: uip.h:1157
#define uip_ipaddr_copy(dest, src)
Copy an IP address from one place to another.
Definition: uip.h:969
#define uip_buf
Macro to access uip_aligned_buf as an array of bytes.
Definition: uip.h:465
uint16_t uip_ext_len
The length of the extension headers.
Definition: uip6.c:122
uint16_t uip_len
The length of the packet in the uip_buf buffer.
Definition: uip6.c:159
#define UIP_BUFSIZE
The size of the uIP packet buffer.
Definition: uipopt.h:93
#define UIP_LINK_MTU
The maximum transmission unit at the IP Layer.
Definition: uipopt.h:154
Header file for the logging system.
Header file for the Packet buffer (packetbuf) management.
Routing driver header file.
int(* get_sr_node_ipaddr)(uip_ipaddr_t *ipaddr, const uip_sr_node_t *node)
Returns the global IPv6 address of a source routing node.
Definition: routing.h:97
All information related to a RPL neighbor.
Definition: rpl-types.h:136
A node in a source routing graph, stored at the root and representing all child-parent relationship.
Definition: uip-sr.h:92
static uip_ipaddr_t ipaddr
Pointer to prefix information option in uip_buf.
Definition: uip-nd6.c:116
Source routing support.