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