[bpt/emacs.git] / src / unexsunos4.c

/* Unexec for Sunos 4 using shared libraries.
   Copyright (C) 1990, 1994 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs 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.

GNU Emacs 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 GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* Contributed by Viktor Dukhovni.  */
/*
 * Unexec for Berkeley a.out format + SUNOS shared libraries
 * The unexeced executable contains the __DYNAMIC area from the
 * original text file,  and then the rest of data + bss + malloced area of
 * the current process.  (The __DYNAMIC area is at the top of the process
 * data segment,  we use "data_start" defined externally to mark the start
 * of the "real" data segment.)
 *
 * For programs that want to remap some of the data segment read only
 * a run_time_remap is provided.  This attempts to remap largest area starting
 * and ending on page boundaries between "data_start" and "bndry"
 * For this it to figure out where the text file is located.  A path search
 * is attempted after trying argv[0] and if all fails we simply do not remap
 *
 * One feature of run_time_remap () is mandatory:  reseting the break.
 *
 *  Note that we can no longer map data into the text segment,  as this causes
 *  the __DYNAMIC struct to become read only,  breaking the runtime loader.
 *  Thus we no longer need to mess with a private crt0.c,  the standard one
 *  will do just fine,  since environ can live in the writable area between
 *  __DYNAMIC and data_start,  just make sure that pre-crt0.o (the name
 *  is somewhat abused here) is loaded first!
 *
 */
#include <sys/param.h>
#include <sys/mman.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <string.h>
#include <stdio.h>
#include <a.out.h>

/* Do this after the above #include's in case a configuration file wants
   to define things for this file based on what <a.out.h> defines.  */
#ifdef emacs
#include <config.h>
#endif

#if defined (SUNOS4) || defined (__FreeBSD__)
#define UNDO_RELOCATION
#endif

#ifdef UNDO_RELOCATION
#include <link.h>
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

/* NetBSD needs this bit, but SunOS does not have it.  */
#ifndef MAP_FILE
#define MAP_FILE 0
#endif


/*
 * for programs other than emacs
 * define data_start + initialized here,  and make sure
 * this object is loaded first!
 * emacs will define these elsewhere,  and load the object containing
 * data_start (pre-crt0.o or firstfile.o?) first!
 * The custom crt0.o *must not* be loaded!
 */
#ifndef emacs
  static int data_start = 0;
  static int initialized = 0;
#else
  extern int initialized;
  extern unsigned data_start;
  extern int pureptr;
#endif

extern char *getenv ();
static unsigned Brk;
static struct exec nhdr;
static int rd_only_len;
static long cookie;


unexec (new_name, a_name, bndry, bss_start, entry) 
     char *new_name, *a_name;
     unsigned bndry, bss_start, entry;
{
  int fd, new;
  char *old;
  struct exec ohdr;		/* Allocate on the stack,  not needed in the next life */
  struct stat stat;

  if ((fd = open (a_name, O_RDONLY)) < 0)
    {
      fprintf (stderr, "%s: open: ", a_name);
      perror (a_name);
      exit (1);
    }
  if ((new = open (new_name, O_WRONLY | O_CREAT, 0666)) == -1)
    {
      fprintf (stderr, "%s: open: ", a_name);
      perror (new_name);
      exit (1);
    }

  if ((fstat (fd, &stat) == -1))
    {
      fprintf (stderr, "%s: ", a_name);
      perror ("fstat");
      exit (1);
    }

  old = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE|MAP_SHARED, fd, 0);
  if (old == (char *)-1)
    {
      fprintf (stderr, "%s: ", a_name);
      perror ("mmap");
      exit (1);
    }
  close (fd);

  nhdr = ohdr = (*(struct exec *)old);


  /*
   * Remember a magic cookie so we know we've got the right binary
   * when remapping.
   */
  cookie = time (0);

  Brk = sbrk (0);		/* Save the break, it is reset to &_end (by ld.so?) */

  /*
   * Round up data start to a page boundary (Lose if not a 2 power!)
   */
  data_start = ((((int)&data_start) - 1) & ~(N_PAGSIZ (nhdr) - 1)) + N_PAGSIZ (nhdr);

  /*
   * Round down read only pages to a multiple of the page size
   */
  if (bndry)
    rd_only_len = ((int)bndry & ~(N_PAGSIZ (nhdr) - 1)) - data_start;

#ifndef emacs
  /* Have to do this some time before dumping the data */
  initialized = 1;
#endif
  
  /* 
   * Handle new data and bss sizes and optional new entry point.
   * No one actually uses bss_start and entry,  but tradition compels
   * one to support them.
   * Could complain if bss_start > Brk,  but the caller is *supposed* to know
   * what she is doing.
   */
  nhdr.a_data = (bss_start ? bss_start : Brk) - N_DATADDR (nhdr);
  nhdr.a_bss  = bss_start ? Brk - bss_start : 0;
  if (entry) 
    nhdr.a_entry = entry;

  /*
   * Write out the text segment with new header
   * Dynamic executables are ZMAGIC with N_TXTOFF==0 and the header
   * part of the text segment, but no need to rely on this.
   * So write the TEXT first,  then go back replace the header.
   * Doing it in the other order is less general!
   */
  lseek (new, N_TXTOFF (nhdr), L_SET);
  write (new, old + N_TXTOFF (ohdr), N_TXTOFF (ohdr) + ohdr.a_text);
  lseek (new, 0L, L_SET);
  write (new, &nhdr, sizeof (nhdr));

  /*
   * Write out the head of the old data segment from the file not
   * from core, this has the unresolved __DYNAMIC relocation data
   * we need to reload
   */
  lseek (new, N_DATOFF (nhdr), L_SET);
  write (new, old + N_DATOFF (ohdr), (int)&data_start - N_DATADDR (ohdr));

  /*
   * Copy the rest of the data from core
   */
  write (new, &data_start, N_BSSADDR (nhdr) - (int)&data_start);

  /*
   * Copy the symbol table and line numbers
   */
  lseek (new, N_TRELOFF (nhdr), L_SET);
  write (new, old + N_TRELOFF (ohdr), stat.st_size - N_TRELOFF (ohdr));

  /* Some other BSD systems use this file.
     We don't know whether this change is right for them.  */
#ifdef UNDO_RELOCATION
  /* Undo the relocations done at startup by ld.so.
     It will do these relocations again when we start the dumped Emacs.
     Doing them twice gives incorrect results.  */
  {
    unsigned long daddr = N_DATADDR (ohdr);
    unsigned long rel, erel;
#ifdef SUNOS4
    extern struct link_dynamic _DYNAMIC;

    /*  SunOS4.x's ld_rel is relative to N_TXTADDR. */
    if (_DYNAMIC.ld_version < 2)
      {
	rel = _DYNAMIC.ld_un.ld_1->ld_rel + N_TXTADDR (ohdr);
	erel = _DYNAMIC.ld_un.ld_1->ld_hash + N_TXTADDR (ohdr);
      }
    else
      {
	rel = _DYNAMIC.ld_un.ld_2->ld_rel + N_TXTADDR (ohdr);
	erel = _DYNAMIC.ld_un.ld_2->ld_hash + N_TXTADDR (ohdr);
      }
#ifdef sparc
#define REL_INFO_TYPE		struct reloc_info_sparc
#else
#define REL_INFO_TYPE		struct relocation_info
#endif /* sparc */
#define REL_TARGET_ADDRESS(r)	(((REL_INFO_TYPE *)(r))->r_address)
#endif /* SUNOS4 */
#ifdef __FreeBSD__
    extern struct _dynamic _DYNAMIC;

    /*  FreeBSD's LD_REL is a virtual address itself. */
    rel = LD_REL (&_DYNAMIC);
    erel = rel + LD_RELSZ (&_DYNAMIC);
#define REL_INFO_TYPE		struct relocation_info
#define REL_TARGET_ADDRESS(r)	(((REL_INFO_TYPE *)(r))->r_address)
#endif

    for (; rel < erel; rel += sizeof (REL_INFO_TYPE))
      {
	/*  This is the virtual address where ld.so will do relocation.  */
	unsigned long target = REL_TARGET_ADDRESS (rel);
	/*  This is the offset in the data segment.  */
	unsigned long segoffset = target - daddr;

	/*  If it is located below data_start, we have to do nothing here,
	    because the old data has been already written to the location. */
	if (target < (unsigned long)&data_start)
	    continue;

	lseek (new, N_DATOFF (nhdr) + segoffset, L_SET);
	write (new, old + N_DATOFF (ohdr) + segoffset, sizeof (unsigned long));
      }
  }
#endif /* UNDO_RELOCATION */

  fchmod (new, 0755);
}

void
run_time_remap (progname)
     char *progname;
{
  char aout[MAXPATHLEN];
  register char *path, *p;

  /* Just in case */
  if (!initialized)
    return;

  /* Restore the break */
  brk (Brk);

  /*  If nothing to remap:  we are done! */
  if (rd_only_len == 0)
    return;

  /*
   * Attempt to find the executable
   * First try argv[0],  will almost always succeed as shells tend to give
   * the full path from the hash list rather than using execvp ()
   */
  if (is_it (progname)) 
    return;

  /*
   * If argv[0] is a full path and does not exist,  not much sense in
   * searching further
   */
  if (strchr (progname, '/')) 
    return;

  /*
   * Try to search for  argv[0] on the PATH
   */
  path = getenv ("PATH");
  if (path == NULL)
    return;

  while (*path)
    {
      /* copy through ':' or end */
      for (p = aout; *p = *path; ++p, ++path)
	if (*p == ':')
	  {
	    ++path;		/* move past ':' */
	    break;
	  }
      *p++ = '/';
      strcpy (p, progname);
      /*
       * aout is a candidate full path name
       */
      if (is_it (aout))
	return;
    }
}

is_it (filename)
  char *filename;
{
  int fd;
  long filenames_cookie;
  struct exec hdr;

  /*
   * Open an executable  and check for a valid header!
   * Can't bcmp the header with what we had,  it may have been stripped!
   * so we may save looking at non executables with the same name, mostly
   * directories.
   */
  fd = open (filename, O_RDONLY);
  if (fd != -1)
    {
      if (read (fd, &hdr, sizeof (hdr)) == sizeof (hdr)
	  && !N_BADMAG (hdr) && N_DATOFF (hdr) == N_DATOFF (nhdr)
	  && N_TRELOFF (hdr) == N_TRELOFF (nhdr))
	{
	  /* compare cookies */
	  lseek (fd, N_DATOFF (hdr) + (int)&cookie - N_DATADDR (hdr), L_SET);
	  read (fd, &filenames_cookie, sizeof (filenames_cookie));
	  if (filenames_cookie == cookie)
	    {			/* Eureka */

	      /*
	       * Do the mapping
	       * The PROT_EXEC may not be needed,  but it is safer this way.
	       * should the shared library decide to indirect through
	       * addresses in the data segment not part of __DYNAMIC
	       */
	      mmap (data_start, rd_only_len, PROT_READ | PROT_EXEC,
		    MAP_FILE | MAP_SHARED | MAP_FIXED, fd,
		    N_DATOFF (hdr) + data_start - N_DATADDR (hdr));
	      close (fd);
	      return 1;
	    }
	}
      close (fd);
    }
  return 0;
}
Commit	Line	Data
1a63b3de RS	1	/* Unexec for Sunos 4 using shared libraries.
	2	Copyright (C) 1990, 1994 Free Software Foundation, Inc.
	3
	4	This file is part of GNU Emacs.
	5
	6	GNU Emacs is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU Emacs is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU Emacs; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
2cad8dd6	20	/* Contributed by Viktor Dukhovni. */
9889c728 JB	21	/*
	22	* Unexec for Berkeley a.out format + SUNOS shared libraries
	23	* The unexeced executable contains the __DYNAMIC area from the
	24	* original text file, and then the rest of data + bss + malloced area of
	25	* the current process. (The __DYNAMIC area is at the top of the process
	26	* data segment, we use "data_start" defined externally to mark the start
	27	* of the "real" data segment.)
	28	*
	29	* For programs that want to remap some of the data segment read only
	30	* a run_time_remap is provided. This attempts to remap largest area starting
	31	* and ending on page boundaries between "data_start" and "bndry"
	32	* For this it to figure out where the text file is located. A path search
	33	* is attempted after trying argv[0] and if all fails we simply do not remap
	34	*
	35	* One feature of run_time_remap () is mandatory: reseting the break.
	36	*
	37	* Note that we can no longer map data into the text segment, as this causes
	38	* the __DYNAMIC struct to become read only, breaking the runtime loader.
	39	* Thus we no longer need to mess with a private crt0.c, the standard one
	40	* will do just fine, since environ can live in the writable area between
	41	* __DYNAMIC and data_start, just make sure that pre-crt0.o (the name
	42	* is somewhat abused here) is loaded first!
	43	*
9889c728	44	*/
9889c728 JB	45	#include <sys/param.h>
	46	#include <sys/mman.h>
	47	#include <sys/file.h>
	48	#include <sys/stat.h>
	49	#include <string.h>
	50	#include <stdio.h>
	51	#include <a.out.h>
	52
26e0a910 RM	53	/* Do this after the above #include's in case a configuration file wants
	54	to define things for this file based on what <a.out.h> defines. */
	55	#ifdef emacs
	56	#include <config.h>
	57	#endif
	58
ee3e4769 RS	59	#if defined (SUNOS4) \|\| defined (__FreeBSD__)
	60	#define UNDO_RELOCATION
	61	#endif
	62
	63	#ifdef UNDO_RELOCATION
1a63b3de RS	64	#include <link.h>
	65	#endif
	66
cda2316f RS	67	#ifdef HAVE_UNISTD_H
	68	#include <unistd.h>
	69	#endif
26e0a910	70
3b95c869 RM	71	/* NetBSD needs this bit, but SunOS does not have it. */
	72	#ifndef MAP_FILE
	73	#define MAP_FILE 0
	74	#endif
	75
	76
9889c728 JB	77	/*
	78	* for programs other than emacs
	79	* define data_start + initialized here, and make sure
	80	* this object is loaded first!
	81	* emacs will define these elsewhere, and load the object containing
	82	* data_start (pre-crt0.o or firstfile.o?) first!
	83	* The custom crt0.o must not be loaded!
	84	*/
	85	#ifndef emacs
	86	static int data_start = 0;
	87	static int initialized = 0;
	88	#else
	89	extern int initialized;
	90	extern unsigned data_start;
	91	extern int pureptr;
	92	#endif
	93
	94	extern char *getenv ();
	95	static unsigned Brk;
	96	static struct exec nhdr;
	97	static int rd_only_len;
	98	static long cookie;
	99
	100
	101	unexec (new_name, a_name, bndry, bss_start, entry)
	102	char new_name, a_name;
	103	unsigned bndry, bss_start, entry;
	104	{
9889c728 JB	105	int fd, new;
	106	char *old;
	107	struct exec ohdr; /* Allocate on the stack, not needed in the next life */
	108	struct stat stat;
	109
9889c728 JB	110	if ((fd = open (a_name, O_RDONLY)) < 0)
	111	{
	112	fprintf (stderr, "%s: open: ", a_name);
	113	perror (a_name);
	114	exit (1);
	115	}
	116	if ((new = open (new_name, O_WRONLY \| O_CREAT, 0666)) == -1)
	117	{
	118	fprintf (stderr, "%s: open: ", a_name);
	119	perror (new_name);
	120	exit (1);
	121	}
	122
	123	if ((fstat (fd, &stat) == -1))
	124	{
	125	fprintf (stderr, "%s: ", a_name);
	126	perror ("fstat");
	127	exit (1);
	128	}
	129
3b95c869	130	old = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE\|MAP_SHARED, fd, 0);
9889c728 JB	131	if (old == (char *)-1)
	132	{
	133	fprintf (stderr, "%s: ", a_name);
	134	perror ("mmap");
	135	exit (1);
	136	}
	137	close (fd);
	138
	139	nhdr = ohdr = ((struct exec )old);
	140
	141
	142	/*
eb8c3be9 JB	143	* Remember a magic cookie so we know we've got the right binary
eb8c3be9 JB	144	* when remapping.
9889c728 JB	145	*/
	146	cookie = time (0);
	147
	148	Brk = sbrk (0); /* Save the break, it is reset to &_end (by ld.so?) */
	149
	150	/*
	151	* Round up data start to a page boundary (Lose if not a 2 power!)
	152	*/
	153	data_start = ((((int)&data_start) - 1) & ~(N_PAGSIZ (nhdr) - 1)) + N_PAGSIZ (nhdr);
	154
	155	/*
	156	* Round down read only pages to a multiple of the page size
	157	*/
	158	if (bndry)
	159	rd_only_len = ((int)bndry & ~(N_PAGSIZ (nhdr) - 1)) - data_start;
	160
	161	#ifndef emacs
	162	/* Have to do this some time before dumping the data */
	163	initialized = 1;
	164	#endif
	165
	166	/*
	167	* Handle new data and bss sizes and optional new entry point.
	168	* No one actually uses bss_start and entry, but tradition compels
	169	* one to support them.
	170	* Could complain if bss_start > Brk, but the caller is supposed to know
	171	* what she is doing.
	172	*/
	173	nhdr.a_data = (bss_start ? bss_start : Brk) - N_DATADDR (nhdr);
	174	nhdr.a_bss = bss_start ? Brk - bss_start : 0;
	175	if (entry)
	176	nhdr.a_entry = entry;
	177
	178	/*
	179	* Write out the text segment with new header
	180	* Dynamic executables are ZMAGIC with N_TXTOFF==0 and the header
	181	* part of the text segment, but no need to rely on this.
	182	* So write the TEXT first, then go back replace the header.
	183	* Doing it in the other order is less general!
	184	*/
	185	lseek (new, N_TXTOFF (nhdr), L_SET);
	186	write (new, old + N_TXTOFF (ohdr), N_TXTOFF (ohdr) + ohdr.a_text);
	187	lseek (new, 0L, L_SET);
	188	write (new, &nhdr, sizeof (nhdr));
	189
	190	/*
	191	* Write out the head of the old data segment from the file not
	192	* from core, this has the unresolved __DYNAMIC relocation data
	193	* we need to reload
	194	*/
	195	lseek (new, N_DATOFF (nhdr), L_SET);
	196	write (new, old + N_DATOFF (ohdr), (int)&data_start - N_DATADDR (ohdr));
	197
	198	/*
	199	* Copy the rest of the data from core
	200	*/
	201	write (new, &data_start, N_BSSADDR (nhdr) - (int)&data_start);
	202
	203	/*
	204	* Copy the symbol table and line numbers
	205	*/
	206	lseek (new, N_TRELOFF (nhdr), L_SET);
	207	write (new, old + N_TRELOFF (ohdr), stat.st_size - N_TRELOFF (ohdr));
	208
1a63b3de RS	209	/* Some other BSD systems use this file.
1a63b3de RS	210	We don't know whether this change is right for them. */
ee3e4769	211	#ifdef UNDO_RELOCATION
1a63b3de RS	212	/* Undo the relocations done at startup by ld.so.
	213	It will do these relocations again when we start the dumped Emacs.
	214	Doing them twice gives incorrect results. */
	215	{
a783251b	216	unsigned long daddr = N_DATADDR (ohdr);
1a63b3de	217	unsigned long rel, erel;
ee3e4769	218	#ifdef SUNOS4
a783251b RS	219	extern struct link_dynamic _DYNAMIC;
	220
	221	/* SunOS4.x's ld_rel is relative to N_TXTADDR. */
1a63b3de RS	222	if (_DYNAMIC.ld_version < 2)
1a63b3de RS	223	{
a783251b RS	224	rel = _DYNAMIC.ld_un.ld_1->ld_rel + N_TXTADDR (ohdr);
a783251b RS	225	erel = _DYNAMIC.ld_un.ld_1->ld_hash + N_TXTADDR (ohdr);
1a63b3de RS	226	}
	227	else
	228	{
a783251b RS	229	rel = _DYNAMIC.ld_un.ld_2->ld_rel + N_TXTADDR (ohdr);
a783251b RS	230	erel = _DYNAMIC.ld_un.ld_2->ld_hash + N_TXTADDR (ohdr);
1a63b3de	231	}
a783251b RS	232	#ifdef sparc
	233	#define REL_INFO_TYPE struct reloc_info_sparc
	234	#else
9629ced8	235	#define REL_INFO_TYPE struct relocation_info
a783251b RS	236	#endif /* sparc */
a783251b RS	237	#define REL_TARGET_ADDRESS(r) (((REL_INFO_TYPE *)(r))->r_address)
ee3e4769 RS	238	#endif /* SUNOS4 */
ee3e4769 RS	239	#ifdef __FreeBSD__
a783251b RS	240	extern struct _dynamic _DYNAMIC;
	241
	242	/* FreeBSD's LD_REL is a virtual address itself. */
	243	rel = LD_REL (&_DYNAMIC);
	244	erel = rel + LD_RELSZ (&_DYNAMIC);
	245	#define REL_INFO_TYPE struct relocation_info
	246	#define REL_TARGET_ADDRESS(r) (((REL_INFO_TYPE *)(r))->r_address)
ee3e4769	247	#endif
1a63b3de	248
a783251b	249	for (; rel < erel; rel += sizeof (REL_INFO_TYPE))
1a63b3de	250	{
a783251b RS	251	/* This is the virtual address where ld.so will do relocation. */
	252	unsigned long target = REL_TARGET_ADDRESS (rel);
	253	/* This is the offset in the data segment. */
	254	unsigned long segoffset = target - daddr;
	255
	256	/* If it is located below data_start, we have to do nothing here,
	257	because the old data has been already written to the location. */
	258	if (target < (unsigned long)&data_start)
	259	continue;
	260
	261	lseek (new, N_DATOFF (nhdr) + segoffset, L_SET);
	262	write (new, old + N_DATOFF (ohdr) + segoffset, sizeof (unsigned long));
1a63b3de RS	263	}
1a63b3de RS	264	}
ee3e4769	265	#endif /* UNDO_RELOCATION */
1a63b3de	266
9889c728 JB	267	fchmod (new, 0755);
	268	}
	269
	270	void
	271	run_time_remap (progname)
	272	char *progname;
	273	{
	274	char aout[MAXPATHLEN];
	275	register char path, p;
	276
	277	/* Just in case */
	278	if (!initialized)
	279	return;
	280
	281	/* Restore the break */
	282	brk (Brk);
	283
	284	/* If nothing to remap: we are done! */
	285	if (rd_only_len == 0)
	286	return;
	287
	288	/*
	289	* Attempt to find the executable
	290	* First try argv[0], will almost always succeed as shells tend to give
	291	* the full path from the hash list rather than using execvp ()
	292	*/
	293	if (is_it (progname))
	294	return;
	295
	296	/*
	297	* If argv[0] is a full path and does not exist, not much sense in
	298	* searching further
	299	*/
	300	if (strchr (progname, '/'))
	301	return;
	302
	303	/*
	304	* Try to search for argv[0] on the PATH
	305	*/
	306	path = getenv ("PATH");
	307	if (path == NULL)
	308	return;
	309
	310	while (*path)
	311	{
	312	/* copy through ':' or end */
	313	for (p = aout; p = path; ++p, ++path)
	314	if (*p == ':')
	315	{
	316	++path; /* move past ':' */
	317	break;
	318	}
	319	*p++ = '/';
	320	strcpy (p, progname);
	321	/*
	322	* aout is a candidate full path name
	323	*/
	324	if (is_it (aout))
	325	return;
	326	}
	327	}
	328
a783251b RS	329	is_it (filename)
a783251b RS	330	char *filename;
9889c728 JB	331	{
9889c728 JB	332	int fd;
a783251b	333	long filenames_cookie;
9889c728 JB	334	struct exec hdr;
	335
	336	/*
	337	* Open an executable and check for a valid header!
a783251b	338	* Can't bcmp the header with what we had, it may have been stripped!
9889c728 JB	339	* so we may save looking at non executables with the same name, mostly
	340	* directories.
	341	*/
a783251b	342	fd = open (filename, O_RDONLY);
9889c728 JB	343	if (fd != -1)
	344	{
	345	if (read (fd, &hdr, sizeof (hdr)) == sizeof (hdr)
	346	&& !N_BADMAG (hdr) && N_DATOFF (hdr) == N_DATOFF (nhdr)
	347	&& N_TRELOFF (hdr) == N_TRELOFF (nhdr))
	348	{
	349	/* compare cookies */
	350	lseek (fd, N_DATOFF (hdr) + (int)&cookie - N_DATADDR (hdr), L_SET);
a783251b RS	351	read (fd, &filenames_cookie, sizeof (filenames_cookie));
a783251b RS	352	if (filenames_cookie == cookie)
9889c728 JB	353	{ /* Eureka */
	354
	355	/*
	356	* Do the mapping
	357	* The PROT_EXEC may not be needed, but it is safer this way.
	358	* should the shared library decide to indirect through
	359	* addresses in the data segment not part of __DYNAMIC
	360	*/
	361	mmap (data_start, rd_only_len, PROT_READ \| PROT_EXEC,
3b95c869	362	MAP_FILE \| MAP_SHARED \| MAP_FIXED, fd,
9889c728 JB	363	N_DATOFF (hdr) + data_start - N_DATADDR (hdr));
	364	close (fd);
	365	return 1;
	366	}
	367	}
	368	close (fd);
	369	}
	370	return 0;
	371	}