smtpd.h revision 1.345
1/* $OpenBSD: smtpd.h,v 1.345 2012/09/01 16:09:14 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_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_NET, 287 C_DOM, 288 C_VDOM 289}; 290 291struct cond { 292 TAILQ_ENTRY(cond) c_entry; 293 objid_t c_map; 294 enum cond_type c_type; 295}; 296 297enum action_type { 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 309struct rule { 310 TAILQ_ENTRY(rule) r_entry; 311 char r_tag[MAX_TAG_SIZE]; 312 int r_accept; 313 struct map *r_sources; 314 struct cond r_condition; 315 enum action_type r_action; 316 union rule_dest { 317 char buffer[MAX_RULEBUFFER_LEN]; 318 struct relayhost relayhost; 319 } r_value; 320 321 char *r_user; 322 struct mailaddr *r_as; 323 objid_t r_amap; 324 time_t r_qexpire; 325}; 326 327struct mailaddr { 328 char user[MAX_LOCALPART_SIZE]; 329 char domain[MAX_DOMAINPART_SIZE]; 330}; 331 332enum delivery_type { 333 D_MDA, 334 D_MTA, 335 D_BOUNCE 336}; 337 338enum delivery_status { 339 DS_PERMFAILURE = 0x1, 340 DS_TEMPFAILURE = 0x2, 341}; 342 343enum delivery_flags { 344 DF_AUTHENTICATED = 0x1, 345 DF_ENQUEUED = 0x2, 346 DF_BOUNCE = 0x4, 347 DF_INTERNAL = 0x8 /* internal expansion forward */ 348}; 349 350union delivery_data { 351 char user[MAXLOGNAME]; 352 char buffer[MAX_RULEBUFFER_LEN]; 353 struct mailaddr mailaddr; 354}; 355 356struct delivery_mda { 357 enum action_type method; 358 union delivery_data to; 359 char as_user[MAXLOGNAME]; 360}; 361 362struct delivery_mta { 363 struct relayhost relay; 364}; 365 366enum expand_type { 367 EXPAND_INVALID, 368 EXPAND_USERNAME, 369 EXPAND_FILENAME, 370 EXPAND_FILTER, 371 EXPAND_INCLUDE, 372 EXPAND_ADDRESS 373}; 374 375enum expand_flags { 376 F_EXPAND_NONE, 377 F_EXPAND_DONE 378}; 379 380struct expandnode { 381 RB_ENTRY(expandnode) entry; 382 size_t refcnt; 383 enum expand_flags flags; 384 enum expand_type type; 385 char as_user[MAXLOGNAME]; 386 union delivery_data u; 387}; 388 389RB_HEAD(expandtree, expandnode); 390 391#define SMTPD_ENVELOPE_VERSION 1 392struct envelope { 393 TAILQ_ENTRY(envelope) entry; 394 395 char tag[MAX_TAG_SIZE]; 396 struct rule rule; 397 398 uint64_t session_id; 399 uint64_t batch_id; 400 401 uint32_t version; 402 uint64_t id; 403 enum delivery_type type; 404 405 char helo[MAXHOSTNAMELEN]; 406 char hostname[MAXHOSTNAMELEN]; 407 char errorline[MAX_LINE_SIZE + 1]; 408 struct sockaddr_storage ss; 409 410 struct mailaddr sender; 411 struct mailaddr rcpt; 412 struct mailaddr dest; 413 414 union delivery_method { 415 struct delivery_mda mda; 416 struct delivery_mta mta; 417 } agent; 418 419 time_t creation; 420 time_t lasttry; 421 time_t expire; 422 uint8_t retry; 423 enum delivery_flags flags; 424}; 425TAILQ_HEAD(deliverylist, envelope); 426 427enum envelope_field { 428 EVP_VERSION, 429 EVP_MSGID, 430 EVP_TYPE, 431 EVP_HELO, 432 EVP_HOSTNAME, 433 EVP_ERRORLINE, 434 EVP_SOCKADDR, 435 EVP_SENDER, 436 EVP_RCPT, 437 EVP_DEST, 438 EVP_CTIME, 439 EVP_EXPIRE, 440 EVP_RETRY, 441 EVP_LASTTRY, 442 EVP_FLAGS, 443 EVP_MDA_METHOD, 444 EVP_MDA_BUFFER, 445 EVP_MDA_USER, 446 EVP_MTA_RELAY_HOST, 447 EVP_MTA_RELAY_PORT, 448 EVP_MTA_RELAY_FLAGS, 449 EVP_MTA_RELAY_CERT, 450 EVP_MTA_RELAY_AUTHMAP 451}; 452 453 454enum child_type { 455 CHILD_INVALID, 456 CHILD_DAEMON, 457 CHILD_MDA, 458 CHILD_ENQUEUE_OFFLINE, 459}; 460 461struct child { 462 SPLAY_ENTRY(child) entry; 463 pid_t pid; 464 enum child_type type; 465 enum smtp_proc_type title; 466 int mda_out; 467 uint32_t mda_id; 468 char *path; 469}; 470 471enum session_state { 472 S_NEW = 0, 473 S_CONNECTED, 474 S_INIT, 475 S_GREETED, 476 S_TLS, 477 S_AUTH_INIT, 478 S_AUTH_USERNAME, 479 S_AUTH_PASSWORD, 480 S_AUTH_FINALIZE, 481 S_RSET, 482 S_HELO, 483 S_MAIL_MFA, 484 S_MAIL_QUEUE, 485 S_MAIL, 486 S_RCPT_MFA, 487 S_RCPT, 488 S_DATA, 489 S_DATA_QUEUE, 490 S_DATACONTENT, 491 S_DONE, 492 S_QUIT, 493 S_CLOSE 494}; 495#define STATE_COUNT 22 496 497struct ssl { 498 SPLAY_ENTRY(ssl) ssl_nodes; 499 char ssl_name[PATH_MAX]; 500 char *ssl_ca; 501 off_t ssl_ca_len; 502 char *ssl_cert; 503 off_t ssl_cert_len; 504 char *ssl_key; 505 off_t ssl_key_len; 506 char *ssl_dhparams; 507 off_t ssl_dhparams_len; 508 uint8_t flags; 509}; 510 511struct listener { 512 uint8_t flags; 513 int fd; 514 struct sockaddr_storage ss; 515 in_port_t port; 516 struct timeval timeout; 517 struct event ev; 518 char ssl_cert_name[PATH_MAX]; 519 struct ssl *ssl; 520 void *ssl_ctx; 521 char tag[MAX_TAG_SIZE]; 522 TAILQ_ENTRY(listener) entry; 523}; 524 525struct auth { 526 uint64_t id; 527 char user[MAXLOGNAME]; 528 char pass[MAX_LINE_SIZE + 1]; 529 int success; 530}; 531 532enum session_flags { 533 F_EHLO = 0x01, 534 F_8BITMIME = 0x02, 535 F_SECURE = 0x04, 536 F_AUTHENTICATED = 0x08, 537 F_WAITIMSG = 0x10, 538 F_ZOMBIE = 0x20, 539}; 540 541struct session { 542 SPLAY_ENTRY(session) s_nodes; 543 uint64_t s_id; 544 545 struct iobuf s_iobuf; 546 struct io s_io; 547 548 enum session_flags s_flags; 549 enum session_state s_state; 550 struct sockaddr_storage s_ss; 551 char s_hostname[MAXHOSTNAMELEN]; 552 struct event s_ev; 553 struct listener *s_l; 554 void *s_ssl; 555 struct timeval s_tv; 556 struct envelope s_msg; 557 short s_nresp[STATE_COUNT]; 558 size_t rcptcount; 559 long s_datalen; 560 561 struct auth s_auth; 562 int s_dstatus; 563 564 FILE *datafp; 565}; 566 567 568struct smtpd { 569 char sc_conffile[MAXPATHLEN]; 570 size_t sc_maxsize; 571 572#define SMTPD_OPT_VERBOSE 0x00000001 573#define SMTPD_OPT_NOACTION 0x00000002 574 uint32_t sc_opts; 575#define SMTPD_CONFIGURING 0x00000001 576#define SMTPD_EXITING 0x00000002 577#define SMTPD_MDA_PAUSED 0x00000004 578#define SMTPD_MTA_PAUSED 0x00000008 579#define SMTPD_SMTP_PAUSED 0x00000010 580#define SMTPD_MDA_BUSY 0x00000020 581#define SMTPD_MTA_BUSY 0x00000040 582#define SMTPD_BOUNCE_BUSY 0x00000080 583#define SMTPD_SMTP_DISABLED 0x00000100 584 uint32_t sc_flags; 585 uint32_t sc_queue_flags; 586#define QUEUE_COMPRESS 0x00000001 587#define QUEUE_ENCRYPT 0x00000002 588 char *sc_queue_compress_algo; 589 struct timeval sc_qintval; 590 int sc_qexpire; 591 struct event sc_ev; 592 int *sc_pipes[PROC_COUNT] 593 [PROC_COUNT]; 594 struct imsgev *sc_ievs[PROC_COUNT]; 595 int sc_instances[PROC_COUNT]; 596 int sc_instance; 597 char *sc_title[PROC_COUNT]; 598 struct passwd *sc_pw; 599 char sc_hostname[MAXHOSTNAMELEN]; 600 struct queue_backend *sc_queue; 601 struct compress_backend *sc_compress; 602 struct scheduler_backend *sc_scheduler; 603 struct stat_backend *sc_stat; 604 605 time_t sc_uptime; 606 607 TAILQ_HEAD(filterlist, filter) *sc_filters; 608 609 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 610 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 611 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 612 SPLAY_HEAD(sessiontree, session) sc_sessions; 613 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 614 SPLAY_HEAD(childtree, child) children; 615 SPLAY_HEAD(lkatree, lka_session) lka_sessions; 616 SPLAY_HEAD(mfatree, mfa_session) mfa_sessions; 617 LIST_HEAD(mdalist, mda_session) mda_sessions; 618 619 uint64_t filtermask; 620}; 621 622#define TRACE_VERBOSE 0x0001 623#define TRACE_IMSG 0x0002 624#define TRACE_IO 0x0004 625#define TRACE_SMTP 0x0008 626#define TRACE_MTA 0x0010 627#define TRACE_BOUNCE 0x0020 628#define TRACE_SCHEDULER 0x0040 629#define TRACE_STAT 0x0080 630#define TRACE_PROFILING 0x0100 631 632 633struct submit_status { 634 uint64_t id; 635 int code; 636 union submit_path { 637 struct mailaddr maddr; 638 uint32_t msgid; 639 uint64_t evpid; 640 char errormsg[MAX_LINE_SIZE + 1]; 641 char dataline[MAX_LINE_SIZE + 1]; 642 } u; 643 enum delivery_flags flags; 644 struct sockaddr_storage ss; 645 struct envelope envelope; 646}; 647 648struct forward_req { 649 uint64_t id; 650 uint8_t status; 651 char as_user[MAXLOGNAME]; 652 struct envelope envelope; 653}; 654 655enum dns_status { 656 DNS_OK = 0, 657 DNS_RETRY, 658 DNS_EINVAL, 659 DNS_ENONAME, 660 DNS_ENOTFOUND, 661}; 662 663struct dns { 664 uint64_t id; 665 char host[MAXHOSTNAMELEN]; 666 char backup[MAXHOSTNAMELEN]; 667 int port; 668 int error; 669 int type; 670 struct imsgev *asker; 671 struct sockaddr_storage ss; 672}; 673 674struct secret { 675 uint64_t id; 676 char mapname[MAX_PATH_SIZE]; 677 char host[MAXHOSTNAMELEN]; 678 char secret[MAX_LINE_SIZE]; 679}; 680 681struct mda_session { 682 LIST_ENTRY(mda_session) entry; 683 struct envelope msg; 684 struct msgbuf w; 685 struct event ev; 686 uint32_t id; 687 FILE *datafp; 688}; 689 690struct deliver { 691 char to[PATH_MAX]; 692 char from[PATH_MAX]; 693 char user[MAXLOGNAME]; 694 short mode; 695}; 696 697struct rulematch { 698 uint64_t id; 699 struct submit_status ss; 700}; 701 702enum lka_session_flags { 703 F_ERROR = 0x1 704}; 705 706struct lka_session { 707 SPLAY_ENTRY(lka_session) nodes; 708 uint64_t id; 709 710 struct deliverylist deliverylist; 711 struct expandtree expandtree; 712 713 uint8_t iterations; 714 uint32_t pending; 715 enum lka_session_flags flags; 716 struct submit_status ss; 717}; 718 719struct filter { 720 TAILQ_ENTRY(filter) f_entry; 721 pid_t pid; 722 struct event ev; 723 struct imsgbuf *ibuf; 724 char name[MAX_FILTER_NAME]; 725 char path[MAXPATHLEN]; 726}; 727 728struct mfa_session { 729 SPLAY_ENTRY(mfa_session) nodes; 730 uint64_t id; 731 732 enum session_state state; 733 struct submit_status ss; 734 struct filter *filter; 735 struct filter_msg fm; 736}; 737 738struct mta_session; 739 740struct mta_route { 741 SPLAY_ENTRY(mta_route) entry; 742 uint64_t id; 743 744 uint8_t flags; 745 char *hostname; 746 char *backupname; 747 uint16_t port; 748 char *cert; 749 char *auth; 750 void *ssl; 751 752 /* route limits */ 753 int maxconn; /* in parallel */ 754 int maxmail; /* per session */ 755 int maxrcpt; /* per mail */ 756 757 int refcount; 758 759 int ntask; 760 TAILQ_HEAD(, mta_task) tasks; 761 762 int nsession; 763 764 int nfail; 765 char errorline[64]; 766}; 767 768struct mta_task { 769 TAILQ_ENTRY(mta_task) entry; 770 struct mta_route *route; 771 uint32_t msgid; 772 TAILQ_HEAD(, envelope) envelopes; 773 struct mailaddr sender; 774 struct mta_session *session; 775}; 776 777/* maps return structures */ 778struct map_credentials { 779 char username[MAX_LINE_SIZE]; 780 char password[MAX_LINE_SIZE]; 781}; 782 783struct map_alias { 784 size_t nbnodes; 785 struct expandtree expandtree; 786}; 787 788struct map_virtual { 789 size_t nbnodes; 790 struct expandtree expandtree; 791}; 792 793struct map_netaddr { 794 struct netaddr netaddr; 795}; 796 797enum queue_op { 798 QOP_INVALID=0, 799 QOP_CREATE, 800 QOP_DELETE, 801 QOP_UPDATE, 802 QOP_COMMIT, 803 QOP_LOAD, 804 QOP_FD_R, 805 QOP_CORRUPT, 806}; 807 808struct queue_backend { 809 int (*init)(int); 810 int (*message)(enum queue_op, uint32_t *); 811 int (*envelope)(enum queue_op, uint64_t *, char *, size_t); 812 813 void *(*qwalk_new)(uint32_t); 814 int (*qwalk)(void *, uint64_t *); 815 void (*qwalk_close)(void *); 816}; 817 818struct compress_backend { 819 int (*compress_file)(FILE *, FILE *); 820 int (*uncompress_file)(FILE *, FILE *); 821 size_t (*compress_buffer)(const char *, size_t, char *, size_t); 822 size_t (*uncompress_buffer)(const char *, size_t, char *, size_t); 823}; 824 825/* auth structures */ 826enum auth_type { 827 AUTH_BSD, 828 AUTH_PWD, 829}; 830 831struct auth_backend { 832 int (*authenticate)(char *, char *); 833}; 834 835 836/* user structures */ 837enum user_type { 838 USER_PWD, 839}; 840 841#define MAXPASSWORDLEN 128 842struct mta_user { 843 char username[MAXLOGNAME]; 844 char directory[MAXPATHLEN]; 845 char password[MAXPASSWORDLEN]; 846 uid_t uid; 847 gid_t gid; 848}; 849 850struct user_backend { 851 int (*getbyname)(struct mta_user *, char *); 852}; 853 854 855/* delivery_backend */ 856struct delivery_backend { 857 void (*open)(struct deliver *); 858}; 859 860struct scheduler_info { 861 uint64_t evpid; 862 enum delivery_type type; 863 time_t creation; 864 time_t lasttry; 865 time_t expire; 866 uint8_t retry; 867}; 868 869struct id_list { 870 struct id_list *next; 871 uint64_t id; 872}; 873 874#define SCHED_NONE 0x00 875#define SCHED_DELAY 0x01 876#define SCHED_REMOVE 0x02 877#define SCHED_EXPIRE 0x04 878#define SCHED_BOUNCE 0x08 879#define SCHED_MDA 0x10 880#define SCHED_MTA 0x20 881 882struct scheduler_batch { 883 int type; 884 time_t delay; 885 struct id_list *evpids; 886}; 887 888struct scheduler_backend { 889 void (*init)(void); 890 891 void (*insert)(struct scheduler_info *); 892 void (*commit)(uint32_t); 893 void (*rollback)(uint32_t); 894 895 void (*update)(struct scheduler_info *); 896 void (*delete)(uint64_t); 897 898 void (*batch)(int, time_t, struct scheduler_batch *); 899 900 void (*schedule)(uint64_t); 901 void (*remove)(uint64_t); 902}; 903 904 905enum stat_type { 906 STAT_COUNTER, 907 STAT_TIMESTAMP, 908 STAT_TIMEVAL, 909 STAT_TIMESPEC, 910}; 911 912struct stat_value { 913 enum stat_type type; 914 union stat_v { 915 size_t counter; 916 time_t timestamp; 917 struct timeval tv; 918 struct timespec ts; 919 } u; 920}; 921 922#define STAT_KEY_SIZE 1024 923struct stat_kv { 924 void *iter; 925 char key[STAT_KEY_SIZE]; 926 struct stat_value val; 927}; 928 929struct stat_backend { 930 void (*init)(void); 931 void (*close)(void); 932 void (*increment)(const char *, size_t); 933 void (*decrement)(const char *, size_t); 934 void (*set)(const char *, const struct stat_value *); 935 int (*iter)(void **, char **, struct stat_value *); 936}; 937 938 939extern struct smtpd *env; 940extern void (*imsg_callback)(struct imsgev *, struct imsg *); 941 942 943/* aliases.c */ 944int aliases_exist(objid_t, char *); 945int aliases_get(objid_t, struct expandtree *, char *); 946int aliases_vdomain_exists(objid_t, char *); 947int aliases_virtual_exist(objid_t, struct mailaddr *); 948int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 949int alias_parse(struct expandnode *, char *); 950 951 952/* auth.c */ 953struct auth_backend *auth_backend_lookup(enum auth_type); 954 955 956/* bounce.c */ 957void bounce_add(uint64_t); 958void bounce_run(uint64_t, int); 959 960 961/* config.c */ 962#define PURGE_LISTENERS 0x01 963#define PURGE_MAPS 0x02 964#define PURGE_RULES 0x04 965#define PURGE_SSL 0x08 966#define PURGE_EVERYTHING 0xff 967void purge_config(uint8_t); 968void unconfigure(void); 969void configure(void); 970void init_pipes(void); 971void config_pipes(struct peer *, uint); 972void config_peers(struct peer *, uint); 973 974 975/* control.c */ 976pid_t control(void); 977void session_socket_blockmode(int, enum blockmodes); 978void session_socket_no_linger(int); 979int session_socket_error(int); 980 981 982/* delivery.c */ 983struct delivery_backend *delivery_backend_lookup(enum action_type); 984 985 986/* dns.c */ 987void dns_query_host(char *, int, uint64_t); 988void dns_query_mx(char *, char *, int, uint64_t); 989void dns_query_ptr(struct sockaddr_storage *, uint64_t); 990void dns_async(struct imsgev *, int, struct dns *); 991 992 993/* enqueue.c */ 994int enqueue(int, char **); 995int enqueue_offline(int, char **); 996 997 998/* envelope.c */ 999void envelope_set_errormsg(struct envelope *, char *, ...); 1000char *envelope_ascii_field_name(enum envelope_field); 1001int envelope_ascii_load(enum envelope_field, struct envelope *, char *); 1002int envelope_ascii_dump(enum envelope_field, struct envelope *, char *, size_t); 1003int envelope_load_buffer(struct envelope *, char *, size_t); 1004int envelope_dump_buffer(struct envelope *, char *, size_t); 1005 1006/* expand.c */ 1007int expand_cmp(struct expandnode *, struct expandnode *); 1008void expandtree_increment_node(struct expandtree *, struct expandnode *); 1009void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1010void expandtree_remove_node(struct expandtree *, struct expandnode *); 1011struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1012void expandtree_free_nodes(struct expandtree *); 1013RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1014 1015 1016/* forward.c */ 1017int forwards_get(int, struct expandtree *, char *); 1018 1019 1020/* lka.c */ 1021pid_t lka(void); 1022int lka_session_cmp(struct lka_session *, struct lka_session *); 1023SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1024 1025/* lka_session.c */ 1026struct lka_session *lka_session_init(struct submit_status *); 1027void lka_session_fail(struct lka_session *); 1028void lka_session_destroy(struct lka_session *); 1029 1030 1031/* map.c */ 1032void *map_lookup(objid_t, char *, enum map_kind); 1033int map_compare(objid_t, char *, enum map_kind, int (*)(char *, char *)); 1034struct map *map_find(objid_t); 1035struct map *map_findbyname(const char *); 1036 1037 1038/* mda.c */ 1039pid_t mda(void); 1040 1041 1042/* mfa.c */ 1043pid_t mfa(void); 1044int mfa_session_cmp(struct mfa_session *, struct mfa_session *); 1045SPLAY_PROTOTYPE(mfatree, mfa_session, nodes, mfa_session_cmp); 1046 1047/* mta.c */ 1048pid_t mta(void); 1049int mta_response_delivery(const char *); 1050const char *mta_response_status(const char *); 1051const char *mta_response_text(const char *); 1052void mta_route_ok(struct mta_route *); 1053void mta_route_error(struct mta_route *, const char *); 1054void mta_route_collect(struct mta_route *); 1055const char *mta_route_to_text(struct mta_route *); 1056 1057/* mta_session.c */ 1058void mta_session(struct mta_route *); 1059void mta_session_imsg(struct imsgev *, struct imsg *); 1060 1061/* parse.y */ 1062int parse_config(struct smtpd *, const char *, int); 1063int cmdline_symset(char *); 1064 1065/* queue.c */ 1066pid_t queue(void); 1067 1068/* queue_backend.c */ 1069uint32_t queue_generate_msgid(void); 1070uint64_t queue_generate_evpid(uint32_t msgid); 1071struct queue_backend *queue_backend_lookup(const char *); 1072int queue_message_incoming_path(uint32_t, char *, size_t); 1073int queue_envelope_incoming_path(uint64_t, char *, size_t); 1074int queue_message_incoming_delete(uint32_t); 1075int queue_message_create(uint32_t *); 1076int queue_message_delete(uint32_t); 1077int queue_message_commit(uint32_t); 1078int queue_message_fd_r(uint32_t); 1079int queue_message_fd_rw(uint32_t); 1080int queue_message_corrupt(uint32_t); 1081int queue_envelope_create(struct envelope *); 1082int queue_envelope_delete(struct envelope *); 1083int queue_envelope_load(uint64_t, struct envelope *); 1084int queue_envelope_update(struct envelope *); 1085void *qwalk_new(uint32_t); 1086int qwalk(void *, uint64_t *); 1087void qwalk_close(void *); 1088 1089/* compress_backend.c */ 1090struct compress_backend *compress_backend_lookup(const char *); 1091int compress_file(FILE *, FILE *); 1092int uncompress_file(FILE *, FILE *); 1093size_t compress_buffer(const char *, size_t, char *, size_t); 1094size_t uncompress_buffer(const char *, size_t, char *, size_t); 1095 1096/* scheduler.c */ 1097pid_t scheduler(void); 1098 1099/* scheduler_bakend.c */ 1100struct scheduler_backend *scheduler_backend_lookup(const char *); 1101void scheduler_info(struct scheduler_info *, struct envelope *); 1102time_t scheduler_compute_schedule(struct scheduler_info *); 1103 1104/* smtp.c */ 1105pid_t smtp(void); 1106void smtp_resume(void); 1107void smtp_destroy(struct session *); 1108 1109/* smtp_session.c */ 1110void session_init(struct listener *, struct session *); 1111int session_cmp(struct session *, struct session *); 1112void session_io(struct io *, int); 1113void session_pickup(struct session *, struct submit_status *); 1114void session_destroy(struct session *, const char *); 1115void session_respond(struct session *, char *, ...) 1116 __attribute__ ((format (printf, 2, 3))); 1117 1118SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1119 1120 1121/* smtpd.c */ 1122int child_cmp(struct child *, struct child *); 1123void imsg_event_add(struct imsgev *); 1124void imsg_compose_event(struct imsgev *, uint16_t, uint32_t, pid_t, 1125 int, void *, uint16_t); 1126void imsg_dispatch(int, short, void *); 1127const char * proc_to_str(int); 1128const char * imsg_to_str(int); 1129SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1130 1131 1132/* ssl.c */ 1133void ssl_init(void); 1134void ssl_transaction(struct session *); 1135void ssl_session_init(struct session *); 1136void ssl_session_destroy(struct session *); 1137int ssl_load_certfile(const char *, uint8_t); 1138void ssl_setup(struct listener *); 1139int ssl_cmp(struct ssl *, struct ssl *); 1140void *ssl_mta_init(struct ssl *); 1141SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1142 1143 1144/* ssl_privsep.c */ 1145int ssl_ctx_use_private_key(void *, char *, off_t); 1146int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1147 1148 1149/* stat_backend.c */ 1150struct stat_backend *stat_backend_lookup(const char *); 1151void stat_increment(const char *, size_t); 1152void stat_decrement(const char *, size_t); 1153void stat_set(const char *, const struct stat_value *); 1154 1155struct stat_value *stat_counter(size_t); 1156struct stat_value *stat_timestamp(time_t); 1157struct stat_value *stat_timeval(struct timeval *); 1158struct stat_value *stat_timespec(struct timespec *); 1159 1160 1161/* tree.c */ 1162SPLAY_HEAD(tree, treeentry); 1163#define tree_init(t) SPLAY_INIT((t)) 1164#define tree_empty(t) SPLAY_EMPTY((t)) 1165int tree_check(struct tree *, uint64_t); 1166void *tree_set(struct tree *, uint64_t, void *); 1167void tree_xset(struct tree *, uint64_t, void *); 1168void *tree_get(struct tree *, uint64_t); 1169void *tree_xget(struct tree *, uint64_t); 1170void *tree_pop(struct tree *, uint64_t); 1171void *tree_xpop(struct tree *, uint64_t); 1172int tree_poproot(struct tree *, uint64_t *, void **); 1173int tree_root(struct tree *, uint64_t *, void **); 1174int tree_iter(struct tree *, void **, uint64_t *, void **); 1175void tree_merge(struct tree *, struct tree *); 1176 1177 1178/* user.c */ 1179struct user_backend *user_backend_lookup(enum user_type); 1180 1181 1182/* util.c */ 1183typedef struct arglist arglist; 1184struct arglist { 1185 char **list; 1186 uint num; 1187 uint nalloc; 1188}; 1189void addargs(arglist *, char *, ...) 1190 __attribute__((format(printf, 2, 3))); 1191int bsnprintf(char *, size_t, const char *, ...) 1192 __attribute__ ((format (printf, 3, 4))); 1193int mkdir_p(char *, mode_t); 1194int safe_fclose(FILE *); 1195int hostname_match(char *, char *); 1196int email_to_mailaddr(struct mailaddr *, char *); 1197int valid_localpart(const char *); 1198int valid_domainpart(const char *); 1199char *ss_to_text(struct sockaddr_storage *); 1200char *time_to_text(time_t); 1201char *duration_to_text(time_t); 1202int secure_file(int, char *, char *, uid_t, int); 1203int lowercase(char *, char *, size_t); 1204void xlowercase(char *, char *, size_t); 1205void sa_set_port(struct sockaddr *, int); 1206uint64_t generate_uid(void); 1207void fdlimit(double); 1208int availdesc(void); 1209uint32_t evpid_to_msgid(uint64_t); 1210uint64_t msgid_to_evpid(uint32_t); 1211void log_imsg(int, int, struct imsg*); 1212int ckdir(const char *, mode_t, uid_t, gid_t, int); 1213int rmtree(char *, int); 1214int mvpurge(char *, char *); 1215int mktmpfile(void); 1216const char *parse_smtp_response(char *, size_t, char **, int *); 1217int text_to_netaddr(struct netaddr *, char *); 1218int text_to_relayhost(struct relayhost *, char *); 1219void *xmalloc(size_t, const char *); 1220void *xcalloc(size_t, size_t, const char *); 1221char *xstrdup(const char *, const char *); 1222