DHCP server and Agent relay update

Added support for response back Relay agent given interface id option.
Relay agent support to add interface id option to Relay message.

Author: Juha Heiskanen

nanostack/dhcp_service_api.h

@@ -142,6 +142,15 @@ uint16_t dhcp_service_init(int8_t interface_id, dhcp_instance_type_e instance_ty
 */
 void dhcp_service_relay_instance_enable(uint16_t instance, uint8_t *server_address);
 
+/**
+* \brief Enable DHCPv6 Relay Agent to add interface ID option to relay frame. Default is disabled.
+*
+*
+* \param instance The instance ID of the registered server.
+* \param enable true add interface option
+*/
+void dhcp_service_relay_interface_id_option_enable(uint16_t instance, bool enable);
+
 /**
 * \brief Get DHCPv6 Relay Agent address pointer.
 *

source/DHCPv6_client/dhcpv6_client_api.h

@@ -139,6 +139,8 @@ void dhcp_client_global_address_delete(int8_t interface, uint8_t *dhcp_addr, uin
 
 void dhcp_relay_agent_enable(int8_t interface, uint8_t border_router_address[static 16]);
 
+void dhcp_relay_agent_interface_id_option_enable(int8_t interface, bool enable);
+
 int dhcp_client_server_address_update(int8_t interface, uint8_t *prefix, uint8_t server_address[static 16]);
 
 

source/DHCPv6_client/dhcpv6_client_service.c

@@ -175,6 +175,16 @@ void dhcp_relay_agent_enable(int8_t interface, uint8_t border_router_address[sta
     dhcp_service_relay_instance_enable(dhcp_client->relay_instance, border_router_address);
 }
 
+void dhcp_relay_agent_interface_id_option_enable(int8_t interface, bool enable)
+{
+    dhcp_client_class_t *dhcp_client = dhcpv6_client_entry_discover(interface);
+    if (!dhcp_client) {
+        return;
+    }
+
+    dhcp_service_relay_interface_id_option_enable(dhcp_client->relay_instance, enable);
+}
+
 void dhcp_client_delete(int8_t interface)
 {
     protocol_interface_info_entry_t *cur = NULL;

source/libDHCPv6/dhcp_service_api.c

@@ -60,6 +60,7 @@ typedef struct {
     int8_t interface_id;
     uint8_t server_address[16];
     bool    relay_activated;
+    bool    add_interface_id_option;
     ns_list_link_t link;
 } relay_instance_t;
 typedef NS_LIST_HEAD(relay_instance_t, link) relay_instance_list_t;
@@ -83,6 +84,8 @@ typedef struct {
     uint8_t *msg_ptr;
     uint16_t msg_len;
     uint8_t *relay_start;
+    uint8_t *opt_interface_id;
+    uint16_t opt_interface_id_length;
     ns_list_link_t link;
 } msg_tr_t;
 typedef NS_LIST_HEAD(msg_tr_t, link) tr_list_t;
@@ -335,6 +338,8 @@ void recv_dhcp_server_msg(void *cb_res)
         }
         //Update Source and data
         msg_tr_ptr->relay_start = msg_ptr;
+        msg_tr_ptr->opt_interface_id = relay_msg.relay_interface_id.msg_ptr;
+        msg_tr_ptr->opt_interface_id_length = relay_msg.relay_interface_id.len;
         memcpy(msg_tr_ptr->addr.address, relay_msg.peer_address, 16);
         msg_ptr = relay_msg.relay_options.msg_ptr;
         msg_len = relay_msg.relay_options.len;
@@ -408,35 +413,37 @@ void recv_dhcp_relay_msg(void *cb_res)
     }
     ns_address_t src_address;
 
-    uint8_t relay_frame[DHCPV6_RELAY_LENGTH + 4];
-    ns_iovec_t msg_iov[2];
-    msg_iov[0].iov_base = relay_frame;
-    msg_iov[0].iov_len = 34;
-    msg_iov[1].iov_base = ns_dyn_mem_temporary_alloc(sckt_data->d_len);
-    msg_iov[1].iov_len = sckt_data->d_len;
-    if (msg_iov[1].iov_base == NULL) {
+    //Relay vector added space for relay frame + Interface ID
+    uint8_t relay_frame[DHCPV6_RELAY_LENGTH + 4 + 5];
+
+
+    uint8_t *socket_data = ns_dyn_mem_temporary_alloc(sckt_data->d_len);
+
+    if (socket_data == NULL) {
         // read actual message
         tr_error("Out of resources");
         goto cleanup;
     }
 
+
     ns_msghdr_t msghdr;
+    ns_iovec_t msg_data;
+    msg_data.iov_base = socket_data;
+    msg_data.iov_len = sckt_data->d_len;
     //Set messages name buffer
     msghdr.msg_name = &src_address;
     msghdr.msg_namelen = sizeof(src_address);
-    msghdr.msg_iov = &msg_iov[1];
+    msghdr.msg_iov = &msg_data;
     msghdr.msg_iovlen = 1;
     msghdr.msg_control = NULL;
     msghdr.msg_controllen = 0;
 
     msg_len = socket_recvmsg(sckt_data->socket_id, &msghdr, NS_MSG_LEGACY0);
 
-
     tr_debug("dhcp Relay recv msg");
 
     //Parse type
-    uint8_t *ptr = msg_iov[1].iov_base;
-    uint8_t msg_type = *ptr;
+    uint8_t msg_type = *socket_data;
 
     int16_t tc = 0;
     if (msg_type == DHCPV6_RELAY_FORWARD) {
@@ -446,7 +453,7 @@ void recv_dhcp_relay_msg(void *cb_res)
     } else if (msg_type == DHCPV6_RELAY_REPLY) {
         //Parse and validate Relay
         dhcpv6_relay_msg_t relay_msg;
-        if (!libdhcpv6_relay_msg_read(ptr, msg_len, &relay_msg)) {
+        if (!libdhcpv6_relay_msg_read(socket_data, msg_len, &relay_msg)) {
             tr_error("Not valid relay");
             goto cleanup;
         }
@@ -458,14 +465,14 @@ void recv_dhcp_relay_msg(void *cb_res)
         memcpy(src_address.address, relay_msg.peer_address, 16);
         src_address.type = ADDRESS_IPV6;
         src_address.identifier = DHCPV6_CLIENT_PORT;
-        msghdr.msg_iov = &msg_iov[0];
+        msghdr.msg_iov = &msg_data;
         msghdr.msg_iovlen = 1;
-        msg_iov[0].iov_base = relay_msg.relay_options.msg_ptr;
-        msg_iov[0].iov_len = relay_msg.relay_options.len;
+        msg_data.iov_base = relay_msg.relay_options.msg_ptr;
+        msg_data.iov_len = relay_msg.relay_options.len;
         tr_debug("Forward Original relay msg to client");
 
     } else {
-        if (0 != libdhcpv6_message_malformed_check(ptr, msg_len)) {
+        if (0 != libdhcpv6_message_malformed_check(socket_data, msg_len)) {
             tr_error("Malformed packet");
             goto cleanup;
         }
@@ -476,10 +483,24 @@ void recv_dhcp_relay_msg(void *cb_res)
             tr_error("No GP address");
             goto cleanup;
         }
-
+        ns_iovec_t msg_iov[2];
+        uint8_t *ptr = relay_frame;
         //Build
-        libdhcpv6_dhcp_relay_msg_write(relay_frame, DHCPV6_RELAY_FORWARD, 0, src_address.address, gp_address);
-        libdhcpv6_dhcp_option_header_write(relay_frame + 34, msg_len);
+        //ADD relay frame vector front of original data
+        msghdr.msg_iov = &msg_iov[0];
+        msg_iov[0].iov_base = relay_frame;
+        msghdr.msg_iovlen = 2;
+        //SET Original Data
+        msg_iov[1].iov_base = socket_data;
+        msg_iov[1].iov_len = msg_len;
+
+        ptr = libdhcpv6_dhcp_relay_msg_write(ptr, DHCPV6_RELAY_FORWARD, 0, src_address.address, gp_address);
+        if (relay_srv->add_interface_id_option) {
+            ptr = libdhcpv6_option_interface_id_write(ptr, sckt_data->interface_id);
+        }
+        ptr = libdhcpv6_dhcp_option_header_write(ptr, DHCPV6_OPTION_RELAY, msg_len);
+        //Update length of relay vector
+        msg_iov[0].iov_len = ptr - relay_frame;
 
         //Update Neighbour table if necessary
         relay_notify_t *neigh_notify = dhcp_service_notify_find(sckt_data->interface_id);
@@ -491,20 +512,14 @@ void recv_dhcp_relay_msg(void *cb_res)
         memcpy(src_address.address, relay_srv->server_address, 16);
         src_address.type = ADDRESS_IPV6;
         src_address.identifier = DHCPV6_SERVER_PORT;
-        //ADD relay frame vector front of original data
-        msghdr.msg_iov = &msg_iov[0];
-        msghdr.msg_iovlen = 2;
-        msg_iov[0].iov_base = relay_frame;
-        msg_iov[0].iov_len = 38;
-        msg_iov[1].iov_len = msg_len;
         tr_debug("Forward Client msg to server");
         tc = IP_DSCP_CS6 << IP_TCLASS_DSCP_SHIFT;
 
     }
     socket_setsockopt(sckt_data->socket_id, SOCKET_IPPROTO_IPV6, SOCKET_IPV6_TCLASS, &tc, sizeof(tc));
     socket_sendmsg(sckt_data->socket_id, &msghdr, NS_MSG_LEGACY0);
 cleanup:
-    ns_dyn_mem_free(msg_iov[1].iov_base);
+    ns_dyn_mem_free(socket_data);
 
     return;
 }
@@ -635,6 +650,7 @@ uint16_t dhcp_service_init(int8_t interface_id, dhcp_instance_type_e instance_ty
         relay_srv->instance_id = id;
         relay_srv->interface_id = interface_id;
         relay_srv->relay_activated = false;
+        relay_srv->add_interface_id_option = false;
 
     }
 
@@ -655,6 +671,14 @@ void dhcp_service_relay_instance_enable(uint16_t instance, uint8_t *server_addre
     }
 }
 
+void dhcp_service_relay_interface_id_option_enable(uint16_t instance, bool enable)
+{
+    relay_instance_t *relay_srv = dhcp_service_relay_find(instance);
+    if (relay_srv) {
+        relay_srv->add_interface_id_option = enable;
+    }
+}
+
 uint8_t *dhcp_service_relay_global_addres_get(uint16_t instance)
 {
     relay_instance_t *relay_srv = dhcp_service_relay_find(instance);
@@ -851,30 +875,42 @@ void dhcp_service_send_message(msg_tr_t *msg_tr_ptr)
         //Build Relay Reply only server do this
         int16_t tc = IP_DSCP_CS6 << IP_TCLASS_DSCP_SHIFT;
         socket_setsockopt(msg_tr_ptr->socket, SOCKET_IPPROTO_IPV6, SOCKET_IPV6_TCLASS, &tc, sizeof(tc));
-        ns_iovec_t data_vector[2];
+        ns_iovec_t data_vector[4];
+        uint8_t relay_header[4];
+        libdhcpv6_dhcp_option_header_write(relay_header, DHCPV6_OPTION_RELAY, msg_tr_ptr->msg_len);
         ns_msghdr_t msghdr;
+        msghdr.msg_iovlen = 0;
         memcpy(msg_tr_ptr->addr.address, msg_tr_ptr->relay_start + 2, 16);
         msg_tr_ptr->addr.identifier = DHCPV6_SERVER_PORT;
         //SET IOV vectors
         //Relay Reply
-        data_vector[0].iov_base = (void *) msg_tr_ptr->relay_start;
-        data_vector[0].iov_len = DHCPV6_RELAY_LENGTH + 4;
+        data_vector[msghdr.msg_iovlen].iov_base = (void *) msg_tr_ptr->relay_start;
+        data_vector[msghdr.msg_iovlen].iov_len = DHCPV6_RELAY_LENGTH;
+        msghdr.msg_iovlen++;
+        if (msg_tr_ptr->opt_interface_id) {
+            data_vector[msghdr.msg_iovlen].iov_base = (void *)(msg_tr_ptr->opt_interface_id - 4);
+            data_vector[msghdr.msg_iovlen].iov_len = msg_tr_ptr->opt_interface_id_length + 4;
+            msghdr.msg_iovlen++;
+        }
+        //Relay reply header
+        data_vector[msghdr.msg_iovlen].iov_base = (void *) relay_header;
+        data_vector[msghdr.msg_iovlen].iov_len = 4;
+        msghdr.msg_iovlen++;
         //DHCPV normal message vector
-        data_vector[1].iov_base = (void *) msg_tr_ptr->msg_ptr;
-        data_vector[1].iov_len = msg_tr_ptr->msg_len;
+        data_vector[msghdr.msg_iovlen].iov_base = (void *) msg_tr_ptr->msg_ptr;
+        data_vector[msghdr.msg_iovlen].iov_len = msg_tr_ptr->msg_len;
+        msghdr.msg_iovlen++;
 
         //Set message name
         msghdr.msg_name = (void *) &msg_tr_ptr->addr;
         msghdr.msg_namelen = sizeof(ns_address_t);
         msghdr.msg_iov = &data_vector[0];
-        msghdr.msg_iovlen = 2;
         //No ancillary data
         msghdr.msg_control = NULL;
         msghdr.msg_controllen = 0;
 
         uint8_t *ptr = msg_tr_ptr->relay_start;
         *ptr = DHCPV6_RELAY_REPLY;
-        libdhcpv6_dhcp_option_header_write(ptr + 34, msg_tr_ptr->msg_len);
         retval = socket_sendmsg(msg_tr_ptr->socket, &msghdr, NS_MSG_LEGACY0);
 
     } else {
@@ -972,6 +1008,12 @@ void dhcp_service_relay_instance_enable(uint16_t instance, uint8_t *server_addre
     (void)server_address;
 }
 
+void dhcp_service_relay_interface_id_option_enable(uint16_t instance, bool enable)
+{
+    (void)instance;
+    (void)enable;
+}
+
 int dhcp_service_send_resp(uint32_t msg_tr_id, uint8_t options, uint8_t *msg_ptr, uint16_t msg_len)
 {
     (void)msg_tr_id;

source/libDHCPv6/libDHCPv6.c

@@ -859,9 +859,16 @@ uint8_t *libdhcpv6_dhcp_relay_msg_write(uint8_t *ptr, uint8_t type, uint8_t hop_
     return ptr;
 }
 
-uint8_t *libdhcpv6_dhcp_option_header_write(uint8_t *ptr, uint16_t length)
+uint8_t *libdhcpv6_option_interface_id_write(uint8_t *ptr, int8_t interface_id)
 {
-    ptr = common_write_16_bit(DHCPV6_OPTION_RELAY, ptr);
+    ptr = libdhcpv6_dhcp_option_header_write(ptr, DHCPV6_OPTION_INTERFACE_ID, 1);
+    *ptr++ = interface_id;
+    return ptr;
+}
+
+uint8_t *libdhcpv6_dhcp_option_header_write(uint8_t *ptr, uint16_t option_type, uint16_t length)
+{
+    ptr = common_write_16_bit(option_type, ptr);
     ptr = common_write_16_bit(length, ptr);
     return ptr;
 }
@@ -878,6 +885,11 @@ bool libdhcpv6_relay_msg_read(uint8_t *ptr, uint16_t length, dhcpv6_relay_msg_t
     relay_msg->peer_address = ptr + 16;
     ptr += 32;
     //Discover
+    if (libdhcpv6_message_option_discover(ptr, length - 34, DHCPV6_OPTION_INTERFACE_ID, &relay_msg->relay_interface_id) != 0) {
+        relay_msg->relay_interface_id.len = 0;
+        relay_msg->relay_interface_id.msg_ptr = NULL;
+    }
+
     if (libdhcpv6_message_option_discover(ptr, length - 34, DHCPV6_OPTION_RELAY, &relay_msg->relay_options) != 0) {
         return false;
     }

source/libDHCPv6/libDHCPv6.h

@@ -125,6 +125,7 @@ typedef struct dhcpv6_relay_msg {
     uint8_t    hop_limit;
     uint8_t    *link_address;
     uint8_t    *peer_address;
+    dhcp_options_msg_t relay_interface_id;
     dhcp_options_msg_t relay_options;
 } dhcpv6_relay_msg_t;
 
@@ -237,6 +238,7 @@ typedef struct dhcpv6_relay_msg {
 
 #define DHCPV6_RELAY_LENGTH 34
 #define DHCPV6_OPTION_RELAY 0x0009
+#define DHCPV6_OPTION_INTERFACE_ID 0x0012
 
 
 
@@ -293,7 +295,7 @@ uint16_t libdhcpv6_address_reply_message_len(uint16_t clientDUIDLength, uint16_t
 
 uint8_t *libdhcpv6_generic_nontemporal_address_message_write(uint8_t *ptr, dhcpv6_solication_base_packet_s *packet, dhcpv6_ia_non_temporal_address_s *nonTemporalAddress, dhcp_duid_options_params_t *serverLink);
 uint8_t *libdhcpv6_dhcp_relay_msg_write(uint8_t *ptr, uint8_t type, uint8_t hop_limit,  uint8_t *peer_addres, uint8_t *link_address);
-uint8_t *libdhcpv6_dhcp_option_header_write(uint8_t *ptr, uint16_t length);
+uint8_t *libdhcpv6_dhcp_option_header_write(uint8_t *ptr, uint16_t option_type, uint16_t length);
 
 int libdhcpv6_get_IA_address(uint8_t *ptr, uint16_t data_length, dhcp_ia_non_temporal_params_t *params);
 int libdhcpv6_get_duid_by_selected_type_id_opt(uint8_t *ptr, uint16_t data_length, uint16_t type, dhcp_duid_options_params_t *params);
@@ -341,6 +343,8 @@ uint8_t *libdhcpv6_rapid_commit_option_write(uint8_t *ptr);
  */
 uint8_t *libdhcvp6_request_option_write(uint8_t *ptr, uint8_t optionCnt, uint16_t *optionPtr);
 
+uint8_t *libdhcpv6_option_interface_id_write(uint8_t *ptr, int8_t interface_id);
+
 
 
 /**

test/nanostack/unittest/stub/dhcp_service_api_stub.c

@@ -179,6 +179,11 @@ void dhcp_service_relay_instance_enable(uint16_t instance, uint8_t *server_addre
 
 }
 
+void dhcp_service_relay_interface_id_option_enable(uint16_t instance, bool enable)
+{
+
+}
+
 uint8_t  *dhcp_service_relay_global_addres_get(uint16_t instance)
 {
     return NULL;

test/nanostack/unittest/stub/libDHCPv6_stub.c

@@ -228,7 +228,12 @@ uint8_t *libdhcpv6_dhcp_relay_msg_write(uint8_t *ptr, uint8_t type, uint8_t hop_
     return ptr + 34;
 }
 
-uint8_t *libdhcpv6_dhcp_option_header_write(uint8_t *ptr, uint16_t length)
+uint8_t *libdhcpv6_option_interface_id_write(uint8_t *ptr, int8_t interface_id)
+{
+    return ptr + 5;
+}
+
+uint8_t *libdhcpv6_dhcp_option_header_write(uint8_t *ptr, uint16_t option_type, uint16_t length)
 {
     return ptr + 4;
 }