Added non-blocking DNS functionality to network interface

- Added non-blocking DNS interface to network interface and
  network stack.
- Added caching of DNS replies.
- Added a network stack function to get DNS addresses from stack.
- Added call and call_in hooks to onboard network stack to
  allow calling functions from onboard stack context.
- Added support to call and call_in functions to LWIP and
  Nanostack.
- Disabled LWIP DNS translator with the exception of DNS
  address storage used in DNS address get.

Author: Mika Leppänen

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,84 @@ 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;
-    }
-    err_t err = netconn_gethostbyname(host, &lwip_addr);
-#elif LWIP_IPV6
-    if (version != NSAPI_IPv6 && 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);
-#endif
+}
 
-    if (err != ERR_OK) {
-        return NSAPI_ERROR_DNS_FAILURE;
+nsapi_error_t LWIP::call(mbed::Callback<void()> func)
+{
+    return call_in(0, func);
+}
+
+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;
     }
 
-    nsapi_addr_t addr;
-    convert_lwip_addr_to_mbed(&addr, &lwip_addr);
-    address->set_addr(addr);
+    cb->delay = delay;
+    cb->callback = func;
 
-    return 0;
+    if (tcpip_callback_with_block(LWIP::tcpip_thread_callback, cb, 1) != ERR_OK) {
+        return NSAPI_ERROR_NO_MEMORY;
+    }
+
+    return NSAPI_ERROR_OK;
 }
 
-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 +445,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 +595,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 +608,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 +623,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 +636,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,44 @@ 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 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 get_dns_server(int index, SocketAddress *address);
+
+    /** Call a callback
      *
-     *  @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)
+     *  Call a callback from the network stack context. If returns error
+     *  callback will not be called.
+     *
+     *  @param func     Callback to be called
      *  @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 call(mbed::Callback<void()> func);
 
-    /** Add a domain name server to list of servers to query
+    /** Call a callback after a delay
      *
-     *  @param address  Destination for the host address
+     *  Call a callback from the network stack context after a delay. If
+     *  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
      */
-    virtual nsapi_error_t add_dns_server(const SocketAddress &address);
+    virtual nsapi_error_t call_in(int delay, mbed::Callback<void()> func);
+
+    /** Get the local IP address
+     *
+     *  @return         Null-terminated representation of the local IP address
+     *                  or null if not yet connected
+     */
+    virtual const char *get_ip_address();
 
 protected:
     LWIP();
@@ -439,6 +454,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 +495,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_ */

features/FEATURE_LWIP/lwip-interface/lwip-sys/arch/lwip_sys_arch.c

@@ -480,6 +480,24 @@ void sys_msleep(u32_t ms) {
     osDelay(ms);
 }
 
+osThreadId_t lwip_tcpip_thread_id = 0;
+
+bool sys_tcpip_thread_set(void)
+{
+    lwip_tcpip_thread_id = osThreadGetId();
+}
+
+bool sys_tcpip_thread_check(void)
+{
+    osThreadId_t thread_id = osThreadGetId();
+
+    if (thread_id == lwip_tcpip_thread_id) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
 // Keep a pool of thread structures
 static int thread_pool_index = 0;
 static sys_thread_data_t thread_pool[SYS_THREAD_POOL_N];

features/FEATURE_LWIP/lwip-interface/lwip-sys/arch/sys_arch.h

@@ -85,6 +85,9 @@ typedef sys_thread_data_t* sys_thread_t;
 // === PROTECTION ===
 typedef int sys_prot_t;
 
+bool sys_tcpip_thread_set(void);
+bool sys_tcpip_thread_check(void);
+
 #else
 #ifdef  __cplusplus
 extern "C" {

features/FEATURE_LWIP/lwip-interface/lwip/src/api/lwip_api_lib.c

@@ -102,11 +102,18 @@ netconn_apimsg(tcpip_callback_fn fn, struct api_msg *apimsg)
   apimsg->op_completed_sem = LWIP_NETCONN_THREAD_SEM_GET();
 #endif /* LWIP_NETCONN_SEM_PER_THREAD */
 
-  err = tcpip_send_msg_wait_sem(fn, apimsg, LWIP_API_MSG_SEM(apimsg));
-  if (err == ERR_OK) {
-    return apimsg->err;
+  if (sys_tcpip_thread_check()) {
+      fn(apimsg);
+      return ERR_OK;
+  } else {
+      err = tcpip_send_msg_wait_sem(fn, apimsg, LWIP_API_MSG_SEM(apimsg));
+
+      if (err == ERR_OK) {
+        return apimsg->err;
+      }
+
+      return err;
   }
-  return err;
 }
 
 /**