[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);
		if (attr->override_attr) {
			free(attr->override_attr->path_url);
			free(attr->override_attr->ctrl_url);
			free(attr->override_attr->data_url);
		}
		free(attr->override_attr);
		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) {
		attr->override_attr = zmalloc(sizeof(struct config_load_session_override_attr));
		if (!attr->override_attr) {
			/* FIXME: return valid error */
			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) {
		attr->override_attr = zmalloc(sizeof(struct config_load_session_override_attr));
		if (!attr->override_attr) {
			/* FIXME: return valid error */
			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) {
		attr->override_attr = zmalloc(sizeof(struct config_load_session_override_attr));
		if (!attr->override_attr) {
			/* FIXME: return valid error */
			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;
	}

	if (!attr->override_attr) {
		attr->override_attr = zmalloc(sizeof(struct config_load_session_override_attr));
		if (!attr->override_attr) {
			/* FIXME: return valid error */
			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,
			attr->override_attr);

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