* Removed the built-in memory leak checker. It wasn't threadsafe and

[citadel.git] / citadel / mime_parser.c

diff --git a/citadel/mime_parser.c b/citadel/mime_parser.c
index ff206dbcd8c9c2371c0b3b690cae938f9e401be6..321a2df32a80120649e800241cd4a0a89bf4f2bd 100644 (file)
--- a/citadel/mime_parser.c
+++ b/citadel/mime_parser.c
@@ -203,7 +203,7 @@ void mime_decode(char *partnum,
         * will never be larger than the encoded data.  This is a safe
         * assumption with base64, uuencode, and quoted-printable.
         */
-       decoded = mallok(length+2048);
+       decoded = malloc(length+2048);
        if (decoded == NULL) {
                return;
        }
@@ -222,7 +222,7 @@ void mime_decode(char *partnum,
                        content_type, bytes_decoded, "binary", userdata);
        }
 
-       phree(decoded);
+       free(decoded);
 }
 
 /*
@@ -275,6 +275,7 @@ void the_mime_parser(char *partnum,
        char *boundary;
        char *startary;
        char *endary;
+       char *next_boundary;
        char *content_type;
        size_t content_length;
        char *encoding;
@@ -292,34 +293,34 @@ void the_mime_parser(char *partnum,
        ptr = content_start;
        content_length = 0;
 
-       boundary = mallok(SIZ);
+       boundary = malloc(SIZ);
        memset(boundary, 0, SIZ);
 
-       startary = mallok(SIZ);
+       startary = malloc(SIZ);
        memset(startary, 0, SIZ);
 
-       endary = mallok(SIZ);
+       endary = malloc(SIZ);
        memset(endary, 0, SIZ);
 
-       header = mallok(SIZ);
+       header = malloc(SIZ);
        memset(header, 0, SIZ);
 
-       content_type = mallok(SIZ);
+       content_type = malloc(SIZ);
        memset(content_type, 0, SIZ);
 
-       encoding = mallok(SIZ);
+       encoding = malloc(SIZ);
        memset(encoding, 0, SIZ);
 
-       content_type_name = mallok(SIZ);
+       content_type_name = malloc(SIZ);
        memset(content_type_name, 0, SIZ);
 
-       content_disposition_name = mallok(SIZ);
+       content_disposition_name = malloc(SIZ);
        memset(content_disposition_name, 0, SIZ);
 
-       filename = mallok(SIZ);
+       filename = malloc(SIZ);
        memset(filename, 0, SIZ);
 
-       disposition = mallok(SIZ);
+       disposition = malloc(SIZ);
        memset(disposition, 0, SIZ);
 
        /* If the caller didn't supply an endpointer, generate one by measure */
@@ -394,46 +395,53 @@ void the_mime_parser(char *partnum,
                /* Figure out where the boundaries are */
                snprintf(startary, SIZ, "--%s", boundary);
                snprintf(endary, SIZ, "--%s--", boundary);
+
+               part_start = NULL;
                do {
-                       if ( (!strncasecmp(ptr, startary, strlen(startary)))
-                          || (!strncasecmp(ptr, endary, strlen(endary))) ) {
-                               if (part_start != NULL) {
-                                       if (strlen(partnum) > 0) {
-                                               snprintf(nested_partnum,
-                                                        sizeof nested_partnum,
-                                                        "%s.%d", partnum,
-                                                        ++part_seq);
-                                       }
-                                       else {
-                                               snprintf(nested_partnum,
-                                                        sizeof nested_partnum,
-                                                        "%d", ++part_seq);
-                                       }
-                                       the_mime_parser(nested_partnum,
-                                                   part_start, part_end,
-                                                       CallBack,
-                                                       PreMultiPartCallBack,
-                                                       PostMultiPartCallBack,
-                                                       userdata,
-                                                       dont_decode);
+                       next_boundary = bmstrstr(ptr, startary, strncmp);
+                       if ( (part_start != NULL) && (next_boundary != NULL) ) {
+                               part_end = next_boundary;
+                               --part_end;
+
+                               if (strlen(partnum) > 0) {
+                                       snprintf(nested_partnum,
+                                                sizeof nested_partnum,
+                                                "%s.%d", partnum,
+                                                ++part_seq);
                                }
-                               ptr = memreadline(ptr, buf, SIZ);
-                               part_start = ptr;
-                       }
-                       else {
-                               part_end = ptr;
-                               ++ptr;
+                               else {
+                                       snprintf(nested_partnum,
+                                                sizeof nested_partnum,
+                                                "%d", ++part_seq);
+                               }
+                               the_mime_parser(nested_partnum,
+                                           part_start, part_end,
+                                               CallBack,
+                                               PreMultiPartCallBack,
+                                               PostMultiPartCallBack,
+                                               userdata,
+                                               dont_decode);
                        }
-                       /* If we pass out of scope in the MIME multipart (by
-                        * hitting the end boundary), force the pointer out
-                        * of scope so this loop ends.
-                        */
-                       if (ptr < content_end) {
-                               if (!strcasecmp(ptr, endary)) {
-                                       ptr = content_end++;
+
+                       if (next_boundary != NULL) {
+                               /* If we pass out of scope, don't attempt to read
+                                * past the end boundary. */
+                               if (!strcmp(next_boundary, endary)) {
+                                       ptr = content_end;
                                }
+                               else {
+                                       /* Set up for the next part. */
+                                       part_start = strstr(next_boundary, "\n");
+                                       ++part_start;
+                                       ptr = part_start;
+                               }
+                       }
+                       else {
+                               /* Invalid end of multipart.  Bail out! */
+                               ptr = content_end;
                        }
-               } while (ptr <= content_end);
+               } while ( (ptr < content_end) && (next_boundary != NULL) );
+
                if (PostMultiPartCallBack != NULL) {
                        PostMultiPartCallBack("", "", partnum, "", NULL,
                                content_type, 0, encoding, userdata);
@@ -479,16 +487,16 @@ void the_mime_parser(char *partnum,
        }
 
 end_parser:    /* free the buffers!  end the oppression!! */
-       phree(boundary);
-       phree(startary);
-       phree(endary);  
-       phree(header);
-       phree(content_type);
-       phree(encoding);
-       phree(content_type_name);
-       phree(content_disposition_name);
-       phree(filename);
-       phree(disposition);
+       free(boundary);
+       free(startary);
+       free(endary);   
+       free(header);
+       free(content_type);
+       free(encoding);
+       free(content_type_name);
+       free(content_disposition_name);
+       free(filename);
+       free(disposition);
 }