src/src/mime.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004, 2015 */
   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 if (charset)
 554   val = string_cat(val, &size, &ptr, charset, Ustrlen(charset));
 555 val = string_cat(val, &size, &ptr, US"?Q?", 3);
 556
 557 while ((c = *fname))
 558   if (c == '%' && isxdigit(fname[1]) && isxdigit(fname[2]))
 559     {
 560     val = string_cat(val, &size, &ptr, US"=", 1);
 561     val = string_cat(val, &size, &ptr, ++fname, 2);
 562     fname += 2;
 563     }
 564   else
 565     val = string_cat(val, &size, &ptr, fname++, 1);
 566
 567 val = string_cat(val, &size, &ptr, US"?=", 2);
 568 val[*len = ptr] = '\0';
 569 return val;
 570 }
 571
 572
 573 int
 574 mime_acl_check(uschar *acl, FILE *f, struct mime_boundary_context *context,
 575     uschar **user_msgptr, uschar **log_msgptr)
 576 {
 577 int rc = OK;
 578 uschar * header = NULL;
 579 struct mime_boundary_context nested_context;
 580
 581 /* reserve a line buffer to work in */
 582 header = store_get(MIME_MAX_HEADER_SIZE+1);
 583
 584 /* Not actually used at the moment, but will be vital to fixing
 585  * some RFC 2046 nonconformance later... */
 586 nested_context.parent = context;
 587
 588 /* loop through parts */
 589 while(1)
 590   {
 591   /* reset all per-part mime variables */
 592   mime_vars_reset();
 593
 594   /* If boundary is null, we assume that *f is positioned on the start of
 595   headers (for example, at the very beginning of a message.  If a boundary is
 596   given, we must first advance to it to reach the start of the next header
 597   block.  */
 598
 599   /* NOTE -- there's an error here -- RFC2046 specifically says to
 600    * check for outer boundaries.  This code doesn't do that, and
 601    * I haven't fixed this.
 602    *
 603    * (I have moved partway towards adding support, however, by adding
 604    * a "parent" field to my new boundary-context structure.)
 605    */
 606   if (context) for (;;)
 607     {
 608     if (!fgets(CS header, MIME_MAX_HEADER_SIZE, f))
 609       {
 610       /* Hit EOF or read error. Ugh. */
 611       DEBUG(D_acl) debug_printf("MIME: Hit EOF ...\n");
 612       return rc;
 613       }
 614
 615     /* boundary line must start with 2 dashes */
 616     if (  Ustrncmp(header, "--", 2) == 0
 617        && Ustrncmp(header+2, context->boundary, Ustrlen(context->boundary)) == 0
 618        )
 619       {                 /* found boundary */
 620       if (Ustrncmp((header+2+Ustrlen(context->boundary)), "--", 2) == 0)
 621         {
 622         /* END boundary found */
 623         DEBUG(D_acl) debug_printf("MIME: End boundary found %s\n",
 624           context->boundary);
 625         return rc;
 626         }
 627
 628       DEBUG(D_acl) debug_printf("MIME: Next part with boundary %s\n",
 629         context->boundary);
 630       break;
 631       }
 632     }
 633
 634   /* parse headers, set up expansion variables */
 635   while (mime_get_header(f, header))
 636     {
 637     struct mime_header * mh;
 638
 639     /* look for interesting headers */
 640     for (mh = mime_header_list;
 641          mh < mime_header_list + mime_header_list_size;
 642          mh++) if (strncmpic(mh->name, header, mh->namelen) == 0)
 643       {
 644       uschar * p = header + mh->namelen;
 645       uschar * q;
 646
 647       /* grab the value (normalize to lower case)
 648       and copy to its corresponding expansion variable */
 649
 650       for (q = p; *q != ';' && *q; q++) ;
 651       *mh->value = string_copynlc(p, q-p);
 652       DEBUG(D_acl) debug_printf("MIME: found %s header, value is '%s'\n",
 653         mh->name, *mh->value);
 654
 655       if (*(p = q)) p++;                        /* jump past the ; */
 656
 657         {
 658         uschar * mime_fname = NULL;
 659         uschar * mime_fname_rfc2231 = NULL;
 660         uschar * mime_filename_charset = NULL;
 661         BOOL decoding_failed = FALSE;
 662
 663         /* grab all param=value tags on the remaining line,
 664         check if they are interesting */
 665
 666         while (*p)
 667           {
 668           mime_parameter * mp;
 669
 670           DEBUG(D_acl) debug_printf("MIME:   considering paramlist '%s'\n", p);
 671
 672           if (  !mime_filename
 673              && strncmpic(CUS"content-disposition:", header, 20) == 0
 674              && strncmpic(CUS"filename*", p, 9) == 0
 675              )
 676             {                                   /* RFC 2231 filename */
 677             uschar * q;
 678
 679             /* find value of the filename */
 680             p += 9;
 681             while(*p != '=' && *p) p++;
 682             if (*p) p++;                        /* p is filename or NUL */
 683             q = mime_param_val(&p);             /* p now trailing ; or NUL */
 684
 685             if (q && *q)
 686               {
 687               uschar * temp_string, * err_msg;
 688               int slen;
 689
 690               /* build up an un-decoded filename over successive
 691               filename*= parameters (for use when 2047 decode fails) */
 692
 693               mime_fname_rfc2231 = string_sprintf("%#s%s",
 694                 mime_fname_rfc2231, q);
 695
 696               if (!decoding_failed)
 697                 {
 698                 int size;
 699                 if (!mime_filename_charset)
 700                   {
 701                   uschar * s = q;
 702
 703                   /* look for a ' in the "filename" */
 704                   while(*s != '\'' && *s) s++;  /* s is 1st ' or NUL */
 705
 706                   if ((size = s-q) > 0)
 707                     mime_filename_charset = string_copyn(q, size);
 708
 709                   if (*(p = s)) p++;
 710                   while(*p == '\'') p++;        /* p is after 2nd ' */
 711                   }
 712                 else
 713                   p = q;
 714
 715                 DEBUG(D_acl) debug_printf("MIME:    charset %s fname '%s'\n",
 716                   mime_filename_charset ? mime_filename_charset : US"<NULL>", p);
 717
 718                 temp_string = rfc2231_to_2047(p, mime_filename_charset, &slen);
 719                 DEBUG(D_acl) debug_printf("MIME:    2047-name %s\n", temp_string);
 720
 721                 temp_string = rfc2047_decode(temp_string, FALSE, NULL, ' ',
 722                   NULL, &err_msg);
 723                 DEBUG(D_acl) debug_printf("MIME:    plain-name %s\n", temp_string);
 724
 725                 size = Ustrlen(temp_string);
 726
 727                 if (size == slen)
 728                   decoding_failed = TRUE;
 729                 else
 730                   /* build up a decoded filename over successive
 731                   filename*= parameters */
 732
 733                   mime_filename = mime_fname = mime_fname
 734                     ? string_sprintf("%s%s", mime_fname, temp_string)
 735                     : temp_string;
 736                 }
 737               }
 738             }
 739
 740           else
 741             /* look for interesting parameters */
 742             for (mp = mime_parameter_list;
 743                  mp < mime_parameter_list + nelem(mime_parameter_list);
 744                  mp++
 745                 ) if (strncmpic(mp->name, p, mp->namelen) == 0)
 746               {
 747               uschar * q;
 748               uschar * dummy_errstr;
 749
 750               /* grab the value and copy to its expansion variable */
 751               p += mp->namelen;
 752               q = mime_param_val(&p);           /* p now trailing ; or NUL */
 753
 754               *mp->value = q && *q
 755                 ? rfc2047_decode(q, check_rfc2047_length, NULL, 32, NULL,
 756                     &dummy_errstr)
 757                 : NULL;
 758               DEBUG(D_acl) debug_printf(
 759                 "MIME:  found %s parameter in %s header, value '%s'\n",
 760                 mp->name, mh->name, *mp->value);
 761
 762               break;                    /* done matching param names */
 763               }
 764
 765
 766           /* There is something, but not one of our interesting parameters.
 767              Advance past the next semicolon */
 768           p = mime_next_semicolon(p);
 769           if (*p) p++;
 770           }                             /* param scan on line */
 771
 772         if (strncmpic(CUS"content-disposition:", header, 20) == 0)
 773           {
 774           if (decoding_failed) mime_filename = mime_fname_rfc2231;
 775
 776           DEBUG(D_acl) debug_printf(
 777             "MIME:  found %s parameter in %s header, value is '%s'\n",
 778             "filename", mh->name, mime_filename);
 779           }
 780         }
 781       }
 782     }
 783
 784   /* set additional flag variables (easier access) */
 785   if (  mime_content_type
 786      && Ustrncmp(mime_content_type,"multipart",9) == 0
 787      )
 788     mime_is_multipart = 1;
 789
 790   /* Make a copy of the boundary pointer.
 791      Required since mime_boundary is global
 792      and can be overwritten further down in recursion */
 793   nested_context.boundary = mime_boundary;
 794
 795   /* raise global counter */
 796   mime_part_count++;
 797
 798   /* copy current file handle to global variable */
 799   mime_stream = f;
 800   mime_current_boundary = context ? context->boundary : 0;
 801
 802   /* Note the context */
 803   mime_is_coverletter = !(context && context->context == MBC_ATTACHMENT);
 804
 805   /* call ACL handling function */
 806   rc = acl_check(ACL_WHERE_MIME, NULL, acl, user_msgptr, log_msgptr);
 807
 808   mime_stream = NULL;
 809   mime_current_boundary = NULL;
 810
 811   if (rc != OK) break;
 812
 813   /* If we have a multipart entity and a boundary, go recursive */
 814   if ( (mime_content_type != NULL) &&
 815        (nested_context.boundary != NULL) &&
 816        (Ustrncmp(mime_content_type,"multipart",9) == 0) )
 817     {
 818     DEBUG(D_acl)
 819       debug_printf("MIME: Entering multipart recursion, boundary '%s'\n",
 820         nested_context.boundary);
 821
 822     nested_context.context =
 823       context && context->context == MBC_ATTACHMENT
 824       ? MBC_ATTACHMENT
 825       :    Ustrcmp(mime_content_type,"multipart/alternative") == 0
 826         || Ustrcmp(mime_content_type,"multipart/related") == 0
 827       ? MBC_COVERLETTER_ALL
 828       : MBC_COVERLETTER_ONESHOT;
 829
 830     rc = mime_acl_check(acl, f, &nested_context, user_msgptr, log_msgptr);
 831     if (rc != OK) break;
 832     }
 833   else if ( (mime_content_type != NULL) &&
 834           (Ustrncmp(mime_content_type,"message/rfc822",14) == 0) )
 835     {
 836     const uschar *rfc822name = NULL;
 837     uschar filename[2048];
 838     int file_nr = 0;
 839     int result = 0;
 840
 841     /* must find first free sequential filename */
 842     do
 843       {
 844       struct stat mystat;
 845       (void)string_format(filename, 2048,
 846         "%s/scan/%s/__rfc822_%05u", spool_directory, message_id, file_nr++);
 847       /* security break */
 848       if (file_nr >= 128)
 849         goto NO_RFC822;
 850       result = stat(CS filename,&mystat);
 851       } while (result != -1);
 852
 853     rfc822name = filename;
 854
 855     /* decode RFC822 attachment */
 856     mime_decoded_filename = NULL;
 857     mime_stream = f;
 858     mime_current_boundary = context ? context->boundary : NULL;
 859     mime_decode(&rfc822name);
 860     mime_stream = NULL;
 861     mime_current_boundary = NULL;
 862     if (!mime_decoded_filename)         /* decoding failed */
 863       {
 864       log_write(0, LOG_MAIN,
 865            "mime_regex acl condition warning - could not decode RFC822 MIME part to file.");
 866       rc = DEFER;
 867       goto out;
 868       }
 869     mime_decoded_filename = NULL;
 870     }
 871
 872 NO_RFC822:
 873   /* If the boundary of this instance is NULL, we are finished here */
 874   if (!context) break;
 875
 876   if (context->context == MBC_COVERLETTER_ONESHOT)
 877     context->context = MBC_ATTACHMENT;
 878   }
 879
 880 out:
 881 mime_vars_reset();
 882 return rc;
 883 }
 884
 885 #endif  /*WITH_CONTENT_SCAN*/
 886
 887 /* vi: sw ai sw=2
 888 */