options.c

   1 /*
   2  * This file is part of ltrace.
   3  * Copyright (C) 2012, 2013, 2014 Petr Machata, Red Hat Inc.
   4  * Copyright (C) 2009,2010 Joe Damato
   5  * Copyright (C) 1998,1999,2002,2003,2004,2007,2008,2009 Juan Cespedes
   6  * Copyright (C) 2006 Ian Wienand
   7  * Copyright (C) 2006 Steve Fink
   8  * Copyright (C) 2006 Paul Gilliam, IBM Corporation
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of the
  13  * License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  23  * 02110-1301 USA
  24  */
  25
  26 #include "config.h"
  27
  28 #include <sys/ioctl.h>
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31 #include <assert.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <getopt.h>
  35 #include <limits.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40
  41 #include "common.h"
  42 #include "filter.h"
  43 #include "glob.h"
  44 #include "demangle.h"
  45
  46 struct options_t options = {
  47         .align    = DEFAULT_ALIGN,    /* alignment column for results */
  48         .user     = NULL,             /* username to run command as */
  49         .syscalls = 0,                /* display syscalls */
  50 #ifdef USE_DEMANGLE
  51         .demangle = 0,                /* Demangle low-level symbol names */
  52 #endif
  53         .indent = 0,                  /* indent output according to program flow */
  54         .output = NULL,               /* output to a specific file */
  55         .summary = 0,                 /* Report a summary on program exit */
  56         .debug = 0,                   /* debug */
  57         .arraylen = DEFAULT_ARRAYLEN, /* maximum # array elements to print */
  58         .strlen = DEFAULT_STRLEN,     /* maximum # of bytes printed in strings */
  59         .follow = 0,                  /* trace child processes */
  60 };
  61
  62 static char *progname;          /* Program name (`ltrace') */
  63 int opt_i = 0;                  /* instruction pointer */
  64 int opt_r = 0;                  /* print relative timestamp */
  65 int opt_t = 0;                  /* print absolute timestamp */
  66 int opt_T = 0;                  /* show the time spent inside each call */
  67
  68 /* List of pids given to option -p: */
  69 struct opt_p_t *opt_p = NULL;   /* attach to process with a given pid */
  70
  71 /* Vector of struct opt_F_t.  */
  72 struct vect opt_F;
  73
  74 static void
  75 err_usage(void) {
  76         fprintf(stderr, "Try `%s --help' for more information.\n", progname);
  77         exit(1);
  78 }
  79
  80 static void
  81 usage(void) {
  82         fprintf(stdout, "Usage: %s [option ...] [command [arg ...]]\n"
  83                 "Trace library calls of a given program.\n\n"
  84                 "  -a, --align=COLUMN  align return values in a secific column.\n"
  85                 "  -A MAXELTS          maximum number of array elements to print.\n"
  86                 "  -b, --no-signals    don't print signals.\n"
  87                 "  -c                  count time and calls, and report a summary on exit.\n"
  88 # ifdef USE_DEMANGLE
  89                 "  -C, --demangle      decode low-level symbol names into user-level names.\n"
  90 # endif
  91                 "  -D, --debug=MASK    enable debugging (see -Dh or --debug=help).\n"
  92                 "  -Dh, --debug=help   show help on debugging.\n"
  93                 "  -e FILTER           modify which library calls to trace.\n"
  94                 "  -f                  trace children (fork() and clone()).\n"
  95                 "  -F, --config=FILE   load alternate configuration file (may be repeated).\n"
  96                 "  -h, --help          display this help and exit.\n"
  97                 "  -i                  print instruction pointer at time of library call.\n"
  98                 "  -l, --library=LIBRARY_PATTERN only trace symbols implemented by this library.\n"
  99                 "  -L                  do NOT display library calls.\n"
 100                 "  -n, --indent=NR     indent output by NR spaces for each call level nesting.\n"
 101                 "  -o, --output=FILENAME write the trace output to file with given name.\n"
 102                 "  -p PID              attach to the process with the process ID pid.\n"
 103                 "  -r                  print relative timestamps.\n"
 104                 "  -s STRSIZE          specify the maximum string size to print.\n"
 105                 "  -S                  trace system calls as well as library calls.\n"
 106                 "  -t, -tt, -ttt       print absolute timestamps.\n"
 107                 "  -T                  show the time spent inside each call.\n"
 108                 "  -u USERNAME         run command with the userid, groupid of username.\n"
 109                 "  -V, --version       output version information and exit.\n"
 110 #if defined(HAVE_UNWINDER)
 111                 "  -w, --where=NR      print backtrace showing NR stack frames at most.\n"
 112 #endif /* defined(HAVE_UNWINDER) */
 113                 "  -x FILTER           modify which static functions to trace.\n"
 114                 "\nReport bugs to ltrace-devel@lists.alioth.debian.org\n",
 115                 progname);
 116 }
 117
 118 static void
 119 usage_debug(void) {
 120         fprintf(stdout, "%s debugging option, --debug=<octal> or -D<octal>:\n", progname);
 121         fprintf(stdout,
 122                         "\n"
 123                         " number  ref. in source   description\n"
 124                         "      1   general           Generally helpful progress information\n"
 125                         "     10   event             Shows every event received by a traced process\n"
 126                         "     20   process           Shows actions carried upon a traced processes\n"
 127                         "     40   function          Shows every entry to internal functions\n"
 128                         "\n"
 129                         "Debugging options are mixed using bitwise-or.\n"
 130                         "Note that the meanings and values are subject to change.\n"
 131                         "Also note that these values are used inconsistently in ltrace, and the\n"
 132                         "only debuglevel that you can rely on is -D77 that will show everything.\n"
 133                    );
 134 }
 135
 136 static char *
 137 search_for_command(char *filename) {
 138         static char pathname[PATH_MAX];
 139         char *path;
 140         int m, n;
 141
 142         if (strchr(filename, '/')) {
 143                 return filename;
 144         }
 145         for (path = getenv("PATH"); path && *path; path += m) {
 146                 if (strchr(path, ':')) {
 147                         n = strchr(path, ':') - path;
 148                         m = n + 1;
 149                 } else {
 150                         m = n = strlen(path);
 151                 }
 152                 if (n + strlen(filename) + 1 >= PATH_MAX) {
 153                         fprintf(stderr, "Error: filename too long.\n");
 154                         exit(1);
 155                 }
 156                 strncpy(pathname, path, n);
 157                 if (n && pathname[n - 1] != '/') {
 158                         pathname[n++] = '/';
 159                 }
 160                 strcpy(pathname + n, filename);
 161                 if (!access(pathname, X_OK)) {
 162                         return pathname;
 163                 }
 164         }
 165         return filename;
 166 }
 167
 168 static void
 169 guess_cols(void) {
 170         struct winsize ws;
 171         char *c;
 172
 173         options.align = DEFAULT_ALIGN;
 174         c = getenv("COLUMNS");
 175         if (c && *c) {
 176                 char *endptr;
 177                 int cols;
 178                 cols = strtol(c, &endptr, 0);
 179                 if (cols > 0 && !*endptr) {
 180                         options.align = cols * 5 / 8;
 181                 }
 182         } else if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col > 0) {
 183                 options.align = ws.ws_col * 5 / 8;
 184         } else if (ioctl(2, TIOCGWINSZ, &ws) != -1 && ws.ws_col > 0) {
 185                 options.align = ws.ws_col * 5 / 8;
 186         }
 187 }
 188
 189 static int
 190 compile_libname(const char *expr, const char *a_lib, int lib_re_p,
 191                 struct filter_lib_matcher *matcher)
 192 {
 193         if (strcmp(a_lib, "MAIN") == 0) {
 194                 filter_lib_matcher_main_init(matcher);
 195         } else {
 196                 /* Add ^ and $ to the library expression as well.  */
 197                 char lib[strlen(a_lib) + 3];
 198                 sprintf(lib, "^%s$", a_lib);
 199
 200                 enum filter_lib_matcher_type type
 201                         = lib[0] == '/' ? FLM_PATHNAME : FLM_SONAME;
 202
 203                 regex_t lib_re;
 204                 int status = (lib_re_p ? regcomp : globcomp)(&lib_re, lib, 0);
 205                 if (status != 0) {
 206                         char buf[100];
 207                         regerror(status, &lib_re, buf, sizeof buf);
 208                         fprintf(stderr, "Couldn't compile '%s': %s.\n",
 209                                 expr, buf);
 210                         return -1;
 211                 }
 212                 filter_lib_matcher_name_init(matcher, type, lib_re);
 213         }
 214         return 0;
 215 }
 216
 217 static int
 218 add_filter_rule(struct filter *filt, const char *expr,
 219                 enum filter_rule_type type,
 220                 const char *a_sym, int sym_re_p,
 221                 const char *a_lib, int lib_re_p)
 222 {
 223         struct filter_rule *rule = malloc(sizeof(*rule));
 224         struct filter_lib_matcher *matcher = malloc(sizeof(*matcher));
 225
 226         if (rule == NULL || matcher == NULL) {
 227         fail:
 228                 free(rule);
 229                 free(matcher);
 230                 return -1;
 231         }
 232
 233         regex_t symbol_re;
 234         {
 235                 /* Add ^ to the start of expression and $ to the end, so that
 236                  * we match the whole symbol name.  Let the user write the "*"
 237                  * explicitly if they wish.  */
 238                 char sym[strlen(a_sym) + 3];
 239                 sprintf(sym, "^%s$", a_sym);
 240                 int status = (sym_re_p ? regcomp : globcomp)
 241                         (&symbol_re, sym, 0);
 242                 if (status != 0) {
 243                         char buf[100];
 244                         regerror(status, &symbol_re, buf, sizeof buf);
 245                         fprintf(stderr, "Couldn't compile '%s': %s.\n",
 246                                 expr, buf);
 247                         goto fail;
 248                 }
 249         }
 250
 251         if (compile_libname(expr, a_lib, lib_re_p, matcher) < 0) {
 252                 regfree(&symbol_re);
 253                 goto fail;
 254         }
 255
 256         filter_rule_init(rule, type, matcher, symbol_re);
 257         filter_add_rule(filt, rule);
 258         return 0;
 259 }
 260
 261 static int
 262 grok_libname_pattern(char **libnamep, char **libendp)
 263 {
 264         char *libname = *libnamep;
 265         char *libend = *libendp;
 266
 267         if (libend[0] != '/')
 268                 return 0;
 269
 270         *libend-- = 0;
 271         if (libname != libend && libname[0] == '/')
 272                 ++libname;
 273         else
 274                 fprintf(stderr, "Unmatched '/' in library name.\n");
 275
 276         *libendp = libend;
 277         *libnamep = libname;
 278         return 1;
 279 }
 280
 281 static int
 282 parse_filter(struct filter *filt, char *expr, int operators)
 283 {
 284         /* Filter is a chain of sym@lib rules separated by '-' or '+'.
 285          * If the filter expression starts with '-', the missing
 286          * initial rule is implicitly *@*.  */
 287
 288         enum filter_rule_type type = FR_ADD;
 289
 290         while (*expr != 0) {
 291                 size_t s = strcspn(expr, &"-+@"[operators ? 0 : 2]);
 292                 char *symname = expr;
 293                 char *libname;
 294                 char *next = expr + s + 1;
 295                 enum filter_rule_type this_type = type;
 296
 297                 if (expr[s] == 0) {
 298                         libname = "*";
 299                         expr = next - 1;
 300
 301                 } else if (expr[s] == '-' || expr[s] == '+') {
 302                         type = expr[s] == '-' ? FR_SUBTRACT : FR_ADD;
 303                         expr[s] = 0;
 304                         libname = "*";
 305                         expr = next;
 306
 307                 } else {
 308                         assert(expr[s] == '@');
 309                         expr[s] = 0;
 310                         s = strcspn(next, &"-+"[operators ? 0 : 2]);
 311                         if (s == 0) {
 312                                 libname = "*";
 313                                 expr = next;
 314                         } else if (next[s] == 0) {
 315                                 expr = next + s;
 316                                 libname = next;
 317                         } else {
 318                                 assert(next[s] == '-' || next[s] == '+');
 319                                 type = next[s] == '-' ? FR_SUBTRACT : FR_ADD;
 320                                 next[s] = 0;
 321                                 expr = next + s + 1;
 322                                 libname = next;
 323                         }
 324                 }
 325
 326                 assert(*libname != 0);
 327                 char *symend = symname + strlen(symname) - 1;
 328                 char *libend = libname + strlen(libname) - 1;
 329                 int sym_is_re = 0;
 330                 int lib_is_re = 0;
 331
 332                 /*
 333                  * /xxx/@... and ...@/xxx/ means that xxx are regular
 334                  * expressions.  They are globs otherwise.
 335                  *
 336                  * /xxx@yyy/ is the same as /xxx/@/yyy/
 337                  *
 338                  * @/xxx matches library path name
 339                  * @.xxx matches library relative path name
 340                  */
 341                 if (symname[0] == '/') {
 342                         if (symname != symend && symend[0] == '/') {
 343                                 ++symname;
 344                                 *symend-- = 0;
 345                                 sym_is_re = 1;
 346
 347                         } else {
 348                                 sym_is_re = 1;
 349                                 lib_is_re = 1;
 350                                 ++symname;
 351
 352                                 /* /XXX@YYY/ is the same as
 353                                  * /XXX/@/YYY/.  */
 354                                 if (libend[0] != '/')
 355                                         fprintf(stderr, "Unmatched '/'"
 356                                                 " in symbol name.\n");
 357                                 else
 358                                         *libend-- = 0;
 359                         }
 360                 }
 361
 362                 /* If libname ends in '/', then we expect '/' in the
 363                  * beginning too.  Otherwise the initial '/' is part
 364                  * of absolute file name.  */
 365                 if (!lib_is_re)
 366                         lib_is_re = grok_libname_pattern(&libname, &libend);
 367
 368                 if (*symname == 0) /* /@AA/ */
 369                         symname = "*";
 370                 if (*libname == 0) /* /aa@/ */
 371                         libname = "*";
 372
 373                 add_filter_rule(filt, expr, this_type,
 374                                 symname, sym_is_re,
 375                                 libname, lib_is_re);
 376         }
 377
 378         return 0;
 379 }
 380
 381 static struct filter *
 382 recursive_parse_chain(const char *orig, char *expr, int operators)
 383 {
 384         struct filter *filt = malloc(sizeof(*filt));
 385         if (filt == NULL) {
 386                 fprintf(stderr, "(Part of) filter will be ignored: '%s': %s.\n",
 387                         expr, strerror(errno));
 388                 return NULL;
 389         }
 390
 391         filter_init(filt);
 392         if (parse_filter(filt, expr, operators) < 0) {
 393                 fprintf(stderr, "Filter '%s' will be ignored.\n", orig);
 394                 free(filt);
 395                 filt = NULL;
 396         }
 397
 398         return filt;
 399 }
 400
 401 static struct filter **
 402 slist_chase_end(struct filter **begin)
 403 {
 404         for (; *begin != NULL; begin = &(*begin)->next)
 405                 ;
 406         return begin;
 407 }
 408
 409 static void
 410 parse_filter_chain(const char *expr, struct filter **retp)
 411 {
 412         char *str = strdup(expr);
 413         if (str == NULL) {
 414                 fprintf(stderr, "Filter '%s' will be ignored: %s.\n",
 415                         expr, strerror(errno));
 416                 return;
 417         }
 418         /* Support initial '!' for backward compatibility.  */
 419         if (str[0] == '!')
 420                 str[0] = '-';
 421
 422         *slist_chase_end(retp) = recursive_parse_chain(expr, str, 1);
 423         free(str);
 424 }
 425
 426 static int
 427 parse_int(const char *optarg, char opt, int min, int max)
 428 {
 429         char *endptr;
 430         long int l = strtol(optarg, &endptr, 0);
 431         if (l < min || (max != 0 && l > max)
 432             || *optarg == 0 || *endptr != 0) {
 433                 const char *fmt = max != 0
 434                         ? "Invalid argument to -%c: '%s'.  Use integer %d..%d.\n"
 435                         : "Invalid argument to -%c: '%s'.  Use integer >=%d.\n";
 436                 fprintf(stderr, fmt, opt, optarg, min, max);
 437                 exit(1);
 438         }
 439         return (int)l;
 440 }
 441
 442 int
 443 parse_colon_separated_list(const char *paths, struct vect *vec)
 444 {
 445         /* PATHS contains a colon-separated list of directories and
 446          * files to load.  It's modeled after shell PATH variable,
 447          * which doesn't allow escapes.  PYTHONPATH in CPython behaves
 448          * the same way.  So let's follow suit, it makes things easier
 449          * to us.  */
 450
 451         char *clone = strdup(paths);
 452         if (clone == NULL) {
 453                 fprintf(stderr, "Couldn't parse argument %s: %s.\n",
 454                         paths, strerror(errno));
 455                 return -1;
 456         }
 457
 458         /* It's undesirable to use strtok, because we want the string
 459          * "a::b" to have three elements.  */
 460         char *tok = clone - 1;
 461         char *end = clone + strlen(clone);
 462         while (tok < end) {
 463                 ++tok;
 464                 size_t len = strcspn(tok, ":");
 465                 tok[len] = 0;
 466
 467                 struct opt_F_t arg = {
 468                         .pathname = tok,
 469                         .own_pathname = tok == clone,
 470                 };
 471                 if (VECT_PUSHBACK(vec, &arg) < 0)
 472                         /* Presumably this is not a deal-breaker.  */
 473                         fprintf(stderr, "Couldn't store component of %s: %s.\n",
 474                                 paths, strerror(errno));
 475
 476                 tok += len;
 477         }
 478
 479         return 0;
 480 }
 481
 482 void
 483 opt_F_destroy(struct opt_F_t *entry)
 484 {
 485         if (entry == NULL)
 486                 return;
 487         if (entry->own_pathname)
 488                 free(entry->pathname);
 489 }
 490
 491 enum opt_F_kind
 492 opt_F_get_kind(struct opt_F_t *entry)
 493 {
 494         if (entry->kind == OPT_F_UNKNOWN) {
 495                 struct stat st;
 496                 if (lstat(entry->pathname, &st) < 0) {
 497                         fprintf(stderr, "Couldn't stat %s: %s\n",
 498                                 entry->pathname, strerror(errno));
 499                         entry->kind = OPT_F_BROKEN;
 500                 } else if (S_ISDIR(st.st_mode)) {
 501                         entry->kind = OPT_F_DIR;
 502                 } else if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
 503                         entry->kind = OPT_F_FILE;
 504                 } else {
 505                         fprintf(stderr, "%s is neither a regular file, "
 506                                 "nor a directory.\n", entry->pathname);
 507                         entry->kind = OPT_F_BROKEN;
 508                 }
 509         }
 510         assert(entry->kind != OPT_F_UNKNOWN);
 511         return entry->kind;
 512 }
 513
 514 char **
 515 process_options(int argc, char **argv)
 516 {
 517         VECT_INIT(&opt_F, struct opt_F_t);
 518
 519         progname = argv[0];
 520         options.output = stderr;
 521         options.no_signals = 0;
 522 #if defined(HAVE_UNWINDER)
 523         options.bt_depth = -1;
 524 #endif /* defined(HAVE_UNWINDER) */
 525
 526         guess_cols();
 527
 528         int libcalls = 1;
 529
 530         while (1) {
 531                 int c;
 532                 char *p;
 533 #ifdef HAVE_GETOPT_LONG
 534                 int option_index = 0;
 535                 static struct option long_options[] = {
 536                         {"align", 1, 0, 'a'},
 537                         {"config", 1, 0, 'F'},
 538                         {"debug", 1, 0, 'D'},
 539 # ifdef USE_DEMANGLE
 540                         {"demangle", 0, 0, 'C'},
 541 # endif
 542                         {"indent", 1, 0, 'n'},
 543                         {"help", 0, 0, 'h'},
 544                         {"library", 1, 0, 'l'},
 545                         {"output", 1, 0, 'o'},
 546                         {"version", 0, 0, 'V'},
 547                         {"no-signals", 0, 0, 'b'},
 548 # if defined(HAVE_UNWINDER)
 549                         {"where", 1, 0, 'w'},
 550 # endif /* defined(HAVE_UNWINDER) */
 551                         {0, 0, 0, 0}
 552                 };
 553 #endif
 554
 555                 const char *opts = "+"
 556 #ifdef USE_DEMANGLE
 557                         "C"
 558 #endif
 559 #if defined(HAVE_UNWINDER)
 560                         "w:"
 561 #endif
 562                         "cfhiLrStTVba:A:D:e:F:l:n:o:p:s:u:x:";
 563
 564 #ifdef HAVE_GETOPT_LONG
 565                 c = getopt_long(argc, argv, opts, long_options, &option_index);
 566 #else
 567                 c = getopt(argc, argv, opts);
 568 #endif
 569                 if (c == -1) {
 570                         break;
 571                 }
 572                 switch (c) {
 573                 case 'a':
 574                         options.align = parse_int(optarg, 'a', 0, 0);
 575                         break;
 576                 case 'A':
 577                         options.arraylen = parse_int(optarg, 'A', 0, 0);
 578                         break;
 579                 case 'b':
 580                         options.no_signals = 1;
 581                         break;
 582                 case 'c':
 583                         options.summary++;
 584                         break;
 585 #ifdef USE_DEMANGLE
 586                 case 'C':
 587                         options.demangle++;
 588                         break;
 589 #endif
 590                 case 'D':
 591                         if (optarg[0]=='h') {
 592                                 usage_debug();
 593                                 exit(0);
 594                         }
 595                         options.debug = strtoul(optarg,&p,8);
 596                         if (*p) {
 597                                 fprintf(stderr, "%s: --debug requires an octal argument\n", progname);
 598                                 err_usage();
 599                         }
 600                         break;
 601
 602                 case 'e':
 603                         parse_filter_chain(optarg, &options.plt_filter);
 604                         break;
 605
 606                 case 'f':
 607                         options.follow = 1;
 608                         break;
 609                 case 'F':
 610                         parse_colon_separated_list(optarg, &opt_F);
 611                         break;
 612                 case 'h':
 613                         usage();
 614                         exit(0);
 615                 case 'i':
 616                         opt_i++;
 617                         break;
 618
 619                 case 'l': {
 620                         size_t patlen = strlen(optarg);
 621                         char buf[patlen + 2];
 622                         sprintf(buf, "@%s", optarg);
 623                         *slist_chase_end(&options.export_filter)
 624                                 = recursive_parse_chain(buf, buf, 0);
 625                         break;
 626                 }
 627
 628                 case 'L':
 629                         libcalls = 0;
 630                         break;
 631                 case 'n':
 632                         options.indent = parse_int(optarg, 'n', 0, 20);
 633                         break;
 634                 case 'o':
 635                         options.output = fopen(optarg, "w");
 636                         if (!options.output) {
 637                                 fprintf(stderr,
 638                                         "can't open %s for writing: %s\n",
 639                                         optarg, strerror(errno));
 640                                 exit(1);
 641                         }
 642                         setvbuf(options.output, (char *)NULL, _IOLBF, 0);
 643                         fcntl(fileno(options.output), F_SETFD, FD_CLOEXEC);
 644                         break;
 645                 case 'p':
 646                         {
 647                                 struct opt_p_t *tmp = malloc(sizeof(struct opt_p_t));
 648                                 if (!tmp) {
 649                                         perror("ltrace: malloc");
 650                                         exit(1);
 651                                 }
 652                                 tmp->pid = parse_int(optarg, 'p', 1, 0);
 653                                 tmp->next = opt_p;
 654                                 opt_p = tmp;
 655                                 break;
 656                         }
 657                 case 'r':
 658                         opt_r++;
 659                         break;
 660                 case 's':
 661                         options.strlen = parse_int(optarg, 's', 0, 0);
 662                         break;
 663                 case 'S':
 664                         options.syscalls = 1;
 665                         break;
 666                 case 't':
 667                         opt_t++;
 668                         break;
 669                 case 'T':
 670                         opt_T++;
 671                         break;
 672                 case 'u':
 673                         options.user = optarg;
 674                         break;
 675                 case 'V':
 676                         printf("ltrace " PACKAGE_VERSION "\n"
 677                                "Copyright (C) 2010-2013 Petr Machata, Red Hat Inc.\n"
 678                                "Copyright (C) 1997-2009 Juan Cespedes <cespedes@debian.org>.\n"
 679                                "License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>\n"
 680                                "This is free software: you are free to change and redistribute it.\n"
 681                                "There is NO WARRANTY, to the extent permitted by law.\n");
 682                         exit(0);
 683                         break;
 684 #if defined(HAVE_UNWINDER)
 685                 case 'w':
 686                         options.bt_depth = parse_int(optarg, 'w', 1, 0);
 687                         break;
 688 #endif /* defined(HAVE_UNWINDER) */
 689
 690                 case 'x':
 691                         parse_filter_chain(optarg, &options.static_filter);
 692                         break;
 693
 694                 default:
 695                         err_usage();
 696                 }
 697         }
 698         argc -= optind;
 699         argv += optind;
 700
 701         /* If neither -e, nor -l, nor -L are used, set default -e.
 702          * Use @MAIN for now, as that's what ltrace used to have in
 703          * the past.  XXX Maybe we should make this "*" instead.  */
 704         if (libcalls
 705             && options.plt_filter == NULL
 706             && options.export_filter == NULL) {
 707                 parse_filter_chain("@MAIN", &options.plt_filter);
 708                 options.hide_caller = 1;
 709         }
 710         if (!libcalls && options.plt_filter != NULL) {
 711                 fprintf(stderr,
 712                         "%s: Option -L can't be used with -e or -l.\n",
 713                         progname);
 714                 err_usage();
 715         }
 716
 717         if (!opt_p && argc < 1) {
 718                 fprintf(stderr, "%s: too few arguments\n", progname);
 719                 err_usage();
 720         }
 721         if (opt_r && opt_t) {
 722                 fprintf(stderr,
 723                         "%s: Options -r and -t can't be used together\n",
 724                         progname);
 725                 err_usage();
 726         }
 727         if (argc > 0) {
 728                 command = search_for_command(argv[0]);
 729         }
 730         return &argv[0];
 731 }