[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 (!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;

	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
434131e4	1	/*
ab5be9fa	2	* Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
434131e4	3	*
ab5be9fa	4	* SPDX-License-Identifier: LGPL-2.1-only
434131e4	5	*
434131e4 JG	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
1e9f1cf8 JG	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 (!location_comm_view.data) {
	129	goto error;
	130	}
	131	offset += location_comm_view.size;
	132	location_comm = (const struct lttng_trace_archive_location_comm *) view->data;
	133
	134	switch ((enum lttng_trace_archive_location_type) location_comm->type) {
	135	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	136	{
	137	const struct lttng_buffer_view absolute_path_view =
	138	lttng_buffer_view_from_view(view, offset,
	139	location_comm->types.local.absolute_path_len);
	140
	141	if (!absolute_path_view.data) {
	142	goto error;
	143	}
	144	if (absolute_path_view.data[absolute_path_view.size - 1] != '\0') {
	145	goto error;
	146	}
	147	offset += absolute_path_view.size;
	148
	149	*location = lttng_trace_archive_location_local_create(
	150	absolute_path_view.data);
	151	if (!*location) {
	152	goto error;
	153	}
	154	break;
	155	}
	156	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	157	{
	158	const struct lttng_buffer_view hostname_view =
	159	lttng_buffer_view_from_view(view, offset,
	160	location_comm->types.relay.hostname_len);
	161	const struct lttng_buffer_view relative_path_view =
	162	lttng_buffer_view_from_view(view,
	163	offset + hostname_view.size,
	164	location_comm->types.relay.relative_path_len);
	165
	166	if (!hostname_view.data \|\| !relative_path_view.data) {
	167	goto error;
	168	}
	169	if (hostname_view.data[hostname_view.size - 1] != '\0') {
	170	goto error;
	171	}
	172	if (relative_path_view.data[relative_path_view.size - 1] != '\0') {
	173	goto error;
	174	}
	175	offset += hostname_view.size + relative_path_view.size;
	176
	177	*location = lttng_trace_archive_location_relay_create(
	178	hostname_view.data,
	179	(enum lttng_trace_archive_location_relay_protocol_type) location_comm->types.relay.protocol,
	180	location_comm->types.relay.ports.control,
181	location_comm->types.relay.ports.data,
182	relative_path_view.data);
183	if (!*location) {
184	goto error;
185	}
186	break;
187	}
188	default:
189	goto error;
190	}
191
e4b6e50f	192	return offset;
1e9f1cf8 JG	193	error:
	194	return -1;
	195	}
	196
	197	LTTNG_HIDDEN
	198	ssize_t lttng_trace_archive_location_serialize(
	199	const struct lttng_trace_archive_location *location,
	200	struct lttng_dynamic_buffer *buffer)
	201	{
	202	int ret;
	203	struct lttng_trace_archive_location_comm location_comm;
1e9f1cf8 JG	204
	205	location_comm.type = (int8_t) location->type;
	206
	207	switch (location->type) {
	208	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	209	location_comm.types.local.absolute_path_len =
	210	strlen(location->types.local.absolute_path) + 1;
	211	break;
	212	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	213	location_comm.types.relay.hostname_len =
	214	strlen(location->types.relay.host) + 1;
	215	location_comm.types.relay.protocol =
	216	(int8_t) location->types.relay.protocol;
	217	location_comm.types.relay.ports.control =
	218	location->types.relay.ports.control;
	219	location_comm.types.relay.ports.data =
	220	location->types.relay.ports.data;
	221	location_comm.types.relay.relative_path_len =
	222	strlen(location->types.relay.relative_path) + 1;
	223	break;
	224	default:
	225	abort();
	226	}
	227
	228	ret = lttng_dynamic_buffer_append(buffer, &location_comm,
	229	sizeof(location_comm));
	230	if (ret) {
	231	goto error;
	232	}
	233
	234	switch (location->type) {
	235	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	236	ret = lttng_dynamic_buffer_append(buffer,
	237	location->types.local.absolute_path,
	238	location_comm.types.local.absolute_path_len);
	239	if (ret) {
	240	goto error;
	241	}
	242	break;
	243	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	244	ret = lttng_dynamic_buffer_append(buffer,
	245	location->types.relay.host,
	246	location_comm.types.relay.hostname_len);
	247	if (ret) {
	248	goto error;
	249	}
	250	ret = lttng_dynamic_buffer_append(buffer,
	251	location->types.relay.relative_path,
	252	location_comm.types.relay.relative_path_len);
	253	if (ret) {
	254	goto error;
	255	}
	256	break;
	257	default:
	258	abort();
	259	}
	260
f7daf93a	261	return 0;
1e9f1cf8 JG	262	error:
	263	return -1;
	264	}
	265
434131e4 JG	266	enum lttng_trace_archive_location_type lttng_trace_archive_location_get_type(
	267	const struct lttng_trace_archive_location *location)
	268	{
	269	enum lttng_trace_archive_location_type type;
	270
	271	if (!location) {
	272	type = LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_UNKNOWN;
	273	goto end;
	274	}
	275
	276	type = location->type;
	277	end:
	278	return type;
	279	}
	280
	281	enum lttng_trace_archive_location_status
	282	lttng_trace_archive_location_local_get_absolute_path(
	283	const struct lttng_trace_archive_location *location,
	284	const char **absolute_path)
	285	{
	286	enum lttng_trace_archive_location_status status =
	287	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
	288
	289	if (!location \|\| !absolute_path \|\|
	290	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL) {
	291	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
	292	goto end;
	293	}
	294
	295	*absolute_path = location->types.local.absolute_path;
	296	end:
	297	return status;
	298	}
	299
	300	enum lttng_trace_archive_location_status
	301	lttng_trace_archive_location_relay_get_host(
	302	const struct lttng_trace_archive_location *location,
	303	const char **relay_host)
	304	{
	305	enum lttng_trace_archive_location_status status =
	306	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
	307
	308	if (!location \|\| !relay_host \|\|
	309	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
	310	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
	311	goto end;
	312	}
	313
	314	*relay_host = location->types.relay.host;
	315	end:
	316	return status;
	317	}
	318
	319	enum lttng_trace_archive_location_status
	320	lttng_trace_archive_location_relay_get_relative_path(
	321	const struct lttng_trace_archive_location *location,
	322	const char **relative_path)
	323	{
	324	enum lttng_trace_archive_location_status status =
	325	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
	326
	327	if (!location \|\| !relative_path \|\|
	328	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
	329	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
330	goto end;
331	}
332
333	*relative_path = location->types.relay.relative_path;
334	end:
335	return status;
336	}
337
338	enum lttng_trace_archive_location_status
339	lttng_trace_archive_location_relay_get_control_port(
340	const struct lttng_trace_archive_location *location,
341	uint16_t *control_port)
342	{
343	enum lttng_trace_archive_location_status status =
344	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
345
346	if (!location \|\| !control_port \|\|
347	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
348	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
349	goto end;
350	}
351
352	*control_port = location->types.relay.ports.control;
353	end:
354	return status;
355	}
356
357	enum lttng_trace_archive_location_status
358	lttng_trace_archive_location_relay_get_data_port(
359	const struct lttng_trace_archive_location *location,
360	uint16_t *data_port)
361	{
362	enum lttng_trace_archive_location_status status =
363	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
364
365	if (!location \|\| !data_port \|\|
366	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
367	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
368	goto end;
369	}
370
371	*data_port = location->types.relay.ports.data;
372	end:
373	return status;
374	}
375
376	enum lttng_trace_archive_location_status
377	lttng_trace_archive_location_relay_get_protocol_type(
378	const struct lttng_trace_archive_location *location,
379	enum lttng_trace_archive_location_relay_protocol_type *protocol)
380	{
381	enum lttng_trace_archive_location_status status =
382	LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK;
383
384	if (!location \|\| !protocol \|\|
385	location->type != LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY) {
386	status = LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_INVALID;
387	goto end;
388	}
389
390	*protocol = location->types.relay.protocol;
391	end:
392	return status;
393	}