?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import sendmail 8.13.4 into a new contrib directory as the first step
[dragonfly.git] / contrib / sendmail-8.13.4 / sendmail / parseaddr.c
blob4852ab5b35a7fb34e6b44b4fff2d963cef4bc0ce
1 /*
2 * Copyright (c) 1998-2005 Sendmail, Inc. and its suppliers.
3 * All rights reserved.
4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
5 * Copyright (c) 1988, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * By using this file, you agree to the terms and conditions set
9 * forth in the LICENSE file which can be found at the top level of
10 * the sendmail distribution.
11 *
12 */
13
14 #include <sendmail.h>
15
16 SM_RCSID("@(#)$Id: parseaddr.c,v 8.381 2005/02/04 22:01:45 ca Exp $")
17
18 static void allocaddr __P((ADDRESS *, int, char *, ENVELOPE *));
19 static int callsubr __P((char**, int, ENVELOPE *));
20 static char *map_lookup __P((STAB *, char *, char **, int *, ENVELOPE *));
21 static ADDRESS *buildaddr __P((char **, ADDRESS *, int, ENVELOPE *));
22 static bool hasctrlchar __P((register char *, bool, bool));
23
24 /* replacement for illegal characters in addresses */
25 #define BAD_CHAR_REPLACEMENT '?'
26
27 /*
28 ** PARSEADDR -- Parse an address
29 **
30 ** Parses an address and breaks it up into three parts: a
31 ** net to transmit the message on, the host to transmit it
32 ** to, and a user on that host. These are loaded into an
33 ** ADDRESS header with the values squirreled away if necessary.
34 ** The "user" part may not be a real user; the process may
35 ** just reoccur on that machine. For example, on a machine
36 ** with an arpanet connection, the address
37 ** csvax.bill@berkeley
38 ** will break up to a "user" of 'csvax.bill' and a host
39 ** of 'berkeley' -- to be transmitted over the arpanet.
40 **
41 ** Parameters:
42 ** addr -- the address to parse.
43 ** a -- a pointer to the address descriptor buffer.
44 ** If NULL, an address will be created.
45 ** flags -- describe detail for parsing. See RF_ definitions
46 ** in sendmail.h.
47 ** delim -- the character to terminate the address, passed
48 ** to prescan.
49 ** delimptr -- if non-NULL, set to the location of the
50 ** delim character that was found.
51 ** e -- the envelope that will contain this address.
52 ** isrcpt -- true if the address denotes a recipient; false
53 ** indicates a sender.
54 **
55 ** Returns:
56 ** A pointer to the address descriptor header (`a' if
57 ** `a' is non-NULL).
58 ** NULL on error.
59 **
60 ** Side Effects:
61 ** e->e_to = addr
62 */
63
64 /* following delimiters are inherent to the internal algorithms */
65 #define DELIMCHARS "()<>,;\r\n" /* default word delimiters */
66
67 ADDRESS *
68 parseaddr(addr, a, flags, delim, delimptr, e, isrcpt)
69 char *addr;
70 register ADDRESS *a;
71 int flags;
72 int delim;
73 char **delimptr;
74 register ENVELOPE *e;
75 bool isrcpt;
76 {
77 char **pvp;
78 auto char *delimptrbuf;
79 bool qup;
80 char pvpbuf[PSBUFSIZE];
81
82 /*
83 ** Initialize and prescan address.
84 */
85
86 e->e_to = addr;
87 if (tTd(20, 1))
88 sm_dprintf("\n--parseaddr(%s)\n", addr);
89
90 if (delimptr == NULL)
91 delimptr = &delimptrbuf;
92
93 pvp = prescan(addr, delim, pvpbuf, sizeof pvpbuf, delimptr, NULL, false);
94 if (pvp == NULL)
95 {
96 if (tTd(20, 1))
97 sm_dprintf("parseaddr-->NULL\n");
98 return NULL;
99 }
100
101 if (invalidaddr(addr, delim == '\0' ? NULL : *delimptr, isrcpt))
102 {
103 if (tTd(20, 1))
104 sm_dprintf("parseaddr-->bad address\n");
105 return NULL;
106 }
107
108 /*
109 ** Save addr if we are going to have to.
110 **
111 ** We have to do this early because there is a chance that
112 ** the map lookups in the rewriting rules could clobber
113 ** static memory somewhere.
114 */
115
116 if (bitset(RF_COPYPADDR, flags) && addr != NULL)
117 {
118 char savec = **delimptr;
119
120 if (savec != '\0')
121 **delimptr = '\0';
122 e->e_to = addr = sm_rpool_strdup_x(e->e_rpool, addr);
123 if (savec != '\0')
124 **delimptr = savec;
125 }
126
127 /*
128 ** Apply rewriting rules.
129 ** Ruleset 0 does basic parsing. It must resolve.
130 */
131
132 qup = false;
133 if (REWRITE(pvp, 3, e) == EX_TEMPFAIL)
134 qup = true;
135 if (REWRITE(pvp, 0, e) == EX_TEMPFAIL)
136 qup = true;
137
138 /*
139 ** Build canonical address from pvp.
140 */
141
142 a = buildaddr(pvp, a, flags, e);
143
144 if (hasctrlchar(a->q_user, isrcpt, true))
145 {
146 if (tTd(20, 1))
147 sm_dprintf("parseaddr-->bad q_user\n");
148
149 /*
150 ** Just mark the address as bad so DSNs work.
151 ** hasctrlchar() has to make sure that the address
152 ** has been sanitized, e.g., shortened.
153 */
154
155 a->q_state = QS_BADADDR;
156 }
157
158 /*
159 ** Make local copies of the host & user and then
160 ** transport them out.
161 */
162
163 allocaddr(a, flags, addr, e);
164 if (QS_IS_BADADDR(a->q_state))
165 {
166 /* weed out bad characters in the printable address too */
167 (void) hasctrlchar(a->q_paddr, isrcpt, false);
168 return a;
169 }
170
171 /*
172 ** Select a queue directory for recipient addresses.
173 ** This is done here and in split_across_queue_groups(),
174 ** but the latter applies to addresses after aliasing,
175 ** and only if splitting is done.
176 */
177
178 if ((a->q_qgrp == NOAQGRP || a->q_qgrp == ENVQGRP) &&
179 !bitset(RF_SENDERADDR|RF_HEADERADDR, flags) &&
180 OpMode != MD_INITALIAS)
181 {
182 int r;
183
184 /* call ruleset which should return a queue group name */
185 r = rscap(RS_QUEUEGROUP, a->q_user, NULL, e, &pvp, pvpbuf,
186 sizeof(pvpbuf));
187 if (r == EX_OK &&
188 pvp != NULL && pvp[0] != NULL &&
189 (pvp[0][0] & 0377) == CANONNET &&
190 pvp[1] != NULL && pvp[1][0] != '\0')
191 {
192 r = name2qid(pvp[1]);
193 if (r == NOQGRP && LogLevel > 10)
194 sm_syslog(LOG_INFO, NOQID,
195 "can't find queue group name %s, selection ignored",
196 pvp[1]);
197 if (tTd(20, 4) && r != NOQGRP)
198 sm_syslog(LOG_INFO, NOQID,
199 "queue group name %s -> %d",
200 pvp[1], r);
201 a->q_qgrp = r == NOQGRP ? ENVQGRP : r;
202 }
203 }
204
205 /*
206 ** If there was a parsing failure, mark it for queueing.
207 */
208
209 if (qup && OpMode != MD_INITALIAS)
210 {
211 char *msg = "Transient parse error -- message queued for future delivery";
212
213 if (e->e_sendmode == SM_DEFER)
214 msg = "Deferring message until queue run";
215 if (tTd(20, 1))
216 sm_dprintf("parseaddr: queuing message\n");
217 message(msg);
218 if (e->e_message == NULL && e->e_sendmode != SM_DEFER)
219 e->e_message = sm_rpool_strdup_x(e->e_rpool, msg);
220 a->q_state = QS_QUEUEUP;
221 a->q_status = "4.4.3";
222 }
223
224 /*
225 ** Compute return value.
226 */
227
228 if (tTd(20, 1))
229 {
230 sm_dprintf("parseaddr-->");
231 printaddr(sm_debug_file(), a, false);
232 }
233
234 return a;
235 }
236 /*
237 ** INVALIDADDR -- check for address containing characters used for macros
238 **
239 ** Parameters:
240 ** addr -- the address to check.
241 ** delimptr -- if non-NULL: end of address to check, i.e.,
242 ** a pointer in the address string.
243 ** isrcpt -- true iff the address is for a recipient.
244 **
245 ** Returns:
246 ** true -- if the address has characters that are reservered
247 ** for macros or is too long.
248 ** false -- otherwise.
249 */
250
251 bool
252 invalidaddr(addr, delimptr, isrcpt)
253 register char *addr;
254 char *delimptr;
255 bool isrcpt;
256 {
257 bool result = false;
258 char savedelim = '\0';
259 char *b = addr;
260 int len = 0;
261
262 if (delimptr != NULL)
263 {
264 /* delimptr points to the end of the address to test */
265 savedelim = *delimptr;
266 if (savedelim != '\0') /* if that isn't '\0' already: */
267 *delimptr = '\0'; /* set it */
268 }
269 for (; *addr != '\0'; addr++)
270 {
271 if ((*addr & 0340) == 0200)
272 {
273 setstat(EX_USAGE);
274 result = true;
275 *addr = BAD_CHAR_REPLACEMENT;
276 }
277 if (++len > MAXNAME - 1)
278 {
279 char saved = *addr;
280
281 *addr = '\0';
282 usrerr("553 5.1.0 Address \"%s\" too long (%d bytes max)",
283 b, MAXNAME - 1);
284 *addr = saved;
285 result = true;
286 goto delim;
287 }
288 }
289 if (result)
290 {
291 if (isrcpt)
292 usrerr("501 5.1.3 8-bit character in mailbox address \"%s\"",
293 b);
294 else
295 usrerr("501 5.1.7 8-bit character in mailbox address \"%s\"",
296 b);
297 }
298 delim:
299 if (delimptr != NULL && savedelim != '\0')
300 *delimptr = savedelim; /* restore old character at delimptr */
301 return result;
302 }
303 /*
304 ** HASCTRLCHAR -- check for address containing meta-characters
305 **
306 ** Checks that the address contains no meta-characters, and contains
307 ** no "non-printable" characters unless they are quoted or escaped.
308 ** Quoted or escaped characters are literals.
309 **
310 ** Parameters:
311 ** addr -- the address to check.
312 ** isrcpt -- true if the address is for a recipient; false
313 ** indicates a from.
314 ** complain -- true if an error should issued if the address
315 ** is invalid and should be "repaired".
316 **
317 ** Returns:
318 ** true -- if the address has any "wierd" characters or
319 ** non-printable characters or if a quote is unbalanced.
320 ** false -- otherwise.
321 */
322
323 static bool
324 hasctrlchar(addr, isrcpt, complain)
325 register char *addr;
326 bool isrcpt, complain;
327 {
328 bool quoted = false;
329 int len = 0;
330 char *result = NULL;
331 char *b = addr;
332
333 if (addr == NULL)
334 return false;
335 for (; *addr != '\0'; addr++)
336 {
337 if (++len > MAXNAME - 1)
338 {
339 if (complain)
340 {
341 (void) shorten_rfc822_string(b, MAXNAME - 1);
342 usrerr("553 5.1.0 Address \"%s\" too long (%d bytes max)",
343 b, MAXNAME - 1);
344 return true;
345 }
346 result = "too long";
347 }
348 if (!quoted && (*addr < 32 || *addr == 127))
349 {
350 result = "non-printable character";
351 *addr = BAD_CHAR_REPLACEMENT;
352 continue;
353 }
354 if (*addr == '"')
355 quoted = !quoted;
356 else if (*addr == '\\')
357 {
358 /* XXX Generic problem: no '\0' in strings. */
359 if (*++addr == '\0')
360 {
361 result = "trailing \\ character";
362 *--addr = BAD_CHAR_REPLACEMENT;
363 break;
364 }
365 }
366 if ((*addr & 0340) == 0200)
367 {
368 setstat(EX_USAGE);
369 result = "8-bit character";
370 *addr = BAD_CHAR_REPLACEMENT;
371 continue;
372 }
373 }
374 if (quoted)
375 result = "unbalanced quote"; /* unbalanced quote */
376 if (result != NULL && complain)
377 {
378 if (isrcpt)
379 usrerr("501 5.1.3 Syntax error in mailbox address \"%s\" (%s)",
380 b, result);
381 else
382 usrerr("501 5.1.7 Syntax error in mailbox address \"%s\" (%s)",
383 b, result);
384 }
385 return result != NULL;
386 }
387 /*
388 ** ALLOCADDR -- do local allocations of address on demand.
389 **
390 ** Also lowercases the host name if requested.
391 **
392 ** Parameters:
393 ** a -- the address to reallocate.
394 ** flags -- the copy flag (see RF_ definitions in sendmail.h
395 ** for a description).
396 ** paddr -- the printname of the address.
397 ** e -- envelope
398 **
399 ** Returns:
400 ** none.
401 **
402 ** Side Effects:
403 ** Copies portions of a into local buffers as requested.
404 */
405
406 static void
407 allocaddr(a, flags, paddr, e)
408 register ADDRESS *a;
409 int flags;
410 char *paddr;
411 ENVELOPE *e;
412 {
413 if (tTd(24, 4))
414 sm_dprintf("allocaddr(flags=%x, paddr=%s)\n", flags, paddr);
415
416 a->q_paddr = paddr;
417
418 if (a->q_user == NULL)
419 a->q_user = "";
420 if (a->q_host == NULL)
421 a->q_host = "";
422
423 if (bitset(RF_COPYPARSE, flags))
424 {
425 a->q_host = sm_rpool_strdup_x(e->e_rpool, a->q_host);
426 if (a->q_user != a->q_paddr)
427 a->q_user = sm_rpool_strdup_x(e->e_rpool, a->q_user);
428 }
429
430 if (a->q_paddr == NULL)
431 a->q_paddr = sm_rpool_strdup_x(e->e_rpool, a->q_user);
432 a->q_qgrp = NOAQGRP;
433 }
434 /*
435 ** PRESCAN -- Prescan name and make it canonical
436 **
437 ** Scans a name and turns it into a set of tokens. This process
438 ** deletes blanks and comments (in parentheses) (if the token type
439 ** for left paren is SPC).
440 **
441 ** This routine knows about quoted strings and angle brackets.
442 **
443 ** There are certain subtleties to this routine. The one that
444 ** comes to mind now is that backslashes on the ends of names
445 ** are silently stripped off; this is intentional. The problem
446 ** is that some versions of sndmsg (like at LBL) set the kill
447 ** character to something other than @ when reading addresses;
448 ** so people type "csvax.eric\@berkeley" -- which screws up the
449 ** berknet mailer.
450 **
451 ** Parameters:
452 ** addr -- the name to chomp.
453 ** delim -- the delimiter for the address, normally
454 ** '\0' or ','; \0 is accepted in any case.
455 ** If '\t' then we are reading the .cf file.
456 ** pvpbuf -- place to put the saved text -- note that
457 ** the pointers are static.
458 ** pvpbsize -- size of pvpbuf.
459 ** delimptr -- if non-NULL, set to the location of the
460 ** terminating delimiter.
461 ** toktab -- if set, a token table to use for parsing.
462 ** If NULL, use the default table.
463 ** ignore -- if true, ignore unbalanced addresses
464 **
465 ** Returns:
466 ** A pointer to a vector of tokens.
467 ** NULL on error.
468 */
469
470 /* states and character types */
471 #define OPR 0 /* operator */
472 #define ATM 1 /* atom */
473 #define QST 2 /* in quoted string */
474 #define SPC 3 /* chewing up spaces */
475 #define ONE 4 /* pick up one character */
476 #define ILL 5 /* illegal character */
477
478 #define NSTATES 6 /* number of states */
479 #define TYPE 017 /* mask to select state type */
480
481 /* meta bits for table */
482 #define M 020 /* meta character; don't pass through */
483 #define B 040 /* cause a break */
484 #define MB M|B /* meta-break */
485
486 static short StateTab[NSTATES][NSTATES] =
487 {
488 /* oldst chtype> OPR ATM QST SPC ONE ILL */
489 /*OPR*/ { OPR|B, ATM|B, QST|B, SPC|MB, ONE|B, ILL|MB },
490 /*ATM*/ { OPR|B, ATM, QST|B, SPC|MB, ONE|B, ILL|MB },
491 /*QST*/ { QST, QST, OPR, QST, QST, QST },
492 /*SPC*/ { OPR, ATM, QST, SPC|M, ONE, ILL|MB },
493 /*ONE*/ { OPR, OPR, OPR, OPR, OPR, ILL|MB },
494 /*ILL*/ { OPR|B, ATM|B, QST|B, SPC|MB, ONE|B, ILL|M },
495 };
496
497 /* token type table -- it gets modified with $o characters */
498 static unsigned char TokTypeTab[256] =
499 {
500 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
501 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,SPC,SPC,SPC,SPC,SPC,ATM,ATM,
502 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
503 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
504 /* sp ! " # $ % & ' ( ) * + , - . / */
505 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, SPC,SPC,ATM,ATM,ATM,ATM,ATM,ATM,
506 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
507 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
508 /* @ A B C D E F G H I J K L M N O */
509 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
510 /* P Q R S T U V W X Y Z [ \ ] ^ _ */
511 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
512 /* ` a b c d e f g h i j k l m n o */
513 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
514 /* p q r s t u v w x y z { | } ~ del */
515 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
516
517 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
518 OPR,OPR,ONE,OPR,OPR,OPR,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR,
519 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
520 OPR,OPR,OPR,ONE,ONE,ONE,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR,
521 /* sp ! " # $ % & ' ( ) * + , - . / */
522 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
523 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
524 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
525 /* @ A B C D E F G H I J K L M N O */
526 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
527 /* P Q R S T U V W X Y Z [ \ ] ^ _ */
528 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
529 /* ` a b c d e f g h i j k l m n o */
530 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
531 /* p q r s t u v w x y z { | } ~ del */
532 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
533 };
534
535 /* token type table for MIME parsing */
536 unsigned char MimeTokenTab[256] =
537 {
538 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
539 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,SPC,SPC,SPC,SPC,SPC,ILL,ILL,
540 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
541 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
542 /* sp ! " # $ % & ' ( ) * + , - . / */
543 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, SPC,SPC,ATM,ATM,OPR,ATM,ATM,OPR,
544 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
545 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,OPR,OPR,OPR,OPR,OPR,OPR,
546 /* @ A B C D E F G H I J K L M N O */
547 OPR,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
548 /* P Q R S T U V W X Y Z [ \ ] ^ _ */
549 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,OPR,OPR,OPR,ATM,ATM,
550 /* ` a b c d e f g h i j k l m n o */
551 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
552 /* p q r s t u v w x y z { | } ~ del */
553 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
554
555 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
556 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
557 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
558 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
559 /* sp ! " # $ % & ' ( ) * + , - . / */
560 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
561 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
562 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
563 /* @ A B C D E F G H I J K L M N O */
564 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
565 /* P Q R S T U V W X Y Z [ \ ] ^ _ */
566 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
567 /* ` a b c d e f g h i j k l m n o */
568 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
569 /* p q r s t u v w x y z { | } ~ del */
570 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL,
571 };
572
573 /* token type table: don't strip comments */
574 unsigned char TokTypeNoC[256] =
575 {
576 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
577 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,SPC,SPC,SPC,SPC,SPC,ATM,ATM,
578 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
579 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
580 /* sp ! " # $ % & ' ( ) * + , - . / */
581 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, OPR,OPR,ATM,ATM,ATM,ATM,ATM,ATM,
582 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
583 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
584 /* @ A B C D E F G H I J K L M N O */
585 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
586 /* P Q R S T U V W X Y Z [ \ ] ^ _ */
587 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
588 /* ` a b c d e f g h i j k l m n o */
589 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
590 /* p q r s t u v w x y z { | } ~ del */
591 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
592
593 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
594 OPR,OPR,ONE,OPR,OPR,OPR,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR,
595 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
596 OPR,OPR,OPR,ONE,ONE,ONE,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR,
597 /* sp ! " # $ % & ' ( ) * + , - . / */
598 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
599 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
600 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
601 /* @ A B C D E F G H I J K L M N O */
602 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
603 /* P Q R S T U V W X Y Z [ \ ] ^ _ */
604 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
605 /* ` a b c d e f g h i j k l m n o */
606 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
607 /* p q r s t u v w x y z { | } ~ del */
608 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM,
609 };
610
611
612 #define NOCHAR (-1) /* signal nothing in lookahead token */
613
614 char **
615 prescan(addr, delim, pvpbuf, pvpbsize, delimptr, toktab, ignore)
616 char *addr;
617 int delim;
618 char pvpbuf[];
619 int pvpbsize;
620 char **delimptr;
621 unsigned char *toktab;
622 bool ignore;
623 {
624 register char *p;
625 register char *q;
626 register int c;
627 char **avp;
628 bool bslashmode;
629 bool route_syntax;
630 int cmntcnt;
631 int anglecnt;
632 char *tok;
633 int state;
634 int newstate;
635 char *saveto = CurEnv->e_to;
636 static char *av[MAXATOM + 1];
637 static bool firsttime = true;
638
639 if (firsttime)
640 {
641 /* initialize the token type table */
642 char obuf[50];
643
644 firsttime = false;
645 if (OperatorChars == NULL)
646 {
647 if (ConfigLevel < 7)
648 OperatorChars = macvalue('o', CurEnv);
649 if (OperatorChars == NULL)
650 OperatorChars = ".:@[]";
651 }
652 expand(OperatorChars, obuf, sizeof obuf - sizeof DELIMCHARS,
653 CurEnv);
654 (void) sm_strlcat(obuf, DELIMCHARS, sizeof obuf);
655 for (p = obuf; *p != '\0'; p++)
656 {
657 if (TokTypeTab[*p & 0xff] == ATM)
658 TokTypeTab[*p & 0xff] = OPR;
659 if (TokTypeNoC[*p & 0xff] == ATM)
660 TokTypeNoC[*p & 0xff] = OPR;
661 }
662 }
663 if (toktab == NULL)
664 toktab = TokTypeTab;
665
666 /* make sure error messages don't have garbage on them */
667 errno = 0;
668
669 q = pvpbuf;
670 bslashmode = false;
671 route_syntax = false;
672 cmntcnt = 0;
673 anglecnt = 0;
674 avp = av;
675 state = ATM;
676 c = NOCHAR;
677 p = addr;
678 CurEnv->e_to = p;
679 if (tTd(22, 11))
680 {
681 sm_dprintf("prescan: ");
682 xputs(sm_debug_file(), p);
683 sm_dprintf("\n");
684 }
685
686 do
687 {
688 /* read a token */
689 tok = q;
690 for (;;)
691 {
692 /* store away any old lookahead character */
693 if (c != NOCHAR && !bslashmode)
694 {
695 /* see if there is room */
696 if (q >= &pvpbuf[pvpbsize - 5])
697 {
698 addrtoolong:
699 usrerr("553 5.1.1 Address too long");
700 if (strlen(addr) > MAXNAME)
701 addr[MAXNAME] = '\0';
702 returnnull:
703 if (delimptr != NULL)
704 {
705 if (p > addr)
706 --p;
707 *delimptr = p;
708 }
709 CurEnv->e_to = saveto;
710 return NULL;
711 }
712
713 /* squirrel it away */
714 #if !ALLOW_255
715 if ((char) c == (char) -1 && !tTd(82, 101))
716 c &= 0x7f;
717 #endif /* !ALLOW_255 */
718 *q++ = c;
719 }
720
721 /* read a new input character */
722 c = (*p++) & 0x00ff;
723 if (c == '\0')
724 {
725 /* diagnose and patch up bad syntax */
726 if (ignore)
727 break;
728 else if (state == QST)
729 {
730 usrerr("553 Unbalanced '\"'");
731 c = '"';
732 }
733 else if (cmntcnt > 0)
734 {
735 usrerr("553 Unbalanced '('");
736 c = ')';
737 }
738 else if (anglecnt > 0)
739 {
740 c = '>';
741 usrerr("553 Unbalanced '<'");
742 }
743 else
744 break;
745
746 p--;
747 }
748 else if (c == delim && cmntcnt <= 0 && state != QST)
749 {
750 if (anglecnt <= 0)
751 break;
752
753 /* special case for better error management */
754 if (delim == ',' && !route_syntax && !ignore)
755 {
756 usrerr("553 Unbalanced '<'");
757 c = '>';
758 p--;
759 }
760 }
761
762 if (tTd(22, 101))
763 sm_dprintf("c=%c, s=%d; ", c, state);
764
765 /* chew up special characters */
766 *q = '\0';
767 if (bslashmode)
768 {
769 bslashmode = false;
770
771 /* kludge \! for naive users */
772 if (cmntcnt > 0)
773 {
774 c = NOCHAR;
775 continue;
776 }
777 else if (c != '!' || state == QST)
778 {
779 /* see if there is room */
780 if (q >= &pvpbuf[pvpbsize - 5])
781 goto addrtoolong;
782 *q++ = '\\';
783 continue;
784 }
785 }
786
787 if (c == '\\')
788 {
789 bslashmode = true;
790 }
791 else if (state == QST)
792 {
793 /* EMPTY */
794 /* do nothing, just avoid next clauses */
795 }
796 else if (c == '(' && toktab['('] == SPC)
797 {
798 cmntcnt++;
799 c = NOCHAR;
800 }
801 else if (c == ')' && toktab['('] == SPC)
802 {
803 if (cmntcnt <= 0)
804 {
805 if (!ignore)
806 {
807 usrerr("553 Unbalanced ')'");
808 c = NOCHAR;
809 }
810 }
811 else
812 cmntcnt--;
813 }
814 else if (cmntcnt > 0)
815 {
816 c = NOCHAR;
817 }
818 else if (c == '<')
819 {
820 char *ptr = p;
821
822 anglecnt++;
823 while (isascii(*ptr) && isspace(*ptr))
824 ptr++;
825 if (*ptr == '@')
826 route_syntax = true;
827 }
828 else if (c == '>')
829 {
830 if (anglecnt <= 0)
831 {
832 if (!ignore)
833 {
834 usrerr("553 Unbalanced '>'");
835 c = NOCHAR;
836 }
837 }
838 else
839 anglecnt--;
840 route_syntax = false;
841 }
842 else if (delim == ' ' && isascii(c) && isspace(c))
843 c = ' ';
844
845 if (c == NOCHAR)
846 continue;
847
848 /* see if this is end of input */
849 if (c == delim && anglecnt <= 0 && state != QST)
850 break;
851
852 newstate = StateTab[state][toktab[c & 0xff]];
853 if (tTd(22, 101))
854 sm_dprintf("ns=%02o\n", newstate);
855 state = newstate & TYPE;
856 if (state == ILL)
857 {
858 if (isascii(c) && isprint(c))
859 usrerr("553 Illegal character %c", c);
860 else
861 usrerr("553 Illegal character 0x%02x",
862 c & 0x0ff);
863 }
864 if (bitset(M, newstate))
865 c = NOCHAR;
866 if (bitset(B, newstate))
867 break;
868 }
869
870 /* new token */
871 if (tok != q)
872 {
873 /* see if there is room */
874 if (q >= &pvpbuf[pvpbsize - 5])
875 goto addrtoolong;
876 *q++ = '\0';
877 if (tTd(22, 36))
878 {
879 sm_dprintf("tok=");
880 xputs(sm_debug_file(), tok);
881 sm_dprintf("\n");
882 }
883 if (avp >= &av[MAXATOM])
884 {
885 usrerr("553 5.1.0 prescan: too many tokens");
886 goto returnnull;
887 }
888 if (q - tok > MAXNAME)
889 {
890 usrerr("553 5.1.0 prescan: token too long");
891 goto returnnull;
892 }
893 *avp++ = tok;
894 }
895 } while (c != '\0' && (c != delim || anglecnt > 0));
896 *avp = NULL;
897 if (delimptr != NULL)
898 {
899 if (p > addr)
900 p--;
901 *delimptr = p;
902 }
903 if (tTd(22, 12))
904 {
905 sm_dprintf("prescan==>");
906 printav(sm_debug_file(), av);
907 }
908 CurEnv->e_to = saveto;
909 if (av[0] == NULL)
910 {
911 if (tTd(22, 1))
912 sm_dprintf("prescan: null leading token\n");
913 return NULL;
914 }
915 return av;
916 }
917 /*
918 ** REWRITE -- apply rewrite rules to token vector.
919 **
920 ** This routine is an ordered production system. Each rewrite
921 ** rule has a LHS (called the pattern) and a RHS (called the
922 ** rewrite); 'rwr' points the the current rewrite rule.
923 **
924 ** For each rewrite rule, 'avp' points the address vector we
925 ** are trying to match against, and 'pvp' points to the pattern.
926 ** If pvp points to a special match value (MATCHZANY, MATCHANY,
927 ** MATCHONE, MATCHCLASS, MATCHNCLASS) then the address in avp
928 ** matched is saved away in the match vector (pointed to by 'mvp').
929 **
930 ** When a match between avp & pvp does not match, we try to
931 ** back out. If we back up over MATCHONE, MATCHCLASS, or MATCHNCLASS
932 ** we must also back out the match in mvp. If we reach a
933 ** MATCHANY or MATCHZANY we just extend the match and start
934 ** over again.
935 **
936 ** When we finally match, we rewrite the address vector
937 ** and try over again.
938 **
939 ** Parameters:
940 ** pvp -- pointer to token vector.
941 ** ruleset -- the ruleset to use for rewriting.
942 ** reclevel -- recursion level (to catch loops).
943 ** e -- the current envelope.
944 ** maxatom -- maximum length of buffer (usually MAXATOM)
945 **
946 ** Returns:
947 ** A status code. If EX_TEMPFAIL, higher level code should
948 ** attempt recovery.
949 **
950 ** Side Effects:
951 ** pvp is modified.
952 */
953
954 struct match
955 {
956 char **match_first; /* first token matched */
957 char **match_last; /* last token matched */
958 char **match_pattern; /* pointer to pattern */
959 };
960
961 int
962 rewrite(pvp, ruleset, reclevel, e, maxatom)
963 char **pvp;
964 int ruleset;
965 int reclevel;
966 register ENVELOPE *e;
967 int maxatom;
968 {
969 register char *ap; /* address pointer */
970 register char *rp; /* rewrite pointer */
971 register char *rulename; /* ruleset name */
972 register char *prefix;
973 register char **avp; /* address vector pointer */
974 register char **rvp; /* rewrite vector pointer */
975 register struct match *mlp; /* cur ptr into mlist */
976 register struct rewrite *rwr; /* pointer to current rewrite rule */
977 int ruleno; /* current rule number */
978 int rstat = EX_OK; /* return status */
979 int loopcount;
980 struct match mlist[MAXMATCH]; /* stores match on LHS */
981 char *npvp[MAXATOM + 1]; /* temporary space for rebuild */
982 char buf[MAXLINE];
983 char name[6];
984
985 /*
986 ** mlp will not exceed mlist[] because readcf enforces
987 ** the upper limit of entries when reading rulesets.
988 */
989
990 if (ruleset < 0 || ruleset >= MAXRWSETS)
991 {
992 syserr("554 5.3.5 rewrite: illegal ruleset number %d", ruleset);
993 return EX_CONFIG;
994 }
995 rulename = RuleSetNames[ruleset];
996 if (rulename == NULL)
997 {
998 (void) sm_snprintf(name, sizeof name, "%d", ruleset);
999 rulename = name;
1000 }
1001 if (OpMode == MD_TEST)
1002 prefix = "";
1003 else
1004 prefix = "rewrite: ruleset ";
1005 if (OpMode == MD_TEST)
1006 {
1007 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1008 "%s%-16.16s input:", prefix, rulename);
1009 printav(smioout, pvp);
1010 }
1011 else if (tTd(21, 1))
1012 {
1013 sm_dprintf("%s%-16.16s input:", prefix, rulename);
1014 printav(sm_debug_file(), pvp);
1015 }
1016 if (reclevel++ > MaxRuleRecursion)
1017 {
1018 syserr("rewrite: excessive recursion (max %d), ruleset %s",
1019 MaxRuleRecursion, rulename);
1020 return EX_CONFIG;
1021 }
1022 if (pvp == NULL)
1023 return EX_USAGE;
1024 if (maxatom <= 0)
1025 return EX_USAGE;
1026
1027 /*
1028 ** Run through the list of rewrite rules, applying
1029 ** any that match.
1030 */
1031
1032 ruleno = 1;
1033 loopcount = 0;
1034 for (rwr = RewriteRules[ruleset]; rwr != NULL; )
1035 {
1036 int status;
1037
1038 /* if already canonical, quit now */
1039 if (pvp[0] != NULL && (pvp[0][0] & 0377) == CANONNET)
1040 break;
1041
1042 if (tTd(21, 12))
1043 {
1044 if (tTd(21, 15))
1045 sm_dprintf("-----trying rule (line %d):",
1046 rwr->r_line);
1047 else
1048 sm_dprintf("-----trying rule:");
1049 printav(sm_debug_file(), rwr->r_lhs);
1050 }
1051
1052 /* try to match on this rule */
1053 mlp = mlist;
1054 rvp = rwr->r_lhs;
1055 avp = pvp;
1056 if (++loopcount > 100)
1057 {
1058 syserr("554 5.3.5 Infinite loop in ruleset %s, rule %d",
1059 rulename, ruleno);
1060 if (tTd(21, 1))
1061 {
1062 sm_dprintf("workspace: ");
1063 printav(sm_debug_file(), pvp);
1064 }
1065 break;
1066 }
1067
1068 while ((ap = *avp) != NULL || *rvp != NULL)
1069 {
1070 rp = *rvp;
1071 if (tTd(21, 35))
1072 {
1073 sm_dprintf("ADVANCE rp=");
1074 xputs(sm_debug_file(), rp);
1075 sm_dprintf(", ap=");
1076 xputs(sm_debug_file(), ap);
1077 sm_dprintf("\n");
1078 }
1079 if (rp == NULL)
1080 {
1081 /* end-of-pattern before end-of-address */
1082 goto backup;
1083 }
1084 if (ap == NULL && (*rp & 0377) != MATCHZANY &&
1085 (*rp & 0377) != MATCHZERO)
1086 {
1087 /* end-of-input with patterns left */
1088 goto backup;
1089 }
1090
1091 switch (*rp & 0377)
1092 {
1093 case MATCHCLASS:
1094 /* match any phrase in a class */
1095 mlp->match_pattern = rvp;
1096 mlp->match_first = avp;
1097 extendclass:
1098 ap = *avp;
1099 if (ap == NULL)
1100 goto backup;
1101 mlp->match_last = avp++;
1102 cataddr(mlp->match_first, mlp->match_last,
1103 buf, sizeof buf, '\0');
1104 if (!wordinclass(buf, rp[1]))
1105 {
1106 if (tTd(21, 36))
1107 {
1108 sm_dprintf("EXTEND rp=");
1109 xputs(sm_debug_file(), rp);
1110 sm_dprintf(", ap=");
1111 xputs(sm_debug_file(), ap);
1112 sm_dprintf("\n");
1113 }
1114 goto extendclass;
1115 }
1116 if (tTd(21, 36))
1117 sm_dprintf("CLMATCH\n");
1118 mlp++;
1119 break;
1120
1121 case MATCHNCLASS:
1122 /* match any token not in a class */
1123 if (wordinclass(ap, rp[1]))
1124 goto backup;
1125
1126 /* FALLTHROUGH */
1127
1128 case MATCHONE:
1129 case MATCHANY:
1130 /* match exactly one token */
1131 mlp->match_pattern = rvp;
1132 mlp->match_first = avp;
1133 mlp->match_last = avp++;
1134 mlp++;
1135 break;
1136
1137 case MATCHZANY:
1138 /* match zero or more tokens */
1139 mlp->match_pattern = rvp;
1140 mlp->match_first = avp;
1141 mlp->match_last = avp - 1;
1142 mlp++;
1143 break;
1144
1145 case MATCHZERO:
1146 /* match zero tokens */
1147 break;
1148
1149 case MACRODEXPAND:
1150 /*
1151 ** Match against run-time macro.
1152 ** This algorithm is broken for the
1153 ** general case (no recursive macros,
1154 ** improper tokenization) but should
1155 ** work for the usual cases.
1156 */
1157
1158 ap = macvalue(rp[1], e);
1159 mlp->match_first = avp;
1160 if (tTd(21, 2))
1161 sm_dprintf("rewrite: LHS $&{%s} => \"%s\"\n",
1162 macname(rp[1]),
1163 ap == NULL ? "(NULL)" : ap);
1164
1165 if (ap == NULL)
1166 break;
1167 while (*ap != '\0')
1168 {
1169 if (*avp == NULL ||
1170 sm_strncasecmp(ap, *avp,
1171 strlen(*avp)) != 0)
1172 {
1173 /* no match */
1174 avp = mlp->match_first;
1175 goto backup;
1176 }
1177 ap += strlen(*avp++);
1178 }
1179
1180 /* match */
1181 break;
1182
1183 default:
1184 /* must have exact match */
1185 if (sm_strcasecmp(rp, ap))
1186 goto backup;
1187 avp++;
1188 break;
1189 }
1190
1191 /* successful match on this token */
1192 rvp++;
1193 continue;
1194
1195 backup:
1196 /* match failed -- back up */
1197 while (--mlp >= mlist)
1198 {
1199 rvp = mlp->match_pattern;
1200 rp = *rvp;
1201 avp = mlp->match_last + 1;
1202 ap = *avp;
1203
1204 if (tTd(21, 36))
1205 {
1206 sm_dprintf("BACKUP rp=");
1207 xputs(sm_debug_file(), rp);
1208 sm_dprintf(", ap=");
1209 xputs(sm_debug_file(), ap);
1210 sm_dprintf("\n");
1211 }
1212
1213 if (ap == NULL)
1214 {
1215 /* run off the end -- back up again */
1216 continue;
1217 }
1218 if ((*rp & 0377) == MATCHANY ||
1219 (*rp & 0377) == MATCHZANY)
1220 {
1221 /* extend binding and continue */
1222 mlp->match_last = avp++;
1223 rvp++;
1224 mlp++;
1225 break;
1226 }
1227 if ((*rp & 0377) == MATCHCLASS)
1228 {
1229 /* extend binding and try again */
1230 mlp->match_last = avp;
1231 goto extendclass;
1232 }
1233 }
1234
1235 if (mlp < mlist)
1236 {
1237 /* total failure to match */
1238 break;
1239 }
1240 }
1241
1242 /*
1243 ** See if we successfully matched
1244 */
1245
1246 if (mlp < mlist || *rvp != NULL)
1247 {
1248 if (tTd(21, 10))
1249 sm_dprintf("----- rule fails\n");
1250 rwr = rwr->r_next;
1251 ruleno++;
1252 loopcount = 0;
1253 continue;
1254 }
1255
1256 rvp = rwr->r_rhs;
1257 if (tTd(21, 12))
1258 {
1259 sm_dprintf("-----rule matches:");
1260 printav(sm_debug_file(), rvp);
1261 }
1262
1263 rp = *rvp;
1264 if (rp != NULL)
1265 {
1266 if ((*rp & 0377) == CANONUSER)
1267 {
1268 rvp++;
1269 rwr = rwr->r_next;
1270 ruleno++;
1271 loopcount = 0;
1272 }
1273 else if ((*rp & 0377) == CANONHOST)
1274 {
1275 rvp++;
1276 rwr = NULL;
1277 }
1278 }
1279
1280 /* substitute */
1281 for (avp = npvp; *rvp != NULL; rvp++)
1282 {
1283 register struct match *m;
1284 register char **pp;
1285
1286 rp = *rvp;
1287 if ((*rp & 0377) == MATCHREPL)
1288 {
1289 /* substitute from LHS */
1290 m = &mlist[rp[1] - '1'];
1291 if (m < mlist || m >= mlp)
1292 {
1293 syserr("554 5.3.5 rewrite: ruleset %s: replacement $%c out of bounds",
1294 rulename, rp[1]);
1295 return EX_CONFIG;
1296 }
1297 if (tTd(21, 15))
1298 {
1299 sm_dprintf("$%c:", rp[1]);
1300 pp = m->match_first;
1301 while (pp <= m->match_last)
1302 {
1303 sm_dprintf(" %p=\"", *pp);
1304 sm_dflush();
1305 sm_dprintf("%s\"", *pp++);
1306 }
1307 sm_dprintf("\n");
1308 }
1309 pp = m->match_first;
1310 while (pp <= m->match_last)
1311 {
1312 if (avp >= &npvp[maxatom])
1313 goto toolong;
1314 *avp++ = *pp++;
1315 }
1316 }
1317 else
1318 {
1319 /* some sort of replacement */
1320 if (avp >= &npvp[maxatom])
1321 {
1322 toolong:
1323 syserr("554 5.3.0 rewrite: expansion too long");
1324 if (LogLevel > 9)
1325 sm_syslog(LOG_ERR, e->e_id,
1326 "rewrite: expansion too long, ruleset=%s, ruleno=%d",
1327 rulename, ruleno);
1328 return EX_DATAERR;
1329 }
1330 if ((*rp & 0377) != MACRODEXPAND)
1331 {
1332 /* vanilla replacement */
1333 *avp++ = rp;
1334 }
1335 else
1336 {
1337 /* $&{x} replacement */
1338 char *mval = macvalue(rp[1], e);
1339 char **xpvp;
1340 int trsize = 0;
1341 static size_t pvpb1_size = 0;
1342 static char **pvpb1 = NULL;
1343 char pvpbuf[PSBUFSIZE];
1344
1345 if (tTd(21, 2))
1346 sm_dprintf("rewrite: RHS $&{%s} => \"%s\"\n",
1347 macname(rp[1]),
1348 mval == NULL ? "(NULL)" : mval);
1349 if (mval == NULL || *mval == '\0')
1350 continue;
1351
1352 /* save the remainder of the input */
1353 for (xpvp = pvp; *xpvp != NULL; xpvp++)
1354 trsize += sizeof *xpvp;
1355 if ((size_t) trsize > pvpb1_size)
1356 {
1357 if (pvpb1 != NULL)
1358 sm_free(pvpb1);
1359 pvpb1 = (char **)
1360 sm_pmalloc_x(trsize);
1361 pvpb1_size = trsize;
1362 }
1363
1364 memmove((char *) pvpb1,
1365 (char *) pvp,
1366 trsize);
1367
1368 /* scan the new replacement */
1369 xpvp = prescan(mval, '\0', pvpbuf,
1370 sizeof pvpbuf, NULL,
1371 NULL, false);
1372 if (xpvp == NULL)
1373 {
1374 /* prescan pre-printed error */
1375 return EX_DATAERR;
1376 }
1377
1378 /* insert it into the output stream */
1379 while (*xpvp != NULL)
1380 {
1381 if (tTd(21, 19))
1382 sm_dprintf(" ... %s\n",
1383 *xpvp);
1384 *avp++ = sm_rpool_strdup_x(
1385 e->e_rpool, *xpvp);
1386 if (avp >= &npvp[maxatom])
1387 goto toolong;
1388 xpvp++;
1389 }
1390 if (tTd(21, 19))
1391 sm_dprintf(" ... DONE\n");
1392
1393 /* restore the old trailing input */
1394 memmove((char *) pvp,
1395 (char *) pvpb1,
1396 trsize);
1397 }
1398 }
1399 }
1400 *avp++ = NULL;
1401
1402 /*
1403 ** Check for any hostname/keyword lookups.
1404 */
1405
1406 for (rvp = npvp; *rvp != NULL; rvp++)
1407 {
1408 char **hbrvp;
1409 char **xpvp;
1410 int trsize;
1411 char *replac;
1412 int endtoken;
1413 STAB *map;
1414 char *mapname;
1415 char **key_rvp;
1416 char **arg_rvp;
1417 char **default_rvp;
1418 char cbuf[MAXNAME + 1];
1419 char *pvpb1[MAXATOM + 1];
1420 char *argvect[MAX_MAP_ARGS];
1421 char pvpbuf[PSBUFSIZE];
1422 char *nullpvp[1];
1423
1424 if ((**rvp & 0377) != HOSTBEGIN &&
1425 (**rvp & 0377) != LOOKUPBEGIN)
1426 continue;
1427
1428 /*
1429 ** Got a hostname/keyword lookup.
1430 **
1431 ** This could be optimized fairly easily.
1432 */
1433
1434 hbrvp = rvp;
1435 if ((**rvp & 0377) == HOSTBEGIN)
1436 {
1437 endtoken = HOSTEND;
1438 mapname = "host";
1439 }
1440 else
1441 {
1442 endtoken = LOOKUPEND;
1443 mapname = *++rvp;
1444 if (mapname == NULL)
1445 syserr("554 5.3.0 rewrite: missing mapname");
1446 }
1447 map = stab(mapname, ST_MAP, ST_FIND);
1448 if (map == NULL)
1449 syserr("554 5.3.0 rewrite: map %s not found",
1450 mapname);
1451
1452 /* extract the match part */
1453 key_rvp = ++rvp;
1454 if (key_rvp == NULL)
1455 syserr("554 5.3.0 rewrite: missing key for map %s",
1456 mapname);
1457 default_rvp = NULL;
1458 arg_rvp = argvect;
1459 xpvp = NULL;
1460 replac = pvpbuf;
1461 while (*rvp != NULL && (**rvp & 0377) != endtoken)
1462 {
1463 int nodetype = **rvp & 0377;
1464
1465 if (nodetype != CANONHOST &&
1466 nodetype != CANONUSER)
1467 {
1468 rvp++;
1469 continue;
1470 }
1471
1472 *rvp++ = NULL;
1473
1474 if (xpvp != NULL)
1475 {
1476 cataddr(xpvp, NULL, replac,
1477 &pvpbuf[sizeof pvpbuf] - replac,
1478 '\0');
1479 if (arg_rvp <
1480 &argvect[MAX_MAP_ARGS - 1])
1481 *++arg_rvp = replac;
1482 replac += strlen(replac) + 1;
1483 xpvp = NULL;
1484 }
1485 switch (nodetype)
1486 {
1487 case CANONHOST:
1488 xpvp = rvp;
1489 break;
1490
1491 case CANONUSER:
1492 default_rvp = rvp;
1493 break;
1494 }
1495 }
1496 if (*rvp != NULL)
1497 *rvp++ = NULL;
1498 if (xpvp != NULL)
1499 {
1500 cataddr(xpvp, NULL, replac,
1501 &pvpbuf[sizeof pvpbuf] - replac,
1502 '\0');
1503 if (arg_rvp < &argvect[MAX_MAP_ARGS - 1])
1504 *++arg_rvp = replac;
1505 }
1506 if (arg_rvp >= &argvect[MAX_MAP_ARGS - 1])
1507 argvect[MAX_MAP_ARGS - 1] = NULL;
1508 else
1509 *++arg_rvp = NULL;
1510
1511 /* save the remainder of the input string */
1512 trsize = (int) (avp - rvp + 1) * sizeof *rvp;
1513 memmove((char *) pvpb1, (char *) rvp, trsize);
1514
1515 /* look it up */
1516 cataddr(key_rvp, NULL, cbuf, sizeof cbuf,
1517 map == NULL ? '\0' : map->s_map.map_spacesub);
1518 argvect[0] = cbuf;
1519 replac = map_lookup(map, cbuf, argvect, &rstat, e);
1520
1521 /* if no replacement, use default */
1522 if (replac == NULL && default_rvp != NULL)
1523 {
1524 /* create the default */
1525 cataddr(default_rvp, NULL, cbuf, sizeof cbuf, '\0');
1526 replac = cbuf;
1527 }
1528
1529 if (replac == NULL)
1530 {
1531 xpvp = key_rvp;
1532 }
1533 else if (*replac == '\0')
1534 {
1535 /* null replacement */
1536 nullpvp[0] = NULL;
1537 xpvp = nullpvp;
1538 }
1539 else
1540 {
1541 /* scan the new replacement */
1542 xpvp = prescan(replac, '\0', pvpbuf,
1543 sizeof pvpbuf, NULL, NULL, false);
1544 if (xpvp == NULL)
1545 {
1546 /* prescan already printed error */
1547 return EX_DATAERR;
1548 }
1549 }
1550
1551 /* append it to the token list */
1552 for (avp = hbrvp; *xpvp != NULL; xpvp++)
1553 {
1554 *avp++ = sm_rpool_strdup_x(e->e_rpool, *xpvp);
1555 if (avp >= &npvp[maxatom])
1556 goto toolong;
1557 }
1558
1559 /* restore the old trailing information */
1560 rvp = avp - 1;
1561 for (xpvp = pvpb1; (*avp++ = *xpvp++) != NULL; )
1562 if (avp >= &npvp[maxatom])
1563 goto toolong;
1564 }
1565
1566 /*
1567 ** Check for subroutine calls.
1568 */
1569
1570 status = callsubr(npvp, reclevel, e);
1571 if (rstat == EX_OK || status == EX_TEMPFAIL)
1572 rstat = status;
1573
1574 /* copy vector back into original space. */
1575 for (avp = npvp; *avp++ != NULL;)
1576 continue;
1577 memmove((char *) pvp, (char *) npvp,
1578 (int) (avp - npvp) * sizeof *avp);
1579
1580 if (tTd(21, 4))
1581 {
1582 sm_dprintf("rewritten as:");
1583 printav(sm_debug_file(), pvp);
1584 }
1585 }
1586
1587 if (OpMode == MD_TEST)
1588 {
1589 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1590 "%s%-16.16s returns:", prefix, rulename);
1591 printav(smioout, pvp);
1592 }
1593 else if (tTd(21, 1))
1594 {
1595 sm_dprintf("%s%-16.16s returns:", prefix, rulename);
1596 printav(sm_debug_file(), pvp);
1597 }
1598 return rstat;
1599 }
1600 /*
1601 ** CALLSUBR -- call subroutines in rewrite vector
1602 **
1603 ** Parameters:
1604 ** pvp -- pointer to token vector.
1605 ** reclevel -- the current recursion level.
1606 ** e -- the current envelope.
1607 **
1608 ** Returns:
1609 ** The status from the subroutine call.
1610 **
1611 ** Side Effects:
1612 ** pvp is modified.
1613 */
1614
1615 static int
1616 callsubr(pvp, reclevel, e)
1617 char **pvp;
1618 int reclevel;
1619 ENVELOPE *e;
1620 {
1621 char **avp;
1622 register int i;
1623 int subr, j;
1624 int nsubr;
1625 int status;
1626 int rstat = EX_OK;
1627 #define MAX_SUBR 16
1628 int subrnumber[MAX_SUBR];
1629 int subrindex[MAX_SUBR];
1630
1631 nsubr = 0;
1632
1633 /*
1634 ** Look for subroutine calls in pvp, collect them into subr*[]
1635 ** We will perform the calls in the next loop, because we will
1636 ** call the "last" subroutine first to avoid recursive calls
1637 ** and too much copying.
1638 */
1639
1640 for (avp = pvp, j = 0; *avp != NULL; avp++, j++)
1641 {
1642 if ((**avp & 0377) == CALLSUBR && avp[1] != NULL)
1643 {
1644 stripquotes(avp[1]);
1645 subr = strtorwset(avp[1], NULL, ST_FIND);
1646 if (subr < 0)
1647 {
1648 syserr("554 5.3.5 Unknown ruleset %s", avp[1]);
1649 return EX_CONFIG;
1650 }
1651
1652 /*
1653 ** XXX instead of doing this we could optimize
1654 ** the rules after reading them: just remove
1655 ** calls to empty rulesets
1656 */
1657
1658 /* subroutine is an empty ruleset? don't call it */
1659 if (RewriteRules[subr] == NULL)
1660 {
1661 if (tTd(21, 3))
1662 sm_dprintf("-----skip subr %s (%d)\n",
1663 avp[1], subr);
1664 for (i = 2; avp[i] != NULL; i++)
1665 avp[i - 2] = avp[i];
1666 avp[i - 2] = NULL;
1667 continue;
1668 }
1669 if (++nsubr >= MAX_SUBR)
1670 {
1671 syserr("554 5.3.0 Too many subroutine calls (%d max)",
1672 MAX_SUBR);
1673 return EX_CONFIG;
1674 }
1675 subrnumber[nsubr] = subr;
1676 subrindex[nsubr] = j;
1677 }
1678 }
1679
1680 /*
1681 ** Perform the actual subroutines calls, "last" one first, i.e.,
1682 ** go from the right to the left through all calls,
1683 ** do the rewriting in place.
1684 */
1685
1686 for (; nsubr > 0; nsubr--)
1687 {
1688 subr = subrnumber[nsubr];
1689 avp = pvp + subrindex[nsubr];
1690
1691 /* remove the subroutine call and name */
1692 for (i = 2; avp[i] != NULL; i++)
1693 avp[i - 2] = avp[i];
1694 avp[i - 2] = NULL;
1695
1696 /*
1697 ** Now we need to call the ruleset specified for
1698 ** the subroutine. We can do this in place since
1699 ** we call the "last" subroutine first.
1700 */
1701
1702 status = rewrite(avp, subr, reclevel, e,
1703 MAXATOM - subrindex[nsubr]);
1704 if (status != EX_OK && status != EX_TEMPFAIL)
1705 return status;
1706 if (rstat == EX_OK || status == EX_TEMPFAIL)
1707 rstat = status;
1708 }
1709 return rstat;
1710 }
1711 /*
1712 ** MAP_LOOKUP -- do lookup in map
1713 **
1714 ** Parameters:
1715 ** smap -- the map to use for the lookup.
1716 ** key -- the key to look up.
1717 ** argvect -- arguments to pass to the map lookup.
1718 ** pstat -- a pointer to an integer in which to store the
1719 ** status from the lookup.
1720 ** e -- the current envelope.
1721 **
1722 ** Returns:
1723 ** The result of the lookup.
1724 ** NULL -- if there was no data for the given key.
1725 */
1726
1727 static char *
1728 map_lookup(smap, key, argvect, pstat, e)
1729 STAB *smap;
1730 char key[];
1731 char **argvect;
1732 int *pstat;
1733 ENVELOPE *e;
1734 {
1735 auto int status = EX_OK;
1736 MAP *map;
1737 char *replac;
1738
1739 if (smap == NULL)
1740 return NULL;
1741
1742 map = &smap->s_map;
1743 DYNOPENMAP(map);
1744
1745 if (e->e_sendmode == SM_DEFER &&
1746 bitset(MF_DEFER, map->map_mflags))
1747 {
1748 /* don't do any map lookups */
1749 if (tTd(60, 1))
1750 sm_dprintf("map_lookup(%s, %s) => DEFERRED\n",
1751 smap->s_name, key);
1752 *pstat = EX_TEMPFAIL;
1753 return NULL;
1754 }
1755
1756 if (!bitset(MF_KEEPQUOTES, map->map_mflags))
1757 stripquotes(key);
1758
1759 if (tTd(60, 1))
1760 {
1761 sm_dprintf("map_lookup(%s, %s", smap->s_name, key);
1762 if (tTd(60, 5))
1763 {
1764 int i;
1765
1766 for (i = 0; argvect[i] != NULL; i++)
1767 sm_dprintf(", %%%d=%s", i, argvect[i]);
1768 }
1769 sm_dprintf(") => ");
1770 }
1771 replac = (*map->map_class->map_lookup)(map, key, argvect, &status);
1772 if (tTd(60, 1))
1773 sm_dprintf("%s (%d)\n",
1774 replac != NULL ? replac : "NOT FOUND",
1775 status);
1776
1777 /* should recover if status == EX_TEMPFAIL */
1778 if (status == EX_TEMPFAIL && !bitset(MF_NODEFER, map->map_mflags))
1779 {
1780 *pstat = EX_TEMPFAIL;
1781 if (tTd(60, 1))
1782 sm_dprintf("map_lookup(%s, %s) tempfail: errno=%d\n",
1783 smap->s_name, key, errno);
1784 if (e->e_message == NULL)
1785 {
1786 char mbuf[320];
1787
1788 (void) sm_snprintf(mbuf, sizeof mbuf,
1789 "%.80s map: lookup (%s): deferred",
1790 smap->s_name,
1791 shortenstring(key, MAXSHORTSTR));
1792 e->e_message = sm_rpool_strdup_x(e->e_rpool, mbuf);
1793 }
1794 }
1795 if (status == EX_TEMPFAIL && map->map_tapp != NULL)
1796 {
1797 size_t i = strlen(key) + strlen(map->map_tapp) + 1;
1798 static char *rwbuf = NULL;
1799 static size_t rwbuflen = 0;
1800
1801 if (i > rwbuflen)
1802 {
1803 if (rwbuf != NULL)
1804 sm_free(rwbuf);
1805 rwbuflen = i;
1806 rwbuf = (char *) sm_pmalloc_x(rwbuflen);
1807 }
1808 (void) sm_strlcpyn(rwbuf, rwbuflen, 2, key, map->map_tapp);
1809 if (tTd(60, 4))
1810 sm_dprintf("map_lookup tempfail: returning \"%s\"\n",
1811 rwbuf);
1812 return rwbuf;
1813 }
1814 return replac;
1815 }
1816 /*
1817 ** INITERRMAILERS -- initialize error and discard mailers
1818 **
1819 ** Parameters:
1820 ** none.
1821 **
1822 ** Returns:
1823 ** none.
1824 **
1825 ** Side Effects:
1826 ** initializes error and discard mailers.
1827 */
1828
1829 static MAILER discardmailer;
1830 static MAILER errormailer;
1831 static char *discardargv[] = { "DISCARD", NULL };
1832 static char *errorargv[] = { "ERROR", NULL };
1833
1834 void
1835 initerrmailers()
1836 {
1837 if (discardmailer.m_name == NULL)
1838 {
1839 /* initialize the discard mailer */
1840 discardmailer.m_name = "*discard*";
1841 discardmailer.m_mailer = "DISCARD";
1842 discardmailer.m_argv = discardargv;
1843 }
1844 if (errormailer.m_name == NULL)
1845 {
1846 /* initialize the bogus mailer */
1847 errormailer.m_name = "*error*";
1848 errormailer.m_mailer = "ERROR";
1849 errormailer.m_argv = errorargv;
1850 }
1851 }
1852 /*
1853 ** BUILDADDR -- build address from token vector.
1854 **
1855 ** Parameters:
1856 ** tv -- token vector.
1857 ** a -- pointer to address descriptor to fill.
1858 ** If NULL, one will be allocated.
1859 ** flags -- info regarding whether this is a sender or
1860 ** a recipient.
1861 ** e -- the current envelope.
1862 **
1863 ** Returns:
1864 ** NULL if there was an error.
1865 ** 'a' otherwise.
1866 **
1867 ** Side Effects:
1868 ** fills in 'a'
1869 */
1870
1871 static struct errcodes
1872 {
1873 char *ec_name; /* name of error code */
1874 int ec_code; /* numeric code */
1875 } ErrorCodes[] =
1876 {
1877 { "usage", EX_USAGE },
1878 { "nouser", EX_NOUSER },
1879 { "nohost", EX_NOHOST },
1880 { "unavailable", EX_UNAVAILABLE },
1881 { "software", EX_SOFTWARE },
1882 { "tempfail", EX_TEMPFAIL },
1883 { "protocol", EX_PROTOCOL },
1884 { "config", EX_CONFIG },
1885 { NULL, EX_UNAVAILABLE }
1886 };
1887
1888 static ADDRESS *
1889 buildaddr(tv, a, flags, e)
1890 register char **tv;
1891 register ADDRESS *a;
1892 int flags;
1893 register ENVELOPE *e;
1894 {
1895 bool tempfail = false;
1896 int maxatom;
1897 struct mailer **mp;
1898 register struct mailer *m;
1899 register char *p;
1900 char *mname;
1901 char **hostp;
1902 char hbuf[MAXNAME + 1];
1903 static char ubuf[MAXNAME + 2];
1904
1905 if (tTd(24, 5))
1906 {
1907 sm_dprintf("buildaddr, flags=%x, tv=", flags);
1908 printav(sm_debug_file(), tv);
1909 }
1910
1911 maxatom = MAXATOM;
1912 if (a == NULL)
1913 a = (ADDRESS *) sm_rpool_malloc_x(e->e_rpool, sizeof *a);
1914 memset((char *) a, '\0', sizeof *a);
1915 hbuf[0] = '\0';
1916
1917 /* set up default error return flags */
1918 a->q_flags |= DefaultNotify;
1919
1920 /* figure out what net/mailer to use */
1921 if (*tv == NULL || (**tv & 0377) != CANONNET)
1922 {
1923 syserr("554 5.3.5 buildaddr: no mailer in parsed address");
1924 badaddr:
1925 /*
1926 ** ExitStat may have been set by an earlier map open
1927 ** failure (to a permanent error (EX_OSERR) in syserr())
1928 ** so we also need to check if this particular $#error
1929 ** return wanted a 4XX failure.
1930 **
1931 ** XXX the real fix is probably to set ExitStat correctly,
1932 ** i.e., to EX_TEMPFAIL if the map open is just a temporary
1933 ** error.
1934 */
1935
1936 if (ExitStat == EX_TEMPFAIL || tempfail)
1937 a->q_state = QS_QUEUEUP;
1938 else
1939 {
1940 a->q_state = QS_BADADDR;
1941 a->q_mailer = &errormailer;
1942 }
1943 return a;
1944 }
1945 mname = *++tv;
1946 --maxatom;
1947
1948 /* extract host and user portions */
1949 if (*++tv != NULL && (**tv & 0377) == CANONHOST)
1950 {
1951 hostp = ++tv;
1952 --maxatom;
1953 }
1954 else
1955 hostp = NULL;
1956 --maxatom;
1957 while (*tv != NULL && (**tv & 0377) != CANONUSER)
1958 {
1959 tv++;
1960 --maxatom;
1961 }
1962 if (*tv == NULL)
1963 {
1964 syserr("554 5.3.5 buildaddr: no user");
1965 goto badaddr;
1966 }
1967 if (tv == hostp)
1968 hostp = NULL;
1969 else if (hostp != NULL)
1970 cataddr(hostp, tv - 1, hbuf, sizeof hbuf, '\0');
1971 cataddr(++tv, NULL, ubuf, sizeof ubuf, ' ');
1972 --maxatom;
1973
1974 /* save away the host name */
1975 if (sm_strcasecmp(mname, "error") == 0)
1976 {
1977 /* Set up triplet for use by -bv */
1978 a->q_mailer = &errormailer;
1979 a->q_user = sm_rpool_strdup_x(e->e_rpool, ubuf);
1980 /* XXX wrong place? */
1981
1982 if (hostp != NULL)
1983 {
1984 register struct errcodes *ep;
1985
1986 a->q_host = sm_rpool_strdup_x(e->e_rpool, hbuf);
1987 if (strchr(hbuf, '.') != NULL)
1988 {
1989 a->q_status = sm_rpool_strdup_x(e->e_rpool,
1990 hbuf);
1991 setstat(dsntoexitstat(hbuf));
1992 }
1993 else if (isascii(hbuf[0]) && isdigit(hbuf[0]))
1994 {
1995 setstat(atoi(hbuf));
1996 }
1997 else
1998 {
1999 for (ep = ErrorCodes; ep->ec_name != NULL; ep++)
2000 if (sm_strcasecmp(ep->ec_name, hbuf) == 0)
2001 break;
2002 setstat(ep->ec_code);
2003 }
2004 }
2005 else
2006 {
2007 a->q_host = NULL;
2008 setstat(EX_UNAVAILABLE);
2009 }
2010 stripquotes(ubuf);
2011 if (ISSMTPCODE(ubuf) && ubuf[3] == ' ')
2012 {
2013 char fmt[16];
2014 int off;
2015
2016 if ((off = isenhsc(ubuf + 4, ' ')) > 0)
2017 {
2018 ubuf[off + 4] = '\0';
2019 off += 5;
2020 }
2021 else
2022 {
2023 off = 4;
2024 ubuf[3] = '\0';
2025 }
2026 (void) sm_strlcpyn(fmt, sizeof fmt, 2, ubuf, " %s");
2027 if (off > 4)
2028 usrerr(fmt, ubuf + off);
2029 else if (isenhsc(hbuf, '\0') > 0)
2030 usrerrenh(hbuf, fmt, ubuf + off);
2031 else
2032 usrerr(fmt, ubuf + off);
2033 /* XXX ubuf[off - 1] = ' '; */
2034 if (ubuf[0] == '4')
2035 tempfail = true;
2036 }
2037 else
2038 {
2039 usrerr("553 5.3.0 %s", ubuf);
2040 }
2041 goto badaddr;
2042 }
2043
2044 for (mp = Mailer; (m = *mp++) != NULL; )
2045 {
2046 if (sm_strcasecmp(m->m_name, mname) == 0)
2047 break;
2048 }
2049 if (m == NULL)
2050 {
2051 syserr("554 5.3.5 buildaddr: unknown mailer %s", mname);
2052 goto badaddr;
2053 }
2054 a->q_mailer = m;
2055
2056 /* figure out what host (if any) */
2057 if (hostp == NULL)
2058 {
2059 if (!bitnset(M_LOCALMAILER, m->m_flags))
2060 {
2061 syserr("554 5.3.5 buildaddr: no host");
2062 goto badaddr;
2063 }
2064 a->q_host = NULL;
2065 }
2066 else
2067 a->q_host = sm_rpool_strdup_x(e->e_rpool, hbuf);
2068
2069 /* figure out the user */
2070 p = ubuf;
2071 if (bitnset(M_CHECKUDB, m->m_flags) && *p == '@')
2072 {
2073 p++;
2074 tv++;
2075 --maxatom;
2076 a->q_flags |= QNOTREMOTE;
2077 }
2078
2079 /* do special mapping for local mailer */
2080 if (*p == '"')
2081 p++;
2082 if (*p == '|' && bitnset(M_CHECKPROG, m->m_flags))
2083 a->q_mailer = m = ProgMailer;
2084 else if (*p == '/' && bitnset(M_CHECKFILE, m->m_flags))
2085 a->q_mailer = m = FileMailer;
2086 else if (*p == ':' && bitnset(M_CHECKINCLUDE, m->m_flags))
2087 {
2088 /* may be :include: */
2089 stripquotes(ubuf);
2090 if (sm_strncasecmp(ubuf, ":include:", 9) == 0)
2091 {
2092 /* if :include:, don't need further rewriting */
2093 a->q_mailer = m = InclMailer;
2094 a->q_user = sm_rpool_strdup_x(e->e_rpool, &ubuf[9]);
2095 return a;
2096 }
2097 }
2098
2099 /* rewrite according recipient mailer rewriting rules */
2100 macdefine(&e->e_macro, A_PERM, 'h', a->q_host);
2101
2102 if (ConfigLevel >= 10 ||
2103 !bitset(RF_SENDERADDR|RF_HEADERADDR, flags))
2104 {
2105 /* sender addresses done later */
2106 (void) rewrite(tv, 2, 0, e, maxatom);
2107 if (m->m_re_rwset > 0)
2108 (void) rewrite(tv, m->m_re_rwset, 0, e, maxatom);
2109 }
2110 (void) rewrite(tv, 4, 0, e, maxatom);
2111
2112 /* save the result for the command line/RCPT argument */
2113 cataddr(tv, NULL, ubuf, sizeof ubuf, '\0');
2114 a->q_user = sm_rpool_strdup_x(e->e_rpool, ubuf);
2115
2116 /*
2117 ** Do mapping to lower case as requested by mailer
2118 */
2119
2120 if (a->q_host != NULL && !bitnset(M_HST_UPPER, m->m_flags))
2121 makelower(a->q_host);
2122 if (!bitnset(M_USR_UPPER, m->m_flags))
2123 makelower(a->q_user);
2124
2125 if (tTd(24, 6))
2126 {
2127 sm_dprintf("buildaddr => ");
2128 printaddr(sm_debug_file(), a, false);
2129 }
2130 return a;
2131 }
2132
2133 /*
2134 ** CATADDR -- concatenate pieces of addresses (putting in <LWSP> subs)
2135 **
2136 ** Parameters:
2137 ** pvp -- parameter vector to rebuild.
2138 ** evp -- last parameter to include. Can be NULL to
2139 ** use entire pvp.
2140 ** buf -- buffer to build the string into.
2141 ** sz -- size of buf.
2142 ** spacesub -- the space separator character; if '\0',
2143 ** use SpaceSub.
2144 **
2145 ** Returns:
2146 ** none.
2147 **
2148 ** Side Effects:
2149 ** Destroys buf.
2150 */
2151
2152 void
2153 cataddr(pvp, evp, buf, sz, spacesub)
2154 char **pvp;
2155 char **evp;
2156 char *buf;
2157 register int sz;
2158 int spacesub;
2159 {
2160 bool oatomtok = false;
2161 bool natomtok = false;
2162 register int i;
2163 register char *p;
2164
2165 if (sz <= 0)
2166 return;
2167
2168 if (spacesub == '\0')
2169 spacesub = SpaceSub;
2170
2171 if (pvp == NULL)
2172 {
2173 *buf = '\0';
2174 return;
2175 }
2176 p = buf;
2177 sz -= 2;
2178 while (*pvp != NULL && sz > 0)
2179 {
2180 natomtok = (TokTypeTab[**pvp & 0xff] == ATM);
2181 if (oatomtok && natomtok)
2182 {
2183 *p++ = spacesub;
2184 if (--sz <= 0)
2185 break;
2186 }
2187 i = sm_strlcpy(p, *pvp, sz);
2188 sz -= i;
2189 if (sz <= 0)
2190 break;
2191 oatomtok = natomtok;
2192 p += i;
2193 if (pvp++ == evp)
2194 break;
2195 }
2196
2197 #if 0
2198 /*
2199 ** Silently truncate long strings: even though this doesn't
2200 ** seem like a good idea it is necessary because header checks
2201 ** send the whole header value to rscheck() and hence rewrite().
2202 ** The latter however sometimes uses a "short" buffer (e.g.,
2203 ** cbuf[MAXNAME + 1]) to call cataddr() which then triggers this
2204 ** error function. One possible fix to the problem is to pass
2205 ** flags to rscheck() and rewrite() to distinguish the various
2206 ** calls and only trigger the error if necessary. For now just
2207 ** undo the change from 8.13.0.
2208 */
2209
2210 if (sz <= 0)
2211 usrerr("cataddr: string too long");
2212 #endif
2213 *p = '\0';
2214 }
2215 /*
2216 ** SAMEADDR -- Determine if two addresses are the same
2217 **
2218 ** This is not just a straight comparison -- if the mailer doesn't
2219 ** care about the host we just ignore it, etc.
2220 **
2221 ** Parameters:
2222 ** a, b -- pointers to the internal forms to compare.
2223 **
2224 ** Returns:
2225 ** true -- they represent the same mailbox.
2226 ** false -- they don't.
2227 **
2228 ** Side Effects:
2229 ** none.
2230 */
2231
2232 bool
2233 sameaddr(a, b)
2234 register ADDRESS *a;
2235 register ADDRESS *b;
2236 {
2237 register ADDRESS *ca, *cb;
2238
2239 /* if they don't have the same mailer, forget it */
2240 if (a->q_mailer != b->q_mailer)
2241 return false;
2242
2243 /* if the user isn't the same, we can drop out */
2244 if (strcmp(a->q_user, b->q_user) != 0)
2245 return false;
2246
2247 /* if we have good uids for both but they differ, these are different */
2248 if (a->q_mailer == ProgMailer)
2249 {
2250 ca = getctladdr(a);
2251 cb = getctladdr(b);
2252 if (ca != NULL && cb != NULL &&
2253 bitset(QGOODUID, ca->q_flags & cb->q_flags) &&
2254 ca->q_uid != cb->q_uid)
2255 return false;
2256 }
2257
2258 /* otherwise compare hosts (but be careful for NULL ptrs) */
2259 if (a->q_host == b->q_host)
2260 {
2261 /* probably both null pointers */
2262 return true;
2263 }
2264 if (a->q_host == NULL || b->q_host == NULL)
2265 {
2266 /* only one is a null pointer */
2267 return false;
2268 }
2269 if (strcmp(a->q_host, b->q_host) != 0)
2270 return false;
2271
2272 return true;
2273 }
2274 /*
2275 ** PRINTADDR -- print address (for debugging)
2276 **
2277 ** Parameters:
2278 ** a -- the address to print
2279 ** follow -- follow the q_next chain.
2280 **
2281 ** Returns:
2282 ** none.
2283 **
2284 ** Side Effects:
2285 ** none.
2286 */
2287
2288 struct qflags
2289 {
2290 char *qf_name;
2291 unsigned long qf_bit;
2292 };
2293
2294 static struct qflags AddressFlags[] =
2295 {
2296 { "QGOODUID", QGOODUID },
2297 { "QPRIMARY", QPRIMARY },
2298 { "QNOTREMOTE", QNOTREMOTE },
2299 { "QSELFREF", QSELFREF },
2300 { "QBOGUSSHELL", QBOGUSSHELL },
2301 { "QUNSAFEADDR", QUNSAFEADDR },
2302 { "QPINGONSUCCESS", QPINGONSUCCESS },
2303 { "QPINGONFAILURE", QPINGONFAILURE },
2304 { "QPINGONDELAY", QPINGONDELAY },
2305 { "QHASNOTIFY", QHASNOTIFY },
2306 { "QRELAYED", QRELAYED },
2307 { "QEXPANDED", QEXPANDED },
2308 { "QDELIVERED", QDELIVERED },
2309 { "QDELAYED", QDELAYED },
2310 { "QTHISPASS", QTHISPASS },
2311 { "QRCPTOK", QRCPTOK },
2312 { NULL, 0 }
2313 };
2314
2315 void
2316 printaddr(fp, a, follow)
2317 SM_FILE_T *fp;
2318 register ADDRESS *a;
2319 bool follow;
2320 {
2321 register MAILER *m;
2322 MAILER pseudomailer;
2323 register struct qflags *qfp;
2324 bool firstone;
2325
2326 if (a == NULL)
2327 {
2328 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "[NULL]\n");
2329 return;
2330 }
2331
2332 while (a != NULL)
2333 {
2334 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%p=", a);
2335 (void) sm_io_flush(fp, SM_TIME_DEFAULT);
2336
2337 /* find the mailer -- carefully */
2338 m = a->q_mailer;
2339 if (m == NULL)
2340 {
2341 m = &pseudomailer;
2342 m->m_mno = -1;
2343 m->m_name = "NULL";
2344 }
2345
2346 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2347 "%s:\n\tmailer %d (%s), host `%s'\n",
2348 a->q_paddr == NULL ? "<null>" : a->q_paddr,
2349 m->m_mno, m->m_name,
2350 a->q_host == NULL ? "<null>" : a->q_host);
2351 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2352 "\tuser `%s', ruser `%s'\n",
2353 a->q_user,
2354 a->q_ruser == NULL ? "<null>" : a->q_ruser);
2355 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "\tstate=");
2356 switch (a->q_state)
2357 {
2358 case QS_OK:
2359 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "OK");
2360 break;
2361
2362 case QS_DONTSEND:
2363 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2364 "DONTSEND");
2365 break;
2366
2367 case QS_BADADDR:
2368 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2369 "BADADDR");
2370 break;
2371
2372 case QS_QUEUEUP:
2373 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2374 "QUEUEUP");
2375 break;
2376
2377 case QS_RETRY:
2378 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "RETRY");
2379 break;
2380
2381 case QS_SENT:
2382 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "SENT");
2383 break;
2384
2385 case QS_VERIFIED:
2386 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2387 "VERIFIED");
2388 break;
2389
2390 case QS_EXPANDED:
2391 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2392 "EXPANDED");
2393 break;
2394
2395 case QS_SENDER:
2396 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2397 "SENDER");
2398 break;
2399
2400 case QS_CLONED:
2401 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2402 "CLONED");
2403 break;
2404
2405 case QS_DISCARDED:
2406 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2407 "DISCARDED");
2408 break;
2409
2410 case QS_REPLACED:
2411 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2412 "REPLACED");
2413 break;
2414
2415 case QS_REMOVED:
2416 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2417 "REMOVED");
2418 break;
2419
2420 case QS_DUPLICATE:
2421 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2422 "DUPLICATE");
2423 break;
2424
2425 case QS_INCLUDED:
2426 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2427 "INCLUDED");
2428 break;
2429
2430 default:
2431 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2432 "%d", a->q_state);
2433 break;
2434 }
2435 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2436 ", next=%p, alias %p, uid %d, gid %d\n",
2437 a->q_next, a->q_alias,
2438 (int) a->q_uid, (int) a->q_gid);
2439 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "\tflags=%lx<",
2440 a->q_flags);
2441 firstone = true;
2442 for (qfp = AddressFlags; qfp->qf_name != NULL; qfp++)
2443 {
2444 if (!bitset(qfp->qf_bit, a->q_flags))
2445 continue;
2446 if (!firstone)
2447 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2448 ",");
2449 firstone = false;
2450 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
2451 qfp->qf_name);
2452 }
2453 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, ">\n");
2454 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2455 "\towner=%s, home=\"%s\", fullname=\"%s\"\n",
2456 a->q_owner == NULL ? "(none)" : a->q_owner,
2457 a->q_home == NULL ? "(none)" : a->q_home,
2458 a->q_fullname == NULL ? "(none)" : a->q_fullname);
2459 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2460 "\torcpt=\"%s\", statmta=%s, status=%s\n",
2461 a->q_orcpt == NULL ? "(none)" : a->q_orcpt,
2462 a->q_statmta == NULL ? "(none)" : a->q_statmta,
2463 a->q_status == NULL ? "(none)" : a->q_status);
2464 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2465 "\tfinalrcpt=\"%s\"\n",
2466 a->q_finalrcpt == NULL ? "(none)" : a->q_finalrcpt);
2467 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2468 "\trstatus=\"%s\"\n",
2469 a->q_rstatus == NULL ? "(none)" : a->q_rstatus);
2470 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
2471 "\tstatdate=%s\n",
2472 a->q_statdate == 0 ? "(none)" : ctime(&a->q_statdate));
2473
2474 if (!follow)
2475 return;
2476 a = a->q_next;
2477 }
2478 }
2479 /*
2480 ** EMPTYADDR -- return true if this address is empty (``<>'')
2481 **
2482 ** Parameters:
2483 ** a -- pointer to the address
2484 **
2485 ** Returns:
2486 ** true -- if this address is "empty" (i.e., no one should
2487 ** ever generate replies to it.
2488 ** false -- if it is a "regular" (read: replyable) address.
2489 */
2490
2491 bool
2492 emptyaddr(a)
2493 register ADDRESS *a;
2494 {
2495 return a->q_paddr == NULL || strcmp(a->q_paddr, "<>") == 0 ||
2496 a->q_user == NULL || strcmp(a->q_user, "<>") == 0;
2497 }
2498 /*
2499 ** REMOTENAME -- return the name relative to the current mailer
2500 **
2501 ** Parameters:
2502 ** name -- the name to translate.
2503 ** m -- the mailer that we want to do rewriting relative to.
2504 ** flags -- fine tune operations.
2505 ** pstat -- pointer to status word.
2506 ** e -- the current envelope.
2507 **
2508 ** Returns:
2509 ** the text string representing this address relative to
2510 ** the receiving mailer.
2511 **
2512 ** Side Effects:
2513 ** none.
2514 **
2515 ** Warnings:
2516 ** The text string returned is tucked away locally;
2517 ** copy it if you intend to save it.
2518 */
2519
2520 char *
2521 remotename(name, m, flags, pstat, e)
2522 char *name;
2523 struct mailer *m;
2524 int flags;
2525 int *pstat;
2526 register ENVELOPE *e;
2527 {
2528 register char **pvp;
2529 char *SM_NONVOLATILE fancy;
2530 char *oldg;
2531 int rwset;
2532 static char buf[MAXNAME + 1];
2533 char lbuf[MAXNAME + 1];
2534 char pvpbuf[PSBUFSIZE];
2535 char addrtype[4];
2536
2537 if (tTd(12, 1))
2538 sm_dprintf("remotename(%s)\n", name);
2539
2540 /* don't do anything if we are tagging it as special */
2541 if (bitset(RF_SENDERADDR, flags))
2542 {
2543 rwset = bitset(RF_HEADERADDR, flags) ? m->m_sh_rwset
2544 : m->m_se_rwset;
2545 addrtype[2] = 's';
2546 }
2547 else
2548 {
2549 rwset = bitset(RF_HEADERADDR, flags) ? m->m_rh_rwset
2550 : m->m_re_rwset;
2551 addrtype[2] = 'r';
2552 }
2553 if (rwset < 0)
2554 return name;
2555 addrtype[1] = ' ';
2556 addrtype[3] = '\0';
2557 addrtype[0] = bitset(RF_HEADERADDR, flags) ? 'h' : 'e';
2558 macdefine(&e->e_macro, A_TEMP, macid("{addr_type}"), addrtype);
2559
2560 /*
2561 ** Do a heuristic crack of this name to extract any comment info.
2562 ** This will leave the name as a comment and a $g macro.
2563 */
2564
2565 if (bitset(RF_CANONICAL, flags) || bitnset(M_NOCOMMENT, m->m_flags))
2566 fancy = "\201g";
2567 else
2568 fancy = crackaddr(name, e);
2569
2570 /*
2571 ** Turn the name into canonical form.
2572 ** Normally this will be RFC 822 style, i.e., "user@domain".
2573 ** If this only resolves to "user", and the "C" flag is
2574 ** specified in the sending mailer, then the sender's
2575 ** domain will be appended.
2576 */
2577
2578 pvp = prescan(name, '\0', pvpbuf, sizeof pvpbuf, NULL, NULL, false);
2579 if (pvp == NULL)
2580 return name;
2581 if (REWRITE(pvp, 3, e) == EX_TEMPFAIL)
2582 *pstat = EX_TEMPFAIL;
2583 if (bitset(RF_ADDDOMAIN, flags) && e->e_fromdomain != NULL)
2584 {
2585 /* append from domain to this address */
2586 register char **pxp = pvp;
2587 int l = MAXATOM; /* size of buffer for pvp */
2588
2589 /* see if there is an "@domain" in the current name */
2590 while (*pxp != NULL && strcmp(*pxp, "@") != 0)
2591 {
2592 pxp++;
2593 --l;
2594 }
2595 if (*pxp == NULL)
2596 {
2597 /* no.... append the "@domain" from the sender */
2598 register char **qxq = e->e_fromdomain;
2599
2600 while ((*pxp++ = *qxq++) != NULL)
2601 {
2602 if (--l <= 0)
2603 {
2604 *--pxp = NULL;
2605 usrerr("553 5.1.0 remotename: too many tokens");
2606 *pstat = EX_UNAVAILABLE;
2607 break;
2608 }
2609 }
2610 if (REWRITE(pvp, 3, e) == EX_TEMPFAIL)
2611 *pstat = EX_TEMPFAIL;
2612 }
2613 }
2614
2615 /*
2616 ** Do more specific rewriting.
2617 ** Rewrite using ruleset 1 or 2 depending on whether this is
2618 ** a sender address or not.
2619 ** Then run it through any receiving-mailer-specific rulesets.
2620 */
2621
2622 if (bitset(RF_SENDERADDR, flags))
2623 {
2624 if (REWRITE(pvp, 1, e) == EX_TEMPFAIL)
2625 *pstat = EX_TEMPFAIL;
2626 }
2627 else
2628 {
2629 if (REWRITE(pvp, 2, e) == EX_TEMPFAIL)
2630 *pstat = EX_TEMPFAIL;
2631 }
2632 if (rwset > 0)
2633 {
2634 if (REWRITE(pvp, rwset, e) == EX_TEMPFAIL)
2635 *pstat = EX_TEMPFAIL;
2636 }
2637
2638 /*
2639 ** Do any final sanitation the address may require.
2640 ** This will normally be used to turn internal forms
2641 ** (e.g., user@host.LOCAL) into external form. This
2642 ** may be used as a default to the above rules.
2643 */
2644
2645 if (REWRITE(pvp, 4, e) == EX_TEMPFAIL)
2646 *pstat = EX_TEMPFAIL;
2647
2648 /*
2649 ** Now restore the comment information we had at the beginning.
2650 */
2651
2652 cataddr(pvp, NULL, lbuf, sizeof lbuf, '\0');
2653 oldg = macget(&e->e_macro, 'g');
2654 macset(&e->e_macro, 'g', lbuf);
2655
2656 SM_TRY
2657 /* need to make sure route-addrs have <angle brackets> */
2658 if (bitset(RF_CANONICAL, flags) && lbuf[0] == '@')
2659 expand("<\201g>", buf, sizeof buf, e);
2660 else
2661 expand(fancy, buf, sizeof buf, e);
2662 SM_FINALLY
2663 macset(&e->e_macro, 'g', oldg);
2664 SM_END_TRY
2665
2666 if (tTd(12, 1))
2667 sm_dprintf("remotename => `%s'\n", buf);
2668 return buf;
2669 }
2670 /*
2671 ** MAPLOCALUSER -- run local username through ruleset 5 for final redirection
2672 **
2673 ** Parameters:
2674 ** a -- the address to map (but just the user name part).
2675 ** sendq -- the sendq in which to install any replacement
2676 ** addresses.
2677 ** aliaslevel -- the alias nesting depth.
2678 ** e -- the envelope.
2679 **
2680 ** Returns:
2681 ** none.
2682 */
2683
2684 #define Q_COPYFLAGS (QPRIMARY|QBOGUSSHELL|QUNSAFEADDR|\
2685 Q_PINGFLAGS|QHASNOTIFY|\
2686 QRELAYED|QEXPANDED|QDELIVERED|QDELAYED|\
2687 QBYTRACE|QBYNDELAY|QBYNRELAY)
2688
2689 void
2690 maplocaluser(a, sendq, aliaslevel, e)
2691 register ADDRESS *a;
2692 ADDRESS **sendq;
2693 int aliaslevel;
2694 ENVELOPE *e;
2695 {
2696 register char **pvp;
2697 register ADDRESS *SM_NONVOLATILE a1 = NULL;
2698 char pvpbuf[PSBUFSIZE];
2699
2700 if (tTd(29, 1))
2701 {
2702 sm_dprintf("maplocaluser: ");
2703 printaddr(sm_debug_file(), a, false);
2704 }
2705 pvp = prescan(a->q_user, '\0', pvpbuf, sizeof pvpbuf, NULL, NULL, false);
2706 if (pvp == NULL)
2707 {
2708 if (tTd(29, 9))
2709 sm_dprintf("maplocaluser: cannot prescan %s\n",
2710 a->q_user);
2711 return;
2712 }
2713
2714 macdefine(&e->e_macro, A_PERM, 'h', a->q_host);
2715 macdefine(&e->e_macro, A_PERM, 'u', a->q_user);
2716 macdefine(&e->e_macro, A_PERM, 'z', a->q_home);
2717
2718 macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), "e r");
2719 if (REWRITE(pvp, 5, e) == EX_TEMPFAIL)
2720 {
2721 if (tTd(29, 9))
2722 sm_dprintf("maplocaluser: rewrite tempfail\n");
2723 a->q_state = QS_QUEUEUP;
2724 a->q_status = "4.4.3";
2725 return;
2726 }
2727 if (pvp[0] == NULL || (pvp[0][0] & 0377) != CANONNET)
2728 {
2729 if (tTd(29, 9))
2730 sm_dprintf("maplocaluser: doesn't resolve\n");
2731 return;
2732 }
2733
2734 SM_TRY
2735 a1 = buildaddr(pvp, NULL, 0, e);
2736 SM_EXCEPT(exc, "E:mta.quickabort")
2737
2738 /*
2739 ** mark address as bad, S5 returned an error
2740 ** and we gave that back to the SMTP client.
2741 */
2742
2743 a->q_state = QS_DONTSEND;
2744 sm_exc_raisenew_x(&EtypeQuickAbort, 2);
2745 SM_END_TRY
2746
2747 /* if non-null, mailer destination specified -- has it changed? */
2748 if (a1 == NULL || sameaddr(a, a1))
2749 {
2750 if (tTd(29, 9))
2751 sm_dprintf("maplocaluser: address unchanged\n");
2752 return;
2753 }
2754
2755 /* make new address take on flags and print attributes of old */
2756 a1->q_flags &= ~Q_COPYFLAGS;
2757 a1->q_flags |= a->q_flags & Q_COPYFLAGS;
2758 a1->q_paddr = sm_rpool_strdup_x(e->e_rpool, a->q_paddr);
2759 a1->q_finalrcpt = a->q_finalrcpt;
2760 a1->q_orcpt = a->q_orcpt;
2761
2762 /* mark old address as dead; insert new address */
2763 a->q_state = QS_REPLACED;
2764 if (tTd(29, 5))
2765 {
2766 sm_dprintf("maplocaluser: QS_REPLACED ");
2767 printaddr(sm_debug_file(), a, false);
2768 }
2769 a1->q_alias = a;
2770 allocaddr(a1, RF_COPYALL, sm_rpool_strdup_x(e->e_rpool, a->q_paddr), e);
2771 (void) recipient(a1, sendq, aliaslevel, e);
2772 }
2773 /*
2774 ** DEQUOTE_INIT -- initialize dequote map
2775 **
2776 ** Parameters:
2777 ** map -- the internal map structure.
2778 ** args -- arguments.
2779 **
2780 ** Returns:
2781 ** true.
2782 */
2783
2784 bool
2785 dequote_init(map, args)
2786 MAP *map;
2787 char *args;
2788 {
2789 register char *p = args;
2790
2791 /* there is no check whether there is really an argument */
2792 map->map_mflags |= MF_KEEPQUOTES;
2793 for (;;)
2794 {
2795 while (isascii(*p) && isspace(*p))
2796 p++;
2797 if (*p != '-')
2798 break;
2799 switch (*++p)
2800 {
2801 case 'a':
2802 map->map_app = ++p;
2803 break;
2804
2805 case 'D':
2806 map->map_mflags |= MF_DEFER;
2807 break;
2808
2809 case 'S':
2810 case 's':
2811 map->map_spacesub = *++p;
2812 break;
2813 }
2814 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
2815 p++;
2816 if (*p != '\0')
2817 *p = '\0';
2818 }
2819 if (map->map_app != NULL)
2820 map->map_app = newstr(map->map_app);
2821
2822 return true;
2823 }
2824 /*
2825 ** DEQUOTE_MAP -- unquote an address
2826 **
2827 ** Parameters:
2828 ** map -- the internal map structure (ignored).
2829 ** name -- the name to dequote.
2830 ** av -- arguments (ignored).
2831 ** statp -- pointer to status out-parameter.
2832 **
2833 ** Returns:
2834 ** NULL -- if there were no quotes, or if the resulting
2835 ** unquoted buffer would not be acceptable to prescan.
2836 ** else -- The dequoted buffer.
2837 */
2838
2839 /* ARGSUSED2 */
2840 char *
2841 dequote_map(map, name, av, statp)
2842 MAP *map;
2843 char *name;
2844 char **av;
2845 int *statp;
2846 {
2847 register char *p;
2848 register char *q;
2849 register char c;
2850 int anglecnt = 0;
2851 int cmntcnt = 0;
2852 int quotecnt = 0;
2853 int spacecnt = 0;
2854 bool quotemode = false;
2855 bool bslashmode = false;
2856 char spacesub = map->map_spacesub;
2857
2858 for (p = q = name; (c = *p++) != '\0'; )
2859 {
2860 if (bslashmode)
2861 {
2862 bslashmode = false;
2863 *q++ = c;
2864 continue;
2865 }
2866
2867 if (c == ' ' && spacesub != '\0')
2868 c = spacesub;
2869
2870 switch (c)
2871 {
2872 case '\\':
2873 bslashmode = true;
2874 break;
2875
2876 case '(':
2877 cmntcnt++;
2878 break;
2879
2880 case ')':
2881 if (cmntcnt-- <= 0)
2882 return NULL;
2883 break;
2884
2885 case ' ':
2886 case '\t':
2887 spacecnt++;
2888 break;
2889 }
2890
2891 if (cmntcnt > 0)
2892 {
2893 *q++ = c;
2894 continue;
2895 }
2896
2897 switch (c)
2898 {
2899 case '"':
2900 quotemode = !quotemode;
2901 quotecnt++;
2902 continue;
2903
2904 case '<':
2905 anglecnt++;
2906 break;
2907
2908 case '>':
2909 if (anglecnt-- <= 0)
2910 return NULL;
2911 break;
2912 }
2913 *q++ = c;
2914 }
2915
2916 if (anglecnt != 0 || cmntcnt != 0 || bslashmode ||
2917 quotemode || quotecnt <= 0 || spacecnt != 0)
2918 return NULL;
2919 *q++ = '\0';
2920 return map_rewrite(map, name, strlen(name), NULL);
2921 }
2922 /*
2923 ** RSCHECK -- check string(s) for validity using rewriting sets
2924 **
2925 ** Parameters:
2926 ** rwset -- the rewriting set to use.
2927 ** p1 -- the first string to check.
2928 ** p2 -- the second string to check -- may be null.
2929 ** e -- the current envelope.
2930 ** flags -- control some behavior, see RSF_ in sendmail.h
2931 ** logl -- logging level.
2932 ** host -- NULL or relay host.
2933 ** logid -- id for sm_syslog.
2934 **
2935 ** Returns:
2936 ** EX_OK -- if the rwset doesn't resolve to $#error
2937 ** else -- the failure status (message printed)
2938 */
2939
2940 int
2941 rscheck(rwset, p1, p2, e, flags, logl, host, logid)
2942 char *rwset;
2943 char *p1;
2944 char *p2;
2945 ENVELOPE *e;
2946 int flags;
2947 int logl;
2948 char *host;
2949 char *logid;
2950 {
2951 char *volatile buf;
2952 int bufsize;
2953 int saveexitstat;
2954 int volatile rstat = EX_OK;
2955 char **pvp;
2956 int rsno;
2957 bool volatile discard = false;
2958 auto ADDRESS a1;
2959 bool saveQuickAbort = QuickAbort;
2960 bool saveSuprErrs = SuprErrs;
2961 bool quarantine = false;
2962 char ubuf[BUFSIZ * 2];
2963 char buf0[MAXLINE];
2964 char pvpbuf[PSBUFSIZE];
2965 extern char MsgBuf[];
2966
2967 if (tTd(48, 2))
2968 sm_dprintf("rscheck(%s, %s, %s)\n", rwset, p1,
2969 p2 == NULL ? "(NULL)" : p2);
2970
2971 rsno = strtorwset(rwset, NULL, ST_FIND);
2972 if (rsno < 0)
2973 return EX_OK;
2974
2975 if (p2 != NULL)
2976 {
2977 bufsize = strlen(p1) + strlen(p2) + 2;
2978 if (bufsize > sizeof buf0)
2979 buf = sm_malloc_x(bufsize);
2980 else
2981 {
2982 buf = buf0;
2983 bufsize = sizeof buf0;
2984 }
2985 (void) sm_snprintf(buf, bufsize, "%s%c%s", p1, CONDELSE, p2);
2986 }
2987 else
2988 {
2989 bufsize = strlen(p1) + 1;
2990 if (bufsize > sizeof buf0)
2991 buf = sm_malloc_x(bufsize);
2992 else
2993 {
2994 buf = buf0;
2995 bufsize = sizeof buf0;
2996 }
2997 (void) sm_strlcpy(buf, p1, bufsize);
2998 }
2999 SM_TRY
3000 {
3001 SuprErrs = true;
3002 QuickAbort = false;
3003 pvp = prescan(buf, '\0', pvpbuf, sizeof pvpbuf, NULL,
3004 bitset(RSF_RMCOMM, flags) ? NULL : TokTypeNoC,
3005 bitset(RSF_RMCOMM, flags) ? false : true);
3006 SuprErrs = saveSuprErrs;
3007 if (pvp == NULL)
3008 {
3009 if (tTd(48, 2))
3010 sm_dprintf("rscheck: cannot prescan input\n");
3011 /*
3012 syserr("rscheck: cannot prescan input: \"%s\"",
3013 shortenstring(buf, MAXSHORTSTR));
3014 rstat = EX_DATAERR;
3015 */
3016 goto finis;
3017 }
3018 if (bitset(RSF_UNSTRUCTURED, flags))
3019 SuprErrs = true;
3020 (void) REWRITE(pvp, rsno, e);
3021 if (bitset(RSF_UNSTRUCTURED, flags))
3022 SuprErrs = saveSuprErrs;
3023 if (pvp[0] == NULL || (pvp[0][0] & 0377) != CANONNET ||
3024 pvp[1] == NULL || (strcmp(pvp[1], "error") != 0 &&
3025 strcmp(pvp[1], "discard") != 0))
3026 {
3027 goto finis;
3028 }
3029
3030 if (strcmp(pvp[1], "discard") == 0)
3031 {
3032 if (tTd(48, 2))
3033 sm_dprintf("rscheck: discard mailer selected\n");
3034 e->e_flags |= EF_DISCARD;
3035 discard = true;
3036 }
3037 else if (strcmp(pvp[1], "error") == 0 &&
3038 pvp[2] != NULL && (pvp[2][0] & 0377) == CANONHOST &&
3039 pvp[3] != NULL && strcmp(pvp[3], "quarantine") == 0)
3040 {
3041 if (pvp[4] == NULL ||
3042 (pvp[4][0] & 0377) != CANONUSER ||
3043 pvp[5] == NULL)
3044 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool,
3045 rwset);
3046 else
3047 {
3048 cataddr(&(pvp[5]), NULL, ubuf,
3049 sizeof ubuf, ' ');
3050 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool,
3051 ubuf);
3052 }
3053 macdefine(&e->e_macro, A_PERM,
3054 macid("{quarantine}"), e->e_quarmsg);
3055 quarantine = true;
3056 }
3057 else
3058 {
3059 int savelogusrerrs = LogUsrErrs;
3060 static bool logged = false;
3061
3062 /* got an error -- process it */
3063 saveexitstat = ExitStat;
3064 LogUsrErrs = false;
3065 (void) buildaddr(pvp, &a1, 0, e);
3066 LogUsrErrs = savelogusrerrs;
3067 rstat = ExitStat;
3068 ExitStat = saveexitstat;
3069 if (!logged)
3070 {
3071 if (bitset(RSF_COUNT, flags))
3072 markstats(e, &a1, STATS_REJECT);
3073 logged = true;
3074 }
3075 }
3076
3077 if (LogLevel > logl)
3078 {
3079 char *relay;
3080 char *p;
3081 char lbuf[MAXLINE];
3082
3083 p = lbuf;
3084 if (p2 != NULL)
3085 {
3086 (void) sm_snprintf(p, SPACELEFT(lbuf, p),
3087 ", arg2=%s",
3088 p2);
3089 p += strlen(p);
3090 }
3091
3092 if (host != NULL)
3093 relay = host;
3094 else
3095 relay = macvalue('_', e);
3096 if (relay != NULL)
3097 {
3098 (void) sm_snprintf(p, SPACELEFT(lbuf, p),
3099 ", relay=%s", relay);
3100 p += strlen(p);
3101 }
3102 *p = '\0';
3103 if (discard)
3104 sm_syslog(LOG_NOTICE, logid,
3105 "ruleset=%s, arg1=%s%s, discard",
3106 rwset, p1, lbuf);
3107 else if (quarantine)
3108 sm_syslog(LOG_NOTICE, logid,
3109 "ruleset=%s, arg1=%s%s, quarantine=%s",
3110 rwset, p1, lbuf, ubuf);
3111 else
3112 sm_syslog(LOG_NOTICE, logid,
3113 "ruleset=%s, arg1=%s%s, reject=%s",
3114 rwset, p1, lbuf, MsgBuf);
3115 }
3116
3117 finis: ;
3118 }
3119 SM_FINALLY
3120 {
3121 /* clean up */
3122 if (buf != buf0)
3123 sm_free(buf);
3124 QuickAbort = saveQuickAbort;
3125 }
3126 SM_END_TRY
3127
3128 setstat(rstat);
3129
3130 /* rulesets don't set errno */
3131 errno = 0;
3132 if (rstat != EX_OK && QuickAbort)
3133 sm_exc_raisenew_x(&EtypeQuickAbort, 2);
3134 return rstat;
3135 }
3136 /*
3137 ** RSCAP -- call rewriting set to return capabilities
3138 **
3139 ** Parameters:
3140 ** rwset -- the rewriting set to use.
3141 ** p1 -- the first string to check.
3142 ** p2 -- the second string to check -- may be null.
3143 ** e -- the current envelope.
3144 ** pvp -- pointer to token vector.
3145 ** pvpbuf -- buffer space.
3146 ** size -- size of buffer space.
3147 **
3148 ** Returns:
3149 ** EX_UNAVAILABLE -- ruleset doesn't exist.
3150 ** EX_DATAERR -- prescan() failed.
3151 ** EX_OK -- rewrite() was successful.
3152 ** else -- return status from rewrite().
3153 */
3154
3155 int
3156 rscap(rwset, p1, p2, e, pvp, pvpbuf, size)
3157 char *rwset;
3158 char *p1;
3159 char *p2;
3160 ENVELOPE *e;
3161 char ***pvp;
3162 char *pvpbuf;
3163 int size;
3164 {
3165 char *volatile buf;
3166 int bufsize;
3167 int volatile rstat = EX_OK;
3168 int rsno;
3169 bool saveQuickAbort = QuickAbort;
3170 bool saveSuprErrs = SuprErrs;
3171 char buf0[MAXLINE];
3172 extern char MsgBuf[];
3173
3174 if (tTd(48, 2))
3175 sm_dprintf("rscap(%s, %s, %s)\n", rwset, p1,
3176 p2 == NULL ? "(NULL)" : p2);
3177
3178 if (pvp != NULL)
3179 *pvp = NULL;
3180 rsno = strtorwset(rwset, NULL, ST_FIND);
3181 if (rsno < 0)
3182 return EX_UNAVAILABLE;
3183
3184 if (p2 != NULL)
3185 {
3186 bufsize = strlen(p1) + strlen(p2) + 2;
3187 if (bufsize > sizeof buf0)
3188 buf = sm_malloc_x(bufsize);
3189 else
3190 {
3191 buf = buf0;
3192 bufsize = sizeof buf0;
3193 }
3194 (void) sm_snprintf(buf, bufsize, "%s%c%s", p1, CONDELSE, p2);
3195 }
3196 else
3197 {
3198 bufsize = strlen(p1) + 1;
3199 if (bufsize > sizeof buf0)
3200 buf = sm_malloc_x(bufsize);
3201 else
3202 {
3203 buf = buf0;
3204 bufsize = sizeof buf0;
3205 }
3206 (void) sm_strlcpy(buf, p1, bufsize);
3207 }
3208 SM_TRY
3209 {
3210 SuprErrs = true;
3211 QuickAbort = false;
3212 *pvp = prescan(buf, '\0', pvpbuf, size, NULL, NULL, false);
3213 if (*pvp != NULL)
3214 rstat = rewrite(*pvp, rsno, 0, e, size);
3215 else
3216 {
3217 if (tTd(48, 2))
3218 sm_dprintf("rscap: cannot prescan input\n");
3219 rstat = EX_DATAERR;
3220 }
3221 }
3222 SM_FINALLY
3223 {
3224 /* clean up */
3225 if (buf != buf0)
3226 sm_free(buf);
3227 SuprErrs = saveSuprErrs;
3228 QuickAbort = saveQuickAbort;
3229
3230 /* prevent information leak, this may contain rewrite error */
3231 MsgBuf[0] = '\0';
3232 }
3233 SM_END_TRY
3234 return rstat;
3235 }
DragonFly BSD