DHCPv6 functionality update

Wi-sun DHCP client enable dhcp option notify and support DNS Server and domain list already.

DHCP client library support extra option notification callback's
for selected option types.

DHCPv6 library support new length field calculation and vendor option write

DHCPv6 server reply message is builded now at Server API code which enable options write's to message.

DHPCP server support Vendor data and DNS server data set.

ICMP RA handler cut padding away now for dns searc list options.

Author: Juha Heiskanen

source/6LoWPAN/ws/ws_bbr_api.c

@@ -391,7 +391,7 @@ static void ws_bbr_dhcp_server_dns_info_update(protocol_interface_info_entry_t *
     (void)cur;
     if (net_dns_server_get(backbone_interface_id, dns_server_address, &dns_search_list_ptr, &dns_search_list_len, 0) == 0) {
         /*Only supporting one DNS server address*/
-        //DHCPv6_server_service_set_dns_server(cur->id, dns_server_address, dns_search_list_ptr, dns_search_list_len);
+        DHCPv6_server_service_set_dns_server(cur->id, global_id, dns_server_address, dns_search_list_ptr, dns_search_list_len);
     }
 
     //TODO Generate vendor data in Wi-SUN network include the cached DNS query results in some sort of TLV format
@@ -421,8 +421,7 @@ static void ws_bbr_dhcp_server_dns_info_update(protocol_interface_info_entry_t *
         }
     }
 
-    (void)global_id;
-    //DHCPv6_server_service_set_vendor_data(cur->id, global_id, ARM_ENTERPRISE_NUMBER, dhcp_vendor_data_ptr, dhcp_vendor_data_len);
+    DHCPv6_server_service_set_vendor_data(cur->id, global_id, ARM_ENTERPRISE_NUMBER, dhcp_vendor_data_ptr, dhcp_vendor_data_len);
 }
 
 static void ws_bbr_dhcp_server_start(protocol_interface_info_entry_t *cur, uint8_t *global_id, uint32_t dhcp_address_lifetime)

source/6LoWPAN/ws/ws_bootstrap.c

@@ -73,6 +73,7 @@
 #include "6LoWPAN/ws/ws_eapol_pdu.h"
 #include "6LoWPAN/ws/ws_eapol_auth_relay.h"
 #include "6LoWPAN/ws/ws_eapol_relay.h"
+#include "libNET/src/net_dns_internal.h"
 
 #define TRACE_GROUP "wsbs"
 
@@ -872,6 +873,51 @@ static void ws_bootstrap_dhcp_neighbour_update_cb(int8_t interface_id, uint8_t l
     ws_bootstrap_mac_neighbor_short_time_set(cur, mac64, WS_NEIGHBOUR_DHCP_ENTRY_LIFETIME);
 }
 
+static void ws_bootstrap_dhcp_info_notify_cb(int8_t interface, dhcp_option_notify_t *options, dhcp_server_notify_info_t *server_info)
+{
+    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface);
+    if (!cur) {
+        return;
+    }
+    uint8_t server_ll64[16];
+    memcpy(server_ll64, ADDR_LINK_LOCAL_PREFIX, 8);
+
+    if (server_info->duid_length == 8) {
+        memcpy(server_ll64 + 8, server_info->duid, 8);
+    } else {
+        server_ll64[8] = server_info->duid[0];
+        server_ll64[9] = server_info->duid[1];
+        server_ll64[10] = server_info->duid[2];
+        server_ll64[11] = 0xff;
+        server_ll64[12] = 0xfe;
+        server_ll64[13] = server_info->duid[3];
+        server_ll64[14] = server_info->duid[4];
+        server_ll64[15] = server_info->duid[5];
+    }
+    server_ll64[8] ^= 2;
+
+    switch (options->option_type) {
+        case DHCPV6_OPTION_VENDOR_SPECIFIC_INFO:
+
+            break;
+
+        case DHCPV6_OPTION_DNS_SERVERS:
+            while (options->option.generic.data_length) {
+                net_dns_server_address_set(interface, server_ll64, options->option.generic.data, server_info->life_time);
+                options->option.generic.data_length -= 16;
+                options->option.generic.data += 16;
+            }
+            break;
+        case DHCPV6_OPTION_DOMAIN_LIST:
+            net_dns_server_search_list_set(interface, server_ll64, options->option.generic.data, options->option.generic.data_length, server_info->life_time);
+            break;
+        default:
+            break;
+    }
+
+}
+
+
 static int8_t ws_bootstrap_up(protocol_interface_info_entry_t *cur)
 {
     int8_t ret_val = -1;
@@ -923,6 +969,7 @@ static int8_t ws_bootstrap_up(protocol_interface_info_entry_t *cur)
     dhcp_service_link_local_rx_cb_set(cur->id, ws_bootstrap_dhcp_neighbour_update_cb);
     dhcp_client_configure(cur->id, true, true, true); //RENEW uses SOLICIT, Interface will use 1 instance for address get, IAID address hint is not used.
     dhcp_client_solicit_timeout_set(cur->id, WS_DHCP_SOLICIT_TIMEOUT, WS_DHCP_SOLICIT_MAX_RT, WS_DHCP_SOLICIT_MAX_RC);
+    dhcp_client_option_notification_cb_set(cur->id, ws_bootstrap_dhcp_info_notify_cb);
 
 
     ws_nud_table_reset(cur);

source/Common_Protocols/icmpv6.c

@@ -639,6 +639,21 @@ if_address_entry_t *icmpv6_slaac_address_add(protocol_interface_info_entry_t *cu
 }
 
 #ifdef HAVE_IPV6_ND
+
+static uint8_t icmpv6_dns_search_list_remove_pad(uint8_t *data_ptr, uint8_t length)
+{
+    while (length) {
+
+        if (data_ptr[length - 2] && data_ptr[length - 1] == 0) {
+            break;
+        } else if (data_ptr[length - 2] == 0 && data_ptr[length - 1] == 0) {
+            length--;
+        }
+    }
+
+    return length;
+}
+
 static buffer_t *icmpv6_ra_handler(buffer_t *buf)
 {
     protocol_interface_info_entry_t *cur;
@@ -869,7 +884,8 @@ static buffer_t *icmpv6_ra_handler(buffer_t *buf)
             uint32_t dns_lifetime = common_read_32_bit(dptr + 2); // 2 x reserved
             uint8_t *dns_search_list = dptr + 6;
             uint8_t dns_search_list_len = length - 8; // Length includes type and length
-
+            //Cut Padding
+            dns_search_list_len = icmpv6_dns_search_list_remove_pad(dns_search_list, dns_search_list_len);
             //tr_info("DNS Search List: %s Lifetime: %lu", trace_array(dns_search_list, dns_search_list_len), (unsigned long) dns_lifetime);
             // Add DNS server to DNS information storage.
             net_dns_server_search_list_set(cur->id, buf->src_sa.address, dns_search_list, dns_search_list_len, dns_lifetime);

source/DHCPv6_Server/DHCPv6_Server_service.c

@@ -115,12 +115,29 @@ int DHCPv6_server_respond_client(dhcpv6_gua_server_entry_s *serverBase, dhcpv6_r
     }
 
     response->responseLength = libdhcpv6_address_reply_message_len(replyPacket->clientDUID.duid_length, replyPacket->serverDUID.duid_length, 0, replyPacket->rapidCommit, address_allocated);
+    //Calculate DNS LIST and Vendor data lengths here
+    response->responseLength += libdhcpv6_dns_server_message_sizes(serverBase);
+    response->responseLength += libdhcpv6_vendor_data_message_sizes(serverBase);
+
     response->responsePtr = ns_dyn_mem_temporary_alloc(response->responseLength);
     if (response->responsePtr) {
+        uint8_t *ptr = response->responsePtr;
+        //Write Generic data at beginning
+        ptr = libdhcpv6_header_write(ptr, DHCPV6_REPLY_TYPE, replyPacket->transaction_ID);
+        ptr = libdhcpv6_duid_option_write(ptr, DHCPV6_SERVER_ID_OPTION, &replyPacket->serverDUID); //16
+        ptr = libdhcpv6_duid_option_write(ptr, DHCPV6_CLIENT_ID_OPTION, &replyPacket->clientDUID); //16
         if (address_allocated) {
-            libdhcpv6_reply_message_write(response->responsePtr, replyPacket, &nonTemporalAddress, NULL);
+            ptr = libdhcpv6_identity_association_option_write(ptr, replyPacket->iaId, replyPacket->T0, replyPacket->T1, true);
+            ptr = libdhcpv6_ia_address_option_write(ptr, nonTemporalAddress.requestedAddress, nonTemporalAddress.preferredLifeTime, nonTemporalAddress.validLifeTime);
+            //Write DNS LIST and Vendor data here
+            ptr = libdhcpv6_dns_server_message_writes(serverBase, ptr);
+            ptr = libdhcpv6_vendor_data_message_writes(serverBase, ptr);
         } else {
-            libdhcpv6_reply_message_write(response->responsePtr, replyPacket, NULL, NULL);
+            ptr = libdhcpv6_identity_association_option_write_with_status(ptr, replyPacket->iaId, replyPacket->T0, replyPacket->T1, DHCPV6_STATUS_NO_ADDR_AVAILABLE_CODE);
+        }
+
+        if (replyPacket->rapidCommit) {
+            ptr = libdhcpv6_rapid_commit_option_write(ptr);
         }
         return 0;
     }
@@ -407,6 +424,71 @@ int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t gu
 
     return 0;
 }
+
+int DHCPv6_server_service_set_dns_server(int8_t interface, uint8_t guaPrefix[static 16], uint8_t dns_server_address[static 16], uint8_t *dns_search_list_ptr, uint8_t dns_search_list_len)
+{
+    dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
+    if (!serverInfo) {
+        return -1;
+    }
+
+    dhcpv6_dns_server_data_t *dns_entry = libdhcpv6_dns_server_allocate(serverInfo, dns_server_address);
+    if (!dns_entry) {
+        return -1;
+    }
+
+    if (dns_entry->search_list_length != dns_search_list_len) {
+        ns_dyn_mem_free(dns_entry->search_list);
+        dns_entry->search_list = NULL;
+        dns_entry->search_list_length = 0;
+        if (dns_search_list_len) {
+            dns_entry->search_list = ns_dyn_mem_alloc(dns_search_list_len);
+            if (dns_entry->search_list) {
+                dns_entry->search_list_length = dns_search_list_len;
+            }
+        }
+    }
+
+    if (dns_entry->search_list_length) {
+        //Copy Search List to allocated buffer
+        memcpy(dns_entry->search_list, dns_search_list_ptr, dns_entry->search_list_length);
+    }
+
+    return 0;
+}
+
+int DHCPv6_server_service_set_vendor_data(int8_t interface, uint8_t guaPrefix[static 16], uint32_t enterprise_number, uint8_t *dhcp_vendor_data_ptr, uint8_t dhcp_vendor_data_len)
+{
+    dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
+    if (!serverInfo) {
+        return -1;
+    }
+
+    dhcpv6_vendor_data_t *vendor_data_entry = libdhcpv6_vendor_data_allocate(serverInfo, enterprise_number);
+
+    if (!vendor_data_entry) {
+        return -1;
+    }
+
+    if (vendor_data_entry->vendor_data_length != dhcp_vendor_data_len) {
+        ns_dyn_mem_free(vendor_data_entry->vendor_data);
+        vendor_data_entry->vendor_data = NULL;
+        vendor_data_entry->vendor_data_length = 0;
+        if (dhcp_vendor_data_len) {
+            vendor_data_entry->vendor_data = ns_dyn_mem_alloc(dhcp_vendor_data_len);
+            if (vendor_data_entry->vendor_data) {
+                vendor_data_entry->vendor_data_length = dhcp_vendor_data_len;
+            }
+        }
+    }
+
+    if (vendor_data_entry->vendor_data_length) {
+        //Copy Venfor Data to allocated buffer
+        memcpy(vendor_data_entry->vendor_data, dhcp_vendor_data_ptr, vendor_data_entry->vendor_data_length);
+    }
+    return 0;
+}
+
 #else
 
 int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)

source/DHCPv6_Server/DHCPv6_server_service.h

@@ -89,6 +89,11 @@ int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_
  *  /param validLifeTimne in seconds
  */
 int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne);
+
+int DHCPv6_server_service_set_dns_server(int8_t interface, uint8_t guaPrefix[static 16], uint8_t dns_server_address[static 16], uint8_t *dns_search_list_ptr, uint8_t dns_search_list_len);
+
+int DHCPv6_server_service_set_vendor_data(int8_t interface, uint8_t guaPrefix[static 16], uint32_t enterprise_number, uint8_t *dhcp_vendor_data_ptr, uint8_t dhcp_vendor_data_len);
+
 #else
 #define DHCPv6_server_service_delete(interface, guaPrefix, delete_gua_addresses)
 #endif

source/DHCPv6_client/dhcpv6_client_api.h

@@ -79,8 +79,48 @@ void dhcp_client_delete(int8_t interface);
  */
 typedef void (dhcp_client_global_adress_cb)(int8_t interface, uint8_t dhcp_addr[static 16], uint8_t prefix[static 16], bool register_status);
 
+typedef struct dhcp_server_notify_info {
+    uint16_t duid_type;
+    uint16_t duid_length;
+    uint32_t life_time;
+    uint8_t *duid;
+} dhcp_server_notify_info_t;
+
+
+typedef struct dhcp_gen_option {
+    uint16_t data_length;
+    uint8_t *data;
+} dhcp_gen_option_t;
+
+typedef struct dhcp_vendor_spesific_option {
+    uint32_t enterprise_number;
+    uint16_t data_length;
+    uint8_t *data;
+} dhcp_vendor_spesific_option_t;
+
+typedef struct dhcp_option_notify_s {
+    uint8_t option_type;
+    union {
+        dhcp_gen_option_t generic;
+        dhcp_vendor_spesific_option_t vendor_spesific;
+    } option;
+} dhcp_option_notify_t;
+
+/* give dhcp Client server Optional options notication
+ *
+ * /param interface interface id
+ * /param option_type Type of option
+ * /param option_data data of options.
+ * /param option_length length of option.
+ * /param server_info info inclu DUID and Life-time for notify options
+ *
+ */
+typedef void (dhcp_client_options_notify_cb)(int8_t interface, dhcp_option_notify_t *options, dhcp_server_notify_info_t *server_info);
+
 int dhcp_client_get_global_address(int8_t interface, uint8_t dhcp_addr[static 16], uint8_t prefix[static 16], dhcp_client_global_adress_cb *error_cb);
 
+int dhcp_client_option_notification_cb_set(int8_t interface, dhcp_client_options_notify_cb *notify_cb);
+
 /* Renew all leased adddresses might be used when short address changes
  *
  * /param interface interface where address is got

source/DHCPv6_client/dhcpv6_client_service.c

@@ -33,6 +33,7 @@
 
 typedef struct {
     dhcp_client_global_adress_cb *global_address_cb;
+    dhcp_client_options_notify_cb *option_information_cb;
     uint16_t service_instance;
     uint16_t relay_instance;
     uint16_t sol_timeout;
@@ -152,6 +153,17 @@ void dhcp_client_solicit_timeout_set(int8_t interface, uint16_t timeout, uint16_
     return;
 }
 
+int dhcp_client_option_notification_cb_set(int8_t interface, dhcp_client_options_notify_cb *notify_cb)
+{
+    dhcp_client_class_t *dhcp_client = dhcpv6_client_entry_discover(interface);
+    if (!dhcp_client) {
+        return -1;
+    }
+    dhcp_client->option_information_cb = notify_cb;
+    return 0;
+
+}
+
 void dhcp_relay_agent_enable(int8_t interface, uint8_t border_router_address[static 16])
 {
     dhcp_client_class_t *dhcp_client = dhcpv6_client_entry_discover(interface);
@@ -215,6 +227,66 @@ void dhcpv6_client_send_error_cb(dhcpv6_client_server_data_t *srv_data_ptr)
 }
 
 
+static void dhcp_vendor_information_notify(uint8_t *ptr, uint16_t data_len, dhcp_client_class_t *dhcp_client, dhcpv6_client_server_data_t *srv_data_ptr)
+{
+    if (!dhcp_client->option_information_cb) {
+        return;
+    }
+
+    if (!srv_data_ptr->iaNontemporalAddress.validLifetime) {
+        return; //Valid Lifetime zero
+    }
+
+    dhcp_option_notify_t dhcp_option;
+
+    uint16_t type, length;
+    bool valid_optional_options;
+
+    dhcp_server_notify_info_t server_info;
+    server_info.life_time = srv_data_ptr->iaNontemporalAddress.validLifetime;
+    server_info.duid = srv_data_ptr->serverDUID.duid;
+    server_info.duid_type = srv_data_ptr->serverDUID.type;
+    server_info.duid_length = srv_data_ptr->serverDUID.duid_length;
+
+    while (data_len >= 4) {
+        type = common_read_16_bit(ptr);
+        ptr += 2;
+        length = common_read_16_bit(ptr);
+        ptr += 2;
+        data_len -= 4;
+        if (data_len < length) {
+            return;
+        }
+        valid_optional_options = false;
+        //Accept only listed items below with validated lengths
+        if ((type == DHCPV6_OPTION_VENDOR_SPECIFIC_INFO || type == DHCPV6_OPTION_VENDOR_CLASS) && data_len >= 4) {
+            valid_optional_options = true;
+            //Parse enterprise number
+            dhcp_option.option.vendor_spesific.enterprise_number = common_read_32_bit(ptr);
+            ptr += 4;
+            data_len -= 4;
+            dhcp_option.option.vendor_spesific.data = ptr;
+            dhcp_option.option.vendor_spesific.data_length = data_len;
+
+
+        } else if (type == DHCPV6_OPTION_DNS_SERVERS && (data_len >= 16 && ((data_len % 16) == 0))) {
+            valid_optional_options = true;
+            dhcp_option.option.generic.data = ptr;
+            dhcp_option.option.generic.data_length = data_len;
+        } else if (type == DHCPV6_OPTION_DOMAIN_LIST) {
+            valid_optional_options = true;
+            dhcp_option.option.generic.data = ptr;
+            dhcp_option.option.generic.data_length = data_len;
+        }
+        if (valid_optional_options) {
+            dhcp_option.option_type = type;
+            dhcp_client->option_information_cb(dhcp_client->interface, &dhcp_option, &server_info);
+        }
+        data_len -= length;
+        ptr += length;
+    }
+}
+
 /* solication responce received for either global address or routter id assignment */
 int dhcp_solicit_resp_cb(uint16_t instance_id, void *ptr, uint8_t msg_name,  uint8_t *msg_ptr, uint16_t msg_len)
 {
@@ -310,6 +382,10 @@ int dhcp_solicit_resp_cb(uint16_t instance_id, void *ptr, uint8_t msg_name,  uin
     if (dhcp_client->global_address_cb) {
         dhcp_client->global_address_cb(dhcp_client->interface, srv_data_ptr->server_address, srv_data_ptr->iaNontemporalAddress.addressPrefix, status);
     }
+
+    //Optional Options notify from Reply
+    dhcp_vendor_information_notify(msg_ptr, msg_len, dhcp_client, srv_data_ptr);
+
     return RET_MSG_ACCEPTED;
 error_exit:
     dhcpv6_client_send_error_cb(srv_data_ptr);