MIME: Support RFC2231 for filenames. Bug 466
[exim.git] / src / src / mime.c
CommitLineData
8523533c
TK
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"
c007c974 9#ifdef WITH_CONTENT_SCAN /* entire file */
8523533c
TK
10#include "mime.h"
11#include <sys/stat.h>
12
13FILE *mime_stream = NULL;
14uschar *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
f846c8f5 24static void
c007c974
JH
25mime_set_anomaly(int level, const char *text)
26{
8523533c 27 mime_anomaly_level = level;
1ba28e2b 28 mime_anomaly_text = CUS text;
f7b63901 29}
8523533c
TK
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
f846c8f5 44static uschar *
c007c974
JH
45mime_decode_qp_char(uschar *qp_p, int *c)
46{
47uschar *initial_pos = qp_p;
48
49/* advance one char */
50qp_p++;
51
52/* Check for two hex digits and decode them */
53if (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 }
8e669ac1 61
c007c974
JH
62/* tab or whitespace may follow just ignore it if it precedes \n */
63while (*qp_p == '\t' || *qp_p == ' ' || *qp_p == '\r')
8523533c 64 qp_p++;
8e669ac1 65
c007c974
JH
66if (*qp_p == '\n') /* hit soft line break */
67 {
68 *c = -1;
69 return qp_p;
70 }
71
72/* illegal char here */
73*c = -2;
74return initial_pos;
8523533c
TK
75}
76
77
baee9eee 78/* just dump MIME part without any decoding */
eb02738d
PP
79static ssize_t
80mime_decode_asis(FILE* in, FILE* out, uschar* boundary)
baee9eee 81{
eb02738d 82 ssize_t len, size = 0;
baee9eee 83 uschar buffer[MIME_MAX_LINE_LENGTH];
d203e649 84
c007c974
JH
85 while(fgets(CS buffer, MIME_MAX_LINE_LENGTH, mime_stream) != NULL)
86 {
baee9eee 87 if (boundary != NULL
c007c974
JH
88 && Ustrncmp(buffer, "--", 2) == 0
89 && Ustrncmp((buffer+2), boundary, Ustrlen(boundary)) == 0
90 )
baee9eee
NM
91 break;
92
93 len = Ustrlen(buffer);
94 if (fwrite(buffer, 1, (size_t)len, out) < len)
95 return -1;
96 size += len;
c007c974 97 } /* while */
baee9eee
NM
98 return size;
99}
84330b7b 100
8523533c 101
baee9eee 102/* decode base64 MIME part */
eb02738d
PP
103static ssize_t
104mime_decode_base64(FILE* in, FILE* out, uschar* boundary)
baee9eee
NM
105{
106 uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
107 uschar *ipos, *opos;
eb02738d 108 ssize_t len, size = 0;
baee9eee
NM
109 int bytestate = 0;
110
111 opos = obuf;
112
7156b1ef 113 while (Ufgets(ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
c007c974 114 {
baee9eee 115 if (boundary != NULL
c007c974
JH
116 && Ustrncmp(ibuf, "--", 2) == 0
117 && Ustrncmp((ibuf+2), boundary, Ustrlen(boundary)) == 0
118 )
baee9eee
NM
119 break;
120
c007c974
JH
121 for (ipos = ibuf ; *ipos != '\r' && *ipos != '\n' && *ipos != 0; ++ipos)
122 {
123 if (*ipos == '=') /* skip padding */
124 {
baee9eee
NM
125 ++bytestate;
126 continue;
c007c974
JH
127 }
128 if (mime_b64[*ipos] == 128) /* skip bad characters */
129 {
8523533c 130 mime_set_anomaly(MIME_ANOMALY_BROKEN_BASE64);
baee9eee 131 continue;
c007c974
JH
132 }
133
baee9eee 134 /* simple state-machine */
c007c974
JH
135 switch((bytestate++) & 3)
136 {
baee9eee
NM
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;
c007c974
JH
154 } /* switch */
155 } /* for */
156
baee9eee
NM
157 /* something to write? */
158 len = opos - obuf;
c007c974
JH
159 if (len > 0)
160 {
161 if (fwrite(obuf, 1, len, out) != len) return -1; /* error */
baee9eee
NM
162 size += len;
163 /* copy incomplete last byte to start of obuf, where we continue */
7156b1ef 164 if ((bytestate & 3) != 0)
baee9eee
NM
165 *obuf = *opos;
166 opos = obuf;
c007c974
JH
167 }
168 } /* while */
baee9eee
NM
169
170 /* write out last byte if it was incomplete */
c007c974
JH
171 if (bytestate & 3)
172 {
173 if (fwrite(obuf, 1, 1, out) != 1) return -1;
174 ++size;
175 }
8e669ac1 176
baee9eee
NM
177 return size;
178}
8e669ac1 179
8e669ac1 180
baee9eee 181/* decode quoted-printable MIME part */
eb02738d
PP
182static ssize_t
183mime_decode_qp(FILE* in, FILE* out, uschar* boundary)
baee9eee 184{
c007c974
JH
185uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
186uschar *ipos, *opos;
187ssize_t len, size = 0;
baee9eee 188
c007c974 189while (fgets(CS ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
baee9eee 190 {
c007c974
JH
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 */
8523533c 196
c007c974
JH
197 ipos = ibuf;
198 opos = obuf;
8e669ac1 199
c007c974
JH
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 }
8523533c 223 }
c007c974
JH
224 else
225 {
226 *opos = *ipos;
227 ++opos;
228 ++ipos;
baee9eee
NM
229 }
230 }
c007c974
JH
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;
baee9eee 237 }
8523533c 238 }
c007c974 239return size;
8523533c
TK
240}
241
242
f846c8f5 243static FILE *
c007c974
JH
244mime_get_decode_file(uschar *pname, uschar *fname)
245{
246FILE *f = NULL;
247uschar *filename;
8e669ac1 248
c007c974 249filename = (uschar *)malloc(2048);
8e669ac1 250
c007c974
JH
251if (pname && fname)
252 {
253 (void)string_format(filename, 2048, "%s/%s", pname, fname);
254 f = modefopen(filename,"wb+",SPOOL_MODE);
8523533c 255 }
c007c974
JH
256else if (!pname)
257 f = modefopen(fname,"wb+",SPOOL_MODE);
258else 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);
8523533c 274
c007c974
JH
275 f = modefopen(filename, "wb+", SPOOL_MODE);
276 }
8e669ac1 277
c007c974
JH
278/* set expansion variable */
279mime_decoded_filename = filename;
8e669ac1 280
c007c974 281return f;
8523533c
TK
282}
283
284
c007c974 285int
55414b25 286mime_decode(const uschar **listptr)
c007c974
JH
287{
288int sep = 0;
55414b25 289const uschar *list = *listptr;
c007c974
JH
290uschar *option;
291uschar option_buffer[1024];
292uschar decode_path[1024];
293FILE *decode_file = NULL;
294long f_pos = 0;
295ssize_t size_counter = 0;
296ssize_t (*decode_function)(FILE*, FILE*, uschar*);
297
298if (mime_stream == NULL)
299 return FAIL;
300
301f_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 */
307if ((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 */
8523533c 314 return FAIL;
8e669ac1 315
c007c974
JH
316 if (Ustrcmp(option,"default") == 0)
317 /* explicit default path + file names */
318 goto DEFAULT_PATH;
8e669ac1 319
c007c974
JH
320 if (option[0] == '/')
321 {
322 struct stat statbuf;
8e669ac1 323
c007c974 324 memset(&statbuf,0,sizeof(statbuf));
8e669ac1 325
c007c974
JH
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);
8523533c 330 else
c007c974
JH
331 /* does not exist or is a file, use as full file name */
332 decode_file = mime_get_decode_file(NULL, option);
333 }
baee9eee 334 else
c007c974
JH
335 /* assume file name only, use default path */
336 decode_file = mime_get_decode_file(decode_path, option);
337 }
338else
339 {
340 /* no option? patch default path */
341DEFAULT_PATH:
342 decode_file = mime_get_decode_file(decode_path, NULL);
343 }
8e669ac1 344
c007c974
JH
345if (!decode_file)
346 return DEFER;
8e669ac1 347
c007c974
JH
348/* decode according to mime type */
349decode_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 */
8e669ac1 357
c007c974 358size_counter = decode_function(mime_stream, decode_file, mime_current_boundary);
baee9eee 359
c007c974
JH
360clearerr(mime_stream);
361fseek(mime_stream, f_pos, SEEK_SET);
8e669ac1 362
c007c974
JH
363if (fclose(decode_file) != 0 || size_counter < 0)
364 return DEFER;
8523533c 365
c007c974
JH
366/* round up to the next KiB */
367mime_content_size = (size_counter + 1023) / 1024;
8e669ac1 368
c007c974
JH
369return OK;
370}
8e669ac1 371
f846c8f5
JH
372
373static int
c007c974
JH
374mime_get_header(FILE *f, uschar *header)
375{
376int c = EOF;
377int done = 0;
378int header_value_mode = 0;
379int header_open_brackets = 0;
380int num_copied = 0;
8e669ac1 381
c007c974
JH
382while(!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 }
8e669ac1 402
c007c974
JH
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;
8e669ac1 412
8523533c
TK
413 /* we have hit a non-whitespace char, start copying value data */
414 header_value_mode = 2;
8e669ac1 415
1bd0d12b
JH
416 if (c == '"') /* flip "quoted" mode */
417 header_value_mode = header_value_mode==2 ? 3 : 2;
8e669ac1 418
1bd0d12b
JH
419 /* leave value mode on unquoted ';' */
420 if (header_value_mode == 2 && c == ';') {
8523533c
TK
421 header_value_mode = 0;
422 };
423 /* -------------------------------- */
424 }
c007c974
JH
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;
8523533c 436 }
c007c974
JH
437 else if (c == '(')
438 {
439 header_open_brackets++;
440 continue;
8523533c 441 }
c007c974
JH
442 else if ((c == ')') && header_open_brackets)
443 {
444 header_open_brackets--;
445 continue;
8523533c 446 }
c007c974
JH
447 else if ( (c == '=') && !header_open_brackets ) /* enter value mode */
448 header_value_mode = 1;
8e669ac1 449
c007c974
JH
450 /* skip chars while we are in a comment */
451 if (header_open_brackets > 0)
452 continue;
453 /* -------------------------------- */
454 }
8e669ac1 455
c007c974
JH
456 /* copy the char to the buffer */
457 header[num_copied++] = (uschar)c;
8e669ac1 458
c007c974
JH
459 /* break if header buffer is full */
460 if (num_copied > MIME_MAX_HEADER_SIZE-1)
461 done = 1;
462 }
8523533c 463
c007c974
JH
464if ((num_copied > 0) && (header[num_copied-1] != ';'))
465 header[num_copied-1] = ';';
8523533c 466
c007c974
JH
467/* 0-terminate */
468header[num_copied] = '\0';
8e669ac1 469
c007c974
JH
470/* return 0 for EOF or empty line */
471if ((c == EOF) || (num_copied == 1))
472 return 0;
473else
474 return 1;
8523533c
TK
475}
476
477
f846c8f5
JH
478static void
479mime_vars_reset(void)
480{
481mime_anomaly_level = 0;
482mime_anomaly_text = NULL;
483mime_boundary = NULL;
484mime_charset = NULL;
485mime_decoded_filename = NULL;
486mime_filename = NULL;
487mime_content_description = NULL;
488mime_content_disposition = NULL;
489mime_content_id = NULL;
490mime_content_transfer_encoding = NULL;
491mime_content_type = NULL;
492mime_is_multipart = 0;
493mime_content_size = 0;
494}
495
496
497/* Grab a parameter value, dealing with quoting.
498
499Arguments:
500 str Input string. Updated on return to point to terminating ; or NUL
501
502Return:
503 Allocated string with parameter value
504*/
505static uschar *
506mime_param_val(uschar ** sp)
507{
508uschar * s = *sp;
509uschar * val = NULL;
510int size = 0, ptr = 0;
511
512/* debug_printf(" considering paramval '%s'\n", s); */
513
514while (*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);
524if (val) val[ptr] = '\0';
525*sp = s;
526return val;
527}
528
529static uschar *
530mime_next_semicolon(uschar * s)
531{
532while (*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++;
542return s;
543}
544
545
c007c974
JH
546int
547mime_acl_check(uschar *acl, FILE *f, struct mime_boundary_context *context,
f846c8f5 548 uschar **user_msgptr, uschar **log_msgptr)
c007c974
JH
549{
550int rc = OK;
f846c8f5 551uschar * header = NULL;
c007c974
JH
552struct mime_boundary_context nested_context;
553
554/* reserve a line buffer to work in */
f846c8f5 555header = store_get(MIME_MAX_HEADER_SIZE+1);
c007c974
JH
556
557/* Not actually used at the moment, but will be vital to fixing
558 * some RFC 2046 nonconformance later... */
559nested_context.parent = context;
560
561/* loop through parts */
562while(1)
563 {
564 /* reset all per-part mime variables */
f846c8f5
JH
565 mime_vars_reset();
566
567 /* If boundary is null, we assume that *f is positioned on the start of
568 headers (for example, at the very beginning of a message. If a boundary is
569 given, we must first advance to it to reach the start of the next header
570 block. */
c007c974
JH
571
572 /* NOTE -- there's an error here -- RFC2046 specifically says to
573 * check for outer boundaries. This code doesn't do that, and
574 * I haven't fixed this.
575 *
576 * (I have moved partway towards adding support, however, by adding
577 * a "parent" field to my new boundary-context structure.)
578 */
f846c8f5 579 if (context) for (;;)
c007c974 580 {
f846c8f5 581 if (!fgets(CS header, MIME_MAX_HEADER_SIZE, f))
c007c974 582 {
f846c8f5
JH
583 /* Hit EOF or read error. Ugh. */
584 DEBUG(D_acl) debug_printf("Hit EOF ...\n");
585 return rc;
586 }
5c6cf6a0 587
f846c8f5
JH
588 /* boundary line must start with 2 dashes */
589 if ( Ustrncmp(header, "--", 2) == 0
590 && Ustrncmp(header+2, context->boundary, Ustrlen(context->boundary)) == 0
591 )
592 { /* found boundary */
593 if (Ustrncmp((header+2+Ustrlen(context->boundary)), "--", 2) == 0)
594 {
595 /* END boundary found */
596 DEBUG(D_acl) debug_printf("End boundary found %s\n",
597 context->boundary);
598 return rc;
c007c974 599 }
f846c8f5
JH
600
601 DEBUG(D_acl) debug_printf("Next part with boundary %s\n",
602 context->boundary);
603 break;
8523533c 604 }
c007c974 605 }
8e669ac1 606
c007c974 607 /* parse headers, set up expansion variables */
5c6cf6a0 608 while (mime_get_header(f, header))
c007c974 609 {
f846c8f5
JH
610 struct mime_header * mh;
611
612 /* look for interesting headers */
613 for (mh = mime_header_list;
614 mh < mime_header_list + mime_header_list_size;
615 mh++) if (strncmpic(mh->name, header, mh->namelen) == 0)
616 {
617 uschar * header_value = NULL;
618 int header_value_len = 0;
619 uschar * p = header + mh->namelen;
620 uschar * q;
c007c974 621
f846c8f5
JH
622 /* grab the value (normalize to lower case)
623 and copy to its corresponding expansion variable */
624
625 for (q = p; *q != ';' && *q; q++) ;
626 *mh->value = string_copynlc(p, q-p);
627 DEBUG(D_acl) debug_printf("found %s MIME header, value is '%s'\n",
628 mh->name, *mh->value);
629
630 if (*(p = q)) p++; /* jump past the ; */
631
632 {
633 uschar * mime_fname = NULL;
634 uschar * mime_fname_rfc2231 = NULL;
635 uschar * mime_filename_charset = NULL;
636 BOOL decoding_failed = FALSE;
c007c974 637
5c6cf6a0
JH
638 /* grab all param=value tags on the remaining line,
639 check if they are interesting */
f846c8f5 640
5c6cf6a0 641 while (*p)
c007c974
JH
642 {
643 mime_parameter * mp;
f846c8f5
JH
644
645 DEBUG(D_acl) debug_printf(" considering paramlist '%s'\n", p);
646
647 if ( !mime_filename
648 && strncmpic("content-disposition:", header, 20) == 0
649 && strncmpic("filename*", p, 9) == 0
650 )
651 { /* RFC 2231 filename */
652 uschar * q;
653
654 /* find value of the filename */
655 p += 9;
656 while(*p != '=' && *p) p++;
657 if (*p) p++; /* p is filename or NUL */
658 q = mime_param_val(&p); /* p now trailing ; or NUL */
659
660 if (q && *q)
c007c974 661 {
f846c8f5
JH
662 uschar * temp_string, * err_msg;
663 int slen;
4fd5d2bf 664
f846c8f5
JH
665 /* build up an un-decoded filename over successive
666 filename*= parameters (for use when 2047 decode fails) */
667
668 mime_fname_rfc2231 = string_sprintf("%#s%s",
669 mime_fname_rfc2231, q);
670
671 if (!decoding_failed)
672 {
673 int size;
674 if (!mime_filename_charset)
4fd5d2bf 675 {
f846c8f5
JH
676 uschar * s = q;
677
678 /* look for a ' in the "filename" */
679 while(*s != '\'' && *s) s++; /* s is ' or NUL */
680
681 if ((size = s-q) > 0)
682 {
683 mime_filename_charset = string_copyn(q, size);
684 p = s;
685
686 while(*p == '\'' && *p) p++; /* p is after ' */
687 }
4fd5d2bf
JH
688 }
689 else
f846c8f5 690 p = q;
5c6cf6a0 691
f846c8f5
JH
692 temp_string = expand_string(string_sprintf(
693 "=?%s?Q?${sg{%s}{\\N%%([\\dA-Fa-f]{2})\\N}{=\\$1}}?=",
694 mime_filename_charset, p));
695 slen = Ustrlen(temp_string);
696
697 temp_string = rfc2047_decode(temp_string, FALSE, NULL, 32,
698 NULL, &err_msg);
699 size = Ustrlen(temp_string);
700
701 if (size == slen)
702 decoding_failed = TRUE;
703 else
704 /* build up a decoded filename over successive
705 filename*= parameters */
706
707 mime_filename = mime_fname = mime_fname
708 ? string_sprintf("%s%s", mime_fname, temp_string)
709 : temp_string;
93cad488 710 }
f846c8f5 711 }
5c6cf6a0 712 }
f846c8f5 713
e7c25d5b 714 else
f846c8f5
JH
715 /* look for interesting parameters */
716 for (mp = mime_parameter_list;
717 mp < mime_parameter_list + nelem(mime_parameter_list);
718 mp++
719 ) if (strncmpic(mp->name, p, mp->namelen) == 0)
720 {
721 uschar * q;
722 uschar * dummy_errstr;
723
724 /* grab the value and copy to its expansion variable */
725 p += mp->namelen;
726 q = mime_param_val(&p); /* p now trailing ; or NUL */
727
728 *mp->value = q && *q
729 ? rfc2047_decode(q, check_rfc2047_length, NULL, 32, NULL,
730 &dummy_errstr)
731 : NULL;
732 DEBUG(D_acl) debug_printf(
733 " found %s MIME parameter in %s header, value '%s'\n",
734 mp->name, mh->name, *mp->value);
735
736 break; /* done matching param names */
737 }
738
739
740 /* There is something, but not one of our interesting parameters.
741 Advance past the next semicolon */
742 p = mime_next_semicolon(p);
743 if (*p) p++;
744 } /* param scan on line */
745
746 if (strncmpic("content-disposition:", header, 20) == 0)
747 {
748 if (decoding_failed) mime_filename = mime_fname_rfc2231;
749
750 DEBUG(D_acl) debug_printf(
751 " found %s MIME parameter in %s header, value is '%s'\n",
752 "filename", mh->name, mime_filename);
753 }
c007c974
JH
754 }
755 }
f846c8f5 756 }
8e669ac1 757
c007c974 758 /* set additional flag variables (easier access) */
f846c8f5
JH
759 if ( mime_content_type
760 && Ustrncmp(mime_content_type,"multipart",9) == 0
761 )
c007c974 762 mime_is_multipart = 1;
8e669ac1 763
c007c974
JH
764 /* Make a copy of the boundary pointer.
765 Required since mime_boundary is global
766 and can be overwritten further down in recursion */
767 nested_context.boundary = mime_boundary;
8e669ac1 768
c007c974
JH
769 /* raise global counter */
770 mime_part_count++;
8523533c 771
c007c974
JH
772 /* copy current file handle to global variable */
773 mime_stream = f;
774 mime_current_boundary = context ? context->boundary : 0;
8e669ac1 775
c007c974
JH
776 /* Note the context */
777 mime_is_coverletter = !(context && context->context == MBC_ATTACHMENT);
8e669ac1 778
c007c974
JH
779 /* call ACL handling function */
780 rc = acl_check(ACL_WHERE_MIME, NULL, acl, user_msgptr, log_msgptr);
8e669ac1 781
c007c974
JH
782 mime_stream = NULL;
783 mime_current_boundary = NULL;
784
785 if (rc != OK) break;
8e669ac1 786
c007c974
JH
787 /* If we have a multipart entity and a boundary, go recursive */
788 if ( (mime_content_type != NULL) &&
789 (nested_context.boundary != NULL) &&
790 (Ustrncmp(mime_content_type,"multipart",9) == 0) )
791 {
f846c8f5
JH
792 DEBUG(D_acl) debug_printf("Entering multipart recursion, boundary '%s'\n",
793 nested_context.boundary);
c007c974
JH
794
795 nested_context.context =
796 context && context->context == MBC_ATTACHMENT
797 ? MBC_ATTACHMENT
798 : Ustrcmp(mime_content_type,"multipart/alternative") == 0
799 || Ustrcmp(mime_content_type,"multipart/related") == 0
800 ? MBC_COVERLETTER_ALL
801 : MBC_COVERLETTER_ONESHOT;
802
803 rc = mime_acl_check(acl, f, &nested_context, user_msgptr, log_msgptr);
804 if (rc != OK) break;
8523533c 805 }
c007c974
JH
806 else if ( (mime_content_type != NULL) &&
807 (Ustrncmp(mime_content_type,"message/rfc822",14) == 0) )
808 {
55414b25 809 const uschar *rfc822name = NULL;
c007c974
JH
810 uschar filename[2048];
811 int file_nr = 0;
812 int result = 0;
8e669ac1 813
c007c974
JH
814 /* must find first free sequential filename */
815 do
816 {
817 struct stat mystat;
818 (void)string_format(filename, 2048,
819 "%s/scan/%s/__rfc822_%05u", spool_directory, message_id, file_nr++);
820 /* security break */
821 if (file_nr >= 128)
822 goto NO_RFC822;
823 result = stat(CS filename,&mystat);
824 } while (result != -1);
825
826 rfc822name = filename;
827
828 /* decode RFC822 attachment */
829 mime_decoded_filename = NULL;
830 mime_stream = f;
831 mime_current_boundary = context ? context->boundary : NULL;
832 mime_decode(&rfc822name);
833 mime_stream = NULL;
834 mime_current_boundary = NULL;
835 if (!mime_decoded_filename) /* decoding failed */
836 {
837 log_write(0, LOG_MAIN,
838 "mime_regex acl condition warning - could not decode RFC822 MIME part to file.");
f846c8f5
JH
839 rc = DEFER;
840 goto out;
c007c974
JH
841 }
842 mime_decoded_filename = NULL;
843 }
8523533c 844
c007c974
JH
845NO_RFC822:
846 /* If the boundary of this instance is NULL, we are finished here */
f846c8f5 847 if (!context) break;
8e669ac1 848
c007c974
JH
849 if (context->context == MBC_COVERLETTER_ONESHOT)
850 context->context = MBC_ATTACHMENT;
851 }
8523533c 852
f846c8f5
JH
853out:
854mime_vars_reset();
c007c974 855return rc;
8523533c
TK
856}
857
c007c974
JH
858#endif /*WITH_CONTENT_SCAN*/
859
860/* vi: sw ai sw=2
861*/