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