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