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 or component class 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] TYPE.PLUGIN.CLS OBJECT\n");
1954         fprintf(fp, "\n");
1955         fprintf(fp, "Options:\n");
1956         fprintf(fp, "\n");
1957         fprintf(fp, "      --omit-home-plugin-path       Omit home plugins from plugin search path\n");
1958         fprintf(fp, "                                    (~/.local/lib/babeltrace/plugins)\n");
1959         fprintf(fp, "      --omit-system-plugin-path     Omit system plugins from plugin search path\n");
1960         fprintf(fp, "  -p, --params=PARAMS               Set the query parameters to PARAMS\n");
1961         fprintf(fp, "                                    (see the expected format of PARAMS below)\n");
1962         fprintf(fp, "      --plugin-path=PATH[:PATH]...  Add PATH to the list of paths from which\n");
1963         fprintf(fp, "                                    dynamic plugins can be loaded\n");
1964         fprintf(fp, "  -h, --help                        Show this help and quit\n");
1965         fprintf(fp, "\n\n");
1966         print_expected_params_format(fp);
1967 }
1968
1969 static
1970 struct poptOption query_long_options[] = {
1971         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
1972         { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
1973         { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
1974         { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
1975         { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
1976         { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
1977         { NULL, 0, '\0', NULL, 0, NULL, NULL },
1978 };
1979
1980 /*
1981  * Creates a Babeltrace config object from the arguments of a query
1982  * command.
1983  *
1984  * *retcode is set to the appropriate exit code to use.
1985  */
1986 static
1987 struct bt_config *bt_config_query_from_args(int argc, const char *argv[],
1988                 int *retcode, bool force_omit_system_plugin_path,
1989                 bool force_omit_home_plugin_path,
1990                 struct bt_value *initial_plugin_paths)
1991 {
1992         poptContext pc = NULL;
1993         char *arg = NULL;
1994         int opt;
1995         int ret;
1996         struct bt_config *cfg = NULL;
1997         const char *leftover;
1998         struct bt_value *params = bt_value_null;
1999
2000         *retcode = 0;
2001         cfg = bt_config_query_create(initial_plugin_paths);
2002         if (!cfg) {
2003                 goto error;
2004         }
2005
2006         cfg->omit_system_plugin_path = force_omit_system_plugin_path;
2007         cfg->omit_home_plugin_path = force_omit_home_plugin_path;
2008         ret = append_env_var_plugin_paths(cfg->plugin_paths);
2009         if (ret) {
2010                 goto error;
2011         }
2012
2013         /* Parse options */
2014         pc = poptGetContext(NULL, argc, (const char **) argv,
2015                 query_long_options, 0);
2016         if (!pc) {
2017                 printf_err("Cannot get popt context\n");
2018                 goto error;
2019         }
2020
2021         poptReadDefaultConfig(pc, 0);
2022
2023         while ((opt = poptGetNextOpt(pc)) > 0) {
2024                 arg = poptGetOptArg(pc);
2025
2026                 switch (opt) {
2027                 case OPT_PLUGIN_PATH:
2028                         if (bt_config_append_plugin_paths_check_setuid_setgid(
2029                                         cfg->plugin_paths, arg)) {
2030                                 goto error;
2031                         }
2032                         break;
2033                 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2034                         cfg->omit_system_plugin_path = true;
2035                         break;
2036                 case OPT_OMIT_HOME_PLUGIN_PATH:
2037                         cfg->omit_home_plugin_path = true;
2038                         break;
2039                 case OPT_PARAMS:
2040                 {
2041                         bt_put(params);
2042                         params = bt_value_from_arg(arg);
2043                         if (!params) {
2044                                 printf_err("Invalid format for --params option's argument:\n    %s\n",
2045                                         arg);
2046                                 goto error;
2047                         }
2048                         break;
2049                 }
2050                 case OPT_HELP:
2051                         print_query_usage(stdout);
2052                         *retcode = -1;
2053                         BT_PUT(cfg);
2054                         goto end;
2055                 default:
2056                         printf_err("Unknown command-line option specified (option code %d)\n",
2057                                 opt);
2058                         goto error;
2059                 }
2060
2061                 free(arg);
2062                 arg = NULL;
2063         }
2064
2065         /* Check for option parsing error */
2066         if (opt < -1) {
2067                 printf_err("While parsing command-line options, at option %s: %s\n",
2068                         poptBadOption(pc, 0), poptStrerror(opt));
2069                 goto error;
2070         }
2071
2072         /*
2073          * We need exactly two leftover arguments which are the
2074          * mandatory component class specification and query object.
2075          */
2076         leftover = poptGetArg(pc);
2077         if (leftover) {
2078                 cfg->cmd_data.query.cfg_component =
2079                         bt_config_component_from_arg(leftover);
2080                 if (!cfg->cmd_data.query.cfg_component) {
2081                         printf_err("Invalid format for component class specification:\n    %s\n",
2082                                 leftover);
2083                         goto error;
2084                 }
2085
2086                 assert(params);
2087                 BT_MOVE(cfg->cmd_data.query.cfg_component->params, params);
2088         } else {
2089                 print_query_usage(stdout);
2090                 *retcode = -1;
2091                 BT_PUT(cfg);
2092                 goto end;
2093         }
2094
2095         leftover = poptGetArg(pc);
2096         if (leftover) {
2097                 if (strlen(leftover) == 0) {
2098                         printf_err("Invalid empty object\n");
2099                         goto error;
2100                 }
2101
2102                 g_string_assign(cfg->cmd_data.query.object, leftover);
2103         } else {
2104                 print_query_usage(stdout);
2105                 *retcode = -1;
2106                 BT_PUT(cfg);
2107                 goto end;
2108         }
2109
2110         leftover = poptGetArg(pc);
2111         if (leftover) {
2112                 printf_err("Unexpected argument: %s\n", leftover);
2113                 goto error;
2114         }
2115
2116         if (append_home_and_system_plugin_paths_cfg(cfg)) {
2117                 goto error;
2118         }
2119
2120         goto end;
2121
2122 error:
2123         *retcode = 1;
2124         BT_PUT(cfg);
2125
2126 end:
2127         if (pc) {
2128                 poptFreeContext(pc);
2129         }
2130
2131         bt_put(params);
2132         free(arg);
2133         return cfg;
2134 }
2135
2136 /*
2137  * Prints the list-plugins command usage.
2138  */
2139 static
2140 void print_list_plugins_usage(FILE *fp)
2141 {
2142         fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] list-plugins [OPTIONS]\n");
2143         fprintf(fp, "\n");
2144         fprintf(fp, "Options:\n");
2145         fprintf(fp, "\n");
2146         fprintf(fp, "      --omit-home-plugin-path       Omit home plugins from plugin search path\n");
2147         fprintf(fp, "                                    (~/.local/lib/babeltrace/plugins)\n");
2148         fprintf(fp, "      --omit-system-plugin-path     Omit system plugins from plugin search path\n");
2149         fprintf(fp, "      --plugin-path=PATH[:PATH]...  Add PATH to the list of paths from which\n");
2150         fprintf(fp, "                                    dynamic plugins can be loaded\n");
2151         fprintf(fp, "  -h, --help                        Show this help and quit\n");
2152         fprintf(fp, "\n");
2153         fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2154         fprintf(fp, "\n");
2155         fprintf(fp, "Use `babeltrace help` to get help for a specific plugin or component class.\n");
2156 }
2157
2158 static
2159 struct poptOption list_plugins_long_options[] = {
2160         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2161         { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2162         { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2163         { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2164         { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2165         { NULL, 0, '\0', NULL, 0, NULL, NULL },
2166 };
2167
2168 /*
2169  * Creates a Babeltrace config object from the arguments of a
2170  * list-plugins command.
2171  *
2172  * *retcode is set to the appropriate exit code to use.
2173  */
2174 static
2175 struct bt_config *bt_config_list_plugins_from_args(int argc, const char *argv[],
2176                 int *retcode, bool force_omit_system_plugin_path,
2177                 bool force_omit_home_plugin_path,
2178                 struct bt_value *initial_plugin_paths)
2179 {
2180         poptContext pc = NULL;
2181         char *arg = NULL;
2182         int opt;
2183         int ret;
2184         struct bt_config *cfg = NULL;
2185         const char *leftover;
2186
2187         *retcode = 0;
2188         cfg = bt_config_list_plugins_create(initial_plugin_paths);
2189         if (!cfg) {
2190                 goto error;
2191         }
2192
2193         cfg->omit_system_plugin_path = force_omit_system_plugin_path;
2194         cfg->omit_home_plugin_path = force_omit_home_plugin_path;
2195         ret = append_env_var_plugin_paths(cfg->plugin_paths);
2196         if (ret) {
2197                 goto error;
2198         }
2199
2200         /* Parse options */
2201         pc = poptGetContext(NULL, argc, (const char **) argv,
2202                 list_plugins_long_options, 0);
2203         if (!pc) {
2204                 printf_err("Cannot get popt context\n");
2205                 goto error;
2206         }
2207
2208         poptReadDefaultConfig(pc, 0);
2209
2210         while ((opt = poptGetNextOpt(pc)) > 0) {
2211                 arg = poptGetOptArg(pc);
2212
2213                 switch (opt) {
2214                 case OPT_PLUGIN_PATH:
2215                         if (bt_config_append_plugin_paths_check_setuid_setgid(
2216                                         cfg->plugin_paths, arg)) {
2217                                 goto error;
2218                         }
2219                         break;
2220                 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2221                         cfg->omit_system_plugin_path = true;
2222                         break;
2223                 case OPT_OMIT_HOME_PLUGIN_PATH:
2224                         cfg->omit_home_plugin_path = true;
2225                         break;
2226                 case OPT_HELP:
2227                         print_list_plugins_usage(stdout);
2228                         *retcode = -1;
2229                         BT_PUT(cfg);
2230                         goto end;
2231                 default:
2232                         printf_err("Unknown command-line option specified (option code %d)\n",
2233                                 opt);
2234                         goto error;
2235                 }
2236
2237                 free(arg);
2238                 arg = NULL;
2239         }
2240
2241         /* Check for option parsing error */
2242         if (opt < -1) {
2243                 printf_err("While parsing command-line options, at option %s: %s\n",
2244                         poptBadOption(pc, 0), poptStrerror(opt));
2245                 goto error;
2246         }
2247
2248         leftover = poptGetArg(pc);
2249         if (leftover) {
2250                 printf_err("Unexpected argument: %s\n", leftover);
2251                 goto error;
2252         }
2253
2254         if (append_home_and_system_plugin_paths_cfg(cfg)) {
2255                 goto error;
2256         }
2257
2258         goto end;
2259
2260 error:
2261         *retcode = 1;
2262         BT_PUT(cfg);
2263
2264 end:
2265         if (pc) {
2266                 poptFreeContext(pc);
2267         }
2268
2269         free(arg);
2270         return cfg;
2271 }
2272
2273 /*
2274  * Prints the run command usage.
2275  */
2276 static
2277 void print_run_usage(FILE *fp)
2278 {
2279         fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] run [OPTIONS]\n");
2280         fprintf(fp, "\n");
2281         fprintf(fp, "Options:\n");
2282         fprintf(fp, "\n");
2283         fprintf(fp, "  -b, --base-params=PARAMS          Set PARAMS as the current base parameters\n");
2284         fprintf(fp, "                                    for all the following components until\n");
2285         fprintf(fp, "                                    --reset-base-params is encountered\n");
2286         fprintf(fp, "                                    (see the expected format of PARAMS below)\n");
2287         fprintf(fp, "  -c, --component=[NAME:]TYPE.PLUGIN.CLS\n");
2288         fprintf(fp, "                                    Instantiate the component class CLS of type\n");
2289         fprintf(fp, "                                    TYPE (`source`, `filter`, or `sink`) found\n");
2290         fprintf(fp, "                                    in the plugin PLUGIN, add it to the graph,\n");
2291         fprintf(fp, "                                    and optionally name it NAME (you can also\n");
2292         fprintf(fp, "                                    specify the name with --name)\n");
2293         fprintf(fp, "  -C, --connect=CONNECTION          Connect two created components (see the\n");
2294         fprintf(fp, "                                    expected format of CONNECTION below)\n");
2295         fprintf(fp, "      --key=KEY                     Set the current initialization string\n");
2296         fprintf(fp, "                                    parameter key to KEY (see --value)\n");
2297         fprintf(fp, "  -n, --name=NAME                   Set the name of the current component\n");
2298         fprintf(fp, "                                    to NAME (must be unique amongst all the\n");
2299         fprintf(fp, "                                    names of the created components)\n");
2300         fprintf(fp, "      --omit-home-plugin-path       Omit home plugins from plugin search path\n");
2301         fprintf(fp, "                                    (~/.local/lib/babeltrace/plugins)\n");
2302         fprintf(fp, "      --omit-system-plugin-path     Omit system plugins from plugin search path\n");
2303         fprintf(fp, "  -p, --params=PARAMS               Add initialization parameters PARAMS to the\n");
2304         fprintf(fp, "                                    current component (see the expected format\n");
2305         fprintf(fp, "                                    of PARAMS below)\n");
2306         fprintf(fp, "      --plugin-path=PATH[:PATH]...  Add PATH to the list of paths from which\n");
2307         fprintf(fp, "                                    dynamic plugins can be loaded\n");
2308         fprintf(fp, "  -r, --reset-base-params           Reset the current base parameters to an\n");
2309         fprintf(fp, "                                    empty map\n");
2310         fprintf(fp, "      --retry-duration=DUR          When babeltrace(1) needs to retry to run\n");
2311         fprintf(fp, "                                    the graph later, retry in DUR µs\n");
2312         fprintf(fp, "                                    (default: 100000)\n");
2313         fprintf(fp, "      --value=VAL                   Add a string initialization parameter to\n");
2314         fprintf(fp, "                                    the current component with a name given by\n");
2315         fprintf(fp, "                                    the last argument of the --key option and a\n");
2316         fprintf(fp, "                                    value set to VAL\n");
2317         fprintf(fp, "  -h, --help                        Show this help and quit\n");
2318         fprintf(fp, "\n");
2319         fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2320         fprintf(fp, "\n\n");
2321         fprintf(fp, "Expected format of CONNECTION\n");
2322         fprintf(fp, "-----------------------------\n");
2323         fprintf(fp, "\n");
2324         fprintf(fp, "    UPSTREAM[.UPSTREAM-PORT]:DOWNSTREAM[.DOWNSTREAM-PORT]\n");
2325         fprintf(fp, "\n");
2326         fprintf(fp, "UPSTREAM and DOWNSTREAM are names of the upstream and downstream\n");
2327         fprintf(fp, "components to connect together. You must escape the following characters\n\n");
2328         fprintf(fp, "with `\\`: `\\`, `.`, and `:`. You can set the name of the current\n");
2329         fprintf(fp, "component with the --name option.\n");
2330         fprintf(fp, "\n");
2331         fprintf(fp, "UPSTREAM-PORT and DOWNSTREAM-PORT are optional globbing patterns to\n");
2332         fprintf(fp, "identify the upstream and downstream ports to use for the connection.\n");
2333         fprintf(fp, "When the port is not specified, `*` is used.\n");
2334         fprintf(fp, "\n");
2335         fprintf(fp, "When a component named UPSTREAM has an available port which matches the\n");
2336         fprintf(fp, "UPSTREAM-PORT globbing pattern, it is connected to the first port which\n");
2337         fprintf(fp, "matches the DOWNSTREAM-PORT globbing pattern of the component named\n");
2338         fprintf(fp, "DOWNSTREAM.\n");
2339         fprintf(fp, "\n");
2340         fprintf(fp, "The only special character in UPSTREAM-PORT and DOWNSTREAM-PORT is `*`\n");
2341         fprintf(fp, "which matches anything. You must escape the following characters\n");
2342         fprintf(fp, "with `\\`: `\\`, `*`, `?`, `[`, `.`, and `:`.\n");
2343         fprintf(fp, "\n");
2344         fprintf(fp, "You can connect a source component to a filter or sink component. You\n");
2345         fprintf(fp, "can connect a filter component to a sink component.\n");
2346         fprintf(fp, "\n");
2347         fprintf(fp, "Examples:\n");
2348         fprintf(fp, "\n");
2349         fprintf(fp, "    my-src:my-sink\n");
2350         fprintf(fp, "    ctf-fs.*stream*:utils-muxer:*\n");
2351         fprintf(fp, "\n");
2352         fprintf(fp, "IMPORTANT: Make sure to single-quote the whole argument when you run\n");
2353         fprintf(fp, "babeltrace from a shell.\n");
2354         fprintf(fp, "\n\n");
2355         print_expected_params_format(fp);
2356 }
2357
2358 /*
2359  * Creates a Babeltrace config object from the arguments of a run
2360  * command.
2361  *
2362  * *retcode is set to the appropriate exit code to use.
2363  */
2364 static
2365 struct bt_config *bt_config_run_from_args(int argc, const char *argv[],
2366                 int *retcode, bool force_omit_system_plugin_path,
2367                 bool force_omit_home_plugin_path,
2368                 struct bt_value *initial_plugin_paths)
2369 {
2370         poptContext pc = NULL;
2371         char *arg = NULL;
2372         struct bt_config_component *cur_cfg_comp = NULL;
2373         enum bt_config_component_dest cur_cfg_comp_dest =
2374                         BT_CONFIG_COMPONENT_DEST_UNKNOWN;
2375         struct bt_value *cur_base_params = NULL;
2376         int opt, ret = 0;
2377         struct bt_config *cfg = NULL;
2378         struct bt_value *instance_names = NULL;
2379         struct bt_value *connection_args = NULL;
2380         GString *cur_param_key = NULL;
2381         char error_buf[256] = { 0 };
2382         long long retry_duration = -1;
2383         struct poptOption run_long_options[] = {
2384                 { "base-params", 'b', POPT_ARG_STRING, NULL, OPT_BASE_PARAMS, NULL, NULL },
2385                 { "component", 'c', POPT_ARG_STRING, NULL, OPT_COMPONENT, NULL, NULL },
2386                 { "connect", 'C', POPT_ARG_STRING, NULL, OPT_CONNECT, NULL, NULL },
2387                 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2388                 { "key", '\0', POPT_ARG_STRING, NULL, OPT_KEY, NULL, NULL },
2389                 { "name", 'n', POPT_ARG_STRING, NULL, OPT_NAME, NULL, NULL },
2390                 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2391                 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2392                 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2393                 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2394                 { "reset-base-params", 'r', POPT_ARG_NONE, NULL, OPT_RESET_BASE_PARAMS, NULL, NULL },
2395                 { "retry-duration", '\0', POPT_ARG_LONGLONG, &retry_duration, OPT_RETRY_DURATION, NULL, NULL },
2396                 { "value", '\0', POPT_ARG_STRING, NULL, OPT_VALUE, NULL, NULL },
2397                 { NULL, 0, '\0', NULL, 0, NULL, NULL },
2398         };
2399
2400         *retcode = 0;
2401         cur_param_key = g_string_new(NULL);
2402         if (!cur_param_key) {
2403                 print_err_oom();
2404                 goto error;
2405         }
2406
2407         if (argc <= 1) {
2408                 print_run_usage(stdout);
2409                 *retcode = -1;
2410                 goto end;
2411         }
2412
2413         cfg = bt_config_run_create(initial_plugin_paths);
2414         if (!cfg) {
2415                 goto error;
2416         }
2417
2418         cfg->cmd_data.run.retry_duration_us = 100000;
2419         cfg->omit_system_plugin_path = force_omit_system_plugin_path;
2420         cfg->omit_home_plugin_path = force_omit_home_plugin_path;
2421         cur_base_params = bt_value_map_create();
2422         if (!cur_base_params) {
2423                 print_err_oom();
2424                 goto error;
2425         }
2426
2427         instance_names = bt_value_map_create();
2428         if (!instance_names) {
2429                 print_err_oom();
2430                 goto error;
2431         }
2432
2433         connection_args = bt_value_array_create();
2434         if (!connection_args) {
2435                 print_err_oom();
2436                 goto error;
2437         }
2438
2439         ret = append_env_var_plugin_paths(cfg->plugin_paths);
2440         if (ret) {
2441                 goto error;
2442         }
2443
2444         /* Parse options */
2445         pc = poptGetContext(NULL, argc, (const char **) argv,
2446                 run_long_options, 0);
2447         if (!pc) {
2448                 printf_err("Cannot get popt context\n");
2449                 goto error;
2450         }
2451
2452         poptReadDefaultConfig(pc, 0);
2453
2454         while ((opt = poptGetNextOpt(pc)) > 0) {
2455                 arg = poptGetOptArg(pc);
2456
2457                 switch (opt) {
2458                 case OPT_PLUGIN_PATH:
2459                         if (bt_config_append_plugin_paths_check_setuid_setgid(
2460                                         cfg->plugin_paths, arg)) {
2461                                 goto error;
2462                         }
2463                         break;
2464                 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2465                         cfg->omit_system_plugin_path = true;
2466                         break;
2467                 case OPT_OMIT_HOME_PLUGIN_PATH:
2468                         cfg->omit_home_plugin_path = true;
2469                         break;
2470                 case OPT_COMPONENT:
2471                 {
2472                         enum bt_config_component_dest new_dest;
2473
2474                         if (cur_cfg_comp) {
2475                                 ret = add_run_cfg_comp_check_name(cfg,
2476                                         cur_cfg_comp, cur_cfg_comp_dest,
2477                                         instance_names);
2478                                 BT_PUT(cur_cfg_comp);
2479                                 if (ret) {
2480                                         goto error;
2481                                 }
2482                         }
2483
2484                         cur_cfg_comp = bt_config_component_from_arg(arg);
2485                         if (!cur_cfg_comp) {
2486                                 printf_err("Invalid format for --component option's argument:\n    %s\n",
2487                                         arg);
2488                                 goto error;
2489                         }
2490
2491                         switch (cur_cfg_comp->type) {
2492                         case BT_COMPONENT_CLASS_TYPE_SOURCE:
2493                                 new_dest = BT_CONFIG_COMPONENT_DEST_SOURCE;
2494                                 break;
2495                         case BT_COMPONENT_CLASS_TYPE_FILTER:
2496                                 new_dest = BT_CONFIG_COMPONENT_DEST_FILTER;
2497                                 break;
2498                         case BT_COMPONENT_CLASS_TYPE_SINK:
2499                                 new_dest = BT_CONFIG_COMPONENT_DEST_SINK;
2500                                 break;
2501                         default:
2502                                 abort();
2503                         }
2504
2505                         assert(cur_base_params);
2506                         bt_put(cur_cfg_comp->params);
2507                         cur_cfg_comp->params = bt_value_copy(cur_base_params);
2508                         if (!cur_cfg_comp->params) {
2509                                 print_err_oom();
2510                                 goto error;
2511                         }
2512
2513                         cur_cfg_comp_dest = new_dest;
2514                         break;
2515                 }
2516                 case OPT_PARAMS:
2517                 {
2518                         struct bt_value *params;
2519                         struct bt_value *params_to_set;
2520
2521                         if (!cur_cfg_comp) {
2522                                 printf_err("Cannot add parameters to unavailable component:\n    %s\n",
2523                                         arg);
2524                                 goto error;
2525                         }
2526
2527                         params = bt_value_from_arg(arg);
2528                         if (!params) {
2529                                 printf_err("Invalid format for --params option's argument:\n    %s\n",
2530                                         arg);
2531                                 goto error;
2532                         }
2533
2534                         params_to_set = bt_value_map_extend(cur_cfg_comp->params,
2535                                 params);
2536                         BT_PUT(params);
2537                         if (!params_to_set) {
2538                                 printf_err("Cannot extend current component parameters with --params option's argument:\n    %s\n",
2539                                         arg);
2540                                 goto error;
2541                         }
2542
2543                         BT_MOVE(cur_cfg_comp->params, params_to_set);
2544                         break;
2545                 }
2546                 case OPT_KEY:
2547                         if (strlen(arg) == 0) {
2548                                 printf_err("Cannot set an empty string as the current parameter key\n");
2549                                 goto error;
2550                         }
2551
2552                         g_string_assign(cur_param_key, arg);
2553                         break;
2554                 case OPT_VALUE:
2555                         if (!cur_cfg_comp) {
2556                                 printf_err("Cannot set a parameter's value of unavailable component:\n    %s\n",
2557                                         arg);
2558                                 goto error;
2559                         }
2560
2561                         if (cur_param_key->len == 0) {
2562                                 printf_err("--value option specified without preceding --key option:\n    %s\n",
2563                                         arg);
2564                                 goto error;
2565                         }
2566
2567                         if (bt_value_map_insert_string(cur_cfg_comp->params,
2568                                         cur_param_key->str, arg)) {
2569                                 print_err_oom();
2570                                 goto error;
2571                         }
2572                         break;
2573                 case OPT_NAME:
2574                         if (!cur_cfg_comp) {
2575                                 printf_err("Cannot set the name of unavailable component:\n    %s\n",
2576                                         arg);
2577                                 goto error;
2578                         }
2579
2580                         g_string_assign(cur_cfg_comp->instance_name, arg);
2581                         break;
2582                 case OPT_BASE_PARAMS:
2583                 {
2584                         struct bt_value *params = bt_value_from_arg(arg);
2585
2586                         if (!params) {
2587                                 printf_err("Invalid format for --base-params option's argument:\n    %s\n",
2588                                         arg);
2589                                 goto error;
2590                         }
2591
2592                         BT_MOVE(cur_base_params, params);
2593                         break;
2594                 }
2595                 case OPT_RESET_BASE_PARAMS:
2596                         BT_PUT(cur_base_params);
2597                         cur_base_params = bt_value_map_create();
2598                         if (!cur_base_params) {
2599                                 print_err_oom();
2600                                 goto error;
2601                         }
2602                         break;
2603                 case OPT_CONNECT:
2604                         if (bt_value_array_append_string(connection_args,
2605                                         arg)) {
2606                                 print_err_oom();
2607                                 goto error;
2608                         }
2609                         break;
2610                 case OPT_RETRY_DURATION:
2611                         if (retry_duration < 0) {
2612                                 printf_err("--retry-duration option's argument must be positive or 0: %lld\n",
2613                                         retry_duration);
2614                                 goto error;
2615                         }
2616
2617                         cfg->cmd_data.run.retry_duration_us =
2618                                 (uint64_t) retry_duration;
2619                         break;
2620                 case OPT_HELP:
2621                         print_run_usage(stdout);
2622                         *retcode = -1;
2623                         BT_PUT(cfg);
2624                         goto end;
2625                 default:
2626                         printf_err("Unknown command-line option specified (option code %d)\n",
2627                                 opt);
2628                         goto error;
2629                 }
2630
2631                 free(arg);
2632                 arg = NULL;
2633         }
2634
2635         /* Check for option parsing error */
2636         if (opt < -1) {
2637                 printf_err("While parsing command-line options, at option %s: %s\n",
2638                         poptBadOption(pc, 0), poptStrerror(opt));
2639                 goto error;
2640         }
2641
2642         /* This command does not accept leftover arguments */
2643         if (poptPeekArg(pc)) {
2644                 printf_err("Unexpected argument: %s\n", poptPeekArg(pc));
2645                 goto error;
2646         }
2647
2648         /* Add current component */
2649         if (cur_cfg_comp) {
2650                 ret = add_run_cfg_comp_check_name(cfg, cur_cfg_comp,
2651                         cur_cfg_comp_dest, instance_names);
2652                 BT_PUT(cur_cfg_comp);
2653                 if (ret) {
2654                         goto error;
2655                 }
2656         }
2657
2658         if (cfg->cmd_data.run.sources->len == 0) {
2659                 printf_err("Incomplete graph: no source component\n");
2660                 goto error;
2661         }
2662
2663         if (cfg->cmd_data.run.sinks->len == 0) {
2664                 printf_err("Incomplete graph: no sink component\n");
2665                 goto error;
2666         }
2667
2668         if (append_home_and_system_plugin_paths_cfg(cfg)) {
2669                 goto error;
2670         }
2671
2672         ret = bt_config_cli_args_create_connections(cfg, connection_args,
2673                 error_buf, 256);
2674         if (ret) {
2675                 printf_err("Cannot creation connections:\n%s", error_buf);
2676                 goto error;
2677         }
2678
2679         goto end;
2680
2681 error:
2682         *retcode = 1;
2683         BT_PUT(cfg);
2684
2685 end:
2686         if (pc) {
2687                 poptFreeContext(pc);
2688         }
2689
2690         if (cur_param_key) {
2691                 g_string_free(cur_param_key, TRUE);
2692         }
2693
2694         free(arg);
2695         BT_PUT(cur_cfg_comp);
2696         BT_PUT(cur_base_params);
2697         BT_PUT(instance_names);
2698         BT_PUT(connection_args);
2699         return cfg;
2700 }
2701
2702 static
2703 struct bt_config *bt_config_run_from_args_array(struct bt_value *run_args,
2704                 int *retcode, bool force_omit_system_plugin_path,
2705                 bool force_omit_home_plugin_path,
2706                 struct bt_value *initial_plugin_paths)
2707 {
2708         struct bt_config *cfg = NULL;
2709         const char **argv;
2710         int64_t i, len;
2711         const size_t argc = bt_value_array_size(run_args) + 1;
2712
2713         argv = calloc(argc, sizeof(*argv));
2714         if (!argv) {
2715                 print_err_oom();
2716                 goto end;
2717         }
2718
2719         argv[0] = "run";
2720
2721         len = bt_value_array_size(run_args);
2722         if (len < 0) {
2723                 printf_err("Invalid executable arguments\n");
2724                 goto end;
2725         }
2726         for (i = 0; i < len; i++) {
2727                 int ret;
2728                 struct bt_value *arg_value = bt_value_array_get(run_args, i);
2729                 const char *arg;
2730
2731                 assert(arg_value);
2732                 ret = bt_value_string_get(arg_value, &arg);
2733                 assert(ret == 0);
2734                 assert(arg);
2735                 argv[i + 1] = arg;
2736                 bt_put(arg_value);
2737         }
2738
2739         cfg = bt_config_run_from_args(argc, argv, retcode,
2740                 force_omit_system_plugin_path, force_omit_home_plugin_path,
2741                 initial_plugin_paths);
2742
2743 end:
2744         free(argv);
2745         return cfg;
2746 }
2747
2748 /*
2749  * Prints the convert command usage.
2750  */
2751 static
2752 void print_convert_usage(FILE *fp)
2753 {
2754         fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] [convert] [OPTIONS] [PATH/URL]\n");
2755         fprintf(fp, "\n");
2756         fprintf(fp, "Options:\n");
2757         fprintf(fp, "\n");
2758         fprintf(fp, "  -c, --component=[NAME:]TYPE.PLUGIN.CLS\n");
2759         fprintf(fp, "                                    Instantiate the component class CLS of type\n");
2760         fprintf(fp, "                                    TYPE (`source`, `filter`, or `sink`) found\n");
2761         fprintf(fp, "                                    in the plugin PLUGIN, add it to the\n");
2762         fprintf(fp, "                                    conversion graph, and optionally name it\n");
2763         fprintf(fp, "                                    NAME (you can also specify the name with\n");
2764         fprintf(fp, "                                    --name)\n");
2765         fprintf(fp, "      --name=NAME                   Set the name of the current component\n");
2766         fprintf(fp, "                                    to NAME (must be unique amongst all the\n");
2767         fprintf(fp, "                                    names of the created components)\n");
2768         fprintf(fp, "      --omit-home-plugin-path       Omit home plugins from plugin search path\n");
2769         fprintf(fp, "                                    (~/.local/lib/babeltrace/plugins)\n");
2770         fprintf(fp, "      --omit-system-plugin-path     Omit system plugins from plugin search path\n");
2771         fprintf(fp, "  -p, --params=PARAMS               Add initialization parameters PARAMS to the\n");
2772         fprintf(fp, "                                    current component (see the expected format\n");
2773         fprintf(fp, "                                    of PARAMS below)\n");
2774         fprintf(fp, "  -P, --path=PATH                   Set the `path` string parameter of the\n");
2775         fprintf(fp, "                                    current component to PATH\n");
2776         fprintf(fp, "      --plugin-path=PATH[:PATH]...  Add PATH to the list of paths from which\n");
2777         fprintf(fp, "      --retry-duration=DUR          When babeltrace(1) needs to retry to run\n");
2778         fprintf(fp, "                                    the graph later, retry in DUR µs\n");
2779         fprintf(fp, "                                    (default: 100000)\n");
2780         fprintf(fp, "                                    dynamic plugins can be loaded\n");
2781         fprintf(fp, "      --run-args                    Print the equivalent arguments for the\n");
2782         fprintf(fp, "                                    `run` command to the standard output,\n");
2783         fprintf(fp, "                                    formatted for a shell, and quit\n");
2784         fprintf(fp, "      --run-args-0                  Print the equivalent arguments for the\n");
2785         fprintf(fp, "                                    `run` command to the standard output,\n");
2786         fprintf(fp, "                                    formatted for `xargs -0`, and quit\n");
2787         fprintf(fp, "  -u, --url=URL                     Set the `url` string parameter of the\n");
2788         fprintf(fp, "                                    current component to URL\n");
2789         fprintf(fp, "  -h, --help                        Show this help and quit\n");
2790         fprintf(fp, "\n");
2791         fprintf(fp, "Implicit `source.ctf.fs` component options:\n");
2792         fprintf(fp, "\n");
2793         fprintf(fp, "      --clock-offset=SEC            Set clock offset to SEC seconds\n");
2794         fprintf(fp, "      --clock-offset-ns=NS          Set clock offset to NS ns\n");
2795         fprintf(fp, "      --stream-intersection         Only process events when all streams\n");
2796         fprintf(fp, "                                    are active\n");
2797         fprintf(fp, "\n");
2798         fprintf(fp, "Implicit `sink.text.pretty` component options:\n");
2799         fprintf(fp, "\n");
2800         fprintf(fp, "      --clock-cycles                Print timestamps in clock cycles\n");
2801         fprintf(fp, "      --clock-date                  Print timestamp dates\n");
2802         fprintf(fp, "      --clock-gmt                   Print and parse timestamps in the GMT\n");
2803         fprintf(fp, "                                    time zone instead of the local time zone\n");
2804         fprintf(fp, "      --clock-seconds               Print the timestamps as `SEC.NS` instead\n");
2805         fprintf(fp, "                                    of `hh:mm:ss.nnnnnnnnn`\n");
2806         fprintf(fp, "      --color=(never | auto | always)\n");
2807         fprintf(fp, "                                    Never, automatically, or always emit\n");
2808         fprintf(fp, "                                    console color codes\n");
2809         fprintf(fp, "  -f, --fields=FIELD[,FIELD]...     Print additional fields; FIELD can be:\n");
2810         fprintf(fp, "                                      `all`, `trace`, `trace:hostname`,\n");
2811         fprintf(fp, "                                      `trace:domain`, `trace:procname`,\n");
2812         fprintf(fp, "                                      `trace:vpid`, `loglevel`, `emf`\n");
2813         fprintf(fp, "  -n, --names=NAME[,NAME]...        Print field names; NAME can be:\n");
2814         fprintf(fp, "                                      `payload` (or `arg` or `args`), `none`,\n");
2815         fprintf(fp, "                                      `all`, `scope`, `header`, `context`\n");
2816         fprintf(fp, "                                      (or `ctx`)\n");
2817         fprintf(fp, "      --no-delta                    Do not print time delta between\n");
2818         fprintf(fp, "                                    consecutive events\n");
2819         fprintf(fp, "  -w, --output=PATH                 Write output text to PATH instead of\n");
2820         fprintf(fp, "                                    the standard output\n");
2821         fprintf(fp, "\n");
2822         fprintf(fp, "Implicit `filter.utils.muxer` component options:\n");
2823         fprintf(fp, "\n");
2824         fprintf(fp, "      --clock-force-correlate       Assume that clocks are inherently\n");
2825         fprintf(fp, "                                    correlated across traces\n");
2826         fprintf(fp, "\n");
2827         fprintf(fp, "Implicit `filter.utils.trimmer` component options:\n");
2828         fprintf(fp, "\n");
2829         fprintf(fp, "  -b, --begin=BEGIN                 Set the beginning time of the conversion\n");
2830         fprintf(fp, "                                    time range to BEGIN (see the format of\n");
2831         fprintf(fp, "                                    BEGIN below)\n");
2832         fprintf(fp, "  -e, --end=END                     Set the end time of the conversion time\n");
2833         fprintf(fp, "                                    range to END (see the format of END below)\n");
2834         fprintf(fp, "  -t, --timerange=TIMERANGE         Set conversion time range to TIMERANGE:\n");
2835         fprintf(fp, "                                    BEGIN,END or [BEGIN,END] (literally `[` and\n");
2836         fprintf(fp, "                                    `]`) (see the format of BEGIN/END below)\n");
2837         fprintf(fp, "\n");
2838         fprintf(fp, "Implicit `filter.lttng-utils.debug-info` component options:\n");
2839         fprintf(fp, "\n");
2840         fprintf(fp, "      --debug-info-dir=DIR          Search for debug info in directory DIR\n");
2841         fprintf(fp, "                                    instead of `/usr/lib/debug`\n");
2842         fprintf(fp, "      --debug-info-full-path        Show full debug info source and\n");
2843         fprintf(fp, "                                    binary paths instead of just names\n");
2844         fprintf(fp, "      --debug-info-target-prefix=DIR\n");
2845         fprintf(fp, "                                    Use directory DIR as a prefix when\n");
2846         fprintf(fp, "                                    looking up executables during debug\n");
2847         fprintf(fp, "                                    info analysis\n");
2848         fprintf(fp, "      --no-debug-info               Do not create an implicit\n");
2849         fprintf(fp, "                                    `lttng-utils.debug-info` filter component\n");
2850         fprintf(fp, "\n");
2851         fprintf(fp, "Legacy options that still work:\n");
2852         fprintf(fp, "\n");
2853         fprintf(fp, "  -i, --input-format=(ctf | lttng-live)\n");
2854         fprintf(fp, "                                    `ctf`:\n");
2855         fprintf(fp, "                                      Create an implicit `source.ctf.fs`\n");
2856         fprintf(fp, "                                      component\n");
2857         fprintf(fp, "                                    `lttng-live`:\n");
2858         fprintf(fp, "                                      Create an implicit `source.ctf.lttng-live`\n");
2859         fprintf(fp, "                                      component\n");
2860         fprintf(fp, "  -o, --output-format=(text | ctf | dummy | ctf-metadata)\n");
2861         fprintf(fp, "                                    `text`:\n");
2862         fprintf(fp, "                                      Create an implicit `sink.text.pretty`\n");
2863         fprintf(fp, "                                      component\n");
2864         fprintf(fp, "                                    `ctf`:\n");
2865         fprintf(fp, "                                      Create an implicit `sink.ctf.fs`\n");
2866         fprintf(fp, "                                      component\n");
2867         fprintf(fp, "                                    `dummy`:\n");
2868         fprintf(fp, "                                      Create an implicit `sink.utils.dummy`\n");
2869         fprintf(fp, "                                      component\n");
2870         fprintf(fp, "                                    `ctf-metadata`:\n");
2871         fprintf(fp, "                                      Query the `source.ctf.fs` component class\n");
2872         fprintf(fp, "                                      for metadata text and quit\n");
2873         fprintf(fp, "\n");
2874         fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2875         fprintf(fp, "\n\n");
2876         fprintf(fp, "Format of BEGIN and END\n");
2877         fprintf(fp, "-----------------------\n");
2878         fprintf(fp, "\n");
2879         fprintf(fp, "    [YYYY-MM-DD [hh:mm:]]ss[.nnnnnnnnn]\n");
2880         fprintf(fp, "\n\n");
2881         print_expected_params_format(fp);
2882 }
2883
2884 static
2885 struct poptOption convert_long_options[] = {
2886         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2887         { "begin", 'b', POPT_ARG_STRING, NULL, OPT_BEGIN, NULL, NULL },
2888         { "clock-cycles", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_CYCLES, NULL, NULL },
2889         { "clock-date", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_DATE, NULL, NULL },
2890         { "clock-force-correlate", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_FORCE_CORRELATE, NULL, NULL },
2891         { "clock-gmt", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_GMT, NULL, NULL },
2892         { "clock-offset", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET, NULL, NULL },
2893         { "clock-offset-ns", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET_NS, NULL, NULL },
2894         { "clock-seconds", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_SECONDS, NULL, NULL },
2895         { "color", '\0', POPT_ARG_STRING, NULL, OPT_COLOR, NULL, NULL },
2896         { "component", 'c', POPT_ARG_STRING, NULL, OPT_COMPONENT, NULL, NULL },
2897         { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL },
2898         { "debug-info-dir", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_DIR, NULL, NULL },
2899         { "debug-info-full-path", 0, POPT_ARG_NONE, NULL, OPT_DEBUG_INFO_FULL_PATH, NULL, NULL },
2900         { "debug-info-target-prefix", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_TARGET_PREFIX, NULL, NULL },
2901         { "end", 'e', POPT_ARG_STRING, NULL, OPT_END, NULL, NULL },
2902         { "fields", 'f', POPT_ARG_STRING, NULL, OPT_FIELDS, NULL, NULL },
2903         { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2904         { "input-format", 'i', POPT_ARG_STRING, NULL, OPT_INPUT_FORMAT, NULL, NULL },
2905         { "name", '\0', POPT_ARG_STRING, NULL, OPT_NAME, NULL, NULL },
2906         { "names", 'n', POPT_ARG_STRING, NULL, OPT_NAMES, NULL, NULL },
2907         { "no-debug-info", '\0', POPT_ARG_NONE, NULL, OPT_NO_DEBUG_INFO, NULL, NULL },
2908         { "no-delta", '\0', POPT_ARG_NONE, NULL, OPT_NO_DELTA, NULL, NULL },
2909         { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2910         { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2911         { "output", 'w', POPT_ARG_STRING, NULL, OPT_OUTPUT, NULL, NULL },
2912         { "output-format", 'o', POPT_ARG_STRING, NULL, OPT_OUTPUT_FORMAT, NULL, NULL },
2913         { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2914         { "path", 'P', POPT_ARG_STRING, NULL, OPT_PATH, NULL, NULL },
2915         { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2916         { "retry-duration", '\0', POPT_ARG_STRING, NULL, OPT_RETRY_DURATION, NULL, NULL },
2917         { "run-args", '\0', POPT_ARG_NONE, NULL, OPT_RUN_ARGS, NULL, NULL },
2918         { "run-args-0", '\0', POPT_ARG_NONE, NULL, OPT_RUN_ARGS_0, NULL, NULL },
2919         { "stream-intersection", '\0', POPT_ARG_NONE, NULL, OPT_STREAM_INTERSECTION, NULL, NULL },
2920         { "timerange", '\0', POPT_ARG_STRING, NULL, OPT_TIMERANGE, NULL, NULL },
2921         { "url", 'u', POPT_ARG_STRING, NULL, OPT_URL, NULL, NULL },
2922         { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL },
2923         { NULL, 0, '\0', NULL, 0, NULL, NULL },
2924 };
2925
2926 static
2927 GString *get_component_auto_name(const char *prefix,
2928                 struct bt_value *existing_names)
2929 {
2930         unsigned int i = 0;
2931         GString *auto_name = g_string_new(NULL);
2932
2933         if (!auto_name) {
2934                 print_err_oom();
2935                 goto end;
2936         }
2937
2938         if (!bt_value_map_has_key(existing_names, prefix)) {
2939                 g_string_assign(auto_name, prefix);
2940                 goto end;
2941         }
2942
2943         do {
2944                 g_string_printf(auto_name, "%s-%d", prefix, i);
2945                 i++;
2946         } while (bt_value_map_has_key(existing_names, auto_name->str));
2947
2948 end:
2949         return auto_name;
2950 }
2951
2952 struct implicit_component_args {
2953         bool exists;
2954         GString *comp_arg;
2955         GString *name_arg;
2956         GString *params_arg;
2957         struct bt_value *extra_params;
2958 };
2959
2960 static
2961 int assign_name_to_implicit_component(struct implicit_component_args *args,
2962                 const char *prefix, struct bt_value *existing_names,
2963                 GList **comp_names, bool append_to_comp_names)
2964 {
2965         int ret = 0;
2966         GString *name = NULL;
2967
2968         if (!args->exists) {
2969                 goto end;
2970         }
2971
2972         name = get_component_auto_name(prefix, existing_names);
2973
2974         if (!name) {
2975                 ret = -1;
2976                 goto end;
2977         }
2978
2979         g_string_assign(args->name_arg, name->str);
2980
2981         if (bt_value_map_insert(existing_names, name->str,
2982                         bt_value_null)) {
2983                 print_err_oom();
2984                 ret = -1;
2985                 goto end;
2986         }
2987
2988         if (append_to_comp_names) {
2989                 *comp_names = g_list_append(*comp_names, name);
2990                 name = NULL;
2991         }
2992
2993 end:
2994         if (name) {
2995                 g_string_free(name, TRUE);
2996         }
2997
2998         return ret;
2999 }
3000
3001 static
3002 int append_run_args_for_implicit_component(
3003                 struct implicit_component_args *impl_args,
3004                 struct bt_value *run_args)
3005 {
3006         int ret = 0;
3007         size_t i;
3008
3009         if (!impl_args->exists) {
3010                 goto end;
3011         }
3012
3013         if (bt_value_array_append_string(run_args, "--component")) {
3014                 print_err_oom();
3015                 goto error;
3016         }
3017
3018         if (bt_value_array_append_string(run_args, impl_args->comp_arg->str)) {
3019                 print_err_oom();
3020                 goto error;
3021         }
3022
3023         if (bt_value_array_append_string(run_args, "--name")) {
3024                 print_err_oom();
3025                 goto error;
3026         }
3027
3028         if (bt_value_array_append_string(run_args, impl_args->name_arg->str)) {
3029                 print_err_oom();
3030                 goto error;
3031         }
3032
3033         if (impl_args->params_arg->len > 0) {
3034                 if (bt_value_array_append_string(run_args, "--params")) {
3035                         print_err_oom();
3036                         goto error;
3037                 }
3038
3039                 if (bt_value_array_append_string(run_args,
3040                                 impl_args->params_arg->str)) {
3041                         print_err_oom();
3042                         goto error;
3043                 }
3044         }
3045
3046         for (i = 0; i < bt_value_array_size(impl_args->extra_params); i++) {
3047                 struct bt_value *elem;
3048                 const char *arg;
3049
3050                 elem = bt_value_array_get(impl_args->extra_params, i);
3051                 if (!elem) {
3052                         goto error;
3053                 }
3054
3055                 assert(bt_value_is_string(elem));
3056                 if (bt_value_string_get(elem, &arg)) {
3057                         goto error;
3058                 }
3059
3060                 ret = bt_value_array_append_string(run_args, arg);
3061                 bt_put(elem);
3062                 if (ret) {
3063                         print_err_oom();
3064                         goto error;
3065                 }
3066         }
3067
3068         goto end;
3069
3070 error:
3071         ret = -1;
3072
3073 end:
3074         return ret;
3075 }
3076
3077 static
3078 void finalize_implicit_component_args(struct implicit_component_args *args)
3079 {
3080         assert(args);
3081
3082         if (args->comp_arg) {
3083                 g_string_free(args->comp_arg, TRUE);
3084         }
3085
3086         if (args->name_arg) {
3087                 g_string_free(args->name_arg, TRUE);
3088         }
3089
3090         if (args->params_arg) {
3091                 g_string_free(args->params_arg, TRUE);
3092         }
3093
3094         bt_put(args->extra_params);
3095 }
3096
3097 static
3098 void destroy_implicit_component_args(void *args)
3099 {
3100         if (!args) {
3101                 return;
3102         }
3103
3104         finalize_implicit_component_args(args);
3105         g_free(args);
3106 }
3107
3108 static
3109 int init_implicit_component_args(struct implicit_component_args *args,
3110                 const char *comp_arg, bool exists)
3111 {
3112         int ret = 0;
3113
3114         args->exists = exists;
3115         args->comp_arg = g_string_new(comp_arg);
3116         args->name_arg = g_string_new(NULL);
3117         args->params_arg = g_string_new(NULL);
3118         args->extra_params = bt_value_array_create();
3119
3120         if (!args->comp_arg || !args->name_arg ||
3121                         !args->params_arg || !args->extra_params) {
3122                 ret = -1;
3123                 finalize_implicit_component_args(args);
3124                 print_err_oom();
3125                 goto end;
3126         }
3127
3128 end:
3129         return ret;
3130 }
3131
3132 static
3133 void append_implicit_component_param(struct implicit_component_args *args,
3134         const char *key, const char *value)
3135 {
3136         assert(args);
3137         assert(key);
3138         assert(value);
3139         append_param_arg(args->params_arg, key, value);
3140 }
3141
3142 static
3143 int append_implicit_component_extra_param(struct implicit_component_args *args,
3144                 const char *key, const char *value)
3145 {
3146         int ret = 0;
3147
3148         assert(args);
3149         assert(key);
3150         assert(value);
3151
3152         if (bt_value_array_append_string(args->extra_params, "--key")) {
3153                 print_err_oom();
3154                 ret = -1;
3155                 goto end;
3156         }
3157
3158         if (bt_value_array_append_string(args->extra_params, key)) {
3159                 print_err_oom();
3160                 ret = -1;
3161                 goto end;
3162         }
3163
3164         if (bt_value_array_append_string(args->extra_params, "--value")) {
3165                 print_err_oom();
3166                 ret = -1;
3167                 goto end;
3168         }
3169
3170         if (bt_value_array_append_string(args->extra_params, value)) {
3171                 print_err_oom();
3172                 ret = -1;
3173                 goto end;
3174         }
3175
3176 end:
3177         return ret;
3178 }
3179
3180 static
3181 int convert_append_name_param(enum bt_config_component_dest dest,
3182                 GString *cur_name, GString *cur_name_prefix,
3183                 struct bt_value *run_args, struct bt_value *all_names,
3184                 GList **source_names, GList **filter_names,
3185                 GList **sink_names)
3186 {
3187         int ret = 0;
3188
3189         if (cur_name_prefix->len > 0) {
3190                 /* We're after a --component option */
3191                 GString *name = NULL;
3192                 bool append_name_opt = false;
3193
3194                 if (cur_name->len == 0) {
3195                         /*
3196                          * No explicit name was provided for the user
3197                          * component.
3198                          */
3199                         name = get_component_auto_name(cur_name_prefix->str,
3200                                 all_names);
3201                         append_name_opt = true;
3202                 } else {
3203                         /*
3204                          * An explicit name was provided for the user
3205                          * component.
3206                          */
3207                         if (bt_value_map_has_key(all_names,
3208                                         cur_name->str)) {
3209                                 printf_err("Duplicate component instance name:\n    %s\n",
3210                                         cur_name->str);
3211                                 goto error;
3212                         }
3213
3214                         name = g_string_new(cur_name->str);
3215                 }
3216
3217                 if (!name) {
3218                         print_err_oom();
3219                         goto error;
3220                 }
3221
3222                 /*
3223                  * Remember this name globally, for the uniqueness of
3224                  * all component names.
3225                  */
3226                 if (bt_value_map_insert(all_names, name->str, bt_value_null)) {
3227                         print_err_oom();
3228                         goto error;
3229                 }
3230
3231                 /*
3232                  * Append the --name option if necessary.
3233                  */
3234                 if (append_name_opt) {
3235                         if (bt_value_array_append_string(run_args, "--name")) {
3236                                 print_err_oom();
3237                                 goto error;
3238                         }
3239
3240                         if (bt_value_array_append_string(run_args, name->str)) {
3241                                 print_err_oom();
3242                                 goto error;
3243                         }
3244                 }
3245
3246                 /*
3247                  * Remember this name specifically for the type of the
3248                  * component. This is to create connection arguments.
3249                  */
3250                 switch (dest) {
3251                 case BT_CONFIG_COMPONENT_DEST_SOURCE:
3252                         *source_names = g_list_append(*source_names, name);
3253                         break;
3254                 case BT_CONFIG_COMPONENT_DEST_FILTER:
3255                         *filter_names = g_list_append(*filter_names, name);
3256                         break;
3257                 case BT_CONFIG_COMPONENT_DEST_SINK:
3258                         *sink_names = g_list_append(*sink_names, name);
3259                         break;
3260                 default:
3261                         abort();
3262                 }
3263
3264                 g_string_assign(cur_name_prefix, "");
3265         }
3266
3267         goto end;
3268
3269 error:
3270         ret = -1;
3271
3272 end:
3273         return ret;
3274 }
3275
3276 /*
3277  * Escapes `.`, `:`, and `\` of `input` with `\`.
3278  */
3279 static
3280 GString *escape_dot_colon(const char *input)
3281 {
3282         GString *output = g_string_new(NULL);
3283         const char *ch;
3284
3285         if (!output) {
3286                 print_err_oom();
3287                 goto end;
3288         }
3289
3290         for (ch = input; *ch != '\0'; ch++) {
3291                 if (*ch == '\\' || *ch == '.' || *ch == ':') {
3292                         g_string_append_c(output, '\\');
3293                 }
3294
3295                 g_string_append_c(output, *ch);
3296         }
3297
3298 end:
3299         return output;
3300 }
3301
3302 /*
3303  * Appends a --connect option to a list of arguments. `upstream_name`
3304  * and `downstream_name` are escaped with escape_dot_colon() in this
3305  * function.
3306  */
3307 static
3308 int append_connect_arg(struct bt_value *run_args,
3309                 const char *upstream_name, const char *downstream_name)
3310 {
3311         int ret = 0;
3312         GString *e_upstream_name = escape_dot_colon(upstream_name);
3313         GString *e_downstream_name = escape_dot_colon(downstream_name);
3314         GString *arg = g_string_new(NULL);
3315
3316         if (!e_upstream_name || !e_downstream_name || !arg) {
3317                 print_err_oom();
3318                 ret = -1;
3319                 goto end;
3320         }
3321
3322         ret = bt_value_array_append_string(run_args, "--connect");
3323         if (ret) {
3324                 print_err_oom();
3325                 ret = -1;
3326                 goto end;
3327         }
3328
3329         g_string_append(arg, e_upstream_name->str);
3330         g_string_append_c(arg, ':');
3331         g_string_append(arg, e_downstream_name->str);
3332         ret = bt_value_array_append_string(run_args, arg->str);
3333         if (ret) {
3334                 print_err_oom();
3335                 ret = -1;
3336                 goto end;
3337         }
3338
3339 end:
3340         if (arg) {
3341                 g_string_free(arg, TRUE);
3342         }
3343
3344         if (e_upstream_name) {
3345                 g_string_free(e_upstream_name, TRUE);
3346         }
3347
3348         if (e_downstream_name) {
3349                 g_string_free(e_downstream_name, TRUE);
3350         }
3351
3352         return ret;
3353 }
3354
3355 /*
3356  * Appends the run command's --connect options for the convert command.
3357  */
3358 static
3359 int convert_auto_connect(struct bt_value *run_args,
3360                 GList *source_names, GList *filter_names,
3361                 GList *sink_names)
3362 {
3363         int ret = 0;
3364         GList *source_at = source_names;
3365         GList *filter_at = filter_names;
3366         GList *filter_prev;
3367         GList *sink_at = sink_names;
3368
3369         assert(source_names);
3370         assert(filter_names);
3371         assert(sink_names);
3372
3373         /* Connect all sources to the first filter */
3374         for (source_at = source_names; source_at != NULL; source_at = g_list_next(source_at)) {
3375                 GString *source_name = source_at->data;
3376                 GString *filter_name = filter_at->data;
3377
3378                 ret = append_connect_arg(run_args, source_name->str,
3379                         filter_name->str);
3380                 if (ret) {
3381                         goto error;
3382                 }
3383         }
3384
3385         filter_prev = filter_at;
3386         filter_at = g_list_next(filter_at);
3387
3388         /* Connect remaining filters */
3389         for (; filter_at != NULL; filter_prev = filter_at, filter_at = g_list_next(filter_at)) {
3390                 GString *filter_name = filter_at->data;
3391                 GString *filter_prev_name = filter_prev->data;
3392
3393                 ret = append_connect_arg(run_args, filter_prev_name->str,
3394                         filter_name->str);
3395                 if (ret) {
3396                         goto error;
3397                 }
3398         }
3399
3400         /* Connect last filter to all sinks */
3401         for (sink_at = sink_names; sink_at != NULL; sink_at = g_list_next(sink_at)) {
3402                 GString *filter_name = filter_prev->data;
3403                 GString *sink_name = sink_at->data;
3404
3405                 ret = append_connect_arg(run_args, filter_name->str,
3406                         sink_name->str);
3407                 if (ret) {
3408                         goto error;
3409                 }
3410         }
3411
3412         goto end;
3413
3414 error:
3415         ret = -1;
3416
3417 end:
3418         return ret;
3419 }
3420
3421 static
3422 int split_timerange(const char *arg, char **begin, char **end)
3423 {
3424         int ret = 0;
3425         const char *ch = arg;
3426         size_t end_pos;
3427         GString *g_begin = NULL;
3428         GString *g_end = NULL;
3429
3430         assert(arg);
3431
3432         if (*ch == '[') {
3433                 ch++;
3434         }
3435
3436         g_begin = bt_common_string_until(ch, "", ",", &end_pos);
3437         if (!g_begin || ch[end_pos] != ',' || g_begin->len == 0) {
3438                 goto error;
3439         }
3440
3441         ch += end_pos + 1;
3442
3443         g_end = bt_common_string_until(ch, "", "]", &end_pos);
3444         if (!g_end || g_end->len == 0) {
3445                 goto error;
3446         }
3447
3448         assert(begin);
3449         assert(end);
3450         *begin = g_begin->str;
3451         *end = g_end->str;
3452         g_string_free(g_begin, FALSE);
3453         g_string_free(g_end, FALSE);
3454         g_begin = NULL;
3455         g_end = NULL;
3456         goto end;
3457
3458 error:
3459         ret = -1;
3460
3461 end:
3462         if (g_begin) {
3463                 g_string_free(g_begin, TRUE);
3464         }
3465
3466         if (g_end) {
3467                 g_string_free(g_end, TRUE);
3468         }
3469
3470         return ret;
3471 }
3472
3473 static
3474 int g_list_prepend_gstring(GList **list, const char *string)
3475 {
3476         int ret = 0;
3477         GString *gs = g_string_new(string);
3478
3479         assert(list);
3480
3481         if (!gs) {
3482                 print_err_oom();
3483                 goto end;
3484         }
3485
3486         *list = g_list_prepend(*list, gs);
3487
3488 end:
3489         return ret;
3490 }
3491
3492 static
3493 struct implicit_component_args *create_implicit_component_args(void)
3494 {
3495         struct implicit_component_args *impl_args =
3496                 g_new0(struct implicit_component_args, 1);
3497
3498         if (!impl_args) {
3499                 goto end;
3500         }
3501
3502         if (init_implicit_component_args(impl_args, NULL, true)) {
3503                 destroy_implicit_component_args(impl_args);
3504                 impl_args = NULL;
3505                 goto end;
3506         }
3507
3508 end:
3509         return impl_args;
3510 }
3511
3512 static
3513 int fill_implicit_ctf_inputs_args(GPtrArray *implicit_ctf_inputs_args,
3514                 struct implicit_component_args *base_implicit_ctf_input_args,
3515                 GList *leftovers)
3516 {
3517         int ret = 0;
3518         GList *leftover;
3519
3520         for (leftover = leftovers; leftover != NULL;
3521                         leftover = g_list_next(leftover)) {
3522                 GString *gs_leftover = leftover->data;
3523                 struct implicit_component_args *impl_args =
3524                         create_implicit_component_args();
3525
3526                 if (!impl_args) {
3527                         print_err_oom();
3528                         goto error;
3529                 }
3530
3531                 impl_args->exists = true;
3532                 g_string_assign(impl_args->comp_arg,
3533                         base_implicit_ctf_input_args->comp_arg->str);
3534                 g_string_assign(impl_args->params_arg,
3535                         base_implicit_ctf_input_args->params_arg->str);
3536
3537                 /*
3538                  * We need our own copy of the extra parameters because
3539                  * this is where the unique path goes.
3540                  */
3541                 BT_PUT(impl_args->extra_params);
3542                 impl_args->extra_params =
3543                         bt_value_copy(base_implicit_ctf_input_args->extra_params);
3544                 if (!impl_args->extra_params) {
3545                         print_err_oom();
3546                         destroy_implicit_component_args(impl_args);
3547                         goto error;
3548                 }
3549
3550                 /* Append unique path parameter */
3551                 ret = append_implicit_component_extra_param(impl_args,
3552                         "path", gs_leftover->str);
3553                 if (ret) {
3554                         destroy_implicit_component_args(impl_args);
3555                         goto error;
3556                 }
3557
3558                 g_ptr_array_add(implicit_ctf_inputs_args, impl_args);
3559         }
3560
3561         goto end;
3562
3563 error:
3564         ret = -1;
3565
3566 end:
3567         return ret;
3568 }
3569
3570 /*
3571  * Creates a Babeltrace config object from the arguments of a convert
3572  * command.
3573  *
3574  * *retcode is set to the appropriate exit code to use.
3575  */
3576 static
3577 struct bt_config *bt_config_convert_from_args(int argc, const char *argv[],
3578                 int *retcode, bool force_omit_system_plugin_path,
3579                 bool force_omit_home_plugin_path, bool force_no_debug_info,
3580                 struct bt_value *initial_plugin_paths, char *log_level)
3581 {
3582         poptContext pc = NULL;
3583         char *arg = NULL;
3584         enum bt_config_component_dest cur_comp_dest =
3585                         BT_CONFIG_COMPONENT_DEST_UNKNOWN;
3586         int opt, ret = 0;
3587         struct bt_config *cfg = NULL;
3588         bool got_input_format_opt = false;
3589         bool got_output_format_opt = false;
3590         bool trimmer_has_begin = false;
3591         bool trimmer_has_end = false;
3592         bool stream_intersection_mode = false;
3593         GString *cur_name = NULL;
3594         GString *cur_name_prefix = NULL;
3595         const char *leftover = NULL;
3596         bool print_run_args = false;
3597         bool print_run_args_0 = false;
3598         bool print_ctf_metadata = false;
3599         struct bt_value *run_args = NULL;
3600         struct bt_value *all_names = NULL;
3601         GList *source_names = NULL;
3602         GList *filter_names = NULL;
3603         GList *sink_names = NULL;
3604         GList *leftovers = NULL;
3605         GPtrArray *implicit_ctf_inputs_args = NULL;
3606         struct implicit_component_args base_implicit_ctf_input_args = { 0 };
3607         struct implicit_component_args implicit_ctf_output_args = { 0 };
3608         struct implicit_component_args implicit_lttng_live_args = { 0 };
3609         struct implicit_component_args implicit_dummy_args = { 0 };
3610         struct implicit_component_args implicit_text_args = { 0 };
3611         struct implicit_component_args implicit_debug_info_args = { 0 };
3612         struct implicit_component_args implicit_muxer_args = { 0 };
3613         struct implicit_component_args implicit_trimmer_args = { 0 };
3614         struct bt_value *plugin_paths = bt_get(initial_plugin_paths);
3615         char error_buf[256] = { 0 };
3616         size_t i;
3617         struct bt_common_lttng_live_url_parts lttng_live_url_parts = { 0 };
3618         char *output = NULL;
3619
3620         *retcode = 0;
3621
3622         if (argc <= 1) {
3623                 print_convert_usage(stdout);
3624                 *retcode = -1;
3625                 goto end;
3626         }
3627
3628         if (init_implicit_component_args(&base_implicit_ctf_input_args,
3629                         "source.ctf.fs", false)) {
3630                 goto error;
3631         }
3632
3633         if (init_implicit_component_args(&implicit_ctf_output_args,
3634                         "sink.ctf.fs", false)) {
3635                 goto error;
3636         }
3637
3638         if (init_implicit_component_args(&implicit_lttng_live_args,
3639                         "source.ctf.lttng-live", false)) {
3640                 goto error;
3641         }
3642
3643         if (init_implicit_component_args(&implicit_text_args,
3644                         "sink.text.pretty", false)) {
3645                 goto error;
3646         }
3647
3648         if (init_implicit_component_args(&implicit_dummy_args,
3649                         "sink.utils.dummy", false)) {
3650                 goto error;
3651         }
3652
3653         if (init_implicit_component_args(&implicit_debug_info_args,
3654                         "filter.lttng-utils.debug-info", !force_no_debug_info)) {
3655                 goto error;
3656         }
3657
3658         if (init_implicit_component_args(&implicit_muxer_args,
3659                         "filter.utils.muxer", true)) {
3660                 goto error;
3661         }
3662
3663         if (init_implicit_component_args(&implicit_trimmer_args,
3664                         "filter.utils.trimmer", false)) {
3665                 goto error;
3666         }
3667
3668         implicit_ctf_inputs_args = g_ptr_array_new_with_free_func(
3669                 (GDestroyNotify) destroy_implicit_component_args);
3670         if (!implicit_ctf_inputs_args) {
3671                 print_err_oom();
3672                 goto error;
3673         }
3674
3675         all_names = bt_value_map_create();
3676         if (!all_names) {
3677                 print_err_oom();
3678                 goto error;
3679         }
3680
3681         run_args = bt_value_array_create();
3682         if (!run_args) {
3683                 print_err_oom();
3684                 goto error;
3685         }
3686
3687         cur_name = g_string_new(NULL);
3688         if (!cur_name) {
3689                 print_err_oom();
3690                 goto error;
3691         }
3692
3693         cur_name_prefix = g_string_new(NULL);
3694         if (!cur_name_prefix) {
3695                 print_err_oom();
3696                 goto error;
3697         }
3698
3699         ret = append_env_var_plugin_paths(plugin_paths);
3700         if (ret) {
3701                 goto error;
3702         }
3703
3704         /*
3705          * First pass: collect all arguments which need to be passed
3706          * as is to the run command. This pass can also add --name
3707          * arguments if needed to automatically name unnamed component
3708          * instances. Also it does the following transformations:
3709          *
3710          *     --path=PATH -> --key path --value PATH
3711          *     --url=URL   -> --key url --value URL
3712          *
3713          * Also it appends the plugin paths of --plugin-path to
3714          * `plugin_paths`.
3715          */
3716         pc = poptGetContext(NULL, argc, (const char **) argv,
3717                 convert_long_options, 0);
3718         if (!pc) {
3719                 printf_err("Cannot get popt context\n");
3720                 goto error;
3721         }
3722
3723         poptReadDefaultConfig(pc, 0);
3724
3725         while ((opt = poptGetNextOpt(pc)) > 0) {
3726                 char *name = NULL;
3727                 char *plugin_name = NULL;
3728                 char *comp_cls_name = NULL;
3729
3730                 arg = poptGetOptArg(pc);
3731
3732                 switch (opt) {
3733                 case OPT_COMPONENT:
3734                 {
3735                         enum bt_component_class_type type;
3736                         const char *type_prefix;
3737
3738                         /* Append current component's name if needed */
3739                         ret = convert_append_name_param(cur_comp_dest, cur_name,
3740                                 cur_name_prefix, run_args, all_names,
3741                                 &source_names, &filter_names, &sink_names);
3742                         if (ret) {
3743                                 goto error;
3744                         }
3745
3746                         /* Parse the argument */
3747                         plugin_comp_cls_names(arg, &name, &plugin_name,
3748                                 &comp_cls_name, &type);
3749                         if (!plugin_name || !comp_cls_name) {
3750                                 printf_err("Invalid format for --component option's argument:\n    %s\n",
3751                                         arg);
3752                                 goto error;
3753                         }
3754
3755                         if (name) {
3756                                 g_string_assign(cur_name, name);
3757                         } else {
3758                                 g_string_assign(cur_name, "");
3759                         }
3760
3761                         switch (type) {
3762                         case BT_COMPONENT_CLASS_TYPE_SOURCE:
3763                                 cur_comp_dest = BT_CONFIG_COMPONENT_DEST_SOURCE;
3764                                 type_prefix = "source";
3765                                 break;
3766                         case BT_COMPONENT_CLASS_TYPE_FILTER:
3767                                 cur_comp_dest = BT_CONFIG_COMPONENT_DEST_FILTER;
3768                                 type_prefix = "filter";
3769                                 break;
3770                         case BT_COMPONENT_CLASS_TYPE_SINK:
3771                                 cur_comp_dest = BT_CONFIG_COMPONENT_DEST_SINK;
3772                                 type_prefix = "sink";
3773                                 break;
3774                         default:
3775                                 abort();
3776                         }
3777
3778                         if (bt_value_array_append_string(run_args,
3779                                         "--component")) {
3780                                 print_err_oom();
3781                                 goto error;
3782                         }
3783
3784                         if (bt_value_array_append_string(run_args, arg)) {
3785                                 print_err_oom();
3786                                 goto error;
3787                         }
3788
3789                         g_string_assign(cur_name_prefix, "");
3790                         g_string_append_printf(cur_name_prefix, "%s.%s.%s",
3791                                 type_prefix, plugin_name, comp_cls_name);
3792                         free(name);
3793                         free(plugin_name);
3794                         free(comp_cls_name);
3795                         name = NULL;
3796                         plugin_name = NULL;
3797                         comp_cls_name = NULL;
3798                         break;
3799                 }
3800                 case OPT_PARAMS:
3801                         if (cur_name_prefix->len == 0) {
3802                                 printf_err("No current component of which to set parameters:\n    %s\n",
3803                                         arg);
3804                                 goto error;
3805                         }
3806
3807                         if (bt_value_array_append_string(run_args,
3808                                         "--params")) {
3809                                 print_err_oom();
3810                                 goto error;
3811                         }
3812
3813                         if (bt_value_array_append_string(run_args, arg)) {
3814                                 print_err_oom();
3815                                 goto error;
3816                         }
3817                         break;
3818                 case OPT_PATH:
3819                         if (cur_name_prefix->len == 0) {
3820                                 printf_err("No current component of which to set `path` parameter:\n    %s\n",
3821                                         arg);
3822                                 goto error;
3823                         }
3824
3825                         if (bt_value_array_append_string(run_args, "--key")) {
3826                                 print_err_oom();
3827                                 goto error;
3828                         }
3829
3830                         if (bt_value_array_append_string(run_args, "path")) {
3831                                 print_err_oom();
3832                                 goto error;
3833                         }
3834
3835                         if (bt_value_array_append_string(run_args, "--value")) {
3836                                 print_err_oom();
3837                                 goto error;
3838                         }
3839
3840                         if (bt_value_array_append_string(run_args, arg)) {
3841                                 print_err_oom();
3842                                 goto error;
3843                         }
3844                         break;
3845                 case OPT_URL:
3846                         if (cur_name_prefix->len == 0) {
3847                                 printf_err("No current component of which to set `url` parameter:\n    %s\n",
3848                                         arg);
3849                                 goto error;
3850                         }
3851
3852                         if (bt_value_array_append_string(run_args, "--key")) {
3853                                 print_err_oom();
3854                                 goto error;
3855                         }
3856
3857                         if (bt_value_array_append_string(run_args, "url")) {
3858                                 print_err_oom();
3859                                 goto error;
3860                         }
3861
3862                         if (bt_value_array_append_string(run_args, "--value")) {
3863                                 print_err_oom();
3864                                 goto error;
3865                         }
3866
3867                         if (bt_value_array_append_string(run_args, arg)) {
3868                                 print_err_oom();
3869                                 goto error;
3870                         }
3871                         break;
3872                 case OPT_NAME:
3873                         if (cur_name_prefix->len == 0) {
3874                                 printf_err("No current component to name:\n    %s\n",
3875                                         arg);
3876                                 goto error;
3877                         }
3878
3879                         if (bt_value_array_append_string(run_args, "--name")) {
3880                                 print_err_oom();
3881                                 goto error;
3882                         }
3883
3884                         if (bt_value_array_append_string(run_args, arg)) {
3885                                 print_err_oom();
3886                                 goto error;
3887                         }
3888
3889                         g_string_assign(cur_name, arg);
3890                         break;
3891                 case OPT_OMIT_HOME_PLUGIN_PATH:
3892                         force_omit_home_plugin_path = true;
3893
3894                         if (bt_value_array_append_string(run_args,
3895                                         "--omit-home-plugin-path")) {
3896                                 print_err_oom();
3897                                 goto error;
3898                         }
3899                         break;
3900                 case OPT_RETRY_DURATION:
3901                         if (bt_value_array_append_string(run_args,
3902                                         "--retry-duration")) {
3903                                 print_err_oom();
3904                                 goto error;
3905                         }
3906
3907                         if (bt_value_array_append_string(run_args, arg)) {
3908                                 print_err_oom();
3909                                 goto error;
3910                         }
3911                         break;
3912                 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
3913                         force_omit_system_plugin_path = true;
3914
3915                         if (bt_value_array_append_string(run_args,
3916                                         "--omit-system-plugin-path")) {
3917                                 print_err_oom();
3918                                 goto error;
3919                         }
3920                         break;
3921                 case OPT_PLUGIN_PATH:
3922                         if (bt_config_append_plugin_paths_check_setuid_setgid(
3923                                         plugin_paths, arg)) {
3924                                 goto error;
3925                         }
3926
3927                         if (bt_value_array_append_string(run_args,
3928                                         "--plugin-path")) {
3929                                 print_err_oom();
3930                                 goto error;
3931                         }
3932
3933                         if (bt_value_array_append_string(run_args, arg)) {
3934                                 print_err_oom();
3935                                 goto error;
3936                         }
3937                         break;
3938                 case OPT_HELP:
3939                         print_convert_usage(stdout);
3940                         *retcode = -1;
3941                         BT_PUT(cfg);
3942                         goto end;
3943                 case OPT_BEGIN:
3944                 case OPT_CLOCK_CYCLES:
3945                 case OPT_CLOCK_DATE:
3946                 case OPT_CLOCK_FORCE_CORRELATE:
3947                 case OPT_CLOCK_GMT:
3948                 case OPT_CLOCK_OFFSET:
3949                 case OPT_CLOCK_OFFSET_NS:
3950                 case OPT_CLOCK_SECONDS:
3951                 case OPT_COLOR:
3952                 case OPT_DEBUG:
3953                 case OPT_DEBUG_INFO_DIR:
3954                 case OPT_DEBUG_INFO_FULL_PATH:
3955                 case OPT_DEBUG_INFO_TARGET_PREFIX:
3956                 case OPT_END:
3957                 case OPT_FIELDS:
3958                 case OPT_INPUT_FORMAT:
3959                 case OPT_NAMES:
3960                 case OPT_NO_DEBUG_INFO:
3961                 case OPT_NO_DELTA:
3962                 case OPT_OUTPUT_FORMAT:
3963                 case OPT_OUTPUT:
3964                 case OPT_RUN_ARGS:
3965                 case OPT_RUN_ARGS_0:
3966                 case OPT_STREAM_INTERSECTION:
3967                 case OPT_TIMERANGE:
3968                 case OPT_VERBOSE:
3969                         /* Ignore in this pass */
3970                         break;
3971                 default:
3972                         printf_err("Unknown command-line option specified (option code %d)\n",
3973                                 opt);
3974                         goto error;
3975                 }
3976
3977                 free(arg);
3978                 arg = NULL;
3979         }
3980
3981         /* Append current component's name if needed */
3982         ret = convert_append_name_param(cur_comp_dest, cur_name,
3983                 cur_name_prefix, run_args, all_names, &source_names,
3984                 &filter_names, &sink_names);
3985         if (ret) {
3986                 goto error;
3987         }
3988
3989         /* Check for option parsing error */
3990         if (opt < -1) {
3991                 printf_err("While parsing command-line options, at option %s: %s\n",
3992                         poptBadOption(pc, 0), poptStrerror(opt));
3993                 goto error;
3994         }
3995
3996         poptFreeContext(pc);
3997         free(arg);
3998         arg = NULL;
3999
4000         /*
4001          * Second pass: transform the convert-specific options and
4002          * arguments into implicit component instances for the run
4003          * command.
4004          */
4005         pc = poptGetContext(NULL, argc, (const char **) argv,
4006                 convert_long_options, 0);
4007         if (!pc) {
4008                 printf_err("Cannot get popt context\n");
4009                 goto error;
4010         }
4011
4012         poptReadDefaultConfig(pc, 0);
4013
4014         while ((opt = poptGetNextOpt(pc)) > 0) {
4015                 arg = poptGetOptArg(pc);
4016
4017                 switch (opt) {
4018                 case OPT_BEGIN:
4019                         if (trimmer_has_begin) {
4020                                 printf("At --begin option: --begin or --timerange option already specified\n    %s\n",
4021                                         arg);
4022                                 goto error;
4023                         }
4024
4025                         trimmer_has_begin = true;
4026                         ret = append_implicit_component_extra_param(
4027                                 &implicit_trimmer_args, "begin", arg);
4028                         implicit_trimmer_args.exists = true;
4029                         if (ret) {
4030                                 goto error;
4031                         }
4032                         break;
4033                 case OPT_END:
4034                         if (trimmer_has_end) {
4035                                 printf("At --end option: --end or --timerange option already specified\n    %s\n",
4036                                         arg);
4037                                 goto error;
4038                         }
4039
4040                         trimmer_has_end = true;
4041                         ret = append_implicit_component_extra_param(
4042                                 &implicit_trimmer_args, "end", arg);
4043                         implicit_trimmer_args.exists = true;
4044                         if (ret) {
4045                                 goto error;
4046                         }
4047                         break;
4048                 case OPT_TIMERANGE:
4049                 {
4050                         char *begin;
4051                         char *end;
4052
4053                         if (trimmer_has_begin || trimmer_has_end) {
4054                                 printf("At --timerange option: --begin, --end, or --timerange option already specified\n    %s\n",
4055                                         arg);
4056                                 goto error;
4057                         }
4058
4059                         ret = split_timerange(arg, &begin, &end);
4060                         if (ret) {
4061                                 printf_err("Invalid --timerange option's argument: expecting BEGIN,END or [BEGIN,END]:\n    %s\n",
4062                                         arg);
4063                                 goto error;
4064                         }
4065
4066                         ret = append_implicit_component_extra_param(
4067                                 &implicit_trimmer_args, "begin", begin);
4068                         ret |= append_implicit_component_extra_param(
4069                                 &implicit_trimmer_args, "end", end);
4070                         implicit_trimmer_args.exists = true;
4071                         free(begin);
4072                         free(end);
4073                         if (ret) {
4074                                 goto error;
4075                         }
4076                         break;
4077                 }
4078                 case OPT_CLOCK_CYCLES:
4079                         append_implicit_component_param(
4080                                 &implicit_text_args, "clock-cycles", "yes");
4081                         implicit_text_args.exists = true;
4082                         break;
4083                 case OPT_CLOCK_DATE:
4084                         append_implicit_component_param(
4085                                 &implicit_text_args, "clock-date", "yes");
4086                         implicit_text_args.exists = true;
4087                         break;
4088                 case OPT_CLOCK_FORCE_CORRELATE:
4089                         append_implicit_component_param(
4090                                 &implicit_muxer_args,
4091                                 "assume-absolute-clock-classes", "yes");
4092                         break;
4093                 case OPT_CLOCK_GMT:
4094                         append_implicit_component_param(
4095                                 &implicit_text_args, "clock-gmt", "yes");
4096                         append_implicit_component_param(
4097                                 &implicit_trimmer_args, "clock-gmt", "yes");
4098                         implicit_text_args.exists = true;
4099                         break;
4100                 case OPT_CLOCK_OFFSET:
4101                         base_implicit_ctf_input_args.exists = true;
4102                         append_implicit_component_param(
4103                                         &base_implicit_ctf_input_args,
4104                                         "clock-class-offset-s", arg);
4105                         break;
4106                 case OPT_CLOCK_OFFSET_NS:
4107                         base_implicit_ctf_input_args.exists = true;
4108                         append_implicit_component_param(
4109                                         &base_implicit_ctf_input_args,
4110                                         "clock-class-offset-ns", arg);
4111                         break;
4112                 case OPT_CLOCK_SECONDS:
4113                         append_implicit_component_param(
4114                                 &implicit_text_args, "clock-seconds", "yes");
4115                         implicit_text_args.exists = true;
4116                         break;
4117                 case OPT_COLOR:
4118                         implicit_text_args.exists = true;
4119                         ret = append_implicit_component_extra_param(
4120                                 &implicit_text_args, "color", arg);
4121                         if (ret) {
4122                                 goto error;
4123                         }
4124                         break;
4125                 case OPT_NO_DEBUG_INFO:
4126                         implicit_debug_info_args.exists = false;
4127                         break;
4128                 case OPT_DEBUG_INFO_DIR:
4129                         implicit_debug_info_args.exists = true;
4130                         ret = append_implicit_component_extra_param(
4131                                 &implicit_debug_info_args, "dir", arg);
4132                         if (ret) {
4133                                 goto error;
4134                         }
4135                         break;
4136                 case OPT_DEBUG_INFO_FULL_PATH:
4137                         implicit_debug_info_args.exists = true;
4138                         append_implicit_component_param(
4139                                 &implicit_debug_info_args, "full-path", "yes");
4140                         break;
4141                 case OPT_DEBUG_INFO_TARGET_PREFIX:
4142                         implicit_debug_info_args.exists = true;
4143                         ret = append_implicit_component_extra_param(
4144                                 &implicit_debug_info_args,
4145                                 "target-prefix", arg);
4146                         if (ret) {
4147                                 goto error;
4148                         }
4149                         break;
4150                 case OPT_FIELDS:
4151                 {
4152                         struct bt_value *fields = fields_from_arg(arg);
4153
4154                         if (!fields) {
4155                                 goto error;
4156                         }
4157
4158                         implicit_text_args.exists = true;
4159                         ret = insert_flat_params_from_array(
4160                                 implicit_text_args.params_arg,
4161                                 fields, "field");
4162                         bt_put(fields);
4163                         if (ret) {
4164                                 goto error;
4165                         }
4166                         break;
4167                 }
4168                 case OPT_NAMES:
4169                 {
4170                         struct bt_value *names = names_from_arg(arg);
4171
4172                         if (!names) {
4173                                 goto error;
4174                         }
4175
4176                         implicit_text_args.exists = true;
4177                         ret = insert_flat_params_from_array(
4178                                 implicit_text_args.params_arg,
4179                                 names, "name");
4180                         bt_put(names);
4181                         if (ret) {
4182                                 goto error;
4183                         }
4184                         break;
4185                 }
4186                 case OPT_NO_DELTA:
4187                         append_implicit_component_param(
4188                                 &implicit_text_args, "no-delta", "yes");
4189                         implicit_text_args.exists = true;
4190                         break;
4191                 case OPT_INPUT_FORMAT:
4192                         if (got_input_format_opt) {
4193                                 printf_err("Duplicate --input-format option\n");
4194                                 goto error;
4195                         }
4196
4197                         got_input_format_opt = true;
4198
4199                         if (strcmp(arg, "ctf") == 0) {
4200                                 base_implicit_ctf_input_args.exists = true;
4201                         } else if (strcmp(arg, "lttng-live") == 0) {
4202                                 implicit_lttng_live_args.exists = true;
4203                         } else {
4204                                 printf_err("Unknown legacy input format:\n    %s\n",
4205                                         arg);
4206                                 goto error;
4207                         }
4208                         break;
4209                 case OPT_OUTPUT_FORMAT:
4210                         if (got_output_format_opt) {
4211                                 printf_err("Duplicate --output-format option\n");
4212                                 goto error;
4213                         }
4214
4215                         got_output_format_opt = true;
4216
4217                         if (strcmp(arg, "text") == 0) {
4218                                 implicit_text_args.exists = true;
4219                         } else if (strcmp(arg, "ctf") == 0) {
4220                                 implicit_ctf_output_args.exists = true;
4221                         } else if (strcmp(arg, "dummy") == 0) {
4222                                 implicit_dummy_args.exists = true;
4223                         } else if (strcmp(arg, "ctf-metadata") == 0) {
4224                                 print_ctf_metadata = true;
4225                         } else {
4226                                 printf_err("Unknown legacy output format:\n    %s\n",
4227                                         arg);
4228                                 goto error;
4229                         }
4230                         break;
4231                 case OPT_OUTPUT:
4232                         if (output) {
4233                                 printf_err("Duplicate --output option\n");
4234                                 goto error;
4235                         }
4236
4237                         output = strdup(arg);
4238                         if (!output) {
4239                                 print_err_oom();
4240                                 goto error;
4241                         }
4242                         break;
4243                 case OPT_RUN_ARGS:
4244                         if (print_run_args_0) {
4245                                 printf_err("Cannot specify --run-args and --run-args-0\n");
4246                                 goto error;
4247                         }
4248
4249                         print_run_args = true;
4250                         break;
4251                 case OPT_RUN_ARGS_0:
4252                         if (print_run_args) {
4253                                 printf_err("Cannot specify --run-args and --run-args-0\n");
4254                                 goto error;
4255                         }
4256
4257                         print_run_args_0 = true;
4258                         break;
4259                 case OPT_STREAM_INTERSECTION:
4260                         /*
4261                          * Applies to all traces implementing the trace-info
4262                          * query.
4263                          */
4264                         stream_intersection_mode = true;
4265                         break;
4266                 case OPT_VERBOSE:
4267                         if (*log_level != 'V' && *log_level != 'D') {
4268                                 *log_level = 'I';
4269                         }
4270                         break;
4271                 case OPT_DEBUG:
4272                         *log_level = 'V';
4273                         break;
4274                 }
4275
4276                 free(arg);
4277                 arg = NULL;
4278         }
4279
4280         /* Check for option parsing error */
4281         if (opt < -1) {
4282                 printf_err("While parsing command-line options, at option %s: %s\n",
4283                         poptBadOption(pc, 0), poptStrerror(opt));
4284                 goto error;
4285         }
4286
4287         /*
4288          * Legacy behaviour: --verbose used to make the `text` output
4289          * format print more information. --verbose is now equivalent to
4290          * the INFO log level, which is why we compare to 'I' here.
4291          */
4292         if (*log_level == 'I') {
4293                 append_implicit_component_param(&implicit_text_args,
4294                         "verbose", "yes");
4295         }
4296
4297         /*
4298          * Append home and system plugin paths now that we possibly got
4299          * --plugin-path.
4300          */
4301         if (append_home_and_system_plugin_paths(plugin_paths,
4302                         force_omit_system_plugin_path,
4303                         force_omit_home_plugin_path)) {
4304                 goto error;
4305         }
4306
4307         /* Consume and keep leftover arguments */
4308         while ((leftover = poptGetArg(pc))) {
4309                 GString *gs_leftover = g_string_new(leftover);
4310
4311                 if (!gs_leftover) {
4312                         print_err_oom();
4313                         goto error;
4314                 }
4315
4316                 leftovers = g_list_append(leftovers, gs_leftover);
4317                 if (!leftovers) {
4318                         g_string_free(gs_leftover, TRUE);
4319                         print_err_oom();
4320                         goto error;
4321                 }
4322         }
4323
4324         /* Print CTF metadata or print LTTng live sessions */
4325         if (print_ctf_metadata) {
4326                 GString *gs_leftover;
4327
4328                 if (g_list_length(leftovers) == 0) {
4329                         printf_err("--output-format=ctf-metadata specified without a path\n");
4330                         goto error;
4331                 }
4332
4333                 if (g_list_length(leftovers) > 1) {
4334                         printf_err("Too many paths specified for --output-format=ctf-metadata\n");
4335                         goto error;
4336                 }
4337
4338                 cfg = bt_config_print_ctf_metadata_create(plugin_paths);
4339                 if (!cfg) {
4340                         goto error;
4341                 }
4342
4343                 gs_leftover = leftovers->data;
4344                 g_string_assign(cfg->cmd_data.print_ctf_metadata.path,
4345                         gs_leftover->str);
4346                 goto end;
4347         }
4348
4349         /*
4350          * If -o ctf was specified, make sure an output path (--output)
4351          * was also specified. --output does not imply -o ctf because
4352          * it's also used for the default, implicit -o text if -o ctf
4353          * is not specified.
4354          */
4355         if (implicit_ctf_output_args.exists) {
4356                 if (!output) {
4357                         printf_err("--output-format=ctf specified without --output (trace output path)\n");
4358                         goto error;
4359                 }
4360
4361                 /*
4362                  * At this point we know that -o ctf AND --output were
4363                  * specified. Make sure that no options were specified
4364                  * which would imply -o text because --output would be
4365                  * ambiguous in this case. For example, this is wrong:
4366                  *
4367                  *     babeltrace --names=all -o ctf --output=/tmp/path my-trace
4368                  *
4369                  * because --names=all implies -o text, and --output
4370                  * could apply to both the sink.text.pretty and
4371                  * sink.ctf.fs implicit components.
4372                  */
4373                 if (implicit_text_args.exists) {
4374                         printf_err("Ambiguous --output option: --output-format=ctf specified but another option implies --output-format=text\n");
4375                         goto error;
4376                 }
4377         }
4378
4379         /*
4380          * If -o dummy and -o ctf were not specified, and if there are
4381          * no explicit sink components, then use an implicit
4382          * `sink.text.pretty` component.
4383          */
4384         if (!implicit_dummy_args.exists && !implicit_ctf_output_args.exists &&
4385                         !sink_names) {
4386                 implicit_text_args.exists = true;
4387         }
4388
4389         /*
4390          * Set implicit `sink.text.pretty` or `sink.ctf.fs` component's
4391          * `path` parameter if --output was specified.
4392          */
4393         if (output) {
4394                 if (implicit_text_args.exists) {
4395                         append_implicit_component_extra_param(&implicit_text_args,
4396                                 "path", output);
4397                 } else if (implicit_ctf_output_args.exists) {
4398                         append_implicit_component_extra_param(&implicit_ctf_output_args,
4399                                 "path", output);
4400                 }
4401         }
4402
4403         /* Decide where the leftover argument(s) go */
4404         if (g_list_length(leftovers) > 0) {
4405                 if (implicit_lttng_live_args.exists) {
4406                         GString *gs_leftover;
4407
4408                         if (g_list_length(leftovers) > 1) {
4409                                 printf_err("Too many URLs specified for --output-format=lttng-live\n");
4410                                 goto error;
4411                         }
4412
4413                         gs_leftover = leftovers->data;
4414                         lttng_live_url_parts =
4415                                 bt_common_parse_lttng_live_url(gs_leftover->str,
4416                                         error_buf, sizeof(error_buf));
4417                         if (!lttng_live_url_parts.proto) {
4418                                 printf_err("Invalid LTTng live URL format: %s\n",
4419                                         error_buf);
4420                                 goto error;
4421                         }
4422
4423                         if (!lttng_live_url_parts.session_name) {
4424                                 /* Print LTTng live sessions */
4425                                 cfg = bt_config_print_lttng_live_sessions_create(
4426                                         plugin_paths);
4427                                 if (!cfg) {
4428                                         goto error;
4429                                 }
4430
4431                                 g_string_assign(cfg->cmd_data.print_lttng_live_sessions.url,
4432                                         gs_leftover->str);
4433                                 goto end;
4434                         }
4435
4436                         ret = append_implicit_component_extra_param(
4437                                 &implicit_lttng_live_args, "url",
4438                                 gs_leftover->str);
4439                         if (ret) {
4440                                 goto error;
4441                         }
4442                 } else {
4443                         /*
4444                          * Append one implicit component argument set
4445                          * for each leftover (souce.ctf.fs paths). Copy
4446                          * the base implicit component arguments.
4447                          * Note that they still have to be named later.
4448                          */
4449                         ret = fill_implicit_ctf_inputs_args(
4450                                 implicit_ctf_inputs_args,
4451                                 &base_implicit_ctf_input_args, leftovers);
4452                         if (ret) {
4453                                 goto error;
4454                         }
4455                 }
4456         }
4457
4458         /*
4459          * Ensure mutual exclusion between implicit `source.ctf.fs` and
4460          * `source.ctf.lttng-live` components.
4461          */
4462         if (base_implicit_ctf_input_args.exists &&
4463                         implicit_lttng_live_args.exists) {
4464                 printf_err("Cannot create both implicit `%s` and `%s` components\n",
4465                         base_implicit_ctf_input_args.comp_arg->str,
4466                         implicit_lttng_live_args.comp_arg->str);
4467                 goto error;
4468         }
4469
4470         /*
4471          * If the implicit `source.ctf.fs` or `source.ctf.lttng-live`
4472          * components exists, make sure there's at least one leftover
4473          * (which is the path or URL).
4474          */
4475         if (base_implicit_ctf_input_args.exists &&
4476                         g_list_length(leftovers) == 0) {
4477                 printf_err("Missing path for implicit `%s` component\n",
4478                         base_implicit_ctf_input_args.comp_arg->str);
4479                 goto error;
4480         }
4481
4482         if (implicit_lttng_live_args.exists && g_list_length(leftovers) == 0) {
4483                 printf_err("Missing URL for implicit `%s` component\n",
4484                         implicit_lttng_live_args.comp_arg->str);
4485                 goto error;
4486         }
4487
4488         /* Assign names to implicit components */
4489         for (i = 0; i < implicit_ctf_inputs_args->len; i++) {
4490                 struct implicit_component_args *impl_args =
4491                         g_ptr_array_index(implicit_ctf_inputs_args, i);
4492
4493                 ret = assign_name_to_implicit_component(impl_args,
4494                         "source-ctf-fs", all_names, &source_names, true);
4495                 if (ret) {
4496                         goto error;
4497                 }
4498         }
4499
4500         ret = assign_name_to_implicit_component(&implicit_lttng_live_args,
4501                 "lttng-live", all_names, &source_names, true);
4502         if (ret) {
4503                 goto error;
4504         }
4505
4506         ret = assign_name_to_implicit_component(&implicit_text_args,
4507                 "pretty", all_names, &sink_names, true);
4508         if (ret) {
4509                 goto error;
4510         }
4511
4512         ret = assign_name_to_implicit_component(&implicit_ctf_output_args,
4513                 "sink-ctf-fs", all_names, &sink_names, true);
4514         if (ret) {
4515                 goto error;
4516         }
4517
4518         ret = assign_name_to_implicit_component(&implicit_dummy_args,
4519                 "dummy", all_names, &sink_names, true);
4520         if (ret) {
4521                 goto error;
4522         }
4523
4524         ret = assign_name_to_implicit_component(&implicit_muxer_args,
4525                 "muxer", all_names, NULL, false);
4526         if (ret) {
4527                 goto error;
4528         }
4529
4530         ret = assign_name_to_implicit_component(&implicit_trimmer_args,
4531                 "trimmer", all_names, NULL, false);
4532         if (ret) {
4533                 goto error;
4534         }
4535
4536         ret = assign_name_to_implicit_component(&implicit_debug_info_args,
4537                 "debug-info", all_names, NULL, false);
4538         if (ret) {
4539                 goto error;
4540         }
4541
4542         /* Make sure there's at least one source and one sink */
4543         if (!source_names) {
4544                 printf_err("No source component\n");
4545                 goto error;
4546         }
4547
4548         if (!sink_names) {
4549                 printf_err("No sink component\n");
4550                 goto error;
4551         }
4552
4553         /*
4554          * Prepend the muxer, the trimmer, and the debug info to the
4555          * filter chain so that we have:
4556          *
4557          *     sources -> muxer -> [trimmer] -> [debug info] ->
4558          *                [user filters] -> sinks
4559          */
4560         if (implicit_debug_info_args.exists) {
4561                 if (g_list_prepend_gstring(&filter_names,
4562                                 implicit_debug_info_args.name_arg->str)) {
4563                         goto error;
4564                 }
4565         }
4566
4567         if (implicit_trimmer_args.exists) {
4568                 if (g_list_prepend_gstring(&filter_names,
4569                                 implicit_trimmer_args.name_arg->str)) {
4570                         goto error;
4571                 }
4572         }
4573
4574         if (g_list_prepend_gstring(&filter_names,
4575                         implicit_muxer_args.name_arg->str)) {
4576                 goto error;
4577         }
4578
4579         /*
4580          * Append the equivalent run arguments for the implicit
4581          * components.
4582          */
4583         for (i = 0; i < implicit_ctf_inputs_args->len; i++) {
4584                 struct implicit_component_args *impl_args =
4585                         g_ptr_array_index(implicit_ctf_inputs_args, i);
4586
4587                 ret = append_run_args_for_implicit_component(impl_args,
4588                         run_args);
4589                 if (ret) {
4590                         goto error;
4591                 }
4592         }
4593
4594         ret = append_run_args_for_implicit_component(&implicit_lttng_live_args,
4595                 run_args);
4596         if (ret) {
4597                 goto error;
4598         }
4599
4600         ret = append_run_args_for_implicit_component(&implicit_text_args,
4601                 run_args);
4602         if (ret) {
4603                 goto error;
4604         }
4605
4606         ret = append_run_args_for_implicit_component(&implicit_ctf_output_args,
4607                 run_args);
4608         if (ret) {
4609                 goto error;
4610         }
4611
4612         ret = append_run_args_for_implicit_component(&implicit_dummy_args,
4613                 run_args);
4614         if (ret) {
4615                 goto error;
4616         }
4617
4618         ret = append_run_args_for_implicit_component(&implicit_muxer_args,
4619                 run_args);
4620         if (ret) {
4621                 goto error;
4622         }
4623
4624         ret = append_run_args_for_implicit_component(&implicit_trimmer_args,
4625                 run_args);
4626         if (ret) {
4627                 goto error;
4628         }
4629
4630         ret = append_run_args_for_implicit_component(&implicit_debug_info_args,
4631                 run_args);
4632         if (ret) {
4633                 goto error;
4634         }
4635
4636         /* Auto-connect components */
4637         ret = convert_auto_connect(run_args, source_names, filter_names,
4638                         sink_names);
4639         if (ret) {
4640                 printf_err("Cannot auto-connect components\n");
4641                 goto error;
4642         }
4643
4644         /*
4645          * We have all the run command arguments now. Depending on
4646          * --run-args, we pass this to the run command or print them
4647          * here.
4648          */
4649         if (print_run_args || print_run_args_0) {
4650                 if (stream_intersection_mode) {
4651                         printf_err("Cannot specify --stream-intersection with --run-args or --run-args-0\n");
4652                         goto error;
4653                 }
4654
4655                 for (i = 0; i < bt_value_array_size(run_args); i++) {
4656                         struct bt_value *arg_value =
4657                                 bt_value_array_get(run_args, i);
4658                         const char *arg;
4659                         GString *quoted = NULL;
4660                         const char *arg_to_print;
4661
4662                         assert(arg_value);
4663                         ret = bt_value_string_get(arg_value, &arg);
4664                         assert(ret == 0);
4665                         BT_PUT(arg_value);
4666
4667                         if (print_run_args) {
4668                                 quoted = bt_common_shell_quote(arg, true);
4669                                 if (!quoted) {
4670                                         goto error;
4671                                 }
4672
4673                                 arg_to_print = quoted->str;
4674                         } else {
4675                                 arg_to_print = arg;
4676                         }
4677
4678                         printf("%s", arg_to_print);
4679
4680                         if (quoted) {
4681                                 g_string_free(quoted, TRUE);
4682                         }
4683
4684                         if (i < bt_value_array_size(run_args) - 1) {
4685                                 if (print_run_args) {
4686                                         putchar(' ');
4687                                 } else {
4688                                         putchar('\0');
4689                                 }
4690                         }
4691                 }
4692
4693                 *retcode = -1;
4694                 BT_PUT(cfg);
4695                 goto end;
4696         }
4697
4698         cfg = bt_config_run_from_args_array(run_args, retcode,
4699                 force_omit_system_plugin_path, force_omit_home_plugin_path,
4700                 initial_plugin_paths);
4701         if (!cfg) {
4702                 goto error;
4703         }
4704
4705         cfg->cmd_data.run.stream_intersection_mode = stream_intersection_mode;
4706         goto end;
4707
4708 error:
4709         *retcode = 1;
4710         BT_PUT(cfg);
4711
4712 end:
4713         if (pc) {
4714                 poptFreeContext(pc);
4715         }
4716
4717         free(arg);
4718         free(output);
4719
4720         if (cur_name) {
4721                 g_string_free(cur_name, TRUE);
4722         }
4723
4724         if (cur_name_prefix) {
4725                 g_string_free(cur_name_prefix, TRUE);
4726         }
4727
4728         if (implicit_ctf_inputs_args) {
4729                 g_ptr_array_free(implicit_ctf_inputs_args, TRUE);
4730         }
4731
4732         bt_put(run_args);
4733         bt_put(all_names);
4734         destroy_glist_of_gstring(source_names);
4735         destroy_glist_of_gstring(filter_names);
4736         destroy_glist_of_gstring(sink_names);
4737         destroy_glist_of_gstring(leftovers);
4738         finalize_implicit_component_args(&base_implicit_ctf_input_args);
4739         finalize_implicit_component_args(&implicit_ctf_output_args);
4740         finalize_implicit_component_args(&implicit_lttng_live_args);
4741         finalize_implicit_component_args(&implicit_dummy_args);
4742         finalize_implicit_component_args(&implicit_text_args);
4743         finalize_implicit_component_args(&implicit_debug_info_args);
4744         finalize_implicit_component_args(&implicit_muxer_args);
4745         finalize_implicit_component_args(&implicit_trimmer_args);
4746         bt_put(plugin_paths);
4747         bt_common_destroy_lttng_live_url_parts(&lttng_live_url_parts);
4748         return cfg;
4749 }
4750
4751 /*
4752  * Prints the Babeltrace 2.x general usage.
4753  */
4754 static
4755 void print_gen_usage(FILE *fp)
4756 {
4757         fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] [COMMAND] [COMMAND ARGUMENTS]\n");
4758         fprintf(fp, "\n");
4759         fprintf(fp, "General options:\n");
4760         fprintf(fp, "\n");
4761         fprintf(fp, "  -d, --debug          Enable debug mode (same as --log-level=V)\n");
4762         fprintf(fp, "  -h, --help           Show this help and quit\n");
4763         fprintf(fp, "      --log-level=LVL  Set all log levels to LVL (`N`, `V`, `D`,\n");
4764         fprintf(fp, "                       `I`, `W` (default), `E`, or `F`)\n");
4765         fprintf(fp, "  -v, --verbose        Enable verbose mode (same as --log-level=I)\n");
4766         fprintf(fp, "  -V, --version        Show version and quit\n");
4767         fprintf(fp, "\n");
4768         fprintf(fp, "Available commands:\n");
4769         fprintf(fp, "\n");
4770         fprintf(fp, "    convert       Convert and trim traces (default)\n");
4771         fprintf(fp, "    help          Get help for a plugin or a component class\n");
4772         fprintf(fp, "    list-plugins  List available plugins and their content\n");
4773         fprintf(fp, "    query         Query objects from a component class\n");
4774         fprintf(fp, "    run           Build a processing graph and run it\n");
4775         fprintf(fp, "\n");
4776         fprintf(fp, "Use `babeltrace COMMAND --help` to show the help of COMMAND.\n");
4777 }
4778
4779 static
4780 char log_level_from_arg(const char *arg)
4781 {
4782         char level = 'U';
4783
4784         if (strcmp(arg, "VERBOSE") == 0 ||
4785                         strcmp(arg, "V") == 0) {
4786                 level = 'V';
4787         } else if (strcmp(arg, "DEBUG") == 0 ||
4788                         strcmp(arg, "D") == 0) {
4789                 level = 'D';
4790         } else if (strcmp(arg, "INFO") == 0 ||
4791                         strcmp(arg, "I") == 0) {
4792                 level = 'I';
4793         } else if (strcmp(arg, "WARN") == 0 ||
4794                         strcmp(arg, "WARNING") == 0 ||
4795                         strcmp(arg, "W") == 0) {
4796                 level = 'W';
4797         } else if (strcmp(arg, "ERROR") == 0 ||
4798                         strcmp(arg, "E") == 0) {
4799                 level = 'E';
4800         } else if (strcmp(arg, "FATAL") == 0 ||
4801                         strcmp(arg, "F") == 0) {
4802                 level = 'F';
4803         } else if (strcmp(arg, "NONE") == 0 ||
4804                         strcmp(arg, "N") == 0) {
4805                 level = 'N';
4806         }
4807
4808         return level;
4809 }
4810
4811 struct bt_config *bt_config_cli_args_create(int argc, const char *argv[],
4812                 int *retcode, bool force_omit_system_plugin_path,
4813                 bool force_omit_home_plugin_path, bool force_no_debug_info,
4814                 struct bt_value *initial_plugin_paths)
4815 {
4816         struct bt_config *config = NULL;
4817         int i;
4818         const char **command_argv = NULL;
4819         int command_argc = -1;
4820         const char *command_name = NULL;
4821         char log_level = 'U';
4822
4823         enum command_type {
4824                 COMMAND_TYPE_NONE = -1,
4825                 COMMAND_TYPE_RUN = 0,
4826                 COMMAND_TYPE_CONVERT,
4827                 COMMAND_TYPE_LIST_PLUGINS,
4828                 COMMAND_TYPE_HELP,
4829                 COMMAND_TYPE_QUERY,
4830         } command_type = COMMAND_TYPE_NONE;
4831
4832         *retcode = -1;
4833
4834         if (!initial_plugin_paths) {
4835                 initial_plugin_paths = bt_value_array_create();
4836                 if (!initial_plugin_paths) {
4837                         *retcode = 1;
4838                         goto end;
4839                 }
4840         } else {
4841                 bt_get(initial_plugin_paths);
4842         }
4843
4844         if (argc <= 1) {
4845                 print_version();
4846                 puts("");
4847                 print_gen_usage(stdout);
4848                 goto end;
4849         }
4850
4851         for (i = 1; i < argc; i++) {
4852                 const char *cur_arg = argv[i];
4853                 const char *next_arg = i == (argc - 1) ? NULL : argv[i + 1];
4854
4855                 if (strcmp(cur_arg, "-d") == 0 ||
4856                                 strcmp(cur_arg, "--debug") == 0) {
4857                         log_level = 'V';
4858                 } else if (strcmp(cur_arg, "-v") == 0 ||
4859                                 strcmp(cur_arg, "--verbose") == 0) {
4860                         if (log_level != 'V' && log_level != 'D') {
4861                                 /*
4862                                  * Legacy: do not override a previous
4863                                  * --debug because --verbose and --debug
4864                                  * can be specified together (in this
4865                                  * case we want the lowest log level to
4866                                  * apply, VERBOSE).
4867                                  */
4868                                 log_level = 'I';
4869                         }
4870                 } else if (strcmp(cur_arg, "--log-level") == 0) {
4871                         if (!next_arg) {
4872                                 printf_err("Missing log level value for --log-level option\n");
4873                                 *retcode = 1;
4874                                 goto end;
4875                         }
4876
4877                         log_level = log_level_from_arg(next_arg);
4878                         if (log_level == 'U') {
4879                                 printf_err("Invalid argument for --log-level option:\n    %s\n",
4880                                         next_arg);
4881                                 *retcode = 1;
4882                                 goto end;
4883                         }
4884
4885                         i++;
4886                 } else if (strncmp(cur_arg, "--log-level=", 12) == 0) {
4887                         const char *arg = &cur_arg[12];
4888
4889                         log_level = log_level_from_arg(arg);
4890                         if (log_level == 'U') {
4891                                 printf_err("Invalid argument for --log-level option:\n    %s\n",
4892                                         arg);
4893                                 *retcode = 1;
4894                                 goto end;
4895                         }
4896                 } else if (strcmp(cur_arg, "-V") == 0 ||
4897                                 strcmp(cur_arg, "--version") == 0) {
4898                         print_version();
4899                         goto end;
4900                 } else if (strcmp(cur_arg, "-h") == 0 ||
4901                                 strcmp(cur_arg, "--help") == 0) {
4902                         print_gen_usage(stdout);
4903                         goto end;
4904                 } else {
4905                         /*
4906                          * First unknown argument: is it a known command
4907                          * name?
4908                          */
4909                         command_argv = &argv[i];
4910                         command_argc = argc - i;
4911
4912                         if (strcmp(cur_arg, "convert") == 0) {
4913                                 command_type = COMMAND_TYPE_CONVERT;
4914                         } else if (strcmp(cur_arg, "list-plugins") == 0) {
4915                                 command_type = COMMAND_TYPE_LIST_PLUGINS;
4916                         } else if (strcmp(cur_arg, "help") == 0) {
4917                                 command_type = COMMAND_TYPE_HELP;
4918                         } else if (strcmp(cur_arg, "query") == 0) {
4919                                 command_type = COMMAND_TYPE_QUERY;
4920                         } else if (strcmp(cur_arg, "run") == 0) {
4921                                 command_type = COMMAND_TYPE_RUN;
4922                         } else {
4923                                 /*
4924                                  * Unknown argument, but not a known
4925                                  * command name: assume the default
4926                                  * `convert` command.
4927                                  */
4928                                 command_type = COMMAND_TYPE_CONVERT;
4929                                 command_name = "convert";
4930                                 command_argv = &argv[i - 1];
4931                                 command_argc = argc - i + 1;
4932                         }
4933                         break;
4934                 }
4935         }
4936
4937         if (command_type == COMMAND_TYPE_NONE) {
4938                 /*
4939                  * We only got non-help, non-version general options
4940                  * like --verbose and --debug, without any other
4941                  * arguments, so we can't do anything useful: print the
4942                  * usage and quit.
4943                  */
4944                 print_gen_usage(stdout);
4945                 goto end;
4946         }
4947
4948         assert(command_argv);
4949         assert(command_argc >= 0);
4950
4951         switch (command_type) {
4952         case COMMAND_TYPE_RUN:
4953                 config = bt_config_run_from_args(command_argc, command_argv,
4954                         retcode, force_omit_system_plugin_path,
4955                         force_omit_home_plugin_path, initial_plugin_paths);
4956                 break;
4957         case COMMAND_TYPE_CONVERT:
4958                 config = bt_config_convert_from_args(command_argc, command_argv,
4959                         retcode, force_omit_system_plugin_path,
4960                         force_omit_home_plugin_path, force_no_debug_info,
4961                         initial_plugin_paths, &log_level);
4962                 break;
4963         case COMMAND_TYPE_LIST_PLUGINS:
4964                 config = bt_config_list_plugins_from_args(command_argc,
4965                         command_argv, retcode, force_omit_system_plugin_path,
4966                         force_omit_home_plugin_path, initial_plugin_paths);
4967                 break;
4968         case COMMAND_TYPE_HELP:
4969                 config = bt_config_help_from_args(command_argc,
4970                         command_argv, retcode, force_omit_system_plugin_path,
4971                         force_omit_home_plugin_path, initial_plugin_paths);
4972                 break;
4973         case COMMAND_TYPE_QUERY:
4974                 config = bt_config_query_from_args(command_argc,
4975                         command_argv, retcode, force_omit_system_plugin_path,
4976                         force_omit_home_plugin_path, initial_plugin_paths);
4977                 break;
4978         default:
4979                 abort();
4980         }
4981
4982         if (config) {
4983                 if (log_level == 'U') {
4984                         log_level = 'W';
4985                 }
4986
4987                 config->log_level = log_level;
4988                 config->command_name = command_name;
4989         }
4990
4991 end:
4992         bt_put(initial_plugin_paths);
4993         return config;
4994 }