From e905364beee184b99637029de7151b43339b2e1c Mon Sep 17 00:00:00 2001 From: Not Zed Date: Mon, 18 Jun 2001 14:36:44 +0000 Subject: Only create a missing uid if we have indexing turned on. 2001-06-18 Not Zed * 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 * 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 * 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 * 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. svn path=/trunk/; revision=10261 --- camel/ChangeLog | 43 +++ camel/Makefile.am | 19 +- camel/camel-folder-summary.c | 8 +- camel/camel-lock-client.c | 329 +++++++++++++++++++++++ camel/camel-lock-client.h | 42 +++ camel/camel-lock-helper.c | 389 ++++++++++++++++++++++++++++ camel/camel-lock-helper.h | 70 +++++ camel/providers/local/camel-maildir-store.c | 114 ++++++++ camel/providers/local/camel-spool-folder.c | 60 ++++- camel/providers/local/camel-spool-folder.h | 2 + camel/providers/local/camel-spool-store.c | 91 +++++-- camel/providers/local/camel-spool-store.h | 2 +- camel/providers/local/camel-spool-summary.c | 13 +- camel/tests/folder/test2.c | 2 +- camel/tests/lib/folders.c | 14 +- 15 files changed, 1145 insertions(+), 53 deletions(-) create mode 100644 camel/camel-lock-client.c create mode 100644 camel/camel-lock-client.h create mode 100644 camel/camel-lock-helper.c create mode 100644 camel/camel-lock-helper.h (limited to 'camel') 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 + + * 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 + + * 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 + + * 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 + + * 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 * 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 + * + * 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 +#endif + +#include +#include + +#include +#include + +#include +#include +#include + +#include +#include + +#ifdef ENABLE_THREADS +#include +#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 + * + * 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 + +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 + * + * 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 +#include + +#include + +#include +#include +#include + +#include + +#include +#include +#include + +#include + +#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 + * + * 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 + +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(); } -- cgit v1.2.3