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