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

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

MFC after:	1 week

1 files changed, 47 insertions, 47 deletions

diff --git a/sbin/hastd/proto.c b/sbin/hastd/proto.c
index ae576a8..72c8c75 100644
--- a/sbin/hastd/proto.c
+++ b/sbin/hastd/proto.c
@@ -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);
 }