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