[lttng-tools.git] / src / lib / lttng-ctl / load.c

/*
 * Copyright (C) 2014 - David Goulet <dgoulet@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
 */

#define _LGPL_SOURCE
#include <assert.h>
#include <string.h>
#include <limits.h>

#include <lttng/lttng-error.h>
#include <lttng/load.h>
#include <lttng/load-internal.h>
#include <common/sessiond-comm/sessiond-comm.h>
#include <common/config/session-config.h>
#include <common/uri.h>
#include <common/macros.h>

#include "lttng-ctl-helper.h"

struct lttng_load_session_attr *lttng_load_session_attr_create(void)
{
	return zmalloc(sizeof(struct lttng_load_session_attr));
}

void lttng_load_session_attr_destroy(struct lttng_load_session_attr *attr)
{
	if (attr) {
		free(attr->raw_override_url);
		free(attr->raw_override_path_url);
		free(attr->raw_override_ctrl_url);
		free(attr->raw_override_data_url);
		free(attr->override_attr.path_url);
		free(attr->override_attr.ctrl_url);
		free(attr->override_attr.data_url);
		free(attr);
	}
}

const char *lttng_load_session_attr_get_session_name(
	struct lttng_load_session_attr *attr)
{
	const char *ret = NULL;

	if (attr && attr->session_name[0]) {
		ret = attr->session_name;
	}

	return ret;
}

const char *lttng_load_session_attr_get_input_url(
	struct lttng_load_session_attr *attr)
{
	const char *ret = NULL;

	if (attr && attr->input_url[0]) {
		ret = attr->input_url;
	}

	return ret;
}

int lttng_load_session_attr_get_overwrite(
	struct lttng_load_session_attr *attr)
{
	return attr ? attr->overwrite : -LTTNG_ERR_INVALID;
}

const char *lttng_load_session_attr_get_override_path_url(
	struct lttng_load_session_attr *attr)
{
	const char *ret = NULL;

	if (attr && attr->override_attr.path_url) {
		ret = attr->raw_override_path_url;
	}

	return ret;
}

const char *lttng_load_session_attr_get_override_ctrl_url(
	struct lttng_load_session_attr *attr)
{
	const char *ret = NULL;

	if (attr && attr->override_attr.ctrl_url) {
		ret = attr->raw_override_ctrl_url;
	}

	return ret;
}

const char *lttng_load_session_attr_get_override_data_url(
	struct lttng_load_session_attr *attr)
{
	const char *ret = NULL;

	if (attr && attr->override_attr.data_url) {
		ret = attr->raw_override_data_url;
	}

	return ret;
}

const char *lttng_load_session_attr_get_override_url(
		struct lttng_load_session_attr *attr)
{
	const char *ret = NULL;

	if (attr && (attr->override_attr.path_url ||
		(attr->override_attr.ctrl_url &&
		 attr->override_attr.data_url))) {
		ret = attr->raw_override_url;
	}

	return ret;
}

int lttng_load_session_attr_set_session_name(
	struct lttng_load_session_attr *attr, const char *session_name)
{
	int ret = 0;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto error;
	}

	if (session_name) {
		size_t len;

		len = strlen(session_name);
		if (len >= LTTNG_NAME_MAX) {
			ret = -LTTNG_ERR_INVALID;
			goto error;
		}

		strncpy(attr->session_name, session_name, len);
	} else {
		attr->session_name[0] = '\0';
	}
error:
	return ret;
}

int lttng_load_session_attr_set_input_url(
	struct lttng_load_session_attr *attr, const char *url)
{
	int ret = 0;
	size_t len;
	ssize_t size;
	struct lttng_uri *uris = NULL;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto error;
	}

	if (!url) {
		attr->input_url[0] = '\0';
		ret = 0;
		goto end;
	}

	len = strlen(url);
	if (len >= PATH_MAX) {
		ret = -LTTNG_ERR_INVALID;
		goto error;
	}

	size = uri_parse_str_urls(url, NULL, &uris);
	if (size <= 0 || uris[0].dtype != LTTNG_DST_PATH) {
		ret = -LTTNG_ERR_INVALID;
		goto error;
	}

	/* Copy string plus the NULL terminated byte. */
	lttng_ctl_copy_string(attr->input_url, uris[0].dst.path,
			sizeof(attr->input_url));

end:
error:
	free(uris);
	return ret;
}

int lttng_load_session_attr_set_overwrite(
	struct lttng_load_session_attr *attr, int overwrite)
{
	int ret = 0;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	attr->overwrite = !!overwrite;
end:
	return ret;
}

int lttng_load_session_attr_set_override_path_url(
	struct lttng_load_session_attr *attr, const char *url)
{
	int ret = 0;
	ssize_t ret_size;
	struct lttng_uri *uri = NULL;
	char *url_str = NULL;
	char *raw_str = NULL;
	int tmp = 0;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	if (attr->override_attr.ctrl_url || attr->override_attr.data_url) {
		/*
		 * FIXME: return a more meaningful error.
		 * Setting a path override after a ctrl or data override make no
		 * sense and show that the user do not know what he is doing.
		 * */
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	/*
	 * FIXME: uri_parse should be able to take as parameter the protocol
	 * type to check validity with or the exclusion. For now only check on
	 * the parsing validity it will fail later on.
	 * */
	ret_size = uri_parse(url, &uri);
	if (ret_size != 1) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	/* Populate the internal override representation */
	url_str = zmalloc(PATH_MAX);
	if (!url_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	tmp = uri_to_str_url(&uri[0], url_str, PATH_MAX);
	if (tmp < 0) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	raw_str = strndup(url, PATH_MAX);
	if (!raw_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	/* Squash old value if any */
	free(attr->override_attr.path_url);
	free(attr->raw_override_path_url);

	/* Populate the object */
	attr->override_attr.path_url = url_str;
	attr->raw_override_path_url = raw_str;

	url_str = NULL;
	raw_str = NULL;
end:
	free(raw_str);
	free(url_str);
	free(uri);
	return ret;
}

int lttng_load_session_attr_set_override_ctrl_url(
	struct lttng_load_session_attr *attr, const char *url)
{
	int ret = 0;
	ssize_t ret_size;
	struct lttng_uri *uri = NULL;
	char *url_str = NULL;
	char *raw_str = NULL;
	int tmp = 0;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	if (attr->override_attr.path_url) {
		/*
		 * FIXME: return a more meaningful error.
		 * Setting a ctrl override after a path override make no
		 * sense and show that the user do not know what he is doing.
		 * */
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	/*
	 * FIXME: uri_parse should be able to take as parameter the protocol
	 * type to check validity with or the exclusion. For now only check on
	 * the parsing validity it will fail later on.
	 * */
	ret_size = uri_parse(url, &uri);
	if (ret_size < 0) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	if (uri[0].port == 0) {
		uri[0].port = DEFAULT_NETWORK_CONTROL_PORT;
	}

	url_str = zmalloc(PATH_MAX);
	if (!url_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	tmp = uri_to_str_url(&uri[0], url_str, PATH_MAX);
	if (tmp < 0) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	raw_str = strndup(url, PATH_MAX);
	if (!raw_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	/* Squash old value if any */
	free(attr->override_attr.ctrl_url);
	free(attr->raw_override_ctrl_url);

	/* Populate the object */
	attr->override_attr.ctrl_url = url_str;
	attr->raw_override_ctrl_url = raw_str;

	url_str = NULL;
	raw_str = NULL;

end:
	free(raw_str);
	free(url_str);
	free(uri);
	return ret;
}

int lttng_load_session_attr_set_override_data_url(
	struct lttng_load_session_attr *attr, const char *url)
{
	int ret = 0;
	ssize_t ret_size;
	struct lttng_uri *uri = NULL;
	char *url_str = NULL;
	char *raw_str = NULL;
	int tmp = 0;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	if (attr->override_attr.path_url) {
		/*
		 * FIXME: return a more meaningful error.
		 * Setting a data override after a path override make no
		 * sense and show that the user do not know what he is doing.
		 * */
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	/*
	 * FIXME: uri_parse should be able to take as parameter the protocol
	 * type to check validity with or the exclusion. For now only check on
	 * the parsing validity it will fail later on.
	 * */
	ret_size = uri_parse(url, &uri);
	if (ret_size < 0) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	if (uri[0].port == 0) {
		uri[0].port = DEFAULT_NETWORK_DATA_PORT;
	}

	url_str = zmalloc(PATH_MAX);
	if (!url_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	tmp = uri_to_str_url(&uri[0], url_str, PATH_MAX);
	if (tmp < 0) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	raw_str = strndup(url, PATH_MAX);
	if (!raw_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	/* Squash old value if any */
	free(attr->override_attr.data_url);
	free(attr->raw_override_data_url);

	/* Populate the object */
	attr->override_attr.data_url = url_str;
	attr->raw_override_data_url = raw_str;

	url_str = NULL;
	raw_str = NULL;
end:
	free(raw_str);
	free(url_str);
	free(uri);
	return ret;
}

int lttng_load_session_attr_set_override_url(
		struct lttng_load_session_attr *attr, const char *url)
{
	int ret = 0;
	ssize_t ret_size;
	struct lttng_uri *uri = NULL;
	char *raw_url_str = NULL;
	char *raw_path_str = NULL;
	char *path_str = NULL;
	char *raw_ctrl_str = NULL;
	char *ctrl_str = NULL;
	char *raw_data_str = NULL;
	char *data_str = NULL;
	char buffer[PATH_MAX];
	int tmp = 0;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}


	/*
	 * FIXME: uri_parse should be able to take as parameter the protocol
	 * type to check validity with or the exclusion. For now only check on
	 * the parsing validity it will fail later on.
	 * */
	ret_size = uri_parse_str_urls(url, NULL, &uri);
	if (ret_size < 0 || ret_size > 2) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	raw_url_str = strndup(url, PATH_MAX);
	if (!raw_url_str) {
		/* FIXME: return valid error */
		ret = LTTNG_ERR_INVALID;
		goto end;
	}

	/* Fetch path | ctrl && data string url */
	tmp = uri_to_str_url(&uri[0], buffer, sizeof(buffer));
	if (tmp < 0) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	switch (uri[0].dtype) {
	case LTTNG_DST_PATH:
		raw_path_str = strndup(buffer, PATH_MAX);
		if (!raw_path_str) {
			/* FIXME: return valid error */
			ret = LTTNG_ERR_INVALID;
			goto end;
		}

		path_str = strndup(raw_path_str, PATH_MAX);
		if (!path_str) {
			/* FIXME: return valid error */
			ret = LTTNG_ERR_INVALID;
			goto end;
		}
		break;
	case LTTNG_DST_IPV4:
	case LTTNG_DST_IPV6:
		if (ret_size != 2) {
			ret = -LTTNG_ERR_INVALID;
			goto end;
		}

		raw_ctrl_str = strndup(buffer, PATH_MAX);
		if (!raw_ctrl_str) {
			/* FIXME: return valid error */
			ret = LTTNG_ERR_INVALID;
			goto end;
		}

		ctrl_str = strndup(raw_ctrl_str, PATH_MAX);
		if (!ctrl_str) {
			/* FIXME: return valid error */
			ret = LTTNG_ERR_INVALID;
			goto end;
		}

		/* Fetch the data uri */
		tmp = uri_to_str_url(&uri[1], buffer, sizeof(buffer));
		if (tmp < 0) {
			ret = -LTTNG_ERR_INVALID;
			goto end;
		}

		raw_data_str = strndup(buffer, PATH_MAX);
		if (!raw_data_str) {
			/* FIXME: return valid error */
			ret = LTTNG_ERR_INVALID;
			goto end;
		}

		data_str = strndup(raw_data_str, PATH_MAX);
		if (!data_str) {
			/* FIXME: return valid error */
			ret = LTTNG_ERR_INVALID;
			goto end;
		}

		break;
	default:
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	free(attr->override_attr.path_url);
	free(attr->override_attr.ctrl_url);
	free(attr->override_attr.data_url);
	free(attr->raw_override_url);
	free(attr->raw_override_path_url);
	free(attr->raw_override_ctrl_url);
	free(attr->raw_override_data_url);

	attr->override_attr.path_url = path_str;
	attr->override_attr.ctrl_url = ctrl_str;
	attr->override_attr.data_url = data_str;

	attr->raw_override_url = raw_url_str;
	attr->raw_override_path_url = raw_path_str;
	attr->raw_override_ctrl_url = raw_ctrl_str;
	attr->raw_override_data_url = raw_data_str;

	/* Pass data responsability to the struct */
	raw_url_str = NULL;
	raw_path_str = NULL;
	path_str = NULL;
	raw_ctrl_str = NULL;
	ctrl_str = NULL;
	raw_data_str = NULL;
	data_str = NULL;

end:
	free(raw_path_str);
	free(path_str);
	free(raw_ctrl_str);
	free(ctrl_str);
	free(raw_data_str);
	free(data_str);
	free(raw_url_str);
	free(uri);
	return ret;
}
/*
 * The lttng-ctl API does not expose all the information needed to load the
 * session configurations. Thus, we must send a load command to the session
 * daemon which will, in turn, load its current session configuration.
 */
int lttng_load_session(struct lttng_load_session_attr *attr)
{
	int ret;
	const char *url, *session_name;

	if (!attr) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	url = attr->input_url[0] != '\0' ? attr->input_url : NULL;
	session_name = attr->session_name[0] != '\0' ?
			attr->session_name : NULL;

	ret = config_load_session(url, session_name, attr->overwrite, 0);

end:
	return ret;
}
Commit	Line	Data
9245bd0e DG	1	/*
	2	* Copyright (C) 2014 - David Goulet <dgoulet@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
6c1c0768	18	#define _LGPL_SOURCE
9245bd0e DG	19	#include <assert.h>
9245bd0e DG	20	#include <string.h>
96607445	21	#include <limits.h>
9245bd0e DG	22
	23	#include <lttng/lttng-error.h>
	24	#include <lttng/load.h>
	25	#include <lttng/load-internal.h>
	26	#include <common/sessiond-comm/sessiond-comm.h>
f40ef1d5	27	#include <common/config/session-config.h>
96607445 JR	28	#include <common/uri.h>
96607445 JR	29	#include <common/macros.h>
9245bd0e DG	30
	31	#include "lttng-ctl-helper.h"
	32
	33	struct lttng_load_session_attr *lttng_load_session_attr_create(void)
	34	{
	35	return zmalloc(sizeof(struct lttng_load_session_attr));
	36	}
	37
	38	void lttng_load_session_attr_destroy(struct lttng_load_session_attr *attr)
	39	{
	40	if (attr) {
96607445 JR	41	free(attr->raw_override_url);
	42	free(attr->raw_override_path_url);
	43	free(attr->raw_override_ctrl_url);
	44	free(attr->raw_override_data_url);
	45	free(attr->override_attr.path_url);
	46	free(attr->override_attr.ctrl_url);
	47	free(attr->override_attr.data_url);
9245bd0e DG	48	free(attr);
	49	}
	50	}
	51
	52	const char *lttng_load_session_attr_get_session_name(
	53	struct lttng_load_session_attr *attr)
	54	{
	55	const char *ret = NULL;
	56
	57	if (attr && attr->session_name[0]) {
	58	ret = attr->session_name;
	59	}
	60
	61	return ret;
	62	}
	63
	64	const char *lttng_load_session_attr_get_input_url(
	65	struct lttng_load_session_attr *attr)
	66	{
	67	const char *ret = NULL;
	68
	69	if (attr && attr->input_url[0]) {
	70	ret = attr->input_url;
	71	}
	72
	73	return ret;
	74	}
	75
	76	int lttng_load_session_attr_get_overwrite(
	77	struct lttng_load_session_attr *attr)
	78	{
	79	return attr ? attr->overwrite : -LTTNG_ERR_INVALID;
	80	}
	81
96607445 JR	82	const char *lttng_load_session_attr_get_override_path_url(
	83	struct lttng_load_session_attr *attr)
	84	{
	85	const char *ret = NULL;
	86
	87	if (attr && attr->override_attr.path_url) {
	88	ret = attr->raw_override_path_url;
	89	}
	90
	91	return ret;
	92	}
	93
	94	const char *lttng_load_session_attr_get_override_ctrl_url(
	95	struct lttng_load_session_attr *attr)
	96	{
	97	const char *ret = NULL;
	98
	99	if (attr && attr->override_attr.ctrl_url) {
	100	ret = attr->raw_override_ctrl_url;
	101	}
	102
	103	return ret;
	104	}
	105
	106	const char *lttng_load_session_attr_get_override_data_url(
	107	struct lttng_load_session_attr *attr)
	108	{
	109	const char *ret = NULL;
	110
	111	if (attr && attr->override_attr.data_url) {
	112	ret = attr->raw_override_data_url;
	113	}
	114
	115	return ret;
	116	}
	117
	118	const char *lttng_load_session_attr_get_override_url(
	119	struct lttng_load_session_attr *attr)
	120	{
	121	const char *ret = NULL;
	122
	123	if (attr && (attr->override_attr.path_url \|\|
	124	(attr->override_attr.ctrl_url &&
	125	attr->override_attr.data_url))) {
	126	ret = attr->raw_override_url;
	127	}
	128
	129	return ret;
	130	}
	131
9245bd0e DG	132	int lttng_load_session_attr_set_session_name(
	133	struct lttng_load_session_attr attr, const char session_name)
	134	{
	135	int ret = 0;
	136
	137	if (!attr) {
	138	ret = -LTTNG_ERR_INVALID;
	139	goto error;
	140	}
	141
	142	if (session_name) {
	143	size_t len;
	144
	145	len = strlen(session_name);
36d2e35d	146	if (len >= LTTNG_NAME_MAX) {
9245bd0e DG	147	ret = -LTTNG_ERR_INVALID;
	148	goto error;
	149	}
	150
	151	strncpy(attr->session_name, session_name, len);
	152	} else {
	153	attr->session_name[0] = '\0';
	154	}
	155	error:
	156	return ret;
	157	}
	158
	159	int lttng_load_session_attr_set_input_url(
	160	struct lttng_load_session_attr attr, const char url)
	161	{
	162	int ret = 0;
a2113b79 JR	163	size_t len;
a2113b79 JR	164	ssize_t size;
9245bd0e DG	165	struct lttng_uri *uris = NULL;
	166
	167	if (!attr) {
	168	ret = -LTTNG_ERR_INVALID;
	169	goto error;
	170	}
	171
	172	if (!url) {
	173	attr->input_url[0] = '\0';
	174	ret = 0;
	175	goto end;
	176	}
	177
	178	len = strlen(url);
	179	if (len >= PATH_MAX) {
	180	ret = -LTTNG_ERR_INVALID;
	181	goto error;
	182	}
	183
	184	size = uri_parse_str_urls(url, NULL, &uris);
	185	if (size <= 0 \|\| uris[0].dtype != LTTNG_DST_PATH) {
	186	ret = -LTTNG_ERR_INVALID;
	187	goto error;
	188	}
	189
	190	/* Copy string plus the NULL terminated byte. */
	191	lttng_ctl_copy_string(attr->input_url, uris[0].dst.path,
	192	sizeof(attr->input_url));
	193
	194	end:
	195	error:
	196	free(uris);
	197	return ret;
	198	}
	199
	200	int lttng_load_session_attr_set_overwrite(
	201	struct lttng_load_session_attr *attr, int overwrite)
	202	{
	203	int ret = 0;
	204
	205	if (!attr) {
	206	ret = -LTTNG_ERR_INVALID;
	207	goto end;
	208	}
	209
	210	attr->overwrite = !!overwrite;
	211	end:
	212	return ret;
	213	}
	214
96607445 JR	215	int lttng_load_session_attr_set_override_path_url(
	216	struct lttng_load_session_attr attr, const char url)
	217	{
	218	int ret = 0;
	219	ssize_t ret_size;
	220	struct lttng_uri *uri = NULL;
	221	char *url_str = NULL;
	222	char *raw_str = NULL;
	223	int tmp = 0;
	224
	225	if (!attr) {
	226	ret = -LTTNG_ERR_INVALID;
	227	goto end;
	228	}
	229
	230	if (attr->override_attr.ctrl_url \|\| attr->override_attr.data_url) {
	231	/*
	232	* FIXME: return a more meaningful error.
	233	* Setting a path override after a ctrl or data override make no
	234	* sense and show that the user do not know what he is doing.
	235	* */
	236	ret = -LTTNG_ERR_INVALID;
	237	goto end;
	238	}
	239
	240	/*
	241	* FIXME: uri_parse should be able to take as parameter the protocol
	242	* type to check validity with or the exclusion. For now only check on
	243	* the parsing validity it will fail later on.
	244	* */
	245	ret_size = uri_parse(url, &uri);
	246	if (ret_size != 1) {
	247	ret = -LTTNG_ERR_INVALID;
	248	goto end;
	249	}
	250
	251	/* Populate the internal override representation */
	252	url_str = zmalloc(PATH_MAX);
	253	if (!url_str) {
	254	/* FIXME: return valid error */
	255	ret = LTTNG_ERR_INVALID;
	256	goto end;
	257	}
	258
	259	tmp = uri_to_str_url(&uri[0], url_str, PATH_MAX);
	260	if (tmp < 0) {
	261	ret = -LTTNG_ERR_INVALID;
	262	goto end;
	263	}
	264
	265	raw_str = strndup(url, PATH_MAX);
	266	if (!raw_str) {
	267	/* FIXME: return valid error */
	268	ret = LTTNG_ERR_INVALID;
	269	goto end;
	270	}
	271
	272	/* Squash old value if any */
	273	free(attr->override_attr.path_url);
	274	free(attr->raw_override_path_url);
	275
	276	/* Populate the object */
	277	attr->override_attr.path_url = url_str;
	278	attr->raw_override_path_url = raw_str;
279
280	url_str = NULL;
281	raw_str = NULL;
282	end:
283	free(raw_str);
284	free(url_str);
285	free(uri);
286	return ret;
287	}
288
289	int lttng_load_session_attr_set_override_ctrl_url(
290	struct lttng_load_session_attr attr, const char url)
291	{
292	int ret = 0;
293	ssize_t ret_size;
294	struct lttng_uri *uri = NULL;
295	char *url_str = NULL;
296	char *raw_str = NULL;
297	int tmp = 0;
298
299	if (!attr) {
300	ret = -LTTNG_ERR_INVALID;
301	goto end;
302	}
303
304	if (attr->override_attr.path_url) {
305	/*
306	* FIXME: return a more meaningful error.
307	* Setting a ctrl override after a path override make no
308	* sense and show that the user do not know what he is doing.
309	* */
310	ret = -LTTNG_ERR_INVALID;
311	goto end;
312	}
313
314	/*
315	* FIXME: uri_parse should be able to take as parameter the protocol
316	* type to check validity with or the exclusion. For now only check on
317	* the parsing validity it will fail later on.
318	* */
319	ret_size = uri_parse(url, &uri);
320	if (ret_size < 0) {
321	ret = -LTTNG_ERR_INVALID;
322	goto end;
323	}
324
325	if (uri[0].port == 0) {
326	uri[0].port = DEFAULT_NETWORK_CONTROL_PORT;
327	}
328
329	url_str = zmalloc(PATH_MAX);
330	if (!url_str) {
331	/* FIXME: return valid error */
332	ret = LTTNG_ERR_INVALID;
333	goto end;
334	}
335
336	tmp = uri_to_str_url(&uri[0], url_str, PATH_MAX);
337	if (tmp < 0) {
338	ret = -LTTNG_ERR_INVALID;
339	goto end;
340	}
341
342	raw_str = strndup(url, PATH_MAX);
343	if (!raw_str) {
344	/* FIXME: return valid error */
345	ret = LTTNG_ERR_INVALID;
346	goto end;
347	}
348
349	/* Squash old value if any */
350	free(attr->override_attr.ctrl_url);
351	free(attr->raw_override_ctrl_url);
352
353	/* Populate the object */
354	attr->override_attr.ctrl_url = url_str;
355	attr->raw_override_ctrl_url = raw_str;
356
357	url_str = NULL;
358	raw_str = NULL;
359
360	end:
361	free(raw_str);
362	free(url_str);
363	free(uri);
364	return ret;
365	}
366
367	int lttng_load_session_attr_set_override_data_url(
368	struct lttng_load_session_attr attr, const char url)
369	{
370	int ret = 0;
371	ssize_t ret_size;
372	struct lttng_uri *uri = NULL;
373	char *url_str = NULL;
374	char *raw_str = NULL;
375	int tmp = 0;
376
377	if (!attr) {
378	ret = -LTTNG_ERR_INVALID;
379	goto end;
380	}
381
382	if (attr->override_attr.path_url) {
383	/*
384	* FIXME: return a more meaningful error.
385	* Setting a data override after a path override make no
386	* sense and show that the user do not know what he is doing.
387	* */
388	ret = -LTTNG_ERR_INVALID;
389	goto end;
390	}
391
392	/*
393	* FIXME: uri_parse should be able to take as parameter the protocol
394	* type to check validity with or the exclusion. For now only check on
395	* the parsing validity it will fail later on.
396	* */
397	ret_size = uri_parse(url, &uri);
398	if (ret_size < 0) {
399	ret = -LTTNG_ERR_INVALID;
400	goto end;
401	}
402
403	if (uri[0].port == 0) {
404	uri[0].port = DEFAULT_NETWORK_DATA_PORT;
405	}
406
407	url_str = zmalloc(PATH_MAX);
408	if (!url_str) {
409	/* FIXME: return valid error */
410	ret = LTTNG_ERR_INVALID;
411	goto end;
412	}
413
414	tmp = uri_to_str_url(&uri[0], url_str, PATH_MAX);
415	if (tmp < 0) {
416	ret = -LTTNG_ERR_INVALID;
417	goto end;
418	}
419
420	raw_str = strndup(url, PATH_MAX);
421	if (!raw_str) {
422	/* FIXME: return valid error */
423	ret = LTTNG_ERR_INVALID;
424	goto end;
425	}
426
427	/* Squash old value if any */
428	free(attr->override_attr.data_url);
429	free(attr->raw_override_data_url);
430
431	/* Populate the object */
432	attr->override_attr.data_url = url_str;
433	attr->raw_override_data_url = raw_str;
434
435	url_str = NULL;
436	raw_str = NULL;
437	end:
438	free(raw_str);
439	free(url_str);
440	free(uri);
441	return ret;
442	}
443
444	int lttng_load_session_attr_set_override_url(
445	struct lttng_load_session_attr attr, const char url)
446	{
447	int ret = 0;
448	ssize_t ret_size;
449	struct lttng_uri *uri = NULL;
450	char *raw_url_str = NULL;
451	char *raw_path_str = NULL;
452	char *path_str = NULL;
453	char *raw_ctrl_str = NULL;
454	char *ctrl_str = NULL;
455	char *raw_data_str = NULL;
456	char *data_str = NULL;
457	char buffer[PATH_MAX];
458	int tmp = 0;
459
460	if (!attr) {
461	ret = -LTTNG_ERR_INVALID;
462	goto end;
463	}
464
465
466	/*
467	* FIXME: uri_parse should be able to take as parameter the protocol
468	* type to check validity with or the exclusion. For now only check on
469	* the parsing validity it will fail later on.
470	* */
471	ret_size = uri_parse_str_urls(url, NULL, &uri);
472	if (ret_size < 0 \|\| ret_size > 2) {
473	ret = -LTTNG_ERR_INVALID;
474	goto end;
475	}
476
477	raw_url_str = strndup(url, PATH_MAX);
478	if (!raw_url_str) {
479	/* FIXME: return valid error */
480	ret = LTTNG_ERR_INVALID;
481	goto end;
482	}
483
484	/* Fetch path \| ctrl && data string url */
485	tmp = uri_to_str_url(&uri[0], buffer, sizeof(buffer));
486	if (tmp < 0) {
487	ret = -LTTNG_ERR_INVALID;
488	goto end;
489	}
490
491	switch (uri[0].dtype) {
492	case LTTNG_DST_PATH:
493	raw_path_str = strndup(buffer, PATH_MAX);
494	if (!raw_path_str) {
495	/* FIXME: return valid error */
496	ret = LTTNG_ERR_INVALID;
497	goto end;
498	}
499
500	path_str = strndup(raw_path_str, PATH_MAX);
501	if (!path_str) {
502	/* FIXME: return valid error */
503	ret = LTTNG_ERR_INVALID;
504	goto end;
505	}
506	break;
507	case LTTNG_DST_IPV4:
508	case LTTNG_DST_IPV6:
509	if (ret_size != 2) {
510	ret = -LTTNG_ERR_INVALID;
511	goto end;
512	}
513
514	raw_ctrl_str = strndup(buffer, PATH_MAX);
515	if (!raw_ctrl_str) {
516	/* FIXME: return valid error */
517	ret = LTTNG_ERR_INVALID;
518	goto end;
519	}
520
521	ctrl_str = strndup(raw_ctrl_str, PATH_MAX);
522	if (!ctrl_str) {
523	/* FIXME: return valid error */
524	ret = LTTNG_ERR_INVALID;
525	goto end;
526	}
527
528	/* Fetch the data uri */
529	tmp = uri_to_str_url(&uri[1], buffer, sizeof(buffer));
530	if (tmp < 0) {
531	ret = -LTTNG_ERR_INVALID;
532	goto end;
533	}
534
535	raw_data_str = strndup(buffer, PATH_MAX);
536	if (!raw_data_str) {
537	/* FIXME: return valid error */
538	ret = LTTNG_ERR_INVALID;
539	goto end;
540	}
541
542	data_str = strndup(raw_data_str, PATH_MAX);
543	if (!data_str) {
544	/* FIXME: return valid error */
545	ret = LTTNG_ERR_INVALID;
546	goto end;
547	}
548
549	break;
550	default:
551	ret = -LTTNG_ERR_INVALID;
552	goto end;
553	}
554
555	free(attr->override_attr.path_url);
556	free(attr->override_attr.ctrl_url);
557	free(attr->override_attr.data_url);
558	free(attr->raw_override_url);
559	free(attr->raw_override_path_url);
560	free(attr->raw_override_ctrl_url);
561	free(attr->raw_override_data_url);
562
563	attr->override_attr.path_url = path_str;
564	attr->override_attr.ctrl_url = ctrl_str;
565	attr->override_attr.data_url = data_str;
566
567	attr->raw_override_url = raw_url_str;
568	attr->raw_override_path_url = raw_path_str;
569	attr->raw_override_ctrl_url = raw_ctrl_str;
570	attr->raw_override_data_url = raw_data_str;
571
572	/* Pass data responsability to the struct */
573	raw_url_str = NULL;
574	raw_path_str = NULL;
575	path_str = NULL;
576	raw_ctrl_str = NULL;
577	ctrl_str = NULL;
578	raw_data_str = NULL;
579	data_str = NULL;
580
581	end:
582	free(raw_path_str);
583	free(path_str);
584	free(raw_ctrl_str);
585	free(ctrl_str);
586	free(raw_data_str);
587	free(data_str);
588	free(raw_url_str);
589	free(uri);
590	return ret;
591	}
9245bd0e DG	592	/*
	593	* The lttng-ctl API does not expose all the information needed to load the
	594	* session configurations. Thus, we must send a load command to the session
	595	* daemon which will, in turn, load its current session configuration.
	596	*/
	597	int lttng_load_session(struct lttng_load_session_attr *attr)
	598	{
	599	int ret;
18e29540	600	const char url, session_name;
9245bd0e DG	601
	602	if (!attr) {
	603	ret = -LTTNG_ERR_INVALID;
	604	goto end;
	605	}
	606
18e29540 JG	607	url = attr->input_url[0] != '\0' ? attr->input_url : NULL;
	608	session_name = attr->session_name[0] != '\0' ?
	609	attr->session_name : NULL;
	610
	611	ret = config_load_session(url, session_name, attr->overwrite, 0);
9245bd0e DG	612
	613	end:
	614	return ret;
	615	}