smtpd.h revision 1.313
1327Sjkh/* $OpenBSD: smtpd.h,v 1.313 2012/07/29 17:21:43 gilles Exp $ */ 2327Sjkh 3327Sjkh/* 4327Sjkh * Copyright (c) 2008 Gilles Chehade <gilles@openbsd.org> 5327Sjkh * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org> 6327Sjkh * 7327Sjkh * Permission to use, copy, modify, and distribute this software for any 8327Sjkh * purpose with or without fee is hereby granted, provided that the above 9327Sjkh * copyright notice and this permission notice appear in all copies. 10327Sjkh * 11327Sjkh * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12327Sjkh * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13327Sjkh * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14327Sjkh * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15327Sjkh * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16327Sjkh * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17327Sjkh * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18327Sjkh */ 19327Sjkh 20327Sjkh#ifndef nitems 21327Sjkh#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 22327Sjkh#endif 23327Sjkh 24327Sjkh#include "filter_api.h" 25327Sjkh#include "ioev.h" 26327Sjkh#include "iobuf.h" 27327Sjkh 28327Sjkh#define IMSG_SIZE_CHECK(p) do { \ 29327Sjkh if (IMSG_DATA_SIZE(&imsg) != sizeof(*p)) \ 30327Sjkh fatalx("bad length imsg received"); \ 31327Sjkh } while (0) 32327Sjkh#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE) 33327Sjkh 34327Sjkh 35327Sjkh#define CONF_FILE "/etc/mail/smtpd.conf" 36327Sjkh#define MAX_LISTEN 16 37327Sjkh#define PROC_COUNT 9 38327Sjkh#define MAX_NAME_SIZE 64 39327Sjkh 40327Sjkh#define MAX_HOPS_COUNT 100 41327Sjkh 42327Sjkh#define MAX_TAG_SIZE 32 43327Sjkh/* SYNC WITH filter.h */ 44327Sjkh//#define MAX_LINE_SIZE 1024 45327Sjkh//#define MAX_LOCALPART_SIZE 128 46327Sjkh//#define MAX_DOMAINPART_SIZE MAXHOSTNAMELEN 47327Sjkh 48327Sjkh/* return and forward path size */ 49327Sjkh#define MAX_FILTER_NAME 32 50327Sjkh#define MAX_PATH_SIZE 256 51327Sjkh#define MAX_RULEBUFFER_LEN 256 52327Sjkh 53327Sjkh#define SMTPD_QUEUE_INTERVAL (15 * 60) 54327Sjkh#define SMTPD_QUEUE_MAXINTERVAL (4 * 60 * 60) 55327Sjkh#define SMTPD_QUEUE_EXPIRY (4 * 24 * 60 * 60) 56327Sjkh#define SMTPD_USER "_smtpd" 57327Sjkh#define SMTPD_FILTER_USER "_smtpmfa" 58327Sjkh#define SMTPD_SOCKET "/var/run/smtpd.sock" 59327Sjkh#define SMTPD_BANNER "220 %s ESMTP OpenSMTPD" 60327Sjkh#define SMTPD_SESSION_TIMEOUT 300 61327Sjkh#define SMTPD_BACKLOG 5 62327Sjkh 63327Sjkh#define PATH_SMTPCTL "/usr/sbin/smtpctl" 64327Sjkh 65327Sjkh#define DIRHASH_BUCKETS 4096 66327Sjkh 67327Sjkh#define PATH_SPOOL "/var/spool/smtpd" 68327Sjkh#define PATH_OFFLINE "/offline" 69327Sjkh#define PATH_PURGE "/purge" 70327Sjkh#define PATH_INCOMING "/incoming" 71327Sjkh#define PATH_ENVELOPES "/envelopes" 72327Sjkh#define PATH_MESSAGE "/message" 73327Sjkh 74327Sjkh/* number of MX records to lookup */ 75327Sjkh#define MAX_MX_COUNT 10 76327Sjkh 77327Sjkh/* max response delay under flood conditions */ 78327Sjkh#define MAX_RESPONSE_DELAY 60 79327Sjkh 80327Sjkh/* how many responses per state are undelayed */ 81327Sjkh#define FAST_RESPONSES 2 82327Sjkh 83327Sjkh/* max len of any smtp line */ 84327Sjkh#define SMTP_LINE_MAX 1024 85327Sjkh 86327Sjkh#define F_STARTTLS 0x01 87327Sjkh#define F_SMTPS 0x02 88327Sjkh#define F_AUTH 0x04 89327Sjkh#define F_SSL (F_SMTPS|F_STARTTLS) 90327Sjkh 91327Sjkh#define F_SCERT 0x01 92327Sjkh#define F_CCERT 0x02 93327Sjkh 94327Sjkh#define ADVERTISE_TLS(s) \ 95327Sjkh ((s)->s_l->flags & F_STARTTLS && !((s)->s_flags & F_SECURE)) 96327Sjkh 97327Sjkh#define ADVERTISE_AUTH(s) \ 98327Sjkh ((s)->s_l->flags & F_AUTH && (s)->s_flags & F_SECURE && \ 99327Sjkh !((s)->s_flags & F_AUTHENTICATED)) 100327Sjkh 101327Sjkh 102327Sjkh 103327Sjkhtypedef u_int32_t objid_t; 104327Sjkh 105327Sjkhstruct netaddr { 106327Sjkh struct sockaddr_storage ss; 107327Sjkh int bits; 108327Sjkh}; 109327Sjkh 110327Sjkhstruct relayhost { 111327Sjkh u_int8_t flags; 112327Sjkh char hostname[MAXHOSTNAMELEN]; 113327Sjkh u_int16_t port; 114327Sjkh char cert[PATH_MAX]; 115327Sjkh char authmap[MAX_PATH_SIZE]; 116327Sjkh}; 117327Sjkh 118327Sjkhenum imsg_type { 119327Sjkh IMSG_NONE, 120327Sjkh IMSG_CTL_OK, /* answer to smtpctl requests */ 121327Sjkh IMSG_CTL_FAIL, 122327Sjkh IMSG_CTL_SHUTDOWN, 123327Sjkh IMSG_CTL_VERBOSE, 124327Sjkh IMSG_CONF_START, 125327Sjkh IMSG_CONF_SSL, 126327Sjkh IMSG_CONF_LISTENER, 127327Sjkh IMSG_CONF_MAP, 128327Sjkh IMSG_CONF_MAP_CONTENT, 129327Sjkh IMSG_CONF_RULE, 130327Sjkh IMSG_CONF_RULE_SOURCE, 131327Sjkh IMSG_CONF_FILTER, 132327Sjkh IMSG_CONF_END, 133327Sjkh IMSG_LKA_MAIL, 134327Sjkh IMSG_LKA_RCPT, 135327Sjkh IMSG_LKA_SECRET, 136327Sjkh IMSG_LKA_RULEMATCH, 137327Sjkh IMSG_MDA_SESS_NEW, 138327Sjkh IMSG_MDA_DONE, 139327Sjkh 140327Sjkh IMSG_MFA_CONNECT, 141327Sjkh IMSG_MFA_HELO, 142327Sjkh IMSG_MFA_MAIL, 143327Sjkh IMSG_MFA_RCPT, 144 IMSG_MFA_DATALINE, 145 IMSG_MFA_QUIT, 146 IMSG_MFA_CLOSE, 147 IMSG_MFA_RSET, 148 149 IMSG_QUEUE_CREATE_MESSAGE, 150 IMSG_QUEUE_SUBMIT_ENVELOPE, 151 IMSG_QUEUE_COMMIT_ENVELOPES, 152 IMSG_QUEUE_REMOVE_MESSAGE, 153 IMSG_QUEUE_COMMIT_MESSAGE, 154 IMSG_QUEUE_TEMPFAIL, 155 IMSG_QUEUE_PAUSE_MDA, 156 IMSG_QUEUE_PAUSE_MTA, 157 IMSG_QUEUE_RESUME_MDA, 158 IMSG_QUEUE_RESUME_MTA, 159 160 IMSG_QUEUE_DELIVERY_OK, 161 IMSG_QUEUE_DELIVERY_TEMPFAIL, 162 IMSG_QUEUE_DELIVERY_PERMFAIL, 163 IMSG_QUEUE_MESSAGE_FD, 164 IMSG_QUEUE_MESSAGE_FILE, 165 IMSG_QUEUE_SCHEDULE, 166 IMSG_QUEUE_REMOVE, 167 168 IMSG_SCHEDULER_REMOVE, 169 IMSG_SCHEDULER_SCHEDULE, 170 171 IMSG_BATCH_CREATE, 172 IMSG_BATCH_APPEND, 173 IMSG_BATCH_CLOSE, 174 IMSG_BATCH_DONE, 175 176 IMSG_PARENT_FORWARD_OPEN, 177 IMSG_PARENT_FORK_MDA, 178 179 IMSG_PARENT_AUTHENTICATE, 180 IMSG_PARENT_SEND_CONFIG, 181 182 IMSG_STATS, 183 IMSG_SMTP_ENQUEUE, 184 IMSG_SMTP_PAUSE, 185 IMSG_SMTP_RESUME, 186 187 IMSG_DNS_HOST, 188 IMSG_DNS_HOST_END, 189 IMSG_DNS_MX, 190 IMSG_DNS_PTR 191}; 192 193enum blockmodes { 194 BM_NORMAL, 195 BM_NONBLOCK 196}; 197 198struct imsgev { 199 struct imsgbuf ibuf; 200 void (*handler)(int, short, void *); 201 struct event ev; 202 void *data; 203 int proc; 204 short events; 205}; 206 207struct ctl_conn { 208 TAILQ_ENTRY(ctl_conn) entry; 209 u_int8_t flags; 210#define CTL_CONN_NOTIFY 0x01 211 struct imsgev iev; 212}; 213TAILQ_HEAD(ctl_connlist, ctl_conn); 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_SCHEDULER, 230} smtpd_process; 231 232struct peer { 233 enum smtp_proc_type id; 234 void (*cb)(int, short, void *); 235}; 236 237enum map_src { 238 S_NONE, 239 S_PLAIN, 240 S_DB 241}; 242 243enum map_kind { 244 K_NONE, 245 K_ALIAS, 246 K_VIRTUAL, 247 K_CREDENTIALS, 248 K_NETADDR 249}; 250 251enum mapel_type { 252 ME_STRING, 253 ME_NET, 254 ME_NETMASK 255}; 256 257struct mapel { 258 TAILQ_ENTRY(mapel) me_entry; 259 union mapel_data { 260 char med_string[MAX_LINE_SIZE]; 261 } me_key; 262 union mapel_data me_val; 263}; 264 265struct map { 266 TAILQ_ENTRY(map) m_entry; 267 char m_name[MAX_LINE_SIZE]; 268 objid_t m_id; 269 enum mapel_type m_eltype; 270 enum map_src m_src; 271 char m_config[MAXPATHLEN]; 272 TAILQ_HEAD(mapel_list, mapel) m_contents; 273}; 274 275 276struct map_backend { 277 void *(*open)(struct map *); 278 void (*close)(void *); 279 void *(*lookup)(void *, char *, enum map_kind); 280 int (*compare)(void *, char *, enum map_kind, int (*)(char *, char *)); 281}; 282 283 284enum cond_type { 285 C_ALL, 286 C_NET, 287 C_DOM, 288 C_VDOM 289}; 290 291struct cond { 292 TAILQ_ENTRY(cond) c_entry; 293 objid_t c_map; 294 enum cond_type c_type; 295}; 296 297enum action_type { 298 A_RELAY, 299 A_RELAYVIA, 300 A_MAILDIR, 301 A_MBOX, 302 A_FILENAME, 303 A_MDA 304}; 305 306#define IS_MAILBOX(x) ((x).r_action == A_MAILDIR || (x).r_action == A_MBOX || (x).r_action == A_FILENAME) 307#define IS_RELAY(x) ((x).r_action == A_RELAY || (x).r_action == A_RELAYVIA) 308 309struct rule { 310 TAILQ_ENTRY(rule) r_entry; 311 char r_tag[MAX_TAG_SIZE]; 312 int r_accept; 313 struct map *r_sources; 314 struct cond r_condition; 315 enum action_type r_action; 316 union rule_dest { 317 char buffer[MAX_RULEBUFFER_LEN]; 318 struct relayhost relayhost; 319 } r_value; 320 321 char *r_user; 322 struct mailaddr *r_as; 323 objid_t r_amap; 324 time_t r_qexpire; 325}; 326 327struct mailaddr { 328 char user[MAX_LOCALPART_SIZE]; 329 char domain[MAX_DOMAINPART_SIZE]; 330}; 331 332enum delivery_type { 333 D_INVALID = 0, 334 D_MDA, 335 D_MTA, 336 D_BOUNCE 337}; 338 339enum delivery_status { 340 DS_PERMFAILURE = 0x1, 341 DS_TEMPFAILURE = 0x2, 342}; 343 344enum delivery_flags { 345 DF_AUTHENTICATED = 0x1, 346 DF_ENQUEUED = 0x2, 347 DF_BOUNCE = 0x4, 348 DF_INTERNAL = 0x8 /* internal expansion forward */ 349}; 350 351union delivery_data { 352 char user[MAXLOGNAME]; 353 char buffer[MAX_RULEBUFFER_LEN]; 354 struct mailaddr mailaddr; 355}; 356 357struct delivery_mda { 358 enum action_type method; 359 union delivery_data to; 360 char as_user[MAXLOGNAME]; 361}; 362 363struct delivery_mta { 364 struct relayhost relay; 365}; 366 367enum expand_type { 368 EXPAND_INVALID, 369 EXPAND_USERNAME, 370 EXPAND_FILENAME, 371 EXPAND_FILTER, 372 EXPAND_INCLUDE, 373 EXPAND_ADDRESS 374}; 375 376enum expand_flags { 377 F_EXPAND_NONE, 378 F_EXPAND_DONE 379}; 380 381struct expandnode { 382 RB_ENTRY(expandnode) entry; 383 size_t refcnt; 384 enum expand_flags flags; 385 enum expand_type type; 386 char as_user[MAXLOGNAME]; 387 union delivery_data u; 388}; 389 390RB_HEAD(expandtree, expandnode); 391 392#define SMTPD_ENVELOPE_VERSION 1 393struct envelope { 394 TAILQ_ENTRY(envelope) entry; 395 396 char tag[MAX_TAG_SIZE]; 397 struct rule rule; 398 399 u_int64_t session_id; 400 u_int64_t batch_id; 401 402 u_int32_t version; 403 u_int64_t id; 404 enum delivery_type type; 405 406 char helo[MAXHOSTNAMELEN]; 407 char hostname[MAXHOSTNAMELEN]; 408 char errorline[MAX_LINE_SIZE + 1]; 409 struct sockaddr_storage ss; 410 411 struct mailaddr sender; 412 struct mailaddr rcpt; 413 struct mailaddr dest; 414 415 union delivery_method { 416 struct delivery_mda mda; 417 struct delivery_mta mta; 418 } agent; 419 420 time_t creation; 421 time_t lasttry; 422 time_t expire; 423 u_int8_t retry; 424 enum delivery_flags flags; 425}; 426TAILQ_HEAD(deliverylist, envelope); 427 428enum envelope_field { 429 EVP_VERSION, 430 EVP_ID, 431 EVP_MSGID, 432 EVP_TYPE, 433 EVP_HELO, 434 EVP_HOSTNAME, 435 EVP_ERRORLINE, 436 EVP_SOCKADDR, 437 EVP_SENDER, 438 EVP_RCPT, 439 EVP_DEST, 440 EVP_CTIME, 441 EVP_EXPIRE, 442 EVP_RETRY, 443 EVP_LASTTRY, 444 EVP_FLAGS, 445 EVP_MDA_METHOD, 446 EVP_MDA_BUFFER, 447 EVP_MDA_USER, 448 EVP_MTA_RELAY_HOST, 449 EVP_MTA_RELAY_PORT, 450 EVP_MTA_RELAY_FLAGS, 451 EVP_MTA_RELAY_CERT, 452 EVP_MTA_RELAY_AUTHMAP 453}; 454 455 456enum child_type { 457 CHILD_INVALID, 458 CHILD_DAEMON, 459 CHILD_MDA, 460 CHILD_ENQUEUE_OFFLINE, 461}; 462 463struct child { 464 SPLAY_ENTRY(child) entry; 465 pid_t pid; 466 enum child_type type; 467 enum smtp_proc_type title; 468 int mda_out; 469 u_int32_t mda_id; 470 char *path; 471}; 472 473enum session_state { 474 S_NEW = 0, 475 S_CONNECTED, 476 S_INIT, 477 S_GREETED, 478 S_TLS, 479 S_AUTH_INIT, 480 S_AUTH_USERNAME, 481 S_AUTH_PASSWORD, 482 S_AUTH_FINALIZE, 483 S_RSET, 484 S_HELO, 485 S_MAIL_MFA, 486 S_MAIL_QUEUE, 487 S_MAIL, 488 S_RCPT_MFA, 489 S_RCPT, 490 S_DATA, 491 S_DATA_QUEUE, 492 S_DATACONTENT, 493 S_DONE, 494 S_QUIT, 495 S_CLOSE 496}; 497#define STATE_COUNT 22 498 499struct ssl { 500 SPLAY_ENTRY(ssl) ssl_nodes; 501 char ssl_name[PATH_MAX]; 502 char *ssl_ca; 503 off_t ssl_ca_len; 504 char *ssl_cert; 505 off_t ssl_cert_len; 506 char *ssl_key; 507 off_t ssl_key_len; 508 char *ssl_dhparams; 509 off_t ssl_dhparams_len; 510 u_int8_t flags; 511}; 512 513struct listener { 514 u_int8_t flags; 515 int fd; 516 struct sockaddr_storage ss; 517 in_port_t port; 518 struct timeval timeout; 519 struct event ev; 520 char ssl_cert_name[PATH_MAX]; 521 struct ssl *ssl; 522 void *ssl_ctx; 523 char tag[MAX_TAG_SIZE]; 524 TAILQ_ENTRY(listener) entry; 525}; 526 527struct auth { 528 u_int64_t id; 529 char user[MAXLOGNAME]; 530 char pass[MAX_LINE_SIZE + 1]; 531 int success; 532}; 533 534enum session_flags { 535 F_EHLO = 0x01, 536 F_8BITMIME = 0x02, 537 F_SECURE = 0x04, 538 F_AUTHENTICATED = 0x08, 539 F_WAITIMSG = 0x10, 540 F_ZOMBIE = 0x20, 541}; 542 543struct session { 544 SPLAY_ENTRY(session) s_nodes; 545 u_int64_t s_id; 546 547 struct iobuf s_iobuf; 548 struct io s_io; 549 550 enum session_flags s_flags; 551 enum session_state s_state; 552 struct sockaddr_storage s_ss; 553 char s_hostname[MAXHOSTNAMELEN]; 554 struct event s_ev; 555 struct listener *s_l; 556 void *s_ssl; 557 struct timeval s_tv; 558 struct envelope s_msg; 559 short s_nresp[STATE_COUNT]; 560 size_t rcptcount; 561 long s_datalen; 562 563 struct auth s_auth; 564 int s_dstatus; 565 566 FILE *datafp; 567}; 568 569 570struct smtpd { 571 char sc_conffile[MAXPATHLEN]; 572 size_t sc_maxsize; 573 574#define SMTPD_OPT_VERBOSE 0x00000001 575#define SMTPD_OPT_NOACTION 0x00000002 576 u_int32_t sc_opts; 577#define SMTPD_CONFIGURING 0x00000001 578#define SMTPD_EXITING 0x00000002 579#define SMTPD_MDA_PAUSED 0x00000004 580#define SMTPD_MTA_PAUSED 0x00000008 581#define SMTPD_SMTP_PAUSED 0x00000010 582#define SMTPD_MDA_BUSY 0x00000020 583#define SMTPD_MTA_BUSY 0x00000040 584#define SMTPD_BOUNCE_BUSY 0x00000080 585 u_int32_t sc_flags; 586 struct timeval sc_qintval; 587 int sc_qexpire; 588 u_int32_t sc_maxconn; 589 struct event sc_ev; 590 int *sc_pipes[PROC_COUNT] 591 [PROC_COUNT]; 592 struct imsgev *sc_ievs[PROC_COUNT]; 593 int sc_instances[PROC_COUNT]; 594 int sc_instance; 595 char *sc_title[PROC_COUNT]; 596 struct passwd *sc_pw; 597 char sc_hostname[MAXHOSTNAMELEN]; 598 struct queue_backend *sc_queue; 599 struct scheduler_backend *sc_scheduler; 600 601 TAILQ_HEAD(filterlist, filter) *sc_filters; 602 603 TAILQ_HEAD(listenerlist, listener) *sc_listeners; 604 TAILQ_HEAD(maplist, map) *sc_maps, *sc_maps_reload; 605 TAILQ_HEAD(rulelist, rule) *sc_rules, *sc_rules_reload; 606 SPLAY_HEAD(sessiontree, session) sc_sessions; 607 SPLAY_HEAD(ssltree, ssl) *sc_ssl; 608 SPLAY_HEAD(childtree, child) children; 609 SPLAY_HEAD(lkatree, lka_session) lka_sessions; 610 SPLAY_HEAD(mfatree, mfa_session) mfa_sessions; 611 LIST_HEAD(mdalist, mda_session) mda_sessions; 612 613 struct stats *stats; 614 u_int64_t filtermask; 615}; 616 617#define TRACE_VERBOSE 0x0001 618#define TRACE_IMSG 0x0002 619#define TRACE_IO 0x0004 620#define TRACE_SMTP 0x0008 621#define TRACE_MTA 0x0010 622#define TRACE_BOUNCE 0x0020 623#define TRACE_SCHEDULER 0x0040 624 625enum { 626 STATS_SMTP_SESSION = 0, 627 STATS_SMTP_SESSION_INET4, 628 STATS_SMTP_SESSION_INET6, 629 STATS_SMTP_SMTPS, 630 STATS_SMTP_STARTTLS, 631 632 STATS_MTA_SESSION, 633 634 STATS_MDA_SESSION, 635 636 STATS_CONTROL_SESSION, 637 638 STATS_LKA_SESSION, 639 STATS_LKA_SESSION_MX, 640 STATS_LKA_SESSION_HOST, 641 STATS_LKA_SESSION_CNAME, 642 STATS_LKA_FAILURE, 643 644 STATS_SCHEDULER, 645 STATS_SCHEDULER_BOUNCES, 646 647 STATS_QUEUE_LOCAL, 648 STATS_QUEUE_REMOTE, 649 650 STATS_RAMQUEUE_ENVELOPE, 651 STATS_RAMQUEUE_MESSAGE, 652 STATS_RAMQUEUE_BATCH, 653 STATS_RAMQUEUE_HOST, 654 655 STATS_MAX, 656}; 657 658#define STAT_COUNT 0 659#define STAT_ACTIVE 1 660#define STAT_MAXACTIVE 2 661 662struct stat_counter { 663 size_t count; 664 size_t active; 665 size_t maxactive; 666}; 667 668struct s_parent { 669 time_t start; 670}; 671 672struct s_session { 673 size_t read_error; 674 size_t read_timeout; 675 size_t read_eof; 676 size_t write_error; 677 size_t write_timeout; 678 size_t write_eof; 679 size_t toofast; 680 size_t tempfail; 681 size_t linetoolong; 682 size_t delays; 683}; 684 685struct stats { 686 struct s_parent parent; 687 struct s_session mta; 688 struct s_session smtp; 689 690 struct stat_counter counters[STATS_MAX]; 691}; 692 693struct submit_status { 694 u_int64_t id; 695 int code; 696 union submit_path { 697 struct mailaddr maddr; 698 u_int32_t msgid; 699 u_int64_t evpid; 700 char errormsg[MAX_LINE_SIZE + 1]; 701 char dataline[MAX_LINE_SIZE + 1]; 702 } u; 703 enum delivery_flags flags; 704 struct sockaddr_storage ss; 705 struct envelope envelope; 706}; 707 708struct forward_req { 709 u_int64_t id; 710 u_int8_t status; 711 char as_user[MAXLOGNAME]; 712 struct envelope envelope; 713}; 714 715enum dns_status { 716 DNS_OK = 0, 717 DNS_RETRY, 718 DNS_EINVAL, 719 DNS_ENONAME, 720 DNS_ENOTFOUND, 721}; 722 723struct dns { 724 u_int64_t id; 725 char host[MAXHOSTNAMELEN]; 726 int port; 727 int error; 728 int type; 729 struct imsgev *asker; 730 struct sockaddr_storage ss; 731 struct dns *next; 732}; 733 734struct secret { 735 u_int64_t id; 736 char mapname[MAX_PATH_SIZE]; 737 char host[MAXHOSTNAMELEN]; 738 char secret[MAX_LINE_SIZE]; 739}; 740 741struct mda_session { 742 LIST_ENTRY(mda_session) entry; 743 struct envelope msg; 744 struct msgbuf w; 745 struct event ev; 746 u_int32_t id; 747 FILE *datafp; 748}; 749 750struct deliver { 751 char to[PATH_MAX]; 752 char from[PATH_MAX]; 753 char user[MAXLOGNAME]; 754 short mode; 755}; 756 757struct rulematch { 758 u_int64_t id; 759 struct submit_status ss; 760}; 761 762enum lka_session_flags { 763 F_ERROR = 0x1 764}; 765 766struct lka_session { 767 SPLAY_ENTRY(lka_session) nodes; 768 u_int64_t id; 769 770 struct deliverylist deliverylist; 771 struct expandtree expandtree; 772 773 u_int8_t iterations; 774 u_int32_t pending; 775 enum lka_session_flags flags; 776 struct submit_status ss; 777}; 778 779struct filter { 780 TAILQ_ENTRY(filter) f_entry; 781 pid_t pid; 782 struct event ev; 783 struct imsgbuf *ibuf; 784 char name[MAX_FILTER_NAME]; 785 char path[MAXPATHLEN]; 786}; 787 788struct mfa_session { 789 SPLAY_ENTRY(mfa_session) nodes; 790 u_int64_t id; 791 792 enum session_state state; 793 struct submit_status ss; 794 struct filter *filter; 795 struct filter_msg fm; 796}; 797 798enum mta_state { 799 MTA_INIT, 800 MTA_SECRET, 801 MTA_DATA, 802 MTA_MX, 803 MTA_CONNECT, 804 MTA_DONE, 805 MTA_SMTP_READY, 806 MTA_SMTP_BANNER, 807 MTA_SMTP_EHLO, 808 MTA_SMTP_HELO, 809 MTA_SMTP_STARTTLS, 810 MTA_SMTP_AUTH, 811 MTA_SMTP_MAIL, 812 MTA_SMTP_RCPT, 813 MTA_SMTP_DATA, 814 MTA_SMTP_QUIT, 815 MTA_SMTP_BODY, 816 MTA_SMTP_DONE, 817 MTA_SMTP_RSET, 818}; 819 820/* mta session flags */ 821#define MTA_FORCE_ANYSSL 0x01 822#define MTA_FORCE_SMTPS 0x02 823#define MTA_ALLOW_PLAIN 0x04 824#define MTA_USE_AUTH 0x08 825#define MTA_FORCE_MX 0x10 826#define MTA_USE_CERT 0x20 827#define MTA_TLS 0x40 828 829#define MTA_EXT_STARTTLS 0x01 830#define MTA_EXT_AUTH 0x02 831#define MTA_EXT_PIPELINING 0x04 832 833struct mta_batch { 834 u_int64_t id; 835 struct relayhost relay; 836 837 u_int32_t msgid; 838}; 839 840/* maps return structures */ 841struct map_credentials { 842 char username[MAX_LINE_SIZE]; 843 char password[MAX_LINE_SIZE]; 844}; 845 846struct map_alias { 847 size_t nbnodes; 848 struct expandtree expandtree; 849}; 850 851struct map_virtual { 852 size_t nbnodes; 853 struct expandtree expandtree; 854}; 855 856struct map_netaddr { 857 struct netaddr netaddr; 858}; 859 860enum queue_op { 861 QOP_INVALID=0, 862 QOP_CREATE, 863 QOP_DELETE, 864 QOP_UPDATE, 865 QOP_COMMIT, 866 QOP_LOAD, 867 QOP_FD_R, 868 QOP_CORRUPT, 869}; 870 871struct queue_backend { 872 int (*init)(int); 873 int (*message)(enum queue_op, u_int32_t *); 874 int (*envelope)(enum queue_op, struct envelope *); 875 876 void *(*qwalk_new)(u_int32_t); 877 int (*qwalk)(void *, u_int64_t *); 878 void (*qwalk_close)(void *); 879}; 880 881 882/* auth structures */ 883enum auth_type { 884 AUTH_BSD, 885 AUTH_PWD, 886}; 887 888struct auth_backend { 889 int (*authenticate)(char *, char *); 890}; 891 892 893/* user structures */ 894enum user_type { 895 USER_PWD, 896}; 897 898#define MAXPASSWORDLEN 128 899struct mta_user { 900 char username[MAXLOGNAME]; 901 char directory[MAXPATHLEN]; 902 char password[MAXPASSWORDLEN]; 903 uid_t uid; 904 gid_t gid; 905}; 906 907struct user_backend { 908 int (*getbyname)(struct mta_user *, char *); 909 int (*getbyuid)(struct mta_user *, uid_t); 910}; 911 912 913/* delivery_backend */ 914struct delivery_backend { 915 void (*open)(struct deliver *); 916}; 917 918struct scheduler_info { 919 u_int64_t evpid; 920 char destination[MAXHOSTNAMELEN]; 921 922 enum delivery_type type; 923 time_t creation; 924 time_t lasttry; 925 time_t expire; 926 u_int8_t retry; 927}; 928 929struct scheduler_backend { 930 void (*init)(void); 931 int (*setup)(void); 932 933 int (*next)(u_int64_t *, time_t *); 934 935 void (*insert)(struct scheduler_info *); 936 void (*schedule)(u_int64_t); 937 void (*remove)(u_int64_t); 938 939 void *(*host)(char *); 940 void *(*message)(u_int32_t); 941 void *(*batch)(u_int64_t); 942 void *(*queue)(void); 943 void (*close)(void *); 944 945 int (*fetch)(void *, u_int64_t *); 946 int (*force)(u_int64_t); 947 948 void (*display)(void); /* may be NULL */ 949}; 950 951 952 953extern struct smtpd *env; 954extern void (*imsg_callback)(struct imsgev *, struct imsg *); 955 956 957/* aliases.c */ 958int aliases_exist(objid_t, char *); 959int aliases_get(objid_t, struct expandtree *, char *); 960int aliases_vdomain_exists(objid_t, char *); 961int aliases_virtual_exist(objid_t, struct mailaddr *); 962int aliases_virtual_get(objid_t, struct expandtree *, struct mailaddr *); 963int alias_parse(struct expandnode *, char *); 964 965 966/* auth.c */ 967struct auth_backend *auth_backend_lookup(enum auth_type); 968 969 970/* bounce.c */ 971int bounce_session(int, struct envelope *); 972int bounce_session_switch(FILE *, enum session_state *, char *, struct envelope *); 973void bounce_event(int, short, void *); 974int bounce_record_message(struct envelope *, struct envelope *); 975 976/* config.c */ 977#define PURGE_LISTENERS 0x01 978#define PURGE_MAPS 0x02 979#define PURGE_RULES 0x04 980#define PURGE_SSL 0x08 981#define PURGE_EVERYTHING 0xff 982void purge_config(u_int8_t); 983void unconfigure(void); 984void configure(void); 985void init_pipes(void); 986void config_pipes(struct peer *, u_int); 987void config_peers(struct peer *, u_int); 988 989 990/* control.c */ 991pid_t control(void); 992void session_socket_blockmode(int, enum blockmodes); 993void session_socket_no_linger(int); 994int session_socket_error(int); 995 996 997/* delivery.c */ 998struct delivery_backend *delivery_backend_lookup(enum action_type); 999 1000 1001/* dns.c */ 1002void dns_query_host(char *, int, u_int64_t); 1003void dns_query_mx(char *, int, u_int64_t); 1004void dns_query_ptr(struct sockaddr_storage *, u_int64_t); 1005void dns_async(struct imsgev *, int, struct dns *); 1006 1007 1008/* enqueue.c */ 1009int enqueue(int, char **); 1010int enqueue_offline(int, char **); 1011 1012 1013/* envelope.c */ 1014void envelope_set_errormsg(struct envelope *, char *, ...); 1015char *envelope_ascii_field_name(enum envelope_field); 1016int envelope_ascii_load(enum envelope_field, struct envelope *, char *); 1017int envelope_ascii_dump(enum envelope_field, struct envelope *, char *, size_t); 1018int envelope_load_file(struct envelope *, FILE *); 1019int envelope_dump_file(struct envelope *, FILE *); 1020 1021/* expand.c */ 1022int expand_cmp(struct expandnode *, struct expandnode *); 1023void expandtree_increment_node(struct expandtree *, struct expandnode *); 1024void expandtree_decrement_node(struct expandtree *, struct expandnode *); 1025void expandtree_remove_node(struct expandtree *, struct expandnode *); 1026struct expandnode *expandtree_lookup(struct expandtree *, struct expandnode *); 1027void expandtree_free_nodes(struct expandtree *); 1028RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); 1029 1030 1031/* forward.c */ 1032int forwards_get(int, struct expandtree *, char *); 1033 1034 1035/* lka.c */ 1036pid_t lka(void); 1037int lka_session_cmp(struct lka_session *, struct lka_session *); 1038SPLAY_PROTOTYPE(lkatree, lka_session, nodes, lka_session_cmp); 1039 1040/* lka_session.c */ 1041struct lka_session *lka_session_init(struct submit_status *); 1042void lka_session_fail(struct lka_session *); 1043void lka_session_destroy(struct lka_session *); 1044 1045 1046/* map.c */ 1047void *map_lookup(objid_t, char *, enum map_kind); 1048int map_compare(objid_t, char *, enum map_kind, int (*)(char *, char *)); 1049struct map *map_find(objid_t); 1050struct map *map_findbyname(const char *); 1051 1052 1053/* mda.c */ 1054pid_t mda(void); 1055 1056 1057/* mfa.c */ 1058pid_t mfa(void); 1059int mfa_session_cmp(struct mfa_session *, struct mfa_session *); 1060SPLAY_PROTOTYPE(mfatree, mfa_session, nodes, mfa_session_cmp); 1061 1062/* mta.c */ 1063pid_t mta(void); 1064 1065/* mta_session.c */ 1066void mta_session_imsg(struct imsgev *, struct imsg *); 1067 1068/* parse.y */ 1069int parse_config(struct smtpd *, const char *, int); 1070int cmdline_symset(char *); 1071 1072 1073/* queue.c */ 1074pid_t queue(void); 1075void queue_submit_envelope(struct envelope *); 1076void queue_commit_envelopes(struct envelope *); 1077 1078 1079/* queue_backend.c */ 1080u_int32_t queue_generate_msgid(void); 1081u_int64_t queue_generate_evpid(u_int32_t msgid); 1082struct queue_backend *queue_backend_lookup(const char *); 1083int queue_message_incoming_path(u_int32_t, char *, size_t); 1084int queue_envelope_incoming_path(u_int64_t, char *, size_t); 1085int queue_message_incoming_delete(u_int32_t); 1086int queue_message_create(u_int32_t *); 1087int queue_message_delete(u_int32_t); 1088int queue_message_commit(u_int32_t); 1089int queue_message_fd_r(u_int32_t); 1090int queue_message_fd_rw(u_int32_t); 1091int queue_message_corrupt(u_int32_t); 1092int queue_envelope_create(struct envelope *); 1093int queue_envelope_delete(struct envelope *); 1094int queue_envelope_load(u_int64_t, struct envelope *); 1095int queue_envelope_update(struct envelope *); 1096void *qwalk_new(u_int32_t); 1097int qwalk(void *, u_int64_t *); 1098void qwalk_close(void *); 1099 1100 1101/* scheduler.c */ 1102pid_t scheduler(void); 1103void message_reset_flags(struct envelope *); 1104 1105 1106/* scheduler.c */ 1107struct scheduler_backend *scheduler_backend_lookup(const char *); 1108void scheduler_info(struct scheduler_info *, struct envelope *); 1109 1110 1111/* smtp.c */ 1112pid_t smtp(void); 1113void smtp_resume(void); 1114 1115 1116/* smtp_session.c */ 1117void session_init(struct listener *, struct session *); 1118int session_cmp(struct session *, struct session *); 1119void session_io(struct io *, int); 1120void session_pickup(struct session *, struct submit_status *); 1121void session_destroy(struct session *, const char *); 1122void session_respond(struct session *, char *, ...) 1123 __attribute__ ((format (printf, 2, 3))); 1124 1125SPLAY_PROTOTYPE(sessiontree, session, s_nodes, session_cmp); 1126 1127 1128/* smtpd.c */ 1129int child_cmp(struct child *, struct child *); 1130void imsg_event_add(struct imsgev *); 1131void imsg_compose_event(struct imsgev *, u_int16_t, u_int32_t, pid_t, 1132 int, void *, u_int16_t); 1133void imsg_dispatch(int, short, void *); 1134const char * proc_to_str(int); 1135const char * imsg_to_str(int); 1136SPLAY_PROTOTYPE(childtree, child, entry, child_cmp); 1137 1138 1139/* ssl.c */ 1140void ssl_init(void); 1141void ssl_transaction(struct session *); 1142void ssl_session_init(struct session *); 1143void ssl_session_destroy(struct session *); 1144int ssl_load_certfile(const char *, u_int8_t); 1145void ssl_setup(struct listener *); 1146int ssl_cmp(struct ssl *, struct ssl *); 1147void *ssl_mta_init(struct ssl *); 1148SPLAY_PROTOTYPE(ssltree, ssl, ssl_nodes, ssl_cmp); 1149 1150 1151/* ssl_privsep.c */ 1152int ssl_ctx_use_private_key(void *, char *, off_t); 1153int ssl_ctx_use_certificate_chain(void *, char *, off_t); 1154 1155/* stats.c */ 1156void stat_init(struct stat_counter *, int); 1157size_t stat_get(int, int); 1158size_t stat_increment(int); 1159size_t stat_decrement(int); 1160 1161 1162/* user.c */ 1163struct user_backend *user_backend_lookup(enum user_type); 1164 1165 1166/* util.c */ 1167typedef struct arglist arglist; 1168struct arglist { 1169 char **list; 1170 u_int num; 1171 u_int nalloc; 1172}; 1173void addargs(arglist *, char *, ...) 1174 __attribute__((format(printf, 2, 3))); 1175int bsnprintf(char *, size_t, const char *, ...) 1176 __attribute__ ((format (printf, 3, 4))); 1177int mkdir_p(char *, mode_t); 1178int safe_fclose(FILE *); 1179int hostname_match(char *, char *); 1180int email_to_mailaddr(struct mailaddr *, char *); 1181int valid_localpart(const char *); 1182int valid_domainpart(const char *); 1183char *ss_to_text(struct sockaddr_storage *); 1184char *time_to_text(time_t); 1185int secure_file(int, char *, char *, uid_t, int); 1186int lowercase(char *, char *, size_t); 1187void xlowercase(char *, char *, size_t); 1188void sa_set_port(struct sockaddr *, int); 1189u_int64_t generate_uid(void); 1190void fdlimit(double); 1191int availdesc(void); 1192u_int32_t evpid_to_msgid(u_int64_t); 1193u_int64_t msgid_to_evpid(u_int32_t); 1194void log_imsg(int, int, struct imsg*); 1195int ckdir(const char *, mode_t, uid_t, gid_t, int); 1196int rmtree(char *, int); 1197int mvpurge(char *, char *); 1198const char *parse_smtp_response(char *, size_t, char **, int *); 1199int text_to_netaddr(struct netaddr *, char *); 1200int text_to_relayhost(struct relayhost *, char *); 1201