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