Merge pull request #62 from ARMmbed/tcpsocket_keepalive

Tcpsocket keepalive

Author: Veijo Pesonen

ESP8266/ESP8266.cpp

@@ -15,7 +15,7 @@
  */
 
 #include "ESP8266.h"
-#include "mbed_trace.h"
+#include "mbed_debug.h"
 #include "nsapi_types.h"
 
 #include <cstring>
@@ -260,22 +260,56 @@ int ESP8266::scan(WiFiAccessPoint *res, unsigned limit)
     return cnt;
 }
 
-bool ESP8266::open(const char *type, int id, const char* addr, int port, int local_port)
+bool ESP8266::open_udp(int id, const char* addr, int port, int local_port)
 {
-    bool done;
+    static const char *type = "UDP";
+    bool done = false;
 
-    if (id >= SOCKET_COUNT) {
+    if (id >= SOCKET_COUNT || _socket_open[id]) {
         return false;
     }
+
     _smutex.lock();
     if(local_port) {
         done = _parser.send("AT+CIPSTART=%d,\"%s\",\"%s\",%d,%d", id, type, addr, port, local_port)
+                && _parser.recv("OK\n");
+    } else {
+        done = _parser.send("AT+CIPSTART=%d,\"%s\",\"%s\",%d", id, type, addr, port)
                && _parser.recv("OK\n");
+    }
+
+    if (done) {
+        _socket_open[id] = 1;
+    }
+
+    _smutex.unlock();
+
+    return done;
+}
+
+bool ESP8266::open_tcp(int id, const char* addr, int port, int keepalive)
+{
+    static const char *type = "UDP";
+    bool done = false;
+
+    if (id >= SOCKET_COUNT || _socket_open[id]) {
+        return false;
+    }
+
+    _smutex.lock();
+
+    if(keepalive) {
+        done = _parser.send("AT+CIPSTART=%d,\"%s\",\"%s\",%d,%d", id, type, addr, port, keepalive)
+                && _parser.recv("OK\n");
     } else {
         done = _parser.send("AT+CIPSTART=%d,\"%s\",\"%s\",%d", id, type, addr, port)
                && _parser.recv("OK\n");
     }
-    _socket_open[id] = 1;
+
+    if (done) {
+        _socket_open[id] = 1;
+    }
+
     _smutex.unlock();
 
     return done;
@@ -321,7 +355,7 @@ void ESP8266::_packet_handler()
     struct packet *packet = (struct packet*)malloc(
             sizeof(struct packet) + amount);
     if (!packet) {
-        tr_error("Could not allocate memory for RX data");
+        debug("Could not allocate memory for RX data");
         return;
     }
 

ESP8266/ESP8266.h

@@ -134,9 +134,24 @@ class ESP8266
     * @param id id to give the new socket, valid 0-4
     * @param port port to open connection with
     * @param addr the IP address of the destination
+    * @param port the port on the destination
+    * @param local_port UDP socket's local port, zero means any
     * @return true only if socket opened successfully
     */
-    bool open(const char *type, int id, const char* addr, int port, int local_port=0);
+    bool open_udp(int id, const char* addr, int port, int local_port = 0);
+
+    /**
+    * Open a socketed connection
+    *
+    * @param type the type of socket to open "UDP" or "TCP"
+    * @param id id to give the new socket, valid 0-4
+    * @param port port to open connection with
+    * @param addr the IP address of the destination
+    * @param port the port on the destination
+    * @param tcp_keepalive TCP connection's keep alive time, zero means disabled
+    * @return true only if socket opened successfully
+    */
+    bool open_tcp(int id, const char* addr, int port, int keepalive = 0);
 
     /**
     * Sends data to an open socket

ESP8266Interface.cpp

@@ -301,6 +301,7 @@ struct esp8266_socket {
     nsapi_protocol_t proto;
     bool connected;
     SocketAddress addr;
+    int keepalive; // TCP
 };
 
 int ESP8266Interface::socket_open(void **handle, nsapi_protocol_t proto)
@@ -328,6 +329,7 @@ int ESP8266Interface::socket_open(void **handle, nsapi_protocol_t proto)
     socket->id = id;
     socket->proto = proto;
     socket->connected = false;
+    socket->keepalive = 0;
     *handle = socket;
     return 0;
 }
@@ -380,11 +382,17 @@ int ESP8266Interface::socket_listen(void *handle, int backlog)
 int ESP8266Interface::socket_connect(void *handle, const SocketAddress &addr)
 {
     struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+
     _esp.setTimeout(ESP8266_MISC_TIMEOUT);
 
-    const char *proto = (socket->proto == NSAPI_UDP) ? "UDP" : "TCP";
-    if (!_esp.open(proto, socket->id, addr.get_ip_address(), addr.get_port(), _local_ports[socket->id])) {
-        return NSAPI_ERROR_DEVICE_ERROR;
+    if (socket->proto == NSAPI_UDP) {
+        if (!_esp.open_udp(socket->id, addr.get_ip_address(), addr.get_port(), _local_ports[socket->id])) {
+            return NSAPI_ERROR_DEVICE_ERROR;
+        }
+    } else {
+        if (!_esp.open_tcp(socket->id, addr.get_ip_address(), addr.get_port(), socket->keepalive)) {
+            return NSAPI_ERROR_DEVICE_ERROR;
+        }
     }
 
     socket->connected = true;
@@ -472,6 +480,61 @@ void ESP8266Interface::socket_attach(void *handle, void (*callback)(void *), voi
     _cbs[socket->id].data = data;
 }
 
+nsapi_error_t ESP8266Interface::setsockopt(nsapi_socket_t handle, int level,
+        int optname, const void *optval, unsigned optlen)
+{
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+
+    if (!optlen || !socket) {
+        return NSAPI_ERROR_PARAMETER;
+    }
+
+    if (level == NSAPI_SOCKET && socket->proto == NSAPI_TCP) {
+        switch (optname) {
+            case NSAPI_KEEPALIVE: {
+                if(socket->connected) {// ESP8266 limitation, keepalive needs to be given before connecting
+                    return NSAPI_ERROR_UNSUPPORTED;
+                }
+
+                if (optlen == sizeof(int)) {
+                    int secs = *(int *)optval;
+                    if (secs  >= 0 && secs <= 7200) {
+                        socket->keepalive = secs;
+                        return NSAPI_ERROR_OK;
+                    }
+                }
+                return NSAPI_ERROR_PARAMETER;
+            }
+        }
+    }
+
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+nsapi_error_t ESP8266Interface::getsockopt(nsapi_socket_t handle, int level, int optname, void *optval, unsigned *optlen)
+{
+    struct esp8266_socket *socket = (struct esp8266_socket *)handle;
+
+    if (!optval || !optlen || !socket) {
+        return NSAPI_ERROR_PARAMETER;
+    }
+
+    if (level == NSAPI_SOCKET && socket->proto == NSAPI_TCP) {
+        switch (optname) {
+            case NSAPI_KEEPALIVE: {
+                if(*optlen > sizeof(int)) {
+                    *optlen = sizeof(int);
+                }
+                memcpy(optval, &(socket->keepalive), *optlen);
+                return NSAPI_ERROR_OK;
+            }
+        }
+    }
+
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+
 void ESP8266Interface::event() {
     for (int i = 0; i < ESP8266_SOCKET_COUNT; i++) {
         if (_cbs[i].callback) {

ESP8266Interface.h

@@ -147,6 +147,40 @@ class ESP8266Interface : public NetworkStack, public WiFiInterface
      */
     using NetworkInterface::add_dns_server;
 
+    /*  Set socket options
+     *
+     *  The setsockopt allow an application to pass stack-specific hints
+     *  to the underlying stack. For unsupported options,
+     *  NSAPI_ERROR_UNSUPPORTED is returned and the socket is unmodified.
+     *
+     *  @param handle   Socket handle
+     *  @param level    Stack-specific protocol level
+     *  @param optname  Stack-specific option identifier
+     *  @param optval   Option value
+     *  @param optlen   Length of the option value
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual nsapi_error_t setsockopt(nsapi_socket_t handle, int level,
+            int optname, const void *optval, unsigned optlen);
+
+    /*  Get socket options
+     *
+     *  getsockopt allows an application to retrieve stack-specific options
+     *  from the underlying stack using stack-specific level and option names,
+     *  or to request generic options using levels from nsapi_socket_level_t.
+     *
+     *  For unsupported options, NSAPI_ERROR_UNSUPPORTED is returned
+     *  and the socket is unmodified.
+     *
+     *  @param level    Stack-specific protocol level or nsapi_socket_level_t
+     *  @param optname  Level-specific option name
+     *  @param optval   Destination for option value
+     *  @param optlen   Length of the option value
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual nsapi_error_t getsockopt(nsapi_socket_t handle, int level, int optname,
+            void *optval, unsigned *optlen);
+
 protected:
     /** Open a socket
      *  @param handle       Handle in which to store new socket