mirror of
https://github.com/fluencelabs/redis
synced 2025-03-19 09:00:51 +00:00
e7b34e8dc3
Change the getaddrinfo(3) hints family from AF_INET to AF_UNSPEC to allow resolution of IPv6 addresses as well as IPv4 addresses. The function will return the IP address of whichever address family is preferenced by the operating system. Most current operating systems will preference AF_INET6 over AF_INET. Unfortunately without attempting to establish a connection to the remote address we can't know if the host is capable of using the returned IP address. It might be desirable to have anetResolve accept an additional argument specifying the AF_INET/AF_INET6 address the caller would like to receive. Currently though it does not appear as though the anetResolve function is ever used within Redis.
487 lines
14 KiB
C
487 lines
14 KiB
C
/* anet.c -- Basic TCP socket stuff made a bit less boring
|
|
*
|
|
* Copyright (c) 2006-2012, 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/stat.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 non-blocking.
|
|
* 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;
|
|
}
|
|
|
|
/* Set TCP keep alive option to detect dead peers. The interval option
|
|
* is only used for Linux as we are using Linux-specific APIs to set
|
|
* the probe send time, interval, and count. */
|
|
int anetKeepAlive(char *err, int fd, int interval)
|
|
{
|
|
int val = 1;
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1)
|
|
{
|
|
anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno));
|
|
return ANET_ERR;
|
|
}
|
|
|
|
#ifdef __linux__
|
|
/* Default settings are more or less garbage, with the keepalive time
|
|
* set to 7200 by default on Linux. Modify settings to make the feature
|
|
* actually useful. */
|
|
|
|
/* Send first probe after interval. */
|
|
val = interval;
|
|
if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) {
|
|
anetSetError(err, "setsockopt TCP_KEEPIDLE: %s\n", strerror(errno));
|
|
return ANET_ERR;
|
|
}
|
|
|
|
/* Send next probes after the specified interval. Note that we set the
|
|
* delay as interval / 3, as we send three probes before detecting
|
|
* an error (see the next setsockopt call). */
|
|
val = interval/3;
|
|
if (val == 0) val = 1;
|
|
if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) {
|
|
anetSetError(err, "setsockopt TCP_KEEPINTVL: %s\n", strerror(errno));
|
|
return ANET_ERR;
|
|
}
|
|
|
|
/* Consider the socket in error state after three we send three ACK
|
|
* probes without getting a reply. */
|
|
val = 3;
|
|
if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) {
|
|
anetSetError(err, "setsockopt TCP_KEEPCNT: %s\n", strerror(errno));
|
|
return ANET_ERR;
|
|
}
|
|
#endif
|
|
|
|
return ANET_OK;
|
|
}
|
|
|
|
static int anetSetTcpNoDelay(char *err, int fd, int val)
|
|
{
|
|
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) == -1)
|
|
{
|
|
anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno));
|
|
return ANET_ERR;
|
|
}
|
|
return ANET_OK;
|
|
}
|
|
|
|
int anetEnableTcpNoDelay(char *err, int fd)
|
|
{
|
|
return anetSetTcpNoDelay(err, fd, 1);
|
|
}
|
|
|
|
int anetDisableTcpNoDelay(char *err, int fd)
|
|
{
|
|
return anetSetTcpNoDelay(err, fd, 0);
|
|
}
|
|
|
|
|
|
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, size_t ipbuf_len)
|
|
{
|
|
struct addrinfo hints, *info;
|
|
int rv;
|
|
|
|
memset(&hints,0,sizeof(hints));
|
|
hints.ai_family = AF_UNSPEC;
|
|
hints.ai_socktype = SOCK_STREAM; /* specify socktype to avoid dups */
|
|
|
|
if ((rv = getaddrinfo(host, NULL, &hints, &info)) != 0) {
|
|
anetSetError(err, "%s", gai_strerror(rv));
|
|
return ANET_ERR;
|
|
}
|
|
if (info->ai_family == AF_INET) {
|
|
struct sockaddr_in *sa = (struct sockaddr_in *)info->ai_addr;
|
|
inet_ntop(AF_INET, &(sa->sin_addr), ipbuf, ipbuf_len);
|
|
} else {
|
|
struct sockaddr_in6 *sa = (struct sockaddr_in6 *)info->ai_addr;
|
|
inet_ntop(AF_INET6, &(sa->sin6_addr), ipbuf, ipbuf_len);
|
|
}
|
|
|
|
freeaddrinfo(info);
|
|
return ANET_OK;
|
|
}
|
|
|
|
static int anetSetReuseAddr(char *err, int fd) {
|
|
int yes = 1;
|
|
/* Make sure connection-intensive things like the redis benckmark
|
|
* will be able to close/open sockets a zillion of times */
|
|
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
|
|
anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
|
|
return ANET_ERR;
|
|
}
|
|
return ANET_OK;
|
|
}
|
|
|
|
static int anetCreateSocket(char *err, int domain) {
|
|
int s;
|
|
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 benchmark
|
|
* will be able to close/open sockets a zillion of times */
|
|
if (anetSetReuseAddr(err,s) == ANET_ERR) {
|
|
close(s);
|
|
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, rv;
|
|
char _port[6]; /* strlen("65535"); */
|
|
struct addrinfo hints, *servinfo, *p;
|
|
|
|
snprintf(_port,6,"%d",port);
|
|
memset(&hints,0,sizeof(hints));
|
|
hints.ai_family = AF_INET;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
if ((rv = getaddrinfo(addr,_port,&hints,&servinfo)) != 0) {
|
|
anetSetError(err, "%s", gai_strerror(rv));
|
|
return ANET_ERR;
|
|
}
|
|
for (p = servinfo; p != NULL; p = p->ai_next) {
|
|
if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)
|
|
continue;
|
|
|
|
/* if we set err then goto cleanup, otherwise next */
|
|
if (anetSetReuseAddr(err,s) == ANET_ERR) {
|
|
goto error;
|
|
}
|
|
if (flags & ANET_CONNECT_NONBLOCK) {
|
|
if (anetNonBlock(err,s) != ANET_OK)
|
|
goto error;
|
|
}
|
|
if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {
|
|
if (errno == EINPROGRESS &&
|
|
flags & ANET_CONNECT_NONBLOCK)
|
|
goto end;
|
|
|
|
close(s);
|
|
continue;
|
|
}
|
|
|
|
/* break with the socket */
|
|
goto end;
|
|
}
|
|
if (p == NULL) {
|
|
anetSetError(err, "creating socket: %s", strerror(errno));
|
|
goto error;
|
|
}
|
|
|
|
error:
|
|
s = ANET_ERR;
|
|
end:
|
|
freeaddrinfo(servinfo);
|
|
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;
|
|
}
|
|
|
|
/* Use a backlog of 512 entries. We pass 511 to the listen() call because
|
|
* the kernel does: backlogsize = roundup_pow_of_two(backlogsize + 1);
|
|
* which will thus give us a backlog of 512 entries */
|
|
if (listen(s, 511) == -1) {
|
|
anetSetError(err, "listen: %s", strerror(errno));
|
|
close(s);
|
|
return ANET_ERR;
|
|
}
|
|
return ANET_OK;
|
|
}
|
|
|
|
int anetTcpServer(char *err, int port, char *bindaddr)
|
|
{
|
|
int s, rv;
|
|
char _port[6]; /* strlen("65535") */
|
|
struct addrinfo hints, *servinfo, *p;
|
|
|
|
snprintf(_port,6,"%d",port);
|
|
memset(&hints,0,sizeof(hints));
|
|
hints.ai_family = AF_INET;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
hints.ai_flags = AI_PASSIVE; /* No effect if bindaddr != NULL */
|
|
|
|
if ((rv = getaddrinfo(bindaddr,_port,&hints,&servinfo)) != 0) {
|
|
anetSetError(err, "%s", gai_strerror(rv));
|
|
return ANET_ERR;
|
|
}
|
|
for (p = servinfo; p != NULL; p = p->ai_next) {
|
|
if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)
|
|
continue;
|
|
|
|
if (anetListen(err,s,p->ai_addr,p->ai_addrlen) == ANET_ERR)
|
|
goto error; /* could continue here? */
|
|
goto end;
|
|
}
|
|
if (p == NULL) {
|
|
anetSetError(err, "unable to bind socket");
|
|
goto error;
|
|
}
|
|
|
|
error:
|
|
s = ANET_ERR;
|
|
end:
|
|
freeaddrinfo(servinfo);
|
|
return s;
|
|
}
|
|
|
|
int anetUnixServer(char *err, char *path, mode_t perm)
|
|
{
|
|
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;
|
|
if (perm)
|
|
chmod(sa.sun_path, perm);
|
|
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, size_t ip_len, 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) inet_ntop(sa.sin_family,(void*)&(sa.sin_addr),ip,ip_len);
|
|
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, size_t ip_len, int *port) {
|
|
struct sockaddr_in sa;
|
|
socklen_t salen = sizeof(sa);
|
|
|
|
if (getpeername(fd,(struct sockaddr*)&sa,&salen) == -1) {
|
|
*port = 0;
|
|
ip[0] = '?';
|
|
ip[1] = '\0';
|
|
return -1;
|
|
}
|
|
if (ip) inet_ntop(sa.sin_family,(void*)&(sa.sin_addr),ip,ip_len);
|
|
if (port) *port = ntohs(sa.sin_port);
|
|
return 0;
|
|
}
|
|
|
|
int anetSockName(int fd, char *ip, size_t ip_len, int *port) {
|
|
struct sockaddr_in sa;
|
|
socklen_t salen = sizeof(sa);
|
|
|
|
if (getsockname(fd,(struct sockaddr*)&sa,&salen) == -1) {
|
|
*port = 0;
|
|
ip[0] = '?';
|
|
ip[1] = '\0';
|
|
return -1;
|
|
}
|
|
if (ip) inet_ntop(sa.sin_family,(void*)&(sa.sin_addr),ip,ip_len);
|
|
if (port) *port = ntohs(sa.sin_port);
|
|
return 0;
|
|
}
|