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

The proto API is a general purpose API, so don't use 'hast' in structures or

Browse Source 
function names. It can now be used outside of HAST.

MFC after:	1 week
This commit is contained in:
Pawel Jakub Dawidek 2011-03-22 16:21:11 +00:00
parent 1198947acd
commit e2eabb44d7
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=219873
7 changed files with 120 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
sbin/hastd/Makefile
View File

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

1
sbin/hastd/hast.h
View File

@ -86,7 +86,6 @@
#define HAST_TIMEOUT 5
#define HAST_CONFIG "/etc/hast.conf"
#define HAST_CONTROL "/var/run/hastctl"
#define HASTD_PORT 8457
#define HASTD_LISTEN "tcp4://0.0.0.0:8457"
#define HASTD_PIDFILE "/var/run/hastd.pid"

94
sbin/hastd/proto.c
View File

@ -45,33 +45,33 @@ __FBSDID("$FreeBSD$");
#define PROTO_CONN_MAGIC 0x907041c
struct proto_conn {
int pc_magic;
struct hast_proto *pc_proto;
void *pc_ctx;
int pc_side;
int pc_magic;
struct proto *pc_proto;
void *pc_ctx;
int pc_side;
#define PROTO_SIDE_CLIENT 0
#define PROTO_SIDE_SERVER_LISTEN 1
#define PROTO_SIDE_SERVER_WORK 2
};
static TAILQ_HEAD(, hast_proto) protos = TAILQ_HEAD_INITIALIZER(protos);
static TAILQ_HEAD(, proto) protos = TAILQ_HEAD_INITIALIZER(protos);
void
proto_register(struct hast_proto *proto, bool isdefault)
proto_register(struct proto *proto, bool isdefault)
{
static bool seen_default = false;
if (!isdefault)
TAILQ_INSERT_HEAD(&protos, proto, hp_next);
TAILQ_INSERT_HEAD(&protos, proto, prt_next);
else {
PJDLOG_ASSERT(!seen_default);
seen_default = true;
TAILQ_INSERT_TAIL(&protos, proto, hp_next);
TAILQ_INSERT_TAIL(&protos, proto, prt_next);
}
}
static struct proto_conn *
proto_alloc(struct hast_proto *proto, int side)
proto_alloc(struct proto *proto, int side)
{
struct proto_conn *conn;
@ -108,7 +108,7 @@ static int
proto_common_setup(const char *srcaddr, const char *dstaddr,
struct proto_conn **connp, int side)
{
struct hast_proto *proto;
struct proto *proto;
struct proto_conn *conn;
void *ctx;
int ret;
@ -116,17 +116,17 @@ proto_common_setup(const char *srcaddr, const char *dstaddr,
PJDLOG_ASSERT(side == PROTO_SIDE_CLIENT ||
side == PROTO_SIDE_SERVER_LISTEN);
TAILQ_FOREACH(proto, &protos, hp_next) {
TAILQ_FOREACH(proto, &protos, prt_next) {
if (side == PROTO_SIDE_CLIENT) {
if (proto->hp_client == NULL)
if (proto->prt_client == NULL)
ret = -1;
else
ret = proto->hp_client(srcaddr, dstaddr, &ctx);
ret = proto->prt_client(srcaddr, dstaddr, &ctx);
} else /* if (side == PROTO_SIDE_SERVER_LISTEN) */ {
if (proto->hp_server == NULL)
if (proto->prt_server == NULL)
ret = -1;
else
ret = proto->hp_server(dstaddr, &ctx);
ret = proto->prt_server(dstaddr, &ctx);
}
/*
* ret == 0 - success
@ -148,8 +148,8 @@ proto_common_setup(const char *srcaddr, const char *dstaddr,
}
conn = proto_alloc(proto, side);
if (conn == NULL) {
if (proto->hp_close != NULL)
proto->hp_close(ctx);
if (proto->prt_close != NULL)
proto->prt_close(ctx);
errno = ENOMEM;
return (-1);
}
@ -176,10 +176,10 @@ proto_connect(struct proto_conn *conn, int timeout)
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_side == PROTO_SIDE_CLIENT);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_connect != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_connect != NULL);
PJDLOG_ASSERT(timeout >= -1);
ret = conn->pc_proto->hp_connect(conn->pc_ctx, timeout);
ret = conn->pc_proto->prt_connect(conn->pc_ctx, timeout);
if (ret != 0) {
errno = ret;
return (-1);
@ -197,10 +197,10 @@ proto_connect_wait(struct proto_conn *conn, int timeout)
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_side == PROTO_SIDE_CLIENT);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_connect_wait != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_connect_wait != NULL);
PJDLOG_ASSERT(timeout >= 0);
ret = conn->pc_proto->hp_connect_wait(conn->pc_ctx, timeout);
ret = conn->pc_proto->prt_connect_wait(conn->pc_ctx, timeout);
if (ret != 0) {
errno = ret;
return (-1);
@ -226,13 +226,13 @@ proto_accept(struct proto_conn *conn, struct proto_conn **newconnp)
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_side == PROTO_SIDE_SERVER_LISTEN);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_accept != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_accept != NULL);
newconn = proto_alloc(conn->pc_proto, PROTO_SIDE_SERVER_WORK);
if (newconn == NULL)
return (-1);
ret = conn->pc_proto->hp_accept(conn->pc_ctx, &newconn->pc_ctx);
ret = conn->pc_proto->prt_accept(conn->pc_ctx, &newconn->pc_ctx);
if (ret != 0) {
proto_free(newconn);
errno = ret;
@ -252,9 +252,9 @@ proto_send(const struct proto_conn *conn, const void *data, size_t size)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_send != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_send != NULL);
ret = conn->pc_proto->hp_send(conn->pc_ctx, data, size, -1);
ret = conn->pc_proto->prt_send(conn->pc_ctx, data, size, -1);
if (ret != 0) {
errno = ret;
return (-1);
@ -270,9 +270,9 @@ proto_recv(const struct proto_conn *conn, void *data, size_t size)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_recv != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_recv != NULL);
ret = conn->pc_proto->hp_recv(conn->pc_ctx, data, size, NULL);
ret = conn->pc_proto->prt_recv(conn->pc_ctx, data, size, NULL);
if (ret != 0) {
errno = ret;
return (-1);
@ -289,16 +289,16 @@ proto_connection_send(const struct proto_conn *conn, struct proto_conn *mconn)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_send != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_send != NULL);
PJDLOG_ASSERT(mconn != NULL);
PJDLOG_ASSERT(mconn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(mconn->pc_proto != NULL);
fd = proto_descriptor(mconn);
PJDLOG_ASSERT(fd >= 0);
protoname = mconn->pc_proto->hp_name;
protoname = mconn->pc_proto->prt_name;
PJDLOG_ASSERT(protoname != NULL);
ret = conn->pc_proto->hp_send(conn->pc_ctx, protoname,
ret = conn->pc_proto->prt_send(conn->pc_ctx, protoname,
strlen(protoname) + 1, fd);
proto_close(mconn);
if (ret != 0) {
@ -313,19 +313,19 @@ proto_connection_recv(const struct proto_conn *conn, bool client,
struct proto_conn **newconnp)
{
char protoname[128];
struct hast_proto *proto;
struct proto *proto;
struct proto_conn *newconn;
int ret, fd;
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_recv != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_recv != NULL);
PJDLOG_ASSERT(newconnp != NULL);
bzero(protoname, sizeof(protoname));
ret = conn->pc_proto->hp_recv(conn->pc_ctx, protoname,
ret = conn->pc_proto->prt_recv(conn->pc_ctx, protoname,
sizeof(protoname) - 1, &fd);
if (ret != 0) {
errno = ret;
@ -334,8 +334,8 @@ proto_connection_recv(const struct proto_conn *conn, bool client,
PJDLOG_ASSERT(fd >= 0);
TAILQ_FOREACH(proto, &protos, hp_next) {
if (strcmp(proto->hp_name, protoname) == 0)
TAILQ_FOREACH(proto, &protos, prt_next) {
if (strcmp(proto->prt_name, protoname) == 0)
break;
}
if (proto == NULL) {
@ -347,8 +347,8 @@ proto_connection_recv(const struct proto_conn *conn, bool client,
client ? PROTO_SIDE_CLIENT : PROTO_SIDE_SERVER_WORK);
if (newconn == NULL)
return (-1);
PJDLOG_ASSERT(newconn->pc_proto->hp_wrap != NULL);
ret = newconn->pc_proto->hp_wrap(fd, client, &newconn->pc_ctx);
PJDLOG_ASSERT(newconn->pc_proto->prt_wrap != NULL);
ret = newconn->pc_proto->prt_wrap(fd, client, &newconn->pc_ctx);
if (ret != 0) {
proto_free(newconn);
errno = ret;
@ -367,9 +367,9 @@ proto_descriptor(const struct proto_conn *conn)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_descriptor != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_descriptor != NULL);
return (conn->pc_proto->hp_descriptor(conn->pc_ctx));
return (conn->pc_proto->prt_descriptor(conn->pc_ctx));
}
bool
@ -379,9 +379,9 @@ proto_address_match(const struct proto_conn *conn, const char *addr)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_address_match != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_address_match != NULL);
return (conn->pc_proto->hp_address_match(conn->pc_ctx, addr));
return (conn->pc_proto->prt_address_match(conn->pc_ctx, addr));
}
void
@ -391,9 +391,9 @@ proto_local_address(const struct proto_conn *conn, char *addr, size_t size)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_local_address != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_local_address != NULL);
conn->pc_proto->hp_local_address(conn->pc_ctx, addr, size);
conn->pc_proto->prt_local_address(conn->pc_ctx, addr, size);
}
void
@ -403,9 +403,9 @@ proto_remote_address(const struct proto_conn *conn, char *addr, size_t size)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_remote_address != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_remote_address != NULL);
conn->pc_proto->hp_remote_address(conn->pc_ctx, addr, size);
conn->pc_proto->prt_remote_address(conn->pc_ctx, addr, size);
}
int
@ -439,8 +439,8 @@ proto_close(struct proto_conn *conn)
PJDLOG_ASSERT(conn != NULL);
PJDLOG_ASSERT(conn->pc_magic == PROTO_CONN_MAGIC);
PJDLOG_ASSERT(conn->pc_proto != NULL);
PJDLOG_ASSERT(conn->pc_proto->hp_close != NULL);
PJDLOG_ASSERT(conn->pc_proto->prt_close != NULL);
conn->pc_proto->hp_close(conn->pc_ctx);
conn->pc_proto->prt_close(conn->pc_ctx);
proto_free(conn);
}

60
sbin/hastd/proto_impl.h
View File

@ -39,39 +39,39 @@
#define __constructor __attribute__((constructor))
typedef int hp_client_t(const char *, const char *, void **);
typedef int hp_connect_t(void *, int);
typedef int hp_connect_wait_t(void *, int);
typedef int hp_server_t(const char *, void **);
typedef int hp_accept_t(void *, void **);
typedef int hp_wrap_t(int, bool, void **);
typedef int hp_send_t(void *, const unsigned char *, size_t, int);
typedef int hp_recv_t(void *, unsigned char *, size_t, int *);
typedef int hp_descriptor_t(const void *);
typedef bool hp_address_match_t(const void *, const char *);
typedef void hp_local_address_t(const void *, char *, size_t);
typedef void hp_remote_address_t(const void *, char *, size_t);
typedef void hp_close_t(void *);
typedef int prt_client_t(const char *, const char *, void **);
typedef int prt_connect_t(void *, int);
typedef int prt_connect_wait_t(void *, int);
typedef int prt_server_t(const char *, void **);
typedef int prt_accept_t(void *, void **);
typedef int prt_wrap_t(int, bool, void **);
typedef int prt_send_t(void *, const unsigned char *, size_t, int);
typedef int prt_recv_t(void *, unsigned char *, size_t, int *);
typedef int prt_descriptor_t(const void *);
typedef bool prt_address_match_t(const void *, const char *);
typedef void prt_local_address_t(const void *, char *, size_t);
typedef void prt_remote_address_t(const void *, char *, size_t);
typedef void prt_close_t(void *);
struct hast_proto {
const char *hp_name;
hp_client_t *hp_client;
hp_connect_t *hp_connect;
hp_connect_wait_t *hp_connect_wait;
hp_server_t *hp_server;
hp_accept_t *hp_accept;
hp_wrap_t *hp_wrap;
hp_send_t *hp_send;
hp_recv_t *hp_recv;
hp_descriptor_t *hp_descriptor;
hp_address_match_t *hp_address_match;
hp_local_address_t *hp_local_address;
hp_remote_address_t *hp_remote_address;
hp_close_t *hp_close;
TAILQ_ENTRY(hast_proto) hp_next;
struct proto {
const char *prt_name;
prt_client_t *prt_client;
prt_connect_t *prt_connect;
prt_connect_wait_t *prt_connect_wait;
prt_server_t *prt_server;
prt_accept_t *prt_accept;
prt_wrap_t *prt_wrap;
prt_send_t *prt_send;
prt_recv_t *prt_recv;
prt_descriptor_t *prt_descriptor;
prt_address_match_t *prt_address_match;
prt_local_address_t *prt_local_address;
prt_remote_address_t *prt_remote_address;
prt_close_t *prt_close;
TAILQ_ENTRY(proto) prt_next;
};
void proto_register(struct hast_proto *proto, bool isdefault);
void proto_register(struct proto *proto, bool isdefault);
int proto_common_send(int sock, const unsigned char *data, size_t size, int fd);
int proto_common_recv(int sock, unsigned char *data, size_t size, int *fdp);

15
sbin/hastd/proto_socketpair.c
View File

@ -40,7 +40,6 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <unistd.h>
#include "hast.h"
#include "pjdlog.h"
#include "proto_impl.h"
@ -221,13 +220,13 @@ sp_close(void *ctx)
free(spctx);
}
static struct hast_proto sp_proto = {
.hp_name = "socketpair",
.hp_client = sp_client,
.hp_send = sp_send,
.hp_recv = sp_recv,
.hp_descriptor = sp_descriptor,
.hp_close = sp_close
static struct proto sp_proto = {
.prt_name = "socketpair",
.prt_client = sp_client,
.prt_send = sp_send,
.prt_recv = sp_recv,
.prt_descriptor = sp_descriptor,
.prt_close = sp_close
};
static __constructor void

39
sbin/hastd/proto_tcp4.c
View File

@ -31,6 +31,9 @@
__FBSDID("$FreeBSD$");
#include <sys/param.h> /* MAXHOSTNAMELEN */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
@ -44,7 +47,6 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <unistd.h>
#include "hast.h"
#include "pjdlog.h"
#include "proto_impl.h"
#include "subr.h"
@ -183,7 +185,8 @@ tcp4_setup_new(const char *addr, int side, void **ctxp)
return (errno);
/* Parse given address. */
if ((ret = tcp4_addr(addr, HASTD_PORT, &tctx->tc_sin)) != 0) {
if ((ret = tcp4_addr(addr, PROTO_TCP4_DEFAULT_PORT,
&tctx->tc_sin)) != 0) {
free(tctx);
return (ret);
}
@ -507,7 +510,7 @@ tcp4_address_match(const void *ctx, const char *addr)
PJDLOG_ASSERT(tctx != NULL);
PJDLOG_ASSERT(tctx->tc_magic == TCP4_CTX_MAGIC);
if (tcp4_addr(addr, HASTD_PORT, &sin) != 0)
if (tcp4_addr(addr, PROTO_TCP4_DEFAULT_PORT, &sin) != 0)
return (false);
ip1 = sin.sin_addr.s_addr;
@ -569,21 +572,21 @@ tcp4_close(void *ctx)
free(tctx);
}
static struct hast_proto tcp4_proto = {
.hp_name = "tcp4",
.hp_client = tcp4_client,
.hp_connect = tcp4_connect,
.hp_connect_wait = tcp4_connect_wait,
.hp_server = tcp4_server,
.hp_accept = tcp4_accept,
.hp_wrap = tcp4_wrap,
.hp_send = tcp4_send,
.hp_recv = tcp4_recv,
.hp_descriptor = tcp4_descriptor,
.hp_address_match = tcp4_address_match,
.hp_local_address = tcp4_local_address,
.hp_remote_address = tcp4_remote_address,
.hp_close = tcp4_close
static struct proto tcp4_proto = {
.prt_name = "tcp4",
.prt_client = tcp4_client,
.prt_connect = tcp4_connect,
.prt_connect_wait = tcp4_connect_wait,
.prt_server = tcp4_server,
.prt_accept = tcp4_accept,
.prt_wrap = tcp4_wrap,
.prt_send = tcp4_send,
.prt_recv = tcp4_recv,
.prt_descriptor = tcp4_descriptor,
.prt_address_match = tcp4_address_match,
.prt_local_address = tcp4_local_address,
.prt_remote_address = tcp4_remote_address,
.prt_close = tcp4_close
};
static __constructor void

28
sbin/hastd/proto_uds.c
View File

@ -33,6 +33,7 @@ __FBSDID("$FreeBSD$");
/* UDS - UNIX Domain Socket */
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
@ -42,7 +43,6 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <unistd.h>
#include "hast.h"
#include "pjdlog.h"
#include "proto_impl.h"
@ -338,19 +338,19 @@ uds_close(void *ctx)
free(uctx);
}
static struct hast_proto uds_proto = {
.hp_name = "uds",
.hp_client = uds_client,
.hp_connect = uds_connect,
.hp_connect_wait = uds_connect_wait,
.hp_server = uds_server,
.hp_accept = uds_accept,
.hp_send = uds_send,
.hp_recv = uds_recv,
.hp_descriptor = uds_descriptor,
.hp_local_address = uds_local_address,
.hp_remote_address = uds_remote_address,
.hp_close = uds_close
static struct proto uds_proto = {
.prt_name = "uds",
.prt_client = uds_client,
.prt_connect = uds_connect,
.prt_connect_wait = uds_connect_wait,
.prt_server = uds_server,
.prt_accept = uds_accept,
.prt_send = uds_send,
.prt_recv = uds_recv,
.prt_descriptor = uds_descriptor,
.prt_local_address = uds_local_address,
.prt_remote_address = uds_remote_address,
.prt_close = uds_close
};
static __constructor void