smtpd.h revision 1.353
1/* $OpenBSD: smtpd.h,v 1.353 2012/09/18 12:13:22 eric 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 S_LDAP*/ 241}; 242 243enum map_kind { 244 K_NONE, 245 K_ALIAS, 246 K_VIRTUAL, 247 K_CREDENTIALS, 248 K_NETADDR 249}; 250 251enum mapel_type { 252 ME_STRING, 253 ME_NET, 254 ME_NETMASK 255}; 256 257struct mapel { 258 TAILQ_ENTRY(mapel) me_entry; 259 union mapel_data { 260 char med_string[MAX_LINE_SIZE]; 261 } me_key; 262 union mapel_data me_val; 263}; 264 265struct map { 266 TAILQ_ENTRY(map) m_entry; 267 char m_name[MAX_LINE_SIZE]; 268 objid_t m_id; 269 enum mapel_type m_eltype; 270 enum map_src m_src; 271 char m_config[MAXPATHLEN]; 272 TAILQ_HEAD(mapel_list, mapel) m_contents; 273}; 274 275 276struct map_backend { 277 void *(*open)(struct map *); 278 void (*close)(void *); 279 void *(*lookup)(void *, char *, enum map_kind); 280 int (*compare)(void *, char *, enum map_kind, int (*)(char *, char *)); 281}; 282 283 284enum cond_type { 285 C_ALL, 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 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#define SMTPD_SMTP_DISABLED 0x00000100 582 uint32_t sc_flags; 583 uint32_t sc_queue_flags; 584#define QUEUE_COMPRESS 0x00000001 585 char *sc_queue_compress_algo; 586 struct timeval sc_qintval; 587 int sc_qexpire; 588 struct event sc_ev; 589 int *sc_pipes[PROC_COUNT] 590 [PROC_COUNT]; 591 struct imsgev *sc_ievs[PROC_COUNT]; 592 int sc_instances[PROC_COUNT]; 593 int sc_instance; 594 char *sc_title[PROC_COUNT]; 595 struct passwd *sc_pw; 596 char sc_hostname[MAXHOSTNAMELEN]; 597 struct queue_backend *sc_queue; 598 struct compress_backend *sc_compress; 599 struct scheduler_backend *sc_scheduler; 600 struct stat_backend *sc_stat; 601 602 time_t sc_uptime; 603 604 TAILQ_HEAD(filterlist, filter) *sc_filters; 605 606 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 607 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 608 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 609 SPLAY_HEAD(sessiontree, session) sc_sessions; 610 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 611 SPLAY_HEAD(childtree, child) children; 612 SPLAY_HEAD(lkatree, lka_session) lka_sessions; 613 SPLAY_HEAD(mfatree, mfa_session) mfa_sessions; 614 LIST_HEAD(mdalist, mda_session) mda_sessions; 615 616 uint64_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#define TRACE_SCHEDULER 0x0040 626#define TRACE_STAT 0x0080 627#define TRACE_PROFILING 0x0100 628 629 630struct submit_status { 631 uint64_t id; 632 int code; 633 union submit_path { 634 struct mailaddr maddr; 635 uint32_t msgid; 636 uint64_t evpid; 637 char errormsg[MAX_LINE_SIZE + 1]; 638 char dataline[MAX_LINE_SIZE + 1]; 639 } u; 640 enum delivery_flags flags; 641 struct sockaddr_storage ss; 642 struct envelope envelope; 643}; 644 645struct forward_req { 646 uint64_t id; 647 uint8_t status; 648 char as_user[MAXLOGNAME]; 649 struct envelope envelope; 650}; 651 652enum dns_status { 653 DNS_OK = 0, 654 DNS_RETRY, 655 DNS_EINVAL, 656 DNS_ENONAME, 657 DNS_ENOTFOUND, 658}; 659 660struct dns { 661 uint64_t id; 662 char host[MAXHOSTNAMELEN]; 663 char backup[MAXHOSTNAMELEN]; 664 int port; 665 int error; 666 int type; 667 struct imsgev *asker; 668 struct sockaddr_storage ss; 669}; 670 671struct secret { 672 uint64_t id; 673 char mapname[MAX_PATH_SIZE]; 674 char host[MAXHOSTNAMELEN]; 675 char secret[MAX_LINE_SIZE]; 676}; 677 678struct mda_session { 679 LIST_ENTRY(mda_session) entry; 680 struct envelope msg; 681 struct msgbuf w; 682 struct event ev; 683 uint32_t id; 684 FILE *datafp; 685}; 686 687struct deliver { 688 char to[PATH_MAX]; 689 char from[PATH_MAX]; 690 char user[MAXLOGNAME]; 691 short mode; 692}; 693 694struct rulematch { 695 uint64_t id; 696 struct submit_status ss; 697}; 698 699enum lka_session_flags { 700 F_ERROR = 0x1 701}; 702 703struct lka_session { 704 SPLAY_ENTRY(lka_session) nodes; 705 uint64_t id; 706 707 struct deliverylist deliverylist; 708 struct expandtree expandtree; 709 710 uint8_t iterations; 711 uint32_t pending; 712 enum lka_session_flags flags; 713 struct submit_status ss; 714}; 715 716struct filter { 717 TAILQ_ENTRY(filter) f_entry; 718 pid_t pid; 719 struct event ev; 720 struct imsgbuf *ibuf; 721 char name[MAX_FILTER_NAME]; 722 char path[MAXPATHLEN]; 723}; 724 725struct mfa_session { 726 SPLAY_ENTRY(mfa_session) nodes; 727 uint64_t id; 728 729 enum session_state state; 730 struct submit_status ss; 731 struct filter *filter; 732 struct filter_msg fm; 733}; 734 735struct mta_session; 736 737struct mta_route { 738 SPLAY_ENTRY(mta_route) entry; 739 uint64_t id; 740 741 uint8_t flags; 742 char *hostname; 743 char *backupname; 744 uint16_t port; 745 char *cert; 746 char *auth; 747 void *ssl; 748 749 /* route limits */ 750 int maxconn; /* in parallel */ 751 int maxmail; /* per session */ 752 int maxrcpt; /* per mail */ 753 754 int refcount; 755 756 int ntask; 757 TAILQ_HEAD(, mta_task) tasks; 758 759 int nsession; 760 761 int nfail; 762 char errorline[64]; 763}; 764 765struct mta_task { 766 TAILQ_ENTRY(mta_task) entry; 767 struct mta_route *route; 768 uint32_t msgid; 769 TAILQ_HEAD(, envelope) envelopes; 770 struct mailaddr sender; 771 struct mta_session *session; 772}; 773 774/* maps return structures */ 775struct map_credentials { 776 char username[MAX_LINE_SIZE]; 777 char password[MAX_LINE_SIZE]; 778}; 779 780struct map_alias { 781 size_t nbnodes; 782 struct expandtree expandtree; 783}; 784 785struct map_virtual { 786 size_t nbnodes; 787 struct expandtree expandtree; 788}; 789 790struct map_netaddr { 791 struct netaddr netaddr; 792}; 793 794enum queue_op { 795 QOP_INVALID=0, 796 QOP_CREATE, 797 QOP_DELETE, 798 QOP_UPDATE, 799 QOP_COMMIT, 800 QOP_LOAD, 801 QOP_FD_R, 802 QOP_CORRUPT, 803}; 804 805struct queue_backend { 806 int (*init)(int); 807 int (*message)(enum queue_op, uint32_t *); 808 int (*envelope)(enum queue_op, uint64_t *, char *, size_t); 809 810 void *(*qwalk_new)(uint32_t); 811 int (*qwalk)(void *, uint64_t *); 812 void (*qwalk_close)(void *); 813}; 814 815struct compress_backend { 816 int (*compress_file)(FILE *, FILE *); 817 int (*uncompress_file)(FILE *, FILE *); 818 size_t (*compress_buffer)(char *, size_t, char *, size_t); 819 size_t (*uncompress_buffer)(char *, size_t, char *, size_t); 820}; 821 822/* auth structures */ 823enum auth_type { 824 AUTH_BSD, 825 AUTH_PWD, 826}; 827 828struct auth_backend { 829 int (*authenticate)(char *, char *); 830}; 831 832 833/* user structures */ 834enum user_type { 835 USER_PWD, 836}; 837 838#define MAXPASSWORDLEN 128 839struct mta_user { 840 char username[MAXLOGNAME]; 841 char directory[MAXPATHLEN]; 842 char password[MAXPASSWORDLEN]; 843 uid_t uid; 844 gid_t gid; 845}; 846 847struct user_backend { 848 int (*getbyname)(struct mta_user *, char *); 849}; 850 851 852/* delivery_backend */ 853struct delivery_backend { 854 void (*open)(struct deliver *); 855}; 856 857struct scheduler_info { 858 uint64_t evpid; 859 enum delivery_type type; 860 time_t creation; 861 time_t lasttry; 862 time_t expire; 863 uint8_t retry; 864}; 865 866struct id_list { 867 struct id_list *next; 868 uint64_t id; 869}; 870 871#define SCHED_NONE 0x00 872#define SCHED_DELAY 0x01 873#define SCHED_REMOVE 0x02 874#define SCHED_EXPIRE 0x04 875#define SCHED_BOUNCE 0x08 876#define SCHED_MDA 0x10 877#define SCHED_MTA 0x20 878 879struct scheduler_batch { 880 int type; 881 time_t delay; 882 struct id_list *evpids; 883}; 884 885struct scheduler_backend { 886 void (*init)(void); 887 888 void (*insert)(struct scheduler_info *); 889 void (*commit)(uint32_t); 890 void (*rollback)(uint32_t); 891 892 void (*update)(struct scheduler_info *); 893 void (*delete)(uint64_t); 894 895 void (*batch)(int, struct scheduler_batch *); 896 897 void (*schedule)(uint64_t); 898 void (*remove)(uint64_t); 899}; 900 901 902enum stat_type { 903 STAT_COUNTER, 904 STAT_TIMESTAMP, 905 STAT_TIMEVAL, 906 STAT_TIMESPEC, 907}; 908 909struct stat_value { 910 enum stat_type type; 911 union stat_v { 912 size_t counter; 913 time_t timestamp; 914 struct timeval tv; 915 struct timespec ts; 916 } u; 917}; 918 919#define STAT_KEY_SIZE 1024 920struct stat_kv { 921 void *iter; 922 char key[STAT_KEY_SIZE]; 923 struct stat_value val; 924}; 925 926struct stat_backend { 927 void (*init)(void); 928 void (*close)(void); 929 void (*increment)(const char *, size_t); 930 void (*decrement)(const char *, size_t); 931 void (*set)(const char *, const struct stat_value *); 932 int (*iter)(void **, char **, struct stat_value *); 933}; 934 935 936extern struct smtpd *env; 937extern void (*imsg_callback)(struct imsgev *, struct imsg *); 938 939 940/* aliases.c */ 941int aliases_exist(objid_t, char *); 942int aliases_get(objid_t, struct expandtree *, char *); 943int aliases_vdomain_exists(objid_t, char *); 944int aliases_virtual_exist(objid_t, struct mailaddr *); 945int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 946int alias_parse(struct expandnode *, char *); 947 948 949/* auth.c */ 950struct auth_backend *auth_backend_lookup(enum auth_type); 951 952 953/* bounce.c */ 954void bounce_add(uint64_t); 955void bounce_run(uint64_t, int); 956 957 958/* config.c */ 959#define PURGE_LISTENERS 0x01 960#define PURGE_MAPS 0x02 961#define PURGE_RULES 0x04 962#define PURGE_SSL 0x08 963#define PURGE_EVERYTHING 0xff 964void purge_config(uint8_t); 965void unconfigure(void); 966void configure(void); 967void init_pipes(void); 968void config_pipes(struct peer *, uint); 969void config_peers(struct peer *, uint); 970 971 972/* control.c */ 973pid_t control(void); 974void session_socket_blockmode(int, enum blockmodes); 975void session_socket_no_linger(int); 976int session_socket_error(int); 977 978 979/* delivery.c */ 980struct delivery_backend *delivery_backend_lookup(enum action_type); 981 982 983/* dns.c */ 984void dns_query_host(char *, int, uint64_t); 985void dns_query_mx(char *, char *, int, uint64_t); 986void dns_query_ptr(struct sockaddr_storage *, uint64_t); 987void dns_async(struct imsgev *, int, struct dns *); 988 989 990/* enqueue.c */ 991int enqueue(int, char **); 992int enqueue_offline(int, char **); 993 994 995/* envelope.c */ 996void envelope_set_errormsg(struct envelope *, char *, ...); 997char *envelope_ascii_field_name(enum envelope_field); 998int envelope_ascii_load(enum envelope_field, struct envelope *, char *); 999int envelope_ascii_dump(enum envelope_field, struct envelope *, char *, size_t); 1000int envelope_load_buffer(struct envelope *, char *, size_t); 1001int envelope_dump_buffer(struct envelope *, char *, size_t); 1002 1003/* expand.c */ 1004int expand_cmp(struct expandnode *, struct expandnode *); 1005void expandtree_increment_node(struct expandtree *, struct expandnode *); 1006void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1007void expandtree_remove_node(struct expandtree *, struct expandnode *); 1008struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1009void expandtree_free_nodes(struct expandtree *); 1010RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1011 1012 1013/* forward.c */ 1014int forwards_get(int, struct expandtree *, char *); 1015 1016 1017/* lka.c */ 1018pid_t lka(void); 1019int lka_session_cmp(struct lka_session *, struct lka_session *); 1020SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1021 1022/* lka_session.c */ 1023struct lka_session *lka_session_init(struct submit_status *); 1024void lka_session_fail(struct lka_session *); 1025void lka_session_destroy(struct lka_session *); 1026 1027 1028/* map.c */ 1029void *map_lookup(objid_t, char *, enum map_kind); 1030int map_compare(objid_t, char *, enum map_kind, int (*)(char *, char *)); 1031struct map *map_find(objid_t); 1032struct map *map_findbyname(const char *); 1033struct map *map_create(enum map_kind, const char *); 1034void map_add(struct map *, const char *, const char *); 1035 1036 1037/* mda.c */ 1038pid_t mda(void); 1039 1040 1041/* mfa.c */ 1042pid_t mfa(void); 1043int mfa_session_cmp(struct mfa_session *, struct mfa_session *); 1044SPLAY_PROTOTYPE(mfatree, mfa_session, nodes, mfa_session_cmp); 1045 1046/* mta.c */ 1047pid_t mta(void); 1048int mta_response_delivery(const char *); 1049const char *mta_response_status(const char *); 1050const char *mta_response_text(const char *); 1051void mta_route_ok(struct mta_route *); 1052void mta_route_error(struct mta_route *, const char *); 1053void mta_route_collect(struct mta_route *); 1054const char *mta_route_to_text(struct mta_route *); 1055 1056/* mta_session.c */ 1057void mta_session(struct mta_route *); 1058void mta_session_imsg(struct imsgev *, struct imsg *); 1059 1060/* parse.y */ 1061int parse_config(struct smtpd *, const char *, int); 1062int cmdline_symset(char *); 1063 1064/* queue.c */ 1065pid_t queue(void); 1066 1067/* queue_backend.c */ 1068uint32_t queue_generate_msgid(void); 1069uint64_t queue_generate_evpid(uint32_t msgid); 1070struct queue_backend *queue_backend_lookup(const char *); 1071int queue_message_incoming_path(uint32_t, char *, size_t); 1072int queue_envelope_incoming_path(uint64_t, char *, size_t); 1073int queue_message_incoming_delete(uint32_t); 1074int queue_message_create(uint32_t *); 1075int queue_message_delete(uint32_t); 1076int queue_message_commit(uint32_t); 1077int queue_message_fd_r(uint32_t); 1078int queue_message_fd_rw(uint32_t); 1079int queue_message_corrupt(uint32_t); 1080int queue_envelope_create(struct envelope *); 1081int queue_envelope_delete(struct envelope *); 1082int queue_envelope_load(uint64_t, struct envelope *); 1083int queue_envelope_update(struct envelope *); 1084void *qwalk_new(uint32_t); 1085int qwalk(void *, uint64_t *); 1086void qwalk_close(void *); 1087 1088/* compress_backend.c */ 1089struct compress_backend *compress_backend_lookup(const char *); 1090int compress_file(FILE *, FILE *); 1091int uncompress_file(FILE *, FILE *); 1092size_t compress_buffer(char *, size_t, char *, size_t); 1093size_t uncompress_buffer(char *, size_t, char *, size_t); 1094 1095/* scheduler.c */ 1096pid_t scheduler(void); 1097 1098/* scheduler_bakend.c */ 1099struct scheduler_backend *scheduler_backend_lookup(const char *); 1100void scheduler_info(struct scheduler_info *, struct envelope *); 1101time_t scheduler_compute_schedule(struct scheduler_info *); 1102 1103/* smtp.c */ 1104pid_t smtp(void); 1105void smtp_resume(void); 1106void smtp_destroy(struct session *); 1107 1108/* smtp_session.c */ 1109void session_init(struct listener *, struct session *); 1110int session_cmp(struct session *, struct session *); 1111void session_io(struct io *, int); 1112void session_pickup(struct session *, struct submit_status *); 1113void session_destroy(struct session *, const char *); 1114void session_respond(struct session *, char *, ...) 1115 __attribute__ ((format (printf, 2, 3))); 1116 1117SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1118 1119 1120/* smtpd.c */ 1121int child_cmp(struct child *, struct child *); 1122void imsg_event_add(struct imsgev *); 1123void imsg_compose_event(struct imsgev *, uint16_t, uint32_t, pid_t, 1124 int, void *, uint16_t); 1125void imsg_dispatch(int, short, void *); 1126const char * proc_to_str(int); 1127const char * imsg_to_str(int); 1128SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1129 1130 1131/* ssl.c */ 1132void ssl_init(void); 1133int ssl_load_certfile(const char *, uint8_t); 1134void ssl_setup(struct listener *); 1135void *ssl_smtp_init(void *); 1136void *ssl_mta_init(struct ssl *); 1137int ssl_cmp(struct ssl *, struct ssl *); 1138SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1139 1140 1141/* ssl_privsep.c */ 1142int ssl_ctx_use_private_key(void *, char *, off_t); 1143int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1144 1145 1146/* stat_backend.c */ 1147struct stat_backend *stat_backend_lookup(const char *); 1148void stat_increment(const char *, size_t); 1149void stat_decrement(const char *, size_t); 1150void stat_set(const char *, const struct stat_value *); 1151 1152struct stat_value *stat_counter(size_t); 1153struct stat_value *stat_timestamp(time_t); 1154struct stat_value *stat_timeval(struct timeval *); 1155struct stat_value *stat_timespec(struct timespec *); 1156 1157 1158/* tree.c */ 1159SPLAY_HEAD(tree, treeentry); 1160#define tree_init(t) SPLAY_INIT((t)) 1161#define tree_empty(t) SPLAY_EMPTY((t)) 1162int tree_check(struct tree *, uint64_t); 1163void *tree_set(struct tree *, uint64_t, void *); 1164void tree_xset(struct tree *, uint64_t, void *); 1165void *tree_get(struct tree *, uint64_t); 1166void *tree_xget(struct tree *, uint64_t); 1167void *tree_pop(struct tree *, uint64_t); 1168void *tree_xpop(struct tree *, uint64_t); 1169int tree_poproot(struct tree *, uint64_t *, void **); 1170int tree_root(struct tree *, uint64_t *, void **); 1171int tree_iter(struct tree *, void **, uint64_t *, void **); 1172void tree_merge(struct tree *, struct tree *); 1173 1174 1175/* user.c */ 1176struct user_backend *user_backend_lookup(enum user_type); 1177 1178 1179/* util.c */ 1180typedef struct arglist arglist; 1181struct arglist { 1182 char **list; 1183 uint num; 1184 uint nalloc; 1185}; 1186void addargs(arglist *, char *, ...) 1187 __attribute__((format(printf, 2, 3))); 1188int bsnprintf(char *, size_t, const char *, ...) 1189 __attribute__ ((format (printf, 3, 4))); 1190int mkdirs(char *, mode_t); 1191int safe_fclose(FILE *); 1192int hostname_match(char *, char *); 1193int email_to_mailaddr(struct mailaddr *, char *); 1194int valid_localpart(const char *); 1195int valid_domainpart(const char *); 1196char *ss_to_text(struct sockaddr_storage *); 1197char *time_to_text(time_t); 1198char *duration_to_text(time_t); 1199int secure_file(int, char *, char *, uid_t, int); 1200int lowercase(char *, char *, size_t); 1201void xlowercase(char *, char *, size_t); 1202void sa_set_port(struct sockaddr *, int); 1203uint64_t generate_uid(void); 1204void fdlimit(double); 1205int availdesc(void); 1206uint32_t evpid_to_msgid(uint64_t); 1207uint64_t msgid_to_evpid(uint32_t); 1208int ckdir(const char *, mode_t, uid_t, gid_t, int); 1209int rmtree(char *, int); 1210int mvpurge(char *, char *); 1211int mktmpfile(void); 1212const char *parse_smtp_response(char *, size_t, char **, int *); 1213int text_to_netaddr(struct netaddr *, char *); 1214int text_to_relayhost(struct relayhost *, char *); 1215void *xmalloc(size_t, const char *); 1216void *xcalloc(size_t, size_t, const char *); 1217char *xstrdup(const char *, const char *); 1218