sio.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SelectSet
struct	SReadlineInfo

Macros
#define	_SReadlineInfo_   1
#define	forever   for ( ; ; )
#define	SSetjmp(a)   setjmp(a)
#define	SLongjmp(a, b)   longjmp(a, b)
#define	Sjmp_buf   jmp_buf
#define	kReUseAddrYes   1
#define	kReUseAddrNo   0
#define	kFullBufferNotRequired   00000
#define	kFullBufferRequired   00001
#define	kFullBufferRequiredExceptLast   00002
#define	kNoFirstSelect   00010
#define	kUseDNSYes   1
#define	kUseDNSNo   0
#define	kTimeoutErr   (-2)
#define	kBrokenPipeErr   (-3)
#define	kAddrStrToAddrMiscErr   (-4)
#define	kAddrStrToAddrBadHost   (-5)
#define	kSNewFailed   (-6)
#define	kSBindFailed   (-7)
#define	kSListenFailed   (-8)
#define	kSrlBufSize   2048
#define	kNoTimeLimit   0
#define	NO_SIGNALS   1
#define	SAccept   SAcceptS
#define	closesocket   close
#define	ioctlsocket   ioctl
#define	SETERRNO
#define	SETWSATIMEOUTERR
#define	LIBSIO_USE_VAR(a)   gLibSio_Uses_Me_To_Quiet_Variable_Unused_Warnings = (a == 0)
#define	UNUSED(a)   a

Typedefs
typedef struct SelectSet	SelectSet
typedef struct SelectSet *	SelectSetPtr
typedef struct SReadlineInfo	SReadlineInfo
typedef void(*	sio_sigproc_t) (int)
typedef volatile sio_sigproc_t	vsio_sigproc_t

Functions
int	PRead (int, char *const, size_t, int)
int	PWrite (int, const char *const, size_t)
int	SAcceptA (int, struct sockaddr_in *const, int)
int	SAcceptS (int, struct sockaddr_in *const, int)
int	SBind (int, const int, const int, const int)
int	SListen (int, int)
int	SClose (int, int)
int	SConnect (int, const struct sockaddr_in *const, int)
int	SConnectByName (int, const char *const, const int)
int	SNewStreamClient (void)
int	SNewDatagramClient (void)
int	SNewStreamServer (const int, const int, const int, int)
int	SNewDatagramServer (const int, const int, const int)
int	SRead (int, char *const, size_t, int, int)
void	FlushSReadlineInfo (SReadlineInfo *)
int	InitSReadlineInfo (SReadlineInfo *, int, char *, size_t, int, int)
void	DisposeSReadlineInfo (SReadlineInfo *)
int	SReadline (SReadlineInfo *, char *const, size_t)
int	SRecv (int, char *const, size_t, int, int, int)
int	SRecvfrom (int, char *const, size_t, int, struct sockaddr_in *const, int)
int	SRecvmsg (int, void *const, int, int)
void	SelectSetInit (SelectSetPtr const, const double)
void	SelectSetAdd (SelectSetPtr const, const int)
void	SelectSetRemove (SelectSetPtr const, const int)
int	SelectW (SelectSetPtr, SelectSetPtr)
int	SelectR (SelectSetPtr, SelectSetPtr)
int	SSend (int, char *, size_t, int, int)
int	SSendto (int, const char *const, size_t, int, const struct sockaddr_in *const, int)
int	Sendto (int, const char *const, size_t, const struct sockaddr_in *const)
int	SSendtoByName (int, const char *const, size_t, int, const char *const, int)
int	SendtoByName (int, const char *const, size_t, const char *const)
int	SWaitUntilReadyForReading (const int sfd, const int tlen)
int	SWaitUntilReadyForWriting (const int sfd, const int tlen)
int	SWrite (int, const char *const, size_t, int, int)
int	GetSocketBufSize (int, size_t *const, size_t *const)
int	SetSocketBufSize (int, size_t, size_t)
int	GetSocketNagleAlgorithm (const int)
int	SetSocketNagleAlgorithm (const int, const int)
int	GetSocketLinger (const int, int *const)
int	SetSocketLinger (const int, const int, const int)
int	AddrStrToAddr (const char *const, struct sockaddr_in *const, const int)
char *	AddrToAddrStr (char *const dst, size_t dsize, struct sockaddr_in *const saddrp, int dns, const char *fmt)
const char *	SError (int e)
void	SIOHandler (int)

Variables
int	gLibSio_Uses_Me_To_Quiet_Variable_Unused_Warnings
void(*)(int)	SSignal (int signum, void(*handler)(int))

Macro Definition Documentation

_SReadlineInfo_

#define _SReadlineInfo_   1

Definition at line 15 of file sio.h.

closesocket

#define closesocket   close

Definition at line 108 of file sio.h.

forever

#define forever   for ( ; ; )

Definition at line 30 of file sio.h.

ioctlsocket

#define ioctlsocket   ioctl

Definition at line 112 of file sio.h.

kAddrStrToAddrBadHost

#define kAddrStrToAddrBadHost   (-5)

Definition at line 62 of file sio.h.

kAddrStrToAddrMiscErr

#define kAddrStrToAddrMiscErr   (-4)

Definition at line 61 of file sio.h.

kBrokenPipeErr

#define kBrokenPipeErr   (-3)

Definition at line 59 of file sio.h.

kFullBufferNotRequired

#define kFullBufferNotRequired   00000

Definition at line 49 of file sio.h.

kFullBufferRequired

#define kFullBufferRequired   00001

Definition at line 50 of file sio.h.

kFullBufferRequiredExceptLast

#define kFullBufferRequiredExceptLast   00002

Definition at line 51 of file sio.h.

kNoFirstSelect

#define kNoFirstSelect   00010

Definition at line 52 of file sio.h.

kNoTimeLimit

#define kNoTimeLimit   0

Definition at line 70 of file sio.h.

kReUseAddrNo

#define kReUseAddrNo   0

Definition at line 46 of file sio.h.

kReUseAddrYes

#define kReUseAddrYes   1

Definition at line 45 of file sio.h.

kSBindFailed

#define kSBindFailed   (-7)

Definition at line 65 of file sio.h.

kSListenFailed

#define kSListenFailed   (-8)

Definition at line 66 of file sio.h.

kSNewFailed

#define kSNewFailed   (-6)

Definition at line 64 of file sio.h.

kSrlBufSize

#define kSrlBufSize   2048

Definition at line 68 of file sio.h.

kTimeoutErr

#define kTimeoutErr   (-2)

Definition at line 58 of file sio.h.

kUseDNSNo

#define kUseDNSNo   0

Definition at line 56 of file sio.h.

kUseDNSYes

#define kUseDNSYes   1

Definition at line 55 of file sio.h.

LIBSIO_USE_VAR

#define LIBSIO_USE_VAR

(

a

)

gLibSio_Uses_Me_To_Quiet_Variable_Unused_Warnings = (a == 0)

Definition at line 140 of file sio.h.

NO_SIGNALS

#define NO_SIGNALS   1

Definition at line 74 of file sio.h.

SAccept

#define SAccept   SAcceptS

Definition at line 81 of file sio.h.

SETERRNO

#define SETERRNO

Definition at line 119 of file sio.h.

SETWSATIMEOUTERR

#define SETWSATIMEOUTERR

Definition at line 120 of file sio.h.

Sjmp_buf

#define Sjmp_buf   jmp_buf

Definition at line 41 of file sio.h.

SLongjmp

#define SLongjmp	(		a,
			b
	)		longjmp(a, b)

Definition at line 40 of file sio.h.

SSetjmp

#define SSetjmp

(

a

)

setjmp(a)

Definition at line 39 of file sio.h.

UNUSED

#define UNUSED

(

a

)

a

Definition at line 142 of file sio.h.

Typedef Documentation

SelectSet

typedef struct SelectSet SelectSet

SelectSetPtr

typedef struct SelectSet * SelectSetPtr

sio_sigproc_t

typedef void(* sio_sigproc_t) (int)

Definition at line 123 of file sio.h.

SReadlineInfo

typedef struct SReadlineInfo SReadlineInfo

vsio_sigproc_t

typedef volatile sio_sigproc_t vsio_sigproc_t

Definition at line 124 of file sio.h.

Function Documentation

AddrStrToAddr()

int AddrStrToAddr	(	const char * const	s,
		struct sockaddr_in * const	sa,
		const int	defaultport
	)

Definition at line 54 of file StrAddr.c.

{
    char portstr[128];
    unsigned long ipnum;
    unsigned int port;
    struct hostent *hp;
    char *hostcp, *atsign, *colon, *cp, *p2;
 
    memset(sa, 0, sizeof(struct sockaddr_in));
    strncpy(portstr, s, sizeof(portstr));
    portstr[sizeof(portstr) - 1] = '\0';
 
    if ((colon = strchr(portstr, ':')) != NULL) {
        /* Does it look like a URL?  http://host ? */
        if ((colon[1] == '/') && (colon[2] == '/')) {
            *colon = '\0';
            port = 0;
            hostcp = colon + 3;
            for (cp = hostcp; *cp != '\0'; cp++) {
                if ((!ISALNUM(*cp)) && (*cp != '.')) {
                    /* http://host:port */
                    if ((*cp == ':') && (isdigit(cp[1]))) {
                        *cp++ = '\0';
                        p2 = cp;
                        while (isdigit(*cp))
                            cp++;
                        *cp = '\0';
                        port = atoi(p2);
                    }
                    *cp = '\0';
                    break;
                }
            }
            if (port == 0)
                port = ServiceNameToPortNumber(portstr);
        } else {
            /* Look for host.name.domain:port */
            *colon = '\0';
            hostcp = portstr;
            port = (unsigned int) atoi(colon + 1);
        }
    } else if ((atsign = strchr(portstr, '@')) != NULL) {
        /* Look for port@host.name.domain */
        *atsign = '\0';
        hostcp = atsign + 1;
        port = (unsigned int) atoi(portstr);
    } else if (defaultport > 0) {
        /* Have just host.name.domain, use that w/ default port. */
        port = (unsigned int) defaultport;
        hostcp = portstr;
    } else {
        /* If defaultport <= 0, they must supply a port number
         * in the host/port string.
         */
        errno = EADDRNOTAVAIL;
        return (kAddrStrToAddrMiscErr);
    }
 
    sa->sin_port = htons((short) port);
 
    ipnum = inet_addr(hostcp);
    if (ipnum != INADDR_NONE) {
        sa->sin_family = AF_INET;
        sa->sin_addr.s_addr = ipnum;
    } else {
        errno = 0;
        hp = gethostbyname(hostcp);
        if (hp == NULL) {
            if (errno == 0)
                errno = ENOENT;
            return (kAddrStrToAddrBadHost);
        }
        sa->sin_family = hp->h_addrtype;
        memcpy(&sa->sin_addr.s_addr, hp->h_addr_list[0],
            (size_t) hp->h_length);
    }
    return (0);
}   /* AddrStrToAddr */

Referenced by SConnectByName(), SendtoByName(), and SSendtoByName().

AddrToAddrStr()

char * AddrToAddrStr	(	char *const	dst,
		size_t	dsize,
		struct sockaddr_in *const	saddrp,
		int	dns,
		const char *	fmt
	)

Definition at line 136 of file StrAddr.c.

{
    const char *addrNamePtr;
    struct hostent *hp;
    char str[128];
    char *dlim, *dp;
    const char *cp;
    struct servent *pp;
 
    if (dns == 0) {
        addrNamePtr = inet_ntoa(saddrp->sin_addr);
    } else {
        hp = gethostbyaddr((char *) &saddrp->sin_addr, (int) sizeof(struct in_addr), AF_INET);
        if ((hp != NULL) && (hp->h_name != NULL) && (hp->h_name[0] != '\0')) {
            addrNamePtr = hp->h_name;
        } else {
            addrNamePtr = inet_ntoa(saddrp->sin_addr);
        }
    }
    if (fmt == NULL)
        fmt = "%h:%p";
    for (dp = dst, dlim = dp + dsize - 1; ; fmt++) {
        if (*fmt == '\0') {
            break;  /* done */
        } else if (*fmt == '%') {
            fmt++;
            if (*fmt == '%') {
                if (dp < dlim)
                    *dp++ = '%';
            } else if (*fmt == 'p') {
                sprintf(str, "%u", (unsigned int) ntohs(saddrp->sin_port));
                for (cp = str; *cp != '\0'; cp++)
                    if (dp < dlim)
                        *dp++ = *cp;
                *dp = '\0';
            } else if (*fmt == 'h') {
                if (addrNamePtr != NULL) {
                    cp = addrNamePtr;
                } else {
                    cp = "unknown";
                }
                for ( ; *cp != '\0'; cp++)
                    if (dp < dlim)
                        *dp++ = *cp;
                *dp = '\0';
            } else if (*fmt == 's') {
                pp = getservbyport((int) (saddrp->sin_port), "tcp");
                if (pp == NULL)
                    pp = getservbyport((int) (saddrp->sin_port), "udp");
                if (pp == NULL) {
                    sprintf(str, "%u", (unsigned int) ntohs(saddrp->sin_port));
                    cp = str;
                } else {
                    cp = pp->s_name;
                }
                for ( ; *cp != '\0'; cp++)
                    if (dp < dlim)
                        *dp++ = *cp;
                /* endservent(); */
                *dp = '\0';
            } else if ((*fmt == 't') || (*fmt == 'u')) {
                pp = getservbyport((int) (saddrp->sin_port), (*fmt == 'u') ? "udp" : "tcp");
                if (pp == NULL) {
                    sprintf(str, "%u", (unsigned int) ntohs(saddrp->sin_port));
                    cp = str;
                } else {
                    cp = pp->s_name;
                }
                for ( ; *cp != '\0'; cp++)
                    if (dp < dlim)
                        *dp++ = *cp;
                /* endservent(); */
                *dp = '\0';
            } else if (*fmt == '\0') {
                break;
            } else {
                if (dp < dlim)
                    *dp++ = *fmt;
            }
        } else if (dp < dlim) {
            *dp++ = *fmt;
        }
    }
    *dp = '\0';
    return (dst);
}   /* AddrToAddrStr */

Referenced by ServeOneClient().

DisposeSReadlineInfo()

void DisposeSReadlineInfo

(

SReadlineInfo *

srl

)

Definition at line 57 of file SReadline.c.

{
    memset(srl->buf, 0, srl->bufSizeMax);
    if (srl->malloc != 0)
        free(srl->buf);
    memset(srl, 0, sizeof(SReadlineInfo));
 
    /* Note: it does not close(srl->fd). */
}   /* DisposeSReadlineInfo */

Referenced by CloseControlConnection(), FTPDeallocateHost(), FTPList(), and FTPListToMemory2().

FlushSReadlineInfo()

void FlushSReadlineInfo

(

SReadlineInfo *

srl

)

Definition at line 4 of file SReadline.c.

{
    /* Discards any input left in the current buffer,
     * and resets the buffer and its pointer.
     */
    srl->bufSize = srl->bufSizeMax;
    memset(srl->buf, 0, srl->bufSize);
    srl->bufLim = srl->buf + srl->bufSizeMax;
 
    /* This line sets the buffer pointer
     * so that the first thing to do is reset and fill the buffer
     * using real I/O.
     */
    srl->bufPtr = srl->bufLim;
}   /* FlushSReadlineInfo */

GetSocketBufSize()

int GetSocketBufSize	(	int	,
		size_t * const	,
		size_t * const
	)

GetSocketLinger()

int GetSocketLinger	(	const int	,
		int * const
	)

GetSocketNagleAlgorithm()

int GetSocketNagleAlgorithm

(

const int

)

InitSReadlineInfo()

int InitSReadlineInfo	(	SReadlineInfo *	srl,
		int	fd,
		char *	buf,
		size_t	bsize,
		int	tlen,
		int	requireEOLN
	)

Definition at line 24 of file SReadline.c.

{
    if (buf == NULL) {
        if (bsize < 512)
            bsize = 512;    /* Pointless, otherwise. */
        buf = (char *) malloc(bsize);
        if (buf == NULL)
            return (-1);
        srl->malloc = 1;
    } else {
        srl->malloc = 0;
    }
    memset(buf, 0, bsize);
    srl->buf = buf;
    srl->bufSize = bsize;
    srl->bufSizeMax = bsize;
    srl->bufLim = srl->buf + bsize;
    srl->fd = fd;
    srl->timeoutLen = tlen;
    srl->requireEOLN = requireEOLN;
 
    /* This line sets the buffer pointer
     * so that the first thing to do is reset and fill the buffer
     * using real I/O.
     */
    srl->bufPtr = srl->bufLim;
    return (0);
}   /* InitSReadlineInfo */

Referenced by FTPList(), FTPListToMemory2(), FTPRebuildConnectionInfo(), OpenControlConnection(), and ServeOneClient().

PRead()

int PRead	(	int	sfd,
		char * const	buf0,
		size_t	size,
		int	retry
	)

Definition at line 19 of file PRead.c.

{
    int nread;
    volatile int nleft;
    char *volatile buf = buf0;
#if !defined(NO_SIGNALS) && defined(SIGPIPE)
    vsio_sigproc_t sigpipe;
 
    if (SSetjmp(gPipeJmp) != 0) {
        (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
        nread = size - nleft;
        if (nread > 0)
            return (nread);
        errno = EPIPE;
        return (kBrokenPipeErr);
    }
 
    sigpipe = (vsio_sigproc_t) SSignal(SIGPIPE, SIOHandler);
#endif
    errno = 0;
 
    nleft = (int) size;
    forever {
        nread = read(sfd, buf, nleft);
        if (nread <= 0) {
            if (nread == 0) {
                /* EOF */
                nread = size - nleft;
                goto done;
            } else if (errno != EINTR) {
                nread = size - nleft;
                if (nread == 0)
                    nread = -1;
                goto done;
            } else {
                errno = 0;
                nread = 0;
                /* Try again. */
            }
        }
        nleft -= nread;
        if ((nleft <= 0) || (retry == 0))
            break;
        buf += nread;
    }
    nread = size - nleft;
 
done:
#if !defined(NO_SIGNALS) && defined(SIGPIPE)
    (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
#endif
    return (nread);
}   /* PRead */

PWrite()

int PWrite	(	int	sfd,
		const char * const	buf0,
		size_t	size
	)

Definition at line 7 of file PWrite.c.

{
    volatile int nleft;
    const char *volatile buf = buf0;
    int nwrote;
#if !defined(NO_SIGNALS) && defined(SIGPIPE)
    vsio_sigproc_t sigpipe;
 
    if (SSetjmp(gPipeJmp) != 0) {
        (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
        nwrote = size - nleft;
        if (nwrote > 0)
            return (nwrote);
        errno = EPIPE;
        return (kBrokenPipeErr);
    }
 
    sigpipe = (vsio_sigproc_t) SSignal(SIGPIPE, SIOHandler);
#endif
 
    nleft = (int) size;
    forever {
        nwrote = write(sfd, buf, nleft);
        if (nwrote < 0) {
            if (errno != EINTR) {
                nwrote = size - nleft;
                if (nwrote == 0)
                    nwrote = -1;
                goto done;
            } else {
                errno = 0;
                nwrote = 0;
                /* Try again. */
            }
        }
        nleft -= nwrote;
        if (nleft <= 0)
            break;
        buf += nwrote;
    }
    nwrote = size - nleft;
 
done:
#if !defined(NO_SIGNALS) && defined(SIGPIPE)
    (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
#endif
 
    return (nwrote);
}   /* PWrite */

SAcceptA()

int SAcceptA	(	int	sfd,
		struct sockaddr_in * const	addr,
		int	tlen
	)

Definition at line 9 of file SAcceptA.c.

{
    int result;
#ifndef NO_SIGNALS
    vsio_sigproc_t sigalrm, sigpipe;
#endif
    size_t size;
 
    if (tlen < 0) {
        errno = 0;
        for (;;) {
            size = sizeof(struct sockaddr_in);
            result = accept(sfd, (struct sockaddr *) addr, (int *) &size);
            if ((result >= 0) || (errno != EINTR))
                return (result);
        }
    }
#ifndef NO_SIGNALS
    if (SSetjmp(gNetTimeoutJmp) != 0) {
        alarm(0);
        (void) SSignal(SIGALRM, (sio_sigproc_t) sigalrm);
        (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
        errno = ETIMEDOUT;
        return (kTimeoutErr);
    }
 
    sigalrm = (vsio_sigproc_t) SSignal(SIGALRM, SIOHandler);
    sigpipe = (vsio_sigproc_t) SSignal(SIGPIPE, SIG_IGN);
    alarm((unsigned int) tlen);
 
    errno = 0;
    do {
        size = sizeof(struct sockaddr_in);
        result = accept(sfd, (struct sockaddr *) addr, (int *) &size);
    } while ((result < 0) && (errno == EINTR));
 
    alarm(0);
    (void) SSignal(SIGALRM, (sio_sigproc_t) sigalrm);
    (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
    return (result);
#else
    return (-1);
#endif
}   /* SAcceptA */

SAcceptS()

int SAcceptS	(	int	sfd,
		struct sockaddr_in * const	addr,
		int	tlen
	)

Definition at line 4 of file SAcceptS.c.

{
    int result;
    fd_set ss;
    struct timeval tv;
    size_t size;
 
    if (tlen <= 0) {
        errno = 0;
        for (;;) {
            size = sizeof(struct sockaddr_in);
            result = accept(sfd, (struct sockaddr *) addr, (int *) &size);
            if ((result >= 0) || (errno != EINTR))
                return (result);
        }
    }
 
    forever {
        errno = 0;
        FD_ZERO(&ss);
        FD_SET(sfd, &ss);
        tv.tv_sec = tlen;
        tv.tv_usec = 0;
        result = select(sfd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, SELECT_TYPE_ARG5 &tv);
        if (result == 1) {
            /* ready */
            break;
        } else if (result == 0) {
            /* timeout */
            errno = ETIMEDOUT;
            SETWSATIMEOUTERR
            return (kTimeoutErr);
        } else if (errno != EINTR) {
            return (-1);
        }
    }
 
    do {
        size = sizeof(struct sockaddr_in);
        result = accept(sfd, (struct sockaddr *) addr, (int *) &size);
    } while ((result < 0) && (errno == EINTR));
 
    return (result);
}   /* SAcceptS */

SBind()

int SBind	(	int	sockfd,
		const int	port,
		const int	nTries,
		const int	reuseFlag
	)

Definition at line 4 of file SBind.c.

{
    unsigned int i;
    int on;
    int onsize;
    struct sockaddr_in localAddr;
 
    localAddr.sin_family = AF_INET;
    localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    localAddr.sin_port = htons((unsigned short) port);
 
    if (reuseFlag != kReUseAddrNo) {
        /* This is mostly so you can quit the server and re-run it
         * again right away.  If you don't do this, the OS may complain
         * that the address is still in use.
         */
        on = 1;
        onsize = (int) sizeof(on);
        (void) setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
            (char *) &on, onsize);
 
#ifdef SO_REUSEPORT
        /* Tells kernel that it's okay to have more
         * than one process originating from this
         * local port.
         */
        on = 1;
        onsize = (int) sizeof(on);
        (void) setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT,
            (char *) &on, onsize);
#endif  /* SO_REUSEPORT */
    }
 
    for (i=1; ; i++) {
        /* Try binding a few times, in case we get Address in Use
         * errors.
         */
        if (bind(sockfd, (struct sockaddr *) &localAddr, sizeof(struct sockaddr_in)) == 0) {
            break;
        }
        if ((int) i == nTries) {
            return (-1);
        }
        /* Give the OS time to clean up the old socket,
         * and then try again.
         */
        sleep(i * 3);
    }
 
    return (0);
}   /* SBind */

Referenced by SNewDatagramServer(), and SNewStreamServer().

SClose()

int SClose	(	int	sfd,
		int	tlen
	)

Definition at line 9 of file SClose.c.

{
#ifndef NO_SIGNALS
    vsio_sigproc_t sigalrm, sigpipe;
 
    if (sfd < 0) {
        errno = EBADF;
        return (-1);
    }
 
    if (tlen < 1) {
        /* Don't time it, shut it down now. */
        if (SetSocketLinger(sfd, 0, 0) == 0) {
            /* Linger disabled, so close()
             * should not block.
             */
            return (closesocket(sfd));
        } else {
            /* This will result in a fd leak,
             * but it's either that or hang forever.
             */
            return (shutdown(sfd, 2));
        }
    }
 
    if (SSetjmp(gNetTimeoutJmp) != 0) {
        alarm(0);
        (void) SSignal(SIGALRM, (sio_sigproc_t) sigalrm);
        (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
        if (SetSocketLinger(sfd, 0, 0) == 0) {
            /* Linger disabled, so close()
             * should not block.
             */
            return closesocket(sfd);
        } else {
            /* This will result in a fd leak,
             * but it's either that or hang forever.
             */
            (void) shutdown(sfd, 2);
        }
        return (-1);
    }
 
    sigalrm = (vsio_sigproc_t) SSignal(SIGALRM, SIOHandler);
    sigpipe = (vsio_sigproc_t) SSignal(SIGPIPE, SIG_IGN);
 
    alarm((unsigned int) tlen);
    for (;;) {
        if (closesocket(sfd) == 0) {
            errno = 0;
            break;
        }
        if (errno != EINTR)
            break;
    }
    alarm(0);
    (void) SSignal(SIGALRM, (sio_sigproc_t) sigalrm);
 
    if ((errno != 0) && (errno != EBADF)) {
        if (SetSocketLinger(sfd, 0, 0) == 0) {
            /* Linger disabled, so close()
             * should not block.
             */
            (void) closesocket(sfd);
        } else {
            /* This will result in a fd leak,
             * but it's either that or hang forever.
             */
            (void) shutdown(sfd, 2);
        }
    }
    (void) SSignal(SIGPIPE, (sio_sigproc_t) sigpipe);
 
    return ((errno == 0) ? 0 : (-1));
#else
    struct timeval tv;
    int result;
    time_t done, now;
    fd_set ss;
 
    if (sfd < 0) {
        errno = EBADF;
        return (-1);
    }
 
    if (tlen < 1) {
        /* Don't time it, shut it down now. */
        if (SetSocketLinger(sfd, 0, 0) == 0) {
            /* Linger disabled, so close()
             * should not block.
             */
            return (closesocket(sfd));
        } else {
            /* This will result in a fd leak,
             * but it's either that or hang forever.
             */
            return (shutdown(sfd, 2));
        }
    }
 
    /* Wait until the socket is ready for writing (usually easy). */
    time(&now);
    done = now + tlen;
 
    forever {
        tlen = done - now;
        if (tlen <= 0) {
            /* timeout */
            if (SetSocketLinger(sfd, 0, 0) == 0) {
                /* Linger disabled, so close()
                 * should not block.
                 */
                (void) closesocket(sfd);
            } else {
                /* This will result in a fd leak,
                 * but it's either that or hang forever.
                 */
                (void) shutdown(sfd, 2);
            }
            errno = ETIMEDOUT;
            return (kTimeoutErr);
        }
 
        errno = 0;
        FD_ZERO(&ss);
        FD_SET(sfd, &ss);
        tv.tv_sec = tlen;
        tv.tv_usec = 0;
        result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG5 &tv);
        if (result == 1) {
            /* ready */
            break;
        } else if (result == 0) {
            /* timeout */
            if (SetSocketLinger(sfd, 0, 0) == 0) {
                /* Linger disabled, so close()
                 * should not block.
                 */
                (void) closesocket(sfd);
            } else {
                /* This will result in a fd leak,
                 * but it's either that or hang forever.
                 */
                (void) shutdown(sfd, 2);
            }
            errno = ETIMEDOUT;
            return (kTimeoutErr);
        } else if (errno != EINTR) {
            /* Error, done. This end may have been shutdown. */
            break;
        }
        time(&now);
    }
 
    /* Wait until the socket is ready for reading. */
    forever {
        tlen = done - now;
        if (tlen <= 0) {
            /* timeout */
            if (SetSocketLinger(sfd, 0, 0) == 0) {
                /* Linger disabled, so close()
                 * should not block.
                 */
                (void) closesocket(sfd);
            } else {
                /* This will result in a fd leak,
                 * but it's either that or hang forever.
                 */
                (void) shutdown(sfd, 2);
            }
            errno = ETIMEDOUT;
            return (kTimeoutErr);
        }
 
        errno = 0;
        FD_ZERO(&ss);
        FD_SET(sfd, &ss);
        tv.tv_sec = tlen;
        tv.tv_usec = 0;
        result = select(sfd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, SELECT_TYPE_ARG5 &tv);
        if (result == 1) {
            /* ready */
            break;
        } else if (result == 0) {
            /* timeout */
            if (SetSocketLinger(sfd, 0, 0) == 0) {
                /* Linger disabled, so close()
                 * should not block.
                 */
                (void) closesocket(sfd);
            } else {
                /* This will result in a fd leak,
                 * but it's either that or hang forever.
                 */
                (void) shutdown(sfd, 2);
            }
            errno = ETIMEDOUT;
            return (kTimeoutErr);
        } else if (errno != EINTR) {
            /* Error, done. This end may have been shutdown. */
            break;
        }
        time(&now);
    }
 
    /* If we get here, close() won't block. */
    return closesocket(sfd);
#endif
}   /* SClose */

Referenced by CloseControlConnection(), CloseDataConnection(), OpenControlConnection(), and ServeOneClient().

SConnect()

int SConnect	(	int	sfd,
		const struct sockaddr_in * const	addr,
		int	tlen
	)

Definition at line 9 of file SConnect.c.

{
#ifndef NO_SIGNALS
    int result;
    vsio_sigproc_t sigalrm;
 
    if (SSetjmp(gNetTimeoutJmp) != 0) {
        alarm(0);
        (void) SSignal(SIGALRM, (sio_sigproc_t) sigalrm);
        errno = ETIMEDOUT;
        return (kTimeoutErr);
    }
 
    sigalrm = (vsio_sigproc_t) SSignal(SIGALRM, SIOHandler);
    alarm((unsigned int) tlen);
 
    errno = 0;
    do {
        result = connect(sfd, (struct sockaddr *) addr,
            (int) sizeof(struct sockaddr_in));
    } while ((result < 0) && (errno == EINTR));
 
    alarm(0);
    (void) SSignal(SIGALRM, (sio_sigproc_t) sigalrm);
    return (result);
#else   /* NO_SIGNALS */
    unsigned long opt;
    fd_set ss, xx;
    struct timeval tv;
    int result;
    int cErrno;
#if defined(WIN32) || defined(_WINDOWS)
    int wsaErrno;
    int soerr, soerrsize;
#else
    int optval;
    int optlen;
#endif
 
    errno = 0;
    if (tlen <= 0) {
        do {
            result = connect(sfd, (struct sockaddr *) addr,
                (int) sizeof(struct sockaddr_in));
            SETERRNO
        } while ((result < 0) && (errno == EINTR));
        return (result);
    }
 
#ifdef FIONBIO
    opt = 1;
    if (ioctlsocket(sfd, FIONBIO, &opt) != 0) {
        SETERRNO
        return (-1);
    }
#else
    if (fcntl(sfd, F_GETFL, &opt) < 0) {
        SETERRNO
        return (-1);
    } else if (fcntl(sfd, F_SETFL, opt | O_NONBLOCK) < 0) {
        SETERRNO
        return (-1);
    }
#endif
 
    errno = 0;
    result = connect(sfd, (struct sockaddr *) addr,
            (int) sizeof(struct sockaddr_in));
    if (result == 0)
        return 0;   /* Already?!? */
 
    if ((result < 0)
#if defined(WIN32) || defined(_WINDOWS)
        && ((wsaErrno = WSAGetLastError()) != WSAEWOULDBLOCK)
        && (wsaErrno != WSAEINPROGRESS)
#else
        && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)
#endif
        ) {
        SETERRNO
        shutdown(sfd, 2);
        return (-1);
    }
    cErrno = errno;
 
    forever {
#if defined(WIN32) || defined(_WINDOWS)
        WSASetLastError(0);
#endif
        FD_ZERO(&ss);
        FD_SET(sfd, &ss);
        xx = ss;
        tv.tv_sec = tlen;
        tv.tv_usec = 0;
        result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, SELECT_TYPE_ARG234 &xx, SELECT_TYPE_ARG5 &tv);
        if (result == 1) {
            /* ready */
            break;
        } else if (result == 0) {
            /* timeout */
            errno = ETIMEDOUT;
            SETWSATIMEOUTERR
            /* Don't bother turning off FIONBIO */
            return (kTimeoutErr);
        } else if (errno != EINTR) {
            /* Don't bother turning off FIONBIO */
            SETERRNO
            return (-1);
        }
    }
 
    /* Supposedly once the select() returns with a writable
     * descriptor, it is connected and we don't need to
     * recall connect().  When select() returns an exception,
     * the connection failed -- we can get the connect error
     * doing a write on the socket which will err out.
     */
 
    if (FD_ISSET(sfd, &xx)) {
#if defined(WIN32) || defined(_WINDOWS)
        errno = 0;
        soerr = 0;
        soerrsize = sizeof(soerr);
        result = getsockopt(sfd, SOL_SOCKET, SO_ERROR, (char *) &soerr, &soerrsize);
        if ((result >= 0) && (soerr != 0)) {
            errno = soerr;
        } else {
            errno = 0;
            (void) send(sfd, "\0", 1, 0);
            SETERRNO
        }
#else
        errno = 0;
        (void) send(sfd, "\0", 1, 0);
#endif
        result = errno;
        shutdown(sfd, 2);
        errno = result;
        return (-1);
    }
 
#if defined(WIN32) || defined(_WINDOWS)
#else
    if (cErrno == EINPROGRESS) {
        /*
         * [from Linux connect(2) page]
         *
         * EINPROGRESS
         *
         * The socket is non-blocking and the connection can­
         * not  be  completed immediately.  It is possible to
         * select(2) or poll(2) for completion  by  selecting
         * the  socket  for  writing.  After select indicates
         * writability,  use  getsockopt(2)   to   read   the
         * SO_ERROR  option  at level SOL_SOCKET to determine
         * whether connect completed  successfully  (SO_ERROR
         * is zero) or unsuccessfully (SO_ERROR is one of the
         * usual error codes  listed  above,  explaining  the
         * reason for the failure).
             */
        optval = 0;
        optlen = sizeof(optval);
        if (getsockopt(sfd, SOL_SOCKET, SO_ERROR, &optval, &optlen) == 0) {
            errno = optval;
            if (errno != 0)
                return (-1);
        }
    }
#endif
 
#ifdef FIONBIO
    opt = 0;
    if (ioctlsocket(sfd, FIONBIO, &opt) != 0) {
        SETERRNO
        shutdown(sfd, 2);
        return (-1);
    }
#else
    if (fcntl(sfd, F_SETFL, opt) < 0) {
        SETERRNO
        shutdown(sfd, 2);
        return (-1);
    }
#endif
 
    return (0);
#endif  /* NO_SIGNALS */
}   /* SConnect */

Referenced by OpenControlConnection(), OpenDataConnection(), and SConnectByName().

SConnectByName()

int SConnectByName	(	int	sfd,
		const char * const	addrStr,
		const int	tlen
	)

Definition at line 4 of file SConnectByName.c.

{
    int result;
    struct sockaddr_in remoteAddr;
 
    if ((result = AddrStrToAddr(addrStr, &remoteAddr, -1)) == 0) {
        result = SConnect(sfd, &remoteAddr, tlen);
    }
    return (result);
}   /* SConnectByName */

SelectR()

int SelectR	(	SelectSetPtr	ssp,
		SelectSetPtr	resultssp
	)

Definition at line 65 of file SSelect.c.

{
    int rc;
 
    do {
        memcpy(resultssp, ssp, sizeof(SelectSet));
        rc = select(resultssp->maxfd, SELECT_TYPE_ARG234 &resultssp->fds, NULL, NULL, SELECT_TYPE_ARG5 &resultssp->timeout);
    } while ((rc < 0) && (errno == EINTR));
    return (rc);
}   /* SelectR */

SelectSetAdd()

void SelectSetAdd	(	SelectSetPtr const	ssp,
		const int	fd
	)

Definition at line 23 of file SSelect.c.

{
    if (fd >= 0) {
        FD_SET(fd, &ssp->fds);
        if (ssp->maxfd < (fd + 1))
            ssp->maxfd = (fd + 1);
        ++ssp->numfds;
    }
}   /* SelectSetAdd */

SelectSetInit()

void SelectSetInit	(	SelectSetPtr const	ssp,
		const double	timeout
	)

Definition at line 4 of file SSelect.c.

{
    double i;
    long l;
 
    /* Inititalize SelectSet, which will clear the fd_set, the
     * timeval, and the maxfd and numfds to 0.
     */
    memset(ssp, 0, sizeof(SelectSet));
    l = (long) timeout;
    i = (double) l;
    ssp->timeout.tv_sec = l;
    ssp->timeout.tv_usec = (long) ((timeout - i) * 1000000.0);
}   /* SelectSetInit */

SelectSetRemove()

void SelectSetRemove	(	SelectSetPtr const	ssp,
		const int	fd
	)

Definition at line 37 of file SSelect.c.

{
    if ((fd >= 0) && (FD_ISSET(fd, &ssp->fds))) {
        FD_CLR(fd, &ssp->fds);
        /* Note that maxfd is left alone, even if maxfd was
         * this one.  That is okay.
         */
        --ssp->numfds;
    }
}   /* SelectSetRemove */

SelectW()

int SelectW	(	SelectSetPtr	ssp,
		SelectSetPtr	resultssp
	)

Definition at line 51 of file SSelect.c.

{
    int rc;
 
    do {
        memcpy(resultssp, ssp, sizeof(SelectSet));
        rc = select(resultssp->maxfd, NULL, SELECT_TYPE_ARG234 &resultssp->fds, NULL, SELECT_TYPE_ARG5 &resultssp->timeout);
    } while ((rc < 0) && (errno == EINTR));
    return (rc);
}   /* SelectW */

Sendto()

int Sendto	(	int	sfd,
		const char * const	buf,
		size_t	size,
		const struct sockaddr_in * const	toAddr
	)

Definition at line 127 of file SSendto.c.

{
    int result;
 
    do {
        result = sendto(sfd, buf, size, 0,
                (struct sockaddr *) toAddr,
                (int) sizeof(struct sockaddr_in));
    } while ((result < 0) && (errno == EINTR));
    return (result);
}   /* Sendto */

SendtoByName()

int SendtoByName	(	int	sfd,
		const char * const	buf,
		size_t	size,
		const char * const	toAddrStr
	)

Definition at line 133 of file SSendtoByName.c.

{
    int result;
    struct sockaddr_in toAddr;
 
    if ((result = AddrStrToAddr(toAddrStr, &toAddr, -1)) < 0) {
        return (result);
    }
 
    do {
        result = sendto(sfd, buf, size, 0,
                (struct sockaddr *) &toAddr,
                (int) sizeof(struct sockaddr_in));
    } while ((result < 0) && (errno == EINTR));
 
    return (result);
}   /* SendtoByName */

SError()

const char * SError

(

int

e

)

Definition at line 141 of file SError.c.

{
#if defined(WIN32) || defined(_WINDOWS)
    const char *cp;
    static char estr[32];
 
    if (e == 0)
        e = WSAGetLastError();
 
    if ((e >= WSABASEERR) && (e < (WSABASEERR + (sizeof(wsaerrlist) / sizeof(const char *))))) {
        return wsaerrlist[e - WSABASEERR];
    }
 
    cp = strerror(e);
    if ((cp == NULL) || (cp[0] == '\0') || (strcmp(cp, "Unknown error") == 0)) {
        wsprintf(estr, "Error #%d", e);
        cp = estr;
    }
    return cp;
#elif defined(HAVE_STRERROR)
    if (e == 0)
        e = errno;
    return strerror(e);
#else
    static char estr[32];
    if (e == 0)
        e = errno;
    sprintf(estr, "Error #%d", e);
    return (estr);
#endif
}   /* SError */

Referenced by UniataAhciStart(), UniataAhciStatus(), UniataAhciWaitCommandReady(), and UniataSataClearErr().

SetSocketBufSize()

int SetSocketBufSize	(	int	,
		size_t	,
		size_t
	)

SetSocketLinger()

int SetSocketLinger	(	const int	,
		const int	,
		const int
	)

Referenced by SClose().

SetSocketNagleAlgorithm()

int SetSocketNagleAlgorithm	(	const int	,
		const int
	)

SIOHandler()

void SIOHandler

(

int

)

Referenced by PRead(), PWrite(), SAcceptA(), SClose(), SConnect(), and UNUSED().

SListen()

int SListen	(	int	sfd,
		int	backlog
	)

Definition at line 60 of file SBind.c.

{
    return (listen(sfd, (unsigned int) backlog));
}   /* SListen */

Referenced by SNewStreamServer().

SNewDatagramClient()

int SNewDatagramClient

(

void

)

Definition at line 19 of file SNew.c.

{
    int sfd;
 
    sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sfd < 0)
        return kSNewFailed;
 
    return (sfd);
}   /* SNewDatagramClient */

SNewDatagramServer()

int SNewDatagramServer	(	const int	port,
		const int	nTries,
		const int	reuseFlag
	)

Definition at line 64 of file SNew.c.

{
    int oerrno;
    int sfd;
 
    sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sfd < 0)
        return kSNewFailed;
 
    if (SBind(sfd, port, nTries, reuseFlag) < 0) {
        oerrno = errno;
        (void) closesocket(sfd);
        errno = oerrno;
        return kSBindFailed;
    }
 
    return (sfd);
}   /* SNewDatagramServer */

SNewStreamClient()

int SNewStreamClient

(

void

)

Definition at line 4 of file SNew.c.

{
    int sfd;
 
    sfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sfd < 0)
        return kSNewFailed;
 
    return (sfd);
}   /* SNewStreamClient */

SNewStreamServer()

int SNewStreamServer	(	const int	port,
		const int	nTries,
		const int	reuseFlag,
		int	listenQueueSize
	)

Definition at line 34 of file SNew.c.

{
    int oerrno;
    int sfd;
 
    sfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sfd < 0)
        return kSNewFailed;
 
    if (SBind(sfd, port, nTries, reuseFlag) < 0) {
        oerrno = errno;
        (void) closesocket(sfd);
        errno = oerrno;
        return kSBindFailed;
    }
 
    if (SListen(sfd, listenQueueSize) < 0) {
        oerrno = errno;
        (void) closesocket(sfd);
        errno = oerrno;
        return kSListenFailed;
    }
 
    return (sfd);
}   /* SNewStreamServer */

Referenced by Server().

SRead()

int SRead	(	int	sfd,
		char * const	buf0,
		size_t	size,
		int	tlen,
		int	retry
	)

Definition at line 118 of file SRead.c.

{
    int nread;
    volatile int nleft;
    char *buf = buf0;
    int tleft;
    time_t done, now;
    fd_set ss;
    struct timeval tv;
    int result, firstRead;
 
    errno = 0;
 
    nleft = (int) size;
    time(&now);
    done = now + tlen;
    firstRead = 1;
 
    forever {
        tleft = (int) (done - now);
        if (tleft < 1) {
            nread = size - nleft;
            if ((nread == 0) || ((retry & (kFullBufferRequired|kFullBufferRequiredExceptLast)) != 0)) {
                nread = kTimeoutErr;
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
            }
            goto done;
        }
 
        if (!firstRead || ((retry & kNoFirstSelect) == 0)) {
            forever {
                errno = 0;
                FD_ZERO(&ss);
                FD_SET(sfd, &ss);
                tv.tv_sec = tlen;
                tv.tv_usec = 0;
                result = select(sfd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, SELECT_TYPE_ARG5 &tv);
                if (result == 1) {
                    /* ready */
                    break;
                } else if (result == 0) {
                    /* timeout */
                    nread = size - nleft;
                    if ((nread > 0) && ((retry & (kFullBufferRequired|kFullBufferRequiredExceptLast)) == 0))
                        return (nread);
                    errno = ETIMEDOUT;
                    SETWSATIMEOUTERR
                        return (kTimeoutErr);
                } else if (errno != EINTR) {
                    return (-1);
                }
            }
            firstRead = 0;
        }
 
#if defined(WIN32) || defined(_WINDOWS)
        nread = recv(sfd, (char *) buf, nleft, 0);
#else
        nread = read(sfd, (char *) buf, nleft);
#endif
 
        if (nread <= 0) {
            if (nread == 0) {
                /* EOF */
                if (retry == ((retry & (kFullBufferRequiredExceptLast)) != 0))
                    nread = size - nleft;
                goto done;
            } else if (errno != EINTR) {
                nread = size - nleft;
                if (nread == 0)
                    nread = -1;
                goto done;
            } else {
                errno = 0;
                nread = 0;
                /* Try again. */
 
                /* Ignore these two lines */
                LIBSIO_USE_VAR(gSioVersion);
                LIBSIO_USE_VAR(gNoSignalsMarker);
            }
        }
        nleft -= nread;
        if ((nleft <= 0) || (((retry & (kFullBufferRequired|kFullBufferRequiredExceptLast)) == 0) && (nleft != (int) size)))
            break;
        buf += nread;
        time(&now);
    }
    nread = size - nleft;
 
done:
    return (nread);
}   /* SRead */

Referenced by FTPGetOneF(), and SReadline().

SReadline()

int SReadline	(	SReadlineInfo *	srl,
		char * const	linebuf,
		size_t	linebufsize
	)

Definition at line 76 of file SReadline.c.

{
    int err;
    char *src;
    char *dst;
    char *dstlim;
    int len;
    int nr;
    int requireEOLN;
    int illegals;
 
    illegals = 0;
    err = 0;
    dst = linebuf;
    dstlim = dst + linebufsize - 1;            /* Leave room for NUL. */
    src = srl->bufPtr;
    requireEOLN = srl->requireEOLN;
    if (requireEOLN)
        dstlim--;
    if (dstlim <= dst)
        return (-1);                /* Buffer too small. */
 
    forever {
        if ((requireEOLN == 0) && (dst >= dstlim))
            break;
        if (src >= srl->bufLim) {
            /* Fill the buffer. */
            if (illegals > 1) {
                /* Probable DOS -- return now and give you an
                 * opportunity to handle bogus input.
                 */
                goto done;
            }
            nr = SRead(srl->fd, srl->buf, srl->bufSizeMax, srl->timeoutLen, 0);
            if (nr == 0) {
                /* EOF. */
                goto done;
            } else if (nr < 0) {
                /* Error. */
                err = nr;
                goto done;
            }
            srl->bufPtr = src = srl->buf;
            srl->bufLim = srl->buf + nr;
        }
        if (*src == '\0') {
            ++src;
            illegals++;
        } else if (*src == '\r') {
            ++src;
            /* If the next character is a \n that is valid,
             * otherwise treat a stray \r as an illegal character.
             */
            if ((src < srl->bufLim) && (*src != '\n'))
                illegals++;
        } else {
            if (*src == '\n') {
                if (dst < dstlim)
                    *dst++ = *src++;
                else
                    src++;
                goto done;
            }
            if (dst < dstlim)
                *dst++ = *src++;
            else
                src++;
        }
    }
 
done:
    srl->bufPtr = src;
    if ((requireEOLN != 0) && (dst != linebuf) && (dst[-1] != '\n'))
        *dst++ = '\n';
    if ((requireEOLN != 0) && (dst == linebuf) && (illegals > 0))
        *dst++ = '\n';
    *dst = '\0';
    len = (int) (dst - linebuf);
    if (err < 0)
        return (err);
    return (len);
}                              /* SReadline */

Referenced by FTPList(), FTPListToMemory2(), GetResponse(), and ServeOneClient().

SRecv()

int SRecv	(	int	sfd,
		char * const	buf0,
		size_t	size,
		int	fl,
		int	tlen,
		int	retry
	)

Definition at line 97 of file SRecv.c.

{
    int nread;
    int nleft;
    char *buf = buf0;
    int tleft;
    time_t done, now;
    fd_set ss;
    struct timeval tv;
    int result;
 
    errno = 0;
 
    nleft = (int) size;
    time(&now);
    done = now + tlen;
    forever {
        tleft = (int) (done - now);
        if (tleft < 1) {
            nread = size - nleft;
            if ((nread == 0) || (retry == kFullBufferRequired)) {
                nread = kTimeoutErr;
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
            }
            goto done;
        }
 
        forever {
            errno = 0;
            FD_ZERO(&ss);
            FD_SET(sfd, &ss);
            tv.tv_sec = tlen;
            tv.tv_usec = 0;
            result = select(sfd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, SELECT_TYPE_ARG5 &tv);
            if (result == 1) {
                /* ready */
                break;
            } else if (result == 0) {
                /* timeout */
                nread = size - nleft;
                if ((nread > 0) && (retry == kFullBufferNotRequired))
                    return (nread);
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
                return (kTimeoutErr);
            } else if (errno != EINTR) {
                return (-1);
            }
        }
 
#if defined(WIN32) || defined(_WINDOWS)
        nread = recv(sfd, (char *) buf, nleft, fl);
#else
        nread = recv(sfd, (char *) buf, nleft, fl);
#endif
 
        if (nread <= 0) {
            if (nread == 0) {
                /* EOF */
                if (retry == kFullBufferRequiredExceptLast)
                    nread = size - nleft;
                goto done;
            } else if (errno != EINTR) {
                nread = size - nleft;
                if (nread == 0)
                    nread = -1;
                goto done;
            } else {
                errno = 0;
                nread = 0;
                /* Try again. */
            }
        }
        nleft -= nread;
        if ((nleft <= 0) || ((retry == 0) && (nleft != (int) size)))
            break;
        buf += nread;
        time(&now);
    }
    nread = size - nleft;
 
done:
    return (nread);
}   /* SRecv */

SRecvfrom()

int SRecvfrom	(	int	sfd,
		char * const	buf,
		size_t	size,
		int	fl,
		struct sockaddr_in * const	fromAddr,
		int	tlen
	)

Definition at line 69 of file SRecvfrom.c.

{
    int nread, tleft;
    fd_set ss;
    struct timeval tv;
    int result;
    time_t done, now;
    int alen;
 
    time(&now);
    done = now + tlen;
    tleft = (int) (done - now);
    nread = 0;
    forever {
        alen = sizeof(struct sockaddr_in);
 
        forever {
            errno = 0;
            FD_ZERO(&ss);
            FD_SET(sfd, &ss);
            tv.tv_sec = tleft;
            tv.tv_usec = 0;
            result = select(sfd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, SELECT_TYPE_ARG5 &tv);
            if (result == 1) {
                /* ready */
                break;
            } else if (result == 0) {
                /* timeout */
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
                return (kTimeoutErr);
            } else if (errno != EINTR) {
                return (-1);
            }
        }
 
        nread = recvfrom(sfd, buf, size, fl,
            (struct sockaddr *) fromAddr, &alen);
 
        if (nread >= 0)
            break;
        if (errno != EINTR)
            break;      /* Fatal error. */
        errno = 0;
        time(&now);
        tleft = (int) (done - now);
        if (tleft < 1) {
            nread = kTimeoutErr;
            errno = ETIMEDOUT;
            SETWSATIMEOUTERR
            break;
        }
    }
 
    return (nread);
}   /* SRecvfrom */

SRecvmsg()

int SRecvmsg	(	int	,
		void * const	,
		int	,
		int
	)

SSend()

int SSend	(	int	sfd,
		char *	buf0,
		size_t	size,
		int	fl,
		int	tlen
	)

Definition at line 90 of file SSend.c.

{
    int nleft;
    char *buf = buf0;
    int nwrote, tleft;
    time_t done, now;
    fd_set ss;
    struct timeval tv;
    int result;
 
    nleft = (int) size;
    time(&now);
    done = now + tlen;
    forever {
        tleft = (int) (done - now);
        if (tleft < 1) {
            nwrote = size - nleft;
            if (nwrote == 0) {
                nwrote = kTimeoutErr;
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
            }
            goto done;
        }
 
 
        /* Unfortunately this doesn't help when the
         * send buffer fills during the time we're
         * writing to it, so you could still be
         * blocked after breaking this loop and starting
         * the write.
         */
 
        forever {
            errno = 0;
            FD_ZERO(&ss);
            FD_SET(sfd, &ss);
            tv.tv_sec = tlen;
            tv.tv_usec = 0;
            result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG5 &tv);
            if (result == 1) {
                /* ready */
                break;
            } else if (result == 0) {
                /* timeout */
                nwrote = size - nleft;
                if (nwrote > 0)
                    return (nwrote);
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
                return (kTimeoutErr);
            } else if (errno != EINTR) {
                return (-1);
            }
        }
 
        nwrote = send(sfd, buf, size, fl);
 
        if (nwrote < 0) {
            if (errno != EINTR) {
                nwrote = size - nleft;
                if (nwrote == 0)
                    nwrote = -1;
                goto done;
            } else {
                errno = 0;
                nwrote = 0;
                /* Try again. */
            }
        }
        nleft -= nwrote;
        if (nleft <= 0)
            break;
        buf += nwrote;
        time(&now);
    }
    nwrote = size - nleft;
 
done:
    return (nwrote);
}   /* SSend */

SSendto()

int SSendto	(	int	sfd,
		const char * const	buf,
		size_t	size,
		int	fl,
		const struct sockaddr_in * const	toAddr,
		int	tlen
	)

Definition at line 68 of file SSendto.c.

{
    int nwrote, tleft;
    time_t done, now;
    fd_set ss;
    struct timeval tv;
    int result;
 
    time(&now);
    done = now + tlen;
    nwrote = 0;
    forever {
        forever {
            if (now >= done) {
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
                return (kTimeoutErr);
            }
            tleft = (int) (done - now);
            errno = 0;
            FD_ZERO(&ss);
            FD_SET(sfd, &ss);
            tv.tv_sec = tleft;
            tv.tv_usec = 0;
            result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG5 &tv);
            if (result == 1) {
                /* ready */
                break;
            } else if (result == 0) {
                /* timeout */
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
                return (kTimeoutErr);
            } else if (errno != EINTR) {
                return (-1);
            }
            time(&now);
        }
 
        nwrote = sendto(sfd, buf, size, fl,
            (struct sockaddr *) toAddr,
            (int) sizeof(struct sockaddr_in));
 
        if (nwrote >= 0)
            break;
        if (errno != EINTR)
            break;      /* Fatal error. */
    }
 
    return (nwrote);
}   /* SSendto */

SSendtoByName()

int SSendtoByName	(	int	sfd,
		const char * const	buf,
		size_t	size,
		int	fl,
		const char * const	toAddrStr,
		int	tlen
	)

Definition at line 73 of file SSendtoByName.c.

{
    int nwrote, tleft;
    time_t done, now;
    fd_set ss;
    struct timeval tv;
    int result;
    struct sockaddr_in toAddr;
 
    if ((result = AddrStrToAddr(toAddrStr, &toAddr, -1)) < 0) {
        return (result);
    }
 
    time(&now);
    done = now + tlen;
    nwrote = 0;
    forever {
        forever {
            if (now >= done) {
                errno = ETIMEDOUT;
                return (kTimeoutErr);
            }
            tleft = (int) (done - now);
            errno = 0;
            FD_ZERO(&ss);
            FD_SET(sfd, &ss);
            tv.tv_sec = tleft;
            tv.tv_usec = 0;
            result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG5 &tv);
            if (result == 1) {
                /* ready */
                break;
            } else if (result == 0) {
                /* timeout */
                errno = ETIMEDOUT;
                return (kTimeoutErr);
            } else if (errno != EINTR) {
                return (-1);
            }
            time(&now);
        }
 
        nwrote = sendto(sfd, buf, size, fl,
            (struct sockaddr *) &toAddr,
            (int) sizeof(struct sockaddr_in));
 
        if (nwrote >= 0)
            break;
        if (errno != EINTR)
            break;      /* Fatal error. */
    }
 
    return (nwrote);
}   /* SSendto */

SWaitUntilReadyForReading()

int SWaitUntilReadyForReading	(	const int	sfd,
		const int	tlen
	)

Definition at line 7 of file SWait.c.

{
    fd_set ss, ss2;
    struct timeval tv;
    int result;
    int tleft;
    time_t now, done;
 
    if (sfd < 0) {
        errno = EBADF;
        return (0);
    }
 
    time(&now);
    done = now + tlen;
    tleft = tlen;
 
    forever {
        FD_ZERO(&ss);
        FD_SET(sfd, &ss);
        ss2 = ss;
        tv.tv_sec = tleft;
        tv.tv_usec = 0;
        result = select(sfd + 1, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG234 &ss2, &tv);
        if (result == 1) {
            /* ready */
            return (1);
        } else if (result < 0) {
            if (errno != EINTR) {
                /* error */
                return (0);
            }
            /* try again */
            time(&now);
            if (now > done) {
                /* timed-out */
                errno = ETIMEDOUT;
                return (0);
            }
            tleft = (int) (done - now);
        } else {
            /* timed-out */
            errno = ETIMEDOUT;
            return (0);
        }
    }
}   /* SWaitUntilReadyForReading */

Referenced by GetResponse().

SWaitUntilReadyForWriting()

int SWaitUntilReadyForWriting	(	const int	sfd,
		const int	tlen
	)

Definition at line 62 of file SWait.c.

{
    fd_set ss, ss2;
    struct timeval tv;
    int result;
    int tleft;
    time_t now, done;
 
    if (sfd < 0) {
        errno = EBADF;
        return (0);
    }
 
    time(&now);
    done = now + tlen;
    tleft = tlen;
 
    forever {
        FD_ZERO(&ss);
        FD_SET(sfd, &ss);
        ss2 = ss;
        tv.tv_sec = tleft;
        tv.tv_usec = 0;
        result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, SELECT_TYPE_ARG234 &ss2, &tv);
        if (result == 1) {
            /* ready */
            return (1);
        } else if (result < 0) {
            if (errno != EINTR) {
                /* error */
                return (0);
            }
            /* try again */
            time(&now);
            if (now > done) {
                /* timed-out */
                errno = ETIMEDOUT;
                return (0);
            }
            tleft = (int) (done - now);
        } else {
            /* timed-out */
            errno = ETIMEDOUT;
            return (0);
        }
    }
}   /* SWaitUntilReadyForWriting */

SWrite()

int SWrite	(	int	sfd,
		const char * const	buf0,
		size_t	size,
		int	tlen,
		int	swopts
	)

Definition at line 90 of file SWrite.c.

{
    int nleft;
    const char *buf = buf0;
    int nwrote, tleft;
    time_t done, now;
    fd_set ss;
    struct timeval tv;
    int result, firstWrite;
 
    nleft = (int) size;
    time(&now);
    done = now + tlen;
    firstWrite = 1;
 
    forever {
        tleft = (int) (done - now);
        if (tleft < 1) {
            nwrote = size - nleft;
            if (nwrote == 0) {
                nwrote = kTimeoutErr;
                errno = ETIMEDOUT;
                SETWSATIMEOUTERR
            }
            goto done;
        }
 
 
        /* Unfortunately this doesn't help when the
         * send buffer fills during the time we're
         * writing to it, so you could still be
         * blocked after breaking this loop and starting
         * the write.
         */
        if (!firstWrite || ((swopts & kNoFirstSelect) == 0)) {
            forever {
                errno = 0;
                FD_ZERO(&ss);
                FD_SET(sfd, &ss);
                tv.tv_sec = tlen;
                tv.tv_usec = 0;
                result = select(sfd + 1, NULL, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG5 &tv);
                if (result == 1) {
                    /* ready */
                    break;
                } else if (result == 0) {
                    /* timeout */
                    nwrote = size - nleft;
                    if (nwrote > 0)
                        return (nwrote);
                    errno = ETIMEDOUT;
                    SETWSATIMEOUTERR
                        return (kTimeoutErr);
                } else if (errno != EINTR) {
                    return (-1);
                }
            }
            firstWrite = 0;
        }
 
#if defined(WIN32) || defined(_WINDOWS)
        nwrote = send(sfd, buf, size, 0);
#else
        nwrote = write(sfd, buf, size);
#endif
 
        if (nwrote < 0) {
            if (errno != EINTR) {
                nwrote = size - nleft;
                if (nwrote == 0)
                    nwrote = -1;
                goto done;
            } else {
                errno = 0;
                nwrote = 0;
                /* Try again. */
            }
        }
        nleft -= nwrote;
        if (nleft <= 0)
            break;
        buf += nwrote;
        time(&now);
    }
    nwrote = size - nleft;
 
done:
    return (nwrote);
}   /* SWrite */

Referenced by FTPPutOneF(), SendCommand(), and ServeOneClient().

Variable Documentation

gLibSio_Uses_Me_To_Quiet_Variable_Unused_Warnings

int gLibSio_Uses_Me_To_Quiet_Variable_Unused_Warnings

extern

Definition at line 4 of file main.c.

SSignal

void(*)(int) SSignal(int signum, void(*handler)(int))	(	int	signum,
		void(*)(int)	handler
	)

Definition at line 237 of file sio.h.

Referenced by PRead(), PWrite(), SAcceptA(), SClose(), SConnect(), and UNUSED().