PUBLIC void socketRegisterInterest(int sid, int handlerMask)
{
WebsSocket *sp;
assert(socketPtr(sid));
sp = socketPtr(sid);
sp->handlerMask = handlerMask;
if (sp->flags & SOCKET_BUFFERED_READ) {
sp->handlerMask |= SOCKET_READABLE;
}
if (sp->flags & SOCKET_BUFFERED_WRITE) {
sp->handlerMask |= SOCKET_WRITABLE;
}
}
/*
Write to a socket. Absorb as much data as the socket can buffer. Block if the socket is in blocking mode. Returns -1
on error, otherwise the number of bytes written.
*/
PUBLIC ssize socketWrite(int sid, void *buf, ssize bufsize)
{
WebsSocket *sp;
ssize len, written, sofar;
int errCode;
if (buf == 0 || (sp = socketPtr(sid)) == NULL) {
return -1;
}
if (sp->flags & SOCKET_EOF) {
return -1;
}
len = bufsize;
sofar = 0;
while (len > 0) {
if ((written = send(sp->sock, (char*) buf + sofar, (int) len, 0)) < 0) {
errCode = socketGetError();
if (errCode == EINTR) {
continue;
} else if (errCode == EWOULDBLOCK || errCode == EAGAIN) {
if (sofar) {
/*
If some data was written, we mask the EAGAIN for this time. Caller should recall and then
will get a negative return code with EAGAIN.
*/
return sofar;
}
}
return -errCode;
}
len -= written;
sofar += written;
}
return sofar;
}
/*
Set the TCP delay behavior (nagle algorithm)
*/
PUBLIC int socketSetNoDelay(int sid, bool on)
{
WebsSocket *sp;
int oldDelay;
if ((sp = socketPtr(sid)) == NULL) {
assert(0);
return 0;
}
oldDelay = sp->flags & SOCKET_NODELAY;
if (on) {
sp->flags |= SOCKET_NODELAY;
} else {
sp->flags &= ~(SOCKET_NODELAY);
}
#if ME_WIN_LIKE
{
BOOL noDelay;
noDelay = on ? 1 : 0;
setsockopt(sp->sock, IPPROTO_TCP, TCP_NODELAY, (FAR char*) &noDelay, sizeof(BOOL));
}
#else
{
int noDelay;
noDelay = on ? 1 : 0;
setsockopt(sp->sock, IPPROTO_TCP, TCP_NODELAY, (char*) &noDelay, sizeof(int));
}
#endif /* ME_WIN_LIKE */
return oldDelay;
}
/*
Write to a socket. Absorb as much data as the socket can buffer. Block if the socket is in blocking mode. Returns -1
on error, otherwise the number of bytes written.
*/
PUBLIC ssize socketWrite(int sid, void *buf, ssize bufsize)
{
WebsSocket *sp;
ssize len, written, sofar;
int errCode;
if (buf == 0 || (sp = socketPtr(sid)) == NULL) {
return -1;
}
if (sp->flags & SOCKET_EOF) {
return -1;
}
len = bufsize;
sofar = 0;
while (len > 0) {
if ((written = send(sp->sock, (char*) buf + sofar, (int) len, 0)) < 0) {
errCode = socketGetError();
if (errCode == EINTR) {
continue;
} else if (errCode == EWOULDBLOCK || errCode == EAGAIN) {
return sofar;
}
return -errCode;
}
len -= written;
sofar += written;
}
return sofar;
}
void socketSetBufferSize(int sid, int in, int line, int out)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
return;
}
if (in >= 0) {
ringqClose(&sp->inBuf);
in++;
ringqOpen(&sp->inBuf, in, in);
}
if (line >= 0) {
ringqClose(&sp->lineBuf);
line++;
ringqOpen(&sp->lineBuf, line, line);
}
if (out >= 0) {
ringqClose(&sp->outBuf);
out++;
ringqOpen(&sp->outBuf, out, out);
}
}
/*
Read from a socket. Return the number of bytes read if successful. This may be less than the requested "bufsize" and
may be zero. This routine may block if the socket is in blocking mode.
Return -1 for errors or EOF. Distinguish between error and EOF via socketEof().
*/
PUBLIC ssize socketRead(int sid, void *buf, ssize bufsize)
{
WebsSocket *sp;
ssize bytes;
int errCode;
assert(buf);
assert(bufsize > 0);
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
if (sp->flags & SOCKET_EOF) {
return -1;
}
if ((bytes = recv(sp->sock, buf, (int) bufsize, 0)) < 0) {
errCode = socketGetError();
if (errCode == EAGAIN || errCode == EWOULDBLOCK) {
bytes = 0;
} else {
/* Conn reset or Some other error */
sp->flags |= SOCKET_EOF;
bytes = -errCode;
}
} else if (bytes == 0) {
sp->flags |= SOCKET_EOF;
bytes = -1;
}
return bytes;
}
int socketGetInput(int sid, char *buf, int toRead, int *errCode)
{
struct sockaddr_in server;
socket_t *sp;
int len, bytesRead;
a_assert(buf);
a_assert(errCode);
*errCode = 0;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
/*
* If we have previously seen an EOF condition, then just return
*/
if (sp->flags & SOCKET_EOF) {
return 0;
}
#if ((defined (WIN) || defined (CE)) && (!defined (LITTLEFOOT) && !defined (WEBS)))
if ( !(sp->flags & SOCKET_BLOCK)
&& ! socketWaitForEvent(sp, FD_CONNECT, errCode)) {
return -1;
}
#endif
/*
* Read the data
*/
if (sp->flags & SOCKET_DATAGRAM) {
len = sizeof(server);
bytesRead = recvfrom(sp->sock, buf, toRead, 0,
(struct sockaddr *) &server, &len);
} else {
bytesRead = recv(sp->sock, buf, toRead, 0);
}
/*
* BUG 01865 -- CPU utilization hangs on Windows. The original code used
* the 'errno' global variable, which is not set by the winsock functions
* as it is under *nix platforms. We use the platform independent
* socketGetError() function instead, which does handle Windows correctly.
* Other, *nix compatible platforms should work as well, since on those
* platforms, socketGetError() just returns the value of errno.
* Thanks to Jonathan Burgoyne for the fix.
*/
if (bytesRead < 0)
{
*errCode = socketGetError();
if (*errCode == ECONNRESET)
{
sp->flags |= SOCKET_CONNRESET;
return 0;
}
return -1;
}
return bytesRead;
}
/*
Return the number of bytes read. Return -1 on errors and EOF.
*/
PUBLIC ssize sslRead(Webs *wp, void *buf, ssize len)
{
Nano *np;
WebsSocket *sp;
sbyte4 nbytes, count;
int rc;
np = (Nano*) wp->ssl;
assert(np);
if (!np->connected && (rc = nanoHandshake(wp)) <= 0) {
return rc;
}
while (1) {
/*
This will do the actual blocking I/O
*/
rc = SSL_recv(np->handle, buf, (sbyte4) len, &nbytes, 0);
logmsg(5, "NanoSSL: ssl_read %d", rc);
if (rc < 0) {
if (rc != ERR_TCP_READ_ERROR) {
sp = socketPtr(wp->sid);
sp->flags |= SOCKET_EOF;
}
return -1;
}
break;
}
SSL_recvPending(np->handle, &count);
if (count > 0) {
socketReservice(wp->wid);
}
return nbytes;
}
PUBLIC void sslFree(Webs *wp)
{
Ms *ms;
WebsSocket *sp;
uchar *buf;
int len;
ms = wp->ssl;
if (ms) {
assert(wp->sid >= 0);
if ((sp = socketPtr(wp->sid)) == 0) {
return;
}
if (!(sp->flags & SOCKET_EOF)) {
/*
Flush data. Append a closure alert to any buffered output data, and try to send it.
Don't bother retrying or blocking, we're just closing anyway.
*/
matrixSslEncodeClosureAlert(ms->handle);
if ((len = matrixSslGetOutdata(ms->handle, &buf)) > 0) {
sslWrite(wp, buf, len);
}
}
if (ms->handle) {
matrixSslDeleteSession(ms->handle);
}
wfree(ms);
wp->ssl = 0;
}
}
/*
Return number of bytes read. Return -1 on errors and EOF.
*/
static ssize innerRead(Webs *wp, char *buf, ssize size)
{
Ms *ms;
uchar *mbuf;
ssize nbytes;
int msize, readMore;
ms = (Ms*) wp->ssl;
do {
if ((msize = matrixSslGetReadbuf(ms->handle, &mbuf)) < 0) {
return -1;
}
readMore = 0;
if ((nbytes = socketRead(wp->sid, mbuf, msize)) < 0) {
return nbytes;
} else if (nbytes > 0) {
nbytes = processIncoming(wp, buf, size, nbytes, &readMore);
if (nbytes < 0) {
sp = socketPtr(wp->sid);
sp->flags |= SOCKET_EOF;
return nbytes;
}
if (nbytes > 0) {
return nbytes;
}
}
} while (readMore);
return 0;
}
int socketGets(int sid, char_t **buf)
{
socket_t *sp;
ringq_t *lq;
char c;
int rc, len;
a_assert(buf);
*buf = NULL;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
lq = &sp->lineBuf;
while (1) {
if ((rc = socketRead(sid, &c, 1)) < 0) {
return rc;
}
if (rc == 0) {
/*
* If there is a partial line and we are at EOF, pretend we saw a '\n'
*/
if (ringqLen(lq) > 0 && (sp->flags & SOCKET_EOF)) {
c = '\n';
} else {
return -1;
}
}
/*
* Validate length of request. Ignore long strings without newlines to
* safeguard against long URL attacks.
*/
if (ringqLen(lq) > E_MAX_REQUEST) {
c = '\n';
}
/*
* If a newline is seen, return the data excluding the new line to the
* caller. If carriage return is seen, just eat it.
*/
if (c == '\n') {
len = ringqLen(lq);
if (len > 0) {
*buf = ballocAscToUni((char *)lq->servp, len);
} else {
*buf = NULL;
}
ringqFlush(lq);
return len;
} else if (c == '\r') {
continue;
}
ringqPutcA(lq, c);
}
return 0;
}
/*
Set the socket blocking mode. Return the previous mode.
*/
PUBLIC int socketSetBlock(int sid, int on)
{
WebsSocket *sp;
int oldBlock;
if ((sp = socketPtr(sid)) == NULL) {
assert(0);
return 0;
}
oldBlock = (sp->flags & SOCKET_BLOCK);
sp->flags &= ~(SOCKET_BLOCK);
if (on) {
sp->flags |= SOCKET_BLOCK;
}
/*
Put the socket into block / non-blocking mode
*/
if (sp->flags & SOCKET_BLOCK) {
#if ME_WIN_LIKE
ulong flag = !on;
ioctlsocket(sp->sock, FIONBIO, &flag);
#elif ECOS
int off;
off = 0;
ioctl(sp->sock, FIONBIO, &off);
#elif VXWORKS
int iflag = !on;
ioctl(sp->sock, FIONBIO, (int) &iflag);
#elif TIDSP
setsockopt((SOCKET)sp->sock, SOL_SOCKET, SO_BLOCKING, &on, sizeof(on));
#else
fcntl(sp->sock, F_SETFL, fcntl(sp->sock, F_GETFL) & ~O_NONBLOCK);
#endif
} else {
#if ME_WIN_LIKE
ulong flag = !on;
int rc = ioctlsocket(sp->sock, FIONBIO, &flag);
rc = rc;
#elif ECOS
int on = 1;
ioctl(sp->sock, FIONBIO, &on);
#elif VXWORKS
int iflag = !on;
ioctl(sp->sock, FIONBIO, (int) &iflag);
#elif TIDSP
setsockopt((SOCKET)sp->sock, SOL_SOCKET, SO_BLOCKING, &on, sizeof(on));
#else
fcntl(sp->sock, F_SETFL, fcntl(sp->sock, F_GETFL) | O_NONBLOCK);
#endif
}
#if MACOSX
/* Prevent SIGPIPE when writing to closed socket on OS X */
int iflag = 1;
setsockopt(sp->sock, SOL_SOCKET, SO_NOSIGPIPE, (void*) &iflag, sizeof(iflag));
#endif
return oldBlock;
}
int socketGetHandle(int sid)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
return sp->sock;
}
int socketCanWrite(int sid)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
return sp->outBuf.buflen - ringqLen(&sp->outBuf) - 1;
}
int socketEof(int sid)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
return sp->flags & SOCKET_EOF;
}
int socketGetPort(int sid)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
return sp->port;
}
PUBLIC void socketReservice(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return;
}
sp->flags |= SOCKET_RESERVICE;
}
/*
Return true if EOF
*/
PUBLIC bool socketEof(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return 1;
}
return sp->flags & SOCKET_EOF;
}
/*
Return the underlying socket handle
*/
PUBLIC Socket socketGetHandle(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
return sp->sock;
}
PUBLIC void socketCloseConnection(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return;
}
socketFree(sid);
}
PUBLIC bool socketIsV6(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return 0;
}
return sp->ip && ipv6(sp->ip);
}
PUBLIC int socketGetPort(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return -1;
}
return sp->port;
}
PUBLIC ssize sslRead(Webs *wp, void *buf, ssize len)
{
WebsSocket *sp;
char ebuf[BIT_GOAHEAD_LIMIT_STRING];
ulong serror;
int rc, error, retries, i;
if (wp->ssl == 0 || len <= 0) {
assert(0);
return -1;
}
/*
Limit retries on WANT_READ. If non-blocking and no data, then this can spin forever.
*/
sp = socketPtr(wp->sid);
retries = 5;
for (i = 0; i < retries; i++) {
rc = SSL_read(wp->ssl, buf, (int) len);
if (rc < 0) {
error = SSL_get_error(wp->ssl, rc);
if (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_CONNECT || error == SSL_ERROR_WANT_ACCEPT) {
continue;
}
serror = ERR_get_error();
ERR_error_string_n(serror, ebuf, sizeof(ebuf) - 1);
trace(5, "SSL_read %s", ebuf);
}
break;
}
if (rc <= 0) {
error = SSL_get_error(wp->ssl, rc);
if (error == SSL_ERROR_WANT_READ) {
rc = 0;
} else if (error == SSL_ERROR_WANT_WRITE) {
sleep(0);
rc = 0;
} else if (error == SSL_ERROR_ZERO_RETURN) {
sp->flags |= SOCKET_EOF;
rc = -1;
} else if (error == SSL_ERROR_SYSCALL) {
sp->flags |= SOCKET_EOF;
rc = -1;
} else if (error != SSL_ERROR_ZERO_RETURN) {
/* SSL_ERROR_SSL */
serror = ERR_get_error();
ERR_error_string_n(serror, ebuf, sizeof(ebuf) - 1);
trace(4, "OpenSSL: connection with protocol error: %s", ebuf);
rc = -1;
sp->flags |= SOCKET_EOF;
}
} else if (SSL_pending(wp->ssl) > 0) {
sp->flags |= SOCKET_BUFFERED_READ;
socketReservice(wp->sid);
}
return rc;
}
int socketGetMode(int sid)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
a_assert(0);
return 0;
}
return sp->flags;
}
void socketSetMode(int sid, int mode)
{
socket_t *sp;
if ((sp = socketPtr(sid)) == NULL) {
a_assert(0);
return;
}
sp->flags = mode;
}
PUBLIC void socketDeleteHandler(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
return;
}
sp->handler = NULL;
socketRegisterInterest(sid, 0);
}
PUBLIC int socketGetMode(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
assert(0);
return 0;
}
return sp->flags;
}
PUBLIC void socketSetMode(int sid, int mode)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
assert(0);
return;
}
sp->flags = mode;
}
/*
Get blocking mode
*/
PUBLIC int socketGetBlock(int sid)
{
WebsSocket *sp;
if ((sp = socketPtr(sid)) == NULL) {
assert(0);
return 0;
}
return (sp->flags & SOCKET_BLOCK);
}
void socketFree(int sid)
{
socket_t *sp;
char_t buf[256];
int i;
if ((sp = socketPtr(sid)) == NULL) {
return;
}
/*
* To close a socket, remove any registered interests, set it to
* non-blocking so that the recv which follows won't block, do a
* shutdown on it so peers on the other end will receive a FIN,
* then read any data not yet retrieved from the receive buffer,
* and finally close it. If these steps are not all performed
* RESETs may be sent to the other end causing problems.
*/
socketRegisterInterest(sp, 0);
if (sp->sock >= 0) {
socketSetBlock(sid, 0);
/**************************** HANHUI ***************************/
/*
if (shutdown(sp->sock, 1) >= 0) {
recv(sp->sock, buf, sizeof(buf), 0);
}
*/
shutdown(sp->sock, SHUT_RDWR);
/**************************** HANHUI ***************************/
#if (defined (WIN) || defined (CE))
closesocket(sp->sock);
#else
close(sp->sock);
#endif
}
ringqClose(&sp->inBuf);
ringqClose(&sp->outBuf);
ringqClose(&sp->lineBuf);
bfree(B_L, sp);
socketMax = hFree((void***) &socketList, sid);
/*
* Calculate the new highest socket number
*/
socketHighestFd = -1;
for (i = 0; i < socketMax; i++) {
if ((sp = socketList[i]) == NULL) {
continue;
}
socketHighestFd = max(socketHighestFd, sp->sock);
}
}
