Blob


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 #include <sys/time.h>
17 #include <sys/tree.h>
18 #include <sys/socket.h>
19 #include <sys/un.h>
21 #include <arpa/inet.h>
22 #include <netinet/in.h>
24 #include <errno.h>
25 #include <event.h>
26 #include <fcntl.h>
27 #include <inttypes.h>
28 #include <limits.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <syslog.h>
34 #include <unistd.h>
36 #include "opensmtpd.h"
37 #include "ioev.h"
39 #define NITEMS(x) (sizeof(x) / sizeof(*x))
41 struct osmtpd_callback {
42 enum osmtpd_type type;
43 enum osmtpd_phase phase;
44 int incoming;
45 void (*osmtpd_cb)(struct osmtpd_callback *, struct osmtpd_ctx *, char *,
46 char *);
47 void *cb;
48 int doregister;
49 int storereport;
50 };
52 struct osmtpd_session {
53 struct osmtpd_ctx ctx;
54 RB_ENTRY(osmtpd_session) entry;
55 };
57 static void osmtpd_register(enum osmtpd_type, enum osmtpd_phase, int, int,
58 void *);
59 static const char *osmtpd_typetostr(enum osmtpd_type);
60 static const char *osmtpd_phasetostr(enum osmtpd_phase);
61 static enum osmtpd_phase osmtpd_strtophase(const char *, const char *);
62 static void osmtpd_newline(struct io *, int, void *);
63 static void osmtpd_outevt(struct io *, int, void *);
64 static void osmtpd_noargs(struct osmtpd_callback *, struct osmtpd_ctx *,
65 char *, char *);
66 static void osmtpd_onearg(struct osmtpd_callback *, struct osmtpd_ctx *,
67 char *, char *);
68 static void osmtpd_connect(struct osmtpd_callback *, struct osmtpd_ctx *,
69 char *, char *);
70 static void osmtpd_link_connect(struct osmtpd_callback *, struct osmtpd_ctx *,
71 char *, char *);
72 static void osmtpd_link_disconnect(struct osmtpd_callback *,
73 struct osmtpd_ctx *, char *, char *);
74 static void osmtpd_link_identify(struct osmtpd_callback *, struct osmtpd_ctx *,
75 char *, char *);
76 static void osmtpd_link_tls(struct osmtpd_callback *, struct osmtpd_ctx *,
77 char *, char *);
78 static void osmtpd_tx_begin(struct osmtpd_callback *, struct osmtpd_ctx *,
79 char *, char *);
80 static void osmtpd_tx_mail(struct osmtpd_callback *, struct osmtpd_ctx *,
81 char *, char *);
82 static void osmtpd_tx_rcpt(struct osmtpd_callback *, struct osmtpd_ctx *,
83 char *, char *);
84 static void osmtpd_tx_envelope(struct osmtpd_callback *, struct osmtpd_ctx *,
85 char *, char *);
86 static void osmtpd_tx_data(struct osmtpd_callback *, struct osmtpd_ctx *,
87 char *, char *);
88 static void osmtpd_tx_commit(struct osmtpd_callback *, struct osmtpd_ctx *,
89 char *, char *);
90 static void osmtpd_tx_rollback(struct osmtpd_callback *, struct osmtpd_ctx *,
91 char *, char *);
92 static void osmtpd_addrtoss(char *, struct sockaddr_storage *, int, char *);
93 static enum osmtpd_status osmtpd_strtostatus(const char *, char *);
94 static int osmtpd_session_cmp(struct osmtpd_session *, struct osmtpd_session *);
95 static void *(*oncreatecb_session)(struct osmtpd_ctx *) = NULL;
96 static void (*ondeletecb_session)(struct osmtpd_ctx *, void *) = NULL;
97 static void *(*oncreatecb_message)(struct osmtpd_ctx *) = NULL;
98 static void (*ondeletecb_message)(struct osmtpd_ctx *, void *) = NULL;
100 static struct osmtpd_callback osmtpd_callbacks[] = {
102 OSMTPD_TYPE_FILTER,
103 OSMTPD_PHASE_CONNECT,
104 1,
105 osmtpd_connect,
106 NULL,
107 0,
109 },
111 OSMTPD_TYPE_FILTER,
112 OSMTPD_PHASE_HELO,
113 1,
114 osmtpd_onearg,
115 NULL,
116 0,
118 },
120 OSMTPD_TYPE_FILTER,
121 OSMTPD_PHASE_EHLO,
122 1,
123 osmtpd_onearg,
124 NULL,
125 0,
127 },
129 OSMTPD_TYPE_FILTER,
130 OSMTPD_PHASE_STARTTLS,
131 1,
132 osmtpd_noargs,
133 NULL,
134 0,
136 },
138 OSMTPD_TYPE_FILTER,
139 OSMTPD_PHASE_AUTH,
140 1,
141 osmtpd_onearg,
142 NULL,
143 0,
145 },
147 OSMTPD_TYPE_FILTER,
148 OSMTPD_PHASE_MAIL_FROM,
149 1,
150 osmtpd_onearg,
151 NULL,
152 0,
154 },
156 OSMTPD_TYPE_FILTER,
157 OSMTPD_PHASE_RCPT_TO,
158 1,
159 osmtpd_onearg,
160 NULL,
161 0,
163 },
165 OSMTPD_TYPE_FILTER,
166 OSMTPD_PHASE_DATA,
167 1,
168 osmtpd_noargs,
169 NULL,
170 0,
172 },
174 OSMTPD_TYPE_FILTER,
175 OSMTPD_PHASE_DATA_LINE,
176 1,
177 osmtpd_onearg,
178 NULL,
179 0,
181 },
183 OSMTPD_TYPE_FILTER,
184 OSMTPD_PHASE_RSET,
185 1,
186 osmtpd_noargs,
187 NULL,
188 0,
190 },
192 OSMTPD_TYPE_FILTER,
193 OSMTPD_PHASE_QUIT,
194 1,
195 osmtpd_noargs,
196 NULL,
197 0,
199 },
201 OSMTPD_TYPE_FILTER,
202 OSMTPD_PHASE_NOOP,
203 1,
204 osmtpd_noargs,
205 NULL,
206 0,
208 },
210 OSMTPD_TYPE_FILTER,
211 OSMTPD_PHASE_HELP,
212 1,
213 osmtpd_noargs,
214 NULL,
215 0,
217 },
219 OSMTPD_TYPE_FILTER,
220 OSMTPD_PHASE_WIZ,
221 1,
222 osmtpd_noargs,
223 NULL,
224 0,
226 },
228 OSMTPD_TYPE_FILTER,
229 OSMTPD_PHASE_COMMIT,
230 1,
231 osmtpd_noargs,
232 NULL,
233 0,
235 },
237 OSMTPD_TYPE_REPORT,
238 OSMTPD_PHASE_LINK_CONNECT,
239 1,
240 osmtpd_link_connect,
241 NULL,
242 0,
244 },
246 OSMTPD_TYPE_REPORT,
247 OSMTPD_PHASE_LINK_DISCONNECT,
248 1,
249 osmtpd_link_disconnect,
250 NULL,
251 0,
253 },
255 OSMTPD_TYPE_REPORT,
256 OSMTPD_PHASE_LINK_IDENTIFY,
257 1,
258 osmtpd_link_identify,
259 NULL,
260 0,
262 },
264 OSMTPD_TYPE_REPORT,
265 OSMTPD_PHASE_LINK_TLS,
266 1,
267 osmtpd_link_tls,
268 NULL,
269 0,
271 },
273 OSMTPD_TYPE_REPORT,
274 OSMTPD_PHASE_TX_BEGIN,
275 1,
276 osmtpd_tx_begin,
277 NULL,
278 0,
280 },
282 OSMTPD_TYPE_REPORT,
283 OSMTPD_PHASE_TX_MAIL,
284 1,
285 osmtpd_tx_mail,
286 NULL,
287 0,
289 },
291 OSMTPD_TYPE_REPORT,
292 OSMTPD_PHASE_TX_RCPT,
293 1,
294 osmtpd_tx_rcpt,
295 NULL,
296 0,
298 },
300 OSMTPD_TYPE_REPORT,
301 OSMTPD_PHASE_TX_ENVELOPE,
302 1,
303 osmtpd_tx_envelope,
304 NULL,
305 0,
307 },
309 OSMTPD_TYPE_REPORT,
310 OSMTPD_PHASE_TX_DATA,
311 1,
312 osmtpd_tx_data,
313 NULL,
314 0,
316 },
318 OSMTPD_TYPE_REPORT,
319 OSMTPD_PHASE_TX_COMMIT,
320 1,
321 osmtpd_tx_commit,
322 NULL,
323 0,
325 },
327 OSMTPD_TYPE_REPORT,
328 OSMTPD_PHASE_TX_ROLLBACK,
329 1,
330 osmtpd_tx_rollback,
331 NULL,
332 0,
334 },
336 OSMTPD_TYPE_REPORT,
337 OSMTPD_PHASE_PROTOCOL_CLIENT,
338 1,
339 osmtpd_onearg,
340 NULL,
341 0,
343 },
345 OSMTPD_TYPE_REPORT,
346 OSMTPD_PHASE_PROTOCOL_SERVER,
347 1,
348 osmtpd_onearg,
349 NULL,
350 0,
352 },
354 OSMTPD_TYPE_REPORT,
355 OSMTPD_PHASE_FILTER_RESPONSE,
356 1,
357 osmtpd_onearg,
358 NULL,
359 0,
361 },
363 OSMTPD_TYPE_REPORT,
364 OSMTPD_PHASE_TIMEOUT,
365 1,
366 osmtpd_noargs,
367 NULL,
368 0,
370 },
372 OSMTPD_TYPE_REPORT,
373 OSMTPD_PHASE_LINK_CONNECT,
374 0,
375 osmtpd_link_connect,
376 NULL,
377 0,
379 },
381 OSMTPD_TYPE_REPORT,
382 OSMTPD_PHASE_LINK_DISCONNECT,
383 0,
384 osmtpd_link_disconnect,
385 NULL,
386 0,
388 },
390 OSMTPD_TYPE_REPORT,
391 OSMTPD_PHASE_LINK_IDENTIFY,
392 0,
393 osmtpd_link_identify,
394 NULL,
395 0,
397 },
399 OSMTPD_TYPE_REPORT,
400 OSMTPD_PHASE_LINK_TLS,
401 0,
402 osmtpd_link_tls,
403 NULL,
404 0,
406 },
408 OSMTPD_TYPE_REPORT,
409 OSMTPD_PHASE_TX_BEGIN,
410 0,
411 osmtpd_tx_begin,
412 NULL,
413 0,
415 },
417 OSMTPD_TYPE_REPORT,
418 OSMTPD_PHASE_TX_MAIL,
419 0,
420 osmtpd_tx_mail,
421 NULL,
422 0,
424 },
426 OSMTPD_TYPE_REPORT,
427 OSMTPD_PHASE_TX_RCPT,
428 0,
429 osmtpd_tx_rcpt,
430 NULL,
431 0,
433 },
435 OSMTPD_TYPE_REPORT,
436 OSMTPD_PHASE_TX_ENVELOPE,
437 0,
438 osmtpd_tx_envelope,
439 NULL,
440 0,
442 },
444 OSMTPD_TYPE_REPORT,
445 OSMTPD_PHASE_TX_DATA,
446 0,
447 osmtpd_tx_data,
448 NULL,
449 0,
451 },
453 OSMTPD_TYPE_REPORT,
454 OSMTPD_PHASE_TX_COMMIT,
455 0,
456 osmtpd_tx_commit,
457 NULL,
458 0,
460 },
462 OSMTPD_TYPE_REPORT,
463 OSMTPD_PHASE_TX_ROLLBACK,
464 0,
465 osmtpd_tx_rollback,
466 NULL,
467 0,
469 },
471 OSMTPD_TYPE_REPORT,
472 OSMTPD_PHASE_PROTOCOL_CLIENT,
473 0,
474 osmtpd_onearg,
475 NULL,
476 0,
478 },
480 OSMTPD_TYPE_REPORT,
481 OSMTPD_PHASE_PROTOCOL_SERVER,
482 0,
483 osmtpd_onearg,
484 NULL,
485 0,
487 },
489 OSMTPD_TYPE_REPORT,
490 OSMTPD_PHASE_FILTER_RESPONSE,
491 0,
492 osmtpd_onearg,
493 NULL,
494 0,
496 },
498 OSMTPD_TYPE_REPORT,
499 OSMTPD_PHASE_TIMEOUT,
500 0,
501 osmtpd_noargs,
502 NULL,
503 0,
506 };
508 static struct io *io_stdout;
509 static int needs;
510 static int ready = 0;
511 /* Default from smtpd */
512 static int session_timeout = 300;
514 RB_HEAD(osmtpd_sessions, osmtpd_session) osmtpd_sessions = RB_INITIALIZER(NULL);
515 RB_PROTOTYPE_STATIC(osmtpd_sessions, osmtpd_session, entry, osmtpd_session_cmp);
517 void
518 osmtpd_register_filter_connect(void (*cb)(struct osmtpd_ctx *, const char *,
519 struct sockaddr_storage *))
521 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_CONNECT, 1, 0,
522 (void *)cb);
523 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
524 NULL);
527 void
528 osmtpd_register_filter_helo(void (*cb)(struct osmtpd_ctx *, const char *))
530 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_HELO, 1, 0,
531 (void *)cb);
532 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
533 NULL);
536 void
537 osmtpd_register_filter_ehlo(void (*cb)(struct osmtpd_ctx *, const char *))
539 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_EHLO, 1, 0,
540 (void *)cb);
541 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
542 NULL);
545 void
546 osmtpd_register_filter_starttls(void (*cb)(struct osmtpd_ctx *))
548 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_STARTTLS, 1, 0,
549 (void *)cb);
550 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
551 NULL);
554 void
555 osmtpd_register_filter_auth(void (*cb)(struct osmtpd_ctx *, const char *))
557 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_AUTH, 1, 0,
558 (void *)cb);
559 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
560 NULL);
563 void
564 osmtpd_register_filter_mailfrom(void (*cb)(struct osmtpd_ctx *, const char *))
566 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_MAIL_FROM, 1, 0,
567 (void *)cb);
568 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
569 NULL);
572 void
573 osmtpd_register_filter_rcptto(void (*cb)(struct osmtpd_ctx *, const char *))
575 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_RCPT_TO, 1, 0,
576 (void *)cb);
577 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
578 NULL);
581 void
582 osmtpd_register_filter_data(void (*cb)(struct osmtpd_ctx *))
584 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_DATA, 1, 0,
585 (void *)cb);
586 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
587 NULL);
590 void
591 osmtpd_register_filter_dataline(void (*cb)(struct osmtpd_ctx *, const char *))
593 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_DATA_LINE, 1, 0,
594 (void *)cb);
595 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
596 NULL);
599 void
600 osmtpd_register_filter_rset(void (*cb)(struct osmtpd_ctx *))
602 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_RSET, 1, 0,
603 (void *)cb);
604 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
605 NULL);
608 void
609 osmtpd_register_filter_quit(void (*cb)(struct osmtpd_ctx *))
611 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_QUIT, 1, 0,
612 (void *)cb);
613 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
614 NULL);
617 void
618 osmtpd_register_filter_noop(void (*cb)(struct osmtpd_ctx *))
620 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_NOOP, 1, 0,
621 (void *)cb);
622 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
623 NULL);
626 void
627 osmtpd_register_filter_help(void (*cb)(struct osmtpd_ctx *))
629 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_HELP, 1, 0,
630 (void *)cb);
631 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
632 NULL);
635 void
636 osmtpd_register_filter_wiz(void (*cb)(struct osmtpd_ctx *))
638 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_WIZ, 1, 0,
639 (void *)cb);
640 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
641 NULL);
644 void
645 osmtpd_register_filter_commit(void (*cb)(struct osmtpd_ctx *))
647 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_COMMIT, 1, 0,
648 (void *)cb);
649 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT, 1, 0,
650 NULL);
653 void
654 osmtpd_register_report_connect(int incoming, void (*cb)(struct osmtpd_ctx *,
655 const char *, enum osmtpd_status, struct sockaddr_storage *,
656 struct sockaddr_storage *))
658 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_LINK_CONNECT, incoming,
659 0, (void *)cb);
660 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
661 incoming, 0, NULL);
664 void
665 osmtpd_register_report_disconnect(int incoming, void (*cb)(struct osmtpd_ctx *))
667 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
668 incoming, 0, (void *)cb);
671 void
672 osmtpd_register_report_identify(int incoming, void (*cb)(struct osmtpd_ctx *,
673 const char *))
675 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_IDENTIFY,
676 incoming, 0, (void *)cb);
677 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
678 incoming, 0, NULL);
681 void
682 osmtpd_register_report_tls(int incoming, void (*cb)(struct osmtpd_ctx *,
683 const char *))
685 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_TLS, incoming, 0,
686 (void *)cb);
687 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
688 incoming, 0, NULL);
691 void
692 osmtpd_register_report_begin(int incoming, void (*cb)(struct osmtpd_ctx *,
693 uint32_t))
695 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_BEGIN, incoming, 0,
696 (void *)cb);
697 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
698 incoming, 0, NULL);
701 void
702 osmtpd_register_report_mail(int incoming, void (*cb)(struct osmtpd_ctx *,
703 uint32_t, const char *, enum osmtpd_status))
705 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_MAIL, incoming, 0,
706 (void *)cb);
707 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
708 incoming, 0, NULL);
711 void
712 osmtpd_register_report_rcpt(int incoming, void (*cb)(struct osmtpd_ctx *,
713 uint32_t, const char *, enum osmtpd_status))
715 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RCPT, incoming, 0,
716 (void *)cb);
717 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
718 incoming, 0, NULL);
721 void
722 osmtpd_register_report_envelope(int incoming, void (*cb)(struct osmtpd_ctx *,
723 uint32_t, uint64_t))
725 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ENVELOPE, incoming,
726 0, (void *)cb);
727 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
728 incoming, 0, NULL);
731 void
732 osmtpd_register_report_data(int incoming, void (*cb)(struct osmtpd_ctx *,
733 uint32_t, enum osmtpd_status))
735 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_DATA, incoming, 0,
736 (void *)cb);
737 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
738 incoming, 0, NULL);
741 void
742 osmtpd_register_report_commit(int incoming, void (*cb)(struct osmtpd_ctx *,
743 uint32_t, size_t))
745 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_COMMIT, incoming, 0,
746 (void *)cb);
747 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
748 incoming, 0, NULL);
751 void
752 osmtpd_register_report_rollback(int incoming, void (*cb)(struct osmtpd_ctx *,
753 uint32_t))
755 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ROLLBACK, incoming,
756 0, (void *)cb);
757 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
758 incoming, 0, NULL);
761 void
762 osmtpd_register_report_client(int incoming, void (*cb)(struct osmtpd_ctx *,
763 const char *))
765 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_PROTOCOL_CLIENT,
766 incoming, 0, (void *)cb);
767 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
768 incoming, 0, NULL);
771 void
772 osmtpd_register_report_server(int incoming, void (*cb)(struct osmtpd_ctx *,
773 const char *))
775 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_PROTOCOL_SERVER,
776 incoming, 0, (void *)cb);
777 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
778 incoming, 0, NULL);
781 void
782 osmtpd_register_report_response(int incoming, void (*cb)(struct osmtpd_ctx *,
783 const char *))
785 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_FILTER_RESPONSE,
786 incoming, 0, (void *)cb);
787 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
788 incoming, 0, NULL);
791 void
792 osmtpd_register_report_timeout(int incoming, void (*cb)(struct osmtpd_ctx *))
794 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TIMEOUT, incoming, 0,
795 (void *)cb);
796 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
797 incoming, 0, NULL);
800 void
801 osmtpd_local_session(void *(*oncreate)(struct osmtpd_ctx *),
802 void (*ondelete)(struct osmtpd_ctx *, void *))
804 oncreatecb_session = oncreate;
805 ondeletecb_session = ondelete;
808 void
809 osmtpd_local_message(void *(*oncreate)(struct osmtpd_ctx *),
810 void (*ondelete)(struct osmtpd_ctx *, void *))
812 oncreatecb_message = oncreate;
813 ondeletecb_message = ondelete;
816 void
817 osmtpd_need(int lneeds)
819 needs |= lneeds;
822 static void
823 osmtpd_register_need(int incoming)
825 if (needs & (OSMTPD_NEED_SRC | OSMTPD_NEED_DST | OSMTPD_NEED_RDNS |
826 OSMTPD_NEED_FCRDNS))
827 osmtpd_register(OSMTPD_TYPE_FILTER, OSMTPD_PHASE_LINK_CONNECT,
828 incoming, 1, NULL);
829 if (needs & OSMTPD_NEED_IDENTITY)
830 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_IDENTIFY,
831 incoming, 1, NULL);
832 if (needs & OSMTPD_NEED_CIPHERS)
833 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_TLS,
834 incoming, 1, NULL);
835 if (needs & OSMTPD_NEED_MSGID) {
836 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_BEGIN,
837 incoming, 1, NULL);
838 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ROLLBACK,
839 incoming, 0, NULL);
840 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_COMMIT,
841 incoming, 0, NULL);
843 if (needs & OSMTPD_NEED_MAILFROM) {
844 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_MAIL,
845 incoming, 1, NULL);
846 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ROLLBACK,
847 incoming, 0, NULL);
848 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_COMMIT,
849 incoming, 0, NULL);
851 if (needs & OSMTPD_NEED_RCPTTO) {
852 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_RCPT,
853 incoming, 1, NULL);
854 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ROLLBACK,
855 incoming, 0, NULL);
856 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_COMMIT,
857 incoming, 0, NULL);
859 if (needs & OSMTPD_NEED_EVPID) {
860 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ENVELOPE,
861 incoming, 1, NULL);
862 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_ROLLBACK,
863 incoming, 0, NULL);
864 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_TX_COMMIT,
865 incoming, 0, NULL);
868 osmtpd_register(OSMTPD_TYPE_REPORT, OSMTPD_PHASE_LINK_DISCONNECT,
869 incoming, 0, NULL);
872 void
873 osmtpd_run(void)
875 size_t i = 0;
876 int registered = 0;
877 /* Doesn't leak, since it needs to exists until the application ends. */
878 struct io *io_stdin;
880 event_init();
882 if ((io_stdin = io_new()) == NULL ||
883 (io_stdout = io_new()) == NULL)
884 osmtpd_err(1, "io_new");
885 io_set_nonblocking(STDIN_FILENO);
886 io_set_fd(io_stdin, STDIN_FILENO);
887 io_set_callback(io_stdin, osmtpd_newline, NULL);
888 io_set_read(io_stdin);
889 io_set_nonblocking(STDOUT_FILENO);
890 io_set_fd(io_stdout, STDOUT_FILENO);
891 io_set_callback(io_stdout, osmtpd_outevt, NULL);
892 io_set_write(io_stdout);
894 for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
895 if (osmtpd_callbacks[i].doregister) {
896 osmtpd_register_need(osmtpd_callbacks[i].incoming);
897 if (oncreatecb_message != NULL) {
898 osmtpd_register(OSMTPD_TYPE_REPORT,
899 OSMTPD_PHASE_TX_BEGIN,
900 osmtpd_callbacks[i].incoming, 0, NULL);
901 osmtpd_register(OSMTPD_TYPE_REPORT,
902 OSMTPD_PHASE_TX_ROLLBACK,
903 osmtpd_callbacks[i].incoming, 0, NULL);
904 osmtpd_register(OSMTPD_TYPE_REPORT,
905 OSMTPD_PHASE_TX_COMMIT,
906 osmtpd_callbacks[i].incoming, 0, NULL);
910 for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
911 if (osmtpd_callbacks[i].doregister) {
912 if (osmtpd_callbacks[i].cb != NULL)
913 registered = 1;
914 io_printf(io_stdout, "register|%s|smtp-%s|%s\n",
915 osmtpd_typetostr(osmtpd_callbacks[i].type),
916 osmtpd_callbacks[i].incoming ? "in" : "out",
917 osmtpd_phasetostr(osmtpd_callbacks[i].phase));
921 if (!registered)
922 osmtpd_errx(1, "No events registered");
923 io_printf(io_stdout, "register|ready\n");
924 ready = 1;
926 event_dispatch();
929 __dead void
930 osmtpd_err(int eval, const char *fmt, ...)
932 va_list ap;
934 va_start(ap, fmt);
935 vfprintf(stderr, fmt, ap);
936 va_end(ap);
937 fprintf(stderr, ": %s\n", strerror(errno));
938 exit(eval);
941 __dead void
942 osmtpd_errx(int eval, const char *fmt, ...)
944 va_list ap;
946 va_start(ap, fmt);
947 vfprintf(stderr, fmt, ap);
948 va_end(ap);
949 fprintf(stderr, "\n");
950 exit(eval);
953 static void
954 osmtpd_newline(struct io *io, int ev, void *arg)
956 static char *linedup = NULL;
957 static size_t dupsize = 0;
958 struct osmtpd_session *ctx, search;
959 enum osmtpd_type type;
960 enum osmtpd_phase phase;
961 int version_major, version_minor, incoming;
962 struct timespec tm;
963 char *line = NULL;
964 const char *errstr = NULL;
965 size_t linelen;
966 char *end;
967 size_t i;
969 if (ev == IO_DISCONNECTED)
970 exit(0);
971 if (ev != IO_DATAIN)
972 return;
973 while ((line = io_getline(io, &linelen)) > 0) {
974 if (dupsize < linelen) {
975 if ((linedup = realloc(linedup, linelen + 1)) == NULL)
976 osmtpd_err(1, NULL);
977 dupsize = linelen + 1;
979 strlcpy(linedup, line, dupsize);
980 if ((end = strchr(line, '|')) == NULL)
981 osmtpd_errx(1, "Invalid line received: missing "
982 "version: %s", linedup);
983 end++[0] = '\0';
984 if (strcmp(line, "filter") == 0)
985 type = OSMTPD_TYPE_FILTER;
986 else if (strcmp(line, "report") == 0)
987 type = OSMTPD_TYPE_REPORT;
988 else if (strcmp(line, "config") == 0) {
989 line = end;
990 if (strcmp(line, "ready") == 0)
991 continue;
992 if ((end = strchr(line, '|')) == NULL)
993 osmtpd_errx(1, "Invalid line received: missing "
994 "key: %s", linedup);
995 end++[0] = '\0';
996 if (strcmp(line, "smtp-session-timeout") == 0) {
997 session_timeout = strtonum(end, 0, INT_MAX,
998 &errstr);
999 if (errstr != NULL)
1000 osmtpd_errx(1, "Invalid line received: "
1001 "invalid smtp-sesion-timeout: %s",
1002 linedup);
1004 continue;
1006 else
1007 osmtpd_errx(1, "Invalid line received: unknown message "
1008 "type: %s", linedup);
1009 line = end;
1010 if ((end = strchr(line, '|')) == NULL)
1011 osmtpd_errx(1, "Invalid line received: missing time: "
1012 "%s", linedup);
1013 end++[0] = '\0';
1014 if (strcmp(line, "0.1") != 0)
1015 osmtpd_errx(1, "Unsupported protocol received: %s",
1016 linedup);
1017 version_major = 0;
1018 version_minor = 1;
1019 line = end;
1020 if ((end = strchr(line, '.')) == NULL)
1021 osmtpd_errx(1, "Invalid line received: invalid "
1022 "timestamp: %s", linedup);
1023 end++[0] = '\0';
1024 tm.tv_sec = (time_t) strtonum(line, 0, INT64_MAX, &errstr);
1025 if (errstr != NULL)
1026 osmtpd_errx(1, "Invalid line received: invalid "
1027 "timestamp: %s", linedup);
1028 line = end;
1029 if ((end = strchr(line, '|')) == NULL)
1030 osmtpd_errx(1, "Invalid line received: missing "
1031 "direction: %s", linedup);
1032 end++[0] = '\0';
1033 tm.tv_nsec = (long) strtonum(line, 0, LONG_MAX, &errstr);
1034 if (errstr != NULL)
1035 osmtpd_errx(1, "Invalid line received: invalid "
1036 "timestamp: %s", linedup);
1037 tm.tv_nsec *= 10 * (9 - (end - line));
1038 line = end;
1039 if ((end = strchr(line, '|')) == NULL)
1040 osmtpd_errx(1, "Invalid line receieved: missing "
1041 "phase: %s", linedup);
1042 end++[0] = '\0';
1043 if (strcmp(line, "smtp-in") == 0)
1044 incoming = 1;
1045 else if (strcmp(line, "smtp-out") == 0)
1046 incoming = 0;
1047 else
1048 osmtpd_errx(1, "Invalid line: invalid direction: %s",
1049 linedup);
1050 line = end;
1051 if ((end = strchr(line, '|')) == NULL)
1052 osmtpd_errx(1, "Invalid line received: missing reqid: "
1053 "%s", linedup);
1054 end++[0] = '\0';
1055 phase = osmtpd_strtophase(line, linedup);
1056 line = end;
1057 errno = 0;
1058 search.ctx.reqid = strtoull(line, &end, 16);
1059 if ((search.ctx.reqid == ULLONG_MAX && errno != 0) ||
1060 (end[0] != '|' && end[0] != '\0'))
1061 osmtpd_errx(1, "Invalid line received: invalid reqid: "
1062 "%s", linedup);
1063 line = end + 1;
1064 ctx = RB_FIND(osmtpd_sessions, &osmtpd_sessions, &search);
1065 if (ctx == NULL) {
1066 if ((ctx = malloc(sizeof(*ctx))) == NULL)
1067 osmtpd_err(1, NULL);
1068 ctx->ctx.reqid = search.ctx.reqid;
1069 ctx->ctx.rdns = NULL;
1070 ctx->ctx.fcrdns = OSMTPD_STATUS_TEMPFAIL;
1071 ctx->ctx.identity = NULL;
1072 ctx->ctx.ciphers = NULL;
1073 ctx->ctx.msgid = 0;
1074 ctx->ctx.mailfrom = NULL;
1075 ctx->ctx.rcptto = malloc(sizeof(*(ctx->ctx.rcptto)));
1076 if (ctx->ctx.rcptto == NULL)
1077 osmtpd_err(1, "malloc");
1078 ctx->ctx.rcptto[0] = NULL;
1079 memset(&(ctx->ctx.src), 0, sizeof(ctx->ctx.src));
1080 ctx->ctx.src.ss_family = AF_UNSPEC;
1081 memset(&(ctx->ctx.dst), 0, sizeof(ctx->ctx.dst));
1082 ctx->ctx.dst.ss_family = AF_UNSPEC;
1083 RB_INSERT(osmtpd_sessions, &osmtpd_sessions, ctx);
1084 ctx->ctx.evpid = 0;
1085 ctx->ctx.local_session = NULL;
1086 ctx->ctx.local_message = NULL;
1087 if (oncreatecb_session != NULL)
1088 ctx->ctx.local_session =
1089 oncreatecb_session(&ctx->ctx);
1091 ctx->ctx.type = type;
1092 ctx->ctx.phase = phase;
1093 ctx->ctx.version_major = version_major;
1094 ctx->ctx.version_minor = version_minor;
1095 ctx->ctx.incoming = incoming;
1096 ctx->ctx.tm.tv_sec = tm.tv_sec;
1097 ctx->ctx.tm.tv_nsec = tm.tv_nsec;
1098 ctx->ctx.token = 0;
1100 for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
1101 if (ctx->ctx.type == osmtpd_callbacks[i].type &&
1102 ctx->ctx.phase == osmtpd_callbacks[i].phase &&
1103 ctx->ctx.incoming == osmtpd_callbacks[i].incoming)
1104 break;
1106 if (i == NITEMS(osmtpd_callbacks)) {
1107 osmtpd_errx(1, "Invalid line received: received "
1108 "unregistered line: %s", linedup);
1110 if (ctx->ctx.type == OSMTPD_TYPE_FILTER) {
1111 ctx->ctx.token = strtoull(line, &end, 16);
1112 if ((ctx->ctx.token == ULLONG_MAX && errno != 0) ||
1113 end[0] != '|')
1114 osmtpd_errx(1, "Invalid line received: invalid "
1115 "token: %s", linedup);
1116 line = end + 1;
1118 osmtpd_callbacks[i].osmtpd_cb(&(osmtpd_callbacks[i]),
1119 &(ctx->ctx), line, linedup);
1123 static void
1124 osmtpd_outevt(struct io *io, int evt, void *arg)
1126 switch (evt) {
1127 case IO_LOWAT:
1128 return;
1129 case IO_DISCONNECTED:
1130 exit(0);
1131 default:
1132 osmtpd_errx(1, "Unexpectd event");
1136 static void
1137 osmtpd_noargs(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx, char *params,
1138 char *linedup)
1140 void (*f)(struct osmtpd_ctx *);
1142 f = cb->cb;
1143 f(ctx);
1146 static void
1147 osmtpd_onearg(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx, char *line,
1148 char *linedup)
1150 void (*f)(struct osmtpd_ctx *, const char *);
1152 f = cb->cb;
1153 f(ctx, line);
1156 static void
1157 osmtpd_connect(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx, char *params,
1158 char *linedup)
1160 struct sockaddr_storage ss;
1161 char *hostname;
1162 char *address;
1163 void (*f)(struct osmtpd_ctx *, const char *, struct sockaddr_storage *);
1165 hostname = params;
1166 if ((address = strchr(params, '|')) == NULL)
1167 osmtpd_errx(1, "Invalid line received: missing address: %s",
1168 linedup);
1169 address++[0] = '\0';
1171 osmtpd_addrtoss(address, &ss, 0, linedup);
1173 f = cb->cb;
1174 f(ctx, hostname, &ss);
1177 static void
1178 osmtpd_link_connect(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1179 char *params, char *linedup)
1181 char *end, *rdns;
1182 enum osmtpd_status fcrdns;
1183 struct sockaddr_storage src, dst;
1184 void (*f)(struct osmtpd_ctx *, const char *, enum osmtpd_status,
1185 struct sockaddr_storage *, struct sockaddr_storage *);
1187 if ((end = strchr(params, '|')) == NULL)
1188 osmtpd_errx(1, "Invalid line received: missing fcrdns: %s",
1189 linedup);
1190 end++[0] = '\0';
1191 rdns = params;
1192 params = end;
1193 if ((end = strchr(params, '|')) == NULL)
1194 osmtpd_errx(1, "Invalid line received: missing src: %s",
1195 linedup);
1196 end++[0] = '\0';
1197 if (strcmp(params, "pass") == 0)
1198 fcrdns = OSMTPD_STATUS_OK;
1199 else if (strcmp(params, "fail") == 0)
1200 fcrdns = OSMTPD_STATUS_PERMFAIL;
1201 else if (strcmp(params, "error") == 0)
1202 fcrdns = OSMTPD_STATUS_TEMPFAIL;
1203 else
1204 osmtpd_errx(1, "Invalid line received: invalid fcrdns: %s",
1205 linedup);
1206 params = end;
1207 if ((end = strchr(params, '|')) == NULL)
1208 osmtpd_errx(1, "Invalid line received: missing dst: %s",
1209 linedup);
1210 end++[0] = '\0';
1211 osmtpd_addrtoss(params, &src, 1, linedup);
1212 params = end;
1213 osmtpd_addrtoss(params, &dst, 1, linedup);
1214 if (cb->storereport) {
1215 if ((ctx->rdns = strdup(rdns)) == NULL)
1216 osmtpd_err(1, "strdup");
1217 ctx->fcrdns = fcrdns;
1218 memcpy(&(ctx->src), &src, sizeof(ctx->src));
1219 memcpy(&(ctx->dst), &dst, sizeof(ctx->dst));
1221 if ((f = cb->cb) != NULL)
1222 f(ctx, rdns, fcrdns, &src, &dst);
1225 static void
1226 osmtpd_link_disconnect(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1227 char *param, char *linedup)
1229 void (*f)(struct osmtpd_ctx *);
1230 size_t i;
1231 struct osmtpd_session *session, search;
1233 if ((f = cb->cb) != NULL)
1234 f(ctx);
1236 search.ctx.reqid = ctx->reqid;
1237 session = RB_FIND(osmtpd_sessions, &osmtpd_sessions, &search);
1238 if (session != NULL) {
1239 RB_REMOVE(osmtpd_sessions, &osmtpd_sessions, session);
1240 if (ondeletecb_session != NULL)
1241 ondeletecb_session(ctx, session->ctx.local_session);
1242 free(session->ctx.rdns);
1243 free(session->ctx.identity);
1244 free(session->ctx.ciphers);
1245 free(session->ctx.mailfrom);
1246 for (i = 0; session->ctx.rcptto[i] != NULL; i++)
1247 free(session->ctx.rcptto[i]);
1248 free(session->ctx.rcptto);
1249 free(session);
1253 static void
1254 osmtpd_link_identify(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1255 char *identity, char *linedup)
1257 void (*f)(struct osmtpd_ctx *, const char *);
1259 if (cb->storereport) {
1260 if ((ctx->identity = strdup(identity)) == NULL)
1261 osmtpd_err(1, NULL);
1264 if ((f = cb->cb) != NULL)
1265 f(ctx, identity);
1268 static void
1269 osmtpd_link_tls(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1270 char *ciphers, char *linedup)
1272 void (*f)(struct osmtpd_ctx *, const char *);
1274 if (cb->storereport) {
1275 if ((ctx->ciphers = strdup(ciphers)) == NULL)
1276 osmtpd_err(1, NULL);
1279 if ((f = cb->cb) != NULL)
1280 f(ctx, ciphers);
1283 static void
1284 osmtpd_tx_begin(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1285 char *msgid, char *linedup)
1287 unsigned long imsgid;
1288 char *endptr;
1289 void (*f)(struct osmtpd_ctx *, uint32_t);
1291 errno = 0;
1292 imsgid = strtoul(msgid, &endptr, 16);
1293 if ((imsgid == ULONG_MAX && errno != 0) || endptr[0] != '\0')
1294 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1295 linedup);
1296 ctx->msgid = imsgid;
1297 /* Check if we're in range */
1298 if ((unsigned long) ctx->msgid != imsgid)
1299 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1300 linedup);
1302 if (!cb->storereport)
1303 ctx->msgid = 0;
1305 if (oncreatecb_message != NULL)
1306 ctx->local_message = oncreatecb_message(ctx);
1308 if ((f = cb->cb) != NULL)
1309 f(ctx, imsgid);
1312 static void
1313 osmtpd_tx_mail(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1314 char *params, char *linedup)
1316 char *end, *mailfrom;
1317 unsigned long imsgid;
1318 uint32_t msgid;
1319 void (*f)(struct osmtpd_ctx *, uint32_t, const char *,
1320 enum osmtpd_status);
1322 errno = 0;
1323 imsgid = strtoul(params, &end, 16);
1324 if ((imsgid == ULONG_MAX && errno != 0))
1325 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1326 linedup);
1327 if (end[0] != '|')
1328 osmtpd_errx(1, "Invalid line received: missing address: %s",
1329 linedup);
1330 msgid = imsgid;
1331 if ((unsigned long) msgid != imsgid)
1332 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1333 linedup);
1334 params = end + 1;
1336 if ((end = strchr(params, '|')) == NULL)
1337 osmtpd_errx(1, "Invalid line received: missing status: %s",
1338 linedup);
1339 end++[0] = '\0';
1340 mailfrom = params;
1341 if (cb->storereport) {
1342 if ((ctx->mailfrom = strdup(mailfrom)) == NULL)
1343 osmtpd_err(1, NULL);
1345 params = end;
1347 if ((f = cb->cb) != NULL)
1348 f(ctx, msgid, mailfrom, osmtpd_strtostatus(params, linedup));
1351 static void
1352 osmtpd_tx_rcpt(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1353 char *params, char *linedup)
1355 char *end, *rcptto;
1356 unsigned long imsgid;
1357 uint32_t msgid;
1358 size_t i;
1359 void (*f)(struct osmtpd_ctx *, uint32_t, const char *,
1360 enum osmtpd_status);
1362 errno = 0;
1363 imsgid = strtoul(params, &end, 16);
1364 if ((imsgid == ULONG_MAX && errno != 0))
1365 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1366 linedup);
1367 if (end[0] != '|')
1368 osmtpd_errx(1, "Invalid line received: missing address: %s",
1369 linedup);
1370 msgid = imsgid;
1371 if ((unsigned long) msgid != imsgid)
1372 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1373 linedup);
1374 params = end + 1;
1376 if ((end = strchr(params, '|')) == NULL)
1377 osmtpd_errx(1, "Invalid line received: missing status: %s",
1378 linedup);
1379 end++[0] = '\0';
1381 rcptto = params;
1382 params = end;
1384 if (cb->storereport) {
1385 for (i = 0; ctx->rcptto[i] != NULL; i++)
1387 ctx->rcptto = reallocarray(ctx->rcptto, i + 2,
1388 sizeof(*(ctx->rcptto)));
1389 if (ctx->rcptto == NULL)
1390 osmtpd_err(1, NULL);
1392 if ((ctx->rcptto[i] = strdup(rcptto)) == NULL)
1393 osmtpd_err(1, NULL);
1394 ctx->rcptto[i + 1] = NULL;
1397 if ((f = cb->cb) != NULL)
1398 f(ctx, msgid, rcptto,
1399 osmtpd_strtostatus(params, linedup));
1402 static void
1403 osmtpd_tx_envelope(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1404 char *params, char *linedup)
1406 unsigned long imsgid;
1407 uint32_t msgid;
1408 uint64_t evpid;
1409 char *end;
1410 void (*f)(struct osmtpd_ctx *, uint32_t, uint64_t);
1412 errno = 0;
1413 imsgid = strtoul(params, &end, 16);
1414 if ((imsgid == ULONG_MAX && errno != 0))
1415 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1416 linedup);
1417 if (end[0] != '|')
1418 osmtpd_errx(1, "Invalid line received: missing address: %s",
1419 linedup);
1420 msgid = imsgid;
1421 if ((unsigned long) msgid != imsgid)
1422 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1423 linedup);
1424 params = end + 1;
1426 evpid = strtoull(params, &end, 16);
1427 if ((ctx->evpid == ULLONG_MAX && errno != 0) ||
1428 end[0] != '\0')
1429 osmtpd_errx(1, "Invalid line received: invalid evpid: %s",
1430 linedup);
1431 if (cb->storereport)
1432 ctx->evpid = evpid;
1434 if ((f = cb->cb) != NULL)
1435 f(ctx, msgid, evpid);
1438 static void
1439 osmtpd_tx_data(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1440 char *params, char *linedup)
1442 char *end;
1443 unsigned long imsgid;
1444 uint32_t msgid;
1445 void (*f)(struct osmtpd_ctx *, uint32_t, enum osmtpd_status);
1447 errno = 0;
1448 imsgid = strtoul(params, &end, 16);
1449 if ((imsgid == ULONG_MAX && errno != 0))
1450 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1451 linedup);
1452 if (end[0] != '|')
1453 osmtpd_errx(1, "Invalid line received: missing address: %s",
1454 linedup);
1455 msgid = imsgid;
1456 if ((unsigned long) msgid != imsgid)
1457 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1458 linedup);
1459 params = end + 1;
1461 if ((f = cb->cb) != NULL)
1462 f(ctx, msgid, osmtpd_strtostatus(params, linedup));
1465 static void
1466 osmtpd_tx_commit(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1467 char *params, char *linedup)
1469 char *end;
1470 const char *errstr = NULL;
1471 unsigned long imsgid;
1472 uint32_t msgid;
1473 size_t i, msgsz;
1474 void (*f)(struct osmtpd_ctx *, uint32_t, size_t);
1476 errno = 0;
1477 imsgid = strtoul(params, &end, 16);
1478 if ((imsgid == ULONG_MAX && errno != 0))
1479 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1480 linedup);
1481 if (end[0] != '|')
1482 osmtpd_errx(1, "Invalid line received: missing address: %s",
1483 linedup);
1484 msgid = imsgid;
1485 if ((unsigned long) msgid != imsgid)
1486 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1487 linedup);
1488 params = end + 1;
1490 msgsz = strtonum(params, 0, UINT32_MAX, &errstr);
1491 if (errstr != NULL)
1492 osmtpd_errx(1, "Invalid line received: invalid msg size: %s",
1493 linedup);
1495 if ((f = cb->cb) != NULL)
1496 f(ctx, msgid, msgsz);
1498 if (ondeletecb_message != NULL) {
1499 ondeletecb_message(ctx, ctx->local_message);
1500 ctx->local_message = NULL;
1503 free(ctx->mailfrom);
1504 ctx->mailfrom = NULL;
1506 for (i = 0; ctx->rcptto[i] != NULL; i++)
1507 free(ctx->rcptto[i]);
1508 ctx->rcptto[0] = NULL;
1509 ctx->evpid = 0;
1510 ctx->msgid = 0;
1513 static void
1514 osmtpd_tx_rollback(struct osmtpd_callback *cb, struct osmtpd_ctx *ctx,
1515 char *params, char *linedup)
1517 char *end;
1518 unsigned long imsgid;
1519 uint32_t msgid;
1520 size_t i;
1521 void (*f)(struct osmtpd_ctx *, uint32_t);
1523 errno = 0;
1524 imsgid = strtoul(params, &end, 16);
1525 if ((imsgid == ULONG_MAX && errno != 0))
1526 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1527 linedup);
1528 if (end[0] != '\0')
1529 osmtpd_errx(1, "Invalid line received: missing address: %s",
1530 linedup);
1531 msgid = imsgid;
1532 if ((unsigned long) msgid != imsgid)
1533 osmtpd_errx(1, "Invalid line received: invalid msgid: %s",
1534 linedup);
1536 if ((f = cb->cb) != NULL)
1537 f(ctx, msgid);
1539 if (ondeletecb_message != NULL) {
1540 ondeletecb_message(ctx, ctx->local_message);
1541 ctx->local_message = NULL;
1544 free(ctx->mailfrom);
1545 ctx->mailfrom = NULL;
1547 for (i = 0; ctx->rcptto[i] != NULL; i++)
1548 free(ctx->rcptto[i]);
1549 ctx->rcptto[0] = NULL;
1550 ctx->evpid = 0;
1551 ctx->msgid = 0;
1554 void
1555 osmtpd_filter_proceed(struct osmtpd_ctx *ctx)
1557 io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1558 "proceed\n", ctx->token, ctx->reqid);
1561 void
1562 osmtpd_filter_reject(struct osmtpd_ctx *ctx, int code, const char *reason, ...)
1564 va_list ap;
1566 if (code < 200 || code > 599)
1567 osmtpd_errx(1, "Invalid reject code");
1569 io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|reject|"
1570 "%d ", ctx->token, ctx->reqid, code);
1571 va_start(ap, reason);
1572 io_vprintf(io_stdout, reason, ap);
1573 va_end(ap);
1574 io_printf(io_stdout, "\n");
1577 void
1578 osmtpd_filter_disconnect(struct osmtpd_ctx *ctx, const char *reason, ...)
1580 va_list ap;
1582 io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1583 "disconnect|421 ", ctx->token, ctx->reqid);
1584 va_start(ap, reason);
1585 io_vprintf(io_stdout, reason, ap);
1586 va_end(ap);
1587 io_printf(io_stdout, "\n");
1590 void
1591 osmtpd_filter_rewrite(struct osmtpd_ctx *ctx, const char *value, ...)
1593 va_list ap;
1595 io_printf(io_stdout, "filter-result|%016"PRIx64"|%016"PRIx64"|"
1596 "rewrite|", ctx->token, ctx->reqid);
1597 va_start(ap, value);
1598 io_vprintf(io_stdout, value, ap);
1599 va_end(ap);
1600 io_printf(io_stdout, "\n");
1603 void
1604 osmtpd_filter_dataline(struct osmtpd_ctx *ctx, const char *line, ...)
1606 va_list ap;
1608 io_printf(io_stdout, "filter-dataline|%016"PRIx64"|%016"PRIx64"|",
1609 ctx->token, ctx->reqid);
1610 va_start(ap, line);
1611 io_vprintf(io_stdout, line, ap);
1612 va_end(ap);
1613 io_printf(io_stdout, "\n");
1616 static void
1617 osmtpd_register(enum osmtpd_type type, enum osmtpd_phase phase, int incoming,
1618 int storereport, void *cb)
1620 size_t i;
1622 if (ready)
1623 osmtpd_errx(1, "Can't register when proc is running");
1625 for (i = 0; i < NITEMS(osmtpd_callbacks); i++) {
1626 if (type == osmtpd_callbacks[i].type &&
1627 phase == osmtpd_callbacks[i].phase &&
1628 incoming == osmtpd_callbacks[i].incoming) {
1629 if (osmtpd_callbacks[i].cb != NULL && cb != NULL)
1630 osmtpd_errx(1, "Event already registered");
1631 if (cb != NULL)
1632 osmtpd_callbacks[i].cb = cb;
1633 osmtpd_callbacks[i].doregister = 1;
1634 if (storereport)
1635 osmtpd_callbacks[i].storereport = 1;
1636 return;
1639 /* NOT REACHED */
1640 osmtpd_errx(1, "Trying to register unknown event");
1643 static enum osmtpd_phase
1644 osmtpd_strtophase(const char *phase, const char *linedup)
1646 if (strcmp(phase, "connect") == 0)
1647 return OSMTPD_PHASE_CONNECT;
1648 if (strcmp(phase, "helo") == 0)
1649 return OSMTPD_PHASE_HELO;
1650 if (strcmp(phase, "ehlo") == 0)
1651 return OSMTPD_PHASE_EHLO;
1652 if (strcmp(phase, "starttls") == 0)
1653 return OSMTPD_PHASE_STARTTLS;
1654 if (strcmp(phase, "auth") == 0)
1655 return OSMTPD_PHASE_AUTH;
1656 if (strcmp(phase, "mail-from") == 0)
1657 return OSMTPD_PHASE_MAIL_FROM;
1658 if (strcmp(phase, "rcpt-to") == 0)
1659 return OSMTPD_PHASE_RCPT_TO;
1660 if (strcmp(phase, "data") == 0)
1661 return OSMTPD_PHASE_DATA;
1662 if (strcmp(phase, "data-line") == 0)
1663 return OSMTPD_PHASE_DATA_LINE;
1664 if (strcmp(phase, "rset") == 0)
1665 return OSMTPD_PHASE_RSET;
1666 if (strcmp(phase, "quit") == 0)
1667 return OSMTPD_PHASE_QUIT;
1668 if (strcmp(phase, "noop") == 0)
1669 return OSMTPD_PHASE_NOOP;
1670 if (strcmp(phase, "help") == 0)
1671 return OSMTPD_PHASE_HELP;
1672 if (strcmp(phase, "wiz") == 0)
1673 return OSMTPD_PHASE_WIZ;
1674 if (strcmp(phase, "commit") == 0)
1675 return OSMTPD_PHASE_COMMIT;
1676 if (strcmp(phase, "link-connect") == 0)
1677 return OSMTPD_PHASE_LINK_CONNECT;
1678 if (strcmp(phase, "link-disconnect") == 0)
1679 return OSMTPD_PHASE_LINK_DISCONNECT;
1680 if (strcmp(phase, "link-identify") == 0)
1681 return OSMTPD_PHASE_LINK_IDENTIFY;
1682 if (strcmp(phase, "link-tls") == 0)
1683 return OSMTPD_PHASE_LINK_TLS;
1684 if (strcmp(phase, "tx-begin") == 0)
1685 return OSMTPD_PHASE_TX_BEGIN;
1686 if (strcmp(phase, "tx-mail") == 0)
1687 return OSMTPD_PHASE_TX_MAIL;
1688 if (strcmp(phase, "tx-rcpt") == 0)
1689 return OSMTPD_PHASE_TX_RCPT;
1690 if (strcmp(phase, "tx-envelope") == 0)
1691 return OSMTPD_PHASE_TX_ENVELOPE;
1692 if (strcmp(phase, "tx-data") == 0)
1693 return OSMTPD_PHASE_TX_DATA;
1694 if (strcmp(phase, "tx-commit") == 0)
1695 return OSMTPD_PHASE_TX_COMMIT;
1696 if (strcmp(phase, "tx-rollback") == 0)
1697 return OSMTPD_PHASE_TX_ROLLBACK;
1698 if (strcmp(phase, "protocol-client") == 0)
1699 return OSMTPD_PHASE_PROTOCOL_CLIENT;
1700 if (strcmp(phase, "protocol-server") == 0)
1701 return OSMTPD_PHASE_PROTOCOL_SERVER;
1702 if (strcmp(phase, "filter-response") == 0)
1703 return OSMTPD_PHASE_FILTER_RESPONSE;
1704 if (strcmp(phase, "timeout") == 0)
1705 return OSMTPD_PHASE_TIMEOUT;
1706 osmtpd_errx(1, "Invalid line received: invalid phase: %s", linedup);
1709 static const char *
1710 osmtpd_typetostr(enum osmtpd_type type)
1712 switch (type) {
1713 case OSMTPD_TYPE_FILTER:
1714 return "filter";
1715 case OSMTPD_TYPE_REPORT:
1716 return "report";
1718 osmtpd_errx(1, "In valid type: %d\n", type);
1721 static const char *
1722 osmtpd_phasetostr(enum osmtpd_phase phase)
1724 switch (phase) {
1725 case OSMTPD_PHASE_CONNECT:
1726 return "connect";
1727 case OSMTPD_PHASE_HELO:
1728 return "helo";
1729 case OSMTPD_PHASE_EHLO:
1730 return "ehlo";
1731 case OSMTPD_PHASE_STARTTLS:
1732 return "starttls";
1733 case OSMTPD_PHASE_AUTH:
1734 return "auth";
1735 case OSMTPD_PHASE_MAIL_FROM:
1736 return "mail-from";
1737 case OSMTPD_PHASE_RCPT_TO:
1738 return "rcpt-to";
1739 case OSMTPD_PHASE_DATA:
1740 return "data";
1741 case OSMTPD_PHASE_DATA_LINE:
1742 return "data-line";
1743 case OSMTPD_PHASE_RSET:
1744 return "rset";
1745 case OSMTPD_PHASE_QUIT:
1746 return "quit";
1747 case OSMTPD_PHASE_NOOP:
1748 return "noop";
1749 case OSMTPD_PHASE_HELP:
1750 return "help";
1751 case OSMTPD_PHASE_WIZ:
1752 return "wiz";
1753 case OSMTPD_PHASE_COMMIT:
1754 return "commit";
1755 case OSMTPD_PHASE_LINK_CONNECT:
1756 return "link-connect";
1757 case OSMTPD_PHASE_LINK_DISCONNECT:
1758 return "link-disconnect";
1759 case OSMTPD_PHASE_LINK_IDENTIFY:
1760 return "link-identify";
1761 case OSMTPD_PHASE_LINK_TLS:
1762 return "link-tls";
1763 case OSMTPD_PHASE_TX_BEGIN:
1764 return "tx-begin";
1765 case OSMTPD_PHASE_TX_MAIL:
1766 return "tx-mail";
1767 case OSMTPD_PHASE_TX_RCPT:
1768 return "tx-rcpt";
1769 case OSMTPD_PHASE_TX_ENVELOPE:
1770 return "tx-envelope";
1771 case OSMTPD_PHASE_TX_DATA:
1772 return "tx-data";
1773 case OSMTPD_PHASE_TX_COMMIT:
1774 return "tx-commit";
1775 case OSMTPD_PHASE_TX_ROLLBACK:
1776 return "tx-rollback";
1777 case OSMTPD_PHASE_PROTOCOL_CLIENT:
1778 return "protocol-client";
1779 case OSMTPD_PHASE_PROTOCOL_SERVER:
1780 return "protocol-server";
1781 case OSMTPD_PHASE_FILTER_RESPONSE:
1782 return "filter-response";
1783 case OSMTPD_PHASE_TIMEOUT:
1784 return "timeout";
1786 osmtpd_errx(1, "In valid phase: %d\n", phase);
1789 static enum
1790 osmtpd_status osmtpd_strtostatus(const char *status, char *linedup)
1792 if (strcmp(status, "ok") == 0)
1793 return OSMTPD_STATUS_OK;
1794 else if (strcmp(status, "tempfail") == 0)
1795 return OSMTPD_STATUS_TEMPFAIL;
1796 else if (strcmp(status, "permfail") == 0)
1797 return OSMTPD_STATUS_PERMFAIL;
1798 osmtpd_errx(1, "Invalid line received: invalid status: %s\n", linedup);
1801 static void
1802 osmtpd_addrtoss(char *addr, struct sockaddr_storage *ss, int hasport,
1803 char *linedup)
1805 char *port;
1806 const char *errstr = NULL;
1807 struct sockaddr_in *sin;
1808 struct sockaddr_in6 *sin6;
1809 struct sockaddr_un *sun;
1811 if (strncasecmp(addr, "ipv6:", 5) == 0) {
1812 sin6 = (struct sockaddr_in6 *)ss;
1813 sin6->sin6_len = sizeof(*sin6);
1814 sin6->sin6_family = AF_INET6;
1815 sin6->sin6_port = 0;
1816 if (hasport) {
1817 if ((port = strrchr(addr, ':')) == NULL)
1818 osmtpd_errx(1, "Invalid line received: invalid "
1819 "address (%s): %s", addr, linedup);
1820 port++;
1821 sin6->sin6_port = htons(strtonum(port, 0, UINT16_MAX,
1822 &errstr));
1823 if (errstr != NULL)
1824 osmtpd_errx(1, "Invalid line received: invalid "
1825 "address (%s): %s", addr, linedup);
1826 port[-1] = '\0';
1828 switch (inet_pton(AF_INET6, addr + 5, &(sin6->sin6_addr))) {
1829 case 1:
1830 break;
1831 case 0:
1832 port[-1] = ':';
1833 osmtpd_errx(1, "Invalid line received: invalid address "
1834 "(%s): %s", addr, linedup);
1835 default:
1836 port[-1] = ':';
1837 osmtpd_err(1, "Can't parse address (%s): %s", addr,
1838 linedup);
1840 } else if (strncasecmp(addr, "unix:", 5) == 0) {
1841 sun = (struct sockaddr_un *)ss;
1842 sun->sun_len = sizeof(*sun);
1843 sun->sun_family = AF_UNIX;
1844 if (strlcpy(sun->sun_path, addr,
1845 sizeof(sun->sun_path)) >= sizeof(sun->sun_path)) {
1846 osmtpd_errx(1, "Invalid line received: address too "
1847 "long (%s): %s", addr, linedup);
1849 } else {
1850 sin = (struct sockaddr_in *)ss;
1851 sin->sin_len = sizeof(*sin);
1852 sin->sin_family = AF_INET;
1853 sin->sin_port = 0;
1854 if (hasport) {
1855 if ((port = strrchr(addr, ':')) == NULL)
1856 osmtpd_errx(1, "Invalid line received: invalid "
1857 "address (%s): %s", addr, linedup);
1858 port++;
1859 sin->sin_port = htons(strtonum(port, 0, UINT16_MAX,
1860 &errstr));
1861 if (errstr != NULL)
1862 osmtpd_errx(1, "Invalid line received: invalid "
1863 "address (%s): %s", addr, linedup);
1864 port[-1] = '\0';
1866 switch (inet_pton(AF_INET, addr, &(sin->sin_addr))) {
1867 case 1:
1868 break;
1869 case 0:
1870 port[-1] = ':';
1871 osmtpd_errx(1, "Invalid line received: invalid address "
1872 "(%s): %s", addr, linedup);
1873 default:
1874 port[-1] = ':';
1875 osmtpd_err(1, "Can't parse address (%s): %s", addr,
1876 linedup);
1881 static int
1882 osmtpd_session_cmp(struct osmtpd_session *a, struct osmtpd_session *b)
1884 return a->ctx.reqid < b->ctx.reqid ? -1 : a->ctx.reqid > b->ctx.reqid;
1887 RB_GENERATE_STATIC(osmtpd_sessions, osmtpd_session, entry, osmtpd_session_cmp);