NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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 "ncrypt/lib.h"
#include "progress/lib.h"
#include "question/lib.h"
#include "adata.h"
#include "edata.h"
#include "hook.h"
#include "mutt_account.h"
#include "mutt_header.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 */
 

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 char *path, struct Buffer *dest)
 Create a header cache filename for a POP mailbox - Implements hcache_namer_t -.
 
static struct HeaderCachepop_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? - Implements MxOps::path_probe() -.
 
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

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

◆ HC_FEXT

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

Definition at line 71 of file pop.c.

Function Documentation

◆ cache_id()

static const char * cache_id ( const char *  id)
static

Make a message-cache-compatible id.

Parameters
idPOP message id
Return values
ptrSanitised string

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

Note
This function returns a pointer to a static buffer.

Definition at line 82 of file pop.c.

83{
84 static char clean[128];
85 mutt_str_copy(clean, id, sizeof(clean));
86 mutt_file_sanitize_filename(clean, true);
87 return clean;
88}
void mutt_file_sanitize_filename(char *path, bool slash)
Replace unsafe characters in a filename.
Definition: file.c:712
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:581
+ 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
adataPOP Account data
eEmail
Return values
0Success
-1Connection lost
-2Invalid command or execution error
-3Error writing to tempfile

Definition at line 119 of file pop.c.

120{
121 FILE *fp = mutt_file_mkstemp();
122 if (!fp)
123 {
124 mutt_perror(_("Can't create temporary file"));
125 return -3;
126 }
127
128 int index = 0;
129 size_t length = 0;
130 char buf[1024] = { 0 };
131
132 struct PopEmailData *edata = pop_edata_get(e);
133
134 snprintf(buf, sizeof(buf), "LIST %d\r\n", edata->refno);
135 int rc = pop_query(adata, buf, sizeof(buf));
136 if (rc == 0)
137 {
138 sscanf(buf, "+OK %d %zu", &index, &length);
139
140 snprintf(buf, sizeof(buf), "TOP %d 0\r\n", edata->refno);
141 rc = pop_fetch_data(adata, buf, NULL, fetch_message, fp);
142
143 if (adata->cmd_top == 2)
144 {
145 if (rc == 0)
146 {
147 adata->cmd_top = 1;
148
149 mutt_debug(LL_DEBUG1, "set TOP capability\n");
150 }
151
152 if (rc == -2)
153 {
154 adata->cmd_top = 0;
155
156 mutt_debug(LL_DEBUG1, "unset TOP capability\n");
157 snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
158 _("Command TOP is not supported by server"));
159 }
160 }
161 }
162
163 switch (rc)
164 {
165 case 0:
166 {
167 rewind(fp);
168 e->env = mutt_rfc822_read_header(fp, e, false, false);
169 e->body->length = length - e->body->offset + 1;
170 rewind(fp);
171 while (!feof(fp))
172 {
173 e->body->length--;
174 if (!fgets(buf, sizeof(buf), fp))
175 break;
176 }
177 break;
178 }
179 case -2:
180 {
181 mutt_error("%s", adata->err_msg);
182 break;
183 }
184 case -3:
185 {
186 mutt_error(_("Can't write header to temporary file"));
187 break;
188 }
189 }
190
191 mutt_file_fclose(&fp);
192 return rc;
193}
struct Envelope * mutt_rfc822_read_header(FILE *fp, struct Email *e, bool user_hdrs, bool weed)
Parses an RFC822 header.
Definition: parse.c:1200
#define mutt_file_fclose(FP)
Definition: file.h:149
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
static int fetch_message(const char *line, void *data)
Parse a Message response - Implements pop_fetch_t -.
Definition: pop.c:99
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
#define _(a)
Definition: message.h:28
struct PopEmailData * pop_edata_get(struct Email *e)
Get the private data for this Email.
Definition: edata.c:68
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:511
#define pop_query(adata, buf, buflen)
Definition: private.h:111
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
struct Envelope * env
Envelope information.
Definition: email.h:68
void * edata
Driver-specific data.
Definition: email.h:74
struct Body * body
List of MIME parts.
Definition: email.h:69
int index
The absolute (unsorted) message number.
Definition: email.h:113
unsigned int cmd_top
optional command TOP
Definition: adata.h:46
char err_msg[POP_CMD_RESPONSE]
Definition: adata.h:56
POP-specific Email data -.
Definition: edata.h:32
#define mutt_file_mkstemp()
Definition: tmp.h:36
+ 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
adataPOP Account data
pathPath to the mailbox
Return values
ptrHeader cache

Definition at line 300 of file pop.c.

301{
302 const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
303 if (!adata || !adata->conn)
304 return hcache_open(c_header_cache, path, NULL, true);
305
306 struct Url url = { 0 };
307 char p[1024] = { 0 };
308
309 mutt_account_tourl(&adata->conn->account, &url);
310 url.path = HC_FNAME;
311 url_tostring(&url, p, sizeof(p), U_PATH);
312 return hcache_open(c_header_cache, p, pop_hcache_namer, true);
313}
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition: helpers.c:168
static void pop_hcache_namer(const char *path, struct Buffer *dest)
Create a header cache filename for a POP mailbox - Implements hcache_namer_t -.
Definition: pop.c:289
struct HeaderCache * hcache_open(const char *path, const char *folder, hcache_namer_t namer, bool create)
Multiplexor for StoreOps::open.
Definition: hcache.c:471
void mutt_account_tourl(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition: mutt_account.c:80
#define HC_FNAME
Definition: pop.c:70
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
struct Connection * conn
Connection to POP server.
Definition: adata.h:38
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * path
Path.
Definition: url.h:75
int url_tostring(const struct Url *url, char *dest, size_t len, uint8_t flags)
Output the URL string for a given Url object.
Definition: url.c:423
#define U_PATH
Definition: url.h:50
+ 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
mMailbox
Return values
0Success
-1Connection lost
-2Invalid command or execution error
-3Error writing to tempfile

Definition at line 324 of file pop.c.

325{
326 if (!m)
327 return -1;
328
330 struct Progress *progress = NULL;
331
332#ifdef USE_HCACHE
333 struct HeaderCache *hc = pop_hcache_open(adata, mailbox_path(m));
334#endif
335
336 adata->check_time = mutt_date_now();
337 adata->clear_cache = false;
338
339 for (int i = 0; i < m->msg_count; i++)
340 {
341 struct PopEmailData *edata = pop_edata_get(m->emails[i]);
342 edata->refno = -1;
343 }
344
345 const int old_count = m->msg_count;
346 int rc = pop_fetch_data(adata, "UIDL\r\n", NULL, fetch_uidl, m);
347 const int new_count = m->msg_count;
348 m->msg_count = old_count;
349
350 if (adata->cmd_uidl == 2)
351 {
352 if (rc == 0)
353 {
354 adata->cmd_uidl = 1;
355
356 mutt_debug(LL_DEBUG1, "set UIDL capability\n");
357 }
358
359 if ((rc == -2) && (adata->cmd_uidl == 2))
360 {
361 adata->cmd_uidl = 0;
362
363 mutt_debug(LL_DEBUG1, "unset UIDL capability\n");
364 snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
365 _("Command UIDL is not supported by server"));
366 }
367 }
368
369 if (m->verbose)
370 {
371 progress = progress_new(MUTT_PROGRESS_READ, new_count - old_count);
372 progress_set_message(progress, _("Fetching message headers..."));
373 }
374
375 if (rc == 0)
376 {
377 int i, deleted;
378 for (i = 0, deleted = 0; i < old_count; i++)
379 {
380 struct PopEmailData *edata = pop_edata_get(m->emails[i]);
381 if (edata->refno == -1)
382 {
383 m->emails[i]->deleted = true;
384 deleted++;
385 }
386 }
387 if (deleted > 0)
388 {
389 mutt_error(ngettext("%d message has been lost. Try reopening the mailbox.",
390 "%d messages have been lost. Try reopening the mailbox.", deleted),
391 deleted);
392 }
393
394 bool hcached = false;
395 for (i = old_count; i < new_count; i++)
396 {
397 progress_update(progress, i + 1 - old_count, -1);
398 struct PopEmailData *edata = pop_edata_get(m->emails[i]);
399#ifdef USE_HCACHE
400 struct HCacheEntry hce = hcache_fetch_email(hc, edata->uid, strlen(edata->uid), 0);
401 if (hce.email)
402 {
403 /* Detach the private data */
404 m->emails[i]->edata = NULL;
405
406 int index = m->emails[i]->index;
407 /* - POP dynamically numbers headers and relies on e->refno
408 * to map messages; so restore header and overwrite restored
409 * refno with current refno, same for index
410 * - e->data needs to a separate pointer as it's driver-specific
411 * data freed separately elsewhere
412 * (the old e->data should point inside a malloc'd block from
413 * hcache so there shouldn't be a memleak here) */
414 email_free(&m->emails[i]);
415 m->emails[i] = hce.email;
416 m->emails[i]->index = index;
417
418 /* Reattach the private data */
419 m->emails[i]->edata = edata;
421 rc = 0;
422 hcached = true;
423 }
424 else
425#endif
426 if ((rc = pop_read_header(adata, m->emails[i])) < 0)
427 break;
428#ifdef USE_HCACHE
429 else
430 {
431 hcache_store_email(hc, edata->uid, strlen(edata->uid), m->emails[i], 0);
432 }
433#endif
434
435 /* faked support for flags works like this:
436 * - if 'hcached' is true, we have the message in our hcache:
437 * - if we also have a body: read
438 * - if we don't have a body: old
439 * (if $mark_old is set which is maybe wrong as
440 * $mark_old should be considered for syncing the
441 * folder and not when opening it XXX)
442 * - if 'hcached' is false, we don't have the message in our hcache:
443 * - if we also have a body: read
444 * - if we don't have a body: new */
445 const bool bcached = (mutt_bcache_exists(adata->bcache, cache_id(edata->uid)) == 0);
446 m->emails[i]->old = false;
447 m->emails[i]->read = false;
448 if (hcached)
449 {
450 const bool c_mark_old = cs_subset_bool(NeoMutt->sub, "mark_old");
451 if (bcached)
452 m->emails[i]->read = true;
453 else if (c_mark_old)
454 m->emails[i]->old = true;
455 }
456 else
457 {
458 if (bcached)
459 m->emails[i]->read = true;
460 }
461
462 m->msg_count++;
463 }
464 }
465 progress_free(&progress);
466
467#ifdef USE_HCACHE
468 hcache_close(&hc);
469#endif
470
471 if (rc < 0)
472 {
473 for (int i = m->msg_count; i < new_count; i++)
474 email_free(&m->emails[i]);
475 return rc;
476 }
477
478 /* after putting the result into our structures,
479 * clean up cache, i.e. wipe messages deleted outside
480 * the availability of our cache */
481 const bool c_message_cache_clean = cs_subset_bool(NeoMutt->sub, "message_cache_clean");
482 if (c_message_cache_clean)
484
486 return new_count - old_count;
487}
int mutt_bcache_exists(struct BodyCache *bcache, const char *id)
Check if a file exists in the Body Cache.
Definition: bcache.c:294
int mutt_bcache_list(struct BodyCache *bcache, bcache_list_t want_id, void *data)
Find matching entries in the Body Cache.
Definition: bcache.c:336
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:46
static int pop_bcache_delete(const char *id, struct BodyCache *bcache, void *data)
Delete an entry from the message cache - Implements bcache_list_t -.
Definition: pop.c:256
void pop_edata_free(void **ptr)
Free the private Email data - Implements Email::edata_free() -.
Definition: edata.c:41
static int fetch_uidl(const char *line, void *data)
Parse UIDL response - Implements pop_fetch_t -.
Definition: pop.c:202
void hcache_close(struct HeaderCache **ptr)
Multiplexor for StoreOps::close.
Definition: hcache.c:545
struct HCacheEntry hcache_fetch_email(struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
Multiplexor for StoreOps::fetch.
Definition: hcache.c:565
int hcache_store_email(struct HeaderCache *hc, const char *key, size_t keylen, struct Email *e, uint32_t uidvalidity)
Multiplexor for StoreOps::store.
Definition: hcache.c:673
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:456
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
struct PopAccountData * pop_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:73
static const char * cache_id(const char *id)
Make a message-cache-compatible id.
Definition: pop.c:82
static struct HeaderCache * pop_hcache_open(struct PopAccountData *adata, const char *path)
Open the header cache.
Definition: pop.c:300
static int pop_read_header(struct PopAccountData *adata, struct Email *e)
Read header.
Definition: pop.c:119
@ MUTT_PROGRESS_READ
Progress tracks elements, according to $read_inc
Definition: lib.h:82
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
Definition: progress.c:139
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:110
void progress_set_message(struct Progress *progress, const char *fmt,...) __attribute__((__format__(__printf__
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition: progress.c:80
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
bool read
Email is read.
Definition: email.h:50
bool old
Email is seen, but unread.
Definition: email.h:49
void(* edata_free)(void **ptr)
Definition: email.h:90
bool deleted
Email is deleted.
Definition: email.h:78
Wrapper for Email retrieved from the header cache.
Definition: lib.h:99
struct Email * email
Retrieved email.
Definition: lib.h:102
Header Cache.
Definition: lib.h:86
int msg_count
Total number of messages.
Definition: mailbox.h:88
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
bool verbose
Display status messages?
Definition: mailbox.h:117
POP-specific Account data -.
Definition: adata.h:37
bool clear_cache
Definition: adata.h:49
time_t check_time
Definition: adata.h:51
struct BodyCache * bcache
body cache
Definition: adata.h:55
unsigned int cmd_uidl
optional command UIDL
Definition: adata.h:45
const char * uid
UID of email.
Definition: edata.h:33
+ 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
adataPOP Account data

Definition at line 493 of file pop.c.

494{
495 if (!adata->clear_cache)
496 return;
497
498 mutt_debug(LL_DEBUG1, "delete cached messages\n");
499
500 for (int i = 0; i < POP_CACHE_LEN; i++)
501 {
502 if (adata->cache[i].path)
503 {
504 unlink(adata->cache[i].path);
505 FREE(&adata->cache[i].path);
506 }
507 }
508}
#define FREE(x)
Definition: memory.h:45
#define POP_CACHE_LEN
Definition: private.h:39
struct PopCache cache[POP_CACHE_LEN]
Definition: adata.h:57
char * path
Definition: private.h:71
+ 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 513 of file pop.c.

514{
515 const char *const c_pop_host = cs_subset_string(NeoMutt->sub, "pop_host");
516 if (!c_pop_host)
517 {
518 mutt_error(_("POP host is not defined"));
519 return;
520 }
521
522 char buf[1024] = { 0 };
523 char msgbuf[128] = { 0 };
524 int last = 0, msgs = 0, bytes = 0, rset = 0, rc;
525 struct ConnAccount cac = { { 0 } };
526
527 char *p = mutt_mem_calloc(strlen(c_pop_host) + 7, sizeof(char));
528 char *url = p;
529 if (url_check_scheme(c_pop_host) == U_UNKNOWN)
530 {
531 strcpy(url, "pop://");
532 p = strchr(url, '\0');
533 }
534 strcpy(p, c_pop_host);
535
536 rc = pop_parse_path(url, &cac);
537 FREE(&url);
538 if (rc)
539 {
540 mutt_error(_("%s is an invalid POP path"), c_pop_host);
541 return;
542 }
543
544 struct Connection *conn = mutt_conn_find(&cac);
545 if (!conn)
546 return;
547
549 adata->conn = conn;
550
551 if (pop_open_connection(adata) < 0)
552 {
553 pop_adata_free((void **) &adata);
554 return;
555 }
556
557 mutt_message(_("Checking for new messages..."));
558
559 /* find out how many messages are in the mailbox. */
560 mutt_str_copy(buf, "STAT\r\n", sizeof(buf));
561 rc = pop_query(adata, buf, sizeof(buf));
562 if (rc == -1)
563 goto fail;
564 if (rc == -2)
565 {
566 mutt_error("%s", adata->err_msg);
567 goto finish;
568 }
569
570 sscanf(buf, "+OK %d %d", &msgs, &bytes);
571
572 /* only get unread messages */
573 const bool c_pop_last = cs_subset_bool(NeoMutt->sub, "pop_last");
574 if ((msgs > 0) && c_pop_last)
575 {
576 mutt_str_copy(buf, "LAST\r\n", sizeof(buf));
577 rc = pop_query(adata, buf, sizeof(buf));
578 if (rc == -1)
579 goto fail;
580 if (rc == 0)
581 sscanf(buf, "+OK %d", &last);
582 }
583
584 if (msgs <= last)
585 {
586 mutt_message(_("No new mail in POP mailbox"));
587 goto finish;
588 }
589
590 const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
591 struct Mailbox *m_spool = mx_path_resolve(c_spool_file);
592
593 if (!mx_mbox_open(m_spool, MUTT_OPEN_NO_FLAGS))
594 {
595 mailbox_free(&m_spool);
596 goto finish;
597 }
598 bool old_append = m_spool->append;
599 m_spool->append = true;
600
601 enum QuadOption delanswer = query_quadoption(_("Delete messages from server?"),
602 NeoMutt->sub, "pop_delete");
603
604 snprintf(msgbuf, sizeof(msgbuf),
605 ngettext("Reading new messages (%d byte)...",
606 "Reading new messages (%d bytes)...", bytes),
607 bytes);
608 mutt_message("%s", msgbuf);
609
610 for (int i = last + 1; i <= msgs; i++)
611 {
612 struct Message *msg = mx_msg_open_new(m_spool, NULL, MUTT_ADD_FROM);
613 if (msg)
614 {
615 snprintf(buf, sizeof(buf), "RETR %d\r\n", i);
616 rc = pop_fetch_data(adata, buf, NULL, fetch_message, msg->fp);
617 if (rc == -3)
618 rset = 1;
619
620 if ((rc == 0) && (mx_msg_commit(m_spool, msg) != 0))
621 {
622 rset = 1;
623 rc = -3;
624 }
625
626 mx_msg_close(m_spool, &msg);
627 }
628 else
629 {
630 rc = -3;
631 }
632
633 if ((rc == 0) && (delanswer == MUTT_YES))
634 {
635 /* delete the message on the server */
636 snprintf(buf, sizeof(buf), "DELE %d\r\n", i);
637 rc = pop_query(adata, buf, sizeof(buf));
638 }
639
640 if (rc == -1)
641 {
642 m_spool->append = old_append;
643 mx_mbox_close(m_spool);
644 goto fail;
645 }
646 if (rc == -2)
647 {
648 mutt_error("%s", adata->err_msg);
649 break;
650 }
651 if (rc == -3)
652 {
653 mutt_error(_("Error while writing mailbox"));
654 break;
655 }
656
657 /* L10N: The plural is picked by the second numerical argument, i.e.
658 the %d right before 'messages', i.e. the total number of messages. */
659 mutt_message(ngettext("%s [%d of %d message read]",
660 "%s [%d of %d messages read]", msgs - last),
661 msgbuf, i - last, msgs - last);
662 }
663
664 m_spool->append = old_append;
665 mx_mbox_close(m_spool);
666
667 if (rset)
668 {
669 /* make sure no messages get deleted */
670 mutt_str_copy(buf, "RSET\r\n", sizeof(buf));
671 if (pop_query(adata, buf, sizeof(buf)) == -1)
672 goto fail;
673 }
674
675finish:
676 /* exit gracefully */
677 mutt_str_copy(buf, "QUIT\r\n", sizeof(buf));
678 if (pop_query(adata, buf, sizeof(buf)) == -1)
679 goto fail;
680 mutt_socket_close(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:291
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:89
void pop_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free() -.
Definition: adata.c:41
#define mutt_message(...)
Definition: logging2.h:91
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:51
struct Connection * mutt_conn_find(const struct ConnAccount *cac)
Find a connection from a list.
Definition: mutt_socket.c:90
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1180
bool mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:288
struct Message * mx_msg_open_new(struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
Open a new message.
Definition: mx.c:1040
int mx_msg_commit(struct Mailbox *m, struct Message *msg)
Commit a message to a folder - Wrapper for MxOps::msg_commit()
Definition: mx.c:1159
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1636
enum MxStatus mx_mbox_close(struct Mailbox *m)
Save changes and close mailbox.
Definition: mx.c:598
#define MUTT_ADD_FROM
add a From_ line
Definition: mx.h:39
#define MUTT_OPEN_NO_FLAGS
No flags are set.
Definition: mxapi.h:40
struct PopAccountData * pop_adata_new(void)
Create a new PopAccountData object.
Definition: adata.c:63
int pop_open_connection(struct PopAccountData *adata)
Open connection and authenticate.
Definition: lib.c:317
int pop_parse_path(const char *path, struct ConnAccount *cac)
Parse a POP mailbox name.
Definition: lib.c:83
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(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition: question.c:365
int mutt_socket_close(struct Connection *conn)
Close a socket.
Definition: socket.c:100
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: message.h:34
FILE * fp
pointer to the message data
Definition: message.h:35
enum UrlScheme url_check_scheme(const char *str)
Check the protocol of a URL.
Definition: url.c:226
@ 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: