[lttng-tools.git] / src / common / location.c

/*
 * Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <lttng/location-internal.h>
#include <common/macros.h>
#include <stdlib.h>

static
struct lttng_trace_archive_location *lttng_trace_archive_location_create(
		enum lttng_trace_archive_location_type type)
{
	struct lttng_trace_archive_location *location;

	location = zmalloc(sizeof(*location));
	if (!location) {
		goto end;
	}

	location->type = type;
end:
	return location;
}

LTTNG_HIDDEN
void lttng_trace_archive_location_destroy(
		struct lttng_trace_archive_location *location)
{
	if (!location) {
		return;
	}

	switch (location->type) {
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
		free(location->types.local.absolute_path);
		break;
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
		free(location->types.relay.host);
		free(location->types.relay.relative_path);
		break;
	default:
		abort();
	}

	free(location);
}

LTTNG_HIDDEN
struct lttng_trace_archive_location *lttng_trace_archive_location_local_create(
		const char *absolute_path)
{
	struct lttng_trace_archive_location *location = NULL;

	if (!absolute_path) {
		goto end;
	}

	location = lttng_trace_archive_location_create(
			LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL);
	if (!location) {
		goto end;
	}

	location->types.local.absolute_path = strdup(absolute_path);
	if (!location->types.local.absolute_path) {
		goto error;
	}

end:
	return location;
error:
	lttng_trace_archive_location_destroy(location);
	return NULL;
}

LTTNG_HIDDEN
struct lttng_trace_archive_location *lttng_trace_archive_location_relay_create(
		const char *host,
		enum lttng_trace_archive_location_relay_protocol_type protocol,
		uint16_t control_port, uint16_t data_port,
		const char *relative_path)
{
	struct lttng_trace_archive_location *location = NULL;

	if (!host || !relative_path) {
		goto end;
	}

	location = lttng_trace_archive_location_create(
			LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY);
	if (!location) {
		goto end;
	}

	location->types.relay.host = strdup(host);
	if (!location->types.relay.host) {
		goto error;
	}
	location->types.relay.relative_path = strdup(relative_path);
	if (!location->types.relay.relative_path) {
		goto error;
	}

	location->types.relay.protocol = protocol;
	location->types.relay.ports.control = control_port;
	location->types.relay.ports.data = data_port;
end:
	return location;
error:
	lttng_trace_archive_location_destroy(location);
	return NULL;
}

LTTNG_HIDDEN
ssize_t lttng_trace_archive_location_create_from_buffer(
		const struct lttng_buffer_view *view,
		struct lttng_trace_archive_location **location)
{
	size_t offset = 0;
	const struct lttng_trace_archive_location_comm *location_comm;
	struct lttng_buffer_view location_comm_view;

	location_comm_view = lttng_buffer_view_from_view(view, 0,
			sizeof(*location_comm));
	if (!location_comm_view.data) {
		goto error;
	}
	offset += location_comm_view.size;
	location_comm = (const struct lttng_trace_archive_location_comm *) view->data;

	switch ((enum lttng_trace_archive_location_type) location_comm->type) {
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	{
		const struct lttng_buffer_view absolute_path_view =
				lttng_buffer_view_from_view(view, offset,
				location_comm->types.local.absolute_path_len);

		if (!absolute_path_view.data) {
			goto error;
		}
		if (absolute_path_view.data[absolute_path_view.size - 1] != '\0') {
			goto error;
		}
		offset += absolute_path_view.size;

		*location = lttng_trace_archive_location_local_create(
				absolute_path_view.data);
		if (!*location) {
			goto error;
		}
		break;
	}
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	{
		const struct lttng_buffer_view hostname_view =
				lttng_buffer_view_from_view(view, offset,
				location_comm->types.relay.hostname_len);
		const struct lttng_buffer_view relative_path_view =
				lttng_buffer_view_from_view(view,
				offset + hostname_view.size,
				location_comm->types.relay.relative_path_len);

		if (!hostname_view.data || !relative_path_view.data) {
			goto error;
		}
		if (hostname_view.data[hostname_view.size - 1] != '\0') {
			goto error;
		}
		if (relative_path_view.data[relative_path_view.size - 1] != '\0') {
			goto error;
		}
		offset += hostname_view.size + relative_path_view.size;

		*location = lttng_trace_archive_location_relay_create(
				hostname_view.data,
				(enum lttng_trace_archive_location_relay_protocol_type) location_comm->types.relay.protocol,
				location_comm->types.relay.ports.control,
				location_comm->types.relay.ports.data,
				relative_path_view.data);
		if (!*location) {
			goto error;
		}
		break;
	}
	default:
		goto error;
	}

	return offset;
error:
	return -1;
}

LTTNG_HIDDEN
ssize_t lttng_trace_archive_location_serialize(
		const struct lttng_trace_archive_location *location,
		struct lttng_dynamic_buffer *buffer)
{
	int ret;
	struct lttng_trace_archive_location_comm location_comm;
	const size_t original_buffer_size = buffer->size;

	location_comm.type = (int8_t) location->type;

	switch (location->type) {
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
		location_comm.types.local.absolute_path_len =
				strlen(location->types.local.absolute_path) + 1;
		break;
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
		location_comm.types.relay.hostname_len =
				strlen(location->types.relay.host) + 1;
		location_comm.types.relay.protocol =
				(int8_t) location->types.relay.protocol;
		location_comm.types.relay.ports.control =
				location->types.relay.ports.control;
		location_comm.types.relay.ports.data =
				location->types.relay.ports.data;
		location_comm.types.relay.relative_path_len =
				strlen(location->types.relay.relative_path) + 1;
		break;
	default:
		abort();
	}

	ret = lttng_dynamic_buffer_append(buffer, &location_comm,
			sizeof(location_comm));
	if (ret) {
		goto error;
	}

	switch (location->type) {
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
		ret = lttng_dynamic_buffer_append(buffer,
				location->types.local.absolute_path,
				location_comm.types.local.absolute_path_len);
		if (ret) {
			goto error;
		}
		break;
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
		ret = lttng_dynamic_buffer_append(buffer,
				location->types.relay.host,
				location_comm.types.relay.hostname_len);
		if (ret) {
			goto error;
		}
		ret = lttng_dynamic_buffer_append(buffer,
				location->types.relay.relative_path,
				location_comm.types.relay.relative_path_len);
		if (ret) {
			goto error;
		}
		break;
	default:
		abort();
	}

	return buffer->size - original_buffer_size;
error:
	return -1;
}

enum lttng_trace_archive_location_type lttng_trace_archive_location_get_type(
		const struct lttng_trace_archive_location *location)
{
	enum lttng_trace_archive_location_type type;

	if (!location) {
		type = LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_UNKNOWN;
		goto end;
	}

	type = location->type;
end:
	return type;
}

enum lttng_trace_archive_location_status
lttng_trace_archive_location_local_get_absolute_path(
		const struct lttng_trace_archive_location *location,
		const char **absolute_path)
{
	enum lttng_trace_archive_location_status status =
			LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;

	if (!location || !absolute_path ||
			location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL) {
		status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
		goto end;
	}

	*absolute_path = location->types.local.absolute_path;
end:
	return status;
}

enum lttng_trace_archive_location_status
lttng_trace_archive_location_relay_get_host(
		const struct lttng_trace_archive_location *location,
		const char **relay_host)
{
	enum lttng_trace_archive_location_status status =
			LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;

	if (!location || !relay_host ||
			location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
		status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
		goto end;
	}

	*relay_host = location->types.relay.host;
end:
	return status;
}

enum lttng_trace_archive_location_status
lttng_trace_archive_location_relay_get_relative_path(
		const struct lttng_trace_archive_location *location,
		const char **relative_path)
{
	enum lttng_trace_archive_location_status status =
			LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;

	if (!location || !relative_path ||
			location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
		status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
		goto end;
	}

	*relative_path = location->types.relay.relative_path;
end:
	return status;
}

enum lttng_trace_archive_location_status
lttng_trace_archive_location_relay_get_control_port(
		const struct lttng_trace_archive_location *location,
		uint16_t *control_port)
{
	enum lttng_trace_archive_location_status status =
			LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;

	if (!location || !control_port ||
			location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
		status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
		goto end;
	}

	*control_port = location->types.relay.ports.control;
end:
	return status;
}

enum lttng_trace_archive_location_status
lttng_trace_archive_location_relay_get_data_port(
		const struct lttng_trace_archive_location *location,
		uint16_t *data_port)
{
	enum lttng_trace_archive_location_status status =
			LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;

	if (!location || !data_port ||
			location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
		status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
		goto end;
	}

	*data_port = location->types.relay.ports.data;
end:
	return status;
}

enum lttng_trace_archive_location_status
lttng_trace_archive_location_relay_get_protocol_type(
		const struct lttng_trace_archive_location *location,
		enum lttng_trace_archive_location_relay_protocol_type *protocol)
{
	enum lttng_trace_archive_location_status status =
			LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;

	if (!location || !protocol ||
			location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
		status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
		goto end;
	}

	*protocol = location->types.relay.protocol;
end:
	return status;
}
Commit	Line	Data
434131e4 JG	1	/*
	2	* Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* This library is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This library is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
	11	* for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public License
	14	* along with this library; if not, write to the Free Software Foundation,
	15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
	18	#include <lttng/location-internal.h>
	19	#include <common/macros.h>
	20	#include <stdlib.h>
	21
	22	static
	23	struct lttng_trace_archive_location *lttng_trace_archive_location_create(
	24	enum lttng_trace_archive_location_type type)
	25	{
	26	struct lttng_trace_archive_location *location;
	27
	28	location = zmalloc(sizeof(*location));
	29	if (!location) {
	30	goto end;
	31	}
	32
	33	location->type = type;
	34	end:
	35	return location;
	36	}
	37
	38	LTTNG_HIDDEN
	39	void lttng_trace_archive_location_destroy(
	40	struct lttng_trace_archive_location *location)
	41	{
	42	if (!location) {
	43	return;
	44	}
	45
	46	switch (location->type) {
	47	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	48	free(location->types.local.absolute_path);
	49	break;
	50	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	51	free(location->types.relay.host);
	52	free(location->types.relay.relative_path);
	53	break;
	54	default:
	55	abort();
	56	}
	57
	58	free(location);
	59	}
	60
	61	LTTNG_HIDDEN
	62	struct lttng_trace_archive_location *lttng_trace_archive_location_local_create(
	63	const char *absolute_path)
	64	{
65	struct lttng_trace_archive_location *location = NULL;
66
67	if (!absolute_path) {
68	goto end;
69	}
70
71	location = lttng_trace_archive_location_create(
72	LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL);
73	if (!location) {
74	goto end;
75	}
76
77	location->types.local.absolute_path = strdup(absolute_path);
78	if (!location->types.local.absolute_path) {
79	goto error;
80	}
81
82	end:
83	return location;
84	error:
85	lttng_trace_archive_location_destroy(location);
86	return NULL;
87	}
88
89	LTTNG_HIDDEN
90	struct lttng_trace_archive_location *lttng_trace_archive_location_relay_create(
91	const char *host,
92	enum lttng_trace_archive_location_relay_protocol_type protocol,
93	uint16_t control_port, uint16_t data_port,
94	const char *relative_path)
95	{
96	struct lttng_trace_archive_location *location = NULL;
97
98	if (!host \|\| !relative_path) {
99	goto end;
100	}
101
102	location = lttng_trace_archive_location_create(
103	LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY);
104	if (!location) {
105	goto end;
106	}
107
108	location->types.relay.host = strdup(host);
109	if (!location->types.relay.host) {
110	goto error;
111	}
112	location->types.relay.relative_path = strdup(relative_path);
113	if (!location->types.relay.relative_path) {
114	goto error;
115	}
116
117	location->types.relay.protocol = protocol;
118	location->types.relay.ports.control = control_port;
119	location->types.relay.ports.data = data_port;
120	end:
121	return location;
122	error:
123	lttng_trace_archive_location_destroy(location);
124	return NULL;
125	}
126
1e9f1cf8 JG	127	LTTNG_HIDDEN
	128	ssize_t lttng_trace_archive_location_create_from_buffer(
	129	const struct lttng_buffer_view *view,
	130	struct lttng_trace_archive_location **location)
	131	{
	132	size_t offset = 0;
	133	const struct lttng_trace_archive_location_comm *location_comm;
	134	struct lttng_buffer_view location_comm_view;
	135
	136	location_comm_view = lttng_buffer_view_from_view(view, 0,
	137	sizeof(*location_comm));
	138	if (!location_comm_view.data) {
	139	goto error;
	140	}
	141	offset += location_comm_view.size;
	142	location_comm = (const struct lttng_trace_archive_location_comm *) view->data;
	143
	144	switch ((enum lttng_trace_archive_location_type) location_comm->type) {
	145	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	146	{
	147	const struct lttng_buffer_view absolute_path_view =
	148	lttng_buffer_view_from_view(view, offset,
	149	location_comm->types.local.absolute_path_len);
	150
	151	if (!absolute_path_view.data) {
	152	goto error;
	153	}
	154	if (absolute_path_view.data[absolute_path_view.size - 1] != '\0') {
	155	goto error;
	156	}
	157	offset += absolute_path_view.size;
	158
	159	*location = lttng_trace_archive_location_local_create(
	160	absolute_path_view.data);
	161	if (!*location) {
	162	goto error;
	163	}
	164	break;
	165	}
	166	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	167	{
	168	const struct lttng_buffer_view hostname_view =
	169	lttng_buffer_view_from_view(view, offset,
	170	location_comm->types.relay.hostname_len);
	171	const struct lttng_buffer_view relative_path_view =
	172	lttng_buffer_view_from_view(view,
	173	offset + hostname_view.size,
	174	location_comm->types.relay.relative_path_len);
	175
	176	if (!hostname_view.data \|\| !relative_path_view.data) {
	177	goto error;
	178	}
	179	if (hostname_view.data[hostname_view.size - 1] != '\0') {
	180	goto error;
	181	}
	182	if (relative_path_view.data[relative_path_view.size - 1] != '\0') {
	183	goto error;
	184	}
	185	offset += hostname_view.size + relative_path_view.size;
	186
	187	*location = lttng_trace_archive_location_relay_create(
	188	hostname_view.data,
	189	(enum lttng_trace_archive_location_relay_protocol_type) location_comm->types.relay.protocol,
	190	location_comm->types.relay.ports.control,
191	location_comm->types.relay.ports.data,
192	relative_path_view.data);
193	if (!*location) {
194	goto error;
195	}
196	break;
197	}
198	default:
199	goto error;
200	}
201
e4b6e50f	202	return offset;
1e9f1cf8 JG	203	error:
	204	return -1;
	205	}
	206
	207	LTTNG_HIDDEN
	208	ssize_t lttng_trace_archive_location_serialize(
	209	const struct lttng_trace_archive_location *location,
	210	struct lttng_dynamic_buffer *buffer)
	211	{
	212	int ret;
	213	struct lttng_trace_archive_location_comm location_comm;
	214	const size_t original_buffer_size = buffer->size;
	215
	216	location_comm.type = (int8_t) location->type;
	217
	218	switch (location->type) {
	219	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	220	location_comm.types.local.absolute_path_len =
	221	strlen(location->types.local.absolute_path) + 1;
	222	break;
	223	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	224	location_comm.types.relay.hostname_len =
	225	strlen(location->types.relay.host) + 1;
	226	location_comm.types.relay.protocol =
	227	(int8_t) location->types.relay.protocol;
	228	location_comm.types.relay.ports.control =
	229	location->types.relay.ports.control;
	230	location_comm.types.relay.ports.data =
	231	location->types.relay.ports.data;
	232	location_comm.types.relay.relative_path_len =
	233	strlen(location->types.relay.relative_path) + 1;
	234	break;
	235	default:
	236	abort();
	237	}
	238
	239	ret = lttng_dynamic_buffer_append(buffer, &location_comm,
	240	sizeof(location_comm));
	241	if (ret) {
	242	goto error;
	243	}
	244
	245	switch (location->type) {
	246	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	247	ret = lttng_dynamic_buffer_append(buffer,
	248	location->types.local.absolute_path,
	249	location_comm.types.local.absolute_path_len);
	250	if (ret) {
	251	goto error;
	252	}
	253	break;
	254	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	255	ret = lttng_dynamic_buffer_append(buffer,
	256	location->types.relay.host,
	257	location_comm.types.relay.hostname_len);
	258	if (ret) {
	259	goto error;
	260	}
	261	ret = lttng_dynamic_buffer_append(buffer,
	262	location->types.relay.relative_path,
	263	location_comm.types.relay.relative_path_len);
	264	if (ret) {
	265	goto error;
	266	}
267	break;
268	default:
269	abort();
270	}
271
272	return buffer->size - original_buffer_size;
273	error:
274	return -1;
275	}
276
434131e4 JG	277	enum lttng_trace_archive_location_type lttng_trace_archive_location_get_type(
	278	const struct lttng_trace_archive_location *location)
	279	{
	280	enum lttng_trace_archive_location_type type;
	281
	282	if (!location) {
	283	type = LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_UNKNOWN;
	284	goto end;
	285	}
	286
	287	type = location->type;
	288	end:
	289	return type;
	290	}
	291
	292	enum lttng_trace_archive_location_status
	293	lttng_trace_archive_location_local_get_absolute_path(
	294	const struct lttng_trace_archive_location *location,
	295	const char **absolute_path)
	296	{
	297	enum lttng_trace_archive_location_status status =
	298	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
	299
	300	if (!location \|\| !absolute_path \|\|
	301	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL) {
	302	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
	303	goto end;
	304	}
	305
	306	*absolute_path = location->types.local.absolute_path;
	307	end:
	308	return status;
	309	}
	310
	311	enum lttng_trace_archive_location_status
	312	lttng_trace_archive_location_relay_get_host(
	313	const struct lttng_trace_archive_location *location,
	314	const char **relay_host)
	315	{
	316	enum lttng_trace_archive_location_status status =
	317	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
	318
	319	if (!location \|\| !relay_host \|\|
	320	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
	321	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
	322	goto end;
	323	}
	324
	325	*relay_host = location->types.relay.host;
	326	end:
	327	return status;
	328	}
	329
	330	enum lttng_trace_archive_location_status
	331	lttng_trace_archive_location_relay_get_relative_path(
	332	const struct lttng_trace_archive_location *location,
	333	const char **relative_path)
	334	{
	335	enum lttng_trace_archive_location_status status =
	336	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
	337
	338	if (!location \|\| !relative_path \|\|
	339	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
	340	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
341	goto end;
342	}
343
344	*relative_path = location->types.relay.relative_path;
345	end:
346	return status;
347	}
348
349	enum lttng_trace_archive_location_status
350	lttng_trace_archive_location_relay_get_control_port(
351	const struct lttng_trace_archive_location *location,
352	uint16_t *control_port)
353	{
354	enum lttng_trace_archive_location_status status =
355	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
356
357	if (!location \|\| !control_port \|\|
358	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
359	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
360	goto end;
361	}
362
363	*control_port = location->types.relay.ports.control;
364	end:
365	return status;
366	}
367
368	enum lttng_trace_archive_location_status
369	lttng_trace_archive_location_relay_get_data_port(
370	const struct lttng_trace_archive_location *location,
371	uint16_t *data_port)
372	{
373	enum lttng_trace_archive_location_status status =
374	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
375
376	if (!location \|\| !data_port \|\|
377	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
378	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
379	goto end;
380	}
381
382	*data_port = location->types.relay.ports.data;
383	end:
384	return status;
385	}
386
387	enum lttng_trace_archive_location_status
388	lttng_trace_archive_location_relay_get_protocol_type(
389	const struct lttng_trace_archive_location *location,
390	enum lttng_trace_archive_location_relay_protocol_type *protocol)
391	{
392	enum lttng_trace_archive_location_status status =
393	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
394
395	if (!location \|\| !protocol \|\|
396	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
397	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
398	goto end;
399	}
400
401	*protocol = location->types.relay.protocol;
402	end:
403	return status;
404	}