smtpd.h revision 1.97 
1/*	$OpenBSD: smtpd.h,v 1.97 2009/04/09 19:49:34 jacekm 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#define CONF_FILE		 "/etc/mail/smtpd.conf"
21#define MAX_LISTEN		 16
22#define PROC_COUNT		 9
23#define READ_BUF_SIZE		 32768
24#define MAX_NAME_SIZE		 64
25
26#define MAX_HOPS_COUNT		 100
27
28/* sizes include the tailing '\0' */
29#define MAX_LINE_SIZE		 1024
30#define MAX_LOCALPART_SIZE	 65
31#define MAX_DOMAINPART_SIZE	 MAXHOSTNAMELEN
32#define MAX_ID_SIZE		 64
33
34/* return and forward path size */
35#define MAX_PATH_SIZE		 256
36
37/*#define SMTPD_CONNECT_TIMEOUT	 (60)*/
38#define SMTPD_CONNECT_TIMEOUT	 (10)
39#define SMTPD_QUEUE_INTERVAL	 (15 * 60)
40#define SMTPD_QUEUE_MAXINTERVAL	 (4 * 60 * 60)
41#define SMTPD_QUEUE_EXPIRY	 (4 * 24 * 60 * 60)
42#define SMTPD_USER		 "_smtpd"
43#define SMTPD_SOCKET		 "/var/run/smtpd.sock"
44#define SMTPD_BANNER		 "220 %s ESMTP OpenSMTPD"
45#define SMTPD_SESSION_TIMEOUT	 300
46#define SMTPD_BACKLOG		 5
47
48#define	PATH_MAILLOCAL		"/usr/libexec/mail.local"
49
50#define	DIRHASH_BUCKETS		 4096
51
52#define PATH_SPOOL		"/var/spool/smtpd"
53
54#define PATH_ENQUEUE		"/enqueue"
55#define PATH_INCOMING		"/incoming"
56#define PATH_QUEUE		"/queue"
57#define PATH_PURGE		"/purge"
58
59#define PATH_MESSAGE		"/message"
60#define PATH_ENVELOPES		"/envelopes"
61
62#define PATH_RUNQUEUE		"/runqueue"
63#define PATH_RUNQUEUEHIGH	"/runqueue-high"
64#define PATH_RUNQUEUELOW	"/runqueue-low"
65
66/* number of MX records to lookup */
67#define MXARRAYSIZE	5
68#define MAX_MX_COUNT	10
69
70/* rfc5321 limits */
71#define	SMTP_TEXTLINE_MAX	1000
72#define	SMTP_CMDLINE_MAX	512
73#define	SMTP_ANYLINE_MAX	SMTP_TEXTLINE_MAX
74
75#define F_STARTTLS		 0x01
76#define F_SMTPS			 0x02
77#define F_AUTH			 0x04
78#define F_SSL			(F_SMTPS|F_STARTTLS)
79
80
81struct netaddr {
82	struct sockaddr_storage ss;
83	int bits;
84};
85
86struct relayhost {
87	u_int8_t flags;
88	char hostname[MAXHOSTNAMELEN];
89	u_int16_t port;
90};
91
92struct mxhost {
93	TAILQ_ENTRY(mxhost)	 entry;
94	u_int8_t flags;
95	struct sockaddr_storage ss;
96	char credentials[MAX_LINE_SIZE];
97};
98
99/* buffer specific headers */
100struct buf {
101	TAILQ_ENTRY(buf)	 entry;
102	u_char			*buf;
103	size_t			 size;
104	size_t			 max;
105	size_t			 wpos;
106	size_t			 rpos;
107	int			 fd;
108};
109
110struct msgbuf {
111	TAILQ_HEAD(, buf)	 bufs;
112	u_int32_t		 queued;
113	int			 fd;
114};
115
116struct buf_read {
117	u_char			 buf[READ_BUF_SIZE];
118	u_char			*rptr;
119	size_t			 wpos;
120};
121
122struct imsg_fd  {
123	TAILQ_ENTRY(imsg_fd)	 entry;
124	int			 fd;
125	u_int32_t		 id;
126};
127
128struct imsgbuf {
129	TAILQ_HEAD(, imsg_fd)	 fds;
130	struct buf_read		 r;
131	struct msgbuf		 w;
132	struct event		 ev;
133	void			(*handler)(int, short, void *);
134	int			 fd;
135	pid_t			 pid;
136	short			 events;
137	void			*data;
138	u_int32_t		 id;
139};
140
141struct imsg_hdr {
142	u_int16_t		 type;
143	u_int16_t		 len;
144	u_int32_t		 peerid;
145	pid_t			 pid;
146};
147
148struct imsg {
149	struct imsg_hdr		 hdr;
150	u_int32_t		 id;
151	void			*data;
152};
153
154enum imsg_type {
155	IMSG_NONE,
156	IMSG_CTL_OK,		/* answer to smtpctl requests */
157	IMSG_CTL_FAIL,
158	IMSG_CTL_SHUTDOWN,
159	IMSG_CONF_START,
160	IMSG_CONF_SSL,
161	IMSG_CONF_SSL_CERT,
162	IMSG_CONF_SSL_KEY,
163	IMSG_CONF_LISTENER,
164	IMSG_CONF_MAP,
165	IMSG_CONF_RULE,
166	IMSG_CONF_CONDITION,
167	IMSG_CONF_OPTION,
168	IMSG_CONF_END,
169	IMSG_CONF_RELOAD,
170	IMSG_LKA_MAIL,
171	IMSG_LKA_RCPT,
172	IMSG_LKA_MX,
173	IMSG_LKA_MX_END,
174	IMSG_LKA_HOST,
175	IMSG_MDA_MAILBOX_FILE,
176	IMSG_MDA_MESSAGE_FILE,
177	IMSG_MFA_RCPT,
178	IMSG_MFA_MAIL,
179
180	IMSG_QUEUE_CREATE_MESSAGE,
181	IMSG_QUEUE_SUBMIT_ENVELOPE,
182	IMSG_QUEUE_COMMIT_ENVELOPES,
183	IMSG_QUEUE_REMOVE_MESSAGE,
184	IMSG_QUEUE_COMMIT_MESSAGE,
185	IMSG_QUEUE_TEMPFAIL,
186	IMSG_QUEUE_STATS,
187
188	IMSG_QUEUE_REMOVE_SUBMISSION,
189	IMSG_QUEUE_MESSAGE_UPDATE,
190	IMSG_QUEUE_MESSAGE_FD,
191	IMSG_QUEUE_MESSAGE_FILE,
192
193	IMSG_RUNNER_UPDATE_ENVELOPE,
194	IMSG_RUNNER_STATS,
195	IMSG_RUNNER_SCHEDULE,
196
197	IMSG_BATCH_CREATE,
198	IMSG_BATCH_APPEND,
199	IMSG_BATCH_CLOSE,
200
201	IMSG_PARENT_FORWARD_OPEN,
202	IMSG_PARENT_MAILBOX_OPEN,
203	IMSG_PARENT_MESSAGE_OPEN,
204	IMSG_PARENT_MAILBOX_RENAME,
205	IMSG_PARENT_STATS,
206
207	IMSG_PARENT_AUTHENTICATE,
208	IMSG_PARENT_SEND_CONFIG,
209
210	IMSG_MDA_PAUSE,
211	IMSG_MTA_PAUSE,
212	IMSG_SMTP_PAUSE,
213	IMSG_SMTP_STATS,
214
215	IMSG_MDA_RESUME,
216	IMSG_MTA_RESUME,
217	IMSG_SMTP_RESUME,
218
219	IMSG_STATS
220};
221
222#define IMSG_HEADER_SIZE	 sizeof(struct imsg_hdr)
223#define	MAX_IMSGSIZE		 16384
224
225enum blockmodes {
226	BM_NORMAL,
227	BM_NONBLOCK
228};
229
230enum ctl_state {
231	CS_NONE = 0,
232	CS_INIT,
233	CS_RCPT,
234	CS_FD,
235	CS_DONE
236};
237
238struct ctl_conn {
239	TAILQ_ENTRY(ctl_conn)	 entry;
240	u_int8_t		 flags;
241#define CTL_CONN_NOTIFY		 0x01
242	struct imsgbuf		 ibuf;
243	enum ctl_state		 state;
244};
245TAILQ_HEAD(ctl_connlist, ctl_conn);
246
247typedef u_int32_t		 objid_t;
248
249struct ctl_id {
250	objid_t		 id;
251	char		 name[MAX_NAME_SIZE];
252};
253
254enum smtp_proc_type {
255	PROC_PARENT = 0,
256	PROC_SMTP,
257	PROC_MFA,
258	PROC_LKA,
259	PROC_QUEUE,
260	PROC_MDA,
261	PROC_MTA,
262	PROC_CONTROL,
263	PROC_RUNNER,
264} smtpd_process;
265
266struct peer {
267	enum smtp_proc_type	 id;
268	void			(*cb)(int, short, void *);
269};
270
271enum map_type {
272	T_SINGLE,
273	T_LIST,
274	T_HASH
275};
276
277enum map_src {
278	S_NONE,
279	S_DYN,
280	S_DNS,
281	S_FILE,
282	S_DB,
283	S_EXT
284};
285
286enum mapel_type {
287	ME_STRING,
288	ME_NET,
289	ME_NETMASK
290};
291
292struct mapel {
293	TAILQ_ENTRY(mapel)		 me_entry;
294	union mapel_data {
295		char			 med_string[MAX_LINE_SIZE];
296		struct netaddr		 med_addr;
297	}				 me_key;
298	union mapel_data		 me_val;
299};
300
301struct map {
302	TAILQ_ENTRY(map)		 m_entry;
303#define F_USED				 0x01
304#define F_DYNAMIC			 0x02
305	u_int8_t			 m_flags;
306	char				 m_name[MAX_LINE_SIZE];
307	objid_t				 m_id;
308	enum map_type			 m_type;
309	enum mapel_type			 m_eltype;
310	enum map_src			 m_src;
311	char				 m_config[MAXPATHLEN];
312	TAILQ_HEAD(mapel_list, mapel)	 m_contents;
313};
314
315enum cond_type {
316	C_ALL,
317	C_NET,
318	C_DOM
319};
320
321struct cond {
322	TAILQ_ENTRY(cond)		 c_entry;
323	objid_t				 c_map;
324	enum cond_type			 c_type;
325	struct map			*c_match;
326};
327
328enum opt_type {
329	O_RWUSER,			/* rewrite user */
330	O_RWDOMAIN,			/* rewrite domain */
331};
332
333struct opt {
334	TAILQ_ENTRY(opt)		 o_entry;
335	enum opt_type			 o_type;
336};
337
338enum action_type {
339	A_INVALID,
340	A_RELAY,
341	A_RELAYVIA,
342	A_MAILDIR,
343	A_MBOX,
344	A_FILENAME,
345	A_EXT
346};
347#define IS_MAILBOX(x)	((x) == A_MAILDIR || (x) == A_MBOX || (x) == A_FILENAME)
348#define IS_RELAY(x)	((x) == A_RELAY || (x) == A_RELAYVIA)
349#define IS_EXT(x)	((x) == A_EXT)
350
351struct rule {
352	TAILQ_ENTRY(rule)		 r_entry;
353	int				 r_accept;
354	struct map			*r_sources;
355	TAILQ_HEAD(condlist, cond)	 r_conditions;
356	enum action_type		 r_action;
357	union rule_dest {
358		char			 path[MAXPATHLEN];
359		struct relayhost       	 relayhost;
360#define	MAXCOMMANDLEN	256
361		char			 command[MAXCOMMANDLEN];
362	}				 r_value;
363	TAILQ_HEAD(optlist, opt)	 r_options;
364};
365
366enum path_flags {
367	F_ALIAS = 0x1,
368	F_VIRTUAL = 0x2,
369	F_EXPANDED = 0x4,
370	F_NOFORWARD = 0x8,
371	F_FORWARDED = 0x10,
372	F_ACCOUNT = 0x20,
373};
374
375struct path {
376	TAILQ_ENTRY(path)		 entry;
377	struct rule			 rule;
378	enum path_flags			 flags;
379	u_int8_t			 forwardcnt;
380	char				 user[MAX_LOCALPART_SIZE];
381	char				 domain[MAX_DOMAINPART_SIZE];
382	char				 pw_name[MAXLOGNAME];
383	union path_data {
384		char filename[MAXPATHLEN];
385		char filter[MAXPATHLEN];
386	}				 u;
387};
388
389enum alias_type {
390	ALIAS_USERNAME,
391	ALIAS_FILENAME,
392	ALIAS_FILTER,
393	ALIAS_INCLUDE,
394	ALIAS_ADDRESS
395};
396
397struct alias {
398	TAILQ_ENTRY(alias)		entry;
399	enum alias_type			 type;
400	union alias_data {
401		char username[MAXLOGNAME];
402		char filename[MAXPATHLEN];
403		char filter[MAXPATHLEN];
404		struct path path;
405	}                                   u;
406};
407TAILQ_HEAD(aliaseslist, alias);
408
409enum message_type {
410	T_MDA_MESSAGE		= 0x1,
411	T_MTA_MESSAGE		= 0x2,
412	T_DAEMON_MESSAGE	= 0x4
413};
414
415enum message_status {
416	S_MESSAGE_LOCKFAILURE	= 0x1,
417	S_MESSAGE_PERMFAILURE	= 0x2,
418	S_MESSAGE_TEMPFAILURE	= 0x4,
419	S_MESSAGE_REJECTED	= 0x8,
420	S_MESSAGE_ACCEPTED	= 0x10,
421	S_MESSAGE_RETRY		= 0x20,
422	S_MESSAGE_EDNS		= 0x40,
423	S_MESSAGE_ECONNECT	= 0x80
424};
425
426enum message_flags {
427	F_MESSAGE_RESOLVED	= 0x1,
428	F_MESSAGE_SCHEDULED	= 0x2,
429	F_MESSAGE_PROCESSING	= 0x4,
430	F_MESSAGE_AUTHENTICATED	= 0x8,
431	F_MESSAGE_ENQUEUED	= 0x10,
432	F_MESSAGE_FORCESCHEDULE	= 0x20
433};
434
435struct message {
436	TAILQ_ENTRY(message)		 entry;
437
438	enum message_type		 type;
439
440	u_int64_t			 id;
441	u_int64_t			 session_id;
442	u_int64_t			 batch_id;
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_status {
464	S_BATCH_PERMFAILURE	= 0x1,
465	S_BATCH_TEMPFAILURE	= 0x2,
466	S_BATCH_REJECTED	= 0x4,
467	S_BATCH_ACCEPTED	= 0x8,
468	S_BATCH_RETRY		= 0x10,
469	S_BATCH_EDNS		= 0x20,
470	S_BATCH_ECONNECT	= 0x40
471};
472
473enum batch_type {
474	T_MDA_BATCH		= 0x1,
475	T_MTA_BATCH		= 0x2,
476	T_DAEMON_BATCH		= 0x4
477};
478
479enum batch_flags {
480	F_BATCH_COMPLETE	= 0x1,
481	F_BATCH_RESOLVED	= 0x2,
482	F_BATCH_SCHEDULED	= 0x4,
483	F_BATCH_EXPIRED		= 0x8,
484};
485
486struct mdaproc {
487	SPLAY_ENTRY(mdaproc)	mdaproc_nodes;
488
489	pid_t			pid;
490};
491
492struct batch {
493	SPLAY_ENTRY(batch)	 b_nodes;
494
495	u_int64_t		 id;
496	u_int64_t		 session_id;
497	enum batch_type		 type;
498	enum batch_flags	 flags;
499
500	struct rule			 rule;
501
502	struct smtpd			*env;
503
504	char				 message_id[MAX_ID_SIZE];
505	char				 hostname[MAXHOSTNAMELEN];
506	char				 errorline[MAX_LINE_SIZE];
507
508	char				 session_helo[MAXHOSTNAMELEN];
509	char				 session_hostname[MAXHOSTNAMELEN];
510	struct sockaddr_storage		 session_ss;
511
512	time_t				 creation;
513	time_t				 lasttry;
514	u_int8_t			 retry;
515
516	struct session			*sessionp;
517
518	struct message			message;
519	struct message			*messagep;
520	FILE				*messagefp;
521	TAILQ_HEAD(messagelist, message) messages;
522
523	enum batch_status		status;
524};
525
526enum session_state {
527	S_INIT = 0,
528	S_GREETED,
529	S_TLS,
530	S_AUTH_INIT,
531	S_AUTH_USERNAME,
532	S_AUTH_PASSWORD,
533	S_AUTH_FINALIZE,
534	S_HELO,
535	S_MAILREQUEST,
536	S_MAIL,
537	S_RCPTREQUEST,
538	S_RCPT,
539	S_DATAREQUEST,
540	S_DATA,
541	S_DATACONTENT,
542	S_DONE,
543	S_QUIT
544};
545#define	IS_AUTH(x)	((x) == S_AUTH_INIT || (x) == S_AUTH_USERNAME || (x) == S_AUTH_PASSWORD || (x) == S_AUTH_FINALIZE)
546
547struct ssl {
548	SPLAY_ENTRY(ssl)	 ssl_nodes;
549	char			 ssl_name[PATH_MAX];
550	char			*ssl_cert;
551	off_t			 ssl_cert_len;
552	char			*ssl_key;
553	off_t			 ssl_key_len;
554};
555
556struct listener {
557	u_int8_t		 flags;
558	int			 fd;
559	struct sockaddr_storage	 ss;
560	in_port_t		 port;
561	struct timeval		 timeout;
562	struct event		 ev;
563	struct smtpd		*env;
564	char			 ssl_cert_name[PATH_MAX];
565	struct ssl		*ssl;
566	void			*ssl_ctx;
567	TAILQ_ENTRY(listener)	 entry;
568};
569
570struct session_auth_req {
571	u_int64_t	session_id;
572	char		buffer[MAX_LINE_SIZE];
573};
574
575struct session_auth_reply {
576	u_int64_t	session_id;
577	u_int8_t	value;
578};
579
580enum session_flags {
581	F_EHLO		= 0x1,
582	F_QUIT		= 0x2,
583	F_8BITMIME	= 0x4,
584	F_SECURE	= 0x8,
585	F_AUTHENTICATED	= 0x10,
586	F_PEERHASTLS	= 0x20,
587	F_PEERHASAUTH	= 0x40,
588	F_EVLOCKED	= 0x80
589};
590
591struct session {
592	SPLAY_ENTRY(session)		 s_nodes;
593	u_int64_t			 s_id;
594
595	enum session_flags		 s_flags;
596	enum session_state		 s_state;
597	time_t				 s_tm;
598	int				 s_fd;
599	struct sockaddr_storage		 s_ss;
600	char				 s_hostname[MAXHOSTNAMELEN];
601	struct event			 s_ev;
602	struct bufferevent		*s_bev;
603	struct listener			*s_l;
604	struct smtpd			*s_env;
605	void				*s_ssl;
606	u_char				*s_buf;
607	int				 s_buflen;
608	struct timeval			 s_tv;
609	struct message			 s_msg;
610	size_t				 rcptcount;
611
612	struct session_auth_req		 s_auth;
613
614	struct batch			*batch;
615	TAILQ_HEAD(mxhostlist, mxhost) mxhosts;
616
617	FILE				*datafp;
618	int				 mboxfd;
619	int				 messagefd;
620};
621
622struct smtpd {
623#define SMTPD_OPT_VERBOSE			 0x00000001
624#define SMTPD_OPT_NOACTION			 0x00000002
625	u_int32_t				 sc_opts;
626#define SMTPD_CONFIGURING			 0x00000001
627#define SMTPD_EXITING				 0x00000002
628#define SMTPD_MDA_PAUSED		       	 0x00000004
629#define SMTPD_MTA_PAUSED		       	 0x00000008
630#define SMTPD_SMTP_PAUSED		       	 0x00000010
631	u_int32_t				 sc_flags;
632	struct timeval				 sc_qintval;
633	u_int32_t				 sc_maxconn;
634	struct event				 sc_ev;
635	int					 *sc_pipes[PROC_COUNT]
636						     [PROC_COUNT];
637	struct imsgbuf				*sc_ibufs[PROC_COUNT];
638	int					 sc_instances[PROC_COUNT];
639	int					 sc_instance;
640	struct passwd				*sc_pw;
641	char					 sc_hostname[MAXHOSTNAMELEN];
642	TAILQ_HEAD(listenerlist, listener)	 sc_listeners;
643	TAILQ_HEAD(maplist, map)		*sc_maps;
644	TAILQ_HEAD(rulelist, rule)		*sc_rules;
645	SPLAY_HEAD(sessiontree, session)	 sc_sessions;
646	SPLAY_HEAD(msgtree, message)		 sc_messages;
647	SPLAY_HEAD(ssltree, ssl)		 sc_ssl;
648
649	SPLAY_HEAD(batchtree, batch)		batch_queue;
650	SPLAY_HEAD(mdaproctree, mdaproc)	mdaproc_queue;
651	SPLAY_HEAD(lkatree, lkasession)		lka_sessions;
652};
653
654struct s_parent {
655	time_t		start;
656};
657
658struct s_queue {
659	size_t		inserts_local;
660	size_t		inserts_remote;
661};
662
663struct s_runner {
664	size_t		active;
665};
666
667struct s_session {
668	size_t		sessions;
669	size_t		sessions_active;
670
671	size_t		ssmtp;
672	size_t		ssmtp_active;
673
674	size_t		starttls;
675	size_t		starttls_active;
676
677	size_t		aborted;
678};
679
680struct stats {
681	int			fd;
682	union u_stats {
683		struct s_parent	parent;
684		struct s_queue	queue;
685		struct s_runner	runner;
686		struct s_session smtp;
687		struct s_session mta;
688	}			u;
689};
690
691struct sched {
692	int			fd;
693	char			mid[MAX_ID_SIZE];
694	int			ret;
695};
696
697struct submit_status {
698	u_int64_t			 id;
699	int				 code;
700	union submit_path {
701		struct path		 path;
702		char			 msgid[MAX_ID_SIZE];
703		char			 errormsg[MAX_LINE_SIZE];
704	}				 u;
705	enum message_flags		 flags;
706	struct sockaddr_storage		 ss;
707	struct message			 msg;
708};
709
710struct message_recipient {
711	u_int64_t			 id;
712	struct sockaddr_storage		 ss;
713	enum message_flags		 flags;
714	struct path			 path;
715	struct message			 msg;
716};
717
718struct forward_req {
719	u_int64_t			 id;
720	u_int8_t			 status;
721	char				 pw_name[MAXLOGNAME];
722};
723
724struct mxreq {
725	u_int64_t id;
726	char hostname[MAXHOSTNAMELEN];
727	struct rule rule;
728};
729
730struct mxrep {
731	u_int64_t id;
732	int getaddrinfo_error;
733	struct mxhost mxhost;
734};
735
736enum lkasession_flags {
737	F_ERROR		= 0x1
738};
739
740struct lkasession {
741	SPLAY_ENTRY(lkasession)		 nodes;
742	u_int64_t			 id;
743
744	struct path			 path;
745	struct aliaseslist		 aliaseslist;
746	u_int8_t			 iterations;
747	u_int32_t			 pending;
748	enum lkasession_flags		 flags;
749	struct message			 message;
750	struct submit_status		 ss;
751};
752
753/* aliases.c */
754int aliases_exist(struct smtpd *, char *);
755int aliases_get(struct smtpd *, struct aliaseslist *, char *);
756int aliases_virtual_exist(struct smtpd *, struct path *);
757int aliases_virtual_get(struct smtpd *, struct aliaseslist *, struct path *);
758int alias_parse(struct alias *, char *);
759
760
761/* log.c */
762void		log_init(int);
763void		log_warn(const char *, ...)
764    __attribute__ ((format (printf, 1, 2)));
765void		log_warnx(const char *, ...)
766    __attribute__ ((format (printf, 1, 2)));
767void		log_info(const char *, ...)
768    __attribute__ ((format (printf, 1, 2)));
769void		log_debug(const char *, ...)
770    __attribute__ ((format (printf, 1, 2)));
771__dead void	fatal(const char *);
772__dead void	fatalx(const char *);
773
774
775/* buffer.c */
776struct buf	*buf_open(size_t);
777struct buf	*buf_dynamic(size_t, size_t);
778int		 buf_add(struct buf *, void *, size_t);
779void		*buf_reserve(struct buf *, size_t);
780int		 buf_close(struct msgbuf *, struct buf *);
781void		 buf_free(struct buf *);
782void		 msgbuf_init(struct msgbuf *);
783void		 msgbuf_clear(struct msgbuf *);
784int		 msgbuf_write(struct msgbuf *);
785
786
787/* dns.c */
788int		 getmxbyname(char *, char ***);
789
790
791/* forward.c */
792int forwards_get(int, struct aliaseslist *);
793
794
795/* imsg.c */
796void	 imsg_init(struct imsgbuf *, int, void (*)(int, short, void *));
797ssize_t	 imsg_read(struct imsgbuf *);
798ssize_t	 imsg_get(struct imsgbuf *, struct imsg *);
799int	 imsg_compose(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t,
800	    int, void *, u_int16_t);
801int	 imsg_composev(struct imsgbuf *, enum imsg_type, u_int32_t,
802	    pid_t, int, const struct iovec *, int);
803int	 imsg_compose_fds(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t,
804	    void *, u_int16_t, int, ...);
805struct buf *imsg_create(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t,
806	    u_int16_t);
807int	 imsg_add(struct buf *, void *, u_int16_t);
808int	 imsg_append(struct imsgbuf *, struct buf *);
809int	 imsg_close(struct imsgbuf *, struct buf *);
810void	 imsg_free(struct imsg *);
811void	 imsg_event_add(struct imsgbuf *); /* needs to be provided externally */
812int	 imsg_get_fd(struct imsgbuf *, struct imsg *);
813int	 imsg_flush(struct imsgbuf *);
814void	 imsg_clear(struct imsgbuf *);
815
816/* lka.c */
817pid_t		 lka(struct smtpd *);
818int		 lkasession_cmp(struct lkasession *, struct lkasession *);
819SPLAY_PROTOTYPE(lkatree, lkasession, nodes, lkasession_cmp);
820
821/* mfa.c */
822pid_t		 mfa(struct smtpd *);
823int		 msg_cmp(struct message *, struct message *);
824
825/* queue.c */
826pid_t		 queue(struct smtpd *);
827u_int64_t	 queue_generate_id(void);
828int		 queue_remove_batch_message(struct smtpd *, struct batch *,
829 		     struct message *);
830int		 queue_load_envelope(struct message *, char *);
831int		 queue_update_envelope(struct message *);
832int		 queue_remove_envelope(struct message *);
833int		 batch_cmp(struct batch *, struct batch *);
834struct batch    *batch_by_id(struct smtpd *, u_int64_t);
835struct message	*message_by_id(struct smtpd *, struct batch *, u_int64_t);
836u_int16_t	 queue_hash(char *);
837
838/* queue_shared.c */
839int		 queue_create_layout_message(char *, char *);
840void		 queue_delete_layout_message(char *, char *);
841int		 queue_record_layout_envelope(char *, struct message *);
842int		 queue_remove_layout_envelope(char *, struct message *);
843int		 queue_commit_layout_message(char *, struct message *);
844int		 queue_open_layout_messagefile(char *, struct message *);
845int		 enqueue_create_layout(char *);
846void		 enqueue_delete_message(char *);
847int		 enqueue_record_envelope(struct message *);
848int		 enqueue_remove_envelope(struct message *);
849int		 enqueue_commit_message(struct message *);
850int		 enqueue_open_messagefile(struct message *);
851int		 queue_create_incoming_layout(char *);
852void		 queue_delete_incoming_message(char *);
853int		 queue_record_incoming_envelope(struct message *);
854int		 queue_remove_incoming_envelope(struct message *);
855int		 queue_commit_incoming_message(struct message *);
856int		 queue_open_incoming_message_file(struct message *);
857int		 queue_open_message_file(char *msgid);
858void		 queue_message_update(struct message *);
859void		 queue_delete_message(char *);
860struct qwalk	*qwalk_new(char *);
861int		 qwalk(struct qwalk *, char *);
862void		 qwalk_close(struct qwalk *);
863void		 show_queue(char *, int);
864
865u_int16_t	queue_hash(char *);
866
867/* map.c */
868char		*map_dblookup(struct smtpd *, char *, char *);
869
870/* mda.c */
871pid_t		 mda(struct smtpd *);
872int		 mdaproc_cmp(struct mdaproc *, struct mdaproc *);
873SPLAY_PROTOTYPE(mdaproctree, mdaproc, mdaproc_nodes, mdaproc_cmp);
874
875/* mta.c */
876pid_t		 mta(struct smtpd *);
877
878/* control.c */
879pid_t		 control(struct smtpd *);
880void		 session_socket_blockmode(int, enum blockmodes);
881
882/* runner.c */
883pid_t		 runner(struct smtpd *);
884SPLAY_PROTOTYPE(batchtree, batch, b_nodes, batch_cmp);
885
886
887/* smtp.c */
888pid_t		 smtp(struct smtpd *);
889void		 smtp_listener_setup(struct smtpd *, struct listener *);
890
891/* smtp_session.c */
892void		 session_init(struct listener *, struct session *);
893int		 session_cmp(struct session *, struct session *);
894void		 session_pickup(struct session *, struct submit_status *);
895void		 session_destroy(struct session *);
896void		 session_respond(struct session *, char *, ...)
897		    __attribute__ ((format (printf, 2, 3)));
898
899SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp);
900
901/* store.c */
902int store_write_header(struct batch *, struct message *, FILE *, int);
903int store_write_message(struct batch *, struct message *);
904int store_write_daemon(struct batch *, struct message *);
905int store_message(struct batch *, struct message *,
906    int (*)(struct batch *, struct message *));
907
908/* config.c */
909#define		 PURGE_LISTENERS	0x01
910#define		 PURGE_MAPS		0x02
911#define		 PURGE_RULES		0x04
912#define		 PURGE_SSL		0x08
913#define		 PURGE_EVERYTHING	0xff
914void		 purge_config(struct smtpd *, u_int8_t);
915void		 unconfigure(struct smtpd *);
916void		 configure(struct smtpd *);
917void		 init_peers(struct smtpd *);
918void		 config_pipes(struct smtpd *, struct peer *, u_int);
919void		 config_peers(struct smtpd *, struct peer *, u_int);
920
921/* parse.y */
922int		 parse_config(struct smtpd *, const char *, int);
923int		 cmdline_symset(char *);
924
925/* ssl.c */
926void	 ssl_init(void);
927void	 ssl_transaction(struct session *);
928
929void	 ssl_session_init(struct session *);
930void	 ssl_session_destroy(struct session *);
931int	 ssl_load_certfile(struct smtpd *, const char *);
932void	 ssl_setup(struct smtpd *, struct listener *);
933int	 ssl_cmp(struct ssl *, struct ssl *);
934SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp);
935
936/* ssl_privsep.c */
937int	 ssl_ctx_use_private_key(void *, char *, off_t);
938int	 ssl_ctx_use_certificate_chain(void *, char *, off_t);
939
940/* smtpd.c */
941struct map	*map_find(struct smtpd *, objid_t);
942struct map	*map_findbyname(struct smtpd *, const char *);
943
944/* util.c */
945typedef struct arglist arglist;
946struct arglist {
947	char    **list;
948	u_int   num;
949	u_int   nalloc;
950};
951void		 addargs(arglist *, char *, ...)
952		     __attribute__((format(printf, 2, 3)));
953int		 bsnprintf(char *, size_t, const char *, ...)
954    __attribute__ ((format (printf, 3, 4)));
955int		 safe_fclose(FILE *);
956struct passwd 	*safe_getpwnam(const char *);
957struct passwd 	*safe_getpwuid(uid_t);
958int		 hostname_match(char *, char *);
959int		 recipient_to_path(struct path *, char *);
960int		 valid_localpart(char *);
961int		 valid_domainpart(char *);
962char		*ss_to_text(struct sockaddr_storage *);
963int		 valid_message_id(char *);
964int		 valid_message_uid(char *);
965char		*time_to_text(time_t);
966int		 secure_file(int, char *, struct passwd *);
967