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