/*
* $Id$
+ */
+/**
+ * \defgroup MIME This is the MIME parser for Citadel.
*
- * This is the MIME parser for Citadel. Sometimes it actually works.
- *
- * Copyright (c) 1998-2001 by Art Cancro
+ * Copyright (c) 1998-2005 by Art Cancro
* This code is distributed under the terms of the GNU General Public License.
- *
+ * \ingroup WebcitHttpServer
*/
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <ctype.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <pthread.h>
+/*@{*/
#include "webcit.h"
+#include "webserver.h"
#include "mime_parser.h"
-
+/**
+ * \brief get mime key
+ * \param target where to put the mime buffer at???
+ * \param source where to extract the mimetype from
+ * \param key what???
+ */
void extract_key(char *target, char *source, char *key)
{
int a, b;
}
-/*
- * For non-multipart messages, we need to generate a quickie partnum of "1"
+/**
+ * \brief For non-multipart messages, we need to generate a quickie partnum of "1"
* to return to callback functions. Some callbacks demand it.
+ * \param supplied_partnum partnum to convert
+ * \return the converted num
*/
char *fixed_partnum(char *supplied_partnum) {
if (supplied_partnum == NULL) return "1";
-/*
- * Convert "quoted-printable" to binary. Returns number of bytes decoded.
+/**
+ * \brief Convert "quoted-printable" to binary. Returns number of bytes decoded.
+ * \param decoded the buffer with the decoded output
+ * \param encoded the encoded string to decode
+ * \param sourcelen length of the decoded buffer
*/
-int decode_quoted_printable(char *decoded, char *encoded, int sourcelen) {
+int CtdlDecodeQuotedPrintable(char *decoded, char *encoded, int sourcelen) {
char buf[SIZ];
int buf_length = 0;
int soft_line_break = 0;
- int ch;
+ unsigned int ch;
int decoded_length = 0;
int i;
return(decoded_length);
}
-/*
+/**
+ * \brief fully decode a message
* Given a message or message-part body and a length, handle any necessary
* decoding and pass the request up the stack.
+ * \param partnum todo ?????
+ * \param part_start todo
+ * \param length todo
+ * \param content_type todo
+ * \param charset todo
+ * \param encoding todo
+ * \param disposition todo
+ * \param name todo
+ * \param filename todo
+ * \param CallBack todo
+ * \param PreMultiPartCallBack todo
+ * \param PostMultiPartCallBack todo
+ * \param userdata todo
+ * \param dont_decode todo
*/
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),
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
if (CallBack != NULL) {
CallBack(name, filename, fixed_partnum(partnum),
disposition, part_start,
- content_type, length, encoding, userdata);
+ content_type, charset, length, encoding, userdata);
}
return;
}
+
if ((strcasecmp(encoding, "base64"))
&& (strcasecmp(encoding, "quoted-printable"))) {
- fprintf(stderr, "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 = malloc(length+2048);
if (decoded == NULL) {
- fprintf(stderr, "ERROR: cannot allocate memory.\n");
return;
}
if (!strcasecmp(encoding, "base64")) {
- bytes_decoded = decode_base64(decoded, part_start);
+ bytes_decoded = CtdlDecodeBase64(decoded, part_start, length);
}
else if (!strcasecmp(encoding, "quoted-printable")) {
- bytes_decoded = decode_quoted_printable(decoded,
+ bytes_decoded = CtdlDecodeQuotedPrintable(decoded,
part_start, length);
}
if (bytes_decoded > 0) if (CallBack != NULL) {
CallBack(name, filename, fixed_partnum(partnum),
disposition, decoded,
- content_type, bytes_decoded, "binary", userdata);
+ content_type, charset, bytes_decoded, "binary", userdata);
}
free(decoded);
}
-
-
-
-/*
- * Break out the components of a multipart message
+/**
+ * \brief Break out the components of a multipart message
* (This function expects to be fed HEADERS + CONTENT)
* 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.
+ * \param partnum todo
+ * \param content_start todo ?????
+ * \param content_end todo
+ * \param CallBack todo
+ * \param PreMultiPartCallBack
+ * \param PostMultiPartCallBack
+ * \param userdata todo
+ * \param dont_decode todo
*/
void the_mime_parser(char *partnum,
char *content_start, char *content_end,
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
{
char *ptr;
+ 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;
+ char *name = NULL;
+ char *content_type_name;
+ char *content_disposition_name;
char *filename;
int is_multipart;
int part_seq = 0;
size_t length;
char nested_partnum[SIZ];
- fprintf(stderr, "the_mime_parser() called\n");
ptr = content_start;
content_length = 0;
content_type = malloc(SIZ);
memset(content_type, 0, SIZ);
+ charset = malloc(SIZ);
+ memset(charset, 0, SIZ);
+
encoding = malloc(SIZ);
memset(encoding, 0, SIZ);
- name = malloc(SIZ);
- memset(name, 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 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 */
+ /** Learn interesting things from the headers */
strcpy(header, "");
do {
- ptr = memreadline(ptr, buf, sizeof buf);
+ ptr = memreadline(ptr, buf, SIZ);
if (ptr >= content_end) {
goto end_parser;
}
- for (i = 0; i < strlen(buf); ++i)
- if (isspace(buf[i]))
+ 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");
- fprintf(stderr, "Extracted content-type <%s>\n",
- 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]);
+ extract_key(content_disposition_name, disposition, "name");
extract_key(filename, disposition, "filename");
}
if (!strncasecmp(header, "Content-length: ", 16)) {
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;
}
- fprintf(stderr, "is_multipart=%d, boundary=<%s>\n",
- is_multipart, boundary);
-
- /* If this is a multipart message, then recursively process it */
+ /** If this is a multipart message, then recursively process it */
part_start = NULL;
if (is_multipart) {
- /* Tell the client about this message's multipartedness */
+ /** Tell the client about this message's multipartedness */
if (PreMultiPartCallBack != NULL) {
PreMultiPartCallBack("", "", partnum, "",
- NULL, content_type,
+ NULL, content_type, charset,
0, encoding, userdata);
}
- /* Figure out where the boundaries are */
- sprintf(startary, "--%s", boundary);
- sprintf(endary, "--%s--", boundary);
+ /** Figure out where the boundaries are */
+ snprintf(startary, SIZ, "--%s", boundary);
+ snprintf(endary, SIZ, "--%s--", boundary);
+ startary_len = strlen(startary);
+
+ part_start = NULL;
do {
- if ( (!strncasecmp(ptr, startary, strlen(startary)))
- || (!strncasecmp(ptr, endary, strlen(endary))) ) {
- fprintf(stderr, "hit boundary!\n");
- if (part_start != NULL) {
- if (strlen(partnum) > 0) {
- sprintf(nested_partnum, "%s.%d",
- partnum, ++part_seq);
- }
- else {
- sprintf(nested_partnum, "%d",
- ++part_seq);
- }
- the_mime_parser(nested_partnum,
- part_start, part_end,
- CallBack,
- PreMultiPartCallBack,
- PostMultiPartCallBack,
- userdata,
- dont_decode);
+ 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;
+
+ 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");
+ ++part_start;
+ ptr = part_start;
}
- ptr = memreadline(ptr, buf, sizeof(buf));
- part_start = ptr;
}
else {
- part_end = ptr;
- ++ptr;
+ /** Invalid end of multipart. Bail out! */
+ ptr = content_end;
}
- } while ( (strcasecmp(ptr, endary)) && (ptr <= content_end) );
+ } while ( (ptr < content_end) && (next_boundary != NULL) );
+
if (PostMultiPartCallBack != NULL) {
PostMultiPartCallBack("", "", partnum, "", NULL,
- content_type, 0, encoding, userdata);
+ content_type, charset, 0, encoding, userdata);
}
goto end_parser;
}
- /* If it's not a multipart message, then do something with it */
+ /** If it's not a multipart message, then do something with it */
if (!is_multipart) {
- fprintf(stderr, "doing non-multipart thing\n");
part_start = ptr;
length = 0;
while (ptr < content_end) {
++length;
}
part_end = content_end;
+ /** fix an off-by-one error */
+ --part_end;
+ --length;
- /* Truncate if the header told us to */
+ /** Truncate if the header told us to */
if ( (content_length > 0) && (length > content_length) ) {
length = content_length;
- fprintf(stderr, "truncated to %ld\n", (long)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(9, "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, NULL, NULL,
- 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!! */
+end_parser: /** free the buffers! end the oppression!! */
free(boundary);
free(startary);
free(endary);
free(header);
free(content_type);
+ free(charset);
free(encoding);
- free(name);
+ free(content_type_name);
+ free(content_disposition_name);
free(filename);
free(disposition);
}
-
-
-
-
-/*
- * Entry point for the MIME parser.
+/**
+ * \brief Entry point for the MIME parser.
* (This function expects to be fed HEADERS + CONTENT)
* 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.
+ * \param content_start todo ?????????
+ * \param content_end todo
+ * \param CallBack todo
+ * \param PreMultiPartCallBack todo
+ * \param PostMultiPartCallBack todo
+ * \param userdata todo
+ * \param dont_decode todo
*/
void mime_parser(char *content_start,
char *content_end,
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
char *cbdisp,
void *cbcontent,
char *cbtype,
+ char *cbcharset,
size_t cblength,
char *cbencoding,
void *cbuserdata),
)
{
- fprintf(stderr, "mime_parser() called\n");
the_mime_parser("", content_start, content_end,
CallBack,
PreMultiPartCallBack,
PostMultiPartCallBack,
userdata, dont_decode);
}
+
+
+
+/*@}*/
projects / citadel.git / blobdiff