|
0
|
1 /* Unexec for Xenix.
|
|
|
2 Copyright (C) 1988, 1994 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of XEmacs.
|
|
|
5
|
|
|
6 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by the
|
|
|
8 Free Software Foundation; either version 2, or (at your option) any
|
|
|
9 later version.
|
|
|
10
|
|
|
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with XEmacs; see the file COPYING. If not, write to
|
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
|
20
|
|
|
21 /* Synched up with: FSF 19.31. */
|
|
|
22
|
|
|
23
|
|
|
24
|
|
|
25 /*
|
|
|
26 On 80386 Xenix, segmentation screws prevent us from modifying the text
|
|
|
27 segment at all. We basically just plug a new value for "data segment
|
|
|
28 size" into the countless headers and copy the other records straight
|
|
|
29 through. The data segment is ORG'ed at the xs_rbase value of the data
|
|
|
30 segment's xseg record (always @ 0x1880000, thanks to the "sophisticated
|
|
|
31 memory management hardware" of the chip) and extends to sbrk(0), exactly.
|
|
|
32 This code is afraid to malloc (should it be?), and alloca has to be the
|
|
|
33 wimpy, malloc-based version; consequently, data is usually copied in
|
|
|
34 smallish chunks.
|
|
|
35
|
|
|
36 gb@entity.com
|
|
|
37 */
|
|
|
38
|
|
|
39 #include <config.h>
|
|
|
40 #include <sys/types.h>
|
|
|
41 #include <fcntl.h>
|
|
|
42 #include <sys/file.h>
|
|
|
43 #include <sys/stat.h>
|
|
|
44 #include <stdio.h>
|
|
|
45 #include <varargs.h>
|
|
|
46 #include <a.out.h>
|
|
2286
|
47 #include "compiler.h"
|
|
0
|
48
|
|
|
49 static void fatal_unexec ();
|
|
|
50
|
|
|
51 #define READ(_fd, _buffer, _size, _error_message, _error_arg) \
|
|
|
52 errno = EEOF; \
|
|
|
53 if (read(_fd, _buffer, _size) != _size) \
|
|
|
54 fatal_unexec(_error_message, _error_arg);
|
|
|
55
|
|
|
56 #define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
|
|
|
57 if (write(_fd, _buffer, _size) != _size) \
|
|
|
58 fatal_unexec(_error_message, _error_arg);
|
|
|
59
|
|
|
60 #define SEEK(_fd, _position, _error_message, _error_arg) \
|
|
|
61 errno = EEOF; \
|
|
|
62 if (lseek(_fd, _position, L_SET) != _position) \
|
|
|
63 fatal_unexec(_error_message, _error_arg);
|
|
|
64
|
|
|
65 extern int errno;
|
|
|
66 extern char *strerror ();
|
|
|
67 #define EEOF -1
|
|
|
68
|
|
|
69 #ifndef L_SET
|
|
|
70 #define L_SET 0
|
|
|
71 #endif
|
|
|
72
|
|
|
73 /* Should check the magic number of the old executable;
|
|
|
74 not yet written. */
|
|
|
75 check_exec (x)
|
|
2286
|
76 struct xexec *UNUSED (x);
|
|
0
|
77 {
|
|
|
78 }
|
|
|
79
|
|
|
80
|
|
|
81 unexec (new_name, a_name, data_start, bss_start, entry_address)
|
|
|
82 char *new_name, *a_name;
|
|
2286
|
83 unsigned UNUSED (data_start);
|
|
|
84 unsigned UNUSED (bss_start);
|
|
|
85 unsigned UNUSED (entry_address);
|
|
0
|
86 {
|
|
|
87 char *sbrk (), *datalim = sbrk (0), *data_org;
|
|
|
88 long segpos, textseen, textpos, textlen, datapos, datadiff, datalen;
|
|
|
89
|
|
|
90 struct xexec u_xexec, /* a.out header */
|
|
|
91 *u_xexecp = &u_xexec;
|
|
|
92 struct xext u_xext, /* extended header */
|
|
|
93 *u_xextp = &u_xext;
|
|
|
94 struct xseg u_xseg, /* segment table entry */
|
|
|
95 *u_xsegp = &u_xseg;
|
|
|
96 int i, nsegs, isdata = 0, infd, outfd;
|
|
|
97
|
|
|
98 infd = open (a_name, O_RDONLY, 0);
|
|
|
99 if (infd < 0) fatal_unexec ("opening %s", a_name);
|
|
|
100
|
|
|
101 outfd = creat (new_name, 0666);
|
|
|
102 if (outfd < 0) fatal_unexec ("creating %s", new_name);
|
|
|
103
|
|
|
104 READ (infd, u_xexecp, sizeof (struct xexec),
|
|
|
105 "error reading %s", a_name);
|
|
|
106 check_exec (u_xexecp);
|
|
|
107 READ (infd, u_xextp, sizeof (struct xext),
|
|
|
108 "error reading %s", a_name);
|
|
|
109 segpos = u_xextp->xe_segpos;
|
|
|
110 nsegs = u_xextp->xe_segsize / sizeof (struct xseg);
|
|
|
111 SEEK (infd, segpos, "seek error on %s", a_name);
|
|
|
112 for (i = 0; i < nsegs; i ++)
|
|
|
113 {
|
|
|
114 READ (infd, u_xsegp, sizeof (struct xseg),
|
|
|
115 "error reading %s", a_name);
|
|
|
116 switch (u_xsegp->xs_type)
|
|
|
117 {
|
|
|
118 case XS_TTEXT:
|
|
|
119 {
|
|
|
120 if (i == 0)
|
|
|
121 {
|
|
|
122 textpos = u_xsegp->xs_filpos;
|
|
|
123 textlen = u_xsegp->xs_psize;
|
|
|
124 break;
|
|
|
125 }
|
|
|
126 fatal_unexec ("invalid text segment in %s", a_name);
|
|
|
127 }
|
|
|
128 case XS_TDATA:
|
|
|
129 {
|
|
|
130 if (i == 1)
|
|
|
131 {
|
|
|
132 datapos = u_xsegp->xs_filpos;
|
|
|
133 datalen = datalim - (data_org = (char *)(u_xsegp->xs_rbase));
|
|
|
134 datadiff = datalen - u_xsegp->xs_psize;
|
|
|
135 break;
|
|
|
136 }
|
|
|
137 fatal_unexec ("invalid data segment in %s", a_name);
|
|
|
138 }
|
|
|
139 default:
|
|
|
140 {
|
|
|
141 if (i > 1) break;
|
|
|
142 fatal_unexec ("invalid segment record in %s", a_name);
|
|
|
143 }
|
|
|
144 }
|
|
|
145 }
|
|
|
146 u_xexecp->x_data = datalen;
|
|
|
147 u_xexecp->x_bss = 0;
|
|
|
148 WRITE (outfd, u_xexecp, sizeof (struct xexec),
|
|
|
149 "error writing %s", new_name);
|
|
|
150 WRITE (outfd, u_xextp, sizeof (struct xext),
|
|
|
151 "error writing %s", new_name);
|
|
|
152 SEEK (infd, segpos, "seek error on %s", a_name);
|
|
|
153 SEEK (outfd, segpos, "seek error on %s", new_name);
|
|
|
154
|
|
|
155 /* Copy the text segment record verbatim. */
|
|
|
156
|
|
|
157 copyrec (infd, outfd, sizeof (struct xseg), a_name, new_name);
|
|
|
158
|
|
|
159 /* Read, modify, write the data segment record. */
|
|
|
160
|
|
|
161 READ (infd, u_xsegp, sizeof (struct xseg),
|
|
|
162 "error reading %s", a_name);
|
|
|
163 u_xsegp->xs_psize = u_xsegp->xs_vsize = datalen;
|
|
|
164 u_xsegp->xs_attr &= (~XS_AITER & ~XS_ABSS);
|
|
|
165 WRITE (outfd, u_xsegp, sizeof (struct xseg),
|
|
|
166 "error writing %s", new_name);
|
|
|
167
|
|
|
168 /* Now copy any additional segment records, adjusting their
|
|
|
169 file position field */
|
|
|
170
|
|
|
171 for (i = 2; i < nsegs; i++)
|
|
|
172 {
|
|
|
173 READ (infd, u_xsegp, sizeof (struct xseg),
|
|
|
174 "error reading %s", a_name);
|
|
|
175 u_xsegp->xs_filpos += datadiff;
|
|
|
176 WRITE (outfd, u_xsegp, sizeof (struct xseg),
|
|
|
177 "error writing %s", new_name);
|
|
|
178 }
|
|
|
179
|
|
|
180 SEEK (infd, textpos, "seek error on %s", a_name);
|
|
|
181 SEEK (outfd, textpos, "seek error on %s", new_name);
|
|
|
182 copyrec (infd, outfd, textlen, a_name, new_name);
|
|
|
183
|
|
|
184 SEEK (outfd, datapos, "seek error on %s", new_name);
|
|
|
185 WRITE (outfd, data_org, datalen,
|
|
|
186 "write error on %s", new_name);
|
|
|
187
|
|
|
188 for (i = 2, segpos += (2 * sizeof (struct xseg));
|
|
|
189 i < nsegs;
|
|
|
190 i++, segpos += sizeof (struct xseg))
|
|
|
191 {
|
|
|
192 SEEK (infd, segpos, "seek error on %s", a_name);
|
|
|
193 READ (infd, u_xsegp, sizeof (struct xseg),
|
|
|
194 "read error on %s", a_name);
|
|
|
195 SEEK (infd, u_xsegp->xs_filpos, "seek error on %s", a_name);
|
|
|
196 /* We should be at eof in the output file here, but we must seek
|
|
|
197 because the xs_filpos and xs_psize fields in symbol table
|
|
|
198 segments are inconsistent. */
|
|
|
199 SEEK (outfd, u_xsegp->xs_filpos + datadiff, "seek error on %s", new_name);
|
|
|
200 copyrec (infd, outfd, u_xsegp->xs_psize, a_name, new_name);
|
|
|
201 }
|
|
|
202 close (infd);
|
|
|
203 close (outfd);
|
|
|
204 mark_x (new_name);
|
|
|
205 return 0;
|
|
|
206 }
|
|
|
207
|
|
|
208 copyrec (infd, outfd, len, in_name, out_name)
|
|
|
209 int infd, outfd, len;
|
|
|
210 char *in_name, *out_name;
|
|
|
211 {
|
|
|
212 char buf[BUFSIZ];
|
|
|
213 int chunk;
|
|
|
214
|
|
|
215 while (len)
|
|
|
216 {
|
|
|
217 chunk = BUFSIZ;
|
|
|
218 if (chunk > len)
|
|
|
219 chunk = len;
|
|
|
220 READ (infd, buf, chunk, "error reading %s", in_name);
|
|
|
221 WRITE (outfd, buf, chunk, "error writing %s", out_name);
|
|
|
222 len -= chunk;
|
|
|
223 }
|
|
|
224 }
|
|
|
225
|
|
|
226 /*
|
|
|
227 * mark_x
|
|
|
228 *
|
|
|
229 * After successfully building the new a.out, mark it executable
|
|
|
230 */
|
|
|
231 static
|
|
|
232 mark_x (name)
|
|
|
233 char *name;
|
|
|
234 {
|
|
|
235 struct stat sbuf;
|
|
|
236 int um = umask (777);
|
|
|
237 umask (um);
|
|
|
238 if (stat (name, &sbuf) < 0)
|
|
|
239 fatal_unexec ("getting protection on %s", name);
|
|
|
240 sbuf.st_mode |= 0111 & ~um;
|
|
|
241 if (chmod (name, sbuf.st_mode) < 0)
|
|
|
242 fatal_unexec ("setting protection on %s", name);
|
|
|
243 }
|
|
|
244
|
|
|
245 static void
|
|
|
246 fatal_unexec (s, va_alist)
|
|
|
247 va_dcl
|
|
|
248 {
|
|
|
249 va_list ap;
|
|
|
250 if (errno == EEOF)
|
|
|
251 fputs ("unexec: unexpected end of file, ", stderr);
|
|
|
252 else
|
|
|
253 fprintf (stderr, "unexec: %s, ", strerror (errno));
|
|
|
254 va_start (ap);
|
|
|
255 _doprnt (s, ap, stderr);
|
|
|
256 fputs (".\n", stderr);
|
|
|
257 exit (1);
|
|
|
258 }
|
