Merge pull request #6903 from ARMmbed/feature-emac-15May-merge

Feature-emac combined merge

Author: kjbracey

features/FEATURE_LWIP/lwip-interface/LWIPStack.cpp

@@ -33,6 +33,7 @@
 #include "lwip/dns.h"
 #include "lwip/udp.h"
 #include "lwip/lwip_errno.h"
+#include "lwip-sys/arch/sys_arch.h"
 
 #include "LWIPStack.h"
 
@@ -47,10 +48,10 @@ void LWIP::socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len)
         return;
     }
 
-    sys_prot_t prot = sys_arch_protect();
-
     LWIP &lwip = LWIP::get_instance();
 
+    lwip.adaptation.lock();
+
     for (int i = 0; i < MEMP_NUM_NETCONN; i++) {
         if (lwip.arena[i].in_use
             && lwip.arena[i].conn == nc
@@ -59,7 +60,7 @@ void LWIP::socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len)
         }
     }
 
-    sys_arch_unprotect(prot);
+    lwip.adaptation.unlock();
 }
 
 #if !LWIP_IPV4 || !LWIP_IPV6
@@ -149,6 +150,7 @@ void LWIP::tcpip_init_irq(void *eh)
 {
     LWIP *lwip = static_cast<LWIP *>(eh);
     lwip->tcpip_inited.release();
+    sys_tcpip_thread_set();
 }
 
 /* LWIP network stack implementation */
@@ -173,80 +175,85 @@ LWIP::LWIP()
     arena_init();
 }
 
-nsapi_error_t LWIP::gethostbyname(const char *host, SocketAddress *address, nsapi_version_t version)
+nsapi_error_t LWIP::get_dns_server(int index, SocketAddress *address)
 {
-    ip_addr_t lwip_addr;
-
-#if LWIP_IPV4 && LWIP_IPV6
-    u8_t addr_type;
-    if (version == NSAPI_UNSPEC) {
-        const ip_addr_t *ip_addr = NULL;
-        if (default_interface) {
-            ip_addr = get_ip_addr(true, &default_interface->netif);
-        }
-        // Prefer IPv6
-        if (IP_IS_V6(ip_addr)) {
-            // If IPv4 is available use it as backup
-            if (get_ipv4_addr(&default_interface->netif)) {
-                addr_type = NETCONN_DNS_IPV6_IPV4;
-            } else {
-                addr_type = NETCONN_DNS_IPV6;
-            }
-        // Prefer IPv4
-        } else {
-            // If IPv6 is available use it as backup
-            if (get_ipv6_addr(&default_interface->netif)) {
-                addr_type = NETCONN_DNS_IPV4_IPV6;
-            } else {
-                addr_type = NETCONN_DNS_IPV4;
+    int dns_entries = 0;
+
+    for (int i = 0; i < DNS_MAX_SERVERS; i++) {
+        const ip_addr_t *ip_addr = dns_getserver(i);
+        if (!ip_addr_isany(ip_addr)) {
+            if (index == dns_entries) {
+                nsapi_addr_t addr;
+                convert_lwip_addr_to_mbed(&addr, ip_addr);
+                address->set_addr(addr);
+                return NSAPI_ERROR_OK;
             }
+            dns_entries++;
         }
-    } else if (version == NSAPI_IPv4) {
-        addr_type = NETCONN_DNS_IPV4;
-    } else if (version == NSAPI_IPv6) {
-        addr_type = NETCONN_DNS_IPV6;
-    } else {
-        return NSAPI_ERROR_DNS_FAILURE;
     }
-    err_t err = netconn_gethostbyname_addrtype(host, &lwip_addr, addr_type);
-#elif LWIP_IPV4
-     if (version != NSAPI_IPv4 && version != NSAPI_UNSPEC) {
-        return NSAPI_ERROR_DNS_FAILURE;
+    return NSAPI_ERROR_NO_ADDRESS;
+}
+
+void LWIP::tcpip_thread_callback(void *ptr)
+{
+    lwip_callback *cb = static_cast<lwip_callback *>(ptr);
+
+    if (cb->delay) {
+        sys_timeout(cb->delay, LWIP::tcpip_thread_callback, ptr);
+        cb->delay = 0;
+    } else {
+        cb->callback();
+        delete cb;
     }
-    err_t err = netconn_gethostbyname(host, &lwip_addr);
-#elif LWIP_IPV6
-    if (version != NSAPI_IPv6 && version != NSAPI_UNSPEC) {
-        return NSAPI_ERROR_DNS_FAILURE;
+}
+
+nsapi_error_t LWIP::call_in(int delay, mbed::Callback<void()> func)
+{
+    lwip_callback *cb = new lwip_callback;
+    if (!cb) {
+        return NSAPI_ERROR_NO_MEMORY;
     }
-    err_t err = netconn_gethostbyname(host, &lwip_addr);
-#endif
 
-    if (err != ERR_OK) {
-        return NSAPI_ERROR_DNS_FAILURE;
+    cb->delay = delay;
+    cb->callback = func;
+
+    if (tcpip_callback_with_block(LWIP::tcpip_thread_callback, cb, 1) != ERR_OK) {
+        return NSAPI_ERROR_NO_MEMORY;
     }
 
-    nsapi_addr_t addr;
-    convert_lwip_addr_to_mbed(&addr, &lwip_addr);
-    address->set_addr(addr);
+    return NSAPI_ERROR_OK;
+}
 
-    return 0;
+LWIP::call_in_callback_cb_t LWIP::get_call_in_callback()
+{
+    call_in_callback_cb_t cb(this, &LWIP::call_in);
+    return cb;
 }
 
-nsapi_error_t LWIP::add_dns_server(const SocketAddress &address)
+const char *LWIP::get_ip_address()
 {
-    // Shift all dns servers down to give precedence to new server
-    for (int i = DNS_MAX_SERVERS-1; i > 0; i--) {
-        dns_setserver(i, dns_getserver(i-1));
+    if (!default_interface) {
+        return NULL;
     }
 
-    nsapi_addr_t addr = address.get_addr();
-    ip_addr_t ip_addr;
-    if (!convert_mbed_addr_to_lwip(&ip_addr, &addr)) {
-        return NSAPI_ERROR_PARAMETER;
-    }
+    const ip_addr_t *addr = get_ip_addr(true, &default_interface->netif);
 
-    dns_setserver(0, &ip_addr);
-    return 0;
+    if (!addr) {
+        return NULL;
+    }
+#if LWIP_IPV6
+    if (IP_IS_V6(addr)) {
+        return ip6addr_ntoa_r(ip_2_ip6(addr), ip_address, sizeof(ip_address));
+    }
+#endif
+#if LWIP_IPV4
+    if (IP_IS_V4(addr)) {
+        return ip4addr_ntoa_r(ip_2_ip4(addr), ip_address, sizeof(ip_address));
+    }
+#endif
+#if LWIP_IPV6 && LWIP_IPV4
+    return NULL;
+#endif
 }
 
 nsapi_error_t LWIP::socket_open(nsapi_socket_t *handle, nsapi_protocol_t proto)
@@ -439,6 +446,7 @@ nsapi_size_or_error_t LWIP::socket_sendto(nsapi_socket_t handle, const SocketAdd
     }
 
     struct netbuf *buf = netbuf_new();
+
     err_t err = netbuf_ref(buf, data, (u16_t)size);
     if (err != ERR_OK) {
         netbuf_free(buf);
@@ -588,7 +596,7 @@ nsapi_error_t LWIP::setsockopt(nsapi_socket_t handle, int level, int optname, co
 
                 member_pair_index = next_free_multicast_member(s, 0);
 
-                sys_prot_t prot = sys_arch_protect();
+                adaptation.lock();
 
                 #if LWIP_IPV4
                 if (IP_IS_V4(&if_addr)) {
@@ -601,7 +609,7 @@ nsapi_error_t LWIP::setsockopt(nsapi_socket_t handle, int level, int optname, co
                 }
                 #endif
 
-                sys_arch_unprotect(prot);
+                adaptation.unlock();
 
                 if (igmp_err == ERR_OK) {
                     set_multicast_member_registry_bit(s, member_pair_index);
@@ -616,7 +624,7 @@ nsapi_error_t LWIP::setsockopt(nsapi_socket_t handle, int level, int optname, co
                 clear_multicast_member_registry_bit(s, member_pair_index);
                 s->multicast_memberships_count--;
 
-                sys_prot_t prot = sys_arch_protect();
+                adaptation.lock();
 
                 #if LWIP_IPV4
                 if (IP_IS_V4(&if_addr)) {
@@ -629,7 +637,7 @@ nsapi_error_t LWIP::setsockopt(nsapi_socket_t handle, int level, int optname, co
                 }
                 #endif
 
-                sys_arch_unprotect(prot);
+                adaptation.unlock();
             }
 
             return err_remap(igmp_err);

features/FEATURE_LWIP/lwip-interface/LWIPStack.h

@@ -198,29 +198,23 @@ class LWIP : public OnboardNetworkStack, private mbed::NonCopyable<LWIP> {
      */
     nsapi_error_t _add_ppp_interface(void *pcb, bool default_if, LWIP::Interface **interface_out);
 
-    /** Translates a hostname to an IP address with specific version
+    /** Get a domain name server from a list of servers to query
      *
-     *  The hostname may be either a domain name or an IP address. If the
-     *  hostname is an IP address, no network transactions will be performed.
+     *  Returns a DNS server address for a index. If returns error no more
+     *  DNS servers to read.
      *
-     *  If no stack-specific DNS resolution is provided, the hostname
-     *  will be resolve using a UDP socket on the stack.
-     *
-     *  @param host     Hostname to resolve
-     *  @param address  Destination for the host SocketAddress
-     *  @param version  IP version of address to resolve, NSAPI_UNSPEC indicates
-     *                  version is chosen by the stack (defaults to NSAPI_UNSPEC)
+     *  @param index    Index of the DNS server, starts from zero
+     *  @param address  Destination for the host address
      *  @return         0 on success, negative error code on failure
      */
-    virtual nsapi_error_t gethostbyname(const char *host,
-            SocketAddress *address, nsapi_version_t version = NSAPI_UNSPEC);
+    virtual nsapi_error_t get_dns_server(int index, SocketAddress *address);
 
-    /** Add a domain name server to list of servers to query
+    /** Get the local IP address
      *
-     *  @param address  Destination for the host address
-     *  @return         0 on success, negative error code on failure
+     *  @return         Null-terminated representation of the local IP address
+     *                  or null if not yet connected
      */
-    virtual nsapi_error_t add_dns_server(const SocketAddress &address);
+    virtual const char *get_ip_address();
 
 protected:
     LWIP();
@@ -423,6 +417,37 @@ class LWIP : public OnboardNetworkStack, private mbed::NonCopyable<LWIP> {
                                      int optname, void *optval, unsigned *optlen);
 private:
 
+    /** Call in callback
+      *
+      *  Callback is used to call the call in method of the network stack.
+      */
+    typedef mbed::Callback<nsapi_error_t (int delay_ms, mbed::Callback<void()> user_cb)> call_in_callback_cb_t;
+
+    /** Get a call in callback
+     *
+     *  Get a call in callback from the network stack context.
+     *
+     *  Callback should not take more than 10ms to execute, otherwise it might
+     *  prevent underlying thread processing. A portable user of the callback
+     *  should not make calls to network operations due to stack size limitations.
+     *  The callback should not perform expensive operations such as socket recv/send
+     *  calls or blocking operations.
+     *
+     *  @return         Call in callback
+     */
+    virtual call_in_callback_cb_t get_call_in_callback();
+
+    /** Call a callback after a delay
+     *
+     *  Call a callback from the network stack context after a delay. If function
+     *  returns error callback will not be called.
+     *
+     *  @param delay    Delay in milliseconds
+     *  @param func     Callback to be called
+     *  @return         0 on success, negative error code on failure
+     */
+    nsapi_error_t call_in(int delay, mbed::Callback<void()> func);
+
     struct mbed_lwip_socket {
         bool in_use;
 
@@ -439,6 +464,11 @@ class LWIP : public OnboardNetworkStack, private mbed::NonCopyable<LWIP> {
         uint32_t         multicast_memberships_registry;
     };
 
+    struct lwip_callback {
+        unsigned int delay;
+        mbed::Callback<void()> callback;
+    };
+
     static nsapi_error_t err_remap(err_t err);
     static bool is_local_addr(const ip_addr_t *ip_addr);
     static const ip_addr_t *get_ip_addr(bool any_addr, const struct netif *netif);
@@ -475,9 +505,14 @@ class LWIP : public OnboardNetworkStack, private mbed::NonCopyable<LWIP> {
     static void socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len);
 
     static void tcpip_init_irq(void *handle);
+    static void tcpip_thread_callback(void *ptr);
+
+    char ip_address[40];
     rtos::Semaphore tcpip_inited;
     Interface *default_interface;
     LWIPMemoryManager memory_manager;
+    osThreadId tcpip_thread_id;
+    rtos::Mutex adaptation;
 };
 
 #endif /* LWIPSTACK_H_ */