{ "hosts_try_dane", opt_stringptr,
(void *)offsetof(smtp_transport_options_block, hosts_try_dane) },
#endif
+ { "hosts_try_fastopen", opt_stringptr,
+ (void *)offsetof(smtp_transport_options_block, hosts_try_fastopen) },
#ifndef DISABLE_PRDR
{ "hosts_try_prdr", opt_stringptr,
(void *)offsetof(smtp_transport_options_block, hosts_try_prdr) },
NULL, /* hosts_try_dane */
NULL, /* hosts_require_dane */
#endif
+ NULL, /* hosts_try_fastopen */
#ifndef DISABLE_PRDR
US"*", /* hosts_try_prdr */
#endif
NULL, /* dkim_private_key */
NULL, /* dkim_selector */
NULL, /* dkim_sign_headers */
- NULL} /* dkim_strict */
+ NULL, /* dkim_strict */
+ FALSE} /* dot_stuffed */
#endif
};
/* Local statics */
-static uschar *smtp_command; /* Points to last cmd for error messages */
-static uschar *mail_command; /* Points to MAIL cmd for error messages */
-static BOOL update_waiting; /* TRUE to update the "wait" database */
-static BOOL pipelining_active; /* current transaction is in pipe mode */
+static uschar *smtp_command; /* Points to last cmd for error messages */
+static uschar *mail_command; /* Points to MAIL cmd for error messages */
+static uschar *data_command = US""; /* Points to DATA cmd for error messages */
+static BOOL update_waiting; /* TRUE to update the "wait" database */
+static BOOL pipelining_active; /* current transaction is in pipe mode */
/*************************************************
static void
write_logs(address_item *addr, host_item *host)
{
-uschar * message = string_sprintf("H=%s [%s]", host->name, host->address);
+uschar * message = LOGGING(outgoing_port)
+ ? string_sprintf("H=%s [%s]:%d", host->name, host->address,
+ host->port == PORT_NONE ? 25 : host->port)
+ : string_sprintf("H=%s [%s]", host->name, host->address);
-if (LOGGING(outgoing_port))
- message = string_sprintf("%s:%d", message,
- host->port == PORT_NONE ? 25 : host->port);
if (addr->message)
{
message = string_sprintf("%s: %s", message, addr->message);
/* Write SMTP chunk header command */
if (chunk_size > 0)
+ {
if((cmd_count = smtp_write_command(tctx->outblock, FALSE, "BDAT %u%s\r\n",
chunk_size,
flags & tc_chunk_last ? " LAST" : "")
) < 0) return ERROR;
+ if (flags & tc_chunk_last)
+ data_command = string_copy(big_buffer); /* Save for later error message */
+ }
prev_cmd_count = cmd_count += tctx->cmd_count;
time_t start_delivery_time = time(NULL);
smtp_transport_options_block *ob =
(smtp_transport_options_block *)(tblock->options_block);
-BOOL lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
-BOOL smtps = strcmpic(ob->protocol, US"smtps") == 0;
-BOOL ok = FALSE;
-BOOL send_rset = TRUE;
-BOOL send_quit = TRUE;
-BOOL setting_up = TRUE;
-BOOL completed_address = FALSE;
-BOOL esmtp = TRUE;
-BOOL pending_MAIL;
-BOOL pass_message = FALSE;
-uschar peer_offered = 0;
+struct lflags {
+ BOOL lmtp:1;
+ BOOL smtps:1;
+ BOOL ok:1;
+ BOOL send_rset:1;
+ BOOL send_quit:1;
+ BOOL setting_up:1;
+ BOOL esmtp:1;
+ BOOL esmtp_sent:1;
+ BOOL pending_MAIL:1;
#ifndef DISABLE_PRDR
-BOOL prdr_active;
+ BOOL prdr_active:1;
#endif
#ifdef SUPPORT_I18N
-BOOL utf8_needed = FALSE;
+ BOOL utf8_needed:1;
+#endif
+ BOOL dsn_all_lasthop:1;
+#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
+ BOOL dane:1;
+ BOOL dane_required:1;
#endif
-BOOL dsn_all_lasthop = TRUE;
+} lflags;
+
+BOOL pass_message = FALSE;
+BOOL completed_address = FALSE;
+uschar peer_offered = 0;
#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
-BOOL dane = FALSE;
-BOOL dane_required = verify_check_given_host(&ob->hosts_require_dane, host) == OK;
dns_answer tlsa_dnsa;
#endif
smtp_inblock inblock;
suppress_tls = suppress_tls; /* stop compiler warning when no TLS support */
+lflags.lmtp = strcmpic(ob->protocol, US"lmtp") == 0;
+lflags.smtps = strcmpic(ob->protocol, US"smtps") == 0;
+lflags.ok = FALSE;
+lflags.send_rset = TRUE;
+lflags.send_quit = TRUE;
+lflags.setting_up = TRUE;
+lflags.esmtp = TRUE;
+lflags.esmtp_sent = FALSE;
+#ifdef SUPPORT_I18N
+lflags.utf8_needed = FALSE;
+#endif
+lflags.dsn_all_lasthop = TRUE;
+#if defined(SUPPORT_TLS) && defined(EXPERIMENTAL_DANE)
+lflags.dane = FALSE;
+lflags.dane_required = verify_check_given_host(&ob->hosts_require_dane, host) == OK;
+#endif
+
*message_defer = FALSE;
smtp_command = US"initial connection";
+buffer[0] = '\0';
if (max_rcpt == 0) max_rcpt = 999999;
/* Set up the buffer for reading SMTP response packets. */
tls_modify_variables(&tls_out);
#ifndef SUPPORT_TLS
-if (smtps)
+if (lflags.smtps)
{
set_errno_nohost(addrlist, ERRNO_TLSFAILURE, US"TLS support not available",
DEFER, FALSE);
if (inblock.sock < 0)
{
- set_errno_nohost(addrlist, (errno == ETIMEDOUT)? ERRNO_CONNECTTIMEOUT : errno,
+ set_errno_nohost(addrlist, errno == ETIMEDOUT ? ERRNO_CONNECTTIMEOUT : errno,
NULL, DEFER, FALSE);
return DEFER;
}
if (host->dnssec == DS_YES)
{
- if( dane_required
+ if( lflags.dane_required
|| verify_check_given_host(&ob->hosts_try_dane, host) == OK
)
- switch (rc = tlsa_lookup(host, &tlsa_dnsa, dane_required))
+ switch (rc = tlsa_lookup(host, &tlsa_dnsa, lflags.dane_required))
{
- case OK: dane = TRUE; break;
+ case OK: lflags.dane = TRUE; break;
case FAIL_FORCED: break;
default: set_errno_nohost(addrlist, ERRNO_DNSDEFER,
string_sprintf("DANE error: tlsa lookup %s",
return rc;
}
}
- else if (dane_required)
+ else if (lflags.dane_required)
{
set_errno_nohost(addrlist, ERRNO_DNSDEFER,
string_sprintf("DANE error: %s lookup not DNSSEC", host->name),
return FAIL;
}
- if (dane)
+ if (lflags.dane)
ob->tls_tempfail_tryclear = FALSE;
}
#endif /*DANE*/
is nevertheless a reasonably clean way of programming this kind of logic,
where you want to escape on any error. */
- if (!smtps)
+ if (!lflags.smtps)
{
- BOOL good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
+ BOOL good_response;
+
+#ifdef TCP_QUICKACK
+ (void) setsockopt(inblock.sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
+#endif
+ good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
'2', ob->command_timeout);
#ifdef EXPERIMENTAL_DSN_INFO
smtp_greeting = string_copy(buffer);
/* Now check if the helo_data expansion went well, and sign off cleanly if
it didn't. */
- if (helo_data == NULL)
+ if (!helo_data)
{
uschar *message = string_sprintf("failed to expand helo_data: %s",
expand_string_message);
mailers use upper case for some reason (the RFC is quite clear about case
independence) so, for peace of mind, I gave in. */
- esmtp = verify_check_given_host(&ob->hosts_avoid_esmtp, host) != OK;
+ lflags.esmtp = verify_check_given_host(&ob->hosts_avoid_esmtp, host) != OK;
/* Alas; be careful, since this goto is not an error-out, so conceivably
we might set data between here and the target which we assume to exist
and be usable. I can see this coming back to bite us. */
#ifdef SUPPORT_TLS
- if (smtps)
+ if (lflags.smtps)
{
smtp_peer_options |= PEER_OFFERED_TLS;
suppress_tls = FALSE;
}
#endif
- if (esmtp)
+ if (lflags.esmtp)
{
if (smtp_write_command(&outblock, FALSE, "%s %s\r\n",
- lmtp? "LHLO" : "EHLO", helo_data) < 0)
+ lflags.lmtp ? "LHLO" : "EHLO", helo_data) < 0)
goto SEND_FAILED;
+ lflags.esmtp_sent = TRUE;
if (!smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
ob->command_timeout))
{
- if (errno != 0 || buffer[0] == 0 || lmtp)
+ if (errno != 0 || buffer[0] == 0 || lflags.lmtp)
{
#ifdef EXPERIMENTAL_DSN_INFO
helo_response = string_copy(buffer);
#endif
goto RESPONSE_FAILED;
}
- esmtp = FALSE;
+ lflags.esmtp = FALSE;
}
#ifdef EXPERIMENTAL_DSN_INFO
helo_response = string_copy(buffer);
#endif
}
else
- {
DEBUG(D_transport)
debug_printf("not sending EHLO (host matches hosts_avoid_esmtp)\n");
- }
- if (!esmtp)
+ if (!lflags.esmtp)
{
BOOL good_response;
+ int n = sizeof(buffer);
+ uschar * rsp = buffer;
+
+ if (lflags.esmtp_sent && (n = Ustrlen(buffer)) < sizeof(buffer)/2)
+ { rsp = buffer + n + 1; n = sizeof(buffer) - n; }
if (smtp_write_command(&outblock, FALSE, "HELO %s\r\n", helo_data) < 0)
goto SEND_FAILED;
- good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
+ good_response = smtp_read_response(&inblock, rsp, n,
'2', ob->command_timeout);
#ifdef EXPERIMENTAL_DSN_INFO
- helo_response = string_copy(buffer);
+ helo_response = string_copy(rsp);
#endif
- if (!good_response) goto RESPONSE_FAILED;
+ if (!good_response)
+ {
+ /* Handle special logging for a closed connection after HELO
+ when had previously sent EHLO */
+
+ if (rsp != buffer && rsp[0] == 0 && (errno == 0 || errno == ECONNRESET))
+ {
+ message = NULL;
+ lflags.send_quit = FALSE;
+ save_errno = ERRNO_SMTPCLOSED;
+ message = string_sprintf("Remote host closed connection "
+ "in response to %s (EHLO response was: %s)",
+ smtp_command, buffer);
+ goto FAILED;
+ }
+ Ustrncpy(buffer, rsp, sizeof(buffer)/2);
+ goto RESPONSE_FAILED;
+ }
}
peer_offered = smtp_peer_options = 0;
- if (esmtp || lmtp)
+ if (lflags.esmtp || lflags.lmtp)
{
peer_offered = ehlo_response(buffer, Ustrlen(buffer),
PEER_OFFERED_TLS /* others checked later */
{
int rc = tls_client_start(inblock.sock, host, addrlist, tblock
# ifdef EXPERIMENTAL_DANE
- , dane ? &tlsa_dnsa : NULL
+ , lflags.dane ? &tlsa_dnsa : NULL
# endif
);
if (rc != OK)
{
# ifdef EXPERIMENTAL_DANE
- if (rc == DEFER && dane)
- {
- log_write(0, LOG_MAIN,
+ if (lflags.dane) log_write(0, LOG_MAIN,
"DANE attempt failed; no TLS connection to %s [%s]",
host->name, host->address);
- }
# endif
save_errno = ERRNO_TLSFAILURE;
message = US"failure while setting up TLS session";
- send_quit = FALSE;
+ lflags.send_quit = FALSE;
goto TLS_FAILED;
}
}
/* For SMTPS we need to wait for the initial OK response. */
- if (smtps)
+ if (lflags.smtps)
{
good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
'2', ob->command_timeout);
if (!good_response) goto RESPONSE_FAILED;
}
- if (esmtp)
+ if (lflags.esmtp)
greeting_cmd = "EHLO";
else
{
}
if (smtp_write_command(&outblock, FALSE, "%s %s\r\n",
- lmtp? "LHLO" : greeting_cmd, helo_data) < 0)
+ lflags.lmtp ? "LHLO" : greeting_cmd, helo_data) < 0)
goto SEND_FAILED;
good_response = smtp_read_response(&inblock, buffer, sizeof(buffer),
'2', ob->command_timeout);
/* If the host is required to use a secure channel, ensure that we
have one. */
-else if ( smtps
+else if ( lflags.smtps
# ifdef EXPERIMENTAL_DANE
- || dane
+ || lflags.dane
# endif
|| verify_check_given_host(&ob->hosts_require_tls, host) == OK
)
#endif
)
{
- if (esmtp || lmtp)
+ if (lflags.esmtp || lflags.lmtp)
{
peer_offered = ehlo_response(buffer, Ustrlen(buffer),
0 /* no TLS */
- | (lmtp && ob->lmtp_ignore_quota ? PEER_OFFERED_IGNQ : 0)
+ | (lflags.lmtp && ob->lmtp_ignore_quota ? PEER_OFFERED_IGNQ : 0)
| PEER_OFFERED_CHUNKING
| PEER_OFFERED_PRDR
#ifdef SUPPORT_I18N
authenticator's client driver is running. */
switch (yield = smtp_auth(buffer, sizeof(buffer), addrlist, host,
- ob, esmtp, &inblock, &outblock))
+ ob, lflags.esmtp, &inblock, &outblock))
{
default: goto SEND_QUIT;
case OK: break;
/* The setting up of the SMTP call is now complete. Any subsequent errors are
message-specific. */
-setting_up = FALSE;
+lflags.setting_up = FALSE;
#ifdef SUPPORT_I18N
if (addrlist->prop.utf8_msg)
{
- utf8_needed = !addrlist->prop.utf8_downcvt
- && !addrlist->prop.utf8_downcvt_maybe;
- DEBUG(D_transport) if (!utf8_needed) debug_printf("utf8: %s downconvert\n",
- addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
+ lflags.utf8_needed = !addrlist->prop.utf8_downcvt
+ && !addrlist->prop.utf8_downcvt_maybe;
+ DEBUG(D_transport) if (!lflags.utf8_needed)
+ debug_printf("utf8: %s downconvert\n",
+ addrlist->prop.utf8_downcvt ? "mandatory" : "optional");
}
/* If this is an international message we need the host to speak SMTPUTF8 */
-if (utf8_needed && !(peer_offered & PEER_OFFERED_UTF8))
+if (lflags.utf8_needed && !(peer_offered & PEER_OFFERED_UTF8))
{
errno = ERRNO_UTF8_FWD;
goto RESPONSE_FAILED;
if (tblock->filter_command != NULL)
{
BOOL rc;
- uschar buffer[64];
- sprintf(CS buffer, "%.50s transport", tblock->name);
+ uschar fbuf[64];
+ sprintf(CS fbuf, "%.50s transport", tblock->name);
rc = transport_set_up_command(&transport_filter_argv, tblock->filter_command,
- TRUE, DEFER, addrlist, buffer, NULL);
+ TRUE, DEFER, addrlist, fbuf, NULL);
transport_filter_timeout = tblock->filter_timeout;
/* On failure, copy the error to all addresses, abandon the SMTP call, and
SEND_MESSAGE:
sync_addr = first_addr;
address_count = 0;
-ok = FALSE;
-send_rset = TRUE;
+lflags.ok = FALSE;
+lflags.send_rset = TRUE;
completed_address = FALSE;
}
#ifndef DISABLE_PRDR
-prdr_active = FALSE;
+lflags.prdr_active = FALSE;
if (peer_offered & PEER_OFFERED_PRDR)
for (addr = first_addr; addr; addr = addr->next)
if (addr->transport_return == PENDING_DEFER)
for (addr = addr->next; addr; addr = addr->next)
if (addr->transport_return == PENDING_DEFER)
{ /* at least two recipients to send */
- prdr_active = TRUE;
+ lflags.prdr_active = TRUE;
sprintf(CS p, " PRDR"); p += 5;
break;
}
/* check if all addresses have lasthop flag */
/* do not send RET and ENVID if true */
-for (dsn_all_lasthop = TRUE, addr = first_addr;
+for (lflags.dsn_all_lasthop = TRUE, addr = first_addr;
address_count < max_rcpt && addr != NULL;
addr = addr->next)
if ((addr->dsn_flags & rf_dsnlasthop) != 1)
{
- dsn_all_lasthop = FALSE;
+ lflags.dsn_all_lasthop = FALSE;
break;
}
/* Add any DSN flags to the mail command */
-if (peer_offered & PEER_OFFERED_DSN && !dsn_all_lasthop)
+if (peer_offered & PEER_OFFERED_DSN && !lflags.dsn_all_lasthop)
{
if (dsn_ret == dsn_ret_hdrs)
{ Ustrcpy(p, " RET=HDRS"); p += 9; }
When PIPELINING is off, each command written reports that it has flushed the
buffer. */
-pending_MAIL = TRUE; /* The block starts with MAIL */
+lflags.pending_MAIL = TRUE; /* The block starts with MAIL */
{
uschar * s = return_path;
}
goto RESPONSE_FAILED;
}
- pending_MAIL = FALSE;
+ lflags.pending_MAIL = FALSE;
break;
}
for (addr = first_addr;
addr && address_count < max_rcpt;
addr = addr->next)
+ if (addr->transport_return == PENDING_DEFER)
{
int count;
BOOL no_flush;
addr->dsn_aware = peer_offered & PEER_OFFERED_DSN
? dsn_support_yes : dsn_support_no;
- if (addr->transport_return != PENDING_DEFER) continue;
-
address_count++;
no_flush = pipelining_active && (!mua_wrapper || addr->next);
rcpt_addr = transport_rcpt_address(addr, tblock->rcpt_include_affixes);
#ifdef SUPPORT_I18N
- {
- uschar * dummy_errstr;
if ( testflag(addrlist, af_utf8_downcvt)
- && (rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, &dummy_errstr),
- dummy_errstr
- ) )
+ && !(rcpt_addr = string_address_utf8_to_alabel(rcpt_addr, NULL))
+ )
{
+ /*XXX could we use a per-address errstr here? Not fail the whole send? */
errno = ERRNO_EXPANDFAIL;
goto SEND_FAILED;
}
- }
#endif
count = smtp_write_command(&outblock, no_flush, "RCPT TO:<%s>%s%s\r\n",
{
switch(sync_responses(first_addr, tblock->rcpt_include_affixes,
&sync_addr, host, count, ob->address_retry_include_sender,
- pending_MAIL, 0, &inblock, ob->command_timeout, buffer,
+ lflags.pending_MAIL, 0, &inblock, ob->command_timeout, buffer,
sizeof(buffer)))
{
- case 3: ok = TRUE; /* 2xx & 5xx => OK & progress made */
+ case 3: lflags.ok = TRUE; /* 2xx & 5xx => OK & progress made */
case 2: completed_address = TRUE; /* 5xx (only) => progress made */
break;
- case 1: ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
- if (!lmtp) completed_address = TRUE; /* can't tell about progress yet */
+ case 1: lflags.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
+ if (!lflags.lmtp) completed_address = TRUE; /* can't tell about progress yet */
case 0: /* No 2xx or 5xx, but no probs */
break;
case -1: goto END_OFF; /* Timeout on RCPT */
default: goto RESPONSE_FAILED; /* I/O error, or any MAIL error */
}
- pending_MAIL = FALSE; /* Dealt with MAIL */
+ lflags.pending_MAIL = FALSE; /* Dealt with MAIL */
}
} /* Loop for next address */
/*XXX could we find a better errno than 0 here? */
set_errno_nohost(addrlist, 0, badaddr->message, FAIL,
testflag(badaddr, af_pass_message));
- ok = FALSE;
+ lflags.ok = FALSE;
break;
}
}
to send is. */
if ( !(peer_offered & PEER_OFFERED_CHUNKING)
- && (ok || (pipelining_active && !mua_wrapper)))
+ && (lflags.ok || (pipelining_active && !mua_wrapper)))
{
int count = smtp_write_command(&outblock, FALSE, "DATA\r\n");
if (count < 0) goto SEND_FAILED;
switch(sync_responses(first_addr, tblock->rcpt_include_affixes, &sync_addr,
- host, count, ob->address_retry_include_sender, pending_MAIL,
- ok ? +1 : -1, &inblock, ob->command_timeout, buffer, sizeof(buffer)))
+ host, count, ob->address_retry_include_sender, lflags.pending_MAIL,
+ lflags.ok ? +1 : -1, &inblock, ob->command_timeout, buffer, sizeof(buffer)))
{
- case 3: ok = TRUE; /* 2xx & 5xx => OK & progress made */
+ case 3: lflags.ok = TRUE; /* 2xx & 5xx => OK & progress made */
case 2: completed_address = TRUE; /* 5xx (only) => progress made */
break;
- case 1: ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
- if (!lmtp) completed_address = TRUE; /* can't tell about progress yet */
+ case 1: lflags.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
+ if (!lflags.lmtp) completed_address = TRUE; /* can't tell about progress yet */
case 0: break; /* No 2xx or 5xx, but no probs */
case -1: goto END_OFF; /* Timeout on RCPT */
default: goto RESPONSE_FAILED; /* I/O error, or any MAIL/DATA error */
}
pipelining_active = FALSE;
+ data_command = string_copy(big_buffer); /* Save for later error message */
}
/* If there were no good recipients (but otherwise there have been no
well as body. Set the appropriate timeout value to be used for each chunk.
(Haven't been able to make it work using select() for writing yet.) */
-if (!(peer_offered & PEER_OFFERED_CHUNKING) && !ok)
+if (!(peer_offered & PEER_OFFERED_CHUNKING) && !lflags.ok)
{
/* Save the first address of the next batch. */
first_addr = addr;
- ok = TRUE;
+ lflags.ok = TRUE;
}
else
{
tctx.host = host;
tctx.first_addr = first_addr;
tctx.sync_addr = &sync_addr;
- tctx.pending_MAIL = pending_MAIL;
+ tctx.pending_MAIL = lflags.pending_MAIL;
tctx.pending_BDAT = FALSE;
- tctx.good_RCPT = ok;
+ tctx.good_RCPT = lflags.ok;
tctx.completed_address = &completed_address;
tctx.cmd_count = 0;
tctx.buffer = buffer;
transport_count = 0;
#ifndef DISABLE_DKIM
- ok = dkim_transport_write_message(inblock.sock, &tctx, &ob->dkim);
+ lflags.ok = dkim_transport_write_message(inblock.sock, &tctx, &ob->dkim);
#else
- ok = transport_write_message(inblock.sock, &tctx, 0);
+ lflags.ok = transport_write_message(inblock.sock, &tctx, 0);
#endif
/* transport_write_message() uses write() because it is called from other
or the failure of a transport filter or the expansion of added headers.
Or, when CHUNKING, it can be a protocol-detected failure. */
- if (!ok)
+ if (!lflags.ok)
goto RESPONSE_FAILED;
/* We used to send the terminating "." explicitly here, but because of
/* Reap any outstanding MAIL & RCPT commands, but not a DATA-go-ahead */
switch(sync_responses(first_addr, tblock->rcpt_include_affixes, &sync_addr,
host, tctx.cmd_count-1, ob->address_retry_include_sender,
- pending_MAIL, 0,
+ lflags.pending_MAIL, 0,
&inblock, ob->command_timeout, buffer, sizeof(buffer)))
{
- case 3: ok = TRUE; /* 2xx & 5xx => OK & progress made */
+ case 3: lflags.ok = TRUE; /* 2xx & 5xx => OK & progress made */
case 2: completed_address = TRUE; /* 5xx (only) => progress made */
break;
- case 1: ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
- if (!lmtp) completed_address = TRUE; /* can't tell about progress yet */
+ case 1: lflags.ok = TRUE; /* 2xx (only) => OK, but if LMTP, */
+ if (!lflags.lmtp) completed_address = TRUE; /* can't tell about progress yet */
case 0: break; /* No 2xx or 5xx, but no probs */
case -1: goto END_OFF; /* Timeout on RCPT */
* followed by the individual responses, before going on with
* the overall response. If we don't get the warning then deal
* with per non-PRDR. */
- if(prdr_active)
+ if(lflags.prdr_active)
{
- ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '3',
+ lflags.ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '3',
ob->final_timeout);
- if (!ok && errno == 0) switch(buffer[0])
+ if (!lflags.ok && errno == 0) switch(buffer[0])
{
- case '2': prdr_active = FALSE;
- ok = TRUE;
+ case '2': lflags.prdr_active = FALSE;
+ lflags.ok = TRUE;
break;
case '4': errno = ERRNO_DATA4XX;
addrlist->more_errno |=
/* For non-PRDR SMTP, we now read a single response that applies to the
whole message. If it is OK, then all the addresses have been delivered. */
- if (!lmtp)
+ if (!lflags.lmtp)
{
- ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
+ lflags.ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
ob->final_timeout);
- if (!ok && errno == 0 && buffer[0] == '4')
+ if (!lflags.ok && errno == 0 && buffer[0] == '4')
{
errno = ERRNO_DATA4XX;
addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
software before the spool gets updated. Also record the final SMTP
confirmation if needed (for SMTP only). */
- if (ok)
+ if (lflags.ok)
{
int flag = '=';
int delivery_time = (int)(time(NULL) - start_delivery_time);
int len;
uschar *conf = NULL;
- send_rset = FALSE;
+ lflags.send_rset = FALSE;
pipelining_active = FALSE;
/* Set up confirmation if needed - applies only to SMTP */
#ifdef DISABLE_EVENT
LOGGING(smtp_confirmation) &&
#endif
- !lmtp
+ !lflags.lmtp
)
{
const uschar *s = string_printing(buffer);
it doesn't get tried again too soon. */
#ifndef DISABLE_PRDR
- if (lmtp || prdr_active)
+ if (lflags.lmtp || lflags.prdr_active)
#else
- if (lmtp)
+ if (lflags.lmtp)
#endif
{
if (!smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
if (errno != 0 || buffer[0] == 0) goto RESPONSE_FAILED;
addr->message = string_sprintf(
#ifndef DISABLE_PRDR
- "%s error after %s: %s", prdr_active ? "PRDR":"LMTP",
+ "%s error after %s: %s", lflags.prdr_active ? "PRDR":"LMTP",
#else
"LMTP error after %s: %s",
#endif
- big_buffer, string_printing(buffer));
+ data_command, string_printing(buffer));
setflag(addr, af_pass_message); /* Allow message to go to user */
if (buffer[0] == '5')
addr->transport_return = FAIL;
addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
addr->transport_return = DEFER;
#ifndef DISABLE_PRDR
- if (!prdr_active)
+ if (!lflags.prdr_active)
#endif
retry_add_item(addr, addr->address_retry_key, 0);
}
addr->special_action = flag;
addr->message = conf;
#ifndef DISABLE_PRDR
- if (prdr_active) addr->flags |= af_prdr_used;
+ if (lflags.prdr_active) addr->flags |= af_prdr_used;
#endif
if (peer_offered & PEER_OFFERED_CHUNKING) addr->flags |= af_chunking_used;
flag = '-';
#ifndef DISABLE_PRDR
- if (!prdr_active)
+ if (!lflags.prdr_active)
#endif
{
/* Update the journal. For homonymic addresses, use the base address plus
}
#ifndef DISABLE_PRDR
- if (prdr_active)
+ if (lflags.prdr_active)
{
/* PRDR - get the final, overall response. For any non-success
upgrade all the address statuses. */
- ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
+ lflags.ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
ob->final_timeout);
- if (!ok)
+ if (!lflags.ok)
{
if(errno == 0 && buffer[0] == '4')
{
here during the setting up phase (i.e. before MAIL FROM) then always defer, as
the problem is not related to this specific message. */
-if (!ok)
+if (!lflags.ok)
{
int code, set_rc;
uschar * set_message;
{
save_errno = errno;
message = NULL;
- send_quit = check_response(host, &save_errno, addrlist->more_errno,
+ lflags.send_quit = check_response(host, &save_errno, addrlist->more_errno,
buffer, &code, &message, &pass_message);
goto FAILED;
}
code = '4';
message = US string_sprintf("send() to %s [%s] failed: %s",
host->name, host->address, strerror(save_errno));
- send_quit = FALSE;
+ lflags.send_quit = FALSE;
goto FAILED;
}
tried again for a while. */
FAILED:
- ok = FALSE; /* For when reached by GOTO */
+ lflags.ok = FALSE; /* For when reached by GOTO */
set_message = message;
- if (setting_up)
- {
+ if (lflags.setting_up)
if (code == '5')
set_rc = FAIL;
else
yield = set_rc = DEFER;
- }
/* We want to handle timeouts after MAIL or "." and loss of connection after
"." specially. They can indicate a problem with the sender address or with
DEBUG(D_transport)
debug_printf("ok=%d send_quit=%d send_rset=%d continue_more=%d "
- "yield=%d first_address is %sNULL\n", ok, send_quit, send_rset,
- continue_more, yield, (first_addr == NULL)? "":"not ");
+ "yield=%d first_address is %sNULL\n", lflags.ok, lflags.send_quit,
+ lflags.send_rset, continue_more, yield, first_addr ? "not " : "");
-if (completed_address && ok && send_quit)
+if (completed_address && lflags.ok && lflags.send_quit)
{
BOOL more;
smtp_compare_t t_compare;
uschar *msg;
BOOL pass_message;
- if (send_rset)
+ if (lflags.send_rset)
{
- if (! (ok = smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0))
+ if (! (lflags.ok = smtp_write_command(&outblock, FALSE, "RSET\r\n") >= 0))
{
msg = US string_sprintf("send() to %s [%s] failed: %s", host->name,
host->address, strerror(save_errno));
- send_quit = FALSE;
+ lflags.send_quit = FALSE;
}
- else if (! (ok = smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
- ob->command_timeout)))
+ else if (! (lflags.ok = smtp_read_response(&inblock, buffer,
+ sizeof(buffer), '2', ob->command_timeout)))
{
int code;
- send_quit = check_response(host, &errno, 0, buffer, &code, &msg,
+ lflags.send_quit = check_response(host, &errno, 0, buffer, &code, &msg,
&pass_message);
- if (!send_quit)
+ if (!lflags.send_quit)
{
DEBUG(D_transport) debug_printf("H=%s [%s] %s\n",
host->name, host->address, msg);
/* Either RSET was not needed, or it succeeded */
- if (ok)
+ if (lflags.ok)
{
if (first_addr != NULL) /* More addresses still to be sent */
{ /* in this run of the transport */
{
tls_close(FALSE, TRUE);
smtp_peer_options = smtp_peer_options_wrap;
- if (smtps)
- ok = FALSE;
+ if (lflags.smtps)
+ lflags.ok = FALSE;
else
- ok = smtp_write_command(&outblock,FALSE,"EHLO %s\r\n",helo_data) >= 0 &&
+ lflags.ok = smtp_write_command(&outblock,FALSE,"EHLO %s\r\n",helo_data) >= 0 &&
smtp_read_response(&inblock, buffer, sizeof(buffer), '2',
ob->command_timeout);
}
/*XXX DSN_INFO: assume likely to do new HELO; but for greet we'll want to
propagate it from the initial
*/
- if (ok && transport_pass_socket(tblock->name, host->name, host->address,
- new_message_id, inblock.sock))
- {
- send_quit = FALSE;
- }
+ if (lflags.ok && transport_pass_socket(tblock->name, host->name,
+ host->address, new_message_id, inblock.sock))
+ lflags.send_quit = FALSE;
}
/* If RSET failed and there are addresses left, they get deferred. */
operation, the old commented-out code was removed on 17-Sep-99. */
SEND_QUIT:
-if (send_quit) (void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
+if (lflags.send_quit) (void)smtp_write_command(&outblock, FALSE, "QUIT\r\n");
END_OFF:
case continue_more won't get set. */
HDEBUG(D_transport|D_acl|D_v) debug_printf(" SMTP(close)>>\n");
+if (lflags.send_quit)
+ {
+ shutdown(outblock.sock, SHUT_WR);
+ if (fcntl(inblock.sock, F_SETFL, O_NONBLOCK) == 0)
+ for (rc = 16; read(inblock.sock, inbuffer, sizeof(inbuffer)) > 0 && rc > 0;)
+ rc--; /* drain socket */
+ }
(void)close(inblock.sock);
#ifndef DISABLE_EVENT
{
address_item *first_addr = NULL;
address_item *addr;
-for (addr = addrlist; addr != NULL; addr = addr->next)
+for (addr = addrlist; addr; addr = addr->next)
if (addr->transport_return == DEFER)
{
- if (first_addr == NULL) first_addr = addr;
+ if (!first_addr) first_addr = addr;
addr->transport_return = PENDING_DEFER;
addr->basic_errno = 0;
addr->more_errno = (host->mx >= 0)? 'M' : 'A';
int total_hosts_tried = 0;
address_item *addr;
BOOL expired = TRUE;
-BOOL continuing = continue_hostname != NULL;
uschar *expanded_hosts = NULL;
uschar *pistring;
uschar *tid = string_sprintf("%s transport", tblock->name);
DEBUG(D_transport)
{
debug_printf("%s transport entered\n", tblock->name);
- for (addr = addrlist; addr != NULL; addr = addr->next)
+ for (addr = addrlist; addr; addr = addr->next)
debug_printf(" %s\n", addr->address);
- if (continuing) debug_printf("already connected to %s [%s]\n",
+ if (hostlist)
+ {
+ debug_printf("hostlist:\n");
+ for (host = hostlist; host; host = host->next)
+ debug_printf(" %s:%d\n", host->name, host->port);
+ }
+ if (continue_hostname) debug_printf("already connected to %s [%s]\n",
continue_hostname, continue_host_address);
}
a host list with hosts_override set, use the host list supplied with the
transport. It is an error for this not to exist. */
-if (hostlist == NULL || (ob->hosts_override && ob->hosts != NULL))
+if (!hostlist || (ob->hosts_override && ob->hosts))
{
- if (ob->hosts == NULL)
+ if (!ob->hosts)
{
addrlist->message = string_sprintf("%s transport called with no hosts set",
tblock->name);
as the hosts string will never be used again, it doesn't matter that we
replace all the : characters with zeros. */
- if (ob->hostlist == NULL)
+ if (!ob->hostlist)
{
uschar *s = ob->hosts;
{
addrlist->message = string_sprintf("failed to expand list of hosts "
"\"%s\" in %s transport: %s", s, tblock->name, expand_string_message);
- addrlist->transport_return = search_find_defer? DEFER : PANIC;
+ addrlist->transport_return = search_find_defer ? DEFER : PANIC;
return FALSE; /* Only top address has status */
}
DEBUG(D_transport) debug_printf("expanded list of hosts \"%s\" to "
host_build_hostlist(&hostlist, s, ob->hosts_randomize);
/* Check that the expansion yielded something useful. */
- if (hostlist == NULL)
+ if (!hostlist)
{
addrlist->message =
string_sprintf("%s transport has empty hosts setting", tblock->name);
already been randomized (but don't bother if continuing down an existing
connection). */
-else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continuing)
+else if (ob->hosts_randomize && hostlist->mx == MX_NONE && !continue_hostname)
{
host_item *newlist = NULL;
- while (hostlist != NULL)
+ while (hostlist)
{
host_item *h = hostlist;
hostlist = hostlist->next;
h->sort_key = random_number(100);
- if (newlist == NULL)
+ if (!newlist)
{
h->next = NULL;
newlist = h;
else
{
host_item *hh = newlist;
- while (hh->next != NULL)
+ while (hh->next)
{
if (h->sort_key < hh->next->sort_key) break;
hh = hh->next;
time. After that, set the status and error data for any addresses that haven't
had it set already. */
-for (cutoff_retry = 0; expired &&
- cutoff_retry < ((ob->delay_after_cutoff)? 1 : 2);
+for (cutoff_retry = 0;
+ expired && cutoff_retry < (ob->delay_after_cutoff ? 1 : 2);
cutoff_retry++)
{
host_item *nexthost = NULL;
int unexpired_hosts_tried = 0;
for (host = hostlist;
- host != NULL &&
- unexpired_hosts_tried < ob->hosts_max_try &&
- total_hosts_tried < ob->hosts_max_try_hardlimit;
+ host
+ && unexpired_hosts_tried < ob->hosts_max_try
+ && total_hosts_tried < ob->hosts_max_try_hardlimit;
host = nexthost)
{
int rc;
int host_af;
uschar *rs;
- BOOL serialized = FALSE;
BOOL host_is_expired = FALSE;
BOOL message_defer = FALSE;
BOOL some_deferred = FALSE;
Note that we mustn't skip unusable hosts if the address is not unset; they
may be needed as expired hosts on the 2nd time round the cutoff loop. */
- if (host->address == NULL)
+ if (!host->address)
{
int new_port, flags;
host_item *hh;
"HOST_FIND_AGAIN" : "HOST_FIND_FAILED", host->name);
host->status = hstatus_unusable;
- for (addr = addrlist; addr != NULL; addr = addr->next)
+ for (addr = addrlist; addr; addr = addr->next)
{
if (addr->transport_return != DEFER) continue;
addr->basic_errno = ERRNO_UNKNOWNHOST;
if (rc == HOST_FOUND_LOCAL && !ob->allow_localhost)
{
- for (addr = addrlist; addr != NULL; addr = addr->next)
+ for (addr = addrlist; addr; addr = addr->next)
{
addr->basic_errno = 0;
addr->message = string_sprintf("%s transport found host %s to be "
result of the lookup. Set expired FALSE, to save the outer loop executing
twice. */
- if (continuing && (Ustrcmp(continue_hostname, host->name) != 0 ||
- Ustrcmp(continue_host_address, host->address) != 0))
+ if ( continue_hostname
+ && ( Ustrcmp(continue_hostname, host->name) != 0
+ || Ustrcmp(continue_host_address, host->address) != 0
+ ) )
{
expired = FALSE;
continue; /* With next host */
&domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK))
{
expired = FALSE;
- for (addr = addrlist; addr != NULL; addr = addr->next)
- {
- if (addr->transport_return != DEFER) continue;
- addr->message = US"domain matches queue_smtp_domains, or -odqs set";
- }
+ for (addr = addrlist; addr; addr = addr->next)
+ if (addr->transport_return == DEFER)
+ addr->message = US"domain matches queue_smtp_domains, or -odqs set";
continue; /* With next host */
}
the standard SMTP port. A host may have its own port setting that overrides
the default. */
- pistring = string_sprintf(":%d", (host->port == PORT_NONE)?
- port : host->port);
+ pistring = string_sprintf(":%d", host->port == PORT_NONE
+ ? port : host->port);
if (Ustrcmp(pistring, ":25") == 0) pistring = US"";
/* Select IPv4 or IPv6, and choose an outgoing interface. If the interface
because connections to the same host from a different interface should be
treated separately. */
- host_af = (Ustrchr(host->address, ':') == NULL)? AF_INET : AF_INET6;
+ host_af = Ustrchr(host->address, ':') == NULL ? AF_INET : AF_INET6;
if ((rs = ob->interface) && *rs)
{
if (!smtp_get_interface(rs, host_af, addrlist, &interface, tid))
switch (host->status)
{
case hstatus_unusable:
- expired = FALSE;
- setflag(addrlist, af_retry_skipped);
- /* Fall through */
+ expired = FALSE;
+ setflag(addrlist, af_retry_skipped);
+ /* Fall through */
case hstatus_unusable_expired:
- switch (host->why)
- {
- case hwhy_retry: hosts_retry++; break;
- case hwhy_failed: hosts_fail++; break;
- case hwhy_deferred: hosts_defer++; break;
- }
-
- /* If there was a retry message key, implying that previously there
- was a message-specific defer, we don't want to update the list of
- messages waiting for these hosts. */
-
- if (retry_message_key != NULL) update_waiting = FALSE;
- continue; /* With the next host or IP address */
+ switch (host->why)
+ {
+ case hwhy_retry: hosts_retry++; break;
+ case hwhy_failed: hosts_fail++; break;
+ case hwhy_deferred: hosts_defer++; break;
+ }
+
+ /* If there was a retry message key, implying that previously there
+ was a message-specific defer, we don't want to update the list of
+ messages waiting for these hosts. */
+
+ if (retry_message_key) update_waiting = FALSE;
+ continue; /* With the next host or IP address */
}
}
else
{
- if (host->address == NULL ||
- host->status != hstatus_unusable_expired ||
- host->last_try > received_time)
+ if ( !host->address
+ || host->status != hstatus_unusable_expired
+ || host->last_try > received_time)
continue;
- DEBUG(D_transport)
- debug_printf("trying expired host %s [%s]%s\n",
+ DEBUG(D_transport) debug_printf("trying expired host %s [%s]%s\n",
host->name, host->address, pistring);
host_is_expired = TRUE;
}
and remember this for later deletion. Do not do any of this if we are
sending the message down a pre-existing connection. */
- if (!continuing &&
- verify_check_given_host(&ob->serialize_hosts, host) == OK)
+ if ( !continue_hostname
+ && verify_check_given_host(&ob->serialize_hosts, host) == OK)
{
serialize_key = string_sprintf("host-serialize-%s", host->name);
if (!enq_start(serialize_key, 1))
hosts_serial++;
continue;
}
- serialized = TRUE;
}
/* OK, we have an IP address that is not waiting for its retry time to
DEBUG(D_transport) debug_printf("delivering %s to %s [%s] (%s%s)\n",
message_id, host->name, host->address, addrlist->address,
- (addrlist->next == NULL)? "" : ", ...");
+ addrlist->next ? ", ..." : "");
set_process_info("delivering %s to %s [%s] (%s%s)",
message_id, host->name, host->address, addrlist->address,
- (addrlist->next == NULL)? "" : ", ...");
+ addrlist->next ? ", ..." : "");
/* This is not for real; don't do the delivery. If there are
any remaining hosts, list them. */
{
host_item *host2;
set_errno_nohost(addrlist, 0, NULL, OK, FALSE);
- for (addr = addrlist; addr != NULL; addr = addr->next)
+ for (addr = addrlist; addr; addr = addr->next)
{
addr->host_used = host;
addr->special_action = '*';
{
debug_printf("*** delivery by %s transport bypassed by -N option\n"
"*** host and remaining hosts:\n", tblock->name);
- for (host2 = host; host2 != NULL; host2 = host2->next)
+ for (host2 = host; host2; host2 = host2->next)
debug_printf(" %s [%s]\n", host2->name,
- (host2->address == NULL)? US"unset" : host2->address);
+ host2->address ? host2->address : US"unset");
}
rc = OK;
}
failures, where the log has already been written. If all hosts defer a
general message is written at the end. */
- if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL &&
- first_addr->basic_errno != ERRNO_TLSFAILURE)
+ if (rc == DEFER && first_addr->basic_errno != ERRNO_AUTHFAIL
+ && first_addr->basic_errno != ERRNO_TLSFAILURE)
write_logs(first_addr, host);
#ifndef DISABLE_EVENT
/* Delivery attempt finished */
- rs = (rc == OK)? US"OK" : (rc == DEFER)? US"DEFER" : (rc == ERROR)?
- US"ERROR" : US"?";
+ rs = rc == OK ? US"OK"
+ : rc == DEFER ? US"DEFER"
+ : rc == ERROR ? US"ERROR"
+ : US"?";
set_process_info("delivering %s: just tried %s [%s] for %s%s: result %s",
message_id, host->name, host->address, addrlist->address,
- (addrlist->next == NULL)? "" : " (& others)", rs);
+ addrlist->next ? " (& others)" : "", rs);
/* Release serialization if set up */
- if (serialized) enq_end(serialize_key);
+ if (serialize_key) enq_end(serialize_key);
/* If the result is DEFER, or if a host retry record is known to exist, we
need to add an item to the retry chain for updating the retry database
the unusable tree at the outer level, so even if different address blocks
contain the same address, it still won't get tried again.) */
- if (rc == DEFER || retry_host_key != NULL)
+ if (rc == DEFER || retry_host_key)
{
- int delete_flag = (rc != DEFER)? rf_delete : 0;
- if (retry_host_key == NULL)
+ int delete_flag = rc != DEFER ? rf_delete : 0;
+ if (!retry_host_key)
{
BOOL incl_ip;
if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
ob->expand_retry_include_ip_address, &incl_ip) != OK)
incl_ip = TRUE; /* error; use most-specific retry record */
- retry_host_key = incl_ip ?
- string_sprintf("T:%S:%s%s", host->name, host->address, pistring) :
- string_sprintf("T:%S%s", host->name, pistring);
+ retry_host_key = incl_ip
+ ? string_sprintf("T:%S:%s%s", host->name, host->address, pistring)
+ : string_sprintf("T:%S%s", host->name, pistring);
}
/* If a delivery of another message over an existing SMTP connection
host is genuinely down, another non-continued message delivery will
notice it soon enough. */
- if (delete_flag != 0 || !continuing)
+ if (delete_flag != 0 || !continue_hostname)
retry_add_item(first_addr, retry_host_key, rf_host | delete_flag);
/* We may have tried an expired host, if its retry time has come; ensure
if (rc == DEFER)
{
- host->status = (host_is_expired)?
- hstatus_unusable_expired : hstatus_unusable;
+ host->status = host_is_expired
+ ? hstatus_unusable_expired : hstatus_unusable;
host->why = hwhy_deferred;
}
}
reasonable. Also, stop the message from being remembered as waiting
for specific hosts. */
- if (message_defer || retry_message_key != NULL)
+ if (message_defer || retry_message_key)
{
- int delete_flag = message_defer? 0 : rf_delete;
- if (retry_message_key == NULL)
+ int delete_flag = message_defer ? 0 : rf_delete;
+ if (!retry_message_key)
{
BOOL incl_ip;
if (exp_bool(addrlist, US"transport", tblock->name, D_transport,
ob->expand_retry_include_ip_address, &incl_ip) != OK)
incl_ip = TRUE; /* error; use most-specific retry record */
- retry_message_key = incl_ip ?
- string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
- message_id) :
- string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
+ retry_message_key = incl_ip
+ ? string_sprintf("T:%S:%s%s:%s", host->name, host->address, pistring,
+ message_id)
+ : string_sprintf("T:%S%s:%s", host->name, pistring, message_id);
}
retry_add_item(addrlist, retry_message_key,
rf_message | rf_host | delete_flag);
case when we were trying to deliver down an existing channel and failed.
Don't try any other hosts in this case. */
- if (continuing) break;
+ if (continue_hostname) break;
/* If the whole delivery, or some individual addresses, were deferred and
there are more hosts that could be tried, do not count this host towards
important because if we don't try all hosts, the address will never time
out. NOTE: this does not apply to hosts_max_try_hardlimit. */
- if ((rc == DEFER || some_deferred) && nexthost != NULL)
+ if ((rc == DEFER || some_deferred) && nexthost)
{
BOOL timedout;
retry_config *retry = retry_find_config(host->name, NULL, 0, 0);
- if (retry != NULL && retry->rules != NULL)
+ if (retry && retry->rules)
{
retry_rule *last_rule;
for (last_rule = retry->rules;
- last_rule->next != NULL;
+ last_rule->next;
last_rule = last_rule->next);
timedout = time(NULL) - received_time > last_rule->timeout;
}
if (mua_wrapper)
{
- for (addr = addrlist; addr != NULL; addr = addr->next)
+ for (addr = addrlist; addr; addr = addr->next)
addr->transport_return = FAIL;
goto END_TRANSPORT;
}