Another windres snapshot. Can now read the COFF resources directory,

although it doesn't yet parse out the binary format.

1 files changed, 342 insertions, 0 deletions

diff --git a/binutils/rescoff.c b/binutils/rescoff.c
new file mode 100644
index 0000000..65df9bf
--- /dev/null
+++ b/binutils/rescoff.c
@@ -0,0 +1,342 @@
+/* resrc.c -- read and write Windows rc files.
+   Copyright 1997 Free Software Foundation, Inc.
+   Written by Ian Lance Taylor, Cygnus Support.
+
+   This file is part of GNU Binutils.
+
+   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 of the License, 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.  */
+
+/* This file contains function that read and write Windows resources
+   in COFF files.  */
+
+#include "bfd.h"
+#include "bucomm.h"
+#include "libiberty.h"
+#include "windres.h"
+
+/* In order to use the address of a resource data entry, we need to
+   get the image base of the file.  Right now we extract it from
+   internal BFD information.  FIXME.  */
+
+#include "coff/internal.h"
+#include "libcoff.h"
+
+/* Information we extract from the file.  */
+
+struct coff_file_info
+{
+  /* File name.  */
+  const char *filename;
+  /* Data read from the file.  */
+  const bfd_byte *data;
+  /* End of data read from file.  */
+  const bfd_byte *data_end;
+  /* Address of the resource section minus the image base of the file.  */
+  bfd_vma secaddr;
+  /* Non-zero if the file is big endian.  */
+  int big_endian;
+};
+
+/* A resource directory table in a COFF file.  */
+
+struct extern_res_directory
+{
+  /* Characteristics.  */
+  bfd_byte characteristics[4];
+  /* Time stamp.  */
+  bfd_byte time[4];
+  /* Major version number.  */
+  bfd_byte major[2];
+  /* Minor version number.  */
+  bfd_byte minor[2];
+  /* Number of named directory entries.  */
+  bfd_byte name_count[2];
+  /* Number of directory entries with IDs.  */
+  bfd_byte id_count[2];
+};
+
+/* A resource directory entry in a COFF file.  */
+
+struct extern_res_entry
+{
+  /* Name or ID.  */
+  bfd_byte name[4];
+  /* Address of resource entry or subdirectory.  */
+  bfd_byte rva[4];
+};
+
+/* A resource data entry in a COFF file.  */
+
+struct extern_res_data
+{
+  /* Address of resource data.  This is apparently a file relative
+     address, rather than a section offset.  */
+  bfd_byte rva[4];
+  /* Size of resource data.  */
+  bfd_byte size[4];
+  /* Code page.  */
+  bfd_byte codepage[4];
+  /* Reserved.  */
+  bfd_byte reserved[4];
+};
+
+/* Macros to swap in values.  */
+
+#define get_16(fi, s) ((fi)->big_endian ? bfd_getb16 (s) : bfd_getl16 (s))
+#define get_32(fi, s) ((fi)->big_endian ? bfd_getb32 (s) : bfd_getl32 (s))
+
+/* Local functions.  */
+
+static void overrun PARAMS ((const struct coff_file_info *, const char *));
+static struct res_directory *read_coff_res_dir
+  PARAMS ((const bfd_byte *, const struct coff_file_info *));
+static struct res_resource *read_coff_data_entry
+  PARAMS ((const bfd_byte *, const struct coff_file_info *));
+
+/* Read the resources in a COFF file.  */
+
+struct res_directory *
+read_coff_rsrc (filename, target)
+     const char *filename;
+     const char *target;
+{
+  bfd *abfd;
+  char **matching;
+  asection *sec;
+  bfd_size_type size;
+  bfd_byte *data;
+  struct coff_file_info finfo;
+
+  abfd = bfd_openr (filename, target);
+  if (abfd == NULL)
+    bfd_fatal (filename);
+
+  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
+    {
+      bfd_nonfatal (bfd_get_filename (abfd));
+      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
+	list_matching_formats (matching);
+      xexit (1);
+    }
+
+  sec = bfd_get_section_by_name (abfd, ".rsrc");
+  if (sec == NULL)
+    {
+      fprintf (stderr, "%s: %s: no resource section\n", program_name,
+	       filename);
+      xexit (1);
+    }
+
+  size = bfd_section_size (abfd, sec);
+  data = (bfd_byte *) xmalloc (size);
+
+  if (! bfd_get_section_contents (abfd, sec, data, 0, size))
+    bfd_fatal ("can't read resource section");
+
+  finfo.filename = filename;
+  finfo.data = data;
+  finfo.data_end = data + size;
+  finfo.secaddr = (bfd_get_section_vma (abfd, sec)
+		   - pe_data (abfd)->pe_opthdr.ImageBase);
+  finfo.big_endian = bfd_big_endian (abfd);
+
+  bfd_close (abfd);
+
+  /* Now just read in the top level resource directory.  Note that we
+     don't free data, since we create resource entries that point into
+     it.  If we ever want to free up the resource information we read,
+     this will have to be cleaned up.  */
+
+  return read_coff_res_dir (data, &finfo);
+}
+
+/* Give an error if we are out of bounds.  */
+
+static void
+overrun (finfo, msg)
+     const struct coff_file_info *finfo;
+     const char *msg;
+{
+  fatal ("%s: %s: address out of bounds", finfo->filename, msg);
+}
+
+/* Read a resource directory.  */
+
+static struct res_directory *
+read_coff_res_dir (data, finfo)
+     const bfd_byte *data;
+     const struct coff_file_info *finfo;
+{
+  const struct extern_res_directory *erd;
+  struct res_directory *rd;
+  int name_count, id_count, i;
+  struct res_entry **pp;
+  const struct extern_res_entry *ere;
+
+  if (finfo->data_end - data < sizeof (struct extern_res_directory))
+    overrun (finfo, "directory");
+
+  erd = (const struct extern_res_directory *) data;
+
+  rd = (struct res_directory *) xmalloc (sizeof *rd);
+  rd->characteristics = get_32 (finfo, erd->characteristics);
+  rd->time = get_32 (finfo, erd->time);
+  rd->major = get_16 (finfo, erd->major);
+  rd->minor = get_16 (finfo, erd->minor);
+  rd->entries = NULL;
+
+  name_count = get_16 (finfo, erd->name_count);
+  id_count = get_16 (finfo, erd->id_count);
+
+  pp = &rd->entries;
+
+  /* The resource directory entries immediately follow the directory
+     table.  */
+  ere = (const struct extern_res_entry *) (erd + 1);
+
+  for (i = 0; i < name_count; i++, ere++)
+    {
+      unsigned long name, rva;
+      struct res_entry *re;
+      const bfd_byte *ers;
+      int length, j;
+
+      if ((const bfd_byte *) ere >= finfo->data_end)
+	overrun (finfo, "named directory entry");
+
+      name = get_32 (finfo, ere->name);
+      rva = get_32 (finfo, ere->rva);
+
+      /* For some reason the high bit in NAME is set.  */
+      name &=~ 0x80000000;
+
+      if (name > finfo->data_end - finfo->data)
+	overrun (finfo, "directory entry name");
+
+      ers = finfo->data + name;
+
+      re = (struct res_entry *) xmalloc (sizeof *re);
+      re->next = NULL;
+      re->id.named = 1;
+      length = get_16 (finfo, ers);
+      re->id.u.n.length = length;
+      re->id.u.n.name = ((unsigned short *)
+			 xmalloc (length * sizeof (unsigned short)));
+      for (j = 0; j < length; j++)
+	re->id.u.n.name[j] = get_16 (finfo, ers + j * 2 + 2);
+
+      if ((rva & 0x80000000) != 0)
+	{
+	  rva &=~ 0x80000000;
+	  if (rva >= finfo->data_end - finfo->data)
+	    overrun (finfo, "named subdirectory");
+	  re->subdir = 1;
+	  re->u.dir = read_coff_res_dir (finfo->data + rva, finfo);
+	}
+      else
+	{
+	  if (rva >= finfo->data_end - finfo->data)
+	    overrun (finfo, "named resource");
+	  re->subdir = 0;
+	  re->u.res = read_coff_data_entry (finfo->data + rva, finfo);
+	}
+
+      *pp = re;
+      pp = &re->next;
+    }
+
+  for (i = 0; i < id_count; i++, ere++)
+    {
+      unsigned long name, rva;
+      struct res_entry *re;
+
+      if ((const bfd_byte *) ere >= finfo->data_end)
+	overrun (finfo, "ID directory entry");
+
+      name = get_32 (finfo, ere->name);
+      rva = get_32 (finfo, ere->rva);
+
+      re = (struct res_entry *) xmalloc (sizeof *re);
+      re->next = NULL;
+      re->id.named = 0;
+      re->id.u.id = name;
+
+      if ((rva & 0x80000000) != 0)
+	{
+	  rva &=~ 0x80000000;
+	  if (rva >= finfo->data_end - finfo->data)
+	    overrun (finfo, "ID subdirectory");
+	  re->subdir = 1;
+	  re->u.dir = read_coff_res_dir (finfo->data + rva, finfo);
+	}
+      else
+	{
+	  if (rva >= finfo->data_end - finfo->data)
+	    overrun (finfo, "ID resource");
+	  re->subdir = 0;
+	  re->u.res = read_coff_data_entry (finfo->data + rva, finfo);
+	}
+
+      *pp = re;
+      pp = &re->next;
+    }
+
+  return rd;
+}
+
+/* Read a resource data entry.  */
+
+static struct res_resource *
+read_coff_data_entry (data, finfo)
+     const bfd_byte *data;
+     const struct coff_file_info *finfo;
+{
+  const struct extern_res_data *erd;
+  struct res_resource *r;
+  unsigned long size, rva;
+  const bfd_byte *resdata;
+
+  if (finfo->data_end - data < sizeof (struct extern_res_data))
+    overrun (finfo, "data entry");
+
+  erd = (const struct extern_res_data *) data;
+
+  r = (struct res_resource *) xmalloc (sizeof *r);
+  memset (&r->res_info, 0, sizeof (struct res_res_info));
+  r->coff_info.codepage = get_32 (finfo, erd->codepage);
+  r->coff_info.reserved = get_32 (finfo, erd->reserved);
+
+  size = get_32 (finfo, erd->size);
+  rva = get_32 (finfo, erd->rva);
+  if (rva < finfo->secaddr
+      || rva - finfo->secaddr >= finfo->data_end - finfo->data)
+    overrun (finfo, "resource data");
+
+  resdata = finfo->data + (rva - finfo->secaddr);
+
+  r->type = RES_TYPE_USERDATA;
+  r->u.userdata = ((struct rcdata_data *)
+		   xmalloc (sizeof (struct rcdata_data)));
+  r->u.userdata->first = ((struct rcdata_item *)
+			  xmalloc (sizeof (struct rcdata_item)));
+  r->u.userdata->last = r->u.userdata->first;
+  r->u.userdata->first->next = NULL;
+  r->u.userdata->first->type = RCDATA_BUFFER;
+  r->u.userdata->first->u.buffer.length = size;
+  r->u.userdata->first->u.buffer.data = (unsigned char *) resdata;
+
+  return r;
+}