JsVar *clientRequestNew(SocketType socketType, JsVar *options, JsVar *callback) {
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_CLIENT_CONNECTIONS,true);
if (!arr) return 0;
JsVar *req, *res = 0;
if ((socketType&ST_TYPE_MASK)==ST_HTTP) {
res = jspNewObject(0, "httpCRs");
if (!res) {
jsvUnLock(arr); // out of memory?
return 0;
}
req = jspNewObject(0, "httpCRq");
} else {
req = jspNewObject(0, "Socket");
}
if (req) { // out of memory?
socketSetType(req, socketType);
if (callback != NULL)
jsvUnLock(jsvAddNamedChild(req, callback, HTTP_NAME_ON_CONNECT));
jsvArrayPush(arr, req);
if (res)
jsvObjectSetChild(req, HTTP_NAME_RESPONSE_VAR, res);
jsvObjectSetChild(req, HTTP_NAME_OPTIONS_VAR, options);
}
jsvUnLock2(res, arr);
return req;
}
void serverClose(JsNetwork *net, JsVar *server) {
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVERS,false);
if (arr) {
// close socket
_socketConnectionKill(net, server);
// remove from array
JsVar *idx = jsvGetArrayIndexOf(arr, server, true);
if (idx) {
jsvRemoveChild(arr, idx);
jsvUnLock(idx);
} else
jsWarn("Server not found!");
jsvUnLock(arr);
}
}
NO_INLINE static void _socketCloseAllConnectionsFor(JsNetwork *net, char *name) {
JsVar *arr = socketGetArray(name, false);
if (!arr) return;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
JsVar *connection = jsvObjectIteratorGetValue(&it);
_socketConnectionKill(net, connection);
jsvUnLock(connection);
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
jsvRemoveAllChildren(arr);
jsvUnLock(arr);
}
void serverListen(JsNetwork *net, JsVar *server, int port) {
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVERS, true);
if (!arr) return; // out of memory
jsvObjectSetChildAndUnLock(server, HTTP_NAME_PORT, jsvNewFromInteger(port));
int sckt = netCreateSocket(net, 0/*server*/, (unsigned short)port, NCF_NORMAL, 0 /*options*/);
if (sckt<0) {
jsError("Unable to create socket\n");
jsvObjectSetChildAndUnLock(server, HTTP_NAME_CLOSENOW, jsvNewFromBool(true));
} else {
jsvObjectSetChildAndUnLock(server, HTTP_NAME_SOCKET, jsvNewFromInteger(sckt+1));
// add to list of servers
jsvArrayPush(arr, server);
}
jsvUnLock(arr);
}
bool socketIdle(JsNetwork *net) {
if (networkState != NETWORKSTATE_ONLINE) {
// clear all clients and servers
_socketCloseAllConnections(net);
return false;
}
bool hadSockets = false;
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVERS,false);
if (arr) {
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
hadSockets = true;
JsVar *server = jsvObjectIteratorGetValue(&it);
int sckt = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(server,HTTP_NAME_SOCKET,0))-1; // so -1 if undefined
int theClient = netAccept(net, sckt);
if (theClient >= 0) {
SocketType socketType = socketGetType(server);
if ((socketType&ST_TYPE_MASK) == ST_HTTP) {
JsVar *req = jspNewObject(0, "httpSRq");
JsVar *res = jspNewObject(0, "httpSRs");
if (res && req) { // out of memory?
socketSetType(req, ST_HTTP);
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVER_CONNECTIONS, true);
if (arr) {
jsvArrayPush(arr, req);
jsvUnLock(arr);
}
jsvObjectSetChild(req, HTTP_NAME_RESPONSE_VAR, res);
jsvObjectSetChild(req, HTTP_NAME_SERVER_VAR, server);
jsvObjectSetChildAndUnLock(req, HTTP_NAME_SOCKET, jsvNewFromInteger(theClient+1));
}
jsvUnLock2(req, res);
} else {
// Normal sockets
JsVar *sock = jspNewObject(0, "Socket");
if (sock) { // out of memory?
socketSetType(sock, ST_NORMAL);
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_CLIENT_CONNECTIONS, true);
if (arr) {
jsvArrayPush(arr, sock);
jsvUnLock(arr);
}
jsvObjectSetChildAndUnLock(sock, HTTP_NAME_SOCKET, jsvNewFromInteger(theClient+1));
jsiQueueObjectCallbacks(server, HTTP_NAME_ON_CONNECT, &sock, 1);
jsvUnLock(sock);
}
}
}
jsvUnLock(server);
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
jsvUnLock(arr);
}
if (socketServerConnectionsIdle(net)) hadSockets = true;
if (socketClientConnectionsIdle(net)) hadSockets = true;
netCheckError(net);
return hadSockets;
}
bool socketClientConnectionsIdle(JsNetwork *net) {
char *buf = alloca(net->chunkSize); // allocate on stack
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_CLIENT_CONNECTIONS,false);
if (!arr) return false;
bool hadSockets = false;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
hadSockets = true;
// Get connection, socket, and socket type
// For normal sockets, socket==connection, but for HTTP connection is httpCRq and socket is httpCRs
JsVar *connection = jsvObjectIteratorGetValue(&it);
SocketType socketType = socketGetType(connection);
JsVar *socket = ((socketType&ST_TYPE_MASK)==ST_HTTP) ? jsvObjectGetChild(connection,HTTP_NAME_RESPONSE_VAR,0) : jsvLockAgain(connection);
bool socketClosed = false;
JsVar *receiveData = 0;
bool hadHeaders = false;
int error = 0; // error code received from netXxxx functions
bool isHttp = (socketType&ST_TYPE_MASK) == ST_HTTP;
bool closeConnectionNow = jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CLOSENOW, false));
bool alreadyConnected = jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CONNECTED, false));
int sckt = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_SOCKET,0))-1; // so -1 if undefined
if (sckt>=0) {
if (isHttp)
hadHeaders = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_HAD_HEADERS,0));
else
hadHeaders = true;
receiveData = jsvObjectGetChild(connection,HTTP_NAME_RECEIVE_DATA,0);
/* We do this up here because we want to wait until we have been once
* around the idle loop (=callbacks have been executed) before we run this */
if (hadHeaders)
socketClientPushReceiveData(connection, socket, &receiveData);
JsVar *sendData = jsvObjectGetChild(connection,HTTP_NAME_SEND_DATA,0);
if (!closeConnectionNow) {
// send data if possible
if (sendData && !jsvIsEmptyString(sendData)) {
// don't try to send if we're already in error state
int num = 0;
if (error == 0) num = socketSendData(net, connection, sckt, &sendData);
if (num > 0 && !alreadyConnected && !isHttp) { // whoa, we sent something, must be connected!
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_CONNECT, &connection, 1);
jsvObjectSetChildAndUnLock(connection, HTTP_NAME_CONNECTED, jsvNewFromBool(true));
alreadyConnected = true;
}
if (num < 0) {
closeConnectionNow = true;
error = num;
}
jsvObjectSetChild(connection, HTTP_NAME_SEND_DATA, sendData); // _http_send prob updated sendData
} else {
// no data to send, do we want to close? do so.
if (jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CLOSE, false)))
closeConnectionNow = true;
}
// Now read data if possible (and we have space for it)
if (!receiveData || !hadHeaders) {
int num = netRecv(net, sckt, buf, net->chunkSize);
//if (num != 0) printf("recv returned %d\r\n", num);
if (!alreadyConnected && num == SOCKET_ERR_NO_CONN) {
; // ignore... it's just telling us we're not connected yet
} else if (num < 0) {
closeConnectionNow = true;
error = num;
// disconnected without headers? error.
if (!hadHeaders && error == SOCKET_ERR_CLOSED) error = SOCKET_ERR_NO_RESP;
} else {
// did we just get connected?
if (!alreadyConnected && !isHttp) {
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_CONNECT, &connection, 1);
jsvObjectSetChildAndUnLock(connection, HTTP_NAME_CONNECTED, jsvNewFromBool(true));
alreadyConnected = true;
// if we do not have any data to send, issue a drain event
if (!sendData || (int)jsvGetStringLength(sendData) == 0)
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_DRAIN, &connection, 1);
}
// got data add it to our receive buffer
if (num > 0) {
if (!receiveData) {
receiveData = jsvNewFromEmptyString();
jsvObjectSetChild(connection, HTTP_NAME_RECEIVE_DATA, receiveData);
}
if (receiveData) { // could be out of memory
jsvAppendStringBuf(receiveData, buf, (size_t)num);
if ((socketType&ST_TYPE_MASK)==ST_HTTP && !hadHeaders) {
// for HTTP see whether we now have full response headers
JsVar *resVar = jsvObjectGetChild(connection,HTTP_NAME_RESPONSE_VAR,0);
if (httpParseHeaders(&receiveData, resVar, false)) {
hadHeaders = true;
jsvObjectSetChildAndUnLock(connection, HTTP_NAME_HAD_HEADERS, jsvNewFromBool(hadHeaders));
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_CONNECT, &resVar, 1);
}
jsvUnLock(resVar);
jsvObjectSetChild(connection, HTTP_NAME_RECEIVE_DATA, receiveData);
}
}
}
}
}
jsvUnLock(sendData);
}
}
if (closeConnectionNow) {
socketClientPushReceiveData(connection, socket, &receiveData);
if (!receiveData) {
if ((socketType&ST_TYPE_MASK) != ST_HTTP)
jsiQueueObjectCallbacks(socket, HTTP_NAME_ON_END, &socket, 1);
// If we had data to send but the socket closed, this is an error
JsVar *sendData = jsvObjectGetChild(connection,HTTP_NAME_SEND_DATA,0);
if (sendData && jsvGetStringLength(sendData) > 0 && error == SOCKET_ERR_CLOSED)
error = SOCKET_ERR_UNSENT_DATA;
jsvUnLock(sendData);
_socketConnectionKill(net, connection);
JsVar *connectionName = jsvObjectIteratorGetKey(&it);
jsvObjectIteratorNext(&it);
jsvRemoveChild(arr, connectionName);
jsvUnLock(connectionName);
socketClosed = true;
// fire error event, if there is an error
bool hadError = fireErrorEvent(error, connection, NULL);
// close callback must happen after error callback
JsVar *params[1] = { jsvNewFromBool(hadError) };
jsiQueueObjectCallbacks(socket, HTTP_NAME_ON_CLOSE, params, 1);
jsvUnLock(params[0]);
}
}
if (!socketClosed) {
jsvObjectIteratorNext(&it);
}
jsvUnLock3(receiveData, connection, socket);
}
jsvUnLock(arr);
return hadSockets;
}
bool socketServerConnectionsIdle(JsNetwork *net) {
char *buf = alloca(net->chunkSize); // allocate on stack
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVER_CONNECTIONS,false);
if (!arr) return false;
bool hadSockets = false;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
hadSockets = true;
// Get connection, socket, and socket type
// For normal sockets, socket==connection, but for HTTP we split it into a request and a response
JsVar *connection = jsvObjectIteratorGetValue(&it);
SocketType socketType = socketGetType(connection);
JsVar *socket = ((socketType&ST_TYPE_MASK)==ST_HTTP) ? jsvObjectGetChild(connection,HTTP_NAME_RESPONSE_VAR,0) : jsvLockAgain(connection);
int sckt = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_SOCKET,0))-1; // so -1 if undefined
bool closeConnectionNow = jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CLOSENOW, false));
int error = 0;
if (!closeConnectionNow) {
int num = netRecv(net, sckt, buf, net->chunkSize);
if (num<0) {
// we probably disconnected so just get rid of this
closeConnectionNow = true;
error = num;
} else {
// add it to our request string
if (num>0) {
JsVar *receiveData = jsvObjectGetChild(connection,HTTP_NAME_RECEIVE_DATA,0);
JsVar *oldReceiveData = receiveData;
if (!receiveData) receiveData = jsvNewFromEmptyString();
if (receiveData) {
jsvAppendStringBuf(receiveData, buf, (size_t)num);
bool hadHeaders = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_HAD_HEADERS,0));
if (!hadHeaders && httpParseHeaders(&receiveData, connection, true)) {
hadHeaders = true;
jsvObjectSetChildAndUnLock(connection, HTTP_NAME_HAD_HEADERS, jsvNewFromBool(hadHeaders));
JsVar *server = jsvObjectGetChild(connection,HTTP_NAME_SERVER_VAR,0);
JsVar *args[2] = { connection, socket };
jsiQueueObjectCallbacks(server, HTTP_NAME_ON_CONNECT, args, ((socketType&ST_TYPE_MASK)==ST_HTTP) ? 2 : 1);
jsvUnLock(server);
}
if (hadHeaders && !jsvIsEmptyString(receiveData)) {
// Keep track of how much we received (so we can close once we have it)
if ((socketType&ST_TYPE_MASK)==ST_HTTP) {
jsvObjectSetChildAndUnLock(connection, HTTP_NAME_RECEIVE_COUNT,
jsvNewFromInteger(
jsvGetIntegerAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_RECEIVE_COUNT, JSV_INTEGER)) +
jsvGetStringLength(receiveData)
));
}
// execute 'data' callback or save data
if (jswrap_stream_pushData(connection, receiveData, false)) {
// clear received data
jsvUnLock(receiveData);
receiveData = 0;
}
}
// if received data changed, update it
if (receiveData != oldReceiveData)
jsvObjectSetChild(connection,HTTP_NAME_RECEIVE_DATA,receiveData);
jsvUnLock(receiveData);
}
}
}
// send data if possible
JsVar *sendData = jsvObjectGetChild(socket,HTTP_NAME_SEND_DATA,0);
if (sendData && !jsvIsEmptyString(sendData)) {
int sent = socketSendData(net, socket, sckt, &sendData);
// FIXME? checking for errors is a bit iffy. With the esp8266 network that returns
// varied error codes we'd want to skip SOCKET_ERR_CLOSED and let the recv side deal
// with normal closing so we don't miss the tail of what's received, but other drivers
// return -1 (which is the same value) for all errors. So we rely on the check ~12 lines
// down if(num>0)closeConnectionNow=false instead.
if (sent < 0) {
closeConnectionNow = true;
error = sent;
}
jsvObjectSetChild(socket, HTTP_NAME_SEND_DATA, sendData); // socketSendData prob updated sendData
}
// only close if we want to close, have no data to send, and aren't receiving data
bool wantClose = jsvGetBoolAndUnLock(jsvObjectGetChild(socket,HTTP_NAME_CLOSE,0));
if (wantClose && (!sendData || jsvIsEmptyString(sendData)) && num<=0) {
bool reallyCloseNow = true;
if ((socketType&ST_TYPE_MASK)==ST_HTTP) {
// Check if we had a Content-Length header - if so, we need to wait until we have received that amount
JsVar *headers = jsvObjectGetChild(connection,"headers",0);
if (headers) {
JsVarInt contentLength = jsvGetIntegerAndUnLock(jsvObjectGetChild(headers,"Content-Length",0));
JsVarInt contentReceived = jsvGetIntegerAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_RECEIVE_COUNT, 0));
if (contentLength > contentReceived) {
reallyCloseNow = false;
}
jsvUnLock(headers);
}
}
closeConnectionNow = reallyCloseNow;
} else if (num > 0)
closeConnectionNow = false; // guarantee that anything received is processed
jsvUnLock(sendData);
}
if (closeConnectionNow) {
// send out any data that we were POSTed
JsVar *receiveData = jsvObjectGetChild(connection,HTTP_NAME_RECEIVE_DATA,0);
bool hadHeaders = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_HAD_HEADERS,0));
if (hadHeaders && !jsvIsEmptyString(receiveData)) {
// execute 'data' callback or save data
jswrap_stream_pushData(connection, receiveData, true);
}
jsvUnLock(receiveData);
// fire error events
bool hadError = fireErrorEvent(error, connection, socket);
// fire the close listeners
JsVar *params[1] = { jsvNewFromBool(hadError) };
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_CLOSE, params, 1);
jsiQueueObjectCallbacks(socket, HTTP_NAME_ON_CLOSE, params, 1);
jsvUnLock(params[0]);
_socketConnectionKill(net, connection);
JsVar *connectionName = jsvObjectIteratorGetKey(&it);
jsvObjectIteratorNext(&it);
jsvRemoveChild(arr, connectionName);
jsvUnLock(connectionName);
} else
jsvObjectIteratorNext(&it);
jsvUnLock2(connection, socket);
}
jsvObjectIteratorFree(&it);
jsvUnLock(arr);
return hadSockets;
}
bool socketClientConnectionsIdle(JsNetwork *net) {
char buf[64];
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_CLIENT_CONNECTIONS,false);
if (!arr) return false;
bool hadSockets = false;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
hadSockets = true;
// Get connection, socket, and socket type
// For normal sockets, socket==connection, but for HTTP we split it into a request and a response
JsVar *connection = jsvObjectIteratorGetValue(&it);
SocketType socketType = socketGetType(connection);
JsVar *socket = (socketType==ST_HTTP) ? jsvObjectGetChild(connection,HTTP_NAME_RESPONSE_VAR,0) : jsvLockAgain(connection);
bool closeConnectionNow = jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CLOSENOW, false));
int sckt = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_SOCKET,0))-1; // so -1 if undefined
if (sckt<0) closeConnectionNow = true;
bool hadHeaders = true;
if (socketType==ST_HTTP)
hadHeaders = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_HAD_HEADERS,0));
JsVar *receiveData = jsvObjectGetChild(connection,HTTP_NAME_RECEIVE_DATA,0);
/* We do this up here because we want to wait until we have been once
* around the idle loop (=callbacks have been executed) before we run this */
if (hadHeaders)
socketClientPushReceiveData(connection, socket, &receiveData);
if (!closeConnectionNow) {
JsVar *sendData = jsvObjectGetChild(connection,HTTP_NAME_SEND_DATA,0);
// send data if possible
if (sendData) {
bool b = socketSendData(net, connection, sckt, &sendData);
if (!b)
closeConnectionNow = true;
jsvObjectSetChild(connection, HTTP_NAME_SEND_DATA, sendData); // _http_send prob updated sendData
} else {
if (jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CLOSE, false)))
closeConnectionNow = true;
}
// Now read data if possible
int num = net->recv(net, sckt, buf, sizeof(buf));
if (num<0) {
// we probably disconnected so just get rid of this
closeConnectionNow = true;
} else {
// add it to our request string
if (num>0) {
if (!receiveData) {
receiveData = jsvNewFromEmptyString();
jsvObjectSetChild(connection, HTTP_NAME_RECEIVE_DATA, receiveData);
}
if (receiveData) { // could be out of memory
jsvAppendStringBuf(receiveData, buf, (size_t)num);
if (socketType==ST_HTTP && !hadHeaders) {
JsVar *resVar = jsvObjectGetChild(connection,HTTP_NAME_RESPONSE_VAR,0);
if (httpParseHeaders(&receiveData, resVar, false)) {
hadHeaders = true;
jsvUnLock(jsvObjectSetChild(connection, HTTP_NAME_HAD_HEADERS, jsvNewFromBool(hadHeaders)));
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_CONNECT, &resVar, 1);
}
jsvUnLock(resVar);
jsvObjectSetChild(connection, HTTP_NAME_RECEIVE_DATA, receiveData);
}
}
}
}
jsvUnLock(sendData);
}
if (closeConnectionNow) {
socketClientPushReceiveData(connection, socket, &receiveData);
if (socketType != ST_HTTP)
jsiQueueObjectCallbacks(socket, HTTP_NAME_ON_END, 0, 0);
jsiQueueObjectCallbacks(socket, HTTP_NAME_ON_CLOSE, 0, 0);
_socketConnectionKill(net, connection);
JsVar *connectionName = jsvObjectIteratorGetKey(&it);
jsvObjectIteratorNext(&it);
jsvRemoveChild(arr, connectionName);
jsvUnLock(connectionName);
} else {
jsvObjectIteratorNext(&it);
}
jsvUnLock(receiveData);
jsvUnLock(connection);
jsvUnLock(socket);
}
jsvUnLock(arr);
return hadSockets;
}
bool socketServerConnectionsIdle(JsNetwork *net) {
char buf[64];
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVER_CONNECTIONS,false);
if (!arr) return false;
bool hadSockets = false;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
hadSockets = true;
// Get connection, socket, and socket type
// For normal sockets, socket==connection, but for HTTP we split it into a request and a response
JsVar *connection = jsvObjectIteratorGetValue(&it);
SocketType socketType = socketGetType(connection);
JsVar *socket = (socketType==ST_HTTP) ? jsvObjectGetChild(connection,HTTP_NAME_RESPONSE_VAR,0) : jsvLockAgain(connection);
int sckt = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_SOCKET,0))-1; // so -1 if undefined
bool closeConnectionNow = jsvGetBoolAndUnLock(jsvObjectGetChild(connection, HTTP_NAME_CLOSENOW, false));
if (!closeConnectionNow) {
int num = net->recv(net, sckt, buf,sizeof(buf));
if (num<0) {
// we probably disconnected so just get rid of this
closeConnectionNow = true;
} else {
// add it to our request string
if (num>0) {
JsVar *receiveData = jsvObjectGetChild(connection,HTTP_NAME_RECEIVE_DATA,0);
JsVar *oldReceiveData = receiveData;
if (!receiveData) receiveData = jsvNewFromEmptyString();
if (receiveData) {
jsvAppendStringBuf(receiveData, buf, (size_t)num);
bool hadHeaders = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_HAD_HEADERS,0));
if (!hadHeaders && httpParseHeaders(&receiveData, connection, true)) {
hadHeaders = true;
jsvUnLock(jsvObjectSetChild(connection, HTTP_NAME_HAD_HEADERS, jsvNewFromBool(hadHeaders)));
JsVar *server = jsvObjectGetChild(connection,HTTP_NAME_SERVER_VAR,0);
JsVar *args[2] = { connection, socket };
jsiQueueObjectCallbacks(server, HTTP_NAME_ON_CONNECT, args, (socketType==ST_HTTP) ? 2 : 1);
jsvUnLock(server);
}
if (hadHeaders && !jsvIsEmptyString(receiveData)) {
// execute 'data' callback or save data
jswrap_stream_pushData(connection, receiveData);
// clear received data
jsvUnLock(receiveData);
receiveData = 0;
}
// if received data changed, update it
if (receiveData != oldReceiveData)
jsvObjectSetChild(connection,HTTP_NAME_RECEIVE_DATA,receiveData);
jsvUnLock(receiveData);
}
}
}
// send data if possible
JsVar *sendData = jsvObjectGetChild(socket,HTTP_NAME_SEND_DATA,0);
if (sendData) {
if (!socketSendData(net, socket, sckt, &sendData))
closeConnectionNow = true;
jsvObjectSetChild(socket, HTTP_NAME_SEND_DATA, sendData); // socketSendData prob updated sendData
}
// only close if we want to close, have no data to send, and aren't receiving data
if (jsvGetBoolAndUnLock(jsvObjectGetChild(socket,HTTP_NAME_CLOSE,0)) && !sendData && num<=0)
closeConnectionNow = true;
jsvUnLock(sendData);
}
if (closeConnectionNow) {
// send out any data that we were POSTed
JsVar *receiveData = jsvObjectGetChild(connection,HTTP_NAME_RECEIVE_DATA,0);
bool hadHeaders = jsvGetBoolAndUnLock(jsvObjectGetChild(connection,HTTP_NAME_HAD_HEADERS,0));
if (hadHeaders && !jsvIsEmptyString(receiveData)) {
// execute 'data' callback or save data
jswrap_stream_pushData(connection, receiveData);
}
jsvUnLock(receiveData);
// fire the close listeners
jsiQueueObjectCallbacks(connection, HTTP_NAME_ON_CLOSE, 0, 0);
jsiQueueObjectCallbacks(socket, HTTP_NAME_ON_CLOSE, 0, 0);
_socketConnectionKill(net, connection);
JsVar *connectionName = jsvObjectIteratorGetKey(&it);
jsvObjectIteratorNext(&it);
jsvRemoveChild(arr, connectionName);
jsvUnLock(connectionName);
} else
jsvObjectIteratorNext(&it);
jsvUnLock(connection);
jsvUnLock(socket);
}
jsvObjectIteratorFree(&it);
jsvUnLock(arr);
return hadSockets;
}