lib.h File Reference

#include <stdbool.h>
#include "core/lib.h"
#include "mx.h"

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	pop_fetch_mail (void)
	Fetch messages and save them in $spool_file. More...
enum MailboxType	pop_path_probe (const char *path, const struct stat *st)
	Is this a POP Mailbox? - Implements MxOps::path_probe() More...

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

Detailed Description

POP network mailbox

Authors

• Vsevolod Volkov

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 lib.h.

Function Documentation

pop_fetch_mail()

void pop_fetch_mail

(

void

)

Fetch messages and save them in $spool_file.

Definition at line 509 of file pop.c.

{
  if (!C_PopHost)
  {
    mutt_error(_("POP host is not defined"));
    return;
  }
 
  char buf[1024];
  char msgbuf[128];
  int last = 0, msgs, bytes, rset = 0, ret;
  struct ConnAccount cac = { { 0 } };
 
  char *p = mutt_mem_calloc(strlen(C_PopHost) + 7, sizeof(char));
  char *url = p;
  if (url_check_scheme(C_PopHost) == U_UNKNOWN)
  {
    strcpy(url, "pop://");
    p = strchr(url, '\0');
  }
  strcpy(p, C_PopHost);
 
  ret = pop_parse_path(url, &cac);
  FREE(&url);
  if (ret)
  {
    mutt_error(_("%s is an invalid POP path"), C_PopHost);
    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)
  {
    //XXX mutt_socket_free(adata->conn);
    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));
  ret = pop_query(adata, buf, sizeof(buf));
  if (ret == -1)
    goto fail;
  if (ret == -2)
  {
    mutt_error("%s", adata->err_msg);
    goto finish;
  }
 
  sscanf(buf, "+OK %d %d", &msgs, &bytes);
 
  /* only get unread messages */
  if ((msgs > 0) && C_PopLast)
  {
    mutt_str_copy(buf, "LAST\r\n", sizeof(buf));
    ret = pop_query(adata, buf, sizeof(buf));
    if (ret == -1)
      goto fail;
    if (ret == 0)
      sscanf(buf, "+OK %d", &last);
  }
 
  if (msgs <= last)
  {
    mutt_message(_("No new mail in POP mailbox"));
    goto finish;
  }
 
  struct Mailbox *m_spool = mx_path_resolve(C_SpoolFile);
  struct Context *ctx = mx_mbox_open(m_spool, MUTT_OPEN_NO_FLAGS);
  if (!ctx)
  {
    mailbox_free(&m_spool);
    goto finish;
  }
 
  bool old_append = m_spool->append;
  m_spool->append = true;
 
  enum QuadOption delanswer =
      query_quadoption(C_PopDelete, _("Delete messages from server?"));
 
  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(ctx->mailbox, NULL, MUTT_ADD_FROM);
    if (msg)
    {
      snprintf(buf, sizeof(buf), "RETR %d\r\n", i);
      ret = pop_fetch_data(adata, buf, NULL, fetch_message, msg->fp);
      if (ret == -3)
        rset = 1;
 
      if ((ret == 0) && (mx_msg_commit(ctx->mailbox, msg) != 0))
      {
        rset = 1;
        ret = -3;
      }
 
      mx_msg_close(ctx->mailbox, &msg);
    }
    else
    {
      ret = -3;
    }
 
    if ((ret == 0) && (delanswer == MUTT_YES))
    {
      /* delete the message on the server */
      snprintf(buf, sizeof(buf), "DELE %d\r\n", i);
      ret = pop_query(adata, buf, sizeof(buf));
    }
 
    if (ret == -1)
    {
      m_spool->append = old_append;
      mx_mbox_close(&ctx);
      goto fail;
    }
    if (ret == -2)
    {
      mutt_error("%s", adata->err_msg);
      break;
    }
    if (ret == -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(&ctx);
 
  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);
  FREE(&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:

pop_path_probe()

enum MailboxType pop_path_probe	(	const char *	path,
		const struct stat *	st
	)

Is this a POP Mailbox? - Implements MxOps::path_probe()

Definition at line 1149 of file pop.c.

{
  if (mutt_istr_startswith(path, "pop://"))
    return MUTT_POP;
 
  if (mutt_istr_startswith(path, "pops://"))
    return MUTT_POP;
 
  return MUTT_UNKNOWN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MxPopOps

struct MxOps MxPopOps

POP Mailbox - Implements MxOps.

Definition at line 1190 of file pop.c.