Testsuite: move regex testcase to Content-scanning section
[exim.git] / src / src / demime.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003-???? */
6 /* License: GPL */
7
8 /* Code for unpacking MIME containers. Called from acl.c. */
9
10 #include "exim.h"
11 #ifdef WITH_OLD_DEMIME
12
13 #include "demime.h"
14
15 uschar demime_reason_buffer[1024];
16 struct file_extension *file_extensions = NULL;
17
18 int demime(uschar **listptr) {
19   int sep = 0;
20   uschar *list = *listptr;
21   uschar *option;
22   uschar option_buffer[64];
23   unsigned long mbox_size;
24   FILE *mbox_file;
25   uschar defer_error_buffer[1024];
26   int demime_rc = 0;
27
28   /* reset found_extension variable */
29   found_extension = NULL;
30
31   /* try to find 1st option */
32   if ((option = string_nextinlist(&list, &sep,
33                                   option_buffer,
34                                   sizeof(option_buffer))) != NULL) {
35
36     /* parse 1st option */
37     if ( (Ustrcmp(option,"false") == 0) || (Ustrcmp(option,"0") == 0) ) {
38       /* explicitly no demimeing */
39       return FAIL;
40     };
41   }
42   else {
43     /* no options -> no demimeing */
44     return FAIL;
45   };
46
47   /* make sure the eml mbox file is spooled up */
48   mbox_file = spool_mbox(&mbox_size, NULL);
49
50   if (mbox_file == NULL) {
51     /* error while spooling */
52     log_write(0, LOG_MAIN|LOG_PANIC,
53            "demime acl condition: error while creating mbox spool file");
54     return DEFER;
55   };
56
57   /* call demimer if not already done earlier */
58   if (!demime_ok)
59     demime_rc = mime_demux(mbox_file, defer_error_buffer);
60
61   (void)fclose(mbox_file);
62
63   if (demime_rc == DEFER) {
64     /* temporary failure (DEFER => DEFER) */
65     log_write(0, LOG_MAIN,
66         "demime acl condition: %s", defer_error_buffer);
67     return DEFER;
68   };
69
70   /* set demime_ok to avoid unpacking again */
71   demime_ok = 1;
72
73   /* check for file extensions, if there */
74   while (option != NULL) {
75     struct file_extension *this_extension = file_extensions;
76
77     /* Look for the wildcard. If it is found, we always return true.
78     The user must then use a custom condition to evaluate demime_errorlevel */
79     if (Ustrcmp(option,"*") == 0) {
80       found_extension = NULL;
81       return OK;
82     };
83
84     /* loop thru extension list */
85     while (this_extension != NULL) {
86       if (strcmpic(option, this_extension->file_extension_string) == 0) {
87         /* found one */
88         found_extension = this_extension->file_extension_string;
89         return OK;
90       };
91       this_extension = this_extension->next;
92     };
93
94     /* grab next extension from option list */
95     option = string_nextinlist(&list, &sep,
96                                option_buffer,
97                                sizeof(option_buffer));
98   };
99
100   /* nothing found */
101   return FAIL;
102 }
103
104
105 /*************************************************
106 * small hex_str -> integer conversion function   *
107 *************************************************/
108
109 /* needed for quoted-printable
110 */
111
112 unsigned int mime_hstr_i(uschar *cptr) {
113   unsigned int i, j = 0;
114
115   while (cptr && *cptr && isxdigit(*cptr)) {
116     i = *cptr++ - '0';
117     if (9 < i) i -= 7;
118     j <<= 4;
119     j |= (i & 0x0f);
120   }
121
122   return(j);
123 }
124
125
126 /*************************************************
127 * decode quoted-printable chars                  *
128 *************************************************/
129
130 /* gets called when we hit a =
131    returns: new pointer position
132    result code in c:
133           -2 - decode error
134           -1 - soft line break, no char
135            0-255 - char to write
136 */
137
138 uschar *mime_decode_qp(uschar *qp_p,int *c) {
139   uschar hex[] = {0,0,0};
140   int nan = 0;
141   uschar *initial_pos = qp_p;
142
143   /* advance one char */
144   qp_p++;
145
146   REPEAT_FIRST:
147   if ( (*qp_p == '\t') || (*qp_p == ' ') || (*qp_p == '\r') )  {
148     /* tab or whitespace may follow
149        just ignore it, but remember
150        that this is not a valid hex
151        encoding any more */
152     nan = 1;
153     qp_p++;
154     goto REPEAT_FIRST;
155   }
156   else if ( (('0' <= *qp_p) && (*qp_p <= '9')) || (('A' <= *qp_p) && (*qp_p <= 'F'))  || (('a' <= *qp_p) && (*qp_p <= 'f')) ) {
157     /* this is a valid hex char, if nan is unset */
158     if (nan) {
159       /* this is illegal */
160       *c = -2;
161       return initial_pos;
162     }
163     else {
164       hex[0] = *qp_p;
165       qp_p++;
166     };
167   }
168   else if (*qp_p == '\n') {
169     /* hit soft line break already, continue */
170     *c = -1;
171     return qp_p;
172   }
173   else {
174     /* illegal char here */
175     *c = -2;
176     return initial_pos;
177   };
178
179   if ( (('0' <= *qp_p) && (*qp_p <= '9')) || (('A' <= *qp_p) && (*qp_p <= 'F')) || (('a' <= *qp_p) && (*qp_p <= 'f')) ) {
180     if (hex[0] > 0) {
181       hex[1] = *qp_p;
182       /* do hex conversion */
183       *c = mime_hstr_i(hex);
184       qp_p++;
185       return qp_p;
186     }
187     else {
188       /* huh ? */
189       *c = -2;
190       return initial_pos;
191     };
192   }
193   else {
194     /* illegal char */
195     *c = -2;
196     return initial_pos;
197   };
198
199 }
200
201
202 /*************************************************
203 * open new dump file                             *
204 *************************************************/
205
206 /* open new dump file
207    returns: -2 soft error
208             or file #, FILE * in f
209 */
210
211 int mime_get_dump_file(uschar *extension, FILE **f, uschar *info) {
212   uschar file_name[1024];
213   int result;
214   unsigned int file_nr;
215   uschar default_extension[] = ".com";
216   uschar *p;
217
218   if (extension == NULL)
219     extension = default_extension;
220
221   /* scan the proposed extension.
222      if it is longer than 4 chars, or
223      contains exotic chars, use the default extension */
224
225 /*  if (Ustrlen(extension) > 4) {
226     extension = default_extension;
227   };
228 */
229
230   p = extension+1;
231
232   while (*p != 0) {
233     *p = (uschar)tolower((uschar)*p);
234     if ( (*p < 97) || (*p > 122) ) {
235       extension = default_extension;
236       break;
237     };
238     p++;
239   };
240
241   /* find a new file to write to */
242   file_nr = 0;
243   do {
244     struct stat mystat;
245
246     (void)string_format(file_name,1024,"%s/scan/%s/%s-%05u%s",spool_directory,message_id,message_id,file_nr,extension);
247     file_nr++;
248     if (file_nr >= MIME_SANITY_MAX_DUMP_FILES) {
249       /* max parts reached */
250       mime_trigger_error(MIME_ERRORLEVEL_TOO_MANY_PARTS);
251       break;
252     };
253     result = stat(CS file_name,&mystat);
254   }
255   while(result != -1);
256
257   *f = modefopen(file_name,"wb+",SPOOL_MODE);
258   if (*f == NULL) {
259     /* cannot open new dump file, disk full ? -> soft error */
260     (void)string_format(info, 1024,"unable to open dump file");
261     return -2;
262   };
263
264   return file_nr;
265 }
266
267
268 /*************************************************
269 * Find a string in a mime header                 *
270 *************************************************/
271
272 /* Find a string in a mime header, and optionally fill in
273    the value associated with it into *value
274
275    returns: 0 - nothing found
276             1 - found param
277             2 - found param + value
278 */
279
280 int mime_header_find(uschar *header, uschar *param, uschar **value) {
281   uschar *needle;
282
283   needle = strstric(header,param,FALSE);
284   if (needle != NULL) {
285     if (value != NULL) {
286       needle += Ustrlen(param);
287       if (*needle == '=') {
288         uschar *value_start;
289         uschar *value_end;
290
291         value_start = needle + 1;
292         value_end = strstric(value_start,US";",FALSE);
293         if (value_end != NULL) {
294           /* allocate mem for value */
295           *value = (uschar *)malloc((value_end - value_start)+1);
296           if (*value == NULL)
297             return 0;
298
299           Ustrncpy(*value,value_start,(value_end - value_start));
300           (*value)[(value_end - value_start)] = '\0';
301           return 2;
302         };
303       };
304     };
305     return 1;
306   };
307   return 0;
308 }
309
310
311 /*************************************************
312 * Read a line of MIME input                      *
313 *************************************************/
314 /* returns status code, one of
315    MIME_READ_LINE_EOF 0
316    MIME_READ_LINE_OK 1
317    MIME_READ_LINE_OVERFLOW 2
318
319    In header mode, the line will be "cooked".
320 */
321
322 int mime_read_line(FILE *f, int mime_demux_mode, uschar *buffer, long *num_copied) {
323   int c = EOF;
324   int done = 0;
325   int header_value_mode = 0;
326   int header_open_brackets = 0;
327
328   *num_copied = 0;
329
330   while(!done) {
331
332     c = fgetc(f);
333     if (c == EOF) break;
334
335     /* --------- header mode -------------- */
336     if (mime_demux_mode == MIME_DEMUX_MODE_MIME_HEADERS) {
337
338       /* always skip CRs */
339       if (c == '\r') continue;
340
341       if (c == '\n') {
342         if ((*num_copied) > 0) {
343           /* look if next char is '\t' or ' ' */
344           c = fgetc(f);
345           if (c == EOF) break;
346           if ( (c == '\t') || (c == ' ') ) continue;
347           (void)ungetc(c,f);
348         };
349         /* end of the header, terminate with ';' */
350         c = ';';
351         done = 1;
352       };
353
354       /* skip control characters */
355       if (c < 32) continue;
356
357       /* skip whitespace + tabs */
358       if ( (c == ' ') || (c == '\t') )
359         continue;
360
361       if (header_value_mode) {
362         /* --------- value mode ----------- */
363         /* skip quotes */
364         if (c == '"') continue;
365
366         /* leave value mode on ';' */
367         if (c == ';') {
368           header_value_mode = 0;
369         };
370         /* -------------------------------- */
371       }
372       else {
373         /* -------- non-value mode -------- */
374         if (c == '\\') {
375           /* quote next char. can be used
376           to escape brackets. */
377           c = fgetc(f);
378           if (c == EOF) break;
379         }
380         else if (c == '(') {
381           header_open_brackets++;
382           continue;
383         }
384         else if ((c == ')') && header_open_brackets) {
385           header_open_brackets--;
386           continue;
387         }
388         else if ( (c == '=') && !header_open_brackets ) {
389           /* enter value mode */
390           header_value_mode = 1;
391         };
392
393         /* skip chars while we are in a comment */
394         if (header_open_brackets > 0)
395           continue;
396         /* -------------------------------- */
397       };
398     }
399     /* ------------------------------------ */
400     else {
401     /* ----------- non-header mode -------- */
402       /* break on '\n' */
403       if (c == '\n')
404         done = 1;
405     /* ------------------------------------ */
406     };
407
408     /* copy the char to the buffer */
409     buffer[*num_copied] = (uschar)c;
410     /* raise counter */
411     (*num_copied)++;
412
413     /* break if buffer is full */
414     if (*num_copied > MIME_SANITY_MAX_LINE_LENGTH-1) {
415       done = 1;
416     };
417   }
418
419   /* 0-terminate */
420   buffer[*num_copied] = '\0';
421
422   if (*num_copied > MIME_SANITY_MAX_LINE_LENGTH-1)
423     return MIME_READ_LINE_OVERFLOW;
424   else
425     if (c == EOF)
426       return MIME_READ_LINE_EOF;
427     else
428       return MIME_READ_LINE_OK;
429 }
430
431
432 /*************************************************
433 * Check for a MIME boundary                      *
434 *************************************************/
435
436 /* returns: 0 - no boundary found
437             1 - start boundary found
438             2 - end boundary found
439 */
440
441 int mime_check_boundary(uschar *line, struct boundary *boundaries) {
442   struct boundary *thisboundary = boundaries;
443   uschar workbuf[MIME_SANITY_MAX_LINE_LENGTH+1];
444   unsigned int i,j=0;
445
446   /* check for '--' first */
447   if (Ustrncmp(line,"--",2) == 0) {
448
449     /* strip tab and space */
450     for (i = 2; i < Ustrlen(line); i++) {
451       if ((line[i] != ' ') && (line[i] != '\t')) {
452         workbuf[j] = line[i];
453         j++;
454       };
455     };
456     workbuf[j+1]='\0';
457
458     while(thisboundary != NULL) {
459       if (Ustrncmp(workbuf,thisboundary->boundary_string,Ustrlen(thisboundary->boundary_string)) == 0) {
460         if (Ustrncmp(&workbuf[Ustrlen(thisboundary->boundary_string)],"--",2) == 0) {
461           /* final boundary found */
462           return 2;
463         };
464         return 1;
465       };
466       thisboundary = thisboundary->next;
467     };
468   };
469
470   return 0;
471 }
472
473
474 /*************************************************
475 * Check for start of a UUENCODE block            *
476 *************************************************/
477
478 /* returns 0 for no hit,
479            >0 for hit
480 */
481
482 int mime_check_uu_start(uschar *line, uschar *uu_file_extension, int *has_tnef) {
483
484   if ( (strncmpic(line,US"begin ",6) == 0)) {
485     uschar *uu_filename = &line[6];
486
487     /* skip perms, if present */
488     Ustrtoul(&line[6],&uu_filename,10);
489
490     /* advance one char */
491     uu_filename++;
492
493     /* This should be the filename.
494     Check if winmail.dat is present,
495     which indicates TNEF. */
496     if (strncmpic(uu_filename,US"winmail.dat",11) == 0) {
497       *has_tnef = 1;
498     };
499
500     /* reverse to dot if present,
501     copy up to 4 chars for the extension */
502     if (Ustrrchr(uu_filename,'.') != NULL)
503       uu_filename = Ustrrchr(uu_filename,'.');
504
505     return sscanf(CS uu_filename, "%4[.0-9A-Za-z]",CS uu_file_extension);
506   }
507   else {
508     /* nothing found */
509     return 0;
510   };
511 }
512
513
514 /*************************************************
515 * Decode a uu line                               *
516 *************************************************/
517
518 /* returns number of decoded bytes
519          -2 for soft errors
520 */
521
522 int warned_about_uudec_line_sanity_1 = 0;
523 int warned_about_uudec_line_sanity_2 = 0;
524 long uu_decode_line(uschar *line, uschar **data, long line_len, uschar *info) {
525   uschar *p;
526   long num_decoded = 0;
527   uschar tmp_c;
528   uschar *work;
529   int uu_decoded_line_len, uu_encoded_line_len;
530
531   /* allocate memory for data and work buffer */
532   *data = (uschar *)malloc(line_len);
533   if (*data == NULL) {
534     (void)string_format(info, 1024,"unable to allocate %lu bytes",line_len);
535     return -2;
536   };
537
538   work = (uschar *)malloc(line_len);
539   if (work == NULL) {
540     (void)string_format(info, 1024,"unable to allocate %lu bytes",line_len);
541     return -2;
542   };
543
544   memcpy(work,line,line_len);
545
546   /* First char is line length
547   This is microsofts way of getting it. Scary. */
548   if (work[0] < 32) {
549     /* ignore this line */
550     return 0;
551   }
552   else {
553     uu_decoded_line_len = uudec[work[0]];
554   };
555
556   p = &work[1];
557
558   while (*p > 32) {
559     *p = uudec[*p];
560     p++;
561   };
562
563   uu_encoded_line_len = (p - &work[1]);
564   p = &work[1];
565
566   /* check that resulting line length is a multiple of 4 */
567   if ( ( uu_encoded_line_len % 4 ) != 0) {
568     if (!warned_about_uudec_line_sanity_1) {
569       mime_trigger_error(MIME_ERRORLEVEL_UU_MISALIGNED);
570       warned_about_uudec_line_sanity_1 = 1;
571     };
572     return -1;
573   };
574
575   /* check that the line length matches */
576   if ( ( (((uu_encoded_line_len/4)*3)-2) > uu_decoded_line_len ) || (((uu_encoded_line_len/4)*3) < uu_decoded_line_len) ) {
577     if (!warned_about_uudec_line_sanity_2) {
578       mime_trigger_error(MIME_ERRORLEVEL_UU_LINE_LENGTH);
579       warned_about_uudec_line_sanity_2 = 1;
580     };
581     return -1;
582   };
583
584   while ( ((p - &work[1]) < uu_encoded_line_len) && (num_decoded < uu_decoded_line_len)) {
585
586     /* byte 0 ---------------------- */
587     if ((p - &work[1] + 1) >= uu_encoded_line_len) {
588       return 0;
589     }
590
591     (*data)[num_decoded] = *p;
592     (*data)[num_decoded] <<= 2;
593
594     tmp_c = *(p+1);
595     tmp_c >>= 4;
596     (*data)[num_decoded] |= tmp_c;
597
598     num_decoded++;
599     p++;
600
601     /* byte 1 ---------------------- */
602     if ((p - &work[1] + 1) >= uu_encoded_line_len) {
603       return 0;
604     }
605
606     (*data)[num_decoded] = *p;
607     (*data)[num_decoded] <<= 4;
608
609     tmp_c = *(p+1);
610     tmp_c >>= 2;
611     (*data)[num_decoded] |= tmp_c;
612
613     num_decoded++;
614     p++;
615
616     /* byte 2 ---------------------- */
617     if ((p - &work[1] + 1) >= uu_encoded_line_len) {
618       return 0;
619     }
620
621     (*data)[num_decoded] = *p;
622     (*data)[num_decoded] <<= 6;
623
624     (*data)[num_decoded] |= *(p+1);
625
626     num_decoded++;
627     p+=2;
628
629   };
630
631   return uu_decoded_line_len;
632 }
633
634
635 /*************************************************
636 * Decode a b64 or qp line                        *
637 *************************************************/
638
639 /* returns number of decoded bytes
640          -1 for hard errors
641          -2 for soft errors
642 */
643
644 int warned_about_b64_line_length = 0;
645 int warned_about_b64_line_sanity = 0;
646 int warned_about_b64_illegal_char = 0;
647 int warned_about_qp_line_sanity = 0;
648 long mime_decode_line(int mime_demux_mode,uschar *line, uschar **data, long max_data_len, uschar *info) {
649   uschar *p;
650   long num_decoded = 0;
651   int offset = 0;
652   uschar tmp_c;
653
654   /* allocate memory for data */
655   *data = (uschar *)malloc(max_data_len);
656   if (*data == NULL) {
657     (void)string_format(info, 1024,"unable to allocate %lu bytes",max_data_len);
658     return -2;
659   };
660
661   if (mime_demux_mode == MIME_DEMUX_MODE_BASE64) {
662     /* ---------------------------------------------- */
663
664     /* NULL out trailing '\r' and '\n' chars */
665     while (Ustrrchr(line,'\r') != NULL) {
666       *(Ustrrchr(line,'\r')) = '\0';
667     };
668     while (Ustrrchr(line,'\n') != NULL) {
669       *(Ustrrchr(line,'\n')) = '\0';
670     };
671
672     /* check maximum base 64 line length */
673     if (Ustrlen(line) > MIME_SANITY_MAX_B64_LINE_LENGTH ) {
674       if (!warned_about_b64_line_length) {
675         mime_trigger_error(MIME_ERRORLEVEL_B64_LINE_LENGTH);
676         warned_about_b64_line_length = 1;
677       };
678     };
679
680     p = line;
681     offset = 0;
682     while (*(p+offset) != '\0') {
683       /* hit illegal char ? */
684       if (b64[*(p+offset)] == 128) {
685         if (!warned_about_b64_illegal_char) {
686           mime_trigger_error(MIME_ERRORLEVEL_B64_ILLEGAL_CHAR);
687           warned_about_b64_illegal_char = 1;
688         };
689         offset++;
690       }
691       else {
692         *p = b64[*(p+offset)];
693         p++;
694       };
695     };
696     *p = 255;
697
698     /* check that resulting line length is a multiple of 4 */
699     if ( ( (p - &line[0]) % 4 ) != 0) {
700       if (!warned_about_b64_line_sanity) {
701         mime_trigger_error(MIME_ERRORLEVEL_B64_MISALIGNED);
702         warned_about_b64_line_sanity = 1;
703       };
704     };
705
706     /* line is translated, start bit shifting */
707     p = line;
708     num_decoded = 0;
709
710     while(*p != 255) {
711
712       /* byte 0 ---------------------- */
713       if (*(p+1) == 255) {
714         break;
715       }
716
717       (*data)[num_decoded] = *p;
718       (*data)[num_decoded] <<= 2;
719
720       tmp_c = *(p+1);
721       tmp_c >>= 4;
722       (*data)[num_decoded] |= tmp_c;
723
724       num_decoded++;
725       p++;
726
727       /* byte 1 ---------------------- */
728       if (*(p+1) == 255) {
729         break;
730       }
731
732       (*data)[num_decoded] = *p;
733       (*data)[num_decoded] <<= 4;
734
735       tmp_c = *(p+1);
736       tmp_c >>= 2;
737       (*data)[num_decoded] |= tmp_c;
738
739       num_decoded++;
740       p++;
741
742       /* byte 2 ---------------------- */
743       if (*(p+1) == 255) {
744         break;
745       }
746
747       (*data)[num_decoded] = *p;
748       (*data)[num_decoded] <<= 6;
749
750       (*data)[num_decoded] |= *(p+1);
751
752       num_decoded++;
753       p+=2;
754
755     };
756     return num_decoded;
757     /* ---------------------------------------------- */
758   }
759   else if (mime_demux_mode == MIME_DEMUX_MODE_QP) {
760     /* ---------------------------------------------- */
761     p = line;
762
763     while (*p != 0) {
764       if (*p == '=') {
765         int decode_qp_result;
766
767         p = mime_decode_qp(p,&decode_qp_result);
768
769         if (decode_qp_result == -2) {
770           /* Error from decoder. p is unchanged. */
771           if (!warned_about_qp_line_sanity) {
772             mime_trigger_error(MIME_ERRORLEVEL_QP_ILLEGAL_CHAR);
773             warned_about_qp_line_sanity = 1;
774           };
775           (*data)[num_decoded] = '=';
776           num_decoded++;
777           p++;
778         }
779         else if (decode_qp_result == -1) {
780           /* End of the line with soft line break.
781           Bail out. */
782           goto QP_RETURN;
783         }
784         else if (decode_qp_result >= 0) {
785           (*data)[num_decoded] = decode_qp_result;
786           num_decoded++;
787         };
788       }
789       else {
790         (*data)[num_decoded] = *p;
791         num_decoded++;
792         p++;
793       };
794     };
795     QP_RETURN:
796     return num_decoded;
797     /* ---------------------------------------------- */
798   };
799
800   return 0;
801 }
802
803
804
805 /*************************************************
806 * Log demime errors and set mime error level     *
807 *************************************************/
808
809 /* This sets the global demime_reason expansion
810 variable and the demime_errorlevel gauge. */
811
812 void mime_trigger_error(int level, uschar *format, ...) {
813   char *f;
814   va_list ap;
815
816   if( (f = malloc(16384+23)) != NULL ) {
817     /* first log the incident */
818     sprintf(f,"demime acl condition: ");
819     f+=22;
820     va_start(ap, format);
821     (void)string_vformat(US f, 16383,(char *)format, ap);
822     va_end(ap);
823     f-=22;
824     log_write(0, LOG_MAIN, "%s", f);
825     /* then copy to demime_reason_buffer if new
826     level is greater than old level */
827     if (level > demime_errorlevel) {
828       demime_errorlevel = level;
829       Ustrcpy(demime_reason_buffer, US f);
830       demime_reason = demime_reason_buffer;
831     };
832     free(f);
833   };
834 }
835
836 /*************************************************
837 * Demultiplex MIME stream.                       *
838 *************************************************/
839
840 /* We can handle BASE64, QUOTED-PRINTABLE, and UUENCODE.
841  UUENCODE does not need to have a proper
842  transfer-encoding header, we detect it with "begin"
843
844  This function will report human parsable errors in
845  *info.
846
847  returns DEFER -> soft error (see *info)
848          OK    -> EOF hit, all ok
849 */
850
851 int mime_demux(FILE *f, uschar *info) {
852   int mime_demux_mode = MIME_DEMUX_MODE_MIME_HEADERS;
853   int uu_mode = MIME_UU_MODE_OFF;
854   FILE *mime_dump_file = NULL;
855   FILE *uu_dump_file = NULL;
856   uschar *line;
857   int mime_read_line_status = MIME_READ_LINE_OK;
858   long line_len;
859   struct boundary *boundaries = NULL;
860   struct mime_part mime_part_p;
861   int has_tnef = 0;
862   int has_rfc822 = 0;
863
864   /* allocate room for our linebuffer */
865   line = (uschar *)malloc(MIME_SANITY_MAX_LINE_LENGTH);
866   if (line == NULL) {
867     (void)string_format(info, 1024,"unable to allocate %u bytes",MIME_SANITY_MAX_LINE_LENGTH);
868     return DEFER;
869   };
870
871   /* clear MIME header structure */
872   memset(&mime_part_p,0,sizeof(mime_part));
873
874   /* ----------------------- start demux loop --------------------- */
875   while (mime_read_line_status == MIME_READ_LINE_OK) {
876
877     /* read a line of input. Depending on the mode we are in,
878     the returned format will differ. */
879     mime_read_line_status = mime_read_line(f,mime_demux_mode,line,&line_len);
880
881     if (mime_read_line_status == MIME_READ_LINE_OVERFLOW) {
882       mime_trigger_error(MIME_ERRORLEVEL_LONG_LINE);
883       /* despite the error, continue  .. */
884       mime_read_line_status = MIME_READ_LINE_OK;
885       continue;
886     }
887     else if (mime_read_line_status == MIME_READ_LINE_EOF) {
888       break;
889     };
890
891     if (mime_demux_mode == MIME_DEMUX_MODE_MIME_HEADERS) {
892       /* -------------- header mode --------------------- */
893
894       /* Check for an empty line, which is the end of the headers.
895        In HEADER mode, the line is returned "cooked", with the
896        final '\n' replaced by a ';' */
897       if (line_len == 1) {
898         int tmp;
899
900         /* We have reached the end of the headers. Start decoding
901         with the collected settings. */
902         if (mime_part_p.seen_content_transfer_encoding > 1) {
903           mime_demux_mode = mime_part_p.seen_content_transfer_encoding;
904         }
905         else {
906           /* default to plain mode if no specific encoding type found */
907           mime_demux_mode = MIME_DEMUX_MODE_PLAIN;
908         };
909
910         /* open new dump file */
911         tmp = mime_get_dump_file(mime_part_p.extension, &mime_dump_file, info);
912         if (tmp < 0) {
913           return DEFER;
914         };
915
916         /* clear out mime_part */
917         memset(&mime_part_p,0,sizeof(mime_part));
918       }
919       else {
920         /* Another header to check for file extensions,
921         encoding type and boundaries */
922         if (strncmpic(US"content-type:",line,Ustrlen("content-type:")) == 0) {
923           /* ---------------------------- Content-Type header ------------------------------- */
924           uschar *value = line;
925
926           /* check for message/partial MIME type and reject it */
927           if (mime_header_find(line,US"message/partial",NULL) > 0)
928             mime_trigger_error(MIME_ERRORLEVEL_MESSAGE_PARTIAL);
929
930           /* check for TNEF content type, remember to unpack TNEF later. */
931           if (mime_header_find(line,US"application/ms-tnef",NULL) > 0)
932             has_tnef = 1;
933
934           /* check for message/rfcxxx attachments */
935           if (mime_header_find(line,US"message/rfc822",NULL) > 0)
936             has_rfc822 = 1;
937
938           /* find the file extension, but do not fill it in
939           it is already set, since content-disposition has
940           precedence. */
941           if (mime_part_p.extension == NULL) {
942             if (mime_header_find(line,US"name",&value) == 2) {
943               if (Ustrlen(value) > MIME_SANITY_MAX_FILENAME)
944                 mime_trigger_error(MIME_ERRORLEVEL_FILENAME_LENGTH);
945               mime_part_p.extension = value;
946               mime_part_p.extension = Ustrrchr(value,'.');
947               if (mime_part_p.extension == NULL) {
948                 /* file without extension, setting
949                 NULL will use the default extension later */
950                 mime_part_p.extension = NULL;
951               }
952               else {
953                 struct file_extension *this_extension =
954                   (struct file_extension *)malloc(sizeof(file_extension));
955
956                 this_extension->file_extension_string =
957                   (uschar *)malloc(Ustrlen(mime_part_p.extension)+1);
958                 Ustrcpy(this_extension->file_extension_string,
959                         mime_part_p.extension+1);
960                 this_extension->next = file_extensions;
961                 file_extensions = this_extension;
962               };
963             };
964           };
965
966           /* find a boundary and add it to the list, if present */
967           value = line;
968           if (mime_header_find(line,US"boundary",&value) == 2) {
969             struct boundary *thisboundary;
970
971             if (Ustrlen(value) > MIME_SANITY_MAX_BOUNDARY_LENGTH) {
972               mime_trigger_error(MIME_ERRORLEVEL_BOUNDARY_LENGTH);
973             }
974             else {
975               thisboundary = (struct boundary*)malloc(sizeof(boundary));
976               thisboundary->next = boundaries;
977               thisboundary->boundary_string = value;
978               boundaries = thisboundary;
979             };
980           };
981
982           if (mime_part_p.seen_content_type == 0) {
983             mime_part_p.seen_content_type = 1;
984           }
985           else {
986             mime_trigger_error(MIME_ERRORLEVEL_DOUBLE_HEADERS);
987           };
988           /* ---------------------------------------------------------------------------- */
989         }
990         else if (strncmpic(US"content-transfer-encoding:",line,Ustrlen("content-transfer-encoding:")) == 0) {
991           /* ---------------------------- Content-Transfer-Encoding header -------------- */
992
993          if (mime_part_p.seen_content_transfer_encoding == 0) {
994             if (mime_header_find(line,US"base64",NULL) > 0) {
995               mime_part_p.seen_content_transfer_encoding = MIME_DEMUX_MODE_BASE64;
996             }
997             else if (mime_header_find(line,US"quoted-printable",NULL) > 0) {
998               mime_part_p.seen_content_transfer_encoding = MIME_DEMUX_MODE_QP;
999             }
1000             else {
1001               mime_part_p.seen_content_transfer_encoding = MIME_DEMUX_MODE_PLAIN;
1002             };
1003           }
1004           else {
1005             mime_trigger_error(MIME_ERRORLEVEL_DOUBLE_HEADERS);
1006           };
1007           /* ---------------------------------------------------------------------------- */
1008         }
1009         else if (strncmpic(US"content-disposition:",line,Ustrlen("content-disposition:")) == 0) {
1010           /* ---------------------------- Content-Disposition header -------------------- */
1011           uschar *value = line;
1012
1013           if (mime_part_p.seen_content_disposition == 0) {
1014             mime_part_p.seen_content_disposition = 1;
1015
1016             if (mime_header_find(line,US"filename",&value) == 2) {
1017               if (Ustrlen(value) > MIME_SANITY_MAX_FILENAME)
1018                 mime_trigger_error(MIME_ERRORLEVEL_FILENAME_LENGTH);
1019               mime_part_p.extension = value;
1020               mime_part_p.extension = Ustrrchr(value,'.');
1021               if (mime_part_p.extension == NULL) {
1022                 /* file without extension, setting
1023                 NULL will use the default extension later */
1024                 mime_part_p.extension = NULL;
1025               }
1026               else {
1027                 struct file_extension *this_extension =
1028                   (struct file_extension *)malloc(sizeof(file_extension));
1029
1030                 this_extension->file_extension_string =
1031                   (uschar *)malloc(Ustrlen(mime_part_p.extension)+1);
1032                 Ustrcpy(this_extension->file_extension_string,
1033                         mime_part_p.extension+1);
1034                 this_extension->next = file_extensions;
1035                 file_extensions = this_extension;
1036               };
1037             };
1038           }
1039           else {
1040             mime_trigger_error(MIME_ERRORLEVEL_DOUBLE_HEADERS);
1041           };
1042           /* ---------------------------------------------------------------------------- */
1043         };
1044       };    /* End of header checks */
1045       /* ------------------------------------------------ */
1046     }
1047     else {
1048       /* -------------- non-header mode ----------------- */
1049       int tmp;
1050
1051       if (uu_mode == MIME_UU_MODE_OFF) {
1052         uschar uu_file_extension[5];
1053         /* We are not currently decoding UUENCODE
1054         Check for possible UUENCODE start tag. */
1055         if (mime_check_uu_start(line,uu_file_extension,&has_tnef)) {
1056           /* possible UUENCODING start detected.
1057           Set unconfirmed mode first. */
1058           uu_mode = MIME_UU_MODE_UNCONFIRMED;
1059           /* open new uu dump file */
1060           tmp = mime_get_dump_file(uu_file_extension, &uu_dump_file, info);
1061           if (tmp < 0) {
1062             free(line);
1063             return DEFER;
1064           };
1065         };
1066       }
1067       else {
1068         uschar *data;
1069         long data_len = 0;
1070
1071         if (uu_mode == MIME_UU_MODE_UNCONFIRMED) {
1072          /* We are in unconfirmed UUENCODE mode. */
1073
1074          data_len = uu_decode_line(line,&data,line_len,info);
1075
1076          if (data_len == -2) {
1077            /* temp error, turn off uudecode mode */
1078            if (uu_dump_file != NULL) {
1079             (void)fclose(uu_dump_file); uu_dump_file = NULL;
1080            };
1081            uu_mode = MIME_UU_MODE_OFF;
1082            return DEFER;
1083          }
1084          else if (data_len == -1) {
1085            if (uu_dump_file != NULL) {
1086             (void)fclose(uu_dump_file); uu_dump_file = NULL;
1087            };
1088            uu_mode = MIME_UU_MODE_OFF;
1089            data_len = 0;
1090          }
1091          else if (data_len > 0) {
1092            /* we have at least decoded a valid byte
1093            turn on confirmed mode */
1094            uu_mode = MIME_UU_MODE_CONFIRMED;
1095          };
1096         }
1097         else if (uu_mode == MIME_UU_MODE_CONFIRMED) {
1098           /* If we are in confirmed UU mode,
1099           check for single "end" tag on line */
1100           if ((strncmpic(line,US"end",3) == 0) && (line[3] < 32)) {
1101             if (uu_dump_file != NULL) {
1102               (void)fclose(uu_dump_file); uu_dump_file = NULL;
1103             };
1104             uu_mode = MIME_UU_MODE_OFF;
1105           }
1106           else {
1107             data_len = uu_decode_line(line,&data,line_len,info);
1108             if (data_len == -2) {
1109                /* temp error, turn off uudecode mode */
1110                if (uu_dump_file != NULL) {
1111                  (void)fclose(uu_dump_file); uu_dump_file = NULL;
1112                };
1113                uu_mode = MIME_UU_MODE_OFF;
1114                return DEFER;
1115              }
1116              else if (data_len == -1) {
1117                /* skip this line */
1118                data_len = 0;
1119              };
1120           };
1121         };
1122
1123         /* write data to dump file, if available */
1124         if (data_len > 0) {
1125           if (fwrite(data,1,data_len,uu_dump_file) < data_len) {
1126             /* short write */
1127             (void)string_format(info, 1024,"short write on uudecode dump file");
1128             free(line);
1129             return DEFER;
1130           };
1131         };
1132       };
1133
1134       if (mime_demux_mode != MIME_DEMUX_MODE_SCANNING) {
1135         /* Non-scanning and Non-header mode. That means
1136         we are currently decoding data to the dump
1137         file. */
1138
1139         /* Check for a known boundary. */
1140         tmp = mime_check_boundary(line,boundaries);
1141         if (tmp == 1) {
1142           /* We have hit a known start boundary.
1143           That will put us back in header mode. */
1144           mime_demux_mode = MIME_DEMUX_MODE_MIME_HEADERS;
1145           if (mime_dump_file != NULL) {
1146             /* if the attachment was a RFC822 message, recurse into it */
1147             if (has_rfc822) {
1148               has_rfc822 = 0;
1149               rewind(mime_dump_file);
1150               mime_demux(mime_dump_file,info);
1151             };
1152
1153             (void)fclose(mime_dump_file); mime_dump_file = NULL;
1154           };
1155         }
1156         else if (tmp == 2) {
1157           /* We have hit a known end boundary.
1158           That puts us into scanning mode, which will end when we hit another known start boundary */
1159           mime_demux_mode = MIME_DEMUX_MODE_SCANNING;
1160           if (mime_dump_file != NULL) {
1161             /* if the attachment was a RFC822 message, recurse into it */
1162             if (has_rfc822) {
1163               has_rfc822 = 0;
1164               rewind(mime_dump_file);
1165               mime_demux(mime_dump_file,info);
1166             };
1167
1168             (void)fclose(mime_dump_file); mime_dump_file = NULL;
1169           };
1170         }
1171         else {
1172           uschar *data;
1173           long data_len = 0;
1174
1175           /* decode the line with the appropriate method */
1176           if (mime_demux_mode == MIME_DEMUX_MODE_PLAIN) {
1177             /* in plain mode, just dump the line */
1178             data = line;
1179             data_len = line_len;
1180           }
1181           else if ( (mime_demux_mode == MIME_DEMUX_MODE_QP) || (mime_demux_mode == MIME_DEMUX_MODE_BASE64) ) {
1182             data_len = mime_decode_line(mime_demux_mode,line,&data,line_len,info);
1183             if (data_len < 0) {
1184               /* Error reported from the line decoder. */
1185               data_len = 0;
1186             };
1187           };
1188
1189           /* write data to dump file */
1190           if (data_len > 0) {
1191             if (fwrite(data,1,data_len,mime_dump_file) < data_len) {
1192               /* short write */
1193               (void)string_format(info, 1024,"short write on dump file");
1194               free(line);
1195               return DEFER;
1196             };
1197           };
1198
1199         };
1200       }
1201       else {
1202         /* Scanning mode. We end up here after a end boundary.
1203         This will usually be at the end of a message or at
1204         the end of a MIME container.
1205         We need to look for another start boundary to get
1206         back into header mode. */
1207         if (mime_check_boundary(line,boundaries) == 1) {
1208           mime_demux_mode = MIME_DEMUX_MODE_MIME_HEADERS;
1209         };
1210
1211       };
1212       /* ------------------------------------------------ */
1213     };
1214   };
1215   /* ----------------------- end demux loop ----------------------- */
1216
1217   /* close files, they could still be open */
1218   if (mime_dump_file != NULL)
1219     (void)fclose(mime_dump_file);
1220   if (uu_dump_file != NULL)
1221     (void)fclose(uu_dump_file);
1222
1223   /* release line buffer */
1224   free(line);
1225
1226   /* FIXME: release boundary buffers.
1227   Not too much of a problem since
1228   this instance of exim is not resident. */
1229
1230   if (has_tnef) {
1231     uschar file_name[1024];
1232     /* at least one file could be TNEF encoded.
1233     attempt to send all decoded files thru the TNEF decoder */
1234
1235     (void)string_format(file_name,1024,"%s/scan/%s",spool_directory,message_id);
1236     /* Removed FTTB. We need to decide on TNEF inclusion */
1237     /* mime_unpack_tnef(file_name); */
1238   };
1239
1240   return 0;
1241 }
1242
1243 #endif