_port(port),

_maxConnections(maxConnections),

_bindAddress(bindAddress) {

// Create space for the connections

_connections = new HTTPConnection*[maxConnections];

for(uint8_t i = 0; i < maxConnections; i++) _connections[i] = NULL;

// Configure runtime data

_socket = -1;

_running = false;

if (!_running) {

if (setupSocket()) {

_running = true;

return 1;

}

return 0;

} else {

return 1;

}

if (_running) {

// Set the flag that the server is stopped

_running = false;

// Clean up the connections

bool hasOpenConnections = true;

while(hasOpenConnections) {

hasOpenConnections = false;

for(int i = 0; i < _maxConnections; i++) {

if (_connections[i] != NULL) {

_connections[i]->closeConnection();

// Check if closing succeeded. If not, we need to call the close function multiple times

// and wait for the client

if (_connections[i]->isClosed()) {

delete _connections[i];

_connections[i] = NULL;

} else {

hasOpenConnections = true;

}

}

}

delay(1);

}

teardownSocket();

}

// Only handle requests if the server is still running

if(!_running) return;

// Step 1: Process existing connections

// Process open connections and store the index of a free connection

// (we might use that later on)

int freeConnectionIdx = -1;

for (int i = 0; i < _maxConnections; i++) {

// Fetch a free index in the pointer array

if (_connections[i] == NULL) {

freeConnectionIdx = i;

} else {

// if there is a connection (_connections[i]!=NULL), check if its open or closed:

if (_connections[i]->isClosed()) {

// if it's closed, clean up:

delete _connections[i];

_connections[i] = NULL;

freeConnectionIdx = i;

} else {

// if not, process it:

_connections[i]->loop();

}

}

}

// Step 2: Check for new connections

// This makes only sense if there is space to store the connection

if (freeConnectionIdx > -1) {

// We create a file descriptor set to be able to use the select function

fd_set sockfds;

// Out socket is the only socket in this set

FD_ZERO(&sockfds);

FD_SET(_socket, &sockfds);

// We define a "immediate" timeout

timeval timeout;

timeout.tv_sec = 0;

timeout.tv_usec = 0; // Return immediately, if possible

// Wait for input

// As by 2017-12-14, it seems that FD_SETSIZE is defined as 0x40, but socket IDs now

// start at 0x1000, so we need to use _socket+1 here

select(_socket + 1, &sockfds, NULL, NULL, &timeout);

// There is input

if (FD_ISSET(_socket, &sockfds)) {

int socketIdentifier = createConnection(freeConnectionIdx);

// If initializing did not work, discard the new socket immediately

if (socketIdentifier < 0) {

delete _connections[freeConnectionIdx];

_connections[freeConnectionIdx] = NULL;

}

}

}

HTTPConnection * newConnection = new HTTPConnection(this);

_connections[idx] = newConnection;

return newConnection->initialize(_socket, &_defaultHeaders);

// (AF_INET = IPv4, SOCK_STREAM = TCP)

_socket = socket(AF_INET, SOCK_STREAM, 0);

if (_socket>=0) {

_sock_addr.sin_family = AF_INET;

// Listen on all interfaces

_sock_addr.sin_addr.s_addr = _bindAddress;

// Set the server port

_sock_addr.sin_port = htons(_port);

// Now bind the TCP socket we did create above to the socket address we specified

// (The TCP-socket now listens on 0.0.0.0:port)

int err = bind(_socket, (struct sockaddr* )&_sock_addr, sizeof(_sock_addr));

if(!err) {

err = listen(_socket, _maxConnections);

if (!err) {

return 1;

} else {

close(_socket);

_socket = -1;

return 0;

}

} else {

close(_socket);

_socket = -1;

return 0;

}

} else {

_socket = -1;

return 0;

}

// Close the actual server sockets

close(_socket);

_socket = -1;