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