[lttng-tools.git] / src / common / sessiond-comm / sessiond-comm.cpp

/*
 * Copyright (C) 2011 EfficiOS Inc.
 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <sys/socket.h>
#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.hpp>
#include <common/compat/errno.hpp>

#include "sessiond-comm.hpp"

/* For Unix socket */
#include <common/unix.hpp>
/* For Inet socket */
#include "inet.hpp"
/* For Inet6 socket */
#include "inet6.hpp"

#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 = zmalloc<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 = zmalloc<lttcomm_relayd_sock>();

	LTTNG_ASSERT(uri);

	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;
}

/*
 * Only valid for an ipv4 and ipv6 bound socket that is already connected to its
 * peer.
 */
int lttcomm_populate_sock_from_open_socket(
		struct lttcomm_sock *sock,
		int fd,
		enum lttcomm_sock_proto protocol)
{
	int ret = 0;
	socklen_t storage_len;
	struct sockaddr_storage storage = {};

	assert(sock);
	assert(fd >= 0);

	sock->proto = protocol;

	storage_len = sizeof(storage);
	ret = getpeername(fd, (struct sockaddr *) &storage,
			&storage_len);
	if (ret) {
		ERR("Failed to get peer info for socket %d (errno: %d)", fd,
				errno);
		ret = -1;
		goto end;
	}

	if (storage_len > sizeof(storage)) {
		ERR("Failed to get peer info for socket %d: storage size is too small", fd);
		ret = -1;
		goto end;
	}

	switch (storage.ss_family) {
	case AF_INET:
		sock->sockaddr.type = LTTCOMM_INET;
		memcpy(&sock->sockaddr.addr, &storage,
				sizeof(struct sockaddr_in));
		break;
	case AF_INET6:
		sock->sockaddr.type = LTTCOMM_INET6;
		memcpy(&sock->sockaddr.addr, &storage,
				sizeof(struct sockaddr_in6));
		break;
	default:
		abort();
		break;
	}

	/* Create a valid socket object with a temporary fd. */
	ret = lttcomm_create_sock(sock);
	if (ret < 0) {
		ERR("Failed to create temporary socket object");
		ret = -1;
		goto end;
	}

	/* Substitute the fd. */
	if (sock->ops->close(sock)) {
		ret = -1;
		goto end;
	}
	sock->fd = fd;

end:
	return ret;
}
Commit	Line	Data
826d496d	1	/*
21cf9b6b	2	* Copyright (C) 2011 EfficiOS Inc.
ab5be9fa MJ	3	* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	4	*
	5	* SPDX-License-Identifier: GPL-2.0-only
fac6795d	6	*
fac6795d DG	7	*/
fac6795d DG	8
4222116f	9	#include <sys/socket.h>
6c1c0768	10	#define _LGPL_SOURCE
fac6795d DG	11	#include <limits.h>
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <string.h>
fac6795d DG	15	#include <sys/stat.h>
fac6795d DG	16	#include <sys/types.h>
fac6795d	17	#include <unistd.h>
2288467f	18	#include <inttypes.h>
fac6795d	19
c9e313bc SM	20	#include <common/common.hpp>
c9e313bc SM	21	#include <common/compat/errno.hpp>
990570ed	22
c9e313bc	23	#include "sessiond-comm.hpp"
fac6795d	24
6364a07a	25	/* For Unix socket */
c9e313bc	26	#include <common/unix.hpp>
6364a07a	27	/* For Inet socket */
c9e313bc	28	#include "inet.hpp"
6364a07a	29	/* For Inet6 socket */
c9e313bc	30	#include "inet6.hpp"
6364a07a	31
554831e7 MD	32	#define NETWORK_TIMEOUT_ENV "LTTNG_NETWORK_SOCKET_TIMEOUT"
554831e7 MD	33
32dd26fb	34	static struct lttcomm_net_family net_families[] = {
6364a07a DG	35	{ LTTCOMM_INET, lttcomm_create_inet_sock },
	36	{ LTTCOMM_INET6, lttcomm_create_inet6_sock },
	37	};
	38
fac6795d DG	39	/*
	40	* Human readable error message.
	41	*/
64efa44e SM	42	static
	43	const char *lttcomm_return_code_str(lttcomm_return_code code) {
	44	switch (code) {
	45	case LTTCOMM_CONSUMERD_SUCCESS:
	46	return "consumerd success";
	47	case LTTCOMM_CONSUMERD_COMMAND_SOCK_READY:
	48	return "consumerd command socket ready";
	49	case LTTCOMM_CONSUMERD_SUCCESS_RECV_FD:
	50	return "consumerd success on receiving fds";
	51	case LTTCOMM_CONSUMERD_ERROR_RECV_FD:
	52	return "consumerd error on receiving fds";
	53	case LTTCOMM_CONSUMERD_ERROR_RECV_CMD:
	54	return "consumerd error on receiving command";
	55	case LTTCOMM_CONSUMERD_POLL_ERROR:
	56	return "consumerd error in polling thread";
	57	case LTTCOMM_CONSUMERD_POLL_NVAL:
	58	return "consumerd polling on closed fd";
	59	case LTTCOMM_CONSUMERD_POLL_HUP:
	60	return "consumerd all fd hung up";
	61	case LTTCOMM_CONSUMERD_EXIT_SUCCESS:
	62	return "consumerd exiting normally";
	63	case LTTCOMM_CONSUMERD_EXIT_FAILURE:
	64	return "consumerd exiting on error";
	65	case LTTCOMM_CONSUMERD_OUTFD_ERROR:
	66	return "consumerd error opening the tracefile";
	67	case LTTCOMM_CONSUMERD_SPLICE_EBADF:
	68	return "consumerd splice EBADF";
	69	case LTTCOMM_CONSUMERD_SPLICE_EINVAL:
	70	return "consumerd splice EINVAL";
	71	case LTTCOMM_CONSUMERD_SPLICE_ENOMEM:
	72	return "consumerd splice ENOMEM";
	73	case LTTCOMM_CONSUMERD_SPLICE_ESPIPE:
	74	return "consumerd splice ESPIPE";
	75	case LTTCOMM_CONSUMERD_ENOMEM:
	76	return "consumerd is out of memory";
	77	case LTTCOMM_CONSUMERD_ERROR_METADATA:
	78	return "consumerd error with metadata";
	79	case LTTCOMM_CONSUMERD_FATAL:
	80	return "consumerd fatal error";
	81	case LTTCOMM_CONSUMERD_RELAYD_FAIL:
	82	return "consumerd error on remote relayd";
	83	case LTTCOMM_CONSUMERD_CHANNEL_FAIL:
	84	return "consumerd channel creation fail";
	85	case LTTCOMM_CONSUMERD_CHAN_NOT_FOUND:
	86	return "consumerd channel not found";
	87	case LTTCOMM_CONSUMERD_ALREADY_SET:
	88	return "consumerd resource already set";
	89	case LTTCOMM_CONSUMERD_ROTATION_FAIL:
	90	return "consumerd rotation failed";
	91	case LTTCOMM_CONSUMERD_SNAPSHOT_FAILED:
	92	return "consumerd snapshot has failed";
	93	case LTTCOMM_CONSUMERD_CREATE_TRACE_CHUNK_FAILED:
	94	return "consumerd trace chunk creation failed";
	95	case LTTCOMM_CONSUMERD_CLOSE_TRACE_CHUNK_FAILED:
	96	return "consumerd trace chunk closing failed";
	97	case LTTCOMM_CONSUMERD_INVALID_PARAMETERS:
	98	return "consumerd invalid parameters";
	99	case LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_LOCAL:
	100	return "consumerd trace chunk exists on consumer daemon";
	101	case LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_REMOTE:
	102	return "consumedd trace chunk exists on relay daemon";
	103	case LTTCOMM_CONSUMERD_UNKNOWN_TRACE_CHUNK:
	104	return "consumerd unknown trace chunk";
	105	case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED:
106	return "consumed relayd does not accept clear command";
107	case LTTCOMM_CONSUMERD_UNKNOWN_ERROR:
108	return "consumerd unknown error";
109	case LTTCOMM_NR:
110	abort();
111	}
112
113	abort();
fac6795d DG	114	};
fac6795d DG	115
554831e7 MD	116	static unsigned long network_timeout;
554831e7 MD	117
fac6795d	118	/*
917216f6 DG	119	* Return ptr to string representing a human readable error code from the
917216f6 DG	120	* lttcomm_return_code enum.
fac6795d	121	*
917216f6	122	* These code MUST be negative in other to treat that as an error value.
fac6795d DG	123	*/
	124	const char *lttcomm_get_readable_code(enum lttcomm_return_code code)
	125	{
64efa44e	126	code = (lttcomm_return_code) -code;
fac6795d	127
64efa44e SM	128	if (code != LTTCOMM_CONSUMERD_SUCCESS &&
	129	!(code >= LTTCOMM_CONSUMERD_COMMAND_SOCK_READY && code < LTTCOMM_NR)) {
	130	code = LTTCOMM_CONSUMERD_UNKNOWN_ERROR;
fac6795d DG	131	}
fac6795d DG	132
64efa44e	133	return lttcomm_return_code_str(code);
fac6795d	134	}
6364a07a DG	135
6364a07a DG	136	/*
de5e9086 DG	137	* Create socket from an already allocated lttcomm socket structure and init
de5e9086 DG	138	* sockaddr in the lttcomm sock.
6364a07a	139	*/
de5e9086	140	int lttcomm_create_sock(struct lttcomm_sock *sock)
6364a07a	141	{
de5e9086	142	int ret, _sock_type, _sock_proto, domain;
6364a07a	143
a0377dfe	144	LTTNG_ASSERT(sock);
de5e9086 DG	145
	146	domain = sock->sockaddr.type;
	147	if (domain != LTTCOMM_INET && domain != LTTCOMM_INET6) {
	148	ERR("Create socket of unknown domain %d", domain);
	149	ret = -1;
	150	goto error;
6364a07a DG	151	}
6364a07a DG	152
de5e9086 DG	153	switch (sock->proto) {
	154	case LTTCOMM_SOCK_UDP:
	155	_sock_type = SOCK_DGRAM;
	156	_sock_proto = IPPROTO_UDP;
	157	break;
	158	case LTTCOMM_SOCK_TCP:
	159	_sock_type = SOCK_STREAM;
	160	_sock_proto = IPPROTO_TCP;
	161	break;
	162	default:
	163	ret = -1;
	164	goto error;
	165	}
6364a07a	166
de5e9086 DG	167	ret = net_families[domain].create(sock, _sock_type, _sock_proto);
	168	if (ret < 0) {
	169	goto error;
	170	}
	171
	172	error:
	173	return ret;
6364a07a DG	174	}
	175
	176	/*
de5e9086	177	* Return allocated lttcomm socket structure.
6364a07a	178	*/
de5e9086	179	struct lttcomm_sock *lttcomm_alloc_sock(enum lttcomm_sock_proto proto)
6364a07a	180	{
64803277	181	struct lttcomm_sock *sock = zmalloc<lttcomm_sock>();
6364a07a	182
de5e9086 DG	183	if (sock == NULL) {
	184	PERROR("zmalloc create sock");
	185	goto end;
6364a07a DG	186	}
	187
	188	sock->proto = proto;
de5e9086	189	sock->fd = -1;
6364a07a	190
de5e9086 DG	191	end:
de5e9086 DG	192	return sock;
6364a07a DG	193	}
	194
	195	/*
de5e9086 DG	196	* Return an allocated lttcomm socket structure and copy src content into
	197	* the newly created socket.
	198	*
	199	* This is mostly useful when lttcomm_sock are passed between process where the
	200	* fd and ops have to be changed within the correct address space.
6364a07a	201	*/
de5e9086	202	struct lttcomm_sock lttcomm_alloc_copy_sock(struct lttcomm_sock src)
6364a07a	203	{
6364a07a DG	204	struct lttcomm_sock *sock;
6364a07a DG	205
de5e9086	206	/* Safety net */
a0377dfe	207	LTTNG_ASSERT(src);
de5e9086 DG	208
de5e9086 DG	209	sock = lttcomm_alloc_sock(src->proto);
6364a07a DG	210	if (sock == NULL) {
	211	goto alloc_error;
	212	}
	213
de5e9086	214	lttcomm_copy_sock(sock, src);
6364a07a	215
de5e9086	216	alloc_error:
6364a07a	217	return sock;
de5e9086	218	}
6364a07a	219
de5e9086 DG	220	/*
	221	* Create and copy socket from an allocated lttcomm socket structure.
	222	*
	223	* This is mostly useful when lttcomm_sock are passed between process where the
	224	* fd and ops have to be changed within the correct address space.
	225	*/
	226	void lttcomm_copy_sock(struct lttcomm_sock dst, struct lttcomm_sock src)
	227	{
	228	/* Safety net */
a0377dfe FD	229	LTTNG_ASSERT(dst);
a0377dfe FD	230	LTTNG_ASSERT(src);
de5e9086 DG	231
	232	dst->proto = src->proto;
	233	dst->fd = src->fd;
	234	dst->ops = src->ops;
	235	/* Copy sockaddr information from original socket */
	236	memcpy(&dst->sockaddr, &src->sockaddr, sizeof(dst->sockaddr));
6364a07a DG	237	}
	238
	239	/*
	240	* Init IPv4 sockaddr structure.
	241	*/
	242	int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr *sockaddr,
	243	const char *ip, unsigned int port)
	244	{
	245	int ret;
	246
a0377dfe FD	247	LTTNG_ASSERT(sockaddr);
	248	LTTNG_ASSERT(ip);
	249	LTTNG_ASSERT(port > 0 && port <= 65535);
6364a07a DG	250
	251	memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
	252
	253	sockaddr->type = LTTCOMM_INET;
	254	sockaddr->addr.sin.sin_family = AF_INET;
	255	sockaddr->addr.sin.sin_port = htons(port);
	256	ret = inet_pton(sockaddr->addr.sin.sin_family, ip,
	257	&sockaddr->addr.sin.sin_addr);
	258	if (ret < 1) {
	259	ret = -1;
de5e9086	260	ERR("%s with port %d: unrecognized IPv4 address", ip, port);
6364a07a DG	261	goto error;
	262	}
	263	memset(sockaddr->addr.sin.sin_zero, 0, sizeof(sockaddr->addr.sin.sin_zero));
	264
	265	error:
	266	return ret;
	267	}
	268
	269	/*
	270	* Init IPv6 sockaddr structure.
	271	*/
	272	int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
	273	const char *ip, unsigned int port)
	274	{
	275	int ret;
	276
a0377dfe FD	277	LTTNG_ASSERT(sockaddr);
	278	LTTNG_ASSERT(ip);
	279	LTTNG_ASSERT(port > 0 && port <= 65535);
6364a07a DG	280
	281	memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
	282
	283	sockaddr->type = LTTCOMM_INET6;
	284	sockaddr->addr.sin6.sin6_family = AF_INET6;
	285	sockaddr->addr.sin6.sin6_port = htons(port);
	286	ret = inet_pton(sockaddr->addr.sin6.sin6_family, ip,
	287	&sockaddr->addr.sin6.sin6_addr);
	288	if (ret < 1) {
	289	ret = -1;
	290	goto error;
	291	}
	292
	293	error:
	294	return ret;
	295	}
de5e9086 DG	296
	297	/*
	298	* Return allocated lttcomm socket structure from lttng URI.
	299	*/
	300	struct lttcomm_sock lttcomm_alloc_sock_from_uri(struct lttng_uri uri)
	301	{
	302	int ret;
	303	int _sock_proto;
	304	struct lttcomm_sock *sock = NULL;
	305
	306	/* Safety net */
a0377dfe	307	LTTNG_ASSERT(uri);
de5e9086 DG	308
	309	/* Check URI protocol */
	310	if (uri->proto == LTTNG_TCP) {
	311	_sock_proto = LTTCOMM_SOCK_TCP;
	312	} else {
	313	ERR("Relayd invalid URI proto: %d", uri->proto);
	314	goto alloc_error;
	315	}
	316
64efa44e	317	sock = lttcomm_alloc_sock((lttcomm_sock_proto) _sock_proto);
de5e9086 DG	318	if (sock == NULL) {
	319	goto alloc_error;
	320	}
	321
	322	/* Check destination type */
	323	if (uri->dtype == LTTNG_DST_IPV4) {
	324	ret = lttcomm_init_inet_sockaddr(&sock->sockaddr, uri->dst.ipv4,
	325	uri->port);
	326	if (ret < 0) {
	327	goto error;
	328	}
	329	} else if (uri->dtype == LTTNG_DST_IPV6) {
	330	ret = lttcomm_init_inet6_sockaddr(&sock->sockaddr, uri->dst.ipv6,
	331	uri->port);
	332	if (ret < 0) {
	333	goto error;
	334	}
	335	} else {
	336	/* Command URI is invalid */
	337	ERR("Relayd invalid URI dst type: %d", uri->dtype);
	338	goto error;
	339	}
	340
	341	return sock;
	342
	343	error:
	344	lttcomm_destroy_sock(sock);
	345	alloc_error:
	346	return NULL;
	347	}
	348
	349	/*
	350	* Destroy and free lttcomm socket.
	351	*/
	352	void lttcomm_destroy_sock(struct lttcomm_sock *sock)
	353	{
0e428499	354	free(sock);
de5e9086	355	}
6151a90f JD	356
	357	/*
	358	* Allocate and return a relayd socket object using a given URI to initialize
	359	* it and the major/minor version of the supported protocol.
	360	*
	361	* On error, NULL is returned.
	362	*/
	363	struct lttcomm_relayd_sock lttcomm_alloc_relayd_sock(struct lttng_uri uri,
	364	uint32_t major, uint32_t minor)
	365	{
	366	int ret;
	367	struct lttcomm_sock *tmp_sock = NULL;
64803277	368	struct lttcomm_relayd_sock *rsock = zmalloc<lttcomm_relayd_sock>();
6151a90f	369
a0377dfe	370	LTTNG_ASSERT(uri);
6151a90f	371
6151a90f JD	372	if (!rsock) {
	373	PERROR("zmalloc relayd sock");
	374	goto error;
	375	}
	376
	377	/* Allocate socket object from URI */
	378	tmp_sock = lttcomm_alloc_sock_from_uri(uri);
	379	if (tmp_sock == NULL) {
	380	goto error_free;
	381	}
	382
	383	/*
	384	* Create socket object which basically sets the ops according to the
	385	* socket protocol.
	386	*/
	387	lttcomm_copy_sock(&rsock->sock, tmp_sock);
	388	/* Temporary socket pointer not needed anymore. */
	389	lttcomm_destroy_sock(tmp_sock);
	390	ret = lttcomm_create_sock(&rsock->sock);
	391	if (ret < 0) {
	392	goto error_free;
	393	}
	394
	395	rsock->major = major;
	396	rsock->minor = minor;
	397
	398	return rsock;
	399
	400	error_free:
	401	free(rsock);
	402	error:
	403	return NULL;
	404	}
554831e7	405
783a3b9a MD	406	/*
	407	* Set socket receiving timeout.
	408	*/
783a3b9a MD	409	int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec)
	410	{
	411	int ret;
	412	struct timeval tv;
	413
	414	tv.tv_sec = msec / 1000;
	415	tv.tv_usec = (msec % 1000) * 1000;
	416
	417	ret = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
	418	if (ret < 0) {
	419	PERROR("setsockopt SO_RCVTIMEO");
	420	}
	421
	422	return ret;
	423	}
	424
	425	/*
	426	* Set socket sending timeout.
	427	*/
783a3b9a MD	428	int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec)
	429	{
	430	int ret;
	431	struct timeval tv;
	432
	433	tv.tv_sec = msec / 1000;
	434	tv.tv_usec = (msec % 1000) * 1000;
	435
	436	ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
	437	if (ret < 0) {
	438	PERROR("setsockopt SO_SNDTIMEO");
	439	}
	440
	441	return ret;
	442	}
	443
2288467f JG	444	int lttcomm_sock_get_port(const struct lttcomm_sock sock, uint16_t port)
2288467f JG	445	{
a0377dfe FD	446	LTTNG_ASSERT(sock);
	447	LTTNG_ASSERT(port);
	448	LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET \|\|
2288467f	449	sock->sockaddr.type == LTTCOMM_INET6);
a0377dfe	450	LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP \|\|
2288467f JG	451	sock->proto == LTTCOMM_SOCK_UDP);
	452
	453	switch (sock->sockaddr.type) {
	454	case LTTCOMM_INET:
	455	*port = ntohs(sock->sockaddr.addr.sin.sin_port);
	456	break;
	457	case LTTCOMM_INET6:
	458	*port = ntohs(sock->sockaddr.addr.sin6.sin6_port);
	459	break;
	460	default:
	461	abort();
	462	}
	463
	464	return 0;
	465	}
	466
2288467f JG	467	int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port)
2288467f JG	468	{
a0377dfe FD	469	LTTNG_ASSERT(sock);
a0377dfe FD	470	LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET \|\|
2288467f	471	sock->sockaddr.type == LTTCOMM_INET6);
a0377dfe	472	LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP \|\|
2288467f JG	473	sock->proto == LTTCOMM_SOCK_UDP);
	474
	475	switch (sock->sockaddr.type) {
	476	case LTTCOMM_INET:
	477	sock->sockaddr.addr.sin.sin_port = htons(port);
	478	break;
	479	case LTTCOMM_INET6:
	480	sock->sockaddr.addr.sin6.sin6_port = htons(port);
	481	break;
	482	default:
	483	abort();
	484	}
	485
	486	return 0;
	487	}
	488
554831e7 MD	489	void lttcomm_init(void)
	490	{
	491	const char *env;
	492
	493	env = getenv(NETWORK_TIMEOUT_ENV);
	494	if (env) {
	495	long timeout;
	496
	497	errno = 0;
	498	timeout = strtol(env, NULL, 0);
	499	if (errno != 0 \|\| timeout < -1L) {
	500	PERROR("Network timeout");
	501	} else {
	502	if (timeout > 0) {
	503	network_timeout = timeout;
	504	}
	505	}
	506	}
	507	}
	508
554831e7 MD	509	unsigned long lttcomm_get_network_timeout(void)
	510	{
	511	return network_timeout;
	512	}
4222116f JR	513
	514	/*
	515	* Only valid for an ipv4 and ipv6 bound socket that is already connected to its
	516	* peer.
	517	*/
	518	int lttcomm_populate_sock_from_open_socket(
	519	struct lttcomm_sock *sock,
	520	int fd,
	521	enum lttcomm_sock_proto protocol)
	522	{
	523	int ret = 0;
	524	socklen_t storage_len;
1c9a0b0e	525	struct sockaddr_storage storage = {};
4222116f JR	526
	527	assert(sock);
	528	assert(fd >= 0);
	529
	530	sock->proto = protocol;
	531
	532	storage_len = sizeof(storage);
	533	ret = getpeername(fd, (struct sockaddr *) &storage,
	534	&storage_len);
	535	if (ret) {
	536	ERR("Failed to get peer info for socket %d (errno: %d)", fd,
	537	errno);
	538	ret = -1;
	539	goto end;
	540	}
	541
	542	if (storage_len > sizeof(storage)) {
	543	ERR("Failed to get peer info for socket %d: storage size is too small", fd);
	544	ret = -1;
	545	goto end;
	546	}
	547
	548	switch (storage.ss_family) {
	549	case AF_INET:
	550	sock->sockaddr.type = LTTCOMM_INET;
	551	memcpy(&sock->sockaddr.addr, &storage,
	552	sizeof(struct sockaddr_in));
	553	break;
	554	case AF_INET6:
	555	sock->sockaddr.type = LTTCOMM_INET6;
	556	memcpy(&sock->sockaddr.addr, &storage,
	557	sizeof(struct sockaddr_in6));
	558	break;
	559	default:
	560	abort();
	561	break;
	562	}
	563
	564	/* Create a valid socket object with a temporary fd. */
	565	ret = lttcomm_create_sock(sock);
	566	if (ret < 0) {
	567	ERR("Failed to create temporary socket object");
	568	ret = -1;
	569	goto end;
	570	}
	571
	572	/* Substitute the fd. */
	573	if (sock->ops->close(sock)) {
	574	ret = -1;
	575	goto end;
	576	}
	577	sock->fd = fd;
	578
	579	end:
	580	return ret;
	581	}