smtpd.h revision 1.177 
1/*	$OpenBSD: smtpd.h,v 1.177 2010/04/21 19:53:16 gilles Exp $	*/
2
3/*
4 * Copyright (c) 2008 Gilles Chehade <gilles@openbsd.org>
5 * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20#include			 <imsg.h>
21
22#ifndef nitems
23#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
24#endif
25
26#define IMSG_SIZE_CHECK(p) do {					\
27	if (IMSG_DATA_SIZE(&imsg) != sizeof(*p))		\
28		fatalx("bad length imsg received");		\
29} while (0)
30#define IMSG_DATA_SIZE(imsg)	((imsg)->hdr.len - IMSG_HEADER_SIZE)
31
32#define CONF_FILE		 "/etc/mail/smtpd.conf"
33#define MAX_LISTEN		 16
34#define PROC_COUNT		 9
35#define MAX_NAME_SIZE		 64
36
37#define MAX_HOPS_COUNT		 100
38
39/* sizes include the tailing '\0' */
40#define MAX_LINE_SIZE		 1024
41#define MAX_LOCALPART_SIZE	 128
42#define MAX_DOMAINPART_SIZE	 MAXHOSTNAMELEN
43#define MAX_ID_SIZE		 64
44#define MAX_TAG_SIZE		 32
45
46/* return and forward path size */
47#define MAX_PATH_SIZE		 256
48
49#define SMTPD_QUEUE_INTERVAL	 (15 * 60)
50#define SMTPD_QUEUE_MAXINTERVAL	 (4 * 60 * 60)
51#define SMTPD_QUEUE_EXPIRY	 (4 * 24 * 60 * 60)
52#define SMTPD_USER		 "_smtpd"
53#define SMTPD_SOCKET		 "/var/run/smtpd.sock"
54#define SMTPD_BANNER		 "220 %s ESMTP OpenSMTPD"
55#define SMTPD_SESSION_TIMEOUT	 300
56#define SMTPD_BACKLOG		 5
57
58#define	PATH_MAILLOCAL		"/usr/libexec/mail.local"
59#define	PATH_SMTPCTL		"/usr/sbin/smtpctl"
60
61#define	DIRHASH_BUCKETS		 4096
62
63#define PATH_SPOOL		"/var/spool/smtpd"
64
65#define PATH_ENQUEUE		"/enqueue"
66#define PATH_INCOMING		"/incoming"
67#define PATH_QUEUE		"/queue"
68#define PATH_PURGE		"/purge"
69
70#define PATH_MESSAGE		"/message"
71#define PATH_ENVELOPES		"/envelopes"
72
73#define PATH_RUNQUEUE		"/runqueue"
74
75#define PATH_OFFLINE		"/offline"
76#define PATH_BOUNCE		"/bounce"
77
78/* number of MX records to lookup */
79#define MAX_MX_COUNT		10
80
81/* max response delay under flood conditions */
82#define MAX_RESPONSE_DELAY	60
83
84/* how many responses per state are undelayed */
85#define FAST_RESPONSES		2
86
87/* max len of any smtp line */
88#define	SMTP_LINE_MAX		16384
89
90#define F_STARTTLS		 0x01
91#define F_SMTPS			 0x02
92#define F_AUTH			 0x04
93#define F_SSL			(F_SMTPS|F_STARTTLS)
94
95#define F_SCERT			0x01
96#define F_CCERT			0x02
97
98#define ADVERTISE_TLS(s) \
99	((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE))
100
101#define ADVERTISE_AUTH(s) \
102	((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \
103	 !((s)->s_flags & F_AUTHENTICATED))
104
105struct netaddr {
106	struct sockaddr_storage ss;
107	int bits;
108};
109
110struct relayhost {
111	u_int8_t flags;
112	char hostname[MAXHOSTNAMELEN];
113	u_int16_t port;
114	char cert[PATH_MAX];
115};
116
117enum imsg_type {
118	IMSG_NONE,
119	IMSG_CTL_OK,		/* answer to smtpctl requests */
120	IMSG_CTL_FAIL,
121	IMSG_CTL_SHUTDOWN,
122	IMSG_CTL_VERBOSE,
123	IMSG_CONF_START,
124	IMSG_CONF_SSL,
125	IMSG_CONF_SSL_CERT,
126	IMSG_CONF_SSL_KEY,
127	IMSG_CONF_LISTENER,
128	IMSG_CONF_MAP,
129	IMSG_CONF_MAP_CONTENT,
130	IMSG_CONF_RULE,
131	IMSG_CONF_RULE_SOURCE,
132	IMSG_CONF_CONDITION,
133	IMSG_CONF_OPTION,
134	IMSG_CONF_END,
135	IMSG_CONF_RELOAD,
136	IMSG_LKA_MAIL,
137	IMSG_LKA_RCPT,
138	IMSG_LKA_SECRET,
139	IMSG_LKA_RULEMATCH,
140	IMSG_MDA_SESS_NEW,
141	IMSG_MDA_DONE,
142	IMSG_MFA_RCPT,
143	IMSG_MFA_MAIL,
144
145	IMSG_QUEUE_CREATE_MESSAGE,
146	IMSG_QUEUE_SUBMIT_ENVELOPE,
147	IMSG_QUEUE_COMMIT_ENVELOPES,
148	IMSG_QUEUE_REMOVE_MESSAGE,
149	IMSG_QUEUE_COMMIT_MESSAGE,
150	IMSG_QUEUE_TEMPFAIL,
151	IMSG_QUEUE_STATS,
152	IMSG_QUEUE_PAUSE_LOCAL,
153	IMSG_QUEUE_PAUSE_OUTGOING,
154	IMSG_QUEUE_RESUME_LOCAL,
155	IMSG_QUEUE_RESUME_OUTGOING,
156
157	IMSG_QUEUE_REMOVE_SUBMISSION,
158	IMSG_QUEUE_MESSAGE_UPDATE,
159	IMSG_QUEUE_MESSAGE_FD,
160	IMSG_QUEUE_MESSAGE_FILE,
161	IMSG_QUEUE_SCHEDULE,
162	IMSG_QUEUE_REMOVE,
163
164	IMSG_BATCH_CREATE,
165	IMSG_BATCH_APPEND,
166	IMSG_BATCH_CLOSE,
167	IMSG_BATCH_DONE,
168
169	IMSG_PARENT_ENQUEUE_OFFLINE,
170	IMSG_PARENT_FORWARD_OPEN,
171	IMSG_PARENT_FORK_MDA,
172	IMSG_PARENT_STATS,
173
174	IMSG_PARENT_AUTHENTICATE,
175	IMSG_PARENT_SEND_CONFIG,
176
177	IMSG_SMTP_STATS,
178
179	IMSG_STATS,
180	IMSG_SMTP_ENQUEUE,
181	IMSG_SMTP_PAUSE,
182	IMSG_SMTP_RESUME,
183
184	IMSG_DNS_A,
185	IMSG_DNS_A_END,
186	IMSG_DNS_MX,
187	IMSG_DNS_PTR
188};
189
190enum blockmodes {
191	BM_NORMAL,
192	BM_NONBLOCK
193};
194
195struct imsgev {
196	struct imsgbuf		 ibuf;
197	void			(*handler)(int, short, void *);
198	struct event		 ev;
199	void			*data;
200	struct smtpd		*env;
201	int			 proc;
202	short			 events;
203};
204
205struct ctl_conn {
206	TAILQ_ENTRY(ctl_conn)	 entry;
207	u_int8_t		 flags;
208#define CTL_CONN_NOTIFY		 0x01
209	struct imsgev		 iev;
210};
211TAILQ_HEAD(ctl_connlist, ctl_conn);
212
213typedef u_int32_t		 objid_t;
214
215struct ctl_id {
216	objid_t		 id;
217	char		 name[MAX_NAME_SIZE];
218};
219
220enum smtp_proc_type {
221	PROC_PARENT = 0,
222	PROC_SMTP,
223	PROC_MFA,
224	PROC_LKA,
225	PROC_QUEUE,
226	PROC_MDA,
227	PROC_MTA,
228	PROC_CONTROL,
229	PROC_RUNNER,
230} smtpd_process;
231
232struct peer {
233	enum smtp_proc_type	 id;
234	void			(*cb)(int, short, void *);
235};
236
237enum map_type {
238	T_SINGLE,
239	T_LIST,
240	T_HASH
241};
242
243enum map_src {
244	S_NONE,
245	S_DYN,
246	S_DNS,
247	S_FILE,
248	S_DB,
249	S_EXT
250};
251
252enum map_kind {
253	K_NONE,
254	K_ALIASES,
255	K_VIRTUAL,
256	K_SECRETS
257};
258
259enum mapel_type {
260	ME_STRING,
261	ME_NET,
262	ME_NETMASK
263};
264
265struct mapel {
266	TAILQ_ENTRY(mapel)		 me_entry;
267	union mapel_data {
268		char			 med_string[MAX_LINE_SIZE];
269		struct netaddr		 med_addr;
270	}				 me_key;
271	union mapel_data		 me_val;
272};
273
274struct map {
275	TAILQ_ENTRY(map)		 m_entry;
276#define F_USED				 0x01
277#define F_DYNAMIC			 0x02
278	u_int8_t			 m_flags;
279	char				 m_name[MAX_LINE_SIZE];
280	objid_t				 m_id;
281	enum map_type			 m_type;
282	enum mapel_type			 m_eltype;
283	enum map_src			 m_src;
284	char				 m_config[MAXPATHLEN];
285	TAILQ_HEAD(mapel_list, mapel)	 m_contents;
286};
287
288enum cond_type {
289	C_ALL,
290	C_NET,
291	C_DOM,
292	C_VDOM
293};
294
295struct cond {
296	TAILQ_ENTRY(cond)		 c_entry;
297	objid_t				 c_map;
298	enum cond_type			 c_type;
299};
300
301enum opt_type {
302	O_RWUSER,			/* rewrite user */
303	O_RWDOMAIN,			/* rewrite domain */
304};
305
306struct opt {
307	TAILQ_ENTRY(opt)		 o_entry;
308	enum opt_type			 o_type;
309};
310
311enum action_type {
312	A_INVALID,
313	A_RELAY,
314	A_RELAYVIA,
315	A_MAILDIR,
316	A_MBOX,
317	A_FILENAME,
318	A_EXT
319};
320
321#define IS_MAILBOX(x)	((x).rule.r_action == A_MAILDIR || (x).rule.r_action == A_MBOX || (x).rule.r_action == A_FILENAME)
322#define IS_RELAY(x)	((x).rule.r_action == A_RELAY || (x).rule.r_action == A_RELAYVIA)
323#define IS_EXT(x)	((x).rule.r_action == A_EXT)
324
325struct rule {
326	TAILQ_ENTRY(rule)		 r_entry;
327	char				 r_tag[MAX_TAG_SIZE];
328	int				 r_accept;
329	struct map			*r_sources;
330	TAILQ_HEAD(condlist, cond)	 r_conditions;
331	enum action_type		 r_action;
332	union rule_dest {
333		char			 path[MAXPATHLEN];
334		struct relayhost       	 relayhost;
335#define	MAXCOMMANDLEN	256
336		char			 command[MAXCOMMANDLEN];
337	}				 r_value;
338	TAILQ_HEAD(optlist, opt)	 r_options;
339
340	char				*r_user;
341	objid_t				 r_amap;
342};
343
344enum path_flags {
345	F_PATH_ALIAS = 0x1,
346	F_PATH_VIRTUAL = 0x2,
347	F_PATH_EXPANDED = 0x4,
348	F_PATH_NOFORWARD = 0x8,
349	F_PATH_FORWARDED = 0x10,
350	F_PATH_ACCOUNT = 0x20,
351	F_PATH_AUTHENTICATED = 0x40,
352	F_PATH_RELAY = 0x80,
353};
354
355struct mailaddr {
356	char	user[MAX_LOCALPART_SIZE];
357	char	domain[MAX_DOMAINPART_SIZE];
358};
359
360union path_data {
361	char username[MAXLOGNAME];
362	char filename[MAXPATHLEN];
363	char filter[MAXPATHLEN];
364	struct mailaddr mailaddr;
365};
366
367struct path {
368	TAILQ_ENTRY(path)		 entry;
369	struct rule			 rule;
370	struct cond			*cond;
371	enum path_flags			 flags;
372	u_int8_t			 forwardcnt;
373	char				 user[MAX_LOCALPART_SIZE];
374	char				 domain[MAX_DOMAINPART_SIZE];
375	char				 pw_name[MAXLOGNAME];
376	union path_data			 u;
377};
378TAILQ_HEAD(deliverylist, path);
379
380enum expand_type {
381	EXPAND_INVALID,
382	EXPAND_USERNAME,
383	EXPAND_FILENAME,
384	EXPAND_FILTER,
385	EXPAND_INCLUDE,
386	EXPAND_ADDRESS
387};
388
389enum expand_flags {
390	F_EXPAND_NONE,
391	F_EXPAND_DONE
392};
393
394struct expand_node {
395	RB_ENTRY(expand_node)	entry;
396	size_t			refcnt;
397	enum expand_flags      	flags;
398	enum expand_type       	type;
399	union path_data		u;
400};
401
402struct alias {
403	enum expand_type type;
404	union path_data		u;
405};
406
407enum message_type {
408	T_MDA_MESSAGE		= 0x1,
409	T_MTA_MESSAGE		= 0x2,
410	T_BOUNCE_MESSAGE	= 0x4
411};
412
413enum message_status {
414	S_MESSAGE_PERMFAILURE	= 0x2,
415	S_MESSAGE_TEMPFAILURE	= 0x4,
416	S_MESSAGE_REJECTED	= 0x8,
417	S_MESSAGE_ACCEPTED	= 0x10,
418	S_MESSAGE_RETRY		= 0x20,
419	S_MESSAGE_EDNS		= 0x40,
420	S_MESSAGE_ECONNECT	= 0x80
421};
422
423enum message_flags {
424	F_MESSAGE_RESOLVED	= 0x1,
425	F_MESSAGE_SCHEDULED	= 0x2,
426	F_MESSAGE_PROCESSING	= 0x4,
427	F_MESSAGE_AUTHENTICATED	= 0x8,
428	F_MESSAGE_ENQUEUED	= 0x10,
429	F_MESSAGE_FORCESCHEDULE	= 0x20,
430	F_MESSAGE_BOUNCE	= 0x40
431};
432
433struct message {
434	TAILQ_ENTRY(message)		 entry;
435
436	enum message_type		 type;
437
438	u_int64_t			 id;
439	u_int64_t			 session_id;
440	u_int64_t			 batch_id;
441
442	char				 tag[MAX_TAG_SIZE];
443
444	char				 message_id[MAX_ID_SIZE];
445	char				 message_uid[MAX_ID_SIZE];
446
447	char				 session_helo[MAXHOSTNAMELEN];
448	char				 session_hostname[MAXHOSTNAMELEN];
449	char				 session_errorline[MAX_LINE_SIZE];
450	struct sockaddr_storage		 session_ss;
451	struct path			 session_rcpt;
452
453	struct path			 sender;
454	struct path			 recipient;
455
456	time_t				 creation;
457	time_t				 lasttry;
458	u_int8_t			 retry;
459	enum message_flags		 flags;
460	enum message_status		 status;
461};
462
463enum batch_type {
464	T_MDA_BATCH		= 0x1,
465	T_MTA_BATCH		= 0x2,
466	T_BOUNCE_BATCH		= 0x4
467};
468
469struct batch {
470	SPLAY_ENTRY(batch)	 b_nodes;
471	u_int64_t		 id;
472	enum batch_type		 type;
473	struct rule		 rule;
474	struct smtpd		*env;
475	char			 message_id[MAX_ID_SIZE];
476	char			 hostname[MAXHOSTNAMELEN];
477	TAILQ_HEAD(, message)	 messages;
478};
479
480enum child_type {
481	CHILD_INVALID,
482	CHILD_DAEMON,
483	CHILD_MDA,
484	CHILD_ENQUEUE_OFFLINE
485};
486
487struct child {
488	SPLAY_ENTRY(child)	 entry;
489	pid_t			 pid;
490	enum child_type		 type;
491	enum smtp_proc_type	 title;
492	int			 mda_out;
493	u_int32_t		 mda_id;
494};
495
496enum session_state {
497	S_INVALID = 0,
498	S_INIT,
499	S_GREETED,
500	S_TLS,
501	S_AUTH_INIT,
502	S_AUTH_USERNAME,
503	S_AUTH_PASSWORD,
504	S_AUTH_FINALIZE,
505	S_HELO,
506	S_MAIL_MFA,
507	S_MAIL_QUEUE,
508	S_MAIL,
509	S_RCPT_MFA,
510	S_RCPT,
511	S_DATA,
512	S_DATA_QUEUE,
513	S_DATACONTENT,
514	S_DONE,
515	S_QUIT
516};
517#define STATE_COUNT	18
518
519struct ssl {
520	SPLAY_ENTRY(ssl)	 ssl_nodes;
521	char			 ssl_name[PATH_MAX];
522	char			*ssl_cert;
523	off_t			 ssl_cert_len;
524	char			*ssl_key;
525	off_t			 ssl_key_len;
526	u_int8_t		 flags;
527};
528
529struct listener {
530	u_int8_t		 flags;
531	int			 fd;
532	struct sockaddr_storage	 ss;
533	in_port_t		 port;
534	struct timeval		 timeout;
535	struct event		 ev;
536	struct smtpd		*env;
537	char			 ssl_cert_name[PATH_MAX];
538	struct ssl		*ssl;
539	void			*ssl_ctx;
540	char			 tag[MAX_TAG_SIZE];
541	TAILQ_ENTRY(listener)	 entry;
542};
543
544struct auth {
545	u_int64_t	 id;
546	char		 user[MAXLOGNAME];
547	char		 pass[MAX_LINE_SIZE];
548	int		 success;
549};
550
551enum session_flags {
552	F_EHLO		= 0x1,
553	F_QUIT		= 0x2,
554	F_8BITMIME	= 0x4,
555	F_SECURE	= 0x8,
556	F_AUTHENTICATED	= 0x10,
557	F_PEERHASTLS	= 0x20,
558	F_PEERHASAUTH	= 0x40,
559	F_WRITEONLY	= 0x80
560};
561
562struct session {
563	SPLAY_ENTRY(session)		 s_nodes;
564	u_int64_t			 s_id;
565
566	enum session_flags		 s_flags;
567	enum session_state		 s_state;
568	int				 s_fd;
569	struct sockaddr_storage		 s_ss;
570	char				 s_hostname[MAXHOSTNAMELEN];
571	struct event			 s_ev;
572	struct bufferevent		*s_bev;
573	struct listener			*s_l;
574	struct smtpd			*s_env;
575	void				*s_ssl;
576	u_char				*s_buf;
577	int				 s_buflen;
578	struct timeval			 s_tv;
579	struct message			 s_msg;
580	short				 s_nresp[STATE_COUNT];
581	size_t				 rcptcount;
582	long				 s_datalen;
583
584	struct auth			 s_auth;
585	struct batch			*batch;
586
587	FILE				*datafp;
588	int				 mboxfd;
589	int				 messagefd;
590};
591
592struct smtpd {
593	char					 sc_conffile[MAXPATHLEN];
594	size_t					 sc_maxsize;
595
596#define SMTPD_OPT_VERBOSE			 0x00000001
597#define SMTPD_OPT_NOACTION			 0x00000002
598	u_int32_t				 sc_opts;
599#define SMTPD_CONFIGURING			 0x00000001
600#define SMTPD_EXITING				 0x00000002
601#define SMTPD_MDA_PAUSED		       	 0x00000004
602#define SMTPD_MTA_PAUSED		       	 0x00000008
603#define SMTPD_SMTP_PAUSED		       	 0x00000010
604	u_int32_t				 sc_flags;
605	struct timeval				 sc_qintval;
606	u_int32_t				 sc_maxconn;
607	struct event				 sc_ev;
608	int					 *sc_pipes[PROC_COUNT]
609							[PROC_COUNT];
610	struct imsgev				*sc_ievs[PROC_COUNT];
611	int					 sc_instances[PROC_COUNT];
612	int					 sc_instance;
613	char					*sc_title[PROC_COUNT];
614	struct passwd				*sc_pw;
615	char					 sc_hostname[MAXHOSTNAMELEN];
616	TAILQ_HEAD(listenerlist, listener)	*sc_listeners;
617	TAILQ_HEAD(maplist, map)		*sc_maps, *sc_maps_reload;
618	TAILQ_HEAD(rulelist, rule)		*sc_rules, *sc_rules_reload;
619	SPLAY_HEAD(sessiontree, session)	 sc_sessions;
620	SPLAY_HEAD(msgtree, message)		 sc_messages;
621	SPLAY_HEAD(ssltree, ssl)		*sc_ssl;
622
623	SPLAY_HEAD(batchtree, batch)		 batch_queue;
624	SPLAY_HEAD(childtree, child)		 children;
625	SPLAY_HEAD(lkatree, lkasession)		 lka_sessions;
626	SPLAY_HEAD(mtatree, mta_session)	 mta_sessions;
627	LIST_HEAD(mdalist, mda_session)		 mda_sessions;
628
629	struct stats				*stats;
630};
631
632struct s_parent {
633	time_t		start;
634};
635
636struct s_queue {
637	size_t		inserts_local;
638	size_t		inserts_remote;
639};
640
641struct s_runner {
642	size_t		active;
643	size_t		bounces_active;
644	size_t		bounces;
645};
646
647struct s_session {
648	size_t		sessions;
649	size_t		sessions_active;
650
651	size_t		smtps;
652	size_t		smtps_active;
653
654	size_t		starttls;
655	size_t		starttls_active;
656
657	size_t		read_error;
658	size_t		read_timeout;
659	size_t		read_eof;
660	size_t		write_error;
661	size_t		write_timeout;
662	size_t		write_eof;
663	size_t		toofast;
664	size_t		tempfail;
665	size_t		linetoolong;
666	size_t		delays;
667};
668
669struct s_mda {
670	size_t		sessions;
671	size_t		sessions_active;
672};
673
674struct s_control {
675	size_t		sessions;
676	size_t		sessions_active;
677};
678
679struct stats {
680	struct s_parent		 parent;
681	struct s_queue		 queue;
682	struct s_runner		 runner;
683	struct s_session	 mta;
684	struct s_mda		 mda;
685	struct s_session	 smtp;
686	struct s_control	 control;
687};
688
689struct sched {
690	int			fd;
691	char			mid[MAX_ID_SIZE];
692	int			ret;
693};
694
695struct remove {
696	int			fd;
697	char			mid[MAX_ID_SIZE];
698	int			ret;
699};
700
701struct reload {
702	int			fd;
703	int			ret;
704};
705
706struct submit_status {
707	u_int64_t			 id;
708	int				 code;
709	union submit_path {
710		struct path		 path;
711		char			 msgid[MAX_ID_SIZE];
712		char			 errormsg[MAX_LINE_SIZE];
713	}				 u;
714	enum message_flags		 flags;
715	struct sockaddr_storage		 ss;
716	struct message			 msg;
717};
718
719struct forward_req {
720	u_int64_t			 id;
721	u_int8_t			 status;
722	char				 pw_name[MAXLOGNAME];
723};
724
725struct dns {
726	u_int64_t		 id;
727	char			 host[MAXHOSTNAMELEN];
728	int			 port;
729	int			 error;
730	struct sockaddr_storage	 ss;
731	struct smtpd		*env;
732	struct dns		*next;
733};
734
735struct secret {
736	u_int64_t		 id;
737	char			 host[MAXHOSTNAMELEN];
738	char			 secret[MAX_LINE_SIZE];
739};
740
741struct mda_session {
742	LIST_ENTRY(mda_session)	 entry;
743	struct message		 msg;
744	struct msgbuf		 w;
745	struct event		 ev;
746	u_int32_t		 id;
747	FILE			*datafp;
748};
749
750struct deliver {
751	char			to[PATH_MAX];
752	char			user[MAXLOGNAME];
753	short			mode;
754};
755
756struct rulematch {
757	u_int64_t		 id;
758	struct submit_status	 ss;
759};
760
761enum lkasession_flags {
762	F_ERROR		= 0x1
763};
764
765struct lkasession {
766	SPLAY_ENTRY(lkasession)		 nodes;
767	u_int64_t			 id;
768
769	struct path			 path;
770	struct deliverylist    		 deliverylist;
771
772	RB_HEAD(expandtree, expand_node)	expandtree;
773
774	u_int8_t			 iterations;
775	u_int32_t			 pending;
776	enum lkasession_flags		 flags;
777	struct message			 message;
778	struct submit_status		 ss;
779};
780
781enum mta_state {
782	MTA_INVALID_STATE,
783	MTA_INIT,
784	MTA_SECRET,
785	MTA_DATA,
786	MTA_MX,
787	MTA_CONNECT,
788	MTA_PTR,
789	MTA_PROTOCOL,
790	MTA_DONE
791};
792
793/* mta session flags */
794#define	MTA_FORCE_ANYSSL	0x1
795#define	MTA_FORCE_SMTPS		0x2
796#define	MTA_ALLOW_PLAIN		0x4
797#define	MTA_USE_AUTH		0x8
798
799struct mta_relay {
800	TAILQ_ENTRY(mta_relay)	 entry;
801	struct sockaddr_storage	 sa;
802	char			 fqdn[MAXHOSTNAMELEN];
803	int			 used;
804};
805
806struct mta_session {
807	SPLAY_ENTRY(mta_session) entry;
808	u_int64_t		 id;
809	struct smtpd		*env;
810	enum mta_state		 state;
811	char			*host;
812	int			 port;
813	int			 flags;
814	TAILQ_HEAD(,message)	 recipients;
815	TAILQ_HEAD(,mta_relay)	 relays;
816	char			*secret;
817	int			 fd;
818	int			 datafd;
819	struct event		 ev;
820	char			*cert;
821	void			*pcb;
822};
823
824extern void (*imsg_callback)(struct smtpd *, struct imsgev *, struct imsg *);
825
826/* aliases.c */
827int aliases_exist(struct smtpd *, objid_t, char *);
828int aliases_get(struct smtpd *, objid_t, struct expandtree *, char *);
829int aliases_vdomain_exists(struct smtpd *, objid_t, char *);
830int aliases_virtual_exist(struct smtpd *, objid_t, struct path *);
831int aliases_virtual_get(struct smtpd *, objid_t, struct expandtree *, struct path *);
832int alias_parse(struct alias *, char *);
833void alias_to_expand_node(struct expand_node *, struct alias *);
834
835/* authenticate.c */
836int authenticate_user(char *, char *);
837
838/* bounce.c */
839void bounce_process(struct smtpd *, struct message *);
840int bounce_session(struct smtpd *, int, struct message *);
841int bounce_session_switch(struct smtpd *, FILE *, enum session_state *, char *,
842	struct message *);
843
844/* log.c */
845void		log_init(int);
846void		log_verbose(int);
847void		log_warn(const char *, ...)
848    __attribute__ ((format (printf, 1, 2)));
849void		log_warnx(const char *, ...)
850    __attribute__ ((format (printf, 1, 2)));
851void		log_info(const char *, ...)
852    __attribute__ ((format (printf, 1, 2)));
853void		log_debug(const char *, ...)
854    __attribute__ ((format (printf, 1, 2)));
855__dead void	fatal(const char *);
856__dead void	fatalx(const char *);
857
858
859/* dns.c */
860void		 dns_query_a(struct smtpd *, char *, int, u_int64_t);
861void		 dns_query_mx(struct smtpd *, char *, int, u_int64_t);
862void		 dns_query_ptr(struct smtpd *, struct sockaddr_storage *,
863		     u_int64_t);
864void		 dns_async(struct smtpd *, struct imsgev *, int,
865		     struct dns *);
866/* expand.c */
867int expand_cmp(struct expand_node *, struct expand_node *);
868void expandtree_increment_node(struct expandtree *, struct expand_node *);
869void expandtree_decrement_node(struct expandtree *, struct expand_node *);
870void expandtree_remove_node(struct expandtree *, struct expand_node *);
871struct expand_node *expandtree_lookup(struct expandtree *, struct expand_node *);
872RB_PROTOTYPE(expandtree, expand_node, nodes, expand_cmp);
873
874/* forward.c */
875int forwards_get(int, struct expandtree *);
876
877/* smtpd.c */
878int	 child_cmp(struct child *, struct child *);
879SPLAY_PROTOTYPE(childtree, child, entry, child_cmp);
880void	 imsg_event_add(struct imsgev *);
881int	 imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t,
882	    int, void *, u_int16_t);
883void	 imsg_dispatch(int, short, void *);
884
885/* lka.c */
886pid_t		 lka(struct smtpd *);
887int		 lkasession_cmp(struct lkasession *, struct lkasession *);
888SPLAY_PROTOTYPE(lkatree, lkasession, nodes, lkasession_cmp);
889
890/* mfa.c */
891pid_t		 mfa(struct smtpd *);
892int		 msg_cmp(struct message *, struct message *);
893
894/* queue.c */
895pid_t		 queue(struct smtpd *);
896int		 queue_load_envelope(struct message *, char *);
897int		 queue_update_envelope(struct message *);
898int		 queue_remove_envelope(struct message *);
899void		 queue_submit_envelope(struct smtpd *, struct message *);
900void		 queue_commit_envelopes(struct smtpd *, struct message*);
901int		 batch_cmp(struct batch *, struct batch *);
902struct batch    *batch_by_id(struct smtpd *, u_int64_t);
903u_int16_t	 queue_hash(char *);
904
905/* queue_shared.c */
906int		 queue_create_layout_message(char *, char *);
907void		 queue_delete_layout_message(char *, char *);
908int		 queue_record_layout_envelope(char *, struct message *);
909int		 queue_remove_layout_envelope(char *, struct message *);
910int		 queue_commit_layout_message(char *, struct message *);
911int		 queue_open_layout_messagefile(char *, struct message *);
912int		 enqueue_create_layout(char *);
913void		 enqueue_delete_message(char *);
914int		 enqueue_record_envelope(struct message *);
915int		 enqueue_remove_envelope(struct message *);
916int		 enqueue_commit_message(struct message *);
917int		 enqueue_open_messagefile(struct message *);
918int		 bounce_create_layout(char *, struct message *);
919void		 bounce_delete_message(char *);
920int		 bounce_record_envelope(struct message *);
921int		 bounce_remove_envelope(struct message *);
922int		 bounce_commit_message(struct message *);
923int		 bounce_record_message(struct message *);
924int		 queue_create_incoming_layout(char *);
925void		 queue_delete_incoming_message(char *);
926int		 queue_record_incoming_envelope(struct message *);
927int		 queue_remove_incoming_envelope(struct message *);
928int		 queue_commit_incoming_message(struct message *);
929int		 queue_open_incoming_message_file(struct message *);
930int		 queue_open_message_file(char *msgid);
931void		 queue_message_update(struct message *);
932void		 queue_delete_message(char *);
933struct qwalk	*qwalk_new(char *);
934int		 qwalk(struct qwalk *, char *);
935void		 qwalk_close(struct qwalk *);
936void		 show_queue(char *, int);
937
938u_int16_t	queue_hash(char *);
939
940/* map.c */
941char		*map_lookup(struct smtpd *, objid_t, char *, enum map_kind);
942
943/* mda.c */
944pid_t		 mda(struct smtpd *);
945
946/* mta.c */
947pid_t		 mta(struct smtpd *);
948int		 mta_session_cmp(struct mta_session *, struct mta_session *);
949SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp);
950
951/* control.c */
952pid_t		 control(struct smtpd *);
953void		 session_socket_blockmode(int, enum blockmodes);
954void		 session_socket_no_linger(int);
955int		 session_socket_error(int);
956
957/* enqueue.c */
958int		 enqueue(int, char **);
959int		 enqueue_offline(int, char **);
960
961/* runner.c */
962pid_t		 runner(struct smtpd *);
963void		 message_reset_flags(struct message *);
964SPLAY_PROTOTYPE(batchtree, batch, b_nodes, batch_cmp);
965
966/* smtp.c */
967pid_t		 smtp(struct smtpd *);
968void		 smtp_resume(struct smtpd *);
969
970/* smtp_session.c */
971void		 session_init(struct listener *, struct session *);
972int		 session_cmp(struct session *, struct session *);
973void		 session_pickup(struct session *, struct submit_status *);
974void		 session_destroy(struct session *);
975void		 session_respond(struct session *, char *, ...)
976		    __attribute__ ((format (printf, 2, 3)));
977void		 session_bufferevent_new(struct session *);
978
979SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp);
980
981/* config.c */
982#define		 PURGE_LISTENERS	0x01
983#define		 PURGE_MAPS		0x02
984#define		 PURGE_RULES		0x04
985#define		 PURGE_SSL		0x08
986#define		 PURGE_EVERYTHING	0xff
987void		 purge_config(struct smtpd *, u_int8_t);
988void		 unconfigure(struct smtpd *);
989void		 configure(struct smtpd *);
990void		 init_pipes(struct smtpd *);
991void		 config_pipes(struct smtpd *, struct peer *, u_int);
992void		 config_peers(struct smtpd *, struct peer *, u_int);
993
994/* parse.y */
995int		 parse_config(struct smtpd *, const char *, int);
996int		 cmdline_symset(char *);
997
998/* ssl.c */
999void	 ssl_init(void);
1000void	 ssl_transaction(struct session *);
1001
1002void	 ssl_session_init(struct session *);
1003void	 ssl_session_destroy(struct session *);
1004int	 ssl_load_certfile(struct smtpd *, const char *, u_int8_t);
1005void	 ssl_setup(struct smtpd *, struct listener *);
1006int	 ssl_cmp(struct ssl *, struct ssl *);
1007SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp);
1008
1009/* ssl_privsep.c */
1010int	 ssl_ctx_use_private_key(void *, char *, off_t);
1011int	 ssl_ctx_use_certificate_chain(void *, char *, off_t);
1012
1013/* map.c */
1014struct map	*map_find(struct smtpd *, objid_t);
1015struct map	*map_findbyname(struct smtpd *, const char *);
1016
1017/* util.c */
1018typedef struct arglist arglist;
1019struct arglist {
1020	char    **list;
1021	u_int   num;
1022	u_int   nalloc;
1023};
1024void		 addargs(arglist *, char *, ...)
1025		     __attribute__((format(printf, 2, 3)));
1026int		 bsnprintf(char *, size_t, const char *, ...)
1027    __attribute__ ((format (printf, 3, 4)));
1028int		 safe_fclose(FILE *);
1029int		 hostname_match(char *, char *);
1030int		 recipient_to_path(struct path *, char *);
1031int		 valid_localpart(char *);
1032int		 valid_domainpart(char *);
1033char		*ss_to_text(struct sockaddr_storage *);
1034int		 valid_message_id(char *);
1035int		 valid_message_uid(char *);
1036char		*time_to_text(time_t);
1037int		 secure_file(int, char *, struct passwd *, int);
1038void		 lowercase(char *, char *, size_t);
1039void		 message_set_errormsg(struct message *, char *, ...);
1040char		*message_get_errormsg(struct message *);
1041void		 sa_set_port(struct sockaddr *, int);
1042struct path	*path_dup(struct path *);
1043u_int64_t	 generate_uid(void);
1044void		 fdlimit(double);
1045int		 availdesc(void);
1046