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