smtpd.h revision 1.66
1/* $OpenBSD: smtpd.h,v 1.66 2009/01/30 21:22:33 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#define CONF_FILE "/etc/mail/smtpd.conf" 21#define MAX_LISTEN 16 22#define PROC_COUNT 9 23#define READ_BUF_SIZE 32768 24#define MAX_NAME_SIZE 64 25 26#define MAX_HOPS_COUNT 100 27 28/* sizes include the tailing '\0' */ 29#define MAX_LINE_SIZE 1024 30#define MAX_LOCALPART_SIZE 65 31#define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN 32#define MAX_ID_SIZE 64 33 34/* return and forward path size */ 35#define MAX_PATH_SIZE 256 36 37/*#define SMTPD_CONNECT_TIMEOUT (60)*/ 38#define SMTPD_CONNECT_TIMEOUT (10) 39#define SMTPD_QUEUE_INTERVAL (15 * 60) 40#define SMTPD_QUEUE_MAXINTERVAL (4 * 60 * 60) 41#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 42#define SMTPD_USER "_smtpd" 43#define SMTPD_SOCKET "/var/run/smtpd.sock" 44#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 45#define SMTPD_SESSION_TIMEOUT 300 46#define SMTPD_BACKLOG 5 47 48#define DIRHASH_BUCKETS 4096 49 50#define PATH_SPOOL "/var/spool/smtpd" 51 52#define PATH_ENQUEUE "/enqueue" 53#define PATH_INCOMING "/incoming" 54#define PATH_QUEUE "/queue" 55#define PATH_PURGE "/purge" 56 57#define PATH_MESSAGE "/message" 58#define PATH_ENVELOPES "/envelopes" 59 60#define PATH_RUNQUEUE "/runqueue" 61#define PATH_RUNQUEUEHIGH "/runqueue-high" 62#define PATH_RUNQUEUELOW "/runqueue-low" 63 64/* used by newaliases */ 65#define PATH_ALIASES "/etc/mail/aliases" 66#define PATH_ALIASESDB "/etc/mail/aliases.db" 67 68/* number of MX records to lookup */ 69#define MXARRAYSIZE 5 70 71/* rfc5321 limits */ 72#define SMTP_TEXTLINE_MAX 1000 73#define SMTP_CMDLINE_MAX 512 74 75#define F_STARTTLS 0x01 76#define F_SSMTP 0x02 77#define F_AUTH 0x04 78#define F_SSL (F_SSMTP|F_STARTTLS) 79 80 81struct netaddr { 82 struct sockaddr_storage ss; 83 int bits; 84}; 85 86struct relayhost { 87 u_int8_t flags; 88 char hostname[MAXHOSTNAMELEN]; 89 u_int16_t port; 90}; 91 92struct mxhost { 93 u_int8_t flags; 94 struct sockaddr_storage ss; 95}; 96 97/* buffer specific headers */ 98struct buf { 99 TAILQ_ENTRY(buf) entry; 100 u_char *buf; 101 size_t size; 102 size_t max; 103 size_t wpos; 104 size_t rpos; 105 int fd; 106}; 107 108struct msgbuf { 109 TAILQ_HEAD(, buf) bufs; 110 u_int32_t queued; 111 int fd; 112}; 113 114struct buf_read { 115 u_char buf[READ_BUF_SIZE]; 116 u_char *rptr; 117 size_t wpos; 118}; 119 120struct imsg_fd { 121 TAILQ_ENTRY(imsg_fd) entry; 122 int fd; 123 u_int32_t id; 124}; 125 126struct imsgbuf { 127 TAILQ_HEAD(, imsg_fd) fds; 128 struct buf_read r; 129 struct msgbuf w; 130 struct event ev; 131 void (*handler)(int, short, void *); 132 int fd; 133 pid_t pid; 134 short events; 135 void *data; 136 u_int32_t id; 137}; 138 139struct imsg_hdr { 140 u_int16_t type; 141 u_int16_t len; 142 u_int32_t peerid; 143 pid_t pid; 144}; 145 146struct imsg { 147 struct imsg_hdr hdr; 148 u_int32_t id; 149 void *data; 150}; 151 152enum imsg_type { 153 IMSG_NONE, 154 IMSG_CTL_OK, /* answer to smtpctl requests */ 155 IMSG_CTL_FAIL, 156 IMSG_CTL_SHUTDOWN, 157 IMSG_CONF_START, 158 IMSG_CONF_SSL, 159 IMSG_CONF_SSL_CERT, 160 IMSG_CONF_SSL_KEY, 161 IMSG_CONF_LISTENER, 162 IMSG_CONF_MAP, 163 IMSG_CONF_RULE, 164 IMSG_CONF_CONDITION, 165 IMSG_CONF_OPTION, 166 IMSG_CONF_END, 167 IMSG_CONF_RELOAD, 168 IMSG_LKA_MAIL, 169 IMSG_LKA_RCPT, 170 IMSG_LKA_MX, 171 IMSG_LKA_HOST, 172 IMSG_MDA_MAILBOX_FILE, 173 IMSG_MDA_MESSAGE_FILE, 174 IMSG_MFA_RCPT, 175 IMSG_MFA_MAIL, 176 177 IMSG_QUEUE_CREATE_MESSAGE, 178 IMSG_QUEUE_SUBMIT_ENVELOPE, 179 IMSG_QUEUE_COMMIT_ENVELOPES, 180 IMSG_QUEUE_REMOVE_MESSAGE, 181 IMSG_QUEUE_COMMIT_MESSAGE, 182 IMSG_QUEUE_TEMPFAIL, 183 IMSG_QUEUE_STATS, 184 185 IMSG_QUEUE_REMOVE_SUBMISSION, 186 IMSG_QUEUE_MESSAGE_UPDATE, 187 IMSG_QUEUE_MESSAGE_FD, 188 IMSG_QUEUE_MESSAGE_FILE, 189 190 IMSG_RUNNER_UPDATE_ENVELOPE, 191 IMSG_RUNNER_STATS, 192 193 IMSG_BATCH_CREATE, 194 IMSG_BATCH_APPEND, 195 IMSG_BATCH_CLOSE, 196 197 IMSG_PARENT_MAILBOX_OPEN, 198 IMSG_PARENT_MESSAGE_OPEN, 199 IMSG_PARENT_MAILBOX_RENAME, 200 IMSG_PARENT_STATS, 201 202 IMSG_PARENT_AUTHENTICATE, 203 IMSG_PARENT_SEND_CONFIG, 204 205 IMSG_MDA_PAUSE, 206 IMSG_MTA_PAUSE, 207 IMSG_SMTP_PAUSE, 208 IMSG_SMTP_STATS, 209 210 IMSG_MDA_RESUME, 211 IMSG_MTA_RESUME, 212 IMSG_SMTP_RESUME, 213 214 IMSG_STATS 215}; 216 217#define IMSG_HEADER_SIZE sizeof(struct imsg_hdr) 218#define MAX_IMSGSIZE 16384 219 220enum blockmodes { 221 BM_NORMAL, 222 BM_NONBLOCK 223}; 224 225struct ctl_conn { 226 TAILQ_ENTRY(ctl_conn) entry; 227 u_int8_t flags; 228#define CTL_CONN_NOTIFY 0x01 229 struct imsgbuf ibuf; 230}; 231TAILQ_HEAD(ctl_connlist, ctl_conn); 232 233typedef u_int32_t objid_t; 234 235struct ctl_id { 236 objid_t id; 237 char name[MAX_NAME_SIZE]; 238}; 239 240enum smtp_proc_type { 241 PROC_PARENT = 0, 242 PROC_SMTP, 243 PROC_MFA, 244 PROC_LKA, 245 PROC_QUEUE, 246 PROC_MDA, 247 PROC_MTA, 248 PROC_CONTROL, 249 PROC_RUNNER, 250} smtpd_process; 251 252struct peer { 253 enum smtp_proc_type id; 254 void (*cb)(int, short, void *); 255}; 256 257enum map_type { 258 T_SINGLE, 259 T_LIST, 260 T_HASH 261}; 262 263enum map_src { 264 S_NONE, 265 S_DYN, 266 S_DNS, 267 S_FILE, 268 S_DB, 269 S_EXT 270}; 271 272enum mapel_type { 273 ME_STRING, 274 ME_NET, 275 ME_NETMASK 276}; 277 278struct mapel { 279 TAILQ_ENTRY(mapel) me_entry; 280 union mapel_data { 281 char med_string[MAX_LINE_SIZE]; 282 struct netaddr med_addr; 283 } me_key; 284 union mapel_data me_val; 285}; 286 287struct map { 288 TAILQ_ENTRY(map) m_entry; 289#define F_USED 0x01 290#define F_DYNAMIC 0x02 291 u_int8_t m_flags; 292 char m_name[MAX_LINE_SIZE]; 293 objid_t m_id; 294 enum map_type m_type; 295 enum mapel_type m_eltype; 296 enum map_src m_src; 297 char m_config[MAXPATHLEN]; 298 TAILQ_HEAD(mapel_list, mapel) m_contents; 299}; 300 301enum cond_type { 302 C_ALL, 303 C_NET, 304 C_DOM 305}; 306 307struct cond { 308 TAILQ_ENTRY(cond) c_entry; 309 objid_t c_map; 310 enum cond_type c_type; 311 struct map *c_match; 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_RELAY, 326 A_RELAYVIA, 327 A_MAILDIR, 328 A_MBOX, 329 A_FILENAME, 330 A_EXT 331}; 332#define IS_MAILBOX(x) ((x) == A_MAILDIR || (x) == A_MBOX || (x) == A_FILENAME) 333#define IS_RELAY(x) ((x) == A_RELAY || (x) == A_RELAYVIA) 334#define IS_EXT(x) ((x) == A_EXT) 335 336struct rule { 337 TAILQ_ENTRY(rule) r_entry; 338 int r_accept; 339 struct map *r_sources; 340 TAILQ_HEAD(condlist, cond) r_conditions; 341 enum action_type r_action; 342 union rule_dest { 343 char path[MAXPATHLEN]; 344 struct relayhost relayhost; 345#define MAXCOMMANDLEN 256 346 char command[MAXCOMMANDLEN]; 347 } r_value; 348 TAILQ_HEAD(optlist, opt) r_options; 349}; 350 351enum path_flags { 352 F_ALIAS = 0x1, 353 F_VIRTUAL = 0x2, 354 F_EXPANDED = 0x4, 355 F_NOFORWARD = 0x8, 356 F_FORWARDED = 0x10, 357 F_ACCOUNT = 0x20, 358}; 359 360struct path { 361 TAILQ_ENTRY(path) entry; 362 struct rule rule; 363 enum path_flags flags; 364 u_int8_t forwardcnt; 365 char user[MAX_LOCALPART_SIZE]; 366 char domain[MAX_DOMAINPART_SIZE]; 367 char pw_name[MAXLOGNAME]; 368 union path_data { 369 char filename[MAXPATHLEN]; 370 char filter[MAXPATHLEN]; 371 } u; 372}; 373 374enum alias_type { 375 ALIAS_USERNAME, 376 ALIAS_FILENAME, 377 ALIAS_FILTER, 378 ALIAS_INCLUDE, 379 ALIAS_ADDRESS 380}; 381 382struct alias { 383 TAILQ_ENTRY(alias) entry; 384 enum alias_type type; 385 union alias_data { 386 char username[MAXLOGNAME]; 387 char filename[MAXPATHLEN]; 388 char filter[MAXPATHLEN]; 389 struct path path; 390 } u; 391}; 392TAILQ_HEAD(aliaseslist, alias); 393 394enum message_type { 395 T_MDA_MESSAGE = 0x1, 396 T_MTA_MESSAGE = 0x2, 397 T_DAEMON_MESSAGE = 0x4 398}; 399 400enum message_status { 401 S_MESSAGE_LOCKFAILURE = 0x1, 402 S_MESSAGE_PERMFAILURE = 0x2, 403 S_MESSAGE_TEMPFAILURE = 0x4, 404 S_MESSAGE_REJECTED = 0x8, 405 S_MESSAGE_ACCEPTED = 0x10, 406 S_MESSAGE_RETRY = 0x20, 407 S_MESSAGE_EDNS = 0x40, 408 S_MESSAGE_ECONNECT = 0x80 409}; 410 411enum message_flags { 412 F_MESSAGE_RESOLVED = 0x1, 413 F_MESSAGE_SCHEDULED = 0x2, 414 F_MESSAGE_PROCESSING = 0x4, 415 F_MESSAGE_AUTHENTICATED = 0x8, 416 F_MESSAGE_ENQUEUED = 0x10 417}; 418 419struct message { 420 SPLAY_ENTRY(message) nodes; 421 TAILQ_ENTRY(message) entry; 422 423 enum message_type type; 424 425 u_int64_t id; 426 u_int64_t session_id; 427 u_int64_t batch_id; 428 429 char message_id[MAX_ID_SIZE]; 430 char message_uid[MAX_ID_SIZE]; 431 432 char session_helo[MAXHOSTNAMELEN]; 433 char session_hostname[MAXHOSTNAMELEN]; 434 char session_errorline[MAX_LINE_SIZE]; 435 struct sockaddr_storage session_ss; 436 struct path session_rcpt; 437 438 struct path sender; 439 struct path recipient; 440 TAILQ_HEAD(pathlist,path) recipients; 441 442 u_int16_t rcptcount; 443 444 time_t creation; 445 time_t lasttry; 446 u_int8_t retry; 447 enum message_flags flags; 448 enum message_status status; 449 FILE *datafp; 450 int mboxfd; 451 int messagefd; 452}; 453 454enum batch_status { 455 S_BATCH_PERMFAILURE = 0x1, 456 S_BATCH_TEMPFAILURE = 0x2, 457 S_BATCH_REJECTED = 0x4, 458 S_BATCH_ACCEPTED = 0x8, 459 S_BATCH_RETRY = 0x10, 460 S_BATCH_EDNS = 0x20, 461 S_BATCH_ECONNECT = 0x40 462}; 463 464enum batch_type { 465 T_MDA_BATCH = 0x1, 466 T_MTA_BATCH = 0x2, 467 T_DAEMON_BATCH = 0x4 468}; 469 470enum batch_flags { 471 F_BATCH_COMPLETE = 0x1, 472 F_BATCH_RESOLVED = 0x2, 473 F_BATCH_SCHEDULED = 0x4, 474 F_BATCH_EXPIRED = 0x8, 475}; 476 477struct mdaproc { 478 SPLAY_ENTRY(mdaproc) mdaproc_nodes; 479 480 pid_t pid; 481}; 482 483struct batch { 484 SPLAY_ENTRY(batch) b_nodes; 485 486 u_int64_t id; 487 u_int64_t session_id; 488 enum batch_type type; 489 enum batch_flags flags; 490 491 struct rule rule; 492 493 struct smtpd *env; 494 495 char message_id[MAX_ID_SIZE]; 496 char hostname[MAXHOSTNAMELEN]; 497 char errorline[MAX_LINE_SIZE]; 498 499 char session_helo[MAXHOSTNAMELEN]; 500 char session_hostname[MAXHOSTNAMELEN]; 501 struct sockaddr_storage session_ss; 502 503 int8_t getaddrinfo_error; 504 struct mxhost mxarray[MXARRAYSIZE*2]; 505 u_int8_t mx_cnt; 506 u_int8_t mx_off; 507 508 time_t creation; 509 time_t lasttry; 510 u_int8_t retry; 511 512 struct session *sessionp; 513 514 struct message message; 515 struct message *messagep; 516 FILE *messagefp; 517 TAILQ_HEAD(messagelist, message) messages; 518 519 enum batch_status status; 520}; 521 522enum session_state { 523 S_INIT = 0, 524 S_GREETED, 525 S_TLS, 526 S_AUTH_INIT, 527 S_AUTH_USERNAME, 528 S_AUTH_PASSWORD, 529 S_AUTH_FINALIZE, 530 S_HELO, 531 S_MAILREQUEST, 532 S_MAIL, 533 S_RCPTREQUEST, 534 S_RCPT, 535 S_DATAREQUEST, 536 S_DATA, 537 S_DATACONTENT, 538 S_DONE, 539 S_QUIT 540}; 541#define IS_AUTH(x) ((x) == S_AUTH_INIT || (x) == S_AUTH_USERNAME || (x) == S_AUTH_PASSWORD || (x) == S_AUTH_FINALIZE) 542 543struct ssl { 544 SPLAY_ENTRY(ssl) ssl_nodes; 545 char ssl_name[PATH_MAX]; 546 char *ssl_cert; 547 off_t ssl_cert_len; 548 char *ssl_key; 549 off_t ssl_key_len; 550}; 551 552struct listener { 553 u_int8_t flags; 554 int fd; 555 struct sockaddr_storage ss; 556 in_port_t port; 557 struct timeval timeout; 558 struct event ev; 559 struct smtpd *env; 560 char ssl_cert_name[PATH_MAX]; 561 struct ssl *ssl; 562 void *ssl_ctx; 563 TAILQ_ENTRY(listener) entry; 564}; 565 566struct session_auth_req { 567 u_int64_t session_id; 568 char buffer[MAX_LINE_SIZE]; 569}; 570 571struct session_auth_reply { 572 u_int64_t session_id; 573 u_int8_t value; 574}; 575 576enum session_flags { 577 F_EHLO = 0x1, 578 F_QUIT = 0x2, 579 F_8BITMIME = 0x4, 580 F_SECURE = 0x8, 581 F_AUTHENTICATED = 0x10, 582 F_PEERHASTLS = 0x20, 583 F_EVLOCKED = 0x40 584}; 585 586struct session { 587 SPLAY_ENTRY(session) s_nodes; 588 u_int64_t s_id; 589 590 enum session_flags s_flags; 591 enum session_state s_state; 592 time_t s_tm; 593 int s_fd; 594 struct sockaddr_storage s_ss; 595 char s_hostname[MAXHOSTNAMELEN]; 596 struct event s_ev; 597 struct bufferevent *s_bev; 598 struct listener *s_l; 599 struct smtpd *s_env; 600 void *s_ssl; 601 u_char *s_buf; 602 int s_buflen; 603 struct timeval s_tv; 604 struct message s_msg; 605 606 struct session_auth_req s_auth; 607 608 struct mxhost *mxarray; 609 u_int8_t mx_cnt; 610 u_int8_t mx_off; 611 612 struct batch *batch; 613 614}; 615 616struct smtpd { 617#define SMTPD_OPT_VERBOSE 0x00000001 618#define SMTPD_OPT_NOACTION 0x00000002 619 u_int32_t sc_opts; 620#define SMTPD_CONFIGURING 0x00000001 621#define SMTPD_EXITING 0x00000002 622#define SMTPD_MDA_PAUSED 0x00000004 623#define SMTPD_MTA_PAUSED 0x00000008 624#define SMTPD_SMTP_PAUSED 0x00000010 625 u_int32_t sc_flags; 626 struct timeval sc_qintval; 627 u_int32_t sc_maxconn; 628 struct event sc_ev; 629 int sc_pipes[PROC_COUNT] 630 [PROC_COUNT][2]; 631 struct imsgbuf *sc_ibufs[PROC_COUNT]; 632 struct passwd *sc_pw; 633 char sc_hostname[MAXHOSTNAMELEN]; 634 TAILQ_HEAD(listenerlist, listener) sc_listeners; 635 TAILQ_HEAD(maplist, map) *sc_maps; 636 TAILQ_HEAD(rulelist, rule) *sc_rules; 637 SPLAY_HEAD(sessiontree, session) sc_sessions; 638 SPLAY_HEAD(msgtree, message) sc_messages; 639 SPLAY_HEAD(ssltree, ssl) sc_ssl; 640 641 SPLAY_HEAD(batchtree, batch) batch_queue; 642 SPLAY_HEAD(mdaproctree, mdaproc) mdaproc_queue; 643}; 644 645struct s_parent { 646 time_t start; 647}; 648 649struct s_queue { 650 size_t inserts; 651}; 652 653struct s_runner { 654 size_t active; 655}; 656 657struct s_smtp { 658 size_t sessions; 659 size_t ssmtp; 660 size_t starttls; 661}; 662 663struct stats { 664 int fd; 665 union u_stats { 666 struct s_parent parent; 667 struct s_queue queue; 668 struct s_runner runner; 669 struct s_smtp smtp; 670 } u; 671}; 672 673struct submit_status { 674 u_int64_t id; 675 int code; 676 union submit_path { 677 struct path path; 678 char msgid[MAX_ID_SIZE]; 679 char errormsg[MAX_LINE_SIZE]; 680 } u; 681 enum message_flags flags; 682 struct sockaddr_storage ss; 683 struct message msg; 684}; 685 686struct message_recipient { 687 u_int64_t id; 688 struct sockaddr_storage ss; 689 enum message_flags flags; 690 struct path path; 691 struct message msg; 692}; 693 694 695/* aliases.c */ 696int aliases_exist(struct smtpd *, char *); 697int aliases_get(struct smtpd *, struct aliaseslist *, char *); 698int aliases_virtual_exist(struct smtpd *, struct path *); 699int aliases_virtual_get(struct smtpd *, struct aliaseslist *, struct path *); 700int alias_parse(struct alias *, char *); 701 702 703/* log.c */ 704void log_init(int); 705void log_warn(const char *, ...) 706 __attribute__ ((format (printf, 1, 2))); 707void log_warnx(const char *, ...) 708 __attribute__ ((format (printf, 1, 2))); 709void log_info(const char *, ...) 710 __attribute__ ((format (printf, 1, 2))); 711void log_debug(const char *, ...) 712 __attribute__ ((format (printf, 1, 2))); 713__dead void fatal(const char *); 714__dead void fatalx(const char *); 715 716 717/* buffer.c */ 718struct buf *buf_open(size_t); 719struct buf *buf_dynamic(size_t, size_t); 720int buf_add(struct buf *, void *, size_t); 721void *buf_reserve(struct buf *, size_t); 722int buf_close(struct msgbuf *, struct buf *); 723void buf_free(struct buf *); 724void msgbuf_init(struct msgbuf *); 725void msgbuf_clear(struct msgbuf *); 726int msgbuf_write(struct msgbuf *); 727 728 729/* dns.c */ 730size_t getmxbyname(char *, char ***); 731 732 733/* forward.c */ 734int forwards_get(struct aliaseslist *, char *); 735 736 737/* imsg.c */ 738void imsg_init(struct imsgbuf *, int, void (*)(int, short, void *)); 739ssize_t imsg_read(struct imsgbuf *); 740ssize_t imsg_get(struct imsgbuf *, struct imsg *); 741int imsg_compose(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t, 742 int, void *, u_int16_t); 743int imsg_composev(struct imsgbuf *, enum imsg_type, u_int32_t, 744 pid_t, int, const struct iovec *, int); 745int imsg_compose_fds(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t, 746 void *, u_int16_t, int, ...); 747struct buf *imsg_create(struct imsgbuf *, enum imsg_type, u_int32_t, pid_t, 748 u_int16_t); 749int imsg_add(struct buf *, void *, u_int16_t); 750int imsg_append(struct imsgbuf *, struct buf *); 751int imsg_close(struct imsgbuf *, struct buf *); 752void imsg_free(struct imsg *); 753void imsg_event_add(struct imsgbuf *); /* needs to be provided externally */ 754int imsg_get_fd(struct imsgbuf *, struct imsg *); 755int imsg_flush(struct imsgbuf *); 756void imsg_clear(struct imsgbuf *); 757 758/* lka.c */ 759pid_t lka(struct smtpd *); 760 761/* mfa.c */ 762pid_t mfa(struct smtpd *); 763int msg_cmp(struct message *, struct message *); 764SPLAY_PROTOTYPE(msgtree, message, nodes, msg_cmp); 765 766/* queue.c */ 767pid_t queue(struct smtpd *); 768u_int64_t queue_generate_id(void); 769int queue_remove_batch_message(struct smtpd *, struct batch *, 770 struct message *); 771int queue_load_envelope(struct message *, char *); 772int queue_update_envelope(struct message *); 773int queue_remove_envelope(struct message *); 774int batch_cmp(struct batch *, struct batch *); 775struct batch *batch_by_id(struct smtpd *, u_int64_t); 776struct message *message_by_id(struct smtpd *, struct batch *, u_int64_t); 777u_int16_t queue_hash(char *); 778 779/* queue_shared.c */ 780int queue_create_layout_message(char *, char *); 781void queue_delete_layout_message(char *, char *); 782int queue_record_layout_envelope(char *, struct message *); 783int queue_remove_layout_envelope(char *, struct message *); 784int queue_commit_layout_message(char *, struct message *); 785int queue_open_layout_messagefile(char *, struct message *); 786int enqueue_create_layout(char *); 787void enqueue_delete_message(char *); 788int enqueue_record_envelope(struct message *); 789int enqueue_remove_envelope(struct message *); 790int enqueue_commit_message(struct message *); 791int enqueue_open_messagefile(struct message *); 792int queue_create_incoming_layout(char *); 793void queue_delete_incoming_message(char *); 794int queue_record_incoming_envelope(struct message *); 795int queue_remove_incoming_envelope(struct message *); 796int queue_commit_incoming_message(struct message *); 797int queue_open_incoming_message_file(struct message *); 798int queue_open_message_file(char *msgid); 799void queue_message_update(struct message *); 800void queue_delete_message(char *); 801struct qwalk *qwalk_new(char *); 802int qwalk(struct qwalk *, char *); 803void qwalk_close(struct qwalk *); 804void show_queue(char *, int); 805 806u_int16_t queue_hash(char *); 807 808/* mda.c */ 809pid_t mda(struct smtpd *); 810int mdaproc_cmp(struct mdaproc *, struct mdaproc *); 811SPLAY_PROTOTYPE(mdaproctree, mdaproc, mdaproc_nodes, mdaproc_cmp); 812 813/* mta.c */ 814pid_t mta(struct smtpd *); 815 816/* control.c */ 817pid_t control(struct smtpd *); 818void session_socket_blockmode(int, enum blockmodes); 819 820/* runner.c */ 821pid_t runner(struct smtpd *); 822SPLAY_PROTOTYPE(batchtree, batch, b_nodes, batch_cmp); 823 824 825/* smtp.c */ 826pid_t smtp(struct smtpd *); 827void smtp_listener_setup(struct smtpd *, struct listener *); 828 829/* smtp_session.c */ 830void session_init(struct listener *, struct session *); 831int session_cmp(struct session *, struct session *); 832void session_pickup(struct session *, struct submit_status *); 833void session_destroy(struct session *); 834void session_respond(struct session *, char *, ...) 835 __attribute__ ((format (printf, 2, 3))); 836 837SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 838 839/* store.c */ 840int store_write_header(struct batch *, struct message *, FILE *, int); 841int store_write_message(struct batch *, struct message *); 842int store_write_daemon(struct batch *, struct message *); 843int store_message(struct batch *, struct message *, 844 int (*)(struct batch *, struct message *)); 845 846/* config.c */ 847#define PURGE_LISTENERS 0x01 848#define PURGE_MAPS 0x02 849#define PURGE_RULES 0x04 850#define PURGE_SSL 0x08 851#define PURGE_EVERYTHING 0xff 852void purge_config(struct smtpd *, u_int8_t); 853void unconfigure(struct smtpd *); 854void configure(struct smtpd *); 855void init_peers(struct smtpd *); 856void config_peers(struct smtpd *, struct peer *, u_int); 857 858/* parse.y */ 859int parse_config(struct smtpd *, const char *, int); 860int cmdline_symset(char *); 861 862/* ssl.c */ 863void ssl_init(void); 864void ssl_transaction(struct session *); 865 866void ssl_session_init(struct session *); 867void ssl_session_destroy(struct session *); 868int ssl_load_certfile(struct smtpd *, const char *); 869void ssl_setup(struct smtpd *, struct listener *); 870int ssl_cmp(struct ssl *, struct ssl *); 871SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 872 873/* ssl_privsep.c */ 874int ssl_ctx_use_private_key(void *, char *, off_t); 875int ssl_ctx_use_certificate_chain(void *, char *, off_t); 876 877/* smtpd.c */ 878struct map *map_find(struct smtpd *, objid_t); 879struct map *map_findbyname(struct smtpd *, const char *); 880 881/* util.c */ 882int bsnprintf(char *, size_t, const char *, ...) 883 __attribute__ ((format (printf, 3, 4))); 884int safe_fclose(FILE *); 885struct passwd *safe_getpwnam(const char *); 886struct passwd *safe_getpwuid(uid_t); 887int hostname_match(char *, char *); 888int recipient_to_path(struct path *, char *); 889