smtpd.h revision 1.440
1/* $OpenBSD: smtpd.h,v 1.440 2013/12/05 10:06:32 eric Exp $ */ 2 3/* 4 * Copyright (c) 2008 Gilles Chehade <gilles@poolp.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 "smtpd-defines.h" 26#include "smtpd-api.h" 27#include "ioev.h" 28#include "iobuf.h" 29 30#define CONF_FILE "/etc/mail/smtpd.conf" 31#define MAILNAME_FILE "/etc/mail/mailname" 32#define CA_FILE "/etc/ssl/cert.pem" 33 34#define PROC_COUNT 10 35 36#define MAX_HOPS_COUNT 100 37#define DEFAULT_MAX_BODY_SIZE (35*1024*1024) 38#define MAX_TAG_SIZE 32 39#define MAX_FILTER_NAME 32 40 41#define EXPAND_BUFFER 1024 42 43#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 44#define SMTPD_SOCKET "/var/run/smtpd.sock" 45#ifndef SMTPD_NAME 46#define SMTPD_NAME "OpenSMTPD" 47#endif 48#define SMTPD_VERSION "5.4" 49#define SMTPD_BANNER "220 %s ESMTP %s" 50#define SMTPD_SESSION_TIMEOUT 300 51#define SMTPD_BACKLOG 5 52 53#define PATH_SMTPCTL "/usr/sbin/smtpctl" 54 55#define PATH_OFFLINE "/offline" 56#define PATH_PURGE "/purge" 57#define PATH_TEMPORARY "/temporary" 58 59#define PATH_FILTERS "/usr/libexec/smtpd" 60#define PATH_TABLES "/usr/libexec/smtpd" 61 62#define F_STARTTLS 0x01 63#define F_SMTPS 0x02 64#define F_TLS_OPTIONAL 0x04 65#define F_SSL (F_STARTTLS | F_SMTPS) 66#define F_AUTH 0x08 67#define F_BACKUP 0x10 /* XXX - MUST BE SYNC-ED WITH RELAY_BACKUP */ 68#define F_STARTTLS_REQUIRE 0x20 69#define F_AUTH_REQUIRE 0x40 70#define F_LMTP 0x80 71#define F_MASK_SOURCE 0x100 72#define F_TLS_VERIFY 0x200 73 74/* must match F_* for mta */ 75#define RELAY_STARTTLS 0x01 76#define RELAY_SMTPS 0x02 77#define RELAY_TLS_OPTIONAL 0x04 78#define RELAY_SSL (RELAY_STARTTLS | RELAY_SMTPS) 79#define RELAY_AUTH 0x08 80#define RELAY_BACKUP 0x10 /* XXX - MUST BE SYNC-ED WITH F_BACKUP */ 81#define RELAY_MX 0x20 82#define RELAY_LMTP 0x80 83#define RELAY_TLS_VERIFY 0x200 84 85struct userinfo { 86 char username[SMTPD_MAXLOGNAME]; 87 char directory[SMTPD_MAXPATHLEN]; 88 uid_t uid; 89 gid_t gid; 90}; 91 92struct netaddr { 93 struct sockaddr_storage ss; 94 int bits; 95}; 96 97struct relayhost { 98 uint16_t flags; 99 char hostname[SMTPD_MAXHOSTNAMELEN]; 100 uint16_t port; 101 char cert[SMTPD_MAXPATHLEN]; 102 char authtable[SMTPD_MAXPATHLEN]; 103 char authlabel[SMTPD_MAXPATHLEN]; 104 char sourcetable[SMTPD_MAXPATHLEN]; 105 char heloname[SMTPD_MAXHOSTNAMELEN]; 106 char helotable[SMTPD_MAXPATHLEN]; 107}; 108 109struct credentials { 110 char username[SMTPD_MAXLINESIZE]; 111 char password[SMTPD_MAXLINESIZE]; 112}; 113 114struct destination { 115 char name[SMTPD_MAXHOSTNAMELEN]; 116}; 117 118struct source { 119 struct sockaddr_storage addr; 120}; 121 122struct addrname { 123 struct sockaddr_storage addr; 124 char name[SMTPD_MAXHOSTNAMELEN]; 125}; 126 127union lookup { 128 struct expand *expand; 129 struct credentials creds; 130 struct netaddr netaddr; 131 struct source source; 132 struct destination domain; 133 struct userinfo userinfo; 134 struct mailaddr mailaddr; 135 struct addrname addrname; 136}; 137 138/* 139 * Bump IMSG_VERSION whenever a change is made to enum imsg_type. 140 * This will ensure that we can never use a wrong version of smtpctl with smtpd. 141 */ 142#define IMSG_VERSION 7 143 144enum imsg_type { 145 IMSG_NONE, 146 IMSG_CTL_OK, /* answer to smtpctl requests */ 147 IMSG_CTL_FAIL, 148 IMSG_CTL_SHUTDOWN, 149 IMSG_CTL_VERBOSE, 150 IMSG_CTL_PAUSE_EVP, 151 IMSG_CTL_PAUSE_MDA, 152 IMSG_CTL_PAUSE_MTA, 153 IMSG_CTL_PAUSE_SMTP, 154 IMSG_CTL_RESUME_EVP, 155 IMSG_CTL_RESUME_MDA, 156 IMSG_CTL_RESUME_MTA, 157 IMSG_CTL_RESUME_SMTP, 158 IMSG_CTL_RESUME_ROUTE, 159 IMSG_CTL_LIST_MESSAGES, 160 IMSG_CTL_LIST_ENVELOPES, 161 IMSG_CTL_REMOVE, 162 IMSG_CTL_SCHEDULE, 163 164 IMSG_CTL_TRACE, 165 IMSG_CTL_UNTRACE, 166 IMSG_CTL_PROFILE, 167 IMSG_CTL_UNPROFILE, 168 169 IMSG_CTL_MTA_SHOW_HOSTS, 170 IMSG_CTL_MTA_SHOW_RELAYS, 171 IMSG_CTL_MTA_SHOW_ROUTES, 172 IMSG_CTL_MTA_SHOW_HOSTSTATS, 173 174 IMSG_CONF_START, 175 IMSG_CONF_SSL, 176 IMSG_CONF_LISTENER, 177 IMSG_CONF_TABLE, 178 IMSG_CONF_TABLE_CONTENT, 179 IMSG_CONF_RULE, 180 IMSG_CONF_RULE_SOURCE, 181 IMSG_CONF_RULE_SENDER, 182 IMSG_CONF_RULE_DESTINATION, 183 IMSG_CONF_RULE_RECIPIENT, 184 IMSG_CONF_RULE_MAPPING, 185 IMSG_CONF_RULE_USERS, 186 IMSG_CONF_FILTER, 187 IMSG_CONF_END, 188 189 IMSG_LKA_UPDATE_TABLE, 190 IMSG_LKA_EXPAND_RCPT, 191 IMSG_LKA_SECRET, 192 IMSG_LKA_SOURCE, 193 IMSG_LKA_HELO, 194 IMSG_LKA_USERINFO, 195 IMSG_LKA_AUTHENTICATE, 196 IMSG_LKA_SSL_INIT, 197 IMSG_LKA_SSL_VERIFY_CERT, 198 IMSG_LKA_SSL_VERIFY_CHAIN, 199 IMSG_LKA_SSL_VERIFY, 200 201 IMSG_DELIVERY_OK, 202 IMSG_DELIVERY_TEMPFAIL, 203 IMSG_DELIVERY_PERMFAIL, 204 IMSG_DELIVERY_LOOP, 205 IMSG_DELIVERY_HOLD, 206 IMSG_DELIVERY_RELEASE, 207 208 IMSG_BOUNCE_INJECT, 209 210 IMSG_MDA_DELIVER, 211 IMSG_MDA_DONE, 212 213 IMSG_MFA_REQ_CONNECT, 214 IMSG_MFA_REQ_HELO, 215 IMSG_MFA_REQ_MAIL, 216 IMSG_MFA_REQ_RCPT, 217 IMSG_MFA_REQ_DATA, 218 IMSG_MFA_REQ_EOM, 219 IMSG_MFA_EVENT_RSET, 220 IMSG_MFA_EVENT_COMMIT, 221 IMSG_MFA_EVENT_ROLLBACK, 222 IMSG_MFA_EVENT_DISCONNECT, 223 IMSG_MFA_SMTP_RESPONSE, 224 225 IMSG_MTA_TRANSFER, 226 IMSG_MTA_SCHEDULE, 227 228 IMSG_QUEUE_CREATE_MESSAGE, 229 IMSG_QUEUE_SUBMIT_ENVELOPE, 230 IMSG_QUEUE_COMMIT_ENVELOPES, 231 IMSG_QUEUE_REMOVE_MESSAGE, 232 IMSG_QUEUE_COMMIT_MESSAGE, 233 IMSG_QUEUE_MESSAGE_FD, 234 IMSG_QUEUE_MESSAGE_FILE, 235 IMSG_QUEUE_REMOVE, 236 IMSG_QUEUE_EXPIRE, 237 IMSG_QUEUE_BOUNCE, 238 239 IMSG_PARENT_FORWARD_OPEN, 240 IMSG_PARENT_FORK_MDA, 241 IMSG_PARENT_KILL_MDA, 242 243 IMSG_SMTP_ENQUEUE_FD, 244 245 IMSG_DNS_HOST, 246 IMSG_DNS_HOST_END, 247 IMSG_DNS_PTR, 248 IMSG_DNS_MX, 249 IMSG_DNS_MX_PREFERENCE, 250 251 IMSG_STAT_INCREMENT, 252 IMSG_STAT_DECREMENT, 253 IMSG_STAT_SET, 254 255 IMSG_DIGEST, 256 IMSG_STATS, 257 IMSG_STATS_GET, 258}; 259 260enum blockmodes { 261 BM_NORMAL, 262 BM_NONBLOCK 263}; 264 265enum smtp_proc_type { 266 PROC_PARENT = 0, 267 PROC_SMTP, 268 PROC_MFA, 269 PROC_LKA, 270 PROC_QUEUE, 271 PROC_MDA, 272 PROC_MTA, 273 PROC_CONTROL, 274 PROC_SCHEDULER, 275 276 PROC_FILTER, 277 PROC_CLIENT, 278}; 279 280enum table_type { 281 T_NONE = 0, 282 T_DYNAMIC = 0x01, /* table with external source */ 283 T_LIST = 0x02, /* table holding a list */ 284 T_HASH = 0x04, /* table holding a hash table */ 285}; 286 287struct table { 288 char t_name[SMTPD_MAXLINESIZE]; 289 enum table_type t_type; 290 char t_config[SMTPD_MAXPATHLEN]; 291 292 struct dict t_dict; 293 294 void *t_handle; 295 struct table_backend *t_backend; 296 void *t_iter; 297}; 298 299struct table_backend { 300 const unsigned int services; 301 int (*config)(struct table *); 302 void *(*open)(struct table *); 303 int (*update)(struct table *); 304 void (*close)(void *); 305 int (*lookup)(void *, const char *, enum table_service, union lookup *); 306 int (*fetch)(void *, enum table_service, union lookup *); 307}; 308 309 310enum dest_type { 311 DEST_DOM, 312 DEST_VDOM 313}; 314 315enum action_type { 316 A_NONE, 317 A_RELAY, 318 A_RELAYVIA, 319 A_MAILDIR, 320 A_MBOX, 321 A_FILENAME, 322 A_MDA, 323 A_LMTP 324}; 325 326enum decision { 327 R_REJECT, 328 R_ACCEPT 329}; 330 331struct rule { 332 TAILQ_ENTRY(rule) r_entry; 333 enum decision r_decision; 334 uint8_t r_nottag; 335 char r_tag[MAX_TAG_SIZE]; 336 337 uint8_t r_notsources; 338 struct table *r_sources; 339 340 uint8_t r_notsenders; 341 struct table *r_senders; 342 343 uint8_t r_notrecipients; 344 struct table *r_recipients; 345 346 uint8_t r_notdestination; 347 enum dest_type r_desttype; 348 struct table *r_destination; 349 350 enum action_type r_action; 351 union rule_dest { 352 char buffer[EXPAND_BUFFER]; 353 struct relayhost relayhost; 354 } r_value; 355 356 struct mailaddr *r_as; 357 struct table *r_mapping; 358 struct table *r_userbase; 359 time_t r_qexpire; 360 uint8_t r_forwardonly; 361}; 362 363struct delivery_mda { 364 enum action_type method; 365 char usertable[SMTPD_MAXPATHLEN]; 366 char username[SMTPD_MAXLOGNAME]; 367 char buffer[EXPAND_BUFFER]; 368}; 369 370struct delivery_mta { 371 struct relayhost relay; 372}; 373 374enum bounce_type { 375 B_ERROR, 376 B_WARNING, 377}; 378 379struct delivery_bounce { 380 enum bounce_type type; 381 time_t delay; 382 time_t expire; 383}; 384 385enum expand_type { 386 EXPAND_INVALID, 387 EXPAND_USERNAME, 388 EXPAND_FILENAME, 389 EXPAND_FILTER, 390 EXPAND_INCLUDE, 391 EXPAND_ADDRESS, 392 EXPAND_ERROR 393}; 394 395struct expandnode { 396 RB_ENTRY(expandnode) entry; 397 TAILQ_ENTRY(expandnode) tq_entry; 398 enum expand_type type; 399 int sameuser; 400 int alias; 401 struct rule *rule; 402 struct expandnode *parent; 403 unsigned int depth; 404 struct table *mapping; 405 struct table *userbase; 406 union { 407 /* 408 * user field handles both expansion user and system user 409 * so we MUST make it large enough to fit a mailaddr user 410 */ 411 char user[SMTPD_MAXLOCALPARTSIZE]; 412 char buffer[EXPAND_BUFFER]; 413 struct mailaddr mailaddr; 414 } u; 415}; 416 417struct expand { 418 RB_HEAD(expandtree, expandnode) tree; 419 TAILQ_HEAD(xnodes, expandnode) *queue; 420 int alias; 421 size_t nb_nodes; 422 struct rule *rule; 423 struct expandnode *parent; 424}; 425 426#define SMTPD_ENVELOPE_VERSION 2 427struct envelope { 428 TAILQ_ENTRY(envelope) entry; 429 430 char tag[MAX_TAG_SIZE]; 431 432 uint32_t version; 433 uint64_t id; 434 enum envelope_flags flags; 435 436 char smtpname[SMTPD_MAXHOSTNAMELEN]; 437 char helo[SMTPD_MAXHOSTNAMELEN]; 438 char hostname[SMTPD_MAXHOSTNAMELEN]; 439 char errorline[SMTPD_MAXLINESIZE]; 440 struct sockaddr_storage ss; 441 442 struct mailaddr sender; 443 struct mailaddr rcpt; 444 struct mailaddr dest; 445 446 enum delivery_type type; 447 union { 448 struct delivery_mda mda; 449 struct delivery_mta mta; 450 struct delivery_bounce bounce; 451 } agent; 452 453 uint16_t retry; 454 time_t creation; 455 time_t expire; 456 time_t lasttry; 457 time_t nexttry; 458 time_t lastbounce; 459}; 460 461struct listener { 462 uint16_t flags; 463 int fd; 464 struct sockaddr_storage ss; 465 in_port_t port; 466 struct timeval timeout; 467 struct event ev; 468 char ssl_cert_name[SMTPD_MAXPATHLEN]; 469 struct ssl *ssl; 470 void *ssl_ctx; 471 char tag[MAX_TAG_SIZE]; 472 char authtable[SMTPD_MAXLINESIZE]; 473 char hostname[SMTPD_MAXHOSTNAMELEN]; 474 char hostnametable[SMTPD_MAXPATHLEN]; 475 TAILQ_ENTRY(listener) entry; 476}; 477 478struct smtpd { 479 char sc_conffile[SMTPD_MAXPATHLEN]; 480 size_t sc_maxsize; 481 482#define SMTPD_OPT_VERBOSE 0x00000001 483#define SMTPD_OPT_NOACTION 0x00000002 484 uint32_t sc_opts; 485 486#define SMTPD_CONFIGURING 0x00000001 487#define SMTPD_EXITING 0x00000002 488#define SMTPD_MDA_PAUSED 0x00000004 489#define SMTPD_MTA_PAUSED 0x00000008 490#define SMTPD_SMTP_PAUSED 0x00000010 491#define SMTPD_MDA_BUSY 0x00000020 492#define SMTPD_MTA_BUSY 0x00000040 493#define SMTPD_BOUNCE_BUSY 0x00000080 494#define SMTPD_SMTP_DISABLED 0x00000100 495 uint32_t sc_flags; 496 497#define QUEUE_COMPRESSION 0x00000001 498#define QUEUE_ENCRYPTION 0x00000002 499#define QUEUE_EVPCACHE 0x00000004 500 uint32_t sc_queue_flags; 501 char *sc_queue_key; 502 size_t sc_queue_evpcache_size; 503 504 size_t sc_mda_max_session; 505 size_t sc_mda_max_user_session; 506 size_t sc_mda_task_hiwat; 507 size_t sc_mda_task_lowat; 508 size_t sc_mda_task_release; 509 510 size_t sc_mta_max_deferred; 511 512 size_t sc_scheduler_max_inflight; 513 size_t sc_scheduler_max_evp_batch_size; 514 size_t sc_scheduler_max_msg_batch_size; 515 size_t sc_scheduler_max_schedule; 516 517 int sc_qexpire; 518#define MAX_BOUNCE_WARN 4 519 time_t sc_bounce_warn[MAX_BOUNCE_WARN]; 520 char sc_hostname[SMTPD_MAXHOSTNAMELEN]; 521 struct stat_backend *sc_stat; 522 struct compress_backend *sc_comp; 523 524 time_t sc_uptime; 525 526 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 527 528 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 529 530 struct dict *sc_ssl_dict; 531 532 struct dict *sc_tables_dict; /* keyed lookup */ 533 534 struct dict *sc_limits_dict; 535 536 struct dict sc_filters; 537 uint32_t filtermask; 538}; 539 540#define TRACE_DEBUG 0x0001 541#define TRACE_IMSG 0x0002 542#define TRACE_IO 0x0004 543#define TRACE_SMTP 0x0008 544#define TRACE_MFA 0x0010 545#define TRACE_MTA 0x0020 546#define TRACE_BOUNCE 0x0040 547#define TRACE_SCHEDULER 0x0080 548#define TRACE_LOOKUP 0x0100 549#define TRACE_STAT 0x0200 550#define TRACE_RULES 0x0400 551#define TRACE_MPROC 0x0800 552#define TRACE_EXPAND 0x1000 553#define TRACE_TABLES 0x2000 554#define TRACE_QUEUE 0x4000 555 556#define PROFILE_TOSTAT 0x0001 557#define PROFILE_IMSG 0x0002 558#define PROFILE_QUEUE 0x0004 559 560struct forward_req { 561 uint64_t id; 562 uint8_t status; 563 564 char user[SMTPD_MAXLOGNAME]; 565 uid_t uid; 566 gid_t gid; 567 char directory[SMTPD_MAXPATHLEN]; 568}; 569 570struct deliver { 571 char to[SMTPD_MAXPATHLEN]; 572 char from[SMTPD_MAXPATHLEN]; 573 char user[SMTPD_MAXLOGNAME]; 574 short mode; 575 576 struct userinfo userinfo; 577}; 578 579#define MAX_FILTER_PER_CHAIN 16 580struct filter { 581 int chain; 582 int done; 583 char name[MAX_FILTER_NAME]; 584 char path[SMTPD_MAXPATHLEN]; 585 char filters[MAX_FILTER_NAME][MAX_FILTER_PER_CHAIN]; 586}; 587 588struct mta_host { 589 SPLAY_ENTRY(mta_host) entry; 590 struct sockaddr *sa; 591 char *ptrname; 592 int refcount; 593 size_t nconn; 594 time_t lastconn; 595 time_t lastptrquery; 596 597#define HOST_IGNORE 0x01 598 int flags; 599}; 600 601struct mta_mx { 602 TAILQ_ENTRY(mta_mx) entry; 603 struct mta_host *host; 604 int preference; 605}; 606 607struct mta_domain { 608 SPLAY_ENTRY(mta_domain) entry; 609 char *name; 610 int flags; 611 TAILQ_HEAD(, mta_mx) mxs; 612 int mxstatus; 613 int refcount; 614 size_t nconn; 615 time_t lastconn; 616 time_t lastmxquery; 617}; 618 619struct mta_source { 620 SPLAY_ENTRY(mta_source) entry; 621 struct sockaddr *sa; 622 int refcount; 623 size_t nconn; 624 time_t lastconn; 625}; 626 627struct mta_connector { 628 struct mta_source *source; 629 struct mta_relay *relay; 630 631#define CONNECTOR_ERROR_FAMILY 0x0001 632#define CONNECTOR_ERROR_SOURCE 0x0002 633#define CONNECTOR_ERROR_MX 0x0004 634#define CONNECTOR_ERROR_ROUTE_NET 0x0008 635#define CONNECTOR_ERROR_ROUTE_SMTP 0x0010 636#define CONNECTOR_ERROR_ROUTE 0x0018 637#define CONNECTOR_ERROR 0x00ff 638 639#define CONNECTOR_LIMIT_HOST 0x0100 640#define CONNECTOR_LIMIT_ROUTE 0x0200 641#define CONNECTOR_LIMIT_SOURCE 0x0400 642#define CONNECTOR_LIMIT_RELAY 0x0800 643#define CONNECTOR_LIMIT_CONN 0x1000 644#define CONNECTOR_LIMIT_DOMAIN 0x2000 645#define CONNECTOR_LIMIT 0xff00 646 647#define CONNECTOR_NEW 0x10000 648#define CONNECTOR_WAIT 0x20000 649 int flags; 650 651 int refcount; 652 size_t nconn; 653 time_t lastconn; 654}; 655 656struct mta_route { 657 SPLAY_ENTRY(mta_route) entry; 658 uint64_t id; 659 struct mta_source *src; 660 struct mta_host *dst; 661#define ROUTE_NEW 0x01 662#define ROUTE_RUNQ 0x02 663#define ROUTE_KEEPALIVE 0x04 664#define ROUTE_DISABLED 0xf0 665#define ROUTE_DISABLED_NET 0x10 666#define ROUTE_DISABLED_SMTP 0x20 667 int flags; 668 int nerror; 669 int penalty; 670 int refcount; 671 size_t nconn; 672 time_t lastconn; 673 time_t lastdisc; 674 time_t lastpenalty; 675}; 676 677struct mta_limits { 678 size_t maxconn_per_host; 679 size_t maxconn_per_route; 680 size_t maxconn_per_source; 681 size_t maxconn_per_connector; 682 size_t maxconn_per_relay; 683 size_t maxconn_per_domain; 684 685 time_t conndelay_host; 686 time_t conndelay_route; 687 time_t conndelay_source; 688 time_t conndelay_connector; 689 time_t conndelay_relay; 690 time_t conndelay_domain; 691 692 time_t discdelay_route; 693 694 size_t max_mail_per_session; 695 time_t sessdelay_transaction; 696 time_t sessdelay_keepalive; 697 698 int family; 699 700 int task_hiwat; 701 int task_lowat; 702 int task_release; 703}; 704 705struct mta_relay { 706 SPLAY_ENTRY(mta_relay) entry; 707 uint64_t id; 708 709 struct mta_domain *domain; 710 struct mta_limits *limits; 711 int flags; 712 char *backupname; 713 int backuppref; 714 char *sourcetable; 715 uint16_t port; 716 char *cert; 717 char *authtable; 718 char *authlabel; 719 char *helotable; 720 char *heloname; 721 char *secret; 722 723 int state; 724 size_t ntask; 725 TAILQ_HEAD(, mta_task) tasks; 726 727 struct tree connectors; 728 size_t sourceloop; 729 time_t lastsource; 730 time_t nextsource; 731 732 int fail; 733 char *failstr; 734 735#define RELAY_WAIT_MX 0x01 736#define RELAY_WAIT_PREFERENCE 0x02 737#define RELAY_WAIT_SECRET 0x04 738#define RELAY_WAIT_LIMITS 0x08 739#define RELAY_WAIT_SOURCE 0x10 740#define RELAY_WAIT_CONNECTOR 0x20 741#define RELAY_WAITMASK 0x3f 742 int status; 743 744 int refcount; 745 size_t nconn; 746 size_t nconn_ready; 747 time_t lastconn; 748}; 749 750struct mta_envelope { 751 TAILQ_ENTRY(mta_envelope) entry; 752 uint64_t id; 753 uint64_t session; 754 time_t creation; 755 char *dest; 756 char *rcpt; 757 struct mta_task *task; 758 int delivery; 759 int penalty; 760 char status[SMTPD_MAXLINESIZE]; 761}; 762 763struct mta_task { 764 TAILQ_ENTRY(mta_task) entry; 765 struct mta_relay *relay; 766 uint32_t msgid; 767 TAILQ_HEAD(, mta_envelope) envelopes; 768 char *sender; 769}; 770 771struct passwd; 772 773struct queue_backend { 774 int (*init)(struct passwd *, int); 775}; 776 777struct compress_backend { 778 size_t (*compress_chunk)(void *, size_t, void *, size_t); 779 size_t (*uncompress_chunk)(void *, size_t, void *, size_t); 780 int (*compress_file)(FILE *, FILE *); 781 int (*uncompress_file)(FILE *, FILE *); 782}; 783 784/* auth structures */ 785enum auth_type { 786 AUTH_BSD, 787 AUTH_PWD, 788}; 789 790struct auth_backend { 791 int (*authenticate)(char *, char *); 792}; 793 794 795/* delivery_backend */ 796struct delivery_backend { 797 int allow_root; 798 void (*open)(struct deliver *); 799}; 800 801struct scheduler_backend { 802 int (*init)(void); 803 804 int (*insert)(struct scheduler_info *); 805 size_t (*commit)(uint32_t); 806 size_t (*rollback)(uint32_t); 807 808 int (*update)(struct scheduler_info *); 809 int (*delete)(uint64_t); 810 int (*hold)(uint64_t, uint64_t); 811 int (*release)(int, uint64_t, int); 812 813 int (*batch)(int, struct scheduler_batch *); 814 815 size_t (*messages)(uint32_t, uint32_t *, size_t); 816 size_t (*envelopes)(uint64_t, struct evpstate *, size_t); 817 int (*schedule)(uint64_t); 818 int (*remove)(uint64_t); 819 int (*suspend)(uint64_t); 820 int (*resume)(uint64_t); 821}; 822 823enum stat_type { 824 STAT_COUNTER, 825 STAT_TIMESTAMP, 826 STAT_TIMEVAL, 827 STAT_TIMESPEC, 828}; 829 830struct stat_value { 831 enum stat_type type; 832 union stat_v { 833 size_t counter; 834 time_t timestamp; 835 struct timeval tv; 836 struct timespec ts; 837 } u; 838}; 839 840#define STAT_KEY_SIZE 1024 841struct stat_kv { 842 void *iter; 843 char key[STAT_KEY_SIZE]; 844 struct stat_value val; 845}; 846 847struct stat_backend { 848 void (*init)(void); 849 void (*close)(void); 850 void (*increment)(const char *, size_t); 851 void (*decrement)(const char *, size_t); 852 void (*set)(const char *, const struct stat_value *); 853 int (*iter)(void **, char **, struct stat_value *); 854}; 855 856struct stat_digest { 857 time_t startup; 858 time_t timestamp; 859 860 size_t clt_connect; 861 size_t clt_disconnect; 862 863 size_t evp_enqueued; 864 size_t evp_dequeued; 865 866 size_t evp_expired; 867 size_t evp_removed; 868 size_t evp_bounce; 869 870 size_t dlv_ok; 871 size_t dlv_permfail; 872 size_t dlv_tempfail; 873 size_t dlv_loop; 874}; 875 876 877struct mproc { 878 pid_t pid; 879 char *name; 880 int proc; 881 void (*handler)(struct mproc *, struct imsg *); 882 struct imsgbuf imsgbuf; 883 884 char *m_buf; 885 size_t m_alloc; 886 size_t m_pos; 887 uint32_t m_type; 888 uint32_t m_peerid; 889 pid_t m_pid; 890 int m_fd; 891 892 int enable; 893 short events; 894 struct event ev; 895 void *data; 896 897 off_t msg_in; 898 off_t msg_out; 899 off_t bytes_in; 900 off_t bytes_out; 901 size_t bytes_queued; 902 size_t bytes_queued_max; 903}; 904 905struct msg { 906 const uint8_t *pos; 907 const uint8_t *end; 908}; 909 910extern enum smtp_proc_type smtpd_process; 911 912extern int verbose; 913extern int profiling; 914 915extern struct mproc *p_control; 916extern struct mproc *p_parent; 917extern struct mproc *p_lka; 918extern struct mproc *p_mda; 919extern struct mproc *p_mfa; 920extern struct mproc *p_mta; 921extern struct mproc *p_queue; 922extern struct mproc *p_scheduler; 923extern struct mproc *p_smtp; 924 925extern struct smtpd *env; 926extern void (*imsg_callback)(struct mproc *, struct imsg *); 927 928struct imsgproc { 929 pid_t pid; 930 struct event ev; 931 struct imsgbuf *ibuf; 932 char *path; 933 char *name; 934 void (*cb)(struct imsg *, void *); 935 void *cb_arg; 936}; 937 938/* inter-process structures */ 939 940struct bounce_req_msg { 941 uint64_t evpid; 942 time_t timestamp; 943 struct delivery_bounce bounce; 944}; 945 946enum mfa_resp_status { 947 MFA_OK, 948 MFA_FAIL, 949 MFA_CLOSE, 950}; 951 952enum dns_error { 953 DNS_OK = 0, 954 DNS_RETRY, 955 DNS_EINVAL, 956 DNS_ENONAME, 957 DNS_ENOTFOUND, 958}; 959 960enum lka_resp_status { 961 LKA_OK, 962 LKA_TEMPFAIL, 963 LKA_PERMFAIL 964}; 965 966enum ca_resp_status { 967 CA_OK, 968 CA_FAIL 969}; 970 971struct ca_cert_req_msg { 972 uint64_t reqid; 973 char name[SMTPD_MAXPATHLEN]; 974}; 975 976struct ca_cert_resp_msg { 977 uint64_t reqid; 978 enum ca_resp_status status; 979 char *cert; 980 off_t cert_len; 981 char *key; 982 off_t key_len; 983}; 984 985struct ca_vrfy_req_msg { 986 uint64_t reqid; 987 char pkiname[SMTPD_MAXHOSTNAMELEN]; 988 unsigned char *cert; 989 off_t cert_len; 990 size_t n_chain; 991 size_t chain_offset; 992 unsigned char **chain_cert; 993 off_t *chain_cert_len; 994}; 995 996struct ca_vrfy_resp_msg { 997 uint64_t reqid; 998 enum ca_resp_status status; 999}; 1000 1001 1002/* aliases.c */ 1003int aliases_get(struct expand *, const char *); 1004int aliases_virtual_check(struct table *, const struct mailaddr *); 1005int aliases_virtual_get(struct expand *, const struct mailaddr *); 1006int alias_parse(struct expandnode *, const char *); 1007 1008 1009/* auth.c */ 1010struct auth_backend *auth_backend_lookup(enum auth_type); 1011 1012 1013/* bounce.c */ 1014void bounce_add(uint64_t); 1015void bounce_fd(int); 1016 1017 1018/* ca.c */ 1019int ca_X509_verify(void *, void *, const char *, const char *, const char **); 1020 1021 1022/* compress_backend.c */ 1023struct compress_backend *compress_backend_lookup(const char *); 1024size_t compress_chunk(void *, size_t, void *, size_t); 1025size_t uncompress_chunk(void *, size_t, void *, size_t); 1026int compress_file(FILE *, FILE *); 1027int uncompress_file(FILE *, FILE *); 1028 1029/* config.c */ 1030#define PURGE_LISTENERS 0x01 1031#define PURGE_TABLES 0x02 1032#define PURGE_RULES 0x04 1033#define PURGE_SSL 0x08 1034#define PURGE_EVERYTHING 0xff 1035void purge_config(uint8_t); 1036void init_pipes(void); 1037void config_process(enum smtp_proc_type); 1038void config_peer(enum smtp_proc_type); 1039void config_done(void); 1040 1041 1042/* control.c */ 1043pid_t control(void); 1044int control_create_socket(void); 1045 1046 1047/* crypto.c */ 1048int crypto_setup(const char *, size_t); 1049int crypto_encrypt_file(FILE *, FILE *); 1050int crypto_decrypt_file(FILE *, FILE *); 1051size_t crypto_encrypt_buffer(const char *, size_t, char *, size_t); 1052size_t crypto_decrypt_buffer(const char *, size_t, char *, size_t); 1053 1054 1055/* delivery.c */ 1056struct delivery_backend *delivery_backend_lookup(enum action_type); 1057 1058 1059/* dns.c */ 1060void dns_query_host(uint64_t, const char *); 1061void dns_query_ptr(uint64_t, const struct sockaddr *); 1062void dns_query_mx(uint64_t, const char *); 1063void dns_query_mx_preference(uint64_t, const char *, const char *); 1064void dns_imsg(struct mproc *, struct imsg *); 1065 1066 1067/* enqueue.c */ 1068int enqueue(int, char **); 1069 1070 1071/* envelope.c */ 1072void envelope_set_errormsg(struct envelope *, char *, ...); 1073int envelope_load_buffer(struct envelope *, const char *, size_t); 1074int envelope_dump_buffer(const struct envelope *, char *, size_t); 1075 1076 1077/* expand.c */ 1078int expand_cmp(struct expandnode *, struct expandnode *); 1079void expand_insert(struct expand *, struct expandnode *); 1080struct expandnode *expand_lookup(struct expand *, struct expandnode *); 1081void expand_clear(struct expand *); 1082void expand_free(struct expand *); 1083int expand_line(struct expand *, const char *, int); 1084int expand_to_text(struct expand *, char *, size_t); 1085RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1086 1087 1088/* forward.c */ 1089int forwards_get(int, struct expand *); 1090 1091 1092/* imsgproc.c */ 1093void imsgproc_init(void); 1094struct imsgproc *imsgproc_fork(const char *, const char *, 1095 void (*)(struct imsg *, void *), void *); 1096void imsgproc_set_read(struct imsgproc *); 1097void imsgproc_set_write(struct imsgproc *); 1098void imsgproc_set_read_write(struct imsgproc *); 1099void imsgproc_reset_callback(struct imsgproc *, void (*)(struct imsg *, void *), void *); 1100 1101/* limit.c */ 1102void limit_mta_set_defaults(struct mta_limits *); 1103int limit_mta_set(struct mta_limits *, const char*, int64_t); 1104 1105/* lka.c */ 1106pid_t lka(void); 1107 1108 1109/* lka_session.c */ 1110void lka_session(uint64_t, struct envelope *); 1111void lka_session_forward_reply(struct forward_req *, int); 1112 1113 1114/* log.c */ 1115void vlog(int, const char *, va_list); 1116 1117 1118/* mda.c */ 1119pid_t mda(void); 1120 1121 1122/* mfa.c */ 1123pid_t mfa(void); 1124void mfa_ready(void); 1125 1126/* mfa_session.c */ 1127void mfa_filter_prepare(void); 1128void mfa_filter_init(void); 1129void mfa_filter_connect(uint64_t, const struct sockaddr *, 1130 const struct sockaddr *, const char *); 1131void mfa_filter_mailaddr(uint64_t, int, const struct mailaddr *); 1132void mfa_filter_line(uint64_t, int, const char *); 1133void mfa_filter_eom(uint64_t, int, size_t); 1134void mfa_filter(uint64_t, int); 1135void mfa_filter_event(uint64_t, int); 1136void mfa_build_fd_chain(uint64_t, int); 1137 1138/* mproc.c */ 1139int mproc_fork(struct mproc *, const char*, const char *); 1140void mproc_init(struct mproc *, int); 1141void mproc_clear(struct mproc *); 1142void mproc_enable(struct mproc *); 1143void mproc_disable(struct mproc *); 1144void m_compose(struct mproc *, uint32_t, uint32_t, pid_t, int, void *, size_t); 1145void m_composev(struct mproc *, uint32_t, uint32_t, pid_t, int, 1146 const struct iovec *, int); 1147void m_forward(struct mproc *, struct imsg *); 1148void m_create(struct mproc *, uint32_t, uint32_t, pid_t, int); 1149void m_add(struct mproc *, const void *, size_t); 1150void m_add_int(struct mproc *, int); 1151void m_add_u32(struct mproc *, uint32_t); 1152void m_add_time(struct mproc *, time_t); 1153void m_add_string(struct mproc *, const char *); 1154void m_add_data(struct mproc *, const void *, size_t); 1155void m_add_evpid(struct mproc *, uint64_t); 1156void m_add_msgid(struct mproc *, uint32_t); 1157void m_add_id(struct mproc *, uint64_t); 1158void m_add_sockaddr(struct mproc *, const struct sockaddr *); 1159void m_add_mailaddr(struct mproc *, const struct mailaddr *); 1160void m_add_envelope(struct mproc *, const struct envelope *); 1161void m_close(struct mproc *); 1162 1163void m_msg(struct msg *, struct imsg *); 1164int m_is_eom(struct msg *); 1165void m_end(struct msg *); 1166void m_get_int(struct msg *, int *); 1167void m_get_u32(struct msg *, uint32_t *); 1168void m_get_time(struct msg *, time_t *); 1169void m_get_string(struct msg *, const char **); 1170void m_get_data(struct msg *, const void **, size_t *); 1171void m_get_evpid(struct msg *, uint64_t *); 1172void m_get_msgid(struct msg *, uint32_t *); 1173void m_get_id(struct msg *, uint64_t *); 1174void m_get_sockaddr(struct msg *, struct sockaddr *); 1175void m_get_mailaddr(struct msg *, struct mailaddr *); 1176void m_get_envelope(struct msg *, struct envelope *); 1177 1178 1179/* mta.c */ 1180pid_t mta(void); 1181void mta_route_ok(struct mta_relay *, struct mta_route *); 1182void mta_route_error(struct mta_relay *, struct mta_route *); 1183void mta_route_down(struct mta_relay *, struct mta_route *); 1184void mta_route_collect(struct mta_relay *, struct mta_route *); 1185void mta_source_error(struct mta_relay *, struct mta_route *, const char *); 1186void mta_delivery_log(struct mta_envelope *, const char *, const char *, int, const char *); 1187void mta_delivery_notify(struct mta_envelope *, uint32_t); 1188struct mta_task *mta_route_next_task(struct mta_relay *, struct mta_route *); 1189const char *mta_host_to_text(struct mta_host *); 1190const char *mta_relay_to_text(struct mta_relay *); 1191 1192/* mta_session.c */ 1193void mta_session(struct mta_relay *, struct mta_route *); 1194void mta_session_imsg(struct mproc *, struct imsg *); 1195 1196 1197/* parse.y */ 1198int parse_config(struct smtpd *, const char *, int); 1199int cmdline_symset(char *); 1200 1201 1202/* queue.c */ 1203pid_t queue(void); 1204void queue_ok(uint64_t); 1205void queue_tempfail(uint64_t, uint32_t, const char *); 1206void queue_permfail(uint64_t, const char *); 1207void queue_loop(uint64_t); 1208void queue_flow_control(void); 1209 1210 1211/* queue_backend.c */ 1212uint32_t queue_generate_msgid(void); 1213uint64_t queue_generate_evpid(uint32_t); 1214int queue_init(const char *, int); 1215int queue_message_create(uint32_t *); 1216int queue_message_delete(uint32_t); 1217int queue_message_commit(uint32_t); 1218int queue_message_fd_r(uint32_t); 1219int queue_message_fd_rw(uint32_t); 1220int queue_message_corrupt(uint32_t); 1221int queue_envelope_create(struct envelope *); 1222int queue_envelope_delete(uint64_t); 1223int queue_envelope_load(uint64_t, struct envelope *); 1224int queue_envelope_update(struct envelope *); 1225int queue_envelope_walk(struct envelope *); 1226 1227 1228/* ruleset.c */ 1229struct rule *ruleset_match(const struct envelope *); 1230 1231 1232/* scheduler.c */ 1233pid_t scheduler(void); 1234 1235 1236/* scheduler_bakend.c */ 1237struct scheduler_backend *scheduler_backend_lookup(const char *); 1238void scheduler_info(struct scheduler_info *, struct envelope *, uint32_t); 1239time_t scheduler_compute_schedule(struct scheduler_info *); 1240 1241 1242/* smtp.c */ 1243pid_t smtp(void); 1244void smtp_collect(void); 1245 1246 1247/* smtp_session.c */ 1248int smtp_session(struct listener *, int, const struct sockaddr_storage *, 1249 const char *); 1250void smtp_session_imsg(struct mproc *, struct imsg *); 1251 1252 1253/* smtpd.c */ 1254void imsg_dispatch(struct mproc *, struct imsg *); 1255void post_fork(int); 1256const char *proc_name(enum smtp_proc_type); 1257const char *proc_title(enum smtp_proc_type); 1258const char *imsg_to_str(int); 1259 1260 1261/* ssl_smtpd.c */ 1262void *ssl_mta_init(char *, off_t, char *, off_t); 1263void *ssl_smtp_init(void *, char *, off_t, char *, off_t); 1264 1265 1266/* stat_backend.c */ 1267struct stat_backend *stat_backend_lookup(const char *); 1268void stat_increment(const char *, size_t); 1269void stat_decrement(const char *, size_t); 1270void stat_set(const char *, const struct stat_value *); 1271struct stat_value *stat_counter(size_t); 1272struct stat_value *stat_timestamp(time_t); 1273struct stat_value *stat_timeval(struct timeval *); 1274struct stat_value *stat_timespec(struct timespec *); 1275 1276 1277/* table.c */ 1278struct table *table_find(const char *, const char *); 1279struct table *table_create(const char *, const char *, const char *, 1280 const char *); 1281int table_config(struct table *); 1282int table_open(struct table *); 1283int table_update(struct table *); 1284void table_close(struct table *); 1285int table_check_use(struct table *, uint32_t, uint32_t); 1286int table_check_type(struct table *, uint32_t); 1287int table_check_service(struct table *, uint32_t); 1288int table_lookup(struct table *, const char *, enum table_service, 1289 union lookup *); 1290int table_fetch(struct table *, enum table_service, union lookup *); 1291void table_destroy(struct table *); 1292void table_add(struct table *, const char *, const char *); 1293void table_delete(struct table *, const char *); 1294int table_domain_match(const char *, const char *); 1295int table_netaddr_match(const char *, const char *); 1296int table_mailaddr_match(const char *, const char *); 1297void table_open_all(void); 1298void table_dump_all(void); 1299void table_close_all(void); 1300const void *table_get(struct table *, const char *); 1301int table_parse_lookup(enum table_service, const char *, const char *, 1302 union lookup *); 1303 1304 1305/* to.c */ 1306int email_to_mailaddr(struct mailaddr *, char *); 1307int text_to_netaddr(struct netaddr *, const char *); 1308int text_to_mailaddr(struct mailaddr *, const char *); 1309int text_to_relayhost(struct relayhost *, const char *); 1310int text_to_userinfo(struct userinfo *, const char *); 1311int text_to_credentials(struct credentials *, const char *); 1312int text_to_expandnode(struct expandnode *, const char *); 1313uint64_t text_to_evpid(const char *); 1314uint32_t text_to_msgid(const char *); 1315const char *sa_to_text(const struct sockaddr *); 1316const char *ss_to_text(const struct sockaddr_storage *); 1317const char *time_to_text(time_t); 1318const char *duration_to_text(time_t); 1319const char *relayhost_to_text(const struct relayhost *); 1320const char *rule_to_text(struct rule *); 1321const char *sockaddr_to_text(struct sockaddr *); 1322const char *mailaddr_to_text(const struct mailaddr *); 1323const char *expandnode_to_text(struct expandnode *); 1324 1325/* util.c */ 1326typedef struct arglist arglist; 1327struct arglist { 1328 char **list; 1329 uint num; 1330 uint nalloc; 1331}; 1332void addargs(arglist *, char *, ...) 1333 __attribute__((format(printf, 2, 3))); 1334int bsnprintf(char *, size_t, const char *, ...) 1335 __attribute__((format (printf, 3, 4))); 1336int mkdirs(char *, mode_t); 1337int safe_fclose(FILE *); 1338int hostname_match(const char *, const char *); 1339int valid_localpart(const char *); 1340int valid_domainpart(const char *); 1341int secure_file(int, char *, char *, uid_t, int); 1342int lowercase(char *, const char *, size_t); 1343void xlowercase(char *, const char *, size_t); 1344int uppercase(char *, const char *, size_t); 1345uint64_t generate_uid(void); 1346void fdlimit(double); 1347int availdesc(void); 1348int ckdir(const char *, mode_t, uid_t, gid_t, int); 1349int rmtree(char *, int); 1350int mvpurge(char *, char *); 1351int mktmpfile(void); 1352const char *parse_smtp_response(char *, size_t, char **, int *); 1353void *xmalloc(size_t, const char *); 1354void *xcalloc(size_t, size_t, const char *); 1355char *xstrdup(const char *, const char *); 1356void *xmemdup(const void *, size_t, const char *); 1357char *strip(char *); 1358void iobuf_xinit(struct iobuf *, size_t, size_t, const char *); 1359void iobuf_xfqueue(struct iobuf *, const char *, const char *, ...); 1360void log_envelope(const struct envelope *, const char *, const char *, 1361 const char *); 1362void session_socket_blockmode(int, enum blockmodes); 1363void session_socket_no_linger(int); 1364int session_socket_error(int); 1365int getmailname(char *, size_t); 1366 1367 1368/* waitq.c */ 1369int waitq_wait(void *, void (*)(void *, void *, void *), void *); 1370void waitq_run(void *, void *); 1371 1372/* runq.c */ 1373struct runq; 1374 1375int runq_init(struct runq **, void (*)(struct runq *, void *)); 1376int runq_schedule(struct runq *, time_t, void (*)(struct runq *, void *), void *); 1377int runq_delay(struct runq *, unsigned int, void (*)(struct runq *, void *), void *); 1378int runq_cancel(struct runq *, void (*)(struct runq *, void *), void *); 1379int runq_pending(struct runq *, void (*)(struct runq *, void *), void *, time_t *); 1380int runq_next(struct runq *, void (**)(struct runq *, void *), void **, time_t *); 1381