static void *
worker(void *d)
{
int i;
CamelException *ex = camel_exception_new();
CamelStore *store;
CamelFolder *folder;
for (i=0;i<MAX_LOOP;i++) {
store = camel_session_get_store(session, path, ex);
camel_exception_clear(ex);
folder = camel_store_get_folder(store, "testbox", CAMEL_STORE_FOLDER_CREATE, ex);
camel_exception_clear(ex);
if (testid == 0) {
camel_object_unref(folder);
camel_object_unref(store);
} else {
camel_object_unref(store);
camel_object_unref(folder);
}
}
camel_exception_free(ex);
return NULL;
}
/**
* mail_importer_add_line:
* importer: A MailImporter structure.
* str: Next line of the mbox.
* finished: TRUE if @str is the last line of the message.
*
* Adds lines to the message until it is finished, and then adds
* the complete message to the folder.
*/
void
mail_importer_add_line (MailImporter *importer,
const char *str,
gboolean finished)
{
CamelMimeMessage *msg;
CamelMessageInfo *info;
CamelException *ex;
if (importer->mstream == NULL)
importer->mstream = CAMEL_STREAM_MEM (camel_stream_mem_new ());
camel_stream_write (CAMEL_STREAM (importer->mstream), str, strlen (str));
if (finished == FALSE)
return;
camel_stream_reset (CAMEL_STREAM (importer->mstream));
info = camel_message_info_new(NULL);
camel_message_info_set_flags(info, CAMEL_MESSAGE_SEEN, ~0);
msg = camel_mime_message_new ();
camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg),
CAMEL_STREAM (importer->mstream));
camel_object_unref (importer->mstream);
importer->mstream = NULL;
ex = camel_exception_new ();
camel_folder_append_message (importer->folder, msg, info, NULL, ex);
camel_object_unref (msg);
camel_exception_free (ex);
camel_message_info_free(info);
}
static void
eme_target_free(EEvent *ep, EEventTarget *t)
{
switch (t->type) {
case EM_EVENT_TARGET_FOLDER: {
EMEventTargetFolder *s = (EMEventTargetFolder *)t;
g_free (s->name);
g_free(s->uri);
break; }
case EM_EVENT_TARGET_MESSAGE: {
EMEventTargetMessage *s = (EMEventTargetMessage *)t;
if (s->folder)
camel_object_unref(s->folder);
if (s->message)
camel_object_unref(s->message);
g_free(s->uid);
break; }
case EM_EVENT_TARGET_COMPOSER : {
EMEventTargetComposer *s = (EMEventTargetComposer *)t;
if (s->composer)
g_object_unref (s->composer);
break; }
}
((EEventClass *)eme_parent)->target_free(ep, t);
}
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 void
free_data(struct _save_data *data)
{
if (data->msg)
camel_object_unref(data->msg);
g_free(data->base);
g_free(data->path);
g_free(data->uid);
camel_object_unref(data->folder);
if (data->model)
g_object_unref(data->model);
g_free(data);
}
static GByteArray *
anon_challenge (CamelSasl *sasl, GByteArray *token, CamelException *ex)
{
CamelSaslAnonymous *sasl_anon = CAMEL_SASL_ANONYMOUS (sasl);
CamelInternetAddress *cia;
GByteArray *ret = NULL;
if (token) {
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Authentication failed."));
return NULL;
}
switch (sasl_anon->type) {
case CAMEL_SASL_ANON_TRACE_EMAIL:
cia = camel_internet_address_new ();
if (camel_internet_address_add (cia, NULL, sasl_anon->trace_info) != 1) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Invalid email address trace information:\n%s"),
sasl_anon->trace_info);
camel_object_unref (cia);
return NULL;
}
camel_object_unref (cia);
ret = g_byte_array_new ();
g_byte_array_append (ret, (guint8 *) sasl_anon->trace_info, strlen (sasl_anon->trace_info));
break;
case CAMEL_SASL_ANON_TRACE_OPAQUE:
if (strchr (sasl_anon->trace_info, '@')) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Invalid opaque trace information:\n%s"),
sasl_anon->trace_info);
return NULL;
}
ret = g_byte_array_new ();
g_byte_array_append (ret, (guint8 *) sasl_anon->trace_info, strlen (sasl_anon->trace_info));
break;
case CAMEL_SASL_ANON_TRACE_EMPTY:
ret = g_byte_array_new ();
break;
default:
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Invalid trace information:\n%s"),
sasl_anon->trace_info);
return NULL;
}
sasl->authenticated = TRUE;
return ret;
}
static void
nntp_folder_cache_message (CamelDiscoFolder *disco_folder, const char *uid, CamelException *ex)
{
CamelNNTPStore *nntp_store = (CamelNNTPStore *)((CamelFolder *) disco_folder)->parent_store;
CamelStream *stream;
char *article, *msgid;
article = alloca(strlen(uid)+1);
strcpy(article, uid);
msgid = strchr(article, ',');
if (!msgid) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Internal error: UID in invalid format: %s"), uid);
return;
}
*msgid++ = 0;
CAMEL_SERVICE_REC_LOCK(nntp_store, connect_lock);
stream = nntp_folder_download_message ((CamelNNTPFolder *) disco_folder, article, msgid, ex);
if (stream)
camel_object_unref (stream);
CAMEL_SERVICE_REC_UNLOCK(nntp_store, connect_lock);
}
/**
* camel_imap_message_cache_copy:
* @source: the source message cache
* @source_uid: UID of a message in @source
* @dest: the destination message cache
* @dest_uid: UID of the message in @dest
*
* Copies all cached parts from @source_uid in @source to @dest_uid in
* @destination.
**/
void
camel_imap_message_cache_copy (CamelImapMessageCache *source,
const char *source_uid,
CamelImapMessageCache *dest,
const char *dest_uid,
CamelException *ex)
{
GPtrArray *subparts;
CamelStream *stream;
char *part;
int i;
subparts = g_hash_table_lookup (source->parts, source_uid);
if (!subparts || !subparts->len)
return;
for (i = 0; i < subparts->len; i++) {
part = strchr (subparts->pdata[i], '.');
if (!part++)
continue;
if ((stream = camel_imap_message_cache_get (source, source_uid, part, ex))) {
camel_imap_message_cache_insert_stream (dest, dest_uid, part, stream, ex);
camel_object_unref (CAMEL_OBJECT (stream));
}
}
}
static CamelStream *
insert_setup (CamelImapMessageCache *cache, const char *uid, const char *part_spec,
char **path, char **key, CamelException *ex)
{
CamelStream *stream;
int fd;
#ifdef G_OS_WIN32
/* Trailing periods in file names are silently dropped on
* Win32, argh. The code in this file requires the period to
* be there. So in case part_spec is empty, use a tilde (just
* a random choice) instead.
*/
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_object_unref (CAMEL_OBJECT (stream));
fd = g_open (*path, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0600);
if (fd == -1) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Failed to cache message %s: %s"),
uid, g_strerror (errno));
g_free (*path);
return NULL;
}
return camel_stream_fs_new_with_fd (fd);
}
/* there is also an identical copy of this in camel-filter-search.c */
gboolean
camel_search_message_body_contains (CamelDataWrapper *object, regex_t *pattern)
{
CamelDataWrapper *containee;
int truth = FALSE;
int parts, i;
containee = camel_medium_get_content_object (CAMEL_MEDIUM (object));
if (containee == NULL)
return FALSE;
/* using the object types is more accurate than using the mime/types */
if (CAMEL_IS_MULTIPART (containee)) {
parts = camel_multipart_get_number (CAMEL_MULTIPART (containee));
for (i = 0; i < parts && truth == FALSE; i++) {
CamelDataWrapper *part = (CamelDataWrapper *)camel_multipart_get_part (CAMEL_MULTIPART (containee), i);
if (part)
truth = camel_search_message_body_contains (part, pattern);
}
} else if (CAMEL_IS_MIME_MESSAGE (containee)) {
/* for messages we only look at its contents */
truth = camel_search_message_body_contains ((CamelDataWrapper *)containee, pattern);
} else if (camel_content_type_is(CAMEL_DATA_WRAPPER (containee)->mime_type, "text", "*")) {
/* for all other text parts, we look inside, otherwise we dont care */
CamelStreamMem *mem = (CamelStreamMem *)camel_stream_mem_new ();
camel_data_wrapper_write_to_stream (containee, CAMEL_STREAM (mem));
camel_stream_write (CAMEL_STREAM (mem), "", 1);
truth = regexec (pattern, (char *) mem->buffer->data, 0, NULL, 0) == 0;
camel_object_unref (mem);
}
return truth;
}
static void
impl_dispose (GObject *object)
{
MailComponentPrivate *priv = MAIL_COMPONENT (object)->priv;
view_changed_timeout_remove ((EComponentView *)object);
if (priv->activity_handler != NULL) {
g_object_unref (priv->activity_handler);
priv->activity_handler = NULL;
}
if (priv->search_context != NULL) {
g_object_unref (priv->search_context);
priv->search_context = NULL;
}
if (priv->local_store != NULL) {
camel_object_unref (priv->local_store);
priv->local_store = NULL;
}
priv->component_view = NULL;
(* G_OBJECT_CLASS (parent_class)->dispose) (object);
}
static void
mc_add_local_store(CamelStore *store, const char *name, MailComponent *mc)
{
mc_add_store(mc, store, name, mc_add_local_store_done);
camel_object_unref(store);
g_object_unref(mc);
}
static void
store_info_unref(struct _store_info *si)
{
if (si->ref_count > 1) {
si->ref_count--;
return;
}
if (si->vtrash)
camel_object_unref(si->vtrash);
if (si->vjunk)
camel_object_unref(si->vjunk);
camel_object_unref(si->store);
g_free(si->name);
g_free(si);
}
/**
* camel_imap_message_cache_remove:
* @cache: the cache
* @uid: UID of the data to remove
*
* Removes all data associated with @uid from @cache.
**/
void
camel_imap_message_cache_remove (CamelImapMessageCache *cache, const char *uid)
{
GPtrArray *subparts;
char *key, *path;
CamelObject *stream;
int i;
subparts = g_hash_table_lookup (cache->parts, uid);
if (!subparts)
return;
for (i = 0; i < subparts->len; i++) {
key = subparts->pdata[i];
path = g_strdup_printf ("%s/%s", cache->path, key);
g_unlink (path);
g_free (path);
stream = g_hash_table_lookup (cache->parts, key);
if (stream) {
camel_object_unhook_event (stream, "finalize",
stream_finalize, cache);
camel_object_unref (stream);
g_hash_table_remove (cache->cached, stream);
}
g_hash_table_remove (cache->parts, key);
g_free (key);
}
g_hash_table_remove (cache->parts, uid);
g_ptr_array_free (subparts, TRUE);
}
static char *
save_attachment (CamelMimePart * part, const char *uid,
const char *attachment_store)
{
CamelDataWrapper *content;
CamelStream *stream = NULL;
CamelStreamFs *stream_fs;
char *attach_file = NULL;
char *file_url = NULL;
const char *mime_filename;
content = camel_medium_get_content_object (CAMEL_MEDIUM (part));
mime_filename = camel_mime_part_get_filename (part);
attach_file = g_strdup_printf ("%s/%s-%s",
attachment_store, uid, mime_filename);
stream = camel_stream_fs_new_with_name (attach_file,
O_RDWR | O_CREAT | O_TRUNC, 0600);
if (stream == NULL)
goto end;
stream_fs = (CamelStreamFs *) stream;
camel_data_wrapper_decode_to_stream (content, stream);
file_url = g_strdup_printf ("file://%s", attach_file);
end:
g_free (attach_file);
camel_object_unref (stream);
return file_url;
}
static void
close_folder (gpointer name, gpointer folder, gpointer data)
{
g_free (name);
camel_folder_sync (folder, FALSE, NULL);
camel_object_unref (folder);
}
/**
* camel_imap_command:
* @store: the IMAP store
* @folder: The folder to perform the operation in (or %NULL if not
* relevant).
* @ex: a CamelException
* @fmt: a sort of printf-style format string, followed by arguments
*
* This function calls camel_imap_command_start() to send the
* command, then reads the complete response to it using
* camel_imap_command_response() and returns a CamelImapResponse
* structure.
*
* As a special case, if @fmt is %NULL, it will just select @folder
* and return the response from doing so.
*
* See camel_imap_command_start() for details on @fmt.
*
* On success, the store's connect_lock will be locked. It will be freed
* when you call camel_imap_response_free. (The lock is recursive, so
* callers can grab and release it themselves if they need to run
* multiple commands atomically.)
*
* Return value: %NULL if an error occurred (in which case @ex will
* be set). Otherwise, a CamelImapResponse describing the server's
* response, which the caller must free with camel_imap_response_free().
**/
CamelImapResponse *
camel_imap_command (CamelImapStore *store, CamelFolder *folder,
CamelException *ex, const char *fmt, ...)
{
va_list ap;
char *cmd;
CAMEL_SERVICE_REC_LOCK (store, connect_lock);
if (fmt) {
va_start (ap, fmt);
cmd = imap_command_strdup_vprintf (store, fmt, ap);
va_end (ap);
} else {
camel_object_ref(folder);
if (store->current_folder)
camel_object_unref(store->current_folder);
store->current_folder = folder;
cmd = imap_command_strdup_printf (store, "SELECT %F", folder->full_name);
}
if (!imap_command_start (store, folder, cmd, ex)) {
g_free (cmd);
CAMEL_SERVICE_REC_UNLOCK (store, connect_lock);
return NULL;
}
g_free (cmd);
return imap_read_response (store, ex);
}
static CamelStream *
insert_abort (char *path, CamelStream *stream)
{
g_unlink (path);
g_free (path);
camel_object_unref (CAMEL_OBJECT (stream));
return NULL;
}
static void
camel_mime_filter_html_finalize(CamelObject *o)
{
CamelMimeFilterHTML *f = (CamelMimeFilterHTML *)o;
camel_object_unref((CamelObject *)f->priv->ctxt);
g_free(f->priv);
}
static void
camel_pop3_stream_finalise(CamelPOP3Stream *is)
{
g_free(is->buf);
g_free(is->linebuf);
if (is->source)
camel_object_unref((CamelObject *)is->source);
}
static void
reset(CamelMimeFilter *mf)
{
CamelMimeFilterHTML *f = (CamelMimeFilterHTML *)mf;
camel_object_unref((CamelObject *)f->priv->ctxt);
f->priv->ctxt = camel_html_parser_new();
}
static int
groupwise_entry_play_append (CamelOfflineJournal *journal, CamelGroupwiseJournalEntry *entry, CamelException *ex)
{
CamelGroupwiseFolder *gw_folder = (CamelGroupwiseFolder *) journal->folder;
CamelFolder *folder = journal->folder;
CamelMimeMessage *message;
CamelMessageInfo *info;
CamelStream *stream;
CamelException lex;
/* if the message isn't in the cache, the user went behind our backs so "not our problem" */
if (!gw_folder->cache || !(stream = camel_data_cache_get (gw_folder->cache, "cache", entry->uid, ex)))
goto done;
message = camel_mime_message_new ();
if (camel_data_wrapper_construct_from_stream ((CamelDataWrapper *) message, stream) == -1) {
camel_object_unref (message);
camel_object_unref (stream);
goto done;
}
camel_object_unref (stream);
if (!(info = camel_folder_summary_uid (folder->summary, entry->uid))) {
/* Note: this should never happen, but rather than crash lets make a new info */
info = camel_message_info_new (NULL);
}
camel_exception_init (&lex);
camel_folder_append_message (folder, message, info, NULL, &lex);
camel_message_info_free (info);
camel_object_unref (message);
if (camel_exception_is_set (&lex)) {
camel_exception_xfer (ex, &lex);
return -1;
}
done:
camel_folder_summary_remove_uid (folder->summary, entry->uid);
camel_data_cache_remove (gw_folder->cache, "cache", entry->uid, NULL);
return 0;
}
static void
camel_vee_store_finalise (CamelObject *obj)
{
CamelVeeStore *vstore = (CamelVeeStore *)obj;
g_hash_table_foreach(vstore->unmatched_uids, cvs_free_unmatched, NULL);
g_hash_table_destroy(vstore->unmatched_uids);
camel_object_unref(vstore->folder_unmatched);
}
static void
camel_seekable_substream_finalize (CamelObject *object)
{
CamelSeekableSubstream *seekable_substream =
CAMEL_SEEKABLE_SUBSTREAM (object);
if (seekable_substream->parent_stream)
camel_object_unref (seekable_substream->parent_stream);
}
static void
free_folder_info(struct _folder_info *info)
{
/*camel_folder_thaw (info->folder); */
mail_sync_folder(info->folder, NULL, NULL);
camel_object_unref(info->folder);
g_free(info->uri);
g_free(info);
}
static void
camel_stream_filter_finalize(CamelObject *o)
{
CamelStreamFilter *filter = (CamelStreamFilter *)o;
struct _CamelStreamFilterPrivate *p = _PRIVATE(filter);
struct _filter *fn, *f;
f = p->filters;
while (f) {
fn = f->next;
camel_object_unref((CamelObject *)f->filter);
g_free(f);
f = fn;
}
g_free(p->realbuffer);
g_free(p);
camel_object_unref((CamelObject *)filter->source);
}
static int
groupwise_entry_play_transfer (CamelOfflineJournal *journal, CamelGroupwiseJournalEntry *entry, CamelException *ex)
{
CamelGroupwiseFolder *gw_folder = (CamelGroupwiseFolder *) journal->folder;
CamelFolder *folder = journal->folder;
CamelGroupwiseMessageInfo *real;
CamelMessageInfoBase *info;
GPtrArray *xuids, *uids;
CamelException lex;
CamelFolder *src;
const char *name;
if (!(info = (CamelMessageInfoBase *) camel_folder_summary_uid (folder->summary, entry->uid))) {
/* Note: this should never happen, but rather than crash lets make a new info */
info = camel_message_info_new (NULL);
}
name = camel_groupwise_store_folder_lookup ((CamelGroupwiseStore *) folder->parent_store, entry->source_container);
if (name && (src = camel_store_get_folder (folder->parent_store, name, 0, ex))) {
uids = g_ptr_array_sized_new (1);
g_ptr_array_add (uids, entry->original_uid);
camel_exception_init (&lex);
camel_folder_transfer_messages_to (src, uids, folder, &xuids, FALSE, &lex);
if (!camel_exception_is_set (&lex)) {
real = (CamelGroupwiseMessageInfo *) camel_folder_summary_uid (folder->summary, xuids->pdata[0]);
/* transfer all the system flags, user flags/tags, etc */
gw_message_info_dup_to ((CamelMessageInfoBase *) real, (CamelMessageInfoBase *) info);
camel_message_info_free (real);
} else {
camel_exception_xfer (ex, &lex);
goto exception;
}
g_ptr_array_free (xuids, TRUE);
g_ptr_array_free (uids, TRUE);
camel_object_unref (src);
} else if (!name) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot get folder container %s"),
entry->source_container);
goto exception;
}
/* message was successfully transferred, remove the fake item from the cache/summary */
camel_folder_summary_remove_uid (folder->summary, entry->uid);
camel_data_cache_remove (gw_folder->cache, "cache", entry->uid, NULL);
camel_message_info_free (info);
return 0;
exception:
camel_message_info_free (info);
return -1;
}
/**
*
* "util_get_msg_body" is based on mail-to-task eplugin's get_description function.
* which is GPL licensed.
* */
static gchar *
util_get_msg_body(CamelMimeMessage *message, gchar **text) {
CamelDataWrapper *content;
CamelStream *mem;
CamelContentType *type;
CamelMimePart *mime_part = CAMEL_MIME_PART(message);
GSList sl;
gchar *str, *convert_str = NULL;
gsize bytes_read, bytes_written;
gint count = 2;
content = camel_medium_get_content_object((CamelMedium *) message);
if (!content)
return;
/*
* Get non-multipart content from multipart message.
*/
while (CAMEL_IS_MULTIPART(content) && count > 0) {
mime_part = camel_multipart_get_part(CAMEL_MULTIPART(content), 0);
content = camel_medium_get_content_object(CAMEL_MEDIUM(mime_part));
count--;
}
if (!mime_part)
return;
type = camel_mime_part_get_content_type(mime_part);
if (!camel_content_type_is(type, "text", "plain"))
return;
mem = camel_stream_mem_new();
camel_data_wrapper_decode_to_stream(content, mem);
str = g_strndup((const gchar *) ((CamelStreamMem *) mem)->buffer->data, ((CamelStreamMem *) mem)->buffer->len);
camel_object_unref(mem);
/* convert to UTF-8 string */
if (str && content->mime_type->params && content->mime_type->params->value) {
convert_str = g_convert(str, strlen(str),
"UTF-8", content->mime_type->params->value,
&bytes_read, &bytes_written, NULL);
}
if (convert_str)
*text = convert_str;
else
*text = str;
/*g_free (str);
if (convert_str)
g_free (convert_str);
*/
}
static void
camel_scalix_stream_finalize (CamelObject *object)
{
CamelSCALIXStream *scalix = (CamelSCALIXStream *) object;
if (scalix->stream)
camel_object_unref (scalix->stream);
g_free (scalix->tokenbuf);
}
static void
camel_multipart_encrypted_finalize (CamelObject *object)
{
CamelMultipartEncrypted *mpe = (CamelMultipartEncrypted *) object;
g_free (mpe->protocol);
if (mpe->decrypted)
camel_object_unref (mpe->decrypted);
}
