Added PPP interface to nanostack

This utilizes ethernet interface. PPP interface differences to Ethernet:
- interface identifier is provided when interface is added
- there is no link layer address (e.g. MAC)
- Neighbor solification’s are not made
- SLLAO is not added to RS (because link layer address e.g. MAC address is not set)
- Duplicate address detection is not made

Author: Mika Leppänen

nanostack/ethernet_mac_api.h

@@ -123,6 +123,22 @@ typedef int8_t eth_mac_mac48_address_set(const eth_mac_api_t *api, const uint8_t
  */
 typedef int8_t eth_mac_mac48_address_get(const eth_mac_api_t *api, uint8_t *mac48_buf);
 
+/**
+ * @brief Set 64 bit interface identifier from IID64
+ * @param api API to handle the request
+ * @param iid64 Pointer having iid64 to be set
+ * @return 0 if successful, -1 otherwise
+ */
+typedef int8_t eth_mac_iid64_address_set(const eth_mac_api_t *api, const uint8_t *iid64);
+
+/**
+ * @brief Read 64 bit interface identifier
+ * @param api API to handle the request
+ * @paramiid64_buf Pointer where IID64 can be written
+ * @return 0 if successful, -1 otherwise
+ */
+typedef int8_t eth_mac_iid64_address_get(const eth_mac_api_t *api, uint8_t *iid64_buf);
+
 /**
  * @brief Upper layer will call this function, when MAC is taken into use
  * @param api API to initialize
@@ -147,6 +163,9 @@ struct eth_mac_api_s {
     eth_mac_mac48_address_set   *mac48_set;                     /**< Setter for MAC address */
     eth_mac_mac48_address_get   *mac48_get;                     /**< Getter for MAC address */
 
+    eth_mac_iid64_address_set   *iid64_set;                     /**< Setter for IID64 */
+    eth_mac_iid64_address_get   *iid64_get;                     /**< Getter for IID64 */
+
     uint8_t                     parent_id;                      /**< Upper layer ID */
     bool                        address_resolution_needed;      /**< Normal ethernet should set this true for tunnel or false for slip */
 };

nanostack/net_interface.h

@@ -320,6 +320,20 @@ extern int8_t arm_nwk_interface_ethernet_init(struct eth_mac_api_s *api, const c
  */
 extern int8_t arm_nwk_interface_lowpan_init(struct mac_api_s *api, char *interface_name_ptr);
 
+/**
+ * \brief Create network interface base to IDLE state.
+ * \param api Generates interface with PPP.
+ * \param interface_name_ptr String pointer to interface name. Need to end to '\0' character.
+ *        Max length 32 characters including NULL at end. Note: the given name is not copied,
+ *        so it must remain valid as long as the interface is.
+ *
+ * \return >=0 Interface ID (0-127). Application needs to save this information.
+ * \return -1 api was NULL.
+ * \return -2 PPP is not supported at this build.
+ * \return -3 No memory for the interface.
+ */
+extern int8_t arm_nwk_interface_ppp_init(struct eth_mac_api_s *api, const char *interface_name_ptr);
+
 /**
  * \brief Set IPv6 interface setup.
  *

nanostack/platform/arm_hal_phy.h

@@ -97,6 +97,7 @@ typedef enum phy_link_type_e {
     PHY_LINK_15_4_SUBGHZ_TYPE,      /**< Standard 802.15.4 subGHz radio 868 /915MHz. */
     PHY_LINK_TUN,                   /**< Tunnel interface for Linux TUN, RF network driver over serial bus or just basic application to application data flow. */
     PHY_LINK_SLIP,                  /**< Generic SLIP driver which just forward SLIP payload */
+    PHY_LINK_PPP,                   /**< PPP */
 } phy_link_type_e;
 
 /** Data layers */

source/MAC/ethernet/ethernet_mac_api.c

@@ -28,7 +28,7 @@ typedef struct eth_mac_internal_s {
     arm_device_driver_list_s *dev_driver;
     uint8_t *mtu_ptr;
     uint16_t mtu_size;
-    uint8_t mac48[6];
+    uint8_t mac48_iid64[8];
     bool active_data_request;
     int8_t tasklet_id;
     //linked list link
@@ -52,6 +52,8 @@ static int8_t eth_mac_api_init(eth_mac_api_t *api, eth_mac_data_confirm *conf_cb
 static void data_req(const eth_mac_api_t *api, const eth_data_req_t *data);
 static int8_t mac48_address_set(const eth_mac_api_t *api, const uint8_t *mac48);
 static int8_t mac48_address_get(const eth_mac_api_t *api, uint8_t *mac48_buf);
+static int8_t iid64_address_set(const eth_mac_api_t *api, const uint8_t *iid64);
+static int8_t iid64_address_get(const eth_mac_api_t *api, uint8_t *iid64_buf);
 
 static int8_t eth_mac_net_phy_rx(const uint8_t *data_ptr, uint16_t data_len, uint8_t link_quality, int8_t dbm, int8_t driver_id);
 static int8_t eth_mac_net_phy_tx_done(int8_t driver_id, uint8_t tx_handle, phy_link_tx_status_e status, uint8_t cca_retry, uint8_t tx_retry);
@@ -98,6 +100,7 @@ eth_mac_api_t *ethernet_mac_create(int8_t driver_id)
     switch (driver->phy_driver->link_type) {
 
         case PHY_LINK_SLIP:
+        case PHY_LINK_PPP:
             //Do not Allocate
             address_resolution_needed = false;
             buffer_length = 0;
@@ -133,19 +136,29 @@ eth_mac_api_t *ethernet_mac_create(int8_t driver_id)
     memset(this, 0, sizeof(eth_mac_api_t));
     this->mac_initialize = &eth_mac_api_init;
     this->data_req = &data_req;
-    this->mac48_get = &mac48_address_get;
-    this->mac48_set = &mac48_address_set;
+
+    if (driver->phy_driver->link_type == PHY_LINK_PPP) {
+        this->iid64_get = &iid64_address_get;
+        this->iid64_set = &iid64_address_set;
+    } else {
+        this->mac48_get = &mac48_address_get;
+        this->mac48_set = &mac48_address_set;
+    }
 
     this->address_resolution_needed = address_resolution_needed;
 
-    memset(&mac_store.mac48, 0, 6);
+    memset(&mac_store.mac48_iid64, 0, 8);
     mac_store.active_data_request = false;
     mac_store.mac_api = this;
     mac_store.dev_driver = driver;
     mac_store.mtu_ptr = buffer_ptr;
     mac_store.mtu_size = buffer_length;
 
-    memcpy(&mac_store.mac48, mac_store.dev_driver->phy_driver->PHY_MAC, 6);
+    if (driver->phy_driver->link_type == PHY_LINK_PPP) {
+        memcpy(&mac_store.mac48_iid64, mac_store.dev_driver->phy_driver->PHY_MAC, 8);
+    } else {
+        memcpy(&mac_store.mac48_iid64, mac_store.dev_driver->phy_driver->PHY_MAC, 6);
+    }
     if (mac_store.tasklet_id == -1) {
         mac_store.tasklet_id = eventOS_event_handler_create(&ethernet_mac_tasklet, ETH_INIT_EVENT);
     }
@@ -289,7 +302,7 @@ static int8_t eth_mac_net_phy_rx(const uint8_t *data_ptr, uint16_t data_len, uin
 
         data_len -= 4;
         data_ptr += 4;
-    } else if (driver->phy_driver->link_type == PHY_LINK_SLIP) {
+    } else if (driver->phy_driver->link_type == PHY_LINK_SLIP || driver->phy_driver->link_type == PHY_LINK_PPP) {
         data_ind->etehernet_type = ETHERTYPE_IPV6;
     }
 
@@ -357,10 +370,10 @@ static int8_t mac48_address_set(const eth_mac_api_t *api, const uint8_t *mac48)
     if (!mac48 || !api || mac_store.mac_api != api) {
         return -1;
     }
-    memcpy(mac_store.mac48, mac48, 6);
+    memcpy(mac_store.mac48_iid64, mac48, 6);
     phy_device_driver_s *driver = mac_store.dev_driver->phy_driver;
     if (driver->address_write) {
-        driver->address_write(PHY_MAC_48BIT, mac_store.mac48);
+        driver->address_write(PHY_MAC_48BIT, mac_store.mac48_iid64);
     }
     return 0;
 }
@@ -370,7 +383,30 @@ static int8_t mac48_address_get(const eth_mac_api_t *api, uint8_t *mac48_buf)
     if (!mac48_buf || !api || mac_store.mac_api != api) {
         return -1;
     }
-    memcpy(&mac_store.mac48, mac_store.dev_driver->phy_driver->PHY_MAC, 6);
-    memcpy(mac48_buf, mac_store.mac48, 6);
+    memcpy(&mac_store.mac48_iid64, mac_store.dev_driver->phy_driver->PHY_MAC, 6);
+    memcpy(mac48_buf, mac_store.mac48_iid64, 6);
+    return 0;
+}
+
+static int8_t iid64_address_set(const eth_mac_api_t *api, const uint8_t *iid64)
+{
+    if (!iid64 || !api || mac_store.mac_api != api) {
+        return -1;
+    }
+    memcpy(mac_store.mac48_iid64, iid64, 8);
+    phy_device_driver_s *driver = mac_store.dev_driver->phy_driver;
+    if (driver->address_write) {
+        driver->address_write(PHY_MAC_48BIT, mac_store.mac48_iid64);
+    }
+    return 0;
+}
+
+static int8_t iid64_address_get(const eth_mac_api_t *api, uint8_t *iid64_buf)
+{
+    if (!iid64_buf || !api || mac_store.mac_api != api) {
+        return -1;
+    }
+    memcpy(&mac_store.mac48_iid64, mac_store.dev_driver->phy_driver->PHY_MAC, 8);
+    memcpy(iid64_buf, mac_store.mac48_iid64, 8);
     return 0;
 }

source/NWK_INTERFACE/Include/protocol.h

@@ -499,6 +499,7 @@ extern uint8_t nwk_bootsrap_ready(protocol_interface_info_entry_t *cur);
 extern protocol_interface_info_entry_t *protocol_stack_interface_info_get(nwk_interface_id nwk_id);
 extern bool nwk_interface_compare_mac_address(protocol_interface_info_entry_t *cur, uint_fast8_t addrlen, const uint8_t addr[/*addrlen*/]);
 extern protocol_interface_info_entry_t *protocol_stack_interface_generate_ethernet(struct eth_mac_api_s *api);
+extern protocol_interface_info_entry_t *protocol_stack_interface_generate_ppp(struct eth_mac_api_s *api);
 extern protocol_interface_info_entry_t *protocol_stack_interface_generate_lowpan(struct mac_api_s *api);
 extern uint32_t protocol_stack_interface_set_reachable_time(protocol_interface_info_entry_t *cur, uint32_t base_reachable_time);
 extern void net_bootsrap_cb_run(uint8_t event);

source/NWK_INTERFACE/protocol_core.c

@@ -904,6 +904,59 @@ protocol_interface_info_entry_t *protocol_stack_interface_generate_ethernet(eth_
     return NULL;
 }
 
+void protocol_stack_interface_ppp_addr_notification(struct protocol_interface_info_entry *interface, const struct if_address_entry *addr, if_address_callback_t reason)
+{
+    if (interface->dup_addr_detect_transmits == 0 && !addr_is_ipv6_link_local(addr->address) && reason == ADDR_CALLBACK_DAD_COMPLETE && addr->source == ADDR_SOURCE_SLAAC) {
+        interface->global_address_available = true;
+    }
+}
+
+protocol_interface_info_entry_t *protocol_stack_interface_generate_ppp(eth_mac_api_t *api)
+{
+    if (!api) {
+        return NULL;
+    }
+    protocol_interface_info_entry_t *new_entry = NULL;
+
+    ns_list_foreach(protocol_interface_info_entry_t, cur, &protocol_interface_info_list) {
+        if (cur->eth_mac_api == api) {
+            return cur;
+        }
+    }
+
+    if (api) {
+        new_entry = protocol_core_interface_ethernet_entry_get(api);
+
+        if (new_entry) {
+            neighbor_cache_init(&(new_entry->neigh_cache));
+            pan_blacklist_cache_init(&(new_entry->pan_blaclist_cache));
+            pan_coordinator_blacklist_cache_init(&(new_entry->pan_cordinator_black_list));
+            ipv6_neighbour_cache_init(&new_entry->ipv6_neighbour_cache, new_entry->id);
+            addr_max_slaac_entries_set(new_entry, 16);
+            uint8_t iid64[8];
+            int8_t error = api->iid64_get(api, iid64);
+            if (error) {
+                tr_error("iid64_get failed: %d", error);
+                ns_dyn_mem_free(new_entry);
+                return NULL;
+            }
+            memcpy(new_entry->iid_slaac, iid64, 8);
+            memcpy(new_entry->iid_eui64, iid64, 8);
+            new_entry->send_mld = false;                 // No mld for PPP
+            new_entry->dup_addr_detect_transmits = 0;    // No duplicate detection for PPP
+
+            ns_list_add_to_start(&protocol_interface_info_list, new_entry);
+
+            (void) ipv6_route_table_set_max_entries(new_entry->id, ROUTE_RADV, 16);
+
+            addr_notification_register(protocol_stack_interface_ppp_addr_notification);
+
+            return new_entry;
+        }
+    }
+    return NULL;
+}
+
 protocol_interface_info_entry_t *protocol_stack_interface_generate_lowpan(mac_api_t *api)
 {
     if (!api) {

source/ipv6_stack/protocol_ipv6.c

@@ -245,6 +245,12 @@ static uint8_t ethernet_llao_write(protocol_interface_info_entry_t *cur, uint8_t
 {
     (void) must;
     (void) ip_addr;
+
+    uint8_t mac_not_set[8] = {0,0,0,0,0,0,0,0};
+    if (memcmp(cur->mac, mac_not_set, 8) == 0) {
+        return 0;
+    }
+
     if (opt_out) {
         opt_out[0] = opt_type;
         opt_out[1] = 1;

source/libNET/src/ns_net.c

@@ -701,6 +701,28 @@ int8_t arm_nwk_interface_ethernet_init(eth_mac_api_t *api, const char *interface
 #endif
 }
 
+extern int8_t arm_nwk_interface_ppp_init(struct eth_mac_api_s *api, const char *interface_name_ptr)
+{
+#ifdef HAVE_ETHERNET
+    if (!api) {
+        return -1;
+    }
+
+    protocol_interface_info_entry_t *cur = protocol_stack_interface_generate_ppp(api);
+    if (!cur) {
+        return -3;
+    }
+
+    cur->if_up = ipv6_interface_up;
+    cur->if_down = ipv6_interface_down;
+    cur->interface_name = interface_name_ptr;
+    return cur->id;
+#else
+    (void)api;
+    (void)interface_name_ptr;
+    return -2;
+#endif
+}
 
 int8_t arm_nwk_interface_lowpan_init(mac_api_t *api, char *interface_name_ptr)
 {