Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Annotate
Revision Log

milter.c @ 19204

Visit:

Revision 19204, 82.6 KB checked in by zacheiss, 21 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r19203, which included commits to RCS files with non-trunk default branches.

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/sendmail/sendmail/milter.c @ 19204

Download in other formats: