pop.c File Reference

POP network mailbox. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "conn/lib.h"
#include "lib.h"
#include "bcache/lib.h"
#include "hooks/lib.h"
#include "ncrypt/lib.h"
#include "progress/lib.h"
#include "question/lib.h"
#include "store/lib.h"
#include "adata.h"
#include "edata.h"
#include "mutt_logging.h"
#include "mutt_socket.h"
#include "mx.h"
#include <libintl.h>
#include "hcache/lib.h"

Include dependency graph for pop.c:

Go to the source code of this file.

Macros
#define	HC_FNAME   "neomutt" /* filename for hcache as POP lacks paths */
#define	HC_FEXT   "hcache" /* extension for hcache as POP lacks paths */
#define	POP_MAX_MESSAGES   500000
	Hard limit on UIDL responses to prevent a malicious server from causing unbounded memory growth.

Functions
static const char *	cache_id (const char *id)
	Make a message-cache-compatible id.
static int	fetch_message (const char *line, void *data)
	Parse a Message response - Implements pop_fetch_t -.
static int	pop_read_header (struct PopAccountData *adata, struct Email *e)
	Read header.
static int	fetch_uidl (const char *line, void *data)
	Parse UIDL response - Implements pop_fetch_t -.
static int	pop_bcache_delete (const char *id, struct BodyCache *bcache, void *data)
	Delete an entry from the message cache - Implements bcache_list_t -.
static void	pop_hcache_namer (const struct StoreOps *store_ops, const char *path, struct Buffer *dest)
	Create a header cache filename for a POP mailbox - Implements hcache_namer_t -.
static struct HeaderCache *	pop_hcache_open (struct PopAccountData *adata, const char *path)
	Open the header cache.
static int	pop_fetch_headers (struct Mailbox *m)
	Read headers.
static void	pop_clear_cache (struct PopAccountData *adata)
	Delete all cached messages.
void	pop_fetch_mail (void)
	Fetch messages and save them in $spool_file.
static bool	pop_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
static bool	pop_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -.
static enum MxOpenReturns	pop_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxStatus	pop_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	pop_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	pop_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
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() -.
static int	pop_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() -.
static int	pop_msg_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Implements MxOps::msg_save_hcache() -.
enum MailboxType	pop_path_probe (const char *path, const struct stat *st)
	Is this a POP Mailbox?
static int	pop_path_canon (struct Buffer *path)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -.

Variables
const struct MxOps	MxPopOps
	POP Mailbox - Implements MxOps -.

Detailed Description

POP network mailbox.

Authors

• Richard Russon
• Pietro Cerutti
• Ian Zimmerman

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file pop.c.

Macro Definition Documentation

HC_FNAME

#define HC_FNAME   "neomutt" /* filename for hcache as POP lacks paths */

Definition at line 69 of file pop.c.

HC_FEXT

#define HC_FEXT   "hcache" /* extension for hcache as POP lacks paths */

Definition at line 70 of file pop.c.

POP_MAX_MESSAGES

#define POP_MAX_MESSAGES   500000

Hard limit on UIDL responses to prevent a malicious server from causing unbounded memory growth.

Definition at line 74 of file pop.c.

Function Documentation

cache_id()

static const char * cache_id ( const char * id )

static

Make a message-cache-compatible id.

Parameters

id	POP message id

Return values

ptr	Sanitised string

The POP message id may contain '/' and other awkward characters.

Note

This function returns a pointer to a static buffer.

Definition at line 85 of file pop.c.

{
  static char clean[128];
  mutt_str_copy(clean, id, sizeof(clean));
  mutt_file_sanitize_filename(clean, true);
  return clean;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pop_read_header()

static int pop_read_header ( struct PopAccountData * adata, struct Email * e )

static

Read header.

Parameters

adata	POP Account data
e	Email

Return values

0	Success
-1	Connection lost
-2	Invalid command or execution error
-3	Error writing to tempfile

Definition at line 122 of file pop.c.

{
  FILE *fp = mutt_file_mkstemp();
  if (!fp)
  {
    mutt_perror(_("Can't create temporary file"));
    return -3;
  }
 
  int index = 0;
  size_t length = 0;
  char buf[1024] = { 0 };
 
  struct PopEmailData *edata = pop_edata_get(e);
 
  snprintf(buf, sizeof(buf), "LIST %d\r\n", edata->refno);
  int rc = pop_query(adata, buf, sizeof(buf));
  if (rc == 0)
  {
    if (sscanf(buf, "+OK %d %zu", &index, &length) == 2)
    {
      snprintf(buf, sizeof(buf), "TOP %d 0\r\n", edata->refno);
      rc = pop_fetch_data(adata, buf, NULL, fetch_message, fp);
 
      if (adata->cmd_top == 2)
      {
        if (rc == 0)
        {
          adata->cmd_top = 1;
 
          mutt_debug(LL_DEBUG1, "set TOP capability\n");
        }
 
        if (rc == -2)
        {
          adata->cmd_top = 0;
 
          mutt_debug(LL_DEBUG1, "unset TOP capability\n");
          snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
                   _("Command TOP is not supported by server"));
        }
      }
      else
      {
        mutt_debug(LL_DEBUG1, "Malformed LIST response: %s\n", buf);
        rc = -1;
      }
    }
  }
 
  switch (rc)
  {
    case 0:
    {
      rewind(fp);
      e->env = mutt_rfc822_read_header(fp, e, false, false);
      e->body->length = length - e->body->offset + 1;
      rewind(fp);
      while (!feof(fp))
      {
        e->body->length--;
        if (!fgets(buf, sizeof(buf), fp))
          break;
      }
      break;
    }
    case -2:
    {
      mutt_error("%s", adata->err_msg);
      break;
    }
    case -3:
    {
      mutt_error(_("Can't write header to temporary file"));
      break;
    }
  }
 
  mutt_file_fclose(&fp);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pop_hcache_open()

static struct HeaderCache * pop_hcache_open ( struct PopAccountData * adata, const char * path )

static

Open the header cache.

Parameters

adata	POP Account data
path	Path to the mailbox

Return values

ptr	Header cache

Definition at line 316 of file pop.c.

{
  const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  if (!adata || !adata->conn)
    return hcache_open(c_header_cache, path, NULL, true);
 
  struct Url url = { 0 };
  char p[1024] = { 0 };
 
  account_to_url(&adata->conn->account, &url);
  url.path = HC_FNAME;
  url_tostring(&url, p, sizeof(p), U_PATH);
  return hcache_open(c_header_cache, p, pop_hcache_namer, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pop_fetch_headers()

static int pop_fetch_headers ( struct Mailbox * m )

static

Read headers.

Parameters

m

Mailbox

Return values

0	Success
-1	Connection lost
-2	Invalid command or execution error
-3	Error writing to tempfile

Definition at line 340 of file pop.c.

{
  if (!m)
    return -1;
 
  struct PopAccountData *adata = pop_adata_get(m);
  struct Progress *progress = NULL;
 
#ifdef USE_HCACHE
  struct HeaderCache *hc = pop_hcache_open(adata, mailbox_path(m));
#endif
 
  adata->check_time = mutt_date_now();
  adata->clear_cache = false;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct PopEmailData *edata = pop_edata_get(m->emails[i]);
    edata->refno = -1;
  }
 
  const int old_count = m->msg_count;
  int rc = pop_fetch_data(adata, "UIDL\r\n", NULL, fetch_uidl, m);
  const int new_count = m->msg_count;
  m->msg_count = old_count;
 
  if (adata->cmd_uidl == 2)
  {
    if (rc == 0)
    {
      adata->cmd_uidl = 1;
 
      mutt_debug(LL_DEBUG1, "set UIDL capability\n");
    }
 
    if ((rc == -2) && (adata->cmd_uidl == 2))
    {
      adata->cmd_uidl = 0;
 
      mutt_debug(LL_DEBUG1, "unset UIDL capability\n");
      snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
               _("Command UIDL is not supported by server"));
    }
  }
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, new_count - old_count);
    progress_set_message(progress, _("Fetching message headers..."));
  }
 
  if (rc == 0)
  {
    int i, deleted;
    for (i = 0, deleted = 0; i < old_count; i++)
    {
      struct PopEmailData *edata = pop_edata_get(m->emails[i]);
      if (edata->refno == -1)
      {
        m->emails[i]->deleted = true;
        deleted++;
      }
    }
    if (deleted > 0)
    {
      mutt_error(ngettext("%d message has been lost. Try reopening the mailbox.",
                          "%d messages have been lost. Try reopening the mailbox.", deleted),
                 deleted);
    }
 
    bool hcached = false;
    for (i = old_count; i < new_count; i++)
    {
      progress_update(progress, i + 1 - old_count, -1);
      struct PopEmailData *edata = pop_edata_get(m->emails[i]);
#ifdef USE_HCACHE
      struct HCacheEntry hce = hcache_fetch_email(hc, edata->uid, strlen(edata->uid), 0);
      if (hce.email)
      {
        /* Detach the private data */
        m->emails[i]->edata = NULL;
 
        int index = m->emails[i]->index;
        /* - POP dynamically numbers headers and relies on e->refno
         *   to map messages; so restore header and overwrite restored
         *   refno with current refno, same for index
         * - e->data needs to a separate pointer as it's driver-specific
         *   data freed separately elsewhere
         *   (the old e->data should point inside a malloc'd block from
         *   hcache so there shouldn't be a memleak here) */
        email_free(&m->emails[i]);
        m->emails[i] = hce.email;
        m->emails[i]->index = index;
 
        /* Reattach the private data */
        m->emails[i]->edata = edata;
        m->emails[i]->edata_free = pop_edata_free;
        rc = 0;
        hcached = true;
      }
      else
#endif
          if ((rc = pop_read_header(adata, m->emails[i])) < 0)
        break;
#ifdef USE_HCACHE
      else
      {
        hcache_store_email(hc, edata->uid, strlen(edata->uid), m->emails[i], 0);
      }
#endif
 
      /* faked support for flags works like this:
       * - if 'hcached' is true, we have the message in our hcache:
       *        - if we also have a body: read
       *        - if we don't have a body: old
       *          (if $mark_old is set which is maybe wrong as
       *          $mark_old should be considered for syncing the
       *          folder and not when opening it XXX)
       * - if 'hcached' is false, we don't have the message in our hcache:
       *        - if we also have a body: read
       *        - if we don't have a body: new */
      const bool bcached = (mutt_bcache_exists(adata->bcache, cache_id(edata->uid)) == 0);
      m->emails[i]->old = false;
      m->emails[i]->read = false;
      if (hcached)
      {
        const bool c_mark_old = cs_subset_bool(NeoMutt->sub, "mark_old");
        if (bcached)
          m->emails[i]->read = true;
        else if (c_mark_old)
          m->emails[i]->old = true;
      }
      else
      {
        if (bcached)
          m->emails[i]->read = true;
      }
 
      m->msg_count++;
    }
  }
  progress_free(&progress);
 
#ifdef USE_HCACHE
  hcache_close(&hc);
#endif
 
  if (rc < 0)
  {
    for (int i = m->msg_count; i < new_count; i++)
      email_free(&m->emails[i]);
    return rc;
  }
 
  /* after putting the result into our structures,
   * clean up cache, i.e. wipe messages deleted outside
   * the availability of our cache */
  const bool c_message_cache_clean = cs_subset_bool(NeoMutt->sub, "message_cache_clean");
  if (c_message_cache_clean)
    mutt_bcache_list(adata->bcache, pop_bcache_delete, m);
 
  mutt_clear_error();
  return new_count - old_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pop_clear_cache()

static void pop_clear_cache ( struct PopAccountData * adata )

static

Delete all cached messages.

Parameters

adata

POP Account data

Definition at line 509 of file pop.c.

{
  if (!adata->clear_cache)
    return;
 
  mutt_debug(LL_DEBUG1, "delete cached messages\n");
 
  for (int i = 0; i < POP_CACHE_LEN; i++)
  {
    if (adata->cache[i].path)
    {
      unlink(adata->cache[i].path);
      FREE(&adata->cache[i].path);
    }
  }
}

Here is the caller graph for this function:

pop_fetch_mail()

void pop_fetch_mail

(

void

)

Fetch messages and save them in $spool_file.

Definition at line 529 of file pop.c.

{
  const char *const c_pop_host = cs_subset_string(NeoMutt->sub, "pop_host");
  if (!c_pop_host)
  {
    mutt_error(_("POP host is not defined"));
    return;
  }
 
  char buf[1024] = { 0 };
  char msgbuf[128] = { 0 };
  int last = 0, msgs = 0, bytes = 0, rset = 0, rc;
  struct ConnAccount cac = { { 0 } };
 
  char *p = MUTT_MEM_CALLOC(strlen(c_pop_host) + 7, char);
  char *url = p;
  if (url_check_scheme(c_pop_host) == U_UNKNOWN)
  {
    strcpy(url, "pop://");
    p = strchr(url, '\0');
  }
  strcpy(p, c_pop_host);
 
  rc = pop_parse_path(url, &cac);
  FREE(&url);
  if (rc)
  {
    mutt_error(_("%s is an invalid POP path"), c_pop_host);
    return;
  }
 
  struct Connection *conn = mutt_conn_find(&cac);
  if (!conn)
    return;
 
  struct PopAccountData *adata = pop_adata_new();
  adata->conn = conn;
 
  if (pop_open_connection(adata) < 0)
  {
    pop_adata_free((void **) &adata);
    return;
  }
 
  mutt_message(_("Checking for new messages..."));
 
  /* find out how many messages are in the mailbox. */
  mutt_str_copy(buf, "STAT\r\n", sizeof(buf));
  rc = pop_query(adata, buf, sizeof(buf));
  if (rc == -1)
    goto fail;
  if (rc == -2)
  {
    mutt_error("%s", adata->err_msg);
    goto finish;
  }
 
  sscanf(buf, "+OK %d %d", &msgs, &bytes);
 
  /* only get unread messages */
  const bool c_pop_last = cs_subset_bool(NeoMutt->sub, "pop_last");
  if ((msgs > 0) && c_pop_last)
  {
    mutt_str_copy(buf, "LAST\r\n", sizeof(buf));
    rc = pop_query(adata, buf, sizeof(buf));
    if (rc == -1)
      goto fail;
    if (rc == 0)
      sscanf(buf, "+OK %d", &last);
  }
 
  if (msgs <= last)
  {
    mutt_message(_("No new mail in POP mailbox"));
    goto finish;
  }
 
  const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
  struct Mailbox *m_spool = mx_path_resolve(c_spool_file);
 
  if (!mx_mbox_open(m_spool, MUTT_OPEN_NO_FLAGS))
  {
    mailbox_free(&m_spool);
    goto finish;
  }
  bool old_append = m_spool->append;
  m_spool->append = true;
 
  enum QuadOption delanswer = query_quadoption(_("Delete messages from server?"),
                                               NeoMutt->sub, "pop_delete");
 
  snprintf(msgbuf, sizeof(msgbuf),
           ngettext("Reading new messages (%d byte)...",
                    "Reading new messages (%d bytes)...", bytes),
           bytes);
  mutt_message("%s", msgbuf);
 
  for (int i = last + 1; i <= msgs; i++)
  {
    struct Message *msg = mx_msg_open_new(m_spool, NULL, MUTT_ADD_FROM);
    if (msg)
    {
      snprintf(buf, sizeof(buf), "RETR %d\r\n", i);
      rc = pop_fetch_data(adata, buf, NULL, fetch_message, msg->fp);
      if (rc == -3)
        rset = 1;
 
      if ((rc == 0) && (mx_msg_commit(m_spool, msg) != 0))
      {
        rset = 1;
        rc = -3;
      }
 
      mx_msg_close(m_spool, &msg);
    }
    else
    {
      rc = -3;
    }
 
    if ((rc == 0) && (delanswer == MUTT_YES))
    {
      /* delete the message on the server */
      snprintf(buf, sizeof(buf), "DELE %d\r\n", i);
      rc = pop_query(adata, buf, sizeof(buf));
    }
 
    if (rc == -1)
    {
      m_spool->append = old_append;
      mx_mbox_close(m_spool);
      goto fail;
    }
    if (rc == -2)
    {
      mutt_error("%s", adata->err_msg);
      break;
    }
    if (rc == -3)
    {
      mutt_error(_("Error while writing mailbox"));
      break;
    }
 
    /* L10N: The plural is picked by the second numerical argument, i.e.
       the %d right before 'messages', i.e. the total number of messages. */
    mutt_message(ngettext("%s [%d of %d message read]",
                          "%s [%d of %d messages read]", msgs - last),
                 msgbuf, i - last, msgs - last);
  }
 
  m_spool->append = old_append;
  mx_mbox_close(m_spool);
 
  if (rset)
  {
    /* make sure no messages get deleted */
    mutt_str_copy(buf, "RSET\r\n", sizeof(buf));
    if (pop_query(adata, buf, sizeof(buf)) == -1)
      goto fail;
  }
 
finish:
  /* exit gracefully */
  mutt_str_copy(buf, "QUIT\r\n", sizeof(buf));
  if (pop_query(adata, buf, sizeof(buf)) == -1)
    goto fail;
  mutt_socket_close(conn);
  pop_adata_free((void **) &adata);
  return;
 
fail:
  mutt_error(_("Server closed connection"));
  mutt_socket_close(conn);
  pop_adata_free((void **) &adata);
}

Here is the call graph for this function:

Here is the caller graph for this function: