(struct execdata): New members `headbuf', `file_data', `optimal_block'.

(load_section): Copy data from U->file_data if that is nonnull.
Use new subfunction `write_to_task' that handles non-page aligned sections.
(input_room): Fix EOF check.
Use io_read if no memory object.
(prepare): New function, broken out of check.
Initialize E->file_data and E->optimal_block.
Set E->stream.__seen bit.
(check): No longer take FILE arg.
Use E->file_data if nonnull; else read from stream if no memory object.
(finish_mapping): Reset members after deallocating resources.
(finish): Likewise.  Call fclose.  Don't deallocate E->header if it points
to &E->headbuf or E->file_data.
(check_gzip): New function, implements executing gzip'd binaries.
(do_exec): Call prepare before check.
Call check_gzip if file format unrecognized.

1 files changed, 300 insertions, 85 deletions

diff --git a/exec/exec.c b/exec/exec.c
index 531d41e0..d8970036 100644
--- a/exec/exec.c
+++ b/exec/exec.c
@@ -81,11 +81,13 @@ struct execdata
     bfd *bfd;
 #else
     file_t file;
-    struct exec *header;
+    struct exec *header, headbuf;
 #endif
     memory_object_t filemap, cntlmap;
     struct shared_io *cntl;
+    char *file_data;		/* File data if already copied in core.  */
     off_t file_size;
+    size_t optimal_block;	/* Optimal size for io_read from file.  */
 
     /* Set by caller of load.  */
     task_t task;
@@ -140,6 +142,8 @@ b2he (error_t deflt)
 #define	b2he()	a2he (errno)
 #endif
 
+static void check_gzip (struct execdata *);
+
 #ifdef	BFD
 
 /* Check a section, updating the `locations' vector [BFD].  */
@@ -242,24 +246,85 @@ load_section (enum section section, struct execdata *u)
     {
       vm_address_t mapstart = round_page (addr);
 
+      /* Allocate space in the task and write CONTENTS into it.  */
+      void write_to_task (vm_address_t mapstart, vm_size_t size,
+			  vm_prot_t vm_prot, vm_address_t contents)
+	{
+	  vm_size_t off = size % vm_page_size;
+	  /* Allocate with vm_map to set max protections.  */
+	  u->error = vm_map (u->task,
+			     &mapstart, size, 0, 0,
+			     MACH_PORT_NULL, 0, 1,
+			     vm_prot|VM_PROT_WRITE,
+			     VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE,
+			     VM_INHERIT_COPY);
+	  if (! u->error && size >= vm_page_size)
+	    u->error = vm_write (u->task, mapstart, contents, size - off);
+	  if (! u->error && off != 0)
+	    {
+	      vm_address_t page = 0;
+	      u->error = vm_allocate (mach_task_self (),
+				      &page, vm_page_size, 1);
+	      if (! u->error)
+		{
+		  memcpy ((void *) page,
+			  (void *) (contents + (size - off)),
+			  off);
+		  u->error = vm_write (u->task, mapstart + (size - off),
+				       page, vm_page_size);
+		  vm_deallocate (mach_task_self (), page, vm_page_size);
+		}
+	    }
+	  /* Reset the current protections to the desired state.  */
+	  if (! u->error && (vm_prot & VM_PROT_WRITE) == 0)
+	    u->error = vm_protect (u->task, mapstart, size, 0, vm_prot);
+	}
+
       if (mapstart - addr < secsize)
 	{
 	  /* MAPSTART is the first page that starts inside the section.
 	     Map all the pages that start inside the section.  */
 
 #ifdef	BFD
-	  if (sec->flags & SEC_IN_MEMORY)
-	    u->error = vm_write (u->task, mapstart,
-				 contents + (mapstart - addr),
-				 secsize - (mapstart - addr));
-	  else
+#define SECTION_IN_MEMORY_P	(sec->flags & SEC_IN_MEMORY)
+#define SECTION_CONTENTS	sec->contents
+#else
+#define SECTION_IN_MEMORY_P	(u->file_data != NULL)
+#define SECTION_CONTENTS	(u->file_data + filepos)
 #endif
+	  if (SECTION_IN_MEMORY_P)
+	    /* Data is already in memory; write it into the task.  */
+	    write_to_task (mapstart, secsize - (mapstart - addr), vm_prot,
+			   (vm_address_t) SECTION_CONTENTS
+			   + (mapstart - addr));
+	  else if (u->filemap != MACH_PORT_NULL)
+	    /* Map the data into the task directly from the file.  */
 	    u->error = vm_map (u->task,
 			       &mapstart, secsize - (mapstart - addr), 0, 0,
 			       u->filemap, filepos + (mapstart - addr), 1, 
 			       vm_prot,
 			       VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE,
 			       VM_INHERIT_COPY);
+	  else
+	    {
+	      /* Cannot map the data.  Read it into a buffer and vm_write
+		 it into the task.  */
+	      void *buf;
+	      const vm_size_t size = secsize - (mapstart - addr);
+	      u->error = vm_allocate (mach_task_self (),
+				      (vm_address_t *) &buf, size, 1);
+	      if (! u->error)
+		{
+		  if (fseek (&u->stream,
+			     filepos + (mapstart - addr), SEEK_SET) ||
+		      fread (buf, size, 1, &u->stream) != 1)
+		    u->error = errno;
+		  else
+		    write_to_task (mapstart, size, vm_prot,
+				   (vm_address_t) buf);
+		  vm_deallocate (mach_task_self (), (vm_address_t) buf, size);
+		}
+	    }
 	  if (u->error)
 	    return;
 	}
@@ -293,50 +358,14 @@ load_section (enum section section, struct execdata *u)
 	  readaddr = (void *) (ourpage + (addr - overlap_page));
 	  readsize = size - (addr - overlap_page);
 
-#ifdef	BFD
-	  if (sec->flags & SEC_IN_MEMORY)
-	    bcopy (sec->contents, readaddr, readsize);
+	  if (SECTION_IN_MEMORY_P)
+	    bcopy (SECTION_CONTENTS, readaddr, readsize);
 	  else
-#endif
-#if	1
 	    if (fread (readaddr, readsize, 1, &u->stream) != 1)
 	      {
 		u->error = errno;
 		goto maplose;
 	      }
-#else
-	  if (u->cntl)
-	    {
-	      /* We cannot call io_read while holding the conch,
-		 so we must read by mapping the file ourselves.  */
-	      vm_address_t data;
-	      if (u->error = vm_map (mach_task_self (), &data, readsize, 0, 1,
-				     u->filemap, filepos, 1,
-				     VM_PROT_READ, VM_PROT_READ,
-				     VM_INHERIT_COPY))
-		goto maplose;
-	      bcopy ((void *) data, readaddr, readsize);
-	      vm_deallocate (mach_task_self (), data, readsize);
-	    }
-	  else
-	    do
-	      {
-		char *data;
-		unsigned int nread;
-		data = readaddr;
-		if (u->error = io_read (u->file, &data, &nread,
-					filepos, readsize))
-		  goto maplose;
-		if (data != readaddr)
-		  {
-		    bcopy (data, readaddr, nread);
-		    vm_deallocate (mach_task_self (), (vm_address_t) data, 
-				   nread);
-		  }
-		readaddr += nread;
-		readsize -= nread;
-	      } while (readsize > 0);
-#endif
 	  u->error = vm_write (u->task, overlap_page, ourpage, size);
 	  if (u->error == KERN_PROTECTION_FAILURE)
 	    {
@@ -481,38 +510,69 @@ input_room (FILE *f)
   struct execdata *e = f->__cookie;
   const size_t size = e->file_size;
 
-  if (f->__buffer != NULL)
-    vm_deallocate (mach_task_self (), (vm_address_t) f->__buffer,
-		   f->__bufsize);
-
-  if (f->__target > size)
+  if (f->__target >= size)
     {
       f->__eof = 1;
       return EOF;
     }
 
-  f->__buffer = NULL;
-  if (vm_map (mach_task_self (),
-	      (vm_address_t *) &f->__buffer, vm_page_size, 0, 1,
-	      e->filemap, f->__target, 1, VM_PROT_READ, VM_PROT_READ,
-	      VM_INHERIT_NONE))
+  if (e->filemap == MACH_PORT_NULL)
     {
-      errno = EIO;
-      f->__error = 1;
-      return EOF;
-    }
-  f->__bufsize = vm_page_size;
-  f->__offset = f->__target;
+      mach_msg_type_number_t nread = f->__bufsize;
+      char *buffer = f->__buffer;
+      if (e->error = io_read (e->file, &buffer, &nread,
+			      f->__target, e->optimal_block))
+	{
+	  errno = e->error;
+	  f->__error = 1;
+	  return EOF;
+	}
+      if (buffer != f->__buffer)
+	{
+	  /* The data was returned out of line.  Discard the old buffer.  */
+	  vm_deallocate (mach_task_self (), (vm_address_t) f->__buffer,
+			 f->__bufsize);
+	  f->__buffer = buffer;
+	  f->__bufsize = round_page (nread);
+	}
 
-  if (f->__target + f->__bufsize > size)
-    f->__get_limit = f->__buffer + (size - f->__target);
+      f->__get_limit = f->__buffer + nread;
+    }
   else
-    f->__get_limit = f->__buffer + f->__bufsize;
+    {
+      if (f->__buffer != NULL)
+	vm_deallocate (mach_task_self (), (vm_address_t) f->__buffer,
+		       f->__bufsize);
+      f->__buffer = NULL;
+      if (vm_map (mach_task_self (),
+		  (vm_address_t *) &f->__buffer, vm_page_size, 0, 1,
+		  e->filemap, f->__target, 1, VM_PROT_READ, VM_PROT_READ,
+		  VM_INHERIT_NONE))
+	{
+	  errno = EIO;
+	  f->__error = 1;
+	  return EOF;
+	}
+      f->__bufsize = vm_page_size;
+
+      if (e->cntl)
+	e->cntl->accessed = 1;
 
-  if (e->cntl)
-    e->cntl->accessed = 1;
+      if (f->__target + f->__bufsize > size)
+	f->__get_limit = f->__buffer + (size - f->__target);
+      else
+	f->__get_limit = f->__buffer + f->__bufsize;
+    }
 
+  f->__offset = f->__target;
   f->__bufp = f->__buffer;
+
+  if (f->__get_limit == f->__buffer)
+    {
+      f->__eof = 1;
+      return EOF;
+    }
+
   return (unsigned char) *f->__bufp++;
 }
 
@@ -529,17 +589,16 @@ close_exec_stream (void *cookie)
 }
 
 
-/* Prepare to load FILE.
-   On successful return, the caller must allocate the
-   E->locations vector, and map check_section over the BFD.  */
+/* Prepare to check and load FILE.  */
 static inline void
-check (file_t file, struct execdata *e)
+prepare (file_t file, struct execdata *e)
 {
   e->file = file;
 
 #ifdef	BFD
   e->bfd = NULL;
 #endif
+  e->file_data = NULL;
   e->cntl = NULL;
   e->filemap = MACH_PORT_NULL;
   e->cntlmap = MACH_PORT_NULL;
@@ -548,7 +607,7 @@ check (file_t file, struct execdata *e)
     memory_object_t rd, wr;
     if (e->error = io_map (file, &rd, &wr))
       return;
-    if (wr)
+    if (wr != MACH_PORT_NULL)
       mach_port_deallocate (mach_task_self (), wr);
     if (rd == MACH_PORT_NULL)
       {
@@ -565,6 +624,7 @@ check (file_t file, struct execdata *e)
 	if (e->error = io_stat (file, &st))
 	  return;
 	e->file_size = st.st_size;
+	e->optimal_block = st.st_blksize;
       }
     else
       e->error = vm_map (mach_task_self (), (vm_address_t *) &e->cntl,
@@ -612,15 +672,26 @@ check (file_t file, struct execdata *e)
   e->stream.__room_funcs.__input = input_room;
   e->stream.__io_funcs.close = close_exec_stream;
   e->stream.__cookie = e;
+  e->stream.__seen = 1;
 
-#ifdef	BFD
+#ifdef BFD
   e->bfd = bfd_openstream (&e->stream);
   if (e->bfd == NULL)
     {
       e->error = b2he (ENOEXEC);
       return;
     }
+#endif
+}
+
+/* Check the magic number, etc. of the file.
+   On successful return, the caller must allocate the
+   E->locations vector, and map check_section over the BFD.  */
 
+static void
+check (struct execdata *e)
+{
+#ifdef	BFD
   bfd_error = no_error;
   if (!bfd_check_format (e->bfd, bfd_object))
     {
@@ -643,11 +714,25 @@ check (file_t file, struct execdata *e)
       return;
     }
   e->header = NULL;
-  if (e->error = vm_map (mach_task_self (),
-			 (vm_address_t *) &e->header, sizeof (*e->header),
-			 0, 1, e->filemap, 0, 1, VM_PROT_READ, VM_PROT_READ,
-			 VM_INHERIT_NONE))
-    return;
+  if (e->file_data)
+    /* Data already in core.  Just use it.  */
+    e->header = (void *) e->file_data;
+  else if (e->filemap == MACH_PORT_NULL)
+    {
+      /* Cannot map the file.  Read the header into a buffer.  */
+      if (fread (&e->headbuf, sizeof e->headbuf, 1, &e->stream) != 1)
+	{
+	  e->error = errno;
+	  return;
+	}
+      e->header = &e->headbuf;
+    }
+  else
+    if (e->error = vm_map (mach_task_self (),
+			   (vm_address_t *) &e->header, sizeof (*e->header),
+			   0, 1, e->filemap, 0, 1, VM_PROT_READ, VM_PROT_READ,
+			   VM_INHERIT_NONE))
+      return;
   if (N_BADMAG (*e->header))
     {
       e->error = ENOEXEC;
@@ -665,7 +750,7 @@ check (file_t file, struct execdata *e)
 
 
 /* Load the file.  */
-static inline void
+static void
 load (task_t usertask, struct execdata *e)
 {
   if (e->error)
@@ -682,7 +767,7 @@ load (task_t usertask, struct execdata *e)
 }
 
 /* Do post-loading processing on the task.  */
-static inline void
+static void
 postload (struct execdata *e)
 {
   if (e->error)
@@ -699,7 +784,7 @@ postload (struct execdata *e)
 
 
 /* Release the conch and clean up mapping the file and control page.  */
-static inline void
+static void
 finish_mapping (struct execdata *e)
 {
   if (e->cntl != NULL)
@@ -716,29 +801,146 @@ finish_mapping (struct execdata *e)
 	  spin_unlock (&e->cntl->lock);
 	}
       vm_deallocate (mach_task_self (), (vm_address_t) e->cntl, vm_page_size);
+      e->cntl = NULL;
     }
   if (e->filemap != MACH_PORT_NULL)
-    mach_port_deallocate (mach_task_self (), e->filemap);
+    {
+      mach_port_deallocate (mach_task_self (), e->filemap);
+      e->filemap = MACH_PORT_NULL;
+    }
   if (e->cntlmap != MACH_PORT_NULL)
-    mach_port_deallocate (mach_task_self (), e->cntlmap);
+    {
+      mach_port_deallocate (mach_task_self (), e->cntlmap);
+      e->cntlmap = MACH_PORT_NULL;
+    }
 }
       
 /* Clean up after reading the file (need not be completed).  */
-static inline void
+static void
 finish (struct execdata *e)
 {
   finish_mapping (e);
+  fclose (&e->stream);
 #ifdef	BFD
   if (e->bfd != NULL)
     (void) bfd_close (e->bfd);
 #else
-  if (e->header != NULL)
+  if (e->header != NULL && e->header != &e->headbuf &&
+      e->header != (void *) e->file_data)
     vm_deallocate (mach_task_self (),
 		   (vm_address_t) e->header, sizeof (*e->header));
-  mach_port_deallocate (mach_task_self (), e->file);
+  e->header = NULL;
 #endif
+  if (e->file != MACH_PORT_NULL)
+    {
+      mach_port_deallocate (mach_task_self (), e->file);
+      e->file = MACH_PORT_NULL;
+    }
 }
 
+/* Check the file for being a gzip'd image.  Return with ENOEXEC means not
+   a valid gzip file; return with another error means lossage in decoding;
+   return with zero means the file was uncompressed into memory which E now
+   points to, and `check' can be run again.  */
+
+static void
+check_gzip (struct execdata *earg)
+{
+  struct execdata *e = earg;
+  /* Entry points to unzip engine.  */
+  int get_method (int);
+  void unzip (int, int);
+  extern long int bytes_out;
+  /* Callbacks from unzip for I/O and error interface.  */
+  extern int (*unzip_read) (char *buf, size_t maxread);
+  extern void (*unzip_write) (const char *buf, size_t nwrite);
+  extern void (*unzip_read_error) (void);
+  extern void (*unzip_error) (const char *msg);
+
+  char *zipdata = NULL;
+  size_t zipdatasz = 0;
+  FILE *zipout = NULL;
+  jmp_buf ziperr;
+  int zipread (char *buf, size_t maxread)
+    {
+      return fread (buf, 1, maxread, &e->stream);
+    }
+  void zipwrite (const char *buf, size_t nwrite)
+    {
+      if (fwrite (buf, nwrite, 1, zipout) != 1)
+	longjmp (ziperr, 1);
+    }
+  void ziprderr (void)
+    {
+      longjmp (ziperr, 2);
+    }
+  void ziperror (const char *msg)
+    {
+      errno = ENOEXEC;
+      longjmp (ziperr, 2);
+    }
+
+  unzip_read = zipread;
+  unzip_write = zipwrite;
+  unzip_read_error = ziprderr;
+  unzip_error = ziperror;
+
+  if (setjmp (ziperr))
+    {
+      /* Error in unzipping jumped out.  */
+      if (zipout)
+	{
+	  fclose (zipout);
+	  free (zipdata);
+	}
+      e->error = errno;
+      return;
+    }
+
+  if (get_method (0) != 0)
+    {
+      /* Not a happy gzip file.  */
+      e->error = ENOEXEC;
+      return;
+    }
+
+  /* Matched gzip magic number.  Ready to unzip.
+     Set up the output stream and let 'er rip.  */
+
+  zipout = open_memstream (&zipdata, &zipdatasz);
+  if (! zipout)
+    {
+      e->error = errno;
+      return;
+    }
+
+  /* Call the gunzip engine.  */
+  bytes_out = 0;
+  unzip (17, 23);		/* Arguments ignored.  */
+
+  /* The output is complete.  Clean up the stream and store its resultant
+     buffer and size in the execdata as the file contents.  */
+  fclose (zipout);
+  e->file_data = zipdata;
+  e->file_size = zipdatasz;
+
+  /* Clean up the old exec file stream's state.  */
+  finish (e);
+
+  /* Point the stream at the buffer of file data.  */
+  memset (&e->stream, 0, sizeof (e->stream));
+  e->stream.__magic = _IOMAGIC;
+  e->stream.__mode.__read = 1;
+  e->stream.__buffer = e->file_data;
+  e->stream.__bufsize = e->file_size;
+  e->stream.__get_limit = e->stream.__buffer + e->stream.__bufsize;
+  e->stream.__bufp = e->stream.__buffer;
+  e->stream.__seen = 1;
+
+  e->error = 0;
+}
+
+
 static int
 request_server (mach_msg_header_t *inp,
 		mach_msg_header_t *outp)
@@ -857,8 +1059,21 @@ do_exec (mach_port_t execserver,
   if ((!std_ports || !std_ints) && (flags & (EXEC_SECURE|EXEC_DEFAULTS)))
     return EIEIO;
 
+  /* Prepare E to read the file.  */
+  prepare (file, &e);
+
   /* Check the file for validity first.  */
-  check (file, &e);
+  check (&e);
+  if (e.error == ENOEXEC)
+    {
+      /* See if it is a compressed image.  */
+      check_gzip (&e);
+      if (e.error == 0)
+	/* The file was uncompressed into memory, and now E describes the
+	   uncompressed image rather than the actual file.  Check it again
+	   for a valid magic number.  */
+	check (&e);
+    }
 #if 0
   if (e.error == ENOEXEC)
     /* Check for a #! executable file.  */