![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mail.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / mail|
Return to mail.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / mail |
1.1 root 1: static char *rcsrev = "$Revision: 1.5 $";
2: static char *rcshdr =
3: "$Header: /src386/bin/mail/RCS/mail.c,v 1.5 93/06/21 17:47:04 bin Exp Locker: bin $";
4: /*
5: * $Header: /src386/bin/mail/RCS/mail.c,v 1.5 93/06/21 17:47:04 bin Exp Locker: bin $
6: * $Log: mail.c,v $
7: * Revision 1.5 93/06/21 17:47:04 bin
8: * bob h removed xmail referencs from help message.
9: *
10: * Revision 1.4 92/05/28 10:28:53 bin
11: * bob h added a test for new msgsep scheme so that mail will exit
12: * if it does not detect the new sep scheme.
13: *
14: * Revision 1.2 92/04/20 10:07:46 bin
15: * The 'final' fix using CORRECT sources to properly write a msgsep at the
16: * top of a save file if new file is opened or if saving the first message
17: * of a mailbox to a file
18: *
19: * Revision 1.1 92/04/20 09:03:08 bin
20: * Initial revision
21: *
22: * Revision 3.4 91/02/18 17:14:10 piggy
23: * Fixed "q" command so that it works with a non-setuid mail.
24: *
25: * Revision 3.3 91/02/18 09:30:09 piggy
26: * Fixed two mishandlings of args[].
27: *
28: * Revision 3.2 91/02/08 15:16:07 piggy
29: * Updated error messages to include malloc failures.
30: *
31: * Revision 3.1 91/02/08 14:34:28 piggy
32: * Made csplit non-destructive.
33: *
34: * Revision 3.0 91/02/07 15:19:14 piggy
35: * *** empty log message ***
36: *
37: * Revision 2.13 90/03/30 16:16:19 wgl
38: * Correct seek pointer work within readmail.
39: *
40: * Revision 2.12 90/03/12 14:19:08 wgl
41: * New version of send doing aliases in a different place.
42: *
43: * Revision 2.11 90/03/08 16:41:15 wgl
44: * Add code to get signature file.
45: *
46: * Revision 2.10 90/03/02 10:41:59 wgl
47: * Add the -a flag so that uucp does not look like it is coming from
48: * somewhere else.
49: *
50: * Revision 2.9 90/03/01 11:17:19 wgl
51: * Final conversion to rely soley on ^A^A as separators.
52: * Effectively delete concept of m_hsize.
53: *
54: * Revision 2.8 90/03/01 10:14:31 wgl
55: * Go buy separators, not "From_" lines.
56: *
57: * Revision 2.7 90/02/28 17:11:41 wgl
58: * Add version print, add some changes to the message-id field.
59: *
60: * Revision 2.6 90/02/28 16:42:09 wgl
61: * Version number fakeout.
62: *
63: * Revision 2.5 90/02/28 16:19:44 wgl
64: * Try again to get versioin number right.
65: *
66: * Revision 2.4 90/02/28 16:18:56 wgl
67: * Get version number right.
68: *
69: * Revision 2.3 90/02/28 16:04:59 wgl
70: * Many changes; ripped out send.
71: * Changes are to make it work with uucp and internet mail.
72: *
73: * Revision 1.6 89/02/22 05:34:00 bin
74: * Changes by rec to integrate with lauren's uumail.
75: *
76: * Revision 1.5 88/09/01 14:49:01 bin
77: * Source administration: Re-install declaration of getenv.
78: * It was inserted after epstein made his copy.
79: *
80: * Revision 1.4 88/09/01 14:44:49 bin
81: * Mark Epsteins changes for ASKCC and for message scrolling, and interrupt
82: * handling during processing.
83: *
84: * Revision 1.3 88/09/01 14:27:41 bin
85: * declare getenv to get rid of integer pointer pun error message.
86: *
87: * Revision 1.2 88/09/01 11:02:23 bin
88: * Remove extra declaration of header which had rcs stuff in it.
89: *
90: * Revision 1.1 88/09/01 10:55:34 bin
91: * Initial revision
92: *
93: */
94: /*
95: * The mail command.
96: * Coherent electronic postal system, user agent.
97: * With v3.0 this program no longer runs setuid.
98: * Modifications by rec january 1986 to include xmail.
99: * by epstein november 1987 to include CC:
100: * by epstein november 1987 to allow ^C exit to leave you in
101: * mail command processor
102: * by epstein november 1987 to substitute /usr/games/fortune
103: * for printing encrypted messages
104: * by rec february 1989 to tail to lauren weinstein's
105: * mail for alias expansion and uucp queuing.
106: * by wgl January 1990 to handle uucp mail more directly.
107: */
108:
109: char isummary[] = "\
110: \
111: Command summary:\n\
112: d Delete current message and print the next message\n\
113: m [user ...] Mail current message to each named 'user'\n\
114: p Print current message again\n\
115: q Quit and update the mailbox\n\
116: r Reverse direction of scan\n\
117: s [file ...] Save message in each named 'file'\n\
118: t [user ...] Mail standard input to each named 'user'\n\
119: w [file ...] Save message in each named 'file' without its header\n\
120: x Exit without updating mailbox\n\
121: newline Print the next message\n\
122: . Print current message again\n\
123: + Print the next message\n\
124: - Print the previous message\n\
125: EOF Put undeleted mail back into mailbox and quit\n\
126: ? Print this command summary\n\
127: !command Pass 'command' to the shell to execute\n\
128: If no 'file' is specified, 'mbox' in user's home directory is default.\n\
129: If no 'user' is specified, the invoking user is default.\n\
130: \
131: ";
132:
133: #include "mail.h"
134:
135: #define NARGS 64 /* Maximum # args to interactive command */
136:
137: #define TRACE printf
138: #define TRUE 1
139: #define FALSE 0
140:
141: extern char *getenv();
142: extern int optind;
143: extern char *optarg;
144: extern char getopt();
145: extern char *malloc();
146: int csplit();
147: char *eat_ws();
148: char *find_ws();
149: char *revnop();
150:
151: int mflag; /* `You have mail.' message to recipient */
152: int rflag; /* Reverse order of print */
153: int qflag; /* Exit after interrrupts */
154: int pflag; /* Print mail */
155: int verbflag; /* verbose */
156: int callmexmail; /* Xmail modifier present */
157: int callmermail; /* rmail modifier present */
158: struct msg {
159: struct msg *m_next; /* Link to next message */
160: struct msg *m_prev; /* Link to previous message */
161: int m_flag; /* Flags - non-zero if deleted */
162: int m_hsize; /* Size of header of message */
163: fsize_t m_seek; /* Start position of message */
164: fsize_t m_end; /* End of message */
165: };
166: struct msg *m_first = NULL; /* First message */
167: struct msg *m_last = NULL; /* Last message */
168:
169: struct tm *tp;
170:
171: char iusage[] = "Bad command--type '?' for command summary\n";
172: char nombox[] = "No mailbox '%s'.\n";
173: char nomail[] = "No mail.\n";
174: char noperm[] = "Mailbox '%s' access denied.\n";
175: char moerr[] = "Cannot open mailbox '%s'\n";
176: char wrerr[] = "Write error on '%s'\n";
177: char nosave[] = "Cannot save letter in '%s'\n";
178: char allocerr[] = "%s: Can't malloc.\n";
179:
180: FILE *mfp; /* Mailbox stream */
181: int myuid; /* User-id of mail user */
182: int mygid; /* Group-id of mail user */
183: char myname[25]; /* User name */
184: char myfullname[50];
185: char mymbox[256]; /* $HOME/mbox */
186: char mydead[256]; /* $HOME/dead.letter */
187: char mysig[256]; /* $HOME/.sig.mail */
188: char myalias[256]; /* $HOME/.aliases */
189: char spoolname[50] = SPOOLDIR;
190: char *mailbox = spoolname;
191: char cmdname[1024]; /* Command for x{en,de}code filter */
192: /* and for tail recursion to uumail */
193: /* and for editor recursion */
194:
195: char *args[NARGS]; /* Interactive command arglist */
196: char msgline[NLINE];
197: char cline[NCLINE] = "+\n";
198: char *temp; /* Currently open temp file */
199: char templ[] = "/tmp/mailXXXXXX"; /* Temp file name template */
200: char *editname; /* name of editor */
201: char *scatname; /* name of scat filter */
202: char *askcc; /* Ask for CC: list? (YES/NO) */
203:
204: /* fsize_t ftell(); */
205: char *getlogin();
206: char *mktemp();
207: int catchintr();
208: int catchpipe();
209: char asuser [32];
210:
211: typedef short int bool;
212: bool watch_first_msg;
213: bool delete_first_msg;
214:
215: main(argc, argv)
216: char *argv[];
217: {
218: register char *ap;
219: char c, *foo;
220: int i;
221:
222: umask(077);
223: logopen();
224:
225: /* Explicitly NULL out args. */
226: for (i = 0; i < NARGS; ++i) {
227: args[i] = NULL;
228: }
229:
230: ap = argv[0];
231: if ( (foo=rindex(ap, '/')) != NULL )
232: ap = foo+1;
233:
234: callmermail = (strcmp(ap, "rmail") == 0);
235: callmexmail = (strcmp(ap, "xmail") == 0);
236:
237: if (callmermail)
238: logdump("argv0 = rmail\n");
239:
240: asuser [0] = '\0';
241: signal(SIGINT, catchintr);
242: signal(SIGPIPE, catchpipe);
243: while ((c = getopt(argc, argv, "a:f:mpqrv")) != EOF) {
244: switch(c) {
245: case 'f':
246: if (!callmermail)
247: mailbox = optarg;
248: break;
249: case 'a':
250: strcpy(asuser, optarg);
251: break;
252: case 'm':
253: mflag++;
254: break;
255: case 'p':
256: pflag++;
257: break;
258: case 'q':
259: qflag++;
260: break;
261: case 'r':
262: rflag++;
263: break;
264: case 'v':
265: fprintf(stderr, "mail, ver. %s\n", revnop());
266: verbflag++;
267: break;
268: default:
269: usage();
270: }
271: }
272: if (callmermail)
273: verbflag = mflag = pflag = rflag = 0;
274: setname();
275: if (optind < argc) {
276: qflag = 1;
277: if ( send2(stdin, &argv[optind], (fsize_t)0,
278: (fsize_t)MAXLONG, 1) != 0 )
279: rmexit(1);
280: } else {
281: if ( ! pflag)
282: callmexmail = 0;
283: commands();
284: }
285: rmexit(0);
286: }
287:
288: /*
289: * Setup all the identities for the current user.
290: */
291: setname()
292: {
293: register struct passwd *pwp;
294: register char *np;
295: extern struct passwd * getpwnam();
296:
297: if (strlen(asuser) > 0) {
298: if((pwp = getpwnam(asuser)) == NULL)
299: merr("No such user %s.\n", asuser);
300: myuid = pwp -> pw_uid;
301: } else
302: myuid = getuid();
303: if ((pwp = getpwuid(myuid)) == NULL)
304: merr("Who are you?\n");
305: np = pwp->pw_name;
306: mygid = pwp->pw_gid;
307: strcat(spoolname, np);
308: strcpy(myname, np);
309: strcpy(myfullname, pwp->pw_gecos);
310: strcpy(mymbox, pwp->pw_dir);
311: strcat(mymbox, "/mbox");
312: strcpy(mydead, pwp->pw_dir);
313: strcat(mydead, "/dead.letter");
314: strcpy(mysig, pwp->pw_dir);
315: strcat(mysig, "/.sig.mail");
316: strcpy(myalias, pwp->pw_dir);
317: strcat(myalias, "/.aliases");
318: mktemp(templ);
319:
320: if ((editname=getenv("EDITOR"))==NULL)
321: editname = "/bin/ed";
322:
323: if ( ((scatname=getenv("PAGER")) != NULL) &&
324: (strlen(scatname) == 0) )
325: scatname = NULL;
326:
327: if ((askcc=getenv("ASKCC")) != NULL)
328: if ( strcmp(askcc, "YES") )
329: askcc = NULL;
330: }
331:
332: /*
333: * Process mail's interactive commands
334: * for reading/deleting/saving mail.
335: */
336: commands()
337: {
338: register struct msg *mp;
339: struct msg *dest;
340: struct stat filestats;
341: register char **fnp;
342: register FILE *fp;
343: fsize_t seek;
344: int need_to_add_sep;
345: char am_i_sep[7];
346: bool first_msg_read;
347: int testfile; /* used to test if file exists */
348:
349: readmail();
350: mprint(mp = rflag ? m_last : m_first);
351: for (;;) {
352: readmail();
353: intcheck();
354:
355: /* if pflag is set, then we will loop through and print all messages
356: * without stopping between messages for command prompts
357: */
358: if(!pflag){
359: callmexmail = 0;
360: mmsg("? ");
361: if (fgets(cline, sizeof cline, stdin) == NULL){
362: if(intcheck())
363: continue;
364: break;
365: }
366: }
367:
368: switch (cline[0]) {
369: case 'd':
370: if (cline[1] != '\n')
371: goto usage;
372: mp->m_flag += 1;
373: if(mp->m_seek == 5)
374: delete_first_msg = TRUE;
375: goto advance;
376:
377: case 'm':
378: case 't':
379: if (csplit(cline, args) == 1) {
380: /* We don't want to put anything into
381: args that we didn't get from malloc. */
382:
383: if (args[1] != NULL) {
384: free(args[1]);
385: }
386: args[1] = malloc(strlen(myname) + 1);
387: strcpy(args[1], myname);
388: args[2] = NULL;
389: }
390: callmexmail = (cline[1] == 'x');
391: if (cline[0] == 'm') {
392: /* when forwarding mail, seek to msg start + 5 to rid the msgsep */
393: send2(mfp, args+1, (mp->m_seek + 5), mp->m_end - ((sizeof(MSGSEP) - 1) *2), 0);
394: fseek(mfp, mp->m_seek, 0);
395: } else
396: send2(stdin, args+1, 0L, (fsize_t)MAXLONG, 1);
397: break;
398:
399: case '.':
400: case 'p':
401: if (cline[1] == 'x') {
402: callmexmail = 1;
403: if (cline[2] != '\n')
404: goto usage;
405: } else if (cline[1] != '\n')
406: goto usage;
407: if (mprint(mp))
408: break;
409: goto advance;
410:
411: case 'q':
412: if (cline[1] != '\n')
413: goto usage;
414: mquit();
415: /* NOTREACHED */
416:
417: case 'r':
418: if (cline[1] != '\n')
419: goto usage;
420: rflag = ! rflag;
421: break;
422: case 's':
423: case 'w':
424: if (csplit(cline, args) == 1) {
425: /* We don't want to put anything into
426: args that we didn't get from malloc. */
427:
428: if (args[1] != NULL) {
429: free(args[1]);
430: }
431: args[1] = malloc(strlen(mymbox) + 1);
432: strcpy(args[1], mymbox);
433: args[2] = NULL;
434: }
435: seek = mp->m_seek;
436: if (cline[0] == 'w')
437: seek += mp->m_hsize;
438: for (fnp = &args[1]; *fnp != NULL; fnp++) {
439: fp = NULL;
440:
441: testfile = stat(*fnp, &filestats);
442:
443: /* attempt to open the file and write */
444:
445: if ( (maccess(*fnp) < 0)
446: || ( (fp = fopen(*fnp,"a")) == NULL)
447: || (mcopy(mfp,fp,seek,mp->m_end,0)))
448: mmsg(nosave, *fnp);
449:
450: /* close the output file. Because some screwy 'not logic'
451: * was used to determine how msg seps were treated in elm
452: * (and I actually understood it after a while), it was
453: * semi implemented here for SCO mail format compatibility.
454: * Unfortunately, for reasons not clear to me yet, sometimes
455: * a message is copied to the out file with no msgsep appended
456: * to the end of it. So, after appending our message to the
457: * outfile, we will reopen the outfile, seek to the last
458: * byte - 5, and see if the last 5 bytes are a msgsep. If
459: * not, close the file and reopen for append and then write
460: * the msgsep.
461: */
462: if (fp != NULL) {
463: fflush(fp);
464: fclose(fp);
465: stat(*fnp,&filestats);
466: fp = fopen(*fnp,"r");
467: /* TRACE("Seeking to position %d\n",(filestats.st_size - 5)); */
468: fseek(fp,(filestats.st_size - 5),0);
469: fgets(am_i_sep,sizeof(MSGSEP),fp);
470: fclose(fp);
471: need_to_add_sep = strcmp(am_i_sep,MSGSEP
472: );
473: if(need_to_add_sep){
474: fp = fopen(*fnp,"a");
475: fprintf(fp,MSGSEP);
476: fflush(fp);
477: fclose(fp);
478: }
479:
480:
481: chown(*fnp, myuid, mygid);
482: }
483: }
484: break;
485:
486: case 'x':
487: if (cline[1] != '\n')
488: goto usage;
489: rmexit(0);
490: /* NOTREACHED */
491:
492: case '!':
493: if (system(cline+1) == 127)
494: mmsg("Try again\n");
495: else
496: mmsg("!\n");
497: break;
498:
499: case '?':
500: mmsg(isummary);
501: break;
502:
503: case '-':
504: if (cline[1] != '\n')
505: goto usage;
506: dest = rflag ? m_last : m_first;
507: goto nextmsg;
508:
509: case '+':
510: if (cline[1] != '\n')
511: goto usage;
512: case '\n':
513: advance:
514: dest = rflag ? m_first : m_last;
515: nextmsg:
516: do {
517: if (mp == dest) {
518: if (pflag)
519: return;
520: mmsg("No more messages.\n");
521: break;
522: }
523: mp = (dest==m_last) ? mp->m_next : mp->m_prev;
524: } while (mprint(mp) == 0);
525: break;
526:
527: default:
528: usage:
529: mmsg(iusage);
530: break;
531: }
532: }
533: putc('\n', stderr);
534: mquit();
535: }
536:
537: /*
538: * Read through the mail-box file
539: * constructing list of letters.
540: * On subsequent calls, append any additional mail
541: * and notify the user.
542: */
543: readmail()
544: {
545: typedef short int bool;
546: register struct msg *mp;
547: struct stat sb;
548: static long m_last_end;
549: int datasw;
550: bool newmsg;
551: static bool checked_format;
552: static fsize_t original_box_size;
553: char convert_cmd[65];
554:
555: if (m_first == NULL) {
556: if (stat(mailbox, &sb) < 0)
557: merr(nombox, mailbox);
558: if (sb.st_size == 0)
559: merr(nomail);
560:
561: /* the following will open the mailbox and read the first
562: * line. If it is not a MSGSEP, then a message will be printed
563: * to run cvmail and exit.
564: */
565:
566: if(!checked_format){
567: if ((mfp = fopen(mailbox, "r")) == NULL)
568: merr(moerr, mailbox);
569: if(fgets(msgline, sizeof msgline, mfp) == NULL){
570: printf("Can not determine mailbox format\n");
571: exit(1);
572: }
573: fclose(mfp);
574: checked_format = TRUE;
575: if(strcmp(MSGSEP, msgline)){
576: printf("Your mailbox or mailfile needs to be converted to the proper format.\n");
577: strcpy(convert_cmd, "/bin/cvmail ");
578: strcat(convert_cmd, mailbox);
579: printf("\nTo manually convert your mailbox, run: %s\n\n", convert_cmd);
580: exit(1);
581: }
582: }
583:
584: original_box_size = sb.st_size;
585: if (access(mailbox, AREAD) < 0)
586: merr(noperm, mailbox);
587: if ((mfp = fopen(mailbox, "r")) == NULL)
588: merr(moerr, mailbox);
589: m_last_end = 0;
590: } else {
591: fstat(fileno(mfp), &sb);
592: if (sb.st_size == m_last_end)
593: return;
594: if (sb.st_size != original_box_size){
595: mmsg("More mail received.\n");
596: original_box_size = sb.st_size;
597: }
598: }
599:
600: /* we will enter a loop which reads the mailbox line by line.
601: * When it hits a MSGSEP indicating the end of a mail message,
602: * a struct msg will be set with the start and end positions
603: * of the message read. We will continue through this loop until
604: * struct msg's have been built for all messages.
605: */
606:
607: newmsg = TRUE;
608: for(mlock(myuid);;) {
609: fseek(mfp, m_last_end, 0);
610: datasw = 0;
611: while (fgets(msgline, sizeof msgline, mfp) != NULL) {
612: /* NB: this means the implicit message
613: seperator is actually "\n\1\1\n". */
614: if(!(datasw = strcmp(MSGSEP, msgline))){
615:
616: /* message seperator */
617: if (((newmsg = !newmsg) == TRUE) && (ftell(mfp) != 5)){
618: mp = (struct msg *)myalloc(sizeof(*mp));
619: mp->m_next = NULL;
620: mp->m_prev = m_last;
621: mp->m_flag = mp->m_hsize = 0;
622: /* start position of msg */ mp->m_seek = m_last_end;
623: /* end position of msg */ mp->m_end = m_last_end = ftell(mfp);
624: /* TRACE("Message ends at %ld\n",ftell(mfp)); */
625: if (m_first == NULL)
626: m_last = m_first = mp;
627: else
628: m_last = m_last->m_next = mp;
629: }
630: }
631: }
632:
633: if(!datasw) /* data ended with message seperator */
634: break;
635:
636: /* unterminated data, patch and retry */
637: fclose(mfp);
638: if ((mfp = fopen(mailbox, "a")) == NULL)
639: merr(moerr, mailbox);
640: fprintf(mfp, MSGSEP); /* terminate it */
641: fclose(mfp);
642: if ((mfp = fopen(mailbox, "r")) == NULL)
643: merr(moerr, mailbox);
644: mmsg("Incomplete message found.\n");
645: }
646: munlock();
647: }
648:
649: /*
650: * Lock the appropriately-numbered mailbox
651: * (numbered by user-number) from multiple
652: * accesses. There is a (small) race here
653: * which will be overlooked for now.
654: */
655: char *lockname;
656:
657: mlock(uid)
658: int uid;
659: {
660: register int fd;
661: static char lock[32];
662:
663: lockname = lock;
664: sprintf(lock, "/tmp/maillock%d", uid);
665: while (access(lockname, 0) == 0)
666: sleep(1);
667: if ((fd = creat(lockname, 0)) >= 0)
668: close(fd);
669: }
670:
671: /*
672: * Unlock the currently-set lock (by `mlock')
673: * also called from rmexit.
674: */
675: munlock()
676: {
677: if (lockname != NULL)
678: unlink(lockname);
679: lockname = NULL;
680: }
681:
682: /*
683: * Exit, after rewriting the
684: * mailbox
685: */
686: mquit()
687: {
688: register struct msg *mp;
689: register FILE *nfp, *tmpfp;
690: struct stat sb;
691:
692: /* Get new stuff. */
693: readmail();
694: /* There is a slight race here. We really should
695: lock BEFORE the readmail(), but readmail() does unlocks...
696: FIX ME. */
697: mlock(myuid);
698:
699: if (mailbox != spoolname && maccess(mailbox) < 0)
700: merr(noperm, mailbox);
701: fstat(fileno(mfp), &sb);
702: signal(SIGINT, SIG_IGN);
703: signal(SIGPIPE, SIG_IGN);
704:
705: /* Make a copy of the mail box; we're going to overwrite it. */
706: tmpfp = tmp_copy(mfp);
707: fclose(mfp);
708:
709: if ((nfp = fopen(mailbox, "w")) == NULL)
710: merr("Cannot re-write '%s'\n", mailbox);
711: chown(mailbox, sb.st_uid, sb.st_gid);
712: chmod(mailbox, sb.st_mode&0777);
713: for (mp = m_first; mp != NULL; mp = mp->m_next) {
714:
715: if (mp->m_flag == 0) {
716: if(delete_first_msg){
717: mp->m_seek = mp->m_seek+5;
718: delete_first_msg = FALSE;
719: }
720: if (mcopy(tmpfp, nfp, mp->m_seek, mp->m_end, 0)) {
721: merr(wrerr, mailbox);
722: }
723: } /* if (mp->m_flag == 0) */
724:
725: } /* for (walk through the linked list of messages) */
726:
727: fclose(nfp);
728: fclose(tmpfp);
729: munlock();
730: rmexit(0);
731: }
732:
733: /*
734: * Print the current message, given by
735: * the message pointer (`mp').
736: */
737: mprint(mp)
738: register struct msg *mp;
739: {
740: FILE *xfp;
741:
742: if (mp->m_flag)
743: return 0;
744: if (callmexmail) {
745: if (scatname != NULL)
746: sprintf(cmdname, "xdecode | %s", scatname);
747: else
748: sprintf(cmdname, "xdecode");
749: if ((xfp = popen(cmdname, "w")) == NULL)
750: return 0;
751: fprintf(xfp, MSGSEP);
752: mcopy(mfp, xfp, mp->m_seek+mp->m_hsize, mp->m_end, 1);
753: pclose(xfp);
754: } else {
755: fseek(mfp, mp->m_seek, 0);
756: if (fgets(msgline, sizeof msgline, mfp) != NULL &&
757: strncmp(msgline, "From xmail", 10) == 0) {
758: printf("From xmail\n");
759: system("/usr/games/fortune");
760: return(1);
761: }
762: if (scatname != NULL) {
763: sprintf(cmdname, "%s", scatname);
764: if ((xfp = popen(cmdname, "w")) == NULL)
765: return(0);
766: mcopy(mfp, xfp, mp->m_seek, mp->m_end - 5, 1);
767: if ( ((pclose(xfp)>>8)&0xFF) == SIGINT )
768: putc('\n', stdout);
769: } else {
770: mcopy(mfp, stdout, mp->m_seek, mp->m_end - 5, 1);
771: }
772: }
773: return (1);
774: }
775:
776: /*
777: * Get additional users to receive message (CC:)
778: */
779:
780: char **
781: getcc()
782: {
783: static char names[NCLINE];
784: static char *ccargs[NARGS];
785:
786: ccargs[0] = NULL;
787: mmsg("CC: ");
788: if ( fgets(names, sizeof names, stdin) == NULL )
789: return(ccargs);
790:
791: csplit(names, ccargs);
792: return(ccargs);
793: }
794:
795:
796: /*
797: * Errors, usage, and exit removing
798: * any tempfiles left around.
799: */
800: mmsg(x)
801: {
802: fprintf(stderr, "%r", &x);
803: }
804:
805: merr(x, s)
806: char *x, *s;
807: {
808: mmsg(x, s);
809: logdump("merr: ");
810: logdump(x, s);
811: rmexit(1);
812: }
813:
814: rmexit(s)
815: int s;
816: {
817: if (temp != NULL)
818: unlink(temp);
819: munlock();
820:
821: logdump("About to exit, status = 0x%04x\n", s);
822: logclose();
823:
824: exit(s);
825: }
826:
827: /*
828: * Catch interrupts, taking the
829: * appropriate action based on
830: * the `-q' option.
831: */
832: int intrflag; /* On when interrupt sent */
833: int pipeflag; /* On when broken pipe caught */
834:
835: catchintr()
836: {
837: logdump("Caught SIGINT\n");
838: if (qflag)
839: rmexit(1);
840: intrflag = 1;
841: signal(SIGINT, catchintr);
842: }
843:
844: catchpipe()
845: {
846: logdump("Caught SIGPIPE\n");
847: pipeflag = 1;
848: signal(SIGPIPE, catchpipe);
849: }
850:
851: intcheck()
852: {
853: if (intrflag || pipeflag) {
854: if (intrflag)
855: putc('\n', stdout);
856: intrflag = pipeflag = 0;
857: return (1);
858: }
859: return (0);
860: }
861:
862: /*
863: * Call the system to execute a command line
864: * which is passed as an argument.
865: * Change the user id and group id.
866: */
867: system(line)
868: char *line;
869: {
870: int status, pid;
871: register wpid;
872: register int (*intfun)(), (*quitfun)();
873:
874: if ((pid = fork()) < 0)
875: return (-1);
876: if (pid == 0) { /* Child */
877: setuid(myuid);
878: setgid(mygid);
879: execl("/bin/sh", "sh", "-c", line, NULL);
880: exit(0177);
881: }
882: intfun = signal(SIGINT, SIG_IGN);
883: quitfun = signal(SIGQUIT, SIG_IGN);
884: while ((wpid = wait(&status))!=pid && wpid>=0)
885: ;
886: if (wpid < 0)
887: status = wpid;
888: signal(SIGINT, intfun);
889: signal(SIGQUIT, quitfun);
890: return (status);
891: }
892:
893: char *
894: revnop()
895: {
896: register char *cp;
897: register char c;
898: static char revnobuf[32];
899:
900: if ((cp = index(rcsrev, ' ')) != NULL) {
901: while (((c = *++cp) == ' ') && (c != '\0'))
902: ;
903: strcpy(revnobuf, cp);
904: if ((cp = index(revnobuf, ' ')) != NULL)
905: *cp = '\0';
906: return (revnobuf);
907: } else
908: return("OOPS");
909: }
910:
911: /*
912: * Split a command line up into
913: * argv (passed) and argc (returned).
914: * We assume that elements of "args" are either NULL or they were
915: * returned from malloc, so that they can be freed.
916: */
917: int
918: csplit(command, args)
919: char *command;
920: char **args;
921: {
922: register char *cp;
923: int i, argsize;
924:
925: i = 0; /* Start filling in at the zero'th arg. */
926: cp = eat_ws(command);
927:
928: /* Walk "cp" through "command", copying segments as we go. */
929: while ( *cp != CNULL ) {
930: /* We've found an argument; find some space. */
931: if (args[i] != NULL ) {
932: free(args[i]);
933: }
934:
935: /* Figure out how big the argment is. */
936: argsize = (int) (find_ws(cp) - cp);
937:
938: /* Alloc enough space for it--include the trailing NULL. */
939: if ((args[i] = malloc(argsize + 1)) == NULL) {
940: mmsg(allocerr, "csplit");
941: return(0); /* Is this the approriate action?? */
942: }
943:
944: /* Copy the argument into the space. */
945: memcpy(args[i], cp, argsize);
946: args[i][argsize] = CNULL; /* This may be redundant. */
947:
948: /* Make sure that cp points to after the argument. */
949: cp += argsize;
950:
951: cp = eat_ws(cp);
952: ++i;
953: } /* while (walk "cp" through "command") */
954:
955: args[i] = NULL;
956: return (i);
957: }
958:
959: /*
960: * Find the next occurence of non-white space in character string s.
961: */
962: char *
963: eat_ws(s)
964: char *s;
965: {
966: while(isspace(*s)){
967: ++s;
968: }
969: return(s);
970: }
971:
972: /*
973: * Find next occurence of white space in character string s.
974: */
975: char *
976: find_ws(s)
977: register char *s;
978: {
979: while((*s != CNULL) && !isspace(*s) ){
980: ++s;
981: }
982: return(s);
983: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.