ng_sixlowpan: Initial import of datagram fragmentation

Makefile.dep

@@ -48,6 +48,11 @@ ifneq (,$(filter sixlowpan,$(USEMODULE)))
   USEMODULE += vtimer
 endif
 
+ifneq (,$(filter ng_sixlowpan_frag,$(USEMODULE)))
+  USEMODULE += ng_sixlowpan
+  USEMODULE += vtimer
+endif
+
 ifneq (,$(filter ng_sixlowpan,$(USEMODULE)))
   USEMODULE += ng_sixlowpan_netif
   USEMODULE += ng_netbase

sys/Makefile

@@ -101,6 +101,9 @@ endif
 ifneq (,$(filter ng_sixlowpan_ctx,$(USEMODULE)))
     DIRS += net/network_layer/ng_sixlowpan/ctx
 endif
+ifneq (,$(filter ng_sixlowpan_frag,$(USEMODULE)))
+    DIRS += net/network_layer/ng_sixlowpan/frag
+endif
 ifneq (,$(filter ng_sixlowpan_netif,$(USEMODULE)))
     DIRS += net/network_layer/ng_sixlowpan/netif
 endif

sys/include/net/ng_sixlowpan.h

@@ -24,6 +24,8 @@
 
 #include "kernel_types.h"
 
+#include "net/ng_sixlowpan/frag.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif

sys/include/net/ng_sixlowpan/frag.h

+/*
+ * Copyright (C) 2015 Martine Lenders <mlenders@inf.fu-berlin.de>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @defgroup    net_ng_sixlowpan_frag   6LoWPAN Fragmentation
+ * @ingroup     net_ng_sixlowpan
+ * @brief       6LoWPAN Fragmentation headers and functionality
+ * @see <a href="https://tools.ietf.org/html/rfc4944#section-5.3">
+ *          RFC 4944, section 5.3
+ *      </a>
+ * @{
+ *
+ * @file
+ * @brief   6LoWPAN Fragmentation definitions
+ *
+ * @author  Martine Lenders <mlenders@inf.fu-berlin.de>
+ */
+#ifndef NG_SIXLOWPAN_FRAG_H_
+#define NG_SIXLOWPAN_FRAG_H_
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+#include "byteorder.h"
+#include "kernel_types.h"
+#include "net/ng_pkt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NG_SIXLOWPAN_FRAG_DISP_MASK     (0xf8)      /**< mask for fragmentation
+                                                     *   dispatch */
+#define NG_SIXLOWPAN_FRAG_1_DISP        (0xc0)      /**< dispatch for 1st fragment */
+#define NG_SIXLOWPAN_FRAG_N_DISP        (0xe0)      /**< dispatch for subsequent
+                                                     *   fragments */
+#define NG_SIXLOWPAN_FRAG_SIZE_MASK     (0x07ff)    /**< mask for datagram size */
+
+/**
+ * @brief   General and 1st 6LoWPAN fragmentation header
+ *
+ * @see <a href="https://tools.ietf.org/html/rfc4944#section-5.1">
+ *          RFC 4944, section 5.1
+ *      </a>
+ */
+typedef struct __attribute__((packed)) {
+    /**
+     * @brief   Dispatch and datagram size.
+     *
+     * @details The 5 most significant bits are the dispatch, the remaining
+     *          bits are the size.
+     */
+    network_uint16_t disp_size;
+    network_uint16_t tag;       /**< datagram tag */
+} ng_sixlowpan_frag_t;
+
+/**
+ * @brief   Subsequent 6LoWPAN fragmentation header
+ *
+ * @see <a href="https://tools.ietf.org/html/rfc4944#section-5.3">
+ *          RFC 4944, section 5.3
+ *      </a>
+ *
+ * @extends ng_sixlowpan_frag_t
+ */
+typedef struct __attribute__((packed)) {
+    /**
+     * @brief   Dispatch and datagram size.
+     *
+     * @details The 5 most significant bits are the dispatch, the remaining
+     *          bits are the size.
+     */
+    network_uint16_t disp_size;
+    network_uint16_t tag;       /**< datagram tag */
+    uint8_t offset;             /**< offset */
+} ng_sixlowpan_frag_n_t;
+
+/**
+ * @brief   Checks if a given fragment is a 6LoWPAN fragment.
+ *
+ * @param[in] hdr   A 6LoWPAN fragmentation header.
+ *
+ * @return  true, if given fragment is a 6LoWPAN fragment.
+ * @return  false, if given fragment is not a 6LoWPAN fragment.
+ */
+static inline bool ng_sixlowpan_frag_is(ng_sixlowpan_frag_t *hdr)
+{
+    return ((hdr->disp_size.u8[0] & NG_SIXLOWPAN_FRAG_DISP_MASK) ==
+            NG_SIXLOWPAN_FRAG_1_DISP) ||
+           ((hdr->disp_size.u8[0] & NG_SIXLOWPAN_FRAG_DISP_MASK) ==
+            NG_SIXLOWPAN_FRAG_N_DISP);
+}
+
+/**
+ * @brief   Sends a packet fragmented.
+ *
+ * @param[in] pid           The interface to send the packet over.
+ * @param[in] pkt           The packet to send.
+ * @param[in] payload_len   The length of the payload to send (IPv6 packet size
+ *                          + inner 6LoWPAN dispatches).
+ *                          This value is purely given to not calculate the
+ *                          payload length using @ref ng_pkt_len() repeatedly.
+ * @param[in] datagram_size The length of just the IPv6 packet. It is the value
+ *                          set that the ng_sixlowpan_frag_t::disp_size will be
+ *                          set to.
+ */
+void ng_sixlowpan_frag_send(kernel_pid_t pid, ng_pktsnip_t *pkt,
+                            size_t payload_len, size_t datagram_size);
+
+/**
+ * @brief   Handles a packet containing a fragment header.
+ *
+ * @param[in] pkt   The packet to handle.
+ */
+void ng_sixlowpan_frag_handle_pkt(ng_pktsnip_t *pkt);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NG_SIXLOWPAN_FRAG_H_ */
+/** @} */

sys/net/network_layer/ng_sixlowpan/frag/Makefile

+MODULE = ng_sixlowpan_frag
+
+include $(RIOTBASE)/Makefile.base

sys/net/network_layer/ng_sixlowpan/frag/ng_sixlowpan_frag.c

+/*
+ * Copyright (C) 2015 Martine Lenders <mlenders@inf.fu-berlin.de>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @{
+ *
+ * @file
+ */
+
+#include "kernel_types.h"
+#include "net/ng_pktbuf.h"
+#include "net/ng_netapi.h"
+#include "net/ng_netif/hdr.h"
+#include "net/ng_sixlowpan/frag.h"
+#include "net/ng_sixlowpan/netif.h"
+#include "utlist.h"
+
+#include "rbuf.h"
+
+#define ENABLE_DEBUG    (0)
+#include "debug.h"
+
+static uint16_t _tag;
+
+static inline uint16_t _floor8(uint16_t length)
+{
+    return length & 0xf8U;
+}
+
+static inline size_t _min(size_t a, size_t b)
+{
+    return (a < b) ? a : b;
+}
+
+static ng_pktsnip_t *_build_frag_pkt(ng_pktsnip_t *pkt, size_t payload_len,
+                                     size_t size)
+{
+    ng_netif_hdr_t *hdr = pkt->data, *new_hdr;
+    ng_pktsnip_t *netif, *frag;
+
+    netif = ng_netif_hdr_build(ng_netif_hdr_get_src_addr(hdr), hdr->src_l2addr_len,
+                               ng_netif_hdr_get_dst_addr(hdr), hdr->dst_l2addr_len);
+
+    if (netif == NULL) {
+        DEBUG("6lo frag: error allocating new link-layer header\n");
+        return NULL;
+    }
+
+    new_hdr = netif->data;
+    new_hdr->if_pid = hdr->if_pid;
+    new_hdr->flags = hdr->flags;
+    new_hdr->rssi = hdr->rssi;
+    new_hdr->lqi = hdr->lqi;
+
+    frag = ng_pktbuf_add(NULL, NULL, _min(size, payload_len),
+                         NG_NETTYPE_SIXLOWPAN);
+
+    if (frag == NULL) {
+        DEBUG("6lo frag: error allocating first fragment\n");
+        ng_pktbuf_release(netif);
+        return NULL;
+    }
+
+    LL_PREPEND(frag, netif);
+
+    return frag;
+}
+
+static uint16_t _send_1st_fragment(ng_sixlowpan_netif_t *iface, ng_pktsnip_t *pkt,
+                                   size_t payload_len, size_t datagram_size)
+{
+    ng_pktsnip_t *frag;
+    uint16_t max_frag_size = _floor8(iface->max_frag_size -
+                                     (payload_len - datagram_size) -
+                                     sizeof(ng_sixlowpan_frag_t));
+    uint16_t local_offset = 0;
+    ng_sixlowpan_frag_t *hdr;
+    uint8_t *data;
+
+    DEBUG("6lo frag: determined max_frag_size = %" PRIu16 "\n", max_frag_size);
+
+    /* 6LoWPAN dispatches don't count into that */
+    max_frag_size += (payload_len - datagram_size);
+
+    frag = _build_frag_pkt(pkt, payload_len,
+                           max_frag_size + sizeof(ng_sixlowpan_frag_t));
+
+    if (frag == NULL) {
+        return 0;
+    }
+
+    hdr = frag->next->data;
+    data = (uint8_t *)(hdr + 1);
+
+    hdr->disp_size = byteorder_htons((uint16_t)datagram_size);
+    hdr->disp_size.u8[0] |= NG_SIXLOWPAN_FRAG_1_DISP;
+    hdr->tag = byteorder_htons(_tag);
+
+    pkt = pkt->next;    /* don't copy netif header */
+
+    while (pkt != NULL) {
+        size_t clen = _min(max_frag_size - local_offset, pkt->size);
+
+        memcpy(data + local_offset, pkt->data, clen);
+        local_offset += clen;
+
+        if (local_offset >= max_frag_size) {
+            break;
+        }
+
+        pkt = pkt->next;
+    }
+
+    DEBUG("6lo frag: send first fragment (datagram size: %u, "
+          "datagram tag: %" PRIu16 ", fragment size: %" PRIu16 ")\n",
+          (unsigned int)datagram_size, _tag, local_offset);
+    ng_netapi_send(iface->pid, frag);
+
+    return local_offset;
+}
+
+static uint16_t _send_nth_fragment(ng_sixlowpan_netif_t *iface, ng_pktsnip_t *pkt,
+                                   size_t payload_len, size_t datagram_size,
+                                   uint16_t offset)
+{
+    ng_pktsnip_t *frag;
+    uint16_t max_frag_size = _floor8(iface->max_frag_size - sizeof(ng_sixlowpan_frag_n_t));
+    uint16_t local_offset = 0, offset_count = 0;
+    ng_sixlowpan_frag_n_t *hdr;
+    uint8_t *data;
+
+    DEBUG("6lo frag: determined max_frag_size = %" PRIu16 "\n", max_frag_size);
+
+    frag = _build_frag_pkt(pkt,
+                           payload_len - offset + sizeof(ng_sixlowpan_frag_n_t),
+                           max_frag_size + sizeof(ng_sixlowpan_frag_n_t));
+
+    if (frag == NULL) {
+        return 0;
+    }
+
+    hdr = frag->next->data;
+    data = (uint8_t *)(hdr + 1);
+
+    /* XXX: truncation of datagram_size > 4095 may happen here */
+    hdr->disp_size = byteorder_htons((uint16_t)datagram_size);
+    hdr->disp_size.u8[0] |= NG_SIXLOWPAN_FRAG_N_DISP;
+    hdr->tag = byteorder_htons(_tag);
+    hdr->offset = (uint8_t)(offset >> 3);
+    pkt = pkt->next;    /* don't copy netif header */
+
+    while ((pkt != NULL) || (offset_count == offset)) {   /* go to offset */
+        offset_count += (uint16_t)pkt->size;
+
+        if (offset_count > offset) {    /* we overshot */
+            /* => copy rest of partly send packet snip */
+            uint16_t pkt_offset = offset - (offset_count - ((uint16_t)pkt->size));
+            size_t clen = _min(max_frag_size, pkt->size - pkt_offset);
+
+            memcpy(data, ((uint8_t *)pkt->data) + pkt_offset, clen);
+            local_offset = clen;
+            pkt = pkt->next;
+            break;
+        }
+
+        pkt = pkt->next;
+    }
+
+    if (local_offset < max_frag_size) { /* copy other packet snips */
+        while (pkt != NULL) {
+            size_t clen = _min(max_frag_size - local_offset, pkt->size);
+
+            memcpy(data + local_offset, pkt->data, clen);
+            local_offset += clen;
+
+            if (local_offset == max_frag_size) {
+                break;
+            }
+
+            pkt = pkt->next;
+        }
+    }
+
+    DEBUG("6lo frag: send first fragment (datagram size: %u, "
+          "datagram tag: %" PRIu16 ", offset: %" PRIu8 " (%u bytes), "
+          "fragment size: %" PRIu16 ")\n",
+          (unsigned int)datagram_size, _tag, hdr->offset, hdr->offset << 3,
+          local_offset);
+    ng_netapi_send(iface->pid, frag);
+
+    return local_offset;
+}
+
+void ng_sixlowpan_frag_send(kernel_pid_t pid, ng_pktsnip_t *pkt,
+                            size_t payload_len, size_t datagram_size)
+{
+    ng_sixlowpan_netif_t *iface = ng_sixlowpan_netif_get(pid);
+    uint16_t offset = 0, res;
+
+#if defined(DEVELHELP) && defined(ENABLE_DEBUG)
+    if (iface == NULL) {
+        DEBUG("6lo frag: iface == NULL, expect segmentation fault.\n");
+    }
+#endif
+
+    if ((res = _send_1st_fragment(iface, pkt, payload_len, datagram_size)) == 0) {
+        /* error sending first fragment */
+        ng_pktbuf_release(pkt);
+        return;
+    }
+
+    offset += res;
+
+    while (offset < datagram_size) {
+        if ((res = _send_nth_fragment(iface, pkt, payload_len, datagram_size,
+                                      offset)) == 0) {
+            /* error sending first fragment */
+            ng_pktbuf_release(pkt);
+            return;
+        }
+
+        offset += res;
+    }
+
+    /* remove original packet from packet buffer */
+    ng_pktbuf_release(pkt);
+    _tag++;
+}
+
+void ng_sixlowpan_frag_handle_pkt(ng_pktsnip_t *pkt)
+{
+    ng_netif_hdr_t *hdr = pkt->next->data;
+    ng_sixlowpan_frag_t *frag = pkt->data;
+    uint16_t offset = 0;
+    size_t frag_size;
+
+    switch (frag->disp_size.u8[0] & NG_SIXLOWPAN_FRAG_DISP_MASK) {
+        case NG_SIXLOWPAN_FRAG_1_DISP:
+            frag_size = (pkt->size - sizeof(ng_sixlowpan_frag_t));
+            break;
+
+        case NG_SIXLOWPAN_FRAG_N_DISP:
+            offset = (((ng_sixlowpan_frag_n_t *)frag)->offset * 8);
+            frag_size = (pkt->size - sizeof(ng_sixlowpan_frag_n_t));
+            break;
+
+        default:
+            DEBUG("6lo rbuf: Not a fragment header.\n");
+            ng_pktbuf_release(pkt);
+
+            return;
+    }
+
+    rbuf_add(hdr, frag, frag_size, offset);
+
+    ng_pktbuf_release(pkt);
+}
+
+/** @} */

sys/net/network_layer/ng_sixlowpan/frag/rbuf.c

+/*
+ * Copyright (C) 2015 Martine Lenders <mlenders@inf.fu-berlin.de>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @{
+ *
+ * @file
+ */
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+#include "rbuf.h"
+#include "net/ng_netapi.h"
+#include "net/ng_netif.h"
+#include "net/ng_netif/hdr.h"
+#include "net/ng_pktbuf.h"
+#include "net/ng_ipv6/netif.h"
+#include "net/ng_sixlowpan.h"
+#include "net/ng_sixlowpan/frag.h"
+#include "thread.h"
+#include "timex.h"
+#include "vtimer.h"
+#include "utlist.h"
+
+#define ENABLE_DEBUG    (0)
+#include "debug.h"
+
+#ifndef RBUF_INT_SIZE
+#define RBUF_INT_SIZE   (NG_IPV6_NETIF_DEFAULT_MTU * RBUF_SIZE / 127)
+#endif
+
+static rbuf_int_t rbuf_int[RBUF_INT_SIZE];
+
+static rbuf_t rbuf[RBUF_SIZE];
+
+#if ENABLE_DEBUG
+static char l2addr_str[3 * RBUF_L2ADDR_MAX_LEN];
+#endif
+
+/* ------------------------------------
+ * internal function definitions
+ * ------------------------------------*/
+/* checks whether start and end are in given interval i */
+static inline bool _rbuf_int_in(rbuf_int_t *i, uint16_t start, uint16_t end);
+/* gets a free entry from interval buffer */
+static rbuf_int_t *_rbuf_int_get_free(void);
+/* remove entry from reassembly buffer */
+static void _rbuf_rem(rbuf_t *entry);
+/* update interval buffer of entry */
+static bool _rbuf_update_ints(rbuf_t *entry, uint16_t offset, size_t frag_size);
+/* checks timeouts and removes entries if necessary (oldest if full) */
+static void _rbuf_gc(void);
+/* gets an entry identified by its tupel */
+static rbuf_t *_rbuf_get(const void *src, size_t src_len,
+                         const void *dst, size_t dst_len,
+                         size_t size, uint16_t tag);
+
+void rbuf_add(ng_netif_hdr_t *netif_hdr, ng_sixlowpan_frag_t *frag,
+              size_t frag_size, size_t offset)
+{
+    rbuf_t *entry;
+    rbuf_int_t *ptr;
+    uint8_t *data = ((uint8_t *)frag) + sizeof(ng_sixlowpan_frag_t);
+
+    _rbuf_gc();
+    entry = _rbuf_get(ng_netif_hdr_get_src_addr(netif_hdr), netif_hdr->src_l2addr_len,
+                      ng_netif_hdr_get_dst_addr(netif_hdr), netif_hdr->dst_l2addr_len,
+                      byteorder_ntohs(frag->disp_size) & NG_SIXLOWPAN_FRAG_SIZE_MASK,
+                      byteorder_ntohs(frag->tag));
+
+    if (entry == NULL) {
+        DEBUG("6lo rbuf: reassembly buffer full.\n");
+        return;
+    }
+
+    ptr = entry->ints;
+
+    while (ptr != NULL) {
+        if (_rbuf_int_in(ptr, offset, offset + frag_size - 1)) {
+            DEBUG("6lo rfrag: overlapping or same intervals, discarding datagram\n");
+            ng_pktbuf_release(entry->pkt);
+            _rbuf_rem(entry);
+            return;
+        }
+
+        ptr = ptr->next;
+    }
+
+    if (_rbuf_update_ints(entry, offset, frag_size)) {
+        if (offset == 0) {
+            /* some dispatches do not count to datagram size and we need
+             * more space because of that */
+            switch (data[0]) {
+                case NG_SIXLOWPAN_UNCOMPRESSED:
+                    if (ng_pktbuf_realloc_data(entry->pkt, entry->pkt->size + 1) < 0) {
+                        DEBUG("6lo rbuf: could not reallocate packet data.\n");
+                        return;
+                    }
+
+                    /* move already inserted fragments 1 to the right */
+                    for (int i = entry->pkt->size - 1; i > 0; i--) {
+                        uint8_t *d = ((uint8_t *)(entry->pkt->data)) + i;
+                        *d = *(d - 1);
+                    }
+
+                default:
+                    break;
+            }
+        }
+        else {
+            data += 1;  /* skip offset field in fragmentation header */
+        }
+
+        /* also adapt offset according to stored dispatch */
+        /* above case only applies for first fragment incoming, this for all */
+        switch (*((uint8_t *)entry->pkt->data)) {
+            case NG_SIXLOWPAN_UNCOMPRESSED:
+                offset++;
+                break;
+
+            default:
+                break;
+        }
+
+        DEBUG("6lo rbuf: add fragment data\n");
+        memcpy(((uint8_t *)entry->pkt->data) + offset, data, frag_size);
+        entry->cur_size += (uint16_t)frag_size;
+    }
+
+    if (entry->cur_size == entry->pkt->size) {
+        kernel_pid_t iface = netif_hdr->if_pid;
+        ng_pktsnip_t *netif = ng_netif_hdr_build(entry->src, entry->src_len,
+                              entry->dst, entry->dst_len);
+
+        if (netif == NULL) {
+            DEBUG("6lo rbuf: error allocating netif header\n");
+            ng_pktbuf_release(entry->pkt);
+            return;
+        }
+
+        netif_hdr = netif->data;
+        netif_hdr->if_pid = iface;
+        entry->pkt->next = netif;
+
+        DEBUG("6lo rbuf: datagram complete, send to self\n");
+        ng_netapi_receive(thread_getpid(), entry->pkt);
+        _rbuf_rem(entry);
+    }
+}
+
+static inline bool _rbuf_int_in(rbuf_int_t *i, uint16_t start, uint16_t end)
+{
+    return (((i->start < start) && (start <= i->end)) ||
+            ((start < i->start) && (i->start <= end)) ||
+            ((i->start == start) && (i->end == end)));
+}
+
+static rbuf_int_t *_rbuf_int_get_free(void)
+{
+    for (int i = 0; i < RBUF_INT_SIZE; i++) {
+        if (rbuf_int[i].end == 0) { /* start must be smaller than end anyways*/
+            return rbuf_int + i;
+        }
+    }
+
+    return NULL;
+}
+
+static void _rbuf_rem(rbuf_t *entry)
+{
+    while (entry->ints != NULL) {
+        rbuf_int_t *next = entry->ints->next;
+
+        entry->ints->start = 0;
+        entry->ints->end = 0;
+        entry->ints->next = NULL;
+        entry->ints = next;
+    }
+
+    entry->pkt = NULL;
+}
+
+static bool _rbuf_update_ints(rbuf_t *entry, uint16_t offset, size_t frag_size)
+{
+    rbuf_int_t *new;
+    uint16_t end = (uint16_t)(offset + frag_size - 1);
+
+    new = _rbuf_int_get_free();
+
+    if (new == NULL) {
+        DEBUG("6lo rfrag: no space left in rbuf interval buffer.\n");
+        return false;
+    }
+
+    new->start = offset;
+    new->end = end;
+
+    DEBUG("6lo rfrag: add interval (%" PRIu16 ", %" PRIu16 ") to entry (%s, ",
+          new->start, new->end, ng_netif_addr_to_str(l2addr_str,
+                  sizeof(l2addr_str), entry->src, entry->src_len));
+    DEBUG("%s, %zu, %" PRIu16 ")\n", ng_netif_addr_to_str(l2addr_str,
+            sizeof(l2addr_str), entry->dst, entry->dst_len), entry->pkt->size,
+          entry->tag);
+
+    LL_PREPEND(entry->ints, new);
+
+    return true;
+}
+
+static void _rbuf_gc(void)
+{
+    rbuf_t *oldest = NULL;
+    timex_t now;
+    int i;
+
+    vtimer_now(&now);
+
+    for (i = 0; i < RBUF_SIZE; i++) {
+        if ((rbuf[i].pkt != NULL) &&
+            ((now.seconds - rbuf[i].arrival) > RBUF_TIMEOUT)) {
+            DEBUG("6lo rfrag: entry (%s, ", ng_netif_addr_to_str(l2addr_str,
+                    sizeof(l2addr_str), rbuf[i].src, rbuf[i].src_len));
+            DEBUG("%s, %zu, %" PRIu16 ") timed out\n",
+                  ng_netif_addr_to_str(l2addr_str, sizeof(l2addr_str), rbuf[i].dst,
+                                       rbuf[i].dst_len),
+                  rbuf[i].pkt->size, rbuf[i].tag);
+
+            ng_pktbuf_release(rbuf[i].pkt);
+            _rbuf_rem(&(rbuf[i]));
+        }
+        else if ((oldest == NULL) || (rbuf[i].arrival < oldest->arrival)) {
+            oldest = &(rbuf[i]);
+        }
+    }
+
+    if (((i >= RBUF_SIZE) && (oldest != NULL))) {
+        DEBUG("6lo rfrag: reassembly buffer full, remove oldest entry");
+        ng_pktbuf_release(oldest->pkt);
+        _rbuf_rem(oldest);
+    }
+}
+
+static rbuf_t *_rbuf_get(const void *src, size_t src_len,
+                         const void *dst, size_t dst_len,
+                         size_t size, uint16_t tag)
+{
+    rbuf_t *res = NULL;
+    timex_t now;
+
+    vtimer_now(&now);
+
+    for (int i = 0; i < RBUF_SIZE; i++) {
+        /* check first if entry already available */
+        if ((rbuf[i].pkt != NULL) && (rbuf[i].pkt->size == size) &&
+            (rbuf[i].tag == tag) && (rbuf[i].src_len == src_len) &&
+            (rbuf[i].dst_len == dst_len) &&
+            (memcmp(rbuf[i].src, src, src_len) == 0) &&
+            (memcmp(rbuf[i].dst, dst, dst_len) == 0)) {
+            DEBUG("6lo rfrag: entry (%s, ", ng_netif_addr_to_str(l2addr_str,
+                  sizeof(l2addr_str), rbuf[i].src, rbuf[i].src_len));
+            DEBUG("%s, %zu, %" PRIu16 ") found\n",
+                  ng_netif_addr_to_str(l2addr_str, sizeof(l2addr_str),
+                                       rbuf[i].dst, rbuf[i].dst_len),
+                  rbuf[i].pkt->size, rbuf[i].tag);
+            res->arrival = now.seconds;
+            return &(rbuf[i]);
+        }
+
+        /* if there is a free spot: remember it */
+        if ((res == NULL) && (rbuf[i].cur_size == 0)) {
+            res = &(rbuf[i]);
+        }
+    }
+
+    if (res != NULL) { /* entry not in buffer but found empty spot */
+        res->pkt = ng_pktbuf_add(NULL, NULL, size, NG_NETTYPE_SIXLOWPAN);
+
+        if (res->pkt == NULL) {
+            DEBUG("6lo rfrag: can not allocate reassembly buffer space.\n");
+            return NULL;
+        }
+
+        res->arrival = now.seconds;
+        memcpy(res->src, src, src_len);
+        memcpy(res->dst, dst, dst_len);
+        res->src_len = src_len;
+        res->dst_len = dst_len;
+        res->tag = tag;
+        res->cur_size = 0;
+
+        DEBUG("6lo rfrag: entry (%s, ", ng_netif_addr_to_str(l2addr_str,
+                sizeof(l2addr_str), res->src, res->src_len));
+        DEBUG("%s, %zu, %" PRIu16 ") created\n",
+              ng_netif_addr_to_str(l2addr_str, sizeof(l2addr_str), res->dst,
+                                   res->dst_len), res->pkt->size, res->tag);
+    }
+
+    return res;
+}
+
+/** @} */

sys/net/network_layer/ng_sixlowpan/frag/rbuf.h

+/*
+ * Copyright (C) 2015 Martine Lenders <mlenders@inf.fu-berlin.de>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @ingroup     net_ng_sixlowpan_frag
+ * @{
+ *
+ * @file
+ * @internal
+ * @brief   6LoWPAN reassembly buffer
+ *
+ * @author  Martine Lenders <mlenders@inf.fu-berlin.de>
+ */
+#ifndef NG_SIXLOWPAN_FRAG_RBUF_H_
+#define NG_SIXLOWPAN_FRAG_RBUF_H_
+
+#include <inttypes.h>
+
+#include "net/ng_netif/hdr.h"
+#include "net/ng_pkt.h"
+#include "timex.h"
+
+#include "net/ng_sixlowpan/frag.h"
+#ifdef __cplusplus
+
+extern "C" {
+#endif
+
+#define RBUF_L2ADDR_MAX_LEN (8U)    /**< maximum length for link-layer addresses */
+#define RBUF_SIZE           (4U)    /**< size of the reassembly buffer */
+#define RBUF_TIMEOUT        (3U)    /**< timeout for reassembly in seconds */
+
+/**
+ * @brief   Fragment intervals to identify limits of fragments.
+ *
+ * @note    Fragments MUST NOT overlap and overlapping fragments are to be
+ *          discarded
+ *
+ * @see <a href="https://tools.ietf.org/html/rfc4944#section-5.3">
+ *          RFC 4944, section 5.3
+ *      </a>
+ */
+typedef struct rbuf_int {
+    struct rbuf_int *next;  /**< next element in interval list */
+    uint16_t start;         /**< start byte of interval */
+    uint16_t end;           /**< end byte of interval */
+} rbuf_int_t;
+
+/**
+ * @brief   An entry in the 6LoWPAN reassembly buffer.
+ *
+ * @details A receipient of a fragment SHALL use
+ *
+ * 1. the source address,
+ * 2. the destination address,
+ * 3. the datagram size (ng_pktsnip_t::size of rbuf_t::pkt), and
+ * 4. the datagram tag
+ *
+ * to identify all fragments that belong to the given datagram.
+ *
+ * @see <a href="https://tools.ietf.org/html/rfc4944#section-5.3">
+ *          RFC 4944, section 5.3
+ *      </a>
+ */
+typedef struct {
+    rbuf_int_t *ints;                   /**< intervals of the fragment */
+    ng_pktsnip_t *pkt;                  /**< the reassembled packet in packet buffer */
+    uint32_t arrival;                   /**< time in seconds of arrival of last
+                                         *   received fragment */
+    uint8_t src[RBUF_L2ADDR_MAX_LEN];   /**< source address */
+    uint8_t dst[RBUF_L2ADDR_MAX_LEN];   /**< destination address */
+    uint8_t src_len;                    /**< length of source address */
+    uint8_t dst_len;                    /**< length of destination address */
+    uint16_t tag;                       /**< the datagram's tag */
+    uint16_t cur_size;                  /**< the datagram's current size */
+} rbuf_t;
+
+/**
+ * @brief   Adds a new fragment to the reassembly buffer.
+ *
+ * @param[in] netif_hdr     The interface header of the fragment, with
+ *                          ng_netif_hdr_t::if_pid and its source and
+ *                          destination address set.
+ * @param[in] frag          The fragment to add.
+ * @param[in] frag_size     The fragment's size.
+ * @param[in] offset        The fragment's offset.
+ */
+void rbuf_add(ng_netif_hdr_t *netif_hdr, ng_sixlowpan_frag_t *frag,
+              size_t frag_size, size_t offset);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NG_SIXLOWPAN_FRAG_RBUF_H_ */
+/** @} */

sys/net/network_layer/ng_sixlowpan/ng_sixlowpan.c

@@ -18,6 +18,7 @@
 #include "utlist.h"
 
 #include "net/ng_sixlowpan.h"
+#include "net/ng_sixlowpan/frag.h"
 #include "net/ng_sixlowpan/netif.h"
 
 #define ENABLE_DEBUG    (0)
@@ -80,6 +81,12 @@ void _receive(ng_pktsnip_t *pkt)
         LL_DELETE(pkt, sixlowpan);
         ng_pktbuf_release(sixlowpan);
     }
+#ifdef MODULE_NG_SIXLOWPAN_FRAG
+    else if (ng_sixlowpan_frag_is((ng_sixlowpan_frag_t *)dispatch)) {
+        DEBUG("6lo: received 6LoWPAN fragment\n");
+        ng_sixlowpan_frag_handle_pkt(pkt);
+    }
+#endif
     else {
         DEBUG("6lo: dispatch %02x ... is not supported\n",
               dispatch[0]);
@@ -137,8 +144,6 @@ void _send(ng_pktsnip_t *pkt)
      * length is the length of the IPv6 datagram + 6LoWPAN dispatches,
      * while the datagram size is the size of only the IPv6 datagram */
     payload_len = ng_pkt_len(ipv6);
-    /* cppcheck: datagram_size will be read by ng_sixlowpan_frag implementation */
-    /* cppcheck-suppress unreadVariable */
     datagram_size = (uint16_t)payload_len;
 
     /* use sixlowpan packet snip as temporary one */
@@ -197,8 +202,17 @@ void _send(ng_pktsnip_t *pkt)
 
         return;
     }
+#ifdef MODULE_NG_SIXLOWPAN_FRAG
+    else {
+        DEBUG("6lo: Send fragmented (%u > %" PRIu16 ")\n",
+              (unsigned int)payload_len, max_frag_size);
+        ng_sixlowpan_frag_send(hdr->if_pid, pkt, payload_len, datagram_size);
+    }
+#else
+    (void)datagram_size;
     DEBUG("6lo: packet too big (%u> %" PRIu16 ")\n",
           (unsigned int)payload_len, max_frag_size);
+#endif
 }
 
 static void *_event_loop(void *args)