smtpd.h revision 1.244
1/* $OpenBSD: smtpd.h,v 1.244 2011/10/23 13:03:05 gilles Exp $ */ 2 3/* 4 * Copyright (c) 2008 Gilles Chehade <gilles@openbsd.org> 5 * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20#ifndef nitems 21#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 22#endif 23 24#include "filter.h" 25 26#define IMSG_SIZE_CHECK(p) do { \ 27 if (IMSG_DATA_SIZE(&imsg) != sizeof(*p)) \ 28 fatalx("bad length imsg received"); \ 29 } while (0) 30#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE) 31 32 33#define CONF_FILE "/etc/mail/smtpd.conf" 34#define MAX_LISTEN 16 35#define PROC_COUNT 9 36#define MAX_NAME_SIZE 64 37 38#define MAX_HOPS_COUNT 100 39 40#define MAX_TAG_SIZE 32 41/* SYNC WITH filter.h */ 42//#define MAX_LINE_SIZE 1024 43//#define MAX_LOCALPART_SIZE 128 44//#define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN 45 46/* return and forward path size */ 47#define MAX_FILTER_NAME 32 48#define MAX_PATH_SIZE 256 49#define MAX_RULEBUFFER_LEN 256 50 51#define SMTPD_QUEUE_INTERVAL (15 * 60) 52#define SMTPD_QUEUE_MAXINTERVAL (4 * 60 * 60) 53#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 54#define SMTPD_USER "_smtpd" 55#define SMTPD_FILTER_USER "_smtpmfa" 56#define SMTPD_SOCKET "/var/run/smtpd.sock" 57#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 58#define SMTPD_SESSION_TIMEOUT 300 59#define SMTPD_BACKLOG 5 60 61#define PATH_MAILLOCAL "/usr/libexec/mail.local" 62#define PATH_SMTPCTL "/usr/sbin/smtpctl" 63 64#define DIRHASH_BUCKETS 4096 65 66#define PATH_SPOOL "/var/spool/smtpd" 67 68#define PATH_ENQUEUE "/enqueue" 69#define PATH_INCOMING "/incoming" 70#define PATH_QUEUE "/queue" 71#define PATH_PURGE "/purge" 72#define PATH_CORRUPT "/corrupt" 73 74#define PATH_MESSAGE "/message" 75#define PATH_ENVELOPES "/envelopes" 76 77#define PATH_OFFLINE "/offline" 78#define PATH_BOUNCE "/bounce" 79 80/* number of MX records to lookup */ 81#define MAX_MX_COUNT 10 82 83/* max response delay under flood conditions */ 84#define MAX_RESPONSE_DELAY 60 85 86/* how many responses per state are undelayed */ 87#define FAST_RESPONSES 2 88 89/* max len of any smtp line */ 90#define SMTP_LINE_MAX 1024 91 92#define F_STARTTLS 0x01 93#define F_SMTPS 0x02 94#define F_AUTH 0x04 95#define F_SSL (F_SMTPS|F_STARTTLS) 96 97#define F_SCERT 0x01 98#define F_CCERT 0x02 99 100#define ADVERTISE_TLS(s) \ 101 ((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE)) 102 103#define ADVERTISE_AUTH(s) \ 104 ((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \ 105 !((s)->s_flags & F_AUTHENTICATED)) 106 107 108 109typedef u_int32_t objid_t; 110 111struct netaddr { 112 struct sockaddr_storage ss; 113 int bits; 114}; 115 116struct relayhost { 117 u_int8_t flags; 118 char hostname[MAXHOSTNAMELEN]; 119 u_int16_t port; 120 char cert[PATH_MAX]; 121 objid_t secmapid; 122}; 123 124enum imsg_type { 125 IMSG_NONE, 126 IMSG_CTL_OK, /* answer to smtpctl requests */ 127 IMSG_CTL_FAIL, 128 IMSG_CTL_SHUTDOWN, 129 IMSG_CTL_VERBOSE, 130 IMSG_CONF_START, 131 IMSG_CONF_SSL, 132 IMSG_CONF_LISTENER, 133 IMSG_CONF_MAP, 134 IMSG_CONF_MAP_CONTENT, 135 IMSG_CONF_RULE, 136 IMSG_CONF_RULE_SOURCE, 137 IMSG_CONF_FILTER, 138 IMSG_CONF_END, 139 IMSG_CONF_RELOAD, 140 IMSG_LKA_MAIL, 141 IMSG_LKA_RCPT, 142 IMSG_LKA_SECRET, 143 IMSG_LKA_RULEMATCH, 144 IMSG_MDA_SESS_NEW, 145 IMSG_MDA_DONE, 146 147 IMSG_MFA_HELO, 148 IMSG_MFA_MAIL, 149 IMSG_MFA_RCPT, 150 IMSG_MFA_DATALINE, 151 152 IMSG_QUEUE_CREATE_MESSAGE, 153 IMSG_QUEUE_SUBMIT_ENVELOPE, 154 IMSG_QUEUE_COMMIT_ENVELOPES, 155 IMSG_QUEUE_REMOVE_MESSAGE, 156 IMSG_QUEUE_COMMIT_MESSAGE, 157 IMSG_QUEUE_TEMPFAIL, 158 IMSG_QUEUE_PAUSE_LOCAL, 159 IMSG_QUEUE_PAUSE_OUTGOING, 160 IMSG_QUEUE_RESUME_LOCAL, 161 IMSG_QUEUE_RESUME_OUTGOING, 162 163 IMSG_QUEUE_MESSAGE_UPDATE, 164 IMSG_QUEUE_MESSAGE_FD, 165 IMSG_QUEUE_MESSAGE_FILE, 166 IMSG_QUEUE_SCHEDULE, 167 IMSG_QUEUE_REMOVE, 168 169 IMSG_RUNNER_REMOVE, 170 IMSG_RUNNER_SCHEDULE, 171 172 IMSG_BATCH_CREATE, 173 IMSG_BATCH_APPEND, 174 IMSG_BATCH_CLOSE, 175 IMSG_BATCH_DONE, 176 177 IMSG_PARENT_ENQUEUE_OFFLINE, 178 IMSG_PARENT_FORWARD_OPEN, 179 IMSG_PARENT_FORK_MDA, 180 181 IMSG_PARENT_AUTHENTICATE, 182 IMSG_PARENT_SEND_CONFIG, 183 184 IMSG_STATS, 185 IMSG_SMTP_ENQUEUE, 186 IMSG_SMTP_PAUSE, 187 IMSG_SMTP_RESUME, 188 189 IMSG_DNS_HOST, 190 IMSG_DNS_HOST_END, 191 IMSG_DNS_MX, 192 IMSG_DNS_PTR 193}; 194 195enum blockmodes { 196 BM_NORMAL, 197 BM_NONBLOCK 198}; 199 200struct imsgev { 201 struct imsgbuf ibuf; 202 void (*handler)(int, short, void *); 203 struct event ev; 204 void *data; 205 int proc; 206 short events; 207}; 208 209struct ctl_conn { 210 TAILQ_ENTRY(ctl_conn) entry; 211 u_int8_t flags; 212#define CTL_CONN_NOTIFY 0x01 213 struct imsgev iev; 214}; 215TAILQ_HEAD(ctl_connlist, ctl_conn); 216 217struct ctl_id { 218 objid_t id; 219 char name[MAX_NAME_SIZE]; 220}; 221 222enum smtp_proc_type { 223 PROC_PARENT = 0, 224 PROC_SMTP, 225 PROC_MFA, 226 PROC_LKA, 227 PROC_QUEUE, 228 PROC_MDA, 229 PROC_MTA, 230 PROC_CONTROL, 231 PROC_RUNNER, 232} smtpd_process; 233 234struct peer { 235 enum smtp_proc_type id; 236 void (*cb)(int, short, void *); 237}; 238 239enum map_type { 240 T_SINGLE, 241 T_LIST, 242 T_HASH 243}; 244 245enum map_src { 246 S_NONE, 247 S_DYN, 248 S_DNS, 249 S_PLAIN, 250 S_DB, 251 S_EXT 252}; 253 254enum map_kind { 255 K_NONE, 256 K_ALIAS, 257 K_VIRTUAL, 258 K_SECRET 259}; 260 261enum mapel_type { 262 ME_STRING, 263 ME_NET, 264 ME_NETMASK 265}; 266 267struct mapel { 268 TAILQ_ENTRY(mapel) me_entry; 269 union mapel_data { 270 char med_string[MAX_LINE_SIZE]; 271 struct netaddr med_addr; 272 } me_key; 273 union mapel_data me_val; 274}; 275 276struct map { 277 TAILQ_ENTRY(map) m_entry; 278#define F_USED 0x01 279#define F_DYNAMIC 0x02 280 u_int8_t m_flags; 281 char m_name[MAX_LINE_SIZE]; 282 objid_t m_id; 283 enum map_type m_type; 284 enum mapel_type m_eltype; 285 enum map_src m_src; 286 char m_config[MAXPATHLEN]; 287 TAILQ_HEAD(mapel_list, mapel) m_contents; 288}; 289 290 291struct map_backend { 292 void *(*open)(char *); 293 void (*close)(void *); 294 void *(*lookup)(void *, char *, enum map_kind); 295}; 296 297 298enum cond_type { 299 C_ALL, 300 C_NET, 301 C_DOM, 302 C_VDOM 303}; 304 305struct cond { 306 TAILQ_ENTRY(cond) c_entry; 307 objid_t c_map; 308 enum cond_type c_type; 309}; 310 311enum action_type { 312 A_INVALID, 313 A_RELAY, 314 A_RELAYVIA, 315 A_MAILDIR, 316 A_MBOX, 317 A_FILENAME, 318 A_EXT 319}; 320 321#define IS_MAILBOX(x) ((x).r_action == A_MAILDIR || (x).r_action == A_MBOX || (x).r_action == A_FILENAME) 322#define IS_RELAY(x) ((x).r_action == A_RELAY || (x).r_action == A_RELAYVIA) 323#define IS_EXT(x) ((x).r_action == A_EXT) 324 325struct rule { 326 TAILQ_ENTRY(rule) r_entry; 327 char r_tag[MAX_TAG_SIZE]; 328 int r_accept; 329 struct map *r_sources; 330 struct cond r_condition; 331 enum action_type r_action; 332 union rule_dest { 333 char buffer[MAX_RULEBUFFER_LEN]; 334 struct relayhost relayhost; 335 } r_value; 336 337 char *r_user; 338 struct mailaddr *r_as; 339 objid_t r_amap; 340 time_t r_qexpire; 341}; 342 343struct mailaddr { 344 char user[MAX_LOCALPART_SIZE]; 345 char domain[MAX_DOMAINPART_SIZE]; 346}; 347 348enum delivery_type { 349 D_INVALID = 0, 350 D_MDA, 351 D_MTA, 352 D_BOUNCE 353}; 354 355enum delivery_status { 356 DS_PERMFAILURE = 0x2, 357 DS_TEMPFAILURE = 0x4, 358 DS_REJECTED = 0x8, 359 DS_ACCEPTED = 0x10 360}; 361 362enum delivery_flags { 363 DF_AUTHENTICATED = 0x1, 364 DF_ENQUEUED = 0x2, 365 DF_BOUNCE = 0x4, 366 DF_INTERNAL = 0x8 /* internal expansion forward */ 367}; 368 369union delivery_data { 370 char user[MAXLOGNAME]; 371 char buffer[MAX_RULEBUFFER_LEN]; 372 struct mailaddr mailaddr; 373}; 374 375struct delivery_mda { 376 enum action_type method; 377 union delivery_data to; 378 char as_user[MAXLOGNAME]; 379}; 380 381struct delivery_mta { 382 struct relayhost relay; 383 struct mailaddr relay_as; 384}; 385 386enum expand_type { 387 EXPAND_INVALID, 388 EXPAND_USERNAME, 389 EXPAND_FILENAME, 390 EXPAND_FILTER, 391 EXPAND_INCLUDE, 392 EXPAND_ADDRESS 393}; 394 395enum expand_flags { 396 F_EXPAND_NONE, 397 F_EXPAND_DONE 398}; 399 400struct expandnode { 401 RB_ENTRY(expandnode) entry; 402 size_t refcnt; 403 enum expand_flags flags; 404 enum expand_type type; 405 char as_user[MAXLOGNAME]; 406 union delivery_data u; 407}; 408 409RB_HEAD(expandtree, expandnode); 410 411#define SMTPD_ENVELOPE_VERSION 1 412struct envelope { 413 TAILQ_ENTRY(envelope) entry; 414 415 char tag[MAX_TAG_SIZE]; 416 struct rule rule; 417 418 u_int64_t session_id; 419 u_int64_t batch_id; 420 421// struct delivery delivery; 422 423 u_int32_t version; 424 u_int64_t id; 425 enum delivery_type type; 426 427 char helo[MAXHOSTNAMELEN]; 428 char hostname[MAXHOSTNAMELEN]; 429 char errorline[MAX_LINE_SIZE + 1]; 430 struct sockaddr_storage ss; 431 432 struct mailaddr sender; 433 struct mailaddr rcpt; 434 struct mailaddr dest; 435 436 union delivery_method { 437 struct delivery_mda mda; 438 struct delivery_mta mta; 439 } agent; 440 441 time_t creation; 442 time_t lasttry; 443 time_t expire; 444 u_int8_t retry; 445 enum delivery_flags flags; 446 enum delivery_status status; 447 448}; 449TAILQ_HEAD(deliverylist, envelope); 450 451 452enum child_type { 453 CHILD_INVALID, 454 CHILD_DAEMON, 455 CHILD_MDA, 456 CHILD_ENQUEUE_OFFLINE, 457}; 458 459struct child { 460 SPLAY_ENTRY(child) entry; 461 pid_t pid; 462 enum child_type type; 463 enum smtp_proc_type title; 464 int mda_out; 465 u_int32_t mda_id; 466}; 467 468enum session_state { 469 S_INVALID = 0, 470 S_INIT, 471 S_GREETED, 472 S_TLS, 473 S_AUTH_INIT, 474 S_AUTH_USERNAME, 475 S_AUTH_PASSWORD, 476 S_AUTH_FINALIZE, 477 S_HELO, 478 S_MAIL_MFA, 479 S_MAIL_QUEUE, 480 S_MAIL, 481 S_RCPT_MFA, 482 S_RCPT, 483 S_DATA, 484 S_DATA_QUEUE, 485 S_DATACONTENT, 486 S_DONE, 487 S_QUIT 488}; 489#define STATE_COUNT 18 490 491struct ssl { 492 SPLAY_ENTRY(ssl) ssl_nodes; 493 char ssl_name[PATH_MAX]; 494 char *ssl_cert; 495 off_t ssl_cert_len; 496 char *ssl_key; 497 off_t ssl_key_len; 498 char *ssl_dhparams; 499 off_t ssl_dhparams_len; 500 u_int8_t flags; 501}; 502 503struct listener { 504 u_int8_t flags; 505 int fd; 506 struct sockaddr_storage ss; 507 in_port_t port; 508 struct timeval timeout; 509 struct event ev; 510 char ssl_cert_name[PATH_MAX]; 511 struct ssl *ssl; 512 void *ssl_ctx; 513 char tag[MAX_TAG_SIZE]; 514 TAILQ_ENTRY(listener) entry; 515}; 516 517struct auth { 518 u_int64_t id; 519 char user[MAXLOGNAME]; 520 char pass[MAX_LINE_SIZE + 1]; 521 int success; 522}; 523 524enum session_flags { 525 F_EHLO = 0x1, 526 F_QUIT = 0x2, 527 F_8BITMIME = 0x4, 528 F_SECURE = 0x8, 529 F_AUTHENTICATED = 0x10, 530 F_PEERHASTLS = 0x20, 531 F_PEERHASAUTH = 0x40, 532 F_WRITEONLY = 0x80 533}; 534 535struct session { 536 SPLAY_ENTRY(session) s_nodes; 537 u_int64_t s_id; 538 539 enum session_flags s_flags; 540 enum session_state s_state; 541 int s_fd; 542 struct sockaddr_storage s_ss; 543 char s_hostname[MAXHOSTNAMELEN]; 544 struct event s_ev; 545 struct bufferevent *s_bev; 546 struct listener *s_l; 547 void *s_ssl; 548 u_char *s_buf; 549 int s_buflen; 550 struct timeval s_tv; 551 struct envelope s_msg; 552 short s_nresp[STATE_COUNT]; 553 size_t rcptcount; 554 long s_datalen; 555 556 struct auth s_auth; 557 558 FILE *datafp; 559 int mboxfd; 560 int messagefd; 561}; 562 563 564/* ram-queue structures */ 565struct ramqueue_host { 566 RB_ENTRY(ramqueue_host) hosttree_entry; 567 TAILQ_HEAD(,ramqueue_batch) batch_queue; 568 u_int64_t h_id; 569 char hostname[MAXHOSTNAMELEN]; 570}; 571struct ramqueue_batch { 572 TAILQ_ENTRY(ramqueue_batch) batch_entry; 573 TAILQ_HEAD(,ramqueue_envelope) envelope_queue; 574 enum delivery_type type; 575 u_int64_t h_id; 576 u_int64_t b_id; 577 u_int32_t msgid; 578 struct rule rule; 579}; 580struct ramqueue_envelope { 581 TAILQ_ENTRY(ramqueue_envelope) queue_entry; 582 TAILQ_ENTRY(ramqueue_envelope) batchqueue_entry; 583 RB_ENTRY(ramqueue_envelope) evptree_entry; 584 struct ramqueue_batch *rq_batch; 585 struct ramqueue_message *rq_msg; 586 struct ramqueue_host *rq_host; 587 u_int64_t evpid; 588 time_t sched; 589}; 590struct ramqueue_message { 591 RB_ENTRY(ramqueue_message) msgtree_entry; 592 RB_HEAD(evptree, ramqueue_envelope) evptree; 593 u_int32_t msgid; 594}; 595struct ramqueue { 596 struct ramqueue_envelope *current_evp; 597 RB_HEAD(hosttree, ramqueue_host) hosttree; 598 RB_HEAD(msgtree, ramqueue_message) msgtree; 599 TAILQ_HEAD(,ramqueue_envelope) queue; 600}; 601 602 603struct smtpd { 604 char sc_conffile[MAXPATHLEN]; 605 size_t sc_maxsize; 606 607#define SMTPD_OPT_VERBOSE 0x00000001 608#define SMTPD_OPT_NOACTION 0x00000002 609 u_int32_t sc_opts; 610#define SMTPD_CONFIGURING 0x00000001 611#define SMTPD_EXITING 0x00000002 612#define SMTPD_MDA_PAUSED 0x00000004 613#define SMTPD_MTA_PAUSED 0x00000008 614#define SMTPD_SMTP_PAUSED 0x00000010 615 u_int32_t sc_flags; 616 struct timeval sc_qintval; 617 int sc_qexpire; 618 u_int32_t sc_maxconn; 619 struct event sc_ev; 620 int *sc_pipes[PROC_COUNT] 621 [PROC_COUNT]; 622 struct imsgev *sc_ievs[PROC_COUNT]; 623 int sc_instances[PROC_COUNT]; 624 int sc_instance; 625 char *sc_title[PROC_COUNT]; 626 struct passwd *sc_pw; 627 char sc_hostname[MAXHOSTNAMELEN]; 628 struct ramqueue sc_rqueue; 629 struct queue_backend *sc_queue; 630 631 TAILQ_HEAD(filterlist, filter) *sc_filters; 632 633 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 634 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 635 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 636 SPLAY_HEAD(sessiontree, session) sc_sessions; 637 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 638 SPLAY_HEAD(childtree, child) children; 639 SPLAY_HEAD(lkatree, lka_session) lka_sessions; 640 SPLAY_HEAD(mfatree, mfa_session) mfa_sessions; 641 SPLAY_HEAD(mtatree, mta_session) mta_sessions; 642 LIST_HEAD(mdalist, mda_session) mda_sessions; 643 644 struct stats *stats; 645 u_int64_t filtermask; 646}; 647 648#define TRACE_VERBOSE 0x01 649#define TRACE_IMSG 0x02 650 651enum { 652 STATS_SMTP_SESSION = 0, 653 STATS_SMTP_SESSION_INET4, 654 STATS_SMTP_SESSION_INET6, 655 STATS_SMTP_SMTPS, 656 STATS_SMTP_STARTTLS, 657 658 STATS_MTA_SESSION, 659 660 STATS_MDA_SESSION, 661 662 STATS_CONTROL_SESSION, 663 664 STATS_LKA_SESSION, 665 STATS_LKA_SESSION_MX, 666 STATS_LKA_SESSION_HOST, 667 STATS_LKA_SESSION_CNAME, 668 STATS_LKA_FAILURE, 669 670 STATS_RUNNER, 671 STATS_RUNNER_BOUNCES, 672 673 STATS_QUEUE_LOCAL, 674 STATS_QUEUE_REMOTE, 675 676 STATS_RAMQUEUE_ENVELOPE, 677 STATS_RAMQUEUE_MESSAGE, 678 STATS_RAMQUEUE_BATCH, 679 STATS_RAMQUEUE_HOST, 680 681 STATS_MAX, 682}; 683 684#define STAT_COUNT 0 685#define STAT_ACTIVE 1 686#define STAT_MAXACTIVE 2 687 688struct stat_counter { 689 size_t count; 690 size_t active; 691 size_t maxactive; 692}; 693 694struct s_parent { 695 time_t start; 696}; 697 698struct s_session { 699 size_t read_error; 700 size_t read_timeout; 701 size_t read_eof; 702 size_t write_error; 703 size_t write_timeout; 704 size_t write_eof; 705 size_t toofast; 706 size_t tempfail; 707 size_t linetoolong; 708 size_t delays; 709}; 710 711struct stats { 712 struct s_parent parent; 713 struct s_session mta; 714 struct s_session smtp; 715 716 struct stat_counter counters[STATS_MAX]; 717}; 718 719struct reload { 720 int fd; 721 int ret; 722}; 723 724struct submit_status { 725 u_int64_t id; 726 int code; 727 union submit_path { 728 struct mailaddr maddr; 729 u_int32_t msgid; 730 u_int64_t evpid; 731 char errormsg[MAX_LINE_SIZE + 1]; 732 char dataline[MAX_LINE_SIZE + 1]; 733 } u; 734 enum delivery_flags flags; 735 struct sockaddr_storage ss; 736 struct envelope envelope; 737}; 738 739struct forward_req { 740 u_int64_t id; 741 u_int8_t status; 742 char as_user[MAXLOGNAME]; 743 struct envelope envelope; 744}; 745 746enum dns_status { 747 DNS_OK = 0, 748 DNS_RETRY, 749 DNS_EINVAL, 750 DNS_ENONAME, 751 DNS_ENOTFOUND, 752}; 753 754struct dns { 755 u_int64_t id; 756 char host[MAXHOSTNAMELEN]; 757 int port; 758 int error; 759 int type; 760 struct imsgev *asker; 761 struct sockaddr_storage ss; 762 struct dns *next; 763}; 764 765struct secret { 766 u_int64_t id; 767 objid_t secmapid; 768 char host[MAXHOSTNAMELEN]; 769 char secret[MAX_LINE_SIZE]; 770}; 771 772struct mda_session { 773 LIST_ENTRY(mda_session) entry; 774 struct envelope msg; 775 struct msgbuf w; 776 struct event ev; 777 u_int32_t id; 778 FILE *datafp; 779}; 780 781struct deliver { 782 char to[PATH_MAX]; 783 char user[MAXLOGNAME]; 784 short mode; 785}; 786 787struct rulematch { 788 u_int64_t id; 789 struct submit_status ss; 790}; 791 792enum lka_session_flags { 793 F_ERROR = 0x1 794}; 795 796struct lka_session { 797 SPLAY_ENTRY(lka_session) nodes; 798 u_int64_t id; 799 800 struct deliverylist deliverylist; 801 struct expandtree expandtree; 802 803 u_int8_t iterations; 804 u_int32_t pending; 805 enum lka_session_flags flags; 806 struct submit_status ss; 807}; 808 809struct filter { 810 TAILQ_ENTRY(filter) f_entry; 811 pid_t pid; 812 struct event ev; 813 struct imsgbuf *ibuf; 814 char name[MAX_FILTER_NAME]; 815 char path[MAXPATHLEN]; 816}; 817 818struct mfa_session { 819 SPLAY_ENTRY(mfa_session) nodes; 820 u_int64_t id; 821 822 enum session_state state; 823 struct submit_status ss; 824 struct filter *filter; 825 struct filter_msg fm; 826}; 827 828enum mta_state { 829 MTA_INVALID_STATE, 830 MTA_INIT, 831 MTA_SECRET, 832 MTA_DATA, 833 MTA_MX, 834 MTA_CONNECT, 835 MTA_PTR, 836 MTA_PROTOCOL, 837 MTA_DONE 838}; 839 840/* mta session flags */ 841#define MTA_FORCE_ANYSSL 0x01 842#define MTA_FORCE_SMTPS 0x02 843#define MTA_ALLOW_PLAIN 0x04 844#define MTA_USE_AUTH 0x08 845#define MTA_FORCE_MX 0x10 846 847struct mta_relay { 848 TAILQ_ENTRY(mta_relay) entry; 849 struct sockaddr_storage sa; 850 char fqdn[MAXHOSTNAMELEN]; 851 int used; 852}; 853 854struct mta_session { 855 SPLAY_ENTRY(mta_session) entry; 856 u_int64_t id; 857 enum mta_state state; 858 char *host; 859 int port; 860 int flags; 861 TAILQ_HEAD(,envelope) recipients; 862 TAILQ_HEAD(,mta_relay) relays; 863 objid_t secmapid; 864 char *secret; 865 int fd; 866 FILE *datafp; 867 struct event ev; 868 char *cert; 869 void *pcb; 870 struct ramqueue_batch *batch; 871}; 872 873 874/* maps return structures */ 875struct map_secret { 876 char username[MAX_LINE_SIZE]; 877 char password[MAX_LINE_SIZE]; 878}; 879 880struct map_alias { 881 size_t nbnodes; 882 struct expandtree expandtree; 883}; 884 885struct map_virtual { 886 size_t nbnodes; 887 struct expandtree expandtree; 888}; 889 890 891/* queue structures */ 892enum queue_type { 893 QT_INVALID=0, 894 QT_FS 895}; 896 897enum queue_kind { 898 Q_INVALID=0, 899 Q_ENQUEUE, 900 Q_INCOMING, 901 Q_QUEUE, 902 Q_PURGE, 903 Q_OFFLINE, 904 Q_BOUNCE, 905 Q_CORRUPT 906}; 907 908enum queue_op { 909 QOP_INVALID=0, 910 QOP_CREATE, 911 QOP_DELETE, 912 QOP_UPDATE, 913 QOP_COMMIT, 914 QOP_LOAD, 915 QOP_FD_R, 916 QOP_FD_RW, 917 QOP_PURGE, 918 QOP_CORRUPT, 919}; 920 921struct queue_backend { 922 enum queue_type type; 923 int (*init)(void); 924 int (*message)(enum queue_kind, enum queue_op, u_int32_t *); 925 int (*envelope)(enum queue_kind, enum queue_op, struct envelope *); 926}; 927 928 929/* auth structures */ 930enum auth_type { 931 AUTH_INVALID=0, 932 AUTH_BSD, 933 AUTH_GETPWNAM, 934}; 935 936struct auth_backend { 937 enum auth_type type; 938 int (*authenticate)(char *, char *); 939}; 940 941 942/* user structures */ 943enum user_type { 944 USER_INVALID=0, 945 USER_GETPWNAM, 946}; 947 948#define MAXPASSWORDLEN 128 949struct user { 950 char username[MAXLOGNAME]; 951 char directory[MAXPATHLEN]; 952 char password[MAXPASSWORDLEN]; 953 uid_t uid; 954 gid_t gid; 955}; 956 957struct user_backend { 958 enum user_type type; 959 int (*getbyname)(struct user *, char *); 960 int (*getbyuid)(struct user *, uid_t); 961}; 962 963 964extern struct smtpd *env; 965extern void (*imsg_callback)(struct imsgev *, struct imsg *); 966 967 968/* aliases.c */ 969int aliases_exist(objid_t, char *); 970int aliases_get(objid_t, struct expandtree *, char *); 971int aliases_vdomain_exists(objid_t, char *); 972int aliases_virtual_exist(objid_t, struct mailaddr *); 973int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 974int alias_parse(struct expandnode *, char *); 975 976 977/* auth_backend.c */ 978struct auth_backend *auth_backend_lookup(enum auth_type); 979 980 981/* bounce.c */ 982int bounce_session(int, struct envelope *); 983int bounce_session_switch(FILE *, enum session_state *, char *, struct envelope *); 984void bounce_event(int, short, void *); 985 986 987/* config.c */ 988#define PURGE_LISTENERS 0x01 989#define PURGE_MAPS 0x02 990#define PURGE_RULES 0x04 991#define PURGE_SSL 0x08 992#define PURGE_EVERYTHING 0xff 993void purge_config(u_int8_t); 994void unconfigure(void); 995void configure(void); 996void init_pipes(void); 997void config_pipes(struct peer *, u_int); 998void config_peers(struct peer *, u_int); 999 1000 1001/* control.c */ 1002pid_t control(void); 1003void session_socket_blockmode(int, enum blockmodes); 1004void session_socket_no_linger(int); 1005int session_socket_error(int); 1006 1007 1008/* dns.c */ 1009void dns_query_host(char *, int, u_int64_t); 1010void dns_query_mx(char *, int, u_int64_t); 1011void dns_query_ptr(struct sockaddr_storage *, u_int64_t); 1012void dns_async(struct imsgev *, int, struct dns *); 1013 1014 1015/* enqueue.c */ 1016int enqueue(int, char **); 1017int enqueue_offline(int, char **); 1018 1019 1020/* expand.c */ 1021int expand_cmp(struct expandnode *, struct expandnode *); 1022void expandtree_increment_node(struct expandtree *, struct expandnode *); 1023void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1024void expandtree_remove_node(struct expandtree *, struct expandnode *); 1025struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1026void expandtree_free_nodes(struct expandtree *); 1027RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1028 1029 1030/* forward.c */ 1031int forwards_get(int, struct expandtree *, char *); 1032 1033 1034/* lka.c */ 1035pid_t lka(void); 1036int lka_session_cmp(struct lka_session *, struct lka_session *); 1037SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1038 1039/* lka_session.c */ 1040struct lka_session *lka_session_init(struct submit_status *); 1041void lka_session_fail(struct lka_session *); 1042void lka_session_destroy(struct lka_session *); 1043 1044 1045/* map.c */ 1046void *map_lookup(objid_t, char *, enum map_kind); 1047struct map *map_find(objid_t); 1048struct map *map_findbyname(const char *); 1049 1050 1051/* mda.c */ 1052pid_t mda(void); 1053 1054 1055/* mfa.c */ 1056pid_t mfa(void); 1057int mfa_session_cmp(struct mfa_session *, struct mfa_session *); 1058SPLAY_PROTOTYPE(mfatree, mfa_session, nodes, mfa_session_cmp); 1059 1060/* mta.c */ 1061pid_t mta(void); 1062int mta_session_cmp(struct mta_session *, struct mta_session *); 1063SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp); 1064 1065 1066/* parse.y */ 1067int parse_config(struct smtpd *, const char *, int); 1068int cmdline_symset(char *); 1069 1070 1071/* queue.c */ 1072pid_t queue(void); 1073void queue_submit_envelope(struct envelope *); 1074void queue_commit_envelopes(struct envelope *); 1075 1076 1077/* queue_backend.c */ 1078struct queue_backend *queue_backend_lookup(enum queue_type); 1079int queue_message_create(enum queue_kind, u_int32_t *); 1080int queue_message_delete(enum queue_kind, u_int32_t); 1081int queue_message_commit(enum queue_kind, u_int32_t); 1082int queue_message_fd_r(enum queue_kind, u_int32_t); 1083int queue_message_fd_rw(enum queue_kind, u_int32_t); 1084int queue_message_purge(enum queue_kind, u_int32_t); 1085int queue_message_corrupt(enum queue_kind, u_int32_t); 1086int queue_envelope_create(enum queue_kind, struct envelope *); 1087int queue_envelope_delete(enum queue_kind, struct envelope *); 1088int queue_envelope_load(enum queue_kind, u_int64_t, struct envelope *); 1089int queue_envelope_update(enum queue_kind, struct envelope *); 1090 1091 1092/* queue_shared.c */ 1093void queue_message_update(struct envelope *); 1094struct qwalk *qwalk_new(char *); 1095int qwalk(struct qwalk *, char *); 1096void qwalk_close(struct qwalk *); 1097int bounce_record_message(struct envelope *, struct envelope *); 1098void show_queue(char *, int); 1099 1100 1101/* ramqueue.c */ 1102void ramqueue_init(struct ramqueue *); 1103int ramqueue_load(struct ramqueue *, time_t *); 1104int ramqueue_load_offline(struct ramqueue *); 1105int ramqueue_host_cmp(struct ramqueue_host *, struct ramqueue_host *); 1106int ramqueue_msg_cmp(struct ramqueue_message *, struct ramqueue_message *); 1107int ramqueue_evp_cmp(struct ramqueue_envelope *, struct ramqueue_envelope *); 1108int ramqueue_is_empty(struct ramqueue *); 1109int ramqueue_is_empty(struct ramqueue *); 1110int ramqueue_batch_is_empty(struct ramqueue_batch *); 1111int ramqueue_host_is_empty(struct ramqueue_host *); 1112void ramqueue_remove_batch(struct ramqueue_host *, struct ramqueue_batch *); 1113void ramqueue_remove_host(struct ramqueue *, struct ramqueue_host *); 1114struct ramqueue_envelope *ramqueue_envelope_by_id(struct ramqueue *, u_int64_t); 1115struct ramqueue_envelope *ramqueue_first_envelope(struct ramqueue *); 1116struct ramqueue_envelope *ramqueue_next_envelope(struct ramqueue *); 1117struct ramqueue_envelope *ramqueue_batch_first_envelope(struct ramqueue_batch *); 1118void ramqueue_insert(struct ramqueue *, struct envelope *, time_t); 1119int ramqueue_message_is_empty(struct ramqueue_message *); 1120void ramqueue_remove_message(struct ramqueue *, struct ramqueue_message *); 1121 1122struct ramqueue_host *ramqueue_lookup_host(struct ramqueue *, char *); 1123struct ramqueue_message *ramqueue_lookup_message(struct ramqueue *, u_int32_t); 1124struct ramqueue_envelope *ramqueue_lookup_envelope(struct ramqueue *, u_int64_t); 1125 1126void ramqueue_schedule(struct ramqueue *, u_int64_t); 1127void ramqueue_schedule_envelope(struct ramqueue *, struct ramqueue_envelope *); 1128 1129void ramqueue_remove_envelope(struct ramqueue *, struct ramqueue_envelope *); 1130 1131 1132RB_PROTOTYPE(hosttree, ramqueue_host, hosttree_entry, ramqueue_host_cmp); 1133RB_PROTOTYPE(msgtree, ramqueue_message, msg_entry, ramqueue_msg_cmp); 1134RB_PROTOTYPE(evptree, ramqueue_envelope, evp_entry, ramqueue_evp_cmp); 1135 1136 1137/* runner.c */ 1138pid_t runner(void); 1139void message_reset_flags(struct envelope *); 1140void runner_schedule(struct ramqueue *, u_int64_t); 1141void runner_remove(struct ramqueue *, u_int64_t); 1142void runner_remove_envelope(struct ramqueue *, struct ramqueue_envelope *); 1143 1144 1145/* smtp.c */ 1146pid_t smtp(void); 1147void smtp_resume(void); 1148 1149 1150/* smtp_session.c */ 1151void session_init(struct listener *, struct session *); 1152int session_cmp(struct session *, struct session *); 1153void session_pickup(struct session *, struct submit_status *); 1154void session_destroy(struct session *); 1155void session_respond(struct session *, char *, ...) 1156 __attribute__ ((format (printf, 2, 3))); 1157void session_bufferevent_new(struct session *); 1158SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1159 1160 1161/* smtpd.c */ 1162int child_cmp(struct child *, struct child *); 1163void imsg_event_add(struct imsgev *); 1164void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 1165 int, void *, u_int16_t); 1166void imsg_dispatch(int, short, void *); 1167SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1168 1169 1170/* ssl.c */ 1171void ssl_init(void); 1172void ssl_transaction(struct session *); 1173void ssl_session_init(struct session *); 1174void ssl_session_destroy(struct session *); 1175int ssl_load_certfile(const char *, u_int8_t); 1176void ssl_setup(struct listener *); 1177int ssl_cmp(struct ssl *, struct ssl *); 1178SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1179 1180 1181/* ssl_privsep.c */ 1182int ssl_ctx_use_private_key(void *, char *, off_t); 1183int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1184 1185/* stats.c */ 1186void stat_init(struct stat_counter *, int); 1187size_t stat_get(int, int); 1188size_t stat_increment(int); 1189size_t stat_decrement(int); 1190 1191 1192/* user_backend.c */ 1193struct user_backend *user_backend_lookup(enum user_type); 1194 1195 1196/* util.c */ 1197typedef struct arglist arglist; 1198struct arglist { 1199 char **list; 1200 u_int num; 1201 u_int nalloc; 1202}; 1203void addargs(arglist *, char *, ...) 1204 __attribute__((format(printf, 2, 3))); 1205int bsnprintf(char *, size_t, const char *, ...) 1206 __attribute__ ((format (printf, 3, 4))); 1207int safe_fclose(FILE *); 1208int hostname_match(char *, char *); 1209int email_to_mailaddr(struct mailaddr *, char *); 1210int valid_localpart(char *); 1211int valid_domainpart(char *); 1212char *ss_to_text(struct sockaddr_storage *); 1213int valid_message_id(char *); 1214int valid_message_uid(char *); 1215char *time_to_text(time_t); 1216int secure_file(int, char *, char *, uid_t, int); 1217void lowercase(char *, char *, size_t); 1218void envelope_set_errormsg(struct envelope *, char *, ...); 1219char *envelope_get_errormsg(struct envelope *); 1220void sa_set_port(struct sockaddr *, int); 1221u_int64_t generate_uid(void); 1222void fdlimit(double); 1223int availdesc(void); 1224u_int32_t msgid_generate(void); 1225u_int64_t evpid_generate(u_int32_t); 1226u_int32_t evpid_to_msgid(u_int64_t); 1227u_int64_t msgid_to_evpid(u_int32_t); 1228u_int32_t filename_to_msgid(char *); 1229u_int64_t filename_to_evpid(char *); 1230void log_imsg(int, int, struct imsg*); 1231