/*
* $Id$
*
- * This is a really bad attempt at writing a parser to handle MIME-encoded
- * messages.
+ * This is the MIME parser for Citadel.
*
- * Copyright (c) 1998-1999 by Art Cancro
- * This code is distributed under the terms of the GNU General Public License.
+ * Copyright (c) 1998-2006 by Art Cancro
+ * This code is distributed under the GNU General Public License v2.
*
*/
-#include "sysdep.h"
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <errno.h>
+
#include "citadel.h"
-#include "mime_parser.h"
-#include "sysdep_decls.h"
#include "server.h"
+#include "sysdep_decls.h"
+#include "tools.h"
+#include "mime_parser.h"
void extract_key(char *target, char *source, char *key)
}
-
-/*
- * Utility function to "readline" from memory
- * (returns new pointer)
+/*
+ * For non-multipart messages, we need to generate a quickie partnum of "1"
+ * to return to callback functions. Some callbacks demand it.
*/
-char *memreadline(char *start, char *buf, int maxlen)
-{
- char ch;
- char *ptr;
+char *fixed_partnum(char *supplied_partnum) {
+ if (supplied_partnum == NULL) return "1";
+ if (strlen(supplied_partnum)==0) return "1";
+ return supplied_partnum;
+}
+
- ptr = start;
- memset(buf, 0, maxlen);
- while (1) {
- ch = *ptr++;
- if ((ch == 10) || (ch == 0)) {
- if (strlen(buf) > 0)
- if (buf[strlen(buf) - 1] == 13)
- buf[strlen(buf) - 1] = 0;
- return ptr;
+/*
+ * Convert "quoted-printable" to binary. Returns number of bytes decoded.
+ * according to RFC2045 section 6.7
+ */
+int CtdlDecodeQuotedPrintable(char *decoded, char *encoded, int sourcelen) {
+ unsigned int ch;
+ int decoded_length = 0;
+ int pos = 0;
+
+ while (pos < sourcelen)
+ {
+ if (!strncmp(&encoded[pos], "=\r\n", 3))
+ {
+ pos += 3;
+ }
+ else if (!strncmp(&encoded[pos], "=\n", 2))
+ {
+ pos += 2;
}
- if (strlen(buf) < (maxlen - 1)) {
- buf[strlen(buf) + 1] = 0;
- buf[strlen(buf)] = ch;
+ else if (encoded[pos] == '=')
+ {
+ ch = 0;
+ sscanf(&encoded[pos+1], "%02x", &ch);
+ pos += 3;
+ decoded[decoded_length++] = ch;
+ }
+ else
+ {
+ decoded[decoded_length++] = encoded[pos];
+ pos += 1;
}
}
+ 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.
*/
void mime_decode(char *partnum,
char *part_start, size_t length,
- char *content_type, char *encoding,
+ char *content_type, char *charset, char *encoding,
char *disposition,
char *name, char *filename,
void (*CallBack)
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
+ size_t cblength,
+ char *cbencoding,
+ void *cbuserdata),
+ void (*PreMultiPartCallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ char *cbcharset,
+ size_t cblength,
+ char *cbencoding,
+ void *cbuserdata),
+ void (*PostMultiPartCallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
{
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"))
/* If this part is not encoded, send as-is */
if ( (strlen(encoding) == 0) || (dont_decode)) {
- CallBack(name, filename, partnum, disposition, part_start,
- content_type, length, encoding, userdata);
+ if (CallBack != NULL) {
+ CallBack(name, filename, fixed_partnum(partnum),
+ disposition, part_start,
+ content_type, charset, length, encoding, userdata);
+ }
return;
}
+
+ /* Fail silently if we hit an unknown encoding. */
if ((strcasecmp(encoding, "base64"))
&& (strcasecmp(encoding, "quoted-printable"))) {
- lprintf(5, "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.
+ * Allocate a buffer for the decoded data. The output buffer is slightly
+ * larger than the input buffer; this assumes that the decoded data
+ * will never be significantly larger than the encoded data. This is a
+ * safe assumption with base64, uuencode, and quoted-printable.
*/
- decoded = mallok(length + 1024);
+ decoded = malloc(length + 32768);
if (decoded == NULL) {
- lprintf(5, "ERROR: cannot allocate memory.\n");
return;
}
- if (pipe(sendpipe) != 0)
- return;
- if (pipe(recvpipe) != 0)
- return;
- childpid = fork();
- if (childpid < 0) {
- phree(decoded);
- return;
- }
- if (childpid == 0) {
- close(2);
- /* send stdio to the pipes */
- if (dup2(sendpipe[0], 0) < 0)
- lprintf(5, "ERROR dup2()\n");
- if (dup2(recvpipe[1], 1) < 0)
- lprintf(5, "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(5, "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(5, "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(5, "ERROR: cannot write to pipe: %s\n",
- strerror(errno));
- write_error = 1;
- }
- bytes_sent = bytes_sent + blocksize;
+ if (!strcasecmp(encoding, "base64")) {
+ bytes_decoded = CtdlDecodeBase64(decoded, part_start, length);
}
- 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)
- CallBack(name, filename, partnum, disposition, decoded,
- content_type, bytes_recv, "binary", userdata);
+ if (bytes_decoded > 0) if (CallBack != NULL) {
+ CallBack(name, filename, fixed_partnum(partnum),
+ disposition, decoded,
+ content_type, charset, bytes_decoded, "binary", userdata);
+ }
- phree(decoded);
+ free(decoded);
}
/*
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
+ size_t cblength,
+ char *cbencoding,
+ void *cbuserdata),
+ void (*PreMultiPartCallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ char *cbcharset,
+ size_t cblength,
+ char *cbencoding,
+ void *cbuserdata),
+ void (*PostMultiPartCallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
{
char *ptr;
- char *part_start, *part_end;
- char buf[256];
- char header[256];
- char boundary[256];
- char startary[256];
- char endary[256];
- char content_type[256];
- char encoding[256];
- char disposition[256];
- char name[256];
- char filename[256];
+ char *srch = NULL;
+ char *part_start, *part_end = NULL;
+ char buf[SIZ];
+ char *header;
+ char *boundary;
+ char *startary;
+ size_t startary_len = 0;
+ char *endary;
+ char *next_boundary;
+ char *content_type;
+ char *charset;
+ size_t content_length;
+ char *encoding;
+ char *disposition;
+ char *name = NULL;
+ char *content_type_name;
+ char *content_disposition_name;
+ char *filename;
int is_multipart;
int part_seq = 0;
int i;
size_t length;
char nested_partnum[256];
+ int crlf_in_use = 0;
+ char *evaluate_crlf_ptr = NULL;
- 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 = malloc(SIZ);
+ memset(boundary, 0, SIZ);
+
+ startary = malloc(SIZ);
+ memset(startary, 0, SIZ);
+
+ endary = malloc(SIZ);
+ memset(endary, 0, SIZ);
+
+ header = malloc(SIZ);
+ memset(header, 0, SIZ);
+
+ content_type = malloc(SIZ);
+ memset(content_type, 0, SIZ);
+
+ charset = malloc(SIZ);
+ memset(charset, 0, SIZ);
+
+ encoding = malloc(SIZ);
+ memset(encoding, 0, SIZ);
+
+ content_type_name = malloc(SIZ);
+ memset(content_type_name, 0, SIZ);
+
+ content_disposition_name = malloc(SIZ);
+ memset(content_disposition_name, 0, SIZ);
+
+ filename = malloc(SIZ);
+ memset(filename, 0, SIZ);
+
+ disposition = malloc(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 == 0)
- return; /* premature end of message */
- if (content_end != NULL)
- if (ptr >= content_end)
- return;
-
- for (i = 0; i < strlen(buf); ++i)
- if (isspace(buf[i]))
+ ptr = memreadline(ptr, buf, SIZ);
+ if (ptr >= content_end) {
+ goto end_parser;
+ }
+
+ for (i = 0; i < strlen(buf); ++i) {
+ if (isspace(buf[i])) {
buf[i] = ' ';
+ }
+ }
+
if (!isspace(buf[0])) {
- if (!strncasecmp(header, "Content-type: ", 14)) {
- strcpy(content_type, &header[14]);
- extract_key(name, content_type, "name");
+ if (!strncasecmp(header, "Content-type:", 13)) {
+ strcpy(content_type, &header[13]);
+ striplt(content_type);
+ extract_key(content_type_name, content_type, "name");
+ extract_key(charset, content_type, "charset");
+ /* 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]);
+ if (!strncasecmp(header, "Content-Disposition:", 20)) {
+ strcpy(disposition, &header[20]);
+ striplt(disposition);
+ extract_key(content_disposition_name, disposition, "name");
extract_key(filename, disposition, "filename");
}
- if (!strncasecmp(header,
- "Content-transfer-encoding: ", 27))
- strcpy(encoding, &header[27]);
+ if (!strncasecmp(header, "Content-length: ", 15)) {
+ char clbuf[10];
+ safestrncpy(clbuf, &header[15], sizeof clbuf);
+ striplt(clbuf);
+ content_length = (size_t) atol(clbuf);
+ }
+ if (!strncasecmp(header, "Content-transfer-encoding: ", 26)) {
+ strcpy(encoding, &header[26]);
+ striplt(encoding);
+ }
if (strlen(boundary) == 0)
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;
if (is_multipart) {
/* Tell the client about this message's multipartedness */
- CallBack("", "", partnum, "", NULL, content_type, 0,
- encoding, userdata);
+ if (PreMultiPartCallBack != NULL) {
+ PreMultiPartCallBack("", "", partnum, "",
+ NULL, content_type, charset,
+ 0, encoding, userdata);
+ }
/* Figure out where the boundaries are */
- sprintf(startary, "--%s", boundary);
- sprintf(endary, "--%s--", boundary);
+ snprintf(startary, SIZ, "--%s", boundary);
+ snprintf(endary, SIZ, "--%s--", boundary);
+ startary_len = strlen(startary);
+
+ part_start = NULL;
do {
- part_end = ptr;
- ptr = memreadline(ptr, buf, sizeof buf);
- if (*ptr == 0)
- return; /* premature end of message */
- if (content_end != NULL)
- if (ptr >= content_end)
- return;
- if ((!strcasecmp(buf, startary))
- || (!strcasecmp(buf, endary))) {
- if (part_start != NULL) {
- if (strlen(partnum) > 0) {
- sprintf(nested_partnum, "%s.%d",
- partnum, ++part_seq);
+ next_boundary = NULL;
+ for (srch=ptr; srch<content_end; ++srch) {
+ if (!memcmp(srch, startary, startary_len)) {
+ next_boundary = srch;
+ srch = content_end;
+ }
+ }
+
+ if ( (part_start != NULL) && (next_boundary != NULL) ) {
+ part_end = next_boundary;
+ --part_end; /* omit the trailing LF */
+ if (crlf_in_use) {
+ --part_end; /* omit the trailing CR */
+ }
+
+ 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);
+ }
+
+ 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");
+
+ /* Determine whether newlines are LF or CRLF */
+ evaluate_crlf_ptr = part_start;
+ --evaluate_crlf_ptr;
+ if (!memcmp(evaluate_crlf_ptr, "\r\n", 2)) {
+ crlf_in_use = 1;
}
else {
- sprintf(nested_partnum, "%d",
- ++part_seq);
+ crlf_in_use = 0;
}
- the_mime_parser(nested_partnum,
- part_start, part_end,
- CallBack, userdata,
- dont_decode);
+
+ /* Advance past the LF ... now we're in the next part */
+ ++part_start;
+ ptr = part_start;
}
- part_start = ptr;
}
- } while (strcasecmp(buf, endary));
+ else {
+ /* Invalid end of multipart. Bail out! */
+ ptr = content_end;
+ }
+ } while ( (ptr < content_end) && (next_boundary != NULL) );
+
+ if (PostMultiPartCallBack != NULL) {
+ PostMultiPartCallBack("", "", partnum, "", NULL,
+ content_type, charset, 0, encoding, userdata);
+ }
+ goto end_parser;
}
/* If it's not a multipart message, then do something with it */
if (!is_multipart) {
part_start = ptr;
length = 0;
- while ((*ptr != 0)
- && ((content_end == NULL) || (ptr < content_end))) {
+ while (ptr < content_end) {
+ ++ptr;
++length;
- part_end = ptr++;
}
+ part_end = content_end;
+
+ /******
+ * I thought there was an off-by-one error here, but there isn't.
+ * This probably means that there's an off-by-one error somewhere
+ * else ... or maybe only in certain messages?
+ --part_end;
+ --length;
+ ******/
+
+ /* Truncate if the header told us to */
+ if ( (content_length > 0) && (length > content_length) ) {
+ length = content_length;
+ }
+
+ /* Sometimes the "name" field is tacked on to Content-type,
+ * and sometimes it's tacked on to Content-disposition. Use
+ * whichever one we have.
+ */
+ if (strlen(content_disposition_name) > strlen(content_type_name)) {
+ name = content_disposition_name;
+ }
+ else {
+ name = content_type_name;
+ }
+
+ /* lprintf(CTDL_DEBUG, "mime_decode part=%s, len=%d, type=%s, charset=%s, encoding=%s\n",
+ partnum, length, content_type, charset, encoding); */
+
+ /* Ok, we've got a non-multipart part here, so do something with it.
+ */
mime_decode(partnum,
- part_start, length,
- content_type, encoding, disposition,
- name, filename, CallBack, userdata, dont_decode);
- }
+ part_start, length,
+ content_type, charset, encoding, disposition,
+ name, filename,
+ CallBack, NULL, NULL,
+ userdata, dont_decode
+ );
+
+ /*
+ * Now if it's an encapsulated message/rfc822 then we have to recurse into it
+ */
+ if (!strcasecmp(content_type, "message/rfc822")) {
+
+ if (PreMultiPartCallBack != NULL) {
+ PreMultiPartCallBack("", "", partnum, "",
+ NULL, content_type, charset,
+ 0, encoding, userdata);
+ }
+ if (CallBack != 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
+ );
+ }
+ if (PostMultiPartCallBack != NULL) {
+ PostMultiPartCallBack("", "", partnum, "", NULL,
+ content_type, charset, 0, encoding, userdata);
+ }
+ }
+
+ }
+
+end_parser: /* free the buffers! end the oppression!! */
+ free(boundary);
+ free(startary);
+ free(endary);
+ free(header);
+ free(content_type);
+ free(charset);
+ free(encoding);
+ free(content_type_name);
+ free(content_disposition_name);
+ free(filename);
+ free(disposition);
}
* Note: NULL can be supplied as content_end; in this case, the message is
* considered to have ended when the parser encounters a 0x00 byte.
*/
-void mime_parser(char *content_start, char *content_end,
+void mime_parser(char *content_start,
+ char *content_end,
+
void (*CallBack)
(char *cbname,
char *cbfilename,
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
+ size_t cblength,
+ char *cbencoding,
+ void *cbuserdata),
+
+ void (*PreMultiPartCallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
+
+ void (*PostMultiPartCallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ char *cbcharset,
+ size_t cblength,
+ char *cbencoding,
+ void *cbuserdata),
+
void *userdata,
int dont_decode
)
{
- lprintf(9, "mime_parser() called\n");
- the_mime_parser("", content_start, content_end, CallBack,
+ the_mime_parser("", content_start, content_end,
+ CallBack,
+ PreMultiPartCallBack,
+ PostMultiPartCallBack,
userdata, dont_decode);
}
projects / citadel.git / blobdiff