![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / lbin / mailx|
Return to cmd3.c CVS log | Up to [Research Unix] / researchv10no / lbin / mailx |
1.1 ! root 1: #ident "@(#)cmd3.c 1.3 'attmail mail(1) command'" ! 2: #ident "@(#)mailx:cmd3.c 1.11.3.1" ! 3: /* Copyright (c) 1984 AT&T */ ! 4: /* All Rights Reserved */ ! 5: ! 6: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */ ! 7: /* The copyright notice above does not evidence any */ ! 8: /* actual or intended publication of such source code. */ ! 9: ! 10: #ident "@(#)mailx:cmd3.c 1.11.1.2" ! 11: ! 12: #include "rcv.h" ! 13: ! 14: /* ! 15: * mailx -- a modified version of a University of California at Berkeley ! 16: * mail program ! 17: * ! 18: * Still more user commands. ! 19: */ ! 20: ! 21: static int bangexp(); ! 22: static int diction(); ! 23: static char *getfilename(); ! 24: static int resp1(); ! 25: static int Resp1(); ! 26: static char *reedit(); ! 27: static int shell1(); ! 28: static void sort(); ! 29: ! 30: static char prevfile[PATHSIZE]; ! 31: static char origprevfile[PATHSIZE]; ! 32: static char lastbang[256]; ! 33: ! 34: /* ! 35: * Process a shell escape by saving signals, ignoring signals, ! 36: * and forking a sh -c ! 37: */ ! 38: ! 39: shell(str) ! 40: char *str; ! 41: { ! 42: shell1(str); ! 43: printf("!\n"); ! 44: return(0); ! 45: } ! 46: ! 47: static int ! 48: shell1(str) ! 49: char *str; ! 50: { ! 51: void (*sig[2])(); ! 52: int stat[1]; ! 53: register int t; ! 54: register pid_t p; ! 55: char *Shell; ! 56: char cmd[BUFSIZ]; ! 57: ! 58: strcpy(cmd, str); ! 59: if (bangexp(cmd) < 0) ! 60: return(-1); ! 61: if ((Shell = value("SHELL")) == NOSTR || *Shell=='\0') ! 62: Shell = SHELL; ! 63: for (t = SIGINT; t <= SIGQUIT; t++) ! 64: sig[t-SIGINT] = sigset(t, SIG_IGN); ! 65: p = fork(); ! 66: if (p == 0) { ! 67: sigchild(); ! 68: for (t = SIGINT; t <= SIGQUIT; t++) ! 69: if (sig[t-SIGINT] != (void (*)())SIG_IGN) /* adb */ ! 70: sigset(t, SIG_DFL); ! 71: execlp(Shell, Shell, "-c", cmd, (char *)0); ! 72: perror(Shell); ! 73: _exit(1); ! 74: } ! 75: while (wait(stat) != p) ! 76: ; ! 77: if (p == (pid_t)-1) ! 78: perror("fork"); ! 79: for (t = SIGINT; t <= SIGQUIT; t++) ! 80: sigset(t, sig[t-SIGINT]); ! 81: return(0); ! 82: } ! 83: ! 84: /* ! 85: * Fork an interactive shell. ! 86: */ ! 87: ! 88: dosh(str) ! 89: char *str; ! 90: { ! 91: void (*sig[2])(); ! 92: int stat[1]; ! 93: register int t; ! 94: register pid_t p; ! 95: char *Shell; ! 96: ! 97: (void) str; ! 98: if ((Shell = value("SHELL")) == NOSTR || *Shell=='\0') ! 99: Shell = SHELL; ! 100: for (t = SIGINT; t <= SIGQUIT; t++) ! 101: sig[t-SIGINT] = sigset(t, SIG_IGN); ! 102: p = fork(); ! 103: if (p == 0) { ! 104: sigchild(); ! 105: for (t = SIGINT; t <= SIGQUIT; t++) ! 106: if (sig[t-SIGINT] != (void (*)())SIG_IGN) /* adb */ ! 107: sigset(t, SIG_DFL); ! 108: execlp(Shell, Shell, (char *)0); ! 109: perror(Shell); ! 110: _exit(1); ! 111: } ! 112: while (wait(stat) != p) ! 113: ; ! 114: if (p == (pid_t)-1) ! 115: perror("fork"); ! 116: for (t = SIGINT; t <= SIGQUIT; t++) ! 117: sigset(t, sig[t-SIGINT]); ! 118: putchar('\n'); ! 119: return(0); ! 120: } ! 121: ! 122: /* ! 123: * Expand the shell escape by expanding unescaped !'s into the ! 124: * last issued command where possible. ! 125: */ ! 126: static int ! 127: bangexp(str) ! 128: char *str; ! 129: { ! 130: char bangbuf[BUFSIZ]; ! 131: register char *cp, *cp2; ! 132: register int n; ! 133: int changed = 0; ! 134: int bangit = (value("bang")!=NOSTR); ! 135: ! 136: cp = str; ! 137: cp2 = bangbuf; ! 138: n = BUFSIZ; ! 139: while (*cp) { ! 140: if (*cp=='!' && bangit) { ! 141: if (n < strlen(lastbang)) { ! 142: overf: ! 143: printf("Command buffer overflow\n"); ! 144: return(-1); ! 145: } ! 146: changed++; ! 147: strcpy(cp2, lastbang); ! 148: cp2 += strlen(lastbang); ! 149: n -= strlen(lastbang); ! 150: cp++; ! 151: continue; ! 152: } ! 153: if (*cp == '\\' && cp[1] == '!') { ! 154: if (--n <= 1) ! 155: goto overf; ! 156: *cp2++ = '!'; ! 157: cp += 2; ! 158: changed++; ! 159: } ! 160: if (--n <= 1) ! 161: goto overf; ! 162: *cp2++ = *cp++; ! 163: } ! 164: *cp2 = 0; ! 165: if (changed) { ! 166: printf("!%s\n", bangbuf); ! 167: fflush(stdout); ! 168: } ! 169: strcpy(str, bangbuf); ! 170: strncpy(lastbang, bangbuf, sizeof lastbang); ! 171: lastbang[(sizeof lastbang)-1] = 0; ! 172: return(0); ! 173: } ! 174: ! 175: /* ! 176: * Print out a nice help message from some file or another. ! 177: */ ! 178: ! 179: help() ! 180: { ! 181: register c; ! 182: register FILE *f; ! 183: ! 184: if ((f = fopen(HELPFILE, "r")) == NULL) { ! 185: printf("No help just now.\n"); ! 186: return(1); ! 187: } ! 188: while ((c = getc(f)) != EOF) ! 189: putchar(c); ! 190: fclose(f); ! 191: return(0); ! 192: } ! 193: ! 194: /* ! 195: * Change user's working directory. ! 196: */ ! 197: ! 198: schdir(str) ! 199: char *str; ! 200: { ! 201: register char *cp; ! 202: ! 203: for (cp = str; *cp == ' '; cp++) ! 204: ; ! 205: if (*cp == '\0') ! 206: cp = homedir; ! 207: else ! 208: if ((cp = expand(cp)) == NOSTR) ! 209: return(1); ! 210: if (chdir(cp) < 0) { ! 211: perror(cp); ! 212: return(1); ! 213: } ! 214: return(0); ! 215: } ! 216: ! 217: /* ! 218: * Reply to a list of messages. Extract each name from the ! 219: * message header and send them off to mail1() ! 220: */ ! 221: ! 222: respond(msgvec) ! 223: int *msgvec; ! 224: { ! 225: if (value("flipr") != NOSTR) return(Resp1(msgvec, 0)); ! 226: else return(resp1(msgvec, 0)); ! 227: } ! 228: ! 229: followup(msgvec) ! 230: int *msgvec; ! 231: { ! 232: if (value("flipf") != NOSTR) return(Resp1(msgvec, 1)); ! 233: else return(resp1(msgvec, 1)); ! 234: } ! 235: ! 236: static int ! 237: resp1(msgvec, useauthor) ! 238: int *msgvec; ! 239: { ! 240: char recfile[128]; ! 241: struct message *mp; ! 242: char *cp, buf[2 * LINESIZE], *rcv, *skin_rcv, *replyto, **ap; ! 243: struct name *np; ! 244: struct header head; ! 245: char mylocalname[100], mydomname[200]; ! 246: ! 247: if (msgvec[1] != 0) { ! 248: printf("Sorry, can't reply to multiple messages at once\n"); ! 249: return(1); ! 250: } ! 251: ! 252: strcpy(mylocalname, myname); ! 253: strcat(mylocalname, "@"); ! 254: strcpy(mydomname, mylocalname); ! 255: strcat(mylocalname, host); ! 256: strcat(mydomname, domain); ! 257: ! 258: mp = &message[msgvec[0] - 1]; ! 259: dot = mp; ! 260: ! 261: rcv = nameof(mp); ! 262: strncpy(recfile, rcv, sizeof recfile); ! 263: ! 264: if ((replyto = hfield("reply-to", mp, addto)) != NOSTR) ! 265: strcpy(buf, replyto); ! 266: else if ((cp = hfield("to", mp, addto)) != NOSTR) ! 267: strcpy(buf, cp); ! 268: else ! 269: strcpy(buf, ""); ! 270: np = elide(extract(buf, GTO)); ! 271: #ifdef OPTIM ! 272: /* rcv = netrename(rcv); */ ! 273: #endif /* OPTIM */ ! 274: /* ! 275: * Delete my name from the reply list, ! 276: * and with it, all my alternate names. ! 277: */ ! 278: skin_rcv = skin(rcv); ! 279: mapf(np, skin_rcv); ! 280: np = delname(np, myname); ! 281: np = delname(np, mylocalname); ! 282: np = delname(np, mydomname); ! 283: np = delname(np, skin_rcv); ! 284: if (altnames != 0) ! 285: for (ap = altnames; *ap; ap++) ! 286: np = delname(np, *ap); ! 287: head.h_seq = 1; ! 288: cp = detract(np, 0); ! 289: if (cp != NOSTR && replyto == NOSTR) { ! 290: strcpy(buf, cp); ! 291: strcat(buf, unuucp(rcv)); ! 292: strcat(buf, ", "); ! 293: } ! 294: else { ! 295: if (cp == NOSTR && replyto != NOSTR) ! 296: printf("Empty reply-to field -- replying to author\n"); ! 297: if (cp == NOSTR) { ! 298: strcpy(buf, unuucp(rcv)); ! 299: strcat(buf, ", "); ! 300: } else ! 301: strcpy(buf, cp); ! 302: } ! 303: head.h_to = buf; ! 304: head.h_subject = hfield("subject", mp, addone); ! 305: if (head.h_subject == NOSTR) ! 306: head.h_subject = hfield("subj", mp, addone); ! 307: head.h_subject = reedit(head.h_subject); ! 308: head.h_cc = NOSTR; ! 309: cp = hfield("cc", mp, addto); ! 310: if (cp != NOSTR) { ! 311: np = elide(extract(cp, GCC)); ! 312: mapf(np, skin_rcv); ! 313: np = delname(np, myname); ! 314: np = delname(np, mylocalname); ! 315: np = delname(np, mydomname); ! 316: np = delname(np, skin_rcv); ! 317: if (altnames != 0) ! 318: for (ap = altnames; *ap; ap++) ! 319: np = delname(np, *ap); ! 320: head.h_cc = detract(np, 0); ! 321: } ! 322: head.h_bcc = NOSTR; ! 323: head.h_defopt = NOSTR; ! 324: head.h_others = NOSTRPTR; ! 325: mail1(&head, useauthor ? recfile : 0); ! 326: return(0); ! 327: } ! 328: ! 329: void ! 330: getrecf(buf, recfile, useauthor) ! 331: char *buf, *recfile; ! 332: { ! 333: register char *bp, *cp; ! 334: register char *recf = recfile; ! 335: register int folderize = (value("outfolder")!=NOSTR); ! 336: ! 337: if (useauthor) { ! 338: if (folderize) ! 339: *recf++ = '+'; ! 340: if (debug) fprintf(stderr, "buf='%s'\n", buf); ! 341: for (bp=skin(buf), cp=recf; *bp && !any(*bp, ", "); bp++) ! 342: if (*bp=='!') ! 343: cp = recf; ! 344: else ! 345: *cp++ = *bp; ! 346: *cp = '\0'; ! 347: if (cp==recf) ! 348: *recfile = '\0'; ! 349: } else { ! 350: if ((cp = value("record")) && *cp) { ! 351: if (folderize && *cp!='+' && *cp!='/' ! 352: && *expand(cp)!='/') ! 353: *recf++ = '+'; ! 354: strcpy(recf, cp); ! 355: } else ! 356: *recf = '\0'; ! 357: } ! 358: if (debug) fprintf(stderr, "recfile='%s'\n", recfile); ! 359: } ! 360: ! 361: /* ! 362: * Modify the subject we are replying to to begin with Re: if ! 363: * it does not already. ! 364: */ ! 365: ! 366: static char * ! 367: reedit(subj) ! 368: char *subj; ! 369: { ! 370: char sbuf[10]; ! 371: register char *newsubj; ! 372: ! 373: if (subj == NOSTR) ! 374: return(NOSTR); ! 375: strncpy(sbuf, subj, 3); ! 376: sbuf[3] = 0; ! 377: if (icequal(sbuf, "re:")) ! 378: return(subj); ! 379: newsubj = salloc((unsigned)(strlen(subj) + 5)); ! 380: sprintf(newsubj, "Re: %s", subj); ! 381: return(newsubj); ! 382: } ! 383: ! 384: /* ! 385: * Preserve the named messages, so that they will be sent ! 386: * back to the system mailbox. ! 387: */ ! 388: ! 389: preserve(msgvec) ! 390: int *msgvec; ! 391: { ! 392: register struct message *mp; ! 393: register int *ip, mesg; ! 394: ! 395: if (edit) { ! 396: printf("Cannot \"preserve\" in edit mode\n"); ! 397: return(1); ! 398: } ! 399: for (ip = msgvec; *ip != NULL; ip++) { ! 400: mesg = *ip; ! 401: mp = &message[mesg-1]; ! 402: mp->m_flag |= MPRESERVE; ! 403: mp->m_flag &= ~MBOX; ! 404: dot = mp; ! 405: } ! 406: return(0); ! 407: } ! 408: ! 409: /* ! 410: * Print the size of each message. ! 411: */ ! 412: ! 413: messize(msgvec) ! 414: int *msgvec; ! 415: { ! 416: register struct message *mp; ! 417: register int *ip, mesg; ! 418: ! 419: for (ip = msgvec; *ip != NULL; ip++) { ! 420: mesg = *ip; ! 421: mp = &message[mesg-1]; ! 422: printf("%d: %ld\n", mesg, mp->m_size); ! 423: } ! 424: return(0); ! 425: } ! 426: ! 427: /* ! 428: * Quit quickly. If we are sourcing, just pop the input level ! 429: * by returning an error. ! 430: */ ! 431: ! 432: int ! 433: rexit(e) ! 434: { ! 435: if (sourcing) ! 436: return(1); ! 437: if (Tflag != NOSTR) ! 438: close(creat(Tflag, TEMPPERM)); ! 439: if (!edit) ! 440: Verhogen(); ! 441: exit(e); ! 442: /* NOTREACHED */ ! 443: } ! 444: ! 445: /* ! 446: * Set or display a variable value. Syntax is similar to that ! 447: * of csh. ! 448: */ ! 449: ! 450: set(arglist) ! 451: char **arglist; ! 452: { ! 453: register struct var *vp; ! 454: register char *cp, *cp2; ! 455: char varbuf[BUFSIZ], **ap, **p; ! 456: int errs, h, s; ! 457: ! 458: if (argcount(arglist) == 0) { ! 459: for (h = 0, s = 1; h < HSHSIZE; h++) ! 460: for (vp = variables[h]; vp != NOVAR; vp = vp->v_link) ! 461: s++; ! 462: ap = (char **) salloc(s * sizeof *ap); ! 463: for (h = 0, p = ap; h < HSHSIZE; h++) ! 464: for (vp = variables[h]; vp != NOVAR; vp = vp->v_link) ! 465: *p++ = vp->v_name; ! 466: *p = NOSTR; ! 467: sort(ap); ! 468: for (p = ap; *p != NOSTR; p++) ! 469: if (((cp = value(*p)) != 0) && *cp) ! 470: printf("%s=\"%s\"\n", *p, cp); ! 471: else ! 472: printf("%s\n", *p); ! 473: return(0); ! 474: } ! 475: errs = 0; ! 476: for (ap = arglist; *ap != NOSTR; ap++) { ! 477: cp = *ap; ! 478: cp2 = varbuf; ! 479: while (*cp != '=' && *cp != '\0') ! 480: *cp2++ = *cp++; ! 481: *cp2 = '\0'; ! 482: if (*cp == '\0') ! 483: cp = ""; ! 484: else ! 485: cp++; ! 486: if (equal(varbuf, "")) { ! 487: printf("Non-null variable name required\n"); ! 488: errs++; ! 489: continue; ! 490: } ! 491: assign(varbuf, cp); ! 492: } ! 493: return(errs); ! 494: } ! 495: ! 496: /* ! 497: * Unset a bunch of variable values. ! 498: */ ! 499: ! 500: unset(arglist) ! 501: char **arglist; ! 502: { ! 503: register int errs; ! 504: register char **ap; ! 505: ! 506: errs = 0; ! 507: for (ap = arglist; *ap != NOSTR; ap++) ! 508: errs += deassign(*ap); ! 509: return(errs); ! 510: } ! 511: ! 512: /* ! 513: * Check to see if environment variable should override variable settings ! 514: */ ! 515: ! 516: check_environment() ! 517: { ! 518: register struct var *vp; ! 519: register int h; ! 520: register char *cp; ! 521: ! 522: for( h =0; h < HSHSIZE; h++) { ! 523: for( vp = variables[h]; vp != NOVAR; vp = vp->v_link) { ! 524: if( (cp = getenv(vp->v_name)) != NULL) { ! 525: assign(vp->v_name,cp); ! 526: } ! 527: } ! 528: } ! 529: } ! 530: ! 531: /* ! 532: * Put add users to a group. ! 533: */ ! 534: ! 535: group(argv) ! 536: char **argv; ! 537: { ! 538: register struct grouphead *gh; ! 539: register struct mgroup *gp; ! 540: register int h; ! 541: int s; ! 542: char **ap, *gname, **p; ! 543: ! 544: if (argcount(argv) == 0) { ! 545: for (h = 0, s = 1; h < HSHSIZE; h++) ! 546: for (gh = groups[h]; gh != NOGRP; gh = gh->g_link) ! 547: s++; ! 548: ap = (char **) salloc(s * sizeof *ap); ! 549: for (h = 0, p = ap; h < HSHSIZE; h++) ! 550: for (gh = groups[h]; gh != NOGRP; gh = gh->g_link) ! 551: *p++ = gh->g_name; ! 552: *p = NOSTR; ! 553: sort(ap); ! 554: for (p = ap; *p != NOSTR; p++) ! 555: printgroup(*p); ! 556: return(0); ! 557: } ! 558: if (argcount(argv) == 1) { ! 559: printgroup(*argv); ! 560: return(0); ! 561: } ! 562: gname = *argv; ! 563: h = hash(gname); ! 564: if ((gh = findgroup(gname)) == NOGRP) { ! 565: gh = (struct grouphead *) calloc(sizeof *gh, 1); ! 566: gh->g_name = vcopy(gname); ! 567: gh->g_list = NOGE; ! 568: gh->g_link = groups[h]; ! 569: groups[h] = gh; ! 570: } ! 571: ! 572: /* ! 573: * Insert names from the command list into the group. ! 574: * Who cares if there are duplicates? They get tossed ! 575: * later anyway. ! 576: */ ! 577: ! 578: for (ap = argv+1; *ap != NOSTR; ap++) { ! 579: gp = (struct mgroup *) calloc(sizeof *gp, 1); ! 580: gp->ge_name = vcopy(*ap); ! 581: gp->ge_link = gh->g_list; ! 582: gh->g_list = gp; ! 583: } ! 584: return(0); ! 585: } ! 586: ! 587: /* ! 588: * Sort the passed string vecotor into ascending dictionary ! 589: * order. ! 590: */ ! 591: ! 592: static void ! 593: sort(list) ! 594: char **list; ! 595: { ! 596: register char **ap; ! 597: ! 598: for (ap = list; *ap != NOSTR; ap++) ! 599: ; ! 600: if (ap-list < 2) ! 601: return; ! 602: qsort(list, ap-list, sizeof *list, diction); ! 603: } ! 604: ! 605: /* ! 606: * Do a dictionary order comparison of the arguments from ! 607: * qsort. ! 608: */ ! 609: static int ! 610: diction(a, b) ! 611: register char **a, **b; ! 612: { ! 613: return(strcmp(*a, *b)); ! 614: } ! 615: ! 616: /* ! 617: * The do nothing command for comments. ! 618: */ ! 619: ! 620: null(e) ! 621: char *e; ! 622: { ! 623: (void) e; ! 624: return(0); ! 625: } ! 626: ! 627: /* ! 628: * Print out the current edit file, if we are editing. ! 629: * Otherwise, print the name of the person who's mail ! 630: * we are reading. ! 631: */ ! 632: int ! 633: file(argv) ! 634: char **argv; ! 635: { ! 636: register char *cp; ! 637: int edit; ! 638: ! 639: if (argv[0] == NOSTR) { ! 640: newfileinfo(); ! 641: return(0); ! 642: } ! 643: ! 644: /* ! 645: * Acker's! Must switch to the new file. ! 646: * We use a funny interpretation -- ! 647: * # -- gets the previous file ! 648: * % -- gets the invoker's post office box ! 649: * %user -- gets someone else's post office box ! 650: * & -- gets invoker's mbox file ! 651: * string -- reads the given file ! 652: */ ! 653: ! 654: cp = getfilename(argv[0], &edit); ! 655: if (cp == NOSTR) ! 656: return(-1); ! 657: if (setfile(cp, edit)) { ! 658: strcpy(origname, origprevfile); ! 659: return(-1); ! 660: } ! 661: newfileinfo(); ! 662: return(0); ! 663: } ! 664: ! 665: /* ! 666: * Evaluate the string given as a new mailbox name. ! 667: * Ultimately, we want this to support a number of meta characters. ! 668: * Possibly: ! 669: * % -- for my system mail box ! 670: * %user -- for user's system mail box ! 671: * # -- for previous file ! 672: * & -- get's invoker's mbox file ! 673: * file name -- for any other file ! 674: */ ! 675: ! 676: static char * ! 677: getfilename(name, aedit) ! 678: char *name; ! 679: int *aedit; ! 680: { ! 681: register char *cp; ! 682: char savename[BUFSIZ]; ! 683: char oldmailname[BUFSIZ]; ! 684: char tmp[BUFSIZ]; ! 685: ! 686: /* ! 687: * Assume we will be in "edit file" mode, until ! 688: * proven wrong. ! 689: */ ! 690: *aedit = 1; ! 691: switch (*name) { ! 692: case '%': ! 693: *aedit = 0; ! 694: strcpy(prevfile, mailname); ! 695: strcpy(origprevfile, origname); ! 696: if (name[1] != 0) { ! 697: strcpy(savename, myname); ! 698: strcpy(oldmailname, mailname); ! 699: strncpy(myname, name+1, PATHSIZE-1); ! 700: myname[PATHSIZE-1] = 0; ! 701: findmail(); ! 702: cp = savestr(mailname); ! 703: strcpy(origname, cp); ! 704: strcpy(myname, savename); ! 705: strcpy(mailname, oldmailname); ! 706: return(cp); ! 707: } ! 708: strcpy(oldmailname, mailname); ! 709: findmail(); ! 710: cp = savestr(mailname); ! 711: strcpy(mailname, oldmailname); ! 712: strcpy(origname, cp); ! 713: return(cp); ! 714: ! 715: case '#': ! 716: if (name[1] != 0) ! 717: goto regular; ! 718: if (prevfile[0] == 0) { ! 719: printf("No previous file\n"); ! 720: return(NOSTR); ! 721: } ! 722: cp = savestr(prevfile); ! 723: strcpy(prevfile, mailname); ! 724: strcpy(tmp, origname); ! 725: strcpy(origname, origprevfile); ! 726: strcpy(origprevfile, tmp); ! 727: return(cp); ! 728: ! 729: case '&': ! 730: strcpy(prevfile, mailname); ! 731: strcpy(origprevfile, origname); ! 732: if (name[1] == 0) { ! 733: char *tmp; ! 734: tmp=Getf("MBOX"); ! 735: strcpy(origname, tmp); ! 736: return(tmp); ! 737: } ! 738: /* Fall into . . . */ ! 739: ! 740: default: ! 741: regular: ! 742: strcpy(prevfile, mailname); ! 743: strcpy(origprevfile, origname); ! 744: cp = expand(name); ! 745: strcpy(origname, cp); ! 746: if (cp[0] != '/') { ! 747: name = getcwd(NOSTR, PATHSIZE); ! 748: strcat(name, "/"); ! 749: strcat(name, cp); ! 750: cp = name; ! 751: } ! 752: return(cp); ! 753: } ! 754: } ! 755: ! 756: /* ! 757: * Expand file names like echo ! 758: */ ! 759: ! 760: echo(str) ! 761: char *str; ! 762: { ! 763: char cmd[LINESIZE]; ! 764: ! 765: sprintf(cmd, "echo %s", str); ! 766: shell1(cmd); ! 767: return(0); ! 768: } ! 769: ! 770: /* ! 771: * Reply to a series of messages by simply mailing to the senders ! 772: * and not messing around with the To: and Cc: lists as in normal ! 773: * reply. ! 774: */ ! 775: ! 776: Respond(msgvec) ! 777: int msgvec[]; ! 778: { ! 779: if (value("flipr") != NOSTR) return(resp1(msgvec, 0)); ! 780: else return(Resp1(msgvec, 0)); ! 781: } ! 782: ! 783: Followup(msgvec) ! 784: int *msgvec; ! 785: { ! 786: if (value("flipf") != NOSTR) return(resp1(msgvec, 1)); ! 787: else return(Resp1(msgvec, 1)); ! 788: } ! 789: ! 790: static int ! 791: Resp1(msgvec, useauthor) ! 792: int *msgvec; ! 793: { ! 794: char recfile[128]; ! 795: struct header head; ! 796: struct message *mp; ! 797: register int s, *ap; ! 798: register char *cp, *subject; ! 799: ! 800: #ifdef V9 ! 801: /* just use UPAS-envelopes for return addresses */ ! 802: extern char *Fromname(); ! 803: ! 804: for (s = 0, ap = msgvec; *ap != 0; ap++) { ! 805: mp = &message[*ap - 1]; ! 806: dot = mp; ! 807: s += strlen(Fromname(mp)) + 2; ! 808: } ! 809: if (s == 0) ! 810: return(0); ! 811: cp = salloc(++s); ! 812: head.h_to = cp; ! 813: for (ap = msgvec; *ap != 0; ap++) { ! 814: mp = &message[*ap - 1]; ! 815: cp = copy(Fromname(mp), cp); ! 816: *cp++ = ','; ! 817: *cp++ = ' '; ! 818: } ! 819: *cp = 0; ! 820: #else ! 821: for (s = 0, ap = msgvec; *ap != 0; ap++) { ! 822: mp = &message[*ap - 1]; ! 823: dot = mp; ! 824: s += strlen(nameof(mp)) + 2; ! 825: } ! 826: if (s == 0) ! 827: return(0); ! 828: cp = salloc((unsigned)(++s)); ! 829: head.h_to = cp; ! 830: for (ap = msgvec; *ap != 0; ap++) { ! 831: mp = &message[*ap - 1]; ! 832: cp = copy(nameof(mp), cp); ! 833: *cp++ = ','; ! 834: *cp++ = ' '; ! 835: } ! 836: *cp = 0; ! 837: #endif /* V9 */ ! 838: strncpy(recfile, head.h_to, sizeof recfile); ! 839: mp = &message[msgvec[0] - 1]; ! 840: subject = hfield("subject", mp, addone); ! 841: head.h_seq = 1; ! 842: if (subject == NOSTR) ! 843: subject = hfield("subj", mp, addone); ! 844: head.h_subject = reedit(subject); ! 845: if (subject != NOSTR) ! 846: head.h_seq++; ! 847: head.h_cc = NOSTR; ! 848: head.h_bcc = NOSTR; ! 849: head.h_defopt = NOSTR; ! 850: head.h_others = NOSTRPTR; ! 851: mail1(&head, useauthor ? recfile : 0); ! 852: return(0); ! 853: } ! 854: ! 855: /* ! 856: * Conditional commands. These allow one to parameterize one's ! 857: * .mailrc and do some things if sending, others if receiving. ! 858: */ ! 859: ! 860: ifcmd(argv) ! 861: char **argv; ! 862: { ! 863: register char *cp; ! 864: ! 865: if (cond != CANY) { ! 866: printf("Illegal nested \"if\"\n"); ! 867: return(1); ! 868: } ! 869: cond = CANY; ! 870: cp = argv[0]; ! 871: switch (*cp) { ! 872: case 'r': case 'R': ! 873: cond = CRCV; ! 874: break; ! 875: ! 876: case 's': case 'S': ! 877: cond = CSEND; ! 878: break; ! 879: ! 880: default: ! 881: printf("Unrecognized if-keyword: \"%s\"\n", cp); ! 882: return(1); ! 883: } ! 884: return(0); ! 885: } ! 886: ! 887: /* ! 888: * Implement 'else'. This is pretty simple -- we just ! 889: * flip over the conditional flag. ! 890: */ ! 891: ! 892: elsecmd() ! 893: { ! 894: ! 895: switch (cond) { ! 896: case CANY: ! 897: printf("\"Else\" without matching \"if\"\n"); ! 898: return(1); ! 899: ! 900: case CSEND: ! 901: cond = CRCV; ! 902: break; ! 903: ! 904: case CRCV: ! 905: cond = CSEND; ! 906: break; ! 907: ! 908: default: ! 909: printf("invalid condition encountered\n"); ! 910: cond = CANY; ! 911: break; ! 912: } ! 913: return(0); ! 914: } ! 915: ! 916: /* ! 917: * End of if statement. Just set cond back to anything. ! 918: */ ! 919: ! 920: endifcmd() ! 921: { ! 922: ! 923: if (cond == CANY) { ! 924: printf("\"Endif\" without matching \"if\"\n"); ! 925: return(1); ! 926: } ! 927: cond = CANY; ! 928: return(0); ! 929: } ! 930: ! 931: /* ! 932: * Set the list of alternate names. ! 933: */ ! 934: alternates(namelist) ! 935: char **namelist; ! 936: { ! 937: register int c; ! 938: register char **ap, **ap2, *cp; ! 939: ! 940: c = argcount(namelist) + 1; ! 941: if (c == 1) { ! 942: if (altnames == 0) ! 943: return(0); ! 944: for (ap = altnames; *ap; ap++) ! 945: printf("%s ", *ap); ! 946: printf("\n"); ! 947: return(0); ! 948: } ! 949: if (altnames != 0) ! 950: free((char *) altnames); ! 951: altnames = (char **) calloc(c, sizeof (char *)); ! 952: for (ap = namelist, ap2 = altnames; *ap; ap++, ap2++) { ! 953: cp = (char *) calloc(strlen(*ap) + 1, sizeof (char)); ! 954: strcpy(cp, *ap); ! 955: *ap2 = cp; ! 956: } ! 957: *ap2 = 0; ! 958: return(0); ! 959: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.