mbox_close()

Close a Mailbox. More...

Collaboration diagram for mbox_close():

Functions
static enum MxStatus	comp_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static enum MxStatus	imap_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
enum MxStatus	maildir_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static enum MxStatus	mbox_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static enum MxStatus	mh_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static enum MxStatus	nntp_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static enum MxStatus	nm_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static enum MxStatus	pop_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.

Detailed Description

Close a Mailbox.

Parameters

m	Mailbox to close

Return values

enum

MxStatus

Precondition

m is not NULL

Function Documentation

comp_mbox_close()

static enum MxStatus comp_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

If the mailbox has been changed then re-compress the tmp file. Then delete the tmp file.

Definition at line 641 of file compress.c.

{
  if (!m->compress_info)
    return MX_STATUS_ERROR;
 
  struct CompressInfo *ci = m->compress_info;
 
  const struct MxOps *ops = ci->child_ops;
  if (!ops)
  {
    compress_info_free(m);
    return MX_STATUS_ERROR;
  }
 
  ops->mbox_close(m);
 
  /* sync has already been called, so we only need to delete some files */
  if (m->append)
  {
    const struct Expando *append = NULL;
    const char *msg = NULL;
 
    /* The file exists and we can append */
    if ((access(m->realpath, F_OK) == 0) && ci->cmd_append)
    {
      append = ci->cmd_append;
      msg = _("Compressed-appending to %s...");
    }
    else
    {
      append = ci->cmd_close;
      msg = _("Compressing %s");
    }
 
    if (!execute_command(m, append, msg))
    {
      mutt_any_key_to_continue(NULL);
      mutt_error(_("Error. Preserving temporary file: %s"), mailbox_path(m));
    }
    else
    {
      if (remove(mailbox_path(m)) < 0)
      {
        mutt_debug(LL_DEBUG1, "remove failed: %s: %s (errno %d)\n",
                   mailbox_path(m), strerror(errno), errno);
      }
    }
 
    unlock_realpath(m);
  }
  else
  {
    /* If the file was removed, remove the compressed folder too */
    if (access(mailbox_path(m), F_OK) != 0)
    {
      const bool c_save_empty = cs_subset_bool(NeoMutt->sub, "save_empty");
      if (!c_save_empty)
      {
        if (remove(m->realpath) < 0)
        {
          mutt_debug(LL_DEBUG1, "remove failed: %s: %s (errno %d)\n",
                     m->realpath, strerror(errno), errno);
        }
      }
    }
    else
    {
      if (remove(mailbox_path(m)) < 0)
      {
        mutt_debug(LL_DEBUG1, "remove failed: %s: %s (errno %d)\n",
                   mailbox_path(m), strerror(errno), errno);
      }
    }
  }
 
  compress_info_free(m);
 
  return MX_STATUS_OK;
}

Here is the call graph for this function:

imap_mbox_close()

static enum MxStatus imap_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

Definition at line 2321 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
 
  /* Check to see if the mailbox is actually open */
  if (!adata || !mdata)
    return MX_STATUS_OK;
 
  /* imap_mbox_open_append() borrows the struct ImapAccountData temporarily,
   * just for the connection.
   *
   * So when these are equal, it means we are actually closing the
   * mailbox and should clean up adata.  Otherwise, we don't want to
   * touch adata - it's still being used.  */
  if (m == adata->mailbox)
  {
    if ((adata->status != IMAP_FATAL) && (adata->state >= IMAP_SELECTED))
    {
      /* mx_mbox_close won't sync if there are no deleted messages
       * and the mailbox is unchanged, so we may have to close here */
      if (m->msg_deleted == 0)
      {
        adata->closing = true;
        imap_exec(adata, "CLOSE", IMAP_CMD_NO_FLAGS);
      }
      adata->state = IMAP_AUTHENTICATED;
    }
 
    mutt_debug(LL_DEBUG3, "closing %s, restoring %p\n", m->pathbuf.data,
               (void *) adata->prev_mailbox);
    adata->mailbox = adata->prev_mailbox;
    adata->prev_mailbox = NULL;
    imap_mbox_select(adata->mailbox);
    imap_mdata_cache_reset(m->mdata);
  }
 
  return MX_STATUS_OK;
}

Here is the call graph for this function:

maildir_mbox_close()

enum MxStatus maildir_mbox_close

(

struct Mailbox *

m

)

Close a Mailbox - Implements MxOps::mbox_close() -.

Return values

MX_STATUS_OK

Always

Definition at line 908 of file mailbox.c.

{
  return MX_STATUS_OK;
}

mbox_mbox_close()

static enum MxStatus mbox_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

Definition at line 1437 of file mbox.c.

{
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return MX_STATUS_ERROR;
 
  if (!adata->fp)
    return MX_STATUS_OK;
 
  if (adata->append)
  {
    mutt_file_unlock(fileno(adata->fp));
    mutt_sig_unblock();
  }
 
  mutt_file_fclose(&adata->fp);
 
  /* fix up the times so mailbox won't get confused */
  if (m->peekonly && !buf_is_empty(&m->pathbuf) &&
      (mutt_file_timespec_compare(&adata->mtime, &adata->atime) > 0))
  {
#ifdef HAVE_UTIMENSAT
    struct timespec ts[2] = { { 0 }, { 0 } };
    ts[0] = adata->atime;
    ts[1] = adata->mtime;
    utimensat(AT_FDCWD, mailbox_path(m), ts, 0);
#else
    struct utimbuf ut = { 0 };
    ut.actime = adata->atime.tv_sec;
    ut.modtime = adata->mtime.tv_sec;
    utime(mailbox_path(m), &ut);
#endif
  }
 
  return MX_STATUS_OK;
}

Here is the call graph for this function:

mh_mbox_close()

static enum MxStatus mh_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

Return values

MX_STATUS_OK

Always

Definition at line 1137 of file mh.c.

{
  return MX_STATUS_OK;
}

nntp_mbox_close()

static enum MxStatus nntp_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

Return values

0

Always

Definition at line 2625 of file nntp.c.

{
  struct NntpMboxData *mdata = m->mdata;
  struct NntpMboxData *tmp_mdata = NULL;
  if (!mdata)
    return MX_STATUS_OK;
 
  mdata->unread = m->msg_unread;
 
  nntp_acache_free(mdata);
  if (!mdata->adata || !mdata->adata->groups_hash || !mdata->group)
    return MX_STATUS_OK;
 
  tmp_mdata = mutt_hash_find(mdata->adata->groups_hash, mdata->group);
  if (!tmp_mdata || (tmp_mdata != mdata))
    nntp_mdata_free((void **) &mdata);
  return MX_STATUS_OK;
}

Here is the call graph for this function:

nm_mbox_close()

static enum MxStatus nm_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

Nothing to do.

Definition at line 2414 of file notmuch.c.

{
  return MX_STATUS_OK;
}

pop_mbox_close()

static enum MxStatus pop_mbox_close ( struct Mailbox * m )

static

Close a Mailbox - Implements MxOps::mbox_close() -.

Definition at line 955 of file pop.c.

{
  struct PopAccountData *adata = pop_adata_get(m);
  if (!adata)
    return MX_STATUS_OK;
 
  pop_logout(m);
 
  if (adata->status != POP_NONE)
  {
    mutt_socket_close(adata->conn);
  }
 
  adata->status = POP_NONE;
 
  adata->clear_cache = true;
  pop_clear_cache(adata);
 
  mutt_bcache_close(&adata->bcache);
 
  return MX_STATUS_OK;
}

Here is the call graph for this function: