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