Add check to avoid corrupt input files whose section sizes are greater than
[platform/upstream/binutils.git] / 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, 2005 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 /* Records the size of a named file so that we
155    do not repeatedly run bfd_stat() on it.  */
156
157 typedef struct
158 {
159   const char *  filename;
160   bfd_size_type filesize;
161 } filename_and_size_t;
162
163 static void strings_a_section (bfd *, asection *, void *);
164 static bfd_boolean strings_object_file (const char *);
165 static bfd_boolean strings_file (char *file);
166 static int integer_arg (char *s);
167 static void print_strings (const char *, FILE *, file_off, int, int, char *);
168 static void usage (FILE *, int);
169 static long get_char (FILE *, file_off *, int *, char **);
170 \f
171 int main (int, char **);
172
173 int
174 main (int argc, char **argv)
175 {
176   int optc;
177   int exit_status = 0;
178   bfd_boolean files_given = FALSE;
179
180 #if defined (HAVE_SETLOCALE)
181   setlocale (LC_ALL, "");
182 #endif
183   bindtextdomain (PACKAGE, LOCALEDIR);
184   textdomain (PACKAGE);
185
186   program_name = argv[0];
187   xmalloc_set_program_name (program_name);
188   string_min = -1;
189   print_addresses = FALSE;
190   print_filenames = FALSE;
191   datasection_only = TRUE;
192   target = NULL;
193   encoding = 's';
194
195   while ((optc = getopt_long (argc, argv, "afhHn:ot:e:Vv0123456789",
196                               long_options, (int *) 0)) != EOF)
197     {
198       switch (optc)
199         {
200         case 'a':
201           datasection_only = FALSE;
202           break;
203
204         case 'f':
205           print_filenames = TRUE;
206           break;
207
208         case 'H':
209         case 'h':
210           usage (stdout, 0);
211
212         case 'n':
213           string_min = integer_arg (optarg);
214           if (string_min < 1)
215             fatal (_("invalid number %s"), optarg);
216           break;
217
218         case 'o':
219           print_addresses = TRUE;
220           address_radix = 8;
221           break;
222
223         case 't':
224           print_addresses = TRUE;
225           if (optarg[1] != '\0')
226             usage (stderr, 1);
227           switch (optarg[0])
228             {
229             case 'o':
230               address_radix = 8;
231               break;
232
233             case 'd':
234               address_radix = 10;
235               break;
236
237             case 'x':
238               address_radix = 16;
239               break;
240
241             default:
242               usage (stderr, 1);
243             }
244           break;
245
246         case 'T':
247           target = optarg;
248           break;
249
250         case 'e':
251           if (optarg[1] != '\0')
252             usage (stderr, 1);
253           encoding = optarg[0];
254           break;
255
256         case 'V':
257         case 'v':
258           print_version ("strings");
259           break;
260
261         case '?':
262           usage (stderr, 1);
263
264         default:
265           if (string_min < 0)
266             string_min = optc - '0';
267           else
268             string_min = string_min * 10 + optc - '0';
269           break;
270         }
271     }
272
273   if (string_min < 0)
274     string_min = 4;
275
276   switch (encoding)
277     {
278     case 'S':
279     case 's':
280       encoding_bytes = 1;
281       break;
282     case 'b':
283     case 'l':
284       encoding_bytes = 2;
285       break;
286     case 'B':
287     case 'L':
288       encoding_bytes = 4;
289       break;
290     default:
291       usage (stderr, 1);
292     }
293
294   bfd_init ();
295   set_default_bfd_target ();
296
297   if (optind >= argc)
298     {
299       datasection_only = FALSE;
300 #ifdef SET_BINARY
301       SET_BINARY (fileno (stdin));
302 #endif
303       print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
304       files_given = TRUE;
305     }
306   else
307     {
308       for (; optind < argc; ++optind)
309         {
310           if (strcmp (argv[optind], "-") == 0)
311             datasection_only = FALSE;
312           else
313             {
314               files_given = TRUE;
315               exit_status |= strings_file (argv[optind]) == FALSE;
316             }
317         }
318     }
319
320   if (!files_given)
321     usage (stderr, 1);
322
323   return (exit_status);
324 }
325 \f
326 /* Scan section SECT of the file ABFD, whose printable name is in
327    ARG->filename and whose size might be in ARG->filesize.  If it
328    contains initialized data set `got_a_section' and print the
329    strings in it.
330
331    FIXME: We ought to be able to return error codes/messages for
332    certain conditions.  */
333
334 static void
335 strings_a_section (bfd *abfd, asection *sect, void *arg)
336 {
337   filename_and_size_t * filename_and_sizep;
338   bfd_size_type *filesizep;
339   bfd_size_type sectsize;
340   void *mem;
341      
342   if ((sect->flags & DATA_FLAGS) != DATA_FLAGS)
343     return;
344
345   sectsize = bfd_get_section_size (sect);
346      
347   if (sectsize <= 0)
348     return;
349
350   /* Get the size of the file.  This might have been cached for us.  */
351   filename_and_sizep = (filename_and_size_t *) arg;
352   filesizep = & filename_and_sizep->filesize;
353
354   if (*filesizep == 0)
355     {
356       struct stat st;
357       
358       if (bfd_stat (abfd, &st))
359         return;
360
361       /* Cache the result so that we do not repeatedly stat this file.  */
362       *filesizep = st.st_size;
363     }
364
365   /* Compare the size of the section against the size of the file.
366      If the section is bigger then the file must be corrupt and
367      we should not try dumping it.  */
368   if (sectsize >= *filesizep)
369     return;
370
371   mem = xmalloc (sectsize);
372
373   if (bfd_get_section_contents (abfd, sect, mem, (file_ptr) 0, sectsize))
374     {
375       got_a_section = TRUE;
376
377       print_strings (filename_and_sizep->filename, NULL, sect->filepos,
378                      0, sectsize, mem);
379     }
380
381   free (mem);
382 }
383
384 /* Scan all of the sections in FILE, and print the strings
385    in the initialized data section(s).
386
387    Return TRUE if successful,
388    FALSE if not (such as if FILE is not an object file).  */
389
390 static bfd_boolean
391 strings_object_file (const char *file)
392 {
393   filename_and_size_t filename_and_size;
394   bfd *abfd;
395
396   abfd = bfd_openr (file, target);
397
398   if (abfd == NULL)
399     /* Treat the file as a non-object file.  */
400     return FALSE;
401
402   /* This call is mainly for its side effect of reading in the sections.
403      We follow the traditional behavior of `strings' in that we don't
404      complain if we don't recognize a file to be an object file.  */
405   if (!bfd_check_format (abfd, bfd_object))
406     {
407       bfd_close (abfd);
408       return FALSE;
409     }
410
411   got_a_section = FALSE;
412   filename_and_size.filename = file;
413   filename_and_size.filesize = 0;
414   bfd_map_over_sections (abfd, strings_a_section, & filename_and_size);
415
416   if (!bfd_close (abfd))
417     {
418       bfd_nonfatal (file);
419       return FALSE;
420     }
421
422   return got_a_section;
423 }
424
425 /* Print the strings in FILE.  Return TRUE if ok, FALSE if an error occurs.  */
426
427 static bfd_boolean
428 strings_file (char *file)
429 {
430   statbuf st;
431
432   if (file_stat (file, &st) < 0)
433     {
434       if (errno == ENOENT)
435         non_fatal (_("'%s': No such file"), file);
436       else
437         non_fatal (_("Warning: could not locate '%s'.  reason: %s"),
438                    file, strerror (errno));
439       return FALSE;
440     }
441
442   /* If we weren't told to scan the whole file,
443      try to open it as an object file and only look at
444      initialized data sections.  If that fails, fall back to the
445      whole file.  */
446   if (!datasection_only || !strings_object_file (file))
447     {
448       FILE *stream;
449
450       stream = file_open (file, FOPEN_RB);
451       if (stream == NULL)
452         {
453           fprintf (stderr, "%s: ", program_name);
454           perror (file);
455           return FALSE;
456         }
457
458       print_strings (file, stream, (file_off) 0, 0, 0, (char *) 0);
459
460       if (fclose (stream) == EOF)
461         {
462           fprintf (stderr, "%s: ", program_name);
463           perror (file);
464           return FALSE;
465         }
466     }
467
468   return TRUE;
469 }
470 \f
471 /* Read the next character, return EOF if none available.
472    Assume that STREAM is positioned so that the next byte read
473    is at address ADDRESS in the file.
474
475    If STREAM is NULL, do not read from it.
476    The caller can supply a buffer of characters
477    to be processed before the data in STREAM.
478    MAGIC is the address of the buffer and
479    MAGICCOUNT is how many characters are in it.  */
480
481 static long
482 get_char (FILE *stream, file_off *address, int *magiccount, char **magic)
483 {
484   int c, i;
485   long r = EOF;
486   unsigned char buf[4];
487
488   for (i = 0; i < encoding_bytes; i++)
489     {
490       if (*magiccount)
491         {
492           (*magiccount)--;
493           c = *(*magic)++;
494         }
495       else
496         {
497           if (stream == NULL)
498             return EOF;
499
500           /* Only use getc_unlocked if we found a declaration for it.
501              Otherwise, libc is not thread safe by default, and we
502              should not use it.  */
503
504 #if defined(HAVE_GETC_UNLOCKED) && HAVE_DECL_GETC_UNLOCKED
505           c = getc_unlocked (stream);
506 #else
507           c = getc (stream);
508 #endif
509           if (c == EOF)
510             return EOF;
511         }
512
513       (*address)++;
514       buf[i] = c;
515     }
516
517   switch (encoding)
518     {
519     case 'S':
520     case 's':
521       r = buf[0];
522       break;
523     case 'b':
524       r = (buf[0] << 8) | buf[1];
525       break;
526     case 'l':
527       r = buf[0] | (buf[1] << 8);
528       break;
529     case 'B':
530       r = ((long) buf[0] << 24) | ((long) buf[1] << 16) |
531         ((long) buf[2] << 8) | buf[3];
532       break;
533     case 'L':
534       r = buf[0] | ((long) buf[1] << 8) | ((long) buf[2] << 16) |
535         ((long) buf[3] << 24);
536       break;
537     }
538
539   if (r == EOF)
540     return 0;
541
542   return r;
543 }
544 \f
545 /* Find the strings in file FILENAME, read from STREAM.
546    Assume that STREAM is positioned so that the next byte read
547    is at address ADDRESS in the file.
548    Stop reading at address STOP_POINT in the file, if nonzero.
549
550    If STREAM is NULL, do not read from it.
551    The caller can supply a buffer of characters
552    to be processed before the data in STREAM.
553    MAGIC is the address of the buffer and
554    MAGICCOUNT is how many characters are in it.
555    Those characters come at address ADDRESS and the data in STREAM follow.  */
556
557 static void
558 print_strings (const char *filename, FILE *stream, file_off address,
559                int stop_point, int magiccount, char *magic)
560 {
561   char *buf = (char *) xmalloc (sizeof (char) * (string_min + 1));
562
563   while (1)
564     {
565       file_off start;
566       int i;
567       long c;
568
569       /* See if the next `string_min' chars are all graphic chars.  */
570     tryline:
571       if (stop_point && address >= stop_point)
572         break;
573       start = address;
574       for (i = 0; i < string_min; i++)
575         {
576           c = get_char (stream, &address, &magiccount, &magic);
577           if (c == EOF)
578             return;
579           if (! STRING_ISGRAPHIC (c))
580             /* Found a non-graphic.  Try again starting with next char.  */
581             goto tryline;
582           buf[i] = c;
583         }
584
585       /* We found a run of `string_min' graphic characters.  Print up
586          to the next non-graphic character.  */
587
588       if (print_filenames)
589         printf ("%s: ", filename);
590       if (print_addresses)
591         switch (address_radix)
592           {
593           case 8:
594 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
595             if (sizeof (start) > sizeof (long))
596               printf ("%7Lo ", (unsigned long long) start);
597             else
598 #else
599 # if !BFD_HOST_64BIT_LONG
600             if (start != (unsigned long) start)
601               printf ("++%7lo ", (unsigned long) start);
602             else
603 # endif
604 #endif
605               printf ("%7lo ", (unsigned long) start);
606             break;
607
608           case 10:
609 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
610             if (sizeof (start) > sizeof (long))
611               printf ("%7Ld ", (unsigned long long) start);
612             else
613 #else
614 # if !BFD_HOST_64BIT_LONG
615             if (start != (unsigned long) start)
616               printf ("++%7ld ", (unsigned long) start);
617             else
618 # endif
619 #endif
620               printf ("%7ld ", (long) start);
621             break;
622
623           case 16:
624 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
625             if (sizeof (start) > sizeof (long))
626               printf ("%7Lx ", (unsigned long long) start);
627             else
628 #else
629 # if !BFD_HOST_64BIT_LONG
630             if (start != (unsigned long) start)
631               printf ("%lx%8.8lx ", (unsigned long) (start >> 32),
632                       (unsigned long) (start & 0xffffffff));
633             else
634 # endif
635 #endif
636               printf ("%7lx ", (unsigned long) start);
637             break;
638           }
639
640       buf[i] = '\0';
641       fputs (buf, stdout);
642
643       while (1)
644         {
645           c = get_char (stream, &address, &magiccount, &magic);
646           if (c == EOF)
647             break;
648           if (! STRING_ISGRAPHIC (c))
649             break;
650           putchar (c);
651         }
652
653       putchar ('\n');
654     }
655 }
656 \f
657 /* Parse string S as an integer, using decimal radix by default,
658    but allowing octal and hex numbers as in C.  */
659
660 static int
661 integer_arg (char *s)
662 {
663   int value;
664   int radix = 10;
665   char *p = s;
666   int c;
667
668   if (*p != '0')
669     radix = 10;
670   else if (*++p == 'x')
671     {
672       radix = 16;
673       p++;
674     }
675   else
676     radix = 8;
677
678   value = 0;
679   while (((c = *p++) >= '0' && c <= '9')
680          || (radix == 16 && (c & ~40) >= 'A' && (c & ~40) <= 'Z'))
681     {
682       value *= radix;
683       if (c >= '0' && c <= '9')
684         value += c - '0';
685       else
686         value += (c & ~40) - 'A';
687     }
688
689   if (c == 'b')
690     value *= 512;
691   else if (c == 'B')
692     value *= 1024;
693   else
694     p--;
695
696   if (*p)
697     fatal (_("invalid integer argument %s"), s);
698
699   return value;
700 }
701
702 static void
703 usage (FILE *stream, int status)
704 {
705   fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
706   fprintf (stream, _(" Display printable strings in [file(s)] (stdin by default)\n"));
707   fprintf (stream, _(" The options are:\n\
708   -a - --all                Scan the entire file, not just the data section\n\
709   -f --print-file-name      Print the name of the file before each string\n\
710   -n --bytes=[number]       Locate & print any NUL-terminated sequence of at\n\
711   -<number>                 least [number] characters (default 4).\n\
712   -t --radix={o,d,x}        Print the location of the string in base 8, 10 or 16\n\
713   -o                        An alias for --radix=o\n\
714   -T --target=<BFDNAME>     Specify the binary file format\n\
715   -e --encoding={s,S,b,l,B,L} Select character size and endianness:\n\
716                             s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit\n\
717   -h --help                 Display this information\n\
718   -v --version              Print the program's version number\n"));
719   list_supported_targets (program_name, stream);
720   if (status == 0)
721     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
722   exit (status);
723 }