X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=imap%2Fmessage.c;h=d780c9c99e2cad46f7126ffd92ecd1af6198e0bb;hp=90a6c39b254f513b0bd91f3af9290342e9fc722c;hb=9eb790d6eb4a56416d342816e1140aabd9c12de8;hpb=c3e57678c8be193fc137854020f3a90887be97c9 diff --git a/imap/message.c b/imap/message.c index 90a6c39..d780c9c 100644 --- a/imap/message.c +++ b/imap/message.c @@ -10,40 +10,31 @@ /* message parsing/updating functions */ -#if HAVE_CONFIG_H -# include "config.h" -#endif +#include -#include -#include +#include +#include +#include #include "mutt.h" -#include "mutt_curses.h" #include "imap_private.h" #include "message.h" -#include "mx.h" #ifdef HAVE_PGP #include "pgp.h" #endif -#if HAVE_STDINT_H -#include -#elif HAVE_INTTYPES_H -#include -#endif - static void flush_buffer (char *buf, size_t * len, CONNECTION * conn); static int msg_fetch_header (CONTEXT * ctx, IMAP_HEADER * h, char *buf, FILE * fp); -static int msg_has_flag (LIST * flag_list, const char *flag); +static int msg_has_flag (string_list_t * flag_list, const char *flag); static int msg_parse_fetch (IMAP_HEADER * h, char *s); static char *msg_parse_flags (IMAP_HEADER * h, char *s); -#if USE_HCACHE +#ifdef USE_HCACHE static int msg_fetch_header_fetch (CONTEXT * ctx, IMAP_HEADER * h, char *buf, FILE * fp); -static size_t imap_hcache_keylen (const char *fn); +static ssize_t imap_hcache_keylen (const char *fn); #endif /* USE_HCACHE */ /* imap_read_headers: @@ -65,18 +56,14 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) const char *want_headers = "DATE FROM SUBJECT TO CC MESSAGE-ID REFERENCES CONTENT-TYPE CONTENT-DESCRIPTION IN-REPLY-TO REPLY-TO LINES LIST-POST X-LABEL"; -#if USE_HCACHE - void *hc = NULL; - uint64_t *uid_validity = NULL; +#ifdef USE_HCACHE + hcache_t *hc = NULL; + unsigned long *uid_validity = NULL; char uid_buf[64]; #endif /* USE_HCACHE */ ctx = idata->ctx; -#if USE_HCACHE - hc = mutt_hcache_open (HeaderCache, ctx->path); -#endif /* USE_HCACHE */ - if (mutt_bit_isset (idata->capabilities, IMAP4REV1)) { snprintf (hdrreq, sizeof (hdrreq), "BODY.PEEK[HEADER.FIELDS (%s%s%s)]", want_headers, ImapHeaders ? " " : "", @@ -91,24 +78,18 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) mutt_error _("Unable to fetch headers from this IMAP server version."); mutt_sleep (2); /* pause a moment to let the user see the error */ -#if USE_HCACHE - mutt_hcache_close (hc); -#endif /* USE_HCACHE */ return -1; } /* instead of downloading all headers and then parsing them, we parse them * as they come in. */ - mutt_mktemp (tempfile); - if (!(fp = safe_fopen (tempfile, "w+"))) { - mutt_error (_("Could not create temporary file %s"), tempfile); - mutt_sleep (2); -#if USE_HCACHE - mutt_hcache_close (hc); -#endif /* USE_HCACHE */ + fp = m_tempfile(tempfile, sizeof(tempfile), NONULL(MCore.tmpdir), NULL); + if (!fp) { + mutt_error(_("Could not create temporary file")); + mutt_sleep(2); return -1; } - unlink (tempfile); + unlink(tempfile); /* make sure context has room to hold the mailbox */ while ((msgend) >= idata->ctx->hdrmax) @@ -118,79 +99,78 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) idata->reopen &= ~IMAP_NEWMAIL_PENDING; idata->newMailCount = 0; -#if USE_HCACHE - snprintf (buf, sizeof (buf), - "FETCH %d:%d (UID FLAGS)", msgbegin + 1, msgend + 1); - fetchlast = msgend + 1; +#ifdef USE_HCACHE + if ((hc = mutt_hcache_open (HeaderCache, ctx->path))) { - imap_cmd_start (idata, buf); + snprintf (buf, sizeof (buf), + "FETCH %d:%d (UID FLAGS)", msgbegin + 1, msgend + 1); + fetchlast = msgend + 1; - for (msgno = msgbegin; msgno <= msgend; msgno++) { - if (ReadInc && (!msgno || ((msgno + 1) % ReadInc == 0))) - mutt_message (_("Evaluating cache... [%d/%d]"), msgno + 1, msgend + 1); + imap_cmd_start (idata, buf); - rewind (fp); - memset (&h, 0, sizeof (h)); - h.data = safe_calloc (1, sizeof (IMAP_HEADER_DATA)); - do { - mfhrc = 0; + for (msgno = msgbegin; msgno <= msgend; msgno++) { + if (ReadInc && (!msgno || ((msgno + 1) % ReadInc == 0))) + mutt_message (_("Evaluating cache... [%d/%d]"), msgno + 1, msgend + 1); - rc = imap_cmd_step (idata); - if (rc != IMAP_CMD_CONTINUE) - break; + rewind (fp); + p_clear(&h, 1); + h.data = p_new(IMAP_HEADER_DATA, 1); + do { + mfhrc = 0; + + rc = imap_cmd_step (idata); + if (rc != IMAP_CMD_CONTINUE) + break; + + if ((mfhrc = + msg_fetch_header_fetch (idata->ctx, &h, idata->cmd.buf, fp)) == -1) + continue; + else if (mfhrc < 0) + break; + + /* make sure we don't get remnants from older larger message headers */ + fputs ("\n\n", fp); + + sprintf (uid_buf, "/%u", h.data->uid); /* XXX --tg 21:41 04-07-11 */ + uid_validity = + (unsigned long *) mutt_hcache_fetch (hc, uid_buf, &imap_hcache_keylen); + + if (uid_validity != NULL && *uid_validity == idata->uid_validity) { + ctx->hdrs[msgno] = mutt_hcache_restore((unsigned char *) uid_validity, 0); + ctx->hdrs[msgno]->index = h.sid - 1; + /* messages which have not been expunged are ACTIVE (borrowed from mh + * folders) */ + ctx->hdrs[msgno]->active = 1; + ctx->hdrs[msgno]->read = h.read; + ctx->hdrs[msgno]->old = h.old; + ctx->hdrs[msgno]->deleted = h.deleted; + ctx->hdrs[msgno]->flagged = h.flagged; + ctx->hdrs[msgno]->replied = h.replied; + ctx->hdrs[msgno]->changed = h.changed; + /* ctx->hdrs[msgno]->received is restored from mutt_hcache_restore */ + ctx->hdrs[msgno]->data = (void *) (h.data); + + ctx->msgcount++; + } - if ((mfhrc = - msg_fetch_header_fetch (idata->ctx, &h, idata->cmd.buf, fp)) == -1) - continue; - else if (mfhrc < 0) - break; + rewind (fp); - /* make sure we don't get remnants from older larger message headers */ - fputs ("\n\n", fp); + p_delete(&uid_validity); - sprintf (uid_buf, "/%u", h.data->uid); /* XXX --tg 21:41 04-07-11 */ - uid_validity = - (uint64_t *) mutt_hcache_fetch (hc, uid_buf, &imap_hcache_keylen); - - if (uid_validity != NULL && *uid_validity == idata->uid_validity) { - ctx->hdrs[msgno] = - mutt_hcache_restore ((unsigned char *) uid_validity, 0); - ctx->hdrs[msgno]->index = h.sid - 1; - if (h.sid != ctx->msgcount + 1) - dprint (1, - (debugfile, - "imap_read_headers: msgcount and sequence ID are inconsistent!")); - /* messages which have not been expunged are ACTIVE (borrowed from mh - * folders) */ - ctx->hdrs[msgno]->active = 1; - ctx->hdrs[msgno]->read = h.read; - ctx->hdrs[msgno]->old = h.old; - ctx->hdrs[msgno]->deleted = h.deleted; - ctx->hdrs[msgno]->flagged = h.flagged; - ctx->hdrs[msgno]->replied = h.replied; - ctx->hdrs[msgno]->changed = h.changed; - /* ctx->hdrs[msgno]->received is restored from mutt_hcache_restore */ - ctx->hdrs[msgno]->data = (void *) (h.data); - - ctx->msgcount++; } - rewind (fp); - - FREE (&uid_validity); + while ((rc != IMAP_CMD_OK) && ((mfhrc == -1) || + ((msgno + 1) >= fetchlast))); + if ((mfhrc < -1) || ((rc != IMAP_CMD_CONTINUE) && (rc != IMAP_CMD_OK))) { + imap_free_header_data((void *)&h.data); + m_fclose(&fp); + mutt_hcache_close (&hc); + return -1; + } } - while ((rc != IMAP_CMD_OK) && ((mfhrc == -1) || - ((msgno + 1) >= fetchlast))); - if ((mfhrc < -1) || ((rc != IMAP_CMD_CONTINUE) && (rc != IMAP_CMD_OK))) { - imap_free_header_data ((void **) &h.data); - fclose (fp); - mutt_hcache_close (hc); - return -1; - } + fetchlast = msgbegin; } - - fetchlast = msgbegin; #endif /* USE_HCACHE */ for (msgno = msgbegin; msgno <= msgend; msgno++) { @@ -222,8 +202,8 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) /* freshen fp, h */ rewind (fp); - memset (&h, 0, sizeof (h)); - h.data = safe_calloc (1, sizeof (IMAP_HEADER_DATA)); + p_clear(&h, 1); + h.data = p_new(IMAP_HEADER_DATA, 1); /* this DO loop does two things: * 1. handles untagged messages, so we can try again on the same msg @@ -246,13 +226,9 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) fputs ("\n\n", fp); /* update context with message header */ - ctx->hdrs[msgno] = mutt_new_header (); + ctx->hdrs[msgno] = header_new(); ctx->hdrs[msgno]->index = h.sid - 1; - if (h.sid != ctx->msgcount + 1) - dprint (1, - (debugfile, - "imap_read_headers: msgcount and sequence ID are inconsistent!")); /* messages which have not been expunged are ACTIVE (borrowed from mh * folders) */ ctx->hdrs[msgno]->active = 1; @@ -273,7 +249,7 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) /* content built as a side-effect of mutt_read_rfc822_header */ ctx->hdrs[msgno]->content->length = h.content_length; -#if USE_HCACHE +#ifdef USE_HCACHE sprintf (uid_buf, "/%u", h.data->uid); mutt_hcache_store (hc, uid_buf, ctx->hdrs[msgno], idata->uid_validity, &imap_hcache_keylen); @@ -285,10 +261,10 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) ((msgno + 1) >= fetchlast))); if ((mfhrc < -1) || ((rc != IMAP_CMD_CONTINUE) && (rc != IMAP_CMD_OK))) { - imap_free_header_data ((void **) &h.data); - fclose (fp); -#if USE_HCACHE - mutt_hcache_close (hc); + imap_free_header_data ((void *)&h.data); + m_fclose(&fp); +#ifdef USE_HCACHE + mutt_hcache_close (&hc); #endif /* USE_HCACHE */ return -1; } @@ -303,11 +279,11 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) } } -#if USE_HCACHE - mutt_hcache_close (hc); +#ifdef USE_HCACHE + mutt_hcache_close (&hc); #endif /* USE_HCACHE */ - fclose (fp); + m_fclose(&fp); if (ctx->msgcount > oldmsgcount) mx_update_context (ctx, ctx->msgcount - oldmsgcount); @@ -315,10 +291,55 @@ int imap_read_headers (IMAP_DATA * idata, int msgbegin, int msgend) return msgend; } +/* move all the headers from extra not present in base into base */ +static void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra) +{ + /* copies each existing element if necessary, and sets the element + * to NULL in the source so that envelope_delete doesn't leave us + * with dangling pointers. */ +#define MOVE_ELEM(h) if (!base->h) { base->h = (*extra)->h; (*extra)->h = NULL; } + MOVE_ELEM(return_path); + MOVE_ELEM(from); + MOVE_ELEM(to); + MOVE_ELEM(cc); + MOVE_ELEM(bcc); + MOVE_ELEM(sender); + MOVE_ELEM(reply_to); + MOVE_ELEM(mail_followup_to); + MOVE_ELEM(list_post); + MOVE_ELEM(message_id); + MOVE_ELEM(supersedes); + MOVE_ELEM(date); + MOVE_ELEM(x_label); + if (!base->refs_changed) { + MOVE_ELEM(references); + } + if (!base->irt_changed) { + MOVE_ELEM(in_reply_to); + } + /* real_subj is subordinate to subject */ + if (!base->subject) { + base->subject = (*extra)->subject; + base->real_subj = (*extra)->real_subj; + (*extra)->subject = NULL; + (*extra)->real_subj = NULL; + } + /* spam and user headers should never be hashed, and the new envelope may + * have better values. Use new versions regardless. */ + mutt_buffer_free (&base->spam); + string_list_wipe(&base->userhdrs); + MOVE_ELEM(spam); + MOVE_ELEM(userhdrs); +#undef MOVE_ELEM + + envelope_delete(extra); +} + int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) { IMAP_DATA *idata; HEADER *h; + ENVELOPE* newenv; char buf[LONG_STRING]; char path[_POSIX_PATH_MAX]; char *pc; @@ -326,8 +347,9 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) int uid; int cacheno; IMAP_CACHE *cache; - int read; + int isread; int rc; + progress_t bar; /* Sam's weird courier server returns an OK response even when FETCH * fails. Thanks Sam. */ @@ -341,18 +363,12 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) cache = &idata->cache[cacheno]; if (cache->path) { - if (cache->uid == HEADER_DATA (h)->uid) { - /* yes, so just return a pointer to the message */ - if (!(msg->fp = fopen (cache->path, "r"))) { - mutt_perror (cache->path); - return (-1); - } + /* don't treat cache errors as fatal, just fall back. */ + if (cache->uid == HEADER_DATA(h)->uid && (msg->fp = fopen (cache->path, "r"))) return 0; - } else { - /* clear the previous entry */ unlink (cache->path); - FREE (&cache->path); + p_delete(&cache->path); } } @@ -360,12 +376,11 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) mutt_message _("Fetching message..."); cache->uid = HEADER_DATA (h)->uid; - mutt_mktemp (path); - cache->path = safe_strdup (path); - if (!(msg->fp = safe_fopen (path, "w+"))) { - FREE (&cache->path); + msg->fp = m_tempfile(path, sizeof(path), NONULL(MCore.tmpdir), NULL); + if (!msg->fp) { return -1; } + cache->path = m_strdup(path); /* mark this header as currently inactive so the command handler won't * also try to update it. HACK until all this code can be moved into the @@ -393,7 +408,7 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) if (ascii_strncasecmp ("UID", pc, 3) == 0) { pc = imap_next_word (pc); uid = atoi (pc); - if (uid != HEADER_DATA (h)->uid) + if (uid != HEADER_DATA(h)->uid) mutt_error (_ ("The message index is incorrect. Try reopening the mailbox.")); } @@ -404,7 +419,10 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) imap_error ("imap_fetch_message()", buf); goto bail; } - if (imap_read_literal (msg->fp, idata, bytes) < 0) + bar.size = bytes; + bar.msg = _("Fetching message..."); + mutt_progress_bar (&bar, 0); + if (imap_read_literal (msg->fp, idata, bytes, &bar) < 0) goto bail; /* pick up trailing line */ if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE) @@ -429,6 +447,12 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) /* see comment before command start. */ h->active = 1; + fflush (msg->fp); + if (ferror (msg->fp)) { + mutt_perror (cache->path); + goto bail; + } + if (rc != IMAP_CMD_OK) goto bail; @@ -444,28 +468,15 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) * the server's notion of 'read' and if it differs from the message info * picked up in mutt_read_rfc822_header, we mark the message (and context * changed). Another possiblity: ignore Status on IMAP?*/ - read = h->read; - /* I hate do this here, since it's so low-level, but I'm not sure where - * I can abstract it. Problem: the id and subj hashes lose their keys when - * mutt_free_envelope gets called, but keep their spots in the hash. This - * confuses threading. Alternatively we could try to merge the new - * envelope into the old one. Also messy and lowlevel. */ - if (ctx->id_hash && h->env->message_id) - hash_delete (ctx->id_hash, h->env->message_id, h, NULL); - if (ctx->subj_hash && h->env->real_subj) - hash_delete (ctx->subj_hash, h->env->real_subj, h, NULL); - mutt_free_envelope (&h->env); - h->env = mutt_read_rfc822_header (msg->fp, h, 0, 0); - if (ctx->id_hash && h->env->message_id) - hash_insert (ctx->id_hash, h->env->message_id, h, 0); - if (ctx->subj_hash && h->env->real_subj) - hash_insert (ctx->subj_hash, h->env->real_subj, h, 1); + isread = h->read; + newenv = mutt_read_rfc822_header (msg->fp, h, 0, 0); + mutt_merge_envelopes(h->env, &newenv); /* see above. We want the new status in h->read, so we unset it manually * and let mutt_set_flag set it correctly, updating context. */ - if (read != h->read) { - h->read = read; - mutt_set_flag (ctx, h, M_NEW, read); + if (isread != h->read) { + h->read = isread; + mutt_set_flag (ctx, h, M_NEW, isread); } h->lines = 0; @@ -475,7 +486,7 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) fgets (buf, sizeof (buf), msg->fp); } - h->content->length = ftell (msg->fp) - h->content->offset; + h->content->length = ftello (msg->fp) - h->content->offset; /* This needs to be done in case this is a multipart message */ #if defined(HAVE_PGP) || defined(HAVE_SMIME) @@ -488,10 +499,10 @@ int imap_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno) return 0; bail: - safe_fclose (&msg->fp); + m_fclose(&msg->fp); if (cache->path) { unlink (cache->path); - FREE (&cache->path); + p_delete(&cache->path); } return -1; @@ -508,6 +519,8 @@ int imap_append_message (CONTEXT * ctx, MESSAGE * msg) int c, last; IMAP_MBOX mx; int rc; + progress_t bar; + size_t sent; idata = (IMAP_DATA *) ctx->data; @@ -535,6 +548,10 @@ int imap_append_message (CONTEXT * ctx, MESSAGE * msg) } rewind (fp); + bar.msg = _("Uploading message..."); + bar.size = len; + mutt_progress_bar (&bar, 0); + imap_munge_mbox_name (mbox, sizeof (mbox), mailbox); snprintf (buf, sizeof (buf), "APPEND %s (%s%s%s%s%s) {%lu}", mbox, msg->flags.read ? "\\Seen" : "", @@ -553,35 +570,32 @@ int imap_append_message (CONTEXT * ctx, MESSAGE * msg) if (rc != IMAP_CMD_RESPOND) { char *pc; - dprint (1, (debugfile, "imap_append_message(): command failed: %s\n", - idata->cmd.buf)); - - pc = idata->cmd.buf + SEQLEN; - SKIPWS (pc); + pc = vskipspaces(idata->cmd.buf + SEQLEN); pc = imap_next_word (pc); mutt_error ("%s", pc); mutt_sleep (1); - fclose (fp); + m_fclose(&fp); goto fail; } - mutt_message _("Uploading message ..."); - - for (last = EOF, len = 0; (c = fgetc (fp)) != EOF; last = c) { + for (last = EOF, sent = len = 0; (c = fgetc (fp)) != EOF; last = c) { if (c == '\n' && last != '\r') buf[len++] = '\r'; buf[len++] = c; - if (len > sizeof (buf) - 3) + if (len > sizeof (buf) - 3) { + sent += len; flush_buffer (buf, &len, idata->conn); + mutt_progress_bar (&bar, sent); + } } if (len) flush_buffer (buf, &len, idata->conn); mutt_socket_write (idata->conn, "\r\n"); - fclose (fp); + m_fclose(&fp); do rc = imap_cmd_step (idata); @@ -590,21 +604,18 @@ int imap_append_message (CONTEXT * ctx, MESSAGE * msg) if (!imap_code (idata->cmd.buf)) { char *pc; - dprint (1, (debugfile, "imap_append_message(): command failed: %s\n", - idata->cmd.buf)); - pc = idata->cmd.buf + SEQLEN; - SKIPWS (pc); + pc = vskipspaces(idata->cmd.buf + SEQLEN); pc = imap_next_word (pc); mutt_error ("%s", pc); mutt_sleep (1); goto fail; } - FREE (&mx.mbox); + p_delete(&mx.mbox); return 0; fail: - FREE (&mx.mbox); + p_delete(&mx.mbox); return -1; } @@ -617,38 +628,34 @@ fail: int imap_copy_messages (CONTEXT * ctx, HEADER * h, char *dest, int delete) { IMAP_DATA *idata; - BUFFER cmd; + BUFFER cmd, sync_cmd; char uid[11]; char mbox[LONG_STRING]; char mmbox[LONG_STRING]; int rc; int n; IMAP_MBOX mx; + int err_continue = M_NO; idata = (IMAP_DATA *) ctx->data; if (imap_parse_path (dest, &mx)) { - dprint (1, (debugfile, "imap_copy_messages: bad destination %s\n", dest)); return -1; } /* check that the save-to folder is in the same account */ if (!mutt_account_match (&(CTX_DATA->conn->account), &(mx.account))) { - dprint (3, (debugfile, "imap_copy_messages: %s not same server as %s\n", - dest, ctx->path)); return 1; } if (h && h->attach_del) { - dprint (3, - (debugfile, - "imap_copy_messages: Message contains attachments to be deleted\n")); return 1; } imap_fix_path (idata, mx.mbox, mbox, sizeof (mbox)); - memset (&cmd, 0, sizeof (cmd)); + p_clear(&sync_cmd, 1); + p_clear(&cmd, 1); mutt_buffer_addstr (&cmd, "UID COPY "); /* Null HEADER* means copy tagged messages */ @@ -658,16 +665,22 @@ int imap_copy_messages (CONTEXT * ctx, HEADER * h, char *dest, int delete) * remainder. */ for (n = 0; n < ctx->msgcount; n++) { if (ctx->hdrs[n]->tagged && ctx->hdrs[n]->attach_del) { - dprint (3, - (debugfile, - "imap_copy_messages: Message contains attachments to be deleted\n")); return 1; } + + if (ctx->hdrs[n]->tagged && ctx->hdrs[n]->active && + ctx->hdrs[n]->changed) + { + rc = imap_sync_message (idata, ctx->hdrs[n], &sync_cmd, &err_continue); + if (rc < 0) + { + goto fail; + } + } } rc = imap_make_msg_set (idata, &cmd, M_TAG, 0); if (!rc) { - dprint (1, (debugfile, "imap_copy_messages: No messages tagged\n")); goto fail; } mutt_message (_("Copying %d messages to %s..."), rc, mbox); @@ -676,6 +689,15 @@ int imap_copy_messages (CONTEXT * ctx, HEADER * h, char *dest, int delete) mutt_message (_("Copying message %d to %s..."), h->index + 1, mbox); snprintf (uid, sizeof (uid), "%u", HEADER_DATA (h)->uid); mutt_buffer_addstr (&cmd, uid); + + if (h->active && h->changed) + { + rc = imap_sync_message (idata, h, &sync_cmd, &err_continue); + if (rc < 0) + { + goto fail; + } + } } /* let's get it on */ @@ -691,8 +713,6 @@ int imap_copy_messages (CONTEXT * ctx, HEADER * h, char *dest, int delete) imap_error ("imap_copy_messages", idata->cmd.buf); goto fail; } - dprint (2, - (debugfile, "imap_copy_messages: server suggests TRYCREATE\n")); snprintf (mmbox, sizeof (mmbox), _("Create %s?"), mbox); if (option (OPTCONFIRMCREATE) && mutt_yesorno (mmbox, 1) < 1) { mutt_clear_error (); @@ -729,23 +749,27 @@ int imap_copy_messages (CONTEXT * ctx, HEADER * h, char *dest, int delete) } if (cmd.data) - FREE (&cmd.data); - FREE (&mx.mbox); + p_delete(&cmd.data); + if (sync_cmd.data) + p_delete(&sync_cmd.data); + p_delete(&mx.mbox); return 0; fail: if (cmd.data) - FREE (&cmd.data); - FREE (&mx.mbox); + p_delete(&cmd.data); + if (sync_cmd.data) + p_delete(&sync_cmd.data); + p_delete(&mx.mbox); return -1; } /* imap_add_keywords: concatenate custom IMAP tags to list, if they * appear in the folder flags list. Why wouldn't they? */ -void imap_add_keywords (char *s, HEADER * h, LIST * mailbox_flags, +void imap_add_keywords (char *s, HEADER * h, string_list_t * mailbox_flags, size_t slen) { - LIST *keywords; + string_list_t *keywords; if (!mailbox_flags || !HEADER_DATA (h) || !HEADER_DATA (h)->keywords) return; @@ -754,8 +778,8 @@ void imap_add_keywords (char *s, HEADER * h, LIST * mailbox_flags, while (keywords) { if (msg_has_flag (mailbox_flags, keywords->data)) { - safe_strcat (s, slen, keywords->data); - safe_strcat (s, slen, " "); + m_strcat(s, slen, keywords->data); + m_strcat(s, slen, " "); } keywords = keywords->next; } @@ -765,9 +789,9 @@ void imap_add_keywords (char *s, HEADER * h, LIST * mailbox_flags, void imap_free_header_data (void **data) { /* this should be safe even if the list wasn't used */ - mutt_free_list (&(((IMAP_HEADER_DATA *) * data)->keywords)); + string_list_wipe(&(((IMAP_HEADER_DATA *) * data)->keywords)); - FREE (data); + p_delete(data); } /* imap_set_flags: fill out the message header according to the flags from @@ -778,12 +802,11 @@ char *imap_set_flags (IMAP_DATA * idata, HEADER * h, char *s) IMAP_HEADER newh; unsigned char readonly; - memset (&newh, 0, sizeof (newh)); - newh.data = safe_calloc (1, sizeof (IMAP_HEADER_DATA)); + p_clear(&newh, 1); + newh.data = p_new(IMAP_HEADER_DATA, 1); - dprint (2, (debugfile, "imap_fetch_message: parsing FLAGS\n")); if ((s = msg_parse_flags (&newh, s)) == NULL) { - FREE (&newh.data); + p_delete(&newh.data); return NULL; } @@ -807,9 +830,9 @@ char *imap_set_flags (IMAP_DATA * idata, HEADER * h, char *s) ctx->changed &= ~readonly; ctx->readonly = readonly; - mutt_free_list (&(HEADER_DATA (h)->keywords)); + string_list_wipe(&(HEADER_DATA (h)->keywords)); HEADER_DATA (h)->keywords = newh.data->keywords; - FREE (&newh.data); + p_delete(&newh.data); return s; } @@ -853,7 +876,7 @@ static int msg_fetch_header (CONTEXT * ctx, IMAP_HEADER * h, char *buf, return rc; if (imap_get_literal_count (buf, &bytes) == 0) { - imap_read_literal (fp, idata, bytes); + imap_read_literal (fp, idata, bytes, NULL); /* we may have other fields of the FETCH _after_ the literal * (eg Domino puts FLAGS here). Nothing wrong with that, either. @@ -875,10 +898,10 @@ static int msg_fetch_header (CONTEXT * ctx, IMAP_HEADER * h, char *buf, return rc; } -#if USE_HCACHE -static size_t imap_hcache_keylen (const char *fn) +#ifdef USE_HCACHE +static ssize_t imap_hcache_keylen (const char *fn) { - return mutt_strlen (fn); + return m_strlen(fn); } /* msg_fetch_header: import IMAP FETCH response into an IMAP_HEADER. @@ -888,7 +911,7 @@ static size_t imap_hcache_keylen (const char *fn) * -1 if the string is not a fetch response * -2 if the string is a corrupt fetch response */ static int msg_fetch_header_fetch (CONTEXT * ctx, IMAP_HEADER * h, char *buf, - FILE * fp) + FILE * fp __attribute__ ((unused))) { IMAP_DATA *idata; int rc = -1; /* default now is that string isn't FETCH response */ @@ -927,14 +950,14 @@ static int msg_fetch_header_fetch (CONTEXT * ctx, IMAP_HEADER * h, char *buf, /* msg_has_flag: do a caseless comparison of the flag against a flag list, * return 1 if found or flag list has '\*', 0 otherwise */ -static int msg_has_flag (LIST * flag_list, const char *flag) +static int msg_has_flag (string_list_t * flag_list, const char *flag) { if (!flag_list) return 0; flag_list = flag_list->next; while (flag_list) { - if (!ascii_strncasecmp (flag_list->data, flag, strlen (flag_list->data))) + if (!ascii_strncasecmp (flag_list->data, flag, m_strlen(flag_list->data))) return 1; flag_list = flag_list->next; @@ -946,33 +969,28 @@ static int msg_has_flag (LIST * flag_list, const char *flag) /* msg_parse_fetch: handle headers returned from header fetch */ static int msg_parse_fetch (IMAP_HEADER * h, char *s) { - char tmp[SHORT_STRING]; + char tmp[STRING]; char *ptmp; if (!s) return -1; while (*s) { - SKIPWS (s); + s = vskipspaces(s); if (ascii_strncasecmp ("FLAGS", s, 5) == 0) { if ((s = msg_parse_flags (h, s)) == NULL) return -1; } else if (ascii_strncasecmp ("UID", s, 3) == 0) { - s += 3; - SKIPWS (s); + s = vskipspaces(s + 3); h->data->uid = (unsigned int) atoi (s); s = imap_next_word (s); } else if (ascii_strncasecmp ("INTERNALDATE", s, 12) == 0) { - s += 12; - SKIPWS (s); + s = vskipspaces(s + 12); if (*s != '\"') { - dprint (1, - (debugfile, - "msg_parse_fetch(): bogus INTERNALDATE entry: %s\n", s)); return -1; } s++; @@ -986,8 +1004,7 @@ static int msg_parse_fetch (IMAP_HEADER * h, char *s) h->received = imap_parse_date (tmp); } else if (ascii_strncasecmp ("RFC822.SIZE", s, 11) == 0) { - s += 11; - SKIPWS (s); + s = vskipspaces(s + 11); ptmp = tmp; while (isdigit ((unsigned char) *s)) *ptmp++ = *s++; @@ -1018,13 +1035,10 @@ static char *msg_parse_flags (IMAP_HEADER * h, char *s) /* sanity-check string */ if (ascii_strncasecmp ("FLAGS", s, 5) != 0) { - dprint (1, (debugfile, "msg_parse_flags: not a FLAGS response: %s\n", s)); return NULL; } - s += 5; - SKIPWS (s); + s = vskipspaces(s + 5); if (*s != '(') { - dprint (1, (debugfile, "msg_parse_flags: bogus FLAGS response: %s\n", s)); return NULL; } s++; @@ -1057,7 +1071,7 @@ static char *msg_parse_flags (IMAP_HEADER * h, char *s) char *flag_word = s; if (!h->data->keywords) - h->data->keywords = mutt_new_list (); + h->data->keywords = string_item_new(); while (*s && !ISSPACE (*s) && *s != ')') s++; @@ -1066,7 +1080,7 @@ static char *msg_parse_flags (IMAP_HEADER * h, char *s) mutt_add_list (h->data->keywords, flag_word); *s = ctmp; } - SKIPWS (s); + s = vskipspaces(s); } /* wrap up, or note bad flags response */ @@ -1077,8 +1091,6 @@ static char *msg_parse_flags (IMAP_HEADER * h, char *s) s++; } else { - dprint (1, (debugfile, - "msg_parse_flags: Unterminated FLAGS response: %s\n", s)); return NULL; }