summaryrefslogtreecommitdiffabout
path: root/kmicromail/libetpan/mh/mailmh.c
authorzautrix <zautrix>2004-07-03 16:33:12 (UTC)
committer zautrix <zautrix>2004-07-03 16:33:12 (UTC)
commite3b89230f065c48c84b48c88edb6eb088374c487 (patch) (side-by-side diff)
tree162ea2ef909a6f82ccfcedf45d80d6c821174912 /kmicromail/libetpan/mh/mailmh.c
parent2dd6ac0b2d24c91d35ce674a6c26351352df2b15 (diff)
downloadkdepimpi-e3b89230f065c48c84b48c88edb6eb088374c487.zip
kdepimpi-e3b89230f065c48c84b48c88edb6eb088374c487.tar.gz
kdepimpi-e3b89230f065c48c84b48c88edb6eb088374c487.tar.bz2
Initial revision
Diffstat (limited to 'kmicromail/libetpan/mh/mailmh.c') (more/less context) (ignore whitespace changes)
-rw-r--r--kmicromail/libetpan/mh/mailmh.c965
1 files changed, 965 insertions, 0 deletions
diff --git a/kmicromail/libetpan/mh/mailmh.c b/kmicromail/libetpan/mh/mailmh.c
new file mode 100644
index 0000000..d6ff950
--- a/dev/null
+++ b/kmicromail/libetpan/mh/mailmh.c
@@ -0,0 +1,965 @@
+/*
+ * libEtPan! -- a mail stuff library
+ *
+ * Copyright (C) 2001, 2002 - DINH Viet Hoa
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the libEtPan! project nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * $Id$
+ */
+
+#include "mailmh.h"
+
+/*
+perfs :
+
+/net/home/dinh/Mail/inbox/sylpheed 686
+
+2724 /net/home/dinh/Mail/inbox/sylpheed
+
+bart:~/LibEtPan/libetpan/tests> time ./mhtest >/dev/null
+
+real 0m0.385s
+user 0m0.270s
+sys 0m0.110s
+
+*/
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libetpan-config.h"
+
+struct mailmh * mailmh_new(const char * foldername)
+{
+ struct mailmh * f;
+
+ f = malloc(sizeof(*f));
+ if (f == NULL)
+ return NULL;
+
+ f->mh_main = mailmh_folder_new(NULL, foldername);
+ if (f->mh_main == NULL) {
+ free(f);
+ return NULL;
+ }
+
+ return f;
+}
+
+void mailmh_free(struct mailmh * f)
+{
+ mailmh_folder_free(f->mh_main);
+ free(f);
+}
+
+
+
+struct mailmh_msg_info * mailmh_msg_info_new(uint32_t index, size_t size,
+ time_t mtime)
+{
+ struct mailmh_msg_info * msg_info;
+
+ msg_info = malloc(sizeof(* msg_info));
+ if (msg_info == NULL)
+ return NULL;
+ msg_info->msg_index = index;
+ msg_info->msg_size = size;
+ msg_info->msg_mtime = mtime;
+
+ msg_info->msg_array_index = 0;
+
+ return msg_info;
+}
+
+void mailmh_msg_info_free(struct mailmh_msg_info * msg_info)
+{
+ free(msg_info);
+}
+
+struct mailmh_folder * mailmh_folder_new(struct mailmh_folder * parent,
+ const char * name)
+{
+ char * filename;
+ char * parent_filename;
+
+ struct mailmh_folder * folder;
+
+ folder = malloc(sizeof(* folder));
+ if (folder == NULL)
+ goto err;
+
+ if (parent == NULL) {
+ filename = strdup(name);
+ if (filename == NULL)
+ goto free_folder;
+ }
+ else {
+ parent_filename = parent->fl_filename;
+ filename = malloc(strlen(parent_filename) + strlen(name) + 2);
+ if (filename == NULL)
+ goto free_folder;
+
+ strcpy(filename, parent_filename);
+ strcat(filename, MAIL_DIR_SEPARATOR_S);
+ strcat(filename, name);
+ }
+
+ folder->fl_filename = filename;
+
+ folder->fl_name = strdup(name);
+ if (folder->fl_name == NULL)
+ goto free_filename;
+
+ folder->fl_msgs_tab = carray_new(128);
+ if (folder->fl_msgs_tab == NULL)
+ goto free_name;
+
+#if 0
+ folder->fl_msgs_hash = cinthash_new(128);
+ if (folder->fl_msgs_hash == NULL)
+ goto free_msgs_tab;
+#endif
+ folder->fl_msgs_hash = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYKEY);
+ if (folder->fl_msgs_hash == NULL)
+ goto free_msgs_tab;
+
+ folder->fl_subfolders_tab = carray_new(128);
+ if (folder->fl_subfolders_tab == NULL)
+ goto free_msgs_hash;
+
+ folder->fl_subfolders_hash = chash_new(128, CHASH_COPYNONE);
+ if (folder->fl_subfolders_hash == NULL)
+ goto free_subfolders_tab;
+
+ folder->fl_mtime = 0;
+ folder->fl_parent = parent;
+ folder->fl_max_index = 0;
+
+ return folder;
+
+ free_subfolders_tab:
+ carray_free(folder->fl_subfolders_tab);
+ free_msgs_hash:
+#if 0
+ cinthash_free(folder->fl_msgs_hash);
+#endif
+ chash_free(folder->fl_msgs_hash);
+ free_msgs_tab:
+ carray_free(folder->fl_msgs_tab);
+ free_name:
+ free(folder->fl_name);
+ free_filename:
+ free(folder->fl_filename);
+ free_folder:
+ free(folder);
+ err:
+ return NULL;
+}
+
+void mailmh_folder_free(struct mailmh_folder * folder)
+{
+ unsigned int i;
+
+ for(i = 0 ; i < carray_count(folder->fl_subfolders_tab) ; i++) {
+ struct mailmh_folder * subfolder;
+
+ subfolder = carray_get(folder->fl_subfolders_tab, i);
+ if (subfolder != NULL)
+ mailmh_folder_free(subfolder);
+ }
+ carray_free(folder->fl_subfolders_tab);
+ chash_free(folder->fl_subfolders_hash);
+
+ for(i = 0 ; i < carray_count(folder->fl_msgs_tab) ; i++) {
+ struct mailmh_msg_info * msg_info;
+
+ msg_info = carray_get(folder->fl_msgs_tab, i);
+ if (msg_info != NULL)
+ mailmh_msg_info_free(msg_info);
+ }
+ carray_free(folder->fl_msgs_tab);
+ chash_free(folder->fl_msgs_hash);
+#if 0
+ cinthash_free(folder->fl_msgs_hash);
+#endif
+
+ free(folder->fl_filename);
+ free(folder->fl_name);
+
+ free(folder);
+}
+
+struct mailmh_folder * mailmh_folder_find(struct mailmh_folder * root,
+ const char * filename)
+{
+ int r;
+ char pathname[PATH_MAX];
+ char * p;
+ chashdatum key;
+ chashdatum data;
+ struct mailmh_folder * folder;
+ char * start;
+
+ if (strcmp(root->fl_filename, filename) == 0)
+ return root;
+
+#if 0
+ r = mailmh_folder_update(root);
+ if (r != MAILMH_NO_ERROR)
+ return NULL;
+#endif
+
+#if 0
+ for(i = 0 ; i < root->fl_subfolders_tab->len ; i++) {
+ struct mailmh_folder * subfolder;
+
+ subfolder = carray_get(root->fl_subfolders_tab, i);
+ if (subfolder != NULL)
+ if (strncmp(subfolder->fl_filename, filename,
+ strlen(subfolder->fl_filename)) == 0)
+ return mailmh_folder_find(subfolder, filename);
+ }
+#endif
+ strncpy(pathname, filename, PATH_MAX);
+ pathname[PATH_MAX - 1] = 0;
+ start = pathname + strlen(root->fl_filename) + 1;
+
+ p = strchr(start, MAIL_DIR_SEPARATOR);
+ if (p != NULL) {
+ * p = 0;
+
+ root = mailmh_folder_find(root, pathname);
+ if (root != NULL) {
+ folder = mailmh_folder_find(root, filename);
+ if (folder == NULL)
+ return NULL;
+ return folder;
+ }
+
+ return NULL;
+ }
+ else {
+ key.data = pathname;
+ key.len = strlen(pathname);
+ r = chash_get(root->fl_subfolders_hash, &key, &data);
+ if (r < 0)
+ return NULL;
+
+ return data.data;
+ }
+}
+
+int mailmh_folder_update(struct mailmh_folder * folder)
+{
+ DIR * d;
+ struct dirent * ent;
+ struct stat buf;
+ char * mh_seq;
+ char filename[PATH_MAX];
+ int res;
+ int r;
+ uint32_t max_index;
+#if 0
+ int add_folder;
+#endif
+ unsigned int i;
+
+ if (stat(folder->fl_filename, &buf) == -1) {
+ res = MAILMH_ERROR_FOLDER;
+ goto err;
+ }
+
+ if (folder->fl_mtime == buf.st_mtime) {
+ res = MAILMH_NO_ERROR;
+ goto err;
+ }
+
+ folder->fl_mtime = buf.st_mtime;
+
+ d = opendir(folder->fl_filename);
+ if (d == NULL) {
+ res = MAILMH_ERROR_FOLDER;
+ goto err;
+ }
+
+ max_index = 0;
+
+#if 0
+ if (folder->fl_subfolders_tab->len == 0)
+ add_folder = 1;
+ else
+ add_folder = 0;
+#endif
+
+ /* clear the message list */
+
+ for(i = 0 ; i < carray_count(folder->fl_msgs_tab) ; i ++) {
+ struct mailmh_msg_info * msg_info;
+ chashdatum key;
+
+ msg_info = carray_get(folder->fl_msgs_tab, i);
+ if (msg_info == NULL)
+ continue;
+
+#if 0
+ cinthash_remove(folder->fl_msgs_hash, msg_info->msg_index);
+#endif
+ key.data = &msg_info->msg_index;
+ key.len = sizeof(msg_info->msg_index);
+ chash_delete(folder->fl_msgs_hash, &key, NULL);
+
+ mailmh_msg_info_free(msg_info);
+ }
+
+ carray_set_size(folder->fl_msgs_tab, 0);
+
+ do {
+ uint32_t index;
+
+ ent = readdir(d);
+
+ if (ent != NULL) {
+
+ snprintf(filename, PATH_MAX,
+ "%s%c%s", folder->fl_filename, MAIL_DIR_SEPARATOR, ent->d_name);
+
+ if (stat(filename, &buf) == -1)
+ continue;
+
+ if (S_ISREG(buf.st_mode)) {
+ index = strtoul(ent->d_name, NULL, 10);
+ if (index != 0) {
+ struct mailmh_msg_info * msg_info;
+ unsigned int array_index;
+ chashdatum key;
+ chashdatum data;
+
+ msg_info = mailmh_msg_info_new(index, buf.st_size, buf.st_mtime);
+ if (msg_info == NULL) {
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+
+ r = carray_add(folder->fl_msgs_tab, msg_info, &array_index);
+ if (r < 0) {
+ mailmh_msg_info_free(msg_info);
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+ msg_info->msg_array_index = array_index;
+
+ if (index > max_index)
+ max_index = index;
+
+#if 0
+ r = cinthash_add(folder->fl_msgs_hash, msg_info->msg_index, msg_info);
+#endif
+ key.data = &msg_info->msg_index;
+ key.len = sizeof(msg_info->msg_index);
+ data.data = msg_info;
+ data.len = 0;
+
+ r = chash_set(folder->fl_msgs_hash, &key, &data, NULL);
+ if (r < 0) {
+ carray_delete_fast(folder->fl_msgs_tab, msg_info->msg_array_index);
+ mailmh_msg_info_free(msg_info);
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+ }
+ }
+ else if (S_ISDIR(buf.st_mode)) {
+ struct mailmh_folder * subfolder;
+ unsigned int array_index;
+ chashdatum key;
+ chashdatum data;
+
+ if (ent->d_name[0] == '.') {
+ if (ent->d_name[1] == 0)
+ continue;
+ if ((ent->d_name[1] == '.') && (ent->d_name[2] == 0))
+ continue;
+ }
+
+ key.data = ent->d_name;
+ key.len = strlen(ent->d_name);
+ r = chash_get(folder->fl_subfolders_hash, &key, &data);
+ if (r < 0) {
+ subfolder = mailmh_folder_new(folder, ent->d_name);
+ if (subfolder == NULL) {
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+
+ r = carray_add(folder->fl_subfolders_tab, subfolder, &array_index);
+ if (r < 0) {
+ mailmh_folder_free(subfolder);
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+ subfolder->fl_array_index = array_index;
+
+ key.data = subfolder->fl_filename;
+ key.len = strlen(subfolder->fl_filename);
+ data.data = subfolder;
+ data.len = 0;
+ r = chash_set(folder->fl_subfolders_hash, &key, &data, NULL);
+ if (r < 0) {
+ carray_delete_fast(folder->fl_subfolders_tab, subfolder->fl_array_index);
+ mailmh_folder_free(subfolder);
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+ }
+ }
+ }
+ }
+ while (ent != NULL);
+
+ folder->fl_max_index = max_index;
+
+ mh_seq = malloc(strlen(folder->fl_filename) + 2 + sizeof(".mh_sequences"));
+ if (mh_seq == NULL) {
+ res = MAILMH_ERROR_MEMORY;
+ goto closedir;
+ }
+ strcpy(mh_seq, folder->fl_filename);
+ strcat(mh_seq, MAIL_DIR_SEPARATOR_S);
+ strcat(mh_seq, ".mh_sequences");
+
+ if (stat(mh_seq, &buf) == -1) {
+ int fd;
+
+ fd = creat(mh_seq, S_IRUSR | S_IWUSR);
+ if (fd != -1)
+ close(fd);
+ }
+ free(mh_seq);
+
+ closedir(d);
+
+ return MAILMH_NO_ERROR;
+
+ closedir:
+ closedir(d);
+ err:
+ return res;
+}
+
+int mailmh_folder_add_subfolder(struct mailmh_folder * parent,
+ const char * name)
+{
+ char * foldername;
+ int r;
+ struct mailmh_folder * folder;
+ unsigned int array_index;
+ chashdatum key;
+ chashdatum data;
+
+ foldername = malloc(strlen(parent->fl_filename) + strlen(name) + 2);
+ if (foldername == NULL)
+ return MAILMH_ERROR_MEMORY;
+ strcpy(foldername, parent->fl_filename);
+ strcat(foldername, MAIL_DIR_SEPARATOR_S);
+ strcat(foldername, name);
+
+ r = mkdir(foldername, 0700);
+ free(foldername);
+
+ if (r < 0)
+ return MAILMH_ERROR_FOLDER;
+
+ folder = mailmh_folder_new(parent, name);
+ if (folder == NULL)
+ return MAILMH_ERROR_MEMORY;
+
+ r = carray_add(parent->fl_subfolders_tab, folder, &array_index);
+ if (r < 0) {
+ mailmh_folder_free(folder);
+ return MAILMH_ERROR_MEMORY;
+ }
+ folder->fl_array_index = array_index;
+
+ key.data = folder->fl_filename;
+ key.len = strlen(folder->fl_filename);
+ data.data = folder;
+ data.len = 0;
+
+ r = chash_set(parent->fl_subfolders_hash, &key, &data, NULL);
+ if (r < 0) {
+ carray_delete_fast(folder->fl_subfolders_tab, folder->fl_array_index);
+ mailmh_folder_free(folder);
+ return MAILMH_ERROR_MEMORY;
+ }
+
+ return MAILMH_NO_ERROR;
+}
+
+int mailmh_folder_remove_subfolder(struct mailmh_folder * folder)
+{
+ struct mailmh_folder * parent;
+ chashdatum key;
+ chashdatum data;
+ int r;
+
+ parent = folder->fl_parent;
+
+ key.data = folder->fl_filename;
+ key.len = strlen(folder->fl_filename);
+
+ r = chash_get(parent->fl_subfolders_hash, &key, &data);
+ if (r < 0)
+ return MAILMH_ERROR_FOLDER;
+
+ chash_delete(parent->fl_subfolders_hash, &key, NULL);
+ carray_delete_fast(parent->fl_subfolders_tab, folder->fl_array_index);
+
+ mailmh_folder_free(folder);
+
+ return MAILMH_NO_ERROR;
+
+}
+
+int mailmh_folder_rename_subfolder(struct mailmh_folder * src_folder,
+ struct mailmh_folder * dst_folder,
+ const char * new_name)
+{
+ int r;
+ struct mailmh_folder * folder;
+ struct mailmh_folder * parent;
+ char * new_foldername;
+
+ parent = src_folder->fl_parent;
+ if (parent == NULL)
+ return MAILMH_ERROR_RENAME;
+
+ new_foldername = malloc(strlen(dst_folder->fl_filename) + 2 + strlen(new_name));
+ if (new_foldername == NULL)
+ return MAILMH_ERROR_MEMORY;
+
+ strcpy(new_foldername, dst_folder->fl_filename);
+ strcat(new_foldername, MAIL_DIR_SEPARATOR_S);
+ strcat(new_foldername, new_name);
+
+ r = rename(src_folder->fl_filename, new_foldername);
+ free(new_foldername);
+ if (r < 0)
+ return MAILMH_ERROR_RENAME;
+
+ r = mailmh_folder_remove_subfolder(src_folder);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+
+ folder = mailmh_folder_new(dst_folder, new_name);
+ if (folder == NULL)
+ return MAILMH_ERROR_MEMORY;
+
+ r = carray_add(parent->fl_subfolders_tab, folder, NULL);
+ if (r < 0) {
+ mailmh_folder_free(folder);
+ return MAILMH_ERROR_MEMORY;
+ }
+
+ return MAILMH_NO_ERROR;
+}
+
+#define MAX_TRY_ALLOC 32
+
+/* initial file MUST be in the same directory */
+
+static int mailmh_folder_alloc_msg(struct mailmh_folder * folder,
+ char * filename, uint32_t * result)
+{
+ uint32_t max;
+ uint32_t k;
+ char * new_filename;
+ size_t len;
+
+ len = strlen(folder->fl_filename) + 20;
+ new_filename = malloc(len);
+ if (new_filename == NULL)
+ return MAILMH_ERROR_MEMORY;
+
+ max = folder->fl_max_index + 1;
+
+ k = 0;
+ while (k < MAX_TRY_ALLOC) {
+ snprintf(new_filename, len, "%s%c%lu", folder->fl_filename,
+ MAIL_DIR_SEPARATOR, (unsigned long) (max + k));
+
+ if (link(filename, new_filename) == 0) {
+ int r;
+
+ free(new_filename);
+ unlink(filename);
+
+ if (k > MAX_TRY_ALLOC / 2) {
+ r = mailmh_folder_update(folder);
+ /* ignore errors */
+ }
+
+ * result = max + k;
+
+ folder->fl_max_index = max + k;
+
+ return MAILMH_NO_ERROR;
+ }
+ else if (errno == EXDEV) {
+ free(filename);
+ return MAILMH_ERROR_FOLDER;
+ }
+ k ++;
+ }
+
+ free(new_filename);
+
+ return MAILMH_ERROR_FOLDER;
+}
+
+int mailmh_folder_get_message_filename(struct mailmh_folder * folder,
+ uint32_t index, char ** result)
+{
+ char * filename;
+ int len;
+
+#if 0
+ r = mailmh_folder_update(folder);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+#endif
+
+ len = strlen(folder->fl_filename) + 20;
+ filename = malloc(len);
+ if (filename == NULL)
+ return MAILMH_ERROR_MEMORY;
+
+ snprintf(filename, len, "%s%c%lu", folder->fl_filename, MAIL_DIR_SEPARATOR,
+ (unsigned long) index);
+
+ * result = filename;
+
+ return MAILMH_NO_ERROR;;
+}
+
+
+int mailmh_folder_get_message_fd(struct mailmh_folder * folder,
+ uint32_t index, int flags, int * result)
+{
+ char * filename;
+ int fd;
+ int r;
+
+#if 0
+ r = mailmh_folder_update(folder);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+#endif
+
+ r = mailmh_folder_get_message_filename(folder, index, &filename);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+
+ fd = open(filename, flags);
+ free(filename);
+ if (fd == -1)
+ return MAILMH_ERROR_MSG_NOT_FOUND;
+
+ * result = fd;
+
+ return MAILMH_NO_ERROR;
+}
+
+int mailmh_folder_get_message_size(struct mailmh_folder * folder,
+ uint32_t index, size_t * result)
+{
+ int r;
+ char * filename;
+ struct stat buf;
+
+ r = mailmh_folder_get_message_filename(folder, index, &filename);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+
+ r = stat(filename, &buf);
+ free(filename);
+ if (r < 0)
+ return MAILMH_ERROR_FILE;
+
+ * result = buf.st_size;
+
+ return MAILMH_NO_ERROR;
+}
+
+int mailmh_folder_add_message(struct mailmh_folder * folder,
+ const char * message, size_t size)
+{
+ char * tmpname;
+ int fd;
+ size_t namesize;
+ size_t left;
+ ssize_t res;
+ struct mailmh_msg_info * msg_info;
+ uint32_t index;
+ int error;
+ int r;
+ unsigned int array_index;
+ struct stat buf;
+ chashdatum key;
+ chashdatum data;
+
+#if 0
+ r = mailmh_folder_update(folder);
+ if (r != MAILMH_NO_ERROR) {
+ error = r;
+ goto err;
+ }
+#endif
+
+ namesize = strlen(folder->fl_filename) + 20;
+ tmpname = malloc(namesize);
+ snprintf(tmpname, namesize, "%s%ctmpXXXXXX",
+ folder->fl_filename, MAIL_DIR_SEPARATOR);
+ fd = mkstemp(tmpname);
+ if (fd < 0) {
+ error = MAILMH_ERROR_FILE;
+ goto free;
+ }
+
+ left = size;
+ while (left > 0) {
+ res = write(fd, message, left);
+ if (res == -1) {
+ close(fd);
+ error = MAILMH_ERROR_FILE;
+ goto free;
+ }
+
+ left -= res;
+ }
+ close(fd);
+
+ r = stat(tmpname, &buf);
+ if (r < 0) {
+ error = MAILMH_ERROR_FILE;
+ goto free;
+ }
+
+ r = mailmh_folder_alloc_msg(folder, tmpname, &index);
+ if (r != MAILMH_NO_ERROR) {
+ unlink(tmpname);
+ error = MAILMH_ERROR_COULD_NOT_ALLOC_MSG;
+ goto free;
+ }
+ free(tmpname);
+
+ msg_info = mailmh_msg_info_new(index, size, buf.st_mtime);
+ if (msg_info == NULL) {
+ mailmh_folder_remove_message(folder, index);
+ error = MAILMH_ERROR_MEMORY;
+ goto err;
+ }
+
+ r = carray_add(folder->fl_msgs_tab, msg_info, &array_index);
+ if (r < 0) {
+ mailmh_folder_remove_message(folder, index);
+ mailmh_msg_info_free(msg_info);
+ error = MAILMH_ERROR_MEMORY;
+ goto err;
+ }
+ msg_info->msg_array_index = array_index;
+
+#if 0
+ r = cinthash_add(folder->fl_msgs_hash, index, msg_info);
+#endif
+ key.data = &index;
+ key.len = sizeof(index);
+ data.data = msg_info;
+ data.len = 0;
+
+ r = chash_set(folder->fl_msgs_hash, &key, &data, NULL);
+ if (r < 0) {
+ carray_delete_fast(folder->fl_msgs_tab, msg_info->msg_array_index);
+ mailmh_msg_info_free(msg_info);
+ error = MAILMH_ERROR_MEMORY;
+ goto err;
+ }
+
+ return MAILMH_NO_ERROR;
+
+ free:
+ free(tmpname);
+ err:
+ return error;
+}
+
+int mailmh_folder_add_message_file(struct mailmh_folder * folder,
+ int fd)
+{
+ char * message;
+ struct stat buf;
+ int r;
+
+#if 0
+ r = mailmh_folder_update(folder);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+#endif
+
+ if (fstat(fd, &buf) == -1)
+ return MAILMH_ERROR_FILE;
+
+ message = mmap(NULL, buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+ if (message == MAP_FAILED)
+ return MAILMH_ERROR_FILE;
+
+ r = mailmh_folder_add_message(folder, message, buf.st_size);
+
+ munmap(message, buf.st_size);
+
+ return r;
+}
+
+int mailmh_folder_remove_message(struct mailmh_folder * folder,
+ uint32_t index)
+{
+ char * filename;
+ struct mailmh_msg_info * msg_info;
+ int res;
+ int r;
+ chashdatum key;
+ chashdatum data;
+
+#if 0
+ r = mailmh_folder_update(folder);
+ if (r != MAILMH_NO_ERROR) {
+ res = r;
+ goto err;
+ }
+#endif
+
+ r = mailmh_folder_get_message_filename(folder, index, &filename);
+ if (filename == NULL) {
+ res = r;
+ goto err;
+ }
+
+ if (unlink(filename) == -1) {
+ res = MAILMH_ERROR_FILE;
+ goto free;
+ }
+
+ key.data = &index;
+ key.len = sizeof(index);
+ r = chash_get(folder->fl_msgs_hash, &key, &data);
+#if 0
+ msg_info = cinthash_find(folder->fl_msgs_hash, index);
+#endif
+ if (r == 0) {
+ msg_info = data.data;
+
+ carray_delete_fast(folder->fl_msgs_tab, msg_info->msg_array_index);
+#if 0
+ cinthash_remove(folder->fl_msgs_hash, index);
+#endif
+ chash_delete(folder->fl_msgs_hash, &key, NULL);
+ }
+
+ return MAILMH_NO_ERROR;
+
+ free:
+ free(filename);
+ err:
+ return res;
+}
+
+
+int mailmh_folder_move_message(struct mailmh_folder * dest_folder,
+ struct mailmh_folder * src_folder,
+ uint32_t index)
+{
+ int fd;
+ char * filename;
+ int r;
+
+#if 0
+ r = mailmh_folder_update(dest_folder);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+ r = mailmh_folder_update(src_folder);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+#endif
+
+ /* move on the same filesystem */
+ r = mailmh_folder_get_message_filename(src_folder, index, &filename);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+
+ r = mailmh_folder_alloc_msg(dest_folder, filename, &index);
+ free(filename);
+ if (r == MAILMH_NO_ERROR)
+ return MAILMH_NO_ERROR;
+
+ /* move on the different filesystems */
+ r = mailmh_folder_get_message_fd(src_folder, index, O_RDONLY, &fd);
+ if (r != MAILMH_NO_ERROR)
+ return r;
+
+ r = mailmh_folder_add_message_file(dest_folder, fd);
+ if (r != MAILMH_NO_ERROR) {
+ close(fd);
+ return r;
+ }
+
+ close(fd);
+
+ r = mailmh_folder_remove_message(src_folder, index);
+
+ return MAILMH_NO_ERROR;
+}
+
+unsigned int mailmh_folder_get_message_number(struct mailmh_folder * folder)
+{
+ unsigned int i;
+ unsigned int count;
+
+ count = 0;
+ for(i = 0 ; i < carray_count(folder->fl_msgs_tab) ; i ++)
+ if (carray_get(folder->fl_msgs_tab, i) != NULL)
+ count ++;
+
+ return count;
+}