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

/* Dump Emacs in macho format.
   Copyright (C) 1990, 1993 Free Software Foundation, Inc.
   Written by Bradley Taylor (btaylor@next.com).

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, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


#undef __STRICT_BSD__

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <mach/mach.h>
#include <mach-o/loader.h>
#include <mach-o/reloc.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <libc.h>


int malloc_cookie;

/*
 * Kludge: we don't expect any program data beyond VM_HIGHDATA
 * What is really needed is a way to find out from malloc() which
 * pages it vm_allocated and write only those out into the data segment.
 *
 * This kludge may break when we stop using fixed virtual address
 * shared libraries. Actually, emacs will probably continue working, but be 
 * much larger on disk than it needs to be (because non-malloced data will
 * be in the file).
 */
static const unsigned VM_HIGHDATA = 0x2000000;

typedef struct region_t {
	vm_address_t address;
	vm_size_t size;
	vm_prot_t protection;
	vm_prot_t max_protection;
	vm_inherit_t inheritance;
	boolean_t shared;
	port_t object_name;
	vm_offset_t offset;
} region_t;


static void
grow(
     struct load_command ***the_commands,
     unsigned *the_commands_len
     )
{
	if (*the_commands == NULL) {
		*the_commands_len = 1;
		*the_commands = malloc(sizeof(*the_commands));
	} else {
		(*the_commands_len)++;
		*the_commands = realloc(*the_commands, 
					(*the_commands_len *
					 sizeof(**the_commands)));
	}
}


static void
save_command(
	     struct load_command *command,
	     struct load_command ***the_commands,
	     unsigned *the_commands_len
	     )
{
	struct load_command **tmp;

	grow(the_commands, the_commands_len);
	tmp = &(*the_commands)[*the_commands_len - 1];
	*tmp = malloc(command->cmdsize);
	bcopy(command, *tmp, command->cmdsize);
}

static void
fatal_unexec(char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	fprintf(stderr, "unexec: ");
	vfprintf(stderr, format, ap);
	fprintf(stderr, "\n");
	va_end(ap);
}

static int
read_macho(
	   int fd,
	   struct mach_header *the_header,
	   struct load_command ***the_commands,
	   unsigned *the_commands_len
	   )
{
	struct load_command command;
	struct load_command *buf;
	int i;
	int size;

	if (read(fd, the_header, sizeof(*the_header)) != sizeof(*the_header)) {
		fatal_unexec("cannot read macho header");
		return (0);
	}
	for (i = 0; i < the_header->ncmds; i++) {
		if (read(fd, &command, sizeof(struct load_command)) != 
		    sizeof(struct load_command)) {
		  	fatal_unexec("cannot read macho load command header");
			return (0);
		}
		size = command.cmdsize - sizeof(struct load_command);
		if (size < 0) {
		  	fatal_unexec("bogus load command size");
			return (0);
		}
		buf = malloc(command.cmdsize);
		buf->cmd = command.cmd;
		buf->cmdsize = command.cmdsize;
		if (read(fd, ((char *)buf + 
			      sizeof(struct load_command)), 
			 size) != size) {
		  	fatal_unexec("cannot read load command data");
			return (0);
		}
		save_command(buf, the_commands, the_commands_len);
	}
	return (1);
}

static int
filldatagap(
	    vm_address_t start_address,
	    vm_size_t *size,
	    vm_address_t end_address
	    )
{
	vm_address_t address;
	vm_size_t gapsize;

	address = (start_address + *size);
	gapsize = end_address - address;
	*size += gapsize;
	if (vm_allocate(task_self(), &address, gapsize,
			FALSE) != KERN_SUCCESS) {
		fatal_unexec("cannot vm_allocate");
	        return (0);
	}
	return (1);
}

static int
get_data_region(
		vm_address_t *address,
		vm_size_t *size
		)
{
	region_t region;
	kern_return_t ret;
	struct section *sect;

	sect = (struct section *) getsectbyname(SEG_DATA, SECT_DATA);
	region.address = 0;
	*address = 0;
	for (;;) {
		ret = vm_region(task_self(), 
				&region.address, 
				&region.size, 
				&region.protection, 
				&region.max_protection, 
				&region.inheritance,
				&region.shared, 
				&region.object_name, 
				&region.offset);
		if (ret != KERN_SUCCESS || region.address >= VM_HIGHDATA) {
			break;
		}
		if (*address != 0) {
			if (region.address > *address + *size) {
				if (!filldatagap(*address, size, 
						 region.address)) {
					return (0);
				}
			} 
			*size += region.size;
		} else {
			if (region.address == sect->addr) {
				*address = region.address;
				*size = region.size;
			} 
		}
		region.address += region.size;
	}
	return (1);
}

static char *
my_malloc(
	  vm_size_t size
	  )
{
	vm_address_t address;

	if (vm_allocate(task_self(), &address, size, TRUE) != KERN_SUCCESS) {
		return (NULL);
	}
	return ((char *)address);
}

static void
my_free(
	char *buf,
	vm_size_t size
	)
{
	vm_deallocate(task_self(), (vm_address_t)buf, size);
}

static int
unexec_doit(
	    int infd,
	    int outfd
	    )
{
	int i;
	struct load_command **the_commands = NULL;
	unsigned the_commands_len;
	struct mach_header the_header;
	int fgrowth = 0;
	int fdatastart;
	int fdatasize;
	int size;
	struct stat st;
	char *buf;
	vm_address_t data_address;
	vm_size_t data_size;
	vm_size_t vmaddr_growth = 0;
	vm_size_t dataseg_vmaddr, dataseg_vmend;

	struct segment_command *segment;

#ifdef NS_TARGET
	unsigned long extreloff = 0;
	unsigned long nextrel = 0;
	struct dysymtab_command *dysymtab;
	struct relocation_info reloc_info;
#endif

	if (!read_macho(infd, &the_header, &the_commands, &the_commands_len)) {
		return (0);
	}


	malloc_cookie = malloc_freezedry ();
	if (!get_data_region(&data_address, &data_size)) {
		return (0);
	}


	/*
	 * DO NOT USE MALLOC IN THIS SECTION
	 */
	{
		/*
		 * Fix offsets
		 */
		for (i = 0; i < the_commands_len; i++) {
			switch (the_commands[i]->cmd) {
			case LC_SEGMENT:
				segment = ((struct segment_command *)
					   the_commands[i]);
				if (strcmp(segment->segname, SEG_DATA) == 0) {
					fdatastart = segment->fileoff;
					fdatasize = segment->filesize;
					fgrowth = (data_size - 
						   segment->filesize);
					segment->vmsize = data_size;
					segment->filesize = data_size;
					dataseg_vmaddr = segment->vmaddr;
					dataseg_vmend = segment->vmaddr + segment->vmsize;
					vmaddr_growth = segment->vmaddr + segment->vmsize;
				} else {
					((struct segment_command *)the_commands[i])->fileoff += fgrowth;
				}

				if( strcmp( segment->segname, SEG_LINKEDIT ) == 0 ) {
					segment->vmaddr = vmaddr_growth;
				}

				break;
			case LC_SYMTAB:
				((struct symtab_command *)
				 the_commands[i])->symoff += fgrowth;
				((struct symtab_command *)
				 the_commands[i])->stroff += fgrowth;
				break;
			case LC_SYMSEG:
				((struct symseg_command *)
				 the_commands[i])->offset += fgrowth;
				break;
#ifdef NS_TARGET
			case LC_DYSYMTAB:
				dysymtab = ((struct dysymtab_command *)the_commands[i]);
				extreloff = dysymtab->extreloff;
				nextrel = dysymtab->nextrel;
				dysymtab->indirectsymoff += fgrowth;
				dysymtab->extreloff += fgrowth;
				break;
#endif
			default:
				break;
			}
		}
		
		/*
		 * Write header
		 */
		if (write(outfd, &the_header, 
			  sizeof(the_header)) != sizeof(the_header)) {
			fatal_unexec("cannot write output file");
			return (0);
		}
		
		/*
		 * Write commands
		 */
		for (i = 0; i < the_commands_len; i++) {
			if (write(outfd, the_commands[i], 
				  the_commands[i]->cmdsize) != 
			    the_commands[i]->cmdsize) {
			  	fatal_unexec("cannot write output file");
				return (0);
			}
		}
		
		/*
		 * Write original text
		 */
		if (lseek(infd, the_header.sizeofcmds + sizeof(the_header), 
			  L_SET) < 0) {
		  	fatal_unexec("cannot seek input file");
			return (0);
		}
		size = fdatastart - (sizeof(the_header) + 
				     the_header.sizeofcmds);
		buf = my_malloc(size);
		if (read(infd, buf, size) != size) {
			my_free(buf, size);
		  	fatal_unexec("cannot read input file");
		}
		if (write(outfd, buf, size) != size) {
			my_free(buf, size);
			fatal_unexec("cannot write output file");
			return (0);
		}
		my_free(buf, size);
		
		
		/*
		 * Write new data
		 */
		if (write(outfd, (char *)data_address, 
			  data_size) != data_size) {
			fatal_unexec("cannot write output file");
			return (0);
		}
		
	}

	/*
	 * OKAY TO USE MALLOC NOW
	 */

	/*
	 * Write rest of file
	 */
	fstat(infd, &st);
	if (lseek(infd, fdatasize, L_INCR) < 0) {
		fatal_unexec("cannot seek input file");
		return (0);
	}
	size = st.st_size - lseek(infd, 0, L_INCR);

	buf = malloc(size);
	if (read(infd, buf, size) != size) {
		free(buf);
		fatal_unexec("cannot read input file");
		return (0);
	}
	if (write(outfd, buf, size) != size) {
		free(buf);
		fatal_unexec("cannot write output file");
		return (0);
	}
	free(buf);

#ifdef NS_TARGET
        /*
         * Fix up relocation entries in the data segment.
         */

	if (lseek(infd, extreloff, L_SET) < 0) {
		fatal_unexec("cannot seek input file");
		return (0);
	}
        
        for (i = 0; i < nextrel; i++)
        {
          long zeroval = 0;

          if (read(infd, &reloc_info, sizeof (reloc_info)) != sizeof (reloc_info)) {
            fatal_unexec("cannot read input file");
            return (0);
          }
          if (reloc_info.r_address >= dataseg_vmaddr && reloc_info.r_address < dataseg_vmend)
          {
            if (lseek (outfd, fdatastart + reloc_info.r_address - dataseg_vmaddr, L_SET) < 0 ) {
              fatal_unexec("cannot seek input file");
              return (0);
            }
            switch (reloc_info.r_length) {
              case 0:
		if (write(outfd, &zeroval, 1) != 1) {
			fatal_unexec("cannot write output file");
			return (0);
		}
                break;
              case 1:
		if (write(outfd, &zeroval, 2) != 2) {
			fatal_unexec("cannot write output file");
			return (0);
		}
                break;
              case 2:
		if (write(outfd, &zeroval, 4) != 4) {
			fatal_unexec("cannot write output file");
			return (0);
		}
                break;
            }
          }
        }
#endif

	return (1);
}

void
unexec(
       char *outfile,
       char *infile
       )
{
	int infd;
	int outfd;
	char tmpbuf[L_tmpnam];
	char *tmpfile;

	infd = open(infile, O_RDONLY, 0);
	if (infd < 0) {
	  	fatal_unexec("cannot open input file `%s'", infile);
		exit(1);
	}
	
	tmpnam(tmpbuf);
	tmpfile = rindex(tmpbuf, '/');
	if (tmpfile == NULL) {
		tmpfile = tmpbuf;
	} else {
		tmpfile++;
	}
	outfd = open(tmpfile, O_WRONLY|O_TRUNC|O_CREAT, 0755);
	if (outfd < 0) {
		close(infd);
		fatal_unexec("cannot open tmp file `%s'", tmpfile);
		exit(1);
	}
	if (!unexec_doit(infd, outfd)) {
		close(infd);
		close(outfd);
		unlink(tmpfile);
		exit(1);
	}
	close(infd);
	close(outfd);
	if (rename(tmpfile, outfile) < 0) {
		unlink(tmpfile);
		fatal_unexec("cannot rename `%s' to `%s'", tmpfile, outfile);
		exit(1);
	}
}
Commit	Line	Data
5743648e	1	/* Dump Emacs in macho format.
f80dc888	2	Copyright (C) 1990, 1993 Free Software Foundation, Inc.
5743648e RS	3	Written by Bradley Taylor (btaylor@next.com).
	4
	5	This file is part of GNU Emacs.
	6
	7	GNU Emacs is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
f80dc888	9	the Free Software Foundation; either version 2, or (at your option)
5743648e RS	10	any later version.
	11
	12	GNU Emacs is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GNU Emacs; see the file COPYING. If not, write to
3b7ad313 EN	19	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
3b7ad313 EN	20	Boston, MA 02111-1307, USA. */
5743648e RS	21
	22
	23	#undef __STRICT_BSD__
	24
	25	#include <stdio.h>
	26	#include <stdlib.h>
	27	#include <stdarg.h>
f80dc888 JB	28	#include <mach/mach.h>
f80dc888 JB	29	#include <mach-o/loader.h>
acacb292	30	#include <mach-o/reloc.h>
5743648e RS	31	#include <sys/file.h>
	32	#include <sys/stat.h>
	33	#include <libc.h>
	34
	35
f80dc888	36	int malloc_cookie;
5743648e RS	37
	38	/*
	39	* Kludge: we don't expect any program data beyond VM_HIGHDATA
	40	* What is really needed is a way to find out from malloc() which
	41	* pages it vm_allocated and write only those out into the data segment.
	42	*
	43	* This kludge may break when we stop using fixed virtual address
	44	* shared libraries. Actually, emacs will probably continue working, but be
	45	* much larger on disk than it needs to be (because non-malloced data will
	46	* be in the file).
	47	*/
	48	static const unsigned VM_HIGHDATA = 0x2000000;
	49
	50	typedef struct region_t {
	51	vm_address_t address;
	52	vm_size_t size;
	53	vm_prot_t protection;
	54	vm_prot_t max_protection;
	55	vm_inherit_t inheritance;
	56	boolean_t shared;
	57	port_t object_name;
	58	vm_offset_t offset;
	59	} region_t;
	60
	61
	62	static void
	63	grow(
	64	struct load_command ***the_commands,
	65	unsigned *the_commands_len
	66	)
	67	{
	68	if (*the_commands == NULL) {
	69	*the_commands_len = 1;
	70	the_commands = malloc(sizeof(the_commands));
	71	} else {
	72	(*the_commands_len)++;
	73	the_commands = realloc(the_commands,
	74	(the_commands_len
	75	sizeof(**the_commands)));
	76	}
	77	}
	78
	79
	80	static void
	81	save_command(
	82	struct load_command *command,
	83	struct load_command ***the_commands,
	84	unsigned *the_commands_len
	85	)
	86	{
	87	struct load_command **tmp;
	88
	89	grow(the_commands, the_commands_len);
	90	tmp = &(the_commands)[the_commands_len - 1];
	91	*tmp = malloc(command->cmdsize);
	92	bcopy(command, *tmp, command->cmdsize);
	93	}
	94
	95	static void
	96	fatal_unexec(char *format, ...)
	97	{
	98	va_list ap;
	99
	100	va_start(ap, format);
101	fprintf(stderr, "unexec: ");
102	vfprintf(stderr, format, ap);
103	fprintf(stderr, "\n");
104	va_end(ap);
105	}
106
107	static int
108	read_macho(
109	int fd,
110	struct mach_header *the_header,
111	struct load_command ***the_commands,
112	unsigned *the_commands_len
113	)
114	{
115	struct load_command command;
116	struct load_command *buf;
117	int i;
118	int size;
119
120	if (read(fd, the_header, sizeof(the_header)) != sizeof(the_header)) {
121	fatal_unexec("cannot read macho header");
122	return (0);
123	}
124	for (i = 0; i < the_header->ncmds; i++) {
125	if (read(fd, &command, sizeof(struct load_command)) !=
126	sizeof(struct load_command)) {
127	fatal_unexec("cannot read macho load command header");
128	return (0);
129	}
130	size = command.cmdsize - sizeof(struct load_command);
131	if (size < 0) {
132	fatal_unexec("bogus load command size");
133	return (0);
134	}
135	buf = malloc(command.cmdsize);
136	buf->cmd = command.cmd;
137	buf->cmdsize = command.cmdsize;
138	if (read(fd, ((char *)buf +
139	sizeof(struct load_command)),
140	size) != size) {
141	fatal_unexec("cannot read load command data");
142	return (0);
143	}
144	save_command(buf, the_commands, the_commands_len);
145	}
146	return (1);
147	}
148
149	static int
150	filldatagap(
151	vm_address_t start_address,
152	vm_size_t *size,
153	vm_address_t end_address
154	)
155	{
156	vm_address_t address;
157	vm_size_t gapsize;
158
159	address = (start_address + *size);
160	gapsize = end_address - address;
161	*size += gapsize;
162	if (vm_allocate(task_self(), &address, gapsize,
163	FALSE) != KERN_SUCCESS) {
164	fatal_unexec("cannot vm_allocate");
165	return (0);
166	}
167	return (1);
168	}
169
170	static int
171	get_data_region(
172	vm_address_t *address,
173	vm_size_t *size
174	)
175	{
176	region_t region;
177	kern_return_t ret;
178	struct section *sect;
179
6930925e	180	sect = (struct section *) getsectbyname(SEG_DATA, SECT_DATA);
5743648e RS	181	region.address = 0;
	182	*address = 0;
	183	for (;;) {
	184	ret = vm_region(task_self(),
	185	&region.address,
	186	&region.size,
	187	&region.protection,
	188	&region.max_protection,
	189	&region.inheritance,
	190	&region.shared,
	191	&region.object_name,
	192	&region.offset);
	193	if (ret != KERN_SUCCESS \|\| region.address >= VM_HIGHDATA) {
	194	break;
	195	}
	196	if (*address != 0) {
	197	if (region.address > address + size) {
	198	if (!filldatagap(*address, size,
	199	region.address)) {
	200	return (0);
	201	}
	202	}
	203	*size += region.size;
	204	} else {
	205	if (region.address == sect->addr) {
	206	*address = region.address;
	207	*size = region.size;
	208	}
	209	}
	210	region.address += region.size;
	211	}
	212	return (1);
	213	}
	214
	215	static char *
	216	my_malloc(
	217	vm_size_t size
	218	)
	219	{
	220	vm_address_t address;
	221
	222	if (vm_allocate(task_self(), &address, size, TRUE) != KERN_SUCCESS) {
	223	return (NULL);
	224	}
	225	return ((char *)address);
	226	}
	227
	228	static void
	229	my_free(
	230	char *buf,
	231	vm_size_t size
	232	)
	233	{
	234	vm_deallocate(task_self(), (vm_address_t)buf, size);
	235	}
	236
	237	static int
	238	unexec_doit(
	239	int infd,
	240	int outfd
	241	)
	242	{
	243	int i;
	244	struct load_command **the_commands = NULL;
245	unsigned the_commands_len;
246	struct mach_header the_header;
acacb292	247	int fgrowth = 0;
5743648e RS	248	int fdatastart;
	249	int fdatasize;
	250	int size;
	251	struct stat st;
	252	char *buf;
	253	vm_address_t data_address;
	254	vm_size_t data_size;
acacb292 RS	255	vm_size_t vmaddr_growth = 0;
acacb292 RS	256	vm_size_t dataseg_vmaddr, dataseg_vmend;
5743648e RS	257
	258	struct segment_command *segment;
	259
acacb292 RS	260	#ifdef NS_TARGET
	261	unsigned long extreloff = 0;
	262	unsigned long nextrel = 0;
	263	struct dysymtab_command *dysymtab;
	264	struct relocation_info reloc_info;
	265	#endif
	266
5743648e RS	267	if (!read_macho(infd, &the_header, &the_commands, &the_commands_len)) {
	268	return (0);
	269	}
	270
	271
f80dc888	272	malloc_cookie = malloc_freezedry ();
5743648e RS	273	if (!get_data_region(&data_address, &data_size)) {
	274	return (0);
	275	}
	276
	277
	278	/*
	279	* DO NOT USE MALLOC IN THIS SECTION
	280	*/
	281	{
	282	/*
	283	* Fix offsets
	284	*/
	285	for (i = 0; i < the_commands_len; i++) {
	286	switch (the_commands[i]->cmd) {
	287	case LC_SEGMENT:
	288	segment = ((struct segment_command *)
	289	the_commands[i]);
	290	if (strcmp(segment->segname, SEG_DATA) == 0) {
	291	fdatastart = segment->fileoff;
	292	fdatasize = segment->filesize;
	293	fgrowth = (data_size -
	294	segment->filesize);
	295	segment->vmsize = data_size;
	296	segment->filesize = data_size;
acacb292 RS	297	dataseg_vmaddr = segment->vmaddr;
	298	dataseg_vmend = segment->vmaddr + segment->vmsize;
	299	vmaddr_growth = segment->vmaddr + segment->vmsize;
	300	} else {
	301	((struct segment_command *)the_commands[i])->fileoff += fgrowth;
	302	}
	303
	304	if( strcmp( segment->segname, SEG_LINKEDIT ) == 0 ) {
	305	segment->vmaddr = vmaddr_growth;
5743648e	306	}
acacb292	307
5743648e RS	308	break;
	309	case LC_SYMTAB:
	310	((struct symtab_command *)
	311	the_commands[i])->symoff += fgrowth;
	312	((struct symtab_command *)
	313	the_commands[i])->stroff += fgrowth;
	314	break;
	315	case LC_SYMSEG:
	316	((struct symseg_command *)
	317	the_commands[i])->offset += fgrowth;
	318	break;
acacb292 RS	319	#ifdef NS_TARGET
	320	case LC_DYSYMTAB:
	321	dysymtab = ((struct dysymtab_command *)the_commands[i]);
	322	extreloff = dysymtab->extreloff;
	323	nextrel = dysymtab->nextrel;
	324	dysymtab->indirectsymoff += fgrowth;
	325	dysymtab->extreloff += fgrowth;
	326	break;
	327	#endif
5743648e RS	328	default:
	329	break;
	330	}
	331	}
	332
	333	/*
	334	* Write header
	335	*/
	336	if (write(outfd, &the_header,
	337	sizeof(the_header)) != sizeof(the_header)) {
	338	fatal_unexec("cannot write output file");
	339	return (0);
	340	}
	341
	342	/*
	343	* Write commands
	344	*/
	345	for (i = 0; i < the_commands_len; i++) {
	346	if (write(outfd, the_commands[i],
	347	the_commands[i]->cmdsize) !=
	348	the_commands[i]->cmdsize) {
	349	fatal_unexec("cannot write output file");
	350	return (0);
	351	}
	352	}
	353
	354	/*
	355	* Write original text
	356	*/
	357	if (lseek(infd, the_header.sizeofcmds + sizeof(the_header),
	358	L_SET) < 0) {
	359	fatal_unexec("cannot seek input file");
	360	return (0);
	361	}
	362	size = fdatastart - (sizeof(the_header) +
	363	the_header.sizeofcmds);
	364	buf = my_malloc(size);
	365	if (read(infd, buf, size) != size) {
	366	my_free(buf, size);
	367	fatal_unexec("cannot read input file");
	368	}
	369	if (write(outfd, buf, size) != size) {
	370	my_free(buf, size);
	371	fatal_unexec("cannot write output file");
	372	return (0);
	373	}
	374	my_free(buf, size);
	375
	376
	377	/*
	378	* Write new data
	379	*/
	380	if (write(outfd, (char *)data_address,
	381	data_size) != data_size) {
	382	fatal_unexec("cannot write output file");
	383	return (0);
	384	}
	385
	386	}
	387
	388	/*
	389	* OKAY TO USE MALLOC NOW
	390	*/
	391
392	/*
393	* Write rest of file
394	*/
395	fstat(infd, &st);
396	if (lseek(infd, fdatasize, L_INCR) < 0) {
397	fatal_unexec("cannot seek input file");
398	return (0);
399	}
400	size = st.st_size - lseek(infd, 0, L_INCR);
401
402	buf = malloc(size);
403	if (read(infd, buf, size) != size) {
404	free(buf);
405	fatal_unexec("cannot read input file");
406	return (0);
407	}
408	if (write(outfd, buf, size) != size) {
409	free(buf);
410	fatal_unexec("cannot write output file");
411	return (0);
412	}
413	free(buf);
acacb292 RS	414
	415	#ifdef NS_TARGET
	416	/*
	417	* Fix up relocation entries in the data segment.
	418	*/
	419
	420	if (lseek(infd, extreloff, L_SET) < 0) {
	421	fatal_unexec("cannot seek input file");
	422	return (0);
	423	}
	424
	425	for (i = 0; i < nextrel; i++)
	426	{
	427	long zeroval = 0;
	428
	429	if (read(infd, &reloc_info, sizeof (reloc_info)) != sizeof (reloc_info)) {
	430	fatal_unexec("cannot read input file");
	431	return (0);
	432	}
	433	if (reloc_info.r_address >= dataseg_vmaddr && reloc_info.r_address < dataseg_vmend)
	434	{
	435	if (lseek (outfd, fdatastart + reloc_info.r_address - dataseg_vmaddr, L_SET) < 0 ) {
	436	fatal_unexec("cannot seek input file");
	437	return (0);
	438	}
	439	switch (reloc_info.r_length) {
	440	case 0:
	441	if (write(outfd, &zeroval, 1) != 1) {
	442	fatal_unexec("cannot write output file");
	443	return (0);
	444	}
	445	break;
	446	case 1:
	447	if (write(outfd, &zeroval, 2) != 2) {
	448	fatal_unexec("cannot write output file");
	449	return (0);
	450	}
	451	break;
	452	case 2:
	453	if (write(outfd, &zeroval, 4) != 4) {
	454	fatal_unexec("cannot write output file");
	455	return (0);
	456	}
	457	break;
	458	}
	459	}
	460	}
	461	#endif
	462
5743648e RS	463	return (1);
	464	}
	465
	466	void
	467	unexec(
	468	char *outfile,
	469	char *infile
	470	)
	471	{
	472	int infd;
	473	int outfd;
	474	char tmpbuf[L_tmpnam];
	475	char *tmpfile;
	476
	477	infd = open(infile, O_RDONLY, 0);
	478	if (infd < 0) {
	479	fatal_unexec("cannot open input file `%s'", infile);
	480	exit(1);
	481	}
	482
	483	tmpnam(tmpbuf);
	484	tmpfile = rindex(tmpbuf, '/');
	485	if (tmpfile == NULL) {
	486	tmpfile = tmpbuf;
	487	} else {
	488	tmpfile++;
	489	}
	490	outfd = open(tmpfile, O_WRONLY\|O_TRUNC\|O_CREAT, 0755);
	491	if (outfd < 0) {
	492	close(infd);
	493	fatal_unexec("cannot open tmp file `%s'", tmpfile);
	494	exit(1);
	495	}
	496	if (!unexec_doit(infd, outfd)) {
	497	close(infd);
	498	close(outfd);
	499	unlink(tmpfile);
	500	exit(1);
	501	}
	502	close(infd);
	503	close(outfd);
	504	if (rename(tmpfile, outfile) < 0) {
	505	unlink(tmpfile);
	506	fatal_unexec("cannot rename `%s' to `%s'", tmpfile, outfile);
	507	exit(1);
	508	}
	509	}