1 files changed, 1 insertions, 1 deletions

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
@@ -119,193 +119,193 @@ static mailmessage_driver local_imap_cached_message_driver = {
   .msg_get_bodystructure = imap_get_bodystructure,
   .msg_fetch_section = imap_fetch_section,
   .msg_fetch_section_header = imap_fetch_section_header,
   .msg_fetch_section_mime = imap_fetch_section_mime,
   .msg_fetch_section_body = imap_fetch_section_body,
   .msg_fetch_envelope = imap_fetch_envelope,
 
   .msg_get_flags = imap_get_flags,
 };
 
 mailmessage_driver * imap_cached_message_driver =
 &local_imap_cached_message_driver;
 
 static inline struct imap_cached_session_state_data *
 get_cached_session_data(mailmessage * msg)
 {
   return msg->msg_session->sess_data;
 }
 
 static inline mailmessage * get_ancestor(mailmessage * msg_info)
 {
   return msg_info->msg_data;
 }
 
 static inline struct imap_cached_session_state_data *
 cached_session_get_data(mailsession * s)
 {
   return s->sess_data;
 }
 
 static inline mailsession * cached_session_get_ancestor(mailsession * s)
 {
   return cached_session_get_data(s)->imap_ancestor;
 }
 
 static inline struct imap_session_state_data *
 cached_session_get_ancestor_data(mailsession * s)
 {
   return cached_session_get_ancestor(s)->sess_data;
 }
 
 static inline mailimap *
 cached_session_get_imap_session(mailsession * session)
 {
   return cached_session_get_ancestor_data(session)->imap_session;
 }
 
 static inline mailimap * get_imap_session(mailmessage * msg)
 {
   return cached_session_get_imap_session(msg->msg_session);
 }
 
 static inline mailsession * get_ancestor_session(mailmessage * msg_info)
 {
   return cached_session_get_ancestor(msg_info->msg_session);
 }
 
 
 static void generate_key_from_mime_section(char * key, size_t size,
 					   struct mailmime * mime)
 {
   clistiter * cur;
   MMAPString * gstr;
   struct mailmime_section * part;
   int r;
 
   snprintf(key, size, "unvalid");
 
   r = mailmime_get_section_id(mime, &part);
   if (r != MAILIMF_NO_ERROR)
     goto err;
 
   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;
   }
 }
 
 static void generate_key_from_message(char * key, size_t size,
 				      mailmessage * msg_info,
 				      int type)
 {
   switch (type) {
   case MAILIMAP_MSG_ATT_RFC822:
     snprintf(key, size, "%s-rfc822", msg_info->msg_uid);
     break;
   case MAILIMAP_MSG_ATT_RFC822_HEADER:
     snprintf(key, size, "%s-rfc822-header", msg_info->msg_uid);
     break;
   case MAILIMAP_MSG_ATT_RFC822_TEXT:
     snprintf(key, size, "%s-rfc822-text", msg_info->msg_uid);
     break;
   case MAILIMAP_MSG_ATT_ENVELOPE:
     snprintf(key, size, "%s-envelope", msg_info->msg_uid);
     break;
   }
 }
 
 static void build_cache_name(char * filename, size_t size,
 			     mailmessage * msg, char * key)
 {
   char * quoted_mb;
 
   quoted_mb = get_cached_session_data(msg)->imap_quoted_mb;
 
   snprintf(filename, size, "%s/%s", quoted_mb, key);
 }
 
 static int imap_initialize(mailmessage * msg_info)
 {
   mailmessage * ancestor;
   int r;
   char key[PATH_MAX];
   char * uid;
   mailimap * imap;
 
   ancestor = mailmessage_new();
   if (ancestor == NULL)
     return MAIL_ERROR_MEMORY;
 
   r = mailmessage_init(ancestor, get_ancestor_session(msg_info),
 		       imap_message_driver,
 		       msg_info->msg_index, 0);
   if (r != MAIL_NO_ERROR) {
     mailmessage_free(ancestor);
     return r;
   }
 
   imap = get_imap_session(msg_info);
 
   snprintf(key, PATH_MAX, "%u-%u",
 	   imap->imap_selection_info->sel_uidvalidity, msg_info->msg_index);
   uid = strdup(key);
   if (uid == NULL) {
     mailmessage_free(ancestor);
     return MAIL_ERROR_MEMORY;
   }
   
   msg_info->msg_data = ancestor;
   msg_info->msg_uid = uid;
 
   return MAIL_NO_ERROR;
 }
   
 static void imap_uninitialize(mailmessage * msg_info)
 {
   mailmessage_free(get_ancestor(msg_info));
   msg_info->msg_data = NULL;