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 static 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 static 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 static 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(const uschar **listptr)
 287 {
 288 int sep = 0;
 289 const 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
 373 static int
 374 mime_get_header(FILE *f, uschar *header)
 375 {
 376 int c = EOF;
 377 int done = 0;
 378 int header_value_mode = 0;
 379 int header_open_brackets = 0;
 380 int num_copied = 0;
 381
 382 while(!done)
 383   {
 384   if ((c = fgetc(f)) == EOF) break;
 385
 386   /* always skip CRs */
 387   if (c == '\r') continue;
 388
 389   if (c == '\n')
 390     {
 391     if (num_copied > 0)
 392       {
 393       /* look if next char is '\t' or ' ' */
 394       if ((c = fgetc(f)) == EOF) break;
 395       if ( (c == '\t') || (c == ' ') ) continue;
 396       (void)ungetc(c,f);
 397       }
 398     /* end of the header, terminate with ';' */
 399     c = ';';
 400     done = 1;
 401     }
 402
 403   /* skip control characters */
 404   if (c < 32) continue;
 405
 406   if (header_value_mode)
 407     {
 408     /* --------- value mode ----------- */
 409     /* skip leading whitespace */
 410     if ( ((c == '\t') || (c == ' ')) && (header_value_mode == 1) )
 411       continue;
 412
 413       /* we have hit a non-whitespace char, start copying value data */
 414       header_value_mode = 2;
 415
 416       if (c == '"')       /* flip "quoted" mode */
 417         header_value_mode = header_value_mode==2 ? 3 : 2;
 418
 419       /* leave value mode on unquoted ';' */
 420       if (header_value_mode == 2 && c == ';') {
 421         header_value_mode = 0;
 422       };
 423       /* -------------------------------- */
 424     }
 425   else
 426     {
 427     /* -------- non-value mode -------- */
 428     /* skip whitespace + tabs */
 429     if ( (c == ' ') || (c == '\t') )
 430       continue;
 431     if (c == '\\')
 432       {
 433       /* quote next char. can be used
 434       to escape brackets. */
 435       if ((c = fgetc(f)) == EOF) break;
 436       }
 437     else if (c == '(')
 438       {
 439       header_open_brackets++;
 440       continue;
 441       }
 442     else if ((c == ')') && header_open_brackets)
 443       {
 444       header_open_brackets--;
 445       continue;
 446       }
 447     else if ( (c == '=') && !header_open_brackets ) /* enter value mode */
 448       header_value_mode = 1;
 449
 450     /* skip chars while we are in a comment */
 451     if (header_open_brackets > 0)
 452       continue;
 453     /* -------------------------------- */
 454     }
 455
 456   /* copy the char to the buffer */
 457   header[num_copied++] = (uschar)c;
 458
 459   /* break if header buffer is full */
 460   if (num_copied > MIME_MAX_HEADER_SIZE-1)
 461     done = 1;
 462   }
 463
 464 if ((num_copied > 0) && (header[num_copied-1] != ';'))
 465   header[num_copied-1] = ';';
 466
 467 /* 0-terminate */
 468 header[num_copied] = '\0';
 469
 470 /* return 0 for EOF or empty line */
 471 if ((c == EOF) || (num_copied == 1))
 472   return 0;
 473 else
 474   return 1;
 475 }
 476
 477
 478 static void
 479 mime_vars_reset(void)
 480 {
 481 mime_anomaly_level     = 0;
 482 mime_anomaly_text      = NULL;
 483 mime_boundary          = NULL;
 484 mime_charset           = NULL;
 485 mime_decoded_filename  = NULL;
 486 mime_filename          = NULL;
 487 mime_content_description = NULL;
 488 mime_content_disposition = NULL;
 489 mime_content_id        = NULL;
 490 mime_content_transfer_encoding = NULL;
 491 mime_content_type      = NULL;
 492 mime_is_multipart      = 0;
 493 mime_content_size      = 0;
 494 }
 495
 496
 497 /* Grab a parameter value, dealing with quoting.
 498
 499 Arguments:
 500  str    Input string.  Updated on return to point to terminating ; or NUL
 501
 502 Return:
 503  Allocated string with parameter value
 504 */
 505 static uschar *
 506 mime_param_val(uschar ** sp)
 507 {
 508 uschar * s = *sp;
 509 uschar * val = NULL;
 510 int size = 0, ptr = 0;
 511
 512 /* debug_printf("   considering paramval '%s'\n", s); */
 513
 514 while (*s && *s != ';')         /* ; terminates */
 515   if (*s == '"')
 516     {
 517     s++;                        /* skip opening " */
 518     while (*s && *s != '"')     /* " protects ; */
 519       val = string_cat(val, &size, &ptr, s++, 1);
 520     if (*s) s++;                /* skip closing " */
 521     }
 522   else
 523     val = string_cat(val, &size, &ptr, s++, 1);
 524 if (val) val[ptr] = '\0';
 525 *sp = s;
 526 return val;
 527 }
 528
 529 static uschar *
 530 mime_next_semicolon(uschar * s)
 531 {
 532 while (*s && *s != ';')         /* ; terminates */
 533   if (*s == '"')
 534     {
 535     s++;                        /* skip opening " */
 536     while (*s && *s != '"')     /* " protects ; */
 537       s++;
 538     if (*s) s++;                /* skip closing " */
 539     }
 540   else
 541     s++;
 542 return s;
 543 }
 544
 545
 546 static uschar *
 547 rfc2231_to_2047(const uschar * fname, const uschar * charset, int * len)
 548 {
 549 int size = 0, ptr = 0;
 550 uschar * val = string_cat(NULL, &size, &ptr, US"=?", 2);
 551 uschar c;
 552
 553 val = string_cat(val, &size, &ptr, charset, Ustrlen(charset));
 554 val = string_cat(val, &size, &ptr, US"?Q?", 3);
 555
 556 while ((c = *fname))
 557   if (c == '%' && isxdigit(fname[1]) && isxdigit(fname[2]))
 558     {
 559     val = string_cat(val, &size, &ptr, US"=", 1);
 560     val = string_cat(val, &size, &ptr, ++fname, 2);
 561     fname += 2;
 562     }
 563   else
 564     val = string_cat(val, &size, &ptr, fname++, 1);
 565
 566 val = string_cat(val, &size, &ptr, US"?=", 2);
 567 val[*len = ptr] = '\0';
 568 return val;
 569 }
 570
 571
 572 int
 573 mime_acl_check(uschar *acl, FILE *f, struct mime_boundary_context *context,
 574     uschar **user_msgptr, uschar **log_msgptr)
 575 {
 576 int rc = OK;
 577 uschar * header = NULL;
 578 struct mime_boundary_context nested_context;
 579
 580 /* reserve a line buffer to work in */
 581 header = store_get(MIME_MAX_HEADER_SIZE+1);
 582
 583 /* Not actually used at the moment, but will be vital to fixing
 584  * some RFC 2046 nonconformance later... */
 585 nested_context.parent = context;
 586
 587 /* loop through parts */
 588 while(1)
 589   {
 590   /* reset all per-part mime variables */
 591   mime_vars_reset();
 592
 593   /* If boundary is null, we assume that *f is positioned on the start of
 594   headers (for example, at the very beginning of a message.  If a boundary is
 595   given, we must first advance to it to reach the start of the next header
 596   block.  */
 597
 598   /* NOTE -- there's an error here -- RFC2046 specifically says to
 599    * check for outer boundaries.  This code doesn't do that, and
 600    * I haven't fixed this.
 601    *
 602    * (I have moved partway towards adding support, however, by adding
 603    * a "parent" field to my new boundary-context structure.)
 604    */
 605   if (context) for (;;)
 606     {
 607     if (!fgets(CS header, MIME_MAX_HEADER_SIZE, f))
 608       {
 609       /* Hit EOF or read error. Ugh. */
 610       DEBUG(D_acl) debug_printf("Hit EOF ...\n");
 611       return rc;
 612       }
 613
 614     /* boundary line must start with 2 dashes */
 615     if (  Ustrncmp(header, "--", 2) == 0
 616        && Ustrncmp(header+2, context->boundary, Ustrlen(context->boundary)) == 0
 617        )
 618       {                 /* found boundary */
 619       if (Ustrncmp((header+2+Ustrlen(context->boundary)), "--", 2) == 0)
 620         {
 621         /* END boundary found */
 622         DEBUG(D_acl) debug_printf("End boundary found %s\n",
 623           context->boundary);
 624         return rc;
 625         }
 626
 627       DEBUG(D_acl) debug_printf("Next part with boundary %s\n",
 628         context->boundary);
 629       break;
 630       }
 631     }
 632
 633   /* parse headers, set up expansion variables */
 634   while (mime_get_header(f, header))
 635     {
 636     struct mime_header * mh;
 637
 638     /* look for interesting headers */
 639     for (mh = mime_header_list;
 640          mh < mime_header_list + mime_header_list_size;
 641          mh++) if (strncmpic(mh->name, header, mh->namelen) == 0)
 642       {
 643       uschar * header_value = NULL;
 644       int header_value_len = 0;
 645       uschar * p = header + mh->namelen;
 646       uschar * q;
 647
 648       /* grab the value (normalize to lower case)
 649       and copy to its corresponding expansion variable */
 650
 651       for (q = p; *q != ';' && *q; q++) ;
 652       *mh->value = string_copynlc(p, q-p);
 653       DEBUG(D_acl) debug_printf("found %s MIME header, value is '%s'\n",
 654         mh->name, *mh->value);
 655
 656       if (*(p = q)) p++;                        /* jump past the ; */
 657
 658         {
 659         uschar * mime_fname = NULL;
 660         uschar * mime_fname_rfc2231 = NULL;
 661         uschar * mime_filename_charset = NULL;
 662         BOOL decoding_failed = FALSE;
 663
 664         /* grab all param=value tags on the remaining line,
 665         check if they are interesting */
 666
 667         while (*p)
 668           {
 669           mime_parameter * mp;
 670
 671           DEBUG(D_acl) debug_printf("  considering paramlist '%s'\n", p);
 672
 673           if (  !mime_filename
 674              && strncmpic("content-disposition:", header, 20) == 0
 675              && strncmpic("filename*", p, 9) == 0
 676              )
 677             {                                   /* RFC 2231 filename */
 678             uschar * q;
 679
 680             /* find value of the filename */
 681             p += 9;
 682             while(*p != '=' && *p) p++;
 683             if (*p) p++;                        /* p is filename or NUL */
 684             q = mime_param_val(&p);             /* p now trailing ; or NUL */
 685
 686             if (q && *q)
 687               {
 688               uschar * temp_string, * err_msg;
 689               int slen;
 690
 691               /* build up an un-decoded filename over successive
 692               filename*= parameters (for use when 2047 decode fails) */
 693
 694               mime_fname_rfc2231 = string_sprintf("%#s%s",
 695                 mime_fname_rfc2231, q);
 696
 697               if (!decoding_failed)
 698                 {
 699                 int size;
 700                 if (!mime_filename_charset)
 701                   {
 702                   uschar * s = q;
 703
 704                   /* look for a ' in the "filename" */
 705                   while(*s != '\'' && *s) s++;  /* s is ' or NUL */
 706
 707                   if ((size = s-q) > 0)
 708                     {
 709                     mime_filename_charset = string_copyn(q, size);
 710                     p = s;
 711
 712                     while(*p == '\'' && *p) p++; /* p is after ' */
 713                     }
 714                   }
 715                 else
 716                   p = q;
 717
 718                 temp_string = rfc2231_to_2047(p, mime_filename_charset, &slen);
 719                 temp_string = rfc2047_decode(temp_string, FALSE, NULL, 32,
 720                   NULL, &err_msg);
 721                 size = Ustrlen(temp_string);
 722
 723                 if (size == slen)
 724                   decoding_failed = TRUE;
 725                 else
 726                   /* build up a decoded filename over successive
 727                   filename*= parameters */
 728
 729                   mime_filename = mime_fname = mime_fname
 730                     ? string_sprintf("%s%s", mime_fname, temp_string)
 731                     : temp_string;
 732                 }
 733               }
 734             }
 735
 736           else
 737             /* look for interesting parameters */
 738             for (mp = mime_parameter_list;
 739                  mp < mime_parameter_list + nelem(mime_parameter_list);
 740                  mp++
 741                 ) if (strncmpic(mp->name, p, mp->namelen) == 0)
 742               {
 743               uschar * q;
 744               uschar * dummy_errstr;
 745
 746               /* grab the value and copy to its expansion variable */
 747               p += mp->namelen;
 748               q = mime_param_val(&p);           /* p now trailing ; or NUL */
 749
 750               *mp->value = q && *q
 751                 ? rfc2047_decode(q, check_rfc2047_length, NULL, 32, NULL,
 752                     &dummy_errstr)
 753                 : NULL;
 754               DEBUG(D_acl) debug_printf(
 755                 " found %s MIME parameter in %s header, value '%s'\n",
 756                 mp->name, mh->name, *mp->value);
 757
 758               break;                    /* done matching param names */
 759               }
 760
 761
 762           /* There is something, but not one of our interesting parameters.
 763              Advance past the next semicolon */
 764           p = mime_next_semicolon(p);
 765           if (*p) p++;
 766           }                             /* param scan on line */
 767
 768         if (strncmpic("content-disposition:", header, 20) == 0)
 769           {
 770           if (decoding_failed) mime_filename = mime_fname_rfc2231;
 771
 772           DEBUG(D_acl) debug_printf(
 773             " found %s MIME parameter in %s header, value is '%s'\n",
 774             "filename", mh->name, mime_filename);
 775           }
 776         }
 777       }
 778     }
 779
 780   /* set additional flag variables (easier access) */
 781   if (  mime_content_type
 782      && Ustrncmp(mime_content_type,"multipart",9) == 0
 783      )
 784     mime_is_multipart = 1;
 785
 786   /* Make a copy of the boundary pointer.
 787      Required since mime_boundary is global
 788      and can be overwritten further down in recursion */
 789   nested_context.boundary = mime_boundary;
 790
 791   /* raise global counter */
 792   mime_part_count++;
 793
 794   /* copy current file handle to global variable */
 795   mime_stream = f;
 796   mime_current_boundary = context ? context->boundary : 0;
 797
 798   /* Note the context */
 799   mime_is_coverletter = !(context && context->context == MBC_ATTACHMENT);
 800
 801   /* call ACL handling function */
 802   rc = acl_check(ACL_WHERE_MIME, NULL, acl, user_msgptr, log_msgptr);
 803
 804   mime_stream = NULL;
 805   mime_current_boundary = NULL;
 806
 807   if (rc != OK) break;
 808
 809   /* If we have a multipart entity and a boundary, go recursive */
 810   if ( (mime_content_type != NULL) &&
 811        (nested_context.boundary != NULL) &&
 812        (Ustrncmp(mime_content_type,"multipart",9) == 0) )
 813     {
 814     DEBUG(D_acl) debug_printf("Entering multipart recursion, boundary '%s'\n",
 815       nested_context.boundary);
 816
 817     nested_context.context =
 818       context && context->context == MBC_ATTACHMENT
 819       ? MBC_ATTACHMENT
 820       :    Ustrcmp(mime_content_type,"multipart/alternative") == 0
 821         || Ustrcmp(mime_content_type,"multipart/related") == 0
 822       ? MBC_COVERLETTER_ALL
 823       : MBC_COVERLETTER_ONESHOT;
 824
 825     rc = mime_acl_check(acl, f, &nested_context, user_msgptr, log_msgptr);
 826     if (rc != OK) break;
 827     }
 828   else if ( (mime_content_type != NULL) &&
 829           (Ustrncmp(mime_content_type,"message/rfc822",14) == 0) )
 830     {
 831     const uschar *rfc822name = NULL;
 832     uschar filename[2048];
 833     int file_nr = 0;
 834     int result = 0;
 835
 836     /* must find first free sequential filename */
 837     do
 838       {
 839       struct stat mystat;
 840       (void)string_format(filename, 2048,
 841         "%s/scan/%s/__rfc822_%05u", spool_directory, message_id, file_nr++);
 842       /* security break */
 843       if (file_nr >= 128)
 844         goto NO_RFC822;
 845       result = stat(CS filename,&mystat);
 846       } while (result != -1);
 847
 848     rfc822name = filename;
 849
 850     /* decode RFC822 attachment */
 851     mime_decoded_filename = NULL;
 852     mime_stream = f;
 853     mime_current_boundary = context ? context->boundary : NULL;
 854     mime_decode(&rfc822name);
 855     mime_stream = NULL;
 856     mime_current_boundary = NULL;
 857     if (!mime_decoded_filename)         /* decoding failed */
 858       {
 859       log_write(0, LOG_MAIN,
 860            "mime_regex acl condition warning - could not decode RFC822 MIME part to file.");
 861       rc = DEFER;
 862       goto out;
 863       }
 864     mime_decoded_filename = NULL;
 865     }
 866
 867 NO_RFC822:
 868   /* If the boundary of this instance is NULL, we are finished here */
 869   if (!context) break;
 870
 871   if (context->context == MBC_COVERLETTER_ONESHOT)
 872     context->context = MBC_ATTACHMENT;
 873   }
 874
 875 out:
 876 mime_vars_reset();
 877 return rc;
 878 }
 879
 880 #endif  /*WITH_CONTENT_SCAN*/
 881
 882 /* vi: sw ai sw=2
 883 */