git://git.exim.org / exim.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Header-wrap expansion. Bug 2843
[exim.git] / src / src / malware.c
diff --git a/src/src/malware.c b/src/src/malware.c
index 17a652a901ced6dce45cd5fff79c51f1ecea7655..f36c46b0f545e684f6fcb01a20ee478de9b472ab 100644 (file)
--- a/src/src/malware.c
+++ b/src/src/malware.c
@@ -2,16 +2,57 @@
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
-/* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003 - 2015 */
-/* License: GPL */
+/*
+ * Copyright (c) The Exim Maintainers 2015 - 2022
+ * Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003 - 2015
+ * License: GPL
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
 
 /* Code for calling virus (malware) scanners. Called from acl.c. */
 
 #include "exim.h"
 
 /* Code for calling virus (malware) scanners. Called from acl.c. */
 
 #include "exim.h"
-#ifdef WITH_CONTENT_SCAN
+#ifdef WITH_CONTENT_SCAN       /* entire file */
 
 
-typedef enum {M_FPROTD, M_DRWEB, M_AVES, M_FSEC, M_KAVD, M_CMDL,
-               M_SOPHIE, M_CLAMD, M_SOCK, M_MKSD, M_AVAST} scanner_t;
+typedef enum {
+#ifndef DISABLE_MAL_FFROTD
+       M_FPROTD,
+#endif
+#ifndef DISABLE_MAL_FFROT6D
+       M_FPROT6D,
+#endif
+#ifndef DISABLE_MAL_DRWEB
+       M_DRWEB,
+#endif
+#ifndef DISABLE_MAL_AVE
+       M_AVES,
+#endif
+#ifndef DISABLE_MAL_FSECURE
+       M_FSEC,
+#endif
+#ifndef DISABLE_MAL_KAV
+       M_KAVD,
+#endif
+#ifndef DISABLE_MAL_SOPHIE
+       M_SOPHIE,
+#endif
+#ifndef DISABLE_MAL_CLAM
+       M_CLAMD,
+#endif
+#ifndef DISABLE_MAL_MKS
+       M_MKSD,
+#endif
+#ifndef DISABLE_MAL_AVAST
+       M_AVAST,
+#endif
+#ifndef DISABLE_MAL_SOCK
+       M_SOCK,
+#endif
+#ifndef DISABLE_MAL_CMDLINE
+       M_CMDL,
+#endif
+       M_DUMMY
+       } scanner_t;
 typedef enum {MC_NONE, MC_TCP, MC_UNIX, MC_STRM} contype_t;
 static struct scan
 {
 typedef enum {MC_NONE, MC_TCP, MC_UNIX, MC_STRM} contype_t;
 static struct scan
 {
@@ -21,84 +62,152 @@ static struct scan
   contype_t    conn;
 } m_scans[] =
 {
   contype_t    conn;
 } m_scans[] =
 {
+#ifndef DISABLE_MAL_FFROTD
   { M_FPROTD,  US"f-protd",    US"localhost 10200-10204",            MC_TCP },
   { M_FPROTD,  US"f-protd",    US"localhost 10200-10204",            MC_TCP },
+#endif
+#ifndef DISABLE_MAL_FFROT6D
+  { M_FPROT6D, US"f-prot6d",   US"localhost 10200",                  MC_TCP },
+#endif
+#ifndef DISABLE_MAL_DRWEB
   { M_DRWEB,   US"drweb",      US"/usr/local/drweb/run/drwebd.sock", MC_STRM },
   { M_DRWEB,   US"drweb",      US"/usr/local/drweb/run/drwebd.sock", MC_STRM },
+#endif
+#ifndef DISABLE_MAL_AVE
   { M_AVES,    US"aveserver",  US"/var/run/aveserver",               MC_UNIX },
   { M_AVES,    US"aveserver",  US"/var/run/aveserver",               MC_UNIX },
+#endif
+#ifndef DISABLE_MAL_FSECURE
   { M_FSEC,    US"fsecure",    US"/var/run/.fsav",                   MC_UNIX },
   { M_FSEC,    US"fsecure",    US"/var/run/.fsav",                   MC_UNIX },
+#endif
+#ifndef DISABLE_MAL_KAV
   { M_KAVD,    US"kavdaemon",  US"/var/run/AvpCtl",                  MC_UNIX },
   { M_KAVD,    US"kavdaemon",  US"/var/run/AvpCtl",                  MC_UNIX },
-  { M_CMDL,    US"cmdline",    NULL,                                 MC_NONE },
+#endif
+#ifndef DISABLE_MAL_SOPHIE
   { M_SOPHIE,  US"sophie",     US"/var/run/sophie",                  MC_UNIX },
   { M_SOPHIE,  US"sophie",     US"/var/run/sophie",                  MC_UNIX },
+#endif
+#ifndef DISABLE_MAL_CLAM
   { M_CLAMD,   US"clamd",      US"/tmp/clamd",                       MC_NONE },
   { M_CLAMD,   US"clamd",      US"/tmp/clamd",                       MC_NONE },
-  { M_SOCK,    US"sock",       US"/tmp/malware.sock",                MC_STRM },
+#endif
+#ifndef DISABLE_MAL_MKS
   { M_MKSD,    US"mksd",       NULL,                                 MC_NONE },
   { M_MKSD,    US"mksd",       NULL,                                 MC_NONE },
+#endif
+#ifndef DISABLE_MAL_AVAST
   { M_AVAST,   US"avast",      US"/var/run/avast/scan.sock",         MC_STRM },
   { M_AVAST,   US"avast",      US"/var/run/avast/scan.sock",         MC_STRM },
+#endif
+#ifndef DISABLE_MAL_SOCK
+  { M_SOCK,    US"sock",       US"/tmp/malware.sock",                MC_STRM },
+#endif
+#ifndef DISABLE_MAL_CMDLINE
+  { M_CMDL,    US"cmdline",    NULL,                                 MC_NONE },
+#endif
   { -1,                NULL,           NULL, MC_NONE }         /* end-marker */
 };
 
   { -1,                NULL,           NULL, MC_NONE }         /* end-marker */
 };
 
+/******************************************************************************/
+# ifdef MACRO_PREDEF           /* build solely to predefine macros */
+
+#  include "macro_predef.h"
+
+void
+features_malware(void)
+{
+const uschar * s;
+uschar * t;
+uschar buf[EXIM_DRIVERNAME_MAX];
+
+spf(buf, sizeof(buf), US"_HAVE_MALWARE_");
+
+for (const struct scan * sc = m_scans; sc->scancode != -1; sc++)
+  {
+  for (s = sc->name, t = buf+14; *s; s++) if (*s != '-')
+    *t++ = toupper(*s);
+  *t = '\0';
+  builtin_macro_create(buf);
+  }
+}
+
+/******************************************************************************/
+# else /*!MACRO_PREDEF, main build*/
+
+
+#define MALWARE_TIMEOUT 120    /* default timeout, seconds */
+
+static const uschar * malware_regex_default = US ".+";
+static const pcre2_code * malware_default_re = NULL;
+
+
+#ifndef DISABLE_MAL_CLAM
 /* The maximum number of clamd servers that are supported in the configuration */
 /* The maximum number of clamd servers that are supported in the configuration */
-#define MAX_CLAMD_SERVERS 32
-#define MAX_CLAMD_SERVERS_S "32"
+# define MAX_CLAMD_SERVERS 32
+# define MAX_CLAMD_SERVERS_S "32"
 
 typedef struct clamd_address {
   uschar * hostspec;
   unsigned tcp_port;
   unsigned retry;
 } clamd_address;
 
 typedef struct clamd_address {
   uschar * hostspec;
   unsigned tcp_port;
   unsigned retry;
 } clamd_address;
-
-#ifndef nelements
-# define nelements(arr) (sizeof(arr) / sizeof(arr[0]))
 #endif
 
 
 #endif
 
 
-#define MALWARE_TIMEOUT 120    /* default timeout, seconds */
-
-
-#define DRWEBD_SCAN_CMD             (1)     /* scan file, buffer or diskfile */
-#define DRWEBD_RETURN_VIRUSES       (1<<0)   /* ask daemon return to us viruses names from report */
-#define DRWEBD_IS_MAIL              (1<<19)  /* say to daemon that format is "archive MAIL" */
+#ifndef DISABLE_MAL_DRWEB
+# define DRWEBD_SCAN_CMD             (1)     /* scan file, buffer or diskfile */
+# define DRWEBD_RETURN_VIRUSES       (1<<0)   /* ask daemon return to us viruses names from report */
+# define DRWEBD_IS_MAIL              (1<<19)  /* say to daemon that format is "archive MAIL" */
 
 
-#define DERR_READ_ERR               (1<<0)   /* read error */
-#define DERR_NOMEMORY               (1<<2)   /* no memory */
-#define DERR_TIMEOUT                (1<<9)   /* scan timeout has run out */
-#define DERR_BAD_CALL               (1<<15)  /* wrong command */
-
-
-static const uschar * malware_regex_default = US ".+";
-static const pcre * malware_default_re = NULL;
+# define DERR_READ_ERR               (1<<0)   /* read error */
+# define DERR_NOMEMORY               (1<<2)   /* no memory */
+# define DERR_TIMEOUT                (1<<9)   /* scan timeout has run out */
+# define DERR_BAD_CALL               (1<<15)  /* wrong command */
 
 static const uschar * drweb_re_str = US "infected\\swith\\s*(.+?)$";
 
 static const uschar * drweb_re_str = US "infected\\swith\\s*(.+?)$";
-static const pcre * drweb_re = NULL;
+static const pcre2_code * drweb_re = NULL;
+#endif
 
 
+#ifndef DISABLE_MAL_FSECURE
 static const uschar * fsec_re_str = US "\\S{0,5}INFECTED\\t[^\\t]*\\t([^\\t]+)\\t\\S*$";
 static const uschar * fsec_re_str = US "\\S{0,5}INFECTED\\t[^\\t]*\\t([^\\t]+)\\t\\S*$";
-static const pcre * fsec_re = NULL;
+static const pcre2_code * fsec_re = NULL;
+#endif
 
 
+#ifndef DISABLE_MAL_KAV
 static const uschar * kav_re_sus_str = US "suspicion:\\s*(.+?)\\s*$";
 static const uschar * kav_re_inf_str = US "infected:\\s*(.+?)\\s*$";
 static const uschar * kav_re_sus_str = US "suspicion:\\s*(.+?)\\s*$";
 static const uschar * kav_re_inf_str = US "infected:\\s*(.+?)\\s*$";
-static const pcre * kav_re_sus = NULL;
-static const pcre * kav_re_inf = NULL;
+static const pcre2_code * kav_re_sus = NULL;
+static const pcre2_code * kav_re_inf = NULL;
+#endif
 
 
+#ifndef DISABLE_MAL_AVAST
 static const uschar * ava_re_clean_str = US "(?!\\\\)\\t\\[\\+\\]";
 static const uschar * ava_re_clean_str = US "(?!\\\\)\\t\\[\\+\\]";
-static const uschar * ava_re_virus_str = US "(?!\\\\)\\t\\[L\\]\\d\\.\\d\\t\\d\\s(.*)";
-static const pcre * ava_re_clean = NULL;
-static const pcre * ava_re_virus = NULL;
+static const uschar * ava_re_virus_str = US "(?!\\\\)\\t\\[L\\]\\d+\\.0\\t0\\s(.*)";
+static const uschar * ava_re_error_str = US "(?!\\\\)\\t\\[E\\]\\d+\\.0\\tError\\s\\d+\\s(.*)";
+static const pcre2_code * ava_re_clean = NULL;
+static const pcre2_code * ava_re_virus = NULL;
+static const pcre2_code * ava_re_error = NULL;
+#endif
+
+#ifndef DISABLE_MAL_FFROT6D
+static const uschar * fprot6d_re_error_str = US "^\\d+\\s<(.+?)>$";
+static const uschar * fprot6d_re_virus_str = US "^\\d+\\s<infected:\\s+(.+?)>\\s+.+$";
+static const pcre2_code * fprot6d_re_error = NULL;
+static const pcre2_code * fprot6d_re_virus = NULL;
+#endif
 
 
 
 /******************************************************************************/
 
 
 
 
 /******************************************************************************/
 
+#ifndef DISABLE_MAL_KAV
 /* Routine to check whether a system is big- or little-endian.
    Ripped from http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-7.html
    Needed for proper kavdaemon implementation. Sigh. */
 /* Routine to check whether a system is big- or little-endian.
    Ripped from http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-7.html
    Needed for proper kavdaemon implementation. Sigh. */
-#define BIG_MY_ENDIAN      0
-#define LITTLE_MY_ENDIAN   1
+# define BIG_MY_ENDIAN      0
+# define LITTLE_MY_ENDIAN   1
 static int test_byte_order(void);
 static inline int
 test_byte_order()
 {
   short int word = 0x0001;
 static int test_byte_order(void);
 static inline int
 test_byte_order()
 {
   short int word = 0x0001;
-  char *byte = (char *) &word;
+  char *byte = CS  &word;
   return(byte[0] ? LITTLE_MY_ENDIAN : BIG_MY_ENDIAN);
 }
   return(byte[0] ? LITTLE_MY_ENDIAN : BIG_MY_ENDIAN);
 }
+#endif
 
 BOOL malware_ok = FALSE;
 
 
 BOOL malware_ok = FALSE;
 
@@ -106,41 +215,75 @@ BOOL malware_ok = FALSE;
 the scan directory normally for that case, but look into rigging up the
 needed header variables if not already set on the command-line? */
 extern int spool_mbox_ok;
 the scan directory normally for that case, but look into rigging up the
 needed header variables if not already set on the command-line? */
 extern int spool_mbox_ok;
-extern uschar spooled_message_id[17];
+extern uschar spooled_message_id[MESSAGE_ID_LENGTH+1];
+
 
 
+/* Some (currently avast only) use backslash escaped whitespace,
+this function undoes these escapes */
 
 
+#ifndef DISABLE_MAL_AVAST
+static inline void
+unescape(uschar *p)
+{
+uschar *p0;
+for (; *p; ++p)
+  if (*p == '\\' && (isspace(p[1]) || p[1] == '\\'))
+    for (p0 = p; *p0; ++p0) *p0 = p0[1];
+}
+#endif
 
 
+/* --- malware_*_defer --- */
 static inline int
 static inline int
-malware_errlog_defer(const uschar * str)
+malware_panic_defer(const uschar * str)
 {
 log_write(0, LOG_MAIN|LOG_PANIC, "malware acl condition: %s", str);
 return DEFER;
 }
 {
 log_write(0, LOG_MAIN|LOG_PANIC, "malware acl condition: %s", str);
 return DEFER;
 }
-
-static int
-m_errlog_defer(struct scan * scanent, const uschar * str)
+static inline int
+malware_log_defer(const uschar * str)
 {
 {
-return malware_errlog_defer(string_sprintf("%s: %s", scanent->name, str));
+log_write(0, LOG_MAIN, "malware acl condition: %s", str);
+return DEFER;
 }
 }
-static int
-m_errlog_defer_3(struct scan * scanent, const uschar * str,
-       int fd_to_close)
+/* --- m_*_defer --- */
+static inline int
+m_panic_defer(struct scan * scanent, const uschar * hostport,
+  const uschar * str)
+{
+return malware_panic_defer(string_sprintf("%s %s : %s",
+  scanent->name, hostport ? hostport : CUS"", str));
+}
+/* --- m_*_defer_3 */
+static inline int
+m_panic_defer_3(struct scan * scanent, const uschar * hostport,
+  const uschar * str, int fd_to_close)
 {
 {
+DEBUG(D_acl) debug_print_socket(fd_to_close);
 (void) close(fd_to_close);
 (void) close(fd_to_close);
-return m_errlog_defer(scanent, str);
+return m_panic_defer(scanent, hostport, str);
 }
 
 /*************************************************/
 
 }
 
 /*************************************************/
 
+#ifndef DISABLE_MAL_CLAM
 /* Only used by the Clamav code, which is working from a list of servers and
 uses the returned in_addr to get a second connection to the same system.
 */
 static inline int
 m_tcpsocket(const uschar * hostname, unsigned int port,
 /* Only used by the Clamav code, which is working from a list of servers and
 uses the returned in_addr to get a second connection to the same system.
 */
 static inline int
 m_tcpsocket(const uschar * hostname, unsigned int port,
-       host_item * host, uschar ** errstr)
+       host_item * host, uschar ** errstr, const blob * fastopen_blob)
 {
 {
-return ip_connectedsocket(SOCK_STREAM, hostname, port, port, 5, host, errstr);
+int fd = ip_connectedsocket(SOCK_STREAM, hostname, port, port, 5,
+                         host, errstr, fastopen_blob);
+#ifdef EXIM_TFO_FREEBSD
+/* Under some fault conditions, FreeBSD 12.2 seen to send a (non-TFO) SYN
+and, getting no response, wait for a long time.  Impose a 5s max. */
+if (fd >= 0)
+  (void) poll_one_fd(fd, POLLOUT, 5 * 1000);
+#endif
+return fd;
 }
 }
+#endif
 
 static int
 m_sock_send(int sock, uschar * buf, int cnt, uschar ** errstr)
 
 static int
 m_sock_send(int sock, uschar * buf, int cnt, uschar ** errstr)
@@ -156,46 +299,49 @@ if (send(sock, buf, cnt, 0) < 0)
 return sock;
 }
 
 return sock;
 }
 
-static const pcre *
-m_pcre_compile(const uschar * re, uschar ** errstr)
+static const pcre2_code *
+m_pcre_compile(const uschar * re, BOOL cacheable, uschar ** errstr)
 {
 {
-const uschar * rerror;
-int roffset;
-const pcre * cre;
-
-cre = pcre_compile(CS re, PCRE_COPT, (const char **)&rerror, &roffset, NULL);
-if (!cre)
-  *errstr= string_sprintf("regular expression error in '%s': %s at offset %d",
-      re, rerror, roffset);
-return cre;
+return regex_compile(re, cacheable ? MCS_CACHEABLE : MCS_NOFLAGS, errstr,
+                     pcre_gen_cmp_ctx);
 }
 
 uschar *
 }
 
 uschar *
-m_pcre_exec(const pcre * cre, uschar * text)
+m_pcre_exec(const pcre2_code * cre, uschar * text)
 {
 {
-int ovector[10*3];
-int i = pcre_exec(cre, NULL, CS text, Ustrlen(text), 0, 0,
-             ovector, nelements(ovector));
+pcre2_match_data * md = pcre2_match_data_create(2, pcre_gen_ctx);
+int i = pcre2_match(cre, text, PCRE2_ZERO_TERMINATED, 0, 0, md, pcre_gen_mtc_ctx);
 uschar * substr = NULL;
 uschar * substr = NULL;
+
 if (i >= 2)                            /* Got it */
 if (i >= 2)                            /* Got it */
-  pcre_get_substring(CS text, ovector, i, 1, (const char **) &substr);
+  {
+  PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
+  int len = ovec[3] - ovec[2];
+  substr = string_copyn(text + ovec[2], len);
+  }
+/* pcre2_match_data_free(md);  gen ctx needs no free */
 return substr;
 }
 
 return substr;
 }
 
-static const pcre *
+static const pcre2_code *
 m_pcre_nextinlist(const uschar ** list, int * sep,
 m_pcre_nextinlist(const uschar ** list, int * sep,
- char * listerr, uschar ** errstr)
+ BOOL cacheable, char * listerr, uschar ** errstr)
 {
 const uschar * list_ele;
 {
 const uschar * list_ele;
-const pcre * cre = NULL;
+const pcre2_code * cre = NULL;
 
 if (!(list_ele = string_nextinlist(list, sep, NULL, 0)))
   *errstr = US listerr;
 else
 
 if (!(list_ele = string_nextinlist(list, sep, NULL, 0)))
   *errstr = US listerr;
 else
-  cre = m_pcre_compile(CUS list_ele, errstr);
+  {
+  DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "RE: ",
+    string_printing(list_ele));
+  cre = m_pcre_compile(CUS list_ele, cacheable, errstr);
+  }
 return cre;
 }
 
 return cre;
 }
 
+
 /*
  Simple though inefficient wrapper for reading a line.  Drop CRs and the
  trailing newline. Can return early on buffer full. Null-terminate.
 /*
  Simple though inefficient wrapper for reading a line.  Drop CRs and the
  trailing newline. Can return early on buffer full. Null-terminate.
@@ -206,13 +352,13 @@ return cre;
          -2 on timeout or error
 */
 static int
          -2 on timeout or error
 */
 static int
-recv_line(int fd, uschar * buffer, int bsize, int tmo)
+recv_line(int fd, uschar * buffer, int bsize, time_t tmo)
 {
 uschar * p = buffer;
 ssize_t rcv;
 BOOL ok = FALSE;
 
 {
 uschar * p = buffer;
 ssize_t rcv;
 BOOL ok = FALSE;
 
-if (!fd_ready(fd, tmo-time(NULL)))
+if (!fd_ready(fd, tmo))
   return -2;
 
 /*XXX tmo handling assumes we always get a whole line */
   return -2;
 
 /*XXX tmo handling assumes we always get a whole line */
@@ -227,30 +373,37 @@ while ((rcv = read(fd, p, 1)) > 0)
   }
 if (!ok)
   {
   }
 if (!ok)
   {
-  DEBUG(D_acl) debug_printf("Malware scan: read %s (%s)\n",
+  DEBUG(D_acl)
+    {
+    debug_printf_indent("Malware scan: read %s (%s)\n",
                rcv==0 ? "EOF" : "error", strerror(errno));
                rcv==0 ? "EOF" : "error", strerror(errno));
+    debug_print_socket(fd);
+    }
   return rcv==0 ? -1 : -2;
   }
 *p = '\0';
 
   return rcv==0 ? -1 : -2;
   }
 *p = '\0';
 
-DEBUG(D_acl) debug_printf("Malware scan: read '%s'\n", buffer);
+DEBUG(D_acl) debug_printf_indent("Malware scan: read '%s'\n", buffer);
 return p - buffer;
 }
 
 /* return TRUE iff size as requested */
 return p - buffer;
 }
 
 /* return TRUE iff size as requested */
+#ifndef DISABLE_MAL_DRWEB
 static BOOL
 static BOOL
-recv_len(int sock, void * buf, int size, int tmo)
+recv_len(int sock, void * buf, int size, time_t tmo)
 {
 {
-return fd_ready(sock, tmo-time(NULL))
+return fd_ready(sock, tmo)
   ? recv(sock, buf, size, 0) == size
   : FALSE;
 }
   ? recv(sock, buf, size, 0) == size
   : FALSE;
 }
+#endif
 
 
 
 
 
 
+#ifndef DISABLE_MAL_MKS
 /* ============= private routines for the "mksd" scanner type ============== */
 
 /* ============= private routines for the "mksd" scanner type ============== */
 
-#include <sys/uio.h>
+# include <sys/uio.h>
 
 static inline int
 mksd_writev (int sock, struct iovec * iov, int iovcnt)
 
 static inline int
 mksd_writev (int sock, struct iovec * iov, int iovcnt)
@@ -264,7 +417,7 @@ for (;;)
   while (i < 0 && errno == EINTR);
   if (i <= 0)
     {
   while (i < 0 && errno == EINTR);
   if (i <= 0)
     {
-    (void) malware_errlog_defer(
+    (void) malware_panic_defer(
            US"unable to write to mksd UNIX socket (/var/run/mksd/socket)");
     return -1;
     }
            US"unable to write to mksd UNIX socket (/var/run/mksd/socket)");
     return -1;
     }
@@ -286,17 +439,18 @@ for (;;)
 }
 
 static inline int
 }
 
 static inline int
-mksd_read_lines (int sock, uschar *av_buffer, int av_buffer_size, int tmo)
+mksd_read_lines (int sock, uschar *av_buffer, int av_buffer_size, time_t tmo)
 {
 {
+client_conn_ctx cctx = {.sock = sock};
 int offset = 0;
 int i;
 
 do
   {
 int offset = 0;
 int i;
 
 do
   {
-  i = ip_recv(sock, av_buffer+offset, av_buffer_size-offset, tmo-time(NULL));
+  i = ip_recv(&cctx, av_buffer+offset, av_buffer_size-offset, tmo);
   if (i <= 0)
     {
   if (i <= 0)
     {
-    (void) malware_errlog_defer(US"unable to read from mksd UNIX socket (/var/run/mksd/socket)");
+    (void) malware_panic_defer(US"unable to read from mksd UNIX socket (/var/run/mksd/socket)");
     return -1;
     }
 
     return -1;
     }
 
@@ -304,7 +458,7 @@ do
   /* offset == av_buffer_size -> buffer full */
   if (offset == av_buffer_size)
     {
   /* offset == av_buffer_size -> buffer full */
   if (offset == av_buffer_size)
     {
-    (void) malware_errlog_defer(US"malformed reply received from mksd");
+    (void) malware_panic_defer(US"malformed reply received from mksd");
     return -1;
     }
   } while (av_buffer[offset-1] != '\n');
     return -1;
     }
   } while (av_buffer[offset-1] != '\n');
@@ -327,7 +481,7 @@ switch (*line)
   case 'A': /* ERR */
     if ((p = strchr (line, '\n')) != NULL)
       *p = '\0';
   case 'A': /* ERR */
     if ((p = strchr (line, '\n')) != NULL)
       *p = '\0';
-    return m_errlog_defer(scanent,
+    return m_panic_defer(scanent, NULL,
       string_sprintf("scanner failed: %s", line));
 
   default: /* VIR */
       string_sprintf("scanner failed: %s", line));
 
   default: /* VIR */
@@ -345,14 +499,14 @@ switch (*line)
        return OK;
        }
       }
        return OK;
        }
       }
-    return m_errlog_defer(scanent,
+    return m_panic_defer(scanent, NULL,
       string_sprintf("malformed reply received: %s", line));
   }
 }
 
 static int
 mksd_scan_packed(struct scan * scanent, int sock, const uschar * scan_filename,
       string_sprintf("malformed reply received: %s", line));
   }
 }
 
 static int
 mksd_scan_packed(struct scan * scanent, int sock, const uschar * scan_filename,
-  int tmo)
+  time_t tmo)
 {
 struct iovec iov[3];
 const char *cmd = "MSQ\n";
 {
 struct iovec iov[3];
 const char *cmd = "MSQ\n";
@@ -373,8 +527,10 @@ if (mksd_read_lines (sock, av_buffer, sizeof (av_buffer), tmo) < 0)
 
 return mksd_parse_line (scanent, CS av_buffer);
 }
 
 return mksd_parse_line (scanent, CS av_buffer);
 }
+#endif /* MKSD */
 
 
 
 
+#ifndef DISABLE_MAL_CLAM
 static int
 clamd_option(clamd_address * cd, const uschar * optstr, int * subsep)
 {
 static int
 clamd_option(clamd_address * cd, const uschar * optstr, int * subsep)
 {
@@ -393,6 +549,9 @@ while ((s = string_nextinlist(&optstr, subsep, NULL, 0)))
     return FAIL;
 return OK;
 }
     return FAIL;
 return OK;
 }
+#endif
+
+
 
 /*************************************************
 *          Scan content for malware              *
 
 /*************************************************
 *          Scan content for malware              *
@@ -403,115 +562,128 @@ is via malware(), or there's malware_in_file() used for testing/debugging.
 
 Arguments:
   malware_re    match condition for "malware="
 
 Arguments:
   malware_re    match condition for "malware="
-  eml_filename  the file holding the email to be scanned
+  cacheable    the RE did not use any dynamic elements during expansion
+  scan_filename  the file holding the email to be scanned, if we're faking
+               this up for the -bmalware test, else NULL
   timeout      if nonzero, non-default timeoutl
   timeout      if nonzero, non-default timeoutl
-  faking        whether or not we're faking this up for the -bmalware test
 
 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
                 where true means malware was found (condition applies)
 */
 static int
 
 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
                 where true means malware was found (condition applies)
 */
 static int
-malware_internal(const uschar * malware_re, const uschar * eml_filename,
-  int timeout, BOOL faking)
+malware_internal(const uschar * malware_re, BOOL cacheable,
+  const uschar * scan_filename, int timeout)
 {
 int sep = 0;
 const uschar *av_scanner_work = av_scanner;
 {
 int sep = 0;
 const uschar *av_scanner_work = av_scanner;
+BOOL av_scanner_textonly;
 uschar *scanner_name;
 unsigned long mbox_size;
 FILE *mbox_file;
 uschar *scanner_name;
 unsigned long mbox_size;
 FILE *mbox_file;
-const pcre *re;
+const pcre2_code *re;
 uschar * errstr;
 struct scan * scanent;
 const uschar * scanner_options;
 uschar * errstr;
 struct scan * scanent;
 const uschar * scanner_options;
-int sock = -1;
+client_conn_ctx malware_daemon_ctx = {.sock = -1};
 time_t tmo;
 time_t tmo;
-
-/* make sure the eml mbox file is spooled up */
-if (!(mbox_file = spool_mbox(&mbox_size, faking ? eml_filename : NULL)))
-  return malware_errlog_defer(US"error while creating mbox spool file");
-
-/* none of our current scanners need the mbox
-   file as a stream, so we can close it right away */
-(void)fclose(mbox_file);
+uschar * eml_filename, * eml_dir;
 
 if (!malware_re)
   return FAIL;         /* empty means "don't match anything" */
 
 
 if (!malware_re)
   return FAIL;         /* empty means "don't match anything" */
 
+/* Ensure the eml mbox file is spooled up */
+
+if (!(mbox_file = spool_mbox(&mbox_size, scan_filename, &eml_filename)))
+  return malware_panic_defer(US"error while creating mbox spool file");
+
+/* None of our current scanners need the mbox file as a stream (they use
+the name), so we can close it right away.  Get the directory too. */
+
+(void) fclose(mbox_file);
+eml_dir = string_copyn(eml_filename, Ustrrchr(eml_filename, '/') - eml_filename);
+
 /* parse 1st option */
 /* parse 1st option */
-  if ( (strcmpic(malware_re, US"false") == 0) ||
-     (Ustrcmp(malware_re,"0") == 0) )
+if (strcmpic(malware_re, US"false") == 0  ||  Ustrcmp(malware_re, "0") == 0)
   return FAIL;         /* explicitly no matching */
 
 /* special cases (match anything except empty) */
   return FAIL;         /* explicitly no matching */
 
 /* special cases (match anything except empty) */
-if (  strcmpic(malware_re,US"true") == 0
-   || Ustrcmp(malware_re,"*") == 0
-   || Ustrcmp(malware_re,"1") == 0
+if (  strcmpic(malware_re, US"true") == 0
+   || Ustrcmp(malware_re, "*") == 0
+   || Ustrcmp(malware_re, "1") == 0
    )
   {
   if (  !malware_default_re
    )
   {
   if (  !malware_default_re
-     && !(malware_default_re = m_pcre_compile(malware_regex_default, &errstr)))
-    return malware_errlog_defer(errstr);
+     && !(malware_default_re = m_pcre_compile(malware_regex_default, FALSE, &errstr)))
+    return malware_panic_defer(errstr);
   malware_re = malware_regex_default;
   re = malware_default_re;
   }
 
 /* compile the regex, see if it works */
   malware_re = malware_regex_default;
   re = malware_default_re;
   }
 
 /* compile the regex, see if it works */
-else if (!(re = m_pcre_compile(malware_re, &errstr)))
-  return malware_errlog_defer(errstr);
-
-/* Reset sep that is set by previous string_nextinlist() call */
-sep = 0;
+else if (!(re = m_pcre_compile(malware_re, cacheable, &errstr)))
+  return malware_panic_defer(errstr);
 
 /* if av_scanner starts with a dollar, expand it first */
 if (*av_scanner == '$')
   {
 
 /* if av_scanner starts with a dollar, expand it first */
 if (*av_scanner == '$')
   {
-  if (!(av_scanner_work = expand_string(av_scanner)))
-    return malware_errlog_defer(
+  if (!(av_scanner_work = expand_string_2(av_scanner, &av_scanner_textonly)))
+    return malware_panic_defer(
         string_sprintf("av_scanner starts with $, but expansion failed: %s",
         expand_string_message));
 
   DEBUG(D_acl)
         string_sprintf("av_scanner starts with $, but expansion failed: %s",
         expand_string_message));
 
   DEBUG(D_acl)
-    debug_printf("Expanded av_scanner global: %s\n", av_scanner_work);
+    debug_printf_indent("Expanded av_scanner global: %s\n", av_scanner_work);
   /* disable result caching in this case */
   malware_name = NULL;
   malware_ok = FALSE;
   }
   /* disable result caching in this case */
   malware_name = NULL;
   malware_ok = FALSE;
   }
+else
+  av_scanner_textonly = TRUE;
 
 /* Do not scan twice (unless av_scanner is dynamic). */
 if (!malware_ok)
   {
   /* find the scanner type from the av_scanner option */
   if (!(scanner_name = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 
 /* Do not scan twice (unless av_scanner is dynamic). */
 if (!malware_ok)
   {
   /* find the scanner type from the av_scanner option */
   if (!(scanner_name = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
-    return malware_errlog_defer(US"av_scanner configuration variable is empty");
+    return malware_panic_defer(US"av_scanner configuration variable is empty");
   if (!timeout) timeout = MALWARE_TIMEOUT;
   tmo = time(NULL) + timeout;
 
   for (scanent = m_scans; ; scanent++)
     {
     if (!scanent->name)
   if (!timeout) timeout = MALWARE_TIMEOUT;
   tmo = time(NULL) + timeout;
 
   for (scanent = m_scans; ; scanent++)
     {
     if (!scanent->name)
-      return malware_errlog_defer(string_sprintf("unknown scanner type '%s'",
+      return malware_panic_defer(string_sprintf("unknown scanner type '%s'",
        scanner_name));
     if (strcmpic(scanner_name, US scanent->name) != 0)
       continue;
        scanner_name));
     if (strcmpic(scanner_name, US scanent->name) != 0)
       continue;
+    DEBUG(D_acl) debug_printf_indent("Malware scan:  %s tmo=%s\n",
+      scanner_name, readconf_printtime(timeout));
+
     if (!(scanner_options = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
       scanner_options = scanent->options_default;
     if (scanent->conn == MC_NONE)
       break;
     if (!(scanner_options = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
       scanner_options = scanent->options_default;
     if (scanent->conn == MC_NONE)
       break;
+
+    DEBUG(D_acl) debug_printf_indent("%15s%10s%s\n", "", "socket: ", scanner_options);
     switch(scanent->conn)
     {
     switch(scanent->conn)
     {
-    case MC_TCP:  sock = ip_tcpsocket(scanner_options, &errstr, 5);      break;
-    case MC_UNIX: sock = ip_unixsocket(scanner_options, &errstr);        break;
-    case MC_STRM: sock = ip_streamsocket(scanner_options, &errstr, 5);  break;
-    default: /* compiler quietening */ break;
+    case MC_TCP:
+      malware_daemon_ctx.sock = ip_tcpsocket(scanner_options, &errstr, 5, NULL); break;
+    case MC_UNIX:
+      malware_daemon_ctx.sock = ip_unixsocket(scanner_options, &errstr);       break;
+    case MC_STRM:
+      malware_daemon_ctx.sock = ip_streamsocket(scanner_options, &errstr, 5, NULL); break;
+    default:
+      /* compiler quietening */ break;
     }
     }
-    if (sock < 0)
-      return m_errlog_defer(scanent, errstr);
+    if (malware_daemon_ctx.sock < 0)
+      return m_panic_defer(scanent, CUS callout_address, errstr);
     break;
   }
     break;
   }
-  DEBUG(D_acl) debug_printf("Malware scan: %s tmo %s\n", scanner_name, readconf_printtime(timeout));
 
   switch (scanent->scancode)
     {
 
   switch (scanent->scancode)
     {
+#ifndef DISABLE_MAL_FFROTD
     case M_FPROTD: /* "f-protd" scanner type -------------------------------- */
       {
       uschar *fp_scan_option;
     case M_FPROTD: /* "f-protd" scanner type -------------------------------- */
       {
       uschar *fp_scan_option;
@@ -531,14 +703,14 @@ if (!malware_ok)
        par_count++;
        }
       scanrequest = string_sprintf("%s HTTP/1.0\r\n\r\n", scanrequest);
        par_count++;
        }
       scanrequest = string_sprintf("%s HTTP/1.0\r\n\r\n", scanrequest);
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s: %s\n",
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s: %s\n",
        scanner_name, scanrequest);
 
       /* send scan request */
        scanner_name, scanrequest);
 
       /* send scan request */
-      if (m_sock_send(sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
 
-      while ((len = recv_line(sock, buf, sizeof(buf), tmo)) >= 0)
+      while ((len = recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo)) >= 0)
        if (len > 0)
          {
          if (Ustrstr(buf, US"<detected type=\"") != NULL)
        if (len > 0)
          {
          if (Ustrstr(buf, US"<detected type=\"") != NULL)
@@ -560,12 +732,59 @@ if (!malware_ok)
          }
       if (len < -1)
        {
          }
       if (len < -1)
        {
-       (void)close(sock);
+       (void)close(malware_daemon_ctx.sock);
        return DEFER;
        }
       break;
       }        /* f-protd */
        return DEFER;
        }
       break;
       }        /* f-protd */
+#endif
+
+#ifndef DISABLE_MAL_FFROT6D
+    case M_FPROT6D: /* "f-prot6d" scanner type ----------------------------------- */
+      {
+      int bread;
+      uschar * e, * linebuffer, * scanrequest;
+      uschar av_buffer[1024];
+
+      if ((!fprot6d_re_virus && !(fprot6d_re_virus = m_pcre_compile(fprot6d_re_virus_str, FALSE, &errstr)))
+        || (!fprot6d_re_error && !(fprot6d_re_error = m_pcre_compile(fprot6d_re_error_str, FALSE, &errstr))))
+        return malware_panic_defer(errstr);
+
+      scanrequest = string_sprintf("SCAN FILE %s\n", eml_filename);
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s: %s\n",
+        scanner_name, scanrequest);
+
+      if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest), &errstr) < 0)
+        return m_panic_defer(scanent, CUS callout_address, errstr);
+
+      bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo);
+
+      if (bread <= 0)
+        return m_panic_defer_3(scanent, CUS callout_address,
+          string_sprintf("unable to read from socket (%s)", strerror(errno)),
+          malware_daemon_ctx.sock);
+
+      if (bread == sizeof(av_buffer))
+        return m_panic_defer_3(scanent, CUS callout_address,
+          US"buffer too small", malware_daemon_ctx.sock);
+
+      av_buffer[bread] = '\0';
+      linebuffer = string_copy(av_buffer);
+
+      m_sock_send(malware_daemon_ctx.sock, US"QUIT\n", 5, 0);
 
 
+      if ((e = m_pcre_exec(fprot6d_re_error, linebuffer)))
+        return m_panic_defer_3(scanent, CUS callout_address,
+          string_sprintf("scanner reported error (%s)", e), malware_daemon_ctx.sock);
+
+      if (!(malware_name = m_pcre_exec(fprot6d_re_virus, linebuffer)))
+        malware_name = NULL;
+
+      break;
+      }  /* f-prot6d */
+#endif
+
+#ifndef DISABLE_MAL_DRWEB
     case M_DRWEB: /* "drweb" scanner type ----------------------------------- */
   /* v0.1 - added support for tcp sockets          */
   /* v0.0 - initial release -- support for unix sockets      */
     case M_DRWEB: /* "drweb" scanner type ----------------------------------- */
   /* v0.1 - added support for tcp sockets          */
   /* v0.0 - initial release -- support for unix sockets      */
@@ -584,157 +803,161 @@ if (!malware_ok)
       if (*scanner_options != '/')
        {
        /* calc file size */
       if (*scanner_options != '/')
        {
        /* calc file size */
-       if ((drweb_fd = open(CCS eml_filename, O_RDONLY)) == -1)
-         return m_errlog_defer_3(scanent,
+       if ((drweb_fd = exim_open2(CCS eml_filename, O_RDONLY)) == -1)
+         return m_panic_defer_3(scanent, NULL,
            string_sprintf("can't open spool file %s: %s",
              eml_filename, strerror(errno)),
            string_sprintf("can't open spool file %s: %s",
              eml_filename, strerror(errno)),
-           sock);
+           malware_daemon_ctx.sock);
 
        if ((fsize = lseek(drweb_fd, 0, SEEK_END)) == -1)
          {
 
        if ((fsize = lseek(drweb_fd, 0, SEEK_END)) == -1)
          {
-         int err = errno;
+         int err;
+badseek:  err = errno;
          (void)close(drweb_fd);
          (void)close(drweb_fd);
-         return m_errlog_defer_3(scanent,
+         return m_panic_defer_3(scanent, NULL,
            string_sprintf("can't seek spool file %s: %s",
              eml_filename, strerror(err)),
            string_sprintf("can't seek spool file %s: %s",
              eml_filename, strerror(err)),
-           sock);
+           malware_daemon_ctx.sock);
          }
        fsize_uint = (unsigned int) fsize;
        if ((off_t)fsize_uint != fsize)
          {
          (void)close(drweb_fd);
          }
        fsize_uint = (unsigned int) fsize;
        if ((off_t)fsize_uint != fsize)
          {
          (void)close(drweb_fd);
-         return m_errlog_defer_3(scanent,
+         return m_panic_defer_3(scanent, NULL,
            string_sprintf("seeking spool file %s, size overflow",
              eml_filename),
            string_sprintf("seeking spool file %s, size overflow",
              eml_filename),
-           sock);
+           malware_daemon_ctx.sock);
          }
        drweb_slen = htonl(fsize);
          }
        drweb_slen = htonl(fsize);
-       lseek(drweb_fd, 0, SEEK_SET);
+       if (lseek(drweb_fd, 0, SEEK_SET) < 0)
+         goto badseek;
 
 
-       DEBUG(D_acl) debug_printf("Malware scan: issuing %s remote scan [%s]\n",
+       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s remote scan [%s]\n",
            scanner_name, scanner_options);
 
        /* send scan request */
            scanner_name, scanner_options);
 
        /* send scan request */
-       if ((send(sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
-           (send(sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
-           (send(sock, &drweb_fin, sizeof(drweb_fin), 0) < 0) ||
-           (send(sock, &drweb_slen, sizeof(drweb_slen), 0) < 0))
+       if ((send(malware_daemon_ctx.sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, &drweb_fin, sizeof(drweb_fin), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), 0) < 0))
          {
          (void)close(drweb_fd);
          {
          (void)close(drweb_fd);
-         return m_errlog_defer_3(scanent, string_sprintf(
+         return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
            "unable to send commands to socket (%s)", scanner_options),
            "unable to send commands to socket (%s)", scanner_options),
-           sock);
+           malware_daemon_ctx.sock);
          }
 
          }
 
-       if (!(drweb_fbuf = (uschar *) malloc (fsize_uint)))
+       if (!(drweb_fbuf = store_malloc(fsize_uint)))
          {
          (void)close(drweb_fd);
          {
          (void)close(drweb_fd);
-         return m_errlog_defer_3(scanent,
+         return m_panic_defer_3(scanent, NULL,
            string_sprintf("unable to allocate memory %u for file (%s)",
              fsize_uint, eml_filename),
            string_sprintf("unable to allocate memory %u for file (%s)",
              fsize_uint, eml_filename),
-           sock);
+           malware_daemon_ctx.sock);
          }
 
        if ((result = read (drweb_fd, drweb_fbuf, fsize)) == -1)
          {
          int err = errno;
          (void)close(drweb_fd);
          }
 
        if ((result = read (drweb_fd, drweb_fbuf, fsize)) == -1)
          {
          int err = errno;
          (void)close(drweb_fd);
-         free(drweb_fbuf);
-         return m_errlog_defer_3(scanent,
+         store_free(drweb_fbuf);
+         return m_panic_defer_3(scanent, NULL,
            string_sprintf("can't read spool file %s: %s",
              eml_filename, strerror(err)),
            string_sprintf("can't read spool file %s: %s",
              eml_filename, strerror(err)),
-           sock);
+           malware_daemon_ctx.sock);
          }
        (void)close(drweb_fd);
 
        /* send file body to socket */
          }
        (void)close(drweb_fd);
 
        /* send file body to socket */
-       if (send(sock, drweb_fbuf, fsize, 0) < 0)
+       if (send(malware_daemon_ctx.sock, drweb_fbuf, fsize, 0) < 0)
          {
          {
-         free(drweb_fbuf);
-         return m_errlog_defer_3(scanent, string_sprintf(
+         store_free(drweb_fbuf);
+         return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
            "unable to send file body to socket (%s)", scanner_options),
            "unable to send file body to socket (%s)", scanner_options),
-           sock);
+           malware_daemon_ctx.sock);
          }
          }
-       (void)close(drweb_fd);
+       store_free(drweb_fbuf);
        }
       else
        {
        drweb_slen = htonl(Ustrlen(eml_filename));
 
        }
       else
        {
        drweb_slen = htonl(Ustrlen(eml_filename));
 
-       DEBUG(D_acl) debug_printf("Malware scan: issuing %s local scan [%s]\n",
+       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s local scan [%s]\n",
            scanner_name, scanner_options);
 
        /* send scan request */
            scanner_name, scanner_options);
 
        /* send scan request */
-       if ((send(sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
-           (send(sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
-           (send(sock, &drweb_slen, sizeof(drweb_slen), 0) < 0) ||
-           (send(sock, eml_filename, Ustrlen(eml_filename), 0) < 0) ||
-           (send(sock, &drweb_fin, sizeof(drweb_fin), 0) < 0))
-         return m_errlog_defer_3(scanent, string_sprintf(
+       if ((send(malware_daemon_ctx.sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, eml_filename, Ustrlen(eml_filename), 0) < 0) ||
+           (send(malware_daemon_ctx.sock, &drweb_fin, sizeof(drweb_fin), 0) < 0))
+         return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
            "unable to send commands to socket (%s)", scanner_options),
            "unable to send commands to socket (%s)", scanner_options),
-           sock);
+           malware_daemon_ctx.sock);
        }
 
       /* wait for result */
        }
 
       /* wait for result */
-      if (!recv_len(sock, &drweb_rc, sizeof(drweb_rc), tmo))
-       return m_errlog_defer_3(scanent,
-                   US"unable to read return code", sock);
+      if (!recv_len(malware_daemon_ctx.sock, &drweb_rc, sizeof(drweb_rc), tmo))
+       return m_panic_defer_3(scanent, CUS callout_address,
+                   US"unable to read return code", malware_daemon_ctx.sock);
       drweb_rc = ntohl(drweb_rc);
 
       drweb_rc = ntohl(drweb_rc);
 
-      if (!recv_len(sock, &drweb_vnum, sizeof(drweb_vnum), tmo))
-       return m_errlog_defer_3(scanent,
-                           US"unable to read the number of viruses", sock);
+      if (!recv_len(malware_daemon_ctx.sock, &drweb_vnum, sizeof(drweb_vnum), tmo))
+       return m_panic_defer_3(scanent, CUS callout_address,
+                           US"unable to read the number of viruses", malware_daemon_ctx.sock);
       drweb_vnum = ntohl(drweb_vnum);
 
       /* "virus(es) found" if virus number is > 0 */
       if (drweb_vnum)
        {
       drweb_vnum = ntohl(drweb_vnum);
 
       /* "virus(es) found" if virus number is > 0 */
       if (drweb_vnum)
        {
-       int i;
+       gstring * g = NULL;
 
        /* setup default virus name */
        malware_name = US"unknown";
 
        /* set up match regex */
        if (!drweb_re)
 
        /* setup default virus name */
        malware_name = US"unknown";
 
        /* set up match regex */
        if (!drweb_re)
-         drweb_re = m_pcre_compile(drweb_re_str, &errstr);
+         drweb_re = m_pcre_compile(drweb_re_str, FALSE, &errstr);
 
        /* read and concatenate virus names into one string */
 
        /* read and concatenate virus names into one string */
-       for (i = 0; i < drweb_vnum; i++)
+       for (int i = 0; i < drweb_vnum; i++)
          {
          {
-         int size = 0, off = 0, ovector[10*3];
+         pcre2_match_data * md = pcre2_match_data_create(2, pcre_gen_ctx);
+
          /* read the size of report */
          /* read the size of report */
-         if (!recv_len(sock, &drweb_slen, sizeof(drweb_slen), tmo))
-           return m_errlog_defer_3(scanent,
-                             US"cannot read report size", sock);
+         if (!recv_len(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), tmo))
+           return m_panic_defer_3(scanent, CUS callout_address,
+                             US"cannot read report size", malware_daemon_ctx.sock);
          drweb_slen = ntohl(drweb_slen);
          drweb_slen = ntohl(drweb_slen);
-         tmpbuf = store_get(drweb_slen);
+
+         /* assume tainted, since it is external input */
+         tmpbuf = store_get(drweb_slen, GET_TAINTED);
 
          /* read report body */
 
          /* read report body */
-         if (!recv_len(sock, tmpbuf, drweb_slen, tmo))
-           return m_errlog_defer_3(scanent,
-                             US"cannot read report string", sock);
+         if (!recv_len(malware_daemon_ctx.sock, tmpbuf, drweb_slen, tmo))
+           return m_panic_defer_3(scanent, CUS callout_address,
+                             US"cannot read report string", malware_daemon_ctx.sock);
          tmpbuf[drweb_slen] = '\0';
 
          /* try matcher on the line, grab substring */
          tmpbuf[drweb_slen] = '\0';
 
          /* try matcher on the line, grab substring */
-         result = pcre_exec(drweb_re, NULL, CS tmpbuf, Ustrlen(tmpbuf), 0, 0,
-                                 ovector, nelements(ovector));
+         result = pcre2_match(drweb_re, (PCRE2_SPTR)tmpbuf, PCRE2_ZERO_TERMINATED,
+                               0, 0, md, pcre_gen_mtc_ctx);
          if (result >= 2)
            {
          if (result >= 2)
            {
-           const char * pre_malware_nb;
-
-           pcre_get_substring(CS tmpbuf, ovector, result, 1, &pre_malware_nb);
+           PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
 
            if (i==0)   /* the first name we just copy to malware_name */
 
            if (i==0)   /* the first name we just copy to malware_name */
-             malware_name = string_append(NULL, &size, &off,
-                                         1, pre_malware_nb);
+             g = string_catn(NULL, US ovec[2], ovec[3] - ovec[2]);
 
            else        /* concatenate each new virus name to previous */
 
            else        /* concatenate each new virus name to previous */
-             malware_name = string_append(malware_name, &size, &off,
-                                         2, "/", pre_malware_nb);
-
-           pcre_free_substring(pre_malware_nb);
+             {
+             g = string_catn(g, US"/", 1);
+             g = string_catn(g, US ovec[2], ovec[3] - ovec[2]);
+             }
            }
            }
+         /* pcre2_match_data_free(md); gen ctx needs no free */
          }
          }
+         malware_name = string_from_gstring(g);
        }
       else
        {
        }
       else
        {
@@ -749,16 +972,18 @@ if (!malware_ok)
         * DERR_CRC_ERROR, DERR_READSOCKET, DERR_WRITE_ERR
         * and others are ignored */
        if (drweb_s)
         * DERR_CRC_ERROR, DERR_READSOCKET, DERR_WRITE_ERR
         * and others are ignored */
        if (drweb_s)
-         return m_errlog_defer_3(scanent,
+         return m_panic_defer_3(scanent, CUS callout_address,
            string_sprintf("drweb daemon retcode 0x%x (%s)", drweb_rc, drweb_s),
            string_sprintf("drweb daemon retcode 0x%x (%s)", drweb_rc, drweb_s),
-           sock);
+           malware_daemon_ctx.sock);
 
        /* no virus found */
        malware_name = NULL;
        }
       break;
       }        /* drweb */
 
        /* no virus found */
        malware_name = NULL;
        }
       break;
       }        /* drweb */
+#endif
 
 
+#ifndef DISABLE_MAL_AVE
     case M_AVES: /* "aveserver" scanner type -------------------------------- */
       {
       uschar buf[32768];
     case M_AVES: /* "aveserver" scanner type -------------------------------- */
       {
       uschar buf[32768];
@@ -766,34 +991,34 @@ if (!malware_ok)
 
       /* read aveserver's greeting and see if it is ready (2xx greeting) */
       buf[0] = 0;
 
       /* read aveserver's greeting and see if it is ready (2xx greeting) */
       buf[0] = 0;
-      recv_line(sock, buf, sizeof(buf), tmo);
+      recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo);
 
       if (buf[0] != '2')               /* aveserver is having problems */
 
       if (buf[0] != '2')               /* aveserver is having problems */
-       return m_errlog_defer_3(scanent,
+       return m_panic_defer_3(scanent, CUS callout_address,
          string_sprintf("unavailable (Responded: %s).",
          string_sprintf("unavailable (Responded: %s).",
-                         ((buf[0] != 0) ? buf : (uschar *)"nothing") ),
-         sock);
+                         ((buf[0] != 0) ? buf : US "nothing") ),
+         malware_daemon_ctx.sock);
 
       /* prepare our command */
       (void)string_format(buf, sizeof(buf), "SCAN bPQRSTUW %s\r\n",
                                                eml_filename);
 
       /* and send it */
 
       /* prepare our command */
       (void)string_format(buf, sizeof(buf), "SCAN bPQRSTUW %s\r\n",
                                                eml_filename);
 
       /* and send it */
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s %s\n",
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s %s\n",
        scanner_name, buf);
        scanner_name, buf);
-      if (m_sock_send(sock, buf, Ustrlen(buf), &errstr) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if (m_sock_send(malware_daemon_ctx.sock, buf, Ustrlen(buf), &errstr) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
       malware_name = NULL;
       result = 0;
       /* read response lines, find malware name and final response */
 
       malware_name = NULL;
       result = 0;
       /* read response lines, find malware name and final response */
-      while (recv_line(sock, buf, sizeof(buf), tmo) > 0)
+      while (recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo) > 0)
        {
        if (buf[0] == '2')
          break;
        if (buf[0] == '5')              /* aveserver is having problems */
          {
        {
        if (buf[0] == '2')
          break;
        if (buf[0] == '5')              /* aveserver is having problems */
          {
-         result = m_errlog_defer(scanent,
+         result = m_panic_defer(scanent, CUS callout_address,
             string_sprintf("unable to scan file %s (Responded: %s).",
                             eml_filename, buf));
          break;
             string_sprintf("unable to scan file %s (Responded: %s).",
                             eml_filename, buf));
          break;
@@ -806,30 +1031,32 @@ if (!malware_ok)
          }
        }
 
          }
        }
 
-      if (m_sock_send(sock, US"quit\r\n", 6, &errstr) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if (m_sock_send(malware_daemon_ctx.sock, US"quit\r\n", 6, &errstr) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
       /* read aveserver's greeting and see if it is ready (2xx greeting) */
       buf[0] = 0;
 
       /* read aveserver's greeting and see if it is ready (2xx greeting) */
       buf[0] = 0;
-      recv_line(sock, buf, sizeof(buf), tmo);
+      recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo);
 
       if (buf[0] != '2')               /* aveserver is having problems */
 
       if (buf[0] != '2')               /* aveserver is having problems */
-       return m_errlog_defer_3(scanent,
+       return m_panic_defer_3(scanent, CUS callout_address,
          string_sprintf("unable to quit dialogue (Responded: %s).",
          string_sprintf("unable to quit dialogue (Responded: %s).",
-                       ((buf[0] != 0) ? buf : (uschar *)"nothing") ),
-         sock);
+                       ((buf[0] != 0) ? buf : US "nothing") ),
+         malware_daemon_ctx.sock);
 
       if (result == DEFER)
        {
 
       if (result == DEFER)
        {
-       (void)close(sock);
+       (void)close(malware_daemon_ctx.sock);
        return DEFER;
        }
       break;
       }        /* aveserver */
        return DEFER;
        }
       break;
       }        /* aveserver */
+#endif
 
 
+#ifndef DISABLE_MAL_FSECURE
     case M_FSEC: /* "fsecure" scanner type ---------------------------------- */
       {
     case M_FSEC: /* "fsecure" scanner type ---------------------------------- */
       {
-      int i, j, bread = 0;
+      int i, bread = 0;
       uschar * file_name;
       uschar av_buffer[1024];
       static uschar *cmdopt[] = { US"CONFIGURE\tARCHIVE\t1\n",
       uschar * file_name;
       uschar av_buffer[1024];
       static uschar *cmdopt[] = { US"CONFIGURE\tARCHIVE\t1\n",
@@ -839,23 +1066,23 @@ if (!malware_ok)
 
       malware_name = NULL;
 
 
       malware_name = NULL;
 
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
          scanner_name, scanner_options);
       /* pass options */
       memset(av_buffer, 0, sizeof(av_buffer));
          scanner_name, scanner_options);
       /* pass options */
       memset(av_buffer, 0, sizeof(av_buffer));
-      for (i = 0; i != nelements(cmdopt); i++)
+      for (i = 0; i != nelem(cmdopt); i++)
        {
 
        {
 
-       if (m_sock_send(sock, cmdopt[i], Ustrlen(cmdopt[i]), &errstr) < 0)
-         return m_errlog_defer(scanent, errstr);
+       if (m_sock_send(malware_daemon_ctx.sock, cmdopt[i], Ustrlen(cmdopt[i]), &errstr) < 0)
+         return m_panic_defer(scanent, CUS callout_address, errstr);
 
 
-       bread = ip_recv(sock, av_buffer, sizeof(av_buffer), tmo-time(NULL));
+       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo);
        if (bread > 0) av_buffer[bread]='\0';
        if (bread < 0)
        if (bread > 0) av_buffer[bread]='\0';
        if (bread < 0)
-         return m_errlog_defer_3(scanent,
+         return m_panic_defer_3(scanent, CUS callout_address,
            string_sprintf("unable to read answer %d (%s)", i, strerror(errno)),
            string_sprintf("unable to read answer %d (%s)", i, strerror(errno)),
-           sock);
-       for (j = 0; j < bread; j++)
+           malware_daemon_ctx.sock);
+       for (int j = 0; j < bread; j++)
          if (av_buffer[j] == '\r' || av_buffer[j] == '\n')
            av_buffer[j] ='@';
        }
          if (av_buffer[j] == '\r' || av_buffer[j] == '\n')
            av_buffer[j] ='@';
        }
@@ -863,13 +1090,13 @@ if (!malware_ok)
       /* pass the mailfile to fsecure */
       file_name = string_sprintf("SCAN\t%s\n", eml_filename);
 
       /* pass the mailfile to fsecure */
       file_name = string_sprintf("SCAN\t%s\n", eml_filename);
 
-      if (m_sock_send(sock, file_name, Ustrlen(file_name), &errstr) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if (m_sock_send(malware_daemon_ctx.sock, file_name, Ustrlen(file_name), &errstr) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
       /* set up match */
       /* todo also SUSPICION\t */
       if (!fsec_re)
 
       /* set up match */
       /* todo also SUSPICION\t */
       if (!fsec_re)
-       fsec_re = m_pcre_compile(fsec_re_str, &errstr);
+       fsec_re = m_pcre_compile(fsec_re_str, FALSE, &errstr);
 
       /* read report, linewise. Apply a timeout as the Fsecure daemon
       sometimes wants an answer to "PING" but they won't tell us what */
 
       /* read report, linewise. Apply a timeout as the Fsecure daemon
       sometimes wants an answer to "PING" but they won't tell us what */
@@ -879,14 +1106,14 @@ if (!malware_ok)
 
        for (;;)
          {
 
        for (;;)
          {
-         errno = ETIME;
+         errno = ETIMEDOUT;
          i =  av_buffer+sizeof(av_buffer)-p;
          i =  av_buffer+sizeof(av_buffer)-p;
-         if ((bread= ip_recv(sock, p, i-1, tmo-time(NULL))) < 0)
-           return m_errlog_defer_3(scanent,
+         if ((bread= ip_recv(&malware_daemon_ctx, p, i-1, tmo)) < 0)
+           return m_panic_defer_3(scanent, CUS callout_address,
              string_sprintf("unable to read result (%s)", strerror(errno)),
              string_sprintf("unable to read result (%s)", strerror(errno)),
-             sock);
+             malware_daemon_ctx.sock);
 
 
-         for (p[bread] = '\0'; q = Ustrchr(p, '\n'); p = q+1)
+         for (p[bread] = '\0'; (q = Ustrchr(p, '\n')); p = q+1)
            {
            *q = '\0';
 
            {
            *q = '\0';
 
@@ -909,15 +1136,18 @@ if (!malware_ok)
       fsec_found:
        break;
       }        /* fsecure */
       fsec_found:
        break;
       }        /* fsecure */
+#endif
 
 
+#ifndef DISABLE_MAL_KAV
     case M_KAVD: /* "kavdaemon" scanner type -------------------------------- */
       {
       time_t t;
       uschar tmpbuf[1024];
       uschar * scanrequest;
       int kav_rc;
     case M_KAVD: /* "kavdaemon" scanner type -------------------------------- */
       {
       time_t t;
       uschar tmpbuf[1024];
       uschar * scanrequest;
       int kav_rc;
-      unsigned long kav_reportlen, bread;
-      const pcre *kav_re;
+      unsigned long kav_reportlen;
+      int bread;
+      const pcre2_code *kav_re;
       uschar *p;
 
       /* get current date and time, build scan request */
       uschar *p;
 
       /* get current date and time, build scan request */
@@ -934,35 +1164,35 @@ if (!malware_ok)
       if (p)
        *p = '\0';
 
       if (p)
        *p = '\0';
 
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
          scanner_name, scanner_options);
 
       /* send scan request */
          scanner_name, scanner_options);
 
       /* send scan request */
-      if (m_sock_send(sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
       /* wait for result */
 
       /* wait for result */
-      if (!recv_len(sock, tmpbuf, 2, tmo))
-       return m_errlog_defer_3(scanent,
-                           US"unable to read 2 bytes from socket.", sock);
+      if (!recv_len(malware_daemon_ctx.sock, tmpbuf, 2, tmo))
+       return m_panic_defer_3(scanent, CUS callout_address,
+                           US"unable to read 2 bytes from socket.", malware_daemon_ctx.sock);
 
       /* get errorcode from one nibble */
       kav_rc = tmpbuf[ test_byte_order()==LITTLE_MY_ENDIAN ? 0 : 1 ] & 0x0F;
       switch(kav_rc)
       {
       case 5: case 6: /* improper kavdaemon configuration */
 
       /* get errorcode from one nibble */
       kav_rc = tmpbuf[ test_byte_order()==LITTLE_MY_ENDIAN ? 0 : 1 ] & 0x0F;
       switch(kav_rc)
       {
       case 5: case 6: /* improper kavdaemon configuration */
-       return m_errlog_defer_3(scanent,
+       return m_panic_defer_3(scanent, CUS callout_address,
                US"please reconfigure kavdaemon to NOT disinfect or remove infected files.",
                US"please reconfigure kavdaemon to NOT disinfect or remove infected files.",
-               sock);
+               malware_daemon_ctx.sock);
       case 1:
       case 1:
-       return m_errlog_defer_3(scanent,
-               US"reported 'scanning not completed' (code 1).", sock);
+       return m_panic_defer_3(scanent, CUS callout_address,
+               US"reported 'scanning not completed' (code 1).", malware_daemon_ctx.sock);
       case 7:
       case 7:
-       return m_errlog_defer_3(scanent,
-               US"reported 'kavdaemon damaged' (code 7).", sock);
+       return m_panic_defer_3(scanent, CUS callout_address,
+               US"reported 'kavdaemon damaged' (code 7).", malware_daemon_ctx.sock);
       }
 
       }
 
-      /* code 8 is not handled, since it is ambigous. It appears mostly on
+      /* code 8 is not handled, since it is ambiguous. It appears mostly on
       bounces where part of a file has been cut off */
 
       /* "virus found" return codes (2-4) */
       bounces where part of a file has been cut off */
 
       /* "virus found" return codes (2-4) */
@@ -979,9 +1209,9 @@ if (!malware_ok)
        if (report_flag == 1)
          {
          /* read report size */
        if (report_flag == 1)
          {
          /* read report size */
-         if (!recv_len(sock, &kav_reportlen, 4, tmo))
-           return m_errlog_defer_3(scanent,
-                 US"cannot read report size", sock);
+         if (!recv_len(malware_daemon_ctx.sock, &kav_reportlen, 4, tmo))
+           return m_panic_defer_3(scanent, CUS callout_address,
+                 US"cannot read report size", malware_daemon_ctx.sock);
 
          /* it's possible that avp returns av_buffer[1] == 1 but the
          reportsize is 0 (!?) */
 
          /* it's possible that avp returns av_buffer[1] == 1 but the
          reportsize is 0 (!?) */
@@ -990,19 +1220,21 @@ if (!malware_ok)
            /* set up match regex, depends on retcode */
            if (kav_rc == 3)
              {
            /* set up match regex, depends on retcode */
            if (kav_rc == 3)
              {
-             if (!kav_re_sus) kav_re_sus = m_pcre_compile(kav_re_sus_str, &errstr);
+             if (!kav_re_sus) kav_re_sus = m_pcre_compile(kav_re_sus_str, FALSE, &errstr);
              kav_re = kav_re_sus;
              }
            else
              {
              kav_re = kav_re_sus;
              }
            else
              {
-             if (!kav_re_inf) kav_re_inf = m_pcre_compile(kav_re_inf_str, &errstr);
+             if (!kav_re_inf) kav_re_inf = m_pcre_compile(kav_re_inf_str, FALSE, &errstr);
              kav_re = kav_re_inf;
              }
 
              kav_re = kav_re_inf;
              }
 
-           /* read report, linewise */
+           /* read report, linewise.  Using size from stream to read amount of data
+           from same stream is safe enough. */
+           /* coverity[tainted_data] */
            while (kav_reportlen > 0)
              {
            while (kav_reportlen > 0)
              {
-             if ((bread = recv_line(sock, tmpbuf, sizeof(tmpbuf), tmo)) < 0)
+             if ((bread = recv_line(malware_daemon_ctx.sock, tmpbuf, sizeof(tmpbuf), tmo)) < 0)
                break;
              kav_reportlen -= bread+1;
 
                break;
              kav_reportlen -= bread+1;
 
@@ -1018,12 +1250,14 @@ if (!malware_ok)
 
       break;
       }
 
       break;
       }
+#endif
 
 
+#ifndef DISABLE_MAL_CMDLINE
     case M_CMDL: /* "cmdline" scanner type ---------------------------------- */
       {
       const uschar *cmdline_scanner = scanner_options;
     case M_CMDL: /* "cmdline" scanner type ---------------------------------- */
       {
       const uschar *cmdline_scanner = scanner_options;
-      const pcre *cmdline_trigger_re;
-      const pcre *cmdline_regex_re;
+      const pcre2_code *cmdline_trigger_re;
+      const pcre2_code *cmdline_regex_re;
       uschar * file_name;
       uschar * commandline;
       void (*eximsigchld)(int);
       uschar * file_name;
       uschar * commandline;
       void (*eximsigchld)(int);
@@ -1037,19 +1271,19 @@ if (!malware_ok)
       uschar *p;
 
       if (!cmdline_scanner)
       uschar *p;
 
       if (!cmdline_scanner)
-       return m_errlog_defer(scanent, errstr);
+       return m_panic_defer(scanent, NULL, errstr);
 
       /* find scanner output trigger */
 
       /* find scanner output trigger */
-      cmdline_trigger_re = m_pcre_nextinlist(&av_scanner_work, &sep,
+      cmdline_trigger_re = m_pcre_nextinlist(&av_scanner_work, &sep, av_scanner_textonly,
                                "missing trigger specification", &errstr);
       if (!cmdline_trigger_re)
                                "missing trigger specification", &errstr);
       if (!cmdline_trigger_re)
-       return m_errlog_defer(scanent, errstr);
+       return m_panic_defer(scanent, NULL, errstr);
 
       /* find scanner name regex */
 
       /* find scanner name regex */
-      cmdline_regex_re = m_pcre_nextinlist(&av_scanner_work, &sep,
+      cmdline_regex_re = m_pcre_nextinlist(&av_scanner_work, &sep, av_scanner_textonly,
                          "missing virus name regex specification", &errstr);
       if (!cmdline_regex_re)
                          "missing virus name regex specification", &errstr);
       if (!cmdline_regex_re)
-       return m_errlog_defer(scanent, errstr);
+       return m_panic_defer(scanent, NULL, errstr);
 
       /* prepare scanner call; despite the naming, file_name holds a directory
       name which is documented as the value given to %s. */
 
       /* prepare scanner call; despite the naming, file_name holds a directory
       name which is documented as the value given to %s. */
@@ -1063,7 +1297,7 @@ if (!malware_ok)
       /* redirect STDERR too */
       commandline = string_sprintf("%s 2>&1", commandline);
 
       /* redirect STDERR too */
       commandline = string_sprintf("%s 2>&1", commandline);
 
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
              scanner_name, commandline);
 
       /* store exims signal handlers */
              scanner_name, commandline);
 
       /* store exims signal handlers */
@@ -1074,20 +1308,19 @@ if (!malware_ok)
        {
        int err = errno;
        signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
        {
        int err = errno;
        signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
-       return m_errlog_defer(scanent,
+       return m_panic_defer(scanent, NULL,
          string_sprintf("call (%s) failed: %s.", commandline, strerror(err)));
        }
       scanner_fd = fileno(scanner_out);
 
          string_sprintf("call (%s) failed: %s.", commandline, strerror(err)));
        }
       scanner_fd = fileno(scanner_out);
 
-      file_name = string_sprintf("%s/scan/%s/%s_scanner_output",
-                               spool_directory, message_id, message_id);
+      file_name = string_sprintf("%s/%s_scanner_output", eml_dir, message_id);
 
       if (!(scanner_record = modefopen(file_name, "wb", SPOOL_MODE)))
        {
        int err = errno;
        (void) pclose(scanner_out);
        signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
 
       if (!(scanner_record = modefopen(file_name, "wb", SPOOL_MODE)))
        {
        int err = errno;
        (void) pclose(scanner_out);
        signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
-       return m_errlog_defer(scanent, string_sprintf(
+       return m_panic_defer(scanent, NULL, string_sprintf(
            "opening scanner output file (%s) failed: %s.",
            file_name, strerror(err)));
        }
            "opening scanner output file (%s) failed: %s.",
            file_name, strerror(err)));
        }
@@ -1103,7 +1336,7 @@ if (!malware_ok)
            break;
          (void) pclose(scanner_out);
          signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
            break;
          (void) pclose(scanner_out);
          signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
-         return m_errlog_defer(scanent, string_sprintf(
+         return m_panic_defer(scanent, NULL, string_sprintf(
              "unable to read from scanner (%s): %s",
              commandline, strerror(err)));
          }
              "unable to read from scanner (%s): %s",
              commandline, strerror(err)));
          }
@@ -1113,7 +1346,7 @@ if (!malware_ok)
          /* short write */
          (void) pclose(scanner_out);
          signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
          /* short write */
          (void) pclose(scanner_out);
          signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
-         return m_errlog_defer(scanent, string_sprintf(
+         return m_panic_defer(scanent, NULL, string_sprintf(
            "short write on scanner output file (%s).", file_name));
          }
        putc('\n', scanner_record);
            "short write on scanner output file (%s).", file_name));
          }
        putc('\n', scanner_record);
@@ -1128,7 +1361,7 @@ if (!malware_ok)
       sep = pclose(scanner_out);
       signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
       if (sep != 0)
       sep = pclose(scanner_out);
       signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
       if (sep != 0)
-         return m_errlog_defer(scanent,
+         return m_panic_defer(scanent, NULL,
              sep == -1
              ? string_sprintf("running scanner failed: %s", strerror(sep))
              : string_sprintf("scanner returned error code: %d", sep));
              sep == -1
              ? string_sprintf("running scanner failed: %s", strerror(sep))
              : string_sprintf("scanner returned error code: %d", sep));
@@ -1140,20 +1373,19 @@ if (!malware_ok)
        malware_name = US"unknown";
 
        /* re-open the scanner output file, look for name match */
        malware_name = US"unknown";
 
        /* re-open the scanner output file, look for name match */
-       scanner_record = fopen(CS file_name, "rb");
-       while (fgets(CS linebuffer, sizeof(linebuffer), scanner_record))
-         {
-         /* try match */
-         if ((s = m_pcre_exec(cmdline_regex_re, linebuffer)))
+       scanner_record = Ufopen(file_name, "rb");
+       while (Ufgets(linebuffer, sizeof(linebuffer), scanner_record))
+         if ((s = m_pcre_exec(cmdline_regex_re, linebuffer))) /* try match */
            malware_name = s;
            malware_name = s;
-         }
        (void)fclose(scanner_record);
        }
       else /* no virus found */
        malware_name = NULL;
       break;
       }        /* cmdline */
        (void)fclose(scanner_record);
        }
       else /* no virus found */
        malware_name = NULL;
       break;
       }        /* cmdline */
+#endif
 
 
+#ifndef DISABLE_MAL_SOPHIE
     case M_SOPHIE: /* "sophie" scanner type --------------------------------- */
       {
       int bread = 0;
     case M_SOPHIE: /* "sophie" scanner type --------------------------------- */
       {
       int bread = 0;
@@ -1166,22 +1398,22 @@ if (!malware_ok)
       if ((p = Ustrrchr(file_name, '/')))
        *p = '\0';
 
       if ((p = Ustrrchr(file_name, '/')))
        *p = '\0';
 
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
          scanner_name, scanner_options);
 
          scanner_name, scanner_options);
 
-      if (  write(sock, file_name, Ustrlen(file_name)) < 0
-        || write(sock, "\n", 1) != 1
+      if (  write(malware_daemon_ctx.sock, file_name, Ustrlen(file_name)) < 0
+        || write(malware_daemon_ctx.sock, "\n", 1) != 1
         )
         )
-       return m_errlog_defer_3(scanent,
+       return m_panic_defer_3(scanent, CUS callout_address,
          string_sprintf("unable to write to UNIX socket (%s)", scanner_options),
          string_sprintf("unable to write to UNIX socket (%s)", scanner_options),
-         sock);
+         malware_daemon_ctx.sock);
 
       /* wait for result */
       memset(av_buffer, 0, sizeof(av_buffer));
 
       /* wait for result */
       memset(av_buffer, 0, sizeof(av_buffer));
-      if ((bread = ip_recv(sock, av_buffer, sizeof(av_buffer), tmo-time(NULL))) <= 0)
-       return m_errlog_defer_3(scanent,
+      if ((bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo)) <= 0)
+       return m_panic_defer_3(scanent, CUS callout_address,
          string_sprintf("unable to read from UNIX socket (%s)", scanner_options),
          string_sprintf("unable to read from UNIX socket (%s)", scanner_options),
-         sock);
+         malware_daemon_ctx.sock);
 
       /* infected ? */
       if (av_buffer[0] == '1') {
 
       /* infected ? */
       if (av_buffer[0] == '1') {
@@ -1191,13 +1423,16 @@ if (!malware_ok)
        malware_name = string_copy(&av_buffer[2]);
       }
       else if (!strncmp(CS av_buffer, "-1", 2))
        malware_name = string_copy(&av_buffer[2]);
       }
       else if (!strncmp(CS av_buffer, "-1", 2))
-       return m_errlog_defer_3(scanent, US"scanner reported error", sock);
+       return m_panic_defer_3(scanent, CUS callout_address,
+               US"scanner reported error", malware_daemon_ctx.sock);
       else /* all ok, no virus */
        malware_name = NULL;
 
       break;
       }
       else /* all ok, no virus */
        malware_name = NULL;
 
       break;
       }
+#endif
 
 
+#ifndef DISABLE_MAL_CLAM
     case M_CLAMD: /* "clamd" scanner type ----------------------------------- */
       {
 /* This code was originally contributed by David Saez */
     case M_CLAMD: /* "clamd" scanner type ----------------------------------- */
       {
 /* This code was originally contributed by David Saez */
@@ -1208,30 +1443,21 @@ if (!malware_ok)
 * The zINSTREAM command was introduced with ClamAV 0.95, which marked
 * STREAM deprecated; see: http://wiki.clamav.net/bin/view/Main/UpgradeNotes095
 * In Exim, we use SCAN if using a Unix-domain socket or explicitly told that
 * The zINSTREAM command was introduced with ClamAV 0.95, which marked
 * STREAM deprecated; see: http://wiki.clamav.net/bin/view/Main/UpgradeNotes095
 * In Exim, we use SCAN if using a Unix-domain socket or explicitly told that
-* the TCP-connected daemon is actually local; otherwise we use zINSTREAM unless
-* WITH_OLD_CLAMAV_STREAM is defined.
+* the TCP-connected daemon is actually local; otherwise we use zINSTREAM
 * See Exim bug 926 for details.  */
 
 * See Exim bug 926 for details.  */
 
-      uschar *p, *vname, *result_tag, *response_end;
+      uschar *p, *vname, *result_tag;
       int bread=0;
       int bread=0;
-      uschar * file_name;
       uschar av_buffer[1024];
       uschar *hostname = US"";
       host_item connhost;
       uschar av_buffer[1024];
       uschar *hostname = US"";
       host_item connhost;
-      uschar *clamav_fbuf;
-      int clam_fd, result;
-      off_t fsize;
+      int clam_fd;
       unsigned int fsize_uint;
       BOOL use_scan_command = FALSE;
       clamd_address * cv[MAX_CLAMD_SERVERS];
       int num_servers = 0;
       unsigned int fsize_uint;
       BOOL use_scan_command = FALSE;
       clamd_address * cv[MAX_CLAMD_SERVERS];
       int num_servers = 0;
-#ifdef WITH_OLD_CLAMAV_STREAM
-      unsigned int port;
-      uschar av_buffer2[1024];
-      int sockData;
-#else
       uint32_t send_size, send_final_zeroblock;
       uint32_t send_size, send_final_zeroblock;
-#endif
+      blob cmd_str;
 
       /*XXX if unixdomain socket, only one server supported. Needs fixing;
       there's no reason we should not mix local and remote servers */
 
       /*XXX if unixdomain socket, only one server supported. Needs fixing;
       there's no reason we should not mix local and remote servers */
@@ -1243,9 +1469,9 @@ if (!malware_ok)
        int subsep = ' ';
 
        /* Local file; so we def want to use_scan_command and don't want to try
        int subsep = ' ';
 
        /* Local file; so we def want to use_scan_command and don't want to try
-        * passing IP/port combinations */
+       passing IP/port combinations */
        use_scan_command = TRUE;
        use_scan_command = TRUE;
-       cd = (clamd_address *) store_get(sizeof(clamd_address));
+       cd = (clamd_address *) store_get(sizeof(clamd_address), GET_UNTAINTED);
 
        /* extract socket-path part */
        sublist = scanner_options;
 
        /* extract socket-path part */
        sublist = scanner_options;
@@ -1253,7 +1479,7 @@ if (!malware_ok)
 
        /* parse options */
        if (clamd_option(cd, sublist, &subsep) != OK)
 
        /* parse options */
        if (clamd_option(cd, sublist, &subsep) != OK)
-         return m_errlog_defer(scanent,
+         return m_panic_defer(scanent, NULL,
            string_sprintf("bad option '%s'", scanner_options));
        cv[0] = cd;
        }
            string_sprintf("bad option '%s'", scanner_options));
        cv[0] = cd;
        }
@@ -1279,19 +1505,19 @@ if (!malware_ok)
            continue;
            }
 
            continue;
            }
 
-         cd = (clamd_address *) store_get(sizeof(clamd_address));
+         cd = (clamd_address *) store_get(sizeof(clamd_address), GET_UNTAINTED);
 
          /* extract host and port part */
          sublist = scanner_options;
          if (!(cd->hostspec = string_nextinlist(&sublist, &subsep, NULL, 0)))
            {
 
          /* extract host and port part */
          sublist = scanner_options;
          if (!(cd->hostspec = string_nextinlist(&sublist, &subsep, NULL, 0)))
            {
-           (void) m_errlog_defer(scanent,
+           (void) m_panic_defer(scanent, NULL,
                      string_sprintf("missing address: '%s'", scanner_options));
            continue;
            }
          if (!(s = string_nextinlist(&sublist, &subsep, NULL, 0)))
            {
                      string_sprintf("missing address: '%s'", scanner_options));
            continue;
            }
          if (!(s = string_nextinlist(&sublist, &subsep, NULL, 0)))
            {
-           (void) m_errlog_defer(scanent,
+           (void) m_panic_defer(scanent, NULL,
                      string_sprintf("missing port: '%s'", scanner_options));
            continue;
            }
                      string_sprintf("missing port: '%s'", scanner_options));
            continue;
            }
@@ -1300,16 +1526,13 @@ if (!malware_ok)
          /* parse options */
          /*XXX should these options be common over scanner types? */
          if (clamd_option(cd, sublist, &subsep) != OK)
          /* parse options */
          /*XXX should these options be common over scanner types? */
          if (clamd_option(cd, sublist, &subsep) != OK)
-           {
-           return m_errlog_defer(scanent,
+           return m_panic_defer(scanent, NULL,
              string_sprintf("bad option '%s'", scanner_options));
              string_sprintf("bad option '%s'", scanner_options));
-           continue;
-           }
 
          cv[num_servers++] = cd;
          if (num_servers >= MAX_CLAMD_SERVERS)
            {
 
          cv[num_servers++] = cd;
          if (num_servers >= MAX_CLAMD_SERVERS)
            {
-           (void) m_errlog_defer(scanent,
+           (void) m_panic_defer(scanent, NULL,
                  US"More than " MAX_CLAMD_SERVERS_S " clamd servers "
                  "specified; only using the first " MAX_CLAMD_SERVERS_S );
            break;
                  US"More than " MAX_CLAMD_SERVERS_S " clamd servers "
                  "specified; only using the first " MAX_CLAMD_SERVERS_S );
            break;
@@ -1319,51 +1542,63 @@ if (!malware_ok)
 
        /* check if we have at least one server */
        if (!num_servers)
 
        /* check if we have at least one server */
        if (!num_servers)
-         return m_errlog_defer(scanent,
+         return m_panic_defer(scanent, NULL,
            US"no useable server addresses in malware configuration option.");
        }
 
       /* See the discussion of response formats below to see why we really
       don't like colons in filenames when passing filenames to ClamAV. */
       if (use_scan_command && Ustrchr(eml_filename, ':'))
            US"no useable server addresses in malware configuration option.");
        }
 
       /* See the discussion of response formats below to see why we really
       don't like colons in filenames when passing filenames to ClamAV. */
       if (use_scan_command && Ustrchr(eml_filename, ':'))
-       return m_errlog_defer(scanent,
+       return m_panic_defer(scanent, NULL,
          string_sprintf("local/SCAN mode incompatible with" \
            " : in path to email filename [%s]", eml_filename));
 
          string_sprintf("local/SCAN mode incompatible with" \
            " : in path to email filename [%s]", eml_filename));
 
+      /* Set up the very first data we will be sending */
+      if (!use_scan_command)
+       { cmd_str.data = US"zINSTREAM"; cmd_str.len = 10; }
+      else
+       {
+       int n;
+       cmd_str.data = string_sprintf("SCAN %s\n%n", eml_filename, &n);
+       cmd_str.len = n;                /* .len is a size_t */
+       }
+
       /* We have some network servers specified */
       if (num_servers)
        {
        /* Confirmed in ClamAV source (0.95.3) that the TCPAddr option of clamd
       /* We have some network servers specified */
       if (num_servers)
        {
        /* Confirmed in ClamAV source (0.95.3) that the TCPAddr option of clamd
-        * only supports AF_INET, but we should probably be looking to the
-        * future and rewriting this to be protocol-independent anyway. */
+       only supports AF_INET, but we should probably be looking to the
+       future and rewriting this to be protocol-independent anyway. */
 
        while (num_servers > 0)
          {
 
        while (num_servers > 0)
          {
-         int i = random_number( num_servers );
+         int i = random_number(num_servers);
          clamd_address * cd = cv[i];
 
          clamd_address * cd = cv[i];
 
-         DEBUG(D_acl) debug_printf("trying server name %s, port %u\n",
+         DEBUG(D_acl) debug_printf_indent("trying server name %s, port %u\n",
                         cd->hostspec, cd->tcp_port);
 
          /* Lookup the host. This is to ensure that we connect to the same IP
                         cd->hostspec, cd->tcp_port);
 
          /* Lookup the host. This is to ensure that we connect to the same IP
-          * on both connections (as one host could resolve to multiple ips) */
+         on both connections (as one host could resolve to multiple ips) */
          for (;;)
            {
          for (;;)
            {
-           sock= m_tcpsocket(cd->hostspec, cd->tcp_port, &connhost, &errstr);
-           if (sock >= 0)
+           /*XXX we trust that the cmd_str is idempotent */
+           if ((malware_daemon_ctx.sock = m_tcpsocket(cd->hostspec, cd->tcp_port,
+                                   &connhost, &errstr,
+                                   use_scan_command ? &cmd_str : NULL)) >= 0)
              {
              /* Connection successfully established with a server */
              hostname = cd->hostspec;
              {
              /* Connection successfully established with a server */
              hostname = cd->hostspec;
+             if (use_scan_command) cmd_str.len = 0;
              break;
              }
            if (cd->retry <= 0) break;
            while (cd->retry > 0) cd->retry = sleep(cd->retry);
            }
              break;
              }
            if (cd->retry <= 0) break;
            while (cd->retry > 0) cd->retry = sleep(cd->retry);
            }
-         if (sock >= 0)
+         if (malware_daemon_ctx.sock >= 0)
            break;
 
            break;
 
-         log_write(0, LOG_MAIN, "malware acl condition: %s: %s",
-           scanent->name, errstr);
+         (void) m_panic_defer(scanent, CUS callout_address, errstr);
 
          /* Remove the server from the list. XXX We should free the memory */
          num_servers--;
 
          /* Remove the server from the list. XXX We should free the memory */
          num_servers--;
@@ -1372,170 +1607,133 @@ if (!malware_ok)
          }
 
        if (num_servers == 0)
          }
 
        if (num_servers == 0)
-         return m_errlog_defer(scanent, US"all servers failed");
+         return m_panic_defer(scanent, NULL, US"all servers failed");
        }
       else
        for (;;)
          {
        }
       else
        for (;;)
          {
-         if ((sock = ip_unixsocket(cv[0]->hostspec, &errstr)) >= 0)
+         if ((malware_daemon_ctx.sock = ip_unixsocket(cv[0]->hostspec, &errstr)) >= 0)
            {
            hostname = cv[0]->hostspec;
            break;
            }
          if (cv[0]->retry <= 0)
            {
            hostname = cv[0]->hostspec;
            break;
            }
          if (cv[0]->retry <= 0)
-           return m_errlog_defer(scanent, errstr);
+           return m_panic_defer(scanent, CUS callout_address, errstr);
          while (cv[0]->retry > 0) cv[0]->retry = sleep(cv[0]->retry);
          }
 
       /* have socket in variable "sock"; command to use is semi-independent of
          while (cv[0]->retry > 0) cv[0]->retry = sleep(cv[0]->retry);
          }
 
       /* have socket in variable "sock"; command to use is semi-independent of
-       * the socket protocol.  We use SCAN if is local (either Unix/local
-       * domain socket, or explicitly told local) else we stream the data.
-       * How we stream the data depends upon how we were built.  */
+      the socket protocol.  We use SCAN if is local (either Unix/local
+      domain socket, or explicitly told local) else we stream the data.
+      How we stream the data depends upon how we were built.  */
 
       if (!use_scan_command)
        {
 
       if (!use_scan_command)
        {
-#ifdef WITH_OLD_CLAMAV_STREAM
-       /* "STREAM\n" command, get back a "PORT <N>\n" response, send data to
-        * that port on a second connection; then in the scan-method-neutral
-        * part, read the response back on the original connection. */
-
-       DEBUG(D_acl) debug_printf(
-           "Malware scan: issuing %s old-style remote scan (PORT)\n",
-           scanner_name);
-
-       /* Pass the string to ClamAV (7 = "STREAM\n") */
-       if (m_sock_send(sock, US"STREAM\n", 7, &errstr) < 0)
-         return m_errlog_defer(scanent, errstr);
-
-       memset(av_buffer2, 0, sizeof(av_buffer2));
-       bread = ip_recv(sock, av_buffer2, sizeof(av_buffer2), tmo-time(NULL));
-
-       if (bread < 0)
-         return m_errlog_defer_3(scanent,
-           string_sprintf("unable to read PORT from socket (%s)",
-               strerror(errno)),
-           sock);
-
-       if (bread == sizeof(av_buffer2))
-         return m_errlog_defer_3(scanent, "buffer too small", sock);
-
-       if (!(*av_buffer2))
-         return m_errlog_defer_3(scanent, "ClamAV returned null", sock);
-
-       av_buffer2[bread] = '\0';
-       if( sscanf(CS av_buffer2, "PORT %u\n", &port) != 1 )
-         return m_errlog_defer_3(scanent,
-           string_sprintf("Expected port information from clamd, got '%s'",
-             av_buffer2),
-           sock);
-
-       sockData = m_tcpsocket(connhost.address, port, NULL, &errstr);
-       if (sockData < 0)
-         return m_errlog_defer_3(scanent, errstr, sock);
-
-# define CLOSE_SOCKDATA (void)close(sockData)
-#else /* WITH_OLD_CLAMAV_STREAM not defined */
+       struct stat st;
+#if defined(EXIM_TCP_CORK) && !defined(OS_SENDFILE)
+       BOOL corked = TRUE;
+#endif
        /* New protocol: "zINSTREAM\n" followed by a sequence of <length><data>
        chunks, <n> a 4-byte number (network order), terminated by a zero-length
        /* New protocol: "zINSTREAM\n" followed by a sequence of <length><data>
        chunks, <n> a 4-byte number (network order), terminated by a zero-length
-       chunk. */
+       chunk. We only send one chunk. */
 
 
-       DEBUG(D_acl) debug_printf(
+       DEBUG(D_acl) debug_printf_indent(
            "Malware scan: issuing %s new-style remote scan (zINSTREAM)\n",
            scanner_name);
 
            "Malware scan: issuing %s new-style remote scan (zINSTREAM)\n",
            scanner_name);
 
-       /* Pass the string to ClamAV (10 = "zINSTREAM\0") */
-       if (send(sock, "zINSTREAM", 10, 0) < 0)
-         return m_errlog_defer_3(scanent,
-           string_sprintf("unable to send zINSTREAM to socket (%s)",
-             strerror(errno)),
-           sock);
-
-# define CLOSE_SOCKDATA /**/
+#if defined(EXIM_TCP_CORK)
+       (void) setsockopt(malware_daemon_ctx.sock, IPPROTO_TCP, EXIM_TCP_CORK,
+                         US &on, sizeof(on));
 #endif
 #endif
+       /* Pass the string to ClamAV (10 = "zINSTREAM\0"), if not already sent */
+       if (cmd_str.len)
+         if (send(malware_daemon_ctx.sock, cmd_str.data, cmd_str.len, 0) < 0)
+           return m_panic_defer_3(scanent, CUS hostname,
+             string_sprintf("unable to send zINSTREAM to socket (%s)",
+               strerror(errno)),
+             malware_daemon_ctx.sock);
 
 
-       /* calc file size */
-       if ((clam_fd = open(CS eml_filename, O_RDONLY)) < 0)
+       if ((clam_fd = exim_open2(CS eml_filename, O_RDONLY)) < 0)
          {
          int err = errno;
          {
          int err = errno;
-         CLOSE_SOCKDATA;
-         return m_errlog_defer_3(scanent,
+         return m_panic_defer_3(scanent, NULL,
            string_sprintf("can't open spool file %s: %s",
              eml_filename, strerror(err)),
            string_sprintf("can't open spool file %s: %s",
              eml_filename, strerror(err)),
-           sock);
+           malware_daemon_ctx.sock);
          }
          }
-       if ((fsize = lseek(clam_fd, 0, SEEK_END)) < 0)
+       if (fstat(clam_fd, &st) < 0)
          {
          int err = errno;
          {
          int err = errno;
-         CLOSE_SOCKDATA; (void)close(clam_fd);
-         return m_errlog_defer_3(scanent,
-           string_sprintf("can't seek spool file %s: %s",
+         (void)close(clam_fd);
+         return m_panic_defer_3(scanent, NULL,
+           string_sprintf("can't stat spool file %s: %s",
              eml_filename, strerror(err)),
              eml_filename, strerror(err)),
-           sock);
+           malware_daemon_ctx.sock);
          }
          }
-       fsize_uint = (unsigned int) fsize;
-       if ((off_t)fsize_uint != fsize)
+       fsize_uint = (unsigned int) st.st_size;
+       if ((off_t)fsize_uint != st.st_size)
          {
          {
-         CLOSE_SOCKDATA; (void)close(clam_fd);
-         return m_errlog_defer_3(scanent,
-           string_sprintf("seeking spool file %s, size overflow",
-             eml_filename),
-           sock);
+         (void)close(clam_fd);
+         return m_panic_defer_3(scanent, NULL,
+           string_sprintf("stat spool file %s, size overflow", eml_filename),
+           malware_daemon_ctx.sock);
          }
          }
-       lseek(clam_fd, 0, SEEK_SET);
 
 
-       if (!(clamav_fbuf = (uschar *) malloc (fsize_uint)))
-         {
-         CLOSE_SOCKDATA; (void)close(clam_fd);
-         return m_errlog_defer_3(scanent,
-           string_sprintf("unable to allocate memory %u for file (%s)",
-             fsize_uint, eml_filename),
-           sock);
-         }
+       /* send file size */
+       send_size = htonl(fsize_uint);
+       if (send(malware_daemon_ctx.sock, &send_size, sizeof(send_size), 0) < 0)
+         return m_panic_defer_3(scanent, NULL,
+           string_sprintf("unable to send file size to socket (%s)", hostname),
+           malware_daemon_ctx.sock);
 
 
-       if ((result = read(clam_fd, clamav_fbuf, fsize_uint)) < 0)
+       /* send file body */
+       while (fsize_uint)
          {
          {
-         int err = errno;
-         free(clamav_fbuf); CLOSE_SOCKDATA; (void)close(clam_fd);
-         return m_errlog_defer_3(scanent,
-           string_sprintf("can't read spool file %s: %s",
-             eml_filename, strerror(err)),
-           sock);
-         }
-       (void)close(clam_fd);
+#ifdef OS_SENDFILE
+         int n = os_sendfile(malware_daemon_ctx.sock, clam_fd, NULL, (size_t)fsize_uint);
+         if (n < 0)
+           return m_panic_defer_3(scanent, NULL,
+             string_sprintf("unable to send file body to socket (%s): %s", hostname, strerror(errno)),
+             malware_daemon_ctx.sock);
+         fsize_uint -= n;
+#else
+         int n = MIN(fsize_uint, big_buffer_size);
+         if ((n = read(clam_fd, big_buffer, n)) < 0)
+           return m_panic_defer_3(scanent, NULL,
+             string_sprintf("can't read spool file %s: %s",
+               eml_filename, strerror(errno)),
+             malware_daemon_ctx.sock);
+         if (send(malware_daemon_ctx.sock, big_buffer, (size_t)n, 0) < 0)
+           return m_panic_defer_3(scanent, NULL,
+             string_sprintf("unable to send file body to socket (%s): %s", hostname, strerror(errno)),
+             malware_daemon_ctx.sock);
+         fsize_uint -= n;
+# ifdef EXIM_TCP_CORK
+         if (corked)
+           {
+           corked = FALSE;
+           (void) setsockopt(malware_daemon_ctx.sock, IPPROTO_TCP, EXIM_TCP_CORK,
+                             US &off, sizeof(off));
+           }
+# endif
+#endif /*!OS_SENDFILE*/
 
 
-       /* send file body to socket */
-#ifdef WITH_OLD_CLAMAV_STREAM
-       if (send(sockData, clamav_fbuf, fsize_uint, 0) < 0)
-         {
-         free(clamav_fbuf); CLOSE_SOCKDATA;
-         return m_errlog_defer_3(scanent,
-           string_sprintf("unable to send file body to socket (%s:%u)",
-             hostname, port),
-           sock);
          }
          }
-#else
-       send_size = htonl(fsize_uint);
+
        send_final_zeroblock = 0;
        send_final_zeroblock = 0;
-       if ((send(sock, &send_size, sizeof(send_size), 0) < 0) ||
-           (send(sock, clamav_fbuf, fsize_uint, 0) < 0) ||
-           (send(sock, &send_final_zeroblock, sizeof(send_final_zeroblock), 0) < 0))
-         {
-         free(clamav_fbuf);
-         return m_errlog_defer_3(scanent,
-           string_sprintf("unable to send file body to socket (%s)", hostname),
-           sock);
-         }
+       if (send(malware_daemon_ctx.sock, &send_final_zeroblock, sizeof(send_final_zeroblock), 0) < 0)
+         return m_panic_defer_3(scanent, NULL,
+           string_sprintf("unable to send file terminator to socket (%s)", hostname),
+           malware_daemon_ctx.sock);
+#ifdef OS_SENDFILE
+       (void) setsockopt(malware_daemon_ctx.sock, IPPROTO_TCP, EXIM_TCP_CORK,
+                         US &off, sizeof(off));
 #endif
 #endif
-
-       free(clamav_fbuf);
-
-       CLOSE_SOCKDATA;
-#undef CLOSE_SOCKDATA
        }
       else
        { /* use scan command */
        /* Send a SCAN command pointing to a filename; then in the then in the
        }
       else
        { /* use scan command */
        /* Send a SCAN command pointing to a filename; then in the then in the
-        * scan-method-neutral part, read the response back */
+       scan-method-neutral part, read the response back */
 
 /* ================================================================= */
 
 
 /* ================================================================= */
 
@@ -1547,37 +1745,39 @@ if (!malware_ok)
        scanned twice, in the broken out files and from the original .eml.
        Since ClamAV now handles emails (and has for quite some time) we can
        just use the email file itself. */
        scanned twice, in the broken out files and from the original .eml.
        Since ClamAV now handles emails (and has for quite some time) we can
        just use the email file itself. */
-       /* Pass the string to ClamAV (7 = "SCAN \n" + \0) */
-       file_name = string_sprintf("SCAN %s\n", eml_filename);
+       /* Pass the string to ClamAV (7 = "SCAN \n" + \0), if not already sent */
 
 
-       DEBUG(D_acl) debug_printf(
+       DEBUG(D_acl) debug_printf_indent(
            "Malware scan: issuing %s local-path scan [%s]\n",
            scanner_name, scanner_options);
 
            "Malware scan: issuing %s local-path scan [%s]\n",
            scanner_name, scanner_options);
 
-       if (send(sock, file_name, Ustrlen(file_name), 0) < 0)
-         return m_errlog_defer_3(scanent,
-           string_sprintf("unable to write to socket (%s)", strerror(errno)),
-           sock);
+       if (cmd_str.len)
+         if (send(malware_daemon_ctx.sock, cmd_str.data, cmd_str.len, 0) < 0)
+           return m_panic_defer_3(scanent, CUS callout_address,
+             string_sprintf("unable to write to socket (%s)", strerror(errno)),
+             malware_daemon_ctx.sock);
 
        /* Do not shut down the socket for writing; a user report noted that
 
        /* Do not shut down the socket for writing; a user report noted that
-        * clamd 0.70 does not react well to this. */
+       clamd 0.70 does not react well to this. */
        }
       /* Commands have been sent, no matter which scan method or connection
        }
       /* Commands have been sent, no matter which scan method or connection
-       * type we're using; now just read the result, independent of method. */
+      type we're using; now just read the result, independent of method. */
 
       /* Read the result */
       memset(av_buffer, 0, sizeof(av_buffer));
 
       /* Read the result */
       memset(av_buffer, 0, sizeof(av_buffer));
-      bread = ip_recv(sock, av_buffer, sizeof(av_buffer), tmo-time(NULL));
-      (void)close(sock);
-      sock = -1;
+      bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo);
+      (void)close(malware_daemon_ctx.sock);
+      malware_daemon_ctx.sock = -1;
+      malware_daemon_ctx.tls_ctx = NULL;
 
       if (bread <= 0)
 
       if (bread <= 0)
-       return m_errlog_defer(scanent,
+       return m_panic_defer(scanent, CUS callout_address,
          string_sprintf("unable to read from socket (%s)",
          errno == 0 ? "EOF" : strerror(errno)));
 
       if (bread == sizeof(av_buffer))
          string_sprintf("unable to read from socket (%s)",
          errno == 0 ? "EOF" : strerror(errno)));
 
       if (bread == sizeof(av_buffer))
-       return m_errlog_defer(scanent, US"buffer too small");
+       return m_panic_defer(scanent, CUS callout_address,
+               US"buffer too small");
       /* We're now assured of a NULL at the end of av_buffer */
 
       /* Check the result. ClamAV returns one of two result formats.
       /* We're now assured of a NULL at the end of av_buffer */
 
       /* Check the result. ClamAV returns one of two result formats.
@@ -1601,24 +1801,25 @@ if (!malware_ok)
       passing a filename to clamd). */
 
       if (!(*av_buffer))
       passing a filename to clamd). */
 
       if (!(*av_buffer))
-       return m_errlog_defer(scanent, US"ClamAV returned null");
+       return m_panic_defer(scanent, CUS callout_address,
+               US"ClamAV returned null");
 
       /* strip newline at the end (won't be present for zINSTREAM)
       (also any trailing whitespace, which shouldn't exist, but we depend upon
       this below, so double-check) */
 
       /* strip newline at the end (won't be present for zINSTREAM)
       (also any trailing whitespace, which shouldn't exist, but we depend upon
       this below, so double-check) */
+
       p = av_buffer + Ustrlen(av_buffer) - 1;
       if (*p == '\n') *p = '\0';
 
       p = av_buffer + Ustrlen(av_buffer) - 1;
       if (*p == '\n') *p = '\0';
 
-      DEBUG(D_acl) debug_printf("Malware response: %s\n", av_buffer);
+      DEBUG(D_acl) debug_printf_indent("Malware response: %s\n", av_buffer);
 
       while (isspace(*--p) && (p > av_buffer))
        *p = '\0';
       if (*p) ++p;
 
       while (isspace(*--p) && (p > av_buffer))
        *p = '\0';
       if (*p) ++p;
-      response_end = p;
 
       /* colon in returned output? */
 
       /* colon in returned output? */
-      if((p = Ustrchr(av_buffer,':')) == NULL)
-       return m_errlog_defer(scanent, string_sprintf(
+      if (!(p = Ustrchr(av_buffer,':')))
+       return m_panic_defer(scanent, CUS callout_address, string_sprintf(
                  "ClamAV returned malformed result (missing colon): %s",
                  av_buffer));
 
                  "ClamAV returned malformed result (missing colon): %s",
                  av_buffer));
 
@@ -1647,27 +1848,29 @@ if (!malware_ok)
            *p = '\0';
          }
        malware_name = string_copy(vname);
            *p = '\0';
          }
        malware_name = string_copy(vname);
-       DEBUG(D_acl) debug_printf("Malware found, name \"%s\"\n", malware_name);
+       DEBUG(D_acl) debug_printf_indent("Malware found, name \"%s\"\n", malware_name);
 
        }
       else if (Ustrcmp(result_tag, "ERROR") == 0)
 
        }
       else if (Ustrcmp(result_tag, "ERROR") == 0)
-       return m_errlog_defer(scanent,
+       return m_panic_defer(scanent, CUS callout_address,
          string_sprintf("ClamAV returned: %s", av_buffer));
 
       else if (Ustrcmp(result_tag, "OK") == 0)
        {
        /* Everything should be OK */
        malware_name = NULL;
          string_sprintf("ClamAV returned: %s", av_buffer));
 
       else if (Ustrcmp(result_tag, "OK") == 0)
        {
        /* Everything should be OK */
        malware_name = NULL;
-       DEBUG(D_acl) debug_printf("Malware not found\n");
+       DEBUG(D_acl) debug_printf_indent("Malware not found\n");
 
        }
       else
 
        }
       else
-       return m_errlog_defer(scanent,
+       return m_panic_defer(scanent, CUS callout_address,
          string_sprintf("unparseable response from ClamAV: {%s}", av_buffer));
 
       break;
       } /* clamd */
          string_sprintf("unparseable response from ClamAV: {%s}", av_buffer));
 
       break;
       } /* clamd */
+#endif
 
 
+#ifndef DISABLE_MAL_SOCK
     case M_SOCK: /* "sock" scanner type ------------------------------------- */
     /* This code was derived by Martin Poole from the clamd code contributed
        by David Saez and the cmdline code
     case M_SOCK: /* "sock" scanner type ------------------------------------- */
     /* This code was derived by Martin Poole from the clamd code contributed
        by David Saez and the cmdline code
@@ -1679,67 +1882,78 @@ if (!malware_ok)
       uschar * linebuffer;
       uschar * sockline_scanner;
       uschar sockline_scanner_default[] = "%s\n";
       uschar * linebuffer;
       uschar * sockline_scanner;
       uschar sockline_scanner_default[] = "%s\n";
-      const pcre *sockline_trig_re;
-      const pcre *sockline_name_re;
+      const pcre2_code *sockline_trig_re;
+      const pcre2_code *sockline_name_re;
 
       /* find scanner command line */
 
       /* find scanner command line */
-      if ((sockline_scanner = string_nextinlist(&av_scanner_work, &sep,
-                                         NULL, 0)))
+      if (  (sockline_scanner = string_nextinlist(&av_scanner_work, &sep,
+                                         NULL, 0))
+        && *sockline_scanner
+        )
       {        /* check for no expansions apart from one %s */
        uschar * s = Ustrchr(sockline_scanner, '%');
        if (s++)
          if ((*s != 's' && *s != '%') || Ustrchr(s+1, '%'))
       {        /* check for no expansions apart from one %s */
        uschar * s = Ustrchr(sockline_scanner, '%');
        if (s++)
          if ((*s != 's' && *s != '%') || Ustrchr(s+1, '%'))
-           return m_errlog_defer_3(scanent,
-                                 US"unsafe sock scanner call spec", sock);
+           return m_panic_defer_3(scanent, NULL,
+                                 US"unsafe sock scanner call spec", malware_daemon_ctx.sock);
       }
       else
        sockline_scanner = sockline_scanner_default;
       }
       else
        sockline_scanner = sockline_scanner_default;
+      DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "cmdline: ",
+       string_printing(sockline_scanner));
 
       /* find scanner output trigger */
 
       /* find scanner output trigger */
-      sockline_trig_re = m_pcre_nextinlist(&av_scanner_work, &sep,
+      sockline_trig_re = m_pcre_nextinlist(&av_scanner_work, &sep, av_scanner_textonly,
                                "missing trigger specification", &errstr);
       if (!sockline_trig_re)
                                "missing trigger specification", &errstr);
       if (!sockline_trig_re)
-       return m_errlog_defer_3(scanent, errstr, sock);
+       return m_panic_defer_3(scanent, NULL, errstr, malware_daemon_ctx.sock);
 
       /* find virus name regex */
 
       /* find virus name regex */
-      sockline_name_re = m_pcre_nextinlist(&av_scanner_work, &sep,
+      sockline_name_re = m_pcre_nextinlist(&av_scanner_work, &sep, av_scanner_textonly,
                          "missing virus name regex specification", &errstr);
       if (!sockline_name_re)
                          "missing virus name regex specification", &errstr);
       if (!sockline_name_re)
-       return m_errlog_defer_3(scanent, errstr, sock);
+       return m_panic_defer_3(scanent, NULL, errstr, malware_daemon_ctx.sock);
 
       /* prepare scanner call - security depends on expansions check above */
 
       /* prepare scanner call - security depends on expansions check above */
-      commandline = string_sprintf("%s/scan/%s/%s.eml", spool_directory, message_id, message_id);
-      commandline = string_sprintf( CS sockline_scanner, CS commandline);
-
+      commandline = string_sprintf( CS sockline_scanner, CS eml_filename);
+      DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "expanded: ",
+       string_printing(commandline));
 
       /* Pass the command string to the socket */
 
       /* Pass the command string to the socket */
-      if (m_sock_send(sock, commandline, Ustrlen(commandline), &errstr) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if (m_sock_send(malware_daemon_ctx.sock, commandline, Ustrlen(commandline), &errstr) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
       /* Read the result */
 
       /* Read the result */
-      bread = ip_recv(sock, av_buffer, sizeof(av_buffer), tmo-time(NULL));
+      bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo);
 
       if (bread <= 0)
 
       if (bread <= 0)
-       return m_errlog_defer_3(scanent,
+       return m_panic_defer_3(scanent, CUS callout_address,
          string_sprintf("unable to read from socket (%s)", strerror(errno)),
          string_sprintf("unable to read from socket (%s)", strerror(errno)),
-         sock);
+         malware_daemon_ctx.sock);
 
       if (bread == sizeof(av_buffer))
 
       if (bread == sizeof(av_buffer))
-       return m_errlog_defer_3(scanent, US"buffer too small", sock);
+       return m_panic_defer_3(scanent, CUS callout_address,
+               US"buffer too small", malware_daemon_ctx.sock);
       av_buffer[bread] = '\0';
       linebuffer = string_copy(av_buffer);
       av_buffer[bread] = '\0';
       linebuffer = string_copy(av_buffer);
+      DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "answer: ",
+       string_printing(linebuffer));
 
       /* try trigger match */
       if (regex_match_and_setup(sockline_trig_re, linebuffer, 0, -1))
        {
        if (!(malware_name = m_pcre_exec(sockline_name_re, av_buffer)))
          malware_name = US "unknown";
 
       /* try trigger match */
       if (regex_match_and_setup(sockline_trig_re, linebuffer, 0, -1))
        {
        if (!(malware_name = m_pcre_exec(sockline_name_re, av_buffer)))
          malware_name = US "unknown";
+       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "name: ",
+         string_printing(malware_name));
        }
       else /* no virus found */
        malware_name = NULL;
       break;
       }
        }
       else /* no virus found */
        malware_name = NULL;
       break;
       }
+#endif
 
 
+#ifndef DISABLE_MAL_MKS
     case M_MKSD: /* "mksd" scanner type ------------------------------------- */
       {
       char *mksd_options_end;
     case M_MKSD: /* "mksd" scanner type ------------------------------------- */
       {
       char *mksd_options_end;
@@ -1754,32 +1968,36 @@ if (!malware_ok)
           || mksd_maxproc < 1
           || mksd_maxproc > 32
           )
           || mksd_maxproc < 1
           || mksd_maxproc > 32
           )
-         return m_errlog_defer(scanent,
+         return m_panic_defer(scanent, CUS callout_address,
            string_sprintf("invalid option '%s'", scanner_options));
        }
 
            string_sprintf("invalid option '%s'", scanner_options));
        }
 
-      if((sock = ip_unixsocket(US "/var/run/mksd/socket", &errstr)) < 0)
-       return m_errlog_defer(scanent, errstr);
+      if((malware_daemon_ctx.sock = ip_unixsocket(US "/var/run/mksd/socket", &errstr)) < 0)
+       return m_panic_defer(scanent, CUS callout_address, errstr);
 
       malware_name = NULL;
 
 
       malware_name = NULL;
 
-      DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan\n", scanner_name);
+      DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan\n", scanner_name);
 
 
-      if ((retval = mksd_scan_packed(scanent, sock, eml_filename, tmo)) != OK)
+      if ((retval = mksd_scan_packed(scanent, malware_daemon_ctx.sock, eml_filename, tmo)) != OK)
        {
        {
-       close (sock);
+       close (malware_daemon_ctx.sock);
        return retval;
        }
       break;
       }
        return retval;
        }
       break;
       }
+#endif
 
 
+#ifndef DISABLE_MAL_AVAST
     case M_AVAST: /* "avast" scanner type ----------------------------------- */
       {
     case M_AVAST: /* "avast" scanner type ----------------------------------- */
       {
-      int ovector[1*3];
       uschar buf[1024];
       uschar * scanrequest;
       enum {AVA_HELO, AVA_OPT, AVA_RSP, AVA_DONE} avast_stage;
       int nread;
       uschar buf[1024];
       uschar * scanrequest;
       enum {AVA_HELO, AVA_OPT, AVA_RSP, AVA_DONE} avast_stage;
       int nread;
+      uschar * error_message = NULL;
+      BOOL more_data = FALSE;
+      BOOL strict = TRUE;
 
       /* According to Martin Tuma @avast the protocol uses "escaped
       whitespace", that is, every embedded whitespace is backslash
 
       /* According to Martin Tuma @avast the protocol uses "escaped
       whitespace", that is, every embedded whitespace is backslash
@@ -1788,34 +2006,75 @@ if (!malware_ok)
       and the [ ] marker.
       [+] - not infected
       [L] - infected
       and the [ ] marker.
       [+] - not infected
       [L] - infected
-      [E] - some error occured
-      Such marker follows the first non-escaped TAB.  */
+      [E] - some error occurred
+      Such marker follows the first non-escaped TAB.  For more information
+      see avast-protocol(5)
+
+      We observed two cases:
+      -> SCAN /file
+      <- /file [E]0.0 Error 13 Permission denied
+      <- 451 SCAN Engine error 13 permission denied
+
+      -> SCAN /file
+      <- /file… [E]3.0 Error 41120 The file is a decompression bomb
+      <- /file… [+]2.0
+      <- /file… [+]2.0 0 Eicar Test Virus!!!
+      <- 200 SCAN OK
+
+      If the scanner returns 4xx, DEFER is a good decision, combined
+      with a panic log entry, to get the admin's attention.
+
+      If the scanner returns 200, we reject it as malware, if found any,
+      or, in case of an error, we set the malware message to the error
+      string.
+
+      Some of the >= 42000 errors are message related - usually some
+      broken archives etc, but some of them are e.g. license related.
+      Once the license expires the engine starts returning errors for
+      every scanning attempt.  I¹ have the full list of the error codes
+      but it is not a public API and is subject to change. It is hard
+      for me to say what you should do in case of an engine error. You
+      can have a “Treat * unscanned file as infection” policy or “Treat
+      unscanned file as clean” policy.  ¹) Jakub Bednar
+
+       */
+
       if (  (  !ava_re_clean
       if (  (  !ava_re_clean
-            && !(ava_re_clean = m_pcre_compile(ava_re_clean_str, &errstr)))
+            && !(ava_re_clean = m_pcre_compile(ava_re_clean_str, FALSE, &errstr)))
         || (  !ava_re_virus
         || (  !ava_re_virus
-           && !(ava_re_virus = m_pcre_compile(ava_re_virus_str, &errstr)))
+           && !(ava_re_virus = m_pcre_compile(ava_re_virus_str, FALSE, &errstr)))
+        || (  !ava_re_error
+           && !(ava_re_error = m_pcre_compile(ava_re_error_str, FALSE, &errstr)))
         )
         )
-       return malware_errlog_defer(errstr);
+       return malware_panic_defer(errstr);
 
       /* wait for result */
       for (avast_stage = AVA_HELO;
 
       /* wait for result */
       for (avast_stage = AVA_HELO;
-          (nread = recv_line(sock, buf, sizeof(buf), tmo)) > 0;
+          (nread = recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo)) > 0;
          )
        {
        int slen = Ustrlen(buf);
          )
        {
        int slen = Ustrlen(buf);
-       if (slen >= 1) 
+       if (slen >= 1)
          {
          {
-         DEBUG(D_acl) debug_printf("got from avast: %s\n", buf);
+
+          /* Multi line responses are bracketed between 210 … and nnn … */
+          if (Ustrncmp(buf, "210", 3) == 0)
+            {
+            more_data = 1;
+            continue;
+            }
+          else if (more_data && isdigit(buf[0])) more_data = 0;
+
          switch (avast_stage)
            {
            case AVA_HELO:
          switch (avast_stage)
            {
            case AVA_HELO:
+              if (more_data) continue;
              if (Ustrncmp(buf, "220", 3) != 0)
                goto endloop;                   /* require a 220 */
              goto sendreq;
 
            case AVA_OPT:
              if (Ustrncmp(buf, "220", 3) != 0)
                goto endloop;                   /* require a 220 */
              goto sendreq;
 
            case AVA_OPT:
-             if (Ustrncmp(buf, "210", 3) == 0)
-               break;                          /* ignore 210 responses */
+              if (more_data) continue;
              if (Ustrncmp(buf, "200", 3) != 0)
                goto endloop;                   /* require a 200 */
 
              if (Ustrncmp(buf, "200", 3) != 0)
                goto endloop;                   /* require a 200 */
 
@@ -1826,93 +2085,110 @@ if (!malware_ok)
              if ((scanrequest = string_nextinlist(&av_scanner_work, &sep,
                                NULL, 0)))
                {
              if ((scanrequest = string_nextinlist(&av_scanner_work, &sep,
                                NULL, 0)))
                {
+                if (Ustrcmp(scanrequest, "pass_unscanned") == 0)
+                  {
+                  DEBUG(D_acl) debug_printf_indent("pass unscanned files as clean\n");
+                  strict = FALSE;
+                  goto sendreq;
+                  }
                scanrequest = string_sprintf("%s\n", scanrequest);
                avast_stage = AVA_OPT;          /* just sent option */
                scanrequest = string_sprintf("%s\n", scanrequest);
                avast_stage = AVA_OPT;          /* just sent option */
+               DEBUG(D_acl) debug_printf_indent("send to avast OPTION: %s", scanrequest);
                }
              else
                {
                }
              else
                {
-               scanrequest = string_sprintf("SCAN %s/scan/%s\n",
-                   spool_directory, message_id);
+               scanrequest = string_sprintf("SCAN %s\n", eml_dir);
                avast_stage = AVA_RSP;          /* just sent command */
                avast_stage = AVA_RSP;          /* just sent command */
+               DEBUG(D_acl) debug_printf_indent("send to avast REQUEST: SCAN %s\n", eml_dir);
                }
 
              /* send config-cmd or scan-request to socket */
              len = Ustrlen(scanrequest);
                }
 
              /* send config-cmd or scan-request to socket */
              len = Ustrlen(scanrequest);
-             if (send(sock, scanrequest, len, 0) < 0)
+             if (send(malware_daemon_ctx.sock, scanrequest, len, 0) == -1)
                {
                scanrequest[len-1] = '\0';
                {
                scanrequest[len-1] = '\0';
-               return m_errlog_defer_3(scanent, string_sprintf(
+               return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
                      "unable to send request '%s' to socket (%s): %s",
                      "unable to send request '%s' to socket (%s): %s",
-                     scanrequest, scanner_options, strerror(errno)), sock);
+                     scanrequest, scanner_options, strerror(errno)), malware_daemon_ctx.sock);
                }
              break;
              }
 
            case AVA_RSP:
                }
              break;
              }
 
            case AVA_RSP:
-             if (Ustrncmp(buf, "210", 3) == 0)
-               break;  /* ignore the "210 SCAN DATA" message */
 
 
-             if (pcre_exec(ava_re_clean, NULL, CS buf, slen,
-                   0, 0, ovector, nelements(ovector)) > 0)
-               break;
+             if (isdigit(buf[0]))  /* We're done */
+                goto endloop;
 
 
-             if ((malware_name = m_pcre_exec(ava_re_virus, buf)))
-               { /* remove backslash in front of [whitespace|backslash] */
-               uschar * p, * p0;
-               for (p = malware_name; *p; ++p) 
-                 if (*p == '\\' && (isspace(p[1]) || p[1] == '\\'))
-                   for (p0 = p; *p0; ++p0) *p0 = p0[1];
-               
-               avast_stage = AVA_DONE;
-               goto endloop;
-               }
+              if (malware_name)     /* Nothing else matters, just read on */
+                break;
 
 
-             if (Ustrncmp(buf, "200 SCAN OK", 11) == 0) 
-               { /* we're done finally */
-               if (send(sock, "QUIT\n", 5, 0) < 0) /* courtesy */
-                 return m_errlog_defer_3(scanent, string_sprintf(
-                             "unable to send quit request to socket (%s): %s",
-                             scanner_options, strerror(errno)),
-                             sock);
-               malware_name = NULL;
-               avast_stage = AVA_DONE;
-               goto endloop;
-               }
+             if (regex_match(ava_re_clean, buf, slen, NULL))
+               break;
+
+              if ((malware_name = m_pcre_exec(ava_re_virus, buf)))
+                {
+                unescape(malware_name);
+                DEBUG(D_acl)
+                  debug_printf_indent("unescaped malware name: '%s'\n", malware_name);
+                break;
+                }
+
+              if (strict)           /* treat scanner errors as malware */
+                {
+                if ((malware_name = m_pcre_exec(ava_re_error, buf)))
+                  {
+                  unescape(malware_name);
+                  DEBUG(D_acl)
+                    debug_printf_indent("unescaped error message: '%s'\n", malware_name);
+                  break;
+                  }
+                }
+              else if (regex_match(ava_re_error, buf, slen, NULL))
+                {
+                log_write(0, LOG_MAIN, "internal scanner error (ignored): %s", buf);
+                break;
+                }
+
+             /* here also for any unexpected response from the scanner */
+              DEBUG(D_acl) debug_printf("avast response not handled: '%s'\n", buf);
 
 
-             /* here for any unexpected response from the scanner */
              goto endloop;
              goto endloop;
+
+           default:    log_write(0, LOG_PANIC, "%s:%d:%s: should not happen",
+                           __FILE__, __LINE__, __FUNCTION__);
            }
          }
        }
            }
          }
        }
+
       endloop:
 
       endloop:
 
-      switch(avast_stage)
-       {
-       case AVA_HELO:  
-       case AVA_OPT:
-       case AVA_RSP:   return m_errlog_defer_3(scanent,
-                           nread >= 0
-                           ? string_sprintf(
-                               "invalid response from scanner: '%s'", buf)
-                           : nread == -1
-                           ? US"EOF from scanner"
-                           : US"timeout from scanner",
-                         sock);
-       default:        break;
-       }
+      if (nread == -1) error_message = US"EOF from scanner";
+      else if (nread < 0) error_message = US"timeout from scanner";
+      else if (nread == 0) error_message = US"got nothing from scanner";
+      else if (buf[0] != '2') error_message = buf;
+
+      DEBUG(D_acl) debug_printf_indent("sent to avast QUIT\n");
+      if (send(malware_daemon_ctx.sock, "QUIT\n", 5, 0) == -1)
+        return m_panic_defer_3(scanent, CUS callout_address,
+          string_sprintf("unable to send quit request to socket (%s): %s",
+            scanner_options, strerror(errno)), malware_daemon_ctx.sock);
+
+      if (error_message)
+        return m_panic_defer_3(scanent, CUS callout_address, error_message, malware_daemon_ctx.sock);
+
       }
       }
-      break;
+#endif
   }    /* scanner type switch */
 
   }    /* scanner type switch */
 
-  if (sock >= 0)
-    (void) close (sock);
+  if (malware_daemon_ctx.sock >= 0)
+    (void) close (malware_daemon_ctx.sock);
   malware_ok = TRUE;                   /* set "been here, done that" marker */
   }
 
 /* match virus name against pattern (caseless ------->----------v) */
 if (malware_name && regex_match_and_setup(re, malware_name, 0, -1))
   {
   malware_ok = TRUE;                   /* set "been here, done that" marker */
   }
 
 /* match virus name against pattern (caseless ------->----------v) */
 if (malware_name && regex_match_and_setup(re, malware_name, 0, -1))
   {
-  DEBUG(D_acl) debug_printf(
+  DEBUG(D_acl) debug_printf_indent(
       "Matched regex to malware [%s] [%s]\n", malware_re, malware_name);
   return OK;
   }
       "Matched regex to malware [%s] [%s]\n", malware_re, malware_name);
   return OK;
   }
@@ -1930,23 +2206,19 @@ filename; it's a wrapper around the malware_file function.
 
 Arguments:
   malware_re  match condition for "malware="
 
 Arguments:
   malware_re  match condition for "malware="
+  cacheable   the RE did not use any dynamic elements during expansion
   timeout     if nonzero, timeout in seconds
 
 Returns:      Exim message processing code (OK, FAIL, DEFER, ...)
               where true means malware was found (condition applies)
 */
 int
   timeout     if nonzero, timeout in seconds
 
 Returns:      Exim message processing code (OK, FAIL, DEFER, ...)
               where true means malware was found (condition applies)
 */
 int
-malware(const uschar * malware_re, int timeout)
+malware(const uschar * malware_re, BOOL cacheable, int timeout)
 {
 {
-  uschar * scan_filename;
-  int ret;
-
-  scan_filename = string_sprintf("%s/scan/%s/%s.eml",
-                   spool_directory, message_id, message_id);
-  ret = malware_internal(malware_re, scan_filename, timeout, FALSE);
-  if (ret == DEFER) av_failed = TRUE;
+int ret = malware_internal(malware_re, cacheable, NULL, timeout);
 
 
-  return ret;
+if (ret == DEFER) av_failed = TRUE;
+return ret;
 }
 
 
 }
 
 
@@ -1968,32 +2240,35 @@ Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
 int
 malware_in_file(uschar *eml_filename)
 {
 int
 malware_in_file(uschar *eml_filename)
 {
-  uschar message_id_buf[64];
-  int ret;
-
-  /* spool_mbox() assumes various parameters exist, when creating
-  the relevant directory and the email within */
-  (void) string_format(message_id_buf, sizeof(message_id_buf),
-      "dummy-%d", vaguely_random_number(INT_MAX));
-  message_id = message_id_buf;
-  sender_address = US"malware-sender@example.net";
-  return_path = US"";
-  recipients_list = NULL;
-  receive_add_recipient(US"malware-victim@example.net", -1);
-  enable_dollar_recipients = TRUE;
-
-  ret = malware_internal(US"*", eml_filename, 0,  TRUE);
-
-  Ustrncpy(spooled_message_id, message_id, sizeof(spooled_message_id));
-  spool_mbox_ok = 1;
-  /* don't set no_mbox_unspool; at present, there's no way for it to become
-  set, but if that changes, then it should apply to these tests too */
-  unspool_mbox();
-
-  /* silence static analysis tools */
-  message_id = NULL;
-
-  return ret;
+uschar message_id_buf[64];
+int ret;
+
+/* spool_mbox() assumes various parameters exist, when creating
+the relevant directory and the email within */
+
+(void) string_format(message_id_buf, sizeof(message_id_buf),
+    "dummy-%d", vaguely_random_number(INT_MAX));
+message_id = message_id_buf;
+sender_address = US"malware-sender@example.net";
+return_path = US"";
+recipients_list = NULL;
+receive_add_recipient(US"malware-victim@example.net", -1);
+f.enable_dollar_recipients = TRUE;
+
+ret = malware_internal(US"*", TRUE, eml_filename, 0);
+
+Ustrncpy(spooled_message_id, message_id, sizeof(spooled_message_id));
+spool_mbox_ok = 1;
+
+/* don't set no_mbox_unspool; at present, there's no way for it to become
+set, but if that changes, then it should apply to these tests too */
+
+unspool_mbox();
+
+/* silence static analysis tools */
+message_id = NULL;
+
+return ret;
 }
 
 
 }
 
 
@@ -2001,21 +2276,50 @@ void
 malware_init(void)
 {
 if (!malware_default_re)
 malware_init(void)
 {
 if (!malware_default_re)
-  malware_default_re = regex_must_compile(malware_regex_default, FALSE, TRUE);
+  malware_default_re = regex_must_compile(malware_regex_default, MCS_NOFLAGS, TRUE);
+
+#ifndef DISABLE_MAL_DRWEB
 if (!drweb_re)
 if (!drweb_re)
-  drweb_re = regex_must_compile(drweb_re_str, FALSE, TRUE);
+  drweb_re = regex_must_compile(drweb_re_str, MCS_NOFLAGS, TRUE);
+#endif
+#ifndef DISABLE_MAL_FSECURE
 if (!fsec_re)
 if (!fsec_re)
-  fsec_re = regex_must_compile(fsec_re_str, FALSE, TRUE);
+  fsec_re = regex_must_compile(fsec_re_str, MCS_NOFLAGS, TRUE);
+#endif
+#ifndef DISABLE_MAL_KAV
 if (!kav_re_sus)
 if (!kav_re_sus)
-  kav_re_sus = regex_must_compile(kav_re_sus_str, FALSE, TRUE);
+  kav_re_sus = regex_must_compile(kav_re_sus_str, MCS_NOFLAGS, TRUE);
 if (!kav_re_inf)
 if (!kav_re_inf)
-  kav_re_inf = regex_must_compile(kav_re_inf_str, FALSE, TRUE);
+  kav_re_inf = regex_must_compile(kav_re_inf_str, MCS_NOFLAGS, TRUE);
+#endif
+#ifndef DISABLE_MAL_AVAST
 if (!ava_re_clean)
 if (!ava_re_clean)
-  ava_re_clean = regex_must_compile(ava_re_clean_str, FALSE, TRUE);
+  ava_re_clean = regex_must_compile(ava_re_clean_str, MCS_NOFLAGS, TRUE);
 if (!ava_re_virus)
 if (!ava_re_virus)
-  ava_re_virus = regex_must_compile(ava_re_virus_str, FALSE, TRUE);
+  ava_re_virus = regex_must_compile(ava_re_virus_str, MCS_NOFLAGS, TRUE);
+if (!ava_re_error)
+  ava_re_error = regex_must_compile(ava_re_error_str, MCS_NOFLAGS, TRUE);
+#endif
+#ifndef DISABLE_MAL_FFROT6D
+if (!fprot6d_re_error)
+  fprot6d_re_error = regex_must_compile(fprot6d_re_error_str, MCS_NOFLAGS, TRUE);
+if (!fprot6d_re_virus)
+  fprot6d_re_virus = regex_must_compile(fprot6d_re_virus_str, MCS_NOFLAGS, TRUE);
+#endif
 }
 
 }
 
+
+gstring *
+malware_show_supported(gstring * g)
+{
+g = string_cat(g, US"Malware:");
+for (struct scan * sc = m_scans; sc->scancode != (scanner_t)-1; sc++)
+  g = string_fmt_append(g, " %s", sc->name);
+return string_cat(g, US"\n");
+}
+
+
+# endif        /*!MACRO_PREDEF*/
 #endif /*WITH_CONTENT_SCAN*/
 /*
  * vi: aw ai sw=2
 #endif /*WITH_CONTENT_SCAN*/
 /*
  * vi: aw ai sw=2
Master Exim source repository