![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to elvprsv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to elvprsv.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* elvprsv.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
8: */
9:
10:
11: /* This file contains the portable sources for the "elvprsv" program.
12: * "Elvprsv" is run by Elvis when Elvis is about to die. It is also
13: * run when the computer boots up. It is not intended to be run directly
14: * by the user, ever.
15: *
16: * Basically, this program does the following four things:
17: * - It extracts the text from the temporary file, and places the text in
18: * a file in the /usr/preserve directory.
19: * - It adds a line to the /usr/preserve/Index file, describing the file
20: * that it just preserved.
21: * - It removes the temporary file.
22: * - It sends mail to the owner of the file, saying that the file was
23: * preserved, and how it can be recovered.
24: *
25: * The /usr/preserve/Index file is a log file that contains one line for each
26: * file that has ever been preserved. Each line of this file describes one
27: * preserved file. The first word on the line is the name of the file that
28: * contains the preserved text. The second word is the full pathname of the
29: * file that was being edited; for anonymous buffers, this is the directory
30: * name plus "/foo".
31: *
32: * If elvprsv's first argument (after the command name) starts with a hyphen,
33: * then the characters after the hyphen are used as a description of when
34: * the editor went away. This is optional.
35: *
36: * The remaining arguments are all the names of temporary files that are
37: * to be preserved. For example, on a UNIX system, the /etc/rc file might
38: * invoke it this way:
39: *
40: * elvprsv "-the system went down" /tmp/elv_*.*
41: *
42: * This file contains only the portable parts of the preserve program.
43: * It must #include a system-specific file. The system-specific file is
44: * expected to define the following functions:
45: *
46: * char *ownername(char *filename) - returns name of person who owns file
47: *
48: * void mail(char *user, char *name, char *when)
49: * - tell user that file was preserved
50: */
51:
52: #include <stdio.h>
53: #include "config.h"
54: #include "vi.h"
55: #include "ctype.h"
56:
57: void preserve P_((char *, char *));
58: void main P_((int, char **));
59:
60: #if AMIGA
61: BLK tmpblk;
62: # include "amiwild.c"
63: # include "amiprsv.c"
64: #endif
65:
66: #if OSK
67: # undef sprintf
68: #endif
69:
70: #if ANY_UNIX || OSK
71: # include "prsvunix.c"
72: #endif
73:
74: #if MSDOS || TOS
75: # include "prsvdos.c"
76: # define WILDCARD_NO_MAIN
77: # include "wildcard.c"
78: #endif
79:
80:
81: BLK buf;
82: BLK hdr;
83: BLK name;
84: int rewrite_now; /* boolean: should we send text directly to orig file? */
85:
86:
87:
88: /* This function preserves a single file, and announces its success/failure
89: * via an e-mail message.
90: */
91: void preserve(tname, when)
92: char *tname; /* name of a temp file to be preserved */
93: char *when; /* description of when the editor died */
94: {
95: int infd; /* fd used for reading from the temp file */
96: FILE *outfp; /* fp used for writing to the recovery file */
97: FILE *index; /* fp used for appending to index file */
98: char outname[100]; /* the name of the recovery file */
99: char *user; /* name of the owner of the temp file */
100: #if AMIGA
101: char *prsvdir;
102: #endif
103: int i;
104:
105: /* open the temp file */
106: infd = open(tname, O_RDONLY|O_BINARY);
107: if (infd < 0)
108: {
109: /* if we can't open the file, then we should assume that
110: * the filename contains wildcard characters that weren't
111: * expanded... and also assume that they weren't expanded
112: * because there are no files that need to be preserved.
113: * THEREFORE... we should silently ignore it.
114: * (Or loudly ignore it if the user was using -R)
115: */
116: if (rewrite_now)
117: {
118: perror(tname);
119: }
120: return;
121: }
122:
123: /* read the header and name from the file */
124: if (read(infd, hdr.c, BLKSIZE) != BLKSIZE
125: || read(infd, name.c, BLKSIZE) != BLKSIZE)
126: {
127: /* something wrong with the file - sorry */
128: fprintf(stderr, "%s: truncated header blocks\n", tname);
129: close(infd);
130: return;
131: }
132:
133: /* If the filename block contains an empty string, then Elvis was
134: * only keeping the temp file around because it contained some text
135: * that was needed for a named cut buffer. The user doesn't care
136: * about that kind of temp file, so we should silently delete it.
137: */
138: if (name.c[0] == '\0' && name.c[1] == '\177')
139: {
140: close(infd);
141: unlink(tname);
142: return;
143: }
144:
145: if (rewrite_now)
146: {
147: /* we don't need to open the index file */
148: index = (FILE *)0;
149:
150: /* make sure we can read every block! */
151: for (i = 1; i < MAXBLKS && hdr.n[i]; i++)
152: {
153: lseek(infd, (long)hdr.n[i] * (long)BLKSIZE, 0);
154: if (read(infd, buf.c, BLKSIZE) != BLKSIZE)
155: {
156: /* messed up header */
157: fprintf(stderr, "%s: unrecoverable -- header trashed\n", name.c);
158: close(infd);
159: return;
160: }
161: }
162:
163: /* open the user's file for writing */
164: outfp = fopen(name.c, "w");
165: if (!outfp)
166: {
167: perror(name.c);
168: close(infd);
169: return;
170: }
171: }
172: else
173: {
174: /* open/create the index file */
175: index = fopen(PRSVINDEX, "a");
176: if (!index)
177: {
178: perror(PRSVINDEX);
179: exit(2);
180: }
181:
182: /* should be at the end of the file already, but MAKE SURE */
183: fseek(index, 0L, 2);
184:
185: /* create the recovery file in the PRESVDIR directory */
186: #if AMIGA
187: prsvdir = &PRSVDIR[strlen(PRSVDIR) - 1];
188: if (*prsvdir == '/' || *prsvdir == ':')
189: {
190: sprintf(outname, "%sp%ld", PRSVDIR, ftell(index));
191: }
192: else
193: #endif
194: sprintf(outname, "%s%cp%ld", PRSVDIR, SLASH, ftell(index));
195: outfp = fopen(outname, "w");
196: if (!outfp)
197: {
198: perror(outname);
199: close(infd);
200: fclose(index);
201: return;
202: }
203: }
204:
205: /* write the text of the file out to the recovery file */
206: for (i = 1; i < MAXBLKS && hdr.n[i]; i++)
207: {
208: lseek(infd, (long)hdr.n[i] * (long)BLKSIZE, 0);
209: if (read(infd, buf.c, BLKSIZE) != BLKSIZE)
210: {
211: /* messed up header */
212: fprintf(stderr, "%s: unrecoverable -- header trashed\n", name.c);
213: fclose(outfp);
214: close(infd);
215: if (index)
216: {
217: fclose(index);
218: }
219: unlink(outname);
220: return;
221: }
222: fputs(buf.c, outfp);
223: }
224:
225: /* add a line to the index file */
226: if (index)
227: {
228: fprintf(index, "%s %s\n", outname, name.c);
229: }
230:
231: /* close everything */
232: close(infd);
233: fclose(outfp);
234: if (index)
235: {
236: fclose(index);
237: }
238:
239: /* Are we doing this due to something more frightening than just
240: * a ":preserve" command?
241: */
242: if (*when)
243: {
244: /* send a mail message */
245: mail(ownername(tname), name.c, when);
246:
247: /* remove the temp file -- the editor has died already */
248: unlink(tname);
249: }
250: }
251:
252: void main(argc, argv)
253: int argc;
254: char **argv;
255: {
256: int i;
257: char *when = "the editor went away";
258:
259: #if MSDOS || TOS
260: /* expand any wildcards in the command line */
261: _ct_init("");
262: argv = wildexpand(&argc, argv);
263: #endif
264:
265: /* do we have a "when" argument? */
266: i = 1;
267: if (argc >= i + 1 && !strcmp(argv[i], "-R"))
268: {
269: rewrite_now = 1;
270: when = "";
271: i++;
272: #if ANY_UNIX
273: setuid(geteuid());
274: #endif
275: }
276: #if OSK
277: else
278: {
279: setuid(0);
280: }
281: #endif
282: if (argc >= i + 1 && argv[i][0] == '-')
283: {
284: when = argv[i] + 1;
285: i++;
286: }
287:
288: /* preserve everything we're supposed to */
289: while (i < argc)
290: {
291: preserve(argv[i], when);
292: i++;
293: }
294: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.