Corrected defects

- Changed call_in/call methods of the stack to callback provided by the stack
- Specified what are limitations for operations that are made in callback
- Added pure virtual class DNS that defines DNS operations
- Added cancel operation and unique ID to DNS request used in cancel
- Added DNS configuration options to netsocket/mbed_lib.json for retries,
  response wait time and cache size
- Changed host name to use dynamic memory in DNS query list and cache,
  set maximum length for the name to 255 bytes.
- Added mutex to asynchronous DNS
- Reworked retries: there is now total retry count and a server specific count
- Ignores invalid incoming UDP socket messages (DNS header is not valid), and retries DNS query
- Reworked DNS module asynchronous operation functions
- Corrected other review issues (nothrow new, missing free, missing mutex unlock etc.)

Author: Mika Leppänen

features/FEATURE_LWIP/lwip-interface/LWIPStack.cpp

@@ -207,11 +207,6 @@ void LWIP::tcpip_thread_callback(void *ptr)
     }
 }
 
-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;
@@ -229,6 +224,12 @@ nsapi_error_t LWIP::call_in(int delay, mbed::Callback<void()> func)
     return NSAPI_ERROR_OK;
 }
 
+LWIP::call_in_callback_cb_t LWIP::get_call_in_callback()
+{
+    call_in_callback_cb_t cb(this, &LWIP::call_in);
+    return cb;
+}
+
 const char *LWIP::get_ip_address()
 {
     if (!default_interface) {

features/FEATURE_LWIP/lwip-interface/LWIPStack.h

@@ -209,27 +209,6 @@ class LWIP : public OnboardNetworkStack, private mbed::NonCopyable<LWIP> {
      */
     virtual nsapi_error_t get_dns_server(int index, SocketAddress *address);
 
-    /** Call a callback
-     *
-     *  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 call(mbed::Callback<void()> func);
-
-    /** Call a callback after a delay
-     *
-     *  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 call_in(int delay, mbed::Callback<void()> func);
-
     /** Get the local IP address
      *
      *  @return         Null-terminated representation of the local IP address
@@ -438,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;
 

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

@@ -482,20 +482,14 @@ void sys_msleep(u32_t ms) {
 
 osThreadId_t lwip_tcpip_thread_id = 0;
 
-bool sys_tcpip_thread_set(void)
+void 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;
-    }
+    return osThreadGetId() == lwip_tcpip_thread_id;
 }
 
 // Keep a pool of thread structures

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

@@ -85,7 +85,7 @@ typedef sys_thread_data_t* sys_thread_t;
 // === PROTECTION ===
 typedef int sys_prot_t;
 
-bool sys_tcpip_thread_set(void);
+void sys_tcpip_thread_set(void);
 bool sys_tcpip_thread_check(void);
 
 #else

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

@@ -910,6 +910,8 @@ netconn_join_leave_group(struct netconn *conn,
 #endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */
 
 #if LWIP_DNS
+#if LWIP_FULL_DNS
+
 /**
  * @ingroup netconn_common
  * Execute a DNS query, only one IP address is returned
@@ -989,6 +991,8 @@ netconn_gethostbyname(const char *name, ip_addr_t *addr)
   API_VAR_FREE(MEMP_DNS_API_MSG, msg);
   return err;
 }
+
+#endif /* LWIP_FULL_DNS */
 #endif /* LWIP_DNS*/
 
 #if LWIP_NETCONN_SEM_PER_THREAD

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

@@ -1892,6 +1892,7 @@ lwip_netconn_do_join_leave_group(void *m)
 #endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */
 
 #if LWIP_DNS
+#if LWIP_FULL_DNS
 /**
  * Callback function that is called when DNS name is resolved
  * (or on timeout). A waiting application thread is waked up by
@@ -1943,5 +1944,6 @@ lwip_netconn_do_gethostbyname(void *arg)
   }
 }
 #endif /* LWIP_DNS */
+#endif /* LWIP_FULL_DNS */
 
 #endif /* LWIP_NETCONN */

features/nanostack/nanostack-interface/Nanostack.cpp

@@ -461,11 +461,6 @@ void Nanostack::call_event_tasklet_main(arm_event_s *event)
     }
 }
 
-nsapi_error_t Nanostack::call(mbed::Callback<void()> func)
-{
-    return call_in(0, func);
-}
-
 nsapi_error_t Nanostack::call_in(int delay, mbed::Callback<void()> func)
 {
     if (call_event_tasklet < 0) {
@@ -494,17 +489,25 @@ nsapi_error_t Nanostack::call_in(int delay, mbed::Callback<void()> func)
     if (delay) {
         uint32_t ticks = eventOS_event_timer_ms_to_ticks(delay);
         if (!eventOS_event_send_in(&event, ticks)) {
+            delete cb;
             return NSAPI_ERROR_NO_MEMORY;
         }
     } else {
         if (eventOS_event_send(&event) < 0) {
+            delete cb;
             return NSAPI_ERROR_NO_MEMORY;
         }
     }
 
     return NSAPI_ERROR_OK;
 }
 
+Nanostack::call_in_callback_cb_t Nanostack::get_call_in_callback()
+{
+    call_in_callback_cb_t cb(this, &Nanostack::call_in);
+    return cb;
+}
+
 const char * Nanostack::get_ip_address()
 {
     NanostackLockGuard lock;

features/nanostack/nanostack-interface/Nanostack.h

@@ -44,27 +44,6 @@ class Nanostack : public OnboardNetworkStack, private mbed::NonCopyable<Nanostac
     /* Local variant with stronger typing and manual address specification */
     nsapi_error_t add_ethernet_interface(EMAC &emac, bool default_if, Nanostack::EthernetInterface **interface_out, const uint8_t *mac_addr = NULL);
 
-    /** Call a callback
-     *
-     *  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 call(mbed::Callback<void()> func);
-
-    /** Call a callback after a delay
-     *
-     *  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 call_in(int delay, mbed::Callback<void()> func);
-
 protected:
 
     Nanostack();
@@ -266,6 +245,38 @@ class Nanostack : public OnboardNetworkStack, private mbed::NonCopyable<Nanostac
     virtual nsapi_error_t getsockopt(void *handle, int level, 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 nanostack_callback {
         mbed::Callback<void()> callback;
     };

features/netsocket/DNS.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2018 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DNS_H
+#define DNS_H
+
+class DNS {
+public:
+
+    /** Translates a hostname to an IP address with specific version
+     *
+     *  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.
+     *
+     *  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)
+     *  @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) = 0;
+
+    /** Hostname translation callback (asynchronous)
+     *
+     *  Callback will be called after DNS resolution completes or a failure occurs.
+     *
+     *  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.
+     *
+     *  @param status  0 on success, negative error code on failure
+     *  @param address On success, destination for the host SocketAddress
+     */
+    typedef mbed::Callback<void (nsapi_error_t result, SocketAddress *address)> hostbyname_cb_t;
+
+    /** Translates a hostname to an IP address (asynchronous)
+     *
+     *  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.
+     *
+     *  If no stack-specific DNS resolution is provided, the hostname
+     *  will be resolve using a UDP socket on the stack.
+     *
+     *  Call is non-blocking. Result of the DNS operation is returned by the callback.
+     *  If this function returns failure, callback will not be called. In case result
+     *  is success (IP address was found from DNS cache), callback will be called
+     *  before function returns.
+     *
+     *  @param host     Hostname to resolve
+     *  @param callback Callback that is called for result
+     *  @param version  IP version of address to resolve, NSAPI_UNSPEC indicates
+     *                  version is chosen by the stack (defaults to NSAPI_UNSPEC)
+     *  @return         0 on success, negative error code on failure or an unique id that
+     *                  represents the hostname translation operation and can be passed to
+     *                  cancel
+     */
+    virtual nsapi_error_t gethostbyname_async(const char *host, hostbyname_cb_t callback,
+            nsapi_version_t version = NSAPI_UNSPEC) = 0;
+
+    /** Cancels asynchronous hostname translation
+     *
+     *  When translation is cancelled, callback will not be called.
+     *
+     *  @param id       Unique id of the hostname translation operation
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual nsapi_error_t gethostbyname_async_cancel(nsapi_error_t id) = 0;
+
+    /** Add a domain name server to list of servers to query
+     *
+     *  @param address  Destination for the host address
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual nsapi_error_t add_dns_server(const SocketAddress &address) = 0;
+};
+
+#endif

features/netsocket/NetworkInterface.cpp

@@ -60,9 +60,14 @@ nsapi_error_t NetworkInterface::gethostbyname(const char *name, SocketAddress *a
     return get_stack()->gethostbyname(name, address, version);
 }
 
-nsapi_error_t NetworkInterface::gethostbyname_async(const char *host, hostbyname_cb_t callback, void *data, nsapi_version_t version)
+nsapi_error_t NetworkInterface::gethostbyname_async(const char *host, hostbyname_cb_t callback, nsapi_version_t version)
 {
-    return get_stack()->gethostbyname_async(host, callback, data, version);
+    return get_stack()->gethostbyname_async(host, callback, version);
+}
+
+nsapi_error_t NetworkInterface::gethostbyname_async_cancel(nsapi_error_t handle)
+{
+    return get_stack()->gethostbyname_async_cancel(handle);
 }
 
 nsapi_error_t NetworkInterface::add_dns_server(const SocketAddress &address)