自学教程：C++ socketPtr函数代码示例

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 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);	}}