* strings.c: Include config.h before bfd.h.
[binutils.git] / binutils / strings.c
blob89e322bc8e59bd65bafa066a9d169a0fe0a1ba6a
1 /* strings -- print the strings of printable characters in files
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
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.
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.
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., 59 Temple Place - Suite 330, Boston, MA
18 02111-1307, USA. */
20 /* Usage: strings [options] file...
22 Options:
23 --all
25 - Do not scan only the initialized data section of object files.
27 --print-file-name
28 -f Print the name of the file before each string.
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.
35 --radix={o,x,d}
36 -t {o,x,d} Print the offset within the file before each string,
37 in octal/hex/decimal.
39 -o Like -to. (Some other implementations have -o like -to,
40 others like -td. We chose one arbitrarily.)
42 --encoding={s,b,l,B,L}
43 -e {s,b,l,B,L}
44 Select character encoding: single-byte, bigendian 16-bit,
45 littleendian 16-bit, bigendian 32-bit, littleendian 32-bit
47 --target=BFDNAME
48 Specify a non-default object file format.
50 --help
51 -h Print the usage message on the standard output.
53 --version
54 -v Print the program version number.
56 Written by Richard Stallman <rms@gnu.ai.mit.edu>
57 and David MacKenzie <djm@gnu.ai.mit.edu>. */
59 #ifdef HAVE_CONFIG_H
60 #include "config.h"
61 #endif
62 #include "bfd.h"
63 #include <stdio.h>
64 #include <getopt.h>
65 #include <errno.h>
66 #include "bucomm.h"
67 #include "libiberty.h"
68 #include "safe-ctype.h"
70 /* Some platforms need to put stdin into binary mode, to read
71 binary files. */
72 #ifdef HAVE_SETMODE
73 #ifndef O_BINARY
74 #ifdef _O_BINARY
75 #define O_BINARY _O_BINARY
76 #define setmode _setmode
77 #else
78 #define O_BINARY 0
79 #endif
80 #endif
81 #if O_BINARY
82 #include <io.h>
83 #define SET_BINARY(f) do { if (!isatty(f)) setmode(f,O_BINARY); } while (0)
84 #endif
85 #endif
87 #define isgraphic(c) (ISPRINT (c) || (c) == '\t')
89 #ifndef errno
90 extern int errno;
91 #endif
93 /* The BFD section flags that identify an initialized data section. */
94 #define DATA_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)
96 #ifdef HAVE_FOPEN64
97 typedef off64_t file_off;
98 #define file_open(s,m) fopen64(s,m)
99 #else
100 typedef off_t file_off;
101 #define file_open(s,m) fopen(s,m)
102 #endif
104 /* Radix for printing addresses (must be 8, 10 or 16). */
105 static int address_radix;
107 /* Minimum length of sequence of graphic chars to trigger output. */
108 static int string_min;
110 /* true means print address within file for each string. */
111 static boolean print_addresses;
113 /* true means print filename for each string. */
114 static boolean print_filenames;
116 /* true means for object files scan only the data section. */
117 static boolean datasection_only;
119 /* true if we found an initialized data section in the current file. */
120 static boolean got_a_section;
122 /* The BFD object file format. */
123 static char *target;
125 /* The character encoding format. */
126 static char encoding;
127 static int encoding_bytes;
129 static struct option long_options[] =
131 {"all", no_argument, NULL, 'a'},
132 {"print-file-name", no_argument, NULL, 'f'},
133 {"bytes", required_argument, NULL, 'n'},
134 {"radix", required_argument, NULL, 't'},
135 {"encoding", required_argument, NULL, 'e'},
136 {"target", required_argument, NULL, 'T'},
137 {"help", no_argument, NULL, 'h'},
138 {"version", no_argument, NULL, 'v'},
139 {NULL, 0, NULL, 0}
142 static void strings_a_section PARAMS ((bfd *, asection *, PTR));
143 static boolean strings_object_file PARAMS ((const char *));
144 static boolean strings_file PARAMS ((char *file));
145 static int integer_arg PARAMS ((char *s));
146 static void print_strings PARAMS ((const char *filename, FILE *stream,
147 file_off address, int stop_point,
148 int magiccount, char *magic));
149 static void usage PARAMS ((FILE *stream, int status));
150 static long get_char PARAMS ((FILE *stream, file_off *address,
151 int *magiccount, char **magic));
154 main (argc, argv)
155 int argc;
156 char **argv;
158 int optc;
159 int exit_status = 0;
160 boolean files_given = false;
162 #if defined (HAVE_SETLOCALE)
163 setlocale (LC_ALL, "");
164 #endif
165 bindtextdomain (PACKAGE, LOCALEDIR);
166 textdomain (PACKAGE);
168 program_name = argv[0];
169 xmalloc_set_program_name (program_name);
170 string_min = -1;
171 print_addresses = false;
172 print_filenames = false;
173 datasection_only = true;
174 target = NULL;
175 encoding = 's';
177 while ((optc = getopt_long (argc, argv, "afn:ot:e:v0123456789",
178 long_options, (int *) 0)) != EOF)
180 switch (optc)
182 case 'a':
183 datasection_only = false;
184 break;
186 case 'f':
187 print_filenames = true;
188 break;
190 case 'h':
191 usage (stdout, 0);
193 case 'n':
194 string_min = integer_arg (optarg);
195 if (string_min < 1)
197 fatal (_("invalid number %s"), optarg);
199 break;
201 case 'o':
202 print_addresses = true;
203 address_radix = 8;
204 break;
206 case 't':
207 print_addresses = true;
208 if (optarg[1] != '\0')
209 usage (stderr, 1);
210 switch (optarg[0])
212 case 'o':
213 address_radix = 8;
214 break;
216 case 'd':
217 address_radix = 10;
218 break;
220 case 'x':
221 address_radix = 16;
222 break;
224 default:
225 usage (stderr, 1);
227 break;
229 case 'T':
230 target = optarg;
231 break;
233 case 'e':
234 if (optarg[1] != '\0')
235 usage (stderr, 1);
236 encoding = optarg[0];
237 break;
239 case 'v':
240 print_version ("strings");
241 break;
243 case '?':
244 usage (stderr, 1);
246 default:
247 if (string_min < 0)
248 string_min = optc - '0';
249 else
250 string_min = string_min * 10 + optc - '0';
251 break;
255 if (string_min < 0)
256 string_min = 4;
258 switch (encoding)
260 case 's':
261 encoding_bytes = 1;
262 break;
263 case 'b':
264 case 'l':
265 encoding_bytes = 2;
266 break;
267 case 'B':
268 case 'L':
269 encoding_bytes = 4;
270 break;
271 default:
272 usage (stderr, 1);
275 bfd_init ();
276 set_default_bfd_target ();
278 if (optind >= argc)
280 datasection_only = false;
281 #ifdef SET_BINARY
282 SET_BINARY (fileno (stdin));
283 #endif
284 print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
285 files_given = true;
287 else
289 for (; optind < argc; ++optind)
291 if (strcmp (argv[optind], "-") == 0)
292 datasection_only = false;
293 else
295 files_given = true;
296 exit_status |= (strings_file (argv[optind]) == false);
301 if (files_given == false)
302 usage (stderr, 1);
304 return (exit_status);
307 /* Scan section SECT of the file ABFD, whose printable name is FILE.
308 If it contains initialized data,
309 set `got_a_section' and print the strings in it. */
311 static void
312 strings_a_section (abfd, sect, filearg)
313 bfd *abfd;
314 asection *sect;
315 PTR filearg;
317 const char *file = (const char *) filearg;
319 if ((sect->flags & DATA_FLAGS) == DATA_FLAGS)
321 bfd_size_type sz = bfd_get_section_size_before_reloc (sect);
322 PTR mem = xmalloc (sz);
323 if (bfd_get_section_contents (abfd, sect, mem, (file_ptr) 0, sz))
325 got_a_section = true;
326 print_strings (file, (FILE *) NULL, sect->filepos, 0, sz, mem);
328 free (mem);
332 /* Scan all of the sections in FILE, and print the strings
333 in the initialized data section(s).
335 Return true if successful,
336 false if not (such as if FILE is not an object file). */
338 static boolean
339 strings_object_file (file)
340 const char *file;
342 bfd *abfd = bfd_openr (file, target);
344 if (abfd == NULL)
346 /* Treat the file as a non-object file. */
347 return false;
350 /* This call is mainly for its side effect of reading in the sections.
351 We follow the traditional behavior of `strings' in that we don't
352 complain if we don't recognize a file to be an object file. */
353 if (bfd_check_format (abfd, bfd_object) == false)
355 bfd_close (abfd);
356 return false;
359 got_a_section = false;
360 bfd_map_over_sections (abfd, strings_a_section, (PTR) file);
362 if (!bfd_close (abfd))
364 bfd_nonfatal (file);
365 return false;
368 return got_a_section;
371 /* Print the strings in FILE. Return true if ok, false if an error occurs. */
373 static boolean
374 strings_file (file)
375 char *file;
377 /* If we weren't told to scan the whole file,
378 try to open it as an object file and only look at
379 initialized data sections. If that fails, fall back to the
380 whole file. */
381 if (!datasection_only || !strings_object_file (file))
383 FILE *stream;
385 stream = file_open (file, FOPEN_RB);
386 if (stream == NULL)
388 fprintf (stderr, "%s: ", program_name);
389 perror (file);
390 return false;
393 print_strings (file, stream, (file_off) 0, 0, 0, (char *) 0);
395 if (fclose (stream) == EOF)
397 fprintf (stderr, "%s: ", program_name);
398 perror (file);
399 return false;
403 return true;
406 /* Read the next character, return EOF if none available.
407 Assume that STREAM is positioned so that the next byte read
408 is at address ADDRESS in the file.
410 If STREAM is NULL, do not read from it.
411 The caller can supply a buffer of characters
412 to be processed before the data in STREAM.
413 MAGIC is the address of the buffer and
414 MAGICCOUNT is how many characters are in it. */
416 static long
417 get_char (stream, address, magiccount, magic)
418 FILE *stream;
419 file_off *address;
420 int *magiccount;
421 char **magic;
423 int c, i;
424 long r;
425 unsigned char buf[4];
427 for (i = 0; i < encoding_bytes; i++)
429 if (*magiccount)
431 (*magiccount)--;
432 c = *(*magic)++;
434 else
436 if (stream == NULL)
437 return EOF;
438 #ifdef HAVE_GETC_UNLOCKED
439 c = getc_unlocked (stream);
440 #else
441 c = getc (stream);
442 #endif
443 if (c == EOF)
444 return EOF;
447 (*address)++;
448 buf[i] = c;
451 switch (encoding)
453 case 's':
454 r = buf[0];
455 break;
456 case 'b':
457 r = (buf[0] << 8) | buf[1];
458 break;
459 case 'l':
460 r = buf[0] | (buf[1] << 8);
461 break;
462 case 'B':
463 r = ((long) buf[0] << 24) | ((long) buf[1] << 16) |
464 ((long) buf[2] << 8) | buf[3];
465 break;
466 case 'L':
467 r = buf[0] | ((long) buf[1] << 8) | ((long) buf[2] << 16) |
468 ((long) buf[3] << 24);
469 break;
472 if (r == EOF)
473 return 0;
475 return r;
478 /* Find the strings in file FILENAME, read from STREAM.
479 Assume that STREAM is positioned so that the next byte read
480 is at address ADDRESS in the file.
481 Stop reading at address STOP_POINT in the file, if nonzero.
483 If STREAM is NULL, do not read from it.
484 The caller can supply a buffer of characters
485 to be processed before the data in STREAM.
486 MAGIC is the address of the buffer and
487 MAGICCOUNT is how many characters are in it.
488 Those characters come at address ADDRESS and the data in STREAM follow. */
490 static void
491 print_strings (filename, stream, address, stop_point, magiccount, magic)
492 const char *filename;
493 FILE *stream;
494 file_off address;
495 int stop_point;
496 int magiccount;
497 char *magic;
499 char *buf = (char *) xmalloc (sizeof (char) * (string_min + 1));
501 while (1)
503 file_off start;
504 int i;
505 long c;
507 /* See if the next `string_min' chars are all graphic chars. */
508 tryline:
509 if (stop_point && address >= stop_point)
510 break;
511 start = address;
512 for (i = 0; i < string_min; i++)
514 c = get_char (stream, &address, &magiccount, &magic);
515 if (c == EOF)
516 return;
517 if (c > 255 || c < 0 || !isgraphic (c))
518 /* Found a non-graphic. Try again starting with next char. */
519 goto tryline;
520 buf[i] = c;
523 /* We found a run of `string_min' graphic characters. Print up
524 to the next non-graphic character. */
526 if (print_filenames)
527 printf ("%s: ", filename);
528 if (print_addresses)
529 switch (address_radix)
531 case 8:
532 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
533 if (sizeof (start) > sizeof (long))
534 printf ("%7Lo ", (unsigned long long) start);
535 else
536 #else
537 # if !BFD_HOST_64BIT_LONG
538 if (start != (unsigned long) start)
539 printf ("++%7lo ", (unsigned long) start);
540 else
541 # endif
542 #endif
543 printf ("%7lo ", (unsigned long) start);
544 break;
546 case 10:
547 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
548 if (sizeof (start) > sizeof (long))
549 printf ("%7Ld ", (unsigned long long) start);
550 else
551 #else
552 # if !BFD_HOST_64BIT_LONG
553 if (start != (unsigned long) start)
554 printf ("++%7ld ", (unsigned long) start);
555 else
556 # endif
557 #endif
558 printf ("%7ld ", (long) start);
559 break;
561 case 16:
562 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
563 if (sizeof (start) > sizeof (long))
564 printf ("%7Lx ", (unsigned long long) start);
565 else
566 #else
567 # if !BFD_HOST_64BIT_LONG
568 if (start != (unsigned long) start)
569 printf ("%lx%8.8lx ", start >> 32, start & 0xffffffff);
570 else
571 # endif
572 #endif
573 printf ("%7lx ", (unsigned long) start);
574 break;
577 buf[i] = '\0';
578 fputs (buf, stdout);
580 while (1)
582 c = get_char (stream, &address, &magiccount, &magic);
583 if (c == EOF)
584 break;
585 if (c > 255 || c < 0 || !isgraphic (c))
586 break;
587 putchar (c);
590 putchar ('\n');
594 /* Parse string S as an integer, using decimal radix by default,
595 but allowing octal and hex numbers as in C. */
597 static int
598 integer_arg (s)
599 char *s;
601 int value;
602 int radix = 10;
603 char *p = s;
604 int c;
606 if (*p != '0')
607 radix = 10;
608 else if (*++p == 'x')
610 radix = 16;
611 p++;
613 else
614 radix = 8;
616 value = 0;
617 while (((c = *p++) >= '0' && c <= '9')
618 || (radix == 16 && (c & ~40) >= 'A' && (c & ~40) <= 'Z'))
620 value *= radix;
621 if (c >= '0' && c <= '9')
622 value += c - '0';
623 else
624 value += (c & ~40) - 'A';
627 if (c == 'b')
628 value *= 512;
629 else if (c == 'B')
630 value *= 1024;
631 else
632 p--;
634 if (*p)
636 fatal (_("invalid integer argument %s"), s);
638 return value;
641 static void
642 usage (stream, status)
643 FILE *stream;
644 int status;
646 fprintf (stream, _("\
647 Usage: %s [-afov] [-n min-len] [-min-len] [-t {o,x,d}] [-e {s,b,l,B,L}]\n\
648 [-] [--all] [--print-file-name] [--bytes=min-len] [--radix={o,x,d}]\n\
649 [--target=bfdname] [--encoding {s,b,l,B,L}] [--help] [--version] file...\n"),
650 program_name);
651 list_supported_targets (program_name, stream);
652 if (status == 0)
653 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
654 exit (status);