d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename tcp4 to tcp in preparation for IPv6 support.

Browse Source 
MFC after:	3 weeks
This commit is contained in:
Pawel Jakub Dawidek 2011-05-20 11:09:02 +00:00
parent 933728eea2
commit bdbd046b35
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=222116
2 changed files with 93 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sbin/hastd/Makefile
View File

@ -20,7 +20,7 @@ SRCS+= y.tab.h
MAN= hastd.8 hast.conf.5 MAN= hastd.8 hast.conf.5
NO_WFORMAT= NO_WFORMAT=
CFLAGS+=-DPROTO_TCP4_DEFAULT_PORT=8457 CFLAGS+=-DPROTO_TCP_DEFAULT_PORT=8457
CFLAGS+=-I${.CURDIR} CFLAGS+=-I${.CURDIR}
CFLAGS+=-DINET CFLAGS+=-DINET
.if ${MK_INET6_SUPPORT} != "no" .if ${MK_INET6_SUPPORT} != "no"

184
sbin/hastd/proto_tcp.c
View File

@ -51,19 +51,19 @@ __FBSDID("$FreeBSD$");
#include "proto_impl.h" #include "proto_impl.h"
#include "subr.h" #include "subr.h"
#define TCP4_CTX_MAGIC 0x7c441c #define TCP_CTX_MAGIC 0x7c441c
struct tcp4_ctx { struct tcp_ctx {
int tc_magic; int tc_magic;
struct sockaddr_in tc_sin; struct sockaddr_in tc_sin;
int tc_fd; int tc_fd;
int tc_side; int tc_side;
#define TCP4_SIDE_CLIENT 0 #define TCP_SIDE_CLIENT 0
#define TCP4_SIDE_SERVER_LISTEN 1 #define TCP_SIDE_SERVER_LISTEN 1
#define TCP4_SIDE_SERVER_WORK 2 #define TCP_SIDE_SERVER_WORK 2
}; };
static int tcp4_connect_wait(void *ctx, int timeout); static int tcp_connect_wait(void *ctx, int timeout);
static void tcp4_close(void *ctx); static void tcp_close(void *ctx);
static in_addr_t static in_addr_t
str2ip(const char *str) str2ip(const char *str)
@ -114,7 +114,7 @@ numfromstr(const char *str, intmax_t minnum, intmax_t maxnum, intmax_t *nump)
} }
static int static int
tcp4_addr(const char *addr, int defport, struct sockaddr_in *sinp) tcp_addr(const char *addr, int defport, struct sockaddr_in *sinp)
{ {
char iporhost[MAXHOSTNAMELEN]; char iporhost[MAXHOSTNAMELEN];
const char *pp; const char *pp;
@ -124,13 +124,13 @@ tcp4_addr(const char *addr, int defport, struct sockaddr_in *sinp)
if (addr == NULL) if (addr == NULL)
return (-1); return (-1);
if (strncasecmp(addr, "tcp4://", 7) == 0) if (strncasecmp(addr, "tcp://", 7) == 0)
addr += 7; addr += 7;
else if (strncasecmp(addr, "tcp://", 6) == 0) else if (strncasecmp(addr, "tcp://", 6) == 0)
addr += 6; addr += 6;
else { else {
/* /*
* Because TCP4 is the default assume IP or host is given without * Because TCP is the default assume IP or host is given without
* prefix. * prefix.
*/ */
} }
@ -170,14 +170,14 @@ tcp4_addr(const char *addr, int defport, struct sockaddr_in *sinp)
} }
static int static int
tcp4_setup_new(const char *addr, int side, void **ctxp) tcp_setup_new(const char *addr, int side, void **ctxp)
{ {
struct tcp4_ctx *tctx; struct tcp_ctx *tctx;
int ret, nodelay; int ret, nodelay;
PJDLOG_ASSERT(addr != NULL); PJDLOG_ASSERT(addr != NULL);
PJDLOG_ASSERT(side == TCP4_SIDE_CLIENT || PJDLOG_ASSERT(side == TCP_SIDE_CLIENT ||
side == TCP4_SIDE_SERVER_LISTEN); side == TCP_SIDE_SERVER_LISTEN);
PJDLOG_ASSERT(ctxp != NULL); PJDLOG_ASSERT(ctxp != NULL);
tctx = malloc(sizeof(*tctx)); tctx = malloc(sizeof(*tctx));
@ -185,7 +185,7 @@ tcp4_setup_new(const char *addr, int side, void **ctxp)
return (errno); return (errno);
/* Parse given address. */ /* Parse given address. */
if ((ret = tcp4_addr(addr, PROTO_TCP4_DEFAULT_PORT, if ((ret = tcp_addr(addr, PROTO_TCP_DEFAULT_PORT,
&tctx->tc_sin)) != 0) { &tctx->tc_sin)) != 0) {
free(tctx); free(tctx);
return (ret); return (ret);
@ -210,20 +210,20 @@ tcp4_setup_new(const char *addr, int side, void **ctxp)
} }
tctx->tc_side = side; tctx->tc_side = side;
tctx->tc_magic = TCP4_CTX_MAGIC; tctx->tc_magic = TCP_CTX_MAGIC;
*ctxp = tctx; *ctxp = tctx;
return (0); return (0);
} }
static int static int
tcp4_setup_wrap(int fd, int side, void **ctxp) tcp_setup_wrap(int fd, int side, void **ctxp)
{ {
struct tcp4_ctx *tctx; struct tcp_ctx *tctx;
PJDLOG_ASSERT(fd >= 0); PJDLOG_ASSERT(fd >= 0);
PJDLOG_ASSERT(side == TCP4_SIDE_CLIENT || PJDLOG_ASSERT(side == TCP_SIDE_CLIENT ||
side == TCP4_SIDE_SERVER_WORK); side == TCP_SIDE_SERVER_WORK);
PJDLOG_ASSERT(ctxp != NULL); PJDLOG_ASSERT(ctxp != NULL);
tctx = malloc(sizeof(*tctx)); tctx = malloc(sizeof(*tctx));
@ -233,47 +233,47 @@ tcp4_setup_wrap(int fd, int side, void **ctxp)
tctx->tc_fd = fd; tctx->tc_fd = fd;
tctx->tc_sin.sin_family = AF_UNSPEC; tctx->tc_sin.sin_family = AF_UNSPEC;
tctx->tc_side = side; tctx->tc_side = side;
tctx->tc_magic = TCP4_CTX_MAGIC; tctx->tc_magic = TCP_CTX_MAGIC;
*ctxp = tctx; *ctxp = tctx;
return (0); return (0);
} }
static int static int
tcp4_client(const char *srcaddr, const char *dstaddr, void **ctxp) tcp_client(const char *srcaddr, const char *dstaddr, void **ctxp)
{ {
struct tcp4_ctx *tctx; struct tcp_ctx *tctx;
struct sockaddr_in sin; struct sockaddr_in sin;
int ret; int ret;
ret = tcp4_setup_new(dstaddr, TCP4_SIDE_CLIENT, ctxp); ret = tcp_setup_new(dstaddr, TCP_SIDE_CLIENT, ctxp);
if (ret != 0) if (ret != 0)
return (ret); return (ret);
tctx = *ctxp; tctx = *ctxp;
if (srcaddr == NULL) if (srcaddr == NULL)
return (0); return (0);
ret = tcp4_addr(srcaddr, 0, &sin); ret = tcp_addr(srcaddr, 0, &sin);
if (ret != 0) { if (ret != 0) {
tcp4_close(tctx); tcp_close(tctx);
return (ret); return (ret);
} }
if (bind(tctx->tc_fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) { if (bind(tctx->tc_fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
ret = errno; ret = errno;
tcp4_close(tctx); tcp_close(tctx);
return (ret); return (ret);
} }
return (0); return (0);
} }
static int static int
tcp4_connect(void *ctx, int timeout) tcp_connect(void *ctx, int timeout)
{ {
struct tcp4_ctx *tctx = ctx; struct tcp_ctx *tctx = ctx;
int error, flags; int error, flags;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
PJDLOG_ASSERT(tctx->tc_side == TCP4_SIDE_CLIENT); PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT);
PJDLOG_ASSERT(tctx->tc_fd >= 0); PJDLOG_ASSERT(tctx->tc_fd >= 0);
PJDLOG_ASSERT(tctx->tc_sin.sin_family != AF_UNSPEC); PJDLOG_ASSERT(tctx->tc_sin.sin_family != AF_UNSPEC);
PJDLOG_ASSERT(timeout >= -1); PJDLOG_ASSERT(timeout >= -1);
@ -309,7 +309,7 @@ tcp4_connect(void *ctx, int timeout)
} }
if (timeout == -1) if (timeout == -1)
return (0); return (0);
return (tcp4_connect_wait(ctx, timeout)); return (tcp_connect_wait(ctx, timeout));
done: done:
flags &= ~O_NONBLOCK; flags &= ~O_NONBLOCK;
if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) { if (fcntl(tctx->tc_fd, F_SETFL, flags) == -1) {
@ -322,17 +322,17 @@ tcp4_connect(void *ctx, int timeout)
} }
static int static int
tcp4_connect_wait(void *ctx, int timeout) tcp_connect_wait(void *ctx, int timeout)
{ {
struct tcp4_ctx *tctx = ctx; struct tcp_ctx *tctx = ctx;
struct timeval tv; struct timeval tv;
fd_set fdset; fd_set fdset;
socklen_t esize; socklen_t esize;
int error, flags, ret; int error, flags, ret;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
PJDLOG_ASSERT(tctx->tc_side == TCP4_SIDE_CLIENT); PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_CLIENT);
PJDLOG_ASSERT(tctx->tc_fd >= 0); PJDLOG_ASSERT(tctx->tc_fd >= 0);
PJDLOG_ASSERT(timeout >= 0); PJDLOG_ASSERT(timeout >= 0);
@ -387,12 +387,12 @@ tcp4_connect_wait(void *ctx, int timeout)
} }
static int static int
tcp4_server(const char *addr, void **ctxp) tcp_server(const char *addr, void **ctxp)
{ {
struct tcp4_ctx *tctx; struct tcp_ctx *tctx;
int ret, val; int ret, val;
ret = tcp4_setup_new(addr, TCP4_SIDE_SERVER_LISTEN, ctxp); ret = tcp_setup_new(addr, TCP_SIDE_SERVER_LISTEN, ctxp);
if (ret != 0) if (ret != 0)
return (ret); return (ret);
@ -408,12 +408,12 @@ tcp4_server(const char *addr, void **ctxp)
if (bind(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sin, if (bind(tctx->tc_fd, (struct sockaddr *)&tctx->tc_sin,
sizeof(tctx->tc_sin)) < 0) { sizeof(tctx->tc_sin)) < 0) {
ret = errno; ret = errno;
tcp4_close(tctx); tcp_close(tctx);
return (ret); return (ret);
} }
if (listen(tctx->tc_fd, 8) < 0) { if (listen(tctx->tc_fd, 8) < 0) {
ret = errno; ret = errno;
tcp4_close(tctx); tcp_close(tctx);
return (ret); return (ret);
} }
@ -421,16 +421,16 @@ tcp4_server(const char *addr, void **ctxp)
} }
static int static int
tcp4_accept(void *ctx, void **newctxp) tcp_accept(void *ctx, void **newctxp)
{ {
struct tcp4_ctx *tctx = ctx; struct tcp_ctx *tctx = ctx;
struct tcp4_ctx *newtctx; struct tcp_ctx *newtctx;
socklen_t fromlen; socklen_t fromlen;
int ret; int ret;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
PJDLOG_ASSERT(tctx->tc_side == TCP4_SIDE_SERVER_LISTEN); PJDLOG_ASSERT(tctx->tc_side == TCP_SIDE_SERVER_LISTEN);
PJDLOG_ASSERT(tctx->tc_fd >= 0); PJDLOG_ASSERT(tctx->tc_fd >= 0);
PJDLOG_ASSERT(tctx->tc_sin.sin_family != AF_UNSPEC); PJDLOG_ASSERT(tctx->tc_sin.sin_family != AF_UNSPEC);
@ -447,28 +447,28 @@ tcp4_accept(void *ctx, void **newctxp)
return (ret); return (ret);
} }
newtctx->tc_side = TCP4_SIDE_SERVER_WORK; newtctx->tc_side = TCP_SIDE_SERVER_WORK;
newtctx->tc_magic = TCP4_CTX_MAGIC; newtctx->tc_magic = TCP_CTX_MAGIC;
*newctxp = newtctx; *newctxp = newtctx;
return (0); return (0);
} }
static int static int
tcp4_wrap(int fd, bool client, void **ctxp) tcp_wrap(int fd, bool client, void **ctxp)
{ {
return (tcp4_setup_wrap(fd, return (tcp_setup_wrap(fd,
client ? TCP4_SIDE_CLIENT : TCP4_SIDE_SERVER_WORK, ctxp)); client ? TCP_SIDE_CLIENT : TCP_SIDE_SERVER_WORK, ctxp));
} }
static int static int
tcp4_send(void *ctx, const unsigned char *data, size_t size, int fd) tcp_send(void *ctx, const unsigned char *data, size_t size, int fd)
{ {
struct tcp4_ctx *tctx = ctx; struct tcp_ctx *tctx = ctx;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
PJDLOG_ASSERT(tctx->tc_fd >= 0); PJDLOG_ASSERT(tctx->tc_fd >= 0);
PJDLOG_ASSERT(fd == -1); PJDLOG_ASSERT(fd == -1);
@ -476,12 +476,12 @@ tcp4_send(void *ctx, const unsigned char *data, size_t size, int fd)
} }
static int static int
tcp4_recv(void *ctx, unsigned char *data, size_t size, int *fdp) tcp_recv(void *ctx, unsigned char *data, size_t size, int *fdp)
{ {
struct tcp4_ctx *tctx = ctx; struct tcp_ctx *tctx = ctx;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
PJDLOG_ASSERT(tctx->tc_fd >= 0); PJDLOG_ASSERT(tctx->tc_fd >= 0);
PJDLOG_ASSERT(fdp == NULL); PJDLOG_ASSERT(fdp == NULL);
@ -489,28 +489,28 @@ tcp4_recv(void *ctx, unsigned char *data, size_t size, int *fdp)
} }
static int static int
tcp4_descriptor(const void *ctx) tcp_descriptor(const void *ctx)
{ {
const struct tcp4_ctx *tctx = ctx; const struct tcp_ctx *tctx = ctx;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
return (tctx->tc_fd); return (tctx->tc_fd);
} }
static bool static bool
tcp4_address_match(const void *ctx, const char *addr) tcp_address_match(const void *ctx, const char *addr)
{ {
const struct tcp4_ctx *tctx = ctx; const struct tcp_ctx *tctx = ctx;
struct sockaddr_in sin; struct sockaddr_in sin;
socklen_t sinlen; socklen_t sinlen;
in_addr_t ip1, ip2; in_addr_t ip1, ip2;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
if (tcp4_addr(addr, PROTO_TCP4_DEFAULT_PORT, &sin) != 0) if (tcp_addr(addr, PROTO_TCP_DEFAULT_PORT, &sin) != 0)
return (false); return (false);
ip1 = sin.sin_addr.s_addr; ip1 = sin.sin_addr.s_addr;
@ -523,48 +523,48 @@ tcp4_address_match(const void *ctx, const char *addr)
} }
static void static void
tcp4_local_address(const void *ctx, char *addr, size_t size) tcp_local_address(const void *ctx, char *addr, size_t size)
{ {
const struct tcp4_ctx *tctx = ctx; const struct tcp_ctx *tctx = ctx;
struct sockaddr_in sin; struct sockaddr_in sin;
socklen_t sinlen; socklen_t sinlen;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
sinlen = sizeof(sin); sinlen = sizeof(sin);
if (getsockname(tctx->tc_fd, (struct sockaddr *)&sin, &sinlen) < 0) { if (getsockname(tctx->tc_fd, (struct sockaddr *)&sin, &sinlen) < 0) {
PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size); PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
return; return;
} }
PJDLOG_VERIFY(snprintf(addr, size, "tcp4://%S", &sin) < (ssize_t)size); PJDLOG_VERIFY(snprintf(addr, size, "tcp://%S", &sin) < (ssize_t)size);
} }
static void static void
tcp4_remote_address(const void *ctx, char *addr, size_t size) tcp_remote_address(const void *ctx, char *addr, size_t size)
{ {
const struct tcp4_ctx *tctx = ctx; const struct tcp_ctx *tctx = ctx;
struct sockaddr_in sin; struct sockaddr_in sin;
socklen_t sinlen; socklen_t sinlen;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
sinlen = sizeof(sin); sinlen = sizeof(sin);
if (getpeername(tctx->tc_fd, (struct sockaddr *)&sin, &sinlen) < 0) { if (getpeername(tctx->tc_fd, (struct sockaddr *)&sin, &sinlen) < 0) {
PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size); PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
return; return;
} }
PJDLOG_VERIFY(snprintf(addr, size, "tcp4://%S", &sin) < (ssize_t)size); PJDLOG_VERIFY(snprintf(addr, size, "tcp://%S", &sin) < (ssize_t)size);
} }
static void static void
tcp4_close(void *ctx) tcp_close(void *ctx)
{ {
struct tcp4_ctx *tctx = ctx; struct tcp_ctx *tctx = ctx;
PJDLOG_ASSERT(tctx != NULL); PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC); PJDLOG_ASSERT(tctx->tc_magic == TCP_CTX_MAGIC);
if (tctx->tc_fd >= 0) if (tctx->tc_fd >= 0)
close(tctx->tc_fd); close(tctx->tc_fd);
@ -572,26 +572,26 @@ tcp4_close(void *ctx)
free(tctx); free(tctx);
} }
static struct proto tcp4_proto = { static struct proto tcp_proto = {
.prt_name = "tcp4", .prt_name = "tcp",
.prt_client = tcp4_client, .prt_client = tcp_client,
.prt_connect = tcp4_connect, .prt_connect = tcp_connect,
.prt_connect_wait = tcp4_connect_wait, .prt_connect_wait = tcp_connect_wait,
.prt_server = tcp4_server, .prt_server = tcp_server,
.prt_accept = tcp4_accept, .prt_accept = tcp_accept,
.prt_wrap = tcp4_wrap, .prt_wrap = tcp_wrap,
.prt_send = tcp4_send, .prt_send = tcp_send,
.prt_recv = tcp4_recv, .prt_recv = tcp_recv,
.prt_descriptor = tcp4_descriptor, .prt_descriptor = tcp_descriptor,
.prt_address_match = tcp4_address_match, .prt_address_match = tcp_address_match,
.prt_local_address = tcp4_local_address, .prt_local_address = tcp_local_address,
.prt_remote_address = tcp4_remote_address, .prt_remote_address = tcp_remote_address,
.prt_close = tcp4_close .prt_close = tcp_close
}; };
static __constructor void static __constructor void
tcp4_ctor(void) tcp_ctor(void)
{ {
proto_register(&tcp4_proto, true); proto_register(&tcp_proto, true);
} }