riot-ci/RIOT
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

gnrc_sixlowpan_frag_rb: unify naming scheme

Browse Source
This commit is contained in:
Martine Lenders 2019-09-28 12:11:54 +02:00
parent 178f4af108
commit e9ff46b2ea
12 changed files with 157 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/include/net/gnrc/sixlowpan.h
View File

@ -67,7 +67,7 @@
*
* 1. If @ref net_gnrc_sixlowpan_frag is included and @ref sixlowpan_frag_is() is true for the
* packet, the fragmentation header will be removed and its remaining data will be added to
* the reassembly buffer (using @ref gnrc_sixlowpan_frag_rbuf_add()) in accordance to the
* the reassembly buffer (using @ref gnrc_sixlowpan_frag_rb_add()) in accordance to the
* fragmentation header. The packet containing the fragment will be discarded. When the
* fragmented datagram is complete, its payload will be marked with @ref GNRC_NETTYPE_IPV6 and
* issued via a @ref GNRC_NETAPI_MSG_TYPE_RCV to all subscribers registered to @ref

2
sys/include/net/gnrc/sixlowpan/config.h
View File

@ -123,7 +123,7 @@ extern "C" {
* @note Only applicable with
* [gnrc_sixlowpan_frag_vrb](@ref net_gnrc_sixlowpan_frag_vrb) module,
* but has also a direct influence on the number of available
* gnrc_sixlowpan_rbuf_int_t entries (even when
* gnrc_sixlowpan_frag_rb_int_t entries (even when
* `gnrc_sixlowpan_frag_vrb` is not compiled in).
*/
#ifndef GNRC_SIXLOWPAN_FRAG_VRB_SIZE

47
sys/include/net/gnrc/sixlowpan/frag/rb.h
View File

@ -42,14 +42,14 @@ extern "C" {
* RFC 4944, section 5.3
* </a>
*/
typedef struct gnrc_sixlowpan_rbuf_int {
typedef struct gnrc_sixlowpan_frag_rb_int {
/**
* @brief next element in fragment interval list
*/
struct gnrc_sixlowpan_rbuf_int *next;
struct gnrc_sixlowpan_frag_rb_int *next;
uint16_t start; /**< start byte of the fragment interval */
uint16_t end; /**< end byte of the fragment interval */
} gnrc_sixlowpan_rbuf_int_t;
} gnrc_sixlowpan_frag_rb_int_t;
/**
* @brief Base class for both reassembly buffer and virtual reassembly buffer
@ -65,11 +65,11 @@ typedef struct gnrc_sixlowpan_rbuf_int {
* @see https://tools.ietf.org/html/draft-ietf-lwig-6lowpan-virtual-reassembly-01
*/
typedef struct {
gnrc_sixlowpan_rbuf_int_t *ints; /**< intervals of already received fragments */
gnrc_sixlowpan_frag_rb_int_t *ints; /**< intervals of already received fragments */
uint8_t src[IEEE802154_LONG_ADDRESS_LEN]; /**< source address */
uint8_t dst[IEEE802154_LONG_ADDRESS_LEN]; /**< destination address */
uint8_t src_len; /**< length of gnrc_sixlowpan_rbuf_t::src */
uint8_t dst_len; /**< length of gnrc_sixlowpan_rbuf_t::dst */
uint8_t src_len; /**< length of gnrc_sixlowpan_frag_rb_t::src */
uint8_t dst_len; /**< length of gnrc_sixlowpan_frag_rb_t::dst */
uint16_t tag; /**< the datagram's tag */
uint16_t datagram_size; /**< the datagram's size */
/**
@ -78,7 +78,7 @@ typedef struct {
uint16_t current_size;
uint32_t arrival; /**< time in microseconds of arrival of
* last received fragment */
} gnrc_sixlowpan_rbuf_base_t;
} gnrc_sixlowpan_frag_rb_base_t;
/**
* @brief An entry in the 6LoWPAN reassembly buffer.
@ -87,12 +87,12 @@ typedef struct {
*
*/
typedef struct {
gnrc_sixlowpan_rbuf_base_t super; /**< base class */
gnrc_sixlowpan_frag_rb_base_t super; /**< base class */
/**
* @brief The reassembled packet in the packet buffer
*/
gnrc_pktsnip_t *pkt;
} gnrc_sixlowpan_rbuf_t;
} gnrc_sixlowpan_frag_rb_t;
/**
* @brief Adds a new fragment to the reassembly buffer. If the packet is
@ -106,9 +106,9 @@ typedef struct {
* @param[in] offset The fragment's offset.
* @param[in] page Current 6Lo dispatch parsing page.
*/
void gnrc_sixlowpan_frag_rbuf_add(gnrc_netif_hdr_t *netif_hdr,
gnrc_pktsnip_t *frag, size_t offset,
unsigned page);
void gnrc_sixlowpan_frag_rb_add(gnrc_netif_hdr_t *netif_hdr,
gnrc_pktsnip_t *frag, size_t offset,
unsigned page);
/**
* @brief Checks if a reassembly buffer entry is unset
@ -118,7 +118,8 @@ void gnrc_sixlowpan_frag_rbuf_add(gnrc_netif_hdr_t *netif_hdr,
* @return true, if @p rbuf is empty (i.e. rbuf->super.pkt is NULL).
* @return false, if @p rbuf is in use.
*/
static inline bool gnrc_sixlowpan_frag_rbuf_entry_empty(const gnrc_sixlowpan_rbuf_t *rbuf) {
static inline bool gnrc_sixlowpan_frag_rb_entry_empty(
const gnrc_sixlowpan_frag_rb_t *rbuf) {
return (rbuf->pkt == NULL);
}
@ -128,7 +129,7 @@ static inline bool gnrc_sixlowpan_frag_rbuf_entry_empty(const gnrc_sixlowpan_rbu
*
* @note Only available when @ref TEST_SUITES is defined
*/
void gnrc_sixlowpan_frag_rbuf_reset(void);
void gnrc_sixlowpan_frag_rb_reset(void);
/**
* @brief Returns a pointer to the array representing the reassembly buffer.
@ -139,7 +140,7 @@ void gnrc_sixlowpan_frag_rbuf_reset(void);
* access is immediately spotted at compile time of tests. The `const`
* qualifier may however be discarded if required by the tests.
*/
const gnrc_sixlowpan_rbuf_t *gnrc_sixlowpan_frag_rbuf_array(void);
const gnrc_sixlowpan_frag_rb_t *gnrc_sixlowpan_frag_rb_array(void);
#endif
/**
@ -147,12 +148,12 @@ const gnrc_sixlowpan_rbuf_t *gnrc_sixlowpan_frag_rbuf_array(void);
*
* @param[in,out] entry Entry to remove
*/
void gnrc_sixlowpan_frag_rbuf_base_rm(gnrc_sixlowpan_rbuf_base_t *entry);
void gnrc_sixlowpan_frag_rb_base_rm(gnrc_sixlowpan_frag_rb_base_t *entry);
/**
* @brief Garbage collect reassembly buffer.
*/
void gnrc_sixlowpan_frag_rbuf_gc(void);
void gnrc_sixlowpan_frag_rb_gc(void);
#if defined(MODULE_GNRC_SIXLOWPAN_FRAG) || defined(DOXYGEN)
/**
@ -165,10 +166,10 @@ void gnrc_sixlowpan_frag_rbuf_gc(void);
*
* @param[in] rbuf A reassembly buffer entry. Must not be NULL.
*/
static inline void gnrc_sixlowpan_frag_rbuf_remove(gnrc_sixlowpan_rbuf_t *rbuf)
static inline void gnrc_sixlowpan_frag_rb_remove(gnrc_sixlowpan_frag_rb_t *rbuf)
{
assert(rbuf != NULL);
gnrc_sixlowpan_frag_rbuf_base_rm(&rbuf->super);
gnrc_sixlowpan_frag_rb_base_rm(&rbuf->super);
rbuf->pkt = NULL;
}
@ -184,13 +185,13 @@ static inline void gnrc_sixlowpan_frag_rbuf_remove(gnrc_sixlowpan_rbuf_t *rbuf)
* Used to construct the @ref gnrc_netif_hdr_t of the completed
* datagram. Must not be NULL.
*/
void gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(gnrc_sixlowpan_rbuf_t *rbuf,
gnrc_netif_hdr_t *netif);
void gnrc_sixlowpan_frag_rb_dispatch_when_complete(gnrc_sixlowpan_frag_rb_t *rbuf,
gnrc_netif_hdr_t *netif);
#else
/* NOPs to be used with gnrc_sixlowpan_iphc if gnrc_sixlowpan_frag is not
* compiled in */
#define gnrc_sixlowpan_frag_rbuf_remove(rbuf) (void)(rbuf)
#define gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(rbuf, netif) \
#define gnrc_sixlowpan_frag_rb_remove(rbuf) (void)(rbuf)
#define gnrc_sixlowpan_frag_rb_dispatch_when_complete(rbuf, netif) \
(void)(rbuf); (void)(netif)
#endif

6
sys/include/net/gnrc/sixlowpan/frag/vrb.h
View File

@ -38,7 +38,7 @@ extern "C" {
* @brief Representation of the virtual reassembly buffer entry
*/
typedef struct {
gnrc_sixlowpan_rbuf_base_t super; /**< base type */
gnrc_sixlowpan_frag_rb_base_t super; /**< base type */
/**
* @brief Link-layer destination address to which the fragments are
@ -76,7 +76,7 @@ typedef struct {
* @return NULL, if VRB is full.
*/
gnrc_sixlowpan_frag_vrb_t *gnrc_sixlowpan_frag_vrb_add(
const gnrc_sixlowpan_rbuf_base_t *base,
const gnrc_sixlowpan_frag_rb_base_t *base,
gnrc_netif_t *out_netif, const uint8_t *out_dst, size_t out_dst_len);
/**
@ -112,7 +112,7 @@ gnrc_sixlowpan_frag_vrb_t *gnrc_sixlowpan_frag_vrb_get(
static inline void gnrc_sixlowpan_frag_vrb_rm(gnrc_sixlowpan_frag_vrb_t *vrb)
{
#ifdef MODULE_GNRC_SIXLOWPAN_FRAG
gnrc_sixlowpan_frag_rbuf_base_rm(&vrb->super);
gnrc_sixlowpan_frag_rb_base_rm(&vrb->super);
#elif defined(TEST_SUITES)
/* for testing just zero datagram_size */
vrb->super.datagram_size = 0;

2
sys/include/net/gnrc/sixlowpan/iphc.h
View File

@ -38,7 +38,7 @@ extern "C" {
* be expected to start with the IPHC dispatch.
* @param[in,out] ctx Context for the packet. May be NULL. If not NULL it
* is expected to be of type
* @ref gnrc_sixlowpan_rbuf_t. This function might
* @ref gnrc_sixlowpan_frag_rb_t. This function might
* change the content of that.
* @param[in] page Current 6Lo dispatch parsing page.
*/

2
sys/net/gnrc/network_layer/sixlowpan/frag/gnrc_sixlowpan_frag.c
View File

@ -359,7 +359,7 @@ void gnrc_sixlowpan_frag_recv(gnrc_pktsnip_t *pkt, void *ctx, unsigned page)
return;
}
gnrc_sixlowpan_frag_rbuf_add(hdr, pkt, offset, page);
gnrc_sixlowpan_frag_rb_add(hdr, pkt, offset, page);
}
uint16_t gnrc_sixlowpan_frag_next_tag(void)

86
sys/net/gnrc/network_layer/sixlowpan/frag/rb/gnrc_sixlowpan_frag_rb.c
View File

@ -48,9 +48,9 @@
GNRC_SIXLOWPAN_FRAG_RBUF_SIZE)
#endif
static gnrc_sixlowpan_rbuf_int_t rbuf_int[RBUF_INT_SIZE];
static gnrc_sixlowpan_frag_rb_int_t rbuf_int[RBUF_INT_SIZE];
static gnrc_sixlowpan_rbuf_t rbuf[GNRC_SIXLOWPAN_FRAG_RBUF_SIZE];
static gnrc_sixlowpan_frag_rb_t rbuf[GNRC_SIXLOWPAN_FRAG_RBUF_SIZE];
static char l2addr_str[3 * IEEE802154_LONG_ADDRESS_LEN];
@ -61,18 +61,18 @@ static msg_t _gc_timer_msg = { .type = GNRC_SIXLOWPAN_MSG_FRAG_GC_RBUF };
* internal function definitions
* ------------------------------------*/
/* checks whether start and end overlaps, but not identical to, given interval i */
static inline bool _rbuf_int_overlap_partially(gnrc_sixlowpan_rbuf_int_t *i,
static inline bool _rbuf_int_overlap_partially(gnrc_sixlowpan_frag_rb_int_t *i,
uint16_t start, uint16_t end);
/* gets a free entry from interval buffer */
static gnrc_sixlowpan_rbuf_int_t *_rbuf_int_get_free(void);
static gnrc_sixlowpan_frag_rb_int_t *_rbuf_int_get_free(void);
/* update interval buffer of entry */
static bool _rbuf_update_ints(gnrc_sixlowpan_rbuf_base_t *entry,
static bool _rbuf_update_ints(gnrc_sixlowpan_frag_rb_base_t *entry,
uint16_t offset, size_t frag_size);
/* gets an entry identified by its tupel */
static gnrc_sixlowpan_rbuf_t *_rbuf_get(const void *src, size_t src_len,
const void *dst, size_t dst_len,
size_t size, uint16_t tag,
unsigned page);
static gnrc_sixlowpan_frag_rb_t *_rbuf_get(const void *src, size_t src_len,
const void *dst, size_t dst_len,
size_t size, uint16_t tag,
unsigned page);
/* internal add to repeat add when fragments overlapped */
static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
size_t offset, unsigned page);
@ -94,10 +94,10 @@ gnrc_sixlowpan_frag_stats_t *gnrc_sixlowpan_frag_stats_get(void)
}
#endif
static int _check_fragments(gnrc_sixlowpan_rbuf_base_t *entry,
static int _check_fragments(gnrc_sixlowpan_frag_rb_base_t *entry,
size_t frag_size, size_t offset)
{
gnrc_sixlowpan_rbuf_int_t *ptr = entry->ints;
gnrc_sixlowpan_frag_rb_int_t *ptr = entry->ints;
/* If the fragment overlaps another fragment and differs in either the size
* or the offset of the overlapped fragment, discards the datagram
@ -120,9 +120,9 @@ static int _check_fragments(gnrc_sixlowpan_rbuf_base_t *entry,
return RBUF_ADD_SUCCESS;
}
void gnrc_sixlowpan_frag_rbuf_add(gnrc_netif_hdr_t *netif_hdr,
gnrc_pktsnip_t *pkt, size_t offset,
unsigned page)
void gnrc_sixlowpan_frag_rb_add(gnrc_netif_hdr_t *netif_hdr,
gnrc_pktsnip_t *pkt, size_t offset,
unsigned page)
{
if (_rbuf_add(netif_hdr, pkt, offset, page) == RBUF_ADD_REPEAT) {
_rbuf_add(netif_hdr, pkt, offset, page);
@ -132,7 +132,7 @@ void gnrc_sixlowpan_frag_rbuf_add(gnrc_netif_hdr_t *netif_hdr,
static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
size_t offset, unsigned page)
{
gnrc_sixlowpan_rbuf_t *entry;
gnrc_sixlowpan_frag_rb_t *entry;
sixlowpan_frag_n_t *frag = pkt->data;
uint8_t *data = ((uint8_t *)pkt->data) + sizeof(sixlowpan_frag_t);
size_t frag_size;
@ -142,7 +142,7 @@ static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
SIXLOWPAN_FRAG_1_DISP)) && (offset == 0)) ||
((((frag->disp_size.u8[0] & SIXLOWPAN_FRAG_DISP_MASK) ==
SIXLOWPAN_FRAG_N_DISP)) && (offset == (frag->offset * 8U))));
gnrc_sixlowpan_frag_rbuf_gc();
gnrc_sixlowpan_frag_rb_gc();
entry = _rbuf_get(gnrc_netif_hdr_get_src_addr(netif_hdr), netif_hdr->src_l2addr_len,
gnrc_netif_hdr_get_dst_addr(netif_hdr), netif_hdr->dst_l2addr_len,
byteorder_ntohs(frag->disp_size) & SIXLOWPAN_FRAG_SIZE_MASK,
@ -170,7 +170,7 @@ static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
DEBUG("6lo rfrag: fragment too big for resulting datagram, discarding datagram\n");
gnrc_pktbuf_release(entry->pkt);
gnrc_pktbuf_release(pkt);
gnrc_sixlowpan_frag_rbuf_remove(entry);
gnrc_sixlowpan_frag_rb_remove(entry);
return RBUF_ADD_ERROR;
}
@ -178,7 +178,7 @@ static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
case RBUF_ADD_REPEAT:
DEBUG("6lo rfrag: overlapping intervals, discarding datagram\n");
gnrc_pktbuf_release(entry->pkt);
gnrc_sixlowpan_frag_rbuf_remove(entry);
gnrc_sixlowpan_frag_rb_remove(entry);
return RBUF_ADD_REPEAT;
case RBUF_ADD_DUPLICATE:
gnrc_pktbuf_release(pkt);
@ -198,7 +198,7 @@ static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
if (frag_hdr == NULL) {
gnrc_pktbuf_release(entry->pkt);
gnrc_pktbuf_release(pkt);
gnrc_sixlowpan_frag_rbuf_remove(entry);
gnrc_sixlowpan_frag_rb_remove(entry);
return RBUF_ADD_ERROR;
}
gnrc_sixlowpan_iphc_recv(pkt, entry, 0);
@ -213,12 +213,12 @@ static int _rbuf_add(gnrc_netif_hdr_t *netif_hdr, gnrc_pktsnip_t *pkt,
memcpy(((uint8_t *)entry->pkt->data) + offset, data,
frag_size);
}
gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(entry, netif_hdr);
gnrc_sixlowpan_frag_rb_dispatch_when_complete(entry, netif_hdr);
gnrc_pktbuf_release(pkt);
return RBUF_ADD_SUCCESS;
}
static inline bool _rbuf_int_overlap_partially(gnrc_sixlowpan_rbuf_int_t *i,
static inline bool _rbuf_int_overlap_partially(gnrc_sixlowpan_frag_rb_int_t *i,
uint16_t start, uint16_t end)
{
/* start and ends are both inclusive, so using <= for both */
@ -226,7 +226,7 @@ static inline bool _rbuf_int_overlap_partially(gnrc_sixlowpan_rbuf_int_t *i,
((start != i->start) || (end != i->end)); /* not identical */
}
static gnrc_sixlowpan_rbuf_int_t *_rbuf_int_get_free(void)
static gnrc_sixlowpan_frag_rb_int_t *_rbuf_int_get_free(void)
{
for (unsigned int i = 0; i < RBUF_INT_SIZE; i++) {
if (rbuf_int[i].end == 0) { /* start must be smaller than end anyways*/
@ -237,10 +237,10 @@ static gnrc_sixlowpan_rbuf_int_t *_rbuf_int_get_free(void)
return NULL;
}
static bool _rbuf_update_ints(gnrc_sixlowpan_rbuf_base_t *entry,
static bool _rbuf_update_ints(gnrc_sixlowpan_frag_rb_base_t *entry,
uint16_t offset, size_t frag_size)
{
gnrc_sixlowpan_rbuf_int_t *new;
gnrc_sixlowpan_frag_rb_int_t *new;
uint16_t end = (uint16_t)(offset + frag_size - 1);
new = _rbuf_int_get_free();
@ -267,14 +267,14 @@ static bool _rbuf_update_ints(gnrc_sixlowpan_rbuf_base_t *entry,
return true;
}
void gnrc_sixlowpan_frag_rbuf_gc(void)
void gnrc_sixlowpan_frag_rb_gc(void)
{
uint32_t now_usec = xtimer_now_usec();
unsigned int i;
for (i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
/* since pkt occupies pktbuf, aggressivly collect garbage */
if (!gnrc_sixlowpan_frag_rbuf_entry_empty(&rbuf[i]) &&
if (!gnrc_sixlowpan_frag_rb_entry_empty(&rbuf[i]) &&
((now_usec - rbuf[i].super.arrival) >
GNRC_SIXLOWPAN_FRAG_RBUF_TIMEOUT_US)) {
DEBUG("6lo rfrag: entry (%s, ",
@ -288,7 +288,7 @@ void gnrc_sixlowpan_frag_rbuf_gc(void)
(unsigned)rbuf[i].super.datagram_size, rbuf[i].super.tag);
gnrc_pktbuf_release(rbuf[i].pkt);
gnrc_sixlowpan_frag_rbuf_remove(&(rbuf[i]));
gnrc_sixlowpan_frag_rb_remove(&(rbuf[i]));
}
}
#ifdef MODULE_GNRC_SIXLOWPAN_FRAG_VRB
@ -302,12 +302,12 @@ static inline void _set_rbuf_timeout(void)
&_gc_timer_msg, sched_active_pid);
}
static gnrc_sixlowpan_rbuf_t *_rbuf_get(const void *src, size_t src_len,
const void *dst, size_t dst_len,
size_t size, uint16_t tag,
unsigned page)
static gnrc_sixlowpan_frag_rb_t *_rbuf_get(const void *src, size_t src_len,
const void *dst, size_t dst_len,
size_t size, uint16_t tag,
unsigned page)
{
gnrc_sixlowpan_rbuf_t *res = NULL, *oldest = NULL;
gnrc_sixlowpan_frag_rb_t *res = NULL, *oldest = NULL;
uint32_t now_usec = xtimer_now_usec();
for (unsigned int i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
@ -332,7 +332,7 @@ static gnrc_sixlowpan_rbuf_t *_rbuf_get(const void *src, size_t src_len,
}
/* if there is a free spot: remember it */
if ((res == NULL) && gnrc_sixlowpan_frag_rbuf_entry_empty(&rbuf[i])) {
if ((res == NULL) && gnrc_sixlowpan_frag_rb_entry_empty(&rbuf[i])) {
res = &(rbuf[i]);
}
@ -349,13 +349,13 @@ static gnrc_sixlowpan_rbuf_t *_rbuf_get(const void *src, size_t src_len,
assert(oldest != NULL);
/* if oldest is not empty, res must not be NULL (because otherwise
* oldest could have been picked as res) */
assert(!gnrc_sixlowpan_frag_rbuf_entry_empty(oldest));
assert(!gnrc_sixlowpan_frag_rb_entry_empty(oldest));
if (GNRC_SIXLOWPAN_FRAG_RBUF_AGGRESSIVE_OVERRIDE ||
((now_usec - oldest->super.arrival) >
GNRC_SIXLOWPAN_FRAG_RBUF_TIMEOUT_US)) {
DEBUG("6lo rfrag: reassembly buffer full, remove oldest entry\n");
gnrc_pktbuf_release(oldest->pkt);
gnrc_sixlowpan_frag_rbuf_remove(oldest);
gnrc_sixlowpan_frag_rb_remove(oldest);
res = oldest;
#if GNRC_SIXLOWPAN_FRAG_RBUF_AGGRESSIVE_OVERRIDE && \
defined(MODULE_GNRC_SIXLOWPAN_FRAG_STATS)
@ -414,7 +414,7 @@ static gnrc_sixlowpan_rbuf_t *_rbuf_get(const void *src, size_t src_len,
}
#ifdef TEST_SUITES
void gnrc_sixlowpan_frag_rbuf_reset(void)
void gnrc_sixlowpan_frag_rb_reset(void)
{
xtimer_remove(&_gc_timer);
memset(rbuf_int, 0, sizeof(rbuf_int));
@ -427,16 +427,16 @@ void gnrc_sixlowpan_frag_rbuf_reset(void)
memset(rbuf, 0, sizeof(rbuf));
}
const gnrc_sixlowpan_rbuf_t *gnrc_sixlowpan_frag_rbuf_array(void)
const gnrc_sixlowpan_frag_rb_t *gnrc_sixlowpan_frag_rb_array(void)
{
return &rbuf[0];
}
#endif
void gnrc_sixlowpan_frag_rbuf_base_rm(gnrc_sixlowpan_rbuf_base_t *entry)
void gnrc_sixlowpan_frag_rb_base_rm(gnrc_sixlowpan_frag_rb_base_t *entry)
{
while (entry->ints != NULL) {
gnrc_sixlowpan_rbuf_int_t *next = entry->ints->next;
gnrc_sixlowpan_frag_rb_int_t *next = entry->ints->next;
entry->ints->start = 0;
entry->ints->end = 0;
@ -446,8 +446,8 @@ void gnrc_sixlowpan_frag_rbuf_base_rm(gnrc_sixlowpan_rbuf_base_t *entry)
entry->datagram_size = 0;
}
void gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(gnrc_sixlowpan_rbuf_t *rbuf,
gnrc_netif_hdr_t *netif_hdr)
void gnrc_sixlowpan_frag_rb_dispatch_when_complete(gnrc_sixlowpan_frag_rb_t *rbuf,
gnrc_netif_hdr_t *netif_hdr)
{
assert(rbuf);
assert(netif_hdr);
@ -460,7 +460,7 @@ void gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(gnrc_sixlowpan_rbuf_t *rbuf
if (netif == NULL) {
DEBUG("6lo rbuf: error allocating netif header\n");
gnrc_pktbuf_release(rbuf->pkt);
gnrc_sixlowpan_frag_rbuf_remove(rbuf);
gnrc_sixlowpan_frag_rb_remove(rbuf);
return;
}
@ -475,7 +475,7 @@ void gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(gnrc_sixlowpan_rbuf_t *rbuf
new_netif_hdr->rssi = netif_hdr->rssi;
LL_APPEND(rbuf->pkt, netif);
gnrc_sixlowpan_dispatch_recv(rbuf->pkt, NULL, 0);
gnrc_sixlowpan_frag_rbuf_remove(rbuf);
gnrc_sixlowpan_frag_rb_remove(rbuf);
}
}

2
sys/net/gnrc/network_layer/sixlowpan/frag/vrb/gnrc_sixlowpan_frag_vrb.c
View File

@ -35,7 +35,7 @@ uint16_t gnrc_sixlowpan_frag_next_tag(void)
#endif /* !defined(MODULE_GNRC_SIXLOWPAN_FRAG) && defined(TEST_SUITES) */
gnrc_sixlowpan_frag_vrb_t *gnrc_sixlowpan_frag_vrb_add(
const gnrc_sixlowpan_rbuf_base_t *base,
const gnrc_sixlowpan_frag_rb_base_t *base,
gnrc_netif_t *out_netif, const uint8_t *out_dst, size_t out_dst_len)
{
gnrc_sixlowpan_frag_vrb_t *vrbe = NULL;

2
sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c
View File

@ -350,7 +350,7 @@ static void *_event_loop(void *args)
break;
case GNRC_SIXLOWPAN_MSG_FRAG_GC_RBUF:
DEBUG("6lo: garbage collect reassembly buffer event received\n");
gnrc_sixlowpan_frag_rbuf_gc();
gnrc_sixlowpan_frag_rb_gc();
break;
#endif

8
sys/net/gnrc/network_layer/sixlowpan/iphc/gnrc_sixlowpan_iphc.c
View File

@ -218,9 +218,9 @@ static size_t _iphc_nhc_udp_decode(gnrc_pktsnip_t *sixlo, size_t offset,
static inline void _recv_error_release(gnrc_pktsnip_t *sixlo,
gnrc_pktsnip_t *ipv6,
gnrc_sixlowpan_rbuf_t *rbuf) {
gnrc_sixlowpan_frag_rb_t *rbuf) {
if (rbuf != NULL) {
gnrc_sixlowpan_frag_rbuf_remove(rbuf);
gnrc_sixlowpan_frag_rb_remove(rbuf);
}
gnrc_pktbuf_release(ipv6);
gnrc_pktbuf_release(sixlo);
@ -238,7 +238,7 @@ void gnrc_sixlowpan_iphc_recv(gnrc_pktsnip_t *sixlo, void *rbuf_ptr,
size_t payload_offset = SIXLOWPAN_IPHC_HDR_LEN;
size_t uncomp_hdr_len = sizeof(ipv6_hdr_t);
gnrc_sixlowpan_ctx_t *ctx = NULL;
gnrc_sixlowpan_rbuf_t *rbuf = rbuf_ptr;
gnrc_sixlowpan_frag_rb_t *rbuf = rbuf_ptr;
if (rbuf != NULL) {
ipv6 = rbuf->pkt;
@ -582,7 +582,7 @@ void gnrc_sixlowpan_iphc_recv(gnrc_pktsnip_t *sixlo, void *rbuf_ptr,
sixlo->size - payload_offset);
if (rbuf != NULL) {
rbuf->super.current_size += (uncomp_hdr_len - payload_offset);
gnrc_sixlowpan_frag_rbuf_dispatch_when_complete(rbuf, netif_hdr);
gnrc_sixlowpan_frag_rb_dispatch_when_complete(rbuf, netif_hdr);
}
else {
LL_DELETE(sixlo, netif);

132
tests/gnrc_sixlowpan_frag/main.c
View File

@ -184,7 +184,7 @@ static inline void _set_fragment_offset(void *frag, uint16_t offset)
static void _set_up(void)
{
gnrc_sixlowpan_frag_rbuf_reset();
gnrc_sixlowpan_frag_rb_reset();
gnrc_pktbuf_init();
gnrc_netif_hdr_init(&_test_netif_hdr.hdr,
GNRC_NETIF_HDR_L2ADDR_MAX_LEN,
@ -205,19 +205,19 @@ static void _set_up(void)
_set_fragment_offset(_fragment4, TEST_FRAGMENT4_OFFSET);
}
static const gnrc_sixlowpan_rbuf_t *_first_non_empty_rbuf(void)
static const gnrc_sixlowpan_frag_rb_t *_first_non_empty_rbuf(void)
{
const gnrc_sixlowpan_rbuf_t *rbuf = gnrc_sixlowpan_frag_rbuf_array();
const gnrc_sixlowpan_frag_rb_t *rbuf = gnrc_sixlowpan_frag_rb_array();
for (unsigned i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
if (!gnrc_sixlowpan_frag_rbuf_entry_empty(&rbuf[i])) {
if (!gnrc_sixlowpan_frag_rb_entry_empty(&rbuf[i])) {
return rbuf;
}
}
return NULL;
}
static void _test_entry(const gnrc_sixlowpan_rbuf_t *entry,
static void _test_entry(const gnrc_sixlowpan_frag_rb_t *entry,
unsigned exp_current_size,
unsigned exp_int_start, unsigned exp_int_end)
{
@ -242,7 +242,7 @@ static void _test_entry(const gnrc_sixlowpan_rbuf_t *entry,
TEST_ASSERT_EQUAL_INT(exp_int_end, entry->super.ints->end);
}
static void _check_pktbuf(const gnrc_sixlowpan_rbuf_t *entry)
static void _check_pktbuf(const gnrc_sixlowpan_frag_rb_t *entry)
{
if (entry != NULL) {
gnrc_pktbuf_release(entry->pkt);
@ -254,11 +254,11 @@ static void test_rbuf_add__success_first_fragment(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, _fragment1, sizeof(_fragment1),
GNRC_NETTYPE_SIXLOWPAN);
const gnrc_sixlowpan_rbuf_t *entry;
const gnrc_sixlowpan_frag_rb_t *entry;
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
entry = _first_non_empty_rbuf();
/* current_size must be the offset of fragment 2, not the size of
* fragment 1 (fragment dispatch was removed, IPHC was applied etc.). */
@ -271,11 +271,11 @@ static void test_rbuf_add__success_subsequent_fragment(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, _fragment2, sizeof(_fragment2),
GNRC_NETTYPE_SIXLOWPAN);
const gnrc_sixlowpan_rbuf_t *entry;
const gnrc_sixlowpan_frag_rb_t *entry;
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT2_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT2_OFFSET, TEST_PAGE);
entry = _first_non_empty_rbuf();
/* current_size must be the offset of fragment 3, not the size of
* fragment 2 (fragment dispatch was removed, IPHC was applied etc.). */
@ -290,14 +290,14 @@ static void test_rbuf_add__success_duplicate_fragments(void)
GNRC_NETTYPE_SIXLOWPAN);
gnrc_pktsnip_t *pkt2 = gnrc_pktbuf_add(NULL, _fragment3, sizeof(_fragment3),
GNRC_NETTYPE_SIXLOWPAN);
const gnrc_sixlowpan_rbuf_t *entry;
const gnrc_sixlowpan_frag_rb_t *entry;
TEST_ASSERT_NOT_NULL(pkt1);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt2);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt2,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt2,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
entry = _first_non_empty_rbuf();
/* current_size must be the offset of fragment 4, not the size of
* fragment 3 (fragment dispatch was removed, IPHC was applied etc.). */
@ -326,17 +326,17 @@ static void test_rbuf_add__success_complete(void)
gnrc_netreg_register(TEST_DATAGRAM_NETTYPE, &reg);
/* Mixing up things. Order decided by fair dice-rolls ;-) */
TEST_ASSERT_NOT_NULL(pkt2);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt2,
TEST_FRAGMENT2_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt2,
TEST_FRAGMENT2_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt4);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt4,
TEST_FRAGMENT4_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt4,
TEST_FRAGMENT4_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt1);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt3);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt3,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt3,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
TEST_ASSERT_MESSAGE(
xtimer_msg_receive_timeout(&msg, TEST_RECEIVE_TIMEOUT) >= 0,
"Receiving reassembled datagram timed out"
@ -357,27 +357,27 @@ static void test_rbuf_add__success_complete(void)
static void test_rbuf_add__full_rbuf(void)
{
gnrc_pktsnip_t *pkt;
const gnrc_sixlowpan_rbuf_t *rbuf;
const gnrc_sixlowpan_frag_rb_t *rbuf;
for (unsigned i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
pkt = gnrc_pktbuf_add(NULL, _fragment1, sizeof(_fragment1),
GNRC_NETTYPE_SIXLOWPAN);
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
_set_fragment_tag(_fragment1, TEST_TAG + i + 1);
/* pkt is released in gnrc_sixlowpan_frag_rbuf_add() */
/* pkt is released in gnrc_sixlowpan_frag_rb_add() */
}
pkt = gnrc_pktbuf_add(NULL, _fragment1, sizeof(_fragment1),
GNRC_NETTYPE_SIXLOWPAN);
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
rbuf = gnrc_sixlowpan_frag_rbuf_array();
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
rbuf = gnrc_sixlowpan_frag_rb_array();
for (unsigned i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
const gnrc_sixlowpan_rbuf_t *entry = &rbuf[i];
const gnrc_sixlowpan_frag_rb_t *entry = &rbuf[i];
TEST_ASSERT_MESSAGE(!gnrc_sixlowpan_frag_rbuf_entry_empty(entry),
TEST_ASSERT_MESSAGE(!gnrc_sixlowpan_frag_rb_entry_empty(entry),
"Reassembly buffer entry unexpectedly empty");
TEST_ASSERT((sizeof(_fragment1) - sizeof(sixlowpan_frag_t)) <
entry->pkt->size);
@ -405,8 +405,8 @@ static void test_rbuf_add__too_big_fragment(void)
GNRC_NETTYPE_SIXLOWPAN);
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
/* packet buffer is empty*/
TEST_ASSERT_NULL(_first_non_empty_rbuf());
_check_pktbuf(NULL);
@ -418,22 +418,22 @@ static void test_rbuf_add__overlap_lhs(void)
gnrc_pktsnip_t *pkt1 = gnrc_pktbuf_add(NULL, _fragment1, sizeof(_fragment1),
GNRC_NETTYPE_SIXLOWPAN);
gnrc_pktsnip_t *pkt2;
const gnrc_sixlowpan_rbuf_t *rbuf;
const gnrc_sixlowpan_frag_rb_t *rbuf;
unsigned rbuf_entries = 0;
_set_fragment_offset(_fragment2, pkt2_offset);
pkt2 = gnrc_pktbuf_add(NULL, _fragment2, sizeof(_fragment2),
GNRC_NETTYPE_SIXLOWPAN);
TEST_ASSERT_NOT_NULL(pkt1);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt2);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt2, pkt2_offset,
TEST_PAGE);
rbuf = gnrc_sixlowpan_frag_rbuf_array();
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt2, pkt2_offset,
TEST_PAGE);
rbuf = gnrc_sixlowpan_frag_rb_array();
for (unsigned i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
const gnrc_sixlowpan_rbuf_t *entry = &rbuf[i];
if (!gnrc_sixlowpan_frag_rbuf_entry_empty(entry)) {
const gnrc_sixlowpan_frag_rb_t *entry = &rbuf[i];
if (!gnrc_sixlowpan_frag_rb_entry_empty(entry)) {
static const size_t pkt3_offset = TEST_FRAGMENT3_OFFSET - 8U - 1;
rbuf_entries++;
@ -461,25 +461,25 @@ static void test_rbuf_add__overlap_rhs(void)
gnrc_pktsnip_t *pkt2;
gnrc_pktsnip_t *pkt3 = gnrc_pktbuf_add(NULL, _fragment3, sizeof(_fragment3),
GNRC_NETTYPE_SIXLOWPAN);
const gnrc_sixlowpan_rbuf_t *rbuf;
const gnrc_sixlowpan_frag_rb_t *rbuf;
unsigned rbuf_entries = 0;
_set_fragment_offset(_fragment2, pkt2_offset);
pkt2 = gnrc_pktbuf_add(NULL, _fragment2, sizeof(_fragment2),
GNRC_NETTYPE_SIXLOWPAN);
TEST_ASSERT_NOT_NULL(pkt1);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt1,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt3);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt3,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt3,
TEST_FRAGMENT3_OFFSET, TEST_PAGE);
TEST_ASSERT_NOT_NULL(pkt2);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt2, pkt2_offset,
TEST_PAGE);
rbuf = gnrc_sixlowpan_frag_rbuf_array();
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt2, pkt2_offset,
TEST_PAGE);
rbuf = gnrc_sixlowpan_frag_rb_array();
for (unsigned i = 0; i < GNRC_SIXLOWPAN_FRAG_RBUF_SIZE; i++) {
const gnrc_sixlowpan_rbuf_t *entry = &rbuf[i];
if (!gnrc_sixlowpan_frag_rbuf_entry_empty(entry)) {
const gnrc_sixlowpan_frag_rb_t *entry = &rbuf[i];
if (!gnrc_sixlowpan_frag_rb_entry_empty(entry)) {
static const size_t pkt3_offset = TEST_FRAGMENT3_OFFSET + 8U - 1U;
rbuf_entries++;
@ -501,7 +501,7 @@ static void test_rbuf_add__overlap_rhs(void)
static void test_rbuf_rm(void)
{
const gnrc_sixlowpan_rbuf_t *entry;
const gnrc_sixlowpan_frag_rb_t *entry;
test_rbuf_add__success_first_fragment();
entry = _first_non_empty_rbuf();
@ -509,7 +509,7 @@ static void test_rbuf_rm(void)
TEST_ASSERT_NOT_NULL(entry);
/* intentionally discarding const qualifier since we enter rbuf's internal
* context again */
gnrc_sixlowpan_frag_rbuf_remove((gnrc_sixlowpan_rbuf_t *)entry);
gnrc_sixlowpan_frag_rb_remove((gnrc_sixlowpan_frag_rb_t *)entry);
/* reassembly buffer is now empty */
TEST_ASSERT_NULL(_first_non_empty_rbuf());
_check_pktbuf(NULL);
@ -519,17 +519,17 @@ static void test_rbuf_gc__manually(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, _fragment1, sizeof(_fragment1),
GNRC_NETTYPE_SIXLOWPAN);
gnrc_sixlowpan_rbuf_t *entry;
gnrc_sixlowpan_frag_rb_t *entry;
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
/* discarding const qualifier intentionally to override `arrival` */
entry = (gnrc_sixlowpan_rbuf_t *)_first_non_empty_rbuf();
entry = (gnrc_sixlowpan_frag_rb_t *)_first_non_empty_rbuf();
TEST_ASSERT_NOT_NULL(entry);
/* set arrival GNRC_SIXLOWPAN_FRAG_RBUF_TIMEOUT_US into the past */
entry->super.arrival -= GNRC_SIXLOWPAN_FRAG_RBUF_TIMEOUT_US;
gnrc_sixlowpan_frag_rbuf_gc();
gnrc_sixlowpan_frag_rb_gc();
/* reassembly buffer is now empty */
TEST_ASSERT_NULL(_first_non_empty_rbuf());
_check_pktbuf(NULL);
@ -540,20 +540,20 @@ static void test_rbuf_gc__timed(void)
msg_t msg;
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, _fragment1, sizeof(_fragment1),
GNRC_NETTYPE_SIXLOWPAN);
gnrc_sixlowpan_rbuf_t *entry;
gnrc_sixlowpan_frag_rb_t *entry;
TEST_ASSERT_NOT_NULL(pkt);
gnrc_sixlowpan_frag_rbuf_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
gnrc_sixlowpan_frag_rb_add(&_test_netif_hdr.hdr, pkt,
TEST_FRAGMENT1_OFFSET, TEST_PAGE);
/* discarding const qualifier intentionally to override `arrival` */
entry = (gnrc_sixlowpan_rbuf_t *)_first_non_empty_rbuf();
entry = (gnrc_sixlowpan_frag_rb_t *)_first_non_empty_rbuf();
TEST_ASSERT_NOT_NULL(entry);
TEST_ASSERT_MESSAGE(
xtimer_msg_receive_timeout(&msg, TEST_GC_TIMEOUT) >= 0,
"Waiting for GC timer timed out"
);
TEST_ASSERT_EQUAL_INT(GNRC_SIXLOWPAN_MSG_FRAG_GC_RBUF, msg.type);
gnrc_sixlowpan_frag_rbuf_gc();
gnrc_sixlowpan_frag_rb_gc();
/* reassembly buffer is now empty */
TEST_ASSERT_NULL(_first_non_empty_rbuf());
_check_pktbuf(NULL);

22
tests/unittests/tests-gnrc_sixlowpan_frag_vrb/tests-gnrc_sixlowpan_frag_vrb.c
View File

@ -45,13 +45,13 @@ static void set_up(void)
static void test_vrb_add__success(void)
{
static const gnrc_sixlowpan_rbuf_int_t interval = {
static const gnrc_sixlowpan_frag_rb_int_t interval = {
.next = NULL,
.start = 0,
.end = 116U,
};
static const gnrc_sixlowpan_rbuf_base_t base = {
.ints = (gnrc_sixlowpan_rbuf_int_t *)&interval,
static const gnrc_sixlowpan_frag_rb_base_t base = {
.ints = (gnrc_sixlowpan_frag_rb_int_t *)&interval,
.src = TEST_SRC,
.dst = TEST_DST,
.src_len = TEST_SRC_LEN,
@ -96,13 +96,13 @@ static void test_vrb_add__success(void)
static void test_vrb_add__duplicate(void)
{
static const gnrc_sixlowpan_rbuf_int_t interval = {
static const gnrc_sixlowpan_frag_rb_int_t interval = {
.next = NULL,
.start = 0,
.end = 116U,
};
static const gnrc_sixlowpan_rbuf_base_t base = {
.ints = (gnrc_sixlowpan_rbuf_int_t *)&interval,
static const gnrc_sixlowpan_frag_rb_base_t base = {
.ints = (gnrc_sixlowpan_frag_rb_int_t *)&interval,
.src = TEST_SRC,
.dst = TEST_DST,
.src_len = TEST_SRC_LEN,
@ -129,7 +129,7 @@ static void test_vrb_add__duplicate(void)
static void test_vrb_add__full(void)
{
gnrc_sixlowpan_rbuf_base_t base = {
gnrc_sixlowpan_frag_rb_base_t base = {
.ints = NULL,
.src = TEST_SRC,
.dst = TEST_DST,
@ -161,7 +161,7 @@ static void test_vrb_add__full(void)
static void test_vrb_get__empty(void)
{
static const gnrc_sixlowpan_rbuf_base_t base = {
static const gnrc_sixlowpan_frag_rb_base_t base = {
.ints = NULL,
.src = TEST_SRC,
.dst = TEST_DST,
@ -179,7 +179,7 @@ static void test_vrb_get__empty(void)
static void test_vrb_get__after_add(void)
{
static const gnrc_sixlowpan_rbuf_base_t base = {
static const gnrc_sixlowpan_frag_rb_base_t base = {
.ints = NULL,
.src = TEST_SRC,
.dst = TEST_DST,
@ -208,7 +208,7 @@ static void test_vrb_get__after_add(void)
static void test_vrb_rm(void)
{
static const gnrc_sixlowpan_rbuf_base_t base = {
static const gnrc_sixlowpan_frag_rb_base_t base = {
.ints = NULL,
.src = TEST_SRC,
.dst = TEST_DST,
@ -234,7 +234,7 @@ static void test_vrb_rm(void)
static void test_vrb_gc(void)
{
gnrc_sixlowpan_rbuf_base_t base = {
gnrc_sixlowpan_frag_rb_base_t base = {
.ints = NULL,
.src = TEST_SRC,
.dst = TEST_DST,