#include <glib/gi18n.h>
#include <stdio.h>
#include <string.h>
+#include "imap.h"
+#include "imap_gtk.h"
+
+#ifdef HAVE_LIBETPAN
+
#include <stdlib.h>
#include <dirent.h>
#include <unistd.h>
#include "folder.h"
#include "session.h"
#include "procmsg.h"
-#include "imap.h"
-#include "imap_gtk.h"
#include "socket.h"
#include "recv.h"
#include "procheader.h"
#include "msgcache.h"
#include "imap-thread.h"
-#ifdef USE_PTHREAD
-#include <pthread.h>
-static pthread_mutex_t imap_mutex;
-static const char *mutex_hold = NULL;
-
-#ifndef __GNUC__
-#define __FUNCTION__ __FILE__
-#endif
-
-#if 0
-#define MUTEX_TRYLOCK_OR_RETURN() { \
- debug_print("%s: locking mutex\n", __FUNCTION__); \
- if (pthread_mutex_trylock(&imap_mutex) == EBUSY) { \
- g_warning("can't lock mutex (held by %s)\n", \
- mutex_hold ? mutex_hold:"(nil)"); \
- return; \
- } \
- mutex_hold = __FUNCTION__; \
-}
-
-#define MUTEX_TRYLOCK_OR_RETURN_VAL(retval) { \
- debug_print("%s: locking mutex\n", __FUNCTION__); \
- if (pthread_mutex_trylock(&imap_mutex) == EBUSY) { \
- g_warning("can't lock mutex (held by %s)\n", \
- mutex_hold ? mutex_hold:"(nil)"); \
- return retval; \
- } \
- mutex_hold = __FUNCTION__; \
-}
-
-#define MUTEX_UNLOCK() { \
- debug_print("%s: unlocking mutex\n", __FUNCTION__);\
- pthread_mutex_unlock(&imap_mutex); \
- mutex_hold = NULL; \
-}
-
-#else
-#define MUTEX_TRYLOCK_OR_RETURN() do {} while(0)
-#define MUTEX_TRYLOCK_OR_RETURN_VAL(retval) do {} while(0)
-#define MUTEX_UNLOCK() do {} while(0)
-#endif
-#endif
-
-#define MUTEX_TRYLOCK_OR_RETURN() do {} while(0)
-#define MUTEX_TRYLOCK_OR_RETURN_VAL(retval) do {} while(0)
-#define MUTEX_UNLOCK() do {} while(0)
-
typedef struct _IMAPFolder IMAPFolder;
typedef struct _IMAPSession IMAPSession;
typedef struct _IMAPNameSpace IMAPNameSpace;
GList *ns_personal;
GList *ns_others;
GList *ns_shared;
+ gchar last_seen_separator;
+ guint refcnt;
};
struct _IMAPSession
gboolean authenticated;
- gchar **capability;
+ GSList *capability;
gboolean uidplus;
gchar *mbox;
/* low-level IMAP4rev1 commands */
static gint imap_cmd_login (IMAPSession *session,
const gchar *user,
- const gchar *pass);
+ const gchar *pass,
+ const gchar *type);
static gint imap_cmd_logout (IMAPSession *session);
static gint imap_cmd_noop (IMAPSession *session);
#if USE_OPENSSL
{
gchar *dir;
- imap_done(folder);
+ while (imap_folder_get_refcnt(folder) > 0)
+ gtk_main_iteration();
+
dir = imap_folder_get_path(folder);
if (is_dir_exist(dir))
remove_dir_recursive(dir);
g_free(dir);
folder_remote_folder_destroy(REMOTE_FOLDER(folder));
+ imap_done(folder);
}
static void imap_folder_init(Folder *folder, const gchar *name,
g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL);
}
+void imap_get_capabilities(IMAPSession *session)
+{
+ struct mailimap_capability_data *capabilities = NULL;
+ clistiter *cur;
+
+ if (session->capability != NULL)
+ return;
+
+ capabilities = imap_threaded_capability(session->folder);
+ for(cur = clist_begin(capabilities->cap_list) ; cur != NULL ;
+ cur = clist_next(cur)) {
+ struct mailimap_capability * cap =
+ clist_content(cur);
+ if (cap->cap_data.cap_name == NULL)
+ continue;
+ session->capability = g_slist_append
+ (session->capability,
+ g_strdup(cap->cap_data.cap_name));
+ debug_print("got capa %s\n", cap->cap_data.cap_name);
+ }
+ mailimap_capability_data_free(capabilities);
+}
+
+gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
+{
+ GSList *cur;
+ for (cur = session->capability; cur; cur = cur->next) {
+ if (!g_ascii_strcasecmp(cur->data, cap))
+ return TRUE;
+ }
+ return FALSE;
+}
+
static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
IMAPAuthType type)
{
- gint ok;
-
- ok = imap_cmd_login(session, user, pass);
-
+ gint ok = IMAP_ERROR;
+ static time_t last_login_err = 0;
+
+ imap_get_capabilities(session);
+
+ switch(type) {
+ case IMAP_AUTH_CRAM_MD5:
+ ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
+ break;
+ case IMAP_AUTH_LOGIN:
+ ok = imap_cmd_login(session, user, pass, "LOGIN");
+ break;
+ default:
+ debug_print("capabilities:\n"
+ "\t CRAM-MD5 %d\n"
+ "\t LOGIN %d\n",
+ imap_has_capability(session, "CRAM-MD5"),
+ imap_has_capability(session, "LOGIN"));
+ if (imap_has_capability(session, "CRAM-MD5"))
+ ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
+ if (ok == IMAP_ERROR) /* we always try LOGIN before giving up */
+ ok = imap_cmd_login(session, user, pass, "LOGIN");
+ }
if (ok == IMAP_SUCCESS)
session->authenticated = TRUE;
-
+ else {
+ gchar *ext_info = NULL;
+
+ if (type == IMAP_AUTH_CRAM_MD5) {
+ ext_info = _("\n\nCRAM-MD5 logins only work if libetpan has been "
+ "compiled with SASL support and the "
+ "CRAM-MD5 SASL plugin is installed.");
+ } else {
+ ext_info = "";
+ }
+
+ if (time(NULL) - last_login_err > 10) {
+ alertpanel_error(_("Connection to %s failed: login refused.%s"),
+ SESSION(session)->server, ext_info);
+ }
+ last_login_err = time(NULL);
+ }
return ok;
}
session->mbox = NULL;
session->cmd_count = 0;
session->folder = folder;
+ IMAP_FOLDER(session->folder)->last_seen_separator = 0;
#if USE_OPENSSL
if (account->ssl_imap == SSL_STARTTLS) {
gchar *tmp_pass;
tmp_pass = input_dialog_query_password(account->recv_server, account->userid);
if (!tmp_pass)
- return;
+ tmp_pass = g_strdup(""); /* allow empty password */
Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return;});
g_free(tmp_pass);
}
return cnt;
}
+static void strip_crs(const gchar *file)
+{
+ FILE *fp = NULL, *outfp = NULL;
+ gchar buf[4096];
+ gchar *out = get_tmp_file();
+ if (file == NULL)
+ goto freeout;
+
+ fp = fopen(file, "rb");
+ if (!fp)
+ goto freeout;
+
+ outfp = fopen(out, "wb");
+ if (!outfp) {
+ fclose(fp);
+ goto freeout;
+ }
+
+ while (fgets(buf, sizeof (buf), fp) != NULL) {
+ while (strstr(buf, "\r")) {
+ gchar *cr = strstr(buf, "\r") ;
+ *cr = '\n';
+ cr++;
+ *cr = '\0';
+ }
+ fputs(buf, outfp);
+ }
+
+ fclose(fp);
+ fclose(outfp);
+ rename_force(out, file);
+freeout:
+ g_free(out);
+}
+
static gchar *imap_fetch_msg_full(Folder *folder, FolderItem *item, gint uid,
gboolean headers, gboolean body)
{
MsgInfo *msginfo = imap_parse_msg(filename, item);
MsgInfo *cached = msgcache_get_msg(item->cache,uid);
guint have_size = get_size_with_lfs(msginfo);
- debug_print("message %d has been already %scached (%d/%d).\n", uid,
+
+ if (cached)
+ debug_print("message %d has been already %scached (%d/%d).\n", uid,
have_size == cached->size ? "fully ":"",
- have_size, cached? (int)cached->size : -1);
+ have_size, (int)cached->size);
if (cached && (cached->size == have_size || !body)) {
procmsg_msginfo_free(cached);
procmsg_msginfo_free(msginfo);
+ strip_crs(filename);
return filename;
} else {
procmsg_msginfo_free(cached);
return NULL;
}
+ strip_crs(filename);
return filename;
}
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(file_list != NULL, -1);
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
-
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return -1;
}
destdir = imap_get_real_path(IMAP_FOLDER(folder), dest->path);
iflags |= IMAP_FLAG_SEEN;
}
- if (dest->stype == F_OUTBOX ||
- dest->stype == F_QUEUE ||
- dest->stype == F_DRAFT ||
- dest->stype == F_TRASH)
+ if (folder_has_parent_of_type(dest, F_QUEUE) ||
+ folder_has_parent_of_type(dest, F_OUTBOX) ||
+ folder_has_parent_of_type(dest, F_DRAFT) ||
+ folder_has_parent_of_type(dest, F_TRASH))
iflags |= IMAP_FLAG_SEEN;
ok = imap_cmd_append(session, destdir, fileinfo->file, iflags,
if (ok != IMAP_SUCCESS) {
g_warning("can't append message %s\n", fileinfo->file);
g_free(destdir);
- MUTEX_UNLOCK();
return -1;
}
g_free(destdir);
- MUTEX_UNLOCK();
return last_uid;
}
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msglist != NULL, -1);
-
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return -1;
}
msginfo = (MsgInfo *)msglist->data;
src = msginfo->folder;
if (src == dest) {
g_warning("the src folder is identical to the dest.\n");
- MUTEX_UNLOCK();
return -1;
}
ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE);
if (ok != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
return ok;
}
g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
- MUTEX_UNLOCK();
-
if (ok == IMAP_SUCCESS)
return last_num;
else
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msglist != NULL, -1);
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
-
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return -1;
}
msginfo = (MsgInfo *)msglist->data;
ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE);
if (ok != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
return ok;
}
seq_list, IMAP_FLAG_DELETED, TRUE);
if (ok != IMAP_SUCCESS) {
log_warning(_("can't set deleted flags\n"));
- MUTEX_UNLOCK();
return ok;
}
ok = imap_cmd_expunge(session);
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
- MUTEX_UNLOCK();
return ok;
}
g_free(destdir);
- MUTEX_UNLOCK();
if (ok == IMAP_SUCCESS)
return 0;
else
{
GSList *list = folder_item_get_msg_list(item);
gint res = imap_remove_msgs(folder, item, list, NULL);
- g_slist_free(list);
+ procmsg_msg_list_free(list);
return res;
}
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(folder->account != NULL, -1);
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
-
session = imap_session_get(folder);
if (!session) {
if (!folder->node) {
item->folder = folder;
folder->node = item->node = g_node_new(item);
}
- MUTEX_UNLOCK();
return -1;
}
int r;
clist * lep_list;
- Xstrdup_a(root_folder, folder->account->imap_dir, {MUTEX_UNLOCK();return -1;});
+ Xstrdup_a(root_folder, folder->account->imap_dir, {return -1;});
extract_quote(root_folder, '"');
subst_char(root_folder,
imap_get_path_separator(IMAP_FOLDER(folder),
item->folder = folder;
folder->node = item->node = g_node_new(item);
}
- MUTEX_UNLOCK();
return -1;
}
imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data));
imap_create_missing_folders(folder);
- MUTEX_UNLOCK();
return 0;
}
if (!folder->trash)
folder->trash = imap_create_special_folder
(folder, F_TRASH, "Trash");
+ if (!folder->queue)
+ folder->queue = imap_create_special_folder
+ (folder, F_QUEUE, "Queue");
+ if (!folder->outbox)
+ folder->outbox = imap_create_special_folder
+ (folder, F_OUTBOX, "Sent");
+ if (!folder->draft)
+ folder->draft = imap_create_special_folder
+ (folder, F_DRAFT, "Drafts");
}
static FolderItem *imap_create_special_folder(Folder *folder,
g_return_val_if_fail(parent != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
- MUTEX_TRYLOCK_OR_RETURN_VAL(NULL);
-
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return NULL;
}
else if (folder->account->imap_dir && *folder->account->imap_dir) {
gchar *imap_dir;
- Xstrdup_a(imap_dir, folder->account->imap_dir, {MUTEX_UNLOCK();return NULL;});
+ Xstrdup_a(imap_dir, folder->account->imap_dir, {return NULL;});
strtailchomp(imap_dir, '/');
dirpath = g_strconcat(imap_dir, "/", name, NULL);
} else
strtailchomp(dirpath, '/');
Xstrdup_a(new_name, name, {
g_free(dirpath);
- MUTEX_UNLOCK();
return NULL;});
strtailchomp(new_name, '/');
g_free(dirpath);
ptr_array_free_strings(argbuf);
g_ptr_array_free(argbuf, TRUE);
- MUTEX_UNLOCK();
return NULL;
}
log_warning(_("can't create mailbox\n"));
g_free(imap_path);
g_free(dirpath);
- MUTEX_UNLOCK();
return NULL;
}
}
make_dir_hier(dirpath);
g_free(dirpath);
- MUTEX_UNLOCK();
return new_item;
}
g_return_val_if_fail(item->path != NULL, -1);
g_return_val_if_fail(name != NULL, -1);
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
-
if (strchr(name, imap_get_path_separator(IMAP_FOLDER(folder), item->path)) != NULL) {
g_warning(_("New folder name must not contain the namespace "
"path separator"));
- MUTEX_UNLOCK();
return -1;
}
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return -1;
}
real_oldpath = imap_get_real_path(IMAP_FOLDER(folder), item->path);
&exists, &recent, &unseen, &uid_validity, FALSE);
if (ok != IMAP_SUCCESS) {
g_free(real_oldpath);
- MUTEX_UNLOCK();
return -1;
}
g_free(real_oldpath);
g_free(newpath);
g_free(real_newpath);
- MUTEX_UNLOCK();
return -1;
}
g_free(real_oldpath);
g_free(real_newpath);
- MUTEX_UNLOCK();
return 0;
}
g_return_val_if_fail(item != NULL, -1);
g_return_val_if_fail(item->path != NULL, -1);
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
-
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return -1;
}
path = imap_get_real_path(IMAP_FOLDER(folder), item->path);
&exists, &recent, &unseen, &uid_validity, FALSE);
if (ok != IMAP_SUCCESS) {
g_free(path);
- MUTEX_UNLOCK();
return -1;
}
if (ok != IMAP_SUCCESS) {
log_warning(_("can't delete mailbox\n"));
g_free(path);
- MUTEX_UNLOCK();
return -1;
}
g_free(cache_dir);
folder_item_remove(item);
- MUTEX_UNLOCK();
return 0;
}
session_set_access_time(SESSION(session));
stuff->done = TRUE;
-
return newlist;
}
cur = numlist;
data->total = g_slist_length(numlist);
debug_print("messages list : %i\n", data->total);
+
while (cur != NULL) {
GSList * partial_result;
int count;
partial_result =
(GSList *)imap_get_uncached_messages_thread(data);
- {
- gchar buf[32];
- g_snprintf(buf, sizeof(buf), "%d / %d",
- data->cur, data->total);
- gtk_progress_bar_set_text
- (GTK_PROGRESS_BAR(mainwindow_get_mainwindow()->progressbar), buf);
- gtk_progress_bar_set_fraction
- (GTK_PROGRESS_BAR(mainwindow_get_mainwindow()->progressbar),
- (gfloat)data->cur / (gfloat)data->total);
- debug_print("update progress %g\n",
- (gfloat)data->cur / (gfloat)data->total);
- }
+ statusbar_progress_all(data->cur,data->total, 1);
g_slist_free(newlist);
}
g_free(data);
- gtk_progress_bar_set_fraction
- (GTK_PROGRESS_BAR(mainwindow_get_mainwindow()->progressbar), 0);
- gtk_progress_bar_set_text
- (GTK_PROGRESS_BAR(mainwindow_get_mainwindow()->progressbar), "");
+ statusbar_progress_all(0,0,0);
statusbar_pop_all();
return result;
return NULL;
}
+
static gchar imap_get_path_separator(IMAPFolder *folder, const gchar *path)
{
IMAPNameSpace *namespace;
gchar separator = '/';
+ if (folder->last_seen_separator == 0) {
+ clist * lep_list;
+ int r = imap_threaded_list((Folder *)folder, "", "", &lep_list);
+ if (r != MAILIMAP_NO_ERROR) {
+ log_warning(_("LIST failed\n"));
+ return '/';
+ }
+
+ if (clist_count(lep_list) > 0) {
+ clistiter * iter = clist_begin(lep_list);
+ struct mailimap_mailbox_list * mb;
+ mb = clist_content(iter);
+
+ folder->last_seen_separator = mb->mb_delimiter;
+ debug_print("got separator: %c\n", folder->last_seen_separator);
+ }
+ mailimap_list_result_free(lep_list);
+ }
+
+ if (folder->last_seen_separator != 0) {
+ debug_print("using separator: %c\n", folder->last_seen_separator);
+ return folder->last_seen_separator;
+ }
+
namespace = imap_find_namespace(folder, path);
if (namespace && namespace->separator)
separator = namespace->separator;
clistiter * iter;
struct mailimap_mailbox_data_status * data_status;
int got_values;
-
- r = imap_threaded_status(FOLDER(folder), path, &data_status);
- if (r != MAILIMAP_NO_ERROR)
+ gchar *real_path;
+
+ real_path = imap_get_real_path(folder, path);
+
+ r = imap_threaded_status(FOLDER(folder), real_path, &data_status);
+ g_free(real_path);
+ if (r != MAILIMAP_NO_ERROR) {
+ debug_print("status err %d\n", r);
return IMAP_ERROR;
+ }
if (data_status->st_info_list == NULL) {
mailimap_mailbox_data_status_free(data_status);
+ debug_print("status->st_info_list == NULL\n");
return IMAP_ERROR;
}
mailimap_mailbox_data_status_free(data_status);
if (got_values != ((1 << 4) + (1 << 3) +
- (1 << 2) + (1 << 1) + (1 << 0)))
+ (1 << 2) + (1 << 1) + (1 << 0))) {
+ debug_print("status: incomplete values received (%d)\n", got_values);
return IMAP_ERROR;
-
+ }
return IMAP_SUCCESS;
}
static void imap_free_capabilities(IMAPSession *session)
{
- g_strfreev(session->capability);
+ slist_free_strings(session->capability);
+ g_slist_free(session->capability);
session->capability = NULL;
}
challenge_len = base64_decode(challenge, buf + 2, -1);
challenge[challenge_len] = '\0';
g_free(buf);
- log_print("IMAP< [Decoded: %s]\n", challenge);
md5_hex_hmac(hexdigest, challenge, challenge_len, pass, strlen(pass));
g_free(challenge);
response = g_strdup_printf("%s %s", user, hexdigest);
- log_print("IMAP> [Encoded: %s]\n", response);
response64 = g_malloc((strlen(response) + 3) * 2 + 1);
base64_encode(response64, response, strlen(response));
g_free(response);
- log_print("IMAP> %s\n", response64);
sock_puts(SESSION(session)->sock, response64);
ok = imap_cmd_ok(session, NULL);
if (ok != IMAP_SUCCESS)
#endif
static gint imap_cmd_login(IMAPSession *session,
- const gchar *user, const gchar *pass)
+ const gchar *user, const gchar *pass,
+ const gchar *type)
{
int r;
gint ok;
- r = imap_threaded_login(session->folder, user, pass);
- if (r != MAILIMAP_NO_ERROR)
+ log_print("IMAP4> Logging %s to %s using %s\n",
+ user,
+ SESSION(session)->server,
+ type);
+ r = imap_threaded_login(session->folder, user, pass, type);
+ if (r != MAILIMAP_NO_ERROR) {
+ log_error("IMAP4< Error logging in to %s\n",
+ SESSION(session)->server);
ok = IMAP_ERROR;
- else
+ } else {
ok = IMAP_SUCCESS;
-
+ }
return ok;
}
static gint imap_cmd_logout(IMAPSession *session)
{
imap_threaded_disconnect(session->folder);
-
+
return IMAP_SUCCESS;
}
unsigned int exists;
r = imap_threaded_noop(session->folder, &exists);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+ debug_print("noop err %d\n", r);
return IMAP_ERROR;
-
+ }
session->exists = exists;
-
+ session_set_access_time(SESSION(session));
+
return IMAP_SUCCESS;
}
static gint imap_cmd_starttls(IMAPSession *session)
{
int r;
-
+
r = imap_threaded_starttls(session->folder);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+ debug_print("starttls err %d\n", r);
return IMAP_ERROR;
-
+ }
return IMAP_SUCCESS;
}
#endif
r = imap_threaded_select(session->folder, folder,
exists, recent, unseen, uid_validity);
if (r != MAILIMAP_NO_ERROR) {
+ debug_print("select err %d\n", r);
return IMAP_ERROR;
}
-
return IMAP_SUCCESS;
}
r = imap_threaded_examine(session->folder, folder,
exists, recent, unseen, uid_validity);
if (r != MAILIMAP_NO_ERROR) {
+ debug_print("examine err %d\n", r);
+
return IMAP_ERROR;
}
-
return IMAP_SUCCESS;
}
static gint imap_cmd_create(IMAPSession *session, const gchar *folder)
{
int r;
-
+
r = imap_threaded_create(session->folder, folder);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+
return IMAP_ERROR;
-
+ }
+
return IMAP_SUCCESS;
}
const gchar *new_folder)
{
int r;
-
+
r = imap_threaded_rename(session->folder, old_folder,
new_folder);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+
return IMAP_ERROR;
-
+ }
+
return IMAP_SUCCESS;
}
{
int r;
+
r = imap_threaded_delete(session->folder, folder);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+
return IMAP_ERROR;
-
+ }
+
return IMAP_SUCCESS;
}
r = imap_threaded_fetch_content(session->folder,
uid, 0, filename);
}
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+ debug_print("fetch err %d\n", r);
return GINT_TO_POINTER(IMAP_ERROR);
-
+ }
return GINT_TO_POINTER(IMAP_SUCCESS);
}
if (new_uid != NULL)
*new_uid = 0;
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+ debug_print("append err %d\n", r);
return IMAP_ERROR;
-
+ }
return IMAP_SUCCESS;
}
g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
r = imap_threaded_copy(session->folder, set, destfolder);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+
return IMAP_ERROR;
-
+ }
+
return IMAP_SUCCESS;
}
mailimap_store_att_flags_new_remove_flags_silent(flag_list);
r = imap_threaded_store(session->folder, set, store_att_flags);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+
return IMAP_ERROR;
+ }
return IMAP_SUCCESS;
}
if (prefs_common.work_offline && !imap_gtk_should_override()) {
return -1;
}
-
+
r = imap_threaded_expunge(session->folder);
- if (r != MAILIMAP_NO_ERROR)
+ if (r != MAILIMAP_NO_ERROR) {
+
return IMAP_ERROR;
-
+ }
+
return IMAP_SUCCESS;
}
g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
g_return_val_if_fail(folder->account != NULL, -1);
- MUTEX_TRYLOCK_OR_RETURN_VAL(-1);
-
session = imap_session_get(folder);
g_return_val_if_fail(session != NULL, -1);
if (selected_folder) {
ok = imap_cmd_noop(session);
if (ok != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
+
return -1;
}
exists = session->exists;
ok = imap_status(session, IMAP_FOLDER(folder), item->item.path,
&exists, &recent, &uid_next, &uid_val, &unseen, FALSE);
if (ok != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
+
return -1;
}
if(item->item.mtime == uid_val)
out which numbers have been removed */
if (exists == nummsgs) {
*msgnum_list = g_slist_copy(item->uid_list);
- MUTEX_UNLOCK();
return nummsgs;
} else if (exists < nummsgs) {
debug_print("Freeing imap uid cache");
if (exists == 0) {
*msgnum_list = NULL;
- MUTEX_UNLOCK();
return 0;
}
nummsgs = get_list_of_uids(folder, item, &uidlist);
if (nummsgs < 0) {
- MUTEX_UNLOCK();
+
return -1;
}
debug_print("removing old messages from %s\n", dir);
remove_numbered_files_not_in_list(dir, *msgnum_list);
g_free(dir);
- MUTEX_UNLOCK();
debug_print("get_num_list - ok - %i\n", nummsgs);
g_return_val_if_fail(item != NULL, NULL);
g_return_val_if_fail(file != NULL, NULL);
- if (item->stype == F_QUEUE) {
+ if (folder_has_parent_of_type(item, F_QUEUE)) {
MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
- } else if (item->stype == F_DRAFT) {
+ } else if (folder_has_parent_of_type(item, F_DRAFT)) {
MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
}
if (ok != IMAP_SUCCESS)
return NULL;
- if (!(item->stype == F_QUEUE || item->stype == F_DRAFT)) {
+ if (!(folder_has_parent_of_type(item, F_DRAFT) ||
+ folder_has_parent_of_type(item, F_QUEUE))) {
ret = g_slist_concat(ret,
imap_get_uncached_messages(session, item,
msgnum_list));
g_return_if_fail(msginfo != NULL);
g_return_if_fail(msginfo->folder == item);
- MUTEX_TRYLOCK_OR_RETURN();
-
session = imap_session_get(folder);
if (!session) {
- MUTEX_UNLOCK();
return;
}
if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE)) != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
return;
}
if (flags_set) {
ok = imap_set_message_flags(session, &numlist, flags_set, TRUE);
if (ok != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
return;
}
}
if (flags_unset) {
ok = imap_set_message_flags(session, &numlist, flags_unset, FALSE);
if (ok != IMAP_SUCCESS) {
- MUTEX_UNLOCK();
return;
}
}
}
msginfo->flags.perm_flags = newflags;
- MUTEX_UNLOCK();
return;
}
static void process_hashtable(void)
{
- MUTEX_TRYLOCK_OR_RETURN();
if (flags_set_table) {
g_hash_table_foreach_remove(flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
g_free(flags_set_table);
g_free(flags_unset_table);
flags_unset_table = NULL;
}
- MUTEX_UNLOCK();
}
static IMAPFolderItem *batching_item = NULL;
free(dup_name);
continue;
}
+
+ if (dup_name[strlen(dup_name)-1] == '/') {
+ g_free(base);
+ free(dup_name);
+ continue;
+ }
loc_name = imap_modified_utf7_to_utf8(base);
loc_path = imap_modified_utf7_to_utf8(dup_name);
MsgFlags flags = {0, 0};
MSG_SET_TMP_FLAGS(flags, MSG_IMAP);
- if (item->stype == F_QUEUE) {
+ if (folder_has_parent_of_type(item, F_QUEUE)) {
MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
- } else if (item->stype == F_DRAFT) {
+ } else if (folder_has_parent_of_type(item, F_DRAFT)) {
MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
}
flags.perm_flags = info->flags;
return flag_list;
}
+
+guint imap_folder_get_refcnt(Folder *folder)
+{
+ return ((IMAPFolder *)folder)->refcnt;
+}
+
+void imap_folder_ref(Folder *folder)
+{
+ ((IMAPFolder *)folder)->refcnt++;
+}
+
+void imap_folder_unref(Folder *folder)
+{
+ if (((IMAPFolder *)folder)->refcnt > 0)
+ ((IMAPFolder *)folder)->refcnt--;
+}
+
+#else /* HAVE_LIBETPAN */
+
+static FolderClass imap_class;
+
+static Folder *imap_folder_new (const gchar *name,
+ const gchar *path)
+{
+ return NULL;
+}
+static gint imap_create_tree (Folder *folder)
+{
+ return -1;
+}
+static FolderItem *imap_create_folder (Folder *folder,
+ FolderItem *parent,
+ const gchar *name)
+{
+ return NULL;
+}
+static gint imap_rename_folder (Folder *folder,
+ FolderItem *item,
+ const gchar *name)
+{
+ return -1;
+}
+
+FolderClass *imap_get_class(void)
+{
+ if (imap_class.idstr == NULL) {
+ imap_class.type = F_IMAP;
+ imap_class.idstr = "imap";
+ imap_class.uistr = "IMAP4";
+
+ imap_class.new_folder = imap_folder_new;
+ imap_class.create_tree = imap_create_tree;
+ imap_class.create_folder = imap_create_folder;
+ imap_class.rename_folder = imap_rename_folder;
+ /* nothing implemented */
+ }
+
+ return &imap_class;
+}
+#endif
projects / claws.git / blobdiff