smtpd.h revision 1.340
1/* $OpenBSD: smtpd.h,v 1.340 2012/08/28 14:03:49 chl Exp $ */ 2 3/* 4 * Copyright (c) 2008 Gilles Chehade <gilles@openbsd.org> 5 * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org> 6 * Copyright (c) 2012 Eric Faurot <eric@openbsd.org> 7 * 8 * Permission to use, copy, modify, and distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21#ifndef nitems 22#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 23#endif 24 25#include "filter_api.h" 26#include "ioev.h" 27#include "iobuf.h" 28 29#define CONF_FILE "/etc/mail/smtpd.conf" 30#define MAX_LISTEN 16 31#define PROC_COUNT 9 32#define MAX_NAME_SIZE 64 33 34#define MAX_HOPS_COUNT 100 35 36#define MAX_TAG_SIZE 32 37 38 39/* return and forward path size */ 40#define MAX_FILTER_NAME 32 41#define MAX_PATH_SIZE 256 42#define MAX_RULEBUFFER_LEN 256 43 44#define SMTPD_QUEUE_INTERVAL (15 * 60) 45#define SMTPD_QUEUE_MAXINTERVAL (4 * 60 * 60) 46#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 47#define SMTPD_USER "_smtpd" 48#define SMTPD_FILTER_USER "_smtpmfa" 49#define SMTPD_SOCKET "/var/run/smtpd.sock" 50#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 51#define SMTPD_SESSION_TIMEOUT 300 52#define SMTPD_BACKLOG 5 53 54#define PATH_SMTPCTL "/usr/sbin/smtpctl" 55 56#define DIRHASH_BUCKETS 4096 57 58#define PATH_SPOOL "/var/spool/smtpd" 59#define PATH_OFFLINE "/offline" 60#define PATH_PURGE "/purge" 61#define PATH_TEMPORARY "/temporary" 62#define PATH_INCOMING "/incoming" 63#define PATH_ENVELOPES "/envelopes" 64#define PATH_MESSAGE "/message" 65 66/* number of MX records to lookup */ 67#define MAX_MX_COUNT 10 68 69/* max response delay under flood conditions */ 70#define MAX_RESPONSE_DELAY 60 71 72/* how many responses per state are undelayed */ 73#define FAST_RESPONSES 2 74 75/* max len of any smtp line */ 76#define SMTP_LINE_MAX MAX_LINE_SIZE 77 78#define F_STARTTLS 0x01 79#define F_SMTPS 0x02 80#define F_AUTH 0x04 81#define F_SSL (F_SMTPS|F_STARTTLS) 82 83#define F_BACKUP 0x10 /* XXX */ 84 85#define F_SCERT 0x01 86#define F_CCERT 0x02 87 88/* must match F_* for mta */ 89#define ROUTE_STARTTLS 0x01 90#define ROUTE_SMTPS 0x02 91#define ROUTE_SSL (ROUTE_STARTTLS | ROUTE_SMTPS) 92#define ROUTE_AUTH 0x04 93#define ROUTE_MX 0x08 94#define ROUTE_BACKUP 0x10 /* XXX */ 95 96typedef uint32_t objid_t; 97 98struct netaddr { 99 struct sockaddr_storage ss; 100 int bits; 101}; 102 103struct relayhost { 104 uint8_t flags; 105 char hostname[MAXHOSTNAMELEN]; 106 uint16_t port; 107 char cert[PATH_MAX]; 108 char authmap[MAX_PATH_SIZE]; 109}; 110 111enum imsg_type { 112 IMSG_NONE, 113 IMSG_CTL_OK, /* answer to smtpctl requests */ 114 IMSG_CTL_FAIL, 115 IMSG_CTL_SHUTDOWN, 116 IMSG_CTL_VERBOSE, 117 IMSG_CONF_START, 118 IMSG_CONF_SSL, 119 IMSG_CONF_LISTENER, 120 IMSG_CONF_MAP, 121 IMSG_CONF_MAP_CONTENT, 122 IMSG_CONF_RULE, 123 IMSG_CONF_RULE_SOURCE, 124 IMSG_CONF_FILTER, 125 IMSG_CONF_END, 126 IMSG_LKA_MAIL, 127 IMSG_LKA_RCPT, 128 IMSG_LKA_SECRET, 129 IMSG_LKA_RULEMATCH, 130 IMSG_MDA_SESS_NEW, 131 IMSG_MDA_DONE, 132 133 IMSG_MFA_CONNECT, 134 IMSG_MFA_HELO, 135 IMSG_MFA_MAIL, 136 IMSG_MFA_RCPT, 137 IMSG_MFA_DATALINE, 138 IMSG_MFA_QUIT, 139 IMSG_MFA_CLOSE, 140 IMSG_MFA_RSET, 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_DELIVERY_OK, 154 IMSG_QUEUE_DELIVERY_TEMPFAIL, 155 IMSG_QUEUE_DELIVERY_PERMFAIL, 156 IMSG_QUEUE_DELIVERY_LOOP, 157 IMSG_QUEUE_MESSAGE_FD, 158 IMSG_QUEUE_MESSAGE_FILE, 159 IMSG_QUEUE_REMOVE, 160 IMSG_QUEUE_EXPIRE, 161 162 IMSG_SCHEDULER_REMOVE, 163 IMSG_SCHEDULER_SCHEDULE, 164 165 IMSG_BATCH_CREATE, 166 IMSG_BATCH_APPEND, 167 IMSG_BATCH_CLOSE, 168 169 IMSG_PARENT_FORWARD_OPEN, 170 IMSG_PARENT_FORK_MDA, 171 172 IMSG_PARENT_AUTHENTICATE, 173 IMSG_PARENT_SEND_CONFIG, 174 175 IMSG_SMTP_ENQUEUE, 176 IMSG_SMTP_PAUSE, 177 IMSG_SMTP_RESUME, 178 179 IMSG_DNS_HOST, 180 IMSG_DNS_HOST_END, 181 IMSG_DNS_MX, 182 IMSG_DNS_PTR, 183 184 IMSG_STAT_INCREMENT, 185 IMSG_STAT_DECREMENT, 186 IMSG_STAT_SET, 187 188 IMSG_STATS, 189 IMSG_STATS_GET, 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 uint8_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_RELAY, 298 A_RELAYVIA, 299 A_MAILDIR, 300 A_MBOX, 301 A_FILENAME, 302 A_MDA 303}; 304 305#define IS_MAILBOX(x) ((x).r_action == A_MAILDIR || (x).r_action == A_MBOX || (x).r_action == A_FILENAME) 306#define IS_RELAY(x) ((x).r_action == A_RELAY || (x).r_action == A_RELAYVIA) 307 308struct rule { 309 TAILQ_ENTRY(rule) r_entry; 310 char r_tag[MAX_TAG_SIZE]; 311 int r_accept; 312 struct map *r_sources; 313 struct cond r_condition; 314 enum action_type r_action; 315 union rule_dest { 316 char buffer[MAX_RULEBUFFER_LEN]; 317 struct relayhost relayhost; 318 } r_value; 319 320 char *r_user; 321 struct mailaddr *r_as; 322 objid_t r_amap; 323 time_t r_qexpire; 324}; 325 326struct mailaddr { 327 char user[MAX_LOCALPART_SIZE]; 328 char domain[MAX_DOMAINPART_SIZE]; 329}; 330 331enum delivery_type { 332 D_MDA, 333 D_MTA, 334 D_BOUNCE 335}; 336 337enum delivery_status { 338 DS_PERMFAILURE = 0x1, 339 DS_TEMPFAILURE = 0x2, 340}; 341 342enum delivery_flags { 343 DF_AUTHENTICATED = 0x1, 344 DF_ENQUEUED = 0x2, 345 DF_BOUNCE = 0x4, 346 DF_INTERNAL = 0x8 /* internal expansion forward */ 347}; 348 349union delivery_data { 350 char user[MAXLOGNAME]; 351 char buffer[MAX_RULEBUFFER_LEN]; 352 struct mailaddr mailaddr; 353}; 354 355struct delivery_mda { 356 enum action_type method; 357 union delivery_data to; 358 char as_user[MAXLOGNAME]; 359}; 360 361struct delivery_mta { 362 struct relayhost relay; 363}; 364 365enum expand_type { 366 EXPAND_INVALID, 367 EXPAND_USERNAME, 368 EXPAND_FILENAME, 369 EXPAND_FILTER, 370 EXPAND_INCLUDE, 371 EXPAND_ADDRESS 372}; 373 374enum expand_flags { 375 F_EXPAND_NONE, 376 F_EXPAND_DONE 377}; 378 379struct expandnode { 380 RB_ENTRY(expandnode) entry; 381 size_t refcnt; 382 enum expand_flags flags; 383 enum expand_type type; 384 char as_user[MAXLOGNAME]; 385 union delivery_data u; 386}; 387 388RB_HEAD(expandtree, expandnode); 389 390#define SMTPD_ENVELOPE_VERSION 1 391struct envelope { 392 TAILQ_ENTRY(envelope) entry; 393 394 char tag[MAX_TAG_SIZE]; 395 struct rule rule; 396 397 uint64_t session_id; 398 uint64_t batch_id; 399 400 uint32_t version; 401 uint64_t id; 402 enum delivery_type type; 403 404 char helo[MAXHOSTNAMELEN]; 405 char hostname[MAXHOSTNAMELEN]; 406 char errorline[MAX_LINE_SIZE + 1]; 407 struct sockaddr_storage ss; 408 409 struct mailaddr sender; 410 struct mailaddr rcpt; 411 struct mailaddr dest; 412 413 union delivery_method { 414 struct delivery_mda mda; 415 struct delivery_mta mta; 416 } agent; 417 418 time_t creation; 419 time_t lasttry; 420 time_t expire; 421 uint8_t retry; 422 enum delivery_flags flags; 423}; 424TAILQ_HEAD(deliverylist, envelope); 425 426enum envelope_field { 427 EVP_VERSION, 428 EVP_MSGID, 429 EVP_TYPE, 430 EVP_HELO, 431 EVP_HOSTNAME, 432 EVP_ERRORLINE, 433 EVP_SOCKADDR, 434 EVP_SENDER, 435 EVP_RCPT, 436 EVP_DEST, 437 EVP_CTIME, 438 EVP_EXPIRE, 439 EVP_RETRY, 440 EVP_LASTTRY, 441 EVP_FLAGS, 442 EVP_MDA_METHOD, 443 EVP_MDA_BUFFER, 444 EVP_MDA_USER, 445 EVP_MTA_RELAY_HOST, 446 EVP_MTA_RELAY_PORT, 447 EVP_MTA_RELAY_FLAGS, 448 EVP_MTA_RELAY_CERT, 449 EVP_MTA_RELAY_AUTHMAP 450}; 451 452 453enum child_type { 454 CHILD_INVALID, 455 CHILD_DAEMON, 456 CHILD_MDA, 457 CHILD_ENQUEUE_OFFLINE, 458}; 459 460struct child { 461 SPLAY_ENTRY(child) entry; 462 pid_t pid; 463 enum child_type type; 464 enum smtp_proc_type title; 465 int mda_out; 466 uint32_t mda_id; 467 char *path; 468}; 469 470enum session_state { 471 S_NEW = 0, 472 S_CONNECTED, 473 S_INIT, 474 S_GREETED, 475 S_TLS, 476 S_AUTH_INIT, 477 S_AUTH_USERNAME, 478 S_AUTH_PASSWORD, 479 S_AUTH_FINALIZE, 480 S_RSET, 481 S_HELO, 482 S_MAIL_MFA, 483 S_MAIL_QUEUE, 484 S_MAIL, 485 S_RCPT_MFA, 486 S_RCPT, 487 S_DATA, 488 S_DATA_QUEUE, 489 S_DATACONTENT, 490 S_DONE, 491 S_QUIT, 492 S_CLOSE 493}; 494#define STATE_COUNT 22 495 496struct ssl { 497 SPLAY_ENTRY(ssl) ssl_nodes; 498 char ssl_name[PATH_MAX]; 499 char *ssl_ca; 500 off_t ssl_ca_len; 501 char *ssl_cert; 502 off_t ssl_cert_len; 503 char *ssl_key; 504 off_t ssl_key_len; 505 char *ssl_dhparams; 506 off_t ssl_dhparams_len; 507 uint8_t flags; 508}; 509 510struct listener { 511 uint8_t flags; 512 int fd; 513 struct sockaddr_storage ss; 514 in_port_t port; 515 struct timeval timeout; 516 struct event ev; 517 char ssl_cert_name[PATH_MAX]; 518 struct ssl *ssl; 519 void *ssl_ctx; 520 char tag[MAX_TAG_SIZE]; 521 TAILQ_ENTRY(listener) entry; 522}; 523 524struct auth { 525 uint64_t id; 526 char user[MAXLOGNAME]; 527 char pass[MAX_LINE_SIZE + 1]; 528 int success; 529}; 530 531enum session_flags { 532 F_EHLO = 0x01, 533 F_8BITMIME = 0x02, 534 F_SECURE = 0x04, 535 F_AUTHENTICATED = 0x08, 536 F_WAITIMSG = 0x10, 537 F_ZOMBIE = 0x20, 538}; 539 540struct session { 541 SPLAY_ENTRY(session) s_nodes; 542 uint64_t s_id; 543 544 struct iobuf s_iobuf; 545 struct io s_io; 546 547 enum session_flags s_flags; 548 enum session_state s_state; 549 struct sockaddr_storage s_ss; 550 char s_hostname[MAXHOSTNAMELEN]; 551 struct event s_ev; 552 struct listener *s_l; 553 void *s_ssl; 554 struct timeval s_tv; 555 struct envelope s_msg; 556 short s_nresp[STATE_COUNT]; 557 size_t rcptcount; 558 long s_datalen; 559 560 struct auth s_auth; 561 int s_dstatus; 562 563 FILE *datafp; 564}; 565 566 567struct smtpd { 568 char sc_conffile[MAXPATHLEN]; 569 size_t sc_maxsize; 570 571#define SMTPD_OPT_VERBOSE 0x00000001 572#define SMTPD_OPT_NOACTION 0x00000002 573 uint32_t sc_opts; 574#define SMTPD_CONFIGURING 0x00000001 575#define SMTPD_EXITING 0x00000002 576#define SMTPD_MDA_PAUSED 0x00000004 577#define SMTPD_MTA_PAUSED 0x00000008 578#define SMTPD_SMTP_PAUSED 0x00000010 579#define SMTPD_MDA_BUSY 0x00000020 580#define SMTPD_MTA_BUSY 0x00000040 581#define SMTPD_BOUNCE_BUSY 0x00000080 582#define SMTPD_SMTP_DISABLED 0x00000100 583 uint32_t sc_flags; 584 uint32_t sc_queue_flags; 585#define QUEUE_COMPRESS 0x00000001 586#define QUEUE_ENCRYPT 0x00000002 587 char *sc_queue_compress_algo; 588 char *sc_queue_encrypt_cipher; 589 char *sc_queue_encrypt_key; 590 struct timeval sc_qintval; 591 int sc_qexpire; 592 struct event sc_ev; 593 int *sc_pipes[PROC_COUNT] 594 [PROC_COUNT]; 595 struct imsgev *sc_ievs[PROC_COUNT]; 596 int sc_instances[PROC_COUNT]; 597 int sc_instance; 598 char *sc_title[PROC_COUNT]; 599 struct passwd *sc_pw; 600 char sc_hostname[MAXHOSTNAMELEN]; 601 struct queue_backend *sc_queue; 602 struct compress_backend *sc_compress; 603 struct scheduler_backend *sc_scheduler; 604 struct stat_backend *sc_stat; 605 606 time_t sc_uptime; 607 608 TAILQ_HEAD(filterlist, filter) *sc_filters; 609 610 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 611 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 612 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 613 SPLAY_HEAD(sessiontree, session) sc_sessions; 614 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 615 SPLAY_HEAD(childtree, child) children; 616 SPLAY_HEAD(lkatree, lka_session) lka_sessions; 617 SPLAY_HEAD(mfatree, mfa_session) mfa_sessions; 618 LIST_HEAD(mdalist, mda_session) mda_sessions; 619 620 uint64_t filtermask; 621}; 622 623#define TRACE_VERBOSE 0x0001 624#define TRACE_IMSG 0x0002 625#define TRACE_IO 0x0004 626#define TRACE_SMTP 0x0008 627#define TRACE_MTA 0x0010 628#define TRACE_BOUNCE 0x0020 629#define TRACE_SCHEDULER 0x0040 630#define TRACE_STAT 0x0080 631#define TRACE_PROFILING 0x0100 632 633 634struct submit_status { 635 uint64_t id; 636 int code; 637 union submit_path { 638 struct mailaddr maddr; 639 uint32_t msgid; 640 uint64_t evpid; 641 char errormsg[MAX_LINE_SIZE + 1]; 642 char dataline[MAX_LINE_SIZE + 1]; 643 } u; 644 enum delivery_flags flags; 645 struct sockaddr_storage ss; 646 struct envelope envelope; 647}; 648 649struct forward_req { 650 uint64_t id; 651 uint8_t status; 652 char as_user[MAXLOGNAME]; 653 struct envelope envelope; 654}; 655 656enum dns_status { 657 DNS_OK = 0, 658 DNS_RETRY, 659 DNS_EINVAL, 660 DNS_ENONAME, 661 DNS_ENOTFOUND, 662}; 663 664struct dns { 665 uint64_t id; 666 char host[MAXHOSTNAMELEN]; 667 char backup[MAXHOSTNAMELEN]; 668 int port; 669 int error; 670 int type; 671 struct imsgev *asker; 672 struct sockaddr_storage ss; 673}; 674 675struct secret { 676 uint64_t id; 677 char mapname[MAX_PATH_SIZE]; 678 char host[MAXHOSTNAMELEN]; 679 char secret[MAX_LINE_SIZE]; 680}; 681 682struct mda_session { 683 LIST_ENTRY(mda_session) entry; 684 struct envelope msg; 685 struct msgbuf w; 686 struct event ev; 687 uint32_t id; 688 FILE *datafp; 689}; 690 691struct deliver { 692 char to[PATH_MAX]; 693 char from[PATH_MAX]; 694 char user[MAXLOGNAME]; 695 short mode; 696}; 697 698struct rulematch { 699 uint64_t id; 700 struct submit_status ss; 701}; 702 703enum lka_session_flags { 704 F_ERROR = 0x1 705}; 706 707struct lka_session { 708 SPLAY_ENTRY(lka_session) nodes; 709 uint64_t id; 710 711 struct deliverylist deliverylist; 712 struct expandtree expandtree; 713 714 uint8_t iterations; 715 uint32_t pending; 716 enum lka_session_flags flags; 717 struct submit_status ss; 718}; 719 720struct filter { 721 TAILQ_ENTRY(filter) f_entry; 722 pid_t pid; 723 struct event ev; 724 struct imsgbuf *ibuf; 725 char name[MAX_FILTER_NAME]; 726 char path[MAXPATHLEN]; 727}; 728 729struct mfa_session { 730 SPLAY_ENTRY(mfa_session) nodes; 731 uint64_t id; 732 733 enum session_state state; 734 struct submit_status ss; 735 struct filter *filter; 736 struct filter_msg fm; 737}; 738 739struct mta_session; 740 741struct mta_route { 742 SPLAY_ENTRY(mta_route) entry; 743 uint64_t id; 744 745 uint8_t flags; 746 char *hostname; 747 char *backupname; 748 uint16_t port; 749 char *cert; 750 char *auth; 751 void *ssl; 752 753 /* route limits */ 754 int maxconn; /* in parallel */ 755 int maxmail; /* per session */ 756 int maxrcpt; /* per mail */ 757 758 int refcount; 759 760 int ntask; 761 TAILQ_HEAD(, mta_task) tasks; 762 763 int nsession; 764 765 int nfail; 766 char errorline[64]; 767}; 768 769struct mta_task { 770 TAILQ_ENTRY(mta_task) entry; 771 struct mta_route *route; 772 uint32_t msgid; 773 TAILQ_HEAD(, envelope) envelopes; 774 struct mailaddr sender; 775 struct mta_session *session; 776}; 777 778/* maps return structures */ 779struct map_credentials { 780 char username[MAX_LINE_SIZE]; 781 char password[MAX_LINE_SIZE]; 782}; 783 784struct map_alias { 785 size_t nbnodes; 786 struct expandtree expandtree; 787}; 788 789struct map_virtual { 790 size_t nbnodes; 791 struct expandtree expandtree; 792}; 793 794struct map_netaddr { 795 struct netaddr netaddr; 796}; 797 798enum queue_op { 799 QOP_INVALID=0, 800 QOP_CREATE, 801 QOP_DELETE, 802 QOP_UPDATE, 803 QOP_COMMIT, 804 QOP_LOAD, 805 QOP_FD_R, 806 QOP_CORRUPT, 807}; 808 809struct queue_backend { 810 int (*init)(int); 811 int (*message)(enum queue_op, uint32_t *); 812 int (*envelope)(enum queue_op, uint64_t *, char *, size_t); 813 814 void *(*qwalk_new)(uint32_t); 815 int (*qwalk)(void *, uint64_t *); 816 void (*qwalk_close)(void *); 817}; 818 819struct compress_backend { 820 int (*compress_file)(int, int); 821 int (*uncompress_file)(int, int); 822 size_t (*compress_buffer)(const char *, size_t, char *, size_t); 823 size_t (*uncompress_buffer)(const char *, size_t, char *, size_t); 824}; 825 826/* auth structures */ 827enum auth_type { 828 AUTH_BSD, 829 AUTH_PWD, 830}; 831 832struct auth_backend { 833 int (*authenticate)(char *, char *); 834}; 835 836 837/* user structures */ 838enum user_type { 839 USER_PWD, 840}; 841 842#define MAXPASSWORDLEN 128 843struct mta_user { 844 char username[MAXLOGNAME]; 845 char directory[MAXPATHLEN]; 846 char password[MAXPASSWORDLEN]; 847 uid_t uid; 848 gid_t gid; 849}; 850 851struct user_backend { 852 int (*getbyname)(struct mta_user *, char *); 853}; 854 855 856/* delivery_backend */ 857struct delivery_backend { 858 void (*open)(struct deliver *); 859}; 860 861struct scheduler_info { 862 uint64_t evpid; 863 enum delivery_type type; 864 time_t creation; 865 time_t lasttry; 866 time_t expire; 867 uint8_t retry; 868}; 869 870struct id_list { 871 struct id_list *next; 872 uint64_t id; 873}; 874 875#define SCHED_NONE 0x00 876#define SCHED_DELAY 0x01 877#define SCHED_REMOVE 0x02 878#define SCHED_EXPIRE 0x04 879#define SCHED_BOUNCE 0x08 880#define SCHED_MDA 0x10 881#define SCHED_MTA 0x20 882 883struct scheduler_batch { 884 int type; 885 time_t delay; 886 struct id_list *evpids; 887}; 888 889struct scheduler_backend { 890 void (*init)(void); 891 892 void (*insert)(struct scheduler_info *); 893 void (*commit)(uint32_t); 894 void (*rollback)(uint32_t); 895 896 void (*update)(struct scheduler_info *); 897 void (*delete)(uint64_t); 898 899 void (*batch)(int, time_t, struct scheduler_batch *); 900 901 void (*schedule)(uint64_t); 902 void (*remove)(uint64_t); 903}; 904 905 906enum stat_type { 907 STAT_COUNTER, 908 STAT_TIMESTAMP, 909 STAT_TIMEVAL, 910 STAT_TIMESPEC, 911}; 912 913struct stat_value { 914 enum stat_type type; 915 union stat_v { 916 size_t counter; 917 time_t timestamp; 918 struct timeval tv; 919 struct timespec ts; 920 } u; 921}; 922 923#define STAT_KEY_SIZE 1024 924struct stat_kv { 925 void *iter; 926 char key[STAT_KEY_SIZE]; 927 struct stat_value val; 928}; 929 930struct stat_backend { 931 void (*init)(void); 932 void (*close)(void); 933 void (*increment)(const char *, size_t); 934 void (*decrement)(const char *, size_t); 935 void (*set)(const char *, const struct stat_value *); 936 int (*iter)(void **, char **, struct stat_value *); 937}; 938 939 940extern struct smtpd *env; 941extern void (*imsg_callback)(struct imsgev *, struct imsg *); 942 943 944/* aliases.c */ 945int aliases_exist(objid_t, char *); 946int aliases_get(objid_t, struct expandtree *, char *); 947int aliases_vdomain_exists(objid_t, char *); 948int aliases_virtual_exist(objid_t, struct mailaddr *); 949int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 950int alias_parse(struct expandnode *, char *); 951 952 953/* auth.c */ 954struct auth_backend *auth_backend_lookup(enum auth_type); 955 956 957/* bounce.c */ 958void bounce_add(uint64_t); 959void bounce_run(uint64_t, int); 960 961 962/* config.c */ 963#define PURGE_LISTENERS 0x01 964#define PURGE_MAPS 0x02 965#define PURGE_RULES 0x04 966#define PURGE_SSL 0x08 967#define PURGE_EVERYTHING 0xff 968void purge_config(uint8_t); 969void unconfigure(void); 970void configure(void); 971void init_pipes(void); 972void config_pipes(struct peer *, uint); 973void config_peers(struct peer *, uint); 974 975 976/* control.c */ 977pid_t control(void); 978void session_socket_blockmode(int, enum blockmodes); 979void session_socket_no_linger(int); 980int session_socket_error(int); 981 982 983/* delivery.c */ 984struct delivery_backend *delivery_backend_lookup(enum action_type); 985 986 987/* dns.c */ 988void dns_query_host(char *, int, uint64_t); 989void dns_query_mx(char *, char *, int, uint64_t); 990void dns_query_ptr(struct sockaddr_storage *, uint64_t); 991void dns_async(struct imsgev *, int, struct dns *); 992 993 994/* enqueue.c */ 995int enqueue(int, char **); 996int enqueue_offline(int, char **); 997 998 999/* envelope.c */ 1000void envelope_set_errormsg(struct envelope *, char *, ...); 1001char *envelope_ascii_field_name(enum envelope_field); 1002int envelope_ascii_load(enum envelope_field, struct envelope *, char *); 1003int envelope_ascii_dump(enum envelope_field, struct envelope *, char *, size_t); 1004int envelope_load_buffer(struct envelope *, char *, size_t); 1005int envelope_dump_buffer(struct envelope *, char *, size_t); 1006 1007/* expand.c */ 1008int expand_cmp(struct expandnode *, struct expandnode *); 1009void expandtree_increment_node(struct expandtree *, struct expandnode *); 1010void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1011void expandtree_remove_node(struct expandtree *, struct expandnode *); 1012struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1013void expandtree_free_nodes(struct expandtree *); 1014RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1015 1016 1017/* forward.c */ 1018int forwards_get(int, struct expandtree *, char *); 1019 1020 1021/* lka.c */ 1022pid_t lka(void); 1023int lka_session_cmp(struct lka_session *, struct lka_session *); 1024SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1025 1026/* lka_session.c */ 1027struct lka_session *lka_session_init(struct submit_status *); 1028void lka_session_fail(struct lka_session *); 1029void lka_session_destroy(struct lka_session *); 1030 1031 1032/* map.c */ 1033void *map_lookup(objid_t, char *, enum map_kind); 1034int map_compare(objid_t, char *, enum map_kind, int (*)(char *, char *)); 1035struct map *map_find(objid_t); 1036struct map *map_findbyname(const char *); 1037 1038 1039/* mda.c */ 1040pid_t mda(void); 1041 1042 1043/* mfa.c */ 1044pid_t mfa(void); 1045int mfa_session_cmp(struct mfa_session *, struct mfa_session *); 1046SPLAY_PROTOTYPE(mfatree, mfa_session, nodes, mfa_session_cmp); 1047 1048/* mta.c */ 1049pid_t mta(void); 1050int mta_response_delivery(const char *); 1051const char *mta_response_status(const char *); 1052const char *mta_response_text(const char *); 1053void mta_route_ok(struct mta_route *); 1054void mta_route_error(struct mta_route *, const char *); 1055void mta_route_collect(struct mta_route *); 1056const char *mta_route_to_text(struct mta_route *); 1057 1058/* mta_session.c */ 1059void mta_session(struct mta_route *); 1060void mta_session_imsg(struct imsgev *, struct imsg *); 1061 1062/* parse.y */ 1063int parse_config(struct smtpd *, const char *, int); 1064int cmdline_symset(char *); 1065 1066/* queue.c */ 1067pid_t queue(void); 1068 1069/* queue_backend.c */ 1070uint32_t queue_generate_msgid(void); 1071uint64_t queue_generate_evpid(uint32_t msgid); 1072struct queue_backend *queue_backend_lookup(const char *); 1073int queue_message_incoming_path(uint32_t, char *, size_t); 1074int queue_envelope_incoming_path(uint64_t, char *, size_t); 1075int queue_message_incoming_delete(uint32_t); 1076int queue_message_create(uint32_t *); 1077int queue_message_delete(uint32_t); 1078int queue_message_commit(uint32_t); 1079int queue_message_fd_r(uint32_t); 1080int queue_message_fd_rw(uint32_t); 1081int queue_message_corrupt(uint32_t); 1082int queue_envelope_create(struct envelope *); 1083int queue_envelope_delete(struct envelope *); 1084int queue_envelope_load(uint64_t, struct envelope *); 1085int queue_envelope_update(struct envelope *); 1086void *qwalk_new(uint32_t); 1087int qwalk(void *, uint64_t *); 1088void qwalk_close(void *); 1089 1090/* compress_backend.c */ 1091struct compress_backend *compress_backend_lookup(const char *); 1092int compress_file(int, int); 1093int uncompress_file(int, int); 1094size_t compress_buffer(const char *, size_t, char *, size_t); 1095size_t uncompress_buffer(const char *, size_t, char *, size_t); 1096 1097/* scheduler.c */ 1098pid_t scheduler(void); 1099 1100/* scheduler_bakend.c */ 1101struct scheduler_backend *scheduler_backend_lookup(const char *); 1102void scheduler_info(struct scheduler_info *, struct envelope *); 1103time_t scheduler_compute_schedule(struct scheduler_info *); 1104 1105/* smtp.c */ 1106pid_t smtp(void); 1107void smtp_resume(void); 1108void smtp_destroy(struct session *); 1109 1110/* smtp_session.c */ 1111void session_init(struct listener *, struct session *); 1112int session_cmp(struct session *, struct session *); 1113void session_io(struct io *, int); 1114void session_pickup(struct session *, struct submit_status *); 1115void session_destroy(struct session *, const char *); 1116void session_respond(struct session *, char *, ...) 1117 __attribute__ ((format (printf, 2, 3))); 1118 1119SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1120 1121 1122/* smtpd.c */ 1123int child_cmp(struct child *, struct child *); 1124void imsg_event_add(struct imsgev *); 1125void imsg_compose_event(struct imsgev *, uint16_t, uint32_t, pid_t, 1126 int, void *, uint16_t); 1127void imsg_dispatch(int, short, void *); 1128const char * proc_to_str(int); 1129const char * imsg_to_str(int); 1130SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1131 1132 1133/* ssl.c */ 1134void ssl_init(void); 1135void ssl_transaction(struct session *); 1136void ssl_session_init(struct session *); 1137void ssl_session_destroy(struct session *); 1138int ssl_load_certfile(const char *, uint8_t); 1139void ssl_setup(struct listener *); 1140int ssl_cmp(struct ssl *, struct ssl *); 1141void *ssl_mta_init(struct ssl *); 1142SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1143 1144 1145/* ssl_privsep.c */ 1146int ssl_ctx_use_private_key(void *, char *, off_t); 1147int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1148 1149 1150/* stat_backend.c */ 1151struct stat_backend *stat_backend_lookup(const char *); 1152void stat_increment(const char *, size_t); 1153void stat_decrement(const char *, size_t); 1154void stat_set(const char *, const struct stat_value *); 1155 1156struct stat_value *stat_counter(size_t); 1157struct stat_value *stat_timestamp(time_t); 1158struct stat_value *stat_timeval(struct timeval *); 1159struct stat_value *stat_timespec(struct timespec *); 1160 1161 1162/* tree.c */ 1163SPLAY_HEAD(tree, treeentry); 1164#define tree_init(t) SPLAY_INIT((t)) 1165#define tree_empty(t) SPLAY_EMPTY((t)) 1166int tree_check(struct tree *, uint64_t); 1167void *tree_set(struct tree *, uint64_t, void *); 1168void tree_xset(struct tree *, uint64_t, void *); 1169void *tree_get(struct tree *, uint64_t); 1170void *tree_xget(struct tree *, uint64_t); 1171void *tree_pop(struct tree *, uint64_t); 1172void *tree_xpop(struct tree *, uint64_t); 1173int tree_poproot(struct tree *, uint64_t *, void **); 1174int tree_root(struct tree *, uint64_t *, void **); 1175int tree_iter(struct tree *, void **, uint64_t *, void **); 1176void tree_merge(struct tree *, struct tree *); 1177 1178 1179/* user.c */ 1180struct user_backend *user_backend_lookup(enum user_type); 1181 1182 1183/* util.c */ 1184typedef struct arglist arglist; 1185struct arglist { 1186 char **list; 1187 uint num; 1188 uint nalloc; 1189}; 1190void addargs(arglist *, char *, ...) 1191 __attribute__((format(printf, 2, 3))); 1192int bsnprintf(char *, size_t, const char *, ...) 1193 __attribute__ ((format (printf, 3, 4))); 1194int mkdir_p(char *, mode_t); 1195int safe_fclose(FILE *); 1196int hostname_match(char *, char *); 1197int email_to_mailaddr(struct mailaddr *, char *); 1198int valid_localpart(const char *); 1199int valid_domainpart(const char *); 1200char *ss_to_text(struct sockaddr_storage *); 1201char *time_to_text(time_t); 1202char *duration_to_text(time_t); 1203int secure_file(int, char *, char *, uid_t, int); 1204int lowercase(char *, char *, size_t); 1205void xlowercase(char *, char *, size_t); 1206void sa_set_port(struct sockaddr *, int); 1207uint64_t generate_uid(void); 1208void fdlimit(double); 1209int availdesc(void); 1210uint32_t evpid_to_msgid(uint64_t); 1211uint64_t msgid_to_evpid(uint32_t); 1212void log_imsg(int, int, struct imsg*); 1213int ckdir(const char *, mode_t, uid_t, gid_t, int); 1214int rmtree(char *, int); 1215int mvpurge(char *, char *); 1216int mktmpfile(void); 1217const char *parse_smtp_response(char *, size_t, char **, int *); 1218int text_to_netaddr(struct netaddr *, char *); 1219int text_to_relayhost(struct relayhost *, char *); 1220void *xmalloc(size_t, const char *); 1221void *xcalloc(size_t, size_t, const char *); 1222char *xstrdup(const char *, const char *); 1223