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