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