/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2007 Hiroyuki Yamamoto & The Claws Mail Team
+ * Copyright (C) 1999-2009 Hiroyuki Yamamoto & The Claws Mail Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
switch (mimeinfo->content) {
case MIMECONTENT_FILE:
if (mimeinfo->tmp)
- g_unlink(mimeinfo->data.filename);
+ claws_unlink(mimeinfo->data.filename);
g_free(mimeinfo->data.filename);
break;
MimeInfo *procmime_mimeinfo_parent(MimeInfo *mimeinfo)
{
- g_return_val_if_fail(mimeinfo != NULL, NULL);
- g_return_val_if_fail(mimeinfo->node != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo->node != NULL, NULL);
if (mimeinfo->node->parent == NULL)
return NULL;
MimeInfo *procmime_mimeinfo_next(MimeInfo *mimeinfo)
{
- g_return_val_if_fail(mimeinfo != NULL, NULL);
- g_return_val_if_fail(mimeinfo->node != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo->node != NULL, NULL);
if (mimeinfo->node->children)
return (MimeInfo *) mimeinfo->node->children->data;
{
const gchar *value;
- g_return_val_if_fail(mimeinfo != NULL, NULL);
- g_return_val_if_fail(name != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo != NULL, NULL);
+ cm_return_val_if_fail(name != NULL, NULL);
value = g_hash_table_lookup(mimeinfo->dispositionparameters, name);
if (value == NULL)
gchar lastline[BUFFSIZE];
memset(lastline, 0, BUFFSIZE);
- g_return_val_if_fail(mimeinfo != NULL, FALSE);
+ cm_return_val_if_fail(mimeinfo != NULL, FALSE);
if (prefs_common.respect_flowed_format &&
mimeinfo->type == MIMETYPE_TEXT &&
gboolean got_error = FALSE;
gboolean uncanonicalize = FALSE;
FILE *tmpfp = outfp;
+ gboolean null_bytes = FALSE;
if (mimeinfo->type == MIMETYPE_TEXT ||
mimeinfo->type == MIMETYPE_MESSAGE) {
decoder = base64_decoder_new();
while ((ftell(infp) < readend) && (fgets(buf, sizeof(buf), infp) != NULL)) {
len = base64_decoder_decode(decoder, buf, outbuf);
+ if (uncanonicalize == TRUE && strlen(outbuf) < len) {
+ uncanonicalize = FALSE;
+ null_bytes = TRUE;
+ }
if (len < 0 && !got_error) {
g_warning("Bad BASE64 content.\n");
if (fwrite(_("[Error decoding BASE64]\n"),
} else if (len >= 0) {
/* print out the error message only once
* per block */
- if (fwrite(outbuf, sizeof(gchar), len, tmpfp) < len)
- err = TRUE;
+ if (null_bytes) {
+ /* we won't uncanonicalize, output to outfp directly */
+ if (fwrite(outbuf, sizeof(gchar), len, outfp) < len)
+ err = TRUE;
+ } else {
+ if (fwrite(outbuf, sizeof(gchar), len, tmpfp) < len)
+ err = TRUE;
+ }
got_error = FALSE;
}
}
return FALSE;
}
- stat(tmpfilename, &statbuf);
+ g_stat(tmpfilename, &statbuf);
if (mimeinfo->tmp && (mimeinfo->data.filename != NULL))
- g_unlink(mimeinfo->data.filename);
+ claws_unlink(mimeinfo->data.filename);
g_free(mimeinfo->data.filename);
mimeinfo->data.filename = tmpfilename;
mimeinfo->tmp = TRUE;
return FALSE;
}
- if (mimeinfo->content == MIMECONTENT_FILE) {
+ if (mimeinfo->content == MIMECONTENT_FILE && mimeinfo->data.filename) {
if ((infp = g_fopen(mimeinfo->data.filename, "rb")) == NULL) {
g_warning("Can't open file %s\n", mimeinfo->data.filename);
+ fclose(outfp);
return FALSE;
}
} else if (mimeinfo->content == MIMECONTENT_MEM) {
infp = str_open_as_stream(mimeinfo->data.mem);
- if (infp == NULL)
+ if (infp == NULL) {
+ fclose(outfp);
return FALSE;
+ }
}
if (encoding == ENC_BASE64) {
if (canonicalize_file(mimeinfo->data.filename, tmp_file) < 0) {
g_free(tmp_file);
fclose(infp);
+ fclose(outfp);
return FALSE;
}
if ((tmp_fp = g_fopen(tmp_file, "rb")) == NULL) {
FILE_OP_ERROR(tmp_file, "fopen");
- g_unlink(tmp_file);
+ claws_unlink(tmp_file);
g_free(tmp_file);
fclose(infp);
+ fclose(outfp);
return FALSE;
}
} else {
infp = str_open_as_stream(out);
tmp_fp = infp;
g_free(out);
- if (infp == NULL)
+ if (infp == NULL) {
+ fclose(outfp);
return FALSE;
+ }
}
}
if (tmp_file) {
fclose(tmp_fp);
- g_unlink(tmp_file);
+ claws_unlink(tmp_file);
g_free(tmp_file);
}
} else if (encoding == ENC_QUOTED_PRINTABLE) {
if (mimeinfo->content == MIMECONTENT_FILE) {
if (mimeinfo->tmp && (mimeinfo->data.filename != NULL))
- g_unlink(mimeinfo->data.filename);
+ claws_unlink(mimeinfo->data.filename);
g_free(mimeinfo->data.filename);
} else if (mimeinfo->content == MIMECONTENT_MEM) {
if (mimeinfo->tmp && (mimeinfo->data.mem != NULL))
g_free(mimeinfo->data.mem);
}
- stat(tmpfilename, &statbuf);
+ g_stat(tmpfilename, &statbuf);
mimeinfo->content = MIMECONTENT_FILE;
mimeinfo->data.filename = tmpfilename;
mimeinfo->tmp = TRUE;
gint restlength, readlength;
gint saved_errno = 0;
- g_return_val_if_fail(outfile != NULL, -1);
- g_return_val_if_fail(mimeinfo != NULL, -1);
+ cm_return_val_if_fail(outfile != NULL, -1);
+ cm_return_val_if_fail(mimeinfo != NULL, -1);
if (mimeinfo->encoding_type != ENC_BINARY && !procmime_decode_content(mimeinfo))
return -EINVAL;
if (fclose(outfp) == EOF) {
saved_errno = errno;
FILE_OP_ERROR(outfile, "fclose");
- g_unlink(outfile);
+ claws_unlink(outfile);
return -(saved_errno);
}
gchar *tmpfile;
gboolean err = FALSE;
- g_return_val_if_fail(mimeinfo != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo != NULL, NULL);
if (!procmime_decode_content(mimeinfo))
return NULL;
? forced_charset :
procmime_mimeinfo_get_parameter(mimeinfo, "charset");
+ if (!forced_charset && src_codeset && !strcasecmp(src_codeset, CS_ISO_8859_1))
+ src_codeset = CS_WINDOWS_1252;
+
if (mimeinfo->type == MIMETYPE_TEXT && !g_ascii_strcasecmp(mimeinfo->subtype, "html")) {
SC_HTMLParser *parser;
CodeConverter *conv;
fclose(tmpfp);
rewind(outfp);
- g_unlink(tmpfile);
+ claws_unlink(tmpfile);
g_free(tmpfile);
if (err == TRUE) {
{
FILE *outfp = NULL;
MimeInfo *mimeinfo, *partinfo;
+ gboolean empty_ok = FALSE, short_scan = TRUE;
START_TIMING("");
- g_return_val_if_fail(msginfo != NULL, NULL);
+ cm_return_val_if_fail(msginfo != NULL, NULL);
- mimeinfo = procmime_scan_message_short(msginfo);
+ /* first we try to short-scan (for speed), refusing empty parts */
+scan_again:
+ if (short_scan)
+ mimeinfo = procmime_scan_message_short(msginfo);
+ else
+ mimeinfo = procmime_scan_message(msginfo);
if (!mimeinfo) return NULL;
partinfo = mimeinfo;
- while (partinfo && partinfo->type != MIMETYPE_TEXT) {
+ while (partinfo && (partinfo->type != MIMETYPE_TEXT ||
+ (partinfo->length == 0 && !empty_ok))) {
partinfo = procmime_mimeinfo_next(partinfo);
}
if (partinfo)
outfp = procmime_get_text_content(partinfo);
-
+ else if (!empty_ok && short_scan) {
+ /* if short scan didn't find a non-empty part, rescan
+ * fully for non-empty parts
+ */
+ short_scan = FALSE;
+ procmime_mimeinfo_free_all(mimeinfo);
+ goto scan_again;
+ } else if (!empty_ok && !short_scan) {
+ /* if full scan didn't find a non-empty part, rescan
+ * accepting empty parts
+ */
+ empty_ok = TRUE;
+ procmime_mimeinfo_free_all(mimeinfo);
+ goto scan_again;
+ }
procmime_mimeinfo_free_all(mimeinfo);
END_TIMING();
return outfp;
FILE *outfp = NULL;
MimeInfo *mimeinfo, *partinfo, *encinfo;
- g_return_val_if_fail(msginfo != NULL, NULL);
+ cm_return_val_if_fail(msginfo != NULL, NULL);
mimeinfo = procmime_scan_message(msginfo);
if (!mimeinfo) {
partinfo = mimeinfo;
while (partinfo && partinfo->type != MIMETYPE_TEXT) {
partinfo = procmime_mimeinfo_next(partinfo);
+ if (privacy_mimeinfo_is_signed(partinfo))
+ procmsg_msginfo_set_flags(msginfo, 0, MSG_SIGNED);
}
if (partinfo)
MimeInfo *mimeinfo, *partinfo;
gboolean result = FALSE;
- g_return_val_if_fail(msginfo != NULL, FALSE);
+ cm_return_val_if_fail(msginfo != NULL, FALSE);
mimeinfo = procmime_scan_message(msginfo);
if (!mimeinfo) {
FILE *outfp;
gchar buf[BUFFSIZE];
- g_return_val_if_fail(mimeinfo != NULL, FALSE);
- g_return_val_if_fail(mimeinfo->type == MIMETYPE_TEXT, FALSE);
- g_return_val_if_fail(str != NULL, FALSE);
- g_return_val_if_fail(find_func != NULL, FALSE);
+ cm_return_val_if_fail(mimeinfo != NULL, FALSE);
+ cm_return_val_if_fail(mimeinfo->type == MIMETYPE_TEXT, FALSE);
+ cm_return_val_if_fail(str != NULL, FALSE);
+ cm_return_val_if_fail(find_func != NULL, FALSE);
outfp = procmime_get_text_content(mimeinfo);
gchar *filename;
gboolean found = FALSE;
- g_return_val_if_fail(msginfo != NULL, FALSE);
- g_return_val_if_fail(str != NULL, FALSE);
- g_return_val_if_fail(find_func != NULL, FALSE);
+ cm_return_val_if_fail(msginfo != NULL, FALSE);
+ cm_return_val_if_fail(str != NULL, FALSE);
+ cm_return_val_if_fail(find_func != NULL, FALSE);
filename = procmsg_get_message_file(msginfo);
if (!filename) return FALSE;
gchar *filename;
gchar f_prefix[10];
- g_return_val_if_fail(mimeinfo != NULL, NULL);
+ cm_return_val_if_fail(mimeinfo != NULL, NULL);
g_snprintf(f_prefix, sizeof(f_prefix), "%08x.", id++);
gchar *procmime_get_mime_type(const gchar *filename)
{
- static GHashTable *mime_type_table = NULL;
- MimeType *mime_type;
const gchar *p;
gchar *ext = NULL;
gchar *base;
+#ifndef G_OS_WIN32
+ static GHashTable *mime_type_table = NULL;
+ MimeType *mime_type;
if (!mime_type_table) {
mime_type_table = procmime_get_mime_type_table();
if (!mime_type_table) return NULL;
}
+#endif
+
+ if (filename == NULL)
+ return NULL;
base = g_path_get_basename(filename);
if ((p = strrchr(base, '.')) != NULL)
- Xstrdup_a(ext, p + 1, p = NULL );
+ ext = g_utf8_strdown(p + 1, -1);
g_free(base);
- if (!p) return NULL;
- g_strdown(ext);
+#ifndef G_OS_WIN32
mime_type = g_hash_table_lookup(mime_type_table, ext);
+
if (mime_type) {
gchar *str;
-
str = g_strconcat(mime_type->type, "/", mime_type->sub_type,
NULL);
+ debug_print("got type %s for %s\n", str, ext);
+ g_free(ext);
return str;
- }
-
+ }
return NULL;
+#else
+ gchar *str = get_content_type_from_registry_with_ext(ext);
+
+ g_free(ext);
+ return str;
+#endif
}
static guint procmime_str_hash(gconstpointer gptr)
exts = g_strsplit(mime_type->extension, " ", 16);
for (i = 0; exts[i] != NULL; i++) {
- /* make the key case insensitive */
- g_strdown(exts[i]);
/* use previously dup'd key on overwriting */
if (g_hash_table_lookup(table, exts[i]))
key = exts[i];
if (mime_type_list)
return mime_type_list;
-#if defined(__NetBSD__)
+#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
if ((fp = g_fopen(DATAROOTDIR "/mime/globs", "rb")) == NULL)
#else
if ((fp = g_fopen("/usr/share/mime/globs", "rb")) == NULL)
}
if (*p)
- mime_type->extension = g_strdup(p);
+ mime_type->extension = g_utf8_strdown(p, -1);
else
mime_type->extension = NULL;
gchar *content_id,
gchar *content_disposition,
gchar *content_location,
+ const gchar *original_msgid,
+ const gchar *disposition_notification_hdr,
const gchar *filename,
guint offset,
guint length,
NULL, TRUE},
{"MIME-Version:",
NULL, TRUE},
+ {"Original-Message-ID:",
+ NULL, TRUE},
+ {"Disposition:",
+ NULL, TRUE},
{NULL, NULL, FALSE}};
guint content_start, i;
FILE *fp;
g_free(hentry[5].body);
hentry[5].body = tmp;
}
+ if (hentry[7].body != NULL) {
+ tmp = conv_unmime_header(hentry[7].body, NULL);
+ g_free(hentry[7].body);
+ hentry[7].body = tmp;
+ }
+ if (hentry[8].body != NULL) {
+ tmp = conv_unmime_header(hentry[8].body, NULL);
+ g_free(hentry[8].body);
+ hentry[8].body = tmp;
+ }
+
content_start = ftell(fp);
fclose(fp);
hentry[0].body, hentry[1].body,
hentry[2].body, hentry[3].body,
hentry[4].body, hentry[5].body,
+ hentry[7].body, hentry[8].body,
mimeinfo->data.filename, content_start,
len, short_scan);
}
}
+static void procmime_parse_disposition_notification(MimeInfo *mimeinfo,
+ const gchar *original_msgid, const gchar *disposition_notification_hdr,
+ gboolean short_scan)
+{
+ HeaderEntry hentry[] = {{"Original-Message-ID:", NULL, TRUE},
+ {"Disposition:", NULL, TRUE},
+ {NULL, NULL, FALSE}};
+ guint i;
+ FILE *fp;
+ gchar *orig_msg_id = NULL;
+ gchar *disp = NULL;
+
+ procmime_decode_content(mimeinfo);
+
+ debug_print("parse disposition notification\n");
+ fp = g_fopen(mimeinfo->data.filename, "rb");
+ if (fp == NULL) {
+ FILE_OP_ERROR(mimeinfo->data.filename, "fopen");
+ return;
+ }
+ fseek(fp, mimeinfo->offset, SEEK_SET);
+
+ if (original_msgid && disposition_notification_hdr) {
+ hentry[0].body = g_strdup(original_msgid);
+ hentry[1].body = g_strdup(disposition_notification_hdr);
+ } else {
+ procheader_get_header_fields(fp, hentry);
+ }
+
+ if (!hentry[0].body || !hentry[1].body) {
+ debug_print("MsgId %s, Disp %s\n",
+ hentry[0].body ? hentry[0].body:"(nil)",
+ hentry[1].body ? hentry[1].body:"(nil)");
+ goto bail;
+ }
+
+ orig_msg_id = g_strdup(hentry[0].body);
+ disp = g_strdup(hentry[1].body);
+
+ extract_parenthesis(orig_msg_id, '<', '>');
+ remove_space(orig_msg_id);
+
+ if (strstr(disp, "displayed")) {
+ /* find sent message, if possible */
+ MsgInfo *info = NULL;
+ GList *flist;
+ debug_print("%s has been displayed.\n", orig_msg_id);
+ for (flist = folder_get_list(); flist != NULL; flist = g_list_next(flist)) {
+ FolderItem *outbox = ((Folder *)(flist->data))->outbox;
+ if (!outbox) {
+ debug_print("skipping folder with no outbox...\n");
+ continue;
+ }
+ info = folder_item_get_msginfo_by_msgid(outbox, orig_msg_id);
+ debug_print("%s %s in %s\n", info?"found":"didn't find", orig_msg_id, outbox->path);
+ if (info) {
+ procmsg_msginfo_set_flags(info, MSG_RETRCPT_GOT, 0);
+ procmsg_msginfo_free(info);
+ }
+ }
+ }
+ g_free(orig_msg_id);
+ g_free(disp);
+bail:
+ for (i = 0; i < (sizeof hentry / sizeof hentry[0]); i++) {
+ g_free(hentry[i].body);
+ hentry[i].body = NULL;
+ }
+}
+
+#define GET_HEADERS() { \
+ procheader_get_header_fields(fp, hentry); \
+ if (hentry[0].body != NULL) { \
+ tmp = conv_unmime_header(hentry[0].body, NULL); \
+ g_free(hentry[0].body); \
+ hentry[0].body = tmp; \
+ } \
+ if (hentry[2].body != NULL) { \
+ tmp = conv_unmime_header(hentry[2].body, NULL); \
+ g_free(hentry[2].body); \
+ hentry[2].body = tmp; \
+ } \
+ if (hentry[4].body != NULL) { \
+ tmp = conv_unmime_header(hentry[4].body, NULL); \
+ g_free(hentry[4].body); \
+ hentry[4].body = tmp; \
+ } \
+ if (hentry[5].body != NULL) { \
+ tmp = conv_unmime_header(hentry[5].body, NULL); \
+ g_free(hentry[5].body); \
+ hentry[5].body = tmp; \
+ } \
+ if (hentry[6].body != NULL) { \
+ tmp = conv_unmime_header(hentry[6].body, NULL); \
+ g_free(hentry[6].body); \
+ hentry[6].body = tmp; \
+ } \
+ if (hentry[7].body != NULL) { \
+ tmp = conv_unmime_header(hentry[7].body, NULL); \
+ g_free(hentry[7].body); \
+ hentry[7].body = tmp; \
+ } \
+}
+
static void procmime_parse_multipart(MimeInfo *mimeinfo, gboolean short_scan)
{
HeaderEntry hentry[] = {{"Content-Type:", NULL, TRUE},
NULL, TRUE},
{"Content-Location:",
NULL, TRUE},
+ {"Original-Message-ID:",
+ NULL, TRUE},
+ {"Disposition:",
+ NULL, TRUE},
{NULL, NULL, FALSE}};
gchar *p, *tmp;
gchar *boundary;
FILE *fp;
int result = 0;
gboolean done = FALSE;
+ gboolean start_found = FALSE;
+ gboolean end_found = FALSE;
boundary = g_hash_table_lookup(mimeinfo->typeparameters, "boundary");
if (!boundary)
FILE_OP_ERROR(mimeinfo->data.filename, "fopen");
return;
}
+
fseek(fp, mimeinfo->offset, SEEK_SET);
while ((p = fgets(buf, sizeof(buf), fp)) != NULL && result == 0) {
if (ftell(fp) - 1 > (mimeinfo->offset + mimeinfo->length))
break;
if (IS_BOUNDARY(buf, boundary, boundary_len)) {
+ start_found = TRUE;
+
if (lastoffset != -1) {
gint len = (ftell(fp) - strlen(buf)) - lastoffset - 1;
if (len < 0)
hentry[0].body, hentry[1].body,
hentry[2].body, hentry[3].body,
hentry[4].body, hentry[5].body,
+ hentry[6].body, hentry[7].body,
mimeinfo->data.filename, lastoffset,
len, short_scan);
if (result == 1 && short_scan) {
done = TRUE;
break;
}
- }
+ }
if (buf[2 + boundary_len] == '-' &&
- buf[2 + boundary_len + 1] == '-')
+ buf[2 + boundary_len + 1] == '-') {
+ end_found = TRUE;
break;
-
+ }
for (i = 0; i < (sizeof hentry / sizeof hentry[0]) ; i++) {
g_free(hentry[i].body);
hentry[i].body = NULL;
}
- procheader_get_header_fields(fp, hentry);
- if (hentry[0].body != NULL) {
- tmp = conv_unmime_header(hentry[0].body, NULL);
- g_free(hentry[0].body);
- hentry[0].body = tmp;
- }
- if (hentry[2].body != NULL) {
- tmp = conv_unmime_header(hentry[2].body, NULL);
- g_free(hentry[2].body);
- hentry[2].body = tmp;
- }
- if (hentry[4].body != NULL) {
- tmp = conv_unmime_header(hentry[4].body, NULL);
- g_free(hentry[4].body);
- hentry[4].body = tmp;
- }
- if (hentry[5].body != NULL) {
- tmp = conv_unmime_header(hentry[5].body, NULL);
- g_free(hentry[5].body);
- hentry[5].body = tmp;
- }
+ GET_HEADERS();
lastoffset = ftell(fp);
}
}
+
+ if (start_found && !end_found && lastoffset != -1) {
+ gint len = (ftell(fp) - strlen(buf)) - lastoffset - 1;
+
+ if (len >= 0) {
+ result = procmime_parse_mimepart(mimeinfo,
+ hentry[0].body, hentry[1].body,
+ hentry[2].body, hentry[3].body,
+ hentry[4].body, hentry[5].body,
+ hentry[6].body, hentry[7].body,
+ mimeinfo->data.filename, lastoffset,
+ len, short_scan);
+ }
+ mimeinfo->broken = TRUE;
+ }
+
for (i = 0; i < (sizeof hentry / sizeof hentry[0]); i++) {
g_free(hentry[i].body);
hentry[i].body = NULL;
param = params;
next = params;
for (; next != NULL; param = next) {
- gchar *attribute, *value, *tmp;
+ gchar *attribute, *value, *tmp, *down_attr, *orig_down_attr;
gint len;
gboolean convert = FALSE;
while (value[0] == ' ')
value++;
- g_strdown(attribute);
-
- len = strlen(attribute);
- if (attribute[len - 1] == '*') {
+ down_attr = g_utf8_strdown(attribute, -1);
+ orig_down_attr = down_attr;
+
+ len = down_attr ? strlen(down_attr):0;
+ if (len > 0 && down_attr[len - 1] == '*') {
gchar *srcpos, *dstpos, *endpos;
convert = TRUE;
- attribute[len - 1] = '\0';
+ down_attr[len - 1] = '\0';
srcpos = value;
dstpos = value;
*tmp = '\0';
}
- if (attribute) {
- while (attribute[0] == ' ')
- attribute++;
- while (attribute[strlen(attribute)-1] == ' ')
- attribute[strlen(attribute)-1] = '\0';
+ if (down_attr) {
+ while (down_attr[0] == ' ')
+ down_attr++;
+ while (down_attr[strlen(down_attr)-1] == ' ')
+ down_attr[strlen(down_attr)-1] = '\0';
}
if (value) {
while (value[0] == ' ')
while (value[strlen(value)-1] == ' ')
value[strlen(value)-1] = '\0';
}
- if (strrchr(attribute, '*') != NULL) {
+ if (down_attr && strrchr(down_attr, '*') != NULL) {
gchar *tmpattr;
- tmpattr = g_strdup(attribute);
+ tmpattr = g_strdup(down_attr);
tmp = strrchr(tmpattr, '*');
tmp[0] = '\0';
if ((tmp[1] == '0') && (tmp[2] == '\0') &&
- (g_slist_find_custom(concatlist, attribute, g_str_equal) == NULL))
+ (g_slist_find_custom(concatlist, down_attr, g_str_equal) == NULL))
concatlist = g_slist_prepend(concatlist, g_strdup(tmpattr));
- if (convert && (g_slist_find_custom(convlist, attribute, g_str_equal) == NULL))
+ if (convert && (g_slist_find_custom(convlist, down_attr, g_str_equal) == NULL))
convlist = g_slist_prepend(convlist, g_strdup(tmpattr));
g_free(tmpattr);
} else if (convert) {
- if (g_slist_find_custom(convlist, attribute, g_str_equal) == NULL)
- convlist = g_slist_prepend(convlist, g_strdup(attribute));
+ if (g_slist_find_custom(convlist, down_attr, g_str_equal) == NULL)
+ convlist = g_slist_prepend(convlist, g_strdup(down_attr));
}
- if (g_hash_table_lookup(table, attribute) == NULL)
- g_hash_table_insert(table, g_strdup(attribute), g_strdup(value));
+ if (g_hash_table_lookup(table, down_attr) == NULL)
+ g_hash_table_insert(table, g_strdup(down_attr), g_strdup(value));
+ g_free(orig_down_attr);
}
for (cur = concatlist; cur != NULL; cur = g_slist_next(cur)) {
while ((partvalue = g_hash_table_lookup(table, attrwnum)) != NULL) {
g_string_append(value, partvalue);
+ g_hash_table_remove(table, attrwnum);
g_free(attrwnum);
n++;
attrwnum = g_strdup_printf("%s*%d", attribute, n);
static void procmime_parse_content_type(const gchar *content_type, MimeInfo *mimeinfo)
{
- g_return_if_fail(content_type != NULL);
- g_return_if_fail(mimeinfo != NULL);
+ cm_return_if_fail(content_type != NULL);
+ cm_return_if_fail(mimeinfo != NULL);
/* RFC 2045, page 13 says that the mime subtype is MANDATORY;
* if it's not available we use the default Content-Type */
}
mimeinfo->type = procmime_get_media_type(type);
- mimeinfo->subtype = g_strdup(subtype);
+ mimeinfo->subtype = g_strstrip(g_strdup(subtype));
/* Get mimeinfo->typeparameters */
if (params != NULL)
{
gchar *tmp, *params;
- g_return_if_fail(content_disposition != NULL);
- g_return_if_fail(mimeinfo != NULL);
+ cm_return_if_fail(content_disposition != NULL);
+ cm_return_if_fail(mimeinfo != NULL);
tmp = g_strdup(content_disposition);
if ((params = strchr(tmp, ';')) != NULL) {
static gboolean procmime_mimeparser_parse(MimeParser *parser, MimeInfo *mimeinfo)
{
- g_return_val_if_fail(parser->parse != NULL, FALSE);
+ cm_return_val_if_fail(parser->parse != NULL, FALSE);
return parser->parse(parser, mimeinfo);
}
gchar *content_id,
gchar *content_disposition,
gchar *content_location,
+ const gchar *original_msgid,
+ const gchar *disposition_notification_hdr,
const gchar *filename,
guint offset,
guint length,
/* Create MimeInfo */
mimeinfo = procmime_mimeinfo_new();
mimeinfo->content = MIMECONTENT_FILE;
+
if (parent != NULL) {
if (g_node_depth(parent->node) > 32) {
/* 32 is an arbitrary value
if (g_ascii_strcasecmp(mimeinfo->subtype, "rfc822") == 0) {
procmime_parse_message_rfc822(mimeinfo, short_scan);
}
+ if (g_ascii_strcasecmp(mimeinfo->subtype, "disposition-notification") == 0) {
+ procmime_parse_disposition_notification(mimeinfo,
+ original_msgid, disposition_notification_hdr, short_scan);
+ }
break;
case MIMETYPE_MULTIPART:
procmime_parse_multipart(mimeinfo, short_scan);
break;
-
+
+ case MIMETYPE_APPLICATION:
+ if (g_ascii_strcasecmp(mimeinfo->subtype, "octet-stream") == 0
+ && original_msgid && *original_msgid
+ && disposition_notification_hdr && *disposition_notification_hdr) {
+ procmime_parse_disposition_notification(mimeinfo,
+ original_msgid, disposition_notification_hdr, short_scan);
+ }
+ break;
default:
break;
}
MimeInfo *mimeinfo;
struct stat buf;
- stat(filename, &buf);
+ g_stat(filename, &buf);
mimeinfo = procmime_mimeinfo_new();
mimeinfo->content = MIMECONTENT_FILE;
{
MimeInfo *mimeinfo;
- g_return_val_if_fail(filename != NULL, NULL);
+ cm_return_val_if_fail(filename != NULL, NULL);
mimeinfo = procmime_scan_file_with_offset(filename, 0, short_scan);
gchar buf[BUFFSIZE];
gint offset = 0;
- g_return_val_if_fail(filename != NULL, NULL);
+ cm_return_val_if_fail(filename != NULL, NULL);
/* Open file */
if ((fp = g_fopen(filename, "rb")) == NULL)
ENC_AS_TOKEN,
ENC_AS_QUOTED_STRING,
ENC_AS_EXTENDED,
- ENC_TO_ASCII,
+ ENC_AS_ENCWORD
} EncodeAs;
typedef struct _ParametersData {
FILE *fp;
guint len;
- guint ascii_only;
gint error;
} ParametersData;
gchar *val = value, *valpos, *tmp;
ParametersData *pdata = (ParametersData *)user_data;
GString *buf = g_string_new("");
+ gint len;
EncodeAs encas = ENC_AS_TOKEN;
for (valpos = val; *valpos != 0; valpos++) {
- if (!IS_ASCII(*valpos) || *valpos == '"') {
- encas = ENC_AS_EXTENDED;
+ if (!IS_ASCII(*valpos)) {
+ encas = ENC_AS_ENCWORD;
break;
}
case ';':
case ':':
case '\\':
- case '\'':
+ case '"':
case '/':
case '[':
case ']':
}
}
- if (encas == ENC_AS_EXTENDED && pdata->ascii_only == TRUE)
- encas = ENC_TO_ASCII;
-
switch (encas) {
case ENC_AS_TOKEN:
g_string_append_printf(buf, "%s=%s", param, val);
break;
- case ENC_TO_ASCII:
- tmp = g_strdup(val);
- g_strcanon(tmp,
- " ()<>@,';:\\/[]?=.0123456789"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz",
- '_');
- g_string_append_printf(buf, "%s=\"%s\"", param, tmp);
- g_free(tmp);
- break;
-
case ENC_AS_QUOTED_STRING:
g_string_append_printf(buf, "%s=\"%s\"", param, val);
break;
+#if 0 /* we don't use that for now */
case ENC_AS_EXTENDED:
if (!g_utf8_validate(val, -1, NULL))
g_string_append_printf(buf, "%s*=%s''", param,
}
}
break;
+#endif
+ case ENC_AS_ENCWORD:
+ len = MAX(strlen(val)*6, 512);
+ tmp = g_malloc(len+1);
+ codeconv_set_strict(TRUE);
+ conv_encode_header_full(tmp, len, val, pdata->len + strlen(param) + 4 , FALSE,
+ prefs_common.outgoing_charset);
+ codeconv_set_strict(FALSE);
+ if (!tmp || !*tmp) {
+ codeconv_set_strict(TRUE);
+ conv_encode_header_full(tmp, len, val, pdata->len + strlen(param) + 4 , FALSE,
+ conv_get_outgoing_charset_str());
+ codeconv_set_strict(FALSE);
+ }
+ if (!tmp || !*tmp) {
+ codeconv_set_strict(TRUE);
+ conv_encode_header_full(tmp, len, val, pdata->len + strlen(param) + 4 , FALSE,
+ CS_UTF_8);
+ codeconv_set_strict(FALSE);
+ }
+ if (!tmp || !*tmp) {
+ conv_encode_header_full(tmp, len, val, pdata->len + strlen(param) + 4 , FALSE,
+ CS_UTF_8);
+ }
+ g_string_append_printf(buf, "%s=\"%s\"", param, tmp);
+ g_free(tmp);
+ break;
+
}
if (buf->str && strlen(buf->str)) {
- if (pdata->len + strlen(buf->str) + 2 > 76) {
+ tmp = strstr(buf->str, "\n");
+ if (tmp)
+ len = (tmp - buf->str);
+ else
+ len = strlen(buf->str);
+ if (pdata->len + len > 76) {
if (fprintf(pdata->fp, ";\n %s", buf->str) < 0)
pdata->error = TRUE;
pdata->len = strlen(buf->str) + 1;
} \
}
-static int procmime_write_mime_header(MimeInfo *mimeinfo, FILE *fp)
+int procmime_write_mime_header(MimeInfo *mimeinfo, FILE *fp)
{
struct TypeTable *type_table;
ParametersData *pdata = g_new0(ParametersData, 1);
debug_print("procmime_write_mime_header\n");
pdata->fp = fp;
- pdata->ascii_only = FALSE;
pdata->error = FALSE;
for (type_table = mime_type_table; type_table->str != NULL; type_table++)
if (mimeinfo->type == type_table->type) {
return -1;
}
pdata->len = strlen(buf);
- pdata->ascii_only = TRUE;
g_free(buf);
break;
}
g_free(buf);
pdata->fp = fp;
- pdata->ascii_only = FALSE;
pdata->error = FALSE;
g_hash_table_foreach(mimeinfo->dispositionparameters, write_parameters, pdata);
if (pdata->error == TRUE) {
projects / claws.git / blobdiff