[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 "sessiond-comm.hpp"

#include <common/common.hpp>
#include <common/compat/errno.hpp>

#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

/* 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 == nullptr) {
		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 == nullptr) {
		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 = nullptr;

	/* 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 == nullptr) {
		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 nullptr;
}

/*
 * 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 = nullptr;
	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 == nullptr) {
		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 nullptr;
}

/*
 * 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()
{
	const char *env;

	env = getenv(NETWORK_TIMEOUT_ENV);
	if (env) {
		long timeout;

		errno = 0;
		timeout = strtol(env, nullptr, 0);
		if (errno != 0 || timeout < -1L) {
			PERROR("Network timeout");
		} else {
			if (timeout > 0) {
				network_timeout = timeout;
			}
		}
	}
}

unsigned long lttcomm_get_network_timeout()
{
	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
28ab034a JG	11	#include "sessiond-comm.hpp"
	12
	13	#include <common/common.hpp>
	14	#include <common/compat/errno.hpp>
	15
	16	#include <inttypes.h>
fac6795d DG	17	#include <limits.h>
	18	#include <stdio.h>
	19	#include <stdlib.h>
	20	#include <string.h>
fac6795d DG	21	#include <sys/stat.h>
fac6795d DG	22	#include <sys/types.h>
fac6795d	23	#include <unistd.h>
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
28ab034a	32	#define NETWORK_TIMEOUT_ENV "LTTNG_NETWORK_SOCKET_TIMEOUT"
554831e7	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	*/
28ab034a JG	42	static const char *lttcomm_return_code_str(lttcomm_return_code code)
28ab034a JG	43	{
64efa44e SM	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	128	if (code != LTTCOMM_CONSUMERD_SUCCESS &&
28ab034a	129	!(code >= LTTCOMM_CONSUMERD_COMMAND_SOCK_READY && code < LTTCOMM_NR)) {
64efa44e	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
cd9adb8b	183	if (sock == nullptr) {
de5e9086 DG	184	PERROR("zmalloc create sock");
de5e9086 DG	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);
cd9adb8b	210	if (sock == nullptr) {
6364a07a DG	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	*/
28ab034a	242	int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr sockaddr, const char ip, unsigned int port)
6364a07a DG	243	{
	244	int ret;
	245
a0377dfe FD	246	LTTNG_ASSERT(sockaddr);
	247	LTTNG_ASSERT(ip);
	248	LTTNG_ASSERT(port > 0 && port <= 65535);
6364a07a DG	249
	250	memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
	251
	252	sockaddr->type = LTTCOMM_INET;
	253	sockaddr->addr.sin.sin_family = AF_INET;
	254	sockaddr->addr.sin.sin_port = htons(port);
28ab034a	255	ret = inet_pton(sockaddr->addr.sin.sin_family, ip, &sockaddr->addr.sin.sin_addr);
6364a07a DG	256	if (ret < 1) {
6364a07a DG	257	ret = -1;
de5e9086	258	ERR("%s with port %d: unrecognized IPv4 address", ip, port);
6364a07a DG	259	goto error;
	260	}
	261	memset(sockaddr->addr.sin.sin_zero, 0, sizeof(sockaddr->addr.sin.sin_zero));
	262
	263	error:
	264	return ret;
	265	}
	266
	267	/*
	268	* Init IPv6 sockaddr structure.
	269	*/
	270	int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
28ab034a JG	271	const char *ip,
28ab034a JG	272	unsigned int port)
6364a07a DG	273	{
	274	int ret;
	275
a0377dfe FD	276	LTTNG_ASSERT(sockaddr);
	277	LTTNG_ASSERT(ip);
	278	LTTNG_ASSERT(port > 0 && port <= 65535);
6364a07a DG	279
	280	memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
	281
	282	sockaddr->type = LTTCOMM_INET6;
	283	sockaddr->addr.sin6.sin6_family = AF_INET6;
	284	sockaddr->addr.sin6.sin6_port = htons(port);
28ab034a	285	ret = inet_pton(sockaddr->addr.sin6.sin6_family, ip, &sockaddr->addr.sin6.sin6_addr);
6364a07a DG	286	if (ret < 1) {
	287	ret = -1;
	288	goto error;
	289	}
	290
	291	error:
	292	return ret;
	293	}
de5e9086 DG	294
	295	/*
	296	* Return allocated lttcomm socket structure from lttng URI.
	297	*/
	298	struct lttcomm_sock lttcomm_alloc_sock_from_uri(struct lttng_uri uri)
	299	{
	300	int ret;
	301	int _sock_proto;
cd9adb8b	302	struct lttcomm_sock *sock = nullptr;
de5e9086 DG	303
de5e9086 DG	304	/* Safety net */
a0377dfe	305	LTTNG_ASSERT(uri);
de5e9086 DG	306
	307	/* Check URI protocol */
	308	if (uri->proto == LTTNG_TCP) {
	309	_sock_proto = LTTCOMM_SOCK_TCP;
	310	} else {
	311	ERR("Relayd invalid URI proto: %d", uri->proto);
	312	goto alloc_error;
	313	}
	314
64efa44e	315	sock = lttcomm_alloc_sock((lttcomm_sock_proto) _sock_proto);
cd9adb8b	316	if (sock == nullptr) {
de5e9086 DG	317	goto alloc_error;
	318	}
	319
	320	/* Check destination type */
	321	if (uri->dtype == LTTNG_DST_IPV4) {
28ab034a	322	ret = lttcomm_init_inet_sockaddr(&sock->sockaddr, uri->dst.ipv4, uri->port);
de5e9086 DG	323	if (ret < 0) {
	324	goto error;
	325	}
	326	} else if (uri->dtype == LTTNG_DST_IPV6) {
28ab034a	327	ret = lttcomm_init_inet6_sockaddr(&sock->sockaddr, uri->dst.ipv6, uri->port);
de5e9086 DG	328	if (ret < 0) {
	329	goto error;
	330	}
	331	} else {
	332	/* Command URI is invalid */
	333	ERR("Relayd invalid URI dst type: %d", uri->dtype);
	334	goto error;
	335	}
	336
	337	return sock;
	338
	339	error:
	340	lttcomm_destroy_sock(sock);
	341	alloc_error:
cd9adb8b	342	return nullptr;
de5e9086 DG	343	}
	344
	345	/*
	346	* Destroy and free lttcomm socket.
	347	*/
	348	void lttcomm_destroy_sock(struct lttcomm_sock *sock)
	349	{
0e428499	350	free(sock);
de5e9086	351	}
6151a90f JD	352
	353	/*
	354	* Allocate and return a relayd socket object using a given URI to initialize
	355	* it and the major/minor version of the supported protocol.
	356	*
	357	* On error, NULL is returned.
	358	*/
28ab034a JG	359	struct lttcomm_relayd_sock *
28ab034a JG	360	lttcomm_alloc_relayd_sock(struct lttng_uri *uri, uint32_t major, uint32_t minor)
6151a90f JD	361	{
6151a90f JD	362	int ret;
cd9adb8b	363	struct lttcomm_sock *tmp_sock = nullptr;
64803277	364	struct lttcomm_relayd_sock *rsock = zmalloc<lttcomm_relayd_sock>();
6151a90f	365
a0377dfe	366	LTTNG_ASSERT(uri);
6151a90f	367
6151a90f JD	368	if (!rsock) {
	369	PERROR("zmalloc relayd sock");
	370	goto error;
	371	}
	372
	373	/* Allocate socket object from URI */
	374	tmp_sock = lttcomm_alloc_sock_from_uri(uri);
cd9adb8b	375	if (tmp_sock == nullptr) {
6151a90f JD	376	goto error_free;
	377	}
	378
	379	/*
	380	* Create socket object which basically sets the ops according to the
	381	* socket protocol.
	382	*/
	383	lttcomm_copy_sock(&rsock->sock, tmp_sock);
	384	/* Temporary socket pointer not needed anymore. */
	385	lttcomm_destroy_sock(tmp_sock);
	386	ret = lttcomm_create_sock(&rsock->sock);
	387	if (ret < 0) {
	388	goto error_free;
	389	}
	390
	391	rsock->major = major;
	392	rsock->minor = minor;
	393
	394	return rsock;
	395
	396	error_free:
	397	free(rsock);
	398	error:
cd9adb8b	399	return nullptr;
6151a90f	400	}
554831e7	401
783a3b9a MD	402	/*
	403	* Set socket receiving timeout.
	404	*/
783a3b9a MD	405	int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec)
	406	{
	407	int ret;
	408	struct timeval tv;
	409
	410	tv.tv_sec = msec / 1000;
	411	tv.tv_usec = (msec % 1000) * 1000;
	412
	413	ret = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
	414	if (ret < 0) {
	415	PERROR("setsockopt SO_RCVTIMEO");
	416	}
	417
	418	return ret;
	419	}
	420
	421	/*
	422	* Set socket sending timeout.
	423	*/
783a3b9a MD	424	int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec)
	425	{
	426	int ret;
	427	struct timeval tv;
	428
	429	tv.tv_sec = msec / 1000;
	430	tv.tv_usec = (msec % 1000) * 1000;
	431
	432	ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
	433	if (ret < 0) {
	434	PERROR("setsockopt SO_SNDTIMEO");
	435	}
	436
	437	return ret;
	438	}
	439
2288467f JG	440	int lttcomm_sock_get_port(const struct lttcomm_sock sock, uint16_t port)
2288467f JG	441	{
a0377dfe FD	442	LTTNG_ASSERT(sock);
a0377dfe FD	443	LTTNG_ASSERT(port);
28ab034a JG	444	LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET \|\| sock->sockaddr.type == LTTCOMM_INET6);
28ab034a JG	445	LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP \|\| sock->proto == LTTCOMM_SOCK_UDP);
2288467f JG	446
	447	switch (sock->sockaddr.type) {
	448	case LTTCOMM_INET:
	449	*port = ntohs(sock->sockaddr.addr.sin.sin_port);
	450	break;
	451	case LTTCOMM_INET6:
	452	*port = ntohs(sock->sockaddr.addr.sin6.sin6_port);
	453	break;
	454	default:
	455	abort();
	456	}
	457
	458	return 0;
	459	}
	460
2288467f JG	461	int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port)
2288467f JG	462	{
a0377dfe	463	LTTNG_ASSERT(sock);
28ab034a JG	464	LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET \|\| sock->sockaddr.type == LTTCOMM_INET6);
28ab034a JG	465	LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP \|\| sock->proto == LTTCOMM_SOCK_UDP);
2288467f JG	466
	467	switch (sock->sockaddr.type) {
	468	case LTTCOMM_INET:
	469	sock->sockaddr.addr.sin.sin_port = htons(port);
	470	break;
	471	case LTTCOMM_INET6:
	472	sock->sockaddr.addr.sin6.sin6_port = htons(port);
	473	break;
	474	default:
	475	abort();
	476	}
	477
	478	return 0;
	479	}
	480
cd9adb8b	481	void lttcomm_init()
554831e7 MD	482	{
	483	const char *env;
	484
	485	env = getenv(NETWORK_TIMEOUT_ENV);
	486	if (env) {
	487	long timeout;
	488
	489	errno = 0;
cd9adb8b	490	timeout = strtol(env, nullptr, 0);
554831e7 MD	491	if (errno != 0 \|\| timeout < -1L) {
	492	PERROR("Network timeout");
	493	} else {
	494	if (timeout > 0) {
	495	network_timeout = timeout;
	496	}
	497	}
	498	}
	499	}
	500
cd9adb8b	501	unsigned long lttcomm_get_network_timeout()
554831e7 MD	502	{
	503	return network_timeout;
	504	}
4222116f JR	505
	506	/*
	507	* Only valid for an ipv4 and ipv6 bound socket that is already connected to its
	508	* peer.
	509	*/
28ab034a JG	510	int lttcomm_populate_sock_from_open_socket(struct lttcomm_sock *sock,
	511	int fd,
	512	enum lttcomm_sock_proto protocol)
4222116f JR	513	{
	514	int ret = 0;
	515	socklen_t storage_len;
1c9a0b0e	516	struct sockaddr_storage storage = {};
4222116f JR	517
	518	assert(sock);
	519	assert(fd >= 0);
	520
	521	sock->proto = protocol;
	522
	523	storage_len = sizeof(storage);
28ab034a	524	ret = getpeername(fd, (struct sockaddr *) &storage, &storage_len);
4222116f	525	if (ret) {
28ab034a	526	ERR("Failed to get peer info for socket %d (errno: %d)", fd, errno);
4222116f JR	527	ret = -1;
	528	goto end;
	529	}
	530
	531	if (storage_len > sizeof(storage)) {
	532	ERR("Failed to get peer info for socket %d: storage size is too small", fd);
	533	ret = -1;
	534	goto end;
	535	}
	536
	537	switch (storage.ss_family) {
	538	case AF_INET:
	539	sock->sockaddr.type = LTTCOMM_INET;
28ab034a	540	memcpy(&sock->sockaddr.addr, &storage, sizeof(struct sockaddr_in));
4222116f JR	541	break;
	542	case AF_INET6:
	543	sock->sockaddr.type = LTTCOMM_INET6;
28ab034a	544	memcpy(&sock->sockaddr.addr, &storage, sizeof(struct sockaddr_in6));
4222116f JR	545	break;
	546	default:
	547	abort();
	548	break;
	549	}
	550
	551	/* Create a valid socket object with a temporary fd. */
	552	ret = lttcomm_create_sock(sock);
	553	if (ret < 0) {
	554	ERR("Failed to create temporary socket object");
	555	ret = -1;
	556	goto end;
	557	}
	558
	559	/* Substitute the fd. */
	560	if (sock->ops->close(sock)) {
	561	ret = -1;
	562	goto end;
	563	}
	564	sock->fd = fd;
	565
	566	end:
	567	return ret;
	568	}