aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--camel/ChangeLog43
-rw-r--r--camel/Makefile.am19
-rw-r--r--camel/camel-folder-summary.c8
-rw-r--r--camel/camel-lock-client.c329
-rw-r--r--camel/camel-lock-client.h42
-rw-r--r--camel/camel-lock-helper.c389
-rw-r--r--camel/camel-lock-helper.h70
-rw-r--r--camel/providers/local/camel-maildir-store.c114
-rw-r--r--camel/providers/local/camel-spool-folder.c60
-rw-r--r--camel/providers/local/camel-spool-folder.h2
-rw-r--r--camel/providers/local/camel-spool-store.c91
-rw-r--r--camel/providers/local/camel-spool-store.h2
-rw-r--r--camel/providers/local/camel-spool-summary.c13
-rw-r--r--camel/tests/folder/test2.c2
-rw-r--r--camel/tests/lib/folders.c14
15 files changed, 1145 insertions, 53 deletions
diff --git a/camel/ChangeLog b/camel/ChangeLog
index e832e39c4d..f675609e64 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,46 @@
+2001-06-18 Not Zed <NotZed@Ximian.com>
+
+ * camel-folder-summary.c
+ (camel_folder_summary_info_new_from_parser): Only create a missing
+ uid if we have indexing turned on.
+
+ * camel-lock-helper.c (setup_process): Function to setup
+ process/sanity/security checks. Change to the real uid as soon as
+ we can.
+ (lock_path): First try to lock as the real uid, if that fails, try
+ the root uid.
+ (unlock_id): Unlock as the uid we created the lock as.
+
+ * Makefile.am (INCLUDES): Added -DCAMEL_SBINDIR for lock helper
+ location.
+
+ * providers/local/camel-spool-folder.c (spool_lock): Implemented,
+ using lock helper locking. Need to work out if the locking
+ requires a root created lock?
+ (spool_unlock): Likewise.
+
+2001-06-15 Not Zed <NotZed@Ximian.com>
+
+ * camel-lock-helper.c: Setuid Lock helper process. Creates and manages
+ .locks, keeping them active, removing them, etc. What real perms it
+ needs is a little system dependent.
+
+2001-06-14 Not Zed <NotZed@Ximian.com>
+
+ * providers/local/camel-maildir-store.c (get_folder_info): Implement.
+ (scan_dir): Does the work of scanning for maildir directories.
+
+2001-06-13 Not Zed <NotZed@Ximian.com>
+
+ * providers/local/camel-spool-store.c (get_folder_info):
+ Implemented, just returns a hardcoded INBOX folder.
+ (free_folder_info): implemented, free's the 1 possible level of
+ folder info.
+
+ * providers/local/camel-spool-folder.c
+ (camel_spool_folder_construct): Set the real unread message
+ count on the folder_created thing.
+
2001-06-15 Dan Winship <danw@ximian.com>
* providers/imap/camel-imap-message-cache.c
diff --git a/camel/Makefile.am b/camel/Makefile.am
index c3a964b991..4636447f57 100644
--- a/camel/Makefile.am
+++ b/camel/Makefile.am
@@ -5,6 +5,8 @@ SUBDIRS = providers tests
libcamelincludedir = $(includedir)/camel
providerdir = $(libdir)/evolution/camel-providers/$(VERSION)
+sbin_PROGRAMS = camel-lock-helper
+
lib_LTLIBRARIES = libcamel.la
INCLUDES = -I.. -I$(srcdir)/.. \
@@ -15,6 +17,7 @@ INCLUDES = -I.. -I$(srcdir)/.. \
$(NSPR_CFLAGS) \
$(NSS_CFLAGS) \
$(OPENSSL_CFLAGS) \
+ -DCAMEL_SBINDIR=\""$(sbindir)"\" \
-DCAMEL_PROVIDERDIR=\""$(providerdir)"\" \
-DG_LOG_DOMAIN=\"camel\"
@@ -38,6 +41,7 @@ libcamel_la_SOURCES = \
camel-folder.c \
camel-internet-address.c \
camel-lock.c \
+ camel-lock-client.c \
camel-medium.c \
camel-mime-filter-bestenc.c \
camel-mime-filter-basic.c \
@@ -121,6 +125,7 @@ libcamelinclude_HEADERS = \
camel-folder.h \
camel-internet-address.h \
camel-lock.h \
+ camel-lock-client.h \
camel-medium.h \
camel-mime-filter-bestenc.h \
camel-mime-filter-basic.h \
@@ -191,13 +196,23 @@ libcamel_la_LIBADD = $(top_builddir)/e-util/libeutil.la \
$(OPENSSL_LDFLAGS)
+camel-lock-helper: camel-lock-helper.o camel-lock.o
+ $(CC) -o $@ $^ -I$(srcdir)/.. -I$(srcdir)
+
+install-exec-local:
+ -file=$(DESTDIR)$(sbindir)/camel-lock-helper; \
+ chown root $$file && chgrp root $$file && chmod u+s $$file
+
noinst_HEADERS = \
camel-charset-map-private.h \
camel-private.h \
- camel-search-private.h
+ camel-search-private.h \
+ camel-lock-helper.h
+# manually include camel-lock-helper.c since we build it manually
EXTRA_DIST = \
- README
+ README \
+ camel-lock-helper.c
#noinst_PROGRAMS = \
# camel-mime-filter-from
diff --git a/camel/camel-folder-summary.c b/camel/camel-folder-summary.c
index e9b60cebc2..a347774ad5 100644
--- a/camel/camel-folder-summary.c
+++ b/camel/camel-folder-summary.c
@@ -801,7 +801,10 @@ CamelMessageInfo *camel_folder_summary_info_new_from_header(CamelFolderSummary *
* @mp:
*
* Create a new info record from a parser. If the parser cannot
- * determine a uid, then a new one is automatically assigned.
+ * determine a uid, then none will be assigned.
+
+ * If indexing is enabled, and the parser cannot determine a new uid, then
+ * one is automatically assigned.
*
* If indexing is enabled, then the content will be indexed based
* on this new uid. In this case, the message info MUST be
@@ -831,7 +834,8 @@ CamelMessageInfo *camel_folder_summary_info_new_from_parser(CamelFolderSummary *
/* assign a unique uid, this is slightly 'wrong' as we do not really
* know if we are going to store this in the summary, but no matter */
- summary_assign_uid(s, info);
+ if (p->index)
+ summary_assign_uid(s, info);
CAMEL_SUMMARY_LOCK(s, filter_lock);
diff --git a/camel/camel-lock-client.c b/camel/camel-lock-client.c
new file mode 100644
index 0000000000..d55bb5ff15
--- /dev/null
+++ b/camel/camel-lock-client.c
@@ -0,0 +1,329 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2001 Ximian Inc.
+ *
+ * Authors: Michael Zucchi <notzed@ximian.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <errno.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+#endif
+
+#include "camel-exception.h"
+#include "camel-lock-helper.h"
+#include "camel-lock-client.h"
+
+#define d(x)
+
+/* dunno where this fucking thing is got from */
+/* see also camel-lock.c */
+#define _(x) (x)
+
+#ifdef ENABLE_THREADS
+static pthread_mutex_t lock_lock = PTHREAD_MUTEX_INITIALIZER;
+#define LOCK() pthread_mutex_lock(&lock_lock)
+#define UNLOCK() pthread_mutex_unlock(&lock_lock)
+#else
+#define LOCK()
+#define UNLOCK()
+#endif
+
+static int lock_sequence;
+static int lock_helper_pid = -1;
+static int lock_stdin_pipe[2], lock_stdout_pipe[2];
+
+static int read_n(int fd, void *buffer, int inlen)
+{
+ char *p = buffer;
+ int len, left = inlen;
+
+ do {
+ len = read(fd, p, left);
+ if (len == -1) {
+ if (errno != EINTR)
+ return -1;
+ } else {
+ left -= len;
+ p += len;
+ }
+ } while (left > 0 && len != 0);
+
+ return inlen - left;
+}
+
+static int write_n(int fd, void *buffer, int inlen)
+{
+ char *p = buffer;
+ int len, left = inlen;
+
+ do {
+ len = write(fd, p, left);
+ if (len == -1) {
+ if (errno != EINTR)
+ return -1;
+ } else {
+ left -= len;
+ p += len;
+ }
+ } while (left > 0);
+
+ return inlen;
+}
+
+static int camel_lock_helper_init(CamelException *ex)
+{
+ /* FIXME: check returns */
+ if (pipe(lock_stdin_pipe) == -1
+ || pipe(lock_stdout_pipe) == -1) {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
+ _("Cannot build locking helper pipe: %s"),
+ strerror(errno));
+ }
+
+ lock_helper_pid = fork();
+ switch(lock_helper_pid) {
+ case -1:
+ close(lock_stdin_pipe[0]);
+ close(lock_stdin_pipe[1]);
+ close(lock_stdout_pipe[0]);
+ close(lock_stdout_pipe[1]);
+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
+ _("Cannot fork locking helper: %s"),
+ strerror(errno));
+ return -1;
+ case 0:
+ close(STDIN_FILENO);
+ dup(lock_stdin_pipe[0]);
+ close(STDOUT_FILENO);
+ dup(lock_stdout_pipe[1]);
+ close(lock_stdin_pipe[0]);
+ close(lock_stdin_pipe[1]);
+ close(lock_stdout_pipe[0]);
+ close(lock_stdout_pipe[1]);
+ execl(CAMEL_SBINDIR "/camel-lock-helper", "camel-lock-helper", NULL);
+ d(fprintf(stderr, "shit, couldn't exec lock helper!\n"));
+ /* it'll pick this up when it tries to use us */
+ exit(255);
+ default:
+ close(lock_stdin_pipe[0]);
+ close(lock_stdout_pipe[1]);
+
+ /* so the child knows when we vanish */
+ fcntl(lock_stdin_pipe[1], F_SETFD, FD_CLOEXEC);
+ fcntl(lock_stdout_pipe[0], F_SETFD, FD_CLOEXEC);
+ }
+
+ return 0;
+}
+
+int camel_lock_helper_lock(const char *path, CamelException *ex)
+{
+ struct _CamelLockHelperMsg *msg;
+ int len = strlen(path);
+ int res = -1;
+ int retry = 3;
+
+ LOCK();
+
+ if (lock_helper_pid == -1) {
+ if (camel_lock_helper_init(ex) == -1) {
+ UNLOCK();
+ return -1;
+ }
+ }
+
+ msg = alloca(len + sizeof(*msg));
+again:
+ msg->magic = CAMEL_LOCK_HELPER_MAGIC;
+ msg->seq = lock_sequence;
+ msg->id = CAMEL_LOCK_HELPER_LOCK;
+ msg->data = len;
+ memcpy(msg+1, path, len);
+
+ write_n(lock_stdin_pipe[1], msg, len+sizeof(*msg));
+
+ do {
+ /* should also have a timeout here? cancellation? */
+ len = read_n(lock_stdout_pipe[0], msg, sizeof(*msg));
+ if (len == 0) {
+ /* child quit, do we try ressurect it? */
+ res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
+ /* if the child exited, this should get it, waidpid returns 0 if the child hasn't */
+ if (waitpid(lock_helper_pid, NULL, WNOHANG) > 0) {
+ lock_helper_pid = -1;
+ close(lock_stdout_pipe[0]);
+ close(lock_stdin_pipe[1]);
+ lock_stdout_pipe[0] = -1;
+ lock_stdin_pipe[1] = -1;
+ }
+ goto fail;
+ }
+
+ if (msg->magic != CAMEL_LOCK_HELPER_RETURN_MAGIC
+ || msg->seq > lock_sequence) {
+ res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
+ d(printf("lock child protocol error\n"));
+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
+ _("Could not lock '%s': protocol error with lock-helper"), path);
+ goto fail;
+ }
+ } while (msg->seq < lock_sequence);
+
+ if (msg->seq == lock_sequence) {
+ switch(msg->id) {
+ case CAMEL_LOCK_HELPER_STATUS_OK:
+ d(printf("lock child locked ok, id is %d\n", msg->data));
+ res = msg->data;
+ break;
+ default:
+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
+ _("Could not lock '%s'"), path);
+ d(printf("locking failed ! status = %d\n", msg->id));
+ break;
+ }
+ } else if (retry > 0) {
+ d(printf("sequence failure, lost message? retry?\n"));
+ retry--;
+ goto again;
+ } else {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
+ _("Could not lock '%s': protocol error with lock-helper"), path);
+ }
+
+fail:
+ lock_sequence++;
+
+ UNLOCK();
+
+ return res;
+}
+
+int camel_lock_helper_unlock(int lockid)
+{
+ struct _CamelLockHelperMsg *msg;
+ int res = -1;
+ int retry = 3;
+ int len;
+
+ d(printf("unlocking lock id %d\n", lockid));
+
+ LOCK();
+
+ /* impossible to unlock if we haven't locked yet */
+ if (lock_helper_pid == -1) {
+ UNLOCK();
+ return -1;
+ }
+
+ msg = alloca(sizeof(*msg));
+again:
+ msg->magic = CAMEL_LOCK_HELPER_MAGIC;
+ msg->seq = lock_sequence;
+ msg->id = CAMEL_LOCK_HELPER_UNLOCK;
+ msg->data = lockid;
+
+ write_n(lock_stdin_pipe[1], msg, sizeof(*msg));
+
+ do {
+ /* should also have a timeout here? cancellation? */
+ len = read_n(lock_stdout_pipe[0], msg, sizeof(*msg));
+ if (len == 0) {
+ /* child quit, do we try ressurect it? */
+ res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
+ if (waitpid(lock_helper_pid, NULL, WNOHANG) > 0) {
+ lock_helper_pid = -1;
+ close(lock_stdout_pipe[0]);
+ close(lock_stdin_pipe[1]);
+ lock_stdout_pipe[0] = -1;
+ lock_stdin_pipe[1] = -1;
+ }
+ goto fail;
+ }
+
+ if (msg->magic != CAMEL_LOCK_HELPER_RETURN_MAGIC
+ || msg->seq > lock_sequence) {
+ goto fail;
+ }
+ } while (msg->seq < lock_sequence);
+
+ if (msg->seq == lock_sequence) {
+ switch(msg->id) {
+ case CAMEL_LOCK_HELPER_STATUS_OK:
+ d(printf("lock child unlocked ok\n"));
+ res = 0;
+ break;
+ default:
+ d(printf("locking failed ! \n"));
+ break;
+ }
+ } else if (retry > 0) {
+ d(printf("sequence failure, lost message? retry?\n"));
+ lock_sequence++;
+ retry--;
+ goto again;
+ }
+
+fail:
+ lock_sequence++;
+
+ UNLOCK();
+
+ return res;
+}
+
+#if 0
+int main(int argc, char **argv)
+{
+ int id1, id2;
+
+ d(printf("locking started\n"));
+ camel_lock_helper_init();
+
+ id1 = camel_lock_helper_lock("1 path 1");
+ if (id1 != -1) {
+ d(printf("lock ok, unlock\n"));
+ camel_lock_helper_unlock(id1);
+ }
+
+ id1 = camel_lock_helper_lock("2 path 1");
+ id2 = camel_lock_helper_lock("2 path 2");
+ camel_lock_helper_unlock(id2);
+ camel_lock_helper_unlock(id1);
+
+ id1 = camel_lock_helper_lock("3 path 1");
+ id2 = camel_lock_helper_lock("3 path 2");
+ camel_lock_helper_unlock(id1);
+}
+#endif
diff --git a/camel/camel-lock-client.h b/camel/camel-lock-client.h
new file mode 100644
index 0000000000..94063a5484
--- /dev/null
+++ b/camel/camel-lock-client.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Author: Michael Zucchi <notzed@ximian.com>
+ *
+ * Copyright (C) 2001 Ximian Inc (http://www.ximian.com/)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+/* defines protocol for lock helper process ipc */
+
+#ifndef _CAMEL_LOCK_CLIENT_H
+#define _CAMEL_LOCK_CLIENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+#include <camel/camel-exception.h>
+
+int camel_lock_helper_lock(const char *path , CamelException *ex);
+int camel_lock_helper_unlock(int lockid);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !_CAMEL_LOCK_HELPER_H */
diff --git a/camel/camel-lock-helper.c b/camel/camel-lock-helper.c
new file mode 100644
index 0000000000..06463f2cf4
--- /dev/null
+++ b/camel/camel-lock-helper.c
@@ -0,0 +1,389 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2001 Ximian Inc.
+ *
+ * Authors: Michael Zucchi <notzed@ximian.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+/* lock helper process */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <errno.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <signal.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <utime.h>
+
+#include <time.h>
+
+#define SETEUID_SAVES (1)
+
+/* we try and include as little as possible */
+
+#include "camel-lock-helper.h"
+#include "camel-lock.h"
+
+#define d(x)
+
+/* keeps track of open locks */
+struct _lock_info {
+ struct _lock_info *next;
+ uid_t uid;
+ int id;
+ int depth;
+ time_t stamp; /* when last updated */
+ char path[1];
+};
+
+static int lock_id = 0;
+static struct _lock_info *lock_info_list;
+static uid_t lock_root_uid = -1;
+static uid_t lock_real_uid = -1;
+
+/* utility functions */
+
+static int read_n(int fd, void *buffer, int inlen)
+{
+ char *p = buffer;
+ int len, left = inlen;
+
+ do {
+ len = read(fd, p, left);
+ if (len == -1) {
+ if (errno != EINTR)
+ return -1;
+ } else {
+ left -= len;
+ p += len;
+ }
+ } while (left > 0 && len != 0);
+
+ return inlen - left;
+}
+
+static int write_n(int fd, void *buffer, int inlen)
+{
+ char *p = buffer;
+ int len, left = inlen;
+
+ do {
+ len = write(fd, p, left);
+ if (len == -1) {
+ if (errno != EINTR)
+ return -1;
+ } else {
+ left -= len;
+ p += len;
+ }
+ } while (left > 0);
+
+ return inlen;
+}
+
+void
+camel_exception_setv (CamelException *ex, ExceptionId id, const char *format, ...)
+{
+ ;
+}
+
+void
+camel_exception_clear (CamelException *exception)
+{
+ ;
+}
+
+char *gettext (const char *msgid);
+
+char *
+gettext (const char *msgid)
+{
+ return NULL;
+}
+
+static int lock_path(const char *path, guint32 *lockid)
+{
+ struct _lock_info *info = NULL;
+ int res = CAMEL_LOCK_HELPER_STATUS_OK;
+ struct stat st;
+
+ d(fprintf(stderr, "locking path '%s' id = %d\n", path, lock_id));
+
+ /* check to see if we have it locked already, make the lock 'recursive' */
+ /* we could also error i suppose, but why bother */
+ info = lock_info_list;
+ while (info) {
+ if (!strcmp(info->path, path)) {
+ info->depth++;
+ return CAMEL_LOCK_HELPER_STATUS_OK;
+ }
+ info = info->next;
+ }
+
+ /* check we are allowed to lock it, we must own it, be able to write to it, and it has to exist */
+ if (stat(path, &st) == -1
+ || st.st_uid != getuid()
+ || !S_ISREG(st.st_mode)
+ || (st.st_mode & 0400) == 0) {
+ return CAMEL_LOCK_HELPER_STATUS_INVALID;
+ }
+
+ info = malloc(sizeof(*info) + strlen(path));
+ if (info == NULL) {
+ res = CAMEL_LOCK_HELPER_STATUS_NOMEM;
+ goto fail;
+ }
+
+ /* we try the real uid first, and if that fails, try the 'root id' */
+ if (camel_lock_dot(path, NULL) == -1) {
+#ifdef SETEUID_SAVES
+ if (lock_real_uid != lock_root_uid) {
+ if (seteuid(lock_root_uid) != -1) {
+ if (camel_lock_dot(path, NULL) == -1) {
+ seteuid(lock_real_uid);
+ res = CAMEL_LOCK_HELPER_STATUS_SYSTEM;
+ goto fail;
+ }
+ seteuid(lock_real_uid);
+ } else {
+ res = CAMEL_LOCK_HELPER_STATUS_SYSTEM;
+ goto fail;
+ }
+ } else {
+ res = CAMEL_LOCK_HELPER_STATUS_SYSTEM;
+ goto fail;
+ }
+#else
+ res = CAMEL_LOCK_HELPER_STATUS_SYSTEM;
+ goto fail;
+#endif
+ } else {
+ info->uid = lock_real_uid;
+ }
+
+ strcpy(info->path, path);
+ info->id = lock_id;
+ info->depth = 1;
+ info->next = lock_info_list;
+ info->stamp = time(0);
+ lock_info_list = info;
+
+ if (lockid)
+ *lockid = lock_id;
+
+ lock_id++;
+
+ d(fprintf(stderr, "lock ok\n"));
+
+ return res;
+fail:
+ d(fprintf(stderr, "lock failed\n"));
+
+ if (info)
+ free(info);
+
+ return res;
+}
+
+static int unlock_id(guint32 lockid)
+{
+ struct _lock_info *info, *p;
+
+ d(fprintf(stderr, "unlocking id '%d'\n", lockid));
+
+ p = (struct _lock_info *)&lock_info_list;
+ info = p->next;
+ while (info) {
+ if (info->id == lockid) {
+ d(fprintf(stderr, "found id %d path '%s'\n", lockid, info->path));
+ info->depth--;
+ if (info->depth <= 0) {
+#ifdef SETEUID_SAVES
+ if (info->uid != lock_real_uid) {
+ seteuid(lock_root_uid);
+ camel_unlock_dot(info->path);
+ seteuid(lock_real_uid);
+ }
+#else
+ camel_unlock_dot(info->path);
+#endif
+ p->next = info->next;
+ free(info);
+ }
+
+ return CAMEL_LOCK_HELPER_STATUS_OK;
+ }
+ p = info;
+ info = info->next;
+ }
+
+ d(fprintf(stderr, "unknown id asked to be unlocked %d\n", lockid));
+ return CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
+}
+
+static void lock_touch(const char *path)
+{
+ char *name;
+
+ /* we could also check that we haven't had our lock stolen from us here */
+
+ name = alloca(strlen(path) + 10);
+ sprintf(name, "%s.lock", path);
+
+ d(fprintf(stderr, "Updating lock %s\n", name));
+ utime(name, NULL);
+}
+
+static void setup_process(void)
+{
+ struct sigaction sa;
+ sigset_t sigset;
+
+ /* ignore sigint/sigio */
+ sa.sa_handler = SIG_IGN;
+ sigemptyset (&sa.sa_mask);
+ sa.sa_flags = 0;
+
+ sigemptyset(&sigset);
+ sigaddset(&sigset, SIGIO);
+ sigaddset(&sigset, SIGINT);
+ sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+
+ sigaction (SIGIO, &sa, NULL);
+ sigaction (SIGINT, &sa, NULL);
+
+ /* FIXME: add more sanity checks/setup here */
+
+#ifdef SETEUID_SAVES
+ /* here we change to the real user id, this is probably not particularly
+ portable so may need configure checks */
+ lock_real_uid = getuid();
+ lock_root_uid = geteuid();
+ if (lock_real_uid != lock_root_uid)
+ seteuid(lock_real_uid);
+#endif
+}
+
+int main(int argc, char **argv)
+{
+ struct _CamelLockHelperMsg msg;
+ int len;
+ int res;
+ char *path;
+ fd_set rset;
+ struct timeval tv;
+ struct _lock_info *info;
+
+ setup_process();
+
+ do {
+ /* do a poll/etc, so we can refresh the .locks as required ... */
+ FD_ZERO(&rset);
+ FD_SET(STDIN_FILENO, &rset);
+
+ /* check the minimum timeout we need to refresh the next oldest lock */
+ if (lock_info_list) {
+ time_t now = time(0);
+ time_t left;
+ time_t delay = CAMEL_DOT_LOCK_REFRESH;
+
+ info = lock_info_list;
+ while (info) {
+ left = CAMEL_DOT_LOCK_REFRESH - (now - info->stamp);
+ left = MAX(left, 0);
+ delay = MIN(left, delay);
+ info = info->next;
+ }
+
+ tv.tv_sec = delay;
+ tv.tv_usec = 0;
+ }
+
+ d(fprintf(stderr, "lock helper waiting for input\n"));
+ if (select(STDIN_FILENO+1, &rset, NULL, NULL, lock_info_list?&tv:NULL) == -1) {
+ if (errno == EINTR)
+ break;
+
+ continue;
+ }
+
+ /* did we get a timeout? scan for any locks that need updating */
+ if (!FD_ISSET(STDIN_FILENO, &rset)) {
+ time_t now = time(0);
+ time_t left;
+
+ d(fprintf(stderr, "Got a timeout, checking locks\n"));
+
+ info = lock_info_list;
+ while (info) {
+ left = (now - info->stamp);
+ if (left >= CAMEL_DOT_LOCK_REFRESH) {
+ lock_touch(info->path);
+ info->stamp = now;
+ }
+ info = info->next;
+ }
+
+ continue;
+ }
+
+
+ len = read_n(STDIN_FILENO, &msg, sizeof(msg));
+ if (len == 0)
+ break;
+
+ res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
+ if (len == sizeof(msg) && msg.magic == CAMEL_LOCK_HELPER_MAGIC) {
+ switch(msg.id) {
+ case CAMEL_LOCK_HELPER_LOCK:
+ res = CAMEL_LOCK_HELPER_STATUS_NOMEM;
+ path = malloc(msg.data+1);
+ if (path != NULL) {
+ res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
+ len = read_n(STDIN_FILENO, path, msg.data);
+ if (len == msg.data) {
+ path[len] = 0;
+ res = lock_path(path, &msg.data);
+ }
+ free(path);
+ }
+ break;
+ case CAMEL_LOCK_HELPER_UNLOCK:
+ res = unlock_id(msg.data);
+ break;
+ }
+ }
+ d(fprintf(stderr, "returning result %d\n", res));
+ msg.id = res;
+ msg.magic = CAMEL_LOCK_HELPER_RETURN_MAGIC;
+ write_n(STDOUT_FILENO, &msg, sizeof(msg));
+ } while (1);
+
+ d(fprintf(stderr, "parent exited, clsoing down remaining id's\n"));
+ while (lock_info_list)
+ unlock_id(lock_info_list->id);
+
+ return 0;
+}
diff --git a/camel/camel-lock-helper.h b/camel/camel-lock-helper.h
new file mode 100644
index 0000000000..3f5bd45f86
--- /dev/null
+++ b/camel/camel-lock-helper.h
@@ -0,0 +1,70 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Author: Michael Zucchi <notzed@helixcode.com>
+ *
+ * Copyright (C) 1999 Helix Code (http://www.helixcode.com/).
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+/* defines protocol for lock helper process ipc */
+
+#ifndef _CAMEL_LOCK_HELPER_H
+#define _CAMEL_LOCK_HELPER_H
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+#include <glib.h>
+
+struct _CamelLockHelperMsg {
+ guint32 magic;
+ guint32 seq;
+ guint32 id;
+ guint32 data;
+};
+
+/* magic values */
+enum {
+ CAMEL_LOCK_HELPER_MAGIC = 0xABADF00D,
+ CAMEL_LOCK_HELPER_RETURN_MAGIC = 0xDEADBEEF
+};
+
+/* return status */
+enum {
+ CAMEL_LOCK_HELPER_STATUS_OK = 0,
+ CAMEL_LOCK_HELPER_STATUS_PROTOCOL,
+ CAMEL_LOCK_HELPER_STATUS_NOMEM,
+ CAMEL_LOCK_HELPER_STATUS_SYSTEM,
+ CAMEL_LOCK_HELPER_STATUS_INVALID, /* not allowed to lock/doesn't exist etc */
+};
+
+/* commands */
+enum {
+ CAMEL_LOCK_HELPER_LOCK = 0xf0f,
+ CAMEL_LOCK_HELPER_UNLOCK = 0xf0f0,
+};
+
+/* seconds between lock refreshes */
+#define CAMEL_DOT_LOCK_REFRESH (30)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !_CAMEL_LOCK_HELPER_H */
diff --git a/camel/providers/local/camel-maildir-store.c b/camel/providers/local/camel-maildir-store.c
index 8fa4454485..b85bdc3aeb 100644
--- a/camel/providers/local/camel-maildir-store.c
+++ b/camel/providers/local/camel-maildir-store.c
@@ -46,6 +46,8 @@ static CamelLocalStoreClass *parent_class = NULL;
static CamelFolder *get_folder(CamelStore * store, const char *folder_name, guint32 flags, CamelException * ex);
static void delete_folder(CamelStore * store, const char *folder_name, CamelException * ex);
+static CamelFolderInfo * get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex);
+
static void camel_maildir_store_class_init(CamelObjectClass * camel_maildir_store_class)
{
CamelStoreClass *camel_store_class = CAMEL_STORE_CLASS(camel_maildir_store_class);
@@ -56,6 +58,9 @@ static void camel_maildir_store_class_init(CamelObjectClass * camel_maildir_stor
/* virtual method overload, use defaults for most */
camel_store_class->get_folder = get_folder;
camel_store_class->delete_folder = delete_folder;
+
+ camel_store_class->get_folder_info = get_folder_info;
+ camel_store_class->free_folder_info = camel_store_free_folder_info_full;
}
CamelType camel_maildir_store_get_type(void)
@@ -198,3 +203,112 @@ static void delete_folder(CamelStore * store, const char *folder_name, CamelExce
g_free(cur);
g_free(new);
}
+
+static CamelFolderInfo *camel_folder_info_new(const char *url, const char *full, const char *name, int unread)
+{
+ CamelFolderInfo *fi;
+
+ fi = g_malloc0(sizeof(*fi));
+ fi->url = g_strdup(url);
+ fi->full_name = g_strdup(full);
+ fi->name = g_strdup(name);
+ fi->unread_message_count = unread;
+
+ return fi;
+}
+
+static int scan_dir(char *root, const char *path, guint32 flags, CamelFolderInfo *parent, CamelFolderInfo **fip, CamelException *ex)
+{
+ DIR *dir;
+ struct dirent *d;
+ char *name, *uri, *tmp, *cur, *new;
+ const char *base;
+ CamelFolderInfo *fi = NULL;
+ struct stat st;
+
+ /* look for folders matching the right structure, recursively */
+ name = g_strdup_printf("%s/%s", root, path);
+
+ printf("checking dir '%s' part '%s' for maildir content\n", root, path);
+
+ tmp = g_strdup_printf("%s/tmp", name);
+ cur = g_strdup_printf("%s/cur", name);
+ new = g_strdup_printf("%s/new", name);
+
+ if (stat(tmp, &st) == 0 && S_ISDIR(st.st_mode)
+ && stat(cur, &st) == 0 && S_ISDIR(st.st_mode)
+ && stat(new, &st) == 0 && S_ISDIR(st.st_mode)) {
+ uri = g_strdup_printf("maildir://%s#%s", root, path);
+ base = strrchr(path, '/');
+ if (base)
+ base++;
+ else
+ base = path;
+ fi = camel_folder_info_new(uri, path, base, -1);
+
+ printf("found! uri = %s\n", fi->url);
+ printf(" full_name = %s\n name = '%s'\n", fi->full_name, fi->name);
+
+ fi->parent = parent;
+ fi->sibling = *fip;
+ *fip = fi;
+ g_free(uri);
+ }
+
+ g_free(tmp);
+ g_free(cur);
+ g_free(new);
+
+ /* we only look further if we found one at this level */
+ if (fi && ((flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE) || parent == NULL)) {
+ dir = opendir(name);
+ if (dir == NULL) {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
+ _("Could not scan folder `%s': %s"),
+ root, strerror(errno));
+ g_free(name);
+ return -1;
+ }
+
+ while ( (d = readdir(dir)) ) {
+ if (strcmp(d->d_name, "tmp") == 0
+ || strcmp(d->d_name, "cur") == 0
+ || strcmp(d->d_name, "new") == 0
+ || strcmp(d->d_name, ".") == 0
+ || strcmp(d->d_name, "..") == 0)
+ continue;
+
+ tmp = g_strdup_printf("%s/%s", name, d->d_name);
+ if (stat(tmp, &st) == 0 && S_ISDIR(st.st_mode)) {
+ new = g_strdup_printf("%s/%s", path, d->d_name);
+ if (scan_dir(root, new, flags, fi, &fi->child, ex) == -1) {
+ g_free(tmp);
+ g_free(new);
+ closedir(dir);
+ return -1;
+ }
+ g_free(new);
+ }
+ g_free(tmp);
+ }
+ closedir(dir);
+ }
+
+ g_free(name);
+
+ return 0;
+}
+
+static CamelFolderInfo *
+get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex)
+{
+ CamelFolderInfo *fi = NULL;
+ CamelService *service = (CamelService *)store;
+
+ if (scan_dir(service->url->path, top?top:".", flags, NULL, &fi, ex) == -1 && fi != NULL) {
+ camel_store_free_folder_info_full(store, fi);
+ fi = NULL;
+ }
+
+ return fi;
+}
diff --git a/camel/providers/local/camel-spool-folder.c b/camel/providers/local/camel-spool-folder.c
index 0df6fae026..acbdb8d1e7 100644
--- a/camel/providers/local/camel-spool-folder.c
+++ b/camel/providers/local/camel-spool-folder.c
@@ -44,6 +44,8 @@
#include "camel-mime-filter-from.h"
#include "camel-exception.h"
+#include "camel-lock-client.h"
+
#include "camel-local-private.h"
#define d(x) /*(printf("%s(%d): ", __FILE__, __LINE__),(x))*/
@@ -187,22 +189,25 @@ camel_spool_folder_construct(CamelSpoolFolder *lf, CamelStore *parent_store, con
root_dir_path = camel_spool_store_get_toplevel_dir(CAMEL_SPOOL_STORE(folder->parent_store));
lf->base_path = g_strdup(root_dir_path);
- lf->folder_path = g_strdup_printf("%s/%s", root_dir_path, full_name);
+ lf->folder_path = g_strdup(root_dir_path);
lf->changes = camel_folder_change_info_new();
lf->flags = flags;
folder->summary = (CamelFolderSummary *)camel_spool_summary_new(lf->folder_path);
- if (camel_spool_folder_lock(lf, CAMEL_LOCK_WRITE, ex) != -1) {
- camel_spool_summary_check((CamelSpoolSummary *)folder->summary, NULL, ex);
- camel_spool_folder_unlock(lf);
+ if (camel_spool_folder_lock(lf, CAMEL_LOCK_WRITE, ex) == -1) {
+ camel_object_unref((CamelObject *)lf);
+ return NULL;
}
+ camel_spool_summary_check((CamelSpoolSummary *)folder->summary, NULL, ex);
+ camel_spool_folder_unlock(lf);
+
fi = g_malloc0(sizeof(*fi));
fi->full_name = g_strdup(full_name);
fi->name = g_strdup(name);
fi->url = g_strdup(lf->folder_path);
- fi->unread_message_count = -1;
+ fi->unread_message_count = camel_folder_get_unread_message_count(folder);
camel_object_trigger_event(CAMEL_OBJECT(parent_store), "folder_created", fi);
camel_folder_info_free (fi);
@@ -256,13 +261,44 @@ int camel_spool_folder_unlock(CamelSpoolFolder *lf)
static int
spool_lock(CamelSpoolFolder *lf, CamelLockType type, CamelException *ex)
{
- return 0;
+ int retry = 0;
+
+ lf->lockfd = open(lf->folder_path, O_RDWR, 0);
+ if (lf->lockfd == -1) {
+ camel_exception_setv(ex, 1, _("Cannot create folder lock on %s: %s"), lf->folder_path, strerror(errno));
+ return -1;
+ }
+
+ while (retry < CAMEL_LOCK_RETRY) {
+ if (retry > 0)
+ sleep(CAMEL_LOCK_DELAY);
+
+ camel_exception_clear(ex);
+
+ if (camel_lock_fcntl(lf->lockfd, type, ex) == 0) {
+ if (camel_lock_flock(lf->lockfd, type, ex) == 0) {
+ if ((lf->lockid = camel_lock_helper_lock(lf->folder_path, ex)) != -1)
+ return 0;
+ camel_unlock_flock(lf->lockfd);
+ }
+ camel_unlock_fcntl(lf->lockfd);
+ }
+ retry++;
+ }
+
+ return -1;
}
static void
spool_unlock(CamelSpoolFolder *lf)
{
- /* nothing */
+ camel_lock_helper_unlock(lf->lockid);
+ lf->lockid = -1;
+ camel_unlock_flock(lf->lockid);
+ camel_unlock_fcntl(lf->lockid);
+
+ close(lf->lockfd);
+ lf->lockfd = -1;
}
static void
@@ -479,10 +515,14 @@ spool_get_message(CamelFolder *folder, const gchar * uid, CamelException *ex)
d(printf("Getting message %s\n", uid));
- /* lock the folder first, burn if we can't */
- if (camel_spool_folder_lock(lf, CAMEL_LOCK_READ, ex) == -1)
+ /* lock the folder first, burn if we can't, need write lock for summary check */
+ if (camel_spool_folder_lock(lf, CAMEL_LOCK_WRITE, ex) == -1)
return NULL;
-
+
+ /* check for new messages, this may renumber uid's though */
+ if (camel_spool_summary_check((CamelSpoolSummary *)folder->summary, lf->changes, ex) == -1)
+ return NULL;
+
retry:
/* get the message summary info */
info = (CamelSpoolMessageInfo *) camel_folder_summary_uid(folder->summary, uid);
diff --git a/camel/providers/local/camel-spool-folder.h b/camel/providers/local/camel-spool-folder.h
index 87b8c16b0d..2b09802678 100644
--- a/camel/providers/local/camel-spool-folder.h
+++ b/camel/providers/local/camel-spool-folder.h
@@ -49,6 +49,8 @@ typedef struct {
int locked; /* lock counter */
CamelLockType locktype; /* what type of lock we have */
+ int lockfd; /* lock fd used for fcntl/etc locking */
+ int lockid; /* lock id for dot locking */
char *base_path; /* base path of the spool folder */
char *folder_path; /* the path to the folder itself */
diff --git a/camel/providers/local/camel-spool-store.c b/camel/providers/local/camel-spool-store.c
index 5ef47347d1..655050c5f4 100644
--- a/camel/providers/local/camel-spool-store.c
+++ b/camel/providers/local/camel-spool-store.c
@@ -46,8 +46,9 @@ static CamelFolder *get_folder(CamelStore * store, const char *folder_name, guin
static char *get_name(CamelService *service, gboolean brief);
static CamelFolder *get_inbox (CamelStore *store, CamelException *ex);
static void rename_folder(CamelStore *store, const char *old_name, const char *new_name, CamelException *ex);
-static CamelFolderInfo *get_folder_info (CamelStore *store, const char *top,
- guint32 flags, CamelException *ex);
+static CamelFolderInfo *get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex);
+static void free_folder_info (CamelStore *store, CamelFolderInfo *fi);
+
static void delete_folder(CamelStore *store, const char *folder_name, CamelException *ex);
static void rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex);
@@ -67,7 +68,7 @@ camel_spool_store_class_init (CamelSpoolStoreClass *camel_spool_store_class)
camel_store_class->get_folder = get_folder;
camel_store_class->get_inbox = get_inbox;
camel_store_class->get_folder_info = get_folder_info;
- camel_store_class->free_folder_info = camel_store_free_folder_info_full;
+ camel_store_class->free_folder_info = free_folder_info;
camel_store_class->delete_folder = delete_folder;
camel_store_class->rename_folder = rename_folder;
@@ -95,15 +96,42 @@ static void
construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex)
{
int len;
+ char *path, *name;
+ struct stat st;
+
+ printf("constructing store of type %s '%s:%s'\n",
+ camel_type_to_name(((CamelObject *)service)->s.type), url->protocol, url->path);
CAMEL_SERVICE_CLASS (parent_class)->construct (service, session, provider, url, ex);
if (camel_exception_is_set (ex))
return;
+ if (service->url->path[0] != '/') {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+ _("Store root %s is not an absolute path"), service->url->path);
+ return;
+ }
+
len = strlen (service->url->path);
- if (service->url->path[len - 1] != '/') {
+ if (len > 0 && service->url->path[len - 1] == '/') {
service->url->path = g_realloc (service->url->path, len + 2);
- strcpy (service->url->path + len, "/");
+ service->url->path[len-1] = 0;
+ }
+
+ path = service->url->path;
+ len = strlen(path);
+ name = path;
+#if 0
+ name = alloca(len+1);
+ strcpy(name, path);
+ name[len-1] = 0;
+#endif
+
+ if (stat(name, &st) == -1 || !S_ISREG(st.st_mode)) {
+ camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+ _("Spool `%s' does not exist or is not a regular file"),
+ path);
+ return;
}
}
@@ -119,35 +147,26 @@ camel_spool_store_get_toplevel_dir (CamelSpoolStore *store)
static CamelFolder *
get_folder(CamelStore * store, const char *folder_name, guint32 flags, CamelException * ex)
{
- struct stat st;
char *path = ((CamelService *)store)->url->path;
char *name;
+ int len;
- if (path[0] != '/') {
- camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
- _("Store root %s is not an absolute path"), path);
- return NULL;
- }
-
- name = g_strdup_printf("%s%s", CAMEL_SERVICE(store)->url->path, folder_name);
+ printf("opening folder %s on path %s\n", folder_name, path);
- if (stat(name, &st) == -1) {
+ /* we only support an 'INBOX' */
+ if (strcmp(folder_name, "INBOX") != 0) {
camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
_("Folder `%s/%s' does not exist."),
path, folder_name);
- g_free(name);
- return NULL;
- } else if (!S_ISREG(st.st_mode)) {
- camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
- _("`%s' is not a regular file."),
- name);
- g_free(name);
return NULL;
}
- g_free(name);
+ len = strlen(path);
+ name = alloca(len+1);
+ strcpy(name, path);
+ name[len-1] = 0;
- return camel_spool_folder_new(store, folder_name, flags, ex);
+ return camel_spool_folder_new(store, name, flags, ex);
}
static CamelFolder *
@@ -171,12 +190,30 @@ static CamelFolderInfo *
get_folder_info (CamelStore *store, const char *top,
guint32 flags, CamelException *ex)
{
- /* FIXME: This is broken, but it corresponds to what was
- * there before.
- */
- return NULL;
+ CamelFolderInfo *fi = NULL;
+ CamelService *service = (CamelService *)store;
+
+ if (top == NULL || strcmp(top, "/INBOX") == 0) {
+ /* FIXME: if the folder is opened we could look it up? */
+ fi = g_malloc0(sizeof(*fi));
+ fi->full_name = "/INBOX";
+ fi->name = "INBOX";
+ fi->url = g_strdup_printf("spool://%s#%s", service->url->path, fi->name);
+ fi->unread_message_count = -1;
+ }
+
+ return fi;
}
+static void free_folder_info (CamelStore *store, CamelFolderInfo *fi)
+{
+ if (fi) {
+ g_free(fi->url);
+ g_free(fi);
+ }
+}
+
+
/* default implementation, rename all */
static void
rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex)
diff --git a/camel/providers/local/camel-spool-store.h b/camel/providers/local/camel-spool-store.h
index 1b118d4742..d348421e3c 100644
--- a/camel/providers/local/camel-spool-store.h
+++ b/camel/providers/local/camel-spool-store.h
@@ -40,7 +40,7 @@ extern "C" {
typedef struct {
CamelStore parent_object;
-
+
} CamelSpoolStore;
diff --git a/camel/providers/local/camel-spool-summary.c b/camel/providers/local/camel-spool-summary.c
index 594a33d744..5d508f643a 100644
--- a/camel/providers/local/camel-spool-summary.c
+++ b/camel/providers/local/camel-spool-summary.c
@@ -513,7 +513,7 @@ spool_summary_check(CamelSpoolSummary *cls, CamelFolderChangeInfo *changeinfo, C
if (st.st_size != cls->folder_size || st.st_mtime != s->time) {
if (cls->folder_size < st.st_size) {
/* this will automatically rescan from 0 if there is a problem */
- d(printf("folder grew, attempting to rebuild from %d\n", cls>folder_size));
+ d(printf("folder grew, attempting to rebuild from %d\n", cls->folder_size));
ret = summary_update(cls, cls->folder_size, changeinfo, ex);
} else {
d(printf("folder shrank! rebuilding from start\n"));
@@ -538,6 +538,7 @@ spool_summary_check(CamelSpoolSummary *cls, CamelFolderChangeInfo *changeinfo, C
/* if we do, then write out the headers using sync_full, etc */
if (work) {
+ d(printf("Have to add new headers, re-syncing from the start to accomplish this\n"));
ret = spool_summary_sync_full(cls, FALSE, changeinfo, ex);
if (stat(cls->folder_path, &st) == -1) {
@@ -683,7 +684,7 @@ spool_summary_sync_full(CamelSpoolSummary *cls, gboolean expunge, CamelFolderCha
g_assert(info);
- d(printf("Looking at message %s\n", info->info.uid));
+ d(printf("Looking at message %s\n", camel_message_info_uid(info)));
/* only need to seek past deleted messages, otherwise we should be at the right spot/state already */
if (lastdel) {
@@ -735,7 +736,7 @@ spool_summary_sync_full(CamelSpoolSummary *cls, gboolean expunge, CamelFolderCha
}
if (info && info->info.flags & (CAMEL_MESSAGE_FOLDER_NOXEV | CAMEL_MESSAGE_FOLDER_FLAGGED)) {
- d(printf("Updating header for %s flags = %08x\n", info->info.uid, info->info.flags));
+ d(printf("Updating header for %s flags = %08x\n", camel_message_info_uid(info), info->info.flags));
if (camel_mime_parser_step(mp, &buffer, &len) == HSCAN_FROM_END) {
g_warning("camel_mime_parser_step failed (2)");
@@ -955,7 +956,7 @@ spool_summary_sync_quick(CamelSpoolSummary *cls, gboolean expunge, CamelFolderCh
g_assert(info);
- d(printf("Checking message %s %08x\n", info->info.uid, info->info.flags));
+ d(printf("Checking message %s %08x\n", camel_message_info_uid(info), info->info.flags));
if ((info->info.flags & CAMEL_MESSAGE_FOLDER_FLAGGED) == 0) {
camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
@@ -963,7 +964,7 @@ spool_summary_sync_quick(CamelSpoolSummary *cls, gboolean expunge, CamelFolderCh
continue;
}
- d(printf("Updating message %s\n", info->info.uid));
+ d(printf("Updating message %s\n", camel_message_info_uid(info)));
camel_mime_parser_seek(mp, info->frompos, SEEK_SET);
@@ -1125,7 +1126,7 @@ spool_summary_add(CamelSpoolSummary *cls, CamelMimeMessage *msg, const CamelMess
mi = camel_folder_summary_add_from_message((CamelFolderSummary *)cls, msg);
if (mi) {
- d(printf("Added, uid = %s\n", mi->uid));
+ d(printf("Added, uid = %s\n", camel_message_info_uid(mi)));
if (info) {
CamelTag *tag = info->user_tags;
CamelFlag *flag = info->user_flags;
diff --git a/camel/tests/folder/test2.c b/camel/tests/folder/test2.c
index 9ea0efabbb..50a89f89e8 100644
--- a/camel/tests/folder/test2.c
+++ b/camel/tests/folder/test2.c
@@ -49,7 +49,7 @@ int main(int argc, char **argv)
/* create a pseudo-spool file, and check that */
creat("/tmp/camel-test/testbox", 0600);
- test_folder_message_ops(session, "spool:///tmp/camel-test", FALSE, TRUE);
+ test_folder_message_ops(session, "spool:///tmp/camel-test/testbox", FALSE, TRUE);
check_unref(session, 1);
camel_exception_free(ex);
diff --git a/camel/tests/lib/folders.c b/camel/tests/lib/folders.c
index 2e9638a25f..86d9a1f3ff 100644
--- a/camel/tests/lib/folders.c
+++ b/camel/tests/lib/folders.c
@@ -308,6 +308,12 @@ test_folder_message_ops(CamelSession *session, const char *name, int local, int
int indexed, max;
GPtrArray *uids;
CamelMessageInfo *info;
+ char *mailbox;
+
+ if (spool)
+ mailbox = "INBOX";
+ else
+ mailbox = "testbox";
max=local?2:1;
@@ -329,7 +335,7 @@ test_folder_message_ops(CamelSession *session, const char *name, int local, int
flags = CAMEL_STORE_FOLDER_CREATE|CAMEL_STORE_FOLDER_BODY_INDEX;
else
flags = CAMEL_STORE_FOLDER_CREATE;
- folder = camel_store_get_folder(store, "testbox", flags, ex);
+ folder = camel_store_get_folder(store, mailbox, flags, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
@@ -396,13 +402,13 @@ test_folder_message_ops(CamelSession *session, const char *name, int local, int
pull();
push("deleting test folder, with messages in it");
- camel_store_delete_folder(store, "testbox", ex);
+ camel_store_delete_folder(store, mailbox, ex);
check(camel_exception_is_set(ex));
camel_exception_clear(ex);
pull();
push("re-opening folder");
- folder = camel_store_get_folder(store, "testbox", flags, ex);
+ folder = camel_store_get_folder(store, mailbox, flags, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
@@ -505,7 +511,7 @@ test_folder_message_ops(CamelSession *session, const char *name, int local, int
if (!spool) {
push("deleting test folder, with no messages in it");
- camel_store_delete_folder(store, "testbox", ex);
+ camel_store_delete_folder(store, mailbox, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
}
generated by cgit (git 2.34.1) at 2024-11-16 22:09:10 +0800