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