![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / mf|
Return to mf.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / mf |
1.1 ! root 1: /* mf.c - mail filter subroutines */ ! 2: ! 3: #include "mf.h" ! 4: #include <ctype.h> ! 5: #include <stdio.h> ! 6: ! 7: /* */ ! 8: ! 9: static char *getcpy (s) ! 10: register char *s; ! 11: { ! 12: register char *p; ! 13: ! 14: if ((p = malloc ((unsigned) (strlen (s) + 2))) != NULL) ! 15: (void) strcpy (p, s); ! 16: return p; ! 17: } ! 18: ! 19: ! 20: static char *add (s1, s2) ! 21: register char *s1, ! 22: *s2; ! 23: { ! 24: register char *p; ! 25: ! 26: if (s2 == NULL) ! 27: return getcpy (s1); ! 28: ! 29: if ((p = malloc ((unsigned) (strlen (s1) + strlen (s2) + 2))) != NULL) ! 30: (void) sprintf (p, "%s%s", s2, s1); ! 31: free (s2); ! 32: return p; ! 33: } ! 34: ! 35: /* */ ! 36: ! 37: int isfrom (string) ! 38: register char *string; ! 39: { ! 40: return (strncmp (string, "From ", 5) == 0 ! 41: || strncmp (string, ">From ", 6) == 0); ! 42: } ! 43: ! 44: ! 45: int lequal (a, b) ! 46: register char *a, ! 47: *b; ! 48: { ! 49: for (; *a; a++, b++) ! 50: if (*b == NULL) ! 51: return FALSE; ! 52: else { ! 53: char c1 = islower (*a) ? toupper (*a) : *a; ! 54: char c2 = islower (*b) ? toupper (*b) : *b; ! 55: if (c1 != c2) ! 56: return FALSE; ! 57: } ! 58: ! 59: return (*b == NULL); ! 60: } ! 61: ! 62: /* */ ! 63: ! 64: /* ! 65: * ! 66: * seekadrx() is tricky. We want to cover both UUCP-style and ARPA-style ! 67: * addresses, so for each list of addresses we see if we can find some ! 68: * character to give us a hint. ! 69: * ! 70: */ ! 71: ! 72: ! 73: #define CHKADR 0 /* undertermined address style */ ! 74: #define UNIXDR 1 /* UNIX-style address */ ! 75: #define ARPADR 2 /* ARPAnet-style address */ ! 76: ! 77: ! 78: static char *punctuators = ";<>.()[]"; ! 79: static char *vp = NULL; ! 80: static char *tp = NULL; ! 81: ! 82: static struct adrx adrxs1; ! 83: ! 84: /* */ ! 85: ! 86: struct adrx *seekadrx (addrs) ! 87: register char *addrs; ! 88: { ! 89: static int state = CHKADR; ! 90: register char *cp; ! 91: register struct adrx *adrxp; ! 92: ! 93: if (state == CHKADR) ! 94: for (state = UNIXDR, cp = addrs; *cp; cp++) ! 95: if (index (punctuators, *cp)) { ! 96: state = ARPADR; ! 97: break; ! 98: } ! 99: ! 100: switch (state) { ! 101: case UNIXDR: ! 102: adrxp = uucpadrx (addrs); ! 103: break; ! 104: ! 105: case ARPADR: ! 106: default: ! 107: adrxp = getadrx (addrs); ! 108: break; ! 109: } ! 110: ! 111: if (adrxp == NULL) ! 112: state = CHKADR; ! 113: ! 114: return adrxp; ! 115: } ! 116: ! 117: /* */ ! 118: ! 119: /* ! 120: * ! 121: * uucpadrx() implements a partial UUCP-style address parser. It's based ! 122: * on the UUCP notion that addresses are separated by spaces or commas. ! 123: * ! 124: */ ! 125: ! 126: ! 127: struct adrx *uucpadrx (addrs) ! 128: register char *addrs; ! 129: { ! 130: register char *cp, ! 131: *wp, ! 132: *xp, ! 133: *yp, ! 134: *zp; ! 135: register struct adrx *adrxp = &adrxs1; ! 136: ! 137: if (vp == NULL) { ! 138: vp = tp = getcpy (addrs); ! 139: compress (addrs, vp); ! 140: } ! 141: else ! 142: if (tp == NULL) { ! 143: free (vp); ! 144: vp = NULL; ! 145: return NULL; ! 146: } ! 147: ! 148: for (cp = tp; isspace (*cp); cp++) ! 149: continue; ! 150: if (*cp == NULL) { ! 151: free (vp); ! 152: vp = tp = NULL; ! 153: return NULL; ! 154: } ! 155: ! 156: /* */ ! 157: ! 158: if ((wp = index (cp, ',')) == NULL) ! 159: if ((wp = index (cp, ' ')) != NULL) { ! 160: xp = wp; ! 161: while (isspace (*xp)) ! 162: xp++; ! 163: if (*xp != NULL && isat (--xp)) { ! 164: yp = xp + 4; ! 165: while (isspace (*yp)) ! 166: yp++; ! 167: if (*yp != NULL) ! 168: if ((zp = index (yp, ' ')) != NULL) ! 169: *zp = NULL, tp = ++zp; ! 170: else ! 171: tp = NULL; ! 172: else ! 173: *wp = NULL, tp = ++wp; ! 174: } ! 175: else ! 176: *wp = NULL, tp = ++wp; ! 177: } ! 178: else ! 179: tp = NULL; ! 180: else ! 181: *wp = NULL, tp = ++wp; ! 182: ! 183: if (adrxp -> text) ! 184: free (adrxp -> text); ! 185: adrxp -> text = getcpy (cp); ! 186: adrxp -> mbox = cp; ! 187: adrxp -> host = adrxp -> path = NULL; ! 188: if ((wp = rindex (cp, '@')) != NULL) { ! 189: *wp++ = NULL; ! 190: adrxp -> host = *wp ? wp : NULL; ! 191: } ! 192: else ! 193: for (wp = cp + strlen (cp) - 4; wp >= cp; wp--) ! 194: if (isat (wp)) { ! 195: *wp++ = NULL; ! 196: adrxp -> host = wp + 3; ! 197: } ! 198: ! 199: adrxp -> pers = adrxp -> grp = adrxp -> note = adrxp -> err = NULL; ! 200: adrxp -> ingrp = 0; ! 201: ! 202: return adrxp; ! 203: } ! 204: ! 205: /* */ ! 206: ! 207: static int compress (fp, tp) ! 208: register char *fp, ! 209: *tp; ! 210: { ! 211: register char c, ! 212: *cp; ! 213: ! 214: for (c = ' ', cp = tp; (*tp = *fp++) != NULL;) ! 215: if (isspace (*tp)) { ! 216: if (c != ' ') ! 217: *tp++ = c = ' '; ! 218: } ! 219: else ! 220: c = *tp++; ! 221: ! 222: if (c == ' ' && cp < tp) ! 223: *--tp = NULL; ! 224: } ! 225: ! 226: ! 227: static int isat (p) ! 228: register char *p; ! 229: { ! 230: return (strncmp (p, " AT ", 4) ! 231: && strncmp (p, " At ", 4) ! 232: && strncmp (p, " aT ", 4) ! 233: && strncmp (p, " at ", 4) ? FALSE : TRUE); ! 234: } ! 235: ! 236: /* */ ! 237: ! 238: /* ! 239: * ! 240: * getadrx() implements a partial 822-style address parser. The parser ! 241: * is neither complete nor correct. It does however recognize nearly all ! 242: * of the 822 address syntax. In addition it handles the majority of the ! 243: * 733 syntax as well. Most problems arise from trying to accomodate both. ! 244: * ! 245: * In terms of 822, the route-specification in ! 246: * ! 247: * "<" [route] local-part "@" domain ">" ! 248: * ! 249: * is parsed and returned unchanged. Multiple at-signs are compressed ! 250: * via source-routing. Recursive groups are not allowed as per the ! 251: * standard. ! 252: * ! 253: * In terms of 733, " at " is recognized as equivalent to "@". ! 254: * ! 255: * In terms of both the parser will not complain about missing hosts. ! 256: * ! 257: * ----- ! 258: * ! 259: * We should not allow addresses like ! 260: * ! 261: * Marshall T. Rose <MRose@UCI> ! 262: * ! 263: * but should insist on ! 264: * ! 265: * "Marshall T. Rose" <MRose@UCI> ! 266: * ! 267: * Unfortunately, a lot of mailers stupidly let people get away with this. ! 268: * ! 269: * ----- ! 270: * ! 271: * We should not allow addresses like ! 272: * ! 273: * <MRose@UCI> ! 274: * ! 275: * but should insist on ! 276: * ! 277: * MRose@UCI ! 278: * ! 279: * Unfortunately, a lot of mailers stupidly let people's UAs get away with ! 280: * this. ! 281: * ! 282: * ----- ! 283: * ! 284: * We should not allow addresses like ! 285: * ! 286: * @UCI:MRose@UCI-750a ! 287: * ! 288: * but should insist on ! 289: * ! 290: * Marshall Rose <@UCI:MRose@UCI-750a> ! 291: * ! 292: * Unfortunately, a lot of mailers stupidly do this. ! 293: * ! 294: */ ! 295: ! 296: /* */ ! 297: ! 298: #define QUOTE '\\' ! 299: ! 300: #define LX_END 0 ! 301: #define LX_ERR 1 ! 302: #define LX_ATOM 2 ! 303: #define LX_QSTR 3 ! 304: #define LX_DLIT 4 ! 305: #define LX_SEMI 5 ! 306: #define LX_COMA 6 ! 307: #define LX_LBRK 7 ! 308: #define LX_RBRK 8 ! 309: #define LX_COLN 9 ! 310: #define LX_DOT 10 ! 311: #define LX_AT 11 ! 312: ! 313: static struct { ! 314: char lx_chr; ! 315: int lx_val; ! 316: } special[] = { ! 317: ';', LX_SEMI, ! 318: ',', LX_COMA, ! 319: '<', LX_LBRK, ! 320: '>', LX_RBRK, ! 321: ':', LX_COLN, ! 322: '.', LX_DOT, ! 323: '@', LX_AT, ! 324: '(', LX_ERR, ! 325: ')', LX_ERR, ! 326: QUOTE, LX_ERR, ! 327: '"', LX_ERR, ! 328: '[', LX_ERR, ! 329: ']', LX_ERR, ! 330: NULL, NULL ! 331: }; ! 332: ! 333: /* */ ! 334: ! 335: static int glevel = 0; ! 336: static int ingrp = 0; ! 337: static int last_lex = LX_END; ! 338: ! 339: static char *dp = NULL; ! 340: static char *cp = NULL; ! 341: static char *ap = NULL; ! 342: static char *pers = NULL; ! 343: static char *mbox = NULL; ! 344: static char *host = NULL; ! 345: static char *path = NULL; ! 346: static char *grp = NULL; ! 347: static char *note = NULL; ! 348: static char err[BUFSIZ]; ! 349: static char adr[BUFSIZ]; ! 350: ! 351: static struct adrx adrxs2; ! 352: ! 353: /* */ ! 354: ! 355: struct adrx *getadrx (addrs) ! 356: register char *addrs; ! 357: { ! 358: register char *bp; ! 359: register struct adrx *adrxp = &adrxs2; ! 360: ! 361: if (pers) ! 362: free (pers); ! 363: if (mbox) ! 364: free (mbox); ! 365: if (host) ! 366: free (host); ! 367: if (path) ! 368: free (path); ! 369: if (grp) ! 370: free (grp); ! 371: if (note) ! 372: free (note); ! 373: pers = mbox = host = path = grp = note = NULL; ! 374: err[0] = NULL; ! 375: ! 376: if (dp == NULL) { ! 377: dp = cp = getcpy (addrs); ! 378: glevel = 0; ! 379: } ! 380: else ! 381: if (cp == NULL) { ! 382: free (dp); ! 383: dp = NULL; ! 384: return NULL; ! 385: } ! 386: ! 387: switch (parse_address ()) { ! 388: case DONE: ! 389: free (dp); ! 390: dp = cp = NULL; ! 391: return NULL; ! 392: ! 393: case OK: ! 394: switch (last_lex) { ! 395: case LX_COMA: ! 396: case LX_END: ! 397: break; ! 398: ! 399: default: /* catch trailing comments */ ! 400: bp = cp; ! 401: (void) my_lex (adr); ! 402: cp = bp; ! 403: break; ! 404: } ! 405: break; ! 406: ! 407: default: ! 408: break; ! 409: } ! 410: ! 411: if (err[0]) ! 412: for (;;) { ! 413: switch (last_lex) { ! 414: case LX_COMA: ! 415: case LX_END: ! 416: break; ! 417: ! 418: default: ! 419: (void) my_lex (adr); ! 420: continue; ! 421: } ! 422: break; ! 423: } ! 424: while (isspace (*ap)) ! 425: ap++; ! 426: if (cp) ! 427: (void) sprintf (adr, "%.*s", cp - ap, ap); ! 428: else ! 429: (void) strcpy (adr, ap); ! 430: bp = adr + strlen (adr) - 1; ! 431: if (*bp == ',' || *bp == ';' || *bp == '\n') ! 432: *bp = NULL; ! 433: ! 434: /* */ ! 435: ! 436: adrxp -> text = adr; ! 437: adrxp -> pers = pers; ! 438: adrxp -> mbox = mbox; ! 439: adrxp -> host = host; ! 440: adrxp -> path = path; ! 441: adrxp -> grp = grp; ! 442: adrxp -> ingrp = ingrp; ! 443: adrxp -> note = note; ! 444: adrxp -> err = err[0] ? err : NULL; ! 445: ! 446: return adrxp; ! 447: } ! 448: ! 449: /* */ ! 450: ! 451: static int parse_address () { ! 452: char buffer[BUFSIZ]; ! 453: ! 454: again: ; ! 455: ap = cp; ! 456: switch (my_lex (buffer)) { ! 457: case LX_ATOM: ! 458: case LX_QSTR: ! 459: pers = getcpy (buffer); ! 460: break; ! 461: ! 462: case LX_SEMI: ! 463: if (glevel-- <= 0) { ! 464: (void) strcpy (err, "extraneous semi-colon"); ! 465: return NOTOK; ! 466: } ! 467: case LX_COMA: ! 468: if (note) { ! 469: free (note); ! 470: note = NULL; ! 471: } ! 472: goto again; ! 473: ! 474: case LX_END: ! 475: return DONE; ! 476: ! 477: case LX_LBRK: /* sigh (2) */ ! 478: goto get_addr; ! 479: ! 480: case LX_AT: /* sigh (3) */ ! 481: cp = ap; ! 482: if (route_addr (buffer) == NOTOK) ! 483: return NOTOK; ! 484: return OK; /* why be choosy? */ ! 485: ! 486: default: ! 487: (void) sprintf (err, "illegal address construct (%s)", buffer); ! 488: return NOTOK; ! 489: } ! 490: ! 491: /* */ ! 492: ! 493: switch (my_lex (buffer)) { ! 494: case LX_ATOM: ! 495: case LX_QSTR: ! 496: pers = add (buffer, add (" ", pers)); ! 497: more_phrase: ; /* sigh (1) */ ! 498: if (phrase (buffer) == NOTOK) ! 499: return NOTOK; ! 500: ! 501: switch (last_lex) { ! 502: case LX_LBRK: ! 503: get_addr: ; ! 504: if (route_addr (buffer) == NOTOK) ! 505: return NOTOK; ! 506: if (last_lex == LX_RBRK) ! 507: return OK; ! 508: (void) sprintf (err, "missing right-bracket (%s)", buffer); ! 509: return NOTOK; ! 510: ! 511: case LX_COLN: ! 512: get_group: ; ! 513: if (glevel++ > 0) { ! 514: (void) sprintf (err, "nested groups not allowed (%s)", ! 515: pers); ! 516: return NOTOK; ! 517: } ! 518: grp = add (": ", pers); ! 519: pers = NULL; ! 520: { ! 521: char *pp = cp; ! 522: ! 523: for (;;) ! 524: switch (my_lex (buffer)) { ! 525: case LX_SEMI: ! 526: case LX_END: /* tsk, tsk */ ! 527: glevel--; ! 528: return OK; ! 529: ! 530: case LX_COMA: ! 531: continue; ! 532: ! 533: default: ! 534: cp = pp; ! 535: return parse_address (); ! 536: } ! 537: } ! 538: ! 539: case LX_DOT: /* sigh (1) */ ! 540: pers = add (".", pers); ! 541: goto more_phrase; ! 542: ! 543: default: ! 544: (void) sprintf (err, ! 545: "no mailbox in address, only a phrase (%s%s)", ! 546: pers, buffer); ! 547: return NOTOK; ! 548: } ! 549: ! 550: /* */ ! 551: ! 552: case LX_LBRK: ! 553: goto get_addr; ! 554: ! 555: case LX_COLN: ! 556: goto get_group; ! 557: ! 558: case LX_DOT: ! 559: mbox = add (buffer, pers); ! 560: pers = NULL; ! 561: if (route_addr (buffer) == NOTOK) ! 562: return NOTOK; ! 563: goto check_end; ! 564: ! 565: case LX_AT: ! 566: ingrp = glevel; ! 567: mbox = pers; ! 568: pers = NULL; ! 569: if (domain (buffer) == NOTOK) ! 570: return NOTOK; ! 571: check_end: ; ! 572: switch (last_lex) { ! 573: case LX_SEMI: ! 574: if (glevel-- <= 0) { ! 575: (void) strcpy (err, "extraneous semi-colon"); ! 576: return NOTOK; ! 577: } ! 578: case LX_COMA: ! 579: case LX_END: ! 580: return OK; ! 581: ! 582: default: ! 583: (void) sprintf (err, "junk after local@domain (%s)", ! 584: buffer); ! 585: return NOTOK; ! 586: } ! 587: ! 588: case LX_SEMI: /* no host */ ! 589: case LX_COMA: ! 590: case LX_END: ! 591: ingrp = glevel; ! 592: if (last_lex == LX_SEMI && glevel-- <= 0) { ! 593: (void) strcpy (err, "extraneous semi-colon"); ! 594: return NOTOK; ! 595: } ! 596: mbox = pers; ! 597: pers = NULL; ! 598: return OK; ! 599: ! 600: default: ! 601: (void) sprintf (err, "missing mailbox (%s)", buffer); ! 602: return NOTOK; ! 603: } ! 604: } ! 605: ! 606: /* */ ! 607: ! 608: static int phrase (buffer) ! 609: register char *buffer; ! 610: { ! 611: for (;;) ! 612: switch (my_lex (buffer)) { ! 613: case LX_ATOM: ! 614: case LX_QSTR: ! 615: pers = add (buffer, add (" ", pers)); ! 616: continue; ! 617: ! 618: default: ! 619: return OK; ! 620: } ! 621: } ! 622: ! 623: /* */ ! 624: ! 625: static int route_addr (buffer) ! 626: register char *buffer; ! 627: { ! 628: register char *pp = cp; ! 629: ! 630: if (my_lex (buffer) == LX_AT) { ! 631: if (route (buffer) == NOTOK) ! 632: return NOTOK; ! 633: } ! 634: else ! 635: cp = pp; ! 636: ! 637: if (local_part (buffer) == NOTOK) ! 638: return NOTOK; ! 639: ! 640: switch (last_lex) { ! 641: case LX_AT: ! 642: return domain (buffer); ! 643: ! 644: case LX_RBRK: /* no host */ ! 645: case LX_COMA: ! 646: case LX_END: ! 647: return OK; ! 648: ! 649: default: ! 650: (void) sprintf (err, "no at-sign after local-part (%s)", buffer); ! 651: return NOTOK; ! 652: } ! 653: } ! 654: ! 655: /* */ ! 656: ! 657: static int local_part (buffer) ! 658: register char *buffer; ! 659: { ! 660: ingrp = glevel; ! 661: ! 662: for (;;) { ! 663: switch (my_lex (buffer)) { ! 664: case LX_ATOM: ! 665: case LX_QSTR: ! 666: mbox = add (buffer, mbox); ! 667: break; ! 668: ! 669: default: ! 670: (void) sprintf (err, "no mailbox in local-part (%s)", buffer); ! 671: return NOTOK; ! 672: } ! 673: ! 674: switch (my_lex (buffer)) { ! 675: case LX_DOT: ! 676: mbox = add (buffer, mbox); ! 677: continue; ! 678: ! 679: default: ! 680: return OK; ! 681: } ! 682: } ! 683: } ! 684: ! 685: /* */ ! 686: ! 687: static int domain (buffer) ! 688: register char *buffer; ! 689: { ! 690: for (;;) { ! 691: switch (my_lex (buffer)) { ! 692: case LX_ATOM: ! 693: case LX_DLIT: ! 694: host = add (buffer, host); ! 695: break; ! 696: ! 697: default: ! 698: (void) sprintf (err, ! 699: "no sub-domain in domain-part of address (%s)", ! 700: buffer); ! 701: return NOTOK; ! 702: } ! 703: ! 704: switch (my_lex (buffer)) { ! 705: case LX_DOT: ! 706: host = add (buffer, host); ! 707: continue; ! 708: ! 709: case LX_AT: /* sigh (0) */ ! 710: mbox = add (host, add ("%", mbox)); ! 711: free (host); ! 712: host = NULL; ! 713: continue; ! 714: ! 715: default: ! 716: return OK; ! 717: } ! 718: } ! 719: } ! 720: ! 721: /* */ ! 722: ! 723: static int route (buffer) ! 724: register char *buffer; ! 725: { ! 726: path = getcpy ("@"); ! 727: ! 728: for (;;) { ! 729: switch (my_lex (buffer)) { ! 730: case LX_ATOM: ! 731: case LX_DLIT: ! 732: path = add (buffer, path); ! 733: break; ! 734: ! 735: default: ! 736: (void) sprintf (err, ! 737: "no sub-domain in domain-part of address (%s)", ! 738: buffer); ! 739: return NOTOK; ! 740: } ! 741: switch (my_lex (buffer)) { ! 742: case LX_COMA: ! 743: path = add (buffer, path); ! 744: for (;;) { ! 745: switch (my_lex (buffer)) { ! 746: case LX_COMA: ! 747: continue; ! 748: ! 749: case LX_AT: ! 750: path = add (buffer, path); ! 751: break; ! 752: ! 753: default: ! 754: (void) sprintf (err, ! 755: "no at-sign found for next domain in route (%s)", ! 756: buffer); ! 757: } ! 758: break; ! 759: } ! 760: continue; ! 761: ! 762: case LX_AT: /* XXX */ ! 763: case LX_DOT: ! 764: path = add (buffer, path); ! 765: continue; ! 766: ! 767: case LX_COLN: ! 768: path = add (buffer, path); ! 769: return OK; ! 770: ! 771: default: ! 772: (void) sprintf (err, ! 773: "no colon found to terminate route (%s)", buffer); ! 774: return NOTOK; ! 775: } ! 776: } ! 777: } ! 778: ! 779: /* */ ! 780: ! 781: static int my_lex (buffer) ! 782: register char *buffer; ! 783: { ! 784: int i; ! 785: register char c, ! 786: *bp; ! 787: ! 788: bp = buffer; ! 789: *bp = NULL; ! 790: if (!cp) ! 791: return (last_lex = LX_END); ! 792: ! 793: c = *cp++; ! 794: while (isspace (c)) ! 795: c = *cp++; ! 796: if (c == NULL) { ! 797: cp = NULL; ! 798: return (last_lex = LX_END); ! 799: } ! 800: ! 801: if (c == '(') ! 802: for (*bp++ = c, i = 0;;) ! 803: switch (c = *cp++) { ! 804: case NULL: ! 805: cp = NULL; ! 806: return (last_lex = LX_ERR); ! 807: case QUOTE: ! 808: *bp++ = c; ! 809: if ((c = *cp++) == NULL) { ! 810: cp = NULL; ! 811: return (last_lex = LX_ERR); ! 812: } ! 813: *bp++ = c; ! 814: continue; ! 815: case '(': ! 816: i++; ! 817: default: ! 818: *bp++ = c; ! 819: continue; ! 820: case ')': ! 821: *bp++ = c; ! 822: if (--i < 0) { ! 823: *bp = NULL; ! 824: note = note ? add (buffer, add (" ", note)) ! 825: : getcpy (buffer); ! 826: return my_lex (buffer); ! 827: } ! 828: } ! 829: ! 830: /* */ ! 831: ! 832: if (c == '"') ! 833: for (*bp++ = c;;) ! 834: switch (c = *cp++) { ! 835: case NULL: ! 836: cp = NULL; ! 837: return (last_lex = LX_ERR); ! 838: case QUOTE: ! 839: *bp++ = c; ! 840: if ((c = *cp++) == NULL) { ! 841: cp = NULL; ! 842: return (last_lex = LX_ERR); ! 843: } ! 844: default: ! 845: *bp++ = c; ! 846: continue; ! 847: case '"': ! 848: *bp++ = c; ! 849: *bp = NULL; ! 850: return (last_lex = LX_QSTR); ! 851: } ! 852: ! 853: if (c == '[') ! 854: for (*bp++ = c;;) ! 855: switch (c = *cp++) { ! 856: case NULL: ! 857: cp = NULL; ! 858: return (last_lex = LX_ERR); ! 859: case QUOTE: ! 860: *bp++ = c; ! 861: if ((c = *cp++) == NULL) { ! 862: cp = NULL; ! 863: return (last_lex = LX_ERR); ! 864: } ! 865: default: ! 866: *bp++ = c; ! 867: continue; ! 868: case ']': ! 869: *bp++ = c; ! 870: *bp = NULL; ! 871: return (last_lex = LX_DLIT); ! 872: } ! 873: ! 874: /* */ ! 875: ! 876: *bp++ = c; ! 877: *bp = NULL; ! 878: for (i = 0; special[i].lx_chr != NULL; i++) ! 879: if (c == special[i].lx_chr) ! 880: return (last_lex = special[i].lx_val); ! 881: ! 882: if (iscntrl (c)) ! 883: return (last_lex = LX_ERR); ! 884: ! 885: for (;;) { ! 886: if ((c = *cp++) == NULL) ! 887: break; ! 888: for (i = 0; special[i].lx_chr != NULL; i++) ! 889: if (c == special[i].lx_chr) ! 890: goto got_atom; ! 891: if (iscntrl (c) || isspace (c)) ! 892: break; ! 893: *bp++ = c; ! 894: } ! 895: got_atom: ; ! 896: if (c == NULL) ! 897: cp = NULL; ! 898: else ! 899: cp--; ! 900: *bp = NULL; ! 901: last_lex = !lequal (buffer, "at") || cp == NULL || index (cp, '<') != NULL ! 902: ? LX_ATOM : LX_AT; ! 903: return last_lex; ! 904: } ! 905: ! 906: /* */ ! 907: ! 908: char *legal_person (p) ! 909: register char *p; ! 910: { ! 911: int i; ! 912: register char *cp; ! 913: static char buffer[BUFSIZ]; ! 914: ! 915: if (*p == '"') ! 916: return p; ! 917: for (cp = p; *cp; cp++) ! 918: for (i = 0; special[i].lx_chr; i++) ! 919: if (*cp == special[i].lx_chr) { ! 920: (void) sprintf (buffer, "\"%s\"", p); ! 921: return buffer; ! 922: } ! 923: ! 924: return p; ! 925: } ! 926: ! 927: /* */ ! 928: ! 929: int mfgets (in, bp) ! 930: register FILE *in; ! 931: register char **bp; ! 932: { ! 933: int i; ! 934: register char *cp, ! 935: *dp, ! 936: *ep; ! 937: static int len = 0; ! 938: static char *pp = NULL; ! 939: ! 940: if (pp == NULL) ! 941: if ((pp = malloc ((unsigned) (len = BUFSIZ))) == NULL) ! 942: return NOTOK; ! 943: ! 944: for (ep = (cp = pp) + len - 2;;) { ! 945: switch (i = getc (in)) { ! 946: case EOF: ! 947: eol: ; ! 948: if (cp != pp) { ! 949: *cp = NULL; ! 950: *bp = pp; ! 951: return OK; ! 952: } ! 953: eoh: ; ! 954: *bp = NULL; ! 955: free (pp); ! 956: pp = NULL; ! 957: return DONE; ! 958: ! 959: case NULL: ! 960: continue; ! 961: ! 962: case '\n': ! 963: if (cp == pp) /* end of headers, gobble it */ ! 964: goto eoh; ! 965: switch (i = getc (in)) { ! 966: default: /* end of line */ ! 967: case '\n': /* end of headers, save for next call */ ! 968: (void) ungetc (i, in); ! 969: goto eol; ! 970: ! 971: case ' ': /* continue headers */ ! 972: case '\t': ! 973: *cp++ = '\n'; ! 974: break; ! 975: } /* fall into default case */ ! 976: ! 977: default: ! 978: *cp++ = i; ! 979: break; ! 980: } ! 981: if (cp >= ep) ! 982: if ((dp = realloc (pp, (unsigned) (len += BUFSIZ))) == NULL) { ! 983: free (pp); ! 984: pp = NULL; ! 985: return NOTOK; ! 986: } ! 987: else ! 988: cp += dp - pp, ep = (pp = cp) + len - 2; ! 989: } ! 990: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.