EMEventTargetMessage *
em_event_target_new_message(EMEvent *eme, CamelFolder *folder, CamelMimeMessage *message, const char *uid, guint32 flags)
{
EMEventTargetMessage *t = e_event_target_new(&eme->popup, EM_EVENT_TARGET_MESSAGE, sizeof(*t));
t->uid = g_strdup (uid);
t->folder = folder;
if (folder)
camel_object_ref(folder);
t->message = message;
if (message)
camel_object_ref(message);
t->target.mask = ~flags;
return t;
}
/**
* 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 gboolean
receive_update_got_folderinfo(CamelStore *store, CamelFolderInfo *info, void *data)
{
if (info) {
GPtrArray *folders = g_ptr_array_new();
struct _refresh_folders_msg *m;
struct _send_info *sinfo = data;
m = mail_msg_new(&refresh_folders_info);
m->store = store;
camel_object_ref(store);
m->folders = folders;
m->info = sinfo;
m->finfo = info;
mail_msg_unordered_push (m);
/* do not free folder info, we will free it later */
return FALSE;
} else {
receive_done ("", data);
}
return TRUE;
}
/**
* camel_mime_filter_save_new_with_stream:
* @stream: a #CamelStream object
*
* Create a new #CamelMimeFilterSave filter object that will save a
* copy of all filtered data to @stream.
*
* Returns a new #CamelMimeFilterSave object
**/
CamelMimeFilter *
camel_mime_filter_save_new_with_stream (CamelStream *stream)
{
CamelMimeFilterSave *save = CAMEL_MIME_FILTER_SAVE (camel_object_new (CAMEL_MIME_FILTER_SAVE_TYPE));
save->stream = stream;
camel_object_ref (stream);
return (CamelMimeFilter *) save;
}
static CamelFolder *get_folder(CamelFilterDriver *d, const char *uri, void *data, CamelException *ex)
{
int i;
for (i=0; i<ARRAY_LEN(mailboxes); i++)
if (!strcmp(mailboxes[i].name, uri)) {
camel_object_ref((CamelObject *)mailboxes[i].folder);
return mailboxes[i].folder;
}
return NULL;
}
EMConfigTargetFolder *
em_config_target_new_folder(EMConfig *emp, struct _CamelFolder *folder, const char *uri)
{
EMConfigTargetFolder *t = e_config_target_new(&emp->config, EM_CONFIG_TARGET_FOLDER, sizeof(*t));
t->uri = g_strdup(uri);
t->folder = folder;
camel_object_ref(folder);
return t;
}
/**
* camel_pop3_stream_new:
*
* Returns a NULL stream. A null stream is always at eof, and
* always returns success for all reads and writes.
*
* Return value: the stream
**/
CamelStream *
camel_pop3_stream_new(CamelStream *source)
{
CamelPOP3Stream *is;
is = (CamelPOP3Stream *)camel_object_new(camel_pop3_stream_get_type ());
camel_object_ref((CamelObject *)source);
is->source = source;
return (CamelStream *)is;
}
/* although we dont do anythign smart here yet, there is no need for this interface to
be available to anyone else.
This can also be used to hook into which folders are being updated, and occasionally
let them refresh */
static CamelFolder *
receive_get_folder(CamelFilterDriver *d, const char *uri, void *data, CamelException *ex)
{
struct _send_info *info = data;
CamelFolder *folder;
struct _folder_info *oldinfo;
gpointer oldkey, oldinfoptr;
g_mutex_lock(info->data->lock);
oldinfo = g_hash_table_lookup(info->data->folders, uri);
g_mutex_unlock(info->data->lock);
if (oldinfo) {
camel_object_ref(oldinfo->folder);
return oldinfo->folder;
}
folder = mail_tool_uri_to_folder (uri, 0, ex);
if (!folder)
return NULL;
/* we recheck that the folder hasn't snuck in while we were loading it... */
/* and we assume the newer one is the same, but unref the old one anyway */
g_mutex_lock(info->data->lock);
if (g_hash_table_lookup_extended (info->data->folders, uri, &oldkey, &oldinfoptr)) {
oldinfo = (struct _folder_info *) oldinfoptr;
camel_object_unref(oldinfo->folder);
oldinfo->folder = folder;
} else {
/*camel_folder_freeze (folder); */
oldinfo = g_malloc0(sizeof(*oldinfo));
oldinfo->folder = folder;
oldinfo->uri = g_strdup(uri);
g_hash_table_insert(info->data->folders, oldinfo->uri, oldinfo);
}
camel_object_ref (folder);
g_mutex_unlock(info->data->lock);
return folder;
}
static void
mc_setup_local_store(MailComponent *mc)
{
MailComponentPrivate *p = mc->priv;
CamelURL *url;
char *tmp;
CamelException ex;
int i;
g_mutex_lock(p->lock);
if (p->local_store != NULL) {
g_mutex_unlock(p->lock);
return;
}
camel_exception_init(&ex);
url = camel_url_new("mbox:", NULL);
tmp = g_build_filename (p->base_directory, "local", NULL);
camel_url_set_path(url, tmp);
g_free(tmp);
tmp = camel_url_to_string(url, 0);
p->local_store = (CamelStore *)camel_session_get_service(session, tmp, CAMEL_PROVIDER_STORE, &ex);
g_free(tmp);
if (p->local_store == NULL)
goto fail;
for (i=0;i<sizeof(mc_default_folders)/sizeof(mc_default_folders[0]);i++) {
/* FIXME: should this uri be account relative? */
camel_url_set_fragment(url, mc_default_folders[i].name);
mc_default_folders[i].uri = camel_url_to_string(url, 0);
mc_default_folders[i].folder = camel_store_get_folder(p->local_store, mc_default_folders[i].name,
CAMEL_STORE_FOLDER_CREATE, &ex);
camel_exception_clear(&ex);
}
camel_url_free(url);
g_mutex_unlock(p->lock);
g_object_ref(mc);
camel_object_ref(p->local_store);
mail_async_event_emit(p->async_event, MAIL_ASYNC_GUI, (MailAsyncFunc)mc_add_local_store, p->local_store, _("On This Computer"), mc);
return;
fail:
g_mutex_unlock(p->lock);
g_warning("Could not setup local store/folder: %s", ex.desc);
camel_url_free(url);
camel_exception_clear(&ex);
}
/**
* camel_scalix_stream_new:
* @stream: tcp stream
*
* Returns a new scalix stream
**/
CamelStream *
camel_scalix_stream_new (CamelStream *stream)
{
CamelSCALIXStream *scalix;
g_return_val_if_fail (CAMEL_IS_STREAM (stream), NULL);
scalix = (CamelSCALIXStream *) camel_object_new (CAMEL_TYPE_SCALIX_STREAM);
camel_object_ref (stream);
scalix->stream = stream;
return (CamelStream *) scalix;
}
/**
* camel_imap4_stream_new:
* @stream: tcp stream
*
* Returns a new imap4 stream
**/
CamelStream *
camel_imap4_stream_new (CamelStream *stream)
{
CamelIMAP4Stream *imap4;
g_return_val_if_fail (CAMEL_IS_STREAM (stream), NULL);
imap4 = (CamelIMAP4Stream *) camel_object_new (CAMEL_TYPE_IMAP4_STREAM);
camel_object_ref (stream);
imap4->stream = stream;
return (CamelStream *) imap4;
}
void
org_gnome_save_attachments_save(EPlugin *ep, EMMenuTargetSelect *target)
{
struct _save_data *data;
if (target->uids->len != 1)
return;
data = g_malloc0(sizeof(*data));
data->folder = target->folder;
camel_object_ref(data->folder);
data->uid = g_strdup(target->uids->pdata[0]);
mail_get_message(data->folder, data->uid, save_got_message, data, mail_msg_unordered_push);
}
/**
* camel_smime_context_new:
* @session: session
*
* Creates a new sm cipher context object.
*
* Returns a new sm cipher context object.
**/
CamelCipherContext *
camel_smime_context_new(CamelSession *session)
{
CamelCipherContext *cipher;
CamelSMIMEContext *ctx;
g_return_val_if_fail(CAMEL_IS_SESSION(session), NULL);
ctx =(CamelSMIMEContext *) camel_object_new(camel_smime_context_get_type());
cipher =(CamelCipherContext *) ctx;
cipher->session = session;
camel_object_ref(session);
return cipher;
}
static void
offline_folder_changed (CamelFolder *folder, CamelFolderChangeInfo *changes, void *dummy)
{
CamelOfflineFolder *offline = (CamelOfflineFolder *) folder;
CamelService *service = (CamelService *) folder->parent_store;
if (changes->uid_added->len > 0 && (offline->sync_offline || camel_url_get_param (service->url, "sync_offline"))) {
CamelSession *session = service->session;
struct _offline_downsync_msg *m;
m = camel_session_thread_msg_new (session, &offline_downsync_ops, sizeof (*m));
m->changes = camel_folder_change_info_new ();
camel_folder_change_info_cat (m->changes, changes);
camel_object_ref (folder);
m->folder = folder;
camel_session_thread_queue (session, &m->msg, 0);
}
}
static void *session_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
{
CamelSessionThreadMsg *m;
g_assert(size >= sizeof(*m));
m = g_malloc0(size);
m->ops = ops;
m->session = session;
camel_object_ref(session);
m->op = camel_operation_new(cs_thread_status, m);
camel_exception_init(&m->ex);
CAMEL_SESSION_LOCK(session, thread_lock);
m->id = session->priv->thread_id++;
g_hash_table_insert(session->priv->thread_active, GINT_TO_POINTER(m->id), m);
CAMEL_SESSION_UNLOCK(session, thread_lock);
return m;
}
/**
* camel_seekable_substream_new:
* @parent_stream: a #CamelSeekableStream object
* @inf_bound: a lower bound
* @sup_bound: an upper bound
*
* Creates a new CamelSeekableSubstream that references the portion
* of @parent_stream from @inf_bound to @sup_bound. (If @sup_bound is
* #CAMEL_STREAM_UNBOUND, it references to the end of stream, even if
* the stream grows.)
*
* While the substream is open, the caller cannot assume anything about
* the current position of @parent_stream. After the substream has been
* closed, @parent_stream will stabilize again.
*
* Return value: the substream
**/
CamelStream *
camel_seekable_substream_new(CamelSeekableStream *parent_stream, off_t start, off_t end)
{
CamelSeekableSubstream *seekable_substream;
g_return_val_if_fail (CAMEL_IS_SEEKABLE_STREAM (parent_stream), NULL);
/* Create the seekable substream. */
seekable_substream = CAMEL_SEEKABLE_SUBSTREAM (camel_object_new (camel_seekable_substream_get_type ()));
/* Initialize it. */
seekable_substream->parent_stream = parent_stream;
camel_object_ref (parent_stream);
/* Set the bound of the substream. We can ignore any possible error
* here, because if we fail to seek now, it will try again later.
*/
camel_seekable_stream_set_bounds ((CamelSeekableStream *)seekable_substream, start, end);
return CAMEL_STREAM (seekable_substream);
}
static struct _send_data *
setup_send_data(void)
{
struct _send_data *data;
if (send_data == NULL) {
send_data = data = g_malloc0(sizeof(*data));
data->lock = g_mutex_new();
data->folders = g_hash_table_new_full (
g_str_hash, g_str_equal,
(GDestroyNotify) NULL,
(GDestroyNotify) free_folder_info);
data->inbox = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_LOCAL_INBOX);
camel_object_ref(data->inbox);
data->active = g_hash_table_new_full (
g_str_hash, g_str_equal,
(GDestroyNotify) NULL,
(GDestroyNotify) free_send_info);
}
return send_data;
}
static void
emss_sync_op (EMSyncStream *emss, enum _write_msg_t op,
const gchar *string, gsize len)
{
struct _write_msg msg;
msg.done = e_flag_new ();
msg.emss = emss;
msg.op = op;
msg.string = string;
msg.len = len;
camel_object_ref (emss);
g_idle_add ((GSourceFunc) emss_process_message, &msg);
e_flag_wait (msg.done);
e_flag_free (msg.done);
camel_object_unref (emss);
}
static struct _store_info *
store_info_new(CamelStore *store, const char *name)
{
struct _store_info *si;
si = g_malloc0(sizeof(*si));
si->ref_count = 1;
if (name == NULL)
si->name = camel_service_get_name((CamelService *)store, TRUE);
else
si->name = g_strdup(name);
si->store = store;
camel_object_ref(store);
/* If these are vfolders then they need to be opened now,
* otherwise they wont keep track of all folders */
if ((store->flags & CAMEL_STORE_VTRASH) != 0)
si->vtrash = camel_store_get_trash(store, NULL);
if ((store->flags & CAMEL_STORE_VJUNK) != 0)
si->vjunk = camel_store_get_junk(store, NULL);
return si;
}
/**
* 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 CamelStream *
nntp_folder_download_message (CamelNNTPFolder *nntp_folder, const char *id, const char *msgid, CamelException *ex)
{
CamelNNTPStore *nntp_store = (CamelNNTPStore *) ((CamelFolder *) nntp_folder)->parent_store;
CamelStream *stream = NULL;
int ret;
char *line;
ret = camel_nntp_command (nntp_store, ex, nntp_folder, &line, "article %s", id);
if (ret == 220) {
stream = camel_data_cache_add (nntp_store->cache, "cache", msgid, NULL);
if (stream) {
if (camel_stream_write_to_stream ((CamelStream *) nntp_store->stream, stream) == -1)
goto fail;
if (camel_stream_reset (stream) == -1)
goto fail;
} else {
stream = (CamelStream *) nntp_store->stream;
camel_object_ref (stream);
}
} else if (ret == 423 || ret == 430) {
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("Cannot get message %s: %s"), msgid, line);
} else if (ret != -1) {
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot get message %s: %s"), msgid, line);
}
return stream;
fail:
if (errno == EINTR)
camel_exception_setv (ex, CAMEL_EXCEPTION_USER_CANCEL, _("User canceled"));
else
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot get message %s: %s"), msgid, g_strerror (errno));
return NULL;
}
static int
sm_sign(CamelCipherContext *context, const char *userid, CamelCipherHash hash, CamelMimePart *ipart, CamelMimePart *opart, CamelException *ex)
{
int res = -1;
NSSCMSMessage *cmsg;
CamelStream *ostream, *istream;
SECOidTag sechash;
NSSCMSEncoderContext *enc;
CamelDataWrapper *dw;
CamelContentType *ct;
switch (hash) {
case CAMEL_CIPHER_HASH_SHA1:
case CAMEL_CIPHER_HASH_DEFAULT:
default:
sechash = SEC_OID_SHA1;
break;
case CAMEL_CIPHER_HASH_MD5:
sechash = SEC_OID_MD5;
break;
}
cmsg = sm_signing_cmsmessage((CamelSMIMEContext *)context, userid, sechash,
((CamelSMIMEContext *)context)->priv->sign_mode == CAMEL_SMIME_SIGN_CLEARSIGN, ex);
if (cmsg == NULL)
return -1;
ostream = camel_stream_mem_new();
/* FIXME: stream this, we stream output at least */
istream = camel_stream_mem_new();
if (camel_cipher_canonical_to_stream(ipart,
CAMEL_MIME_FILTER_CANON_STRIP
|CAMEL_MIME_FILTER_CANON_CRLF
|CAMEL_MIME_FILTER_CANON_FROM, istream) == -1) {
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not generate signing data: %s"), g_strerror(errno));
goto fail;
}
enc = NSS_CMSEncoder_Start(cmsg,
sm_write_stream, ostream, /* DER output callback */
NULL, NULL, /* destination storage */
NULL, NULL, /* password callback */
NULL, NULL, /* decrypt key callback */
NULL, NULL ); /* detached digests */
if (!enc) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create encoder context"));
goto fail;
}
if (NSS_CMSEncoder_Update(enc, (char *) ((CamelStreamMem *)istream)->buffer->data, ((CamelStreamMem *)istream)->buffer->len) != SECSuccess) {
NSS_CMSEncoder_Cancel(enc);
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to add data to CMS encoder"));
goto fail;
}
if (NSS_CMSEncoder_Finish(enc) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to encode data"));
goto fail;
}
res = 0;
dw = camel_data_wrapper_new();
camel_stream_reset(ostream);
camel_data_wrapper_construct_from_stream(dw, ostream);
dw->encoding = CAMEL_TRANSFER_ENCODING_BINARY;
if (((CamelSMIMEContext *)context)->priv->sign_mode == CAMEL_SMIME_SIGN_CLEARSIGN) {
CamelMultipartSigned *mps;
CamelMimePart *sigpart;
sigpart = camel_mime_part_new();
ct = camel_content_type_new("application", "x-pkcs7-signature");
camel_content_type_set_param(ct, "name", "smime.p7s");
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
camel_medium_set_content_object((CamelMedium *)sigpart, dw);
camel_mime_part_set_filename(sigpart, "smime.p7s");
camel_mime_part_set_disposition(sigpart, "attachment");
camel_mime_part_set_encoding(sigpart, CAMEL_TRANSFER_ENCODING_BASE64);
mps = camel_multipart_signed_new();
ct = camel_content_type_new("multipart", "signed");
camel_content_type_set_param(ct, "micalg", camel_cipher_hash_to_id(context, hash));
camel_content_type_set_param(ct, "protocol", context->sign_protocol);
camel_data_wrapper_set_mime_type_field((CamelDataWrapper *)mps, ct);
camel_content_type_unref(ct);
camel_multipart_set_boundary((CamelMultipart *)mps, NULL);
mps->signature = sigpart;
mps->contentraw = istream;
camel_stream_reset(istream);
camel_object_ref(istream);
camel_medium_set_content_object((CamelMedium *)opart, (CamelDataWrapper *)mps);
} else {
ct = camel_content_type_new("application", "x-pkcs7-mime");
camel_content_type_set_param(ct, "name", "smime.p7m");
camel_content_type_set_param(ct, "smime-type", "signed-data");
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
camel_medium_set_content_object((CamelMedium *)opart, dw);
camel_mime_part_set_filename(opart, "smime.p7m");
camel_mime_part_set_description(opart, "S/MIME Signed Message");
camel_mime_part_set_disposition(opart, "attachment");
camel_mime_part_set_encoding(opart, CAMEL_TRANSFER_ENCODING_BASE64);
}
camel_object_unref(dw);
fail:
camel_object_unref(ostream);
camel_object_unref(istream);
return res;
}
static void
save_got_message(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *d)
{
struct _save_data *data = d;
GtkDialog *dialog;
GtkWidget *w, *tree;
GtkTreeStore *model;
GtkCellRenderer *renderer;
/* not found, the mailer will show an error box for this */
if (msg == NULL) {
free_data(data);
return;
}
data->msg = msg;
camel_object_ref(msg);
dialog = (GtkDialog *)gtk_dialog_new_with_buttons(_("Save attachments"),
NULL, /* target->parent? */
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
w = gtk_file_chooser_button_new (_("Select save base name"), GTK_FILE_CHOOSER_ACTION_OPEN);
data->entry = w;
g_object_set(w, "filechooser_action", GTK_FILE_CHOOSER_ACTION_SAVE, NULL);
gtk_widget_show(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, FALSE, TRUE, 6);
g_signal_connect(GTK_FILE_CHOOSER_BUTTON (w), "selection-changed", G_CALLBACK(entry_changed), data);
model = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
data->model = model;
fill_model(msg, model);
tree = gtk_tree_view_new_with_model((GtkTreeModel *)model);
data->tree = tree;
gtk_widget_show(tree);
gtk_tree_view_expand_all((GtkTreeView *)tree);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("MIME Type"), renderer, "text", 1, NULL);
gtk_tree_view_set_expander_column((GtkTreeView *)tree, gtk_tree_view_get_column((GtkTreeView *)tree, 0));
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "activatable", TRUE, NULL);
g_signal_connect(renderer, "toggled", G_CALLBACK(toggle_changed), data);
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Save"), renderer, "active", 0, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Name"), renderer, "text", 2, NULL);
w = g_object_new(gtk_frame_get_type(),
"shadow_type", GTK_SHADOW_NONE,
"label_widget", g_object_new(gtk_label_get_type(),
"label", "<span weight=\"bold\">Attachments</span>",
"use_markup", TRUE,
"xalign", 0.0, NULL),
"child", g_object_new(gtk_alignment_get_type(),
"left_padding", 12,
"top_padding", 6,
"child", g_object_new(gtk_scrolled_window_get_type(),
"hscrollbar_policy", GTK_POLICY_AUTOMATIC,
"vscrollbar_policy", GTK_POLICY_AUTOMATIC,
"shadow_type", GTK_SHADOW_IN,
"child", tree,
NULL),
NULL),
NULL);
gtk_widget_show_all(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, TRUE, TRUE, 0);
g_signal_connect(dialog, "response", G_CALLBACK(save_response), data);
gtk_window_set_default_size((GtkWindow *)dialog, 500, 500);
gtk_widget_show((GtkWidget *)dialog);
}
static CamelFolder *
groupwise_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex)
{
CamelGroupwiseStore *gw_store = CAMEL_GROUPWISE_STORE (store);
CamelGroupwiseStorePrivate *priv = gw_store->priv;
CamelFolder *folder;
CamelGroupwiseSummary *summary;
char *container_id, *folder_dir, *storage_path;
EGwConnectionStatus status;
GList *list = NULL;
gboolean done = FALSE, all_ok = TRUE;
const char *position = E_GW_CURSOR_POSITION_END;
int count = 0, cursor, summary_count = 0;
CamelStoreInfo *si = NULL;
guint total = 0;
folder = groupwise_get_folder_from_disk (store, folder_name, flags, ex);
if (folder) {
camel_object_ref (folder);
return folder;
}
camel_exception_clear (ex);
CAMEL_SERVICE_REC_LOCK (gw_store, connect_lock);
if (!camel_groupwise_store_connected (gw_store, ex)) {
CAMEL_SERVICE_REC_UNLOCK (gw_store, connect_lock);
return NULL;
}
if (gw_store->current_folder) {
camel_object_unref (gw_store->current_folder);
gw_store->current_folder = NULL;
}
if (!E_IS_GW_CONNECTION( priv->cnc)) {
if (!groupwise_connect (CAMEL_SERVICE(store), ex)) {
CAMEL_SERVICE_REC_UNLOCK (gw_store, connect_lock);
return NULL;
}
}
container_id = g_strdup (g_hash_table_lookup (priv->name_hash, folder_name));
storage_path = g_strdup_printf("%s/folders", priv->storage_path);
folder_dir = e_path_to_physical (storage_path, folder_name);
g_free(storage_path);
folder = camel_gw_folder_new (store, folder_name, folder_dir, ex);
if (!folder) {
CAMEL_SERVICE_REC_UNLOCK (gw_store, connect_lock);
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_INVALID, _("Authentication failed"));
g_free (folder_dir);
g_free (container_id);
return NULL;
}
g_free (folder_dir);
si = camel_store_summary_path ((CamelStoreSummary *)gw_store->summary, folder_name);
if (si) {
total = si->total;
camel_store_summary_info_free ((CamelStoreSummary *)(gw_store)->summary, si);
}
summary = (CamelGroupwiseSummary *) folder->summary;
summary_count = camel_folder_summary_count (folder->summary);
if(!summary_count || !summary->time_string) {
d(g_print ("\n\n** %s **: No summary as yet : using get cursor request\n\n", folder->name);)
CamelImapResponse *
imap_read_response (CamelImapStore *store, CamelException *ex)
{
CamelImapResponse *response;
CamelImapResponseType type;
char *respbuf, *p;
/* Get another lock so that when we reach the tagged
* response and camel_imap_command_response unlocks,
* we're still locked. This lock is owned by response
* and gets unlocked when response is freed.
*/
CAMEL_SERVICE_REC_LOCK (store, connect_lock);
response = g_new0 (CamelImapResponse, 1);
if (store->current_folder && camel_disco_store_status (CAMEL_DISCO_STORE (store)) != CAMEL_DISCO_STORE_RESYNCING) {
response->folder = store->current_folder;
camel_object_ref (CAMEL_OBJECT (response->folder));
}
response->untagged = g_ptr_array_new ();
while ((type = camel_imap_command_response (store, &respbuf, ex))
== CAMEL_IMAP_RESPONSE_UNTAGGED)
g_ptr_array_add (response->untagged, respbuf);
if (type == CAMEL_IMAP_RESPONSE_ERROR) {
camel_imap_response_free_without_processing (store, response);
return NULL;
}
response->status = respbuf;
/* Check for OK or continuation response. */
if (*respbuf == '+')
return response;
p = strchr (respbuf, ' ');
if (p && !g_ascii_strncasecmp (p, " OK", 3))
return response;
/* We should never get BAD, or anything else but +, OK, or NO
* for that matter. Well, we could get BAD, treat as NO.
*/
if (!p || (g_ascii_strncasecmp(p, " NO", 3) != 0 && g_ascii_strncasecmp(p, " BAD", 4)) ) {
g_warning ("Unexpected response from IMAP server: %s",
respbuf);
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Unexpected response from IMAP "
"server: %s"), respbuf);
camel_imap_response_free_without_processing (store, response);
return NULL;
}
p += 3;
if (!*p++)
p = NULL;
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_INVALID,
_("IMAP command failed: %s"),
p ? p : _("Unknown error"));
camel_imap_response_free_without_processing (store, response);
return NULL;
}
