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

/*
 * 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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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.
 */
LTTNG_HIDDEN
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;
}

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

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

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

LTTNG_HIDDEN
unsigned long lttcomm_get_network_timeout(void)
{
	return network_timeout;
}
Commit	Line	Data
826d496d	1	/*
ab5be9fa MJ	2	* Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
	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
6c1c0768	9	#define _LGPL_SOURCE
fac6795d DG	10	#include <limits.h>
	11	#include <stdio.h>
	12	#include <stdlib.h>
	13	#include <string.h>
fac6795d DG	14	#include <sys/stat.h>
fac6795d DG	15	#include <sys/types.h>
fac6795d	16	#include <unistd.h>
2288467f	17	#include <inttypes.h>
fac6795d	18
90e535ef	19	#include <common/common.h>
edf4b93e	20	#include <common/compat/errno.h>
990570ed	21
10a8a223	22	#include "sessiond-comm.h"
fac6795d	23
6364a07a	24	/* For Unix socket */
2038dd6c	25	#include <common/unix.h>
6364a07a DG	26	/* For Inet socket */
	27	#include "inet.h"
	28	/* For Inet6 socket */
	29	#include "inet6.h"
	30
554831e7 MD	31	#define NETWORK_TIMEOUT_ENV "LTTNG_NETWORK_SOCKET_TIMEOUT"
554831e7 MD	32
32dd26fb	33	static struct lttcomm_net_family net_families[] = {
6364a07a DG	34	{ LTTCOMM_INET, lttcomm_create_inet_sock },
	35	{ LTTCOMM_INET6, lttcomm_create_inet6_sock },
	36	};
	37
fac6795d DG	38	/*
	39	* Human readable error message.
	40	*/
	41	static const char *lttcomm_readable_code[] = {
f73fabfd DG	42	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) ] = "consumerd command socket ready",
	43	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SUCCESS_RECV_FD) ] = "consumerd success on receiving fds",
	44	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_RECV_FD) ] = "consumerd error on receiving fds",
	45	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_RECV_CMD) ] = "consumerd error on receiving command",
	46	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_ERROR) ] = "consumerd error in polling thread",
	47	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_NVAL) ] = "consumerd polling on closed fd",
	48	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_HUP) ] = "consumerd all fd hung up",
	49	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_EXIT_SUCCESS) ] = "consumerd exiting normally",
	50	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_EXIT_FAILURE) ] = "consumerd exiting on error",
	51	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_OUTFD_ERROR) ] = "consumerd error opening the tracefile",
	52	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_EBADF) ] = "consumerd splice EBADF",
	53	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_EINVAL) ] = "consumerd splice EINVAL",
	54	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_ENOMEM) ] = "consumerd splice ENOMEM",
	55	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_ESPIPE) ] = "consumerd splice ESPIPE",
40727660 MD	56	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ENOMEM) ] = "Consumer is out of memory",
	57	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_METADATA) ] = "Error with metadata",
	58	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_FATAL) ] = "Fatal error",
618a6a28	59	[ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_RELAYD_FAIL) ] = "Error on remote relayd",
80e327fa	60
f73fabfd DG	61	/* Last element */
f73fabfd DG	62	[ LTTCOMM_ERR_INDEX(LTTCOMM_NR) ] = "Unknown error code"
fac6795d DG	63	};
fac6795d DG	64
554831e7 MD	65	static unsigned long network_timeout;
554831e7 MD	66
fac6795d	67	/*
917216f6 DG	68	* Return ptr to string representing a human readable error code from the
917216f6 DG	69	* lttcomm_return_code enum.
fac6795d	70	*
917216f6	71	* These code MUST be negative in other to treat that as an error value.
fac6795d	72	*/
90e535ef	73	LTTNG_HIDDEN
fac6795d DG	74	const char *lttcomm_get_readable_code(enum lttcomm_return_code code)
fac6795d DG	75	{
f73fabfd	76	code = -code;
fac6795d	77
c617c0c6	78	if (code < LTTCOMM_CONSUMERD_COMMAND_SOCK_READY \|\| code > LTTCOMM_NR) {
f73fabfd	79	code = LTTCOMM_NR;
fac6795d DG	80	}
fac6795d DG	81
f73fabfd	82	return lttcomm_readable_code[LTTCOMM_ERR_INDEX(code)];
fac6795d	83	}
6364a07a DG	84
6364a07a DG	85	/*
de5e9086 DG	86	* Create socket from an already allocated lttcomm socket structure and init
de5e9086 DG	87	* sockaddr in the lttcomm sock.
6364a07a	88	*/
90e535ef	89	LTTNG_HIDDEN
de5e9086	90	int lttcomm_create_sock(struct lttcomm_sock *sock)
6364a07a	91	{
de5e9086	92	int ret, _sock_type, _sock_proto, domain;
6364a07a	93
a0377dfe	94	LTTNG_ASSERT(sock);
de5e9086 DG	95
	96	domain = sock->sockaddr.type;
	97	if (domain != LTTCOMM_INET && domain != LTTCOMM_INET6) {
	98	ERR("Create socket of unknown domain %d", domain);
	99	ret = -1;
	100	goto error;
6364a07a DG	101	}
6364a07a DG	102
de5e9086 DG	103	switch (sock->proto) {
	104	case LTTCOMM_SOCK_UDP:
	105	_sock_type = SOCK_DGRAM;
	106	_sock_proto = IPPROTO_UDP;
	107	break;
	108	case LTTCOMM_SOCK_TCP:
	109	_sock_type = SOCK_STREAM;
	110	_sock_proto = IPPROTO_TCP;
	111	break;
	112	default:
	113	ret = -1;
	114	goto error;
	115	}
6364a07a	116
de5e9086 DG	117	ret = net_families[domain].create(sock, _sock_type, _sock_proto);
	118	if (ret < 0) {
	119	goto error;
	120	}
	121
	122	error:
	123	return ret;
6364a07a DG	124	}
	125
	126	/*
de5e9086	127	* Return allocated lttcomm socket structure.
6364a07a	128	*/
90e535ef	129	LTTNG_HIDDEN
de5e9086	130	struct lttcomm_sock *lttcomm_alloc_sock(enum lttcomm_sock_proto proto)
6364a07a	131	{
de5e9086	132	struct lttcomm_sock *sock;
6364a07a	133
de5e9086 DG	134	sock = zmalloc(sizeof(struct lttcomm_sock));
	135	if (sock == NULL) {
	136	PERROR("zmalloc create sock");
	137	goto end;
6364a07a DG	138	}
	139
	140	sock->proto = proto;
de5e9086	141	sock->fd = -1;
6364a07a	142
de5e9086 DG	143	end:
de5e9086 DG	144	return sock;
6364a07a DG	145	}
	146
	147	/*
de5e9086 DG	148	* Return an allocated lttcomm socket structure and copy src content into
	149	* the newly created socket.
	150	*
	151	* This is mostly useful when lttcomm_sock are passed between process where the
	152	* fd and ops have to be changed within the correct address space.
6364a07a	153	*/
90e535ef	154	LTTNG_HIDDEN
de5e9086	155	struct lttcomm_sock lttcomm_alloc_copy_sock(struct lttcomm_sock src)
6364a07a	156	{
6364a07a DG	157	struct lttcomm_sock *sock;
6364a07a DG	158
de5e9086	159	/* Safety net */
a0377dfe	160	LTTNG_ASSERT(src);
de5e9086 DG	161
de5e9086 DG	162	sock = lttcomm_alloc_sock(src->proto);
6364a07a DG	163	if (sock == NULL) {
	164	goto alloc_error;
	165	}
	166
de5e9086	167	lttcomm_copy_sock(sock, src);
6364a07a	168
de5e9086	169	alloc_error:
6364a07a	170	return sock;
de5e9086	171	}
6364a07a	172
de5e9086 DG	173	/*
	174	* Create and copy socket from an allocated lttcomm socket structure.
	175	*
	176	* This is mostly useful when lttcomm_sock are passed between process where the
	177	* fd and ops have to be changed within the correct address space.
	178	*/
90e535ef	179	LTTNG_HIDDEN
de5e9086 DG	180	void lttcomm_copy_sock(struct lttcomm_sock dst, struct lttcomm_sock src)
	181	{
	182	/* Safety net */
a0377dfe FD	183	LTTNG_ASSERT(dst);
a0377dfe FD	184	LTTNG_ASSERT(src);
de5e9086 DG	185
	186	dst->proto = src->proto;
	187	dst->fd = src->fd;
	188	dst->ops = src->ops;
	189	/* Copy sockaddr information from original socket */
	190	memcpy(&dst->sockaddr, &src->sockaddr, sizeof(dst->sockaddr));
6364a07a DG	191	}
	192
	193	/*
	194	* Init IPv4 sockaddr structure.
	195	*/
90e535ef	196	LTTNG_HIDDEN
6364a07a DG	197	int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr *sockaddr,
	198	const char *ip, unsigned int port)
	199	{
	200	int ret;
	201
a0377dfe FD	202	LTTNG_ASSERT(sockaddr);
	203	LTTNG_ASSERT(ip);
	204	LTTNG_ASSERT(port > 0 && port <= 65535);
6364a07a DG	205
	206	memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
	207
	208	sockaddr->type = LTTCOMM_INET;
	209	sockaddr->addr.sin.sin_family = AF_INET;
	210	sockaddr->addr.sin.sin_port = htons(port);
	211	ret = inet_pton(sockaddr->addr.sin.sin_family, ip,
	212	&sockaddr->addr.sin.sin_addr);
	213	if (ret < 1) {
	214	ret = -1;
de5e9086	215	ERR("%s with port %d: unrecognized IPv4 address", ip, port);
6364a07a DG	216	goto error;
	217	}
	218	memset(sockaddr->addr.sin.sin_zero, 0, sizeof(sockaddr->addr.sin.sin_zero));
	219
	220	error:
	221	return ret;
	222	}
	223
	224	/*
	225	* Init IPv6 sockaddr structure.
	226	*/
90e535ef	227	LTTNG_HIDDEN
6364a07a DG	228	int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
	229	const char *ip, unsigned int port)
	230	{
	231	int ret;
	232
a0377dfe FD	233	LTTNG_ASSERT(sockaddr);
	234	LTTNG_ASSERT(ip);
	235	LTTNG_ASSERT(port > 0 && port <= 65535);
6364a07a DG	236
	237	memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
	238
	239	sockaddr->type = LTTCOMM_INET6;
	240	sockaddr->addr.sin6.sin6_family = AF_INET6;
	241	sockaddr->addr.sin6.sin6_port = htons(port);
	242	ret = inet_pton(sockaddr->addr.sin6.sin6_family, ip,
	243	&sockaddr->addr.sin6.sin6_addr);
	244	if (ret < 1) {
	245	ret = -1;
	246	goto error;
	247	}
	248
	249	error:
	250	return ret;
	251	}
de5e9086 DG	252
	253	/*
	254	* Return allocated lttcomm socket structure from lttng URI.
	255	*/
90e535ef	256	LTTNG_HIDDEN
de5e9086 DG	257	struct lttcomm_sock lttcomm_alloc_sock_from_uri(struct lttng_uri uri)
	258	{
	259	int ret;
	260	int _sock_proto;
	261	struct lttcomm_sock *sock = NULL;
	262
	263	/* Safety net */
a0377dfe	264	LTTNG_ASSERT(uri);
de5e9086 DG	265
	266	/* Check URI protocol */
	267	if (uri->proto == LTTNG_TCP) {
	268	_sock_proto = LTTCOMM_SOCK_TCP;
	269	} else {
	270	ERR("Relayd invalid URI proto: %d", uri->proto);
	271	goto alloc_error;
	272	}
	273
	274	sock = lttcomm_alloc_sock(_sock_proto);
	275	if (sock == NULL) {
	276	goto alloc_error;
	277	}
	278
	279	/* Check destination type */
	280	if (uri->dtype == LTTNG_DST_IPV4) {
	281	ret = lttcomm_init_inet_sockaddr(&sock->sockaddr, uri->dst.ipv4,
	282	uri->port);
	283	if (ret < 0) {
	284	goto error;
	285	}
	286	} else if (uri->dtype == LTTNG_DST_IPV6) {
	287	ret = lttcomm_init_inet6_sockaddr(&sock->sockaddr, uri->dst.ipv6,
	288	uri->port);
	289	if (ret < 0) {
	290	goto error;
	291	}
	292	} else {
	293	/* Command URI is invalid */
	294	ERR("Relayd invalid URI dst type: %d", uri->dtype);
	295	goto error;
	296	}
	297
	298	return sock;
	299
	300	error:
	301	lttcomm_destroy_sock(sock);
	302	alloc_error:
	303	return NULL;
	304	}
	305
	306	/*
	307	* Destroy and free lttcomm socket.
	308	*/
90e535ef	309	LTTNG_HIDDEN
de5e9086 DG	310	void lttcomm_destroy_sock(struct lttcomm_sock *sock)
de5e9086 DG	311	{
0e428499	312	free(sock);
de5e9086	313	}
6151a90f JD	314
	315	/*
	316	* Allocate and return a relayd socket object using a given URI to initialize
	317	* it and the major/minor version of the supported protocol.
	318	*
	319	* On error, NULL is returned.
	320	*/
bc182241	321	LTTNG_HIDDEN
6151a90f JD	322	struct lttcomm_relayd_sock lttcomm_alloc_relayd_sock(struct lttng_uri uri,
	323	uint32_t major, uint32_t minor)
	324	{
	325	int ret;
	326	struct lttcomm_sock *tmp_sock = NULL;
	327	struct lttcomm_relayd_sock *rsock = NULL;
	328
a0377dfe	329	LTTNG_ASSERT(uri);
6151a90f JD	330
	331	rsock = zmalloc(sizeof(*rsock));
	332	if (!rsock) {
	333	PERROR("zmalloc relayd sock");
	334	goto error;
	335	}
	336
	337	/* Allocate socket object from URI */
	338	tmp_sock = lttcomm_alloc_sock_from_uri(uri);
	339	if (tmp_sock == NULL) {
	340	goto error_free;
	341	}
	342
	343	/*
	344	* Create socket object which basically sets the ops according to the
	345	* socket protocol.
	346	*/
	347	lttcomm_copy_sock(&rsock->sock, tmp_sock);
	348	/* Temporary socket pointer not needed anymore. */
	349	lttcomm_destroy_sock(tmp_sock);
	350	ret = lttcomm_create_sock(&rsock->sock);
	351	if (ret < 0) {
	352	goto error_free;
	353	}
	354
	355	rsock->major = major;
	356	rsock->minor = minor;
	357
	358	return rsock;
	359
	360	error_free:
	361	free(rsock);
	362	error:
	363	return NULL;
	364	}
554831e7	365
783a3b9a MD	366	/*
	367	* Set socket receiving timeout.
	368	*/
	369	LTTNG_HIDDEN
	370	int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec)
	371	{
	372	int ret;
	373	struct timeval tv;
	374
	375	tv.tv_sec = msec / 1000;
	376	tv.tv_usec = (msec % 1000) * 1000;
	377
	378	ret = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
	379	if (ret < 0) {
	380	PERROR("setsockopt SO_RCVTIMEO");
	381	}
	382
	383	return ret;
	384	}
	385
	386	/*
	387	* Set socket sending timeout.
	388	*/
	389	LTTNG_HIDDEN
	390	int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec)
	391	{
	392	int ret;
	393	struct timeval tv;
	394
	395	tv.tv_sec = msec / 1000;
	396	tv.tv_usec = (msec % 1000) * 1000;
	397
	398	ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
	399	if (ret < 0) {
	400	PERROR("setsockopt SO_SNDTIMEO");
	401	}
	402
	403	return ret;
	404	}
	405
2288467f JG	406	LTTNG_HIDDEN
	407	int lttcomm_sock_get_port(const struct lttcomm_sock sock, uint16_t port)
	408	{
a0377dfe FD	409	LTTNG_ASSERT(sock);
	410	LTTNG_ASSERT(port);
	411	LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET \|\|
2288467f	412	sock->sockaddr.type == LTTCOMM_INET6);
a0377dfe	413	LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP \|\|
2288467f JG	414	sock->proto == LTTCOMM_SOCK_UDP);
	415
	416	switch (sock->sockaddr.type) {
	417	case LTTCOMM_INET:
	418	*port = ntohs(sock->sockaddr.addr.sin.sin_port);
	419	break;
	420	case LTTCOMM_INET6:
	421	*port = ntohs(sock->sockaddr.addr.sin6.sin6_port);
	422	break;
	423	default:
	424	abort();
	425	}
	426
	427	return 0;
	428	}
	429
	430	LTTNG_HIDDEN
	431	int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port)
	432	{
a0377dfe FD	433	LTTNG_ASSERT(sock);
a0377dfe FD	434	LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET \|\|
2288467f	435	sock->sockaddr.type == LTTCOMM_INET6);
a0377dfe	436	LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP \|\|
2288467f JG	437	sock->proto == LTTCOMM_SOCK_UDP);
	438
	439	switch (sock->sockaddr.type) {
	440	case LTTCOMM_INET:
	441	sock->sockaddr.addr.sin.sin_port = htons(port);
	442	break;
	443	case LTTCOMM_INET6:
	444	sock->sockaddr.addr.sin6.sin6_port = htons(port);
	445	break;
	446	default:
	447	abort();
	448	}
	449
	450	return 0;
	451	}
	452
554831e7 MD	453	LTTNG_HIDDEN
	454	void lttcomm_init(void)
	455	{
	456	const char *env;
	457
	458	env = getenv(NETWORK_TIMEOUT_ENV);
	459	if (env) {
	460	long timeout;
	461
	462	errno = 0;
	463	timeout = strtol(env, NULL, 0);
	464	if (errno != 0 \|\| timeout < -1L) {
	465	PERROR("Network timeout");
	466	} else {
	467	if (timeout > 0) {
	468	network_timeout = timeout;
	469	}
	470	}
	471	}
	472	}
	473
	474	LTTNG_HIDDEN
	475	unsigned long lttcomm_get_network_timeout(void)
	476	{
	477	return network_timeout;
	478	}