NeoMutt  2022-04-29-249-gaae397
Teaching an old dog new tricks
DOXYGEN
lib.h File Reference

POP network mailbox. More...

#include "core/lib.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

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 511 of file pop.c.

512{
513 const char *const c_pop_host = cs_subset_string(NeoMutt->sub, "pop_host");
514 if (!c_pop_host)
515 {
516 mutt_error(_("POP host is not defined"));
517 return;
518 }
519
520 char buf[1024] = { 0 };
521 char msgbuf[128] = { 0 };
522 int last = 0, msgs, bytes, rset = 0, rc;
523 struct ConnAccount cac = { { 0 } };
524
525 char *p = mutt_mem_calloc(strlen(c_pop_host) + 7, sizeof(char));
526 char *url = p;
527 if (url_check_scheme(c_pop_host) == U_UNKNOWN)
528 {
529 strcpy(url, "pop://");
530 p = strchr(url, '\0');
531 }
532 strcpy(p, c_pop_host);
533
534 rc = pop_parse_path(url, &cac);
535 FREE(&url);
536 if (rc)
537 {
538 mutt_error(_("%s is an invalid POP path"), c_pop_host);
539 return;
540 }
541
542 struct Connection *conn = mutt_conn_find(&cac);
543 if (!conn)
544 return;
545
547 adata->conn = conn;
548
549 if (pop_open_connection(adata) < 0)
550 {
551 //XXX mutt_socket_free(adata->conn);
552 pop_adata_free((void **) &adata);
553 return;
554 }
555
556 mutt_message(_("Checking for new messages..."));
557
558 /* find out how many messages are in the mailbox. */
559 mutt_str_copy(buf, "STAT\r\n", sizeof(buf));
560 rc = pop_query(adata, buf, sizeof(buf));
561 if (rc == -1)
562 goto fail;
563 if (rc == -2)
564 {
565 mutt_error("%s", adata->err_msg);
566 goto finish;
567 }
568
569 sscanf(buf, "+OK %d %d", &msgs, &bytes);
570
571 /* only get unread messages */
572 const bool c_pop_last = cs_subset_bool(NeoMutt->sub, "pop_last");
573 if ((msgs > 0) && c_pop_last)
574 {
575 mutt_str_copy(buf, "LAST\r\n", sizeof(buf));
576 rc = pop_query(adata, buf, sizeof(buf));
577 if (rc == -1)
578 goto fail;
579 if (rc == 0)
580 sscanf(buf, "+OK %d", &last);
581 }
582
583 if (msgs <= last)
584 {
585 mutt_message(_("No new mail in POP mailbox"));
586 goto finish;
587 }
588
589 const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
590 struct Mailbox *m_spool = mx_path_resolve(c_spool_file);
591
592 if (!mx_mbox_open(m_spool, MUTT_OPEN_NO_FLAGS))
593 {
594 mailbox_free(&m_spool);
595 goto finish;
596 }
597 bool old_append = m_spool->append;
598 m_spool->append = true;
599
600 const enum QuadOption c_pop_delete = cs_subset_quad(NeoMutt->sub, "pop_delete");
601 enum QuadOption delanswer = query_quadoption(c_pop_delete, _("Delete messages from server?"));
602
603 snprintf(msgbuf, sizeof(msgbuf),
604 ngettext("Reading new messages (%d byte)...",
605 "Reading new messages (%d bytes)...", bytes),
606 bytes);
607 mutt_message("%s", msgbuf);
608
609 for (int i = last + 1; i <= msgs; i++)
610 {
611 struct Message *msg = mx_msg_open_new(m_spool, NULL, MUTT_ADD_FROM);
612 if (msg)
613 {
614 snprintf(buf, sizeof(buf), "RETR %d\r\n", i);
615 rc = pop_fetch_data(adata, buf, NULL, fetch_message, msg->fp);
616 if (rc == -3)
617 rset = 1;
618
619 if ((rc == 0) && (mx_msg_commit(m_spool, msg) != 0))
620 {
621 rset = 1;
622 rc = -3;
623 }
624
625 mx_msg_close(m_spool, &msg);
626 }
627 else
628 {
629 rc = -3;
630 }
631
632 if ((rc == 0) && (delanswer == MUTT_YES))
633 {
634 /* delete the message on the server */
635 snprintf(buf, sizeof(buf), "DELE %d\r\n", i);
636 rc = pop_query(adata, buf, sizeof(buf));
637 }
638
639 if (rc == -1)
640 {
641 m_spool->append = old_append;
642 mx_mbox_close(m_spool);
643 goto fail;
644 }
645 if (rc == -2)
646 {
647 mutt_error("%s", adata->err_msg);
648 break;
649 }
650 if (rc == -3)
651 {
652 mutt_error(_("Error while writing mailbox"));
653 break;
654 }
655
656 /* L10N: The plural is picked by the second numerical argument, i.e.
657 the %d right before 'messages', i.e. the total number of messages. */
658 mutt_message(ngettext("%s [%d of %d message read]",
659 "%s [%d of %d messages read]", msgs - last),
660 msgbuf, i - last, msgs - last);
661 }
662
663 m_spool->append = old_append;
664 mx_mbox_close(m_spool);
665
666 if (rset)
667 {
668 /* make sure no messages get deleted */
669 mutt_str_copy(buf, "RSET\r\n", sizeof(buf));
670 if (pop_query(adata, buf, sizeof(buf)) == -1)
671 goto fail;
672 }
673
674finish:
675 /* exit gracefully */
676 mutt_str_copy(buf, "QUIT\r\n", sizeof(buf));
677 if (pop_query(adata, buf, sizeof(buf)) == -1)
678 goto fail;
679 mutt_socket_close(conn);
680 FREE(&conn);
681 pop_adata_free((void **) &adata);
682 return;
683
684fail:
685 mutt_error(_("Server closed connection"));
686 mutt_socket_close(conn);
687 pop_adata_free((void **) &adata);
688}
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:218
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
#define mutt_error(...)
Definition: logging.h:87
#define mutt_message(...)
Definition: logging.h:86
static int fetch_message(const char *line, void *data)
Write line to file - Implements pop_fetch_t -.
Definition: pop.c:98
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:87
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
#define FREE(x)
Definition: memory.h:43
#define _(a)
Definition: message.h:28
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:652
struct Connection * mutt_conn_find(const struct ConnAccount *cac)
Find a connection from a list.
Definition: mutt_socket.c:89
int mx_msg_close(struct Mailbox *m, struct Message **msg)
Close a message.
Definition: mx.c:1193
bool mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:304
struct Message * mx_msg_open_new(struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
Open a new message.
Definition: mx.c:1057
int mx_msg_commit(struct Mailbox *m, struct Message *msg)
Commit a message to a folder - Wrapper for MxOps::msg_commit()
Definition: mx.c:1172
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1677
enum MxStatus mx_mbox_close(struct Mailbox *m)
Save changes and close mailbox.
Definition: mx.c:615
#define MUTT_ADD_FROM
add a From_ line
Definition: mx.h:43
#define MUTT_OPEN_NO_FLAGS
No flags are set.
Definition: mxapi.h:61
struct PopAccountData * pop_adata_new(void)
Create a new PopAccountData object.
Definition: adata.c:54
void pop_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free()
Definition: adata.c:40
int pop_open_connection(struct PopAccountData *adata)
Open connection and authenticate.
Definition: lib.c:308
int pop_parse_path(const char *path, struct ConnAccount *cac)
Parse a POP mailbox name.
Definition: lib.c:82
int pop_fetch_data(struct PopAccountData *adata, const char *query, struct Progress *progress, pop_fetch_t callback, void *data)
Read Headers with callback function.
Definition: lib.c:502
#define pop_query(adata, buf, buflen)
Definition: private.h:109
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: question.c:386
int mutt_socket_close(struct Connection *conn)
Close a socket.
Definition: socket.c:98
void * adata
Private data (for Mailbox backends)
Definition: account.h:43
Login details for a remote server.
Definition: connaccount.h:53
A mailbox.
Definition: mailbox.h:79
bool append
Mailbox is opened in append mode.
Definition: mailbox.h:109
A local copy of an email.
Definition: mxapi.h:43
FILE * fp
pointer to the message data
Definition: mxapi.h:44
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
POP-specific Account data -.
Definition: adata.h:37
char err_msg[POP_CMD_RESPONSE]
Definition: adata.h:56
struct Connection * conn
Connection to POP server.
Definition: adata.h:38
enum UrlScheme url_check_scheme(const char *str)
Check the protocol of a URL.
Definition: url.c:221
@ U_UNKNOWN
Url wasn't recognised.
Definition: url.h:35
+ Here is the call graph for this function:
+ Here is the caller graph for this function: