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