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