1 files changed, 80 insertions, 72 deletions

diff --git a/src/stream.c b/src/stream.c
index 9447a64..11b05ec 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -23,44 +23,44 @@
  * Client side.
  */
 
-enum stream_client_conn_state {
+enum osmo_stream_client_conn_state {
         STREAM_CLIENT_LINK_STATE_NONE         = 0,
         STREAM_CLIENT_LINK_STATE_CONNECTING   = 1,
         STREAM_CLIENT_LINK_STATE_CONNECTED    = 2,
         STREAM_CLIENT_LINK_STATE_MAX
 };
 
-struct stream_client_conn {
+struct osmo_stream_client_conn {
 	struct osmo_fd			ofd;
 	struct llist_head		tx_queue;
 	struct osmo_timer_list		timer;
-	enum stream_client_conn_state	state;
+	enum osmo_stream_client_conn_state	state;
 	const char			*addr;
 	uint16_t			port;
-	int (*connect_cb)(struct stream_client_conn *link);
-	int (*read_cb)(struct stream_client_conn *link, struct msgb *msg);
-	int (*write_cb)(struct stream_client_conn *link);
+	int (*connect_cb)(struct osmo_stream_client_conn *link);
+	int (*read_cb)(struct osmo_stream_client_conn *link, struct msgb *msg);
+	int (*write_cb)(struct osmo_stream_client_conn *link);
 	void				*data;
 };
 
-void stream_client_conn_close(struct stream_client_conn *link);
+void osmo_stream_client_conn_close(struct osmo_stream_client_conn *link);
 
-static void stream_client_retry(struct stream_client_conn *link)
+static void osmo_stream_client_retry(struct osmo_stream_client_conn *link)
 {
 	LOGP(DLINP, LOGL_DEBUG, "connection closed\n");
-	stream_client_conn_close(link);
+	osmo_stream_client_conn_close(link);
 	LOGP(DLINP, LOGL_DEBUG, "retrying in 5 seconds...\n");
 	osmo_timer_schedule(&link->timer, 5, 0);
 	link->state = STREAM_CLIENT_LINK_STATE_CONNECTING;
 }
 
-void stream_client_conn_close(struct stream_client_conn *link)
+void osmo_stream_client_conn_close(struct osmo_stream_client_conn *link)
 {
 	osmo_fd_unregister(&link->ofd);
 	close(link->ofd.fd);
 }
 
-static void stream_client_read(struct stream_client_conn *link)
+static void osmo_stream_client_read(struct osmo_stream_client_conn *link)
 {
 	struct msgb *msg;
 	int ret;
@@ -77,11 +77,11 @@ static void stream_client_read(struct stream_client_conn *link)
 		if (errno == EPIPE || errno == ECONNRESET) {
 			LOGP(DLINP, LOGL_ERROR, "lost connection with server\n");
 		}
-		stream_client_retry(link);
+		osmo_stream_client_retry(link);
 		return;
 	} else if (ret == 0) {
 		LOGP(DLINP, LOGL_ERROR, "connection closed with server\n");
-		stream_client_retry(link);
+		osmo_stream_client_retry(link);
 		return;
 	}
 	msgb_put(msg, ret);
@@ -89,7 +89,7 @@ static void stream_client_read(struct stream_client_conn *link)
 		link->read_cb(link, msg);
 }
 
-static int stream_client_write(struct stream_client_conn *link)
+static int osmo_stream_client_write(struct osmo_stream_client_conn *link)
 {
 	struct msgb *msg;
 	struct llist_head *lh;
@@ -113,7 +113,7 @@ static int stream_client_write(struct stream_client_conn *link)
 	ret = send(link->ofd.fd, msg->data, msg->len, 0);
 	if (ret < 0) {
 		if (errno == EPIPE || errno == ENOTCONN) {
-			stream_client_retry(link);
+			osmo_stream_client_retry(link);
 		}
 		LOGP(DLINP, LOGL_ERROR, "error to send\n");
 	}
@@ -121,9 +121,9 @@ static int stream_client_write(struct stream_client_conn *link)
 	return 0;
 }
 
-static int stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what)
+static int osmo_stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what)
 {
-	struct stream_client_conn *link = ofd->data;
+	struct osmo_stream_client_conn *link = ofd->data;
 	int error, ret;
 	socklen_t len = sizeof(error);
 
@@ -131,7 +131,7 @@ static int stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what)
 	case STREAM_CLIENT_LINK_STATE_CONNECTING:
 		ret = getsockopt(ofd->fd, SOL_SOCKET, SO_ERROR, &error, &len);
 		if (ret >= 0 && error > 0) {
-			stream_client_retry(link);
+			osmo_stream_client_retry(link);
 			return 0;
 		}
 		ofd->when &= ~BSC_FD_WRITE;
@@ -143,11 +143,11 @@ static int stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what)
 	case STREAM_CLIENT_LINK_STATE_CONNECTED:
 		if (what & BSC_FD_READ) {
 			LOGP(DLINP, LOGL_DEBUG, "connected read\n");
-			stream_client_read(link);
+			osmo_stream_client_read(link);
 		}
 		if (what & BSC_FD_WRITE) {
 			LOGP(DLINP, LOGL_DEBUG, "connected write\n");
-			stream_client_write(link);
+			osmo_stream_client_write(link);
 		}
 		break;
 	default:
@@ -158,17 +158,17 @@ static int stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what)
 
 static void link_timer_cb(void *data);
 
-struct stream_client_conn *stream_client_conn_create(void *ctx)
+struct osmo_stream_client_conn *osmo_stream_client_conn_create(void *ctx)
 {
-	struct stream_client_conn *link;
+	struct osmo_stream_client_conn *link;
 
-	link = talloc_zero(ctx, struct stream_client_conn);
+	link = talloc_zero(ctx, struct osmo_stream_client_conn);
 	if (!link)
 		return NULL;
 
 	link->ofd.when |= BSC_FD_READ | BSC_FD_WRITE;
 	link->ofd.priv_nr = 0;	/* XXX */
-	link->ofd.cb = stream_client_fd_cb;
+	link->ofd.cb = osmo_stream_client_fd_cb;
 	link->ofd.data = link;
 	link->state = STREAM_CLIENT_LINK_STATE_CONNECTING;
 	link->timer.cb = link_timer_cb;
@@ -179,43 +179,46 @@ struct stream_client_conn *stream_client_conn_create(void *ctx)
 }
 
 void
-stream_client_conn_set_addr(struct stream_client_conn *link, const char *addr)
+osmo_stream_client_conn_set_addr(struct osmo_stream_client_conn *link,
+				 const char *addr)
 {
 	link->addr = talloc_strdup(link, addr);
 }
 
 void
-stream_client_conn_set_port(struct stream_client_conn *link, uint16_t port)
+osmo_stream_client_conn_set_port(struct osmo_stream_client_conn *link,
+				 uint16_t port)
 {
 	link->port = port;
 }
 
 void
-stream_client_conn_set_data(struct stream_client_conn *link, void *data)
+osmo_stream_client_conn_set_data(struct osmo_stream_client_conn *link,
+				 void *data)
 {
 	link->data = data;
 }
 
 void
-stream_client_conn_set_connect_cb(struct stream_client_conn *link,
-			int (*connect_cb)(struct stream_client_conn *link))
+osmo_stream_client_conn_set_connect_cb(struct osmo_stream_client_conn *link,
+	int (*connect_cb)(struct osmo_stream_client_conn *link))
 {
 	link->connect_cb = connect_cb;
 }
 
 void
-stream_client_conn_set_read_cb(struct stream_client_conn *link,
-	int (*read_cb)(struct stream_client_conn *link, struct msgb *msgb))
+osmo_stream_client_conn_set_read_cb(struct osmo_stream_client_conn *link,
+	int (*read_cb)(struct osmo_stream_client_conn *link, struct msgb *msgb))
 {
 	link->read_cb = read_cb;
 }
 
-void stream_client_conn_destroy(struct stream_client_conn *link)
+void osmo_stream_client_conn_destroy(struct osmo_stream_client_conn *link)
 {
 	talloc_free(link);
 }
 
-int stream_client_conn_open(struct stream_client_conn *link)
+int osmo_stream_client_conn_open(struct osmo_stream_client_conn *link)
 {
 	int ret;
 
@@ -236,20 +239,21 @@ int stream_client_conn_open(struct stream_client_conn *link)
 
 static void link_timer_cb(void *data)
 {
-	struct stream_client_conn *link = data;
+	struct osmo_stream_client_conn *link = data;
 
 	LOGP(DLINP, LOGL_DEBUG, "reconnecting.\n");
 
 	switch(link->state) {
 	case STREAM_CLIENT_LINK_STATE_CONNECTING:
-		stream_client_conn_open(link);
+		osmo_stream_client_conn_open(link);
 	        break;
 	default:
 		break;
 	}
 }
 
-void stream_client_conn_send(struct stream_client_conn *link, struct msgb *msg)
+void osmo_stream_client_conn_send(struct osmo_stream_client_conn *link,
+				  struct msgb *msg)
 {
 	msgb_enqueue(&link->tx_queue, msg);
 	link->ofd.when |= BSC_FD_WRITE;
@@ -259,20 +263,20 @@ void stream_client_conn_send(struct stream_client_conn *link, struct msgb *msg)
  * Server side.
  */
 
-struct stream_server_link {
+struct osmo_stream_server_link {
         struct osmo_fd                  ofd;
         const char                      *addr;
         uint16_t                        port;
-        int (*accept_cb)(struct stream_server_link *link, int fd);
+        int (*accept_cb)(struct osmo_stream_server_link *link, int fd);
         void                            *data;
 };
 
-static int stream_server_fd_cb(struct osmo_fd *ofd, unsigned int what)
+static int osmo_stream_server_fd_cb(struct osmo_fd *ofd, unsigned int what)
 {
 	int ret;
 	struct sockaddr_in sa;
 	socklen_t sa_len = sizeof(sa);
-	struct stream_server_link *link = ofd->data;
+	struct osmo_stream_server_link *link = ofd->data;
 
 	ret = accept(ofd->fd, (struct sockaddr *)&sa, &sa_len);
 	if (ret < 0) {
@@ -289,44 +293,46 @@ static int stream_server_fd_cb(struct osmo_fd *ofd, unsigned int what)
 	return 0;
 }
 
-struct stream_server_link *stream_server_link_create(void *ctx)
+struct osmo_stream_server_link *osmo_stream_server_link_create(void *ctx)
 {
-	struct stream_server_link *link;
+	struct osmo_stream_server_link *link;
 
-	link = talloc_zero(ctx, struct stream_server_link);
+	link = talloc_zero(ctx, struct osmo_stream_server_link);
 	if (!link)
 		return NULL;
 
 	link->ofd.when |= BSC_FD_READ | BSC_FD_WRITE;
-	link->ofd.cb = stream_server_fd_cb;
+	link->ofd.cb = osmo_stream_server_fd_cb;
 	link->ofd.data = link;
 
 	return link;
 }
 
-void stream_server_link_set_addr(struct stream_server_link *link, const char *addr)
+void osmo_stream_server_link_set_addr(struct osmo_stream_server_link *link,
+				      const char *addr)
 {
 	link->addr = talloc_strdup(link, addr);
 }
 
-void stream_server_link_set_port(struct stream_server_link *link, uint16_t port)
+void osmo_stream_server_link_set_port(struct osmo_stream_server_link *link,
+				      uint16_t port)
 {
 	link->port = port;
 }
 
-void stream_server_link_set_accept_cb(struct stream_server_link *link,
-		int (*accept_cb)(struct stream_server_link *link, int fd))
+void osmo_stream_server_link_set_accept_cb(struct osmo_stream_server_link *link,
+	int (*accept_cb)(struct osmo_stream_server_link *link, int fd))
 
 {
 	link->accept_cb = accept_cb;
 }
 
-void stream_server_link_destroy(struct stream_server_link *link)
+void osmo_stream_server_link_destroy(struct osmo_stream_server_link *link)
 {
 	talloc_free(link);
 }
 
-int stream_server_link_open(struct stream_server_link *link)
+int osmo_stream_server_link_open(struct osmo_stream_server_link *link)
 {
 	int ret;
 
@@ -343,22 +349,22 @@ int stream_server_link_open(struct stream_server_link *link)
 	return 0;
 }
 
-void stream_server_link_close(struct stream_server_link *link)
+void osmo_stream_server_link_close(struct osmo_stream_server_link *link)
 {
 	osmo_fd_unregister(&link->ofd);
 	close(link->ofd.fd);
 }
 
-struct stream_server_conn {
-	struct stream_server_link	*server;
+struct osmo_stream_server_conn {
+	struct osmo_stream_server_link	*server;
         struct osmo_fd                  ofd;
         struct llist_head               tx_queue;
-        int (*closed_cb)(struct stream_server_conn *peer);
-        int (*cb)(struct stream_server_conn *peer, struct msgb *msg);
+        int (*closed_cb)(struct osmo_stream_server_conn *peer);
+        int (*cb)(struct osmo_stream_server_conn *peer, struct msgb *msg);
         void                            *data;
 };
 
-static void stream_server_conn_read(struct stream_server_conn *conn)
+static void osmo_stream_server_conn_read(struct osmo_stream_server_conn *conn)
 {
 	struct msgb *msg;
 	int ret;
@@ -375,11 +381,11 @@ static void stream_server_conn_read(struct stream_server_conn *conn)
 		if (errno == EPIPE || errno == ECONNRESET) {
 			LOGP(DLINP, LOGL_ERROR, "lost connection with server\n");
 		}
-		stream_server_conn_destroy(conn);
+		osmo_stream_server_conn_destroy(conn);
 		return;
 	} else if (ret == 0) {
 		LOGP(DLINP, LOGL_ERROR, "connection closed with server\n");
-		stream_server_conn_destroy(conn);
+		osmo_stream_server_conn_destroy(conn);
 		return;
 	}
 	msgb_put(msg, ret);
@@ -390,7 +396,7 @@ static void stream_server_conn_read(struct stream_server_conn *conn)
 	return;
 }
 
-static void stream_server_conn_write(struct stream_server_conn *conn)
+static void osmo_stream_server_conn_write(struct osmo_stream_server_conn *conn)
 {
 	struct msgb *msg;
 	struct llist_head *lh;
@@ -413,27 +419,28 @@ static void stream_server_conn_write(struct stream_server_conn *conn)
 	msgb_free(msg);
 }
 
-static int stream_server_conn_cb(struct osmo_fd *ofd, unsigned int what)
+static int osmo_stream_server_conn_cb(struct osmo_fd *ofd, unsigned int what)
 {
-	struct stream_server_conn *conn = ofd->data;
+	struct osmo_stream_server_conn *conn = ofd->data;
 
 	LOGP(DLINP, LOGL_DEBUG, "connected read/write\n");
 	if (what & BSC_FD_READ)
-		stream_server_conn_read(conn);
+		osmo_stream_server_conn_read(conn);
 	if (what & BSC_FD_WRITE)
-		stream_server_conn_write(conn);
+		osmo_stream_server_conn_write(conn);
 
 	return 0;
 }
 
-struct stream_server_conn *
-stream_server_conn_create(void *ctx, struct stream_server_link *link, int fd,
-		int (*cb)(struct stream_server_conn *conn, struct msgb *msg),
-		int (*closed_cb)(struct stream_server_conn *conn), void *data)
+struct osmo_stream_server_conn *
+osmo_stream_server_conn_create(void *ctx, struct osmo_stream_server_link *link,
+	int fd,
+	int (*cb)(struct osmo_stream_server_conn *conn, struct msgb *msg),
+	int (*closed_cb)(struct osmo_stream_server_conn *conn), void *data)
 {
-	struct stream_server_conn *conn;
+	struct osmo_stream_server_conn *conn;
 
-	conn = talloc_zero(ctx, struct stream_server_conn);
+	conn = talloc_zero(ctx, struct osmo_stream_server_conn);
 	if (conn == NULL) {
 		LOGP(DLINP, LOGL_ERROR, "cannot allocate new peer in server, "
 			"reason=`%s'\n", strerror(errno));
@@ -442,7 +449,7 @@ stream_server_conn_create(void *ctx, struct stream_server_link *link, int fd,
 	conn->server = link;
 	conn->ofd.fd = fd;
 	conn->ofd.data = conn;
-	conn->ofd.cb = stream_server_conn_cb;
+	conn->ofd.cb = osmo_stream_server_conn_cb;
 	conn->ofd.when = BSC_FD_READ;
 	conn->cb = cb;
 	conn->closed_cb = closed_cb;
@@ -457,7 +464,7 @@ stream_server_conn_create(void *ctx, struct stream_server_link *link, int fd,
 	return conn;
 }
 
-void stream_server_conn_destroy(struct stream_server_conn *conn)
+void osmo_stream_server_conn_destroy(struct osmo_stream_server_conn *conn)
 {
 	close(conn->ofd.fd);
 	osmo_fd_unregister(&conn->ofd);
@@ -466,7 +473,8 @@ void stream_server_conn_destroy(struct stream_server_conn *conn)
 	talloc_free(conn);
 }
 
-void stream_server_conn_send(struct stream_server_conn *conn, struct msgb *msg)
+void osmo_stream_server_conn_send(struct osmo_stream_server_conn *conn,
+				  struct msgb *msg)
 {
 	msgb_enqueue(&conn->tx_queue, msg);
 	conn->ofd.when |= BSC_FD_WRITE;