![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unexenix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to unexenix.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* Unexec for Xenix.
2: Note that the GNU project considers support for Xenix operation
3: a peripheral activity which should not be allowed to divert effort
4: from development of the GNU system. Changes in this code will be
5: installed when Xenix users send them in, but aside from that
6: we don't plan to think about it, or about whether other Emacs
7: maintenance might break it.
8:
9: Copyright (C) 1988 Free Software Foundation, Inc.
10:
11: NO WARRANTY
12:
13: BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
14: NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
15: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
16: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
17: WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
18: BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
19: FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
20: AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
21: DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
22: CORRECTION.
23:
24: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
25: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
26: WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
27: LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
28: OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
29: USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
30: DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
31: A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
32: PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
33: DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
34:
35: GENERAL PUBLIC LICENSE TO COPY
36:
37: 1. You may copy and distribute verbatim copies of this source file
38: as you receive it, in any medium, provided that you conspicuously and
39: appropriately publish on each copy a valid copyright notice "Copyright
40: (C) 1987 Free Software Foundation, Inc."; and include following the
41: copyright notice a verbatim copy of the above disclaimer of warranty
42: and of this License. You may charge a distribution fee for the
43: physical act of transferring a copy.
44:
45: 2. You may modify your copy or copies of this source file or
46: any portion of it, and copy and distribute such modifications under
47: the terms of Paragraph 1 above, provided that you also do the following:
48:
49: a) cause the modified files to carry prominent notices stating
50: that you changed the files and the date of any change; and
51:
52: b) cause the whole of any work that you distribute or publish,
53: that in whole or in part contains or is a derivative of this
54: program or any part thereof, to be licensed at no charge to all
55: third parties on terms identical to those contained in this
56: License Agreement (except that you may choose to grant more extensive
57: warranty protection to some or all third parties, at your option).
58:
59: c) You may charge a distribution fee for the physical act of
60: transferring a copy, and you may at your option offer warranty
61: protection in exchange for a fee.
62:
63: Mere aggregation of another unrelated program with this program (or its
64: derivative) on a volume of a storage or distribution medium does not bring
65: the other program under the scope of these terms.
66:
67: 3. You may copy and distribute this program (or a portion or derivative
68: of it, under Paragraph 2) in object code or executable form under the terms
69: of Paragraphs 1 and 2 above provided that you also do one of the following:
70:
71: a) accompany it with the complete corresponding machine-readable
72: source code, which must be distributed under the terms of
73: Paragraphs 1 and 2 above; or,
74:
75: b) accompany it with a written offer, valid for at least three
76: years, to give any third party free (except for a nominal
77: shipping charge) a complete machine-readable copy of the
78: corresponding source code, to be distributed under the terms of
79: Paragraphs 1 and 2 above; or,
80:
81: c) accompany it with the information you received as to where the
82: corresponding source code may be obtained. (This alternative is
83: allowed only for noncommercial distribution and only if you
84: received the program in object code or executable form alone.)
85:
86: For an executable file, complete source code means all the source code for
87: all modules it contains; but, as a special exception, it need not include
88: source code for modules which are standard libraries that accompany the
89: operating system on which the executable file runs.
90:
91: 4. You may not copy, sublicense, distribute or transfer this program
92: except as expressly provided under this License Agreement. Any attempt
93: otherwise to copy, sublicense, distribute or transfer this program is void and
94: your rights to use the program under this License agreement shall be
95: automatically terminated. However, parties who have received computer
96: software programs from you with this License Agreement will not have
97: their licenses terminated so long as such parties remain in full compliance.
98:
99: 5. If you wish to incorporate parts of this program into other free
100: programs whose distribution conditions are different, write to the Free
101: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
102: worked out a simple rule that can be stated here, but we will often permit
103: this. We will be guided by the two goals of preserving the free status of
104: all derivatives of our free software and of promoting the sharing and reuse of
105: software.
106:
107:
108: In other words, you are welcome to use, share and improve this program.
109: You are forbidden to forbid anyone else to use, share and improve
110: what you give them. Help stamp out software-hoarding! */
111:
112:
113: /*
114: On 80386 Xenix, segmentation screws prevent us from modifying the text
115: segment at all. We basically just plug a new value for "data segment
116: size" into the countless headers and copy the other records straight
117: through. The data segment is ORG'ed at the xs_rbase value of the data
118: segment's xseg record (always @ 0x1880000, thanks to the "sophisticated
119: memory management hardware" of the chip) and extends to sbrk(0), exactly.
120: This code is afraid to malloc (should it be?), and alloca has to be the
121: wimpy, malloc-based version; consequently, data is usually copied in
122: smallish chunks.
123:
124: [email protected]
125: */
126:
127: #include "config.h"
128: #include <sys/types.h>
129: #include <fcntl.h>
130: #include <sys/file.h>
131: #include <sys/stat.h>
132: #include <stdio.h>
133: #include <varargs.h>
134: #include <a.out.h>
135:
136: static void fatal_unexec ();
137:
138: #define READ(_fd, _buffer, _size, _error_message, _error_arg) \
139: errno = EEOF; \
140: if (read(_fd, _buffer, _size) != _size) \
141: fatal_unexec(_error_message, _error_arg);
142:
143: #define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
144: if (write(_fd, _buffer, _size) != _size) \
145: fatal_unexec(_error_message, _error_arg);
146:
147: #define SEEK(_fd, _position, _error_message, _error_arg) \
148: errno = EEOF; \
149: if (lseek(_fd, _position, L_SET) != _position) \
150: fatal_unexec(_error_message, _error_arg);
151:
152: extern int errno;
153: extern int sys_nerr;
154: extern char *sys_errlist[];
155: #define EEOF -1
156:
157: #ifndef L_SET
158: #define L_SET 0
159: #endif
160:
161: /* Should check the magic number of the old executable;
162: not yet written. */
163: check_exec (x)
164: struct xexec *x;
165: {
166: }
167:
168:
169: unexec (new_name, a_name, data_start, bss_start, entry_address)
170: char *new_name, *a_name;
171: unsigned data_start, bss_start, entry_address;
172: {
173: char *sbrk (), *datalim = sbrk (0), *data_org;
174: long segpos, textseen, textpos, textlen, datapos, datadiff, datalen;
175:
176: struct xexec u_xexec, /* a.out header */
177: *u_xexecp = &u_xexec;
178: struct xext u_xext, /* extended header */
179: *u_xextp = &u_xext;
180: struct xseg u_xseg, /* segment table entry */
181: *u_xsegp = &u_xseg;
182: int i, nsegs, isdata = 0, infd, outfd;
183:
184: infd = open (a_name, O_RDONLY, 0);
185: if (infd < 0) fatal_unexec ("opening %s", a_name);
186:
187: outfd = creat (new_name, 0666);
188: if (outfd < 0) fatal_unexec ("creating %s", new_name);
189:
190: READ (infd, u_xexecp, sizeof (struct xexec),
191: "error reading %s", a_name);
192: check_exec (u_xexecp);
193: READ (infd, u_xextp, sizeof (struct xext),
194: "error reading %s", a_name);
195: segpos = u_xextp->xe_segpos;
196: nsegs = u_xextp->xe_segsize / sizeof (struct xseg);
197: SEEK (infd, segpos, "seek error on %s", a_name);
198: for (i = 0; i < nsegs; i ++)
199: {
200: READ (infd, u_xsegp, sizeof (struct xseg),
201: "error reading %s", a_name);
202: switch (u_xsegp->xs_type)
203: {
204: case XS_TTEXT:
205: {
206: if (i == 0)
207: {
208: textpos = u_xsegp->xs_filpos;
209: textlen = u_xsegp->xs_psize;
210: break;
211: }
212: fatal_unexec ("invalid text segment in %s", a_name);
213: }
214: case XS_TDATA:
215: {
216: if (i == 1)
217: {
218: datapos = u_xsegp->xs_filpos;
219: datalen = datalim - (data_org = (char *)(u_xsegp->xs_rbase));
220: datadiff = datalen - u_xsegp->xs_psize;
221: break;
222: }
223: fatal_unexec ("invalid data segment in %s", a_name);
224: }
225: default:
226: {
227: if (i > 1) break;
228: fatal_unexec ("invalid segment record in %s", a_name);
229: }
230: }
231: }
232: u_xexecp->x_data = datalen;
233: u_xexecp->x_bss = 0;
234: WRITE (outfd, u_xexecp, sizeof (struct xexec),
235: "error writing %s", new_name);
236: WRITE (outfd, u_xextp, sizeof (struct xext),
237: "error writing %s", new_name);
238: SEEK (infd, segpos, "seek error on %s", a_name);
239: SEEK (outfd, segpos, "seek error on %s", new_name);
240:
241: /* Copy the text segment record verbatim. */
242:
243: copyrec (infd, outfd, sizeof (struct xseg), a_name, new_name);
244:
245: /* Read, modify, write the data segment record. */
246:
247: READ (infd, u_xsegp, sizeof (struct xseg),
248: "error reading %s", a_name);
249: u_xsegp->xs_psize = u_xsegp->xs_vsize = datalen;
250: u_xsegp->xs_attr &= (~XS_AITER & ~XS_ABSS);
251: WRITE (outfd, u_xsegp, sizeof (struct xseg),
252: "error writing %s", new_name);
253:
254: /* Now copy any additional segment records, adjusting their
255: file position field */
256:
257: for (i = 2; i < nsegs; i++)
258: {
259: READ (infd, u_xsegp, sizeof (struct xseg),
260: "error reading %s", a_name);
261: u_xsegp->xs_filpos += datadiff;
262: WRITE (outfd, u_xsegp, sizeof (struct xseg),
263: "error writing %s", new_name);
264: }
265:
266: SEEK (infd, textpos, "seek error on %s", a_name);
267: SEEK (outfd, textpos, "seek error on %s", new_name);
268: copyrec (infd, outfd, textlen, a_name, new_name);
269:
270: SEEK (outfd, datapos, "seek error on %s", new_name);
271: WRITE (outfd, data_org, datalen,
272: "write error on %s", new_name);
273:
274: for (i = 2, segpos += (2 * sizeof (struct xseg));
275: i < nsegs;
276: i++, segpos += sizeof (struct xseg))
277: {
278: SEEK (infd, segpos, "seek error on %s", a_name);
279: READ (infd, u_xsegp, sizeof (struct xseg),
280: "read error on %s", a_name);
281: SEEK (infd, u_xsegp->xs_filpos, "seek error on %s", a_name);
282: /* We should be at eof in the output file here, but we must seek
283: because the xs_filpos and xs_psize fields in symbol table
284: segments are inconsistent. */
285: SEEK (outfd, u_xsegp->xs_filpos + datadiff, "seek error on %s", new_name);
286: copyrec (infd, outfd, u_xsegp->xs_psize, a_name, new_name);
287: }
288: close (infd);
289: close (outfd);
290: mark_x (new_name);
291: return 0;
292: }
293:
294: copyrec (infd, outfd, len, in_name, out_name)
295: int infd, outfd, len;
296: char *in_name, *out_name;
297: {
298: char buf[BUFSIZ];
299: int chunk;
300:
301: while (len)
302: {
303: chunk = BUFSIZ;
304: if (chunk > len)
305: chunk = len;
306: READ (infd, buf, chunk, "error reading %s", in_name);
307: WRITE (outfd, buf, chunk, "error writing %s", out_name);
308: len -= chunk;
309: }
310: }
311:
312: /*
313: * mark_x
314: *
315: * After succesfully building the new a.out, mark it executable
316: */
317: static
318: mark_x (name)
319: char *name;
320: {
321: struct stat sbuf;
322: int um = umask (777);
323: umask (um);
324: if (stat (name, &sbuf) < 0)
325: fatal_unexec ("getting protection on %s", name);
326: sbuf.st_mode |= 0111 & ~um;
327: if (chmod (name, sbuf.st_mode) < 0)
328: fatal_unexec ("setting protection on %s", name);
329: }
330:
331: static void
332: fatal_unexec (s, va_alist)
333: va_dcl
334: {
335: va_list ap;
336: if (errno == EEOF)
337: fputs ("unexec: unexpected end of file, ", stderr);
338: else if (errno < sys_nerr)
339: fprintf (stderr, "unexec: %s, ", sys_errlist[errno]);
340: else
341: fprintf (stderr, "unexec: error code %d, ", errno);
342: va_start (ap);
343: _doprnt (s, ap, stderr);
344: fputs (".\n", stderr);
345: exit (1);
346: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.