smtpd.h revision 1.167
1/* $OpenBSD: smtpd.h,v 1.167 2010/01/03 14:37:37 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_SIZE_CHECK(p) do { \ 27 if (IMSG_DATA_SIZE(&imsg) != sizeof(*p)) \ 28 fatalx("bad length imsg received"); \ 29} while (0) 30#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE) 31 32#define CONF_FILE "/etc/mail/smtpd.conf" 33#define MAX_LISTEN 16 34#define PROC_COUNT 9 35#define MAX_NAME_SIZE 64 36 37#define MAX_HOPS_COUNT 100 38 39/* sizes include the tailing '\0' */ 40#define MAX_LINE_SIZE 1024 41#define MAX_LOCALPART_SIZE 65 42#define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN 43#define MAX_ID_SIZE 64 44#define MAX_TAG_SIZE 32 45 46/* return and forward path size */ 47#define MAX_PATH_SIZE 256 48 49#define SMTPD_QUEUE_INTERVAL (15 * 60) 50#define SMTPD_QUEUE_MAXINTERVAL (4 * 60 * 60) 51#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 52#define SMTPD_USER "_smtpd" 53#define SMTPD_SOCKET "/var/run/smtpd.sock" 54#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 55#define SMTPD_SESSION_TIMEOUT 300 56#define SMTPD_BACKLOG 5 57 58#define PATH_MAILLOCAL "/usr/libexec/mail.local" 59#define PATH_SMTPCTL "/usr/sbin/smtpctl" 60 61#define DIRHASH_BUCKETS 4096 62 63#define PATH_SPOOL "/var/spool/smtpd" 64 65#define PATH_ENQUEUE "/enqueue" 66#define PATH_INCOMING "/incoming" 67#define PATH_QUEUE "/queue" 68#define PATH_PURGE "/purge" 69 70#define PATH_MESSAGE "/message" 71#define PATH_ENVELOPES "/envelopes" 72 73#define PATH_RUNQUEUE "/runqueue" 74 75#define PATH_OFFLINE "/offline" 76#define PATH_BOUNCE "/bounce" 77 78/* number of MX records to lookup */ 79#define MAX_MX_COUNT 10 80 81/* max response delay under flood conditions */ 82#define MAX_RESPONSE_DELAY 60 83 84/* how many responses per state are undelayed */ 85#define FAST_RESPONSES 2 86 87/* max len of any smtp line */ 88#define SMTP_LINE_MAX 16384 89 90#define F_STARTTLS 0x01 91#define F_SMTPS 0x02 92#define F_AUTH 0x04 93#define F_SSL (F_SMTPS|F_STARTTLS) 94 95#define F_SCERT 0x01 96#define F_CCERT 0x02 97 98#define ADVERTISE_TLS(s) \ 99 ((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE)) 100 101#define ADVERTISE_AUTH(s) \ 102 ((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \ 103 !((s)->s_flags & F_AUTHENTICATED)) 104 105struct netaddr { 106 struct sockaddr_storage ss; 107 int bits; 108}; 109 110struct relayhost { 111 u_int8_t flags; 112 char hostname[MAXHOSTNAMELEN]; 113 u_int16_t port; 114 char cert[PATH_MAX]; 115}; 116 117enum imsg_type { 118 IMSG_NONE, 119 IMSG_CTL_OK, /* answer to smtpctl requests */ 120 IMSG_CTL_FAIL, 121 IMSG_CTL_SHUTDOWN, 122 IMSG_CTL_VERBOSE, 123 IMSG_CONF_START, 124 IMSG_CONF_SSL, 125 IMSG_CONF_SSL_CERT, 126 IMSG_CONF_SSL_KEY, 127 IMSG_CONF_LISTENER, 128 IMSG_CONF_MAP, 129 IMSG_CONF_MAP_CONTENT, 130 IMSG_CONF_RULE, 131 IMSG_CONF_RULE_SOURCE, 132 IMSG_CONF_CONDITION, 133 IMSG_CONF_OPTION, 134 IMSG_CONF_END, 135 IMSG_CONF_RELOAD, 136 IMSG_LKA_MAIL, 137 IMSG_LKA_RCPT, 138 IMSG_LKA_SECRET, 139 IMSG_LKA_RULEMATCH, 140 IMSG_MDA_FINALIZE, 141 IMSG_MFA_RCPT, 142 IMSG_MFA_MAIL, 143 144 IMSG_QUEUE_CREATE_MESSAGE, 145 IMSG_QUEUE_SUBMIT_ENVELOPE, 146 IMSG_QUEUE_COMMIT_ENVELOPES, 147 IMSG_QUEUE_REMOVE_MESSAGE, 148 IMSG_QUEUE_COMMIT_MESSAGE, 149 IMSG_QUEUE_TEMPFAIL, 150 IMSG_QUEUE_STATS, 151 152 IMSG_QUEUE_REMOVE_SUBMISSION, 153 IMSG_QUEUE_MESSAGE_UPDATE, 154 IMSG_QUEUE_MESSAGE_FD, 155 IMSG_QUEUE_MESSAGE_FILE, 156 157 IMSG_RUNNER_UPDATE_ENVELOPE, 158 IMSG_RUNNER_STATS, 159 IMSG_RUNNER_SCHEDULE, 160 161 IMSG_BATCH_CREATE, 162 IMSG_BATCH_APPEND, 163 IMSG_BATCH_CLOSE, 164 IMSG_BATCH_DONE, 165 166 IMSG_PARENT_ENQUEUE_OFFLINE, 167 IMSG_PARENT_FORWARD_OPEN, 168 IMSG_PARENT_MAILBOX_OPEN, 169 IMSG_PARENT_MESSAGE_OPEN, 170 IMSG_PARENT_MAILDIR_RENAME, 171 IMSG_PARENT_MAILDIR_FAIL, 172 IMSG_PARENT_STATS, 173 174 IMSG_PARENT_AUTHENTICATE, 175 IMSG_PARENT_SEND_CONFIG, 176 177 IMSG_MDA_PAUSE, 178 IMSG_MTA_PAUSE, 179 IMSG_SMTP_PAUSE, 180 IMSG_SMTP_STATS, 181 182 IMSG_MDA_RESUME, 183 IMSG_MTA_RESUME, 184 IMSG_SMTP_RESUME, 185 186 IMSG_STATS, 187 188 IMSG_SMTP_ENQUEUE, 189 190 IMSG_DNS_A, 191 IMSG_DNS_A_END, 192 IMSG_DNS_MX, 193 IMSG_DNS_PTR 194}; 195 196enum blockmodes { 197 BM_NORMAL, 198 BM_NONBLOCK 199}; 200 201struct imsgev { 202 struct imsgbuf ibuf; 203 void (*handler)(int, short, void *); 204 struct event ev; 205 void *data; 206 short events; 207}; 208 209struct ctl_conn { 210 TAILQ_ENTRY(ctl_conn) entry; 211 u_int8_t flags; 212#define CTL_CONN_NOTIFY 0x01 213 struct imsgev iev; 214}; 215TAILQ_HEAD(ctl_connlist, ctl_conn); 216 217typedef u_int32_t objid_t; 218 219struct ctl_id { 220 objid_t id; 221 char name[MAX_NAME_SIZE]; 222}; 223 224enum smtp_proc_type { 225 PROC_PARENT = 0, 226 PROC_SMTP, 227 PROC_MFA, 228 PROC_LKA, 229 PROC_QUEUE, 230 PROC_MDA, 231 PROC_MTA, 232 PROC_CONTROL, 233 PROC_RUNNER, 234} smtpd_process; 235 236struct peer { 237 enum smtp_proc_type id; 238 void (*cb)(int, short, void *); 239}; 240 241enum map_type { 242 T_SINGLE, 243 T_LIST, 244 T_HASH 245}; 246 247enum map_src { 248 S_NONE, 249 S_DYN, 250 S_DNS, 251 S_FILE, 252 S_DB, 253 S_EXT 254}; 255 256enum mapel_type { 257 ME_STRING, 258 ME_NET, 259 ME_NETMASK 260}; 261 262struct mapel { 263 TAILQ_ENTRY(mapel) me_entry; 264 union mapel_data { 265 char med_string[MAX_LINE_SIZE]; 266 struct netaddr med_addr; 267 } me_key; 268 union mapel_data me_val; 269}; 270 271struct map { 272 TAILQ_ENTRY(map) m_entry; 273#define F_USED 0x01 274#define F_DYNAMIC 0x02 275 u_int8_t m_flags; 276 char m_name[MAX_LINE_SIZE]; 277 objid_t m_id; 278 enum map_type m_type; 279 enum mapel_type m_eltype; 280 enum map_src m_src; 281 char m_config[MAXPATHLEN]; 282 TAILQ_HEAD(mapel_list, mapel) m_contents; 283}; 284 285enum cond_type { 286 C_ALL, 287 C_NET, 288 C_DOM, 289 C_VDOM 290}; 291 292struct cond { 293 TAILQ_ENTRY(cond) c_entry; 294 objid_t c_map; 295 enum cond_type c_type; 296}; 297 298enum opt_type { 299 O_RWUSER, /* rewrite user */ 300 O_RWDOMAIN, /* rewrite domain */ 301}; 302 303struct opt { 304 TAILQ_ENTRY(opt) o_entry; 305 enum opt_type o_type; 306}; 307 308enum action_type { 309 A_INVALID, 310 A_RELAY, 311 A_RELAYVIA, 312 A_MAILDIR, 313 A_MBOX, 314 A_FILENAME, 315 A_EXT 316}; 317 318#define IS_MAILBOX(x) ((x).rule.r_action == A_MAILDIR || (x).rule.r_action == A_MBOX || (x).rule.r_action == A_FILENAME) 319#define IS_RELAY(x) ((x).rule.r_action == A_RELAY || (x).rule.r_action == A_RELAYVIA) 320#define IS_EXT(x) ((x).rule.r_action == A_EXT) 321 322struct rule { 323 TAILQ_ENTRY(rule) r_entry; 324 char r_tag[MAX_TAG_SIZE]; 325 int r_accept; 326 struct map *r_sources; 327 TAILQ_HEAD(condlist, cond) r_conditions; 328 enum action_type r_action; 329 union rule_dest { 330 char path[MAXPATHLEN]; 331 struct relayhost relayhost; 332#define MAXCOMMANDLEN 256 333 char command[MAXCOMMANDLEN]; 334 } r_value; 335 TAILQ_HEAD(optlist, opt) r_options; 336 337 char *r_user; 338 objid_t r_amap; 339}; 340 341enum path_flags { 342 F_PATH_ALIAS = 0x1, 343 F_PATH_VIRTUAL = 0x2, 344 F_PATH_EXPANDED = 0x4, 345 F_PATH_NOFORWARD = 0x8, 346 F_PATH_FORWARDED = 0x10, 347 F_PATH_ACCOUNT = 0x20, 348 F_PATH_AUTHENTICATED = 0x40, 349 F_PATH_RELAY = 0x80, 350}; 351 352struct mailaddr { 353 char user[MAX_LOCALPART_SIZE]; 354 char domain[MAX_DOMAINPART_SIZE]; 355}; 356 357union path_data { 358 char username[MAXLOGNAME]; 359 char filename[MAXPATHLEN]; 360 char filter[MAXPATHLEN]; 361 struct mailaddr mailaddr; 362}; 363 364struct path { 365 TAILQ_ENTRY(path) entry; 366 struct rule rule; 367 struct cond *cond; 368 enum path_flags flags; 369 u_int8_t forwardcnt; 370 char user[MAX_LOCALPART_SIZE]; 371 char domain[MAX_DOMAINPART_SIZE]; 372 char pw_name[MAXLOGNAME]; 373 union path_data u; 374}; 375TAILQ_HEAD(deliverylist, path); 376 377enum expand_type { 378 EXPAND_INVALID, 379 EXPAND_USERNAME, 380 EXPAND_FILENAME, 381 EXPAND_FILTER, 382 EXPAND_INCLUDE, 383 EXPAND_ADDRESS 384}; 385 386enum expand_flags { 387 F_EXPAND_NONE, 388 F_EXPAND_DONE 389}; 390 391struct expand_node { 392 RB_ENTRY(expand_node) entry; 393 size_t refcnt; 394 enum expand_flags flags; 395 enum expand_type type; 396 union path_data u; 397}; 398 399struct alias { 400 enum expand_type type; 401 union path_data u; 402}; 403 404enum message_type { 405 T_MDA_MESSAGE = 0x1, 406 T_MTA_MESSAGE = 0x2, 407 T_BOUNCE_MESSAGE = 0x4 408}; 409 410enum message_status { 411 S_MESSAGE_LOCKFAILURE = 0x1, 412 S_MESSAGE_PERMFAILURE = 0x2, 413 S_MESSAGE_TEMPFAILURE = 0x4, 414 S_MESSAGE_REJECTED = 0x8, 415 S_MESSAGE_ACCEPTED = 0x10, 416 S_MESSAGE_RETRY = 0x20, 417 S_MESSAGE_EDNS = 0x40, 418 S_MESSAGE_ECONNECT = 0x80 419}; 420 421enum message_flags { 422 F_MESSAGE_RESOLVED = 0x1, 423 F_MESSAGE_SCHEDULED = 0x2, 424 F_MESSAGE_PROCESSING = 0x4, 425 F_MESSAGE_AUTHENTICATED = 0x8, 426 F_MESSAGE_ENQUEUED = 0x10, 427 F_MESSAGE_FORCESCHEDULE = 0x20, 428 F_MESSAGE_BOUNCE = 0x40 429}; 430 431struct message { 432 TAILQ_ENTRY(message) entry; 433 434 enum message_type type; 435 436 u_int64_t id; 437 u_int64_t session_id; 438 u_int64_t batch_id; 439 440 char tag[MAX_TAG_SIZE]; 441 442 char message_id[MAX_ID_SIZE]; 443 char message_uid[MAX_ID_SIZE]; 444 445 char session_helo[MAXHOSTNAMELEN]; 446 char session_hostname[MAXHOSTNAMELEN]; 447 char session_errorline[MAX_LINE_SIZE]; 448 struct sockaddr_storage session_ss; 449 struct path session_rcpt; 450 451 struct path sender; 452 struct path recipient; 453 454 time_t creation; 455 time_t lasttry; 456 u_int8_t retry; 457 enum message_flags flags; 458 enum message_status status; 459}; 460 461enum batch_type { 462 T_MDA_BATCH = 0x1, 463 T_MTA_BATCH = 0x2, 464 T_BOUNCE_BATCH = 0x4 465}; 466 467struct batch { 468 SPLAY_ENTRY(batch) b_nodes; 469 470 u_int64_t id; 471 enum batch_type type; 472 struct rule rule; 473 474 struct smtpd *env; 475 476 char message_id[MAX_ID_SIZE]; 477 char hostname[MAXHOSTNAMELEN]; 478 479 struct message message; 480 TAILQ_HEAD(, message) messages; 481 482 FILE *mboxfp; 483 FILE *datafp; 484 void *rbuf; 485 int rbufsz; 486 int cleanup_parent; 487 struct event ev; 488}; 489 490enum child_type { 491 CHILD_INVALID, 492 CHILD_DAEMON, 493 CHILD_MDA, 494 CHILD_ENQUEUE_OFFLINE 495}; 496 497struct child { 498 SPLAY_ENTRY(child) entry; 499 500 pid_t pid; 501 enum child_type type; 502 enum smtp_proc_type title; 503 struct batch mda_batch; 504}; 505 506enum session_state { 507 S_INVALID = 0, 508 S_INIT, 509 S_GREETED, 510 S_TLS, 511 S_AUTH_INIT, 512 S_AUTH_USERNAME, 513 S_AUTH_PASSWORD, 514 S_AUTH_FINALIZE, 515 S_HELO, 516 S_MAIL_MFA, 517 S_MAIL_QUEUE, 518 S_MAIL, 519 S_RCPT_MFA, 520 S_RCPT, 521 S_DATA, 522 S_DATA_QUEUE, 523 S_DATACONTENT, 524 S_DONE, 525 S_QUIT 526}; 527#define STATE_COUNT 18 528 529struct ssl { 530 SPLAY_ENTRY(ssl) ssl_nodes; 531 char ssl_name[PATH_MAX]; 532 char *ssl_cert; 533 off_t ssl_cert_len; 534 char *ssl_key; 535 off_t ssl_key_len; 536 u_int8_t flags; 537}; 538 539struct listener { 540 u_int8_t flags; 541 int fd; 542 struct sockaddr_storage ss; 543 in_port_t port; 544 struct timeval timeout; 545 struct event ev; 546 struct smtpd *env; 547 char ssl_cert_name[PATH_MAX]; 548 struct ssl *ssl; 549 void *ssl_ctx; 550 char tag[MAX_TAG_SIZE]; 551 TAILQ_ENTRY(listener) entry; 552}; 553 554struct auth { 555 u_int64_t id; 556 char user[MAXLOGNAME]; 557 char pass[MAX_LINE_SIZE]; 558 int success; 559}; 560 561enum session_flags { 562 F_EHLO = 0x1, 563 F_QUIT = 0x2, 564 F_8BITMIME = 0x4, 565 F_SECURE = 0x8, 566 F_AUTHENTICATED = 0x10, 567 F_PEERHASTLS = 0x20, 568 F_PEERHASAUTH = 0x40, 569 F_WRITEONLY = 0x80 570}; 571 572struct session { 573 SPLAY_ENTRY(session) s_nodes; 574 u_int64_t s_id; 575 576 enum session_flags s_flags; 577 enum session_state s_state; 578 int s_fd; 579 struct sockaddr_storage s_ss; 580 char s_hostname[MAXHOSTNAMELEN]; 581 struct event s_ev; 582 struct bufferevent *s_bev; 583 struct listener *s_l; 584 struct smtpd *s_env; 585 void *s_ssl; 586 u_char *s_buf; 587 int s_buflen; 588 struct timeval s_tv; 589 struct message s_msg; 590 short s_nresp[STATE_COUNT]; 591 size_t rcptcount; 592 long s_datalen; 593 594 struct auth s_auth; 595 struct batch *batch; 596 597 FILE *datafp; 598 int mboxfd; 599 int messagefd; 600}; 601 602struct smtpd { 603 char sc_conffile[MAXPATHLEN]; 604 605#define SMTPD_OPT_VERBOSE 0x00000001 606#define SMTPD_OPT_NOACTION 0x00000002 607 u_int32_t sc_opts; 608#define SMTPD_CONFIGURING 0x00000001 609#define SMTPD_EXITING 0x00000002 610#define SMTPD_MDA_PAUSED 0x00000004 611#define SMTPD_MTA_PAUSED 0x00000008 612#define SMTPD_SMTP_PAUSED 0x00000010 613 u_int32_t sc_flags; 614 struct timeval sc_qintval; 615 u_int32_t sc_maxconn; 616 struct event sc_ev; 617 int *sc_pipes[PROC_COUNT] 618 [PROC_COUNT]; 619 struct imsgev *sc_ievs[PROC_COUNT]; 620 int sc_instances[PROC_COUNT]; 621 int sc_instance; 622 char *sc_title[PROC_COUNT]; 623 struct passwd *sc_pw; 624 char sc_hostname[MAXHOSTNAMELEN]; 625 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 626 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 627 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 628 SPLAY_HEAD(sessiontree, session) sc_sessions; 629 SPLAY_HEAD(msgtree, message) sc_messages; 630 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 631 632 SPLAY_HEAD(batchtree, batch) batch_queue; 633 SPLAY_HEAD(childtree, child) children; 634 SPLAY_HEAD(lkatree, lkasession) lka_sessions; 635 SPLAY_HEAD(mtatree, mta_session) mta_sessions; 636 637 struct stats *stats; 638}; 639 640struct s_parent { 641 time_t start; 642}; 643 644struct s_queue { 645 size_t inserts_local; 646 size_t inserts_remote; 647}; 648 649struct s_runner { 650 size_t active; 651 size_t bounces_active; 652 size_t bounces; 653}; 654 655struct s_session { 656 size_t sessions; 657 size_t sessions_active; 658 659 size_t smtps; 660 size_t smtps_active; 661 662 size_t starttls; 663 size_t starttls_active; 664 665 size_t read_error; 666 size_t read_timeout; 667 size_t read_eof; 668 size_t write_error; 669 size_t write_timeout; 670 size_t write_eof; 671 size_t toofast; 672 size_t tempfail; 673 size_t linetoolong; 674 size_t delays; 675}; 676 677struct s_mda { 678 size_t sessions; 679 size_t sessions_active; 680}; 681 682struct s_control { 683 size_t sessions; 684 size_t sessions_active; 685}; 686 687struct stats { 688 struct s_parent parent; 689 struct s_queue queue; 690 struct s_runner runner; 691 struct s_session mta; 692 struct s_mda mda; 693 struct s_session smtp; 694 struct s_control control; 695}; 696 697struct sched { 698 int fd; 699 char mid[MAX_ID_SIZE]; 700 int ret; 701}; 702 703struct reload { 704 int fd; 705 int ret; 706}; 707 708struct submit_status { 709 u_int64_t id; 710 int code; 711 union submit_path { 712 struct path path; 713 char msgid[MAX_ID_SIZE]; 714 char errormsg[MAX_LINE_SIZE]; 715 } u; 716 enum message_flags flags; 717 struct sockaddr_storage ss; 718 struct message msg; 719}; 720 721struct forward_req { 722 u_int64_t id; 723 u_int8_t status; 724 char pw_name[MAXLOGNAME]; 725}; 726 727struct dns { 728 u_int64_t id; 729 char host[MAXHOSTNAMELEN]; 730 int port; 731 int error; 732 struct sockaddr_storage ss; 733 struct smtpd *env; 734 struct dns *next; 735}; 736 737struct secret { 738 u_int64_t id; 739 char host[MAXHOSTNAMELEN]; 740 char secret[MAX_LINE_SIZE]; 741}; 742 743struct rulematch { 744 u_int64_t id; 745 struct submit_status ss; 746}; 747 748enum lkasession_flags { 749 F_ERROR = 0x1 750}; 751 752struct lkasession { 753 SPLAY_ENTRY(lkasession) nodes; 754 u_int64_t id; 755 756 struct path path; 757 struct deliverylist deliverylist; 758 759 RB_HEAD(expandtree, expand_node) expandtree; 760 761 u_int8_t iterations; 762 u_int32_t pending; 763 enum lkasession_flags flags; 764 struct message message; 765 struct submit_status ss; 766}; 767 768enum mta_state { 769 MTA_INVALID_STATE, 770 MTA_INIT, 771 MTA_SECRET, 772 MTA_DATA, 773 MTA_MX, 774 MTA_CONNECT, 775 MTA_PTR, 776 MTA_PROTOCOL, 777 MTA_DONE 778}; 779 780/* mta session flags */ 781#define MTA_FORCE_ANYSSL 0x1 782#define MTA_FORCE_SMTPS 0x2 783#define MTA_ALLOW_PLAIN 0x4 784#define MTA_USE_AUTH 0x8 785 786struct mta_relay { 787 TAILQ_ENTRY(mta_relay) entry; 788 struct sockaddr_storage sa; 789 char fqdn[MAXHOSTNAMELEN]; 790 int used; 791}; 792 793struct mta_session { 794 SPLAY_ENTRY(mta_session) entry; 795 u_int64_t id; 796 struct smtpd *env; 797 enum mta_state state; 798 char *host; 799 int port; 800 int flags; 801 TAILQ_HEAD(,message) recipients; 802 TAILQ_HEAD(,mta_relay) relays; 803 char *secret; 804 int fd; 805 int datafd; 806 struct event ev; 807 char *cert; 808 void *pcb; 809}; 810 811/* aliases.c */ 812int aliases_exist(struct smtpd *, objid_t, char *); 813int aliases_get(struct smtpd *, objid_t, struct expandtree *, char *); 814int aliases_vdomain_exists(struct smtpd *, objid_t, char *); 815int aliases_virtual_exist(struct smtpd *, objid_t, struct path *); 816int aliases_virtual_get(struct smtpd *, objid_t, struct expandtree *, struct path *); 817int alias_parse(struct alias *, char *); 818void alias_to_expand_node(struct expand_node *, struct alias *); 819 820/* authenticate.c */ 821int authenticate_user(char *, char *); 822 823/* bounce.c */ 824void bounce_process(struct smtpd *, struct message *); 825int bounce_session(struct smtpd *, int, struct message *); 826int bounce_session_switch(struct smtpd *, FILE *, enum session_state *, char *, 827 struct message *); 828 829/* log.c */ 830void log_init(int); 831void log_verbose(int); 832void log_warn(const char *, ...) 833 __attribute__ ((format (printf, 1, 2))); 834void log_warnx(const char *, ...) 835 __attribute__ ((format (printf, 1, 2))); 836void log_info(const char *, ...) 837 __attribute__ ((format (printf, 1, 2))); 838void log_debug(const char *, ...) 839 __attribute__ ((format (printf, 1, 2))); 840__dead void fatal(const char *); 841__dead void fatalx(const char *); 842 843 844/* dns.c */ 845void dns_query_a(struct smtpd *, char *, int, u_int64_t); 846void dns_query_mx(struct smtpd *, char *, int, u_int64_t); 847void dns_query_ptr(struct smtpd *, struct sockaddr_storage *, 848 u_int64_t); 849void dns_async(struct smtpd *, struct imsgev *, int, 850 struct dns *); 851/* expand.c */ 852int expand_cmp(struct expand_node *, struct expand_node *); 853void expandtree_increment_node(struct expandtree *, struct expand_node *); 854void expandtree_decrement_node(struct expandtree *, struct expand_node *); 855void expandtree_remove_node(struct expandtree *, struct expand_node *); 856struct expand_node *expandtree_lookup(struct expandtree *, struct expand_node *); 857RB_PROTOTYPE(expandtree, expand_node, nodes, expand_cmp); 858 859/* forward.c */ 860int forwards_get(int, struct expandtree *); 861 862/* smtpd.c */ 863int child_cmp(struct child *, struct child *); 864SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 865void imsg_event_add(struct imsgev *); 866int imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 867 int, void *, u_int16_t); 868 869/* lka.c */ 870pid_t lka(struct smtpd *); 871int lkasession_cmp(struct lkasession *, struct lkasession *); 872SPLAY_PROTOTYPE(lkatree, lkasession, nodes, lkasession_cmp); 873 874/* mfa.c */ 875pid_t mfa(struct smtpd *); 876int msg_cmp(struct message *, struct message *); 877 878/* queue.c */ 879pid_t queue(struct smtpd *); 880int queue_load_envelope(struct message *, char *); 881int queue_update_envelope(struct message *); 882int queue_remove_envelope(struct message *); 883void queue_submit_envelope(struct smtpd *, struct message *); 884void queue_commit_envelopes(struct smtpd *, struct message*); 885int batch_cmp(struct batch *, struct batch *); 886struct batch *batch_by_id(struct smtpd *, u_int64_t); 887u_int16_t queue_hash(char *); 888 889/* queue_shared.c */ 890int queue_create_layout_message(char *, char *); 891void queue_delete_layout_message(char *, char *); 892int queue_record_layout_envelope(char *, struct message *); 893int queue_remove_layout_envelope(char *, struct message *); 894int queue_commit_layout_message(char *, struct message *); 895int queue_open_layout_messagefile(char *, struct message *); 896int enqueue_create_layout(char *); 897void enqueue_delete_message(char *); 898int enqueue_record_envelope(struct message *); 899int enqueue_remove_envelope(struct message *); 900int enqueue_commit_message(struct message *); 901int enqueue_open_messagefile(struct message *); 902int bounce_create_layout(char *, struct message *); 903void bounce_delete_message(char *); 904int bounce_record_envelope(struct message *); 905int bounce_remove_envelope(struct message *); 906int bounce_commit_message(struct message *); 907int bounce_record_message(struct message *); 908int queue_create_incoming_layout(char *); 909void queue_delete_incoming_message(char *); 910int queue_record_incoming_envelope(struct message *); 911int queue_remove_incoming_envelope(struct message *); 912int queue_commit_incoming_message(struct message *); 913int queue_open_incoming_message_file(struct message *); 914int queue_open_message_file(char *msgid); 915void queue_message_update(struct message *); 916void queue_delete_message(char *); 917struct qwalk *qwalk_new(char *); 918int qwalk(struct qwalk *, char *); 919void qwalk_close(struct qwalk *); 920void show_queue(char *, int); 921 922u_int16_t queue_hash(char *); 923 924/* map.c */ 925char *map_dblookup(struct smtpd *, objid_t, char *); 926char *map_dblookupbyname(struct smtpd *, char *, char *); 927 928/* mda.c */ 929pid_t mda(struct smtpd *); 930 931/* mta.c */ 932pid_t mta(struct smtpd *); 933int mta_session_cmp(struct mta_session *, struct mta_session *); 934SPLAY_PROTOTYPE(mtatree, mta_session, entry, mta_session_cmp); 935 936/* control.c */ 937pid_t control(struct smtpd *); 938void session_socket_blockmode(int, enum blockmodes); 939void session_socket_no_linger(int); 940int session_socket_error(int); 941 942/* enqueue.c */ 943int enqueue(int, char **); 944int enqueue_offline(int, char **); 945 946/* runner.c */ 947pid_t runner(struct smtpd *); 948void message_reset_flags(struct message *); 949SPLAY_PROTOTYPE(batchtree, batch, b_nodes, batch_cmp); 950 951/* smtp.c */ 952pid_t smtp(struct smtpd *); 953void smtp_resume(struct smtpd *); 954 955/* smtp_session.c */ 956void session_init(struct listener *, struct session *); 957int session_cmp(struct session *, struct session *); 958void session_pickup(struct session *, struct submit_status *); 959void session_destroy(struct session *); 960void session_respond(struct session *, char *, ...) 961 __attribute__ ((format (printf, 2, 3))); 962void session_bufferevent_new(struct session *); 963 964SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 965 966/* config.c */ 967#define PURGE_LISTENERS 0x01 968#define PURGE_MAPS 0x02 969#define PURGE_RULES 0x04 970#define PURGE_SSL 0x08 971#define PURGE_EVERYTHING 0xff 972void purge_config(struct smtpd *, u_int8_t); 973void unconfigure(struct smtpd *); 974void configure(struct smtpd *); 975void init_pipes(struct smtpd *); 976void config_pipes(struct smtpd *, struct peer *, u_int); 977void config_peers(struct smtpd *, struct peer *, u_int); 978 979/* parse.y */ 980int parse_config(struct smtpd *, const char *, int); 981int cmdline_symset(char *); 982 983/* ssl.c */ 984void ssl_init(void); 985void ssl_transaction(struct session *); 986 987void ssl_session_init(struct session *); 988void ssl_session_destroy(struct session *); 989int ssl_load_certfile(struct smtpd *, const char *, u_int8_t); 990void ssl_setup(struct smtpd *, struct listener *); 991int ssl_cmp(struct ssl *, struct ssl *); 992SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 993 994/* ssl_privsep.c */ 995int ssl_ctx_use_private_key(void *, char *, off_t); 996int ssl_ctx_use_certificate_chain(void *, char *, off_t); 997 998/* map.c */ 999struct map *map_find(struct smtpd *, objid_t); 1000struct map *map_findbyname(struct smtpd *, const char *); 1001 1002/* util.c */ 1003typedef struct arglist arglist; 1004struct arglist { 1005 char **list; 1006 u_int num; 1007 u_int nalloc; 1008}; 1009void addargs(arglist *, char *, ...) 1010 __attribute__((format(printf, 2, 3))); 1011int bsnprintf(char *, size_t, const char *, ...) 1012 __attribute__ ((format (printf, 3, 4))); 1013int safe_fclose(FILE *); 1014int hostname_match(char *, char *); 1015int recipient_to_path(struct path *, char *); 1016int valid_localpart(char *); 1017int valid_domainpart(char *); 1018char *ss_to_text(struct sockaddr_storage *); 1019int valid_message_id(char *); 1020int valid_message_uid(char *); 1021char *time_to_text(time_t); 1022int secure_file(int, char *, struct passwd *, int); 1023void lowercase(char *, char *, size_t); 1024void message_set_errormsg(struct message *, char *, ...); 1025char *message_get_errormsg(struct message *); 1026void sa_set_port(struct sockaddr *, int); 1027struct path *path_dup(struct path *); 1028u_int64_t generate_uid(void); 1029void fdlimit(double); 1030int availdesc(void); 1031