mbox_open()

Open a Mailbox. More...

Collaboration diagram for mbox_open():

Functions
static enum MxOpenReturns	comp_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxOpenReturns	imap_mbox_open (struct Mailbox *m)
	Open a mailbox - Implements MxOps::mbox_open() -.
enum MxOpenReturns	maildir_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxOpenReturns	mbox_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxOpenReturns	mh_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxOpenReturns	nntp_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxOpenReturns	nm_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxOpenReturns	pop_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.

Detailed Description

Open a Mailbox.

Parameters

m	Mailbox to open

Return values

enum	MxOpenReturns

Precondition

m is not NULL

Function Documentation

comp_mbox_open()

static enum MxOpenReturns comp_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open() -.

Set up a compressed mailbox to be read. Decompress the mailbox and set up the paths and hooks needed. Then determine the type of the mailbox so we can delegate the handling of messages.

Definition at line 413 of file compress.c.

{
  struct CompressInfo *ci = set_compress_info(m);
  if (!ci)
    return MX_OPEN_ERROR;
 
  /* If there's no close-hook, or the file isn't writable */
  if (!ci->cmd_close || (access(mailbox_path(m), W_OK) != 0))
    m->readonly = true;
 
  if (setup_paths(m) != 0)
    goto cmo_fail;
  store_size(m);
 
  if (!lock_realpath(m, false))
  {
    mutt_error(_("Unable to lock mailbox"));
    goto cmo_fail;
  }
 
  if (!execute_command(m, ci->cmd_open, _("Decompressing %s")))
    goto cmo_fail;
 
  unlock_realpath(m);
 
  m->type = mx_path_probe(mailbox_path(m));
  if (m->type == MUTT_UNKNOWN)
  {
    mutt_error(_("Can't identify the contents of the compressed file"));
    goto cmo_fail;
  }
 
  ci->child_ops = mx_get_ops(m->type);
  if (!ci->child_ops)
  {
    mutt_error(_("Can't find mailbox ops for mailbox type %d"), m->type);
    goto cmo_fail;
  }
 
  m->account->type = m->type;
  return ci->child_ops->mbox_open(m);
 
cmo_fail:
  /* remove the partial uncompressed file */
  (void) remove(mailbox_path(m));
  compress_info_free(m);
  return MX_OPEN_ERROR;
}

Here is the call graph for this function:

imap_mbox_open()

static enum MxOpenReturns imap_mbox_open ( struct Mailbox *  m )

static

Open a mailbox - Implements MxOps::mbox_open() -.

Definition at line 1872 of file imap.c.

{
  if (!m->account || !m->mdata)
    return MX_OPEN_ERROR;
 
  char buf[PATH_MAX] = { 0 };
  int count = 0;
  int rc;
 
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
 
  mutt_debug(LL_DEBUG3, "opening %s, saving %s\n", m->pathbuf.data,
             (adata->mailbox ? adata->mailbox->pathbuf.data : "(none)"));
  adata->prev_mailbox = adata->mailbox;
  adata->mailbox = m;
 
  /* clear mailbox status */
  adata->status = 0;
  m->rights = 0;
  mdata->new_mail_count = 0;
 
  if (m->verbose)
    mutt_message(_("Selecting %s..."), mdata->name);
 
  /* pipeline ACL test */
  if (adata->capabilities & IMAP_CAP_ACL)
  {
    snprintf(buf, sizeof(buf), "MYRIGHTS %s", mdata->munge_name);
    imap_exec(adata, buf, IMAP_CMD_QUEUE);
  }
  else
  {
    /* assume we have all rights if ACL is unavailable */
    m->rights |= MUTT_ACL_LOOKUP | MUTT_ACL_READ | MUTT_ACL_SEEN | MUTT_ACL_WRITE |
                 MUTT_ACL_INSERT | MUTT_ACL_POST | MUTT_ACL_CREATE | MUTT_ACL_DELETE;
  }
 
  /* pipeline the postponed count if possible */
  const char *const c_postponed = cs_subset_string(NeoMutt->sub, "postponed");
  struct Mailbox *m_postponed = mx_mbox_find2(c_postponed);
  struct ImapAccountData *postponed_adata = imap_adata_get(m_postponed);
  if (postponed_adata &&
      imap_account_match(&postponed_adata->conn->account, &adata->conn->account))
  {
    imap_mailbox_status(m_postponed, true);
  }
 
  const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
  if (c_imap_check_subscribed)
    imap_exec(adata, "LSUB \"\" \"*\"", IMAP_CMD_QUEUE);
 
  imap_mbox_select(m);
 
  do
  {
    char *pc = NULL;
 
    rc = imap_cmd_step(adata);
    if (rc != IMAP_RES_CONTINUE)
      break;
 
    if (!mutt_strn_equal(adata->buf, "* ", 2))
      continue;
    pc = imap_next_word(adata->buf);
 
    /* Obtain list of available flags here, may be overridden by a
     * PERMANENTFLAGS tag in the OK response */
    if (mutt_istr_startswith(pc, "FLAGS"))
    {
      /* don't override PERMANENTFLAGS */
      if (STAILQ_EMPTY(&mdata->flags))
      {
        mutt_debug(LL_DEBUG3, "Getting mailbox FLAGS\n");
        pc = get_flags(&mdata->flags, pc);
        if (!pc)
          goto fail;
      }
    }
    else if (mutt_istr_startswith(pc, "OK [PERMANENTFLAGS"))
    {
      /* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
      mutt_debug(LL_DEBUG3, "Getting mailbox PERMANENTFLAGS\n");
      /* safe to call on NULL */
      mutt_list_free(&mdata->flags);
      /* skip "OK [PERMANENT" so syntax is the same as FLAGS */
      pc += 13;
      pc = get_flags(&(mdata->flags), pc);
      if (!pc)
        goto fail;
    }
    else if (mutt_istr_startswith(pc, "OK [UIDVALIDITY"))
    {
      /* save UIDVALIDITY for the header cache */
      mutt_debug(LL_DEBUG3, "Getting mailbox UIDVALIDITY\n");
      pc += 3;
      pc = imap_next_word(pc);
      if (!mutt_str_atoui(pc, &mdata->uidvalidity))
        goto fail;
    }
    else if (mutt_istr_startswith(pc, "OK [UIDNEXT"))
    {
      mutt_debug(LL_DEBUG3, "Getting mailbox UIDNEXT\n");
      pc += 3;
      pc = imap_next_word(pc);
      if (!mutt_str_atoui(pc, &mdata->uid_next))
        goto fail;
    }
    else if (mutt_istr_startswith(pc, "OK [HIGHESTMODSEQ"))
    {
      mutt_debug(LL_DEBUG3, "Getting mailbox HIGHESTMODSEQ\n");
      pc += 3;
      pc = imap_next_word(pc);
      if (!mutt_str_atoull(pc, &mdata->modseq))
        goto fail;
    }
    else if (mutt_istr_startswith(pc, "OK [NOMODSEQ"))
    {
      mutt_debug(LL_DEBUG3, "Mailbox has NOMODSEQ set\n");
      mdata->modseq = 0;
    }
    else
    {
      pc = imap_next_word(pc);
      if (mutt_istr_startswith(pc, "EXISTS"))
      {
        count = mdata->new_mail_count;
        mdata->new_mail_count = 0;
      }
    }
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc == IMAP_RES_NO)
  {
    char *s = imap_next_word(adata->buf); /* skip seq */
    s = imap_next_word(s);                /* Skip response */
    mutt_error("%s", s);
    goto fail;
  }
 
  if (rc != IMAP_RES_OK)
    goto fail;
 
  /* check for READ-ONLY notification */
  if (mutt_istr_startswith(imap_get_qualifier(adata->buf), "[READ-ONLY]") &&
      !(adata->capabilities & IMAP_CAP_ACL))
  {
    mutt_debug(LL_DEBUG2, "Mailbox is read-only\n");
    m->readonly = true;
  }
 
  /* dump the mailbox flags we've found */
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  if (c_debug_level > LL_DEBUG2)
  {
    if (STAILQ_EMPTY(&mdata->flags))
    {
      mutt_debug(LL_DEBUG3, "No folder flags found\n");
    }
    else
    {
      struct ListNode *np = NULL;
      struct Buffer *flag_buffer = buf_pool_get();
      buf_printf(flag_buffer, "Mailbox flags: ");
      STAILQ_FOREACH(np, &mdata->flags, entries)
      {
        buf_add_printf(flag_buffer, "[%s] ", np->data);
      }
      mutt_debug(LL_DEBUG3, "%s\n", buf_string(flag_buffer));
      buf_pool_release(&flag_buffer);
    }
  }
 
  if (!((m->rights & MUTT_ACL_DELETE) || (m->rights & MUTT_ACL_SEEN) ||
        (m->rights & MUTT_ACL_WRITE) || (m->rights & MUTT_ACL_INSERT)))
  {
    m->readonly = true;
  }
 
  mx_alloc_memory(m, count);
 
  m->msg_count = 0;
  m->msg_unread = 0;
  m->msg_flagged = 0;
  m->msg_new = 0;
  m->msg_deleted = 0;
  m->size = 0;
  m->vcount = 0;
 
  if ((count > 0) && (imap_read_headers(m, 1, count, true) < 0))
  {
    mutt_error(_("Error opening mailbox"));
    goto fail;
  }
 
  mutt_debug(LL_DEBUG2, "msg_count is %d\n", m->msg_count);
  return MX_OPEN_OK;
 
fail:
  if (adata->state == IMAP_SELECTED)
    adata->state = IMAP_AUTHENTICATED;
  return MX_OPEN_ERROR;
}

Here is the call graph for this function:

maildir_mbox_open()

enum MxOpenReturns maildir_mbox_open

(

struct Mailbox *

m

)

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 740 of file mailbox.c.

{
  if ((maildir_read_dir(m, "new") == -1) || (maildir_read_dir(m, "cur") == -1))
    return MX_OPEN_ERROR;
 
  return MX_OPEN_OK;
}

Here is the call graph for this function:

mbox_mbox_open()

static enum MxOpenReturns mbox_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 828 of file mbox.c.

{
  if (init_mailbox(m) != 0)
    return MX_OPEN_ERROR;
 
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return MX_OPEN_ERROR;
 
  adata->fp = m->readonly ? NULL : mbox_open_readwrite(m);
  if (!adata->fp)
  {
    adata->fp = mbox_open_readonly(m);
  }
  if (!adata->fp)
  {
    mutt_perror("%s", mailbox_path(m));
    return MX_OPEN_ERROR;
  }
 
  mutt_sig_block();
  if (mbox_lock_mailbox(m, false, true) == -1)
  {
    mutt_sig_unblock();
    return MX_OPEN_ERROR;
  }
 
  m->has_new = true;
  enum MxOpenReturns rc = MX_OPEN_ERROR;
  if (m->type == MUTT_MBOX)
    rc = mbox_parse_mailbox(m);
  else if (m->type == MUTT_MMDF)
    rc = mmdf_parse_mailbox(m);
  else
    rc = MX_OPEN_ERROR;
 
  if (!mbox_has_new(m))
    m->has_new = false;
  clearerr(adata->fp); // Clear the EOF flag
  mutt_file_touch_atime(fileno(adata->fp));
 
  mbox_unlock_mailbox(m);
  mutt_sig_unblock();
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_mbox_open()

static enum MxOpenReturns mh_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 816 of file mh.c.

{
  return mh_read_dir(m) ? MX_OPEN_OK : MX_OPEN_ERROR;
}

Here is the call graph for this function:

nntp_mbox_open()

static enum MxOpenReturns nntp_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 2383 of file nntp.c.

{
  if (!m->account)
    return MX_OPEN_ERROR;
 
  char buf[8192] = { 0 };
  char server[1024] = { 0 };
  char *group = NULL;
  int rc;
  struct HeaderCache *hc = NULL;
  anum_t first = 0, last = 0, count = 0;
 
  struct Url *url = url_parse(mailbox_path(m));
  if (!url || !url->host || !url->path ||
      !((url->scheme == U_NNTP) || (url->scheme == U_NNTPS)))
  {
    url_free(&url);
    mutt_error(_("%s is an invalid newsgroup specification"), mailbox_path(m));
    return MX_OPEN_ERROR;
  }
 
  group = url->path;
  if (group[0] == '/') /* Skip a leading '/' */
    group++;
 
  url->path = strchr(url->path, '\0');
  url_tostring(url, server, sizeof(server), U_NO_FLAGS);
 
  mutt_account_hook(m->realpath);
  struct NntpAccountData *adata = m->account->adata;
  if (!adata)
    adata = CurrentNewsSrv;
  if (!adata)
  {
    adata = nntp_select_server(m, server, true);
    m->account->adata = adata;
    m->account->adata_free = nntp_adata_free;
  }
 
  if (!adata)
  {
    url_free(&url);
    return MX_OPEN_ERROR;
  }
  CurrentNewsSrv = adata;
 
  m->msg_count = 0;
  m->msg_unread = 0;
  m->vcount = 0;
 
  if (group[0] == '/')
    group++;
 
  /* find news group data structure */
  struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
  if (!mdata)
  {
    nntp_newsrc_close(adata);
    mutt_error(_("Newsgroup %s not found on the server"), group);
    url_free(&url);
    return MX_OPEN_ERROR;
  }
 
  m->rights &= ~MUTT_ACL_INSERT; // Clear the flag
  const bool c_save_unsubscribed = cs_subset_bool(NeoMutt->sub, "save_unsubscribed");
  if (!mdata->newsrc_ent && !mdata->subscribed && !c_save_unsubscribed)
    m->readonly = true;
 
  /* select newsgroup */
  mutt_message(_("Selecting %s..."), group);
  url_free(&url);
  buf[0] = '\0';
  if (nntp_query(mdata, buf, sizeof(buf)) < 0)
  {
    nntp_newsrc_close(adata);
    return MX_OPEN_ERROR;
  }
 
  /* newsgroup not found, remove it */
  if (mutt_str_startswith(buf, "411"))
  {
    mutt_error(_("Newsgroup %s has been removed from the server"), mdata->group);
    if (!mdata->deleted)
    {
      mdata->deleted = true;
      nntp_active_save_cache(adata);
    }
    if (mdata->newsrc_ent && !mdata->subscribed && !c_save_unsubscribed)
    {
      FREE(&mdata->newsrc_ent);
      mdata->newsrc_len = 0;
      nntp_delete_group_cache(mdata);
      nntp_newsrc_update(adata);
    }
  }
  else
  {
    /* parse newsgroup info */
    if (sscanf(buf, "211 " ANUM_FMT " " ANUM_FMT " " ANUM_FMT, &count, &first, &last) != 3)
    {
      nntp_newsrc_close(adata);
      mutt_error("GROUP: %s", buf);
      return MX_OPEN_ERROR;
    }
    mdata->first_message = first;
    mdata->last_message = last;
    mdata->deleted = false;
 
    /* get description if empty */
    const bool c_nntp_load_description = cs_subset_bool(NeoMutt->sub, "nntp_load_description");
    if (c_nntp_load_description && !mdata->desc)
    {
      if (get_description(mdata, NULL, NULL) < 0)
      {
        nntp_newsrc_close(adata);
        return MX_OPEN_ERROR;
      }
      if (mdata->desc)
        nntp_active_save_cache(adata);
    }
  }
 
  adata->check_time = mutt_date_now();
  m->mdata = mdata;
  // Every known newsgroup has an mdata which is stored in adata->groups_list.
  // Currently we don't let the Mailbox free the mdata.
  // m->mdata_free = nntp_mdata_free;
  if (!mdata->bcache && (mdata->newsrc_ent || mdata->subscribed || c_save_unsubscribed))
    mdata->bcache = mutt_bcache_open(&adata->conn->account, mdata->group);
 
  /* strip off extra articles if adding context is greater than $nntp_context */
  first = mdata->first_message;
  const long c_nntp_context = cs_subset_long(NeoMutt->sub, "nntp_context");
  if (c_nntp_context && ((mdata->last_message - first + 1) > c_nntp_context))
    first = mdata->last_message - c_nntp_context + 1;
  mdata->last_loaded = first ? first - 1 : 0;
  count = mdata->first_message;
  mdata->first_message = first;
  nntp_bcache_update(mdata);
  mdata->first_message = count;
#ifdef USE_HCACHE
  hc = nntp_hcache_open(mdata);
  nntp_hcache_update(mdata, hc);
#endif
  if (!hc)
    m->rights &= ~(MUTT_ACL_WRITE | MUTT_ACL_DELETE); // Clear the flags
 
  nntp_newsrc_close(adata);
  rc = nntp_fetch_headers(m, hc, first, mdata->last_message, false);
#ifdef USE_HCACHE
  hcache_close(&hc);
#endif
  if (rc < 0)
    return MX_OPEN_ERROR;
  mdata->last_loaded = mdata->last_message;
  adata->newsrc_modified = false;
  return MX_OPEN_OK;
}

Here is the call graph for this function:

nm_mbox_open()

static enum MxOpenReturns nm_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 2068 of file notmuch.c.

{
  if (init_mailbox(m) != 0)
    return MX_OPEN_ERROR;
 
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return MX_OPEN_ERROR;
 
  mutt_debug(LL_DEBUG1, "nm: reading messages...[current count=%d]\n", m->msg_count);
 
  progress_setup(m);
  enum MxOpenReturns rc = MX_OPEN_ERROR;
 
  notmuch_query_t *q = get_query(m, false);
  if (q)
  {
    rc = MX_OPEN_OK;
    switch (mdata->query_type)
    {
      case NM_QUERY_TYPE_UNKNOWN: // UNKNOWN should never occur, but MESGS is default
      case NM_QUERY_TYPE_MESGS:
        if (!read_mesgs_query(m, q, false))
          rc = MX_OPEN_ABORT;
        break;
      case NM_QUERY_TYPE_THREADS:
        if (!read_threads_query(m, q, false, get_limit(mdata)))
          rc = MX_OPEN_ABORT;
        break;
    }
    notmuch_query_destroy(q);
  }
 
  nm_db_release(m);
 
  mdata->mtime.tv_sec = mutt_date_now();
  mdata->mtime.tv_nsec = 0;
 
  mdata->oldmsgcount = 0;
 
  mutt_debug(LL_DEBUG1, "nm: reading messages... done [rc=%d, count=%d]\n", rc, m->msg_count);
  progress_free(&mdata->progress);
  return rc;
}

Here is the call graph for this function:

pop_mbox_open()

static enum MxOpenReturns pop_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open() -.

Fetch only headers

Definition at line 740 of file pop.c.

{
  if (!m->account)
    return MX_OPEN_ERROR;
 
  char buf[PATH_MAX] = { 0 };
  struct ConnAccount cac = { { 0 } };
  struct Url url = { 0 };
 
  if (pop_parse_path(mailbox_path(m), &cac))
  {
    mutt_error(_("%s is an invalid POP path"), mailbox_path(m));
    return MX_OPEN_ERROR;
  }
 
  account_to_url(&cac, &url);
  url.path = NULL;
  url_tostring(&url, buf, sizeof(buf), U_NO_FLAGS);
 
  buf_strcpy(&m->pathbuf, buf);
  mutt_str_replace(&m->realpath, mailbox_path(m));
 
  struct PopAccountData *adata = m->account->adata;
  if (!adata)
  {
    adata = pop_adata_new();
    m->account->adata = adata;
    m->account->adata_free = pop_adata_free;
  }
 
  struct Connection *conn = adata->conn;
  if (!conn)
  {
    adata->conn = mutt_conn_new(&cac);
    conn = adata->conn;
    if (!conn)
      return MX_OPEN_ERROR;
  }
 
  if (conn->fd < 0)
    mutt_account_hook(m->realpath);
 
  if (pop_open_connection(adata) < 0)
    return MX_OPEN_ERROR;
 
  adata->bcache = mutt_bcache_open(&cac, NULL);
 
  /* init (hard-coded) ACL rights */
  m->rights = MUTT_ACL_SEEN | MUTT_ACL_DELETE;
#ifdef USE_HCACHE
  /* flags are managed using header cache, so it only makes sense to
   * enable them in that case */
  m->rights |= MUTT_ACL_WRITE;
#endif
 
  while (true)
  {
    if (pop_reconnect(m) < 0)
      return MX_OPEN_ERROR;
 
    m->size = adata->size;
 
    mutt_message(_("Fetching list of messages..."));
 
    const int rc = pop_fetch_headers(m);
 
    if (rc >= 0)
      return MX_OPEN_OK;
 
    if (rc < -1)
      return MX_OPEN_ERROR;
  }
}

Here is the call graph for this function: