smtpd.h revision 1.574
1/* $OpenBSD: smtpd.h,v 1.574 2018/11/29 12:48:16 gilles 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 <netinet/in.h> 26#include <netdb.h> 27#include <event.h> 28 29#include "smtpd-defines.h" 30#include "smtpd-api.h" 31#include "ioev.h" 32 33#define CHECK_IMSG_DATA_SIZE(imsg, expected_sz) do { \ 34 if ((imsg)->hdr.len - IMSG_HEADER_SIZE != (expected_sz)) \ 35 fatalx("smtpd: imsg %d: data size expected %zd got %zd",\ 36 (imsg)->hdr.type, \ 37 (expected_sz), (imsg)->hdr.len - IMSG_HEADER_SIZE); \ 38} while (0) 39 40#define CONF_FILE "/etc/mail/smtpd.conf" 41#define MAILNAME_FILE "/etc/mail/mailname" 42#define CA_FILE "/etc/ssl/cert.pem" 43 44#define PROC_COUNT 7 45 46#define MAX_HOPS_COUNT 100 47#define DEFAULT_MAX_BODY_SIZE (35*1024*1024) 48 49#define EXPAND_BUFFER 1024 50 51#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 52#define SMTPD_SOCKET "/var/run/smtpd.sock" 53#define SMTPD_NAME "OpenSMTPD" 54#define SMTPD_VERSION "6.4.0" 55#define SMTPD_SESSION_TIMEOUT 300 56#define SMTPD_BACKLOG 5 57 58#define PATH_SMTPCTL "/usr/sbin/smtpctl" 59 60#define PATH_OFFLINE "/offline" 61#define PATH_PURGE "/purge" 62#define PATH_TEMPORARY "/temporary" 63 64#define PATH_LIBEXEC "/usr/local/libexec/smtpd" 65 66 67/* 68 * RFC 5322 defines these characters as valid, some of them are 69 * potentially dangerous and need to be escaped. 70 */ 71#define MAILADDR_ALLOWED "!#$%&'*/?^`{|}~+-=_" 72#define MAILADDR_ESCAPE "!#$%&'*/?^`{|}~" 73 74 75#define F_STARTTLS 0x01 76#define F_SMTPS 0x02 77#define F_SSL (F_STARTTLS | F_SMTPS) 78#define F_AUTH 0x08 79#define F_STARTTLS_REQUIRE 0x20 80#define F_AUTH_REQUIRE 0x40 81#define F_MASK_SOURCE 0x100 82#define F_TLS_VERIFY 0x200 83#define F_EXT_DSN 0x400 84#define F_RECEIVEDAUTH 0x800 85#define F_MASQUERADE 0x1000 86#define F_FILTERED 0x2000 87 88#define RELAY_TLS_OPPORTUNISTIC 0 89#define RELAY_TLS_STARTTLS 1 90#define RELAY_TLS_SMTPS 2 91#define RELAY_TLS_NO 3 92 93#define RELAY_AUTH 0x08 94#define RELAY_LMTP 0x80 95#define RELAY_TLS_VERIFY 0x200 96 97#define MTA_EXT_DSN 0x400 98 99 100#define P_NEWALIASES 0 101#define P_MAKEMAP 1 102 103struct userinfo { 104 char username[SMTPD_VUSERNAME_SIZE]; 105 char directory[PATH_MAX]; 106 uid_t uid; 107 gid_t gid; 108}; 109 110struct netaddr { 111 struct sockaddr_storage ss; 112 int bits; 113}; 114 115struct relayhost { 116 uint16_t flags; 117 int tls; 118 char hostname[HOST_NAME_MAX+1]; 119 uint16_t port; 120 char authlabel[PATH_MAX]; 121}; 122 123struct credentials { 124 char username[LINE_MAX]; 125 char password[LINE_MAX]; 126}; 127 128struct destination { 129 char name[HOST_NAME_MAX+1]; 130}; 131 132struct source { 133 struct sockaddr_storage addr; 134}; 135 136struct addrname { 137 struct sockaddr_storage addr; 138 char name[HOST_NAME_MAX+1]; 139}; 140 141union lookup { 142 struct expand *expand; 143 struct credentials creds; 144 struct netaddr netaddr; 145 struct source source; 146 struct destination domain; 147 struct userinfo userinfo; 148 struct mailaddr mailaddr; 149 struct addrname addrname; 150 struct maddrmap *maddrmap; 151 char relayhost[LINE_MAX]; 152}; 153 154/* 155 * Bump IMSG_VERSION whenever a change is made to enum imsg_type. 156 * This will ensure that we can never use a wrong version of smtpctl with smtpd. 157 */ 158#define IMSG_VERSION 16 159 160enum imsg_type { 161 IMSG_NONE, 162 163 IMSG_CTL_OK, 164 IMSG_CTL_FAIL, 165 166 IMSG_CTL_GET_DIGEST, 167 IMSG_CTL_GET_STATS, 168 IMSG_CTL_LIST_MESSAGES, 169 IMSG_CTL_LIST_ENVELOPES, 170 IMSG_CTL_MTA_SHOW_HOSTS, 171 IMSG_CTL_MTA_SHOW_RELAYS, 172 IMSG_CTL_MTA_SHOW_ROUTES, 173 IMSG_CTL_MTA_SHOW_HOSTSTATS, 174 IMSG_CTL_MTA_BLOCK, 175 IMSG_CTL_MTA_UNBLOCK, 176 IMSG_CTL_MTA_SHOW_BLOCK, 177 IMSG_CTL_PAUSE_EVP, 178 IMSG_CTL_PAUSE_MDA, 179 IMSG_CTL_PAUSE_MTA, 180 IMSG_CTL_PAUSE_SMTP, 181 IMSG_CTL_PROFILE, 182 IMSG_CTL_PROFILE_DISABLE, 183 IMSG_CTL_PROFILE_ENABLE, 184 IMSG_CTL_RESUME_EVP, 185 IMSG_CTL_RESUME_MDA, 186 IMSG_CTL_RESUME_MTA, 187 IMSG_CTL_RESUME_SMTP, 188 IMSG_CTL_RESUME_ROUTE, 189 IMSG_CTL_REMOVE, 190 IMSG_CTL_SCHEDULE, 191 IMSG_CTL_SHOW_STATUS, 192 IMSG_CTL_TRACE_DISABLE, 193 IMSG_CTL_TRACE_ENABLE, 194 IMSG_CTL_UPDATE_TABLE, 195 IMSG_CTL_VERBOSE, 196 IMSG_CTL_DISCOVER_EVPID, 197 IMSG_CTL_DISCOVER_MSGID, 198 199 IMSG_CTL_SMTP_SESSION, 200 201 IMSG_GETADDRINFO, 202 IMSG_GETADDRINFO_END, 203 IMSG_GETNAMEINFO, 204 205 IMSG_SETUP_KEY, 206 IMSG_SETUP_PEER, 207 IMSG_SETUP_DONE, 208 209 IMSG_CONF_START, 210 IMSG_CONF_END, 211 212 IMSG_STAT_INCREMENT, 213 IMSG_STAT_DECREMENT, 214 IMSG_STAT_SET, 215 216 IMSG_LKA_AUTHENTICATE, 217 IMSG_LKA_OPEN_FORWARD, 218 IMSG_LKA_ENVELOPE_SUBMIT, 219 IMSG_LKA_ENVELOPE_COMMIT, 220 221 IMSG_QUEUE_DELIVER, 222 IMSG_QUEUE_DELIVERY_OK, 223 IMSG_QUEUE_DELIVERY_TEMPFAIL, 224 IMSG_QUEUE_DELIVERY_PERMFAIL, 225 IMSG_QUEUE_DELIVERY_LOOP, 226 IMSG_QUEUE_DISCOVER_EVPID, 227 IMSG_QUEUE_DISCOVER_MSGID, 228 IMSG_QUEUE_ENVELOPE_ACK, 229 IMSG_QUEUE_ENVELOPE_COMMIT, 230 IMSG_QUEUE_ENVELOPE_REMOVE, 231 IMSG_QUEUE_ENVELOPE_SCHEDULE, 232 IMSG_QUEUE_ENVELOPE_SUBMIT, 233 IMSG_QUEUE_HOLDQ_HOLD, 234 IMSG_QUEUE_HOLDQ_RELEASE, 235 IMSG_QUEUE_MESSAGE_COMMIT, 236 IMSG_QUEUE_MESSAGE_ROLLBACK, 237 IMSG_QUEUE_SMTP_SESSION, 238 IMSG_QUEUE_TRANSFER, 239 240 IMSG_MDA_DELIVERY_OK, 241 IMSG_MDA_DELIVERY_TEMPFAIL, 242 IMSG_MDA_DELIVERY_PERMFAIL, 243 IMSG_MDA_DELIVERY_LOOP, 244 IMSG_MDA_DELIVERY_HOLD, 245 IMSG_MDA_DONE, 246 IMSG_MDA_FORK, 247 IMSG_MDA_HOLDQ_RELEASE, 248 IMSG_MDA_LOOKUP_USERINFO, 249 IMSG_MDA_KILL, 250 IMSG_MDA_OPEN_MESSAGE, 251 252 IMSG_MFA_SMTP_RESPONSE, 253 254 IMSG_MTA_DELIVERY_OK, 255 IMSG_MTA_DELIVERY_TEMPFAIL, 256 IMSG_MTA_DELIVERY_PERMFAIL, 257 IMSG_MTA_DELIVERY_LOOP, 258 IMSG_MTA_DELIVERY_HOLD, 259 IMSG_MTA_DNS_HOST, 260 IMSG_MTA_DNS_HOST_END, 261 IMSG_MTA_DNS_MX, 262 IMSG_MTA_DNS_MX_PREFERENCE, 263 IMSG_MTA_HOLDQ_RELEASE, 264 IMSG_MTA_LOOKUP_CREDENTIALS, 265 IMSG_MTA_LOOKUP_SOURCE, 266 IMSG_MTA_LOOKUP_HELO, 267 IMSG_MTA_LOOKUP_SMARTHOST, 268 IMSG_MTA_OPEN_MESSAGE, 269 IMSG_MTA_SCHEDULE, 270 IMSG_MTA_TLS_INIT, 271 IMSG_MTA_TLS_VERIFY_CERT, 272 IMSG_MTA_TLS_VERIFY_CHAIN, 273 IMSG_MTA_TLS_VERIFY, 274 275 IMSG_SCHED_ENVELOPE_BOUNCE, 276 IMSG_SCHED_ENVELOPE_DELIVER, 277 IMSG_SCHED_ENVELOPE_EXPIRE, 278 IMSG_SCHED_ENVELOPE_INJECT, 279 IMSG_SCHED_ENVELOPE_REMOVE, 280 IMSG_SCHED_ENVELOPE_TRANSFER, 281 282 IMSG_SMTP_AUTHENTICATE, 283 IMSG_SMTP_MESSAGE_COMMIT, 284 IMSG_SMTP_MESSAGE_CREATE, 285 IMSG_SMTP_MESSAGE_ROLLBACK, 286 IMSG_SMTP_MESSAGE_OPEN, 287 IMSG_SMTP_CHECK_SENDER, 288 IMSG_SMTP_EXPAND_RCPT, 289 IMSG_SMTP_LOOKUP_HELO, 290 IMSG_SMTP_TLS_INIT, 291 IMSG_SMTP_TLS_VERIFY_CERT, 292 IMSG_SMTP_TLS_VERIFY_CHAIN, 293 IMSG_SMTP_TLS_VERIFY, 294 295 IMSG_SMTP_REQ_CONNECT, 296 IMSG_SMTP_REQ_HELO, 297 IMSG_SMTP_REQ_MAIL, 298 IMSG_SMTP_REQ_RCPT, 299 IMSG_SMTP_REQ_DATA, 300 IMSG_SMTP_REQ_EOM, 301 IMSG_SMTP_EVENT_RSET, 302 IMSG_SMTP_EVENT_COMMIT, 303 IMSG_SMTP_EVENT_ROLLBACK, 304 IMSG_SMTP_EVENT_DISCONNECT, 305 306 IMSG_LKA_PROCESSOR_FORK, 307 308 IMSG_SMTP_REPORT_LINK_CONNECT, 309 IMSG_SMTP_REPORT_LINK_DISCONNECT, 310 IMSG_SMTP_REPORT_LINK_TLS, 311 312 IMSG_SMTP_REPORT_TX_BEGIN, 313 IMSG_SMTP_REPORT_TX_ENVELOPE, 314 IMSG_SMTP_REPORT_TX_COMMIT, 315 IMSG_SMTP_REPORT_TX_ROLLBACK, 316 317 IMSG_SMTP_REPORT_PROTOCOL_CLIENT, 318 IMSG_SMTP_REPORT_PROTOCOL_SERVER, 319 320 IMSG_SMTP_FILTER, 321 322 IMSG_CA_PRIVENC, 323 IMSG_CA_PRIVDEC 324}; 325 326enum smtp_proc_type { 327 PROC_PARENT = 0, 328 PROC_LKA, 329 PROC_QUEUE, 330 PROC_CONTROL, 331 PROC_SCHEDULER, 332 PROC_PONY, 333 PROC_CA, 334 PROC_PROCESSOR, 335 PROC_CLIENT, 336}; 337 338enum table_type { 339 T_NONE = 0, 340 T_DYNAMIC = 0x01, /* table with external source */ 341 T_LIST = 0x02, /* table holding a list */ 342 T_HASH = 0x04, /* table holding a hash table */ 343}; 344 345struct table { 346 char t_name[LINE_MAX]; 347 enum table_type t_type; 348 char t_config[PATH_MAX]; 349 350 struct dict t_dict; 351 352 void *t_handle; 353 struct table_backend *t_backend; 354 void *t_iter; 355}; 356 357struct table_backend { 358 const unsigned int services; 359 int (*config)(struct table *); 360 void *(*open)(struct table *); 361 int (*update)(struct table *); 362 void (*close)(void *); 363 int (*lookup)(void *, struct dict *, const char *, enum table_service, union lookup *); 364 int (*fetch)(void *, struct dict *, enum table_service, union lookup *); 365}; 366 367 368enum bounce_type { 369 B_ERROR, 370 B_WARNING, 371 B_DSN 372}; 373 374enum dsn_ret { 375 DSN_RETFULL = 1, 376 DSN_RETHDRS 377}; 378 379struct delivery_bounce { 380 enum bounce_type type; 381 time_t delay; 382 time_t ttl; 383 enum dsn_ret dsn_ret; 384 int mta_without_dsn; 385}; 386 387enum expand_type { 388 EXPAND_INVALID, 389 EXPAND_USERNAME, 390 EXPAND_FILENAME, 391 EXPAND_FILTER, 392 EXPAND_INCLUDE, 393 EXPAND_ADDRESS, 394 EXPAND_ERROR, 395}; 396 397enum filter_phase { 398 FILTER_CONNECTED = 0, 399 FILTER_HELO, 400 FILTER_EHLO, 401 FILTER_STARTTLS, 402 FILTER_AUTH, 403 FILTER_MAIL_FROM, 404 FILTER_RCPT_TO, 405 FILTER_DATA, 406 FILTER_RSET, 407 FILTER_QUIT, 408 FILTER_NOOP, 409 FILTER_HELP, 410 FILTER_WIZ, 411 FILTER_COMMIT, 412 FILTER_PHASES_COUNT /* must be last */ 413}; 414 415struct expandnode { 416 RB_ENTRY(expandnode) entry; 417 TAILQ_ENTRY(expandnode) tq_entry; 418 enum expand_type type; 419 int sameuser; 420 int realuser; 421 int forwarded; 422 struct rule *rule; 423 struct expandnode *parent; 424 unsigned int depth; 425 union { 426 /* 427 * user field handles both expansion user and system user 428 * so we MUST make it large enough to fit a mailaddr user 429 */ 430 char user[SMTPD_MAXLOCALPARTSIZE]; 431 char buffer[EXPAND_BUFFER]; 432 struct mailaddr mailaddr; 433 } u; 434}; 435 436struct expand { 437 RB_HEAD(expandtree, expandnode) tree; 438 TAILQ_HEAD(xnodes, expandnode) *queue; 439 size_t nb_nodes; 440 struct rule *rule; 441 struct expandnode *parent; 442}; 443 444struct maddrnode { 445 TAILQ_ENTRY(maddrnode) entries; 446 struct mailaddr mailaddr; 447}; 448 449struct maddrmap { 450 TAILQ_HEAD(xmaddr, maddrnode) queue; 451}; 452 453#define DSN_SUCCESS 0x01 454#define DSN_FAILURE 0x02 455#define DSN_DELAY 0x04 456#define DSN_NEVER 0x08 457 458#define DSN_ENVID_LEN 100 459 460#define SMTPD_ENVELOPE_VERSION 3 461struct envelope { 462 TAILQ_ENTRY(envelope) entry; 463 464 char dispatcher[HOST_NAME_MAX+1]; 465 466 char tag[SMTPD_TAG_SIZE]; 467 468 uint32_t version; 469 uint64_t id; 470 enum envelope_flags flags; 471 472 char smtpname[HOST_NAME_MAX+1]; 473 char helo[HOST_NAME_MAX+1]; 474 char hostname[HOST_NAME_MAX+1]; 475 char errorline[LINE_MAX]; 476 struct sockaddr_storage ss; 477 478 struct mailaddr sender; 479 struct mailaddr rcpt; 480 struct mailaddr dest; 481 482 char mda_user[SMTPD_VUSERNAME_SIZE]; 483 char mda_exec[LINE_MAX]; 484 485 enum delivery_type type; 486 union { 487 struct delivery_bounce bounce; 488 } agent; 489 490 uint16_t retry; 491 time_t creation; 492 time_t ttl; 493 time_t lasttry; 494 time_t nexttry; 495 time_t lastbounce; 496 497 struct mailaddr dsn_orcpt; 498 char dsn_envid[DSN_ENVID_LEN+1]; 499 uint8_t dsn_notify; 500 enum dsn_ret dsn_ret; 501 502 uint8_t esc_class; 503 uint8_t esc_code; 504}; 505 506struct listener { 507 uint16_t flags; 508 int fd; 509 struct sockaddr_storage ss; 510 in_port_t port; 511 struct timeval timeout; 512 struct event ev; 513 char pki_name[PATH_MAX]; 514 char ca_name[PATH_MAX]; 515 char tag[SMTPD_TAG_SIZE]; 516 char authtable[LINE_MAX]; 517 char hostname[HOST_NAME_MAX+1]; 518 char hostnametable[PATH_MAX]; 519 char sendertable[PATH_MAX]; 520 521 TAILQ_ENTRY(listener) entry; 522 523 int local; /* there must be a better way */ 524}; 525 526struct smtpd { 527 char sc_conffile[PATH_MAX]; 528 size_t sc_maxsize; 529 530#define SMTPD_OPT_VERBOSE 0x00000001 531#define SMTPD_OPT_NOACTION 0x00000002 532 uint32_t sc_opts; 533 534#define SMTPD_EXITING 0x00000001 /* unused */ 535#define SMTPD_MDA_PAUSED 0x00000002 536#define SMTPD_MTA_PAUSED 0x00000004 537#define SMTPD_SMTP_PAUSED 0x00000008 538#define SMTPD_MDA_BUSY 0x00000010 539#define SMTPD_MTA_BUSY 0x00000020 540#define SMTPD_BOUNCE_BUSY 0x00000040 541#define SMTPD_SMTP_DISABLED 0x00000080 542 uint32_t sc_flags; 543 544#define QUEUE_COMPRESSION 0x00000001 545#define QUEUE_ENCRYPTION 0x00000002 546#define QUEUE_EVPCACHE 0x00000004 547 uint32_t sc_queue_flags; 548 char *sc_queue_key; 549 size_t sc_queue_evpcache_size; 550 551 size_t sc_session_max_rcpt; 552 size_t sc_session_max_mails; 553 554 struct dict *sc_mda_wrappers; 555 size_t sc_mda_max_session; 556 size_t sc_mda_max_user_session; 557 size_t sc_mda_task_hiwat; 558 size_t sc_mda_task_lowat; 559 size_t sc_mda_task_release; 560 561 size_t sc_mta_max_deferred; 562 563 size_t sc_scheduler_max_inflight; 564 size_t sc_scheduler_max_evp_batch_size; 565 size_t sc_scheduler_max_msg_batch_size; 566 size_t sc_scheduler_max_schedule; 567 568 struct dict *sc_processors_dict; 569 struct dict *sc_smtp_reporters_dict; 570 571 int sc_ttl; 572#define MAX_BOUNCE_WARN 4 573 time_t sc_bounce_warn[MAX_BOUNCE_WARN]; 574 char sc_hostname[HOST_NAME_MAX+1]; 575 struct stat_backend *sc_stat; 576 struct compress_backend *sc_comp; 577 578 time_t sc_uptime; 579 580 /* This is a listener for a local socket used by smtp_enqueue(). */ 581 struct listener *sc_sock_listener; 582 583 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 584 585 TAILQ_HEAD(rulelist, rule) *sc_rules; 586 TAILQ_HEAD(filterrules, filter_rule) sc_filter_rules[FILTER_PHASES_COUNT]; 587 588 struct dict *sc_dispatchers; 589 struct dispatcher *sc_dispatcher_bounce; 590 591 struct dict *sc_ca_dict; 592 struct dict *sc_pki_dict; 593 struct dict *sc_ssl_dict; 594 595 struct dict *sc_tables_dict; /* keyed lookup */ 596 597 struct dict *sc_limits_dict; 598 599 char *sc_tls_ciphers; 600 601 char *sc_subaddressing_delim; 602}; 603 604#define TRACE_DEBUG 0x0001 605#define TRACE_IMSG 0x0002 606#define TRACE_IO 0x0004 607#define TRACE_SMTP 0x0008 608#define TRACE_FILTERS 0x0010 609#define TRACE_MTA 0x0020 610#define TRACE_BOUNCE 0x0040 611#define TRACE_SCHEDULER 0x0080 612#define TRACE_LOOKUP 0x0100 613#define TRACE_STAT 0x0200 614#define TRACE_RULES 0x0400 615#define TRACE_MPROC 0x0800 616#define TRACE_EXPAND 0x1000 617#define TRACE_TABLES 0x2000 618#define TRACE_QUEUE 0x4000 619 620#define PROFILE_TOSTAT 0x0001 621#define PROFILE_IMSG 0x0002 622#define PROFILE_QUEUE 0x0004 623 624struct forward_req { 625 uint64_t id; 626 uint8_t status; 627 628 char user[SMTPD_VUSERNAME_SIZE]; 629 uid_t uid; 630 gid_t gid; 631 char directory[PATH_MAX]; 632}; 633 634struct deliver { 635 char dispatcher[EXPAND_BUFFER]; 636 637 struct mailaddr sender; 638 struct mailaddr rcpt; 639 struct mailaddr dest; 640 641 char mda_exec[LINE_MAX]; 642 643 struct userinfo userinfo; 644}; 645 646struct mta_host { 647 SPLAY_ENTRY(mta_host) entry; 648 struct sockaddr *sa; 649 char *ptrname; 650 int refcount; 651 size_t nconn; 652 time_t lastconn; 653 time_t lastptrquery; 654 655#define HOST_IGNORE 0x01 656 int flags; 657}; 658 659struct mta_mx { 660 TAILQ_ENTRY(mta_mx) entry; 661 struct mta_host *host; 662 int preference; 663}; 664 665struct mta_domain { 666 SPLAY_ENTRY(mta_domain) entry; 667 char *name; 668 int as_host; 669 TAILQ_HEAD(, mta_mx) mxs; 670 int mxstatus; 671 int refcount; 672 size_t nconn; 673 time_t lastconn; 674 time_t lastmxquery; 675}; 676 677struct mta_source { 678 SPLAY_ENTRY(mta_source) entry; 679 struct sockaddr *sa; 680 int refcount; 681 size_t nconn; 682 time_t lastconn; 683}; 684 685struct mta_connector { 686 struct mta_source *source; 687 struct mta_relay *relay; 688 689#define CONNECTOR_ERROR_FAMILY 0x0001 690#define CONNECTOR_ERROR_SOURCE 0x0002 691#define CONNECTOR_ERROR_MX 0x0004 692#define CONNECTOR_ERROR_ROUTE_NET 0x0008 693#define CONNECTOR_ERROR_ROUTE_SMTP 0x0010 694#define CONNECTOR_ERROR_ROUTE 0x0018 695#define CONNECTOR_ERROR_BLOCKED 0x0020 696#define CONNECTOR_ERROR 0x00ff 697 698#define CONNECTOR_LIMIT_HOST 0x0100 699#define CONNECTOR_LIMIT_ROUTE 0x0200 700#define CONNECTOR_LIMIT_SOURCE 0x0400 701#define CONNECTOR_LIMIT_RELAY 0x0800 702#define CONNECTOR_LIMIT_CONN 0x1000 703#define CONNECTOR_LIMIT_DOMAIN 0x2000 704#define CONNECTOR_LIMIT 0xff00 705 706#define CONNECTOR_NEW 0x10000 707#define CONNECTOR_WAIT 0x20000 708 int flags; 709 710 int refcount; 711 size_t nconn; 712 time_t lastconn; 713}; 714 715struct mta_route { 716 SPLAY_ENTRY(mta_route) entry; 717 uint64_t id; 718 struct mta_source *src; 719 struct mta_host *dst; 720#define ROUTE_NEW 0x01 721#define ROUTE_RUNQ 0x02 722#define ROUTE_KEEPALIVE 0x04 723#define ROUTE_DISABLED 0xf0 724#define ROUTE_DISABLED_NET 0x10 725#define ROUTE_DISABLED_SMTP 0x20 726 int flags; 727 int nerror; 728 int penalty; 729 int refcount; 730 size_t nconn; 731 time_t lastconn; 732 time_t lastdisc; 733 time_t lastpenalty; 734}; 735 736struct mta_limits { 737 size_t maxconn_per_host; 738 size_t maxconn_per_route; 739 size_t maxconn_per_source; 740 size_t maxconn_per_connector; 741 size_t maxconn_per_relay; 742 size_t maxconn_per_domain; 743 744 time_t conndelay_host; 745 time_t conndelay_route; 746 time_t conndelay_source; 747 time_t conndelay_connector; 748 time_t conndelay_relay; 749 time_t conndelay_domain; 750 751 time_t discdelay_route; 752 753 size_t max_mail_per_session; 754 time_t sessdelay_transaction; 755 time_t sessdelay_keepalive; 756 757 size_t max_failures_per_session; 758 759 int family; 760 761 int task_hiwat; 762 int task_lowat; 763 int task_release; 764}; 765 766struct mta_relay { 767 SPLAY_ENTRY(mta_relay) entry; 768 uint64_t id; 769 770 struct dispatcher *dispatcher; 771 struct mta_domain *domain; 772 struct mta_limits *limits; 773 int tls; 774 int flags; 775 char *backupname; 776 int backuppref; 777 char *sourcetable; 778 uint16_t port; 779 char *pki_name; 780 char *ca_name; 781 char *authtable; 782 char *authlabel; 783 char *helotable; 784 char *heloname; 785 char *secret; 786 787 int state; 788 size_t ntask; 789 TAILQ_HEAD(, mta_task) tasks; 790 791 struct tree connectors; 792 size_t sourceloop; 793 time_t lastsource; 794 time_t nextsource; 795 796 int fail; 797 char *failstr; 798 799#define RELAY_WAIT_MX 0x01 800#define RELAY_WAIT_PREFERENCE 0x02 801#define RELAY_WAIT_SECRET 0x04 802#define RELAY_WAIT_LIMITS 0x08 803#define RELAY_WAIT_SOURCE 0x10 804#define RELAY_WAIT_CONNECTOR 0x20 805#define RELAY_WAIT_SMARTHOST 0x40 806#define RELAY_WAITMASK 0x7f 807 int status; 808 809 int refcount; 810 size_t nconn; 811 size_t nconn_ready; 812 time_t lastconn; 813}; 814 815struct mta_envelope { 816 TAILQ_ENTRY(mta_envelope) entry; 817 uint64_t id; 818 uint64_t session; 819 time_t creation; 820 char *smtpname; 821 char *dest; 822 char *rcpt; 823 struct mta_task *task; 824 int delivery; 825 826 int ext; 827 char *dsn_orcpt; 828 char dsn_envid[DSN_ENVID_LEN+1]; 829 uint8_t dsn_notify; 830 enum dsn_ret dsn_ret; 831 832 char status[LINE_MAX]; 833}; 834 835struct mta_task { 836 TAILQ_ENTRY(mta_task) entry; 837 struct mta_relay *relay; 838 uint32_t msgid; 839 TAILQ_HEAD(, mta_envelope) envelopes; 840 char *sender; 841}; 842 843struct passwd; 844 845struct queue_backend { 846 int (*init)(struct passwd *, int, const char *); 847}; 848 849struct compress_backend { 850 size_t (*compress_chunk)(void *, size_t, void *, size_t); 851 size_t (*uncompress_chunk)(void *, size_t, void *, size_t); 852 int (*compress_file)(FILE *, FILE *); 853 int (*uncompress_file)(FILE *, FILE *); 854}; 855 856/* auth structures */ 857enum auth_type { 858 AUTH_BSD, 859 AUTH_PWD, 860}; 861 862struct auth_backend { 863 int (*authenticate)(char *, char *); 864}; 865 866struct scheduler_backend { 867 int (*init)(const char *); 868 869 int (*insert)(struct scheduler_info *); 870 size_t (*commit)(uint32_t); 871 size_t (*rollback)(uint32_t); 872 873 int (*update)(struct scheduler_info *); 874 int (*delete)(uint64_t); 875 int (*hold)(uint64_t, uint64_t); 876 int (*release)(int, uint64_t, int); 877 878 int (*batch)(int, int*, size_t*, uint64_t*, int*); 879 880 size_t (*messages)(uint32_t, uint32_t *, size_t); 881 size_t (*envelopes)(uint64_t, struct evpstate *, size_t); 882 int (*schedule)(uint64_t); 883 int (*remove)(uint64_t); 884 int (*suspend)(uint64_t); 885 int (*resume)(uint64_t); 886 int (*query)(uint64_t); 887}; 888 889enum stat_type { 890 STAT_COUNTER, 891 STAT_TIMESTAMP, 892 STAT_TIMEVAL, 893 STAT_TIMESPEC, 894}; 895 896struct stat_value { 897 enum stat_type type; 898 union stat_v { 899 size_t counter; 900 time_t timestamp; 901 struct timeval tv; 902 struct timespec ts; 903 } u; 904}; 905 906#define STAT_KEY_SIZE 1024 907struct stat_kv { 908 void *iter; 909 char key[STAT_KEY_SIZE]; 910 struct stat_value val; 911}; 912 913struct stat_backend { 914 void (*init)(void); 915 void (*close)(void); 916 void (*increment)(const char *, size_t); 917 void (*decrement)(const char *, size_t); 918 void (*set)(const char *, const struct stat_value *); 919 int (*iter)(void **, char **, struct stat_value *); 920}; 921 922struct stat_digest { 923 time_t startup; 924 time_t timestamp; 925 926 size_t clt_connect; 927 size_t clt_disconnect; 928 929 size_t evp_enqueued; 930 size_t evp_dequeued; 931 932 size_t evp_expired; 933 size_t evp_removed; 934 size_t evp_bounce; 935 936 size_t dlv_ok; 937 size_t dlv_permfail; 938 size_t dlv_tempfail; 939 size_t dlv_loop; 940}; 941 942 943struct mproc { 944 pid_t pid; 945 char *name; 946 int proc; 947 void (*handler)(struct mproc *, struct imsg *); 948 struct imsgbuf imsgbuf; 949 950 char *m_buf; 951 size_t m_alloc; 952 size_t m_pos; 953 uint32_t m_type; 954 uint32_t m_peerid; 955 pid_t m_pid; 956 int m_fd; 957 958 int enable; 959 short events; 960 struct event ev; 961 void *data; 962}; 963 964struct msg { 965 const uint8_t *pos; 966 const uint8_t *end; 967}; 968 969extern enum smtp_proc_type smtpd_process; 970 971extern int tracing; 972extern int foreground_log; 973extern int profiling; 974 975extern struct mproc *p_control; 976extern struct mproc *p_parent; 977extern struct mproc *p_lka; 978extern struct mproc *p_queue; 979extern struct mproc *p_scheduler; 980extern struct mproc *p_pony; 981extern struct mproc *p_ca; 982 983extern struct smtpd *env; 984extern void (*imsg_callback)(struct mproc *, struct imsg *); 985 986struct imsgproc { 987 pid_t pid; 988 struct event ev; 989 struct imsgbuf *ibuf; 990 char *path; 991 char *name; 992 void (*cb)(struct imsg *, void *); 993 void *cb_arg; 994}; 995 996/* inter-process structures */ 997 998struct bounce_req_msg { 999 uint64_t evpid; 1000 time_t timestamp; 1001 struct delivery_bounce bounce; 1002}; 1003 1004enum dns_error { 1005 DNS_OK = 0, 1006 DNS_RETRY, 1007 DNS_EINVAL, 1008 DNS_ENONAME, 1009 DNS_ENOTFOUND, 1010}; 1011 1012enum lka_resp_status { 1013 LKA_OK, 1014 LKA_TEMPFAIL, 1015 LKA_PERMFAIL 1016}; 1017 1018struct processor { 1019 const char *command; 1020 const char *user; 1021 const char *group; 1022 const char *chroot; 1023}; 1024 1025struct filter_rule { 1026 TAILQ_ENTRY(filter_rule) entry; 1027 1028 enum filter_phase phase; 1029 char *reject; 1030 char *disconnect; 1031 char *rewrite; 1032 char *proc; 1033 1034 int8_t not_table; 1035 struct table *table; 1036 1037 int8_t not_regex; 1038 struct table *regex; 1039 1040 int8_t not_rdns; 1041 int8_t rdns; 1042}; 1043 1044enum filter_status { 1045 FILTER_PROCEED, 1046 FILTER_REWRITE, 1047 FILTER_REJECT, 1048 FILTER_DISCONNECT, 1049}; 1050 1051enum ca_resp_status { 1052 CA_OK, 1053 CA_FAIL 1054}; 1055 1056enum mda_resp_status { 1057 MDA_OK, 1058 MDA_TEMPFAIL, 1059 MDA_PERMFAIL 1060}; 1061 1062struct ca_cert_req_msg { 1063 uint64_t reqid; 1064 char name[HOST_NAME_MAX+1]; 1065 int fallback; 1066}; 1067 1068struct ca_cert_resp_msg { 1069 uint64_t reqid; 1070 enum ca_resp_status status; 1071 char name[HOST_NAME_MAX+1]; 1072 char *cert; 1073 off_t cert_len; 1074}; 1075 1076struct ca_vrfy_req_msg { 1077 uint64_t reqid; 1078 char name[HOST_NAME_MAX+1]; 1079 int fallback; 1080 unsigned char *cert; 1081 off_t cert_len; 1082 size_t n_chain; 1083 size_t chain_offset; 1084 unsigned char **chain_cert; 1085 off_t *chain_cert_len; 1086}; 1087 1088struct ca_vrfy_resp_msg { 1089 uint64_t reqid; 1090 enum ca_resp_status status; 1091}; 1092 1093struct msg_walkinfo { 1094 struct event ev; 1095 uint32_t msgid; 1096 uint32_t peerid; 1097 size_t n_evp; 1098 void *data; 1099 int done; 1100}; 1101 1102 1103enum dispatcher_type { 1104 DISPATCHER_LOCAL, 1105 DISPATCHER_REMOTE, 1106 DISPATCHER_BOUNCE, 1107}; 1108 1109struct dispatcher_local { 1110 uint8_t requires_root; /* only for MBOX */ 1111 1112 uint8_t expand_only; 1113 uint8_t forward_only; 1114 1115 char *mda_wrapper; 1116 char *command; 1117 1118 char *table_alias; 1119 char *table_virtual; 1120 char *table_userbase; 1121 1122 char *user; 1123}; 1124 1125struct dispatcher_remote { 1126 char *helo; 1127 char *helo_source; 1128 1129 char *source; 1130 1131 char *ca; 1132 char *pki; 1133 1134 char *mail_from; 1135 1136 char *smarthost; 1137 char *auth; 1138 int tls_required; 1139 int tls_noverify; 1140 1141 int backup; 1142 char *backupmx; 1143}; 1144 1145struct dispatcher_bounce { 1146}; 1147 1148struct dispatcher { 1149 enum dispatcher_type type; 1150 union dispatcher_agent { 1151 struct dispatcher_local local; 1152 struct dispatcher_remote remote; 1153 struct dispatcher_bounce bounce; 1154 } u; 1155 1156 time_t ttl; 1157}; 1158 1159struct rule { 1160 TAILQ_ENTRY(rule) r_entry; 1161 1162 uint8_t reject; 1163 1164 int8_t flag_tag; 1165 int8_t flag_from; 1166 int8_t flag_for; 1167 int8_t flag_from_socket; 1168 1169 int8_t flag_smtp_helo; 1170 int8_t flag_smtp_starttls; 1171 int8_t flag_smtp_auth; 1172 int8_t flag_smtp_mail_from; 1173 int8_t flag_smtp_rcpt_to; 1174 1175 1176 char *table_tag; 1177 char *table_from; 1178 char *table_for; 1179 1180 char *table_smtp_helo; 1181 char *table_smtp_auth; 1182 char *table_smtp_mail_from; 1183 char *table_smtp_rcpt_to; 1184 1185 char *dispatcher; 1186}; 1187 1188 1189/* aliases.c */ 1190int aliases_get(struct expand *, const char *); 1191int aliases_virtual_get(struct expand *, const struct mailaddr *); 1192int alias_parse(struct expandnode *, const char *); 1193 1194 1195/* auth.c */ 1196struct auth_backend *auth_backend_lookup(enum auth_type); 1197 1198 1199/* bounce.c */ 1200void bounce_add(uint64_t); 1201void bounce_fd(int); 1202 1203 1204/* ca.c */ 1205int ca(void); 1206int ca_X509_verify(void *, void *, const char *, const char *, const char **); 1207void ca_imsg(struct mproc *, struct imsg *); 1208void ca_init(void); 1209void ca_engine_init(void); 1210 1211/* compress_backend.c */ 1212struct compress_backend *compress_backend_lookup(const char *); 1213size_t compress_chunk(void *, size_t, void *, size_t); 1214size_t uncompress_chunk(void *, size_t, void *, size_t); 1215int compress_file(FILE *, FILE *); 1216int uncompress_file(FILE *, FILE *); 1217 1218/* config.c */ 1219#define PURGE_LISTENERS 0x01 1220#define PURGE_TABLES 0x02 1221#define PURGE_RULES 0x04 1222#define PURGE_PKI 0x08 1223#define PURGE_PKI_KEYS 0x10 1224#define PURGE_DISPATCHERS 0x20 1225#define PURGE_EVERYTHING 0xff 1226struct smtpd *config_default(void); 1227void purge_config(uint8_t); 1228void config_process(enum smtp_proc_type); 1229void config_peer(enum smtp_proc_type); 1230 1231 1232/* control.c */ 1233int control(void); 1234int control_create_socket(void); 1235 1236 1237/* crypto.c */ 1238int crypto_setup(const char *, size_t); 1239int crypto_encrypt_file(FILE *, FILE *); 1240int crypto_decrypt_file(FILE *, FILE *); 1241size_t crypto_encrypt_buffer(const char *, size_t, char *, size_t); 1242size_t crypto_decrypt_buffer(const char *, size_t, char *, size_t); 1243 1244 1245/* dns.c */ 1246void dns_imsg(struct mproc *, struct imsg *); 1247 1248 1249/* enqueue.c */ 1250int enqueue(int, char **, FILE *); 1251 1252 1253/* envelope.c */ 1254void envelope_set_errormsg(struct envelope *, char *, ...); 1255void envelope_set_esc_class(struct envelope *, enum enhanced_status_class); 1256void envelope_set_esc_code(struct envelope *, enum enhanced_status_code); 1257int envelope_load_buffer(struct envelope *, const char *, size_t); 1258int envelope_dump_buffer(const struct envelope *, char *, size_t); 1259 1260 1261/* expand.c */ 1262int expand_cmp(struct expandnode *, struct expandnode *); 1263void expand_insert(struct expand *, struct expandnode *); 1264struct expandnode *expand_lookup(struct expand *, struct expandnode *); 1265void expand_clear(struct expand *); 1266void expand_free(struct expand *); 1267int expand_line(struct expand *, const char *, int); 1268int expand_to_text(struct expand *, char *, size_t); 1269RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1270 1271 1272/* forward.c */ 1273int forwards_get(int, struct expand *); 1274 1275 1276/* imsgproc.c */ 1277void imsgproc_init(void); 1278struct imsgproc *imsgproc_fork(const char *, const char *, 1279 void (*)(struct imsg *, void *), void *); 1280void imsgproc_set_read(struct imsgproc *); 1281void imsgproc_set_write(struct imsgproc *); 1282void imsgproc_set_read_write(struct imsgproc *); 1283void imsgproc_reset_callback(struct imsgproc *, void (*)(struct imsg *, void *), void *); 1284 1285 1286/* limit.c */ 1287void limit_mta_set_defaults(struct mta_limits *); 1288int limit_mta_set(struct mta_limits *, const char*, int64_t); 1289 1290 1291/* lka.c */ 1292int lka(void); 1293 1294 1295/* lka_proc.c */ 1296void lka_proc_forked(const char *, int); 1297struct io *lka_proc_get_io(const char *); 1298 1299 1300/* lka_report.c */ 1301void lka_report_smtp_link_connect(time_t, uint64_t, const char *, const struct sockaddr_storage *, const struct sockaddr_storage *); 1302void lka_report_smtp_link_disconnect(time_t, uint64_t); 1303void lka_report_smtp_link_tls(time_t, uint64_t, const char *); 1304void lka_report_smtp_tx_begin(time_t, uint64_t, uint32_t); 1305void lka_report_smtp_tx_envelope(time_t, uint64_t, uint32_t, uint64_t); 1306void lka_report_smtp_tx_commit(time_t, uint64_t, uint32_t, size_t); 1307void lka_report_smtp_tx_rollback(time_t, uint64_t); 1308void lka_report_smtp_protocol_client(time_t, uint64_t, const char *); 1309void lka_report_smtp_protocol_server(time_t, uint64_t, const char *); 1310 1311 1312/* lka_filter.c */ 1313void lka_filter(uint64_t, enum filter_phase, const char *, const char *); 1314int lka_filter_response(uint64_t, const char *, const char *); 1315 1316 1317/* lka_session.c */ 1318void lka_session(uint64_t, struct envelope *); 1319void lka_session_forward_reply(struct forward_req *, int); 1320 1321 1322/* log.c */ 1323void vlog(int, const char *, va_list); 1324void logit(int, const char *, ...) __attribute__((format (printf, 2, 3))); 1325 1326 1327/* mda.c */ 1328void mda_postfork(void); 1329void mda_postprivdrop(void); 1330void mda_imsg(struct mproc *, struct imsg *); 1331 1332 1333/* mda_unpriv.c */ 1334void mda_unpriv(struct dispatcher *, struct deliver *, const char *, const char *); 1335 1336 1337/* mda_variables.c */ 1338size_t mda_expand_format(char *, size_t, const struct deliver *, 1339 const struct userinfo *, const char *); 1340 1341 1342/* makemap.c */ 1343int makemap(int, int, char **); 1344 1345 1346/* mailaddr.c */ 1347int mailaddr_line(struct maddrmap *, const char *); 1348void maddrmap_init(struct maddrmap *); 1349void maddrmap_insert(struct maddrmap *, struct maddrnode *); 1350void maddrmap_free(struct maddrmap *); 1351 1352 1353/* mproc.c */ 1354int mproc_fork(struct mproc *, const char*, char **); 1355void mproc_init(struct mproc *, int); 1356void mproc_clear(struct mproc *); 1357void mproc_enable(struct mproc *); 1358void mproc_disable(struct mproc *); 1359void mproc_event_add(struct mproc *); 1360void m_compose(struct mproc *, uint32_t, uint32_t, pid_t, int, void *, size_t); 1361void m_composev(struct mproc *, uint32_t, uint32_t, pid_t, int, 1362 const struct iovec *, int); 1363void m_forward(struct mproc *, struct imsg *); 1364void m_create(struct mproc *, uint32_t, uint32_t, pid_t, int); 1365void m_add(struct mproc *, const void *, size_t); 1366void m_add_int(struct mproc *, int); 1367void m_add_u32(struct mproc *, uint32_t); 1368void m_add_size(struct mproc *, size_t); 1369void m_add_time(struct mproc *, time_t); 1370void m_add_string(struct mproc *, const char *); 1371void m_add_data(struct mproc *, const void *, size_t); 1372void m_add_evpid(struct mproc *, uint64_t); 1373void m_add_msgid(struct mproc *, uint32_t); 1374void m_add_id(struct mproc *, uint64_t); 1375void m_add_sockaddr(struct mproc *, const struct sockaddr *); 1376void m_add_mailaddr(struct mproc *, const struct mailaddr *); 1377void m_add_envelope(struct mproc *, const struct envelope *); 1378void m_add_params(struct mproc *, struct dict *); 1379void m_close(struct mproc *); 1380void m_flush(struct mproc *); 1381 1382void m_msg(struct msg *, struct imsg *); 1383int m_is_eom(struct msg *); 1384void m_end(struct msg *); 1385void m_get_int(struct msg *, int *); 1386void m_get_size(struct msg *, size_t *); 1387void m_get_u32(struct msg *, uint32_t *); 1388void m_get_time(struct msg *, time_t *); 1389void m_get_string(struct msg *, const char **); 1390void m_get_data(struct msg *, const void **, size_t *); 1391void m_get_evpid(struct msg *, uint64_t *); 1392void m_get_msgid(struct msg *, uint32_t *); 1393void m_get_id(struct msg *, uint64_t *); 1394void m_get_sockaddr(struct msg *, struct sockaddr *); 1395void m_get_mailaddr(struct msg *, struct mailaddr *); 1396void m_get_envelope(struct msg *, struct envelope *); 1397void m_get_params(struct msg *, struct dict *); 1398void m_clear_params(struct dict *); 1399 1400 1401/* mta.c */ 1402void mta_postfork(void); 1403void mta_postprivdrop(void); 1404void mta_imsg(struct mproc *, struct imsg *); 1405void mta_route_ok(struct mta_relay *, struct mta_route *); 1406void mta_route_error(struct mta_relay *, struct mta_route *); 1407void mta_route_down(struct mta_relay *, struct mta_route *); 1408void mta_route_collect(struct mta_relay *, struct mta_route *); 1409void mta_source_error(struct mta_relay *, struct mta_route *, const char *); 1410void mta_delivery_log(struct mta_envelope *, const char *, const char *, int, const char *); 1411void mta_delivery_notify(struct mta_envelope *); 1412struct mta_task *mta_route_next_task(struct mta_relay *, struct mta_route *); 1413const char *mta_host_to_text(struct mta_host *); 1414const char *mta_relay_to_text(struct mta_relay *); 1415 1416 1417/* mta_session.c */ 1418void mta_session(struct mta_relay *, struct mta_route *); 1419void mta_session_imsg(struct mproc *, struct imsg *); 1420 1421 1422/* parse.y */ 1423int parse_config(struct smtpd *, const char *, int); 1424int cmdline_symset(char *); 1425 1426 1427/* queue.c */ 1428int queue(void); 1429 1430 1431/* queue_backend.c */ 1432uint32_t queue_generate_msgid(void); 1433uint64_t queue_generate_evpid(uint32_t); 1434int queue_init(const char *, int); 1435int queue_close(void); 1436int queue_message_create(uint32_t *); 1437int queue_message_delete(uint32_t); 1438int queue_message_commit(uint32_t); 1439int queue_message_fd_r(uint32_t); 1440int queue_message_fd_rw(uint32_t); 1441int queue_envelope_create(struct envelope *); 1442int queue_envelope_delete(uint64_t); 1443int queue_envelope_load(uint64_t, struct envelope *); 1444int queue_envelope_update(struct envelope *); 1445int queue_envelope_walk(struct envelope *); 1446int queue_message_walk(struct envelope *, uint32_t, int *, void **); 1447 1448 1449/* ruleset.c */ 1450struct rule *ruleset_match(const struct envelope *); 1451 1452 1453/* scheduler.c */ 1454int scheduler(void); 1455 1456 1457/* scheduler_bakend.c */ 1458struct scheduler_backend *scheduler_backend_lookup(const char *); 1459void scheduler_info(struct scheduler_info *, struct envelope *); 1460 1461 1462/* pony.c */ 1463int pony(void); 1464void pony_imsg(struct mproc *, struct imsg *); 1465 1466 1467/* resolver.c */ 1468void resolver_getaddrinfo(const char *, const char *, const struct addrinfo *, 1469 void(*)(void *, int, struct addrinfo*), void *); 1470void resolver_getnameinfo(const struct sockaddr *, int, 1471 void(*)(void *, int, const char *, const char *), void *); 1472void resolver_dispatch_request(struct mproc *, struct imsg *); 1473void resolver_dispatch_result(struct mproc *, struct imsg *); 1474 1475 1476/* smtp.c */ 1477void smtp_postfork(void); 1478void smtp_postprivdrop(void); 1479void smtp_imsg(struct mproc *, struct imsg *); 1480void smtp_configure(void); 1481void smtp_collect(void); 1482 1483 1484/* smtp_report.c */ 1485void smtp_report_link_connect(uint64_t, const char *, const struct sockaddr_storage *, const struct sockaddr_storage *); 1486void smtp_report_link_disconnect(uint64_t); 1487void smtp_report_link_tls(uint64_t, const char *); 1488void smtp_report_tx_begin(uint64_t, uint32_t); 1489void smtp_report_tx_envelope(uint64_t, uint32_t, uint64_t); 1490void smtp_report_tx_commit(uint64_t, uint32_t, size_t); 1491void smtp_report_tx_rollback(uint64_t); 1492void smtp_report_protocol_client(uint64_t, const char *); 1493void smtp_report_protocol_server(uint64_t, const char *); 1494 1495 1496/* smtp_session.c */ 1497int smtp_session(struct listener *, int, const struct sockaddr_storage *, 1498 const char *, struct io *); 1499void smtp_session_imsg(struct mproc *, struct imsg *); 1500 1501 1502/* smtpf_session.c */ 1503int smtpf_session(struct listener *, int, const struct sockaddr_storage *, 1504 const char *); 1505void smtpf_session_imsg(struct mproc *, struct imsg *); 1506 1507 1508/* smtpd.c */ 1509void imsg_dispatch(struct mproc *, struct imsg *); 1510const char *proc_name(enum smtp_proc_type); 1511const char *proc_title(enum smtp_proc_type); 1512const char *imsg_to_str(int); 1513void log_imsg(int, int, struct imsg *); 1514int fork_proc_backend(const char *, const char *, const char *); 1515 1516 1517/* ssl_smtpd.c */ 1518void *ssl_mta_init(void *, char *, off_t, const char *); 1519void *ssl_smtp_init(void *, int); 1520 1521 1522/* stat_backend.c */ 1523struct stat_backend *stat_backend_lookup(const char *); 1524void stat_increment(const char *, size_t); 1525void stat_decrement(const char *, size_t); 1526void stat_set(const char *, const struct stat_value *); 1527struct stat_value *stat_counter(size_t); 1528struct stat_value *stat_timestamp(time_t); 1529struct stat_value *stat_timeval(struct timeval *); 1530struct stat_value *stat_timespec(struct timespec *); 1531 1532 1533/* table.c */ 1534struct table *table_find(struct smtpd *, const char *, const char *); 1535struct table *table_create(struct smtpd *, const char *, const char *, const char *, 1536 const char *); 1537int table_config(struct table *); 1538int table_open(struct table *); 1539int table_update(struct table *); 1540void table_close(struct table *); 1541int table_check_use(struct table *, uint32_t, uint32_t); 1542int table_check_type(struct table *, uint32_t); 1543int table_check_service(struct table *, uint32_t); 1544int table_lookup(struct table *, struct dict *, const char *, enum table_service, 1545 union lookup *); 1546int table_fetch(struct table *, struct dict *, enum table_service, union lookup *); 1547void table_destroy(struct smtpd *, struct table *); 1548void table_add(struct table *, const char *, const char *); 1549int table_domain_match(const char *, const char *); 1550int table_netaddr_match(const char *, const char *); 1551int table_mailaddr_match(const char *, const char *); 1552int table_regex_match(const char *, const char *); 1553void table_open_all(struct smtpd *); 1554void table_dump_all(struct smtpd *); 1555void table_close_all(struct smtpd *); 1556int table_parse_lookup(enum table_service, const char *, const char *, 1557 union lookup *); 1558 1559 1560/* to.c */ 1561int email_to_mailaddr(struct mailaddr *, char *); 1562int text_to_netaddr(struct netaddr *, const char *); 1563int text_to_mailaddr(struct mailaddr *, const char *); 1564int text_to_relayhost(struct relayhost *, const char *); 1565int text_to_userinfo(struct userinfo *, const char *); 1566int text_to_credentials(struct credentials *, const char *); 1567int text_to_expandnode(struct expandnode *, const char *); 1568uint64_t text_to_evpid(const char *); 1569uint32_t text_to_msgid(const char *); 1570const char *sa_to_text(const struct sockaddr *); 1571const char *ss_to_text(const struct sockaddr_storage *); 1572const char *time_to_text(time_t); 1573const char *duration_to_text(time_t); 1574const char *rule_to_text(struct rule *); 1575const char *sockaddr_to_text(struct sockaddr *); 1576const char *mailaddr_to_text(const struct mailaddr *); 1577const char *expandnode_to_text(struct expandnode *); 1578 1579 1580/* util.c */ 1581typedef struct arglist arglist; 1582struct arglist { 1583 char **list; 1584 uint num; 1585 uint nalloc; 1586}; 1587void addargs(arglist *, char *, ...) 1588 __attribute__((format(printf, 2, 3))); 1589int bsnprintf(char *, size_t, const char *, ...) 1590 __attribute__((format (printf, 3, 4))); 1591int mkdirs(char *, mode_t); 1592int safe_fclose(FILE *); 1593int hostname_match(const char *, const char *); 1594int mailaddr_match(const struct mailaddr *, const struct mailaddr *); 1595int valid_localpart(const char *); 1596int valid_domainpart(const char *); 1597int valid_smtp_response(const char *); 1598int secure_file(int, char *, char *, uid_t, int); 1599int lowercase(char *, const char *, size_t); 1600void xlowercase(char *, const char *, size_t); 1601int uppercase(char *, const char *, size_t); 1602uint64_t generate_uid(void); 1603int availdesc(void); 1604int ckdir(const char *, mode_t, uid_t, gid_t, int); 1605int rmtree(char *, int); 1606int mvpurge(char *, char *); 1607int mktmpfile(void); 1608const char *parse_smtp_response(char *, size_t, char **, int *); 1609int xasprintf(char **, const char *, ...); 1610void *xmalloc(size_t); 1611void *xcalloc(size_t, size_t); 1612char *xstrdup(const char *); 1613void *xmemdup(const void *, size_t); 1614char *strip(char *); 1615int io_xprint(struct io *, const char *); 1616int io_xprintf(struct io *, const char *, ...); 1617void log_envelope(const struct envelope *, const char *, const char *, 1618 const char *); 1619int session_socket_error(int); 1620int getmailname(char *, size_t); 1621int base64_encode(unsigned char const *, size_t, char *, size_t); 1622int base64_decode(char const *, unsigned char *, size_t); 1623 1624void log_trace_verbose(int); 1625void log_trace(int, const char *, ...) 1626 __attribute__((format (printf, 2, 3))); 1627 1628/* waitq.c */ 1629int waitq_wait(void *, void (*)(void *, void *, void *), void *); 1630void waitq_run(void *, void *); 1631 1632 1633/* runq.c */ 1634struct runq; 1635 1636int runq_init(struct runq **, void (*)(struct runq *, void *)); 1637int runq_schedule(struct runq *, time_t, void (*)(struct runq *, void *), void *); 1638int runq_delay(struct runq *, unsigned int, void (*)(struct runq *, void *), void *); 1639int runq_cancel(struct runq *, void (*)(struct runq *, void *), void *); 1640int runq_pending(struct runq *, void (*)(struct runq *, void *), void *, time_t *); 1641int runq_next(struct runq *, void (**)(struct runq *, void *), void **, time_t *); 1642