[exim.git] / src / src / spf.c

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* SPF support.
   Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004 - 2014
   License: GPL
   Copyright (c) The Exim Maintainers 2015 - 2019
*/

/* Code for calling spf checks via libspf-alt. Called from acl.c. */

#include "exim.h"
#ifdef SUPPORT_SPF

/* must be kept in numeric order */
static spf_result_id spf_result_id_list[] = {
  /* name		value */
  { US"invalid",	0},
  { US"neutral",	1 },
  { US"pass",		2 },
  { US"fail",		3 },
  { US"softfail",	4 },
  { US"none",		5 },
  { US"temperror",	6 }, /* RFC 4408 defined */
  { US"permerror",	7 }  /* RFC 4408 defined */
};

SPF_server_t    *spf_server = NULL;
SPF_request_t   *spf_request = NULL;
SPF_response_t  *spf_response = NULL;
SPF_response_t  *spf_response_2mx = NULL;

SPF_dns_rr_t  * spf_nxdomain = NULL;


static SPF_dns_rr_t *
SPF_dns_exim_lookup(SPF_dns_server_t *spf_dns_server,
const char *domain, ns_type rr_type, int should_cache)
{
dns_answer * dnsa = store_get_dns_answer();
dns_scan dnss;
SPF_dns_rr_t * spfrr;

DEBUG(D_receive) debug_printf("SPF_dns_exim_lookup '%s'\n", domain);

if (dns_lookup(dnsa, US domain, rr_type, NULL) == DNS_SUCCEED)
  for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
       rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
    if (  rr->type == rr_type
       && (rr_type != T_TXT || Ustrncmp(rr->data+1, "v=spf1", 6) == 0))
      {
      const uschar * s = rr->data;
      SPF_dns_rr_t srr = {
	.domain = CS rr->name,			/* query information */
	.domain_buf_len = DNS_MAXNAME,
	.rr_type = rr->type,

	.num_rr = 1,				/* answer information */
	.rr = NULL,
	.rr_buf_len = 0,
	.rr_buf_num = 0,
	.ttl = rr->ttl,
	.utc_ttl = 0,
	.herrno = NETDB_SUCCESS,

	.hook = NULL,				/* misc information */
	.source = spf_dns_server
      };

      switch(rr_type)
	{
        case T_MX:
          s += 2;			/* skip the MX precedence field */
        case T_PTR:
	  {
          uschar * buf = store_malloc(256);
          (void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, s,
            (DN_EXPAND_ARG4_TYPE)buf, 256);
          s = buf;
          break;
	  }

        case T_TXT:
	  {
	  gstring * g = NULL;
	  uschar chunk_len;
          for (int off = 0; off < rr->size; off += chunk_len)
            {
            if (!(chunk_len = s[off++])) break;
            g = string_catn(g, s+off, chunk_len);
            }
          if (!g)
            {
            HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
              "empty name: treated as non-existent host name\n");
            continue;
            }
          gstring_release_unused(g);
          s = string_copy_malloc(string_from_gstring(g));
          break;
	  }

        case T_A:
        case T_AAAA:
        default:
	  {
          uschar * buf = store_malloc(dnsa->answerlen + 1);
	  s = memcpy(buf, s, dnsa->answerlen + 1);
          break;
	  }
	}
      DEBUG(D_receive) debug_printf("SPF_dns_exim_lookup '%s'\n", s);
      srr.rr = (void *) &s;

      /* spfrr->rr must have been malloc()d for this */
      SPF_dns_rr_dup(&spfrr, &srr);

      return spfrr;
      }

SPF_dns_rr_dup(&spfrr, spf_nxdomain);
return spfrr;
}


SPF_dns_server_t *
SPF_dns_exim_new(int debug)
{
SPF_dns_server_t *spf_dns_server;

DEBUG(D_receive) debug_printf("SPF_dns_exim_new\n");

if (!(spf_dns_server = malloc(sizeof(SPF_dns_server_t))))
  return NULL;
memset(spf_dns_server, 0, sizeof(SPF_dns_server_t));

spf_dns_server->destroy      = NULL;
spf_dns_server->lookup       = SPF_dns_exim_lookup;
spf_dns_server->get_spf      = NULL;
spf_dns_server->get_exp      = NULL;
spf_dns_server->add_cache    = NULL;
spf_dns_server->layer_below  = NULL;
spf_dns_server->name         = "exim";
spf_dns_server->debug        = debug;

/* XXX This might have to return NO_DATA sometimes. */

spf_nxdomain = SPF_dns_rr_new_init(spf_dns_server,
  "", ns_t_any, 24 * 60 * 60, HOST_NOT_FOUND);
if (!spf_nxdomain)
  {
  free(spf_dns_server);
  return NULL;
  }

return spf_dns_server;
}


/* Construct the SPF library stack.
   Return: Boolean success.
*/

BOOL
spf_init(void)
{
SPF_dns_server_t * dc;
int debug = 0;

DEBUG(D_receive) debug = 1;

/* We insert our own DNS access layer rather than letting the spf library
do it, so that our dns access path is used for debug tracing and for the
testsuite. */

if (!(dc = SPF_dns_exim_new(debug)))
  {
  DEBUG(D_receive) debug_printf("spf: SPF_dns_exim_new() failed\n");
  return FALSE;
  }
if (!(dc = SPF_dns_cache_new(dc, NULL, debug, 8)))
  {
  DEBUG(D_receive) debug_printf("spf: SPF_dns_cache_new() failed\n");
  return FALSE;
  }
if (!(spf_server = SPF_server_new_dns(dc, debug)))
  {
  DEBUG(D_receive) debug_printf("spf: SPF_server_new() failed.\n");
  return FALSE;
  }
  /* Quick hack to override the outdated explanation URL.
  See https://www.mail-archive.com/mailop@mailop.org/msg08019.html */
  SPF_server_set_explanation(spf_server, "Please%_see%_http://www.open-spf.org/Why?id=%{S}&ip=%{C}&receiver=%{R}", &spf_response);
  if (SPF_response_errcode(spf_response) != SPF_E_SUCCESS)
    log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", SPF_strerror(SPF_response_errcode(spf_response)));

return TRUE;
}


/* Set up a context that can be re-used for several
   messages on the same SMTP connection (that come from the
   same host with the same HELO string).

Return: Boolean success
*/

BOOL
spf_conn_init(uschar * spf_helo_domain, uschar * spf_remote_addr)
{
DEBUG(D_receive)
  debug_printf("spf_conn_init: %s %s\n", spf_helo_domain, spf_remote_addr);

if (!spf_server && !spf_init()) return FALSE;

if (SPF_server_set_rec_dom(spf_server, CS primary_hostname))
  {
  DEBUG(D_receive) debug_printf("spf: SPF_server_set_rec_dom(\"%s\") failed.\n",
    primary_hostname);
  spf_server = NULL;
  return FALSE;
  }

spf_request = SPF_request_new(spf_server);

if (  SPF_request_set_ipv4_str(spf_request, CS spf_remote_addr)
   && SPF_request_set_ipv6_str(spf_request, CS spf_remote_addr)
   )
  {
  DEBUG(D_receive)
    debug_printf("spf: SPF_request_set_ipv4_str() and "
      "SPF_request_set_ipv6_str() failed [%s]\n", spf_remote_addr);
  spf_server = NULL;
  spf_request = NULL;
  return FALSE;
  }

if (SPF_request_set_helo_dom(spf_request, CS spf_helo_domain))
  {
  DEBUG(D_receive) debug_printf("spf: SPF_set_helo_dom(\"%s\") failed.\n",
    spf_helo_domain);
  spf_server = NULL;
  spf_request = NULL;
  return FALSE;
  }

return TRUE;
}


/* spf_process adds the envelope sender address to the existing
   context (if any), retrieves the result, sets up expansion
   strings and evaluates the condition outcome.

Return: OK/FAIL  */

int
spf_process(const uschar **listptr, uschar *spf_envelope_sender, int action)
{
int sep = 0;
const uschar *list = *listptr;
uschar *spf_result_id;
int rc = SPF_RESULT_PERMERROR;

DEBUG(D_receive) debug_printf("spf_process\n");

if (!(spf_server && spf_request))
  /* no global context, assume temp error and skip to evaluation */
  rc = SPF_RESULT_PERMERROR;

else if (SPF_request_set_env_from(spf_request, CS spf_envelope_sender))
  /* Invalid sender address. This should be a real rare occurrence */
  rc = SPF_RESULT_PERMERROR;

else
  {
  /* get SPF result */
  if (action == SPF_PROCESS_FALLBACK)
    {
    SPF_request_query_fallback(spf_request, &spf_response, CS spf_guess);
    spf_result_guessed = TRUE;
    }
  else
    SPF_request_query_mailfrom(spf_request, &spf_response);

  /* set up expansion items */
  spf_header_comment     = US SPF_response_get_header_comment(spf_response);
  spf_received           = US SPF_response_get_received_spf(spf_response);
  spf_result             = US SPF_strresult(SPF_response_result(spf_response));
  spf_smtp_comment       = US SPF_response_get_smtp_comment(spf_response);

  rc = SPF_response_result(spf_response);
  }

/* We got a result. Now see if we should return OK or FAIL for it */
DEBUG(D_acl) debug_printf("SPF result is %s (%d)\n", SPF_strresult(rc), rc);

if (action == SPF_PROCESS_GUESS && (!strcmp (SPF_strresult(rc), "none")))
  return spf_process(listptr, spf_envelope_sender, SPF_PROCESS_FALLBACK);

while ((spf_result_id = string_nextinlist(&list, &sep, NULL, 0)))
  {
  BOOL negate, result;

  if ((negate = spf_result_id[0] == '!'))
    spf_result_id++;

  result = Ustrcmp(spf_result_id, spf_result_id_list[rc].name) == 0;
  if (negate != result) return OK;
  }

/* no match */
return FAIL;
}


gstring *
authres_spf(gstring * g)
{
uschar * s;
if (!spf_result) return g;

g = string_append(g, 2, US";\n\tspf=", spf_result);
if (spf_result_guessed)
  g = string_cat(g, US" (best guess record for domain)");

s = expand_string(US"$sender_address_domain");
return s && *s
  ? string_append(g, 2, US" smtp.mailfrom=", s)
  : string_cat(g, US" smtp.mailfrom=<>");
}


#endif
Commit	Line	Data
8523533c TK	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
8e669ac1	4
b8e97684	5	/* SPF support.
5a66c31b	6	Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004 - 2014
80fea873	7	License: GPL
b8e97684	8	Copyright (c) The Exim Maintainers 2015 - 2019
80fea873	9	*/
8e669ac1	10
8523533c TK	11	/* Code for calling spf checks via libspf-alt. Called from acl.c. */
	12
	13	#include "exim.h"
7952eef9	14	#ifdef SUPPORT_SPF
8523533c	15
6d06cf48 TK	16	/* must be kept in numeric order */
6d06cf48 TK	17	static spf_result_id spf_result_id_list[] = {
f2ed27cf JH	18	/* name value */
	19	{ US"invalid", 0},
	20	{ US"neutral", 1 },
	21	{ US"pass", 2 },
	22	{ US"fail", 3 },
	23	{ US"softfail", 4 },
	24	{ US"none", 5 },
f2ed27cf JH	25	{ US"temperror", 6 }, /* RFC 4408 defined */
f2ed27cf JH	26	{ US"permerror", 7 } /* RFC 4408 defined */
6d06cf48 TK	27	};
6d06cf48 TK	28
384152a6 TK	29	SPF_server_t *spf_server = NULL;
	30	SPF_request_t *spf_request = NULL;
	31	SPF_response_t *spf_response = NULL;
	32	SPF_response_t *spf_response_2mx = NULL;
8523533c	33
b8e97684 JH	34	SPF_dns_rr_t * spf_nxdomain = NULL;
	35
	36
	37
	38	static SPF_dns_rr_t *
	39	SPF_dns_exim_lookup(SPF_dns_server_t *spf_dns_server,
	40	const char *domain, ns_type rr_type, int should_cache)
	41	{
8743d3ac	42	dns_answer * dnsa = store_get_dns_answer();
b8e97684 JH	43	dns_scan dnss;
	44	SPF_dns_rr_t * spfrr;
	45
4a3709fb	46	DEBUG(D_receive) debug_printf("SPF_dns_exim_lookup '%s'\n", domain);
b8e97684	47
8743d3ac JH	48	if (dns_lookup(dnsa, US domain, rr_type, NULL) == DNS_SUCCEED)
	49	for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
	50	rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
b8e97684	51	if ( rr->type == rr_type
4a3709fb	52	&& (rr_type != T_TXT \|\| Ustrncmp(rr->data+1, "v=spf1", 6) == 0))
b8e97684	53	{
4a3709fb	54	const uschar * s = rr->data;
b8e97684 JH	55	SPF_dns_rr_t srr = {
	56	.domain = CS rr->name, /* query information */
	57	.domain_buf_len = DNS_MAXNAME,
	58	.rr_type = rr->type,
	59
	60	.num_rr = 1, /* answer information */
	61	.rr = NULL,
	62	.rr_buf_len = 0,
	63	.rr_buf_num = 0,
	64	.ttl = rr->ttl,
	65	.utc_ttl = 0,
	66	.herrno = NETDB_SUCCESS,
	67
	68	.hook = NULL, /* misc information */
	69	.source = spf_dns_server
	70	};
	71
4a3709fb	72	switch(rr_type)
b8e97684	73	{
4a3709fb WB	74	case T_MX:
	75	s += 2; /* skip the MX precedence field */
	76	case T_PTR:
	77	{
	78	uschar * buf = store_malloc(256);
	79	(void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, s,
	80	(DN_EXPAND_ARG4_TYPE)buf, 256);
	81	s = buf;
	82	break;
	83	}
	84
	85	case T_TXT:
	86	{
	87	gstring * g = NULL;
	88	uschar chunk_len;
	89	for (int off = 0; off < rr->size; off += chunk_len)
	90	{
	91	if (!(chunk_len = s[off++])) break;
	92	g = string_catn(g, s+off, chunk_len);
	93	}
	94	if (!g)
	95	{
	96	HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
	97	"empty name: treated as non-existent host name\n");
	98	continue;
	99	}
	100	gstring_release_unused(g);
	101	s = string_copy_malloc(string_from_gstring(g));
	102	break;
	103	}
	104
	105	case T_A:
	106	case T_AAAA:
	107	default:
	108	{
	109	uschar * buf = store_malloc(dnsa->answerlen + 1);
	110	s = memcpy(buf, s, dnsa->answerlen + 1);
	111	break;
	112	}
b8e97684	113	}
4a3709fb	114	DEBUG(D_receive) debug_printf("SPF_dns_exim_lookup '%s'\n", s);
b8e97684 JH	115	srr.rr = (void *) &s;
	116
	117	/* spfrr->rr must have been malloc()d for this */
	118	SPF_dns_rr_dup(&spfrr, &srr);
	119
	120	return spfrr;
	121	}
	122
	123	SPF_dns_rr_dup(&spfrr, spf_nxdomain);
	124	return spfrr;
	125	}
	126
	127
	128
	129	SPF_dns_server_t *
	130	SPF_dns_exim_new(int debug)
	131	{
	132	SPF_dns_server_t *spf_dns_server;
	133
	134	DEBUG(D_receive) debug_printf("SPF_dns_exim_new\n");
	135
	136	if (!(spf_dns_server = malloc(sizeof(SPF_dns_server_t))))
	137	return NULL;
	138	memset(spf_dns_server, 0, sizeof(SPF_dns_server_t));
	139
	140	spf_dns_server->destroy = NULL;
	141	spf_dns_server->lookup = SPF_dns_exim_lookup;
	142	spf_dns_server->get_spf = NULL;
	143	spf_dns_server->get_exp = NULL;
	144	spf_dns_server->add_cache = NULL;
	145	spf_dns_server->layer_below = NULL;
	146	spf_dns_server->name = "exim";
	147	spf_dns_server->debug = debug;
	148
	149	/* XXX This might have to return NO_DATA sometimes. */
	150
	151	spf_nxdomain = SPF_dns_rr_new_init(spf_dns_server,
	152	"", ns_t_any, 24 * 60 * 60, HOST_NOT_FOUND);
	153	if (!spf_nxdomain)
	154	{
	155	free(spf_dns_server);
	156	return NULL;
	157	}
	158
	159	return spf_dns_server;
	160	}
	161
	162
eb52e2cb	163
8e669ac1	164
73ec116f JH	165	/* Construct the SPF library stack.
	166	Return: Boolean success.
	167	*/
8e669ac1	168
eb52e2cb	169	BOOL
73ec116f	170	spf_init(void)
eb52e2cb	171	{
b8e97684	172	SPF_dns_server_t * dc;
73ec116f	173	int debug = 0;
b8e97684	174
73ec116f	175	DEBUG(D_receive) debug = 1;
b8e97684 JH	176
	177	/* We insert our own DNS access layer rather than letting the spf library
	178	do it, so that our dns access path is used for debug tracing and for the
	179	testsuite. */
8e669ac1	180
b8e97684 JH	181	if (!(dc = SPF_dns_exim_new(debug)))
	182	{
	183	DEBUG(D_receive) debug_printf("spf: SPF_dns_exim_new() failed\n");
	184	return FALSE;
	185	}
	186	if (!(dc = SPF_dns_cache_new(dc, NULL, debug, 8)))
	187	{
	188	DEBUG(D_receive) debug_printf("spf: SPF_dns_cache_new() failed\n");
	189	return FALSE;
	190	}
	191	if (!(spf_server = SPF_server_new_dns(dc, debug)))
eb52e2cb JH	192	{
	193	DEBUG(D_receive) debug_printf("spf: SPF_server_new() failed.\n");
	194	return FALSE;
8523533c	195	}
05e4f4de HSHR	196	/* Quick hack to override the outdated explanation URL.
	197	See https://www.mail-archive.com/mailop@mailop.org/msg08019.html */
	198	SPF_server_set_explanation(spf_server, "Please%_see%_http://www.open-spf.org/Why?id=%{S}&ip=%{C}&receiver=%{R}", &spf_response);
	199	if (SPF_response_errcode(spf_response) != SPF_E_SUCCESS)
	200	log_write(0, LOG_MAIN\|LOG_PANIC_DIE, "%s", SPF_strerror(SPF_response_errcode(spf_response)));
	201
73ec116f JH	202	return TRUE;
	203	}
	204
	205
	206	/* Set up a context that can be re-used for several
	207	messages on the same SMTP connection (that come from the
	208	same host with the same HELO string).
	209
	210	Return: Boolean success
	211	*/
	212
	213	BOOL
	214	spf_conn_init(uschar * spf_helo_domain, uschar * spf_remote_addr)
	215	{
	216	DEBUG(D_receive)
	217	debug_printf("spf_conn_init: %s %s\n", spf_helo_domain, spf_remote_addr);
	218
	219	if (!spf_server && !spf_init()) return FALSE;
8523533c	220
eb52e2cb JH	221	if (SPF_server_set_rec_dom(spf_server, CS primary_hostname))
	222	{
	223	DEBUG(D_receive) debug_printf("spf: SPF_server_set_rec_dom(\"%s\") failed.\n",
	224	primary_hostname);
	225	spf_server = NULL;
	226	return FALSE;
7b3a77e5 TK	227	}
7b3a77e5 TK	228
eb52e2cb JH	229	spf_request = SPF_request_new(spf_server);
	230
	231	if ( SPF_request_set_ipv4_str(spf_request, CS spf_remote_addr)
	232	&& SPF_request_set_ipv6_str(spf_request, CS spf_remote_addr)
	233	)
	234	{
	235	DEBUG(D_receive)
	236	debug_printf("spf: SPF_request_set_ipv4_str() and "
	237	"SPF_request_set_ipv6_str() failed [%s]\n", spf_remote_addr);
	238	spf_server = NULL;
	239	spf_request = NULL;
	240	return FALSE;
8523533c TK	241	}
8523533c TK	242
eb52e2cb JH	243	if (SPF_request_set_helo_dom(spf_request, CS spf_helo_domain))
	244	{
	245	DEBUG(D_receive) debug_printf("spf: SPF_set_helo_dom(\"%s\") failed.\n",
	246	spf_helo_domain);
	247	spf_server = NULL;
	248	spf_request = NULL;
	249	return FALSE;
8523533c	250	}
8e669ac1	251
eb52e2cb	252	return TRUE;
8523533c TK	253	}
	254
	255
	256	/* spf_process adds the envelope sender address to the existing
	257	context (if any), retrieves the result, sets up expansion
eb52e2cb	258	strings and evaluates the condition outcome.
f9ba5e22	259
eb52e2cb JH	260	Return: OK/FAIL */
	261
	262	int
	263	spf_process(const uschar *listptr, uschar spf_envelope_sender, int action)
	264	{
	265	int sep = 0;
	266	const uschar list = listptr;
	267	uschar *spf_result_id;
	268	int rc = SPF_RESULT_PERMERROR;
	269
b8e97684 JH	270	DEBUG(D_receive) debug_printf("spf_process\n");
b8e97684 JH	271
eb52e2cb JH	272	if (!(spf_server && spf_request))
	273	/* no global context, assume temp error and skip to evaluation */
	274	rc = SPF_RESULT_PERMERROR;
	275
	276	else if (SPF_request_set_env_from(spf_request, CS spf_envelope_sender))
aded2255	277	/* Invalid sender address. This should be a real rare occurrence */
eb52e2cb JH	278	rc = SPF_RESULT_PERMERROR;
	279
	280	else
	281	{
8523533c	282	/* get SPF result */
65a7d8c3	283	if (action == SPF_PROCESS_FALLBACK)
87e9d061	284	{
7156b1ef	285	SPF_request_query_fallback(spf_request, &spf_response, CS spf_guess);
87e9d061 JH	286	spf_result_guessed = TRUE;
87e9d061 JH	287	}
65a7d8c3 NM	288	else
65a7d8c3 NM	289	SPF_request_query_mailfrom(spf_request, &spf_response);
8523533c TK	290
8523533c TK	291	/* set up expansion items */
5903c6ff JH	292	spf_header_comment = US SPF_response_get_header_comment(spf_response);
	293	spf_received = US SPF_response_get_received_spf(spf_response);
	294	spf_result = US SPF_strresult(SPF_response_result(spf_response));
	295	spf_smtp_comment = US SPF_response_get_smtp_comment(spf_response);
8523533c	296
384152a6	297	rc = SPF_response_result(spf_response);
eb52e2cb JH	298	}
	299
	300	/* We got a result. Now see if we should return OK or FAIL for it */
	301	DEBUG(D_acl) debug_printf("SPF result is %s (%d)\n", SPF_strresult(rc), rc);
	302
	303	if (action == SPF_PROCESS_GUESS && (!strcmp (SPF_strresult(rc), "none")))
	304	return spf_process(listptr, spf_envelope_sender, SPF_PROCESS_FALLBACK);
	305
	306	while ((spf_result_id = string_nextinlist(&list, &sep, NULL, 0)))
	307	{
	308	BOOL negate, result;
	309
	310	if ((negate = spf_result_id[0] == '!'))
	311	spf_result_id++;
	312
	313	result = Ustrcmp(spf_result_id, spf_result_id_list[rc].name) == 0;
	314	if (negate != result) return OK;
	315	}
8523533c	316
eb52e2cb JH	317	/* no match */
eb52e2cb JH	318	return FAIL;
8523533c TK	319	}
8523533c TK	320
dfbcb5ac JH	321
	322
	323	gstring *
	324	authres_spf(gstring * g)
	325	{
87e9d061	326	uschar * s;
dfbcb5ac JH	327	if (!spf_result) return g;
dfbcb5ac JH	328
87e9d061 JH	329	g = string_append(g, 2, US";\n\tspf=", spf_result);
	330	if (spf_result_guessed)
	331	g = string_cat(g, US" (best guess record for domain)");
	332
	333	s = expand_string(US"$sender_address_domain");
	334	return s && *s
	335	? string_append(g, 2, US" smtp.mailfrom=", s)
	336	: string_cat(g, US" smtp.mailfrom=<>");
dfbcb5ac JH	337	}
	338
	339
8523533c	340	#endif