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