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