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