msg_open()

Open an email message in a Mailbox. More...

Collaboration diagram for msg_open():

Functions
static bool	comp_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
bool	imap_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
bool	maildir_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	mbox_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	mh_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	nntp_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	nm_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	pop_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Detailed Description

Open an email message in a Mailbox.

Parameters

m	Mailbox
msg	Message to open
e	Email to open

Return values

true	Success
false	Error

Precondition

m is not NULL

msg is not NULL

e is not NULL

Function Documentation

comp_msg_open()

static bool comp_msg_open ( struct Mailbox * m, struct Message * msg, struct Email * e )

static

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 718 of file compress.c.

{
  if (!m->compress_info)
    return false;
 
  struct CompressInfo *ci = m->compress_info;
 
  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return false;
 
  /* Delegate */
  return ops->msg_open(m, msg, e);
}

imap_msg_open()

bool imap_msg_open	(	struct Mailbox *	m,
		struct Message *	msg,
		struct Email *	e )

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 1977 of file message.c.

{
  struct Envelope *newenv = NULL;
  char buf[1024] = { 0 };
  char *pc = NULL;
  unsigned int bytes;
  unsigned int uid;
  bool retried = false;
  bool read;
  int rc;
 
  /* Sam's weird courier server returns an OK response even when FETCH
   * fails. Thanks Sam. */
  bool fetched = false;
 
  struct ImapAccountData *adata = imap_adata_get(m);
 
  if (!adata || (adata->mailbox != m))
    return false;
 
  msg->fp = msg_cache_get(m, e);
  if (msg->fp)
  {
    if (imap_edata_get(e)->parsed)
      return true;
    goto parsemsg;
  }
 
  /* This function is called in a few places after endwin()
   * e.g. mutt_pipe_message(). */
  bool output_progress = !isendwin() && m->verbose;
  if (output_progress)
    mutt_message(_("Fetching message..."));
 
  msg->fp = msg_cache_put(m, e);
  if (!msg->fp)
  {
    struct Buffer *tempfile = buf_pool_get();
    buf_mktemp(tempfile);
    msg->fp = mutt_file_fopen(buf_string(tempfile), "w+");
    unlink(buf_string(tempfile));
    buf_pool_release(&tempfile);
 
    if (!msg->fp)
      return false;
  }
 
  /* 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
   * command handler */
  e->active = false;
 
  const bool c_imap_peek = cs_subset_bool(NeoMutt->sub, "imap_peek");
  snprintf(buf, sizeof(buf), "UID FETCH %u %s", imap_edata_get(e)->uid,
           ((adata->capabilities & IMAP_CAP_IMAP4REV1) ?
                (c_imap_peek ? "BODY.PEEK[]" : "BODY[]") :
                "RFC822"));
 
  imap_cmd_start(adata, buf);
  do
  {
    rc = imap_cmd_step(adata);
    if (rc != IMAP_RES_CONTINUE)
      break;
 
    pc = adata->buf;
    pc = imap_next_word(pc);
    pc = imap_next_word(pc);
 
    if (mutt_istr_startswith(pc, "FETCH"))
    {
      while (*pc)
      {
        pc = imap_next_word(pc);
        if (pc[0] == '(')
          pc++;
        if (mutt_istr_startswith(pc, "UID"))
        {
          pc = imap_next_word(pc);
          if (!mutt_str_atoui(pc, &uid))
            goto bail;
          if (uid != imap_edata_get(e)->uid)
          {
            mutt_error(_("The message index is incorrect. Try reopening the mailbox."));
          }
        }
        else if (mutt_istr_startswith(pc, "RFC822") || mutt_istr_startswith(pc, "BODY[]"))
        {
          pc = imap_next_word(pc);
          if (imap_get_literal_count(pc, &bytes) < 0)
          {
            imap_error("imap_msg_open()", buf);
            goto bail;
          }
 
          const int res = imap_read_literal(msg->fp, adata, bytes, NULL);
          if (res < 0)
          {
            goto bail;
          }
          /* pick up trailing line */
          rc = imap_cmd_step(adata);
          if (rc != IMAP_RES_CONTINUE)
            goto bail;
          pc = adata->buf;
 
          fetched = true;
        }
        else if (!e->changed && mutt_istr_startswith(pc, "FLAGS"))
        {
          /* UW-IMAP will provide a FLAGS update here if the FETCH causes a
           * change (eg from \Unseen to \Seen).
           * Uncommitted changes in neomutt take precedence. If we decide to
           * incrementally update flags later, this won't stop us syncing */
          pc = imap_set_flags(m, e, pc, NULL);
          if (!pc)
            goto bail;
        }
      }
    }
  } while (rc == IMAP_RES_CONTINUE);
 
  /* see comment before command start. */
  e->active = true;
 
  fflush(msg->fp);
  if (ferror(msg->fp))
    goto bail;
 
  if (rc != IMAP_RES_OK)
    goto bail;
 
  if (!fetched || !imap_code(adata->buf))
    goto bail;
 
  if (msg_cache_commit(m, e) < 0)
    mutt_debug(LL_DEBUG1, "failed to add message to cache\n");
 
parsemsg:
  /* Update the header information.  Previously, we only downloaded a
   * portion of the headers, those required for the main display.  */
  rewind(msg->fp);
  /* It may be that the Status header indicates a message is read, but the
   * IMAP server doesn't know the message has been \Seen. So we capture
   * the server's notion of 'read' and if it differs from the message info
   * picked up in mutt_rfc822_read_header, we mark the message (and context
   * changed). Another possibility: ignore Status on IMAP? */
  read = e->read;
  newenv = mutt_rfc822_read_header(msg->fp, e, false, false);
  mutt_env_merge(e->env, &newenv);
 
  /* see above. We want the new status in e->read, so we unset it manually
   * and let mutt_set_flag set it correctly, updating context. */
  if (read != e->read)
  {
    e->read = read;
    mutt_set_flag(m, e, MUTT_NEW, read, true);
  }
 
  e->lines = 0;
  while (fgets(buf, sizeof(buf), msg->fp) && !feof(msg->fp))
  {
    e->lines++;
  }
 
  e->body->length = ftell(msg->fp) - e->body->offset;
 
  mutt_clear_error();
  rewind(msg->fp);
  imap_edata_get(e)->parsed = true;
 
  /* retry message parse if cached message is empty */
  if (!retried && ((e->lines == 0) || (e->body->length == 0)))
  {
    imap_cache_del(m, e);
    retried = true;
    goto parsemsg;
  }
 
  return true;
 
bail:
  e->active = true;
  mutt_file_fclose(&msg->fp);
  imap_cache_del(m, e);
  return false;
}

Here is the call graph for this function:

maildir_msg_open()

bool maildir_msg_open	(	struct Mailbox *	m,
		struct Message *	msg,
		struct Email *	e )

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 504 of file message.c.

{
  char path[PATH_MAX] = { 0 };
 
  snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
 
  msg->fp = mutt_file_fopen(path, "r");
  if (!msg->fp && (errno == ENOENT))
    msg->fp = maildir_open_find_message(mailbox_path(m), e->path, NULL);
 
  if (!msg->fp)
  {
    mutt_perror("%s", path);
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

mbox_msg_open()

static bool mbox_msg_open ( struct Mailbox * m, struct Message * msg, struct Email * e )

static

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 1473 of file mbox.c.

{
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return false;
 
  msg->fp = mutt_file_fopen(mailbox_path(m), "r");
  if (!msg->fp)
    return false;
 
  return true;
}

Here is the call graph for this function:

mh_msg_open()

static bool mh_msg_open ( struct Mailbox * m, struct Message * msg, struct Email * e )

static

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 1141 of file mh.c.

{
  char path[PATH_MAX] = { 0 };
 
  snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
 
  msg->fp = mutt_file_fopen(path, "r");
  if (!msg->fp)
  {
    mutt_perror("%s", path);
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

nntp_msg_open()

static bool nntp_msg_open ( struct Mailbox * m, struct Message * msg, struct Email * e )

static

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 2645 of file nntp.c.

{
  struct NntpMboxData *mdata = m->mdata;
  char article[16] = { 0 };
 
  /* try to get article from cache */
  struct NntpAcache *acache = &mdata->acache[e->index % NNTP_ACACHE_LEN];
  if (acache->path)
  {
    if (acache->index == e->index)
    {
      msg->fp = mutt_file_fopen(acache->path, "r");
      if (msg->fp)
        return true;
    }
    else
    {
      /* clear previous entry */
      unlink(acache->path);
      FREE(&acache->path);
    }
  }
  snprintf(article, sizeof(article), ANUM_FMT, nntp_edata_get(e)->article_num);
  msg->fp = mutt_bcache_get(mdata->bcache, article);
  if (msg->fp)
  {
    if (nntp_edata_get(e)->parsed)
      return true;
  }
  else
  {
    /* don't try to fetch article from removed newsgroup */
    if (mdata->deleted)
      return false;
 
    /* create new cache file */
    const char *fetch_msg = _("Fetching message...");
    mutt_message("%s", fetch_msg);
    msg->fp = mutt_bcache_put(mdata->bcache, article);
    if (!msg->fp)
    {
      struct Buffer *tempfile = buf_pool_get();
      buf_mktemp(tempfile);
      acache->path = buf_strdup(tempfile);
      buf_pool_release(&tempfile);
      acache->index = e->index;
      msg->fp = mutt_file_fopen(acache->path, "w+");
      if (!msg->fp)
      {
        mutt_perror("%s", acache->path);
        unlink(acache->path);
        FREE(&acache->path);
        return false;
      }
    }
 
    /* fetch message to cache file */
    char buf[2048] = { 0 };
    snprintf(buf, sizeof(buf), "ARTICLE %s\r\n",
             nntp_edata_get(e)->article_num ? article : e->env->message_id);
    const int rc = nntp_fetch_lines(mdata, buf, sizeof(buf), NULL, fetch_tempfile, msg->fp);
    if (rc)
    {
      mutt_file_fclose(&msg->fp);
      if (acache->path)
      {
        unlink(acache->path);
        FREE(&acache->path);
      }
      if (rc > 0)
      {
        if (mutt_str_startswith(buf, nntp_edata_get(e)->article_num ? "423" : "430"))
        {
          mutt_error(_("Article %s not found on the server"),
                     nntp_edata_get(e)->article_num ? article : e->env->message_id);
        }
        else
        {
          mutt_error("ARTICLE: %s", buf);
        }
      }
      return false;
    }
 
    if (!acache->path)
      mutt_bcache_commit(mdata->bcache, article);
  }
 
  /* replace envelope with new one
   * hash elements must be updated because pointers will be changed */
  if (m->id_hash && e->env->message_id)
    mutt_hash_delete(m->id_hash, e->env->message_id, e);
  if (m->subj_hash && e->env->real_subj)
    mutt_hash_delete(m->subj_hash, e->env->real_subj, e);
 
  mutt_env_free(&e->env);
  e->env = mutt_rfc822_read_header(msg->fp, e, false, false);
 
  if (m->id_hash && e->env->message_id)
    mutt_hash_insert(m->id_hash, e->env->message_id, e);
  if (m->subj_hash && e->env->real_subj)
    mutt_hash_insert(m->subj_hash, e->env->real_subj, e);
 
  /* fix content length */
  if (!mutt_file_seek(msg->fp, 0, SEEK_END))
  {
    return false;
  }
  e->body->length = ftell(msg->fp) - e->body->offset;
 
  /* this is called in neomutt before the open which fetches the message,
   * which is probably wrong, but we just call it again here to handle
   * the problem instead of fixing it */
  nntp_edata_get(e)->parsed = true;
  mutt_parse_mime_message(e, msg->fp);
 
  /* these would normally be updated in mview_update(), but the
   * full headers aren't parsed with overview, so the information wasn't
   * available then */
  if (WithCrypto)
    e->security = crypt_query(e->body);
 
  rewind(msg->fp);
  mutt_clear_error();
  return true;
}

Here is the call graph for this function:

nm_msg_open()

static bool nm_msg_open ( struct Mailbox * m, struct Message * msg, struct Email * e )

static

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 2388 of file notmuch.c.

{
  char path[PATH_MAX] = { 0 };
  char *folder = nm_email_get_folder(e);
 
  snprintf(path, sizeof(path), "%s/%s", folder, e->path);
 
  msg->fp = mutt_file_fopen(path, "r");
  if (!msg->fp && (errno == ENOENT) && ((m->type == MUTT_MAILDIR) || (m->type == MUTT_NOTMUCH)))
  {
    msg->fp = maildir_open_find_message(folder, e->path, NULL);
  }
 
  return msg->fp != NULL;
}

Here is the call graph for this function:

pop_msg_open()

static bool pop_msg_open ( struct Mailbox * m, struct Message * msg, struct Email * e )

static

Open an email message in a Mailbox - Implements MxOps::msg_open() -.

Definition at line 975 of file pop.c.

{
  char buf[1024] = { 0 };
  struct PopAccountData *adata = pop_adata_get(m);
  struct PopEmailData *edata = pop_edata_get(e);
  bool bcache = true;
  bool success = false;
  struct Buffer *path = NULL;
 
  /* see if we already have the message in body cache */
  msg->fp = mutt_bcache_get(adata->bcache, cache_id(edata->uid));
  if (msg->fp)
    return true;
 
  /* see if we already have the message in our cache in
   * case $message_cache_dir is unset */
  struct PopCache *cache = &adata->cache[e->index % POP_CACHE_LEN];
 
  if (cache->path)
  {
    if (cache->index == e->index)
    {
      /* yes, so just return a pointer to the message */
      msg->fp = mutt_file_fopen(cache->path, "r");
      if (msg->fp)
        return true;
 
      mutt_perror("%s", cache->path);
      return false;
    }
    else
    {
      /* clear the previous entry */
      unlink(cache->path);
      FREE(&cache->path);
    }
  }
 
  path = buf_pool_get();
 
  while (true)
  {
    if (pop_reconnect(m) < 0)
      goto cleanup;
 
    /* verify that massage index is correct */
    if (edata->refno < 0)
    {
      mutt_error(_("The message index is incorrect. Try reopening the mailbox."));
      goto cleanup;
    }
 
    /* see if we can put in body cache; use our cache as fallback */
    msg->fp = mutt_bcache_put(adata->bcache, cache_id(edata->uid));
    if (!msg->fp)
    {
      /* no */
      bcache = false;
      buf_mktemp(path);
      msg->fp = mutt_file_fopen(buf_string(path), "w+");
      if (!msg->fp)
      {
        mutt_perror("%s", buf_string(path));
        goto cleanup;
      }
    }
 
    snprintf(buf, sizeof(buf), "RETR %d\r\n", edata->refno);
 
    struct Progress *progress = progress_new(MUTT_PROGRESS_NET,
                                             e->body->length + e->body->offset - 1);
    progress_set_message(progress, _("Fetching message..."));
    const int rc = pop_fetch_data(adata, buf, progress, fetch_message, msg->fp);
    progress_free(&progress);
 
    if (rc == 0)
      break;
 
    mutt_file_fclose(&msg->fp);
 
    /* if RETR failed (e.g. connection closed), be sure to remove either
     * the file in bcache or from POP's own cache since the next iteration
     * of the loop will re-attempt to put() the message */
    if (!bcache)
      unlink(buf_string(path));
 
    if (rc == -2)
    {
      mutt_error("%s", adata->err_msg);
      goto cleanup;
    }
 
    if (rc == -3)
    {
      mutt_error(_("Can't write message to temporary file"));
      goto cleanup;
    }
  }
 
  /* Update the header information.  Previously, we only downloaded a
   * portion of the headers, those required for the main display.  */
  if (bcache)
  {
    mutt_bcache_commit(adata->bcache, cache_id(edata->uid));
  }
  else
  {
    cache->index = e->index;
    cache->path = buf_strdup(path);
  }
  rewind(msg->fp);
 
  /* Detach the private data */
  e->edata = NULL;
 
  /* we replace envelope, key in subj_hash has to be updated as well */
  if (m->subj_hash && e->env->real_subj)
    mutt_hash_delete(m->subj_hash, e->env->real_subj, e);
  mutt_label_hash_remove(m, e);
  mutt_env_free(&e->env);
  e->env = mutt_rfc822_read_header(msg->fp, e, false, false);
  if (m->subj_hash && e->env->real_subj)
    mutt_hash_insert(m->subj_hash, e->env->real_subj, e);
  mutt_label_hash_add(m, e);
 
  /* Reattach the private data */
  e->edata = edata;
  e->edata_free = pop_edata_free;
 
  e->lines = 0;
  while (fgets(buf, sizeof(buf), msg->fp) && !feof(msg->fp))
  {
    e->lines++;
  }
 
  e->body->length = ftello(msg->fp) - e->body->offset;
 
  /* This needs to be done in case this is a multipart message */
  if (!WithCrypto)
    e->security = crypt_query(e->body);
 
  mutt_clear_error();
  rewind(msg->fp);
 
  success = true;
 
cleanup:
  buf_pool_release(&path);
  return success;
}

Here is the call graph for this function: