47 #include "net/routing/rpl-lite/rpl.h" 53 #define LOG_MODULE "RPL" 54 #define LOG_LEVEL LOG_LEVEL_RPL 60 struct uip_routing_hdr *rh_header;
65 rh_header = (
struct uip_routing_hdr *)uipbuf_search_header(
uip_buf,
uip_len, UIP_PROTO_ROUTING);
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)) {
82 uip_create_linklocal_prefix(ipaddr);
86 LOG_DBG(
"no SRH found\n");
93 struct uip_routing_hdr *rh_header;
94 struct uip_rpl_srh_hdr *srh_header;
99 uint8_t segments_left;
100 uip_ipaddr_t current_dest_addr;
103 rh_header = (
struct uip_routing_hdr *)uipbuf_search_header(
uip_buf,
uip_len, UIP_PROTO_ROUTING);
105 if(rh_header == NULL || rh_header->routing_type != RPL_RH_TYPE_SRH) {
106 LOG_INFO(
"SRH not found\n");
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;
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);
124 if(segments_left == 0) {
126 }
else if(segments_left > path_len) {
128 LOG_ERR(
"SRH with too many segments left (%u > %u)\n",
129 segments_left, path_len);
132 uint8_t i = path_len - segments_left;
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));
137 if(rh_offset + addr_offset + 16 - cmpr >
UIP_BUFSIZE) {
138 LOG_ERR(
"Invalid SRH address pointer\n");
142 uint8_t *addr_ptr = ((uint8_t *)rh_header) + addr_offset;
149 memcpy(((uint8_t *)&
UIP_IP_BUF->destipaddr) + cmpr, addr_ptr, 16 - cmpr);
151 memcpy(addr_ptr, ((uint8_t *)¤t_dest_addr) + cmpr, 16 - cmpr);
154 rh_header->seg_left--;
156 LOG_INFO(
"SRH next hop ");
167 count_matching_bytes(
const void *p1,
const void *p2,
size_t n)
170 for(i = 0; i < n; i++) {
171 if(((uint8_t *)p1)[i] != ((uint8_t *)p2)[i]) {
183 insert_srh_header(
void)
188 uint8_t cmpri, cmpre;
194 uip_ipaddr_t node_addr;
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);
200 LOG_INFO(
"SRH creating source routing header with destination ");
210 LOG_INFO(
"SRH destination not in our DAG, skip SRH insertion\n");
215 if(dest_node == NULL) {
217 LOG_INFO(
"SRH node not found, skip SRH insertion\n");
222 if(root_node == NULL) {
223 LOG_ERR(
"SRH root node not found\n");
228 LOG_ERR(
"SRH no path found to destination\n");
234 node = dest_node->parent;
243 while(node != NULL && node != root_node) {
248 cmpri = MIN(cmpri, count_matching_bytes(&node_addr, &
UIP_IP_BUF->destipaddr, 16));
251 LOG_INFO(
"SRH Hop ");
252 LOG_INFO_6ADDR(&node_addr);
259 ext_len = RPL_RH_LEN + RPL_SRH_LEN
260 + (path_len - 1) * (16 - cmpre)
263 padding = ext_len % 8 == 0 ? 0 : (8 - (ext_len % 8));
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);
271 LOG_ERR(
"packet too long: impossible to add source routing header (%u bytes)\n", ext_len);
285 rh_hdr->len = (ext_len - 8) / 8;
286 rh_hdr->routing_type = RPL_RH_TYPE_SRH;
287 rh_hdr->seg_left = path_len;
290 srh_hdr->cmpr = (cmpri << 4) + cmpre;
291 srh_hdr->pad = padding << 4;
296 hop_ptr = ((uint8_t *)rh_hdr) + ext_len - padding;
298 while(node != NULL && node->parent != root_node) {
301 hop_ptr -= (16 - cmpri);
302 memcpy(hop_ptr, ((uint8_t*)&node_addr) + cmpri, 16 - cmpri);
312 uipbuf_add_ext_hdr(ext_len);
322 int rank_error_signaled;
324 uint16_t sender_rank;
325 uint8_t sender_closer;
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);
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);
338 if(!curr_instance.used || curr_instance.instance_id != rpl_opt->instance) {
339 LOG_ERR(
"unknown instance: %u\n", rpl_opt->instance);
343 if(rpl_opt->flags & RPL_HDR_OPT_FWD_ERR) {
344 LOG_ERR(
"forward error!\n");
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);
355 LOG_INFO(
"ext hdr: packet from ");
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);
365 rpl_opt->flags |= RPL_HDR_OPT_RANK_ERR;
368 return rpl_process_hbh(sender, sender_rank, loop_detected, rank_error_signaled);
375 update_hbh_header(
void)
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));
381 if(hbh_hdr->len != ((RPL_HOP_BY_HOP_LEN - 8) / 8)
382 || rpl_opt->opt_len != RPL_HDR_OPT_LEN) {
384 LOG_ERR(
"hop-by-hop extension header has wrong size (%u)\n", rpl_opt->opt_len);
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");
394 rpl_opt->senderrank =
UIP_HTONS(curr_instance.dag.rank);
395 rpl_opt->instance = curr_instance.instance_id;
406 insert_hbh_header(
void)
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));
412 LOG_INFO(
"creating hop-by-hop option\n");
414 LOG_ERR(
"packet too long: impossible to add hop-by-hop option\n");
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);
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;
431 rpl_opt->senderrank =
UIP_HTONS(curr_instance.dag.rank);
432 rpl_opt->instance = curr_instance.instance_id;
434 uipbuf_add_ext_hdr(RPL_HOP_BY_HOP_LEN);
438 return update_hbh_header();
444 if(!curr_instance.used
455 return insert_srh_header();
461 return insert_hbh_header();
464 return update_hbh_header();
472 uint8_t *prev_proto_ptr;
475 uint8_t *next_header;
476 struct uip_ext_hdr *ext_ptr;
477 struct uip_ext_hdr_opt *opt_ptr;
479 next_header = uipbuf_get_next_header(
uip_buf,
uip_len, &protocol,
true);
480 if(next_header == NULL) {
483 ext_ptr = (
struct uip_ext_hdr *)next_header;
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)) {
491 *prev_proto_ptr = ext_ptr->next;
492 ext_len = ext_ptr->len * 8 + 8;
493 if(uipbuf_add_ext_hdr(-ext_len) ==
false) {
503 memmove(next_header, next_header + ext_len,
507 protocol = *prev_proto_ptr;
510 next_header = uipbuf_get_next_header(next_header,
513 if(next_header == NULL) {
517 ext_ptr = (
struct uip_ext_hdr *)next_header;
518 prev_proto_ptr = &ext_ptr->next;
static uip_ipaddr_t ipaddr
Pointer to prefix information option in uip_buf.
#define UIP_IP_BUF
Direct access to IPv6 header.
uint16_t uip_len
The length of the packet in the uip_buf buffer.
#define UIP_PROTO_HBHO
extension headers types
#define UIP_BUFSIZE
The size of the uIP packet buffer.
int rpl_is_addr_in_our_dag(const uip_ipaddr_t *addr)
Tells whether a given global IPv6 address is in our current DAG.
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.
int rpl_dag_root_is_root(void)
Tells whether we are DAG root or not.
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.
uint16_t uip_ext_len
The length of the extension headers.
Routing driver header file
#define uip_buf
Macro to access uip_aligned_buf as an array of bytes.
All information related to a RPL neighbor.
#define uip_ipaddr_copy(dest, src)
Copy an IP address from one place to another.
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.
#define uip_is_addr_mcast(a)
is address a multicast address, see RFC 4291 a is of type uip_ipaddr_t*
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.
uip_ds6_netif_t uip_ds6_if
The single interface.
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. ...
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.
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.
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.
A node in a source routing graph, stored at the root and representing all child-parent relationship...
int rpl_ext_header_srh_update(void)
Process and update SRH in-place, i.e.