RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

fib: initial source route support

Browse Source
This commit is contained in:
BytesGalore 2015-08-05 14:40:49 +02:00
parent fac55ca258
commit 6c57582107
9 changed files with 2111 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

265
sys/include/net/fib.h
View File

@ -15,6 +15,8 @@
*
* @file
* @brief Types and functions for FIB
* @note The used fib_table_t* used in all essential FIB functions
* MUST be valid.
*
* @author Martin Landsmann <martin.landsmann@haw-hamburg.de>
* @author Oliver Hahm <oliver.hahm@inria.fr>
@ -41,7 +43,20 @@ typedef struct rp_address_msg_t {
uint32_t address_flags; /**< The flags for the given address */
} rp_address_msg_t;
#define FIB_MSG_RP_SIGNAL (0x99) /**< message type for RP notifications */
/**
* @brief message type for RP notification: unreachable destination
*/
#define FIB_MSG_RP_SIGNAL_UNREACHABLE_DESTINATION (0x99)
/**
* @brief message type for RP notification: entry used
*/
#define FIB_MSG_RP_SIGNAL_DESTINATION_USED (0x98)
/**
* @brief message type for RP notification: sr created
*/
#define FIB_MSG_RP_SIGNAL_SOURCE_ROUTE_CREATED (0x97)
/**
* @brief the size in bytes of a full address
@ -58,7 +73,7 @@ typedef struct fib_destination_set_entry_t {
} fib_destination_set_entry_t;
/**
* @brief indicator of a lifetime that does not expire (2^32 - 1)
* @brief indicator of a lifetime that does not expire (2^64 - 1)
*/
#define FIB_LIFETIME_NO_EXPIRE (0xFFFFFFFFffffffff)
@ -71,15 +86,13 @@ typedef struct fib_destination_set_entry_t {
* @brief initializes all FIB entries with 0
*
* @param[in] table the fib instance to initialize
*
* @pre @p table is not NULL and points to a pre-filled struct
*/
void fib_init(fib_table_t *table);
/**
* @brief de-initializes the FIB entries
* @brief de-initializes the FIB entries and source route entries
*
* @param[in] table the fib instance to de-initialize
* @param[in] table the fib instance to de-initialize
*/
void fib_deinit(fib_table_t *table);
@ -196,6 +209,238 @@ int fib_get_destination_set(fib_table_t *table, uint8_t *prefix,
fib_destination_set_entry_t *dst_set,
size_t *dst_set_size);
/**
* @brief creates a new source route
*
* @param[in, out] table the table the new source route belongs to
* @param[in, out] fib_sr pointer to store the new created source route pointer
* @param[in] sr_iface_id the interface ID used for the created source route
* @param[in] sr_flags the flags for the source route
* @param[in] sr_lifetime the lifetime in ms of the source route
*
* @return 0 on success
* -EFAULT on wrong parameters, i.e. fib_sr is NULL and/or sr_lifetime is 0
* -ENOBUFS on insufficient memory, i.e. all source route fields are in use
*/
int fib_sr_create(fib_table_t *table, fib_sr_t **fib_sr, kernel_pid_t sr_iface_id,
uint32_t sr_flags, uint32_t sr_lifetime);
/**
* @brief reads the information from the sr head to the given locations
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to read from
* @param[in, out] sr_iface_id pointer to store the iface_id
* @param[in, out] sr_flags pointer to store the flags
* @param[in, out] sr_lifetime pointer to store the current left lifetime
*
* @return 0 on success
* -ENOENT on expired lifetime of the source route
* -EFAULT on fib_sr is NULL
*/
int fib_sr_read_head(fib_table_t *table, fib_sr_t *fib_sr, kernel_pid_t *sr_iface_id,
uint32_t *sr_flags, uint32_t *sr_lifetime);
/**
* @brief reads the destination address from the sr head to the given location
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to read from
* @param[in, out] dst pointer to the store destination address bytes
* @param[in, out] dst_size pointer to store the destination address size
*
* @return 0 on success
* -ENOENT on expired lifetime of the source route
* -EFAULT on one of the parameter pointers is NULL
* -ENOBUFS if the size to store the destination is insufficient low
* -EHOSTUNREACH on the destination address is not set
*/
int fib_sr_read_destination(fib_table_t *table, fib_sr_t *fib_sr,
uint8_t *dst, size_t *dst_size);
/**
* @brief sets the provided parameters in the given sr header if a given parameter
* is NULL its considered not to be changed
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to write to
* @param[in] sr_iface_id pointer to the new iface_id
* @param[in] sr_flags pointer to the new flags
* @param[in] sr_lifetime pointer to store the new lifetime
*
* @return 0 on success
* -ENOENT on expired lifetime of the source route
* -EFAULT on passed fib_sr is NULL
*/
int fib_sr_set(fib_table_t *table, fib_sr_t *fib_sr, kernel_pid_t *sr_iface_id,
uint32_t *sr_flags, uint32_t *sr_lifetime);
/**
* @brief deletes the sr
*
* @param[in, out] fib_sr pointer to the source route to be deleted
*
* @return 0 on success
* -EFAULT on fib_sr pointer is NULL
*/
int fib_sr_delete(fib_table_t *table, fib_sr_t *fib_sr);
/**
* @brief iterates to the next entry in the sr_path
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to iterate
* @param[in, out] sr_path_entry pointer to the entry for iterating to the next entry
*
* @return 0 on success
* 1 on success, end reached
* -ENOENT on expired lifetime of the source route
* -EFAULT on fib_sr and/or sr_path_entry is NULL
*/
int fib_sr_next(fib_table_t *table, fib_sr_t *fib_sr, fib_sr_entry_t **sr_path_entry);
/**
* @brief searches the entry containing the given address
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to search for a hop address
* @param[in] addr pointer to the searched address bytes
* @param[in] addr_size the size in bytes of the searched address type
* @param[out] sr_path_entry pointer to the found address entry
*
* @return 0 on success
* -EHOSTUNREACH when no address matches on the path
* -ENOENT on expired lifetime of the source route
* -EFAULT on one of the given parameter pointer is NULL
*/
int fib_sr_search(fib_table_t *table, fib_sr_t *fib_sr, uint8_t *addr, size_t addr_size,
fib_sr_entry_t **sr_path_entry);
/**
* @brief append a new entry at the end of the source route, i.e. a new destination
*
* @param[in] table the table with the source route to append the new entry
* @param[in] fib_sr pointer to the sr to append a hop address
* @param[in] dst pointer to the new destination address bytes
* @param[in] dst_size the size in bytes of the destination address type
*
* @return 0 on success
* -EINVAL on the given destination is already on the path in the source route
* -ENOENT on expired lifetime of the source route
* -EFAULT on fib_sr and/or dst is NULL
*/
int fib_sr_entry_append(fib_table_t *table, fib_sr_t *fib_sr,
uint8_t *dst, size_t dst_size);
/**
* @brief adds a new entry behind a given sr entry
*
* @param[in] table the table with the source route to add the new entry
* @param[in] fib_sr pointer to the sr to add a hop address
* @param[in] sr_path_entry pointer to the entry after which we add the new one
* @param[in] addr pointer to the new address bytes
* @param[in] addr_size the size in bytes of the address type
* @param[in] keep_remaining_route indicate if the remaining route after sr_path_entry
* should be kept and appended after the new entry
*
* @return 0 on success
* -EFAULT on fib_sr and/or sr_path_entry and/or addr is NULL
* -ENOENT on expired lifetime of the source route
* -EINVAL on the given address is already present in the path
*/
int fib_sr_entry_add(fib_table_t *table, fib_sr_t *fib_sr,
fib_sr_entry_t *sr_path_entry, uint8_t *addr, size_t addr_size,
bool keep_remaining_route);
/**
* @brief removes an entry from a source route
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to delete a hop address
* @param[in] addr pointer to the address bytes to delete
* @param[in] addr_size the size in bytes of the address type
* @param[in] keep_remaining_route indicate if the remaining route
* should be kept and appended after the predecessor of the removed entry
*
* @return 0 on success
* -EFAULT on one of the passed pointers is NULL
* -ENOENT on expired lifetime of the source route
*/
int fib_sr_entry_delete(fib_table_t *table, fib_sr_t *fib_sr, uint8_t *addr, size_t addr_size,
bool keep_remaining_route);
/**
* @brief overwrites the address of an entry with a new address
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to overwrite a hop address
* @param[in] addr_old pointer to the address bytes to overwrite
* @param[in] addr_old_size the size in bytes of the address type
* @param[in] addr_new pointer to the new address bytes
* @param[in] addr_new_size the size in bytes of the address type
*
* @return 0 on success
* -EINVAL on the given address is already present in the path
* -ENOMEM on no memory left to create a new address entry to overwrite the old one
* -EFAULT on one of the passed pointers is NULL
* -ENOENT on expired lifetime of the source route
*/
int fib_sr_entry_overwrite(fib_table_t *table, fib_sr_t *fib_sr,
uint8_t *addr_old, size_t addr_old_size,
uint8_t *addr_new, size_t addr_new_size);
/**
* @brief writes the address of an entry to the given out pointers
*
* @param[in] table the fib instance to access
* @param[in] fib_sr pointer to the sr to get a hop address
* @param[in] sr_path_entry pointer to the entry with the address
* @param[out] addr pointer to store the address bytes
* @param[in, out] addr_size the size in bytes of the address type
*
* @return 0 on success
* -ENOMEM on insufficient memory provided to store the address
* -EFAULT on one of the passed pointers is NULL
* -ENOENT on expired lifetime of the source route
*/
int fib_sr_entry_get_address(fib_table_t *table, fib_sr_t *fib_sr, fib_sr_entry_t *sr_path_entry,
uint8_t *addr, size_t *addr_size);
/**
* @brief copies a source route to the given destination
*
* @param[in] table table to search for a source route
* @param[in] dst pointer to the destination address bytes
* @param[in] dst_size the size in bytes of the destination address type
* @param[out] sr_iface_id pointer to the store the iface_id for this route
* @param[in, out] sr_flags pointer to store the flags of this route
* @param[out] addr_list pointer to the location for storing the source route addresses
* @param[in, out] addr_list_elements the number of elements available in addr_list
* @param[in, out] element_size the provided size for one element in addr_list
* @param[in] reverse indicator if the hops should be stored in reverse order
* @param[in, out] fib_sr pointer for cosecutive receiving matching source routes.
* If NULL only the first matching source route is returned.
* If !NULL the pointer will be overwritten with the current returned fib_sr.
* The FIB skips all entries until the provided fib_sr+1.
* The fib_sr pointer is only overwritten when a further matching sr has been found.
*
* @note The actual needed size for an element and the number of elements
* is stored in addr_list_elements and element_size respectively
* when the return value is NOT -EFAULT or NOT -EHOSTUNREACH.
* However,the required size for may change in between calls.
*
* @return 0 on success, path to destination with equal flags
* 1 on success, path to destination with distinct flags
* -EFAULT on one of the provided parameter pointers is NULL
* -EHOSTUNREACH if no sr for the destination exists in the FIB
* -ENOBUFS if the size to store all hops is insufficient low
*/
int fib_sr_get_route(fib_table_t *table, uint8_t *dst, size_t dst_size, kernel_pid_t *sr_iface_id,
uint32_t *sr_flags,
uint8_t *addr_list, size_t *addr_list_size, size_t *element_size,
bool reverse, fib_sr_t **fib_sr);
/**
* @brief returns the actual number of used FIB entries
*
@ -222,6 +467,14 @@ void fib_print_fib_table(fib_table_t *table);
*/
void fib_print_routes(fib_table_t *table);
/**
* @brief Prints the given FIB sourceroute
*
* @param[in] table the fib instance to print
* @param [in] sr the source route to print
*/
void fib_print_sr(fib_table_t *table, fib_sr_t *sr);
#if FIB_DEVEL_HELPER
/**
* @brief get the point in time at which the entry for destination dst expires.

55
sys/include/net/fib/table.h
View File

@ -53,11 +53,64 @@ typedef struct fib_entry_t {
struct universal_address_container_t *next_hop;
} fib_entry_t;
/**
* @brief Container descriptor for a FIB source route entry
*/
typedef struct fib_sr_entry_t {
/** Pointer to the shared generic address */
struct universal_address_container_t *address;
/** Pointer to the next shared generic address on the source route */
struct fib_sr_entry_t *next;
} fib_sr_entry_t;
/**
* @brief Container descriptor for a FIB source route
*/
typedef struct fib_sr_t {
/** interface ID */
kernel_pid_t sr_iface_id;
/** Lifetime of this entry (an absolute time-point is stored by the FIB) */
uint64_t sr_lifetime;
/** Flags for this source route */
uint32_t sr_flags;
/** Pointer to the first hop on the source route */
struct fib_sr_entry_t *sr_path;
/** Pointer to the destination of the source route */
struct fib_sr_entry_t *sr_dest;
} fib_sr_t;
/**
* @brief Container for one FIB source route table,
* combining source routes and an entry pool
*/
typedef struct fib_sr_meta_t {
/** pointer to source route header array */
fib_sr_t *headers;
/** pointer to entry pool array holding all hop entries for this table */
fib_sr_entry_t *entry_pool;
/** the maximum number of elements in the entry pool */
size_t entry_pool_size;
} fib_sr_meta_t;
/**
* @breif FIB table type for single hop entries
*/
#define FIB_TABLE_TYPE_SH (1)
/**
* @breif FIB table type for source routes
*/
#define FIB_TABLE_TYPE_SR (FIB_TABLE_TYPE_SH + 1)
/**
* @brief Meta information about the FIB table
*/
typedef struct {
fib_entry_t *entries; /**< array holding the FIB entries */
union{
fib_entry_t *entries; /**< array holding the FIB entries */
fib_sr_meta_t *source_routes; /**< array holding the FIB source routes */
}data;
uint8_t table_type; /**< the table kind SR or single hop */
size_t size; /**< number of entries in this table */
mutex_t mtx_access; /** access mutex to control exclusive operations on calls */
size_t notify_rp_pos; /** registered RPs for notifications about unreachable destinations */

3
sys/net/gnrc/network_layer/ipv6/gnrc_ipv6.c
View File

@ -88,7 +88,8 @@ kernel_pid_t gnrc_ipv6_init(void)
}
#ifdef MODULE_FIB
gnrc_ipv6_fib_table.entries = _fib_entries;
gnrc_ipv6_fib_table.data.entries = _fib_entries;
gnrc_ipv6_fib_table.table_type = FIB_TABLE_TYPE_SH;
gnrc_ipv6_fib_table.size = GNRC_IPV6_FIB_TABLE_SIZE;
fib_init(&gnrc_ipv6_fib_table);
#endif

1107
sys/net/network_layer/fib/fib.c
View File

File diff suppressed because it is too large Load Diff

3
tests/unittests/tests-fib/tests-fib.c
View File

@ -21,7 +21,8 @@
#define TEST_FIB_TABLE_SIZE (20)
static fib_entry_t _entries[TEST_FIB_TABLE_SIZE];
static fib_table_t test_fib_table = { .entries = _entries,
static fib_table_t test_fib_table = { .data.entries = _entries,
.table_type = FIB_TABLE_TYPE_SH,
.size = TEST_FIB_TABLE_SIZE,
.mtx_access = MUTEX_INIT,
.notify_rp_pos = 0 };

3
tests/unittests/tests-fib_sr/Makefile Normal file
View File

@ -0,0 +1,3 @@
MODULE = tests-fib_sr
include $(RIOTBASE)/Makefile.base

3
tests/unittests/tests-fib_sr/Makefile.include Normal file
View File

@ -0,0 +1,3 @@
CFLAGS += -DFIB_DEVEL_HELPER -DUNIVERSAL_ADDRESS_SIZE=16 -DUNIVERSAL_ADDRESS_MAX_ENTRIES=40
USEMODULE += fib

730
tests/unittests/tests-fib_sr/tests-fib_sr.c Normal file
View File

@ -0,0 +1,730 @@
/*
* Copyright (C) 2015 Martin Landsmann
*
* 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.
*/
#include <stdio.h> /**< required for snprintf() */
#include <string.h>
#include <errno.h>
#include "embUnit.h"
#include "tests-fib_sr.h"
#include "thread.h"
#include "net/fib.h"
#include "universal_address.h"
/**
* @brief maximum number of source routes
*/
#define TEST_MAX_FIB_SR (20)
/**
* @brief maximum number of entries in all source routes
*/
#define TEST_MAX_FIB_SR_ENTRIES (TEST_MAX_FIB_SR * 20)
/**
* @brief the FIB source route headers
*/
static fib_sr_t _sr_headers[TEST_MAX_FIB_SR];
/**
* @brief the FIB source route table entries pool
*/
static fib_sr_entry_t _sr_datapool[TEST_MAX_FIB_SR_ENTRIES];
/**
* @brief the FIB source route table "glue container"
*/
static fib_sr_meta_t _entries_sr = { .headers = _sr_headers,
.entry_pool = _sr_datapool,
.entry_pool_size = TEST_MAX_FIB_SR_ENTRIES};
/**
* @brief the FIB source route table
* @note is initialized in the entry function of this unittest
*/
static fib_table_t test_fib_sr_table;
/*
* @brief create a new empty source route and check the parameters
* It is expected to have a new source route with the given parameters
*/
static void test_fib_sr_01_create_empty_sr(void)
{
fib_sr_t *local_sourceroutes[1];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
kernel_pid_t sr_iface_id;
uint32_t sr_flags;
uint32_t sr_lifetime;
TEST_ASSERT_EQUAL_INT(0, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
&sr_iface_id, &sr_flags,
&sr_lifetime)
);
TEST_ASSERT_EQUAL_INT(42, sr_iface_id);
TEST_ASSERT_EQUAL_INT(0x0, sr_flags);
/* the lifetime should decrease
* Since the FIB uses timex under the hood which has a finer grained resolution
* testing the lifetime requires to active wait a bit, say 5 ms.
* Uncomment the following two lines if you want to test the temporal behaviour
* @note this may fail since unittests are currently not thread-friendly
*/
//xtimer_usleep(5 * MS_IN_USEC);
//TEST_ASSERT(sr_lifetime<10000);
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new empty source route, change its parameters
* and check the change
* It is expected to have a new source route with the given adjusted parameters
*/
static void test_fib_sr_02_change_sr_parameters(void)
{
fib_sr_t *local_sourceroutes[1];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
/* Case 01 - re-set all parameters */
kernel_pid_t sr_iface_id = 43;
uint32_t sr_flags = 0x99;
uint32_t sr_lifetime = 20000;
TEST_ASSERT_EQUAL_INT(0, fib_sr_set(&test_fib_sr_table, local_sourceroutes[0],
&sr_iface_id, &sr_flags, &sr_lifetime));
TEST_ASSERT_EQUAL_INT(0, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
&sr_iface_id, &sr_flags,
&sr_lifetime)
);
TEST_ASSERT_EQUAL_INT(43, sr_iface_id);
TEST_ASSERT_EQUAL_INT(0x99, sr_flags);
/* the lifetime should be slightly below 20000
* Since the FIB uses timex under the hood which has a finer grained resolution
* testing the lifetime requires to active wait a bit, say 5 ms.
* Uncomment the following three lines if you want to test the temporal behaviour
* @note this may fail since unittests are currently not thread-friendly
*/
//xtimer_usleep(5 * MS_IN_USEC);
//TEST_ASSERT(sr_lifetime>10000);
//TEST_ASSERT(sr_lifetime<20000);
fib_deinit(&test_fib_sr_table);
}
/*
* @brief check errors on reading sr parameters and trying to access an expired sr
*/
static void test_fib_sr_03_read_sr_parameters(void)
{
fib_sr_t *local_sourceroutes[1];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
kernel_pid_t sr_iface_id;
uint32_t sr_flags;
uint32_t sr_lifetime;
TEST_ASSERT_EQUAL_INT(-EFAULT, fib_sr_read_head(&test_fib_sr_table, NULL,
&sr_iface_id, &sr_flags,
&sr_lifetime)
);
TEST_ASSERT_EQUAL_INT(-EFAULT, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
NULL, &sr_flags,
&sr_lifetime)
);
/* we set the lifetime to 1 ms and expect it to expire */
sr_lifetime = 1;
TEST_ASSERT_EQUAL_INT(0, fib_sr_set(&test_fib_sr_table, local_sourceroutes[0],
&sr_iface_id, &sr_flags, &sr_lifetime)
);
/*
* Since the FIB uses timex under the hood which has a finer grained resolution
* testing the lifetime requires to active wait a bit, say 1 ms.
* Uncomment the following lines if you want to test the temporal behaviour
* @note this may fail since unittests are currently not thread-friendly
*/
/*
xtimer_usleep(1 * MS_IN_USEC);
TEST_ASSERT_EQUAL_INT(-ENOENT, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
&sr_iface_id, &sr_flags,
&sr_lifetime)
);
*/
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new empty source route and delete it
* It is expected to have no source route
*/
static void test_fib_sr_04_create_and_delete_sr(void)
{
fib_sr_t *local_sourceroutes[1];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
/* test wrong parameter */
TEST_ASSERT_EQUAL_INT(-EFAULT, fib_sr_delete(&test_fib_sr_table, NULL));
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
kernel_pid_t sr_iface_id;
uint32_t sr_flags;
uint32_t sr_lifetime;
TEST_ASSERT_EQUAL_INT(-ENOENT, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
&sr_iface_id, &sr_flags,
&sr_lifetime)
);
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new empty source route and append two hops on its path
*/
static void test_fib_sr_05_create_sr_and_append_hop(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
snprintf(addr_nxt, add_buf_size, "Some address X1");
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
/* append a first hop */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt,
add_buf_size)
);
snprintf(addr_nxt, add_buf_size, "Some address X2");
/* append a hop behind the first hop */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt,
add_buf_size)
);
/* the destination should be now X2 */
char addr_out[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_read_destination(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_out,
&add_buf_size)
);
TEST_ASSERT_EQUAL_INT(0, memcmp(addr_nxt, addr_out, add_buf_size));
/* try to append the address twice */
TEST_ASSERT_EQUAL_INT(-EINVAL, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt,
add_buf_size)
);
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief helper function to create source routes.
* The enrties are constructed with the given prefix and numbers
* counted from the given count borders (from and to).
* @param[in] pre prefix string to use
* @param[in] from starting index to count from
* @param[in] to last index to count to
* @param[in] sr the source route to append the created entries
* @param[in] buf_size the size in bytes for each address to be created
*/
static void _create_sr(const char* pre, size_t from, size_t to, fib_sr_t* sr, size_t buf_size)
{
char addr_nxt[buf_size];
strncpy(addr_nxt, pre, strlen(pre));
for (size_t i = from; i < to; ++i) {
snprintf(&(addr_nxt[strlen(pre)]), buf_size, "%d", (int)i);
/* append a hop */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, sr,
(uint8_t *)&addr_nxt,
buf_size)
);
}
}
/*
* @brief create a new source route with a number of hops on its path
* Search entry and add a new entry after the found one
*/
static void test_fib_sr_06_create_sr_with_hops(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
/* now we search for a specific entry, e.g. X6 */
fib_sr_entry_t *sr_path_entry[1];
snprintf(addr_nxt, add_buf_size, "Some address X6");
TEST_ASSERT_EQUAL_INT(0, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
&sr_path_entry[0])
);
/* and move on to the next entry (just because we can) */
TEST_ASSERT_EQUAL_INT(0, fib_sr_next(&test_fib_sr_table, local_sourceroutes[0],
&sr_path_entry[0]));
/* now we add a new entry behind sr_path_entry[0] and drop the remaining route */
snprintf(addr_nxt, add_buf_size, "Some address XY");
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_add(&test_fib_sr_table, local_sourceroutes[0],
sr_path_entry[0],
(uint8_t *)&addr_nxt,
add_buf_size, false)
);
/* so entries X8 and X9 should be gone */
snprintf(addr_nxt, add_buf_size, "Some address X8");
TEST_ASSERT_EQUAL_INT(-EHOSTUNREACH, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
&sr_path_entry[0])
);
snprintf(addr_nxt, add_buf_size, "Some address X9");
TEST_ASSERT_EQUAL_INT(-EHOSTUNREACH, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
&sr_path_entry[0])
);
/* now we go to a earlier entry and add a new entry not dropping the remaining ones */
snprintf(addr_nxt, add_buf_size, "Some address X2");
TEST_ASSERT_EQUAL_INT(0, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
&sr_path_entry[0])
);
snprintf(addr_nxt, add_buf_size, "Some address XZ");
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_add(&test_fib_sr_table, local_sourceroutes[0],
sr_path_entry[0],
(uint8_t *)&addr_nxt,
add_buf_size, true)
);
/*
* @note uncomment the following line to print the source route.
* expected X0, .., X2, XZ, X3, .., X7, XY
*/
/* fib_print_sr( local_sourceroutes[0]); */
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new source route with a number of hops on its path,
* and delete several entries
*/
static void test_fib_sr_07_create_sr_with_hops_and_delete_one(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
snprintf(addr_nxt, add_buf_size, "Some address X6");
/* we delete X6 keeping the remaining entries */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_delete(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
true)
);
snprintf(addr_nxt, add_buf_size, "Some address X9");
/* now the destination */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_delete(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
true)
);
snprintf(addr_nxt, add_buf_size, "Some address X0");
/* and now the first hop on the path */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_delete(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
true)
);
/*
* @note uncomment the following line to print the source route.
* expected X1, .., X5, X7, .., X8
*/
/* fib_print_sr( local_sourceroutes[0]); */
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new source route with a number of hops on its path,
* and overwrite the address of one entry
*/
static void test_fib_sr_08_create_sr_with_hops_and_overwrite_one(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
char addr_exc[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
/* now we search for a specific entry, e.g. X6 */
snprintf(addr_nxt, add_buf_size, "Some address X6");
snprintf(addr_exc, add_buf_size, "Some address XY");
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_overwrite(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt, add_buf_size,
(uint8_t *)&addr_exc, add_buf_size)
);
/*
* @note uncomment the following line to print the source route.
* expected X0, .., X5, XY, X7, .., X9
*/
/* fib_print_sr( local_sourceroutes[0]); */
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new source route with a number of hops on its path,
* search an entry and copy the address to the caller
*/
static void test_fib_sr_09_create_sr_with_hops_and_get_one(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
char addr_out[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
/* first we have an empty iterator */
fib_sr_entry_t *sr_path_entry[1];
sr_path_entry[0] = NULL;
/* now we move on to a specific hop, i.e. the 6th one (X5) */
for (size_t i = 0; i < 6; ++i) {
TEST_ASSERT_EQUAL_INT(0, fib_sr_next(&test_fib_sr_table, local_sourceroutes[0],
&sr_path_entry[0]));
}
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_get_address(&test_fib_sr_table, local_sourceroutes[0],
sr_path_entry[0],
(uint8_t *)&addr_out, &add_buf_size)
);
/* we ecpect the X5 address */
snprintf(addr_nxt, add_buf_size, "Some address X5");
TEST_ASSERT_EQUAL_INT(0, memcmp(addr_nxt, addr_out, add_buf_size));
/*
* @note uncomment the following line to print the source route.
*/
/* fib_print_sr( local_sourceroutes[0]); */
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new source route with a number of hops on its path,
* and get it (also in reverse order)
*/
static void test_fib_sr_10_create_sr_with_hops_and_get_a_route(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
size_t addr_list_elements = 10;
size_t element_size = 16;
uint8_t addr_list[ addr_list_elements * element_size ];
kernel_pid_t sr_iface_id;
uint32_t sr_flags = 0x0;
snprintf(addr_nxt, add_buf_size, "Some address X9");
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
false, NULL)
);
/*
* @note uncomment the following lines to print the source route and the result.
* expected X0, .., X9
*/
/*
fib_print_sr( local_sourceroutes[0]);
for (size_t i = 0; i < addr_list_elements; ++i) {
printf("[");
for (size_t j = 0; j < element_size; j++) {
printf("%c", addr_list[(i*element_size)+j]);
}printf("] ");
}puts("");
*/
/* now we get the addresses in reverse order */
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
true, NULL)
);
/*
* @note uncomment the following lines to print the source route and the result.
* expected X0, .., X9
*/
/*
fib_print_sr( local_sourceroutes[0]);
for (size_t i = 0; i < addr_list_elements; ++i) {
printf("[");
for (size_t j = 0; j < element_size; j++) {
printf("%c", addr_list[(i*element_size)+j]);
}printf("] ");
}puts("");
*/
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create a new source route with a number of hops on its path,
* and get a partial route (also in reverse order)
*/
static void test_fib_sr_11_create_sr_with_hops_and_get_a_partial_route(void)
{
fib_sr_t *local_sourceroutes[1];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
size_t addr_list_elements = 10;
size_t element_size = 16;
uint8_t addr_list[ addr_list_elements * element_size ];
kernel_pid_t sr_iface_id;
uint32_t sr_flags = 0x0;
snprintf(addr_nxt, add_buf_size, "Some address X7");
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
false, NULL)
);
/*
* @note uncomment the following lines to print the resulting source route.
* expected X0..X9 where X0..X7 has usecount of 2
*/
/*
fib_print_sr( local_sourceroutes[0]);
for (size_t i = 0; i < addr_list_elements; ++i) {
printf("[");
for (size_t j = 0; j < element_size; j++) {
printf("%c", addr_list[(i*element_size)+j]);
}printf("] ");
}puts("");
*/
/* now we get the addresses in reverse order */
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
true, NULL)
);
/*
* @note uncomment the following lines to print the resulting source route.
*/
/*
for (size_t i = 0; i < addr_list_elements; ++i) {
printf("[");
for (size_t j = 0; j < element_size; j++) {
printf("%c", addr_list[(i*element_size)+j]);
}printf("] ");
}puts("");
*/
/* remove the source route */
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
fib_deinit(&test_fib_sr_table);
}
/*
* @brief create new source routes and get all routes succesively
*/
static void test_fib_sr_12_get_consecutive_sr(void)
{
fib_sr_t *local_sourceroutes[3];
size_t add_buf_size = 16;
char addr_nxt[add_buf_size];
/* Create SR1 X0,.., X9,XX */
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
42, 0x0, 10000));
_create_sr("Some address X", 0, 10, local_sourceroutes[0], 16);
snprintf(addr_nxt, add_buf_size, "Some address XX");
/* append a the last hop, i.e. the destination */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
(uint8_t *)&addr_nxt,
add_buf_size)
);
/* Create SR1 Y1,.., Y7,XX */
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[1],
42, 0x0, 10000));
_create_sr("Some address Y", 1, 8, local_sourceroutes[1], 16);
snprintf(addr_nxt, add_buf_size, "Some address XX");
/* append a the last hop, i.e. the destination */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[1],
(uint8_t *)&addr_nxt,
add_buf_size)
);
/* Create SR1 Z5,.., Z7,XX */
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[2],
42, 0x0, 10000));
_create_sr("Some address Z", 5, 8, local_sourceroutes[2], 16);
snprintf(addr_nxt, add_buf_size, "Some address XX");
/* append a the last hop, i.e. the destination */
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[2],
(uint8_t *)&addr_nxt,
add_buf_size)
);
fib_sr_t *iter[1];
iter[0] = NULL;
size_t addr_list_elements = 11;
size_t element_size = 16;
uint8_t addr_list[ addr_list_elements * element_size ];
kernel_pid_t sr_iface_id;
uint32_t sr_flags = 0x0;
snprintf(addr_nxt, add_buf_size, "Some address XX");
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
false, iter)
);
TEST_ASSERT_EQUAL_INT(11, addr_list_elements);
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
false, iter)
);
TEST_ASSERT_EQUAL_INT(8, addr_list_elements);
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
add_buf_size, &sr_iface_id, &sr_flags,
addr_list, &addr_list_elements, &element_size,
false, iter)
);
TEST_ASSERT_EQUAL_INT(4, addr_list_elements);
fib_deinit(&test_fib_sr_table);
}
Test *tests_fib_sr_tests(void)
{
test_fib_sr_table.data.source_routes = &_entries_sr;
test_fib_sr_table.table_type = FIB_TABLE_TYPE_SR;
test_fib_sr_table.size = TEST_MAX_FIB_SR;
mutex_init(&(test_fib_sr_table.mtx_access));
test_fib_sr_table.notify_rp_pos = 0;
fib_init(&test_fib_sr_table);
EMB_UNIT_TESTFIXTURES(fixtures) {
new_TestFixture(test_fib_sr_01_create_empty_sr),
new_TestFixture(test_fib_sr_02_change_sr_parameters),
new_TestFixture(test_fib_sr_03_read_sr_parameters),
new_TestFixture(test_fib_sr_04_create_and_delete_sr),
new_TestFixture(test_fib_sr_05_create_sr_and_append_hop),
new_TestFixture(test_fib_sr_06_create_sr_with_hops),
new_TestFixture(test_fib_sr_07_create_sr_with_hops_and_delete_one),
new_TestFixture(test_fib_sr_08_create_sr_with_hops_and_overwrite_one),
new_TestFixture(test_fib_sr_09_create_sr_with_hops_and_get_one),
new_TestFixture(test_fib_sr_10_create_sr_with_hops_and_get_a_route),
new_TestFixture(test_fib_sr_11_create_sr_with_hops_and_get_a_partial_route),
new_TestFixture(test_fib_sr_12_get_consecutive_sr),
};
EMB_UNIT_TESTCALLER(fib_sr_tests, NULL, NULL, fixtures);
return (Test *)&fib_sr_tests;
}
void tests_fib_sr(void)
{
TESTS_RUN(tests_fib_sr_tests());
}

43
tests/unittests/tests-fib_sr/tests-fib_sr.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (C) 2015 Martin Landsmann
*
* 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.
*/
/**
* @addtogroup unittests
* @{
*
* @file
* @brief Unittests for the ``fib`` module (source routes)
*
* @author Martin Landsmann <Martin.Landsmann@HAW-Hamburg.de>
*/
#ifndef TESTS_FIB_H_
#define TESTS_FIB_H_
#include "embUnit/embUnit.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief The entry point of this test suite.
*/
void tests_fib_sr(void);
/**
* @brief Generates tests for FIB source routing
*
* @return embUnit tests if successful, NULL if not.
*/
Test *tests_fib_sr_tests(void);
#ifdef __cplusplus
}
#endif
#endif /* TESTS_FIB_H_ */
/** @} */