fib: initial source route support

sys/include/net/fib.h

@@ -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.

sys/include/net/fib/table.h

@@ -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 */

sys/net/gnrc/network_layer/ipv6/gnrc_ipv6.c

@@ -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