xref: /illumos-gate/usr/src/cmd/sendmail/src/milter.c (revision e9af4bc0)
1 /*
2  * Copyright (c) 1999-2009 Sendmail, Inc. and its suppliers.
3  *	All rights reserved.
4  *
5  * By using this file, you agree to the terms and conditions set
6  * forth in the LICENSE file which can be found at the top level of
7  * the sendmail distribution.
8  *
9  */
10 
11 #include <sendmail.h>
12 
13 SM_RCSID("@(#)$Id: milter.c,v 8.277 2009/11/06 00:57:06 ca Exp $")
14 
15 #if MILTER
16 # include <sm/sendmail.h>
17 # include <libmilter/mfapi.h>
18 # include <libmilter/mfdef.h>
19 
20 # include <errno.h>
21 # include <sm/time.h>
22 # include <sys/uio.h>
23 
24 # if NETINET || NETINET6
25 #  include <arpa/inet.h>
26 #  if MILTER_NO_NAGLE
27 #   include <netinet/tcp.h>
28 #  endif /* MILTER_NO_NAGLE */
29 # endif /* NETINET || NETINET6 */
30 
31 # include <sm/fdset.h>
32 
33 static void	milter_connect_timeout __P((int));
34 static void	milter_error __P((struct milter *, ENVELOPE *));
35 static int	milter_open __P((struct milter *, bool, ENVELOPE *));
36 static void	milter_parse_timeouts __P((char *, struct milter *));
37 static char	*milter_sysread __P((struct milter *, char *, ssize_t, time_t,
38 			ENVELOPE *, const char *));
39 static char	*milter_read __P((struct milter *, char *, ssize_t *, time_t,
40 			ENVELOPE *, const char *));
41 static char	*milter_write __P((struct milter *, int, char *, ssize_t,
42 			time_t, ENVELOPE *, const char *));
43 static char	*milter_send_command __P((struct milter *, int, void *,
44 			ssize_t, ENVELOPE *, char *, const char *));
45 static char	*milter_command __P((int, void *, ssize_t, char **,
46 			ENVELOPE *, char *, const char *, bool));
47 static char	*milter_body __P((struct milter *, ENVELOPE *, char *));
48 static int	milter_reopen_df __P((ENVELOPE *));
49 static int	milter_reset_df __P((ENVELOPE *));
50 static void	milter_quit_filter __P((struct milter *, ENVELOPE *));
51 static void	milter_abort_filter __P((struct milter *, ENVELOPE *));
52 static void	milter_send_macros __P((struct milter *, char **, int,
53 			ENVELOPE *));
54 static int	milter_negotiate __P((struct milter *, ENVELOPE *,
55 			milters_T *));
56 static void	milter_per_connection_check __P((ENVELOPE *));
57 static char	*milter_headers __P((struct milter *, ENVELOPE *, char *));
58 static void	milter_addheader __P((struct milter *, char *, ssize_t,
59 			ENVELOPE *));
60 static void	milter_insheader __P((struct milter *, char *, ssize_t,
61 			ENVELOPE *));
62 static void	milter_changeheader __P((struct milter *, char *, ssize_t,
63 			ENVELOPE *));
64 static void	milter_chgfrom __P((char *, ssize_t, ENVELOPE *));
65 static void	milter_addrcpt __P((char *, ssize_t, ENVELOPE *));
66 static void	milter_addrcpt_par __P((char *, ssize_t, ENVELOPE *));
67 static void	milter_delrcpt __P((char *, ssize_t, ENVELOPE *));
68 static int	milter_replbody __P((char *, ssize_t, bool, ENVELOPE *));
69 static int	milter_set_macros __P((char *, char **, char *, int));
70 
71 
72 /* milter states */
73 # define SMFS_CLOSED		'C'	/* closed for all further actions */
74 # define SMFS_OPEN		'O'	/* connected to remote milter filter */
75 # define SMFS_INMSG		'M'	/* currently servicing a message */
76 # define SMFS_DONE		'D'	/* done with current message */
77 # define SMFS_CLOSABLE		'Q'	/* done with current connection */
78 # define SMFS_ERROR		'E'	/* error state */
79 # define SMFS_READY		'R'	/* ready for action */
80 # define SMFS_SKIP		'S'	/* skip body */
81 
82 static char *MilterConnectMacros[MAXFILTERMACROS + 1];
83 static char *MilterHeloMacros[MAXFILTERMACROS + 1];
84 static char *MilterEnvFromMacros[MAXFILTERMACROS + 1];
85 static char *MilterEnvRcptMacros[MAXFILTERMACROS + 1];
86 static char *MilterDataMacros[MAXFILTERMACROS + 1];
87 static char *MilterEOMMacros[MAXFILTERMACROS + 1];
88 static char *MilterEOHMacros[MAXFILTERMACROS + 1];
89 static size_t MilterMaxDataSize = MILTER_MAX_DATA_SIZE;
90 
91 # define MILTER_CHECK_DONE_MSG() \
92 	if (*state == SMFIR_REPLYCODE || \
93 	    *state == SMFIR_REJECT || \
94 	    *state == SMFIR_DISCARD || \
95 	    *state == SMFIR_TEMPFAIL) \
96 	{ \
97 		/* Abort the filters to let them know we are done with msg */ \
98 		milter_abort(e); \
99 	}
100 
101 # define MILTER_CHECK_ERROR(initial, action) \
102 	if (!initial && tTd(71, 100)) \
103 	{ \
104 		if (e->e_quarmsg == NULL) \
105 		{ \
106 			e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
107 							 "filter failure"); \
108 			macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
109 				  e->e_quarmsg); \
110 		} \
111 	} \
112 	else if (tTd(71, 101)) \
113 	{ \
114 		if (e->e_quarmsg == NULL) \
115 		{ \
116 			e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
117 							 "filter failure"); \
118 			macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
119 				  e->e_quarmsg); \
120 		} \
121 	} \
122 	else if (bitnset(SMF_TEMPFAIL, m->mf_flags)) \
123 		*state = SMFIR_TEMPFAIL; \
124 	else if (bitnset(SMF_TEMPDROP, m->mf_flags)) \
125 		*state = SMFIR_SHUTDOWN; \
126 	else if (bitnset(SMF_REJECT, m->mf_flags)) \
127 		*state = SMFIR_REJECT; \
128 	else \
129 		action;
130 
131 # define MILTER_CHECK_REPLYCODE(default) \
132 	if (response == NULL || \
133 	    strlen(response) + 1 != (size_t) rlen || \
134 	    rlen < 3 || \
135 	    (response[0] != '4' && response[0] != '5') || \
136 	    !isascii(response[1]) || !isdigit(response[1]) || \
137 	    !isascii(response[2]) || !isdigit(response[2])) \
138 	{ \
139 		if (response != NULL) \
140 			sm_free(response); /* XXX */ \
141 		response = newstr(default); \
142 	} \
143 	else \
144 	{ \
145 		char *ptr = response; \
146  \
147 		/* Check for unprotected %'s in the string */ \
148 		while (*ptr != '\0') \
149 		{ \
150 			if (*ptr == '%' && *++ptr != '%') \
151 			{ \
152 				sm_free(response); /* XXX */ \
153 				response = newstr(default); \
154 				break; \
155 			} \
156 			ptr++; \
157 		} \
158 	}
159 
160 # define MILTER_DF_ERROR(msg) \
161 { \
162 	int save_errno = errno; \
163  \
164 	if (tTd(64, 5)) \
165 	{ \
166 		sm_dprintf(msg, dfname, sm_errstring(save_errno)); \
167 		sm_dprintf("\n"); \
168 	} \
169 	if (MilterLogLevel > 0) \
170 		sm_syslog(LOG_ERR, e->e_id, msg, dfname, sm_errstring(save_errno)); \
171 	if (SuperSafe == SAFE_REALLY) \
172 	{ \
173 		if (e->e_dfp != NULL) \
174 		{ \
175 			(void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT); \
176 			e->e_dfp = NULL; \
177 		} \
178 		e->e_flags &= ~EF_HAS_DF; \
179 	} \
180 	errno = save_errno; \
181 }
182 
183 /*
184 **  MILTER_TIMEOUT -- make sure socket is ready in time
185 **
186 **	Parameters:
187 **		routine -- routine name for debug/logging
188 **		secs -- number of seconds in timeout
189 **		write -- waiting to read or write?
190 **		started -- whether this is part of a previous sequence
191 **
192 **	Assumes 'm' is a milter structure for the current socket.
193 */
194 
195 # define MILTER_TIMEOUT(routine, secs, write, started, function) \
196 { \
197 	int ret; \
198 	int save_errno; \
199 	fd_set fds; \
200 	struct timeval tv; \
201  \
202 	if (SM_FD_SETSIZE > 0 && m->mf_sock >= SM_FD_SETSIZE) \
203 	{ \
204 		if (tTd(64, 5)) \
205 			sm_dprintf("milter_%s(%s): socket %d is larger than FD_SETSIZE %d\n", \
206 				   (routine), m->mf_name, m->mf_sock, \
207 				   SM_FD_SETSIZE); \
208 		if (MilterLogLevel > 0) \
209 			sm_syslog(LOG_ERR, e->e_id, \
210 				  "Milter (%s): socket(%s) %d is larger than FD_SETSIZE %d", \
211 				  m->mf_name, (routine), m->mf_sock, \
212 				  SM_FD_SETSIZE); \
213 		milter_error(m, e); \
214 		return NULL; \
215 	} \
216  \
217 	do \
218 	{ \
219 		FD_ZERO(&fds); \
220 		SM_FD_SET(m->mf_sock, &fds); \
221 		tv.tv_sec = (secs); \
222 		tv.tv_usec = 0; \
223 		ret = select(m->mf_sock + 1, \
224 			     (write) ? NULL : &fds, \
225 			     (write) ? &fds : NULL, \
226 			     NULL, &tv); \
227 	} while (ret < 0 && errno == EINTR); \
228  \
229 	switch (ret) \
230 	{ \
231 	  case 0: \
232 		if (tTd(64, 5)) \
233 			sm_dprintf("milter_%s(%s): timeout, where=%s\n", \
234 				(routine), m->mf_name, (function)); \
235 		if (MilterLogLevel > 0) \
236 			sm_syslog(LOG_ERR, e->e_id, \
237 				  "Milter (%s): timeout %s data %s, where=%s", \
238 				  m->mf_name, \
239 				  started ? "during" : "before", \
240 				  (routine), (function)); \
241 		milter_error(m, e); \
242 		return NULL; \
243  \
244 	  case -1: \
245 		save_errno = errno; \
246 		if (tTd(64, 5)) \
247 			sm_dprintf("milter_%s(%s): select: %s\n", (routine), \
248 				   m->mf_name, sm_errstring(save_errno)); \
249 		if (MilterLogLevel > 0) \
250 		{ \
251 			sm_syslog(LOG_ERR, e->e_id, \
252 				  "Milter (%s): select(%s): %s", \
253 				  m->mf_name, (routine), \
254 				  sm_errstring(save_errno)); \
255 		} \
256 		milter_error(m, e); \
257 		return NULL; \
258  \
259 	  default: \
260 		if (SM_FD_ISSET(m->mf_sock, &fds)) \
261 			break; \
262 		if (tTd(64, 5)) \
263 			sm_dprintf("milter_%s(%s): socket not ready\n", \
264 				(routine), m->mf_name); \
265 		if (MilterLogLevel > 0) \
266 		{ \
267 			sm_syslog(LOG_ERR, e->e_id, \
268 				  "Milter (%s): socket(%s) not ready", \
269 				  m->mf_name, (routine)); \
270 		} \
271 		milter_error(m, e); \
272 		return NULL; \
273 	} \
274 }
275 
276 /*
277 **  Low level functions
278 */
279 
280 /*
281 **  MILTER_READ -- read from a remote milter filter
282 **
283 **	Parameters:
284 **		m -- milter to read from.
285 **		cmd -- return param for command read.
286 **		rlen -- return length of response string.
287 **		to -- timeout in seconds.
288 **		e -- current envelope.
289 **
290 **	Returns:
291 **		response string (may be NULL)
292 */
293 
294 static char *
milter_sysread(m,buf,sz,to,e,where)295 milter_sysread(m, buf, sz, to, e, where)
296 	struct milter *m;
297 	char *buf;
298 	ssize_t sz;
299 	time_t to;
300 	ENVELOPE *e;
301 	const char *where;
302 {
303 	time_t readstart = 0;
304 	ssize_t len, curl;
305 	bool started = false;
306 
307 	curl = 0;
308 
309 	if (to > 0)
310 		readstart = curtime();
311 
312 	for (;;)
313 	{
314 		if (to > 0)
315 		{
316 			time_t now;
317 
318 			now = curtime();
319 			if (now - readstart >= to)
320 			{
321 				if (tTd(64, 5))
322 					sm_dprintf("milter_sys_read (%s): timeout %s data read in %s",
323 						  m->mf_name,
324 						  started ? "during" : "before",
325 						  where);
326 				if (MilterLogLevel > 0)
327 					sm_syslog(LOG_ERR, e->e_id,
328 						  "Milter (%s): timeout %s data read in %s",
329 						  m->mf_name,
330 						  started ? "during" : "before",
331 						  where);
332 				milter_error(m, e);
333 				return NULL;
334 			}
335 			to -= now - readstart;
336 			readstart = now;
337 			MILTER_TIMEOUT("read", to, false, started, where);
338 		}
339 
340 		len = read(m->mf_sock, buf + curl, sz - curl);
341 
342 		if (len < 0)
343 		{
344 			int save_errno = errno;
345 
346 			if (tTd(64, 5))
347 				sm_dprintf("milter_sys_read(%s): read returned %ld: %s\n",
348 					m->mf_name, (long) len,
349 					sm_errstring(save_errno));
350 			if (MilterLogLevel > 0)
351 				sm_syslog(LOG_ERR, e->e_id,
352 					  "Milter (%s): read returned %ld: %s",
353 					  m->mf_name, (long) len,
354 					  sm_errstring(save_errno));
355 			milter_error(m, e);
356 			return NULL;
357 		}
358 
359 		started = true;
360 		curl += len;
361 		if (len == 0 || curl >= sz)
362 			break;
363 
364 	}
365 
366 	if (curl != sz)
367 	{
368 		if (tTd(64, 5))
369 			sm_dprintf("milter_sys_read(%s): cmd read returned %ld, expecting %ld\n",
370 				m->mf_name, (long) curl, (long) sz);
371 		if (MilterLogLevel > 0)
372 			sm_syslog(LOG_ERR, e->e_id,
373 				  "milter_sys_read(%s): cmd read returned %ld, expecting %ld",
374 				  m->mf_name, (long) curl, (long) sz);
375 		milter_error(m, e);
376 		return NULL;
377 	}
378 	return buf;
379 }
380 
381 static char *
milter_read(m,cmd,rlen,to,e,where)382 milter_read(m, cmd, rlen, to, e, where)
383 	struct milter *m;
384 	char *cmd;
385 	ssize_t *rlen;
386 	time_t to;
387 	ENVELOPE *e;
388 	const char *where;
389 {
390 	time_t readstart = 0;
391 	ssize_t expl;
392 	mi_int32 i;
393 # if MILTER_NO_NAGLE && defined(TCP_CORK)
394 	int cork = 0;
395 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
396 	char *buf;
397 	char data[MILTER_LEN_BYTES + 1];
398 
399 	if (m->mf_sock < 0)
400 	{
401 		if (MilterLogLevel > 0)
402 			sm_syslog(LOG_ERR, e->e_id,
403 				  "milter_read(%s): socket closed, where=%s",
404 				  m->mf_name, where);
405 		milter_error(m, e);
406 		return NULL;
407 	}
408 
409 	*rlen = 0;
410 	*cmd = '\0';
411 
412 	if (to > 0)
413 		readstart = curtime();
414 
415 # if MILTER_NO_NAGLE && defined(TCP_CORK)
416 	setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
417 		   sizeof(cork));
418 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
419 
420 	if (milter_sysread(m, data, sizeof(data), to, e, where) == NULL)
421 		return NULL;
422 
423 # if MILTER_NO_NAGLE && defined(TCP_CORK)
424 	cork = 1;
425 	setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
426 		   sizeof(cork));
427 # endif /* MILTER_NO_NAGLE && defined(TCP_CORK) */
428 
429 	/* reset timeout */
430 	if (to > 0)
431 	{
432 		time_t now;
433 
434 		now = curtime();
435 		if (now - readstart >= to)
436 		{
437 			if (tTd(64, 5))
438 				sm_dprintf("milter_read(%s): timeout before data read, where=%s\n",
439 					m->mf_name, where);
440 			if (MilterLogLevel > 0)
441 				sm_syslog(LOG_ERR, e->e_id,
442 					  "Milter read(%s): timeout before data read, where=%s",
443 					  m->mf_name, where);
444 			milter_error(m, e);
445 			return NULL;
446 		}
447 		to -= now - readstart;
448 	}
449 
450 	*cmd = data[MILTER_LEN_BYTES];
451 	data[MILTER_LEN_BYTES] = '\0';
452 	(void) memcpy(&i, data, MILTER_LEN_BYTES);
453 	expl = ntohl(i) - 1;
454 
455 	if (tTd(64, 25))
456 		sm_dprintf("milter_read(%s): expecting %ld bytes\n",
457 			m->mf_name, (long) expl);
458 
459 	if (expl < 0)
460 	{
461 		if (tTd(64, 5))
462 			sm_dprintf("milter_read(%s): read size %ld out of range, where=%s\n",
463 				m->mf_name, (long) expl, where);
464 		if (MilterLogLevel > 0)
465 			sm_syslog(LOG_ERR, e->e_id,
466 				  "milter_read(%s): read size %ld out of range, where=%s",
467 				  m->mf_name, (long) expl, where);
468 		milter_error(m, e);
469 		return NULL;
470 	}
471 
472 	if (expl == 0)
473 		return NULL;
474 
475 	buf = (char *) xalloc(expl);
476 
477 	if (milter_sysread(m, buf, expl, to, e, where) == NULL)
478 	{
479 		sm_free(buf); /* XXX */
480 		return NULL;
481 	}
482 
483 	if (tTd(64, 50))
484 		sm_dprintf("milter_read(%s): Returning %*s\n",
485 			m->mf_name, (int) expl, buf);
486 	*rlen = expl;
487 	return buf;
488 }
489 
490 /*
491 **  MILTER_WRITE -- write to a remote milter filter
492 **
493 **	Parameters:
494 **		m -- milter to read from.
495 **		cmd -- command to send.
496 **		buf -- optional command data.
497 **		len -- length of buf.
498 **		to -- timeout in seconds.
499 **		e -- current envelope.
500 **
501 **	Returns:
502 **		buf if successful, NULL otherwise
503 **		Not actually used anywhere but function prototype
504 **			must match milter_read()
505 */
506 
507 static char *
milter_write(m,cmd,buf,len,to,e,where)508 milter_write(m, cmd, buf, len, to, e, where)
509 	struct milter *m;
510 	int cmd;
511 	char *buf;
512 	ssize_t len;
513 	time_t to;
514 	ENVELOPE *e;
515 	const char *where;
516 {
517 	ssize_t sl, i;
518 	int num_vectors;
519 	mi_int32 nl;
520 	char command = (char) cmd;
521 	char data[MILTER_LEN_BYTES + 1];
522 	bool started = false;
523 	struct iovec vector[2];
524 
525 	/*
526 	**  At most two buffers will be written, though
527 	**  only one may actually be used (see num_vectors).
528 	**  The first is the size/command and the second is the command data.
529 	*/
530 
531 	if (len < 0 || len > MilterMaxDataSize)
532 	{
533 		if (tTd(64, 5))
534 		{
535 			sm_dprintf("milter_write(%s): length %ld out of range, cmd=%c\n",
536 				m->mf_name, (long) len, command);
537 			sm_dprintf("milter_write(%s): buf=%s\n",
538 				m->mf_name, str2prt(buf));
539 		}
540 		if (MilterLogLevel > 0)
541 			sm_syslog(LOG_ERR, e->e_id,
542 				  "milter_write(%s): length %ld out of range, cmd=%c",
543 				  m->mf_name, (long) len, command);
544 		milter_error(m, e);
545 		return NULL;
546 	}
547 	if (m->mf_sock < 0)
548 	{
549 		if (MilterLogLevel > 0)
550 			sm_syslog(LOG_ERR, e->e_id,
551 				  "milter_write(%s): socket closed",
552 				  m->mf_name);
553 		milter_error(m, e);
554 		return NULL;
555 	}
556 
557 	if (tTd(64, 20))
558 		sm_dprintf("milter_write(%s): cmd %c, len %ld\n",
559 			   m->mf_name, command, (long) len);
560 
561 	nl = htonl(len + 1);	/* add 1 for the command char */
562 	(void) memcpy(data, (char *) &nl, MILTER_LEN_BYTES);
563 	data[MILTER_LEN_BYTES] = command;
564 	sl = MILTER_LEN_BYTES + 1;
565 
566 	/* set up the vector for the size / command */
567 	vector[0].iov_base = (void *) data;
568 	vector[0].iov_len  = sl;
569 
570 	/*
571 	**  Determine if there is command data.  If so, there will be two
572 	**  vectors.  If not, there will be only one.  The vectors are set
573 	**  up here and 'num_vectors' and 'sl' are set appropriately.
574 	*/
575 
576 	/* NOTE:  len<0 has already been checked for.  Pedantic */
577 	if (len <= 0 || buf == NULL)
578 	{
579 		/* There is no command data -- only a size / command data */
580 		num_vectors = 1;
581 	}
582 	else
583 	{
584 		/*
585 		**  There is both size / command and command data.
586 		**  Set up the vector for the command data.
587 		*/
588 
589 		num_vectors = 2;
590 		sl += len;
591 		vector[1].iov_base = (void *) buf;
592 		vector[1].iov_len  = len;
593 
594 		if (tTd(64, 50))
595 			sm_dprintf("milter_write(%s): Sending %*s\n",
596 				   m->mf_name, (int) len, buf);
597 	}
598 
599 	if (to > 0)
600 		MILTER_TIMEOUT("write", to, true, started, where);
601 
602 	/* write the vector(s) */
603 	i = writev(m->mf_sock, vector, num_vectors);
604 	if (i != sl)
605 	{
606 		int save_errno = errno;
607 
608 		if (tTd(64, 5))
609 			sm_dprintf("milter_write(%s): write(%c) returned %ld, expected %ld: %s\n",
610 				   m->mf_name, command, (long) i, (long) sl,
611 				   sm_errstring(save_errno));
612 		if (MilterLogLevel > 0)
613 			sm_syslog(LOG_ERR, e->e_id,
614 				  "Milter (%s): write(%c) returned %ld, expected %ld: %s",
615 				  m->mf_name, command, (long) i, (long) sl,
616 				  sm_errstring(save_errno));
617 		milter_error(m, e);
618 		return NULL;
619 	}
620 	return buf;
621 }
622 
623 /*
624 **  Utility functions
625 */
626 
627 /*
628 **  MILTER_OPEN -- connect to remote milter filter
629 **
630 **	Parameters:
631 **		m -- milter to connect to.
632 **		parseonly -- parse but don't connect.
633 **		e -- current envelope.
634 **
635 **	Returns:
636 **		connected socket if successful && !parseonly,
637 **		0 upon parse success if parseonly,
638 **		-1 otherwise.
639 */
640 
641 static jmp_buf	MilterConnectTimeout;
642 
643 static int
milter_open(m,parseonly,e)644 milter_open(m, parseonly, e)
645 	struct milter *m;
646 	bool parseonly;
647 	ENVELOPE *e;
648 {
649 	int sock = 0;
650 	SOCKADDR_LEN_T addrlen = 0;
651 	int addrno = 0;
652 	int save_errno;
653 	char *p;
654 	char *colon;
655 	char *at;
656 	struct hostent *hp = NULL;
657 	SOCKADDR addr;
658 
659 	if (m->mf_conn == NULL || m->mf_conn[0] == '\0')
660 	{
661 		if (tTd(64, 5))
662 			sm_dprintf("X%s: empty or missing socket information\n",
663 				   m->mf_name);
664 		if (parseonly)
665 			syserr("X%s: empty or missing socket information",
666 			       m->mf_name);
667 		else if (MilterLogLevel > 0)
668 			sm_syslog(LOG_ERR, e->e_id,
669 				  "Milter (%s): empty or missing socket information",
670 				  m->mf_name);
671 		milter_error(m, e);
672 		return -1;
673 	}
674 
675 	/* protocol:filename or protocol:port@host */
676 	memset(&addr, '\0', sizeof(addr));
677 	p = m->mf_conn;
678 	colon = strchr(p, ':');
679 	if (colon != NULL)
680 	{
681 		*colon = '\0';
682 
683 		if (*p == '\0')
684 		{
685 # if NETUNIX
686 			/* default to AF_UNIX */
687 			addr.sa.sa_family = AF_UNIX;
688 # else /* NETUNIX */
689 #  if NETINET
690 			/* default to AF_INET */
691 			addr.sa.sa_family = AF_INET;
692 #  else /* NETINET */
693 #   if NETINET6
694 			/* default to AF_INET6 */
695 			addr.sa.sa_family = AF_INET6;
696 #   else /* NETINET6 */
697 			/* no protocols available */
698 			if (MilterLogLevel > 0)
699 				sm_syslog(LOG_ERR, e->e_id,
700 					  "Milter (%s): no valid socket protocols available",
701 					  m->mf_name);
702 			milter_error(m, e);
703 			return -1;
704 #   endif /* NETINET6 */
705 #  endif /* NETINET */
706 # endif /* NETUNIX */
707 		}
708 # if NETUNIX
709 		else if (sm_strcasecmp(p, "unix") == 0 ||
710 			 sm_strcasecmp(p, "local") == 0)
711 			addr.sa.sa_family = AF_UNIX;
712 # endif /* NETUNIX */
713 # if NETINET
714 		else if (sm_strcasecmp(p, "inet") == 0)
715 			addr.sa.sa_family = AF_INET;
716 # endif /* NETINET */
717 # if NETINET6
718 		else if (sm_strcasecmp(p, "inet6") == 0)
719 			addr.sa.sa_family = AF_INET6;
720 # endif /* NETINET6 */
721 		else
722 		{
723 # ifdef EPROTONOSUPPORT
724 			errno = EPROTONOSUPPORT;
725 # else /* EPROTONOSUPPORT */
726 			errno = EINVAL;
727 # endif /* EPROTONOSUPPORT */
728 			if (tTd(64, 5))
729 				sm_dprintf("X%s: unknown socket type %s\n",
730 					m->mf_name, p);
731 			if (parseonly)
732 				syserr("X%s: unknown socket type %s",
733 				       m->mf_name, p);
734 			else if (MilterLogLevel > 0)
735 				sm_syslog(LOG_ERR, e->e_id,
736 					  "Milter (%s): unknown socket type %s",
737 					  m->mf_name, p);
738 			milter_error(m, e);
739 			return -1;
740 		}
741 		*colon++ = ':';
742 	}
743 	else
744 	{
745 		/* default to AF_UNIX */
746 		addr.sa.sa_family = AF_UNIX;
747 		colon = p;
748 	}
749 
750 # if NETUNIX
751 	if (addr.sa.sa_family == AF_UNIX)
752 	{
753 		long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK;
754 
755 		at = colon;
756 		if (strlen(colon) >= sizeof(addr.sunix.sun_path))
757 		{
758 			if (tTd(64, 5))
759 				sm_dprintf("X%s: local socket name %s too long\n",
760 					m->mf_name, colon);
761 			errno = EINVAL;
762 			if (parseonly)
763 				syserr("X%s: local socket name %s too long",
764 				       m->mf_name, colon);
765 			else if (MilterLogLevel > 0)
766 				sm_syslog(LOG_ERR, e->e_id,
767 					  "Milter (%s): local socket name %s too long",
768 					  m->mf_name, colon);
769 			milter_error(m, e);
770 			return -1;
771 		}
772 		errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff,
773 				 S_IRUSR|S_IWUSR, NULL);
774 
775 		/* if just parsing .cf file, socket doesn't need to exist */
776 		if (parseonly && errno == ENOENT)
777 		{
778 			if (OpMode == MD_DAEMON ||
779 			    OpMode == MD_FGDAEMON)
780 				(void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
781 						     "WARNING: X%s: local socket name %s missing\n",
782 						     m->mf_name, colon);
783 		}
784 		else if (errno != 0)
785 		{
786 			/* if not safe, don't create */
787 			save_errno = errno;
788 			if (tTd(64, 5))
789 				sm_dprintf("X%s: local socket name %s unsafe\n",
790 					m->mf_name, colon);
791 			errno = save_errno;
792 			if (parseonly)
793 			{
794 				if (OpMode == MD_DAEMON ||
795 				    OpMode == MD_FGDAEMON ||
796 				    OpMode == MD_SMTP)
797 					syserr("X%s: local socket name %s unsafe",
798 					       m->mf_name, colon);
799 			}
800 			else if (MilterLogLevel > 0)
801 				sm_syslog(LOG_ERR, e->e_id,
802 					  "Milter (%s): local socket name %s unsafe",
803 					  m->mf_name, colon);
804 			milter_error(m, e);
805 			return -1;
806 		}
807 
808 		(void) sm_strlcpy(addr.sunix.sun_path, colon,
809 			       sizeof(addr.sunix.sun_path));
810 		addrlen = sizeof(struct sockaddr_un);
811 	}
812 	else
813 # endif /* NETUNIX */
814 # if NETINET || NETINET6
815 	if (false
816 #  if NETINET
817 		 || addr.sa.sa_family == AF_INET
818 #  endif /* NETINET */
819 #  if NETINET6
820 		 || addr.sa.sa_family == AF_INET6
821 #  endif /* NETINET6 */
822 		 )
823 	{
824 		unsigned short port;
825 
826 		/* Parse port@host */
827 		at = strchr(colon, '@');
828 		if (at == NULL)
829 		{
830 			if (tTd(64, 5))
831 				sm_dprintf("X%s: bad address %s (expected port@host)\n",
832 					m->mf_name, colon);
833 			if (parseonly)
834 				syserr("X%s: bad address %s (expected port@host)",
835 				       m->mf_name, colon);
836 			else if (MilterLogLevel > 0)
837 				sm_syslog(LOG_ERR, e->e_id,
838 					  "Milter (%s): bad address %s (expected port@host)",
839 					  m->mf_name, colon);
840 			milter_error(m, e);
841 			return -1;
842 		}
843 		*at = '\0';
844 		if (isascii(*colon) && isdigit(*colon))
845 			port = htons((unsigned short) atoi(colon));
846 		else
847 		{
848 #  ifdef NO_GETSERVBYNAME
849 			if (tTd(64, 5))
850 				sm_dprintf("X%s: invalid port number %s\n",
851 					m->mf_name, colon);
852 			if (parseonly)
853 				syserr("X%s: invalid port number %s",
854 				       m->mf_name, colon);
855 			else if (MilterLogLevel > 0)
856 				sm_syslog(LOG_ERR, e->e_id,
857 					  "Milter (%s): invalid port number %s",
858 					  m->mf_name, colon);
859 			milter_error(m, e);
860 			return -1;
861 #  else /* NO_GETSERVBYNAME */
862 			struct servent *sp;
863 
864 			sp = getservbyname(colon, "tcp");
865 			if (sp == NULL)
866 			{
867 				save_errno = errno;
868 				if (tTd(64, 5))
869 					sm_dprintf("X%s: unknown port name %s\n",
870 						m->mf_name, colon);
871 				errno = save_errno;
872 				if (parseonly)
873 					syserr("X%s: unknown port name %s",
874 					       m->mf_name, colon);
875 				else if (MilterLogLevel > 0)
876 					sm_syslog(LOG_ERR, e->e_id,
877 						  "Milter (%s): unknown port name %s",
878 						  m->mf_name, colon);
879 				milter_error(m, e);
880 				return -1;
881 			}
882 			port = sp->s_port;
883 #  endif /* NO_GETSERVBYNAME */
884 		}
885 		*at++ = '@';
886 		if (*at == '[')
887 		{
888 			char *end;
889 
890 			end = strchr(at, ']');
891 			if (end != NULL)
892 			{
893 				bool found = false;
894 #  if NETINET
895 				unsigned long hid = INADDR_NONE;
896 #  endif /* NETINET */
897 #  if NETINET6
898 				struct sockaddr_in6 hid6;
899 #  endif /* NETINET6 */
900 
901 				*end = '\0';
902 #  if NETINET
903 				if (addr.sa.sa_family == AF_INET &&
904 				    (hid = inet_addr(&at[1])) != INADDR_NONE)
905 				{
906 					addr.sin.sin_addr.s_addr = hid;
907 					addr.sin.sin_port = port;
908 					found = true;
909 				}
910 #  endif /* NETINET */
911 #  if NETINET6
912 				(void) memset(&hid6, '\0', sizeof(hid6));
913 				if (addr.sa.sa_family == AF_INET6 &&
914 				    anynet_pton(AF_INET6, &at[1],
915 						&hid6.sin6_addr) == 1)
916 				{
917 					addr.sin6.sin6_addr = hid6.sin6_addr;
918 					addr.sin6.sin6_port = port;
919 					found = true;
920 				}
921 #  endif /* NETINET6 */
922 				*end = ']';
923 				if (!found)
924 				{
925 					if (tTd(64, 5))
926 						sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
927 							m->mf_name, at);
928 					if (parseonly)
929 						syserr("X%s: Invalid numeric domain spec \"%s\"",
930 						       m->mf_name, at);
931 					else if (MilterLogLevel > 0)
932 						sm_syslog(LOG_ERR, e->e_id,
933 							  "Milter (%s): Invalid numeric domain spec \"%s\"",
934 							  m->mf_name, at);
935 					milter_error(m, e);
936 					return -1;
937 				}
938 			}
939 			else
940 			{
941 				if (tTd(64, 5))
942 					sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
943 						m->mf_name, at);
944 				if (parseonly)
945 					syserr("X%s: Invalid numeric domain spec \"%s\"",
946 					       m->mf_name, at);
947 				else if (MilterLogLevel > 0)
948 					sm_syslog(LOG_ERR, e->e_id,
949 						  "Milter (%s): Invalid numeric domain spec \"%s\"",
950 						  m->mf_name, at);
951 				milter_error(m, e);
952 				return -1;
953 			}
954 		}
955 		else
956 		{
957 			hp = sm_gethostbyname(at, addr.sa.sa_family);
958 			if (hp == NULL)
959 			{
960 				save_errno = errno;
961 				if (tTd(64, 5))
962 					sm_dprintf("X%s: Unknown host name %s\n",
963 						   m->mf_name, at);
964 				errno = save_errno;
965 				if (parseonly)
966 					syserr("X%s: Unknown host name %s",
967 					       m->mf_name, at);
968 				else if (MilterLogLevel > 0)
969 					sm_syslog(LOG_ERR, e->e_id,
970 						  "Milter (%s): Unknown host name %s",
971 						  m->mf_name, at);
972 				milter_error(m, e);
973 				return -1;
974 			}
975 			addr.sa.sa_family = hp->h_addrtype;
976 			switch (hp->h_addrtype)
977 			{
978 #  if NETINET
979 			  case AF_INET:
980 				memmove(&addr.sin.sin_addr,
981 					hp->h_addr, INADDRSZ);
982 				addr.sin.sin_port = port;
983 				addrlen = sizeof(struct sockaddr_in);
984 				addrno = 1;
985 				break;
986 #  endif /* NETINET */
987 
988 #  if NETINET6
989 			  case AF_INET6:
990 				memmove(&addr.sin6.sin6_addr,
991 					hp->h_addr, IN6ADDRSZ);
992 				addr.sin6.sin6_port = port;
993 				addrlen = sizeof(struct sockaddr_in6);
994 				addrno = 1;
995 				break;
996 #  endif /* NETINET6 */
997 
998 			  default:
999 				if (tTd(64, 5))
1000 					sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1001 						   m->mf_name, at,
1002 						   hp->h_addrtype);
1003 				if (parseonly)
1004 					syserr("X%s: Unknown protocol for %s (%d)",
1005 					       m->mf_name, at, hp->h_addrtype);
1006 				else if (MilterLogLevel > 0)
1007 					sm_syslog(LOG_ERR, e->e_id,
1008 						  "Milter (%s): Unknown protocol for %s (%d)",
1009 						  m->mf_name, at,
1010 						  hp->h_addrtype);
1011 				milter_error(m, e);
1012 #  if NETINET6
1013 				freehostent(hp);
1014 #  endif /* NETINET6 */
1015 				return -1;
1016 			}
1017 		}
1018 	}
1019 	else
1020 # endif /* NETINET || NETINET6 */
1021 	{
1022 		if (tTd(64, 5))
1023 			sm_dprintf("X%s: unknown socket protocol\n",
1024 				   m->mf_name);
1025 		if (parseonly)
1026 			syserr("X%s: unknown socket protocol", m->mf_name);
1027 		else if (MilterLogLevel > 0)
1028 			sm_syslog(LOG_ERR, e->e_id,
1029 				  "Milter (%s): unknown socket protocol",
1030 				  m->mf_name);
1031 		milter_error(m, e);
1032 		return -1;
1033 	}
1034 
1035 	/* just parsing through? */
1036 	if (parseonly)
1037 	{
1038 		m->mf_state = SMFS_READY;
1039 # if NETINET6
1040 		if (hp != NULL)
1041 			freehostent(hp);
1042 # endif /* NETINET6 */
1043 		return 0;
1044 	}
1045 
1046 	/* sanity check */
1047 	if (m->mf_state != SMFS_READY &&
1048 	    m->mf_state != SMFS_CLOSED)
1049 	{
1050 		/* shouldn't happen */
1051 		if (tTd(64, 1))
1052 			sm_dprintf("Milter (%s): Trying to open filter in state %c\n",
1053 				   m->mf_name, (char) m->mf_state);
1054 		milter_error(m, e);
1055 # if NETINET6
1056 		if (hp != NULL)
1057 			freehostent(hp);
1058 # endif /* NETINET6 */
1059 		return -1;
1060 	}
1061 
1062 	/* nope, actually connecting */
1063 	for (;;)
1064 	{
1065 		sock = socket(addr.sa.sa_family, SOCK_STREAM, 0);
1066 		if (sock < 0)
1067 		{
1068 			save_errno = errno;
1069 			if (tTd(64, 5))
1070 				sm_dprintf("Milter (%s): error creating socket: %s\n",
1071 					   m->mf_name,
1072 					   sm_errstring(save_errno));
1073 			if (MilterLogLevel > 0)
1074 				sm_syslog(LOG_ERR, e->e_id,
1075 					  "Milter (%s): error creating socket: %s",
1076 					  m->mf_name, sm_errstring(save_errno));
1077 			milter_error(m, e);
1078 # if NETINET6
1079 			if (hp != NULL)
1080 				freehostent(hp);
1081 # endif /* NETINET6 */
1082 			return -1;
1083 		}
1084 
1085 		if (setjmp(MilterConnectTimeout) == 0)
1086 		{
1087 			SM_EVENT *ev = NULL;
1088 			int i;
1089 
1090 			if (m->mf_timeout[SMFTO_CONNECT] > 0)
1091 				ev = sm_setevent(m->mf_timeout[SMFTO_CONNECT],
1092 						 milter_connect_timeout, 0);
1093 
1094 			i = connect(sock, (struct sockaddr *) &addr, addrlen);
1095 			save_errno = errno;
1096 			if (ev != NULL)
1097 				sm_clrevent(ev);
1098 			errno = save_errno;
1099 			if (i >= 0)
1100 				break;
1101 		}
1102 
1103 		/* couldn't connect.... try next address */
1104 		save_errno = errno;
1105 		p = CurHostName;
1106 		CurHostName = at;
1107 		if (tTd(64, 5))
1108 			sm_dprintf("milter_open (%s): open %s failed: %s\n",
1109 				   m->mf_name, at, sm_errstring(save_errno));
1110 		if (MilterLogLevel > 13)
1111 			sm_syslog(LOG_INFO, e->e_id,
1112 				  "Milter (%s): open %s failed: %s",
1113 				  m->mf_name, at, sm_errstring(save_errno));
1114 		CurHostName = p;
1115 		(void) close(sock);
1116 
1117 		/* try next address */
1118 		if (hp != NULL && hp->h_addr_list[addrno] != NULL)
1119 		{
1120 			switch (addr.sa.sa_family)
1121 			{
1122 # if NETINET
1123 			  case AF_INET:
1124 				memmove(&addr.sin.sin_addr,
1125 					hp->h_addr_list[addrno++],
1126 					INADDRSZ);
1127 				break;
1128 # endif /* NETINET */
1129 
1130 # if NETINET6
1131 			  case AF_INET6:
1132 				memmove(&addr.sin6.sin6_addr,
1133 					hp->h_addr_list[addrno++],
1134 					IN6ADDRSZ);
1135 				break;
1136 # endif /* NETINET6 */
1137 
1138 			  default:
1139 				if (tTd(64, 5))
1140 					sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1141 						   m->mf_name, at,
1142 						   hp->h_addrtype);
1143 				if (MilterLogLevel > 0)
1144 					sm_syslog(LOG_ERR, e->e_id,
1145 						  "Milter (%s): Unknown protocol for %s (%d)",
1146 						  m->mf_name, at,
1147 						  hp->h_addrtype);
1148 				milter_error(m, e);
1149 # if NETINET6
1150 				freehostent(hp);
1151 # endif /* NETINET6 */
1152 				return -1;
1153 			}
1154 			continue;
1155 		}
1156 		p = CurHostName;
1157 		CurHostName = at;
1158 		if (tTd(64, 5))
1159 			sm_dprintf("X%s: error connecting to filter: %s\n",
1160 				   m->mf_name, sm_errstring(save_errno));
1161 		if (MilterLogLevel > 0)
1162 			sm_syslog(LOG_ERR, e->e_id,
1163 				  "Milter (%s): error connecting to filter: %s",
1164 				  m->mf_name, sm_errstring(save_errno));
1165 		CurHostName = p;
1166 		milter_error(m, e);
1167 # if NETINET6
1168 		if (hp != NULL)
1169 			freehostent(hp);
1170 # endif /* NETINET6 */
1171 		return -1;
1172 	}
1173 	m->mf_state = SMFS_OPEN;
1174 # if NETINET6
1175 	if (hp != NULL)
1176 	{
1177 		freehostent(hp);
1178 		hp = NULL;
1179 	}
1180 # endif /* NETINET6 */
1181 # if MILTER_NO_NAGLE && !defined(TCP_CORK)
1182 	{
1183 		int nodelay = 1;
1184 
1185 		setsockopt(m->mf_sock, IPPROTO_TCP, TCP_NODELAY,
1186 			   (char *)&nodelay, sizeof(nodelay));
1187 	}
1188 # endif /* MILTER_NO_NAGLE && !defined(TCP_CORK) */
1189 	return sock;
1190 }
1191 
1192 static void
milter_connect_timeout(ignore)1193 milter_connect_timeout(ignore)
1194 	int ignore;
1195 {
1196 	/*
1197 	**  NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
1198 	**	ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1199 	**	DOING.
1200 	*/
1201 
1202 	errno = ETIMEDOUT;
1203 	longjmp(MilterConnectTimeout, 1);
1204 }
1205 
1206 /*
1207 **  MILTER_SETUP -- setup structure for a mail filter
1208 **
1209 **	Parameters:
1210 **		line -- the options line.
1211 **
1212 **	Returns:
1213 **		none
1214 */
1215 
1216 void
milter_setup(line)1217 milter_setup(line)
1218 	char *line;
1219 {
1220 	char fcode;
1221 	char *p;
1222 	struct milter *m;
1223 	STAB *s;
1224 
1225 	/* collect the filter name */
1226 	for (p = line;
1227 	     *p != '\0' && *p != ',' && !(isascii(*p) && isspace(*p));
1228 	     p++)
1229 		continue;
1230 	if (*p != '\0')
1231 		*p++ = '\0';
1232 	if (line[0] == '\0')
1233 	{
1234 		syserr("name required for mail filter");
1235 		return;
1236 	}
1237 	m = (struct milter *) xalloc(sizeof(*m));
1238 	memset((char *) m, '\0', sizeof(*m));
1239 	m->mf_name = newstr(line);
1240 	m->mf_state = SMFS_READY;
1241 	m->mf_sock = -1;
1242 	m->mf_timeout[SMFTO_CONNECT] = (time_t) 300;
1243 	m->mf_timeout[SMFTO_WRITE] = (time_t) 10;
1244 	m->mf_timeout[SMFTO_READ] = (time_t) 10;
1245 	m->mf_timeout[SMFTO_EOM] = (time_t) 300;
1246 #if _FFR_MILTER_CHECK
1247 	m->mf_mta_prot_version = SMFI_PROT_VERSION;
1248 	m->mf_mta_prot_flags = SMFI_CURR_PROT;
1249 	m->mf_mta_actions = SMFI_CURR_ACTS;
1250 #endif /* _FFR_MILTER_CHECK */
1251 
1252 	/* now scan through and assign info from the fields */
1253 	while (*p != '\0')
1254 	{
1255 		char *delimptr;
1256 
1257 		while (*p != '\0' &&
1258 		       (*p == ',' || (isascii(*p) && isspace(*p))))
1259 			p++;
1260 
1261 		/* p now points to field code */
1262 		fcode = *p;
1263 		while (*p != '\0' && *p != '=' && *p != ',')
1264 			p++;
1265 		if (*p++ != '=')
1266 		{
1267 			syserr("X%s: `=' expected", m->mf_name);
1268 			return;
1269 		}
1270 		while (isascii(*p) && isspace(*p))
1271 			p++;
1272 
1273 		/* p now points to the field body */
1274 		p = munchstring(p, &delimptr, ',');
1275 
1276 		/* install the field into the filter struct */
1277 		switch (fcode)
1278 		{
1279 		  case 'S':		/* socket */
1280 			if (p == NULL)
1281 				m->mf_conn = NULL;
1282 			else
1283 				m->mf_conn = newstr(p);
1284 			break;
1285 
1286 		  case 'F':		/* Milter flags configured on MTA */
1287 			for (; *p != '\0'; p++)
1288 			{
1289 				if (!(isascii(*p) && isspace(*p)))
1290 					setbitn(bitidx(*p), m->mf_flags);
1291 			}
1292 			break;
1293 
1294 		  case 'T':		/* timeouts */
1295 			milter_parse_timeouts(p, m);
1296 			break;
1297 
1298 #if _FFR_MILTER_CHECK
1299 		  case 'a':
1300 			m->mf_mta_actions = strtoul(p, NULL, 0);
1301 			break;
1302 		  case 'f':
1303 			m->mf_mta_prot_flags = strtoul(p, NULL, 0);
1304 			break;
1305 		  case 'v':
1306 			m->mf_mta_prot_version = strtoul(p, NULL, 0);
1307 			break;
1308 #endif /* _FFR_MILTER_CHECK */
1309 
1310 		  default:
1311 			syserr("X%s: unknown filter equate %c=",
1312 			       m->mf_name, fcode);
1313 			break;
1314 		}
1315 		p = delimptr;
1316 	}
1317 
1318 	/* early check for errors */
1319 	(void) milter_open(m, true, CurEnv);
1320 
1321 	/* enter the filter into the symbol table */
1322 	s = stab(m->mf_name, ST_MILTER, ST_ENTER);
1323 	if (s->s_milter != NULL)
1324 		syserr("X%s: duplicate filter definition", m->mf_name);
1325 	else
1326 		s->s_milter = m;
1327 }
1328 
1329 /*
1330 **  MILTER_CONFIG -- parse option list into an array and check config
1331 **
1332 **	Called when reading configuration file.
1333 **
1334 **	Parameters:
1335 **		spec -- the filter list.
1336 **		list -- the array to fill in.
1337 **		max -- the maximum number of entries in list.
1338 **
1339 **	Returns:
1340 **		none
1341 */
1342 
1343 void
milter_config(spec,list,max)1344 milter_config(spec, list, max)
1345 	char *spec;
1346 	struct milter **list;
1347 	int max;
1348 {
1349 	int numitems = 0;
1350 	char *p;
1351 
1352 	/* leave one for the NULL signifying the end of the list */
1353 	max--;
1354 
1355 	for (p = spec; p != NULL; )
1356 	{
1357 		STAB *s;
1358 
1359 		while (isascii(*p) && isspace(*p))
1360 			p++;
1361 		if (*p == '\0')
1362 			break;
1363 		spec = p;
1364 
1365 		if (numitems >= max)
1366 		{
1367 			syserr("Too many filters defined, %d max", max);
1368 			if (max > 0)
1369 				list[0] = NULL;
1370 			return;
1371 		}
1372 		p = strpbrk(p, ";,");
1373 		if (p != NULL)
1374 			*p++ = '\0';
1375 
1376 		s = stab(spec, ST_MILTER, ST_FIND);
1377 		if (s == NULL)
1378 		{
1379 			syserr("InputFilter %s not defined", spec);
1380 			ExitStat = EX_CONFIG;
1381 			return;
1382 		}
1383 		list[numitems++] = s->s_milter;
1384 	}
1385 	list[numitems] = NULL;
1386 
1387 	/* if not set, set to LogLevel */
1388 	if (MilterLogLevel == -1)
1389 		MilterLogLevel = LogLevel;
1390 }
1391 
1392 /*
1393 **  MILTER_PARSE_TIMEOUTS -- parse timeout list
1394 **
1395 **	Called when reading configuration file.
1396 **
1397 **	Parameters:
1398 **		spec -- the timeout list.
1399 **		m -- milter to set.
1400 **
1401 **	Returns:
1402 **		none
1403 */
1404 
1405 static void
milter_parse_timeouts(spec,m)1406 milter_parse_timeouts(spec, m)
1407 	char *spec;
1408 	struct milter *m;
1409 {
1410 	char fcode;
1411 	int tcode;
1412 	char *p;
1413 
1414 	p = spec;
1415 
1416 	/* now scan through and assign info from the fields */
1417 	while (*p != '\0')
1418 	{
1419 		char *delimptr;
1420 
1421 		while (*p != '\0' &&
1422 		       (*p == ';' || (isascii(*p) && isspace(*p))))
1423 			p++;
1424 
1425 		/* p now points to field code */
1426 		fcode = *p;
1427 		while (*p != '\0' && *p != ':')
1428 			p++;
1429 		if (*p++ != ':')
1430 		{
1431 			syserr("X%s, T=: `:' expected", m->mf_name);
1432 			return;
1433 		}
1434 		while (isascii(*p) && isspace(*p))
1435 			p++;
1436 
1437 		/* p now points to the field body */
1438 		p = munchstring(p, &delimptr, ';');
1439 		tcode = -1;
1440 
1441 		/* install the field into the filter struct */
1442 		switch (fcode)
1443 		{
1444 		  case 'C':
1445 			tcode = SMFTO_CONNECT;
1446 			break;
1447 
1448 		  case 'S':
1449 			tcode = SMFTO_WRITE;
1450 			break;
1451 
1452 		  case 'R':
1453 			tcode = SMFTO_READ;
1454 			break;
1455 
1456 		  case 'E':
1457 			tcode = SMFTO_EOM;
1458 			break;
1459 
1460 		  default:
1461 			if (tTd(64, 5))
1462 				sm_dprintf("X%s: %c unknown\n",
1463 					   m->mf_name, fcode);
1464 			syserr("X%s: unknown filter timeout %c",
1465 			       m->mf_name, fcode);
1466 			break;
1467 		}
1468 		if (tcode >= 0)
1469 		{
1470 			m->mf_timeout[tcode] = convtime(p, 's');
1471 			if (tTd(64, 5))
1472 				sm_dprintf("X%s: %c=%ld\n",
1473 					   m->mf_name, fcode,
1474 					   (u_long) m->mf_timeout[tcode]);
1475 		}
1476 		p = delimptr;
1477 	}
1478 }
1479 
1480 /*
1481 **  MILTER_SET_MACROS -- set milter macros
1482 **
1483 **	Parameters:
1484 **		name -- name of milter.
1485 **		macros -- where to store macros.
1486 **		val -- the value of the option.
1487 **		nummac -- current number of macros
1488 **
1489 **	Returns:
1490 **		new number of macros
1491 */
1492 
1493 static int
milter_set_macros(name,macros,val,nummac)1494 milter_set_macros(name, macros, val, nummac)
1495 	char *name;
1496 	char **macros;
1497 	char *val;
1498 	int nummac;
1499 {
1500 	char *p;
1501 
1502 	p = newstr(val);
1503 	while (*p != '\0')
1504 	{
1505 		char *macro;
1506 
1507 		/* Skip leading commas, spaces */
1508 		while (*p != '\0' &&
1509 		       (*p == ',' || (isascii(*p) && isspace(*p))))
1510 			p++;
1511 
1512 		if (*p == '\0')
1513 			break;
1514 
1515 		/* Find end of macro */
1516 		macro = p;
1517 		while (*p != '\0' && *p != ',' &&
1518 		       isascii(*p) && !isspace(*p))
1519 			p++;
1520 		if (*p != '\0')
1521 			*p++ = '\0';
1522 
1523 		if (nummac >= MAXFILTERMACROS)
1524 		{
1525 			syserr("milter_set_option: too many macros in Milter.%s (max %d)",
1526 			       name, MAXFILTERMACROS);
1527 			macros[nummac] = NULL;
1528 			return -1;
1529 		}
1530 		macros[nummac++] = macro;
1531 	}
1532 	macros[nummac] = NULL;
1533 	return nummac;
1534 }
1535 
1536 /*
1537 **  MILTER_SET_OPTION -- set an individual milter option
1538 **
1539 **	Parameters:
1540 **		name -- the name of the option.
1541 **		val -- the value of the option.
1542 **		sticky -- if set, don't let other setoptions override
1543 **			this value.
1544 **
1545 **	Returns:
1546 **		none.
1547 */
1548 
1549 /* set if Milter sub-option is stuck */
1550 static BITMAP256	StickyMilterOpt;
1551 
1552 static struct milteropt
1553 {
1554 	char		*mo_name;	/* long name of milter option */
1555 	unsigned char	mo_code;	/* code for option */
1556 } MilterOptTab[] =
1557 {
1558 # define MO_MACROS_CONNECT		SMFIM_CONNECT
1559 	{ "macros.connect",		MO_MACROS_CONNECT		},
1560 # define MO_MACROS_HELO			SMFIM_HELO
1561 	{ "macros.helo",		MO_MACROS_HELO			},
1562 # define MO_MACROS_ENVFROM		SMFIM_ENVFROM
1563 	{ "macros.envfrom",		MO_MACROS_ENVFROM		},
1564 # define MO_MACROS_ENVRCPT		SMFIM_ENVRCPT
1565 	{ "macros.envrcpt",		MO_MACROS_ENVRCPT		},
1566 # define MO_MACROS_DATA			SMFIM_DATA
1567 	{ "macros.data",		MO_MACROS_DATA			},
1568 # define MO_MACROS_EOM			SMFIM_EOM
1569 	{ "macros.eom",			MO_MACROS_EOM			},
1570 # define MO_MACROS_EOH			SMFIM_EOH
1571 	{ "macros.eoh",			MO_MACROS_EOH			},
1572 
1573 # define MO_LOGLEVEL			0x07
1574 	{ "loglevel",			MO_LOGLEVEL			},
1575 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1576 #  define MO_MAXDATASIZE		0x08
1577 	{ "maxdatasize",		MO_MAXDATASIZE			},
1578 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1579 	{ NULL,				(unsigned char)-1		},
1580 };
1581 
1582 void
milter_set_option(name,val,sticky)1583 milter_set_option(name, val, sticky)
1584 	char *name;
1585 	char *val;
1586 	bool sticky;
1587 {
1588 	int nummac, r;
1589 	struct milteropt *mo;
1590 	char **macros = NULL;
1591 
1592 	nummac = 0;
1593 	if (tTd(37, 2) || tTd(64, 5))
1594 		sm_dprintf("milter_set_option(%s = %s)", name, val);
1595 
1596 	if (name == NULL)
1597 	{
1598 		syserr("milter_set_option: invalid Milter option, must specify suboption");
1599 		return;
1600 	}
1601 
1602 	for (mo = MilterOptTab; mo->mo_name != NULL; mo++)
1603 	{
1604 		if (sm_strcasecmp(mo->mo_name, name) == 0)
1605 			break;
1606 	}
1607 
1608 	if (mo->mo_name == NULL)
1609 	{
1610 		syserr("milter_set_option: invalid Milter option %s", name);
1611 		return;
1612 	}
1613 
1614 	/*
1615 	**  See if this option is preset for us.
1616 	*/
1617 
1618 	if (!sticky && bitnset(mo->mo_code, StickyMilterOpt))
1619 	{
1620 		if (tTd(37, 2) || tTd(64,5))
1621 			sm_dprintf(" (ignored)\n");
1622 		return;
1623 	}
1624 
1625 	if (tTd(37, 2) || tTd(64,5))
1626 		sm_dprintf("\n");
1627 
1628 	switch (mo->mo_code)
1629 	{
1630 	  case MO_LOGLEVEL:
1631 		MilterLogLevel = atoi(val);
1632 		break;
1633 
1634 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1635 	  case MO_MAXDATASIZE:
1636 #  if _FFR_MDS_NEGOTIATE
1637 		MilterMaxDataSize = (size_t)atol(val);
1638 		if (MilterMaxDataSize != MILTER_MDS_64K &&
1639 		    MilterMaxDataSize != MILTER_MDS_256K &&
1640 		    MilterMaxDataSize != MILTER_MDS_1M)
1641 		{
1642 			sm_syslog(LOG_WARNING, NOQID,
1643 				"WARNING: Milter.%s=%d, allowed are only %d, %d, and %d",
1644 				name, MilterMaxDataSize,
1645 				MILTER_MDS_64K, MILTER_MDS_256K,
1646 				MILTER_MDS_1M);
1647 			if (MilterMaxDataSize < MILTER_MDS_64K)
1648 				MilterMaxDataSize = MILTER_MDS_64K;
1649 			else if (MilterMaxDataSize < MILTER_MDS_256K)
1650 				MilterMaxDataSize = MILTER_MDS_256K;
1651 			else
1652 				MilterMaxDataSize = MILTER_MDS_1M;
1653 		}
1654 #  endif /* _FFR_MDS_NEGOTIATE */
1655 		break;
1656 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1657 
1658 	  case MO_MACROS_CONNECT:
1659 		if (macros == NULL)
1660 			macros = MilterConnectMacros;
1661 		/* FALLTHROUGH */
1662 
1663 	  case MO_MACROS_HELO:
1664 		if (macros == NULL)
1665 			macros = MilterHeloMacros;
1666 		/* FALLTHROUGH */
1667 
1668 	  case MO_MACROS_ENVFROM:
1669 		if (macros == NULL)
1670 			macros = MilterEnvFromMacros;
1671 		/* FALLTHROUGH */
1672 
1673 	  case MO_MACROS_ENVRCPT:
1674 		if (macros == NULL)
1675 			macros = MilterEnvRcptMacros;
1676 		/* FALLTHROUGH */
1677 
1678 	  case MO_MACROS_EOH:
1679 		if (macros == NULL)
1680 			macros = MilterEOHMacros;
1681 		/* FALLTHROUGH */
1682 
1683 	  case MO_MACROS_EOM:
1684 		if (macros == NULL)
1685 			macros = MilterEOMMacros;
1686 		/* FALLTHROUGH */
1687 
1688 	  case MO_MACROS_DATA:
1689 		if (macros == NULL)
1690 			macros = MilterDataMacros;
1691 
1692 		r = milter_set_macros(name, macros, val, nummac);
1693 		if (r >= 0)
1694 			nummac = r;
1695 		break;
1696 
1697 	  default:
1698 		syserr("milter_set_option: invalid Milter option %s", name);
1699 		break;
1700 	}
1701 	if (sticky)
1702 		setbitn(mo->mo_code, StickyMilterOpt);
1703 }
1704 
1705 /*
1706 **  MILTER_REOPEN_DF -- open & truncate the data file (for replbody)
1707 **
1708 **	Parameters:
1709 **		e -- current envelope.
1710 **
1711 **	Returns:
1712 **		0 if succesful, -1 otherwise
1713 */
1714 
1715 static int
milter_reopen_df(e)1716 milter_reopen_df(e)
1717 	ENVELOPE *e;
1718 {
1719 	char dfname[MAXPATHLEN];
1720 
1721 	(void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1722 
1723 	/*
1724 	**  In SuperSafe == SAFE_REALLY mode, e->e_dfp is a read-only FP so
1725 	**  close and reopen writable (later close and reopen
1726 	**  read only again).
1727 	**
1728 	**  In SuperSafe != SAFE_REALLY mode, e->e_dfp still points at the
1729 	**  buffered file I/O descriptor, still open for writing so there
1730 	**  isn't any work to do here (except checking for consistency).
1731 	*/
1732 
1733 	if (SuperSafe == SAFE_REALLY)
1734 	{
1735 		/* close read-only data file */
1736 		if (bitset(EF_HAS_DF, e->e_flags) && e->e_dfp != NULL)
1737 		{
1738 			(void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1739 			e->e_flags &= ~EF_HAS_DF;
1740 		}
1741 
1742 		/* open writable */
1743 		if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1744 					   SM_IO_RDWR_B, NULL)) == NULL)
1745 		{
1746 			MILTER_DF_ERROR("milter_reopen_df: sm_io_open %s: %s");
1747 			return -1;
1748 		}
1749 	}
1750 	else if (e->e_dfp == NULL)
1751 	{
1752 		/* shouldn't happen */
1753 		errno = ENOENT;
1754 		MILTER_DF_ERROR("milter_reopen_df: NULL e_dfp (%s: %s)");
1755 		return -1;
1756 	}
1757 	return 0;
1758 }
1759 
1760 /*
1761 **  MILTER_RESET_DF -- re-open read-only the data file (for replbody)
1762 **
1763 **	Parameters:
1764 **		e -- current envelope.
1765 **
1766 **	Returns:
1767 **		0 if succesful, -1 otherwise
1768 */
1769 
1770 static int
milter_reset_df(e)1771 milter_reset_df(e)
1772 	ENVELOPE *e;
1773 {
1774 	int afd;
1775 	char dfname[MAXPATHLEN];
1776 
1777 	(void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1778 
1779 	if (sm_io_flush(e->e_dfp, SM_TIME_DEFAULT) != 0 ||
1780 	    sm_io_error(e->e_dfp))
1781 	{
1782 		MILTER_DF_ERROR("milter_reset_df: error writing/flushing %s: %s");
1783 		return -1;
1784 	}
1785 	else if (SuperSafe != SAFE_REALLY)
1786 	{
1787 		/* skip next few clauses */
1788 		/* EMPTY */
1789 	}
1790 	else if ((afd = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL)) >= 0
1791 		 && fsync(afd) < 0)
1792 	{
1793 		MILTER_DF_ERROR("milter_reset_df: error sync'ing %s: %s");
1794 		return -1;
1795 	}
1796 	else if (sm_io_close(e->e_dfp, SM_TIME_DEFAULT) < 0)
1797 	{
1798 		MILTER_DF_ERROR("milter_reset_df: error closing %s: %s");
1799 		return -1;
1800 	}
1801 	else if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1802 					SM_IO_RDONLY_B, NULL)) == NULL)
1803 	{
1804 		MILTER_DF_ERROR("milter_reset_df: error reopening %s: %s");
1805 		return -1;
1806 	}
1807 	else
1808 		e->e_flags |= EF_HAS_DF;
1809 	return 0;
1810 }
1811 
1812 /*
1813 **  MILTER_QUIT_FILTER -- close down a single filter
1814 **
1815 **	Parameters:
1816 **		m -- milter structure of filter to close down.
1817 **		e -- current envelope.
1818 **
1819 **	Returns:
1820 **		none
1821 */
1822 
1823 static void
milter_quit_filter(m,e)1824 milter_quit_filter(m, e)
1825 	struct milter *m;
1826 	ENVELOPE *e;
1827 {
1828 	if (tTd(64, 10))
1829 		sm_dprintf("milter_quit_filter(%s)\n", m->mf_name);
1830 	if (MilterLogLevel > 18)
1831 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): quit filter",
1832 			  m->mf_name);
1833 
1834 	/* Never replace error state */
1835 	if (m->mf_state == SMFS_ERROR)
1836 		return;
1837 
1838 	if (m->mf_sock < 0 ||
1839 	    m->mf_state == SMFS_CLOSED ||
1840 	    m->mf_state == SMFS_READY)
1841 	{
1842 		m->mf_sock = -1;
1843 		m->mf_state = SMFS_CLOSED;
1844 		return;
1845 	}
1846 
1847 	(void) milter_write(m, SMFIC_QUIT, (char *) NULL, 0,
1848 			    m->mf_timeout[SMFTO_WRITE], e, "quit_filter");
1849 	if (m->mf_sock >= 0)
1850 	{
1851 		(void) close(m->mf_sock);
1852 		m->mf_sock = -1;
1853 	}
1854 	if (m->mf_state != SMFS_ERROR)
1855 		m->mf_state = SMFS_CLOSED;
1856 }
1857 
1858 /*
1859 **  MILTER_ABORT_FILTER -- tell filter to abort current message
1860 **
1861 **	Parameters:
1862 **		m -- milter structure of filter to abort.
1863 **		e -- current envelope.
1864 **
1865 **	Returns:
1866 **		none
1867 */
1868 
1869 static void
milter_abort_filter(m,e)1870 milter_abort_filter(m, e)
1871 	struct milter *m;
1872 	ENVELOPE *e;
1873 {
1874 	if (tTd(64, 10))
1875 		sm_dprintf("milter_abort_filter(%s)\n", m->mf_name);
1876 	if (MilterLogLevel > 10)
1877 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): abort filter",
1878 			  m->mf_name);
1879 
1880 	if (m->mf_sock < 0 ||
1881 	    m->mf_state != SMFS_INMSG)
1882 		return;
1883 
1884 	(void) milter_write(m, SMFIC_ABORT, (char *) NULL, 0,
1885 			    m->mf_timeout[SMFTO_WRITE], e, "abort_filter");
1886 	if (m->mf_state != SMFS_ERROR)
1887 		m->mf_state = SMFS_DONE;
1888 }
1889 
1890 /*
1891 **  MILTER_SEND_MACROS -- provide macros to the filters
1892 **
1893 **	Parameters:
1894 **		m -- milter to send macros to.
1895 **		macros -- macros to send for filter smfi_getsymval().
1896 **		cmd -- which command the macros are associated with.
1897 **		e -- current envelope (for macro access).
1898 **
1899 **	Returns:
1900 **		none
1901 */
1902 
1903 static void
milter_send_macros(m,macros,cmd,e)1904 milter_send_macros(m, macros, cmd, e)
1905 	struct milter *m;
1906 	char **macros;
1907 	int cmd;
1908 	ENVELOPE *e;
1909 {
1910 	int i;
1911 	int mid;
1912 	char command = (char) cmd;
1913 	char *v;
1914 	char *buf, *bp;
1915 	char exp[MAXLINE];
1916 	ssize_t s;
1917 
1918 	/* sanity check */
1919 	if (macros == NULL || macros[0] == NULL)
1920 		return;
1921 
1922 	/* put together data */
1923 	s = 1;			/* for the command character */
1924 	for (i = 0; macros[i] != NULL; i++)
1925 	{
1926 		mid = macid(macros[i]);
1927 		if (mid == 0)
1928 			continue;
1929 		v = macvalue(mid, e);
1930 		if (v == NULL)
1931 			continue;
1932 		expand(v, exp, sizeof(exp), e);
1933 		s += strlen(macros[i]) + 1 + strlen(exp) + 1;
1934 	}
1935 
1936 	if (s < 0)
1937 		return;
1938 
1939 	buf = (char *) xalloc(s);
1940 	bp = buf;
1941 	*bp++ = command;
1942 	for (i = 0; macros[i] != NULL; i++)
1943 	{
1944 		mid = macid(macros[i]);
1945 		if (mid == 0)
1946 			continue;
1947 		v = macvalue(mid, e);
1948 		if (v == NULL)
1949 			continue;
1950 		expand(v, exp, sizeof(exp), e);
1951 
1952 		if (tTd(64, 10))
1953 			sm_dprintf("milter_send_macros(%s, %c): %s=%s\n",
1954 				m->mf_name, command, macros[i], exp);
1955 
1956 		(void) sm_strlcpy(bp, macros[i], s - (bp - buf));
1957 		bp += strlen(bp) + 1;
1958 		(void) sm_strlcpy(bp, exp, s - (bp - buf));
1959 		bp += strlen(bp) + 1;
1960 	}
1961 	(void) milter_write(m, SMFIC_MACRO, buf, s,
1962 			    m->mf_timeout[SMFTO_WRITE], e, "send_macros");
1963 	sm_free(buf);
1964 }
1965 
1966 /*
1967 **  MILTER_SEND_COMMAND -- send a command and return the response for a filter
1968 **
1969 **	Parameters:
1970 **		m -- current milter filter
1971 **		cmd -- command to send.
1972 **		data -- optional command data.
1973 **		sz -- length of buf.
1974 **		e -- current envelope (for e->e_id).
1975 **		state -- return state word.
1976 **
1977 **	Returns:
1978 **		response string (may be NULL)
1979 */
1980 
1981 static char *
milter_send_command(m,cmd,data,sz,e,state,where)1982 milter_send_command(m, cmd, data, sz, e, state, where)
1983 	struct milter *m;
1984 	int cmd;
1985 	void *data;
1986 	ssize_t sz;
1987 	ENVELOPE *e;
1988 	char *state;
1989 	const char *where;
1990 {
1991 	char rcmd;
1992 	ssize_t rlen;
1993 	unsigned long skipflag;
1994 	unsigned long norespflag = 0;
1995 	char command = (char) cmd;
1996 	char *action;
1997 	char *defresponse;
1998 	char *response;
1999 
2000 	if (tTd(64, 10))
2001 		sm_dprintf("milter_send_command(%s): cmd %c len %ld\n",
2002 			m->mf_name, (char) command, (long) sz);
2003 
2004 	/* find skip flag and default failure */
2005 	switch (command)
2006 	{
2007 	  case SMFIC_CONNECT:
2008 		skipflag = SMFIP_NOCONNECT;
2009 		norespflag = SMFIP_NR_CONN;
2010 		action = "connect";
2011 		defresponse = "554 Command rejected";
2012 		break;
2013 
2014 	  case SMFIC_HELO:
2015 		skipflag = SMFIP_NOHELO;
2016 		norespflag = SMFIP_NR_HELO;
2017 		action = "helo";
2018 		defresponse = "550 Command rejected";
2019 		break;
2020 
2021 	  case SMFIC_MAIL:
2022 		skipflag = SMFIP_NOMAIL;
2023 		norespflag = SMFIP_NR_MAIL;
2024 		action = "mail";
2025 		defresponse = "550 5.7.1 Command rejected";
2026 		break;
2027 
2028 	  case SMFIC_RCPT:
2029 		skipflag = SMFIP_NORCPT;
2030 		norespflag = SMFIP_NR_RCPT;
2031 		action = "rcpt";
2032 		defresponse = "550 5.7.1 Command rejected";
2033 		break;
2034 
2035 	  case SMFIC_HEADER:
2036 		skipflag = SMFIP_NOHDRS;
2037 		norespflag = SMFIP_NR_HDR;
2038 		action = "header";
2039 		defresponse = "550 5.7.1 Command rejected";
2040 		break;
2041 
2042 	  case SMFIC_BODY:
2043 		skipflag = SMFIP_NOBODY;
2044 		norespflag = SMFIP_NR_BODY;
2045 		action = "body";
2046 		defresponse = "554 5.7.1 Command rejected";
2047 		break;
2048 
2049 	  case SMFIC_EOH:
2050 		skipflag = SMFIP_NOEOH;
2051 		norespflag = SMFIP_NR_EOH;
2052 		action = "eoh";
2053 		defresponse = "550 5.7.1 Command rejected";
2054 		break;
2055 
2056 	  case SMFIC_UNKNOWN:
2057 		skipflag = SMFIP_NOUNKNOWN;
2058 		norespflag = SMFIP_NR_UNKN;
2059 		action = "unknown";
2060 		defresponse = "550 5.7.1 Command rejected";
2061 		break;
2062 
2063 	  case SMFIC_DATA:
2064 		skipflag = SMFIP_NODATA;
2065 		norespflag = SMFIP_NR_DATA;
2066 		action = "data";
2067 		defresponse = "550 5.7.1 Command rejected";
2068 		break;
2069 
2070 	  case SMFIC_BODYEOB:
2071 	  case SMFIC_OPTNEG:
2072 	  case SMFIC_MACRO:
2073 	  case SMFIC_ABORT:
2074 	  case SMFIC_QUIT:
2075 		/* NOTE: not handled by milter_send_command() */
2076 		/* FALLTHROUGH */
2077 
2078 	  default:
2079 		skipflag = 0;
2080 		action = "default";
2081 		defresponse = "550 5.7.1 Command rejected";
2082 		break;
2083 	}
2084 
2085 	if (tTd(64, 10))
2086 		sm_dprintf("milter_send_command(%s): skip=%lx, pflags=%x\n",
2087 			m->mf_name, skipflag, m->mf_pflags);
2088 
2089 	/* check if filter wants this command */
2090 	if (skipflag != 0 && bitset(skipflag, m->mf_pflags))
2091 		return NULL;
2092 
2093 	/* send the command to the filter */
2094 	(void) milter_write(m, command, data, sz,
2095 			    m->mf_timeout[SMFTO_WRITE], e, where);
2096 	if (m->mf_state == SMFS_ERROR)
2097 	{
2098 		MILTER_CHECK_ERROR(false, return NULL);
2099 		return NULL;
2100 	}
2101 
2102 	/* check if filter sends response to this command */
2103 	if (norespflag != 0 && bitset(norespflag, m->mf_pflags))
2104 		return NULL;
2105 
2106 	/* get the response from the filter */
2107 	response = milter_read(m, &rcmd, &rlen,
2108 			       m->mf_timeout[SMFTO_READ], e, where);
2109 	if (m->mf_state == SMFS_ERROR)
2110 	{
2111 		MILTER_CHECK_ERROR(false, return NULL);
2112 		return NULL;
2113 	}
2114 
2115 	if (tTd(64, 10))
2116 		sm_dprintf("milter_send_command(%s): returned %c\n",
2117 			   m->mf_name, (char) rcmd);
2118 
2119 	switch (rcmd)
2120 	{
2121 	  case SMFIR_REPLYCODE:
2122 		MILTER_CHECK_REPLYCODE(defresponse);
2123 		if (MilterLogLevel > 10)
2124 			sm_syslog(LOG_INFO, e->e_id,
2125 				  "milter=%s, action=%s, reject=%s",
2126 				  m->mf_name, action, response);
2127 		*state = rcmd;
2128 		break;
2129 
2130 	  case SMFIR_REJECT:
2131 		if (MilterLogLevel > 10)
2132 			sm_syslog(LOG_INFO, e->e_id,
2133 				  "milter=%s, action=%s, reject",
2134 				  m->mf_name, action);
2135 		*state = rcmd;
2136 		break;
2137 
2138 	  case SMFIR_DISCARD:
2139 		if (MilterLogLevel > 10)
2140 			sm_syslog(LOG_INFO, e->e_id,
2141 				  "milter=%s, action=%s, discard",
2142 				  m->mf_name, action);
2143 		*state = rcmd;
2144 		break;
2145 
2146 	  case SMFIR_TEMPFAIL:
2147 		if (MilterLogLevel > 10)
2148 			sm_syslog(LOG_INFO, e->e_id,
2149 				  "milter=%s, action=%s, tempfail",
2150 				  m->mf_name, action);
2151 		*state = rcmd;
2152 		break;
2153 
2154 	  case SMFIR_ACCEPT:
2155 		/* this filter is done with message/connection */
2156 		if (command == SMFIC_HELO ||
2157 		    command == SMFIC_CONNECT)
2158 			m->mf_state = SMFS_CLOSABLE;
2159 		else
2160 			m->mf_state = SMFS_DONE;
2161 		if (MilterLogLevel > 10)
2162 			sm_syslog(LOG_INFO, e->e_id,
2163 				  "milter=%s, action=%s, accepted",
2164 				  m->mf_name, action);
2165 		break;
2166 
2167 	  case SMFIR_CONTINUE:
2168 		/* if MAIL command is ok, filter is in message state */
2169 		if (command == SMFIC_MAIL)
2170 			m->mf_state = SMFS_INMSG;
2171 		if (MilterLogLevel > 12)
2172 			sm_syslog(LOG_INFO, e->e_id,
2173 				  "milter=%s, action=%s, continue",
2174 				  m->mf_name, action);
2175 		break;
2176 
2177 	  case SMFIR_SKIP:
2178 		if (MilterLogLevel > 12)
2179 			sm_syslog(LOG_INFO, e->e_id,
2180 				  "milter=%s, action=%s, skip",
2181 				  m->mf_name, action);
2182 		m->mf_state = SMFS_SKIP;
2183 		break;
2184 
2185 	  default:
2186 		/* Invalid response to command */
2187 		if (MilterLogLevel > 0)
2188 			sm_syslog(LOG_ERR, e->e_id,
2189 				  "milter_send_command(%s): action=%s returned bogus response %c",
2190 				  m->mf_name, action, rcmd);
2191 		milter_error(m, e);
2192 		break;
2193 	}
2194 
2195 	if (*state != SMFIR_REPLYCODE && response != NULL)
2196 	{
2197 		sm_free(response); /* XXX */
2198 		response = NULL;
2199 	}
2200 	return response;
2201 }
2202 
2203 /*
2204 **  MILTER_COMMAND -- send a command and return the response for each filter
2205 **
2206 **	Parameters:
2207 **		cmd -- command to send.
2208 **		data -- optional command data.
2209 **		sz -- length of buf.
2210 **		macros -- macros to send for filter smfi_getsymval().
2211 **		e -- current envelope (for macro access).
2212 **		state -- return state word.
2213 **		where -- description of calling function (logging).
2214 **		cmd_error -- did the SMTP command cause an error?
2215 **
2216 **	Returns:
2217 **		response string (may be NULL)
2218 */
2219 
2220 static char *
milter_command(cmd,data,sz,macros,e,state,where,cmd_error)2221 milter_command(cmd, data, sz, macros, e, state, where, cmd_error)
2222 	int cmd;
2223 	void *data;
2224 	ssize_t sz;
2225 	char **macros;
2226 	ENVELOPE *e;
2227 	char *state;
2228 	const char *where;
2229 	bool cmd_error;
2230 {
2231 	int i;
2232 	char command = (char) cmd;
2233 	char *response = NULL;
2234 	time_t tn = 0;
2235 
2236 	if (tTd(64, 10))
2237 		sm_dprintf("milter_command: cmd %c len %ld\n",
2238 			command, (long) sz);
2239 
2240 	*state = SMFIR_CONTINUE;
2241 	for (i = 0; InputFilters[i] != NULL; i++)
2242 	{
2243 		struct milter *m = InputFilters[i];
2244 
2245 		/* previous problem? */
2246 		if (m->mf_state == SMFS_ERROR)
2247 		{
2248 			MILTER_CHECK_ERROR(false, continue);
2249 			break;
2250 		}
2251 
2252 		/* sanity check */
2253 		if (m->mf_sock < 0 ||
2254 		    (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
2255 			continue;
2256 
2257 		/* send macros (regardless of whether we send command) */
2258 		if (macros != NULL && macros[0] != NULL)
2259 		{
2260 			milter_send_macros(m, macros, command, e);
2261 			if (m->mf_state == SMFS_ERROR)
2262 			{
2263 				MILTER_CHECK_ERROR(false, continue);
2264 				break;
2265 			}
2266 		}
2267 
2268 		if (MilterLogLevel > 21)
2269 			tn = curtime();
2270 
2271 		/*
2272 		**  send the command if
2273 		**	there is no error
2274 		**	or it's RCPT and the client asked for it:
2275 		**	!cmd_error ||
2276 		**	where == "rcpt" && m->mf_pflags & SMFIP_RCPT_REJ != 0
2277 		**  negate that condition and use continue
2278 		*/
2279 
2280 		if (cmd_error &&
2281 		    (strcmp(where, "rcpt") != 0 ||
2282 		     (m->mf_pflags & SMFIP_RCPT_REJ) == 0))
2283 			continue;
2284 
2285 		response = milter_send_command(m, command, data, sz, e, state,
2286 						where);
2287 
2288 		if (MilterLogLevel > 21)
2289 		{
2290 			/* log the time it took for the command per filter */
2291 			sm_syslog(LOG_INFO, e->e_id,
2292 				  "Milter (%s): time command (%c), %d",
2293 				  m->mf_name, command, (int) (tn - curtime()));
2294 		}
2295 
2296 		if (*state != SMFIR_CONTINUE)
2297 			break;
2298 	}
2299 	return response;
2300 }
2301 
2302 static int milter_getsymlist __P((struct milter *, char *, int, int));
2303 
2304 static int
milter_getsymlist(m,buf,rlen,offset)2305 milter_getsymlist(m, buf, rlen, offset)
2306 	struct milter *m;
2307 	char *buf;
2308 	int rlen;
2309 	int offset;
2310 {
2311 	int i, r, nummac;
2312 	mi_int32 v;
2313 
2314 	SM_ASSERT(m != NULL);
2315 	SM_ASSERT(buf != NULL);
2316 
2317 	while (offset + MILTER_LEN_BYTES < rlen)
2318 	{
2319 		size_t len;
2320 		char **macros;
2321 
2322 		nummac = 0;
2323 		(void) memcpy((char *) &v, buf + offset, MILTER_LEN_BYTES);
2324 		i = ntohl(v);
2325 		if (i < SMFIM_FIRST || i > SMFIM_LAST)
2326 			return -1;
2327 		offset += MILTER_LEN_BYTES;
2328 		macros = NULL;
2329 
2330 		switch (i)
2331 		{
2332 		  case MO_MACROS_CONNECT:
2333 			if (macros == NULL)
2334 				macros = MilterConnectMacros;
2335 			/* FALLTHROUGH */
2336 
2337 		  case MO_MACROS_HELO:
2338 			if (macros == NULL)
2339 				macros = MilterHeloMacros;
2340 			/* FALLTHROUGH */
2341 
2342 		  case MO_MACROS_ENVFROM:
2343 			if (macros == NULL)
2344 				macros = MilterEnvFromMacros;
2345 			/* FALLTHROUGH */
2346 
2347 		  case MO_MACROS_ENVRCPT:
2348 			if (macros == NULL)
2349 				macros = MilterEnvRcptMacros;
2350 			/* FALLTHROUGH */
2351 
2352 		  case MO_MACROS_EOM:
2353 			if (macros == NULL)
2354 				macros = MilterEOMMacros;
2355 			/* FALLTHROUGH */
2356 
2357 		  case MO_MACROS_EOH:
2358 			if (macros == NULL)
2359 				macros = MilterEOHMacros;
2360 			/* FALLTHROUGH */
2361 
2362 		  case MO_MACROS_DATA:
2363 			if (macros == NULL)
2364 				macros = MilterDataMacros;
2365 
2366 			len = strlen(buf + offset);
2367 			if (len > 0)
2368 			{
2369 				r = milter_set_macros(m->mf_name, macros,
2370 						buf + offset, nummac);
2371 				if (r >= 0)
2372 					nummac = r;
2373 			}
2374 			break;
2375 
2376 		  default:
2377 			return -1;
2378 		}
2379 		if (len == 0)
2380 			return -1;
2381 		offset += len + 1;
2382 	}
2383 
2384 	return 0;
2385 }
2386 
2387 /*
2388 **  MILTER_NEGOTIATE -- get version and flags from filter
2389 **
2390 **	Parameters:
2391 **		m -- milter filter structure.
2392 **		e -- current envelope.
2393 **		milters -- milters structure.
2394 **
2395 **	Returns:
2396 **		0 on success, -1 otherwise
2397 */
2398 
2399 static int
milter_negotiate(m,e,milters)2400 milter_negotiate(m, e, milters)
2401 	struct milter *m;
2402 	ENVELOPE *e;
2403 	milters_T *milters;
2404 {
2405 	char rcmd;
2406 	mi_int32 fvers, fflags, pflags;
2407 	mi_int32 mta_prot_vers, mta_prot_flags, mta_actions;
2408 	ssize_t rlen;
2409 	char *response;
2410 	char data[MILTER_OPTLEN];
2411 
2412 	/* sanity check */
2413 	if (m->mf_sock < 0 || m->mf_state != SMFS_OPEN)
2414 	{
2415 		if (MilterLogLevel > 0)
2416 			sm_syslog(LOG_ERR, e->e_id,
2417 				  "Milter (%s): negotiate, impossible state",
2418 				  m->mf_name);
2419 		milter_error(m, e);
2420 		return -1;
2421 	}
2422 
2423 #if _FFR_MILTER_CHECK
2424 	mta_prot_vers = m->mf_mta_prot_version;
2425 	mta_prot_flags = m->mf_mta_prot_flags;
2426 	mta_actions = m->mf_mta_actions;
2427 #else /* _FFR_MILTER_CHECK */
2428 	mta_prot_vers = SMFI_PROT_VERSION;
2429 	mta_prot_flags = SMFI_CURR_PROT;
2430 	mta_actions = SMFI_CURR_ACTS;
2431 #endif /* _FFR_MILTER_CHECK */
2432 #if _FFR_MDS_NEGOTIATE
2433 	if (MilterMaxDataSize == MILTER_MDS_256K)
2434 		mta_prot_flags |= SMFIP_MDS_256K;
2435 	else if (MilterMaxDataSize == MILTER_MDS_1M)
2436 		mta_prot_flags |= SMFIP_MDS_1M;
2437 #endif /* _FFR_MDS_NEGOTIATE */
2438 
2439 	fvers = htonl(mta_prot_vers);
2440 	pflags = htonl(mta_prot_flags);
2441 	fflags = htonl(mta_actions);
2442 	(void) memcpy(data, (char *) &fvers, MILTER_LEN_BYTES);
2443 	(void) memcpy(data + MILTER_LEN_BYTES,
2444 		      (char *) &fflags, MILTER_LEN_BYTES);
2445 	(void) memcpy(data + (MILTER_LEN_BYTES * 2),
2446 		      (char *) &pflags, MILTER_LEN_BYTES);
2447 	(void) milter_write(m, SMFIC_OPTNEG, data, sizeof(data),
2448 			    m->mf_timeout[SMFTO_WRITE], e, "negotiate");
2449 
2450 	if (m->mf_state == SMFS_ERROR)
2451 		return -1;
2452 
2453 	if (tTd(64, 5))
2454 		sm_dprintf("milter_negotiate(%s): send: version %lu, fflags 0x%lx, pflags 0x%lx\n",
2455 			m->mf_name, ntohl(fvers), ntohl(fflags), ntohl(pflags));
2456 
2457 	response = milter_read(m, &rcmd, &rlen, m->mf_timeout[SMFTO_READ], e,
2458 				"negotiate");
2459 	if (m->mf_state == SMFS_ERROR)
2460 		return -1;
2461 
2462 	if (rcmd != SMFIC_OPTNEG)
2463 	{
2464 		if (tTd(64, 5))
2465 			sm_dprintf("milter_negotiate(%s): returned %c instead of %c\n",
2466 				m->mf_name, rcmd, SMFIC_OPTNEG);
2467 		if (MilterLogLevel > 0)
2468 			sm_syslog(LOG_ERR, e->e_id,
2469 				  "Milter (%s): negotiate: returned %c instead of %c",
2470 				  m->mf_name, rcmd, SMFIC_OPTNEG);
2471 		if (response != NULL)
2472 			sm_free(response); /* XXX */
2473 		milter_error(m, e);
2474 		return -1;
2475 	}
2476 
2477 	/* Make sure we have enough bytes for the version */
2478 	if (response == NULL || rlen < MILTER_LEN_BYTES)
2479 	{
2480 		if (tTd(64, 5))
2481 			sm_dprintf("milter_negotiate(%s): did not return valid info\n",
2482 				m->mf_name);
2483 		if (MilterLogLevel > 0)
2484 			sm_syslog(LOG_ERR, e->e_id,
2485 				  "Milter (%s): negotiate: did not return valid info",
2486 				  m->mf_name);
2487 		if (response != NULL)
2488 			sm_free(response); /* XXX */
2489 		milter_error(m, e);
2490 		return -1;
2491 	}
2492 
2493 	/* extract information */
2494 	(void) memcpy((char *) &fvers, response, MILTER_LEN_BYTES);
2495 
2496 	/* Now make sure we have enough for the feature bitmap */
2497 	if (rlen < MILTER_OPTLEN)
2498 	{
2499 		if (tTd(64, 5))
2500 			sm_dprintf("milter_negotiate(%s): did not return enough info\n",
2501 				m->mf_name);
2502 		if (MilterLogLevel > 0)
2503 			sm_syslog(LOG_ERR, e->e_id,
2504 				  "Milter (%s): negotiate: did not return enough info",
2505 				  m->mf_name);
2506 		if (response != NULL)
2507 			sm_free(response); /* XXX */
2508 		milter_error(m, e);
2509 		return -1;
2510 	}
2511 
2512 	(void) memcpy((char *) &fflags, response + MILTER_LEN_BYTES,
2513 		      MILTER_LEN_BYTES);
2514 	(void) memcpy((char *) &pflags, response + (MILTER_LEN_BYTES * 2),
2515 		      MILTER_LEN_BYTES);
2516 
2517 	m->mf_fvers = ntohl(fvers);
2518 	m->mf_fflags = ntohl(fflags);
2519 	m->mf_pflags = ntohl(pflags);
2520 
2521 	/* check for version compatibility */
2522 	if (m->mf_fvers == 1 ||
2523 	    m->mf_fvers > SMFI_VERSION)
2524 	{
2525 		if (tTd(64, 5))
2526 			sm_dprintf("milter_negotiate(%s): version %d != MTA milter version %d\n",
2527 				m->mf_name, m->mf_fvers, SMFI_VERSION);
2528 		if (MilterLogLevel > 0)
2529 			sm_syslog(LOG_ERR, e->e_id,
2530 				  "Milter (%s): negotiate: version %d != MTA milter version %d",
2531 				  m->mf_name, m->mf_fvers, SMFI_VERSION);
2532 		milter_error(m, e);
2533 		goto error;
2534 	}
2535 
2536 	/* check for filter feature mismatch */
2537 	if ((m->mf_fflags & mta_actions) != m->mf_fflags)
2538 	{
2539 		if (tTd(64, 5))
2540 			sm_dprintf("milter_negotiate(%s): filter abilities 0x%x != MTA milter abilities 0x%lx\n",
2541 				m->mf_name, m->mf_fflags,
2542 				(unsigned long) mta_actions);
2543 		if (MilterLogLevel > 0)
2544 			sm_syslog(LOG_ERR, e->e_id,
2545 				  "Milter (%s): negotiate: filter abilities 0x%x != MTA milter abilities 0x%lx",
2546 				  m->mf_name, m->mf_fflags,
2547 				  (unsigned long) mta_actions);
2548 		milter_error(m, e);
2549 		goto error;
2550 	}
2551 
2552 #if _FFR_MDS_NEGOTIATE
2553 	/* use a table instead of sequence? */
2554 	if (bitset(SMFIP_MDS_1M, m->mf_pflags))
2555 	{
2556 		if (MilterMaxDataSize != MILTER_MDS_1M)
2557 		{
2558 			/* this should not happen... */
2559 			sm_syslog(LOG_WARNING, NOQID,
2560 				  "WARNING: Milter.maxdatasize: configured=%d, set by libmilter=%d",
2561 		    		  MilterMaxDataSize, MILTER_MDS_1M);
2562 			MilterMaxDataSize = MILTER_MDS_1M;
2563 		}
2564 	}
2565 	else if (bitset(SMFIP_MDS_256K, m->mf_pflags))
2566 	{
2567 		if (MilterMaxDataSize != MILTER_MDS_256K)
2568 		{
2569 			sm_syslog(LOG_WARNING, NOQID,
2570 				  "WARNING: Milter.maxdatasize: configured=%d, set by libmilter=%d",
2571 		    		  MilterMaxDataSize, MILTER_MDS_256K);
2572 			MilterMaxDataSize = MILTER_MDS_256K;
2573 		}
2574 	}
2575 	else if (MilterMaxDataSize != MILTER_MDS_64K)
2576 	{
2577 		sm_syslog(LOG_WARNING, NOQID,
2578 			  "WARNING: Milter.maxdatasize: configured=%d, set by libmilter=%d",
2579 	    		  MilterMaxDataSize, MILTER_MDS_64K);
2580 		MilterMaxDataSize = MILTER_MDS_64K;
2581 	}
2582 	m->mf_pflags &= ~SMFI_INTERNAL;
2583 #endif /* _FFR_MDS_NEGOTIATE */
2584 
2585 	/* check for protocol feature mismatch */
2586 	if ((m->mf_pflags & mta_prot_flags) != m->mf_pflags)
2587 	{
2588 		if (tTd(64, 5))
2589 			sm_dprintf("milter_negotiate(%s): protocol abilities 0x%x != MTA milter abilities 0x%lx\n",
2590 				m->mf_name, m->mf_pflags,
2591 				(unsigned long) mta_prot_flags);
2592 		if (MilterLogLevel > 0)
2593 			sm_syslog(LOG_ERR, e->e_id,
2594 				  "Milter (%s): negotiate: protocol abilities 0x%x != MTA milter abilities 0x%lx",
2595 				  m->mf_name, m->mf_pflags,
2596 				  (unsigned long) mta_prot_flags);
2597 		milter_error(m, e);
2598 		goto error;
2599 	}
2600 
2601 	if (m->mf_fvers <= 2)
2602 		m->mf_pflags |= SMFIP_NOUNKNOWN;
2603 	if (m->mf_fvers <= 3)
2604 		m->mf_pflags |= SMFIP_NODATA;
2605 
2606 	if (rlen > MILTER_OPTLEN)
2607 	{
2608 		milter_getsymlist(m, response, rlen, MILTER_OPTLEN);
2609 	}
2610 
2611 	if (bitset(SMFIF_DELRCPT, m->mf_fflags))
2612 		milters->mis_flags |= MIS_FL_DEL_RCPT;
2613 	if (!bitset(SMFIP_NORCPT, m->mf_pflags) &&
2614 	    !bitset(SMFIP_NR_RCPT, m->mf_pflags))
2615 		milters->mis_flags |= MIS_FL_REJ_RCPT;
2616 
2617 	if (tTd(64, 5))
2618 		sm_dprintf("milter_negotiate(%s): received: version %u, fflags 0x%x, pflags 0x%x\n",
2619 			m->mf_name, m->mf_fvers, m->mf_fflags, m->mf_pflags);
2620 	return 0;
2621 
2622   error:
2623 	if (response != NULL)
2624 		sm_free(response); /* XXX */
2625 	return -1;
2626 }
2627 
2628 /*
2629 **  MILTER_PER_CONNECTION_CHECK -- checks on per-connection commands
2630 **
2631 **	Reduce code duplication by putting these checks in one place
2632 **
2633 **	Parameters:
2634 **		e -- current envelope.
2635 **
2636 **	Returns:
2637 **		none
2638 */
2639 
2640 static void
milter_per_connection_check(e)2641 milter_per_connection_check(e)
2642 	ENVELOPE *e;
2643 {
2644 	int i;
2645 
2646 	/* see if we are done with any of the filters */
2647 	for (i = 0; InputFilters[i] != NULL; i++)
2648 	{
2649 		struct milter *m = InputFilters[i];
2650 
2651 		if (m->mf_state == SMFS_CLOSABLE)
2652 			milter_quit_filter(m, e);
2653 	}
2654 }
2655 
2656 /*
2657 **  MILTER_ERROR -- Put a milter filter into error state
2658 **
2659 **	Parameters:
2660 **		m -- the broken filter.
2661 **		e -- current envelope.
2662 **
2663 **	Returns:
2664 **		none
2665 */
2666 
2667 static void
milter_error(m,e)2668 milter_error(m, e)
2669 	struct milter *m;
2670 	ENVELOPE *e;
2671 {
2672 	/*
2673 	**  We could send a quit here but we may have gotten here due to
2674 	**  an I/O error so we don't want to try to make things worse.
2675 	*/
2676 
2677 	if (m->mf_sock >= 0)
2678 	{
2679 		(void) close(m->mf_sock);
2680 		m->mf_sock = -1;
2681 	}
2682 	m->mf_state = SMFS_ERROR;
2683 
2684 	if (MilterLogLevel > 0)
2685 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): to error state",
2686 			  m->mf_name);
2687 }
2688 
2689 /*
2690 **  MILTER_HEADERS -- send headers to a single milter filter
2691 **
2692 **	Parameters:
2693 **		m -- current filter.
2694 **		e -- current envelope.
2695 **		state -- return state from response.
2696 **
2697 **	Returns:
2698 **		response string (may be NULL)
2699 */
2700 
2701 static char *
milter_headers(m,e,state)2702 milter_headers(m, e, state)
2703 	struct milter *m;
2704 	ENVELOPE *e;
2705 	char *state;
2706 {
2707 	char *response = NULL;
2708 	HDR *h;
2709 
2710 	if (MilterLogLevel > 17)
2711 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, send",
2712 			  m->mf_name);
2713 
2714 	for (h = e->e_header; h != NULL; h = h->h_link)
2715 	{
2716 		int len_n, len_v, len_t, len_f;
2717 		char *buf, *hv;
2718 
2719 		/* don't send over deleted headers */
2720 		if (h->h_value == NULL)
2721 		{
2722 			/* strip H_USER so not counted in milter_changeheader() */
2723 			h->h_flags &= ~H_USER;
2724 			continue;
2725 		}
2726 
2727 		/* skip auto-generated */
2728 		if (!bitset(H_USER, h->h_flags))
2729 			continue;
2730 
2731 		if (tTd(64, 10))
2732 			sm_dprintf("milter_headers: %s:%s\n",
2733 				h->h_field, h->h_value);
2734 		if (MilterLogLevel > 21)
2735 			sm_syslog(LOG_INFO, e->e_id, "Milter (%s): header, %s",
2736 				  m->mf_name, h->h_field);
2737 
2738 		if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags)
2739 		    || *(h->h_value) != ' ')
2740 			hv = h->h_value;
2741 		else
2742 			hv = h->h_value + 1;
2743 		len_f = strlen(h->h_field) + 1;
2744 		len_t = len_f + strlen(hv) + 1;
2745 		if (len_t < 0)
2746 			continue;
2747 		buf = (char *) xalloc(len_t);
2748 
2749 		/*
2750 		**  Note: currently the call to dequote_internal_chars()
2751 		**  is not required as h_field is supposed to be 7-bit US-ASCII.
2752 		*/
2753 
2754 		len_n = dequote_internal_chars(h->h_field, buf, len_f);
2755 		SM_ASSERT(len_n < len_f);
2756 		len_v = dequote_internal_chars(hv, buf + len_n + 1,
2757 						len_t - len_n - 1);
2758 		SM_ASSERT(len_t >= len_n + 1 + len_v + 1);
2759 		len_t = len_n + 1 + len_v + 1;
2760 
2761 		/* send it over */
2762 		response = milter_send_command(m, SMFIC_HEADER, buf,
2763 					       len_t, e, state, "header");
2764 		sm_free(buf);
2765 		if (m->mf_state == SMFS_ERROR ||
2766 		    m->mf_state == SMFS_DONE ||
2767 		    *state != SMFIR_CONTINUE)
2768 			break;
2769 	}
2770 	if (MilterLogLevel > 17)
2771 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, sent",
2772 			  m->mf_name);
2773 	return response;
2774 }
2775 
2776 /*
2777 **  MILTER_BODY -- send the body to a filter
2778 **
2779 **	Parameters:
2780 **		m -- current filter.
2781 **		e -- current envelope.
2782 **		state -- return state from response.
2783 **
2784 **	Returns:
2785 **		response string (may be NULL)
2786 */
2787 
2788 static char *
milter_body(m,e,state)2789 milter_body(m, e, state)
2790 	struct milter *m;
2791 	ENVELOPE *e;
2792 	char *state;
2793 {
2794 	char bufchar = '\0';
2795 	char prevchar = '\0';
2796 	int c;
2797 	char *response = NULL;
2798 	char *bp;
2799 	char buf[MILTER_CHUNK_SIZE];
2800 
2801 	if (tTd(64, 10))
2802 		sm_dprintf("milter_body\n");
2803 
2804 	if (bfrewind(e->e_dfp) < 0)
2805 	{
2806 		ExitStat = EX_IOERR;
2807 		*state = SMFIR_TEMPFAIL;
2808 		syserr("milter_body: %s/%cf%s: rewind error",
2809 		       qid_printqueue(e->e_qgrp, e->e_qdir),
2810 		       DATAFL_LETTER, e->e_id);
2811 		return NULL;
2812 	}
2813 
2814 	if (MilterLogLevel > 17)
2815 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, send",
2816 			  m->mf_name);
2817 	bp = buf;
2818 	while ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) != SM_IO_EOF)
2819 	{
2820 		/*  Change LF to CRLF */
2821 		if (c == '\n')
2822 		{
2823 #if !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
2824 			/* Not a CRLF already? */
2825 			if (prevchar != '\r')
2826 #endif /* !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF */
2827 			{
2828 				/* Room for CR now? */
2829 				if (bp + 2 > &buf[sizeof(buf)])
2830 				{
2831 					/* No room, buffer LF */
2832 					bufchar = c;
2833 
2834 					/* and send CR now */
2835 					c = '\r';
2836 				}
2837 				else
2838 				{
2839 					/* Room to do it now */
2840 					*bp++ = '\r';
2841 					prevchar = '\r';
2842 				}
2843 			}
2844 		}
2845 		*bp++ = (char) c;
2846 		prevchar = c;
2847 		if (bp >= &buf[sizeof(buf)])
2848 		{
2849 			/* send chunk */
2850 			response = milter_send_command(m, SMFIC_BODY, buf,
2851 						       bp - buf, e, state,
2852 							"body chunk");
2853 			bp = buf;
2854 			if (bufchar != '\0')
2855 			{
2856 				*bp++ = bufchar;
2857 				bufchar = '\0';
2858 				prevchar = bufchar;
2859 			}
2860 		}
2861 		if (m->mf_state == SMFS_ERROR ||
2862 		    m->mf_state == SMFS_DONE ||
2863 		    m->mf_state == SMFS_SKIP ||
2864 		    *state != SMFIR_CONTINUE)
2865 			break;
2866 	}
2867 
2868 	/* check for read errors */
2869 	if (sm_io_error(e->e_dfp))
2870 	{
2871 		ExitStat = EX_IOERR;
2872 		if (*state == SMFIR_CONTINUE ||
2873 		    *state == SMFIR_ACCEPT ||
2874 		    m->mf_state == SMFS_SKIP)
2875 		{
2876 			*state = SMFIR_TEMPFAIL;
2877 			if (response != NULL)
2878 			{
2879 				sm_free(response); /* XXX */
2880 				response = NULL;
2881 			}
2882 		}
2883 		syserr("milter_body: %s/%cf%s: read error",
2884 		       qid_printqueue(e->e_qgrp, e->e_qdir),
2885 		       DATAFL_LETTER, e->e_id);
2886 		return response;
2887 	}
2888 
2889 	/* send last body chunk */
2890 	if (bp > buf &&
2891 	    m->mf_state != SMFS_ERROR &&
2892 	    m->mf_state != SMFS_DONE &&
2893 	    m->mf_state != SMFS_SKIP &&
2894 	    *state == SMFIR_CONTINUE)
2895 	{
2896 		/* send chunk */
2897 		response = milter_send_command(m, SMFIC_BODY, buf, bp - buf,
2898 					       e, state, "last body chunk");
2899 		bp = buf;
2900 	}
2901 	if (MilterLogLevel > 17)
2902 		sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, sent",
2903 			  m->mf_name);
2904 	if (m->mf_state == SMFS_SKIP)
2905 	{
2906 		*state = SMFIR_CONTINUE;
2907 		m->mf_state = SMFS_READY;
2908 	}
2909 
2910 	return response;
2911 }
2912 
2913 /*
2914 **  Actions
2915 */
2916 
2917 /*
2918 **  ADDLEADINGSPACE -- Add a leading space to a string
2919 **
2920 **	Parameters:
2921 **		str -- string
2922 **		rp -- resource pool for allocations
2923 **
2924 **	Returns:
2925 **		pointer to new string
2926 */
2927 
2928 static char *addleadingspace __P((char *, SM_RPOOL_T *));
2929 
2930 static char *
addleadingspace(str,rp)2931 addleadingspace(str, rp)
2932 	char *str;
2933 	SM_RPOOL_T *rp;
2934 {
2935 	size_t l;
2936 	char *new;
2937 
2938 	SM_ASSERT(str != NULL);
2939 	l = strlen(str);
2940 	SM_ASSERT(l + 2 > l);
2941 	new = sm_rpool_malloc_x(rp, l + 2);
2942 	new[0] = ' ';
2943 	new[1] = '\0';
2944 	sm_strlcpy(new + 1, str, l + 1);
2945 	return new;
2946 }
2947 
2948 /*
2949 **  MILTER_ADDHEADER -- Add the supplied header to the message
2950 **
2951 **	Parameters:
2952 **		m -- current filter.
2953 **		response -- encoded form of header/value.
2954 **		rlen -- length of response.
2955 **		e -- current envelope.
2956 **
2957 **	Returns:
2958 **		none
2959 */
2960 
2961 static void
milter_addheader(m,response,rlen,e)2962 milter_addheader(m, response, rlen, e)
2963 	struct milter *m;
2964 	char *response;
2965 	ssize_t rlen;
2966 	ENVELOPE *e;
2967 {
2968 	int mh_v_len;
2969 	char *val, *mh_value;
2970 	HDR *h;
2971 
2972 	if (tTd(64, 10))
2973 		sm_dprintf("milter_addheader: ");
2974 
2975 	/* sanity checks */
2976 	if (response == NULL)
2977 	{
2978 		if (tTd(64, 10))
2979 			sm_dprintf("NULL response\n");
2980 		return;
2981 	}
2982 
2983 	if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
2984 	{
2985 		if (tTd(64, 10))
2986 			sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
2987 				   (int) strlen(response), (int) (rlen - 1));
2988 		return;
2989 	}
2990 
2991 	/* Find separating NUL */
2992 	val = response + strlen(response) + 1;
2993 
2994 	/* another sanity check */
2995 	if (strlen(response) + strlen(val) + 2 != (size_t) rlen)
2996 	{
2997 		if (tTd(64, 10))
2998 			sm_dprintf("didn't follow protocol (part len)\n");
2999 		return;
3000 	}
3001 
3002 	if (*response == '\0')
3003 	{
3004 		if (tTd(64, 10))
3005 			sm_dprintf("empty field name\n");
3006 		return;
3007 	}
3008 
3009 	for (h = e->e_header; h != NULL; h = h->h_link)
3010 	{
3011 		if (sm_strcasecmp(h->h_field, response) == 0 &&
3012 		    !bitset(H_USER, h->h_flags) &&
3013 		    !bitset(H_TRACE, h->h_flags))
3014 			break;
3015 	}
3016 
3017 	mh_v_len = 0;
3018 	mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3019 
3020 	/* add to e_msgsize */
3021 	e->e_msgsize += strlen(response) + 2 + strlen(val);
3022 
3023 	if (h != NULL)
3024 	{
3025 		if (tTd(64, 10))
3026 			sm_dprintf("Replace default header %s value with %s\n",
3027 				   h->h_field, mh_value);
3028 		if (MilterLogLevel > 8)
3029 			sm_syslog(LOG_INFO, e->e_id,
3030 				  "Milter change: default header %s value with %s",
3031 				  h->h_field, mh_value);
3032 		if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3033 			h->h_value = mh_value;
3034 		else
3035 		{
3036 			h->h_value = addleadingspace(mh_value, e->e_rpool);
3037 			SM_FREE(mh_value);
3038 		}
3039 		h->h_flags |= H_USER;
3040 	}
3041 	else
3042 	{
3043 		if (tTd(64, 10))
3044 			sm_dprintf("Add %s: %s\n", response, mh_value);
3045 		if (MilterLogLevel > 8)
3046 			sm_syslog(LOG_INFO, e->e_id,
3047 				  "Milter add: header: %s: %s",
3048 				  response, mh_value);
3049 		addheader(newstr(response), mh_value, H_USER, e,
3050 			!bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3051 		SM_FREE(mh_value);
3052 	}
3053 }
3054 
3055 /*
3056 **  MILTER_INSHEADER -- Insert the supplied header
3057 **
3058 **	Parameters:
3059 **		m -- current filter.
3060 **		response -- encoded form of header/value.
3061 **		rlen -- length of response.
3062 **		e -- current envelope.
3063 **
3064 **	Returns:
3065 **		none
3066 **
3067 **	Notes:
3068 **		Unlike milter_addheader(), this does not attempt to determine
3069 **		if the header already exists in the envelope, even a
3070 **		deleted version.  It just blindly inserts.
3071 */
3072 
3073 static void
milter_insheader(m,response,rlen,e)3074 milter_insheader(m, response, rlen, e)
3075 	struct milter *m;
3076 	char *response;
3077 	ssize_t rlen;
3078 	ENVELOPE *e;
3079 {
3080 	mi_int32 idx, i;
3081 	int mh_v_len;
3082 	char *field, *val, *mh_value;
3083 
3084 	if (tTd(64, 10))
3085 		sm_dprintf("milter_insheader: ");
3086 
3087 	/* sanity checks */
3088 	if (response == NULL)
3089 	{
3090 		if (tTd(64, 10))
3091 			sm_dprintf("NULL response\n");
3092 		return;
3093 	}
3094 
3095 	if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3096 	{
3097 		if (tTd(64, 10))
3098 			sm_dprintf("didn't follow protocol (total len)\n");
3099 		return;
3100 	}
3101 
3102 	/* decode */
3103 	(void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3104 	idx = ntohl(i);
3105 	field = response + MILTER_LEN_BYTES;
3106 	val = field + strlen(field) + 1;
3107 
3108 	/* another sanity check */
3109 	if (MILTER_LEN_BYTES + strlen(field) + 1 +
3110 	    strlen(val) + 1 != (size_t) rlen)
3111 	{
3112 		if (tTd(64, 10))
3113 			sm_dprintf("didn't follow protocol (part len)\n");
3114 		return;
3115 	}
3116 
3117 	if (*field == '\0')
3118 	{
3119 		if (tTd(64, 10))
3120 			sm_dprintf("empty field name\n");
3121 		return;
3122 	}
3123 
3124 	/* add to e_msgsize */
3125 	e->e_msgsize += strlen(response) + 2 + strlen(val);
3126 
3127 	if (tTd(64, 10))
3128 		sm_dprintf("Insert (%d) %s: %s\n", idx, field, val);
3129 	if (MilterLogLevel > 8)
3130 		sm_syslog(LOG_INFO, e->e_id,
3131 			  "Milter insert (%d): header: %s: %s",
3132 			  idx, field, val);
3133 	mh_v_len = 0;
3134 	mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3135 	insheader(idx, newstr(field), mh_value, H_USER, e,
3136 		!bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3137 	SM_FREE(mh_value);
3138 }
3139 
3140 /*
3141 **  MILTER_CHANGEHEADER -- Change the supplied header in the message
3142 **
3143 **	Parameters:
3144 **		m -- current filter.
3145 **		response -- encoded form of header/index/value.
3146 **		rlen -- length of response.
3147 **		e -- current envelope.
3148 **
3149 **	Returns:
3150 **		none
3151 */
3152 
3153 static void
milter_changeheader(m,response,rlen,e)3154 milter_changeheader(m, response, rlen, e)
3155 	struct milter *m;
3156 	char *response;
3157 	ssize_t rlen;
3158 	ENVELOPE *e;
3159 {
3160 	mi_int32 i, index;
3161 	int mh_v_len;
3162 	char *field, *val, *mh_value;
3163 	HDR *h, *sysheader;
3164 
3165 	if (tTd(64, 10))
3166 		sm_dprintf("milter_changeheader: ");
3167 
3168 	/* sanity checks */
3169 	if (response == NULL)
3170 	{
3171 		if (tTd(64, 10))
3172 			sm_dprintf("NULL response\n");
3173 		return;
3174 	}
3175 
3176 	if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3177 	{
3178 		if (tTd(64, 10))
3179 			sm_dprintf("didn't follow protocol (total len)\n");
3180 		return;
3181 	}
3182 
3183 	/* Find separating NUL */
3184 	(void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3185 	index = ntohl(i);
3186 	field = response + MILTER_LEN_BYTES;
3187 	val = field + strlen(field) + 1;
3188 
3189 	/* another sanity check */
3190 	if (MILTER_LEN_BYTES + strlen(field) + 1 +
3191 	    strlen(val) + 1 != (size_t) rlen)
3192 	{
3193 		if (tTd(64, 10))
3194 			sm_dprintf("didn't follow protocol (part len)\n");
3195 		return;
3196 	}
3197 
3198 	if (*field == '\0')
3199 	{
3200 		if (tTd(64, 10))
3201 			sm_dprintf("empty field name\n");
3202 		return;
3203 	}
3204 
3205 	mh_v_len = 0;
3206 	mh_value = quote_internal_chars(val, NULL, &mh_v_len);
3207 
3208 	sysheader = NULL;
3209 	for (h = e->e_header; h != NULL; h = h->h_link)
3210 	{
3211 		if (sm_strcasecmp(h->h_field, field) == 0)
3212 		{
3213 			if (bitset(H_USER, h->h_flags) && --index <= 0)
3214 			{
3215 				sysheader = NULL;
3216 				break;
3217 			}
3218 			else if (!bitset(H_USER, h->h_flags) &&
3219 				 !bitset(H_TRACE, h->h_flags))
3220 			{
3221 				/*
3222 				**  DRUMS msg-fmt draft says can only have
3223 				**  multiple occurences of trace fields,
3224 				**  so make sure we replace any non-trace,
3225 				**  non-user field.
3226 				*/
3227 
3228 				sysheader = h;
3229 			}
3230 		}
3231 	}
3232 
3233 	/* if not found as user-provided header at index, use sysheader */
3234 	if (h == NULL)
3235 		h = sysheader;
3236 
3237 	if (h == NULL)
3238 	{
3239 		if (*val == '\0')
3240 		{
3241 			if (tTd(64, 10))
3242 				sm_dprintf("Delete (noop) %s\n", field);
3243 			if (MilterLogLevel > 8)
3244 				sm_syslog(LOG_INFO, e->e_id,
3245 					"Milter delete (noop): header: %s"
3246 					, field);
3247 		}
3248 		else
3249 		{
3250 			/* treat modify value with no existing header as add */
3251 			if (tTd(64, 10))
3252 				sm_dprintf("Add %s: %s\n", field, mh_value);
3253 			if (MilterLogLevel > 8)
3254 				sm_syslog(LOG_INFO, e->e_id,
3255 					"Milter change (add): header: %s: %s"
3256 					, field, mh_value);
3257 			addheader(newstr(field), mh_value, H_USER, e,
3258 				!bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3259 		}
3260 		return;
3261 	}
3262 
3263 	if (tTd(64, 10))
3264 	{
3265 		if (*val == '\0')
3266 		{
3267 			sm_dprintf("Delete%s %s:%s\n",
3268 				   h == sysheader ? " (default header)" : "",
3269 				   field,
3270 				   h->h_value == NULL ? "<NULL>" : h->h_value);
3271 		}
3272 		else
3273 		{
3274 			sm_dprintf("Change%s %s: from %s to %s\n",
3275 				   h == sysheader ? " (default header)" : "",
3276 				   field,
3277 				   h->h_value == NULL ? "<NULL>" : h->h_value,
3278 				   mh_value);
3279 		}
3280 	}
3281 
3282 	if (MilterLogLevel > 8)
3283 	{
3284 		if (*val == '\0')
3285 		{
3286 			sm_syslog(LOG_INFO, e->e_id,
3287 				  "Milter delete: header%s %s:%s",
3288 				  h == sysheader ? " (default header)" : "",
3289 				  field,
3290 				  h->h_value == NULL ? "<NULL>" : h->h_value);
3291 		}
3292 		else
3293 		{
3294 			sm_syslog(LOG_INFO, e->e_id,
3295 				  "Milter change: header%s %s: from %s to %s",
3296 				  h == sysheader ? " (default header)" : "",
3297 				  field,
3298 				  h->h_value == NULL ? "<NULL>" : h->h_value,
3299 				  mh_value);
3300 		}
3301 	}
3302 
3303 	if (h != sysheader && h->h_value != NULL)
3304 	{
3305 		size_t l;
3306 
3307 		l = strlen(h->h_value);
3308 		if (l > e->e_msgsize)
3309 			e->e_msgsize = 0;
3310 		else
3311 			e->e_msgsize -= l;
3312 		/* rpool, don't free: sm_free(h->h_value); XXX */
3313 	}
3314 
3315 	if (*val == '\0')
3316 	{
3317 		/* Remove "Field: " from message size */
3318 		if (h != sysheader)
3319 		{
3320 			size_t l;
3321 
3322 			l = strlen(h->h_field) + 2;
3323 			if (l > e->e_msgsize)
3324 				e->e_msgsize = 0;
3325 			else
3326 				e->e_msgsize -= l;
3327 		}
3328 		h->h_value = NULL;
3329 		SM_FREE(mh_value);
3330 	}
3331 	else
3332 	{
3333 		if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3334 			h->h_value = mh_value;
3335 		else
3336 		{
3337 			h->h_value = addleadingspace(mh_value, e->e_rpool);
3338 			SM_FREE(mh_value);
3339 		}
3340 		h->h_flags |= H_USER;
3341 		e->e_msgsize += strlen(h->h_value);
3342 	}
3343 }
3344 
3345 /*
3346 **  MILTER_SPLIT_RESPONSE -- Split response into fields.
3347 **
3348 **	Parameters:
3349 **		response -- encoded repsonse.
3350 **		rlen -- length of response.
3351 **		pargc -- number of arguments (ouput)
3352 **
3353 **	Returns:
3354 **		array of pointers to the individual strings
3355 */
3356 
3357 static char **milter_split_response __P((char *, ssize_t, int *));
3358 
3359 static char **
milter_split_response(response,rlen,pargc)3360 milter_split_response(response, rlen, pargc)
3361 	char *response;
3362 	ssize_t rlen;
3363 	int *pargc;
3364 {
3365 	char **s;
3366 	size_t i;
3367 	int elem, nelem;
3368 
3369 	SM_ASSERT(response != NULL);
3370 	SM_ASSERT(pargc != NULL);
3371 	*pargc = 0;
3372 	if (rlen < 2 || strlen(response) >= (size_t) rlen)
3373 	{
3374 		if (tTd(64, 10))
3375 			sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3376 				   (int) strlen(response), (int) (rlen - 1));
3377 		return NULL;
3378 	}
3379 
3380 	nelem = 0;
3381 	for (i = 0; i < rlen; i++)
3382 	{
3383 		if (response[i] == '\0')
3384 			++nelem;
3385 	}
3386 	if (nelem == 0)
3387 		return NULL;
3388 
3389 	/* last entry is only for the name */
3390 	s = (char **)malloc((nelem + 1) * (sizeof(*s)));
3391 	if (s == NULL)
3392 		return NULL;
3393 	s[0] = response;
3394 	for (i = 0, elem = 0; i < rlen && elem < nelem; i++)
3395 	{
3396 		if (response[i] == '\0')
3397 		{
3398 			++elem;
3399 			if (i + 1 >= rlen)
3400 				s[elem] = NULL;
3401 			else
3402 				s[elem] = &(response[i + 1]);
3403 		}
3404 	}
3405 	*pargc = nelem;
3406 
3407 	if (tTd(64, 10))
3408 	{
3409 		for (elem = 0; elem < nelem; elem++)
3410 			sm_dprintf("argv[%d]=\"%s\"\n", elem, s[elem]);
3411 	}
3412 
3413 	/* overwrite last entry (already done above, just paranoia) */
3414 	s[elem] = NULL;
3415 	return s;
3416 }
3417 
3418 /*
3419 **  MILTER_CHGFROM -- Change the envelope sender address
3420 **
3421 **	Parameters:
3422 **		response -- encoded form of recipient address.
3423 **		rlen -- length of response.
3424 **		e -- current envelope.
3425 **
3426 **	Returns:
3427 **		none
3428 */
3429 
3430 static void
milter_chgfrom(response,rlen,e)3431 milter_chgfrom(response, rlen, e)
3432 	char *response;
3433 	ssize_t rlen;
3434 	ENVELOPE *e;
3435 {
3436 	int olderrors, argc;
3437 	char **argv;
3438 
3439 	if (tTd(64, 10))
3440 		sm_dprintf("milter_chgfrom: ");
3441 
3442 	/* sanity checks */
3443 	if (response == NULL)
3444 	{
3445 		if (tTd(64, 10))
3446 			sm_dprintf("NULL response\n");
3447 		return;
3448 	}
3449 
3450 	if (*response == '\0' ||
3451 	    strlen(response) + 1 > (size_t) rlen)
3452 	{
3453 		if (tTd(64, 10))
3454 			sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3455 				   (int) strlen(response), (int) (rlen - 1));
3456 		return;
3457 	}
3458 
3459 	if (tTd(64, 10))
3460 		sm_dprintf("%s\n", response);
3461 	if (MilterLogLevel > 8)
3462 		sm_syslog(LOG_INFO, e->e_id, "Milter chgfrom: %s", response);
3463 	argv = milter_split_response(response, rlen, &argc);
3464 	if (argc < 1 || argc > 2)
3465 	{
3466 		if (tTd(64, 10))
3467 			sm_dprintf("didn't follow protocol argc=%d\n", argc);
3468 		return;
3469 	}
3470 
3471 	olderrors = Errors;
3472 	setsender(argv[0], e, NULL, '\0', false);
3473 	if (argc == 2)
3474 	{
3475 		reset_mail_esmtp_args(e);
3476 
3477 		/*
3478 		**  need "features" here: how to get those? via e?
3479 		**  "fake" it for now: allow everything.
3480 		*/
3481 
3482 		parse_esmtp_args(e, NULL, argv[0], argv[1], "MAIL", NULL,
3483 				mail_esmtp_args);
3484 	}
3485 	Errors = olderrors;
3486 	return;
3487 }
3488 
3489 /*
3490 **  MILTER_ADDRCPT_PAR -- Add the supplied recipient to the message
3491 **
3492 **	Parameters:
3493 **		response -- encoded form of recipient address.
3494 **		rlen -- length of response.
3495 **		e -- current envelope.
3496 **
3497 **	Returns:
3498 **		none
3499 */
3500 
3501 static void
milter_addrcpt_par(response,rlen,e)3502 milter_addrcpt_par(response, rlen, e)
3503 	char *response;
3504 	ssize_t rlen;
3505 	ENVELOPE *e;
3506 {
3507 	int olderrors, argc;
3508 	char *delimptr;
3509 	char **argv;
3510 	ADDRESS *a;
3511 
3512 	if (tTd(64, 10))
3513 		sm_dprintf("milter_addrcpt_par: ");
3514 
3515 	/* sanity checks */
3516 	if (response == NULL)
3517 	{
3518 		if (tTd(64, 10))
3519 			sm_dprintf("NULL response\n");
3520 		return;
3521 	}
3522 
3523 	if (tTd(64, 10))
3524 		sm_dprintf("%s\n", response);
3525 	if (MilterLogLevel > 8)
3526 		sm_syslog(LOG_INFO, e->e_id, "Milter add: rcpt: %s", response);
3527 
3528 	argv = milter_split_response(response, rlen, &argc);
3529 	if (argc < 1 || argc > 2)
3530 	{
3531 		if (tTd(64, 10))
3532 			sm_dprintf("didn't follow protocol argc=%d\n", argc);
3533 		return;
3534 	}
3535 	olderrors = Errors;
3536 
3537 	/* how to set ESMTP arguments? */
3538 	a = parseaddr(argv[0], NULLADDR, RF_COPYALL, ' ', &delimptr, e, true);
3539 
3540 	if (a != NULL && olderrors == Errors)
3541 	{
3542 		parse_esmtp_args(e, a, argv[0], argv[1], "RCPT", NULL,
3543 				rcpt_esmtp_args);
3544 		if (olderrors == Errors)
3545 			a = recipient(a, &e->e_sendqueue, 0, e);
3546 		else
3547 			sm_dprintf("olderrors=%d, Errors=%d\n",
3548 				olderrors, Errors);
3549 	}
3550 	else
3551 	{
3552 		sm_dprintf("a=%p, olderrors=%d, Errors=%d\n",
3553 			a, olderrors, Errors);
3554 	}
3555 
3556 	Errors = olderrors;
3557 	return;
3558 }
3559 
3560 /*
3561 **  MILTER_ADDRCPT -- Add the supplied recipient to the message
3562 **
3563 **	Parameters:
3564 **		response -- encoded form of recipient address.
3565 **		rlen -- length of response.
3566 **		e -- current envelope.
3567 **
3568 **	Returns:
3569 **		none
3570 */
3571 
3572 static void
milter_addrcpt(response,rlen,e)3573 milter_addrcpt(response, rlen, e)
3574 	char *response;
3575 	ssize_t rlen;
3576 	ENVELOPE *e;
3577 {
3578 	int olderrors;
3579 
3580 	if (tTd(64, 10))
3581 		sm_dprintf("milter_addrcpt: ");
3582 
3583 	/* sanity checks */
3584 	if (response == NULL)
3585 	{
3586 		if (tTd(64, 10))
3587 			sm_dprintf("NULL response\n");
3588 		return;
3589 	}
3590 
3591 	if (*response == '\0' ||
3592 	    strlen(response) + 1 != (size_t) rlen)
3593 	{
3594 		if (tTd(64, 10))
3595 			sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3596 				   (int) strlen(response), (int) (rlen - 1));
3597 		return;
3598 	}
3599 
3600 	if (tTd(64, 10))
3601 		sm_dprintf("%s\n", response);
3602 	if (MilterLogLevel > 8)
3603 		sm_syslog(LOG_INFO, e->e_id, "Milter add: rcpt: %s", response);
3604 	olderrors = Errors;
3605 	(void) sendtolist(response, NULLADDR, &e->e_sendqueue, 0, e);
3606 	Errors = olderrors;
3607 	return;
3608 }
3609 
3610 /*
3611 **  MILTER_DELRCPT -- Delete the supplied recipient from the message
3612 **
3613 **	Parameters:
3614 **		response -- encoded form of recipient address.
3615 **		rlen -- length of response.
3616 **		e -- current envelope.
3617 **
3618 **	Returns:
3619 **		none
3620 */
3621 
3622 static void
milter_delrcpt(response,rlen,e)3623 milter_delrcpt(response, rlen, e)
3624 	char *response;
3625 	ssize_t rlen;
3626 	ENVELOPE *e;
3627 {
3628 	if (tTd(64, 10))
3629 		sm_dprintf("milter_delrcpt: ");
3630 
3631 	/* sanity checks */
3632 	if (response == NULL)
3633 	{
3634 		if (tTd(64, 10))
3635 			sm_dprintf("NULL response\n");
3636 		return;
3637 	}
3638 
3639 	if (*response == '\0' ||
3640 	    strlen(response) + 1 != (size_t) rlen)
3641 	{
3642 		if (tTd(64, 10))
3643 			sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3644 				   (int) strlen(response), (int) (rlen - 1));
3645 		return;
3646 	}
3647 
3648 	if (tTd(64, 10))
3649 		sm_dprintf("%s\n", response);
3650 	if (MilterLogLevel > 8)
3651 		sm_syslog(LOG_INFO, e->e_id, "Milter delete: rcpt %s",
3652 			  response);
3653 	(void) removefromlist(response, &e->e_sendqueue, e);
3654 	return;
3655 }
3656 
3657 /*
3658 **  MILTER_REPLBODY -- Replace the current data file with new body
3659 **
3660 **	Parameters:
3661 **		response -- encoded form of new body.
3662 **		rlen -- length of response.
3663 **		newfilter -- if first time called by a new filter
3664 **		e -- current envelope.
3665 **
3666 **	Returns:
3667 **		0 upon success, -1 upon failure
3668 */
3669 
3670 static int
milter_replbody(response,rlen,newfilter,e)3671 milter_replbody(response, rlen, newfilter, e)
3672 	char *response;
3673 	ssize_t rlen;
3674 	bool newfilter;
3675 	ENVELOPE *e;
3676 {
3677 	static char prevchar;
3678 	int i;
3679 
3680 	if (tTd(64, 10))
3681 		sm_dprintf("milter_replbody\n");
3682 
3683 	/* If a new filter, reset previous character and truncate data file */
3684 	if (newfilter)
3685 	{
3686 		off_t prevsize;
3687 		char dfname[MAXPATHLEN];
3688 
3689 		(void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER),
3690 				  sizeof(dfname));
3691 
3692 		/* Reset prevchar */
3693 		prevchar = '\0';
3694 
3695 		/* Get the current data file information */
3696 		prevsize = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_SIZE, NULL);
3697 		if (prevsize < 0)
3698 			prevsize = 0;
3699 
3700 		/* truncate current data file */
3701 		if (sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
3702 		{
3703 			if (sm_io_setinfo(e->e_dfp, SM_BF_TRUNCATE, NULL) < 0)
3704 			{
3705 				MILTER_DF_ERROR("milter_replbody: sm_io truncate %s: %s");
3706 				return -1;
3707 			}
3708 		}
3709 		else
3710 		{
3711 			int err;
3712 
3713 			err = sm_io_error(e->e_dfp);
3714 			(void) sm_io_flush(e->e_dfp, SM_TIME_DEFAULT);
3715 
3716 			/*
3717 			**  Clear error if tried to fflush()
3718 			**  a read-only file pointer and
3719 			**  there wasn't a previous error.
3720 			*/
3721 
3722 			if (err == 0)
3723 				sm_io_clearerr(e->e_dfp);
3724 
3725 			/* errno is set implicitly by fseek() before return */
3726 			err = sm_io_seek(e->e_dfp, SM_TIME_DEFAULT,
3727 					 0, SEEK_SET);
3728 			if (err < 0)
3729 			{
3730 				MILTER_DF_ERROR("milter_replbody: sm_io_seek %s: %s");
3731 				return -1;
3732 			}
3733 # if NOFTRUNCATE
3734 			/* XXX: Not much we can do except rewind it */
3735 			errno = EINVAL;
3736 			MILTER_DF_ERROR("milter_replbody: ftruncate not available on this platform (%s:%s)");
3737 			return -1;
3738 # else /* NOFTRUNCATE */
3739 			err = ftruncate(sm_io_getinfo(e->e_dfp,
3740 						      SM_IO_WHAT_FD, NULL),
3741 					0);
3742 			if (err < 0)
3743 			{
3744 				MILTER_DF_ERROR("milter_replbody: sm_io ftruncate %s: %s");
3745 				return -1;
3746 			}
3747 # endif /* NOFTRUNCATE */
3748 		}
3749 
3750 		if (prevsize > e->e_msgsize)
3751 			e->e_msgsize = 0;
3752 		else
3753 			e->e_msgsize -=