src/src/mime.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004 */
   6 /* License: GPL */
   7
   8 #include "exim.h"
   9 #ifdef WITH_CONTENT_SCAN        /* entire file */
  10 #include "mime.h"
  11 #include <sys/stat.h>
  12
  13 FILE *mime_stream = NULL;
  14 uschar *mime_current_boundary = NULL;
  15
  16 /*************************************************
  17 * set MIME anomaly level + text                  *
  18 *************************************************/
  19
  20 /* Small wrapper to set the two expandables which
  21    give info on detected "problems" in MIME
  22    encodings. Those are defined in mime.h. */
  23
  24 void
  25 mime_set_anomaly(int level, const char *text)
  26 {
  27   mime_anomaly_level = level;
  28   mime_anomaly_text = CUS text;
  29 }
  30
  31
  32 /*************************************************
  33 * decode quoted-printable chars                  *
  34 *************************************************/
  35
  36 /* gets called when we hit a =
  37    returns: new pointer position
  38    result code in c:
  39           -2 - decode error
  40           -1 - soft line break, no char
  41            0-255 - char to write
  42 */
  43
  44 uschar *
  45 mime_decode_qp_char(uschar *qp_p, int *c)
  46 {
  47 uschar *initial_pos = qp_p;
  48
  49 /* advance one char */
  50 qp_p++;
  51
  52 /* Check for two hex digits and decode them */
  53 if (isxdigit(*qp_p) && isxdigit(qp_p[1]))
  54   {
  55   /* Do hex conversion */
  56   *c = (isdigit(*qp_p) ? *qp_p - '0' : toupper(*qp_p) - 'A' + 10) <<4;
  57   qp_p++;
  58   *c |= isdigit(*qp_p) ? *qp_p - '0' : toupper(*qp_p) - 'A' + 10;
  59   return qp_p + 1;
  60   }
  61
  62 /* tab or whitespace may follow just ignore it if it precedes \n */
  63 while (*qp_p == '\t' || *qp_p == ' ' || *qp_p == '\r')
  64   qp_p++;
  65
  66 if (*qp_p == '\n')      /* hit soft line break */
  67   {
  68   *c = -1;
  69   return qp_p;
  70   }
  71
  72 /* illegal char here */
  73 *c = -2;
  74 return initial_pos;
  75 }
  76
  77
  78 /* just dump MIME part without any decoding */
  79 static ssize_t
  80 mime_decode_asis(FILE* in, FILE* out, uschar* boundary)
  81 {
  82   ssize_t len, size = 0;
  83   uschar buffer[MIME_MAX_LINE_LENGTH];
  84
  85   while(fgets(CS buffer, MIME_MAX_LINE_LENGTH, mime_stream) != NULL)
  86     {
  87     if (boundary != NULL
  88        && Ustrncmp(buffer, "--", 2) == 0
  89        && Ustrncmp((buffer+2), boundary, Ustrlen(boundary)) == 0
  90        )
  91       break;
  92
  93     len = Ustrlen(buffer);
  94     if (fwrite(buffer, 1, (size_t)len, out) < len)
  95       return -1;
  96     size += len;
  97     } /* while */
  98   return size;
  99 }
 100
 101
 102 /* decode base64 MIME part */
 103 static ssize_t
 104 mime_decode_base64(FILE* in, FILE* out, uschar* boundary)
 105 {
 106   uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
 107   uschar *ipos, *opos;
 108   ssize_t len, size = 0;
 109   int bytestate = 0;
 110
 111   opos = obuf;
 112
 113   while (Ufgets(ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
 114     {
 115     if (boundary != NULL
 116        && Ustrncmp(ibuf, "--", 2) == 0
 117        && Ustrncmp((ibuf+2), boundary, Ustrlen(boundary)) == 0
 118        )
 119       break;
 120
 121     for (ipos = ibuf ; *ipos != '\r' && *ipos != '\n' && *ipos != 0; ++ipos)
 122       {
 123       if (*ipos == '=')                 /* skip padding */
 124         {
 125         ++bytestate;
 126         continue;
 127         }
 128       if (mime_b64[*ipos] == 128)       /* skip bad characters */
 129         {
 130         mime_set_anomaly(MIME_ANOMALY_BROKEN_BASE64);
 131         continue;
 132         }
 133
 134       /* simple state-machine */
 135       switch((bytestate++) & 3)
 136         {
 137         case 0:
 138           *opos = mime_b64[*ipos] << 2;
 139            break;
 140         case 1:
 141           *opos |= mime_b64[*ipos] >> 4;
 142           ++opos;
 143           *opos = mime_b64[*ipos] << 4;
 144           break;
 145         case 2:
 146           *opos |= mime_b64[*ipos] >> 2;
 147           ++opos;
 148           *opos = mime_b64[*ipos] << 6;
 149           break;
 150         case 3:
 151           *opos |= mime_b64[*ipos];
 152           ++opos;
 153           break;
 154         } /* switch */
 155       } /* for */
 156
 157     /* something to write? */
 158     len = opos - obuf;
 159     if (len > 0)
 160       {
 161       if (fwrite(obuf, 1, len, out) != len) return -1; /* error */
 162       size += len;
 163       /* copy incomplete last byte to start of obuf, where we continue */
 164       if ((bytestate & 3) != 0)
 165         *obuf = *opos;
 166       opos = obuf;
 167       }
 168     } /* while */
 169
 170   /* write out last byte if it was incomplete */
 171   if (bytestate & 3)
 172     {
 173     if (fwrite(obuf, 1, 1, out) != 1) return -1;
 174     ++size;
 175     }
 176
 177   return size;
 178 }
 179
 180
 181 /* decode quoted-printable MIME part */
 182 static ssize_t
 183 mime_decode_qp(FILE* in, FILE* out, uschar* boundary)
 184 {
 185 uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
 186 uschar *ipos, *opos;
 187 ssize_t len, size = 0;
 188
 189 while (fgets(CS ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
 190   {
 191   if (boundary != NULL
 192      && Ustrncmp(ibuf, "--", 2) == 0
 193      && Ustrncmp((ibuf+2), boundary, Ustrlen(boundary)) == 0
 194      )
 195     break; /* todo: check for missing boundary */
 196
 197   ipos = ibuf;
 198   opos = obuf;
 199
 200   while (*ipos != 0)
 201     {
 202     if (*ipos == '=')
 203       {
 204       int decode_qp_result;
 205
 206       ipos = mime_decode_qp_char(ipos, &decode_qp_result);
 207
 208       if (decode_qp_result == -2)
 209         {
 210         /* Error from decoder. ipos is unchanged. */
 211         mime_set_anomaly(MIME_ANOMALY_BROKEN_QP);
 212         *opos = '=';
 213         ++opos;
 214         ++ipos;
 215         }
 216       else if (decode_qp_result == -1)
 217         break;
 218       else if (decode_qp_result >= 0)
 219         {
 220         *opos = decode_qp_result;
 221         ++opos;
 222         }
 223       }
 224     else
 225       {
 226       *opos = *ipos;
 227       ++opos;
 228       ++ipos;
 229       }
 230     }
 231   /* something to write? */
 232   len = opos - obuf;
 233   if (len > 0)
 234     {
 235     if (fwrite(obuf, 1, len, out) != len) return -1; /* error */
 236     size += len;
 237     }
 238   }
 239 return size;
 240 }
 241
 242
 243 FILE *
 244 mime_get_decode_file(uschar *pname, uschar *fname)
 245 {
 246 FILE *f = NULL;
 247 uschar *filename;
 248
 249 filename = (uschar *)malloc(2048);
 250
 251 if (pname && fname)
 252   {
 253   (void)string_format(filename, 2048, "%s/%s", pname, fname);
 254   f = modefopen(filename,"wb+",SPOOL_MODE);
 255   }
 256 else if (!pname)
 257   f = modefopen(fname,"wb+",SPOOL_MODE);
 258 else if (!fname)
 259   {
 260   int file_nr = 0;
 261   int result = 0;
 262
 263   /* must find first free sequential filename */
 264   do
 265     {
 266     struct stat mystat;
 267     (void)string_format(filename, 2048,
 268       "%s/%s-%05u", pname, message_id, file_nr++);
 269     /* security break */
 270     if (file_nr >= 1024)
 271       break;
 272     result = stat(CS filename, &mystat);
 273     } while(result != -1);
 274
 275   f = modefopen(filename, "wb+", SPOOL_MODE);
 276   }
 277
 278 /* set expansion variable */
 279 mime_decoded_filename = filename;
 280
 281 return f;
 282 }
 283
 284
 285 int
 286 mime_decode(uschar **listptr)
 287 {
 288 int sep = 0;
 289 uschar *list = *listptr;
 290 uschar *option;
 291 uschar option_buffer[1024];
 292 uschar decode_path[1024];
 293 FILE *decode_file = NULL;
 294 long f_pos = 0;
 295 ssize_t size_counter = 0;
 296 ssize_t (*decode_function)(FILE*, FILE*, uschar*);
 297
 298 if (mime_stream == NULL)
 299   return FAIL;
 300
 301 f_pos = ftell(mime_stream);
 302
 303 /* build default decode path (will exist since MBOX must be spooled up) */
 304 (void)string_format(decode_path,1024,"%s/scan/%s",spool_directory,message_id);
 305
 306 /* try to find 1st option */
 307 if ((option = string_nextinlist(&list, &sep,
 308                                 option_buffer,
 309                                 sizeof(option_buffer))) != NULL)
 310   {
 311   /* parse 1st option */
 312   if ( (Ustrcmp(option,"false") == 0) || (Ustrcmp(option,"0") == 0) )
 313     /* explicitly no decoding */
 314     return FAIL;
 315
 316   if (Ustrcmp(option,"default") == 0)
 317     /* explicit default path + file names */
 318     goto DEFAULT_PATH;
 319
 320   if (option[0] == '/')
 321     {
 322     struct stat statbuf;
 323
 324     memset(&statbuf,0,sizeof(statbuf));
 325
 326     /* assume either path or path+file name */
 327     if ( (stat(CS option, &statbuf) == 0) && S_ISDIR(statbuf.st_mode) )
 328       /* is directory, use it as decode_path */
 329       decode_file = mime_get_decode_file(option, NULL);
 330     else
 331       /* does not exist or is a file, use as full file name */
 332       decode_file = mime_get_decode_file(NULL, option);
 333     }
 334   else
 335     /* assume file name only, use default path */
 336     decode_file = mime_get_decode_file(decode_path, option);
 337   }
 338 else
 339   {
 340   /* no option? patch default path */
 341 DEFAULT_PATH:
 342   decode_file = mime_get_decode_file(decode_path, NULL);
 343   }
 344
 345 if (!decode_file)
 346   return DEFER;
 347
 348 /* decode according to mime type */
 349 decode_function =
 350   !mime_content_transfer_encoding
 351   ? mime_decode_asis    /* no encoding, dump as-is */
 352   : Ustrcmp(mime_content_transfer_encoding, "base64") == 0
 353   ? mime_decode_base64
 354   : Ustrcmp(mime_content_transfer_encoding, "quoted-printable") == 0
 355   ? mime_decode_qp
 356   : mime_decode_asis;   /* unknown encoding type, just dump as-is */
 357
 358 size_counter = decode_function(mime_stream, decode_file, mime_current_boundary);
 359
 360 clearerr(mime_stream);
 361 fseek(mime_stream, f_pos, SEEK_SET);
 362
 363 if (fclose(decode_file) != 0 || size_counter < 0)
 364   return DEFER;
 365
 366 /* round up to the next KiB */
 367 mime_content_size = (size_counter + 1023) / 1024;
 368
 369 return OK;
 370 }
 371
 372 int
 373 mime_get_header(FILE *f, uschar *header)
 374 {
 375 int c = EOF;
 376 int done = 0;
 377 int header_value_mode = 0;
 378 int header_open_brackets = 0;
 379 int num_copied = 0;
 380
 381 while(!done)
 382   {
 383   if ((c = fgetc(f)) == EOF) break;
 384
 385   /* always skip CRs */
 386   if (c == '\r') continue;
 387
 388   if (c == '\n')
 389     {
 390     if (num_copied > 0)
 391       {
 392       /* look if next char is '\t' or ' ' */
 393       if ((c = fgetc(f)) == EOF) break;
 394       if ( (c == '\t') || (c == ' ') ) continue;
 395       (void)ungetc(c,f);
 396       }
 397     /* end of the header, terminate with ';' */
 398     c = ';';
 399     done = 1;
 400     }
 401
 402   /* skip control characters */
 403   if (c < 32) continue;
 404
 405   if (header_value_mode)
 406     {
 407     /* --------- value mode ----------- */
 408     /* skip leading whitespace */
 409     if ( ((c == '\t') || (c == ' ')) && (header_value_mode == 1) )
 410       continue;
 411
 412       /* we have hit a non-whitespace char, start copying value data */
 413       header_value_mode = 2;
 414
 415       if (c == '"')       /* flip "quoted" mode */
 416         header_value_mode = header_value_mode==2 ? 3 : 2;
 417
 418       /* leave value mode on unquoted ';' */
 419       if (header_value_mode == 2 && c == ';') {
 420         header_value_mode = 0;
 421       };
 422       /* -------------------------------- */
 423     }
 424   else
 425     {
 426     /* -------- non-value mode -------- */
 427     /* skip whitespace + tabs */
 428     if ( (c == ' ') || (c == '\t') )
 429       continue;
 430     if (c == '\\')
 431       {
 432       /* quote next char. can be used
 433       to escape brackets. */
 434       if ((c = fgetc(f)) == EOF) break;
 435       }
 436     else if (c == '(')
 437       {
 438       header_open_brackets++;
 439       continue;
 440       }
 441     else if ((c == ')') && header_open_brackets)
 442       {
 443       header_open_brackets--;
 444       continue;
 445       }
 446     else if ( (c == '=') && !header_open_brackets ) /* enter value mode */
 447       header_value_mode = 1;
 448
 449     /* skip chars while we are in a comment */
 450     if (header_open_brackets > 0)
 451       continue;
 452     /* -------------------------------- */
 453     }
 454
 455   /* copy the char to the buffer */
 456   header[num_copied++] = (uschar)c;
 457
 458   /* break if header buffer is full */
 459   if (num_copied > MIME_MAX_HEADER_SIZE-1)
 460     done = 1;
 461   }
 462
 463 if ((num_copied > 0) && (header[num_copied-1] != ';'))
 464   header[num_copied-1] = ';';
 465
 466 /* 0-terminate */
 467 header[num_copied] = '\0';
 468
 469 /* return 0 for EOF or empty line */
 470 if ((c == EOF) || (num_copied == 1))
 471   return 0;
 472 else
 473   return 1;
 474 }
 475
 476
 477 int
 478 mime_acl_check(uschar *acl, FILE *f, struct mime_boundary_context *context,
 479                    uschar **user_msgptr, uschar **log_msgptr)
 480 {
 481 int rc = OK;
 482 uschar *header = NULL;
 483 struct mime_boundary_context nested_context;
 484
 485 /* reserve a line buffer to work in */
 486 if (!(header = (uschar *)malloc(MIME_MAX_HEADER_SIZE+1)))
 487   {
 488   log_write(0, LOG_PANIC,
 489        "MIME ACL: can't allocate %d bytes of memory.", MIME_MAX_HEADER_SIZE+1);
 490   return DEFER;
 491   }
 492
 493 /* Not actually used at the moment, but will be vital to fixing
 494  * some RFC 2046 nonconformance later... */
 495 nested_context.parent = context;
 496
 497 /* loop through parts */
 498 while(1)
 499   {
 500   /* reset all per-part mime variables */
 501   mime_anomaly_level     = 0;
 502   mime_anomaly_text      = NULL;
 503   mime_boundary          = NULL;
 504   mime_charset           = NULL;
 505   mime_decoded_filename  = NULL;
 506   mime_filename          = NULL;
 507   mime_content_description = NULL;
 508   mime_content_disposition = NULL;
 509   mime_content_id        = NULL;
 510   mime_content_transfer_encoding = NULL;
 511   mime_content_type      = NULL;
 512   mime_is_multipart      = 0;
 513   mime_content_size      = 0;
 514
 515   /*
 516   If boundary is null, we assume that *f is positioned on the start of headers (for example,
 517   at the very beginning of a message.
 518   If a boundary is given, we must first advance to it to reach the start of the next header
 519   block.
 520   */
 521
 522   /* NOTE -- there's an error here -- RFC2046 specifically says to
 523    * check for outer boundaries.  This code doesn't do that, and
 524    * I haven't fixed this.
 525    *
 526    * (I have moved partway towards adding support, however, by adding
 527    * a "parent" field to my new boundary-context structure.)
 528    */
 529   if (context != NULL)
 530     {
 531     while(fgets(CS header, MIME_MAX_HEADER_SIZE, f) != NULL)
 532       {
 533       /* boundary line must start with 2 dashes */
 534       if (Ustrncmp(header,"--",2) == 0)
 535         {
 536         if (Ustrncmp((header+2),context->boundary,Ustrlen(context->boundary)) == 0)
 537           {
 538           /* found boundary */
 539           if (Ustrncmp((header+2+Ustrlen(context->boundary)),"--",2) == 0)
 540             {
 541             /* END boundary found */
 542             debug_printf("End boundary found %s\n", context->boundary);
 543             return rc;
 544             }
 545           else
 546             debug_printf("Next part with boundary %s\n", context->boundary);
 547
 548           /* can't use break here */
 549           goto DECODE_HEADERS;
 550           }
 551         }
 552       }
 553     /* Hit EOF or read error. Ugh. */
 554     debug_printf("Hit EOF ...\n");
 555     return rc;
 556     }
 557
 558 DECODE_HEADERS:
 559   /* parse headers, set up expansion variables */
 560   while (mime_get_header(f,header))
 561     {
 562     int i;
 563     /* loop through header list */
 564     for (i = 0; i < mime_header_list_size; i++)
 565       {
 566       uschar *header_value = NULL;
 567       int header_value_len = 0;
 568
 569       /* found an interesting header? */
 570       if (strncmpic(mime_header_list[i].name,header,mime_header_list[i].namelen) == 0)
 571         {
 572         uschar *p = header + mime_header_list[i].namelen;
 573         /* yes, grab the value (normalize to lower case)
 574            and copy to its corresponding expansion variable */
 575         while(*p != ';')
 576           {
 577           *p = tolower(*p);
 578           p++;
 579           }
 580         header_value_len = (p - (header + mime_header_list[i].namelen));
 581         header_value = (uschar *)malloc(header_value_len+1);
 582         memset(header_value,0,header_value_len+1);
 583         p = header + mime_header_list[i].namelen;
 584         Ustrncpy(header_value, p, header_value_len);
 585         debug_printf("Found %s MIME header, value is '%s'\n", mime_header_list[i].name, header_value);
 586         *((uschar **)(mime_header_list[i].value)) = header_value;
 587
 588         /* make p point to the next character after the closing ';' */
 589         p += (header_value_len+1);
 590
 591         /* grab all param=value tags on the remaining line, check if they are interesting */
 592 NEXT_PARAM_SEARCH:
 593         while (*p != 0)
 594           {
 595           mime_parameter * mp;
 596           for (mp = mime_parameter_list;
 597                mp < &mime_parameter_list[mime_parameter_list_size];
 598                mp++)
 599             {
 600             uschar *param_value = NULL;
 601             int param_value_len = 0;
 602
 603             /* found an interesting parameter? */
 604             if (strncmpic(mp->name, p, mp->namelen) == 0)
 605               {
 606               uschar *q = p + mp->namelen;
 607               int size = 0;
 608               int ptr = 0;
 609
 610               /* yes, grab the value and copy to its corresponding expansion variable */
 611               while(*q && *q != ';')            /* ; terminates */
 612                 {
 613                 if (*q == '"')
 614                   {
 615                   q++;                          /* skip leading " */
 616                   while(*q && *q != '"')        /* which protects ; */
 617                     param_value = string_cat(param_value, &size, &ptr, q++, 1);
 618                   if (*q) q++;                  /* skip trailing " */
 619                   }
 620                 else
 621                   param_value = string_cat(param_value, &size, &ptr, q++, 1);
 622                 }
 623               if (param_value)
 624                 {
 625                 param_value[ptr++] = '\0';
 626                 param_value_len = ptr;
 627
 628                 param_value = rfc2047_decode(param_value,
 629                       check_rfc2047_length, NULL, 32, &param_value_len, &q);
 630                 debug_printf("Found %s MIME parameter in %s header, "
 631                       "value is '%s'\n", mp->name, mime_header_list[i].name,
 632                       param_value);
 633                 }
 634               *mp->value = param_value;
 635               p += (mp->namelen + param_value_len + 1);
 636               goto NEXT_PARAM_SEARCH;
 637             }
 638           }
 639           /* There is something, but not one of our interesting parameters.
 640              Advance to the next semicolon */
 641           while(*p != ';') p++;
 642           p++;
 643         }
 644       }
 645     }
 646   }
 647
 648   /* set additional flag variables (easier access) */
 649   if ( (mime_content_type != NULL) &&
 650        (Ustrncmp(mime_content_type,"multipart",9) == 0) )
 651     mime_is_multipart = 1;
 652
 653   /* Make a copy of the boundary pointer.
 654      Required since mime_boundary is global
 655      and can be overwritten further down in recursion */
 656   nested_context.boundary = mime_boundary;
 657
 658   /* raise global counter */
 659   mime_part_count++;
 660
 661   /* copy current file handle to global variable */
 662   mime_stream = f;
 663   mime_current_boundary = context ? context->boundary : 0;
 664
 665   /* Note the context */
 666   mime_is_coverletter = !(context && context->context == MBC_ATTACHMENT);
 667
 668   /* call ACL handling function */
 669   rc = acl_check(ACL_WHERE_MIME, NULL, acl, user_msgptr, log_msgptr);
 670
 671   mime_stream = NULL;
 672   mime_current_boundary = NULL;
 673
 674   if (rc != OK) break;
 675
 676   /* If we have a multipart entity and a boundary, go recursive */
 677   if ( (mime_content_type != NULL) &&
 678        (nested_context.boundary != NULL) &&
 679        (Ustrncmp(mime_content_type,"multipart",9) == 0) )
 680     {
 681     debug_printf("Entering multipart recursion, boundary '%s'\n", nested_context.boundary);
 682
 683     nested_context.context =
 684       context && context->context == MBC_ATTACHMENT
 685       ? MBC_ATTACHMENT
 686       :    Ustrcmp(mime_content_type,"multipart/alternative") == 0
 687         || Ustrcmp(mime_content_type,"multipart/related") == 0
 688       ? MBC_COVERLETTER_ALL
 689       : MBC_COVERLETTER_ONESHOT;
 690
 691     rc = mime_acl_check(acl, f, &nested_context, user_msgptr, log_msgptr);
 692     if (rc != OK) break;
 693     }
 694   else if ( (mime_content_type != NULL) &&
 695           (Ustrncmp(mime_content_type,"message/rfc822",14) == 0) )
 696     {
 697     uschar *rfc822name = NULL;
 698     uschar filename[2048];
 699     int file_nr = 0;
 700     int result = 0;
 701
 702     /* must find first free sequential filename */
 703     do
 704       {
 705       struct stat mystat;
 706       (void)string_format(filename, 2048,
 707         "%s/scan/%s/__rfc822_%05u", spool_directory, message_id, file_nr++);
 708       /* security break */
 709       if (file_nr >= 128)
 710         goto NO_RFC822;
 711       result = stat(CS filename,&mystat);
 712       } while (result != -1);
 713
 714     rfc822name = filename;
 715
 716     /* decode RFC822 attachment */
 717     mime_decoded_filename = NULL;
 718     mime_stream = f;
 719     mime_current_boundary = context ? context->boundary : NULL;
 720     mime_decode(&rfc822name);
 721     mime_stream = NULL;
 722     mime_current_boundary = NULL;
 723     if (!mime_decoded_filename)         /* decoding failed */
 724       {
 725       log_write(0, LOG_MAIN,
 726            "mime_regex acl condition warning - could not decode RFC822 MIME part to file.");
 727       return DEFER;
 728       }
 729     mime_decoded_filename = NULL;
 730     }
 731
 732 NO_RFC822:
 733   /* If the boundary of this instance is NULL, we are finished here */
 734   if (context == NULL) break;
 735
 736   if (context->context == MBC_COVERLETTER_ONESHOT)
 737     context->context = MBC_ATTACHMENT;
 738   }
 739
 740 return rc;
 741 }
 742
 743 #endif  /*WITH_CONTENT_SCAN*/
 744
 745 /* vi: sw ai sw=2
 746 */