![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to v6-mail.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / delivermail|
Return to v6-mail.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / delivermail |
1.1 root 1: #
2:
3: /*
4: * mail command usage
5: * mail [-yn]
6: * prints your mail
7: * mail people
8: * sends standard input to people
9: *
10: * mail -r machine user people
11: * sends mail from the network
12: *
13: * if NOTROOT is defined, don't run as root.
14: */
15:
16: #define SIGINT 2
17: #define DIRECT 040000
18: #define RMAILCMD "/usr/net/bin/sendmail"
19: #define GETUID() (getuid() & 0377)
20: #define SPOOLDIR "/usr/spool/mail/"
21: #define NOTROOT $
22:
23: struct inode {
24: char minor;
25: char major;
26: int inumber;
27: int flags;
28: char nlinks;
29: char uid;
30: char gid;
31: char size0;
32: int size1;
33: int addr[8];
34: int actime[2];
35: int modtime[2];
36: } inode;
37:
38: char lettmp[] "/tmp/maXXXXX";
39: char preptmp[] "/tmp/mbXXXXX";
40: int pwfil;
41: int chew;
42: int errs;
43: char *strcat(), *strcpy();
44:
45: main(argc, argv)
46: char **argv;
47: {
48: register int me;
49: extern int fout;
50: int uf, delexit();
51: char namebuf[20];
52:
53: mktemp(lettmp);
54: mktemp(preptmp);
55: unlink(lettmp);
56: unlink(preptmp);
57: me = GETUID();
58: if (getname(me, namebuf) < 0) {
59: printf("Who are you?\n");
60: delexit(1);
61: }
62: if (argc < 2)
63: goto hitit;
64: for (argc--, argv++; argc > 0 && argv[0][0] == '-'; argc--, argv++)
65: switch(argv[0][1]) {
66: register char *cp, *np;
67:
68: case 'y':
69: case 'n':
70: argc++, argv--;
71: hitit:
72: printmail(argc, argv, namebuf);
73: delexit(0);
74:
75: case 'r':
76: if (argc < 2)
77: continue;
78: case 'f':
79: if (argc < 1)
80: continue;
81: if (!equal("network", namebuf) && me != 0) {
82: printf("Nice try!\n");
83: delexit(1);
84: }
85: chew++;
86: np = namebuf;
87: for (cp = argv[1]; *cp; cp++)
88: *np++ = *cp;
89: if (argv[0][1] == 'r')
90: {
91: argc--, argv++;
92: *np++ = ':';
93: for (cp = argv[1]; *cp; cp++)
94: *np++ = *cp;
95: }
96: *np++ = 0;
97: argc--, argv++;
98: continue;
99: }
100: if ((signal(SIGINT, 01) & 01) == 0)
101: signal(SIGINT, delexit);
102: unlink(lettmp);
103: # ifdef NOTROOT
104: fout = creat(lettmp, 0666);
105: # else
106: fout = creat(lettmp, 0600);
107: # endif
108: if (fout < 0) {
109: fout = 1;
110: perror(lettmp);
111: delexit(1);
112: }
113: argc++, argv--;
114: bulkmail(argc, argv, namebuf);
115: delexit(0);
116: }
117:
118: printmail(argc, argv, name)
119: char **argv;
120: char *name;
121: {
122: extern int fin, fout;
123: register n, c, f;
124: char *mname;
125:
126: mname = cat(SPOOLDIR, name);
127: if (stat(mname, &inode)>=0 && inode.nlinks==1 &&
128: fopen(mname, &fin)>=0 && (c = getchar())) {
129: putchar(c);
130: getput();
131: close(fin);
132: c = 'x';
133: if (argc<2) {
134: if (ttyn(0)!='x') {
135: printf("Save?");
136: fin = 0;
137: c = getchar();
138: }
139: } else
140: c = argv[1][1];
141: if (!any(c, "yn"))
142: delexit(0);
143: if (c == 'y') {
144: if (accesss("mbox")) {
145: printf("Saved mail in 'mbox'\n");
146: prepend(mname, "mbox", GETUID());
147: unlink(mname);
148: } else
149: printf("In wrong directory\n");
150: } else
151: unlink(mname);
152: } else
153: printf("No mail.\n");
154: }
155:
156: bulkmail(argc, argv, from)
157: char **argv, *from;
158: {
159: extern int fin, fout;
160: register int c;
161: register char *cp;
162: char linebuf[128];
163: int tbuf[2], ttyn1;
164:
165: fin = 0;
166: (&fin)[1] = 0;
167: time(tbuf);
168: ttyn1 = ttyn(1);
169: if (ttyn1 < 033) {
170: ttyn1 =+ 'a' - 1;
171: ttyn1 =<< 8;
172: ttyn1 =| '^';
173: }
174: printf("From %s tty%c %s", from, ttyn1, ctime(tbuf));
175:
176: /*
177: * If delivering mail from the network via mail -r,
178: * Strip the leading line and throw it away, as long
179: * as it begins with "From ..."
180: */
181:
182: if (chew) {
183: cp = linebuf;
184: do {
185: c = getchar();
186: if (cp - linebuf < 120)
187: *cp++ = c;
188: } while (c != '\n' && c != 0);
189: *cp = '\0';
190: if (linebuf[0] != 'F' || linebuf[1] != 'r' ||
191: linebuf[2] != 'o' || linebuf[3] != 'm')
192: printf("%s", linebuf);
193: }
194: getput();
195: putchar('\n');
196: flush();
197: close(fout);
198: while (--argc > 0)
199: sendto(*++argv);
200: delexit(errs);
201: }
202:
203: sendto(person)
204: char *person;
205: {
206: static int saved;
207: extern int fout, fin;
208: register char *filep;
209: register int him;
210: int i;
211:
212: if ((person[0] == 'i' || person[0] == 'I') && person[1] == ':')
213: person += 2;
214: for (i = 0; person[i] != '\0'; i++)
215: {
216: if (person[i] == ':')
217: {
218: person[i] = '\0';
219: if (equal(person, "ing70") || equal(person, "ingres"))
220: person += i + 1;
221: else
222: person[i] = ':';
223: break;
224: }
225: }
226: if (person[i] == ':' || equal(person, "msgs"))
227: {
228: int i = fork();
229: int s;
230:
231: if (i < 0) {
232: perror("fork");
233: goto assback;
234: }
235: if (i == 0) {
236: close(0);
237: open(lettmp, 0);
238: if (any(':', person)) {
239: execl(RMAILCMD, "sendmail", person, 0);
240: execl("/usr/bin/sendmail", "sendmail", person, 0);
241: execl("/bin/sendmail", "sendmail", person, 0);
242: perror("sendmail");
243: } else {
244: execl("/usr/new/msgs", "msgs", "-s", 0);
245: execl("/usr/ucb/msgs", "msgs", "-s", 0);
246: execl("/usr/bin/msgs", "msgs", "-s", 0);
247: }
248: exit(12);
249: }
250: for (;;) {
251: register int j = wait(&s);
252: if (j == -1)
253: goto assback;
254: if (j == i)
255: break;
256: }
257: if ((s & 0377) != 0 || (s >> 8) == 12)
258: goto assback;
259: return;
260: }
261:
262: if ((him = getuserid(person)) == -1) {
263: assback:
264: fout = 1;
265: flush();
266: printf("Can't send to %s.\n", person);
267: errs++;
268: if (ttyn(0)!='x' && saved==0) {
269: saved++;
270: if (accesss("dead.letter")) {
271: printf("Letter saved in 'dead.letter'\n");
272: prepend(lettmp, "dead.letter", GETUID());
273: } else
274: printf("In wrong directory\n");
275: }
276: return;
277: }
278: filep = cat(SPOOLDIR, person);
279: lock(filep);
280: prepend(lettmp, filep, him);
281: unlock();
282: }
283:
284: prepend(from, to, own)
285: char *from, *to;
286: {
287: extern int fin, fout;
288: register int sig;
289: int statb[18];
290:
291: if (stat(to, statb) >= 0 && (statb[2] & 060000) != 0) {
292: write(2, "Exotic destination\n", 19);
293: delexit(1);
294: }
295: unlink(preptmp);
296: if (fcreat(preptmp, &fout) < 0) {
297: fout = 1;
298: perror("mail");
299: delexit(1);
300: }
301: chmod(preptmp, 0600);
302: if (fopen(from, &fin) < 0) {
303: close(fout);
304: fout = 1;
305: perror("mail");
306: unlink(preptmp);
307: return(0);
308: }
309: getput();
310: close(fin);
311: fopen(to, &fin);
312: getput();
313: close(fin);
314: flush();
315: close(fout);
316: sig = signal(SIGINT, 01);
317: unlink(to);
318: if (fcreat(to, &fout) < 0) {
319: unlink(preptmp);
320: fout = 1;
321: signal(SIGINT, sig);
322: return(0);
323: }
324: # ifdef NOTROOT
325: chmod(to, 0666);
326: # else
327: chmod(to, 0600);
328: chown(to, own);
329: # endif
330: if(stat(to, &inode) < 0 || inode.nlinks != 1) {
331: close(fout);
332: fout = 1;
333: unlink(preptmp);
334: signal(SIGINT, sig);
335: return(0);
336: }
337: if (fopen(preptmp, &fin) < 0) {
338: fout = 1;
339: perror("mail");
340: signal(SIGINT, sig);
341: errs++;
342: return(0);
343: }
344: getput();
345: flush();
346: close(fout);
347: close(fin);
348: fout = 1;
349: signal(SIGINT, sig);
350: return(1);
351: }
352:
353: delexit(ex)
354: {
355: unlock();
356: unlink(lettmp);
357: unlink(preptmp);
358: exit(ex);
359: }
360:
361: equal(as1, as2)
362: {
363: register char *s1, *s2;
364:
365: s1 = as1;
366: s2 = as2;
367: while (*s1++ == *s2)
368: if (*s2++ == 0)
369: return(1);
370: return(0);
371: }
372:
373: cat(ap1, ap2)
374: char *ap1, *ap2;
375: {
376: register char *p1, *p2;
377: static char fn[32];
378:
379: p1 = ap1;
380: p2 = fn;
381: while (*p2++ = *p1++);
382: p2--;
383: p1 = ap2;
384: while (*p2++ = *p1++);
385: return(fn);
386: }
387:
388: getput()
389: {
390: extern int errno;
391: register c;
392:
393: while(c = getchar()) {
394: errno = 0;
395: putchar(c);
396: if(errno) {
397: perror("mail");
398: delexit(1);
399: }
400: }
401: }
402:
403: accesss(s1)
404: {
405: if (access(".", 2) != -1 && (stat(s1, &inode)<0 || access(s1, 2)==0))
406: return(1);
407: return(0);
408: }
409:
410: any(c, str)
411: char *str;
412: {
413: register char *f;
414:
415: f = str;
416: while (*f)
417: if (c == *f++)
418: return(1);
419: return(0);
420: }
421:
422: char *maillock = ".lock"; /* Lock suffix for mailname */
423: char *lockname = "/usr/spool/mail/tmXXXXXX";
424: char locktmp[30]; /* Usable lock temporary */
425: char curlock[50]; /* Last used name of lock */
426: int locked; /* To note that we locked it */
427:
428: /*
429: * Lock the specified mail file by setting the file mailfile.lock.
430: * We must, of course, be careful to unlink the lock file by a call
431: * to unlock before we stop. The algorithm used here is to see if
432: * the lock exists, and if it does, to check its modify time. If it
433: * is older than 30 seconds, we assume error and set our own file.
434: * Otherwise, we wait for 5 seconds and try again.
435: */
436:
437: lock(file)
438: char *file;
439: {
440: register int f;
441: long age;
442: struct inode sbuf;
443: long curtime;
444:
445: if (file == (char *) 0) {
446: printf("Locked = %d\n", locked);
447: return(0);
448: }
449: if (locked)
450: return(0);
451: strcpy(curlock, file);
452: strcat(curlock, maillock);
453: strcpy(locktmp, lockname);
454: mktemp(locktmp);
455: unlink(locktmp);
456: for (;;) {
457: f = lock1(locktmp, curlock);
458: if (f == 0) {
459: locked = 1;
460: return(0);
461: }
462: if (stat(curlock, &sbuf) < 0)
463: return(0);
464: time(&curtime);
465: age = * ((long *) sbuf.modtime);
466: if (curtime < age + 30) {
467: sleep(5);
468: continue;
469: }
470: unlink(curlock);
471: }
472: }
473:
474: /*
475: * Remove the mail lock, and note that we no longer
476: * have it locked.
477: */
478:
479: unlock()
480: {
481:
482: if (locked)
483: unlink(curlock);
484: locked = 0;
485: }
486:
487: /*
488: * Attempt to set the lock by creating the temporary file,
489: * then doing a link/unlink. If it fails, return -1 else 0
490: */
491:
492: lock1(tempfile, name)
493: char tempfile[], name[];
494: {
495: register int fd;
496:
497: fd = creat(tempfile, 0);
498: if (fd < 0)
499: return(-1);
500: close(fd);
501: if (link(tempfile, name) < 0) {
502: unlink(tempfile);
503: return(-1);
504: }
505: unlink(tempfile);
506: return(0);
507: }
508:
509: /*
510: * Concatenate s2 on the end of s1. S1's space must be large enough.
511: * Return s1.
512: */
513:
514: char *
515: strcat(s1, s2)
516: register char *s1, *s2;
517: {
518: register os1;
519:
520: os1 = s1;
521: while (*s1++)
522: ;
523: *--s1;
524: while (*s1++ = *s2++)
525: ;
526: return(os1);
527: }
528:
529: /*
530: * Copy string s2 to s1. s1 must be large enough.
531: * return s1
532: */
533:
534: char *
535: strcpy(s1, s2)
536: register char *s1, *s2;
537: {
538: register os1;
539:
540: os1 = s1;
541: while (*s1++ = *s2++)
542: ;
543: return(os1);
544: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.