static CamelMimeMessage *
maildir_folder_get_message_sync (CamelFolder *folder,
const gchar *uid,
GCancellable *cancellable,
GError **error)
{
CamelLocalFolder *lf = (CamelLocalFolder *) folder;
CamelStream *message_stream = NULL;
CamelMimeMessage *message = NULL;
gchar *name = NULL;
d (printf ("getting message: %s\n", uid));
if (!lf || camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1)
return NULL;
name = maildir_folder_get_filename (folder, uid, error);
if (!name)
goto fail;
message_stream = camel_stream_fs_new_with_name (
name, O_RDONLY, 0, error);
if (message_stream == NULL) {
g_prefix_error (
error, _("Cannot get message %s from folder %s: "),
uid, lf->folder_path);
goto fail;
}
message = camel_mime_message_new ();
if (!camel_data_wrapper_construct_from_stream_sync (
(CamelDataWrapper *) message,
message_stream, cancellable, error)) {
g_prefix_error (
error, _("Cannot get message %s from folder %s: "),
uid, lf->folder_path);
g_object_unref (message);
message = NULL;
}
g_object_unref (message_stream);
fail:
g_free (name);
camel_local_folder_unlock (lf);
camel_local_folder_claim_changes (lf);
return message;
}
CamelMimeMessage *
test_message_read_file (const gchar *name)
{
CamelStream *stream;
CamelMimeMessage *msg2;
stream = camel_stream_fs_new_with_name (name, O_RDONLY, 0, NULL);
msg2 = camel_mime_message_new ();
camel_data_wrapper_construct_from_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream, NULL, NULL);
/* stream's refcount may be > 1 if the message is real big */
check (G_OBJECT (stream)->ref_count >=1);
g_object_unref (stream);
return msg2;
}
gint
test_message_write_file (CamelMimeMessage *msg,
const gchar *name)
{
CamelStream *stream;
gint ret;
stream = camel_stream_fs_new_with_name (
name, O_CREAT | O_WRONLY, 0600, NULL);
camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg), stream, NULL, NULL);
ret = camel_stream_close (stream, NULL, NULL);
check (G_OBJECT (stream)->ref_count == 1);
g_object_unref (stream);
return ret;
}
/**
* camel_imap_message_cache_get:
* @cache: the cache
* @uid: the UID of the data to get
* @part_spec: the part_spec of the data to get
* @ex: exception
*
* Return value: a CamelStream containing the cached data (which the
* caller must unref), or %NULL if that data is not cached.
**/
CamelStream *
camel_imap_message_cache_get (CamelImapMessageCache *cache, const char *uid,
const char *part_spec, CamelException *ex)
{
CamelStream *stream;
char *path, *key;
if (uid[0] == 0)
return NULL;
#ifdef G_OS_WIN32
/* See comment in insert_setup() */
if (!*part_spec)
part_spec = "~";
#endif
path = g_strdup_printf ("%s/%s.%s", cache->path, uid, part_spec);
key = strrchr (path, '/') + 1;
stream = g_hash_table_lookup (cache->parts, key);
if (stream) {
camel_stream_reset (CAMEL_STREAM (stream));
camel_object_ref (CAMEL_OBJECT (stream));
g_free (path);
return stream;
}
stream = camel_stream_fs_new_with_name (path, O_RDONLY, 0);
if (stream) {
cache_put (cache, uid, key, stream);
} else {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Failed to cache %s: %s"),
part_spec, g_strerror (errno));
}
g_free (path);
return stream;
}
static GtkWidget *
mbox_get_preview (EImport *ei,
EImportTarget *target,
EImportImporter *im)
{
GtkWidget *preview = NULL;
EImportTargetURI *s = (EImportTargetURI *) target;
gchar *filename;
gint fd;
CamelMimeParser *mp;
GtkListStore *store = NULL;
GtkTreeIter iter;
GtkWidget *preview_widget = NULL;
gboolean any_read = FALSE;
if (!create_preview_func || !fill_preview_func)
return NULL;
filename = g_filename_from_uri (s->uri_src, NULL, NULL);
if (!filename) {
g_message (G_STRLOC ": Couldn't get filename from URI '%s'", s->uri_src);
return NULL;
}
fd = g_open (filename, O_RDONLY | O_BINARY, 0);
if (fd == -1) {
g_warning (
"Cannot find source file to import '%s': %s",
filename, g_strerror (errno));
g_free (filename);
return NULL;
}
mp = camel_mime_parser_new ();
camel_mime_parser_scan_from (mp, TRUE);
if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
goto cleanup;
}
while (camel_mime_parser_step (mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM) {
CamelMimeMessage *msg;
any_read = TRUE;
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
g_object_unref (msg);
break;
}
mbox_preview_add_message (msg, &store);
g_object_unref (msg);
camel_mime_parser_step (mp, NULL, NULL);
}
if (!any_read) {
CamelStream *stream;
stream = camel_stream_fs_new_with_name (filename, O_RDONLY, 0, NULL);
if (stream) {
CamelMimeMessage *msg;
msg = camel_mime_message_new ();
if (camel_data_wrapper_construct_from_stream_sync ((CamelDataWrapper *) msg, stream, NULL, NULL))
mbox_preview_add_message (msg, &store);
g_object_unref (msg);
g_object_unref (stream);
}
}
if (store) {
GtkTreeView *tree_view;
GtkTreeSelection *selection;
preview = e_web_view_preview_new ();
gtk_widget_show (preview);
tree_view = e_web_view_preview_get_tree_view (
E_WEB_VIEW_PREVIEW (preview));
if (!tree_view) {
g_warn_if_reached ();
gtk_widget_destroy (preview);
preview = NULL;
goto cleanup;
}
gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (store));
g_object_unref (store);
/* Translators: Column header for a message subject */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("mboxImp", "Subject"),
gtk_cell_renderer_text_new (), "text", 0, NULL);
/* Translators: Column header for a message From address */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("mboxImp", "From"),
gtk_cell_renderer_text_new (), "text", 1, NULL);
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) > 1)
e_web_view_preview_show_tree_view (
E_WEB_VIEW_PREVIEW (preview));
create_preview_func (G_OBJECT (preview), &preview_widget);
if (!preview_widget) {
g_warn_if_reached ();
goto cleanup;
}
e_web_view_preview_set_preview (
E_WEB_VIEW_PREVIEW (preview), preview_widget);
gtk_widget_show (preview_widget);
selection = gtk_tree_view_get_selection (tree_view);
if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) {
g_warn_if_reached ();
goto cleanup;
}
gtk_tree_selection_select_iter (selection, &iter);
g_signal_connect (
selection, "changed",
G_CALLBACK (preview_selection_changed_cb), preview);
preview_selection_changed_cb (
selection, E_WEB_VIEW_PREVIEW (preview));
}
cleanup:
g_object_unref (mp);
g_free (filename);
/* 'fd' is freed together with 'mp' */
/* coverity[leaked_handle] */
return preview;
}
static gboolean
mbox_supported (EImport *ei,
EImportTarget *target,
EImportImporter *im)
{
gchar signature[1024];
gboolean ret = FALSE;
gint fd, n;
EImportTargetURI *s;
gchar *filename;
if (target->type != E_IMPORT_TARGET_URI)
return FALSE;
s = (EImportTargetURI *) target;
if (s->uri_src == NULL)
return TRUE;
if (strncmp (s->uri_src, "file:///", strlen ("file:///")) != 0)
return FALSE;
filename = g_filename_from_uri (s->uri_src, NULL, NULL);
fd = g_open (filename, O_RDONLY, 0);
if (fd != -1) {
n = read (fd, signature, 1024);
ret = n >= 5 && memcmp (signature, "From ", 5) == 0;
close (fd);
/* An artificial number, at least 256 bytes message
to be able to try to import it as an MBOX */
if (!ret && n >= 256) {
gint ii;
ret = (signature[0] >= 'a' && signature[0] <= 'z') ||
(signature[0] >= 'A' && signature[0] <= 'Z');
for (ii = 0; ii < n && ret; ii++) {
ret = signature[ii] == '-' ||
signature[ii] == ' ' ||
signature[ii] == '\t' ||
(signature[ii] >= 'a' && signature[ii] <= 'z') ||
(signature[ii] >= 'A' && signature[ii] <= 'Z') ||
(signature[ii] >= '0' && signature[ii] <= '9');
}
/* It's probably a header name which starts with ASCII letter and
contains only [a..z][A..Z][\t, ,-] and the read stopped on ':'. */
if (ii > 0 && ii < n && !ret && signature[ii - 1] == ':') {
CamelStream *stream;
stream = camel_stream_fs_new_with_name (filename, O_RDONLY, 0, NULL);
if (stream) {
CamelMimeMessage *msg;
msg = camel_mime_message_new ();
/* Check whether the message can be parsed and whether
it contains any mandatory fields. */
ret = camel_data_wrapper_construct_from_stream_sync ((CamelDataWrapper *) msg, stream, NULL, NULL) &&
camel_mime_message_get_message_id (msg) &&
camel_mime_message_get_subject (msg) &&
camel_mime_message_get_from (msg) &&
(camel_mime_message_get_recipients (msg, CAMEL_RECIPIENT_TYPE_TO) ||
camel_mime_message_get_recipients (msg, CAMEL_RECIPIENT_TYPE_RESENT_TO));
g_object_unref (msg);
g_object_unref (stream);
}
}
}
}
g_free (filename);
return ret;
}
gint
main (gint argc,
gchar **argv)
{
CamelStream *source;
CamelStream *correct;
CamelStream *stream;
CamelMimeFilter *sh;
gchar *work;
gint i;
gssize comp_progress, comp_correct_chunk, comp_filter_chunk;
gint comp_i;
gchar comp_correct[CHUNK_SIZE], comp_filter[CHUNK_SIZE];
camel_test_init (argc, argv);
for (i = 0; i < NUM_CASES; i++) {
gint j;
work = g_strdup_printf ("CRLF/DOT filter, test case %d", i);
camel_test_start (work);
g_free (work);
for (j = CRLF_ENCODE; j < CRLF_DONE; j++) {
CamelMimeFilterCRLFDirection direction;
gchar *infile = NULL, *outfile = NULL;
switch (j) {
case CRLF_ENCODE:
camel_test_push ("Test of the encoder");
direction = CAMEL_MIME_FILTER_CRLF_ENCODE;
infile = g_strdup_printf ("%s/crlf-%d.in", SOURCEDIR, i + 1);
outfile = g_strdup_printf ("%s/crlf-%d.out", SOURCEDIR, i + 1);
break;
case CRLF_DECODE:
camel_test_push ("Test of the decoder");
direction = CAMEL_MIME_FILTER_CRLF_DECODE;
infile = g_strdup_printf ("%s/crlf-%d.out", SOURCEDIR, i + 1);
outfile = g_strdup_printf ("%s/crlf-%d.in", SOURCEDIR, i + 1);
break;
default:
break;
}
camel_test_push ("Initializing objects");
source = camel_stream_fs_new_with_name (infile, 0, O_RDONLY, NULL);
if (!source) {
camel_test_fail ("Failed to open input case in \"%s\"", infile);
g_free (infile);
continue;
}
g_free (infile);
correct = camel_stream_fs_new_with_name (outfile, 0, O_RDONLY, NULL);
if (!correct) {
camel_test_fail ("Failed to open correct output in \"%s\"", outfile);
g_free (outfile);
continue;
}
g_free (outfile);
stream = camel_stream_filter_new (source);
if (!stream) {
camel_test_fail ("Couldn't create CamelStreamFilter??");
continue;
}
sh = camel_mime_filter_crlf_new (direction, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS);
if (!sh) {
camel_test_fail ("Couldn't create CamelMimeFilterCrlf??");
continue;
}
camel_stream_filter_add (
CAMEL_STREAM_FILTER (stream), sh);
camel_test_pull ();
camel_test_push ("Running filter and comparing to correct result");
comp_progress = 0;
while (1) {
comp_correct_chunk = camel_stream_read (
correct, comp_correct,
CHUNK_SIZE, NULL, NULL);
comp_filter_chunk = 0;
if (comp_correct_chunk == 0)
break;
while (comp_filter_chunk < comp_correct_chunk) {
gssize delta;
delta = camel_stream_read (
stream,
comp_filter + comp_filter_chunk,
CHUNK_SIZE - comp_filter_chunk,
NULL, NULL);
if (delta == 0) {
camel_test_fail ("Chunks are different sizes: correct is %d, "
"filter is %d, %d bytes into stream",
comp_correct_chunk, comp_filter_chunk, comp_progress);
}
comp_filter_chunk += delta;
}
for (comp_i = 0; comp_i < comp_filter_chunk; comp_i++) {
if (comp_correct[comp_i] != comp_filter[comp_i]) {
camel_test_fail ("Difference: correct is %c, filter is %c, "
"%d bytes into stream",
comp_correct[comp_i],
comp_filter[comp_i],
comp_progress + comp_i);
}
}
comp_progress += comp_filter_chunk;
}
camel_test_pull ();
/* inefficient */
camel_test_push ("Cleaning up");
g_object_unref (stream);
g_object_unref (correct);
g_object_unref (source);
g_object_unref (sh);
camel_test_pull ();
camel_test_pull ();
}
camel_test_end ();
}
return 0;
}
gint main (gint argc, gchar **argv)
{
CamelService *service;
CamelSession *session;
CamelStore *store;
CamelFolder *folder;
CamelMimeMessage *msg;
gint i, j;
CamelStream *mbox;
CamelFilterDriver *driver;
GError *error = NULL;
camel_test_init (argc, argv);
camel_test_provider_init (1, local_drivers);
/* clear out any camel-test data */
system ("/bin/rm -rf /tmp/camel-test");
camel_test_start ("Simple filtering of mbox");
session = camel_test_session_new ("/tmp/camel-test");
/* todo: cross-check everything with folder_info checks as well */
/* todo: work out how to do imap/pop/nntp tests */
push ("getting store");
service = camel_session_add_service (
session, "test-uid", "mbox:///tmp/camel-test/mbox",
CAMEL_PROVIDER_STORE, &error);
check_msg (error == NULL, "getting store: %s", error->message);
check (CAMEL_IS_STORE (service));
store = CAMEL_STORE (service);
g_clear_error (&error);
pull ();
push ("Creating output folders");
for (i = 0; i < G_N_ELEMENTS (mailboxes); i++) {
push ("creating %s", mailboxes[i].name);
mailboxes[i].folder = folder = camel_store_get_folder_sync (
store, mailboxes[i].name,
CAMEL_STORE_FOLDER_CREATE, NULL, &error);
check_msg (error == NULL, "%s", error->message);
check (folder != NULL);
/* we need an empty folder for this to work */
test_folder_counts (folder, 0, 0);
g_clear_error (&error);
pull ();
}
pull ();
/* append a bunch of messages with specific content */
push ("creating 100 test message mbox");
mbox = camel_stream_fs_new_with_name ("/tmp/camel-test/inbox", O_WRONLY|O_CREAT|O_EXCL, 0600, NULL);
for (j = 0; j < 100; j++) {
gchar *content, *subject;
push ("creating test message");
msg = test_message_create_simple ();
content = g_strdup_printf ("data%d content\n", j);
test_message_set_content_simple ((CamelMimePart *)msg, 0, "text/plain",
content, strlen (content));
test_free (content);
subject = g_strdup_printf ("Test%d message%d subject", j, 100-j);
camel_mime_message_set_subject (msg, subject);
camel_mime_message_set_date (msg, j * 60 * 24, 0);
pull ();
camel_stream_write_string (mbox, "From \n", NULL, NULL);
check (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg), mbox, NULL, NULL) != -1);
#if 0
push ("appending simple message %d", j);
camel_folder_append_message (folder, msg, NULL, ex);
check_msg (error == NULL, "%s", error->message);
g_clear_error (&error);
pull ();
#endif
test_free (subject);
check_unref (msg, 1);
}
check (camel_stream_close (mbox, NULL, NULL) != -1);
check_unref (mbox, 1);
pull ();
push ("Building filters");
driver = camel_filter_driver_new (session);
camel_filter_driver_set_folder_func (driver, get_folder, NULL);
for (i = 0; i < G_N_ELEMENTS (rules); i++) {
camel_filter_driver_add_rule (driver, rules[i].name, rules[i].match, rules[i].action);
}
pull ();
push ("Executing filters");
camel_filter_driver_set_default_folder (driver, mailboxes[0].folder);
#if 0 /* FIXME We no longer filter mbox files. */
camel_filter_driver_filter_mbox (
driver, "/tmp/camel-test/inbox", NULL, NULL, &error);
#endif
check_msg (error == NULL, "%s", error->message);
/* now need to check the folder counts/etc */
check_unref (driver, 1);
g_clear_error (&error);
pull ();
/* this tests that invalid rules are caught */
push ("Testing broken match rules");
for (i = 0; i < G_N_ELEMENTS (brokens); i++) {
push ("rule %s", brokens[i].match);
driver = camel_filter_driver_new (session);
camel_filter_driver_set_folder_func (driver, get_folder, NULL);
camel_filter_driver_add_rule (driver, brokens[i].name, brokens[i].match, brokens[i].action);
#if 0 /* FIXME We no longer filter mbox files. */
camel_filter_driver_filter_mbox (
driver, "/tmp/camel-test/inbox", NULL, NULL, &error);
#endif
check (error != NULL);
check_unref (driver, 1);
g_clear_error (&error);
pull ();
}
pull ();
push ("Testing broken action rules");
for (i = 0; i < G_N_ELEMENTS (brokena); i++) {
push ("rule %s", brokena[i].action);
driver = camel_filter_driver_new (session);
camel_filter_driver_set_folder_func (driver, get_folder, NULL);
camel_filter_driver_add_rule (driver, brokena[i].name, brokena[i].match, brokena[i].action);
#if 0 /* FIXME We no longer filter mbox files. */
camel_filter_driver_filter_mbox (
driver, "/tmp/camel-test/inbox", NULL, NULL, &error);
#endif
check (error != NULL);
check_unref (driver, 1);
g_clear_error (&error);
pull ();
}
pull ();
for (i = 0; i < G_N_ELEMENTS (mailboxes); i++) {
check_unref (mailboxes[i].folder, 1);
}
check_unref (store, 1);
check_unref (session, 1);
camel_test_end ();
return 0;
}
static gboolean
maildir_folder_append_message_sync (CamelFolder *folder,
CamelMimeMessage *message,
CamelMessageInfo *info,
gchar **appended_uid,
GCancellable *cancellable,
GError **error)
{
CamelLocalFolder *lf = (CamelLocalFolder *)folder;
CamelStream *output_stream;
CamelMessageInfo *mi;
CamelMaildirMessageInfo *mdi;
gchar *name, *dest = NULL;
gboolean success = TRUE;
d(printf("Appending message\n"));
/* If we can't lock, don't do anything */
if (camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1)
return FALSE;
/* add it to the summary/assign the uid, etc */
mi = camel_local_summary_add (
CAMEL_LOCAL_SUMMARY (folder->summary),
message, info, lf->changes, error);
if (mi == NULL)
goto check_changed;
if ((camel_message_info_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) && !camel_mime_message_has_attachment (message))
camel_message_info_set_flags (mi, CAMEL_MESSAGE_ATTACHMENTS, 0);
mdi = (CamelMaildirMessageInfo *)mi;
d(printf("Appending message: uid is %s filename is %s\n", camel_message_info_uid(mi), mdi->filename));
/* write it out to tmp, use the uid we got from the summary */
name = g_strdup_printf ("%s/tmp/%s", lf->folder_path, camel_message_info_uid(mi));
output_stream = camel_stream_fs_new_with_name (
name, O_WRONLY|O_CREAT, 0600, error);
if (output_stream == NULL)
goto fail_write;
if (camel_data_wrapper_write_to_stream_sync (
(CamelDataWrapper *)message, output_stream, cancellable, error) == -1
|| camel_stream_close (output_stream, cancellable, error) == -1)
goto fail_write;
/* now move from tmp to cur (bypass new, does it matter?) */
dest = g_strdup_printf("%s/cur/%s", lf->folder_path, camel_maildir_info_filename (mdi));
if (g_rename (name, dest) == -1) {
g_set_error (
error, G_IO_ERROR,
g_io_error_from_errno (errno),
"%s", g_strerror (errno));
goto fail_write;
}
g_free (dest);
g_free (name);
if (appended_uid)
*appended_uid = g_strdup(camel_message_info_uid(mi));
if (output_stream)
g_object_unref (output_stream);
goto check_changed;
fail_write:
/* remove the summary info so we are not out-of-sync with the mh folder */
camel_folder_summary_remove_uid (CAMEL_FOLDER_SUMMARY (folder->summary),
camel_message_info_uid (mi));
g_prefix_error (
error, _("Cannot append message to maildir folder: %s: "),
name);
if (output_stream) {
g_object_unref (CAMEL_OBJECT (output_stream));
unlink (name);
}
g_free (name);
g_free (dest);
success = FALSE;
check_changed:
camel_local_folder_unlock (lf);
if (lf && camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
return success;
}
static void
test_filter(CamelMimeFilter *f, const char *inname, const char *outname)
{
CamelStreamMem *in, *out;
CamelStream *indisk, *outdisk, *filter;
int id;
camel_test_push("Data file `%s'", inname);
camel_test_push("setup");
indisk = camel_stream_fs_new_with_name(inname, O_RDONLY, 0);
check(indisk);
outdisk = camel_stream_fs_new_with_name(outname, O_RDONLY, 0);
check(outdisk);
out = (CamelStreamMem *)camel_stream_mem_new();
check(camel_stream_write_to_stream(outdisk, (CamelStream *)out) > 0);
camel_test_pull();
camel_test_push("reading through filter stream");
in = (CamelStreamMem *)camel_stream_mem_new();
filter = (CamelStream *)camel_stream_filter_new_with_stream(indisk);
check_count(indisk, 2);
id = camel_stream_filter_add((CamelStreamFilter *)filter, f);
check_count(f, 2);
check(camel_stream_write_to_stream(filter, (CamelStream *)in) > 0);
check_msg(in->buffer->len == out->buffer->len
&& memcmp(in->buffer->data, out->buffer->data, in->buffer->len) == 0,
"Buffer content mismatch, %d != %d, in = '%.*s' != out = '%.*s'", in->buffer->len, out->buffer->len,
in->buffer->len, in->buffer->data, out->buffer->len, out->buffer->data);
camel_test_pull();
camel_stream_filter_remove((CamelStreamFilter *)filter, id);
check_count(f, 1);
camel_mime_filter_reset(f);
check_unref(filter, 1);
check_count(indisk, 1);
check_count(f, 1);
check_unref(in, 1);
check(camel_stream_reset(indisk) == 0);
camel_test_push("writing through filter stream");
in = (CamelStreamMem *)camel_stream_mem_new();
filter = (CamelStream *)camel_stream_filter_new_with_stream((CamelStream *)in);
check_count(in, 2);
id = camel_stream_filter_add((CamelStreamFilter *)filter, f);
check_count(f, 2);
check(camel_stream_write_to_stream(indisk, filter) > 0);
check(camel_stream_flush(filter) == 0);
check_msg(in->buffer->len == out->buffer->len
&& memcmp(in->buffer->data, out->buffer->data, in->buffer->len) == 0,
"Buffer content mismatch, %d != %d, in = '%.*s' != out = '%.*s'", in->buffer->len, out->buffer->len,
in->buffer->len, in->buffer->data, out->buffer->len, out->buffer->data);
camel_stream_filter_remove((CamelStreamFilter *)filter, id);
check_unref(filter, 1);
check_unref(in, 1);
check_unref(indisk, 1);
check_unref(outdisk, 1);
check_unref(out, 1);
camel_test_pull();
camel_test_pull();
}
static gboolean
mbox_folder_append_message_sync (CamelFolder *folder,
CamelMimeMessage *message,
CamelMessageInfo *info,
gchar **appended_uid,
GCancellable *cancellable,
GError **error)
{
CamelLocalFolder *lf = (CamelLocalFolder *) folder;
CamelStream *output_stream = NULL, *filter_stream = NULL;
CamelMimeFilter *filter_from;
CamelMboxSummary *mbs = (CamelMboxSummary *) folder->summary;
CamelMessageInfo *mi;
gchar *fromline = NULL;
struct stat st;
gint retval;
gboolean has_attachment;
#if 0
gchar *xev;
#endif
/* If we can't lock, dont do anything */
if (camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1)
return FALSE;
d (printf ("Appending message\n"));
/* first, check the summary is correct (updates folder_size too) */
retval = camel_local_summary_check ((CamelLocalSummary *) folder->summary, lf->changes, cancellable, error);
if (retval == -1)
goto fail;
/* add it to the summary/assign the uid, etc */
mi = camel_local_summary_add ((CamelLocalSummary *) folder->summary, message, info, lf->changes, error);
if (mi == NULL)
goto fail;
d (printf ("Appending message: uid is %s\n", camel_message_info_get_uid (mi)));
has_attachment = camel_mime_message_has_attachment (message);
if (((camel_message_info_get_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) && !has_attachment) ||
((camel_message_info_get_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) == 0 && has_attachment)) {
camel_message_info_set_flags (mi, CAMEL_MESSAGE_ATTACHMENTS, has_attachment ? CAMEL_MESSAGE_ATTACHMENTS : 0);
}
output_stream = camel_stream_fs_new_with_name (
lf->folder_path, O_WRONLY | O_APPEND |
O_LARGEFILE, 0666, error);
if (output_stream == NULL) {
g_prefix_error (
error, _("Cannot open mailbox: %s: "),
lf->folder_path);
goto fail;
}
/* and we need to set the frompos/XEV explicitly */
((CamelMboxMessageInfo *) mi)->frompos = mbs->folder_size;
#if 0
xev = camel_local_summary_encode_x_evolution ((CamelLocalSummary *) folder->summary, mi);
if (xev) {
/* the x-ev header should match the 'current' flags, no problem, so store as much */
camel_medium_set_header ((CamelMedium *) message, "X-Evolution", xev);
mi->flags &= ~ CAMEL_MESSAGE_FOLDER_NOXEV | CAMEL_MESSAGE_FOLDER_FLAGGED;
g_free (xev);
}
#endif
/* we must write this to the non-filtered stream ... */
fromline = camel_mime_message_build_mbox_from (message);
if (camel_stream_write (output_stream, fromline, strlen (fromline), cancellable, error) == -1)
goto fail_write;
/* and write the content to the filtering stream, that translates '\nFrom' into '\n>From' */
filter_stream = camel_stream_filter_new (output_stream);
filter_from = camel_mime_filter_from_new ();
camel_stream_filter_add ((CamelStreamFilter *) filter_stream, filter_from);
g_object_unref (filter_from);
if (camel_data_wrapper_write_to_stream_sync (
(CamelDataWrapper *) message, filter_stream, cancellable, error) == -1 ||
camel_stream_write (filter_stream, "\n", 1, cancellable, error) == -1 ||
camel_stream_flush (filter_stream, cancellable, error) == -1)
goto fail_write;
/* filter stream ref's the output stream itself, so we need to unref it too */
g_object_unref (filter_stream);
g_object_unref (output_stream);
g_free (fromline);
if (!((CamelMessageInfoBase *) mi)->preview && camel_folder_summary_get_need_preview (folder->summary)) {
if (camel_mime_message_build_preview ((CamelMimePart *) message, mi) && ((CamelMessageInfoBase *) mi)->preview)
camel_folder_summary_add_preview (folder->summary, mi);
}
/* now we 'fudge' the summary to tell it its uptodate, because its idea of uptodate has just changed */
/* the stat really shouldn't fail, we just wrote to it */
if (g_stat (lf->folder_path, &st) == 0) {
((CamelFolderSummary *) mbs)->time = st.st_mtime;
mbs->folder_size = st.st_size;
}
/* unlock as soon as we can */
camel_local_folder_unlock (lf);
if (camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
if (appended_uid)
*appended_uid = g_strdup(camel_message_info_get_uid(mi));
return TRUE;
fail_write:
g_prefix_error (
error, _("Cannot append message to mbox file: %s: "),
lf->folder_path);
if (output_stream) {
gint fd;
fd = camel_stream_fs_get_fd (CAMEL_STREAM_FS (output_stream));
if (fd != -1) {
/* reset the file to original size */
do {
retval = ftruncate (fd, mbs->folder_size);
} while (retval == -1 && errno == EINTR);
}
g_object_unref (output_stream);
}
if (filter_stream)
g_object_unref (filter_stream);
g_free (fromline);
/* remove the summary info so we are not out-of-sync with the mbox */
camel_folder_summary_remove (CAMEL_FOLDER_SUMMARY (mbs), mi);
/* and tell the summary it's up-to-date */
if (g_stat (lf->folder_path, &st) == 0) {
((CamelFolderSummary *) mbs)->time = st.st_mtime;
mbs->folder_size = st.st_size;
}
fail:
/* make sure we unlock the folder - before we start triggering events into appland */
camel_local_folder_unlock (lf);
/* cascade the changes through, anyway, if there are any outstanding */
if (camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
return FALSE;
}
static gboolean
mh_folder_append_message_sync (CamelFolder *folder,
CamelMimeMessage *message,
CamelMessageInfo *info,
gchar **appended_uid,
GCancellable *cancellable,
GError **error)
{
CamelLocalFolder *lf = (CamelLocalFolder *) folder;
CamelStream *output_stream;
CamelMessageInfo *mi;
gchar *name;
gboolean has_attachment;
/* FIXME: probably needs additional locking (although mh doesn't appear do do it) */
d(printf("Appending message\n"));
/* If we can't lock, don't do anything */
if (!lf || camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1)
return FALSE;
/* add it to the summary/assign the uid, etc */
mi = camel_local_summary_add ((CamelLocalSummary *) folder->summary, message, info, lf->changes, error);
if (mi == NULL)
goto check_changed;
has_attachment = camel_mime_message_has_attachment (message);
if (((camel_message_info_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) && !has_attachment) ||
((camel_message_info_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) == 0 && has_attachment)) {
camel_message_info_set_flags (mi, CAMEL_MESSAGE_ATTACHMENTS, has_attachment ? CAMEL_MESSAGE_ATTACHMENTS : 0);
}
d(printf("Appending message: uid is %s\n", camel_message_info_uid(mi)));
/* write it out, use the uid we got from the summary */
name = g_strdup_printf("%s/%s", lf->folder_path, camel_message_info_uid(mi));
output_stream = camel_stream_fs_new_with_name (
name, O_WRONLY | O_CREAT, 0600, error);
if (output_stream == NULL)
goto fail_write;
if (camel_data_wrapper_write_to_stream_sync (
(CamelDataWrapper *) message, output_stream, cancellable, error) == -1
|| camel_stream_close (output_stream, cancellable, error) == -1)
goto fail_write;
/* close this? */
g_object_unref (output_stream);
g_free (name);
if (appended_uid)
*appended_uid = g_strdup(camel_message_info_uid(mi));
goto check_changed;
fail_write:
/* remove the summary info so we are not out-of-sync with the mh folder */
camel_folder_summary_remove_uid (CAMEL_FOLDER_SUMMARY (folder->summary),
camel_message_info_uid (mi));
g_prefix_error (
error, _("Cannot append message to mh folder: %s: "), name);
if (output_stream) {
g_object_unref (output_stream);
unlink (name);
}
g_free (name);
check_changed:
camel_local_folder_unlock (lf);
if (camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
return TRUE;
}
static CamelMimeMessage *
mh_folder_get_message_sync (CamelFolder *folder,
const gchar *uid,
GCancellable *cancellable,
GError **error)
{
CamelLocalFolder *lf = (CamelLocalFolder *) folder;
CamelStream *message_stream = NULL;
CamelMimeMessage *message = NULL;
CamelMessageInfo *info;
gchar *name = NULL;
d(printf("getting message: %s\n", uid));
if (!lf || camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1)
return NULL;
/* get the message summary info */
if ((info = camel_folder_summary_get (folder->summary, uid)) == NULL) {
set_cannot_get_message_ex (
error, CAMEL_FOLDER_ERROR_INVALID_UID,
uid, lf->folder_path, _("No such message"));
goto fail;
}
/* we only need it to check the message exists */
camel_message_info_free (info);
name = g_strdup_printf("%s/%s", lf->folder_path, uid);
message_stream = camel_stream_fs_new_with_name (
name, O_RDONLY, 0, error);
if (message_stream == NULL) {
g_prefix_error (
error, _("Cannot get message %s from folder %s: "),
name, lf->folder_path);
goto fail;
}
message = camel_mime_message_new ();
if (!camel_data_wrapper_construct_from_stream_sync (
(CamelDataWrapper *) message,
message_stream, cancellable, error)) {
g_prefix_error (
error, _("Cannot get message %s from folder %s: "),
name, lf->folder_path);
g_object_unref (message);
message = NULL;
}
g_object_unref (message_stream);
fail:
g_free (name);
camel_local_folder_unlock (lf);
if (camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
return message;
}
static gint
do_perf (gint argc,
gchar **argv)
{
CamelIndex *idx;
DIR *dir;
const gchar *path = "/home/notzed/evolution/local/Inbox/mbox/cur";
struct dirent *d;
CamelStream *null, *filter, *stream;
CamelMimeFilter *filter_index;
gchar *name;
CamelIndexName *idn;
dir = opendir (path);
if (dir == NULL) {
perror("open dir");
return 1;
}
idx = (CamelIndex *) camel_text_index_new (
"/tmp/index", O_TRUNC|O_CREAT|O_RDWR);
if (idx == NULL) {
perror("open index");
closedir (dir);
return 1;
}
null = camel_stream_null_new ();
filter = camel_stream_filter_new (null);
g_object_unref (null);
filter_index = camel_mime_filter_index_new (idx);
camel_stream_filter_add ((CamelStreamFilter *) filter, filter_index);
while ((d = readdir (dir))) {
printf("indexing '%s'\n", d->d_name);
idn = camel_index_add_name (idx, d->d_name);
camel_mime_filter_index_set_name (
CAMEL_MIME_FILTER_INDEX (filter_index), idn);
name = g_strdup_printf("%s/%s", path, d->d_name);
stream = camel_stream_fs_new_with_name (name, O_RDONLY, 0, NULL);
camel_stream_write_to_stream (stream, filter, NULL, NULL);
g_object_unref (stream);
g_free (name);
camel_index_write_name (idx, idn);
g_object_unref (idn);
camel_mime_filter_index_set_name (
CAMEL_MIME_FILTER_INDEX (filter_index), NULL);
}
closedir (dir);
camel_index_sync (idx);
g_object_unref (idx);
g_object_unref (filter);
g_object_unref (filter_index);
return 0;
}
void
org_gnome_format_tnef(void *ep, EMFormatHookTarget *t)
{
char *tmpdir = NULL, *name = NULL;
CamelStream *out;
struct dirent *d;
DIR *dir;
CamelMultipart *mp;
CamelMimePart *mainpart;
CamelDataWrapper *content;
int len;
TNEFStruct *tnef;
tnef = (TNEFStruct *) g_malloc(sizeof(TNEFStruct));
tmpdir = e_mkdtemp("tnef-attachment-XXXXXX");
if (tmpdir == NULL)
return;
filepath = tmpdir;
name = g_build_filename(tmpdir, ".evo-attachment.tnef", NULL);
out = camel_stream_fs_new_with_name(name, O_RDWR|O_CREAT, 0666);
if (out == NULL)
goto fail;
content = camel_medium_get_content_object((CamelMedium *)t->part);
if (content == NULL)
goto fail;
if (camel_data_wrapper_decode_to_stream(content, out) == -1
|| camel_stream_close(out) == -1) {
camel_object_unref(out);
goto fail;
}
camel_object_unref(out);
/* Extracting the winmail.dat */
TNEFInitialize(tnef);
tnef->Debug = verbose;
if (TNEFParseFile(name, tnef) == -1) {
printf("ERROR processing file\n");
}
processTnef(tnef);
TNEFFree(tnef);
/* Extraction done */
dir = opendir(tmpdir);
if (dir == NULL)
goto fail;
mainpart = camel_mime_part_new();
mp = camel_multipart_new();
camel_data_wrapper_set_mime_type((CamelDataWrapper *)mp, "multipart/mixed");
camel_multipart_set_boundary(mp, NULL);
camel_medium_set_content_object((CamelMedium *)mainpart, (CamelDataWrapper *)mp);
while ((d = readdir(dir))) {
CamelMimePart *part;
CamelDataWrapper *content;
CamelStream *stream;
char *path;
const char *type;
if (!strcmp(d->d_name, ".")
|| !strcmp(d->d_name, "..")
|| !strcmp(d->d_name, ".evo-attachment.tnef"))
continue;
path = g_build_filename(tmpdir, d->d_name, NULL);
stream = camel_stream_fs_new_with_name(path, O_RDONLY, 0);
content = camel_data_wrapper_new();
camel_data_wrapper_construct_from_stream(content, stream);
camel_object_unref(stream);
part = camel_mime_part_new();
camel_mime_part_set_encoding(part, CAMEL_TRANSFER_ENCODING_BINARY);
camel_medium_set_content_object((CamelMedium *)part, content);
camel_object_unref(content);
type = em_utils_snoop_type(part);
if (type)
camel_data_wrapper_set_mime_type((CamelDataWrapper *)part, type);
camel_mime_part_set_filename(part, d->d_name);
g_free(path);
camel_multipart_add_part(mp, part);
}
closedir(dir);
len = t->format->part_id->len;
g_string_append_printf(t->format->part_id, ".tnef");
if (camel_multipart_get_number(mp) > 0)
em_format_part_as(t->format, t->stream, mainpart, "multipart/mixed");
else if (t->item->handler.old)
t->item->handler.old->handler(t->format, t->stream, t->part, t->item->handler.old);
g_string_truncate(t->format->part_id, len);
camel_object_unref(mainpart);
goto ok;
fail:
if (t->item->handler.old)
t->item->handler.old->handler(t->format, t->stream, t->part, t->item->handler.old);
ok:
g_free(name);
g_free(tmpdir);
}
static void
import_mbox_exec (struct _import_mbox_msg *m,
GCancellable *cancellable,
GError **error)
{
CamelFolder *folder;
CamelMimeParser *mp = NULL;
struct stat st;
gint fd;
if (g_stat (m->path, &st) == -1) {
g_warning (
"cannot find source file to import '%s': %s",
m->path, g_strerror (errno));
return;
}
if (m->uri == NULL || m->uri[0] == 0)
folder = e_mail_session_get_local_folder (
m->session, E_MAIL_LOCAL_FOLDER_INBOX);
else
folder = e_mail_session_uri_to_folder_sync (
m->session, m->uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, error);
if (folder == NULL)
return;
if (S_ISREG (st.st_mode)) {
gboolean any_read = FALSE;
fd = g_open (m->path, O_RDONLY | O_BINARY, 0);
if (fd == -1) {
g_warning (
"cannot find source file to import '%s': %s",
m->path, g_strerror (errno));
goto fail1;
}
mp = camel_mime_parser_new ();
camel_mime_parser_scan_from (mp, TRUE);
if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
/* will never happen - 0 is unconditionally returned */
goto fail2;
}
camel_operation_push_message (
cancellable, _("Importing '%s'"),
camel_folder_get_display_name (folder));
camel_folder_freeze (folder);
while (camel_mime_parser_step (mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM &&
!g_cancellable_is_cancelled (cancellable)) {
CamelMimeMessage *msg;
gint pc = 0;
any_read = TRUE;
if (st.st_size > 0)
pc = (gint) (100.0 * ((gdouble)
camel_mime_parser_tell (mp) /
(gdouble) st.st_size));
camel_operation_progress (cancellable, pc);
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (msg);
break;
}
import_mbox_add_message (folder, msg, cancellable, error);
g_object_unref (msg);
if (error && *error != NULL)
break;
camel_mime_parser_step (mp, NULL, NULL);
}
if (!any_read && !g_cancellable_is_cancelled (cancellable)) {
CamelStream *stream;
stream = camel_stream_fs_new_with_name (m->path, O_RDONLY, 0, NULL);
if (stream) {
CamelMimeMessage *msg;
msg = camel_mime_message_new ();
if (camel_data_wrapper_construct_from_stream_sync ((CamelDataWrapper *) msg, stream, NULL, NULL))
import_mbox_add_message (folder, msg, cancellable, error);
g_object_unref (msg);
g_object_unref (stream);
}
}
/* Not passing a GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
camel_operation_pop_message (cancellable);
fail2:
g_object_unref (mp);
}
fail1:
/* Not passing a GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
g_object_unref (folder);
/* 'fd' is freed together with 'mp' */
/* coverity[leaked_handle] */
}
