smtpd.h revision 1.518
1/* $OpenBSD: smtpd.h,v 1.518 2016/08/31 15:24:04 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 14 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_SHUTDOWN, 199 IMSG_CTL_TRACE_DISABLE, 200 IMSG_CTL_TRACE_ENABLE, 201 IMSG_CTL_UPDATE_TABLE, 202 IMSG_CTL_VERBOSE, 203 IMSG_CTL_DISCOVER_EVPID, 204 IMSG_CTL_DISCOVER_MSGID, 205 IMSG_CTL_UNCORRUPT_MSGID, 206 207 IMSG_CTL_SMTP_SESSION, 208 209 IMSG_SETUP_KEY, 210 IMSG_SETUP_PEER, 211 IMSG_SETUP_DONE, 212 213 IMSG_CONF_START, 214 IMSG_CONF_END, 215 216 IMSG_STAT_INCREMENT, 217 IMSG_STAT_DECREMENT, 218 IMSG_STAT_SET, 219 220 IMSG_LKA_AUTHENTICATE, 221 IMSG_LKA_OPEN_FORWARD, 222 IMSG_LKA_ENVELOPE_SUBMIT, 223 IMSG_LKA_ENVELOPE_COMMIT, 224 225 IMSG_QUEUE_DELIVER, 226 IMSG_QUEUE_DELIVERY_OK, 227 IMSG_QUEUE_DELIVERY_TEMPFAIL, 228 IMSG_QUEUE_DELIVERY_PERMFAIL, 229 IMSG_QUEUE_DELIVERY_LOOP, 230 IMSG_QUEUE_DISCOVER_EVPID, 231 IMSG_QUEUE_DISCOVER_MSGID, 232 IMSG_QUEUE_ENVELOPE_ACK, 233 IMSG_QUEUE_ENVELOPE_COMMIT, 234 IMSG_QUEUE_ENVELOPE_REMOVE, 235 IMSG_QUEUE_ENVELOPE_SCHEDULE, 236 IMSG_QUEUE_ENVELOPE_SUBMIT, 237 IMSG_QUEUE_HOLDQ_HOLD, 238 IMSG_QUEUE_HOLDQ_RELEASE, 239 IMSG_QUEUE_MESSAGE_COMMIT, 240 IMSG_QUEUE_MESSAGE_ROLLBACK, 241 IMSG_QUEUE_SMTP_SESSION, 242 IMSG_QUEUE_TRANSFER, 243 244 IMSG_MDA_DELIVERY_OK, 245 IMSG_MDA_DELIVERY_TEMPFAIL, 246 IMSG_MDA_DELIVERY_PERMFAIL, 247 IMSG_MDA_DELIVERY_LOOP, 248 IMSG_MDA_DELIVERY_HOLD, 249 IMSG_MDA_DONE, 250 IMSG_MDA_FORK, 251 IMSG_MDA_HOLDQ_RELEASE, 252 IMSG_MDA_LOOKUP_USERINFO, 253 IMSG_MDA_KILL, 254 IMSG_MDA_OPEN_MESSAGE, 255 256 IMSG_MFA_SMTP_RESPONSE, 257 258 IMSG_MTA_DELIVERY_OK, 259 IMSG_MTA_DELIVERY_TEMPFAIL, 260 IMSG_MTA_DELIVERY_PERMFAIL, 261 IMSG_MTA_DELIVERY_LOOP, 262 IMSG_MTA_DELIVERY_HOLD, 263 IMSG_MTA_DNS_HOST, 264 IMSG_MTA_DNS_HOST_END, 265 IMSG_MTA_DNS_PTR, 266 IMSG_MTA_DNS_MX, 267 IMSG_MTA_DNS_MX_PREFERENCE, 268 IMSG_MTA_HOLDQ_RELEASE, 269 IMSG_MTA_LOOKUP_CREDENTIALS, 270 IMSG_MTA_LOOKUP_SOURCE, 271 IMSG_MTA_LOOKUP_HELO, 272 IMSG_MTA_OPEN_MESSAGE, 273 IMSG_MTA_SCHEDULE, 274 IMSG_MTA_TLS_INIT, 275 IMSG_MTA_TLS_VERIFY_CERT, 276 IMSG_MTA_TLS_VERIFY_CHAIN, 277 IMSG_MTA_TLS_VERIFY, 278 279 IMSG_SCHED_ENVELOPE_BOUNCE, 280 IMSG_SCHED_ENVELOPE_DELIVER, 281 IMSG_SCHED_ENVELOPE_EXPIRE, 282 IMSG_SCHED_ENVELOPE_INJECT, 283 IMSG_SCHED_ENVELOPE_REMOVE, 284 IMSG_SCHED_ENVELOPE_TRANSFER, 285 286 IMSG_SMTP_AUTHENTICATE, 287 IMSG_SMTP_DNS_PTR, 288 IMSG_SMTP_MESSAGE_COMMIT, 289 IMSG_SMTP_MESSAGE_CREATE, 290 IMSG_SMTP_MESSAGE_ROLLBACK, 291 IMSG_SMTP_MESSAGE_OPEN, 292 IMSG_SMTP_CHECK_SENDER, 293 IMSG_SMTP_EXPAND_RCPT, 294 IMSG_SMTP_LOOKUP_HELO, 295 IMSG_SMTP_TLS_INIT, 296 IMSG_SMTP_TLS_VERIFY_CERT, 297 IMSG_SMTP_TLS_VERIFY_CHAIN, 298 IMSG_SMTP_TLS_VERIFY, 299 300 IMSG_SMTP_REQ_CONNECT, 301 IMSG_SMTP_REQ_HELO, 302 IMSG_SMTP_REQ_MAIL, 303 IMSG_SMTP_REQ_RCPT, 304 IMSG_SMTP_REQ_DATA, 305 IMSG_SMTP_REQ_EOM, 306 IMSG_SMTP_EVENT_RSET, 307 IMSG_SMTP_EVENT_COMMIT, 308 IMSG_SMTP_EVENT_ROLLBACK, 309 IMSG_SMTP_EVENT_DISCONNECT, 310 311 IMSG_CA_PRIVENC, 312 IMSG_CA_PRIVDEC 313}; 314 315enum smtp_proc_type { 316 PROC_PARENT = 0, 317 PROC_LKA, 318 PROC_QUEUE, 319 PROC_CONTROL, 320 PROC_SCHEDULER, 321 PROC_PONY, 322 PROC_CA, 323 324 PROC_FILTER, 325 PROC_CLIENT, 326}; 327 328enum table_type { 329 T_NONE = 0, 330 T_DYNAMIC = 0x01, /* table with external source */ 331 T_LIST = 0x02, /* table holding a list */ 332 T_HASH = 0x04, /* table holding a hash table */ 333}; 334 335struct table { 336 char t_name[LINE_MAX]; 337 enum table_type t_type; 338 char t_config[PATH_MAX]; 339 340 struct dict t_dict; 341 342 void *t_handle; 343 struct table_backend *t_backend; 344 void *t_iter; 345}; 346 347struct table_backend { 348 const unsigned int services; 349 int (*config)(struct table *); 350 void *(*open)(struct table *); 351 int (*update)(struct table *); 352 void (*close)(void *); 353 int (*lookup)(void *, struct dict *, const char *, enum table_service, union lookup *); 354 int (*fetch)(void *, struct dict *, enum table_service, union lookup *); 355}; 356 357 358enum dest_type { 359 DEST_DOM, 360 DEST_VDOM 361}; 362 363enum action_type { 364 A_NONE, 365 A_RELAY, 366 A_RELAYVIA, 367 A_MAILDIR, 368 A_MBOX, 369 A_FILENAME, 370 A_MDA, 371 A_LMTP 372}; 373 374enum decision { 375 R_REJECT, 376 R_ACCEPT 377}; 378 379struct rule { 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 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#define PROFILE_BUFFERS 0x0008 662 663struct forward_req { 664 uint64_t id; 665 uint8_t status; 666 667 char user[SMTPD_VUSERNAME_SIZE]; 668 uid_t uid; 669 gid_t gid; 670 char directory[PATH_MAX]; 671}; 672 673struct deliver { 674 char to[EXPAND_BUFFER]; 675 char from[SMTPD_MAXMAILADDRSIZE]; 676 char dest[SMTPD_MAXMAILADDRSIZE]; 677 char user[SMTPD_VUSERNAME_SIZE]; 678 short mode; 679 680 struct userinfo userinfo; 681}; 682 683#define MAX_FILTER_PER_CHAIN 16 684struct filter_conf { 685 int chain; 686 int done; 687 int argc; 688 char *name; 689 char *argv[MAX_FILTER_ARGS + 1]; 690 char *path; 691}; 692 693struct mta_host { 694 SPLAY_ENTRY(mta_host) entry; 695 struct sockaddr *sa; 696 char *ptrname; 697 int refcount; 698 size_t nconn; 699 time_t lastconn; 700 time_t lastptrquery; 701 702#define HOST_IGNORE 0x01 703 int flags; 704}; 705 706struct mta_mx { 707 TAILQ_ENTRY(mta_mx) entry; 708 struct mta_host *host; 709 int preference; 710}; 711 712struct mta_domain { 713 SPLAY_ENTRY(mta_domain) entry; 714 char *name; 715 int flags; 716 TAILQ_HEAD(, mta_mx) mxs; 717 int mxstatus; 718 int refcount; 719 size_t nconn; 720 time_t lastconn; 721 time_t lastmxquery; 722}; 723 724struct mta_source { 725 SPLAY_ENTRY(mta_source) entry; 726 struct sockaddr *sa; 727 int refcount; 728 size_t nconn; 729 time_t lastconn; 730}; 731 732struct mta_connector { 733 struct mta_source *source; 734 struct mta_relay *relay; 735 736#define CONNECTOR_ERROR_FAMILY 0x0001 737#define CONNECTOR_ERROR_SOURCE 0x0002 738#define CONNECTOR_ERROR_MX 0x0004 739#define CONNECTOR_ERROR_ROUTE_NET 0x0008 740#define CONNECTOR_ERROR_ROUTE_SMTP 0x0010 741#define CONNECTOR_ERROR_ROUTE 0x0018 742#define CONNECTOR_ERROR_BLOCKED 0x0020 743#define CONNECTOR_ERROR 0x00ff 744 745#define CONNECTOR_LIMIT_HOST 0x0100 746#define CONNECTOR_LIMIT_ROUTE 0x0200 747#define CONNECTOR_LIMIT_SOURCE 0x0400 748#define CONNECTOR_LIMIT_RELAY 0x0800 749#define CONNECTOR_LIMIT_CONN 0x1000 750#define CONNECTOR_LIMIT_DOMAIN 0x2000 751#define CONNECTOR_LIMIT 0xff00 752 753#define CONNECTOR_NEW 0x10000 754#define CONNECTOR_WAIT 0x20000 755 int flags; 756 757 int refcount; 758 size_t nconn; 759 time_t lastconn; 760}; 761 762struct mta_route { 763 SPLAY_ENTRY(mta_route) entry; 764 uint64_t id; 765 struct mta_source *src; 766 struct mta_host *dst; 767#define ROUTE_NEW 0x01 768#define ROUTE_RUNQ 0x02 769#define ROUTE_KEEPALIVE 0x04 770#define ROUTE_DISABLED 0xf0 771#define ROUTE_DISABLED_NET 0x10 772#define ROUTE_DISABLED_SMTP 0x20 773 int flags; 774 int nerror; 775 int penalty; 776 int refcount; 777 size_t nconn; 778 time_t lastconn; 779 time_t lastdisc; 780 time_t lastpenalty; 781}; 782 783struct mta_limits { 784 size_t maxconn_per_host; 785 size_t maxconn_per_route; 786 size_t maxconn_per_source; 787 size_t maxconn_per_connector; 788 size_t maxconn_per_relay; 789 size_t maxconn_per_domain; 790 791 time_t conndelay_host; 792 time_t conndelay_route; 793 time_t conndelay_source; 794 time_t conndelay_connector; 795 time_t conndelay_relay; 796 time_t conndelay_domain; 797 798 time_t discdelay_route; 799 800 size_t max_mail_per_session; 801 time_t sessdelay_transaction; 802 time_t sessdelay_keepalive; 803 804 size_t max_failures_per_session; 805 806 int family; 807 808 int task_hiwat; 809 int task_lowat; 810 int task_release; 811}; 812 813struct mta_relay { 814 SPLAY_ENTRY(mta_relay) entry; 815 uint64_t id; 816 817 struct mta_domain *domain; 818 struct mta_limits *limits; 819 int flags; 820 char *backupname; 821 int backuppref; 822 char *sourcetable; 823 uint16_t port; 824 char *pki_name; 825 char *ca_name; 826 char *authtable; 827 char *authlabel; 828 char *helotable; 829 char *heloname; 830 char *secret; 831 832 int state; 833 size_t ntask; 834 TAILQ_HEAD(, mta_task) tasks; 835 836 struct tree connectors; 837 size_t sourceloop; 838 time_t lastsource; 839 time_t nextsource; 840 841 int fail; 842 char *failstr; 843 844#define RELAY_WAIT_MX 0x01 845#define RELAY_WAIT_PREFERENCE 0x02 846#define RELAY_WAIT_SECRET 0x04 847#define RELAY_WAIT_LIMITS 0x08 848#define RELAY_WAIT_SOURCE 0x10 849#define RELAY_WAIT_CONNECTOR 0x20 850#define RELAY_WAITMASK 0x3f 851 int status; 852 853 int refcount; 854 size_t nconn; 855 size_t nconn_ready; 856 time_t lastconn; 857}; 858 859struct mta_envelope { 860 TAILQ_ENTRY(mta_envelope) entry; 861 uint64_t id; 862 uint64_t session; 863 time_t creation; 864 char *dest; 865 char *rcpt; 866 struct mta_task *task; 867 int delivery; 868 869 int ext; 870 char *dsn_orcpt; 871 char dsn_envid[DSN_ENVID_LEN+1]; 872 uint8_t dsn_notify; 873 enum dsn_ret dsn_ret; 874 875 char status[LINE_MAX]; 876}; 877 878struct mta_task { 879 TAILQ_ENTRY(mta_task) entry; 880 struct mta_relay *relay; 881 uint32_t msgid; 882 TAILQ_HEAD(, mta_envelope) envelopes; 883 char *sender; 884}; 885 886struct passwd; 887 888struct queue_backend { 889 int (*init)(struct passwd *, int, const char *); 890}; 891 892struct compress_backend { 893 size_t (*compress_chunk)(void *, size_t, void *, size_t); 894 size_t (*uncompress_chunk)(void *, size_t, void *, size_t); 895 int (*compress_file)(FILE *, FILE *); 896 int (*uncompress_file)(FILE *, FILE *); 897}; 898 899/* auth structures */ 900enum auth_type { 901 AUTH_BSD, 902 AUTH_PWD, 903}; 904 905struct auth_backend { 906 int (*authenticate)(char *, char *); 907}; 908 909 910/* delivery_backend */ 911struct delivery_backend { 912 int allow_root; 913 void (*open)(struct deliver *); 914}; 915 916struct scheduler_backend { 917 int (*init)(const char *); 918 919 int (*insert)(struct scheduler_info *); 920 size_t (*commit)(uint32_t); 921 size_t (*rollback)(uint32_t); 922 923 int (*update)(struct scheduler_info *); 924 int (*delete)(uint64_t); 925 int (*hold)(uint64_t, uint64_t); 926 int (*release)(int, uint64_t, int); 927 928 int (*batch)(int, int*, size_t*, uint64_t*, int*); 929 930 size_t (*messages)(uint32_t, uint32_t *, size_t); 931 size_t (*envelopes)(uint64_t, struct evpstate *, size_t); 932 int (*schedule)(uint64_t); 933 int (*remove)(uint64_t); 934 int (*suspend)(uint64_t); 935 int (*resume)(uint64_t); 936 int (*query)(uint64_t); 937}; 938 939enum stat_type { 940 STAT_COUNTER, 941 STAT_TIMESTAMP, 942 STAT_TIMEVAL, 943 STAT_TIMESPEC, 944}; 945 946struct stat_value { 947 enum stat_type type; 948 union stat_v { 949 size_t counter; 950 time_t timestamp; 951 struct timeval tv; 952 struct timespec ts; 953 } u; 954}; 955 956#define STAT_KEY_SIZE 1024 957struct stat_kv { 958 void *iter; 959 char key[STAT_KEY_SIZE]; 960 struct stat_value val; 961}; 962 963struct stat_backend { 964 void (*init)(void); 965 void (*close)(void); 966 void (*increment)(const char *, size_t); 967 void (*decrement)(const char *, size_t); 968 void (*set)(const char *, const struct stat_value *); 969 int (*iter)(void **, char **, struct stat_value *); 970}; 971 972struct stat_digest { 973 time_t startup; 974 time_t timestamp; 975 976 size_t clt_connect; 977 size_t clt_disconnect; 978 979 size_t evp_enqueued; 980 size_t evp_dequeued; 981 982 size_t evp_expired; 983 size_t evp_removed; 984 size_t evp_bounce; 985 986 size_t dlv_ok; 987 size_t dlv_permfail; 988 size_t dlv_tempfail; 989 size_t dlv_loop; 990}; 991 992 993struct mproc { 994 pid_t pid; 995 char *name; 996 int proc; 997 void (*handler)(struct mproc *, struct imsg *); 998 struct imsgbuf imsgbuf; 999 1000 char *m_buf; 1001 size_t m_alloc; 1002 size_t m_pos; 1003 uint32_t m_type; 1004 uint32_t m_peerid; 1005 pid_t m_pid; 1006 int m_fd; 1007 1008 int enable; 1009 short events; 1010 struct event ev; 1011 void *data; 1012 1013 off_t msg_in; 1014 off_t msg_out; 1015 off_t bytes_in; 1016 off_t bytes_out; 1017 size_t bytes_queued; 1018 size_t bytes_queued_max; 1019}; 1020 1021struct msg { 1022 const uint8_t *pos; 1023 const uint8_t *end; 1024}; 1025 1026extern enum smtp_proc_type smtpd_process; 1027 1028extern int verbose; 1029extern int foreground_log; 1030extern int profiling; 1031 1032extern struct mproc *p_control; 1033extern struct mproc *p_parent; 1034extern struct mproc *p_lka; 1035extern struct mproc *p_queue; 1036extern struct mproc *p_scheduler; 1037extern struct mproc *p_pony; 1038extern struct mproc *p_ca; 1039 1040extern struct smtpd *env; 1041extern void (*imsg_callback)(struct mproc *, struct imsg *); 1042 1043struct imsgproc { 1044 pid_t pid; 1045 struct event ev; 1046 struct imsgbuf *ibuf; 1047 char *path; 1048 char *name; 1049 void (*cb)(struct imsg *, void *); 1050 void *cb_arg; 1051}; 1052 1053/* inter-process structures */ 1054 1055struct bounce_req_msg { 1056 uint64_t evpid; 1057 time_t timestamp; 1058 struct delivery_bounce bounce; 1059}; 1060 1061enum dns_error { 1062 DNS_OK = 0, 1063 DNS_RETRY, 1064 DNS_EINVAL, 1065 DNS_ENONAME, 1066 DNS_ENOTFOUND, 1067}; 1068 1069enum lka_resp_status { 1070 LKA_OK, 1071 LKA_TEMPFAIL, 1072 LKA_PERMFAIL 1073}; 1074 1075enum ca_resp_status { 1076 CA_OK, 1077 CA_FAIL 1078}; 1079 1080struct ca_cert_req_msg { 1081 uint64_t reqid; 1082 char name[HOST_NAME_MAX+1]; 1083 int fallback; 1084}; 1085 1086struct ca_cert_resp_msg { 1087 uint64_t reqid; 1088 enum ca_resp_status status; 1089 char name[HOST_NAME_MAX+1]; 1090 char *cert; 1091 off_t cert_len; 1092}; 1093 1094struct ca_vrfy_req_msg { 1095 uint64_t reqid; 1096 char name[HOST_NAME_MAX+1]; 1097 int fallback; 1098 unsigned char *cert; 1099 off_t cert_len; 1100 size_t n_chain; 1101 size_t chain_offset; 1102 unsigned char **chain_cert; 1103 off_t *chain_cert_len; 1104}; 1105 1106struct ca_vrfy_resp_msg { 1107 uint64_t reqid; 1108 enum ca_resp_status status; 1109}; 1110 1111struct msg_walkinfo { 1112 struct event ev; 1113 uint32_t msgid; 1114 uint32_t peerid; 1115 size_t n_evp; 1116 void *data; 1117 int done; 1118}; 1119 1120/* aliases.c */ 1121int aliases_get(struct expand *, const char *); 1122int aliases_virtual_get(struct expand *, const struct mailaddr *); 1123int alias_parse(struct expandnode *, const char *); 1124 1125 1126/* auth.c */ 1127struct auth_backend *auth_backend_lookup(enum auth_type); 1128 1129 1130/* bounce.c */ 1131void bounce_add(uint64_t); 1132void bounce_fd(int); 1133 1134 1135/* ca.c */ 1136int ca(void); 1137int ca_X509_verify(void *, void *, const char *, const char *, const char **); 1138void ca_imsg(struct mproc *, struct imsg *); 1139void ca_init(void); 1140void ca_engine_init(void); 1141 1142/* compress_backend.c */ 1143struct compress_backend *compress_backend_lookup(const char *); 1144size_t compress_chunk(void *, size_t, void *, size_t); 1145size_t uncompress_chunk(void *, size_t, void *, size_t); 1146int compress_file(FILE *, FILE *); 1147int uncompress_file(FILE *, FILE *); 1148 1149/* config.c */ 1150#define PURGE_LISTENERS 0x01 1151#define PURGE_TABLES 0x02 1152#define PURGE_RULES 0x04 1153#define PURGE_PKI 0x08 1154#define PURGE_PKI_KEYS 0x10 1155#define PURGE_EVERYTHING 0x0f 1156void purge_config(uint8_t); 1157void config_process(enum smtp_proc_type); 1158void config_peer(enum smtp_proc_type); 1159void config_done(void); 1160 1161 1162/* control.c */ 1163int control(void); 1164int control_create_socket(void); 1165 1166 1167/* crypto.c */ 1168int crypto_setup(const char *, size_t); 1169int crypto_encrypt_file(FILE *, FILE *); 1170int crypto_decrypt_file(FILE *, FILE *); 1171size_t crypto_encrypt_buffer(const char *, size_t, char *, size_t); 1172size_t crypto_decrypt_buffer(const char *, size_t, char *, size_t); 1173 1174 1175/* delivery.c */ 1176struct delivery_backend *delivery_backend_lookup(enum action_type); 1177 1178 1179/* dns.c */ 1180void dns_imsg(struct mproc *, struct imsg *); 1181 1182 1183/* enqueue.c */ 1184int enqueue(int, char **, FILE *); 1185 1186 1187/* envelope.c */ 1188void envelope_set_errormsg(struct envelope *, char *, ...); 1189void envelope_set_esc_class(struct envelope *, enum enhanced_status_class); 1190void envelope_set_esc_code(struct envelope *, enum enhanced_status_code); 1191int envelope_load_buffer(struct envelope *, const char *, size_t); 1192int envelope_dump_buffer(const struct envelope *, char *, size_t); 1193 1194 1195/* expand.c */ 1196int expand_cmp(struct expandnode *, struct expandnode *); 1197void expand_insert(struct expand *, struct expandnode *); 1198struct expandnode *expand_lookup(struct expand *, struct expandnode *); 1199void expand_clear(struct expand *); 1200void expand_free(struct expand *); 1201int expand_line(struct expand *, const char *, int); 1202int expand_to_text(struct expand *, char *, size_t); 1203RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1204 1205 1206/* filter.c */ 1207void filter_postfork(void); 1208void filter_configure(void); 1209void filter_connect(uint64_t, const struct sockaddr *, 1210 const struct sockaddr *, const char *, const char *); 1211void filter_mailaddr(uint64_t, int, const struct mailaddr *); 1212void filter_line(uint64_t, int, const char *); 1213void filter_eom(uint64_t, int, size_t); 1214void filter_event(uint64_t, int); 1215void filter_build_fd_chain(uint64_t, int); 1216 1217 1218/* forward.c */ 1219int forwards_get(int, struct expand *); 1220 1221 1222/* imsgproc.c */ 1223void imsgproc_init(void); 1224struct imsgproc *imsgproc_fork(const char *, const char *, 1225 void (*)(struct imsg *, void *), void *); 1226void imsgproc_set_read(struct imsgproc *); 1227void imsgproc_set_write(struct imsgproc *); 1228void imsgproc_set_read_write(struct imsgproc *); 1229void imsgproc_reset_callback(struct imsgproc *, void (*)(struct imsg *, void *), void *); 1230 1231 1232/* limit.c */ 1233void limit_mta_set_defaults(struct mta_limits *); 1234int limit_mta_set(struct mta_limits *, const char*, int64_t); 1235 1236 1237/* lka.c */ 1238int lka(void); 1239 1240 1241/* lka_session.c */ 1242void lka_session(uint64_t, struct envelope *); 1243void lka_session_forward_reply(struct forward_req *, int); 1244 1245 1246/* log.c */ 1247void vlog(int, const char *, va_list); 1248void logit(int, const char *, ...) __attribute__((format (printf, 2, 3))); 1249 1250 1251/* mda.c */ 1252void mda_postfork(void); 1253void mda_postprivdrop(void); 1254void mda_imsg(struct mproc *, struct imsg *); 1255 1256 1257/* makemap.c */ 1258int makemap(int, char **); 1259 1260 1261/* mailaddr.c */ 1262int mailaddr_line(struct maddrmap *, const char *); 1263void maddrmap_init(struct maddrmap *); 1264void maddrmap_insert(struct maddrmap *, struct maddrnode *); 1265void maddrmap_free(struct maddrmap *); 1266 1267 1268/* mproc.c */ 1269int mproc_fork(struct mproc *, const char*, char **); 1270void mproc_init(struct mproc *, int); 1271void mproc_clear(struct mproc *); 1272void mproc_enable(struct mproc *); 1273void mproc_disable(struct mproc *); 1274void mproc_event_add(struct mproc *); 1275void m_compose(struct mproc *, uint32_t, uint32_t, pid_t, int, void *, size_t); 1276void m_composev(struct mproc *, uint32_t, uint32_t, pid_t, int, 1277 const struct iovec *, int); 1278void m_forward(struct mproc *, struct imsg *); 1279void m_create(struct mproc *, uint32_t, uint32_t, pid_t, int); 1280void m_add(struct mproc *, const void *, size_t); 1281void m_add_int(struct mproc *, int); 1282void m_add_u32(struct mproc *, uint32_t); 1283void m_add_size(struct mproc *, size_t); 1284void m_add_time(struct mproc *, time_t); 1285void m_add_string(struct mproc *, const char *); 1286void m_add_data(struct mproc *, const void *, size_t); 1287void m_add_evpid(struct mproc *, uint64_t); 1288void m_add_msgid(struct mproc *, uint32_t); 1289void m_add_id(struct mproc *, uint64_t); 1290void m_add_sockaddr(struct mproc *, const struct sockaddr *); 1291void m_add_mailaddr(struct mproc *, const struct mailaddr *); 1292void m_add_envelope(struct mproc *, const struct envelope *); 1293void m_add_params(struct mproc *, struct dict *); 1294void m_close(struct mproc *); 1295void m_flush(struct mproc *); 1296 1297void m_msg(struct msg *, struct imsg *); 1298int m_is_eom(struct msg *); 1299void m_end(struct msg *); 1300void m_get_int(struct msg *, int *); 1301void m_get_size(struct msg *, size_t *); 1302void m_get_u32(struct msg *, uint32_t *); 1303void m_get_time(struct msg *, time_t *); 1304void m_get_string(struct msg *, const char **); 1305void m_get_data(struct msg *, const void **, size_t *); 1306void m_get_evpid(struct msg *, uint64_t *); 1307void m_get_msgid(struct msg *, uint32_t *); 1308void m_get_id(struct msg *, uint64_t *); 1309void m_get_sockaddr(struct msg *, struct sockaddr *); 1310void m_get_mailaddr(struct msg *, struct mailaddr *); 1311void m_get_envelope(struct msg *, struct envelope *); 1312void m_get_params(struct msg *, struct dict *); 1313void m_clear_params(struct dict *); 1314 1315 1316/* mta.c */ 1317void mta_postfork(void); 1318void mta_postprivdrop(void); 1319void mta_imsg(struct mproc *, struct imsg *); 1320void mta_route_ok(struct mta_relay *, struct mta_route *); 1321void mta_route_error(struct mta_relay *, struct mta_route *); 1322void mta_route_down(struct mta_relay *, struct mta_route *); 1323void mta_route_collect(struct mta_relay *, struct mta_route *); 1324void mta_source_error(struct mta_relay *, struct mta_route *, const char *); 1325void mta_delivery_log(struct mta_envelope *, const char *, const char *, int, const char *); 1326void mta_delivery_notify(struct mta_envelope *); 1327struct mta_task *mta_route_next_task(struct mta_relay *, struct mta_route *); 1328const char *mta_host_to_text(struct mta_host *); 1329const char *mta_relay_to_text(struct mta_relay *); 1330 1331 1332/* mta_session.c */ 1333void mta_session(struct mta_relay *, struct mta_route *); 1334void mta_session_imsg(struct mproc *, struct imsg *); 1335 1336 1337/* parse.y */ 1338int parse_config(struct smtpd *, const char *, int); 1339int cmdline_symset(char *); 1340 1341 1342/* queue.c */ 1343int queue(void); 1344void queue_flow_control(void); 1345 1346 1347/* queue_backend.c */ 1348uint32_t queue_generate_msgid(void); 1349uint64_t queue_generate_evpid(uint32_t); 1350int queue_init(const char *, int); 1351int queue_close(void); 1352int queue_message_create(uint32_t *); 1353int queue_message_delete(uint32_t); 1354int queue_message_commit(uint32_t); 1355int queue_message_fd_r(uint32_t); 1356int queue_message_fd_rw(uint32_t); 1357int queue_message_corrupt(uint32_t); 1358int queue_message_uncorrupt(uint32_t); 1359int queue_envelope_create(struct envelope *); 1360int queue_envelope_delete(uint64_t); 1361int queue_envelope_load(uint64_t, struct envelope *); 1362int queue_envelope_update(struct envelope *); 1363int queue_envelope_walk(struct envelope *); 1364int queue_message_walk(struct envelope *, uint32_t, int *, void **); 1365 1366 1367/* ruleset.c */ 1368struct rule *ruleset_match(const struct envelope *); 1369 1370 1371/* scheduler.c */ 1372int scheduler(void); 1373 1374 1375/* scheduler_bakend.c */ 1376struct scheduler_backend *scheduler_backend_lookup(const char *); 1377void scheduler_info(struct scheduler_info *, struct envelope *); 1378 1379 1380/* pony.c */ 1381int pony(void); 1382void pony_imsg(struct mproc *, struct imsg *); 1383 1384 1385/* smtp.c */ 1386void smtp_postfork(void); 1387void smtp_postprivdrop(void); 1388void smtp_imsg(struct mproc *, struct imsg *); 1389void smtp_configure(void); 1390void smtp_collect(void); 1391 1392 1393/* smtp_session.c */ 1394int smtp_session(struct listener *, int, const struct sockaddr_storage *, 1395 const char *); 1396void smtp_session_imsg(struct mproc *, struct imsg *); 1397void smtp_filter_response(uint64_t, int, int, uint32_t, const char *); 1398void smtp_filter_fd(uint64_t, int); 1399 1400 1401/* smtpd.c */ 1402void imsg_dispatch(struct mproc *, struct imsg *); 1403const char *proc_name(enum smtp_proc_type); 1404const char *proc_title(enum smtp_proc_type); 1405const char *imsg_to_str(int); 1406void log_imsg(int, int, struct imsg *); 1407int fork_proc_backend(const char *, const char *, const char *); 1408 1409 1410/* ssl_smtpd.c */ 1411void *ssl_mta_init(void *, char *, off_t, const char *); 1412void *ssl_smtp_init(void *, int); 1413 1414 1415/* stat_backend.c */ 1416struct stat_backend *stat_backend_lookup(const char *); 1417void stat_increment(const char *, size_t); 1418void stat_decrement(const char *, size_t); 1419void stat_set(const char *, const struct stat_value *); 1420struct stat_value *stat_counter(size_t); 1421struct stat_value *stat_timestamp(time_t); 1422struct stat_value *stat_timeval(struct timeval *); 1423struct stat_value *stat_timespec(struct timespec *); 1424 1425 1426/* table.c */ 1427struct table *table_find(const char *, const char *); 1428struct table *table_create(const char *, const char *, const char *, 1429 const char *); 1430int table_config(struct table *); 1431int table_open(struct table *); 1432int table_update(struct table *); 1433void table_close(struct table *); 1434int table_check_use(struct table *, uint32_t, uint32_t); 1435int table_check_type(struct table *, uint32_t); 1436int table_check_service(struct table *, uint32_t); 1437int table_lookup(struct table *, struct dict *, const char *, enum table_service, 1438 union lookup *); 1439int table_fetch(struct table *, struct dict *, enum table_service, union lookup *); 1440void table_destroy(struct table *); 1441void table_add(struct table *, const char *, const char *); 1442int table_domain_match(const char *, const char *); 1443int table_netaddr_match(const char *, const char *); 1444int table_mailaddr_match(const char *, const char *); 1445void table_open_all(void); 1446void table_dump_all(void); 1447void table_close_all(void); 1448int table_parse_lookup(enum table_service, const char *, const char *, 1449 union lookup *); 1450 1451 1452/* to.c */ 1453int email_to_mailaddr(struct mailaddr *, char *); 1454int text_to_netaddr(struct netaddr *, const char *); 1455int text_to_mailaddr(struct mailaddr *, const char *); 1456int text_to_relayhost(struct relayhost *, const char *); 1457int text_to_userinfo(struct userinfo *, const char *); 1458int text_to_credentials(struct credentials *, const char *); 1459int text_to_expandnode(struct expandnode *, const char *); 1460uint64_t text_to_evpid(const char *); 1461uint32_t text_to_msgid(const char *); 1462const char *sa_to_text(const struct sockaddr *); 1463const char *ss_to_text(const struct sockaddr_storage *); 1464const char *time_to_text(time_t); 1465const char *duration_to_text(time_t); 1466const char *relayhost_to_text(const struct relayhost *); 1467const char *rule_to_text(struct rule *); 1468const char *sockaddr_to_text(struct sockaddr *); 1469const char *mailaddr_to_text(const struct mailaddr *); 1470const char *expandnode_to_text(struct expandnode *); 1471 1472 1473/* util.c */ 1474typedef struct arglist arglist; 1475struct arglist { 1476 char **list; 1477 uint num; 1478 uint nalloc; 1479}; 1480void addargs(arglist *, char *, ...) 1481 __attribute__((format(printf, 2, 3))); 1482int bsnprintf(char *, size_t, const char *, ...) 1483 __attribute__((format (printf, 3, 4))); 1484int mkdirs(char *, mode_t); 1485int safe_fclose(FILE *); 1486int hostname_match(const char *, const char *); 1487int mailaddr_match(const struct mailaddr *, const struct mailaddr *); 1488int valid_localpart(const char *); 1489int valid_domainpart(const char *); 1490int secure_file(int, char *, char *, uid_t, int); 1491int lowercase(char *, const char *, size_t); 1492void xlowercase(char *, const char *, size_t); 1493int uppercase(char *, const char *, size_t); 1494uint64_t generate_uid(void); 1495int availdesc(void); 1496int ckdir(const char *, mode_t, uid_t, gid_t, int); 1497int rmtree(char *, int); 1498int mvpurge(char *, char *); 1499int mktmpfile(void); 1500const char *parse_smtp_response(char *, size_t, char **, int *); 1501void *xmalloc(size_t, const char *); 1502void *xcalloc(size_t, size_t, const char *); 1503char *xstrdup(const char *, const char *); 1504void *xmemdup(const void *, size_t, const char *); 1505char *strip(char *); 1506void iobuf_xinit(struct iobuf *, size_t, size_t, const char *); 1507void iobuf_xfqueue(struct iobuf *, const char *, const char *, ...); 1508void log_envelope(const struct envelope *, const char *, const char *, 1509 const char *); 1510int session_socket_error(int); 1511int getmailname(char *, size_t); 1512int base64_encode(unsigned char const *, size_t, char *, size_t); 1513int base64_decode(char const *, unsigned char *, size_t); 1514 1515 1516/* waitq.c */ 1517int waitq_wait(void *, void (*)(void *, void *, void *), void *); 1518void waitq_run(void *, void *); 1519 1520 1521/* runq.c */ 1522struct runq; 1523 1524int runq_init(struct runq **, void (*)(struct runq *, void *)); 1525int runq_schedule(struct runq *, time_t, void (*)(struct runq *, void *), void *); 1526int runq_delay(struct runq *, unsigned int, void (*)(struct runq *, void *), void *); 1527int runq_cancel(struct runq *, void (*)(struct runq *, void *), void *); 1528int runq_pending(struct runq *, void (*)(struct runq *, void *), void *, time_t *); 1529int runq_next(struct runq *, void (**)(struct runq *, void *), void **, time_t *); 1530