Let RxIRQ handle IPD messages. Detect it if the underlying socket changed in recv() call so we don't route back to a closed TCPSocket

Author: janjongboom

ESP8266/ESP8266.cpp

@@ -22,6 +22,10 @@ ESP8266::ESP8266(PinName tx, PinName rx, Callback<void(SignalingAction, int)> si
 {
     _serial.baud(115200);
     _parser.debugOn(debug);
+
+    _in_server_mode = false;
+    _ipd_packet = NULL;
+    _global_socket_counter = 0;
 }
 
 int ESP8266::get_firmware_version()
@@ -211,6 +215,8 @@ bool ESP8266::send(int id, const void *data, uint32_t amount)
 
 void ESP8266::_packet_handler()
 {
+    if (_in_server_mode) return;
+
     int id;
     uint32_t amount;
 
@@ -243,7 +249,10 @@ int32_t ESP8266::recv(int id, void *data, uint32_t amount)
 {
     bool exit_when_not_found = false;
 
-    bool is_incoming_socket = _incoming_socket_status[id];
+    // see if the underlying socket changed while in the recv() call
+    // if you don't do this check it might be that a CLOSED,CONNECT happens on the same esp8266 socket id
+    // and thus we associate the data with the wrong mbed TCPSocket
+    uint32_t incoming_socket_id = _incoming_socket_status[id];
 
     while (true) {
         // check if any packets are ready for us
@@ -281,15 +290,15 @@ int32_t ESP8266::recv(int id, void *data, uint32_t amount)
         // We know when it happens (due to monitoring the RX IRQ channel)
         // but there's no way of signaling this thread and actually abort the request...
 
-        if (is_incoming_socket) {
+        if (incoming_socket_id > 0) {
             int timeout = _parser.getTimeout();
             _parser.setTimeout(1000);
 
             if (!_parser.recv("OK")) {
                 _parser.setTimeout(timeout);
 
                 // socket gone
-                if (!_incoming_socket_status[id]) return NSAPI_ERROR_NO_SOCKET;
+                if (incoming_socket_id != _incoming_socket_status[id]) return NSAPI_ERROR_NO_SOCKET;
 
                 // otherwise, just continue trying to get data...
                 continue;
@@ -375,18 +384,36 @@ bool ESP8266::bind(const SocketAddress& address)
     // attach to the serial
     _serial.attach(callback(this, &ESP8266::attach_rx));
 
+    _in_server_mode = true;
+
     // and start the actual server
     return _parser.send("AT+CIPSERVER=1,%d", address.get_port())
         && _parser.recv("OK");
 }
 
 void ESP8266::process_command(char* cmd, size_t size) {
-    if (size == 9 /* 0,CONNECT */
+    if (_ipd_packet) {
+        memcpy(_ipd_packet_data_ptr, cmd, size);
+        _ipd_packet_data_ptr += size;
+
+        _ipd_packet_data_ptr[0] = '\r';
+        _ipd_packet_data_ptr[1] = '\n';
+        _ipd_packet_data_ptr += 2;
+
+        if (_ipd_packet_data_ptr == ((char*)(_ipd_packet + 1)) + _ipd_packet->len) {
+            // append to packet list
+            *_packets_end = _ipd_packet;
+            _packets_end = &_ipd_packet->next;
+
+            _ipd_packet = NULL;
+        }
+    }
+    else if (size == 9 /* 0,CONNECT */
         && (cmd[0] >= '0' && cmd[0] <= '9')
         && (cmd[1] == ',')
         && (strcmp(&cmd[2], "CONNECT") == 0)) {
 
-        _incoming_socket_status[cmd[0] - '0'] = true;
+        _incoming_socket_status[cmd[0] - '0'] = ++_global_socket_counter;
 
         _signalingCallback(ESP8266_SOCKET_CONNECT, cmd[0] - '0');
     }
@@ -395,10 +422,43 @@ void ESP8266::process_command(char* cmd, size_t size) {
         && (cmd[1] == ',')
         && (strcmp(&cmd[2], "CLOSED") == 0)) {
 
-        _incoming_socket_status[cmd[0] - '0'] = false;
+        _incoming_socket_status[cmd[0] - '0'] = 0;
 
         _signalingCallback(ESP8266_SOCKET_CLOSE, cmd[0] - '0');
     }
+    else if (cmd[0] == '+' && cmd[1] == 'I' && cmd[2] == 'P' && cmd[3] == 'D') {
+        int id = cmd[5] - '0';
+
+        // parse out the length param...
+        size_t length_ix = 6;
+        while (cmd[length_ix] != ':' && length_ix < size) length_ix++;
+        char* temp_length_buff = (char*)calloc(length_ix - 7 + 1, 1);
+        if (!temp_length_buff) return;
+        memcpy(temp_length_buff, cmd + 7, length_ix - 7);
+        int amount = atoi(temp_length_buff);
+
+        // alloc a new packet (and store it in a global var. we'll get the data for this packet straight after this msg)
+        _ipd_packet = (struct packet*)malloc(
+                sizeof(struct packet) + amount);
+        if (!_ipd_packet) {
+            return;
+        }
+
+        _ipd_packet->id = id;
+        _ipd_packet->len = amount;
+        _ipd_packet->next = 0;
+
+        _ipd_packet_data_ptr = (char*)(_ipd_packet + 1);
+
+        size_t data_len = size - length_ix - 1;
+        memcpy(_ipd_packet_data_ptr, cmd + length_ix + 1, data_len);
+        _ipd_packet_data_ptr += data_len;
+
+        // re-add the newline \r\n again...
+        _ipd_packet_data_ptr[0] = '\r';
+        _ipd_packet_data_ptr[1] = '\n';
+        _ipd_packet_data_ptr += 2;
+    }
     free(cmd);
 }
 

ESP8266/ESP8266.h

@@ -245,8 +245,11 @@ class ESP8266
     Thread* event_thread;
     char* rx_buffer;
     size_t rx_ix;
-    bool _incoming_socket_status[5];
-
+    uint32_t _incoming_socket_status[5];
+    uint32_t _global_socket_counter;
+    bool _in_server_mode;
+    struct packet *_ipd_packet;
+    char* _ipd_packet_data_ptr;
 };
 
 #endif

ESP8266Interface.cpp

@@ -243,8 +243,6 @@ int ESP8266Interface::socket_accept(void *server, void **socket, SocketAddress *
             //     _incoming_sockets[ix].socket, _incoming_sockets[ix].socket && _incoming_sockets[ix].socket->connected,
             //     _incoming_sockets[ix].accepted);
             if (_incoming_sockets[ix].socket && _incoming_sockets[ix].socket->connected && !_incoming_sockets[ix].accepted) {
-                printf("accepting socket %d\n", ix);
-
                 *socket = _incoming_sockets[ix].socket;
                 // addr is not used here I think...
                 _incoming_sockets[ix].accepted = true;
@@ -262,6 +260,10 @@ int ESP8266Interface::socket_send(void *handle, const void *data, unsigned size)
     struct esp8266_socket *socket = (struct esp8266_socket *)handle;
     _esp.setTimeout(ESP8266_SEND_TIMEOUT);
 
+    if (!socket->connected) {
+        return NSAPI_ERROR_NO_SOCKET;
+    }
+
     if (!_esp.send(socket->id, data, size)) {
         return NSAPI_ERROR_DEVICE_ERROR;
     }
@@ -336,7 +338,7 @@ void ESP8266Interface::event(int) {
 
 void ESP8266Interface::signal(SignalingAction action, int socket_id) {
     if (action == ESP8266_SOCKET_CONNECT) {
-        printf("ESP8266::SOCKET CONNECT %d\n", socket_id);
+        // printf("ESP8266::SOCKET CONNECT %d\n", socket_id);
         if (_ids[socket_id]) {
             // this should not be possible...
             // printf("ESP8266_SOCKET_CONNECT for socket that already exists...\n");
@@ -359,7 +361,7 @@ void ESP8266Interface::signal(SignalingAction action, int socket_id) {
         _incoming_sockets[socket_id].accepted = false;
     }
     else if (action == ESP8266_SOCKET_CLOSE) {
-        printf("ESP8266::SOCKET CLOSE %d\n", socket_id);
+        // printf("ESP8266::SOCKET CLOSE %d\n", socket_id);
 
         // Q: should we be able to delete the socket here? probably segfaults if held in user code
         struct esp8266_socket *socket = _incoming_sockets[socket_id].socket;
@@ -372,6 +374,6 @@ void ESP8266Interface::signal(SignalingAction action, int socket_id) {
         _ids[socket_id] = false;
         _incoming_sockets[socket_id].accepted = false;
         _incoming_sockets[socket_id].socket = NULL;
-        delete socket;
+        // delete socket;
     }
 }