Change new API to use Socket API: getsockopt

Use getsockopt to read latency value as it provides better solution
than a separate API.

Author: Arto Kinnunen

features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h

@@ -140,19 +140,6 @@ class InterfaceNanostack : public virtual NetworkInterface {
      */
     nsapi_error_t set_file_system_root_path(const char *root_path);
 
-    /** @copydoc NetworkInterface::get_interface_timing_property */
-    virtual nsapi_error_t get_interface_timing_property(unsigned int data_amount,
-                                                        unsigned int *initial_delay_min,
-                                                        unsigned int *initial_delay_max,
-                                                        unsigned int *initial_delay_rand,
-                                                        unsigned int *expected_rtt);
-
-    /** @copydoc NetworkInterface::get_interface_initial_delay */
-    virtual nsapi_error_t get_interface_initial_delay(unsigned int data_amount, unsigned int *initial_delay);
-
-    /** @copydoc NetworkInterface::get_interface_rtt */
-    virtual nsapi_error_t get_interface_rtt(unsigned int *expected_rtt);
-
     /** Get the interface ID
      *  @return  Interface identifier
      */

features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp

@@ -223,61 +223,6 @@ nsapi_error_t InterfaceNanostack::set_file_system_root_path(const char *root_pat
     return MESH_ERROR_UNKNOWN;
 }
 
-nsapi_error_t InterfaceNanostack::get_interface_timing_property(unsigned int data_amount,
-                                                                unsigned int *initial_delay_min,
-                                                                unsigned int *initial_delay_max,
-                                                                unsigned int *initial_delay_rand,
-                                                                unsigned int *expected_rtt)
-{
-    net_timing_constraint_t net_timing_constraint;
-
-    if (!initial_delay_min || !initial_delay_max || !initial_delay_rand || !expected_rtt) {
-        return NSAPI_ERROR_PARAMETER;
-    }
-
-    if (arm_nwk_interface_timing_constraint_get(get_interface_id(), data_amount, &net_timing_constraint) == 0) {
-        *initial_delay_min = net_timing_constraint.jitter_min;
-        *initial_delay_max = net_timing_constraint.jitter_max;
-        *initial_delay_rand = net_timing_constraint.jitter_rand;
-        *expected_rtt = net_timing_constraint.network_latency * 2; // RTT = 2 * latency + some processing time
-        return NSAPI_ERROR_OK;
-    }
-
-    return NSAPI_ERROR_NO_CONNECTION;
-}
-
-nsapi_error_t InterfaceNanostack::get_interface_initial_delay(unsigned int data_amount, unsigned int *initial_delay)
-{
-    net_timing_constraint_t net_timing_constraint;
-
-    if (!initial_delay) {
-        return NSAPI_ERROR_PARAMETER;
-    }
-
-    if (arm_nwk_interface_timing_constraint_get(get_interface_id(), 0, &net_timing_constraint) == 0) {
-        *initial_delay = net_timing_constraint.jitter_rand;
-        return NSAPI_ERROR_OK;
-    }
-
-    return NSAPI_ERROR_NO_CONNECTION;
-}
-
-nsapi_error_t InterfaceNanostack::get_interface_rtt(unsigned int *expected_rtt)
-{
-    net_timing_constraint_t net_timing_constraint;
-
-    if (!expected_rtt) {
-        return NSAPI_ERROR_PARAMETER;
-    }
-
-    if (arm_nwk_interface_timing_constraint_get(get_interface_id(), 0, &net_timing_constraint) == 0) {
-        *expected_rtt = net_timing_constraint.network_latency * 2; // RTT = 2 * latency + some processing time
-        return NSAPI_ERROR_OK;
-    }
-
-    return NSAPI_ERROR_NO_CONNECTION;
-}
-
 #if !DEVICE_802_15_4_PHY
 MBED_WEAK MeshInterface *MeshInterface::get_target_default_instance()
 {

features/nanostack/nanostack-interface/Nanostack.cpp

@@ -838,13 +838,25 @@ nsapi_error_t Nanostack::setsockopt(void *handle, int level, int optname, const
 nsapi_error_t Nanostack::getsockopt(void *handle, int level, int optname, void *optval, unsigned *optlen)
 {
     NanostackSocket *socket = static_cast<NanostackSocket *>(handle);
+
     if (handle == NULL) {
         MBED_ASSERT(false);
         return NSAPI_ERROR_NO_SOCKET;
     }
 
     NanostackLockGuard lock;
 
+    if (level == NSAPI_SOCKET) {
+        if (optname == NSAPI_LATENCY) {
+            if (*optlen < 16) {
+                return NSAPI_ERROR_PARAMETER;
+            }
+            // Adjust to Nanostack namespace
+            level = SOCKET_IPPROTO_IPV6;
+            optname = SOCKET_LATENCY;
+        }
+    }
+
     uint16_t optlen16 = *optlen;
 
     int retcode = ::socket_getsockopt(socket->socket_id, level, optname, optval, &optlen16);

features/netsocket/InternetSocket.cpp

@@ -114,6 +114,29 @@ int InternetSocket::leave_multicast_group(const SocketAddress &address)
     return modify_multicast_group(address, NSAPI_DROP_MEMBERSHIP);
 }
 
+int InternetSocket::get_latency_estimate_to_address(const SocketAddress &address, uint32_t *latency)
+{
+    nsapi_error_t ret;
+    void *option[4];
+    unsigned opt_len = 16;  // room for IPv6 address
+
+    // Set up address
+    memcpy(option, address.get_ip_bytes(), 16);
+
+    ret = this->getsockopt(NSAPI_SOCKET, NSAPI_LATENCY, (void *)option, &opt_len);
+    if (ret == NSAPI_ERROR_OK) {
+        if (option[0] == 0) {
+            // address was not valid as 0 was returned
+            ret = NSAPI_ERROR_NO_ADDRESS;
+        } else {
+            // success, latency found
+            *latency = (uint32_t)option[0];
+        }
+    }
+
+    return ret;
+}
+
 
 nsapi_error_t InternetSocket::bind(uint16_t port)
 {

features/netsocket/InternetSocket.h

@@ -86,6 +86,14 @@ class InternetSocket : public Socket {
      */
     int leave_multicast_group(const SocketAddress &address);
 
+    /** Get estimated latency to reach destination address.
+     *
+     * @param address   Destination address where latency will be estimated.
+     * @param latency   Address to latency value in milliseconds.
+     *  @return         NSAPI_ERROR_OK on success, negative error code on failure (@see InternetSocket::getsockopt).
+     */
+    int get_latency_estimate_to_address(const SocketAddress &address, uint32_t *latency);
+
     /** Bind the socket to a port on which to receive data.
      *
      *  @param port     Local port to bind.

features/netsocket/NetworkInterface.cpp

@@ -174,22 +174,3 @@ nsapi_error_t NetworkInterface::set_blocking(bool blocking)
     return NSAPI_ERROR_UNSUPPORTED;
 }
 
-nsapi_error_t NetworkInterface::get_interface_timing_property(unsigned int data_amount,
-                                                              unsigned int *initial_delay_min,
-                                                              unsigned int *initial_delay_max,
-                                                              unsigned int *initial_delay_rand,
-                                                              unsigned int *expected_rtt)
-{
-    return NSAPI_ERROR_UNSUPPORTED;
-}
-
-nsapi_error_t NetworkInterface::get_interface_initial_delay(unsigned int data_amount,
-                                                            unsigned int *initial_delay)
-{
-    return NSAPI_ERROR_UNSUPPORTED;
-}
-
-nsapi_error_t NetworkInterface::get_interface_rtt(unsigned int *expected_rtt)
-{
-    return NSAPI_ERROR_UNSUPPORTED;
-}

features/netsocket/NetworkInterface.h

@@ -378,65 +378,6 @@ class NetworkInterface: public DNS {
      */
     virtual nsapi_error_t set_blocking(bool blocking);
 
-    /** Get network interface timing properties.
-     *
-     * Network interfaces have different characteristics. Some wireless networks are
-     * established slowly and may have a high latency while some wired networks are
-     * ready almost instantly after power on.
-     *
-     * Application can use network timing properties to adapt to the varying network
-     * interfaces. Properties include:
-     * * initial delay, a estimated wait time that application should wait after startup before sending data to the network.
-     * * round-trip time, a estimated time between sending a signal and receiving the response.
-     *
-     * @param data_amount Amount of data to be sent in kilobytes.
-     * @param initial_delay_min Address to minimum delay value (ms), must be non-null.
-     * @param initial_delay_max Address to maximum delay value (ms), must be non-null.
-     * @param initial_delay_rand Address to randomized delay value (ms), must be non-null.
-     * @param expected_rtt Address to expected round-trip time value (ms), must be non-null.
-     * @return NSAPI_ERROR_OK on success.
-     * @return NSAPI_ERROR_UNSUPPORTED if API is not implemented to interface.
-     * @return NSAPI_ERROR_NO_CONNECTION if network is not connected.
-     * @return NSAPI_ERROR_PARAMETER. if input parameters are not valid.
-     */
-    virtual nsapi_error_t get_interface_timing_property(unsigned int data_amount,
-                                                        unsigned int *initial_delay_min,
-                                                        unsigned int *initial_delay_max,
-                                                        unsigned int *initial_delay_rand,
-                                                        unsigned int *expected_rtt);
-
-    /** Get initial delay for the network interface
-     *
-     * Initial delay can be used to optimize network performance. Some wireless networks
-     * use a lot of network bandwidth to find and extend the network during startup.
-     * Having an application sending data aggressively during the startup can result to
-     * network congestion that will drop network performance even more.
-     * Initial delay is a randomized value based on the selected interface properties.
-     *
-     * @param data_amount Amount of data in kilobytes that application is going to send.
-     * @param initial_delay Address to location where initial_delay is written in milliseconds.
-     * @return NSAPI_ERROR_OK on success.
-     * @return NSAPI_ERROR_UNSUPPORTED if API is not implemented to interface.
-     * @return NSAPI_ERROR_NO_CONNECTION if network is not connected.
-     * @return NSAPI_ERROR_PARAMETER. if input parameters are not valid.
-     */
-    virtual nsapi_error_t get_interface_initial_delay(unsigned int data_amount,
-                                                      unsigned int *initial_delay);
-
-    /** Get network interface expected round-trip time (RTT)
-     *
-     * Application can use expected RTT to adjust possible retry intervals.
-     * Wired networks may have RTT value less than a seconds while some wireless
-     * networks could have a RTT up to several minutes.
-     *
-     * @param expected_rtt Address to location where expected RTT is written (ms).
-     * @return NSAPI_ERROR_OK on success.
-     * @return NSAPI_ERROR_UNSUPPORTED if API is not implemented to interface.
-     * @return NSAPI_ERROR_NO_CONNECTION if network is not connected.
-     * @return NSAPI_ERROR_PARAMETER. if input parameters are not valid.
-     */
-    virtual nsapi_error_t get_interface_rtt(unsigned int *expected_rtt);
-
     /** Return pointer to an EthInterface.
      * @return Pointer to requested interface type or NULL if this class doesn't implement the interface.
      */

features/netsocket/nsapi_types.h

@@ -267,7 +267,8 @@ typedef enum nsapi_socket_option {
     NSAPI_RCVBUF,            /*!< Sets recv buffer size */
     NSAPI_ADD_MEMBERSHIP,    /*!< Add membership to multicast address */
     NSAPI_DROP_MEMBERSHIP,   /*!< Drop membership to multicast address */
-    NSAPI_BIND_TO_DEVICE,        /*!< Bind socket network interface name*/
+    NSAPI_BIND_TO_DEVICE,    /*!< Bind socket network interface name*/
+    NSAPI_LATENCY,           /*!< Read latency and initial delay */
 } nsapi_socket_option_t;
 
 typedef enum nsapi_tlssocket_level {