Lines Matching full:s
191 #define SESSION_FILTERED(s) \
192 ((s)->relay->dispatcher->u.remote.filtername)
213 struct mta_session *s;
218 s = xcalloc(1, sizeof *s);
219 s->id = generate_uid();
220 s->relay = relay;
221 s->route = route;
222 s->mxname = xstrdup(mxname);
224 mta_filter_begin(s);
227 s->flags |= MTA_LMTP;
230 s->flags |= MTA_FORCE_SMTPS;
231 s->flags |= MTA_WANT_SECURE;
234 s->flags |= MTA_FORCE_TLS;
235 s->flags |= MTA_WANT_SECURE;
241 s->flags |= MTA_FORCE_PLAIN;
247 log_debug("debug: mta: %p: spawned for relay %s", s,
257 evtimer_set(&s->ev, mta_start, s);
258 evtimer_add(&s->ev, &tv);
259 } else if (waitq_wait(&route->dst->ptrname, mta_on_ptr, s)) {
260 resolver_getnameinfo(s->route->dst->sa, NI_NUMERICSERV,
261 mta_getnameinfo_cb, s);
268 struct mta_session *s;
283 s = mta_tree_pop(&wait_fd, reqid);
284 if (s == NULL) {
292 mta_flush_task(s, IMSG_MTA_DELIVERY_TEMPFAIL,
294 mta_enter_state(s, MTA_READY);
298 if ((s->ext & MTA_EXT_SIZE) && s->ext_size != 0) {
301 mta_flush_task(s, IMSG_MTA_DELIVERY_TEMPFAIL,
303 mta_enter_state(s, MTA_READY);
307 if (sb.st_size > (off_t)s->ext_size) {
309 mta_flush_task(s, IMSG_MTA_DELIVERY_PERMFAIL,
311 mta_enter_state(s, MTA_READY);
317 s->datafp = fdopen(fd, "r");
318 if (s->datafp == NULL)
321 mta_enter_state(s, MTA_MAIL);
332 s = mta_tree_pop(&wait_helo, reqid);
333 if (s == NULL)
337 s->helo = xstrdup(name);
338 mta_connect(s);
340 mta_source_error(s->relay, s->route,
342 mta_free(s);
347 fatalx("mta_session_imsg: unexpected %s imsg",
355 struct mta_session *s;
357 s = tree_xpop(wait, reqid);
358 if (s->flags & MTA_FREE) {
359 log_debug("debug: mta: %p: zombie session", s);
360 mta_free(s);
363 s->flags &= ~MTA_WAIT;
365 return (s);
369 mta_free(struct mta_session *s)
374 log_debug("debug: mta: %p: session done", s);
376 mta_disconnected(s);
378 if (s->ready)
379 s->relay->nconn_ready -= 1;
381 if (s->flags & MTA_HANGON) {
382 log_debug("debug: mta: %p: cancelling hangon timer", s);
383 runq_cancel(hangon, s);
386 if (s->io)
387 io_free(s->io);
389 if (s->task)
391 if (s->datafp) {
392 fclose(s->datafp);
393 s->datalen = 0;
395 free(s->helo);
397 relay = s->relay;
398 route = s->route;
399 free(s->username);
400 free(s->mxname);
401 free(s);
409 struct mta_session *s = arg;
412 h = s->route->dst;
422 struct mta_session *s = arg;
426 s->flags &= ~MTA_HANGON;
427 s->hangon++;
429 mta_enter_state(s, MTA_READY);
435 struct mta_session *s = arg;
437 mta_connect(s);
443 struct mta_session *s = arg;
445 mta_connect(s);
449 mta_connect(struct mta_session *s)
456 if (s->helo == NULL) {
457 if (s->relay->helotable && s->route->src->sa) {
459 m_add_id(p_lka, s->id);
460 m_add_string(p_lka, s->relay->helotable);
461 m_add_sockaddr(p_lka, s->route->src->sa);
463 tree_xset(&wait_helo, s->id, s);
464 s->flags |= MTA_WAIT;
467 else if (s->relay->heloname)
468 s->helo = xstrdup(s->relay->heloname);
470 s->helo = xstrdup(env->sc_hostname);
473 if (s->io) {
474 io_free(s->io);
475 s->io = NULL;
478 s->use_smtps = s->use_starttls = s->use_smtp_tls = 0;
480 switch (s->attempt) {
482 if (s->flags & MTA_FORCE_SMTPS)
483 s->use_smtps = 1; /* smtps */
484 else if (s->flags & (MTA_FORCE_TLS|MTA_FORCE_ANYSSL))
485 s->use_starttls = 1; /* tls, tls+smtps */
486 else if (!(s->flags & MTA_FORCE_PLAIN))
487 s->use_smtp_tls = 1;
490 if (s->flags & MTA_FORCE_ANYSSL) {
491 s->use_smtps = 1; /* tls+smtps */
494 else if (s->flags & MTA_DOWNGRADE_PLAIN) {
499 mta_free(s);
502 portno = s->use_smtps ? 465 : 25;
505 if (s->relay->port)
506 portno = s->relay->port;
508 memmove(&ss, s->route->dst->sa, s->route->dst->sa->sa_len);
516 s->attempt += 1;
517 if (s->use_smtp_tls)
519 else if (s->use_starttls)
521 else if (s->use_smtps)
523 else if (s->flags & MTA_LMTP)
529 "connecting address=%s%s:%d host=%s",
530 s->id, schema, sa_to_text(s->route->dst->sa),
531 portno, s->route->dst->ptrname);
533 mta_enter_state(s, MTA_INIT);
534 s->io = io_new();
535 io_set_callback(s->io, mta_io, s);
536 io_set_timeout(s->io, 300000);
537 if (io_connect(s->io, sa, s->route->src->sa) == -1) {
542 log_debug("debug: mta: io_connect failed: %s", io_error(s->io));
544 mta_source_error(s->relay, s->route, io_error(s->io));
546 mta_error(s, "Connection failed: %s", io_error(s->io));
547 mta_free(s);
552 mta_enter_state(struct mta_session *s, int newstate)
564 oldstate = s->state;
566 log_trace(TRACE_MTA, "mta: %p: %s -> %s", s,
570 s->state = newstate;
572 memset(s->replybuf, 0, sizeof s->replybuf);
577 switch (s->state) {
583 s->ext = 0;
584 mta_send(s, "EHLO %s", s->helo);
585 mta_report_link_identify(s, "EHLO", s->helo);
589 s->ext = 0;
590 mta_send(s, "HELO %s", s->helo);
591 mta_report_link_identify(s, "HELO", s->helo);
595 s->ext = 0;
596 mta_send(s, "LHLO %s", s->helo);
597 mta_report_link_identify(s, "LHLO", s->helo);
601 if (s->flags & MTA_DOWNGRADE_PLAIN)
602 mta_enter_state(s, MTA_AUTH);
603 if (s->flags & MTA_TLS) /* already started */
604 mta_enter_state(s, MTA_AUTH);
605 else if ((s->ext & MTA_EXT_STARTTLS) == 0) {
606 if (s->flags & MTA_FORCE_TLS || s->flags & MTA_WANT_SECURE) {
607 mta_error(s, "TLS required but not supported by remote host");
608 s->flags |= MTA_RECONN;
612 mta_enter_state(s, MTA_AUTH);
615 mta_send(s, "STARTTLS");
619 if (s->relay->secret && s->flags & MTA_TLS) {
620 if (s->ext & MTA_EXT_AUTH) {
621 if (s->ext & MTA_EXT_AUTH_PLAIN) {
622 mta_enter_state(s, MTA_AUTH_PLAIN);
625 if (s->ext & MTA_EXT_AUTH_LOGIN) {
626 mta_enter_state(s, MTA_AUTH_LOGIN);
629 log_debug("debug: mta: %p: no supported AUTH method on session", s);
630 mta_error(s, "no supported AUTH method");
633 log_debug("debug: mta: %p: AUTH not advertised on session", s);
634 mta_error(s, "AUTH not advertised");
637 else if (s->relay->secret) {
639 "session", s);
640 mta_error(s, "Refuse to AUTH over insecure channel");
641 mta_connect(s);
643 mta_enter_state(s, MTA_READY);
649 if (base64_decode(s->relay->secret, (unsigned char *)ibuf,
651 log_debug("debug: mta: %p: credentials too large on session", s);
652 mta_error(s, "Credentials too large");
655 s->username = xstrdup(ibuf+1);
656 mta_send(s, "AUTH PLAIN %s", s->relay->secret);
660 mta_send(s, "AUTH LOGIN");
665 if (base64_decode(s->relay->secret, (unsigned char *)ibuf,
667 log_debug("debug: mta: %p: credentials too large on session", s);
668 mta_error(s, "Credentials too large");
671 s->username = xstrdup(ibuf+1);
675 mta_send(s, "%s", obuf);
683 if (base64_decode(s->relay->secret, (unsigned char *)ibuf,
685 log_debug("debug: mta: %p: credentials too large on session", s);
686 mta_error(s, "Credentials too large");
693 mta_send(s, "%s", obuf);
701 if (s->ready == 0) {
702 s->ready = 1;
703 s->relay->nconn_ready += 1;
704 mta_route_ok(s->relay, s->route);
707 if (s->msgtried >= MAX_TRYBEFOREDISABLE) {
709 s->id);
710 mta_route_down(s->relay, s->route);
711 mta_enter_state(s, MTA_QUIT);
715 if (s->msgcount >= s->relay->limits->max_mail_per_session) {
717 "%p: cannot send more message to relay %s", s,
718 mta_relay_to_text(s->relay));
719 mta_enter_state(s, MTA_QUIT);
727 if (s->flags & MTA_DOWNGRADE_PLAIN)
728 s->flags &= ~MTA_DOWNGRADE_PLAIN;
729 else if (s->task)
732 if (s->task == NULL)
733 s->task = mta_route_next_task(s->relay, s->route);
734 if (s->task == NULL) {
735 log_debug("debug: mta: %p: no task for relay %s",
736 s, mta_relay_to_text(s->relay));
738 if (s->relay->nconn > 1 ||
739 s->hangon >= s->relay->limits->sessdelay_keepalive) {
740 mta_enter_state(s, MTA_QUIT);
745 (long long)(s->relay->limits->sessdelay_keepalive -
746 s->hangon));
747 s->flags |= MTA_HANGON;
748 runq_schedule(hangon, 1, s);
752 log_debug("debug: mta: %p: handling next task for relay %s", s,
753 mta_relay_to_text(s->relay));
758 m_add_id(p_queue, s->id);
759 m_add_msgid(p_queue, s->task->msgid);
762 tree_xset(&wait_fd, s->id, s);
763 s->flags |= MTA_WAIT;
767 s->currevp = TAILQ_FIRST(&s->task->envelopes);
769 e = s->currevp;
770 s->hangon = 0;
771 s->msgtried++;
779 s->relay->srs &&
780 strchr(s->task->sender, '@') &&
784 srs_sender = srs_encode(s->task->sender,
787 free(s->task->sender);
788 s->task->sender = xstrdup(srs_sender);
792 if (s->ext & MTA_EXT_DSN) {
793 mta_send(s, "MAIL FROM:<%s>%s%s%s%s",
794 s->task->sender,
800 mta_send(s, "MAIL FROM:<%s>", s->task->sender);
804 if (s->currevp == NULL)
805 s->currevp = TAILQ_FIRST(&s->task->envelopes);
807 e = s->currevp;
808 if (s->ext & MTA_EXT_DSN) {
809 mta_send(s, "RCPT TO:<%s>%s%s%s%s",
816 mta_send(s, "RCPT TO:<%s>", e->dest);
818 mta_report_tx_envelope(s, s->task->msgid, e->id);
819 s->rcptcount++;
823 fseek(s->datafp, 0, SEEK_SET);
824 mta_send(s, "DATA");
828 if (s->datafp == NULL) {
829 log_trace(TRACE_MTA, "mta: %p: end-of-file", s);
830 mta_enter_state(s, MTA_EOM);
834 if ((q = mta_queue_data(s)) == -1) {
835 s->flags |= MTA_FREE;
839 mta_enter_state(s, MTA_BODY);
843 log_trace(TRACE_MTA, "mta: %p: >>> [...%zd bytes...]", s, q);
847 mta_send(s, ".");
852 io_set_read(s->io);
856 if (s->datafp) {
857 fclose(s->datafp);
858 s->datafp = NULL;
859 s->datalen = 0;
861 mta_send(s, "RSET");
865 mta_send(s, "QUIT");
878 mta_response(struct mta_session *s, char *line)
889 switch (s->state) {
893 mta_error(s, "BANNER rejected: %s", line);
894 s->flags |= MTA_FREE;
905 mta_report_link_greeting(s, pbuf);
907 if (s->flags & MTA_LMTP)
908 mta_enter_state(s, MTA_LHLO);
910 mta_enter_state(s, MTA_EHLO);
916 if ((s->relay->flags & RELAY_AUTH) ||
917 (s->flags & MTA_WANT_SECURE)) {
918 mta_error(s, "EHLO rejected: %s", line);
919 s->flags |= MTA_FREE;
922 mta_enter_state(s, MTA_HELO);
925 if (!(s->flags & MTA_FORCE_PLAIN))
926 mta_enter_state(s, MTA_STARTTLS);
928 mta_enter_state(s, MTA_READY);
933 mta_error(s, "HELO rejected: %s", line);
934 s->flags |= MTA_FREE;
937 mta_enter_state(s, MTA_READY);
942 mta_error(s, "LHLO rejected: %s", line);
943 s->flags |= MTA_FREE;
946 mta_enter_state(s, MTA_READY);
951 if (!(s->flags & MTA_WANT_SECURE)) {
952 mta_enter_state(s, MTA_AUTH);
956 mta_error(s, "STARTTLS rejected: %s", line);
957 s->flags |= MTA_FREE;
961 mta_tls_init(s);
966 mta_error(s, "AUTH rejected: %s", line);
967 mta_report_link_auth(s, s->username, "fail");
968 s->flags |= MTA_FREE;
971 mta_report_link_auth(s, s->username, "pass");
972 mta_enter_state(s, MTA_READY);
977 mta_error(s, "AUTH rejected: %s", line);
978 mta_report_link_auth(s, s->username, "fail");
979 s->flags |= MTA_FREE;
982 mta_enter_state(s, MTA_AUTH_LOGIN_USER);
987 mta_error(s, "AUTH rejected: %s", line);
988 mta_report_link_auth(s, s->username, "fail");
989 s->flags |= MTA_FREE;
992 mta_enter_state(s, MTA_AUTH_LOGIN_PASS);
997 mta_error(s, "AUTH rejected: %s", line);
998 mta_report_link_auth(s, s->username, "fail");
999 s->flags |= MTA_FREE;
1002 mta_report_link_auth(s, s->username, "pass");
1003 mta_enter_state(s, MTA_READY);
1013 mta_flush_task(s, delivery, line, 0, 0);
1014 mta_enter_state(s, MTA_RSET);
1017 mta_report_tx_begin(s, s->task->msgid);
1018 mta_report_tx_mail(s, s->task->msgid, s->task->sender, 1);
1019 mta_enter_state(s, MTA_RCPT);
1023 e = s->currevp;
1031 s->currevp = TAILQ_NEXT(s->currevp, entry);
1033 s->failures = 0;
1042 mta_report_tx_rollback(s, s->task->msgid);
1043 mta_report_tx_reset(s, s->task->msgid);
1048 s->failures++;
1051 TAILQ_REMOVE(&s->task->envelopes, e, entry);
1055 (void)snprintf(buf, sizeof(buf), "%s",
1056 mta_host_to_text(s->route->dst));
1058 e->session = s->id;
1066 if (getsockname(io_fileno(s->io), sa, &sa_len) == -1)
1076 if (s->relay->limits->max_failures_per_session &&
1077 s->failures == s->relay->limits->max_failures_per_session) {
1078 mta_flush_task(s, IMSG_MTA_DELIVERY_TEMPFAIL,
1080 mta_enter_state(s, MTA_QUIT);
1087 if (TAILQ_EMPTY(&s->task->envelopes)) {
1088 mta_flush_task(s, IMSG_MTA_DELIVERY_OK,
1090 mta_enter_state(s, MTA_RSET);
1097 mta_report_tx_rcpt(s,
1098 s->task->msgid, e->dest, 1);
1101 mta_report_tx_rcpt(s,
1102 s->task->msgid, e->dest, -1);
1105 mta_report_tx_rcpt(s,
1106 s->task->msgid, e->dest, 0);
1110 if (s->currevp == NULL)
1111 mta_enter_state(s, MTA_DATA);
1113 mta_enter_state(s, MTA_RCPT);
1118 mta_report_tx_data(s, s->task->msgid, 1);
1119 mta_enter_state(s, MTA_BODY);
1127 mta_report_tx_data(s, s->task->msgid,
1129 mta_report_tx_rollback(s, s->task->msgid);
1130 mta_report_tx_reset(s, s->task->msgid);
1131 mta_flush_task(s, delivery, line, 0, 0);
1132 mta_enter_state(s, MTA_RSET);
1139 s->msgtried = 0;
1140 s->msgcount++;
1147 mta_report_tx_rollback(s, s->task->msgid);
1148 mta_report_tx_reset(s, s->task->msgid);
1151 mta_report_tx_commit(s, s->task->msgid, s->datalen);
1152 mta_report_tx_reset(s, s->task->msgid);
1154 mta_flush_task(s, delivery, line, (s->flags & MTA_LMTP) ? 1 : 0, 0);
1155 if (s->task) {
1156 s->rcptcount--;
1157 mta_enter_state(s, MTA_LMTP_EOM);
1159 s->rcptcount = 0;
1160 if (s->relay->limits->sessdelay_transaction) {
1162 (long long)s->relay->limits->sessdelay_transaction);
1163 s->hangon = s->relay->limits->sessdelay_transaction -1;
1164 s->flags |= MTA_HANGON;
1166 s->relay->limits->sessdelay_transaction, s);
1169 mta_enter_state(s, MTA_READY);
1174 s->rcptcount = 0;
1176 if (s->task) {
1177 mta_report_tx_rollback(s, s->task->msgid);
1178 mta_report_tx_reset(s, s->task->msgid);
1180 if (s->relay->limits->sessdelay_transaction) {
1182 (long long)s->relay->limits->sessdelay_transaction);
1183 s->hangon = s->relay->limits->sessdelay_transaction -1;
1184 s->flags |= MTA_HANGON;
1186 s->relay->limits->sessdelay_transaction, s);
1189 mta_enter_state(s, MTA_READY);
1200 struct mta_session *s = arg;
1206 log_trace(TRACE_IO, "mta: %p: %s %s", s, io_strevent(evt),
1212 mta_connected(s);
1214 if (s->use_smtps) {
1216 mta_tls_init(s);
1217 if (s->flags & MTA_FREE)
1218 mta_free(s);
1221 mta_enter_state(s, MTA_BANNER);
1227 log_info("%016"PRIx64" mta tls ciphers=%s",
1228 s->id, tls_to_text(io_tls(s->io)));
1229 s->flags |= MTA_TLS;
1230 if (s->relay->dispatcher->u.remote.tls_verify)
1231 s->flags |= MTA_TLS_VERIFIED;
1233 mta_tls_started(s);
1234 mta_report_link_tls(s,
1235 tls_to_text(io_tls(s->io)));
1240 line = io_getline(s->io, &len);
1242 if (io_datalen(s->io) >= LINE_MAX) {
1243 mta_error(s, "Input too long");
1244 mta_free(s);
1253 log_trace(TRACE_MTA, "mta: %p: <<< %s", s, line);
1254 mta_report_protocol_server(s, line);
1257 mta_error(s, "Bad response: %s", error);
1258 mta_free(s);
1263 if (s->state == MTA_EHLO) {
1265 s->ext |= MTA_EXT_STARTTLS;
1267 s->ext |= MTA_EXT_AUTH;
1270 s->ext |= MTA_EXT_AUTH_PLAIN;
1273 s->ext |= MTA_EXT_AUTH_LOGIN;
1276 s->ext |= MTA_EXT_PIPELINING;
1278 s->ext |= MTA_EXT_DSN;
1280 s->ext_size = strtonum(msg+5, 0, UINT32_MAX, &error);
1282 s->ext |= MTA_EXT_SIZE;
1288 if (s->replybuf[0] == '\0')
1289 (void)strlcat(s->replybuf, line, sizeof s->replybuf);
1296 (void)strlcat(s->replybuf, p, sizeof s->replybuf);
1304 if (s->replybuf[0] == '\0')
1305 (void)strlcat(s->replybuf, line, sizeof s->replybuf);
1312 if (strlcat(s->replybuf, p, sizeof s->replybuf) >= sizeof s->replybuf)
1313 (void)strlcpy(s->replybuf, line, sizeof s->replybuf);
1316 if (s->state == MTA_QUIT) {
1318 s->id, s->msgcount);
1319 mta_free(s);
1323 mta_response(s, s->replybuf);
1324 if (s->flags & MTA_FREE) {
1325 mta_free(s);
1328 if (s->flags & MTA_RECONN) {
1329 s->flags &= ~MTA_RECONN;
1330 mta_connect(s);
1334 if (io_datalen(s->io)) {
1336 mta_error(s, "Remote host sent too much data");
1337 if (s->flags & MTA_WAIT)
1338 s->flags |= MTA_FREE;
1340 mta_free(s);
1345 if (s->state == MTA_BODY) {
1346 mta_enter_state(s, MTA_BODY);
1347 if (s->flags & MTA_FREE) {
1348 mta_free(s);
1353 if (io_queued(s->io) == 0)
1358 log_debug("debug: mta: %p: connection timeout", s);
1359 mta_error(s, "Connection timeout");
1360 mta_report_timeout(s);
1361 if (!s->ready)
1362 mta_connect(s);
1364 mta_free(s);
1368 log_debug("debug: mta: %p: IO error: %s", s, io_error(io));
1370 if (s->state == MTA_STARTTLS && s->use_smtp_tls) {
1374 "downgrading to plain", s->id);
1375 s->flags &= ~MTA_TLS;
1376 s->flags |= MTA_DOWNGRADE_PLAIN;
1377 mta_connect(s);
1381 mta_error(s, "IO Error: %s", io_error(io));
1382 mta_free(s);
1386 log_debug("debug: mta: %p: disconnected in state %s",
1387 s, mta_strstate(s->state));
1388 mta_error(s, "Connection closed unexpectedly");
1389 if (!s->ready)
1390 mta_connect(s);
1392 mta_free(s);
1401 mta_send(struct mta_session *s, char *fmt, ...)
1412 log_trace(TRACE_MTA, "mta: %p: >>> %s", s, p);
1415 mta_report_protocol_client(s, "AUTH PLAIN ********");
1416 else if (s->state == MTA_AUTH_LOGIN_USER || s->state == MTA_AUTH_LOGIN_PASS)
1417 mta_report_protocol_client(s, "********");
1419 mta_report_protocol_client(s, p);
1421 io_xprintf(s->io, "%s\r\n", p);
1430 mta_queue_data(struct mta_session *s)
1436 q = io_queued(s->io);
1438 while (io_queued(s->io) < MTA_HIWAT) {
1439 if ((len = getline(&ln, &sz, s->datafp)) == -1)
1443 s->datalen += io_xprintf(s->io, "%s%s\r\n", *ln == '.' ? "." : "", ln);
1447 if (ferror(s->datafp)) {
1448 mta_flush_task(s, IMSG_MTA_DELIVERY_TEMPFAIL,
1453 if (feof(s->datafp)) {
1454 fclose(s->datafp);
1455 s->datafp = NULL;
1458 return (io_queued(s->io) - q);
1462 mta_flush_task(struct mta_session *s, int delivery, const char *error, size_t count,
1473 (void)snprintf(relay, sizeof relay, "%s", mta_host_to_text(s->route->dst));
1475 while ((e = TAILQ_FIRST(&s->task->envelopes))) {
1482 TAILQ_REMOVE(&s->task->envelopes, e, entry);
1485 e->session = s->id;
1486 e->ext = s->ext;
1495 if (getsockname(io_fileno(s->io), sa, &sa_len) == -1)
1514 free(s->task->sender);
1515 free(s->task);
1516 s->task = NULL;
1518 if (s->datafp) {
1519 fclose(s->datafp);
1520 s->datafp = NULL;
1529 mta_error(struct mta_session *s, const char *fmt, ...)
1540 if (s->msgcount)
1542 " after %zu message%s sent: %s", s->id, s->msgcount,
1543 (s->msgcount > 1) ? "s" : "", error);
1545 log_info("%016"PRIx64" mta error reason=%s",
1546 s->id, error);
1552 if (s->state == MTA_INIT &&
1559 mta_route_error(s->relay, s->route);
1561 if (s->task)
1562 mta_flush_task(s, IMSG_MTA_DELIVERY_TEMPFAIL, error, 0, 0);
1568 mta_tls_init(struct mta_session *s)
1574 log_info("%016"PRIx64" mta closing reason=tls-failure", s->id);
1575 s->flags |= MTA_FREE;
1579 remote = &s->relay->dispatcher->u.remote;
1580 if ((s->flags & MTA_WANT_SECURE) && !remote->tls_required) {
1587 log_info("%016"PRIx64" mta closing reason=tls-failure", s->id);
1589 s->flags |= MTA_FREE;
1593 if (io_connect_tls(s->io, tls, s->mxname) == -1) {
1594 log_info("%016"PRIx64" mta closing reason=tls-connect-failed", s->id);
1596 s->flags |= MTA_FREE;
1601 mta_tls_started(struct mta_session *s)
1603 if (tls_peer_cert_provided(io_tls(s->io))) {
1605 "cert-check result=\"%s\" fingerprint=\"%s\"",
1606 s->id,
1607 (s->flags & MTA_TLS_VERIFIED) ? "valid" : "unverified",
1608 tls_peer_cert_hash(io_tls(s->io)));
1613 s->id);
1616 if (s->use_smtps) {
1617 mta_enter_state(s, MTA_BANNER);
1618 io_set_read(s->io);
1621 mta_enter_state(s, MTA_EHLO);
1695 mta_filter_begin(struct mta_session *s)
1697 if (!SESSION_FILTERED(s))
1701 m_add_id(p_lka, s->id);
1702 m_add_string(p_lka, s->relay->dispatcher->u.remote.filtername);
1707 mta_filter_end(struct mta_session *s)
1709 if (!SESSION_FILTERED(s))
1713 m_add_id(p_lka, s->id);
1718 mta_connected(struct mta_session *s)
1724 log_info("%016"PRIx64" mta connected", s->id);
1727 if (getsockname(io_fileno(s->io),
1731 if (getpeername(io_fileno(s->io),
1735 mta_report_link_connect(s,
1736 s->route->dst->ptrname, 1,
1742 mta_disconnected(struct mta_session *s)
1744 mta_report_link_disconnect(s);
1745 mta_filter_end(s);
1750 mta_report_link_connect(struct mta_session *s, const char *rdns, int fcrdns,
1754 if (! SESSION_FILTERED(s))
1757 report_smtp_link_connect("smtp-out", s->id, rdns, fcrdns, ss_src, ss_dest);
1761 mta_report_link_greeting(struct mta_session *s,
1764 if (! SESSION_FILTERED(s))
1767 report_smtp_link_greeting("smtp-out", s->id, domain);
1771 mta_report_link_identify(struct mta_session *s, const char *method, const char *identity)
1773 if (! SESSION_FILTERED(s))
1776 report_smtp_link_identify("smtp-out", s->id, method, identity);
1780 mta_report_link_tls(struct mta_session *s, const char *ssl)
1782 if (! SESSION_FILTERED(s))
1785 report_smtp_link_tls("smtp-out", s->id, ssl);
1789 mta_report_link_disconnect(struct mta_session *s)
1791 if (! SESSION_FILTERED(s))
1794 report_smtp_link_disconnect("smtp-out", s->id);
1798 mta_report_link_auth(struct mta_session *s, const char *user, const char *result)
1800 if (! SESSION_FILTERED(s))
1803 report_smtp_link_auth("smtp-out", s->id, user, result);
1807 mta_report_tx_reset(struct mta_session *s, uint32_t msgid)
1809 if (! SESSION_FILTERED(s))
1812 report_smtp_tx_reset("smtp-out", s->id, msgid);
1816 mta_report_tx_begin(struct mta_session *s, uint32_t msgid)
1818 if (! SESSION_FILTERED(s))
1821 report_smtp_tx_begin("smtp-out", s->id, msgid);
1825 mta_report_tx_mail(struct mta_session *s, uint32_t msgid, const char *address, int ok)
1827 if (! SESSION_FILTERED(s))
1830 report_smtp_tx_mail("smtp-out", s->id, msgid, address, ok);
1834 mta_report_tx_rcpt(struct mta_session *s, uint32_t msgid, const char *address, int ok)
1836 if (! SESSION_FILTERED(s))
1839 report_smtp_tx_rcpt("smtp-out", s->id, msgid, address, ok);
1843 mta_report_tx_envelope(struct mta_session *s, uint32_t msgid, uint64_t evpid)
1845 if (! SESSION_FILTERED(s))
1848 report_smtp_tx_envelope("smtp-out", s->id, msgid, evpid);
1852 mta_report_tx_data(struct mta_session *s, uint32_t msgid, int ok)
1854 if (! SESSION_FILTERED(s))
1857 report_smtp_tx_data("smtp-out", s->id, msgid, ok);
1861 mta_report_tx_commit(struct mta_session *s, uint32_t msgid, size_t msgsz)
1863 if (! SESSION_FILTERED(s))
1866 report_smtp_tx_commit("smtp-out", s->id, msgid, msgsz);
1870 mta_report_tx_rollback(struct mta_session *s, uint32_t msgid)
1872 if (! SESSION_FILTERED(s))
1875 report_smtp_tx_rollback("smtp-out", s->id, msgid);
1879 mta_report_protocol_client(struct mta_session *s, const char *command)
1881 if (! SESSION_FILTERED(s))
1884 report_smtp_protocol_client("smtp-out", s->id, command);
1888 mta_report_protocol_server(struct mta_session *s, const char *response)
1890 if (! SESSION_FILTERED(s))
1893 report_smtp_protocol_server("smtp-out", s->id, response);
1898 mta_report_filter_response(struct mta_session *s, int phase, int response, const char *param)
1900 if (! SESSION_FILTERED(s))
1903 report_smtp_filter_response("smtp-out", s->id, phase, response, param);
1908 mta_report_timeout(struct mta_session *s)
1910 if (! SESSION_FILTERED(s))
1913 report_smtp_timeout("smtp-out", s->id);