smtpd.h revision 1.218
1/* $OpenBSD: smtpd.h,v 1.218 2011/04/17 12:46:46 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_BATCH_CREATE, 162 IMSG_BATCH_APPEND, 163 IMSG_BATCH_CLOSE, 164 IMSG_BATCH_DONE, 165 166 IMSG_PARENT_ENQUEUE_OFFLINE, 167 IMSG_PARENT_FORWARD_OPEN, 168 IMSG_PARENT_FORK_MDA, 169 170 IMSG_PARENT_AUTHENTICATE, 171 IMSG_PARENT_SEND_CONFIG, 172 173 IMSG_STATS, 174 IMSG_SMTP_ENQUEUE, 175 IMSG_SMTP_PAUSE, 176 IMSG_SMTP_RESUME, 177 178 IMSG_DNS_HOST, 179 IMSG_DNS_HOST_END, 180 IMSG_DNS_MX, 181 IMSG_DNS_PTR 182}; 183 184enum blockmodes { 185 BM_NORMAL, 186 BM_NONBLOCK 187}; 188 189struct imsgev { 190 struct imsgbuf ibuf; 191 void (*handler)(int, short, void *); 192 struct event ev; 193 void *data; 194 struct smtpd *env; 195 int proc; 196 short events; 197}; 198 199struct ctl_conn { 200 TAILQ_ENTRY(ctl_conn) entry; 201 u_int8_t flags; 202#define CTL_CONN_NOTIFY 0x01 203 struct imsgev iev; 204}; 205TAILQ_HEAD(ctl_connlist, ctl_conn); 206 207struct ctl_id { 208 objid_t id; 209 char name[MAX_NAME_SIZE]; 210}; 211 212enum smtp_proc_type { 213 PROC_PARENT = 0, 214 PROC_SMTP, 215 PROC_MFA, 216 PROC_LKA, 217 PROC_QUEUE, 218 PROC_MDA, 219 PROC_MTA, 220 PROC_CONTROL, 221 PROC_RUNNER, 222} smtpd_process; 223 224struct peer { 225 enum smtp_proc_type id; 226 void (*cb)(int, short, void *); 227}; 228 229enum map_type { 230 T_SINGLE, 231 T_LIST, 232 T_HASH 233}; 234 235enum map_src { 236 S_NONE, 237 S_DYN, 238 S_DNS, 239 S_PLAIN, 240 S_DB, 241 S_EXT 242}; 243 244enum map_kind { 245 K_NONE, 246 K_ALIAS, 247 K_VIRTUAL, 248 K_SECRET 249}; 250 251enum mapel_type { 252 ME_STRING, 253 ME_NET, 254 ME_NETMASK 255}; 256 257struct mapel { 258 TAILQ_ENTRY(mapel) me_entry; 259 union mapel_data { 260 char med_string[MAX_LINE_SIZE]; 261 struct netaddr med_addr; 262 } me_key; 263 union mapel_data me_val; 264}; 265 266struct map { 267 TAILQ_ENTRY(map) m_entry; 268#define F_USED 0x01 269#define F_DYNAMIC 0x02 270 u_int8_t m_flags; 271 char m_name[MAX_LINE_SIZE]; 272 objid_t m_id; 273 enum map_type m_type; 274 enum mapel_type m_eltype; 275 enum map_src m_src; 276 char m_config[MAXPATHLEN]; 277 TAILQ_HEAD(mapel_list, mapel) m_contents; 278}; 279 280struct map_backend { 281 enum map_src source; 282 void *(*open)(char *); 283 void (*close)(void *); 284 char *(*get)(void *, char *, size_t *); 285 int (*put)(void *, char *, char *); 286}; 287 288struct map_parser { 289 enum map_kind kind; 290 void *(*extract)(char *, char *, size_t); 291}; 292 293enum cond_type { 294 C_ALL, 295 C_NET, 296 C_DOM, 297 C_VDOM 298}; 299 300struct cond { 301 TAILQ_ENTRY(cond) c_entry; 302 objid_t c_map; 303 enum cond_type c_type; 304}; 305 306enum action_type { 307 A_INVALID, 308 A_RELAY, 309 A_RELAYVIA, 310 A_MAILDIR, 311 A_MBOX, 312 A_FILENAME, 313 A_EXT 314}; 315 316#define IS_MAILBOX(x) ((x).rule.r_action == A_MAILDIR || (x).rule.r_action == A_MBOX || (x).rule.r_action == A_FILENAME) 317#define IS_RELAY(x) ((x).rule.r_action == A_RELAY || (x).rule.r_action == A_RELAYVIA) 318#define IS_EXT(x) ((x).rule.r_action == A_EXT) 319 320struct rule { 321 TAILQ_ENTRY(rule) r_entry; 322 char r_tag[MAX_TAG_SIZE]; 323 int r_accept; 324 struct map *r_sources; 325 struct cond r_condition; 326 enum action_type r_action; 327 union rule_dest { 328 char buffer[MAX_RULEBUFFER_LEN]; 329 struct relayhost relayhost; 330 } r_value; 331 332 char *r_user; 333 objid_t r_amap; 334 time_t r_qexpire; 335}; 336 337enum path_flags { 338 F_PATH_ALIAS = 0x1, 339 F_PATH_VIRTUAL = 0x2, 340 F_PATH_EXPANDED = 0x4, 341 F_PATH_NOFORWARD = 0x8, 342 F_PATH_FORWARDED = 0x10, 343 F_PATH_ACCOUNT = 0x20, 344 F_PATH_AUTHENTICATED = 0x40, 345 F_PATH_RELAY = 0x80, 346}; 347 348struct mailaddr { 349 char user[MAX_LOCALPART_SIZE]; 350 char domain[MAX_DOMAINPART_SIZE]; 351}; 352 353union path_data { 354 char username[MAXLOGNAME]; 355 char filename[MAXPATHLEN]; 356 char filter[MAXPATHLEN]; 357 struct mailaddr mailaddr; 358}; 359 360struct path { 361 TAILQ_ENTRY(path) entry; 362 struct rule rule; 363 enum path_flags flags; 364 u_int8_t forwardcnt; 365 char user[MAX_LOCALPART_SIZE]; 366 char domain[MAX_DOMAINPART_SIZE]; 367 char pw_name[MAXLOGNAME]; 368 union path_data u; 369}; 370TAILQ_HEAD(deliverylist, path); 371 372enum expand_type { 373 EXPAND_INVALID, 374 EXPAND_USERNAME, 375 EXPAND_FILENAME, 376 EXPAND_FILTER, 377 EXPAND_INCLUDE, 378 EXPAND_ADDRESS 379}; 380 381enum expand_flags { 382 F_EXPAND_NONE, 383 F_EXPAND_DONE 384}; 385 386struct expandnode { 387 RB_ENTRY(expandnode) entry; 388 size_t refcnt; 389 enum expand_flags flags; 390 enum expand_type type; 391 union path_data u; 392}; 393 394RB_HEAD(expandtree, expandnode); 395 396enum message_type { 397 T_MDA_MESSAGE = 0x1, 398 T_MTA_MESSAGE = 0x2, 399 T_BOUNCE_MESSAGE = 0x4 400}; 401 402enum message_status { 403 S_MESSAGE_PERMFAILURE = 0x2, 404 S_MESSAGE_TEMPFAILURE = 0x4, 405 S_MESSAGE_REJECTED = 0x8, 406 S_MESSAGE_ACCEPTED = 0x10, 407 S_MESSAGE_RETRY = 0x20, 408 S_MESSAGE_EDNS = 0x40, 409 S_MESSAGE_ECONNECT = 0x80 410}; 411 412enum message_flags { 413 F_MESSAGE_RESOLVED = 0x1, 414 F_MESSAGE_SCHEDULED = 0x2, 415 F_MESSAGE_PROCESSING = 0x4, 416 F_MESSAGE_AUTHENTICATED = 0x8, 417 F_MESSAGE_ENQUEUED = 0x10, 418 F_MESSAGE_FORCESCHEDULE = 0x20, 419 F_MESSAGE_BOUNCE = 0x40 420}; 421 422struct envelope { 423 TAILQ_ENTRY(envelope) entry; 424 425 enum message_type type; 426 427 u_int64_t id; 428 u_int64_t session_id; 429 u_int64_t batch_id; 430 431 char tag[MAX_TAG_SIZE]; 432 433 u_int64_t evpid; 434 char session_helo[MAXHOSTNAMELEN]; 435 char session_hostname[MAXHOSTNAMELEN]; 436 char session_errorline[MAX_LINE_SIZE]; 437 struct sockaddr_storage session_ss; 438 struct path session_rcpt; 439 440 struct path sender; 441 struct path recipient; 442 443 time_t creation; 444 time_t lasttry; 445 time_t expire; 446 u_int8_t retry; 447 enum message_flags flags; 448 enum message_status status; 449}; 450 451enum child_type { 452 CHILD_INVALID, 453 CHILD_DAEMON, 454 CHILD_MDA, 455 CHILD_ENQUEUE_OFFLINE 456}; 457 458struct child { 459 SPLAY_ENTRY(child) entry; 460 pid_t pid; 461 enum child_type type; 462 enum smtp_proc_type title; 463 int mda_out; 464 u_int32_t mda_id; 465}; 466 467enum session_state { 468 S_INVALID = 0, 469 S_INIT, 470 S_GREETED, 471 S_TLS, 472 S_AUTH_INIT, 473 S_AUTH_USERNAME, 474 S_AUTH_PASSWORD, 475 S_AUTH_FINALIZE, 476 S_HELO, 477 S_MAIL_MFA, 478 S_MAIL_QUEUE, 479 S_MAIL, 480 S_RCPT_MFA, 481 S_RCPT, 482 S_DATA, 483 S_DATA_QUEUE, 484 S_DATACONTENT, 485 S_DONE, 486 S_QUIT 487}; 488#define STATE_COUNT 18 489 490struct ssl { 491 SPLAY_ENTRY(ssl) ssl_nodes; 492 char ssl_name[PATH_MAX]; 493 char *ssl_cert; 494 off_t ssl_cert_len; 495 char *ssl_key; 496 off_t ssl_key_len; 497 char *ssl_dhparams; 498 off_t ssl_dhparams_len; 499 u_int8_t flags; 500}; 501 502struct listener { 503 u_int8_t flags; 504 int fd; 505 struct sockaddr_storage ss; 506 in_port_t port; 507 struct timeval timeout; 508 struct event ev; 509 struct smtpd *env; 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 struct smtpd *s_env; 548 void *s_ssl; 549 u_char *s_buf; 550 int s_buflen; 551 struct timeval s_tv; 552 struct envelope s_msg; 553 short s_nresp[STATE_COUNT]; 554 size_t rcptcount; 555 long s_datalen; 556 557 struct auth s_auth; 558 559 FILE *datafp; 560 int mboxfd; 561 int messagefd; 562}; 563 564 565/* ram-queue structures */ 566struct ramqueue_host { 567 RB_ENTRY(ramqueue_host) host_entry; 568 TAILQ_HEAD(,ramqueue_batch) batch_queue; 569 u_int64_t h_id; 570 char hostname[MAXHOSTNAMELEN]; 571}; 572struct ramqueue_batch { 573 TAILQ_ENTRY(ramqueue_batch) batch_entry; 574 TAILQ_HEAD(,ramqueue_envelope) envelope_queue; 575 enum message_type type; 576 u_int64_t h_id; 577 u_int64_t b_id; 578 u_int32_t msgid; 579 struct rule rule; 580}; 581struct ramqueue_envelope { 582 TAILQ_ENTRY(ramqueue_envelope) queue_entry; 583 TAILQ_ENTRY(ramqueue_envelope) batchqueue_entry; 584 struct ramqueue_host *host; 585 struct ramqueue_batch *batch; 586 u_int64_t evpid; 587 time_t sched; 588}; 589 590struct ramqueue { 591 struct smtpd *env; 592 struct ramqueue_envelope *current_evp; 593 RB_HEAD(hosttree, ramqueue_host) hosttree; 594 TAILQ_HEAD(,ramqueue_envelope) queue; 595}; 596 597 598struct smtpd { 599 char sc_conffile[MAXPATHLEN]; 600 size_t sc_maxsize; 601 602#define SMTPD_OPT_VERBOSE 0x00000001 603#define SMTPD_OPT_NOACTION 0x00000002 604 u_int32_t sc_opts; 605#define SMTPD_CONFIGURING 0x00000001 606#define SMTPD_EXITING 0x00000002 607#define SMTPD_MDA_PAUSED 0x00000004 608#define SMTPD_MTA_PAUSED 0x00000008 609#define SMTPD_SMTP_PAUSED 0x00000010 610 u_int32_t sc_flags; 611 struct timeval sc_qintval; 612 int sc_qexpire; 613 u_int32_t sc_maxconn; 614 struct event sc_ev; 615 int *sc_pipes[PROC_COUNT] 616 [PROC_COUNT]; 617 struct imsgev *sc_ievs[PROC_COUNT]; 618 int sc_instances[PROC_COUNT]; 619 int sc_instance; 620 char *sc_title[PROC_COUNT]; 621 struct passwd *sc_pw; 622 char sc_hostname[MAXHOSTNAMELEN]; 623 struct ramqueue sc_rqueue; 624 struct queue_backend *sc_queue; 625 626 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 627 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 628 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 629 SPLAY_HEAD(sessiontree, session) sc_sessions; 630 SPLAY_HEAD(msgtree, envelope) sc_messages; 631 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 632 SPLAY_HEAD(childtree, child) children; 633 SPLAY_HEAD(lkatree, lkasession) lka_sessions; 634 SPLAY_HEAD(dnstree, dnssession) dns_sessions; 635 SPLAY_HEAD(mtatree, mta_session) mta_sessions; 636 LIST_HEAD(mdalist, mda_session) mda_sessions; 637 638 struct stats *stats; 639}; 640 641struct s_parent { 642 time_t start; 643}; 644 645struct s_queue { 646 size_t inserts_local; 647 size_t inserts_remote; 648}; 649 650struct s_runner { 651 size_t active; 652 size_t maxactive; 653 size_t bounces_active; 654 size_t bounces_maxactive; 655 size_t bounces; 656}; 657 658struct s_session { 659 size_t sessions; 660 size_t sessions_inet4; 661 size_t sessions_inet6; 662 size_t sessions_active; 663 size_t sessions_maxactive; 664 665 size_t smtps; 666 size_t smtps_active; 667 size_t smtps_maxactive; 668 669 size_t starttls; 670 size_t starttls_active; 671 size_t starttls_maxactive; 672 673 size_t read_error; 674 size_t read_timeout; 675 size_t read_eof; 676 size_t write_error; 677 size_t write_timeout; 678 size_t write_eof; 679 size_t toofast; 680 size_t tempfail; 681 size_t linetoolong; 682 size_t delays; 683}; 684 685struct s_mda { 686 size_t sessions; 687 size_t sessions_active; 688 size_t sessions_maxactive; 689}; 690 691struct s_control { 692 size_t sessions; 693 size_t sessions_active; 694 size_t sessions_maxactive; 695}; 696 697struct s_lka { 698 size_t queries; 699 size_t queries_active; 700 size_t queries_maxactive; 701 size_t queries_mx; 702 size_t queries_host; 703 size_t queries_cname; 704 size_t queries_failure; 705}; 706 707struct s_ramqueue { 708 size_t hosts; 709 size_t batches; 710 size_t envelopes; 711 size_t hosts_max; 712 size_t batches_max; 713 size_t envelopes_max; 714}; 715 716struct stats { 717 struct s_parent parent; 718 struct s_queue queue; 719 struct s_runner runner; 720 struct s_session mta; 721 struct s_mda mda; 722 struct s_session smtp; 723 struct s_control control; 724 struct s_lka lka; 725 struct s_ramqueue ramqueue; 726}; 727 728struct reload { 729 int fd; 730 int ret; 731}; 732 733struct submit_status { 734 u_int64_t id; 735 int code; 736 union submit_path { 737 struct path path; 738 u_int32_t msgid; 739 u_int64_t evpid; 740 char errormsg[MAX_LINE_SIZE]; 741 } u; 742 enum message_flags flags; 743 struct sockaddr_storage ss; 744 struct envelope msg; 745}; 746 747struct forward_req { 748 u_int64_t id; 749 u_int8_t status; 750 char pw_name[MAXLOGNAME]; 751}; 752 753struct dns { 754 u_int64_t id; 755 char host[MAXHOSTNAMELEN]; 756 int port; 757 int error; 758 int type; 759 struct imsgev *asker; 760 struct sockaddr_storage ss; 761 struct smtpd *env; 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 lkasession_flags { 793 F_ERROR = 0x1 794}; 795 796struct lkasession { 797 SPLAY_ENTRY(lkasession) nodes; 798 u_int64_t id; 799 800 struct path path; 801 struct deliverylist deliverylist; 802 803 struct expandtree expandtree; 804 805 u_int8_t iterations; 806 u_int32_t pending; 807 enum lkasession_flags flags; 808 struct envelope message; 809 struct submit_status ss; 810}; 811 812struct mx { 813 char host[MAXHOSTNAMELEN]; 814 int prio; 815}; 816 817struct dnssession { 818 SPLAY_ENTRY(dnssession) nodes; 819 u_int64_t id; 820 struct dns query; 821 struct event ev; 822 struct asr_query *aq; 823 struct mx mxarray[MAX_MX_COUNT]; 824 size_t mxarraysz; 825 size_t mxcurrent; 826 size_t mxfound; 827}; 828 829enum mta_state { 830 MTA_INVALID_STATE, 831 MTA_INIT, 832 MTA_SECRET, 833 MTA_DATA, 834 MTA_MX, 835 MTA_CONNECT, 836 MTA_PTR, 837 MTA_PROTOCOL, 838 MTA_DONE 839}; 840 841/* mta session flags */ 842#define MTA_FORCE_ANYSSL 0x01 843#define MTA_FORCE_SMTPS 0x02 844#define MTA_ALLOW_PLAIN 0x04 845#define MTA_USE_AUTH 0x08 846#define MTA_FORCE_MX 0x10 847 848struct mta_relay { 849 TAILQ_ENTRY(mta_relay) entry; 850 struct sockaddr_storage sa; 851 char fqdn[MAXHOSTNAMELEN]; 852 int used; 853}; 854 855struct mta_session { 856 SPLAY_ENTRY(mta_session) entry; 857 u_int64_t id; 858 struct smtpd *env; 859 enum mta_state state; 860 char *host; 861 int port; 862 int flags; 863 TAILQ_HEAD(,envelope) recipients; 864 TAILQ_HEAD(,mta_relay) relays; 865 objid_t secmapid; 866 char *secret; 867 int fd; 868 FILE *datafp; 869 struct event ev; 870 char *cert; 871 void *pcb; 872 struct ramqueue_batch *batch; 873}; 874 875 876/* maps return structures */ 877struct map_secret { 878 char username[MAX_LINE_SIZE]; 879 char password[MAX_LINE_SIZE]; 880}; 881 882struct map_alias { 883 size_t nbnodes; 884 struct expandtree expandtree; 885}; 886 887struct map_virtual { 888 size_t nbnodes; 889 struct expandtree expandtree; 890}; 891 892 893/* queue structures */ 894enum queue_type { 895 QT_INVALID=0, 896 QT_FS 897}; 898 899enum queue_kind { 900 Q_INVALID=0, 901 Q_ENQUEUE, 902 Q_INCOMING, 903 Q_QUEUE, 904 Q_PURGE, 905 Q_OFFLINE, 906 Q_BOUNCE 907}; 908 909enum queue_op { 910 QOP_INVALID=0, 911 QOP_CREATE, 912 QOP_DELETE, 913 QOP_UPDATE, 914 QOP_COMMIT, 915 QOP_LOAD, 916 QOP_FD_R, 917 QOP_FD_RW, 918 QOP_PURGE 919}; 920 921struct queue_backend { 922 enum queue_type type; 923 int (*init)(struct smtpd *); 924 int (*message)(struct smtpd *, enum queue_kind, enum queue_op, u_int32_t *); 925 int (*envelope)(struct smtpd *, enum queue_kind, enum queue_op, 926 struct envelope *); 927}; 928 929extern void (*imsg_callback)(struct smtpd *, struct imsgev *, struct imsg *); 930 931 932 933/* aliases.c */ 934int aliases_exist(struct smtpd *, objid_t, char *); 935int aliases_get(struct smtpd *, objid_t, struct expandtree *, char *); 936int aliases_vdomain_exists(struct smtpd *, objid_t, char *); 937int aliases_virtual_exist(struct smtpd *, objid_t, struct path *); 938int aliases_virtual_get(struct smtpd *, objid_t, struct expandtree *, struct path *); 939int alias_parse(struct expandnode *, char *); 940 941 942/* authenticate.c */ 943int authenticate_user(char *, char *); 944 945 946/* bounce.c */ 947int bounce_session(struct smtpd *, int, struct envelope *); 948int bounce_session_switch(struct smtpd *, FILE *, enum session_state *, char *, 949 struct envelope *); 950void bounce_event(int, short, void *); 951 952 953/* config.c */ 954#define PURGE_LISTENERS 0x01 955#define PURGE_MAPS 0x02 956#define PURGE_RULES 0x04 957#define PURGE_SSL 0x08 958#define PURGE_EVERYTHING 0xff 959void purge_config(struct smtpd *, u_int8_t); 960void unconfigure(struct smtpd *); 961void configure(struct smtpd *); 962void init_pipes(struct smtpd *); 963void config_pipes(struct smtpd *, struct peer *, u_int); 964void config_peers(struct smtpd *, struct peer *, u_int); 965 966 967/* control.c */ 968pid_t control(struct smtpd *); 969void session_socket_blockmode(int, enum blockmodes); 970void session_socket_no_linger(int); 971int session_socket_error(int); 972 973 974/* dns.c */ 975void dns_query_host(struct smtpd *, char *, int, u_int64_t); 976void dns_query_mx(struct smtpd *, char *, int, u_int64_t); 977void dns_query_ptr(struct smtpd *, struct sockaddr_storage *, 978 u_int64_t); 979void dns_async(struct smtpd *, struct imsgev *, int, struct dns *); 980 981 982/* enqueue.c */ 983int enqueue(int, char **); 984int enqueue_offline(int, char **); 985 986 987/* expand.c */ 988int expand_cmp(struct expandnode *, struct expandnode *); 989void expandtree_increment_node(struct expandtree *, struct expandnode *); 990void expandtree_decrement_node(struct expandtree *, struct expandnode *); 991void expandtree_remove_node(struct expandtree *, struct expandnode *); 992struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 993void expandtree_free_nodes(struct expandtree *); 994RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 995 996 997/* forward.c */ 998int forwards_get(int, struct expandtree *); 999 1000 1001/* lka.c */ 1002pid_t lka(struct smtpd *); 1003int lkasession_cmp(struct lkasession *, struct lkasession *); 1004int dnssession_cmp(struct dnssession *, struct dnssession *); 1005SPLAY_PROTOTYPE(lkatree, lkasession, nodes, lkasession_cmp); 1006SPLAY_PROTOTYPE(dnstree, dnssession, nodes, dnssession_cmp); 1007 1008 1009/* map.c */ 1010void *map_lookup(struct smtpd *, objid_t, char *, enum map_kind); 1011struct map *map_find(struct smtpd *, objid_t); 1012struct map *map_findbyname(struct smtpd *, const char *); 1013 1014 1015 1016/* mda.c */ 1017pid_t mda(struct smtpd *); 1018 1019 1020/* mfa.c */ 1021pid_t mfa(struct smtpd *); 1022 1023 1024/* mta.c */ 1025pid_t mta(struct smtpd *); 1026int mta_session_cmp(struct mta_session *, struct mta_session *); 1027SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp); 1028 1029 1030/* parse.y */ 1031int parse_config(struct smtpd *, const char *, int); 1032int cmdline_symset(char *); 1033 1034 1035/* queue.c */ 1036pid_t queue(struct smtpd *); 1037void queue_submit_envelope(struct smtpd *, struct envelope *); 1038void queue_commit_envelopes(struct smtpd *, struct envelope *); 1039 1040 1041/* queue_backend.c */ 1042struct queue_backend *queue_backend_lookup(enum queue_type); 1043int queue_message_create(struct smtpd *, enum queue_kind, u_int32_t *); 1044int queue_message_delete(struct smtpd *, enum queue_kind, u_int32_t); 1045int queue_message_commit(struct smtpd *, enum queue_kind, u_int32_t); 1046int queue_message_fd_r(struct smtpd *, enum queue_kind, u_int32_t); 1047int queue_message_fd_rw(struct smtpd *, enum queue_kind, u_int32_t); 1048int queue_message_purge(struct smtpd *, enum queue_kind, u_int32_t); 1049int queue_envelope_create(struct smtpd *, enum queue_kind, 1050 struct envelope *); 1051int queue_envelope_delete(struct smtpd *, enum queue_kind, 1052 struct envelope *); 1053int queue_envelope_load(struct smtpd *, enum queue_kind, 1054 u_int64_t, struct envelope *); 1055int queue_envelope_update(struct smtpd *, enum queue_kind, 1056 struct envelope *); 1057 1058 1059/* queue_shared.c */ 1060void queue_message_update(struct smtpd *, struct envelope *); 1061struct qwalk *qwalk_new(char *); 1062int qwalk(struct qwalk *, char *); 1063void qwalk_close(struct qwalk *); 1064int bounce_record_message(struct smtpd *, struct envelope *, struct envelope *); 1065void show_queue(char *, int); 1066 1067 1068/* ramqueue.c */ 1069void ramqueue_init(struct smtpd *, struct ramqueue *); 1070int ramqueue_load(struct ramqueue *, time_t *); 1071int ramqueue_load_offline(struct ramqueue *); 1072int ramqueue_host_cmp(struct ramqueue_host *, struct ramqueue_host *); 1073void ramqueue_remove(struct ramqueue *, struct ramqueue_envelope *); 1074int ramqueue_is_empty(struct ramqueue *); 1075int ramqueue_is_empty(struct ramqueue *); 1076int ramqueue_batch_is_empty(struct ramqueue_batch *); 1077int ramqueue_host_is_empty(struct ramqueue_host *); 1078void ramqueue_remove_batch(struct ramqueue_host *, struct ramqueue_batch *); 1079void ramqueue_remove_host(struct ramqueue *, struct ramqueue_host *); 1080struct ramqueue_envelope *ramqueue_first_envelope(struct ramqueue *); 1081struct ramqueue_envelope *ramqueue_next_envelope(struct ramqueue *); 1082struct ramqueue_envelope *ramqueue_batch_first_envelope(struct ramqueue_batch *); 1083RB_PROTOTYPE(hosttree, ramqueue_host, host_entry, ramqueue_host_cmp); 1084 1085 1086/* runner.c */ 1087pid_t runner(struct smtpd *); 1088void message_reset_flags(struct envelope *); 1089 1090 1091/* smtp.c */ 1092pid_t smtp(struct smtpd *); 1093void smtp_resume(struct smtpd *); 1094 1095 1096/* smtp_session.c */ 1097void session_init(struct listener *, struct session *); 1098int session_cmp(struct session *, struct session *); 1099void session_pickup(struct session *, struct submit_status *); 1100void session_destroy(struct session *); 1101void session_respond(struct session *, char *, ...) 1102 __attribute__ ((format (printf, 2, 3))); 1103void session_bufferevent_new(struct session *); 1104 1105SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1106 1107 1108/* smtpd.c */ 1109int child_cmp(struct child *, struct child *); 1110SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1111void imsg_event_add(struct imsgev *); 1112void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 1113 int, void *, u_int16_t); 1114void imsg_dispatch(int, short, void *); 1115 1116 1117/* ssl.c */ 1118void ssl_init(void); 1119void ssl_transaction(struct session *); 1120 1121void ssl_session_init(struct session *); 1122void ssl_session_destroy(struct session *); 1123int ssl_load_certfile(struct smtpd *, const char *, u_int8_t); 1124void ssl_setup(struct smtpd *, struct listener *); 1125int ssl_cmp(struct ssl *, struct ssl *); 1126SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1127 1128 1129/* ssl_privsep.c */ 1130int ssl_ctx_use_private_key(void *, char *, off_t); 1131int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1132 1133 1134/* util.c */ 1135typedef struct arglist arglist; 1136struct arglist { 1137 char **list; 1138 u_int num; 1139 u_int nalloc; 1140}; 1141void addargs(arglist *, char *, ...) 1142 __attribute__((format(printf, 2, 3))); 1143int bsnprintf(char *, size_t, const char *, ...) 1144 __attribute__ ((format (printf, 3, 4))); 1145int safe_fclose(FILE *); 1146int hostname_match(char *, char *); 1147int recipient_to_path(struct path *, char *); 1148int valid_localpart(char *); 1149int valid_domainpart(char *); 1150char *ss_to_text(struct sockaddr_storage *); 1151int valid_message_id(char *); 1152int valid_message_uid(char *); 1153char *time_to_text(time_t); 1154int secure_file(int, char *, struct passwd *, int); 1155void lowercase(char *, char *, size_t); 1156void message_set_errormsg(struct envelope *, char *, ...); 1157char *message_get_errormsg(struct envelope *); 1158void sa_set_port(struct sockaddr *, int); 1159struct path *path_dup(struct path *); 1160u_int64_t generate_uid(void); 1161void fdlimit(double); 1162int availdesc(void); 1163u_int32_t evpid_to_msgid(u_int64_t); 1164u_int64_t msgid_to_evpid(u_int32_t); 1165u_int32_t filename_to_msgid(char *); 1166u_int64_t filename_to_evpid(char *); 1167