*
* This is the MIME parser for Citadel. Sometimes it actually works.
*
- * Copyright (c) 1998-2001 by Art Cancro
+ * Copyright (c) 1998-2002 by Art Cancro
* This code is distributed under the terms of the GNU General Public License.
*
*/
#include <string.h>
#include <sys/stat.h>
#include <errno.h>
+
#include "citadel.h"
#include "server.h"
-#include "dynloader.h"
+#include "serv_extensions.h"
#include "sysdep_decls.h"
-#include "mime_parser.h"
#include "tools.h"
+#include "mime_parser.h"
+
void extract_key(char *target, char *source, char *key)
{
}
+
+/*
+ * Convert "quoted-printable" to binary. Returns number of bytes decoded.
+ */
+int CtdlDecodeQuotedPrintable(char *decoded, char *encoded, int sourcelen) {
+ char buf[SIZ];
+ int buf_length = 0;
+ int soft_line_break = 0;
+ int ch;
+ int decoded_length = 0;
+ int i;
+
+ decoded[0] = 0;
+ decoded_length = 0;
+ buf[0] = 0;
+ buf_length = 0;
+
+ for (i = 0; i < sourcelen; ++i) {
+
+ buf[buf_length++] = encoded[i];
+
+ if ( (encoded[i] == '\n')
+ || (encoded[i] == 0)
+ || (i == (sourcelen-1)) ) {
+ buf[buf_length++] = 0;
+
+ /*** begin -- process one line ***/
+
+ if (buf[strlen(buf)-1] == '\n') {
+ buf[strlen(buf)-1] = 0;
+ }
+ if (buf[strlen(buf)-1] == '\r') {
+ buf[strlen(buf)-1] = 0;
+ }
+ while (isspace(buf[strlen(buf)-1])) {
+ buf[strlen(buf)-1] = 0;
+ }
+ soft_line_break = 0;
+
+ while (strlen(buf) > 0) {
+ if (!strcmp(buf, "=")) {
+ soft_line_break = 1;
+ strcpy(buf, "");
+ } else if ((strlen(buf)>=3) && (buf[0]=='=')) {
+ sscanf(&buf[1], "%02x", &ch);
+ decoded[decoded_length++] = ch;
+ strcpy(buf, &buf[3]);
+ } else {
+ decoded[decoded_length++] = buf[0];
+ strcpy(buf, &buf[1]);
+ }
+ }
+ if (soft_line_break == 0) {
+ decoded[decoded_length++] = '\r';
+ decoded[decoded_length++] = '\n';
+ }
+ buf_length = 0;
+ /*** end -- process one line ***/
+ }
+ }
+
+ decoded[decoded_length++] = 0;
+ return(decoded_length);
+}
+
/*
* Given a message or message-part body and a length, handle any necessary
* decoding and pass the request up the stack.
{
char *decoded;
- struct stat statbuf;
- int sendpipe[2];
- int recvpipe[2];
- int childpid;
- size_t bytes_sent = 0;
- size_t bytes_recv = 0;
- size_t blocksize;
- int write_error = 0;
-
- lprintf(9, "mime_decode() called\n");
+ size_t bytes_decoded = 0;
/* Some encodings aren't really encodings */
if (!strcasecmp(encoding, "7bit"))
}
return;
}
+
if ((strcasecmp(encoding, "base64"))
&& (strcasecmp(encoding, "quoted-printable"))) {
- lprintf(9, "ERROR: unknown MIME encoding '%s'\n", encoding);
return;
}
/*
* Allocate a buffer for the decoded data. The output buffer is the
* same size as the input buffer; this assumes that the decoded data
* will never be larger than the encoded data. This is a safe
- * assumption with base64, uuencode, and quoted-printable. Just to
- * be safe, we still pad the buffer a bit.
+ * assumption with base64, uuencode, and quoted-printable.
*/
- decoded = malloc(length + 1024);
+ decoded = mallok(length+2048);
if (decoded == NULL) {
- lprintf(9, "ERROR: cannot allocate memory.\n");
return;
}
- if (pipe(sendpipe) != 0)
- return;
- if (pipe(recvpipe) != 0)
- return;
- childpid = fork();
- if (childpid < 0) {
- free(decoded);
- return;
+ if (!strcasecmp(encoding, "base64")) {
+ bytes_decoded = CtdlDecodeBase64(decoded, part_start, length);
}
- if (childpid == 0) {
- close(2);
- /* send stdio to the pipes */
- if (dup2(sendpipe[0], 0) < 0)
- lprintf(9, "ERROR dup2()\n");
- if (dup2(recvpipe[1], 1) < 0)
- lprintf(9, "ERROR dup2()\n");
- close(sendpipe[1]); /* Close the ends we're not using */
- close(recvpipe[0]);
- if (!strcasecmp(encoding, "base64"))
- execlp("./base64", "base64", "-d", NULL);
- else if (!strcasecmp(encoding, "quoted-printable"))
- execlp("./qpdecode", "qpdecode", NULL);
- lprintf(9, "ERROR: cannot exec decoder for %s\n", encoding);
- exit(1);
- }
- close(sendpipe[0]); /* Close the ends we're not using */
- close(recvpipe[1]);
-
- while ((bytes_sent < length) && (write_error == 0)) {
- /* Empty the input pipe FIRST */
- while (fstat(recvpipe[0], &statbuf), (statbuf.st_size > 0)) {
- blocksize = read(recvpipe[0], &decoded[bytes_recv],
- statbuf.st_size);
- if (blocksize < 0)
- lprintf(9, "ERROR: cannot read from pipe\n");
- else
- bytes_recv = bytes_recv + blocksize;
- }
- /* Then put some data into the output pipe */
- blocksize = length - bytes_sent;
- if (blocksize > 2048)
- blocksize = 2048;
- if (write(sendpipe[1], &part_start[bytes_sent], blocksize) < 0) {
- lprintf(9, "ERROR: cannot write to pipe: %s\n",
- strerror(errno));
- write_error = 1;
- }
- bytes_sent = bytes_sent + blocksize;
- }
- close(sendpipe[1]);
- /* Empty the input pipe */
- while ((blocksize = read(recvpipe[0], &decoded[bytes_recv], 1)),
- (blocksize > 0)) {
- bytes_recv = bytes_recv + blocksize;
+ else if (!strcasecmp(encoding, "quoted-printable")) {
+ bytes_decoded = CtdlDecodeQuotedPrintable(decoded,
+ part_start, length);
}
- if (bytes_recv > 0) if (CallBack != NULL) {
+ if (bytes_decoded > 0) if (CallBack != NULL) {
CallBack(name, filename, fixed_partnum(partnum),
disposition, decoded,
- content_type, bytes_recv, "binary", userdata);
+ content_type, bytes_decoded, "binary", userdata);
}
- free(decoded);
+ phree(decoded);
}
/*
char *ptr;
char *part_start, *part_end = NULL;
char buf[SIZ];
- char header[SIZ];
- char boundary[SIZ];
- char startary[SIZ];
- char endary[SIZ];
- char content_type[SIZ];
+ char *header;
+ char *boundary;
+ char *startary;
+ char *endary;
+ char *content_type;
size_t content_length;
- char encoding[SIZ];
- char disposition[SIZ];
- char name[SIZ];
- char filename[SIZ];
+ char *encoding;
+ char *disposition;
+ char *name;
+ char *filename;
int is_multipart;
int part_seq = 0;
int i;
size_t length;
char nested_partnum[SIZ];
- lprintf(9, "the_mime_parser() called\n");
ptr = content_start;
- memset(boundary, 0, sizeof boundary);
- memset(content_type, 0, sizeof content_type);
- memset(encoding, 0, sizeof encoding);
- memset(name, 0, sizeof name);
- memset(filename, 0, sizeof filename);
- memset(disposition, 0, sizeof disposition);
content_length = 0;
+ boundary = mallok(SIZ);
+ memset(boundary, 0, SIZ);
+
+ startary = mallok(SIZ);
+ memset(startary, 0, SIZ);
+
+ endary = mallok(SIZ);
+ memset(endary, 0, SIZ);
+
+ header = mallok(SIZ);
+ memset(header, 0, SIZ);
+
+ content_type = mallok(SIZ);
+ memset(content_type, 0, SIZ);
+
+ encoding = mallok(SIZ);
+ memset(encoding, 0, SIZ);
+
+ name = mallok(SIZ);
+ memset(name, 0, SIZ);
+
+ filename = mallok(SIZ);
+ memset(filename, 0, SIZ);
+
+ disposition = mallok(SIZ);
+ memset(disposition, 0, SIZ);
+
/* If the caller didn't supply an endpointer, generate one by measure */
if (content_end == NULL) {
content_end = &content_start[strlen(content_start)];
/* Learn interesting things from the headers */
strcpy(header, "");
do {
- ptr = memreadline(ptr, buf, sizeof buf);
- if (ptr >= content_end)
- return;
+ ptr = memreadline(ptr, buf, SIZ);
+ if (ptr >= content_end) {
+ goto end_parser;
+ }
for (i = 0; i < strlen(buf); ++i)
if (isspace(buf[i]))
if (!strncasecmp(header, "Content-type: ", 14)) {
strcpy(content_type, &header[14]);
extract_key(name, content_type, "name");
- lprintf(9, "Extracted content-type <%s>\n",
- content_type);
+ /* Deal with weird headers */
+ if (strchr(content_type, ' '))
+ *(strchr(content_type, ' ')) = '\0';
+ if (strchr(content_type, ';'))
+ *(strchr(content_type, ';')) = '\0';
}
if (!strncasecmp(header, "Content-Disposition: ", 21)) {
strcpy(disposition, &header[21]);
extract_key(boundary, header, "boundary");
strcpy(header, "");
}
- if ((strlen(header) + strlen(buf) + 2) < sizeof(header))
+ if ((strlen(header) + strlen(buf) + 2) < SIZ)
strcat(header, buf);
} while ((strlen(buf) > 0) && (*ptr != 0));
- for (i = 0; i < strlen(disposition); ++i)
- if (disposition[i] == ';')
- disposition[i] = 0;
- while (isspace(disposition[0]))
- strcpy(disposition, &disposition[1]);
- for (i = 0; i < strlen(content_type); ++i)
- if (content_type[i] == ';')
- content_type[i] = 0;
- while (isspace(content_type[0]))
- strcpy(content_type, &content_type[1]);
+ if (strchr(disposition, ';'))
+ *(strchr(disposition, ';')) = '\0';
+ striplt(disposition);
+ if (strchr(content_type, ';'))
+ *(strchr(content_type, ';')) = '\0';
+ striplt(content_type);
if (strlen(boundary) > 0) {
is_multipart = 1;
is_multipart = 0;
}
- lprintf(9, "is_multipart=%d, boundary=<%s>\n",
- is_multipart, boundary);
-
/* If this is a multipart message, then recursively process it */
part_start = NULL;
if (is_multipart) {
}
/* Figure out where the boundaries are */
- sprintf(startary, "--%s", boundary);
- sprintf(endary, "--%s--", boundary);
+ snprintf(startary, SIZ, "--%s", boundary);
+ snprintf(endary, SIZ, "--%s--", boundary);
do {
if ( (!strncasecmp(ptr, startary, strlen(startary)))
|| (!strncasecmp(ptr, endary, strlen(endary))) ) {
- lprintf(9, "hit boundary!\n");
if (part_start != NULL) {
if (strlen(partnum) > 0) {
- sprintf(nested_partnum, "%s.%d",
- partnum, ++part_seq);
+ snprintf(nested_partnum,
+ sizeof nested_partnum,
+ "%s.%d", partnum,
+ ++part_seq);
}
else {
- sprintf(nested_partnum, "%d",
- ++part_seq);
+ snprintf(nested_partnum,
+ sizeof nested_partnum,
+ "%d", ++part_seq);
}
the_mime_parser(nested_partnum,
part_start, part_end,
userdata,
dont_decode);
}
- ptr = memreadline(ptr, buf, sizeof(buf));
+ ptr = memreadline(ptr, buf, SIZ);
part_start = ptr;
}
else {
part_end = ptr;
++ptr;
}
- } while ( (strcasecmp(ptr, endary)) && (ptr <= content_end) );
+ /* 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++;
+ }
+ }
+ } while (ptr <= content_end);
if (PostMultiPartCallBack != NULL) {
PostMultiPartCallBack("", "", partnum, "", NULL,
content_type, 0, encoding, userdata);
}
- return;
+ goto end_parser;
}
/* If it's not a multipart message, then do something with it */
if (!is_multipart) {
- lprintf(9, "doing non-multipart thing\n");
part_start = ptr;
length = 0;
while (ptr < content_end) {
/* Truncate if the header told us to */
if ( (content_length > 0) && (length > content_length) ) {
length = content_length;
- lprintf(9, "truncated to %ld\n", content_length);
}
mime_decode(partnum,
CallBack, NULL, NULL,
userdata, dont_decode);
}
+
+end_parser: /* free the buffers! end the oppression!! */
+ phree(boundary);
+ phree(startary);
+ phree(endary);
+ phree(header);
+ phree(content_type);
+ phree(encoding);
+ phree(name);
+ phree(filename);
+ phree(disposition);
}
)
{
- lprintf(9, "mime_parser() called\n");
the_mime_parser("", content_start, content_end,
CallBack,
PreMultiPartCallBack,