From cee5fb36dab5741c2f2a5b5952e734bac6621c8f Mon Sep 17 00:00:00 2001 From: Pablo Neira Ayuso Date: Wed, 15 Aug 2012 21:14:38 +0200 Subject: src: shorter stream function names %s/_client_conn_/_cli_/g %s/_server_conn_/_srv_/g %s/_client_/cli/g %s/server/srv/g %s/RECONFIG/RECONF/g %s/SERVER/SRV/g %s/CLIENT/CLI/g --- src/stream.c | 313 +++++++++++++++++++++++++++++------------------------------ 1 file changed, 153 insertions(+), 160 deletions(-) (limited to 'src/stream.c') diff --git a/src/stream.c b/src/stream.c index b32f9b5..c72de3c 100644 --- a/src/stream.c +++ b/src/stream.c @@ -23,61 +23,61 @@ * Client side. */ -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 +enum osmo_stream_cli_state { + STREAM_CLI_STATE_NONE = 0, + STREAM_CLI_STATE_CONNECTING = 1, + STREAM_CLI_STATE_CONNECTED = 2, + STREAM_CLI_STATE_MAX }; -#define OSMO_STREAM_CLIENT_F_RECONFIG (1 << 0) +#define OSMO_STREAM_CLI_F_RECONF (1 << 0) -struct osmo_stream_client_conn { +struct osmo_stream_cli { struct osmo_fd ofd; struct llist_head tx_queue; struct osmo_timer_list timer; - enum osmo_stream_client_conn_state state; + enum osmo_stream_cli_state state; const char *addr; uint16_t port; - int (*connect_cb)(struct osmo_stream_client_conn *link); - int (*read_cb)(struct osmo_stream_client_conn *link); - int (*write_cb)(struct osmo_stream_client_conn *link); + int (*connect_cb)(struct osmo_stream_cli *srv); + int (*read_cb)(struct osmo_stream_cli *srv); + int (*write_cb)(struct osmo_stream_cli *srv); void *data; int flags; int reconnect_timeout; }; -void osmo_stream_client_conn_close(struct osmo_stream_client_conn *link); +void osmo_stream_cli_close(struct osmo_stream_cli *cli); -static void osmo_stream_client_reconnect(struct osmo_stream_client_conn *link) +static void osmo_stream_cli_reconnect(struct osmo_stream_cli *cli) { - if (link->reconnect_timeout < 0) { + if (cli->reconnect_timeout < 0) { LOGP(DLINP, LOGL_DEBUG, "not reconnecting, disabled.\n"); return; } LOGP(DLINP, LOGL_DEBUG, "connection closed\n"); - osmo_stream_client_conn_close(link); + osmo_stream_cli_close(cli); LOGP(DLINP, LOGL_DEBUG, "retrying in %d seconds...\n", - link->reconnect_timeout); - osmo_timer_schedule(&link->timer, link->reconnect_timeout, 0); - link->state = STREAM_CLIENT_LINK_STATE_CONNECTING; + cli->reconnect_timeout); + osmo_timer_schedule(&cli->timer, cli->reconnect_timeout, 0); + cli->state = STREAM_CLI_STATE_CONNECTING; } -void osmo_stream_client_conn_close(struct osmo_stream_client_conn *link) +void osmo_stream_cli_close(struct osmo_stream_cli *cli) { - osmo_fd_unregister(&link->ofd); - close(link->ofd.fd); + osmo_fd_unregister(&cli->ofd); + close(cli->ofd.fd); } -static void osmo_stream_client_read(struct osmo_stream_client_conn *link) +static void osmo_stream_cli_read(struct osmo_stream_cli *cli) { LOGP(DLINP, LOGL_DEBUG, "message received\n"); - if (link->read_cb) - link->read_cb(link); + if (cli->read_cb) + cli->read_cb(cli); } -static int osmo_stream_client_write(struct osmo_stream_client_conn *link) +static int osmo_stream_cli_write(struct osmo_stream_cli *cli) { struct msgb *msg; struct llist_head *lh; @@ -85,23 +85,23 @@ static int osmo_stream_client_write(struct osmo_stream_client_conn *link) LOGP(DLINP, LOGL_DEBUG, "sending data\n"); - if (llist_empty(&link->tx_queue)) { - link->ofd.when &= ~BSC_FD_WRITE; + if (llist_empty(&cli->tx_queue)) { + cli->ofd.when &= ~BSC_FD_WRITE; return 0; } - lh = link->tx_queue.next; + lh = cli->tx_queue.next; llist_del(lh); msg = llist_entry(lh, struct msgb, list); - if (link->state == STREAM_CLIENT_LINK_STATE_CONNECTING) { + if (cli->state == STREAM_CLI_STATE_CONNECTING) { LOGP(DLINP, LOGL_ERROR, "not connected, dropping data!\n"); return 0; } - ret = send(link->ofd.fd, msg->data, msg->len, 0); + ret = send(cli->ofd.fd, msg->data, msg->len, 0); if (ret < 0) { if (errno == EPIPE || errno == ENOTCONN) { - osmo_stream_client_reconnect(link); + osmo_stream_cli_reconnect(cli); } LOGP(DLINP, LOGL_ERROR, "error to send\n"); } @@ -109,33 +109,33 @@ static int osmo_stream_client_write(struct osmo_stream_client_conn *link) return 0; } -static int osmo_stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what) +static int osmo_stream_cli_fd_cb(struct osmo_fd *ofd, unsigned int what) { - struct osmo_stream_client_conn *link = ofd->data; + struct osmo_stream_cli *cli = ofd->data; int error, ret; socklen_t len = sizeof(error); - switch(link->state) { - case STREAM_CLIENT_LINK_STATE_CONNECTING: + switch(cli->state) { + case STREAM_CLI_STATE_CONNECTING: ret = getsockopt(ofd->fd, SOL_SOCKET, SO_ERROR, &error, &len); if (ret >= 0 && error > 0) { - osmo_stream_client_reconnect(link); + osmo_stream_cli_reconnect(cli); return 0; } ofd->when &= ~BSC_FD_WRITE; LOGP(DLINP, LOGL_DEBUG, "connection done.\n"); - link->state = STREAM_CLIENT_LINK_STATE_CONNECTED; - if (link->connect_cb) - link->connect_cb(link); + cli->state = STREAM_CLI_STATE_CONNECTED; + if (cli->connect_cb) + cli->connect_cb(cli); break; - case STREAM_CLIENT_LINK_STATE_CONNECTED: + case STREAM_CLI_STATE_CONNECTED: if (what & BSC_FD_READ) { LOGP(DLINP, LOGL_DEBUG, "connected read\n"); - osmo_stream_client_read(link); + osmo_stream_cli_read(cli); } if (what & BSC_FD_WRITE) { LOGP(DLINP, LOGL_DEBUG, "connected write\n"); - osmo_stream_client_write(link); + osmo_stream_cli_write(cli); } break; default: @@ -144,156 +144,151 @@ static int osmo_stream_client_fd_cb(struct osmo_fd *ofd, unsigned int what) return 0; } -static void link_timer_cb(void *data); +static void cli_timer_cb(void *data); -struct osmo_stream_client_conn *osmo_stream_client_conn_create(void *ctx) +struct osmo_stream_cli *osmo_stream_cli_create(void *ctx) { - struct osmo_stream_client_conn *link; + struct osmo_stream_cli *cli; - link = talloc_zero(ctx, struct osmo_stream_client_conn); - if (!link) + cli = talloc_zero(ctx, struct osmo_stream_cli); + if (!cli) return NULL; - link->ofd.fd = -1; - link->ofd.when |= BSC_FD_READ | BSC_FD_WRITE; - link->ofd.priv_nr = 0; /* XXX */ - 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; - link->timer.data = link; - link->reconnect_timeout = 5; /* default is 5 seconds. */ - INIT_LLIST_HEAD(&link->tx_queue); + cli->ofd.fd = -1; + cli->ofd.when |= BSC_FD_READ | BSC_FD_WRITE; + cli->ofd.priv_nr = 0; /* XXX */ + cli->ofd.cb = osmo_stream_cli_fd_cb; + cli->ofd.data = cli; + cli->state = STREAM_CLI_STATE_CONNECTING; + cli->timer.cb = cli_timer_cb; + cli->timer.data = link; + cli->reconnect_timeout = 5; /* default is 5 seconds. */ + INIT_LLIST_HEAD(&cli->tx_queue); - return link; + return cli; } void -osmo_stream_client_conn_set_addr(struct osmo_stream_client_conn *link, - const char *addr) +osmo_stream_cli_set_addr(struct osmo_stream_cli *cli, const char *addr) { - link->addr = talloc_strdup(link, addr); - link->flags |= OSMO_STREAM_CLIENT_F_RECONFIG; + cli->addr = talloc_strdup(cli, addr); + cli->flags |= OSMO_STREAM_CLI_F_RECONF; } void -osmo_stream_client_conn_set_port(struct osmo_stream_client_conn *link, - uint16_t port) +osmo_stream_cli_set_port(struct osmo_stream_cli *cli, uint16_t port) { - link->port = port; - link->flags |= OSMO_STREAM_CLIENT_F_RECONFIG; + cli->port = port; + cli->flags |= OSMO_STREAM_CLI_F_RECONF; } -void osmo_stream_client_conn_set_reconnect_timeout( - struct osmo_stream_client_conn *link, int timeout) +void +osmo_stream_cli_set_reconnect_timeout(struct osmo_stream_cli *cli, int timeout) { - link->reconnect_timeout = timeout; + cli->reconnect_timeout = timeout; } void -osmo_stream_client_conn_set_data(struct osmo_stream_client_conn *link, - void *data) +osmo_stream_cli_set_data(struct osmo_stream_cli *cli, void *data) { - link->data = data; + cli->data = data; } -void *osmo_stream_client_conn_get_data(struct osmo_stream_client_conn *link) +void *osmo_stream_cli_get_data(struct osmo_stream_cli *cli) { - return link->data; + return cli->data; } struct osmo_fd * -osmo_stream_client_conn_get_ofd(struct osmo_stream_client_conn *link) +osmo_stream_cli_get_ofd(struct osmo_stream_cli *cli) { - return &link->ofd; + return &cli->ofd; } void -osmo_stream_client_conn_set_connect_cb(struct osmo_stream_client_conn *link, - int (*connect_cb)(struct osmo_stream_client_conn *link)) +osmo_stream_cli_set_connect_cb(struct osmo_stream_cli *cli, + int (*connect_cb)(struct osmo_stream_cli *cli)) { - link->connect_cb = connect_cb; + cli->connect_cb = connect_cb; } void -osmo_stream_client_conn_set_read_cb(struct osmo_stream_client_conn *link, - int (*read_cb)(struct osmo_stream_client_conn *link)) +osmo_stream_cli_set_read_cb(struct osmo_stream_cli *cli, + int (*read_cb)(struct osmo_stream_cli *cli)) { - link->read_cb = read_cb; + cli->read_cb = read_cb; } -void osmo_stream_client_conn_destroy(struct osmo_stream_client_conn *link) +void osmo_stream_cli_destroy(struct osmo_stream_cli *cli) { talloc_free(link); } -int osmo_stream_client_conn_open(struct osmo_stream_client_conn *link) +int osmo_stream_cli_open(struct osmo_stream_cli *cli) { int ret; /* we are reconfiguring this socket, close existing first. */ - if ((link->flags & OSMO_STREAM_CLIENT_F_RECONFIG) && link->ofd.fd >= 0) - osmo_stream_client_conn_close(link); + if ((cli->flags & OSMO_STREAM_CLI_F_RECONF) && cli->ofd.fd >= 0) + osmo_stream_cli_close(cli); - link->flags &= ~OSMO_STREAM_CLIENT_F_RECONFIG; + cli->flags &= ~OSMO_STREAM_CLI_F_RECONF; ret = osmo_sock_init(AF_INET, SOCK_STREAM, IPPROTO_TCP, - link->addr, link->port, + cli->addr, cli->port, OSMO_SOCK_F_CONNECT|OSMO_SOCK_F_NONBLOCK); if (ret < 0) { if (errno != EINPROGRESS) return ret; } - link->ofd.fd = ret; - if (osmo_fd_register(&link->ofd) < 0) { + cli->ofd.fd = ret; + if (osmo_fd_register(&cli->ofd) < 0) { close(ret); return -EIO; } return 0; } -static void link_timer_cb(void *data) +static void cli_timer_cb(void *data) { - struct osmo_stream_client_conn *link = data; + struct osmo_stream_cli *cli = data; LOGP(DLINP, LOGL_DEBUG, "reconnecting.\n"); - switch(link->state) { - case STREAM_CLIENT_LINK_STATE_CONNECTING: - osmo_stream_client_conn_open(link); + switch(cli->state) { + case STREAM_CLI_STATE_CONNECTING: + osmo_stream_cli_open(cli); break; default: break; } } -void osmo_stream_client_conn_send(struct osmo_stream_client_conn *link, - struct msgb *msg) +void osmo_stream_cli_send(struct osmo_stream_cli *cli, struct msgb *msg) { - msgb_enqueue(&link->tx_queue, msg); - link->ofd.when |= BSC_FD_WRITE; + msgb_enqueue(&cli->tx_queue, msg); + cli->ofd.when |= BSC_FD_WRITE; } -int osmo_stream_client_conn_recv(struct osmo_stream_client_conn *link, - struct msgb *msg) +int osmo_stream_cli_recv(struct osmo_stream_cli *cli, struct msgb *msg) { int ret; - ret = recv(link->ofd.fd, msg->data, msg->data_len, 0); + ret = recv(cli->ofd.fd, msg->data, msg->data_len, 0); if (ret < 0) { if (errno == EPIPE || errno == ECONNRESET) { LOGP(DLINP, LOGL_ERROR, - "lost connection with server\n"); + "lost connection with srv\n"); } - osmo_stream_client_reconnect(link); + osmo_stream_cli_reconnect(cli); return ret; } else if (ret == 0) { - LOGP(DLINP, LOGL_ERROR, "connection closed with server\n"); - osmo_stream_client_reconnect(link); + LOGP(DLINP, LOGL_ERROR, "connection closed with srv\n"); + osmo_stream_cli_reconnect(cli); return ret; } msgb_put(msg, ret); - LOGP(DLINP, LOGL_DEBUG, "received %d bytes from server\n", ret); + LOGP(DLINP, LOGL_DEBUG, "received %d bytes from srv\n", ret); return ret; } @@ -301,23 +296,23 @@ int osmo_stream_client_conn_recv(struct osmo_stream_client_conn *link, * Server side. */ -#define OSMO_STREAM_SERVER_F_RECONFIG (1 << 0) +#define OSMO_STREAM_SRV_F_RECONF (1 << 0) -struct osmo_stream_server_link { +struct osmo_stream_srv_link { struct osmo_fd ofd; const char *addr; uint16_t port; - int (*accept_cb)(struct osmo_stream_server_link *link, int fd); + int (*accept_cb)(struct osmo_stream_srv_link *srv, int fd); void *data; int flags; }; -static int osmo_stream_server_fd_cb(struct osmo_fd *ofd, unsigned int what) +static int osmo_stream_srv_fd_cb(struct osmo_fd *ofd, unsigned int what) { int ret; struct sockaddr_in sa; socklen_t sa_len = sizeof(sa); - struct osmo_stream_server_link *link = ofd->data; + struct osmo_stream_srv_link *link = ofd->data; ret = accept(ofd->fd, (struct sockaddr *)&sa, &sa_len); if (ret < 0) { @@ -334,75 +329,75 @@ static int osmo_stream_server_fd_cb(struct osmo_fd *ofd, unsigned int what) return 0; } -struct osmo_stream_server_link *osmo_stream_server_link_create(void *ctx) +struct osmo_stream_srv_link *osmo_stream_srv_link_create(void *ctx) { - struct osmo_stream_server_link *link; + struct osmo_stream_srv_link *link; - link = talloc_zero(ctx, struct osmo_stream_server_link); + link = talloc_zero(ctx, struct osmo_stream_srv_link); if (!link) return NULL; link->ofd.fd = -1; link->ofd.when |= BSC_FD_READ | BSC_FD_WRITE; - link->ofd.cb = osmo_stream_server_fd_cb; + link->ofd.cb = osmo_stream_srv_fd_cb; link->ofd.data = link; return link; } -void osmo_stream_server_link_set_addr(struct osmo_stream_server_link *link, +void osmo_stream_srv_link_set_addr(struct osmo_stream_srv_link *link, const char *addr) { link->addr = talloc_strdup(link, addr); - link->flags |= OSMO_STREAM_SERVER_F_RECONFIG; + link->flags |= OSMO_STREAM_SRV_F_RECONF; } -void osmo_stream_server_link_set_port(struct osmo_stream_server_link *link, +void osmo_stream_srv_link_set_port(struct osmo_stream_srv_link *link, uint16_t port) { link->port = port; - link->flags |= OSMO_STREAM_SERVER_F_RECONFIG; + link->flags |= OSMO_STREAM_SRV_F_RECONF; } void -osmo_stream_server_link_set_data(struct osmo_stream_server_link *link, +osmo_stream_srv_link_set_data(struct osmo_stream_srv_link *link, void *data) { link->data = data; } -void *osmo_stream_server_link_get_data(struct osmo_stream_server_link *link) +void *osmo_stream_srv_link_get_data(struct osmo_stream_srv_link *link) { return link->data; } struct osmo_fd * -osmo_stream_server_link_get_ofd(struct osmo_stream_server_link *link) +osmo_stream_srv_link_get_ofd(struct osmo_stream_srv_link *link) { return &link->ofd; } -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)) +void osmo_stream_srv_link_set_accept_cb(struct osmo_stream_srv_link *link, + int (*accept_cb)(struct osmo_stream_srv_link *link, int fd)) { link->accept_cb = accept_cb; } -void osmo_stream_server_link_destroy(struct osmo_stream_server_link *link) +void osmo_stream_srv_link_destroy(struct osmo_stream_srv_link *link) { talloc_free(link); } -int osmo_stream_server_link_open(struct osmo_stream_server_link *link) +int osmo_stream_srv_link_open(struct osmo_stream_srv_link *link) { int ret; /* we are reconfiguring this socket, close existing first. */ - if ((link->flags & OSMO_STREAM_SERVER_F_RECONFIG) && link->ofd.fd >= 0) - osmo_stream_server_link_close(link); + if ((link->flags & OSMO_STREAM_SRV_F_RECONF) && link->ofd.fd >= 0) + osmo_stream_srv_link_close(link); - link->flags &= ~OSMO_STREAM_SERVER_F_RECONFIG; + link->flags &= ~OSMO_STREAM_SRV_F_RECONF; ret = osmo_sock_init(AF_INET, SOCK_STREAM, IPPROTO_TCP, link->addr, link->port, OSMO_SOCK_F_BIND); @@ -417,22 +412,22 @@ int osmo_stream_server_link_open(struct osmo_stream_server_link *link) return 0; } -void osmo_stream_server_link_close(struct osmo_stream_server_link *link) +void osmo_stream_srv_link_close(struct osmo_stream_srv_link *link) { osmo_fd_unregister(&link->ofd); close(link->ofd.fd); } -struct osmo_stream_server_conn { - struct osmo_stream_server_link *server; +struct osmo_stream_srv { + struct osmo_stream_srv_link *srv; struct osmo_fd ofd; struct llist_head tx_queue; - int (*closed_cb)(struct osmo_stream_server_conn *peer); - int (*cb)(struct osmo_stream_server_conn *peer); + int (*closed_cb)(struct osmo_stream_srv *peer); + int (*cb)(struct osmo_stream_srv *peer); void *data; }; -static void osmo_stream_server_conn_read(struct osmo_stream_server_conn *conn) +static void osmo_stream_srv_read(struct osmo_stream_srv *conn) { LOGP(DLINP, LOGL_DEBUG, "message received\n"); @@ -442,7 +437,7 @@ static void osmo_stream_server_conn_read(struct osmo_stream_server_conn *conn) return; } -static void osmo_stream_server_conn_write(struct osmo_stream_server_conn *conn) +static void osmo_stream_srv_write(struct osmo_stream_srv *conn) { struct msgb *msg; struct llist_head *lh; @@ -465,37 +460,37 @@ static void osmo_stream_server_conn_write(struct osmo_stream_server_conn *conn) msgb_free(msg); } -static int osmo_stream_server_conn_cb(struct osmo_fd *ofd, unsigned int what) +static int osmo_stream_srv_cb(struct osmo_fd *ofd, unsigned int what) { - struct osmo_stream_server_conn *conn = ofd->data; + struct osmo_stream_srv *conn = ofd->data; LOGP(DLINP, LOGL_DEBUG, "connected read/write\n"); if (what & BSC_FD_READ) - osmo_stream_server_conn_read(conn); + osmo_stream_srv_read(conn); if (what & BSC_FD_WRITE) - osmo_stream_server_conn_write(conn); + osmo_stream_srv_write(conn); return 0; } -struct osmo_stream_server_conn * -osmo_stream_server_conn_create(void *ctx, struct osmo_stream_server_link *link, +struct osmo_stream_srv * +osmo_stream_srv_create(void *ctx, struct osmo_stream_srv_link *link, int fd, - int (*cb)(struct osmo_stream_server_conn *conn), - int (*closed_cb)(struct osmo_stream_server_conn *conn), void *data) + int (*cb)(struct osmo_stream_srv *conn), + int (*closed_cb)(struct osmo_stream_srv *conn), void *data) { - struct osmo_stream_server_conn *conn; + struct osmo_stream_srv *conn; - conn = talloc_zero(ctx, struct osmo_stream_server_conn); + conn = talloc_zero(ctx, struct osmo_stream_srv); if (conn == NULL) { - LOGP(DLINP, LOGL_ERROR, "cannot allocate new peer in server, " + LOGP(DLINP, LOGL_ERROR, "cannot allocate new peer in srv, " "reason=`%s'\n", strerror(errno)); return NULL; } - conn->server = link; + conn->srv = link; conn->ofd.fd = fd; conn->ofd.data = conn; - conn->ofd.cb = osmo_stream_server_conn_cb; + conn->ofd.cb = osmo_stream_srv_cb; conn->ofd.when = BSC_FD_READ; conn->cb = cb; conn->closed_cb = closed_cb; @@ -511,24 +506,24 @@ osmo_stream_server_conn_create(void *ctx, struct osmo_stream_server_link *link, } void -osmo_stream_server_conn_set_data(struct osmo_stream_server_conn *conn, +osmo_stream_srv_set_data(struct osmo_stream_srv *conn, void *data) { conn->data = data; } -void *osmo_stream_server_conn_get_data(struct osmo_stream_server_conn *link) +void *osmo_stream_srv_get_data(struct osmo_stream_srv *link) { return link->data; } struct osmo_fd * -osmo_stream_server_conn_get_ofd(struct osmo_stream_server_conn *link) +osmo_stream_srv_get_ofd(struct osmo_stream_srv *link) { return &link->ofd; } -void osmo_stream_server_conn_destroy(struct osmo_stream_server_conn *conn) +void osmo_stream_srv_destroy(struct osmo_stream_srv *conn) { close(conn->ofd.fd); osmo_fd_unregister(&conn->ofd); @@ -537,15 +532,13 @@ void osmo_stream_server_conn_destroy(struct osmo_stream_server_conn *conn) talloc_free(conn); } -void osmo_stream_server_conn_send(struct osmo_stream_server_conn *conn, - struct msgb *msg) +void osmo_stream_srv_send(struct osmo_stream_srv *conn, struct msgb *msg) { msgb_enqueue(&conn->tx_queue, msg); conn->ofd.when |= BSC_FD_WRITE; } -int osmo_stream_server_conn_recv(struct osmo_stream_server_conn *conn, - struct msgb *msg) +int osmo_stream_srv_recv(struct osmo_stream_srv *conn, struct msgb *msg) { int ret; @@ -553,11 +546,11 @@ int osmo_stream_server_conn_recv(struct osmo_stream_server_conn *conn, if (ret < 0) { if (errno == EPIPE || errno == ECONNRESET) { LOGP(DLINP, LOGL_ERROR, - "lost connection with server\n"); + "lost connection with srv\n"); } return ret; } else if (ret == 0) { - LOGP(DLINP, LOGL_ERROR, "connection closed with server\n"); + LOGP(DLINP, LOGL_ERROR, "connection closed with srv\n"); return ret; } msgb_put(msg, ret); -- cgit v1.2.3