NeoMutt  2025-12-11-694-ga89709
Teaching an old dog new tricks
 		DOXYGEN
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Enumerations | Functions
private.h File Reference

Shared constants/structs that are private to IMAP. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "config/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  ImapList
 Items in an IMAP browser. More...
 
struct  ImapCommand
 IMAP command structure. More...
 
struct  SeqsetIterator
 UID Sequence Set Iterator. More...
 

Macros

#define IMAP_PORT   143
 Default port for IMAP.
 
#define IMAP_SSL_PORT   993
 Port for IMAP over SSL/TLS.
 
#define IMAP_LOG_CMD   2
 Log commands only.
 
#define IMAP_LOG_LTRL   3
 Log literal values.
 
#define IMAP_LOG_PASS   5
 Log passwords (dangerous!)
 
#define IMAP_RES_NO   -2
 <tag> NO ...
 
#define IMAP_RES_BAD   -1
 <tag> BAD ...
 
#define IMAP_RES_OK   0
 <tag> OK ...
 
#define IMAP_RES_CONTINUE   1
 * ...
 
#define IMAP_RES_RESPOND   2
 +
 
#define IMAP_RES_NEW   3
 ImapCommand.state additions.
 
#define SEQ_LEN   16
 Length of IMAP sequence buffer.
 
#define IMAP_OPEN_NO_FLAGS   0
 No flags are set.
 
#define IMAP_REOPEN_ALLOW   (1 << 0)
 Allow re-opening a folder upon expunge.
 
#define IMAP_EXPUNGE_EXPECTED   (1 << 1)
 Messages will be expunged from the server.
 
#define IMAP_EXPUNGE_PENDING   (1 << 2)
 Messages on the server have been expunged.
 
#define IMAP_NEWMAIL_PENDING   (1 << 3)
 New mail is waiting on the server.
 
#define IMAP_FLAGS_PENDING   (1 << 4)
 Flags have changed on the server.
 
#define IMAP_CMD_NO_FLAGS   0
 No flags are set.
 
#define IMAP_CMD_PASS   (1 << 0)
 Command contains a password. Suppress logging.
 
#define IMAP_CMD_QUEUE   (1 << 1)
 Queue a command, do not execute.
 
#define IMAP_CMD_POLL   (1 << 2)
 Poll the tcp connection before running the imap command.
 
#define IMAP_CMD_SINGLE   (1 << 3)
 Run a single command.
 
#define IMAP_DATELEN   27
 Length of IMAP date string "DD-MMM-YYYY HH:MM:SS +ZZzz" plus NUL.
 
#define IMAP_CAP_NO_FLAGS   0
 No flags are set.
 
#define IMAP_CAP_IMAP4   (1 << 0)
 Server supports IMAP4.
 
#define IMAP_CAP_IMAP4REV1   (1 << 1)
 Server supports IMAP4rev1.
 
#define IMAP_CAP_STATUS   (1 << 2)
 Server supports STATUS command.
 
#define IMAP_CAP_ACL   (1 << 3)
 RFC2086: IMAP4 ACL extension.
 
#define IMAP_CAP_NAMESPACE   (1 << 4)
 RFC2342: IMAP4 Namespace.
 
#define IMAP_CAP_AUTH_CRAM_MD5   (1 << 5)
 RFC2195: CRAM-MD5 authentication.
 
#define IMAP_CAP_AUTH_GSSAPI   (1 << 6)
 RFC1731: GSSAPI authentication.
 
#define IMAP_CAP_AUTH_ANONYMOUS   (1 << 7)
 AUTH=ANONYMOUS.
 
#define IMAP_CAP_AUTH_OAUTHBEARER   (1 << 8)
 RFC7628: AUTH=OAUTHBEARER.
 
#define IMAP_CAP_AUTH_XOAUTH2   (1 << 9)
 AUTH=XOAUTH2, deprecated but used by OWA.
 
#define IMAP_CAP_STARTTLS   (1 << 10)
 RFC2595: STARTTLS.
 
#define IMAP_CAP_LOGINDISABLED   (1 << 11)
 RFC2595: LOGINDISABLED.
 
#define IMAP_CAP_IDLE   (1 << 12)
 RFC2177: IDLE.
 
#define IMAP_CAP_SASL_IR   (1 << 13)
 SASL initial response draft.
 
#define IMAP_CAP_ENABLE   (1 << 14)
 RFC5161.
 
#define IMAP_CAP_CONDSTORE   (1 << 15)
 RFC7162.
 
#define IMAP_CAP_QRESYNC   (1 << 16)
 RFC7162.
 
#define IMAP_CAP_LIST_EXTENDED   (1 << 17)
 RFC5258: IMAP4 LIST Command Extensions.
 
#define IMAP_CAP_COMPRESS   (1 << 18)
 RFC4978: COMPRESS=DEFLATE.
 
#define IMAP_CAP_X_GM_EXT_1   (1 << 19)
 https://developers.google.com/gmail/imap/imap-extensions
 
#define IMAP_CAP_ID   (1 << 20)
 RFC2971: IMAP4 ID extension.
 
#define IMAP_CAP_ALL   ((1 << 21) - 1)
 

Typedefs

typedef uint8_t ImapOpenFlags
 Flags, e.g. MUTT_THREAD_COLLAPSE.
 
typedef uint8_t ImapCmdFlags
 Flags for imap_exec(), e.g. IMAP_CMD_PASS.
 
typedef uint32_t ImapCapFlags
 Capabilities we are interested in.
 

Enumerations

enum  ImapExecResult { IMAP_EXEC_SUCCESS = 0 , IMAP_EXEC_ERROR , IMAP_EXEC_FATAL }
 Imap_exec return code. More...
 
enum  ImapFlags { IMAP_FATAL = 1 , IMAP_BYE }
 IMAP server responses. More...
 
enum  ImapState {
  IMAP_DISCONNECTED = 0 , IMAP_CONNECTED , IMAP_AUTHENTICATED , IMAP_SELECTED ,
  IMAP_IDLE
}
 IMAP connection state. More...
 

Functions

int imap_create_mailbox (struct ImapAccountData *adata, const char *mailbox)
 Create a new mailbox.
 
int imap_rename_mailbox (struct ImapAccountData *adata, char *oldname, const char *newname)
 Rename a mailbox.
 
int imap_open_connection (struct ImapAccountData *adata)
 Open an IMAP connection.
 
void imap_close_connection (struct ImapAccountData *adata)
 Close an IMAP connection.
 
int imap_read_literal (FILE *fp, struct ImapAccountData *adata, unsigned long bytes, struct Progress *progress)
 Read bytes bytes from server into file.
 
void imap_expunge_mailbox (struct Mailbox *m, bool resort)
 Purge messages from the server.
 
int imap_login (struct ImapAccountData *adata)
 Open an IMAP connection.
 
int imap_sync_message_for_copy (struct Mailbox *m, struct Email *e, struct Buffer *cmd, enum QuadOption *err_continue)
 Update server to reflect the flags of a single message.
 
bool imap_has_flag (struct ListHead *flag_list, const char *flag)
 Does the flag exist in the list.
 
int imap_adata_find (const char *path, struct ImapAccountData **adata, struct ImapMboxData **mdata)
 Find the Account data for this path.
 
int imap_authenticate (struct ImapAccountData *adata)
 Authenticate to an IMAP server.
 
int imap_cmd_start (struct ImapAccountData *adata, const char *cmdstr)
 Given an IMAP command, send it to the server.
 
int imap_cmd_step (struct ImapAccountData *adata)
 Reads server responses from an IMAP command.
 
void imap_cmd_finish (struct ImapAccountData *adata)
 Attempt to perform cleanup.
 
bool imap_code (const char *s)
 Was the command successful.
 
const char * imap_cmd_trailer (struct ImapAccountData *adata)
 Extra information after tagged command response if any.
 
int imap_exec (struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
 Execute a command and wait for the response from the server.
 
int imap_cmd_idle (struct ImapAccountData *adata)
 Enter the IDLE state.
 
int imap_read_headers (struct Mailbox *m, unsigned int msn_begin, unsigned int msn_end, bool initial_download)
 Read headers from the server.
 
char * imap_set_flags (struct Mailbox *m, struct Email *e, char *s, bool *server_changes)
 Fill the message header according to the server flags.
 
int imap_cache_del (struct Mailbox *m, struct Email *e)
 Delete an email from the body cache.
 
int imap_cache_clean (struct Mailbox *m)
 Delete all the entries in the message cache.
 
int imap_append_message (struct Mailbox *m, struct Message *msg)
 Write an email back to the server.
 
bool imap_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
 Open an email message in a Mailbox - Implements MxOps::msg_open() -.
 
int imap_msg_close (struct Mailbox *m, struct Message *msg)
 Close an email - Implements MxOps::msg_close() -.
 
int imap_msg_commit (struct Mailbox *m, struct Message *msg)
 Save changes to an email - Implements MxOps::msg_commit() -.
 
int imap_msg_save_hcache (struct Mailbox *m, struct Email *e)
 Save message to the header cache - Implements MxOps::msg_save_hcache() -.
 
void imap_hcache_open (struct ImapAccountData *adata, struct ImapMboxData *mdata, bool create)
 Open a header cache.
 
void imap_hcache_close (struct ImapMboxData *mdata)
 Close the header cache.
 
struct Email * imap_hcache_get (struct ImapMboxData *mdata, unsigned int uid)
 Get a header cache entry by its UID.
 
int imap_hcache_put (struct ImapMboxData *mdata, struct Email *e)
 Add an entry to the header cache.
 
int imap_hcache_del (struct ImapMboxData *mdata, unsigned int uid)
 Delete an item from the header cache.
 
int imap_hcache_store_uid_seqset (struct ImapMboxData *mdata)
 Store a UID Sequence Set in the header cache.
 
int imap_hcache_clear_uid_seqset (struct ImapMboxData *mdata)
 Delete a UID Sequence Set from the header cache.
 
char * imap_hcache_get_uid_seqset (struct ImapMboxData *mdata)
 Get a UID Sequence Set from the header cache.
 
enum QuadOption imap_continue (const char *msg, const char *resp)
 Display a message and ask the user if they want to go on.
 
void imap_error (const char *where, const char *msg)
 Show an error and abort.
 
void imap_mdata_cache_reset (struct ImapMboxData *mdata)
 Release and clear cache data of ImapMboxData structure.
 
char * imap_fix_path (const char *mailbox, char *path, size_t plen)
 Fix up the imap path.
 
char * imap_fix_path_with_delim (char delim, const char *mailbox, char *path, size_t plen)
 Fix up the imap path.
 
void imap_cachepath (char delim, const char *mailbox, struct Buffer *dest)
 Generate a cache path for a mailbox.
 
int imap_get_literal_count (char *buf, unsigned int *bytes)
 Write number of bytes in an IMAP literal into bytes.
 
char * imap_get_qualifier (char *buf)
 Get the qualifier from a tagged response.
 
char * imap_next_word (char *s)
 Find where the next IMAP word begins.
 
void imap_qualify_path (char *buf, size_t buflen, struct ConnAccount *conn_account, char *path)
 Make an absolute IMAP folder target.
 
void imap_buf_qualify_path (struct Buffer *buf, struct ConnAccount *conn_account, char *path)
 Make an absolute IMAP folder target to a buffer.
 
void imap_quote_string (char *dest, size_t dlen, const char *src, bool quote_backtick)
 Quote string according to IMAP rules.
 
void imap_unquote_string (char *s)
 Equally stupid unquoting routine.
 
void imap_munge_mbox_name (bool unicode, char *dest, size_t dlen, const char *src)
 Quote awkward characters in a mailbox name.
 
void imap_unmunge_mbox_name (bool unicode, char *s)
 Remove quoting from a mailbox name.
 
struct SeqsetIterator * mutt_seqset_iterator_new (const char *seqset)
 Create a new Sequence Set Iterator.
 
int mutt_seqset_iterator_next (struct SeqsetIterator *iter, unsigned int *next)
 Get the next UID from a Sequence Set.
 
void mutt_seqset_iterator_free (struct SeqsetIterator **ptr)
 Free a Sequence Set Iterator.
 
bool imap_account_match (const struct ConnAccount *a1, const struct ConnAccount *a2)
 Compare two Accounts.
 
void imap_get_parent (const char *mbox, char delim, char *buf, size_t buflen)
 Get an IMAP folder's parent.
 
bool mutt_account_match (const struct ConnAccount *a1, const struct ConnAccount *a2)
 
void imap_utf_encode (bool unicode, char **s)
 Encode email from local charset to UTF-8.
 
void imap_utf_decode (bool unicode, char **s)
 Decode email from UTF-8 to local charset.
 
void imap_allow_reopen (struct Mailbox *m)
 Allow re-opening a folder upon expunge.
 
void imap_disallow_reopen (struct Mailbox *m)
 Disallow re-opening a folder upon expunge.
 
void cmd_parse_search (struct ImapAccountData *adata, const char *s)
 Store SEARCH response for later use.
 

Detailed Description

Shared constants/structs that are private to IMAP.

Authors
  • Pietro Cerutti
  • Richard Russon
  • Mehdi Abaakouk
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 private.h.

Macro Definition Documentation

◆ IMAP_PORT

#define IMAP_PORT   143

Default port for IMAP.

Definition at line 44 of file private.h.

◆ IMAP_SSL_PORT

#define IMAP_SSL_PORT   993

Port for IMAP over SSL/TLS.

Definition at line 45 of file private.h.

◆ IMAP_LOG_CMD

#define IMAP_LOG_CMD   2

Log commands only.

Definition at line 47 of file private.h.

◆ IMAP_LOG_LTRL

#define IMAP_LOG_LTRL   3

Log literal values.

Definition at line 48 of file private.h.

◆ IMAP_LOG_PASS

#define IMAP_LOG_PASS   5

Log passwords (dangerous!)

Definition at line 49 of file private.h.

◆ IMAP_RES_NO

#define IMAP_RES_NO   -2

<tag> NO ...

Definition at line 52 of file private.h.

◆ IMAP_RES_BAD

#define IMAP_RES_BAD   -1

<tag> BAD ...

Definition at line 53 of file private.h.

◆ IMAP_RES_OK

#define IMAP_RES_OK   0

<tag> OK ...

Definition at line 54 of file private.h.

◆ IMAP_RES_CONTINUE

#define IMAP_RES_CONTINUE   1

* ...

Definition at line 55 of file private.h.

◆ IMAP_RES_RESPOND

#define IMAP_RES_RESPOND   2

+

Definition at line 56 of file private.h.

◆ IMAP_RES_NEW

#define IMAP_RES_NEW   3

ImapCommand.state additions.

Definition at line 57 of file private.h.

◆ SEQ_LEN

#define SEQ_LEN   16

Length of IMAP sequence buffer.

Definition at line 60 of file private.h.

◆ IMAP_OPEN_NO_FLAGS

#define IMAP_OPEN_NO_FLAGS   0

No flags are set.

Definition at line 63 of file private.h.

◆ IMAP_REOPEN_ALLOW

#define IMAP_REOPEN_ALLOW   (1 << 0)

Allow re-opening a folder upon expunge.

Definition at line 64 of file private.h.

◆ IMAP_EXPUNGE_EXPECTED

#define IMAP_EXPUNGE_EXPECTED   (1 << 1)

Messages will be expunged from the server.

Definition at line 65 of file private.h.

◆ IMAP_EXPUNGE_PENDING

#define IMAP_EXPUNGE_PENDING   (1 << 2)

Messages on the server have been expunged.

Definition at line 66 of file private.h.

◆ IMAP_NEWMAIL_PENDING

#define IMAP_NEWMAIL_PENDING   (1 << 3)

New mail is waiting on the server.

Definition at line 67 of file private.h.

◆ IMAP_FLAGS_PENDING

#define IMAP_FLAGS_PENDING   (1 << 4)

Flags have changed on the server.

Definition at line 68 of file private.h.

◆ IMAP_CMD_NO_FLAGS

#define IMAP_CMD_NO_FLAGS   0

No flags are set.

Definition at line 71 of file private.h.

◆ IMAP_CMD_PASS

#define IMAP_CMD_PASS   (1 << 0)

Command contains a password. Suppress logging.

Definition at line 72 of file private.h.

◆ IMAP_CMD_QUEUE

#define IMAP_CMD_QUEUE   (1 << 1)

Queue a command, do not execute.

Definition at line 73 of file private.h.

◆ IMAP_CMD_POLL

#define IMAP_CMD_POLL   (1 << 2)

Poll the tcp connection before running the imap command.

Definition at line 74 of file private.h.

◆ IMAP_CMD_SINGLE

#define IMAP_CMD_SINGLE   (1 << 3)

Run a single command.

Definition at line 75 of file private.h.

◆ IMAP_DATELEN

#define IMAP_DATELEN   27

Length of IMAP date string "DD-MMM-YYYY HH:MM:SS +ZZzz" plus NUL.

Definition at line 88 of file private.h.

◆ IMAP_CAP_NO_FLAGS

#define IMAP_CAP_NO_FLAGS   0

No flags are set.

Definition at line 120 of file private.h.

◆ IMAP_CAP_IMAP4

#define IMAP_CAP_IMAP4   (1 << 0)

Server supports IMAP4.

Definition at line 121 of file private.h.

◆ IMAP_CAP_IMAP4REV1

#define IMAP_CAP_IMAP4REV1   (1 << 1)

Server supports IMAP4rev1.

Definition at line 122 of file private.h.

◆ IMAP_CAP_STATUS

#define IMAP_CAP_STATUS   (1 << 2)

Server supports STATUS command.

Definition at line 123 of file private.h.

◆ IMAP_CAP_ACL

#define IMAP_CAP_ACL   (1 << 3)

RFC2086: IMAP4 ACL extension.

Definition at line 124 of file private.h.

◆ IMAP_CAP_NAMESPACE

#define IMAP_CAP_NAMESPACE   (1 << 4)

RFC2342: IMAP4 Namespace.

Definition at line 125 of file private.h.

◆ IMAP_CAP_AUTH_CRAM_MD5

#define IMAP_CAP_AUTH_CRAM_MD5   (1 << 5)

RFC2195: CRAM-MD5 authentication.

Definition at line 126 of file private.h.

◆ IMAP_CAP_AUTH_GSSAPI

#define IMAP_CAP_AUTH_GSSAPI   (1 << 6)

RFC1731: GSSAPI authentication.

Definition at line 127 of file private.h.

◆ IMAP_CAP_AUTH_ANONYMOUS

#define IMAP_CAP_AUTH_ANONYMOUS   (1 << 7)

AUTH=ANONYMOUS.

Definition at line 128 of file private.h.

◆ IMAP_CAP_AUTH_OAUTHBEARER

#define IMAP_CAP_AUTH_OAUTHBEARER   (1 << 8)

RFC7628: AUTH=OAUTHBEARER.

Definition at line 129 of file private.h.

◆ IMAP_CAP_AUTH_XOAUTH2

#define IMAP_CAP_AUTH_XOAUTH2   (1 << 9)

AUTH=XOAUTH2, deprecated but used by OWA.

Definition at line 130 of file private.h.

◆ IMAP_CAP_STARTTLS

#define IMAP_CAP_STARTTLS   (1 << 10)

RFC2595: STARTTLS.

Definition at line 131 of file private.h.

◆ IMAP_CAP_LOGINDISABLED

#define IMAP_CAP_LOGINDISABLED   (1 << 11)

RFC2595: LOGINDISABLED.

Definition at line 132 of file private.h.

◆ IMAP_CAP_IDLE

#define IMAP_CAP_IDLE   (1 << 12)

RFC2177: IDLE.

Definition at line 133 of file private.h.

◆ IMAP_CAP_SASL_IR

#define IMAP_CAP_SASL_IR   (1 << 13)

SASL initial response draft.

Definition at line 134 of file private.h.

◆ IMAP_CAP_ENABLE

#define IMAP_CAP_ENABLE   (1 << 14)

RFC5161.

Definition at line 135 of file private.h.

◆ IMAP_CAP_CONDSTORE

#define IMAP_CAP_CONDSTORE   (1 << 15)

RFC7162.

Definition at line 136 of file private.h.

◆ IMAP_CAP_QRESYNC

#define IMAP_CAP_QRESYNC   (1 << 16)

RFC7162.

Definition at line 137 of file private.h.

◆ IMAP_CAP_LIST_EXTENDED

#define IMAP_CAP_LIST_EXTENDED   (1 << 17)

RFC5258: IMAP4 LIST Command Extensions.

Definition at line 138 of file private.h.

◆ IMAP_CAP_COMPRESS

#define IMAP_CAP_COMPRESS   (1 << 18)

RFC4978: COMPRESS=DEFLATE.

Definition at line 139 of file private.h.

◆ IMAP_CAP_X_GM_EXT_1

#define IMAP_CAP_X_GM_EXT_1   (1 << 19)

https://developers.google.com/gmail/imap/imap-extensions

Definition at line 140 of file private.h.

◆ IMAP_CAP_ID

#define IMAP_CAP_ID   (1 << 20)

RFC2971: IMAP4 ID extension.

Definition at line 141 of file private.h.

◆ IMAP_CAP_ALL

#define IMAP_CAP_ALL   ((1 << 21) - 1)

Definition at line 143 of file private.h.

Typedef Documentation

◆ ImapOpenFlags

typedef uint8_t ImapOpenFlags

Flags, e.g. MUTT_THREAD_COLLAPSE.

Definition at line 62 of file private.h.

◆ ImapCmdFlags

typedef uint8_t ImapCmdFlags

Flags for imap_exec(), e.g. IMAP_CMD_PASS.

Definition at line 70 of file private.h.

◆ ImapCapFlags

typedef uint32_t ImapCapFlags

Capabilities we are interested in.

Note
This must be kept in the same order as Capabilities. Flags, e.g. IMAP_CAP_IMAP4

Definition at line 119 of file private.h.

Enumeration Type Documentation

◆ ImapExecResult

enum ImapExecResult

Imap_exec return code.

Enumerator
IMAP_EXEC_SUCCESS 

Imap command executed or queued successfully.

IMAP_EXEC_ERROR 

Imap command failure.

IMAP_EXEC_FATAL 

Imap connection failure.

Definition at line 80 of file private.h.

81{
82 IMAP_EXEC_SUCCESS = 0,
83 IMAP_EXEC_ERROR,
84 IMAP_EXEC_FATAL,
85};
IMAP_EXEC_SUCCESS
@ IMAP_EXEC_SUCCESS
Imap command executed or queued successfully.
Definition private.h:82
IMAP_EXEC_ERROR
@ IMAP_EXEC_ERROR
Imap command failure.
Definition private.h:83
IMAP_EXEC_FATAL
@ IMAP_EXEC_FATAL
Imap connection failure.
Definition private.h:84

◆ ImapFlags

enum ImapFlags

IMAP server responses.

Enumerator
IMAP_FATAL 

Unrecoverable error occurred.

IMAP_BYE 

Logged out from server.

Definition at line 93 of file private.h.

94{
95 IMAP_FATAL = 1,
96 IMAP_BYE,
97};
IMAP_BYE
@ IMAP_BYE
Logged out from server.
Definition private.h:96
IMAP_FATAL
@ IMAP_FATAL
Unrecoverable error occurred.
Definition private.h:95

◆ ImapState

enum ImapState

IMAP connection state.

Enumerator
IMAP_DISCONNECTED 

Disconnected from server.

IMAP_CONNECTED 

Connected to server.

IMAP_AUTHENTICATED 

Connection is authenticated.

IMAP_SELECTED 

Mailbox is selected.

IMAP_IDLE 

Connection is idle.

Definition at line 102 of file private.h.

103{
104 /* States */
105 IMAP_DISCONNECTED = 0,
106 IMAP_CONNECTED,
107 IMAP_AUTHENTICATED,
108 IMAP_SELECTED,
109
110 /* and pseudo-states */
111 IMAP_IDLE,
112};
IMAP_DISCONNECTED
@ IMAP_DISCONNECTED
Disconnected from server.
Definition private.h:105
IMAP_IDLE
@ IMAP_IDLE
Connection is idle.
Definition private.h:111
IMAP_AUTHENTICATED
@ IMAP_AUTHENTICATED
Connection is authenticated.
Definition private.h:107
IMAP_SELECTED
@ IMAP_SELECTED
Mailbox is selected.
Definition private.h:108
IMAP_CONNECTED
@ IMAP_CONNECTED
Connected to server.
Definition private.h:106

Function Documentation

◆ imap_create_mailbox()

int imap_create_mailbox ( struct ImapAccountData * adata,
const char * mailbox )

Create a new mailbox.

Parameters
adataImap Account data
mailboxMailbox to create
Return values
0Success
-1Failure

Definition at line 542 of file imap.c.

543{
544 char buf[2048] = { 0 };
545 char mbox[1024] = { 0 };
546
547 imap_munge_mbox_name(adata->unicode, mbox, sizeof(mbox), mailbox);
548 snprintf(buf, sizeof(buf), "CREATE %s", mbox);
549
550 if (imap_exec(adata, buf, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
551 {
552 mutt_error(_("CREATE failed: %s"), imap_cmd_trailer(adata));
553 return -1;
554 }
555
556 return 0;
557}
mutt_error
#define mutt_error(...)
Definition logging2.h:94
imap_cmd_trailer
const char * imap_cmd_trailer(struct ImapAccountData *adata)
Extra information after tagged command response if any.
Definition command.c:1378
imap_exec
int imap_exec(struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
Execute a command and wait for the response from the server.
Definition command.c:1415
IMAP_CMD_NO_FLAGS
#define IMAP_CMD_NO_FLAGS
No flags are set.
Definition private.h:71
imap_munge_mbox_name
void imap_munge_mbox_name(bool unicode, char *dest, size_t dlen, const char *src)
Quote awkward characters in a mailbox name.
Definition util.c:968
_
#define _(a)
Definition message.h:28
ImapAccountData::unicode
bool unicode
If true, we can send UTF-8, and the server will use UTF8 rather than mUTF7.
Definition adata.h:63
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_rename_mailbox()

int imap_rename_mailbox ( struct ImapAccountData * adata,
char * oldname,
const char * newname )

Rename a mailbox.

Parameters
adataImap Account data
oldnameExisting mailbox
newnameNew name for mailbox
Return values
0Success
-1Failure

Definition at line 584 of file imap.c.

585{
586 char oldmbox[1024] = { 0 };
587 char newmbox[1024] = { 0 };
588 int rc = 0;
589
590 imap_munge_mbox_name(adata->unicode, oldmbox, sizeof(oldmbox), oldname);
591 imap_munge_mbox_name(adata->unicode, newmbox, sizeof(newmbox), newname);
592
593 struct Buffer *buf = buf_pool_get();
594 buf_printf(buf, "RENAME %s %s", oldmbox, newmbox);
595
596 if (imap_exec(adata, buf_string(buf), IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
597 rc = -1;
598
599 buf_pool_release(&buf);
600
601 return rc;
602}
buf_printf
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition buffer.c:161
buf_string
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition buffer.h:96
buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition pool.c:91
buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition pool.c:111
Buffer
String manipulation buffer.
Definition buffer.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_open_connection()

int imap_open_connection ( struct ImapAccountData * adata)

Open an IMAP connection.

Parameters
adataImap Account data
Return values
0Success
-1Failure

Definition at line 921 of file imap.c.

922{
923 if (mutt_socket_open(adata->conn) < 0)
924 return -1;
925
926 adata->state = IMAP_CONNECTED;
927
928 if (imap_cmd_step(adata) != IMAP_RES_OK)
929 {
930 imap_close_connection(adata);
931 return -1;
932 }
933
934 if (mutt_istr_startswith(adata->buf, "* OK"))
935 {
936 if (!mutt_istr_startswith(adata->buf, "* OK [CAPABILITY") && check_capabilities(adata))
937 {
938 goto bail;
939 }
940#ifdef USE_SSL
941 /* Attempt STARTTLS if available and desired. */
942 const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
943 if ((adata->conn->ssf == 0) &&
944 (c_ssl_force_tls || (adata->capabilities & IMAP_CAP_STARTTLS)))
945 {
946 enum QuadOption ans;
947
948 if (c_ssl_force_tls)
949 {
950 ans = MUTT_YES;
951 }
952 else if ((ans = query_quadoption(_("Secure connection with TLS?"),
953 NeoMutt->sub, "ssl_starttls")) == MUTT_ABORT)
954 {
955 goto bail;
956 }
957 if (ans == MUTT_YES)
958 {
959 enum ImapExecResult rc = imap_exec(adata, "STARTTLS", IMAP_CMD_SINGLE);
960 // Clear any data after the STARTTLS acknowledgement
961 mutt_socket_empty(adata->conn);
962
963 if (rc == IMAP_EXEC_FATAL)
964 goto bail;
965 if (rc != IMAP_EXEC_ERROR)
966 {
967 if (mutt_ssl_starttls(adata->conn))
968 {
969 mutt_error(_("Could not negotiate TLS connection"));
970 goto bail;
971 }
972 else
973 {
974 /* RFC2595 demands we recheck CAPABILITY after TLS completes. */
975 if (imap_exec(adata, "CAPABILITY", IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
976 goto bail;
977 }
978 }
979 }
980 }
981
982 if (c_ssl_force_tls && (adata->conn->ssf == 0))
983 {
984 mutt_error(_("Encrypted connection unavailable"));
985 goto bail;
986 }
987#endif
988 }
989 else if (mutt_istr_startswith(adata->buf, "* PREAUTH"))
990 {
991#ifdef USE_SSL
992 /* Unless using a secure $tunnel, an unencrypted PREAUTH response may be a
993 * MITM attack. The only way to stop "STARTTLS" MITM attacks is via
994 * $ssl_force_tls: an attacker can easily spoof "* OK" and strip the
995 * STARTTLS capability. So consult $ssl_force_tls, not $ssl_starttls, to
996 * decide whether to abort. Note that if using $tunnel and
997 * $tunnel_is_secure, adata->conn->ssf will be set to 1. */
998 const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
999 if ((adata->conn->ssf == 0) && c_ssl_force_tls)
1000 {
1001 mutt_error(_("Encrypted connection unavailable"));
1002 goto bail;
1003 }
1004#endif
1005
1006 adata->state = IMAP_AUTHENTICATED;
1007 if (check_capabilities(adata) != 0)
1008 goto bail;
1009 FREE(&adata->capstr);
1010 }
1011 else
1012 {
1013 imap_error("imap_open_connection()", adata->buf);
1014 goto bail;
1015 }
1016
1017 return 0;
1018
1019bail:
1020 imap_close_connection(adata);
1021 FREE(&adata->capstr);
1022 return -1;
1023}
cs_subset_bool
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition helpers.c:47
mutt_ssl_starttls
int mutt_ssl_starttls(struct Connection *conn)
Negotiate TLS over an already opened connection.
Definition gnutls.c:1172
imap_cmd_step
int imap_cmd_step(struct ImapAccountData *adata)
Reads server responses from an IMAP command.
Definition command.c:1225
IMAP_RES_OK
#define IMAP_RES_OK
<tag> OK ...
Definition private.h:54
IMAP_CAP_STARTTLS
#define IMAP_CAP_STARTTLS
RFC2595: STARTTLS.
Definition private.h:131
ImapExecResult
ImapExecResult
Imap_exec return code.
Definition private.h:81
imap_error
void imap_error(const char *where, const char *msg)
Show an error and abort.
Definition util.c:662
IMAP_CMD_SINGLE
#define IMAP_CMD_SINGLE
Run a single command.
Definition private.h:75
imap_close_connection
void imap_close_connection(struct ImapAccountData *adata)
Close an IMAP connection.
Definition imap.c:1029
check_capabilities
static int check_capabilities(struct ImapAccountData *adata)
Make sure we can log in to this server.
Definition imap.c:207
FREE
#define FREE(x)
Free memory and set the pointer to NULL.
Definition memory.h:68
mutt_istr_startswith
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition string.c:246
QuadOption
QuadOption
Possible values for a quad-option.
Definition quad.h:36
MUTT_ABORT
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition quad.h:37
MUTT_YES
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition quad.h:39
query_quadoption
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition question.c:384
mutt_socket_empty
void mutt_socket_empty(struct Connection *conn)
Clear out any queued data.
Definition socket.c:306
mutt_socket_open
int mutt_socket_open(struct Connection *conn)
Simple wrapper.
Definition socket.c:76
Connection::ssf
unsigned int ssf
Security strength factor, in bits (see notes)
Definition connection.h:50
ImapAccountData::capabilities
ImapCapFlags capabilities
Capability flags.
Definition adata.h:55
ImapAccountData::state
unsigned char state
ImapState, e.g. IMAP_AUTHENTICATED.
Definition adata.h:44
ImapAccountData::capstr
char * capstr
Capability string from the server.
Definition adata.h:54
ImapAccountData::buf
char * buf
Command buffer.
Definition adata.h:60
ImapAccountData::conn
struct Connection * conn
Connection to IMAP server.
Definition adata.h:41
NeoMutt
Container for Accounts, Notifications.
Definition neomutt.h:41
NeoMutt::sub
struct ConfigSubset * sub
Inherited config items.
Definition neomutt.h:49
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_close_connection()

void imap_close_connection ( struct ImapAccountData * adata)

Close an IMAP connection.

Parameters
adataImap Account data

Definition at line 1029 of file imap.c.

1030{
1031 if (adata->state != IMAP_DISCONNECTED)
1032 {
1033 mutt_socket_close(adata->conn);
1034 adata->state = IMAP_DISCONNECTED;
1035 }
1036 adata->seqno = 0;
1037 adata->nextcmd = 0;
1038 adata->lastcmd = 0;
1039 adata->status = 0;
1040 memset(adata->cmds, 0, sizeof(struct ImapCommand) * adata->cmdslots);
1041}
mutt_socket_close
int mutt_socket_close(struct Connection *conn)
Close a socket.
Definition socket.c:100
ImapAccountData::lastcmd
int lastcmd
Last command in the queue.
Definition adata.h:75
ImapAccountData::nextcmd
int nextcmd
Next command to be sent.
Definition adata.h:74
ImapAccountData::cmds
struct ImapCommand * cmds
Queue of commands for the server.
Definition adata.h:72
ImapAccountData::status
unsigned char status
ImapFlags, e.g. IMAP_FATAL.
Definition adata.h:45
ImapAccountData::cmdslots
int cmdslots
Size of the command queue.
Definition adata.h:73
ImapAccountData::seqno
unsigned int seqno
tag sequence number, e.g. '{seqid}0001'
Definition adata.h:57
ImapCommand
IMAP command structure.
Definition private.h:160
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_read_literal()

int imap_read_literal ( FILE * fp,
struct ImapAccountData * adata,
unsigned long bytes,
struct Progress * progress )

Read bytes bytes from server into file.

Parameters
fpFile handle for email file
adataImap Account data
bytesNumber of bytes to read
progressProgress bar
Return values
0Success
-1Failure

Not explicitly buffered, relies on FILE buffering.

Note
Strips \r from \r\n. Apparently even literals use \r\n-terminated strings ?!

Definition at line 704 of file imap.c.

706{
707 char c;
708 bool r = false;
709 struct Buffer buf = { 0 }; // Do not allocate, maybe it won't be used
710
711 const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
712 if (c_debug_level >= IMAP_LOG_LTRL)
713 buf_alloc(&buf, bytes + 1);
714
715 mutt_debug(LL_DEBUG2, "reading %lu byte literal from server\n", bytes);
716
717 /* For large transfers, calculate checkpoint for progress logging */
718 unsigned long checkpoint = bytes / 10; // Log every 10%
719 if (checkpoint == 0)
720 checkpoint = bytes; // For small transfers, don't log progress
721
722 time_t start_time = mutt_date_now();
723 time_t last_progress = start_time;
724 time_t last_activity = start_time;
725
726 /* Get timeout value - use imap_poll_timeout or default to 60 seconds */
727 const short c_imap_poll_timeout = cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
728 const int stall_timeout = (c_imap_poll_timeout > 0) ? c_imap_poll_timeout : 60;
729
730 for (unsigned long pos = 0; pos < bytes; pos++)
731 {
732 /* Check for user interrupt (Ctrl-C) periodically */
733 if ((pos % 4096) == 0)
734 {
735 if (SigInt)
736 {
737 mutt_debug(LL_DEBUG1, "Literal read interrupted by user at %lu/%lu bytes\n",
738 pos, bytes);
739 mutt_error(_("Download interrupted"));
740 SigInt = false;
741 adata->status = IMAP_FATAL;
742 buf_dealloc(&buf);
743 return -1;
744 }
745
746 /* Check for stalled transfer */
747 time_t now = mutt_date_now();
748 if ((now - last_activity) > stall_timeout)
749 {
750 mutt_debug(LL_DEBUG1, "Literal read stalled at %lu/%lu bytes (no data for %d seconds)\n",
751 pos, bytes, stall_timeout);
752 mutt_error(_("Download stalled - no data received for %d seconds"), stall_timeout);
753 adata->status = IMAP_FATAL;
754 buf_dealloc(&buf);
755 return -1;
756 }
757 }
758
759 if (mutt_socket_readchar(adata->conn, &c) != 1)
760 {
761 time_t duration = mutt_date_now() - start_time;
762 mutt_debug(LL_DEBUG1, "Error during literal read at byte %lu/%lu (%.1f%% complete)\n",
763 pos, bytes, (bytes > 0) ? ((double) pos / bytes * 100.0) : 0.0);
764 mutt_debug(LL_DEBUG1, "Read failed after %ld seconds (errno=%d: %s)\n",
765 (long) duration, errno, strerror(errno));
766 adata->status = IMAP_FATAL;
767
768 buf_dealloc(&buf);
769 return -1;
770 }
771
772 last_activity = mutt_date_now();
773
774 if (r && (c != '\n'))
775 fputc('\r', fp);
776
777 if (c == '\r')
778 {
779 r = true;
780 continue;
781 }
782 else
783 {
784 r = false;
785 }
786
787 fputc(c, fp);
788
789 if ((pos % 1024) == 0)
790 progress_update(progress, pos, -1);
791
792 /* Log progress every 10% for large transfers */
793 if ((checkpoint > 0) && ((pos % checkpoint) == 0) && (pos > 0))
794 {
795 time_t now = mutt_date_now();
796 if (now > last_progress)
797 {
798 mutt_debug(LL_DEBUG2, "Literal read progress: %lu/%lu bytes (%.1f%%)\n",
799 pos, bytes, ((double) pos / bytes * 100.0));
800 last_progress = now;
801 }
802 }
803
804 if (c_debug_level >= IMAP_LOG_LTRL)
805 buf_addch(&buf, c);
806 }
807
808 time_t duration = mutt_date_now() - start_time;
809 if (duration > 0)
810 {
811 mutt_debug(LL_DEBUG2, "Literal read complete: %lu bytes in %ld seconds\n",
812 bytes, (long) duration);
813 }
814
815 if (c_debug_level >= IMAP_LOG_LTRL)
816 {
817 mutt_debug(IMAP_LOG_LTRL, "\n%s", buf.data);
818 buf_dealloc(&buf);
819 }
820 return 0;
821}
buf_dealloc
void buf_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition buffer.c:377
buf_addch
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition buffer.c:241
buf_alloc
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition buffer.c:337
cs_subset_number
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition helpers.c:143
mutt_debug
#define mutt_debug(LEVEL,...)
Definition logging2.h:91
IMAP_LOG_LTRL
#define IMAP_LOG_LTRL
Log literal values.
Definition private.h:48
LL_DEBUG2
@ LL_DEBUG2
Log at debug level 2.
Definition logging2.h:46
LL_DEBUG1
@ LL_DEBUG1
Log at debug level 1.
Definition logging2.h:45
mutt_date_now
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition date.c:457
progress_update
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition progress.c:80
SigInt
volatile sig_atomic_t SigInt
true after SIGINT is received
Definition signal.c:68
mutt_socket_readchar
int mutt_socket_readchar(struct Connection *conn, char *c)
Simple read buffering to speed things up.
Definition socket.c:200
Buffer::data
char * data
Pointer to data.
Definition buffer.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_expunge_mailbox()

void imap_expunge_mailbox ( struct Mailbox * m,
bool resort )

Purge messages from the server.

Parameters
mMailbox
resortTrigger a resort?

Purge IMAP portion of expunged messages from the context. Must not be done while something has a handle on any headers (eg inside pager or editor). That is, check IMAP_REOPEN_ALLOW.

Definition at line 849 of file imap.c.

850{
851 struct ImapAccountData *adata = imap_adata_get(m);
852 struct ImapMboxData *mdata = imap_mdata_get(m);
853 if (!adata || !mdata)
854 return;
855
856 struct Email *e = NULL;
857
858#ifdef USE_HCACHE
859 imap_hcache_open(adata, mdata, false);
860#endif
861
862 for (int i = 0; i < m->msg_count; i++)
863 {
864 e = m->emails[i];
865 if (!e)
866 break;
867
868 if (e->index == INT_MAX)
869 {
870 mutt_debug(LL_DEBUG2, "Expunging message UID %u\n", imap_edata_get(e)->uid);
871
872 e->deleted = true;
873
874 imap_cache_del(m, e);
875#ifdef USE_HCACHE
876 imap_hcache_del(mdata, imap_edata_get(e)->uid);
877#endif
878
879 mutt_hash_int_delete(mdata->uid_hash, imap_edata_get(e)->uid, e);
880
881 imap_edata_free((void **) &e->edata);
882 }
883 else
884 {
885 /* NeoMutt has several places where it turns off e->active as a
886 * hack. For example to avoid FLAG updates, or to exclude from
887 * imap_exec_msg_set.
888 *
889 * Unfortunately, when a reopen is allowed and the IMAP_EXPUNGE_PENDING
890 * flag becomes set (e.g. a flag update to a modified header),
891 * this function will be called by imap_cmd_finish().
892 *
893 * The ctx_update_tables() will free and remove these "inactive" headers,
894 * despite that an EXPUNGE was not received for them.
895 * This would result in memory leaks and segfaults due to dangling
896 * pointers in the msn_index and uid_hash.
897 *
898 * So this is another hack to work around the hacks. We don't want to
899 * remove the messages, so make sure active is on. */
900 e->active = true;
901 }
902 }
903
904#ifdef USE_HCACHE
905 imap_hcache_close(mdata);
906#endif
907
908 mailbox_changed(m, NT_MAILBOX_UPDATE);
909 if (resort)
910 {
911 mailbox_changed(m, NT_MAILBOX_RESORT);
912 }
913}
mailbox_changed
void mailbox_changed(struct Mailbox *m, enum NotifyMailbox action)
Notify observers of a change to a Mailbox.
Definition mailbox.c:232
NT_MAILBOX_RESORT
@ NT_MAILBOX_RESORT
Email list needs resorting.
Definition mailbox.h:180
NT_MAILBOX_UPDATE
@ NT_MAILBOX_UPDATE
Update internal tables.
Definition mailbox.h:181
imap_edata_free
void imap_edata_free(void **ptr)
Free the private Email data - Implements Email::edata_free() -.
Definition edata.c:39
mutt_hash_int_delete
void mutt_hash_int_delete(struct HashTable *table, unsigned int intkey, const void *data)
Remove an element from a Hash Table.
Definition hash.c:446
imap_adata_get
struct ImapAccountData * imap_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition adata.c:158
imap_edata_get
struct ImapEmailData * imap_edata_get(struct Email *e)
Get the private data for this Email.
Definition edata.c:66
imap_mdata_get
struct ImapMboxData * imap_mdata_get(struct Mailbox *m)
Get the Mailbox data for this mailbox.
Definition mdata.c:61
imap_cache_del
int imap_cache_del(struct Mailbox *m, struct Email *e)
Delete an email from the body cache.
Definition message.c:1897
imap_hcache_open
void imap_hcache_open(struct ImapAccountData *adata, struct ImapMboxData *mdata, bool create)
Open a header cache.
Definition util.c:304
imap_hcache_close
void imap_hcache_close(struct ImapMboxData *mdata)
Close the header cache.
Definition util.c:345
imap_hcache_del
int imap_hcache_del(struct ImapMboxData *mdata, unsigned int uid)
Delete an item from the header cache.
Definition util.c:403
Account::adata
void * adata
Private data (for Mailbox backends)
Definition account.h:42
Email
The envelope/body of an email.
Definition email.h:39
Email::edata
void * edata
Driver-specific data.
Definition email.h:74
Email::active
bool active
Message is not to be removed.
Definition email.h:76
Email::deleted
bool deleted
Email is deleted.
Definition email.h:78
Email::index
int index
The absolute (unsorted) message number.
Definition email.h:110
ImapAccountData
IMAP-specific Account data -.
Definition adata.h:40
ImapMboxData
IMAP-specific Mailbox data -.
Definition mdata.h:40
ImapMboxData::uid_hash
struct HashTable * uid_hash
Hash Table: "uid" -> Email.
Definition mdata.h:60
Mailbox::msg_count
int msg_count
Total number of messages.
Definition mailbox.h:87
Mailbox::mdata
void * mdata
Driver specific data.
Definition mailbox.h:131
Mailbox::emails
struct Email ** emails
Array of Emails.
Definition mailbox.h:95
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_login()

int imap_login ( struct ImapAccountData * adata)

Open an IMAP connection.

Parameters
adataImap Account data
Return values
0Success
-1Failure

Ensure ImapAccountData is connected and logged into the imap server.

Definition at line 1969 of file imap.c.

1970{
1971 if (!adata)
1972 return -1;
1973
1974 if (adata->state == IMAP_DISCONNECTED)
1975 {
1976 buf_reset(&adata->cmdbuf); // purge outstanding queued commands
1977 imap_open_connection(adata);
1978 }
1979 if (adata->state == IMAP_CONNECTED)
1980 {
1981 if (imap_authenticate(adata) == IMAP_AUTH_SUCCESS)
1982 {
1983 adata->state = IMAP_AUTHENTICATED;
1984 FREE(&adata->capstr);
1985 if (adata->conn->ssf != 0)
1986 {
1987 mutt_debug(LL_DEBUG2, "Communication encrypted at %d bits\n",
1988 adata->conn->ssf);
1989 }
1990 }
1991 else
1992 {
1993 mutt_account_unsetpass(&adata->conn->account);
1994 }
1995 }
1996 if (adata->state == IMAP_AUTHENTICATED)
1997 {
1998 /* capabilities may have changed */
1999 imap_exec(adata, "CAPABILITY", IMAP_CMD_PASS);
2000
2001#ifdef USE_ZLIB
2002 /* RFC4978 */
2003 const bool c_imap_deflate = cs_subset_bool(NeoMutt->sub, "imap_deflate");
2004 if ((adata->capabilities & IMAP_CAP_COMPRESS) && c_imap_deflate &&
2005 (imap_exec(adata, "COMPRESS DEFLATE", IMAP_CMD_PASS) == IMAP_EXEC_SUCCESS))
2006 {
2007 mutt_debug(LL_DEBUG2, "IMAP compression is enabled on connection to %s\n",
2008 adata->conn->account.host);
2009 mutt_zstrm_wrap_conn(adata->conn);
2010 }
2011#endif
2012
2013 /* enable RFC2971, if the server supports that */
2014 const bool c_imap_send_id = cs_subset_bool(NeoMutt->sub, "imap_send_id");
2015 if (c_imap_send_id && (adata->capabilities & IMAP_CAP_ID))
2016 {
2017 imap_exec(adata, "ID (\"name\" \"NeoMutt\" \"version\" \"" PACKAGE_VERSION "\")",
2018 IMAP_CMD_QUEUE);
2019 }
2020
2021 /* enable RFC6855, if the server supports that */
2022 const bool c_imap_rfc5161 = cs_subset_bool(NeoMutt->sub, "imap_rfc5161");
2023 if (c_imap_rfc5161 && (adata->capabilities & IMAP_CAP_ENABLE))
2024 imap_exec(adata, "ENABLE UTF8=ACCEPT", IMAP_CMD_QUEUE);
2025
2026 /* enable QRESYNC. Advertising QRESYNC also means CONDSTORE
2027 * is supported (even if not advertised), so flip that bit. */
2028 if (adata->capabilities & IMAP_CAP_QRESYNC)
2029 {
2030 adata->capabilities |= IMAP_CAP_CONDSTORE;
2031 const bool c_imap_qresync = cs_subset_bool(NeoMutt->sub, "imap_qresync");
2032 if (c_imap_rfc5161 && c_imap_qresync)
2033 imap_exec(adata, "ENABLE QRESYNC", IMAP_CMD_QUEUE);
2034 }
2035
2036 /* get root delimiter, '/' as default */
2037 adata->delim = '/';
2038 imap_exec(adata, "LIST \"\" \"\"", IMAP_CMD_QUEUE);
2039
2040 /* we may need the root delimiter before we open a mailbox */
2041 imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS);
2042
2043 /* select the mailbox that used to be open before disconnect */
2044 if (adata->mailbox)
2045 {
2046 imap_mbox_select(adata->mailbox);
2047 }
2048 }
2049
2050 if (adata->state < IMAP_AUTHENTICATED)
2051 return -1;
2052
2053 return 0;
2054}
IMAP_AUTH_SUCCESS
@ IMAP_AUTH_SUCCESS
Authentication successful.
Definition auth.h:40
buf_reset
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition buffer.c:76
mutt_account_unsetpass
void mutt_account_unsetpass(struct ConnAccount *cac)
Unset ConnAccount's password.
Definition connaccount.c:177
imap_authenticate
int imap_authenticate(struct ImapAccountData *adata)
Authenticate to an IMAP server.
Definition auth.c:116
IMAP_CAP_ENABLE
#define IMAP_CAP_ENABLE
RFC5161.
Definition private.h:135
IMAP_CAP_ID
#define IMAP_CAP_ID
RFC2971: IMAP4 ID extension.
Definition private.h:141
IMAP_CMD_PASS
#define IMAP_CMD_PASS
Command contains a password. Suppress logging.
Definition private.h:72
IMAP_CAP_QRESYNC
#define IMAP_CAP_QRESYNC
RFC7162.
Definition private.h:137
IMAP_CAP_COMPRESS
#define IMAP_CAP_COMPRESS
RFC4978: COMPRESS=DEFLATE.
Definition private.h:139
IMAP_CAP_CONDSTORE
#define IMAP_CAP_CONDSTORE
RFC7162.
Definition private.h:136
IMAP_CMD_QUEUE
#define IMAP_CMD_QUEUE
Queue a command, do not execute.
Definition private.h:73
imap_open_connection
int imap_open_connection(struct ImapAccountData *adata)
Open an IMAP connection.
Definition imap.c:921
imap_mbox_select
static void imap_mbox_select(struct Mailbox *m)
Select a Mailbox.
Definition imap.c:1936
ConnAccount::host
char host[128]
Server to login to.
Definition connaccount.h:54
Connection::account
struct ConnAccount account
Account details: username, password, etc.
Definition connection.h:49
ImapAccountData::delim
char delim
Path delimiter.
Definition adata.h:78
ImapAccountData::mailbox
struct Mailbox * mailbox
Current selected mailbox.
Definition adata.h:79
ImapAccountData::cmdbuf
struct Buffer cmdbuf
Command queue.
Definition adata.h:76
mutt_zstrm_wrap_conn
void mutt_zstrm_wrap_conn(struct Connection *conn)
Wrap a compression layer around a Connection.
Definition zstrm.c:297
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_sync_message_for_copy()

int imap_sync_message_for_copy ( struct Mailbox * m,
struct Email * e,
struct Buffer * cmd,
enum QuadOption * err_continue )

Update server to reflect the flags of a single message.

Parameters
[in]mMailbox
[in]eEmail
[in]cmdBuffer for the command string
[out]err_continueDid the user force a continue?
Return values
0Success
-1Failure

Update the IMAP server to reflect the flags for a single message before performing a "UID COPY".

Note
This does not sync the "deleted" flag state, because it is not desirable to propagate that flag into the copy.

Definition at line 1106 of file imap.c.

1108{
1109 struct ImapAccountData *adata = imap_adata_get(m);
1110 struct ImapEmailData *edata = imap_edata_get(e);
1111
1112 if (!adata || (adata->mailbox != m) || !e)
1113 return -1;
1114
1115 if (!compare_flags_for_copy(e))
1116 {
1117 if (e->deleted == edata->deleted)
1118 e->changed = false;
1119 return 0;
1120 }
1121
1122 buf_printf(cmd, "UID STORE %u", edata->uid);
1123
1124 struct Buffer *flags = buf_pool_get();
1125
1126 set_flag(m, MUTT_ACL_SEEN, e->read, "\\Seen ", flags);
1127 set_flag(m, MUTT_ACL_WRITE, e->old, "Old ", flags);
1128 set_flag(m, MUTT_ACL_WRITE, e->flagged, "\\Flagged ", flags);
1129 set_flag(m, MUTT_ACL_WRITE, e->replied, "\\Answered ", flags);
1130 set_flag(m, MUTT_ACL_DELETE, edata->deleted, "\\Deleted ", flags);
1131
1132 if (m->rights & MUTT_ACL_WRITE)
1133 {
1134 /* restore system flags */
1135 if (edata->flags_system)
1136 buf_addstr(flags, edata->flags_system);
1137
1138 /* set custom flags */
1139 struct Buffer *tags = buf_pool_get();
1140 driver_tags_get_with_hidden(&e->tags, tags);
1141 if (!buf_is_empty(tags))
1142 buf_addstr(flags, buf_string(tags));
1143 buf_pool_release(&tags);
1144 }
1145
1146 mutt_str_remove_trailing_ws(flags->data);
1147 buf_fix_dptr(flags);
1148
1149 /* UW-IMAP is OK with null flags, Cyrus isn't. The only solution is to
1150 * explicitly revoke all system flags (if we have permission) */
1151 if (buf_is_empty(flags))
1152 {
1153 set_flag(m, MUTT_ACL_SEEN, true, "\\Seen ", flags);
1154 set_flag(m, MUTT_ACL_WRITE, true, "Old ", flags);
1155 set_flag(m, MUTT_ACL_WRITE, true, "\\Flagged ", flags);
1156 set_flag(m, MUTT_ACL_WRITE, true, "\\Answered ", flags);
1157 set_flag(m, MUTT_ACL_DELETE, !edata->deleted, "\\Deleted ", flags);
1158
1159 /* erase custom flags */
1160 if ((m->rights & MUTT_ACL_WRITE) && edata->flags_remote)
1161 buf_addstr(flags, edata->flags_remote);
1162
1163 mutt_str_remove_trailing_ws(flags->data);
1164 buf_fix_dptr(flags);
1165
1166 buf_addstr(cmd, " -FLAGS.SILENT (");
1167 }
1168 else
1169 {
1170 buf_addstr(cmd, " FLAGS.SILENT (");
1171 }
1172
1173 buf_addstr(cmd, buf_string(flags));
1174 buf_addstr(cmd, ")");
1175
1176 int rc = -1;
1177
1178 /* after all this it's still possible to have no flags, if you
1179 * have no ACL rights */
1180 if (!buf_is_empty(flags) &&
1181 (imap_exec(adata, cmd->data, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS) &&
1182 err_continue && (*err_continue != MUTT_YES))
1183 {
1184 *err_continue = imap_continue("imap_sync_message: STORE failed", adata->buf);
1185 if (*err_continue != MUTT_YES)
1186 goto done;
1187 }
1188
1189 /* server have now the updated flags */
1190 FREE(&edata->flags_remote);
1191 struct Buffer *flags_remote = buf_pool_get();
1192 driver_tags_get_with_hidden(&e->tags, flags_remote);
1193 edata->flags_remote = buf_strdup(flags_remote);
1194 buf_pool_release(&flags_remote);
1195
1196 if (e->deleted == edata->deleted)
1197 e->changed = false;
1198
1199 rc = 0;
1200
1201done:
1202 buf_pool_release(&flags);
1203 return rc;
1204}
buf_is_empty
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition buffer.c:291
buf_fix_dptr
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition buffer.c:182
buf_addstr
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition buffer.c:226
buf_strdup
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition buffer.c:571
MUTT_ACL_DELETE
#define MUTT_ACL_DELETE
Delete a message.
Definition mailbox.h:62
MUTT_ACL_WRITE
#define MUTT_ACL_WRITE
Write to a message (for flagging or linking threads)
Definition mailbox.h:70
MUTT_ACL_SEEN
#define MUTT_ACL_SEEN
Change the 'seen' status of a message.
Definition mailbox.h:69
imap_continue
enum QuadOption imap_continue(const char *msg, const char *resp)
Display a message and ask the user if they want to go on.
Definition util.c:651
set_flag
static void set_flag(struct Mailbox *m, AclFlags aclflag, bool flag, const char *str, struct Buffer *flags)
Append str to flags if we currently have permission according to aclflag.
Definition imap.c:287
compare_flags_for_copy
static bool compare_flags_for_copy(struct Email *e)
Compare local flags against the server.
Definition imap.c:307
mutt_str_remove_trailing_ws
void mutt_str_remove_trailing_ws(char *s)
Trim trailing whitespace from a string.
Definition string.c:570
Email::read
bool read
Email is read.
Definition email.h:50
Email::old
bool old
Email is seen, but unread.
Definition email.h:49
Email::changed
bool changed
Email has been edited.
Definition email.h:77
Email::flagged
bool flagged
Marked important?
Definition email.h:47
Email::replied
bool replied
Email has been replied to.
Definition email.h:51
Email::tags
struct TagList tags
For drivers that support server tagging.
Definition email.h:72
ImapEmailData
IMAP-specific Email data -.
Definition edata.h:35
ImapEmailData::flags_remote
char * flags_remote
Remote flags.
Definition edata.h:49
ImapEmailData::deleted
bool deleted
Email has been deleted.
Definition edata.h:39
ImapEmailData::flags_system
char * flags_system
System flags.
Definition edata.h:48
Mailbox::rights
AclFlags rights
ACL bits, see AclFlags.
Definition mailbox.h:118
driver_tags_get_with_hidden
void driver_tags_get_with_hidden(struct TagList *tl, struct Buffer *tags)
Get all tags, also hidden ones, separated by space.
Definition tags.c:175
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_has_flag()

bool imap_has_flag ( struct ListHead * flag_list,
const char * flag )

Does the flag exist in the list.

Parameters
flag_listList of server flags
flagFlag to find
Return values
trueFlag exists

Do a caseless comparison of the flag against a flag list, return true if found or flag list has '*'. Note that "flag" might contain additional whitespace at the end, so we really need to compare up to the length of each element in "flag_list".

Definition at line 1054 of file imap.c.

1055{
1056 if (STAILQ_EMPTY(flag_list))
1057 return false;
1058
1059 const size_t flaglen = mutt_str_len(flag);
1060 struct ListNode *np = NULL;
1061 STAILQ_FOREACH(np, flag_list, entries)
1062 {
1063 const size_t nplen = strlen(np->data);
1064 if ((flaglen >= nplen) && ((flag[nplen] == '\0') || (flag[nplen] == ' ')) &&
1065 mutt_istrn_equal(np->data, flag, nplen))
1066 {
1067 return true;
1068 }
1069
1070 if (mutt_str_equal(np->data, "\\*"))
1071 return true;
1072 }
1073
1074 return false;
1075}
mutt_str_equal
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition string.c:665
mutt_str_len
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition string.c:503
mutt_istrn_equal
bool mutt_istrn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings ignoring case (to a maximum), safely.
Definition string.c:457
STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition queue.h:390
STAILQ_EMPTY
#define STAILQ_EMPTY(head)
Definition queue.h:382
ListNode
A List node for strings.
Definition list.h:37
ListNode::data
char * data
String.
Definition list.h:38
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_adata_find()

int imap_adata_find ( const char * path,
struct ImapAccountData ** adata,
struct ImapMboxData ** mdata )

Find the Account data for this path.

Parameters
pathPath to search for
adataImap Account data
mdataImap Mailbox data
Return values
0Success
-1Failure

Definition at line 72 of file util.c.

74{
75 struct ConnAccount cac = { { 0 } };
76 struct ImapAccountData *tmp_adata = NULL;
77 char tmp[1024] = { 0 };
78
79 if (imap_parse_path(path, &cac, tmp, sizeof(tmp)) < 0)
80 return -1;
81
82 struct Account **ap = NULL;
83 ARRAY_FOREACH(ap, &NeoMutt->accounts)
84 {
85 struct Account *a = *ap;
86 if (a->type != MUTT_IMAP)
87 continue;
88
89 tmp_adata = a->adata;
90 if (!tmp_adata)
91 continue;
92 if (imap_account_match(&tmp_adata->conn->account, &cac))
93 {
94 if (mdata)
95 {
96 *mdata = imap_mdata_new(tmp_adata, tmp);
97 }
98 *adata = tmp_adata;
99 return 0;
100 }
101 }
102 mutt_debug(LL_DEBUG3, "no ImapAccountData found\n");
103 return -1;
104}
ARRAY_FOREACH
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition array.h:223
MUTT_IMAP
@ MUTT_IMAP
'IMAP' Mailbox type
Definition mailbox.h:49
imap_mdata_new
struct ImapMboxData * imap_mdata_new(struct ImapAccountData *adata, const char *name)
Allocate and initialise a new ImapMboxData structure.
Definition mdata.c:74
LL_DEBUG3
@ LL_DEBUG3
Log at debug level 3.
Definition logging2.h:47
Account
A group of associated Mailboxes.
Definition account.h:36
Account::type
enum MailboxType type
Type of Mailboxes this Account contains.
Definition account.h:37
ConnAccount
Login details for a remote server.
Definition connaccount.h:53
NeoMutt::accounts
struct AccountArray accounts
All Accounts.
Definition neomutt.h:50
imap_parse_path
int imap_parse_path(const char *path, struct ConnAccount *cac, char *mailbox, size_t mailboxlen)
Parse an IMAP mailbox name into ConnAccount, name.
Definition util.c:479
imap_account_match
bool imap_account_match(const struct ConnAccount *a1, const struct ConnAccount *a2)
Compare two Accounts.
Definition util.c:1103
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_authenticate()

int imap_authenticate ( struct ImapAccountData * adata)

Authenticate to an IMAP server.

Parameters
adataImap Account data
Return values
enumImapAuthRes, e.g. IMAP_AUTH_SUCCESS

Attempt to authenticate using either user-specified authentication method if specified, or any.

Definition at line 116 of file auth.c.

117{
118 int rc = IMAP_AUTH_FAILURE;
119
120 const struct Slist *c_imap_authenticators = cs_subset_slist(NeoMutt->sub, "imap_authenticators");
121 if (c_imap_authenticators && (c_imap_authenticators->count > 0))
122 {
123 mutt_debug(LL_DEBUG2, "Trying user-defined imap_authenticators\n");
124
125 /* Try user-specified list of authentication methods */
126 struct ListNode *np = NULL;
127 STAILQ_FOREACH(np, &c_imap_authenticators->head, entries)
128 {
129 mutt_debug(LL_DEBUG2, "Trying method %s\n", np->data);
130
131 for (size_t i = 0; i < countof(ImapAuthenticators); i++)
132 {
133 const struct ImapAuth *auth = &ImapAuthenticators[i];
134 if (!auth->method || mutt_istr_equal(auth->method, np->data))
135 {
136 rc = auth->authenticate(adata, np->data);
137 if (rc == IMAP_AUTH_SUCCESS)
138 {
139 return rc;
140 }
141 }
142 }
143 }
144 }
145 else
146 {
147 /* Fall back to default: any authenticator */
148 mutt_debug(LL_DEBUG2, "Trying pre-defined imap_authenticators\n");
149
150 for (size_t i = 0; i < countof(ImapAuthenticators); i++)
151 {
152 rc = ImapAuthenticators[i].authenticate(adata, NULL);
153 if (rc == IMAP_AUTH_SUCCESS)
154 return rc;
155 }
156 }
157
158 mutt_error(_("No authenticators available or wrong credentials"));
159 return rc;
160}
IMAP_AUTH_FAILURE
@ IMAP_AUTH_FAILURE
Authentication failed.
Definition auth.h:41
cs_subset_slist
const struct Slist * cs_subset_slist(const struct ConfigSubset *sub, const char *name)
Get a string-list config item by name.
Definition helpers.c:242
ImapAuthenticators
static const struct ImapAuth ImapAuthenticators[]
Accepted authentication methods.
Definition auth.c:65
countof
#define countof(x)
Definition memory.h:49
mutt_istr_equal
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition string.c:677
ImapAuth
IMAP authentication multiplexor.
Definition auth.c:47
ImapAuth::authenticate
enum ImapAuthRes(* authenticate)(struct ImapAccountData *adata, const char *method)
Definition auth.c:56
ImapAuth::method
const char * method
Name of authentication method supported, NULL means variable.
Definition auth.c:58
Slist
String list.
Definition slist.h:37
Slist::head
struct ListHead head
List containing values.
Definition slist.h:38
Slist::count
size_t count
Number of values in list.
Definition slist.h:39
+ Here is the caller graph for this function:

◆ imap_cmd_start()

int imap_cmd_start ( struct ImapAccountData * adata,
const char * cmdstr )

Given an IMAP command, send it to the server.

Parameters
adataImap Account data
cmdstrCommand string to send
Return values
0Success
<0Failure, e.g. IMAP_RES_BAD

If cmdstr is NULL, sends queued commands.

Definition at line 1211 of file command.c.

1212{
1213 return cmd_start(adata, cmdstr, IMAP_CMD_NO_FLAGS);
1214}
cmd_start
static int cmd_start(struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
Start a new IMAP command.
Definition command.c:266
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_cmd_step()

int imap_cmd_step ( struct ImapAccountData * adata)

Reads server responses from an IMAP command.

Parameters
adataImap Account data
Return values
0Success
<0Failure, e.g. IMAP_RES_BAD

detects tagged completion response, handles untagged messages, can read arbitrarily large strings (using malloc, so don't make it too large!).

Definition at line 1225 of file command.c.

1226{
1227 if (!adata)
1228 return -1;
1229
1230 size_t len = 0;
1231 int c;
1232 int rc;
1233 int stillrunning = 0;
1234 struct ImapCommand *cmd = NULL;
1235
1236 if (adata->status == IMAP_FATAL)
1237 {
1238 cmd_handle_fatal(adata);
1239 return IMAP_RES_BAD;
1240 }
1241
1242 /* read into buffer, expanding buffer as necessary until we have a full
1243 * line */
1244 do
1245 {
1246 if (len == adata->blen)
1247 {
1248 MUTT_MEM_REALLOC(&adata->buf, adata->blen + IMAP_CMD_BUFSIZE, char);
1249 adata->blen = adata->blen + IMAP_CMD_BUFSIZE;
1250 mutt_debug(LL_DEBUG3, "grew buffer to %zu bytes\n", adata->blen);
1251 }
1252
1253 /* back up over '\0' */
1254 if (len)
1255 len--;
1256
1257 mutt_debug(LL_DEBUG3, "reading from socket (fd=%d, state=%d)\n",
1258 adata->conn ? adata->conn->fd : -1, adata->state);
1259 time_t read_start = mutt_date_now();
1260
1261 c = mutt_socket_readln_d(adata->buf + len, adata->blen - len, adata->conn, MUTT_SOCK_LOG_FULL);
1262
1263 time_t read_duration = mutt_date_now() - read_start;
1264 if (read_duration > 1)
1265 {
1266 mutt_debug(LL_DEBUG1, "socket read took %ld seconds\n", (long) read_duration);
1267 }
1268
1269 if (c <= 0)
1270 {
1271 mutt_debug(LL_DEBUG1, "Error reading server response (rc=%d, errno=%d: %s)\n",
1272 c, errno, strerror(errno));
1273 mutt_debug(LL_DEBUG1, "Connection state: fd=%d, state=%d, status=%d\n",
1274 adata->conn ? adata->conn->fd : -1, adata->state, adata->status);
1275 cmd_handle_fatal(adata);
1276 return IMAP_RES_BAD;
1277 }
1278
1279 len += c;
1280 }
1281 /* if we've read all the way to the end of the buffer, we haven't read a
1282 * full line (mutt_socket_readln strips the \r, so we always have at least
1283 * one character free when we've read a full line) */
1284 while (len == adata->blen);
1285
1286 /* don't let one large string make cmd->buf hog memory forever */
1287 if ((adata->blen > IMAP_CMD_BUFSIZE) && (len <= IMAP_CMD_BUFSIZE))
1288 {
1289 MUTT_MEM_REALLOC(&adata->buf, IMAP_CMD_BUFSIZE, char);
1290 adata->blen = IMAP_CMD_BUFSIZE;
1291 mutt_debug(LL_DEBUG3, "shrank buffer to %zu bytes\n", adata->blen);
1292 }
1293
1294 adata->lastread = mutt_date_now();
1295
1296 /* handle untagged messages. The caller still gets its shot afterwards. */
1297 if ((mutt_str_startswith(adata->buf, "* ") ||
1298 mutt_str_startswith(imap_next_word(adata->buf), "OK [")) &&
1299 cmd_handle_untagged(adata))
1300 {
1301 return IMAP_RES_BAD;
1302 }
1303
1304 /* server demands a continuation response from us */
1305 if (adata->buf[0] == '+')
1306 return IMAP_RES_RESPOND;
1307
1308 /* Look for tagged command completions.
1309 *
1310 * Some response handlers can end up recursively calling
1311 * imap_cmd_step() and end up handling all tagged command
1312 * completions.
1313 * (e.g. FETCH->set_flag->set_header_color->~h pattern match.)
1314 *
1315 * Other callers don't even create an adata->cmds entry.
1316 *
1317 * For both these cases, we default to returning OK */
1318 rc = IMAP_RES_OK;
1319 c = adata->lastcmd;
1320 do
1321 {
1322 cmd = &adata->cmds[c];
1323 if (cmd->state == IMAP_RES_NEW)
1324 {
1325 if (mutt_str_startswith(adata->buf, cmd->seq))
1326 {
1327 if (!stillrunning)
1328 {
1329 /* first command in queue has finished - move queue pointer up */
1330 adata->lastcmd = (adata->lastcmd + 1) % adata->cmdslots;
1331 }
1332 cmd->state = cmd_status(adata->buf);
1333 rc = cmd->state;
1334 if (cmd->state == IMAP_RES_NO || cmd->state == IMAP_RES_BAD)
1335 {
1336 mutt_message(_("IMAP command failed: %s"), adata->buf);
1337 }
1338 }
1339 else
1340 {
1341 stillrunning++;
1342 }
1343 }
1344
1345 c = (c + 1) % adata->cmdslots;
1346 } while (c != adata->nextcmd);
1347
1348 if (stillrunning)
1349 {
1350 rc = IMAP_RES_CONTINUE;
1351 }
1352 else
1353 {
1354 mutt_debug(LL_DEBUG3, "IMAP queue drained\n");
1355 imap_cmd_finish(adata);
1356 }
1357
1358 return rc;
1359}
mutt_message
#define mutt_message(...)
Definition logging2.h:93
cmd_handle_untagged
static int cmd_handle_untagged(struct ImapAccountData *adata)
Fallback parser for otherwise unhandled messages.
Definition command.c:1115
cmd_status
static int cmd_status(const char *s)
Parse response line for tagged OK/NO/BAD.
Definition command.c:302
cmd_handle_fatal
static void cmd_handle_fatal(struct ImapAccountData *adata)
When ImapAccountData is in fatal state, do what we can.
Definition command.c:184
IMAP_CMD_BUFSIZE
#define IMAP_CMD_BUFSIZE
Default buffer size for IMAP commands.
Definition command.c:63
imap_cmd_finish
void imap_cmd_finish(struct ImapAccountData *adata)
Attempt to perform cleanup.
Definition command.c:1498
IMAP_RES_RESPOND
#define IMAP_RES_RESPOND
+
Definition private.h:56
IMAP_RES_NEW
#define IMAP_RES_NEW
ImapCommand.state additions.
Definition private.h:57
IMAP_RES_NO
#define IMAP_RES_NO
<tag> NO ...
Definition private.h:52
IMAP_RES_CONTINUE
#define IMAP_RES_CONTINUE
* ...
Definition private.h:55
imap_next_word
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition util.c:826
IMAP_RES_BAD
#define IMAP_RES_BAD
<tag> BAD ...
Definition private.h:53
MUTT_MEM_REALLOC
#define MUTT_MEM_REALLOC(pptr, n, type)
Definition memory.h:55
mutt_str_startswith
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition string.c:234
mutt_socket_readln_d
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
MUTT_SOCK_LOG_FULL
#define MUTT_SOCK_LOG_FULL
Log everything including full protocol.
Definition socket.h:53
Connection::fd
int fd
Socket file descriptor.
Definition connection.h:53
ImapAccountData::lastread
time_t lastread
last time we read a command for the server
Definition adata.h:58
ImapAccountData::blen
size_t blen
Command buffer length.
Definition adata.h:61
ImapCommand::state
int state
Command state, e.g. IMAP_RES_NEW.
Definition private.h:162
ImapCommand::seq
char seq[SEQ_LEN+1]
Command tag, e.g. 'a0001'.
Definition private.h:161
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_cmd_finish()

void imap_cmd_finish ( struct ImapAccountData * adata)

Attempt to perform cleanup.

Parameters
adataImap Account data

If a reopen is allowed, it attempts to perform cleanup (eg fetch new mail if detected, do expunge). Called automatically by imap_cmd_step(), but may be called at any time.

mdata->check_status is set and will be used later by imap_check_mailbox().

Definition at line 1498 of file command.c.

1499{
1500 if (!adata)
1501 return;
1502
1503 if (adata->status == IMAP_FATAL)
1504 {
1505 adata->closing = false;
1506 cmd_handle_fatal(adata);
1507 return;
1508 }
1509
1510 if (!(adata->state >= IMAP_SELECTED) || !adata->mailbox || adata->closing)
1511 {
1512 adata->closing = false;
1513 return;
1514 }
1515
1516 adata->closing = false;
1517
1518 struct ImapMboxData *mdata = imap_mdata_get(adata->mailbox);
1519
1520 if (mdata && mdata->reopen & IMAP_REOPEN_ALLOW)
1521 {
1522 // First remove expunged emails from the msn_index
1523 if (mdata->reopen & IMAP_EXPUNGE_PENDING)
1524 {
1525 mutt_debug(LL_DEBUG2, "Expunging mailbox\n");
1526 imap_expunge_mailbox(adata->mailbox, true);
1527 /* Detect whether we've gotten unexpected EXPUNGE messages */
1528 if (!(mdata->reopen & IMAP_EXPUNGE_EXPECTED))
1529 mdata->check_status |= IMAP_EXPUNGE_PENDING;
1530 mdata->reopen &= ~(IMAP_EXPUNGE_PENDING | IMAP_EXPUNGE_EXPECTED);
1531 }
1532
1533 // Then add new emails to it
1534 if (mdata->reopen & IMAP_NEWMAIL_PENDING)
1535 {
1536 const size_t max_msn = imap_msn_highest(&mdata->msn);
1537 if (mdata->new_mail_count > max_msn)
1538 {
1539 if (!(mdata->reopen & IMAP_EXPUNGE_PENDING))
1540 mdata->check_status |= IMAP_NEWMAIL_PENDING;
1541
1542 mutt_debug(LL_DEBUG2, "Fetching new mails from %zd to %u\n",
1543 max_msn + 1, mdata->new_mail_count);
1544 imap_read_headers(adata->mailbox, max_msn + 1, mdata->new_mail_count, false);
1545 }
1546 }
1547
1548 /* imap_read_headers may have triggered a fatal error that NULLed
1549 * adata->mailbox. Re-check before accessing mdata further. */
1550 if (!adata->mailbox)
1551 {
1552 adata->status = 0;
1553 return;
1554 }
1555
1556 // And to finish inform about MUTT_REOPEN if needed
1557 if (mdata->reopen & IMAP_EXPUNGE_PENDING && !(mdata->reopen & IMAP_EXPUNGE_EXPECTED))
1558 mdata->check_status |= IMAP_EXPUNGE_PENDING;
1559
1560 if (mdata->reopen & IMAP_EXPUNGE_PENDING)
1561 mdata->reopen &= ~(IMAP_EXPUNGE_PENDING | IMAP_EXPUNGE_EXPECTED);
1562 }
1563
1564 adata->status = 0;
1565}
imap_read_headers
int imap_read_headers(struct Mailbox *m, unsigned int msn_begin, unsigned int msn_end, bool initial_download)
Read headers from the server.
Definition message.c:1363
IMAP_EXPUNGE_PENDING
#define IMAP_EXPUNGE_PENDING
Messages on the server have been expunged.
Definition private.h:66
IMAP_EXPUNGE_EXPECTED
#define IMAP_EXPUNGE_EXPECTED
Messages will be expunged from the server.
Definition private.h:65
IMAP_REOPEN_ALLOW
#define IMAP_REOPEN_ALLOW
Allow re-opening a folder upon expunge.
Definition private.h:64
IMAP_NEWMAIL_PENDING
#define IMAP_NEWMAIL_PENDING
New mail is waiting on the server.
Definition private.h:67
imap_expunge_mailbox
void imap_expunge_mailbox(struct Mailbox *m, bool resort)
Purge messages from the server.
Definition imap.c:849
imap_msn_highest
size_t imap_msn_highest(const struct MSNArray *msn)
Return the highest MSN in use.
Definition msn.c:72
ImapAccountData::closing
bool closing
If true, we are waiting for CLOSE completion.
Definition adata.h:43
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_code()

bool imap_code ( const char * s)

Was the command successful.

Parameters
sIMAP command status
Return values
1Command result was OK
0NO or BAD

Definition at line 1367 of file command.c.

1368{
1369 return cmd_status(s) == IMAP_RES_OK;
1370}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_cmd_trailer()

const char * imap_cmd_trailer ( struct ImapAccountData * adata)

Extra information after tagged command response if any.

Parameters
adataImap Account data
Return values
ptrExtra command information (pointer into adata->buf)
""Error (static string)

Definition at line 1378 of file command.c.

1379{
1380 static const char *notrailer = "";
1381 const char *s = adata->buf;
1382
1383 if (!s)
1384 {
1385 mutt_debug(LL_DEBUG2, "not a tagged response\n");
1386 return notrailer;
1387 }
1388
1389 s = imap_next_word((char *) s);
1390 if (!s || (!mutt_istr_startswith(s, "OK") && !mutt_istr_startswith(s, "NO") &&
1391 !mutt_istr_startswith(s, "BAD")))
1392 {
1393 mutt_debug(LL_DEBUG2, "not a command completion: %s\n", adata->buf);
1394 return notrailer;
1395 }
1396
1397 s = imap_next_word((char *) s);
1398 if (!s)
1399 return notrailer;
1400
1401 return s;
1402}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_exec()

int imap_exec ( struct ImapAccountData * adata,
const char * cmdstr,
ImapCmdFlags flags )

Execute a command and wait for the response from the server.

Parameters
adataImap Account data
cmdstrCommand to execute
flagsFlags, see ImapCmdFlags
Return values
IMAP_EXEC_SUCCESSCommand successful or queued
IMAP_EXEC_ERRORCommand returned an error
IMAP_EXEC_FATALImap connection failure

Also, handle untagged responses.

Definition at line 1415 of file command.c.

1416{
1417 if (!adata)
1418 return IMAP_EXEC_ERROR;
1419
1420 /* Check connection health before executing command */
1421 if ((adata->state >= IMAP_AUTHENTICATED) && (adata->last_success > 0))
1422 {
1423 time_t now = mutt_date_now();
1424 time_t idle_time = now - adata->last_success;
1425
1426 if (idle_time > IMAP_CONN_STALE_THRESHOLD)
1427 {
1428 mutt_debug(LL_DEBUG2, "Connection idle for %ld seconds, sending NOOP to verify\n",
1429 (long) idle_time);
1430 /* Connection may be stale - let the command proceed and handle any error */
1431 }
1432 }
1433
1434 if (flags & IMAP_CMD_SINGLE)
1435 {
1436 // Process any existing commands
1437 if (adata->nextcmd != adata->lastcmd)
1438 imap_exec(adata, NULL, IMAP_CMD_POLL);
1439 }
1440
1441 int rc = cmd_start(adata, cmdstr, flags);
1442 if (rc < 0)
1443 {
1444 cmd_handle_fatal(adata);
1445 return IMAP_EXEC_FATAL;
1446 }
1447
1448 if (flags & IMAP_CMD_QUEUE)
1449 return IMAP_EXEC_SUCCESS;
1450
1451 const short c_imap_poll_timeout = cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
1452 if ((flags & IMAP_CMD_POLL) && (c_imap_poll_timeout > 0) &&
1453 ((mutt_socket_poll(adata->conn, c_imap_poll_timeout)) == 0))
1454 {
1455 mutt_error(_("Connection to %s timed out"), adata->conn->account.host);
1456 cmd_handle_fatal(adata);
1457 return IMAP_EXEC_FATAL;
1458 }
1459
1460 /* Allow interruptions, particularly useful if there are network problems. */
1461 mutt_sig_allow_interrupt(true);
1462 do
1463 {
1464 rc = imap_cmd_step(adata);
1465 // The queue is empty, so the single command has been processed
1466 if ((flags & IMAP_CMD_SINGLE) && (adata->nextcmd == adata->lastcmd))
1467 break;
1468 } while (rc == IMAP_RES_CONTINUE);
1469 mutt_sig_allow_interrupt(false);
1470
1471 if (rc == IMAP_RES_NO)
1472 return IMAP_EXEC_ERROR;
1473 if (rc != IMAP_RES_OK)
1474 {
1475 if (adata->status != IMAP_FATAL)
1476 return IMAP_EXEC_ERROR;
1477
1478 mutt_debug(LL_DEBUG1, "command failed: %s\n", adata->buf);
1479 return IMAP_EXEC_FATAL;
1480 }
1481
1482 /* Track successful command completion for connection health monitoring */
1483 adata->last_success = mutt_date_now();
1484
1485 return IMAP_EXEC_SUCCESS;
1486}
IMAP_CONN_STALE_THRESHOLD
#define IMAP_CONN_STALE_THRESHOLD
Threshold in seconds after which to consider a connection potentially stale.
Definition command.c:72
IMAP_CMD_POLL
#define IMAP_CMD_POLL
Poll the tcp connection before running the imap command.
Definition private.h:74
mutt_sig_allow_interrupt
void mutt_sig_allow_interrupt(bool allow)
Allow/disallow Ctrl-C (SIGINT)
Definition signal.c:315
mutt_socket_poll
int mutt_socket_poll(struct Connection *conn, time_t wait_secs)
Checks whether reads would block.
Definition socket.c:182
ImapAccountData::last_success
time_t last_success
last time a command completed successfully
Definition adata.h:59
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_cmd_idle()

int imap_cmd_idle ( struct ImapAccountData * adata)

Enter the IDLE state.

Parameters
adataImap Account data
Return values
0Success
<0Failure, e.g. IMAP_RES_BAD

Definition at line 1573 of file command.c.

1574{
1575 int rc;
1576
1577 mutt_debug(LL_DEBUG2, "Entering IDLE mode for %s\n",
1578 adata->conn ? adata->conn->account.host : "NULL");
1579
1580 if (cmd_start(adata, "IDLE", IMAP_CMD_POLL) < 0)
1581 {
1582 mutt_debug(LL_DEBUG1, "Failed to send IDLE command\n");
1583 cmd_handle_fatal(adata);
1584 return -1;
1585 }
1586
1587 const short c_imap_poll_timeout = cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
1588 mutt_debug(LL_DEBUG2, "Waiting for IDLE continuation (timeout=%d)\n", c_imap_poll_timeout);
1589
1590 if ((c_imap_poll_timeout > 0) &&
1591 ((mutt_socket_poll(adata->conn, c_imap_poll_timeout)) == 0))
1592 {
1593 mutt_debug(LL_DEBUG1, "IDLE timed out waiting for server continuation response\n");
1594 mutt_error(_("Connection to %s timed out waiting for IDLE response"),
1595 adata->conn->account.host);
1596 cmd_handle_fatal(adata);
1597 return -1;
1598 }
1599
1600 do
1601 {
1602 rc = imap_cmd_step(adata);
1603 } while (rc == IMAP_RES_CONTINUE);
1604
1605 if (rc == IMAP_RES_RESPOND)
1606 {
1607 /* successfully entered IDLE state */
1608 adata->state = IMAP_IDLE;
1609 /* queue automatic exit when next command is issued */
1610 buf_addstr(&adata->cmdbuf, "DONE\r\n");
1611 mutt_debug(LL_DEBUG2, "Successfully entered IDLE state\n");
1612 rc = IMAP_RES_OK;
1613 }
1614 if (rc != IMAP_RES_OK)
1615 {
1616 mutt_debug(LL_DEBUG1, "IDLE command failed with rc=%d (expected RESPOND=%d)\n",
1617 rc, IMAP_RES_RESPOND);
1618 mutt_error(_("IDLE command failed for %s"), adata->conn->account.host);
1619 return -1;
1620 }
1621
1622 return 0;
1623}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_read_headers()

int imap_read_headers ( struct Mailbox * m,
unsigned int msn_begin,
unsigned int msn_end,
bool initial_download )

Read headers from the server.

Parameters
mImap Selected Mailbox
msn_beginFirst Message Sequence Number
msn_endLast Message Sequence Number
initial_downloadtrue, if this is the first opening of the mailbox
Return values
numLast MSN
-1Failure

Changed to read many headers instead of just one. It will return the msn of the last message read. It will return a value other than msn_end if mail comes in while downloading headers (in theory).

Definition at line 1363 of file message.c.

1365{
1366 unsigned int maxuid = 0;
1367 int rc = -1;
1368 bool evalhc = false;
1369
1370#ifdef USE_HCACHE
1371 uint32_t uidvalidity = 0;
1372 unsigned int uid_next = 0;
1373 unsigned long long modseq = 0;
1374 bool has_condstore = false;
1375 bool has_qresync = false;
1376 bool eval_condstore = false;
1377 bool eval_qresync = false;
1378 char *uid_seqset = NULL;
1379 const unsigned int msn_begin_save = msn_begin;
1380#endif /* USE_HCACHE */
1381
1382 struct ImapAccountData *adata = imap_adata_get(m);
1383 struct ImapMboxData *mdata = imap_mdata_get(m);
1384 if (!adata || (adata->mailbox != m) || !mdata)
1385 return -1;
1386
1387#ifdef USE_HCACHE
1388retry:
1389#endif /* USE_HCACHE */
1390
1391 /* make sure context has room to hold the mailbox */
1392 mx_alloc_memory(m, msn_end);
1393 imap_msn_reserve(&mdata->msn, msn_end);
1394 imap_alloc_uid_hash(adata, m, msn_end);
1395
1396 mdata->reopen &= ~(IMAP_REOPEN_ALLOW | IMAP_NEWMAIL_PENDING);
1397 mdata->new_mail_count = 0;
1398
1399#ifdef USE_HCACHE
1400 imap_hcache_open(adata, mdata, true);
1401
1402 if (mdata->hcache && initial_download)
1403 {
1404 hcache_fetch_raw_obj(mdata->hcache, "UIDVALIDITY", 11, &uidvalidity);
1405 hcache_fetch_raw_obj(mdata->hcache, "UIDNEXT", 7, &uid_next);
1406 if (mdata->modseq)
1407 {
1408 const bool c_imap_condstore = cs_subset_bool(NeoMutt->sub, "imap_condstore");
1409 if ((adata->capabilities & IMAP_CAP_CONDSTORE) && c_imap_condstore)
1410 has_condstore = true;
1411
1412 /* If IMAP_CAP_QRESYNC and ImapQResync then NeoMutt sends ENABLE QRESYNC.
1413 * If we receive an ENABLED response back, then adata->qresync is set. */
1414 if (adata->qresync)
1415 has_qresync = true;
1416 }
1417
1418 if (uidvalidity && uid_next && (uidvalidity == mdata->uidvalidity))
1419 {
1420 evalhc = true;
1421 if (hcache_fetch_raw_obj(mdata->hcache, "MODSEQ", 6, &modseq))
1422 {
1423 if (has_qresync)
1424 {
1425 uid_seqset = imap_hcache_get_uid_seqset(mdata);
1426 if (uid_seqset)
1427 eval_qresync = true;
1428 }
1429
1430 if (!eval_qresync && has_condstore)
1431 eval_condstore = true;
1432 }
1433 }
1434 }
1435 if (evalhc)
1436 {
1437 if (eval_qresync)
1438 {
1439 if (read_headers_qresync_eval_cache(adata, m, uid_seqset) < 0)
1440 goto bail;
1441 }
1442 else
1443 {
1444 if (read_headers_normal_eval_cache(adata, m, msn_end, uid_next,
1445 has_condstore || has_qresync, eval_condstore) < 0)
1446 goto bail;
1447 }
1448
1449 if ((eval_condstore || eval_qresync) && (modseq != mdata->modseq))
1450 {
1451 if (read_headers_condstore_qresync_updates(adata, m, msn_end, uid_next,
1452 modseq, eval_qresync) < 0)
1453 {
1454 goto bail;
1455 }
1456 }
1457
1458 /* Look for the first empty MSN and start there */
1459 while (msn_begin <= msn_end)
1460 {
1461 if (!imap_msn_get(&mdata->msn, msn_begin - 1))
1462 break;
1463 msn_begin++;
1464 }
1465 }
1466#endif /* USE_HCACHE */
1467
1468 if (read_headers_fetch_new(m, msn_begin, msn_end, evalhc, &maxuid, initial_download) < 0)
1469 goto bail;
1470
1471#ifdef USE_HCACHE
1472 if (eval_qresync && initial_download)
1473 {
1474 if (imap_verify_qresync(m) != 0)
1475 {
1476 eval_qresync = false;
1477 eval_condstore = false;
1478 evalhc = false;
1479 modseq = 0;
1480 maxuid = 0;
1481 FREE(&uid_seqset);
1482 uidvalidity = 0;
1483 uid_next = 0;
1484 msn_begin = msn_begin_save;
1485
1486 goto retry;
1487 }
1488 }
1489#endif /* USE_HCACHE */
1490
1491 if (maxuid && (mdata->uid_next < maxuid + 1))
1492 mdata->uid_next = maxuid + 1;
1493
1494#ifdef USE_HCACHE
1495 hcache_store_raw(mdata->hcache, "UIDVALIDITY", 11, &mdata->uidvalidity,
1496 sizeof(mdata->uidvalidity));
1497 if (maxuid && (mdata->uid_next < maxuid + 1))
1498 {
1499 mutt_debug(LL_DEBUG2, "Overriding UIDNEXT: %u -> %u\n", mdata->uid_next, maxuid + 1);
1500 mdata->uid_next = maxuid + 1;
1501 }
1502 if (mdata->uid_next > 1)
1503 {
1504 hcache_store_raw(mdata->hcache, "UIDNEXT", 7, &mdata->uid_next, sizeof(mdata->uid_next));
1505 }
1506
1507 /* We currently only sync CONDSTORE and QRESYNC on the initial download.
1508 * To do it more often, we'll need to deal with flag updates combined with
1509 * unsync'ed local flag changes. We'll also need to properly sync flags to
1510 * the header cache on close. I'm not sure it's worth the added complexity. */
1511 if (initial_download)
1512 {
1513 if (has_condstore || has_qresync)
1514 {
1515 hcache_store_raw(mdata->hcache, "MODSEQ", 6, &mdata->modseq, sizeof(mdata->modseq));
1516 }
1517 else
1518 {
1519 hcache_delete_raw(mdata->hcache, "MODSEQ", 6);
1520 }
1521
1522 if (has_qresync)
1523 imap_hcache_store_uid_seqset(mdata);
1524 else
1525 imap_hcache_clear_uid_seqset(mdata);
1526 }
1527#endif /* USE_HCACHE */
1528
1529 /* TODO: it's not clear to me why we are calling mx_alloc_memory yet again. */
1530 mx_alloc_memory(m, m->msg_count);
1531
1532 mdata->reopen |= IMAP_REOPEN_ALLOW;
1533
1534 rc = msn_end;
1535
1536bail:
1537#ifdef USE_HCACHE
1538 imap_hcache_close(mdata);
1539 FREE(&uid_seqset);
1540#endif /* USE_HCACHE */
1541
1542 return rc;
1543}
hcache_delete_raw
int hcache_delete_raw(struct HeaderCache *hc, const char *key, size_t keylen)
Multiplexor for StoreOps::delete_record.
Definition hcache.c:766
hcache_store_raw
int hcache_store_raw(struct HeaderCache *hc, const char *key, size_t keylen, void *data, size_t dlen)
Store a key / data pair.
Definition hcache.c:738
hcache_fetch_raw_obj
#define hcache_fetch_raw_obj(hc, key, keylen, dst)
Definition lib.h:168
read_headers_normal_eval_cache
static int read_headers_normal_eval_cache(struct ImapAccountData *adata, struct Mailbox *m, unsigned int msn_end, unsigned int uid_next, bool store_flag_updates, bool eval_condstore)
Retrieve data from the header cache.
Definition message.c:697
imap_verify_qresync
static int imap_verify_qresync(struct Mailbox *m)
Check to see if QRESYNC got jumbled.
Definition message.c:1036
read_headers_condstore_qresync_updates
static int read_headers_condstore_qresync_updates(struct ImapAccountData *adata, struct Mailbox *m, unsigned int msn_end, unsigned int uid_next, unsigned long long hc_modseq, bool eval_qresync)
Retrieve updates from the server.
Definition message.c:935
imap_alloc_uid_hash
static void imap_alloc_uid_hash(struct ImapAccountData *adata, struct Mailbox *m, unsigned int msn_count)
Create a Hash Table for the UIDs.
Definition message.c:534
read_headers_qresync_eval_cache
static int read_headers_qresync_eval_cache(struct ImapAccountData *adata, struct Mailbox *m, char *uid_seqset)
Retrieve data from the header cache.
Definition message.c:846
read_headers_fetch_new
static int read_headers_fetch_new(struct Mailbox *m, unsigned int msn_begin, unsigned int msn_end, bool evalhc, unsigned int *maxuid, bool initial_download)
Retrieve new messages from the server.
Definition message.c:1113
imap_hcache_store_uid_seqset
int imap_hcache_store_uid_seqset(struct ImapMboxData *mdata)
Store a UID Sequence Set in the header cache.
Definition util.c:420
imap_hcache_get_uid_seqset
char * imap_hcache_get_uid_seqset(struct ImapMboxData *mdata)
Get a UID Sequence Set from the header cache.
Definition util.c:455
imap_hcache_clear_uid_seqset
int imap_hcache_clear_uid_seqset(struct ImapMboxData *mdata)
Delete a UID Sequence Set from the header cache.
Definition util.c:441
imap_msn_get
struct Email * imap_msn_get(const struct MSNArray *msn, int idx)
Return the Email associated with an msn.
Definition msn.c:83
imap_msn_reserve
void imap_msn_reserve(struct MSNArray *msn, size_t num)
Create / reallocate the cache.
Definition msn.c:44
mx_alloc_memory
void mx_alloc_memory(struct Mailbox *m, int req_size)
Create storage for the emails.
Definition mx.c:1208
ImapAccountData::qresync
bool qresync
true, if QRESYNC is successfully ENABLE'd
Definition adata.h:64
ImapMboxData::uid_next
unsigned int uid_next
Next UID for new message.
Definition mdata.h:52
ImapMboxData::modseq
unsigned long long modseq
Modification sequence number.
Definition mdata.h:53
ImapMboxData::uidvalidity
uint32_t uidvalidity
UID validity.
Definition mdata.h:51
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_set_flags()

char * imap_set_flags ( struct Mailbox * m,
struct Email * e,
char * s,
bool * server_changes )

Fill the message header according to the server flags.

Parameters
[in]mImap Selected Mailbox
[in]eEmail
[in]sCommand string
[out]server_changesSet to true if the flags have changed
Return values
ptrThe end of flags string
NULLFailure

Expects a flags line of the form "FLAGS (flag flag ...)"

imap_set_flags: fill out the message header according to the flags from the server. Expects a flags line of the form "FLAGS (flag flag ...)"

Sets server_changes to 1 if a change to a flag is made, or in the case of e->changed, if a change to a flag would have been made.

Definition at line 1948 of file message.c.

1949{
1950 struct ImapAccountData *adata = imap_adata_get(m);
1951 if (!adata || (adata->mailbox != m))
1952 return NULL;
1953
1954 struct ImapHeader newh = { 0 };
1955 struct ImapEmailData old_edata = { 0 };
1956 int local_changes = e->changed;
1957
1958 struct ImapEmailData *edata = e->edata;
1959 newh.edata = edata;
1960
1961 mutt_debug(LL_DEBUG2, "parsing FLAGS\n");
1962 s = msg_parse_flags(&newh, s);
1963 if (!s)
1964 return NULL;
1965
1966 /* Update tags system */
1967 /* We take a copy of the tags so we can split the string */
1968 char *tags_copy = mutt_str_dup(edata->flags_remote);
1969 driver_tags_replace(&e->tags, tags_copy);
1970 FREE(&tags_copy);
1971
1972 /* YAUH (yet another ugly hack): temporarily set context to
1973 * read-write even if it's read-only, so *server* updates of
1974 * flags can be processed by mutt_set_flag. mailbox->changed must
1975 * be restored afterwards */
1976 bool readonly = m->readonly;
1977 m->readonly = false;
1978
1979 /* This is redundant with the following two checks. Removing:
1980 * mutt_set_flag (m, e, MUTT_NEW, !(edata->read || edata->old), true); */
1981 set_changed_flag(m, e, local_changes, server_changes, MUTT_OLD, old_edata.old,
1982 edata->old, e->old);
1983 set_changed_flag(m, e, local_changes, server_changes, MUTT_READ,
1984 old_edata.read, edata->read, e->read);
1985 set_changed_flag(m, e, local_changes, server_changes, MUTT_DELETE,
1986 old_edata.deleted, edata->deleted, e->deleted);
1987 set_changed_flag(m, e, local_changes, server_changes, MUTT_FLAG,
1988 old_edata.flagged, edata->flagged, e->flagged);
1989 set_changed_flag(m, e, local_changes, server_changes, MUTT_REPLIED,
1990 old_edata.replied, edata->replied, e->replied);
1991
1992 /* this message is now definitively *not* changed (mutt_set_flag
1993 * marks things changed as a side-effect) */
1994 if (local_changes == 0)
1995 e->changed = false;
1996 m->changed &= !readonly;
1997 m->readonly = readonly;
1998
1999 return s;
2000}
set_changed_flag
static void set_changed_flag(struct Mailbox *m, struct Email *e, int local_changes, bool *server_changes, enum MessageType flag_name, bool old_hd_flag, bool new_hd_flag, bool h_flag)
Have the flags of an email changed.
Definition message.c:656
msg_parse_flags
static char * msg_parse_flags(struct ImapHeader *h, char *s)
Read a FLAGS token into an ImapHeader.
Definition message.c:194
mutt_str_dup
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition string.c:257
MUTT_READ
@ MUTT_READ
Messages that have been read.
Definition mutt.h:92
MUTT_OLD
@ MUTT_OLD
Old messages.
Definition mutt.h:90
MUTT_FLAG
@ MUTT_FLAG
Flagged messages.
Definition mutt.h:98
MUTT_DELETE
@ MUTT_DELETE
Messages to be deleted.
Definition mutt.h:94
MUTT_REPLIED
@ MUTT_REPLIED
Messages that have been replied to.
Definition mutt.h:91
ImapEmailData::old
bool old
Email has been seen.
Definition edata.h:38
ImapEmailData::read
bool read
Email has been read.
Definition edata.h:37
ImapEmailData::flagged
bool flagged
Email has been flagged.
Definition edata.h:40
ImapEmailData::replied
bool replied
Email has been replied to.
Definition edata.h:41
ImapHeader
IMAP-specific header.
Definition message.h:34
ImapHeader::edata
struct ImapEmailData * edata
IMAP-specific Email data.
Definition message.h:35
Mailbox::changed
bool changed
Mailbox has been modified.
Definition mailbox.h:109
Mailbox::readonly
bool readonly
Don't allow changes to the mailbox.
Definition mailbox.h:115
driver_tags_replace
bool driver_tags_replace(struct TagList *tl, const char *tags)
Replace all tags.
Definition tags.c:202
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_cache_del()

int imap_cache_del ( struct Mailbox * m,
struct Email * e )

Delete an email from the body cache.

Parameters
mSelected Imap Mailbox
eEmail
Return values
0Success
-1Failure

Definition at line 1897 of file message.c.

1898{
1899 struct ImapAccountData *adata = imap_adata_get(m);
1900 struct ImapMboxData *mdata = imap_mdata_get(m);
1901
1902 if (!e || !adata || (adata->mailbox != m) || !mdata)
1903 return -1;
1904
1905 mdata->bcache = imap_bcache_open(m);
1906 char id[64] = { 0 };
1907 snprintf(id, sizeof(id), "%u-%u", mdata->uidvalidity, imap_edata_get(e)->uid);
1908 return mutt_bcache_del(mdata->bcache, id);
1909}
mutt_bcache_del
int mutt_bcache_del(struct BodyCache *bcache, const char *id)
Delete a file from the Body Cache.
Definition bcache.c:274
imap_bcache_open
static struct BodyCache * imap_bcache_open(struct Mailbox *m)
Open a message cache.
Definition message.c:81
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_cache_clean()

int imap_cache_clean ( struct Mailbox * m)

Delete all the entries in the message cache.

Parameters
mSelectedImap Mailbox
Return values
0Always

Definition at line 1916 of file message.c.

1917{
1918 struct ImapAccountData *adata = imap_adata_get(m);
1919 struct ImapMboxData *mdata = imap_mdata_get(m);
1920
1921 if (!adata || (adata->mailbox != m) || !mdata)
1922 return -1;
1923
1924 mdata->bcache = imap_bcache_open(m);
1925 mutt_bcache_list(mdata->bcache, imap_bcache_delete, mdata);
1926
1927 return 0;
1928}
mutt_bcache_list
int mutt_bcache_list(struct BodyCache *bcache, bcache_list_t want_id, void *data)
Find matching entries in the Body Cache.
Definition bcache.c:339
imap_bcache_delete
static int imap_bcache_delete(const char *id, struct BodyCache *bcache, void *data)
Delete an entry from the message cache - Implements bcache_list_t -.
Definition message.c:169
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_append_message()

int imap_append_message ( struct Mailbox * m,
struct Message * msg )

Write an email back to the server.

Parameters
mMailbox
msgMessage to save
Return values
0Success
-1Failure

Definition at line 1552 of file message.c.

1553{
1554 if (!m || !msg)
1555 return -1;
1556
1557 struct ImapAccountData *adata = imap_adata_get(m);
1558 struct ImapMboxData *mdata = imap_mdata_get(m);
1559 if (!adata || !mdata)
1560 return -1;
1561
1562 FILE *fp = NULL;
1563 char buf[2048] = { 0 };
1564 struct Buffer *internaldate = NULL;
1565 struct Buffer *imap_flags = NULL;
1566 size_t len;
1567 struct Progress *progress = NULL;
1568 size_t sent;
1569 int c, last;
1570 int rc;
1571
1572 fp = mutt_file_fopen(msg->path, "r");
1573 if (!fp)
1574 {
1575 mutt_perror("%s", msg->path);
1576 goto fail;
1577 }
1578
1579 /* currently we set the \Seen flag on all messages, but probably we
1580 * should scan the message Status header for flag info. Since we're
1581 * already rereading the whole file for length it isn't any more
1582 * expensive (it'd be nice if we had the file size passed in already
1583 * by the code that writes the file, but that's a lot of changes.
1584 * Ideally we'd have an Email structure with flag info here... */
1585 for (last = EOF, len = 0; (c = fgetc(fp)) != EOF; last = c)
1586 {
1587 if ((c == '\n') && (last != '\r'))
1588 len++;
1589
1590 len++;
1591 }
1592 rewind(fp);
1593
1594 if (m->verbose)
1595 {
1596 progress = progress_new(MUTT_PROGRESS_NET, len);
1597 progress_set_message(progress, _("Uploading message..."));
1598 }
1599
1600 internaldate = buf_pool_get();
1601 mutt_date_make_imap(internaldate, msg->received);
1602
1603 imap_flags = buf_pool_get();
1604
1605 if (msg->flags.read)
1606 buf_addstr(imap_flags, " \\Seen");
1607 if (msg->flags.replied)
1608 buf_addstr(imap_flags, " \\Answered");
1609 if (msg->flags.flagged)
1610 buf_addstr(imap_flags, " \\Flagged");
1611 if (msg->flags.draft)
1612 buf_addstr(imap_flags, " \\Draft");
1613
1614 snprintf(buf, sizeof(buf), "APPEND %s (%s) \"%s\" {%lu}", mdata->munge_name,
1615 imap_flags->data + 1, buf_string(internaldate), (unsigned long) len);
1616 buf_pool_release(&internaldate);
1617
1618 imap_cmd_start(adata, buf);
1619
1620 do
1621 {
1622 rc = imap_cmd_step(adata);
1623 } while (rc == IMAP_RES_CONTINUE);
1624
1625 if (rc != IMAP_RES_RESPOND)
1626 goto cmd_step_fail;
1627
1628 for (last = EOF, sent = len = 0; (c = fgetc(fp)) != EOF; last = c)
1629 {
1630 if ((c == '\n') && (last != '\r'))
1631 buf[len++] = '\r';
1632
1633 buf[len++] = c;
1634
1635 if (len > sizeof(buf) - 3)
1636 {
1637 sent += len;
1638 if (flush_buffer(buf, &len, adata->conn) < 0)
1639 goto fail;
1640 progress_update(progress, sent, -1);
1641 }
1642 }
1643
1644 if (len > 0)
1645 if (flush_buffer(buf, &len, adata->conn) < 0)
1646 goto fail;
1647
1648 if (mutt_socket_send(adata->conn, "\r\n") < 0)
1649 goto fail;
1650 mutt_file_fclose(&fp);
1651
1652 do
1653 {
1654 rc = imap_cmd_step(adata);
1655 } while (rc == IMAP_RES_CONTINUE);
1656
1657 if (rc != IMAP_RES_OK)
1658 goto cmd_step_fail;
1659
1660 progress_free(&progress);
1661 buf_pool_release(&imap_flags);
1662 return 0;
1663
1664cmd_step_fail:
1665 mutt_debug(LL_DEBUG1, "command failed: %s\n", adata->buf);
1666 if (rc != IMAP_RES_BAD)
1667 {
1668 char *pc = imap_next_word(adata->buf); /* skip sequence number or token */
1669 pc = imap_next_word(pc); /* skip response code */
1670 if (*pc != '\0')
1671 mutt_error("%s", pc);
1672 }
1673
1674fail:
1675 mutt_file_fclose(&fp);
1676 progress_free(&progress);
1677 buf_pool_release(&imap_flags);
1678 return -1;
1679}
mutt_file_fclose
#define mutt_file_fclose(FP)
Definition file.h:139
mutt_file_fopen
#define mutt_file_fopen(PATH, MODE)
Definition file.h:138
mutt_perror
#define mutt_perror(...)
Definition logging2.h:95
imap_cmd_start
int imap_cmd_start(struct ImapAccountData *adata, const char *cmdstr)
Given an IMAP command, send it to the server.
Definition command.c:1211
flush_buffer
static int flush_buffer(char *buf, size_t *len, struct Connection *conn)
Write data to a connection.
Definition message.c:493
mutt_date_make_imap
int mutt_date_make_imap(struct Buffer *buf, time_t timestamp)
Format date in IMAP style: DD-MMM-YYYY HH:MM:SS +ZZzz.
Definition date.c:812
MUTT_PROGRESS_NET
@ MUTT_PROGRESS_NET
Progress tracks bytes, according to $net_inc
Definition lib.h:83
progress_new
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
Definition progress.c:139
progress_free
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition progress.c:110
progress_set_message
void progress_set_message(struct Progress *progress, const char *fmt,...) __attribute__((__format__(__printf__
mutt_socket_send
#define mutt_socket_send(conn, buf)
Definition socket.h:56
ImapMboxData::munge_name
char * munge_name
Munged version of the mailbox name.
Definition mdata.h:42
Mailbox::verbose
bool verbose
Display status messages?
Definition mailbox.h:116
Message::path
char * path
path to temp file
Definition message.h:36
Message::flags
struct Message::@264267271004327071125374067057142037276212342100 flags
Flags for the Message.
Message::draft
bool draft
Message has been read.
Definition message.h:44
Message::replied
bool replied
Message has been replied to.
Definition message.h:43
Message::received
time_t received
Time at which this message was received.
Definition message.h:46
Message::flagged
bool flagged
Message is flagged.
Definition message.h:42
Message::read
bool read
Message has been read.
Definition message.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_open()

void imap_hcache_open ( struct ImapAccountData * adata,
struct ImapMboxData * mdata,
bool create )

Open a header cache.

Parameters
adataImap Account data
mdataImap Mailbox data
createCreate a new header cache if missing?

Definition at line 304 of file util.c.

305{
306 if (!adata || !mdata)
307 return;
308
309 if (mdata->hcache)
310 return;
311
312 struct HeaderCache *hc = NULL;
313 struct Buffer *mbox = buf_pool_get();
314 struct Buffer *cachepath = buf_pool_get();
315
316 imap_cachepath(adata->delim, mdata->name, mbox);
317
318 if (strstr(buf_string(mbox), "/../") || mutt_str_equal(buf_string(mbox), "..") ||
319 mutt_strn_equal(buf_string(mbox), "../", 3))
320 {
321 goto cleanup;
322 }
323 size_t len = buf_len(mbox);
324 if ((len > 3) && (mutt_str_equal(buf_string(mbox) + len - 3, "/..")))
325 goto cleanup;
326
327 struct Url url = { 0 };
328 account_to_url(&adata->conn->account, &url);
329 url.path = mbox->data;
330 url_tobuffer(&url, cachepath, U_PATH);
331
332 const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
333 hc = hcache_open(c_header_cache, buf_string(cachepath), imap_hcache_namer, create);
334
335cleanup:
336 buf_pool_release(&mbox);
337 buf_pool_release(&cachepath);
338 mdata->hcache = hc;
339}
buf_len
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition buffer.c:491
cs_subset_path
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition helpers.c:168
imap_hcache_namer
static void imap_hcache_namer(const struct StoreOps *store_ops, const char *path, struct Buffer *dest)
Generate a filename for the header cache - Implements hcache_namer_t -.
Definition util.c:292
hcache_open
struct HeaderCache * hcache_open(const char *path, const char *folder, hcache_namer_t namer, bool create)
Multiplexor for StoreOps::open.
Definition hcache.c:479
mutt_strn_equal
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition string.c:429
account_to_url
void account_to_url(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition mutt_account.c:80
HeaderCache
Header Cache.
Definition lib.h:87
ImapMboxData::hcache
struct HeaderCache * hcache
Email header cache.
Definition mdata.h:64
ImapMboxData::name
char * name
Mailbox name.
Definition mdata.h:41
Url
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition url.h:69
Url::path
char * path
Path.
Definition url.h:75
url_tobuffer
int url_tobuffer(const struct Url *url, struct Buffer *buf, uint8_t flags)
Output the URL string for a given Url object.
Definition url.c:358
U_PATH
#define U_PATH
Path is included in URL.
Definition url.h:50
imap_cachepath
void imap_cachepath(char delim, const char *mailbox, struct Buffer *dest)
Generate a cache path for a mailbox.
Definition util.c:751
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_close()

void imap_hcache_close ( struct ImapMboxData * mdata)

Close the header cache.

Parameters
mdataImap Mailbox data

Definition at line 345 of file util.c.

346{
347 if (!mdata->hcache)
348 return;
349
350 hcache_close(&mdata->hcache);
351}
hcache_close
void hcache_close(struct HeaderCache **ptr)
Multiplexor for StoreOps::close.
Definition hcache.c:550
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_get()

struct Email * imap_hcache_get ( struct ImapMboxData * mdata,
unsigned int uid )

Get a header cache entry by its UID.

Parameters
mdataImap Mailbox data
uidUID to find
Return values
ptrEmail
NULLFailure

Definition at line 360 of file util.c.

361{
362 if (!mdata->hcache)
363 return NULL;
364
365 char key[16] = { 0 };
366
367 snprintf(key, sizeof(key), "%u", uid);
368 struct HCacheEntry hce = hcache_fetch_email(mdata->hcache, key, mutt_str_len(key),
369 mdata->uidvalidity);
370 if (!hce.email && hce.uidvalidity)
371 {
372 mutt_debug(LL_DEBUG3, "hcache uidvalidity mismatch: %u\n", hce.uidvalidity);
373 }
374
375 return hce.email;
376}
hcache_fetch_email
struct HCacheEntry hcache_fetch_email(struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
Multiplexor for StoreOps::fetch.
Definition hcache.c:570
HCacheEntry
Wrapper for Email retrieved from the header cache.
Definition lib.h:100
HCacheEntry::uidvalidity
uint32_t uidvalidity
IMAP-specific UIDVALIDITY.
Definition lib.h:101
HCacheEntry::email
struct Email * email
Retrieved email.
Definition lib.h:103
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_put()

int imap_hcache_put ( struct ImapMboxData * mdata,
struct Email * e )

Add an entry to the header cache.

Parameters
mdataImap Mailbox data
eEmail
Return values
0Success
-1Failure

Definition at line 385 of file util.c.

386{
387 if (!mdata->hcache)
388 return -1;
389
390 char key[16] = { 0 };
391
392 snprintf(key, sizeof(key), "%u", imap_edata_get(e)->uid);
393 return hcache_store_email(mdata->hcache, key, mutt_str_len(key), e, mdata->uidvalidity);
394}
hcache_store_email
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:684
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_del()

int imap_hcache_del ( struct ImapMboxData * mdata,
unsigned int uid )

Delete an item from the header cache.

Parameters
mdataImap Mailbox data
uidUID of entry to delete
Return values
0Success
-1Failure

Definition at line 403 of file util.c.

404{
405 if (!mdata->hcache)
406 return -1;
407
408 char key[16] = { 0 };
409
410 snprintf(key, sizeof(key), "%u", uid);
411 return hcache_delete_email(mdata->hcache, key, mutt_str_len(key));
412}
hcache_delete_email
int hcache_delete_email(struct HeaderCache *hc, const char *key, size_t keylen)
Multiplexor for StoreOps::delete_record.
Definition hcache.c:753
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_store_uid_seqset()

int imap_hcache_store_uid_seqset ( struct ImapMboxData * mdata)

Store a UID Sequence Set in the header cache.

Parameters
mdataImap Mailbox data
Return values
0Success
-1Error

Definition at line 420 of file util.c.

421{
422 if (!mdata->hcache)
423 return -1;
424
425 struct Buffer *buf = buf_pool_get();
426 buf_alloc(buf, 8192); // The seqset is likely large. Preallocate to reduce reallocs
427 imap_msn_index_to_uid_seqset(buf, mdata);
428
429 int rc = hcache_store_raw(mdata->hcache, "UIDSEQSET", 9, buf->data, buf_len(buf) + 1);
430 mutt_debug(LL_DEBUG3, "Stored UIDSEQSET %s\n", buf_string(buf));
431 buf_pool_release(&buf);
432 return rc;
433}
imap_msn_index_to_uid_seqset
static void imap_msn_index_to_uid_seqset(struct Buffer *buf, struct ImapMboxData *mdata)
Convert MSN index of UIDs to Seqset.
Definition util.c:235
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_clear_uid_seqset()

int imap_hcache_clear_uid_seqset ( struct ImapMboxData * mdata)

Delete a UID Sequence Set from the header cache.

Parameters
mdataImap Mailbox data
Return values
0Success
-1Error

Definition at line 441 of file util.c.

442{
443 if (!mdata->hcache)
444 return -1;
445
446 return hcache_delete_raw(mdata->hcache, "UIDSEQSET", 9);
447}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_hcache_get_uid_seqset()

char * imap_hcache_get_uid_seqset ( struct ImapMboxData * mdata)

Get a UID Sequence Set from the header cache.

Parameters
mdataImap Mailbox data
Return values
ptrUID Sequence Set
NULLError

Definition at line 455 of file util.c.

456{
457 if (!mdata->hcache)
458 return NULL;
459
460 char *seqset = hcache_fetch_raw_str(mdata->hcache, "UIDSEQSET", 9);
461 mutt_debug(LL_DEBUG3, "Retrieved UIDSEQSET %s\n", NONULL(seqset));
462
463 return seqset;
464}
hcache_fetch_raw_str
char * hcache_fetch_raw_str(struct HeaderCache *hc, const char *key, size_t keylen)
Fetch a string from the cache.
Definition hcache.c:663
NONULL
#define NONULL(x)
Definition string2.h:44
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_continue()

enum QuadOption imap_continue ( const char * msg,
const char * resp )

Display a message and ask the user if they want to go on.

Parameters
msgLocation of the error
respMessage for user
Return values
QuadOptionResult, e.g. MUTT_NO

Definition at line 651 of file util.c.

652{
653 imap_error(msg, resp);
654 return query_yesorno(_("Continue?"), MUTT_NO);
655}
MUTT_NO
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition quad.h:38
query_yesorno
enum QuadOption query_yesorno(const char *prompt, enum QuadOption def)
Ask the user a Yes/No question.
Definition question.c:329
imap_error
void imap_error(const char *where, const char *msg)
Show an error and abort.
Definition util.c:662
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_error()

void imap_error ( const char * where,
const char * msg )

Show an error and abort.

Parameters
whereLocation of the error
msgMessage for user

Definition at line 662 of file util.c.

663{
664 mutt_error("%s [%s]", where, msg);
665}
+ Here is the caller graph for this function:

◆ imap_mdata_cache_reset()

void imap_mdata_cache_reset ( struct ImapMboxData * mdata)

Release and clear cache data of ImapMboxData structure.

Parameters
mdataImap Mailbox data

Definition at line 110 of file util.c.

111{
112 mutt_hash_free(&mdata->uid_hash);
113 imap_msn_free(&mdata->msn);
114 mutt_bcache_close(&mdata->bcache);
115}
mutt_bcache_close
void mutt_bcache_close(struct BodyCache **ptr)
Close an Email-Body Cache.
Definition bcache.c:167
mutt_hash_free
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition hash.c:459
imap_msn_free
void imap_msn_free(struct MSNArray *msn)
Free the cache.
Definition msn.c:62
ImapMboxData::bcache
struct BodyCache * bcache
Email body cache.
Definition mdata.h:62
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_fix_path()

char * imap_fix_path ( const char * mailbox,
char * path,
size_t plen )

Fix up the imap path.

Parameters
mailboxMailbox path
pathBuffer for the result
plenLength of buffer
Return values
ptrFixed-up path
Note
the first character in mailbox matching any of the characters in $imap_delim_chars is used as a delimiter.

This is necessary because the rest of neomutt assumes a hierarchy delimiter of '/', which is not necessarily true in IMAP. Additionally, the filesystem converts multiple hierarchy delimiters into a single one, ie "///" is equal to "/". IMAP servers are not required to do this. Moreover, IMAP servers may dislike the path ending with the delimiter.

Definition at line 683 of file util.c.

684{
685 const char *const c_imap_delim_chars = cs_subset_string(NeoMutt->sub, "imap_delim_chars");
686
687 char *out = path;
688 size_t space_left = plen - 1;
689
690 if (mailbox)
691 {
692 for (const char *c = mailbox; *c && space_left; c++, space_left--)
693 {
694 if (strchr(NONULL(c_imap_delim_chars), *c))
695 {
696 return imap_fix_path_with_delim(*c, mailbox, path, plen);
697 }
698 *out++ = *c;
699 }
700 }
701
702 *out = '\0';
703 return path;
704}
cs_subset_string
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition helpers.c:291
imap_fix_path_with_delim
char * imap_fix_path_with_delim(const char delim, const char *mailbox, char *path, size_t plen)
Fix up the imap path.
Definition util.c:715
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_fix_path_with_delim()

char * imap_fix_path_with_delim ( const char delim,
const char * mailbox,
char * path,
size_t plen )

Fix up the imap path.

Parameters
delimDelimiter specified by the server
mailboxMailbox path
pathBuffer for the result
plenLength of buffer
Return values
ptrFixed-up path

Definition at line 715 of file util.c.

716{
717 char *out = path;
718 size_t space_left = plen - 1;
719
720 if (mailbox)
721 {
722 for (const char *c = mailbox; *c && space_left; c++, space_left--)
723 {
724 if (*c == delim || *c == '/')
725 {
726 while (*c && *(c + 1) == *c)
727 c++;
728 *out++ = delim;
729 }
730 else
731 {
732 *out++ = *c;
733 }
734 }
735 }
736
737 if (out != path && *(out - 1) == delim)
738 {
739 out--;
740 }
741 *out = '\0';
742 return path;
743}
+ Here is the caller graph for this function:

◆ imap_cachepath()

void imap_cachepath ( char delim,
const char * mailbox,
struct Buffer * dest )

Generate a cache path for a mailbox.

Parameters
delimImap server delimiter
mailboxMailbox name
destBuffer to store cache path

Definition at line 751 of file util.c.

752{
753 const char *p = mailbox;
754 buf_reset(dest);
755 if (!p)
756 return;
757
758 while (*p)
759 {
760 if (p[0] == delim)
761 {
762 buf_addch(dest, '/');
763 /* simple way to avoid collisions with UIDs */
764 if ((p[1] >= '0') && (p[1] <= '9'))
765 buf_addch(dest, '_');
766 }
767 else
768 {
769 buf_addch(dest, *p);
770 }
771 p++;
772 }
773}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_get_literal_count()

int imap_get_literal_count ( char * buf,
unsigned int * bytes )

Write number of bytes in an IMAP literal into bytes.

Parameters
[in]bufNumber as a string
[out]bytesResulting number
Return values
0Success
-1Failure

Definition at line 782 of file util.c.

783{
784 char *pc = NULL;
785 char *pn = NULL;
786
787 if (!buf || !(pc = strchr(buf, '{')))
788 return -1;
789
790 pc++;
791 pn = pc;
792 while (mutt_isdigit(*pc))
793 pc++;
794 *pc = '\0';
795 if (!mutt_str_atoui(pn, bytes))
796 return -1;
797
798 return 0;
799}
mutt_str_atoui
const char * mutt_str_atoui(const char *str, unsigned int *dst)
Convert ASCII string to an unsigned integer.
Definition atoi.c:217
mutt_isdigit
bool mutt_isdigit(int arg)
Wrapper for isdigit(3)
Definition ctype.c:66
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_get_qualifier()

char * imap_get_qualifier ( char * buf)

Get the qualifier from a tagged response.

Parameters
bufCommand string to process
Return values
ptrStart of the qualifier

In a tagged response, skip tag and status for the qualifier message. Used by imap_copy_message for TRYCREATE

Definition at line 809 of file util.c.

810{
811 char *s = buf;
812
813 /* skip tag */
814 s = imap_next_word(s);
815 /* skip OK/NO/BAD response */
816 s = imap_next_word(s);
817
818 return s;
819}
imap_next_word
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition util.c:826
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_next_word()

char * imap_next_word ( char * s)

Find where the next IMAP word begins.

Parameters
sCommand string to process
Return values
ptrNext IMAP word

Definition at line 826 of file util.c.

827{
828 bool quoted = false;
829
830 while (*s)
831 {
832 if (*s == '\\')
833 {
834 s++;
835 if (*s)
836 s++;
837 continue;
838 }
839 if (*s == '\"')
840 quoted = !quoted;
841 if (!quoted && mutt_isspace(*s))
842 break;
843 s++;
844 }
845
846 SKIPWS(s);
847 return s;
848}
mutt_isspace
bool mutt_isspace(int arg)
Wrapper for isspace(3)
Definition ctype.c:96
SKIPWS
#define SKIPWS(ch)
Definition string2.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_qualify_path()

void imap_qualify_path ( char * buf,
size_t buflen,
struct ConnAccount * cac,
char * path )

Make an absolute IMAP folder target.

Parameters
bufBuffer for the result
buflenLength of buffer
cacConnAccount of the account
pathPath relative to the mailbox

Definition at line 857 of file util.c.

858{
859 struct Url url = { 0 };
860 account_to_url(cac, &url);
861 url.path = path;
862 url_tostring(&url, buf, buflen, U_NO_FLAGS);
863}
url_tostring
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
U_NO_FLAGS
#define U_NO_FLAGS
No flags are set for URL parsing.
Definition url.h:49
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_buf_qualify_path()

void imap_buf_qualify_path ( struct Buffer * buf,
struct ConnAccount * cac,
char * path )

Make an absolute IMAP folder target to a buffer.

Parameters
bufBuffer for the result
cacConnAccount of the account
pathPath relative to the mailbox

Definition at line 871 of file util.c.

872{
873 struct Url url = { 0 };
874 account_to_url(cac, &url);
875 url.path = path;
876 url_tobuffer(&url, buf, U_NO_FLAGS);
877}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_quote_string()

void imap_quote_string ( char * dest,
size_t dlen,
const char * src,
bool quote_backtick )

Quote string according to IMAP rules.

Parameters
destBuffer for the result
dlenLength of the buffer
srcString to be quoted
quote_backtickIf true, quote backticks too

Surround string with quotes, escape " and \ with backslash

Definition at line 888 of file util.c.

889{
890 const char *quote = "`\"\\";
891 if (!quote_backtick)
892 quote++;
893
894 char *pt = dest;
895 const char *s = src;
896
897 if (dlen < 3)
898 {
899 *dest = '\0';
900 return;
901 }
902
903 *pt++ = '"';
904 /* save room for quote-chars */
905 dlen -= 3;
906
907 for (; *s && dlen; s++)
908 {
909 if (strchr(quote, *s))
910 {
911 if (dlen < 2)
912 break;
913 dlen -= 2;
914 *pt++ = '\\';
915 *pt++ = *s;
916 }
917 else
918 {
919 *pt++ = *s;
920 dlen--;
921 }
922 }
923 *pt++ = '"';
924 *pt = '\0';
925}
+ Here is the caller graph for this function:

◆ imap_unquote_string()

void imap_unquote_string ( char * s)

Equally stupid unquoting routine.

Parameters
sString to be unquoted

Definition at line 931 of file util.c.

932{
933 char *d = s;
934
935 if (*s == '\"')
936 s++;
937 else
938 return;
939
940 while (*s)
941 {
942 if (*s == '\"')
943 {
944 *d = '\0';
945 return;
946 }
947 if (*s == '\\')
948 {
949 s++;
950 }
951 if (*s)
952 {
953 *d = *s;
954 d++;
955 s++;
956 }
957 }
958 *d = '\0';
959}
+ Here is the caller graph for this function:

◆ imap_munge_mbox_name()

void imap_munge_mbox_name ( bool unicode,
char * dest,
size_t dlen,
const char * src )

Quote awkward characters in a mailbox name.

Parameters
unicodetrue if Unicode is allowed
destBuffer to store safe mailbox name
dlenLength of buffer
srcMailbox name

Definition at line 968 of file util.c.

969{
970 char *buf = mutt_str_dup(src);
971 imap_utf_encode(unicode, &buf);
972
973 imap_quote_string(dest, dlen, buf, false);
974
975 FREE(&buf);
976}
imap_utf_encode
void imap_utf_encode(bool unicode, char **s)
Encode email from local charset to UTF-8.
Definition utf7.c:397
imap_quote_string
void imap_quote_string(char *dest, size_t dlen, const char *src, bool quote_backtick)
Quote string according to IMAP rules.
Definition util.c:888
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_unmunge_mbox_name()

void imap_unmunge_mbox_name ( bool unicode,
char * s )

Remove quoting from a mailbox name.

Parameters
unicodetrue if Unicode is allowed
sMailbox name

The string will be altered in-place.

Definition at line 985 of file util.c.

986{
987 imap_unquote_string(s);
988
989 char *buf = mutt_str_dup(s);
990 if (buf)
991 {
992 imap_utf_decode(unicode, &buf);
993 strncpy(s, buf, strlen(s));
994 }
995
996 FREE(&buf);
997}
imap_utf_decode
void imap_utf_decode(bool unicode, char **s)
Decode email from UTF-8 to local charset.
Definition utf7.c:430
imap_unquote_string
void imap_unquote_string(char *s)
Equally stupid unquoting routine.
Definition util.c:931
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_seqset_iterator_new()

struct SeqsetIterator * mutt_seqset_iterator_new ( const char * seqset)

Create a new Sequence Set Iterator.

Parameters
seqsetSource Sequence Set
Return values
ptrNewly allocated Sequence Set Iterator

Definition at line 1135 of file util.c.

1136{
1137 if (!seqset || (*seqset == '\0'))
1138 return NULL;
1139
1140 struct SeqsetIterator *iter = MUTT_MEM_CALLOC(1, struct SeqsetIterator);
1141 iter->full_seqset = mutt_str_dup(seqset);
1142 iter->eostr = strchr(iter->full_seqset, '\0');
1143 iter->substr_cur = iter->substr_end = iter->full_seqset;
1144
1145 return iter;
1146}
MUTT_MEM_CALLOC
#define MUTT_MEM_CALLOC(n, type)
Definition memory.h:52
SeqsetIterator
UID Sequence Set Iterator.
Definition private.h:169
SeqsetIterator::eostr
char * eostr
End of string.
Definition private.h:171
SeqsetIterator::substr_end
char * substr_end
End of substring.
Definition private.h:177
SeqsetIterator::substr_cur
char * substr_cur
Current position in substring.
Definition private.h:176
SeqsetIterator::full_seqset
char * full_seqset
Full sequence set string.
Definition private.h:170
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_seqset_iterator_next()

int mutt_seqset_iterator_next ( struct SeqsetIterator * iter,
unsigned int * next )

Get the next UID from a Sequence Set.

Parameters
[in]iterSequence Set Iterator
[out]nextNext UID in set
Return values
0Next sequence is generated
1Iterator is finished
-1error

Definition at line 1156 of file util.c.

1157{
1158 if (!iter || !next)
1159 return -1;
1160
1161 if (iter->in_range)
1162 {
1163 if ((iter->down && (iter->range_cur == (iter->range_end - 1))) ||
1164 (!iter->down && (iter->range_cur == (iter->range_end + 1))))
1165 {
1166 iter->in_range = 0;
1167 }
1168 }
1169
1170 if (!iter->in_range)
1171 {
1172 iter->substr_cur = iter->substr_end;
1173 if (iter->substr_cur == iter->eostr)
1174 return 1;
1175
1176 iter->substr_end = strchr(iter->substr_cur, ',');
1177 if (!iter->substr_end)
1178 iter->substr_end = iter->eostr;
1179 else
1180 *(iter->substr_end++) = '\0';
1181
1182 char *range_sep = strchr(iter->substr_cur, ':');
1183 if (range_sep)
1184 *range_sep++ = '\0';
1185
1186 if (!mutt_str_atoui_full(iter->substr_cur, &iter->range_cur))
1187 return -1;
1188 if (range_sep)
1189 {
1190 if (!mutt_str_atoui_full(range_sep, &iter->range_end))
1191 return -1;
1192 }
1193 else
1194 {
1195 iter->range_end = iter->range_cur;
1196 }
1197
1198 iter->down = (iter->range_end < iter->range_cur);
1199 iter->in_range = 1;
1200 }
1201
1202 *next = iter->range_cur;
1203 if (iter->down)
1204 iter->range_cur--;
1205 else
1206 iter->range_cur++;
1207
1208 return 0;
1209}
SeqsetIterator::range_end
unsigned int range_end
End of range.
Definition private.h:175
SeqsetIterator::down
int down
Counting down.
Definition private.h:173
SeqsetIterator::in_range
int in_range
Currently in a range.
Definition private.h:172
SeqsetIterator::range_cur
unsigned int range_cur
Current range value.
Definition private.h:174
+ Here is the caller graph for this function:

◆ mutt_seqset_iterator_free()

void mutt_seqset_iterator_free ( struct SeqsetIterator ** ptr)

Free a Sequence Set Iterator.

Parameters
[out]ptrIterator to free

Definition at line 1215 of file util.c.

1216{
1217 if (!ptr || !*ptr)
1218 return;
1219
1220 struct SeqsetIterator *iter = *ptr;
1221 FREE(&iter->full_seqset);
1222 FREE(ptr);
1223}
+ Here is the caller graph for this function:

◆ imap_account_match()

bool imap_account_match ( const struct ConnAccount * a1,
const struct ConnAccount * a2 )

Compare two Accounts.

Parameters
a1First ConnAccount
a2Second ConnAccount
Return values
trueAccounts match

Definition at line 1103 of file util.c.

1104{
1105 if (!a1 || !a2)
1106 return false;
1107 if (a1->type != a2->type)
1108 return false;
1109 if (!mutt_istr_equal(a1->host, a2->host))
1110 return false;
1111 if ((a1->port != 0) && (a2->port != 0) && (a1->port != a2->port))
1112 return false;
1113 if (a1->flags & a2->flags & MUTT_ACCT_USER)
1114 return mutt_str_equal(a1->user, a2->user);
1115
1116 const char *user = NONULL(NeoMutt->username);
1117
1118 const char *const c_imap_user = cs_subset_string(NeoMutt->sub, "imap_user");
1119 if ((a1->type == MUTT_ACCT_TYPE_IMAP) && c_imap_user)
1120 user = c_imap_user;
1121
1122 if (a1->flags & MUTT_ACCT_USER)
1123 return mutt_str_equal(a1->user, user);
1124 if (a2->flags & MUTT_ACCT_USER)
1125 return mutt_str_equal(a2->user, user);
1126
1127 return true;
1128}
MUTT_ACCT_USER
#define MUTT_ACCT_USER
User field has been set.
Definition connaccount.h:44
MUTT_ACCT_TYPE_IMAP
@ MUTT_ACCT_TYPE_IMAP
Imap Account.
Definition mutt_account.h:36
ConnAccount::user
char user[128]
Username.
Definition connaccount.h:56
ConnAccount::type
unsigned char type
Connection type, e.g. MUTT_ACCT_TYPE_IMAP.
Definition connaccount.h:59
ConnAccount::flags
MuttAccountFlags flags
Which fields are initialised, e.g. MUTT_ACCT_USER.
Definition connaccount.h:60
ConnAccount::port
unsigned short port
Port to connect to.
Definition connaccount.h:58
NeoMutt::username
char * username
User's login name.
Definition neomutt.h:57
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_get_parent()

void imap_get_parent ( const char * mbox,
char delim,
char * buf,
size_t buflen )

Get an IMAP folder's parent.

Parameters
mboxMailbox whose parent is to be determined
delimPath delimiter
bufBuffer for the result
buflenLength of the buffer

Definition at line 124 of file util.c.

125{
126 /* Make a copy of the mailbox name, but only if the pointers are different */
127 if (mbox != buf)
128 mutt_str_copy(buf, mbox, buflen);
129
130 int n = mutt_str_len(buf);
131
132 /* Let's go backwards until the next delimiter
133 *
134 * If buf[n] is a '/', the first n-- will allow us
135 * to ignore it. If it isn't, then buf looks like
136 * "/aaaaa/bbbb". There is at least one "b", so we can't skip
137 * the "/" after the 'a's.
138 *
139 * If buf == '/', then n-- => n == 0, so the loop ends
140 * immediately */
141 for (n--; (n >= 0) && (buf[n] != delim); n--)
142 ; // do nothing
143
144 /* We stopped before the beginning. There is a trailing slash. */
145 if (n > 0)
146 {
147 /* Strip the trailing delimiter. */
148 buf[n] = '\0';
149 }
150 else
151 {
152 buf[0] = (n == 0) ? delim : '\0';
153 }
154}
mutt_str_copy
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:586
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_account_match()

bool mutt_account_match ( const struct ConnAccount * a1,
const struct ConnAccount * a2 )

◆ imap_utf_encode()

void imap_utf_encode ( bool unicode,
char ** s )

Encode email from local charset to UTF-8.

Parameters
[in]unicodetrue if Unicode is allowed
[out]sEmail to convert

Definition at line 397 of file utf7.c.

398{
399 if (!s || !*s)
400 return;
401
402 const char *c_charset = cc_charset();
403 if (!c_charset)
404 return;
405
406 if (unicode && mutt_ch_is_utf8(c_charset))
407 {
408 return;
409 }
410
411 if (mutt_ch_convert_string(s, c_charset, "utf-8", MUTT_ICONV_NO_FLAGS) != 0)
412 {
413 FREE(s);
414 return;
415 }
416
417 if (!unicode)
418 {
419 char *utf7 = utf8_to_utf7(*s, strlen(*s), NULL, 0);
420 FREE(s);
421 *s = utf7;
422 }
423}
cc_charset
const char * cc_charset(void)
Get the cached value of $charset.
Definition config_cache.c:116
mutt_ch_convert_string
int mutt_ch_convert_string(char **ps, const char *from, const char *to, uint8_t flags)
Convert a string between encodings.
Definition charset.c:817
mutt_ch_is_utf8
#define mutt_ch_is_utf8(str)
Definition charset.h:107
MUTT_ICONV_NO_FLAGS
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition charset.h:66
utf8_to_utf7
static char * utf8_to_utf7(const char *u8, size_t u8len, char **u7, size_t *u7len)
Convert data from UTF-8 to RFC2060's UTF-7.
Definition utf7.c:252
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_utf_decode()

void imap_utf_decode ( bool unicode,
char ** s )

Decode email from UTF-8 to local charset.

Parameters
[in]unicodetrue if Unicode is allowed
[out]sEmail to convert

Definition at line 430 of file utf7.c.

431{
432 if (!s || !*s)
433 return;
434
435 const char *c_charset = cc_charset();
436 if (!c_charset)
437 return;
438
439 if (unicode && mutt_ch_is_utf8(c_charset))
440 {
441 return;
442 }
443
444 if (!unicode)
445 {
446 char *utf8 = utf7_to_utf8(*s, strlen(*s), 0, 0);
447 FREE(s);
448 *s = utf8;
449 }
450
451 if (mutt_ch_convert_string(s, "utf-8", c_charset, MUTT_ICONV_NO_FLAGS) != 0)
452 {
453 FREE(s);
454 }
455}
utf7_to_utf8
static char * utf7_to_utf8(const char *u7, size_t u7len, char **u8, size_t *u8len)
Convert data from RFC2060's UTF-7 to UTF-8.
Definition utf7.c:106
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_allow_reopen()

void imap_allow_reopen ( struct Mailbox * m)

Allow re-opening a folder upon expunge.

Parameters
mMailbox

Definition at line 1075 of file util.c.

1076{
1077 struct ImapAccountData *adata = imap_adata_get(m);
1078 struct ImapMboxData *mdata = imap_mdata_get(m);
1079 if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
1080 return;
1081 mdata->reopen |= IMAP_REOPEN_ALLOW;
1082}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ imap_disallow_reopen()

void imap_disallow_reopen ( struct Mailbox * m)

Disallow re-opening a folder upon expunge.

Parameters
mMailbox

Definition at line 1088 of file util.c.

1089{
1090 struct ImapAccountData *adata = imap_adata_get(m);
1091 struct ImapMboxData *mdata = imap_mdata_get(m);
1092 if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
1093 return;
1094 mdata->reopen &= ~IMAP_REOPEN_ALLOW;
1095}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ cmd_parse_search()

void cmd_parse_search ( struct ImapAccountData * adata,
const char * s )

Store SEARCH response for later use.

Parameters
adataImap Account data
sCommand string with search results

Definition at line 259 of file search.c.

260{
261 unsigned int uid;
262 struct Email *e = NULL;
263
264 if (!adata->mailbox)
265 return;
266
267 struct ImapMboxData *mdata = adata->mailbox->mdata;
268 if (!mdata)
269 return;
270
271 mutt_debug(LL_DEBUG2, "Handling SEARCH\n");
272
273 while ((s = imap_next_word((char *) s)) && (*s != '\0'))
274 {
275 if (!mutt_str_atoui(s, &uid))
276 continue;
277 e = mutt_hash_int_find(mdata->uid_hash, uid);
278 if (e)
279 e->matched = true;
280 }
281}
mutt_hash_int_find
void * mutt_hash_int_find(const struct HashTable *table, unsigned int intkey)
Find the HashElem data in a Hash Table element using a key.
Definition hash.c:394
Email::matched
bool matched
Search matches this Email.
Definition email.h:102
+ Here is the call graph for this function:
+ Here is the caller graph for this function: