smtpd.h revision 1.231
1/* $OpenBSD: smtpd.h,v 1.231 2011/08/17 19:36:23 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#define IMSG_SIZE_CHECK(p) do { \ 25 if (IMSG_DATA_SIZE(&imsg) != sizeof(*p)) \ 26 fatalx("bad length imsg received"); \ 27 } while (0) 28#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE) 29 30 31#define CONF_FILE "/etc/mail/smtpd.conf" 32#define MAX_LISTEN 16 33#define PROC_COUNT 9 34#define MAX_NAME_SIZE 64 35 36#define MAX_HOPS_COUNT 100 37 38/* sizes include the tailing '\0' */ 39#define MAX_LINE_SIZE 1024 40#define MAX_LOCALPART_SIZE 128 41#define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN 42#define MAX_TAG_SIZE 32 43 44/* return and forward path size */ 45#define MAX_PATH_SIZE 256 46#define MAX_RULEBUFFER_LEN 256 47 48#define SMTPD_QUEUE_INTERVAL (15 * 60) 49#define SMTPD_QUEUE_MAXINTERVAL (4 * 60 * 60) 50#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 51#define SMTPD_USER "_smtpd" 52#define SMTPD_SOCKET "/var/run/smtpd.sock" 53#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 54#define SMTPD_SESSION_TIMEOUT 300 55#define SMTPD_BACKLOG 5 56 57#define PATH_MAILLOCAL "/usr/libexec/mail.local" 58#define PATH_SMTPCTL "/usr/sbin/smtpctl" 59 60#define DIRHASH_BUCKETS 4096 61 62#define PATH_SPOOL "/var/spool/smtpd" 63 64#define PATH_ENQUEUE "/enqueue" 65#define PATH_INCOMING "/incoming" 66#define PATH_QUEUE "/queue" 67#define PATH_PURGE "/purge" 68 69#define PATH_MESSAGE "/message" 70#define PATH_ENVELOPES "/envelopes" 71 72#define PATH_OFFLINE "/offline" 73#define PATH_BOUNCE "/bounce" 74 75/* number of MX records to lookup */ 76#define MAX_MX_COUNT 10 77 78/* max response delay under flood conditions */ 79#define MAX_RESPONSE_DELAY 60 80 81/* how many responses per state are undelayed */ 82#define FAST_RESPONSES 2 83 84/* max len of any smtp line */ 85#define SMTP_LINE_MAX 16384 86 87#define F_STARTTLS 0x01 88#define F_SMTPS 0x02 89#define F_AUTH 0x04 90#define F_SSL (F_SMTPS|F_STARTTLS) 91 92#define F_SCERT 0x01 93#define F_CCERT 0x02 94 95#define ADVERTISE_TLS(s) \ 96 ((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE)) 97 98#define ADVERTISE_AUTH(s) \ 99 ((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \ 100 !((s)->s_flags & F_AUTHENTICATED)) 101 102#define SET_IF_GREATER(x,y) do { y = MAX(x,y); } while(0) 103 104 105typedef u_int32_t objid_t; 106 107struct netaddr { 108 struct sockaddr_storage ss; 109 int bits; 110}; 111 112struct relayhost { 113 u_int8_t flags; 114 char hostname[MAXHOSTNAMELEN]; 115 u_int16_t port; 116 char cert[PATH_MAX]; 117 objid_t secmapid; 118}; 119 120enum imsg_type { 121 IMSG_NONE, 122 IMSG_CTL_OK, /* answer to smtpctl requests */ 123 IMSG_CTL_FAIL, 124 IMSG_CTL_SHUTDOWN, 125 IMSG_CTL_VERBOSE, 126 IMSG_CONF_START, 127 IMSG_CONF_SSL, 128 IMSG_CONF_LISTENER, 129 IMSG_CONF_MAP, 130 IMSG_CONF_MAP_CONTENT, 131 IMSG_CONF_RULE, 132 IMSG_CONF_RULE_SOURCE, 133 IMSG_CONF_END, 134 IMSG_CONF_RELOAD, 135 IMSG_LKA_MAIL, 136 IMSG_LKA_RCPT, 137 IMSG_LKA_SECRET, 138 IMSG_LKA_RULEMATCH, 139 IMSG_MDA_SESS_NEW, 140 IMSG_MDA_DONE, 141 IMSG_MFA_RCPT, 142 IMSG_MFA_MAIL, 143 144 IMSG_QUEUE_CREATE_MESSAGE, 145 IMSG_QUEUE_SUBMIT_ENVELOPE, 146 IMSG_QUEUE_COMMIT_ENVELOPES, 147 IMSG_QUEUE_REMOVE_MESSAGE, 148 IMSG_QUEUE_COMMIT_MESSAGE, 149 IMSG_QUEUE_TEMPFAIL, 150 IMSG_QUEUE_PAUSE_LOCAL, 151 IMSG_QUEUE_PAUSE_OUTGOING, 152 IMSG_QUEUE_RESUME_LOCAL, 153 IMSG_QUEUE_RESUME_OUTGOING, 154 155 IMSG_QUEUE_MESSAGE_UPDATE, 156 IMSG_QUEUE_MESSAGE_FD, 157 IMSG_QUEUE_MESSAGE_FILE, 158 IMSG_QUEUE_SCHEDULE, 159 IMSG_QUEUE_REMOVE, 160 161 IMSG_RUNNER_REMOVE, 162 IMSG_RUNNER_SCHEDULE, 163 164 IMSG_BATCH_CREATE, 165 IMSG_BATCH_APPEND, 166 IMSG_BATCH_CLOSE, 167 IMSG_BATCH_DONE, 168 169 IMSG_PARENT_ENQUEUE_OFFLINE, 170 IMSG_PARENT_FORWARD_OPEN, 171 IMSG_PARENT_FORK_MDA, 172 173 IMSG_PARENT_AUTHENTICATE, 174 IMSG_PARENT_SEND_CONFIG, 175 176 IMSG_STATS, 177 IMSG_SMTP_ENQUEUE, 178 IMSG_SMTP_PAUSE, 179 IMSG_SMTP_RESUME, 180 181 IMSG_DNS_HOST, 182 IMSG_DNS_HOST_END, 183 IMSG_DNS_MX, 184 IMSG_DNS_PTR 185}; 186 187enum blockmodes { 188 BM_NORMAL, 189 BM_NONBLOCK 190}; 191 192struct imsgev { 193 struct imsgbuf ibuf; 194 void (*handler)(int, short, void *); 195 struct event ev; 196 void *data; 197 int proc; 198 short events; 199}; 200 201struct ctl_conn { 202 TAILQ_ENTRY(ctl_conn) entry; 203 u_int8_t flags; 204#define CTL_CONN_NOTIFY 0x01 205 struct imsgev iev; 206}; 207TAILQ_HEAD(ctl_connlist, ctl_conn); 208 209struct ctl_id { 210 objid_t id; 211 char name[MAX_NAME_SIZE]; 212}; 213 214enum smtp_proc_type { 215 PROC_PARENT = 0, 216 PROC_SMTP, 217 PROC_MFA, 218 PROC_LKA, 219 PROC_QUEUE, 220 PROC_MDA, 221 PROC_MTA, 222 PROC_CONTROL, 223 PROC_RUNNER, 224} smtpd_process; 225 226struct peer { 227 enum smtp_proc_type id; 228 void (*cb)(int, short, void *); 229}; 230 231enum map_type { 232 T_SINGLE, 233 T_LIST, 234 T_HASH 235}; 236 237enum map_src { 238 S_NONE, 239 S_DYN, 240 S_DNS, 241 S_PLAIN, 242 S_DB, 243 S_EXT 244}; 245 246enum map_kind { 247 K_NONE, 248 K_ALIAS, 249 K_VIRTUAL, 250 K_SECRET 251}; 252 253enum mapel_type { 254 ME_STRING, 255 ME_NET, 256 ME_NETMASK 257}; 258 259struct mapel { 260 TAILQ_ENTRY(mapel) me_entry; 261 union mapel_data { 262 char med_string[MAX_LINE_SIZE]; 263 struct netaddr med_addr; 264 } me_key; 265 union mapel_data me_val; 266}; 267 268struct map { 269 TAILQ_ENTRY(map) m_entry; 270#define F_USED 0x01 271#define F_DYNAMIC 0x02 272 u_int8_t m_flags; 273 char m_name[MAX_LINE_SIZE]; 274 objid_t m_id; 275 enum map_type m_type; 276 enum mapel_type m_eltype; 277 enum map_src m_src; 278 char m_config[MAXPATHLEN]; 279 TAILQ_HEAD(mapel_list, mapel) m_contents; 280}; 281 282 283struct map_backend { 284 void *(*open)(char *); 285 void (*close)(void *); 286 void *(*lookup)(void *, char *, enum map_kind); 287}; 288 289 290enum cond_type { 291 C_ALL, 292 C_NET, 293 C_DOM, 294 C_VDOM 295}; 296 297struct cond { 298 TAILQ_ENTRY(cond) c_entry; 299 objid_t c_map; 300 enum cond_type c_type; 301}; 302 303enum action_type { 304 A_INVALID, 305 A_RELAY, 306 A_RELAYVIA, 307 A_MAILDIR, 308 A_MBOX, 309 A_FILENAME, 310 A_EXT 311}; 312 313#define IS_MAILBOX(x) ((x).r_action == A_MAILDIR || (x).r_action == A_MBOX || (x).r_action == A_FILENAME) 314#define IS_RELAY(x) ((x).r_action == A_RELAY || (x).r_action == A_RELAYVIA) 315#define IS_EXT(x) ((x).r_action == A_EXT) 316 317struct rule { 318 TAILQ_ENTRY(rule) r_entry; 319 char r_tag[MAX_TAG_SIZE]; 320 int r_accept; 321 struct map *r_sources; 322 struct cond r_condition; 323 enum action_type r_action; 324 union rule_dest { 325 char buffer[MAX_RULEBUFFER_LEN]; 326 struct relayhost relayhost; 327 } r_value; 328 329 char *r_user; 330 struct mailaddr *r_as; 331 objid_t r_amap; 332 time_t r_qexpire; 333}; 334 335struct mailaddr { 336 char user[MAX_LOCALPART_SIZE]; 337 char domain[MAX_DOMAINPART_SIZE]; 338}; 339 340 341enum delivery_type { 342 D_INVALID = 0, 343 D_MDA, 344 D_MTA, 345 D_BOUNCE 346}; 347 348enum delivery_status { 349 DS_PERMFAILURE = 0x2, 350 DS_TEMPFAILURE = 0x4, 351 DS_REJECTED = 0x8, 352 DS_ACCEPTED = 0x10, 353 DS_RETRY = 0x20, 354 DS_EDNS = 0x40, 355 DS_ECONNECT = 0x80 356}; 357 358enum delivery_flags { 359 DF_RESOLVED = 0x1, 360 DF_SCHEDULED = 0x2, 361 DF_PROCESSING = 0x4, 362 DF_AUTHENTICATED = 0x8, 363 DF_ENQUEUED = 0x10, 364 DF_FORCESCHEDULE = 0x20, 365 DF_BOUNCE = 0x40, 366 DF_INTERNAL = 0x80 /* 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 386struct delivery { 387 u_int64_t id; 388 enum delivery_type type; 389 390 char helo[MAXHOSTNAMELEN]; 391 char hostname[MAXHOSTNAMELEN]; 392 char errorline[MAX_LINE_SIZE]; 393 struct sockaddr_storage ss; 394 395 struct mailaddr from; 396 struct mailaddr rcpt; 397 struct mailaddr rcpt_orig; 398 399 union delivery_method { 400 struct delivery_mda mda; 401 struct delivery_mta mta; 402 } agent; 403 404 time_t creation; 405 time_t lasttry; 406 time_t expire; 407 u_int8_t retry; 408 enum delivery_flags flags; 409 enum delivery_status status; 410}; 411 412enum expand_type { 413 EXPAND_INVALID, 414 EXPAND_USERNAME, 415 EXPAND_FILENAME, 416 EXPAND_FILTER, 417 EXPAND_INCLUDE, 418 EXPAND_ADDRESS 419}; 420 421enum expand_flags { 422 F_EXPAND_NONE, 423 F_EXPAND_DONE 424}; 425 426struct expandnode { 427 RB_ENTRY(expandnode) entry; 428 size_t refcnt; 429 enum expand_flags flags; 430 enum expand_type type; 431 char as_user[MAXLOGNAME]; 432 union delivery_data u; 433}; 434 435RB_HEAD(expandtree, expandnode); 436 437 438struct envelope { 439 TAILQ_ENTRY(envelope) entry; 440 441 char tag[MAX_TAG_SIZE]; 442 struct rule rule; 443 444 u_int64_t session_id; 445 u_int64_t batch_id; 446 447 struct delivery delivery; 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]; 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_host *host; 585 struct ramqueue_batch *batch; 586 struct ramqueue_message *message; 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(listenerlist, listener) *sc_listeners; 632 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 633 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 634 SPLAY_HEAD(sessiontree, session) sc_sessions; 635 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 636 SPLAY_HEAD(childtree, child) children; 637 SPLAY_HEAD(lkatree, lka_session) lka_sessions; 638 SPLAY_HEAD(mtatree, mta_session) mta_sessions; 639 LIST_HEAD(mdalist, mda_session) mda_sessions; 640 641 struct stats *stats; 642}; 643 644struct s_parent { 645 time_t start; 646}; 647 648struct s_queue { 649 size_t inserts_local; 650 size_t inserts_remote; 651}; 652 653struct s_runner { 654 size_t active; 655 size_t maxactive; 656 size_t bounces_active; 657 size_t bounces_maxactive; 658 size_t bounces; 659}; 660 661struct s_session { 662 size_t sessions; 663 size_t sessions_inet4; 664 size_t sessions_inet6; 665 size_t sessions_active; 666 size_t sessions_maxactive; 667 668 size_t smtps; 669 size_t smtps_active; 670 size_t smtps_maxactive; 671 672 size_t starttls; 673 size_t starttls_active; 674 size_t starttls_maxactive; 675 676 size_t read_error; 677 size_t read_timeout; 678 size_t read_eof; 679 size_t write_error; 680 size_t write_timeout; 681 size_t write_eof; 682 size_t toofast; 683 size_t tempfail; 684 size_t linetoolong; 685 size_t delays; 686}; 687 688struct s_mda { 689 size_t sessions; 690 size_t sessions_active; 691 size_t sessions_maxactive; 692}; 693 694struct s_control { 695 size_t sessions; 696 size_t sessions_active; 697 size_t sessions_maxactive; 698}; 699 700struct s_lka { 701 size_t queries; 702 size_t queries_active; 703 size_t queries_maxactive; 704 size_t queries_mx; 705 size_t queries_host; 706 size_t queries_cname; 707 size_t queries_failure; 708}; 709 710struct s_ramqueue { 711 size_t hosts; 712 size_t batches; 713 size_t messages; 714 size_t envelopes; 715 size_t hosts_max; 716 size_t batches_max; 717 size_t messages_max; 718 size_t envelopes_max; 719}; 720 721struct stats { 722 struct s_parent parent; 723 struct s_queue queue; 724 struct s_runner runner; 725 struct s_session mta; 726 struct s_mda mda; 727 struct s_session smtp; 728 struct s_control control; 729 struct s_lka lka; 730 struct s_ramqueue ramqueue; 731}; 732 733struct reload { 734 int fd; 735 int ret; 736}; 737 738struct submit_status { 739 u_int64_t id; 740 int code; 741 union submit_path { 742 struct mailaddr maddr; 743 u_int32_t msgid; 744 u_int64_t evpid; 745 char errormsg[MAX_LINE_SIZE]; 746 } u; 747 enum delivery_flags flags; 748 struct sockaddr_storage ss; 749 struct envelope envelope; 750}; 751 752struct forward_req { 753 u_int64_t id; 754 u_int8_t status; 755 char as_user[MAXLOGNAME]; 756 struct envelope envelope; 757}; 758 759enum dns_status { 760 DNS_OK = 0, 761 DNS_RETRY, 762 DNS_EINVAL, 763 DNS_ENONAME, 764 DNS_ENOTFOUND, 765}; 766 767struct dns { 768 u_int64_t id; 769 char host[MAXHOSTNAMELEN]; 770 int port; 771 int error; 772 int type; 773 struct imsgev *asker; 774 struct sockaddr_storage ss; 775 struct dns *next; 776}; 777 778struct secret { 779 u_int64_t id; 780 objid_t secmapid; 781 char host[MAXHOSTNAMELEN]; 782 char secret[MAX_LINE_SIZE]; 783}; 784 785struct mda_session { 786 LIST_ENTRY(mda_session) entry; 787 struct envelope msg; 788 struct msgbuf w; 789 struct event ev; 790 u_int32_t id; 791 FILE *datafp; 792}; 793 794struct deliver { 795 char to[PATH_MAX]; 796 char user[MAXLOGNAME]; 797 short mode; 798}; 799 800struct rulematch { 801 u_int64_t id; 802 struct submit_status ss; 803}; 804 805enum lka_session_flags { 806 F_ERROR = 0x1 807}; 808 809struct lka_session { 810 SPLAY_ENTRY(lka_session) nodes; 811 u_int64_t id; 812 813 struct deliverylist deliverylist; 814 struct expandtree expandtree; 815 816 u_int8_t iterations; 817 u_int32_t pending; 818 enum lka_session_flags flags; 819 struct submit_status ss; 820}; 821 822enum mta_state { 823 MTA_INVALID_STATE, 824 MTA_INIT, 825 MTA_SECRET, 826 MTA_DATA, 827 MTA_MX, 828 MTA_CONNECT, 829 MTA_PTR, 830 MTA_PROTOCOL, 831 MTA_DONE 832}; 833 834/* mta session flags */ 835#define MTA_FORCE_ANYSSL 0x01 836#define MTA_FORCE_SMTPS 0x02 837#define MTA_ALLOW_PLAIN 0x04 838#define MTA_USE_AUTH 0x08 839#define MTA_FORCE_MX 0x10 840 841struct mta_relay { 842 TAILQ_ENTRY(mta_relay) entry; 843 struct sockaddr_storage sa; 844 char fqdn[MAXHOSTNAMELEN]; 845 int used; 846}; 847 848struct mta_session { 849 SPLAY_ENTRY(mta_session) entry; 850 u_int64_t id; 851 enum mta_state state; 852 char *host; 853 int port; 854 int flags; 855 TAILQ_HEAD(,envelope) recipients; 856 TAILQ_HEAD(,mta_relay) relays; 857 objid_t secmapid; 858 char *secret; 859 int fd; 860 FILE *datafp; 861 struct event ev; 862 char *cert; 863 void *pcb; 864 struct ramqueue_batch *batch; 865}; 866 867 868/* maps return structures */ 869struct map_secret { 870 char username[MAX_LINE_SIZE]; 871 char password[MAX_LINE_SIZE]; 872}; 873 874struct map_alias { 875 size_t nbnodes; 876 struct expandtree expandtree; 877}; 878 879struct map_virtual { 880 size_t nbnodes; 881 struct expandtree expandtree; 882}; 883 884 885/* queue structures */ 886enum queue_type { 887 QT_INVALID=0, 888 QT_FS 889}; 890 891enum queue_kind { 892 Q_INVALID=0, 893 Q_ENQUEUE, 894 Q_INCOMING, 895 Q_QUEUE, 896 Q_PURGE, 897 Q_OFFLINE, 898 Q_BOUNCE 899}; 900 901enum queue_op { 902 QOP_INVALID=0, 903 QOP_CREATE, 904 QOP_DELETE, 905 QOP_UPDATE, 906 QOP_COMMIT, 907 QOP_LOAD, 908 QOP_FD_R, 909 QOP_FD_RW, 910 QOP_PURGE 911}; 912 913struct queue_backend { 914 enum queue_type type; 915 int (*init)(void); 916 int (*message)(enum queue_kind, enum queue_op, u_int32_t *); 917 int (*envelope)(enum queue_kind, enum queue_op, struct envelope *); 918}; 919 920 921/* auth structures */ 922enum auth_type { 923 AUTH_INVALID=0, 924 AUTH_BSD, 925 AUTH_GETPWNAM, 926}; 927 928struct auth_backend { 929 enum auth_type type; 930 int (*authenticate)(char *, char *); 931}; 932 933 934/* user structures */ 935enum user_type { 936 USER_INVALID=0, 937 USER_GETPWNAM, 938}; 939 940#define MAXPASSWORDLEN 128 941struct user { 942 char username[MAXLOGNAME]; 943 char directory[MAXPATHLEN]; 944 char password[MAXPASSWORDLEN]; 945 uid_t uid; 946 gid_t gid; 947}; 948 949struct user_backend { 950 enum user_type type; 951 int (*getbyname)(struct user *, char *); 952 int (*getbyuid)(struct user *, uid_t); 953}; 954 955 956extern struct smtpd *env; 957extern void (*imsg_callback)(struct imsgev *, struct imsg *); 958 959 960/* aliases.c */ 961int aliases_exist(objid_t, char *); 962int aliases_get(objid_t, struct expandtree *, char *); 963int aliases_vdomain_exists(objid_t, char *); 964int aliases_virtual_exist(objid_t, struct mailaddr *); 965int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 966int alias_parse(struct expandnode *, char *); 967 968 969/* auth_backend.c */ 970struct auth_backend *auth_backend_lookup(enum auth_type); 971 972 973/* bounce.c */ 974int bounce_session(int, struct envelope *); 975int bounce_session_switch(FILE *, enum session_state *, char *, struct envelope *); 976void bounce_event(int, short, void *); 977 978 979/* config.c */ 980#define PURGE_LISTENERS 0x01 981#define PURGE_MAPS 0x02 982#define PURGE_RULES 0x04 983#define PURGE_SSL 0x08 984#define PURGE_EVERYTHING 0xff 985void purge_config(u_int8_t); 986void unconfigure(void); 987void configure(void); 988void init_pipes(void); 989void config_pipes(struct peer *, u_int); 990void config_peers(struct peer *, u_int); 991 992 993/* control.c */ 994pid_t control(void); 995void session_socket_blockmode(int, enum blockmodes); 996void session_socket_no_linger(int); 997int session_socket_error(int); 998 999 1000/* dns.c */ 1001void dns_query_host(char *, int, u_int64_t); 1002void dns_query_mx(char *, int, u_int64_t); 1003void dns_query_ptr(struct sockaddr_storage *, u_int64_t); 1004void dns_async(struct imsgev *, int, struct dns *); 1005 1006 1007/* enqueue.c */ 1008int enqueue(int, char **); 1009int enqueue_offline(int, char **); 1010 1011 1012/* expand.c */ 1013int expand_cmp(struct expandnode *, struct expandnode *); 1014void expandtree_increment_node(struct expandtree *, struct expandnode *); 1015void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1016void expandtree_remove_node(struct expandtree *, struct expandnode *); 1017struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1018void expandtree_free_nodes(struct expandtree *); 1019RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1020 1021 1022/* forward.c */ 1023int forwards_get(int, struct expandtree *, char *); 1024 1025 1026/* lka.c */ 1027pid_t lka(void); 1028int lka_session_cmp(struct lka_session *, struct lka_session *); 1029SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1030 1031/* lka_session.c */ 1032struct lka_session *lka_session_init(struct submit_status *); 1033void lka_session_fail(struct lka_session *); 1034void lka_session_destroy(struct lka_session *); 1035 1036 1037/* map.c */ 1038void *map_lookup(objid_t, char *, enum map_kind); 1039struct map *map_find(objid_t); 1040struct map *map_findbyname(const char *); 1041 1042 1043/* mda.c */ 1044pid_t mda(void); 1045 1046 1047/* mfa.c */ 1048pid_t mfa(void); 1049 1050 1051/* mta.c */ 1052pid_t mta(void); 1053int mta_session_cmp(struct mta_session *, struct mta_session *); 1054SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp); 1055 1056 1057/* parse.y */ 1058int parse_config(struct smtpd *, const char *, int); 1059int cmdline_symset(char *); 1060 1061 1062/* queue.c */ 1063pid_t queue(void); 1064void queue_submit_envelope(struct envelope *); 1065void queue_commit_envelopes(struct envelope *); 1066 1067 1068/* queue_backend.c */ 1069struct queue_backend *queue_backend_lookup(enum queue_type); 1070int queue_message_create(enum queue_kind, u_int32_t *); 1071int queue_message_delete(enum queue_kind, u_int32_t); 1072int queue_message_commit(enum queue_kind, u_int32_t); 1073int queue_message_fd_r(enum queue_kind, u_int32_t); 1074int queue_message_fd_rw(enum queue_kind, u_int32_t); 1075int queue_message_purge(enum queue_kind, u_int32_t); 1076int queue_envelope_create(enum queue_kind, struct envelope *); 1077int queue_envelope_delete(enum queue_kind, struct envelope *); 1078int queue_envelope_load(enum queue_kind, u_int64_t, struct envelope *); 1079int queue_envelope_update(enum queue_kind, struct envelope *); 1080 1081 1082/* queue_shared.c */ 1083void queue_message_update(struct envelope *); 1084struct qwalk *qwalk_new(char *); 1085int qwalk(struct qwalk *, char *); 1086void qwalk_close(struct qwalk *); 1087int bounce_record_message(struct envelope *, struct envelope *); 1088void show_queue(char *, int); 1089 1090 1091/* ramqueue.c */ 1092void ramqueue_init(struct ramqueue *); 1093int ramqueue_load(struct ramqueue *, time_t *); 1094int ramqueue_load_offline(struct ramqueue *); 1095int ramqueue_host_cmp(struct ramqueue_host *, struct ramqueue_host *); 1096int ramqueue_msg_cmp(struct ramqueue_message *, struct ramqueue_message *); 1097int ramqueue_evp_cmp(struct ramqueue_envelope *, struct ramqueue_envelope *); 1098void ramqueue_remove(struct ramqueue *, struct ramqueue_envelope *); 1099int ramqueue_is_empty(struct ramqueue *); 1100int ramqueue_is_empty(struct ramqueue *); 1101int ramqueue_batch_is_empty(struct ramqueue_batch *); 1102int ramqueue_host_is_empty(struct ramqueue_host *); 1103void ramqueue_remove_batch(struct ramqueue_host *, struct ramqueue_batch *); 1104void ramqueue_remove_host(struct ramqueue *, struct ramqueue_host *); 1105struct ramqueue_envelope *ramqueue_envelope_by_id(struct ramqueue *, u_int64_t); 1106struct ramqueue_envelope *ramqueue_first_envelope(struct ramqueue *); 1107struct ramqueue_envelope *ramqueue_next_envelope(struct ramqueue *); 1108struct ramqueue_envelope *ramqueue_batch_first_envelope(struct ramqueue_batch *); 1109void ramqueue_insert(struct ramqueue *, struct envelope *, time_t); 1110int ramqueue_message_is_empty(struct ramqueue_message *); 1111void ramqueue_remove_message(struct ramqueue *, struct ramqueue_message *); 1112 1113struct ramqueue_host *ramqueue_lookup_host(struct ramqueue *, char *); 1114struct ramqueue_message *ramqueue_lookup_message(struct ramqueue *, u_int32_t); 1115struct ramqueue_envelope *ramqueue_lookup_envelope(struct ramqueue *, u_int64_t); 1116 1117void ramqueue_reschedule(struct ramqueue *, u_int64_t); 1118void ramqueue_reschedule_envelope(struct ramqueue *, struct ramqueue_envelope *); 1119 1120RB_PROTOTYPE(hosttree, ramqueue_host, hosttree_entry, ramqueue_host_cmp); 1121RB_PROTOTYPE(msgtree, ramqueue_message, msg_entry, ramqueue_msg_cmp); 1122RB_PROTOTYPE(evptree, ramqueue_envelope, evp_entry, ramqueue_evp_cmp); 1123 1124 1125/* runner.c */ 1126pid_t runner(void); 1127void message_reset_flags(struct envelope *); 1128 1129 1130/* smtp.c */ 1131pid_t smtp(void); 1132void smtp_resume(void); 1133 1134 1135/* smtp_session.c */ 1136void session_init(struct listener *, struct session *); 1137int session_cmp(struct session *, struct session *); 1138void session_pickup(struct session *, struct submit_status *); 1139void session_destroy(struct session *); 1140void session_respond(struct session *, char *, ...) 1141 __attribute__ ((format (printf, 2, 3))); 1142void session_bufferevent_new(struct session *); 1143SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1144 1145 1146/* smtpd.c */ 1147int child_cmp(struct child *, struct child *); 1148void imsg_event_add(struct imsgev *); 1149void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 1150 int, void *, u_int16_t); 1151void imsg_dispatch(int, short, void *); 1152SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1153 1154 1155/* ssl.c */ 1156void ssl_init(void); 1157void ssl_transaction(struct session *); 1158void ssl_session_init(struct session *); 1159void ssl_session_destroy(struct session *); 1160int ssl_load_certfile(const char *, u_int8_t); 1161void ssl_setup(struct listener *); 1162int ssl_cmp(struct ssl *, struct ssl *); 1163SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1164 1165 1166/* ssl_privsep.c */ 1167int ssl_ctx_use_private_key(void *, char *, off_t); 1168int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1169 1170 1171/* user_backend.c */ 1172struct user_backend *user_backend_lookup(enum user_type); 1173 1174 1175/* util.c */ 1176typedef struct arglist arglist; 1177struct arglist { 1178 char **list; 1179 u_int num; 1180 u_int nalloc; 1181}; 1182void addargs(arglist *, char *, ...) 1183 __attribute__((format(printf, 2, 3))); 1184int bsnprintf(char *, size_t, const char *, ...) 1185 __attribute__ ((format (printf, 3, 4))); 1186int safe_fclose(FILE *); 1187int hostname_match(char *, char *); 1188int email_to_mailaddr(struct mailaddr *, char *); 1189int valid_localpart(char *); 1190int valid_domainpart(char *); 1191char *ss_to_text(struct sockaddr_storage *); 1192int valid_message_id(char *); 1193int valid_message_uid(char *); 1194char *time_to_text(time_t); 1195int secure_file(int, char *, char *, uid_t, int); 1196void lowercase(char *, char *, size_t); 1197void envelope_set_errormsg(struct envelope *, char *, ...); 1198char *envelope_get_errormsg(struct envelope *); 1199void sa_set_port(struct sockaddr *, int); 1200u_int64_t generate_uid(void); 1201void fdlimit(double); 1202int availdesc(void); 1203u_int32_t evpid_to_msgid(u_int64_t); 1204u_int64_t msgid_to_evpid(u_int32_t); 1205u_int32_t filename_to_msgid(char *); 1206u_int64_t filename_to_evpid(char *); 1207