[binutils.git] / binutils / strings.c

/* strings -- print the strings of printable characters in files
   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   2002, 2003, 2004 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */
\f
/* Usage: strings [options] file...

   Options:
   --all
   -a
   -		Do not scan only the initialized data section of object files.

   --print-file-name
   -f		Print the name of the file before each string.

   --bytes=min-len
   -n min-len
   -min-len	Print graphic char sequences, MIN-LEN or more bytes long,
		that are followed by a NUL or a newline.  Default is 4.

   --radix={o,x,d}
   -t {o,x,d}	Print the offset within the file before each string,
		in octal/hex/decimal.

   -o		Like -to.  (Some other implementations have -o like -to,
		others like -td.  We chose one arbitrarily.)

   --encoding={s,S,b,l,B,L}
   -e {s,S,b,l,B,L}
		Select character encoding: 7-bit-character, 8-bit-character,
		bigendian 16-bit, littleendian 16-bit, bigendian 32-bit,
		littleendian 32-bit.

   --target=BFDNAME
		Specify a non-default object file format.

   --help
   -h		Print the usage message on the standard output.

   --version
   -v		Print the program version number.

   Written by Richard Stallman <[email protected]>
   and David MacKenzie <[email protected]>.  */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "bfd.h"
#include <stdio.h>
#include "getopt.h"
#include <errno.h>
#include "bucomm.h"
#include "libiberty.h"
#include "safe-ctype.h"
#include <sys/stat.h>

/* Some platforms need to put stdin into binary mode, to read
    binary files.  */
#ifdef HAVE_SETMODE
#ifndef O_BINARY
#ifdef _O_BINARY
#define O_BINARY _O_BINARY
#define setmode _setmode
#else
#define O_BINARY 0
#endif
#endif
#if O_BINARY
#include <io.h>
#define SET_BINARY(f) do { if (!isatty (f)) setmode (f,O_BINARY); } while (0)
#endif
#endif

#define STRING_ISGRAPHIC(c) \
      (   (c) >= 0 \
       && (c) <= 255 \
       && ((c) == '\t' || ISPRINT (c) || (encoding == 'S' && (c) > 127)))

#ifndef errno
extern int errno;
#endif

/* The BFD section flags that identify an initialized data section.  */
#define DATA_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)

#ifdef HAVE_FOPEN64
typedef off64_t file_off;
#define file_open(s,m) fopen64(s, m)
#else
typedef off_t file_off;
#define file_open(s,m) fopen(s, m)
#endif
#ifdef HAVE_STAT64
typedef struct stat64 statbuf;
#define file_stat(f,s) stat64(f, s)
#else
typedef struct stat statbuf;
#define file_stat(f,s) stat(f, s)
#endif

/* Radix for printing addresses (must be 8, 10 or 16).  */
static int address_radix;

/* Minimum length of sequence of graphic chars to trigger output.  */
static int string_min;

/* TRUE means print address within file for each string.  */
static bfd_boolean print_addresses;

/* TRUE means print filename for each string.  */
static bfd_boolean print_filenames;

/* TRUE means for object files scan only the data section.  */
static bfd_boolean datasection_only;

/* TRUE if we found an initialized data section in the current file.  */
static bfd_boolean got_a_section;

/* The BFD object file format.  */
static char *target;

/* The character encoding format.  */
static char encoding;
static int encoding_bytes;

static struct option long_options[] =
{
  {"all", no_argument, NULL, 'a'},
  {"print-file-name", no_argument, NULL, 'f'},
  {"bytes", required_argument, NULL, 'n'},
  {"radix", required_argument, NULL, 't'},
  {"encoding", required_argument, NULL, 'e'},
  {"target", required_argument, NULL, 'T'},
  {"help", no_argument, NULL, 'h'},
  {"version", no_argument, NULL, 'v'},
  {NULL, 0, NULL, 0}
};

static void strings_a_section (bfd *, asection *, void *);
static bfd_boolean strings_object_file (const char *);
static bfd_boolean strings_file (char *file);
static int integer_arg (char *s);
static void print_strings (const char *, FILE *, file_off, int, int, char *);
static void usage (FILE *, int);
static long get_char (FILE *, file_off *, int *, char **);
\f
int main (int, char **);

int
main (int argc, char **argv)
{
  int optc;
  int exit_status = 0;
  bfd_boolean files_given = FALSE;

#if defined (HAVE_SETLOCALE)
  setlocale (LC_ALL, "");
#endif
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  program_name = argv[0];
  xmalloc_set_program_name (program_name);
  string_min = -1;
  print_addresses = FALSE;
  print_filenames = FALSE;
  datasection_only = TRUE;
  target = NULL;
  encoding = 's';

  while ((optc = getopt_long (argc, argv, "afhHn:ot:e:Vv0123456789",
			      long_options, (int *) 0)) != EOF)
    {
      switch (optc)
	{
	case 'a':
	  datasection_only = FALSE;
	  break;

	case 'f':
	  print_filenames = TRUE;
	  break;

	case 'H':
	case 'h':
	  usage (stdout, 0);

	case 'n':
	  string_min = integer_arg (optarg);
	  if (string_min < 1)
	    fatal (_("invalid number %s"), optarg);
	  break;

	case 'o':
	  print_addresses = TRUE;
	  address_radix = 8;
	  break;

	case 't':
	  print_addresses = TRUE;
	  if (optarg[1] != '\0')
	    usage (stderr, 1);
	  switch (optarg[0])
	    {
	    case 'o':
	      address_radix = 8;
	      break;

	    case 'd':
	      address_radix = 10;
	      break;

	    case 'x':
	      address_radix = 16;
	      break;

	    default:
	      usage (stderr, 1);
	    }
	  break;

	case 'T':
	  target = optarg;
	  break;

	case 'e':
	  if (optarg[1] != '\0')
	    usage (stderr, 1);
	  encoding = optarg[0];
	  break;

	case 'V':
	case 'v':
	  print_version ("strings");
	  break;

	case '?':
	  usage (stderr, 1);

	default:
	  if (string_min < 0)
	    string_min = optc - '0';
	  else
	    string_min = string_min * 10 + optc - '0';
	  break;
	}
    }

  if (string_min < 0)
    string_min = 4;

  switch (encoding)
    {
    case 'S':
    case 's':
      encoding_bytes = 1;
      break;
    case 'b':
    case 'l':
      encoding_bytes = 2;
      break;
    case 'B':
    case 'L':
      encoding_bytes = 4;
      break;
    default:
      usage (stderr, 1);
    }

  bfd_init ();
  set_default_bfd_target ();

  if (optind >= argc)
    {
      datasection_only = FALSE;
#ifdef SET_BINARY
      SET_BINARY (fileno (stdin));
#endif
      print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
      files_given = TRUE;
    }
  else
    {
      for (; optind < argc; ++optind)
	{
	  if (strcmp (argv[optind], "-") == 0)
	    datasection_only = FALSE;
	  else
	    {
	      files_given = TRUE;
	      exit_status |= strings_file (argv[optind]) == FALSE;
	    }
	}
    }

  if (!files_given)
    usage (stderr, 1);

  return (exit_status);
}
\f
/* Scan section SECT of the file ABFD, whose printable name is FILE.
   If it contains initialized data,
   set `got_a_section' and print the strings in it.  */

static void
strings_a_section (bfd *abfd, asection *sect, void *filearg)
{
  const char *file = (const char *) filearg;

  if ((sect->flags & DATA_FLAGS) == DATA_FLAGS)
    {
      bfd_size_type sz = bfd_get_section_size (sect);
      void *mem = xmalloc (sz);

      if (bfd_get_section_contents (abfd, sect, mem, (file_ptr) 0, sz))
	{
	  got_a_section = TRUE;
	  print_strings (file, (FILE *) NULL, sect->filepos, 0, sz, mem);
	}
      free (mem);
    }
}

/* Scan all of the sections in FILE, and print the strings
   in the initialized data section(s).

   Return TRUE if successful,
   FALSE if not (such as if FILE is not an object file).  */

static bfd_boolean
strings_object_file (const char *file)
{
  bfd *abfd = bfd_openr (file, target);

  if (abfd == NULL)
    /* Treat the file as a non-object file.  */
    return FALSE;

  /* This call is mainly for its side effect of reading in the sections.
     We follow the traditional behavior of `strings' in that we don't
     complain if we don't recognize a file to be an object file.  */
  if (!bfd_check_format (abfd, bfd_object))
    {
      bfd_close (abfd);
      return FALSE;
    }

  got_a_section = FALSE;
  bfd_map_over_sections (abfd, strings_a_section, (void *) file);

  if (!bfd_close (abfd))
    {
      bfd_nonfatal (file);
      return FALSE;
    }

  return got_a_section;
}

/* Print the strings in FILE.  Return TRUE if ok, FALSE if an error occurs.  */

static bfd_boolean
strings_file (char *file)
{
  statbuf st;

  if (file_stat (file, &st) < 0)
    {
      if (errno == ENOENT)
	non_fatal (_("'%s': No such file"), file);
      else
	non_fatal (_("Warning: could not locate '%s'.  reason: %s"),
		   file, strerror (errno));
      return FALSE;
    }

  /* If we weren't told to scan the whole file,
     try to open it as an object file and only look at
     initialized data sections.  If that fails, fall back to the
     whole file.  */
  if (!datasection_only || !strings_object_file (file))
    {
      FILE *stream;

      stream = file_open (file, FOPEN_RB);
      if (stream == NULL)
	{
	  fprintf (stderr, "%s: ", program_name);
	  perror (file);
	  return FALSE;
	}

      print_strings (file, stream, (file_off) 0, 0, 0, (char *) 0);

      if (fclose (stream) == EOF)
	{
	  fprintf (stderr, "%s: ", program_name);
	  perror (file);
	  return FALSE;
	}
    }

  return TRUE;
}
\f
/* Read the next character, return EOF if none available.
   Assume that STREAM is positioned so that the next byte read
   is at address ADDRESS in the file.

   If STREAM is NULL, do not read from it.
   The caller can supply a buffer of characters
   to be processed before the data in STREAM.
   MAGIC is the address of the buffer and
   MAGICCOUNT is how many characters are in it.  */

static long
get_char (FILE *stream, file_off *address, int *magiccount, char **magic)
{
  int c, i;
  long r = EOF;
  unsigned char buf[4];

  for (i = 0; i < encoding_bytes; i++)
    {
      if (*magiccount)
	{
	  (*magiccount)--;
	  c = *(*magic)++;
	}
      else
	{
	  if (stream == NULL)
	    return EOF;
#ifdef HAVE_GETC_UNLOCKED
	  c = getc_unlocked (stream);
#else
	  c = getc (stream);
#endif
	  if (c == EOF)
	    return EOF;
	}

      (*address)++;
      buf[i] = c;
    }

  switch (encoding)
    {
    case 'S':
    case 's':
      r = buf[0];
      break;
    case 'b':
      r = (buf[0] << 8) | buf[1];
      break;
    case 'l':
      r = buf[0] | (buf[1] << 8);
      break;
    case 'B':
      r = ((long) buf[0] << 24) | ((long) buf[1] << 16) |
	((long) buf[2] << 8) | buf[3];
      break;
    case 'L':
      r = buf[0] | ((long) buf[1] << 8) | ((long) buf[2] << 16) |
	((long) buf[3] << 24);
      break;
    }

  if (r == EOF)
    return 0;

  return r;
}
\f
/* Find the strings in file FILENAME, read from STREAM.
   Assume that STREAM is positioned so that the next byte read
   is at address ADDRESS in the file.
   Stop reading at address STOP_POINT in the file, if nonzero.

   If STREAM is NULL, do not read from it.
   The caller can supply a buffer of characters
   to be processed before the data in STREAM.
   MAGIC is the address of the buffer and
   MAGICCOUNT is how many characters are in it.
   Those characters come at address ADDRESS and the data in STREAM follow.  */

static void
print_strings (const char *filename, FILE *stream, file_off address,
	       int stop_point, int magiccount, char *magic)
{
  char *buf = (char *) xmalloc (sizeof (char) * (string_min + 1));

  while (1)
    {
      file_off start;
      int i;
      long c;

      /* See if the next `string_min' chars are all graphic chars.  */
    tryline:
      if (stop_point && address >= stop_point)
	break;
      start = address;
      for (i = 0; i < string_min; i++)
	{
	  c = get_char (stream, &address, &magiccount, &magic);
	  if (c == EOF)
	    return;
	  if (! STRING_ISGRAPHIC (c))
	    /* Found a non-graphic.  Try again starting with next char.  */
	    goto tryline;
	  buf[i] = c;
	}

      /* We found a run of `string_min' graphic characters.  Print up
	 to the next non-graphic character.  */

      if (print_filenames)
	printf ("%s: ", filename);
      if (print_addresses)
	switch (address_radix)
	  {
	  case 8:
#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
	    if (sizeof (start) > sizeof (long))
	      printf ("%7Lo ", (unsigned long long) start);
	    else
#else
# if !BFD_HOST_64BIT_LONG
	    if (start != (unsigned long) start)
	      printf ("++%7lo ", (unsigned long) start);
	    else
# endif
#endif
	      printf ("%7lo ", (unsigned long) start);
	    break;

	  case 10:
#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
	    if (sizeof (start) > sizeof (long))
	      printf ("%7Ld ", (unsigned long long) start);
	    else
#else
# if !BFD_HOST_64BIT_LONG
	    if (start != (unsigned long) start)
	      printf ("++%7ld ", (unsigned long) start);
	    else
# endif
#endif
	      printf ("%7ld ", (long) start);
	    break;

	  case 16:
#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
	    if (sizeof (start) > sizeof (long))
	      printf ("%7Lx ", (unsigned long long) start);
	    else
#else
# if !BFD_HOST_64BIT_LONG
	    if (start != (unsigned long) start)
	      printf ("%lx%8.8lx ", (unsigned long) (start >> 32),
		      (unsigned long) (start & 0xffffffff));
	    else
# endif
#endif
	      printf ("%7lx ", (unsigned long) start);
	    break;
	  }

      buf[i] = '\0';
      fputs (buf, stdout);

      while (1)
	{
	  c = get_char (stream, &address, &magiccount, &magic);
	  if (c == EOF)
	    break;
	  if (! STRING_ISGRAPHIC (c))
	    break;
	  putchar (c);
	}

      putchar ('\n');
    }
}
\f
/* Parse string S as an integer, using decimal radix by default,
   but allowing octal and hex numbers as in C.  */

static int
integer_arg (char *s)
{
  int value;
  int radix = 10;
  char *p = s;
  int c;

  if (*p != '0')
    radix = 10;
  else if (*++p == 'x')
    {
      radix = 16;
      p++;
    }
  else
    radix = 8;

  value = 0;
  while (((c = *p++) >= '0' && c <= '9')
	 || (radix == 16 && (c & ~40) >= 'A' && (c & ~40) <= 'Z'))
    {
      value *= radix;
      if (c >= '0' && c <= '9')
	value += c - '0';
      else
	value += (c & ~40) - 'A';
    }

  if (c == 'b')
    value *= 512;
  else if (c == 'B')
    value *= 1024;
  else
    p--;

  if (*p)
    fatal (_("invalid integer argument %s"), s);

  return value;
}

static void
usage (FILE *stream, int status)
{
  fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
  fprintf (stream, _(" Display printable strings in [file(s)] (stdin by default)\n"));
  fprintf (stream, _(" The options are:\n\
  -a - --all                Scan the entire file, not just the data section\n\
  -f --print-file-name      Print the name of the file before each string\n\
  -n --bytes=[number]       Locate & print any NUL-terminated sequence of at\n\
  -<number>                 least [number] characters (default 4).\n\
  -t --radix={o,d,x}        Print the location of the string in base 8, 10 or 16\n\
  -o                        An alias for --radix=o\n\
  -T --target=<BFDNAME>     Specify the binary file format\n\
  -e --encoding={s,S,b,l,B,L} Select character size and endianness:\n\
                            s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit\n\
  -h --help                 Display this information\n\
  -v --version              Print the program's version number\n"));
  list_supported_targets (program_name, stream);
  if (status == 0)
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
  exit (status);
}
Commit	Line	Data
252b5132	1	/* strings -- print the strings of printable characters in files
8b53311e	2	Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
e9f87780	3	2002, 2003, 2004 Free Software Foundation, Inc.
252b5132 RH	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., 59 Temple Place - Suite 330, Boston, MA
	18	02111-1307, 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
8745eafa NC	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.
d132876a	47
252b5132 RH	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 <[email protected]>
	58	and David MacKenzie <[email protected]>. */
	59
cedd9a58 JJ	60	#ifdef HAVE_CONFIG_H
	61	#include "config.h"
	62	#endif
252b5132 RH	63	#include "bfd.h"
252b5132 RH	64	#include <stdio.h>
e9792343	65	#include "getopt.h"
252b5132 RH	66	#include <errno.h>
	67	#include "bucomm.h"
	68	#include "libiberty.h"
3882b010	69	#include "safe-ctype.h"
fb608b92	70	#include <sys/stat.h>
252b5132	71
5af11cab AM	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>
8745eafa	85	#define SET_BINARY(f) do { if (!isatty (f)) setmode (f,O_BINARY); } while (0)
5af11cab AM	86	#endif
	87	#endif
	88
8745eafa NC	89	#define STRING_ISGRAPHIC(c) \
	90	( (c) >= 0 \
	91	&& (c) <= 255 \
	92	&& ((c) == '\t' \|\| ISPRINT (c) \|\| (encoding == 'S' && (c) > 127)))
252b5132 RH	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
cedd9a58 JJ	101	#ifdef HAVE_FOPEN64
cedd9a58 JJ	102	typedef off64_t file_off;
8745eafa	103	#define file_open(s,m) fopen64(s, m)
cedd9a58 JJ	104	#else
cedd9a58 JJ	105	typedef off_t file_off;
8745eafa	106	#define file_open(s,m) fopen(s, m)
cedd9a58	107	#endif
fb5b5478 JJ	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
cedd9a58	115
252b5132 RH	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
b34976b6 AM	122	/* TRUE means print address within file for each string. */
b34976b6 AM	123	static bfd_boolean print_addresses;
252b5132	124
b34976b6 AM	125	/* TRUE means print filename for each string. */
b34976b6 AM	126	static bfd_boolean print_filenames;
252b5132	127
b34976b6 AM	128	/* TRUE means for object files scan only the data section. */
b34976b6 AM	129	static bfd_boolean datasection_only;
252b5132	130
b34976b6 AM	131	/* TRUE if we found an initialized data section in the current file. */
b34976b6 AM	132	static bfd_boolean got_a_section;
252b5132 RH	133
	134	/* The BFD object file format. */
	135	static char *target;
	136
d132876a NC	137	/* The character encoding format. */
	138	static char encoding;
	139	static int encoding_bytes;
	140
252b5132 RH	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'},
d132876a	147	{"encoding", required_argument, NULL, 'e'},
252b5132 RH	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
2da42df6 AJ	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 *);
252b5132	161	\f
2da42df6	162	int main (int, char **);
65de42c0	163
252b5132	164	int
2da42df6	165	main (int argc, char **argv)
252b5132 RH	166	{
	167	int optc;
	168	int exit_status = 0;
b34976b6	169	bfd_boolean files_given = FALSE;
252b5132	170
3882b010	171	#if defined (HAVE_SETLOCALE)
1c529ca6	172	setlocale (LC_ALL, "");
252b5132 RH	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;
b34976b6 AM	180	print_addresses = FALSE;
	181	print_filenames = FALSE;
	182	datasection_only = TRUE;
252b5132	183	target = NULL;
d132876a	184	encoding = 's';
252b5132	185
8b53311e	186	while ((optc = getopt_long (argc, argv, "afhHn:ot:e:Vv0123456789",
252b5132 RH	187	long_options, (int *) 0)) != EOF)
	188	{
	189	switch (optc)
	190	{
	191	case 'a':
b34976b6	192	datasection_only = FALSE;
252b5132 RH	193	break;
	194
	195	case 'f':
b34976b6	196	print_filenames = TRUE;
252b5132 RH	197	break;
252b5132 RH	198
8b53311e	199	case 'H':
252b5132 RH	200	case 'h':
	201	usage (stdout, 0);
	202
	203	case 'n':
	204	string_min = integer_arg (optarg);
	205	if (string_min < 1)
8745eafa	206	fatal (_("invalid number %s"), optarg);
252b5132 RH	207	break;
	208
	209	case 'o':
b34976b6	210	print_addresses = TRUE;
252b5132 RH	211	address_radix = 8;
	212	break;
	213
	214	case 't':
b34976b6	215	print_addresses = TRUE;
252b5132 RH	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
d132876a NC	241	case 'e':
	242	if (optarg[1] != '\0')
	243	usage (stderr, 1);
	244	encoding = optarg[0];
	245	break;
	246
8b53311e	247	case 'V':
252b5132 RH	248	case 'v':
	249	print_version ("strings");
	250	break;
	251
	252	case '?':
	253	usage (stderr, 1);
	254
	255	default:
	256	if (string_min < 0)
221f77a9	257	string_min = optc - '0';
252b5132 RH	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
d132876a NC	267	switch (encoding)
d132876a NC	268	{
8745eafa	269	case 'S':
d132876a NC	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
252b5132 RH	285	bfd_init ();
	286	set_default_bfd_target ();
	287
	288	if (optind >= argc)
	289	{
b34976b6	290	datasection_only = FALSE;
5af11cab AM	291	#ifdef SET_BINARY
	292	SET_BINARY (fileno (stdin));
	293	#endif
252b5132	294	print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
b34976b6	295	files_given = TRUE;
252b5132 RH	296	}
	297	else
	298	{
	299	for (; optind < argc; ++optind)
	300	{
	301	if (strcmp (argv[optind], "-") == 0)
b34976b6	302	datasection_only = FALSE;
252b5132 RH	303	else
252b5132 RH	304	{
b34976b6 AM	305	files_given = TRUE;
b34976b6 AM	306	exit_status \|= strings_file (argv[optind]) == FALSE;
252b5132 RH	307	}
	308	}
	309	}
	310
b34976b6	311	if (!files_given)
252b5132 RH	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
2da42df6	322	strings_a_section (bfd abfd, asection sect, void *filearg)
252b5132 RH	323	{
	324	const char file = (const char ) filearg;
	325
	326	if ((sect->flags & DATA_FLAGS) == DATA_FLAGS)
	327	{
135dfb4a	328	bfd_size_type sz = bfd_get_section_size (sect);
2da42df6	329	void *mem = xmalloc (sz);
8745eafa	330
252b5132 RH	331	if (bfd_get_section_contents (abfd, sect, mem, (file_ptr) 0, sz))
252b5132 RH	332	{
b34976b6	333	got_a_section = TRUE;
252b5132 RH	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
b34976b6 AM	343	Return TRUE if successful,
b34976b6 AM	344	FALSE if not (such as if FILE is not an object file). */
252b5132	345
b34976b6	346	static bfd_boolean
2da42df6	347	strings_object_file (const char *file)
252b5132 RH	348	{
	349	bfd *abfd = bfd_openr (file, target);
	350
	351	if (abfd == NULL)
8745eafa NC	352	/* Treat the file as a non-object file. */
8745eafa NC	353	return FALSE;
252b5132 RH	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. */
b34976b6	358	if (!bfd_check_format (abfd, bfd_object))
252b5132 RH	359	{
252b5132 RH	360	bfd_close (abfd);
b34976b6	361	return FALSE;
252b5132 RH	362	}
252b5132 RH	363
b34976b6	364	got_a_section = FALSE;
2da42df6	365	bfd_map_over_sections (abfd, strings_a_section, (void *) file);
252b5132 RH	366
	367	if (!bfd_close (abfd))
	368	{
	369	bfd_nonfatal (file);
b34976b6	370	return FALSE;
252b5132 RH	371	}
	372
	373	return got_a_section;
	374	}
	375
b34976b6	376	/* Print the strings in FILE. Return TRUE if ok, FALSE if an error occurs. */
252b5132	377
b34976b6	378	static bfd_boolean
2da42df6	379	strings_file (char *file)
252b5132	380	{
fb5b5478 JJ	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	}
f24ddbdd	392
252b5132 RH	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
cedd9a58	401	stream = file_open (file, FOPEN_RB);
252b5132 RH	402	if (stream == NULL)
	403	{
	404	fprintf (stderr, "%s: ", program_name);
	405	perror (file);
b34976b6	406	return FALSE;
252b5132 RH	407	}
252b5132 RH	408
cedd9a58	409	print_strings (file, stream, (file_off) 0, 0, 0, (char *) 0);
252b5132 RH	410
	411	if (fclose (stream) == EOF)
	412	{
	413	fprintf (stderr, "%s: ", program_name);
	414	perror (file);
b34976b6	415	return FALSE;
252b5132 RH	416	}
	417	}
	418
b34976b6	419	return TRUE;
252b5132 RH	420	}
252b5132 RH	421	\f
d132876a NC	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
2da42df6	433	get_char (FILE stream, file_off address, int magiccount, char *magic)
d132876a NC	434	{
d132876a NC	435	int c, i;
956cd1d6	436	long r = EOF;
d132876a NC	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;
cedd9a58 JJ	450	#ifdef HAVE_GETC_UNLOCKED
	451	c = getc_unlocked (stream);
	452	#else
d132876a	453	c = getc (stream);
cedd9a58	454	#endif
d132876a NC	455	if (c == EOF)
	456	return EOF;
	457	}
	458
	459	(*address)++;
	460	buf[i] = c;
	461	}
	462
	463	switch (encoding)
	464	{
8745eafa	465	case 'S':
d132876a NC	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
252b5132 RH	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
2da42df6 AJ	504	print_strings (const char filename, FILE stream, file_off address,
2da42df6 AJ	505	int stop_point, int magiccount, char *magic)
252b5132	506	{
d132876a	507	char buf = (char ) xmalloc (sizeof (char) * (string_min + 1));
252b5132 RH	508
	509	while (1)
	510	{
cedd9a58	511	file_off start;
252b5132	512	int i;
d132876a	513	long c;
252b5132 RH	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	{
d132876a NC	522	c = get_char (stream, &address, &magiccount, &magic);
	523	if (c == EOF)
	524	return;
8745eafa	525	if (! STRING_ISGRAPHIC (c))
252b5132 RH	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
e9f87780	532	to the next non-graphic character. */
252b5132 RH	533
	534	if (print_filenames)
	535	printf ("%s: ", filename);
	536	if (print_addresses)
	537	switch (address_radix)
	538	{
	539	case 8:
cedd9a58 JJ	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);
252b5132 RH	552	break;
	553
	554	case 10:
cedd9a58 JJ	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);
252b5132 RH	567	break;
	568
	569	case 16:
cedd9a58 JJ	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)
e9f87780 AM	577	printf ("%lx%8.8lx ", (unsigned long) (start >> 32),
e9f87780 AM	578	(unsigned long) (start & 0xffffffff));
cedd9a58 JJ	579	else
	580	# endif
	581	#endif
	582	printf ("%7lx ", (unsigned long) start);
252b5132 RH	583	break;
	584	}
	585
	586	buf[i] = '\0';
	587	fputs (buf, stdout);
	588
	589	while (1)
	590	{
d132876a NC	591	c = get_char (stream, &address, &magiccount, &magic);
	592	if (c == EOF)
	593	break;
8745eafa	594	if (! STRING_ISGRAPHIC (c))
252b5132 RH	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
2da42df6	607	integer_arg (char *s)
252b5132 RH	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)
8745eafa NC	643	fatal (_("invalid integer argument %s"), s);
8745eafa NC	644
252b5132 RH	645	return value;
	646	}
	647
	648	static void
2da42df6	649	usage (FILE *stream, int status)
252b5132	650	{
8b53311e NC	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\
d412a550	658	-t --radix={o,d,x} Print the location of the string in base 8, 10 or 16\n\
8b53311e NC	659	-o An alias for --radix=o\n\
8b53311e NC	660	-T --target=<BFDNAME> Specify the binary file format\n\
8745eafa NC	661	-e --encoding={s,S,b,l,B,L} Select character size and endianness:\n\
8745eafa NC	662	s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit\n\
8b53311e NC	663	-h --help Display this information\n\
8b53311e NC	664	-v --version Print the program's version number\n"));
252b5132 RH	665	list_supported_targets (program_name, stream);
252b5132 RH	666	if (status == 0)
8ad3436c	667	fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 RH	668	exit (status);
252b5132 RH	669	}