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