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

/*
 * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#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 (!lttng_buffer_view_is_valid(&location_comm_view)) {
		goto error;
	}

	offset += location_comm_view.size;
	location_comm = (const struct lttng_trace_archive_location_comm *) 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 (!lttng_buffer_view_is_valid(&absolute_path_view)) {
			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 (!lttng_buffer_view_is_valid(&hostname_view) ||
				!lttng_buffer_view_is_valid(
						&relative_path_view)) {
			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;

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