tidying
[users/heiko/exim.git] / 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 */