cli/babeltrace-cfg-cli-args.c

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