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