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