smtpd.h revision 1.305
1/* $OpenBSD: smtpd.h,v 1.305 2012/07/09 09:57:53 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 626enum { 627 STATS_SMTP_SESSION = 0, 628 STATS_SMTP_SESSION_INET4, 629 STATS_SMTP_SESSION_INET6, 630 STATS_SMTP_SMTPS, 631 STATS_SMTP_STARTTLS, 632 633 STATS_MTA_SESSION, 634 635 STATS_MDA_SESSION, 636 637 STATS_CONTROL_SESSION, 638 639 STATS_LKA_SESSION, 640 STATS_LKA_SESSION_MX, 641 STATS_LKA_SESSION_HOST, 642 STATS_LKA_SESSION_CNAME, 643 STATS_LKA_FAILURE, 644 645 STATS_SCHEDULER, 646 STATS_SCHEDULER_BOUNCES, 647 648 STATS_QUEUE_LOCAL, 649 STATS_QUEUE_REMOTE, 650 651 STATS_RAMQUEUE_ENVELOPE, 652 STATS_RAMQUEUE_MESSAGE, 653 STATS_RAMQUEUE_BATCH, 654 STATS_RAMQUEUE_HOST, 655 656 STATS_MAX, 657}; 658 659#define STAT_COUNT 0 660#define STAT_ACTIVE 1 661#define STAT_MAXACTIVE 2 662 663struct stat_counter { 664 size_t count; 665 size_t active; 666 size_t maxactive; 667}; 668 669struct s_parent { 670 time_t start; 671}; 672 673struct s_session { 674 size_t read_error; 675 size_t read_timeout; 676 size_t read_eof; 677 size_t write_error; 678 size_t write_timeout; 679 size_t write_eof; 680 size_t toofast; 681 size_t tempfail; 682 size_t linetoolong; 683 size_t delays; 684}; 685 686struct stats { 687 struct s_parent parent; 688 struct s_session mta; 689 struct s_session smtp; 690 691 struct stat_counter counters[STATS_MAX]; 692}; 693 694struct submit_status { 695 u_int64_t id; 696 int code; 697 union submit_path { 698 struct mailaddr maddr; 699 u_int32_t msgid; 700 u_int64_t evpid; 701 char errormsg[MAX_LINE_SIZE + 1]; 702 char dataline[MAX_LINE_SIZE + 1]; 703 } u; 704 enum delivery_flags flags; 705 struct sockaddr_storage ss; 706 struct envelope envelope; 707}; 708 709struct forward_req { 710 u_int64_t id; 711 u_int8_t status; 712 char as_user[MAXLOGNAME]; 713 struct envelope envelope; 714}; 715 716enum dns_status { 717 DNS_OK = 0, 718 DNS_RETRY, 719 DNS_EINVAL, 720 DNS_ENONAME, 721 DNS_ENOTFOUND, 722}; 723 724struct dns { 725 u_int64_t id; 726 char host[MAXHOSTNAMELEN]; 727 int port; 728 int error; 729 int type; 730 struct imsgev *asker; 731 struct sockaddr_storage ss; 732 struct dns *next; 733}; 734 735struct secret { 736 u_int64_t id; 737 char mapname[MAX_PATH_SIZE]; 738 char host[MAXHOSTNAMELEN]; 739 char secret[MAX_LINE_SIZE]; 740}; 741 742struct mda_session { 743 LIST_ENTRY(mda_session) entry; 744 struct envelope msg; 745 struct msgbuf w; 746 struct event ev; 747 u_int32_t id; 748 FILE *datafp; 749}; 750 751struct deliver { 752 char to[PATH_MAX]; 753 char from[PATH_MAX]; 754 char user[MAXLOGNAME]; 755 short mode; 756}; 757 758struct rulematch { 759 u_int64_t id; 760 struct submit_status ss; 761}; 762 763enum lka_session_flags { 764 F_ERROR = 0x1 765}; 766 767struct lka_session { 768 SPLAY_ENTRY(lka_session) nodes; 769 u_int64_t id; 770 771 struct deliverylist deliverylist; 772 struct expandtree expandtree; 773 774 u_int8_t iterations; 775 u_int32_t pending; 776 enum lka_session_flags flags; 777 struct submit_status ss; 778}; 779 780struct filter { 781 TAILQ_ENTRY(filter) f_entry; 782 pid_t pid; 783 struct event ev; 784 struct imsgbuf *ibuf; 785 char name[MAX_FILTER_NAME]; 786 char path[MAXPATHLEN]; 787}; 788 789struct mfa_session { 790 SPLAY_ENTRY(mfa_session) nodes; 791 u_int64_t id; 792 793 enum session_state state; 794 struct submit_status ss; 795 struct filter *filter; 796 struct filter_msg fm; 797}; 798 799enum mta_state { 800 MTA_INIT, 801 MTA_SECRET, 802 MTA_DATA, 803 MTA_MX, 804 MTA_CONNECT, 805 MTA_DONE, 806 MTA_SMTP_READY, 807 MTA_SMTP_BANNER, 808 MTA_SMTP_EHLO, 809 MTA_SMTP_HELO, 810 MTA_SMTP_STARTTLS, 811 MTA_SMTP_AUTH, 812 MTA_SMTP_MAIL, 813 MTA_SMTP_RCPT, 814 MTA_SMTP_DATA, 815 MTA_SMTP_QUIT, 816 MTA_SMTP_BODY, 817 MTA_SMTP_DONE, 818 MTA_SMTP_RSET, 819}; 820 821/* mta session flags */ 822#define MTA_FORCE_ANYSSL 0x01 823#define MTA_FORCE_SMTPS 0x02 824#define MTA_ALLOW_PLAIN 0x04 825#define MTA_USE_AUTH 0x08 826#define MTA_FORCE_MX 0x10 827#define MTA_USE_CERT 0x20 828#define MTA_TLS 0x40 829 830struct mta_relay { 831 TAILQ_ENTRY(mta_relay) entry; 832 struct sockaddr_storage sa; 833 char fqdn[MAXHOSTNAMELEN]; 834 int used; 835}; 836 837struct mta_task; 838 839#define MTA_EXT_STARTTLS 0x01 840#define MTA_EXT_AUTH 0x02 841#define MTA_EXT_PIPELINING 0x04 842 843struct mta_session { 844 SPLAY_ENTRY(mta_session) entry; 845 u_int64_t id; 846 enum mta_state state; 847 char *host; 848 int port; 849 int flags; 850 TAILQ_HEAD(,mta_relay) relays; 851 char *authmap; 852 char *secret; 853 FILE *datafp; 854 855 TAILQ_HEAD(,mta_task) tasks; 856 857 struct envelope *currevp; 858 struct iobuf iobuf; 859 struct io io; 860 int ext; /* extension */ 861 struct ssl *ssl; 862}; 863 864struct mta_batch { 865 u_int64_t id; 866 struct relayhost relay; 867 868 u_int32_t msgid; 869}; 870 871/* maps return structures */ 872struct map_credentials { 873 char username[MAX_LINE_SIZE]; 874 char password[MAX_LINE_SIZE]; 875}; 876 877struct map_alias { 878 size_t nbnodes; 879 struct expandtree expandtree; 880}; 881 882struct map_virtual { 883 size_t nbnodes; 884 struct expandtree expandtree; 885}; 886 887struct map_netaddr { 888 struct netaddr netaddr; 889}; 890 891enum queue_op { 892 QOP_INVALID=0, 893 QOP_CREATE, 894 QOP_DELETE, 895 QOP_UPDATE, 896 QOP_COMMIT, 897 QOP_LOAD, 898 QOP_FD_R, 899 QOP_CORRUPT, 900}; 901 902struct queue_backend { 903 int (*init)(int); 904 int (*message)(enum queue_op, u_int32_t *); 905 int (*envelope)(enum queue_op, struct envelope *); 906 907 void *(*qwalk_new)(u_int32_t); 908 int (*qwalk)(void *, u_int64_t *); 909 void (*qwalk_close)(void *); 910}; 911 912 913/* auth structures */ 914enum auth_type { 915 AUTH_BSD, 916 AUTH_PWD, 917}; 918 919struct auth_backend { 920 int (*authenticate)(char *, char *); 921}; 922 923 924/* user structures */ 925enum user_type { 926 USER_PWD, 927}; 928 929#define MAXPASSWORDLEN 128 930struct mta_user { 931 char username[MAXLOGNAME]; 932 char directory[MAXPATHLEN]; 933 char password[MAXPASSWORDLEN]; 934 uid_t uid; 935 gid_t gid; 936}; 937 938struct user_backend { 939 int (*getbyname)(struct mta_user *, char *); 940 int (*getbyuid)(struct mta_user *, uid_t); 941}; 942 943 944/* delivery_backend */ 945struct delivery_backend { 946 void (*open)(struct deliver *); 947}; 948 949struct scheduler_info { 950 u_int64_t evpid; 951 char destination[MAXHOSTNAMELEN]; 952 953 enum delivery_type type; 954 time_t creation; 955 time_t lasttry; 956 time_t expire; 957 u_int8_t retry; 958}; 959 960struct scheduler_backend { 961 void (*init)(void); 962 int (*setup)(time_t, time_t); 963 964 int (*next)(u_int64_t *, time_t *); 965 966 void (*insert)(struct scheduler_info *); 967 void (*schedule)(u_int64_t); 968 void (*remove)(u_int64_t); 969 970 void *(*host)(char *); 971 void *(*message)(u_int32_t); 972 void *(*batch)(u_int64_t); 973 void *(*queue)(void); 974 void (*close)(void *); 975 976 int (*fetch)(void *, u_int64_t *); 977 int (*force)(u_int64_t); 978 979 void (*display)(void); /* may be NULL */ 980}; 981 982 983 984extern struct smtpd *env; 985extern void (*imsg_callback)(struct imsgev *, struct imsg *); 986 987 988/* aliases.c */ 989int aliases_exist(objid_t, char *); 990int aliases_get(objid_t, struct expandtree *, char *); 991int aliases_vdomain_exists(objid_t, char *); 992int aliases_virtual_exist(objid_t, struct mailaddr *); 993int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 994int alias_parse(struct expandnode *, char *); 995 996 997/* auth.c */ 998struct auth_backend *auth_backend_lookup(enum auth_type); 999 1000 1001/* bounce.c */ 1002int bounce_session(int, struct envelope *); 1003int bounce_session_switch(FILE *, enum session_state *, char *, struct envelope *); 1004void bounce_event(int, short, void *); 1005int bounce_record_message(struct envelope *, struct envelope *); 1006 1007/* config.c */ 1008#define PURGE_LISTENERS 0x01 1009#define PURGE_MAPS 0x02 1010#define PURGE_RULES 0x04 1011#define PURGE_SSL 0x08 1012#define PURGE_EVERYTHING 0xff 1013void purge_config(u_int8_t); 1014void unconfigure(void); 1015void configure(void); 1016void init_pipes(void); 1017void config_pipes(struct peer *, u_int); 1018void config_peers(struct peer *, u_int); 1019 1020 1021/* control.c */ 1022pid_t control(void); 1023void session_socket_blockmode(int, enum blockmodes); 1024void session_socket_no_linger(int); 1025int session_socket_error(int); 1026 1027 1028/* delivery.c */ 1029struct delivery_backend *delivery_backend_lookup(enum action_type); 1030 1031 1032/* dns.c */ 1033void dns_query_host(char *, int, u_int64_t); 1034void dns_query_mx(char *, int, u_int64_t); 1035void dns_query_ptr(struct sockaddr_storage *, u_int64_t); 1036void dns_async(struct imsgev *, int, struct dns *); 1037 1038 1039/* enqueue.c */ 1040int enqueue(int, char **); 1041int enqueue_offline(int, char **); 1042 1043 1044/* envelope.c */ 1045void envelope_set_errormsg(struct envelope *, char *, ...); 1046char *envelope_ascii_field_name(enum envelope_field); 1047int envelope_ascii_load(enum envelope_field, struct envelope *, char *); 1048int envelope_ascii_dump(enum envelope_field, struct envelope *, char *, size_t); 1049int envelope_load_file(struct envelope *, FILE *); 1050int envelope_dump_file(struct envelope *, FILE *); 1051 1052/* expand.c */ 1053int expand_cmp(struct expandnode *, struct expandnode *); 1054void expandtree_increment_node(struct expandtree *, struct expandnode *); 1055void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1056void expandtree_remove_node(struct expandtree *, struct expandnode *); 1057struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1058void expandtree_free_nodes(struct expandtree *); 1059RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1060 1061 1062/* forward.c */ 1063int forwards_get(int, struct expandtree *, char *); 1064 1065 1066/* lka.c */ 1067pid_t lka(void); 1068int lka_session_cmp(struct lka_session *, struct lka_session *); 1069SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1070 1071/* lka_session.c */ 1072struct lka_session *lka_session_init(struct submit_status *); 1073void lka_session_fail(struct lka_session *); 1074void lka_session_destroy(struct lka_session *); 1075 1076 1077/* map.c */ 1078void *map_lookup(objid_t, char *, enum map_kind); 1079int map_compare(objid_t, char *, enum map_kind, int (*)(char *, char *)); 1080struct map *map_find(objid_t); 1081struct map *map_findbyname(const char *); 1082 1083 1084/* mda.c */ 1085pid_t mda(void); 1086 1087 1088/* mfa.c */ 1089pid_t mfa(void); 1090int mfa_session_cmp(struct mfa_session *, struct mfa_session *); 1091SPLAY_PROTOTYPE(mfatree, mfa_session, nodes, mfa_session_cmp); 1092 1093/* mta.c */ 1094pid_t mta(void); 1095 1096/* mta_session.c */ 1097void mta_session_imsg(struct imsgev *, struct imsg *); 1098 1099/* parse.y */ 1100int parse_config(struct smtpd *, const char *, int); 1101int cmdline_symset(char *); 1102 1103 1104/* queue.c */ 1105pid_t queue(void); 1106void queue_submit_envelope(struct envelope *); 1107void queue_commit_envelopes(struct envelope *); 1108 1109 1110/* queue_backend.c */ 1111u_int32_t queue_generate_msgid(void); 1112u_int64_t queue_generate_evpid(u_int32_t msgid); 1113struct queue_backend *queue_backend_lookup(const char *); 1114int queue_message_incoming_path(u_int32_t, char *, size_t); 1115int queue_envelope_incoming_path(u_int64_t, char *, size_t); 1116int queue_message_incoming_delete(u_int32_t); 1117int queue_message_create(u_int32_t *); 1118int queue_message_delete(u_int32_t); 1119int queue_message_commit(u_int32_t); 1120int queue_message_fd_r(u_int32_t); 1121int queue_message_fd_rw(u_int32_t); 1122int queue_message_corrupt(u_int32_t); 1123int queue_envelope_create(struct envelope *); 1124int queue_envelope_delete(struct envelope *); 1125int queue_envelope_load(u_int64_t, struct envelope *); 1126int queue_envelope_update(struct envelope *); 1127void *qwalk_new(u_int32_t); 1128int qwalk(void *, u_int64_t *); 1129void qwalk_close(void *); 1130 1131 1132/* scheduler.c */ 1133pid_t scheduler(void); 1134void message_reset_flags(struct envelope *); 1135 1136 1137/* scheduler.c */ 1138struct scheduler_backend *scheduler_backend_lookup(const char *); 1139void scheduler_info(struct scheduler_info *, struct envelope *); 1140 1141 1142/* smtp.c */ 1143pid_t smtp(void); 1144void smtp_resume(void); 1145 1146 1147/* smtp_session.c */ 1148void session_init(struct listener *, struct session *); 1149int session_cmp(struct session *, struct session *); 1150void session_io(struct io *, int); 1151void session_pickup(struct session *, struct submit_status *); 1152void session_destroy(struct session *, const char *); 1153void session_respond(struct session *, char *, ...) 1154 __attribute__ ((format (printf, 2, 3))); 1155 1156SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1157 1158 1159/* smtpd.c */ 1160int child_cmp(struct child *, struct child *); 1161void imsg_event_add(struct imsgev *); 1162void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 1163 int, void *, u_int16_t); 1164void imsg_dispatch(int, short, void *); 1165const char * proc_to_str(int); 1166const char * imsg_to_str(int); 1167SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1168 1169 1170/* ssl.c */ 1171void ssl_init(void); 1172void ssl_transaction(struct session *); 1173void ssl_session_init(struct session *); 1174void ssl_session_destroy(struct session *); 1175int ssl_load_certfile(const char *, u_int8_t); 1176void ssl_setup(struct listener *); 1177int ssl_cmp(struct ssl *, struct ssl *); 1178void *ssl_mta_init(struct ssl *); 1179SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1180 1181 1182/* ssl_privsep.c */ 1183int ssl_ctx_use_private_key(void *, char *, off_t); 1184int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1185 1186/* stats.c */ 1187void stat_init(struct stat_counter *, int); 1188size_t stat_get(int, int); 1189size_t stat_increment(int); 1190size_t stat_decrement(int); 1191 1192 1193/* user.c */ 1194struct user_backend *user_backend_lookup(enum user_type); 1195 1196 1197/* util.c */ 1198typedef struct arglist arglist; 1199struct arglist { 1200 char **list; 1201 u_int num; 1202 u_int nalloc; 1203}; 1204void addargs(arglist *, char *, ...) 1205 __attribute__((format(printf, 2, 3))); 1206int bsnprintf(char *, size_t, const char *, ...) 1207 __attribute__ ((format (printf, 3, 4))); 1208int safe_fclose(FILE *); 1209int hostname_match(char *, char *); 1210int email_to_mailaddr(struct mailaddr *, char *); 1211int valid_localpart(char *); 1212int valid_domainpart(char *); 1213char *ss_to_text(struct sockaddr_storage *); 1214int valid_message_id(char *); 1215int valid_message_uid(char *); 1216char *time_to_text(time_t); 1217int secure_file(int, char *, char *, uid_t, int); 1218void lowercase(char *, char *, size_t); 1219void sa_set_port(struct sockaddr *, int); 1220u_int64_t generate_uid(void); 1221void fdlimit(double); 1222int availdesc(void); 1223u_int32_t evpid_to_msgid(u_int64_t); 1224u_int64_t msgid_to_evpid(u_int32_t); 1225void log_imsg(int, int, struct imsg*); 1226int ckdir(const char *, mode_t, uid_t, gid_t, int); 1227int rmtree(char *, int); 1228int mvpurge(char *, char *); 1229const char *parse_smtp_response(char *, size_t, char **, int *); 1230int text_to_netaddr(struct netaddr *, char *); 1231int text_to_relayhost(struct relayhost *, char *); 1232