binutils/strings.c

   1 /* strings -- print the strings of printable characters in files
   2    Copyright (C) 1993-2018 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  17    02110-1301, USA.  */
  18 \f
  19 /* Usage: strings [options] file...
  20
  21    Options:
  22    --all
  23    -a
  24    -            Scan each file in its entirety.
  25
  26    --data
  27    -d           Scan only the initialized data section(s) of object files.
  28
  29    --print-file-name
  30    -f           Print the name of the file before each string.
  31
  32    --bytes=min-len
  33    -n min-len
  34    -min-len     Print graphic char sequences, MIN-LEN or more bytes long,
  35                 that are followed by a NUL or a newline.  Default is 4.
  36
  37    --radix={o,x,d}
  38    -t {o,x,d}   Print the offset within the file before each string,
  39                 in octal/hex/decimal.
  40
  41   --include-all-whitespace
  42   -w            By default tab and space are the only whitepace included in graphic
  43                 char sequences.  This option considers all of isspace() valid.
  44
  45    -o           Like -to.  (Some other implementations have -o like -to,
  46                 others like -td.  We chose one arbitrarily.)
  47
  48    --encoding={s,S,b,l,B,L}
  49    -e {s,S,b,l,B,L}
  50                 Select character encoding: 7-bit-character, 8-bit-character,
  51                 bigendian 16-bit, littleendian 16-bit, bigendian 32-bit,
  52                 littleendian 32-bit.
  53
  54    --target=BFDNAME
  55    -T {bfdname}
  56                 Specify a non-default object file format.
  57
  58   --output-separator=sep_string
  59   -s sep_string String used to separate parsed strings in output.
  60                 Default is newline.
  61
  62    --help
  63    -h           Print the usage message on the standard output.
  64
  65    --version
  66    -V
  67    -v           Print the program version number.
  68
  69    Written by Richard Stallman <rms@gnu.ai.mit.edu>
  70    and David MacKenzie <djm@gnu.ai.mit.edu>.  */
  71
  72 #include "sysdep.h"
  73 #include "bfd.h"
  74 #include "getopt.h"
  75 #include "libiberty.h"
  76 #include "safe-ctype.h"
  77 #include "bucomm.h"
  78
  79 #define STRING_ISGRAPHIC(c) \
  80       (   (c) >= 0 \
  81        && (c) <= 255 \
  82        && ((c) == '\t' || ISPRINT (c) || (encoding == 'S' && (c) > 127) \
  83            || (include_all_whitespace && ISSPACE (c))) \
  84       )
  85
  86 #ifndef errno
  87 extern int errno;
  88 #endif
  89
  90 /* The BFD section flags that identify an initialized data section.  */
  91 #define DATA_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)
  92
  93 /* Radix for printing addresses (must be 8, 10 or 16).  */
  94 static int address_radix;
  95
  96 /* Minimum length of sequence of graphic chars to trigger output.  */
  97 static int string_min;
  98
  99 /* Whether or not we include all whitespace as a graphic char.   */
 100 static bfd_boolean include_all_whitespace;
 101
 102 /* TRUE means print address within file for each string.  */
 103 static bfd_boolean print_addresses;
 104
 105 /* TRUE means print filename for each string.  */
 106 static bfd_boolean print_filenames;
 107
 108 /* TRUE means for object files scan only the data section.  */
 109 static bfd_boolean datasection_only;
 110
 111 /* The BFD object file format.  */
 112 static char *target;
 113
 114 /* The character encoding format.  */
 115 static char encoding;
 116 static int encoding_bytes;
 117
 118 /* Output string used to separate parsed strings  */
 119 static char *output_separator;
 120
 121 static struct option long_options[] =
 122 {
 123   {"all", no_argument, NULL, 'a'},
 124   {"data", no_argument, NULL, 'd'},
 125   {"print-file-name", no_argument, NULL, 'f'},
 126   {"bytes", required_argument, NULL, 'n'},
 127   {"radix", required_argument, NULL, 't'},
 128   {"include-all-whitespace", no_argument, NULL, 'w'},
 129   {"encoding", required_argument, NULL, 'e'},
 130   {"target", required_argument, NULL, 'T'},
 131   {"output-separator", required_argument, NULL, 's'},
 132   {"help", no_argument, NULL, 'h'},
 133   {"version", no_argument, NULL, 'v'},
 134   {NULL, 0, NULL, 0}
 135 };
 136
 137 static bfd_boolean strings_file (char *);
 138 static void print_strings (const char *, FILE *, file_ptr, int, int, char *);
 139 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
 140 \f
 141 int main (int, char **);
 142
 143 int
 144 main (int argc, char **argv)
 145 {
 146   int optc;
 147   int exit_status = 0;
 148   bfd_boolean files_given = FALSE;
 149   char *s;
 150   int numeric_opt = 0;
 151
 152 #if defined (HAVE_SETLOCALE)
 153   setlocale (LC_ALL, "");
 154 #endif
 155   bindtextdomain (PACKAGE, LOCALEDIR);
 156   textdomain (PACKAGE);
 157
 158   program_name = argv[0];
 159   xmalloc_set_program_name (program_name);
 160   bfd_set_error_program_name (program_name);
 161
 162   expandargv (&argc, &argv);
 163
 164   string_min = 4;
 165   include_all_whitespace = FALSE;
 166   print_addresses = FALSE;
 167   print_filenames = FALSE;
 168   if (DEFAULT_STRINGS_ALL)
 169     datasection_only = FALSE;
 170   else
 171     datasection_only = TRUE;
 172   target = NULL;
 173   encoding = 's';
 174   output_separator = NULL;
 175
 176   while ((optc = getopt_long (argc, argv, "adfhHn:wot:e:T:s:Vv0123456789",
 177                               long_options, (int *) 0)) != EOF)
 178     {
 179       switch (optc)
 180         {
 181         case 'a':
 182           datasection_only = FALSE;
 183           break;
 184
 185         case 'd':
 186           datasection_only = TRUE;
 187           break;
 188
 189         case 'f':
 190           print_filenames = TRUE;
 191           break;
 192
 193         case 'H':
 194         case 'h':
 195           usage (stdout, 0);
 196
 197         case 'n':
 198           string_min = (int) strtoul (optarg, &s, 0);
 199           if (s != NULL && *s != 0)
 200             fatal (_("invalid integer argument %s"), optarg);
 201           break;
 202
 203         case 'w':
 204           include_all_whitespace = TRUE;
 205           break;
 206
 207         case 'o':
 208           print_addresses = TRUE;
 209           address_radix = 8;
 210           break;
 211
 212         case 't':
 213           print_addresses = TRUE;
 214           if (optarg[1] != '\0')
 215             usage (stderr, 1);
 216           switch (optarg[0])
 217             {
 218             case 'o':
 219               address_radix = 8;
 220               break;
 221
 222             case 'd':
 223               address_radix = 10;
 224               break;
 225
 226             case 'x':
 227               address_radix = 16;
 228               break;
 229
 230             default:
 231               usage (stderr, 1);
 232             }
 233           break;
 234
 235         case 'T':
 236           target = optarg;
 237           break;
 238
 239         case 'e':
 240           if (optarg[1] != '\0')
 241             usage (stderr, 1);
 242           encoding = optarg[0];
 243           break;
 244
 245         case 's':
 246           output_separator = optarg;
 247           break;
 248
 249         case 'V':
 250         case 'v':
 251           print_version ("strings");
 252           break;
 253
 254         case '?':
 255           usage (stderr, 1);
 256
 257         default:
 258           numeric_opt = optind;
 259           break;
 260         }
 261     }
 262
 263   if (numeric_opt != 0)
 264     {
 265       string_min = (int) strtoul (argv[numeric_opt - 1] + 1, &s, 0);
 266       if (s != NULL && *s != 0)
 267         fatal (_("invalid integer argument %s"), argv[numeric_opt - 1] + 1);
 268     }
 269   if (string_min < 1)
 270     fatal (_("invalid minimum string length %d"), string_min);
 271
 272   switch (encoding)
 273     {
 274     case 'S':
 275     case 's':
 276       encoding_bytes = 1;
 277       break;
 278     case 'b':
 279     case 'l':
 280       encoding_bytes = 2;
 281       break;
 282     case 'B':
 283     case 'L':
 284       encoding_bytes = 4;
 285       break;
 286     default:
 287       usage (stderr, 1);
 288     }
 289
 290   if (bfd_init () != BFD_INIT_MAGIC)
 291     fatal (_("fatal error: libbfd ABI mismatch"));
 292   set_default_bfd_target ();
 293
 294   if (optind >= argc)
 295     {
 296       datasection_only = FALSE;
 297       SET_BINARY (fileno (stdin));
 298       print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
 299       files_given = TRUE;
 300     }
 301   else
 302     {
 303       for (; optind < argc; ++optind)
 304         {
 305           if (strcmp (argv[optind], "-") == 0)
 306             datasection_only = FALSE;
 307           else
 308             {
 309               files_given = TRUE;
 310               exit_status |= !strings_file (argv[optind]);
 311             }
 312         }
 313     }
 314
 315   if (!files_given)
 316     usage (stderr, 1);
 317
 318   return (exit_status);
 319 }
 320 \f
 321 /* Scan section SECT of the file ABFD, whose printable name is
 322    FILENAME.  If it contains initialized data set GOT_A_SECTION and
 323    print the strings in it.  */
 324
 325 static void
 326 strings_a_section (bfd *abfd, asection *sect, const char *filename,
 327                    bfd_boolean *got_a_section)
 328 {
 329   bfd_size_type sectsize;
 330   bfd_byte *mem;
 331
 332   if ((sect->flags & DATA_FLAGS) != DATA_FLAGS)
 333     return;
 334
 335   sectsize = bfd_get_section_size (sect);
 336   if (sectsize == 0)
 337     return;
 338
 339   if (!bfd_malloc_and_get_section (abfd, sect, &mem))
 340     {
 341       non_fatal (_("%s: Reading section %s failed: %s"),
 342                  filename, sect->name, bfd_errmsg (bfd_get_error ()));
 343       return;
 344     }
 345
 346   *got_a_section = TRUE;
 347   print_strings (filename, NULL, sect->filepos, 0, sectsize, (char *) mem);
 348   free (mem);
 349 }
 350
 351 /* Scan all of the sections in FILE, and print the strings
 352    in the initialized data section(s).
 353
 354    Return TRUE if successful,
 355    FALSE if not (such as if FILE is not an object file).  */
 356
 357 static bfd_boolean
 358 strings_object_file (const char *file)
 359 {
 360   bfd *abfd;
 361   asection *s;
 362   bfd_boolean got_a_section;
 363
 364   abfd = bfd_openr (file, target);
 365
 366   if (abfd == NULL)
 367     /* Treat the file as a non-object file.  */
 368     return FALSE;
 369
 370   /* This call is mainly for its side effect of reading in the sections.
 371      We follow the traditional behavior of `strings' in that we don't
 372      complain if we don't recognize a file to be an object file.  */
 373   if (!bfd_check_format (abfd, bfd_object))
 374     {
 375       bfd_close (abfd);
 376       return FALSE;
 377     }
 378
 379   got_a_section = FALSE;
 380   for (s = abfd->sections; s != NULL; s = s->next)
 381     strings_a_section (abfd, s, file, &got_a_section);
 382
 383   if (!bfd_close (abfd))
 384     {
 385       bfd_nonfatal (file);
 386       return FALSE;
 387     }
 388
 389   return got_a_section;
 390 }
 391
 392 /* Print the strings in FILE.  Return TRUE if ok, FALSE if an error occurs.  */
 393
 394 static bfd_boolean
 395 strings_file (char *file)
 396 {
 397   struct stat st;
 398
 399   /* get_file_size does not support non-S_ISREG files.  */
 400
 401   if (stat (file, &st) < 0)
 402     {
 403       if (errno == ENOENT)
 404         non_fatal (_("'%s': No such file"), file);
 405       else
 406         non_fatal (_("Warning: could not locate '%s'.  reason: %s"),
 407                    file, strerror (errno));
 408       return FALSE;
 409     }
 410   else if (S_ISDIR (st.st_mode))
 411     {
 412       non_fatal (_("Warning: '%s' is a directory"), file);
 413       return FALSE;
 414     }
 415
 416   /* If we weren't told to scan the whole file,
 417      try to open it as an object file and only look at
 418      initialized data sections.  If that fails, fall back to the
 419      whole file.  */
 420   if (!datasection_only || !strings_object_file (file))
 421     {
 422       FILE *stream;
 423
 424       stream = fopen (file, FOPEN_RB);
 425       if (stream == NULL)
 426         {
 427           fprintf (stderr, "%s: ", program_name);
 428           perror (file);
 429           return FALSE;
 430         }
 431
 432       print_strings (file, stream, (file_ptr) 0, 0, 0, (char *) 0);
 433
 434       if (fclose (stream) == EOF)
 435         {
 436           fprintf (stderr, "%s: ", program_name);
 437           perror (file);
 438           return FALSE;
 439         }
 440     }
 441
 442   return TRUE;
 443 }
 444 \f
 445 /* Read the next character, return EOF if none available.
 446    Assume that STREAM is positioned so that the next byte read
 447    is at address ADDRESS in the file.
 448
 449    If STREAM is NULL, do not read from it.
 450    The caller can supply a buffer of characters
 451    to be processed before the data in STREAM.
 452    MAGIC is the address of the buffer and
 453    MAGICCOUNT is how many characters are in it.  */
 454
 455 static long
 456 get_char (FILE *stream, file_ptr *address, int *magiccount, char **magic)
 457 {
 458   int c, i;
 459   long r = 0;
 460
 461   for (i = 0; i < encoding_bytes; i++)
 462     {
 463       if (*magiccount)
 464         {
 465           (*magiccount)--;
 466           c = *(*magic)++;
 467         }
 468       else
 469         {
 470           if (stream == NULL)
 471             return EOF;
 472
 473           /* Only use getc_unlocked if we found a declaration for it.
 474              Otherwise, libc is not thread safe by default, and we
 475              should not use it.  */
 476
 477 #if defined(HAVE_GETC_UNLOCKED) && HAVE_DECL_GETC_UNLOCKED
 478           c = getc_unlocked (stream);
 479 #else
 480           c = getc (stream);
 481 #endif
 482           if (c == EOF)
 483             return EOF;
 484         }
 485
 486       (*address)++;
 487       r = (r << 8) | (c & 0xff);
 488     }
 489
 490   switch (encoding)
 491     {
 492     default:
 493       break;
 494     case 'l':
 495       r = ((r & 0xff) << 8) | ((r & 0xff00) >> 8);
 496       break;
 497     case 'L':
 498       r = (((r & 0xff) << 24) | ((r & 0xff00) << 8)
 499            | ((r & 0xff0000) >> 8) | ((r & 0xff000000) >> 24));
 500       break;
 501     }
 502
 503   return r;
 504 }
 505 \f
 506 /* Find the strings in file FILENAME, read from STREAM.
 507    Assume that STREAM is positioned so that the next byte read
 508    is at address ADDRESS in the file.
 509    Stop reading at address STOP_POINT in the file, if nonzero.
 510
 511    If STREAM is NULL, do not read from it.
 512    The caller can supply a buffer of characters
 513    to be processed before the data in STREAM.
 514    MAGIC is the address of the buffer and
 515    MAGICCOUNT is how many characters are in it.
 516    Those characters come at address ADDRESS and the data in STREAM follow.  */
 517
 518 static void
 519 print_strings (const char *filename, FILE *stream, file_ptr address,
 520                int stop_point, int magiccount, char *magic)
 521 {
 522   char *buf = (char *) xmalloc (sizeof (char) * (string_min + 1));
 523
 524   while (1)
 525     {
 526       file_ptr start;
 527       int i;
 528       long c;
 529
 530       /* See if the next `string_min' chars are all graphic chars.  */
 531     tryline:
 532       if (stop_point && address >= stop_point)
 533         break;
 534       start = address;
 535       for (i = 0; i < string_min; i++)
 536         {
 537           c = get_char (stream, &address, &magiccount, &magic);
 538           if (c == EOF)
 539             {
 540               free (buf);
 541               return;
 542             }
 543
 544           if (! STRING_ISGRAPHIC (c))
 545             {
 546               /* Found a non-graphic. Try again starting with next char.  */
 547               if (encoding_bytes > 1)
 548                 {
 549                   /* In case of multibyte encodings rewind using magic buffer.  */
 550                   if (magiccount == 0)
 551                     {
 552                       /* If no magic buffer exists: use memory of c.  */
 553                       switch (encoding)
 554                         {
 555                         default:
 556                           break;
 557                         case 'b':
 558                           c = c & 0xff;
 559                           magiccount += 1;
 560                           break;
 561                         case 'l':
 562                         case 'L':
 563                           c = c >> 8;
 564                           magiccount += (encoding_bytes -1);
 565                           break;
 566                         case 'B':
 567                           c = (( c & 0xff0000) >> 16) | ( c & 0xff00)
 568                             | (( c & 0xff) << 16);
 569                           magiccount += 3;
 570                           break;
 571                         }
 572                       magic = (char *) &c;
 573                     }
 574                   else
 575                     {
 576                       /* If magic buffer exists: rewind.  */
 577                       magic = magic - (encoding_bytes -1);
 578                     }
 579
 580                   address = address - (encoding_bytes -1);
 581                 }
 582
 583               goto tryline;
 584             }
 585           buf[i] = c;
 586         }
 587
 588       /* We found a run of `string_min' graphic characters.  Print up
 589          to the next non-graphic character.  */
 590
 591       if (print_filenames)
 592         printf ("%s: ", filename);
 593       if (print_addresses)
 594         switch (address_radix)
 595           {
 596           case 8:
 597 #ifdef HAVE_LONG_LONG
 598             if (sizeof (start) > sizeof (long))
 599               {
 600 # ifndef __MSVCRT__
 601                 printf ("%7llo ", (unsigned long long) start);
 602 # else
 603                 printf ("%7I64o ", (unsigned long long) start);
 604 # endif
 605               }
 606             else
 607 #elif !BFD_HOST_64BIT_LONG
 608             if (start != (unsigned long) start)
 609               printf ("++%7lo ", (unsigned long) start);
 610             else
 611 #endif
 612               printf ("%7lo ", (unsigned long) start);
 613             break;
 614
 615           case 10:
 616 #ifdef HAVE_LONG_LONG
 617             if (sizeof (start) > sizeof (long))
 618               {
 619 # ifndef __MSVCRT__
 620                 printf ("%7lld ", (unsigned long long) start);
 621 # else
 622                 printf ("%7I64d ", (unsigned long long) start);
 623 # endif
 624               }
 625             else
 626 #elif !BFD_HOST_64BIT_LONG
 627             if (start != (unsigned long) start)
 628               printf ("++%7ld ", (unsigned long) start);
 629             else
 630 #endif
 631               printf ("%7ld ", (long) start);
 632             break;
 633
 634           case 16:
 635 #ifdef HAVE_LONG_LONG
 636             if (sizeof (start) > sizeof (long))
 637               {
 638 # ifndef __MSVCRT__
 639                 printf ("%7llx ", (unsigned long long) start);
 640 # else
 641                 printf ("%7I64x ", (unsigned long long) start);
 642 # endif
 643               }
 644             else
 645 #elif !BFD_HOST_64BIT_LONG
 646             if (start != (unsigned long) start)
 647               printf ("%lx%8.8lx ", (unsigned long) (start >> 32),
 648                       (unsigned long) (start & 0xffffffff));
 649             else
 650 #endif
 651               printf ("%7lx ", (unsigned long) start);
 652             break;
 653           }
 654
 655       buf[i] = '\0';
 656       fputs (buf, stdout);
 657
 658       while (1)
 659         {
 660           c = get_char (stream, &address, &magiccount, &magic);
 661           if (c == EOF)
 662             break;
 663           if (! STRING_ISGRAPHIC (c))
 664             {
 665               if (encoding_bytes > 1)
 666                 {
 667                   /* In case of multibyte encodings rewind using magic buffer.  */
 668                   if (magiccount == 0)
 669                     {
 670                       /* If no magic buffer exists: use memory of c.  */
 671                       switch (encoding)
 672                         {
 673                         default:
 674                           break;
 675                         case 'b':
 676                           c = c & 0xff;
 677                           magiccount += 1;
 678                           break;
 679                         case 'l':
 680                         case 'L':
 681                           c = c >> 8;
 682                           magiccount += (encoding_bytes -1);
 683                           break;
 684                         case 'B':
 685                           c = (( c & 0xff0000) >> 16) | ( c & 0xff00)
 686                             | (( c & 0xff) << 16);
 687                           magiccount += 3;
 688                           break;
 689                         }
 690                       magic = (char *) &c;
 691                     }
 692                   else
 693                     {
 694                       /* If magic buffer exists: rewind.  */
 695                       magic = magic - (encoding_bytes -1);
 696                     }
 697                   address = address - (encoding_bytes -1);
 698                 }
 699               break;
 700             }
 701           putchar (c);
 702         }
 703
 704       if (output_separator)
 705         fputs (output_separator, stdout);
 706       else
 707         putchar ('\n');
 708     }
 709   free (buf);
 710 }
 711 \f
 712 static void
 713 usage (FILE *stream, int status)
 714 {
 715   fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
 716   fprintf (stream, _(" Display printable strings in [file(s)] (stdin by default)\n"));
 717   fprintf (stream, _(" The options are:\n"));
 718
 719   if (DEFAULT_STRINGS_ALL)
 720     fprintf (stream, _("\
 721   -a - --all                Scan the entire file, not just the data section [default]\n\
 722   -d --data                 Only scan the data sections in the file\n"));
 723   else
 724     fprintf (stream, _("\
 725   -a - --all                Scan the entire file, not just the data section\n\
 726   -d --data                 Only scan the data sections in the file [default]\n"));
 727
 728   fprintf (stream, _("\
 729   -f --print-file-name      Print the name of the file before each string\n\
 730   -n --bytes=[number]       Locate & print any NUL-terminated sequence of at\n\
 731   -<number>                   least [number] characters (default 4).\n\
 732   -t --radix={o,d,x}        Print the location of the string in base 8, 10 or 16\n\
 733   -w --include-all-whitespace Include all whitespace as valid string characters\n\
 734   -o                        An alias for --radix=o\n\
 735   -T --target=<BFDNAME>     Specify the binary file format\n\
 736   -e --encoding={s,S,b,l,B,L} Select character size and endianness:\n\
 737                             s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit\n\
 738   -s --output-separator=<string> String used to separate strings in output.\n\
 739   @<file>                   Read options from <file>\n\
 740   -h --help                 Display this information\n\
 741   -v -V --version           Print the program's version number\n"));
 742   list_supported_targets (program_name, stream);
 743   if (REPORT_BUGS_TO[0] && status == 0)
 744     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 745   exit (status);
 746 }