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