1 /*
2  * Copyright (c) 2019 Martijn van Duren <martijn@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 #define _GNU_SOURCE 1
17 
18 #include <sys/time.h>
19 #include <sys/tree.h>
20 #include <sys/socket.h>
21 #include <sys/un.h>
22 
23 #include <arpa/inet.h>
24 #include <netinet/in.h>
25 
26 #include <errno.h>
27 #include <event.h>
28 #include <fcntl.h>
29 #include <inttypes.h>
30 #include <limits.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <syslog.h>
36 #include <unistd.h>
37 
38 #include "openbsd-compat.h"
39 #include "opensmtpd.h"
40 #include "ioev.h"
41 
42 #define NITEMS(x) (sizeof(x) / sizeof(*x))
43 
44 enum osmtpd_session_status {
45 	SESSION_OK = 0,
46 	SESSION_ERROR,
47 	SESSION_DISCONNECTED
48 };
49 
50 struct osmtpd_session {
51 	struct osmtpd_ctx ctx;		/* Must remain first element */
52 	enum osmtpd_session_status status;
53 	RB_ENTRY(osmtpd_session) entry;
54 };
55 
56 struct osmtpd_callback {
57 	enum osmtpd_type type;
58 	enum osmtpd_phase phase;
59 	int incoming;
60 	void (*osmtpd_cb)(struct osmtpd_callback *, struct osmtpd_session *,
61 	    char *, char *);
62 	void *cb;
63 	int doregister;
64 	int storereport;
65 };
66 
67 static void osmtpd_register(enum osmtpd_type, enum osmtpd_phase, int, int,
68     void *);
69 static const char *osmtpd_typetostr(enum osmtpd_type);
70 static const char *osmtpd_phasetostr(enum osmtpd_phase);
71 static enum osmtpd_phase osmtpd_strtophase(const char *, const char *);
72 static void osmtpd_newline(struct io *, int, void *);
73 static void osmtpd_outevt(struct io *, int, void *);
74 static void osmtpd_noargs(struct osmtpd_callback *, struct osmtpd_session *,
75     char *, char *);
76 static void osmtpd_onearg(struct osmtpd_callback *, struct osmtpd_session *,
77     char *, char *);
78 static void osmtpd_connect(struct osmtpd_callback *, struct osmtpd_session *,
79     char *, char *);
80 static void osmtpd_identify(struct osmtpd_callback *, struct osmtpd_session *,
81     char *, char *);
82 static void osmtpd_link_connect(struct osmtpd_callback *, struct osmtpd_session *,
83     char *, char *);
84 static void osmtpd_link_disconnect(struct osmtpd_callback *,
85     struct osmtpd_session *, char *, char *);
86 static void osmtpd_link_greeting(struct osmtpd_callback *, struct osmtpd_session *,
87     char *, char *);
88 static void osmtpd_link_identify(struct osmtpd_callback *, struct osmtpd_session *,
89     char *, char *);
90 static void osmtpd_link_tls(struct osmtpd_callback *, struct osmtpd_session *,
91     char *, char *);
92 static void osmtpd_link_auth(struct osmtpd_callback *, struct osmtpd_session *,
93     char *, char *);
94 static void osmtpd_tx_reset(struct osmtpd_callback *, struct osmtpd_session *,
95     char *, char *);
96 static void osmtpd_tx_begin(struct osmtpd_callback *, struct osmtpd_session *,
97     char *, char *);
98 static void osmtpd_tx_mail(struct osmtpd_callback *, struct osmtpd_session *,
99     char *, char *);
100 static void osmtpd_tx_rcpt(struct osmtpd_callback *, struct osmtpd_session *,
101     char *, char *);
102 static void osmtpd_tx_envelope(struct osmtpd_callback *, struct osmtpd_session *,
103     char *, char *);
104 static void osmtpd_tx_data(struct osmtpd_callback *, struct osmtpd_session *,
105     char *, char *);
106 static void osmtpd_tx_commit(struct osmtpd_callback *, struct osmtpd_session *,
107     char *, char *);
108 static void osmtpd_tx_rollback(struct osmtpd_callback *, struct osmtpd_session *,
109     char *, char *);
110 static void osmtpd_addrtoss(char *, struct sockaddr_storage *, int, char *);
111 static enum osmtpd_status osmtpd_strtostatus(const char *, char *);
112 static int osmtpd_session_cmp(struct osmtpd_session *, struct osmtpd_session *);
113 static void *(*oncreatecb_session)(struct osmtpd_ctx *) = NULL;
114 static void (*ondeletecb_session)(struct osmtpd_ctx *, void *) = NULL;
115 static void *(*oncreatecb_message)(struct osmtpd_ctx *) = NULL;
116 static void (*ondeletecb_message)(struct osmtpd_ctx *, void *) = NULL;
117 static void (*conf_cb)(const char *, const char *);
118 
119 static struct osmtpd_callback osmtpd_callbacks[] = {
120 	{
121 	    OSMTPD_TYPE_FILTER,
122 	    OSMTPD_PHASE_CONNECT,
123 	    1,
124 	    osmtpd_connect,
125 	    NULL,
126 	    0,
127 	    0
128 	},
129 	{
130 	    OSMTPD_TYPE_FILTER,
131 	    OSMTPD_PHASE_HELO,
132 	    1,
133 	    osmtpd_identify,
134 	    NULL,
135 	    0,
136 	    0
137 	},
138 	{
139 	    OSMTPD_TYPE_FILTER,
140 	    OSMTPD_PHASE_EHLO,
141 	    1,
142 	    osmtpd_identify,
143 	    NULL,
144 	    0,
145 	    0
146 	},
147 	{
148 	    OSMTPD_TYPE_FILTER,
149 	    OSMTPD_PHASE_STARTTLS,
150 	    1,
151 	    osmtpd_noargs,
152 	    NULL,
153 	    0,
154 	    0
155 	},
156 	{
157 	    OSMTPD_TYPE_FILTER,
158 	    OSMTPD_PHASE_AUTH,
159 	    1,
160 	    osmtpd_onearg,
161 	    NULL,
162 	    0,
163 	    0
164 	},
165 	{
166 	    OSMTPD_TYPE_FILTER,
167 	    OSMTPD_PHASE_MAIL_FROM,
168 	    1,
169 	    osmtpd_onearg,
170 	    NULL,
171 	    0,
172 	    0
173 	},
174 	{
175 	    OSMTPD_TYPE_FILTER,
176 	    OSMTPD_PHASE_RCPT_TO,
177 	    1,
178 	    osmtpd_onearg,
179 	    NULL,
180 	    0,
181 	    0
182 	},
183 	{
184 	    OSMTPD_TYPE_FILTER,
185 	    OSMTPD_PHASE_DATA,
186 	    1,
187 	    osmtpd_noargs,
188 	    NULL,
189 	    0,
190 	    0
191 	},
192 	{
193 	    OSMTPD_TYPE_FILTER,
194 	    OSMTPD_PHASE_DATA_LINE,
195 	    1,
196 	    osmtpd_onearg,
197 	    NULL,
198 	    0,
199 	    0
200 	},
201 	{
202 	    OSMTPD_TYPE_FILTER,
203 	    OSMTPD_PHASE_RSET,
204 	    1,
205 	    osmtpd_noargs,
206 	    NULL,
207 	    0,
208 	    0
209 	},
210 	{
211 	    OSMTPD_TYPE_FILTER,
212 	    OSMTPD_PHASE_QUIT,
213 	    1,
214 	    osmtpd_noargs,
215 	    NULL,
216 	    0,
217 	    0
218 	},
219 	{
220 	    OSMTPD_TYPE_FILTER,
221 	    OSMTPD_PHASE_NOOP,
222 	    1,
223 	    osmtpd_noargs,
224 	    NULL,
225 	    0,
226 	    0
227 	},
228 	{
229 	    OSMTPD_TYPE_FILTER,
230 	    OSMTPD_PHASE_HELP,
231 	    1,
232 	    osmtpd_noargs,
233 	    NULL,
234 	    0,
235 	    0
236 	},
237 	{
238 	    OSMTPD_TYPE_FILTER,
239 	    OSMTPD_PHASE_WIZ,
240 	    1,
241 	    osmtpd_noargs,
242 	    NULL,
243 	    0,
244 	    0
245 	},
246 	{
247 	    OSMTPD_TYPE_FILTER,
248 	    OSMTPD_PHASE_COMMIT,
249 	    1,
250 	    osmtpd_noargs,
251 	    NULL,
252 	    0,
253 	    0
254 	},
255 	{
256 	    OSMTPD_TYPE_REPORT,
257 	    OSMTPD_PHASE_LINK_CONNECT,
258 	    1,
259 	    osmtpd_link_connect,
260 	    NULL,
261 	    0,
262 	    0
263 	},
264 	{
265 	    OSMTPD_TYPE_REPORT,
266 	    OSMTPD_PHASE_LINK_DISCONNECT,
267 	    1,
268 	    osmtpd_link_disconnect,
269 	    NULL,
270 	    0,
271 	    0
272 	},
273 	{
274 	    OSMTPD_TYPE_REPORT,
275 	    OSMTPD_PHASE_LINK_GREETING,
276 	    1,
277 	    osmtpd_link_greeting,
278 	    NULL,
279 	    0,
280 	    0
281 	},
282 	{
283 	    OSMTPD_TYPE_REPORT,
284 	    OSMTPD_PHASE_LINK_IDENTIFY,
285 	    1,
286 	    osmtpd_link_identify,
287 	    NULL,
288 	    0,
289 	    0
290 	},
291 	{
292 	    OSMTPD_TYPE_REPORT,
293 	    OSMTPD_PHASE_LINK_TLS,
294 	    1,
295 	    osmtpd_link_tls,
296 	    NULL,
297 	    0,
298 	    0
299 	},
300 	{
301 	    OSMTPD_TYPE_REPORT,
302 	    OSMTPD_PHASE_LINK_AUTH,
303 	    1,
304 	    osmtpd_link_auth,
305 	    NULL,
306 	    0,
307 	    0
308 	},
309 	{
310 	    OSMTPD_TYPE_REPORT,
311 	    OSMTPD_PHASE_TX_RESET,
312 	    1,
313 	    osmtpd_tx_reset,
314 	    NULL,
315 	    0,
316 	    0
317 	},
318 	{
319 	    OSMTPD_TYPE_REPORT,
320 	    OSMTPD_PHASE_TX_BEGIN,
321 	    1,
322 	    osmtpd_tx_begin,
323 	    NULL,
324 	    0,
325 	    0
326 	},
327 	{
328 	    OSMTPD_TYPE_REPORT,
329 	    OSMTPD_PHASE_TX_MAIL,
330 	    1,
331 	    osmtpd_tx_mail,
332 	    NULL,
333 	    0,
334 	    0
335 	},
336 	{
337 	    OSMTPD_TYPE_REPORT,
338 	    OSMTPD_PHASE_TX_RCPT,
339 	    1,
340 	    osmtpd_tx_rcpt,
341 	    NULL,
342 	    0,
343 	    0
344 	},
345 	{
346 	    OSMTPD_TYPE_REPORT,
347 	    OSMTPD_PHASE_TX_ENVELOPE,
348 	    1,
349 	    osmtpd_tx_envelope,
350 	    NULL,
351 	    0,
352 	   0
353 	},
354 	{
355 	    OSMTPD_TYPE_REPORT,
356 	    OSMTPD_PHASE_TX_DATA,
357 	    1,
358 	    osmtpd_tx_data,
359 	    NULL,
360 	    0,
361 	    0
362 	},
363 	{
364 	    OSMTPD_TYPE_REPORT,
365 	    OSMTPD_PHASE_TX_COMMIT,
366 	    1,
367 	    osmtpd_tx_commit,
368 	    NULL,
369 	    0,
370 	    0
371 	},
372 	{
373 	    OSMTPD_TYPE_REPORT,
374 	    OSMTPD_PHASE_TX_ROLLBACK,
375 	    1,
376 	    osmtpd_tx_rollback,
377 	    NULL,
378 	    0,
379 	    0
380 	},
381 	{
382 	    OSMTPD_TYPE_REPORT,
383 	    OSMTPD_PHASE_PROTOCOL_CLIENT,
384 	    1,
385 	    osmtpd_onearg,
386 	    NULL,
387 	    0,
388 	    0
389 	},
390 	{
391 	    OSMTPD_TYPE_REPORT,
392 	    OSMTPD_PHASE_PROTOCOL_SERVER,
393 	    1,
394 	    osmtpd_onearg,
395 	    NULL,
396 	    0,
397 	    0
398 	},
399 	{
400 	    OSMTPD_TYPE_REPORT,
401 	    OSMTPD_PHASE_FILTER_RESPONSE,
402 	    1,
403 	    osmtpd_onearg,
404 	    NULL,
405 	    0,
406 	    0
407 	},
408 	{
409 	    OSMTPD_TYPE_REPORT,
410 	    OSMTPD_PHASE_TIMEOUT,
411 	    1,
412 	    osmtpd_noargs,
413 	    NULL,
414 	    0,
415 	    0
416 	},
417 	{
418 	    OSMTPD_TYPE_REPORT,
419 	    OSMTPD_PHASE_LINK_CONNECT,
420 	    0,
421 	    osmtpd_link_connect,
422 	    NULL,
423 	    0,
424 	    0
425 	},
426 	{
427 	    OSMTPD_TYPE_REPORT,
428 	    OSMTPD_PHASE_LINK_DISCONNECT,
429 	    0,
430 	    osmtpd_link_disconnect,
431 	    NULL,
432 	    0,
433 	    0
434 	},
435 	{
436 	    OSMTPD_TYPE_REPORT,
437 	    OSMTPD_PHASE_LINK_GREETING,
438 	    0,
439 	    osmtpd_link_greeting,
440 	    NULL,
441 	    0,
442 	    0
443 	},
444 	{
445 	    OSMTPD_TYPE_REPORT,
446 	    OSMTPD_PHASE_LINK_IDENTIFY,
447 	    0,
448 	    osmtpd_link_identify,
449 	    NULL,
450 	    0,
451 	    0
452 	},
453 	{
454 	    OSMTPD_TYPE_REPORT,
455 	    OSMTPD_PHASE_LINK_TLS,
456 	    0,
457 	    osmtpd_link_tls,
458 	    NULL,
459 	    0,
460 	    0
461 	},
462 	{
463 	    OSMTPD_TYPE_REPORT,
464 	    OSMTPD_PHASE_LINK_AUTH,
465 	    0,
466 	    osmtpd_link_auth,
467 	    NULL,
468 	    0,
469 	    0
470 	},
471 	{
472 	    OSMTPD_TYPE_REPORT,
473 	    OSMTPD_PHASE_TX_RESET,
474 	    0,
475 	    osmtpd_tx_reset,
476 	    NULL,
477 	    0,
478 	    0
479 	},
480 	{
481 	    OSMTPD_TYPE_REPORT,
482 	    OSMTPD_PHASE_TX_BEGIN,
483 	    0,
484 	    osmtpd_tx_begin,
485 	    NULL,
486 	    0,
487 	    0
488 	},
489 	{
490 	    OSMTPD_TYPE_REPORT,
491 	    OSMTPD_PHASE_TX_MAIL,
492 	    0,
493 	    osmtpd_tx_mail,
494 	    NULL,
495 	    0,
496 	    0
497 	},
498 	{
499 	    OSMTPD_TYPE_REPORT,
500 	    OSMTPD_PHASE_TX_RCPT,
501 	    0,
502 	    osmtpd_tx_rcpt,
503 	    NULL,
504 	    0,
505 	    0
506 	},
507 	{
508 	    OSMTPD_TYPE_REPORT,
509 	    OSMTPD_PHASE_TX_ENVELOPE,
510 	    0,
511 	    osmtpd_tx_envelope,
512 	    NULL,
513 	    0,
514 	    0
515 	},
516 	{
517 	    OSMTPD_TYPE_REPORT,
518 	    OSMTPD_PHASE_TX_DATA,
519 	    0,
520 	    osmtpd_tx_data,
521 	    NULL,
522 	    0,
523 	    0
524 	},
525 	{
526 	    OSMTPD_TYPE_REPORT,
527 	    OSMTPD_PHASE_TX_COMMIT,
528 	    0,
529 	    osmtpd_tx_commit,
530 	    NULL,
531 	    0,
532 	    0
533 	},
534 	{
535 	    OSMTPD_TYPE_REPORT,
536 	    OSMTPD_PHASE_TX_ROLLBACK,
537 	    0,
538 	    osmtpd_tx_rollback,
539 	    NULL,
540 	    0,
541 	    0
542 	},
543 	{
544 	    OSMTPD_TYPE_REPORT,
545 	    OSMTPD_PHASE_PROTOCOL_CLIENT,
546 	    0,
547 	    osmtpd_onearg,
548 	    NULL,
549 	    0,
550 	    0
551 	},
552 	{
553 	    OSMTPD_TYPE_REPORT,
554 	    OSMTPD_PHASE_PROTOCOL_SERVER,
555 	    0,
556 	    osmtpd_onearg,
557 	    NULL,
558 	    0,
559 	    0
560 	},
561 	{
562 	    OSMTPD_TYPE_REPORT,
563 	    OSMTPD_PHASE_FILTER_RESPONSE,
564 	    0,
565 	    osmtpd_onearg,
566 	    NULL,
567 	    0,
568 	    0
569 	},
570 	{
571 	    OSMTPD_TYPE_REPORT,
572 	    OSMTPD_PHASE_TIMEOUT,
573 	    0,
574 	    osmtpd_noargs,
575 	    NULL,
576 	    0,
577 	    0
578 	}
579 };
580 
581 static struct io *io_stdout;
582 static int needs;
583 static int ready = 0;
584 /* Default from smtpd */
585 static int session_timeout = 300;
586 int version_major, version_minor;
587 
588 RB_HEAD(osmtpd_sessions, osmtpd_session) osmtpd_sessions = RB_INITIALIZER(NULL);
589 RB_PROTOTYPE_STATIC(osmtpd_sessions, osmtpd_session, entry, osmtpd_session_cmp);
590 
591 void
592 osmtpd_register_conf(void (*cb)(const char *, const char *))
593 {
594 	conf_cb = cb;
595 }
596 
597 void
598 osmtpd_register_filter_connect(int (*cb)(struct osmtpd_ctx *, const char *,
599     struct sockaddr_storage *))
600 {
601 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_CONNECT, 1, 0,
602 	    (void *)cb);
603 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
604 	    NULL);
605 }
606 
607 void
608 osmtpd_register_filter_helo(int (*cb)(struct osmtpd_ctx *, const char *))
609 {
610 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_HELO, 1, 0,
611 	    (void *)cb);
612 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
613 	    NULL);
614 }
615 
616 void
617 osmtpd_register_filter_ehlo(int (*cb)(struct osmtpd_ctx *, const char *))
618 {
619 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_EHLO, 1, 0,
620 	    (void *)cb);
621 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
622 	    NULL);
623 }
624 
625 void
626 osmtpd_register_filter_starttls(int (*cb)(struct osmtpd_ctx *))
627 {
628 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_STARTTLS, 1, 0,
629 	    (void *)cb);
630 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
631 	    NULL);
632 }
633 
634 void
635 osmtpd_register_filter_auth(int (*cb)(struct osmtpd_ctx *, const char *))
636 {
637 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_AUTH, 1, 0,
638 	    (void *)cb);
639 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
640 	    NULL);
641 }
642 
643 void
644 osmtpd_register_filter_mailfrom(int (*cb)(struct osmtpd_ctx *, const char *))
645 {
646 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_MAIL_FROM, 1, 0,
647 	    (void *)cb);
648 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
649 	    NULL);
650 }
651 
652 void
653 osmtpd_register_filter_rcptto(int (*cb)(struct osmtpd_ctx *, const char *))
654 {
655 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_RCPT_TO, 1, 0,
656 	    (void *)cb);
657 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
658 	    NULL);
659 }
660 
661 void
662 osmtpd_register_filter_data(int (*cb)(struct osmtpd_ctx *))
663 {
664 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_DATA, 1, 0,
665 	    (void *)cb);
666 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
667 	    NULL);
668 }
669 
670 void
671 osmtpd_register_filter_dataline(int (*cb)(struct osmtpd_ctx *, const char *))
672 {
673 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_DATA_LINE, 1, 0,
674 	    (void *)cb);
675 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
676 	    NULL);
677 }
678 
679 void
680 osmtpd_register_filter_rset(int (*cb)(struct osmtpd_ctx *))
681 {
682 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_RSET, 1, 0,
683 	    (void *)cb);
684 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
685 	    NULL);
686 }
687 
688 void
689 osmtpd_register_filter_quit(int (*cb)(struct osmtpd_ctx *))
690 {
691 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_QUIT, 1, 0,
692 	    (void *)cb);
693 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
694 	    NULL);
695 }
696 
697 void
698 osmtpd_register_filter_noop(int (*cb)(struct osmtpd_ctx *))
699 {
700 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_NOOP, 1, 0,
701 	    (void *)cb);
702 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
703 	    NULL);
704 }
705 
706 void
707 osmtpd_register_filter_help(int (*cb)(struct osmtpd_ctx *))
708 {
709 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_HELP, 1, 0,
710 	    (void *)cb);
711 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
712 	    NULL);
713 }
714 
715 void
716 osmtpd_register_filter_wiz(int (*cb)(struct osmtpd_ctx *))
717 {
718 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_WIZ, 1, 0,
719 	    (void *)cb);
720 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
721 	    NULL);
722 }
723 
724 void
725 osmtpd_register_filter_commit(int (*cb)(struct osmtpd_ctx *))
726 {
727 	osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_COMMIT, 1, 0,
728 	    (void *)cb);
729 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
730 	    NULL);
731 }
732 
733 void
734 osmtpd_register_report_connect(int incoming, int (*cb)(struct osmtpd_ctx *,
735     const char *, enum osmtpd_status, struct sockaddr_storage *,
736     struct sockaddr_storage *))
737 {
738 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_CONNECT, incoming,
739 	    0, (void *)cb);
740 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
741 	    incoming, 0, NULL);
742 }
743 
744 void
745 osmtpd_register_report_disconnect(int incoming, int (*cb)(struct osmtpd_ctx *))
746 {
747 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
748 	    incoming, 0, (void *)cb);
749 }
750 
751 void
752 osmtpd_register_report_identify(int incoming, int (*cb)(struct osmtpd_ctx *,
753     const char *))
754 {
755 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_IDENTIFY,
756 	    incoming, 0, (void *)cb);
757 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
758 	    incoming, 0, NULL);
759 }
760 
761 void
762 osmtpd_register_report_tls(int incoming, int (*cb)(struct osmtpd_ctx *,
763     const char *))
764 {
765 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_TLS, incoming, 0,
766 	    (void *)cb);
767 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
768 	    incoming, 0, NULL);
769 }
770 
771 void
772 osmtpd_register_report_auth(int incoming, int (*cb)(struct osmtpd_ctx *,
773     const char *, enum osmtpd_auth_status))
774 {
775 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_AUTH, incoming, 0,
776 	    (void *)cb);
777 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
778 	    incoming, 0, NULL);
779 }
780 
781 void
782 osmtpd_register_report_reset(int incoming, int (*cb)(struct osmtpd_ctx *,
783     uint32_t))
784 {
785 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RESET, incoming, 0,
786 	    (void *)cb);
787 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
788 	    incoming, 0, NULL);
789 }
790 
791 void
792 osmtpd_register_report_begin(int incoming, int (*cb)(struct osmtpd_ctx *,
793     uint32_t))
794 {
795 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_BEGIN, incoming, 0,
796 	    (void *)cb);
797 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
798 	    incoming, 0, NULL);
799 }
800 
801 void
802 osmtpd_register_report_mail(int incoming, int (*cb)(struct osmtpd_ctx *,
803     uint32_t, const char *, enum osmtpd_status))
804 {
805 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_MAIL, incoming, 0,
806 	    (void *)cb);
807 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
808 	    incoming, 0, NULL);
809 }
810 
811 void
812 osmtpd_register_report_rcpt(int incoming, int (*cb)(struct osmtpd_ctx *,
813     uint32_t, const char *, enum osmtpd_status))
814 {
815 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RCPT, incoming, 0,
816 	    (void *)cb);
817 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
818 	    incoming, 0, NULL);
819 }
820 
821 void
822 osmtpd_register_report_envelope(int incoming, int (*cb)(struct osmtpd_ctx *,
823     uint32_t, uint64_t))
824 {
825 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ENVELOPE, incoming,
826 	    0, (void *)cb);
827 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
828 	    incoming, 0, NULL);
829 }
830 
831 void
832 osmtpd_register_report_data(int incoming, int (*cb)(struct osmtpd_ctx *,
833     uint32_t, enum osmtpd_status))
834 {
835 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_DATA, incoming, 0,
836 	    (void *)cb);
837 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
838 	    incoming, 0, NULL);
839 }
840 
841 void
842 osmtpd_register_report_commit(int incoming, int (*cb)(struct osmtpd_ctx *,
843     uint32_t, size_t))
844 {
845 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_COMMIT, incoming, 0,
846 	    (void *)cb);
847 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
848 	    incoming, 0, NULL);
849 }
850 
851 void
852 osmtpd_register_report_rollback(int incoming, int (*cb)(struct osmtpd_ctx *,
853     uint32_t))
854 {
855 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ROLLBACK, incoming,
856 	    0, (void *)cb);
857 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
858 	    incoming, 0, NULL);
859 }
860 
861 void
862 osmtpd_register_report_client(int incoming, int (*cb)(struct osmtpd_ctx *,
863     const char *))
864 {
865 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_PROTOCOL_CLIENT,
866 	    incoming, 0, (void *)cb);
867 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
868 	    incoming, 0, NULL);
869 }
870 
871 void
872 osmtpd_register_report_server(int incoming, int (*cb)(struct osmtpd_ctx *,
873     const char *))
874 {
875 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_PROTOCOL_SERVER,
876 	    incoming, 0, (void *)cb);
877 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
878 	    incoming, 0, NULL);
879 }
880 
881 void
882 osmtpd_register_report_response(int incoming, int (*cb)(struct osmtpd_ctx *,
883     const char *))
884 {
885 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_FILTER_RESPONSE,
886 	    incoming, 0, (void *)cb);
887 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
888 	    incoming, 0, NULL);
889 }
890 
891 void
892 osmtpd_register_report_timeout(int incoming, int (*cb)(struct osmtpd_ctx *))
893 {
894 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TIMEOUT, incoming, 0,
895 	    (void *)cb);
896 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
897 	    incoming, 0, NULL);
898 }
899 
900 void
901 osmtpd_local_session(void *(*oncreate)(struct osmtpd_ctx *),
902     void (*ondelete)(struct osmtpd_ctx *, void *))
903 {
904 	oncreatecb_session = oncreate;
905 	ondeletecb_session = ondelete;
906 }
907 
908 void
909 osmtpd_local_message(void *(*oncreate)(struct osmtpd_ctx *),
910     void (*ondelete)(struct osmtpd_ctx *, void *))
911 {
912 	oncreatecb_message = oncreate;
913 	ondeletecb_message = ondelete;
914 }
915 
916 void
917 osmtpd_need(int lneeds)
918 {
919 	needs |= lneeds;
920 }
921 
922 static void
923 osmtpd_register_need(int incoming)
924 {
925 	if (needs & (OSMTPD_NEED_SRC | OSMTPD_NEED_DST | OSMTPD_NEED_RDNS |
926 	    OSMTPD_NEED_FCRDNS))
927 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_CONNECT,
928 		    incoming, 1, NULL);
929 	if (needs & OSMTPD_NEED_GREETING)
930 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_GREETING,
931 		    incoming, 1, NULL);
932 	if (needs & OSMTPD_NEED_IDENTITY)
933 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_IDENTIFY,
934 		    incoming, 1, NULL);
935 	if (needs & OSMTPD_NEED_CIPHERS)
936 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_TLS,
937 		    incoming, 1, NULL);
938 	if (needs & OSMTPD_NEED_USERNAME)
939 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_AUTH,
940 		    incoming, 1, NULL);
941 	if (needs & OSMTPD_NEED_MSGID) {
942 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_BEGIN,
943 		    incoming, 1, NULL);
944 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RESET,
945 		    incoming, 0, NULL);
946 	}
947 	if (needs & OSMTPD_NEED_MAILFROM) {
948 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_MAIL,
949 		    incoming, 1, NULL);
950 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RESET,
951 		    incoming, 0, NULL);
952 	}
953 	if (needs & OSMTPD_NEED_RCPTTO) {
954 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RCPT,
955 		    incoming, 1, NULL);
956 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RESET,
957 		    incoming, 0, NULL);
958 	}
959 	if (needs & OSMTPD_NEED_EVPID) {
960 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ENVELOPE,
961 		    incoming, 1, NULL);
962 		osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RESET,
963 		    incoming, 0, NULL);
964 	}
965 
966 	osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
967 	    incoming, 0, NULL);
968 }
969 
970 void
971 osmtpd_run(void)
972 {
973 	size_t i = 0;
974 	int registered = 0;
975 	struct event_base *evbase;
976 	struct io *io_stdin;
977 	struct osmtpd_callback *hidenity = NULL, *eidentity = NULL;
978 	struct osmtpd_callback *ridentity = NULL;
979 
980 	evbase = event_init();
981 
982 	if ((io_stdin = io_new()) == NULL ||
983 	    (io_stdout = io_new()) == NULL)
984 		osmtpd_err(1, "io_new");
985 	io_set_nonblocking(STDIN_FILENO);
986 	io_set_fd(io_stdin, STDIN_FILENO);
987 	io_set_callback(io_stdin, osmtpd_newline, NULL);
988 	io_set_read(io_stdin);
989 	io_set_nonblocking(STDOUT_FILENO);
990 	io_set_fd(io_stdout, STDOUT_FILENO);
991 	io_set_callback(io_stdout, osmtpd_outevt, NULL);
992 	io_set_write(io_stdout);
993 
994 	for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
995 		if (osmtpd_callbacks[i].doregister) {
996 			osmtpd_register_need(osmtpd_callbacks[i].incoming);
997 			if (oncreatecb_message != NULL) {
998 				osmtpd_register(OSMTPD_TYPE_REPORT,
999 				    OSMTPD_PHASE_TX_BEGIN,
1000 				    osmtpd_callbacks[i].incoming, 0, NULL);
1001 				osmtpd_register(OSMTPD_TYPE_REPORT,
1002 				    OSMTPD_PHASE_TX_RESET,
1003 				    osmtpd_callbacks[i].incoming, 0, NULL);
1004 			}
1005 			if (osmtpd_callbacks[i].type == OSMTPD_TYPE_FILTER &&
1006 			    osmtpd_callbacks[i].phase == OSMTPD_PHASE_HELO)
1007 				hidenity = &(osmtpd_callbacks[i]);
1008 			if (osmtpd_callbacks[i].type == OSMTPD_TYPE_FILTER &&
1009 			    osmtpd_callbacks[i].phase == OSMTPD_PHASE_EHLO)
1010 				eidentity = &(osmtpd_callbacks[i]);
1011 			if (osmtpd_callbacks[i].type == OSMTPD_TYPE_REPORT &&
1012 			    osmtpd_callbacks[i].phase ==
1013 			    OSMTPD_PHASE_LINK_IDENTIFY &&
1014 			    osmtpd_callbacks[i].incoming == 1)
1015 				ridentity = &(osmtpd_callbacks[i]);
1016 		}
1017 	}
1018 	if (ridentity != NULL && ridentity->storereport) {
1019 		if (hidenity != NULL && hidenity->doregister)
1020 			hidenity->storereport = 1;
1021 		if (eidentity != NULL && eidentity->doregister)
1022 			eidentity->storereport = 1;
1023 	}
1024 	for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
1025 		if (osmtpd_callbacks[i].doregister) {
1026 			if (osmtpd_callbacks[i].cb != NULL)
1027 				registered = 1;
1028 			io_printf(io_stdout, "register|%s|smtp-%s|%s\n",
1029 			    osmtpd_typetostr(osmtpd_callbacks[i].type),
1030 			    osmtpd_callbacks[i].incoming ? "in" : "out",
1031 			    osmtpd_phasetostr(osmtpd_callbacks[i].phase));
1032 		}
1033 	}
1034 
1035 	if (!registered)
1036 		osmtpd_errx(1, "No events registered");
1037 	io_printf(io_stdout, "register|ready\n");
1038 	ready = 1;
1039 
1040 	event_dispatch();
1041 	io_free(io_stdin);
1042 	io_free(io_stdout);
1043 	event_base_free(evbase);
1044 }
1045 
1046 __dead void
1047 osmtpd_err(int eval, const char *fmt, ...)
1048 {
1049 	va_list ap;
1050 
1051 	if (version_major == 0 && version_minor >= 8)
1052 		fprintf(stderr, "FATAL|");
1053 	va_start(ap, fmt);
1054 	vfprintf(stderr, fmt, ap);
1055 	va_end(ap);
1056 	fprintf(stderr, ": %s\n", strerror(errno));
1057 	exit(eval);
1058 }
1059 
1060 __dead void
1061 osmtpd_errx(int eval, const char *fmt, ...)
1062 {
1063 	va_list ap;
1064 
1065 	if (version_major == 0 && version_minor >= 8)
1066 		fprintf(stderr, "FATAL|");
1067 	va_start(ap, fmt);
1068 	vfprintf(stderr, fmt, ap);
1069 	va_end(ap);
1070 	fprintf(stderr, "\n");
1071 	exit(eval);
1072 }
1073 
1074 void
1075 osmtpd_warn(struct osmtpd_ctx *ctx, const char *fmt, ...)
1076 {
1077 	va_list ap;
1078 
1079 	if (version_major == 0 && version_minor >= 8)
1080 		fprintf(stderr, "WARN|");
1081 	if (ctx)
1082 		fprintf(stderr, "%016"PRIx64" ", ctx->reqid);
1083 	va_start(ap, fmt);
1084 	vfprintf(stderr, fmt, ap);
1085 	va_end(ap);
1086 	fprintf(stderr, ": %s\n", strerror(errno));
1087 }
1088 
1089 void
1090 osmtpd_warnx(struct osmtpd_ctx *ctx, const char *fmt, ...)
1091 {
1092 	va_list ap;
1093 
1094 	if (version_major == 0 && version_minor >= 8)
1095 		fprintf(stderr, "WARN|");
1096 	if (ctx)
1097 		fprintf(stderr, "%016"PRIx64" ", ctx->reqid);
1098 	va_start(ap, fmt);
1099 	vfprintf(stderr, fmt, ap);
1100 	va_end(ap);
1101 	fprintf(stderr, "\n");
1102 }
1103 
1104 void
1105 osmtpd_info(struct osmtpd_ctx *ctx, const char *fmt, ...)
1106 {
1107 	va_list ap;
1108 
1109 	if (version_major == 0 && version_minor >= 8)
1110 		fprintf(stderr, "INFO|");
1111 	if (ctx)
1112 		fprintf(stderr, "%016"PRIx64" ", ctx->reqid);
1113 	va_start(ap, fmt);
1114 	vfprintf(stderr, fmt, ap);
1115 	va_end(ap);
1116 	fprintf(stderr, "\n");
1117 }
1118 
1119 void
1120 osmtpd_debug(struct osmtpd_ctx *ctx, const char *fmt, ...)
1121 {
1122 	va_list ap;
1123 
1124 	if (version_major == 0 && version_minor >= 8)
1125 		fprintf(stderr, "DEBUG|");
1126 	if (ctx)
1127 		fprintf(stderr, "%016"PRIx64" ", ctx->reqid);
1128 	va_start(ap, fmt);
1129 	vfprintf(stderr, fmt, ap);
1130 	va_end(ap);
1131 	fprintf(stderr, "\n");
1132 }
1133 
1134 static void
1135 osmtpd_newline(struct io *io, int ev, __unused void *arg)
1136 {
1137 	static char *linedup = NULL;
1138 	static size_t dupsize = 0;
1139 	struct osmtpd_session *ctx, search;
1140 	enum osmtpd_type type;
1141 	enum osmtpd_phase phase;
1142 	int major, minor, incoming;
1143 	struct timespec tm;
1144 	char *line = NULL;
1145 	const char *errstr = NULL;
1146 	size_t linelen;
1147 	char *end;
1148 	size_t i;
1149 
1150 	if (ev == IO_DISCONNECTED) {
1151 		event_loopexit(0);
1152 		return;
1153 	}
1154 	if (ev != IO_DATAIN)
1155 		return;
1156 	/*
1157 	 * Multiple calls to io_printf (through osmtpd_filter_dataline) can
1158 	 * cause a build-up of kevents, because of event_add/event_del loop.
1159 	 */
1160 	io_pause(io_stdout, IO_OUT);
1161 	while ((line = io_getline(io, &linelen)) != NULL) {
1162 		if (dupsize < linelen) {
1163 			if ((linedup = realloc(linedup, linelen + 1)) == NULL)
1164 				osmtpd_err(1, NULL);
1165 			dupsize = linelen + 1;
1166 		}
1167 		strlcpy(linedup, line, dupsize);
1168 		if ((end = strchr(line, '|')) == NULL)
1169 			osmtpd_errx(1, "Invalid line received: missing "
1170 			    "version: %s", linedup);
1171 		end++[0] = '\0';
1172 		if (strcmp(line, "filter") == 0)
1173 			type = OSMTPD_TYPE_FILTER;
1174 		else if (strcmp(line, "report") == 0)
1175 			type = OSMTPD_TYPE_REPORT;
1176 		else if (strcmp(line, "config") == 0) {
1177 			line = end;
1178 			if (strcmp(line, "ready") == 0) {
1179 				if (conf_cb != NULL)
1180 					conf_cb(NULL, NULL);
1181 				continue;
1182 			}
1183 			if ((end = strchr(line, '|')) == NULL)
1184 				osmtpd_errx(1, "Invalid line received: missing "
1185 				    "key: %s", linedup);
1186 			end++[0] = '\0';
1187 			if (conf_cb != NULL)
1188 				conf_cb(line, end);
1189 			if (strcmp(line, "smtp-session-timeout") == 0) {
1190 				session_timeout = strtonum(end, 0, INT_MAX,
1191 				    &errstr);
1192 				if (errstr != NULL)
1193 					osmtpd_errx(1, "Invalid line received: "
1194 					    "invalid smtp-sesion-timeout: %s",
1195 					    linedup);
1196 			}
1197 			continue;
1198 		}
1199 		else
1200 			osmtpd_errx(1, "Invalid line received: unknown message "
1201 			    "type: %s", linedup);
1202 		line = end;
1203 		major = strtoul(line, &end, 10);
1204 		if (line == end || end[0] != '.')
1205 			osmtpd_errx(1, "Invalid protocol received: %s",
1206 			    linedup);
1207 		line = end + 1;
1208 		minor = strtoul(line, &end, 10);
1209 		if (end[0] == '\0')
1210 			osmtpd_errx(1, "Invalid line received: missing time: "
1211 			    "%s", linedup);
1212 		if (line == end || end[0] != '|')
1213 			osmtpd_errx(1, "Invalid protocol received: %s",
1214 			    linedup);
1215 		if (major != 0)
1216 			osmtpd_errx(1, "Unsupported protocol received: %s",
1217 			    linedup);
1218 		if (version_major == 0 && version_minor == 0) {
1219 			version_major = major;
1220 			version_minor = minor;
1221 		} else {
1222 			if (version_major != major && version_minor != minor)
1223 				osmtpd_errx(1, "Unexpected protocol version "
1224 				    "change: %s", linedup);
1225 		}
1226 		line = end + 1;
1227 		if ((end = strchr(line, '.')) == NULL)
1228 			osmtpd_errx(1, "Invalid line received: invalid "
1229 			    "timestamp: %s", linedup);
1230 		end++[0] = '\0';
1231 		tm.tv_sec = (time_t) strtonum(line, 0, INT64_MAX, &errstr);
1232 		if (errstr != NULL)
1233 			osmtpd_errx(1, "Invalid line received: invalid "
1234 			    "timestamp: %s", linedup);
1235 		line = end;
1236 		if ((end = strchr(line, '|')) == NULL)
1237 			osmtpd_errx(1, "Invalid line received: missing "
1238 			    "direction: %s", linedup);
1239 		end++[0] = '\0';
1240 		tm.tv_nsec = (long) strtonum(line, 0, LONG_MAX, &errstr);
1241 		if (errstr != NULL)
1242 			osmtpd_errx(1, "Invalid line received: invalid "
1243 			    "timestamp: %s", linedup);
1244 		tm.tv_nsec *= 10 * (9 - (end - line));
1245 		line = end;
1246 		if ((end = strchr(line, '|')) == NULL)
1247 			osmtpd_errx(1, "Invalid line received: missing "
1248 			    "phase: %s", linedup);
1249 		end++[0] = '\0';
1250 		if (strcmp(line, "smtp-in") == 0)
1251 			incoming = 1;
1252 		else if (strcmp(line, "smtp-out") == 0)
1253 			incoming = 0;
1254 		else
1255 			osmtpd_errx(1, "Invalid line: invalid direction: %s",
1256 			    linedup);
1257 		line = end;
1258 		if ((end = strchr(line, '|')) == NULL)
1259 			osmtpd_errx(1, "Invalid line received: missing reqid: "
1260 			    "%s", linedup);
1261 		end++[0] = '\0';
1262 		phase = osmtpd_strtophase(line, linedup);
1263 		line = end;
1264 		errno = 0;
1265 		search.ctx.reqid = strtoull(line, &end, 16);
1266 		if ((search.ctx.reqid == ULLONG_MAX && errno != 0) ||
1267 		    (end[0] != '|' && end[0] != '\0'))
1268 			osmtpd_errx(1, "Invalid line received: invalid reqid: "
1269 			    "%s", linedup);
1270 		line = end + 1;
1271 		ctx = RB_FIND(osmtpd_sessions, &osmtpd_sessions, &search);
1272 		if (ctx == NULL) {
1273 			if ((ctx = malloc(sizeof(*ctx))) == NULL)
1274 				osmtpd_err(1, NULL);
1275 			ctx->status = SESSION_OK;
1276 			ctx->ctx.reqid = search.ctx.reqid;
1277 			ctx->ctx.rdns = NULL;
1278 			ctx->ctx.fcrdns = OSMTPD_STATUS_TEMPFAIL;
1279 			ctx->ctx.identity = NULL;
1280 			ctx->ctx.greeting.identity = NULL;
1281 			ctx->ctx.ciphers = NULL;
1282 			ctx->ctx.msgid = 0;
1283 			ctx->ctx.username = NULL;
1284 			ctx->ctx.mailfrom = NULL;
1285 			ctx->ctx.rcptto = malloc(sizeof(*(ctx->ctx.rcptto)));
1286 			if (ctx->ctx.rcptto == NULL)
1287 				osmtpd_err(1, "malloc");
1288 			ctx->ctx.rcptto[0] = NULL;
1289 			memset(&(ctx->ctx.src), 0, sizeof(ctx->ctx.src));
1290 			ctx->ctx.src.ss_family = AF_UNSPEC;
1291 			memset(&(ctx->ctx.dst), 0, sizeof(ctx->ctx.dst));
1292 			ctx->ctx.dst.ss_family = AF_UNSPEC;
1293 			RB_INSERT(osmtpd_sessions, &osmtpd_sessions, ctx);
1294 			ctx->ctx.evpid = 0;
1295 			ctx->ctx.local_session = NULL;
1296 			ctx->ctx.local_message = NULL;
1297 			if (oncreatecb_session != NULL)
1298 				if ((ctx->ctx.local_session =
1299 				    oncreatecb_session(&ctx->ctx)) == NULL)
1300 					ctx->status = SESSION_ERROR;
1301 		}
1302 		ctx->ctx.type = type;
1303 		ctx->ctx.phase = phase;
1304 		ctx->ctx.version_major = major;
1305 		ctx->ctx.version_minor = minor;
1306 		ctx->ctx.incoming = incoming;
1307 		ctx->ctx.tm.tv_sec = tm.tv_sec;
1308 		ctx->ctx.tm.tv_nsec = tm.tv_nsec;
1309 		ctx->ctx.token = 0;
1310 
1311 		for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
1312 			if (ctx->ctx.type == osmtpd_callbacks[i].type &&
1313 			    ctx->ctx.phase == osmtpd_callbacks[i].phase &&
1314 			    ctx->ctx.incoming == osmtpd_callbacks[i].incoming)
1315 				break;
1316 		}
1317 		if (i == NITEMS(osmtpd_callbacks)) {
1318 			osmtpd_errx(1, "Invalid line received: received "
1319 			    "unregistered line: %s", linedup);
1320 		}
1321 		if (ctx->ctx.type == OSMTPD_TYPE_FILTER) {
1322 			ctx->ctx.token = strtoull(line, &end, 16);
1323 			if ((ctx->ctx.token == ULLONG_MAX && errno != 0) ||
1324 			    end[0] != '|')
1325 				osmtpd_errx(1, "Invalid line received: invalid "
1326 				    "token: %s", linedup);
1327 			line = end + 1;
1328 			if (ctx->status == SESSION_ERROR)
1329 				osmtpd_filter_disconnect(&ctx->ctx,
1330 				    "internal server error");
1331 		}
1332 		osmtpd_callbacks[i].osmtpd_cb(&(osmtpd_callbacks[i]),
1333 		    ctx, line, linedup);
1334 	}
1335 	io_resume(io_stdout, IO_OUT);
1336 }
1337 
1338 static void
1339 osmtpd_outevt(__unused struct io *io, int evt, __unused void *arg)
1340 {
1341 	switch (evt) {
1342 	case IO_LOWAT:
1343 		return;
1344 	case IO_DISCONNECTED:
1345 		exit(0);
1346 	default:
1347 		osmtpd_errx(1, "Unexpectd event");
1348 	}
1349 }
1350 
1351 static void
1352 osmtpd_noargs(struct osmtpd_callback *cb, struct osmtpd_session *session,
1353     __unused char *params, __unused char *linedup)
1354 {
1355 	int (*f)(struct osmtpd_ctx *);
1356 
1357 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1358 		if (f(&session->ctx))
1359 			session->status = SESSION_ERROR;
1360 }
1361 
1362 static void
1363 osmtpd_onearg(struct osmtpd_callback *cb, struct osmtpd_session *session,
1364     char *line, __unused char *linedup)
1365 {
1366 	int (*f)(struct osmtpd_ctx *, const char *);
1367 
1368 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1369 		if (f(&session->ctx, line))
1370 			session->status = SESSION_ERROR;
1371 }
1372 
1373 static void
1374 osmtpd_connect(struct osmtpd_callback *cb, struct osmtpd_session *session,
1375     char *params, char *linedup)
1376 {
1377 	struct sockaddr_storage ss;
1378 	char *hostname;
1379 	char *address;
1380 	int (*f)(struct osmtpd_ctx *, const char *, struct sockaddr_storage *);
1381 
1382 	hostname = params;
1383 	if ((address = strchr(params, '|')) == NULL)
1384 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1385 		    linedup);
1386 	address++[0] = '\0';
1387 
1388 	osmtpd_addrtoss(address, &ss, 0, linedup);
1389 
1390 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1391 		if (f(&session->ctx, hostname, &ss))
1392 			session->status = SESSION_ERROR;
1393 }
1394 
1395 static void
1396 osmtpd_identify(struct osmtpd_callback *cb, struct osmtpd_session *session,
1397     char *identity, __unused char *linedup)
1398 {
1399 	int (*f)(struct osmtpd_ctx *, const char *);
1400 
1401 	if (cb->storereport) {
1402 		free(session->ctx.identity);
1403 		if ((session->ctx.identity = strdup(identity)) == NULL)
1404 			osmtpd_err(1, "strdup");
1405 	}
1406 
1407 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1408 		if (f(&session->ctx, identity))
1409 			session->status = SESSION_ERROR;
1410 }
1411 
1412 static void
1413 osmtpd_link_connect(struct osmtpd_callback *cb, struct osmtpd_session *session,
1414     char *params, char *linedup)
1415 {
1416 	char *end, *rdns;
1417 	enum osmtpd_status fcrdns;
1418 	struct sockaddr_storage src, dst;
1419 	int (*f)(struct osmtpd_ctx *, const char *, enum osmtpd_status,
1420 	    struct sockaddr_storage *, struct sockaddr_storage *);
1421 
1422 	if ((end = strchr(params, '|')) == NULL)
1423 		osmtpd_errx(1, "Invalid line received: missing fcrdns: %s",
1424 		    linedup);
1425 	end++[0] = '\0';
1426 	rdns = params;
1427 	params = end;
1428 	if ((end = strchr(params, '|')) == NULL)
1429 		osmtpd_errx(1, "Invalid line received: missing src: %s",
1430 		    linedup);
1431 	end++[0] = '\0';
1432 	if (strcmp(params, "pass") == 0)
1433 		fcrdns = OSMTPD_STATUS_OK;
1434 	else if (strcmp(params, "fail") == 0)
1435 		fcrdns = OSMTPD_STATUS_PERMFAIL;
1436 	else if (strcmp(params, "error") == 0)
1437 		fcrdns = OSMTPD_STATUS_TEMPFAIL;
1438 	else
1439 		osmtpd_errx(1, "Invalid line received: invalid fcrdns: %s",
1440 		    linedup);
1441 	params = end;
1442 	if ((end = strchr(params, '|')) == NULL)
1443 		osmtpd_errx(1, "Invalid line received: missing dst: %s",
1444 		    linedup);
1445 	end++[0] = '\0';
1446 	osmtpd_addrtoss(params, &src, 1, linedup);
1447 	params = end;
1448 	osmtpd_addrtoss(params, &dst, 1, linedup);
1449 	if (cb->storereport) {
1450 		if ((session->ctx.rdns = strdup(rdns)) == NULL)
1451 			osmtpd_err(1, "strdup");
1452 		session->ctx.fcrdns = fcrdns;
1453 		memcpy(&session->ctx.src, &src, sizeof(session->ctx.src));
1454 		memcpy(&session->ctx.dst, &dst, sizeof(session->ctx.dst));
1455 	}
1456 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1457 		if (f(&session->ctx, rdns, fcrdns, &src, &dst))
1458 			session->status = SESSION_ERROR;
1459 }
1460 
1461 static void
1462 osmtpd_link_disconnect(struct osmtpd_callback *cb,
1463     struct osmtpd_session *session, __unused char *param,
1464     __unused char *linedup)
1465 {
1466 	int (*f)(struct osmtpd_ctx *);
1467 	size_t i;
1468 
1469 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1470 		if (f(&session->ctx))
1471 			session->status = SESSION_ERROR;
1472 
1473 	RB_REMOVE(osmtpd_sessions, &osmtpd_sessions, session);
1474 	if (ondeletecb_session != NULL && session->ctx.local_session != NULL)
1475 		ondeletecb_session(&session->ctx, session->ctx.local_session);
1476 	free(session->ctx.rdns);
1477 	free(session->ctx.identity);
1478 	free(session->ctx.greeting.identity);
1479 	free(session->ctx.ciphers);
1480 	free(session->ctx.username);
1481 	free(session->ctx.mailfrom);
1482 	for (i = 0; session->ctx.rcptto[i] != NULL; i++)
1483 		free(session->ctx.rcptto[i]);
1484 	free(session->ctx.rcptto);
1485 	free(session);
1486 }
1487 
1488 static void
1489 osmtpd_link_greeting(struct osmtpd_callback *cb, struct osmtpd_session *session,
1490     char *identity, __unused char *linedup)
1491 {
1492 	int (*f)(struct osmtpd_ctx *, const char *);
1493 
1494 	if (cb->storereport) {
1495 		free(session->ctx.greeting.identity);
1496 		if ((session->ctx.greeting.identity = strdup(identity)) == NULL)
1497 			osmtpd_err(1, NULL);
1498 	}
1499 
1500 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1501 		if (f(&session->ctx, identity))
1502 			session->status = SESSION_ERROR;
1503 }
1504 
1505 static void
1506 osmtpd_link_identify(struct osmtpd_callback *cb, struct osmtpd_session *session,
1507     char *identity, __unused char *linedup)
1508 {
1509 	int (*f)(struct osmtpd_ctx *, const char *);
1510 
1511 	if (cb->storereport) {
1512 		free(session->ctx.identity);
1513 		if ((session->ctx.identity = strdup(identity)) == NULL)
1514 			osmtpd_err(1, NULL);
1515 	}
1516 
1517 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1518 		if (f(&session->ctx, identity))
1519 			session->status = SESSION_ERROR;
1520 }
1521 
1522 static void
1523 osmtpd_link_tls(struct osmtpd_callback *cb, struct osmtpd_session *session,
1524     char *ciphers, __unused char *linedup)
1525 {
1526 	int (*f)(struct osmtpd_ctx *, const char *);
1527 
1528 	if (cb->storereport) {
1529 		if ((session->ctx.ciphers = strdup(ciphers)) == NULL)
1530 			osmtpd_err(1, NULL);
1531 	}
1532 
1533 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1534 		if (f(&session->ctx, ciphers))
1535 			session->status = SESSION_ERROR;
1536 }
1537 
1538 static void
1539 osmtpd_link_auth(struct osmtpd_callback *cb, struct osmtpd_session *session,
1540     char *username, char *linedup)
1541 {
1542 	int (*f)(struct osmtpd_ctx *, const char *, enum osmtpd_auth_status);
1543 	char *status;
1544 	enum osmtpd_auth_status s;
1545 
1546 	if ((status = strrchr(username, '|')) == NULL)
1547 		osmtpd_errx(1, "Invalid auth received: %s", linedup);
1548 	status[0] = '\0';
1549 	status++;
1550 	if (strcmp(status, "pass") == 0)
1551 		s = OSMTPD_AUTH_PASS;
1552 	else if (strcmp(status, "fail") == 0)
1553 		s = OSMTPD_AUTH_FAIL;
1554 	else if (strcmp(status, "error") == 0)
1555 		s = OSMTPD_AUTH_ERROR;
1556 	else
1557 		osmtpd_errx(1, "Invalid auth status received: %s", linedup);
1558 
1559 	if (cb->storereport && s == OSMTPD_AUTH_PASS) {
1560 		if ((session->ctx.username = strdup(username)) == NULL)
1561 			osmtpd_err(1, NULL);
1562 	}
1563 
1564 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1565 		if (f(&session->ctx, username, s))
1566 			session->status = SESSION_ERROR;
1567 }
1568 
1569 static void
1570 osmtpd_tx_reset(struct osmtpd_callback *cb, struct osmtpd_session *session,
1571     char *params, char *linedup)
1572 {
1573 	char *end;
1574 	unsigned long imsgid;
1575 	uint32_t msgid;
1576 	size_t i;
1577 	int (*f)(struct osmtpd_ctx *, uint32_t);
1578 
1579 	errno = 0;
1580 	imsgid = strtoul(params, &end, 16);
1581 	if ((imsgid == ULONG_MAX && errno != 0))
1582 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1583 		    linedup);
1584 	if (end[0] != '\0')
1585 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1586 		    linedup);
1587 	msgid = imsgid;
1588 	if ((unsigned long) msgid != imsgid)
1589 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1590 		    linedup);
1591 
1592 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1593 		if (f(&session->ctx, msgid))
1594 			session->status = SESSION_ERROR;
1595 
1596 	if (ondeletecb_message != NULL && session->ctx.local_message != NULL) {
1597 		ondeletecb_message(&session->ctx, session->ctx.local_message);
1598 		session->ctx.local_message = NULL;
1599 	}
1600 
1601 	free(session->ctx.mailfrom);
1602 	session->ctx.mailfrom = NULL;
1603 
1604 	for (i = 0; session->ctx.rcptto[i] != NULL; i++)
1605 		free(session->ctx.rcptto[i]);
1606 	session->ctx.rcptto[0] = NULL;
1607 	session->ctx.evpid = 0;
1608 	session->ctx.msgid = 0;
1609 }
1610 
1611 static void
1612 osmtpd_tx_begin(struct osmtpd_callback *cb, struct osmtpd_session *session,
1613     char *msgid, char *linedup)
1614 {
1615 	unsigned long imsgid;
1616 	char *endptr;
1617 	int (*f)(struct osmtpd_ctx *, uint32_t);
1618 
1619 	errno = 0;
1620 	imsgid = strtoul(msgid, &endptr, 16);
1621 	if ((imsgid == ULONG_MAX && errno != 0) || endptr[0] != '\0')
1622 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1623 		    linedup);
1624 	session->ctx.msgid = imsgid;
1625 	/* Check if we're in range */
1626 	if ((unsigned long) session->ctx.msgid != imsgid)
1627 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1628 		    linedup);
1629 
1630 	if (!cb->storereport)
1631 		session->ctx.msgid = 0;
1632 
1633 	if (oncreatecb_message != NULL) {
1634 		session->ctx.local_message = oncreatecb_message(&session->ctx);
1635 		if (session->ctx.local_message == NULL)
1636 			session->status = SESSION_ERROR;
1637 	}
1638 
1639 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1640 		if (f(&session->ctx, imsgid))
1641 			session->status = SESSION_ERROR;
1642 }
1643 
1644 static void
1645 osmtpd_tx_mail(struct osmtpd_callback *cb, struct osmtpd_session *session,
1646     char *params, char *linedup)
1647 {
1648 	char *end, *mailfrom;
1649 	enum osmtpd_status status;
1650 	unsigned long imsgid;
1651 	uint32_t msgid;
1652 	int (*f)(struct osmtpd_ctx *, uint32_t, const char *,
1653 	    enum osmtpd_status);
1654 
1655 	errno = 0;
1656 	imsgid = strtoul(params, &end, 16);
1657 	if ((imsgid == ULONG_MAX && errno != 0))
1658 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1659 		    linedup);
1660 	if (end[0] != '|')
1661 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1662 		    linedup);
1663 	msgid = imsgid;
1664 	if ((unsigned long) msgid != imsgid)
1665 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1666 		    linedup);
1667 	params = end + 1;
1668 
1669 	if ((end = strchr(params, '|')) == NULL)
1670 		osmtpd_errx(1, "Invalid line received: missing status: %s",
1671 		    linedup);
1672 	end++[0] = '\0';
1673 	if (session->ctx.version_major == 0 && session->ctx.version_minor < 6) {
1674 		mailfrom = params;
1675 		status = osmtpd_strtostatus(end, linedup);
1676 	} else {
1677 		mailfrom = end;
1678 		status = osmtpd_strtostatus(params, linedup);
1679 	}
1680 	if (cb->storereport) {
1681 		if ((session->ctx.mailfrom = strdup(mailfrom)) == NULL)
1682 			osmtpd_err(1, NULL);
1683 	}
1684 
1685 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1686 		if (f(&session->ctx, msgid, mailfrom, status))
1687 			session->status = SESSION_ERROR;
1688 }
1689 
1690 static void
1691 osmtpd_tx_rcpt(struct osmtpd_callback *cb, struct osmtpd_session *session,
1692     char *params, char *linedup)
1693 {
1694 	char *end, *rcptto;
1695 	enum osmtpd_status status;
1696 	unsigned long imsgid;
1697 	uint32_t msgid;
1698 	size_t i;
1699 	int (*f)(struct osmtpd_ctx *, uint32_t, const char *,
1700 	    enum osmtpd_status);
1701 
1702 	errno = 0;
1703 	imsgid = strtoul(params, &end, 16);
1704 	if ((imsgid == ULONG_MAX && errno != 0))
1705 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1706 		    linedup);
1707 	if (end[0] != '|')
1708 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1709 		    linedup);
1710 	msgid = imsgid;
1711 	if ((unsigned long) msgid != imsgid)
1712 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1713 		    linedup);
1714 	params = end + 1;
1715 
1716 	if ((end = strchr(params, '|')) == NULL)
1717 		osmtpd_errx(1, "Invalid line received: missing status: %s",
1718 		    linedup);
1719 	end++[0] = '\0';
1720 
1721 	if (session->ctx.version_major == 0 && session->ctx.version_minor < 6) {
1722 		rcptto = params;
1723 		status = osmtpd_strtostatus(end, linedup);
1724 	} else {
1725 		rcptto = end;
1726 		status = osmtpd_strtostatus(params, linedup);
1727 	}
1728 
1729 	if (cb->storereport) {
1730 		for (i = 0; session->ctx.rcptto[i] != NULL; i++)
1731 			;
1732 		session->ctx.rcptto = reallocarray(session->ctx.rcptto, i + 2,
1733 		    sizeof(*session->ctx.rcptto));
1734 		if (session->ctx.rcptto == NULL)
1735 			osmtpd_err(1, NULL);
1736 
1737 		if ((session->ctx.rcptto[i] = strdup(rcptto)) == NULL)
1738 			osmtpd_err(1, NULL);
1739 		session->ctx.rcptto[i + 1] = NULL;
1740 	}
1741 
1742 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1743 		if (f(&session->ctx, msgid, rcptto, status))
1744 			session->status = SESSION_ERROR;
1745 }
1746 
1747 static void
1748 osmtpd_tx_envelope(struct osmtpd_callback *cb, struct osmtpd_session *session,
1749     char *params, char *linedup)
1750 {
1751 	unsigned long imsgid;
1752 	uint32_t msgid;
1753 	uint64_t evpid;
1754 	char *end;
1755 	int (*f)(struct osmtpd_ctx *, uint32_t, uint64_t);
1756 
1757 	errno = 0;
1758 	imsgid = strtoul(params, &end, 16);
1759 	if ((imsgid == ULONG_MAX && errno != 0))
1760 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1761 		    linedup);
1762 	if (end[0] != '|')
1763 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1764 		    linedup);
1765 	msgid = imsgid;
1766 	if ((unsigned long) msgid != imsgid)
1767 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1768 		    linedup);
1769 	params = end + 1;
1770 
1771 	evpid = strtoull(params, &end, 16);
1772 	if ((session->ctx.evpid == ULLONG_MAX && errno != 0) || end[0] != '\0')
1773 		osmtpd_errx(1, "Invalid line received: invalid evpid: %s",
1774 		    linedup);
1775 	if (cb->storereport)
1776 		session->ctx.evpid = evpid;
1777 
1778 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1779 		if (f(&session->ctx, msgid, evpid))
1780 			session->status = SESSION_ERROR;
1781 }
1782 
1783 static void
1784 osmtpd_tx_data(struct osmtpd_callback *cb, struct osmtpd_session *session,
1785     char *params, char *linedup)
1786 {
1787 	char *end;
1788 	unsigned long imsgid;
1789 	uint32_t msgid;
1790 	int (*f)(struct osmtpd_ctx *, uint32_t, enum osmtpd_status);
1791 
1792 	errno = 0;
1793 	imsgid = strtoul(params, &end, 16);
1794 	if ((imsgid == ULONG_MAX && errno != 0))
1795 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1796 		    linedup);
1797 	if (end[0] != '|')
1798 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1799 		    linedup);
1800 	msgid = imsgid;
1801 	if ((unsigned long) msgid != imsgid)
1802 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1803 		    linedup);
1804 	params = end + 1;
1805 
1806 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1807 		if (f(&session->ctx, msgid, osmtpd_strtostatus(params, linedup)))
1808 			session->status = SESSION_ERROR;
1809 }
1810 
1811 static void
1812 osmtpd_tx_commit(struct osmtpd_callback *cb, struct osmtpd_session *session,
1813     char *params, char *linedup)
1814 {
1815 	char *end;
1816 	const char *errstr = NULL;
1817 	unsigned long imsgid;
1818 	uint32_t msgid;
1819 	size_t msgsz;
1820 	int (*f)(struct osmtpd_ctx *, uint32_t, size_t);
1821 
1822 	errno = 0;
1823 	imsgid = strtoul(params, &end, 16);
1824 	if ((imsgid == ULONG_MAX && errno != 0))
1825 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1826 		    linedup);
1827 	if (end[0] != '|')
1828 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1829 		    linedup);
1830 	msgid = imsgid;
1831 	if ((unsigned long) msgid != imsgid)
1832 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1833 		    linedup);
1834 	params = end + 1;
1835 
1836 	msgsz = strtonum(params, 0, UINT32_MAX, &errstr);
1837 	if (errstr != NULL)
1838 		osmtpd_errx(1, "Invalid line received: invalid msg size: %s",
1839 		    linedup);
1840 
1841 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1842 		if (f(&session->ctx, msgid, msgsz))
1843 			session->status = SESSION_ERROR;
1844 }
1845 
1846 static void
1847 osmtpd_tx_rollback(struct osmtpd_callback *cb, struct osmtpd_session *session,
1848     char *params, char *linedup)
1849 {
1850 	char *end;
1851 	unsigned long imsgid;
1852 	uint32_t msgid;
1853 	int (*f)(struct osmtpd_ctx *, uint32_t);
1854 
1855 	errno = 0;
1856 	imsgid = strtoul(params, &end, 16);
1857 	if ((imsgid == ULONG_MAX && errno != 0))
1858 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1859 		    linedup);
1860 	if (end[0] != '\0')
1861 		osmtpd_errx(1, "Invalid line received: missing address: %s",
1862 		    linedup);
1863 	msgid = imsgid;
1864 	if ((unsigned long) msgid != imsgid)
1865 		osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1866 		    linedup);
1867 
1868 	if ((f = cb->cb) != NULL && session->status == SESSION_OK)
1869 		if (f(&session->ctx, msgid))
1870 			session->status = SESSION_ERROR;
1871 }
1872 
1873 void
1874 osmtpd_filter_proceed(struct osmtpd_ctx *ctx)
1875 {
1876 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
1877 
1878 	if (session->status == SESSION_DISCONNECTED)
1879 		return;
1880 
1881 	if (ctx->version_major == 0 && ctx->version_minor < 5)
1882 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1883 		    "proceed\n", ctx->token, ctx->reqid);
1884 	else
1885 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1886 		    "proceed\n", ctx->reqid, ctx->token);
1887 }
1888 
1889 void
1890 osmtpd_filter_reject(struct osmtpd_ctx *ctx, int code, const char *reason, ...)
1891 {
1892 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
1893 	va_list ap;
1894 
1895 	if (session->status == SESSION_DISCONNECTED)
1896 		return;
1897 
1898 	if (code < 200 || code > 599)
1899 		osmtpd_errx(1, "Invalid reject code");
1900 
1901 	if (ctx->version_major == 0 && ctx->version_minor < 5)
1902 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1903 		    "reject|%d ", ctx->token, ctx->reqid, code);
1904 	else
1905 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1906 		    "reject|%d ", ctx->reqid, ctx->token, code);
1907 	va_start(ap, reason);
1908 	io_vprintf(io_stdout, reason, ap);
1909 	va_end(ap);
1910 	io_printf(io_stdout, "\n");
1911 }
1912 
1913 void
1914 osmtpd_filter_reject_enh(struct osmtpd_ctx *ctx, int code, int class,
1915     int subject, int detail, const char *reason, ...)
1916 {
1917 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
1918 	va_list ap;
1919 
1920 	if (session->status == SESSION_DISCONNECTED)
1921 		return;
1922 
1923 	if (code < 200 || code > 599)
1924 		osmtpd_errx(1, "Invalid reject code");
1925 	if (class < 2 || class > 5)
1926 		osmtpd_errx(1, "Invalid enhanced status class");
1927 	if (subject < 0 || subject > 999)
1928 		osmtpd_errx(1, "Invalid enhanced status subject");
1929 	if (detail < 0 || detail > 999)
1930 		osmtpd_errx(1, "Invalid enhanced status detail");
1931 
1932 	if (ctx->version_major == 0 && ctx->version_minor < 5)
1933 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1934 		    "reject|%d %d.%d.%d ", ctx->token, ctx->reqid, code, class,
1935 		    subject, detail);
1936 	else
1937 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1938 		    "reject|%d %d.%d.%d ", ctx->reqid, ctx->token, code, class,
1939 		    subject, detail);
1940 	va_start(ap, reason);
1941 	io_vprintf(io_stdout, reason, ap);
1942 	va_end(ap);
1943 	io_printf(io_stdout, "\n");
1944 }
1945 
1946 void
1947 osmtpd_filter_disconnect(struct osmtpd_ctx *ctx, const char *reason, ...)
1948 {
1949 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
1950 	va_list ap;
1951 
1952 	if (session->status == SESSION_DISCONNECTED)
1953 		return;
1954 
1955 	if (ctx->version_major == 0 && ctx->version_minor < 5)
1956 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1957 		    "disconnect|421 ", ctx->token, ctx->reqid);
1958 	else
1959 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1960 		    "disconnect|421 ", ctx->reqid, ctx->token);
1961 	va_start(ap, reason);
1962 	io_vprintf(io_stdout, reason, ap);
1963 	va_end(ap);
1964 	io_printf(io_stdout, "\n");
1965 	session->status = SESSION_DISCONNECTED;
1966 }
1967 
1968 void
1969 osmtpd_filter_disconnect_enh(struct osmtpd_ctx *ctx, int class, int subject,
1970     int detail, const char *reason, ...)
1971 {
1972 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
1973 	va_list ap;
1974 
1975 	if (session->status == SESSION_DISCONNECTED)
1976 		return;
1977 
1978 	if (class <= 2 || class >= 5)
1979 		osmtpd_errx(1, "Invalid enhanced status class");
1980 	if (subject < 0 || subject > 999)
1981 		osmtpd_errx(1, "Invalid enhanced status subject");
1982 	if (detail < 0 || detail > 999)
1983 		osmtpd_errx(1, "Invalid enhanced status detail");
1984 	if (ctx->version_major == 0 && ctx->version_minor < 5)
1985 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1986 		    "disconnect|421 %d.%d.%d ", ctx->token, ctx->reqid, class,
1987 		    subject, detail);
1988 	else
1989 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1990 		    "disconnect|421 %d.%d.%d ", ctx->reqid, ctx->token, class,
1991 		    subject, detail);
1992 	va_start(ap, reason);
1993 	io_vprintf(io_stdout, reason, ap);
1994 	va_end(ap);
1995 	io_printf(io_stdout, "\n");
1996 	session->status = SESSION_DISCONNECTED;
1997 }
1998 
1999 void
2000 osmtpd_filter_rewrite(struct osmtpd_ctx *ctx, const char *value, ...)
2001 {
2002 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
2003 	va_list ap;
2004 
2005 	if (session->status == SESSION_DISCONNECTED)
2006 		return;
2007 
2008 	if (ctx->version_major == 0 && ctx->version_minor < 5)
2009 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
2010 		    "rewrite|", ctx->token, ctx->reqid);
2011 	else
2012 		io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
2013 		    "rewrite|", ctx->reqid, ctx->token);
2014 	va_start(ap, value);
2015 	io_vprintf(io_stdout, value, ap);
2016 	va_end(ap);
2017 	io_printf(io_stdout, "\n");
2018 }
2019 
2020 void
2021 osmtpd_filter_dataline(struct osmtpd_ctx *ctx, const char *line, ...)
2022 {
2023 	struct osmtpd_session *session = (struct osmtpd_session *)ctx;
2024 	va_list ap;
2025 
2026 	if (session->status == SESSION_DISCONNECTED)
2027 		return;
2028 
2029 	if (ctx->version_major == 0 && ctx->version_minor < 5)
2030 		io_printf(io_stdout, "filter-dataline|%016"PRIx64"|%016"PRIx64"|",
2031 		    ctx->token, ctx->reqid);
2032 	else
2033 		io_printf(io_stdout, "filter-dataline|%016"PRIx64"|%016"PRIx64"|",
2034 		    ctx->reqid, ctx->token);
2035 	va_start(ap, line);
2036 	io_vprintf(io_stdout, line, ap);
2037 	va_end(ap);
2038 	io_printf(io_stdout, "\n");
2039 }
2040 
2041 static void
2042 osmtpd_register(enum osmtpd_type type, enum osmtpd_phase phase, int incoming,
2043     int storereport, void *cb)
2044 {
2045 	size_t i;
2046 
2047 	if (ready)
2048 		osmtpd_errx(1, "Can't register when proc is running");
2049 
2050 	for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
2051 		if (type ==  osmtpd_callbacks[i].type &&
2052 		    phase == osmtpd_callbacks[i].phase &&
2053 		    incoming == osmtpd_callbacks[i].incoming) {
2054 			if (osmtpd_callbacks[i].cb != NULL && cb != NULL)
2055 				osmtpd_errx(1, "Event already registered");
2056 			if (cb != NULL)
2057 				osmtpd_callbacks[i].cb = cb;
2058 			osmtpd_callbacks[i].doregister = 1;
2059 			if (storereport)
2060 				osmtpd_callbacks[i].storereport = 1;
2061 			return;
2062 		}
2063 	}
2064 	/* NOT REACHED */
2065 	osmtpd_errx(1, "Trying to register unknown event");
2066 }
2067 
2068 static enum osmtpd_phase
2069 osmtpd_strtophase(const char *phase, const char *linedup)
2070 {
2071 	if (strcmp(phase, "connect") == 0)
2072 		return OSMTPD_PHASE_CONNECT;
2073 	if (strcmp(phase, "helo") == 0)
2074 		return OSMTPD_PHASE_HELO;
2075 	if (strcmp(phase, "ehlo") == 0)
2076 		return OSMTPD_PHASE_EHLO;
2077 	if (strcmp(phase, "starttls") == 0)
2078 		return OSMTPD_PHASE_STARTTLS;
2079 	if (strcmp(phase, "auth") == 0)
2080 		return OSMTPD_PHASE_AUTH;
2081 	if (strcmp(phase, "mail-from") == 0)
2082 		return OSMTPD_PHASE_MAIL_FROM;
2083 	if (strcmp(phase, "rcpt-to") == 0)
2084 		return OSMTPD_PHASE_RCPT_TO;
2085 	if (strcmp(phase, "data") == 0)
2086 		return OSMTPD_PHASE_DATA;
2087 	if (strcmp(phase, "data-line") == 0)
2088 		return OSMTPD_PHASE_DATA_LINE;
2089 	if (strcmp(phase, "rset") == 0)
2090 		return OSMTPD_PHASE_RSET;
2091 	if (strcmp(phase, "quit") == 0)
2092 		return OSMTPD_PHASE_QUIT;
2093 	if (strcmp(phase, "noop") == 0)
2094 		return OSMTPD_PHASE_NOOP;
2095 	if (strcmp(phase, "help") == 0)
2096 		return OSMTPD_PHASE_HELP;
2097 	if (strcmp(phase, "wiz") == 0)
2098 		return OSMTPD_PHASE_WIZ;
2099 	if (strcmp(phase, "commit") == 0)
2100 		return OSMTPD_PHASE_COMMIT;
2101 	if (strcmp(phase, "link-connect") == 0)
2102 		return OSMTPD_PHASE_LINK_CONNECT;
2103 	if (strcmp(phase, "link-disconnect") == 0)
2104 		return OSMTPD_PHASE_LINK_DISCONNECT;
2105 	if (strcmp(phase, "link-greeting") == 0)
2106 		return OSMTPD_PHASE_LINK_GREETING;
2107 	if (strcmp(phase, "link-identify") == 0)
2108 		return OSMTPD_PHASE_LINK_IDENTIFY;
2109 	if (strcmp(phase, "link-tls") == 0)
2110 		return OSMTPD_PHASE_LINK_TLS;
2111 	if (strcmp(phase, "link-auth") == 0)
2112 		return OSMTPD_PHASE_LINK_AUTH;
2113 	if (strcmp(phase, "tx-reset") == 0)
2114 		return OSMTPD_PHASE_TX_RESET;
2115 	if (strcmp(phase, "tx-begin") == 0)
2116 		return OSMTPD_PHASE_TX_BEGIN;
2117 	if (strcmp(phase, "tx-mail") == 0)
2118 		return OSMTPD_PHASE_TX_MAIL;
2119 	if (strcmp(phase, "tx-rcpt") == 0)
2120 		return OSMTPD_PHASE_TX_RCPT;
2121 	if (strcmp(phase, "tx-envelope") == 0)
2122 		return OSMTPD_PHASE_TX_ENVELOPE;
2123 	if (strcmp(phase, "tx-data") == 0)
2124 		return OSMTPD_PHASE_TX_DATA;
2125 	if (strcmp(phase, "tx-commit") == 0)
2126 		return OSMTPD_PHASE_TX_COMMIT;
2127 	if (strcmp(phase, "tx-rollback") == 0)
2128 		return OSMTPD_PHASE_TX_ROLLBACK;
2129 	if (strcmp(phase, "protocol-client") == 0)
2130 		return OSMTPD_PHASE_PROTOCOL_CLIENT;
2131 	if (strcmp(phase, "protocol-server") == 0)
2132 		return OSMTPD_PHASE_PROTOCOL_SERVER;
2133 	if (strcmp(phase, "filter-response") == 0)
2134 		return OSMTPD_PHASE_FILTER_RESPONSE;
2135 	if (strcmp(phase, "timeout") == 0)
2136 		return OSMTPD_PHASE_TIMEOUT;
2137 	osmtpd_errx(1, "Invalid line received: invalid phase: %s", linedup);
2138 }
2139 
2140 static const char *
2141 osmtpd_typetostr(enum osmtpd_type type)
2142 {
2143 	switch (type) {
2144 	case OSMTPD_TYPE_FILTER:
2145 		return "filter";
2146 	case OSMTPD_TYPE_REPORT:
2147 		return "report";
2148 	}
2149 	osmtpd_errx(1, "In valid type: %d\n", type);
2150 }
2151 
2152 static const char *
2153 osmtpd_phasetostr(enum osmtpd_phase phase)
2154 {
2155 	switch (phase) {
2156 	case OSMTPD_PHASE_CONNECT:
2157 		return "connect";
2158 	case OSMTPD_PHASE_HELO:
2159 		return "helo";
2160 	case OSMTPD_PHASE_EHLO:
2161 		return "ehlo";
2162 	case OSMTPD_PHASE_STARTTLS:
2163 		return "starttls";
2164 	case OSMTPD_PHASE_AUTH:
2165 		return "auth";
2166 	case OSMTPD_PHASE_MAIL_FROM:
2167 		return "mail-from";
2168 	case OSMTPD_PHASE_RCPT_TO:
2169 		return "rcpt-to";
2170 	case OSMTPD_PHASE_DATA:
2171 		return "data";
2172 	case OSMTPD_PHASE_DATA_LINE:
2173 		return "data-line";
2174 	case OSMTPD_PHASE_RSET:
2175 		return "rset";
2176 	case OSMTPD_PHASE_QUIT:
2177 		return "quit";
2178 	case OSMTPD_PHASE_NOOP:
2179 		return "noop";
2180 	case OSMTPD_PHASE_HELP:
2181 		return "help";
2182 	case OSMTPD_PHASE_WIZ:
2183 		return "wiz";
2184 	case OSMTPD_PHASE_COMMIT:
2185 		return "commit";
2186 	case OSMTPD_PHASE_LINK_CONNECT:
2187 		return "link-connect";
2188 	case OSMTPD_PHASE_LINK_DISCONNECT:
2189 		return "link-disconnect";
2190 	case OSMTPD_PHASE_LINK_GREETING:
2191 		return "link-greeting";
2192 	case OSMTPD_PHASE_LINK_IDENTIFY:
2193 		return "link-identify";
2194 	case OSMTPD_PHASE_LINK_TLS:
2195 		return "link-tls";
2196 	case OSMTPD_PHASE_LINK_AUTH:
2197 		return "link-auth";
2198 	case OSMTPD_PHASE_TX_RESET:
2199 		return "tx-reset";
2200 	case OSMTPD_PHASE_TX_BEGIN:
2201 		return "tx-begin";
2202 	case OSMTPD_PHASE_TX_MAIL:
2203 		return "tx-mail";
2204 	case OSMTPD_PHASE_TX_RCPT:
2205 		return "tx-rcpt";
2206 	case OSMTPD_PHASE_TX_ENVELOPE:
2207 		return "tx-envelope";
2208 	case OSMTPD_PHASE_TX_DATA:
2209 		return "tx-data";
2210 	case OSMTPD_PHASE_TX_COMMIT:
2211 		return "tx-commit";
2212 	case OSMTPD_PHASE_TX_ROLLBACK:
2213 		return "tx-rollback";
2214 	case OSMTPD_PHASE_PROTOCOL_CLIENT:
2215 		return "protocol-client";
2216 	case OSMTPD_PHASE_PROTOCOL_SERVER:
2217 		return "protocol-server";
2218 	case OSMTPD_PHASE_FILTER_RESPONSE:
2219 		return "filter-response";
2220 	case OSMTPD_PHASE_TIMEOUT:
2221 		return "timeout";
2222 	}
2223 	osmtpd_errx(1, "In valid phase: %d\n", phase);
2224 }
2225 
2226 static enum osmtpd_status
2227 osmtpd_strtostatus(const char *status, char *linedup)
2228 {
2229 	if (strcmp(status, "ok") == 0)
2230 		return OSMTPD_STATUS_OK;
2231 	else if (strcmp(status, "tempfail") == 0)
2232 		return OSMTPD_STATUS_TEMPFAIL;
2233 	else if (strcmp(status, "permfail") == 0)
2234 		return OSMTPD_STATUS_PERMFAIL;
2235 	osmtpd_errx(1, "Invalid line received: invalid status: %s\n", linedup);
2236 }
2237 
2238 static void
2239 osmtpd_addrtoss(char *addr, struct sockaddr_storage *ss, int hasport,
2240     char *linedup)
2241 {
2242 	char *port = NULL;
2243 	const char *errstr = NULL;
2244 	struct sockaddr_in *sin;
2245 	struct sockaddr_in6 *sin6;
2246 	struct sockaddr_un *sun;
2247 	size_t n;
2248 
2249 	if (addr[0] == '[') {
2250 		sin6 = (struct sockaddr_in6 *)ss;
2251 		sin6->sin6_family = AF_INET6;
2252 		sin6->sin6_port = 0;
2253 		if (hasport) {
2254 			if ((port = strrchr(addr, ':')) == NULL)
2255 				osmtpd_errx(1, "Invalid line received: invalid "
2256 				    "address (%s): %s", addr, linedup);
2257 			if (port[-1] != ']')
2258 				osmtpd_errx(1, "Invalid line received: invalid "
2259 				    "address (%s): %s", addr, linedup);
2260 			port++;
2261 			sin6->sin6_port = htons(strtonum(port, 0, UINT16_MAX,
2262 			    &errstr));
2263 			if (errstr != NULL)
2264 				osmtpd_errx(1, "Invalid line received: invalid "
2265 				    "address (%s): %s", addr, linedup);
2266 			port[-2] = '\0';
2267 		} else {
2268 			n = strlen(addr);
2269 			if (addr[n - 1] != ']')
2270 				osmtpd_errx(1, "Invalid line received: invalid "
2271 				    "address (%s): %s", addr, linedup);
2272 			addr[n - 1] = '\0';
2273 		}
2274 		switch (inet_pton(AF_INET6, addr + 1, &(sin6->sin6_addr))) {
2275 		case 1:
2276 			break;
2277 		case 0:
2278 			if (hasport)
2279 				port[-2] = ']';
2280 			else
2281 				addr[n - 1] = ']';
2282 			osmtpd_errx(1, "Invalid line received: invalid address "
2283 			    "(%s): %s", addr, linedup);
2284 		default:
2285 			if (hasport)
2286 				port[-2] = ']';
2287 			else
2288 				addr[n - 1] = ']';
2289 			osmtpd_err(1, "Can't parse address (%s): %s", addr,
2290 			    linedup);
2291 		}
2292 	} else if (strncasecmp(addr, "unix:", 5) == 0) {
2293 		sun = (struct sockaddr_un *)ss;
2294 		sun->sun_family = AF_UNIX;
2295 		if (strlcpy(sun->sun_path, addr,
2296 		    sizeof(sun->sun_path)) >= sizeof(sun->sun_path)) {
2297 			osmtpd_errx(1, "Invalid line received: address too "
2298 			    "long (%s): %s", addr, linedup);
2299 		}
2300 	} else {
2301 		sin = (struct sockaddr_in *)ss;
2302 		sin->sin_family = AF_INET;
2303 		sin->sin_port = 0;
2304 		if (hasport) {
2305 			if ((port = strrchr(addr, ':')) == NULL)
2306 				osmtpd_errx(1, "Invalid line received: invalid "
2307 				    "address (%s): %s", addr, linedup);
2308 			port++;
2309 			sin->sin_port = htons(strtonum(port, 0, UINT16_MAX,
2310 			    &errstr));
2311 			if (errstr != NULL)
2312 				osmtpd_errx(1, "Invalid line received: invalid "
2313 				    "address (%s): %s", addr, linedup);
2314 			port[-1] = '\0';
2315 		}
2316 		switch (inet_pton(AF_INET, addr, &(sin->sin_addr))) {
2317 		case 1:
2318 			break;
2319 		case 0:
2320 			if (hasport)
2321 				port[-1] = ':';
2322 			osmtpd_errx(1, "Invalid line received: invalid address "
2323 			    "(%s): %s", addr, linedup);
2324 		default:
2325 			if (hasport)
2326 				port[-1] = ':';
2327 			osmtpd_err(1, "Can't parse address (%s): %s", addr,
2328 			    linedup);
2329 		}
2330 	}
2331 }
2332 
2333 static int
2334 osmtpd_session_cmp(struct osmtpd_session *a, struct osmtpd_session *b)
2335 {
2336 	return a->ctx.reqid < b->ctx.reqid ? -1 : a->ctx.reqid > b->ctx.reqid;
2337 }
2338 
2339 RB_GENERATE_STATIC(osmtpd_sessions, osmtpd_session, entry, osmtpd_session_cmp);