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