![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / upas / print|
Return to print.c CVS log | Up to [Research Unix] / researchv8dc / cmd / upas / print |
1.1 root 1: /*
2: * print mail
3: */
4: #include <stdio.h>
5: #include <sys/types.h>
6: #include <sys/stat.h>
7: #include <setjmp.h>
8: #include <ctype.h>
9: #include "mail.h"
10: #include "letter.h"
11: #include "string.h"
12:
13: /* globals */
14: static int flgp;
15: static int manual;
16: static int forward;
17: static int nlet;
18: static int error;
19: static int otherfile;
20: static jmp_buf sjbuf;
21: #define seq(i) (forward ? i-1 : nlet-i)
22: static int changed; /* true if mail file has been changed */
23:
24: /* exported */
25: char *thissys;
26:
27: /* imported */
28: extern void lock();
29: extern void unlock();
30: extern char *getlogin();
31: extern char *getenv();
32: extern char *getarg();
33: extern FILE *popen();
34: extern char *mailpath();
35: extern long getunix();
36: extern char *getsysname();
37: extern char *P();
38: extern void V();
39:
40: /* predefined */
41: static char *doargs();
42: static long copymt();
43: static void domanual();
44: static void doauto();
45: static int docommand();
46: static int copyback();
47: static int done();
48: static int special_mailfile();
49: static int doprint();
50: static void dohelp();
51: static void print_from();
52: static int reply();
53: static int remail();
54: static int squirrel_away();
55:
56: main(argc, argv)
57: char **argv;
58: {
59: struct stat stbuf;
60: char *mp, *tp;
61: long mailsize;
62: FILE *malf;
63:
64: mp = doargs(argc, argv);
65: if (stat(mp, &stbuf) < 0 || stbuf.st_size == 0L) {
66: printf("No mail.\n");
67: return 0;
68: }
69: thissys = getsysname();
70: (void)signal(SIGINT, done);
71: (void)signal(SIGHUP, done);
72: lock(mp);
73: tp = otherfile ? NULL : P();
74: if (tp != NULL)
75: fprintf(stderr, "You are already reading mail on %s!\n\n", tp);
76: malf = fopen(mp, "r");
77: if (malf == NULL) {
78: fprintf(stderr, "mail: cannot read %s.\n", mp);
79: error++;
80: (void)done();
81: }
82:
83: /* see if we're piping or forwarding */
84: if(special_mailfile(mp))
85: (void)done();
86:
87: /* make temporary */
88: inittmp();
89:
90: /* read mbox */
91: mailsize = copymt(malf);
92: fclose(malf);
93: unlock();
94:
95: /* print the mail */
96: if (flgp)
97: printall();
98: else {
99: if (manual)
100: domanual();
101: else
102: doauto();
103: }
104: if (changed)
105: copyback(mailsize, mp);
106: (void)done();
107:
108: return 0;
109: }
110:
111: /* Output all messages */
112: printall()
113: {
114: int i, current;
115:
116: for (i = 0; i < nlet; i++) {
117: current = forward ? i : nlet - i - 1;
118: doprint(current);
119: }
120: }
121:
122: /* remember an interrupt happened */
123: rememberint()
124: {
125: signal(SIGINT, rememberint);
126: clearerr(stdin);
127: clearerr(stdout);
128: longjmp(sjbuf, 1);
129: }
130:
131: #define eatwhite(p) while(*p==' '||*p=='\t') p++
132:
133: /*
134: * Return a letter number
135: */
136: static int
137: lnumber(pp, dot, def)
138: char **pp;
139: {
140: eatwhite(*pp);
141: switch(**pp) {
142: case '$':
143: (*pp)++;
144: dot = nlet;
145: break;
146: case 'n':
147: case '+':
148: (*pp)++;
149: dot = dot + 1;
150: break;
151: case '^':
152: case '-':
153: (*pp)++;
154: dot = dot - 1;
155: break;
156: case '.':
157: (*pp)++;
158: break;
159: case '0': case '1': case '2': case '3': case '4':
160: case '5': case '6': case '7': case '8': case '9':
161: dot = 0;
162: while (isdigit(**pp))
163: dot = dot*10 + *(*pp)++ - '0';
164: break; /* first letter is 1 */
165: default:
166: dot = def;
167: break;
168: }
169: if (dot <= 0)
170: dot = 1;
171: return dot;
172: }
173:
174: /*
175: * Read and parse a command line. A command consists of an optional
176: * range, a single letter command, and optional arguments.
177: */
178: static char *
179: parse(cmdp, firstp, lastp, dot)
180: char *cmdp; /* the 1 letter command */
181: int *firstp; /* first command in a range */
182: int *lastp; /* last command in a range */
183: int dot; /* current letter */
184: {
185: static char resp[CMDSIZE];
186: char *p = resp;
187:
188: /* get command and dump trailing newline */
189: printf("? ");
190: fflush(stdout);
191: if (fgets(resp, CMDSIZE, stdin) == NULL)
192: return NULL;
193: p[strlen(p) - 1] = '\0';
194:
195: /* get range */
196: eatwhite(p);
197: if (*p != '\0') {
198: if (*p == ',')
199: *firstp = 1;
200: else
201: *firstp = lnumber(&p, dot, dot);
202: eatwhite(p);
203: if (*p != ',')
204: *lastp = *firstp;
205: else {
206: p++;
207: *lastp = lnumber(&p, dot, nlet);
208: }
209: } else
210: *firstp = *lastp = dot+1;
211:
212: /* get command */
213: eatwhite(p);
214: if (*p != '\0')
215: *cmdp = *p++;
216: else
217: *cmdp = 'p';
218:
219: /* compound command */
220: if (*cmdp == 'd' && (*p == 'q' || *p == 'p'))
221: *(cmdp+1) = *p++;
222: else
223: *(cmdp+1) = '\0';
224: eatwhite(p);
225: return p;
226: }
227:
228: /* Process user commands in the new style.
229: * All actions are prompted for.
230: */
231: static void
232: domanual()
233: {
234: int dot=1, print, i;
235: int first, last;
236: char cmd[2], *args;
237:
238: printf("%d letters\n", nlet);
239: while (1) {
240: /* in case of interrupt, come back here but don't print */
241: if (setjmp(sjbuf)) /* after long jump */
242: printf("\n");
243: signal(SIGINT, rememberint);
244: args = parse(cmd, &first, &last, dot);
245: if (args == NULL)
246: break;
247: for (i = first; i <= last && i <= nlet; i++) {
248: dot = i; /* must be here in case of interrupt */
249: if (docommand(cmd[0], args, i, &print) < 0)
250: return;
251: }
252: switch (cmd[1]) {
253: case 'q':
254: return;
255: case 'p':
256: doprint(seq(++dot));
257: break;
258: }
259: }
260: }
261:
262: /* Process user commands in the old style.
263: * This implies printing the next message
264: * without prompting for it
265: */
266: static void
267: doauto()
268: {
269: int print=1, dot=1, i;
270: int first, last;
271: char cmd[2], *args;
272:
273: while (dot <= nlet && dot >= 0) {
274: /* in case of interrupt, come back here but don't print */
275: if (setjmp(sjbuf)) /* after long jump */
276: printf("\n");
277: else { /* here normally */
278: signal(SIGINT, rememberint);
279: if (print)
280: doprint(seq(dot));
281: }
282: print = 0;
283: args = parse(cmd, &first, &last, dot);
284: if (args == NULL)
285: break;
286: for (i = first; i <= last && i <= nlet; i++) {
287: dot = i; /* in case of interrupt while printing */
288: dot = docommand(cmd[0], args, i, &print);
289: }
290: if (dot > 0 && dot < last)
291: dot = last;
292: switch (cmd[1]) {
293: case 'q':
294: return;
295: case 'p':
296: print++;
297: break;
298: }
299: }
300: }
301:
302: /*
303: * Perform a command.
304: */
305: static int
306: docommand(cmd, args, dot, pflag)
307: char cmd; /* command to perform */
308: char *args; /* arguments to the command */
309: int dot; /* the message to apply it to */
310: int *pflag; /* (returned) true if next message to be printed */
311: {
312: switch (cmd) {
313: default:
314: printf("usage\n");
315: case '?':
316: dohelp();
317: break;
318: case 'h':
319: print_from(seq(dot));
320: break;
321: case '=':
322: printf("at letter %d\n", dot);
323: break;
324: case 'p':
325: doprint(seq(dot));
326: break;
327: case 'x':
328: changed = 0;
329: dot = -1;
330: break;
331: case 'y':
332: case 'w':
333: case 's':
334: if (squirrel_away(seq(dot), args) == 0) {
335: (void)ldelete(seq(dot));
336: changed++;
337: (*pflag)++;
338: dot++;
339: }
340: break;
341: case 'm':
342: if (remail(seq(dot), args) == 0) {
343: (void)ldelete(seq(dot));
344: changed++;
345: (*pflag)++;
346: dot++;
347: }
348: break;
349: case 'r':
350: if (*args != '\0') {
351: fprintf(stderr, "invalid: r takes no arguments\n");
352: break;
353: }
354: (void)reply(seq(dot));
355: printf("!\n");
356: break;
357: case '!':
358: system(args);
359: printf("!\n");
360: break;
361: case 'd':
362: if (*args != '\0') {
363: fprintf(stderr,"invalid: d takes no arguments\n");
364: break;
365: }
366: (void)ldelete(seq(dot));
367: changed++;
368: (*pflag)++;
369: dot++;
370: break;
371: case 'u':
372: if (*args != '\0') {
373: fprintf(stderr,"invalid: u takes no arguments\n");
374: break;
375: }
376: (void)lundelete(seq(dot));
377: (*pflag)++;
378: dot++;
379: break;
380: case 'q':
381: dot = -1;
382: break;
383: }
384: return dot;
385: }
386:
387: /* copy mail to temp file, returns size of mail file */
388: static long
389: copymt(mfp)
390: FILE *mfp;
391: {
392: letter *lp=NULL;
393: char line[FROMLINESIZE];
394:
395: /* read in letters */
396: while (fgets(line, FROMLINESIZE, mfp) != NULL) {
397: if (strncmp(line, FROM, FSIZE)==0 || lp==NULL) {
398: lp = lopen(nlet++, "w");
399: }
400: lputs(line, lp);
401: }
402:
403: /* remember where end of file is */
404: return ftell(mfp);
405: }
406:
407: /* copy temp or whatever back to /usr/spool/mail */
408: static int
409: copyback(oldsize, mp)
410: long oldsize;
411: char *mp;
412: {
413: register i;
414: register int new = 0;
415: struct stat stbuf;
416: letter *lp;
417: FILE *malf;
418:
419: lock(mp);
420:
421: /* read new mail that arrived while we were printing */
422: stat(mp, &stbuf);
423: if (stbuf.st_size != oldsize) { /* new mail has arrived */
424: malf = fopen(mp, "r");
425: if (malf == NULL) {
426: fprintf(stderr, "mail: can't re-read %s\n", mp);
427: (void)done();
428: }
429: fseek(malf, oldsize, 0);
430: (void)copymt(malf);
431: fclose(malf);
432: new++;
433: }
434:
435: /* turn off interrupts while writing back */
436: signal(SIGHUP, SIG_IGN);
437: signal(SIGINT, SIG_IGN);
438: signal(SIGQUIT, SIG_IGN);
439: signal(SIGTERM, SIG_IGN);
440:
441: /* write the sucker back */
442: malf = fopen(mp, "w");
443: if (malf == NULL) {
444: fprintf(stderr, "mail: can't rewrite %s\n", mp);
445: (void)done();
446: }
447: for (i = 0; i < nlet; i++)
448: if ((lp=lopen(i, "ru")) != NULL) {
449: copyfrom(lp, malf);
450: }
451: fclose(malf);
452: unlock();
453: if (new)
454: printf("new mail arrived\n");
455: }
456:
457: /* come here to finish up */
458: static int
459: done()
460: {
461: unlock();
462: V();
463: releasetmp();
464: exit(error);
465: return 0;
466: }
467:
468: static char *
469: doargs(argc, argv)
470: int argc;
471: char *argv[];
472: {
473: static char mailfile[256];
474:
475: (void)strcpy(mailfile, mailpath(getlogin()));
476:
477: for (; argc>1; argv++, argc--) {
478: if (argv[1][0]=='-') {
479: if (argv[1][1]=='p') {
480: flgp++;
481: } else if (argv[1][1]=='f') {
482: if (argc>=3) {
483: strcpy(mailfile, argv[2]);
484: argv++;
485: argc--;
486: otherfile = 1;
487: }
488: } else if (argv[1][1]=='r') {
489: forward = 1;
490: } else if (argv[1][1]=='m') {
491: manual = 1;
492: } else {
493: fprintf(stderr, "mail: unknown option %c\n", argv[1][1]);
494: done();
495: }
496: } else
497: break;
498: }
499: return mailfile;
500: }
501:
502: /* return non-zero if this is not a normal mail file */
503: static int
504: special_mailfile(mp)
505: char *mp; /* mail file */
506: {
507: char fbuf[256];
508: char *sp1, *sp2;
509: int stat;
510:
511: sp2 = "";
512:
513: /* if something is being done to the mail, go away */
514: stat = delivery_status(mp, fbuf);
515: switch(stat & MFTYPE) {
516: case MF_FORWARD:
517: sp1 = "Your mail is being forwarded to";
518: break;
519: case MF_PIPE:
520: sp1 = "Your mail is being piped to";
521: break;
522: default:
523: return 0;
524: }
525:
526: if (stat & MFEXTRA)
527: sp2 = "and your mailbox contains extra stuff\n";
528: printf("%s %s %s\n", sp1, fbuf, sp2);
529: return stat & MFTYPE;
530: }
531:
532: static void
533: dohelp()
534: {
535: printf("Commands are of the form '[range] command [args]'.\n");
536: printf("The command can be:\n");
537: printf("d\tdelete\n");
538: printf("u\tundelete\n");
539: printf("h\tprint from lines of all messages\n");
540: printf("m user\tmail to user\n");
541: printf("p\tprint\n");
542: printf("r\treply to last message\n");
543: printf("q\tquit\n");
544: printf("s[file]\tsave (default mbox)\n");
545: printf("x\texit without changing mail\n");
546: printf("=\tprint current message number\n");
547: printf("! cmd\texecute cmd\n");
548: }
549:
550: /* print the from line (and status) of each message */
551: static void
552: print_from(let)
553: int let;
554: {
555: int deleted;
556: char from[FROMLINESIZE];
557: letter *lp;
558:
559: lp = lopen(let, "ru");
560: if (lp == NULL) {
561: deleted = 1;
562: lp = lopen(let, "r");
563: } else
564: deleted = 0;
565: lgets(from, FROMLINESIZE, lp);
566: printf("%3d %c %4d %s", seq(let), deleted?'d':' ',
567: lsize(lp), from+FSIZE);
568: }
569:
570: /* save a letter in a file, return 0 if successful */
571: static int
572: squirrel_away(let, resp)
573: int let;
574: char *resp;
575: {
576: char *p;
577: letter *lp;
578: char path[PATHSIZE];
579: int problems=0;
580: FILE *malf;
581:
582: if (*resp == '\0') {
583: p = getenv("HOME");
584: if(p != 0) {
585: strcpy(resp, p);
586: strcat(resp, "/mbox");
587: } else
588: strcpy(resp, "mbox");
589: }
590: for (p = resp; (p = getarg(path, p)) != NULL; ) {
591: malf = fopen(path, "a");
592: if (malf == NULL) {
593: fprintf(stderr, "mail: cannot append to %s\n", path);
594: problems++;
595: continue;
596: }
597: lp = lopen(let, "r");
598: copyfrom(lp, malf);
599: fclose(malf);
600: }
601: return problems;
602: }
603:
604: /* reply to mail, return 0 if no problems */
605: static char replyline[FROMLINESIZE];
606: static char replycmd[CMDSIZE];
607: static int
608: reply(let)
609: int let;
610: {
611: char *sp;
612: letter *lp;
613:
614: lp = lopen(let, "r");
615: lgets(replyline, FROMLINESIZE, lp);
616: sp = strchr(replyline+FSIZE, ' ');
617: if (sp != NULL)
618: *sp = '\0';
619: strcpy(replycmd, "/bin/mail ");
620: strcat(replycmd, replyline+FSIZE);
621: printf("!%s\n", replycmd);
622: system(replycmd);
623: return 0;
624: }
625:
626: /* pass mail onto someone else, return 0 if no problems */
627: static int
628: remail(let, resp)
629: int let;
630: char *resp;
631: {
632: char cmd[CMDSIZE];
633: FILE *pipf;
634: letter *lp;
635:
636: if (*resp == '\0') {
637: fprintf(stderr, "invalid: m requires a destination\n");
638: return -1;
639: }
640: strcpy(cmd, "mail ");
641: strcat(cmd, resp);
642:
643: /* fork so that mail becomes super-user again */
644: pipf = popen(cmd, "w");
645: if(pipf == NULL) {
646: fprintf(stderr, "mail: can't fork to remail\n");
647: return -1;
648: }
649: lp = lopen(let, "r");
650: copyfrom(lp, pipf);
651: return pclose(pipf);
652: }
653:
654: /* output the letter */
655: static int
656: doprint(let)
657: int let;
658: {
659: letter *lp;
660:
661: lp = lopen(let, "r");
662: if (lp == NULL)
663: return -1;
664: copyfrom(lp, stdout);
665: return 0;
666: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.