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