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