src/src/malware.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003 - 2015
   6  * License: GPL
   7  * Copyright (c) The Exim Maintainers 2015 - 2018
   8  */
   9
  10 /* Code for calling virus (malware) scanners. Called from acl.c. */
  11
  12 #include "exim.h"
  13 #ifdef WITH_CONTENT_SCAN        /* entire file */
  14
  15 typedef enum {
  16 #ifndef DISABLE_MAL_FFROTD
  17         M_FPROTD,
  18 #endif
  19 #ifndef DISABLE_MAL_FFROT6D
  20         M_FPROT6D,
  21 #endif
  22 #ifndef DISABLE_MAL_DRWEB
  23         M_DRWEB,
  24 #endif
  25 #ifndef DISABLE_MAL_AVE
  26         M_AVES,
  27 #endif
  28 #ifndef DISABLE_MAL_FSECURE
  29         M_FSEC,
  30 #endif
  31 #ifndef DISABLE_MAL_KAV
  32         M_KAVD,
  33 #endif
  34 #ifndef DISABLE_MAL_SOPHIE
  35         M_SOPHIE,
  36 #endif
  37 #ifndef DISABLE_MAL_CLAM
  38         M_CLAMD,
  39 #endif
  40 #ifndef DISABLE_MAL_MKS
  41         M_MKSD,
  42 #endif
  43 #ifndef DISABLE_MAL_AVAST
  44         M_AVAST,
  45 #endif
  46 #ifndef DISABLE_MAL_SOCK
  47         M_SOCK,
  48 #endif
  49 #ifndef DISABLE_MAL_CMDLINE
  50         M_CMDL,
  51 #endif
  52         M_DUMMY
  53         } scanner_t;
  54 typedef enum {MC_NONE, MC_TCP, MC_UNIX, MC_STRM} contype_t;
  55 static struct scan
  56 {
  57   scanner_t     scancode;
  58   const uschar * name;
  59   const uschar * options_default;
  60   contype_t     conn;
  61 } m_scans[] =
  62 {
  63 #ifndef DISABLE_MAL_FFROTD
  64   { M_FPROTD,   US"f-protd",    US"localhost 10200-10204",            MC_TCP },
  65 #endif
  66 #ifndef DISABLE_MAL_FFROT6D
  67   { M_FPROT6D,  US"f-prot6d",   US"localhost 10200",                  MC_TCP },
  68 #endif
  69 #ifndef DISABLE_MAL_DRWEB
  70   { M_DRWEB,    US"drweb",      US"/usr/local/drweb/run/drwebd.sock", MC_STRM },
  71 #endif
  72 #ifndef DISABLE_MAL_AVE
  73   { M_AVES,     US"aveserver",  US"/var/run/aveserver",               MC_UNIX },
  74 #endif
  75 #ifndef DISABLE_MAL_FSECURE
  76   { M_FSEC,     US"fsecure",    US"/var/run/.fsav",                   MC_UNIX },
  77 #endif
  78 #ifndef DISABLE_MAL_KAV
  79   { M_KAVD,     US"kavdaemon",  US"/var/run/AvpCtl",                  MC_UNIX },
  80 #endif
  81 #ifndef DISABLE_MAL_SOPHIE
  82   { M_SOPHIE,   US"sophie",     US"/var/run/sophie",                  MC_UNIX },
  83 #endif
  84 #ifndef DISABLE_MAL_CLAM
  85   { M_CLAMD,    US"clamd",      US"/tmp/clamd",                       MC_NONE },
  86 #endif
  87 #ifndef DISABLE_MAL_MKS
  88   { M_MKSD,     US"mksd",       NULL,                                 MC_NONE },
  89 #endif
  90 #ifndef DISABLE_MAL_AVAST
  91   { M_AVAST,    US"avast",      US"/var/run/avast/scan.sock",         MC_STRM },
  92 #endif
  93 #ifndef DISABLE_MAL_SOCK
  94   { M_SOCK,     US"sock",       US"/tmp/malware.sock",                MC_STRM },
  95 #endif
  96 #ifndef DISABLE_MAL_CMDLINE
  97   { M_CMDL,     US"cmdline",    NULL,                                 MC_NONE },
  98 #endif
  99   { -1,         NULL,           NULL, MC_NONE }         /* end-marker */
 100 };
 101
 102 /******************************************************************************/
 103 # ifdef MACRO_PREDEF            /* build solely to predefine macros */
 104
 105 #  include "macro_predef.h"
 106
 107 void
 108 features_malware(void)
 109 {
 110 const struct scan * sc;
 111 const uschar * s;
 112 uschar * t;
 113 uschar buf[64];
 114
 115 spf(buf, sizeof(buf), US"_HAVE_MALWARE_");
 116
 117 for (sc = m_scans; sc->scancode != -1; sc++)
 118   {
 119   for(s = sc->name, t = buf+14; *s; s++) if (*s != '-') *t++ = toupper(*s);
 120   *t = '\0';
 121   builtin_macro_create(buf);
 122   }
 123 }
 124
 125 /******************************************************************************/
 126 # else  /*!MACRO_PREDEF, main build*/
 127
 128
 129 #define MALWARE_TIMEOUT 120     /* default timeout, seconds */
 130
 131 static const uschar * malware_regex_default = US ".+";
 132 static const pcre * malware_default_re = NULL;
 133
 134
 135
 136 #ifndef DISABLE_MAL_CLAM
 137 /* The maximum number of clamd servers that are supported in the configuration */
 138 # define MAX_CLAMD_SERVERS 32
 139 # define MAX_CLAMD_SERVERS_S "32"
 140
 141 typedef struct clamd_address {
 142   uschar * hostspec;
 143   unsigned tcp_port;
 144   unsigned retry;
 145 } clamd_address;
 146 #endif
 147
 148
 149 #ifndef DISABLE_MAL_DRWEB
 150 # define DRWEBD_SCAN_CMD             (1)     /* scan file, buffer or diskfile */
 151 # define DRWEBD_RETURN_VIRUSES       (1<<0)   /* ask daemon return to us viruses names from report */
 152 # define DRWEBD_IS_MAIL              (1<<19)  /* say to daemon that format is "archive MAIL" */
 153
 154 # define DERR_READ_ERR               (1<<0)   /* read error */
 155 # define DERR_NOMEMORY               (1<<2)   /* no memory */
 156 # define DERR_TIMEOUT                (1<<9)   /* scan timeout has run out */
 157 # define DERR_BAD_CALL               (1<<15)  /* wrong command */
 158
 159 static const uschar * drweb_re_str = US "infected\\swith\\s*(.+?)$";
 160 static const pcre * drweb_re = NULL;
 161 #endif
 162
 163 #ifndef DISABLE_MAL_FSECURE
 164 static const uschar * fsec_re_str = US "\\S{0,5}INFECTED\\t[^\\t]*\\t([^\\t]+)\\t\\S*$";
 165 static const pcre * fsec_re = NULL;
 166 #endif
 167
 168 #ifndef DISABLE_MAL_KAV
 169 static const uschar * kav_re_sus_str = US "suspicion:\\s*(.+?)\\s*$";
 170 static const uschar * kav_re_inf_str = US "infected:\\s*(.+?)\\s*$";
 171 static const pcre * kav_re_sus = NULL;
 172 static const pcre * kav_re_inf = NULL;
 173 #endif
 174
 175 #ifndef DISABLE_MAL_AVAST
 176 static const uschar * ava_re_clean_str = US "(?!\\\\)\\t\\[\\+\\]";
 177 static const uschar * ava_re_virus_str = US "(?!\\\\)\\t\\[L\\]\\d+\\.0\\t0\\s(.*)";
 178 static const uschar * ava_re_error_str = US "(?!\\\\)\\t\\[E\\]\\d+\\.0\\tError\\s\\d+\\s(.*)";
 179 static const pcre * ava_re_clean = NULL;
 180 static const pcre * ava_re_virus = NULL;
 181 static const pcre * ava_re_error = NULL;
 182 #endif
 183
 184 #ifndef DISABLE_MAL_FFROT6D
 185 static const uschar * fprot6d_re_error_str = US "^\\d+\\s<(.+?)>$";
 186 static const uschar * fprot6d_re_virus_str = US "^\\d+\\s<infected:\\s+(.+?)>\\s+.+$";
 187 static const pcre * fprot6d_re_error = NULL;
 188 static const pcre * fprot6d_re_virus = NULL;
 189 #endif
 190
 191
 192
 193 /******************************************************************************/
 194
 195 #ifndef DISABLE_MAL_KAV
 196 /* Routine to check whether a system is big- or little-endian.
 197    Ripped from http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-7.html
 198    Needed for proper kavdaemon implementation. Sigh. */
 199 # define BIG_MY_ENDIAN      0
 200 # define LITTLE_MY_ENDIAN   1
 201 static int test_byte_order(void);
 202 static inline int
 203 test_byte_order()
 204 {
 205   short int word = 0x0001;
 206   char *byte = CS  &word;
 207   return(byte[0] ? LITTLE_MY_ENDIAN : BIG_MY_ENDIAN);
 208 }
 209 #endif
 210
 211 BOOL malware_ok = FALSE;
 212
 213 /* Gross hacks for the -bmalware option; perhaps we should just create
 214 the scan directory normally for that case, but look into rigging up the
 215 needed header variables if not already set on the command-line? */
 216 extern int spool_mbox_ok;
 217 extern uschar spooled_message_id[MESSAGE_ID_LENGTH+1];
 218
 219
 220 /* Some (currently avast only) use backslash escaped whitespace,
 221 this function undoes these escapes */
 222
 223 static inline void
 224 unescape(uschar *p)
 225 {
 226 uschar *p0;
 227 for (; *p; ++p)
 228   if (*p == '\\' && (isspace(p[1]) || p[1] == '\\'))
 229     for (p0 = p; *p0; ++p0) *p0 = p0[1];
 230 }
 231
 232 /* --- malware_*_defer --- */
 233 static inline int
 234 malware_panic_defer(const uschar * str)
 235 {
 236 log_write(0, LOG_MAIN|LOG_PANIC, "malware acl condition: %s", str);
 237 return DEFER;
 238 }
 239 static inline int
 240 malware_log_defer(const uschar * str)
 241 {
 242 log_write(0, LOG_MAIN, "malware acl condition: %s", str);
 243 return DEFER;
 244 }
 245 /* --- m_*_defer --- */
 246 static inline int
 247 m_panic_defer(struct scan * scanent, const uschar * hostport,
 248   const uschar * str)
 249 {
 250 return malware_panic_defer(string_sprintf("%s %s : %s",
 251   scanent->name, hostport ? hostport : CUS"", str));
 252 }
 253 static inline int
 254 m_log_defer(struct scan * scanent, const uschar * hostport,
 255   const uschar * str)
 256 {
 257 return malware_log_defer(string_sprintf("%s %s : %s",
 258   scanent->name, hostport ? hostport : CUS"", str));
 259 }
 260 /* --- m_*_defer_3 */
 261 static inline int
 262 m_panic_defer_3(struct scan * scanent, const uschar * hostport,
 263   const uschar * str, int fd_to_close)
 264 {
 265 (void) close(fd_to_close);
 266 return m_panic_defer(scanent, hostport, str);
 267 }
 268
 269 /*************************************************/
 270
 271 #ifndef DISABLE_MAL_CLAM
 272 /* Only used by the Clamav code, which is working from a list of servers and
 273 uses the returned in_addr to get a second connection to the same system.
 274 */
 275 static inline int
 276 m_tcpsocket(const uschar * hostname, unsigned int port,
 277         host_item * host, uschar ** errstr, const blob * fastopen_blob)
 278 {
 279 return ip_connectedsocket(SOCK_STREAM, hostname, port, port, 5,
 280                           host, errstr, fastopen_blob);
 281 }
 282 #endif
 283
 284 static int
 285 m_sock_send(int sock, uschar * buf, int cnt, uschar ** errstr)
 286 {
 287 if (send(sock, buf, cnt, 0) < 0)
 288   {
 289   int err = errno;
 290   (void)close(sock);
 291   *errstr = string_sprintf("unable to send to socket (%s): %s",
 292          buf, strerror(err));
 293   return -1;
 294   }
 295 return sock;
 296 }
 297
 298 static const pcre *
 299 m_pcre_compile(const uschar * re, uschar ** errstr)
 300 {
 301 const uschar * rerror;
 302 int roffset;
 303 const pcre * cre;
 304
 305 cre = pcre_compile(CS re, PCRE_COPT, (const char **)&rerror, &roffset, NULL);
 306 if (!cre)
 307   *errstr= string_sprintf("regular expression error in '%s': %s at offset %d",
 308       re, rerror, roffset);
 309 return cre;
 310 }
 311
 312 uschar *
 313 m_pcre_exec(const pcre * cre, uschar * text)
 314 {
 315 int ovector[10*3];
 316 int i = pcre_exec(cre, NULL, CS text, Ustrlen(text), 0, 0,
 317               ovector, nelem(ovector));
 318 uschar * substr = NULL;
 319 if (i >= 2)                             /* Got it */
 320   pcre_get_substring(CS text, ovector, i, 1, (const char **) &substr);
 321 return substr;
 322 }
 323
 324 static const pcre *
 325 m_pcre_nextinlist(const uschar ** list, int * sep,
 326  char * listerr, uschar ** errstr)
 327 {
 328 const uschar * list_ele;
 329 const pcre * cre = NULL;
 330
 331 if (!(list_ele = string_nextinlist(list, sep, NULL, 0)))
 332   *errstr = US listerr;
 333 else
 334   {
 335   DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "RE: ",
 336     string_printing(list_ele));
 337   cre = m_pcre_compile(CUS list_ele, errstr);
 338   }
 339 return cre;
 340 }
 341
 342 /*
 343  Simple though inefficient wrapper for reading a line.  Drop CRs and the
 344  trailing newline. Can return early on buffer full. Null-terminate.
 345  Apply initial timeout if no data ready.
 346
 347  Return: number of chars - zero for an empty line
 348          -1 on EOF
 349          -2 on timeout or error
 350 */
 351 static int
 352 recv_line(int fd, uschar * buffer, int bsize, int tmo)
 353 {
 354 uschar * p = buffer;
 355 ssize_t rcv;
 356 BOOL ok = FALSE;
 357
 358 if (!fd_ready(fd, tmo-time(NULL)))
 359   return -2;
 360
 361 /*XXX tmo handling assumes we always get a whole line */
 362 /* read until \n */
 363 errno = 0;
 364 while ((rcv = read(fd, p, 1)) > 0)
 365   {
 366   ok = TRUE;
 367   if (p-buffer > bsize-2) break;
 368   if (*p == '\n') break;
 369   if (*p != '\r') p++;
 370   }
 371 if (!ok)
 372   {
 373   DEBUG(D_acl) debug_printf_indent("Malware scan: read %s (%s)\n",
 374                 rcv==0 ? "EOF" : "error", strerror(errno));
 375   return rcv==0 ? -1 : -2;
 376   }
 377 *p = '\0';
 378
 379 DEBUG(D_acl) debug_printf_indent("Malware scan: read '%s'\n", buffer);
 380 return p - buffer;
 381 }
 382
 383 /* return TRUE iff size as requested */
 384 static BOOL
 385 recv_len(int sock, void * buf, int size, int tmo)
 386 {
 387 return fd_ready(sock, tmo-time(NULL))
 388   ? recv(sock, buf, size, 0) == size
 389   : FALSE;
 390 }
 391
 392
 393
 394 #ifndef DISABLE_MAL_MKS
 395 /* ============= private routines for the "mksd" scanner type ============== */
 396
 397 # include <sys/uio.h>
 398
 399 static inline int
 400 mksd_writev (int sock, struct iovec * iov, int iovcnt)
 401 {
 402 int i;
 403
 404 for (;;)
 405   {
 406   do
 407     i = writev (sock, iov, iovcnt);
 408   while (i < 0 && errno == EINTR);
 409   if (i <= 0)
 410     {
 411     (void) malware_panic_defer(
 412             US"unable to write to mksd UNIX socket (/var/run/mksd/socket)");
 413     return -1;
 414     }
 415   for (;;)      /* check for short write */
 416     if (i >= iov->iov_len)
 417       {
 418       if (--iovcnt == 0)
 419         return 0;
 420       i -= iov->iov_len;
 421       iov++;
 422       }
 423     else
 424       {
 425       iov->iov_len -= i;
 426       iov->iov_base = CS iov->iov_base + i;
 427       break;
 428       }
 429   }
 430 }
 431
 432 static inline int
 433 mksd_read_lines (int sock, uschar *av_buffer, int av_buffer_size, int tmo)
 434 {
 435 client_conn_ctx cctx = {.sock = sock};
 436 int offset = 0;
 437 int i;
 438
 439 do
 440   {
 441   i = ip_recv(&cctx, av_buffer+offset, av_buffer_size-offset, tmo-time(NULL));
 442   if (i <= 0)
 443     {
 444     (void) malware_panic_defer(US"unable to read from mksd UNIX socket (/var/run/mksd/socket)");
 445     return -1;
 446     }
 447
 448   offset += i;
 449   /* offset == av_buffer_size -> buffer full */
 450   if (offset == av_buffer_size)
 451     {
 452     (void) malware_panic_defer(US"malformed reply received from mksd");
 453     return -1;
 454     }
 455   } while (av_buffer[offset-1] != '\n');
 456
 457 av_buffer[offset] = '\0';
 458 return offset;
 459 }
 460
 461 static inline int
 462 mksd_parse_line(struct scan * scanent, char * line)
 463 {
 464 char *p;
 465
 466 switch (*line)
 467   {
 468   case 'O': /* OK */
 469     return OK;
 470
 471   case 'E':
 472   case 'A': /* ERR */
 473     if ((p = strchr (line, '\n')) != NULL)
 474       *p = '\0';
 475     return m_panic_defer(scanent, NULL,
 476       string_sprintf("scanner failed: %s", line));
 477
 478   default: /* VIR */
 479     if ((p = strchr (line, '\n')) != NULL)
 480       {
 481       *p = '\0';
 482       if (  p-line > 5
 483          && line[3] == ' '
 484          && (p = strchr(line+4, ' ')) != NULL
 485          && p-line > 4
 486          )
 487         {
 488         *p = '\0';
 489         malware_name = string_copy(US line+4);
 490         return OK;
 491         }
 492       }
 493     return m_panic_defer(scanent, NULL,
 494       string_sprintf("malformed reply received: %s", line));
 495   }
 496 }
 497
 498 static int
 499 mksd_scan_packed(struct scan * scanent, int sock, const uschar * scan_filename,
 500   int tmo)
 501 {
 502 struct iovec iov[3];
 503 const char *cmd = "MSQ\n";
 504 uschar av_buffer[1024];
 505
 506 iov[0].iov_base = (void *) cmd;
 507 iov[0].iov_len = 3;
 508 iov[1].iov_base = (void *) scan_filename;
 509 iov[1].iov_len = Ustrlen(scan_filename);
 510 iov[2].iov_base = (void *) (cmd + 3);
 511 iov[2].iov_len = 1;
 512
 513 if (mksd_writev (sock, iov, 3) < 0)
 514   return DEFER;
 515
 516 if (mksd_read_lines (sock, av_buffer, sizeof (av_buffer), tmo) < 0)
 517   return DEFER;
 518
 519 return mksd_parse_line (scanent, CS av_buffer);
 520 }
 521 #endif  /* MKSD */
 522
 523
 524 #ifndef DISABLE_MAL_CLAM
 525 static int
 526 clamd_option(clamd_address * cd, const uschar * optstr, int * subsep)
 527 {
 528 uschar * s;
 529
 530 cd->retry = 0;
 531 while ((s = string_nextinlist(&optstr, subsep, NULL, 0)))
 532   if (Ustrncmp(s, "retry=", 6) == 0)
 533     {
 534     int sec = readconf_readtime((s += 6), '\0', FALSE);
 535     if (sec < 0)
 536       return FAIL;
 537     cd->retry = sec;
 538     }
 539   else
 540     return FAIL;
 541 return OK;
 542 }
 543 #endif
 544
 545
 546
 547 /*************************************************
 548 *          Scan content for malware              *
 549 *************************************************/
 550
 551 /* This is an internal interface for scanning an email; the normal interface
 552 is via malware(), or there's malware_in_file() used for testing/debugging.
 553
 554 Arguments:
 555   malware_re    match condition for "malware="
 556   scan_filename  the file holding the email to be scanned, if we're faking
 557                 this up for the -bmalware test, else NULL
 558   timeout       if nonzero, non-default timeoutl
 559
 560 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
 561                 where true means malware was found (condition applies)
 562 */
 563 static int
 564 malware_internal(const uschar * malware_re, const uschar * scan_filename,
 565   int timeout)
 566 {
 567 int sep = 0;
 568 const uschar *av_scanner_work = av_scanner;
 569 uschar *scanner_name;
 570 unsigned long mbox_size;
 571 FILE *mbox_file;
 572 const pcre *re;
 573 uschar * errstr;
 574 struct scan * scanent;
 575 const uschar * scanner_options;
 576 client_conn_ctx malware_daemon_ctx = {.sock = -1};
 577 time_t tmo;
 578 uschar * eml_filename, * eml_dir;
 579
 580 if (!malware_re)
 581   return FAIL;          /* empty means "don't match anything" */
 582
 583 /* Ensure the eml mbox file is spooled up */
 584
 585 if (!(mbox_file = spool_mbox(&mbox_size, scan_filename, &eml_filename)))
 586   return malware_panic_defer(US"error while creating mbox spool file");
 587
 588 /* None of our current scanners need the mbox file as a stream (they use
 589 the name), so we can close it right away.  Get the directory too. */
 590
 591 (void) fclose(mbox_file);
 592 eml_dir = string_copyn(eml_filename, Ustrrchr(eml_filename, '/') - eml_filename);
 593
 594 /* parse 1st option */
 595 if (strcmpic(malware_re, US"false") == 0  ||  Ustrcmp(malware_re,"0") == 0)
 596   return FAIL;          /* explicitly no matching */
 597
 598 /* special cases (match anything except empty) */
 599 if (  strcmpic(malware_re,US"true") == 0
 600    || Ustrcmp(malware_re,"*") == 0
 601    || Ustrcmp(malware_re,"1") == 0
 602    )
 603   {
 604   if (  !malware_default_re
 605      && !(malware_default_re = m_pcre_compile(malware_regex_default, &errstr)))
 606     return malware_panic_defer(errstr);
 607   malware_re = malware_regex_default;
 608   re = malware_default_re;
 609   }
 610
 611 /* compile the regex, see if it works */
 612 else if (!(re = m_pcre_compile(malware_re, &errstr)))
 613   return malware_panic_defer(errstr);
 614
 615 /* if av_scanner starts with a dollar, expand it first */
 616 if (*av_scanner == '$')
 617   {
 618   if (!(av_scanner_work = expand_string(av_scanner)))
 619     return malware_panic_defer(
 620          string_sprintf("av_scanner starts with $, but expansion failed: %s",
 621          expand_string_message));
 622
 623   DEBUG(D_acl)
 624     debug_printf_indent("Expanded av_scanner global: %s\n", av_scanner_work);
 625   /* disable result caching in this case */
 626   malware_name = NULL;
 627   malware_ok = FALSE;
 628   }
 629
 630 /* Do not scan twice (unless av_scanner is dynamic). */
 631 if (!malware_ok)
 632   {
 633   /* find the scanner type from the av_scanner option */
 634   if (!(scanner_name = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 635     return malware_panic_defer(US"av_scanner configuration variable is empty");
 636   if (!timeout) timeout = MALWARE_TIMEOUT;
 637   tmo = time(NULL) + timeout;
 638
 639   for (scanent = m_scans; ; scanent++)
 640     {
 641     if (!scanent->name)
 642       return malware_panic_defer(string_sprintf("unknown scanner type '%s'",
 643         scanner_name));
 644     if (strcmpic(scanner_name, US scanent->name) != 0)
 645       continue;
 646     DEBUG(D_acl) debug_printf_indent("Malware scan:  %s tmo=%s\n",
 647       scanner_name, readconf_printtime(timeout));
 648
 649     if (!(scanner_options = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 650       scanner_options = scanent->options_default;
 651     if (scanent->conn == MC_NONE)
 652       break;
 653
 654     DEBUG(D_acl) debug_printf_indent("%15s%10s%s\n", "", "socket: ", scanner_options);
 655     switch(scanent->conn)
 656     {
 657     case MC_TCP:
 658       malware_daemon_ctx.sock = ip_tcpsocket(scanner_options, &errstr, 5);      break;
 659     case MC_UNIX:
 660       malware_daemon_ctx.sock = ip_unixsocket(scanner_options, &errstr);        break;
 661     case MC_STRM:
 662       malware_daemon_ctx.sock = ip_streamsocket(scanner_options, &errstr, 5);   break;
 663     default:
 664       /* compiler quietening */ break;
 665     }
 666     if (malware_daemon_ctx.sock < 0)
 667       return m_panic_defer(scanent, CUS callout_address, errstr);
 668     break;
 669   }
 670
 671   switch (scanent->scancode)
 672     {
 673 #ifndef DISABLE_MAL_FFROTD
 674     case M_FPROTD: /* "f-protd" scanner type -------------------------------- */
 675       {
 676       uschar *fp_scan_option;
 677       unsigned int detected=0, par_count=0;
 678       uschar * scanrequest;
 679       uschar buf[32768], *strhelper, *strhelper2;
 680       uschar * malware_name_internal = NULL;
 681       int len;
 682
 683       scanrequest = string_sprintf("GET %s", eml_filename);
 684
 685       while ((fp_scan_option = string_nextinlist(&av_scanner_work, &sep,
 686                             NULL, 0)))
 687         {
 688         scanrequest = string_sprintf("%s%s%s", scanrequest,
 689                                   par_count ? "%20" : "?", fp_scan_option);
 690         par_count++;
 691         }
 692       scanrequest = string_sprintf("%s HTTP/1.0\r\n\r\n", scanrequest);
 693       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s: %s\n",
 694         scanner_name, scanrequest);
 695
 696       /* send scan request */
 697       if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
 698         return m_panic_defer(scanent, CUS callout_address, errstr);
 699
 700       while ((len = recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo)) >= 0)
 701         if (len > 0)
 702           {
 703           if (Ustrstr(buf, US"<detected type=\"") != NULL)
 704             detected = 1;
 705           else if (detected && (strhelper = Ustrstr(buf, US"<name>")))
 706             {
 707             if ((strhelper2 = Ustrstr(buf, US"</name>")) != NULL)
 708               {
 709               *strhelper2 = '\0';
 710               malware_name_internal = string_copy(strhelper+6);
 711               }
 712             }
 713           else if (Ustrstr(buf, US"<summary code=\""))
 714             {
 715             malware_name = Ustrstr(buf, US"<summary code=\"11\">")
 716                 ? malware_name_internal : NULL;
 717             break;
 718             }
 719           }
 720       if (len < -1)
 721         {
 722         (void)close(malware_daemon_ctx.sock);
 723         return DEFER;
 724         }
 725       break;
 726       } /* f-protd */
 727 #endif
 728
 729 #ifndef DISABLE_MAL_FFROT6D
 730     case M_FPROT6D: /* "f-prot6d" scanner type ----------------------------------- */
 731       {
 732       int bread;
 733       uschar * e;
 734       uschar * linebuffer;
 735       uschar * scanrequest;
 736       uschar av_buffer[1024];
 737
 738       if ((!fprot6d_re_virus && !(fprot6d_re_virus = m_pcre_compile(fprot6d_re_virus_str, &errstr)))
 739         || (!fprot6d_re_error && !(fprot6d_re_error = m_pcre_compile(fprot6d_re_error_str, &errstr))))
 740         return malware_panic_defer(errstr);
 741
 742       scanrequest = string_sprintf("SCAN FILE %s\n", eml_filename);
 743       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s: %s\n",
 744         scanner_name, scanrequest);
 745
 746       if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest), &errstr) < 0)
 747         return m_panic_defer(scanent, CUS callout_address, errstr);
 748
 749       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
 750
 751       if (bread <= 0)
 752         return m_panic_defer_3(scanent, CUS callout_address,
 753           string_sprintf("unable to read from socket (%s)", strerror(errno)),
 754           malware_daemon_ctx.sock);
 755
 756       if (bread == sizeof(av_buffer))
 757         return m_panic_defer_3(scanent, CUS callout_address,
 758           US"buffer too small", malware_daemon_ctx.sock);
 759
 760       av_buffer[bread] = '\0';
 761       linebuffer = string_copy(av_buffer);
 762
 763       m_sock_send(malware_daemon_ctx.sock, US"QUIT\n", 5, 0);
 764
 765       if ((e = m_pcre_exec(fprot6d_re_error, linebuffer)))
 766         return m_panic_defer_3(scanent, CUS callout_address,
 767           string_sprintf("scanner reported error (%s)", e), malware_daemon_ctx.sock);
 768
 769       if (!(malware_name = m_pcre_exec(fprot6d_re_virus, linebuffer)))
 770         malware_name = NULL;
 771
 772       break;
 773       }  /* f-prot6d */
 774 #endif
 775
 776 #ifndef DISABLE_MAL_DRWEB
 777     case M_DRWEB: /* "drweb" scanner type ----------------------------------- */
 778   /* v0.1 - added support for tcp sockets          */
 779   /* v0.0 - initial release -- support for unix sockets      */
 780       {
 781       int result;
 782       off_t fsize;
 783       unsigned int fsize_uint;
 784       uschar * tmpbuf, *drweb_fbuf;
 785       int drweb_rc, drweb_cmd, drweb_flags = 0x0000, drweb_fd,
 786           drweb_vnum, drweb_slen, drweb_fin = 0x0000;
 787
 788       /* prepare variables */
 789       drweb_cmd = htonl(DRWEBD_SCAN_CMD);
 790       drweb_flags = htonl(DRWEBD_RETURN_VIRUSES | DRWEBD_IS_MAIL);
 791
 792       if (*scanner_options != '/')
 793         {
 794         /* calc file size */
 795         if ((drweb_fd = open(CCS eml_filename, O_RDONLY)) == -1)
 796           return m_panic_defer_3(scanent, NULL,
 797             string_sprintf("can't open spool file %s: %s",
 798               eml_filename, strerror(errno)),
 799             malware_daemon_ctx.sock);
 800
 801         if ((fsize = lseek(drweb_fd, 0, SEEK_END)) == -1)
 802           {
 803           int err;
 804 badseek:  err = errno;
 805           (void)close(drweb_fd);
 806           return m_panic_defer_3(scanent, NULL,
 807             string_sprintf("can't seek spool file %s: %s",
 808               eml_filename, strerror(err)),
 809             malware_daemon_ctx.sock);
 810           }
 811         fsize_uint = (unsigned int) fsize;
 812         if ((off_t)fsize_uint != fsize)
 813           {
 814           (void)close(drweb_fd);
 815           return m_panic_defer_3(scanent, NULL,
 816             string_sprintf("seeking spool file %s, size overflow",
 817               eml_filename),
 818             malware_daemon_ctx.sock);
 819           }
 820         drweb_slen = htonl(fsize);
 821         if (lseek(drweb_fd, 0, SEEK_SET) < 0)
 822           goto badseek;
 823
 824         DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s remote scan [%s]\n",
 825             scanner_name, scanner_options);
 826
 827         /* send scan request */
 828         if ((send(malware_daemon_ctx.sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
 829             (send(malware_daemon_ctx.sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
 830             (send(malware_daemon_ctx.sock, &drweb_fin, sizeof(drweb_fin), 0) < 0) ||
 831             (send(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), 0) < 0))
 832           {
 833           (void)close(drweb_fd);
 834           return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
 835             "unable to send commands to socket (%s)", scanner_options),
 836             malware_daemon_ctx.sock);
 837           }
 838
 839         if (!(drweb_fbuf = US malloc(fsize_uint)))
 840           {
 841           (void)close(drweb_fd);
 842           return m_panic_defer_3(scanent, NULL,
 843             string_sprintf("unable to allocate memory %u for file (%s)",
 844               fsize_uint, eml_filename),
 845             malware_daemon_ctx.sock);
 846           }
 847
 848         if ((result = read (drweb_fd, drweb_fbuf, fsize)) == -1)
 849           {
 850           int err = errno;
 851           (void)close(drweb_fd);
 852           free(drweb_fbuf);
 853           return m_panic_defer_3(scanent, NULL,
 854             string_sprintf("can't read spool file %s: %s",
 855               eml_filename, strerror(err)),
 856             malware_daemon_ctx.sock);
 857           }
 858         (void)close(drweb_fd);
 859
 860         /* send file body to socket */
 861         if (send(malware_daemon_ctx.sock, drweb_fbuf, fsize, 0) < 0)
 862           {
 863           free(drweb_fbuf);
 864           return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
 865             "unable to send file body to socket (%s)", scanner_options),
 866             malware_daemon_ctx.sock);
 867           }
 868         }
 869       else
 870         {
 871         drweb_slen = htonl(Ustrlen(eml_filename));
 872
 873         DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s local scan [%s]\n",
 874             scanner_name, scanner_options);
 875
 876         /* send scan request */
 877         if ((send(malware_daemon_ctx.sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
 878             (send(malware_daemon_ctx.sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
 879             (send(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), 0) < 0) ||
 880             (send(malware_daemon_ctx.sock, eml_filename, Ustrlen(eml_filename), 0) < 0) ||
 881             (send(malware_daemon_ctx.sock, &drweb_fin, sizeof(drweb_fin), 0) < 0))
 882           return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
 883             "unable to send commands to socket (%s)", scanner_options),
 884             malware_daemon_ctx.sock);
 885         }
 886
 887       /* wait for result */
 888       if (!recv_len(malware_daemon_ctx.sock, &drweb_rc, sizeof(drweb_rc), tmo))
 889         return m_panic_defer_3(scanent, CUS callout_address,
 890                     US"unable to read return code", malware_daemon_ctx.sock);
 891       drweb_rc = ntohl(drweb_rc);
 892
 893       if (!recv_len(malware_daemon_ctx.sock, &drweb_vnum, sizeof(drweb_vnum), tmo))
 894         return m_panic_defer_3(scanent, CUS callout_address,
 895                             US"unable to read the number of viruses", malware_daemon_ctx.sock);
 896       drweb_vnum = ntohl(drweb_vnum);
 897
 898       /* "virus(es) found" if virus number is > 0 */
 899       if (drweb_vnum)
 900         {
 901         int i;
 902         gstring * g = NULL;
 903
 904         /* setup default virus name */
 905         malware_name = US"unknown";
 906
 907         /* set up match regex */
 908         if (!drweb_re)
 909           drweb_re = m_pcre_compile(drweb_re_str, &errstr);
 910
 911         /* read and concatenate virus names into one string */
 912         for (i = 0; i < drweb_vnum; i++)
 913           {
 914           int ovector[10*3];
 915
 916           /* read the size of report */
 917           if (!recv_len(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), tmo))
 918             return m_panic_defer_3(scanent, CUS callout_address,
 919                               US"cannot read report size", malware_daemon_ctx.sock);
 920           drweb_slen = ntohl(drweb_slen);
 921           tmpbuf = store_get(drweb_slen);
 922
 923           /* read report body */
 924           if (!recv_len(malware_daemon_ctx.sock, tmpbuf, drweb_slen, tmo))
 925             return m_panic_defer_3(scanent, CUS callout_address,
 926                               US"cannot read report string", malware_daemon_ctx.sock);
 927           tmpbuf[drweb_slen] = '\0';
 928
 929           /* try matcher on the line, grab substring */
 930           result = pcre_exec(drweb_re, NULL, CS tmpbuf, Ustrlen(tmpbuf), 0, 0,
 931                                   ovector, nelem(ovector));
 932           if (result >= 2)
 933             {
 934             const char * pre_malware_nb;
 935
 936             pcre_get_substring(CS tmpbuf, ovector, result, 1, &pre_malware_nb);
 937
 938             if (i==0)   /* the first name we just copy to malware_name */
 939               g = string_cat(NULL, US pre_malware_nb);
 940
 941             /*XXX could be string_append_listele? */
 942             else        /* concatenate each new virus name to previous */
 943               g = string_append(g, 2, "/", pre_malware_nb);
 944
 945             pcre_free_substring(pre_malware_nb);
 946             }
 947           }
 948           malware_name = string_from_gstring(g);
 949         }
 950       else
 951         {
 952         const char *drweb_s = NULL;
 953
 954         if (drweb_rc & DERR_READ_ERR) drweb_s = "read error";
 955         if (drweb_rc & DERR_NOMEMORY) drweb_s = "no memory";
 956         if (drweb_rc & DERR_TIMEOUT)  drweb_s = "timeout";
 957         if (drweb_rc & DERR_BAD_CALL) drweb_s = "wrong command";
 958         /* retcodes DERR_SYMLINK, DERR_NO_REGFILE, DERR_SKIPPED.
 959          * DERR_TOO_BIG, DERR_TOO_COMPRESSED, DERR_SPAM,
 960          * DERR_CRC_ERROR, DERR_READSOCKET, DERR_WRITE_ERR
 961          * and others are ignored */
 962         if (drweb_s)
 963           return m_panic_defer_3(scanent, CUS callout_address,
 964             string_sprintf("drweb daemon retcode 0x%x (%s)", drweb_rc, drweb_s),
 965             malware_daemon_ctx.sock);
 966
 967         /* no virus found */
 968         malware_name = NULL;
 969         }
 970       break;
 971       } /* drweb */
 972 #endif
 973
 974 #ifndef DISABLE_MAL_AVE
 975     case M_AVES: /* "aveserver" scanner type -------------------------------- */
 976       {
 977       uschar buf[32768];
 978       int result;
 979
 980       /* read aveserver's greeting and see if it is ready (2xx greeting) */
 981       buf[0] = 0;
 982       recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo);
 983
 984       if (buf[0] != '2')                /* aveserver is having problems */
 985         return m_panic_defer_3(scanent, CUS callout_address,
 986           string_sprintf("unavailable (Responded: %s).",
 987                           ((buf[0] != 0) ? buf : US "nothing") ),
 988           malware_daemon_ctx.sock);
 989
 990       /* prepare our command */
 991       (void)string_format(buf, sizeof(buf), "SCAN bPQRSTUW %s\r\n",
 992                                                 eml_filename);
 993
 994       /* and send it */
 995       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s %s\n",
 996         scanner_name, buf);
 997       if (m_sock_send(malware_daemon_ctx.sock, buf, Ustrlen(buf), &errstr) < 0)
 998         return m_panic_defer(scanent, CUS callout_address, errstr);
 999
1000       malware_name = NULL;
1001       result = 0;
1002       /* read response lines, find malware name and final response */
1003       while (recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo) > 0)
1004         {
1005         if (buf[0] == '2')
1006           break;
1007         if (buf[0] == '5')              /* aveserver is having problems */
1008           {
1009           result = m_panic_defer(scanent, CUS callout_address,
1010              string_sprintf("unable to scan file %s (Responded: %s).",
1011                              eml_filename, buf));
1012           break;
1013           }
1014         if (Ustrncmp(buf,"322",3) == 0)
1015           {
1016           uschar *p = Ustrchr(&buf[4], ' ');
1017           *p = '\0';
1018           malware_name = string_copy(&buf[4]);
1019           }
1020         }
1021
1022       if (m_sock_send(malware_daemon_ctx.sock, US"quit\r\n", 6, &errstr) < 0)
1023         return m_panic_defer(scanent, CUS callout_address, errstr);
1024
1025       /* read aveserver's greeting and see if it is ready (2xx greeting) */
1026       buf[0] = 0;
1027       recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo);
1028
1029       if (buf[0] != '2')                /* aveserver is having problems */
1030         return m_panic_defer_3(scanent, CUS callout_address,
1031           string_sprintf("unable to quit dialogue (Responded: %s).",
1032                         ((buf[0] != 0) ? buf : US "nothing") ),
1033           malware_daemon_ctx.sock);
1034
1035       if (result == DEFER)
1036         {
1037         (void)close(malware_daemon_ctx.sock);
1038         return DEFER;
1039         }
1040       break;
1041       } /* aveserver */
1042 #endif
1043
1044 #ifndef DISABLE_MAL_FSECURE
1045     case M_FSEC: /* "fsecure" scanner type ---------------------------------- */
1046       {
1047       int i, j, bread = 0;
1048       uschar * file_name;
1049       uschar av_buffer[1024];
1050       static uschar *cmdopt[] = { US"CONFIGURE\tARCHIVE\t1\n",
1051                                       US"CONFIGURE\tTIMEOUT\t0\n",
1052                                       US"CONFIGURE\tMAXARCH\t5\n",
1053                                       US"CONFIGURE\tMIME\t1\n" };
1054
1055       malware_name = NULL;
1056
1057       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1058           scanner_name, scanner_options);
1059       /* pass options */
1060       memset(av_buffer, 0, sizeof(av_buffer));
1061       for (i = 0; i != nelem(cmdopt); i++)
1062         {
1063
1064         if (m_sock_send(malware_daemon_ctx.sock, cmdopt[i], Ustrlen(cmdopt[i]), &errstr) < 0)
1065           return m_panic_defer(scanent, CUS callout_address, errstr);
1066
1067         bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
1068         if (bread > 0) av_buffer[bread]='\0';
1069         if (bread < 0)
1070           return m_panic_defer_3(scanent, CUS callout_address,
1071             string_sprintf("unable to read answer %d (%s)", i, strerror(errno)),
1072             malware_daemon_ctx.sock);
1073         for (j = 0; j < bread; j++)
1074           if (av_buffer[j] == '\r' || av_buffer[j] == '\n')
1075             av_buffer[j] ='@';
1076         }
1077
1078       /* pass the mailfile to fsecure */
1079       file_name = string_sprintf("SCAN\t%s\n", eml_filename);
1080
1081       if (m_sock_send(malware_daemon_ctx.sock, file_name, Ustrlen(file_name), &errstr) < 0)
1082         return m_panic_defer(scanent, CUS callout_address, errstr);
1083
1084       /* set up match */
1085       /* todo also SUSPICION\t */
1086       if (!fsec_re)
1087         fsec_re = m_pcre_compile(fsec_re_str, &errstr);
1088
1089       /* read report, linewise. Apply a timeout as the Fsecure daemon
1090       sometimes wants an answer to "PING" but they won't tell us what */
1091         {
1092         uschar * p = av_buffer;
1093         uschar * q;
1094
1095         for (;;)
1096           {
1097           errno = ETIMEDOUT;
1098           i =  av_buffer+sizeof(av_buffer)-p;
1099           if ((bread= ip_recv(&malware_daemon_ctx, p, i-1, tmo-time(NULL))) < 0)
1100             return m_panic_defer_3(scanent, CUS callout_address,
1101               string_sprintf("unable to read result (%s)", strerror(errno)),
1102               malware_daemon_ctx.sock);
1103
1104           for (p[bread] = '\0'; (q = Ustrchr(p, '\n')); p = q+1)
1105             {
1106             *q = '\0';
1107
1108             /* Really search for virus again? */
1109             if (!malware_name)
1110               /* try matcher on the line, grab substring */
1111               malware_name = m_pcre_exec(fsec_re, p);
1112
1113             if (Ustrstr(p, "OK\tScan ok."))
1114               goto fsec_found;
1115             }
1116
1117           /* copy down the trailing partial line then read another chunk */
1118           i =  av_buffer+sizeof(av_buffer)-p;
1119           memmove(av_buffer, p, i);
1120           p = av_buffer+i;
1121           }
1122         }
1123
1124       fsec_found:
1125         break;
1126       } /* fsecure */
1127 #endif
1128
1129 #ifndef DISABLE_MAL_KAV
1130     case M_KAVD: /* "kavdaemon" scanner type -------------------------------- */
1131       {
1132       time_t t;
1133       uschar tmpbuf[1024];
1134       uschar * scanrequest;
1135       int kav_rc;
1136       unsigned long kav_reportlen;
1137       int bread;
1138       const pcre *kav_re;
1139       uschar *p;
1140
1141       /* get current date and time, build scan request */
1142       time(&t);
1143       /* pdp note: before the eml_filename parameter, this scanned the
1144       directory; not finding documentation, so we'll strip off the directory.
1145       The side-effect is that the test framework scanning may end up in
1146       scanning more than was requested, but for the normal interface, this is
1147       fine. */
1148
1149       strftime(CS tmpbuf, sizeof(tmpbuf), "%d %b %H:%M:%S", localtime(&t));
1150       scanrequest = string_sprintf("<0>%s:%s", CS tmpbuf, eml_filename);
1151       p = Ustrrchr(scanrequest, '/');
1152       if (p)
1153         *p = '\0';
1154
1155       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1156           scanner_name, scanner_options);
1157
1158       /* send scan request */
1159       if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
1160         return m_panic_defer(scanent, CUS callout_address, errstr);
1161
1162       /* wait for result */
1163       if (!recv_len(malware_daemon_ctx.sock, tmpbuf, 2, tmo))
1164         return m_panic_defer_3(scanent, CUS callout_address,
1165                             US"unable to read 2 bytes from socket.", malware_daemon_ctx.sock);
1166
1167       /* get errorcode from one nibble */
1168       kav_rc = tmpbuf[ test_byte_order()==LITTLE_MY_ENDIAN ? 0 : 1 ] & 0x0F;
1169       switch(kav_rc)
1170       {
1171       case 5: case 6: /* improper kavdaemon configuration */
1172         return m_panic_defer_3(scanent, CUS callout_address,
1173                 US"please reconfigure kavdaemon to NOT disinfect or remove infected files.",
1174                 malware_daemon_ctx.sock);
1175       case 1:
1176         return m_panic_defer_3(scanent, CUS callout_address,
1177                 US"reported 'scanning not completed' (code 1).", malware_daemon_ctx.sock);
1178       case 7:
1179         return m_panic_defer_3(scanent, CUS callout_address,
1180                 US"reported 'kavdaemon damaged' (code 7).", malware_daemon_ctx.sock);
1181       }
1182
1183       /* code 8 is not handled, since it is ambiguous. It appears mostly on
1184       bounces where part of a file has been cut off */
1185
1186       /* "virus found" return codes (2-4) */
1187       if (kav_rc > 1 && kav_rc < 5)
1188         {
1189         int report_flag = 0;
1190
1191         /* setup default virus name */
1192         malware_name = US"unknown";
1193
1194         report_flag = tmpbuf[ test_byte_order() == LITTLE_MY_ENDIAN ? 1 : 0 ];
1195
1196         /* read the report, if available */
1197         if (report_flag == 1)
1198           {
1199           /* read report size */
1200           if (!recv_len(malware_daemon_ctx.sock, &kav_reportlen, 4, tmo))
1201             return m_panic_defer_3(scanent, CUS callout_address,
1202                   US"cannot read report size", malware_daemon_ctx.sock);
1203
1204           /* it's possible that avp returns av_buffer[1] == 1 but the
1205           reportsize is 0 (!?) */
1206           if (kav_reportlen > 0)
1207             {
1208             /* set up match regex, depends on retcode */
1209             if (kav_rc == 3)
1210               {
1211               if (!kav_re_sus) kav_re_sus = m_pcre_compile(kav_re_sus_str, &errstr);
1212               kav_re = kav_re_sus;
1213               }
1214             else
1215               {
1216               if (!kav_re_inf) kav_re_inf = m_pcre_compile(kav_re_inf_str, &errstr);
1217               kav_re = kav_re_inf;
1218               }
1219
1220             /* read report, linewise.  Using size from stream to read amount of data
1221             from same stream is safe enough. */
1222             /* coverity[tainted_data] */
1223             while (kav_reportlen > 0)
1224               {
1225               if ((bread = recv_line(malware_daemon_ctx.sock, tmpbuf, sizeof(tmpbuf), tmo)) < 0)
1226                 break;
1227               kav_reportlen -= bread+1;
1228
1229               /* try matcher on the line, grab substring */
1230               if ((malware_name = m_pcre_exec(kav_re, tmpbuf)))
1231                 break;
1232               }
1233             }
1234           }
1235         }
1236       else /* no virus found */
1237         malware_name = NULL;
1238
1239       break;
1240       }
1241 #endif
1242
1243 #ifndef DISABLE_MAL_CMDLINE
1244     case M_CMDL: /* "cmdline" scanner type ---------------------------------- */
1245       {
1246       const uschar *cmdline_scanner = scanner_options;
1247       const pcre *cmdline_trigger_re;
1248       const pcre *cmdline_regex_re;
1249       uschar * file_name;
1250       uschar * commandline;
1251       void (*eximsigchld)(int);
1252       void (*eximsigpipe)(int);
1253       FILE *scanner_out = NULL;
1254       int scanner_fd;
1255       FILE *scanner_record = NULL;
1256       uschar linebuffer[32767];
1257       int rcnt;
1258       int trigger = 0;
1259       uschar *p;
1260
1261       if (!cmdline_scanner)
1262         return m_panic_defer(scanent, NULL, errstr);
1263
1264       /* find scanner output trigger */
1265       cmdline_trigger_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1266                                 "missing trigger specification", &errstr);
1267       if (!cmdline_trigger_re)
1268         return m_panic_defer(scanent, NULL, errstr);
1269
1270       /* find scanner name regex */
1271       cmdline_regex_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1272                           "missing virus name regex specification", &errstr);
1273       if (!cmdline_regex_re)
1274         return m_panic_defer(scanent, NULL, errstr);
1275
1276       /* prepare scanner call; despite the naming, file_name holds a directory
1277       name which is documented as the value given to %s. */
1278
1279       file_name = string_copy(eml_filename);
1280       p = Ustrrchr(file_name, '/');
1281       if (p)
1282         *p = '\0';
1283       commandline = string_sprintf(CS cmdline_scanner, file_name);
1284
1285       /* redirect STDERR too */
1286       commandline = string_sprintf("%s 2>&1", commandline);
1287
1288       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1289               scanner_name, commandline);
1290
1291       /* store exims signal handlers */
1292       eximsigchld = signal(SIGCHLD,SIG_DFL);
1293       eximsigpipe = signal(SIGPIPE,SIG_DFL);
1294
1295       if (!(scanner_out = popen(CS commandline,"r")))
1296         {
1297         int err = errno;
1298         signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1299         return m_panic_defer(scanent, NULL,
1300           string_sprintf("call (%s) failed: %s.", commandline, strerror(err)));
1301         }
1302       scanner_fd = fileno(scanner_out);
1303
1304       file_name = string_sprintf("%s/%s_scanner_output", eml_dir, message_id);
1305
1306       if (!(scanner_record = modefopen(file_name, "wb", SPOOL_MODE)))
1307         {
1308         int err = errno;
1309         (void) pclose(scanner_out);
1310         signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1311         return m_panic_defer(scanent, NULL, string_sprintf(
1312             "opening scanner output file (%s) failed: %s.",
1313             file_name, strerror(err)));
1314         }
1315
1316       /* look for trigger while recording output */
1317       while ((rcnt = recv_line(scanner_fd, linebuffer,
1318                       sizeof(linebuffer), tmo)))
1319         {
1320         if (rcnt < 0)
1321           {
1322           int err = errno;
1323           if (rcnt == -1)
1324             break;
1325           (void) pclose(scanner_out);
1326           signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1327           return m_panic_defer(scanent, NULL, string_sprintf(
1328               "unable to read from scanner (%s): %s",
1329               commandline, strerror(err)));
1330           }
1331
1332         if (Ustrlen(linebuffer) > fwrite(linebuffer, 1, Ustrlen(linebuffer), scanner_record))
1333           {
1334           /* short write */
1335           (void) pclose(scanner_out);
1336           signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1337           return m_panic_defer(scanent, NULL, string_sprintf(
1338             "short write on scanner output file (%s).", file_name));
1339           }
1340         putc('\n', scanner_record);
1341         /* try trigger match */
1342         if (  !trigger
1343            && regex_match_and_setup(cmdline_trigger_re, linebuffer, 0, -1)
1344            )
1345           trigger = 1;
1346         }
1347
1348       (void)fclose(scanner_record);
1349       sep = pclose(scanner_out);
1350       signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1351       if (sep != 0)
1352           return m_panic_defer(scanent, NULL,
1353               sep == -1
1354               ? string_sprintf("running scanner failed: %s", strerror(sep))
1355               : string_sprintf("scanner returned error code: %d", sep));
1356
1357       if (trigger)
1358         {
1359         uschar * s;
1360         /* setup default virus name */
1361         malware_name = US"unknown";
1362
1363         /* re-open the scanner output file, look for name match */
1364         scanner_record = fopen(CS file_name, "rb");
1365         while (fgets(CS linebuffer, sizeof(linebuffer), scanner_record))
1366           {
1367           /* try match */
1368           if ((s = m_pcre_exec(cmdline_regex_re, linebuffer)))
1369             malware_name = s;
1370           }
1371         (void)fclose(scanner_record);
1372         }
1373       else /* no virus found */
1374         malware_name = NULL;
1375       break;
1376       } /* cmdline */
1377 #endif
1378
1379 #ifndef DISABLE_MAL_SOPHIE
1380     case M_SOPHIE: /* "sophie" scanner type --------------------------------- */
1381       {
1382       int bread = 0;
1383       uschar *p;
1384       uschar * file_name;
1385       uschar av_buffer[1024];
1386
1387       /* pass the scan directory to sophie */
1388       file_name = string_copy(eml_filename);
1389       if ((p = Ustrrchr(file_name, '/')))
1390         *p = '\0';
1391
1392       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1393           scanner_name, scanner_options);
1394
1395       if (  write(malware_daemon_ctx.sock, file_name, Ustrlen(file_name)) < 0
1396          || write(malware_daemon_ctx.sock, "\n", 1) != 1
1397          )
1398         return m_panic_defer_3(scanent, CUS callout_address,
1399           string_sprintf("unable to write to UNIX socket (%s)", scanner_options),
1400           malware_daemon_ctx.sock);
1401
1402       /* wait for result */
1403       memset(av_buffer, 0, sizeof(av_buffer));
1404       if ((bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL))) <= 0)
1405         return m_panic_defer_3(scanent, CUS callout_address,
1406           string_sprintf("unable to read from UNIX socket (%s)", scanner_options),
1407           malware_daemon_ctx.sock);
1408
1409       /* infected ? */
1410       if (av_buffer[0] == '1') {
1411         uschar * s = Ustrchr(av_buffer, '\n');
1412         if (s)
1413           *s = '\0';
1414         malware_name = string_copy(&av_buffer[2]);
1415       }
1416       else if (!strncmp(CS av_buffer, "-1", 2))
1417         return m_panic_defer_3(scanent, CUS callout_address,
1418                 US"scanner reported error", malware_daemon_ctx.sock);
1419       else /* all ok, no virus */
1420         malware_name = NULL;
1421
1422       break;
1423       }
1424 #endif
1425
1426 #ifndef DISABLE_MAL_CLAM
1427     case M_CLAMD: /* "clamd" scanner type ----------------------------------- */
1428       {
1429 /* This code was originally contributed by David Saez */
1430 /* There are three scanning methods available to us:
1431 *  (1) Use the SCAN command, pointing to a file in the filesystem
1432 *  (2) Use the STREAM command, send the data on a separate port
1433 *  (3) Use the zINSTREAM command, send the data inline
1434 * The zINSTREAM command was introduced with ClamAV 0.95, which marked
1435 * STREAM deprecated; see: http://wiki.clamav.net/bin/view/Main/UpgradeNotes095
1436 * In Exim, we use SCAN if using a Unix-domain socket or explicitly told that
1437 * the TCP-connected daemon is actually local; otherwise we use zINSTREAM
1438 * See Exim bug 926 for details.  */
1439
1440       uschar *p, *vname, *result_tag;
1441       int bread=0;
1442       uschar av_buffer[1024];
1443       uschar *hostname = US"";
1444       host_item connhost;
1445       uschar *clamav_fbuf;
1446       int clam_fd, result;
1447       off_t fsize;
1448       unsigned int fsize_uint;
1449       BOOL use_scan_command = FALSE;
1450       clamd_address * cv[MAX_CLAMD_SERVERS];
1451       int num_servers = 0;
1452       uint32_t send_size, send_final_zeroblock;
1453       blob cmd_str;
1454
1455       /*XXX if unixdomain socket, only one server supported. Needs fixing;
1456       there's no reason we should not mix local and remote servers */
1457
1458       if (*scanner_options == '/')
1459         {
1460         clamd_address * cd;
1461         const uschar * sublist;
1462         int subsep = ' ';
1463
1464         /* Local file; so we def want to use_scan_command and don't want to try
1465          * passing IP/port combinations */
1466         use_scan_command = TRUE;
1467         cd = (clamd_address *) store_get(sizeof(clamd_address));
1468
1469         /* extract socket-path part */
1470         sublist = scanner_options;
1471         cd->hostspec = string_nextinlist(&sublist, &subsep, NULL, 0);
1472
1473         /* parse options */
1474         if (clamd_option(cd, sublist, &subsep) != OK)
1475           return m_panic_defer(scanent, NULL,
1476             string_sprintf("bad option '%s'", scanner_options));
1477         cv[0] = cd;
1478         }
1479       else
1480         {
1481         /* Go through the rest of the list of host/port and construct an array
1482          * of servers to try. The first one is the bit we just passed from
1483          * scanner_options so process that first and then scan the remainder of
1484          * the address buffer */
1485         do
1486           {
1487           clamd_address * cd;
1488           const uschar * sublist;
1489           int subsep = ' ';
1490           uschar * s;
1491
1492           /* The 'local' option means use the SCAN command over the network
1493            * socket (ie common file storage in use) */
1494           /*XXX we could accept this also as a local option? */
1495           if (strcmpic(scanner_options, US"local") == 0)
1496             {
1497             use_scan_command = TRUE;
1498             continue;
1499             }
1500
1501           cd = (clamd_address *) store_get(sizeof(clamd_address));
1502
1503           /* extract host and port part */
1504           sublist = scanner_options;
1505           if (!(cd->hostspec = string_nextinlist(&sublist, &subsep, NULL, 0)))
1506             {
1507             (void) m_panic_defer(scanent, NULL,
1508                       string_sprintf("missing address: '%s'", scanner_options));
1509             continue;
1510             }
1511           if (!(s = string_nextinlist(&sublist, &subsep, NULL, 0)))
1512             {
1513             (void) m_panic_defer(scanent, NULL,
1514                       string_sprintf("missing port: '%s'", scanner_options));
1515             continue;
1516             }
1517           cd->tcp_port = atoi(CS s);
1518
1519           /* parse options */
1520           /*XXX should these options be common over scanner types? */
1521           if (clamd_option(cd, sublist, &subsep) != OK)
1522             return m_panic_defer(scanent, NULL,
1523               string_sprintf("bad option '%s'", scanner_options));
1524
1525           cv[num_servers++] = cd;
1526           if (num_servers >= MAX_CLAMD_SERVERS)
1527             {
1528             (void) m_panic_defer(scanent, NULL,
1529                   US"More than " MAX_CLAMD_SERVERS_S " clamd servers "
1530                   "specified; only using the first " MAX_CLAMD_SERVERS_S );
1531             break;
1532             }
1533           } while ((scanner_options = string_nextinlist(&av_scanner_work, &sep,
1534                                         NULL, 0)));
1535
1536         /* check if we have at least one server */
1537         if (!num_servers)
1538           return m_panic_defer(scanent, NULL,
1539             US"no useable server addresses in malware configuration option.");
1540         }
1541
1542       /* See the discussion of response formats below to see why we really
1543       don't like colons in filenames when passing filenames to ClamAV. */
1544       if (use_scan_command && Ustrchr(eml_filename, ':'))
1545         return m_panic_defer(scanent, NULL,
1546           string_sprintf("local/SCAN mode incompatible with" \
1547             " : in path to email filename [%s]", eml_filename));
1548
1549       /* Set up the very first data we will be sending */
1550       if (!use_scan_command)
1551         { cmd_str.data = US"zINSTREAM"; cmd_str.len = 10; }
1552       else
1553         {
1554         cmd_str.data = string_sprintf("SCAN %s\n", eml_filename);
1555         cmd_str.len = Ustrlen(cmd_str.data);
1556         }
1557
1558       /* We have some network servers specified */
1559       if (num_servers)
1560         {
1561         /* Confirmed in ClamAV source (0.95.3) that the TCPAddr option of clamd
1562          * only supports AF_INET, but we should probably be looking to the
1563          * future and rewriting this to be protocol-independent anyway. */
1564
1565         while (num_servers > 0)
1566           {
1567           int i = random_number(num_servers);
1568           clamd_address * cd = cv[i];
1569
1570           DEBUG(D_acl) debug_printf_indent("trying server name %s, port %u\n",
1571                          cd->hostspec, cd->tcp_port);
1572
1573           /* Lookup the host. This is to ensure that we connect to the same IP
1574            * on both connections (as one host could resolve to multiple ips) */
1575           for (;;)
1576             {
1577             /*XXX we trust that the cmd_str is ideempotent */
1578             if ((malware_daemon_ctx.sock = m_tcpsocket(cd->hostspec, cd->tcp_port,
1579                                     &connhost, &errstr, &cmd_str)) >= 0)
1580               {
1581               /* Connection successfully established with a server */
1582               hostname = cd->hostspec;
1583               cmd_str.len = 0;
1584               break;
1585               }
1586             if (cd->retry <= 0) break;
1587             while (cd->retry > 0) cd->retry = sleep(cd->retry);
1588             }
1589           if (malware_daemon_ctx.sock >= 0)
1590             break;
1591
1592           (void) m_panic_defer(scanent, CUS callout_address, errstr);
1593
1594           /* Remove the server from the list. XXX We should free the memory */
1595           num_servers--;
1596           for (; i < num_servers; i++)
1597             cv[i] = cv[i+1];
1598           }
1599
1600         if (num_servers == 0)
1601           return m_panic_defer(scanent, NULL, US"all servers failed");
1602         }
1603       else
1604         for (;;)
1605           {
1606           if ((malware_daemon_ctx.sock = ip_unixsocket(cv[0]->hostspec, &errstr)) >= 0)
1607             {
1608             hostname = cv[0]->hostspec;
1609             break;
1610             }
1611           if (cv[0]->retry <= 0)
1612             return m_panic_defer(scanent, CUS callout_address, errstr);
1613           while (cv[0]->retry > 0) cv[0]->retry = sleep(cv[0]->retry);
1614           }
1615
1616       /* have socket in variable "sock"; command to use is semi-independent of
1617        * the socket protocol.  We use SCAN if is local (either Unix/local
1618        * domain socket, or explicitly told local) else we stream the data.
1619        * How we stream the data depends upon how we were built.  */
1620
1621       if (!use_scan_command)
1622         {
1623         /* New protocol: "zINSTREAM\n" followed by a sequence of <length><data>
1624         chunks, <n> a 4-byte number (network order), terminated by a zero-length
1625         chunk. */
1626
1627         DEBUG(D_acl) debug_printf_indent(
1628             "Malware scan: issuing %s new-style remote scan (zINSTREAM)\n",
1629             scanner_name);
1630
1631         /* Pass the string to ClamAV (10 = "zINSTREAM\0"), if not already sent */
1632         if (cmd_str.len)
1633           if (send(malware_daemon_ctx.sock, cmd_str.data, cmd_str.len, 0) < 0)
1634             return m_panic_defer_3(scanent, CUS hostname,
1635               string_sprintf("unable to send zINSTREAM to socket (%s)",
1636                 strerror(errno)),
1637               malware_daemon_ctx.sock);
1638
1639         /* calc file size */
1640         if ((clam_fd = open(CS eml_filename, O_RDONLY)) < 0)
1641           {
1642           int err = errno;
1643           return m_panic_defer_3(scanent, NULL,
1644             string_sprintf("can't open spool file %s: %s",
1645               eml_filename, strerror(err)),
1646             malware_daemon_ctx.sock);
1647           }
1648         if ((fsize = lseek(clam_fd, 0, SEEK_END)) < 0)
1649           {
1650           int err;
1651 b_seek:   err = errno;
1652           (void)close(clam_fd);
1653           return m_panic_defer_3(scanent, NULL,
1654             string_sprintf("can't seek spool file %s: %s",
1655               eml_filename, strerror(err)),
1656             malware_daemon_ctx.sock);
1657           }
1658         fsize_uint = (unsigned int) fsize;
1659         if ((off_t)fsize_uint != fsize)
1660           {
1661           (void)close(clam_fd);
1662           return m_panic_defer_3(scanent, NULL,
1663             string_sprintf("seeking spool file %s, size overflow",
1664               eml_filename),
1665             malware_daemon_ctx.sock);
1666           }
1667         if (lseek(clam_fd, 0, SEEK_SET) < 0)
1668           goto b_seek;
1669
1670         if (!(clamav_fbuf = US malloc(fsize_uint)))
1671           {
1672           (void)close(clam_fd);
1673           return m_panic_defer_3(scanent, NULL,
1674             string_sprintf("unable to allocate memory %u for file (%s)",
1675               fsize_uint, eml_filename),
1676             malware_daemon_ctx.sock);
1677           }
1678
1679         if ((result = read(clam_fd, clamav_fbuf, fsize_uint)) < 0)
1680           {
1681           int err = errno;
1682           free(clamav_fbuf); (void)close(clam_fd);
1683           return m_panic_defer_3(scanent, NULL,
1684             string_sprintf("can't read spool file %s: %s",
1685               eml_filename, strerror(err)),
1686             malware_daemon_ctx.sock);
1687           }
1688         (void)close(clam_fd);
1689
1690         /* send file body to socket */
1691         send_size = htonl(fsize_uint);
1692         send_final_zeroblock = 0;
1693         if ((send(malware_daemon_ctx.sock, &send_size, sizeof(send_size), 0) < 0) ||
1694             (send(malware_daemon_ctx.sock, clamav_fbuf, fsize_uint, 0) < 0) ||
1695             (send(malware_daemon_ctx.sock, &send_final_zeroblock, sizeof(send_final_zeroblock), 0) < 0))
1696           {
1697           free(clamav_fbuf);
1698           return m_panic_defer_3(scanent, NULL,
1699             string_sprintf("unable to send file body to socket (%s)", hostname),
1700             malware_daemon_ctx.sock);
1701           }
1702
1703         free(clamav_fbuf);
1704         }
1705       else
1706         { /* use scan command */
1707         /* Send a SCAN command pointing to a filename; then in the then in the
1708          * scan-method-neutral part, read the response back */
1709
1710 /* ================================================================= */
1711
1712         /* Prior to the reworking post-Exim-4.72, this scanned a directory,
1713         which dates to when ClamAV needed us to break apart the email into the
1714         MIME parts (eg, with the now deprecated demime condition coming first).
1715         Some time back, ClamAV gained the ability to deconstruct the emails, so
1716         doing this would actually have resulted in the mail attachments being
1717         scanned twice, in the broken out files and from the original .eml.
1718         Since ClamAV now handles emails (and has for quite some time) we can
1719         just use the email file itself. */
1720         /* Pass the string to ClamAV (7 = "SCAN \n" + \0), if not already sent */
1721
1722         DEBUG(D_acl) debug_printf_indent(
1723             "Malware scan: issuing %s local-path scan [%s]\n",
1724             scanner_name, scanner_options);
1725
1726         if (cmd_str.len)
1727           if (send(malware_daemon_ctx.sock, cmd_str.data, cmd_str.len, 0) < 0)
1728             return m_panic_defer_3(scanent, CUS callout_address,
1729               string_sprintf("unable to write to socket (%s)", strerror(errno)),
1730               malware_daemon_ctx.sock);
1731
1732         /* Do not shut down the socket for writing; a user report noted that
1733          * clamd 0.70 does not react well to this. */
1734         }
1735       /* Commands have been sent, no matter which scan method or connection
1736        * type we're using; now just read the result, independent of method. */
1737
1738       /* Read the result */
1739       memset(av_buffer, 0, sizeof(av_buffer));
1740       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
1741       (void)close(malware_daemon_ctx.sock);
1742       malware_daemon_ctx.sock = -1;
1743       malware_daemon_ctx.tls_ctx = NULL;
1744
1745       if (bread <= 0)
1746         return m_panic_defer(scanent, CUS callout_address,
1747           string_sprintf("unable to read from socket (%s)",
1748           errno == 0 ? "EOF" : strerror(errno)));
1749
1750       if (bread == sizeof(av_buffer))
1751         return m_panic_defer(scanent, CUS callout_address,
1752                 US"buffer too small");
1753       /* We're now assured of a NULL at the end of av_buffer */
1754
1755       /* Check the result. ClamAV returns one of two result formats.
1756       In the basic mode, the response is of the form:
1757         infected: -> "<filename>: <virusname> FOUND"
1758         not-infected: -> "<filename>: OK"
1759         error: -> "<filename>: <errcode> ERROR
1760       If the ExtendedDetectionInfo option has been turned on, then we get:
1761         "<filename>: <virusname>(<virushash>:<virussize>) FOUND"
1762       for the infected case.  Compare:
1763 /tmp/eicar.com: Eicar-Test-Signature FOUND
1764 /tmp/eicar.com: Eicar-Test-Signature(44d88612fea8a8f36de82e1278abb02f:68) FOUND
1765
1766       In the streaming case, clamd uses the filename "stream" which you should
1767       be able to verify with { ktrace clamdscan --stream /tmp/eicar.com }.  (The
1768       client app will replace "stream" with the original filename before returning
1769       results to stdout, but the trace shows the data).
1770
1771       We will assume that the pathname passed to clamd from Exim does not contain
1772       a colon.  We will have whined loudly above if the eml_filename does (and we're
1773       passing a filename to clamd). */
1774
1775       if (!(*av_buffer))
1776         return m_panic_defer(scanent, CUS callout_address,
1777                 US"ClamAV returned null");
1778
1779       /* strip newline at the end (won't be present for zINSTREAM)
1780       (also any trailing whitespace, which shouldn't exist, but we depend upon
1781       this below, so double-check) */
1782       p = av_buffer + Ustrlen(av_buffer) - 1;
1783       if (*p == '\n') *p = '\0';
1784
1785       DEBUG(D_acl) debug_printf_indent("Malware response: %s\n", av_buffer);
1786
1787       while (isspace(*--p) && (p > av_buffer))
1788         *p = '\0';
1789       if (*p) ++p;
1790
1791       /* colon in returned output? */
1792       if(!(p = Ustrchr(av_buffer,':')))
1793         return m_panic_defer(scanent, CUS callout_address, string_sprintf(
1794                   "ClamAV returned malformed result (missing colon): %s",
1795                   av_buffer));
1796
1797       /* strip filename */
1798       while (*p && isspace(*++p)) /**/;
1799       vname = p;
1800
1801       /* It would be bad to encounter a virus with "FOUND" in part of the name,
1802       but we should at least be resistant to it. */
1803       p = Ustrrchr(vname, ' ');
1804       result_tag = p ? p+1 : vname;
1805
1806       if (Ustrcmp(result_tag, "FOUND") == 0)
1807         {
1808         /* p should still be the whitespace before the result_tag */
1809         while (isspace(*p)) --p;
1810         *++p = '\0';
1811         /* Strip off the extended information too, which will be in parens
1812         after the virus name, with no intervening whitespace. */
1813         if (*--p == ')')
1814           {
1815           /* "(hash:size)", so previous '(' will do; if not found, we have
1816           a curious virus name, but not an error. */
1817           p = Ustrrchr(vname, '(');
1818           if (p)
1819             *p = '\0';
1820           }
1821         malware_name = string_copy(vname);
1822         DEBUG(D_acl) debug_printf_indent("Malware found, name \"%s\"\n", malware_name);
1823
1824         }
1825       else if (Ustrcmp(result_tag, "ERROR") == 0)
1826         return m_panic_defer(scanent, CUS callout_address,
1827           string_sprintf("ClamAV returned: %s", av_buffer));
1828
1829       else if (Ustrcmp(result_tag, "OK") == 0)
1830         {
1831         /* Everything should be OK */
1832         malware_name = NULL;
1833         DEBUG(D_acl) debug_printf_indent("Malware not found\n");
1834
1835         }
1836       else
1837         return m_panic_defer(scanent, CUS callout_address,
1838           string_sprintf("unparseable response from ClamAV: {%s}", av_buffer));
1839
1840       break;
1841       } /* clamd */
1842 #endif
1843
1844 #ifndef DISABLE_MAL_SOCK
1845     case M_SOCK: /* "sock" scanner type ------------------------------------- */
1846     /* This code was derived by Martin Poole from the clamd code contributed
1847        by David Saez and the cmdline code
1848     */
1849       {
1850       int bread;
1851       uschar * commandline;
1852       uschar av_buffer[1024];
1853       uschar * linebuffer;
1854       uschar * sockline_scanner;
1855       uschar sockline_scanner_default[] = "%s\n";
1856       const pcre *sockline_trig_re;
1857       const pcre *sockline_name_re;
1858
1859       /* find scanner command line */
1860       if (  (sockline_scanner = string_nextinlist(&av_scanner_work, &sep,
1861                                           NULL, 0))
1862          && *sockline_scanner
1863          )
1864       { /* check for no expansions apart from one %s */
1865         uschar * s = Ustrchr(sockline_scanner, '%');
1866         if (s++)
1867           if ((*s != 's' && *s != '%') || Ustrchr(s+1, '%'))
1868             return m_panic_defer_3(scanent, NULL,
1869                                   US"unsafe sock scanner call spec", malware_daemon_ctx.sock);
1870       }
1871       else
1872         sockline_scanner = sockline_scanner_default;
1873       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "cmdline: ",
1874         string_printing(sockline_scanner));
1875
1876       /* find scanner output trigger */
1877       sockline_trig_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1878                                 "missing trigger specification", &errstr);
1879       if (!sockline_trig_re)
1880         return m_panic_defer_3(scanent, NULL, errstr, malware_daemon_ctx.sock);
1881
1882       /* find virus name regex */
1883       sockline_name_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1884                           "missing virus name regex specification", &errstr);
1885       if (!sockline_name_re)
1886         return m_panic_defer_3(scanent, NULL, errstr, malware_daemon_ctx.sock);
1887
1888       /* prepare scanner call - security depends on expansions check above */
1889       commandline = string_sprintf( CS sockline_scanner, CS eml_filename);
1890       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "expanded: ",
1891         string_printing(commandline));
1892
1893       /* Pass the command string to the socket */
1894       if (m_sock_send(malware_daemon_ctx.sock, commandline, Ustrlen(commandline), &errstr) < 0)
1895         return m_panic_defer(scanent, CUS callout_address, errstr);
1896
1897       /* Read the result */
1898       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
1899
1900       if (bread <= 0)
1901         return m_panic_defer_3(scanent, CUS callout_address,
1902           string_sprintf("unable to read from socket (%s)", strerror(errno)),
1903           malware_daemon_ctx.sock);
1904
1905       if (bread == sizeof(av_buffer))
1906         return m_panic_defer_3(scanent, CUS callout_address,
1907                 US"buffer too small", malware_daemon_ctx.sock);
1908       av_buffer[bread] = '\0';
1909       linebuffer = string_copy(av_buffer);
1910       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "answer: ",
1911         string_printing(linebuffer));
1912
1913       /* try trigger match */
1914       if (regex_match_and_setup(sockline_trig_re, linebuffer, 0, -1))
1915         {
1916         if (!(malware_name = m_pcre_exec(sockline_name_re, av_buffer)))
1917           malware_name = US "unknown";
1918         DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "name: ",
1919           string_printing(malware_name));
1920         }
1921       else /* no virus found */
1922         malware_name = NULL;
1923       break;
1924       }
1925 #endif
1926
1927 #ifndef DISABLE_MAL_MKS
1928     case M_MKSD: /* "mksd" scanner type ------------------------------------- */
1929       {
1930       char *mksd_options_end;
1931       int mksd_maxproc = 1;  /* default, if no option supplied */
1932       int retval;
1933
1934       if (scanner_options)
1935         {
1936         mksd_maxproc = (int)strtol(CS scanner_options, &mksd_options_end, 10);
1937         if (  *scanner_options == '\0'
1938            || *mksd_options_end != '\0'
1939            || mksd_maxproc < 1
1940            || mksd_maxproc > 32
1941            )
1942           return m_panic_defer(scanent, CUS callout_address,
1943             string_sprintf("invalid option '%s'", scanner_options));
1944         }
1945
1946       if((malware_daemon_ctx.sock = ip_unixsocket(US "/var/run/mksd/socket", &errstr)) < 0)
1947         return m_panic_defer(scanent, CUS callout_address, errstr);
1948
1949       malware_name = NULL;
1950
1951       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan\n", scanner_name);
1952
1953       if ((retval = mksd_scan_packed(scanent, malware_daemon_ctx.sock, eml_filename, tmo)) != OK)
1954         {
1955         close (malware_daemon_ctx.sock);
1956         return retval;
1957         }
1958       break;
1959       }
1960 #endif
1961
1962 #ifndef DISABLE_MAL_AVAST
1963     case M_AVAST: /* "avast" scanner type ----------------------------------- */
1964       {
1965       uschar buf[1024];
1966       uschar * scanrequest;
1967       enum {AVA_HELO, AVA_OPT, AVA_RSP, AVA_DONE} avast_stage;
1968       int nread;
1969       uschar * error_message = NULL;
1970       BOOL more_data = FALSE;
1971       BOOL strict = TRUE;
1972
1973       /* According to Martin Tuma @avast the protocol uses "escaped
1974       whitespace", that is, every embedded whitespace is backslash
1975       escaped, as well as backslash is protected by backslash.
1976       The returned lines contain the name of the scanned file, a tab
1977       and the [ ] marker.
1978       [+] - not infected
1979       [L] - infected
1980       [E] - some error occured
1981       Such marker follows the first non-escaped TAB.  For more information
1982       see avast-protocol(5)
1983
1984       We observed two cases:
1985       -> SCAN /file
1986       <- /file [E]0.0 Error 13 Permission denied
1987       <- 451 SCAN Engine error 13 permission denied
1988
1989       -> SCAN /file
1990       <- /file… [E]3.0 Error 41120 The file is a decompression bomb
1991       <- /file… [+]2.0
1992       <- /file… [+]2.0 0 Eicar Test Virus!!!
1993       <- 200 SCAN OK
1994
1995       If the scanner returns 4xx, DEFER is a good decision, combined
1996       with a panic log entry, to get the admin's attention.
1997
1998       If the scanner returns 200, we reject it as malware, if found any,
1999       or, in case of an error, we set the malware message to the error
2000       string.
2001
2002       Some of the >= 42000 errors are message related - usually some
2003       broken archives etc, but some of them are e.g. license related.
2004       Once the license expires the engine starts returning errors for
2005       every scanning attempt.  I¹ have the full list of the error codes
2006       but it is not a public API and is subject to change. It is hard
2007       for me to say what you should do in case of an engine error. You
2008       can have a “Treat * unscanned file as infection” policy or “Treat
2009       unscanned file as clean” policy.  ¹) Jakub Bednar
2010
2011        */
2012
2013       if (  (  !ava_re_clean
2014             && !(ava_re_clean = m_pcre_compile(ava_re_clean_str, &errstr)))
2015          || (  !ava_re_virus
2016             && !(ava_re_virus = m_pcre_compile(ava_re_virus_str, &errstr)))
2017          || (  !ava_re_error
2018             && !(ava_re_error = m_pcre_compile(ava_re_error_str, &errstr)))
2019          )
2020         return malware_panic_defer(errstr);
2021
2022       /* wait for result */
2023       for (avast_stage = AVA_HELO;
2024            (nread = recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo)) > 0;
2025           )
2026         {
2027         int slen = Ustrlen(buf);
2028         if (slen >= 1)
2029           {
2030
2031           /* Multi line responses are bracketed between 210 … and nnn … */
2032           if (Ustrncmp(buf, "210", 3) == 0)
2033             {
2034             more_data = 1;
2035             continue;
2036             }
2037           else if (more_data && isdigit(buf[0])) more_data = 0;
2038
2039           switch (avast_stage)
2040             {
2041             case AVA_HELO:
2042               if (more_data) continue;
2043               if (Ustrncmp(buf, "220", 3) != 0)
2044                 goto endloop;                   /* require a 220 */
2045               goto sendreq;
2046
2047             case AVA_OPT:
2048               if (more_data) continue;
2049               if (Ustrncmp(buf, "200", 3) != 0)
2050                 goto endloop;                   /* require a 200 */
2051
2052             sendreq:
2053               {
2054               int len;
2055               /* Check for another option to send. Newline-terminate it. */
2056               if ((scanrequest = string_nextinlist(&av_scanner_work, &sep,
2057                                 NULL, 0)))
2058                 {
2059                 if (Ustrcmp(scanrequest, "pass_unscanned") == 0)
2060                   {
2061                   DEBUG(D_acl) debug_printf_indent("pass unscanned files as clean\n");
2062                   strict = FALSE;
2063                   goto sendreq;
2064                   }
2065                 scanrequest = string_sprintf("%s\n", scanrequest);
2066                 avast_stage = AVA_OPT;          /* just sent option */
2067                 DEBUG(D_acl) debug_printf_indent("send to avast OPTION: %s", scanrequest);
2068                 }
2069               else
2070                 {
2071                 scanrequest = string_sprintf("SCAN %s\n", eml_dir);
2072                 avast_stage = AVA_RSP;          /* just sent command */
2073                 DEBUG(D_acl) debug_printf_indent("send to avast REQUEST: SCAN %s\n", eml_dir);
2074                 }
2075
2076               /* send config-cmd or scan-request to socket */
2077               len = Ustrlen(scanrequest);
2078               if (send(malware_daemon_ctx.sock, scanrequest, len, 0) == -1)
2079                 {
2080                 scanrequest[len-1] = '\0';
2081                 return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
2082                       "unable to send request '%s' to socket (%s): %s",
2083                       scanrequest, scanner_options, strerror(errno)), malware_daemon_ctx.sock);
2084                 }
2085               break;
2086               }
2087
2088             case AVA_RSP:
2089
2090               if (isdigit(buf[0]))  /* We're done */
2091                 goto endloop;
2092
2093               if (malware_name)     /* Nothing else matters, just read on */
2094                 break;
2095
2096               if (pcre_exec(ava_re_clean, NULL, CS buf, slen, 0, 0, NULL, 0) == 0)
2097                 break;
2098
2099               if ((malware_name = m_pcre_exec(ava_re_virus, buf)))
2100                 {
2101                 unescape(malware_name);
2102                 DEBUG(D_acl)
2103                   debug_printf_indent("unescaped malware name: '%s'\n", malware_name);
2104                 break;
2105                 }
2106
2107               if (strict)           /* treat scanner errors as malware */
2108                 {
2109                 if ((malware_name = m_pcre_exec(ava_re_error, buf)))
2110                   {
2111                   unescape(malware_name);
2112                   DEBUG(D_acl)
2113                     debug_printf_indent("unescaped error message: '%s'\n", malware_name);
2114                   break;
2115                   }
2116                 }
2117               else if (pcre_exec(ava_re_error, NULL, CS buf, slen, 0, 0, NULL, 0) == 0)
2118                 {
2119                 log_write(0, LOG_MAIN, "internal scanner error (ignored): %s", buf);
2120                 break;
2121                 }
2122
2123               /* here also for any unexpected response from the scanner */
2124               DEBUG(D_acl) debug_printf("avast response not handled: '%s'\n", buf);
2125
2126               goto endloop;
2127
2128             default:    log_write(0, LOG_PANIC, "%s:%d:%s: should not happen",
2129                             __FILE__, __LINE__, __FUNCTION__);
2130             }
2131           }
2132         }
2133
2134       endloop:
2135
2136       if (nread == -1) error_message = US"EOF from scanner";
2137       else if (nread < 0) error_message = US"timeout from scanner";
2138       else if (nread == 0) error_message = US"got nothing from scanner";
2139       else if (buf[0] != '2') error_message = buf;
2140
2141       DEBUG(D_acl) debug_printf_indent("sent to avast QUIT\n");
2142       if (send(malware_daemon_ctx.sock, "QUIT\n", 5, 0) == -1)
2143         return m_panic_defer_3(scanent, CUS callout_address,
2144           string_sprintf("unable to send quit request to socket (%s): %s",
2145             scanner_options, strerror(errno)), malware_daemon_ctx.sock);
2146
2147       if (error_message)
2148         return m_panic_defer_3(scanent, CUS callout_address, error_message, malware_daemon_ctx.sock);
2149
2150       }
2151 #endif
2152   }     /* scanner type switch */
2153
2154   if (malware_daemon_ctx.sock >= 0)
2155     (void) close (malware_daemon_ctx.sock);
2156   malware_ok = TRUE;                    /* set "been here, done that" marker */
2157   }
2158
2159 /* match virus name against pattern (caseless ------->----------v) */
2160 if (malware_name && regex_match_and_setup(re, malware_name, 0, -1))
2161   {
2162   DEBUG(D_acl) debug_printf_indent(
2163       "Matched regex to malware [%s] [%s]\n", malware_re, malware_name);
2164   return OK;
2165   }
2166 else
2167   return FAIL;
2168 }
2169
2170
2171 /*************************************************
2172 *          Scan an email for malware             *
2173 *************************************************/
2174
2175 /* This is the normal interface for scanning an email, which doesn't need a
2176 filename; it's a wrapper around the malware_file function.
2177
2178 Arguments:
2179   malware_re  match condition for "malware="
2180   timeout     if nonzero, timeout in seconds
2181
2182 Returns:      Exim message processing code (OK, FAIL, DEFER, ...)
2183               where true means malware was found (condition applies)
2184 */
2185 int
2186 malware(const uschar * malware_re, int timeout)
2187 {
2188 int ret = malware_internal(malware_re, NULL, timeout);
2189
2190 if (ret == DEFER) av_failed = TRUE;
2191 return ret;
2192 }
2193
2194
2195 /*************************************************
2196 *          Scan a file for malware               *
2197 *************************************************/
2198
2199 /* This is a test wrapper for scanning an email, which is not used in
2200 normal processing.  Scan any file, using the Exim scanning interface.
2201 This function tampers with various global variables so is unsafe to use
2202 in any other context.
2203
2204 Arguments:
2205   eml_filename  a file holding the message to be scanned
2206
2207 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
2208                 where true means malware was found (condition applies)
2209 */
2210 int
2211 malware_in_file(uschar *eml_filename)
2212 {
2213 uschar message_id_buf[64];
2214 int ret;
2215
2216 /* spool_mbox() assumes various parameters exist, when creating
2217 the relevant directory and the email within */
2218
2219 (void) string_format(message_id_buf, sizeof(message_id_buf),
2220     "dummy-%d", vaguely_random_number(INT_MAX));
2221 message_id = message_id_buf;
2222 sender_address = US"malware-sender@example.net";
2223 return_path = US"";
2224 recipients_list = NULL;
2225 receive_add_recipient(US"malware-victim@example.net", -1);
2226 f.enable_dollar_recipients = TRUE;
2227
2228 ret = malware_internal(US"*", eml_filename, 0);
2229
2230 Ustrncpy(spooled_message_id, message_id, sizeof(spooled_message_id));
2231 spool_mbox_ok = 1;
2232
2233 /* don't set no_mbox_unspool; at present, there's no way for it to become
2234 set, but if that changes, then it should apply to these tests too */
2235
2236 unspool_mbox();
2237
2238 /* silence static analysis tools */
2239 message_id = NULL;
2240
2241 return ret;
2242 }
2243
2244
2245 void
2246 malware_init(void)
2247 {
2248 if (!malware_default_re)
2249   malware_default_re = regex_must_compile(malware_regex_default, FALSE, TRUE);
2250
2251 #ifndef DISABLE_MAL_DRWEB
2252 if (!drweb_re)
2253   drweb_re = regex_must_compile(drweb_re_str, FALSE, TRUE);
2254 #endif
2255 #ifndef DISABLE_MAL_FSECURE
2256 if (!fsec_re)
2257   fsec_re = regex_must_compile(fsec_re_str, FALSE, TRUE);
2258 #endif
2259 #ifndef DISABLE_MAL_KAV
2260 if (!kav_re_sus)
2261   kav_re_sus = regex_must_compile(kav_re_sus_str, FALSE, TRUE);
2262 if (!kav_re_inf)
2263   kav_re_inf = regex_must_compile(kav_re_inf_str, FALSE, TRUE);
2264 #endif
2265 #ifndef DISABLE_MAL_AVAST
2266 if (!ava_re_clean)
2267   ava_re_clean = regex_must_compile(ava_re_clean_str, FALSE, TRUE);
2268 if (!ava_re_virus)
2269   ava_re_virus = regex_must_compile(ava_re_virus_str, FALSE, TRUE);
2270 if (!ava_re_error)
2271   ava_re_error = regex_must_compile(ava_re_error_str, FALSE, TRUE);
2272 #endif
2273 #ifndef DISABLE_MAL_FFROT6D
2274 if (!fprot6d_re_error)
2275   fprot6d_re_error = regex_must_compile(fprot6d_re_error_str, FALSE, TRUE);
2276 if (!fprot6d_re_virus)
2277   fprot6d_re_virus = regex_must_compile(fprot6d_re_virus_str, FALSE, TRUE);
2278 #endif
2279 }
2280
2281
2282 void
2283 malware_show_supported(FILE * f)
2284 {
2285 struct scan * sc;
2286 fprintf(f, "Malware:");
2287 for (sc = m_scans; sc->scancode != (scanner_t)-1; sc++) fprintf(f, " %s", sc->name);
2288 fprintf(f, "\n");
2289 }
2290
2291
2292 # endif /*!MACRO_PREDEF*/
2293 #endif /*WITH_CONTENT_SCAN*/
2294 /*
2295  * vi: aw ai sw=2
2296  */