2 * Copyright (C) 2014 - David Goulet <dgoulet@efficios.com>
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.
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
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
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>
27 #include <common/config/session-config.h>
28 #include <common/uri.h>
29 #include <common/macros.h>
30 #include <common/compat/string.h>
32 #include "lttng-ctl-helper.h"
34 struct lttng_load_session_attr
*lttng_load_session_attr_create(void)
36 return zmalloc(sizeof(struct lttng_load_session_attr
));
40 void reset_load_session_attr_urls(struct lttng_load_session_attr
*attr
)
42 free(attr
->raw_override_url
);
43 free(attr
->raw_override_path_url
);
44 free(attr
->raw_override_ctrl_url
);
45 free(attr
->raw_override_data_url
);
46 if (attr
->override_attr
) {
47 free(attr
->override_attr
->path_url
);
48 free(attr
->override_attr
->ctrl_url
);
49 free(attr
->override_attr
->data_url
);
50 free(attr
->override_attr
->session_name
);
54 void lttng_load_session_attr_destroy(struct lttng_load_session_attr
*attr
)
57 reset_load_session_attr_urls(attr
);
58 free(attr
->override_attr
);
63 static int validate_attr(const struct lttng_load_session_attr
*attr
)
68 ret
= -LTTNG_ERR_INVALID
;
72 if (!attr
->override_attr
) {
77 * Refuse override name if the objective is to load multiple session
78 * since this operation is ambiguous while loading multiple session.
80 if (attr
->override_attr
->session_name
81 && attr
->session_name
[0] == '\0') {
82 ret
= -LTTNG_ERR_INVALID
;
89 const char *lttng_load_session_attr_get_session_name(
90 struct lttng_load_session_attr
*attr
)
92 const char *ret
= NULL
;
94 if (attr
&& attr
->session_name
[0]) {
95 ret
= attr
->session_name
;
101 const char *lttng_load_session_attr_get_input_url(
102 struct lttng_load_session_attr
*attr
)
104 const char *ret
= NULL
;
106 if (attr
&& attr
->input_url
[0]) {
107 ret
= attr
->input_url
;
113 int lttng_load_session_attr_get_overwrite(
114 struct lttng_load_session_attr
*attr
)
116 return attr
? attr
->overwrite
: -LTTNG_ERR_INVALID
;
119 const char *lttng_load_session_attr_get_override_ctrl_url(
120 struct lttng_load_session_attr
*attr
)
122 const char *ret
= NULL
;
124 if (!attr
|| !attr
->override_attr
) {
128 ret
= attr
->raw_override_ctrl_url
;
133 const char *lttng_load_session_attr_get_override_data_url(
134 struct lttng_load_session_attr
*attr
)
136 const char *ret
= NULL
;
138 if (!attr
|| !attr
->override_attr
) {
142 ret
= attr
->raw_override_data_url
;
147 const char *lttng_load_session_attr_get_override_url(
148 struct lttng_load_session_attr
*attr
)
150 const char *ret
= NULL
;
152 if (!attr
|| !attr
->override_attr
) {
156 if ((attr
->override_attr
->path_url
||
157 (attr
->override_attr
->ctrl_url
&&
158 attr
->override_attr
->data_url
))) {
159 ret
= attr
->raw_override_url
;
165 const char *lttng_load_session_attr_get_override_session_name(
166 struct lttng_load_session_attr
*attr
)
168 const char *ret
= NULL
;
170 if (!attr
|| !attr
->override_attr
) {
174 ret
= attr
->override_attr
->session_name
;
179 int lttng_load_session_attr_set_session_name(
180 struct lttng_load_session_attr
*attr
, const char *session_name
)
185 ret
= -LTTNG_ERR_INVALID
;
192 len
= strlen(session_name
);
193 if (len
>= LTTNG_NAME_MAX
) {
194 ret
= -LTTNG_ERR_INVALID
;
198 ret
= lttng_strncpy(attr
->session_name
, session_name
,
199 sizeof(attr
->session_name
));
201 ret
= -LTTNG_ERR_INVALID
;
205 attr
->session_name
[0] = '\0';
211 int lttng_load_session_attr_set_input_url(
212 struct lttng_load_session_attr
*attr
, const char *url
)
217 struct lttng_uri
*uris
= NULL
;
220 ret
= -LTTNG_ERR_INVALID
;
225 attr
->input_url
[0] = '\0';
231 if (len
>= PATH_MAX
) {
232 ret
= -LTTNG_ERR_INVALID
;
236 size
= uri_parse_str_urls(url
, NULL
, &uris
);
237 if (size
<= 0 || uris
[0].dtype
!= LTTNG_DST_PATH
) {
238 ret
= -LTTNG_ERR_INVALID
;
242 /* Copy string plus the NULL terminated byte. */
243 ret
= lttng_strncpy(attr
->input_url
, uris
[0].dst
.path
,
244 sizeof(attr
->input_url
));
246 ret
= -LTTNG_ERR_INVALID
;
256 int lttng_load_session_attr_set_overwrite(
257 struct lttng_load_session_attr
*attr
, int overwrite
)
262 ret
= -LTTNG_ERR_INVALID
;
266 attr
->overwrite
= !!overwrite
;
271 int lttng_load_session_attr_set_override_ctrl_url(
272 struct lttng_load_session_attr
*attr
, const char *url
)
276 struct lttng_uri
*uri
= NULL
;
277 char *url_str
= NULL
;
278 char *raw_str
= NULL
;
281 ret
= -LTTNG_ERR_INVALID
;
285 if (!attr
->override_attr
) {
286 attr
->override_attr
= zmalloc(
287 sizeof(struct config_load_session_override_attr
));
288 if (!attr
->override_attr
) {
289 ret
= -LTTNG_ERR_NOMEM
;
294 if (attr
->override_attr
->path_url
) {
296 * Setting a ctrl override after a path override makes no sense.
298 ret
= -LTTNG_ERR_INVALID
;
303 * FIXME: uri_parse should be able to take as parameter the protocol
304 * type to validate "url". For now only check the parsing goes through;
305 * it will fail later on.
307 ret_size
= uri_parse(url
, &uri
);
309 ret
= -LTTNG_ERR_INVALID
;
313 if (uri
[0].port
== 0) {
314 uri
[0].port
= DEFAULT_NETWORK_CONTROL_PORT
;
317 url_str
= zmalloc(PATH_MAX
);
319 /* FIXME: return valid error */
320 ret
= -LTTNG_ERR_NOMEM
;
324 ret
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
326 ret
= -LTTNG_ERR_INVALID
;
331 raw_str
= lttng_strndup(url
, PATH_MAX
);
333 ret
= -LTTNG_ERR_NOMEM
;
337 /* Squash old value if any */
338 free(attr
->override_attr
->ctrl_url
);
339 free(attr
->raw_override_ctrl_url
);
341 /* Populate the object */
342 attr
->override_attr
->ctrl_url
= url_str
;
343 attr
->raw_override_ctrl_url
= raw_str
;
345 /* Ownership passed to attr. */
356 int lttng_load_session_attr_set_override_data_url(
357 struct lttng_load_session_attr
*attr
, const char *url
)
361 struct lttng_uri
*uri
= NULL
;
362 char *url_str
= NULL
;
363 char *raw_str
= NULL
;
366 ret
= -LTTNG_ERR_INVALID
;
370 if (!attr
->override_attr
) {
371 attr
->override_attr
= zmalloc(
372 sizeof(struct config_load_session_override_attr
));
373 if (!attr
->override_attr
) {
374 ret
= -LTTNG_ERR_NOMEM
;
379 if (attr
->override_attr
->path_url
) {
381 * Setting a data override after a path override makes no sense.
383 ret
= -LTTNG_ERR_INVALID
;
388 * FIXME: uri_parse should be able to take as parameter the protocol
389 * type to validate "url". For now only check the parsing goes through;
390 * it will fail later on.
392 ret_size
= uri_parse(url
, &uri
);
394 ret
= -LTTNG_ERR_INVALID
;
398 if (uri
[0].port
== 0) {
399 uri
[0].port
= DEFAULT_NETWORK_DATA_PORT
;
402 url_str
= zmalloc(PATH_MAX
);
404 ret
= -LTTNG_ERR_NOMEM
;
408 ret
= uri_to_str_url(&uri
[0], url_str
, PATH_MAX
);
410 ret
= -LTTNG_ERR_INVALID
;
415 raw_str
= lttng_strndup(url
, PATH_MAX
);
417 ret
= -LTTNG_ERR_NOMEM
;
421 /* Squash old value if any */
422 free(attr
->override_attr
->data_url
);
423 free(attr
->raw_override_data_url
);
425 /* Populate the object */
426 attr
->override_attr
->data_url
= url_str
;
427 attr
->raw_override_data_url
= raw_str
;
429 /* Ownership passed to attr. */
439 int lttng_load_session_attr_set_override_url(
440 struct lttng_load_session_attr
*attr
, const char *url
)
444 struct lttng_uri
*uri
= NULL
;
445 char *raw_url_str
= NULL
;
446 char *raw_path_str
= NULL
;
447 char *path_str
= NULL
;
448 char *raw_ctrl_str
= NULL
;
449 char *ctrl_str
= NULL
;
450 char *raw_data_str
= NULL
;
451 char *data_str
= NULL
;
452 char buffer
[PATH_MAX
];
454 if (!attr
|| !url
|| strlen(url
) >= PATH_MAX
) {
455 ret
= -LTTNG_ERR_INVALID
;
459 if (!attr
->override_attr
) {
460 attr
->override_attr
= zmalloc(
461 sizeof(struct config_load_session_override_attr
));
462 if (!attr
->override_attr
) {
463 ret
= -LTTNG_ERR_NOMEM
;
469 * FIXME: uri_parse should be able to take as parameter the protocol
470 * type to validate "url". For now only check the parsing goes through;
471 * it will fail later on.
473 ret_size
= uri_parse_str_urls(url
, NULL
, &uri
);
474 if (ret_size
< 0 || ret_size
> 2) {
475 /* Unexpected URL format. */
476 ret
= -LTTNG_ERR_INVALID
;
480 raw_url_str
= lttng_strndup(url
, PATH_MAX
);
482 ret
= -LTTNG_ERR_NOMEM
;
486 /* Get path | ctrl && data string URL. */
487 ret
= uri_to_str_url(&uri
[0], buffer
, sizeof(buffer
));
488 if (ret
< 0 || ret
>= PATH_MAX
) {
489 ret
= -LTTNG_ERR_INVALID
;
494 switch (uri
[0].dtype
) {
496 raw_path_str
= lttng_strndup(buffer
, PATH_MAX
);
498 ret
= -LTTNG_ERR_NOMEM
;
502 path_str
= lttng_strndup(raw_path_str
, PATH_MAX
);
504 ret
= -LTTNG_ERR_NOMEM
;
511 ret
= -LTTNG_ERR_INVALID
;
515 raw_ctrl_str
= lttng_strndup(buffer
, PATH_MAX
);
517 ret
= -LTTNG_ERR_NOMEM
;
521 ctrl_str
= lttng_strndup(raw_ctrl_str
, PATH_MAX
);
523 ret
= -LTTNG_ERR_NOMEM
;
527 /* Get the data uri. */
528 ret
= uri_to_str_url(&uri
[1], buffer
, sizeof(buffer
));
530 ret
= -LTTNG_ERR_INVALID
;
535 raw_data_str
= lttng_strndup(buffer
, PATH_MAX
);
537 ret
= -LTTNG_ERR_NOMEM
;
541 data_str
= lttng_strndup(raw_data_str
, PATH_MAX
);
543 ret
= -LTTNG_ERR_NOMEM
;
549 ret
= -LTTNG_ERR_INVALID
;
553 reset_load_session_attr_urls(attr
);
555 attr
->override_attr
->path_url
= path_str
;
556 attr
->override_attr
->ctrl_url
= ctrl_str
;
557 attr
->override_attr
->data_url
= data_str
;
559 attr
->raw_override_url
= raw_url_str
;
560 attr
->raw_override_path_url
= raw_path_str
;
561 attr
->raw_override_ctrl_url
= raw_ctrl_str
;
562 attr
->raw_override_data_url
= raw_data_str
;
564 /* Pass data ownership to attr. */
585 int lttng_load_session_attr_set_override_session_name(
586 struct lttng_load_session_attr
*attr
, const char *session_name
)
591 if (!attr
||!session_name
) {
592 ret
= -LTTNG_ERR_INVALID
;
596 if (!attr
->override_attr
) {
597 attr
->override_attr
= zmalloc(
598 sizeof(struct config_load_session_override_attr
));
599 if (!attr
->override_attr
) {
600 ret
= -LTTNG_ERR_NOMEM
;
605 len
= strlen(session_name
);
606 if (len
>= LTTNG_NAME_MAX
) {
607 ret
= -LTTNG_ERR_INVALID
;
611 attr
->override_attr
->session_name
= lttng_strndup(session_name
,
613 if (!attr
->override_attr
->session_name
) {
614 ret
= -LTTNG_ERR_NOMEM
;
621 int lttng_load_session(struct lttng_load_session_attr
*attr
)
624 const char *url
, *session_name
;
627 ret
= -LTTNG_ERR_INVALID
;
631 ret
= validate_attr(attr
);
636 url
= attr
->input_url
[0] != '\0' ? attr
->input_url
: NULL
;
637 session_name
= attr
->session_name
[0] != '\0' ?
638 attr
->session_name
: NULL
;
640 ret
= config_load_session(url
, session_name
, attr
->overwrite
, 0,
641 attr
->override_attr
);