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