Relay message flow optimization

Service and KMP store now header size which is allocated for message
relay purpose

Socket send message API is enabled which reduce temporary memory
allocation.

MPX send store now 2 pointer: data pointer which is used at send and
buffer which can be freed.

Author: Juha Heiskanen

source/6LoWPAN/ws/ws_eapol_auth_relay.c

@@ -34,8 +34,7 @@
 #include "6LoWPAN/ws/ws_eapol_pdu.h"
 #include "6LoWPAN/ws/ws_eapol_relay.h"
 #include "6LoWPAN/ws/ws_eapol_auth_relay.h"
-#include "Security/kmp/kmp_socket_api.h"
-
+#include "common_functions.h"
 #ifdef HAVE_WS
 
 #define TRACE_GROUP "wspsu"
@@ -45,12 +44,6 @@ static int8_t ws_eapol_auth_relay_eapol_pdu_receive(const uint8_t *eui_64, const
 static int8_t ws_eapol_auth_relay_socket_pdu_receive(const ns_address_t *src_addr, void *data, uint16_t len);
 static int8_t ws_eapol_auth_relay_send_to_kmp(const uint8_t *eui_64, const uint8_t *ip_addr, uint16_t port, const void *data, uint16_t data_len);
 
-// Wi-Sun EAPOL relay UDP data format
-typedef struct {
-    uint8_t eui_64[8];    /**< Supplicant EUI-64 */
-    uint8_t kmp_id;       /**< KMP id */
-} eapol_relay_udp_pdu_t;
-
 int8_t ws_eapol_auth_relay_init(protocol_interface_info_entry_t *interface_ptr)
 {
     ws_eapol_relay_init(interface_ptr);
@@ -93,64 +86,76 @@ static int8_t ws_eapol_auth_relay_socket_pdu_receive(const ns_address_t *src_add
 
     // KMP message from source port 10254
     if (src_addr->identifier == 10254) {
-        kmp_udp_pdu_t *pdu = data;
-        uint16_t data_len = len - sizeof(kmp_udp_pdu_t) + 2 * sizeof(uint8_t);
-
+        uint8_t *ptr = data;
+        uint8_t *relay_ip_addr, *eui_64;
+        uint16_t relay_port;
+        relay_ip_addr = ptr;
+        ptr += 16;
+        relay_port = common_read_16_bit(ptr);
+        ptr += 2;
+        eui_64 = ptr;
+        ptr += 8;
+        uint16_t data_len = len - 26;
         // KMP protocol to relay -> packet with IP relay address -> to IP relay of node
-        if (memcmp(pdu->relay_ip_addr, ADDR_UNSPECIFIED, 16) != 0) {
-            res = ws_eapol_relay_send_to_relay(pdu->eui_64, pdu->relay_ip_addr, pdu->relay_port,
-                &pdu->kmp_id, data_len);
-            ns_dyn_mem_free(pdu);
+        if (memcmp(relay_ip_addr, ADDR_UNSPECIFIED, 16) != 0) {
+            res = ws_eapol_relay_send_to_relay(eui_64, relay_ip_addr, relay_port,
+                ptr, data_len);
+            ns_dyn_mem_free(data);
 
         // KMP protocol to relay -> no IP relay address -> to MPX
         } else {
-            void *eapol_pdu = ns_dyn_mem_temporary_alloc(data_len);
-            if (!eapol_pdu) {
-                ns_dyn_mem_free(pdu);
-                return -1;
-            }
-            memcpy(eapol_pdu, &pdu->kmp_id, data_len);
-
-            res = ws_eapol_pdu_send_to_mpx(pdu->eui_64, eapol_pdu, data_len);
-            ns_dyn_mem_free(pdu);
+            res = ws_eapol_pdu_send_to_mpx(eui_64, ptr, data_len, data);
         }
 
+
     // Other source port (either 10253 or node relay source port)
     } else {
-        eapol_relay_udp_pdu_t *pdu = data;
-        uint16_t data_len = len - sizeof(eapol_relay_udp_pdu_t) + sizeof(uint8_t);
-        res = ws_eapol_auth_relay_send_to_kmp(pdu->eui_64, src_addr->address, src_addr->identifier,
-            &pdu->kmp_id, data_len);
-        ns_dyn_mem_free(pdu);
+        uint8_t *ptr = data;
+        res = ws_eapol_auth_relay_send_to_kmp(ptr, src_addr->address, src_addr->identifier,
+                                              ptr + 8, len -8);
+        ns_dyn_mem_free(data);
      }
 
     return res;
 }
 
 static int8_t ws_eapol_auth_relay_send_to_kmp(const uint8_t *eui_64, const uint8_t *ip_addr, uint16_t port, const void *data, uint16_t data_len)
 {
-    uint16_t pdu_len = data_len + sizeof(kmp_udp_pdu_t) - 2 * sizeof(uint8_t);
-    kmp_udp_pdu_t *pdu = ns_dyn_mem_temporary_alloc(pdu_len);
-    if (!pdu) {
-        return -1;
-    }
 
-    memcpy(pdu->relay_ip_addr, ip_addr, 16);
-    pdu->relay_port = port;
-
-    memcpy(&pdu->eui_64[0], eui_64, 8);
-    memcpy(&pdu->kmp_id, data, data_len);
 
     ns_address_t dest_addr;
     if (ws_eapol_relay_kmp_ll_address_get(&dest_addr) < 0) {
-        ns_dyn_mem_free(pdu);
         return -1;
     }
 
-    ws_eapol_relay_socket_pdu_send(&dest_addr, pdu, pdu_len);
-    ns_dyn_mem_free(pdu);
 
-    return 0;
+    int8_t socket_id = ws_eapol_relay_socket_id_get();
+    if (socket_id >= 0) {
+        uint8_t temp_array[26];
+        ns_iovec_t msg_iov[2];
+        ns_msghdr_t msghdr;
+        //Set messages name buffer
+        msghdr.msg_name = &dest_addr;
+        msghdr.msg_namelen = sizeof(dest_addr);
+        msghdr.msg_iov = &msg_iov[0];
+        msghdr.msg_iovlen = 2;
+        msghdr.msg_control = NULL;
+        msghdr.msg_controllen = 0;
+        uint8_t *ptr = temp_array;
+        memcpy(ptr, ip_addr, 16);
+        ptr += 16;
+        ptr = common_write_16_bit(port, ptr);
+        memcpy(ptr, eui_64, 8);
+        msg_iov[0].iov_base = temp_array;
+        msg_iov[0].iov_len = 26;
+        msg_iov[1].iov_base = (void*)data;
+        msg_iov[1].iov_len = data_len;
+        socket_sendmsg(socket_id, &msghdr, NS_MSG_LEGACY0);
+        return 0;
+
+    }
+
+    return -1;
 }
 
 #endif /* HAVE_WS */

source/6LoWPAN/ws/ws_eapol_pdu.c

@@ -43,6 +43,7 @@ static void ws_eapol_pdu_data_request_primitiv_set(mcps_data_req_t *dataReq, pro
 typedef struct {
     uint8_t handle;
     void *data_ptr;
+    void *buffer;
     ns_list_link_t link;
 } eapol_pdu_msdu_entry_t;
 
@@ -110,17 +111,18 @@ int8_t ws_eapol_pdu_cb_register(eapol_pdu_recv_cb_data_t *cb_data)
     return 0;
 }
 
-int8_t ws_eapol_pdu_send_to_mpx(const uint8_t *eui_64, void *data, uint16_t data_len)
+int8_t ws_eapol_pdu_send_to_mpx(const uint8_t *eui_64, void *data, uint16_t data_len, void *buffer)
 {
     mcps_data_req_t data_request;
     ws_eapol_pdu_data_request_primitiv_set(&data_request, eapol_pdu_data->interface_ptr);
 
     eapol_pdu_msdu_entry_t *msdu_entry = ns_dyn_mem_temporary_alloc(sizeof(eapol_pdu_msdu_entry_t));
     if (!msdu_entry) {
-       ns_dyn_mem_free(data);
+       ns_dyn_mem_free(buffer);
        return -1;
     }
     msdu_entry->data_ptr = data;
+    msdu_entry->buffer = buffer;
     msdu_entry->handle = eapol_pdu_data->msdu_handle++;
     ns_list_add_to_start(&eapol_pdu_data->msdu_list, msdu_entry);
 
@@ -164,7 +166,7 @@ static void ws_eapol_pdu_mpx_data_confirm(const mpx_api_t* api, const struct mcp
 
     ns_list_foreach(eapol_pdu_msdu_entry_t, msdu, &eapol_pdu_data->msdu_list) {
        if (msdu->handle == data->msduHandle) {
-          ns_dyn_mem_free(msdu->data_ptr);
+          ns_dyn_mem_free(msdu->buffer);
           ns_list_remove(&eapol_pdu_data->msdu_list, msdu);
           ns_dyn_mem_free(msdu);
           return;

source/6LoWPAN/ws/ws_eapol_pdu.h

@@ -24,7 +24,7 @@ typedef int8_t ws_eapol_pdu_address_check(const uint8_t *eui_64);
 
 typedef int8_t ws_eapol_pdu_receive(const uint8_t *eui_64, const void *pdu, uint16_t size);
 
-int8_t ws_eapol_pdu_send_to_mpx(const uint8_t *eui_64, void *data, uint16_t data_len);
+int8_t ws_eapol_pdu_send_to_mpx(const uint8_t *eui_64, void *data, uint16_t data_len, void *buffer);
 
 typedef enum {
     EAPOL_PDU_RECV_HIGH_PRIORITY = 0,

source/6LoWPAN/ws/ws_eapol_relay.c

@@ -36,20 +36,13 @@
 #include "6LoWPAN/ws/ws_config.h"
 #include "6LoWPAN/ws/ws_eapol_pdu.h"
 #include "6LoWPAN/ws/ws_eapol_relay.h"
-#include "Security/kmp/kmp_socket_api.h"
 
 #ifdef HAVE_WS
 
 #define TRACE_GROUP "wserel"
 
 static void ws_eapol_relay_socket_cb(void *ptr);
 
-// Wi-Sun EAPOL relay UDP data format
-typedef struct {
-    uint8_t eui_64[8];    /**< Supplicant EUI-64 */
-    uint8_t kmp_id;       /**< KMP id */
-} eapol_relay_udp_pdu_t;
-
 typedef struct {
     ws_eapol_relay_socket_pdu_receive *sock_pdu_recv;       /**< Socket pdu receive callback */
     protocol_interface_info_entry_t *interface_ptr;         /**< Interface pointer */
@@ -105,22 +98,26 @@ int8_t ws_eapol_relay_border_router_addr_get(uint8_t *addr)
 
 int8_t ws_eapol_relay_send_to_relay(const uint8_t *eui_64, const uint8_t *ip_addr, uint16_t port, const void *data, uint16_t data_len)
 {
-    uint16_t pdu_len = data_len + sizeof(eapol_relay_udp_pdu_t) - sizeof(uint8_t);
-    eapol_relay_udp_pdu_t *pdu = ns_dyn_mem_temporary_alloc(pdu_len);
-    if (!pdu) {
-       return -1;
-    }
-    memcpy(pdu->eui_64, eui_64, 8);
-    memcpy(&pdu->kmp_id, data, data_len);
 
     ns_address_t dest_addr;
     dest_addr.type = ADDRESS_IPV6;
     dest_addr.identifier = port;
     memcpy(&dest_addr.address[0], ip_addr, 16);
 
-    socket_sendto(eapol_relay_data->relay_socket_id , &dest_addr, pdu, pdu_len);
-    ns_dyn_mem_free(pdu);
-
+    ns_iovec_t msg_iov[2];
+    ns_msghdr_t msghdr;
+    //Set messages name buffer
+    msghdr.msg_name = &dest_addr;
+    msghdr.msg_namelen = sizeof(dest_addr);
+    msghdr.msg_iov = &msg_iov[0];
+    msghdr.msg_iovlen = 2;
+    msghdr.msg_control = NULL;
+    msghdr.msg_controllen = 0;
+    msg_iov[0].iov_base = (void*)eui_64;
+    msg_iov[0].iov_len = 8;
+    msg_iov[1].iov_base = (void*)data;
+    msg_iov[1].iov_len = data_len;
+    socket_sendmsg(eapol_relay_data->relay_socket_id, &msghdr, NS_MSG_LEGACY0);
     return 0;
 }
 
@@ -147,6 +144,15 @@ int8_t ws_eapol_relay_socket_pdu_send(const ns_address_t *addr, const void *data
     return 0;
 }
 
+int8_t ws_eapol_relay_socket_id_get(void)
+{
+    if (!eapol_relay_data) {
+        return -1;
+    }
+
+    return eapol_relay_data->relay_socket_id;
+}
+
 static void ws_eapol_relay_socket_cb(void *cb)
 {
     if (!eapol_relay_data || !eapol_relay_data->sock_pdu_recv) {

source/6LoWPAN/ws/ws_eapol_relay.h

@@ -26,6 +26,7 @@ int8_t ws_eapol_relay_cb_register(ws_eapol_relay_socket_pdu_receive *sock_pdu_re
 int8_t ws_eapol_relay_border_router_addr_get(uint8_t *addr);
 int8_t ws_eapol_relay_kmp_ll_address_get(ns_address_t *addr);
 int8_t ws_eapol_relay_socket_pdu_send(const ns_address_t *addr, const void *data, uint16_t len);
+int8_t ws_eapol_relay_socket_id_get(void);
 
 int8_t ws_eapol_relay_send_to_relay(const uint8_t *eui_64, const uint8_t *ip_addr, uint16_t port, const void *data, uint16_t data_len);
 

source/6LoWPAN/ws/ws_eapol_supp_relay.c

@@ -34,7 +34,6 @@
 #include "6LoWPAN/ws/ws_eapol_pdu.h"
 #include "6LoWPAN/ws/ws_eapol_relay.h"
 #include "6LoWPAN/ws/ws_eapol_supp_relay.h"
-#include "Security/kmp/kmp_socket_api.h"
 
 #ifdef HAVE_WS
 
@@ -44,12 +43,6 @@ static int8_t ws_eapol_supp_relay_eapol_pdu_address_check(const uint8_t *eui_64)
 static int8_t ws_eapol_supp_relay_eapol_pdu_receive(const uint8_t *eui_64, const void *pdu, uint16_t size);
 static int8_t ws_eapol_supp_relay_socket_pdu_receive(const ns_address_t *src_addr, void *data, uint16_t len);
 
-// Wi-Sun EAPOL relay UDP data format
-typedef struct {
-    uint8_t eui_64[8];    /**< Supplicant EUI-64 */
-    uint8_t kmp_id;       /**< KMP id */
-} eapol_relay_udp_pdu_t;
-
 static ws_eapol_supp_relay_address_get *br_relay_addr_get;
 
 int8_t ws_eapol_supp_relay_init(protocol_interface_info_entry_t *interface_ptr)
@@ -119,20 +112,10 @@ static int8_t ws_eapol_supp_relay_socket_pdu_receive(const ns_address_t *src_add
 {
     (void) src_addr;
 
-    eapol_relay_udp_pdu_t *pdu = data;
-    uint16_t data_len = len - sizeof(eapol_relay_udp_pdu_t) + sizeof(uint8_t);
-
-    void *eapol_pdu = ns_dyn_mem_temporary_alloc(data_len);
-    if (!eapol_pdu) {
-        ns_dyn_mem_free(data);
-        return -1;
-    }
-
-    memcpy(eapol_pdu, &pdu->kmp_id, data_len);
-    ws_eapol_pdu_send_to_mpx(pdu->eui_64, eapol_pdu, data_len);
+    uint8_t *pdu = data;
+    //First 8 byte is EUID64 and rsr payload
+    return ws_eapol_pdu_send_to_mpx(pdu, pdu + 8, len - 8, data);
 
-    ns_dyn_mem_free(data);
-    return 0;
 }
 
 #endif /* HAVE_WS */

source/6LoWPAN/ws/ws_pae_auth.c

@@ -125,7 +125,7 @@ void ws_pae_auth_init(protocol_interface_info_entry_t *interface_ptr)
 
     kmp_socket_if_init(interface_ptr);
 
-    kmp_service_init(interface_ptr);
+    kmp_service_init(interface_ptr, 27);
     kmp_service_cb_register(ws_pae_auth_kmp_incoming_ind, kmp_socket_if_send);
 }
 

source/6LoWPAN/ws/ws_pae_supp.c

@@ -108,7 +108,7 @@ int8_t ws_pae_supp_init(protocol_interface_info_entry_t *interface_ptr)
         return -1;
     }
 
-    if (kmp_service_init(interface_ptr) < 0) {
+    if (kmp_service_init(interface_ptr, 1) < 0) {
         return -1;
     }
 

source/Security/kmp/key_sec_prot.c

@@ -85,17 +85,12 @@ static void key_sec_prot_create_request(sec_prot_t *prot, sec_prot_keys_t *sec_k
     key_sec_prot_int_t *data = key_sec_prot_get(prot);
     (void) sec_keys;
 
-    uint8_t kmpid_test[22];
-    kmpid_test[0] = 0xdd;
-    kmpid_test[1] = 20;
-    common_write_24_bit(0x0C5A9E, &kmpid_test[2]);
-    kmpid_test[5] = 1;
 
     eapol_pdu_t eapol_pdu;
 
-    uint16_t eapol_pdu_size =  eapol_pdu_key_frame_init(&eapol_pdu, 22, kmpid_test);
+    uint16_t eapol_pdu_size =  eapol_pdu_key_frame_init(&eapol_pdu, 0, NULL);
 
-    uint8_t *eapol_decoded_data = ns_dyn_mem_temporary_alloc(eapol_pdu_size); // In future fill with data that defines eapol message
+    uint8_t *eapol_decoded_data = ns_dyn_mem_temporary_alloc(eapol_pdu_size + prot->header_size); // In future fill with data that defines eapol message
 
 
     if (!eapol_decoded_data) {
@@ -106,9 +101,9 @@ static void key_sec_prot_create_request(sec_prot_t *prot, sec_prot_keys_t *sec_k
         eapol_pdu.msg.key.key_information.pairwise_key = true;
         eapol_pdu.msg.key.replay_counter = 10;
         eapol_pdu.msg.key.key_length = 32;
-        eapol_write_pdu_frame(eapol_decoded_data, &eapol_pdu);
+        eapol_write_pdu_frame(eapol_decoded_data+prot->header_size, &eapol_pdu);
 
-        if (prot->send(prot, eapol_decoded_data, eapol_pdu_size) < 0) {
+        if (prot->send(prot, eapol_decoded_data, eapol_pdu_size + prot->header_size) < 0) {
             data->result = SEC_RESULT_ERR_NO_MEM;
         }
     }
@@ -130,12 +125,10 @@ static int8_t key_sec_prot_receive(sec_prot_t *prot, void *pdu, uint16_t size)
     eapol_pdu_t eapol_pdu;
     // Decoding is successful
     if (eapol_parse_pdu_header(pdu, size, &eapol_pdu)) {
-        ns_dyn_mem_free(pdu);
         prot->create_ind(prot);
         return 0;
     } else {
         // No error handling yet, indicate just that ready to be deleted
-        ns_dyn_mem_free(pdu);
         prot->finished(prot);
         return -1;
     }