projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fixes after rebase on eepp-jgalar/fixes-mar-7
[babeltrace.git] / cli / babeltrace-cfg.c
CommitLineData
c42c79ea
PP		 1/*
2 * Babeltrace trace converter - parameter parsing
3 *
4 * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25#include <errno.h>
26#include <stdlib.h>
27#include <string.h>
28#include <assert.h>
29#include <stdio.h>
30#include <stdbool.h>
31#include <inttypes.h>
32#include <babeltrace/babeltrace.h>
1670bffd 33#include <babeltrace/common-internal.h>
c42c79ea
PP		 34#include <babeltrace/values.h>
35#include <popt.h>
36#include <glib.h>
98ecef32
MD		 37#include <sys/types.h>
38#include <pwd.h>
c42c79ea 39#include "babeltrace-cfg.h"
ebba3338 40#include "babeltrace-cfg-connect.h"
c42c79ea
PP		 41
42/*
43 * Error printf() macro which prepends "Error: " the first time it's
44 * called. This gives a nicer feel than having a bunch of error prefixes
45 * (since the following lines usually describe the error and possible
46 * solutions), or the error prefix just at the end.
47 */
82a498b7
PP		 48#define printf_err(fmt, args...) \
49 do { \
50 if (is_first_error) { \
51 fprintf(stderr, "Command line error: "); \
52 is_first_error = false; \
53 } \
54 fprintf(stderr, fmt, ##args); \
c42c79ea
PP		 55 } while (0)
56
57static bool is_first_error = true;
58
59/* INI-style parsing FSM states */
60enum ini_parsing_fsm_state {
61 /* Expect a map key (identifier) */
62 INI_EXPECT_MAP_KEY,
63
64 /* Expect an equal character ('=') */
65 INI_EXPECT_EQUAL,
66
67 /* Expect a value */
68 INI_EXPECT_VALUE,
69
70 /* Expect a negative number value */
71 INI_EXPECT_VALUE_NUMBER_NEG,
72
73 /* Expect a comma character (',') */
74 INI_EXPECT_COMMA,
75};
76
77/* INI-style parsing state variables */
78struct ini_parsing_state {
79 /* Lexical scanner (owned by this) */
80 GScanner *scanner;
81
82 /* Output map value object being filled (owned by this) */
83 struct bt_value *params;
84
85 /* Next expected FSM state */
86 enum ini_parsing_fsm_state expecting;
87
88 /* Last decoded map key (owned by this) */
89 char *last_map_key;
90
91 /* Complete INI-style string to parse (not owned by this) */
92 const char *arg;
93
94 /* Error buffer (not owned by this) */
95 GString *ini_error;
96};
97
98/* Offset option with "is set" boolean */
99struct offset_opt {
100 int64_t value;
101 bool is_set;
102};
103
104/* Legacy "ctf"/"lttng-live" format options */
105struct ctf_legacy_opts {
106 struct offset_opt offset_s;
107 struct offset_opt offset_ns;
108 bool stream_intersection;
109};
110
111/* Legacy "text" format options */
112struct text_legacy_opts {
113 /*
114 * output, dbg_info_dir, dbg_info_target_prefix, names,
115 * and fields are owned by this.
116 */
117 GString *output;
118 GString *dbg_info_dir;
119 GString *dbg_info_target_prefix;
120 struct bt_value *names;
121 struct bt_value *fields;
122
123 /* Flags */
124 bool no_delta;
125 bool clock_cycles;
126 bool clock_seconds;
127 bool clock_date;
128 bool clock_gmt;
129 bool dbg_info_full_path;
a263021c 130 bool verbose;
c42c79ea
PP		 131};
132
133/* Legacy input format format */
134enum legacy_input_format {
135 LEGACY_INPUT_FORMAT_NONE = 0,
136 LEGACY_INPUT_FORMAT_CTF,
137 LEGACY_INPUT_FORMAT_LTTNG_LIVE,
138};
139
140/* Legacy output format format */
141enum legacy_output_format {
142 LEGACY_OUTPUT_FORMAT_NONE = 0,
143 LEGACY_OUTPUT_FORMAT_TEXT,
c42c79ea
PP		 144 LEGACY_OUTPUT_FORMAT_DUMMY,
145};
146
147/*
148 * Prints the "out of memory" error.
149 */
150static
151void print_err_oom(void)
152{
153 printf_err("Out of memory\n");
154}
155
c42c79ea
PP		 156/*
157 * Appends an "expecting token" error to the INI-style parsing state's
158 * error buffer.
159 */
160static
161void ini_append_error_expecting(struct ini_parsing_state *state,
162 GScanner *scanner, const char *expecting)
163{
164 size_t i;
165 size_t pos;
166
167 g_string_append_printf(state->ini_error, "Expecting %s:\n", expecting);
168
169 /* Only print error if there's one line */
170 if (strchr(state->arg, '\n') != NULL || strlen(state->arg) == 0) {
171 return;
172 }
173
174 g_string_append_printf(state->ini_error, "\n %s\n", state->arg);
175 pos = g_scanner_cur_position(scanner) + 4;
176
177 if (!g_scanner_eof(scanner)) {
178 pos--;
179 }
180
181 for (i = 0; i < pos; ++i) {
182 g_string_append_printf(state->ini_error, " ");
183 }
184
185 g_string_append_printf(state->ini_error, "^\n\n");
186}
187
188static
189int ini_handle_state(struct ini_parsing_state *state)
190{
191 int ret = 0;
192 GTokenType token_type;
193 struct bt_value *value = NULL;
194
195 token_type = g_scanner_get_next_token(state->scanner);
196 if (token_type == G_TOKEN_EOF) {
197 if (state->expecting != INI_EXPECT_COMMA) {
198 switch (state->expecting) {
199 case INI_EXPECT_EQUAL:
200 ini_append_error_expecting(state,
201 state->scanner, "'='");
202 break;
203 case INI_EXPECT_VALUE:
204 case INI_EXPECT_VALUE_NUMBER_NEG:
205 ini_append_error_expecting(state,
206 state->scanner, "value");
207 break;
208 case INI_EXPECT_MAP_KEY:
209 ini_append_error_expecting(state,
210 state->scanner, "unquoted map key");
211 break;
212 default:
213 break;
214 }
215 goto error;
216 }
217
218 /* We're done! */
219 ret = 1;
220 goto success;
221 }
222
223 switch (state->expecting) {
224 case INI_EXPECT_MAP_KEY:
225 if (token_type != G_TOKEN_IDENTIFIER) {
226 ini_append_error_expecting(state, state->scanner,
227 "unquoted map key");
228 goto error;
229 }
230
231 free(state->last_map_key);
232 state->last_map_key =
233 strdup(state->scanner->value.v_identifier);
234 if (!state->last_map_key) {
235 g_string_append(state->ini_error,
236 "Out of memory\n");
237 goto error;
238 }
239
240 if (bt_value_map_has_key(state->params, state->last_map_key)) {
241 g_string_append_printf(state->ini_error,
6d1d5711 242 "Duplicate parameter key: `%s`\n",
c42c79ea
PP		 243 state->last_map_key);
244 goto error;
245 }
246
247 state->expecting = INI_EXPECT_EQUAL;
248 goto success;
249 case INI_EXPECT_EQUAL:
250 if (token_type != G_TOKEN_CHAR) {
251 ini_append_error_expecting(state,
252 state->scanner, "'='");
253 goto error;
254 }
255
256 if (state->scanner->value.v_char != '=') {
257 ini_append_error_expecting(state,
258 state->scanner, "'='");
259 goto error;
260 }
261
262 state->expecting = INI_EXPECT_VALUE;
263 goto success;
264 case INI_EXPECT_VALUE:
265 {
266 switch (token_type) {
267 case G_TOKEN_CHAR:
268 if (state->scanner->value.v_char == '-') {
269 /* Negative number */
270 state->expecting =
271 INI_EXPECT_VALUE_NUMBER_NEG;
272 goto success;
273 } else {
274 ini_append_error_expecting(state,
275 state->scanner, "value");
276 goto error;
277 }
278 break;
279 case G_TOKEN_INT:
280 {
281 /* Positive integer */
282 uint64_t int_val = state->scanner->value.v_int64;
283
284 if (int_val > (1ULL << 63) - 1) {
285 g_string_append_printf(state->ini_error,
286 "Integer value %" PRIu64 " is outside the range of a 64-bit signed integer\n",
287 int_val);
288 goto error;
289 }
290
291 value = bt_value_integer_create_init(
292 (int64_t) int_val);
293 break;
294 }
295 case G_TOKEN_FLOAT:
296 /* Positive floating point number */
297 value = bt_value_float_create_init(
298 state->scanner->value.v_float);
299 break;
300 case G_TOKEN_STRING:
301 /* Quoted string */
302 value = bt_value_string_create_init(
303 state->scanner->value.v_string);
304 break;
305 case G_TOKEN_IDENTIFIER:
306 {
307 /*
308 * Using symbols would be appropriate here,
309 * but said symbols are allowed as map key,
310 * so it's easier to consider everything an
311 * identifier.
312 *
313 * If one of the known symbols is not
314 * recognized here, then fall back to creating
315 * a string value.
316 */
317 const char *id = state->scanner->value.v_identifier;
318
319 if (!strcmp(id, "null") || !strcmp(id, "NULL") ||
320 !strcmp(id, "nul")) {
321 value = bt_value_null;
322 } else if (!strcmp(id, "true") || !strcmp(id, "TRUE") ||
323 !strcmp(id, "yes") ||
324 !strcmp(id, "YES")) {
325 value = bt_value_bool_create_init(true);
326 } else if (!strcmp(id, "false") ||
327 !strcmp(id, "FALSE") ||
328 !strcmp(id, "no") ||
329 !strcmp(id, "NO")) {
330 value = bt_value_bool_create_init(false);
331 } else {
332 value = bt_value_string_create_init(id);
333 }
334 break;
335 }
336 default:
337 /* Unset value variable will trigger the error */
338 break;
339 }
340
341 if (!value) {
342 ini_append_error_expecting(state,
343 state->scanner, "value");
344 goto error;
345 }
346
347 state->expecting = INI_EXPECT_COMMA;
348 goto success;
349 }
350 case INI_EXPECT_VALUE_NUMBER_NEG:
351 {
352 switch (token_type) {
353 case G_TOKEN_INT:
354 {
355 /* Negative integer */
356 uint64_t int_val = state->scanner->value.v_int64;
357
358 if (int_val > (1ULL << 63) - 1) {
359 g_string_append_printf(state->ini_error,
360 "Integer value -%" PRIu64 " is outside the range of a 64-bit signed integer\n",
361 int_val);
362 goto error;
363 }
364
365 value = bt_value_integer_create_init(
366 -((int64_t) int_val));
367 break;
368 }
369 case G_TOKEN_FLOAT:
370 /* Negative floating point number */
371 value = bt_value_float_create_init(
372 -state->scanner->value.v_float);
373 break;
374 default:
375 /* Unset value variable will trigger the error */
376 break;
377 }
378
379 if (!value) {
380 ini_append_error_expecting(state,
381 state->scanner, "value");
382 goto error;
383 }
384
385 state->expecting = INI_EXPECT_COMMA;
386 goto success;
387 }
388 case INI_EXPECT_COMMA:
389 if (token_type != G_TOKEN_CHAR) {
390 ini_append_error_expecting(state,
391 state->scanner, "','");
392 goto error;
393 }
394
395 if (state->scanner->value.v_char != ',') {
396 ini_append_error_expecting(state,
397 state->scanner, "','");
398 goto error;
399 }
400
401 state->expecting = INI_EXPECT_MAP_KEY;
402 goto success;
403 default:
404 assert(false);
405 }
406
407error:
408 ret = -1;
409 goto end;
410
411success:
412 if (value) {
413 if (bt_value_map_insert(state->params,
414 state->last_map_key, value)) {
415 /* Only override return value on error */
416 ret = -1;
417 }
418 }
419
420end:
421 BT_PUT(value);
422 return ret;
423}
424
425/*
426 * Converts an INI-style argument to an equivalent map value object.
427 *
428 * Return value is owned by the caller.
429 */
430static
431struct bt_value *bt_value_from_ini(const char *arg, GString *ini_error)
432{
433 /* Lexical scanner configuration */
434 GScannerConfig scanner_config = {
435 /* Skip whitespaces */
436 .cset_skip_characters = " \t\n",
437
438 /* Identifier syntax is: [a-zA-Z_][a-zA-Z0-9_.:-]* */
439 .cset_identifier_first =
440 G_CSET_a_2_z
441 "_"
442 G_CSET_A_2_Z,
443 .cset_identifier_nth =
444 G_CSET_a_2_z
445 "_0123456789-.:"
446 G_CSET_A_2_Z,
447
448 /* "hello" and "Hello" two different keys */
449 .case_sensitive = TRUE,
450
451 /* No comments */
452 .cpair_comment_single = NULL,
453 .skip_comment_multi = TRUE,
454 .skip_comment_single = TRUE,
455 .scan_comment_multi = FALSE,
456
457 /*
458 * Do scan identifiers, including 1-char identifiers,
459 * but NULL is a normal identifier.
460 */
461 .scan_identifier = TRUE,
462 .scan_identifier_1char = TRUE,
463 .scan_identifier_NULL = FALSE,
464
465 /*
466 * No specific symbols: null and boolean "symbols" are
467 * scanned as plain identifiers.
468 */
469 .scan_symbols = FALSE,
470 .symbol_2_token = FALSE,
471 .scope_0_fallback = FALSE,
472
473 /*
474 * Scan "0b"-, "0"-, and "0x"-prefixed integers, but not
475 * integers prefixed with "$".
476 */
477 .scan_binary = TRUE,
478 .scan_octal = TRUE,
479 .scan_float = TRUE,
480 .scan_hex = TRUE,
481 .scan_hex_dollar = FALSE,
482
483 /* Convert scanned numbers to integer tokens */
484 .numbers_2_int = TRUE,
485
486 /* Support both integers and floating-point numbers */
487 .int_2_float = FALSE,
488
489 /* Scan integers as 64-bit signed integers */
490 .store_int64 = TRUE,
491
492 /* Only scan double-quoted strings */
493 .scan_string_sq = FALSE,
494 .scan_string_dq = TRUE,
495
496 /* Do not converter identifiers to string tokens */
497 .identifier_2_string = FALSE,
498
499 /* Scan characters as G_TOKEN_CHAR token */
500 .char_2_token = FALSE,
501 };
502 struct ini_parsing_state state = {
503 .scanner = NULL,
504 .params = NULL,
505 .expecting = INI_EXPECT_MAP_KEY,
506 .arg = arg,
507 .ini_error = ini_error,
508 };
509
510 state.params = bt_value_map_create();
511 if (!state.params) {
512 goto error;
513 }
514
515 state.scanner = g_scanner_new(&scanner_config);
516 if (!state.scanner) {
517 goto error;
518 }
519
520 /* Let the scan begin */
521 g_scanner_input_text(state.scanner, arg, strlen(arg));
522
523 while (true) {
524 int ret = ini_handle_state(&state);
525
526 if (ret < 0) {
527 /* Error */
528 goto error;
529 } else if (ret > 0) {
530 /* Done */
531 break;
532 }
533 }
534
535 goto end;
536
537error:
538 BT_PUT(state.params);
539
540end:
541 if (state.scanner) {
542 g_scanner_destroy(state.scanner);
543 }
544
545 free(state.last_map_key);
546 return state.params;
547}
548
549/*
550 * Returns the parameters map value object from a command-line
bdc61c70 551 * parameter option's argument.
c42c79ea
PP		 552 *
553 * Return value is owned by the caller.
554 */
555static
556struct bt_value *bt_value_from_arg(const char *arg)
557{
558 struct bt_value *params = NULL;
c42c79ea
PP		 559 GString *ini_error = NULL;
560
c42c79ea
PP		 561 ini_error = g_string_new(NULL);
562 if (!ini_error) {
563 print_err_oom();
564 goto end;
565 }
566
567 /* Try INI-style parsing */
bdc61c70 568 params = bt_value_from_ini(arg, ini_error);
c42c79ea
PP		 569 if (!params) {
570 printf_err("%s", ini_error->str);
571 goto end;
572 }
573
574end:
575 if (ini_error) {
576 g_string_free(ini_error, TRUE);
577 }
578 return params;
579}
580
581/*
db0f160a
PP		 582 * Returns the plugin and component class names, and the instance name,
583 * from a command-line source/filter/sink option's argument. arg must
584 * have the following format:
bdc61c70 585 *
db0f160a 586 * [NAME:]PLUGIN.CLS
bdc61c70 587 *
db0f160a
PP		 588 * where NAME is the optional component name, PLUGIN is the plugin name,
589 * and CLS is the component class name.
c42c79ea
PP		 590 *
591 * On success, both *plugin and *component are not NULL. *plugin
db0f160a
PP		 592 * and *component are owned by the caller. On success, *name can be NULL
593 * if no component name was found.
c42c79ea
PP		 594 */
595static
db0f160a
PP		 596void plugin_comp_cls_names(const char *arg, char **name, char **plugin,
597 char **comp_cls)
c42c79ea 598{
db0f160a
PP		 599 const char *at = arg;
600 GString *gs_name = NULL;
601 GString *gs_plugin = NULL;
602 GString *gs_comp_cls = NULL;
603 size_t end_pos;
604
605 assert(arg);
606 assert(plugin);
607 assert(comp_cls);
608
609 if (!bt_common_string_is_printable(arg)) {
610 printf_err("Argument contains a non-printable character\n");
87796884 611 goto error;
c42c79ea
PP		 612 }
613
db0f160a
PP		 614 /* Parse the component name */
615 gs_name = bt_common_string_until(at, ".:\\", ":", &end_pos);
616 if (!gs_name) {
87796884 617 goto error;
c42c79ea
PP		 618 }
619
db0f160a
PP		 620 if (arg[end_pos] == ':') {
621 at += end_pos + 1;
622 } else {
623 /* No name */
624 g_string_assign(gs_name, "");
625 }
87796884 626
db0f160a
PP		 627 /* Parse the plugin name */
628 gs_plugin = bt_common_string_until(at, ".:\\", ".", &end_pos);
629 if (!gs_plugin || gs_plugin->len == 0 || at[end_pos] == '\0') {
630 goto error;
631 }
87796884 632
db0f160a
PP		 633 at += end_pos + 1;
634
635 /* Parse the component class name */
636 gs_comp_cls = bt_common_string_until(at, ".:\\", ".", &end_pos);
637 if (!gs_comp_cls || gs_comp_cls->len == 0) {
638 goto error;
87796884
PP		 639 }
640
db0f160a
PP		 641 if (at[end_pos] != '\0') {
642 /* Found a non-escaped `.` */
87796884
PP		 643 goto error;
644 }
645
db0f160a
PP		 646 if (name) {
647 if (gs_name->len == 0) {
648 *name = NULL;
649 g_string_free(gs_name, TRUE);
650 } else {
651 *name = gs_name->str;
652 g_string_free(gs_name, FALSE);
653 }
654 } else {
655 g_string_free(gs_name, TRUE);
656 }
657
658 *plugin = gs_plugin->str;
659 *comp_cls = gs_comp_cls->str;
660 g_string_free(gs_plugin, FALSE);
661 g_string_free(gs_comp_cls, FALSE);
662 gs_name = NULL;
663 gs_plugin = NULL;
664 gs_comp_cls = NULL;
87796884
PP		 665 goto end;
666
667error:
db0f160a
PP		 668 if (gs_name) {
669 g_string_free(gs_name, TRUE);
670 }
671
672 if (gs_plugin) {
673 g_string_free(gs_plugin, TRUE);
674 }
675
676 if (gs_comp_cls) {
677 g_string_free(gs_comp_cls, TRUE);
678 }
679
680 if (name) {
681 *name = NULL;
682 }
683
87796884 684 *plugin = NULL;
db0f160a 685 *comp_cls = NULL;
c42c79ea
PP		 686
687end:
688 return;
689}
690
691/*
692 * Prints the Babeltrace version.
693 */
694static
695void print_version(void)
696{
697 puts("Babeltrace " VERSION);
698}
699
c42c79ea
PP		 700/*
701 * Destroys a component configuration.
702 */
703static
704void bt_config_component_destroy(struct bt_object *obj)
705{
706 struct bt_config_component *bt_config_component =
707 container_of(obj, struct bt_config_component, base);
708
709 if (!obj) {
710 goto end;
711 }
712
713 if (bt_config_component->plugin_name) {
714 g_string_free(bt_config_component->plugin_name, TRUE);
715 }
716
db0f160a
PP		 717 if (bt_config_component->comp_cls_name) {
718 g_string_free(bt_config_component->comp_cls_name, TRUE);
c42c79ea
PP		 719 }
720
3b6cfcc5
PP		 721 if (bt_config_component->instance_name) {
722 g_string_free(bt_config_component->instance_name, TRUE);
723 }
724
c42c79ea
PP		 725 BT_PUT(bt_config_component->params);
726 g_free(bt_config_component);
727
728end:
729 return;
730}
731
732/*
bdc61c70 733 * Creates a component configuration using the given plugin name and
db0f160a
PP		 734 * component name. `plugin_name` and `comp_cls_name` are copied (belong
735 * to the return value).
c42c79ea
PP		 736 *
737 * Return value is owned by the caller.
738 */
739static
90de159b
PP		 740struct bt_config_component *bt_config_component_create(
741 enum bt_component_class_type type,
db0f160a 742 const char *plugin_name, const char *comp_cls_name)
c42c79ea
PP		 743{
744 struct bt_config_component *cfg_component = NULL;
745
746 cfg_component = g_new0(struct bt_config_component, 1);
747 if (!cfg_component) {
748 print_err_oom();
749 goto error;
750 }
751
752 bt_object_init(cfg_component, bt_config_component_destroy);
90de159b 753 cfg_component->type = type;
c42c79ea
PP		 754 cfg_component->plugin_name = g_string_new(plugin_name);
755 if (!cfg_component->plugin_name) {
756 print_err_oom();
757 goto error;
758 }
759
db0f160a
PP		 760 cfg_component->comp_cls_name = g_string_new(comp_cls_name);
761 if (!cfg_component->comp_cls_name) {
c42c79ea
PP		 762 print_err_oom();
763 goto error;
764 }
765
3b6cfcc5
PP		 766 cfg_component->instance_name = g_string_new(NULL);
767 if (!cfg_component->instance_name) {
768 print_err_oom();
769 goto error;
770 }
771
bdc61c70
PP		 772 /* Start with empty parameters */
773 cfg_component->params = bt_value_map_create();
774 if (!cfg_component->params) {
775 print_err_oom();
776 goto error;
777 }
778
c42c79ea
PP		 779 goto end;
780
781error:
782 BT_PUT(cfg_component);
783
784end:
785 return cfg_component;
786}
787
788/*
789 * Creates a component configuration from a command-line source/sink
bdc61c70 790 * option's argument.
c42c79ea 791 */
90de159b
PP		 792struct bt_config_component *bt_config_component_from_arg(
793 enum bt_component_class_type type, const char *arg)
c42c79ea 794{
db0f160a
PP		 795 struct bt_config_component *cfg_comp = NULL;
796 char *name = NULL;
797 char *plugin_name = NULL;
798 char *comp_cls_name = NULL;
c42c79ea 799
db0f160a
PP		 800 plugin_comp_cls_names(arg, &name, &plugin_name, &comp_cls_name);
801 if (!plugin_name || !comp_cls_name) {
49849a47 802 printf_err("Cannot get plugin or component class name\n");
c42c79ea
PP		 803 goto error;
804 }
805
db0f160a
PP		 806 cfg_comp = bt_config_component_create(type, plugin_name, comp_cls_name);
807 if (!cfg_comp) {
c42c79ea
PP		 808 goto error;
809 }
810
db0f160a
PP		 811 if (name) {
812 g_string_assign(cfg_comp->instance_name, name);
813 }
814
c42c79ea
PP		 815 goto end;
816
817error:
db0f160a 818 BT_PUT(cfg_comp);
c42c79ea
PP		 819
820end:
db0f160a 821 g_free(name);
bdc61c70 822 g_free(plugin_name);
db0f160a
PP		 823 g_free(comp_cls_name);
824 return cfg_comp;
c42c79ea
PP		 825}
826
827/*
828 * Destroys a configuration.
829 */
830static
831void bt_config_destroy(struct bt_object *obj)
832{
290725f7 833 struct bt_config *cfg =
c42c79ea
PP		 834 container_of(obj, struct bt_config, base);
835
836 if (!obj) {
837 goto end;
838 }
839
db0f160a
PP		 840 BT_PUT(cfg->plugin_paths);
841
290725f7 842 switch (cfg->command) {
db0f160a
PP		 843 case BT_CONFIG_COMMAND_RUN:
844 if (cfg->cmd_data.run.sources) {
845 g_ptr_array_free(cfg->cmd_data.run.sources, TRUE);
290725f7 846 }
c42c79ea 847
db0f160a
PP		 848 if (cfg->cmd_data.run.filters) {
849 g_ptr_array_free(cfg->cmd_data.run.filters, TRUE);
ebba3338
PP		 850 }
851
db0f160a
PP		 852 if (cfg->cmd_data.run.sinks) {
853 g_ptr_array_free(cfg->cmd_data.run.sinks, TRUE);
290725f7
PP		 854 }
855
db0f160a
PP		 856 if (cfg->cmd_data.run.connections) {
857 g_ptr_array_free(cfg->cmd_data.run.connections,
ebba3338
PP		 858 TRUE);
859 }
290725f7 860 break;
290725f7 861 case BT_CONFIG_COMMAND_LIST_PLUGINS:
290725f7 862 break;
22e22462 863 case BT_CONFIG_COMMAND_HELP:
90de159b 864 BT_PUT(cfg->cmd_data.help.cfg_component);
22e22462 865 break;
a67681c1 866 case BT_CONFIG_COMMAND_QUERY:
a67681c1 867 BT_PUT(cfg->cmd_data.query.cfg_component);
63ce0e1d 868
a67681c1
PP		 869 if (cfg->cmd_data.query.object) {
870 g_string_free(cfg->cmd_data.query.object, TRUE);
63ce0e1d
PP		 871 }
872 break;
db0f160a
PP		 873 case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
874 if (cfg->cmd_data.print_ctf_metadata.path) {
875 g_string_free(cfg->cmd_data.print_ctf_metadata.path,
876 TRUE);
877 }
878 break;
879 case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
880 if (cfg->cmd_data.print_lttng_live_sessions.url) {
881 g_string_free(
882 cfg->cmd_data.print_lttng_live_sessions.url,
883 TRUE);
884 }
885 break;
290725f7
PP		 886 default:
887 assert(false);
c42c79ea
PP		 888 }
889
290725f7 890 g_free(cfg);
c42c79ea
PP		 891
892end:
893 return;
894}
895
1670bffd
PP		 896static void destroy_gstring(void *data)
897{
898 g_string_free(data, TRUE);
899}
900
db0f160a
PP		 901static void destroy_glist_of_gstring(GList *list)
902{
903 if (!list) {
904 return;
905 }
906
907 GList *at;
908
909 for (at = list; at != NULL; at = g_list_next(at)) {
910 g_string_free(at->data, TRUE);
911 }
912
913 g_list_free(list);
914}
915
c42c79ea
PP		 916/*
917 * Extracts the various paths from the string arg, delimited by ':',
5a3ee633 918 * and appends them to the array value object plugin_paths.
c42c79ea 919 */
5a3ee633
PP		 920enum bt_value_status bt_config_append_plugin_paths(
921 struct bt_value *plugin_paths, const char *arg)
c42c79ea 922{
1670bffd
PP		 923 enum bt_value_status status = BT_VALUE_STATUS_OK;
924 GPtrArray *dirs = g_ptr_array_new_with_free_func(destroy_gstring);
925 int ret;
926 size_t i;
c42c79ea 927
1670bffd
PP		 928 if (!dirs) {
929 status = BT_VALUE_STATUS_ERROR;
930 goto end;
931 }
c42c79ea 932
1670bffd
PP		 933 ret = bt_common_append_plugin_path_dirs(arg, dirs);
934 if (ret) {
935 status = BT_VALUE_STATUS_ERROR;
936 goto end;
937 }
c42c79ea 938
1670bffd
PP		 939 for (i = 0; i < dirs->len; i++) {
940 GString *dir = g_ptr_array_index(dirs, i);
c42c79ea 941
1670bffd 942 bt_value_array_append_string(plugin_paths, dir->str);
c42c79ea
PP		 943 }
944
1670bffd
PP		 945end:
946 g_ptr_array_free(dirs, TRUE);
947 return status;
c42c79ea
PP		 948}
949
950/*
951 * Creates a simple lexical scanner for parsing comma-delimited names
952 * and fields.
953 *
954 * Return value is owned by the caller.
955 */
956static
957GScanner *create_csv_identifiers_scanner(void)
958{
db0f160a 959 GScanner *scanner;
c42c79ea
PP		 960 GScannerConfig scanner_config = {
961 .cset_skip_characters = " \t\n",
962 .cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z "_",
963 .cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z ":_-",
964 .case_sensitive = TRUE,
965 .cpair_comment_single = NULL,
966 .skip_comment_multi = TRUE,
967 .skip_comment_single = TRUE,
968 .scan_comment_multi = FALSE,
969 .scan_identifier = TRUE,
970 .scan_identifier_1char = TRUE,
971 .scan_identifier_NULL = FALSE,
972 .scan_symbols = FALSE,
973 .symbol_2_token = FALSE,
974 .scope_0_fallback = FALSE,
975 .scan_binary = FALSE,
976 .scan_octal = FALSE,
977 .scan_float = FALSE,
978 .scan_hex = FALSE,
979 .scan_hex_dollar = FALSE,
980 .numbers_2_int = FALSE,
981 .int_2_float = FALSE,
982 .store_int64 = FALSE,
983 .scan_string_sq = FALSE,
984 .scan_string_dq = FALSE,
985 .identifier_2_string = FALSE,
986 .char_2_token = TRUE,
987 };
988
db0f160a
PP		 989 scanner = g_scanner_new(&scanner_config);
990 if (!scanner) {
991 print_err_oom();
6e1bc0df 992 }
db0f160a
PP		 993
994 return scanner;
6e1bc0df
MD		 995}
996
c42c79ea
PP		 997/*
998 * Converts a comma-delimited list of known names (--names option) to
999 * an array value object containing those names as string value objects.
1000 *
1001 * Return value is owned by the caller.
1002 */
1003static
1004struct bt_value *names_from_arg(const char *arg)
1005{
1006 GScanner *scanner = NULL;
1007 struct bt_value *names = NULL;
6e1bc0df 1008 bool found_all = false, found_none = false, found_item = false;
c42c79ea
PP		 1009
1010 names = bt_value_array_create();
1011 if (!names) {
1012 print_err_oom();
1013 goto error;
1014 }
1015
1016 scanner = create_csv_identifiers_scanner();
1017 if (!scanner) {
c42c79ea
PP		 1018 goto error;
1019 }
1020
1021 g_scanner_input_text(scanner, arg, strlen(arg));
1022
1023 while (true) {
1024 GTokenType token_type = g_scanner_get_next_token(scanner);
1025
1026 switch (token_type) {
1027 case G_TOKEN_IDENTIFIER:
1028 {
1029 const char *identifier = scanner->value.v_identifier;
1030
1031 if (!strcmp(identifier, "payload") ||
1032 !strcmp(identifier, "args") ||
1033 !strcmp(identifier, "arg")) {
6e1bc0df 1034 found_item = true;
c42c79ea
PP		 1035 if (bt_value_array_append_string(names,
1036 "payload")) {
1037 goto error;
1038 }
1039 } else if (!strcmp(identifier, "context") ||
1040 !strcmp(identifier, "ctx")) {
6e1bc0df 1041 found_item = true;
c42c79ea
PP		 1042 if (bt_value_array_append_string(names,
1043 "context")) {
1044 goto error;
1045 }
1046 } else if (!strcmp(identifier, "scope") ||
1047 !strcmp(identifier, "header")) {
6e1bc0df 1048 found_item = true;
c42c79ea
PP		 1049 if (bt_value_array_append_string(names,
1050 identifier)) {
1051 goto error;
1052 }
6e1bc0df
MD		 1053 } else if (!strcmp(identifier, "all")) {
1054 found_all = true;
1055 if (bt_value_array_append_string(names,
1056 identifier)) {
c42c79ea
PP		 1057 goto error;
1058 }
6e1bc0df
MD		 1059 } else if (!strcmp(identifier, "none")) {
1060 found_none = true;
c42c79ea
PP		 1061 if (bt_value_array_append_string(names,
1062 identifier)) {
1063 goto error;
1064 }
c42c79ea 1065 } else {
db0f160a 1066 printf_err("Unknown name: `%s`\n",
c42c79ea
PP		 1067 identifier);
1068 goto error;
1069 }
1070 break;
1071 }
1072 case G_TOKEN_COMMA:
1073 continue;
1074 case G_TOKEN_EOF:
1075 goto end;
1076 default:
1077 goto error;
1078 }
1079 }
1080
6e1bc0df
MD		 1081end:
1082 if (found_none && found_all) {
6d1d5711 1083 printf_err("Only either `all` or `none` can be specified in the list given to the --names option, but not both.\n");
6e1bc0df
MD		 1084 goto error;
1085 }
1086 /*
1087 * Legacy behavior is to clear the defaults (show none) when at
1088 * least one item is specified.
1089 */
1090 if (found_item && !found_none && !found_all) {
1091 if (bt_value_array_append_string(names, "none")) {
1092 goto error;
1093 }
1094 }
1095 if (scanner) {
1096 g_scanner_destroy(scanner);
1097 }
1098 return names;
c42c79ea
PP		 1099
1100error:
1101 BT_PUT(names);
c42c79ea
PP		 1102 if (scanner) {
1103 g_scanner_destroy(scanner);
1104 }
1105 return names;
1106}
1107
c42c79ea
PP		 1108/*
1109 * Converts a comma-delimited list of known fields (--fields option) to
1110 * an array value object containing those fields as string
1111 * value objects.
1112 *
1113 * Return value is owned by the caller.
1114 */
1115static
1116struct bt_value *fields_from_arg(const char *arg)
1117{
1118 GScanner *scanner = NULL;
1119 struct bt_value *fields;
1120
1121 fields = bt_value_array_create();
1122 if (!fields) {
1123 print_err_oom();
1124 goto error;
1125 }
1126
1127 scanner = create_csv_identifiers_scanner();
1128 if (!scanner) {
c42c79ea
PP		 1129 goto error;
1130 }
1131
1132 g_scanner_input_text(scanner, arg, strlen(arg));
1133
1134 while (true) {
1135 GTokenType token_type = g_scanner_get_next_token(scanner);
1136
1137 switch (token_type) {
1138 case G_TOKEN_IDENTIFIER:
1139 {
1140 const char *identifier = scanner->value.v_identifier;
1141
1142 if (!strcmp(identifier, "trace") ||
1143 !strcmp(identifier, "trace:hostname") ||
1144 !strcmp(identifier, "trace:domain") ||
1145 !strcmp(identifier, "trace:procname") ||
1146 !strcmp(identifier, "trace:vpid") ||
1147 !strcmp(identifier, "loglevel") ||
1148 !strcmp(identifier, "emf") ||
6e1bc0df
MD		 1149 !strcmp(identifier, "callsite") ||
1150 !strcmp(identifier, "all")) {
c42c79ea
PP		 1151 if (bt_value_array_append_string(fields,
1152 identifier)) {
1153 goto error;
1154 }
c42c79ea 1155 } else {
db0f160a 1156 printf_err("Unknown field: `%s`\n",
c42c79ea
PP		 1157 identifier);
1158 goto error;
1159 }
1160 break;
1161 }
1162 case G_TOKEN_COMMA:
1163 continue;
1164 case G_TOKEN_EOF:
1165 goto end;
1166 default:
1167 goto error;
1168 }
1169 }
1170
1171 goto end;
1172
1173error:
1174 BT_PUT(fields);
1175
1176end:
1177 if (scanner) {
1178 g_scanner_destroy(scanner);
1179 }
1180 return fields;
1181}
1182
db0f160a
PP		 1183static
1184void append_param_arg(GString *params_arg, const char *key, const char *value)
1185{
1186 assert(params_arg);
1187 assert(key);
1188 assert(value);
1189
1190 if (params_arg->len != 0) {
1191 g_string_append_c(params_arg, ',');
1192 }
1193
1194 g_string_append(params_arg, key);
1195 g_string_append_c(params_arg, '=');
1196 g_string_append(params_arg, value);
1197}
1198
c42c79ea 1199/*
db0f160a
PP		 1200 * Inserts the equivalent "prefix-NAME=yes" strings into params_arg
1201 * where the names are in names_array.
c42c79ea
PP		 1202 */
1203static
db0f160a
PP		 1204int insert_flat_params_from_array(GString *params_arg,
1205 struct bt_value *names_array, const char *prefix)
c42c79ea
PP		 1206{
1207 int ret = 0;
1208 int i;
6e1bc0df 1209 GString *tmpstr = NULL, *default_value = NULL;
60535549 1210 bool default_set = false, non_default_set = false;
c42c79ea
PP		 1211
1212 /*
db0f160a 1213 * names_array may be NULL if no CLI options were specified to
c42c79ea
PP		 1214 * trigger its creation.
1215 */
db0f160a 1216 if (!names_array) {
c42c79ea
PP		 1217 goto end;
1218 }
1219
1220 tmpstr = g_string_new(NULL);
1221 if (!tmpstr) {
1222 print_err_oom();
1223 ret = -1;
1224 goto end;
1225 }
1226
6e1bc0df
MD		 1227 default_value = g_string_new(NULL);
1228 if (!default_value) {
1229 print_err_oom();
1230 ret = -1;
1231 goto end;
1232 }
1233
db0f160a
PP		 1234 for (i = 0; i < bt_value_array_size(names_array); i++) {
1235 struct bt_value *str_obj = bt_value_array_get(names_array, i);
c42c79ea 1236 const char *suffix;
6e1bc0df 1237 bool is_default = false;
c42c79ea
PP		 1238
1239 if (!str_obj) {
1240 printf_err("Unexpected error\n");
1241 ret = -1;
1242 goto end;
1243 }
1244
1245 ret = bt_value_string_get(str_obj, &suffix);
1246 BT_PUT(str_obj);
1247 if (ret) {
1248 printf_err("Unexpected error\n");
1249 goto end;
1250 }
1251
1252 g_string_assign(tmpstr, prefix);
1253 g_string_append(tmpstr, "-");
6e1bc0df
MD		 1254
1255 /* Special-case for "all" and "none". */
1256 if (!strcmp(suffix, "all")) {
1257 is_default = true;
1258 g_string_assign(default_value, "show");
1259 } else if (!strcmp(suffix, "none")) {
1260 is_default = true;
1261 g_string_assign(default_value, "hide");
1262 }
1263 if (is_default) {
60535549 1264 default_set = true;
6e1bc0df 1265 g_string_append(tmpstr, "default");
db0f160a
PP		 1266 append_param_arg(params_arg, tmpstr->str,
1267 default_value->str);
6e1bc0df 1268 } else {
60535549 1269 non_default_set = true;
6e1bc0df 1270 g_string_append(tmpstr, suffix);
db0f160a 1271 append_param_arg(params_arg, tmpstr->str, "yes");
c42c79ea
PP		 1272 }
1273 }
1274
60535549
JD		 1275 /* Implicit field-default=hide if any non-default option is set. */
1276 if (non_default_set && !default_set) {
1277 g_string_assign(tmpstr, prefix);
1278 g_string_append(tmpstr, "-default");
1279 g_string_assign(default_value, "hide");
7b077a9d 1280 append_param_arg(params_arg, tmpstr->str, default_value->str);
60535549
JD		 1281 }
1282
c42c79ea 1283end:
6e1bc0df
MD		 1284 if (default_value) {
1285 g_string_free(default_value, TRUE);
1286 }
db0f160a 1287
c42c79ea
PP		 1288 if (tmpstr) {
1289 g_string_free(tmpstr, TRUE);
1290 }
1291
1292 return ret;
1293}
1294
db0f160a
PP		 1295/* popt options */
1296enum {
1297 OPT_NONE = 0,
1298 OPT_BASE_PARAMS,
1299 OPT_BEGIN,
1300 OPT_CLOCK_CYCLES,
1301 OPT_CLOCK_DATE,
1302 OPT_CLOCK_FORCE_CORRELATE,
1303 OPT_CLOCK_GMT,
1304 OPT_CLOCK_OFFSET,
1305 OPT_CLOCK_OFFSET_NS,
1306 OPT_CLOCK_SECONDS,
1307 OPT_COLOR,
1308 OPT_CONNECT,
1309 OPT_DEBUG,
1310 OPT_DEBUG_INFO_DIR,
1311 OPT_DEBUG_INFO_FULL_PATH,
1312 OPT_DEBUG_INFO_TARGET_PREFIX,
1313 OPT_END,
1314 OPT_FIELDS,
1315 OPT_FILTER,
1316 OPT_HELP,
1317 OPT_INPUT_FORMAT,
1318 OPT_KEY,
1319 OPT_LIST,
1320 OPT_NAME,
1321 OPT_NAMES,
1322 OPT_NO_DEBUG_INFO,
1323 OPT_NO_DELTA,
1324 OPT_OMIT_HOME_PLUGIN_PATH,
1325 OPT_OMIT_SYSTEM_PLUGIN_PATH,
1326 OPT_OUTPUT_FORMAT,
1327 OPT_OUTPUT,
1328 OPT_PARAMS,
1329 OPT_PATH,
1330 OPT_PLUGIN_PATH,
1331 OPT_RESET_BASE_PARAMS,
1332 OPT_RUN_ARGS,
1333 OPT_RUN_ARGS_0,
1334 OPT_SINK,
1335 OPT_SOURCE,
1336 OPT_STREAM_INTERSECTION,
1337 OPT_TIMERANGE,
1338 OPT_URL,
1339 OPT_VALUE,
1340 OPT_VERBOSE,
1341};
1342
1343enum bt_config_component_dest {
1344 BT_CONFIG_COMPONENT_DEST_SOURCE,
1345 BT_CONFIG_COMPONENT_DEST_FILTER,
1346 BT_CONFIG_COMPONENT_DEST_SINK,
1347};
1348
c42c79ea 1349/*
db0f160a
PP		 1350 * Adds a configuration component to the appropriate configuration
1351 * array depending on the destination.
c42c79ea 1352 */
db0f160a
PP		 1353static void add_run_cfg_comp(struct bt_config *cfg,
1354 struct bt_config_component *cfg_comp,
1355 enum bt_config_component_dest dest)
c42c79ea 1356{
db0f160a 1357 bt_get(cfg_comp);
c42c79ea 1358
db0f160a
PP		 1359 switch (dest) {
1360 case BT_CONFIG_COMPONENT_DEST_SOURCE:
1361 g_ptr_array_add(cfg->cmd_data.run.sources, cfg_comp);
1362 break;
1363 case BT_CONFIG_COMPONENT_DEST_FILTER:
1364 g_ptr_array_add(cfg->cmd_data.run.filters, cfg_comp);
1365 break;
1366 case BT_CONFIG_COMPONENT_DEST_SINK:
1367 g_ptr_array_add(cfg->cmd_data.run.sinks, cfg_comp);
1368 break;
1369 default:
1370 assert(false);
c42c79ea 1371 }
db0f160a 1372}
c42c79ea 1373
db0f160a
PP		 1374static int add_run_cfg_comp_check_name(struct bt_config *cfg,
1375 struct bt_config_component *cfg_comp,
1376 enum bt_config_component_dest dest,
1377 struct bt_value *instance_names)
1378{
1379 int ret = 0;
c42c79ea 1380
db0f160a
PP		 1381 if (cfg_comp->instance_name->len == 0) {
1382 printf_err("Found an unnamed component\n");
1383 ret = -1;
1384 goto end;
c42c79ea
PP		 1385 }
1386
db0f160a
PP		 1387 if (bt_value_map_has_key(instance_names, cfg_comp->instance_name->str)) {
1388 printf_err("Duplicate component instance name:\n %s\n",
1389 cfg_comp->instance_name->str);
1390 ret = -1;
1391 goto end;
c42c79ea
PP		 1392 }
1393
db0f160a
PP		 1394 if (bt_value_map_insert(instance_names,
1395 cfg_comp->instance_name->str, bt_value_null)) {
c42c79ea 1396 print_err_oom();
db0f160a
PP		 1397 ret = -1;
1398 goto end;
c42c79ea
PP		 1399 }
1400
db0f160a 1401 add_run_cfg_comp(cfg, cfg_comp, dest);
c42c79ea 1402
db0f160a
PP		 1403end:
1404 return ret;
1405}
c42c79ea 1406
db0f160a
PP		 1407static int append_env_var_plugin_paths(struct bt_value *plugin_paths)
1408{
1409 int ret = 0;
1410 const char *envvar;
c42c79ea 1411
db0f160a
PP		 1412 if (bt_common_is_setuid_setgid()) {
1413 printf_debug("Skipping non-system plugin paths for setuid/setgid binary\n");
1414 goto end;
c42c79ea
PP		 1415 }
1416
db0f160a
PP		 1417 envvar = getenv("BABELTRACE_PLUGIN_PATH");
1418 if (!envvar) {
1419 goto end;
a263021c
JD		 1420 }
1421
db0f160a 1422 ret = bt_config_append_plugin_paths(plugin_paths, envvar);
c42c79ea 1423
db0f160a
PP		 1424end:
1425 if (ret) {
1426 printf_err("Cannot append plugin paths from BABELTRACE_PLUGIN_PATH\n");
c42c79ea
PP		 1427 }
1428
db0f160a 1429 return ret;
c42c79ea
PP		 1430}
1431
db0f160a
PP		 1432static int append_home_and_system_plugin_paths(struct bt_value *plugin_paths,
1433 bool omit_system_plugin_path, bool omit_home_plugin_path)
c42c79ea 1434{
db0f160a 1435 int ret;
c42c79ea 1436
db0f160a
PP		 1437 if (!omit_home_plugin_path) {
1438 if (bt_common_is_setuid_setgid()) {
1439 printf_debug("Skipping non-system plugin paths for setuid/setgid binary\n");
1440 } else {
1441 char *home_plugin_dir =
1442 bt_common_get_home_plugin_path();
1443
1444 if (home_plugin_dir) {
1445 ret = bt_config_append_plugin_paths(
1446 plugin_paths, home_plugin_dir);
1447 free(home_plugin_dir);
1448
1449 if (ret) {
1450 printf_err("Invalid home plugin path\n");
1451 goto error;
1452 }
1453 }
1454 }
1455 }
1456
1457 if (!omit_system_plugin_path) {
1458 if (bt_config_append_plugin_paths(plugin_paths,
1459 bt_common_get_system_plugin_path())) {
1460 printf_err("Invalid system plugin path\n");
1461 goto error;
1462 }
1463 }
1464 return 0;
1465error:
1466 printf_err("Cannot append home and system plugin paths\n");
1467 return -1;
1468}
1469
1470static int append_home_and_system_plugin_paths_cfg(struct bt_config *cfg)
1471{
1472 return append_home_and_system_plugin_paths(cfg->plugin_paths,
1473 cfg->omit_system_plugin_path, cfg->omit_home_plugin_path);
1474}
1475
1476static struct bt_config *bt_config_base_create(enum bt_config_command command,
1477 struct bt_value *initial_plugin_paths, bool needs_plugins)
1478{
1479 struct bt_config *cfg;
c42c79ea 1480
db0f160a
PP		 1481 /* Create config */
1482 cfg = g_new0(struct bt_config, 1);
1483 if (!cfg) {
1484 print_err_oom();
c42c79ea
PP		 1485 goto error;
1486 }
1487
db0f160a
PP		 1488 bt_object_init(cfg, bt_config_destroy);
1489 cfg->command = command;
1490 cfg->command_needs_plugins = needs_plugins;
bdc61c70 1491
db0f160a
PP		 1492 if (initial_plugin_paths) {
1493 cfg->plugin_paths = bt_get(initial_plugin_paths);
1494 } else {
1495 cfg->plugin_paths = bt_value_array_create();
1496 if (!cfg->plugin_paths) {
1497 print_err_oom();
1498 goto error;
1499 }
1500 }
c42c79ea
PP		 1501
1502 goto end;
1503
1504error:
db0f160a 1505 BT_PUT(cfg);
c42c79ea
PP		 1506
1507end:
db0f160a 1508 return cfg;
c42c79ea
PP		 1509}
1510
db0f160a
PP		 1511static struct bt_config *bt_config_run_create(
1512 struct bt_value *initial_plugin_paths)
c42c79ea 1513{
db0f160a 1514 struct bt_config *cfg;
c42c79ea 1515
db0f160a
PP		 1516 /* Create config */
1517 cfg = bt_config_base_create(BT_CONFIG_COMMAND_RUN,
1518 initial_plugin_paths, true);
1519 if (!cfg) {
1520 goto error;
1521 }
1522
1523 cfg->cmd_data.run.sources = g_ptr_array_new_with_free_func(
1524 (GDestroyNotify) bt_put);
1525 if (!cfg->cmd_data.run.sources) {
c42c79ea
PP		 1526 print_err_oom();
1527 goto error;
1528 }
1529
db0f160a
PP		 1530 cfg->cmd_data.run.filters = g_ptr_array_new_with_free_func(
1531 (GDestroyNotify) bt_put);
1532 if (!cfg->cmd_data.run.filters) {
c42c79ea
PP		 1533 print_err_oom();
1534 goto error;
1535 }
1536
db0f160a
PP		 1537 cfg->cmd_data.run.sinks = g_ptr_array_new_with_free_func(
1538 (GDestroyNotify) bt_put);
1539 if (!cfg->cmd_data.run.sinks) {
c42c79ea
PP		 1540 print_err_oom();
1541 goto error;
1542 }
1543
db0f160a
PP		 1544 cfg->cmd_data.run.connections = g_ptr_array_new_with_free_func(
1545 (GDestroyNotify) bt_config_connection_destroy);
1546 if (!cfg->cmd_data.run.connections) {
c42c79ea
PP		 1547 print_err_oom();
1548 goto error;
1549 }
1550
1551 goto end;
1552
1553error:
db0f160a 1554 BT_PUT(cfg);
c42c79ea
PP		 1555
1556end:
db0f160a 1557 return cfg;
c42c79ea
PP		 1558}
1559
db0f160a
PP		 1560static struct bt_config *bt_config_list_plugins_create(
1561 struct bt_value *initial_plugin_paths)
c42c79ea 1562{
db0f160a 1563 struct bt_config *cfg;
c42c79ea 1564
db0f160a
PP		 1565 /* Create config */
1566 cfg = bt_config_base_create(BT_CONFIG_COMMAND_LIST_PLUGINS,
1567 initial_plugin_paths, true);
1568 if (!cfg) {
c42c79ea
PP		 1569 goto error;
1570 }
1571
db0f160a 1572 goto end;
c42c79ea 1573
db0f160a
PP		 1574error:
1575 BT_PUT(cfg);
c42c79ea 1576
db0f160a
PP		 1577end:
1578 return cfg;
1579}
c42c79ea 1580
db0f160a
PP		 1581static struct bt_config *bt_config_help_create(
1582 struct bt_value *initial_plugin_paths)
1583{
1584 struct bt_config *cfg;
bdc61c70 1585
db0f160a
PP		 1586 /* Create config */
1587 cfg = bt_config_base_create(BT_CONFIG_COMMAND_HELP,
1588 initial_plugin_paths, true);
1589 if (!cfg) {
1590 goto error;
1591 }
c42c79ea 1592
db0f160a
PP		 1593 cfg->cmd_data.help.cfg_component =
1594 bt_config_component_create(BT_COMPONENT_CLASS_TYPE_UNKNOWN,
1595 NULL, NULL);
1596 if (!cfg->cmd_data.help.cfg_component) {
1597 goto error;
c42c79ea
PP		 1598 }
1599
1600 goto end;
1601
1602error:
db0f160a 1603 BT_PUT(cfg);
c42c79ea
PP		 1604
1605end:
db0f160a 1606 return cfg;
c42c79ea
PP		 1607}
1608
db0f160a
PP		 1609static struct bt_config *bt_config_query_create(
1610 struct bt_value *initial_plugin_paths)
c42c79ea 1611{
db0f160a 1612 struct bt_config *cfg;
c42c79ea 1613
db0f160a
PP		 1614 /* Create config */
1615 cfg = bt_config_base_create(BT_CONFIG_COMMAND_QUERY,
1616 initial_plugin_paths, true);
1617 if (!cfg) {
1618 goto error;
c42c79ea
PP		 1619 }
1620
db0f160a
PP		 1621 cfg->cmd_data.query.object = g_string_new(NULL);
1622 if (!cfg->cmd_data.query.object) {
1623 print_err_oom();
1624 goto error;
c42c79ea
PP		 1625 }
1626
db0f160a 1627 goto end;
c42c79ea 1628
db0f160a
PP		 1629error:
1630 BT_PUT(cfg);
1631
1632end:
1633 return cfg;
c42c79ea
PP		 1634}
1635
db0f160a
PP		 1636static struct bt_config *bt_config_print_ctf_metadata_create(
1637 struct bt_value *initial_plugin_paths)
c42c79ea 1638{
db0f160a 1639 struct bt_config *cfg;
c42c79ea 1640
db0f160a
PP		 1641 /* Create config */
1642 cfg = bt_config_base_create(BT_CONFIG_COMMAND_PRINT_CTF_METADATA,
1643 initial_plugin_paths, true);
1644 if (!cfg) {
1645 goto error;
c42c79ea
PP		 1646 }
1647
db0f160a
PP		 1648 cfg->cmd_data.print_ctf_metadata.path = g_string_new(NULL);
1649 if (!cfg->cmd_data.print_ctf_metadata.path) {
1650 print_err_oom();
1651 goto error;
1652 }
c42c79ea 1653
db0f160a 1654 goto end;
c42c79ea 1655
db0f160a
PP		 1656error:
1657 BT_PUT(cfg);
c42c79ea
PP		 1658
1659end:
db0f160a 1660 return cfg;
c42c79ea
PP		 1661}
1662
db0f160a
PP		 1663static struct bt_config *bt_config_print_lttng_live_sessions_create(
1664 struct bt_value *initial_plugin_paths)
c42c79ea 1665{
db0f160a 1666 struct bt_config *cfg;
c42c79ea 1667
db0f160a
PP		 1668 /* Create config */
1669 cfg = bt_config_base_create(BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS,
1670 initial_plugin_paths, true);
1671 if (!cfg) {
1672 goto error;
1673 }
c42c79ea 1674
db0f160a
PP		 1675 cfg->cmd_data.print_lttng_live_sessions.url = g_string_new(NULL);
1676 if (!cfg->cmd_data.print_lttng_live_sessions.url) {
1677 print_err_oom();
1678 goto error;
c42c79ea
PP		 1679 }
1680
1681 goto end;
1682
1683error:
db0f160a 1684 BT_PUT(cfg);
c42c79ea
PP		 1685
1686end:
db0f160a 1687 return cfg;
c42c79ea
PP		 1688}
1689
db0f160a
PP		 1690int bt_config_append_plugin_paths_check_setuid_setgid(
1691 struct bt_value *plugin_paths, const char *arg)
c42c79ea 1692{
db0f160a 1693 int ret = 0;
c42c79ea 1694
db0f160a
PP		 1695 if (bt_common_is_setuid_setgid()) {
1696 printf_debug("Skipping non-system plugin paths for setuid/setgid binary\n");
c42c79ea
PP		 1697 goto end;
1698 }
1699
db0f160a
PP		 1700 if (bt_config_append_plugin_paths(plugin_paths, arg)) {
1701 printf_err("Invalid --plugin-path option's argument:\n %s\n",
1702 arg);
1703 ret = -1;
1704 goto end;
c42c79ea
PP		 1705 }
1706
db0f160a
PP		 1707end:
1708 return ret;
1709}
c42c79ea
PP		 1710
1711/*
db0f160a 1712 * Prints the expected format for a --params option.
c42c79ea
PP		 1713 */
1714static
db0f160a 1715void print_expected_params_format(FILE *fp)
c42c79ea 1716{
db0f160a
PP		 1717 fprintf(fp, "Expected format of PARAMS\n");
1718 fprintf(fp, "-------------------------\n");
1719 fprintf(fp, "\n");
1720 fprintf(fp, " PARAM=VALUE[,PARAM=VALUE]...\n");
1721 fprintf(fp, "\n");
1722 fprintf(fp, "The parameter string is a comma-separated list of PARAM=VALUE assignments,\n");
1723 fprintf(fp, "where PARAM is the parameter name (C identifier plus the [:.-] characters),\n");
1724 fprintf(fp, "and VALUE can be one of:\n");
1725 fprintf(fp, "\n");
1726 fprintf(fp, "* `null`, `nul`, `NULL`: null value (no backticks).\n");
1727 fprintf(fp, "* `true`, `TRUE`, `yes`, `YES`: true boolean value (no backticks).\n");
1728 fprintf(fp, "* `false`, `FALSE`, `no`, `NO`: false boolean value (no backticks).\n");
1729 fprintf(fp, "* Binary (`0b` prefix), octal (`0` prefix), decimal, or hexadecimal\n");
1730 fprintf(fp, " (`0x` prefix) signed 64-bit integer.\n");
1731 fprintf(fp, "* Double precision floating point number (scientific notation is accepted).\n");
1732 fprintf(fp, "* Unquoted string with no special characters, and not matching any of\n");
1733 fprintf(fp, " the null and boolean value symbols above.\n");
1734 fprintf(fp, "* Double-quoted string (accepts escape characters).\n");
1735 fprintf(fp, "\n");
1736 fprintf(fp, "You can put whitespaces allowed around individual `=` and `,` symbols.\n");
1737 fprintf(fp, "\n");
1738 fprintf(fp, "Example:\n");
1739 fprintf(fp, "\n");
1740 fprintf(fp, " many=null, fresh=yes, condition=false, squirrel=-782329,\n");
1741 fprintf(fp, " observe=3.14, simple=beef, needs-quotes=\"some string\",\n");
1742 fprintf(fp, " escape.chars-are:allowed=\"this is a \\\" double quote\"\n");
1743 fprintf(fp, "\n");
1744 fprintf(fp, "IMPORTANT: Make sure to single-quote the whole argument when you run babeltrace\n");
1745 fprintf(fp, "from a shell.\n");
1746}
c42c79ea 1747
c42c79ea 1748
db0f160a
PP		 1749/*
1750 * Prints the help command usage.
1751 */
1752static
1753void print_help_usage(FILE *fp)
1754{
1755 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] help [OPTIONS] PLUGIN\n");
1756 fprintf(fp, " babeltrace [GENERAL OPTIONS] help [OPTIONS] --source=PLUGIN.CLS\n");
1757 fprintf(fp, " babeltrace [GENERAL OPTIONS] help [OPTIONS] --filter=PLUGIN.CLS\n");
1758 fprintf(fp, " babeltrace [GENERAL OPTIONS] help [OPTIONS] --sink=PLUGIN.CLS\n");
1759 fprintf(fp, "\n");
1760 fprintf(fp, "Options:\n");
1761 fprintf(fp, "\n");
1762 fprintf(fp, " -f, --filter=PLUGIN.CLS Get help for the filter component class\n");
1763 fprintf(fp, " CLS found in the plugin PLUGIN\n");
1764 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
1765 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
1766 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
1767 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
1768 fprintf(fp, " dynamic plugins can be loaded\n");
1769 fprintf(fp, " -S, --sink=PLUGIN.CLS Get help for the sink component class\n");
1770 fprintf(fp, " CLS found in the plugin PLUGIN\n");
1771 fprintf(fp, " -s, --source=PLUGIN.CLS Get help for the source component class\n");
1772 fprintf(fp, " CLS found in the plugin PLUGIN\n");
1773 fprintf(fp, " -h --help Show this help and quit\n");
1774 fprintf(fp, "\n");
1775 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
1776 fprintf(fp, "\n");
1777 fprintf(fp, "Use `babeltrace list-plugins` to show the list of available plugins.\n");
c42c79ea
PP		 1778}
1779
db0f160a
PP		 1780static struct poptOption help_long_options[] = {
1781 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
1782 { "filter", 'f', POPT_ARG_STRING, NULL, OPT_FILTER, NULL, NULL },
1783 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
1784 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
1785 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
1786 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
1787 { "sink", 'S', POPT_ARG_STRING, NULL, OPT_SINK, NULL, NULL },
1788 { "source", 's', POPT_ARG_STRING, NULL, OPT_SOURCE, NULL, NULL },
1789 { NULL, 0, 0, NULL, 0, NULL, NULL },
1790};
1791
c42c79ea 1792/*
db0f160a
PP		 1793 * Creates a Babeltrace config object from the arguments of a help
1794 * command.
c42c79ea 1795 *
db0f160a 1796 * *retcode is set to the appropriate exit code to use.
c42c79ea
PP		 1797 */
1798static
db0f160a
PP		 1799struct bt_config *bt_config_help_from_args(int argc, const char *argv[],
1800 int *retcode, bool omit_system_plugin_path,
1801 bool omit_home_plugin_path,
1802 struct bt_value *initial_plugin_paths)
c42c79ea 1803{
db0f160a
PP		 1804 poptContext pc = NULL;
1805 char *arg = NULL;
1806 int opt;
1807 int ret;
1808 struct bt_config *cfg = NULL;
1809 const char *leftover;
1810 char *plugin_name = NULL, *comp_cls_name = NULL;
1811 char *plug_comp_cls_names = NULL;
c42c79ea 1812
db0f160a
PP		 1813 *retcode = 0;
1814 cfg = bt_config_help_create(initial_plugin_paths);
1815 if (!cfg) {
1816 goto error;
c42c79ea
PP		 1817 }
1818
db0f160a
PP		 1819 cfg->omit_system_plugin_path = omit_system_plugin_path;
1820 cfg->omit_home_plugin_path = omit_home_plugin_path;
1821 ret = append_env_var_plugin_paths(cfg->plugin_paths);
1822 if (ret) {
1823 goto error;
c42c79ea
PP		 1824 }
1825
db0f160a
PP		 1826 /* Parse options */
1827 pc = poptGetContext(NULL, argc, (const char **) argv,
1828 help_long_options, 0);
1829 if (!pc) {
1830 printf_err("Cannot get popt context\n");
1831 goto error;
1832 }
c42c79ea 1833
db0f160a
PP		 1834 poptReadDefaultConfig(pc, 0);
1835
1836 while ((opt = poptGetNextOpt(pc)) > 0) {
1837 arg = poptGetOptArg(pc);
1838
1839 switch (opt) {
1840 case OPT_PLUGIN_PATH:
1841 if (bt_config_append_plugin_paths_check_setuid_setgid(
1842 cfg->plugin_paths, arg)) {
1843 goto error;
1844 }
1845 break;
1846 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
1847 cfg->omit_system_plugin_path = true;
1848 break;
1849 case OPT_OMIT_HOME_PLUGIN_PATH:
1850 cfg->omit_home_plugin_path = true;
1851 break;
1852 case OPT_SOURCE:
1853 case OPT_FILTER:
1854 case OPT_SINK:
1855 if (cfg->cmd_data.help.cfg_component->type !=
1856 BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
1857 printf_err("Cannot specify more than one plugin and component class:\n %s\n",
1858 arg);
1859 goto error;
1860 }
1861
1862 switch (opt) {
1863 case OPT_SOURCE:
1864 cfg->cmd_data.help.cfg_component->type =
1865 BT_COMPONENT_CLASS_TYPE_SOURCE;
1866 break;
1867 case OPT_FILTER:
1868 cfg->cmd_data.help.cfg_component->type =
1869 BT_COMPONENT_CLASS_TYPE_FILTER;
c42c79ea 1870 break;
db0f160a
PP		 1871 case OPT_SINK:
1872 cfg->cmd_data.help.cfg_component->type =
1873 BT_COMPONENT_CLASS_TYPE_SINK;
c42c79ea
PP		 1874 break;
1875 default:
1876 assert(false);
1877 }
db0f160a
PP		 1878 plug_comp_cls_names = strdup(arg);
1879 if (!plug_comp_cls_names) {
1880 print_err_oom();
1881 goto error;
05a67631 1882 }
db0f160a
PP		 1883 break;
1884 case OPT_HELP:
1885 print_help_usage(stdout);
1886 *retcode = -1;
1887 BT_PUT(cfg);
1888 goto end;
1889 default:
1890 printf_err("Unknown command-line option specified (option code %d)\n",
1891 opt);
c42c79ea
PP		 1892 goto error;
1893 }
c42c79ea 1894
db0f160a
PP		 1895 free(arg);
1896 arg = NULL;
1897 }
05a67631 1898
db0f160a
PP		 1899 /* Check for option parsing error */
1900 if (opt < -1) {
1901 printf_err("While parsing command-line options, at option %s: %s\n",
1902 poptBadOption(pc, 0), poptStrerror(opt));
1903 goto error;
1904 }
05a67631 1905
db0f160a
PP		 1906 leftover = poptGetArg(pc);
1907 if (leftover) {
1908 if (cfg->cmd_data.help.cfg_component->type !=
1909 BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
1910 printf_err("Cannot specify plugin name and --source/--filter/--sink component class:\n %s\n",
1911 leftover);
05a67631
PP		 1912 goto error;
1913 }
1914
db0f160a
PP		 1915 g_string_assign(cfg->cmd_data.help.cfg_component->plugin_name,
1916 leftover);
1917 } else {
1918 if (cfg->cmd_data.help.cfg_component->type ==
1919 BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
1920 print_help_usage(stdout);
1921 *retcode = -1;
1922 BT_PUT(cfg);
1923 goto end;
c42c79ea
PP		 1924 }
1925
db0f160a
PP		 1926 plugin_comp_cls_names(plug_comp_cls_names, NULL,
1927 &plugin_name, &comp_cls_name);
1928 if (plugin_name && comp_cls_name) {
1929 g_string_assign(cfg->cmd_data.help.cfg_component->plugin_name,
1930 plugin_name);
1931 g_string_assign(cfg->cmd_data.help.cfg_component->comp_cls_name,
1932 comp_cls_name);
1933 } else {
1934 printf_err("Invalid --source/--filter/--sink option's argument:\n %s\n",
1935 plug_comp_cls_names);
c42c79ea
PP		 1936 goto error;
1937 }
db0f160a 1938 }
c42c79ea 1939
db0f160a
PP		 1940 if (append_home_and_system_plugin_paths_cfg(cfg)) {
1941 goto error;
c42c79ea
PP		 1942 }
1943
db0f160a 1944 goto end;
c42c79ea
PP		 1945
1946error:
db0f160a
PP		 1947 *retcode = 1;
1948 BT_PUT(cfg);
1949
1950end:
1951 free(plug_comp_cls_names);
1952 g_free(plugin_name);
1953 g_free(comp_cls_name);
1954
1955 if (pc) {
1956 poptFreeContext(pc);
1957 }
1958
1959 free(arg);
1960 return cfg;
c42c79ea
PP		 1961}
1962
1963/*
db0f160a 1964 * Prints the help command usage.
c42c79ea
PP		 1965 */
1966static
db0f160a 1967void print_query_usage(FILE *fp)
c42c79ea 1968{
db0f160a
PP		 1969 fprintf(fp, "Usage: babeltrace [GEN OPTS] query [OPTS] OBJECT --source=PLUGIN.CLS\n");
1970 fprintf(fp, " babeltrace [GEN OPTS] query [OPTS] OBJECT --filter=PLUGIN.CLS\n");
1971 fprintf(fp, " babeltrace [GEN OPTS] query [OPTS] OBJECT --sink=PLUGIN.CLS\n");
1972 fprintf(fp, "\n");
1973 fprintf(fp, "Options:\n");
1974 fprintf(fp, "\n");
1975 fprintf(fp, " -f. --filter=PLUGIN.CLS Query object from the filter component\n");
1976 fprintf(fp, " class CLS found in the plugin PLUGIN\n");
1977 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
1978 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
1979 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
1980 fprintf(fp, " -p, --params=PARAMS Set the query parameters to PARAMS\n");
1981 fprintf(fp, " (see the expected format of PARAMS below)\n");
1982 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
1983 fprintf(fp, " dynamic plugins can be loaded\n");
1984 fprintf(fp, " -S, --sink=PLUGIN.CLS Query object from the sink component class\n");
1985 fprintf(fp, " CLS found in the plugin PLUGIN\n");
1986 fprintf(fp, " -s, --source=PLUGIN.CLS Query object from the source component\n");
1987 fprintf(fp, " class CLS found in the plugin PLUGIN\n");
1988 fprintf(fp, " -h --help Show this help and quit\n");
1989 fprintf(fp, "\n\n");
1990 print_expected_params_format(fp);
1991}
c42c79ea 1992
db0f160a
PP		 1993static struct poptOption query_long_options[] = {
1994 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
1995 { "filter", 'f', POPT_ARG_STRING, NULL, OPT_FILTER, NULL, NULL },
1996 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
1997 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
1998 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
1999 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2000 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2001 { "sink", 'S', POPT_ARG_STRING, NULL, OPT_SINK, NULL, NULL },
2002 { "source", 's', POPT_ARG_STRING, NULL, OPT_SOURCE, NULL, NULL },
2003 { NULL, 0, 0, NULL, 0, NULL, NULL },
2004};
c42c79ea 2005
db0f160a
PP		 2006/*
2007 * Creates a Babeltrace config object from the arguments of a query
2008 * command.
2009 *
2010 * *retcode is set to the appropriate exit code to use.
2011 */
2012static
2013struct bt_config *bt_config_query_from_args(int argc, const char *argv[],
2014 int *retcode, bool omit_system_plugin_path,
2015 bool omit_home_plugin_path,
2016 struct bt_value *initial_plugin_paths)
2017{
2018 poptContext pc = NULL;
2019 char *arg = NULL;
2020 int opt;
2021 int ret;
2022 struct bt_config *cfg = NULL;
2023 const char *leftover;
2024 struct bt_value *params = bt_value_null;
2025
2026 *retcode = 0;
2027 cfg = bt_config_query_create(initial_plugin_paths);
2028 if (!cfg) {
2029 goto error;
2030 }
2031
2032 cfg->omit_system_plugin_path =
2033 omit_system_plugin_path;
2034 cfg->omit_home_plugin_path = omit_home_plugin_path;
2035 ret = append_env_var_plugin_paths(cfg->plugin_paths);
2036 if (ret) {
2037 goto error;
2038 }
2039
2040 /* Parse options */
2041 pc = poptGetContext(NULL, argc, (const char **) argv,
2042 query_long_options, 0);
2043 if (!pc) {
2044 printf_err("Cannot get popt context\n");
2045 goto error;
2046 }
2047
2048 poptReadDefaultConfig(pc, 0);
2049
2050 while ((opt = poptGetNextOpt(pc)) > 0) {
2051 arg = poptGetOptArg(pc);
2052
2053 switch (opt) {
2054 case OPT_PLUGIN_PATH:
2055 if (bt_config_append_plugin_paths_check_setuid_setgid(
2056 cfg->plugin_paths, arg)) {
2057 goto error;
2058 }
2059 break;
2060 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2061 cfg->omit_system_plugin_path = true;
2062 break;
2063 case OPT_OMIT_HOME_PLUGIN_PATH:
2064 cfg->omit_home_plugin_path = true;
2065 break;
2066 case OPT_SOURCE:
2067 case OPT_FILTER:
2068 case OPT_SINK:
2069 {
2070 enum bt_component_class_type type;
2071
2072 if (cfg->cmd_data.query.cfg_component) {
2073 printf_err("Cannot specify more than one plugin and component class:\n %s\n",
2074 arg);
2075 goto error;
2076 }
2077
2078 switch (opt) {
2079 case OPT_SOURCE:
2080 type = BT_COMPONENT_CLASS_TYPE_SOURCE;
2081 break;
2082 case OPT_FILTER:
2083 type = BT_COMPONENT_CLASS_TYPE_FILTER;
2084 break;
2085 case OPT_SINK:
2086 type = BT_COMPONENT_CLASS_TYPE_SINK;
2087 break;
2088 default:
2089 assert(false);
2090 }
2091
2092 cfg->cmd_data.query.cfg_component =
2093 bt_config_component_from_arg(type, arg);
2094 if (!cfg->cmd_data.query.cfg_component) {
2095 printf_err("Invalid format for --source/--filter/--sink option's argument:\n %s\n",
2096 arg);
2097 goto error;
2098 }
2099
2100 /* Default parameters: null */
2101 bt_put(cfg->cmd_data.query.cfg_component->params);
2102 cfg->cmd_data.query.cfg_component->params =
2103 bt_value_null;
2104 break;
2105 }
2106 case OPT_PARAMS:
2107 {
2108 params = bt_value_from_arg(arg);
2109 if (!params) {
2110 printf_err("Invalid format for --params option's argument:\n %s\n",
2111 arg);
2112 goto error;
2113 }
2114 break;
2115 }
2116 case OPT_HELP:
2117 print_query_usage(stdout);
2118 *retcode = -1;
2119 BT_PUT(cfg);
2120 goto end;
2121 default:
2122 printf_err("Unknown command-line option specified (option code %d)\n",
2123 opt);
2124 goto error;
2125 }
2126
2127 free(arg);
2128 arg = NULL;
2129 }
2130
2131 if (!cfg->cmd_data.query.cfg_component) {
2132 printf_err("No target component class specified with --source/--filter/--sink option\n");
2133 goto error;
2134 }
2135
2136 assert(params);
2137 BT_MOVE(cfg->cmd_data.query.cfg_component->params, params);
2138
2139 /* Check for option parsing error */
2140 if (opt < -1) {
2141 printf_err("While parsing command-line options, at option %s: %s\n",
2142 poptBadOption(pc, 0), poptStrerror(opt));
2143 goto error;
2144 }
2145
2146 /*
2147 * We need exactly one leftover argument which is the
2148 * mandatory object.
2149 */
2150 leftover = poptGetArg(pc);
2151 if (leftover) {
2152 if (strlen(leftover) == 0) {
2153 printf_err("Invalid empty object\n");
2154 goto error;
2155 }
2156
2157 g_string_assign(cfg->cmd_data.query.object, leftover);
2158 } else {
2159 print_query_usage(stdout);
2160 *retcode = -1;
2161 BT_PUT(cfg);
2162 goto end;
2163 }
2164
2165 leftover = poptGetArg(pc);
2166 if (leftover) {
2167 printf_err("Unexpected argument: %s\n", leftover);
2168 goto error;
2169 }
2170
2171 if (append_home_and_system_plugin_paths_cfg(cfg)) {
2172 goto error;
2173 }
2174
2175 goto end;
2176
2177error:
2178 *retcode = 1;
2179 BT_PUT(cfg);
2180
2181end:
2182 if (pc) {
2183 poptFreeContext(pc);
2184 }
2185
2186 BT_PUT(params);
2187 free(arg);
2188 return cfg;
c42c79ea
PP		 2189}
2190
db0f160a
PP		 2191/*
2192 * Prints the list-plugins command usage.
2193 */
2194static
2195void print_list_plugins_usage(FILE *fp)
2196{
2197 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] list-plugins [OPTIONS]\n");
2198 fprintf(fp, "\n");
2199 fprintf(fp, "Options:\n");
2200 fprintf(fp, "\n");
2201 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
2202 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
2203 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
2204 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
2205 fprintf(fp, " dynamic plugins can be loaded\n");
2206 fprintf(fp, " -h --help Show this help and quit\n");
2207 fprintf(fp, "\n");
2208 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2209 fprintf(fp, "\n");
2210 fprintf(fp, "Use `babeltrace help` to get help for a specific plugin or component class.\n");
2211}
2212
2213static struct poptOption list_plugins_long_options[] = {
2214 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2215 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2216 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2217 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2218 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2219 { NULL, 0, 0, NULL, 0, NULL, NULL },
c42c79ea
PP		 2220};
2221
db0f160a
PP		 2222/*
2223 * Creates a Babeltrace config object from the arguments of a
2224 * list-plugins command.
2225 *
2226 * *retcode is set to the appropriate exit code to use.
2227 */
2228static
2229struct bt_config *bt_config_list_plugins_from_args(int argc, const char *argv[],
2230 int *retcode, bool omit_system_plugin_path,
2231 bool omit_home_plugin_path,
2232 struct bt_value *initial_plugin_paths)
2233{
2234 poptContext pc = NULL;
2235 char *arg = NULL;
2236 int opt;
2237 int ret;
2238 struct bt_config *cfg = NULL;
2239 const char *leftover;
2240
2241 *retcode = 0;
2242 cfg = bt_config_list_plugins_create(initial_plugin_paths);
2243 if (!cfg) {
2244 goto error;
2245 }
2246
2247 cfg->omit_system_plugin_path = omit_system_plugin_path;
2248 cfg->omit_home_plugin_path = omit_home_plugin_path;
2249 ret = append_env_var_plugin_paths(cfg->plugin_paths);
2250 if (ret) {
2251 goto error;
2252 }
2253
2254 /* Parse options */
2255 pc = poptGetContext(NULL, argc, (const char **) argv,
2256 list_plugins_long_options, 0);
2257 if (!pc) {
2258 printf_err("Cannot get popt context\n");
2259 goto error;
2260 }
2261
2262 poptReadDefaultConfig(pc, 0);
2263
2264 while ((opt = poptGetNextOpt(pc)) > 0) {
2265 arg = poptGetOptArg(pc);
c42c79ea 2266
db0f160a
PP		 2267 switch (opt) {
2268 case OPT_PLUGIN_PATH:
2269 if (bt_config_append_plugin_paths_check_setuid_setgid(
2270 cfg->plugin_paths, arg)) {
2271 goto error;
2272 }
2273 break;
2274 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2275 cfg->omit_system_plugin_path = true;
2276 break;
2277 case OPT_OMIT_HOME_PLUGIN_PATH:
2278 cfg->omit_home_plugin_path = true;
2279 break;
2280 case OPT_HELP:
2281 print_list_plugins_usage(stdout);
2282 *retcode = -1;
2283 BT_PUT(cfg);
2284 goto end;
2285 default:
2286 printf_err("Unknown command-line option specified (option code %d)\n",
2287 opt);
2288 goto error;
2289 }
bdc61c70 2290
db0f160a
PP		 2291 free(arg);
2292 arg = NULL;
bdc61c70 2293 }
0f9915c6 2294
db0f160a
PP		 2295 /* Check for option parsing error */
2296 if (opt < -1) {
2297 printf_err("While parsing command-line options, at option %s: %s\n",
2298 poptBadOption(pc, 0), poptStrerror(opt));
2299 goto error;
2300 }
5a3ee633 2301
db0f160a
PP		 2302 leftover = poptGetArg(pc);
2303 if (leftover) {
2304 printf_err("Unexpected argument: %s\n", leftover);
2305 goto error;
5a3ee633
PP		 2306 }
2307
db0f160a
PP		 2308 if (append_home_and_system_plugin_paths_cfg(cfg)) {
2309 goto error;
5a3ee633
PP		 2310 }
2311
db0f160a
PP		 2312 goto end;
2313
2314error:
2315 *retcode = 1;
2316 BT_PUT(cfg);
5a3ee633
PP		 2317
2318end:
db0f160a
PP		 2319 if (pc) {
2320 poptFreeContext(pc);
2321 }
2322
2323 free(arg);
2324 return cfg;
5a3ee633
PP		 2325}
2326
db0f160a
PP		 2327/*
2328 * Prints the run command usage.
2329 */
2330static
2331void print_run_usage(FILE *fp)
98ecef32 2332{
db0f160a
PP		 2333 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] run [OPTIONS]\n");
2334 fprintf(fp, "\n");
2335 fprintf(fp, "Options:\n");
2336 fprintf(fp, "\n");
2337 fprintf(fp, " -b, --base-params=PARAMS Set PARAMS as the current base parameters\n");
2338 fprintf(fp, " for all the following components until\n");
2339 fprintf(fp, " --reset-base-params is encountered\n");
2340 fprintf(fp, " (see the expected format of PARAMS below)\n");
2341 fprintf(fp, " -c, --connect=CONNECTION Connect two created components (see the\n");
2342 fprintf(fp, " expected format of CONNECTION below)\n");
2343 fprintf(fp, " -f, --filter=[NAME:]PLUGIN.CLS Instantiate a filter component from plugin\n");
2344 fprintf(fp, " PLUGIN and component class CLS, set it as\n");
2345 fprintf(fp, " the current component, and if NAME is\n");
2346 fprintf(fp, " given, set its instance name to NAME\n");
2347 fprintf(fp, " --key=KEY Set the current initialization string\n");
2348 fprintf(fp, " parameter key to KEY (see --value)\n");
2349 fprintf(fp, " -n, --name=NAME Set the name of the current component\n");
2350 fprintf(fp, " to NAME (must be unique amongst all the\n");
2351 fprintf(fp, " names of the created components)\n");
2352 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
2353 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
2354 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
2355 fprintf(fp, " -p, --params=PARAMS Add initialization parameters PARAMS to the\n");
2356 fprintf(fp, " current component (see the expected format\n");
2357 fprintf(fp, " of PARAMS below)\n");
2358 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
2359 fprintf(fp, " dynamic plugins can be loaded\n");
2360 fprintf(fp, " -r, --reset-base-params Reset the current base parameters to an\n");
2361 fprintf(fp, " empty map\n");
2362 fprintf(fp, " -S, --sink=[NAME:]PLUGIN.CLS Instantiate a sink component from plugin\n");
2363 fprintf(fp, " PLUGIN and component class CLS, set it as\n");
2364 fprintf(fp, " the current component, and if NAME is\n");
2365 fprintf(fp, " given, set its instance name to NAME\n");
2366 fprintf(fp, " -s, --source=[NAME:]PLUGIN.CLS Instantiate a source component from plugin\n");
2367 fprintf(fp, " PLUGIN and component class CLS, set it as\n");
2368 fprintf(fp, " the current component, and if NAME is\n");
2369 fprintf(fp, " given, set its instance name to NAME\n");
2370 fprintf(fp, " --value=VAL Add a string initialization parameter to\n");
2371 fprintf(fp, " the current component with a name given by\n");
2372 fprintf(fp, " the last argument of the --key option and a\n");
2373 fprintf(fp, " value set to VAL\n");
2374 fprintf(fp, " -h --help Show this help and quit\n");
2375 fprintf(fp, "\n");
2376 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2377 fprintf(fp, "\n\n");
2378 fprintf(fp, "Expected format of CONNECTION\n");
2379 fprintf(fp, "-----------------------------\n");
2380 fprintf(fp, "\n");
2381 fprintf(fp, " UPSTREAM[.UPSTREAM-PORT]:DOWNSTREAM[.DOWNSTREAM-PORT]\n");
2382 fprintf(fp, "\n");
2383 fprintf(fp, "UPSTREAM and DOWNSTREAM are the names of the upstream and downstream components\n");
2384 fprintf(fp, "to connect together. You can set the name of the current component with the\n");
2385 fprintf(fp, "--name option.\n");
2386 fprintf(fp, "\n");
2387 fprintf(fp, "UPSTREAM-PORT and DOWNSTREAM-PORT are the optional upstream and downstream\n");
2388 fprintf(fp, "ports to use for the connection. When the port is not specified, the default\n");
2389 fprintf(fp, "port is used.\n");
2390 fprintf(fp, "\n");
2391 fprintf(fp, "You can connect a source component to a filter or sink component. You\n");
2392 fprintf(fp, "can connect a filter component to a sink component.\n");
2393 fprintf(fp, "\n");
2394 fprintf(fp, "Example:\n");
2395 fprintf(fp, "\n");
2396 fprintf(fp, " my-filter.top10:json-out\n");
2397 fprintf(fp, "\n\n");
2398 print_expected_params_format(fp);
2399}
98ecef32 2400
db0f160a
PP		 2401static struct poptOption run_long_options[] = {
2402 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2403 { "base-params", 'b', POPT_ARG_STRING, NULL, OPT_BASE_PARAMS, NULL, NULL },
2404 { "connect", 'c', POPT_ARG_STRING, NULL, OPT_CONNECT, NULL, NULL },
2405 { "filter", 'f', POPT_ARG_STRING, NULL, OPT_FILTER, NULL, NULL },
2406 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2407 { "key", '\0', POPT_ARG_STRING, NULL, OPT_KEY, NULL, NULL },
2408 { "name", 'n', POPT_ARG_STRING, NULL, OPT_NAME, NULL, NULL },
2409 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2410 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2411 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2412 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2413 { "reset-base-params", 'r', POPT_ARG_NONE, NULL, OPT_RESET_BASE_PARAMS, NULL, NULL },
2414 { "sink", 'S', POPT_ARG_STRING, NULL, OPT_SINK, NULL, NULL },
2415 { "source", 's', POPT_ARG_STRING, NULL, OPT_SOURCE, NULL, NULL },
2416 { "value", '\0', POPT_ARG_STRING, NULL, OPT_VALUE, NULL, NULL },
2417 { NULL, 0, 0, NULL, 0, NULL, NULL },
2418};
1670bffd 2419
db0f160a
PP		 2420/*
2421 * Creates a Babeltrace config object from the arguments of a run
2422 * command.
2423 *
2424 * *retcode is set to the appropriate exit code to use.
2425 */
2426static
2427struct bt_config *bt_config_run_from_args(int argc, const char *argv[],
2428 int *retcode, bool omit_system_plugin_path,
2429 bool omit_home_plugin_path,
2430 struct bt_value *initial_plugin_paths)
2431{
2432 poptContext pc = NULL;
2433 char *arg = NULL;
2434 struct bt_config_component *cur_cfg_comp = NULL;
2435 enum bt_config_component_dest cur_cfg_comp_dest;
2436 struct bt_value *cur_base_params = NULL;
2437 int opt, ret = 0;
2438 struct bt_config *cfg = NULL;
2439 struct bt_value *instance_names = NULL;
2440 struct bt_value *connection_args = NULL;
2441 GString *cur_param_key = NULL;
2442 char error_buf[256] = { 0 };
1670bffd 2443
db0f160a
PP		 2444 *retcode = 0;
2445 cur_param_key = g_string_new(NULL);
2446 if (!cur_param_key) {
2447 print_err_oom();
2448 goto error;
98ecef32
MD		 2449 }
2450
db0f160a
PP		 2451 if (argc <= 1) {
2452 print_run_usage(stdout);
2453 *retcode = -1;
2454 goto end;
98ecef32 2455 }
98ecef32 2456
db0f160a
PP		 2457 cfg = bt_config_run_create(initial_plugin_paths);
2458 if (!cfg) {
2459 goto error;
2460 }
bd9f0fa2 2461
db0f160a
PP		 2462 cfg->omit_system_plugin_path = omit_system_plugin_path;
2463 cfg->omit_home_plugin_path = omit_home_plugin_path;
2464 cur_base_params = bt_value_map_create();
2465 if (!cur_base_params) {
2466 print_err_oom();
2467 goto error;
bd9f0fa2 2468 }
bd9f0fa2 2469
db0f160a
PP		 2470 instance_names = bt_value_map_create();
2471 if (!instance_names) {
2472 print_err_oom();
2473 goto error;
2474 }
c1870f57 2475
db0f160a
PP		 2476 connection_args = bt_value_array_create();
2477 if (!connection_args) {
c1870f57
JG		 2478 print_err_oom();
2479 goto error;
2480 }
2481
db0f160a
PP		 2482 ret = append_env_var_plugin_paths(cfg->plugin_paths);
2483 if (ret) {
2484 goto error;
2485 }
c1870f57 2486
db0f160a
PP		 2487 /* Parse options */
2488 pc = poptGetContext(NULL, argc, (const char **) argv,
2489 run_long_options, 0);
2490 if (!pc) {
2491 printf_err("Cannot get popt context\n");
2492 goto error;
2493 }
2494
2495 poptReadDefaultConfig(pc, 0);
2496
2497 while ((opt = poptGetNextOpt(pc)) > 0) {
2498 arg = poptGetOptArg(pc);
2499
2500 switch (opt) {
2501 case OPT_PLUGIN_PATH:
2502 if (bt_config_append_plugin_paths_check_setuid_setgid(
2503 cfg->plugin_paths, arg)) {
2504 goto error;
2505 }
2506 break;
2507 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2508 cfg->omit_system_plugin_path = true;
2509 break;
2510 case OPT_OMIT_HOME_PLUGIN_PATH:
2511 cfg->omit_home_plugin_path = true;
2512 break;
2513 case OPT_SOURCE:
2514 case OPT_FILTER:
2515 case OPT_SINK:
2516 {
2517 enum bt_component_class_type new_comp_type;
2518 enum bt_config_component_dest new_dest;
2519 const char *opt_name;
2520
2521 switch (opt) {
2522 case OPT_SOURCE:
2523 new_comp_type = BT_COMPONENT_CLASS_TYPE_SOURCE;
2524 new_dest = BT_CONFIG_COMPONENT_DEST_SOURCE;
2525 opt_name = "--source";
2526 break;
2527 case OPT_FILTER:
2528 new_comp_type = BT_COMPONENT_CLASS_TYPE_FILTER;
2529 new_dest = BT_CONFIG_COMPONENT_DEST_FILTER;
2530 opt_name = "--filter";
2531 break;
2532 case OPT_SINK:
2533 new_comp_type = BT_COMPONENT_CLASS_TYPE_SINK;
2534 new_dest = BT_CONFIG_COMPONENT_DEST_SINK;
2535 opt_name = "--sink";
2536 break;
2537 default:
2538 assert(false);
2539 }
c1870f57 2540
db0f160a
PP		 2541 if (cur_cfg_comp) {
2542 ret = add_run_cfg_comp_check_name(cfg,
2543 cur_cfg_comp, cur_cfg_comp_dest,
2544 instance_names);
2545 BT_PUT(cur_cfg_comp);
2546 if (ret) {
2547 goto error;
2548 }
2549 }
c1870f57 2550
db0f160a
PP		 2551 cur_cfg_comp = bt_config_component_from_arg(
2552 new_comp_type, arg);
2553 if (!cur_cfg_comp) {
2554 printf_err("Invalid format for %s option's argument:\n %s\n",
2555 opt_name, arg);
2556 goto error;
2557 }
c42c79ea 2558
db0f160a
PP		 2559 assert(cur_base_params);
2560 bt_put(cur_cfg_comp->params);
2561 cur_cfg_comp->params = bt_value_copy(cur_base_params);
2562 if (!cur_cfg_comp->params) {
2563 print_err_oom();
2564 goto error;
2565 }
c42c79ea 2566
db0f160a
PP		 2567 cur_cfg_comp_dest = new_dest;
2568 break;
2569 }
2570 case OPT_PARAMS:
2571 {
2572 struct bt_value *params;
2573 struct bt_value *params_to_set;
c42c79ea 2574
db0f160a
PP		 2575 if (!cur_cfg_comp) {
2576 printf_err("Cannot add parameters to unavailable component:\n %s\n",
2577 arg);
2578 goto error;
2579 }
ebba3338 2580
db0f160a
PP		 2581 params = bt_value_from_arg(arg);
2582 if (!params) {
2583 printf_err("Invalid format for --params option's argument:\n %s\n",
2584 arg);
2585 goto error;
2586 }
c42c79ea 2587
db0f160a
PP		 2588 params_to_set = bt_value_map_extend(cur_cfg_comp->params,
2589 params);
2590 BT_PUT(params);
2591 if (!params_to_set) {
2592 printf_err("Cannot extend current component parameters with --params option's argument:\n %s\n",
2593 arg);
2594 goto error;
2595 }
ebba3338 2596
db0f160a
PP		 2597 BT_MOVE(cur_cfg_comp->params, params_to_set);
2598 break;
290725f7 2599 }
db0f160a
PP		 2600 case OPT_KEY:
2601 if (strlen(arg) == 0) {
2602 printf_err("Cannot set an empty string as the current parameter key\n");
2603 goto error;
2604 }
b07ffa28 2605
db0f160a
PP		 2606 g_string_assign(cur_param_key, arg);
2607 break;
2608 case OPT_VALUE:
2609 if (!cur_cfg_comp) {
2610 printf_err("Cannot set a parameter's value of unavailable component:\n %s\n",
2611 arg);
2612 goto error;
2613 }
c42c79ea 2614
db0f160a
PP		 2615 if (cur_param_key->len == 0) {
2616 printf_err("--value option specified without preceding --key option:\n %s\n",
2617 arg);
2618 goto error;
2619 }
290725f7 2620
db0f160a
PP		 2621 if (bt_value_map_insert_string(cur_cfg_comp->params,
2622 cur_param_key->str, arg)) {
2623 print_err_oom();
2624 goto error;
2625 }
2626 break;
2627 case OPT_NAME:
2628 if (!cur_cfg_comp) {
2629 printf_err("Cannot set the name of unavailable component:\n %s\n",
2630 arg);
2631 goto error;
2632 }
290725f7 2633
db0f160a
PP		 2634 g_string_assign(cur_cfg_comp->instance_name, arg);
2635 break;
2636 case OPT_BASE_PARAMS:
2637 {
2638 struct bt_value *params = bt_value_from_arg(arg);
290725f7 2639
db0f160a
PP		 2640 if (!params) {
2641 printf_err("Invalid format for --base-params option's argument:\n %s\n",
2642 arg);
2643 goto error;
2644 }
5a3ee633 2645
db0f160a
PP		 2646 BT_MOVE(cur_base_params, params);
2647 break;
2648 }
2649 case OPT_RESET_BASE_PARAMS:
2650 BT_PUT(cur_base_params);
2651 cur_base_params = bt_value_map_create();
2652 if (!cur_base_params) {
2653 print_err_oom();
2654 goto error;
2655 }
2656 break;
2657 case OPT_CONNECT:
2658 if (bt_value_array_append_string(connection_args,
2659 arg)) {
2660 print_err_oom();
2661 goto error;
2662 }
2663 break;
2664 case OPT_HELP:
2665 print_run_usage(stdout);
2666 *retcode = -1;
2667 BT_PUT(cfg);
2668 goto end;
2669 default:
2670 printf_err("Unknown command-line option specified (option code %d)\n",
2671 opt);
290725f7
PP		 2672 goto error;
2673 }
290725f7 2674
db0f160a
PP		 2675 free(arg);
2676 arg = NULL;
2677 }
290725f7 2678
db0f160a
PP		 2679 /* Check for option parsing error */
2680 if (opt < -1) {
2681 printf_err("While parsing command-line options, at option %s: %s\n",
2682 poptBadOption(pc, 0), poptStrerror(opt));
2683 goto error;
2684 }
22e22462 2685
db0f160a
PP		 2686 /* This command does not accept leftover arguments */
2687 if (poptPeekArg(pc)) {
2688 printf_err("Unexpected argument: %s\n", poptPeekArg(pc));
22e22462
PP		 2689 goto error;
2690 }
2691
db0f160a
PP		 2692 /* Add current component */
2693 if (cur_cfg_comp) {
2694 ret = add_run_cfg_comp_check_name(cfg, cur_cfg_comp,
2695 cur_cfg_comp_dest, instance_names);
2696 BT_PUT(cur_cfg_comp);
2697 if (ret) {
22e22462
PP		 2698 goto error;
2699 }
2700 }
2701
db0f160a
PP		 2702 if (cfg->cmd_data.run.sources->len == 0) {
2703 printf_err("Incomplete graph: no source component\n");
22e22462
PP		 2704 goto error;
2705 }
2706
db0f160a
PP		 2707 if (cfg->cmd_data.run.sinks->len == 0) {
2708 printf_err("Incomplete graph: no sink component\n");
63ce0e1d
PP		 2709 goto error;
2710 }
2711
db0f160a
PP		 2712 if (append_home_and_system_plugin_paths_cfg(cfg)) {
2713 goto error;
63ce0e1d
PP		 2714 }
2715
db0f160a
PP		 2716 ret = bt_config_create_connections(cfg, connection_args,
2717 error_buf, 256);
2718 if (ret) {
2719 printf_err("Cannot creation connections:\n%s", error_buf);
63ce0e1d
PP		 2720 goto error;
2721 }
2722
2723 goto end;
2724
2725error:
db0f160a 2726 *retcode = 1;
63ce0e1d
PP		 2727 BT_PUT(cfg);
2728
2729end:
db0f160a
PP		 2730 if (pc) {
2731 poptFreeContext(pc);
2732 }
2733
2734 if (cur_param_key) {
2735 g_string_free(cur_param_key, TRUE);
2736 }
2737
2738 free(arg);
2739 BT_PUT(cur_cfg_comp);
2740 BT_PUT(cur_base_params);
2741 BT_PUT(instance_names);
2742 BT_PUT(connection_args);
63ce0e1d
PP		 2743 return cfg;
2744}
2745
63ce0e1d 2746static
db0f160a
PP		 2747struct bt_config *bt_config_run_from_args_array(struct bt_value *run_args,
2748 int *retcode, bool omit_system_plugin_path,
2749 bool omit_home_plugin_path,
2750 struct bt_value *initial_plugin_paths)
2751{
2752 struct bt_config *cfg = NULL;
2753 const char **argv;
2754 size_t i;
2755 const size_t argc = bt_value_array_size(run_args) + 1;
2756
2757 argv = calloc(argc, sizeof(*argv));
2758 if (!argv) {
2759 print_err_oom();
2760 goto end;
2761 }
63ce0e1d 2762
db0f160a
PP		 2763 argv[0] = "run";
2764
2765 for (i = 0; i < bt_value_array_size(run_args); i++) {
2766 int ret;
2767 struct bt_value *arg_value = bt_value_array_get(run_args, i);
2768 const char *arg;
2769
2770 assert(arg_value);
2771 ret = bt_value_string_get(arg_value, &arg);
2772 assert(ret == 0);
2773 assert(arg);
2774 argv[i + 1] = arg;
2775 bt_put(arg_value);
2776 }
2777
2778 cfg = bt_config_run_from_args(argc, argv, retcode,
2779 omit_system_plugin_path, omit_home_plugin_path,
2780 initial_plugin_paths);
2781
2782end:
2783 free(argv);
2784 return cfg;
2785}
63ce0e1d 2786
22e22462 2787/*
db0f160a 2788 * Prints the convert command usage.
22e22462
PP		 2789 */
2790static
db0f160a 2791void print_convert_usage(FILE *fp)
22e22462 2792{
db0f160a 2793 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] [convert] [OPTIONS] [PATH/URL]\n");
22e22462
PP		 2794 fprintf(fp, "\n");
2795 fprintf(fp, "Options:\n");
2796 fprintf(fp, "\n");
db0f160a
PP		 2797 fprintf(fp, " --filter=[NAME:]PLUGIN.CLS Instantiate a filter component from plugin\n");
2798 fprintf(fp, " PLUGIN and component class CLS, set it as\n");
2799 fprintf(fp, " the current component, and if NAME is\n");
2800 fprintf(fp, " given, set its instance name to NAME\n");
2801 fprintf(fp, " --name=NAME Set the name of the current component\n");
2802 fprintf(fp, " to NAME (must be unique amongst all the\n");
2803 fprintf(fp, " names of the created components)\n");
22e22462
PP		 2804 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
2805 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
2806 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
db0f160a
PP		 2807 fprintf(fp, " -p, --params=PARAMS Add initialization parameters PARAMS to the\n");
2808 fprintf(fp, " current component (see the expected format\n");
2809 fprintf(fp, " of PARAMS below)\n");
2810 fprintf(fp, " -P, --path=PATH Set the `path` string parameter of the\n");
2811 fprintf(fp, " current component to PATH\n");
22e22462
PP		 2812 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
2813 fprintf(fp, " dynamic plugins can be loaded\n");
db0f160a
PP		 2814 fprintf(fp, " --run-args Print the equivalent arguments for the\n");
2815 fprintf(fp, " `run` command to the standard output,\n");
2816 fprintf(fp, " formatted for a shell, and quit\n");
2817 fprintf(fp, " --run-args-0 Print the equivalent arguments for the\n");
2818 fprintf(fp, " `run` command to the standard output,\n");
2819 fprintf(fp, " formatted for `xargs -0`, and quit\n");
2820 fprintf(fp, " --sink=[NAME:]PLUGIN.CLS Instantiate a sink component from plugin\n");
2821 fprintf(fp, " PLUGIN and component class CLS, set it as\n");
2822 fprintf(fp, " the current component, and if NAME is\n");
2823 fprintf(fp, " given, set its instance name to NAME\n");
2824 fprintf(fp, " --source=[NAME:]PLUGIN.CLS Instantiate a source component from plugin\n");
2825 fprintf(fp, " PLUGIN and component class CLS, set it as\n");
2826 fprintf(fp, " the current component, and if NAME is\n");
2827 fprintf(fp, " given, set its instance name to NAME\n");
2828 fprintf(fp, " -u, --url=URL Set the `url` string parameter of the\n");
2829 fprintf(fp, " current component to URL\n");
22e22462
PP		 2830 fprintf(fp, " -h --help Show this help and quit\n");
2831 fprintf(fp, "\n");
db0f160a
PP		 2832 fprintf(fp, "Implicit `ctf.fs` source component options:\n");
2833 fprintf(fp, "\n");
2834 fprintf(fp, " --clock-offset=SEC Set clock offset to SEC seconds\n");
2835 fprintf(fp, " --clock-offset-ns=NS Set clock offset to NS ns\n");
2836 fprintf(fp, " --stream-intersection Only process events when all streams\n");
2837 fprintf(fp, " are active\n");
2838 fprintf(fp, "\n");
2839 fprintf(fp, "Implicit `text.text` sink component options:\n");
2840 fprintf(fp, "\n");
2841 fprintf(fp, " --clock-cycles Print timestamps in clock cycles\n");
2842 fprintf(fp, " --clock-date Print timestamp dates\n");
2843 fprintf(fp, " --clock-gmt Print and parse timestamps in the GMT\n");
2844 fprintf(fp, " time zone instead of the local time zone\n");
2845 fprintf(fp, " --clock-seconds Print the timestamps as `SEC.NS` instead\n");
2846 fprintf(fp, " of `hh:mm:ss.nnnnnnnnn`\n");
2847 fprintf(fp, " --color=(never | auto | always)\n");
2848 fprintf(fp, " Never, automatically, or always emit\n");
2849 fprintf(fp, " console color codes\n");
2850 fprintf(fp, " -f, --fields=FIELD[,FIELD]... Print additional fields; FIELD can be:\n");
2851 fprintf(fp, " `all`, `trace`, `trace:hostname`,\n");
2852 fprintf(fp, " `trace:domain`, `trace:procname`,\n");
2853 fprintf(fp, " `trace:vpid`, `loglevel`, `emf`\n");
2854 fprintf(fp, " -n, --names=NAME[,NAME]... Print field names; NAME can be:\n");
2855 fprintf(fp, " `payload` (or `arg` or `args`), `none`,\n");
2856 fprintf(fp, " `all`, `scope`, `header`, `context`\n");
2857 fprintf(fp, " (or `ctx`)\n");
2858 fprintf(fp, " --no-delta Do not print time delta between\n");
2859 fprintf(fp, " consecutive events\n");
2860 fprintf(fp, " -w, --output=PATH Write output text to PATH instead of\n");
2861 fprintf(fp, " the standard output\n");
2862 fprintf(fp, "\n");
2863 fprintf(fp, "Implicit `utils.muxer` filter component options:\n");
2864 fprintf(fp, "\n");
2865 fprintf(fp, " --clock-force-correlate Assume that clocks are inherently\n");
2866 fprintf(fp, " correlated across traces\n");
2867 fprintf(fp, "\n");
2868 fprintf(fp, "Implicit `utils.trimmer` filter component options:\n");
2869 fprintf(fp, "\n");
2870 fprintf(fp, " -b, --begin=BEGIN Set the beginning time of the conversion\n");
2871 fprintf(fp, " time range to BEGIN (see the format of\n");
2872 fprintf(fp, " BEGIN below)\n");
2873 fprintf(fp, " -e, --end=END Set the end time of the conversion time\n");
2874 fprintf(fp, " range to END (see the format of END below)\n");
2875 fprintf(fp, " -t, --timerange=TIMERANGE Set conversion time range to TIMERANGE:\n");
2876 fprintf(fp, " BEGIN,END or [BEGIN,END] (literally `[` and\n");
2877 fprintf(fp, " `]`) (see the format of BEGIN/END below)\n");
2878 fprintf(fp, "\n");
2879 fprintf(fp, "Implicit `lttng-utils.debug-info` filter component options:\n");
2880 fprintf(fp, "\n");
2881 fprintf(fp, " --debug-info-dir=DIR Search for debug info in directory DIR\n");
2882 fprintf(fp, " instead of `/usr/lib/debug`\n");
2883 fprintf(fp, " --debug-info-full-path Show full debug info source and\n");
2884 fprintf(fp, " binary paths instead of just names\n");
2885 fprintf(fp, " --debug-info-target-prefix=DIR\n");
2886 fprintf(fp, " Use directory DIR as a prefix when\n");
2887 fprintf(fp, " looking up executables during debug\n");
2888 fprintf(fp, " info analysis\n");
2889 fprintf(fp, " --no-debug-info Do not create an implicit\n");
2890 fprintf(fp, " `lttng-utils.debug-info` filter component\n");
2891 fprintf(fp, "\n");
2892 fprintf(fp, "Legacy options that still work:\n");
2893 fprintf(fp, "\n");
2894 fprintf(fp, " -i, --input-format=(ctf | lttng-live)\n");
2895 fprintf(fp, " `ctf`:\n");
2896 fprintf(fp, " Create an implicit `ctf.fs` source\n");
2897 fprintf(fp, " component\n");
2898 fprintf(fp, " `lttng-live`:\n");
2899 fprintf(fp, " Create an implicit `ctf.lttng-live`\n");
2900 fprintf(fp, " source component\n");
2901 fprintf(fp, " -o, --output-format=(text | dummy | ctf-metadata)\n");
2902 fprintf(fp, " `text`:\n");
2903 fprintf(fp, " Create an implicit `text.text` sink\n");
2904 fprintf(fp, " component\n");
2905 fprintf(fp, " `dummy`:\n");
2906 fprintf(fp, " Create an implicit `utils.dummy` sink\n");
2907 fprintf(fp, " component\n");
2908 fprintf(fp, " `ctf-metadata`:\n");
2909 fprintf(fp, " Query the `ctf.fs` component class for\n");
2910 fprintf(fp, " metadata text and quit\n");
2911 fprintf(fp, "\n");
22e22462 2912 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
db0f160a
PP		 2913 fprintf(fp, "\n\n");
2914 fprintf(fp, "Format of BEGIN and END\n");
2915 fprintf(fp, "-----------------------\n");
22e22462 2916 fprintf(fp, "\n");
db0f160a
PP		 2917 fprintf(fp, " [YYYY-MM-DD [hh:mm:]]ss[.nnnnnnnnn]\n");
2918 fprintf(fp, "\n\n");
2919 print_expected_params_format(fp);
22e22462
PP		 2920}
2921
db0f160a 2922static struct poptOption convert_long_options[] = {
22e22462 2923 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
db0f160a
PP		 2924 { "begin", 'b', POPT_ARG_STRING, NULL, OPT_BEGIN, NULL, NULL },
2925 { "clock-cycles", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_CYCLES, NULL, NULL },
2926 { "clock-date", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_DATE, NULL, NULL },
2927 { "clock-force-correlate", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_FORCE_CORRELATE, NULL, NULL },
2928 { "clock-gmt", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_GMT, NULL, NULL },
2929 { "clock-offset", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET, NULL, NULL },
2930 { "clock-offset-ns", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET_NS, NULL, NULL },
2931 { "clock-seconds", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_SECONDS, NULL, NULL },
2932 { "color", '\0', POPT_ARG_STRING, NULL, OPT_COLOR, NULL, NULL },
2933 { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL },
2934 { "debug-info-dir", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_DIR, NULL, NULL },
2935 { "debug-info-full-path", 0, POPT_ARG_NONE, NULL, OPT_DEBUG_INFO_FULL_PATH, NULL, NULL },
2936 { "debug-info-target-prefix", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_TARGET_PREFIX, NULL, NULL },
2937 { "end", 'e', POPT_ARG_STRING, NULL, OPT_END, NULL, NULL },
2938 { "fields", 'f', POPT_ARG_STRING, NULL, OPT_FIELDS, NULL, NULL },
22e22462
PP		 2939 { "filter", '\0', POPT_ARG_STRING, NULL, OPT_FILTER, NULL, NULL },
2940 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
db0f160a
PP		 2941 { "input-format", 'i', POPT_ARG_STRING, NULL, OPT_INPUT_FORMAT, NULL, NULL },
2942 { "name", '\0', POPT_ARG_STRING, NULL, OPT_NAME, NULL, NULL },
2943 { "names", 'n', POPT_ARG_STRING, NULL, OPT_NAMES, NULL, NULL },
2944 { "no-debug-info", '\0', POPT_ARG_NONE, NULL, OPT_NO_DEBUG_INFO, NULL, NULL },
2945 { "no-delta", '\0', POPT_ARG_NONE, NULL, OPT_NO_DELTA, NULL, NULL },
22e22462
PP		 2946 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2947 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
db0f160a
PP		 2948 { "output", 'w', POPT_ARG_STRING, NULL, OPT_OUTPUT, NULL, NULL },
2949 { "output-format", 'o', POPT_ARG_STRING, NULL, OPT_OUTPUT_FORMAT, NULL, NULL },
2950 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2951 { "path", 'P', POPT_ARG_STRING, NULL, OPT_PATH, NULL, NULL },
22e22462 2952 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
db0f160a
PP		 2953 { "run-args", '\0', POPT_ARG_NONE, NULL, OPT_RUN_ARGS, NULL, NULL },
2954 { "run-args-0", '\0', POPT_ARG_NONE, NULL, OPT_RUN_ARGS_0, NULL, NULL },
22e22462
PP		 2955 { "sink", '\0', POPT_ARG_STRING, NULL, OPT_SINK, NULL, NULL },
2956 { "source", '\0', POPT_ARG_STRING, NULL, OPT_SOURCE, NULL, NULL },
db0f160a
PP		 2957 { "stream-intersection", '\0', POPT_ARG_NONE, NULL, OPT_STREAM_INTERSECTION, NULL, NULL },
2958 { "timerange", '\0', POPT_ARG_STRING, NULL, OPT_TIMERANGE, NULL, NULL },
2959 { "url", 'u', POPT_ARG_STRING, NULL, OPT_URL, NULL, NULL },
2960 { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL },
22e22462
PP		 2961 { NULL, 0, 0, NULL, 0, NULL, NULL },
2962};
2963
db0f160a
PP		 2964static
2965GString *get_component_auto_name(const char *prefix,
2966 struct bt_value *existing_names)
22e22462 2967{
db0f160a
PP		 2968 unsigned int i = 0;
2969 GString *auto_name = g_string_new(NULL);
22e22462 2970
db0f160a 2971 if (!auto_name) {
22e22462 2972 print_err_oom();
db0f160a 2973 goto end;
22e22462
PP		 2974 }
2975
db0f160a
PP		 2976 if (!bt_value_map_has_key(existing_names, prefix)) {
2977 g_string_assign(auto_name, prefix);
2978 goto end;
22e22462
PP		 2979 }
2980
db0f160a
PP		 2981 do {
2982 g_string_printf(auto_name, "%s-%d", prefix, i);
2983 i++;
2984 } while (bt_value_map_has_key(existing_names, auto_name->str));
2985
2986end:
2987 return auto_name;
2988}
2989
2990struct implicit_component_args {
2991 bool exists;
2992 GString *plugin_comp_cls_arg;
2993 GString *name_arg;
2994 GString *params_arg;
2995 struct bt_value *extra_args;
2996};
2997
2998static
2999int assign_name_to_implicit_component(struct implicit_component_args *args,
3000 const char *prefix, struct bt_value *existing_names,
3001 GList **comp_names, bool append_to_comp_names)
3002{
3003 int ret = 0;
3004 GString *name = NULL;
3005
3006 if (!args->exists) {
3007 goto end;
22e22462
PP		 3008 }
3009
db0f160a 3010 name = get_component_auto_name(prefix, existing_names);
22e22462 3011
db0f160a
PP		 3012 if (!name) {
3013 ret = -1;
3014 goto end;
3015 }
22e22462 3016
db0f160a 3017 g_string_assign(args->name_arg, name->str);
22e22462 3018
db0f160a
PP		 3019 if (bt_value_map_insert(existing_names, name->str,
3020 bt_value_null)) {
3021 print_err_oom();
3022 ret = -1;
3023 goto end;
3024 }
3025
3026 if (append_to_comp_names) {
3027 *comp_names = g_list_append(*comp_names, name);
3028 name = NULL;
3029 }
3030
3031end:
3032 if (name) {
3033 g_string_free(name, TRUE);
3034 }
3035
3036 return ret;
3037}
3038
3039static
3040int append_run_args_for_implicit_component(
3041 enum bt_component_class_type type,
3042 struct implicit_component_args *impl_args,
3043 struct bt_value *run_args)
3044{
3045 int ret = 0;
3046 size_t i;
3047
3048 if (!impl_args->exists) {
3049 goto end;
3050 }
3051
3052 switch (type) {
3053 case BT_COMPONENT_CLASS_TYPE_SOURCE:
3054 if (bt_value_array_append_string(run_args, "--source")) {
3055 print_err_oom();
3056 goto error;
3057 }
3058 break;
3059 case BT_COMPONENT_CLASS_TYPE_FILTER:
3060 if (bt_value_array_append_string(run_args, "--filter")) {
3061 print_err_oom();
3062 goto error;
3063 }
3064 break;
3065 case BT_COMPONENT_CLASS_TYPE_SINK:
3066 if (bt_value_array_append_string(run_args, "--sink")) {
3067 print_err_oom();
22e22462
PP		 3068 goto error;
3069 }
db0f160a
PP		 3070 break;
3071 default:
3072 assert(false);
3073 }
22e22462 3074
db0f160a
PP		 3075 if (bt_value_array_append_string(run_args,
3076 impl_args->plugin_comp_cls_arg->str)) {
3077 print_err_oom();
3078 goto error;
22e22462
PP		 3079 }
3080
db0f160a
PP		 3081 if (bt_value_array_append_string(run_args, "--name")) {
3082 print_err_oom();
22e22462
PP		 3083 goto error;
3084 }
3085
db0f160a
PP		 3086 if (bt_value_array_append_string(run_args, impl_args->name_arg->str)) {
3087 print_err_oom();
3088 goto error;
3089 }
3090
3091 if (impl_args->params_arg->len > 0) {
3092 if (bt_value_array_append_string(run_args, "--params")) {
3093 print_err_oom();
22e22462
PP		 3094 goto error;
3095 }
3096
db0f160a
PP		 3097 if (bt_value_array_append_string(run_args,
3098 impl_args->params_arg->str)) {
3099 print_err_oom();
3100 goto error;
22e22462 3101 }
db0f160a 3102 }
22e22462 3103
db0f160a
PP		 3104 for (i = 0; i < bt_value_array_size(impl_args->extra_args); i++) {
3105 struct bt_value *elem;
3106 const char *arg;
3107
3108 elem = bt_value_array_get(impl_args->extra_args, i);
3109 if (!elem) {
3110 goto error;
3111 }
3112
3113 assert(bt_value_is_string(elem));
3114 if (bt_value_string_get(elem, &arg)) {
3115 goto error;
3116 }
3117
3118 ret = bt_value_array_append_string(run_args, arg);
3119 bt_put(elem);
3120 if (ret) {
3121 print_err_oom();
22e22462
PP		 3122 goto error;
3123 }
3124 }
3125
db0f160a
PP		 3126 goto end;
3127
3128error:
3129 ret = -1;
3130
3131end:
3132 return ret;
3133}
3134
3135static
3136void destroy_implicit_component_args(struct implicit_component_args *args)
3137{
3138 assert(args);
3139
3140 if (args->plugin_comp_cls_arg) {
3141 g_string_free(args->plugin_comp_cls_arg, TRUE);
3142 }
3143
3144 if (args->name_arg) {
3145 g_string_free(args->name_arg, TRUE);
3146 }
3147
3148 if (args->params_arg) {
3149 g_string_free(args->params_arg, TRUE);
22e22462
PP		 3150 }
3151
db0f160a
PP		 3152 bt_put(args->extra_args);
3153}
22e22462 3154
db0f160a
PP		 3155static
3156int init_implicit_component_args(struct implicit_component_args *args,
3157 const char *plugin_comp_cls_arg, bool exists)
3158{
3159 int ret = 0;
22e22462 3160
db0f160a
PP		 3161 args->exists = exists;
3162 args->plugin_comp_cls_arg = g_string_new(plugin_comp_cls_arg);
3163 args->name_arg = g_string_new(NULL);
3164 args->params_arg = g_string_new(NULL);
3165 args->extra_args = bt_value_array_create();
22e22462 3166
db0f160a
PP		 3167 if (!args->plugin_comp_cls_arg || !args->name_arg ||
3168 !args->params_arg || !args->extra_args) {
3169 ret = -1;
3170 destroy_implicit_component_args(args);
3171 print_err_oom();
3172 goto end;
22e22462
PP		 3173 }
3174
db0f160a
PP		 3175end:
3176 return ret;
22e22462
PP		 3177}
3178
63ce0e1d 3179static
db0f160a
PP		 3180void append_implicit_component_param(struct implicit_component_args *args,
3181 const char *key, const char *value)
63ce0e1d 3182{
db0f160a
PP		 3183 assert(args);
3184 assert(key);
3185 assert(value);
3186 append_param_arg(args->params_arg, key, value);
63ce0e1d
PP		 3187}
3188
db0f160a
PP		 3189static
3190int append_implicit_component_extra_arg(struct implicit_component_args *args,
3191 const char *key, const char *value)
63ce0e1d 3192{
db0f160a 3193 int ret = 0;
63ce0e1d 3194
db0f160a
PP		 3195 assert(args);
3196 assert(key);
3197 assert(value);
3198
3199 if (bt_value_array_append_string(args->extra_args, "--key")) {
63ce0e1d 3200 print_err_oom();
db0f160a
PP		 3201 ret = -1;
3202 goto end;
63ce0e1d
PP		 3203 }
3204
db0f160a
PP		 3205 if (bt_value_array_append_string(args->extra_args, key)) {
3206 print_err_oom();
3207 ret = -1;
3208 goto end;
63ce0e1d
PP		 3209 }
3210
db0f160a
PP		 3211 if (bt_value_array_append_string(args->extra_args, "--value")) {
3212 print_err_oom();
3213 ret = -1;
3214 goto end;
63ce0e1d
PP		 3215 }
3216
db0f160a
PP		 3217 if (bt_value_array_append_string(args->extra_args, value)) {
3218 print_err_oom();
3219 ret = -1;
3220 goto end;
3221 }
63ce0e1d 3222
db0f160a
PP		 3223end:
3224 return ret;
3225}
63ce0e1d 3226
db0f160a
PP		 3227static
3228int convert_append_name_param(enum bt_config_component_dest dest,
3229 GString *cur_name, GString *cur_name_prefix,
3230 struct bt_value *run_args, struct bt_value *all_names,
3231 GList **source_names, GList **filter_names,
3232 GList **sink_names)
3233{
3234 int ret = 0;
63ce0e1d 3235
db0f160a
PP		 3236 if (cur_name_prefix->len > 0) {
3237 /* We're after a --source/--filter/--sink */
3238 GString *name = NULL;
3239 bool append_name_opt = false;
3240
3241 if (cur_name->len == 0) {
3242 /*
3243 * No explicit name was provided for the user
3244 * component.
3245 */
3246 name = get_component_auto_name(
3247 cur_name_prefix->str,
3248 all_names);
3249 append_name_opt = true;
3250 } else {
3251 /*
3252 * An explicit name was provided for the user
3253 * component.
3254 */
3255 if (bt_value_map_has_key(all_names,
3256 cur_name->str)) {
3257 printf_err("Duplicate component instance name:\n %s\n",
3258 cur_name->str);
63ce0e1d
PP		 3259 goto error;
3260 }
3261
db0f160a
PP		 3262 name = g_string_new(cur_name->str);
3263 }
63ce0e1d 3264
db0f160a
PP		 3265 if (!name) {
3266 print_err_oom();
3267 goto error;
3268 }
3269
3270 /*
3271 * Remember this name globally, for the uniqueness of
3272 * all component names.
3273 */
3274 if (bt_value_map_insert(all_names, name->str, bt_value_null)) {
3275 print_err_oom();
3276 goto error;
3277 }
3278
3279 /*
3280 * Append the --name option if necessary.
3281 */
3282 if (append_name_opt) {
3283 if (bt_value_array_append_string(run_args, "--name")) {
3284 print_err_oom();
63ce0e1d
PP		 3285 goto error;
3286 }
3287
db0f160a
PP		 3288 if (bt_value_array_append_string(run_args, name->str)) {
3289 print_err_oom();
63ce0e1d
PP		 3290 goto error;
3291 }
63ce0e1d 3292 }
db0f160a
PP		 3293
3294 /*
3295 * Remember this name specifically for the type of the
3296 * component. This is to create connection arguments.
3297 */
3298 switch (dest) {
3299 case BT_CONFIG_COMPONENT_DEST_SOURCE:
3300 *source_names = g_list_append(*source_names, name);
3301 break;
3302 case BT_CONFIG_COMPONENT_DEST_FILTER:
3303 *filter_names = g_list_append(*filter_names, name);
3304 break;
3305 case BT_CONFIG_COMPONENT_DEST_SINK:
3306 *sink_names = g_list_append(*sink_names, name);
3307 break;
63ce0e1d 3308 default:
db0f160a 3309 assert(false);
63ce0e1d
PP		 3310 }
3311
db0f160a 3312 g_string_assign(cur_name_prefix, "");
63ce0e1d
PP		 3313 }
3314
db0f160a 3315 goto end;
63ce0e1d 3316
db0f160a
PP		 3317error:
3318 ret = -1;
63ce0e1d 3319
db0f160a
PP		 3320end:
3321 return ret;
3322}
3323
3324/*
3325 * Escapes `.`, `:`, and `\` of `input` with `\`.
3326 */
3327GString *escape_dot_colon(const char *input)
3328{
3329 GString *output = g_string_new(NULL);
3330 const char *ch;
3331
3332 if (!output) {
3333 print_err_oom();
3334 goto end;
63ce0e1d
PP		 3335 }
3336
db0f160a
PP		 3337 for (ch = input; *ch != '\0'; ch++) {
3338 if (*ch == '\\' || *ch == '.' || *ch == ':') {
3339 g_string_append_c(output, '\\');
63ce0e1d
PP		 3340 }
3341
db0f160a
PP		 3342 g_string_append_c(output, *ch);
3343 }
3344
3345end:
3346 return output;
3347}
3348
3349/*
3350 * Appends a --connect option to a list of arguments. `upstream_name`
3351 * and `downstream_name` are escaped with escape_dot_colon() in this
3352 * function.
3353 */
3354int append_connect_arg(struct bt_value *run_args,
3355 const char *upstream_name, const char *downstream_name)
3356{
3357 int ret = 0;
3358 GString *e_upstream_name = escape_dot_colon(upstream_name);
3359 GString *e_downstream_name = escape_dot_colon(downstream_name);
3360 GString *arg = g_string_new(NULL);
3361
3362 if (!e_upstream_name || !e_downstream_name || !arg) {
3363 print_err_oom();
3364 ret = -1;
63ce0e1d
PP		 3365 goto end;
3366 }
3367
db0f160a
PP		 3368 ret = bt_value_array_append_string(run_args, "--connect");
3369 if (ret) {
3370 print_err_oom();
3371 ret = -1;
3372 goto end;
63ce0e1d
PP		 3373 }
3374
db0f160a
PP		 3375 g_string_append(arg, e_upstream_name->str);
3376 g_string_append_c(arg, ':');
3377 g_string_append(arg, e_downstream_name->str);
3378 ret = bt_value_array_append_string(run_args, arg->str);
3379 if (ret) {
3380 print_err_oom();
3381 ret = -1;
3382 goto end;
63ce0e1d
PP		 3383 }
3384
db0f160a
PP		 3385end:
3386 if (arg) {
3387 g_string_free(arg, TRUE);
3388 }
63ce0e1d 3389
db0f160a
PP		 3390 if (e_upstream_name) {
3391 g_string_free(e_upstream_name, TRUE);
3392 }
63ce0e1d 3393
db0f160a
PP		 3394 if (e_downstream_name) {
3395 g_string_free(e_downstream_name, TRUE);
63ce0e1d
PP		 3396 }
3397
db0f160a 3398 return ret;
63ce0e1d
PP		 3399}
3400
290725f7 3401/*
db0f160a 3402 * Appends the run command's --connect options for the convert command.
290725f7 3403 */
db0f160a
PP		 3404int convert_auto_connect(struct bt_value *run_args,
3405 GList *source_names, GList *filter_names,
3406 GList *sink_names)
290725f7 3407{
db0f160a
PP		 3408 int ret = 0;
3409 GList *source_at = source_names;
3410 GList *filter_at = filter_names;
3411 GList *filter_prev;
3412 GList *sink_at = sink_names;
3413
3414 assert(source_names);
3415 assert(filter_names);
3416 assert(sink_names);
3417
3418 /* Connect all sources to the first filter */
3419 for (source_at = source_names; source_at != NULL; source_at = g_list_next(source_at)) {
3420 GString *source_name = source_at->data;
3421 GString *filter_name = filter_at->data;
3422
3423 ret = append_connect_arg(run_args, source_name->str,
3424 filter_name->str);
3425 if (ret) {
3426 goto error;
3427 }
3428 }
290725f7 3429
db0f160a
PP		 3430 filter_prev = filter_at;
3431 filter_at = g_list_next(filter_at);
290725f7 3432
db0f160a
PP		 3433 /* Connect remaining filters */
3434 for (; filter_at != NULL; filter_prev = filter_at, filter_at = g_list_next(filter_at)) {
3435 GString *filter_name = filter_at->data;
3436 GString *filter_prev_name = filter_prev->data;
290725f7 3437
db0f160a
PP		 3438 ret = append_connect_arg(run_args, filter_prev_name->str,
3439 filter_name->str);
3440 if (ret) {
3441 goto error;
3442 }
290725f7
PP		 3443 }
3444
db0f160a
PP		 3445 /* Connect last filter to all sinks */
3446 for (sink_at = sink_names; sink_at != NULL; sink_at = g_list_next(sink_at)) {
3447 GString *filter_name = filter_prev->data;
3448 GString *sink_name = sink_at->data;
290725f7 3449
db0f160a
PP		 3450 ret = append_connect_arg(run_args, filter_name->str,
3451 sink_name->str);
3452 if (ret) {
3453 goto error;
3454 }
290725f7
PP		 3455 }
3456
db0f160a 3457 goto end;
c42c79ea 3458
db0f160a
PP		 3459error:
3460 ret = -1;
c42c79ea 3461
db0f160a
PP		 3462end:
3463 return ret;
3464}
290725f7 3465
db0f160a
PP		 3466static int split_timerange(const char *arg, char **begin, char **end)
3467{
3468 int ret = 0;
3469 const char *ch = arg;
3470 size_t end_pos;
3471 GString *g_begin = NULL;
3472 GString *g_end = NULL;
290725f7 3473
db0f160a
PP		 3474 assert(arg);
3475
3476 if (*ch == '[') {
3477 ch++;
290725f7
PP		 3478 }
3479
db0f160a
PP		 3480 g_begin = bt_common_string_until(ch, "", ",", &end_pos);
3481 if (!g_begin || ch[end_pos] != ',' || g_begin->len == 0) {
290725f7
PP		 3482 goto error;
3483 }
3484
db0f160a
PP		 3485 ch += end_pos + 1;
3486
3487 g_end = bt_common_string_until(ch, "", "]", &end_pos);
3488 if (!g_end || g_end->len == 0) {
290725f7
PP		 3489 goto error;
3490 }
3491
db0f160a
PP		 3492 assert(begin);
3493 assert(end);
3494 *begin = g_begin->str;
3495 *end = g_end->str;
3496 g_string_free(g_begin, FALSE);
3497 g_string_free(g_end, FALSE);
3498 g_begin = NULL;
3499 g_end = NULL;
290725f7
PP		 3500 goto end;
3501
3502error:
db0f160a 3503 ret = -1;
290725f7
PP		 3504
3505end:
db0f160a
PP		 3506 if (g_begin) {
3507 g_string_free(g_begin, TRUE);
290725f7
PP		 3508 }
3509
db0f160a
PP		 3510 if (g_end) {
3511 g_string_free(g_end, TRUE);
3512 }
290725f7 3513
db0f160a 3514 return ret;
290725f7
PP		 3515}
3516
290725f7 3517static
db0f160a 3518int g_list_prepend_gstring(GList **list, const char *string)
290725f7 3519{
db0f160a
PP		 3520 int ret = 0;
3521 GString *gs = g_string_new(string);
290725f7 3522
db0f160a
PP		 3523 assert(list);
3524
3525 if (!gs) {
3526 print_err_oom();
3527 goto end;
3528 }
3529
3530 *list = g_list_prepend(*list, gs);
3531
3532end:
3533 return ret;
3534}
290725f7
PP		 3535
3536/*
3537 * Creates a Babeltrace config object from the arguments of a convert
3538 * command.
3539 *
3540 * *retcode is set to the appropriate exit code to use.
3541 */
db0f160a 3542static
290725f7
PP		 3543struct bt_config *bt_config_convert_from_args(int argc, const char *argv[],
3544 int *retcode, bool omit_system_plugin_path,
3545 bool omit_home_plugin_path,
3546 struct bt_value *initial_plugin_paths)
3547{
3548 poptContext pc = NULL;
3549 char *arg = NULL;
db0f160a 3550 enum bt_config_component_dest cur_comp_dest;
290725f7
PP		 3551 int opt, ret = 0;
3552 struct bt_config *cfg = NULL;
ae3b9aa4 3553 bool got_verbose_opt = false;
db0f160a
PP		 3554 bool got_debug_opt = false;
3555 bool got_input_format_opt = false;
3556 bool got_output_format_opt = false;
3557 bool trimmer_has_begin = false;
3558 bool trimmer_has_end = false;
3559 GString *cur_name = NULL;
3560 GString *cur_name_prefix = NULL;
3561 const char *leftover = NULL;
3562 bool print_run_args = false;
3563 bool print_run_args_0 = false;
3564 bool print_ctf_metadata = false;
3565 struct bt_value *run_args = NULL;
3566 struct bt_value *all_names = NULL;
3567 GList *source_names = NULL;
3568 GList *filter_names = NULL;
3569 GList *sink_names = NULL;
3570 struct implicit_component_args implicit_ctf_args = { 0 };
3571 struct implicit_component_args implicit_lttng_live_args = { 0 };
3572 struct implicit_component_args implicit_dummy_args = { 0 };
3573 struct implicit_component_args implicit_text_args = { 0 };
3574 struct implicit_component_args implicit_debug_info_args = { 0 };
3575 struct implicit_component_args implicit_muxer_args = { 0 };
3576 struct implicit_component_args implicit_trimmer_args = { 0 };
3577 struct bt_value *plugin_paths = bt_get(initial_plugin_paths);
3578 char error_buf[256] = { 0 };
3579 size_t i;
3580 struct bt_common_lttng_live_url_parts lttng_live_url_parts = { 0 };
290725f7
PP		 3581
3582 *retcode = 0;
290725f7
PP		 3583
3584 if (argc <= 1) {
3585 print_convert_usage(stdout);
3586 *retcode = -1;
3587 goto end;
3588 }
3589
db0f160a 3590 if (init_implicit_component_args(&implicit_ctf_args, "ctf.fs", false)) {
290725f7
PP		 3591 goto error;
3592 }
3593
db0f160a
PP		 3594 if (init_implicit_component_args(&implicit_lttng_live_args,
3595 "ctf.lttng-live", false)) {
290725f7
PP		 3596 goto error;
3597 }
3598
db0f160a
PP		 3599 if (init_implicit_component_args(&implicit_text_args, "text.text",
3600 false)) {
290725f7
PP		 3601 goto error;
3602 }
3603
db0f160a
PP		 3604 if (init_implicit_component_args(&implicit_dummy_args, "utils.dummy",
3605 false)) {
290725f7
PP		 3606 goto error;
3607 }
3608
db0f160a
PP		 3609 if (init_implicit_component_args(&implicit_debug_info_args,
3610 "lttng-utils.debug-info", true)) {
290725f7
PP		 3611 goto error;
3612 }
3613
db0f160a
PP		 3614 if (init_implicit_component_args(&implicit_muxer_args, "utils.muxer",
3615 true)) {
290725f7
PP		 3616 goto error;
3617 }
3618
db0f160a
PP		 3619 if (init_implicit_component_args(&implicit_trimmer_args,
3620 "utils.trimmer", false)) {
3b6cfcc5
PP		 3621 goto error;
3622 }
3623
db0f160a
PP		 3624 all_names = bt_value_map_create();
3625 if (!all_names) {
3626 print_err_oom();
3627 goto error;
3628 }
3629
3630 run_args = bt_value_array_create();
3631 if (!run_args) {
ebba3338
PP		 3632 print_err_oom();
3633 goto error;
3634 }
3635
db0f160a
PP		 3636 cur_name = g_string_new(NULL);
3637 if (!cur_name) {
3638 print_err_oom();
290725f7
PP		 3639 goto error;
3640 }
3641
db0f160a
PP		 3642 cur_name_prefix = g_string_new(NULL);
3643 if (!cur_name_prefix) {
22e22462
PP		 3644 print_err_oom();
3645 goto error;
290725f7
PP		 3646 }
3647
db0f160a
PP		 3648 ret = append_env_var_plugin_paths(plugin_paths);
3649 if (ret) {
3650 goto error;
3651 }
22e22462 3652
db0f160a
PP		 3653 /*
3654 * First pass: collect all arguments which need to be passed
3655 * as is to the run command. This pass can also add --name
3656 * arguments if needed to automatically name unnamed component
3657 * instances. Also it does the following transformations:
3658 *
3659 * --path=PATH -> --key path --value PATH
3660 * --url=URL -> --key url --value URL
3661 *
3662 * Also it appends the plugin paths of --plugin-path to
3663 * `plugin_paths`.
3664 */
290725f7
PP		 3665 pc = poptGetContext(NULL, argc, (const char **) argv,
3666 convert_long_options, 0);
3667 if (!pc) {
3668 printf_err("Cannot get popt context\n");
3669 goto error;
3670 }
3671
3672 poptReadDefaultConfig(pc, 0);
3673
3674 while ((opt = poptGetNextOpt(pc)) > 0) {
db0f160a
PP		 3675 char *name = NULL;
3676 char *plugin_name = NULL;
3677 char *comp_cls_name = NULL;
3678
290725f7
PP		 3679 arg = poptGetOptArg(pc);
3680
3681 switch (opt) {
db0f160a
PP		 3682 case OPT_SOURCE:
3683 case OPT_FILTER:
3684 case OPT_SINK:
3685 /* Append current component's name if needed */
3686 ret = convert_append_name_param(cur_comp_dest, cur_name,
3687 cur_name_prefix, run_args, all_names,
3688 &source_names, &filter_names, &sink_names);
3689 if (ret) {
c42c79ea
PP		 3690 goto error;
3691 }
3692
db0f160a
PP		 3693 /* Parse the argument */
3694 plugin_comp_cls_names(arg, &name, &plugin_name,
3695 &comp_cls_name);
3696 if (!plugin_name || !comp_cls_name) {
3697 printf_err("Invalid format for --source/--filter/--sink option's argument:\n %s\n",
3698 arg);
c42c79ea
PP		 3699 goto error;
3700 }
3701
db0f160a
PP		 3702 if (name) {
3703 g_string_assign(cur_name, name);
3704 } else {
3705 g_string_assign(cur_name, "");
c42c79ea
PP		 3706 }
3707
db0f160a
PP		 3708 switch (opt) {
3709 case OPT_SOURCE:
3710 cur_comp_dest =
3711 BT_CONFIG_COMPONENT_DEST_SOURCE;
3712 if (bt_value_array_append_string(run_args,
3713 "--source")) {
3714 print_err_oom();
3715 goto error;
3716 }
3717 break;
3718 case OPT_FILTER:
3719 cur_comp_dest =
3720 BT_CONFIG_COMPONENT_DEST_FILTER;
3721 if (bt_value_array_append_string(run_args,
3722 "--filter")) {
3723 print_err_oom();
3724 goto error;
3725 }
3726 break;
3727 case OPT_SINK:
3728 cur_comp_dest =
3729 BT_CONFIG_COMPONENT_DEST_SINK;
3730 if (bt_value_array_append_string(run_args,
3731 "--sink")) {
3732 print_err_oom();
3733 goto error;
c42c79ea 3734 }
db0f160a
PP		 3735 break;
3736 default:
3737 assert(false);
c42c79ea
PP		 3738 }
3739
db0f160a
PP		 3740 if (bt_value_array_append_string(run_args, arg)) {
3741 print_err_oom();
3742 goto error;
bdc61c70
PP		 3743 }
3744
db0f160a
PP		 3745 g_string_assign(cur_name_prefix, "");
3746 g_string_append(cur_name_prefix, plugin_name);
3747 g_string_append_c(cur_name_prefix, '.');
3748 g_string_append(cur_name_prefix, comp_cls_name);
3749 free(name);
3750 free(plugin_name);
3751 free(comp_cls_name);
3752 name = NULL;
3753 plugin_name = NULL;
3754 comp_cls_name = NULL;
3755 break;
3756 case OPT_PARAMS:
3757 if (cur_name_prefix->len == 0) {
3758 printf_err("No current component of which to set parameters:\n %s\n",
c42c79ea
PP		 3759 arg);
3760 goto error;
3761 }
3762
db0f160a
PP		 3763 if (bt_value_array_append_string(run_args,
3764 "--params")) {
c9313318 3765 print_err_oom();
290725f7 3766 goto error;
c9313318
PP		 3767 }
3768
db0f160a
PP		 3769 if (bt_value_array_append_string(run_args, arg)) {
3770 print_err_oom();
3771 goto error;
355b476b 3772 }
db0f160a
PP		 3773 break;
3774 case OPT_PATH:
3775 if (cur_name_prefix->len == 0) {
3776 printf_err("No current component of which to set `path` parameter:\n %s\n",
355b476b
PP		 3777 arg);
3778 goto error;
3779 }
355b476b 3780
db0f160a 3781 if (bt_value_array_append_string(run_args, "--key")) {
355b476b
PP		 3782 print_err_oom();
3783 goto error;
3784 }
3785
db0f160a
PP		 3786 if (bt_value_array_append_string(run_args, "path")) {
3787 print_err_oom();
3788 goto error;
c42c79ea
PP		 3789 }
3790
db0f160a
PP		 3791 if (bt_value_array_append_string(run_args, "--value")) {
3792 print_err_oom();
3793 goto error;
bdc61c70
PP		 3794 }
3795
db0f160a
PP		 3796 if (bt_value_array_append_string(run_args, arg)) {
3797 print_err_oom();
3798 goto error;
3799 }
3800 break;
3801 case OPT_URL:
3802 if (cur_name_prefix->len == 0) {
3803 printf_err("No current component of which to set `url` parameter:\n %s\n",
c42c79ea
PP		 3804 arg);
3805 goto error;
3806 }
3807
db0f160a 3808 if (bt_value_array_append_string(run_args, "--key")) {
c9313318 3809 print_err_oom();
290725f7 3810 goto error;
c9313318
PP		 3811 }
3812
db0f160a
PP		 3813 if (bt_value_array_append_string(run_args, "url")) {
3814 print_err_oom();
bdc61c70
PP		 3815 goto error;
3816 }
3817
db0f160a
PP		 3818 if (bt_value_array_append_string(run_args, "--value")) {
3819 print_err_oom();
bdc61c70
PP		 3820 goto error;
3821 }
3822
db0f160a
PP		 3823 if (bt_value_array_append_string(run_args, arg)) {
3824 print_err_oom();
3825 goto error;
3826 }
3827 break;
3828 case OPT_NAME:
3829 if (cur_name_prefix->len == 0) {
3830 printf_err("No current component to name:\n %s\n",
b07ffa28
PP		 3831 arg);
3832 goto error;
3833 }
3834
db0f160a
PP		 3835 if (bt_value_array_append_string(run_args, "--name")) {
3836 print_err_oom();
ad6a19bd
PP		 3837 goto error;
3838 }
3839
db0f160a
PP		 3840 if (bt_value_array_append_string(run_args, arg)) {
3841 print_err_oom();
3842 goto error;
3843 }
ad6a19bd 3844
db0f160a
PP		 3845 g_string_assign(cur_name, arg);
3846 break;
3847 case OPT_OMIT_HOME_PLUGIN_PATH:
3848 if (bt_value_array_append_string(run_args,
3849 "--omit-home-plugin-path")) {
ad6a19bd
PP		 3850 print_err_oom();
3851 goto error;
3852 }
3853 break;
db0f160a
PP		 3854 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
3855 if (bt_value_array_append_string(run_args,
3856 "--omit-system-plugin-path")) {
3857 print_err_oom();
3b6cfcc5
PP		 3858 goto error;
3859 }
db0f160a
PP		 3860 break;
3861 case OPT_PLUGIN_PATH:
3862 if (bt_config_append_plugin_paths_check_setuid_setgid(
3863 plugin_paths, arg)) {
3b6cfcc5
PP		 3864 goto error;
3865 }
3866
db0f160a
PP		 3867 if (bt_value_array_append_string(run_args,
3868 "--plugin-path")) {
3869 print_err_oom();
3870 goto error;
3871 }
3b6cfcc5 3872
db0f160a 3873 if (bt_value_array_append_string(run_args, arg)) {
3b6cfcc5
PP		 3874 print_err_oom();
3875 goto error;
3876 }
3877 break;
db0f160a
PP		 3878 case OPT_HELP:
3879 print_convert_usage(stdout);
3880 *retcode = -1;
3881 BT_PUT(cfg);
3882 goto end;
3883 case OPT_BEGIN:
3884 case OPT_CLOCK_CYCLES:
3885 case OPT_CLOCK_DATE:
3886 case OPT_CLOCK_FORCE_CORRELATE:
3887 case OPT_CLOCK_GMT:
3888 case OPT_CLOCK_OFFSET:
3889 case OPT_CLOCK_OFFSET_NS:
3890 case OPT_CLOCK_SECONDS:
3891 case OPT_COLOR:
3892 case OPT_DEBUG:
3893 case OPT_DEBUG_INFO_DIR:
3894 case OPT_DEBUG_INFO_FULL_PATH:
3895 case OPT_DEBUG_INFO_TARGET_PREFIX:
3896 case OPT_END:
3897 case OPT_FIELDS:
3898 case OPT_INPUT_FORMAT:
3899 case OPT_NAMES:
3900 case OPT_NO_DEBUG_INFO:
3901 case OPT_NO_DELTA:
3902 case OPT_OUTPUT_FORMAT:
3903 case OPT_OUTPUT:
3904 case OPT_RUN_ARGS:
3905 case OPT_RUN_ARGS_0:
3906 case OPT_STREAM_INTERSECTION:
3907 case OPT_TIMERANGE:
3908 case OPT_VERBOSE:
3909 /* Ignore in this pass */
3910 break;
3911 default:
3912 printf_err("Unknown command-line option specified (option code %d)\n",
3913 opt);
3914 goto error;
3915 }
b07ffa28 3916
db0f160a
PP		 3917 free(arg);
3918 arg = NULL;
3919 }
3920
3921 /* Append current component's name if needed */
3922 ret = convert_append_name_param(cur_comp_dest, cur_name,
3923 cur_name_prefix, run_args, all_names, &source_names,
3924 &filter_names, &sink_names);
3925 if (ret) {
3926 goto error;
3927 }
3928
3929 /* Check for option parsing error */
3930 if (opt < -1) {
3931 printf_err("While parsing command-line options, at option %s: %s\n",
3932 poptBadOption(pc, 0), poptStrerror(opt));
3933 goto error;
3934 }
3935
3936 poptFreeContext(pc);
3937 free(arg);
3938 arg = NULL;
3939
3940 /*
3941 * Second pass: transform the convert-specific options and
3942 * arguments into implicit component instances for the run
3943 * command.
3944 */
3945 pc = poptGetContext(NULL, argc, (const char **) argv,
3946 convert_long_options, 0);
3947 if (!pc) {
3948 printf_err("Cannot get popt context\n");
3949 goto error;
3950 }
3951
3952 poptReadDefaultConfig(pc, 0);
3953
3954 while ((opt = poptGetNextOpt(pc)) > 0) {
3955 arg = poptGetOptArg(pc);
3956
3957 switch (opt) {
3958 case OPT_BEGIN:
3959 if (trimmer_has_begin) {
3960 printf("At --begin option: --begin or --timerange option already specified\n %s\n",
b07ffa28
PP		 3961 arg);
3962 goto error;
3963 }
3964
db0f160a
PP		 3965 trimmer_has_begin = true;
3966 ret = append_implicit_component_extra_arg(
3967 &implicit_trimmer_args, "begin", arg);
3968 implicit_trimmer_args.exists = true;
3969 if (ret) {
3970 goto error;
3971 }
b07ffa28 3972 break;
db0f160a
PP		 3973 case OPT_END:
3974 if (trimmer_has_end) {
3975 printf("At --end option: --end or --timerange option already specified\n %s\n",
3976 arg);
3977 goto error;
3978 }
3979
3980 trimmer_has_end = true;
3981 ret = append_implicit_component_extra_arg(
3982 &implicit_trimmer_args, "end", arg);
3983 implicit_trimmer_args.exists = true;
3984 if (ret) {
b07ffa28
PP		 3985 goto error;
3986 }
3987 break;
db0f160a
PP		 3988 case OPT_TIMERANGE:
3989 {
3990 char *begin;
3991 char *end;
3992
3993 if (trimmer_has_begin || trimmer_has_end) {
3994 printf("At --timerange option: --begin, --end, or --timerange option already specified\n %s\n",
3995 arg);
c42c79ea
PP		 3996 goto error;
3997 }
3998
db0f160a
PP		 3999 ret = split_timerange(arg, &begin, &end);
4000 if (ret) {
4001 printf_err("Invalid --timerange option's argument: expecting BEGIN,END or [BEGIN,END]:\n %s\n",
2703153b 4002 arg);
c42c79ea
PP		 4003 goto error;
4004 }
db0f160a
PP		 4005
4006 ret = append_implicit_component_extra_arg(
4007 &implicit_trimmer_args, "begin", begin);
4008 ret |= append_implicit_component_extra_arg(
4009 &implicit_trimmer_args, "end", end);
4010 implicit_trimmer_args.exists = true;
4011 free(begin);
4012 free(end);
4013 if (ret) {
4014 goto error;
4015 }
4016 break;
4017 }
4018 case OPT_CLOCK_CYCLES:
4019 append_implicit_component_param(
4020 &implicit_text_args, "clock-cycles", "yes");
4021 implicit_text_args.exists = true;
4022 break;
4023 case OPT_CLOCK_DATE:
4024 append_implicit_component_param(
4025 &implicit_text_args, "clock-date", "yes");
4026 implicit_text_args.exists = true;
4027 break;
4028 case OPT_CLOCK_FORCE_CORRELATE:
4029 append_implicit_component_param(
4030 &implicit_muxer_args, "force-correlate", "yes");
4031 break;
4032 case OPT_CLOCK_GMT:
4033 append_implicit_component_param(
4034 &implicit_text_args, "clock-gmt", "yes");
4035 implicit_text_args.exists = true;
4036 break;
4037 case OPT_CLOCK_OFFSET:
4038 ret = append_implicit_component_extra_arg(
4039 &implicit_ctf_args, "clock-offset-cycles", arg);
4040 implicit_ctf_args.exists = true;
4041 if (ret) {
4042 goto error;
4043 }
c42c79ea 4044 break;
db0f160a
PP		 4045 case OPT_CLOCK_OFFSET_NS:
4046 ret = append_implicit_component_extra_arg(
4047 &implicit_ctf_args, "clock-offset-ns", arg);
4048 implicit_ctf_args.exists = true;
4049 if (ret) {
c42c79ea
PP		 4050 goto error;
4051 }
4052 break;
c42c79ea 4053 case OPT_CLOCK_SECONDS:
db0f160a
PP		 4054 append_implicit_component_param(
4055 &implicit_text_args, "clock-seconds", "yes");
4056 implicit_text_args.exists = true;
c42c79ea 4057 break;
db0f160a
PP		 4058 case OPT_COLOR:
4059 ret = append_implicit_component_extra_arg(
4060 &implicit_text_args, "color", arg);
4061 implicit_text_args.exists = true;
4062 if (ret) {
4063 goto error;
4064 }
c42c79ea 4065 break;
db0f160a
PP		 4066 case OPT_NO_DEBUG_INFO:
4067 implicit_debug_info_args.exists = false;
4068 break;
4069 case OPT_DEBUG_INFO_DIR:
4070 ret = append_implicit_component_extra_arg(
4071 &implicit_debug_info_args, "dir", arg);
4072 if (ret) {
4073 goto error;
4074 }
c42c79ea
PP		 4075 break;
4076 case OPT_DEBUG_INFO_FULL_PATH:
db0f160a
PP		 4077 append_implicit_component_param(
4078 &implicit_debug_info_args, "full-path", "yes");
c42c79ea 4079 break;
db0f160a
PP		 4080 case OPT_DEBUG_INFO_TARGET_PREFIX:
4081 ret = append_implicit_component_extra_arg(
4082 &implicit_debug_info_args,
4083 "target-prefix", arg);
4084 if (ret) {
4085 goto error;
4086 }
4087 break;
4088 case OPT_FIELDS:
c42c79ea 4089 {
db0f160a 4090 struct bt_value *fields = fields_from_arg(arg);
c42c79ea 4091
db0f160a 4092 if (!fields) {
c42c79ea
PP		 4093 goto error;
4094 }
4095
db0f160a
PP		 4096 ret = insert_flat_params_from_array(
4097 implicit_text_args.params_arg,
4098 fields, "field");
4099 bt_put(fields);
4100 if (ret) {
c42c79ea
PP		 4101 goto error;
4102 }
c42c79ea
PP		 4103 break;
4104 }
db0f160a 4105 case OPT_NAMES:
c42c79ea 4106 {
db0f160a 4107 struct bt_value *names = names_from_arg(arg);
c42c79ea 4108
db0f160a 4109 if (!names) {
c42c79ea
PP		 4110 goto error;
4111 }
4112
db0f160a
PP		 4113 ret = insert_flat_params_from_array(
4114 implicit_text_args.params_arg,
4115 names, "name");
4116 bt_put(names);
4117 if (ret) {
c42c79ea
PP		 4118 goto error;
4119 }
c42c79ea
PP		 4120 break;
4121 }
db0f160a
PP		 4122 case OPT_NO_DELTA:
4123 append_implicit_component_param(
4124 &implicit_text_args, "no-delta", "yes");
4125 implicit_text_args.exists = true;
c42c79ea 4126 break;
db0f160a
PP		 4127 case OPT_INPUT_FORMAT:
4128 if (got_input_format_opt) {
4129 printf_err("Duplicate --input-format option\n");
0f9915c6
MD		 4130 goto error;
4131 }
db0f160a
PP		 4132
4133 got_input_format_opt = true;
4134
4135 if (strcmp(arg, "ctf") == 0) {
4136 implicit_ctf_args.exists = true;
4137 } else if (strcmp(arg, "lttng-live") == 0) {
4138 implicit_lttng_live_args.exists = true;
4139 } else {
4140 printf_err("Unknown legacy input format:\n %s\n",
2703153b 4141 arg);
0f9915c6
MD		 4142 goto error;
4143 }
0f9915c6 4144 break;
db0f160a
PP		 4145 case OPT_OUTPUT_FORMAT:
4146 if (got_output_format_opt) {
4147 printf_err("Duplicate --output-format option\n");
0f9915c6
MD		 4148 goto error;
4149 }
0f9915c6 4150
db0f160a
PP		 4151 got_output_format_opt = true;
4152
4153 if (strcmp(arg, "text") == 0) {
4154 implicit_text_args.exists = true;
4155 } else if (strcmp(arg, "dummy") == 0) {
4156 implicit_dummy_args.exists = true;
4157 } else if (strcmp(arg, "ctf-metadata") == 0) {
4158 print_ctf_metadata = true;
4159 } else {
4160 printf_err("Unknown legacy output format:\n %s\n",
2703153b 4161 arg);
0f9915c6
MD		 4162 goto error;
4163 }
db0f160a
PP		 4164 break;
4165 case OPT_OUTPUT:
4166 ret = append_implicit_component_extra_arg(
4167 &implicit_text_args, "path", arg);
4168 implicit_text_args.exists = true;
4169 if (ret) {
0f9915c6
MD		 4170 goto error;
4171 }
db0f160a
PP		 4172 break;
4173 case OPT_RUN_ARGS:
4174 if (print_run_args_0) {
4175 printf_err("Cannot specify --run-args and --run-args-0\n");
0f9915c6
MD		 4176 goto error;
4177 }
db0f160a
PP		 4178
4179 print_run_args = true;
0f9915c6 4180 break;
db0f160a
PP		 4181 case OPT_RUN_ARGS_0:
4182 if (print_run_args) {
4183 printf_err("Cannot specify --run-args and --run-args-0\n");
ebba3338
PP		 4184 goto error;
4185 }
db0f160a
PP		 4186
4187 print_run_args_0 = true;
4188 break;
4189 case OPT_STREAM_INTERSECTION:
4190 append_implicit_component_param(&implicit_ctf_args,
4191 "stream-intersection", "yes");
4192 implicit_ctf_args.exists = true;
ebba3338 4193 break;
c42c79ea 4194 case OPT_VERBOSE:
ae3b9aa4 4195 if (got_verbose_opt) {
db0f160a 4196 printf_err("Duplicate -v/--verbose option\n");
ae3b9aa4
PP		 4197 goto error;
4198 }
4199
db0f160a
PP		 4200 append_implicit_component_param(&implicit_text_args,
4201 "verbose", "yes");
4202 implicit_text_args.exists = true;
ae3b9aa4 4203 got_verbose_opt = true;
c42c79ea
PP		 4204 break;
4205 case OPT_DEBUG:
db0f160a 4206 got_debug_opt = true;
c42c79ea 4207 break;
c42c79ea
PP		 4208 }
4209
4210 free(arg);
4211 arg = NULL;
4212 }
4213
4214 /* Check for option parsing error */
4215 if (opt < -1) {
4216 printf_err("While parsing command-line options, at option %s: %s\n",
4217 poptBadOption(pc, 0), poptStrerror(opt));
4218 goto error;
4219 }
4220
db0f160a
PP		 4221 /*
4222 * Append home and system plugin paths now that we possibly got
4223 * --plugin-path.
4224 */
4225 if (append_home_and_system_plugin_paths(plugin_paths,
4226 omit_system_plugin_path, omit_home_plugin_path)) {
4227 goto error;
4228 }
c42c79ea 4229
db0f160a
PP		 4230 /* Consume leftover argument */
4231 leftover = poptGetArg(pc);
4232
4233 if (poptPeekArg(pc)) {
4234 printf_err("Unexpected argument:\n %s\n",
4235 poptPeekArg(pc));
4236 goto error;
4237 }
4238
4239 /* Print CTF metadata or print LTTng-live sessions */
4240 if (print_ctf_metadata) {
4241 if (!leftover) {
4242 printf_err("--output-format=ctf-metadata specified without a path\n");
4243 goto error;
c42c79ea
PP		 4244 }
4245
db0f160a
PP		 4246 cfg = bt_config_print_ctf_metadata_create(plugin_paths);
4247 if (!cfg) {
c42c79ea
PP		 4248 goto error;
4249 }
db0f160a
PP		 4250
4251 cfg->debug = got_debug_opt;
4252 cfg->verbose = got_verbose_opt;
4253 g_string_assign(cfg->cmd_data.print_ctf_metadata.path,
4254 leftover);
4255 goto end;
4256 }
4257
4258 /*
4259 * If -o dummy was not specified, and if there are no explicit
4260 * sink components, then use an implicit `text.text` sink.
4261 */
4262 if (!implicit_dummy_args.exists && !sink_names) {
4263 implicit_text_args.exists = true;
4264 }
4265
4266 /* Decide where the leftover argument goes */
4267 if (leftover) {
4268 if (implicit_lttng_live_args.exists) {
4269 lttng_live_url_parts =
4270 bt_common_parse_lttng_live_url(leftover,
4271 error_buf, 256);
4272 if (!lttng_live_url_parts.proto) {
4273 printf_err("Invalid LTTng-live URL format: %s\n",
4274 error_buf);
4275 goto error;
4276 }
4277
4278 if (!lttng_live_url_parts.session_name) {
4279 /* Print LTTng-live sessions */
4280 cfg = bt_config_print_lttng_live_sessions_create(
4281 plugin_paths);
4282 if (!cfg) {
4283 goto error;
4284 }
4285
4286 cfg->debug = got_debug_opt;
4287 cfg->verbose = got_verbose_opt;
4288 g_string_assign(cfg->cmd_data.print_lttng_live_sessions.url,
4289 leftover);
4290 goto end;
4291 }
4292
4293 ret = append_implicit_component_extra_arg(
4294 &implicit_lttng_live_args, "url", leftover);
4295 if (ret) {
4296 goto error;
4297 }
4298 } else {
4299 ret = append_implicit_component_extra_arg(
4300 &implicit_ctf_args, "path", leftover);
4301 implicit_ctf_args.exists = true;
4302 if (ret) {
4303 goto error;
4304 }
4305 }
4306 }
4307
4308 /*
4309 * Ensure mutual exclusion between implicit `ctf.fs` and
4310 * `ctf.lttng-live` sources.
4311 */
4312 if (implicit_ctf_args.exists && implicit_lttng_live_args.exists) {
4313 printf_err("Cannot create both implicit `ctf.fs` and `ctf.lttng-live` source components\n");
4314 goto error;
4315 }
4316
4317 /*
4318 * If the implicit `ctf.fs` or `ctf.lttng-live` source exists,
4319 * make sure there's a leftover (which is the path or URL).
4320 */
4321 if (implicit_ctf_args.exists && !leftover) {
4322 printf_err("Missing path for implicit `ctf.fs` source component\n");
4323 goto error;
4324 }
4325
4326 if (implicit_lttng_live_args.exists && !leftover) {
4327 printf_err("Missing URL for implicit `ctf.lttng-live` source component\n");
4328 goto error;
4329 }
4330
4331 /* Assign names to implicit components */
4332 ret = assign_name_to_implicit_component(&implicit_ctf_args,
4333 "ctf", all_names, &source_names, true);
4334 if (ret) {
4335 goto error;
4336 }
4337
4338 ret = assign_name_to_implicit_component(&implicit_lttng_live_args,
4339 "lttng-live", all_names, &source_names, true);
4340 if (ret) {
4341 goto error;
4342 }
4343
4344 ret = assign_name_to_implicit_component(&implicit_text_args,
4345 "text", all_names, &sink_names, true);
4346 if (ret) {
4347 goto error;
4348 }
4349
4350 ret = assign_name_to_implicit_component(&implicit_dummy_args,
4351 "dummy", all_names, &sink_names, true);
4352 if (ret) {
4353 goto error;
4354 }
4355
4356 ret = assign_name_to_implicit_component(&implicit_muxer_args,
4357 "mux", all_names, NULL, false);
4358 if (ret) {
4359 goto error;
4360 }
4361
4362 ret = assign_name_to_implicit_component(&implicit_trimmer_args,
4363 "trim", all_names, NULL, false);
4364 if (ret) {
4365 goto error;
c42c79ea
PP		 4366 }
4367
db0f160a
PP		 4368 ret = assign_name_to_implicit_component(&implicit_debug_info_args,
4369 "debug-info", all_names, NULL, false);
4370 if (ret) {
6cf24c61
MD		 4371 goto error;
4372 }
4373
db0f160a
PP		 4374 /* Make sure there's at least one source and one sink */
4375 if (!source_names) {
4376 printf_err("No source component\n");
4377 goto error;
6cf24c61 4378 }
6cf24c61 4379
db0f160a
PP		 4380 if (!sink_names) {
4381 printf_err("No sink component\n");
c42c79ea
PP		 4382 goto error;
4383 }
4384
4385 /*
db0f160a
PP		 4386 * Prepend the muxer, the trimmer, and the debug info to the
4387 * filter chain so that we have:
4388 *
4389 * sources -> muxer -> [trimmer] -> [debug info] ->
4390 * [user filters] -> sinks
c42c79ea 4391 */
db0f160a
PP		 4392 if (implicit_debug_info_args.exists) {
4393 if (g_list_prepend_gstring(&filter_names,
4394 implicit_debug_info_args.name_arg->str)) {
c42c79ea
PP		 4395 goto error;
4396 }
db0f160a
PP		 4397 }
4398
4399 if (implicit_trimmer_args.exists) {
4400 if (g_list_prepend_gstring(&filter_names,
4401 implicit_trimmer_args.name_arg->str)) {
bd9f0fa2
MD		 4402 goto error;
4403 }
c42c79ea
PP		 4404 }
4405
db0f160a
PP		 4406 if (g_list_prepend_gstring(&filter_names,
4407 implicit_muxer_args.name_arg->str)) {
4408 goto error;
05a67631
PP		 4409 }
4410
c42c79ea 4411 /*
db0f160a
PP		 4412 * Append the equivalent run arguments for the implicit
4413 * components.
c42c79ea 4414 */
db0f160a
PP		 4415 ret = append_run_args_for_implicit_component(
4416 BT_COMPONENT_CLASS_TYPE_SOURCE, &implicit_ctf_args, run_args);
4417 if (ret) {
4418 goto error;
c42c79ea
PP		 4419 }
4420
db0f160a
PP		 4421 ret = append_run_args_for_implicit_component(
4422 BT_COMPONENT_CLASS_TYPE_SOURCE, &implicit_lttng_live_args,
4423 run_args);
4424 if (ret) {
4425 goto error;
bd9f0fa2
MD		 4426 }
4427
db0f160a
PP		 4428 ret = append_run_args_for_implicit_component(
4429 BT_COMPONENT_CLASS_TYPE_SINK, &implicit_text_args, run_args);
4430 if (ret) {
4431 goto error;
4432 }
4433
4434 ret = append_run_args_for_implicit_component(
4435 BT_COMPONENT_CLASS_TYPE_SINK, &implicit_dummy_args, run_args);
4436 if (ret) {
4437 goto error;
4438 }
4439
4440 ret = append_run_args_for_implicit_component(
4441 BT_COMPONENT_CLASS_TYPE_FILTER, &implicit_muxer_args, run_args);
4442 if (ret) {
4443 goto error;
4444 }
4445
4446 ret = append_run_args_for_implicit_component(
4447 BT_COMPONENT_CLASS_TYPE_FILTER, &implicit_trimmer_args,
4448 run_args);
ebba3338 4449 if (ret) {
ebba3338
PP		 4450 goto error;
4451 }
4452
db0f160a
PP		 4453 ret = append_run_args_for_implicit_component(
4454 BT_COMPONENT_CLASS_TYPE_FILTER, &implicit_debug_info_args,
4455 run_args);
4456 if (ret) {
4457 goto error;
4458 }
4459
4460 /* Auto-connect components */
4461 ret = convert_auto_connect(run_args, source_names, filter_names,
4462 sink_names);
4463 if (ret) {
4464 printf_err("Cannot auto-connect components\n");
4465 goto error;
4466 }
4467
4468 /*
4469 * We have all the run command arguments now. Depending on
4470 * --run-args, we pass this to the run command or print them
4471 * here.
4472 */
4473 if (print_run_args || print_run_args_0) {
4474 for (i = 0; i < bt_value_array_size(run_args); i++) {
4475 struct bt_value *arg_value =
4476 bt_value_array_get(run_args, i);
4477 const char *arg;
4478 GString *quoted = NULL;
4479 const char *arg_to_print;
4480
4481 assert(arg_value);
4482 ret = bt_value_string_get(arg_value, &arg);
4483 assert(ret == 0);
4484 BT_PUT(arg_value);
4485
4486 if (print_run_args) {
4487 quoted = bt_common_shell_quote(arg);
4488 if (!quoted) {
4489 goto error;
4490 }
4491
4492 arg_to_print = quoted->str;
4493 } else {
4494 arg_to_print = arg;
4495 }
4496
4497 printf("%s", arg_to_print);
4498
4499 if (quoted) {
4500 g_string_free(quoted, TRUE);
4501 }
4502
4503 if (i < bt_value_array_size(run_args) - 1) {
4504 if (print_run_args) {
4505 putchar(' ');
4506 } else {
4507 putchar('\0');
4508 }
4509 }
4510 }
4511
4512 *retcode = -1;
4513 BT_PUT(cfg);
4514 goto end;
4515 }
4516
4517 cfg = bt_config_run_from_args_array(run_args, retcode,
4518 omit_system_plugin_path, omit_home_plugin_path,
4519 initial_plugin_paths);
c42c79ea
PP		 4520 goto end;
4521
4522error:
290725f7
PP		 4523 *retcode = 1;
4524 BT_PUT(cfg);
4525
c42c79ea
PP		 4526end:
4527 if (pc) {
4528 poptFreeContext(pc);
4529 }
4530
db0f160a 4531 free(arg);
c42c79ea 4532
db0f160a
PP		 4533 if (cur_name) {
4534 g_string_free(cur_name, TRUE);
c42c79ea
PP		 4535 }
4536
db0f160a
PP		 4537 if (cur_name_prefix) {
4538 g_string_free(cur_name_prefix, TRUE);
c42c79ea
PP		 4539 }
4540
db0f160a
PP		 4541 bt_put(run_args);
4542 bt_put(all_names);
4543 destroy_glist_of_gstring(source_names);
4544 destroy_glist_of_gstring(filter_names);
4545 destroy_glist_of_gstring(sink_names);
4546 destroy_implicit_component_args(&implicit_ctf_args);
4547 destroy_implicit_component_args(&implicit_lttng_live_args);
4548 destroy_implicit_component_args(&implicit_dummy_args);
4549 destroy_implicit_component_args(&implicit_text_args);
4550 destroy_implicit_component_args(&implicit_debug_info_args);
4551 destroy_implicit_component_args(&implicit_muxer_args);
4552 destroy_implicit_component_args(&implicit_trimmer_args);
4553 bt_put(plugin_paths);
4554 bt_common_destroy_lttng_live_url_parts(&lttng_live_url_parts);
290725f7
PP		 4555 return cfg;
4556}
4557
4558/*
4559 * Prints the Babeltrace 2.x general usage.
4560 */
4561static
4562void print_gen_usage(FILE *fp)
4563{
db0f160a 4564 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] [COMMAND] [COMMAND ARGUMENTS]\n");
290725f7
PP		 4565 fprintf(fp, "\n");
4566 fprintf(fp, "General options:\n");
4567 fprintf(fp, "\n");
db0f160a 4568 fprintf(fp, " -d, --debug Turn on debug mode\n");
290725f7 4569 fprintf(fp, " -h --help Show this help and quit\n");
db0f160a 4570 fprintf(fp, " -v, --verbose Turn on verbose mode\n");
290725f7
PP		 4571 fprintf(fp, " -V, --version Show version and quit\n");
4572 fprintf(fp, "\n");
4573 fprintf(fp, "Available commands:\n");
4574 fprintf(fp, "\n");
db0f160a 4575 fprintf(fp, " convert Convert and trim traces (default)\n");
22e22462 4576 fprintf(fp, " help Get help for a plugin or a component class\n");
290725f7 4577 fprintf(fp, " list-plugins List available plugins and their content\n");
a67681c1 4578 fprintf(fp, " query Query objects from a component class\n");
db0f160a 4579 fprintf(fp, " run Build a processing graph and run it\n");
290725f7
PP		 4580 fprintf(fp, "\n");
4581 fprintf(fp, "Use `babeltrace COMMAND --help` to show the help of COMMAND.\n");
4582}
4583
4584struct bt_config *bt_config_from_args(int argc, const char *argv[],
4585 int *retcode, bool omit_system_plugin_path,
4586 bool omit_home_plugin_path,
4587 struct bt_value *initial_plugin_paths)
4588{
4589 struct bt_config *config = NULL;
4590 bool verbose = false;
4591 bool debug = false;
4592 int i;
290725f7
PP		 4593 const char **command_argv = NULL;
4594 int command_argc = -1;
4595 const char *command_name = NULL;
4596
db0f160a
PP		 4597 enum command_type {
4598 COMMAND_TYPE_NONE = -1,
4599 COMMAND_TYPE_RUN = 0,
4600 COMMAND_TYPE_CONVERT,
4601 COMMAND_TYPE_LIST_PLUGINS,
4602 COMMAND_TYPE_HELP,
4603 COMMAND_TYPE_QUERY,
4604 } command_type = COMMAND_TYPE_NONE;
4605
290725f7
PP		 4606 *retcode = -1;
4607
db0f160a
PP		 4608 if (!initial_plugin_paths) {
4609 initial_plugin_paths = bt_value_array_create();
4610 if (!initial_plugin_paths) {
4611 *retcode = 1;
4612 goto end;
4613 }
4614 } else {
4615 bt_get(initial_plugin_paths);
4616 }
4617
290725f7
PP		 4618 if (argc <= 1) {
4619 print_gen_usage(stdout);
4620 goto end;
4621 }
4622
4623 for (i = 1; i < argc; i++) {
4624 const char *cur_arg = argv[i];
4625
4626 if (strcmp(cur_arg, "-d") == 0 ||
4627 strcmp(cur_arg, "--debug") == 0) {
4628 debug = true;
4629 } else if (strcmp(cur_arg, "-v") == 0 ||
4630 strcmp(cur_arg, "--verbose") == 0) {
4631 verbose = true;
4632 } else if (strcmp(cur_arg, "-V") == 0 ||
4633 strcmp(cur_arg, "--version") == 0) {
4634 print_version();
4635 goto end;
4636 } else if (strcmp(cur_arg, "-h") == 0 ||
4637 strcmp(cur_arg, "--help") == 0) {
4638 print_gen_usage(stdout);
4639 goto end;
290725f7 4640 } else {
22e22462
PP		 4641 bool has_command = true;
4642
290725f7
PP		 4643 /*
4644 * First unknown argument: is it a known command
4645 * name?
4646 */
4647 if (strcmp(cur_arg, "convert") == 0) {
db0f160a 4648 command_type = COMMAND_TYPE_CONVERT;
290725f7 4649 } else if (strcmp(cur_arg, "list-plugins") == 0) {
db0f160a 4650 command_type = COMMAND_TYPE_LIST_PLUGINS;
22e22462 4651 } else if (strcmp(cur_arg, "help") == 0) {
db0f160a 4652 command_type = COMMAND_TYPE_HELP;
a67681c1 4653 } else if (strcmp(cur_arg, "query") == 0) {
db0f160a
PP		 4654 command_type = COMMAND_TYPE_QUERY;
4655 } else if (strcmp(cur_arg, "run") == 0) {
4656 command_type = COMMAND_TYPE_RUN;
290725f7
PP		 4657 } else {
4658 /*
4659 * Unknown argument, but not a known
4660 * command name: assume the whole
4661 * arguments are for the default convert
4662 * command.
4663 */
db0f160a 4664 command_type = COMMAND_TYPE_CONVERT;
290725f7
PP		 4665 command_argv = argv;
4666 command_argc = argc;
22e22462
PP		 4667 has_command = false;
4668 }
4669
4670 if (has_command) {
4671 command_argv = &argv[i];
4672 command_argc = argc - i;
4673 command_name = cur_arg;
290725f7
PP		 4674 }
4675 break;
4676 }
4677 }
4678
db0f160a 4679 if (command_type == COMMAND_TYPE_NONE) {
290725f7
PP		 4680 /*
4681 * We only got non-help, non-version general options
4682 * like --verbose and --debug, without any other
4683 * arguments, so we can't do anything useful: print the
4684 * usage and quit.
4685 */
4686 print_gen_usage(stdout);
4687 goto end;
4688 }
4689
4690 assert(command_argv);
4691 assert(command_argc >= 0);
4692
db0f160a
PP		 4693 switch (command_type) {
4694 case COMMAND_TYPE_RUN:
4695 config = bt_config_run_from_args(command_argc, command_argv,
4696 retcode, omit_system_plugin_path,
4697 omit_home_plugin_path, initial_plugin_paths);
4698 break;
4699 case COMMAND_TYPE_CONVERT:
290725f7
PP		 4700 config = bt_config_convert_from_args(command_argc, command_argv,
4701 retcode, omit_system_plugin_path,
4702 omit_home_plugin_path, initial_plugin_paths);
4703 break;
db0f160a 4704 case COMMAND_TYPE_LIST_PLUGINS:
290725f7
PP		 4705 config = bt_config_list_plugins_from_args(command_argc,
4706 command_argv, retcode, omit_system_plugin_path,
4707 omit_home_plugin_path, initial_plugin_paths);
4708 break;
db0f160a 4709 case COMMAND_TYPE_HELP:
22e22462
PP		 4710 config = bt_config_help_from_args(command_argc,
4711 command_argv, retcode, omit_system_plugin_path,
4712 omit_home_plugin_path, initial_plugin_paths);
4713 break;
db0f160a 4714 case COMMAND_TYPE_QUERY:
a67681c1 4715 config = bt_config_query_from_args(command_argc,
63ce0e1d
PP		 4716 command_argv, retcode, omit_system_plugin_path,
4717 omit_home_plugin_path, initial_plugin_paths);
4718 break;
290725f7
PP		 4719 default:
4720 assert(false);
4721 }
4722
4723 if (config) {
4724 if (verbose) {
4725 config->verbose = true;
4726 }
4727
4728 if (debug) {
4729 config->debug = true;
4730 }
4731
4732 config->command_name = command_name;
4733 }
4734
4735end:
db0f160a 4736 bt_put(initial_plugin_paths);
290725f7 4737 return config;
c42c79ea 4738}
BabelTrace - Trace Format Babel Tower
This page took 0.246093 seconds and 4 git commands to generate.