![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parseaddr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / usr.lib / sendmail / src|
Return to parseaddr.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.lib / sendmail / src |
1.1 root 1: /*
2: * Copyright (c) 1983 Eric P. Allman
3: * Copyright (c) 1988 Regents of the University of California.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms are permitted
7: * provided that the above copyright notice and this paragraph are
8: * duplicated in all such forms and that any documentation,
9: * advertising materials, and other materials related to such
10: * distribution and use acknowledge that the software was developed
11: * by the University of California, Berkeley. The name of the
12: * University may not be used to endorse or promote products derived
13: * from this software without specific prior written permission.
14: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
15: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
16: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17: */
18:
19: #ifndef lint
20: static char sccsid[] = "@(#)parseaddr.c 5.9 (Berkeley) 6/30/88";
21: #endif /* not lint */
22:
23: # include "sendmail.h"
24:
25: /*
26: ** PARSEADDR -- Parse an address
27: **
28: ** Parses an address and breaks it up into three parts: a
29: ** net to transmit the message on, the host to transmit it
30: ** to, and a user on that host. These are loaded into an
31: ** ADDRESS header with the values squirreled away if necessary.
32: ** The "user" part may not be a real user; the process may
33: ** just reoccur on that machine. For example, on a machine
34: ** with an arpanet connection, the address
35: ** csvax.bill@berkeley
36: ** will break up to a "user" of 'csvax.bill' and a host
37: ** of 'berkeley' -- to be transmitted over the arpanet.
38: **
39: ** Parameters:
40: ** addr -- the address to parse.
41: ** a -- a pointer to the address descriptor buffer.
42: ** If NULL, a header will be created.
43: ** copyf -- determines what shall be copied:
44: ** -1 -- don't copy anything. The printname
45: ** (q_paddr) is just addr, and the
46: ** user & host are allocated internally
47: ** to parse.
48: ** 0 -- copy out the parsed user & host, but
49: ** don't copy the printname.
50: ** +1 -- copy everything.
51: ** delim -- the character to terminate the address, passed
52: ** to prescan.
53: **
54: ** Returns:
55: ** A pointer to the address descriptor header (`a' if
56: ** `a' is non-NULL).
57: ** NULL on error.
58: **
59: ** Side Effects:
60: ** none
61: */
62:
63: /* following delimiters are inherent to the internal algorithms */
64: # define DELIMCHARS "\001()<>,;\\\"\r\n" /* word delimiters */
65:
66: ADDRESS *
67: parseaddr(addr, a, copyf, delim)
68: char *addr;
69: register ADDRESS *a;
70: int copyf;
71: char delim;
72: {
73: register char **pvp;
74: register struct mailer *m;
75: char pvpbuf[PSBUFSIZE];
76: extern char **prescan();
77: extern ADDRESS *buildaddr();
78:
79: /*
80: ** Initialize and prescan address.
81: */
82:
83: CurEnv->e_to = addr;
84: # ifdef DEBUG
85: if (tTd(20, 1))
86: printf("\n--parseaddr(%s)\n", addr);
87: # endif DEBUG
88:
89: pvp = prescan(addr, delim, pvpbuf);
90: if (pvp == NULL)
91: return (NULL);
92:
93: /*
94: ** Apply rewriting rules.
95: ** Ruleset 0 does basic parsing. It must resolve.
96: */
97:
98: rewrite(pvp, 3);
99: rewrite(pvp, 0);
100:
101: /*
102: ** See if we resolved to a real mailer.
103: */
104:
105: if (pvp[0][0] != CANONNET)
106: {
107: setstat(EX_USAGE);
108: usrerr("cannot resolve name");
109: return (NULL);
110: }
111:
112: /*
113: ** Build canonical address from pvp.
114: */
115:
116: a = buildaddr(pvp, a);
117: if (a == NULL)
118: return (NULL);
119: m = a->q_mailer;
120:
121: /*
122: ** Make local copies of the host & user and then
123: ** transport them out.
124: */
125:
126: if (copyf > 0)
127: {
128: extern char *DelimChar;
129: char savec = *DelimChar;
130:
131: *DelimChar = '\0';
132: a->q_paddr = newstr(addr);
133: *DelimChar = savec;
134: }
135: else
136: a->q_paddr = addr;
137:
138: if (a->q_user == NULL)
139: a->q_user = "";
140: if (a->q_host == NULL)
141: a->q_host = "";
142:
143: if (copyf >= 0)
144: {
145: a->q_host = newstr(a->q_host);
146: if (a->q_user != a->q_paddr)
147: a->q_user = newstr(a->q_user);
148: }
149:
150: /*
151: ** Convert host name to lower case if requested.
152: ** User name will be done later.
153: */
154:
155: if (!bitnset(M_HST_UPPER, m->m_flags))
156: makelower(a->q_host);
157:
158: /*
159: ** Compute return value.
160: */
161:
162: # ifdef DEBUG
163: if (tTd(20, 1))
164: {
165: printf("parseaddr-->");
166: printaddr(a, FALSE);
167: }
168: # endif DEBUG
169:
170: return (a);
171: }
172: /*
173: ** LOWERADDR -- map UPPER->lower case on addresses as requested.
174: **
175: ** Parameters:
176: ** a -- address to be mapped.
177: **
178: ** Returns:
179: ** none.
180: **
181: ** Side Effects:
182: ** none.
183: */
184:
185: loweraddr(a)
186: register ADDRESS *a;
187: {
188: register MAILER *m = a->q_mailer;
189:
190: if (!bitnset(M_USR_UPPER, m->m_flags))
191: makelower(a->q_user);
192: }
193: /*
194: ** PRESCAN -- Prescan name and make it canonical
195: **
196: ** Scans a name and turns it into a set of tokens. This process
197: ** deletes blanks and comments (in parentheses).
198: **
199: ** This routine knows about quoted strings and angle brackets.
200: **
201: ** There are certain subtleties to this routine. The one that
202: ** comes to mind now is that backslashes on the ends of names
203: ** are silently stripped off; this is intentional. The problem
204: ** is that some versions of sndmsg (like at LBL) set the kill
205: ** character to something other than @ when reading addresses;
206: ** so people type "csvax.eric\@berkeley" -- which screws up the
207: ** berknet mailer.
208: **
209: ** Parameters:
210: ** addr -- the name to chomp.
211: ** delim -- the delimiter for the address, normally
212: ** '\0' or ','; \0 is accepted in any case.
213: ** If '\t' then we are reading the .cf file.
214: ** pvpbuf -- place to put the saved text -- note that
215: ** the pointers are static.
216: **
217: ** Returns:
218: ** A pointer to a vector of tokens.
219: ** NULL on error.
220: **
221: ** Side Effects:
222: ** sets DelimChar to point to the character matching 'delim'.
223: */
224:
225: /* states and character types */
226: # define OPR 0 /* operator */
227: # define ATM 1 /* atom */
228: # define QST 2 /* in quoted string */
229: # define SPC 3 /* chewing up spaces */
230: # define ONE 4 /* pick up one character */
231:
232: # define NSTATES 5 /* number of states */
233: # define TYPE 017 /* mask to select state type */
234:
235: /* meta bits for table */
236: # define M 020 /* meta character; don't pass through */
237: # define B 040 /* cause a break */
238: # define MB M|B /* meta-break */
239:
240: static short StateTab[NSTATES][NSTATES] =
241: {
242: /* oldst chtype> OPR ATM QST SPC ONE */
243: /*OPR*/ OPR|B, ATM|B, QST|B, SPC|MB, ONE|B,
244: /*ATM*/ OPR|B, ATM, QST|B, SPC|MB, ONE|B,
245: /*QST*/ QST, QST, OPR, QST, QST,
246: /*SPC*/ OPR, ATM, QST, SPC|M, ONE,
247: /*ONE*/ OPR, OPR, OPR, OPR, OPR,
248: };
249:
250: # define NOCHAR -1 /* signal nothing in lookahead token */
251:
252: char *DelimChar; /* set to point to the delimiter */
253:
254: char **
255: prescan(addr, delim, pvpbuf)
256: char *addr;
257: char delim;
258: char pvpbuf[];
259: {
260: register char *p;
261: register char *q;
262: register int c;
263: char **avp;
264: bool bslashmode;
265: int cmntcnt;
266: int anglecnt;
267: char *tok;
268: int state;
269: int newstate;
270: static char *av[MAXATOM+1];
271: extern int errno;
272:
273: /* make sure error messages don't have garbage on them */
274: errno = 0;
275:
276: q = pvpbuf;
277: bslashmode = FALSE;
278: cmntcnt = 0;
279: anglecnt = 0;
280: avp = av;
281: state = OPR;
282: c = NOCHAR;
283: p = addr;
284: # ifdef DEBUG
285: if (tTd(22, 45))
286: {
287: printf("prescan: ");
288: xputs(p);
289: (void) putchar('\n');
290: }
291: # endif DEBUG
292:
293: do
294: {
295: /* read a token */
296: tok = q;
297: for (;;)
298: {
299: /* store away any old lookahead character */
300: if (c != NOCHAR)
301: {
302: /* see if there is room */
303: if (q >= &pvpbuf[PSBUFSIZE - 5])
304: {
305: usrerr("Address too long");
306: DelimChar = p;
307: return (NULL);
308: }
309:
310: /* squirrel it away */
311: *q++ = c;
312: }
313:
314: /* read a new input character */
315: c = *p++;
316: if (c == '\0')
317: break;
318: c &= ~0200;
319:
320: # ifdef DEBUG
321: if (tTd(22, 101))
322: printf("c=%c, s=%d; ", c, state);
323: # endif DEBUG
324:
325: /* chew up special characters */
326: *q = '\0';
327: if (bslashmode)
328: {
329: /* kludge \! for naive users */
330: if (c != '!')
331: c |= 0200;
332: bslashmode = FALSE;
333: }
334: else if (c == '\\')
335: {
336: bslashmode = TRUE;
337: c = NOCHAR;
338: }
339: else if (state == QST)
340: {
341: /* do nothing, just avoid next clauses */
342: }
343: else if (c == '(')
344: {
345: cmntcnt++;
346: c = NOCHAR;
347: }
348: else if (c == ')')
349: {
350: if (cmntcnt <= 0)
351: {
352: usrerr("Unbalanced ')'");
353: DelimChar = p;
354: return (NULL);
355: }
356: else
357: cmntcnt--;
358: }
359: else if (cmntcnt > 0)
360: c = NOCHAR;
361: else if (c == '<')
362: anglecnt++;
363: else if (c == '>')
364: {
365: if (anglecnt <= 0)
366: {
367: usrerr("Unbalanced '>'");
368: DelimChar = p;
369: return (NULL);
370: }
371: anglecnt--;
372: }
373: else if (delim == ' ' && isspace(c))
374: c = ' ';
375:
376: if (c == NOCHAR)
377: continue;
378:
379: /* see if this is end of input */
380: if (c == delim && anglecnt <= 0 && state != QST)
381: break;
382:
383: newstate = StateTab[state][toktype(c)];
384: # ifdef DEBUG
385: if (tTd(22, 101))
386: printf("ns=%02o\n", newstate);
387: # endif DEBUG
388: state = newstate & TYPE;
389: if (bitset(M, newstate))
390: c = NOCHAR;
391: if (bitset(B, newstate))
392: break;
393: }
394:
395: /* new token */
396: if (tok != q)
397: {
398: *q++ = '\0';
399: # ifdef DEBUG
400: if (tTd(22, 36))
401: {
402: printf("tok=");
403: xputs(tok);
404: (void) putchar('\n');
405: }
406: # endif DEBUG
407: if (avp >= &av[MAXATOM])
408: {
409: syserr("prescan: too many tokens");
410: DelimChar = p;
411: return (NULL);
412: }
413: *avp++ = tok;
414: }
415: } while (c != '\0' && (c != delim || anglecnt > 0));
416: *avp = NULL;
417: DelimChar = --p;
418: if (cmntcnt > 0)
419: usrerr("Unbalanced '('");
420: else if (anglecnt > 0)
421: usrerr("Unbalanced '<'");
422: else if (state == QST)
423: usrerr("Unbalanced '\"'");
424: else if (av[0] != NULL)
425: return (av);
426: return (NULL);
427: }
428: /*
429: ** TOKTYPE -- return token type
430: **
431: ** Parameters:
432: ** c -- the character in question.
433: **
434: ** Returns:
435: ** Its type.
436: **
437: ** Side Effects:
438: ** none.
439: */
440:
441: toktype(c)
442: register char c;
443: {
444: static char buf[50];
445: static bool firstime = TRUE;
446:
447: if (firstime)
448: {
449: firstime = FALSE;
450: expand("\001o", buf, &buf[sizeof buf - 1], CurEnv);
451: (void) strcat(buf, DELIMCHARS);
452: }
453: if (c == MATCHCLASS || c == MATCHREPL || c == MATCHNCLASS)
454: return (ONE);
455: if (c == '"')
456: return (QST);
457: if (!isascii(c))
458: return (ATM);
459: if (isspace(c) || c == ')')
460: return (SPC);
461: if (iscntrl(c) || index(buf, c) != NULL)
462: return (OPR);
463: return (ATM);
464: }
465: /*
466: ** REWRITE -- apply rewrite rules to token vector.
467: **
468: ** This routine is an ordered production system. Each rewrite
469: ** rule has a LHS (called the pattern) and a RHS (called the
470: ** rewrite); 'rwr' points the the current rewrite rule.
471: **
472: ** For each rewrite rule, 'avp' points the address vector we
473: ** are trying to match against, and 'pvp' points to the pattern.
474: ** If pvp points to a special match value (MATCHZANY, MATCHANY,
475: ** MATCHONE, MATCHCLASS, MATCHNCLASS) then the address in avp
476: ** matched is saved away in the match vector (pointed to by 'mvp').
477: **
478: ** When a match between avp & pvp does not match, we try to
479: ** back out. If we back up over MATCHONE, MATCHCLASS, or MATCHNCLASS
480: ** we must also back out the match in mvp. If we reach a
481: ** MATCHANY or MATCHZANY we just extend the match and start
482: ** over again.
483: **
484: ** When we finally match, we rewrite the address vector
485: ** and try over again.
486: **
487: ** Parameters:
488: ** pvp -- pointer to token vector.
489: **
490: ** Returns:
491: ** none.
492: **
493: ** Side Effects:
494: ** pvp is modified.
495: */
496:
497: struct match
498: {
499: char **first; /* first token matched */
500: char **last; /* last token matched */
501: };
502:
503: # define MAXMATCH 9 /* max params per rewrite */
504:
505:
506: rewrite(pvp, ruleset)
507: char **pvp;
508: int ruleset;
509: {
510: register char *ap; /* address pointer */
511: register char *rp; /* rewrite pointer */
512: register char **avp; /* address vector pointer */
513: register char **rvp; /* rewrite vector pointer */
514: register struct match *mlp; /* cur ptr into mlist */
515: register struct rewrite *rwr; /* pointer to current rewrite rule */
516: struct match mlist[MAXMATCH]; /* stores match on LHS */
517: char *npvp[MAXATOM+1]; /* temporary space for rebuild */
518:
519: if (OpMode == MD_TEST || tTd(21, 2))
520: {
521: printf("rewrite: ruleset %2d input:", ruleset);
522: printav(pvp);
523: }
524: if (pvp == NULL)
525: return;
526:
527: /*
528: ** Run through the list of rewrite rules, applying
529: ** any that match.
530: */
531:
532: for (rwr = RewriteRules[ruleset]; rwr != NULL; )
533: {
534: # ifdef DEBUG
535: if (tTd(21, 12))
536: {
537: printf("-----trying rule:");
538: printav(rwr->r_lhs);
539: }
540: # endif DEBUG
541:
542: /* try to match on this rule */
543: mlp = mlist;
544: rvp = rwr->r_lhs;
545: avp = pvp;
546: while ((ap = *avp) != NULL || *rvp != NULL)
547: {
548: rp = *rvp;
549: # ifdef DEBUG
550: if (tTd(21, 35))
551: {
552: printf("ap=");
553: xputs(ap);
554: printf(", rp=");
555: xputs(rp);
556: printf("\n");
557: }
558: # endif DEBUG
559: if (rp == NULL)
560: {
561: /* end-of-pattern before end-of-address */
562: goto backup;
563: }
564: if (ap == NULL && *rp != MATCHZANY)
565: {
566: /* end-of-input */
567: break;
568: }
569:
570: switch (*rp)
571: {
572: register STAB *s;
573:
574: case MATCHCLASS:
575: case MATCHNCLASS:
576: /* match any token in (not in) a class */
577: s = stab(ap, ST_CLASS, ST_FIND);
578: if (s == NULL || !bitnset(rp[1], s->s_class))
579: {
580: if (*rp == MATCHCLASS)
581: goto backup;
582: }
583: else if (*rp == MATCHNCLASS)
584: goto backup;
585:
586: /* explicit fall-through */
587:
588: case MATCHONE:
589: case MATCHANY:
590: /* match exactly one token */
591: mlp->first = avp;
592: mlp->last = avp++;
593: mlp++;
594: break;
595:
596: case MATCHZANY:
597: /* match zero or more tokens */
598: mlp->first = avp;
599: mlp->last = avp - 1;
600: mlp++;
601: break;
602:
603: default:
604: /* must have exact match */
605: if (strcasecmp(rp, ap))
606: goto backup;
607: avp++;
608: break;
609: }
610:
611: /* successful match on this token */
612: rvp++;
613: continue;
614:
615: backup:
616: /* match failed -- back up */
617: while (--rvp >= rwr->r_lhs)
618: {
619: rp = *rvp;
620: if (*rp == MATCHANY || *rp == MATCHZANY)
621: {
622: /* extend binding and continue */
623: avp = ++mlp[-1].last;
624: avp++;
625: rvp++;
626: break;
627: }
628: avp--;
629: if (*rp == MATCHONE || *rp == MATCHCLASS ||
630: *rp == MATCHNCLASS)
631: {
632: /* back out binding */
633: mlp--;
634: }
635: }
636:
637: if (rvp < rwr->r_lhs)
638: {
639: /* total failure to match */
640: break;
641: }
642: }
643:
644: /*
645: ** See if we successfully matched
646: */
647:
648: if (rvp < rwr->r_lhs || *rvp != NULL)
649: {
650: # ifdef DEBUG
651: if (tTd(21, 10))
652: printf("----- rule fails\n");
653: # endif DEBUG
654: rwr = rwr->r_next;
655: continue;
656: }
657:
658: rvp = rwr->r_rhs;
659: # ifdef DEBUG
660: if (tTd(21, 12))
661: {
662: printf("-----rule matches:");
663: printav(rvp);
664: }
665: # endif DEBUG
666:
667: rp = *rvp;
668: if (*rp == CANONUSER)
669: {
670: rvp++;
671: rwr = rwr->r_next;
672: }
673: else if (*rp == CANONHOST)
674: {
675: rvp++;
676: rwr = NULL;
677: }
678: else if (*rp == CANONNET)
679: rwr = NULL;
680:
681: /* substitute */
682: for (avp = npvp; *rvp != NULL; rvp++)
683: {
684: register struct match *m;
685: register char **pp;
686:
687: rp = *rvp;
688: if (*rp == MATCHREPL)
689: {
690: /* substitute from LHS */
691: m = &mlist[rp[1] - '1'];
692: if (m >= mlp)
693: {
694: syserr("rewrite: ruleset %d: replacement out of bounds", ruleset);
695: return;
696: }
697: # ifdef DEBUG
698: if (tTd(21, 15))
699: {
700: printf("$%c:", rp[1]);
701: pp = m->first;
702: while (pp <= m->last)
703: {
704: printf(" %x=\"", *pp);
705: (void) fflush(stdout);
706: printf("%s\"", *pp++);
707: }
708: printf("\n");
709: }
710: # endif DEBUG
711: pp = m->first;
712: while (pp <= m->last)
713: {
714: if (avp >= &npvp[MAXATOM])
715: {
716: syserr("rewrite: expansion too long");
717: return;
718: }
719: *avp++ = *pp++;
720: }
721: }
722: else
723: {
724: /* vanilla replacement */
725: if (avp >= &npvp[MAXATOM])
726: {
727: toolong:
728: syserr("rewrite: expansion too long");
729: return;
730: }
731: *avp++ = rp;
732: }
733: }
734: *avp++ = NULL;
735:
736: /*
737: ** Check for any hostname lookups.
738: */
739:
740: for (rvp = npvp; *rvp != NULL; rvp++)
741: {
742: char **hbrvp;
743: char **xpvp;
744: int trsize;
745: char *olddelimchar;
746: char buf[MAXNAME + 1];
747: char *pvpb1[MAXATOM + 1];
748: char pvpbuf[PSBUFSIZE];
749: extern char *DelimChar;
750:
751: if (**rvp != HOSTBEGIN)
752: continue;
753:
754: /*
755: ** Got a hostname lookup.
756: **
757: ** This could be optimized fairly easily.
758: */
759:
760: hbrvp = rvp;
761:
762: /* extract the match part */
763: while (*++rvp != NULL && **rvp != HOSTEND)
764: continue;
765: if (*rvp != NULL)
766: *rvp++ = NULL;
767:
768: /* save the remainder of the input string */
769: trsize = (int) (avp - rvp + 1) * sizeof *rvp;
770: bcopy((char *) rvp, (char *) pvpb1, trsize);
771:
772: /* look it up */
773: cataddr(++hbrvp, buf, sizeof buf);
774: maphostname(buf, sizeof buf);
775:
776: /* scan the new host name */
777: olddelimchar = DelimChar;
778: xpvp = prescan(buf, '\0', pvpbuf);
779: DelimChar = olddelimchar;
780: if (xpvp == NULL)
781: {
782: syserr("rewrite: cannot prescan canonical hostname: %s", buf);
783: return;
784: }
785:
786: /* append it to the token list */
787: for (avp = --hbrvp; *xpvp != NULL; xpvp++)
788: {
789: *avp++ = newstr(*xpvp);
790: if (avp >= &npvp[MAXATOM])
791: goto toolong;
792: }
793:
794: /* restore the old trailing information */
795: for (xpvp = pvpb1; (*avp++ = *xpvp++) != NULL; )
796: if (avp >= &npvp[MAXATOM])
797: goto toolong;
798:
799: break;
800: }
801:
802: /*
803: ** Check for subroutine calls.
804: */
805:
806: if (*npvp != NULL && **npvp == CALLSUBR)
807: {
808: bcopy((char *) &npvp[2], (char *) pvp,
809: (int) (avp - npvp - 2) * sizeof *avp);
810: # ifdef DEBUG
811: if (tTd(21, 3))
812: printf("-----callsubr %s\n", npvp[1]);
813: # endif DEBUG
814: rewrite(pvp, atoi(npvp[1]));
815: }
816: else
817: {
818: bcopy((char *) npvp, (char *) pvp,
819: (int) (avp - npvp) * sizeof *avp);
820: }
821: # ifdef DEBUG
822: if (tTd(21, 4))
823: {
824: printf("rewritten as:");
825: printav(pvp);
826: }
827: # endif DEBUG
828: }
829:
830: if (OpMode == MD_TEST || tTd(21, 2))
831: {
832: printf("rewrite: ruleset %2d returns:", ruleset);
833: printav(pvp);
834: }
835: }
836: /*
837: ** BUILDADDR -- build address from token vector.
838: **
839: ** Parameters:
840: ** tv -- token vector.
841: ** a -- pointer to address descriptor to fill.
842: ** If NULL, one will be allocated.
843: **
844: ** Returns:
845: ** NULL if there was an error.
846: ** 'a' otherwise.
847: **
848: ** Side Effects:
849: ** fills in 'a'
850: */
851:
852: ADDRESS *
853: buildaddr(tv, a)
854: register char **tv;
855: register ADDRESS *a;
856: {
857: static char buf[MAXNAME];
858: struct mailer **mp;
859: register struct mailer *m;
860:
861: if (a == NULL)
862: a = (ADDRESS *) xalloc(sizeof *a);
863: bzero((char *) a, sizeof *a);
864:
865: /* figure out what net/mailer to use */
866: if (**tv != CANONNET)
867: {
868: syserr("buildaddr: no net");
869: return (NULL);
870: }
871: tv++;
872: if (!strcasecmp(*tv, "error"))
873: {
874: if (**++tv == CANONHOST)
875: {
876: setstat(atoi(*++tv));
877: tv++;
878: }
879: if (**tv != CANONUSER)
880: syserr("buildaddr: error: no user");
881: buf[0] = '\0';
882: while (*++tv != NULL)
883: {
884: if (buf[0] != '\0')
885: (void) strcat(buf, " ");
886: (void) strcat(buf, *tv);
887: }
888: usrerr(buf);
889: return (NULL);
890: }
891: for (mp = Mailer; (m = *mp++) != NULL; )
892: {
893: if (!strcasecmp(m->m_name, *tv))
894: break;
895: }
896: if (m == NULL)
897: {
898: syserr("buildaddr: unknown mailer %s", *tv);
899: return (NULL);
900: }
901: a->q_mailer = m;
902:
903: /* figure out what host (if any) */
904: tv++;
905: if (!bitnset(M_LOCAL, m->m_flags))
906: {
907: if (**tv++ != CANONHOST)
908: {
909: syserr("buildaddr: no host");
910: return (NULL);
911: }
912: buf[0] = '\0';
913: while (*tv != NULL && **tv != CANONUSER)
914: (void) strcat(buf, *tv++);
915: a->q_host = newstr(buf);
916: }
917: else
918: a->q_host = NULL;
919:
920: /* figure out the user */
921: if (**tv != CANONUSER)
922: {
923: syserr("buildaddr: no user");
924: return (NULL);
925: }
926:
927: /* rewrite according recipient mailer rewriting rules */
928: rewrite(++tv, 2);
929: if (m->m_r_rwset > 0)
930: rewrite(tv, m->m_r_rwset);
931: rewrite(tv, 4);
932:
933: /* save the result for the command line/RCPT argument */
934: cataddr(tv, buf, sizeof buf);
935: a->q_user = buf;
936:
937: return (a);
938: }
939: /*
940: ** CATADDR -- concatenate pieces of addresses (putting in <LWSP> subs)
941: **
942: ** Parameters:
943: ** pvp -- parameter vector to rebuild.
944: ** buf -- buffer to build the string into.
945: ** sz -- size of buf.
946: **
947: ** Returns:
948: ** none.
949: **
950: ** Side Effects:
951: ** Destroys buf.
952: */
953:
954: cataddr(pvp, buf, sz)
955: char **pvp;
956: char *buf;
957: register int sz;
958: {
959: bool oatomtok = FALSE;
960: bool natomtok = FALSE;
961: register int i;
962: register char *p;
963:
964: if (pvp == NULL)
965: {
966: (void) strcpy(buf, "");
967: return;
968: }
969: p = buf;
970: sz -= 2;
971: while (*pvp != NULL && (i = strlen(*pvp)) < sz)
972: {
973: natomtok = (toktype(**pvp) == ATM);
974: if (oatomtok && natomtok)
975: *p++ = SpaceSub;
976: (void) strcpy(p, *pvp);
977: oatomtok = natomtok;
978: p += i;
979: sz -= i + 1;
980: pvp++;
981: }
982: *p = '\0';
983: }
984: /*
985: ** SAMEADDR -- Determine if two addresses are the same
986: **
987: ** This is not just a straight comparison -- if the mailer doesn't
988: ** care about the host we just ignore it, etc.
989: **
990: ** Parameters:
991: ** a, b -- pointers to the internal forms to compare.
992: **
993: ** Returns:
994: ** TRUE -- they represent the same mailbox.
995: ** FALSE -- they don't.
996: **
997: ** Side Effects:
998: ** none.
999: */
1000:
1001: bool
1002: sameaddr(a, b)
1003: register ADDRESS *a;
1004: register ADDRESS *b;
1005: {
1006: /* if they don't have the same mailer, forget it */
1007: if (a->q_mailer != b->q_mailer)
1008: return (FALSE);
1009:
1010: /* if the user isn't the same, we can drop out */
1011: if (strcmp(a->q_user, b->q_user) != 0)
1012: return (FALSE);
1013:
1014: /* if the mailer ignores hosts, we have succeeded! */
1015: if (bitnset(M_LOCAL, a->q_mailer->m_flags))
1016: return (TRUE);
1017:
1018: /* otherwise compare hosts (but be careful for NULL ptrs) */
1019: if (a->q_host == NULL || b->q_host == NULL)
1020: return (FALSE);
1021: if (strcmp(a->q_host, b->q_host) != 0)
1022: return (FALSE);
1023:
1024: return (TRUE);
1025: }
1026: /*
1027: ** PRINTADDR -- print address (for debugging)
1028: **
1029: ** Parameters:
1030: ** a -- the address to print
1031: ** follow -- follow the q_next chain.
1032: **
1033: ** Returns:
1034: ** none.
1035: **
1036: ** Side Effects:
1037: ** none.
1038: */
1039:
1040: # ifdef DEBUG
1041:
1042: printaddr(a, follow)
1043: register ADDRESS *a;
1044: bool follow;
1045: {
1046: bool first = TRUE;
1047:
1048: while (a != NULL)
1049: {
1050: first = FALSE;
1051: printf("%x=", a);
1052: (void) fflush(stdout);
1053: printf("%s: mailer %d (%s), host `%s', user `%s'\n", a->q_paddr,
1054: a->q_mailer->m_mno, a->q_mailer->m_name, a->q_host,
1055: a->q_user);
1056: printf("\tnext=%x, flags=%o, alias %x\n", a->q_next, a->q_flags,
1057: a->q_alias);
1058: printf("\thome=\"%s\", fullname=\"%s\"\n", a->q_home,
1059: a->q_fullname);
1060:
1061: if (!follow)
1062: return;
1063: a = a->q_next;
1064: }
1065: if (first)
1066: printf("[NULL]\n");
1067: }
1068:
1069: # endif DEBUG
1070: /*
1071: ** REMOTENAME -- return the name relative to the current mailer
1072: **
1073: ** Parameters:
1074: ** name -- the name to translate.
1075: ** m -- the mailer that we want to do rewriting relative
1076: ** to.
1077: ** senderaddress -- if set, uses the sender rewriting rules
1078: ** rather than the recipient rewriting rules.
1079: ** canonical -- if set, strip out any comment information,
1080: ** etc.
1081: **
1082: ** Returns:
1083: ** the text string representing this address relative to
1084: ** the receiving mailer.
1085: **
1086: ** Side Effects:
1087: ** none.
1088: **
1089: ** Warnings:
1090: ** The text string returned is tucked away locally;
1091: ** copy it if you intend to save it.
1092: */
1093:
1094: char *
1095: remotename(name, m, senderaddress, canonical)
1096: char *name;
1097: struct mailer *m;
1098: bool senderaddress;
1099: bool canonical;
1100: {
1101: register char **pvp;
1102: char *fancy;
1103: extern char *macvalue();
1104: char *oldg = macvalue('g', CurEnv);
1105: static char buf[MAXNAME];
1106: char lbuf[MAXNAME];
1107: char pvpbuf[PSBUFSIZE];
1108: extern char **prescan();
1109: extern char *crackaddr();
1110:
1111: # ifdef DEBUG
1112: if (tTd(12, 1))
1113: printf("remotename(%s)\n", name);
1114: # endif DEBUG
1115:
1116: /* don't do anything if we are tagging it as special */
1117: if ((senderaddress ? m->m_s_rwset : m->m_r_rwset) < 0)
1118: return (name);
1119:
1120: /*
1121: ** Do a heuristic crack of this name to extract any comment info.
1122: ** This will leave the name as a comment and a $g macro.
1123: */
1124:
1125: if (canonical)
1126: fancy = "\001g";
1127: else
1128: fancy = crackaddr(name);
1129:
1130: /*
1131: ** Turn the name into canonical form.
1132: ** Normally this will be RFC 822 style, i.e., "user@domain".
1133: ** If this only resolves to "user", and the "C" flag is
1134: ** specified in the sending mailer, then the sender's
1135: ** domain will be appended.
1136: */
1137:
1138: pvp = prescan(name, '\0', pvpbuf);
1139: if (pvp == NULL)
1140: return (name);
1141: rewrite(pvp, 3);
1142: if (CurEnv->e_fromdomain != NULL)
1143: {
1144: /* append from domain to this address */
1145: register char **pxp = pvp;
1146:
1147: /* see if there is an "@domain" in the current name */
1148: while (*pxp != NULL && strcmp(*pxp, "@") != 0)
1149: pxp++;
1150: if (*pxp == NULL)
1151: {
1152: /* no.... append the "@domain" from the sender */
1153: register char **qxq = CurEnv->e_fromdomain;
1154:
1155: while ((*pxp++ = *qxq++) != NULL)
1156: continue;
1157: rewrite(pvp, 3);
1158: }
1159: }
1160:
1161: /*
1162: ** Do more specific rewriting.
1163: ** Rewrite using ruleset 1 or 2 depending on whether this is
1164: ** a sender address or not.
1165: ** Then run it through any receiving-mailer-specific rulesets.
1166: */
1167:
1168: if (senderaddress)
1169: {
1170: rewrite(pvp, 1);
1171: if (m->m_s_rwset > 0)
1172: rewrite(pvp, m->m_s_rwset);
1173: }
1174: else
1175: {
1176: rewrite(pvp, 2);
1177: if (m->m_r_rwset > 0)
1178: rewrite(pvp, m->m_r_rwset);
1179: }
1180:
1181: /*
1182: ** Do any final sanitation the address may require.
1183: ** This will normally be used to turn internal forms
1184: ** (e.g., [email protected]) into external form. This
1185: ** may be used as a default to the above rules.
1186: */
1187:
1188: rewrite(pvp, 4);
1189:
1190: /*
1191: ** Now restore the comment information we had at the beginning.
1192: */
1193:
1194: cataddr(pvp, lbuf, sizeof lbuf);
1195: define('g', lbuf, CurEnv);
1196: expand(fancy, buf, &buf[sizeof buf - 1], CurEnv);
1197: define('g', oldg, CurEnv);
1198:
1199: # ifdef DEBUG
1200: if (tTd(12, 1))
1201: printf("remotename => `%s'\n", buf);
1202: # endif DEBUG
1203: return (buf);
1204: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.