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