From e9ff46b2ead4f447725d82cade1690bfc7e7c5a2 Mon Sep 17 00:00:00 2001 From: Martine Lenders Date: Sat, 28 Sep 2019 12:11:54 +0200 Subject: [PATCH] gnrc_sixlowpan_frag_rb: unify naming scheme --- sys/include/net/gnrc/sixlowpan.h | 2 +- sys/include/net/gnrc/sixlowpan/config.h | 2 +- sys/include/net/gnrc/sixlowpan/frag/rb.h | 47 ++++--- sys/include/net/gnrc/sixlowpan/frag/vrb.h | 6 +- sys/include/net/gnrc/sixlowpan/iphc.h | 2 +- .../sixlowpan/frag/gnrc_sixlowpan_frag.c | 2 +- .../frag/rb/gnrc_sixlowpan_frag_rb.c | 86 ++++++------ .../frag/vrb/gnrc_sixlowpan_frag_vrb.c | 2 +- .../network_layer/sixlowpan/gnrc_sixlowpan.c | 2 +- .../sixlowpan/iphc/gnrc_sixlowpan_iphc.c | 8 +- tests/gnrc_sixlowpan_frag/main.c | 132 +++++++++--------- .../tests-gnrc_sixlowpan_frag_vrb.c | 22 +-- 12 files changed, 157 insertions(+), 156 deletions(-) diff --git a/sys/include/net/gnrc/sixlowpan.h b/sys/include/net/gnrc/sixlowpan.h index b2e1a190a2..e7c0c81357 100644 --- a/sys/include/net/gnrc/sixlowpan.h +++ b/sys/include/net/gnrc/sixlowpan.h @@ -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 diff --git a/sys/include/net/gnrc/sixlowpan/config.h b/sys/include/net/gnrc/sixlowpan/config.h index 84a825c135..b800ed8933 100644 --- a/sys/include/net/gnrc/sixlowpan/config.h +++ b/sys/include/net/gnrc/sixlowpan/config.h @@ -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 diff --git a/sys/include/net/gnrc/sixlowpan/frag/rb.h b/sys/include/net/gnrc/sixlowpan/frag/rb.h index 87e24aff69..36f404ea6f 100644 --- a/sys/include/net/gnrc/sixlowpan/frag/rb.h +++ b/sys/include/net/gnrc/sixlowpan/frag/rb.h @@ -42,14 +42,14 @@ extern "C" { * RFC 4944, section 5.3 * */ -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 diff --git a/sys/include/net/gnrc/sixlowpan/frag/vrb.h b/sys/include/net/gnrc/sixlowpan/frag/vrb.h index 21df143836..1a16586953 100644 --- a/sys/include/net/gnrc/sixlowpan/frag/vrb.h +++ b/sys/include/net/gnrc/sixlowpan/frag/vrb.h @@ -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; diff --git a/sys/include/net/gnrc/sixlowpan/iphc.h b/sys/include/net/gnrc/sixlowpan/iphc.h index 7e60d25a1a..ee9a5508df 100644 --- a/sys/include/net/gnrc/sixlowpan/iphc.h +++ b/sys/include/net/gnrc/sixlowpan/iphc.h @@ -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. */ diff --git a/sys/net/gnrc/network_layer/sixlowpan/frag/gnrc_sixlowpan_frag.c b/sys/net/gnrc/network_layer/sixlowpan/frag/gnrc_sixlowpan_frag.c index a750e9660e..4c418db811 100644 --- a/sys/net/gnrc/network_layer/sixlowpan/frag/gnrc_sixlowpan_frag.c +++ b/sys/net/gnrc/network_layer/sixlowpan/frag/gnrc_sixlowpan_frag.c @@ -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) diff --git a/sys/net/gnrc/network_layer/sixlowpan/frag/rb/gnrc_sixlowpan_frag_rb.c b/sys/net/gnrc/network_layer/sixlowpan/frag/rb/gnrc_sixlowpan_frag_rb.c index 5d98131c9f..f389681ca3 100644 --- a/sys/net/gnrc/network_layer/sixlowpan/frag/rb/gnrc_sixlowpan_frag_rb.c +++ b/sys/net/gnrc/network_layer/sixlowpan/frag/rb/gnrc_sixlowpan_frag_rb.c @@ -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); } } diff --git a/sys/net/gnrc/network_layer/sixlowpan/frag/vrb/gnrc_sixlowpan_frag_vrb.c b/sys/net/gnrc/network_layer/sixlowpan/frag/vrb/gnrc_sixlowpan_frag_vrb.c index a2abf73a10..a37d466327 100644 --- a/sys/net/gnrc/network_layer/sixlowpan/frag/vrb/gnrc_sixlowpan_frag_vrb.c +++ b/sys/net/gnrc/network_layer/sixlowpan/frag/vrb/gnrc_sixlowpan_frag_vrb.c @@ -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; diff --git a/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c b/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c index bf123ad16e..3c57df4b8c 100644 --- a/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c +++ b/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c @@ -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 diff --git a/sys/net/gnrc/network_layer/sixlowpan/iphc/gnrc_sixlowpan_iphc.c b/sys/net/gnrc/network_layer/sixlowpan/iphc/gnrc_sixlowpan_iphc.c index e79347531a..4f007dead6 100644 --- a/sys/net/gnrc/network_layer/sixlowpan/iphc/gnrc_sixlowpan_iphc.c +++ b/sys/net/gnrc/network_layer/sixlowpan/iphc/gnrc_sixlowpan_iphc.c @@ -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); diff --git a/tests/gnrc_sixlowpan_frag/main.c b/tests/gnrc_sixlowpan_frag/main.c index 12da5838be..299ca68118 100644 --- a/tests/gnrc_sixlowpan_frag/main.c +++ b/tests/gnrc_sixlowpan_frag/main.c @@ -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, ®); /* 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); diff --git a/tests/unittests/tests-gnrc_sixlowpan_frag_vrb/tests-gnrc_sixlowpan_frag_vrb.c b/tests/unittests/tests-gnrc_sixlowpan_frag_vrb/tests-gnrc_sixlowpan_frag_vrb.c index 6b2feb4de1..8e6393d282 100644 --- a/tests/unittests/tests-gnrc_sixlowpan_frag_vrb/tests-gnrc_sixlowpan_frag_vrb.c +++ b/tests/unittests/tests-gnrc_sixlowpan_frag_vrb/tests-gnrc_sixlowpan_frag_vrb.c @@ -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,