static int
stream_flush (CamelStream *stream)
{
CamelSeekableSubstream *sus = (CamelSeekableSubstream *)stream;
return camel_stream_flush(CAMEL_STREAM(sus->parent_stream));
}
static int
stream_flush (CamelStream *stream)
{
CamelSCALIXStream *scalix = (CamelSCALIXStream *) stream;
return camel_stream_flush (scalix->stream);
}
static int
stream_flush (CamelStream *stream)
{
CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) stream;
return camel_stream_flush (imap4->stream);
}
static gboolean
update_cache (CamelGroupwiseJournal *groupwise_journal, CamelMimeMessage *message,
const CamelMessageInfo *mi, char **updated_uid, CamelException *ex)
{
CamelOfflineJournal *journal = (CamelOfflineJournal *) groupwise_journal;
CamelGroupwiseFolder *groupwise_folder = (CamelGroupwiseFolder *) journal->folder;
CamelFolder *folder = (CamelFolder *) journal->folder;
CamelMessageInfo *info;
CamelStream *cache;
guint32 nextuid;
char *uid;
if (groupwise_folder->cache == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM,
_("Cannot append message in offline mode: cache unavailable"));
return FALSE;
}
nextuid = camel_folder_summary_next_uid (folder->summary);
uid = g_strdup_printf ("-%u", nextuid);
if (!(cache = camel_data_cache_add (groupwise_folder->cache, "cache", uid, ex))) {
folder->summary->nextuid--;
g_free (uid);
return FALSE;
}
if (camel_data_wrapper_write_to_stream ((CamelDataWrapper *) message, cache) == -1
|| camel_stream_flush (cache) == -1) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Cannot append message in offline mode: %s"),
g_strerror (errno));
camel_data_cache_remove (groupwise_folder->cache, "cache", uid, NULL);
folder->summary->nextuid--;
camel_object_unref (cache);
g_free (uid);
return FALSE;
}
camel_object_unref (cache);
info = camel_folder_summary_info_new_from_message (folder->summary, message);
g_free(info->uid);
info->uid = g_strdup (uid);
gw_message_info_dup_to ((CamelMessageInfoBase *) info, (CamelMessageInfoBase *) mi);
camel_folder_summary_add (folder->summary, info);
if (updated_uid)
*updated_uid = g_strdup (uid);
g_free (uid);
return TRUE;
}
static CamelStream *
insert_finish (CamelImapMessageCache *cache, const char *uid, char *path,
char *key, CamelStream *stream)
{
camel_stream_flush (stream);
camel_stream_reset (stream);
cache_put (cache, uid, key, stream);
g_free (path);
return stream;
}
static gssize
data_wrapper_decode_to_stream_sync (CamelDataWrapper *data_wrapper,
CamelStream *stream,
GCancellable *cancellable,
GError **error)
{
CamelMimeFilter *filter;
CamelStream *fstream;
gssize ret;
fstream = camel_stream_filter_new (stream);
switch (data_wrapper->encoding) {
case CAMEL_TRANSFER_ENCODING_BASE64:
filter = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
g_object_unref (filter);
break;
case CAMEL_TRANSFER_ENCODING_QUOTEDPRINTABLE:
filter = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_QP_DEC);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
g_object_unref (filter);
break;
case CAMEL_TRANSFER_ENCODING_UUENCODE:
filter = camel_mime_filter_basic_new (CAMEL_MIME_FILTER_BASIC_UU_DEC);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
g_object_unref (filter);
break;
default:
break;
}
if (!(camel_content_type_is (data_wrapper->mime_type, "text", "pdf")) && camel_content_type_is (data_wrapper->mime_type, "text", "*")) {
filter = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_DECODE,
CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY);
camel_stream_filter_add (CAMEL_STREAM_FILTER (fstream), filter);
g_object_unref (filter);
}
ret = camel_data_wrapper_write_to_stream_sync (
data_wrapper, fstream, cancellable, error);
camel_stream_flush (fstream, NULL, NULL);
g_object_unref (fstream);
return ret;
}
static gint
run_command (struct _CamelSExp *f,
gint argc,
struct _CamelSExpResult **argv,
FilterMessageSearch *fms)
{
CamelMimeMessage *message;
CamelStream *stream;
gint i;
gint pipe_to_child;
GPid child_pid;
GError *error = NULL;
GPtrArray *args;
child_watch_data_t child_watch_data;
GSource *source;
GMainContext *context;
if (argc < 1 || argv[0]->value.string[0] == '\0')
return 0;
args = g_ptr_array_new ();
for (i = 0; i < argc; i++)
g_ptr_array_add (args, argv[i]->value.string);
g_ptr_array_add (args, NULL);
if (!g_spawn_async_with_pipes (NULL,
(gchar **) args->pdata,
NULL,
G_SPAWN_DO_NOT_REAP_CHILD |
G_SPAWN_SEARCH_PATH |
G_SPAWN_STDOUT_TO_DEV_NULL |
G_SPAWN_STDERR_TO_DEV_NULL,
child_setup_func,
NULL,
&child_pid,
&pipe_to_child,
NULL,
NULL,
&error)) {
g_ptr_array_free (args, TRUE);
g_set_error (
fms->error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
_("Failed to create child process '%s': %s"),
argv[0]->value.string, error->message);
g_error_free (error);
return -1;
}
g_ptr_array_free (args, TRUE);
message = camel_filter_search_get_message (fms, f);
stream = camel_stream_fs_new_with_fd (pipe_to_child);
camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (message), stream, NULL, NULL);
camel_stream_flush (stream, NULL, NULL);
g_object_unref (stream);
context = g_main_context_new ();
child_watch_data.loop = g_main_loop_new (context, FALSE);
g_main_context_unref (context);
source = g_child_watch_source_new (child_pid);
g_source_set_callback (source, (GSourceFunc) child_watch, &child_watch_data, NULL);
g_source_attach (source, g_main_loop_get_context (child_watch_data.loop));
g_source_unref (source);
g_main_loop_run (child_watch_data.loop);
g_main_loop_unref (child_watch_data.loop);
#ifndef G_OS_WIN32
if (WIFEXITED (child_watch_data.child_status))
return WEXITSTATUS (child_watch_data.child_status);
else
return -1;
#else
return child_watch_data.child_status;
#endif
}
static int
pipe_to_sa_full (CamelMimeMessage *msg, const char *in, char **argv, int rv_err, int wait_for_termination, GByteArray *output_buffer, GError **error)
{
int result, status, errnosav, fds[2], out_fds[2];
CamelStream *stream;
char *program;
pid_t pid;
if (camel_debug_start ("junk")) {
int i;
printf ("pipe_to_sa ");
for (i = 0; argv[i]; i++)
printf ("%s ", argv[i]);
printf ("\n");
camel_debug_end ();
}
program = g_find_program_in_path (argv [0]);
if (program == NULL) {
d(printf ("program not found, returning %d\n", rv_err));
g_set_error (error, EM_JUNK_ERROR, rv_err, _("SpamAssassin not found, code: %d"), rv_err);
return rv_err;
}
g_free (program);
if (pipe (fds) == -1) {
errnosav = errno;
d(printf ("failed to create a pipe (for use with spamassassin: %s\n", strerror (errno)));
g_set_error (error, EM_JUNK_ERROR, errnosav, _("Failed to create pipe: %s"), strerror (errnosav));
errno = errnosav;
return rv_err;
}
if (output_buffer && pipe (out_fds) == -1) {
errnosav = errno;
d(printf ("failed to create a pipe (for use with spamassassin: %s\n", strerror (errno)));
g_set_error (error, EM_JUNK_ERROR, errnosav, _("Failed to create pipe: %s"), strerror (errnosav));
close (fds [0]);
close (fds [1]);
errno = errnosav;
return rv_err;
}
if (!(pid = fork ())) {
/* child process */
int maxfd, fd, nullfd;
nullfd = open ("/dev/null", O_WRONLY);
if (dup2 (fds[0], STDIN_FILENO) == -1 ||
dup2 (nullfd, STDERR_FILENO) == -1 ||
(output_buffer == NULL && dup2 (nullfd, STDOUT_FILENO) == -1) ||
(output_buffer != NULL && dup2 (out_fds[1], STDOUT_FILENO) == -1))
_exit (rv_err & 0377);
close (fds [0]);
if (output_buffer)
close (out_fds [1]);
setsid ();
maxfd = sysconf (_SC_OPEN_MAX);
for (fd = 3; fd < maxfd; fd++)
fcntl (fd, F_SETFD, FD_CLOEXEC);
execvp (argv[0], argv);
_exit (rv_err & 0377);
} else if (pid < 0) {
errnosav = errno;
close (fds[0]);
close (fds[1]);
if (output_buffer) {
close (out_fds [0]);
close (out_fds [1]);
}
if (errnosav != 0 && errnosav != -1)
g_set_error (error, EM_JUNK_ERROR, errnosav, _("Error after fork: %s"), strerror (errnosav));
errno = errnosav;
return rv_err;
}
/* parent process */
close (fds[0]);
if (output_buffer)
close (out_fds [1]);
if (msg) {
stream = camel_stream_fs_new_with_fd (fds[1]);
camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (msg), stream);
camel_stream_flush (stream);
camel_stream_close (stream);
camel_object_unref (stream);
} else if (in) {
camel_write (fds[1], in, strlen (in));
close (fds[1]);
}
if (output_buffer) {
CamelStreamMem *memstream;
stream = camel_stream_fs_new_with_fd (out_fds[0]);
memstream = (CamelStreamMem *) camel_stream_mem_new ();
camel_stream_mem_set_byte_array (memstream, output_buffer);
camel_stream_write_to_stream (stream, (CamelStream *) memstream);
camel_object_unref (stream);
g_byte_array_append (output_buffer, (unsigned char *)"", 1);
d(printf ("child process output: %s len: %d\n", output_buffer->data, output_buffer->len));
}
if (wait_for_termination) {
int res;
d(printf ("wait for child %d termination\n", pid));
result = waitpid (pid, &status, 0);
d(printf ("child %d terminated with result %d status %d exited %d exitstatus %d\n", pid, result, status, WIFEXITED (status), WEXITSTATUS (status)));
if (result == -1 && errno == EINTR) {
/* child process is hanging... */
kill (pid, SIGTERM);
sleep (1);
result = waitpid (pid, &status, WNOHANG);
if (result == 0) {
/* ...still hanging, set phasers to KILL */
kill (pid, SIGKILL);
sleep (1);
result = waitpid (pid, &status, WNOHANG);
g_set_error (error, EM_JUNK_ERROR, -2, _("SpamAssassin child process does not respond, killing..."));
} else
g_set_error (error, EM_JUNK_ERROR, -3, _("Wait for Spamassassin child process interrupted, terminating..."));
}
if (result != -1 && WIFEXITED (status))
res = WEXITSTATUS (status);
else
res = rv_err;
if (res != 0)
g_set_error (error, EM_JUNK_ERROR, res, _("Pipe to SpamAssassin failed, error code: %d"), res);
return res;
} else
return 0;
}
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 void
create_mime_message_cb (ESoapMessage *msg,
gpointer user_data)
{
struct _create_mime_msg_data *create_data = user_data;
CamelStream *mem, *filtered;
CamelMimeFilter *filter;
CamelContentType *content_type;
GByteArray *bytes;
gchar *base64;
gint msgflag;
guint32 message_camel_flags = 0;
if (create_data->info)
message_camel_flags = camel_message_info_flags (create_data->info);
e_soap_message_start_element (msg, "Message", NULL, NULL);
e_soap_message_start_element (msg, "MimeContent", NULL, NULL);
/* This is horrid. We really need to extend ESoapMessage to allow us
* to stream this directly rather than storing it in RAM. Which right
* now we are doing about four times: the GByteArray in the mem stream,
* then the base64 version, then the xmlDoc, then the soup request. */
camel_mime_message_set_best_encoding (
create_data->message,
CAMEL_BESTENC_GET_ENCODING,
CAMEL_BESTENC_8BIT);
mem = camel_stream_mem_new ();
filtered = camel_stream_filter_new (mem);
filter = camel_mime_filter_crlf_new (
CAMEL_MIME_FILTER_CRLF_ENCODE,
CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY);
camel_stream_filter_add (CAMEL_STREAM_FILTER (filtered), filter);
g_object_unref (filter);
camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (create_data->message),
filtered, NULL, NULL);
camel_stream_flush (filtered, NULL, NULL);
camel_stream_flush (mem, NULL, NULL);
bytes = camel_stream_mem_get_byte_array (CAMEL_STREAM_MEM (mem));
base64 = g_base64_encode (bytes->data, bytes->len);
g_object_unref (mem);
g_object_unref (filtered);
e_soap_message_write_string (msg, base64);
g_free (base64);
e_soap_message_end_element (msg); /* MimeContent */
content_type = camel_mime_part_get_content_type (CAMEL_MIME_PART (create_data->message));
if (content_type && camel_content_type_is (content_type, "multipart", "report") &&
camel_content_type_param (content_type, "report-type") &&
g_ascii_strcasecmp (camel_content_type_param (content_type, "report-type"), "disposition-notification") == 0) {
/* it's a disposition notification reply, set ItemClass too */
e_soap_message_start_element (msg, "ItemClass", NULL, NULL);
e_soap_message_write_string (msg, "REPORT.IPM.NOTE.IPNRN");
e_soap_message_end_element (msg); /* ItemClass */
}
e_ews_message_write_string_parameter_with_attribute (
msg,
"Importance",
NULL,
(message_camel_flags & CAMEL_MESSAGE_FLAGGED) != 0 ? "High" : "Normal",
NULL,
NULL);
/* more MAPI crap. You can't just set the IsDraft property
* here you have to use the MAPI MSGFLAG_UNSENT extended
* property Further crap is that Exchange 2007 assumes when it
* sees this property that you're setting the value to 0
* ... it never checks */
msgflag = MAPI_MSGFLAG_READ; /* draft or sent is always read */
if ((message_camel_flags & CAMEL_MESSAGE_DRAFT) != 0)
msgflag |= MAPI_MSGFLAG_UNSENT;
e_ews_message_add_extended_property_tag_int (msg, 0x0e07, msgflag);
if ((message_camel_flags & (CAMEL_MESSAGE_FORWARDED | CAMEL_MESSAGE_ANSWERED)) != 0) {
gint icon;
icon = (message_camel_flags & CAMEL_MESSAGE_ANSWERED) != 0 ? 0x105 : 0x106;
e_ews_message_add_extended_property_tag_int (msg, 0x1080, icon);
}
if (create_data->info) {
const gchar *followup, *completed, *dueby;
time_t completed_tt = (time_t) 0 , dueby_tt = (time_t) 0;
/* follow-up flags */
followup = camel_message_info_user_tag (create_data->info, "follow-up");
completed = camel_message_info_user_tag (create_data->info, "completed-on");
dueby = camel_message_info_user_tag (create_data->info, "due-by");
if (followup && !*followup)
followup = NULL;
if (completed && *completed)
completed_tt = camel_header_decode_date (completed, NULL);
if (dueby && *dueby)
dueby_tt = camel_header_decode_date (dueby, NULL);
/* PidTagFlagStatus */
e_ews_message_add_extended_property_tag_int (msg, 0x1090,
followup ? (completed_tt != (time_t) 0 ? 0x01 /* followupComplete */: 0x02 /* followupFlagged */) : 0x0);
if (followup) {
/* PidLidFlagRequest */
e_ews_message_add_extended_property_distinguished_tag_string (msg, "Common", 0x8530, followup);
/* PidTagToDoItemFlags */
e_ews_message_add_extended_property_tag_int (msg, 0x0e2b, 1);
}
if (followup && completed_tt != (time_t) 0) {
/* minute precision */
completed_tt = completed_tt - (completed_tt % 60);
/* PidTagFlagCompleteTime */
e_ews_message_add_extended_property_tag_time (msg, 0x1091, completed_tt);
/* PidLidTaskDateCompleted */
e_ews_message_add_extended_property_distinguished_tag_time (msg, "Task", 0x810f, completed_tt);
/* PidLidTaskStatus */
e_ews_message_add_extended_property_distinguished_tag_int (msg, "Task", 0x8101, 2);
/* PidLidPercentComplete */
e_ews_message_add_extended_property_distinguished_tag_double (msg, "Task", 0x8102, 1.0);
/* PidLidTaskComplete */
e_ews_message_add_extended_property_distinguished_tag_boolean (msg, "Task", 0x811c, TRUE);
}
if (followup && dueby_tt != (time_t) 0 && completed_tt == (time_t) 0) {
/* PidLidTaskStatus */
e_ews_message_add_extended_property_distinguished_tag_int (msg, "Task", 0x8101, 0);
/* PidLidPercentComplete */
e_ews_message_add_extended_property_distinguished_tag_double (msg, "Task", 0x8102, 0.0);
/* PidLidTaskDueDate */
e_ews_message_add_extended_property_distinguished_tag_time (msg, "Task", 0x8105, dueby_tt);
/* PidLidTaskComplete */
e_ews_message_add_extended_property_distinguished_tag_boolean (msg, "Task", 0x811c, FALSE);
}
}
if (create_data->recipients) {
GHashTable *recip_to, *recip_cc, *recip_bcc;
recip_to = g_hash_table_new (camel_strcase_hash, camel_strcase_equal);
recip_cc = g_hash_table_new (camel_strcase_hash, camel_strcase_equal);
recip_bcc = g_hash_table_new (camel_strcase_hash, camel_strcase_equal);
filter_recipients (create_data->message, create_data->recipients, recip_to, recip_cc, recip_bcc);
write_recipients (msg, "ToRecipients", recip_to);
write_recipients (msg, "CcRecipients", recip_cc);
write_recipients (msg, "BccRecipients", recip_bcc);
g_hash_table_destroy (recip_to);
g_hash_table_destroy (recip_cc);
g_hash_table_destroy (recip_bcc);
}
e_ews_message_write_string_parameter_with_attribute (
msg,
"IsRead",
NULL,
(message_camel_flags & CAMEL_MESSAGE_SEEN) != 0 ? "true" : "false",
NULL,
NULL);
e_soap_message_end_element (msg); /* Message */
g_free (create_data);
}
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
nntp_folder_append_message_sync (CamelFolder *folder,
CamelMimeMessage *message,
CamelMessageInfo *info,
gchar **appended_uid,
GCancellable *cancellable,
GError **error)
{
CamelStore *parent_store;
CamelNNTPStore *nntp_store;
CamelNNTPStream *nntp_stream = NULL;
CamelStream *filtered_stream;
CamelMimeFilter *crlffilter;
gint ret;
guint u;
struct _camel_header_raw *header, *savedhdrs, *n, *tail;
const gchar *full_name;
gchar *group, *line;
gboolean success = TRUE;
GError *local_error = NULL;
full_name = camel_folder_get_full_name (folder);
parent_store = camel_folder_get_parent_store (folder);
nntp_store = CAMEL_NNTP_STORE (parent_store);
/* send 'POST' command */
ret = camel_nntp_command (
nntp_store, cancellable, error, NULL, &line, "post");
if (ret != 340) {
if (ret == 440) {
g_set_error (
error, CAMEL_FOLDER_ERROR,
CAMEL_FOLDER_ERROR_INSUFFICIENT_PERMISSION,
_("Posting failed: %s"), line);
success = FALSE;
} else if (ret != -1) {
g_set_error (
error, CAMEL_ERROR,
CAMEL_ERROR_GENERIC,
_("Posting failed: %s"), line);
success = FALSE;
}
goto exit;
}
/* the 'Newsgroups: ' header */
group = g_strdup_printf ("Newsgroups: %s\r\n", full_name);
/* remove mail 'To', 'CC', and 'BCC' headers */
savedhdrs = NULL;
tail = (struct _camel_header_raw *) &savedhdrs;
header = (struct _camel_header_raw *) &CAMEL_MIME_PART (message)->headers;
n = header->next;
while (n != NULL) {
if (!g_ascii_strcasecmp (n->name, "To") || !g_ascii_strcasecmp (n->name, "Cc") || !g_ascii_strcasecmp (n->name, "Bcc")) {
header->next = n->next;
tail->next = n;
n->next = NULL;
tail = n;
} else {
header = n;
}
n = header->next;
}
nntp_stream = camel_nntp_store_ref_stream (nntp_store);
/* setup stream filtering */
filtered_stream = camel_stream_filter_new (CAMEL_STREAM (nntp_stream));
crlffilter = camel_mime_filter_crlf_new (
CAMEL_MIME_FILTER_CRLF_ENCODE,
CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS);
camel_stream_filter_add (
CAMEL_STREAM_FILTER (filtered_stream), crlffilter);
g_object_unref (crlffilter);
/* write the message */
if (local_error == NULL)
camel_stream_write (
CAMEL_STREAM (nntp_stream),
group, strlen (group),
cancellable, &local_error);
if (local_error == NULL)
camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (message),
filtered_stream, cancellable, &local_error);
if (local_error == NULL)
camel_stream_flush (
filtered_stream, cancellable, &local_error);
if (local_error == NULL)
camel_stream_write (
CAMEL_STREAM (nntp_stream),
"\r\n.\r\n", 5,
cancellable, &local_error);
if (local_error == NULL)
camel_nntp_stream_line (
nntp_stream, (guchar **) &line,
&u, cancellable, &local_error);
if (local_error == NULL && atoi (line) != 240)
local_error = g_error_new_literal (
CAMEL_ERROR, CAMEL_ERROR_GENERIC, line);
if (local_error != NULL) {
g_propagate_prefixed_error (
error, local_error, _("Posting failed: "));
success = FALSE;
}
g_object_unref (filtered_stream);
g_free (group);
header->next = savedhdrs;
exit:
g_clear_object (&nntp_stream);
return success;
}
static void
nntp_folder_append_message_online (CamelFolder *folder, CamelMimeMessage *mime_message,
const CamelMessageInfo *info, char **appended_uid,
CamelException *ex)
{
CamelNNTPStore *nntp_store = (CamelNNTPStore *) folder->parent_store;
CamelStream *stream = (CamelStream*)nntp_store->stream;
CamelStreamFilter *filtered_stream;
CamelMimeFilter *crlffilter;
int ret;
unsigned int u;
struct _camel_header_raw *header, *savedhdrs, *n, *tail;
char *group, *line;
CAMEL_SERVICE_REC_LOCK(nntp_store, connect_lock);
/* send 'POST' command */
ret = camel_nntp_command (nntp_store, ex, NULL, &line, "post");
if (ret != 340) {
if (ret == 440)
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INSUFFICIENT_PERMISSION,
_("Posting failed: %s"), line);
else if (ret != -1)
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Posting failed: %s"), line);
CAMEL_SERVICE_REC_UNLOCK(nntp_store, connect_lock);
return;
}
/* the 'Newsgroups: ' header */
group = g_strdup_printf ("Newsgroups: %s\r\n", folder->full_name);
/* setup stream filtering */
crlffilter = camel_mime_filter_crlf_new (CAMEL_MIME_FILTER_CRLF_ENCODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_DOTS);
filtered_stream = camel_stream_filter_new_with_stream (stream);
camel_stream_filter_add (filtered_stream, crlffilter);
camel_object_unref (crlffilter);
/* remove mail 'To', 'CC', and 'BCC' headers */
savedhdrs = NULL;
tail = (struct _camel_header_raw *) &savedhdrs;
header = (struct _camel_header_raw *) &CAMEL_MIME_PART (mime_message)->headers;
n = header->next;
while (n != NULL) {
if (!g_ascii_strcasecmp (n->name, "To") || !g_ascii_strcasecmp (n->name, "Cc") || !g_ascii_strcasecmp (n->name, "Bcc")) {
header->next = n->next;
tail->next = n;
n->next = NULL;
tail = n;
} else {
header = n;
}
n = header->next;
}
/* write the message */
if (camel_stream_write(stream, group, strlen(group)) == -1
|| camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (mime_message), CAMEL_STREAM (filtered_stream)) == -1
|| camel_stream_flush (CAMEL_STREAM (filtered_stream)) == -1
|| camel_stream_write (stream, "\r\n.\r\n", 5) == -1
|| (ret = camel_nntp_stream_line (nntp_store->stream, (unsigned char **)&line, &u)) == -1) {
if (errno == EINTR)
camel_exception_setv (ex, CAMEL_EXCEPTION_USER_CANCEL, _("User canceled"));
else
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Posting failed: %s"), g_strerror (errno));
} else if (atoi(line) != 240) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Posting failed: %s"), line);
}
camel_object_unref (filtered_stream);
g_free(group);
header->next = savedhdrs;
CAMEL_SERVICE_REC_UNLOCK(nntp_store, connect_lock);
return;
}
static gboolean
empe_inlinepgp_signed_parse (EMailParserExtension *extension,
EMailParser *parser,
CamelMimePart *part,
GString *part_id,
GCancellable *cancellable,
GQueue *out_mail_parts)
{
CamelStream *filtered_stream;
CamelMimeFilterPgp *pgp_filter;
CamelContentType *content_type;
CamelCipherContext *cipher;
CamelCipherValidity *valid;
CamelDataWrapper *dw;
CamelMimePart *opart;
CamelStream *ostream;
GQueue work_queue = G_QUEUE_INIT;
GList *head, *link;
gchar *type;
gint len;
GError *local_error = NULL;
GByteArray *ba;
if (g_cancellable_is_cancelled (cancellable) ||
/* avoid recursion */
(part_id->str && part_id->len > 17 && g_str_has_suffix (part_id->str, ".inlinepgp_signed")))
return FALSE;
cipher = camel_gpg_context_new (e_mail_parser_get_session (parser));
/* Verify the signature of the message */
valid = camel_cipher_context_verify_sync (
cipher, part, cancellable, &local_error);
if (local_error != NULL) {
e_mail_parser_error (
parser, out_mail_parts,
_("Error verifying signature: %s"),
local_error->message);
g_error_free (local_error);
e_mail_parser_parse_part_as (
parser, part, part_id,
"application/vnd.evolution.source",
cancellable, out_mail_parts);
g_object_unref (cipher);
return TRUE;
}
/* Setup output stream */
ostream = camel_stream_mem_new ();
filtered_stream = camel_stream_filter_new (ostream);
/* Add PGP header / footer filter */
pgp_filter = (CamelMimeFilterPgp *) camel_mime_filter_pgp_new ();
camel_stream_filter_add (
CAMEL_STREAM_FILTER (filtered_stream),
CAMEL_MIME_FILTER (pgp_filter));
g_object_unref (pgp_filter);
/* Pass through the filters that have been setup */
dw = camel_medium_get_content ((CamelMedium *) part);
camel_data_wrapper_decode_to_stream_sync (
dw, (CamelStream *) filtered_stream, cancellable, NULL);
camel_stream_flush ((CamelStream *) filtered_stream, cancellable, NULL);
g_object_unref (filtered_stream);
/* Create a new text/plain MIME part containing the signed
* content preserving the original part's Content-Type params. */
content_type = camel_mime_part_get_content_type (part);
type = camel_content_type_format (content_type);
content_type = camel_content_type_decode (type);
g_free (type);
g_free (content_type->type);
content_type->type = g_strdup ("text");
g_free (content_type->subtype);
content_type->subtype = g_strdup ("plain");
type = camel_content_type_format (content_type);
camel_content_type_unref (content_type);
ba = camel_stream_mem_get_byte_array ((CamelStreamMem *) ostream);
opart = camel_mime_part_new ();
camel_mime_part_set_content (opart, (gchar *) ba->data, ba->len, type);
g_free (type);
len = part_id->len;
g_string_append (part_id, ".inlinepgp_signed");
e_mail_parser_parse_part (
parser, opart, part_id, cancellable, &work_queue);
head = g_queue_peek_head_link (&work_queue);
for (link = head; link != NULL; link = g_list_next (link)) {
EMailPart *mail_part = link->data;
e_mail_part_update_validity (
mail_part, valid,
E_MAIL_PART_VALIDITY_SIGNED |
E_MAIL_PART_VALIDITY_PGP);
}
e_queue_transfer (&work_queue, out_mail_parts);
g_string_truncate (part_id, len);
/* Add a widget with details about the encryption, but only when
* the encrypted isn't itself secured, in that case it has created
* the button itself */
if (!e_mail_part_is_secured (opart)) {
EMailPart *mail_part;
g_string_append (part_id, ".inlinepgp_signed.button");
e_mail_parser_parse_part_as (
parser, part, part_id,
"application/vnd.evolution.widget.secure-button",
cancellable, &work_queue);
mail_part = g_queue_peek_head (&work_queue);
if (mail_part != NULL)
e_mail_part_update_validity (
mail_part, valid,
E_MAIL_PART_VALIDITY_SIGNED |
E_MAIL_PART_VALIDITY_PGP);
e_queue_transfer (&work_queue, out_mail_parts);
g_string_truncate (part_id, len);
}
/* Clean Up */
camel_cipher_validity_free (valid);
g_object_unref (opart);
g_object_unref (ostream);
g_object_unref (cipher);
return TRUE;
}
