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