[redis.git] / src / anet.c

/* anet.c -- Basic TCP socket stuff made a bit less boring
 *
 * Copyright (c) 2006-2010, Salvatore Sanfilippo <antirez at gmail dot com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the name of Redis nor the names of its contributors may be used
 *     to endorse or promote products derived from this software without
 *     specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "fmacros.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>

#include "anet.h"

static void anetSetError(char *err, const char *fmt, ...)
{
    va_list ap;

    if (!err) return;
    va_start(ap, fmt);
    vsnprintf(err, ANET_ERR_LEN, fmt, ap);
    va_end(ap);
}

int anetNonBlock(char *err, int fd)
{
    int flags;

    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(fd, F_GETFL)) == -1) {
        anetSetError(err, "fcntl(F_GETFL): %s", strerror(errno));
        return ANET_ERR;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        anetSetError(err, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

int anetTcpNoDelay(char *err, int fd)
{
    int yes = 1;
    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1)
    {
        anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

int anetSetSendBuffer(char *err, int fd, int buffsize)
{
    if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buffsize, sizeof(buffsize)) == -1)
    {
        anetSetError(err, "setsockopt SO_SNDBUF: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

int anetTcpKeepAlive(char *err, int fd)
{
    int yes = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) == -1) {
        anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

int anetResolve(char *err, char *host, char *ipbuf)
{
    struct sockaddr_in sa;

    sa.sin_family = AF_INET;
    if (inet_aton(host, &sa.sin_addr) == 0) {
        struct hostent *he;

        he = gethostbyname(host);
        if (he == NULL) {
            anetSetError(err, "can't resolve: %s", host);
            return ANET_ERR;
        }
        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
    }
    strcpy(ipbuf,inet_ntoa(sa.sin_addr));
    return ANET_OK;
}

static int anetCreateSocket(char *err, int domain) {
    int s, on = 1;
    if ((s = socket(domain, SOCK_STREAM, 0)) == -1) {
        anetSetError(err, "creating socket: %s", strerror(errno));
        return ANET_ERR;
    }

    /* Make sure connection-intensive things like the redis benckmark
     * will be able to close/open sockets a zillion of times */
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
        anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
        return ANET_ERR;
    }
    return s;
}

#define ANET_CONNECT_NONE 0
#define ANET_CONNECT_NONBLOCK 1
static int anetTcpGenericConnect(char *err, char *addr, int port, int flags)
{
    int s;
    struct sockaddr_in sa;

    if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
        return ANET_ERR;

    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
    if (inet_aton(addr, &sa.sin_addr) == 0) {
        struct hostent *he;

        he = gethostbyname(addr);
        if (he == NULL) {
            anetSetError(err, "can't resolve: %s", addr);
            close(s);
            return ANET_ERR;
        }
        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
    }
    if (flags & ANET_CONNECT_NONBLOCK) {
        if (anetNonBlock(err,s) != ANET_OK)
            return ANET_ERR;
    }
    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS &&
            flags & ANET_CONNECT_NONBLOCK)
            return s;

        anetSetError(err, "connect: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return s;
}

int anetTcpConnect(char *err, char *addr, int port)
{
    return anetTcpGenericConnect(err,addr,port,ANET_CONNECT_NONE);
}

int anetTcpNonBlockConnect(char *err, char *addr, int port)
{
    return anetTcpGenericConnect(err,addr,port,ANET_CONNECT_NONBLOCK);
}

int anetUnixGenericConnect(char *err, char *path, int flags)
{
    int s;
    struct sockaddr_un sa;

    if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
        return ANET_ERR;

    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (flags & ANET_CONNECT_NONBLOCK) {
        if (anetNonBlock(err,s) != ANET_OK)
            return ANET_ERR;
    }
    if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) == -1) {
        if (errno == EINPROGRESS &&
            flags & ANET_CONNECT_NONBLOCK)
            return s;

        anetSetError(err, "connect: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return s;
}

int anetUnixConnect(char *err, char *path)
{
    return anetUnixGenericConnect(err,path,ANET_CONNECT_NONE);
}

int anetUnixNonBlockConnect(char *err, char *path)
{
    return anetUnixGenericConnect(err,path,ANET_CONNECT_NONBLOCK);
}

/* Like read(2) but make sure 'count' is read before to return
 * (unless error or EOF condition is encountered) */
int anetRead(int fd, char *buf, int count)
{
    int nread, totlen = 0;
    while(totlen != count) {
        nread = read(fd,buf,count-totlen);
        if (nread == 0) return totlen;
        if (nread == -1) return -1;
        totlen += nread;
        buf += nread;
    }
    return totlen;
}

/* Like write(2) but make sure 'count' is read before to return
 * (unless error is encountered) */
int anetWrite(int fd, char *buf, int count)
{
    int nwritten, totlen = 0;
    while(totlen != count) {
        nwritten = write(fd,buf,count-totlen);
        if (nwritten == 0) return totlen;
        if (nwritten == -1) return -1;
        totlen += nwritten;
        buf += nwritten;
    }
    return totlen;
}

static int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len) {
    if (bind(s,sa,len) == -1) {
        anetSetError(err, "bind: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    if (listen(s, 511) == -1) { /* the magic 511 constant is from nginx */
        anetSetError(err, "listen: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return ANET_OK;
}

int anetTcpServer(char *err, int port, char *bindaddr)
{
    int s;
    struct sockaddr_in sa;

    if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
        return ANET_ERR;

    memset(&sa,0,sizeof(sa));
    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
    sa.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bindaddr && inet_aton(bindaddr, &sa.sin_addr) == 0) {
        anetSetError(err, "invalid bind address");
        close(s);
        return ANET_ERR;
    }
    if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
        return ANET_ERR;
    return s;
}

int anetUnixServer(char *err, char *path)
{
    int s;
    struct sockaddr_un sa;

    if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
        return ANET_ERR;

    memset(&sa,0,sizeof(sa));
    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
        return ANET_ERR;
    return s;
}

static int anetGenericAccept(char *err, int s, struct sockaddr *sa, socklen_t *len) {
    int fd;
    while(1) {
        fd = accept(s,sa,len);
        if (fd == -1) {
            if (errno == EINTR)
                continue;
            else {
                anetSetError(err, "accept: %s", strerror(errno));
                return ANET_ERR;
            }
        }
        break;
    }
    return fd;
}

int anetTcpAccept(char *err, int s, char *ip, int *port) {
    int fd;
    struct sockaddr_in sa;
    socklen_t salen = sizeof(sa);
    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
        return ANET_ERR;

    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
    if (port) *port = ntohs(sa.sin_port);
    return fd;
}

int anetUnixAccept(char *err, int s) {
    int fd;
    struct sockaddr_un sa;
    socklen_t salen = sizeof(sa);
    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
        return ANET_ERR;

    return fd;
}

int anetPeerToString(int fd, char *ip, int *port) {
    struct sockaddr_in sa;
    socklen_t salen = sizeof(sa);

    if (getpeername(fd,(struct sockaddr*)&sa,&salen) == -1) return -1;
    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
    if (port) *port = ntohs(sa.sin_port);
    return 0;
}
Commit	Line	Data
ed9b544e	1	/* anet.c -- Basic TCP socket stuff made a bit less boring
ed9b544e	2	*
12d090d2	3	* Copyright (c) 2006-2010, Salvatore Sanfilippo <antirez at gmail dot com>
ed9b544e	4	* All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions are met:
	8	*
	9	* * Redistributions of source code must retain the above copyright notice,
	10	* this list of conditions and the following disclaimer.
	11	* * Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* * Neither the name of Redis nor the names of its contributors may be used
	15	* to endorse or promote products derived from this software without
	16	* specific prior written permission.
	17	*
	18	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	19	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	20	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	21	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	22	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	23	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	25	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	26	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	27	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	28	* POSSIBILITY OF SUCH DAMAGE.
	29	*/
	30
23d4709d	31	#include "fmacros.h"
23d4709d	32
ed9b544e	33	#include <sys/types.h>
ed9b544e	34	#include <sys/socket.h>
c61e6925	35	#include <sys/un.h>
ed9b544e	36	#include <netinet/in.h>
	37	#include <netinet/tcp.h>
	38	#include <arpa/inet.h>
	39	#include <unistd.h>
	40	#include <fcntl.h>
	41	#include <string.h>
	42	#include <netdb.h>
	43	#include <errno.h>
	44	#include <stdarg.h>
	45	#include <stdio.h>
	46
	47	#include "anet.h"
	48
	49	static void anetSetError(char err, const char fmt, ...)
	50	{
	51	va_list ap;
	52
	53	if (!err) return;
	54	va_start(ap, fmt);
	55	vsnprintf(err, ANET_ERR_LEN, fmt, ap);
	56	va_end(ap);
	57	}
	58
	59	int anetNonBlock(char *err, int fd)
	60	{
	61	int flags;
	62
	63	/* Set the socket nonblocking.
	64	* Note that fcntl(2) for F_GETFL and F_SETFL can't be
	65	* interrupted by a signal. */
	66	if ((flags = fcntl(fd, F_GETFL)) == -1) {
9b1d738f	67	anetSetError(err, "fcntl(F_GETFL): %s", strerror(errno));
ed9b544e	68	return ANET_ERR;
	69	}
	70	if (fcntl(fd, F_SETFL, flags \| O_NONBLOCK) == -1) {
9b1d738f	71	anetSetError(err, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
ed9b544e	72	return ANET_ERR;
	73	}
	74	return ANET_OK;
	75	}
	76
	77	int anetTcpNoDelay(char *err, int fd)
	78	{
	79	int yes = 1;
	80	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1)
	81	{
9b1d738f	82	anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno));
ed9b544e	83	return ANET_ERR;
	84	}
	85	return ANET_OK;
	86	}
	87
	88	int anetSetSendBuffer(char *err, int fd, int buffsize)
	89	{
	90	if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buffsize, sizeof(buffsize)) == -1)
	91	{
9b1d738f	92	anetSetError(err, "setsockopt SO_SNDBUF: %s", strerror(errno));
ed9b544e	93	return ANET_ERR;
	94	}
	95	return ANET_OK;
	96	}
	97
	98	int anetTcpKeepAlive(char *err, int fd)
	99	{
	100	int yes = 1;
	101	if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) == -1) {
9b1d738f	102	anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno));
ed9b544e	103	return ANET_ERR;
	104	}
	105	return ANET_OK;
	106	}
	107
	108	int anetResolve(char err, char host, char *ipbuf)
	109	{
	110	struct sockaddr_in sa;
	111
	112	sa.sin_family = AF_INET;
	113	if (inet_aton(host, &sa.sin_addr) == 0) {
	114	struct hostent *he;
	115
	116	he = gethostbyname(host);
	117	if (he == NULL) {
9b1d738f	118	anetSetError(err, "can't resolve: %s", host);
ed9b544e	119	return ANET_ERR;
	120	}
	121	memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
	122	}
	123	strcpy(ipbuf,inet_ntoa(sa.sin_addr));
	124	return ANET_OK;
	125	}
	126
704bd093 PN	127	static int anetCreateSocket(char *err, int domain) {
	128	int s, on = 1;
	129	if ((s = socket(domain, SOCK_STREAM, 0)) == -1) {
9b1d738f	130	anetSetError(err, "creating socket: %s", strerror(errno));
704bd093 PN	131	return ANET_ERR;
	132	}
	133
	134	/* Make sure connection-intensive things like the redis benckmark
	135	* will be able to close/open sockets a zillion of times */
	136	if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
9b1d738f	137	anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
704bd093 PN	138	return ANET_ERR;
	139	}
	140	return s;
	141	}
	142
ed9b544e	143	#define ANET_CONNECT_NONE 0
	144	#define ANET_CONNECT_NONBLOCK 1
	145	static int anetTcpGenericConnect(char err, char addr, int port, int flags)
	146	{
704bd093	147	int s;
ed9b544e	148	struct sockaddr_in sa;
ed9b544e	149
704bd093	150	if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
ed9b544e	151	return ANET_ERR;
ed9b544e	152
	153	sa.sin_family = AF_INET;
	154	sa.sin_port = htons(port);
	155	if (inet_aton(addr, &sa.sin_addr) == 0) {
	156	struct hostent *he;
	157
	158	he = gethostbyname(addr);
	159	if (he == NULL) {
9b1d738f	160	anetSetError(err, "can't resolve: %s", addr);
ed9b544e	161	close(s);
	162	return ANET_ERR;
	163	}
	164	memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
	165	}
	166	if (flags & ANET_CONNECT_NONBLOCK) {
	167	if (anetNonBlock(err,s) != ANET_OK)
	168	return ANET_ERR;
	169	}
	170	if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
	171	if (errno == EINPROGRESS &&
	172	flags & ANET_CONNECT_NONBLOCK)
	173	return s;
	174
9b1d738f	175	anetSetError(err, "connect: %s", strerror(errno));
ed9b544e	176	close(s);
	177	return ANET_ERR;
	178	}
	179	return s;
	180	}
	181
	182	int anetTcpConnect(char err, char addr, int port)
	183	{
	184	return anetTcpGenericConnect(err,addr,port,ANET_CONNECT_NONE);
	185	}
	186
	187	int anetTcpNonBlockConnect(char err, char addr, int port)
	188	{
	189	return anetTcpGenericConnect(err,addr,port,ANET_CONNECT_NONBLOCK);
	190	}
	191
c61e6925 PN	192	int anetUnixGenericConnect(char err, char path, int flags)
	193	{
	194	int s;
	195	struct sockaddr_un sa;
	196
704bd093	197	if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
c61e6925	198	return ANET_ERR;
704bd093	199
c61e6925 PN	200	sa.sun_family = AF_LOCAL;
	201	strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
	202	if (flags & ANET_CONNECT_NONBLOCK) {
	203	if (anetNonBlock(err,s) != ANET_OK)
	204	return ANET_ERR;
	205	}
	206	if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) == -1) {
	207	if (errno == EINPROGRESS &&
	208	flags & ANET_CONNECT_NONBLOCK)
	209	return s;
	210
9b1d738f	211	anetSetError(err, "connect: %s", strerror(errno));
c61e6925 PN	212	close(s);
	213	return ANET_ERR;
	214	}
	215	return s;
	216	}
	217
	218	int anetUnixConnect(char err, char path)
	219	{
	220	return anetUnixGenericConnect(err,path,ANET_CONNECT_NONE);
	221	}
	222
	223	int anetUnixNonBlockConnect(char err, char path)
	224	{
	225	return anetUnixGenericConnect(err,path,ANET_CONNECT_NONBLOCK);
	226	}
	227
ed9b544e	228	/* Like read(2) but make sure 'count' is read before to return
ed9b544e	229	* (unless error or EOF condition is encountered) */
a4d1ba9a	230	int anetRead(int fd, char *buf, int count)
ed9b544e	231	{
	232	int nread, totlen = 0;
	233	while(totlen != count) {
	234	nread = read(fd,buf,count-totlen);
	235	if (nread == 0) return totlen;
	236	if (nread == -1) return -1;
	237	totlen += nread;
	238	buf += nread;
	239	}
	240	return totlen;
	241	}
	242
	243	/* Like write(2) but make sure 'count' is read before to return
	244	* (unless error is encountered) */
a4d1ba9a	245	int anetWrite(int fd, char *buf, int count)
ed9b544e	246	{
	247	int nwritten, totlen = 0;
	248	while(totlen != count) {
	249	nwritten = write(fd,buf,count-totlen);
	250	if (nwritten == 0) return totlen;
	251	if (nwritten == -1) return -1;
	252	totlen += nwritten;
	253	buf += nwritten;
	254	}
	255	return totlen;
	256	}
	257
704bd093 PN	258	static int anetListen(char err, int s, struct sockaddr sa, socklen_t len) {
704bd093 PN	259	if (bind(s,sa,len) == -1) {
9b1d738f	260	anetSetError(err, "bind: %s", strerror(errno));
704bd093	261	close(s);
ed9b544e	262	return ANET_ERR;
ed9b544e	263	}
704bd093	264	if (listen(s, 511) == -1) { /* the magic 511 constant is from nginx */
9b1d738f	265	anetSetError(err, "listen: %s", strerror(errno));
ed9b544e	266	close(s);
	267	return ANET_ERR;
	268	}
704bd093 PN	269	return ANET_OK;
	270	}
	271
	272	int anetTcpServer(char err, int port, char bindaddr)
	273	{
	274	int s;
	275	struct sockaddr_in sa;
	276
	277	if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
	278	return ANET_ERR;
	279
ed9b544e	280	memset(&sa,0,sizeof(sa));
	281	sa.sin_family = AF_INET;
	282	sa.sin_port = htons(port);
	283	sa.sin_addr.s_addr = htonl(INADDR_ANY);
704bd093	284	if (bindaddr && inet_aton(bindaddr, &sa.sin_addr) == 0) {
9b1d738f	285	anetSetError(err, "invalid bind address");
ed9b544e	286	close(s);
	287	return ANET_ERR;
	288	}
704bd093	289	if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
ed9b544e	290	return ANET_ERR;
ed9b544e	291	return s;
	292	}
	293
c61e6925 PN	294	int anetUnixServer(char err, char path)
	295	{
	296	int s;
	297	struct sockaddr_un sa;
	298
704bd093	299	if ((s = anetCreateSocket(err,AF_LOCAL)) == ANET_ERR)
c61e6925	300	return ANET_ERR;
704bd093	301
c61e6925 PN	302	memset(&sa,0,sizeof(sa));
	303	sa.sun_family = AF_LOCAL;
	304	strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
704bd093	305	if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
c61e6925	306	return ANET_ERR;
c61e6925 PN	307	return s;
	308	}
	309
ab17b909	310	static int anetGenericAccept(char err, int s, struct sockaddr sa, socklen_t *len) {
ed9b544e	311	int fd;
ed9b544e	312	while(1) {
ab17b909	313	fd = accept(s,sa,len);
ed9b544e	314	if (fd == -1) {
	315	if (errno == EINTR)
	316	continue;
	317	else {
9b1d738f	318	anetSetError(err, "accept: %s", strerror(errno));
ed9b544e	319	return ANET_ERR;
	320	}
	321	}
	322	break;
	323	}
ab17b909 PN	324	return fd;
	325	}
	326
	327	int anetTcpAccept(char err, int s, char ip, int *port) {
	328	int fd;
	329	struct sockaddr_in sa;
	330	socklen_t salen = sizeof(sa);
	331	if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
	332	return ANET_ERR;
	333
ed9b544e	334	if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
	335	if (port) *port = ntohs(sa.sin_port);
	336	return fd;
	337	}
ab17b909	338
4fe83b55	339	int anetUnixAccept(char *err, int s) {
ab17b909 PN	340	int fd;
	341	struct sockaddr_un sa;
	342	socklen_t salen = sizeof(sa);
	343	if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
	344	return ANET_ERR;
	345
ab17b909 PN	346	return fd;
ab17b909 PN	347	}
3cd12b56	348
	349	int anetPeerToString(int fd, char ip, int port) {
	350	struct sockaddr_in sa;
	351	socklen_t salen = sizeof(sa);
	352
	353	if (getpeername(fd,(struct sockaddr*)&sa,&salen) == -1) return -1;
	354	if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
	355	if (port) *port = ntohs(sa.sin_port);
	356	return 0;
	357	}