smtpd.h revision 1.525
1/* $OpenBSD: smtpd.h,v 1.525 2016/11/25 09:21:21 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 "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 105struct userinfo { 106 char username[SMTPD_VUSERNAME_SIZE]; 107 char directory[PATH_MAX]; 108 uid_t uid; 109 gid_t gid; 110}; 111 112struct netaddr { 113 struct sockaddr_storage ss; 114 int bits; 115}; 116 117struct 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 130struct credentials { 131 char username[LINE_MAX]; 132 char password[LINE_MAX]; 133}; 134 135struct destination { 136 char name[HOST_NAME_MAX+1]; 137}; 138 139struct source { 140 struct sockaddr_storage addr; 141}; 142 143struct addrname { 144 struct sockaddr_storage addr; 145 char name[HOST_NAME_MAX+1]; 146}; 147 148union 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 166enum 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 314enum 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 327enum 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 334struct 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 346struct 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 357enum dest_type { 358 DEST_DOM, 359 DEST_VDOM 360}; 361 362enum 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 373enum decision { 374 R_REJECT, 375 R_ACCEPT 376}; 377 378struct rule { 379 uint64_t r_id; 380 TAILQ_ENTRY(rule) r_entry; 381 enum decision r_decision; 382 uint8_t r_nottag; 383 char r_tag[SMTPD_TAG_SIZE]; 384 385 uint8_t r_notsources; 386 struct table *r_sources; 387 388 uint8_t r_notsenders; 389 struct table *r_senders; 390 391 uint8_t r_notrecipients; 392 struct table *r_recipients; 393 394 uint8_t r_notdestination; 395 enum dest_type r_desttype; 396 struct table *r_destination; 397 398 uint8_t r_wantauth; 399 400 enum action_type r_action; 401 union rule_dest { 402 char buffer[EXPAND_BUFFER]; 403 struct relayhost relayhost; 404 } r_value; 405 406 struct mailaddr *r_as; 407 struct table *r_mapping; 408 struct table *r_userbase; 409 time_t r_qexpire; 410 uint8_t r_forwardonly; 411 char r_delivery_user[LINE_MAX]; 412}; 413 414struct delivery_mda { 415 enum action_type method; 416 char usertable[SMTPD_TABLENAME_SIZE]; 417 char username[SMTPD_VUSERNAME_SIZE]; 418 char buffer[EXPAND_BUFFER]; 419 char delivery_user[SMTPD_VUSERNAME_SIZE]; 420}; 421 422struct delivery_mta { 423 struct relayhost relay; 424}; 425 426enum bounce_type { 427 B_ERROR, 428 B_WARNING, 429 B_DSN 430}; 431 432enum dsn_ret { 433 DSN_RETFULL = 1, 434 DSN_RETHDRS 435}; 436 437struct delivery_bounce { 438 enum bounce_type type; 439 time_t delay; 440 time_t expire; 441 enum dsn_ret dsn_ret; 442 int mta_without_dsn; 443}; 444 445enum expand_type { 446 EXPAND_INVALID, 447 EXPAND_USERNAME, 448 EXPAND_FILENAME, 449 EXPAND_FILTER, 450 EXPAND_INCLUDE, 451 EXPAND_ADDRESS, 452 EXPAND_ERROR, 453 EXPAND_MAILDIR 454}; 455 456struct expandnode { 457 RB_ENTRY(expandnode) entry; 458 TAILQ_ENTRY(expandnode) tq_entry; 459 enum expand_type type; 460 int sameuser; 461 int alias; 462 struct rule *rule; 463 struct expandnode *parent; 464 unsigned int depth; 465 struct table *mapping; 466 struct table *userbase; 467 union { 468 /* 469 * user field handles both expansion user and system user 470 * so we MUST make it large enough to fit a mailaddr user 471 */ 472 char user[SMTPD_MAXLOCALPARTSIZE]; 473 char buffer[EXPAND_BUFFER]; 474 struct mailaddr mailaddr; 475 } u; 476}; 477 478struct expand { 479 RB_HEAD(expandtree, expandnode) tree; 480 TAILQ_HEAD(xnodes, expandnode) *queue; 481 int alias; 482 size_t nb_nodes; 483 struct rule *rule; 484 struct expandnode *parent; 485}; 486 487struct maddrnode { 488 TAILQ_ENTRY(maddrnode) entries; 489 struct mailaddr mailaddr; 490}; 491 492struct maddrmap { 493 TAILQ_HEAD(xmaddr, maddrnode) queue; 494}; 495 496#define DSN_SUCCESS 0x01 497#define DSN_FAILURE 0x02 498#define DSN_DELAY 0x04 499#define DSN_NEVER 0x08 500 501#define DSN_ENVID_LEN 100 502 503#define SMTPD_ENVELOPE_VERSION 2 504struct envelope { 505 TAILQ_ENTRY(envelope) entry; 506 507 char tag[SMTPD_TAG_SIZE]; 508 509 uint32_t version; 510 uint64_t id; 511 enum envelope_flags flags; 512 513 char smtpname[HOST_NAME_MAX+1]; 514 char helo[HOST_NAME_MAX+1]; 515 char hostname[HOST_NAME_MAX+1]; 516 char errorline[LINE_MAX]; 517 struct sockaddr_storage ss; 518 519 struct mailaddr sender; 520 struct mailaddr rcpt; 521 struct mailaddr dest; 522 523 enum delivery_type type; 524 union { 525 struct delivery_mda mda; 526 struct delivery_mta mta; 527 struct delivery_bounce bounce; 528 } agent; 529 530 uint16_t retry; 531 time_t creation; 532 time_t expire; 533 time_t lasttry; 534 time_t nexttry; 535 time_t lastbounce; 536 537 struct mailaddr dsn_orcpt; 538 char dsn_envid[DSN_ENVID_LEN+1]; 539 uint8_t dsn_notify; 540 enum dsn_ret dsn_ret; 541 542 uint8_t esc_class; 543 uint8_t esc_code; 544}; 545 546struct listener { 547 uint16_t flags; 548 int fd; 549 struct sockaddr_storage ss; 550 in_port_t port; 551 struct timeval timeout; 552 struct event ev; 553 char pki_name[PATH_MAX]; 554 char ca_name[PATH_MAX]; 555 char tag[SMTPD_TAG_SIZE]; 556 char filter[PATH_MAX]; 557 char authtable[LINE_MAX]; 558 char hostname[HOST_NAME_MAX+1]; 559 char hostnametable[PATH_MAX]; 560 char sendertable[PATH_MAX]; 561 562 TAILQ_ENTRY(listener) entry; 563 564 int local; /* there must be a better way */ 565}; 566 567struct smtpd { 568 char sc_conffile[PATH_MAX]; 569 size_t sc_maxsize; 570 571#define SMTPD_OPT_VERBOSE 0x00000001 572#define SMTPD_OPT_NOACTION 0x00000002 573 uint32_t sc_opts; 574 575#define SMTPD_EXITING 0x00000001 /* unused */ 576#define SMTPD_MDA_PAUSED 0x00000002 577#define SMTPD_MTA_PAUSED 0x00000004 578#define SMTPD_SMTP_PAUSED 0x00000008 579#define SMTPD_MDA_BUSY 0x00000010 580#define SMTPD_MTA_BUSY 0x00000020 581#define SMTPD_BOUNCE_BUSY 0x00000040 582#define SMTPD_SMTP_DISABLED 0x00000080 583 uint32_t sc_flags; 584 585#define QUEUE_COMPRESSION 0x00000001 586#define QUEUE_ENCRYPTION 0x00000002 587#define QUEUE_EVPCACHE 0x00000004 588 uint32_t sc_queue_flags; 589 char *sc_queue_key; 590 size_t sc_queue_evpcache_size; 591 592 size_t sc_session_max_rcpt; 593 size_t sc_session_max_mails; 594 595 size_t sc_mda_max_session; 596 size_t sc_mda_max_user_session; 597 size_t sc_mda_task_hiwat; 598 size_t sc_mda_task_lowat; 599 size_t sc_mda_task_release; 600 601 size_t sc_mta_max_deferred; 602 603 size_t sc_scheduler_max_inflight; 604 size_t sc_scheduler_max_evp_batch_size; 605 size_t sc_scheduler_max_msg_batch_size; 606 size_t sc_scheduler_max_schedule; 607 608 int sc_qexpire; 609#define MAX_BOUNCE_WARN 4 610 time_t sc_bounce_warn[MAX_BOUNCE_WARN]; 611 char sc_hostname[HOST_NAME_MAX+1]; 612 struct stat_backend *sc_stat; 613 struct compress_backend *sc_comp; 614 615 time_t sc_uptime; 616 617 /* This is a listener for a local socket used by smtp_enqueue(). */ 618 struct listener *sc_sock_listener; 619 620 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 621 622 TAILQ_HEAD(rulelist, rule) *sc_rules; 623 624 struct dict *sc_ca_dict; 625 struct dict *sc_pki_dict; 626 struct dict *sc_ssl_dict; 627 628 struct dict *sc_tables_dict; /* keyed lookup */ 629 630 struct dict *sc_limits_dict; 631 632 struct dict sc_filters; 633 uint32_t filtermask; 634 635 char sc_enqueue_filter[PATH_MAX]; 636 637 char *sc_tls_ciphers; 638 639 char *sc_subaddressing_delim; 640}; 641 642#define TRACE_DEBUG 0x0001 643#define TRACE_IMSG 0x0002 644#define TRACE_IO 0x0004 645#define TRACE_SMTP 0x0008 646#define TRACE_FILTERS 0x0010 647#define TRACE_MTA 0x0020 648#define TRACE_BOUNCE 0x0040 649#define TRACE_SCHEDULER 0x0080 650#define TRACE_LOOKUP 0x0100 651#define TRACE_STAT 0x0200 652#define TRACE_RULES 0x0400 653#define TRACE_MPROC 0x0800 654#define TRACE_EXPAND 0x1000 655#define TRACE_TABLES 0x2000 656#define TRACE_QUEUE 0x4000 657 658#define PROFILE_TOSTAT 0x0001 659#define PROFILE_IMSG 0x0002 660#define PROFILE_QUEUE 0x0004 661 662struct forward_req { 663 uint64_t id; 664 uint8_t status; 665 666 char user[SMTPD_VUSERNAME_SIZE]; 667 uid_t uid; 668 gid_t gid; 669 char directory[PATH_MAX]; 670}; 671 672struct deliver { 673 char to[EXPAND_BUFFER]; 674 char from[SMTPD_MAXMAILADDRSIZE]; 675 char dest[SMTPD_MAXMAILADDRSIZE]; 676 char user[SMTPD_VUSERNAME_SIZE]; 677 short mode; 678 679 struct userinfo userinfo; 680}; 681 682#define MAX_FILTER_PER_CHAIN 16 683struct filter_conf { 684 int chain; 685 int done; 686 int argc; 687 char *name; 688 char *argv[MAX_FILTER_ARGS + 1]; 689 char *path; 690}; 691 692struct mta_host { 693 SPLAY_ENTRY(mta_host) entry; 694 struct sockaddr *sa; 695 char *ptrname; 696 int refcount; 697 size_t nconn; 698 time_t lastconn; 699 time_t lastptrquery; 700 701#define HOST_IGNORE 0x01 702 int flags; 703}; 704 705struct mta_mx { 706 TAILQ_ENTRY(mta_mx) entry; 707 struct mta_host *host; 708 int preference; 709}; 710 711struct mta_domain { 712 SPLAY_ENTRY(mta_domain) entry; 713 char *name; 714 int flags; 715 TAILQ_HEAD(, mta_mx) mxs; 716 int mxstatus; 717 int refcount; 718 size_t nconn; 719 time_t lastconn; 720 time_t lastmxquery; 721}; 722 723struct mta_source { 724 SPLAY_ENTRY(mta_source) entry; 725 struct sockaddr *sa; 726 int refcount; 727 size_t nconn; 728 time_t lastconn; 729}; 730 731struct mta_connector { 732 struct mta_source *source; 733 struct mta_relay *relay; 734 735#define CONNECTOR_ERROR_FAMILY 0x0001 736#define CONNECTOR_ERROR_SOURCE 0x0002 737#define CONNECTOR_ERROR_MX 0x0004 738#define CONNECTOR_ERROR_ROUTE_NET 0x0008 739#define CONNECTOR_ERROR_ROUTE_SMTP 0x0010 740#define CONNECTOR_ERROR_ROUTE 0x0018 741#define CONNECTOR_ERROR_BLOCKED 0x0020 742#define CONNECTOR_ERROR 0x00ff 743 744#define CONNECTOR_LIMIT_HOST 0x0100 745#define CONNECTOR_LIMIT_ROUTE 0x0200 746#define CONNECTOR_LIMIT_SOURCE 0x0400 747#define CONNECTOR_LIMIT_RELAY 0x0800 748#define CONNECTOR_LIMIT_CONN 0x1000 749#define CONNECTOR_LIMIT_DOMAIN 0x2000 750#define CONNECTOR_LIMIT 0xff00 751 752#define CONNECTOR_NEW 0x10000 753#define CONNECTOR_WAIT 0x20000 754 int flags; 755 756 int refcount; 757 size_t nconn; 758 time_t lastconn; 759}; 760 761struct mta_route { 762 SPLAY_ENTRY(mta_route) entry; 763 uint64_t id; 764 struct mta_source *src; 765 struct mta_host *dst; 766#define ROUTE_NEW 0x01 767#define ROUTE_RUNQ 0x02 768#define ROUTE_KEEPALIVE 0x04 769#define ROUTE_DISABLED 0xf0 770#define ROUTE_DISABLED_NET 0x10 771#define ROUTE_DISABLED_SMTP 0x20 772 int flags; 773 int nerror; 774 int penalty; 775 int refcount; 776 size_t nconn; 777 time_t lastconn; 778 time_t lastdisc; 779 time_t lastpenalty; 780}; 781 782struct mta_limits { 783 size_t maxconn_per_host; 784 size_t maxconn_per_route; 785 size_t maxconn_per_source; 786 size_t maxconn_per_connector; 787 size_t maxconn_per_relay; 788 size_t maxconn_per_domain; 789 790 time_t conndelay_host; 791 time_t conndelay_route; 792 time_t conndelay_source; 793 time_t conndelay_connector; 794 time_t conndelay_relay; 795 time_t conndelay_domain; 796 797 time_t discdelay_route; 798 799 size_t max_mail_per_session; 800 time_t sessdelay_transaction; 801 time_t sessdelay_keepalive; 802 803 size_t max_failures_per_session; 804 805 int family; 806 807 int task_hiwat; 808 int task_lowat; 809 int task_release; 810}; 811 812struct mta_relay { 813 SPLAY_ENTRY(mta_relay) entry; 814 uint64_t id; 815 816 struct mta_domain *domain; 817 struct mta_limits *limits; 818 int flags; 819 char *backupname; 820 int backuppref; 821 char *sourcetable; 822 uint16_t port; 823 char *pki_name; 824 char *ca_name; 825 char *authtable; 826 char *authlabel; 827 char *helotable; 828 char *heloname; 829 char *secret; 830 831 int state; 832 size_t ntask; 833 TAILQ_HEAD(, mta_task) tasks; 834 835 struct tree connectors; 836 size_t sourceloop; 837 time_t lastsource; 838 time_t nextsource; 839 840 int fail; 841 char *failstr; 842 843#define RELAY_WAIT_MX 0x01 844#define RELAY_WAIT_PREFERENCE 0x02 845#define RELAY_WAIT_SECRET 0x04 846#define RELAY_WAIT_LIMITS 0x08 847#define RELAY_WAIT_SOURCE 0x10 848#define RELAY_WAIT_CONNECTOR 0x20 849#define RELAY_WAITMASK 0x3f 850 int status; 851 852 int refcount; 853 size_t nconn; 854 size_t nconn_ready; 855 time_t lastconn; 856}; 857 858struct mta_envelope { 859 TAILQ_ENTRY(mta_envelope) entry; 860 uint64_t id; 861 uint64_t session; 862 time_t creation; 863 char *dest; 864 char *rcpt; 865 struct mta_task *task; 866 int delivery; 867 868 int ext; 869 char *dsn_orcpt; 870 char dsn_envid[DSN_ENVID_LEN+1]; 871 uint8_t dsn_notify; 872 enum dsn_ret dsn_ret; 873 874 char status[LINE_MAX]; 875}; 876 877struct mta_task { 878 TAILQ_ENTRY(mta_task) entry; 879 struct mta_relay *relay; 880 uint32_t msgid; 881 TAILQ_HEAD(, mta_envelope) envelopes; 882 char *sender; 883}; 884 885struct passwd; 886 887struct queue_backend { 888 int (*init)(struct passwd *, int, const char *); 889}; 890 891struct compress_backend { 892 size_t (*compress_chunk)(void *, size_t, void *, size_t); 893 size_t (*uncompress_chunk)(void *, size_t, void *, size_t); 894 int (*compress_file)(FILE *, FILE *); 895 int (*uncompress_file)(FILE *, FILE *); 896}; 897 898/* auth structures */ 899enum auth_type { 900 AUTH_BSD, 901 AUTH_PWD, 902}; 903 904struct auth_backend { 905 int (*authenticate)(char *, char *); 906}; 907 908 909/* delivery_backend */ 910struct delivery_backend { 911 int allow_root; 912 void (*open)(struct deliver *); 913}; 914 915struct scheduler_backend { 916 int (*init)(const char *); 917 918 int (*insert)(struct scheduler_info *); 919 size_t (*commit)(uint32_t); 920 size_t (*rollback)(uint32_t); 921 922 int (*update)(struct scheduler_info *); 923 int (*delete)(uint64_t); 924 int (*hold)(uint64_t, uint64_t); 925 int (*release)(int, uint64_t, int); 926 927 int (*batch)(int, int*, size_t*, uint64_t*, int*); 928 929 size_t (*messages)(uint32_t, uint32_t *, size_t); 930 size_t (*envelopes)(uint64_t, struct evpstate *, size_t); 931 int (*schedule)(uint64_t); 932 int (*remove)(uint64_t); 933 int (*suspend)(uint64_t); 934 int (*resume)(uint64_t); 935 int (*query)(uint64_t); 936}; 937 938enum stat_type { 939 STAT_COUNTER, 940 STAT_TIMESTAMP, 941 STAT_TIMEVAL, 942 STAT_TIMESPEC, 943}; 944 945struct stat_value { 946 enum stat_type type; 947 union stat_v { 948 size_t counter; 949 time_t timestamp; 950 struct timeval tv; 951 struct timespec ts; 952 } u; 953}; 954 955#define STAT_KEY_SIZE 1024 956struct stat_kv { 957 void *iter; 958 char key[STAT_KEY_SIZE]; 959 struct stat_value val; 960}; 961 962struct stat_backend { 963 void (*init)(void); 964 void (*close)(void); 965 void (*increment)(const char *, size_t); 966 void (*decrement)(const char *, size_t); 967 void (*set)(const char *, const struct stat_value *); 968 int (*iter)(void **, char **, struct stat_value *); 969}; 970 971struct stat_digest { 972 time_t startup; 973 time_t timestamp; 974 975 size_t clt_connect; 976 size_t clt_disconnect; 977 978 size_t evp_enqueued; 979 size_t evp_dequeued; 980 981 size_t evp_expired; 982 size_t evp_removed; 983 size_t evp_bounce; 984 985 size_t dlv_ok; 986 size_t dlv_permfail; 987 size_t dlv_tempfail; 988 size_t dlv_loop; 989}; 990 991 992struct mproc { 993 pid_t pid; 994 char *name; 995 int proc; 996 void (*handler)(struct mproc *, struct imsg *); 997 struct imsgbuf imsgbuf; 998 999 char *m_buf; 1000 size_t m_alloc; 1001 size_t m_pos; 1002 uint32_t m_type; 1003 uint32_t m_peerid; 1004 pid_t m_pid; 1005 int m_fd; 1006 1007 int enable; 1008 short events; 1009 struct event ev; 1010 void *data; 1011}; 1012 1013struct msg { 1014 const uint8_t *pos; 1015 const uint8_t *end; 1016}; 1017 1018extern enum smtp_proc_type smtpd_process; 1019 1020extern int verbose; 1021extern int foreground_log; 1022extern int profiling; 1023 1024extern struct mproc *p_control; 1025extern struct mproc *p_parent; 1026extern struct mproc *p_lka; 1027extern struct mproc *p_queue; 1028extern struct mproc *p_scheduler; 1029extern struct mproc *p_pony; 1030extern struct mproc *p_ca; 1031 1032extern struct smtpd *env; 1033extern void (*imsg_callback)(struct mproc *, struct imsg *); 1034 1035struct imsgproc { 1036 pid_t pid; 1037 struct event ev; 1038 struct imsgbuf *ibuf; 1039 char *path; 1040 char *name; 1041 void (*cb)(struct imsg *, void *); 1042 void *cb_arg; 1043}; 1044 1045/* inter-process structures */ 1046 1047struct bounce_req_msg { 1048 uint64_t evpid; 1049 time_t timestamp; 1050 struct delivery_bounce bounce; 1051}; 1052 1053enum dns_error { 1054 DNS_OK = 0, 1055 DNS_RETRY, 1056 DNS_EINVAL, 1057 DNS_ENONAME, 1058 DNS_ENOTFOUND, 1059}; 1060 1061enum lka_resp_status { 1062 LKA_OK, 1063 LKA_TEMPFAIL, 1064 LKA_PERMFAIL 1065}; 1066 1067enum ca_resp_status { 1068 CA_OK, 1069 CA_FAIL 1070}; 1071 1072struct ca_cert_req_msg { 1073 uint64_t reqid; 1074 char name[HOST_NAME_MAX+1]; 1075 int fallback; 1076}; 1077 1078struct ca_cert_resp_msg { 1079 uint64_t reqid; 1080 enum ca_resp_status status; 1081 char name[HOST_NAME_MAX+1]; 1082 char *cert; 1083 off_t cert_len; 1084}; 1085 1086struct ca_vrfy_req_msg { 1087 uint64_t reqid; 1088 char name[HOST_NAME_MAX+1]; 1089 int fallback; 1090 unsigned char *cert; 1091 off_t cert_len; 1092 size_t n_chain; 1093 size_t chain_offset; 1094 unsigned char **chain_cert; 1095 off_t *chain_cert_len; 1096}; 1097 1098struct ca_vrfy_resp_msg { 1099 uint64_t reqid; 1100 enum ca_resp_status status; 1101}; 1102 1103struct msg_walkinfo { 1104 struct event ev; 1105 uint32_t msgid; 1106 uint32_t peerid; 1107 size_t n_evp; 1108 void *data; 1109 int done; 1110}; 1111 1112/* aliases.c */ 1113int aliases_get(struct expand *, const char *); 1114int aliases_virtual_get(struct expand *, const struct mailaddr *); 1115int alias_parse(struct expandnode *, const char *); 1116 1117 1118/* auth.c */ 1119struct auth_backend *auth_backend_lookup(enum auth_type); 1120 1121 1122/* bounce.c */ 1123void bounce_add(uint64_t); 1124void bounce_fd(int); 1125 1126 1127/* ca.c */ 1128int ca(void); 1129int ca_X509_verify(void *, void *, const char *, const char *, const char **); 1130void ca_imsg(struct mproc *, struct imsg *); 1131void ca_init(void); 1132void ca_engine_init(void); 1133 1134/* compress_backend.c */ 1135struct compress_backend *compress_backend_lookup(const char *); 1136size_t compress_chunk(void *, size_t, void *, size_t); 1137size_t uncompress_chunk(void *, size_t, void *, size_t); 1138int compress_file(FILE *, FILE *); 1139int uncompress_file(FILE *, FILE *); 1140 1141/* config.c */ 1142#define PURGE_LISTENERS 0x01 1143#define PURGE_TABLES 0x02 1144#define PURGE_RULES 0x04 1145#define PURGE_PKI 0x08 1146#define PURGE_PKI_KEYS 0x10 1147#define PURGE_EVERYTHING 0x0f 1148void purge_config(uint8_t); 1149void config_process(enum smtp_proc_type); 1150void config_peer(enum smtp_proc_type); 1151 1152 1153/* control.c */ 1154int control(void); 1155int control_create_socket(void); 1156 1157 1158/* crypto.c */ 1159int crypto_setup(const char *, size_t); 1160int crypto_encrypt_file(FILE *, FILE *); 1161int crypto_decrypt_file(FILE *, FILE *); 1162size_t crypto_encrypt_buffer(const char *, size_t, char *, size_t); 1163size_t crypto_decrypt_buffer(const char *, size_t, char *, size_t); 1164 1165 1166/* delivery.c */ 1167struct delivery_backend *delivery_backend_lookup(enum action_type); 1168 1169 1170/* dns.c */ 1171void dns_imsg(struct mproc *, struct imsg *); 1172 1173 1174/* enqueue.c */ 1175int enqueue(int, char **, FILE *); 1176 1177 1178/* envelope.c */ 1179void envelope_set_errormsg(struct envelope *, char *, ...); 1180void envelope_set_esc_class(struct envelope *, enum enhanced_status_class); 1181void envelope_set_esc_code(struct envelope *, enum enhanced_status_code); 1182int envelope_load_buffer(struct envelope *, const char *, size_t); 1183int envelope_dump_buffer(const struct envelope *, char *, size_t); 1184 1185 1186/* expand.c */ 1187int expand_cmp(struct expandnode *, struct expandnode *); 1188void expand_insert(struct expand *, struct expandnode *); 1189struct expandnode *expand_lookup(struct expand *, struct expandnode *); 1190void expand_clear(struct expand *); 1191void expand_free(struct expand *); 1192int expand_line(struct expand *, const char *, int); 1193int expand_to_text(struct expand *, char *, size_t); 1194RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1195 1196 1197/* filter.c */ 1198void filter_postfork(void); 1199void filter_configure(void); 1200void filter_connect(uint64_t, const struct sockaddr *, 1201 const struct sockaddr *, const char *, const char *); 1202void filter_mailaddr(uint64_t, int, const struct mailaddr *); 1203void filter_line(uint64_t, int, const char *); 1204void filter_eom(uint64_t, int, size_t); 1205void filter_event(uint64_t, int); 1206void filter_build_fd_chain(uint64_t, int); 1207 1208 1209/* forward.c */ 1210int forwards_get(int, struct expand *); 1211 1212 1213/* imsgproc.c */ 1214void imsgproc_init(void); 1215struct imsgproc *imsgproc_fork(const char *, const char *, 1216 void (*)(struct imsg *, void *), void *); 1217void imsgproc_set_read(struct imsgproc *); 1218void imsgproc_set_write(struct imsgproc *); 1219void imsgproc_set_read_write(struct imsgproc *); 1220void imsgproc_reset_callback(struct imsgproc *, void (*)(struct imsg *, void *), void *); 1221 1222 1223/* limit.c */ 1224void limit_mta_set_defaults(struct mta_limits *); 1225int limit_mta_set(struct mta_limits *, const char*, int64_t); 1226 1227 1228/* lka.c */ 1229int lka(void); 1230 1231 1232/* lka_session.c */ 1233void lka_session(uint64_t, struct envelope *); 1234void lka_session_forward_reply(struct forward_req *, int); 1235 1236 1237/* log.c */ 1238void vlog(int, const char *, va_list); 1239void logit(int, const char *, ...) __attribute__((format (printf, 2, 3))); 1240 1241 1242/* mda.c */ 1243void mda_postfork(void); 1244void mda_postprivdrop(void); 1245void mda_imsg(struct mproc *, struct imsg *); 1246 1247 1248/* makemap.c */ 1249int makemap(int, char **); 1250 1251 1252/* mailaddr.c */ 1253int mailaddr_line(struct maddrmap *, const char *); 1254void maddrmap_init(struct maddrmap *); 1255void maddrmap_insert(struct maddrmap *, struct maddrnode *); 1256void maddrmap_free(struct maddrmap *); 1257 1258 1259/* mproc.c */ 1260int mproc_fork(struct mproc *, const char*, char **); 1261void mproc_init(struct mproc *, int); 1262void mproc_clear(struct mproc *); 1263void mproc_enable(struct mproc *); 1264void mproc_disable(struct mproc *); 1265void mproc_event_add(struct mproc *); 1266void m_compose(struct mproc *, uint32_t, uint32_t, pid_t, int, void *, size_t); 1267void m_composev(struct mproc *, uint32_t, uint32_t, pid_t, int, 1268 const struct iovec *, int); 1269void m_forward(struct mproc *, struct imsg *); 1270void m_create(struct mproc *, uint32_t, uint32_t, pid_t, int); 1271void m_add(struct mproc *, const void *, size_t); 1272void m_add_int(struct mproc *, int); 1273void m_add_u32(struct mproc *, uint32_t); 1274void m_add_size(struct mproc *, size_t); 1275void m_add_time(struct mproc *, time_t); 1276void m_add_string(struct mproc *, const char *); 1277void m_add_data(struct mproc *, const void *, size_t); 1278void m_add_evpid(struct mproc *, uint64_t); 1279void m_add_msgid(struct mproc *, uint32_t); 1280void m_add_id(struct mproc *, uint64_t); 1281void m_add_sockaddr(struct mproc *, const struct sockaddr *); 1282void m_add_mailaddr(struct mproc *, const struct mailaddr *); 1283void m_add_envelope(struct mproc *, const struct envelope *); 1284void m_add_params(struct mproc *, struct dict *); 1285void m_close(struct mproc *); 1286void m_flush(struct mproc *); 1287 1288void m_msg(struct msg *, struct imsg *); 1289int m_is_eom(struct msg *); 1290void m_end(struct msg *); 1291void m_get_int(struct msg *, int *); 1292void m_get_size(struct msg *, size_t *); 1293void m_get_u32(struct msg *, uint32_t *); 1294void m_get_time(struct msg *, time_t *); 1295void m_get_string(struct msg *, const char **); 1296void m_get_data(struct msg *, const void **, size_t *); 1297void m_get_evpid(struct msg *, uint64_t *); 1298void m_get_msgid(struct msg *, uint32_t *); 1299void m_get_id(struct msg *, uint64_t *); 1300void m_get_sockaddr(struct msg *, struct sockaddr *); 1301void m_get_mailaddr(struct msg *, struct mailaddr *); 1302void m_get_envelope(struct msg *, struct envelope *); 1303void m_get_params(struct msg *, struct dict *); 1304void m_clear_params(struct dict *); 1305 1306 1307/* mta.c */ 1308void mta_postfork(void); 1309void mta_postprivdrop(void); 1310void mta_imsg(struct mproc *, struct imsg *); 1311void mta_route_ok(struct mta_relay *, struct mta_route *); 1312void mta_route_error(struct mta_relay *, struct mta_route *); 1313void mta_route_down(struct mta_relay *, struct mta_route *); 1314void mta_route_collect(struct mta_relay *, struct mta_route *); 1315void mta_source_error(struct mta_relay *, struct mta_route *, const char *); 1316void mta_delivery_log(struct mta_envelope *, const char *, const char *, int, const char *); 1317void mta_delivery_notify(struct mta_envelope *); 1318struct mta_task *mta_route_next_task(struct mta_relay *, struct mta_route *); 1319const char *mta_host_to_text(struct mta_host *); 1320const char *mta_relay_to_text(struct mta_relay *); 1321 1322 1323/* mta_session.c */ 1324void mta_session(struct mta_relay *, struct mta_route *); 1325void mta_session_imsg(struct mproc *, struct imsg *); 1326 1327 1328/* parse.y */ 1329int parse_config(struct smtpd *, const char *, int); 1330int cmdline_symset(char *); 1331 1332 1333/* queue.c */ 1334int queue(void); 1335 1336 1337/* queue_backend.c */ 1338uint32_t queue_generate_msgid(void); 1339uint64_t queue_generate_evpid(uint32_t); 1340int queue_init(const char *, int); 1341int queue_close(void); 1342int queue_message_create(uint32_t *); 1343int queue_message_delete(uint32_t); 1344int queue_message_commit(uint32_t); 1345int queue_message_fd_r(uint32_t); 1346int queue_message_fd_rw(uint32_t); 1347int queue_message_corrupt(uint32_t); 1348int queue_message_uncorrupt(uint32_t); 1349int queue_envelope_create(struct envelope *); 1350int queue_envelope_delete(uint64_t); 1351int queue_envelope_load(uint64_t, struct envelope *); 1352int queue_envelope_update(struct envelope *); 1353int queue_envelope_walk(struct envelope *); 1354int queue_message_walk(struct envelope *, uint32_t, int *, void **); 1355 1356 1357/* ruleset.c */ 1358struct rule *ruleset_match(const struct envelope *); 1359 1360 1361/* scheduler.c */ 1362int scheduler(void); 1363 1364 1365/* scheduler_bakend.c */ 1366struct scheduler_backend *scheduler_backend_lookup(const char *); 1367void scheduler_info(struct scheduler_info *, struct envelope *); 1368 1369 1370/* pony.c */ 1371int pony(void); 1372void pony_imsg(struct mproc *, struct imsg *); 1373 1374 1375/* smtp.c */ 1376void smtp_postfork(void); 1377void smtp_postprivdrop(void); 1378void smtp_imsg(struct mproc *, struct imsg *); 1379void smtp_configure(void); 1380void smtp_collect(void); 1381 1382 1383/* smtp_session.c */ 1384int smtp_session(struct listener *, int, const struct sockaddr_storage *, 1385 const char *); 1386void smtp_session_imsg(struct mproc *, struct imsg *); 1387void smtp_filter_response(uint64_t, int, int, uint32_t, const char *); 1388void smtp_filter_fd(uint64_t, int); 1389 1390 1391/* smtpd.c */ 1392void imsg_dispatch(struct mproc *, struct imsg *); 1393const char *proc_name(enum smtp_proc_type); 1394const char *proc_title(enum smtp_proc_type); 1395const char *imsg_to_str(int); 1396void log_imsg(int, int, struct imsg *); 1397int fork_proc_backend(const char *, const char *, const char *); 1398 1399 1400/* ssl_smtpd.c */ 1401void *ssl_mta_init(void *, char *, off_t, const char *); 1402void *ssl_smtp_init(void *, int); 1403 1404 1405/* stat_backend.c */ 1406struct stat_backend *stat_backend_lookup(const char *); 1407void stat_increment(const char *, size_t); 1408void stat_decrement(const char *, size_t); 1409void stat_set(const char *, const struct stat_value *); 1410struct stat_value *stat_counter(size_t); 1411struct stat_value *stat_timestamp(time_t); 1412struct stat_value *stat_timeval(struct timeval *); 1413struct stat_value *stat_timespec(struct timespec *); 1414 1415 1416/* table.c */ 1417struct table *table_find(const char *, const char *); 1418struct table *table_create(const char *, const char *, const char *, 1419 const char *); 1420int table_config(struct table *); 1421int table_open(struct table *); 1422int table_update(struct table *); 1423void table_close(struct table *); 1424int table_check_use(struct table *, uint32_t, uint32_t); 1425int table_check_type(struct table *, uint32_t); 1426int table_check_service(struct table *, uint32_t); 1427int table_lookup(struct table *, struct dict *, const char *, enum table_service, 1428 union lookup *); 1429int table_fetch(struct table *, struct dict *, enum table_service, union lookup *); 1430void table_destroy(struct table *); 1431void table_add(struct table *, const char *, const char *); 1432int table_domain_match(const char *, const char *); 1433int table_netaddr_match(const char *, const char *); 1434int table_mailaddr_match(const char *, const char *); 1435void table_open_all(void); 1436void table_dump_all(void); 1437void table_close_all(void); 1438int table_parse_lookup(enum table_service, const char *, const char *, 1439 union lookup *); 1440 1441 1442/* to.c */ 1443int email_to_mailaddr(struct mailaddr *, char *); 1444int text_to_netaddr(struct netaddr *, const char *); 1445int text_to_mailaddr(struct mailaddr *, const char *); 1446int text_to_relayhost(struct relayhost *, const char *); 1447int text_to_userinfo(struct userinfo *, const char *); 1448int text_to_credentials(struct credentials *, const char *); 1449int text_to_expandnode(struct expandnode *, const char *); 1450uint64_t text_to_evpid(const char *); 1451uint32_t text_to_msgid(const char *); 1452const char *sa_to_text(const struct sockaddr *); 1453const char *ss_to_text(const struct sockaddr_storage *); 1454const char *time_to_text(time_t); 1455const char *duration_to_text(time_t); 1456const char *relayhost_to_text(const struct relayhost *); 1457const char *rule_to_text(struct rule *); 1458const char *sockaddr_to_text(struct sockaddr *); 1459const char *mailaddr_to_text(const struct mailaddr *); 1460const char *expandnode_to_text(struct expandnode *); 1461 1462 1463/* util.c */ 1464typedef struct arglist arglist; 1465struct arglist { 1466 char **list; 1467 uint num; 1468 uint nalloc; 1469}; 1470void addargs(arglist *, char *, ...) 1471 __attribute__((format(printf, 2, 3))); 1472int bsnprintf(char *, size_t, const char *, ...) 1473 __attribute__((format (printf, 3, 4))); 1474int mkdirs(char *, mode_t); 1475int safe_fclose(FILE *); 1476int hostname_match(const char *, const char *); 1477int mailaddr_match(const struct mailaddr *, const struct mailaddr *); 1478int valid_localpart(const char *); 1479int valid_domainpart(const char *); 1480int secure_file(int, char *, char *, uid_t, int); 1481int lowercase(char *, const char *, size_t); 1482void xlowercase(char *, const char *, size_t); 1483int uppercase(char *, const char *, size_t); 1484uint64_t generate_uid(void); 1485int availdesc(void); 1486int ckdir(const char *, mode_t, uid_t, gid_t, int); 1487int rmtree(char *, int); 1488int mvpurge(char *, char *); 1489int mktmpfile(void); 1490const char *parse_smtp_response(char *, size_t, char **, int *); 1491void *xmalloc(size_t, const char *); 1492void *xcalloc(size_t, size_t, const char *); 1493char *xstrdup(const char *, const char *); 1494void *xmemdup(const void *, size_t, const char *); 1495char *strip(char *); 1496void iobuf_xinit(struct iobuf *, size_t, size_t, const char *); 1497void iobuf_xfqueue(struct iobuf *, const char *, const char *, ...); 1498int io_xprint(struct io *, const char *); 1499int io_xprintf(struct io *, const char *, ...); 1500void log_envelope(const struct envelope *, const char *, const char *, 1501 const char *); 1502int session_socket_error(int); 1503int getmailname(char *, size_t); 1504int base64_encode(unsigned char const *, size_t, char *, size_t); 1505int base64_decode(char const *, unsigned char *, size_t); 1506 1507 1508/* waitq.c */ 1509int waitq_wait(void *, void (*)(void *, void *, void *), void *); 1510void waitq_run(void *, void *); 1511 1512 1513/* runq.c */ 1514struct runq; 1515 1516int runq_init(struct runq **, void (*)(struct runq *, void *)); 1517int runq_schedule(struct runq *, time_t, void (*)(struct runq *, void *), void *); 1518int runq_delay(struct runq *, unsigned int, void (*)(struct runq *, void *), void *); 1519int runq_cancel(struct runq *, void (*)(struct runq *, void *), void *); 1520int runq_pending(struct runq *, void (*)(struct runq *, void *), void *, time_t *); 1521int runq_next(struct runq *, void (**)(struct runq *, void *), void **, time_t *); 1522