*
* This is the MIME parser for Citadel. Sometimes it actually works.
*
- * Copyright (c) 1998-2003 by Art Cancro
+ * Copyright (c) 1998-2005 by Art Cancro
* This code is distributed under the terms of the GNU General Public License.
*
*/
-#include <ctype.h>
+
#include <stdlib.h>
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
#include <stdio.h>
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
#include <signal.h>
#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <netdb.h>
+#include <ctype.h>
#include <string.h>
-#include <pwd.h>
+#include <sys/stat.h>
#include <errno.h>
-#include <stdarg.h>
-#include <pthread.h>
-#include <signal.h>
+
#include "webcit.h"
-#include "webserver.h"
#include "mime_parser.h"
char buf[SIZ];
int buf_length = 0;
int soft_line_break = 0;
- int ch;
+ unsigned int ch;
int decoded_length = 0;
int i;
*/
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;
}
* 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;
}
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);
}
- phree(decoded);
+ free(decoded);
}
/*
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 *boundary;
char *startary;
char *endary;
+ char *next_boundary;
char *content_type;
+ char *charset;
size_t content_length;
char *encoding;
char *disposition;
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);
+ charset = malloc(SIZ);
+ memset(charset, 0, 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 */
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(content_type_name, content_type, "name");
+ extract_key(charset, content_type, "charset");
/* Deal with weird headers */
if (strchr(content_type, ' '))
*(strchr(content_type, ' ')) = '\0';
*(strchr(content_type, ';')) = '\0';
striplt(content_type);
+ if (!strlen(content_type)) {
+ strcpy(content_type, "text/plain");
+ }
+ if (!strlen(charset)) {
+ strcpy(charset, "us-ascii");
+ }
+
if (strlen(boundary) > 0) {
is_multipart = 1;
} else {
/* 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 */
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);
+ content_type, charset, 0, encoding, userdata);
}
goto end_parser;
}
++length;
}
part_end = content_end;
- /* fix an off-by-one error */
- --part_end;
- --length;
+ /* fix an off-by-one error */
+ --part_end;
+ --length;
/* Truncate if the header told us to */
if ( (content_length > 0) && (length > content_length) ) {
mime_decode(partnum,
part_start, length,
- content_type, encoding, disposition,
+ content_type, charset, encoding, disposition,
name, filename,
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(content_type_name);
- phree(content_disposition_name);
- phree(filename);
- phree(disposition);
+ 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);
}
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),
PostMultiPartCallBack,
userdata, dont_decode);
}
-
);
}
+
+
+/*
+ * bmstrstr() is a variant of strstr() that uses the Boyer-Moore search
+ * algorithm, and can use any caller-supplied string compare function whose
+ * calling syntax is similar to strncmp(). For example, we can supply it
+ * with strncasecmp() to do a case-insensitive search.
+ *
+ * Original code: copyright (c) 1997-1998 by Urs Janssen <urs@tin.org>
+ * Modifications: copyright (c) 2003 by Art Cancro <ajc@uncensored.citadel.org>
+ */
+char *bmstrstr(char *text, char *pattern,
+ int (*cmpfunc)(const char *, const char *, size_t) )
+{
+ register unsigned char *p, *t;
+ register int i, j, *delta;
+ register size_t p1;
+ int deltaspace[256];
+ size_t textlen;
+ size_t patlen;
+
+ if (text == NULL) return(NULL);
+ if (pattern == NULL) return(NULL);
+
+ textlen = strlen(text);
+ patlen = strlen(pattern);
+
+ /* algorithm fails if pattern is empty */
+ if ((p1 = patlen) == 0)
+ return (text);
+
+ /* code below fails (whenever i is unsigned) if pattern too long */
+ if (p1 > textlen)
+ return (NULL);
+
+ /* set up deltas */
+ delta = deltaspace;
+ for (i = 0; i <= 255; i++)
+ delta[i] = p1;
+ for (p = (unsigned char *) pattern, i = p1; --i > 0;)
+ delta[*p++] = i;
+
+ /*
+ * From now on, we want patlen - 1.
+ * In the loop below, p points to the end of the pattern,
+ * t points to the end of the text to be tested against the
+ * pattern, and i counts the amount of text remaining, not
+ * including the part to be tested.
+ */
+ p1--;
+ p = (unsigned char *) pattern + p1;
+ t = (unsigned char *) text + p1;
+ i = textlen - patlen;
+ while (1) {
+ if (tolower(*p) == tolower(*t)
+ && cmpfunc((p - p1), (t - p1), p1) == 0)
+ return ((char *) t - p1);
+ j = delta[*t];
+ if (i < j)
+ break;
+ i -= j;
+ t += j;
+ }
+ return (NULL);
+}
+
projects / citadel.git / commitdiff