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