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