smtpd.h revision 1.193
1/* $OpenBSD: smtpd.h,v 1.193 2010/06/10 19:34:51 chl Exp $ */ 2 3/* 4 * Copyright (c) 2008 Gilles Chehade <gilles@openbsd.org> 5 * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20#include <imsg.h> 21 22#ifndef nitems 23#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 24#endif 25 26#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE) 27 28#define CONF_FILE "/etc/mail/smtpd.conf" 29#define MAX_LISTEN 16 30#define PROC_COUNT 8 31#define MAX_NAME_SIZE 64 32 33#define MAX_HOPS_COUNT 100 34 35/* sizes include the tailing '\0' */ 36#define MAX_LINE_SIZE 1024 37#define MAX_LOCALPART_SIZE 128 38#define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN 39#define MAX_TAG_SIZE 32 40 41/* return and forward path size */ 42#define MAX_PATH_SIZE 256 43 44#define SMTPD_EXPIRE (4 * 24 * 60 * 60) 45#define SMTPD_USER "_smtpd" 46#define SMTPD_SOCKET "/var/run/smtpd.sock" 47#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 48#define SMTPD_SESSION_TIMEOUT 300 49#define SMTPD_BACKLOG 5 50 51#define PATH_SMTPCTL "/usr/sbin/smtpctl" 52#define PATH_SPOOL "/var/spool/smtpd" 53#define PATH_OFFLINE "/offline" 54 55/* number of MX records to lookup */ 56#define MAX_MX_COUNT 10 57 58/* max response delay under flood conditions */ 59#define MAX_RESPONSE_DELAY 60 60 61/* how many responses per state are undelayed */ 62#define FAST_RESPONSES 2 63 64/* max len of any smtp line */ 65#define SMTP_LINE_MAX 16384 66 67#define F_STARTTLS 0x01 68#define F_SMTPS 0x02 69#define F_AUTH 0x04 70#define F_SSL (F_SMTPS|F_STARTTLS) 71 72#define F_SCERT 0x01 73#define F_CCERT 0x02 74 75#define ADVERTISE_TLS(s) \ 76 ((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE)) 77 78#define ADVERTISE_AUTH(s) \ 79 ((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \ 80 !((s)->s_flags & F_AUTHENTICATED)) 81 82struct netaddr { 83 struct sockaddr_storage ss; 84 int bits; 85}; 86 87struct relayhost { 88 u_int8_t flags; 89 char hostname[MAXHOSTNAMELEN]; 90 u_int16_t port; 91 char cert[PATH_MAX]; 92}; 93 94enum imsg_type { 95 IMSG_NONE, 96 IMSG_CTL_OK, /* answer to smtpctl requests */ 97 IMSG_CTL_FAIL, 98 IMSG_CTL_SHUTDOWN, 99 IMSG_CTL_VERBOSE, 100 IMSG_CONF_START, 101 IMSG_CONF_SSL, 102 IMSG_CONF_SSL_CERT, 103 IMSG_CONF_SSL_KEY, 104 IMSG_CONF_LISTENER, 105 IMSG_CONF_MAP, 106 IMSG_CONF_MAP_CONTENT, 107 IMSG_CONF_RULE, 108 IMSG_CONF_RULE_SOURCE, 109 IMSG_CONF_CONDITION, 110 IMSG_CONF_OPTION, 111 IMSG_CONF_END, 112 IMSG_CONF_RELOAD, 113 IMSG_LKA_MAIL, 114 IMSG_LKA_RCPT, 115 IMSG_LKA_RULEMATCH, 116 IMSG_LKA_SECRET, 117 IMSG_MDA_DONE, 118 IMSG_MFA_MAIL, 119 IMSG_MFA_RCPT, 120 121 IMSG_QUEUE_CREATE, 122 IMSG_QUEUE_APPEND, 123 IMSG_QUEUE_OPEN, 124 IMSG_QUEUE_CLOSE, 125 IMSG_QUEUE_DELETE, 126 IMSG_QUEUE_STATS, 127 IMSG_QUEUE_PAUSE_LOCAL, 128 IMSG_QUEUE_PAUSE_RELAY, 129 IMSG_QUEUE_RESUME_LOCAL, 130 IMSG_QUEUE_RESUME_RELAY, 131 IMSG_QUEUE_SCHEDULE, 132 IMSG_QUEUE_REMOVE, 133 134 IMSG_BATCH_CREATE, 135 IMSG_BATCH_APPEND, 136 IMSG_BATCH_CLOSE, 137 IMSG_BATCH_UPDATE, 138 IMSG_BATCH_DONE, 139 140 IMSG_PARENT_FORWARD_OPEN, 141 IMSG_PARENT_FORK_MDA, 142 IMSG_PARENT_STATS, 143 144 IMSG_PARENT_AUTHENTICATE, 145 IMSG_PARENT_SEND_CONFIG, 146 147 IMSG_SMTP_STATS, 148 149 IMSG_STATS, 150 IMSG_SMTP_ENQUEUE, 151 IMSG_SMTP_PAUSE, 152 IMSG_SMTP_RESUME, 153 154 IMSG_DNS_A, 155 IMSG_DNS_A_END, 156 IMSG_DNS_MX, 157 IMSG_DNS_PTR 158}; 159 160enum blockmodes { 161 BM_NORMAL, 162 BM_NONBLOCK 163}; 164 165struct imsgev { 166 struct imsgbuf ibuf; 167 void (*handler)(int, short, void *); 168 struct event ev; 169 void *data; 170 struct smtpd *env; 171 int proc; 172 short events; 173}; 174 175struct ctl_conn { 176 TAILQ_ENTRY(ctl_conn) entry; 177 u_int8_t flags; 178#define CTL_CONN_NOTIFY 0x01 179 struct imsgev iev; 180}; 181TAILQ_HEAD(ctl_connlist, ctl_conn); 182 183typedef u_int32_t objid_t; 184 185struct ctl_id { 186 objid_t id; 187 char name[MAX_NAME_SIZE]; 188}; 189 190enum smtp_proc_type { 191 PROC_PARENT = 0, 192 PROC_SMTP, 193 PROC_MFA, 194 PROC_LKA, 195 PROC_QUEUE, 196 PROC_MDA, 197 PROC_MTA, 198 PROC_CONTROL 199} smtpd_process; 200 201struct peer { 202 enum smtp_proc_type id; 203 void (*cb)(int, short, void *); 204}; 205 206enum map_type { 207 T_SINGLE, 208 T_LIST, 209 T_HASH 210}; 211 212enum map_src { 213 S_NONE, 214 S_DYN, 215 S_DNS, 216 S_PLAIN, 217 S_DB, 218 S_EXT 219}; 220 221enum map_kind { 222 K_NONE, 223 K_ALIAS, 224 K_VIRTUAL, 225 K_SECRET 226}; 227 228enum mapel_type { 229 ME_STRING, 230 ME_NET, 231 ME_NETMASK 232}; 233 234struct mapel { 235 TAILQ_ENTRY(mapel) me_entry; 236 union mapel_data { 237 char med_string[MAX_LINE_SIZE]; 238 struct netaddr med_addr; 239 } me_key; 240 union mapel_data me_val; 241}; 242 243struct map { 244 TAILQ_ENTRY(map) m_entry; 245#define F_USED 0x01 246#define F_DYNAMIC 0x02 247 u_int8_t m_flags; 248 char m_name[MAX_LINE_SIZE]; 249 objid_t m_id; 250 enum map_type m_type; 251 enum mapel_type m_eltype; 252 enum map_src m_src; 253 char m_config[MAXPATHLEN]; 254 TAILQ_HEAD(mapel_list, mapel) m_contents; 255}; 256 257struct map_backend { 258 enum map_src source; 259 void *(*open)(char *); 260 void (*close)(void *); 261 char *(*get)(void *, char *, size_t *); 262 int (*put)(void *, char *, char *); 263}; 264 265struct map_parser { 266 enum map_kind kind; 267 void *(*extract)(char *, char *, size_t); 268}; 269 270enum cond_type { 271 C_ALL, 272 C_NET, 273 C_DOM, 274 C_VDOM 275}; 276 277struct cond { 278 TAILQ_ENTRY(cond) c_entry; 279 objid_t c_map; 280 enum cond_type c_type; 281}; 282 283enum action_type { 284 A_INVALID, 285 A_RELAY, 286 A_RELAYVIA, 287 A_MAILDIR, 288 A_MBOX, 289 A_FILENAME, 290 A_EXT 291}; 292 293#define IS_MAILBOX(x) ((x).rule.r_action == A_MAILDIR || (x).rule.r_action == A_MBOX || (x).rule.r_action == A_FILENAME) 294#define IS_RELAY(x) ((x).rule.r_action == A_RELAY || (x).rule.r_action == A_RELAYVIA) 295#define IS_EXT(x) ((x).rule.r_action == A_EXT) 296 297struct rule { 298 TAILQ_ENTRY(rule) r_entry; 299 char r_tag[MAX_TAG_SIZE]; 300 int r_accept; 301 struct map *r_sources; 302 struct cond r_condition; 303 enum action_type r_action; 304 union rule_dest { 305 char path[MAXPATHLEN]; 306 struct relayhost relayhost; 307#define MAXCOMMANDLEN 256 308 char command[MAXCOMMANDLEN]; 309 } r_value; 310 311 char *r_user; 312 objid_t r_amap; 313}; 314 315enum path_flags { 316 F_PATH_ALIAS = 0x1, 317 F_PATH_VIRTUAL = 0x2, 318 F_PATH_EXPANDED = 0x4, 319 F_PATH_NOFORWARD = 0x8, 320 F_PATH_FORWARDED = 0x10, 321 F_PATH_ACCOUNT = 0x20, 322 F_PATH_AUTHENTICATED = 0x40, 323 F_PATH_RELAY = 0x80, 324}; 325 326struct mailaddr { 327 char user[MAX_LOCALPART_SIZE]; 328 char domain[MAX_DOMAINPART_SIZE]; 329}; 330 331union path_data { 332 char username[MAXLOGNAME]; 333 char filename[MAXPATHLEN]; 334 char filter[MAXPATHLEN]; 335 struct mailaddr mailaddr; 336}; 337 338struct path { 339 TAILQ_ENTRY(path) entry; 340 struct rule rule; 341 enum path_flags flags; 342 u_int8_t forwardcnt; 343 char user[MAX_LOCALPART_SIZE]; 344 char domain[MAX_DOMAINPART_SIZE]; 345 char pw_name[MAXLOGNAME]; 346 union path_data u; 347}; 348TAILQ_HEAD(deliverylist, path); 349 350enum expand_type { 351 EXPAND_INVALID, 352 EXPAND_USERNAME, 353 EXPAND_FILENAME, 354 EXPAND_FILTER, 355 EXPAND_INCLUDE, 356 EXPAND_ADDRESS 357}; 358 359enum expand_flags { 360 F_EXPAND_NONE, 361 F_EXPAND_DONE 362}; 363 364struct expandnode { 365 RB_ENTRY(expandnode) entry; 366 size_t refcnt; 367 enum expand_flags flags; 368 enum expand_type type; 369 union path_data u; 370}; 371 372RB_HEAD(expandtree, expandnode); 373 374struct action { 375 SLIST_ENTRY(action) entry; 376 u_int64_t id; 377 char data[1]; /* actually bigger */ 378}; 379 380struct content { 381 SLIST_HEAD(,action) actions; 382 u_int64_t id; 383 int ref; 384 struct event *ev; 385}; 386 387#define NO_RETRY_EXPIRED 0 388#define RETRY_NOW 1 389 390struct batch { 391 SLIST_ENTRY(batch) entry; 392 SLIST_HEAD(,action) actions; 393 struct content *content; 394 time_t retry; 395 char sortkey[1]; /* actually bigger */ 396}; 397 398struct incoming { 399 SLIST_ENTRY(incoming) entry; 400 SLIST_HEAD(,batch) batches[3]; 401 struct content *content; 402 char **local; 403 int local_sz; 404 int nlocal; 405}; 406 407#define Q_LOCAL 0 408#define Q_RELAY 1 409#define Q_BOUNCE 2 410 411struct queue { 412 SLIST_HEAD(,batch) head; 413 struct event ev; 414 struct smtpd *env; 415 char *name; 416 void **session; 417 int session_sz; 418 size_t sessions; 419 size_t max; 420}; 421 422struct aux { 423 char *mode; 424 char *mail_from; 425 char *rcpt_to; 426 char *user_from; 427 char *user_to; 428 char *path; 429 char *rcpt; 430 char *relay_via; 431 char *port; 432 char *ssl; 433 char *cert; 434 char *auth; 435}; 436 437struct bounce { 438 struct event ev; 439 struct batch *batch; 440 struct smtp_client *pcb; 441 int id; 442}; 443 444enum message_flags { 445 F_MESSAGE_AUTHENTICATED = 0x1 446}; 447 448enum message_status { 449 S_MESSAGE_PERMFAILURE = 0x1, 450 S_MESSAGE_TEMPFAILURE = 0x2 451}; 452 453struct message { 454 TAILQ_ENTRY(message) entry; 455 456 char tag[MAX_TAG_SIZE]; 457 458 u_int32_t id; /* smtp session id */ 459 u_int32_t session_id; /* smtp session id */ 460 u_int32_t queue_id; 461 462 char session_helo[MAXHOSTNAMELEN]; 463 char session_hostname[MAXHOSTNAMELEN]; 464 char session_errorline[MAX_LINE_SIZE]; 465 struct sockaddr_storage session_ss; 466 struct path session_rcpt; 467 468 struct path sender; 469 struct path recipient; 470 471 time_t creation; 472 time_t lasttry; 473 u_int8_t retry; 474 enum message_flags flags; 475 enum message_status status; 476}; 477 478enum child_type { 479 CHILD_INVALID, 480 CHILD_DAEMON, 481 CHILD_MDA, 482 CHILD_ENQUEUE_OFFLINE 483}; 484 485struct child { 486 SPLAY_ENTRY(child) entry; 487 pid_t pid; 488 enum child_type type; 489 enum smtp_proc_type title; 490 int mda_out; 491 u_int32_t mda_id; 492}; 493 494enum session_state { 495 S_INVALID = 0, 496 S_INIT, 497 S_GREETED, 498 S_TLS, 499 S_AUTH_INIT, 500 S_AUTH_USERNAME, 501 S_AUTH_PASSWORD, 502 S_AUTH_FINALIZE, 503 S_HELO, 504 S_MAIL_MFA, 505 S_MAIL_QUEUE, 506 S_MAIL, 507 S_RCPT_MFA, 508 S_RCPT, 509 S_DATA, 510 S_DATA_QUEUE, 511 S_DATACONTENT, 512 S_DONE, 513 S_QUIT 514}; 515#define STATE_COUNT 18 516 517struct ssl { 518 SPLAY_ENTRY(ssl) ssl_nodes; 519 char ssl_name[PATH_MAX]; 520 char *ssl_cert; 521 off_t ssl_cert_len; 522 char *ssl_key; 523 off_t ssl_key_len; 524 u_int8_t flags; 525}; 526 527struct listener { 528 u_int8_t flags; 529 int fd; 530 struct sockaddr_storage ss; 531 in_port_t port; 532 struct timeval timeout; 533 struct event ev; 534 struct smtpd *env; 535 char ssl_cert_name[PATH_MAX]; 536 struct ssl *ssl; 537 void *ssl_ctx; 538 char tag[MAX_TAG_SIZE]; 539 TAILQ_ENTRY(listener) entry; 540}; 541 542struct auth { 543 u_int64_t id; 544 char user[MAXLOGNAME]; 545 char pass[MAX_LINE_SIZE]; 546 int success; 547}; 548 549enum session_flags { 550 F_EHLO = 0x1, 551 F_QUIT = 0x2, 552 F_8BITMIME = 0x4, 553 F_SECURE = 0x8, 554 F_AUTHENTICATED = 0x10, 555 F_PEERHASTLS = 0x20, 556 F_PEERHASAUTH = 0x40, 557 F_WRITEONLY = 0x80 558}; 559 560struct session { 561 SPLAY_ENTRY(session) s_nodes; 562 u_int32_t s_id; 563 564 enum session_flags s_flags; 565 enum session_state s_state; 566 int s_fd; 567 struct sockaddr_storage s_ss; 568 char s_hostname[MAXHOSTNAMELEN]; 569 struct event s_ev; 570 struct bufferevent *s_bev; 571 struct listener *s_l; 572 struct smtpd *s_env; 573 void *s_ssl; 574 u_char *s_buf; 575 int s_buflen; 576 struct timeval s_tv; 577 struct message s_msg; 578 short s_nresp[STATE_COUNT]; 579 size_t rcptcount; 580 long s_datalen; 581 582 struct auth s_auth; 583 struct batch *batch; 584 585 FILE *datafp; 586 int mboxfd; 587 int messagefd; 588 589 u_int32_t queue_id; 590 u_int64_t content_id; 591}; 592 593struct smtpd { 594 char sc_conffile[MAXPATHLEN]; 595 size_t sc_maxsize; 596 597#define SMTPD_OPT_VERBOSE 0x00000001 598#define SMTPD_OPT_NOACTION 0x00000002 599 u_int32_t sc_opts; 600#define SMTPD_CONFIGURING 0x00000001 601#define SMTPD_EXITING 0x00000002 602#define SMTPD_MDA_PAUSED 0x00000004 603#define SMTPD_MTA_PAUSED 0x00000008 604#define SMTPD_SMTP_PAUSED 0x00000010 605 u_int32_t sc_flags; 606 u_int32_t sc_maxconn; 607 int sc_qexpire; 608 struct event sc_ev; 609 int *sc_pipes[PROC_COUNT] 610 [PROC_COUNT]; 611 struct imsgev *sc_ievs[PROC_COUNT]; 612 int sc_instances[PROC_COUNT]; 613 int sc_instance; 614 char *sc_title[PROC_COUNT]; 615 struct passwd *sc_pw; 616 char sc_hostname[MAXHOSTNAMELEN]; 617 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 618 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 619 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 620 SPLAY_HEAD(sessiontree, session) sc_sessions; 621 SPLAY_HEAD(msgtree, message) sc_messages; 622 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 623 624 SPLAY_HEAD(childtree, child) children; 625 SPLAY_HEAD(lkatree, lkasession) lka_sessions; 626 SPLAY_HEAD(mtatree, mta_session) mta_sessions; 627 LIST_HEAD(mdalist, mda_session) mda_sessions; 628 629 struct stats *stats; 630}; 631 632struct s_parent { 633 time_t start; 634}; 635 636struct s_queue { 637 size_t length; 638 size_t inserts; 639}; 640 641struct s_session { 642 size_t sessions; 643 size_t sessions_active; 644 645 size_t smtps; 646 size_t smtps_active; 647 648 size_t starttls; 649 size_t starttls_active; 650 651 size_t read_error; 652 size_t read_timeout; 653 size_t read_eof; 654 size_t write_error; 655 size_t write_timeout; 656 size_t write_eof; 657 size_t toofast; 658 size_t tempfail; 659 size_t linetoolong; 660 size_t delays; 661}; 662 663struct s_mda { 664 size_t sessions; 665 size_t sessions_active; 666}; 667 668struct s_control { 669 size_t sessions; 670 size_t sessions_active; 671}; 672 673struct stats { 674 struct s_parent parent; 675 struct s_queue queue; 676 struct s_session mta; 677 struct s_mda mda; 678 struct s_session smtp; 679 struct s_control control; 680}; 681 682struct reload { 683 int fd; 684 int ret; 685}; 686 687struct submit_status { 688 u_int64_t id; 689 int code; 690 union submit_path { 691 struct path path; 692 char errormsg[MAX_LINE_SIZE]; 693 } u; 694 enum message_flags flags; 695 struct sockaddr_storage ss; 696 struct message msg; 697}; 698 699struct forward_req { 700 u_int32_t id; 701 u_int8_t status; 702 char pw_name[MAXLOGNAME]; 703}; 704 705struct dns { 706 u_int64_t id; 707 char host[MAXHOSTNAMELEN]; 708 int port; 709 int error; 710 struct sockaddr_storage ss; 711 struct smtpd *env; 712 struct dns *next; 713}; 714 715struct mda_session { 716 LIST_ENTRY(mda_session) entry; 717 struct msgbuf w; 718 struct event ev; 719 time_t birth; 720 u_int64_t content_id; 721 u_int64_t action_id; 722 u_int32_t id; 723 struct aux aux; 724 char *auxraw; 725 FILE *datafp; 726}; 727 728struct deliver { 729 int mode; 730 char to[PATH_MAX]; 731 char user[MAXLOGNAME]; 732}; 733 734struct rulematch { 735 u_int64_t id; 736 struct submit_status ss; 737}; 738 739enum lkasession_flags { 740 F_ERROR = 0x1 741}; 742 743struct lkasession { 744 SPLAY_ENTRY(lkasession) nodes; 745 u_int32_t id; 746 747 struct path path; 748 struct deliverylist deliverylist; 749 750 struct expandtree expandtree; 751 752 u_int8_t iterations; 753 u_int32_t pending; 754 enum lkasession_flags flags; 755 struct message message; 756 struct submit_status ss; 757}; 758 759enum mta_state { 760 MTA_INVALID_STATE, 761 MTA_INIT, 762 MTA_SECRET, 763 MTA_MX, 764 MTA_CONNECT, 765 MTA_PTR, 766 MTA_PROTOCOL, 767 MTA_DONE 768}; 769 770struct mta_relay { 771 TAILQ_ENTRY(mta_relay) entry; 772 struct sockaddr_storage sa; 773 char fqdn[MAXHOSTNAMELEN]; 774 int used; 775}; 776 777struct recipient { 778 TAILQ_ENTRY(recipient) entry; 779 u_int64_t action_id; 780 char status[128]; 781 char address[1]; /* actually bigger */ 782}; 783 784struct mta_session { 785 SPLAY_ENTRY(mta_session) entry; 786 u_int32_t id; 787 struct smtpd *env; 788 enum mta_state state; 789 time_t birth; 790 u_int64_t content_id; 791 struct aux aux; 792 char *auxraw; 793 TAILQ_HEAD(,recipient) recipients; 794 TAILQ_HEAD(,mta_relay) relays; 795 char *secret; 796 int fd; 797 int datafd; 798 struct event ev; 799 void *pcb; 800}; 801 802/* maps return structures */ 803struct map_secret { 804 char username[MAX_LINE_SIZE]; 805 char password[MAX_LINE_SIZE]; 806}; 807 808struct map_alias { 809 size_t nbnodes; 810 struct expandtree expandtree; 811}; 812 813struct map_virtual { 814 size_t nbnodes; 815 struct expandtree expandtree; 816}; 817 818 819 820extern void (*imsg_callback)(struct smtpd *, struct imsgev *, struct imsg *); 821 822/* aliases.c */ 823int aliases_exist(struct smtpd *, objid_t, char *); 824int aliases_get(struct smtpd *, objid_t, struct expandtree *, char *); 825int aliases_vdomain_exists(struct smtpd *, objid_t, char *); 826int aliases_virtual_exist(struct smtpd *, objid_t, struct path *); 827int aliases_virtual_get(struct smtpd *, objid_t, struct expandtree *, struct path *); 828int alias_parse(struct expandnode *, char *); 829 830/* authenticate.c */ 831int authenticate_user(char *, char *); 832 833/* bounce.c */ 834int bounce_session(struct smtpd *, int, struct message *); 835int bounce_session_switch(struct smtpd *, FILE *, enum session_state *, char *, 836 struct message *); 837 838/* log.c */ 839void log_init(int); 840void log_verbose(int); 841void log_warn(const char *, ...) 842 __attribute__ ((format (printf, 1, 2))); 843void log_warnx(const char *, ...) 844 __attribute__ ((format (printf, 1, 2))); 845void log_info(const char *, ...) 846 __attribute__ ((format (printf, 1, 2))); 847void log_debug(const char *, ...) 848 __attribute__ ((format (printf, 1, 2))); 849__dead void fatal(const char *); 850__dead void fatalx(const char *); 851 852 853/* dns.c */ 854void dns_query_a(struct smtpd *, char *, int, u_int64_t); 855void dns_query_mx(struct smtpd *, char *, int, u_int64_t); 856void dns_query_ptr(struct smtpd *, struct sockaddr_storage *, 857 u_int64_t); 858void dns_async(struct smtpd *, struct imsgev *, int, 859 struct dns *); 860/* expand.c */ 861int expand_cmp(struct expandnode *, struct expandnode *); 862void expandtree_increment_node(struct expandtree *, struct expandnode *); 863void expandtree_decrement_node(struct expandtree *, struct expandnode *); 864void expandtree_remove_node(struct expandtree *, struct expandnode *); 865struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 866void expandtree_free_nodes(struct expandtree *); 867RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 868 869/* forward.c */ 870int forwards_get(int, struct expandtree *); 871 872/* smtpd.c */ 873int child_cmp(struct child *, struct child *); 874SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 875void imsg_event_add(struct imsgev *); 876void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 877 int, void *, u_int16_t); 878void imsg_dispatch(int, short, void *); 879 880/* lka.c */ 881pid_t lka(struct smtpd *); 882int lkasession_cmp(struct lkasession *, struct lkasession *); 883SPLAY_PROTOTYPE(lkatree, lkasession, nodes, lkasession_cmp); 884 885/* mfa.c */ 886pid_t mfa(struct smtpd *); 887 888/* queue.c */ 889pid_t queue(struct smtpd *); 890 891/* map.c */ 892void *map_lookup(struct smtpd *, objid_t, char *, enum map_kind); 893 894/* mda.c */ 895pid_t mda(struct smtpd *); 896 897/* mta.c */ 898pid_t mta(struct smtpd *); 899int mta_session_cmp(struct mta_session *, struct mta_session *); 900SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp); 901 902/* control.c */ 903pid_t control(struct smtpd *); 904void session_socket_blockmode(int, enum blockmodes); 905void session_socket_no_linger(int); 906int session_socket_error(int); 907 908/* enqueue.c */ 909int enqueue(int, char **); 910int enqueue_offline(int, char **); 911 912/* smtp.c */ 913pid_t smtp(struct smtpd *); 914void smtp_resume(struct smtpd *); 915 916/* smtp_session.c */ 917void session_init(struct listener *, struct session *); 918int session_cmp(struct session *, struct session *); 919void session_pickup(struct session *); 920void session_destroy(struct session *); 921void session_respond(struct session *, char *, ...) 922 __attribute__ ((format (printf, 2, 3))); 923void session_bufferevent_new(struct session *); 924 925SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 926 927/* config.c */ 928#define PURGE_LISTENERS 0x01 929#define PURGE_MAPS 0x02 930#define PURGE_RULES 0x04 931#define PURGE_SSL 0x08 932#define PURGE_EVERYTHING 0xff 933void purge_config(struct smtpd *, u_int8_t); 934void unconfigure(struct smtpd *); 935void configure(struct smtpd *); 936void init_pipes(struct smtpd *); 937void config_pipes(struct smtpd *, struct peer *, u_int); 938void config_peers(struct smtpd *, struct peer *, u_int); 939 940/* parse.y */ 941int parse_config(struct smtpd *, const char *, int); 942int cmdline_symset(char *); 943 944/* ssl.c */ 945void ssl_init(void); 946void ssl_transaction(struct session *); 947 948void ssl_session_init(struct session *); 949void ssl_session_destroy(struct session *); 950int ssl_load_certfile(struct smtpd *, const char *, u_int8_t); 951void ssl_setup(struct smtpd *, struct listener *); 952int ssl_cmp(struct ssl *, struct ssl *); 953SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 954 955/* ssl_privsep.c */ 956int ssl_ctx_use_private_key(void *, char *, off_t); 957int ssl_ctx_use_certificate_chain(void *, char *, off_t); 958 959/* map.c */ 960struct map *map_find(struct smtpd *, objid_t); 961struct map *map_findbyname(struct smtpd *, const char *); 962 963/* util.c */ 964typedef struct arglist arglist; 965struct arglist { 966 char **list; 967 u_int num; 968 u_int nalloc; 969}; 970void addargs(arglist *, char *, ...) 971 __attribute__((format(printf, 2, 3))); 972int bsnprintf(char *, size_t, const char *, ...) 973 __attribute__ ((format (printf, 3, 4))); 974int hostname_match(char *, char *); 975int recipient_to_path(struct path *, char *); 976int valid_localpart(char *); 977int valid_domainpart(char *); 978char *ss_to_text(struct sockaddr_storage *); 979char *time_to_text(time_t); 980int secure_file(int, char *, struct passwd *, int); 981void lowercase(char *, char *, size_t); 982void sa_set_port(struct sockaddr *, char *); 983struct path *path_dup(struct path *); 984u_int64_t generate_uid(void); 985void fdlimit(double); 986int availdesc(void); 987int table_alloc(void ***, int *); 988void *table_lookup(void **, int, int); 989void auxsplit(struct aux *, char *); 990char *rcpt_pretty(struct aux *); 991