NeoMutt  2024-04-16-36-g75b6fb
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
private.h File Reference

POP network mailbox. More...

#include <stdbool.h>
#include <time.h>
#include "conn/lib.h"
+ Include dependency graph for private.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  PopCache
 POP-specific email cache. More...
 
struct  PopAuth
 POP authentication multiplexor. More...
 

Macros

#define POP_PORT   110
 
#define POP_SSL_PORT   995
 
#define POP_CACHE_LEN   10
 
#define POP_CMD_RESPONSE   512
 
#define pop_query(adata, buf, buflen)   pop_query_d(adata, buf, buflen, NULL)
 

Typedefs

typedef int(* pop_fetch_t) (const char *str, void *data)
 

Enumerations

enum  PopStatus { POP_NONE = 0 , POP_CONNECTED , POP_DISCONNECTED }
 POP server responses. More...
 
enum  PopAuthRes { POP_A_SUCCESS = 0 , POP_A_SOCKET , POP_A_FAILURE , POP_A_UNAVAIL }
 POP authentication responses. More...
 

Functions

bool pop_auth_is_valid (const char *authenticator)
 Check if string is a valid pop authentication method.
 
int pop_authenticate (struct PopAccountData *adata)
 Authenticate with a POP server.
 
void pop_apop_timestamp (struct PopAccountData *adata, char *buf)
 Get the server timestamp for APOP authentication.
 
int pop_parse_path (const char *path, struct ConnAccount *acct)
 Parse a POP mailbox name.
 
int pop_connect (struct PopAccountData *adata)
 Open connection.
 
int pop_open_connection (struct PopAccountData *adata)
 Open connection and authenticate.
 
int pop_query_d (struct PopAccountData *adata, char *buf, size_t buflen, char *msg)
 Send data from buffer and receive answer to the same buffer.
 
int pop_fetch_data (struct PopAccountData *adata, const char *query, struct Progress *progress, pop_fetch_t callback, void *data)
 Read Headers with callback function.
 
int pop_reconnect (struct Mailbox *m)
 Reconnect and verify indexes if connection was lost.
 
void pop_logout (struct Mailbox *m)
 Logout from a POP server.
 
const char * pop_get_field (enum ConnAccountField field, void *gf_data)
 Get connection login credentials - Implements ConnAccount::get_field() -.
 

Detailed Description

POP network mailbox.

Authors
  • Vsevolod Volkov
  • Richard Russon

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

Macro Definition Documentation

◆ POP_PORT

#define POP_PORT   110

Definition at line 35 of file private.h.

◆ POP_SSL_PORT

#define POP_SSL_PORT   995

Definition at line 36 of file private.h.

◆ POP_CACHE_LEN

#define POP_CACHE_LEN   10

Definition at line 39 of file private.h.

◆ POP_CMD_RESPONSE

#define POP_CMD_RESPONSE   512

Definition at line 42 of file private.h.

◆ pop_query

#define pop_query (   adata,
  buf,
  buflen 
)    pop_query_d(adata, buf, buflen, NULL)

Definition at line 111 of file private.h.

Typedef Documentation

◆ pop_fetch_t

typedef int(* pop_fetch_t) (const char *str, void *data)

Definition at line 108 of file private.h.

Enumeration Type Documentation

◆ PopStatus

enum PopStatus

POP server responses.

Enumerator
POP_NONE 

No connected to server.

POP_CONNECTED 

Connected to server.

POP_DISCONNECTED 

Disconnected from server.

Definition at line 47 of file private.h.

48{
49 POP_NONE = 0,
52};
@ POP_DISCONNECTED
Disconnected from server.
Definition: private.h:51
@ POP_CONNECTED
Connected to server.
Definition: private.h:50
@ POP_NONE
No connected to server.
Definition: private.h:49

◆ PopAuthRes

enum PopAuthRes

POP authentication responses.

Enumerator
POP_A_SUCCESS 

Authenticated successfully.

POP_A_SOCKET 

Connection lost.

POP_A_FAILURE 

Authentication failed.

POP_A_UNAVAIL 

No valid authentication method.

Definition at line 57 of file private.h.

58{
59 POP_A_SUCCESS = 0,
63};
@ POP_A_UNAVAIL
No valid authentication method.
Definition: private.h:62
@ POP_A_SUCCESS
Authenticated successfully.
Definition: private.h:59
@ POP_A_FAILURE
Authentication failed.
Definition: private.h:61
@ POP_A_SOCKET
Connection lost.
Definition: private.h:60

Function Documentation

◆ pop_auth_is_valid()

bool pop_auth_is_valid ( const char *  authenticator)

Check if string is a valid pop authentication method.

Parameters
authenticatorAuthenticator string to check
Return values
trueArgument is a valid auth method

Validate whether an input string is an accepted pop authentication method as defined by PopAuthenticators.

Definition at line 502 of file auth.c.

503{
504 for (size_t i = 0; i < mutt_array_size(PopAuthenticators); i++)
505 {
506 const struct PopAuth *auth = &PopAuthenticators[i];
507 if (auth->method && mutt_istr_equal(auth->method, authenticator))
508 return true;
509 }
510
511 return false;
512}
#define mutt_array_size(x)
Definition: memory.h:38
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:666
static const struct PopAuth PopAuthenticators[]
Accepted authentication methods.
Definition: auth.c:479
POP authentication multiplexor.
Definition: private.h:78
const char * method
Name of authentication method supported, NULL means variable.
Definition: private.h:89
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_authenticate()

int pop_authenticate ( struct PopAccountData adata)

Authenticate with a POP server.

Parameters
adataPOP Account data
Return values
numResult, e.g. POP_A_SUCCESS
0Successful
-1Connection lost
-2Login failed
-3Authentication cancelled

Definition at line 523 of file auth.c.

524{
525 struct ConnAccount *cac = &adata->conn->account;
526 const struct PopAuth *authenticator = NULL;
527 int attempts = 0;
528 int rc = POP_A_UNAVAIL;
529
530 if ((mutt_account_getuser(cac) < 0) || (cac->user[0] == '\0'))
531 {
532 return -3;
533 }
534
535 const struct Slist *c_pop_authenticators = cs_subset_slist(NeoMutt->sub, "pop_authenticators");
536 const bool c_pop_auth_try_all = cs_subset_bool(NeoMutt->sub, "pop_auth_try_all");
537 if (c_pop_authenticators && (c_pop_authenticators->count > 0))
538 {
539 /* Try user-specified list of authentication methods */
540 struct ListNode *np = NULL;
541 STAILQ_FOREACH(np, &c_pop_authenticators->head, entries)
542 {
543 mutt_debug(LL_DEBUG2, "Trying method %s\n", np->data);
544 authenticator = PopAuthenticators;
545
546 while (authenticator->authenticate)
547 {
548 if (!authenticator->method || mutt_istr_equal(authenticator->method, np->data))
549 {
550 rc = authenticator->authenticate(adata, np->data);
551 if (rc == POP_A_SOCKET)
552 {
553 switch (pop_connect(adata))
554 {
555 case 0:
556 {
557 rc = authenticator->authenticate(adata, np->data);
558 break;
559 }
560 case -2:
561 rc = POP_A_FAILURE;
562 }
563 }
564
565 if (rc != POP_A_UNAVAIL)
566 attempts++;
567 if ((rc == POP_A_SUCCESS) || (rc == POP_A_SOCKET) ||
568 ((rc == POP_A_FAILURE) && !c_pop_auth_try_all))
569 {
570 break;
571 }
572 }
573 authenticator++;
574 }
575 }
576 }
577 else
578 {
579 /* Fall back to default: any authenticator */
580 mutt_debug(LL_DEBUG2, "Using any available method\n");
581 authenticator = PopAuthenticators;
582
583 while (authenticator->authenticate)
584 {
585 rc = authenticator->authenticate(adata, NULL);
586 if (rc == POP_A_SOCKET)
587 {
588 switch (pop_connect(adata))
589 {
590 case 0:
591 {
592 rc = authenticator->authenticate(adata, NULL);
593 break;
594 }
595 case -2:
596 rc = POP_A_FAILURE;
597 }
598 }
599
600 if (rc != POP_A_UNAVAIL)
601 attempts++;
602 if ((rc == POP_A_SUCCESS) || (rc == POP_A_SOCKET) ||
603 ((rc == POP_A_FAILURE) && !c_pop_auth_try_all))
604 {
605 break;
606 }
607
608 authenticator++;
609 }
610 }
611
612 switch (rc)
613 {
614 case POP_A_SUCCESS:
615 return 0;
616 case POP_A_SOCKET:
617 return -1;
618 case POP_A_UNAVAIL:
619 if (attempts == 0)
620 mutt_error(_("No authenticators available"));
621 }
622
623 return -2;
624}
const struct Slist * cs_subset_slist(const struct ConfigSubset *sub, const char *name)
Get a string-list config item by name.
Definition: helpers.c:243
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
int mutt_account_getuser(struct ConnAccount *cac)
Retrieve username into ConnAccount, if necessary.
Definition: connaccount.c:52
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
#define _(a)
Definition: message.h:28
int pop_connect(struct PopAccountData *adata)
Open connection.
Definition: lib.c:282
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
Login details for a remote server.
Definition: connaccount.h:53
char user[128]
Username.
Definition: connaccount.h:56
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
struct Connection * conn
Connection to POP server.
Definition: adata.h:38
enum PopAuthRes(* authenticate)(struct PopAccountData *adata, const char *method)
Definition: private.h:87
String list.
Definition: slist.h:37
struct ListHead head
List containing values.
Definition: slist.h:38
size_t count
Number of values in list.
Definition: slist.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_apop_timestamp()

void pop_apop_timestamp ( struct PopAccountData adata,
char *  buf 
)

Get the server timestamp for APOP authentication.

Parameters
adataPOP Account data
bufTimestamp string

Definition at line 301 of file auth.c.

302{
303 char *p1 = NULL, *p2 = NULL;
304
305 FREE(&adata->timestamp);
306
307 if ((p1 = strchr(buf, '<')) && (p2 = strchr(p1, '>')))
308 {
309 p2[1] = '\0';
310 adata->timestamp = mutt_str_dup(p1);
311 }
312}
#define FREE(x)
Definition: memory.h:45
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
char * timestamp
Definition: adata.h:54
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_parse_path()

int pop_parse_path ( const char *  path,
struct ConnAccount cac 
)

Parse a POP mailbox name.

Parameters
pathPath to parse
cacAccount to store details
Return values
0success
-1error

Split a POP path into host, port, username and password

Definition at line 83 of file lib.c.

84{
85 /* Defaults */
86 cac->flags = 0;
88 cac->port = 0;
89 cac->service = "pop";
91
92 struct Url *url = url_parse(path);
93
94 if (!url || ((url->scheme != U_POP) && (url->scheme != U_POPS)) ||
95 !url->host || (mutt_account_fromurl(cac, url) < 0))
96 {
97 url_free(&url);
98 mutt_error(_("Invalid POP URL: %s"), path);
99 return -1;
100 }
101
102 if (url->scheme == U_POPS)
103 cac->flags |= MUTT_ACCT_SSL;
104
105 struct servent *service = getservbyname((url->scheme == U_POP) ? "pop3" : "pop3s", "tcp");
106 if (cac->port == 0)
107 {
108 if (service)
109 cac->port = ntohs(service->s_port);
110 else
111 cac->port = (url->scheme == U_POP) ? POP_PORT : POP_SSL_PORT;
112 }
113
114 url_free(&url);
115 return 0;
116}
#define MUTT_ACCT_SSL
Account uses SSL/TLS.
Definition: connaccount.h:47
const char * pop_get_field(enum ConnAccountField field, void *gf_data)
Get connection login credentials - Implements ConnAccount::get_field() -.
Definition: lib.c:57
int mutt_account_fromurl(struct ConnAccount *cac, const struct Url *url)
Fill ConnAccount with information from url.
Definition: mutt_account.c:44
@ MUTT_ACCT_TYPE_POP
Pop Account.
Definition: mutt_account.h:39
#define POP_SSL_PORT
Definition: private.h:36
#define POP_PORT
Definition: private.h:35
const char * service
Name of the service, e.g. "imap".
Definition: connaccount.h:61
const char *(* get_field)(enum ConnAccountField field, void *gf_data)
Definition: connaccount.h:70
unsigned char type
Connection type, e.g. MUTT_ACCT_TYPE_IMAP.
Definition: connaccount.h:59
MuttAccountFlags flags
Which fields are initialised, e.g. MUTT_ACCT_USER.
Definition: connaccount.h:60
unsigned short port
Port to connect to.
Definition: connaccount.h:58
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * host
Host.
Definition: url.h:73
char * path
Path.
Definition: url.h:75
enum UrlScheme scheme
Scheme, e.g. U_SMTPS.
Definition: url.h:70
struct Url * url_parse(const char *src)
Fill in Url.
Definition: url.c:239
void url_free(struct Url **ptr)
Free the contents of a URL.
Definition: url.c:124
@ U_POPS
Url is pops://.
Definition: url.h:38
@ U_POP
Url is pop://.
Definition: url.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_connect()

int pop_connect ( struct PopAccountData adata)

Open connection.

Parameters
adataPOP Account data
Return values
0Successful
-1Connection lost
-2Invalid response

Definition at line 282 of file lib.c.

283{
284 char buf[1024] = { 0 };
285
286 adata->status = POP_NONE;
287 if ((mutt_socket_open(adata->conn) < 0) ||
288 (mutt_socket_readln(buf, sizeof(buf), adata->conn) < 0))
289 {
290 mutt_error(_("Error connecting to server: %s"), adata->conn->account.host);
291 return -1;
292 }
293
294 adata->status = POP_CONNECTED;
295
296 if (!mutt_str_startswith(buf, "+OK"))
297 {
298 *adata->err_msg = '\0';
299 pop_error(adata, buf);
300 mutt_error("%s", adata->err_msg);
301 return -2;
302 }
303
304 pop_apop_timestamp(adata, buf);
305
306 return 0;
307}
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230
void pop_apop_timestamp(struct PopAccountData *adata, char *buf)
Get the server timestamp for APOP authentication.
Definition: auth.c:301
static void pop_error(struct PopAccountData *adata, char *msg)
Copy error message to err_msg buffer.
Definition: lib.c:123
int mutt_socket_open(struct Connection *conn)
Simple wrapper.
Definition: socket.c:76
#define mutt_socket_readln(buf, buflen, conn)
Definition: socket.h:56
char host[128]
Server to login to.
Definition: connaccount.h:54
char err_msg[POP_CMD_RESPONSE]
Definition: adata.h:56
unsigned int status
Definition: adata.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_open_connection()

int pop_open_connection ( struct PopAccountData adata)

Open connection and authenticate.

Parameters
adataPOP Account data
Return values
0Successful
-1Connection lost
-2Invalid command or execution error
-3Authentication cancelled

Definition at line 317 of file lib.c.

318{
319 char buf[1024] = { 0 };
320
321 int rc = pop_connect(adata);
322 if (rc < 0)
323 return rc;
324
325 rc = pop_capabilities(adata, 0);
326 if (rc == -1)
327 goto err_conn;
328 if (rc == -2)
329 return -2;
330
331#ifdef USE_SSL
332 /* Attempt STLS if available and desired. */
333 const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
334 if ((adata->conn->ssf == 0) && (adata->cmd_stls || c_ssl_force_tls))
335 {
336 if (c_ssl_force_tls)
337 adata->use_stls = 2;
338 if (adata->use_stls == 0)
339 {
340 enum QuadOption ans = query_quadoption(_("Secure connection with TLS?"),
341 NeoMutt->sub, "ssl_starttls");
342 if (ans == MUTT_ABORT)
343 return -2;
344 adata->use_stls = 1;
345 if (ans == MUTT_YES)
346 adata->use_stls = 2;
347 }
348 if (adata->use_stls == 2)
349 {
350 mutt_str_copy(buf, "STLS\r\n", sizeof(buf));
351 rc = pop_query(adata, buf, sizeof(buf));
352 // Clear any data after the STLS acknowledgement
353 mutt_socket_empty(adata->conn);
354 if (rc == -1)
355 goto err_conn;
356 if (rc != 0)
357 {
358 mutt_error("%s", adata->err_msg);
359 }
360 else if (mutt_ssl_starttls(adata->conn))
361 {
362 mutt_error(_("Could not negotiate TLS connection"));
363 return -2;
364 }
365 else
366 {
367 /* recheck capabilities after STLS completes */
368 rc = pop_capabilities(adata, 1);
369 if (rc == -1)
370 goto err_conn;
371 if (rc == -2)
372 return -2;
373 }
374 }
375 }
376
377 if (c_ssl_force_tls && (adata->conn->ssf == 0))
378 {
379 mutt_error(_("Encrypted connection unavailable"));
380 return -2;
381 }
382#endif
383
384 rc = pop_authenticate(adata);
385 if (rc == -1)
386 goto err_conn;
387 if (rc == -3)
389 if (rc != 0)
390 return rc;
391
392 /* recheck capabilities after authentication */
393 rc = pop_capabilities(adata, 2);
394 if (rc == -1)
395 goto err_conn;
396 if (rc == -2)
397 return -2;
398
399 /* get total size of mailbox */
400 mutt_str_copy(buf, "STAT\r\n", sizeof(buf));
401 rc = pop_query(adata, buf, sizeof(buf));
402 if (rc == -1)
403 goto err_conn;
404 if (rc == -2)
405 {
406 mutt_error("%s", adata->err_msg);
407 return rc;
408 }
409
410 unsigned int n = 0, size = 0;
411 sscanf(buf, "+OK %u %u", &n, &size);
412 adata->size = size;
413 return 0;
414
415err_conn:
416 adata->status = POP_DISCONNECTED;
417 mutt_error(_("Server closed connection"));
418 return -1;
419}
int mutt_ssl_starttls(struct Connection *conn)
Negotiate TLS over an already opened connection.
Definition: gnutls.c:1149
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:575
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
int pop_authenticate(struct PopAccountData *adata)
Authenticate with a POP server.
Definition: auth.c:523
static int pop_capabilities(struct PopAccountData *adata, int mode)
Get capabilities from a POP server.
Definition: lib.c:203
#define pop_query(adata, buf, buflen)
Definition: private.h:111
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ 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:366
void mutt_socket_empty(struct Connection *conn)
Clear out any queued data.
Definition: socket.c:306
unsigned int ssf
Security strength factor, in bits (see notes)
Definition: connection.h:50
size_t size
Definition: adata.h:50
bool cmd_stls
optional command STLS
Definition: adata.h:43
unsigned int use_stls
Definition: adata.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_query_d()

int pop_query_d ( struct PopAccountData adata,
char *  buf,
size_t  buflen,
char *  msg 
)

Send data from buffer and receive answer to the same buffer.

Parameters
adataPOP Account data
bufBuffer to send/store data
buflenBuffer length
msgProgress message
Return values
0Successful
-1Connection lost
-2Invalid command or execution error

Definition at line 466 of file lib.c.

467{
468 if (adata->status != POP_CONNECTED)
469 return -1;
470
471 /* print msg instead of real command */
472 if (msg)
473 {
474 mutt_debug(MUTT_SOCK_LOG_CMD, "> %s", msg);
475 }
476
478
479 char *c = strpbrk(buf, " \r\n");
480 if (c)
481 *c = '\0';
482 snprintf(adata->err_msg, sizeof(adata->err_msg), "%s: ", buf);
483
484 if (mutt_socket_readln_d(buf, buflen, adata->conn, MUTT_SOCK_LOG_FULL) < 0)
485 {
486 adata->status = POP_DISCONNECTED;
487 return -1;
488 }
489 if (mutt_str_startswith(buf, "+OK"))
490 return 0;
491
492 pop_error(adata, buf);
493 return -2;
494}
int mutt_socket_readln_d(char *buf, size_t buflen, struct Connection *conn, int dbg)
Read a line from a socket.
Definition: socket.c:238
#define MUTT_SOCK_LOG_FULL
Definition: socket.h:54
#define MUTT_SOCK_LOG_CMD
Definition: socket.h:52
#define mutt_socket_send_d(conn, buf, dbg)
Definition: socket.h:58
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_fetch_data()

int pop_fetch_data ( struct PopAccountData adata,
const char *  query,
struct Progress *  progress,
pop_fetch_t  callback,
void *  data 
)

Read Headers with callback function.

Parameters
adataPOP Account data
queryPOP query to send to server
progressProgress bar
callbackFunction called for each header read
dataData to pass to the callback
Return values
0Successful
-1Connection lost
-2Invalid command or execution error
-3Error in callback(*line, *data)

This function calls callback(*line, *data) for each received line, callback(NULL, *data) if rewind(*data) needs, exits when fail or done.

Definition at line 511 of file lib.c.

513{
514 char buf[1024] = { 0 };
515 long pos = 0;
516 size_t lenbuf = 0;
517
518 mutt_str_copy(buf, query, sizeof(buf));
519 int rc = pop_query(adata, buf, sizeof(buf));
520 if (rc < 0)
521 return rc;
522
523 char *inbuf = mutt_mem_malloc(sizeof(buf));
524
525 while (true)
526 {
527 const int chunk = mutt_socket_readln_d(buf, sizeof(buf), adata->conn, MUTT_SOCK_LOG_FULL);
528 if (chunk < 0)
529 {
530 adata->status = POP_DISCONNECTED;
531 rc = -1;
532 break;
533 }
534
535 char *p = buf;
536 if (!lenbuf && (buf[0] == '.'))
537 {
538 if (buf[1] != '.')
539 break;
540 p++;
541 }
542
543 mutt_str_copy(inbuf + lenbuf, p, sizeof(buf));
544 pos += chunk;
545
546 /* cast is safe since we break out of the loop when chunk<=0 */
547 if ((size_t) chunk >= sizeof(buf))
548 {
549 lenbuf += strlen(p);
550 }
551 else
552 {
553 progress_update(progress, pos, -1);
554 if ((rc == 0) && (callback(inbuf, data) < 0))
555 rc = -3;
556 lenbuf = 0;
557 }
558
559 mutt_mem_realloc(&inbuf, lenbuf + sizeof(buf));
560 }
561
562 FREE(&inbuf);
563 return rc;
564}
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:114
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition: progress.c:80
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_reconnect()

int pop_reconnect ( struct Mailbox m)

Reconnect and verify indexes if connection was lost.

Parameters
mMailbox
Return values
0Success
-1Error

Definition at line 609 of file lib.c.

610{
612
613 if (adata->status == POP_CONNECTED)
614 return 0;
615
616 while (true)
617 {
619
620 int rc = pop_open_connection(adata);
621 if (rc == 0)
622 {
623 struct Progress *progress = progress_new(MUTT_PROGRESS_NET, 0);
624 progress_set_message(progress, _("Verifying message indexes..."));
625
626 for (int i = 0; i < m->msg_count; i++)
627 {
628 struct PopEmailData *edata = pop_edata_get(m->emails[i]);
629 edata->refno = -1;
630 }
631
632 rc = pop_fetch_data(adata, "UIDL\r\n", progress, check_uidl, m);
633 progress_free(&progress);
634 if (rc == -2)
635 {
636 mutt_error("%s", adata->err_msg);
637 }
638 }
639
640 if (rc == 0)
641 return 0;
642
643 pop_logout(m);
644
645 if (rc < -1)
646 return -1;
647
648 if (query_quadoption(_("Connection lost. Reconnect to POP server?"),
649 NeoMutt->sub, "pop_reconnect") != MUTT_YES)
650 {
651 return -1;
652 }
653 }
654}
static int check_uidl(const char *line, void *data)
Parse UIDL response - Implements pop_fetch_t -.
Definition: lib.c:575
struct PopAccountData * pop_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:73
struct PopEmailData * pop_edata_get(struct Email *e)
Get the private data for this Email.
Definition: edata.c:68
int pop_open_connection(struct PopAccountData *adata)
Open connection and authenticate.
Definition: lib.c:317
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
void pop_logout(struct Mailbox *m)
Logout from a POP server.
Definition: lib.c:425
@ MUTT_PROGRESS_NET
Progress tracks bytes, according to $net_inc
Definition: lib.h:81
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__
int mutt_socket_close(struct Connection *conn)
Close a socket.
Definition: socket.c:100
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
void * edata
Driver-specific data.
Definition: email.h:74
int msg_count
Total number of messages.
Definition: mailbox.h:88
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
POP-specific Account data -.
Definition: adata.h:37
POP-specific Email data -.
Definition: edata.h:32
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ pop_logout()

void pop_logout ( struct Mailbox m)

Logout from a POP server.

Parameters
mMailbox

Definition at line 425 of file lib.c.

426{
428
429 if (adata->status == POP_CONNECTED)
430 {
431 int rc = 0;
432 char buf[1024] = { 0 };
433 mutt_message(_("Closing connection to POP server..."));
434
435 if (m->readonly)
436 {
437 mutt_str_copy(buf, "RSET\r\n", sizeof(buf));
438 rc = pop_query(adata, buf, sizeof(buf));
439 }
440
441 if (rc != -1)
442 {
443 mutt_str_copy(buf, "QUIT\r\n", sizeof(buf));
444 rc = pop_query(adata, buf, sizeof(buf));
445 }
446
447 if (rc < 0)
448 mutt_debug(LL_DEBUG1, "Error closing POP connection\n");
449
451 }
452
453 adata->status = POP_DISCONNECTED;
454}
#define mutt_message(...)
Definition: logging2.h:91
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
bool readonly
Don't allow changes to the mailbox.
Definition: mailbox.h:116
+ Here is the call graph for this function:
+ Here is the caller graph for this function: