*
*/
+#include "sysdep.h"
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <ctype.h>
#include <string.h>
+#include <sys/stat.h>
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+#endif
+#include "citadel.h"
#include "mime_parser.h"
+#include "sysdep_decls.h"
+#include "server.h"
- /**** OTHERWISE, HERE'S WHERE WE HANDLE THE STUFF!! *****
-
- CallBack(name, filename, "", content, content_type, length);
-
- **** END OF STUFF-HANDLER ****/
-
-
/*
* Utility function to "readline" from memory
* (returns new pointer)
char *ptr;
ptr = start;
- bzero(buf, maxlen);
+ memset(buf, 0, maxlen);
while(1) {
ch = *ptr++;
}
}
+/*
+ * 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 *disposition,
+ char *name, char *filename,
+ void (*CallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ size_t cblength)
+ ) {
+
+ 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");
+
+ /* Some encodings aren't really encodings */
+ if (!strcasecmp(encoding, "7bit")) strcpy(encoding, "");
+ if (!strcasecmp(encoding, "8bit")) strcpy(encoding, "");
+ if (!strcasecmp(encoding, "binary")) strcpy(encoding, "");
+
+ /* If this part is not encoded, send as-is */
+ if (strlen(encoding)==0) {
+ CallBack(name, filename, partnum, disposition, part_start,
+ content_type, length);
+ return;
+ }
+
+ 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.
+ */
+ decoded = mallok(length + 1024);
+ 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;
+ }
+ close(sendpipe[1]);
+ /* Empty the input pipe */
+ while ( (blocksize = read(recvpipe[0], &decoded[bytes_recv], 1)),
+ (blocksize > 0) ) {
+ bytes_recv = bytes_recv + blocksize;
+ }
+
+ if (bytes_recv > 0)
+ CallBack(name, filename, partnum, disposition, decoded,
+ content_type, bytes_recv);
+
+ phree(decoded);
+ }
/*
* Break out the components of a multipart message
* 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 the_mime_parser(char *partnum,
+ char *content_start, char *content_end,
void (*CallBack)
(char *cbname,
char *cbfilename,
- char *cbencoding,
+ char *cbpartnum,
+ char *cbdisp,
void *cbcontent,
char *cbtype,
size_t cblength)
char buf[256];
char header[256];
char boundary[256];
+ char startary[256];
+ char endary[256];
char content_type[256];
char encoding[256];
- int content_length;
+ char disposition[256];
+ char name[256];
+ char filename[256];
+ int is_multipart;
+ int part_seq = 0;
int i;
+ size_t length;
+ char nested_partnum[256];
+ lprintf(9, "the_mime_parser() called\n");
ptr = content_start;
- bzero(boundary, sizeof boundary);
- bzero(content_type, sizeof content_type);
- bzero(encoding, sizeof encoding);
- content_length = 0;
+ 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);
/* Learn interesting things from the headers */
strcpy(header, "");
for (i=0; i<strlen(buf); ++i)
if (isspace(buf[i])) buf[i]=' ';
if (!isspace(buf[0])) {
- if (!strncasecmp(header, "Content-type: ", 14))
+ if (!strncasecmp(header, "Content-type: ", 14)) {
strcpy(content_type, &header[14]);
- if (!strncasecmp(header, "Content-length: ", 16))
- content_length = atoi(&header[16]);
+ extract_key(name, content_type, "name");
+ }
+ if (!strncasecmp(header, "Content-Disposition: ", 21)) {
+ strcpy(disposition, &header[21]);
+ extract_key(filename, disposition, "filename");
+ }
if (!strncasecmp(header,
"Content-transfer-encoding: ", 27))
strcpy(encoding, &header[27]);
strcat(header, buf);
} while ((strlen(buf) > 0) && (*ptr != 0));
- cprintf("Content type is <%s>\n", content_type);
- cprintf("Encoding is <%s>\n", encoding);
- cprintf("Content length is %d\n", content_length);
- cprintf("Boundary is <%s>\n", boundary);
+ for (i=0; i<strlen(disposition); ++i)
+ if (disposition[i]==';') disposition[i] = 0;
+ for (i=0; i<strlen(content_type); ++i)
+ if (content_type[i]==';') content_type[i] = 0;
+ if (strlen(boundary) > 0) {
+ is_multipart = 1;
+ }
+ else {
+ is_multipart = 0;
+ }
/* If this is a multipart message, then recursively process it */
- if (strlen(boundary)>0) {
+ part_start = NULL;
+ if (is_multipart) {
+ sprintf(startary, "--%s", boundary);
+ sprintf(endary, "--%s--", boundary);
+ 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) {
+ sprintf(nested_partnum, "%s.%d",
+ partnum, ++part_seq);
+ the_mime_parser(nested_partnum,
+ part_start, part_end,
+ CallBack);
+ }
+ part_start = ptr;
+ }
+ } while (strcasecmp(buf, endary));
+ }
+
+ /* 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))) {
+ ++length;
+ part_end = ptr++;
+ }
+ mime_decode(partnum,
+ part_start, length,
+ content_type, encoding, disposition,
+ name, filename, CallBack);
}
+ }
+
+/*
+ * 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.
+ */
+void mime_parser(char *content_start, char *content_end,
+ void (*CallBack)
+ (char *cbname,
+ char *cbfilename,
+ char *cbpartnum,
+ char *cbdisp,
+ void *cbcontent,
+ char *cbtype,
+ size_t cblength)
+ ) {
+ lprintf(9, "mime_parser() called\n");
+ the_mime_parser("1", content_start, content_end, CallBack);
}