Socket won't re-bind after socket connection accepted

Precursor - I’m a hardware engineer so my programming leaves a lot to be desired!

I’m having a very weird issue with MBED’s EthernetInterface and TCPSocket. I configure an EthernetInterface instance, link a TCPSocket as a server, bind to port 80 and configure to listen. I accept with a TCPSocket instance pointer and do my read/writes if accept is successful. If a network connection loss is detected ie connection status is no longer NSAPI_STATUS_GLOBAL_UP, both sockets are deleted and the process starts all over.

This works fine when I never actually connect to the socket. However, if I do connect to the socket, the socket is unable to bind when all of the TCPSockets instances are recreated.

Thanks in advance for any help.

#include “WebGui.h”
#include “Variables.h”
#include <stdio.h>
#include <string.h>
#include “slre.h”

EthernetInterface eth;
TCPSocket *client_sock;
TCPSocket *socket;
SocketAddress server_addr;
SocketAddress client_addr;
nsapi_version_t VersionType = NSAPI_IPv4;

int retval;
char sendBuffer[8500];
char receiveBuffer[5000];
char headerBuffer[100];
char XMLBuffer[2000];

#define disconnectCountout 5
int disconnectCounter = 0;

SocketAddress ip;
SocketAddress mask;
SocketAddress gateway;

void webMain()
{
printf(“Program Start\n”);

struct slre setTempRegex,minAlarmRegex, maxAlarmRegex;
struct cap captures[1 + 1];

if(!slre_compile(&setTempRegex, "setSetTemp=(\d*\.*\d*)&"))
{
    printf("Invalid SLRE Expression: %s\n",setTempRegex.err_str);
}
if(!slre_compile(&minAlarmRegex, "setMinTemp=(\d*\.*\d*)&"))
{
    printf("Invalid SLRE Expression: %s\n",minAlarmRegex.err_str);
}
if(!slre_compile(&maxAlarmRegex, "setMaxTemp=(\d*\.*\d*)&"))
{
    printf("Invalid SLRE Expression: %s\n",maxAlarmRegex.err_str);
}

while(true)
{
    //If web gui enabled
    if(dhcpStatic != 0)
    {
        eth.set_as_default();
        
        //If Static set
        if(dhcpStatic == 2)
        {  
            printf("Setting Static\n");
            eth.set_dhcp(false);
            
            char tempBuffer[15];
        
            sprintf(tempBuffer,"%d.%d.%d.%d",IPAddress[0],IPAddress[1],IPAddress[2],IPAddress[3]);
            ip = tempBuffer;
            sprintf(tempBuffer,"%d.%d.%d.%d",Subnet[0],Subnet[1],Subnet[2],Subnet[3]);
            mask = tempBuffer;
            sprintf(tempBuffer,"%d.%d.%d.%d",Gateway[0],Gateway[1],Gateway[2],Gateway[3]);
            gateway = tempBuffer;
            
            retval = eth.set_network(ip,mask,gateway); 
            changeNetworkStatus = false;
        }
        //If DHCP set
        else if(dhcpStatic == 1)
        {
            printf("Setting DHCP\n");
            
            retval = eth.set_dhcp(true);
            changeNetworkStatus = false;
        }

        if(NSAPI_ERROR_OK != retval)
        {
            printf("Cannot configure the network: %d\n",retval);
            
            changeNetworkStatus = true;
        }
        else
        {
            printf("Configuration Set: Returned %d\n",retval);
            
            retval = eth.connect();
            
            if (NSAPI_ERROR_OK != retval)
            {
                eth.disconnect();
                printf("Unable to create ethernet interface: %d\n",retval);
                if(dhcpStatic == 1)
                {
                    
                    networkStatus = 1;
                }
                else
                {
                    networkStatus = 2;
                }
            }
            else
            {
                networkStatus = 0;
                if(dhcpStatic == 1)
                {
                    eth.get_ip_address(&ip);
                    eth.get_netmask(&mask);
                    eth.get_gateway(&gateway);
                    memcpy(dhcpIPAddress,ip.get_ip_bytes(),4);
                    memcpy(dhcpSubnet,mask.get_ip_bytes(),4);
                    memcpy(dhcpGateway,gateway.get_ip_bytes(),4);
                }
                
                printf("Ethernet Connected: Returned %d\n",retval);
                
                socket = new TCPSocket;
                socket->set_timeout(1000);
                

                /* Open the server on ethernet stack */
                retval = socket->open(&eth);
                
                if (NSAPI_ERROR_OK != retval)
                {
                    printf("Unable to open socket: Returned %d\n",retval);
                }
                else
                {
                    printf("Socket Opened\n");
                }
                       
                /* Bind the HTTP port (TCP 80) to the server */
                retval = socket->bind(80);
                if (NSAPI_ERROR_OK != retval)
                {
                    printf("Unable to bind: Returned %d\n",retval);
                }
                else
                {
                    printf("Socket Bound\n");
                }

                /* Can handle x simultaneous connections */
                retval = socket->listen(1);
                if (NSAPI_ERROR_OK != retval)
                {
                    printf("Unable to listen: Returned %d\n",retval);
                }
                else
                {
                    printf("Socket Listening\n\n");
                }
                
                client_sock = new TCPSocket;
                
                while(true)
                {
                    printf("Network Status %d\n",eth.get_connection_status());
                    if(eth.get_connection_status() != NSAPI_STATUS_GLOBAL_UP)
                    {
                        disconnectCounter++;
                    }
                
                    if(disconnectCounter >= disconnectCountout)
                    {
                        disconnectCounter = 0;
                        socket->close();
                        delete socket;
                        eth.disconnect();
                        delete client_sock;
                        
                        if(dhcpStatic == 1)
                        {
                            dhcpIPAddress[0] = 0;
                            dhcpIPAddress[1] = 0;
                            dhcpIPAddress[2] = 0;
                            dhcpIPAddress[3] = 0;
                            dhcpSubnet[0] = 0;
                            dhcpSubnet[1] = 0;
                            dhcpSubnet[2] = 0;
                            dhcpSubnet[3] = 0;
                            dhcpGateway[0] = 0;
                            dhcpGateway[1] = 0;
                            dhcpGateway[2] = 0;
                            dhcpGateway[3] = 0;
                            networkStatus = 1;
                            break;
                        }
                        else
                        {
                            networkStatus = 2;
                            break;
                        }
                    }
                    
                    client_sock = socket->accept(&retval);
                    
                    if (NSAPI_ERROR_OK != retval)
                    {
                        printf("Unable to accept: Returned %d\n",retval);
                    }
                    else
                    {                    
                        //Read HTTP Request
                        client_sock->recv(receiveBuffer, 5000);
                                           
                        if (strstr(receiveBuffer,"ajax_switch"))
                        {
                            memset(sendBuffer,'\0',5000);
                            if (strstr(receiveBuffer,"resetTemps=1") != NULL)
                            {
                                resetRecordTemps = true;
                                printf("Received Record Reset\n");
                            }
                            if(slre_match(&setTempRegex, receiveBuffer, 5000, captures))
                            {
                                char intermediateBuffer[captures[1].len + 1];
                                for (int i = 0; i < captures[1].len; i++)
                                {
                                    intermediateBuffer[i] = *(captures[1].ptr + i);
                                }
                                intermediateBuffer[captures[1].len] = '\0';
                                setTemp = atof(intermediateBuffer);
                                Eeprom_Write_Float(addr,ee_setTemp,setTemp);
                            }
                            if(slre_match(&minAlarmRegex, receiveBuffer, 5000, captures))
                            {
                                char intermediateBuffer[captures[1].len + 1];
                                for (int i = 0; i < captures[1].len; i++)
                                {
                                    intermediateBuffer[i] = *(captures[1].ptr + i);
                                }
                                intermediateBuffer[captures[1].len] = '\0';
                                minAlarmTemp = atof(intermediateBuffer);
                            }
                            if(slre_match(&maxAlarmRegex, receiveBuffer, 5000, captures))
                            {
                                char intermediateBuffer[captures[1].len + 1];
                                for (int i = 0; i < captures[1].len; i++)
                                {
                                    intermediateBuffer[i] = *(captures[1].ptr + i);
                                }
                                intermediateBuffer[captures[1].len] = '\0';
                                maxAlarmTemp = atof(intermediateBuffer);
                            }
                            
                            strcpy(sendBuffer, createXMLHeader());
                            strcat(sendBuffer, createXML());
                            client_sock->send(sendBuffer, strlen(sendBuffer));
                        }
                        else
                        {
                            strcpy(sendBuffer, createStandardHeader());
                            strcat(sendBuffer, htmlString);
                            client_sock->send(sendBuffer, strlen(sendBuffer));
                            memset(sendBuffer,'\0',5000);
                        }
                        memset(receiveBuffer,'\0',5000);
                        client_sock->close();
                    }
                }
            }
        }
    }
}

}