imap: more data tidying

diff --git a/imap/command.c b/imap/command.c
index d8361e86b14e8c1bb38177d211f13493cd349ebf..f4447fe033f21823775f5d304a8428516227e3ae 100644 (file)
--- a/imap/command.c
+++ b/imap/command.c
@@ -257,7 +257,7 @@ static void cmd_parse_expunge(struct ImapMboxData *mdata, const char *s)
      * It needs to resort using SORT_ORDER anyway, so setting to INT_MAX
      * makes the code simpler and possibly more efficient. */
     e->index = INT_MAX;
-    HEADER_DATA(e)->msn = 0;
+    IMAP_EDATA(e)->msn = 0;
   }
 
   /* decrement seqno of those above. */
@@ -265,7 +265,7 @@ static void cmd_parse_expunge(struct ImapMboxData *mdata, const char *s)
   {
     e = mdata->msn_index[cur];
     if (e)
-      HEADER_DATA(e)->msn--;
+      IMAP_EDATA(e)->msn--;
     mdata->msn_index[cur - 1] = e;
   }
 
@@ -321,13 +321,13 @@ static void cmd_parse_vanished(struct ImapMboxData *mdata, char *s)
     if (!e)
       continue;
 
-    unsigned int exp_msn = HEADER_DATA(e)->msn;
+    unsigned int exp_msn = IMAP_EDATA(e)->msn;
 
     /* imap_expunge_mailbox() will rewrite e->index.
      * It needs to resort using SORT_ORDER anyway, so setting to INT_MAX
      * makes the code simpler and possibly more efficient. */
     e->index = INT_MAX;
-    HEADER_DATA(e)->msn = 0;
+    IMAP_EDATA(e)->msn = 0;
 
     if ((exp_msn < 1) || (exp_msn > mdata->max_msn))
     {
@@ -349,7 +349,7 @@ static void cmd_parse_vanished(struct ImapMboxData *mdata, char *s)
       {
         e = mdata->msn_index[cur];
         if (e)
-          HEADER_DATA(e)->msn--;
+          IMAP_EDATA(e)->msn--;
         mdata->msn_index[cur - 1] = e;
       }
 
@@ -404,7 +404,7 @@ static void cmd_parse_fetch(struct ImapMboxData *mdata, char *s)
     return;
   }
 
-  mutt_debug(2, "Message UID %u updated\n", HEADER_DATA(e)->uid);
+  mutt_debug(2, "Message UID %u updated\n", IMAP_EDATA(e)->uid);
   /* skip FETCH */
   s = imap_next_word(s);
   s = imap_next_word(s);
@@ -453,7 +453,7 @@ static void cmd_parse_fetch(struct ImapMboxData *mdata, char *s)
         mutt_debug(1, "Illegal UID.  Skipping update.\n");
         return;
       }
-      if (uid != HEADER_DATA(e)->uid)
+      if (uid != IMAP_EDATA(e)->uid)
       {
         mutt_debug(1, "UID vs MSN mismatch.  Skipping update.\n");
         return;

diff --git a/imap/imap.c b/imap/imap.c
index 1f343221186f1e56204115d9eb656343b778215f..e6d02f55a6e72b2adb314dd7ac9a305f6de58c95 100644 (file)
--- a/imap/imap.c
+++ b/imap/imap.c
@@ -196,23 +196,23 @@ static int make_msg_set(struct ImapMboxData *mdata, struct Buffer *buf, int flag
       switch (flag)
       {
         case MUTT_DELETED:
-          if (emails[n]->deleted != HEADER_DATA(emails[n])->deleted)
+          if (emails[n]->deleted != IMAP_EDATA(emails[n])->deleted)
             match = invert ^ emails[n]->deleted;
           break;
         case MUTT_FLAG:
-          if (emails[n]->flagged != HEADER_DATA(emails[n])->flagged)
+          if (emails[n]->flagged != IMAP_EDATA(emails[n])->flagged)
             match = invert ^ emails[n]->flagged;
           break;
         case MUTT_OLD:
-          if (emails[n]->old != HEADER_DATA(emails[n])->old)
+          if (emails[n]->old != IMAP_EDATA(emails[n])->old)
             match = invert ^ emails[n]->old;
           break;
         case MUTT_READ:
-          if (emails[n]->read != HEADER_DATA(emails[n])->read)
+          if (emails[n]->read != IMAP_EDATA(emails[n])->read)
             match = invert ^ emails[n]->read;
           break;
         case MUTT_REPLIED:
-          if (emails[n]->replied != HEADER_DATA(emails[n])->replied)
+          if (emails[n]->replied != IMAP_EDATA(emails[n])->replied)
             match = invert ^ emails[n]->replied;
           break;
         case MUTT_TAG:
@@ -231,25 +231,25 @@ static int make_msg_set(struct ImapMboxData *mdata, struct Buffer *buf, int flag
       count++;
       if (setstart == 0)
       {
-        setstart = HEADER_DATA(emails[n])->uid;
+        setstart = IMAP_EDATA(emails[n])->uid;
         if (!started)
         {
-          mutt_buffer_printf(buf, "%u", HEADER_DATA(emails[n])->uid);
+          mutt_buffer_printf(buf, "%u", IMAP_EDATA(emails[n])->uid);
           started = true;
         }
         else
-          mutt_buffer_printf(buf, ",%u", HEADER_DATA(emails[n])->uid);
+          mutt_buffer_printf(buf, ",%u", IMAP_EDATA(emails[n])->uid);
       }
       /* tie up if the last message also matches */
       else if (n == mdata->ctx->mailbox->msg_count - 1)
-        mutt_buffer_printf(buf, ":%u", HEADER_DATA(emails[n])->uid);
+        mutt_buffer_printf(buf, ":%u", IMAP_EDATA(emails[n])->uid);
     }
     /* End current set if message doesn't match or we've reached the end
      * of the mailbox via inactive messages following the last match. */
     else if (setstart && (emails[n]->active || n == mdata->ctx->mailbox->msg_count - 1))
     {
-      if (HEADER_DATA(emails[n - 1])->uid > setstart)
-        mutt_buffer_printf(buf, ":%u", HEADER_DATA(emails[n - 1])->uid);
+      if (IMAP_EDATA(emails[n - 1])->uid > setstart)
+        mutt_buffer_printf(buf, ":%u", IMAP_EDATA(emails[n - 1])->uid);
       setstart = 0;
     }
   }
@@ -851,28 +851,28 @@ void imap_expunge_mailbox(struct ImapMboxData *mdata)
 
     if (e->index == INT_MAX)
     {
-      mutt_debug(2, "Expunging message UID %u.\n", HEADER_DATA(e)->uid);
+      mutt_debug(2, "Expunging message UID %u.\n", IMAP_EDATA(e)->uid);
 
       e->active = false;
       mdata->ctx->mailbox->size -= e->content->length;
 
       imap_cache_del(mdata, e);
 #ifdef USE_HCACHE
-      imap_hcache_del(mdata, HEADER_DATA(e)->uid);
+      imap_hcache_del(mdata, IMAP_EDATA(e)->uid);
 #endif
 
       /* free cached body from disk, if necessary */
-      cacheno = HEADER_DATA(e)->uid % IMAP_CACHE_LEN;
-      if (mdata->cache[cacheno].uid == HEADER_DATA(e)->uid &&
+      cacheno = IMAP_EDATA(e)->uid % IMAP_CACHE_LEN;
+      if (mdata->cache[cacheno].uid == IMAP_EDATA(e)->uid &&
           mdata->cache[cacheno].path)
       {
         unlink(mdata->cache[cacheno].path);
         FREE(&mdata->cache[cacheno].path);
       }
 
-      mutt_hash_int_delete(mdata->uid_hash, HEADER_DATA(e)->uid, e);
+      mutt_hash_int_delete(mdata->uid_hash, IMAP_EDATA(e)->uid, e);
 
-      imap_free_email_data((struct ImapEmailData **) &e->data);
+      imap_free_emaildata((void **) &e->data);
     }
     else
     {
@@ -1271,12 +1271,12 @@ int imap_sync_message_for_copy(struct ImapMboxData *mdata, struct Email *e,
 
   if (!compare_flags_for_copy(e))
   {
-    if (e->deleted == HEADER_DATA(e)->deleted)
+    if (e->deleted == IMAP_EDATA(e)->deleted)
       e->changed = false;
     return 0;
   }
 
-  snprintf(uid, sizeof(uid), "%u", HEADER_DATA(e)->uid);
+  snprintf(uid, sizeof(uid), "%u", IMAP_EDATA(e)->uid);
   cmd->dptr = cmd->data;
   mutt_buffer_addstr(cmd, "UID STORE ");
   mutt_buffer_addstr(cmd, uid);
@@ -1287,14 +1287,14 @@ int imap_sync_message_for_copy(struct ImapMboxData *mdata, struct Email *e,
   set_flag(mdata, MUTT_ACL_WRITE, e->old, "Old ", flags, sizeof(flags));
   set_flag(mdata, MUTT_ACL_WRITE, e->flagged, "\\Flagged ", flags, sizeof(flags));
   set_flag(mdata, MUTT_ACL_WRITE, e->replied, "\\Answered ", flags, sizeof(flags));
-  set_flag(mdata, MUTT_ACL_DELETE, HEADER_DATA(e)->deleted, "\\Deleted ", flags,
+  set_flag(mdata, MUTT_ACL_DELETE, IMAP_EDATA(e)->deleted, "\\Deleted ", flags,
            sizeof(flags));
 
   if (mutt_bit_isset(mdata->ctx->mailbox->rights, MUTT_ACL_WRITE))
   {
     /* restore system flags */
-    if (HEADER_DATA(e)->flags_system)
-      mutt_str_strcat(flags, sizeof(flags), HEADER_DATA(e)->flags_system);
+    if (IMAP_EDATA(e)->flags_system)
+      mutt_str_strcat(flags, sizeof(flags), IMAP_EDATA(e)->flags_system);
     /* set custom flags */
     tags = driver_tags_get_with_hidden(&e->tags);
     if (tags)
@@ -1314,13 +1314,13 @@ int imap_sync_message_for_copy(struct ImapMboxData *mdata, struct Email *e,
     set_flag(mdata, MUTT_ACL_WRITE, 1, "Old ", flags, sizeof(flags));
     set_flag(mdata, MUTT_ACL_WRITE, 1, "\\Flagged ", flags, sizeof(flags));
     set_flag(mdata, MUTT_ACL_WRITE, 1, "\\Answered ", flags, sizeof(flags));
-    set_flag(mdata, MUTT_ACL_DELETE, !HEADER_DATA(e)->deleted, "\\Deleted ",
+    set_flag(mdata, MUTT_ACL_DELETE, !IMAP_EDATA(e)->deleted, "\\Deleted ",
              flags, sizeof(flags));
 
     /* erase custom flags */
     if (mutt_bit_isset(mdata->ctx->mailbox->rights, MUTT_ACL_WRITE) &&
-        HEADER_DATA(e)->flags_remote)
-      mutt_str_strcat(flags, sizeof(flags), HEADER_DATA(e)->flags_remote);
+        IMAP_EDATA(e)->flags_remote)
+      mutt_str_strcat(flags, sizeof(flags), IMAP_EDATA(e)->flags_remote);
 
     mutt_str_remove_trailing_ws(flags);
 
@@ -1349,11 +1349,11 @@ int imap_sync_message_for_copy(struct ImapMboxData *mdata, struct Email *e,
   }
 
   /* server have now the updated flags */
-  FREE(&HEADER_DATA(e)->flags_remote);
-  HEADER_DATA(e)->flags_remote = driver_tags_get_with_hidden(&e->tags);
+  FREE(&IMAP_EDATA(e)->flags_remote);
+  IMAP_EDATA(e)->flags_remote = driver_tags_get_with_hidden(&e->tags);
 
   e->active = true;
-  if (e->deleted == HEADER_DATA(e)->deleted)
+  if (e->deleted == IMAP_EDATA(e)->deleted)
     e->changed = false;
 
   return 0;
@@ -2061,7 +2061,7 @@ int imap_sync_mailbox(struct Context *ctx, bool expunge)
     {
       imap_cache_del(mdata, e);
 #ifdef USE_HCACHE
-      imap_hcache_del(mdata, HEADER_DATA(e)->uid);
+      imap_hcache_del(mdata, IMAP_EDATA(e)->uid);
 #endif
     }
 
@@ -2153,11 +2153,11 @@ int imap_sync_mailbox(struct Context *ctx, bool expunge)
    * there is no need to mutate the hcache after flag-only changes. */
   for (int i = 0; i < ctx->mailbox->msg_count; i++)
   {
-    HEADER_DATA(ctx->mailbox->hdrs[i])->deleted = ctx->mailbox->hdrs[i]->deleted;
-    HEADER_DATA(ctx->mailbox->hdrs[i])->flagged = ctx->mailbox->hdrs[i]->flagged;
-    HEADER_DATA(ctx->mailbox->hdrs[i])->old = ctx->mailbox->hdrs[i]->old;
-    HEADER_DATA(ctx->mailbox->hdrs[i])->read = ctx->mailbox->hdrs[i]->read;
-    HEADER_DATA(ctx->mailbox->hdrs[i])->replied = ctx->mailbox->hdrs[i]->replied;
+    IMAP_EDATA(ctx->mailbox->hdrs[i])->deleted = ctx->mailbox->hdrs[i]->deleted;
+    IMAP_EDATA(ctx->mailbox->hdrs[i])->flagged = ctx->mailbox->hdrs[i]->flagged;
+    IMAP_EDATA(ctx->mailbox->hdrs[i])->old = ctx->mailbox->hdrs[i]->old;
+    IMAP_EDATA(ctx->mailbox->hdrs[i])->read = ctx->mailbox->hdrs[i]->read;
+    IMAP_EDATA(ctx->mailbox->hdrs[i])->replied = ctx->mailbox->hdrs[i]->replied;
     ctx->mailbox->hdrs[i]->changed = false;
   }
   ctx->mailbox->changed = false;
@@ -2565,14 +2565,6 @@ static int imap_mbox_close(struct Context *ctx)
     mutt_bcache_close(&mdata->bcache);
   }
 
-  /* free IMAP part of headers */
-  for (int i = 0; i < ctx->mailbox->msg_count; i++)
-  {
-    /* mailbox may not have fully loaded */
-    if (ctx->mailbox->hdrs[i] && ctx->mailbox->hdrs[i]->data)
-      imap_free_email_data((struct ImapEmailData **) &(ctx->mailbox->hdrs[i]->data));
-  }
-
   return 0;
 }
 
@@ -2696,10 +2688,10 @@ static int imap_tags_commit(struct Context *ctx, struct Email *e, char *buf)
   if (!mutt_bit_isset(mdata->ctx->mailbox->rights, MUTT_ACL_WRITE))
     return 0;
 
-  snprintf(uid, sizeof(uid), "%u", HEADER_DATA(e)->uid);
+  snprintf(uid, sizeof(uid), "%u", IMAP_EDATA(e)->uid);
 
   /* Remove old custom flags */
-  if (HEADER_DATA(e)->flags_remote)
+  if (IMAP_EDATA(e)->flags_remote)
   {
     cmd = mutt_buffer_new();
     if (!cmd)
@@ -2711,7 +2703,7 @@ static int imap_tags_commit(struct Context *ctx, struct Email *e, char *buf)
     mutt_buffer_addstr(cmd, "UID STORE ");
     mutt_buffer_addstr(cmd, uid);
     mutt_buffer_addstr(cmd, " -FLAGS.SILENT (");
-    mutt_buffer_addstr(cmd, HEADER_DATA(e)->flags_remote);
+    mutt_buffer_addstr(cmd, IMAP_EDATA(e)->flags_remote);
     mutt_buffer_addstr(cmd, ")");
 
     /* Should we return here, or we are fine and we could
@@ -2754,8 +2746,8 @@ static int imap_tags_commit(struct Context *ctx, struct Email *e, char *buf)
   /* We are good sync them */
   mutt_debug(1, "NEW TAGS: %d\n", buf);
   driver_tags_replace(&e->tags, buf);
-  FREE(&HEADER_DATA(e)->flags_remote);
-  HEADER_DATA(e)->flags_remote = driver_tags_get_with_hidden(&e->tags);
+  FREE(&IMAP_EDATA(e)->flags_remote);
+  IMAP_EDATA(e)->flags_remote = driver_tags_get_with_hidden(&e->tags);
   return 0;
 }
 

diff --git a/imap/imap_private.h b/imap/imap_private.h
index d9e7aaf5a602e433602b7007e457d65472420a1f..05afa8f3a61b79444cf331ba967530d5c598d9ee 100644 (file)
--- a/imap/imap_private.h
+++ b/imap/imap_private.h
@@ -318,7 +318,7 @@ int imap_exec(struct ImapMboxData *mdata, const char *cmdstr, int flags);
 int imap_cmd_idle(struct ImapMboxData *mdata);
 
 /* message.c */
-void imap_free_email_data(struct ImapEmailData **data);
+void imap_free_emaildata(void **data);
 int imap_read_headers(struct ImapMboxData *mdata, unsigned int msn_begin, unsigned int msn_end, bool initial_download);
 char *imap_set_flags(struct ImapMboxData *mdata, struct Email *e, char *s, int *server_changes);
 int imap_cache_del(struct ImapMboxData *mdata, struct Email *e);

diff --git a/imap/message.c b/imap/message.c
index 3e3e900a571c4a790b4293c7542a81c05b803312..5c091dfbbebf8be64672b76581822e5b913b2051 100644 (file)
--- a/imap/message.c
+++ b/imap/message.c
@@ -68,10 +68,10 @@ struct BodyCache;
 char *ImapHeaders; ///< Config: (imap) Additional email headers to download when getting index
 
 /**
- * new_header_data - Create a new ImapEmailData
+ * new_emaildata - Create a new ImapEmailData
  * @retval ptr New ImapEmailData
  */
-static struct ImapEmailData *new_header_data(void)
+static struct ImapEmailData *new_emaildata(void)
 {
   return mutt_mem_calloc(1, sizeof(struct ImapEmailData));
 }
@@ -109,7 +109,7 @@ static FILE *msg_cache_get(struct ImapMboxData *mdata, struct Email *e)
 
   mdata->bcache = msg_cache_open(mdata);
   char id[64];
-  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, HEADER_DATA(e)->uid);
+  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, IMAP_EDATA(e)->uid);
   return mutt_bcache_get(mdata->bcache, id);
 }
 
@@ -127,7 +127,7 @@ static FILE *msg_cache_put(struct ImapMboxData *mdata, struct Email *e)
 
   mdata->bcache = msg_cache_open(mdata);
   char id[64];
-  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, HEADER_DATA(e)->uid);
+  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, IMAP_EDATA(e)->uid);
   return mutt_bcache_put(mdata->bcache, id);
 }
 
@@ -145,7 +145,7 @@ static int msg_cache_commit(struct ImapMboxData *mdata, struct Email *e)
 
   mdata->bcache = msg_cache_open(mdata);
   char id[64];
-  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, HEADER_DATA(e)->uid);
+  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, IMAP_EDATA(e)->uid);
 
   return mutt_bcache_commit(mdata->bcache, id);
 }
@@ -687,7 +687,7 @@ static int read_headers_normal_eval_cache(struct ImapMboxData *mdata,
     mutt_progress_update(&progress, msgno, -1);
 
     memset(&h, 0, sizeof(h));
-    h.data = mutt_mem_calloc(1, sizeof(struct ImapEmailData));
+    h.data = new_emaildata();
     do
     {
       rc = imap_cmd_step(mdata);
@@ -766,7 +766,7 @@ static int read_headers_normal_eval_cache(struct ImapMboxData *mdata,
       }
     } while (mfhrc == -1);
 
-    imap_free_email_data(&h.data);
+    imap_free_emaildata((void **) &h.data);
 
     if ((mfhrc < -1) || ((rc != IMAP_CMD_CONTINUE) && (rc != IMAP_CMD_OK)))
       return -1;
@@ -816,8 +816,9 @@ static int read_headers_qresync_eval_cache(struct ImapMboxData *mdata, char *uid
       if (ctx->mailbox->msg_count >= ctx->mailbox->hdrmax)
         mx_alloc_memory(ctx->mailbox);
 
-      struct ImapEmailData *edata = mutt_mem_calloc(1, sizeof(struct ImapEmailData));
+      struct ImapEmailData *edata = new_emaildata();
       e->data = edata;
+      e->free_data = imap_free_emaildata;
 
       e->index = ctx->mailbox->msg_count;
       e->active = true;
@@ -1014,7 +1015,7 @@ static int read_headers_fetch_new(struct ImapMboxData *mdata, unsigned int msn_b
 
       rewind(fp);
       memset(&h, 0, sizeof(h));
-      h.data = new_header_data();
+      h.data = new_emaildata();
 
       /* this DO loop does two things:
        * 1. handles untagged messages, so we can try again on the same msg
@@ -1098,7 +1099,7 @@ static int read_headers_fetch_new(struct ImapMboxData *mdata, unsigned int msn_b
         idx++;
       } while (mfhrc == -1);
 
-      imap_free_email_data(&h.data);
+      imap_free_emaildata((void **) &h.data);
 
       if ((mfhrc < -1) || ((rc != IMAP_CMD_CONTINUE) && (rc != IMAP_CMD_OK)))
         goto bail;
@@ -1567,7 +1568,7 @@ int imap_copy_messages(struct Context *ctx, struct Email *e, char *dest, bool de
     else
     {
       mutt_message(_("Copying message %d to %s..."), e->index + 1, mbox);
-      mutt_buffer_printf(&cmd, "UID COPY %u %s", HEADER_DATA(e)->uid, mmbox);
+      mutt_buffer_printf(&cmd, "UID COPY %u %s", IMAP_EDATA(e)->uid, mmbox);
 
       if (e->active && e->changed)
       {
@@ -1668,7 +1669,7 @@ int imap_cache_del(struct ImapMboxData *mdata, struct Email *e)
 
   mdata->bcache = msg_cache_open(mdata);
   char id[64];
-  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, HEADER_DATA(e)->uid);
+  snprintf(id, sizeof(id), "%u-%u", mdata->uid_validity, IMAP_EDATA(e)->uid);
   return mutt_bcache_del(mdata->bcache, id);
 }
 
@@ -1686,17 +1687,18 @@ int imap_cache_clean(struct ImapMboxData *mdata)
 }
 
 /**
- * imap_free_email_data - free ImapHeader structure
+ * imap_free_emaildata - free ImapHeader structure
  * @param data Header data to free
  */
-void imap_free_email_data(struct ImapEmailData **data)
+void imap_free_emaildata(void **data)
 {
   if (!data || !*data)
     return;
 
+  struct ImapEmailData *edata = *data;
   /* this should be safe even if the list wasn't used */
-  FREE(&((*data)->flags_system));
-  FREE(&((*data)->flags_remote));
+  FREE(&edata->flags_system);
+  FREE(&edata->flags_remote);
   FREE(data);
 }
 
@@ -1801,7 +1803,7 @@ int imap_msg_open(struct Context *ctx, struct Message *msg, int msgno)
   msg->fp = msg_cache_get(mdata, e);
   if (msg->fp)
   {
-    if (HEADER_DATA(e)->parsed)
+    if (IMAP_EDATA(e)->parsed)
       return 0;
     else
       goto parsemsg;
@@ -1809,13 +1811,13 @@ int imap_msg_open(struct Context *ctx, struct Message *msg, int msgno)
 
   /* we still do some caching even if imap_cachedir is unset */
   /* see if we already have the message in our cache */
-  cacheno = HEADER_DATA(e)->uid % IMAP_CACHE_LEN;
+  cacheno = IMAP_EDATA(e)->uid % IMAP_CACHE_LEN;
   cache = &mdata->cache[cacheno];
 
   if (cache->path)
   {
     /* don't treat cache errors as fatal, just fall back. */
-    if (cache->uid == HEADER_DATA(e)->uid && (msg->fp = fopen(cache->path, "r")))
+    if (cache->uid == IMAP_EDATA(e)->uid && (msg->fp = fopen(cache->path, "r")))
       return 0;
     else
     {
@@ -1833,7 +1835,7 @@ int imap_msg_open(struct Context *ctx, struct Message *msg, int msgno)
   msg->fp = msg_cache_put(mdata, e);
   if (!msg->fp)
   {
-    cache->uid = HEADER_DATA(e)->uid;
+    cache->uid = IMAP_EDATA(e)->uid;
     mutt_mktemp(path, sizeof(path));
     cache->path = mutt_str_strdup(path);
     msg->fp = mutt_file_fopen(path, "w+");
@@ -1849,7 +1851,7 @@ int imap_msg_open(struct Context *ctx, struct Message *msg, int msgno)
    * command handler */
   e->active = false;
 
-  snprintf(buf, sizeof(buf), "UID FETCH %u %s", HEADER_DATA(e)->uid,
+  snprintf(buf, sizeof(buf), "UID FETCH %u %s", IMAP_EDATA(e)->uid,
            (mutt_bit_isset(mdata->capabilities, IMAP4REV1) ?
                 (ImapPeek ? "BODY.PEEK[]" : "BODY[]") :
                 "RFC822"));
@@ -1877,7 +1879,7 @@ int imap_msg_open(struct Context *ctx, struct Message *msg, int msgno)
           pc = imap_next_word(pc);
           if (mutt_str_atoui(pc, &uid) < 0)
             goto bail;
-          if (uid != HEADER_DATA(e)->uid)
+          if (uid != IMAP_EDATA(e)->uid)
           {
             mutt_error(_(
                 "The message index is incorrect. Try reopening the mailbox."));
@@ -1976,7 +1978,7 @@ parsemsg:
 
   mutt_clear_error();
   rewind(msg->fp);
-  HEADER_DATA(e)->parsed = true;
+  IMAP_EDATA(e)->parsed = true;
 
   /* retry message parse if cached message is empty */
   if (!retried && ((e->lines == 0) || (e->content->length == 0)))

diff --git a/imap/message.h b/imap/message.h
index 2beee5bb718bb2861b4ef406f3cab28e5f68a677..e7588144aa98c196cbd15606b60e6e23081ac2f3 100644 (file)
--- a/imap/message.h
+++ b/imap/message.h
@@ -62,6 +62,6 @@ struct ImapHeader
   long content_length;
 };
 
-#define HEADER_DATA(ph) ((struct ImapEmailData *) ((ph)->data))
+#define IMAP_EDATA(email) ((struct ImapEmailData *) ((email)->data))
 
 #endif /* MUTT_IMAP_MESSAGE_H */

diff --git a/imap/util.c b/imap/util.c
index b1474e45063272dbc96363ee099fe6256a297499..2085feb3ad6228a1ec252409ccdd1f7f00bbeead 100644 (file)
--- a/imap/util.c
+++ b/imap/util.c
@@ -232,7 +232,7 @@ static void imap_msn_index_to_uid_seqset(struct Buffer *b, struct ImapMboxData *
     if (msn <= mdata->max_msn)
     {
       struct Email *cur_header = mdata->msn_index[msn - 1];
-      cur_uid = cur_header ? HEADER_DATA(cur_header)->uid : 0;
+      cur_uid = cur_header ? IMAP_EDATA(cur_header)->uid : 0;
       if (!state || (cur_uid && ((cur_uid - 1) == last_uid)))
         match = true;
       last_uid = cur_uid;
@@ -375,7 +375,7 @@ int imap_hcache_put(struct ImapMboxData *mdata, struct Email *e)
   if (!mdata->hcache)
     return -1;
 
-  sprintf(key, "/%u", HEADER_DATA(e)->uid);
+  sprintf(key, "/%u", IMAP_EDATA(e)->uid);
   return mutt_hcache_store(mdata->hcache, key, imap_hcache_keylen(key), e, mdata->uid_validity);
 }