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