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

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

/* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003 - 2015
 * License: GPL
 * Copyright (c) The Exim Maintainers 2016 - 2018
 */

/* Code for calling spamassassin's spamd. Called from acl.c. */

#include "exim.h"
#ifdef WITH_CONTENT_SCAN
#include "spam.h"

uschar spam_score_buffer[16];
uschar spam_score_int_buffer[16];
uschar spam_bar_buffer[128];
uschar * spam_action_buffer;
uschar spam_report_buffer[32600];
uschar prev_user_name[128] = "";
int spam_ok = 0;
int spam_rc = 0;
uschar *prev_spamd_address_work = NULL;

static const uschar * loglabel = US"spam acl condition:";


static int
spamd_param_init(spamd_address_container *spamd)
{
/* default spamd server weight, time and priority value */
spamd->is_failed = FALSE;
spamd->weight = SPAMD_WEIGHT;
spamd->timeout = SPAMD_TIMEOUT;
spamd->retry = 0;
spamd->priority = 1;
return 0;
}


static int
spamd_param(const uschar * param, spamd_address_container * spamd)
{
static int timesinceday = -1;
const uschar * s;
const uschar * name;

/*XXX more clever parsing could discard embedded spaces? */

if (sscanf(CCS param, "pri=%u", &spamd->priority))
  return 0; /* OK */

if (sscanf(CCS param, "weight=%u", &spamd->weight))
  {
  if (spamd->weight == 0) /* this server disabled: skip it */
    return 1;
  return 0; /* OK */
  }

if (Ustrncmp(param, "time=", 5) == 0)
  {
  unsigned int start_h = 0, start_m = 0, start_s = 0;
  unsigned int end_h = 24, end_m = 0, end_s = 0;
  unsigned int time_start, time_end;
  const uschar * end_string;

  name = US"time";
  s = param+5;
  if ((end_string = Ustrchr(s, '-')))
    {
    end_string++;
    if (  sscanf(CS end_string, "%u.%u.%u", &end_h,   &end_m,   &end_s)   == 0
       || sscanf(CS s,          "%u.%u.%u", &start_h, &start_m, &start_s) == 0
       )
      goto badval;
    }
  else
    goto badval;

  if (timesinceday < 0)
    {
    time_t now = time(NULL);
    struct tm *tmp = localtime(&now);
    timesinceday = tmp->tm_hour*3600 + tmp->tm_min*60 + tmp->tm_sec;
    }

  time_start = start_h*3600 + start_m*60 + start_s;
  time_end = end_h*3600 + end_m*60 + end_s;

  if (timesinceday < time_start || timesinceday >= time_end)
    return 1; /* skip spamd server */

  return 0; /* OK */
  }

if (Ustrncmp(param, "tmo=", 4) == 0)
  {
  int sec = readconf_readtime((s = param+4), '\0', FALSE);
  name = US"timeout";
  if (sec < 0)
    goto badval;
  spamd->timeout = sec;
  return 0;
  }

if (Ustrncmp(param, "retry=", 6) == 0)
  {
  int sec = readconf_readtime((s = param+6), '\0', FALSE);
  name = US"retry";
  if (sec < 0)
    goto badval;
  spamd->retry = sec;
  return 0;
  }

log_write(0, LOG_MAIN, "%s warning - invalid spamd parameter: '%s'",
  loglabel, param);
return -1; /* syntax error */

badval:
  log_write(0, LOG_MAIN,
    "%s warning - invalid spamd %s value: '%s'", loglabel, name, s);
  return -1; /* syntax error */
}


static int
spamd_get_server(spamd_address_container ** spamds, int num_servers)
{
unsigned int i;
spamd_address_container * sd;
long rnd, weights;
unsigned pri;
static BOOL srandomed = FALSE;

/* speedup, if we have only 1 server */
if (num_servers == 1)
  return (spamds[0]->is_failed ? -1 : 0);

/* init ranmod */
if (!srandomed)
  {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  srandom((unsigned int)(tv.tv_usec/1000));
  srandomed = TRUE;
  }

/* scan for highest pri */
for (pri = 0, i = 0; i < num_servers; i++)
  {
  sd = spamds[i];
  if (!sd->is_failed && sd->priority > pri) pri = sd->priority;
  }

/* get sum of weights */
for (weights = 0, i = 0; i < num_servers; i++)
  {
  sd = spamds[i];
  if (!sd->is_failed && sd->priority == pri) weights += sd->weight;
  }
if (weights == 0)	/* all servers failed */
  return -1;

for (rnd = random() % weights, i = 0; i < num_servers; i++)
  {
  sd = spamds[i];
  if (!sd->is_failed && sd->priority == pri)
    if ((rnd -= sd->weight) <= 0)
      return i;
  }

log_write(0, LOG_MAIN|LOG_PANIC,
  "%s unknown error (memory/cpu corruption?)", loglabel);
return -1;
}


int
spam(const uschar **listptr)
{
int sep = 0;
const uschar *list = *listptr;
uschar *user_name;
uschar user_name_buffer[128];
unsigned long mbox_size;
FILE *mbox_file;
client_conn_ctx spamd_cctx = {.sock = -1};
uschar spamd_buffer[32600];
int i, j, offset, result;
uschar spamd_version[8];
uschar spamd_short_result[8];
uschar spamd_score_char;
double spamd_threshold, spamd_score, spamd_reject_score;
int spamd_report_offset;
uschar *p,*q;
int override = 0;
time_t start;
size_t read, wrote;
#ifndef NO_POLL_H
struct pollfd pollfd;
#else                               /* Patch posted by Erik ? for OS X */
struct timeval select_tv;         /* and applied by PH */
fd_set select_fd;
#endif
uschar *spamd_address_work;
spamd_address_container * sd;

/* stop compiler warning */
result = 0;

/* find the username from the option list */
if ((user_name = string_nextinlist(&list, &sep,
				   user_name_buffer,
				   sizeof(user_name_buffer))) == NULL)
  {
  /* no username given, this means no scanning should be done */
  return FAIL;
  }

/* if username is "0" or "false", do not scan */
if ( (Ustrcmp(user_name,"0") == 0) ||
     (strcmpic(user_name,US"false") == 0) )
  return FAIL;

/* if there is an additional option, check if it is "true" */
if (strcmpic(list,US"true") == 0)
  /* in that case, always return true later */
  override = 1;

/* expand spamd_address if needed */
if (*spamd_address == '$')
  {
  spamd_address_work = expand_string(spamd_address);
  if (spamd_address_work == NULL)
    {
    log_write(0, LOG_MAIN|LOG_PANIC,
      "%s spamd_address starts with $, but expansion failed: %s",
      loglabel, expand_string_message);
    return DEFER;
    }
  }
else
  spamd_address_work = spamd_address;

DEBUG(D_acl) debug_printf_indent("spamd: addrlist '%s'\n", spamd_address_work);

/* check if previous spamd_address was expanded and has changed. dump cached results if so */
if (  spam_ok
   && prev_spamd_address_work != NULL
   && Ustrcmp(prev_spamd_address_work, spamd_address_work) != 0
   )
  spam_ok = 0;

/* if we scanned for this username last time, just return */
if (spam_ok && Ustrcmp(prev_user_name, user_name) == 0)
  return override ? OK : spam_rc;

/* make sure the eml mbox file is spooled up */

if (!(mbox_file = spool_mbox(&mbox_size, NULL, NULL)))
  {								/* error while spooling */
  log_write(0, LOG_MAIN|LOG_PANIC,
	 "%s error while creating mbox spool file", loglabel);
  return DEFER;
  }

start = time(NULL);

  {
  int num_servers = 0;
  int current_server;
  uschar * address;
  const uschar * spamd_address_list_ptr = spamd_address_work;
  spamd_address_container * spamd_address_vector[32];

  /* Check how many spamd servers we have
     and register their addresses */
  sep = 0;				/* default colon-sep */
  while ((address = string_nextinlist(&spamd_address_list_ptr, &sep, NULL, 0)))
    {
    const uschar * sublist;
    int sublist_sep = -(int)' ';	/* default space-sep */
    unsigned args;
    uschar * s;

    DEBUG(D_acl) debug_printf_indent("spamd: addr entry '%s'\n", address);
    sd = (spamd_address_container *)store_get(sizeof(spamd_address_container));

    for (sublist = address, args = 0, spamd_param_init(sd);
	 (s = string_nextinlist(&sublist, &sublist_sep, NULL, 0));
	 args++
	 )
      {
	DEBUG(D_acl) debug_printf_indent("spamd:  addr parm '%s'\n", s);
	switch (args)
	{
	case 0:   sd->hostspec = s;
		  if (*s == '/') args++;	/* local; no port */
		  break;
	case 1:   sd->hostspec = string_sprintf("%s %s", sd->hostspec, s);
		  break;
	default:  spamd_param(s, sd);
		  break;
	}
      }
    if (args < 2)
      {
      log_write(0, LOG_MAIN,
	"%s warning - invalid spamd address: '%s'", loglabel, address);
      continue;
      }

    spamd_address_vector[num_servers] = sd;
    if (++num_servers > 31)
      break;
    }

  /* check if we have at least one server */
  if (!num_servers)
    {
    log_write(0, LOG_MAIN|LOG_PANIC,
       "%s no useable spamd server addresses in spamd_address configuration option.",
       loglabel);
    goto defer;
    }

  current_server = spamd_get_server(spamd_address_vector, num_servers);
  sd = spamd_address_vector[current_server];
  for(;;)
    {
    uschar * errstr;

    DEBUG(D_acl) debug_printf_indent("spamd: trying server %s\n", sd->hostspec);

    for (;;)
      {
      /*XXX could potentially use TFO early-data here */
      if (  (spamd_cctx.sock = ip_streamsocket(sd->hostspec, &errstr, 5)) >= 0
         || sd->retry <= 0
	 )
	break;
      DEBUG(D_acl) debug_printf_indent("spamd: server %s: retry conn\n", sd->hostspec);
      while (sd->retry > 0) sd->retry = sleep(sd->retry);
      }
    if (spamd_cctx.sock >= 0)
      break;

    log_write(0, LOG_MAIN, "%s spamd: %s", loglabel, errstr);
    sd->is_failed = TRUE;

    current_server = spamd_get_server(spamd_address_vector, num_servers);
    if (current_server < 0)
      {
      log_write(0, LOG_MAIN|LOG_PANIC, "%s all spamd servers failed", loglabel);
      goto defer;
      }
    sd = spamd_address_vector[current_server];
    }
  }

(void)fcntl(spamd_cctx.sock, F_SETFL, O_NONBLOCK);
/* now we are connected to spamd on spamd_sock */

(void)string_format(spamd_buffer,
	sizeof(spamd_buffer),
	"REPORT SPAMC/1.2\r\nUser: %s\r\nContent-length: %ld\r\n\r\n",
	user_name,
	mbox_size);
/* send our request */
wrote = send(spamd_cctx.sock, spamd_buffer, Ustrlen(spamd_buffer), 0);

if (wrote == -1)
  {
  (void)close(spamd_cctx.sock);
  log_write(0, LOG_MAIN|LOG_PANIC,
       "%s spamd %s send failed: %s", loglabel, callout_address, strerror(errno));
  goto defer;
  }

/* now send the file */
/* spamd sometimes accepts connections but doesn't read data off
 * the connection.  We make the file descriptor non-blocking so
 * that the write will only write sufficient data without blocking
 * and we poll the descriptor to make sure that we can write without
 * blocking.  Short writes are gracefully handled and if the whole
 * transaction takes too long it is aborted.
 * Note: poll() is not supported in OSX 10.2 and is reported to be
 *       broken in more recent versions (up to 10.4).
 */
#ifndef NO_POLL_H
pollfd.fd = spamd_cctx.sock;
pollfd.events = POLLOUT;
#endif
do
  {
  read = fread(spamd_buffer,1,sizeof(spamd_buffer),mbox_file);
  if (read > 0)
    {
    offset = 0;
again:
#ifndef NO_POLL_H
    result = poll(&pollfd, 1, 1000);

/* Patch posted by Erik ? for OS X and applied by PH */
#else
    select_tv.tv_sec = 1;
    select_tv.tv_usec = 0;
    FD_ZERO(&select_fd);
    FD_SET(spamd_cctx.sock, &select_fd);
    result = select(spamd_cctx.sock+1, NULL, &select_fd, NULL, &select_tv);
#endif
/* End Erik's patch */

    if (result == -1 && errno == EINTR)
      goto again;
    else if (result < 1)
      {
      if (result == -1)
	log_write(0, LOG_MAIN|LOG_PANIC,
	  "%s %s on spamd %s socket", loglabel, callout_address, strerror(errno));
      else
	{
	if (time(NULL) - start < sd->timeout)
	  goto again;
	log_write(0, LOG_MAIN|LOG_PANIC,
	  "%s timed out writing spamd %s, socket", loglabel, callout_address);
	}
      (void)close(spamd_cctx.sock);
      goto defer;
      }

    wrote = send(spamd_cctx.sock,spamd_buffer + offset,read - offset,0);
    if (wrote == -1)
      {
      log_write(0, LOG_MAIN|LOG_PANIC,
	  "%s %s on spamd %s socket", loglabel, callout_address, strerror(errno));
      (void)close(spamd_cctx.sock);
      goto defer;
      }
    if (offset + wrote != read)
      {
      offset += wrote;
      goto again;
      }
    }
  }
while (!feof(mbox_file) && !ferror(mbox_file));

if (ferror(mbox_file))
  {
  log_write(0, LOG_MAIN|LOG_PANIC,
    "%s error reading spool file: %s", loglabel, strerror(errno));
  (void)close(spamd_cctx.sock);
  goto defer;
  }

(void)fclose(mbox_file);

/* we're done sending, close socket for writing */
shutdown(spamd_cctx.sock, SHUT_WR);

/* read spamd response using what's left of the timeout.  */
memset(spamd_buffer, 0, sizeof(spamd_buffer));
offset = 0;
while ((i = ip_recv(&spamd_cctx,
		   spamd_buffer + offset,
		   sizeof(spamd_buffer) - offset - 1,
		   sd->timeout - time(NULL) + start)) > 0)
  offset += i;
spamd_buffer[offset] = '\0';	/* guard byte */

/* error handling */
if (i <= 0 && errno != 0)
  {
  log_write(0, LOG_MAIN|LOG_PANIC,
       "%s error reading from spamd %s, socket: %s", loglabel, callout_address, strerror(errno));
  (void)close(spamd_cctx.sock);
  return DEFER;
  }

/* reading done */
(void)close(spamd_cctx.sock);

  {				/* spamassassin */
  /* dig in the spamd output and put the report in a multiline header,
  if requested */
  if (sscanf(CS spamd_buffer,
       "SPAMD/%7s 0 EX_OK\r\nContent-length: %*u\r\n\r\n%lf/%lf\r\n%n",
       spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3)
    {
      /* try to fall back to pre-2.50 spamd output */
      if (sscanf(CS spamd_buffer,
	   "SPAMD/%7s 0 EX_OK\r\nSpam: %*s ; %lf / %lf\r\n\r\n%n",
	   spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3)
	{
	log_write(0, LOG_MAIN|LOG_PANIC,
		  "%s cannot parse spamd %s output", loglabel, callout_address);
	return DEFER;
	}
    }

  spam_action_buffer = spamd_score >= spamd_threshold ? US"reject" : US"no action";
  }

/* Create report. Since this is a multiline string,
we must hack it into shape first */
p = &spamd_buffer[spamd_report_offset];
q = spam_report_buffer;
while (*p != '\0')
  {
  /* skip \r */
  if (*p == '\r')
    {
    p++;
    continue;
    }
  *q++ = *p;
  if (*p++ == '\n')
    {
    /* add an extra space after the newline to ensure
    that it is treated as a header continuation line */
    *q++ = ' ';
    }
  }
/* NULL-terminate */
*q-- = '\0';
/* cut off trailing leftovers */
while (*q <= ' ')
  *q-- = '\0';

spam_report = spam_report_buffer;
spam_action = spam_action_buffer;

/* create spam bar */
spamd_score_char = spamd_score > 0 ? '+' : '-';
j = abs((int)(spamd_score));
i = 0;
if (j != 0)
  while ((i < j) && (i <= MAX_SPAM_BAR_CHARS))
     spam_bar_buffer[i++] = spamd_score_char;
else
  {
  spam_bar_buffer[0] = '/';
  i = 1;
  }
spam_bar_buffer[i] = '\0';
spam_bar = spam_bar_buffer;

/* create "float" spam score */
(void)string_format(spam_score_buffer, sizeof(spam_score_buffer),
	"%.1f", spamd_score);
spam_score = spam_score_buffer;

/* create "int" spam score */
j = (int)((spamd_score + 0.001)*10);
(void)string_format(spam_score_int_buffer, sizeof(spam_score_int_buffer),
	"%d", j);
spam_score_int = spam_score_int_buffer;

/* compare threshold against score */
spam_rc = spamd_score >= spamd_threshold
  ? OK	/* spam as determined by user's threshold */
  : FAIL;	/* not spam */

/* remember expanded spamd_address if needed */
if (spamd_address_work != spamd_address)
  prev_spamd_address_work = string_copy(spamd_address_work);

/* remember user name and "been here" for it */
Ustrcpy(prev_user_name, user_name);
spam_ok = 1;

return override
  ? OK		/* always return OK, no matter what the score */
  : spam_rc;

defer:
  (void)fclose(mbox_file);
  return DEFER;
}

#endif
/* vi: aw ai sw=2
*/
Commit	Line	Data
8523533c TK	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
	4
80fea873 JH	5	/* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003 - 2015
80fea873 JH	6	* License: GPL
f9ba5e22	7	* Copyright (c) The Exim Maintainers 2016 - 2018
80fea873	8	*/
8523533c TK	9
	10	/* Code for calling spamassassin's spamd. Called from acl.c. */
	11
	12	#include "exim.h"
	13	#ifdef WITH_CONTENT_SCAN
	14	#include "spam.h"
	15
	16	uschar spam_score_buffer[16];
	17	uschar spam_score_int_buffer[16];
	18	uschar spam_bar_buffer[128];
dd998666	19	uschar * spam_action_buffer;
8523533c TK	20	uschar spam_report_buffer[32600];
	21	uschar prev_user_name[128] = "";
	22	int spam_ok = 0;
	23	int spam_rc = 0;
f7274286	24	uschar *prev_spamd_address_work = NULL;
8523533c	25
fd4d8871	26	static const uschar * loglabel = US"spam acl condition:";
8523533c	27
23763898	28
fd4d8871 R	29	static int
	30	spamd_param_init(spamd_address_container *spamd)
	31	{
dc7b3d36	32	/* default spamd server weight, time and priority value */
fd4d8871	33	spamd->is_failed = FALSE;
8a512ed5 JH	34	spamd->weight = SPAMD_WEIGHT;
	35	spamd->timeout = SPAMD_TIMEOUT;
	36	spamd->retry = 0;
dc7b3d36	37	spamd->priority = 1;
fd4d8871 R	38	return 0;
fd4d8871 R	39	}
8523533c	40
8523533c	41
fd4d8871	42	static int
fc362fc5	43	spamd_param(const uschar * param, spamd_address_container * spamd)
fd4d8871 R	44	{
fd4d8871 R	45	static int timesinceday = -1;
23763898	46	const uschar * s;
8a512ed5	47	const uschar * name;
fd4d8871	48
fd4d8871 R	49	/XXX more clever parsing could discard embedded spaces? /
fd4d8871 R	50
fc362fc5	51	if (sscanf(CCS param, "pri=%u", &spamd->priority))
dc7b3d36 JH	52	return 0; /* OK */
dc7b3d36 JH	53
fc362fc5	54	if (sscanf(CCS param, "weight=%u", &spamd->weight))
fd4d8871 R	55	{
	56	if (spamd->weight == 0) /* this server disabled: skip it */
	57	return 1;
	58	return 0; /* OK */
	59	}
	60
23763898	61	if (Ustrncmp(param, "time=", 5) == 0)
fd4d8871 R	62	{
	63	unsigned int start_h = 0, start_m = 0, start_s = 0;
	64	unsigned int end_h = 24, end_m = 0, end_s = 0;
	65	unsigned int time_start, time_end;
23763898	66	const uschar * end_string;
fd4d8871	67
8a512ed5	68	name = US"time";
23763898 JH	69	s = param+5;
23763898 JH	70	if ((end_string = Ustrchr(s, '-')))
ddcf2b5f	71	{
23763898 JH	72	end_string++;
	73	if ( sscanf(CS end_string, "%u.%u.%u", &end_h, &end_m, &end_s) == 0
	74	\|\| sscanf(CS s, "%u.%u.%u", &start_h, &start_m, &start_s) == 0
	75	)
8a512ed5	76	goto badval;
f7274286	77	}
f7274286	78	else
8a512ed5	79	goto badval;
8523533c	80
fd4d8871	81	if (timesinceday < 0)
ddcf2b5f	82	{
fd4d8871 R	83	time_t now = time(NULL);
	84	struct tm *tmp = localtime(&now);
	85	timesinceday = tmp->tm_hour3600 + tmp->tm_min60 + tmp->tm_sec;
	86	}
8e669ac1	87
fd4d8871 R	88	time_start = start_h3600 + start_m60 + start_s;
fd4d8871 R	89	time_end = end_h3600 + end_m60 + end_s;
8e669ac1	90
fd4d8871 R	91	if (timesinceday < time_start \|\| timesinceday >= time_end)
fd4d8871 R	92	return 1; /* skip spamd server */
c5f280e2	93
fd4d8871 R	94	return 0; /* OK */
fd4d8871 R	95	}
8e669ac1	96
23763898 JH	97	if (Ustrncmp(param, "tmo=", 4) == 0)
	98	{
	99	int sec = readconf_readtime((s = param+4), '\0', FALSE);
8a512ed5	100	name = US"timeout";
23763898	101	if (sec < 0)
8a512ed5 JH	102	goto badval;
	103	spamd->timeout = sec;
	104	return 0;
	105	}
	106
	107	if (Ustrncmp(param, "retry=", 6) == 0)
	108	{
	109	int sec = readconf_readtime((s = param+6), '\0', FALSE);
	110	name = US"retry";
	111	if (sec < 0)
	112	goto badval;
	113	spamd->retry = sec;
23763898 JH	114	return 0;
	115	}
	116
fd4d8871 R	117	log_write(0, LOG_MAIN, "%s warning - invalid spamd parameter: '%s'",
	118	loglabel, param);
	119	return -1; /* syntax error */
8a512ed5 JH	120
	121	badval:
	122	log_write(0, LOG_MAIN,
	123	"%s warning - invalid spamd %s value: '%s'", loglabel, name, s);
	124	return -1; /* syntax error */
fd4d8871	125	}
8523533c	126
8523533c	127
fd4d8871	128	static int
dc7b3d36	129	spamd_get_server(spamd_address_container ** spamds, int num_servers)
fd4d8871 R	130	{
fd4d8871 R	131	unsigned int i;
dc7b3d36 JH	132	spamd_address_container * sd;
	133	long rnd, weights;
	134	unsigned pri;
	135	static BOOL srandomed = FALSE;
fd4d8871	136
806c3df9	137	/* speedup, if we have only 1 server */
dc7b3d36 JH	138	if (num_servers == 1)
dc7b3d36 JH	139	return (spamds[0]->is_failed ? -1 : 0);
8e669ac1	140
dc7b3d36 JH	141	/* init ranmod */
	142	if (!srandomed)
	143	{
	144	struct timeval tv;
	145	gettimeofday(&tv, NULL);
	146	srandom((unsigned int)(tv.tv_usec/1000));
	147	srandomed = TRUE;
	148	}
8e669ac1	149
dc7b3d36 JH	150	/* scan for highest pri */
	151	for (pri = 0, i = 0; i < num_servers; i++)
	152	{
	153	sd = spamds[i];
	154	if (!sd->is_failed && sd->priority > pri) pri = sd->priority;
fd4d8871	155	}
8e669ac1	156
dc7b3d36 JH	157	/* get sum of weights */
	158	for (weights = 0, i = 0; i < num_servers; i++)
	159	{
	160	sd = spamds[i];
	161	if (!sd->is_failed && sd->priority == pri) weights += sd->weight;
	162	}
	163	if (weights == 0) /* all servers failed */
	164	return -1;
8e669ac1	165
dc7b3d36 JH	166	for (rnd = random() % weights, i = 0; i < num_servers; i++)
	167	{
	168	sd = spamds[i];
	169	if (!sd->is_failed && sd->priority == pri)
	170	if ((rnd -= sd->weight) <= 0)
fd4d8871	171	return i;
dc7b3d36	172	}
29cfeb94	173
fd4d8871 R	174	log_write(0, LOG_MAIN\|LOG_PANIC,
	175	"%s unknown error (memory/cpu corruption?)", loglabel);
	176	return -1;
	177	}
29cfeb94	178
29cfeb94	179
fd4d8871	180	int
55414b25	181	spam(const uschar **listptr)
fd4d8871 R	182	{
fd4d8871 R	183	int sep = 0;
55414b25	184	const uschar list = listptr;
fd4d8871 R	185	uschar *user_name;
	186	uschar user_name_buffer[128];
	187	unsigned long mbox_size;
	188	FILE *mbox_file;
74f1a423	189	client_conn_ctx spamd_cctx = {.sock = -1};
fd4d8871 R	190	uschar spamd_buffer[32600];
fd4d8871 R	191	int i, j, offset, result;
fd4d8871 R	192	uschar spamd_version[8];
	193	uschar spamd_short_result[8];
	194	uschar spamd_score_char;
	195	double spamd_threshold, spamd_score, spamd_reject_score;
	196	int spamd_report_offset;
	197	uschar p,q;
	198	int override = 0;
	199	time_t start;
	200	size_t read, wrote;
fd4d8871 R	201	#ifndef NO_POLL_H
	202	struct pollfd pollfd;
	203	#else /* Patch posted by Erik ? for OS X */
	204	struct timeval select_tv; /* and applied by PH */
	205	fd_set select_fd;
	206	#endif
	207	uschar *spamd_address_work;
8a512ed5	208	spamd_address_container * sd;
fd4d8871 R	209
	210	/* stop compiler warning */
	211	result = 0;
	212
	213	/* find the username from the option list */
	214	if ((user_name = string_nextinlist(&list, &sep,
	215	user_name_buffer,
	216	sizeof(user_name_buffer))) == NULL)
	217	{
	218	/* no username given, this means no scanning should be done */
	219	return FAIL;
	220	}
	221
	222	/* if username is "0" or "false", do not scan */
	223	if ( (Ustrcmp(user_name,"0") == 0) \|\|
	224	(strcmpic(user_name,US"false") == 0) )
	225	return FAIL;
	226
	227	/* if there is an additional option, check if it is "true" */
	228	if (strcmpic(list,US"true") == 0)
	229	/* in that case, always return true later */
	230	override = 1;
	231
	232	/* expand spamd_address if needed */
	233	if (*spamd_address == '$')
	234	{
	235	spamd_address_work = expand_string(spamd_address);
	236	if (spamd_address_work == NULL)
	237	{
	238	log_write(0, LOG_MAIN\|LOG_PANIC,
	239	"%s spamd_address starts with $, but expansion failed: %s",
	240	loglabel, expand_string_message);
	241	return DEFER;
29cfeb94	242	}
fd4d8871 R	243	}
	244	else
	245	spamd_address_work = spamd_address;
	246
e1d04f48	247	DEBUG(D_acl) debug_printf_indent("spamd: addrlist '%s'\n", spamd_address_work);
fd4d8871 R	248
	249	/* check if previous spamd_address was expanded and has changed. dump cached results if so */
	250	if ( spam_ok
	251	&& prev_spamd_address_work != NULL
	252	&& Ustrcmp(prev_spamd_address_work, spamd_address_work) != 0
	253	)
	254	spam_ok = 0;
	255
	256	/* if we scanned for this username last time, just return */
	257	if (spam_ok && Ustrcmp(prev_user_name, user_name) == 0)
	258	return override ? OK : spam_rc;
	259
	260	/* make sure the eml mbox file is spooled up */
328c5688	261
040721f2	262	if (!(mbox_file = spool_mbox(&mbox_size, NULL, NULL)))
328c5688	263	{ /* error while spooling */
fd4d8871 R	264	log_write(0, LOG_MAIN\|LOG_PANIC,
	265	"%s error while creating mbox spool file", loglabel);
	266	return DEFER;
	267	}
	268
	269	start = time(NULL);
	270
	271	{
	272	int num_servers = 0;
	273	int current_server;
dc7b3d36 JH	274	uschar * address;
dc7b3d36 JH	275	const uschar * spamd_address_list_ptr = spamd_address_work;
fd4d8871	276	spamd_address_container * spamd_address_vector[32];
fd4d8871 R	277
	278	/* Check how many spamd servers we have
	279	and register their addresses */
dc7b3d36	280	sep = 0; /* default colon-sep */
040721f2	281	while ((address = string_nextinlist(&spamd_address_list_ptr, &sep, NULL, 0)))
ddcf2b5f	282	{
55414b25	283	const uschar * sublist;
fd4d8871 R	284	int sublist_sep = -(int)' '; /* default space-sep */
	285	unsigned args;
	286	uschar * s;
fd4d8871	287
e1d04f48	288	DEBUG(D_acl) debug_printf_indent("spamd: addr entry '%s'\n", address);
2aad5761	289	sd = (spamd_address_container *)store_get(sizeof(spamd_address_container));
fd4d8871	290
2aad5761	291	for (sublist = address, args = 0, spamd_param_init(sd);
755762fd	292	(s = string_nextinlist(&sublist, &sublist_sep, NULL, 0));
fd4d8871 R	293	args++
fd4d8871 R	294	)
ddcf2b5f	295	{
e1d04f48	296	DEBUG(D_acl) debug_printf_indent("spamd: addr parm '%s'\n", s);
fd4d8871 R	297	switch (args)
fd4d8871 R	298	{
2aad5761	299	case 0: sd->hostspec = s;
fd4d8871 R	300	if (s == '/') args++; / local; no port */
fd4d8871 R	301	break;
2aad5761 JH	302	case 1: sd->hostspec = string_sprintf("%s %s", sd->hostspec, s);
	303	break;
	304	default: spamd_param(s, sd);
	305	break;
fd4d8871	306	}
ddcf2b5f	307	}
fd4d8871	308	if (args < 2)
c5f280e2	309	{
fd4d8871 R	310	log_write(0, LOG_MAIN,
	311	"%s warning - invalid spamd address: '%s'", loglabel, address);
	312	continue;
c5f280e2	313	}
8523533c	314
2aad5761	315	spamd_address_vector[num_servers] = sd;
fd4d8871 R	316	if (++num_servers > 31)
fd4d8871 R	317	break;
8523533c TK	318	}
8523533c TK	319
fd4d8871 R	320	/* check if we have at least one server */
fd4d8871 R	321	if (!num_servers)
ddcf2b5f	322	{
0f501486	323	log_write(0, LOG_MAIN\|LOG_PANIC,
fd4d8871 R	324	"%s no useable spamd server addresses in spamd_address configuration option.",
fd4d8871 R	325	loglabel);
8acbb134	326	goto defer;
ddcf2b5f	327	}
0f501486	328
8a512ed5 JH	329	current_server = spamd_get_server(spamd_address_vector, num_servers);
	330	sd = spamd_address_vector[current_server];
	331	for(;;)
ddcf2b5f	332	{
2aad5761	333	uschar * errstr;
8523533c	334
e1d04f48	335	DEBUG(D_acl) debug_printf_indent("spamd: trying server %s\n", sd->hostspec);
fd4d8871	336
8a512ed5 JH	337	for (;;)
8a512ed5 JH	338	{
4a5cbaff	339	/XXX could potentially use TFO early-data here /
74f1a423	340	if ( (spamd_cctx.sock = ip_streamsocket(sd->hostspec, &errstr, 5)) >= 0
8a512ed5 JH	341	\|\| sd->retry <= 0
	342	)
	343	break;
e1d04f48	344	DEBUG(D_acl) debug_printf_indent("spamd: server %s: retry conn\n", sd->hostspec);
8a512ed5 JH	345	while (sd->retry > 0) sd->retry = sleep(sd->retry);
8a512ed5 JH	346	}
74f1a423	347	if (spamd_cctx.sock >= 0)
2aad5761	348	break;
25257489	349
2aad5761 JH	350	log_write(0, LOG_MAIN, "%s spamd: %s", loglabel, errstr);
2aad5761 JH	351	sd->is_failed = TRUE;
25257489	352
2aad5761 JH	353	current_server = spamd_get_server(spamd_address_vector, num_servers);
2aad5761 JH	354	if (current_server < 0)
fd4d8871	355	{
8a512ed5	356	log_write(0, LOG_MAIN\|LOG_PANIC, "%s all spamd servers failed", loglabel);
2aad5761	357	goto defer;
fd4d8871	358	}
8a512ed5	359	sd = spamd_address_vector[current_server];
ddcf2b5f	360	}
fd4d8871	361	}
8523533c	362
74f1a423	363	(void)fcntl(spamd_cctx.sock, F_SETFL, O_NONBLOCK);
dd998666 JH	364	/* now we are connected to spamd on spamd_sock */
	365
	366	(void)string_format(spamd_buffer,
	367	sizeof(spamd_buffer),
	368	"REPORT SPAMC/1.2\r\nUser: %s\r\nContent-length: %ld\r\n\r\n",
	369	user_name,
	370	mbox_size);
	371	/* send our request */
	372	wrote = send(spamd_cctx.sock, spamd_buffer, Ustrlen(spamd_buffer), 0);
	373
fd4d8871 R	374	if (wrote == -1)
fd4d8871 R	375	{
74f1a423	376	(void)close(spamd_cctx.sock);
fd4d8871	377	log_write(0, LOG_MAIN\|LOG_PANIC,
0ea02355	378	"%s spamd %s send failed: %s", loglabel, callout_address, strerror(errno));
8acbb134	379	goto defer;
fd4d8871 R	380	}
	381
	382	/* now send the file */
4c04137d	383	/* spamd sometimes accepts connections but doesn't read data off
fd4d8871 R	384	* the connection. We make the file descriptor non-blocking so
fd4d8871 R	385	* that the write will only write sufficient data without blocking
4c04137d	386	* and we poll the descriptor to make sure that we can write without
fd4d8871	387	* blocking. Short writes are gracefully handled and if the whole
4c04137d	388	* transaction takes too long it is aborted.
fd4d8871 R	389	* Note: poll() is not supported in OSX 10.2 and is reported to be
	390	* broken in more recent versions (up to 10.4).
	391	*/
	392	#ifndef NO_POLL_H
74f1a423	393	pollfd.fd = spamd_cctx.sock;
fd4d8871 R	394	pollfd.events = POLLOUT;
fd4d8871 R	395	#endif
fd4d8871 R	396	do
	397	{
	398	read = fread(spamd_buffer,1,sizeof(spamd_buffer),mbox_file);
	399	if (read > 0)
ddcf2b5f	400	{
fd4d8871 R	401	offset = 0;
	402	again:
	403	#ifndef NO_POLL_H
	404	result = poll(&pollfd, 1, 1000);
8523533c	405
fd4d8871 R	406	/* Patch posted by Erik ? for OS X and applied by PH */
	407	#else
	408	select_tv.tv_sec = 1;
	409	select_tv.tv_usec = 0;
	410	FD_ZERO(&select_fd);
74f1a423 JH	411	FD_SET(spamd_cctx.sock, &select_fd);
74f1a423 JH	412	result = select(spamd_cctx.sock+1, NULL, &select_fd, NULL, &select_tv);
fd4d8871 R	413	#endif
fd4d8871 R	414	/* End Erik's patch */
8523533c	415
fd4d8871 R	416	if (result == -1 && errno == EINTR)
	417	goto again;
	418	else if (result < 1)
c5f280e2	419	{
fd4d8871 R	420	if (result == -1)
fd4d8871 R	421	log_write(0, LOG_MAIN\|LOG_PANIC,
0ea02355	422	"%s %s on spamd %s socket", loglabel, callout_address, strerror(errno));
fd4d8871 R	423	else
fd4d8871 R	424	{
8a512ed5	425	if (time(NULL) - start < sd->timeout)
fd4d8871 R	426	goto again;
fd4d8871 R	427	log_write(0, LOG_MAIN\|LOG_PANIC,
0ea02355	428	"%s timed out writing spamd %s, socket", loglabel, callout_address);
fd4d8871	429	}
74f1a423	430	(void)close(spamd_cctx.sock);
8acbb134	431	goto defer;
c5f280e2	432	}
8e669ac1	433
74f1a423	434	wrote = send(spamd_cctx.sock,spamd_buffer + offset,read - offset,0);
fd4d8871	435	if (wrote == -1)
c5f280e2	436	{
fd4d8871	437	log_write(0, LOG_MAIN\|LOG_PANIC,
0ea02355	438	"%s %s on spamd %s socket", loglabel, callout_address, strerror(errno));
74f1a423	439	(void)close(spamd_cctx.sock);
8acbb134	440	goto defer;
c5f280e2	441	}
fd4d8871	442	if (offset + wrote != read)
ddcf2b5f	443	{
fd4d8871 R	444	offset += wrote;
fd4d8871 R	445	goto again;
ddcf2b5f JH	446	}
ddcf2b5f JH	447	}
fd4d8871 R	448	}
fd4d8871 R	449	while (!feof(mbox_file) && !ferror(mbox_file));
8523533c	450
fd4d8871 R	451	if (ferror(mbox_file))
	452	{
	453	log_write(0, LOG_MAIN\|LOG_PANIC,
	454	"%s error reading spool file: %s", loglabel, strerror(errno));
74f1a423	455	(void)close(spamd_cctx.sock);
8acbb134	456	goto defer;
fd4d8871 R	457	}
	458
	459	(void)fclose(mbox_file);
	460
	461	/* we're done sending, close socket for writing */
dd998666	462	shutdown(spamd_cctx.sock, SHUT_WR);
fd4d8871 R	463
	464	/* read spamd response using what's left of the timeout. */
	465	memset(spamd_buffer, 0, sizeof(spamd_buffer));
	466	offset = 0;
74f1a423	467	while ((i = ip_recv(&spamd_cctx,
fd4d8871 R	468	spamd_buffer + offset,
fd4d8871 R	469	sizeof(spamd_buffer) - offset - 1,
77560253	470	sd->timeout - time(NULL) + start)) > 0)
fd4d8871	471	offset += i;
77560253	472	spamd_buffer[offset] = '\0'; /* guard byte */
fd4d8871 R	473
	474	/* error handling */
	475	if (i <= 0 && errno != 0)
	476	{
	477	log_write(0, LOG_MAIN\|LOG_PANIC,
0ea02355	478	"%s error reading from spamd %s, socket: %s", loglabel, callout_address, strerror(errno));
74f1a423	479	(void)close(spamd_cctx.sock);
fd4d8871 R	480	return DEFER;
	481	}
	482
	483	/* reading done */
74f1a423	484	(void)close(spamd_cctx.sock);
fd4d8871	485
fd4d8871 R	486	{ /* spamassassin */
	487	/* dig in the spamd output and put the report in a multiline header,
	488	if requested */
	489	if (sscanf(CS spamd_buffer,
	490	"SPAMD/%7s 0 EX_OK\r\nContent-length: %*u\r\n\r\n%lf/%lf\r\n%n",
	491	spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3)
ddcf2b5f	492	{
fd4d8871 R	493	/* try to fall back to pre-2.50 spamd output */
	494	if (sscanf(CS spamd_buffer,
	495	"SPAMD/%7s 0 EX_OK\r\nSpam: %*s ; %lf / %lf\r\n\r\n%n",
	496	spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3)
	497	{
	498	log_write(0, LOG_MAIN\|LOG_PANIC,
0ea02355	499	"%s cannot parse spamd %s output", loglabel, callout_address);
fd4d8871 R	500	return DEFER;
fd4d8871 R	501	}
ddcf2b5f	502	}
fd4d8871	503
dd998666	504	spam_action_buffer = spamd_score >= spamd_threshold ? US"reject" : US"no action";
fd4d8871 R	505	}
	506
	507	/* Create report. Since this is a multiline string,
	508	we must hack it into shape first */
	509	p = &spamd_buffer[spamd_report_offset];
	510	q = spam_report_buffer;
	511	while (*p != '\0')
	512	{
	513	/* skip \r */
	514	if (*p == '\r')
	515	{
	516	p++;
	517	continue;
	518	}
	519	q++ = p;
	520	if (*p++ == '\n')
	521	{
	522	/* add an extra space after the newline to ensure
	523	that it is treated as a header continuation line */
	524	*q++ = ' ';
	525	}
	526	}
	527	/* NULL-terminate */
	528	*q-- = '\0';
	529	/* cut off trailing leftovers */
	530	while (*q <= ' ')
	531	*q-- = '\0';
	532
	533	spam_report = spam_report_buffer;
	534	spam_action = spam_action_buffer;
	535
	536	/* create spam bar */
	537	spamd_score_char = spamd_score > 0 ? '+' : '-';
	538	j = abs((int)(spamd_score));
	539	i = 0;
	540	if (j != 0)
	541	while ((i < j) && (i <= MAX_SPAM_BAR_CHARS))
	542	spam_bar_buffer[i++] = spamd_score_char;
	543	else
	544	{
	545	spam_bar_buffer[0] = '/';
	546	i = 1;
	547	}
	548	spam_bar_buffer[i] = '\0';
	549	spam_bar = spam_bar_buffer;
	550
	551	/* create "float" spam score */
	552	(void)string_format(spam_score_buffer, sizeof(spam_score_buffer),
	553	"%.1f", spamd_score);
	554	spam_score = spam_score_buffer;
	555
	556	/* create "int" spam score */
	557	j = (int)((spamd_score + 0.001)*10);
	558	(void)string_format(spam_score_int_buffer, sizeof(spam_score_int_buffer),
	559	"%d", j);
	560	spam_score_int = spam_score_int_buffer;
	561
	562	/* compare threshold against score */
	563	spam_rc = spamd_score >= spamd_threshold
	564	? OK /* spam as determined by user's threshold */
	565	: FAIL; /* not spam */
	566
	567	/* remember expanded spamd_address if needed */
	568	if (spamd_address_work != spamd_address)
569	prev_spamd_address_work = string_copy(spamd_address_work);
570
571	/* remember user name and "been here" for it */
572	Ustrcpy(prev_user_name, user_name);
573	spam_ok = 1;
574
575	return override
576	? OK /* always return OK, no matter what the score */
577	: spam_rc;
8acbb134 JH	578
	579	defer:
	580	(void)fclose(mbox_file);
	581	return DEFER;
8523533c TK	582	}
	583
	584	#endif
2aad5761 JH	585	/* vi: aw ai sw=2
2aad5761 JH	586	*/