smtpd.h revision 1.435
1/* $OpenBSD: smtpd.h,v 1.435 2013/11/19 10:01:20 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 size_t sc_scheduler_max_inflight; 509 int sc_qexpire; 510#define MAX_BOUNCE_WARN 4 511 time_t sc_bounce_warn[MAX_BOUNCE_WARN]; 512 char sc_hostname[SMTPD_MAXHOSTNAMELEN]; 513 struct stat_backend *sc_stat; 514 struct compress_backend *sc_comp; 515 516 time_t sc_uptime; 517 518 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 519 520 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 521 522 struct dict *sc_ssl_dict; 523 524 struct dict *sc_tables_dict; /* keyed lookup */ 525 526 struct dict *sc_limits_dict; 527 528 struct dict sc_filters; 529 uint32_t filtermask; 530}; 531 532#define TRACE_DEBUG 0x0001 533#define TRACE_IMSG 0x0002 534#define TRACE_IO 0x0004 535#define TRACE_SMTP 0x0008 536#define TRACE_MFA 0x0010 537#define TRACE_MTA 0x0020 538#define TRACE_BOUNCE 0x0040 539#define TRACE_SCHEDULER 0x0080 540#define TRACE_LOOKUP 0x0100 541#define TRACE_STAT 0x0200 542#define TRACE_RULES 0x0400 543#define TRACE_MPROC 0x0800 544#define TRACE_EXPAND 0x1000 545#define TRACE_TABLES 0x2000 546#define TRACE_QUEUE 0x4000 547 548#define PROFILE_TOSTAT 0x0001 549#define PROFILE_IMSG 0x0002 550#define PROFILE_QUEUE 0x0004 551 552struct forward_req { 553 uint64_t id; 554 uint8_t status; 555 556 char user[SMTPD_MAXLOGNAME]; 557 uid_t uid; 558 gid_t gid; 559 char directory[SMTPD_MAXPATHLEN]; 560}; 561 562struct deliver { 563 char to[SMTPD_MAXPATHLEN]; 564 char from[SMTPD_MAXPATHLEN]; 565 char user[SMTPD_MAXLOGNAME]; 566 short mode; 567 568 struct userinfo userinfo; 569}; 570 571#define MAX_FILTER_PER_CHAIN 16 572struct filter { 573 int chain; 574 int done; 575 char name[MAX_FILTER_NAME]; 576 char path[SMTPD_MAXPATHLEN]; 577 char filters[MAX_FILTER_NAME][MAX_FILTER_PER_CHAIN]; 578}; 579 580struct mta_host { 581 SPLAY_ENTRY(mta_host) entry; 582 struct sockaddr *sa; 583 char *ptrname; 584 int refcount; 585 size_t nconn; 586 time_t lastconn; 587 time_t lastptrquery; 588 589#define HOST_IGNORE 0x01 590 int flags; 591}; 592 593struct mta_mx { 594 TAILQ_ENTRY(mta_mx) entry; 595 struct mta_host *host; 596 int preference; 597}; 598 599struct mta_domain { 600 SPLAY_ENTRY(mta_domain) entry; 601 char *name; 602 int flags; 603 TAILQ_HEAD(, mta_mx) mxs; 604 int mxstatus; 605 int refcount; 606 size_t nconn; 607 time_t lastconn; 608 time_t lastmxquery; 609}; 610 611struct mta_source { 612 SPLAY_ENTRY(mta_source) entry; 613 struct sockaddr *sa; 614 int refcount; 615 size_t nconn; 616 time_t lastconn; 617}; 618 619struct mta_connector { 620 struct mta_source *source; 621 struct mta_relay *relay; 622 623#define CONNECTOR_ERROR_FAMILY 0x0001 624#define CONNECTOR_ERROR_SOURCE 0x0002 625#define CONNECTOR_ERROR_MX 0x0004 626#define CONNECTOR_ERROR_ROUTE_NET 0x0008 627#define CONNECTOR_ERROR_ROUTE_SMTP 0x0010 628#define CONNECTOR_ERROR_ROUTE 0x0018 629#define CONNECTOR_ERROR 0x00ff 630 631#define CONNECTOR_LIMIT_HOST 0x0100 632#define CONNECTOR_LIMIT_ROUTE 0x0200 633#define CONNECTOR_LIMIT_SOURCE 0x0400 634#define CONNECTOR_LIMIT_RELAY 0x0800 635#define CONNECTOR_LIMIT_CONN 0x1000 636#define CONNECTOR_LIMIT_DOMAIN 0x2000 637#define CONNECTOR_LIMIT 0xff00 638 639#define CONNECTOR_NEW 0x10000 640#define CONNECTOR_WAIT 0x20000 641 int flags; 642 643 int refcount; 644 size_t nconn; 645 time_t lastconn; 646}; 647 648struct mta_route { 649 SPLAY_ENTRY(mta_route) entry; 650 uint64_t id; 651 struct mta_source *src; 652 struct mta_host *dst; 653#define ROUTE_NEW 0x01 654#define ROUTE_RUNQ 0x02 655#define ROUTE_KEEPALIVE 0x04 656#define ROUTE_DISABLED 0xf0 657#define ROUTE_DISABLED_NET 0x10 658#define ROUTE_DISABLED_SMTP 0x20 659 int flags; 660 int nerror; 661 int penalty; 662 int refcount; 663 size_t nconn; 664 time_t lastconn; 665 time_t lastdisc; 666 time_t lastpenalty; 667}; 668 669struct mta_limits { 670 size_t maxconn_per_host; 671 size_t maxconn_per_route; 672 size_t maxconn_per_source; 673 size_t maxconn_per_connector; 674 size_t maxconn_per_relay; 675 size_t maxconn_per_domain; 676 677 time_t conndelay_host; 678 time_t conndelay_route; 679 time_t conndelay_source; 680 time_t conndelay_connector; 681 time_t conndelay_relay; 682 time_t conndelay_domain; 683 684 time_t discdelay_route; 685 686 size_t max_mail_per_session; 687 time_t sessdelay_transaction; 688 time_t sessdelay_keepalive; 689 690 int family; 691 692 int task_hiwat; 693 int task_lowat; 694 int task_release; 695}; 696 697struct mta_relay { 698 SPLAY_ENTRY(mta_relay) entry; 699 uint64_t id; 700 701 struct mta_domain *domain; 702 struct mta_limits *limits; 703 int flags; 704 char *backupname; 705 int backuppref; 706 char *sourcetable; 707 uint16_t port; 708 char *cert; 709 char *authtable; 710 char *authlabel; 711 char *helotable; 712 char *heloname; 713 char *secret; 714 715 int state; 716 size_t ntask; 717 TAILQ_HEAD(, mta_task) tasks; 718 719 struct tree connectors; 720 size_t sourceloop; 721 time_t lastsource; 722 time_t nextsource; 723 724 int fail; 725 char *failstr; 726 727#define RELAY_WAIT_MX 0x01 728#define RELAY_WAIT_PREFERENCE 0x02 729#define RELAY_WAIT_SECRET 0x04 730#define RELAY_WAIT_LIMITS 0x08 731#define RELAY_WAIT_SOURCE 0x10 732#define RELAY_WAIT_CONNECTOR 0x20 733#define RELAY_WAITMASK 0x3f 734 int status; 735 736 int refcount; 737 size_t nconn; 738 size_t nconn_ready; 739 time_t lastconn; 740}; 741 742struct mta_envelope { 743 TAILQ_ENTRY(mta_envelope) entry; 744 uint64_t id; 745 uint64_t session; 746 time_t creation; 747 char *dest; 748 char *rcpt; 749 struct mta_task *task; 750 int delivery; 751}; 752 753struct mta_task { 754 TAILQ_ENTRY(mta_task) entry; 755 struct mta_relay *relay; 756 uint32_t msgid; 757 TAILQ_HEAD(, mta_envelope) envelopes; 758 char *sender; 759}; 760 761struct passwd; 762 763struct queue_backend { 764 int (*init)(struct passwd *, int); 765}; 766 767struct compress_backend { 768 size_t (*compress_chunk)(void *, size_t, void *, size_t); 769 size_t (*uncompress_chunk)(void *, size_t, void *, size_t); 770 int (*compress_file)(FILE *, FILE *); 771 int (*uncompress_file)(FILE *, FILE *); 772}; 773 774/* auth structures */ 775enum auth_type { 776 AUTH_BSD, 777 AUTH_PWD, 778}; 779 780struct auth_backend { 781 int (*authenticate)(char *, char *); 782}; 783 784 785/* delivery_backend */ 786struct delivery_backend { 787 int allow_root; 788 void (*open)(struct deliver *); 789}; 790 791struct scheduler_backend { 792 int (*init)(void); 793 794 int (*insert)(struct scheduler_info *); 795 size_t (*commit)(uint32_t); 796 size_t (*rollback)(uint32_t); 797 798 int (*update)(struct scheduler_info *); 799 int (*delete)(uint64_t); 800 int (*hold)(uint64_t, uint64_t); 801 int (*release)(uint64_t, int); 802 803 int (*batch)(int, struct scheduler_batch *); 804 805 size_t (*messages)(uint32_t, uint32_t *, size_t); 806 size_t (*envelopes)(uint64_t, struct evpstate *, size_t); 807 int (*schedule)(uint64_t); 808 int (*remove)(uint64_t); 809 int (*suspend)(uint64_t); 810 int (*resume)(uint64_t); 811}; 812 813enum stat_type { 814 STAT_COUNTER, 815 STAT_TIMESTAMP, 816 STAT_TIMEVAL, 817 STAT_TIMESPEC, 818}; 819 820struct stat_value { 821 enum stat_type type; 822 union stat_v { 823 size_t counter; 824 time_t timestamp; 825 struct timeval tv; 826 struct timespec ts; 827 } u; 828}; 829 830#define STAT_KEY_SIZE 1024 831struct stat_kv { 832 void *iter; 833 char key[STAT_KEY_SIZE]; 834 struct stat_value val; 835}; 836 837struct stat_backend { 838 void (*init)(void); 839 void (*close)(void); 840 void (*increment)(const char *, size_t); 841 void (*decrement)(const char *, size_t); 842 void (*set)(const char *, const struct stat_value *); 843 int (*iter)(void **, char **, struct stat_value *); 844}; 845 846struct stat_digest { 847 time_t startup; 848 time_t timestamp; 849 850 size_t clt_connect; 851 size_t clt_disconnect; 852 853 size_t evp_enqueued; 854 size_t evp_dequeued; 855 856 size_t evp_expired; 857 size_t evp_removed; 858 size_t evp_bounce; 859 860 size_t dlv_ok; 861 size_t dlv_permfail; 862 size_t dlv_tempfail; 863 size_t dlv_loop; 864}; 865 866 867struct mproc { 868 pid_t pid; 869 char *name; 870 int proc; 871 void (*handler)(struct mproc *, struct imsg *); 872 struct imsgbuf imsgbuf; 873 874 char *m_buf; 875 size_t m_alloc; 876 size_t m_pos; 877 uint32_t m_type; 878 uint32_t m_peerid; 879 pid_t m_pid; 880 int m_fd; 881 882 int enable; 883 short events; 884 struct event ev; 885 void *data; 886 887 off_t msg_in; 888 off_t msg_out; 889 off_t bytes_in; 890 off_t bytes_out; 891 size_t bytes_queued; 892 size_t bytes_queued_max; 893}; 894 895struct msg { 896 const uint8_t *pos; 897 const uint8_t *end; 898}; 899 900extern enum smtp_proc_type smtpd_process; 901 902extern int verbose; 903extern int profiling; 904 905extern struct mproc *p_control; 906extern struct mproc *p_parent; 907extern struct mproc *p_lka; 908extern struct mproc *p_mda; 909extern struct mproc *p_mfa; 910extern struct mproc *p_mta; 911extern struct mproc *p_queue; 912extern struct mproc *p_scheduler; 913extern struct mproc *p_smtp; 914 915extern struct smtpd *env; 916extern void (*imsg_callback)(struct mproc *, struct imsg *); 917 918struct imsgproc { 919 pid_t pid; 920 struct event ev; 921 struct imsgbuf *ibuf; 922 char *path; 923 char *name; 924 void (*cb)(struct imsg *, void *); 925 void *cb_arg; 926}; 927 928/* inter-process structures */ 929 930struct bounce_req_msg { 931 uint64_t evpid; 932 time_t timestamp; 933 struct delivery_bounce bounce; 934}; 935 936enum mfa_resp_status { 937 MFA_OK, 938 MFA_FAIL, 939 MFA_CLOSE, 940}; 941 942enum dns_error { 943 DNS_OK = 0, 944 DNS_RETRY, 945 DNS_EINVAL, 946 DNS_ENONAME, 947 DNS_ENOTFOUND, 948}; 949 950enum lka_resp_status { 951 LKA_OK, 952 LKA_TEMPFAIL, 953 LKA_PERMFAIL 954}; 955 956enum ca_resp_status { 957 CA_OK, 958 CA_FAIL 959}; 960 961struct ca_cert_req_msg { 962 uint64_t reqid; 963 char name[SMTPD_MAXPATHLEN]; 964}; 965 966struct ca_cert_resp_msg { 967 uint64_t reqid; 968 enum ca_resp_status status; 969 char *cert; 970 off_t cert_len; 971 char *key; 972 off_t key_len; 973}; 974 975struct ca_vrfy_req_msg { 976 uint64_t reqid; 977 char pkiname[SMTPD_MAXHOSTNAMELEN]; 978 unsigned char *cert; 979 off_t cert_len; 980 size_t n_chain; 981 size_t chain_offset; 982 unsigned char **chain_cert; 983 off_t *chain_cert_len; 984}; 985 986struct ca_vrfy_resp_msg { 987 uint64_t reqid; 988 enum ca_resp_status status; 989}; 990 991 992/* aliases.c */ 993int aliases_get(struct expand *, const char *); 994int aliases_virtual_check(struct table *, const struct mailaddr *); 995int aliases_virtual_get(struct expand *, const struct mailaddr *); 996int alias_parse(struct expandnode *, const char *); 997 998 999/* auth.c */ 1000struct auth_backend *auth_backend_lookup(enum auth_type); 1001 1002 1003/* bounce.c */ 1004void bounce_add(uint64_t); 1005void bounce_fd(int); 1006 1007 1008/* ca.c */ 1009int ca_X509_verify(void *, void *, const char *, const char *, const char **); 1010 1011 1012/* compress_backend.c */ 1013struct compress_backend *compress_backend_lookup(const char *); 1014size_t compress_chunk(void *, size_t, void *, size_t); 1015size_t uncompress_chunk(void *, size_t, void *, size_t); 1016int compress_file(FILE *, FILE *); 1017int uncompress_file(FILE *, FILE *); 1018 1019/* config.c */ 1020#define PURGE_LISTENERS 0x01 1021#define PURGE_TABLES 0x02 1022#define PURGE_RULES 0x04 1023#define PURGE_SSL 0x08 1024#define PURGE_EVERYTHING 0xff 1025void purge_config(uint8_t); 1026void init_pipes(void); 1027void config_process(enum smtp_proc_type); 1028void config_peer(enum smtp_proc_type); 1029void config_done(void); 1030 1031 1032/* control.c */ 1033pid_t control(void); 1034int control_create_socket(void); 1035 1036 1037/* crypto.c */ 1038int crypto_setup(const char *, size_t); 1039int crypto_encrypt_file(FILE *, FILE *); 1040int crypto_decrypt_file(FILE *, FILE *); 1041size_t crypto_encrypt_buffer(const char *, size_t, char *, size_t); 1042size_t crypto_decrypt_buffer(const char *, size_t, char *, size_t); 1043 1044 1045/* delivery.c */ 1046struct delivery_backend *delivery_backend_lookup(enum action_type); 1047 1048 1049/* dns.c */ 1050void dns_query_host(uint64_t, const char *); 1051void dns_query_ptr(uint64_t, const struct sockaddr *); 1052void dns_query_mx(uint64_t, const char *); 1053void dns_query_mx_preference(uint64_t, const char *, const char *); 1054void dns_imsg(struct mproc *, struct imsg *); 1055 1056 1057/* enqueue.c */ 1058int enqueue(int, char **); 1059 1060 1061/* envelope.c */ 1062void envelope_set_errormsg(struct envelope *, char *, ...); 1063int envelope_load_buffer(struct envelope *, const char *, size_t); 1064int envelope_dump_buffer(const struct envelope *, char *, size_t); 1065 1066 1067/* expand.c */ 1068int expand_cmp(struct expandnode *, struct expandnode *); 1069void expand_insert(struct expand *, struct expandnode *); 1070struct expandnode *expand_lookup(struct expand *, struct expandnode *); 1071void expand_clear(struct expand *); 1072void expand_free(struct expand *); 1073int expand_line(struct expand *, const char *, int); 1074int expand_to_text(struct expand *, char *, size_t); 1075RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1076 1077 1078/* forward.c */ 1079int forwards_get(int, struct expand *); 1080 1081 1082/* imsgproc.c */ 1083void imsgproc_init(void); 1084struct imsgproc *imsgproc_fork(const char *, const char *, 1085 void (*)(struct imsg *, void *), void *); 1086void imsgproc_set_read(struct imsgproc *); 1087void imsgproc_set_write(struct imsgproc *); 1088void imsgproc_set_read_write(struct imsgproc *); 1089void imsgproc_reset_callback(struct imsgproc *, void (*)(struct imsg *, void *), void *); 1090 1091/* limit.c */ 1092void limit_mta_set_defaults(struct mta_limits *); 1093int limit_mta_set(struct mta_limits *, const char*, int64_t); 1094 1095/* lka.c */ 1096pid_t lka(void); 1097 1098 1099/* lka_session.c */ 1100void lka_session(uint64_t, struct envelope *); 1101void lka_session_forward_reply(struct forward_req *, int); 1102 1103 1104/* log.c */ 1105void vlog(int, const char *, va_list); 1106 1107 1108/* mda.c */ 1109pid_t mda(void); 1110 1111 1112/* mfa.c */ 1113pid_t mfa(void); 1114void mfa_ready(void); 1115 1116/* mfa_session.c */ 1117void mfa_filter_prepare(void); 1118void mfa_filter_init(void); 1119void mfa_filter_connect(uint64_t, const struct sockaddr *, 1120 const struct sockaddr *, const char *); 1121void mfa_filter_mailaddr(uint64_t, int, const struct mailaddr *); 1122void mfa_filter_line(uint64_t, int, const char *); 1123void mfa_filter_eom(uint64_t, int, size_t); 1124void mfa_filter(uint64_t, int); 1125void mfa_filter_event(uint64_t, int); 1126void mfa_build_fd_chain(uint64_t, int); 1127 1128/* mproc.c */ 1129int mproc_fork(struct mproc *, const char*, const char *); 1130void mproc_init(struct mproc *, int); 1131void mproc_clear(struct mproc *); 1132void mproc_enable(struct mproc *); 1133void mproc_disable(struct mproc *); 1134void m_compose(struct mproc *, uint32_t, uint32_t, pid_t, int, void *, size_t); 1135void m_composev(struct mproc *, uint32_t, uint32_t, pid_t, int, 1136 const struct iovec *, int); 1137void m_forward(struct mproc *, struct imsg *); 1138void m_create(struct mproc *, uint32_t, uint32_t, pid_t, int); 1139void m_add(struct mproc *, const void *, size_t); 1140void m_add_int(struct mproc *, int); 1141void m_add_u32(struct mproc *, uint32_t); 1142void m_add_time(struct mproc *, time_t); 1143void m_add_string(struct mproc *, const char *); 1144void m_add_data(struct mproc *, const void *, size_t); 1145void m_add_evpid(struct mproc *, uint64_t); 1146void m_add_msgid(struct mproc *, uint32_t); 1147void m_add_id(struct mproc *, uint64_t); 1148void m_add_sockaddr(struct mproc *, const struct sockaddr *); 1149void m_add_mailaddr(struct mproc *, const struct mailaddr *); 1150void m_add_envelope(struct mproc *, const struct envelope *); 1151void m_close(struct mproc *); 1152 1153void m_msg(struct msg *, struct imsg *); 1154int m_is_eom(struct msg *); 1155void m_end(struct msg *); 1156void m_get_int(struct msg *, int *); 1157void m_get_u32(struct msg *, uint32_t *); 1158void m_get_time(struct msg *, time_t *); 1159void m_get_string(struct msg *, const char **); 1160void m_get_data(struct msg *, const void **, size_t *); 1161void m_get_evpid(struct msg *, uint64_t *); 1162void m_get_msgid(struct msg *, uint32_t *); 1163void m_get_id(struct msg *, uint64_t *); 1164void m_get_sockaddr(struct msg *, struct sockaddr *); 1165void m_get_mailaddr(struct msg *, struct mailaddr *); 1166void m_get_envelope(struct msg *, struct envelope *); 1167 1168 1169/* mta.c */ 1170pid_t mta(void); 1171void mta_route_ok(struct mta_relay *, struct mta_route *); 1172void mta_route_error(struct mta_relay *, struct mta_route *); 1173void mta_route_down(struct mta_relay *, struct mta_route *); 1174void mta_route_collect(struct mta_relay *, struct mta_route *); 1175void mta_source_error(struct mta_relay *, struct mta_route *, const char *); 1176void mta_delivery_log(struct mta_envelope *, const char *, const char *, int, const char *); 1177void mta_delivery_notify(struct mta_envelope *, int, const char *, uint32_t); 1178void mta_delivery(struct mta_envelope *, const char *, const char *, int, const char *, uint32_t); 1179struct mta_task *mta_route_next_task(struct mta_relay *, struct mta_route *); 1180const char *mta_host_to_text(struct mta_host *); 1181const char *mta_relay_to_text(struct mta_relay *); 1182 1183/* mta_session.c */ 1184void mta_session(struct mta_relay *, struct mta_route *); 1185void mta_session_imsg(struct mproc *, struct imsg *); 1186 1187 1188/* parse.y */ 1189int parse_config(struct smtpd *, const char *, int); 1190int cmdline_symset(char *); 1191 1192 1193/* queue.c */ 1194pid_t queue(void); 1195void queue_ok(uint64_t); 1196void queue_tempfail(uint64_t, uint32_t, const char *); 1197void queue_permfail(uint64_t, const char *); 1198void queue_loop(uint64_t); 1199void queue_flow_control(void); 1200 1201 1202/* queue_backend.c */ 1203uint32_t queue_generate_msgid(void); 1204uint64_t queue_generate_evpid(uint32_t); 1205int queue_init(const char *, int); 1206int queue_message_create(uint32_t *); 1207int queue_message_delete(uint32_t); 1208int queue_message_commit(uint32_t); 1209int queue_message_fd_r(uint32_t); 1210int queue_message_fd_rw(uint32_t); 1211int queue_message_corrupt(uint32_t); 1212int queue_envelope_create(struct envelope *); 1213int queue_envelope_delete(uint64_t); 1214int queue_envelope_load(uint64_t, struct envelope *); 1215int queue_envelope_update(struct envelope *); 1216int queue_envelope_walk(struct envelope *); 1217 1218 1219/* ruleset.c */ 1220struct rule *ruleset_match(const struct envelope *); 1221 1222 1223/* scheduler.c */ 1224pid_t scheduler(void); 1225 1226 1227/* scheduler_bakend.c */ 1228struct scheduler_backend *scheduler_backend_lookup(const char *); 1229void scheduler_info(struct scheduler_info *, struct envelope *, uint32_t); 1230time_t scheduler_compute_schedule(struct scheduler_info *); 1231 1232 1233/* smtp.c */ 1234pid_t smtp(void); 1235void smtp_collect(void); 1236 1237 1238/* smtp_session.c */ 1239int smtp_session(struct listener *, int, const struct sockaddr_storage *, 1240 const char *); 1241void smtp_session_imsg(struct mproc *, struct imsg *); 1242 1243 1244/* smtpd.c */ 1245void imsg_dispatch(struct mproc *, struct imsg *); 1246void post_fork(int); 1247const char *proc_name(enum smtp_proc_type); 1248const char *proc_title(enum smtp_proc_type); 1249const char *imsg_to_str(int); 1250 1251 1252/* ssl_smtpd.c */ 1253void *ssl_mta_init(char *, off_t, char *, off_t); 1254void *ssl_smtp_init(void *, char *, off_t, char *, off_t); 1255 1256 1257/* stat_backend.c */ 1258struct stat_backend *stat_backend_lookup(const char *); 1259void stat_increment(const char *, size_t); 1260void stat_decrement(const char *, size_t); 1261void stat_set(const char *, const struct stat_value *); 1262struct stat_value *stat_counter(size_t); 1263struct stat_value *stat_timestamp(time_t); 1264struct stat_value *stat_timeval(struct timeval *); 1265struct stat_value *stat_timespec(struct timespec *); 1266 1267 1268/* table.c */ 1269struct table *table_find(const char *, const char *); 1270struct table *table_create(const char *, const char *, const char *, 1271 const char *); 1272int table_config(struct table *); 1273int table_open(struct table *); 1274int table_update(struct table *); 1275void table_close(struct table *); 1276int table_check_use(struct table *, uint32_t, uint32_t); 1277int table_check_type(struct table *, uint32_t); 1278int table_check_service(struct table *, uint32_t); 1279int table_lookup(struct table *, const char *, enum table_service, 1280 union lookup *); 1281int table_fetch(struct table *, enum table_service, union lookup *); 1282void table_destroy(struct table *); 1283void table_add(struct table *, const char *, const char *); 1284void table_delete(struct table *, const char *); 1285int table_domain_match(const char *, const char *); 1286int table_netaddr_match(const char *, const char *); 1287int table_mailaddr_match(const char *, const char *); 1288void table_open_all(void); 1289void table_dump_all(void); 1290void table_close_all(void); 1291const void *table_get(struct table *, const char *); 1292int table_parse_lookup(enum table_service, const char *, const char *, 1293 union lookup *); 1294 1295 1296/* to.c */ 1297int email_to_mailaddr(struct mailaddr *, char *); 1298int text_to_netaddr(struct netaddr *, const char *); 1299int text_to_mailaddr(struct mailaddr *, const char *); 1300int text_to_relayhost(struct relayhost *, const char *); 1301int text_to_userinfo(struct userinfo *, const char *); 1302int text_to_credentials(struct credentials *, const char *); 1303int text_to_expandnode(struct expandnode *, const char *); 1304uint64_t text_to_evpid(const char *); 1305uint32_t text_to_msgid(const char *); 1306const char *sa_to_text(const struct sockaddr *); 1307const char *ss_to_text(const struct sockaddr_storage *); 1308const char *time_to_text(time_t); 1309const char *duration_to_text(time_t); 1310const char *relayhost_to_text(const struct relayhost *); 1311const char *rule_to_text(struct rule *); 1312const char *sockaddr_to_text(struct sockaddr *); 1313const char *mailaddr_to_text(const struct mailaddr *); 1314const char *expandnode_to_text(struct expandnode *); 1315 1316/* util.c */ 1317typedef struct arglist arglist; 1318struct arglist { 1319 char **list; 1320 uint num; 1321 uint nalloc; 1322}; 1323void addargs(arglist *, char *, ...) 1324 __attribute__((format(printf, 2, 3))); 1325int bsnprintf(char *, size_t, const char *, ...) 1326 __attribute__((format (printf, 3, 4))); 1327int mkdirs(char *, mode_t); 1328int safe_fclose(FILE *); 1329int hostname_match(const char *, const char *); 1330int valid_localpart(const char *); 1331int valid_domainpart(const char *); 1332int secure_file(int, char *, char *, uid_t, int); 1333int lowercase(char *, const char *, size_t); 1334void xlowercase(char *, const char *, size_t); 1335int uppercase(char *, const char *, size_t); 1336uint64_t generate_uid(void); 1337void fdlimit(double); 1338int availdesc(void); 1339int ckdir(const char *, mode_t, uid_t, gid_t, int); 1340int rmtree(char *, int); 1341int mvpurge(char *, char *); 1342int mktmpfile(void); 1343const char *parse_smtp_response(char *, size_t, char **, int *); 1344void *xmalloc(size_t, const char *); 1345void *xcalloc(size_t, size_t, const char *); 1346char *xstrdup(const char *, const char *); 1347void *xmemdup(const void *, size_t, const char *); 1348char *strip(char *); 1349void iobuf_xinit(struct iobuf *, size_t, size_t, const char *); 1350void iobuf_xfqueue(struct iobuf *, const char *, const char *, ...); 1351void log_envelope(const struct envelope *, const char *, const char *, 1352 const char *); 1353void session_socket_blockmode(int, enum blockmodes); 1354void session_socket_no_linger(int); 1355int session_socket_error(int); 1356int getmailname(char *, size_t); 1357 1358 1359/* waitq.c */ 1360int waitq_wait(void *, void (*)(void *, void *, void *), void *); 1361void waitq_run(void *, void *); 1362 1363/* runq.c */ 1364struct runq; 1365 1366int runq_init(struct runq **, void (*)(struct runq *, void *)); 1367int runq_schedule(struct runq *, time_t, void (*)(struct runq *, void *), void *); 1368int runq_delay(struct runq *, unsigned int, void (*)(struct runq *, void *), void *); 1369int runq_cancel(struct runq *, void (*)(struct runq *, void *), void *); 1370int runq_pending(struct runq *, void (*)(struct runq *, void *), void *, time_t *); 1371int runq_next(struct runq *, void (**)(struct runq *, void *), void **, time_t *); 1372