src/src/malware.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003-2014 */
   6 /* License: GPL */
   7
   8 /* Code for calling virus (malware) scanners. Called from acl.c. */
   9
  10 #include "exim.h"
  11 #ifdef WITH_CONTENT_SCAN
  12
  13 typedef enum {M_FPROTD, M_DRWEB, M_AVES, M_FSEC, M_KAVD, M_CMDL,
  14                 M_SOPHIE, M_CLAMD, M_SOCK, M_MKSD} scanner_t;
  15 typedef enum {MC_NONE, MC_TCP, MC_UNIX, MC_STRM} contype_t;
  16 static struct scan
  17 {
  18   scanner_t     scancode;
  19   const uschar * name;
  20   const uschar * options_default;
  21   contype_t     conn;
  22 } m_scans[] =
  23 {
  24   { M_FPROTD,   US"f-protd",    US"localhost 10200-10204",            MC_TCP },
  25   { M_DRWEB,    US"drweb",      US"/usr/local/drweb/run/drwebd.sock", MC_STRM },
  26   { M_AVES,     US"aveserver",  US"/var/run/aveserver",               MC_UNIX },
  27   { M_FSEC,     US"fsecure",    US"/var/run/.fsav",                   MC_UNIX },
  28   { M_KAVD,     US"kavdaemon",  US"/var/run/AvpCtl",                  MC_UNIX },
  29   { M_CMDL,     US"cmdline",    NULL,                                 MC_NONE },
  30   { M_SOPHIE,   US"sophie",     US"/var/run/sophie",                  MC_UNIX },
  31   { M_CLAMD,    US"clamd",      US"/tmp/clamd",                       MC_NONE },
  32   { M_SOCK,     US"sock",       US"/tmp/malware.sock",                MC_STRM },
  33   { M_MKSD,     US"mksd",       NULL,                                 MC_NONE },
  34   { -1,         NULL,           NULL, MC_NONE }         /* end-marker */
  35 };
  36
  37 /* The maximum number of clamd servers that are supported in the configuration */
  38 #define MAX_CLAMD_SERVERS 32
  39 #define MAX_CLAMD_SERVERS_S "32"
  40 /* Maximum length of the hostname that can be specified in the clamd address list */
  41 #define MAX_CLAMD_ADDRESS_LENGTH 64
  42 #define MAX_CLAMD_ADDRESS_LENGTH_S "64"
  43
  44 typedef struct clamd_address_container {
  45   uschar tcp_addr[MAX_CLAMD_ADDRESS_LENGTH+1];
  46   unsigned int tcp_port;
  47 } clamd_address_container;
  48
  49 /* declaration of private routines */
  50 static int mksd_scan_packed(struct scan * scanent, int sock, uschar *scan_filename);
  51 static int malware_internal(uschar **listptr, uschar *eml_filename, BOOL faking);
  52
  53 #ifndef nelements
  54 # define nelements(arr) (sizeof(arr) / sizeof(arr[0]))
  55 #endif
  56
  57
  58 #define        MALWARE_TIMEOUT             120
  59
  60
  61 #define DRWEBD_SCAN_CMD             (1)     /* scan file, buffer or diskfile */
  62 #define DRWEBD_RETURN_VIRUSES       (1<<0)   /* ask daemon return to us viruses names from report */
  63 #define DRWEBD_IS_MAIL              (1<<19)  /* say to daemon that format is "archive MAIL" */
  64
  65 #define DERR_READ_ERR               (1<<0)   /* read error */
  66 #define DERR_NOMEMORY               (1<<2)   /* no memory */
  67 #define DERR_TIMEOUT                (1<<9)   /* scan timeout has run out */
  68 #define DERR_BAD_CALL               (1<<15)  /* wrong command */
  69
  70 /* Routine to check whether a system is big- or little-endian.
  71    Ripped from http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-7.html
  72    Needed for proper kavdaemon implementation. Sigh. */
  73 #define BIG_MY_ENDIAN      0
  74 #define LITTLE_MY_ENDIAN   1
  75 static int test_byte_order(void);
  76 static inline int
  77 test_byte_order()
  78 {
  79   short int word = 0x0001;
  80   char *byte = (char *) &word;
  81   return(byte[0] ? LITTLE_MY_ENDIAN : BIG_MY_ENDIAN);
  82 }
  83
  84 BOOL malware_ok = FALSE;
  85
  86 /* Gross hacks for the -bmalware option; perhaps we should just create
  87 the scan directory normally for that case, but look into rigging up the
  88 needed header variables if not already set on the command-line? */
  89 extern int spool_mbox_ok;
  90 extern uschar spooled_message_id[17];
  91
  92 /*************************************************
  93 *          Scan an email for malware             *
  94 *************************************************/
  95
  96 /* This is the normal interface for scanning an email, which doesn't need a
  97 filename; it's a wrapper around the malware_file function.
  98
  99 Arguments:
 100   listptr     the list of options to the "malware = ..." ACL condition
 101
 102 Returns:      Exim message processing code (OK, FAIL, DEFER, ...)
 103               where true means malware was found (condition applies)
 104 */
 105 int
 106 malware(uschar **listptr)
 107 {
 108   uschar * scan_filename;
 109   int ret;
 110
 111   scan_filename = string_sprintf("%s/scan/%s/%s.eml",
 112                     spool_directory, message_id, message_id);
 113   ret = malware_internal(listptr, scan_filename, FALSE);
 114   if (ret == DEFER) av_failed = TRUE;
 115
 116   return ret;
 117 }
 118
 119
 120 /*************************************************
 121 *          Scan a file for malware               *
 122 *************************************************/
 123
 124 /* This is a test wrapper for scanning an email, which is not used in
 125 normal processing.  Scan any file, using the Exim scanning interface.
 126 This function tampers with various global variables so is unsafe to use
 127 in any other context.
 128
 129 Arguments:
 130   eml_filename  a file holding the message to be scanned
 131
 132 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
 133                 where true means malware was found (condition applies)
 134 */
 135 int
 136 malware_in_file(uschar *eml_filename)
 137 {
 138   uschar *scan_options[2];
 139   uschar message_id_buf[64];
 140   int ret;
 141
 142   scan_options[0] = US"*";
 143   scan_options[1] = NULL;
 144
 145   /* spool_mbox() assumes various parameters exist, when creating
 146   the relevant directory and the email within */
 147   (void) string_format(message_id_buf, sizeof(message_id_buf),
 148       "dummy-%d", vaguely_random_number(INT_MAX));
 149   message_id = message_id_buf;
 150   sender_address = US"malware-sender@example.net";
 151   return_path = US"";
 152   recipients_list = NULL;
 153   receive_add_recipient(US"malware-victim@example.net", -1);
 154   enable_dollar_recipients = TRUE;
 155
 156   ret = malware_internal(scan_options, eml_filename, TRUE);
 157
 158   Ustrncpy(spooled_message_id, message_id, sizeof(spooled_message_id));
 159   spool_mbox_ok = 1;
 160   /* don't set no_mbox_unspool; at present, there's no way for it to become
 161   set, but if that changes, then it should apply to these tests too */
 162   unspool_mbox();
 163
 164   /* silence static analysis tools */
 165   message_id = NULL;
 166
 167   return ret;
 168 }
 169
 170
 171 static inline int
 172 malware_errlog_defer(const uschar * str)
 173 {
 174   log_write(0, LOG_MAIN|LOG_PANIC, "malware acl condition: %s", str);
 175   return DEFER;
 176 }
 177
 178 static int
 179 m_errlog_defer(struct scan * scanent, const uschar * str)
 180 {
 181   return malware_errlog_defer(string_sprintf("%s: %s", scanent->name, str));
 182 }
 183 static int
 184 m_errlog_defer_3(struct scan * scanent, const uschar * str,
 185         int fd_to_close)
 186 {
 187   (void) close(fd_to_close);
 188   return m_errlog_defer(scanent, str);
 189 }
 190
 191 /*************************************************/
 192
 193 /* Only used by the Clamav code, which is working from a list of servers and
 194 uses the returned in_addr to get a second connection to the same system.
 195 */
 196 static inline int
 197 m_tcpsocket(const uschar * hostname, unsigned int port,
 198         host_item * host, uschar ** errstr)
 199 {
 200   return ip_connectedsocket(SOCK_STREAM, hostname, port, port, 5, host, errstr);
 201 }
 202
 203 static int
 204 m_tcpsocket_fromdef(const uschar * hostport, uschar ** errstr)
 205 {
 206   int scan;
 207   uschar hostname[256];
 208   unsigned int portlow, porthigh;
 209
 210   /* extract host and port part */
 211   scan = sscanf(CS hostport, "%255s %u-%u", hostname, &portlow, &porthigh);
 212   if ( scan != 3 ) {
 213     if ( scan != 2 ) {
 214       *errstr = string_sprintf("invalid socket '%s'", hostport);
 215       return -1;
 216     }
 217     porthigh = portlow;
 218   }
 219
 220   return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
 221                             5, NULL, errstr);
 222 }
 223
 224 static int
 225 m_unixsocket(const uschar * path, uschar ** errstr)
 226 {
 227   int sock;
 228   struct sockaddr_un server;
 229
 230   if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 231     *errstr = US"can't open UNIX socket.";
 232     return -1;
 233   }
 234
 235   server.sun_family = AF_UNIX;
 236   Ustrncpy(server.sun_path, path, sizeof(server.sun_path)-1);
 237   server.sun_path[sizeof(server.sun_path)-1] = '\0';
 238   if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0) {
 239     int err = errno;
 240     (void)close(sock);
 241     *errstr =  string_sprintf("unable to connect to UNIX socket (%s): %s",
 242                   path, strerror(err));
 243     return -1;
 244     }
 245   return sock;
 246 }
 247
 248 static inline int
 249 m_streamsocket(const uschar * spec, uschar ** errstr)
 250 {
 251   return *spec == '/'
 252     ? m_unixsocket(spec, errstr) : m_tcpsocket_fromdef(spec, errstr);
 253 }
 254
 255 static int
 256 m_sock_send(int sock, uschar * buf, int cnt, uschar ** errstr)
 257 {
 258   if (send(sock, buf, cnt, 0) < 0) {
 259     int err = errno;
 260     (void)close(sock);
 261     *errstr = string_sprintf("unable to send to socket (%s): %s",
 262            buf, strerror(err));
 263     return -1;
 264     }
 265   return sock;
 266 }
 267
 268 static const pcre *
 269 m_pcre_compile(const uschar * re, uschar ** errstr)
 270 {
 271   const uschar * rerror;
 272   int roffset;
 273   const pcre * cre;
 274
 275   cre = pcre_compile(CS re, PCRE_COPT, (const char **)&rerror, &roffset, NULL);
 276   if (!cre)
 277     *errstr= string_sprintf("regular expression error in '%s': %s at offset %d",
 278         re, rerror, roffset);
 279   return cre;
 280 }
 281
 282 uschar *
 283 m_pcre_exec(const pcre * cre, uschar * text)
 284 {
 285   int ovector[10*3];
 286   int i = pcre_exec(cre, NULL, CS text, Ustrlen(text), 0, 0,
 287                 ovector, nelements(ovector));
 288   uschar * substr = NULL;
 289   if (i >= 2)                           /* Got it */
 290     pcre_get_substring(CS text, ovector, i, 1, (const char **) &substr);
 291   return substr;
 292 }
 293
 294 static const pcre *
 295 m_pcre_nextinlist(uschar ** list, int * sep, char * listerr, uschar ** errstr)
 296 {
 297   const uschar * list_ele;
 298   const pcre * cre = NULL;
 299
 300   if (!(list_ele = string_nextinlist(list, sep, NULL, 0)))
 301     *errstr = US listerr;
 302   else
 303     cre = m_pcre_compile(CUS list_ele, errstr);
 304   return cre;
 305 }
 306
 307 /*************************************************
 308 *          Scan content for malware              *
 309 *************************************************/
 310
 311 /* This is an internal interface for scanning an email; the normal interface
 312 is via malware(), or there's malware_in_file() used for testing/debugging.
 313
 314 Arguments:
 315   listptr       the list of options to the "malware = ..." ACL condition
 316   eml_filename  the file holding the email to be scanned
 317   faking        whether or not we're faking this up for the -bmalware test
 318
 319 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
 320                 where true means malware was found (condition applies)
 321 */
 322 static int
 323 malware_internal(uschar **listptr, uschar *eml_filename, BOOL faking)
 324 {
 325   int sep = 0;
 326   uschar *list = *listptr;
 327   uschar *av_scanner_work = av_scanner;
 328   uschar *scanner_name;
 329   uschar *malware_regex;
 330   uschar malware_regex_default[] = ".+";
 331   unsigned long mbox_size;
 332   FILE *mbox_file;
 333   const pcre *re;
 334   uschar * errstr;
 335   struct scan * scanent;
 336   const uschar * scanner_options;
 337   int sock = -1;
 338
 339   /* make sure the eml mbox file is spooled up */
 340   if (!(mbox_file = spool_mbox(&mbox_size, faking ? eml_filename : NULL)))
 341     return malware_errlog_defer(US"error while creating mbox spool file");
 342
 343   /* none of our current scanners need the mbox
 344      file as a stream, so we can close it right away */
 345   (void)fclose(mbox_file);
 346
 347   /* extract the malware regex to match against from the option list */
 348   if (!(malware_regex = string_nextinlist(&list, &sep, NULL, 0)))
 349     return FAIL;                /* empty means "don't match anything" */
 350
 351   /* parse 1st option */
 352     if ( (strcmpic(malware_regex,US"false") == 0) ||
 353        (Ustrcmp(malware_regex,"0") == 0) )
 354     return FAIL;                /* explicitly no matching */
 355
 356   /* special cases (match anything except empty) */
 357   if ( (strcmpic(malware_regex,US"true") == 0) ||
 358        (Ustrcmp(malware_regex,"*") == 0) ||
 359        (Ustrcmp(malware_regex,"1") == 0) )
 360     malware_regex = malware_regex_default;
 361
 362   /* Reset sep that is set by previous string_nextinlist() call */
 363   sep = 0;
 364
 365   /* compile the regex, see if it works */
 366   if (!(re = m_pcre_compile(malware_regex, &errstr)))
 367     return malware_errlog_defer(errstr);
 368
 369   /* if av_scanner starts with a dollar, expand it first */
 370   if (*av_scanner == '$') {
 371     if (!(av_scanner_work = expand_string(av_scanner)))
 372       return malware_errlog_defer(
 373            string_sprintf("av_scanner starts with $, but expansion failed: %s",
 374            expand_string_message));
 375
 376     debug_printf("Expanded av_scanner global: %s\n", av_scanner_work);
 377     /* disable result caching in this case */
 378     malware_name = NULL;
 379     malware_ok = FALSE;
 380   }
 381
 382   /* Do not scan twice (unless av_scanner is dynamic). */
 383   if (!malware_ok) {
 384
 385     /* find the scanner type from the av_scanner option */
 386     if (!(scanner_name = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 387       return malware_errlog_defer(US"av_scanner configuration variable is empty");
 388
 389     for (scanent = m_scans; ; scanent++) {
 390       if (!scanent->name)
 391         return malware_errlog_defer(string_sprintf("unknown scanner type '%s'",
 392           scanner_name));
 393       if (strcmpic(scanner_name, US scanent->name) != 0)
 394         continue;
 395       if (!(scanner_options = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 396         scanner_options = scanent->options_default;
 397       if (scanent->conn == MC_NONE)
 398         break;
 399       switch(scanent->conn)
 400       {
 401       case MC_TCP:  sock = m_tcpsocket_fromdef(scanner_options, &errstr); break;
 402       case MC_UNIX: sock = m_unixsocket(scanner_options, &errstr);        break;
 403       case MC_STRM: sock = m_streamsocket(scanner_options, &errstr);      break;
 404       default: /* compiler quietening */ break;
 405       }
 406       if (sock < 0)
 407         return m_errlog_defer(scanent, errstr);
 408       break;
 409     }
 410     DEBUG(D_lookup) debug_printf("Malware scan: %s\n", scanner_name);
 411
 412     switch (scanent->scancode) {
 413     case M_FPROTD: /* "f-protd" scanner type -------------------------------- */
 414       {
 415         uschar *fp_scan_option;
 416         unsigned int detected=0, par_count=0;
 417         uschar * scanrequest;
 418         uschar buf[32768], *strhelper, *strhelper2;
 419         uschar * malware_name_internal = NULL;
 420
 421         DEBUG(D_acl) debug_printf("Malware scan: issuing %s GET\n", scanner_name);
 422         scanrequest = string_sprintf("GET %s", eml_filename);
 423
 424         while ((fp_scan_option = string_nextinlist(&av_scanner_work, &sep,
 425                               NULL, 0))) {
 426           scanrequest = string_sprintf("%s%s%s", scanrequest,
 427                                     par_count ? "%20" : "?", fp_scan_option);
 428           par_count++;
 429         }
 430         scanrequest = string_sprintf("%s HTTP/1.0\r\n\r\n", scanrequest);
 431
 432         /* send scan request */
 433         if (m_sock_send(sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
 434           return m_errlog_defer(scanent, errstr);
 435
 436         /* We get a lot of empty lines, so we need this hack to check for any data at all */
 437         while( recv(sock, buf, 1, MSG_PEEK) > 0 ) {
 438           if ( recv_line(sock, buf, sizeof(buf)) > 0) {
 439             if ( Ustrstr(buf, US"<detected type=\"") != NULL )
 440               detected = 1;
 441             else if ( detected && (strhelper = Ustrstr(buf, US"<name>")) ) {
 442               if ((strhelper2 = Ustrstr(buf, US"</name>")) != NULL) {
 443                 *strhelper2 = '\0';
 444                 malware_name_internal = string_copy(strhelper+6);
 445               }
 446             } else if ( Ustrstr(buf, US"<summary code=\"") )
 447                 malware_name = Ustrstr(buf, US"<summary code=\"11\">")
 448                   ? malware_name_internal : NULL;
 449           }
 450         }
 451         break;
 452       } /* f-protd */
 453
 454     case M_DRWEB: /* "drweb" scanner type ----------------------------------- */
 455     /* v0.1 - added support for tcp sockets          */
 456     /* v0.0 - initial release -- support for unix sockets      */
 457       {
 458         int result;
 459         unsigned int fsize;
 460         uschar * tmpbuf, *drweb_fbuf;
 461         int drweb_rc, drweb_cmd, drweb_flags = 0x0000, drweb_fd,
 462             drweb_vnum, drweb_slen, drweb_fin = 0x0000;
 463         unsigned long bread;
 464         const pcre *drweb_re;
 465
 466         /* prepare variables */
 467         drweb_cmd = htonl(DRWEBD_SCAN_CMD);
 468         drweb_flags = htonl(DRWEBD_RETURN_VIRUSES | DRWEBD_IS_MAIL);
 469
 470         if (*scanner_options != '/') {
 471
 472           /* calc file size */
 473           if ((drweb_fd = open(CS eml_filename, O_RDONLY)) == -1)
 474             return m_errlog_defer_3(scanent,
 475               string_sprintf("can't open spool file %s: %s",
 476                 eml_filename, strerror(errno)),
 477               sock);
 478
 479           if ((fsize = lseek(drweb_fd, 0, SEEK_END)) == -1) {
 480             int err = errno;
 481             (void)close(drweb_fd);
 482             return m_errlog_defer_3(scanent,
 483               string_sprintf("can't seek spool file %s: %s",
 484                 eml_filename, strerror(err)),
 485               sock);
 486           }
 487           drweb_slen = htonl(fsize);
 488           lseek(drweb_fd, 0, SEEK_SET);
 489
 490           DEBUG(D_acl) debug_printf("Malware scan: issuing %s remote scan [%s]\n",
 491               scanner_name, scanner_options);
 492
 493           /* send scan request */
 494           if ((send(sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
 495               (send(sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
 496               (send(sock, &drweb_fin, sizeof(drweb_fin), 0) < 0) ||
 497               (send(sock, &drweb_slen, sizeof(drweb_slen), 0) < 0)) {
 498             (void)close(drweb_fd);
 499             return m_errlog_defer_3(scanent,
 500               string_sprintf("unable to send commands to socket (%s)", scanner_options),
 501               sock);
 502           }
 503
 504           if (!(drweb_fbuf = (uschar *) malloc (fsize))) {
 505             (void)close(drweb_fd);
 506             return m_errlog_defer_3(scanent,
 507               string_sprintf("unable to allocate memory %u for file (%s)",
 508                 fsize, eml_filename),
 509               sock);
 510           }
 511
 512           if ((result = read (drweb_fd, drweb_fbuf, fsize)) == -1) {
 513             int err = errno;
 514             (void)close(drweb_fd);
 515             free(drweb_fbuf);
 516             return m_errlog_defer_3(scanent,
 517               string_sprintf("can't read spool file %s: %s",
 518                 eml_filename, strerror(err)),
 519               sock);
 520           }
 521           (void)close(drweb_fd);
 522
 523           /* send file body to socket */
 524           if (send(sock, drweb_fbuf, fsize, 0) < 0) {
 525             free(drweb_fbuf);
 526             return m_errlog_defer_3(scanent,
 527               string_sprintf("unable to send file body to socket (%s)", scanner_options),
 528             sock);
 529           }
 530           (void)close(drweb_fd);
 531
 532         } else {
 533
 534           drweb_slen = htonl(Ustrlen(eml_filename));
 535
 536           DEBUG(D_acl) debug_printf("Malware scan: issuing %s local scan [%s]\n",
 537               scanner_name, scanner_options);
 538
 539           /* send scan request */
 540           if ((send(sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
 541               (send(sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
 542               (send(sock, &drweb_slen, sizeof(drweb_slen), 0) < 0) ||
 543               (send(sock, eml_filename, Ustrlen(eml_filename), 0) < 0) ||
 544               (send(sock, &drweb_fin, sizeof(drweb_fin), 0) < 0))
 545             return m_errlog_defer_3(scanent,
 546               string_sprintf("unable to send commands to socket (%s)", scanner_options),
 547               sock);
 548         }
 549
 550         /* wait for result */
 551         if ((bread = recv(sock, &drweb_rc, sizeof(drweb_rc), 0) != sizeof(drweb_rc)))
 552           return m_errlog_defer_3(scanent,
 553                       US"unable to read return code", sock);
 554         drweb_rc = ntohl(drweb_rc);
 555
 556         if ((bread = recv(sock, &drweb_vnum, sizeof(drweb_vnum), 0) != sizeof(drweb_vnum)))
 557           return m_errlog_defer_3(scanent,
 558                               US"unable to read the number of viruses", sock);
 559         drweb_vnum = ntohl(drweb_vnum);
 560
 561         /* "virus(es) found" if virus number is > 0 */
 562         if (drweb_vnum) {
 563           int i;
 564
 565           /* setup default virus name */
 566           malware_name = US"unknown";
 567
 568           /* set up match regex */
 569           drweb_re = m_pcre_compile(US"infected\\swith\\s*(.+?)$", &errstr);
 570
 571           /* read and concatenate virus names into one string */
 572           for (i=0;i<drweb_vnum;i++)
 573           {
 574             int size = 0, off = 0, ovector[10*3];
 575             /* read the size of report */
 576             if ((bread = recv(sock, &drweb_slen, sizeof(drweb_slen), 0) != sizeof(drweb_slen)))
 577               return m_errlog_defer_3(scanent,
 578                                 US"cannot read report size", sock);
 579             drweb_slen = ntohl(drweb_slen);
 580             tmpbuf = store_get(drweb_slen);
 581
 582             /* read report body */
 583             if ((bread = recv(sock, tmpbuf, drweb_slen, 0)) != drweb_slen)
 584               return m_errlog_defer_3(scanent,
 585                                 US"cannot read report string", sock);
 586             tmpbuf[drweb_slen] = '\0';
 587
 588             /* try matcher on the line, grab substring */
 589             result = pcre_exec(drweb_re, NULL, CS tmpbuf, Ustrlen(tmpbuf), 0, 0,
 590                                     ovector, nelements(ovector));
 591             if (result >= 2) {
 592               const char * pre_malware_nb;
 593
 594               pcre_get_substring(CS tmpbuf, ovector, result, 1, &pre_malware_nb);
 595
 596               if (i==0) /* the first name we just copy to malware_name */
 597                 malware_name = string_append(NULL, &size, &off,
 598                                             1, pre_malware_nb);
 599
 600               else      /* concatenate each new virus name to previous */
 601                 malware_name = string_append(malware_name, &size, &off,
 602                                             2, "/", pre_malware_nb);
 603
 604               pcre_free_substring(pre_malware_nb);
 605             }
 606           }
 607         }
 608         else {
 609           const char *drweb_s = NULL;
 610
 611           if (drweb_rc & DERR_READ_ERR) drweb_s = "read error";
 612           if (drweb_rc & DERR_NOMEMORY) drweb_s = "no memory";
 613           if (drweb_rc & DERR_TIMEOUT)  drweb_s = "timeout";
 614           if (drweb_rc & DERR_BAD_CALL) drweb_s = "wrong command";
 615           /* retcodes DERR_SYMLINK, DERR_NO_REGFILE, DERR_SKIPPED.
 616            * DERR_TOO_BIG, DERR_TOO_COMPRESSED, DERR_SPAM,
 617            * DERR_CRC_ERROR, DERR_READSOCKET, DERR_WRITE_ERR
 618            * and others are ignored */
 619           if (drweb_s)
 620             return m_errlog_defer_3(scanent,
 621               string_sprintf("drweb daemon retcode 0x%x (%s)", drweb_rc, drweb_s),
 622               sock);
 623
 624           /* no virus found */
 625           malware_name = NULL;
 626         }
 627         break;
 628       } /* drweb */
 629
 630     case M_AVES: /* "aveserver" scanner type -------------------------------- */
 631       {
 632         uschar buf[32768];
 633         int result;
 634
 635         /* read aveserver's greeting and see if it is ready (2xx greeting) */
 636         recv_line(sock, buf, sizeof(buf));
 637
 638         if (buf[0] != '2')              /* aveserver is having problems */
 639           return m_errlog_defer_3(scanent,
 640             string_sprintf("unavailable (Responded: %s).",
 641                             ((buf[0] != 0) ? buf : (uschar *)"nothing") ),
 642             sock);
 643
 644         /* prepare our command */
 645         (void)string_format(buf, sizeof(buf), "SCAN bPQRSTUW %s\r\n",
 646                                                   eml_filename);
 647
 648         DEBUG(D_acl) debug_printf("Malware scan: issuing %s SCAN\n", scanner_name);
 649
 650         /* and send it */
 651         if (m_sock_send(sock, buf, Ustrlen(buf), &errstr) < 0)
 652           return m_errlog_defer(scanent, errstr);
 653
 654         malware_name = NULL;
 655         result = 0;
 656         /* read response lines, find malware name and final response */
 657         while (recv_line(sock, buf, sizeof(buf)) > 0) {
 658           debug_printf("aveserver: %s\n", buf);
 659           if (buf[0] == '2')
 660             break;
 661           if (buf[0] == '5') {          /* aveserver is having problems */
 662             result = m_errlog_defer(scanent,
 663                string_sprintf("unable to scan file %s (Responded: %s).",
 664                                eml_filename, buf));
 665             break;
 666           } else if (Ustrncmp(buf,"322",3) == 0) {
 667             uschar *p = Ustrchr(&buf[4],' ');
 668             *p = '\0';
 669             malware_name = string_copy(&buf[4]);
 670           }
 671         }
 672
 673         /* and send it */
 674         if (m_sock_send(sock, US"quit\r\n", 6, &errstr) < 0)
 675           return m_errlog_defer(scanent, errstr);
 676
 677         /* read aveserver's greeting and see if it is ready (2xx greeting) */
 678         recv_line(sock, buf, sizeof(buf));
 679
 680         if (buf[0] != '2')              /* aveserver is having problems */
 681           return m_errlog_defer_3(scanent,
 682             string_sprintf("unable to quit dialogue (Responded: %s).",
 683                           ((buf[0] != 0) ? buf : (uschar *)"nothing") ),
 684             sock);
 685
 686         if (result == DEFER) {
 687           (void)close(sock);
 688           return DEFER;
 689         }
 690         break;
 691       } /* aveserver */
 692
 693     case M_FSEC: /* "fsecure" scanner type ---------------------------------- */
 694       {
 695         int i, j, bread = 0;
 696         uschar * file_name;
 697         uschar av_buffer[1024];
 698         const pcre * fs_inf;
 699         static uschar *cmdopt[] = { US"CONFIGURE\tARCHIVE\t1\n",
 700                                         US"CONFIGURE\tTIMEOUT\t0\n",
 701                                         US"CONFIGURE\tMAXARCH\t5\n",
 702                                         US"CONFIGURE\tMIME\t1\n" };
 703
 704         malware_name = NULL;
 705
 706         DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
 707             scanner_name, scanner_options);
 708
 709         /* pass options */
 710         memset(av_buffer, 0, sizeof(av_buffer));
 711         for (i=0; i != nelements(cmdopt); i++) {
 712
 713           if (m_sock_send(sock, cmdopt[i], Ustrlen(cmdopt[i]), &errstr) < 0)
 714             return m_errlog_defer(scanent, errstr);
 715
 716           bread = ip_recv(sock, av_buffer, sizeof(av_buffer), MALWARE_TIMEOUT);
 717           if (bread >0) av_buffer[bread]='\0';
 718           if (bread < 0)
 719             return m_errlog_defer_3(scanent,
 720               string_sprintf("unable to read answer %d (%s)", i, strerror(errno)),
 721               sock);
 722           for (j=0;j<bread;j++)
 723             if((av_buffer[j]=='\r')||(av_buffer[j]=='\n'))
 724               av_buffer[j] ='@';
 725         }
 726
 727         /* pass the mailfile to fsecure */
 728         file_name = string_sprintf("SCAN\t%s\n", eml_filename);
 729
 730         if (m_sock_send(sock, file_name, Ustrlen(file_name), &errstr) < 0)
 731           return m_errlog_defer(scanent, errstr);
 732
 733         /* set up match */
 734         /* todo also SUSPICION\t */
 735         fs_inf = m_pcre_compile(US"\\S{0,5}INFECTED\\t[^\\t]*\\t([^\\t]+)\\t\\S*$", &errstr);
 736
 737         /* read report, linewise */
 738         do {
 739           i = 0;
 740           memset(av_buffer, 0, sizeof(av_buffer));
 741           do {
 742             if ((bread= ip_recv(sock, &av_buffer[i], 1, MALWARE_TIMEOUT)) < 0)
 743               return m_errlog_defer_3(scanent,
 744                 string_sprintf("unable to read result (%s)", strerror(errno)),
 745                 sock);
 746           } while (++i < sizeof(av_buffer)-1  &&  av_buffer[i-1] != '\n');
 747           av_buffer[i-1] = '\0';
 748
 749           /* Really search for virus again? */
 750           if (malware_name == NULL)
 751             /* try matcher on the line, grab substring */
 752             malware_name = m_pcre_exec(fs_inf, av_buffer);
 753         }
 754         while (Ustrstr(av_buffer, "OK\tScan ok.") == NULL);
 755         break;
 756       } /* fsecure */
 757
 758     case M_KAVD: /* "kavdaemon" scanner type -------------------------------- */
 759       {
 760         time_t t;
 761         uschar tmpbuf[1024];
 762         uschar * scanrequest;
 763         int kav_rc;
 764         unsigned long kav_reportlen, bread;
 765         const pcre *kav_re;
 766         uschar *p;
 767
 768         /* get current date and time, build scan request */
 769         time(&t);
 770         /* pdp note: before the eml_filename parameter, this scanned the
 771         directory; not finding documentation, so we'll strip off the directory.
 772         The side-effect is that the test framework scanning may end up in
 773         scanning more than was requested, but for the normal interface, this is
 774         fine. */
 775
 776         strftime(CS tmpbuf, sizeof(tmpbuf), "%d %b %H:%M:%S", localtime(&t));
 777         scanrequest = string_sprintf("<0>%s:%s", CS tmpbuf, eml_filename);
 778         p = Ustrrchr(scanrequest, '/');
 779         if (p)
 780           *p = '\0';
 781
 782         DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
 783             scanner_name, scanner_options);
 784
 785         /* send scan request */
 786         if (m_sock_send(sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
 787           return m_errlog_defer(scanent, errstr);
 788
 789         /* wait for result */
 790         if ((bread = recv(sock, tmpbuf, 2, 0) != 2))
 791           return m_errlog_defer_3(scanent,
 792                               US"unable to read 2 bytes from socket.", sock);
 793
 794         /* get errorcode from one nibble */
 795         kav_rc = tmpbuf[ test_byte_order()==LITTLE_MY_ENDIAN ? 0 : 1 ] & 0x0F;
 796         switch(kav_rc)
 797         {
 798         case 5: case 6: /* improper kavdaemon configuration */
 799           return m_errlog_defer_3(scanent,
 800                   US"please reconfigure kavdaemon to NOT disinfect or remove infected files.",
 801                   sock);
 802         case 1:
 803           return m_errlog_defer_3(scanent,
 804                   US"reported 'scanning not completed' (code 1).", sock);
 805         case 7:
 806           return m_errlog_defer_3(scanent,
 807                   US"reported 'kavdaemon damaged' (code 7).", sock);
 808         }
 809
 810         /* code 8 is not handled, since it is ambigous. It appears mostly on
 811         bounces where part of a file has been cut off */
 812
 813         /* "virus found" return codes (2-4) */
 814         if ((kav_rc > 1) && (kav_rc < 5)) {
 815           int report_flag = 0;
 816
 817           /* setup default virus name */
 818           malware_name = US"unknown";
 819
 820           report_flag = tmpbuf[ test_byte_order() == LITTLE_MY_ENDIAN ? 1 : 0 ];
 821
 822           /* read the report, if available */
 823           if( report_flag == 1 ) {
 824             /* read report size */
 825             if ((bread = recv(sock, &kav_reportlen, 4, 0)) != 4)
 826               return m_errlog_defer_3(scanent,
 827                     US"cannot read report size", sock);
 828
 829             /* it's possible that avp returns av_buffer[1] == 1 but the
 830             reportsize is 0 (!?) */
 831             if (kav_reportlen > 0) {
 832               /* set up match regex, depends on retcode */
 833               kav_re = m_pcre_compile( kav_rc == 3
 834                                        ? US"suspicion:\\s*(.+?)\\s*$"
 835                                        : US"infected:\\s*(.+?)\\s*$",
 836                                        &errstr );
 837
 838               /* read report, linewise */
 839               while (kav_reportlen > 0) {
 840                 bread = 0;
 841                 while ( recv(sock, &tmpbuf[bread], 1, 0) == 1 ) {
 842                   kav_reportlen--;
 843                   if ( (tmpbuf[bread] == '\n') || (bread > 1021) ) break;
 844                   bread++;
 845                 }
 846                 bread++;
 847                 tmpbuf[bread] = '\0';
 848
 849                 /* try matcher on the line, grab substring */
 850                 if ((malware_name = m_pcre_exec(kav_re, tmpbuf)))
 851                   break;
 852               }
 853             }
 854           }
 855         }
 856         else /* no virus found */
 857           malware_name = NULL;
 858
 859         break;
 860       }
 861
 862     case M_CMDL: /* "cmdline" scanner type ---------------------------------- */
 863       {
 864         const uschar *cmdline_scanner = scanner_options;
 865         const pcre *cmdline_trigger_re;
 866         const pcre *cmdline_regex_re;
 867         uschar * file_name;
 868         uschar * commandline;
 869         void (*eximsigchld)(int);
 870         void (*eximsigpipe)(int);
 871         FILE *scanner_out = NULL;
 872         FILE *scanner_record = NULL;
 873         uschar linebuffer[32767];
 874         int trigger = 0;
 875         uschar *p;
 876
 877         if (!cmdline_scanner)
 878           return m_errlog_defer(scanent, errstr);
 879
 880         /* find scanner output trigger */
 881         cmdline_trigger_re = m_pcre_nextinlist(&av_scanner_work, &sep,
 882                                   "missing trigger specification", &errstr);
 883         if (!cmdline_trigger_re)
 884           return m_errlog_defer(scanent, errstr);
 885
 886         /* find scanner name regex */
 887         cmdline_regex_re = m_pcre_nextinlist(&av_scanner_work, &sep,
 888                             "missing virus name regex specification", &errstr);
 889         if (!cmdline_regex_re)
 890           return m_errlog_defer(scanent, errstr);
 891
 892         /* prepare scanner call; despite the naming, file_name holds a directory
 893         name which is documented as the value given to %s. */
 894
 895         file_name = string_copy(eml_filename);
 896         p = Ustrrchr(file_name, '/');
 897         if (p)
 898           *p = '\0';
 899         commandline = string_sprintf(CS cmdline_scanner, file_name);
 900
 901         /* redirect STDERR too */
 902         commandline = string_sprintf("%s 2>&1", commandline);
 903
 904         DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n", scanner_name, commandline);
 905
 906         /* store exims signal handlers */
 907         eximsigchld = signal(SIGCHLD,SIG_DFL);
 908         eximsigpipe = signal(SIGPIPE,SIG_DFL);
 909
 910         if (!(scanner_out = popen(CS commandline,"r"))) {
 911           int err = errno;
 912           signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
 913           return m_errlog_defer(scanent,
 914             string_sprintf("call (%s) failed: %s.", commandline, strerror(err)));
 915         }
 916
 917         file_name = string_sprintf("%s/scan/%s/%s_scanner_output",
 918                                   spool_directory, message_id, message_id);
 919         scanner_record = modefopen(file_name, "wb", SPOOL_MODE);
 920
 921         if (scanner_record == NULL) {
 922           int err = errno;
 923           (void) pclose(scanner_out);
 924           signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
 925           return m_errlog_defer(scanent,
 926             string_sprintf("opening scanner output file (%s) failed: %s.",
 927               file_name, strerror(err)));
 928         }
 929
 930         /* look for trigger while recording output */
 931         while(fgets(CS linebuffer, sizeof(linebuffer), scanner_out)) {
 932           if ( Ustrlen(linebuffer) > fwrite(linebuffer, 1, Ustrlen(linebuffer), scanner_record) ) {
 933             /* short write */
 934             (void) pclose(scanner_out);
 935             signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
 936             return m_errlog_defer(scanent,
 937               string_sprintf("short write on scanner output file (%s).", file_name));
 938           }
 939           /* try trigger match */
 940           if (!trigger && regex_match_and_setup(cmdline_trigger_re, linebuffer, 0, -1))
 941             trigger = 1;
 942         }
 943
 944         (void)fclose(scanner_record);
 945         sep = pclose(scanner_out);
 946         signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
 947         if (sep != 0)
 948             return m_errlog_defer(scanent,
 949                 sep == -1
 950                 ? string_sprintf("running scanner failed: %s", strerror(sep))
 951                 : string_sprintf("scanner returned error code: %d", sep));
 952
 953         if (trigger) {
 954           uschar * s;
 955           /* setup default virus name */
 956           malware_name = US"unknown";
 957
 958           /* re-open the scanner output file, look for name match */
 959           scanner_record = fopen(CS file_name, "rb");
 960           while(fgets(CS linebuffer, sizeof(linebuffer), scanner_record)) {
 961             /* try match */
 962             if ((s = m_pcre_exec(cmdline_regex_re, linebuffer)))
 963               malware_name = s;
 964           }
 965           (void)fclose(scanner_record);
 966         }
 967         else /* no virus found */
 968           malware_name = NULL;
 969         break;
 970       } /* cmdline */
 971
 972     case M_SOPHIE: /* "sophie" scanner type --------------------------------- */
 973       {
 974         int bread = 0;
 975         uschar *p;
 976         uschar * file_name;
 977         uschar av_buffer[1024];
 978
 979         /* pass the scan directory to sophie */
 980         file_name = string_copy(eml_filename);
 981         if ((p = Ustrrchr(file_name, '/')))
 982           *p = '\0';
 983
 984         DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan [%s]\n",
 985             scanner_name, scanner_options);
 986
 987         if (  write(sock, file_name, Ustrlen(file_name)) < 0
 988            || write(sock, "\n", 1) != 1
 989            )
 990           return m_errlog_defer_3(scanent,
 991             string_sprintf("unable to write to UNIX socket (%s)", scanner_options),
 992             sock);
 993
 994         /* wait for result */
 995         memset(av_buffer, 0, sizeof(av_buffer));
 996         if ((!(bread = ip_recv(sock, av_buffer, sizeof(av_buffer), MALWARE_TIMEOUT)) > 0))
 997           return m_errlog_defer_3(scanent,
 998             string_sprintf("unable to read from UNIX socket (%s)", scanner_options),
 999             sock);
1000
1001         /* infected ? */
1002         if (av_buffer[0] == '1') {
1003           uschar * s = Ustrchr(av_buffer, '\n');
1004           if (s)
1005             *s = '\0';
1006           malware_name = string_copy(&av_buffer[2]);
1007         }
1008         else if (!strncmp(CS av_buffer, "-1", 2))
1009           return m_errlog_defer_3(scanent, US"scanner reported error", sock);
1010         else /* all ok, no virus */
1011           malware_name = NULL;
1012
1013         break;
1014       }
1015
1016     case M_CLAMD: /* "clamd" scanner type ----------------------------------- */
1017       {
1018       /* This code was originally contributed by David Saez */
1019       /* There are three scanning methods available to us:
1020        *  (1) Use the SCAN command, pointing to a file in the filesystem
1021        *  (2) Use the STREAM command, send the data on a separate port
1022        *  (3) Use the zINSTREAM command, send the data inline
1023        * The zINSTREAM command was introduced with ClamAV 0.95, which marked
1024        * STREAM deprecated; see: http://wiki.clamav.net/bin/view/Main/UpgradeNotes095
1025        * In Exim, we use SCAN if using a Unix-domain socket or explicitly told that
1026        * the TCP-connected daemon is actually local; otherwise we use zINSTREAM unless
1027        * WITH_OLD_CLAMAV_STREAM is defined.
1028        * See Exim bug 926 for details.  */
1029
1030         uschar *p, *vname, *result_tag, *response_end;
1031         int bread=0;
1032         uschar * file_name;
1033         uschar av_buffer[1024];
1034         uschar *hostname = US"";
1035         host_item connhost;
1036         uschar *clamav_fbuf;
1037         int clam_fd, result;
1038         unsigned int fsize;
1039         BOOL use_scan_command = FALSE;
1040         clamd_address_container * clamd_address_vector[MAX_CLAMD_SERVERS];
1041         int current_server;
1042         int num_servers = 0;
1043   #ifdef WITH_OLD_CLAMAV_STREAM
1044         unsigned int port;
1045         uschar av_buffer2[1024];
1046         int sockData;
1047   #else
1048         uint32_t send_size, send_final_zeroblock;
1049   #endif
1050
1051         if (*scanner_options == '/')
1052           /* Local file; so we def want to use_scan_command and don't want to try
1053            * passing IP/port combinations */
1054           use_scan_command = TRUE;
1055         else {
1056           const uschar *address = scanner_options;
1057           uschar address_buffer[MAX_CLAMD_ADDRESS_LENGTH + 20];
1058
1059           /* Go through the rest of the list of host/port and construct an array
1060            * of servers to try. The first one is the bit we just passed from
1061            * scanner_options so process that first and then scan the remainder of
1062            * the address buffer */
1063           do {
1064             clamd_address_container *this_clamd;
1065
1066             /* The 'local' option means use the SCAN command over the network
1067              * socket (ie common file storage in use) */
1068             if (strcmpic(address,US"local") == 0) {
1069               use_scan_command = TRUE;
1070               continue;
1071             }
1072
1073             /* XXX: If unsuccessful we should free this memory */
1074             this_clamd =
1075                 (clamd_address_container *)store_get(sizeof(clamd_address_container));
1076
1077             /* extract host and port part */
1078             if( sscanf(CS address, "%" MAX_CLAMD_ADDRESS_LENGTH_S "s %u",
1079                    this_clamd->tcp_addr, &(this_clamd->tcp_port)) != 2 ) {
1080               (void) m_errlog_defer(scanent,
1081                           string_sprintf("invalid address '%s'", address));
1082               continue;
1083             }
1084
1085             clamd_address_vector[num_servers] = this_clamd;
1086             num_servers++;
1087             if (num_servers >= MAX_CLAMD_SERVERS) {
1088               (void) m_errlog_defer(scanent,
1089                     US"More than " MAX_CLAMD_SERVERS_S " clamd servers "
1090                     "specified; only using the first " MAX_CLAMD_SERVERS_S );
1091               break;
1092             }
1093           } while ((address = string_nextinlist(&av_scanner_work, &sep,
1094                                           address_buffer,
1095                                           sizeof(address_buffer))) != NULL);
1096
1097           /* check if we have at least one server */
1098           if (!num_servers)
1099             return m_errlog_defer(scanent,
1100               US"no useable server addresses in malware configuration option.");
1101         }
1102
1103         /* See the discussion of response formats below to see why we really don't
1104         like colons in filenames when passing filenames to ClamAV. */
1105         if (use_scan_command && Ustrchr(eml_filename, ':'))
1106           return m_errlog_defer(scanent,
1107             string_sprintf("local/SCAN mode incompatible with" \
1108               " : in path to email filename [%s]", eml_filename));
1109
1110         /* We have some network servers specified */
1111         if (num_servers) {
1112
1113           /* Confirmed in ClamAV source (0.95.3) that the TCPAddr option of clamd
1114            * only supports AF_INET, but we should probably be looking to the
1115            * future and rewriting this to be protocol-independent anyway. */
1116
1117           while ( num_servers > 0 ) {
1118             /* Randomly pick a server to start with */
1119             current_server = random_number( num_servers );
1120
1121             debug_printf("trying server name %s, port %u\n",
1122                          clamd_address_vector[current_server]->tcp_addr,
1123                          clamd_address_vector[current_server]->tcp_port);
1124
1125             /* Lookup the host. This is to ensure that we connect to the same IP
1126              * on both connections (as one host could resolve to multiple ips) */
1127             sock= m_tcpsocket(clamd_address_vector[current_server]->tcp_addr,
1128                                 clamd_address_vector[current_server]->tcp_port,
1129                                 &connhost, &errstr);
1130             if (sock >= 0) {
1131               /* Connection successfully established with a server */
1132               hostname = clamd_address_vector[current_server]->tcp_addr;
1133               break;
1134             }
1135
1136             (void) m_errlog_defer(scanent, errstr);
1137
1138             /* Remove the server from the list. XXX We should free the memory */
1139             num_servers--;
1140             int i;
1141             for( i = current_server; i < num_servers; i++ )
1142               clamd_address_vector[i] = clamd_address_vector[i+1];
1143           }
1144
1145           if ( num_servers == 0 )
1146             return m_errlog_defer(scanent, US"all servers failed");
1147
1148         } else {
1149           if ((sock = m_unixsocket(scanner_options, &errstr)) < 0)
1150             return m_errlog_defer(scanent, errstr);
1151         }
1152
1153         /* have socket in variable "sock"; command to use is semi-independent of
1154          * the socket protocol.  We use SCAN if is local (either Unix/local
1155          * domain socket, or explicitly told local) else we stream the data.
1156          * How we stream the data depends upon how we were built.  */
1157
1158         if (!use_scan_command) {
1159
1160   #ifdef WITH_OLD_CLAMAV_STREAM
1161           /* "STREAM\n" command, get back a "PORT <N>\n" response, send data to
1162            * that port on a second connection; then in the scan-method-neutral
1163            * part, read the response back on the original connection. */
1164
1165           DEBUG(D_acl) debug_printf("Malware scan: issuing %s old-style remote scan (PORT)\n",
1166               scanner_name);
1167
1168           /* Pass the string to ClamAV (7 = "STREAM\n") */
1169           if (m_sock_send(sock, US"STREAM\n", 7, &errstr) < 0)
1170             return m_errlog_defer(scanent, errstr);
1171
1172           memset(av_buffer2, 0, sizeof(av_buffer2));
1173           bread = ip_recv(sock, av_buffer2, sizeof(av_buffer2), MALWARE_TIMEOUT);
1174
1175           if (bread < 0)
1176             return m_errlog_defer_3(scanent,
1177               string_sprintf("unable to read PORT from socket (%s)",
1178                   strerror(errno)),
1179               sock);
1180
1181           if (bread == sizeof(av_buffer2))
1182             return m_errlog_defer_3(scanent, "buffer too small", sock);
1183
1184           if (!(*av_buffer2))
1185             return m_errlog_defer_3(scanent, "ClamAV returned null", sock);
1186
1187           av_buffer2[bread] = '\0';
1188           if( sscanf(CS av_buffer2, "PORT %u\n", &port) != 1 )
1189             return m_errlog_defer_3(scanent,
1190               string_sprintf("Expected port information from clamd, got '%s'",
1191                 av_buffer2),
1192               sock);
1193
1194           sockData = m_tcpsocket(connhost.address, port, NULL, &errstr);
1195           if (sockData < 0)
1196             return m_errlog_defer_3(scanent, errstr, sock);
1197
1198   #define CLOSE_SOCKDATA (void)close(sockData)
1199   #else /* WITH_OLD_CLAMAV_STREAM not defined */
1200           /* New protocol: "zINSTREAM\n" followed by a sequence of <length><data>
1201           chunks, <n> a 4-byte number (network order), terminated by a zero-length
1202           chunk. */
1203
1204           DEBUG(D_acl) debug_printf("Malware scan: issuing %s new-style remote scan (zINSTREAM)\n",
1205               scanner_name);
1206
1207           /* Pass the string to ClamAV (10 = "zINSTREAM\0") */
1208           if (send(sock, "zINSTREAM", 10, 0) < 0)
1209             return m_errlog_defer_3(scanent,
1210               string_sprintf("unable to send zINSTREAM to socket (%s)",
1211                 strerror(errno)),
1212               sock);
1213
1214   #define CLOSE_SOCKDATA /**/
1215   #endif
1216
1217           /* calc file size */
1218           if ((clam_fd = open(CS eml_filename, O_RDONLY)) < 0) {
1219             int err = errno;
1220             CLOSE_SOCKDATA;
1221             return m_errlog_defer_3(scanent,
1222               string_sprintf("can't open spool file %s: %s",
1223                 eml_filename, strerror(err)),
1224               sock);
1225           }
1226           if ((fsize = lseek(clam_fd, 0, SEEK_END)) < 0) {
1227             int err = errno;
1228             CLOSE_SOCKDATA; (void)close(clam_fd);
1229             return m_errlog_defer_3(scanent,
1230               string_sprintf("can't seek spool file %s: %s",
1231                 eml_filename, strerror(err)),
1232               sock);
1233           }
1234           lseek(clam_fd, 0, SEEK_SET);
1235
1236           if (!(clamav_fbuf = (uschar *) malloc (fsize))) {
1237             CLOSE_SOCKDATA; (void)close(clam_fd);
1238             return m_errlog_defer_3(scanent,
1239               string_sprintf("unable to allocate memory %u for file (%s)",
1240                 fsize, eml_filename),
1241               sock);
1242           }
1243
1244           if ((result = read(clam_fd, clamav_fbuf, fsize)) < 0) {
1245             int err = errno;
1246             free(clamav_fbuf); CLOSE_SOCKDATA; (void)close(clam_fd);
1247             return m_errlog_defer_3(scanent,
1248               string_sprintf("can't read spool file %s: %s",
1249                 eml_filename, strerror(err)),
1250               sock);
1251           }
1252           (void)close(clam_fd);
1253
1254           /* send file body to socket */
1255   #ifdef WITH_OLD_CLAMAV_STREAM
1256           if (send(sockData, clamav_fbuf, fsize, 0) < 0) {
1257             free(clamav_fbuf); CLOSE_SOCKDATA;
1258             return m_errlog_defer_3(scanent,
1259               string_sprintf("unable to send file body to socket (%s:%u)",
1260                 hostname, port),
1261               sock);
1262           }
1263   #else
1264           send_size = htonl(fsize);
1265           send_final_zeroblock = 0;
1266           if ((send(sock, &send_size, sizeof(send_size), 0) < 0) ||
1267               (send(sock, clamav_fbuf, fsize, 0) < 0) ||
1268               (send(sock, &send_final_zeroblock, sizeof(send_final_zeroblock), 0) < 0))
1269             {
1270             free(clamav_fbuf);
1271             return m_errlog_defer_3(scanent,
1272               string_sprintf("unable to send file body to socket (%s)", hostname),
1273               sock);
1274             }
1275   #endif
1276
1277           free(clamav_fbuf);
1278
1279           CLOSE_SOCKDATA;
1280   #undef CLOSE_SOCKDATA
1281
1282         } else { /* use scan command */
1283           /* Send a SCAN command pointing to a filename; then in the then in the
1284            * scan-method-neutral part, read the response back */
1285
1286   /* ================================================================= */
1287
1288           /* Prior to the reworking post-Exim-4.72, this scanned a directory,
1289           which dates to when ClamAV needed us to break apart the email into the
1290           MIME parts (eg, with the now deprecated demime condition coming first).
1291           Some time back, ClamAV gained the ability to deconstruct the emails, so
1292           doing this would actually have resulted in the mail attachments being
1293           scanned twice, in the broken out files and from the original .eml.
1294           Since ClamAV now handles emails (and has for quite some time) we can
1295           just use the email file itself. */
1296           /* Pass the string to ClamAV (7 = "SCAN \n" + \0) */
1297           file_name = string_sprintf("SCAN %s\n", eml_filename);
1298
1299           DEBUG(D_acl) debug_printf("Malware scan: issuing %s local-path scan [%s]\n",
1300               scanner_name, scanner_options);
1301
1302           if (send(sock, file_name, Ustrlen(file_name), 0) < 0)
1303             return m_errlog_defer_3(scanent,
1304               string_sprintf("unable to write to socket (%s)", strerror(errno)),
1305               sock);
1306
1307           /* Do not shut down the socket for writing; a user report noted that
1308            * clamd 0.70 does not react well to this. */
1309         }
1310         /* Commands have been sent, no matter which scan method or connection
1311          * type we're using; now just read the result, independent of method. */
1312
1313         /* Read the result */
1314         memset(av_buffer, 0, sizeof(av_buffer));
1315         bread = ip_recv(sock, av_buffer, sizeof(av_buffer), MALWARE_TIMEOUT);
1316         (void)close(sock);
1317         sock = -1;
1318
1319         if (!(bread > 0))
1320           return m_errlog_defer(scanent,
1321             string_sprintf("unable to read from socket (%s)", strerror(errno)));
1322
1323         if (bread == sizeof(av_buffer))
1324           return m_errlog_defer(scanent, US"buffer too small");
1325         /* We're now assured of a NULL at the end of av_buffer */
1326
1327         /* Check the result. ClamAV returns one of two result formats.
1328         In the basic mode, the response is of the form:
1329           infected: -> "<filename>: <virusname> FOUND"
1330           not-infected: -> "<filename>: OK"
1331           error: -> "<filename>: <errcode> ERROR
1332         If the ExtendedDetectionInfo option has been turned on, then we get:
1333           "<filename>: <virusname>(<virushash>:<virussize>) FOUND"
1334         for the infected case.  Compare:
1335   /tmp/eicar.com: Eicar-Test-Signature FOUND
1336   /tmp/eicar.com: Eicar-Test-Signature(44d88612fea8a8f36de82e1278abb02f:68) FOUND
1337
1338         In the streaming case, clamd uses the filename "stream" which you should
1339         be able to verify with { ktrace clamdscan --stream /tmp/eicar.com }.  (The
1340         client app will replace "stream" with the original filename before returning
1341         results to stdout, but the trace shows the data).
1342
1343         We will assume that the pathname passed to clamd from Exim does not contain
1344         a colon.  We will have whined loudly above if the eml_filename does (and we're
1345         passing a filename to clamd). */
1346
1347         if (!(*av_buffer))
1348           return m_errlog_defer(scanent, US"ClamAV returned null");
1349
1350         /* strip newline at the end (won't be present for zINSTREAM)
1351         (also any trailing whitespace, which shouldn't exist, but we depend upon
1352         this below, so double-check) */
1353         p = av_buffer + Ustrlen(av_buffer) - 1;
1354         if (*p == '\n') *p = '\0';
1355
1356         DEBUG(D_acl) debug_printf("Malware response: %s\n", av_buffer);
1357
1358         while (isspace(*--p) && (p > av_buffer))
1359           *p = '\0';
1360         if (*p) ++p;
1361         response_end = p;
1362
1363         /* colon in returned output? */
1364         if((p = Ustrchr(av_buffer,':')) == NULL)
1365           return m_errlog_defer(scanent,
1366             string_sprintf("ClamAV returned malformed result (missing colon): %s",
1367                     av_buffer));
1368
1369         /* strip filename */
1370         while (*p && isspace(*++p)) /**/;
1371         vname = p;
1372
1373         /* It would be bad to encounter a virus with "FOUND" in part of the name,
1374         but we should at least be resistant to it. */
1375         p = Ustrrchr(vname, ' ');
1376         result_tag = p ? p+1 : vname;
1377
1378         if (Ustrcmp(result_tag, "FOUND") == 0) {
1379           /* p should still be the whitespace before the result_tag */
1380           while (isspace(*p)) --p;
1381           *++p = '\0';
1382           /* Strip off the extended information too, which will be in parens
1383           after the virus name, with no intervening whitespace. */
1384           if (*--p == ')') {
1385             /* "(hash:size)", so previous '(' will do; if not found, we have
1386             a curious virus name, but not an error. */
1387             p = Ustrrchr(vname, '(');
1388             if (p)
1389               *p = '\0';
1390           }
1391           malware_name = string_copy(vname);
1392           DEBUG(D_acl) debug_printf("Malware found, name \"%s\"\n", malware_name);
1393
1394         } else if (Ustrcmp(result_tag, "ERROR") == 0)
1395           return m_errlog_defer(scanent,
1396             string_sprintf("ClamAV returned: %s", av_buffer));
1397
1398         else if (Ustrcmp(result_tag, "OK") == 0) {
1399           /* Everything should be OK */
1400           malware_name = NULL;
1401           DEBUG(D_acl) debug_printf("Malware not found\n");
1402
1403         } else
1404           return m_errlog_defer(scanent,
1405             string_sprintf("unparseable response from ClamAV: {%s}", av_buffer));
1406
1407         break;
1408       } /* clamd */
1409
1410     case M_SOCK: /* "sock" scanner type ------------------------------------- */
1411       /* This code was derived by Martin Poole from the clamd code contributed
1412          by David Saez and the cmdline code
1413       */
1414       {
1415         int bread;
1416         uschar * commandline;
1417         uschar av_buffer[1024];
1418         uschar * linebuffer;
1419         uschar * sockline_scanner;
1420         uschar sockline_scanner_default[] = "%s\n";
1421         const pcre *sockline_trig_re;
1422         const pcre *sockline_name_re;
1423
1424         /* find scanner command line */
1425         if ((sockline_scanner = string_nextinlist(&av_scanner_work, &sep,
1426                                             NULL, 0)))
1427         {       /* check for no expansions apart from one %s */
1428           char * s = index(CS sockline_scanner, '%');
1429           if (s++)
1430             if ((*s != 's' && *s != '%') || index(s+1, '%'))
1431               return m_errlog_defer_3(scanent,
1432                                     US"unsafe sock scanner call spec", sock);
1433         }
1434         else
1435           sockline_scanner = sockline_scanner_default;
1436
1437         /* find scanner output trigger */
1438         sockline_trig_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1439                                   "missing trigger specification", &errstr);
1440         if (!sockline_trig_re)
1441           return m_errlog_defer_3(scanent, errstr, sock);
1442
1443         /* find virus name regex */
1444         sockline_name_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1445                             "missing virus name regex specification", &errstr);
1446         if (!sockline_name_re)
1447           return m_errlog_defer_3(scanent, errstr, sock);
1448
1449         /* prepare scanner call - security depends on expansions check above */
1450         commandline = string_sprintf("%s/scan/%s/%s.eml", spool_directory, message_id, message_id);
1451         commandline = string_sprintf( CS sockline_scanner, CS commandline);
1452
1453
1454         /* Pass the command string to the socket */
1455         if (m_sock_send(sock, commandline, Ustrlen(commandline), &errstr) < 0)
1456           return m_errlog_defer(scanent, errstr);
1457
1458         /* Read the result */
1459         memset(av_buffer, 0, sizeof(av_buffer));
1460         bread = read(sock, av_buffer, sizeof(av_buffer));
1461
1462         if (!(bread > 0))
1463           return m_errlog_defer_3(scanent,
1464             string_sprintf("unable to read from socket (%s)", strerror(errno)),
1465             sock);
1466
1467         if (bread == sizeof(av_buffer))
1468           return m_errlog_defer_3(scanent, US"buffer too small", sock);
1469         linebuffer = string_copy(av_buffer);
1470
1471         /* try trigger match */
1472         if (regex_match_and_setup(sockline_trig_re, linebuffer, 0, -1)) {
1473           if (!(malware_name = m_pcre_exec(sockline_name_re, av_buffer)))
1474             malware_name = US "unknown";
1475         }
1476         else /* no virus found */
1477           malware_name = NULL;
1478         break;
1479       }
1480
1481     case M_MKSD: /* "mksd" scanner type ------------------------------------- */
1482       {
1483         char *mksd_options_end;
1484         int mksd_maxproc = 1;  /* default, if no option supplied */
1485         int sock;
1486         int retval;
1487
1488         if (scanner_options) {
1489           mksd_maxproc = (int)strtol(CS scanner_options, &mksd_options_end, 10);
1490           if (  *scanner_options == '\0'
1491              || *mksd_options_end != '\0'
1492              || mksd_maxproc < 1
1493              || mksd_maxproc > 32
1494              )
1495             return m_errlog_defer(scanent,
1496               string_sprintf("invalid option '%s'", scanner_options));
1497         }
1498
1499         if((sock = m_unixsocket(US "/var/run/mksd/socket", &errstr)) < 0)
1500           return m_errlog_defer(scanent, errstr);
1501
1502         malware_name = NULL;
1503
1504         DEBUG(D_acl) debug_printf("Malware scan: issuing %s scan\n", scanner_name);
1505
1506         if ((retval = mksd_scan_packed(scanent, sock, eml_filename)) != OK) {
1507           close (sock);
1508           return retval;
1509         }
1510         break;
1511       }
1512     }
1513
1514     if (sock >= 0)
1515       (void) close (sock);
1516     malware_ok = TRUE;                  /* set "been here, done that" marker */
1517   }
1518
1519   /* match virus name against pattern (caseless ------->----------v) */
1520   if ( malware_name && (regex_match_and_setup(re, malware_name, 0, -1)) ) {
1521     DEBUG(D_acl) debug_printf("Matched regex to malware [%s] [%s]\n", malware_regex, malware_name);
1522     return OK;
1523   }
1524   else
1525     return FAIL;
1526 }
1527
1528
1529 /* simple wrapper for reading lines from sockets */
1530 int
1531 recv_line(int sock, uschar *buffer, int size)
1532 {
1533   uschar *p = buffer;
1534
1535   memset(buffer,0,size);
1536   /* read until \n */
1537   while(recv(sock,p,1,0) > -1) {
1538     if ((p-buffer) > (size-2)) break;
1539     if (*p == '\n') break;
1540     if (*p != '\r') p++;
1541   }
1542   *p = '\0';
1543
1544   return (p-buffer);
1545 }
1546
1547
1548 /* ============= private routines for the "mksd" scanner type ============== */
1549
1550 #include <sys/uio.h>
1551
1552 static inline int
1553 mksd_writev (int sock, struct iovec *iov, int iovcnt)
1554 {
1555   int i;
1556
1557   for (;;) {
1558     do
1559       i = writev (sock, iov, iovcnt);
1560     while ((i < 0) && (errno == EINTR));
1561     if (i <= 0) {
1562       (void) malware_errlog_defer(US"unable to write to mksd UNIX socket (/var/run/mksd/socket)");
1563       return -1;
1564     }
1565
1566     for (;;)
1567       if (i >= iov->iov_len) {
1568         if (--iovcnt == 0)
1569           return 0;
1570         i -= iov->iov_len;
1571         iov++;
1572       } else {
1573         iov->iov_len -= i;
1574         iov->iov_base = CS iov->iov_base + i;
1575         break;
1576       }
1577   }
1578 }
1579
1580 static inline int
1581 mksd_read_lines (int sock, uschar *av_buffer, int av_buffer_size)
1582 {
1583   int offset = 0;
1584   int i;
1585
1586   do {
1587     if ((i = recv (sock, av_buffer+offset, av_buffer_size-offset, 0)) <= 0) {
1588       (void) malware_errlog_defer(US"unable to read from mksd UNIX socket (/var/run/mksd/socket)");
1589       return -1;
1590     }
1591
1592     offset += i;
1593     /* offset == av_buffer_size -> buffer full */
1594     if (offset == av_buffer_size) {
1595       (void) malware_errlog_defer(US"malformed reply received from mksd");
1596       return -1;
1597     }
1598   } while (av_buffer[offset-1] != '\n');
1599
1600   av_buffer[offset] = '\0';
1601   return offset;
1602 }
1603
1604 static inline int
1605 mksd_parse_line(struct scan * scanent, char *line)
1606 {
1607   char *p;
1608
1609   switch (*line) {
1610     case 'O': /* OK */
1611       return OK;
1612
1613     case 'E':
1614     case 'A': /* ERR */
1615       if ((p = strchr (line, '\n')) != NULL)
1616         *p = '\0';
1617       return m_errlog_defer(scanent,
1618         string_sprintf("scanner failed: %s", line));
1619
1620     default: /* VIR */
1621       if ((p = strchr (line, '\n')) != NULL) {
1622         *p = '\0';
1623         if (((p-line) > 5) && (line[3] == ' '))
1624           if (((p = strchr (line+4, ' ')) != NULL) && ((p-line) > 4)) {
1625             *p = '\0';
1626             malware_name = string_copy(US line+4);
1627             return OK;
1628           }
1629       }
1630       return m_errlog_defer(scanent,
1631         string_sprintf("malformed reply received: %s", line));
1632   }
1633 }
1634
1635 static int
1636 mksd_scan_packed(struct scan * scanent, int sock, uschar *scan_filename)
1637 {
1638   struct iovec iov[3];
1639   const char *cmd = "MSQ\n";
1640   uschar av_buffer[1024];
1641
1642   iov[0].iov_base = (void *) cmd;
1643   iov[0].iov_len = 3;
1644   iov[1].iov_base = CS scan_filename;
1645   iov[1].iov_len = Ustrlen(scan_filename);
1646   iov[2].iov_base = (void *) (cmd + 3);
1647   iov[2].iov_len = 1;
1648
1649   if (mksd_writev (sock, iov, 3) < 0)
1650     return DEFER;
1651
1652   if (mksd_read_lines (sock, av_buffer, sizeof (av_buffer)) < 0)
1653     return DEFER;
1654
1655   return mksd_parse_line (scanent, CS av_buffer);
1656 }
1657
1658 #endif /*WITH_CONTENT_SCAN*/
1659 /*
1660  * vi: aw ai sw=2
1661  */