noinst_LTLIBRARIES = libsessiond-comm.la
-libsessiond_comm_la_SOURCES = sessiond-comm.c sessiond-comm.h \
- inet.c inet.h inet6.c inet6.h \
- relayd.h agent.h
+libsessiond_comm_la_SOURCES = \
+ agent.h \
+ inet.cpp \
+ inet.h \
+ inet6.cpp \
+ inet6.h \
+ relayd.h \
+ sessiond-comm.cpp \
+ sessiond-comm.h
+++ /dev/null
-/*
- * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
- *
- * SPDX-License-Identifier: GPL-2.0-only
- *
- */
-
-#define _LGPL_SOURCE
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <common/compat/time.h>
-#include <poll.h>
-
-#include <common/common.h>
-#include <common/time.h>
-#include <common/compat/errno.h>
-
-#include "inet.h"
-
-#define RECONNECT_DELAY 200 /* ms */
-
-/*
- * INET protocol operations.
- */
-static const struct lttcomm_proto_ops inet_ops = {
- .bind = lttcomm_bind_inet_sock,
- .close = lttcomm_close_inet_sock,
- .connect = lttcomm_connect_inet_sock,
- .accept = lttcomm_accept_inet_sock,
- .listen = lttcomm_listen_inet_sock,
- .recvmsg = lttcomm_recvmsg_inet_sock,
- .sendmsg = lttcomm_sendmsg_inet_sock,
-};
-
-unsigned long lttcomm_inet_tcp_timeout;
-
-/*
- * Creates an PF_INET socket.
- */
-int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
-{
- int val = 1, ret;
- unsigned long timeout;
-
- /* Create server socket */
- if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
- PERROR("socket inet");
- goto error;
- }
-
- sock->ops = &inet_ops;
-
- /*
- * Set socket option to reuse the address.
- */
- ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
- if (ret < 0) {
- PERROR("setsockopt inet");
- goto error;
- }
- timeout = lttcomm_get_network_timeout();
- if (timeout) {
- ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
- if (ret) {
- goto error;
- }
- ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
- if (ret) {
- goto error;
- }
- }
-
- return 0;
-
-error:
- return -1;
-}
-
-/*
- * Bind socket and return.
- */
-int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
-{
- struct sockaddr_in sockaddr = sock->sockaddr.addr.sin;
-
- return bind(sock->fd, &sockaddr, sizeof(sockaddr));
-}
-
-static
-int connect_no_timeout(struct lttcomm_sock *sock)
-{
- struct sockaddr_in sockaddr = sock->sockaddr.addr.sin;
-
- return connect(sock->fd, &sockaddr, sizeof(sockaddr));
-}
-
-static
-int connect_with_timeout(struct lttcomm_sock *sock)
-{
- unsigned long timeout = lttcomm_get_network_timeout();
- int ret, flags, connect_ret;
- struct timespec orig_time, cur_time;
- unsigned long diff_ms;
- struct sockaddr_in sockaddr;
-
- ret = fcntl(sock->fd, F_GETFL, 0);
- if (ret == -1) {
- PERROR("fcntl");
- return -1;
- }
- flags = ret;
-
- /* Set socket to nonblock */
- ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
- if (ret == -1) {
- PERROR("fcntl");
- return -1;
- }
-
- ret = lttng_clock_gettime(CLOCK_MONOTONIC, &orig_time);
- if (ret == -1) {
- PERROR("clock_gettime");
- return -1;
- }
-
- sockaddr = sock->sockaddr.addr.sin;
- connect_ret = connect(sock->fd, &sockaddr, sizeof(sockaddr));
- if (connect_ret == -1 && errno != EAGAIN && errno != EWOULDBLOCK &&
- errno != EINPROGRESS) {
- goto error;
- } else if (!connect_ret) {
- /* Connect succeeded */
- goto success;
- }
-
- DBG("Asynchronous connect for sock %d, performing polling with"
- " timeout: %lums", sock->fd, timeout);
- /*
- * Perform poll loop following EINPROGRESS recommendation from
- * connect(2) man page.
- */
- do {
- struct pollfd fds;
-
- fds.fd = sock->fd;
- fds.events = POLLOUT;
- fds.revents = 0;
- ret = poll(&fds, 1, RECONNECT_DELAY);
- if (ret < 0) {
- goto error;
- } else if (ret > 0) {
- int optval;
- socklen_t optval_len = sizeof(optval);
-
- if (!(fds.revents & POLLOUT)) {
- /* Either hup or error */
- errno = EPIPE;
- goto error;
- }
- /* got something */
- ret = getsockopt(sock->fd, SOL_SOCKET,
- SO_ERROR, &optval, &optval_len);
- if (ret) {
- PERROR("getsockopt");
- goto error;
- }
- if (!optval) {
- connect_ret = 0;
- goto success;
- } else {
- /* Get actual connect() errno from opt_val */
- errno = optval;
- goto error;
- }
- }
- /* ret == 0: timeout */
- ret = lttng_clock_gettime(CLOCK_MONOTONIC, &cur_time);
- if (ret == -1) {
- PERROR("clock_gettime");
- connect_ret = ret;
- goto error;
- }
- if (timespec_to_ms(timespec_abs_diff(cur_time, orig_time), &diff_ms) < 0) {
- ERR("timespec_to_ms input overflows milliseconds output");
- connect_ret = -1;
- goto error;
- }
- } while (diff_ms < timeout);
-
- /* Timeout */
- errno = ETIMEDOUT;
- connect_ret = -1;
-
-success:
- /* Restore initial flags */
- ret = fcntl(sock->fd, F_SETFL, flags);
- if (ret == -1) {
- PERROR("fcntl");
- /* Continue anyway */
- }
-error:
- return connect_ret;
-}
-
-/*
- * Connect PF_INET socket.
- */
-int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
-{
- int ret, closeret;
-
- if (lttcomm_get_network_timeout()) {
- ret = connect_with_timeout(sock);
- } else {
- ret = connect_no_timeout(sock);
- }
- if (ret < 0) {
- PERROR("connect");
- goto error_connect;
- }
-
- return ret;
-
-error_connect:
- closeret = close(sock->fd);
- if (closeret) {
- PERROR("close inet");
- }
-
- return ret;
-}
-
-/*
- * Do an accept(2) on the sock and return the new lttcomm socket. The socket
- * MUST be bind(2) before.
- */
-struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
-{
- int new_fd;
- socklen_t len;
- struct lttcomm_sock *new_sock;
- unsigned long timeout;
- struct sockaddr_in new_addr = {};
-
- if (sock->proto == LTTCOMM_SOCK_UDP) {
- /*
- * accept(2) does not exist for UDP so simply return the passed socket.
- */
- new_sock = sock;
- goto end;
- }
-
- new_sock = lttcomm_alloc_sock(sock->proto);
- if (new_sock == NULL) {
- goto error;
- }
-
- len = sizeof(new_addr);
-
- /* Blocking call */
- new_fd = accept(sock->fd, (struct sockaddr *) &new_addr, &len);
- if (new_fd < 0) {
- PERROR("accept inet");
- goto error;
- }
- new_sock->sockaddr.addr.sin = new_addr;
- timeout = lttcomm_get_network_timeout();
- if (timeout) {
- int ret;
-
- ret = lttcomm_setsockopt_rcv_timeout(new_fd, timeout);
- if (ret) {
- goto error_close;
- }
- ret = lttcomm_setsockopt_snd_timeout(new_fd, timeout);
- if (ret) {
- goto error_close;
- }
- }
-
- new_sock->fd = new_fd;
- new_sock->ops = &inet_ops;
-
-end:
- return new_sock;
-
-error_close:
- if (close(new_fd) < 0) {
- PERROR("accept inet close fd");
- }
-
-error:
- free(new_sock);
- return NULL;
-}
-
-/*
- * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
- */
-int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
-{
- int ret;
-
- if (sock->proto == LTTCOMM_SOCK_UDP) {
- /* listen(2) does not exist for UDP so simply return success. */
- ret = 0;
- goto end;
- }
-
- /* Default listen backlog */
- if (backlog <= 0) {
- backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
- }
-
- ret = listen(sock->fd, backlog);
- if (ret < 0) {
- PERROR("listen inet");
- }
-
-end:
- return ret;
-}
-
-/*
- * Receive data of size len in put that data into the buf param. Using recvmsg
- * API.
- *
- * Return the size of received data.
- */
-ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
- size_t len, int flags)
-{
- struct msghdr msg;
- struct iovec iov[1];
- ssize_t ret = -1;
- size_t len_last;
- struct sockaddr_in addr = sock->sockaddr.addr.sin;
-
- memset(&msg, 0, sizeof(msg));
-
- iov[0].iov_base = buf;
- iov[0].iov_len = len;
- msg.msg_iov = iov;
- msg.msg_iovlen = 1;
-
- msg.msg_name = (struct sockaddr *) &addr;
- msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
-
- do {
- len_last = iov[0].iov_len;
- ret = recvmsg(sock->fd, &msg, flags);
- if (ret > 0) {
- if (flags & MSG_DONTWAIT) {
- goto end;
- }
- iov[0].iov_base += ret;
- iov[0].iov_len -= ret;
- LTTNG_ASSERT(ret <= len_last);
- }
- } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
-
- if (ret < 0) {
- if (errno == EAGAIN && flags & MSG_DONTWAIT) {
- /*
- * EAGAIN is expected in non-blocking mode and should
- * not be reported as an error. Moreover, if no data
- * was read, 0 must not be returned as it would be
- * interpreted as an orderly shutdown of the socket.
- */
- goto end;
- }
- PERROR("recvmsg inet");
- } else if (ret > 0) {
- ret = len;
- }
- /* Else ret = 0 meaning an orderly shutdown. */
-end:
- return ret;
-}
-
-/*
- * Send buf data of size len. Using sendmsg API.
- *
- * Return the size of sent data.
- */
-ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, const void *buf,
- size_t len, int flags)
-{
- struct msghdr msg;
- struct iovec iov[1];
- ssize_t ret = -1;
-
- memset(&msg, 0, sizeof(msg));
-
- iov[0].iov_base = (void *) buf;
- iov[0].iov_len = len;
- msg.msg_iov = iov;
- msg.msg_iovlen = 1;
-
- switch (sock->proto) {
- case LTTCOMM_SOCK_UDP:
- {
- struct sockaddr_in addr = sock->sockaddr.addr.sin;
-
- msg.msg_name = (struct sockaddr *) &addr;
- msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
- break;
- }
- default:
- break;
- }
-
- do {
- ret = sendmsg(sock->fd, &msg, flags);
- } while (ret < 0 && errno == EINTR);
- if (ret < 0) {
- /*
- * Only warn about EPIPE when quiet mode is deactivated.
- * We consider EPIPE as expected.
- */
- if (errno != EPIPE || !lttng_opt_quiet) {
- PERROR("sendmsg inet");
- }
- }
-
- return ret;
-}
-
-/*
- * Shutdown cleanly and close.
- */
-int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
-{
- int ret;
-
- /* Don't try to close an invalid marked socket */
- if (sock->fd == -1) {
- return 0;
- }
-
- ret = close(sock->fd);
- if (ret) {
- PERROR("close inet");
- }
-
- /* Mark socket */
- sock->fd = -1;
-
- return ret;
-}
-
-/*
- * Return value read from /proc or else 0 if value is not found.
- */
-static unsigned long read_proc_value(const char *path)
-{
- int ret, fd;
- ssize_t size_ret;
- long r_val;
- unsigned long val = 0;
- char buf[64];
-
- fd = open(path, O_RDONLY);
- if (fd < 0) {
- goto error;
- }
-
- size_ret = lttng_read(fd, buf, sizeof(buf));
- /*
- * Allow reading a file smaller than buf, but keep space for
- * final \0.
- */
- if (size_ret < 0 || size_ret >= sizeof(buf)) {
- PERROR("read proc failed");
- goto error_close;
- }
- buf[size_ret] = '\0';
-
- errno = 0;
- r_val = strtol(buf, NULL, 10);
- if (errno != 0 || r_val < -1L) {
- val = 0;
- goto error_close;
- } else {
- if (r_val > 0) {
- val = r_val;
- }
- }
-
-error_close:
- ret = close(fd);
- if (ret) {
- PERROR("close /proc value");
- }
-error:
- return val;
-}
-
-void lttcomm_inet_init(void)
-{
- unsigned long syn_retries, fin_timeout, syn_timeout, env;
-
- env = lttcomm_get_network_timeout();
- if (env) {
- lttcomm_inet_tcp_timeout = env;
- goto end;
- }
-
- /* Assign default value and see if we can change it. */
- lttcomm_inet_tcp_timeout = DEFAULT_INET_TCP_TIMEOUT;
-
- syn_retries = read_proc_value(LTTCOMM_INET_PROC_SYN_RETRIES_PATH);
- fin_timeout = read_proc_value(LTTCOMM_INET_PROC_FIN_TIMEOUT_PATH);
-
- syn_timeout = syn_retries * LTTCOMM_INET_SYN_TIMEOUT_FACTOR;
-
- /*
- * Get the maximum between the two possible timeout value and use that to
- * get the maximum with the default timeout.
- */
- lttcomm_inet_tcp_timeout = max_t(unsigned long,
- max_t(unsigned long, syn_timeout, fin_timeout),
- lttcomm_inet_tcp_timeout);
-
-end:
- DBG("TCP inet operation timeout set to %lu sec", lttcomm_inet_tcp_timeout);
-}
--- /dev/null
+/*
+ * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ *
+ */
+
+#define _LGPL_SOURCE
+#include <algorithm>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <common/compat/time.h>
+#include <poll.h>
+
+#include <common/common.h>
+#include <common/time.h>
+#include <common/compat/errno.h>
+
+#include "inet.h"
+
+#define RECONNECT_DELAY 200 /* ms */
+
+/*
+ * INET protocol operations.
+ */
+static const struct lttcomm_proto_ops inet_ops = {
+ .bind = lttcomm_bind_inet_sock,
+ .close = lttcomm_close_inet_sock,
+ .connect = lttcomm_connect_inet_sock,
+ .accept = lttcomm_accept_inet_sock,
+ .listen = lttcomm_listen_inet_sock,
+ .recvmsg = lttcomm_recvmsg_inet_sock,
+ .sendmsg = lttcomm_sendmsg_inet_sock,
+};
+
+unsigned long lttcomm_inet_tcp_timeout;
+
+/*
+ * Creates an PF_INET socket.
+ */
+int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
+{
+ int val = 1, ret;
+ unsigned long timeout;
+
+ /* Create server socket */
+ if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
+ PERROR("socket inet");
+ goto error;
+ }
+
+ sock->ops = &inet_ops;
+
+ /*
+ * Set socket option to reuse the address.
+ */
+ ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
+ if (ret < 0) {
+ PERROR("setsockopt inet");
+ goto error;
+ }
+ timeout = lttcomm_get_network_timeout();
+ if (timeout) {
+ ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
+ if (ret) {
+ goto error;
+ }
+ ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
+ if (ret) {
+ goto error;
+ }
+ }
+
+ return 0;
+
+error:
+ return -1;
+}
+
+/*
+ * Bind socket and return.
+ */
+int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
+{
+ struct sockaddr_in sockaddr = sock->sockaddr.addr.sin;
+
+ return bind(sock->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr));
+}
+
+static
+int connect_no_timeout(struct lttcomm_sock *sock)
+{
+ struct sockaddr_in sockaddr = sock->sockaddr.addr.sin;
+
+ return connect(sock->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr));
+}
+
+static
+int connect_with_timeout(struct lttcomm_sock *sock)
+{
+ unsigned long timeout = lttcomm_get_network_timeout();
+ int ret, flags, connect_ret;
+ struct timespec orig_time, cur_time;
+ unsigned long diff_ms;
+ struct sockaddr_in sockaddr;
+
+ ret = fcntl(sock->fd, F_GETFL, 0);
+ if (ret == -1) {
+ PERROR("fcntl");
+ return -1;
+ }
+ flags = ret;
+
+ /* Set socket to nonblock */
+ ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
+ if (ret == -1) {
+ PERROR("fcntl");
+ return -1;
+ }
+
+ ret = lttng_clock_gettime(CLOCK_MONOTONIC, &orig_time);
+ if (ret == -1) {
+ PERROR("clock_gettime");
+ return -1;
+ }
+
+ sockaddr = sock->sockaddr.addr.sin;
+ connect_ret = connect(sock->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr));
+ if (connect_ret == -1 && errno != EAGAIN && errno != EWOULDBLOCK &&
+ errno != EINPROGRESS) {
+ goto error;
+ } else if (!connect_ret) {
+ /* Connect succeeded */
+ goto success;
+ }
+
+ DBG("Asynchronous connect for sock %d, performing polling with"
+ " timeout: %lums", sock->fd, timeout);
+ /*
+ * Perform poll loop following EINPROGRESS recommendation from
+ * connect(2) man page.
+ */
+ do {
+ struct pollfd fds;
+
+ fds.fd = sock->fd;
+ fds.events = POLLOUT;
+ fds.revents = 0;
+ ret = poll(&fds, 1, RECONNECT_DELAY);
+ if (ret < 0) {
+ goto error;
+ } else if (ret > 0) {
+ int optval;
+ socklen_t optval_len = sizeof(optval);
+
+ if (!(fds.revents & POLLOUT)) {
+ /* Either hup or error */
+ errno = EPIPE;
+ goto error;
+ }
+ /* got something */
+ ret = getsockopt(sock->fd, SOL_SOCKET,
+ SO_ERROR, &optval, &optval_len);
+ if (ret) {
+ PERROR("getsockopt");
+ goto error;
+ }
+ if (!optval) {
+ connect_ret = 0;
+ goto success;
+ } else {
+ /* Get actual connect() errno from opt_val */
+ errno = optval;
+ goto error;
+ }
+ }
+ /* ret == 0: timeout */
+ ret = lttng_clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ if (ret == -1) {
+ PERROR("clock_gettime");
+ connect_ret = ret;
+ goto error;
+ }
+ if (timespec_to_ms(timespec_abs_diff(cur_time, orig_time), &diff_ms) < 0) {
+ ERR("timespec_to_ms input overflows milliseconds output");
+ connect_ret = -1;
+ goto error;
+ }
+ } while (diff_ms < timeout);
+
+ /* Timeout */
+ errno = ETIMEDOUT;
+ connect_ret = -1;
+
+success:
+ /* Restore initial flags */
+ ret = fcntl(sock->fd, F_SETFL, flags);
+ if (ret == -1) {
+ PERROR("fcntl");
+ /* Continue anyway */
+ }
+error:
+ return connect_ret;
+}
+
+/*
+ * Connect PF_INET socket.
+ */
+int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
+{
+ int ret, closeret;
+
+ if (lttcomm_get_network_timeout()) {
+ ret = connect_with_timeout(sock);
+ } else {
+ ret = connect_no_timeout(sock);
+ }
+ if (ret < 0) {
+ PERROR("connect");
+ goto error_connect;
+ }
+
+ return ret;
+
+error_connect:
+ closeret = close(sock->fd);
+ if (closeret) {
+ PERROR("close inet");
+ }
+
+ return ret;
+}
+
+/*
+ * Do an accept(2) on the sock and return the new lttcomm socket. The socket
+ * MUST be bind(2) before.
+ */
+struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
+{
+ int new_fd;
+ socklen_t len;
+ struct lttcomm_sock *new_sock;
+ unsigned long timeout;
+ struct sockaddr_in new_addr = {};
+
+ if (sock->proto == LTTCOMM_SOCK_UDP) {
+ /*
+ * accept(2) does not exist for UDP so simply return the passed socket.
+ */
+ new_sock = sock;
+ goto end;
+ }
+
+ new_sock = lttcomm_alloc_sock(sock->proto);
+ if (new_sock == NULL) {
+ goto error;
+ }
+
+ len = sizeof(new_addr);
+
+ /* Blocking call */
+ new_fd = accept(sock->fd, (struct sockaddr *) &new_addr, &len);
+ if (new_fd < 0) {
+ PERROR("accept inet");
+ goto error;
+ }
+ new_sock->sockaddr.addr.sin = new_addr;
+ timeout = lttcomm_get_network_timeout();
+ if (timeout) {
+ int ret;
+
+ ret = lttcomm_setsockopt_rcv_timeout(new_fd, timeout);
+ if (ret) {
+ goto error_close;
+ }
+ ret = lttcomm_setsockopt_snd_timeout(new_fd, timeout);
+ if (ret) {
+ goto error_close;
+ }
+ }
+
+ new_sock->fd = new_fd;
+ new_sock->ops = &inet_ops;
+
+end:
+ return new_sock;
+
+error_close:
+ if (close(new_fd) < 0) {
+ PERROR("accept inet close fd");
+ }
+
+error:
+ free(new_sock);
+ return NULL;
+}
+
+/*
+ * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
+ */
+int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
+{
+ int ret;
+
+ if (sock->proto == LTTCOMM_SOCK_UDP) {
+ /* listen(2) does not exist for UDP so simply return success. */
+ ret = 0;
+ goto end;
+ }
+
+ /* Default listen backlog */
+ if (backlog <= 0) {
+ backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
+ }
+
+ ret = listen(sock->fd, backlog);
+ if (ret < 0) {
+ PERROR("listen inet");
+ }
+
+end:
+ return ret;
+}
+
+/*
+ * Receive data of size len in put that data into the buf param. Using recvmsg
+ * API.
+ *
+ * Return the size of received data.
+ */
+ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
+ size_t len, int flags)
+{
+ struct msghdr msg;
+ struct iovec iov[1];
+ ssize_t ret = -1;
+ size_t len_last;
+ struct sockaddr_in addr = sock->sockaddr.addr.sin;
+
+ memset(&msg, 0, sizeof(msg));
+
+ iov[0].iov_base = buf;
+ iov[0].iov_len = len;
+ msg.msg_iov = iov;
+ msg.msg_iovlen = 1;
+
+ msg.msg_name = (struct sockaddr *) &addr;
+ msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
+
+ do {
+ len_last = iov[0].iov_len;
+ ret = recvmsg(sock->fd, &msg, flags);
+ if (ret > 0) {
+ if (flags & MSG_DONTWAIT) {
+ goto end;
+ }
+ iov[0].iov_base = ((char *) iov[0].iov_base) + ret;
+ iov[0].iov_len -= ret;
+ LTTNG_ASSERT(ret <= len_last);
+ }
+ } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
+
+ if (ret < 0) {
+ if (errno == EAGAIN && flags & MSG_DONTWAIT) {
+ /*
+ * EAGAIN is expected in non-blocking mode and should
+ * not be reported as an error. Moreover, if no data
+ * was read, 0 must not be returned as it would be
+ * interpreted as an orderly shutdown of the socket.
+ */
+ goto end;
+ }
+ PERROR("recvmsg inet");
+ } else if (ret > 0) {
+ ret = len;
+ }
+ /* Else ret = 0 meaning an orderly shutdown. */
+end:
+ return ret;
+}
+
+/*
+ * Send buf data of size len. Using sendmsg API.
+ *
+ * Return the size of sent data.
+ */
+ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, const void *buf,
+ size_t len, int flags)
+{
+ struct msghdr msg;
+ struct iovec iov[1];
+ ssize_t ret = -1;
+
+ memset(&msg, 0, sizeof(msg));
+
+ iov[0].iov_base = (void *) buf;
+ iov[0].iov_len = len;
+ msg.msg_iov = iov;
+ msg.msg_iovlen = 1;
+
+ switch (sock->proto) {
+ case LTTCOMM_SOCK_UDP:
+ {
+ struct sockaddr_in addr = sock->sockaddr.addr.sin;
+
+ msg.msg_name = (struct sockaddr *) &addr;
+ msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
+ break;
+ }
+ default:
+ break;
+ }
+
+ do {
+ ret = sendmsg(sock->fd, &msg, flags);
+ } while (ret < 0 && errno == EINTR);
+ if (ret < 0) {
+ /*
+ * Only warn about EPIPE when quiet mode is deactivated.
+ * We consider EPIPE as expected.
+ */
+ if (errno != EPIPE || !lttng_opt_quiet) {
+ PERROR("sendmsg inet");
+ }
+ }
+
+ return ret;
+}
+
+/*
+ * Shutdown cleanly and close.
+ */
+int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
+{
+ int ret;
+
+ /* Don't try to close an invalid marked socket */
+ if (sock->fd == -1) {
+ return 0;
+ }
+
+ ret = close(sock->fd);
+ if (ret) {
+ PERROR("close inet");
+ }
+
+ /* Mark socket */
+ sock->fd = -1;
+
+ return ret;
+}
+
+/*
+ * Return value read from /proc or else 0 if value is not found.
+ */
+static unsigned long read_proc_value(const char *path)
+{
+ int ret, fd;
+ ssize_t size_ret;
+ long r_val;
+ unsigned long val = 0;
+ char buf[64];
+
+ fd = open(path, O_RDONLY);
+ if (fd < 0) {
+ goto error;
+ }
+
+ size_ret = lttng_read(fd, buf, sizeof(buf));
+ /*
+ * Allow reading a file smaller than buf, but keep space for
+ * final \0.
+ */
+ if (size_ret < 0 || size_ret >= sizeof(buf)) {
+ PERROR("read proc failed");
+ goto error_close;
+ }
+ buf[size_ret] = '\0';
+
+ errno = 0;
+ r_val = strtol(buf, NULL, 10);
+ if (errno != 0 || r_val < -1L) {
+ val = 0;
+ goto error_close;
+ } else {
+ if (r_val > 0) {
+ val = r_val;
+ }
+ }
+
+error_close:
+ ret = close(fd);
+ if (ret) {
+ PERROR("close /proc value");
+ }
+error:
+ return val;
+}
+
+void lttcomm_inet_init(void)
+{
+ unsigned long syn_retries, fin_timeout, syn_timeout, env;
+
+ env = lttcomm_get_network_timeout();
+ if (env) {
+ lttcomm_inet_tcp_timeout = env;
+ goto end;
+ }
+
+ /* Assign default value and see if we can change it. */
+ lttcomm_inet_tcp_timeout = DEFAULT_INET_TCP_TIMEOUT;
+
+ syn_retries = read_proc_value(LTTCOMM_INET_PROC_SYN_RETRIES_PATH);
+ fin_timeout = read_proc_value(LTTCOMM_INET_PROC_FIN_TIMEOUT_PATH);
+
+ syn_timeout = syn_retries * LTTCOMM_INET_SYN_TIMEOUT_FACTOR;
+
+ /*
+ * Get the maximum between the two possible timeout value and use that to
+ * get the maximum with the default timeout.
+ */
+ lttcomm_inet_tcp_timeout = std::max(std::max(syn_timeout, fin_timeout),
+ lttcomm_inet_tcp_timeout);
+
+end:
+ DBG("TCP inet operation timeout set to %lu sec", lttcomm_inet_tcp_timeout);
+}
+++ /dev/null
-/*
- * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
- *
- * SPDX-License-Identifier: GPL-2.0-only
- *
- */
-
-#define _LGPL_SOURCE
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <common/compat/time.h>
-#include <poll.h>
-
-#include <common/common.h>
-#include <common/time.h>
-#include <common/compat/errno.h>
-
-#include "inet6.h"
-
-#define RECONNECT_DELAY 200 /* ms */
-
-/*
- * INET protocol operations.
- */
-static const struct lttcomm_proto_ops inet6_ops = {
- .bind = lttcomm_bind_inet6_sock,
- .close = lttcomm_close_inet6_sock,
- .connect = lttcomm_connect_inet6_sock,
- .accept = lttcomm_accept_inet6_sock,
- .listen = lttcomm_listen_inet6_sock,
- .recvmsg = lttcomm_recvmsg_inet6_sock,
- .sendmsg = lttcomm_sendmsg_inet6_sock,
-};
-
-/*
- * Creates an PF_INET socket.
- */
-int lttcomm_create_inet6_sock(struct lttcomm_sock *sock, int type, int proto)
-{
- int val = 1, ret;
- unsigned long timeout;
-
- /* Create server socket */
- if ((sock->fd = socket(PF_INET6, type, proto)) < 0) {
- PERROR("socket inet6");
- goto error;
- }
-
- sock->ops = &inet6_ops;
-
- /*
- * Set socket option to reuse the address.
- */
- ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
- if (ret < 0) {
- PERROR("setsockopt inet6");
- goto error;
- }
- timeout = lttcomm_get_network_timeout();
- if (timeout) {
- ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
- if (ret) {
- goto error;
- }
- ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
- if (ret) {
- goto error;
- }
- }
-
- return 0;
-
-error:
- return -1;
-}
-
-/*
- * Bind socket and return.
- */
-int lttcomm_bind_inet6_sock(struct lttcomm_sock *sock)
-{
- struct sockaddr_in6 sockaddr = sock->sockaddr.addr.sin6;
- return bind(sock->fd, &sockaddr, sizeof(sockaddr));
-}
-
-static
-int connect_no_timeout(struct lttcomm_sock *sock)
-{
- struct sockaddr_in6 sockaddr = sock->sockaddr.addr.sin6;
- return connect(sock->fd, &sockaddr, sizeof(sockaddr));
-}
-
-static
-int connect_with_timeout(struct lttcomm_sock *sock)
-{
- unsigned long timeout = lttcomm_get_network_timeout();
- int ret, flags, connect_ret;
- struct timespec orig_time, cur_time;
- unsigned long diff_ms;
- struct sockaddr_in6 sockaddr;
-
- ret = fcntl(sock->fd, F_GETFL, 0);
- if (ret == -1) {
- PERROR("fcntl");
- return -1;
- }
- flags = ret;
-
- /* Set socket to nonblock */
- ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
- if (ret == -1) {
- PERROR("fcntl");
- return -1;
- }
-
- ret = lttng_clock_gettime(CLOCK_MONOTONIC, &orig_time);
- if (ret == -1) {
- PERROR("clock_gettime");
- return -1;
- }
-
- sockaddr = sock->sockaddr.addr.sin6;
- connect_ret = connect(sock->fd, &sockaddr, sizeof(sockaddr));
- if (connect_ret == -1 && errno != EAGAIN && errno != EWOULDBLOCK &&
- errno != EINPROGRESS) {
- goto error;
- } else if (!connect_ret) {
- /* Connect succeeded */
- goto success;
- }
-
- DBG("Asynchronous connect for sock %d, performing polling with"
- " timeout: %lums", sock->fd, timeout);
-
- /*
- * Perform poll loop following EINPROGRESS recommendation from
- * connect(2) man page.
- */
- do {
- struct pollfd fds;
-
- fds.fd = sock->fd;
- fds.events = POLLOUT;
- fds.revents = 0;
- ret = poll(&fds, 1, RECONNECT_DELAY);
- if (ret < 0) {
- goto error;
- } else if (ret > 0) {
- int optval;
- socklen_t optval_len = sizeof(optval);
-
- if (!(fds.revents & POLLOUT)) {
- /* Either hup or error */
- errno = EPIPE;
- goto error;
- }
- /* got something */
- ret = getsockopt(sock->fd, SOL_SOCKET,
- SO_ERROR, &optval, &optval_len);
- if (ret) {
- PERROR("getsockopt");
- goto error;
- }
- if (!optval) {
- connect_ret = 0;
- goto success;
- } else {
- /* Get actual connect() errno from opt_val */
- errno = optval;
- goto error;
- }
- }
- /* ret == 0: timeout */
- ret = lttng_clock_gettime(CLOCK_MONOTONIC, &cur_time);
- if (ret == -1) {
- PERROR("clock_gettime");
- connect_ret = ret;
- goto error;
- }
- if (timespec_to_ms(timespec_abs_diff(cur_time, orig_time), &diff_ms) < 0) {
- ERR("timespec_to_ms input overflows milliseconds output");
- connect_ret = -1;
- goto error;
- }
- } while (diff_ms < timeout);
-
- /* Timeout */
- errno = ETIMEDOUT;
- connect_ret = -1;
-
-success:
- /* Restore initial flags */
- ret = fcntl(sock->fd, F_SETFL, flags);
- if (ret == -1) {
- PERROR("fcntl");
- /* Continue anyway */
- }
-error:
- return connect_ret;
-}
-
-/*
- * Connect PF_INET socket.
- */
-int lttcomm_connect_inet6_sock(struct lttcomm_sock *sock)
-{
- int ret, closeret;
-
- if (lttcomm_get_network_timeout()) {
- ret = connect_with_timeout(sock);
- } else {
- ret = connect_no_timeout(sock);
- }
- if (ret < 0) {
- PERROR("connect inet6");
- goto error_connect;
- }
-
- return ret;
-
-error_connect:
- closeret = close(sock->fd);
- if (closeret) {
- PERROR("close inet6");
- }
-
- return ret;
-}
-
-/*
- * Do an accept(2) on the sock and return the new lttcomm socket. The socket
- * MUST be bind(2) before.
- */
-struct lttcomm_sock *lttcomm_accept_inet6_sock(struct lttcomm_sock *sock)
-{
- int new_fd;
- socklen_t len;
- struct lttcomm_sock *new_sock;
- struct sockaddr_in6 new_addr = {};
-
- if (sock->proto == LTTCOMM_SOCK_UDP) {
- /*
- * accept(2) does not exist for UDP so simply return the passed socket.
- */
- new_sock = sock;
- goto end;
- }
-
- new_sock = lttcomm_alloc_sock(sock->proto);
- if (new_sock == NULL) {
- goto error;
- }
-
- len = sizeof(new_addr);
-
- /* Blocking call */
- new_fd = accept(sock->fd, (struct sockaddr *) &new_addr, &len);
- if (new_fd < 0) {
- PERROR("accept inet6");
- goto error;
- }
- new_sock->sockaddr.addr.sin6 = new_addr;
- new_sock->fd = new_fd;
- new_sock->ops = &inet6_ops;
-
-end:
- return new_sock;
-
-error:
- free(new_sock);
- return NULL;
-}
-
-/*
- * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
- */
-int lttcomm_listen_inet6_sock(struct lttcomm_sock *sock, int backlog)
-{
- int ret;
-
- if (sock->proto == LTTCOMM_SOCK_UDP) {
- /* listen(2) does not exist for UDP so simply return success. */
- ret = 0;
- goto end;
- }
-
- /* Default listen backlog */
- if (backlog <= 0) {
- backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
- }
-
- ret = listen(sock->fd, backlog);
- if (ret < 0) {
- PERROR("listen inet6");
- }
-
-end:
- return ret;
-}
-
-/*
- * Receive data of size len in put that data into the buf param. Using recvmsg
- * API.
- *
- * Return the size of received data.
- */
-ssize_t lttcomm_recvmsg_inet6_sock(struct lttcomm_sock *sock, void *buf,
- size_t len, int flags)
-{
- struct msghdr msg;
- struct iovec iov[1];
- ssize_t ret = -1;
- size_t len_last;
- struct sockaddr_in6 addr = sock->sockaddr.addr.sin6;
-
- memset(&msg, 0, sizeof(msg));
-
- iov[0].iov_base = buf;
- iov[0].iov_len = len;
- msg.msg_iov = iov;
- msg.msg_iovlen = 1;
-
- msg.msg_name = (struct sockaddr *) &addr;
- msg.msg_namelen = sizeof(sock->sockaddr.addr.sin6);
-
- do {
- len_last = iov[0].iov_len;
- ret = recvmsg(sock->fd, &msg, flags);
- if (ret > 0) {
- if (flags & MSG_DONTWAIT) {
- goto end;
- }
- iov[0].iov_base += ret;
- iov[0].iov_len -= ret;
- LTTNG_ASSERT(ret <= len_last);
- }
- } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
- if (ret < 0) {
- PERROR("recvmsg inet");
- } else if (ret > 0) {
- ret = len;
- }
- /* Else ret = 0 meaning an orderly shutdown. */
-end:
- return ret;
-}
-
-/*
- * Send buf data of size len. Using sendmsg API.
- *
- * Return the size of sent data.
- */
-ssize_t lttcomm_sendmsg_inet6_sock(struct lttcomm_sock *sock, const void *buf,
- size_t len, int flags)
-{
- struct msghdr msg;
- struct iovec iov[1];
- ssize_t ret = -1;
-
- memset(&msg, 0, sizeof(msg));
-
- iov[0].iov_base = (void *) buf;
- iov[0].iov_len = len;
- msg.msg_iov = iov;
- msg.msg_iovlen = 1;
-
- switch (sock->proto) {
- case LTTCOMM_SOCK_UDP:
- {
- struct sockaddr_in6 addr = sock->sockaddr.addr.sin6;
-
- msg.msg_name = (struct sockaddr *) &addr;
- msg.msg_namelen = sizeof(sock->sockaddr.addr.sin6);
- break;
- }
- default:
- break;
- }
-
- do {
- ret = sendmsg(sock->fd, &msg, flags);
- } while (ret < 0 && errno == EINTR);
- if (ret < 0) {
- /*
- * Only warn about EPIPE when quiet mode is deactivated.
- * We consider EPIPE as expected.
- */
- if (errno != EPIPE || !lttng_opt_quiet) {
- PERROR("sendmsg inet6");
- }
- }
-
- return ret;
-}
-
-/*
- * Shutdown cleanly and close.
- */
-int lttcomm_close_inet6_sock(struct lttcomm_sock *sock)
-{
- int ret;
-
- /* Don't try to close an invalid marked socket */
- if (sock->fd == -1) {
- return 0;
- }
-
- ret = close(sock->fd);
- if (ret) {
- PERROR("close inet6");
- }
-
- /* Mark socket */
- sock->fd = -1;
-
- return ret;
-}
--- /dev/null
+/*
+ * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ *
+ */
+
+#define _LGPL_SOURCE
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <common/compat/time.h>
+#include <poll.h>
+
+#include <common/common.h>
+#include <common/time.h>
+#include <common/compat/errno.h>
+
+#include "inet6.h"
+
+#define RECONNECT_DELAY 200 /* ms */
+
+/*
+ * INET protocol operations.
+ */
+static const struct lttcomm_proto_ops inet6_ops = {
+ .bind = lttcomm_bind_inet6_sock,
+ .close = lttcomm_close_inet6_sock,
+ .connect = lttcomm_connect_inet6_sock,
+ .accept = lttcomm_accept_inet6_sock,
+ .listen = lttcomm_listen_inet6_sock,
+ .recvmsg = lttcomm_recvmsg_inet6_sock,
+ .sendmsg = lttcomm_sendmsg_inet6_sock,
+};
+
+/*
+ * Creates an PF_INET socket.
+ */
+int lttcomm_create_inet6_sock(struct lttcomm_sock *sock, int type, int proto)
+{
+ int val = 1, ret;
+ unsigned long timeout;
+
+ /* Create server socket */
+ if ((sock->fd = socket(PF_INET6, type, proto)) < 0) {
+ PERROR("socket inet6");
+ goto error;
+ }
+
+ sock->ops = &inet6_ops;
+
+ /*
+ * Set socket option to reuse the address.
+ */
+ ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
+ if (ret < 0) {
+ PERROR("setsockopt inet6");
+ goto error;
+ }
+ timeout = lttcomm_get_network_timeout();
+ if (timeout) {
+ ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
+ if (ret) {
+ goto error;
+ }
+ ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
+ if (ret) {
+ goto error;
+ }
+ }
+
+ return 0;
+
+error:
+ return -1;
+}
+
+/*
+ * Bind socket and return.
+ */
+int lttcomm_bind_inet6_sock(struct lttcomm_sock *sock)
+{
+ struct sockaddr_in6 sockaddr = sock->sockaddr.addr.sin6;
+ return bind(sock->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr));
+}
+
+static
+int connect_no_timeout(struct lttcomm_sock *sock)
+{
+ struct sockaddr_in6 sockaddr = sock->sockaddr.addr.sin6;
+ return connect(sock->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr));
+}
+
+static
+int connect_with_timeout(struct lttcomm_sock *sock)
+{
+ unsigned long timeout = lttcomm_get_network_timeout();
+ int ret, flags, connect_ret;
+ struct timespec orig_time, cur_time;
+ unsigned long diff_ms;
+ struct sockaddr_in6 sockaddr;
+
+ ret = fcntl(sock->fd, F_GETFL, 0);
+ if (ret == -1) {
+ PERROR("fcntl");
+ return -1;
+ }
+ flags = ret;
+
+ /* Set socket to nonblock */
+ ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
+ if (ret == -1) {
+ PERROR("fcntl");
+ return -1;
+ }
+
+ ret = lttng_clock_gettime(CLOCK_MONOTONIC, &orig_time);
+ if (ret == -1) {
+ PERROR("clock_gettime");
+ return -1;
+ }
+
+ sockaddr = sock->sockaddr.addr.sin6;
+ connect_ret = connect(sock->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr));
+ if (connect_ret == -1 && errno != EAGAIN && errno != EWOULDBLOCK &&
+ errno != EINPROGRESS) {
+ goto error;
+ } else if (!connect_ret) {
+ /* Connect succeeded */
+ goto success;
+ }
+
+ DBG("Asynchronous connect for sock %d, performing polling with"
+ " timeout: %lums", sock->fd, timeout);
+
+ /*
+ * Perform poll loop following EINPROGRESS recommendation from
+ * connect(2) man page.
+ */
+ do {
+ struct pollfd fds;
+
+ fds.fd = sock->fd;
+ fds.events = POLLOUT;
+ fds.revents = 0;
+ ret = poll(&fds, 1, RECONNECT_DELAY);
+ if (ret < 0) {
+ goto error;
+ } else if (ret > 0) {
+ int optval;
+ socklen_t optval_len = sizeof(optval);
+
+ if (!(fds.revents & POLLOUT)) {
+ /* Either hup or error */
+ errno = EPIPE;
+ goto error;
+ }
+ /* got something */
+ ret = getsockopt(sock->fd, SOL_SOCKET,
+ SO_ERROR, &optval, &optval_len);
+ if (ret) {
+ PERROR("getsockopt");
+ goto error;
+ }
+ if (!optval) {
+ connect_ret = 0;
+ goto success;
+ } else {
+ /* Get actual connect() errno from opt_val */
+ errno = optval;
+ goto error;
+ }
+ }
+ /* ret == 0: timeout */
+ ret = lttng_clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ if (ret == -1) {
+ PERROR("clock_gettime");
+ connect_ret = ret;
+ goto error;
+ }
+ if (timespec_to_ms(timespec_abs_diff(cur_time, orig_time), &diff_ms) < 0) {
+ ERR("timespec_to_ms input overflows milliseconds output");
+ connect_ret = -1;
+ goto error;
+ }
+ } while (diff_ms < timeout);
+
+ /* Timeout */
+ errno = ETIMEDOUT;
+ connect_ret = -1;
+
+success:
+ /* Restore initial flags */
+ ret = fcntl(sock->fd, F_SETFL, flags);
+ if (ret == -1) {
+ PERROR("fcntl");
+ /* Continue anyway */
+ }
+error:
+ return connect_ret;
+}
+
+/*
+ * Connect PF_INET socket.
+ */
+int lttcomm_connect_inet6_sock(struct lttcomm_sock *sock)
+{
+ int ret, closeret;
+
+ if (lttcomm_get_network_timeout()) {
+ ret = connect_with_timeout(sock);
+ } else {
+ ret = connect_no_timeout(sock);
+ }
+ if (ret < 0) {
+ PERROR("connect inet6");
+ goto error_connect;
+ }
+
+ return ret;
+
+error_connect:
+ closeret = close(sock->fd);
+ if (closeret) {
+ PERROR("close inet6");
+ }
+
+ return ret;
+}
+
+/*
+ * Do an accept(2) on the sock and return the new lttcomm socket. The socket
+ * MUST be bind(2) before.
+ */
+struct lttcomm_sock *lttcomm_accept_inet6_sock(struct lttcomm_sock *sock)
+{
+ int new_fd;
+ socklen_t len;
+ struct lttcomm_sock *new_sock;
+ struct sockaddr_in6 new_addr = {};
+
+ if (sock->proto == LTTCOMM_SOCK_UDP) {
+ /*
+ * accept(2) does not exist for UDP so simply return the passed socket.
+ */
+ new_sock = sock;
+ goto end;
+ }
+
+ new_sock = lttcomm_alloc_sock(sock->proto);
+ if (new_sock == NULL) {
+ goto error;
+ }
+
+ len = sizeof(new_addr);
+
+ /* Blocking call */
+ new_fd = accept(sock->fd, (struct sockaddr *) &new_addr, &len);
+ if (new_fd < 0) {
+ PERROR("accept inet6");
+ goto error;
+ }
+ new_sock->sockaddr.addr.sin6 = new_addr;
+ new_sock->fd = new_fd;
+ new_sock->ops = &inet6_ops;
+
+end:
+ return new_sock;
+
+error:
+ free(new_sock);
+ return NULL;
+}
+
+/*
+ * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
+ */
+int lttcomm_listen_inet6_sock(struct lttcomm_sock *sock, int backlog)
+{
+ int ret;
+
+ if (sock->proto == LTTCOMM_SOCK_UDP) {
+ /* listen(2) does not exist for UDP so simply return success. */
+ ret = 0;
+ goto end;
+ }
+
+ /* Default listen backlog */
+ if (backlog <= 0) {
+ backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
+ }
+
+ ret = listen(sock->fd, backlog);
+ if (ret < 0) {
+ PERROR("listen inet6");
+ }
+
+end:
+ return ret;
+}
+
+/*
+ * Receive data of size len in put that data into the buf param. Using recvmsg
+ * API.
+ *
+ * Return the size of received data.
+ */
+ssize_t lttcomm_recvmsg_inet6_sock(struct lttcomm_sock *sock, void *buf,
+ size_t len, int flags)
+{
+ struct msghdr msg;
+ struct iovec iov[1];
+ ssize_t ret = -1;
+ size_t len_last;
+ struct sockaddr_in6 addr = sock->sockaddr.addr.sin6;
+
+ memset(&msg, 0, sizeof(msg));
+
+ iov[0].iov_base = buf;
+ iov[0].iov_len = len;
+ msg.msg_iov = iov;
+ msg.msg_iovlen = 1;
+
+ msg.msg_name = (struct sockaddr *) &addr;
+ msg.msg_namelen = sizeof(sock->sockaddr.addr.sin6);
+
+ do {
+ len_last = iov[0].iov_len;
+ ret = recvmsg(sock->fd, &msg, flags);
+ if (ret > 0) {
+ if (flags & MSG_DONTWAIT) {
+ goto end;
+ }
+ iov[0].iov_base = ((char *) iov[0].iov_base) + ret;
+ iov[0].iov_len -= ret;
+ LTTNG_ASSERT(ret <= len_last);
+ }
+ } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
+ if (ret < 0) {
+ PERROR("recvmsg inet");
+ } else if (ret > 0) {
+ ret = len;
+ }
+ /* Else ret = 0 meaning an orderly shutdown. */
+end:
+ return ret;
+}
+
+/*
+ * Send buf data of size len. Using sendmsg API.
+ *
+ * Return the size of sent data.
+ */
+ssize_t lttcomm_sendmsg_inet6_sock(struct lttcomm_sock *sock, const void *buf,
+ size_t len, int flags)
+{
+ struct msghdr msg;
+ struct iovec iov[1];
+ ssize_t ret = -1;
+
+ memset(&msg, 0, sizeof(msg));
+
+ iov[0].iov_base = (void *) buf;
+ iov[0].iov_len = len;
+ msg.msg_iov = iov;
+ msg.msg_iovlen = 1;
+
+ switch (sock->proto) {
+ case LTTCOMM_SOCK_UDP:
+ {
+ struct sockaddr_in6 addr = sock->sockaddr.addr.sin6;
+
+ msg.msg_name = (struct sockaddr *) &addr;
+ msg.msg_namelen = sizeof(sock->sockaddr.addr.sin6);
+ break;
+ }
+ default:
+ break;
+ }
+
+ do {
+ ret = sendmsg(sock->fd, &msg, flags);
+ } while (ret < 0 && errno == EINTR);
+ if (ret < 0) {
+ /*
+ * Only warn about EPIPE when quiet mode is deactivated.
+ * We consider EPIPE as expected.
+ */
+ if (errno != EPIPE || !lttng_opt_quiet) {
+ PERROR("sendmsg inet6");
+ }
+ }
+
+ return ret;
+}
+
+/*
+ * Shutdown cleanly and close.
+ */
+int lttcomm_close_inet6_sock(struct lttcomm_sock *sock)
+{
+ int ret;
+
+ /* Don't try to close an invalid marked socket */
+ if (sock->fd == -1) {
+ return 0;
+ }
+
+ ret = close(sock->fd);
+ if (ret) {
+ PERROR("close inet6");
+ }
+
+ /* Mark socket */
+ sock->fd = -1;
+
+ return ret;
+}
+++ /dev/null
-/*
- * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
- * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * SPDX-License-Identifier: GPL-2.0-only
- *
- */
-
-#define _LGPL_SOURCE
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <inttypes.h>
-
-#include <common/common.h>
-#include <common/compat/errno.h>
-
-#include "sessiond-comm.h"
-
-/* For Unix socket */
-#include <common/unix.h>
-/* For Inet socket */
-#include "inet.h"
-/* For Inet6 socket */
-#include "inet6.h"
-
-#define NETWORK_TIMEOUT_ENV "LTTNG_NETWORK_SOCKET_TIMEOUT"
-
-static struct lttcomm_net_family net_families[] = {
- { LTTCOMM_INET, lttcomm_create_inet_sock },
- { LTTCOMM_INET6, lttcomm_create_inet6_sock },
-};
-
-/*
- * Human readable error message.
- */
-static const char *lttcomm_readable_code[] = {
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) ] = "consumerd command socket ready",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SUCCESS_RECV_FD) ] = "consumerd success on receiving fds",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_RECV_FD) ] = "consumerd error on receiving fds",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_RECV_CMD) ] = "consumerd error on receiving command",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_ERROR) ] = "consumerd error in polling thread",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_NVAL) ] = "consumerd polling on closed fd",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_HUP) ] = "consumerd all fd hung up",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_EXIT_SUCCESS) ] = "consumerd exiting normally",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_EXIT_FAILURE) ] = "consumerd exiting on error",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_OUTFD_ERROR) ] = "consumerd error opening the tracefile",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_EBADF) ] = "consumerd splice EBADF",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_EINVAL) ] = "consumerd splice EINVAL",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_ENOMEM) ] = "consumerd splice ENOMEM",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_ESPIPE) ] = "consumerd splice ESPIPE",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ENOMEM) ] = "Consumer is out of memory",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_METADATA) ] = "Error with metadata",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_FATAL) ] = "Fatal error",
- [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_RELAYD_FAIL) ] = "Error on remote relayd",
-
- /* Last element */
- [ LTTCOMM_ERR_INDEX(LTTCOMM_NR) ] = "Unknown error code"
-};
-
-static unsigned long network_timeout;
-
-/*
- * Return ptr to string representing a human readable error code from the
- * lttcomm_return_code enum.
- *
- * These code MUST be negative in other to treat that as an error value.
- */
-const char *lttcomm_get_readable_code(enum lttcomm_return_code code)
-{
- code = -code;
-
- if (code < LTTCOMM_CONSUMERD_COMMAND_SOCK_READY || code > LTTCOMM_NR) {
- code = LTTCOMM_NR;
- }
-
- return lttcomm_readable_code[LTTCOMM_ERR_INDEX(code)];
-}
-
-/*
- * Create socket from an already allocated lttcomm socket structure and init
- * sockaddr in the lttcomm sock.
- */
-int lttcomm_create_sock(struct lttcomm_sock *sock)
-{
- int ret, _sock_type, _sock_proto, domain;
-
- LTTNG_ASSERT(sock);
-
- domain = sock->sockaddr.type;
- if (domain != LTTCOMM_INET && domain != LTTCOMM_INET6) {
- ERR("Create socket of unknown domain %d", domain);
- ret = -1;
- goto error;
- }
-
- switch (sock->proto) {
- case LTTCOMM_SOCK_UDP:
- _sock_type = SOCK_DGRAM;
- _sock_proto = IPPROTO_UDP;
- break;
- case LTTCOMM_SOCK_TCP:
- _sock_type = SOCK_STREAM;
- _sock_proto = IPPROTO_TCP;
- break;
- default:
- ret = -1;
- goto error;
- }
-
- ret = net_families[domain].create(sock, _sock_type, _sock_proto);
- if (ret < 0) {
- goto error;
- }
-
-error:
- return ret;
-}
-
-/*
- * Return allocated lttcomm socket structure.
- */
-struct lttcomm_sock *lttcomm_alloc_sock(enum lttcomm_sock_proto proto)
-{
- struct lttcomm_sock *sock;
-
- sock = zmalloc(sizeof(struct lttcomm_sock));
- if (sock == NULL) {
- PERROR("zmalloc create sock");
- goto end;
- }
-
- sock->proto = proto;
- sock->fd = -1;
-
-end:
- return sock;
-}
-
-/*
- * Return an allocated lttcomm socket structure and copy src content into
- * the newly created socket.
- *
- * This is mostly useful when lttcomm_sock are passed between process where the
- * fd and ops have to be changed within the correct address space.
- */
-struct lttcomm_sock *lttcomm_alloc_copy_sock(struct lttcomm_sock *src)
-{
- struct lttcomm_sock *sock;
-
- /* Safety net */
- LTTNG_ASSERT(src);
-
- sock = lttcomm_alloc_sock(src->proto);
- if (sock == NULL) {
- goto alloc_error;
- }
-
- lttcomm_copy_sock(sock, src);
-
-alloc_error:
- return sock;
-}
-
-/*
- * Create and copy socket from an allocated lttcomm socket structure.
- *
- * This is mostly useful when lttcomm_sock are passed between process where the
- * fd and ops have to be changed within the correct address space.
- */
-void lttcomm_copy_sock(struct lttcomm_sock *dst, struct lttcomm_sock *src)
-{
- /* Safety net */
- LTTNG_ASSERT(dst);
- LTTNG_ASSERT(src);
-
- dst->proto = src->proto;
- dst->fd = src->fd;
- dst->ops = src->ops;
- /* Copy sockaddr information from original socket */
- memcpy(&dst->sockaddr, &src->sockaddr, sizeof(dst->sockaddr));
-}
-
-/*
- * Init IPv4 sockaddr structure.
- */
-int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr *sockaddr,
- const char *ip, unsigned int port)
-{
- int ret;
-
- LTTNG_ASSERT(sockaddr);
- LTTNG_ASSERT(ip);
- LTTNG_ASSERT(port > 0 && port <= 65535);
-
- memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
-
- sockaddr->type = LTTCOMM_INET;
- sockaddr->addr.sin.sin_family = AF_INET;
- sockaddr->addr.sin.sin_port = htons(port);
- ret = inet_pton(sockaddr->addr.sin.sin_family, ip,
- &sockaddr->addr.sin.sin_addr);
- if (ret < 1) {
- ret = -1;
- ERR("%s with port %d: unrecognized IPv4 address", ip, port);
- goto error;
- }
- memset(sockaddr->addr.sin.sin_zero, 0, sizeof(sockaddr->addr.sin.sin_zero));
-
-error:
- return ret;
-}
-
-/*
- * Init IPv6 sockaddr structure.
- */
-int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
- const char *ip, unsigned int port)
-{
- int ret;
-
- LTTNG_ASSERT(sockaddr);
- LTTNG_ASSERT(ip);
- LTTNG_ASSERT(port > 0 && port <= 65535);
-
- memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
-
- sockaddr->type = LTTCOMM_INET6;
- sockaddr->addr.sin6.sin6_family = AF_INET6;
- sockaddr->addr.sin6.sin6_port = htons(port);
- ret = inet_pton(sockaddr->addr.sin6.sin6_family, ip,
- &sockaddr->addr.sin6.sin6_addr);
- if (ret < 1) {
- ret = -1;
- goto error;
- }
-
-error:
- return ret;
-}
-
-/*
- * Return allocated lttcomm socket structure from lttng URI.
- */
-struct lttcomm_sock *lttcomm_alloc_sock_from_uri(struct lttng_uri *uri)
-{
- int ret;
- int _sock_proto;
- struct lttcomm_sock *sock = NULL;
-
- /* Safety net */
- LTTNG_ASSERT(uri);
-
- /* Check URI protocol */
- if (uri->proto == LTTNG_TCP) {
- _sock_proto = LTTCOMM_SOCK_TCP;
- } else {
- ERR("Relayd invalid URI proto: %d", uri->proto);
- goto alloc_error;
- }
-
- sock = lttcomm_alloc_sock(_sock_proto);
- if (sock == NULL) {
- goto alloc_error;
- }
-
- /* Check destination type */
- if (uri->dtype == LTTNG_DST_IPV4) {
- ret = lttcomm_init_inet_sockaddr(&sock->sockaddr, uri->dst.ipv4,
- uri->port);
- if (ret < 0) {
- goto error;
- }
- } else if (uri->dtype == LTTNG_DST_IPV6) {
- ret = lttcomm_init_inet6_sockaddr(&sock->sockaddr, uri->dst.ipv6,
- uri->port);
- if (ret < 0) {
- goto error;
- }
- } else {
- /* Command URI is invalid */
- ERR("Relayd invalid URI dst type: %d", uri->dtype);
- goto error;
- }
-
- return sock;
-
-error:
- lttcomm_destroy_sock(sock);
-alloc_error:
- return NULL;
-}
-
-/*
- * Destroy and free lttcomm socket.
- */
-void lttcomm_destroy_sock(struct lttcomm_sock *sock)
-{
- free(sock);
-}
-
-/*
- * Allocate and return a relayd socket object using a given URI to initialize
- * it and the major/minor version of the supported protocol.
- *
- * On error, NULL is returned.
- */
-struct lttcomm_relayd_sock *lttcomm_alloc_relayd_sock(struct lttng_uri *uri,
- uint32_t major, uint32_t minor)
-{
- int ret;
- struct lttcomm_sock *tmp_sock = NULL;
- struct lttcomm_relayd_sock *rsock = NULL;
-
- LTTNG_ASSERT(uri);
-
- rsock = zmalloc(sizeof(*rsock));
- if (!rsock) {
- PERROR("zmalloc relayd sock");
- goto error;
- }
-
- /* Allocate socket object from URI */
- tmp_sock = lttcomm_alloc_sock_from_uri(uri);
- if (tmp_sock == NULL) {
- goto error_free;
- }
-
- /*
- * Create socket object which basically sets the ops according to the
- * socket protocol.
- */
- lttcomm_copy_sock(&rsock->sock, tmp_sock);
- /* Temporary socket pointer not needed anymore. */
- lttcomm_destroy_sock(tmp_sock);
- ret = lttcomm_create_sock(&rsock->sock);
- if (ret < 0) {
- goto error_free;
- }
-
- rsock->major = major;
- rsock->minor = minor;
-
- return rsock;
-
-error_free:
- free(rsock);
-error:
- return NULL;
-}
-
-/*
- * Set socket receiving timeout.
- */
-int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec)
-{
- int ret;
- struct timeval tv;
-
- tv.tv_sec = msec / 1000;
- tv.tv_usec = (msec % 1000) * 1000;
-
- ret = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
- if (ret < 0) {
- PERROR("setsockopt SO_RCVTIMEO");
- }
-
- return ret;
-}
-
-/*
- * Set socket sending timeout.
- */
-int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec)
-{
- int ret;
- struct timeval tv;
-
- tv.tv_sec = msec / 1000;
- tv.tv_usec = (msec % 1000) * 1000;
-
- ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
- if (ret < 0) {
- PERROR("setsockopt SO_SNDTIMEO");
- }
-
- return ret;
-}
-
-int lttcomm_sock_get_port(const struct lttcomm_sock *sock, uint16_t *port)
-{
- LTTNG_ASSERT(sock);
- LTTNG_ASSERT(port);
- LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET ||
- sock->sockaddr.type == LTTCOMM_INET6);
- LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP ||
- sock->proto == LTTCOMM_SOCK_UDP);
-
- switch (sock->sockaddr.type) {
- case LTTCOMM_INET:
- *port = ntohs(sock->sockaddr.addr.sin.sin_port);
- break;
- case LTTCOMM_INET6:
- *port = ntohs(sock->sockaddr.addr.sin6.sin6_port);
- break;
- default:
- abort();
- }
-
- return 0;
-}
-
-int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port)
-{
- LTTNG_ASSERT(sock);
- LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET ||
- sock->sockaddr.type == LTTCOMM_INET6);
- LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP ||
- sock->proto == LTTCOMM_SOCK_UDP);
-
- switch (sock->sockaddr.type) {
- case LTTCOMM_INET:
- sock->sockaddr.addr.sin.sin_port = htons(port);
- break;
- case LTTCOMM_INET6:
- sock->sockaddr.addr.sin6.sin6_port = htons(port);
- break;
- default:
- abort();
- }
-
- return 0;
-}
-
-void lttcomm_init(void)
-{
- const char *env;
-
- env = getenv(NETWORK_TIMEOUT_ENV);
- if (env) {
- long timeout;
-
- errno = 0;
- timeout = strtol(env, NULL, 0);
- if (errno != 0 || timeout < -1L) {
- PERROR("Network timeout");
- } else {
- if (timeout > 0) {
- network_timeout = timeout;
- }
- }
- }
-}
-
-unsigned long lttcomm_get_network_timeout(void)
-{
- return network_timeout;
-}
--- /dev/null
+/*
+ * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ *
+ */
+
+#define _LGPL_SOURCE
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <inttypes.h>
+
+#include <common/common.h>
+#include <common/compat/errno.h>
+
+#include "sessiond-comm.h"
+
+/* For Unix socket */
+#include <common/unix.h>
+/* For Inet socket */
+#include "inet.h"
+/* For Inet6 socket */
+#include "inet6.h"
+
+#define NETWORK_TIMEOUT_ENV "LTTNG_NETWORK_SOCKET_TIMEOUT"
+
+static struct lttcomm_net_family net_families[] = {
+ { LTTCOMM_INET, lttcomm_create_inet_sock },
+ { LTTCOMM_INET6, lttcomm_create_inet6_sock },
+};
+
+/*
+ * Human readable error message.
+ */
+static
+const char *lttcomm_return_code_str(lttcomm_return_code code) {
+ switch (code) {
+ case LTTCOMM_CONSUMERD_SUCCESS:
+ return "consumerd success";
+ case LTTCOMM_CONSUMERD_COMMAND_SOCK_READY:
+ return "consumerd command socket ready";
+ case LTTCOMM_CONSUMERD_SUCCESS_RECV_FD:
+ return "consumerd success on receiving fds";
+ case LTTCOMM_CONSUMERD_ERROR_RECV_FD:
+ return "consumerd error on receiving fds";
+ case LTTCOMM_CONSUMERD_ERROR_RECV_CMD:
+ return "consumerd error on receiving command";
+ case LTTCOMM_CONSUMERD_POLL_ERROR:
+ return "consumerd error in polling thread";
+ case LTTCOMM_CONSUMERD_POLL_NVAL:
+ return "consumerd polling on closed fd";
+ case LTTCOMM_CONSUMERD_POLL_HUP:
+ return "consumerd all fd hung up";
+ case LTTCOMM_CONSUMERD_EXIT_SUCCESS:
+ return "consumerd exiting normally";
+ case LTTCOMM_CONSUMERD_EXIT_FAILURE:
+ return "consumerd exiting on error";
+ case LTTCOMM_CONSUMERD_OUTFD_ERROR:
+ return "consumerd error opening the tracefile";
+ case LTTCOMM_CONSUMERD_SPLICE_EBADF:
+ return "consumerd splice EBADF";
+ case LTTCOMM_CONSUMERD_SPLICE_EINVAL:
+ return "consumerd splice EINVAL";
+ case LTTCOMM_CONSUMERD_SPLICE_ENOMEM:
+ return "consumerd splice ENOMEM";
+ case LTTCOMM_CONSUMERD_SPLICE_ESPIPE:
+ return "consumerd splice ESPIPE";
+ case LTTCOMM_CONSUMERD_ENOMEM:
+ return "consumerd is out of memory";
+ case LTTCOMM_CONSUMERD_ERROR_METADATA:
+ return "consumerd error with metadata";
+ case LTTCOMM_CONSUMERD_FATAL:
+ return "consumerd fatal error";
+ case LTTCOMM_CONSUMERD_RELAYD_FAIL:
+ return "consumerd error on remote relayd";
+ case LTTCOMM_CONSUMERD_CHANNEL_FAIL:
+ return "consumerd channel creation fail";
+ case LTTCOMM_CONSUMERD_CHAN_NOT_FOUND:
+ return "consumerd channel not found";
+ case LTTCOMM_CONSUMERD_ALREADY_SET:
+ return "consumerd resource already set";
+ case LTTCOMM_CONSUMERD_ROTATION_FAIL:
+ return "consumerd rotation failed";
+ case LTTCOMM_CONSUMERD_SNAPSHOT_FAILED:
+ return "consumerd snapshot has failed";
+ case LTTCOMM_CONSUMERD_CREATE_TRACE_CHUNK_FAILED:
+ return "consumerd trace chunk creation failed";
+ case LTTCOMM_CONSUMERD_CLOSE_TRACE_CHUNK_FAILED:
+ return "consumerd trace chunk closing failed";
+ case LTTCOMM_CONSUMERD_INVALID_PARAMETERS:
+ return "consumerd invalid parameters";
+ case LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_LOCAL:
+ return "consumerd trace chunk exists on consumer daemon";
+ case LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_REMOTE:
+ return "consumedd trace chunk exists on relay daemon";
+ case LTTCOMM_CONSUMERD_UNKNOWN_TRACE_CHUNK:
+ return "consumerd unknown trace chunk";
+ case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED:
+ return "consumed relayd does not accept clear command";
+ case LTTCOMM_CONSUMERD_UNKNOWN_ERROR:
+ return "consumerd unknown error";
+ case LTTCOMM_NR:
+ abort();
+ }
+
+ abort();
+};
+
+static unsigned long network_timeout;
+
+/*
+ * Return ptr to string representing a human readable error code from the
+ * lttcomm_return_code enum.
+ *
+ * These code MUST be negative in other to treat that as an error value.
+ */
+const char *lttcomm_get_readable_code(enum lttcomm_return_code code)
+{
+ code = (lttcomm_return_code) -code;
+
+ if (code != LTTCOMM_CONSUMERD_SUCCESS &&
+ !(code >= LTTCOMM_CONSUMERD_COMMAND_SOCK_READY && code < LTTCOMM_NR)) {
+ code = LTTCOMM_CONSUMERD_UNKNOWN_ERROR;
+ }
+
+ return lttcomm_return_code_str(code);
+}
+
+/*
+ * Create socket from an already allocated lttcomm socket structure and init
+ * sockaddr in the lttcomm sock.
+ */
+int lttcomm_create_sock(struct lttcomm_sock *sock)
+{
+ int ret, _sock_type, _sock_proto, domain;
+
+ LTTNG_ASSERT(sock);
+
+ domain = sock->sockaddr.type;
+ if (domain != LTTCOMM_INET && domain != LTTCOMM_INET6) {
+ ERR("Create socket of unknown domain %d", domain);
+ ret = -1;
+ goto error;
+ }
+
+ switch (sock->proto) {
+ case LTTCOMM_SOCK_UDP:
+ _sock_type = SOCK_DGRAM;
+ _sock_proto = IPPROTO_UDP;
+ break;
+ case LTTCOMM_SOCK_TCP:
+ _sock_type = SOCK_STREAM;
+ _sock_proto = IPPROTO_TCP;
+ break;
+ default:
+ ret = -1;
+ goto error;
+ }
+
+ ret = net_families[domain].create(sock, _sock_type, _sock_proto);
+ if (ret < 0) {
+ goto error;
+ }
+
+error:
+ return ret;
+}
+
+/*
+ * Return allocated lttcomm socket structure.
+ */
+struct lttcomm_sock *lttcomm_alloc_sock(enum lttcomm_sock_proto proto)
+{
+ struct lttcomm_sock *sock;
+
+ sock = (lttcomm_sock *) zmalloc(sizeof(lttcomm_sock));
+ if (sock == NULL) {
+ PERROR("zmalloc create sock");
+ goto end;
+ }
+
+ sock->proto = proto;
+ sock->fd = -1;
+
+end:
+ return sock;
+}
+
+/*
+ * Return an allocated lttcomm socket structure and copy src content into
+ * the newly created socket.
+ *
+ * This is mostly useful when lttcomm_sock are passed between process where the
+ * fd and ops have to be changed within the correct address space.
+ */
+struct lttcomm_sock *lttcomm_alloc_copy_sock(struct lttcomm_sock *src)
+{
+ struct lttcomm_sock *sock;
+
+ /* Safety net */
+ LTTNG_ASSERT(src);
+
+ sock = lttcomm_alloc_sock(src->proto);
+ if (sock == NULL) {
+ goto alloc_error;
+ }
+
+ lttcomm_copy_sock(sock, src);
+
+alloc_error:
+ return sock;
+}
+
+/*
+ * Create and copy socket from an allocated lttcomm socket structure.
+ *
+ * This is mostly useful when lttcomm_sock are passed between process where the
+ * fd and ops have to be changed within the correct address space.
+ */
+void lttcomm_copy_sock(struct lttcomm_sock *dst, struct lttcomm_sock *src)
+{
+ /* Safety net */
+ LTTNG_ASSERT(dst);
+ LTTNG_ASSERT(src);
+
+ dst->proto = src->proto;
+ dst->fd = src->fd;
+ dst->ops = src->ops;
+ /* Copy sockaddr information from original socket */
+ memcpy(&dst->sockaddr, &src->sockaddr, sizeof(dst->sockaddr));
+}
+
+/*
+ * Init IPv4 sockaddr structure.
+ */
+int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr *sockaddr,
+ const char *ip, unsigned int port)
+{
+ int ret;
+
+ LTTNG_ASSERT(sockaddr);
+ LTTNG_ASSERT(ip);
+ LTTNG_ASSERT(port > 0 && port <= 65535);
+
+ memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
+
+ sockaddr->type = LTTCOMM_INET;
+ sockaddr->addr.sin.sin_family = AF_INET;
+ sockaddr->addr.sin.sin_port = htons(port);
+ ret = inet_pton(sockaddr->addr.sin.sin_family, ip,
+ &sockaddr->addr.sin.sin_addr);
+ if (ret < 1) {
+ ret = -1;
+ ERR("%s with port %d: unrecognized IPv4 address", ip, port);
+ goto error;
+ }
+ memset(sockaddr->addr.sin.sin_zero, 0, sizeof(sockaddr->addr.sin.sin_zero));
+
+error:
+ return ret;
+}
+
+/*
+ * Init IPv6 sockaddr structure.
+ */
+int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
+ const char *ip, unsigned int port)
+{
+ int ret;
+
+ LTTNG_ASSERT(sockaddr);
+ LTTNG_ASSERT(ip);
+ LTTNG_ASSERT(port > 0 && port <= 65535);
+
+ memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
+
+ sockaddr->type = LTTCOMM_INET6;
+ sockaddr->addr.sin6.sin6_family = AF_INET6;
+ sockaddr->addr.sin6.sin6_port = htons(port);
+ ret = inet_pton(sockaddr->addr.sin6.sin6_family, ip,
+ &sockaddr->addr.sin6.sin6_addr);
+ if (ret < 1) {
+ ret = -1;
+ goto error;
+ }
+
+error:
+ return ret;
+}
+
+/*
+ * Return allocated lttcomm socket structure from lttng URI.
+ */
+struct lttcomm_sock *lttcomm_alloc_sock_from_uri(struct lttng_uri *uri)
+{
+ int ret;
+ int _sock_proto;
+ struct lttcomm_sock *sock = NULL;
+
+ /* Safety net */
+ LTTNG_ASSERT(uri);
+
+ /* Check URI protocol */
+ if (uri->proto == LTTNG_TCP) {
+ _sock_proto = LTTCOMM_SOCK_TCP;
+ } else {
+ ERR("Relayd invalid URI proto: %d", uri->proto);
+ goto alloc_error;
+ }
+
+ sock = lttcomm_alloc_sock((lttcomm_sock_proto) _sock_proto);
+ if (sock == NULL) {
+ goto alloc_error;
+ }
+
+ /* Check destination type */
+ if (uri->dtype == LTTNG_DST_IPV4) {
+ ret = lttcomm_init_inet_sockaddr(&sock->sockaddr, uri->dst.ipv4,
+ uri->port);
+ if (ret < 0) {
+ goto error;
+ }
+ } else if (uri->dtype == LTTNG_DST_IPV6) {
+ ret = lttcomm_init_inet6_sockaddr(&sock->sockaddr, uri->dst.ipv6,
+ uri->port);
+ if (ret < 0) {
+ goto error;
+ }
+ } else {
+ /* Command URI is invalid */
+ ERR("Relayd invalid URI dst type: %d", uri->dtype);
+ goto error;
+ }
+
+ return sock;
+
+error:
+ lttcomm_destroy_sock(sock);
+alloc_error:
+ return NULL;
+}
+
+/*
+ * Destroy and free lttcomm socket.
+ */
+void lttcomm_destroy_sock(struct lttcomm_sock *sock)
+{
+ free(sock);
+}
+
+/*
+ * Allocate and return a relayd socket object using a given URI to initialize
+ * it and the major/minor version of the supported protocol.
+ *
+ * On error, NULL is returned.
+ */
+struct lttcomm_relayd_sock *lttcomm_alloc_relayd_sock(struct lttng_uri *uri,
+ uint32_t major, uint32_t minor)
+{
+ int ret;
+ struct lttcomm_sock *tmp_sock = NULL;
+ struct lttcomm_relayd_sock *rsock = NULL;
+
+ LTTNG_ASSERT(uri);
+
+ rsock = (lttcomm_relayd_sock *) zmalloc(sizeof(*rsock));
+ if (!rsock) {
+ PERROR("zmalloc relayd sock");
+ goto error;
+ }
+
+ /* Allocate socket object from URI */
+ tmp_sock = lttcomm_alloc_sock_from_uri(uri);
+ if (tmp_sock == NULL) {
+ goto error_free;
+ }
+
+ /*
+ * Create socket object which basically sets the ops according to the
+ * socket protocol.
+ */
+ lttcomm_copy_sock(&rsock->sock, tmp_sock);
+ /* Temporary socket pointer not needed anymore. */
+ lttcomm_destroy_sock(tmp_sock);
+ ret = lttcomm_create_sock(&rsock->sock);
+ if (ret < 0) {
+ goto error_free;
+ }
+
+ rsock->major = major;
+ rsock->minor = minor;
+
+ return rsock;
+
+error_free:
+ free(rsock);
+error:
+ return NULL;
+}
+
+/*
+ * Set socket receiving timeout.
+ */
+int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec)
+{
+ int ret;
+ struct timeval tv;
+
+ tv.tv_sec = msec / 1000;
+ tv.tv_usec = (msec % 1000) * 1000;
+
+ ret = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+ if (ret < 0) {
+ PERROR("setsockopt SO_RCVTIMEO");
+ }
+
+ return ret;
+}
+
+/*
+ * Set socket sending timeout.
+ */
+int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec)
+{
+ int ret;
+ struct timeval tv;
+
+ tv.tv_sec = msec / 1000;
+ tv.tv_usec = (msec % 1000) * 1000;
+
+ ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
+ if (ret < 0) {
+ PERROR("setsockopt SO_SNDTIMEO");
+ }
+
+ return ret;
+}
+
+int lttcomm_sock_get_port(const struct lttcomm_sock *sock, uint16_t *port)
+{
+ LTTNG_ASSERT(sock);
+ LTTNG_ASSERT(port);
+ LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET ||
+ sock->sockaddr.type == LTTCOMM_INET6);
+ LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP ||
+ sock->proto == LTTCOMM_SOCK_UDP);
+
+ switch (sock->sockaddr.type) {
+ case LTTCOMM_INET:
+ *port = ntohs(sock->sockaddr.addr.sin.sin_port);
+ break;
+ case LTTCOMM_INET6:
+ *port = ntohs(sock->sockaddr.addr.sin6.sin6_port);
+ break;
+ default:
+ abort();
+ }
+
+ return 0;
+}
+
+int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port)
+{
+ LTTNG_ASSERT(sock);
+ LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET ||
+ sock->sockaddr.type == LTTCOMM_INET6);
+ LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP ||
+ sock->proto == LTTCOMM_SOCK_UDP);
+
+ switch (sock->sockaddr.type) {
+ case LTTCOMM_INET:
+ sock->sockaddr.addr.sin.sin_port = htons(port);
+ break;
+ case LTTCOMM_INET6:
+ sock->sockaddr.addr.sin6.sin6_port = htons(port);
+ break;
+ default:
+ abort();
+ }
+
+ return 0;
+}
+
+void lttcomm_init(void)
+{
+ const char *env;
+
+ env = getenv(NETWORK_TIMEOUT_ENV);
+ if (env) {
+ long timeout;
+
+ errno = 0;
+ timeout = strtol(env, NULL, 0);
+ if (errno != 0 || timeout < -1L) {
+ PERROR("Network timeout");
+ } else {
+ if (timeout > 0) {
+ network_timeout = timeout;
+ }
+ }
+ }
+}
+
+unsigned long lttcomm_get_network_timeout(void)
+{
+ return network_timeout;
+}
#define LTTCOMM_MAX_SEND_FDS 16
#endif
-/*
- * Get the error code index from 0 since LTTCOMM_OK start at 1000
- */
-#define LTTCOMM_ERR_INDEX(code) (code - LTTCOMM_CONSUMERD_COMMAND_SOCK_READY)
-
enum lttcomm_sessiond_command {
/* Tracer command */
LTTNG_ADD_CONTEXT = 0,
LTTCOMM_CONSUMERD_ROTATION_FAIL, /* Rotation has failed. */
LTTCOMM_CONSUMERD_SNAPSHOT_FAILED, /* snapshot has failed. */
LTTCOMM_CONSUMERD_CREATE_TRACE_CHUNK_FAILED,/* Trace chunk creation failed. */
- LTTCOMM_CONSUMERD_CLOSE_TRACE_CHUNK_FAILED, /* Trace chunk creation failed. */
+ LTTCOMM_CONSUMERD_CLOSE_TRACE_CHUNK_FAILED, /* Trace chunk close failed. */
LTTCOMM_CONSUMERD_INVALID_PARAMETERS, /* Invalid parameters. */
LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_LOCAL, /* Trace chunk exists on consumer daemon. */
LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_REMOTE,/* Trace chunk exists on relay daemon. */
projects / lttng-tools.git / commitdiff
