mbox_sync()

Save changes to the Mailbox. More...

Collaboration diagram for mbox_sync():

Functions
static enum MxStatus	comp_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
enum MxStatus	maildir_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	mbox_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	mh_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	nntp_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	nm_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	pop_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Detailed Description

Save changes to the Mailbox.

Parameters

m	Mailbox to sync

Return values

enum

MxStatus

Precondition

m is not NULL

Function Documentation

comp_mbox_sync()

static enum MxStatus comp_mbox_sync ( struct Mailbox * m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Changes in NeoMutt only affect the tmp file. Calling comp_mbox_sync() will commit them to the compressed file.

Definition at line 586 of file compress.c.

{
  if (!m->compress_info)
    return MX_STATUS_ERROR;
 
  struct CompressInfo *ci = m->compress_info;
 
  if (!ci->cmd_close)
  {
    mutt_error(_("Can't sync a compressed file without a close-hook"));
    return MX_STATUS_ERROR;
  }
 
  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return MX_STATUS_ERROR;
 
  if (!lock_realpath(m, true))
  {
    mutt_error(_("Unable to lock mailbox"));
    return MX_STATUS_ERROR;
  }
 
  enum MxStatus check = comp_mbox_check(m);
  if (check != MX_STATUS_OK)
    goto sync_cleanup;
 
  check = ops->mbox_sync(m);
  if (check != MX_STATUS_OK)
    goto sync_cleanup;
 
  if (!execute_command(m, ci->cmd_close, _("Compressing %s")))
  {
    check = MX_STATUS_ERROR;
    goto sync_cleanup;
  }
 
  check = MX_STATUS_OK;
 
sync_cleanup:
  store_size(m);
  unlock_realpath(m);
  return check;
}

Here is the call graph for this function:

maildir_mbox_sync()

enum MxStatus maildir_mbox_sync

(

struct Mailbox *

m

)

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Return values

enum

MxStatus

Note

The flag retvals come from a call to a backend sync function

Definition at line 846 of file mailbox.c.

{
  enum MxStatus check = maildir_check(m);
  if (check == MX_STATUS_ERROR)
    return check;
 
  struct HeaderCache *hc = maildir_hcache_open(m);
 
  struct Progress *progress = NULL;
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_WRITE, m->msg_count);
    progress_set_message(progress, _("Writing %s..."), mailbox_path(m));
  }
 
  for (int i = 0; i < m->msg_count; i++)
  {
    progress_update(progress, i, -1);
 
    struct Email *e = m->emails[i];
    if (!maildir_sync_mailbox_message(m, e, hc))
    {
      progress_free(&progress);
      goto err;
    }
  }
  progress_free(&progress);
  maildir_hcache_close(&hc);
 
  /* XXX race condition? */
 
  maildir_update_mtime(m);
 
  /* adjust indices */
 
  if (m->msg_deleted)
  {
    const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
    for (int i = 0, j = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
 
      if (!e->deleted || c_maildir_trash)
        e->index = j++;
    }
  }
 
  return check;
 
err:
  maildir_hcache_close(&hc);
  return MX_STATUS_ERROR;
}

Here is the call graph for this function:

mbox_mbox_sync()

static enum MxStatus mbox_mbox_sync ( struct Mailbox * m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Definition at line 1058 of file mbox.c.

{
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return MX_STATUS_ERROR;
 
  struct Buffer *tempfile = NULL;
  char buf[32] = { 0 };
  int j;
  bool unlink_tempfile = false;
  bool need_sort = false; /* flag to resort mailbox if new mail arrives */
  int first = -1;         /* first message to be written */
  LOFF_T offset;          /* location in mailbox to write changed messages */
  struct stat st = { 0 };
  struct MUpdate *new_offset = NULL;
  struct MUpdate *old_offset = NULL;
  FILE *fp = NULL;
  struct Progress *progress = NULL;
  enum MxStatus rc = MX_STATUS_ERROR;
 
  /* sort message by their position in the mailbox on disk */
  const enum EmailSortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  if (c_sort != EMAIL_SORT_UNSORTED)
  {
    mutt_sort_unsorted(m);
    need_sort = true;
  }
 
  /* need to open the file for writing in such a way that it does not truncate
   * the file, so use read-write mode.  */
  adata->fp = freopen(mailbox_path(m), "r+", adata->fp);
  if (!adata->fp)
  {
    mx_fastclose_mailbox(m, false);
    mutt_error(_("Fatal error!  Could not reopen mailbox!"));
    goto fatal;
  }
 
  mutt_sig_block();
 
  if (mbox_lock_mailbox(m, true, true) == -1)
  {
    mutt_sig_unblock();
    mutt_error(_("Unable to lock mailbox"));
    goto bail;
  }
 
  /* Check to make sure that the file hasn't changed on disk */
  enum MxStatus check = mbox_mbox_check(m);
  if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
  {
    /* new mail arrived, or mailbox reopened */
    rc = check;
    goto bail;
  }
  else if (check < 0)
  {
    goto fatal;
  }
 
  /* Create a temporary file to write the new version of the mailbox in. */
  tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  int fd = open(buf_string(tempfile), O_WRONLY | O_EXCL | O_CREAT, 0600);
  if ((fd == -1) || !(fp = fdopen(fd, "w")))
  {
    if (fd != -1)
    {
      close(fd);
      unlink_tempfile = true;
    }
    mutt_error(_("Could not create temporary file"));
    goto bail;
  }
  unlink_tempfile = true;
 
  /* find the first deleted/changed message.  we save a lot of time by only
   * rewriting the mailbox from the point where it has actually changed.  */
  int i = 0;
  for (; (i < m->msg_count) && !m->emails[i]->deleted &&
         !m->emails[i]->changed && !m->emails[i]->attach_del;
       i++)
  {
  }
  if (i == m->msg_count)
  {
    /* this means m->changed or m->msg_deleted was set, but no
     * messages were found to be changed or deleted.  This should
     * never happen, is we presume it is a bug in neomutt.  */
    mutt_error(_("sync: mbox modified, but no modified messages (report this bug)"));
    mutt_debug(LL_DEBUG1, "no modified messages\n");
    goto bail;
  }
 
  /* save the index of the first changed/deleted message */
  first = i;
  /* where to start overwriting */
  offset = m->emails[i]->offset;
 
  /* the offset stored in the header does not include the MMDF_SEP, so make
   * sure we seek to the correct location */
  if (m->type == MUTT_MMDF)
    offset -= (sizeof(MMDF_SEP) - 1);
 
  /* allocate space for the new offsets */
  new_offset = MUTT_MEM_CALLOC(m->msg_count - first, struct MUpdate);
  old_offset = MUTT_MEM_CALLOC(m->msg_count - first, struct MUpdate);
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_WRITE, m->msg_count);
    progress_set_message(progress, _("Writing %s..."), mailbox_path(m));
  }
 
  for (i = first, j = 0; i < m->msg_count; i++)
  {
    progress_update(progress, i, i / (m->msg_count / 100 + 1));
    /* back up some information which is needed to restore offsets when
     * something fails.  */
 
    old_offset[i - first].valid = true;
    old_offset[i - first].hdr = m->emails[i]->offset;
    old_offset[i - first].body = m->emails[i]->body->offset;
    old_offset[i - first].lines = m->emails[i]->lines;
    old_offset[i - first].length = m->emails[i]->body->length;
 
    if (!m->emails[i]->deleted)
    {
      j++;
 
      if (m->type == MUTT_MMDF)
      {
        if (fputs(MMDF_SEP, fp) == EOF)
        {
          mutt_perror("%s", buf_string(tempfile));
          goto bail;
        }
      }
 
      /* save the new offset for this message.  we add 'offset' because the
       * temporary file only contains saved message which are located after
       * 'offset' in the real mailbox */
      new_offset[i - first].hdr = ftello(fp) + offset;
 
      struct Message *msg = mx_msg_open(m, m->emails[i]);
      const int rc2 = mutt_copy_message(fp, m->emails[i], msg, MUTT_CM_UPDATE,
                                        CH_FROM | CH_UPDATE | CH_UPDATE_LEN, 0);
      mx_msg_close(m, &msg);
      if (rc2 != 0)
      {
        mutt_perror("%s", buf_string(tempfile));
        goto bail;
      }
 
      /* Since messages could have been deleted, the offsets stored in memory
       * will be wrong, so update what we can, which is the offset of this
       * message, and the offset of the body.  If this is a multipart message,
       * we just flush the in memory cache so that the message will be reparsed
       * if the user accesses it later.  */
      new_offset[i - first].body = ftello(fp) - m->emails[i]->body->length + offset;
      mutt_body_free(&m->emails[i]->body->parts);
 
      if (m->type == MUTT_MMDF)
      {
        if (fputs(MMDF_SEP, fp) == EOF)
        {
          mutt_perror("%s", buf_string(tempfile));
          goto bail;
        }
      }
      else
      {
        if (fputs("\n", fp) == EOF)
        {
          mutt_perror("%s", buf_string(tempfile));
          goto bail;
        }
      }
    }
  }
 
  if (mutt_file_fclose(&fp) != 0)
  {
    mutt_debug(LL_DEBUG1, "mutt_file_fclose (&) returned non-zero\n");
    mutt_perror("%s", buf_string(tempfile));
    goto bail;
  }
 
  /* Save the state of this folder. */
  if (stat(mailbox_path(m), &st) == -1)
  {
    mutt_perror("%s", mailbox_path(m));
    goto bail;
  }
 
  unlink_tempfile = false;
 
  fp = mutt_file_fopen(buf_string(tempfile), "r");
  if (!fp)
  {
    mutt_sig_unblock();
    mx_fastclose_mailbox(m, false);
    mutt_debug(LL_DEBUG1, "unable to reopen temp copy of mailbox!\n");
    mutt_perror("%s", buf_string(tempfile));
    FREE(&new_offset);
    FREE(&old_offset);
    goto fatal;
  }
 
  if (!mutt_file_seek(adata->fp, offset, SEEK_SET) || /* seek the append location */
      /* do a sanity check to make sure the mailbox looks ok */
      !fgets(buf, sizeof(buf), adata->fp) ||
      ((m->type == MUTT_MBOX) && !mutt_str_startswith(buf, "From ")) ||
      ((m->type == MUTT_MMDF) && !mutt_str_equal(MMDF_SEP, buf)))
  {
    mutt_debug(LL_DEBUG1, "message not in expected position\n");
    mutt_debug(LL_DEBUG1, "    LINE: %s\n", buf);
    i = -1;
  }
  else
  {
    if (!mutt_file_seek(adata->fp, offset, SEEK_SET)) /* return to proper offset */
    {
      i = -1;
    }
    else
    {
      /* copy the temp mailbox back into place starting at the first
       * change/deleted message */
      if (m->verbose)
        mutt_message(_("Committing changes..."));
      i = mutt_file_copy_stream(fp, adata->fp);
 
      if (ferror(adata->fp))
        i = -1;
    }
    if (i >= 0)
    {
      m->size = ftello(adata->fp); /* update the mailbox->size of the mailbox */
      if ((m->size < 0) || (ftruncate(fileno(adata->fp), m->size) != 0))
      {
        i = -1;
        mutt_debug(LL_DEBUG1, "ftruncate() failed\n");
      }
    }
  }
 
  mutt_file_fclose(&fp);
  mbox_unlock_mailbox(m);
 
  if ((mutt_file_fclose(&adata->fp) != 0) || (i == -1))
  {
    /* error occurred while writing the mailbox back, so keep the temp copy around */
 
    struct Buffer *savefile = buf_pool_get();
 
    const char *const c_tmp_dir = cs_subset_path(NeoMutt->sub, "tmp_dir");
    buf_printf(savefile, "%s/neomutt.%s-%s-%u", NONULL(c_tmp_dir),
               NONULL(NeoMutt->username), NONULL(ShortHostname), (unsigned int) getpid());
    rename(buf_string(tempfile), buf_string(savefile));
    mutt_sig_unblock();
    mx_fastclose_mailbox(m, false);
    pretty_mailbox(savefile);
    mutt_error(_("Write failed!  Saved partial mailbox to %s"), buf_string(savefile));
    buf_pool_release(&savefile);
    FREE(&new_offset);
    FREE(&old_offset);
    goto fatal;
  }
 
  /* Restore the previous access/modification times */
  mbox_reset_atime(m, &st);
 
  /* reopen the mailbox in read-only mode */
  adata->fp = mbox_open_readwrite(m);
  if (!adata->fp)
  {
    adata->fp = mbox_open_readonly(m);
  }
  if (!adata->fp)
  {
    unlink(buf_string(tempfile));
    mutt_sig_unblock();
    mx_fastclose_mailbox(m, false);
    mutt_error(_("Fatal error!  Could not reopen mailbox!"));
    FREE(&new_offset);
    FREE(&old_offset);
    goto fatal;
  }
 
  /* update the offsets of the rewritten messages */
  for (i = first, j = first; i < m->msg_count; i++)
  {
    if (!m->emails[i]->deleted)
    {
      m->emails[i]->offset = new_offset[i - first].hdr;
      m->emails[i]->body->hdr_offset = new_offset[i - first].hdr;
      m->emails[i]->body->offset = new_offset[i - first].body;
      m->emails[i]->index = j++;
    }
  }
  FREE(&new_offset);
  FREE(&old_offset);
  unlink(buf_string(tempfile)); /* remove partial copy of the mailbox */
  buf_pool_release(&tempfile);
  mutt_sig_unblock();
 
  const bool c_check_mbox_size = cs_subset_bool(NeoMutt->sub, "check_mbox_size");
  if (c_check_mbox_size)
  {
    struct Mailbox *m_tmp = mailbox_find(mailbox_path(m));
    if (m_tmp && !m_tmp->has_new)
      mailbox_update(m_tmp);
  }
 
  progress_free(&progress);
  return 0; /* signal success */
 
bail: /* Come here in case of disaster */
 
  mutt_file_fclose(&fp);
 
  if (tempfile && unlink_tempfile)
    unlink(buf_string(tempfile));
 
  /* restore offsets, as far as they are valid */
  if ((first >= 0) && old_offset)
  {
    for (i = first; (i < m->msg_count) && old_offset[i - first].valid; i++)
    {
      m->emails[i]->offset = old_offset[i - first].hdr;
      m->emails[i]->body->hdr_offset = old_offset[i - first].hdr;
      m->emails[i]->body->offset = old_offset[i - first].body;
      m->emails[i]->lines = old_offset[i - first].lines;
      m->emails[i]->body->length = old_offset[i - first].length;
    }
  }
 
  /* this is ok to call even if we haven't locked anything */
  mbox_unlock_mailbox(m);
 
  mutt_sig_unblock();
  FREE(&new_offset);
  FREE(&old_offset);
 
  adata->fp = freopen(mailbox_path(m), "r", adata->fp);
  if (!adata->fp)
  {
    mutt_error(_("Could not reopen mailbox"));
    mx_fastclose_mailbox(m, false);
    goto fatal;
  }
 
  mailbox_changed(m, NT_MAILBOX_UPDATE);
  if (need_sort)
  {
    /* if the mailbox was reopened, the thread tree will be invalid so make
     * sure to start threading from scratch.  */
    mailbox_changed(m, NT_MAILBOX_RESORT);
  }
 
fatal:
  buf_pool_release(&tempfile);
  progress_free(&progress);
  return rc;
}

Here is the call graph for this function:

mh_mbox_sync()

static enum MxStatus mh_mbox_sync ( struct Mailbox * m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Return values

MX_STATUS_REOPENED	mailbox has been externally modified
MX_STATUS_NEW_MAIL	new mail has arrived
0	Success
-1	Error

Note

The flag retvals come from a call to a backend sync function

Definition at line 1062 of file mh.c.

{
  enum MxStatus check = mh_check(m);
  if (check == MX_STATUS_ERROR)
    return check;
 
  struct HeaderCache *hc = NULL;
#ifdef USE_HCACHE
  const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  hc = hcache_open(c_header_cache, mailbox_path(m), NULL, true);
#endif
 
  struct Progress *progress = NULL;
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_WRITE, m->msg_count);
    progress_set_message(progress, _("Writing %s..."), mailbox_path(m));
  }
 
  for (int i = 0; i < m->msg_count; i++)
  {
    progress_update(progress, i, -1);
 
    struct Email *e = m->emails[i];
    if (mh_sync_mailbox_message(m, e, hc) == -1)
    {
      progress_free(&progress);
      goto err;
    }
  }
  progress_free(&progress);
 
#ifdef USE_HCACHE
  hcache_close(&hc);
#endif
 
  mh_seq_update(m);
 
  /* XXX race condition? */
 
  mh_update_mtime(m);
 
  /* adjust indices */
 
  if (m->msg_deleted)
  {
    for (int i = 0, j = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
 
      if (!e->deleted)
        e->index = j++;
    }
  }
 
  return check;
 
err:
#ifdef USE_HCACHE
  hcache_close(&hc);
#endif
  return MX_STATUS_ERROR;
}

Here is the call graph for this function:

nntp_mbox_sync()

static enum MxStatus nntp_mbox_sync ( struct Mailbox * m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Note

May also return values from check_mailbox()

Definition at line 2561 of file nntp.c.

{
  struct NntpMboxData *mdata = m->mdata;
 
  /* check for new articles */
  mdata->adata->check_time = 0;
  enum MxStatus check = check_mailbox(m);
  if (check != MX_STATUS_OK)
    return check;
 
#ifdef USE_HCACHE
  mdata->last_cached = 0;
  struct HeaderCache *hc = nntp_hcache_open(mdata);
#endif
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    char buf[16] = { 0 };
 
    snprintf(buf, sizeof(buf), ANUM_FMT, nntp_edata_get(e)->article_num);
    if (mdata->bcache && e->deleted)
    {
      mutt_debug(LL_DEBUG2, "mutt_bcache_del %s\n", buf);
      mutt_bcache_del(mdata->bcache, buf);
    }
 
#ifdef USE_HCACHE
    if (hc && (e->changed || e->deleted))
    {
      if (e->deleted && !e->read)
        mdata->unread--;
      mutt_debug(LL_DEBUG2, "hcache_store_email %s\n", buf);
      hcache_store_email(hc, buf, strlen(buf), e, 0);
    }
#endif
  }
 
#ifdef USE_HCACHE
  if (hc)
  {
    hcache_close(&hc);
    mdata->last_cached = mdata->last_loaded;
  }
#endif
 
  /* save .newsrc entries */
  nntp_newsrc_gen_entries(m);
  nntp_newsrc_update(mdata->adata);
  nntp_newsrc_close(mdata->adata);
  return MX_STATUS_OK;
}

Here is the call graph for this function:

nm_mbox_sync()

static enum MxStatus nm_mbox_sync ( struct Mailbox * m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Definition at line 2278 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return MX_STATUS_ERROR;
 
  enum MxStatus rc = MX_STATUS_OK;
  struct Progress *progress = NULL;
  char *url = mutt_str_dup(mailbox_path(m));
  bool changed = false;
 
  mutt_debug(LL_DEBUG1, "nm: sync start\n");
 
  if (m->verbose)
  {
    /* all is in this function so we don't use data->progress here */
    progress = progress_new(MUTT_PROGRESS_WRITE, m->msg_count);
    progress_set_message(progress, _("Writing %s..."), mailbox_path(m));
  }
 
  struct HeaderCache *hc = nm_hcache_open(m);
 
  int mh_sync_errors = 0;
  for (int i = 0; i < m->msg_count; i++)
  {
    char old_file[PATH_MAX], new_file[PATH_MAX];
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    struct NmEmailData *edata = nm_edata_get(e);
 
    progress_update(progress, i, -1);
 
    *old_file = '\0';
    *new_file = '\0';
 
    if (edata->oldpath)
    {
      mutt_str_copy(old_file, edata->oldpath, sizeof(old_file));
      mutt_debug(LL_DEBUG2, "nm: fixing obsolete path '%s'\n", old_file);
    }
    else
    {
      email_get_fullpath(e, old_file, sizeof(old_file));
    }
 
    buf_strcpy(&m->pathbuf, edata->folder);
    m->type = edata->type;
 
    bool ok = maildir_sync_mailbox_message(m, e, hc);
    if (!ok)
    {
      // Syncing file failed, query notmuch for new filepath.
      m->type = MUTT_NOTMUCH;
      notmuch_database_t *db = nm_db_get(m, true);
      if (db)
      {
        notmuch_message_t *msg = get_nm_message(db, e);
 
        sync_email_path_with_nm(e, msg);
 
        buf_strcpy(&m->pathbuf, edata->folder);
        m->type = edata->type;
        ok = maildir_sync_mailbox_message(m, e, hc);
        m->type = MUTT_NOTMUCH;
      }
      nm_db_release(m);
      m->type = edata->type;
    }
 
    buf_strcpy(&m->pathbuf, url);
    m->type = MUTT_NOTMUCH;
 
    if (!ok)
    {
      mh_sync_errors += 1;
      continue;
    }
 
    if (!e->deleted)
      email_get_fullpath(e, new_file, sizeof(new_file));
 
    if (e->deleted || !mutt_str_equal(old_file, new_file))
    {
      if (e->deleted && (remove_filename(m, old_file) == 0))
        changed = true;
      else if (*new_file && *old_file && (rename_filename(m, old_file, new_file, e) == 0))
        changed = true;
    }
 
    FREE(&edata->oldpath);
  }
 
  if (mh_sync_errors > 0)
  {
    mutt_error(ngettext("Unable to sync %d message due to external mailbox modification",
                        "Unable to sync %d messages due to external mailbox modification",
                        mh_sync_errors),
               mh_sync_errors);
    rc = MX_STATUS_ERROR;
  }
 
  buf_strcpy(&m->pathbuf, url);
  m->type = MUTT_NOTMUCH;
 
  nm_db_release(m);
 
  if (changed)
  {
    mdata->mtime.tv_sec = mutt_date_now();
    mdata->mtime.tv_nsec = 0;
  }
 
  nm_hcache_close(&hc);
 
  progress_free(&progress);
  FREE(&url);
  mutt_debug(LL_DEBUG1, "nm: .... sync done [rc=%d]\n", rc);
  return rc;
}

Here is the call graph for this function:

pop_mbox_sync()

static enum MxStatus pop_mbox_sync ( struct Mailbox * m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync() -.

Update POP mailbox, delete messages from server

Definition at line 864 of file pop.c.

{
  int i, j, rc = 0;
  char buf[1024] = { 0 };
  struct PopAccountData *adata = pop_adata_get(m);
#ifdef USE_HCACHE
  struct HeaderCache *hc = NULL;
#endif
 
  adata->check_time = 0;
 
  int num_deleted = 0;
  for (i = 0; i < m->msg_count; i++)
  {
    if (m->emails[i]->deleted)
      num_deleted++;
  }
 
  while (true)
  {
    if (pop_reconnect(m) < 0)
      return MX_STATUS_ERROR;
 
#ifdef USE_HCACHE
    hc = pop_hcache_open(adata, mailbox_path(m));
#endif
 
    struct Progress *progress = NULL;
    if (m->verbose)
    {
      progress = progress_new(MUTT_PROGRESS_WRITE, num_deleted);
      progress_set_message(progress, _("Marking messages deleted..."));
    }
 
    for (i = 0, j = 0, rc = 0; (rc == 0) && (i < m->msg_count); i++)
    {
      struct PopEmailData *edata = pop_edata_get(m->emails[i]);
      if (m->emails[i]->deleted && (edata->refno != -1))
      {
        j++;
        progress_update(progress, j, -1);
        snprintf(buf, sizeof(buf), "DELE %d\r\n", edata->refno);
        rc = pop_query(adata, buf, sizeof(buf));
        if (rc == 0)
        {
          mutt_bcache_del(adata->bcache, cache_id(edata->uid));
#ifdef USE_HCACHE
          hcache_delete_email(hc, edata->uid, strlen(edata->uid));
#endif
        }
      }
 
#ifdef USE_HCACHE
      if (m->emails[i]->changed)
      {
        hcache_store_email(hc, edata->uid, strlen(edata->uid), m->emails[i], 0);
      }
#endif
    }
    progress_free(&progress);
 
#ifdef USE_HCACHE
    hcache_close(&hc);
#endif
 
    if (rc == 0)
    {
      mutt_str_copy(buf, "QUIT\r\n", sizeof(buf));
      rc = pop_query(adata, buf, sizeof(buf));
    }
 
    if (rc == 0)
    {
      adata->clear_cache = true;
      pop_clear_cache(adata);
      adata->status = POP_DISCONNECTED;
      return MX_STATUS_OK;
    }
 
    if (rc == -2)
    {
      mutt_error("%s", adata->err_msg);
      return MX_STATUS_ERROR;
    }
  }
}

Here is the call graph for this function: