binutils/strings.c

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