Mail fixes and libetpan updated

38 files changed, 703 insertions, 40 deletions

diff --git a/kmicromail/libetpan/generic/imapdriver.c b/kmicromail/libetpan/generic/imapdriver.c
index 0d63319..b3e5982 100644
--- a/kmicromail/libetpan/generic/imapdriver.c
+++ b/kmicromail/libetpan/generic/imapdriver.c
@@ -79,48 +79,50 @@ static int imapdriver_examine_folder(mailsession * session, char * mb);
 static int imapdriver_select_folder(mailsession * session, char * mb);
 static int imapdriver_expunge_folder(mailsession * session);
 
 static int imapdriver_status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int imapdriver_messages_number(mailsession * session, char * mb,
 				      uint32_t * result);
 
 static int imapdriver_recent_number(mailsession * session, char * mb,
 				      uint32_t * result);
 
 static int imapdriver_unseen_number(mailsession * session, char * mb,
 				      uint32_t * result);
 
 static int imapdriver_list_folders(mailsession * session, char * mb,
 				    struct mail_list ** result);
 static int imapdriver_lsub_folders(mailsession * session, char * mb,
 				   struct mail_list ** result);
 static int imapdriver_subscribe_folder(mailsession * session, char * mb);
 static int imapdriver_unsubscribe_folder(mailsession * session, char * mb);
 static int imapdriver_append_message(mailsession * session,
 				     char * message, size_t size);
+static int imapdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
 static int imapdriver_copy_message(mailsession * session,
 				   uint32_t num, char * mb);
 
 static int imapdriver_get_messages_list(mailsession * session,
 					struct mailmessage_list ** result);
 
 static int
 imapdriver_get_envelopes_list(mailsession * session,
 			      struct mailmessage_list * env_list);
 
 
 #if 0
 static int imapdriver_search_messages(mailsession * session, char * charset,
 				      struct mail_search_key * key,
 				      struct mail_search_result ** result);
 #endif
 
 static int imapdriver_get_message(mailsession * session,
 				  uint32_t num, mailmessage ** result);
 
 static int imapdriver_get_message_by_uid(mailsession * session,
     const char * uid,
     mailmessage ** result);
 
@@ -136,48 +138,49 @@ static mailsession_driver local_imap_session_driver = {
   .sess_connect_path = NULL,
   .sess_starttls = imapdriver_starttls,
   .sess_login = imapdriver_login,
   .sess_logout = imapdriver_logout,
   .sess_noop = imapdriver_noop,
 
   .sess_build_folder_name = imapdriver_build_folder_name,
   .sess_create_folder = imapdriver_create_folder,
   .sess_delete_folder = imapdriver_delete_folder,
   .sess_rename_folder = imapdriver_rename_folder,
   .sess_check_folder = imapdriver_check_folder,
   .sess_examine_folder = imapdriver_examine_folder,
   .sess_select_folder = imapdriver_select_folder,
   .sess_expunge_folder = imapdriver_expunge_folder,
   .sess_status_folder = imapdriver_status_folder,
   .sess_messages_number = imapdriver_messages_number,
   .sess_recent_number = imapdriver_recent_number,
   .sess_unseen_number = imapdriver_unseen_number,
   .sess_list_folders = imapdriver_list_folders,
   .sess_lsub_folders = imapdriver_lsub_folders,
   .sess_subscribe_folder = imapdriver_subscribe_folder,
   .sess_unsubscribe_folder = imapdriver_unsubscribe_folder,
 
   .sess_append_message = imapdriver_append_message,
+  .sess_append_message_flags = imapdriver_append_message_flags,
   .sess_copy_message = imapdriver_copy_message,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = imapdriver_get_messages_list,
   .sess_get_envelopes_list = imapdriver_get_envelopes_list,
   .sess_remove_message = NULL,
 #if 0
   .sess_search_messages = imapdriver_search_messages,
 #endif
   
   .sess_get_message = imapdriver_get_message,
   .sess_get_message_by_uid = imapdriver_get_message_by_uid,
 };
 
 mailsession_driver * imap_session_driver = &local_imap_session_driver;
 
 static inline struct imap_session_state_data * get_data(mailsession * session)
 {
   return session->sess_data;
 }
 
 static mailimap * get_imap_session(mailsession * session)
 {
   return get_data(session)->imap_session;
@@ -750,48 +753,73 @@ static int imapdriver_subscribe_folder(mailsession * session, char * mb)
 
 static int imapdriver_unsubscribe_folder(mailsession * session, char * mb)
 {
   int r;
 
   r = mailimap_unsubscribe(get_imap_session(session), mb);
 
   return imap_error_to_mail_error(r);
 }
 
 /* messages operations */
 
 static int imapdriver_append_message(mailsession * session,
 				     char * message, size_t size)
 {
   int r;
 
   r = mailimap_append_simple(get_imap_session(session),
       get_data(session)->imap_mailbox,
       message, size);
   
   return imap_error_to_mail_error(r);
 }
 
+static int imapdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  struct mailimap_flag_list * flag_list;
+  int r;
+  
+  if (flags != NULL) {
+    r = imap_flags_to_imap_flags(flags, &flag_list);
+    if (r != MAIL_NO_ERROR)
+      return r;
+  }
+  else {
+    flag_list = NULL;
+  }
+  
+  r = mailimap_append(get_imap_session(session),
+      get_data(session)->imap_mailbox,
+      flag_list, NULL, message, size);
+  
+  if (flag_list != NULL)
+    mailimap_flag_list_free(flag_list);
+  
+  return imap_error_to_mail_error(r);
+}
+
 static int imapdriver_copy_message(mailsession * session,
 				   uint32_t num, char * mb)
 {
   int r;
   struct mailimap_set * set;
   int res;
 
   set = mailimap_set_new_single(num);
   if (set == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto err;
   }
 
   r = mailimap_uid_copy(get_imap_session(session), set, mb);
 
   mailimap_set_free(set);
 
   return imap_error_to_mail_error(r);
 
  err:
   return res;
 }
 
 static int imapdriver_get_messages_list(mailsession * session,
diff --git a/kmicromail/libetpan/generic/imapdriver_cached.c b/kmicromail/libetpan/generic/imapdriver_cached.c
index e6af8e8..04044ae 100644
--- a/kmicromail/libetpan/generic/imapdriver_cached.c
+++ b/kmicromail/libetpan/generic/imapdriver_cached.c
@@ -84,48 +84,50 @@ static int imapdriver_cached_examine_folder(mailsession * session,
 					    char * mb);
 static int imapdriver_cached_select_folder(mailsession * session, char * mb);
 static int imapdriver_cached_expunge_folder(mailsession * session);
 static int imapdriver_cached_status_folder(mailsession * session, char * mb,
 					   uint32_t * result_messages,
 					   uint32_t * result_recent,
 					   uint32_t * result_unseen);
 static int imapdriver_cached_messages_number(mailsession * session,
 					     char * mb,
 					     uint32_t * result);
 static int imapdriver_cached_recent_number(mailsession * session, char * mb,
 					   uint32_t * result);
 static int imapdriver_cached_unseen_number(mailsession * session, char * mb,
 					   uint32_t * result);
 static int imapdriver_cached_list_folders(mailsession * session, char * mb,
 					  struct mail_list ** result);
 static int imapdriver_cached_lsub_folders(mailsession * session, char * mb,
 					  struct mail_list ** result);
 static int imapdriver_cached_subscribe_folder(mailsession * session,
 					      char * mb);
 static int imapdriver_cached_unsubscribe_folder(mailsession * session,
 						char * mb);
 static int imapdriver_cached_append_message(mailsession * session,
 					    char * message, size_t size);
+static int imapdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
 static int imapdriver_cached_copy_message(mailsession * session,
 					  uint32_t num, char * mb);
 
 static int imapdriver_cached_get_messages_list(mailsession * session,
 						struct mailmessage_list **
 						result);
 static int
 imapdriver_cached_get_envelopes_list(mailsession * session,
 				     struct mailmessage_list * env_list);
 static int imapdriver_cached_remove_message(mailsession * session,
 					    uint32_t num);
 
 #if 0
 static int imapdriver_cached_search_messages(mailsession * session,
 					      char * charset,
 					      struct mail_search_key * key,
 					      struct mail_search_result **
 					      result);
 #endif
 
 static int imapdriver_cached_get_message(mailsession * session,
 					 uint32_t num, mailmessage ** result);
 
 static int imapdriver_cached_get_message_by_uid(mailsession * session,
@@ -144,48 +146,49 @@ static mailsession_driver local_imap_cached_session_driver = {
   .sess_connect_path = NULL,
   .sess_starttls = imapdriver_cached_starttls,
   .sess_login = imapdriver_cached_login,
   .sess_logout = imapdriver_cached_logout,
   .sess_noop = imapdriver_cached_noop,
 
   .sess_build_folder_name = imapdriver_cached_build_folder_name,
   .sess_create_folder = imapdriver_cached_create_folder,
   .sess_delete_folder = imapdriver_cached_delete_folder,
   .sess_rename_folder = imapdriver_cached_rename_folder,
   .sess_check_folder = imapdriver_cached_check_folder,
   .sess_examine_folder = imapdriver_cached_examine_folder,
   .sess_select_folder = imapdriver_cached_select_folder,
   .sess_expunge_folder = imapdriver_cached_expunge_folder,
   .sess_status_folder = imapdriver_cached_status_folder,
   .sess_messages_number = imapdriver_cached_messages_number,
   .sess_recent_number = imapdriver_cached_recent_number,
   .sess_unseen_number = imapdriver_cached_unseen_number,
   .sess_list_folders = imapdriver_cached_list_folders,
   .sess_lsub_folders = imapdriver_cached_lsub_folders,
   .sess_subscribe_folder = imapdriver_cached_subscribe_folder,
   .sess_unsubscribe_folder = imapdriver_cached_unsubscribe_folder,
 
   .sess_append_message = imapdriver_cached_append_message,
+  .sess_append_message_flags = imapdriver_cached_append_message_flags,
   .sess_copy_message = imapdriver_cached_copy_message,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = imapdriver_cached_get_messages_list,
   .sess_get_envelopes_list = imapdriver_cached_get_envelopes_list,
   .sess_remove_message = imapdriver_cached_remove_message,
 #if 0
   .sess_search_messages = imapdriver_cached_search_messages,
 #endif
 
   .sess_get_message = imapdriver_cached_get_message,
   .sess_get_message_by_uid = imapdriver_cached_get_message_by_uid,
 };
 
 mailsession_driver * imap_cached_session_driver =
 &local_imap_cached_session_driver;
 
 #define CACHE_MESSAGE_LIST
 
 static inline struct imap_cached_session_state_data *
 get_cached_data(mailsession * session)
 {
   return session->sess_data;
 }
@@ -755,48 +758,61 @@ static int imapdriver_cached_subscribe_folder(mailsession * session,
 static int imapdriver_cached_unsubscribe_folder(mailsession * session,
 						char * mb)
 {
   int r;
 
   r = mailsession_unsubscribe_folder(get_ancestor(session), mb);
   
   check_for_uid_cache(session);
 
   return r;
 }
 
 static int imapdriver_cached_append_message(mailsession * session,
 					    char * message, size_t size)
 {
   int r;
   
   r = mailsession_append_message(get_ancestor(session), message, size);
   
   check_for_uid_cache(session);
   
   return r;
 }
 
+static int imapdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  int r;
+  
+  r = mailsession_append_message_flags(get_ancestor(session),
+      message, size, flags);
+  
+  check_for_uid_cache(session);
+  
+  return r;
+}
+
 static int imapdriver_cached_copy_message(mailsession * session,
 					  uint32_t num, char * mb)
 {
   int r;
 
   r = mailsession_copy_message(get_ancestor(session), num, mb);
 
   check_for_uid_cache(session);
   
   return r;
 }
 
 static int cmp_uid(uint32_t ** pa, uint32_t ** pb)
 {
   uint32_t * a;
   uint32_t * b;
   
   a = * pa;
   b = * pb;
   
   return * a - * b;
 }
 
 
diff --git a/kmicromail/libetpan/generic/imapdriver_cached_message.c b/kmicromail/libetpan/generic/imapdriver_cached_message.c
index c0542a3..c4357a3 100644
--- a/kmicromail/libetpan/generic/imapdriver_cached_message.c
+++ b/kmicromail/libetpan/generic/imapdriver_cached_message.c
@@ -191,49 +191,49 @@ static void generate_key_from_mime_section(char * key, size_t size,
   gstr = mmap_string_new("part");
   if (gstr == NULL)
     goto free_section;
 
   for(cur = clist_begin(part->sec_list) ;
       cur != NULL ; cur = clist_next(cur)) {
     char s[20];
 
     snprintf(s, 20, ".%u", * (uint32_t *) clist_content(cur));
     if (mmap_string_append(gstr, s) == NULL)
       goto free_str;
   }
 
   snprintf(key, size, "%s", gstr->str);
 
   mmap_string_free(gstr);
   mailmime_section_free(part);
 
   return;
 
  free_str:
   mmap_string_free(gstr);
  free_section:
   mailmime_section_free(part);
- err:
+ err:;
 }
 
 static void generate_key_from_section(char * key, size_t size,
 				      mailmessage * msg_info,
 				      struct mailmime * mime, int type)
 {
   char section_str[PATH_MAX];
 
   generate_key_from_mime_section(section_str, PATH_MAX, mime);
 
   switch (type) {
   case IMAP_SECTION_MESSAGE:
     snprintf(key, size, "%s-%s", msg_info->msg_uid, section_str);
     break;
   case IMAP_SECTION_HEADER:
     snprintf(key, size, "%s-%s-header", msg_info->msg_uid, section_str);
     break;
   case IMAP_SECTION_MIME:
     snprintf(key, size, "%s-%s-mime", msg_info->msg_uid, section_str);
     break;
   case IMAP_SECTION_BODY:
     snprintf(key, size, "%s-%s-text", msg_info->msg_uid, section_str);
     break;
   }
diff --git a/kmicromail/libetpan/generic/imapdriver_tools.c b/kmicromail/libetpan/generic/imapdriver_tools.c
index 3d737f3..de4008f 100644
--- a/kmicromail/libetpan/generic/imapdriver_tools.c
+++ b/kmicromail/libetpan/generic/imapdriver_tools.c
@@ -3086,58 +3086,57 @@ static int imap_flags_to_flags(struct mailimap_msg_att_dynamic * att_dyn,
 	  /* do nothing */
 	  break;
 	}
       }
     }
     /*
       MAIL_FLAG_NEW was set for \Recent messages.
       Correct this flag for \Seen messages by unsetting it.
     */
     if ((flags->fl_flags & MAIL_FLAG_SEEN) && (flags->fl_flags & MAIL_FLAG_NEW)) {
       flags->fl_flags &= ~MAIL_FLAG_NEW;
     }
   }
 
   * result = flags;
   
   return MAIL_NO_ERROR;
 
  free:
   mail_flags_free(flags);
  err:
   return MAIL_ERROR_MEMORY;
 }
 
-static int flags_to_imap_flags(struct mail_flags * flags,
-			       struct mailimap_store_att_flags ** result)
+int imap_flags_to_imap_flags(struct mail_flags * flags,
+    struct mailimap_flag_list ** result)
 {
   struct mailimap_flag * flag;
   struct mailimap_flag_list * flag_list;
-  struct mailimap_store_att_flags * att_flags;
   int res;
   clistiter * cur;
   int r;
-  
+
   flag_list = mailimap_flag_list_new_empty();
   if (flag_list == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto err;
   }
 
   if ((flags->fl_flags & MAIL_FLAG_DELETED) != 0) {
     flag = mailimap_flag_new_deleted();
     if (flag == NULL) {
       res = MAIL_ERROR_MEMORY;
       goto free_flag_list;
     }
     r = mailimap_flag_list_add(flag_list, flag);
     if (r != MAILIMAP_NO_ERROR) {
       mailimap_flag_free(flag);
       res = MAIL_ERROR_MEMORY;
       goto free_flag_list;
     }
   }
 
   if ((flags->fl_flags & MAIL_FLAG_FLAGGED) != 0) {
     flag = mailimap_flag_new_flagged();
     if (flag == NULL) {
       res = MAIL_ERROR_MEMORY;
@@ -3218,59 +3217,84 @@ static int flags_to_imap_flags(struct mail_flags * flags,
 	res = MAIL_ERROR_MEMORY;
 	goto free_flag_list;
       }
     }
     else {
       flag_str = strdup(flag_str);
       if (flag_str == NULL) {
 	res = MAIL_ERROR_MEMORY;
 	goto free_flag_list;
       }
       flag = mailimap_flag_new_flag_keyword(flag_str);
       if (flag == NULL) {
 	free(flag_str);
 	res = MAIL_ERROR_MEMORY;
 	goto free_flag_list;
       }
       r = mailimap_flag_list_add(flag_list, flag);
       if (r != MAILIMAP_NO_ERROR) {
 	mailimap_flag_free(flag);
 	res = MAIL_ERROR_MEMORY;
 	goto free_flag_list;
       }
     }
   }
+  
+  * result = flag_list;
+  
+  return MAIL_NO_ERROR;
+  
+ free_flag_list: 
+  mailimap_flag_list_free(flag_list);
+ err:
+  return res;
+}
 
+static int flags_to_imap_flags(struct mail_flags * flags,
+			       struct mailimap_store_att_flags ** result)
+{
+  struct mailimap_flag_list * flag_list;
+  struct mailimap_store_att_flags * att_flags;
+  int res;
+  int r;
+  
+  r = imap_flags_to_imap_flags(flags,
+      &flag_list);
+  if (r != MAIL_NO_ERROR) {
+    res = r;
+    goto err;
+  }
+  
   att_flags = mailimap_store_att_flags_new_set_flags_silent(flag_list);
   if (att_flags == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto free_flag_list;
   }
-
+  
   * result = att_flags;
-
+  
   return MAIL_NO_ERROR;
-
+  
  free_flag_list: 
   mailimap_flag_list_free(flag_list);
  err:
   return res;
 }
 
 
 static int
 imap_fetch_result_to_flags(clist * fetch_result, uint32_t index,
 			   struct mail_flags ** result)
 {
   clistiter * cur;
   int r;
 
   for(cur = clist_begin(fetch_result) ; cur != NULL ;
       cur = clist_next(cur)) {
     struct mailimap_msg_att * msg_att;
     clistiter * item_cur;
     uint32_t uid;
     struct mailimap_msg_att_dynamic * att_dyn;
 
     msg_att = clist_content(cur);
 
     uid = 0;
diff --git a/kmicromail/libetpan/generic/imapdriver_tools.h b/kmicromail/libetpan/generic/imapdriver_tools.h
index 6582a31..59c993e 100644
--- a/kmicromail/libetpan/generic/imapdriver_tools.h
+++ b/kmicromail/libetpan/generic/imapdriver_tools.h
@@ -85,29 +85,32 @@ int imap_error_to_mail_error(int error);
 
 int imap_store_flags(mailimap * imap, uint32_t first, uint32_t last,
 		     struct mail_flags * flags);
 
 int imap_fetch_flags(mailimap * imap,
 		     uint32_t index, struct mail_flags ** result);
 
 int imap_get_messages_list(mailimap * imap,
     mailsession * session, mailmessage_driver * driver,
     uint32_t first_index,
     struct mailmessage_list ** result);
 
 int
 imapdriver_get_cached_envelope(struct mail_cache_db * cache_db,
     MMAPString * mmapstr,
     mailsession * session, mailmessage * msg,
     struct mailimf_fields ** result);
 
 int
 imapdriver_write_cached_envelope(struct mail_cache_db * cache_db,
     MMAPString * mmapstr,
     mailsession * session, mailmessage * msg,
     struct mailimf_fields * fields);
 
+int imap_flags_to_imap_flags(struct mail_flags * flags,
+    struct mailimap_flag_list ** result);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif
diff --git a/kmicromail/libetpan/generic/imapstorage.c b/kmicromail/libetpan/generic/imapstorage.c
index e8683d8..972b6dd 100644
--- a/kmicromail/libetpan/generic/imapstorage.c
+++ b/kmicromail/libetpan/generic/imapstorage.c
@@ -50,49 +50,49 @@
 #define IMAPS_DEFAULT_PORT 993
 
 static int imap_mailstorage_connect(struct mailstorage * storage);
 static int
 imap_mailstorage_get_folder_session(struct mailstorage * storage,
     char * pathname, mailsession ** result);
 static void imap_mailstorage_uninitialize(struct mailstorage * storage);
 
 static mailstorage_driver imap_mailstorage_driver = {
   .sto_name               = "imap",
   .sto_connect            = imap_mailstorage_connect,
   .sto_get_folder_session = imap_mailstorage_get_folder_session,
   .sto_uninitialize       = imap_mailstorage_uninitialize,
 };
 
 int imap_mailstorage_init(struct mailstorage * storage,
     char * imap_servername, uint16_t imap_port,
     char * imap_command,
     int imap_connection_type, int imap_auth_type,
     char * imap_login, char * imap_password,
     int imap_cached, char * imap_cache_directory)
 {
   struct imap_mailstorage * imap_storage;
 
-  imap_storage = malloc(sizeof(struct imap_mailstorage));
+  imap_storage = malloc(sizeof(* imap_storage));
   if (imap_storage == NULL)
     goto err;
 
   imap_storage->imap_servername = strdup(imap_servername);
   if (imap_storage->imap_servername == NULL)
     goto free;
 
   imap_storage->imap_connection_type = imap_connection_type;
   
   if (imap_port == 0) {
     switch (imap_connection_type) {
     case CONNECTION_TYPE_PLAIN:
     case CONNECTION_TYPE_TRY_STARTTLS:
     case CONNECTION_TYPE_STARTTLS:
     case CONNECTION_TYPE_COMMAND:
     case CONNECTION_TYPE_COMMAND_TRY_STARTTLS:
     case CONNECTION_TYPE_COMMAND_STARTTLS:
       imap_port = IMAP_DEFAULT_PORT;
       break;
 
     case CONNECTION_TYPE_TLS:
     case CONNECTION_TYPE_COMMAND_TLS:
       imap_port = IMAPS_DEFAULT_PORT;
       break;
diff --git a/kmicromail/libetpan/generic/maildirdriver.c b/kmicromail/libetpan/generic/maildirdriver.c
index 7830ceb..5f21422 100644
--- a/kmicromail/libetpan/generic/maildirdriver.c
+++ b/kmicromail/libetpan/generic/maildirdriver.c
@@ -64,92 +64,96 @@ static int initialize(mailsession * session);
 static void uninitialize(mailsession * session);
 
 static int connect_path(mailsession * session, char * path);
 
 static int logout(mailsession * session);
 
 static int expunge_folder(mailsession * session);
 
 static int status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int recent_number(mailsession * session, char * mb,
     uint32_t * result);
 
 static int unseen_number(mailsession * session, char * mb,
     uint32_t * result);
 
 static int messages_number(mailsession * session, char * mb,
     uint32_t * result);
 
 static int append_message(mailsession * session,
     char * message, size_t size);
 
+static int append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 static int get_messages_list(mailsession * session,
     struct mailmessage_list ** result);
 
 static int get_envelopes_list(mailsession * session,
     struct mailmessage_list * env_list);
 
 static int check_folder(mailsession * session);
 
 static int get_message_by_uid(mailsession * session,
     const char * uid, mailmessage ** result);
 
 static mailsession_driver local_maildir_session_driver = {
   .sess_name = "maildir",
 
   .sess_initialize = initialize,
   .sess_uninitialize = uninitialize,
 
   .sess_parameters = NULL,
 
   .sess_connect_stream = NULL,
   .sess_connect_path = connect_path,
   .sess_starttls = NULL,
   .sess_login = NULL,
   .sess_logout = logout,
   .sess_noop = NULL,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = check_folder,
   .sess_examine_folder = NULL,
   .sess_select_folder = NULL,
   .sess_expunge_folder = expunge_folder,
   .sess_status_folder = status_folder,
   .sess_messages_number = messages_number,
   .sess_recent_number = recent_number,
   .sess_unseen_number = unseen_number,
   .sess_list_folders = NULL,
   .sess_lsub_folders = NULL,
   .sess_subscribe_folder = NULL,
   .sess_unsubscribe_folder = NULL,
 
   .sess_append_message = append_message,
+  .sess_append_message_flags = append_message_flags,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = get_messages_list,
   .sess_get_envelopes_list = get_envelopes_list,
   .sess_remove_message = NULL,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = NULL,
   .sess_get_message_by_uid = get_message_by_uid,
 };
 
 mailsession_driver * maildir_session_driver = &local_maildir_session_driver;
 
 
 static int flags_store_process(struct maildir * md,
     struct mail_flags_store * flags_store);
 
 
 static inline struct maildir_session_state_data * get_data(mailsession * session)
 {
   return session->sess_data;
@@ -334,60 +338,107 @@ static int unseen_number(mailsession * session, char * mb,
 
 static int recent_number(mailsession * session, char * mb,
     uint32_t * result)
 {
   uint32_t messages;
   uint32_t recent;
   uint32_t unseen;
   int r;
   
   r = status_folder(session, mb, &messages, &recent, &unseen);
   if (r != MAIL_NO_ERROR)
     return r;
 
   * result = recent;
  
   return MAIL_NO_ERROR;
 }
 
 
 /* messages operations */
 
 static int append_message(mailsession * session,
     char * message, size_t size)
 {
+#if 0
   struct maildir * md;
   int r;
 
   md = get_maildir_session(session);
   if (md == NULL)
     return MAIL_ERROR_BAD_STATE;
   
   r = maildir_message_add(md, message, size);
   if (r != MAILDIR_NO_ERROR)
     return maildirdriver_maildir_error_to_mail_error(r);
   
   return MAIL_NO_ERROR;
+#endif
+  
+  return append_message_flags(session, message, size, NULL);
+}
+
+static int append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  struct maildir * md;
+  int r;
+  char uid[PATH_MAX];
+  struct maildir_msg * md_msg;
+  chashdatum key;
+  chashdatum value;
+  uint32_t md_flags;
+  
+  md = get_maildir_session(session);
+  if (md == NULL)
+    return MAIL_ERROR_BAD_STATE;
+  
+  r = maildir_message_add_uid(md, message, size,
+      uid, sizeof(uid));
+  if (r != MAILDIR_NO_ERROR)
+    return maildirdriver_maildir_error_to_mail_error(r);
+  
+  if (flags == NULL)
+    goto exit;
+  
+  key.data = uid;
+  key.len = strlen(uid);
+  r = chash_get(md->mdir_msg_hash, &key, &value);
+  if (r < 0)
+    goto exit;
+  
+  md_msg = value.data;
+  
+  md_flags = maildirdriver_flags_to_maildir_flags(flags->fl_flags);
+  
+  r = maildir_message_change_flags(md, uid, md_flags);
+  if (r != MAILDIR_NO_ERROR)
+    goto exit;
+  
+  return MAIL_NO_ERROR;
+  
+ exit:
+  return MAIL_NO_ERROR;
 }
 
 static int get_messages_list(mailsession * session,
     struct mailmessage_list ** result)
 {
   struct maildir * md;
   int r;
   struct mailmessage_list * env_list;
   int res;
   
   md = get_maildir_session(session);
   if (md == NULL)
     return MAIL_ERROR_BAD_STATE;
   
   r = maildir_update(md);
   if (r != MAILDIR_NO_ERROR) {
     res = maildirdriver_maildir_error_to_mail_error(r);
     goto err;
   }
   
   r = maildir_get_messages_list(session, md,
       maildir_message_driver, &env_list);
   if (r != MAILDIR_NO_ERROR) {
     res = r;
diff --git a/kmicromail/libetpan/generic/maildirdriver_cached.c b/kmicromail/libetpan/generic/maildirdriver_cached.c
index 503d1c9..8a5e206 100644
--- a/kmicromail/libetpan/generic/maildirdriver_cached.c
+++ b/kmicromail/libetpan/generic/maildirdriver_cached.c
@@ -65,95 +65,99 @@ static int parameters(mailsession * session,
     int id, void * value);
 
 static int connect_path(mailsession * session, char * path);
 
 static int logout(mailsession * session);
 
 static int expunge_folder(mailsession * session);
 
 static int status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int recent_number(mailsession * session, char * mb,
     uint32_t * result);
 
 static int unseen_number(mailsession * session, char * mb,
     uint32_t * result);
 
 static int messages_number(mailsession * session, char * mb,
     uint32_t * result);
 
 static int append_message(mailsession * session,
     char * message, size_t size);
 
+static int append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 static int get_messages_list(mailsession * session,
     struct mailmessage_list ** result);
 
 static int get_envelopes_list(mailsession * session,
     struct mailmessage_list * env_list);
 
 static int check_folder(mailsession * session);
 
 static int get_message(mailsession * session,
     uint32_t num, mailmessage ** result);
 
 static int get_message_by_uid(mailsession * session,
     const char * uid, mailmessage ** result);
 
 static mailsession_driver local_maildir_cached_session_driver = {
   .sess_name = "maildir-cached",
 
   .sess_initialize = initialize,
   .sess_uninitialize = uninitialize,
 
   .sess_parameters = parameters,
 
   .sess_connect_stream = NULL,
   .sess_connect_path = connect_path,
   .sess_starttls = NULL,
   .sess_login = NULL,
   .sess_logout = logout,
   .sess_noop = NULL,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = check_folder,
   .sess_examine_folder = NULL,
   .sess_select_folder = NULL,
   .sess_expunge_folder = expunge_folder,
   .sess_status_folder = status_folder,
   .sess_messages_number = messages_number,
   .sess_recent_number = recent_number,
   .sess_unseen_number = unseen_number,
   .sess_list_folders = NULL,
   .sess_lsub_folders = NULL,
   .sess_subscribe_folder = NULL,
   .sess_unsubscribe_folder = NULL,
 
   .sess_append_message = append_message,
+  .sess_append_message_flags = append_message_flags,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = get_messages_list,
   .sess_get_envelopes_list = get_envelopes_list,
   .sess_remove_message = NULL,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = get_message,
   .sess_get_message_by_uid = get_message_by_uid,
 };
 
 mailsession_driver * maildir_cached_session_driver =
 &local_maildir_cached_session_driver;
 
 
 static inline struct maildir_cached_session_state_data *
 get_cached_data(mailsession * session)
 {
   return session->sess_data;
 }
 
@@ -433,51 +437,125 @@ static int status_folder(mailsession * session, char * mb,
 }
 
 static int messages_number(mailsession * session, char * mb,
     uint32_t * result)
 {
   return mailsession_messages_number(get_ancestor(session), mb, result);
 }
 
 static int unseen_number(mailsession * session, char * mb,
     uint32_t * result)
 {
   return mailsession_unseen_number(get_ancestor(session), mb, result);
 }
 
 static int recent_number(mailsession * session, char * mb,
     uint32_t * result)
 {
   return mailsession_recent_number(get_ancestor(session), mb, result);
 }
 
 
 static int append_message(mailsession * session,
     char * message, size_t size)
 {
+#if 0
   return mailsession_append_message(get_ancestor(session), message, size);
+#endif
+  return append_message_flags(session, message, size, NULL);
 }
 
+static int append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  struct maildir * md;
+  int r;
+  char uid[PATH_MAX];
+  struct maildir_msg * md_msg;
+  chashdatum key;
+  chashdatum value;
+  uint32_t md_flags;
+  struct mail_cache_db * cache_db_flags;
+  char filename_flags[PATH_MAX];
+  MMAPString * mmapstr;
+  struct maildir_cached_session_state_data * data;
+  
+  md = get_maildir_session(session);
+  if (md == NULL)
+    return MAIL_ERROR_BAD_STATE;
+  
+  r = maildir_message_add_uid(md, message, size,
+      uid, sizeof(uid));
+  if (r != MAILDIR_NO_ERROR)
+    return maildirdriver_maildir_error_to_mail_error(r);
+  
+  if (flags == NULL)
+    goto exit;
+  
+  data = get_cached_data(session);
+  
+  snprintf(filename_flags, PATH_MAX, "%s%c%s%c%s",
+      data->md_flags_directory, MAIL_DIR_SEPARATOR, data->md_quoted_mb,
+      MAIL_DIR_SEPARATOR, FLAGS_NAME);
+  
+  r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
+  if (r < 0)
+    goto exit;
+  
+  mmapstr = mmap_string_new("");
+  if (mmapstr == NULL)
+    goto close_db_flags;
+  
+  r = write_cached_flags(cache_db_flags, mmapstr,
+      uid, flags);
+  
+  mmap_string_free(mmapstr);
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+  
+  if (r != MAIL_NO_ERROR)
+    goto exit;
+  
+  key.data = uid;
+  key.len = strlen(uid);
+  r = chash_get(md->mdir_msg_hash, &key, &value);
+  if (r < 0)
+    goto exit;
+  
+  md_msg = value.data;
+  
+  md_flags = maildirdriver_flags_to_maildir_flags(flags->fl_flags);
+  
+  r = maildir_message_change_flags(md, uid, md_flags);
+  if (r != MAILDIR_NO_ERROR)
+    goto exit;
+  
+  return MAIL_NO_ERROR;
+  
+ close_db_flags:
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+ exit:
+  return MAIL_NO_ERROR;
+}
 
 #define UID_NAME "uid.db"
 
 static int uid_clean_up(struct mail_cache_db * uid_db,
     struct mailmessage_list * env_list)
 {
   chash * hash_exist;
   int res;
   int r;
   unsigned int i;
   chashdatum key;
   chashdatum value;
   char key_str[PATH_MAX];
   
   /* flush cache */
   
   hash_exist = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYALL);
   if (hash_exist == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto err;
   }
   
   value.data = NULL;
   value.len = 0;
diff --git a/kmicromail/libetpan/generic/maildirdriver_cached_message.c b/kmicromail/libetpan/generic/maildirdriver_cached_message.c
index 51866aa..34de351 100644
--- a/kmicromail/libetpan/generic/maildirdriver_cached_message.c
+++ b/kmicromail/libetpan/generic/maildirdriver_cached_message.c
@@ -18,88 +18,93 @@
  *
  * 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 "maildirdriver_message.h"
 
 #include "mailmessage_tools.h"
 #include "maildirdriver.h"
 #include "maildir.h"
 #include "generic_cache.h"
+#include "mail_cache_db.h"
+#include "maildirdriver_tools.h"
 
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 
+static int get_flags(mailmessage * msg_info,
+    struct mail_flags ** result);
+
 static int prefetch(mailmessage * msg_info);
 
 static void prefetch_free(struct generic_message_t * msg);
 
 static int initialize(mailmessage * msg_info);
 
 static void check(mailmessage * msg_info);
 
 static mailmessage_driver local_maildir_cached_message_driver = {
   .msg_name = "maildir-cached",
 
   .msg_initialize = initialize,
   .msg_uninitialize = mailmessage_generic_uninitialize,
 
   .msg_flush = mailmessage_generic_flush,
   .msg_check = check,
 
   .msg_fetch_result_free = mailmessage_generic_fetch_result_free,
 
   .msg_fetch = mailmessage_generic_fetch,
   .msg_fetch_header = mailmessage_generic_fetch_header,
   .msg_fetch_body = mailmessage_generic_fetch_header,
   .msg_fetch_size = NULL,
   .msg_get_bodystructure = mailmessage_generic_get_bodystructure,
   .msg_fetch_section = mailmessage_generic_fetch_section,
   .msg_fetch_section_header = mailmessage_generic_fetch_section_header,
   .msg_fetch_section_mime = mailmessage_generic_fetch_section_mime,
   .msg_fetch_section_body = mailmessage_generic_fetch_section_body,
   .msg_fetch_envelope = mailmessage_generic_fetch_envelope,
 
-  .msg_get_flags = NULL,
+  .msg_get_flags = get_flags,
 };
 
 mailmessage_driver * maildir_cached_message_driver =
 &local_maildir_cached_message_driver;
 
 struct maildir_msg_data {
   int fd;
 };
 
 #if 0
 static inline struct maildir_cached_session_state_data *
 get_cached_session_data(mailmessage * msg)
 {
   return msg->session->data;
 }
 
 static inline mailsession * cached_session_get_ancestor(mailsession * session)
 {
   return get_data(session)->session;
 }
 
 static inline struct maildir_session_state_data *
 cached_session_get_ancestor_data(mailsession * session)
 {
@@ -225,24 +230,105 @@ static int initialize(mailmessage * msg_info)
   int r;
   
   r = mailmessage_generic_initialize(msg_info);
   if (r != MAIL_NO_ERROR)
     return r;
 
   msg = msg_info->msg_data;
   msg->msg_prefetch = prefetch;
   msg->msg_prefetch_free = prefetch_free;
 
   return MAIL_NO_ERROR;
 }
 
 static void check(mailmessage * msg_info)
 {
   int r;
 
   if (msg_info->msg_flags != NULL) {
     r = mail_flags_store_set(get_session_ancestor_data(msg_info)->md_flags_store, msg_info);
     
     r = mail_flags_store_set(get_cached_session_data(msg_info)->md_flags_store, msg_info);
     /* ignore errors */
   }
 }
+
+#define FLAGS_NAME "flags.db"
+
+static int get_flags(mailmessage * msg_info,
+    struct mail_flags ** result)
+{
+  struct mail_cache_db * cache_db_flags;
+  chashdatum key;
+  chashdatum value;
+  struct maildir * md;
+  struct mail_flags * flags;
+  struct maildir_cached_session_state_data * data;
+  struct maildir_msg * md_msg;
+  int r;
+  uint32_t driver_flags;
+  char filename_flags[PATH_MAX];
+  char keyname[PATH_MAX];
+  MMAPString * mmapstr;
+  
+  if (msg_info->msg_flags != NULL) {
+    * result = msg_info->msg_flags;
+    return MAIL_NO_ERROR;
+  }
+  
+  data = get_cached_session_data(msg_info);
+  flags = mail_flags_store_get(data->md_flags_store,
+      msg_info->msg_index);
+  if (flags != NULL) {
+    msg_info->msg_flags = flags;
+    * result = msg_info->msg_flags;
+    return MAIL_NO_ERROR;
+  }
+  
+  snprintf(filename_flags, PATH_MAX, "%s%c%s%c%s",
+      data->md_flags_directory, MAIL_DIR_SEPARATOR, data->md_quoted_mb,
+      MAIL_DIR_SEPARATOR, FLAGS_NAME);
+  
+  r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
+  if (r < 0)
+    return MAIL_ERROR_FILE;
+  
+  snprintf(keyname, PATH_MAX, "%s-flags", msg_info->msg_uid);
+  
+  mmapstr = mmap_string_new("");
+  if (mmapstr == NULL) {
+    mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+    return MAIL_ERROR_MEMORY;
+  }
+  
+  r = generic_cache_flags_read(cache_db_flags, mmapstr, keyname, &flags);
+  mmap_string_free(mmapstr);
+  
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+  
+  if (r != MAIL_NO_ERROR) {
+    flags = mail_flags_new_empty();
+    if (flags == NULL)
+      return MAIL_ERROR_MEMORY;
+  }
+  
+  md = get_maildir_session(msg_info);
+  if (md == NULL)
+    return MAIL_ERROR_BAD_STATE;
+  
+  key.data = msg_info->msg_uid;
+  key.len = strlen(msg_info->msg_uid);
+  r = chash_get(md->mdir_msg_hash, &key, &value);
+  if (r < 0)
+    return MAIL_ERROR_MSG_NOT_FOUND;
+  
+  md_msg = value.data;
+  
+  driver_flags = maildirdriver_maildir_flags_to_flags(md_msg->msg_flags);
+  
+  flags->fl_flags = driver_flags;
+  msg_info->msg_flags = flags;
+  
+  * result = msg_info->msg_flags;
+  
+  return MAIL_NO_ERROR;
+}
diff --git a/kmicromail/libetpan/generic/maildirdriver_message.c b/kmicromail/libetpan/generic/maildirdriver_message.c
index 7cf9dd1..613fc39 100644
--- a/kmicromail/libetpan/generic/maildirdriver_message.c
+++ b/kmicromail/libetpan/generic/maildirdriver_message.c
@@ -13,93 +13,97 @@
  *    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 "maildirdriver_message.h"
+#include "maildirdriver_tools.h"
 
 #include "mailmessage_tools.h"
 #include "maildirdriver.h"
 #include "maildir.h"
 #include "generic_cache.h"
 
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 
+static int get_flags(mailmessage * msg_info,
+    struct mail_flags ** result);
+
 static int prefetch(mailmessage * msg_info);
 
 static void prefetch_free(struct generic_message_t * msg);
 
 static int initialize(mailmessage * msg_info);
 
 static void check(mailmessage * msg_info);
 
 static mailmessage_driver local_maildir_message_driver = {
   .msg_name = "maildir",
 
   .msg_initialize = initialize,
   .msg_uninitialize = mailmessage_generic_uninitialize,
 
   .msg_flush = mailmessage_generic_flush,
   .msg_check = check,
 
   .msg_fetch_result_free = mailmessage_generic_fetch_result_free,
 
   .msg_fetch = mailmessage_generic_fetch,
   .msg_fetch_header = mailmessage_generic_fetch_header,
   .msg_fetch_body = mailmessage_generic_fetch_header,
   .msg_fetch_size = NULL,
   .msg_get_bodystructure = mailmessage_generic_get_bodystructure,
   .msg_fetch_section = mailmessage_generic_fetch_section,
   .msg_fetch_section_header = mailmessage_generic_fetch_section_header,
   .msg_fetch_section_mime = mailmessage_generic_fetch_section_mime,
   .msg_fetch_section_body = mailmessage_generic_fetch_section_body,
   .msg_fetch_envelope = mailmessage_generic_fetch_envelope,
 
-  .msg_get_flags = NULL,
+  .msg_get_flags = get_flags,
 };
 
 mailmessage_driver * maildir_message_driver = &local_maildir_message_driver;
 
 struct maildir_msg_data {
   int fd;
 };
 
 static inline struct maildir_session_state_data *
 get_session_data(mailmessage * msg)
 {
   return msg->msg_session->sess_data;
 }
 
 static struct maildir * get_maildir_session(mailmessage * msg)
 {
   return get_session_data(msg)->md_session;
 }
 
 static int prefetch(mailmessage * msg_info)
 {
   struct generic_message_t * msg;
   int res;
   struct maildir_msg_data * data;
@@ -176,24 +180,76 @@ static int initialize(mailmessage * msg_info)
   struct generic_message_t * msg;
   int r;
   
   r = mailmessage_generic_initialize(msg_info);
   if (r != MAIL_NO_ERROR)
     return r;
 
   msg = msg_info->msg_data;
   msg->msg_prefetch = prefetch;
   msg->msg_prefetch_free = prefetch_free;
 
   return MAIL_NO_ERROR;
 }
 
 static void check(mailmessage * msg_info)
 {
   int r;
 
   if (msg_info->msg_flags != NULL) {
     r = mail_flags_store_set(get_session_data(msg_info)->md_flags_store,
         msg_info);
     /* ignore errors */
   }
 }
+
+static int get_flags(mailmessage * msg_info,
+    struct mail_flags ** result)
+{
+  chashdatum key;
+  chashdatum value;
+  struct maildir * md;
+  struct mail_flags * flags;
+  struct maildir_session_state_data * data;
+  struct maildir_msg * md_msg;
+  int r;
+  uint32_t driver_flags;
+  clist * ext;
+  
+  if (msg_info->msg_flags != NULL) {
+    * result = msg_info->msg_flags;
+    return MAIL_NO_ERROR;
+  }
+  
+  data = get_session_data(msg_info);
+  flags = mail_flags_store_get(data->md_flags_store,
+      msg_info->msg_index);
+  if (flags != NULL) {
+    msg_info->msg_flags = flags;
+    * result = msg_info->msg_flags;
+    return MAIL_NO_ERROR;
+  }
+  
+  md = get_maildir_session(msg_info);
+  if (md == NULL)
+    return MAIL_ERROR_BAD_STATE;
+  
+  key.data = msg_info->msg_uid;
+  key.len = strlen(msg_info->msg_uid);
+  r = chash_get(md->mdir_msg_hash, &key, &value);
+  if (r < 0)
+    return MAIL_ERROR_MSG_NOT_FOUND;
+  
+  md_msg = value.data;
+  
+  driver_flags = maildirdriver_maildir_flags_to_flags(md_msg->msg_flags);
+  
+  ext = clist_new();
+  if (ext == NULL)
+    return MAIL_ERROR_MEMORY;
+  
+  msg_info->msg_flags = mail_flags_new(driver_flags, ext);
+  
+  * result = msg_info->msg_flags;
+  
+  return MAIL_NO_ERROR;
+}
diff --git a/kmicromail/libetpan/generic/maildirstorage.c b/kmicromail/libetpan/generic/maildirstorage.c
index 7e6b461..e37f591 100644
--- a/kmicromail/libetpan/generic/maildirstorage.c
+++ b/kmicromail/libetpan/generic/maildirstorage.c
@@ -12,81 +12,82 @@
  * 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 "maildirstorage.h"
 #include "mailstorage.h"
 
 #include "mail.h"
 #include "mailmessage.h"
 #include "maildirdriver.h"
 #include "maildirdriver_cached.h"
 #include "maildriver.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 /* maildir storage */
 
 static int maildir_mailstorage_connect(struct mailstorage * storage);
 static int
 maildir_mailstorage_get_folder_session(struct mailstorage * storage,
     char * pathname, mailsession ** result);
 static void maildir_mailstorage_uninitialize(struct mailstorage * storage);
 
 static mailstorage_driver maildir_mailstorage_driver = {
   .sto_name               = "maildir",
   .sto_connect            = maildir_mailstorage_connect,
   .sto_get_folder_session = maildir_mailstorage_get_folder_session,
   .sto_uninitialize       = maildir_mailstorage_uninitialize,
 };
 
 int maildir_mailstorage_init(struct mailstorage * storage,
     char * md_pathname, int md_cached,
     char * md_cache_directory, char * md_flags_directory)
 {
   struct maildir_mailstorage * maildir_storage;
 
-  maildir_storage = malloc(sizeof(struct maildir_mailstorage));
+  maildir_storage = malloc(sizeof(* maildir_storage));
   if (maildir_storage == NULL)
     goto err;
 
   maildir_storage->md_pathname = strdup(md_pathname);
   if (maildir_storage->md_pathname == NULL)
     goto free;
 
   maildir_storage->md_cached = md_cached;
 
   if (md_cached && (md_cache_directory != NULL) &&
       (md_flags_directory != NULL)) {
     maildir_storage->md_cache_directory = strdup(md_cache_directory);
     if (maildir_storage->md_cache_directory == NULL)
       goto free_pathname;
 
     maildir_storage->md_flags_directory = strdup(md_flags_directory);
     if (maildir_storage->md_flags_directory == NULL)
       goto free_cache_directory;
   }
   else {
     maildir_storage->md_cached = FALSE;
     maildir_storage->md_cache_directory = NULL;
     maildir_storage->md_flags_directory = NULL;
   }
diff --git a/kmicromail/libetpan/generic/maildirstorage.h b/kmicromail/libetpan/generic/maildirstorage.h
index d17ea2c..73d7b20 100644
--- a/kmicromail/libetpan/generic/maildirstorage.h
+++ b/kmicromail/libetpan/generic/maildirstorage.h
@@ -23,47 +23,47 @@
  * 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$
  */
 
 #ifndef MAILDIRSTORAGE_H
 
 #define MAILDIRSTORAGE_H
 
 #include <libetpan/maildirdriver_types.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /*
-  maildir_mailstorage_init is the constructor for a mbox storage.
+  maildir_mailstorage_init is the constructor for a maildir storage.
 
   @param storage this is the storage to initialize.
   
   @param pathname is the directory that contains the mailbox.
   
   @param cached if this value is != 0, a persistant cache will be
     stored on local system.
 
   @param cache_directory is the location of the cache
 
   @param flags_directory is the location of the flags
 */
 
 int maildir_mailstorage_init(struct mailstorage * storage,
     char * md_pathname, int md_cached,
     char * md_cache_directory, char * md_flags_directory);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
diff --git a/kmicromail/libetpan/generic/maildriver.c b/kmicromail/libetpan/generic/maildriver.c
index 01e3e34..1fc478a 100644
--- a/kmicromail/libetpan/generic/maildriver.c
+++ b/kmicromail/libetpan/generic/maildriver.c
@@ -261,48 +261,58 @@ int mailsession_subscribe_folder(mailsession * session, char * mb)
     return MAIL_ERROR_NOT_IMPLEMENTED;
 
   return session->sess_driver->sess_subscribe_folder(session, mb);
 }
 
 int mailsession_unsubscribe_folder(mailsession * session, char * mb)
 {
   if (session->sess_driver->sess_unsubscribe_folder == NULL)
     return MAIL_ERROR_NOT_IMPLEMENTED;
 
   return session->sess_driver->sess_unsubscribe_folder(session, mb);
 }
 
 /* message */
 
 int mailsession_append_message(mailsession * session,
 			       char * message, size_t size)
 {
   if (session->sess_driver->sess_append_message == NULL)
     return MAIL_ERROR_NOT_IMPLEMENTED;
 
   return session->sess_driver->sess_append_message(session, message, size);
 }
 
+int mailsession_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  if (session->sess_driver->sess_append_message_flags == NULL)
+    return MAIL_ERROR_NOT_IMPLEMENTED;
+
+  return session->sess_driver->sess_append_message_flags(session,
+      message, size, flags);
+}
+
 int mailsession_copy_message(mailsession * session,
 			     uint32_t num, char * mb)
 {
   if (session->sess_driver->sess_copy_message == NULL)
     return MAIL_ERROR_NOT_IMPLEMENTED;
 
   return session->sess_driver->sess_copy_message(session, num, mb);
 }
 
 int mailsession_move_message(mailsession * session,
 			     uint32_t num, char * mb)
 {
   if (session->sess_driver->sess_move_message == NULL) {
     int r;
 
     if ((session->sess_driver->sess_copy_message == NULL) &&
 	(session->sess_driver->sess_remove_message == NULL))
       return MAIL_ERROR_NOT_IMPLEMENTED;
 
     r = mailsession_copy_message(session, num, mb);
     if (r != MAIL_NO_ERROR)
       return r;
 
     r = mailsession_remove_message(session, num);
diff --git a/kmicromail/libetpan/generic/maildriver.h b/kmicromail/libetpan/generic/maildriver.h
index 7da9aea..c773190 100644
--- a/kmicromail/libetpan/generic/maildriver.h
+++ b/kmicromail/libetpan/generic/maildriver.h
@@ -379,48 +379,51 @@ int mailsession_subscribe_folder(mailsession * session, char * mb);
   @param session the session
   @param mb the mailbox
 
   @return MAIL_NO_ERROR is returned on success, MAIL_ERROR_XXX is returned
     on error
 */
 
 int mailsession_unsubscribe_folder(mailsession * session, char * mb);
 
 /*
   mailsession_append_message adds a RFC 2822 message to the current
   given mailbox
 
   @param session the session
   @param message is a string that contains the RFC 2822 message
   @param size this is the size of the message
 
   @return MAIL_NO_ERROR is returned on success, MAIL_ERROR_XXX is returned
     on error
 */
 
 int mailsession_append_message(mailsession * session,
 			       char * message, size_t size);
 
+int mailsession_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 /*
   NOTE: some drivers does not implement this
 
   mailsession_copy_message copies a message whose number is given to
   a given mailbox. The mailbox must be accessible from the same session.
 
   @param session the session
   @param num the message number
   @param mb the destination mailbox
 
   @return MAIL_NO_ERROR is returned on success, MAIL_ERROR_XXX is returned
     on error
 */
 
 int mailsession_copy_message(mailsession * session,
 			     uint32_t num, char * mb);
 
 /*
   NOTE: some drivers does not implement this
 
   mailsession_move_message copies a message whose number is given to
   a given mailbox. The mailbox must be accessible from the same session.
 
   @param session the session
diff --git a/kmicromail/libetpan/generic/maildriver_types.h b/kmicromail/libetpan/generic/maildriver_types.h
index 3ff9440..9eab4d6 100644
--- a/kmicromail/libetpan/generic/maildriver_types.h
+++ b/kmicromail/libetpan/generic/maildriver_types.h
@@ -486,48 +486,50 @@ struct mailsession_driver {
   int (* sess_select_folder)(mailsession * session, char * mb);
   int (* sess_expunge_folder)(mailsession * session);
   int (* sess_status_folder)(mailsession * session, char * mb,
       uint32_t * result_num, uint32_t * result_recent,
       uint32_t * result_unseen);
   int (* sess_messages_number)(mailsession * session, char * mb,
       uint32_t * result);
   int (* sess_recent_number)(mailsession * session, char * mb,
       uint32_t * result);
   int (* sess_unseen_number)(mailsession * session, char * mb,
       uint32_t * result);
 
   int (* sess_list_folders)(mailsession * session, char * mb,
       struct mail_list ** result);
   int (* sess_lsub_folders)(mailsession * session, char * mb,
       struct mail_list ** result);
 
   int (* sess_subscribe_folder)(mailsession * session, char * mb);
   int (* sess_unsubscribe_folder)(mailsession * session, char * mb);
 
   /* messages operations */
 
   int (* sess_append_message)(mailsession * session,
       char * message, size_t size);
+  int (* sess_append_message_flags)(mailsession * session,
+      char * message, size_t size, struct mail_flags * flags);
   int (* sess_copy_message)(mailsession * session,
       uint32_t num, char * mb);
   int (* sess_move_message)(mailsession * session,
       uint32_t num, char * mb);
 
   int (* sess_get_message)(mailsession * session,
       uint32_t num, mailmessage ** result);
 
   int (* sess_get_message_by_uid)(mailsession * session,
       const char * uid, mailmessage ** result);
   
   int (* sess_get_messages_list)(mailsession * session,
       struct mailmessage_list ** result);
   int (* sess_get_envelopes_list)(mailsession * session,
       struct mailmessage_list * env_list);
   int (* sess_remove_message)(mailsession * session, uint32_t num);
 #if 0
   int (* sess_search_messages)(mailsession * session, char * charset,
       struct mail_search_key * key,
       struct mail_search_result ** result);
 #endif
 };
 
 
diff --git a/kmicromail/libetpan/generic/mailfolder.c b/kmicromail/libetpan/generic/mailfolder.c
index 2ddc37d..89ba891 100644
--- a/kmicromail/libetpan/generic/mailfolder.c
+++ b/kmicromail/libetpan/generic/mailfolder.c
@@ -11,48 +11,55 @@ int mailfolder_check(struct mailfolder * folder)
 {
   return mailsession_check_folder(folder->fld_session);
 }
 
 int mailfolder_expunge(struct mailfolder * folder)
 {
   return mailsession_expunge_folder(folder->fld_session);
 }
 
 int mailfolder_status(struct mailfolder * folder,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen)
 {
   return mailsession_status_folder(folder->fld_session,
       folder->fld_pathname, result_messages,
       result_recent, result_unseen);
 }
 
 int mailfolder_append_message(struct mailfolder * folder,
     char * message, size_t size)
 {
   return mailsession_append_message(folder->fld_session, message, size);
 }
 
+int mailfolder_append_message_flags(struct mailfolder * folder,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  return mailsession_append_message_flags(folder->fld_session, message,
+      size, flags);
+}
+
 int mailfolder_get_messages_list(struct mailfolder * folder,
     struct mailmessage_list ** result)
 {
   int r;
   struct mailmessage_list * msg_list;
   unsigned int i;
   
   r = mailsession_get_messages_list(folder->fld_session, &msg_list);
   if (r != MAIL_NO_ERROR)
     return r;
   
   for(i = 0 ; i < carray_count(msg_list->msg_tab) ; i ++) {
     mailmessage * msg;
     
     msg = carray_get(msg_list->msg_tab, i);
     msg->msg_folder = folder;
   }
   
   * result = msg_list;
   
   return MAIL_NO_ERROR;
 }
 
 int mailfolder_get_envelopes_list(struct mailfolder * folder,
diff --git a/kmicromail/libetpan/generic/mailfolder.h b/kmicromail/libetpan/generic/mailfolder.h
index 3ecad23..ff53470 100644
--- a/kmicromail/libetpan/generic/mailfolder.h
+++ b/kmicromail/libetpan/generic/mailfolder.h
@@ -1,32 +1,35 @@
 #ifndef MAILFOLDER_H
 
 #define MAILFOLDER_H
 
 #include "mailstorage_types.h"
 
 int mailfolder_noop(struct mailfolder * folder);
 
 int mailfolder_check(struct mailfolder * folder);
 
 int mailfolder_expunge(struct mailfolder * folder);
 
 int mailfolder_status(struct mailfolder * folder,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 int mailfolder_append_message(struct mailfolder * folder,
     char * message, size_t size);
 
+int mailfolder_append_message_flags(struct mailfolder * folder,
+    char * message, size_t size, struct mail_flags * flags);
+
 int mailfolder_get_messages_list(struct mailfolder * folder,
     struct mailmessage_list ** result);
 
 int mailfolder_get_envelopes_list(struct mailfolder * folder,
     struct mailmessage_list * result);
 
 int mailfolder_get_message(struct mailfolder * folder,
     uint32_t num, mailmessage ** result);
 
 int mailfolder_get_message_by_uid(struct mailfolder * folder,
     const char * uid, mailmessage ** result);
 
 #endif
diff --git a/kmicromail/libetpan/generic/mailstorage.c b/kmicromail/libetpan/generic/mailstorage.c
index 25e561e..dc91744 100644
--- a/kmicromail/libetpan/generic/mailstorage.c
+++ b/kmicromail/libetpan/generic/mailstorage.c
@@ -302,33 +302,40 @@ int mailstorage_connect(struct mailstorage * storage)
 }
 
 
 void mailstorage_disconnect(struct mailstorage * storage)
 {
   int r;
   clistiter * cur;
 
   while ((cur = clist_begin(storage->sto_shared_folders)) != NULL) {
     struct mailfolder * folder;
 
     folder = cur->data;
     mailfolder_disconnect(folder);
   }
 
   if (storage->sto_session == NULL)
     return;
 
   r = mailsession_logout(storage->sto_session);
 
   mailsession_free(storage->sto_session);
   storage->sto_session = NULL;
 }
 
+
+int mailstorage_noop(struct mailstorage * storage)
+{
+  return mailsession_noop(storage->sto_session);
+}
+
+
 static int mailstorage_get_folder(struct mailstorage * storage,
     char * pathname, mailsession ** result)
 {
   if (storage->sto_driver->sto_get_folder_session == NULL)
     return MAIL_ERROR_NOT_IMPLEMENTED;
 
   return storage->sto_driver->sto_get_folder_session(storage,
       pathname, result);
 }
diff --git a/kmicromail/libetpan/generic/mailstorage.h b/kmicromail/libetpan/generic/mailstorage.h
index d56aef1..4c57883 100644
--- a/kmicromail/libetpan/generic/mailstorage.h
+++ b/kmicromail/libetpan/generic/mailstorage.h
@@ -50,49 +50,50 @@ extern "C" {
   mailstorage_new
 
   This function creates an empty storage. This storage have to be initialized.
   The "driver" and "data" fields should be initialized.
 
   @param id  is the name of the storage. It can be NULL.
     The given parameter is no more needed when the creation is finished.
     The given string is duplicated.
 
   @return The mail storage is returned.
 */
 
 struct mailstorage * mailstorage_new(char * sto_id);
 
 void mailstorage_free(struct mailstorage * storage);
 
 /*
   session will be initialized on success.
 */
 
 int mailstorage_connect(struct mailstorage * storage);
 
 void mailstorage_disconnect(struct mailstorage * storage);
 
+int mailstorage_noop(struct mailstorage * storage);
+
 
 /* folder */
 
 struct mailfolder * mailfolder_new(struct mailstorage * fld_storage,
     char * fld_pathname, char * fld_virtual_name);
 
 void mailfolder_free(struct mailfolder * folder);
 
 int mailfolder_add_child(struct mailfolder * parent,
         struct mailfolder * child);
 
 int mailfolder_detach_parent(struct mailfolder * folder);
 
 int mailfolder_connect(struct mailfolder * folder);
 
 void mailfolder_disconnect(struct mailfolder * folder);
 
-
 #ifdef __cplusplus
 }
 #endif
 
 #endif
 
 
diff --git a/kmicromail/libetpan/generic/mboxdriver.c b/kmicromail/libetpan/generic/mboxdriver.c
index fa3e2ea..c19a668 100644
--- a/kmicromail/libetpan/generic/mboxdriver.c
+++ b/kmicromail/libetpan/generic/mboxdriver.c
@@ -56,48 +56,51 @@
 
 static int mboxdriver_initialize(mailsession * session);
 
 static void mboxdriver_uninitialize(mailsession * session);
 
 static int mboxdriver_parameters(mailsession * session,
 				 int id, void * value);
 
 static int mboxdriver_connect_path(mailsession * session, char * path);
 
 static int mboxdriver_logout(mailsession * session);
 
 static int mboxdriver_expunge_folder(mailsession * session);
 
 static int mboxdriver_status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int mboxdriver_messages_number(mailsession * session, char * mb,
 				      uint32_t * result);
 
 static int mboxdriver_append_message(mailsession * session,
 				     char * message, size_t size);
 
+static int mboxdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 static int mboxdriver_get_messages_list(mailsession * session,
 					struct mailmessage_list ** result);
 
 static int
 mboxdriver_get_envelopes_list(mailsession * session,
 			      struct mailmessage_list * env_list);
 
 static int mboxdriver_remove_message(mailsession * session, uint32_t num);
 
 static int mboxdriver_get_message(mailsession * session,
 				  uint32_t num, mailmessage ** result);
 
 static int mboxdriver_get_message_by_uid(mailsession * session,
     const char * uid,
     mailmessage ** result);
 
 static mailsession_driver local_mbox_session_driver = {
   .sess_name = "mbox",
 
   .sess_initialize = mboxdriver_initialize,
   .sess_uninitialize = mboxdriver_uninitialize,
 
   .sess_parameters = mboxdriver_parameters,
 
@@ -105,48 +108,49 @@ static mailsession_driver local_mbox_session_driver = {
   .sess_connect_stream = NULL,
   .sess_starttls = NULL,
   .sess_login = NULL,
   .sess_logout = mboxdriver_logout,
   .sess_noop = NULL,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = NULL,
   .sess_examine_folder = NULL,
   .sess_select_folder = NULL,
   .sess_expunge_folder = mboxdriver_expunge_folder,
   .sess_status_folder = mboxdriver_status_folder,
   .sess_messages_number = mboxdriver_messages_number,
   .sess_recent_number = mboxdriver_messages_number,
   .sess_unseen_number = mboxdriver_messages_number,
   .sess_list_folders = NULL,
   .sess_lsub_folders = NULL,
   .sess_subscribe_folder = NULL,
   .sess_unsubscribe_folder = NULL,
 
   .sess_append_message = mboxdriver_append_message,
+  .sess_append_message_flags = mboxdriver_append_message_flags,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = mboxdriver_get_messages_list,
   .sess_get_envelopes_list = mboxdriver_get_envelopes_list,
   .sess_remove_message = mboxdriver_remove_message,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = mboxdriver_get_message,
   .sess_get_message_by_uid = mboxdriver_get_message_by_uid,
 };
 
 mailsession_driver * mbox_session_driver = &local_mbox_session_driver;
 
 static inline struct mbox_session_state_data * get_data(mailsession * session)
 {
   return session->sess_data;
 }
 
 static inline struct mailmbox_folder * get_mbox_session(mailsession * session)
 {
   return get_data(session)->mbox_folder;
@@ -323,48 +327,54 @@ static int mboxdriver_messages_number(mailsession * session, char * mb,
 }
 
 /* messages operations */
 
 static int mboxdriver_append_message(mailsession * session,
 				     char * message, size_t size)
 {
   int r;
   struct mailmbox_folder * folder;
 
   folder = get_mbox_session(session);
   if (folder == NULL)
     return MAIL_ERROR_APPEND;
 
   r = mailmbox_append_message(folder, message, size);
 
   switch (r) {
   case MAILMBOX_ERROR_FILE:
     return MAIL_ERROR_DISKSPACE;
   default:
     return mboxdriver_mbox_error_to_mail_error(r);
   }
 }
 
+static int mboxdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  return mboxdriver_append_message(session, message, size);
+}
+
 static int mboxdriver_get_messages_list(mailsession * session,
 					struct mailmessage_list ** result)
 {
   struct mailmbox_folder * folder;
   int res;
 
   folder = get_mbox_session(session);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
 
   return mbox_get_messages_list(folder, session, mbox_message_driver, result);
 
  err:
   return res;
 }
 
 static int
 mboxdriver_get_envelopes_list(mailsession * session,
 			      struct mailmessage_list * env_list)
 {
   struct mailmbox_folder * folder;
   unsigned int i;
diff --git a/kmicromail/libetpan/generic/mboxdriver_cached.c b/kmicromail/libetpan/generic/mboxdriver_cached.c
index 07871fa..3af7fb9 100644
--- a/kmicromail/libetpan/generic/mboxdriver_cached.c
+++ b/kmicromail/libetpan/generic/mboxdriver_cached.c
@@ -65,48 +65,51 @@ static void mboxdriver_cached_uninitialize(mailsession * session);
 static int mboxdriver_cached_parameters(mailsession * session,
 					int id, void * value);
 
 static int mboxdriver_cached_connect_path(mailsession * session, char * path);
 
 static int mboxdriver_cached_logout(mailsession * session);
 
 static int mboxdriver_cached_check_folder(mailsession * session);
 
 static int mboxdriver_cached_expunge_folder(mailsession * session);
 
 static int mboxdriver_cached_status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 static int mboxdriver_cached_messages_number(mailsession * session, char * mb,
 					     uint32_t * result);
 static int mboxdriver_cached_recent_number(mailsession * session, char * mb,
 					   uint32_t * result);
 static int mboxdriver_cached_unseen_number(mailsession * session, char * mb,
 					   uint32_t * result);
 
 static int mboxdriver_cached_append_message(mailsession * session,
 					    char * message, size_t size);
 
+static int mboxdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 static int
 mboxdriver_cached_get_messages_list(mailsession * session,
 				    struct mailmessage_list ** result);
 
 static int
 mboxdriver_cached_get_envelopes_list(mailsession * session,
 			      struct mailmessage_list * env_list);
 
 static int mboxdriver_cached_remove_message(mailsession * session,
 					    uint32_t num);
 
 static int mboxdriver_cached_get_message(mailsession * session,
 					 uint32_t num, mailmessage ** result);
 
 static int mboxdriver_cached_get_message_by_uid(mailsession * session,
     const char * uid,
     mailmessage ** result);
 
 static mailsession_driver local_mbox_cached_session_driver = {
   .sess_name = "mbox-cached",
 
   .sess_initialize = mboxdriver_cached_initialize,
   .sess_uninitialize = mboxdriver_cached_uninitialize,
 
@@ -116,48 +119,50 @@ static mailsession_driver local_mbox_cached_session_driver = {
   .sess_connect_stream = NULL,
   .sess_starttls = NULL,
   .sess_login = NULL,
   .sess_logout = mboxdriver_cached_logout,
   .sess_noop = NULL,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = mboxdriver_cached_check_folder,
   .sess_examine_folder = NULL,
   .sess_select_folder = NULL,
   .sess_expunge_folder = mboxdriver_cached_expunge_folder,
   .sess_status_folder = mboxdriver_cached_status_folder,
   .sess_messages_number = mboxdriver_cached_messages_number,
   .sess_recent_number = mboxdriver_cached_recent_number,
   .sess_unseen_number = mboxdriver_cached_unseen_number,
   .sess_list_folders = NULL,
   .sess_lsub_folders = NULL,
   .sess_subscribe_folder = NULL,
   .sess_unsubscribe_folder = NULL,
 
   .sess_append_message = mboxdriver_cached_append_message,
+  .sess_append_message_flags = mboxdriver_cached_append_message_flags,
+  
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = mboxdriver_cached_get_messages_list,
   .sess_get_envelopes_list = mboxdriver_cached_get_envelopes_list,
   .sess_remove_message = mboxdriver_cached_remove_message,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = mboxdriver_cached_get_message,
   .sess_get_message_by_uid = mboxdriver_cached_get_message_by_uid,
 };
 
 mailsession_driver * mbox_cached_session_driver =
 &local_mbox_cached_session_driver;
 
 
 #define ENV_NAME "env.db"
 #define FLAGS_NAME "flags.db"
 
 
 
 static int mbox_error_to_mail_error(int error)
@@ -885,49 +890,126 @@ static int mboxdriver_cached_recent_number(mailsession * session, char * mb,
 
 static int mboxdriver_cached_unseen_number(mailsession * session, char * mb,
 					   uint32_t * result)
 {
   uint32_t messages;
   uint32_t recent;
   uint32_t unseen;
   int r;
   
   r = mboxdriver_cached_status_folder(session, mb,
       &messages, &recent, &unseen);
   if (r != MAIL_NO_ERROR)
     return r;
   
   * result = unseen;
   
   return MAIL_NO_ERROR;
 }
 
 /* messages operations */
 
 static int mboxdriver_cached_append_message(mailsession * session,
 					    char * message, size_t size)
 {
-  return mailsession_append_message(get_ancestor(session), message, size);
+  return mboxdriver_cached_append_message_flags(session,
+      message, size, NULL);
+}
+
+static int mboxdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  int r;
+  struct mailmbox_folder * folder;
+  struct mbox_cached_session_state_data * data;
+  unsigned int uid;
+  struct mailmbox_msg_info * msg_info;
+  chashdatum key;
+  chashdatum value;
+  struct mail_cache_db * cache_db_flags;
+  char filename_flags[PATH_MAX];
+  MMAPString * mmapstr;
+  char keyname[PATH_MAX];
+  
+  folder = get_mbox_session(session);
+  if (folder == NULL)
+    return MAIL_ERROR_APPEND;
+  
+  r = mailmbox_append_message_uid(folder, message, size, &uid);
+  
+  switch (r) {
+  case MAILMBOX_ERROR_FILE:
+    return MAIL_ERROR_DISKSPACE;
+  case MAILMBOX_NO_ERROR:
+    break;
+  default:
+    return mboxdriver_mbox_error_to_mail_error(r);
+  }
+  
+  /* could store in flags store instead */
+  
+  if (flags == NULL)
+    goto exit;
+  
+  key.data = &uid;
+  key.len = sizeof(uid); 
+  r = chash_get(folder->mb_hash, &key, &value);
+  if (r < 0)
+    goto exit;
+  
+  msg_info = value.data;
+  
+  data = get_cached_data(session);
+  
+  snprintf(filename_flags, PATH_MAX, "%s%c%s%c%s",
+      data->mbox_flags_directory, MAIL_DIR_SEPARATOR, data->mbox_quoted_mb,
+      MAIL_DIR_SEPARATOR, FLAGS_NAME);
+  
+  r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
+  if (r < 0)
+    goto exit;
+  
+  mmapstr = mmap_string_new("");
+  if (mmapstr == NULL)
+    goto close_db_flags;
+  
+  snprintf(keyname, PATH_MAX, "%u-%lu", uid,
+      (unsigned long) msg_info->msg_body_len);
+  
+  r = mboxdriver_write_cached_flags(cache_db_flags, mmapstr, keyname, flags);
+  
+  mmap_string_free(mmapstr);
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+  
+  if (r != MAIL_NO_ERROR)
+    goto exit;
+  
+  return MAIL_NO_ERROR;
+  
+ close_db_flags:
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+ exit:
+  return MAIL_NO_ERROR;
 }
 
 static int
 mboxdriver_cached_get_messages_list(mailsession * session,
 				    struct mailmessage_list ** result)
 {
   struct mailmbox_folder * folder;
   int res;
 
   folder = get_mbox_session(session);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
 
   return mbox_get_uid_messages_list(folder,
       session, mbox_cached_message_driver, result);
 
  err:
   return res;
 }
 
 static int
 get_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
@@ -939,95 +1021,97 @@ get_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
   struct mailimf_fields * fields;
   int res;
   struct mailmbox_msg_info * info;
   struct mailmbox_folder * folder;
   chashdatum key;
   chashdatum data;
   
   folder = get_mbox_session(session);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
   
   key.data = &num;
   key.len = sizeof(num);
   
   r = chash_get(folder->mb_hash, &key, &data);
   if (r < 0) {
     res = MAIL_ERROR_MSG_NOT_FOUND;
     goto err;
   }
   
   info = data.data;
   
-  snprintf(keyname, PATH_MAX, "%u-%u-envelope", num, info->msg_body_len);
+  snprintf(keyname, PATH_MAX, "%u-%lu-envelope", num,
+      (unsigned long) info->msg_body_len);
 
   r = generic_cache_fields_read(cache_db, mmapstr, keyname, &fields);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   * result = fields;
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
 
 static int
 write_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
     mailsession * session, uint32_t num,
     struct mailimf_fields * fields)
 {
   int r;
   char keyname[PATH_MAX];
   int res;
   struct mailmbox_msg_info * info;
   struct mailmbox_folder * folder;
   chashdatum key;
   chashdatum data;
   
   folder = get_mbox_session(session);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
 
   key.data = &num;
   key.len = sizeof(num);
   
   r = chash_get(folder->mb_hash, &key, &data);
   if (r < 0) {
     res = MAIL_ERROR_MSG_NOT_FOUND;
     goto err;
   }
   
   info = data.data;
   
-  snprintf(keyname, PATH_MAX, "%u-%u-envelope", num, info->msg_body_len);
+  snprintf(keyname, PATH_MAX, "%u-%lu-envelope", num,
+      (unsigned long) info->msg_body_len);
 
   r = generic_cache_fields_write(cache_db, mmapstr, keyname, fields);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
 
 static int
 mboxdriver_cached_get_envelopes_list(mailsession * session,
 				     struct mailmessage_list * env_list)
 {
   int r;
   unsigned int i;
   struct mbox_cached_session_state_data * cached_data;
   char filename_env[PATH_MAX];
   char filename_flags[PATH_MAX];
   struct mail_cache_db * cache_db_env;
   struct mail_cache_db * cache_db_flags;
diff --git a/kmicromail/libetpan/generic/mboxdriver_cached_message.c b/kmicromail/libetpan/generic/mboxdriver_cached_message.c
index 6d92b22..828396b 100644
--- a/kmicromail/libetpan/generic/mboxdriver_cached_message.c
+++ b/kmicromail/libetpan/generic/mboxdriver_cached_message.c
@@ -161,49 +161,50 @@ static int mbox_initialize(mailmessage * msg_info)
   char static_uid[PATH_MAX];
   struct mailmbox_msg_info * info;
   struct mailmbox_folder * folder;
   int res;
   chashdatum key;
   chashdatum data;
 
   folder = get_mbox_session(msg_info);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
     
   key.data = (char *) &msg_info->msg_index;
   key.len = sizeof(msg_info->msg_index);
   
   r = chash_get(folder->mb_hash, &key, &data);
   if (r < 0) {
     res = MAIL_ERROR_MSG_NOT_FOUND;
     goto err;
   }
   
   info = (struct mailmbox_msg_info *) data.data;
   
-  snprintf(static_uid, PATH_MAX, "%u-%u", msg_info->msg_index, info->msg_body_len);
+  snprintf(static_uid, PATH_MAX, "%u-%lu",
+      msg_info->msg_index, (unsigned long) info->msg_body_len);
   uid = strdup(static_uid);
   if (uid == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto err;
   }
   
   r = mailmessage_generic_initialize(msg_info);
   if (r != MAIL_NO_ERROR) {
     free(uid);
     res = r;
     goto err;
   }
 
   msg = msg_info->msg_data;
 
   msg->msg_prefetch = mbox_prefetch;
   msg->msg_prefetch_free = mbox_prefetch_free;
   msg_info->msg_uid = uid;
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
diff --git a/kmicromail/libetpan/generic/mboxdriver_message.c b/kmicromail/libetpan/generic/mboxdriver_message.c
index da9a65d..6922625 100644
--- a/kmicromail/libetpan/generic/mboxdriver_message.c
+++ b/kmicromail/libetpan/generic/mboxdriver_message.c
@@ -12,49 +12,49 @@
  * 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 "mhdriver_message.h"
+#include "mboxdriver_message.h"
 
 #include "mailmessage_tools.h"
 #include "mboxdriver_tools.h"
 #include "mboxdriver.h"
 #include "mailmbox.h"
 
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 
 static int mbox_prefetch(mailmessage * msg_info);
 
 static void mbox_prefetch_free(struct generic_message_t * msg);
 
 static int mbox_initialize(mailmessage * msg_info);
 
 static int mbox_fetch_size(mailmessage * msg_info,
 			   size_t * result);
 
 static int mbox_fetch_header(mailmessage * msg_info,
@@ -135,50 +135,50 @@ static int mbox_initialize(mailmessage * msg_info)
   char static_uid[PATH_MAX];
   struct mailmbox_msg_info * info;
   struct mailmbox_folder * folder;
   int res;
   chashdatum key;
   chashdatum data;
   
   folder = get_mbox_session(msg_info);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
   
   key.data = &msg_info->msg_index;
   key.len = sizeof(msg_info->msg_index);
   
   r = chash_get(folder->mb_hash, &key, &data);
   if (r < 0) {
     res = MAIL_ERROR_MSG_NOT_FOUND;
     goto err;
   }
   
   info = data.data;
   
-  snprintf(static_uid, PATH_MAX, "%u-%u",
-      msg_info->msg_index, info->msg_body_len);
+  snprintf(static_uid, PATH_MAX, "%u-%lu",
+      msg_info->msg_index, (unsigned long) info->msg_body_len);
   uid = strdup(static_uid);
   if (uid == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto err;
   }
   
   r = mailmessage_generic_initialize(msg_info);
   if (r != MAIL_NO_ERROR) {
     free(uid);
     res = r;
     goto err;
   }
   
   msg = msg_info->msg_data;
   msg->msg_prefetch = mbox_prefetch;
   msg->msg_prefetch_free = mbox_prefetch_free;
   msg_info->msg_uid = uid;
   
   return MAIL_NO_ERROR;
   
  err:
   return res;
 }
 
diff --git a/kmicromail/libetpan/generic/mboxdriver_tools.c b/kmicromail/libetpan/generic/mboxdriver_tools.c
index 1e27798..252a20b 100644
--- a/kmicromail/libetpan/generic/mboxdriver_tools.c
+++ b/kmicromail/libetpan/generic/mboxdriver_tools.c
@@ -196,49 +196,50 @@ mboxdriver_get_cached_flags(struct mail_cache_db * cache_db,
   struct mail_flags * flags;
   int res;
   struct mailmbox_msg_info * info;
   struct mailmbox_folder * folder;
   chashdatum key;
   chashdatum data;
 
   folder = cached_session_get_mbox_session(session);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
   
   key.data = &num;
   key.len = sizeof(num);
   
   r = chash_get(folder->mb_hash, &key, &data);
   if (r < 0) {
     res = MAIL_ERROR_MSG_NOT_FOUND;
     goto err;
   }
   
   info = data.data;
 
-  snprintf(keyname, PATH_MAX, "%u-%u-flags", num, info->msg_body_len);
+  snprintf(keyname, PATH_MAX, "%u-%lu-flags", num,
+      (unsigned long) info->msg_body_len);
 
   r = generic_cache_flags_read(cache_db, mmapstr, keyname, &flags);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   * result = flags;
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
 
 int
 mboxdriver_write_cached_flags(struct mail_cache_db * cache_db,
     MMAPString * mmapstr,
     char * uid,
     struct mail_flags * flags)
 {
   int r;
   char keyname[PATH_MAX];
   int res;
diff --git a/kmicromail/libetpan/generic/mboxstorage.c b/kmicromail/libetpan/generic/mboxstorage.c
index 0a7dc93..4b55b2b 100644
--- a/kmicromail/libetpan/generic/mboxstorage.c
+++ b/kmicromail/libetpan/generic/mboxstorage.c
@@ -44,49 +44,49 @@
 #include <stdlib.h>
 #include <string.h>
 
 /* mbox storage */
 
 static int mbox_mailstorage_connect(struct mailstorage * storage);
 static int
 mbox_mailstorage_get_folder_session(struct mailstorage * storage,
     char * pathname, mailsession ** result);
 static void mbox_mailstorage_uninitialize(struct mailstorage * storage);
 
 static mailstorage_driver mbox_mailstorage_driver = {
   .sto_name               = "mbox",
   .sto_connect            = mbox_mailstorage_connect,
   .sto_get_folder_session = mbox_mailstorage_get_folder_session,
   .sto_uninitialize       = mbox_mailstorage_uninitialize,
 };
 
 int mbox_mailstorage_init(struct mailstorage * storage,
     char * mbox_pathname, int mbox_cached,
     char * mbox_cache_directory, char * mbox_flags_directory)
 {
   struct mbox_mailstorage * mbox_storage;
 
-  mbox_storage = malloc(sizeof(struct mbox_mailstorage));
+  mbox_storage = malloc(sizeof(* mbox_storage));
   if (mbox_storage == NULL)
     goto err;
 
   mbox_storage->mbox_pathname = strdup(mbox_pathname);
   if (mbox_storage->mbox_pathname == NULL)
     goto free;
 
   mbox_storage->mbox_cached = mbox_cached;
 
   if (mbox_cached && (mbox_cache_directory != NULL) &&
       (mbox_flags_directory != NULL)) {
     mbox_storage->mbox_cache_directory = strdup(mbox_cache_directory);
     if (mbox_storage->mbox_cache_directory == NULL)
       goto free_pathname;
 
     mbox_storage->mbox_flags_directory = strdup(mbox_flags_directory);
     if (mbox_storage->mbox_flags_directory == NULL)
       goto free_cache_directory;
   }
   else {
     mbox_storage->mbox_cached = FALSE;
     mbox_storage->mbox_cache_directory = NULL;
     mbox_storage->mbox_flags_directory = NULL;
   }
diff --git a/kmicromail/libetpan/generic/mhdriver.c b/kmicromail/libetpan/generic/mhdriver.c
index af38d27..05a6a4f 100644
--- a/kmicromail/libetpan/generic/mhdriver.c
+++ b/kmicromail/libetpan/generic/mhdriver.c
@@ -68,48 +68,50 @@ static int mhdriver_delete_folder(mailsession * session, char * mb);
 static int mhdriver_rename_folder(mailsession * session, char * mb,
 				  char * new_name);
 
 static int mhdriver_select_folder(mailsession * session, char * mb);
 
 static int mhdriver_status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int mhdriver_messages_number(mailsession * session, char * mb,
 				    uint32_t * result);
 
 static int mhdriver_list_folders(mailsession * session, char * mb,
 				 struct mail_list ** result);
 
 static int mhdriver_lsub_folders(mailsession * session, char * mb,
 				 struct mail_list ** result);
 
 static int mhdriver_subscribe_folder(mailsession * session, char * mb);
 
 static int mhdriver_unsubscribe_folder(mailsession * session, char * mb);
 
 static int mhdriver_append_message(mailsession * session,
 				   char * message, size_t size);
+static int mhdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
 static int mhdriver_copy_message(mailsession * session,
 				 uint32_t num, char * mb);
 
 static int mhdriver_remove_message(mailsession * session, uint32_t num);
 
 static int mhdriver_move_message(mailsession * session,
 				 uint32_t num, char * mb);
 
 static int mhdriver_get_messages_list(mailsession * session,
 				      struct mailmessage_list ** result);
 
 static int mhdriver_get_message(mailsession * session,
 				uint32_t num, mailmessage ** result);
 
 static int mhdriver_get_message_by_uid(mailsession * session,
     const char * uid,
     mailmessage ** result);
 
 static mailsession_driver local_mh_session_driver = {
   .sess_name = "mh",
 
   .sess_initialize = mhdriver_initialize,
   .sess_uninitialize = mhdriver_uninitialize,
 
@@ -118,49 +120,50 @@ static mailsession_driver local_mh_session_driver = {
   .sess_connect_stream = NULL,
   .sess_connect_path = mhdriver_connect_path,
   .sess_starttls = NULL,
   .sess_login = NULL,
   .sess_logout = mhdriver_logout,
   .sess_noop = NULL,
 
   .sess_build_folder_name = mhdriver_build_folder_name,
   .sess_create_folder = mhdriver_create_folder,
   .sess_delete_folder = mhdriver_delete_folder,
   .sess_rename_folder = mhdriver_rename_folder,
   .sess_check_folder = NULL,
   .sess_examine_folder = NULL,
   .sess_select_folder = mhdriver_select_folder,
   .sess_expunge_folder = NULL,
   .sess_status_folder = mhdriver_status_folder,
   .sess_messages_number = mhdriver_messages_number,
   .sess_recent_number = mhdriver_messages_number,
   .sess_unseen_number = mhdriver_messages_number,
   .sess_list_folders = mhdriver_list_folders,
   .sess_lsub_folders = mhdriver_lsub_folders,
   .sess_subscribe_folder = mhdriver_subscribe_folder,
   .sess_unsubscribe_folder = mhdriver_unsubscribe_folder,
 
-  .sess_append_message = mhdriver_append_message,
+  .sess_append_message = mhdriver_append_message, 
+  .sess_append_message_flags = mhdriver_append_message_flags,
   .sess_copy_message = mhdriver_copy_message,
   .sess_move_message = mhdriver_move_message,
 
   .sess_get_messages_list = mhdriver_get_messages_list,
   .sess_get_envelopes_list = maildriver_generic_get_envelopes_list,
   .sess_remove_message = mhdriver_remove_message,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = mhdriver_get_message,
   .sess_get_message_by_uid = mhdriver_get_message_by_uid,
 };
 
 mailsession_driver * mh_session_driver = &local_mh_session_driver;
 
 static inline struct mh_session_state_data * get_data(mailsession * session)
 {
   return session->sess_data;
 }
 
 static inline struct mailmh * get_mh_session(mailsession * session)
 {
   return get_data(session)->mh_session;
@@ -663,48 +666,54 @@ static int mhdriver_unsubscribe_folder(mailsession * session, char * mb)
 
 /* messages operations */
 
 static int mhdriver_append_message(mailsession * session,
 				   char * message, size_t size)
 {
   int r;
   struct mailmh_folder * folder;
 
   folder = get_mh_cur_folder(session);
   if (folder == NULL)
     return MAIL_ERROR_BAD_STATE;
 
   r = mailmh_folder_add_message(folder, message, size);
 
   switch (r) {
   case MAILMH_ERROR_FILE:
     return MAIL_ERROR_DISKSPACE;
 
   default:
     return mhdriver_mh_error_to_mail_error(r);
   }
 }
 
+static int mhdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  return mhdriver_append_message(session, message, size);
+}
+
 static int mhdriver_copy_message(mailsession * session,
 				 uint32_t num, char * mb)
 {
   int fd;
   int r;
   struct mailmh_folder * folder;
   struct mailmh * mh;
   int res;
 
   mh = get_mh_session(session);
   if (mh == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
 
   folder = get_mh_cur_folder(session);
   if (folder == NULL) {
     res = MAIL_ERROR_BAD_STATE;
     goto err;
   }
 
   r = mailmh_folder_get_message_fd(folder, num, O_RDONLY, &fd);
   if (r != MAIL_NO_ERROR) {
     res = r;
diff --git a/kmicromail/libetpan/generic/mhdriver_cached.c b/kmicromail/libetpan/generic/mhdriver_cached.c
index 5c35089..04aa523 100644
--- a/kmicromail/libetpan/generic/mhdriver_cached.c
+++ b/kmicromail/libetpan/generic/mhdriver_cached.c
@@ -87,48 +87,50 @@ static int mhdriver_cached_expunge_folder(mailsession * session);
 static int mhdriver_cached_status_folder(mailsession * session, char * mb,
     uint32_t * result_messages, uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int mhdriver_cached_messages_number(mailsession * session, char * mb,
 					   uint32_t * result);
 static int mhdriver_cached_recent_number(mailsession * session, char * mb,
 					   uint32_t * result);
 static int mhdriver_cached_unseen_number(mailsession * session, char * mb,
 					   uint32_t * result);
 
 static int mhdriver_cached_list_folders(mailsession * session, char * mb,
 					struct mail_list ** result);
 
 static int mhdriver_cached_lsub_folders(mailsession * session, char * mb,
 					struct mail_list ** result);
 
 static int mhdriver_cached_subscribe_folder(mailsession * session, char * mb);
 
 static int mhdriver_cached_unsubscribe_folder(mailsession * session,
 					      char * mb);
 
 static int mhdriver_cached_append_message(mailsession * session,
 					  char * message, size_t size);
+static int mhdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
 static int mhdriver_cached_copy_message(mailsession * session,
 					uint32_t num, char * mb);
 
 static int mhdriver_cached_remove_message(mailsession * session,
 					  uint32_t num);
 
 static int mhdriver_cached_move_message(mailsession * session,
 					uint32_t num, char * mb);
 
 static int
 mhdriver_cached_get_messages_list(mailsession * session,
 				  struct mailmessage_list ** result);
 
 static int
 mhdriver_cached_get_envelopes_list(mailsession * session,
 				   struct mailmessage_list * env_list);
 
 static int mhdriver_cached_get_message(mailsession * session,
 				       uint32_t num, mailmessage ** result);
 
 static int mhdriver_cached_get_message_by_uid(mailsession * session,
     const char * uid,
     mailmessage ** result);
 
@@ -144,48 +146,49 @@ static mailsession_driver local_mh_cached_session_driver = {
   .sess_connect_path = mhdriver_cached_connect_path,
   .sess_starttls = NULL,
   .sess_login = NULL,
   .sess_logout = mhdriver_cached_logout,
   .sess_noop = NULL,
 
   .sess_build_folder_name = mhdriver_cached_build_folder_name,
   .sess_create_folder = mhdriver_cached_create_folder,
   .sess_delete_folder = mhdriver_cached_delete_folder,
   .sess_rename_folder = mhdriver_cached_rename_folder,
   .sess_check_folder = mhdriver_cached_check_folder,
   .sess_examine_folder = NULL,
   .sess_select_folder = mhdriver_cached_select_folder,
   .sess_expunge_folder = mhdriver_cached_expunge_folder,
   .sess_status_folder = mhdriver_cached_status_folder,
   .sess_messages_number = mhdriver_cached_messages_number,
   .sess_recent_number = mhdriver_cached_recent_number,
   .sess_unseen_number = mhdriver_cached_unseen_number,
   .sess_list_folders = mhdriver_cached_list_folders,
   .sess_lsub_folders = mhdriver_cached_lsub_folders,
   .sess_subscribe_folder = mhdriver_cached_subscribe_folder,
   .sess_unsubscribe_folder = mhdriver_cached_unsubscribe_folder,
 
   .sess_append_message = mhdriver_cached_append_message,
+  .sess_append_message_flags = mhdriver_cached_append_message_flags,
   .sess_copy_message = mhdriver_cached_copy_message,
   .sess_move_message = mhdriver_cached_move_message,
 
   .sess_get_messages_list = mhdriver_cached_get_messages_list,
   .sess_get_envelopes_list = mhdriver_cached_get_envelopes_list,
   .sess_remove_message = mhdriver_cached_remove_message,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = mhdriver_cached_get_message,
   .sess_get_message_by_uid = mhdriver_cached_get_message_by_uid,
 };
 
 mailsession_driver * mh_cached_session_driver =
 &local_mh_cached_session_driver;
 
 #define ENV_NAME "env.db"
 #define FLAGS_NAME "flags.db"
 
 
 static inline struct mh_cached_session_state_data *
 get_cached_data(mailsession * session)
 {
@@ -862,49 +865,127 @@ static int mhdriver_cached_list_folders(mailsession * session, char * mb,
 }
 
 static int mhdriver_cached_lsub_folders(mailsession * session, char * mb,
 					struct mail_list ** result)
 {
   return mailsession_lsub_folders(get_ancestor(session), mb, result);
 }
 
 static int mhdriver_cached_subscribe_folder(mailsession * session, char * mb)
 {
   return mailsession_subscribe_folder(get_ancestor(session), mb);
 }
 
 static int mhdriver_cached_unsubscribe_folder(mailsession * session,
 					      char * mb)
 {
   return mailsession_unsubscribe_folder(get_ancestor(session), mb);
 }
 
 /* messages operations */
 
 static int mhdriver_cached_append_message(mailsession * session,
 					  char * message, size_t size)
 {
-  return mailsession_append_message(get_ancestor(session), message, size);
+  return mhdriver_cached_append_message_flags(session,
+      message, size, NULL);
+}
+
+static int mhdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{ 
+  int r;
+  struct mailmh_folder * folder;
+  struct mailmh_msg_info * msg_info;
+  chashdatum key;
+  chashdatum value;
+  uint32_t uid;
+  struct mh_cached_session_state_data * data;
+  char filename_flags[PATH_MAX];
+  struct mail_cache_db * cache_db_flags;
+  MMAPString * mmapstr;
+  char keyname[PATH_MAX];
+  
+  folder = get_mh_cur_folder(session);
+  if (folder == NULL)
+    return MAIL_ERROR_BAD_STATE;
+  
+  r = mailmh_folder_add_message_uid(folder,
+      message, size, &uid);
+  
+  switch (r) {
+  case MAILMH_ERROR_FILE:
+    return MAIL_ERROR_DISKSPACE;
+    
+  case MAILMH_NO_ERROR:
+    break;
+    
+  default:
+    return mhdriver_mh_error_to_mail_error(r);
+  }
+  
+  if (flags == NULL)
+    goto exit;
+  
+  key.data = &uid;
+  key.len = sizeof(uid);
+  r = chash_get(folder->fl_msgs_hash, &key, &value);
+  if (r < 0)
+    return MAIL_ERROR_CACHE_MISS;
+  
+  msg_info = value.data;
+  
+  data = get_cached_data(session);
+  
+  snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
+      data->mh_flags_directory, data->mh_quoted_mb, FLAGS_NAME);
+  
+  r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
+  if (r < 0)
+    goto exit;
+  
+  mmapstr = mmap_string_new("");
+  if (mmapstr == NULL)
+    goto close_db_flags;
+  
+  snprintf(keyname, PATH_MAX, "%u-%lu-%lu-flags",
+      uid, (unsigned long) msg_info->msg_mtime,
+      (unsigned long) msg_info->msg_size);
+  
+  r = mhdriver_write_cached_flags(cache_db_flags, mmapstr, keyname, flags);
+  
+  mmap_string_free(mmapstr);
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+  
+  if (r != MAIL_NO_ERROR)
+    goto exit;
+  
+  return MAIL_NO_ERROR;
+  
+ close_db_flags:
+  mail_cache_db_close_unlock(filename_flags, cache_db_flags);
+ exit:
+  return MAIL_NO_ERROR;
 }
 
 static int mhdriver_cached_copy_message(mailsession * session,
 					uint32_t num, char * mb)
 {
   return mailsession_copy_message(get_ancestor(session), num, mb);
 }
 
 static int mhdriver_cached_remove_message(mailsession * session, uint32_t num)
 {
   return mailsession_remove_message(get_ancestor(session), num);
 }
 
 static int mhdriver_cached_move_message(mailsession * session,
 					uint32_t num, char * mb)
 {
   return mailsession_move_message(get_ancestor(session), num, mb);
 }
 
 static int
 mhdriver_cached_get_messages_list(mailsession * session,
 				  struct mailmessage_list ** result)
 {
   struct mailmh_folder * folder;
@@ -932,95 +1013,97 @@ get_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
 {
   int r;
   char keyname[PATH_MAX];
   struct mailimf_fields * fields;
   int res;
   struct mailmh_folder * folder;
   struct mailmh_msg_info * msg_info;
   chashdatum key;
   chashdatum data;
   
   folder = get_mh_cur_folder(session);
 
 #if 0
   msg_info = cinthash_find(mh_data->mh_cur_folder->fl_msgs_hash, num);
   if (msg_info == NULL)
     return MAIL_ERROR_CACHE_MISS;
 #endif
   key.data = &num;
   key.len = sizeof(num);
   r = chash_get(folder->fl_msgs_hash, &key, &data);
   if (r < 0)
     return MAIL_ERROR_CACHE_MISS;
   msg_info = data.data;
   
-  snprintf(keyname, PATH_MAX, "%u-%u-%u-envelope",
-	   num, (uint32_t) msg_info->msg_mtime, msg_info->msg_size);
+  snprintf(keyname, PATH_MAX, "%u-%lu-%lu-envelope",
+	   num, (unsigned long) msg_info->msg_mtime,
+      (unsigned long) msg_info->msg_size);
 
   r = generic_cache_fields_read(cache_db, mmapstr, keyname, &fields);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   * result = fields;
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
 
 static int
 write_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
     mailsession * session, uint32_t num,
     struct mailimf_fields * fields)
 {
   int r;
   char keyname[PATH_MAX];
   int res;
   struct mailmh_folder * folder;
   chashdatum key;
   chashdatum data;
   struct mailmh_msg_info * msg_info;
 
   folder = get_mh_cur_folder(session);
 #if 0
   msg_info = cinthash_find(mh_data->mh_cur_folder->fl_msgs_hash, num);
   if (msg_info == NULL) {
     res = MAIL_ERROR_CACHE_MISS;
     goto err;
   }
 #endif
   key.data = &num;
   key.len = sizeof(num);
   r = chash_get(folder->fl_msgs_hash, &key, &data);
   if (r < 0)
     return MAIL_ERROR_CACHE_MISS;
   msg_info = data.data;
 
-  snprintf(keyname, PATH_MAX, "%u-%u-%u-envelope",
-	   num, (uint32_t) msg_info->msg_mtime, msg_info->msg_size);
+  snprintf(keyname, PATH_MAX, "%u-%lu-%lu-envelope",
+	   num, (unsigned long) msg_info->msg_mtime,
+      (unsigned long) msg_info->msg_size);
 
   r = generic_cache_fields_write(cache_db, mmapstr, keyname, fields);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
 
 static int
 mhdriver_cached_get_envelopes_list(mailsession * session,
 				   struct mailmessage_list * env_list)
 {
   int r;
   unsigned int i;
   char filename_env[PATH_MAX];
   char filename_flags[PATH_MAX];
   struct mail_cache_db * cache_db_env;
   struct mail_cache_db * cache_db_flags;
   MMAPString * mmapstr;
diff --git a/kmicromail/libetpan/generic/mhdriver_cached_message.c b/kmicromail/libetpan/generic/mhdriver_cached_message.c
index f716fb9..f69868d 100644
--- a/kmicromail/libetpan/generic/mhdriver_cached_message.c
+++ b/kmicromail/libetpan/generic/mhdriver_cached_message.c
@@ -158,50 +158,50 @@ static void mh_prefetch_free(struct generic_message_t * msg)
   }
 }
 
 static int mh_initialize(mailmessage * msg_info)
 {
   struct generic_message_t * msg;
   int r;
   char * uid;
   char static_uid[PATH_MAX];
   struct mailmh_msg_info * mh_msg_info;
   chashdatum key;
   chashdatum data;
   struct mailmh_folder * folder;
 
   folder = get_mh_cur_folder(msg_info);
   
   key.data = &msg_info->msg_index;
   key.len = sizeof(msg_info->msg_index);
   r = chash_get(folder->fl_msgs_hash, &key, &data);
   if (r < 0)
     return MAIL_ERROR_INVAL;
   
   mh_msg_info = data.data;
 
-  snprintf(static_uid, PATH_MAX, "%u-%lu-%u", msg_info->msg_index,
-	   mh_msg_info->msg_mtime, mh_msg_info->msg_size);
+  snprintf(static_uid, PATH_MAX, "%u-%lu-%lu", msg_info->msg_index,
+	   mh_msg_info->msg_mtime, (unsigned long) mh_msg_info->msg_size);
   uid = strdup(static_uid);
   if (uid == NULL)
     return MAIL_ERROR_MEMORY;
 
   r = mailmessage_generic_initialize(msg_info);
   if (r != MAIL_NO_ERROR) {
     free(uid);
     return r;
   }
 
   msg = msg_info->msg_data;
   msg->msg_prefetch = mh_prefetch;
   msg->msg_prefetch_free = mh_prefetch_free;
   msg_info->msg_uid = uid;
 
   return MAIL_NO_ERROR;
 }
 
 static void mh_uninitialize(mailmessage * msg_info)
 {
   mailmessage_generic_uninitialize(msg_info);
 }
 
 
diff --git a/kmicromail/libetpan/generic/mhdriver_message.c b/kmicromail/libetpan/generic/mhdriver_message.c
index 2c023e7..aafd2d9 100644
--- a/kmicromail/libetpan/generic/mhdriver_message.c
+++ b/kmicromail/libetpan/generic/mhdriver_message.c
@@ -123,50 +123,51 @@ static inline struct mh_session_state_data * get_data(mailmessage * msg)
 
 static inline struct mailmh_folder * get_mh_cur_folder(mailmessage * msg)
 {
   return get_data(msg)->mh_cur_folder;
 }
 
 static int mh_initialize(mailmessage * msg_info)
 {
   struct generic_message_t * msg;
   int r;
   char * uid;
   char static_uid[PATH_MAX];
   struct mailmh_msg_info * mh_msg_info;
   chashdatum key;
   chashdatum value;
   
   key.data = &msg_info->msg_index;
   key.len = sizeof(msg_info->msg_index);
   r = chash_get(get_mh_cur_folder(msg_info)->fl_msgs_hash, &key, &value);
   if (r < 0)
     return MAIL_ERROR_INVAL;
   
   mh_msg_info = value.data;
   
-  snprintf(static_uid, PATH_MAX, "%u-%lu-%u", msg_info->msg_index,
-	   mh_msg_info->msg_mtime, mh_msg_info->msg_size);
+  snprintf(static_uid, PATH_MAX, "%u-%lu-%lu", msg_info->msg_index,
+	   (unsigned long) mh_msg_info->msg_mtime,
+      (unsigned long) mh_msg_info->msg_size);
   uid = strdup(static_uid);
   if (uid == NULL)
     return MAIL_ERROR_MEMORY;
 
   r = mailmessage_generic_initialize(msg_info);
   if (r != MAIL_NO_ERROR) {
     free(uid);
     return r;
   }
 
   msg = msg_info->msg_data;
   msg->msg_prefetch = mh_prefetch;
   msg->msg_prefetch_free = mh_prefetch_free;
   msg_info->msg_uid = uid;
 
   return MAIL_NO_ERROR;
 }
 
      
 static int mh_fetch_size(mailmessage * msg_info,
 			 size_t * result)
 {
   int r;
   size_t size;
diff --git a/kmicromail/libetpan/generic/mhdriver_tools.c b/kmicromail/libetpan/generic/mhdriver_tools.c
index cb863fa..c15bb6d 100644
--- a/kmicromail/libetpan/generic/mhdriver_tools.c
+++ b/kmicromail/libetpan/generic/mhdriver_tools.c
@@ -348,50 +348,51 @@ mhdriver_get_cached_flags(struct mail_cache_db * cache_db,
     struct mail_flags ** result)
 {
   int r;
   char keyname[PATH_MAX];
   struct mail_flags * flags;
   int res;
   struct mailmh_msg_info * msg_info;
   chashdatum key;
   chashdatum data;
   struct mailmh_folder * folder;
   
   folder = cached_get_mh_cur_folder(session);
 #if 0
   msg_info = cinthash_find(mh_data->cur_folder->fl_msgs_hash, num);
   if (msg_info == NULL)
     return MAIL_ERROR_CACHE_MISS;
 #endif
   key.data = &num;
   key.len = sizeof(num);
   r = chash_get(folder->fl_msgs_hash, &key, &data);
   if (r < 0)
     return MAIL_ERROR_CACHE_MISS;
   msg_info = data.data;
   
-  snprintf(keyname, PATH_MAX, "%u-%u-%u-flags",
-	   num, (uint32_t) msg_info->msg_mtime, msg_info->msg_size);
+  snprintf(keyname, PATH_MAX, "%u-%lu-%lu-flags",
+	   num, (unsigned long) msg_info->msg_mtime,
+      (unsigned long) msg_info->msg_size);
 
   r = generic_cache_flags_read(cache_db, mmapstr, keyname, &flags);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   * result = flags;
 
   return MAIL_NO_ERROR;
 
  err:
   return res;
 }
 
 int
 mhdriver_write_cached_flags(struct mail_cache_db * cache_db,
     MMAPString * mmapstr,
     char * uid,
     struct mail_flags * flags)
 {
   int r;
   char keyname[PATH_MAX];
   int res;
diff --git a/kmicromail/libetpan/generic/mhstorage.c b/kmicromail/libetpan/generic/mhstorage.c
index 32fc26b..715b961 100644
--- a/kmicromail/libetpan/generic/mhstorage.c
+++ b/kmicromail/libetpan/generic/mhstorage.c
@@ -41,49 +41,49 @@
 
 #include <stdlib.h>
 #include <string.h>
 
 /* mh storage */
 
 static int mh_mailstorage_connect(struct mailstorage * storage);
 static int mh_mailstorage_get_folder_session(struct mailstorage * storage,
     char * pathname, mailsession ** result);
 static void mh_mailstorage_uninitialize(struct mailstorage * storage);
 
 static mailstorage_driver mh_mailstorage_driver = {
   .sto_name               = "mh",
   .sto_connect            = mh_mailstorage_connect,
   .sto_get_folder_session = mh_mailstorage_get_folder_session,
   .sto_uninitialize       = mh_mailstorage_uninitialize,
 };
 
 int mh_mailstorage_init(struct mailstorage * storage,
     char * mh_pathname, int mh_cached,
     char * mh_cache_directory, char * mh_flags_directory)
 {
   struct mh_mailstorage * mh_storage;
 
-  mh_storage = malloc(sizeof(struct mh_mailstorage));
+  mh_storage = malloc(sizeof(* mh_storage));
   if (mh_storage == NULL)
     goto err;
 
   mh_storage->mh_pathname = strdup(mh_pathname);
   if (mh_storage->mh_pathname == NULL)
     goto free;
 
   mh_storage->mh_cached = mh_cached;
 
   if (mh_cached && (mh_cache_directory != NULL) &&
       (mh_flags_directory != NULL)) {
     mh_storage->mh_cache_directory = strdup(mh_cache_directory);
     if (mh_storage->mh_cache_directory == NULL)
       goto free_pathname;
     mh_storage->mh_flags_directory = strdup(mh_flags_directory);
     if (mh_storage->mh_flags_directory == NULL)
       goto free_cache_directory;
   }
   else {
     mh_storage->mh_cached = FALSE;
     mh_storage->mh_cache_directory = NULL;
     mh_storage->mh_flags_directory = NULL;
   }
 
diff --git a/kmicromail/libetpan/generic/nntpdriver.c b/kmicromail/libetpan/generic/nntpdriver.c
index fde5f1a..1b65838 100644
--- a/kmicromail/libetpan/generic/nntpdriver.c
+++ b/kmicromail/libetpan/generic/nntpdriver.c
@@ -48,48 +48,51 @@ static int nntpdriver_initialize(mailsession * session);
 
 static void nntpdriver_uninitialize(mailsession * session);
 
 static int nntpdriver_parameters(mailsession * session,
 				 int id, void * value);
 
 static int nntpdriver_connect_stream(mailsession * session, mailstream * s);
 
 static int nntpdriver_login(mailsession * session,
 			    char * userid, char * password);
 
 static int nntpdriver_logout(mailsession * session);
 
 static int nntpdriver_status_folder(mailsession * session, char * mb,
     uint32_t * result_messages,
     uint32_t * result_recent,
     uint32_t * result_unseen);
 
 static int nntpdriver_messages_number(mailsession * session, char * mb,
 				      uint32_t * result);
 
 static int nntpdriver_append_message(mailsession * session,
 				     char * message, size_t size);
 
+static int nntpdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 static int
 nntpdriver_get_envelopes_list(mailsession * session,
 			      struct mailmessage_list * env_list);
 
 
 static int nntpdriver_get_messages_list(mailsession * session,
 					struct mailmessage_list ** result);
 
 static int nntpdriver_list_folders(mailsession * session, char * mb,
 				   struct mail_list ** result);
 
 static int nntpdriver_lsub_folders(mailsession * session, char * mb,
 				   struct mail_list ** result);
 
 static int nntpdriver_subscribe_folder(mailsession * session, char * mb);
 
 static int nntpdriver_unsubscribe_folder(mailsession * session, char * mb);
 
 static int nntpdriver_get_message(mailsession * session,
 				  uint32_t num, mailmessage ** result);
 
 static int nntpdriver_get_message_by_uid(mailsession * session,
     const char * uid,
     mailmessage ** result);
@@ -108,48 +111,49 @@ static mailsession_driver local_nntp_session_driver = {
   .sess_connect_path = NULL,
   .sess_starttls = NULL,
   .sess_login = nntpdriver_login,
   .sess_logout = nntpdriver_logout,
   .sess_noop = nntpdriver_noop,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = NULL,
   .sess_examine_folder = NULL,
   .sess_select_folder = nntpdriver_select_folder,
   .sess_expunge_folder = NULL,
   .sess_status_folder = nntpdriver_status_folder,
   .sess_messages_number = nntpdriver_messages_number,
   .sess_recent_number = nntpdriver_messages_number,
   .sess_unseen_number = nntpdriver_messages_number,
   .sess_list_folders = nntpdriver_list_folders,
   .sess_lsub_folders = nntpdriver_lsub_folders,
   .sess_subscribe_folder = nntpdriver_subscribe_folder,
   .sess_unsubscribe_folder = nntpdriver_unsubscribe_folder,
 
   .sess_append_message = nntpdriver_append_message,
+  .sess_append_message_flags = nntpdriver_append_message_flags,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = nntpdriver_get_messages_list,
   .sess_get_envelopes_list = nntpdriver_get_envelopes_list,
   .sess_remove_message = NULL,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = nntpdriver_get_message,
   .sess_get_message_by_uid = nntpdriver_get_message_by_uid,
 };
 
 
 mailsession_driver * nntp_session_driver = &local_nntp_session_driver;
 
 static inline struct nntp_session_state_data *
 get_data(mailsession * session)
 {
   return session->sess_data;
 }
 
 static inline newsnntp * get_nntp_session(mailsession * session)
@@ -609,48 +613,54 @@ static int nntpdriver_append_message(mailsession * session,
   data = get_data(session);
 
   do {
     r = newsnntp_post(get_nntp_session(session), message, size);
     switch (r) {
     case NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_USERNAME:
       r = nntpdriver_authenticate_user(session);
       if (r != MAIL_NO_ERROR)
 	return r;
       break;
       
     case NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD:
       r = nntpdriver_authenticate_password(session);
       if (r != MAIL_NO_ERROR)
 	return r;
       break;
 
     default:
       return nntpdriver_nntp_error_to_mail_error(r);
     }
   }
   while (1);
 }
 
+static int nntpdriver_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  return nntpdriver_append_message(session, message, size);
+}
+
 
 static int xover_resp_to_fields(struct newsnntp_xover_resp_item * item,
 				struct mailimf_fields ** result);
 
 
 static int
 nntpdriver_get_envelopes_list(mailsession * session,
 			      struct mailmessage_list * env_list)
 {
   newsnntp * nntp;
   int r;
   struct nntp_session_state_data * data;
   clist * list;
   int done;
   clistiter * cur;
   uint32_t first_seq;
   unsigned int i;
 
   nntp = get_nntp_session(session);
 
   data = get_data(session);
 
   if (data->nntp_group_info == NULL)
     return MAIL_ERROR_BAD_STATE;
diff --git a/kmicromail/libetpan/generic/nntpdriver_cached.c b/kmicromail/libetpan/generic/nntpdriver_cached.c
index 1f8a8af..0343a65 100644
--- a/kmicromail/libetpan/generic/nntpdriver_cached.c
+++ b/kmicromail/libetpan/generic/nntpdriver_cached.c
@@ -75,48 +75,51 @@ static int nntpdriver_cached_login(mailsession * session,
 static int nntpdriver_cached_logout(mailsession * session);
 
 static int nntpdriver_cached_check_folder(mailsession * session);
 
 static int nntpdriver_cached_select_folder(mailsession * session, char * mb);
 
 static int nntpdriver_cached_status_folder(mailsession * session,
 					   char * mb,
 					   uint32_t * result_messages,
 					   uint32_t * result_recent,
 					   uint32_t * result_unseen);
 
 static int nntpdriver_cached_messages_number(mailsession * session, char * mb,
 					     uint32_t * result);
 
 static int nntpdriver_cached_recent_number(mailsession * session, char * mb,
 					   uint32_t * result);
 
 static int nntpdriver_cached_unseen_number(mailsession * session, char * mb,
 					   uint32_t * result);
 
 static int nntpdriver_cached_append_message(mailsession * session,
 					    char * message, size_t size);
 
+static int nntpdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags);
+
 static int
 nntpdriver_cached_get_envelopes_list(mailsession * session,
 				     struct mailmessage_list * env_list);
 
 
 static int
 nntpdriver_cached_get_messages_list(mailsession * session,
 				    struct mailmessage_list ** result);
 
 static int nntpdriver_cached_list_folders(mailsession * session, char * mb,
 					  struct mail_list ** result);
 
 static int nntpdriver_cached_lsub_folders(mailsession * session, char * mb,
 					  struct mail_list ** result);
 
 static int nntpdriver_cached_subscribe_folder(mailsession * session,
 					      char * mb);
 
 static int nntpdriver_cached_unsubscribe_folder(mailsession * session,
 						char * mb);
 
 static int nntpdriver_cached_get_message(mailsession * session,
 					 uint32_t num, mailmessage ** result);
 
@@ -138,48 +141,49 @@ static mailsession_driver local_nntp_cached_session_driver = {
   .sess_connect_path = NULL,
   .sess_starttls = NULL,
   .sess_login = nntpdriver_cached_login,
   .sess_logout = nntpdriver_cached_logout,
   .sess_noop = nntpdriver_cached_noop,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = nntpdriver_cached_check_folder,
   .sess_examine_folder = NULL,
   .sess_select_folder = nntpdriver_cached_select_folder,
   .sess_expunge_folder = NULL,
   .sess_status_folder = nntpdriver_cached_status_folder,
   .sess_messages_number = nntpdriver_cached_messages_number,
   .sess_recent_number = nntpdriver_cached_recent_number,
   .sess_unseen_number = nntpdriver_cached_unseen_number,
   .sess_list_folders = nntpdriver_cached_list_folders,
   .sess_lsub_folders = nntpdriver_cached_lsub_folders,
   .sess_subscribe_folder = nntpdriver_cached_subscribe_folder,
   .sess_unsubscribe_folder = nntpdriver_cached_unsubscribe_folder,
 
   .sess_append_message = nntpdriver_cached_append_message,
+  .sess_append_message_flags = nntpdriver_cached_append_message_flags,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = nntpdriver_cached_get_messages_list,
   .sess_get_envelopes_list = nntpdriver_cached_get_envelopes_list,
   .sess_remove_message = NULL,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = nntpdriver_cached_get_message,
   .sess_get_message_by_uid = nntpdriver_cached_get_message_by_uid,
 };
 
 
 mailsession_driver * nntp_cached_session_driver =
 &local_nntp_cached_session_driver;
 
 #define ENV_NAME "env.db"
 #define FLAGS_NAME "flags.db"
 
 
 
 static void read_article_seq(mailsession * session,
@@ -610,48 +614,54 @@ static int nntpdriver_cached_lsub_folders(mailsession * session, char * mb,
 }
 
 static int nntpdriver_cached_subscribe_folder(mailsession * session,
 					      char * mb)
 {
   return mailsession_subscribe_folder(get_ancestor(session), mb);
 }
 
 static int nntpdriver_cached_unsubscribe_folder(mailsession * session,
 						char * mb)
 {
   return mailsession_unsubscribe_folder(get_ancestor(session), mb);
 }
 
 
 
 /* messages operations */
 
 static int nntpdriver_cached_append_message(mailsession * session,
 					    char * message, size_t size)
 {
   return mailsession_append_message(get_ancestor(session), message, size);
 }
 
+static int nntpdriver_cached_append_message_flags(mailsession * session,
+    char * message, size_t size, struct mail_flags * flags)
+{
+  return nntpdriver_cached_append_message(session, message, size);
+}
+
 
 
 static int
 get_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
     mailsession * session, uint32_t num,
     struct mailimf_fields ** result)
 {
   char keyname[PATH_MAX];
   int r;
   struct mailimf_fields * fields;
   int res;
 
   snprintf(keyname, PATH_MAX, "%i-envelope", num);
 
   r = generic_cache_fields_read(cache_db, mmapstr, keyname, &fields);
   if (r != MAIL_NO_ERROR) {
     res = r;
     goto err;
   }
 
   * result = fields;
 
   return MAIL_NO_ERROR;
 
diff --git a/kmicromail/libetpan/generic/nntpstorage.c b/kmicromail/libetpan/generic/nntpstorage.c
index 5ba333b..89974cd 100644
--- a/kmicromail/libetpan/generic/nntpstorage.c
+++ b/kmicromail/libetpan/generic/nntpstorage.c
@@ -50,49 +50,49 @@
 #define NNTPS_DEFAULT_PORT 563
 
 static int nntp_mailstorage_connect(struct mailstorage * storage);
 static int nntp_mailstorage_get_folder_session(struct mailstorage * storage,
     char * pathname, mailsession ** result);
 static void nntp_mailstorage_uninitialize(struct mailstorage * storage);
 
 static mailstorage_driver nntp_mailstorage_driver = {
   .sto_name               = "nntp",
   .sto_connect            = nntp_mailstorage_connect,
   .sto_get_folder_session = nntp_mailstorage_get_folder_session,
   .sto_uninitialize       = nntp_mailstorage_uninitialize,
 };
 
 int nntp_mailstorage_init(struct mailstorage * storage,
     char * nn_servername, uint16_t nn_port,
     char * nn_command,
     int nn_connection_type, int nn_auth_type,
     char * nn_login, char * nn_password,
     int nn_cached, char * nn_cache_directory, char * nn_flags_directory)
 {
   struct nntp_mailstorage * nntp_storage;
   int res;
   
-  nntp_storage = malloc(sizeof(struct nntp_mailstorage));
+  nntp_storage = malloc(sizeof(* nntp_storage));
   if (nntp_storage == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto err;
   }
 
   nntp_storage->nntp_servername = strdup(nn_servername);
   if (nntp_storage->nntp_servername == NULL) {
     res = MAIL_ERROR_MEMORY;
     goto free;
   }
 
   nntp_storage->nntp_connection_type = nn_connection_type;
   
   if (nn_port == 0) {
     switch (nn_connection_type) {
     case CONNECTION_TYPE_PLAIN:
     case CONNECTION_TYPE_COMMAND:
       nn_port = NNTP_DEFAULT_PORT;
       break;
 
     case CONNECTION_TYPE_TLS:
     case CONNECTION_TYPE_COMMAND_TLS:
       nn_port = NNTPS_DEFAULT_PORT;
       break;
diff --git a/kmicromail/libetpan/generic/pop3driver.c b/kmicromail/libetpan/generic/pop3driver.c
index 20b0fc2..375879e 100644
--- a/kmicromail/libetpan/generic/pop3driver.c
+++ b/kmicromail/libetpan/generic/pop3driver.c
@@ -88,48 +88,49 @@ static mailsession_driver local_pop3_session_driver = {
   .sess_connect_path = NULL,
   .sess_starttls = pop3driver_starttls,
   .sess_login = pop3driver_login,
   .sess_logout = pop3driver_logout,
   .sess_noop = pop3driver_noop,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = NULL,
   .sess_examine_folder = NULL,
   .sess_select_folder = NULL,
   .sess_expunge_folder = NULL,
   .sess_status_folder = pop3driver_status_folder,
   .sess_messages_number = pop3driver_messages_number,
   .sess_recent_number = pop3driver_messages_number,
   .sess_unseen_number = pop3driver_messages_number,
   .sess_list_folders = NULL,
   .sess_lsub_folders = NULL,
   .sess_subscribe_folder = NULL,
   .sess_unsubscribe_folder = NULL,
 
   .sess_append_message = NULL,
+  .sess_append_message_flags = NULL,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = pop3driver_get_messages_list,
   .sess_get_envelopes_list = maildriver_generic_get_envelopes_list,
   .sess_remove_message = pop3driver_remove_message,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = pop3driver_get_message,
   .sess_get_message_by_uid = NULL,
 };
 
 mailsession_driver * pop3_session_driver = &local_pop3_session_driver;
 
 static inline struct pop3_session_state_data *
 get_data(mailsession * session)
 {
   return session->sess_data;
 }
 
 static mailpop3 * get_pop3_session(mailsession * session)
 {
diff --git a/kmicromail/libetpan/generic/pop3driver_cached.c b/kmicromail/libetpan/generic/pop3driver_cached.c
index 6f97303..24f624b 100644
--- a/kmicromail/libetpan/generic/pop3driver_cached.c
+++ b/kmicromail/libetpan/generic/pop3driver_cached.c
@@ -89,93 +89,97 @@ static int pop3driver_cached_messages_number(mailsession * session,
     uint32_t * result);
 
 static int pop3driver_cached_recent_number(mailsession * session,
     char * mb,
     uint32_t * result);
 
 static int pop3driver_cached_unseen_number(mailsession * session,
     char * mb,
     uint32_t * result);
 
 static int pop3driver_cached_remove_message(mailsession * session,
     uint32_t num);
 
 static int
 pop3driver_cached_get_messages_list(mailsession * session,
     struct mailmessage_list ** result);
 
 static int
 pop3driver_cached_get_envelopes_list(mailsession * session,
     struct mailmessage_list * env_list);
 
 static int pop3driver_cached_get_message(mailsession * session,
     uint32_t num, mailmessage ** result);
 
+static int pop3driver_cached_get_message_by_uid(mailsession * session,
+    const char * uid, mailmessage ** result);
+
 static mailsession_driver local_pop3_cached_session_driver = {
   .sess_name = "pop3-cached",
 
   .sess_initialize = pop3driver_cached_initialize,
   .sess_uninitialize = pop3driver_cached_uninitialize,
 
   .sess_parameters = pop3driver_cached_parameters,
 
   .sess_connect_stream = pop3driver_cached_connect_stream,
   .sess_connect_path = NULL,
   .sess_starttls = pop3driver_cached_starttls,
   .sess_login = pop3driver_cached_login,
   .sess_logout = pop3driver_cached_logout,
   .sess_noop = pop3driver_cached_noop,
 
   .sess_build_folder_name = NULL,
   .sess_create_folder = NULL,
   .sess_delete_folder = NULL,
   .sess_rename_folder = NULL,
   .sess_check_folder = pop3driver_cached_check_folder,
   .sess_examine_folder = NULL,
   .sess_select_folder = NULL,
   .sess_expunge_folder = pop3driver_cached_expunge_folder,
   .sess_status_folder = pop3driver_cached_status_folder,
   .sess_messages_number = pop3driver_cached_messages_number,
   .sess_recent_number = pop3driver_cached_recent_number,
   .sess_unseen_number = pop3driver_cached_unseen_number,
   .sess_list_folders = NULL,
   .sess_lsub_folders = NULL,
   .sess_subscribe_folder = NULL,
   .sess_unsubscribe_folder = NULL,
 
   .sess_append_message = NULL,
+  .sess_append_message_flags = NULL,
   .sess_copy_message = NULL,
   .sess_move_message = NULL,
 
   .sess_get_messages_list = pop3driver_cached_get_messages_list,
   .sess_get_envelopes_list = pop3driver_cached_get_envelopes_list,
   .sess_remove_message = pop3driver_cached_remove_message,
 #if 0
   .sess_search_messages = maildriver_generic_search_messages,
 #endif
 
   .sess_get_message = pop3driver_cached_get_message,
-  .sess_get_message_by_uid = NULL,
+  .sess_get_message_by_uid = pop3driver_cached_get_message_by_uid,
 };
 
 mailsession_driver * pop3_cached_session_driver =
 &local_pop3_cached_session_driver;
 
 #define ENV_NAME "env.db"
 #define FLAGS_NAME "flags.db"
 
 
 static inline struct pop3_cached_session_state_data *
 get_cached_data(mailsession * session)
 {
   return session->sess_data;
 }
 
 static inline mailsession * get_ancestor(mailsession * session)
 {
   return get_cached_data(session)->pop3_ancestor;
 }
 
 static inline struct pop3_session_state_data *
 get_ancestor_data(mailsession * session)
 {
   return get_ancestor(session)->sess_data;
@@ -834,24 +838,62 @@ pop3driver_cached_get_envelopes_list(mailsession * session,
  err:
   return res;
 }
 
 static int pop3driver_cached_get_message(mailsession * session,
     uint32_t num, mailmessage ** result)
 {
   mailmessage * msg_info;
   int r;
 
   msg_info = mailmessage_new();
   if (msg_info == NULL)
     return MAIL_ERROR_MEMORY;
 
   r = mailmessage_init(msg_info, session, pop3_cached_message_driver, num, 0);
   if (r != MAIL_NO_ERROR) {
     mailmessage_free(msg_info);
     return r;
   }
 
   * result = msg_info;
 
   return MAIL_NO_ERROR;
 }
+
+static int pop3driver_cached_get_message_by_uid(mailsession * session,
+				  const char * uid, mailmessage ** result)
+{
+  mailpop3 * pop3;
+  struct mailpop3_msg_info * msg_info;
+  int found;
+  unsigned int i;
+  
+  if (uid == NULL)
+    return MAIL_ERROR_INVAL;
+  
+  pop3 = get_pop3_session(session);
+  
+  found = 0;
+  
+  /* iterate all messages and look for uid */
+  for(i = 0 ; i < carray_count(pop3->pop3_msg_tab) ; i++) {
+    msg_info = carray_get(pop3->pop3_msg_tab, i);
+    
+    if (msg_info == NULL)
+      continue;
+    
+    if (msg_info->msg_deleted)
+      continue;
+    
+    /* uid found, stop looking */
+    if (strcmp(msg_info->msg_uidl, uid) == 0) {
+      found = 1;
+      break;
+    }
+  }
+  
+  if (!found)
+    return MAIL_ERROR_MSG_NOT_FOUND;
+  
+  return pop3driver_cached_get_message(session, msg_info->msg_index, result);
+}
diff --git a/kmicromail/libetpan/generic/pop3driver_message.c b/kmicromail/libetpan/generic/pop3driver_message.c
index 77bd94c..357bb2e 100644
--- a/kmicromail/libetpan/generic/pop3driver_message.c
+++ b/kmicromail/libetpan/generic/pop3driver_message.c
@@ -18,130 +18,164 @@
  *
  * 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 "pop3driver_message.h"
 
 #include "mailmessage_tools.h"
 #include "pop3driver_tools.h"
 #include "pop3driver.h"
 #include "mailpop3.h"
+#include <stdlib.h>
+#include <string.h>
 
 static int pop3_prefetch(mailmessage * msg_info);
 
 static void pop3_prefetch_free(struct generic_message_t * msg);
 
 static int pop3_initialize(mailmessage * msg_info);
 
 static int pop3_fetch_header(mailmessage * msg_info,
 			     char ** result,
 			     size_t * result_len);
 
 static int pop3_fetch_size(mailmessage * msg_info,
 			   size_t * result);
 
 static mailmessage_driver local_pop3_message_driver = {
   .msg_name = "pop3",
 
   .msg_initialize = pop3_initialize,
   .msg_uninitialize = mailmessage_generic_uninitialize,
 
   .msg_flush = mailmessage_generic_flush,
   .msg_check = NULL,
 
   .msg_fetch_result_free = mailmessage_generic_fetch_result_free,
 
   .msg_fetch = mailmessage_generic_fetch,
   .msg_fetch_header = pop3_fetch_header,
   .msg_fetch_body = mailmessage_generic_fetch_body,
   .msg_fetch_size = pop3_fetch_size,
   .msg_get_bodystructure = mailmessage_generic_get_bodystructure,
   .msg_fetch_section = mailmessage_generic_fetch_section,
   .msg_fetch_section_header = mailmessage_generic_fetch_section_header,
   .msg_fetch_section_mime = mailmessage_generic_fetch_section_mime,
   .msg_fetch_section_body = mailmessage_generic_fetch_section_body,
   .msg_fetch_envelope = mailmessage_generic_fetch_envelope,
 
   .msg_get_flags = NULL,
 };
 
 mailmessage_driver * pop3_message_driver = &local_pop3_message_driver;
 
+static inline struct pop3_session_state_data *
+get_data(mailsession * session)
+{
+  return session->sess_data;
+}
+
+
+static mailpop3 * get_pop3_session(mailsession * session)
+{
+  return get_data(session)->pop3_session;
+}
+
 
 static int pop3_prefetch(mailmessage * msg_info)
 {
   char * msg_content;
   size_t msg_length;
   struct generic_message_t * msg;
   int r;
 
   r = pop3driver_retr(msg_info->msg_session, msg_info->msg_index,
 		      &msg_content, &msg_length);
   if (r != MAIL_NO_ERROR)
     return r;
 
   msg = msg_info->msg_data;
 
   msg->msg_message = msg_content;
   msg->msg_length = msg_length;
 
   return MAIL_NO_ERROR;
 }
 
 static void pop3_prefetch_free(struct generic_message_t * msg)
 {
   if (msg->msg_message != NULL) {
     mmap_string_unref(msg->msg_message);
     msg->msg_message = NULL;
   }
 }
 
 static int pop3_initialize(mailmessage * msg_info)
 {
   struct generic_message_t * msg;
   int r;
+  char * uid;
+  struct mailpop3_msg_info * info;
+  mailpop3 * pop3;
+
+  pop3 = get_pop3_session(msg_info->msg_session);
+  
+  r = mailpop3_get_msg_info(pop3, msg_info->msg_index, &info);
+  switch (r) {
+  case MAILPOP3_NO_ERROR:
+    break;
+  default:
+    return pop3driver_pop3_error_to_mail_error(r);
+  }
+
+  uid = strdup(info->msg_uidl);
+  if (uid == NULL)
+    return MAIL_ERROR_MEMORY;
   
   r = mailmessage_generic_initialize(msg_info);
-  if (r != MAIL_NO_ERROR)
+  if (r != MAIL_NO_ERROR) {
+    free(uid);
     return r;
+  }
 
   msg = msg_info->msg_data;
   msg->msg_prefetch = pop3_prefetch;
   msg->msg_prefetch_free = pop3_prefetch_free;
+  msg_info->msg_uid = uid;
 
   return MAIL_NO_ERROR;
 }
 
      
 static int pop3_fetch_header(mailmessage * msg_info,
 			     char ** result,
 			     size_t * result_len)
 {
   struct generic_message_t * msg;
   char * headers;
   size_t headers_length;
   int r;
   
   msg = msg_info->msg_data;
 
   if (msg->msg_message != NULL)
     return mailmessage_generic_fetch_header(msg_info,
         result, result_len);
   
   r = pop3driver_header(msg_info->msg_session, msg_info->msg_index,
 			&headers, &headers_length);
   if (r != MAIL_NO_ERROR)
     return r;
diff --git a/kmicromail/libetpan/generic/pop3storage.c b/kmicromail/libetpan/generic/pop3storage.c
index 8e7a94e..375aeaf 100644
--- a/kmicromail/libetpan/generic/pop3storage.c
+++ b/kmicromail/libetpan/generic/pop3storage.c
@@ -47,49 +47,49 @@
 #define POP3_DEFAULT_PORT  110
 #define POP3S_DEFAULT_PORT 995
 
 static int pop3_mailstorage_connect(struct mailstorage * storage);
 static int pop3_mailstorage_get_folder_session(struct mailstorage * storage,
     char * pathname, mailsession ** result);
 static void pop3_mailstorage_uninitialize(struct mailstorage * storage);
 
 static mailstorage_driver pop3_mailstorage_driver = {
   .sto_name               = "pop3",
   .sto_connect            = pop3_mailstorage_connect,
   .sto_get_folder_session = pop3_mailstorage_get_folder_session,
   .sto_uninitialize       = pop3_mailstorage_uninitialize,
 };
 
 int pop3_mailstorage_init(struct mailstorage * storage,
     char * pop3_servername, uint16_t pop3_port,
     char * pop3_command,
     int pop3_connection_type, int pop3_auth_type,
     char * pop3_login, char * pop3_password,
     int pop3_cached, char * pop3_cache_directory, char * pop3_flags_directory)
 {
   struct pop3_mailstorage * pop3_storage;
 
-  pop3_storage = malloc(sizeof(struct pop3_mailstorage));
+  pop3_storage = malloc(sizeof(* pop3_storage));
   if (pop3_storage == NULL)
     goto err;
   
   pop3_storage->pop3_servername = strdup(pop3_servername);
   if (pop3_storage->pop3_servername == NULL)
     goto free;
 
   pop3_storage->pop3_connection_type = pop3_connection_type;
   
   if (pop3_port == 0) {
     switch (pop3_connection_type) {
     case CONNECTION_TYPE_PLAIN:
     case CONNECTION_TYPE_TRY_STARTTLS:
     case CONNECTION_TYPE_STARTTLS:
     case CONNECTION_TYPE_COMMAND:
     case CONNECTION_TYPE_COMMAND_TRY_STARTTLS:
     case CONNECTION_TYPE_COMMAND_STARTTLS:
       pop3_port = POP3_DEFAULT_PORT;
       break;
 
     case CONNECTION_TYPE_TLS:
     case CONNECTION_TYPE_COMMAND_TLS:
       pop3_port = POP3S_DEFAULT_PORT;
       break;