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 "mutt.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. More...
#define	IMAP_SSL_PORT   993
	Port for IMAP over SSL/TLS. More...
#define	IMAP_LOG_CMD   2
#define	IMAP_LOG_LTRL   3
#define	IMAP_LOG_PASS   5
#define	IMAP_RES_NO   -2
	<tag> NO ... More...
#define	IMAP_RES_BAD   -1
	<tag> BAD ... More...
#define	IMAP_RES_OK   0
	<tag> OK ... More...
#define	IMAP_RES_CONTINUE   1
	* ... More...
#define	IMAP_RES_RESPOND   2
	+ More...
#define	IMAP_RES_NEW   3
	ImapCommand.state additions. More...
#define	SEQ_LEN   16
#define	IMAP_MAX_CMDLEN   1024
	Maximum length of command lines before they must be split (for lazy servers) More...
#define	IMAP_OPEN_NO_FLAGS   0
	No flags are set. More...
#define	IMAP_REOPEN_ALLOW   (1 << 0)
	Allow re-opening a folder upon expunge. More...
#define	IMAP_EXPUNGE_EXPECTED   (1 << 1)
	Messages will be expunged from the server. More...
#define	IMAP_EXPUNGE_PENDING   (1 << 2)
	Messages on the server have been expunged. More...
#define	IMAP_NEWMAIL_PENDING   (1 << 3)
	New mail is waiting on the server. More...
#define	IMAP_FLAGS_PENDING   (1 << 4)
	Flags have changed on the server. More...
#define	IMAP_CMD_NO_FLAGS   0
	No flags are set. More...
#define	IMAP_CMD_PASS   (1 << 0)
	Command contains a password. Suppress logging. More...
#define	IMAP_CMD_QUEUE   (1 << 1)
	Queue a command, do not execute. More...
#define	IMAP_CMD_POLL   (1 << 2)
	Poll the tcp connection before running the imap command. More...
#define	IMAP_CMD_SINGLE   (1 << 3)
	Run a single command. More...
#define	IMAP_DATELEN   27
#define	IMAP_CAP_NO_FLAGS   0
	No flags are set. More...
#define	IMAP_CAP_IMAP4   (1 << 0)
	Server supports IMAP4. More...
#define	IMAP_CAP_IMAP4REV1   (1 << 1)
	Server supports IMAP4rev1. More...
#define	IMAP_CAP_STATUS   (1 << 2)
	Server supports STATUS command. More...
#define	IMAP_CAP_ACL   (1 << 3)
	RFC2086: IMAP4 ACL extension. More...
#define	IMAP_CAP_NAMESPACE   (1 << 4)
	RFC2342: IMAP4 Namespace. More...
#define	IMAP_CAP_AUTH_CRAM_MD5   (1 << 5)
	RFC2195: CRAM-MD5 authentication. More...
#define	IMAP_CAP_AUTH_GSSAPI   (1 << 6)
	RFC1731: GSSAPI authentication. More...
#define	IMAP_CAP_AUTH_ANONYMOUS   (1 << 7)
	AUTH=ANONYMOUS. More...
#define	IMAP_CAP_AUTH_OAUTHBEARER   (1 << 8)
	RFC7628: AUTH=OAUTHBEARER. More...
#define	IMAP_CAP_STARTTLS   (1 << 9)
	RFC2595: STARTTLS. More...
#define	IMAP_CAP_LOGINDISABLED   (1 << 10)
	RFC2595: LOGINDISABLED. More...
#define	IMAP_CAP_IDLE   (1 << 11)
	RFC2177: IDLE. More...
#define	IMAP_CAP_SASL_IR   (1 << 12)
	SASL initial response draft. More...
#define	IMAP_CAP_ENABLE   (1 << 13)
	RFC5161. More...
#define	IMAP_CAP_CONDSTORE   (1 << 14)
	RFC7162. More...
#define	IMAP_CAP_QRESYNC   (1 << 15)
	RFC7162. More...
#define	IMAP_CAP_LIST_EXTENDED   (1 << 16)
	RFC5258: IMAP4 LIST Command Extensions. More...
#define	IMAP_CAP_COMPRESS   (1 << 17)
	RFC4978: COMPRESS=DEFLATE. More...
#define	IMAP_CAP_X_GM_EXT_1   (1 << 18)
	https://developers.google.com/gmail/imap/imap-extensions More...
#define	IMAP_CAP_ALL   ((1 << 19) - 1)

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

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

Detailed Description

Shared constants/structs that are private to IMAP.

Authors

• Brandon Long
• Brendan Cully
• Richard Russon

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 45 of file private.h.

IMAP_SSL_PORT

#define IMAP_SSL_PORT   993

Port for IMAP over SSL/TLS.

Definition at line 46 of file private.h.

IMAP_LOG_CMD

#define IMAP_LOG_CMD   2

Definition at line 49 of file private.h.

IMAP_LOG_LTRL

#define IMAP_LOG_LTRL   3

Definition at line 50 of file private.h.

IMAP_LOG_PASS

#define IMAP_LOG_PASS   5

Definition at line 51 of file private.h.

IMAP_RES_NO

#define IMAP_RES_NO   -2

<tag> NO ...

Definition at line 54 of file private.h.

IMAP_RES_BAD

#define IMAP_RES_BAD   -1

<tag> BAD ...

Definition at line 55 of file private.h.

IMAP_RES_OK

#define IMAP_RES_OK   0

<tag> OK ...

Definition at line 56 of file private.h.

IMAP_RES_CONTINUE

#define IMAP_RES_CONTINUE   1

* ...

Definition at line 57 of file private.h.

IMAP_RES_RESPOND

#define IMAP_RES_RESPOND   2

+

Definition at line 58 of file private.h.

IMAP_RES_NEW

#define IMAP_RES_NEW   3

ImapCommand.state additions.

Definition at line 59 of file private.h.

SEQ_LEN

#define SEQ_LEN   16

Definition at line 61 of file private.h.

IMAP_MAX_CMDLEN

#define IMAP_MAX_CMDLEN   1024

Maximum length of command lines before they must be split (for lazy servers)

Definition at line 62 of file private.h.

IMAP_OPEN_NO_FLAGS

#define IMAP_OPEN_NO_FLAGS   0

No flags are set.

Definition at line 65 of file private.h.

IMAP_REOPEN_ALLOW

#define IMAP_REOPEN_ALLOW   (1 << 0)

Allow re-opening a folder upon expunge.

Definition at line 66 of file private.h.

IMAP_EXPUNGE_EXPECTED

#define IMAP_EXPUNGE_EXPECTED   (1 << 1)

Messages will be expunged from the server.

Definition at line 67 of file private.h.

IMAP_EXPUNGE_PENDING

#define IMAP_EXPUNGE_PENDING   (1 << 2)

Messages on the server have been expunged.

Definition at line 68 of file private.h.

IMAP_NEWMAIL_PENDING

#define IMAP_NEWMAIL_PENDING   (1 << 3)

New mail is waiting on the server.

Definition at line 69 of file private.h.

IMAP_FLAGS_PENDING

#define IMAP_FLAGS_PENDING   (1 << 4)

Flags have changed on the server.

Definition at line 70 of file private.h.

IMAP_CMD_NO_FLAGS

#define IMAP_CMD_NO_FLAGS   0

No flags are set.

Definition at line 73 of file private.h.

IMAP_CMD_PASS

#define IMAP_CMD_PASS   (1 << 0)

Command contains a password. Suppress logging.

Definition at line 74 of file private.h.

IMAP_CMD_QUEUE

#define IMAP_CMD_QUEUE   (1 << 1)

Queue a command, do not execute.

Definition at line 75 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 76 of file private.h.

IMAP_CMD_SINGLE

#define IMAP_CMD_SINGLE   (1 << 3)

Run a single command.

Definition at line 77 of file private.h.

IMAP_DATELEN

#define IMAP_DATELEN   27

Definition at line 90 of file private.h.

IMAP_CAP_NO_FLAGS

#define IMAP_CAP_NO_FLAGS   0

No flags are set.

Definition at line 122 of file private.h.

IMAP_CAP_IMAP4

#define IMAP_CAP_IMAP4   (1 << 0)

Server supports IMAP4.

Definition at line 123 of file private.h.

IMAP_CAP_IMAP4REV1

#define IMAP_CAP_IMAP4REV1   (1 << 1)

Server supports IMAP4rev1.

Definition at line 124 of file private.h.

IMAP_CAP_STATUS

#define IMAP_CAP_STATUS   (1 << 2)

Server supports STATUS command.

Definition at line 125 of file private.h.

IMAP_CAP_ACL

#define IMAP_CAP_ACL   (1 << 3)

RFC2086: IMAP4 ACL extension.

Definition at line 126 of file private.h.

IMAP_CAP_NAMESPACE

#define IMAP_CAP_NAMESPACE   (1 << 4)

RFC2342: IMAP4 Namespace.

Definition at line 127 of file private.h.

IMAP_CAP_AUTH_CRAM_MD5

#define IMAP_CAP_AUTH_CRAM_MD5   (1 << 5)

RFC2195: CRAM-MD5 authentication.

Definition at line 128 of file private.h.

IMAP_CAP_AUTH_GSSAPI

#define IMAP_CAP_AUTH_GSSAPI   (1 << 6)

RFC1731: GSSAPI authentication.

Definition at line 129 of file private.h.

IMAP_CAP_AUTH_ANONYMOUS

#define IMAP_CAP_AUTH_ANONYMOUS   (1 << 7)

AUTH=ANONYMOUS.

Definition at line 130 of file private.h.

IMAP_CAP_AUTH_OAUTHBEARER

#define IMAP_CAP_AUTH_OAUTHBEARER   (1 << 8)

RFC7628: AUTH=OAUTHBEARER.

Definition at line 131 of file private.h.

IMAP_CAP_STARTTLS

#define IMAP_CAP_STARTTLS   (1 << 9)

RFC2595: STARTTLS.

Definition at line 132 of file private.h.

IMAP_CAP_LOGINDISABLED

#define IMAP_CAP_LOGINDISABLED   (1 << 10)

RFC2595: LOGINDISABLED.

Definition at line 133 of file private.h.

IMAP_CAP_IDLE

#define IMAP_CAP_IDLE   (1 << 11)

RFC2177: IDLE.

Definition at line 134 of file private.h.

IMAP_CAP_SASL_IR

#define IMAP_CAP_SASL_IR   (1 << 12)

SASL initial response draft.

Definition at line 135 of file private.h.

IMAP_CAP_ENABLE

#define IMAP_CAP_ENABLE   (1 << 13)

RFC5161.

Definition at line 136 of file private.h.

IMAP_CAP_CONDSTORE

#define IMAP_CAP_CONDSTORE   (1 << 14)

RFC7162.

Definition at line 137 of file private.h.

IMAP_CAP_QRESYNC

#define IMAP_CAP_QRESYNC   (1 << 15)

RFC7162.

Definition at line 138 of file private.h.

IMAP_CAP_LIST_EXTENDED

#define IMAP_CAP_LIST_EXTENDED   (1 << 16)

RFC5258: IMAP4 LIST Command Extensions.

Definition at line 139 of file private.h.

IMAP_CAP_COMPRESS

#define IMAP_CAP_COMPRESS   (1 << 17)

RFC4978: COMPRESS=DEFLATE.

Definition at line 140 of file private.h.

IMAP_CAP_X_GM_EXT_1

#define IMAP_CAP_X_GM_EXT_1   (1 << 18)

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

Definition at line 141 of file private.h.

IMAP_CAP_ALL

#define IMAP_CAP_ALL   ((1 << 19) - 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 64 of file private.h.

ImapCmdFlags

typedef uint8_t ImapCmdFlags

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

Definition at line 72 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 121 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 82 of file private.h.

{
  IMAP_EXEC_SUCCESS = 0, 
  IMAP_EXEC_ERROR,       
  IMAP_EXEC_FATAL,       
};

ImapFlags

enum ImapFlags

IMAP server responses.

Enumerator
IMAP_FATAL	Unrecoverable error occurred.
IMAP_BYE	Logged out from server.

Definition at line 95 of file private.h.

{
  IMAP_FATAL = 1, 
  IMAP_BYE,       
};

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 104 of file private.h.

{
  /* States */
  IMAP_DISCONNECTED = 0, 
  IMAP_CONNECTED,        
  IMAP_AUTHENTICATED,    
  IMAP_SELECTED,         

  /* and pseudo-states */
  IMAP_IDLE, 
};

Function Documentation

imap_create_mailbox()

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

Create a new mailbox.

Parameters

adata	Imap Account data
mailbox	Mailbox to create

Return values

0	Success
-1	Failure

Definition at line 448 of file imap.c.

{
  char buf[2048], mbox[1024];

  imap_munge_mbox_name(adata->unicode, mbox, sizeof(mbox), mailbox);
  snprintf(buf, sizeof(buf), "CREATE %s", mbox);

  if (imap_exec(adata, buf, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
  {
    mutt_error(_("CREATE failed: %s"), imap_cmd_trailer(adata));
    return -1;
  }

  return 0;
}

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

adata	Imap Account data
oldname	Existing mailbox
newname	New name for mailbox

Return values

0	Success
-1	Failure

Definition at line 489 of file imap.c.

{
  char oldmbox[1024];
  char newmbox[1024];
  int rc = 0;

  imap_munge_mbox_name(adata->unicode, oldmbox, sizeof(oldmbox), oldname);
  imap_munge_mbox_name(adata->unicode, newmbox, sizeof(newmbox), newname);

  struct Buffer *buf = mutt_buffer_pool_get();
  mutt_buffer_printf(buf, "RENAME %s %s", oldmbox, newmbox);

  if (imap_exec(adata, mutt_buffer_string(buf), IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
    rc = -1;

  mutt_buffer_pool_release(&buf);

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_exec_msgset()

int imap_exec_msgset	(	struct Mailbox *	m,
		const char *	pre,
		const char *	post,
		enum MessageType	flag,
		bool	changed,
		bool	invert
	)

Prepare commands for all messages matching conditions.

Parameters

m	Selected Imap Mailbox
pre	prefix commands
post	postfix commands
flag	flag type on which to filter, e.g. MUTT_REPLIED
changed	include only changed messages in message set
invert	invert sense of flag, eg MUTT_READ matches unread messages

Return values

num	Matched messages
-1	Failure

pre/post: commands are of the form "%s %s %s %s", tag, pre, message set, post Prepares commands for all messages matching conditions (must be flushed with imap_exec)

Definition at line 927 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  if (!adata || (adata->mailbox != m))
    return -1;

  struct Email **emails = NULL;
  int pos;
  int rc;
  int count = 0;

  struct Buffer cmd = mutt_buffer_make(0);

  /* We make a copy of the headers just in case resorting doesn't give
   exactly the original order (duplicate messages?), because other parts of
   the ctx are tied to the header order. This may be overkill. */
  const short c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  if (c_sort != SORT_ORDER)
  {
    emails = m->emails;
    // We overcommit here, just in case new mail arrives whilst we're sync-ing
    m->emails = mutt_mem_malloc(m->email_max * sizeof(struct Email *));
    memcpy(m->emails, emails, m->email_max * sizeof(struct Email *));

    cs_subset_str_native_set(NeoMutt->sub, "sort", SORT_ORDER, NULL);
    qsort(m->emails, m->msg_count, sizeof(struct Email *), compare_uid);
  }

  pos = 0;

  do
  {
    mutt_buffer_reset(&cmd);
    mutt_buffer_add_printf(&cmd, "%s ", pre);
    rc = make_msg_set(m, &cmd, flag, changed, invert, &pos);
    if (rc > 0)
    {
      mutt_buffer_add_printf(&cmd, " %s", post);
      if (imap_exec(adata, cmd.data, IMAP_CMD_QUEUE) != IMAP_EXEC_SUCCESS)
      {
        rc = -1;
        goto out;
      }
      count += rc;
    }
  } while (rc > 0);

  rc = count;

out:
  mutt_buffer_dealloc(&cmd);
  if (c_sort != SORT_ORDER)
  {
    cs_subset_str_native_set(NeoMutt->sub, "sort", c_sort, NULL);
    FREE(&m->emails);
    m->emails = emails;
  }

  return rc;
}

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

adata

Imap Account data

Return values

0	Success
-1	Failure

Definition at line 745 of file imap.c.

{
  if (mutt_socket_open(adata->conn) < 0)
    return -1;

  adata->state = IMAP_CONNECTED;

  if (imap_cmd_step(adata) != IMAP_RES_OK)
  {
    imap_close_connection(adata);
    return -1;
  }

  if (mutt_istr_startswith(adata->buf, "* OK"))
  {
    if (!mutt_istr_startswith(adata->buf, "* OK [CAPABILITY") && check_capabilities(adata))
    {
      goto bail;
    }
#ifdef USE_SSL
    /* Attempt STARTTLS if available and desired. */
    const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
    if ((adata->conn->ssf == 0) &&
        (c_ssl_force_tls || (adata->capabilities & IMAP_CAP_STARTTLS)))
    {
      enum QuadOption ans;

      const enum QuadOption c_ssl_starttls =
          cs_subset_quad(NeoMutt->sub, "ssl_starttls");
      if (c_ssl_force_tls)
        ans = MUTT_YES;
      else if ((ans = query_quadoption(c_ssl_starttls,
                                       _("Secure connection with TLS?"))) == MUTT_ABORT)
      {
        goto bail;
      }
      if (ans == MUTT_YES)
      {
        enum ImapExecResult rc = imap_exec(adata, "STARTTLS", IMAP_CMD_SINGLE);
        // Clear any data after the STARTTLS acknowledgement
        mutt_socket_empty(adata->conn);

        if (rc == IMAP_EXEC_FATAL)
          goto bail;
        if (rc != IMAP_EXEC_ERROR)
        {
          if (mutt_ssl_starttls(adata->conn))
          {
            mutt_error(_("Could not negotiate TLS connection"));
            goto bail;
          }
          else
          {
            /* RFC2595 demands we recheck CAPABILITY after TLS completes. */
            if (imap_exec(adata, "CAPABILITY", IMAP_CMD_NO_FLAGS))
              goto bail;
          }
        }
      }
    }

    if (c_ssl_force_tls && (adata->conn->ssf == 0))
    {
      mutt_error(_("Encrypted connection unavailable"));
      goto bail;
    }
#endif
  }
  else if (mutt_istr_startswith(adata->buf, "* PREAUTH"))
  {
#ifdef USE_SSL
    /* Unless using a secure $tunnel, an unencrypted PREAUTH response may be a
     * MITM attack.  The only way to stop "STARTTLS" MITM attacks is via
     * $ssl_force_tls: an attacker can easily spoof "* OK" and strip the
     * STARTTLS capability.  So consult $ssl_force_tls, not $ssl_starttls, to
     * decide whether to abort. Note that if using $tunnel and
     * $tunnel_is_secure, adata->conn->ssf will be set to 1. */
    const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
    if ((adata->conn->ssf == 0) && c_ssl_force_tls)
    {
      mutt_error(_("Encrypted connection unavailable"));
      goto bail;
    }
#endif

    adata->state = IMAP_AUTHENTICATED;
    if (check_capabilities(adata) != 0)
      goto bail;
    FREE(&adata->capstr);
  }
  else
  {
    imap_error("imap_open_connection()", adata->buf);
    goto bail;
  }

  return 0;

bail:
  imap_close_connection(adata);
  FREE(&adata->capstr);
  return -1;
}

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

adata

Imap Account data

Definition at line 853 of file imap.c.

{
  if (adata->state != IMAP_DISCONNECTED)
  {
    mutt_socket_close(adata->conn);
    adata->state = IMAP_DISCONNECTED;
  }
  adata->seqno = 0;
  adata->nextcmd = 0;
  adata->lastcmd = 0;
  adata->status = 0;
  memset(adata->cmds, 0, sizeof(struct ImapCommand) * adata->cmdslots);
}

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 *	pbar
	)

Read bytes bytes from server into file.

Parameters

fp	File handle for email file
adata	Imap Account data
bytes	Number of bytes to read
pbar	Progress bar

Return values

0	Success
-1	Failure

Not explicitly buffered, relies on FILE buffering.

Note

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

Definition at line 600 of file imap.c.

{
  char c;
  bool r = false;
  struct Buffer buf = { 0 }; // Do not allocate, maybe it won't be used

  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  if (c_debug_level >= IMAP_LOG_LTRL)
    mutt_buffer_alloc(&buf, bytes + 10);

  mutt_debug(LL_DEBUG2, "reading %ld bytes\n", bytes);

  for (unsigned long pos = 0; pos < bytes; pos++)
  {
    if (mutt_socket_readchar(adata->conn, &c) != 1)
    {
      mutt_debug(LL_DEBUG1, "error during read, %ld bytes read\n", pos);
      adata->status = IMAP_FATAL;

      mutt_buffer_dealloc(&buf);
      return -1;
    }

    if (r && (c != '\n'))
      fputc('\r', fp);

    if (c == '\r')
    {
      r = true;
      continue;
    }
    else
      r = false;

    fputc(c, fp);

    if (pbar && !(pos % 1024))
      progress_update(pbar, pos, -1);
    if (c_debug_level >= IMAP_LOG_LTRL)
      mutt_buffer_addch(&buf, c);
  }

  if (c_debug_level >= IMAP_LOG_LTRL)
  {
    mutt_debug(IMAP_LOG_LTRL, "\n%s", buf.data);
    mutt_buffer_dealloc(&buf);
  }
  return 0;
}

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

)

Purge messages from the server.

Parameters

m

Mailbox

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 676 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || !mdata)
    return;

  struct Email *e = NULL;

#ifdef USE_HCACHE
  imap_hcache_open(adata, mdata);
#endif

  for (int i = 0; i < m->msg_count; i++)
  {
    e = m->emails[i];
    if (!e)
      break;

    if (e->index == INT_MAX)
    {
      mutt_debug(LL_DEBUG2, "Expunging message UID %u\n", imap_edata_get(e)->uid);

      e->deleted = true;

      imap_cache_del(m, e);
#ifdef USE_HCACHE
      imap_hcache_del(mdata, imap_edata_get(e)->uid);
#endif

      mutt_hash_int_delete(mdata->uid_hash, imap_edata_get(e)->uid, e);

      imap_edata_free((void **) &e->edata);
    }
    else
    {
      /* NeoMutt has several places where it turns off e->active as a
       * hack.  For example to avoid FLAG updates, or to exclude from
       * imap_exec_msgset.
       *
       * Unfortunately, when a reopen is allowed and the IMAP_EXPUNGE_PENDING
       * flag becomes set (e.g. a flag update to a modified header),
       * this function will be called by imap_cmd_finish().
       *
       * The ctx_update_tables() will free and remove these "inactive" headers,
       * despite that an EXPUNGE was not received for them.
       * This would result in memory leaks and segfaults due to dangling
       * pointers in the msn_index and uid_hash.
       *
       * So this is another hack to work around the hacks.  We don't want to
       * remove the messages, so make sure active is on.  */
      e->active = true;
    }
  }

#ifdef USE_HCACHE
  imap_hcache_close(mdata);
#endif

  mailbox_changed(m, NT_MAILBOX_UPDATE);
  mailbox_changed(m, NT_MAILBOX_RESORT);
}

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

adata

Imap Account data

Return values

0	Success
-1	Failure

Ensure ImapAccountData is connected and logged into the imap server.

Definition at line 1849 of file imap.c.

{
  if (!adata)
    return -1;

  if (adata->state == IMAP_DISCONNECTED)
  {
    mutt_buffer_reset(&adata->cmdbuf); // purge outstanding queued commands
    imap_open_connection(adata);
  }
  if (adata->state == IMAP_CONNECTED)
  {
    if (imap_authenticate(adata) == IMAP_AUTH_SUCCESS)
    {
      adata->state = IMAP_AUTHENTICATED;
      FREE(&adata->capstr);
      if (adata->conn->ssf != 0)
      {
        mutt_debug(LL_DEBUG2, "Communication encrypted at %d bits\n",
                   adata->conn->ssf);
      }
    }
    else
      mutt_account_unsetpass(&adata->conn->account);
  }
  if (adata->state == IMAP_AUTHENTICATED)
  {
    /* capabilities may have changed */
    imap_exec(adata, "CAPABILITY", IMAP_CMD_PASS);

#ifdef USE_ZLIB
    /* RFC4978 */
    const bool c_imap_deflate = cs_subset_bool(NeoMutt->sub, "imap_deflate");
    if ((adata->capabilities & IMAP_CAP_COMPRESS) && c_imap_deflate &&
        (imap_exec(adata, "COMPRESS DEFLATE", IMAP_CMD_PASS) == IMAP_EXEC_SUCCESS))
    {
      mutt_debug(LL_DEBUG2, "IMAP compression is enabled on connection to %s\n",
                 adata->conn->account.host);
      mutt_zstrm_wrap_conn(adata->conn);
    }
#endif

    /* enable RFC6855, if the server supports that */
    const bool c_imap_rfc5161 = cs_subset_bool(NeoMutt->sub, "imap_rfc5161");
    if (c_imap_rfc5161 && (adata->capabilities & IMAP_CAP_ENABLE))
      imap_exec(adata, "ENABLE UTF8=ACCEPT", IMAP_CMD_QUEUE);

    /* enable QRESYNC.  Advertising QRESYNC also means CONDSTORE
     * is supported (even if not advertised), so flip that bit. */
    if (adata->capabilities & IMAP_CAP_QRESYNC)
    {
      adata->capabilities |= IMAP_CAP_CONDSTORE;
      const bool c_imap_qresync = cs_subset_bool(NeoMutt->sub, "imap_qresync");
      if (c_imap_rfc5161 && c_imap_qresync)
        imap_exec(adata, "ENABLE QRESYNC", IMAP_CMD_QUEUE);
    }

    /* get root delimiter, '/' as default */
    adata->delim = '/';
    imap_exec(adata, "LIST \"\" \"\"", IMAP_CMD_QUEUE);

    /* we may need the root delimiter before we open a mailbox */
    imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS);

    /* select the mailbox that used to be open before disconnect */
    if (adata->mailbox)
    {
      imap_mbox_select(adata->mailbox);
    }
  }

  if (adata->state < IMAP_AUTHENTICATED)
    return -1;

  return 0;
}

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]	m	Mailbox
[in]	e	Email
[in]	cmd	Buffer for the command string
[out]	err_continue	Did the user force a continue?

Return values

0	Success
-1	Failure

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 1004 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  if (!adata || (adata->mailbox != m))
    return -1;

  char flags[1024];
  char *tags = NULL;
  char uid[11];

  if (!compare_flags_for_copy(e))
  {
    if (e->deleted == imap_edata_get(e)->deleted)
      e->changed = false;
    return 0;
  }

  snprintf(uid, sizeof(uid), "%u", imap_edata_get(e)->uid);
  mutt_buffer_reset(cmd);
  mutt_buffer_addstr(cmd, "UID STORE ");
  mutt_buffer_addstr(cmd, uid);

  flags[0] = '\0';

  set_flag(m, MUTT_ACL_SEEN, e->read, "\\Seen ", flags, sizeof(flags));
  set_flag(m, MUTT_ACL_WRITE, e->old, "Old ", flags, sizeof(flags));
  set_flag(m, MUTT_ACL_WRITE, e->flagged, "\\Flagged ", flags, sizeof(flags));
  set_flag(m, MUTT_ACL_WRITE, e->replied, "\\Answered ", flags, sizeof(flags));
  set_flag(m, MUTT_ACL_DELETE, imap_edata_get(e)->deleted, "\\Deleted ", flags,
           sizeof(flags));

  if (m->rights & MUTT_ACL_WRITE)
  {
    /* restore system flags */
    if (imap_edata_get(e)->flags_system)
      mutt_str_cat(flags, sizeof(flags), imap_edata_get(e)->flags_system);
    /* set custom flags */
    tags = driver_tags_get_with_hidden(&e->tags);
    if (tags)
    {
      mutt_str_cat(flags, sizeof(flags), tags);
      FREE(&tags);
    }
  }

  mutt_str_remove_trailing_ws(flags);

  /* UW-IMAP is OK with null flags, Cyrus isn't. The only solution is to
   * explicitly revoke all system flags (if we have permission) */
  if (*flags == '\0')
  {
    set_flag(m, MUTT_ACL_SEEN, true, "\\Seen ", flags, sizeof(flags));
    set_flag(m, MUTT_ACL_WRITE, true, "Old ", flags, sizeof(flags));
    set_flag(m, MUTT_ACL_WRITE, true, "\\Flagged ", flags, sizeof(flags));
    set_flag(m, MUTT_ACL_WRITE, true, "\\Answered ", flags, sizeof(flags));
    set_flag(m, MUTT_ACL_DELETE, !imap_edata_get(e)->deleted, "\\Deleted ",
             flags, sizeof(flags));

    /* erase custom flags */
    if ((m->rights & MUTT_ACL_WRITE) && imap_edata_get(e)->flags_remote)
      mutt_str_cat(flags, sizeof(flags), imap_edata_get(e)->flags_remote);

    mutt_str_remove_trailing_ws(flags);

    mutt_buffer_addstr(cmd, " -FLAGS.SILENT (");
  }
  else
    mutt_buffer_addstr(cmd, " FLAGS.SILENT (");

  mutt_buffer_addstr(cmd, flags);
  mutt_buffer_addstr(cmd, ")");

  /* after all this it's still possible to have no flags, if you
   * have no ACL rights */
  if (*flags && (imap_exec(adata, cmd->data, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS) &&
      err_continue && (*err_continue != MUTT_YES))
  {
    *err_continue = imap_continue("imap_sync_message: STORE failed", adata->buf);
    if (*err_continue != MUTT_YES)
      return -1;
  }

  /* server have now the updated flags */
  FREE(&imap_edata_get(e)->flags_remote);
  imap_edata_get(e)->flags_remote = driver_tags_get_with_hidden(&e->tags);

  if (e->deleted == imap_edata_get(e)->deleted)
    e->changed = false;

  return 0;
}

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_list	List of server flags
flag	Flag to find

Return values

true	Flag 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 878 of file imap.c.

{
  if (STAILQ_EMPTY(flag_list))
    return false;

  const size_t flaglen = mutt_str_len(flag);
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, flag_list, entries)
  {
    const size_t nplen = strlen(np->data);
    if ((flaglen >= nplen) && ((flag[nplen] == '\0') || (flag[nplen] == ' ')) &&
        mutt_istrn_equal(np->data, flag, nplen))
    {
      return true;
    }

    if (mutt_str_equal(np->data, "\\*"))
      return true;
  }

  return false;
}

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

path	Path to search for
adata	Imap Account data
mdata	Imap Mailbox data

Return values

0	Success
-1	Failure

Definition at line 72 of file util.c.

{
  struct ConnAccount cac = { { 0 } };
  struct ImapAccountData *tmp_adata = NULL;
  char tmp[1024];

  if (imap_parse_path(path, &cac, tmp, sizeof(tmp)) < 0)
    return -1;

  struct Account *np = NULL;
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    if (np->type != MUTT_IMAP)
      continue;

    tmp_adata = np->adata;
    if (!tmp_adata)
      continue;
    if (imap_account_match(&tmp_adata->conn->account, &cac))
    {
      *mdata = imap_mdata_new(tmp_adata, tmp);
      *adata = tmp_adata;
      return 0;
    }
  }
  mutt_debug(LL_DEBUG3, "no ImapAccountData found\n");
  return -1;
}

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

adata

Imap Account data

Return values

num	Result, e.g. IMAP_AUTH_SUCCESS

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

Definition at line 107 of file auth.c.

{
  int rc = IMAP_AUTH_FAILURE;

  const struct Slist *c_imap_authenticators =
      cs_subset_slist(NeoMutt->sub, "imap_authenticators");
  if (c_imap_authenticators && (c_imap_authenticators->count > 0))
  {
    mutt_debug(LL_DEBUG2, "Trying user-defined imap_authenticators\n");

    /* Try user-specified list of authentication methods */
    struct ListNode *np = NULL;
    STAILQ_FOREACH(np, &c_imap_authenticators->head, entries)
    {
      mutt_debug(LL_DEBUG2, "Trying method %s\n", np->data);

      for (size_t i = 0; i < mutt_array_size(imap_authenticators); i++)
      {
        const struct ImapAuth *auth = &imap_authenticators[i];
        if (!auth->method || mutt_istr_equal(auth->method, np->data))
        {
          rc = auth->authenticate(adata, np->data);
          if (rc == IMAP_AUTH_SUCCESS)
          {
            return rc;
          }
        }
      }
    }
  }
  else
  {
    /* Fall back to default: any authenticator */
    mutt_debug(LL_DEBUG2, "Trying pre-defined imap_authenticators\n");

    for (size_t i = 0; i < mutt_array_size(imap_authenticators); i++)
    {
      rc = imap_authenticators[i].authenticate(adata, NULL);
      if (rc == IMAP_AUTH_SUCCESS)
        return rc;
    }
  }

  mutt_error(_("No authenticators available or wrong credentials"));
  return rc;
}

Here is the call graph for this function:

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

adata	Imap Account data
cmdstr	Command string to send

Return values

0	Success
<0	Failure, e.g. IMAP_RES_BAD

If cmdstr is NULL, sends queued commands.

Definition at line 1065 of file command.c.

{
  return cmd_start(adata, cmdstr, IMAP_CMD_NO_FLAGS);
}

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

adata

Imap Account data

Return values

0	Success
<0	Failure, 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 1079 of file command.c.

{
  if (!adata)
    return -1;

  size_t len = 0;
  int c;
  int rc;
  int stillrunning = 0;
  struct ImapCommand *cmd = NULL;

  if (adata->status == IMAP_FATAL)
  {
    cmd_handle_fatal(adata);
    return IMAP_RES_BAD;
  }

  /* read into buffer, expanding buffer as necessary until we have a full
   * line */
  do
  {
    if (len == adata->blen)
    {
      mutt_mem_realloc(&adata->buf, adata->blen + IMAP_CMD_BUFSIZE);
      adata->blen = adata->blen + IMAP_CMD_BUFSIZE;
      mutt_debug(LL_DEBUG3, "grew buffer to %lu bytes\n", adata->blen);
    }

    /* back up over '\0' */
    if (len)
      len--;
    c = mutt_socket_readln_d(adata->buf + len, adata->blen - len, adata->conn, MUTT_SOCK_LOG_FULL);
    if (c <= 0)
    {
      mutt_debug(LL_DEBUG1, "Error reading server response\n");
      cmd_handle_fatal(adata);
      return IMAP_RES_BAD;
    }

    len += c;
  }
  /* if we've read all the way to the end of the buffer, we haven't read a
   * full line (mutt_socket_readln strips the \r, so we always have at least
   * one character free when we've read a full line) */
  while (len == adata->blen);

  /* don't let one large string make cmd->buf hog memory forever */
  if ((adata->blen > IMAP_CMD_BUFSIZE) && (len <= IMAP_CMD_BUFSIZE))
  {
    mutt_mem_realloc(&adata->buf, IMAP_CMD_BUFSIZE);
    adata->blen = IMAP_CMD_BUFSIZE;
    mutt_debug(LL_DEBUG3, "shrank buffer to %lu bytes\n", adata->blen);
  }

  adata->lastread = mutt_date_epoch();

  /* handle untagged messages. The caller still gets its shot afterwards. */
  if ((mutt_str_startswith(adata->buf, "* ") ||
       mutt_str_startswith(imap_next_word(adata->buf), "OK [")) &&
      cmd_handle_untagged(adata))
  {
    return IMAP_RES_BAD;
  }

  /* server demands a continuation response from us */
  if (adata->buf[0] == '+')
    return IMAP_RES_RESPOND;

  /* Look for tagged command completions.
   *
   * Some response handlers can end up recursively calling
   * imap_cmd_step() and end up handling all tagged command
   * completions.
   * (e.g. FETCH->set_flag->set_header_color->~h pattern match.)
   *
   * Other callers don't even create an adata->cmds entry.
   *
   * For both these cases, we default to returning OK */
  rc = IMAP_RES_OK;
  c = adata->lastcmd;
  do
  {
    cmd = &adata->cmds[c];
    if (cmd->state == IMAP_RES_NEW)
    {
      if (mutt_str_startswith(adata->buf, cmd->seq))
      {
        if (!stillrunning)
        {
          /* first command in queue has finished - move queue pointer up */
          adata->lastcmd = (adata->lastcmd + 1) % adata->cmdslots;
        }
        cmd->state = cmd_status(adata->buf);
        rc = cmd->state;
        if (cmd->state == IMAP_RES_NO || cmd->state == IMAP_RES_BAD)
        {
          mutt_message(_("IMAP command failed: %s"), adata->buf);
        }
      }
      else
        stillrunning++;
    }

    c = (c + 1) % adata->cmdslots;
  } while (c != adata->nextcmd);

  if (stillrunning)
    rc = IMAP_RES_CONTINUE;
  else
  {
    mutt_debug(LL_DEBUG3, "IMAP queue drained\n");
    imap_cmd_finish(adata);
  }

  return rc;
}

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

adata

Imap 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 1316 of file command.c.

{
  if (!adata)
    return;

  if (adata->status == IMAP_FATAL)
  {
    adata->closing = false;
    cmd_handle_fatal(adata);
    return;
  }

  if (!(adata->state >= IMAP_SELECTED) || (adata->mailbox && adata->closing))
  {
    adata->closing = false;
    return;
  }

  adata->closing = false;

  struct ImapMboxData *mdata = imap_mdata_get(adata->mailbox);

  if (mdata && mdata->reopen & IMAP_REOPEN_ALLOW)
  {
    // First remove expunged emails from the msn_index
    if (mdata->reopen & IMAP_EXPUNGE_PENDING)
    {
      mutt_debug(LL_DEBUG2, "Expunging mailbox\n");
      imap_expunge_mailbox(adata->mailbox);
      /* Detect whether we've gotten unexpected EXPUNGE messages */
      if (!(mdata->reopen & IMAP_EXPUNGE_EXPECTED))
        mdata->check_status |= IMAP_EXPUNGE_PENDING;
      mdata->reopen &= ~(IMAP_EXPUNGE_PENDING | IMAP_EXPUNGE_EXPECTED);
    }

    // Then add new emails to it
    if (mdata->reopen & IMAP_NEWMAIL_PENDING)
    {
      const size_t max_msn = imap_msn_highest(&mdata->msn);
      if (mdata->new_mail_count > max_msn)
      {
        if (!(mdata->reopen & IMAP_EXPUNGE_PENDING))
          mdata->check_status |= IMAP_NEWMAIL_PENDING;

        mutt_debug(LL_DEBUG2, "Fetching new mails from %d to %d\n", max_msn + 1,
                   mdata->new_mail_count);
        imap_read_headers(adata->mailbox, max_msn + 1, mdata->new_mail_count, false);
      }
    }

    // And to finish inform about MUTT_REOPEN if needed
    if (mdata->reopen & IMAP_EXPUNGE_PENDING && !(mdata->reopen & IMAP_EXPUNGE_EXPECTED))
      mdata->check_status |= IMAP_EXPUNGE_PENDING;

    if (mdata->reopen & IMAP_EXPUNGE_PENDING)
      mdata->reopen &= ~(IMAP_EXPUNGE_PENDING | IMAP_EXPUNGE_EXPECTED);
  }

  adata->status = 0;
}

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

s	IMAP command status

Return values

1	Command result was OK
0	NO or BAD

Definition at line 1202 of file command.c.

{
  return cmd_status(s) == IMAP_RES_OK;
}

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

adata

Imap Account data

Return values

ptr	Extra command information (pointer into adata->buf)
""	Error (static string)

Definition at line 1213 of file command.c.

{
  static const char *notrailer = "";
  const char *s = adata->buf;

  if (!s)
  {
    mutt_debug(LL_DEBUG2, "not a tagged response\n");
    return notrailer;
  }

  s = imap_next_word((char *) s);
  if (!s || (!mutt_istr_startswith(s, "OK") && !mutt_istr_startswith(s, "NO") &&
             !mutt_istr_startswith(s, "BAD")))
  {
    mutt_debug(LL_DEBUG2, "not a command completion: %s\n", adata->buf);
    return notrailer;
  }

  s = imap_next_word((char *) s);
  if (!s)
    return notrailer;

  return s;
}

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

adata	Imap Account data
cmdstr	Command to execute
flags	Flags, see ImapCmdFlags

Return values

IMAP_EXEC_SUCCESS	Command successful or queued
IMAP_EXEC_ERROR	Command returned an error
IMAP_EXEC_FATAL	Imap connection failure

Also, handle untagged responses.

Definition at line 1250 of file command.c.

{
  int rc;

  if (flags & IMAP_CMD_SINGLE)
  {
    // Process any existing commands
    if (adata->nextcmd != adata->lastcmd)
      imap_exec(adata, NULL, IMAP_CMD_POLL);
  }

  rc = cmd_start(adata, cmdstr, flags);
  if (rc < 0)
  {
    cmd_handle_fatal(adata);
    return IMAP_EXEC_FATAL;
  }

  if (flags & IMAP_CMD_QUEUE)
    return IMAP_EXEC_SUCCESS;

  const short c_imap_poll_timeout =
      cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
  if ((flags & IMAP_CMD_POLL) && (c_imap_poll_timeout > 0) &&
      ((mutt_socket_poll(adata->conn, c_imap_poll_timeout)) == 0))
  {
    mutt_error(_("Connection to %s timed out"), adata->conn->account.host);
    cmd_handle_fatal(adata);
    return IMAP_EXEC_FATAL;
  }

  /* Allow interruptions, particularly useful if there are network problems. */
  mutt_sig_allow_interrupt(true);
  do
  {
    rc = imap_cmd_step(adata);
    // The queue is empty, so the single command has been processed
    if ((flags & IMAP_CMD_SINGLE) && (adata->nextcmd == adata->lastcmd))
      break;
  } while (rc == IMAP_RES_CONTINUE);
  mutt_sig_allow_interrupt(false);

  if (rc == IMAP_RES_NO)
    return IMAP_EXEC_ERROR;
  if (rc != IMAP_RES_OK)
  {
    if (adata->status != IMAP_FATAL)
      return IMAP_EXEC_ERROR;

    mutt_debug(LL_DEBUG1, "command failed: %s\n", adata->buf);
    return IMAP_EXEC_FATAL;
  }

  return IMAP_EXEC_SUCCESS;
}

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

adata

Imap Account data

Return values

0	Success
<0	Failure, e.g. IMAP_RES_BAD

Definition at line 1383 of file command.c.

{
  int rc;

  if (cmd_start(adata, "IDLE", IMAP_CMD_POLL) < 0)
  {
    cmd_handle_fatal(adata);
    return -1;
  }

  const short c_imap_poll_timeout =
      cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
  if ((c_imap_poll_timeout > 0) &&
      ((mutt_socket_poll(adata->conn, c_imap_poll_timeout)) == 0))
  {
    mutt_error(_("Connection to %s timed out"), adata->conn->account.host);
    cmd_handle_fatal(adata);
    return -1;
  }

  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);

  if (rc == IMAP_RES_RESPOND)
  {
    /* successfully entered IDLE state */
    adata->state = IMAP_IDLE;
    /* queue automatic exit when next command is issued */
    mutt_buffer_addstr(&adata->cmdbuf, "DONE\r\n");
    rc = IMAP_RES_OK;
  }
  if (rc != IMAP_RES_OK)
  {
    mutt_debug(LL_DEBUG1, "error starting IDLE\n");
    return -1;
  }

  return 0;
}

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

m	Imap Selected Mailbox
msn_begin	First Message Sequence Number
msn_end	Last Message Sequence Number
initial_download	true, if this is the first opening of the mailbox

Return values

num	Last MSN
-1	Failure

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 1299 of file message.c.

{
  int oldmsgcount;
  unsigned int maxuid = 0;
  int retval = -1;
  bool evalhc = false;

#ifdef USE_HCACHE
  void *uidvalidity = NULL;
  void *puid_next = NULL;
  unsigned int uid_next = 0;
  bool has_condstore = false;
  bool has_qresync = false;
  bool eval_condstore = false;
  bool eval_qresync = false;
  unsigned long long *pmodseq = NULL;
  unsigned long long hc_modseq = 0;
  char *uid_seqset = NULL;
#endif /* USE_HCACHE */

  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || (adata->mailbox != m))
    return -1;

#ifdef USE_HCACHE
retry:
#endif /* USE_HCACHE */

  /* make sure context has room to hold the mailbox */
  while (msn_end > m->email_max)
    mx_alloc_memory(m);
  imap_msn_reserve(&mdata->msn, msn_end);
  imap_alloc_uid_hash(adata, msn_end);

  oldmsgcount = m->msg_count;
  mdata->reopen &= ~(IMAP_REOPEN_ALLOW | IMAP_NEWMAIL_PENDING);
  mdata->new_mail_count = 0;

#ifdef USE_HCACHE
  imap_hcache_open(adata, mdata);

  if (mdata->hcache && initial_download)
  {
    size_t dlen = 0;
    uidvalidity = mutt_hcache_fetch_raw(mdata->hcache, "/UIDVALIDITY", 12, &dlen);
    puid_next = mutt_hcache_fetch_raw(mdata->hcache, "/UIDNEXT", 8, &dlen);
    if (puid_next)
    {
      uid_next = *(unsigned int *) puid_next;
      mutt_hcache_free_raw(mdata->hcache, &puid_next);
    }

    if (mdata->modseq)
    {
      const bool c_imap_condstore =
          cs_subset_bool(NeoMutt->sub, "imap_condstore");
      if ((adata->capabilities & IMAP_CAP_CONDSTORE) && c_imap_condstore)
        has_condstore = true;

      /* If IMAP_CAP_QRESYNC and ImapQResync then NeoMutt sends ENABLE QRESYNC.
       * If we receive an ENABLED response back, then adata->qresync is set.  */
      if (adata->qresync)
        has_qresync = true;
    }

    if (uidvalidity && uid_next && (*(uint32_t *) uidvalidity == mdata->uidvalidity))
    {
      size_t dlen2 = 0;
      evalhc = true;
      pmodseq = mutt_hcache_fetch_raw(mdata->hcache, "/MODSEQ", 7, &dlen2);
      if (pmodseq)
      {
        hc_modseq = *pmodseq;
        mutt_hcache_free_raw(mdata->hcache, (void **) &pmodseq);
      }
      if (hc_modseq)
      {
        if (has_qresync)
        {
          uid_seqset = imap_hcache_get_uid_seqset(mdata);
          if (uid_seqset)
            eval_qresync = true;
        }

        if (!eval_qresync && has_condstore)
          eval_condstore = true;
      }
    }
    mutt_hcache_free_raw(mdata->hcache, &uidvalidity);
  }
  if (evalhc)
  {
    if (eval_qresync)
    {
      if (read_headers_qresync_eval_cache(adata, uid_seqset) < 0)
        goto bail;
    }
    else
    {
      if (read_headers_normal_eval_cache(adata, msn_end, uid_next, has_condstore || has_qresync,
                                         eval_condstore) < 0)
        goto bail;
    }

    if ((eval_condstore || eval_qresync) && (hc_modseq != mdata->modseq))
    {
      if (read_headers_condstore_qresync_updates(adata, msn_end, uid_next,
                                                 hc_modseq, eval_qresync) < 0)
      {
        goto bail;
      }
    }

    /* Look for the first empty MSN and start there */
    while (msn_begin <= msn_end)
    {
      if (!imap_msn_get(&mdata->msn, msn_begin - 1))
        break;
      msn_begin++;
    }
  }
#endif /* USE_HCACHE */

  if (read_headers_fetch_new(m, msn_begin, msn_end, evalhc, &maxuid, initial_download) < 0)
    goto bail;

#ifdef USE_HCACHE
  if (eval_qresync && initial_download)
  {
    if (imap_verify_qresync(m) != 0)
    {
      eval_qresync = false;
      eval_condstore = false;
      evalhc = false;
      hc_modseq = 0;
      maxuid = 0;
      FREE(&uid_seqset);
      uidvalidity = NULL;
      uid_next = 0;

      goto retry;
    }
  }
#endif /* USE_HCACHE */

  if (maxuid && (mdata->uid_next < maxuid + 1))
    mdata->uid_next = maxuid + 1;

#ifdef USE_HCACHE
  mutt_hcache_store_raw(mdata->hcache, "/UIDVALIDITY", 12, &mdata->uidvalidity,
                        sizeof(mdata->uidvalidity));
  if (maxuid && (mdata->uid_next < maxuid + 1))
  {
    mutt_debug(LL_DEBUG2, "Overriding UIDNEXT: %u -> %u\n", mdata->uid_next, maxuid + 1);
    mdata->uid_next = maxuid + 1;
  }
  if (mdata->uid_next > 1)
  {
    mutt_hcache_store_raw(mdata->hcache, "/UIDNEXT", 8, &mdata->uid_next,
                          sizeof(mdata->uid_next));
  }

  /* We currently only sync CONDSTORE and QRESYNC on the initial download.
   * To do it more often, we'll need to deal with flag updates combined with
   * unsync'ed local flag changes.  We'll also need to properly sync flags to
   * the header cache on close.  I'm not sure it's worth the added complexity.  */
  if (initial_download)
  {
    if (has_condstore || has_qresync)
    {
      mutt_hcache_store_raw(mdata->hcache, "/MODSEQ", 7, &mdata->modseq,
                            sizeof(mdata->modseq));
    }
    else
      mutt_hcache_delete_record(mdata->hcache, "/MODSEQ", 7);

    if (has_qresync)
      imap_hcache_store_uid_seqset(mdata);
    else
      imap_hcache_clear_uid_seqset(mdata);
  }
#endif /* USE_HCACHE */

  if (m->msg_count > oldmsgcount)
  {
    /* TODO: it's not clear to me why we are calling mx_alloc_memory
     *       yet again. */
    mx_alloc_memory(m);
  }

  mdata->reopen |= IMAP_REOPEN_ALLOW;

  retval = msn_end;

bail:
#ifdef USE_HCACHE
  imap_hcache_close(mdata);
  FREE(&uid_seqset);
#endif /* USE_HCACHE */

  return retval;
}

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]	m	Imap Selected Mailbox
[in]	e	Email
[in]	s	Command string
[out]	server_changes	Set to true if the flags have changed

Return values

ptr	The end of flags string
NULL	Failure

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 1870 of file message.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  if (!adata || (adata->mailbox != m))
    return NULL;

  struct ImapHeader newh = { 0 };
  struct ImapEmailData old_edata = { 0 };
  int local_changes = e->changed;

  struct ImapEmailData *edata = e->edata;
  newh.edata = edata;

  mutt_debug(LL_DEBUG2, "parsing FLAGS\n");
  s = msg_parse_flags(&newh, s);
  if (!s)
    return NULL;

  /* Update tags system */
  /* We take a copy of the tags so we can split the string */
  char *tags_copy = mutt_str_dup(edata->flags_remote);
  driver_tags_replace(&e->tags, tags_copy);
  FREE(&tags_copy);

  /* YAUH (yet another ugly hack): temporarily set context to
   * read-write even if it's read-only, so *server* updates of
   * flags can be processed by mutt_set_flag. mailbox->changed must
   * be restored afterwards */
  bool readonly = m->readonly;
  m->readonly = false;

  /* This is redundant with the following two checks. Removing:
   * mutt_set_flag (m, e, MUTT_NEW, !(edata->read || edata->old)); */
  set_changed_flag(m, e, local_changes, server_changes, MUTT_OLD, old_edata.old,
                   edata->old, e->old);
  set_changed_flag(m, e, local_changes, server_changes, MUTT_READ,
                   old_edata.read, edata->read, e->read);
  set_changed_flag(m, e, local_changes, server_changes, MUTT_DELETE,
                   old_edata.deleted, edata->deleted, e->deleted);
  set_changed_flag(m, e, local_changes, server_changes, MUTT_FLAG,
                   old_edata.flagged, edata->flagged, e->flagged);
  set_changed_flag(m, e, local_changes, server_changes, MUTT_REPLIED,
                   old_edata.replied, edata->replied, e->replied);

  /* this message is now definitively *not* changed (mutt_set_flag
   * marks things changed as a side-effect) */
  if (local_changes == 0)
    e->changed = false;
  m->changed &= !readonly;
  m->readonly = readonly;

  return s;
}

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

m	Selected Imap Mailbox
e	Email

Return values

0	Success
-1	Failure

Definition at line 1819 of file message.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);

  if (!e || !adata || (adata->mailbox != m))
    return -1;

  mdata->bcache = msg_cache_open(m);
  char id[64];
  snprintf(id, sizeof(id), "%u-%u", mdata->uidvalidity, imap_edata_get(e)->uid);
  return mutt_bcache_del(mdata->bcache, id);
}

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

m	SelectedImap Mailbox

Return values

0

Always

Definition at line 1838 of file message.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);

  if (!adata || (adata->mailbox != m))
    return -1;

  mdata->bcache = msg_cache_open(m);
  mutt_bcache_list(mdata->bcache, msg_cache_clean_cb, mdata);

  return 0;
}

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

m	Mailbox
msg	Message to save

Return values

0	Success
-1	Failure

Definition at line 1511 of file message.c.

{
  if (!m || !msg)
    return -1;

  FILE *fp = NULL;
  char buf[1024 * 2];
  char internaldate[IMAP_DATELEN];
  char imap_flags[128];
  size_t len;
  struct Progress *progress = NULL;
  size_t sent;
  int c, last;
  int rc;

  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);

  fp = fopen(msg->path, "r");
  if (!fp)
  {
    mutt_perror(msg->path);
    goto fail;
  }

  /* currently we set the \Seen flag on all messages, but probably we
   * should scan the message Status header for flag info. Since we're
   * already rereading the whole file for length it isn't any more
   * expensive (it'd be nice if we had the file size passed in already
   * by the code that writes the file, but that's a lot of changes.
   * Ideally we'd have an Email structure with flag info here... */
  for (last = EOF, len = 0; (c = fgetc(fp)) != EOF; last = c)
  {
    if ((c == '\n') && (last != '\r'))
      len++;

    len++;
  }
  rewind(fp);

  if (m->verbose)
    progress = progress_new(_("Uploading message..."), MUTT_PROGRESS_NET, len);

  mutt_date_make_imap(internaldate, sizeof(internaldate), msg->received);

  imap_flags[0] = '\0';
  imap_flags[1] = '\0';

  if (msg->flags.read)
    mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Seen");
  if (msg->flags.replied)
    mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Answered");
  if (msg->flags.flagged)
    mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Flagged");
  if (msg->flags.draft)
    mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Draft");

  snprintf(buf, sizeof(buf), "APPEND %s (%s) \"%s\" {%lu}", mdata->munge_name,
           imap_flags + 1, internaldate, (unsigned long) len);

  imap_cmd_start(adata, buf);

  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);

  if (rc != IMAP_RES_RESPOND)
    goto cmd_step_fail;

  for (last = EOF, sent = len = 0; (c = fgetc(fp)) != EOF; last = c)
  {
    if ((c == '\n') && (last != '\r'))
      buf[len++] = '\r';

    buf[len++] = c;

    if (len > sizeof(buf) - 3)
    {
      sent += len;
      if (flush_buffer(buf, &len, adata->conn) < 0)
        goto fail;
      if (m->verbose)
        progress_update(progress, sent, -1);
    }
  }

  if (len)
    if (flush_buffer(buf, &len, adata->conn) < 0)
      goto fail;

  if (mutt_socket_send(adata->conn, "\r\n") < 0)
    goto fail;
  mutt_file_fclose(&fp);

  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);

  if (rc != IMAP_RES_OK)
    goto cmd_step_fail;

  progress_free(&progress);
  return 0;

cmd_step_fail:
  mutt_debug(LL_DEBUG1, "command failed: %s\n", adata->buf);
  if (rc != IMAP_RES_BAD)
  {
    char *pc = imap_next_word(adata->buf); /* skip sequence number or token */
    pc = imap_next_word(pc);               /* skip response code */
    if (*pc != '\0')
      mutt_error("%s", pc);
  }

fail:
  mutt_file_fclose(&fp);
  progress_free(&progress);
  return -1;
}

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
	)

Open a header cache.

Parameters

adata	Imap Account data
mdata	Imap Mailbox data

Definition at line 297 of file util.c.

{
  if (!adata || !mdata)
    return;

  if (mdata->hcache)
    return;

  struct HeaderCache *hc = NULL;
  struct Buffer *mbox = mutt_buffer_pool_get();
  struct Buffer *cachepath = mutt_buffer_pool_get();

  imap_cachepath(adata->delim, mdata->name, mbox);

  if (strstr(mutt_buffer_string(mbox), "/../") ||
      mutt_str_equal(mutt_buffer_string(mbox), "..") ||
      mutt_strn_equal(mutt_buffer_string(mbox), "../", 3))
  {
    goto cleanup;
  }
  size_t len = mutt_buffer_len(mbox);
  if ((len > 3) && (strcmp(mutt_buffer_string(mbox) + len - 3, "/..") == 0))
    goto cleanup;

  struct Url url = { 0 };
  mutt_account_tourl(&adata->conn->account, &url);
  url.path = mbox->data;
  url_tobuffer(&url, cachepath, U_PATH);

  const char *const c_header_cache =
      cs_subset_path(NeoMutt->sub, "header_cache");
  hc = mutt_hcache_open(c_header_cache, mutt_buffer_string(cachepath), imap_hcache_namer);

cleanup:
  mutt_buffer_pool_release(&mbox);
  mutt_buffer_pool_release(&cachepath);
  mdata->hcache = hc;
}

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

mdata

Imap Mailbox data

Definition at line 340 of file util.c.

{
  if (!mdata->hcache)
    return;

  mutt_hcache_close(mdata->hcache);
  mdata->hcache = NULL;
}

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

mdata	Imap Mailbox data
uid	UID to find

Return values

ptr	Email
NULL	Failure

Definition at line 356 of file util.c.

{
  if (!mdata->hcache)
    return NULL;

  char key[16];

  sprintf(key, "/%u", uid);
  struct HCacheEntry hce =
      mutt_hcache_fetch(mdata->hcache, key, mutt_str_len(key), mdata->uidvalidity);
  if (!hce.email && hce.uidvalidity)
  {
    mutt_debug(LL_DEBUG3, "hcache uidvalidity mismatch: %u\n", hce.uidvalidity);
  }

  return hce.email;
}

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

mdata	Imap Mailbox data
e	Email

Return values

0	Success
-1	Failure

Definition at line 381 of file util.c.

{
  if (!mdata->hcache)
    return -1;

  char key[16];

  sprintf(key, "/%u", imap_edata_get(e)->uid);
  return mutt_hcache_store(mdata->hcache, key, mutt_str_len(key), e, mdata->uidvalidity);
}

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

mdata	Imap Mailbox data
uid	UID of entry to delete

Return values

0	Success
-1	Failure

Definition at line 399 of file util.c.

{
  if (!mdata->hcache)
    return -1;

  char key[16];

  sprintf(key, "/%u", uid);
  return mutt_hcache_delete_record(mdata->hcache, key, mutt_str_len(key));
}

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

mdata

Imap Mailbox data

Return values

0	Success
-1	Error

Definition at line 416 of file util.c.

{
  if (!mdata->hcache)
    return -1;

  /* The seqset is likely large.  Preallocate to reduce reallocs */
  struct Buffer buf = mutt_buffer_make(8192);
  imap_msn_index_to_uid_seqset(&buf, mdata);

  int rc = mutt_hcache_store_raw(mdata->hcache, "/UIDSEQSET", 10, buf.data,
                                 mutt_buffer_len(&buf) + 1);
  mutt_debug(LL_DEBUG3, "Stored /UIDSEQSET %s\n", buf.data);
  mutt_buffer_dealloc(&buf);
  return rc;
}

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

mdata

Imap Mailbox data

Return values

0	Success
-1	Error

Definition at line 438 of file util.c.

{
  if (!mdata->hcache)
    return -1;

  return mutt_hcache_delete_record(mdata->hcache, "/UIDSEQSET", 10);
}

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

mdata

Imap Mailbox data

Return values

ptr	UID Sequence Set
NULL	Error

Definition at line 452 of file util.c.

{
  if (!mdata->hcache)
    return NULL;

  char *seqset = NULL;
  size_t dlen = 0;
  char *hc_seqset = mutt_hcache_fetch_raw(mdata->hcache, "/UIDSEQSET", 10, &dlen);
  if (hc_seqset)
  {
    seqset = mutt_strn_dup(hc_seqset, dlen);
    mutt_hcache_free_raw(mdata->hcache, (void **) &hc_seqset);
  }
  mutt_debug(LL_DEBUG3, "Retrieved /UIDSEQSET %s\n", NONULL(seqset));

  return seqset;
}

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

msg	Location of the error
resp	Message for user

Return values

QuadOption

Result, e.g. MUTT_NO

Definition at line 654 of file util.c.

{
  imap_error(msg, resp);
  return mutt_yesorno(_("Continue?"), MUTT_NO);
}

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

where	Location of the error
msg	Message for user

Definition at line 665 of file util.c.

{
  mutt_error("%s [%s]", where, msg);
}

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

mdata

Imap Mailbox data

Definition at line 106 of file util.c.

{
  mutt_hash_free(&mdata->uid_hash);
  imap_msn_free(&mdata->msn);
  mutt_bcache_close(&mdata->bcache);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_fix_path()

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

Fix up the imap path.

Parameters

delim	Delimiter specified by the server, '\0' for $imap_delim_chars
mailbox	Mailbox path
path	Buffer for the result
plen	Length of buffer

Return values

ptr	Fixed-up path

Note

if delim is '\0', 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 687 of file util.c.

{
  int i = 0;
  for (; mailbox && *mailbox && (i < plen - 1); i++)
  {
    const char *const c_imap_delim_chars =
        cs_subset_string(NeoMutt->sub, "imap_delim_chars");
    if (*mailbox == delim || (!delim && strchr(NONULL(c_imap_delim_chars), *mailbox)))
    {
      delim = *mailbox;
      /* Skip multiple occurrences of delim */
      while (*mailbox && *(mailbox + 1) == delim)
        mailbox++;
    }
    path[i] = *mailbox++;
  }

  /* Do not terminate with a delimiter */
  if (i && path[i - 1] == delim)
    i--;

  /* Ensure null termination */
  path[i] = '\0';
  return path;
}

Here is the call graph for this function:

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

delim	Imap server delimiter
mailbox	Mailbox name
dest	Buffer to store cache path

Definition at line 719 of file util.c.

{
  const char *p = mailbox;
  mutt_buffer_reset(dest);
  if (!p)
    return;

  while (*p)
  {
    if (p[0] == delim)
    {
      mutt_buffer_addch(dest, '/');
      /* simple way to avoid collisions with UIDs */
      if ((p[1] >= '0') && (p[1] <= '9'))
        mutt_buffer_addch(dest, '_');
    }
    else
      mutt_buffer_addch(dest, *p);
    p++;
  }
}

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	(	const char *	buf,
		unsigned int *	bytes
	)

write number of bytes in an IMAP literal into bytes

Parameters

[in]	buf	Number as a string
[out]	bytes	Resulting number

Return values

0	Success
-1	Failure

Definition at line 748 of file util.c.

{
  char *pc = NULL;
  char *pn = NULL;

  if (!buf || !(pc = strchr(buf, '{')))
    return -1;

  pc++;
  pn = pc;
  while (isdigit((unsigned char) *pc))
    pc++;
  *pc = '\0';
  if (mutt_str_atoui(pn, bytes) < 0)
    return -1;

  return 0;
}

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

buf	Command string to process

Return values

ptr	Start 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 775 of file util.c.

{
  char *s = buf;

  /* skip tag */
  s = imap_next_word(s);
  /* skip OK/NO/BAD response */
  s = imap_next_word(s);

  return s;
}

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

s	Command string to process

Return values

ptr	Next IMAP word

Definition at line 792 of file util.c.

{
  bool quoted = false;

  while (*s)
  {
    if (*s == '\\')
    {
      s++;
      if (*s)
        s++;
      continue;
    }
    if (*s == '\"')
      quoted = !quoted;
    if (!quoted && IS_SPACE(*s))
      break;
    s++;
  }

  SKIPWS(s);
  return s;
}

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

buf	Buffer for the result
buflen	Length of buffer
cac	ConnAccount of the account
path	Path relative to the mailbox

Definition at line 823 of file util.c.

{
  struct Url url = { 0 };
  mutt_account_tourl(cac, &url);
  url.path = path;
  url_tostring(&url, buf, buflen, U_NO_FLAGS);
}

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

dest	Buffer for the result
dlen	Length of the buffer
src	String to be quoted
quote_backtick	If true, quote backticks too

Surround string with quotes, escape " and \ with backslash

Definition at line 840 of file util.c.

{
  const char *quote = "`\"\\";
  if (!quote_backtick)
    quote++;

  char *pt = dest;
  const char *s = src;

  *pt++ = '"';
  /* save room for quote-chars */
  dlen -= 3;

  for (; *s && dlen; s++)
  {
    if (strchr(quote, *s))
    {
      if (dlen < 2)
        break;
      dlen -= 2;
      *pt++ = '\\';
      *pt++ = *s;
    }
    else
    {
      *pt++ = *s;
      dlen--;
    }
  }
  *pt++ = '"';
  *pt = '\0';
}

Here is the caller graph for this function:

imap_unquote_string()

void imap_unquote_string

(

char *

s

)

equally stupid unquoting routine

Parameters

s	String to be unquoted

Definition at line 877 of file util.c.

{
  char *d = s;

  if (*s == '\"')
    s++;
  else
    return;

  while (*s)
  {
    if (*s == '\"')
    {
      *d = '\0';
      return;
    }
    if (*s == '\\')
    {
      s++;
    }
    if (*s)
    {
      *d = *s;
      d++;
      s++;
    }
  }
  *d = '\0';
}

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

unicode	true if Unicode is allowed
dest	Buffer to store safe mailbox name
dlen	Length of buffer
src	Mailbox name

Definition at line 914 of file util.c.

{
  char *buf = mutt_str_dup(src);
  imap_utf_encode(unicode, &buf);

  imap_quote_string(dest, dlen, buf, false);

  FREE(&buf);
}

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

unicode	true if Unicode is allowed
s	Mailbox name

The string will be altered in-place.

Definition at line 931 of file util.c.

{
  imap_unquote_string(s);

  char *buf = mutt_str_dup(s);
  if (buf)
  {
    imap_utf_decode(unicode, &buf);
    strncpy(s, buf, strlen(s));
  }

  FREE(&buf);
}

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

seqset

Source Sequence Set

Return values

ptr	Newly allocated Sequence Set Iterator

Definition at line 1081 of file util.c.

{
  if (!seqset || (*seqset == '\0'))
    return NULL;

  struct SeqsetIterator *iter = mutt_mem_calloc(1, sizeof(struct SeqsetIterator));
  iter->full_seqset = mutt_str_dup(seqset);
  iter->eostr = strchr(iter->full_seqset, '\0');
  iter->substr_cur = iter->substr_end = iter->full_seqset;

  return iter;
}

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]	iter	Sequence Set Iterator
[out]	next	Next UID in set

Return values

0	Next sequence is generated
1	Iterator is finished
-1	error

Definition at line 1102 of file util.c.

{
  if (!iter || !next)
    return -1;

  if (iter->in_range)
  {
    if ((iter->down && (iter->range_cur == (iter->range_end - 1))) ||
        (!iter->down && (iter->range_cur == (iter->range_end + 1))))
    {
      iter->in_range = 0;
    }
  }

  if (!iter->in_range)
  {
    iter->substr_cur = iter->substr_end;
    if (iter->substr_cur == iter->eostr)
      return 1;

    iter->substr_end = strchr(iter->substr_cur, ',');
    if (!iter->substr_end)
      iter->substr_end = iter->eostr;
    else
      *(iter->substr_end++) = '\0';

    char *range_sep = strchr(iter->substr_cur, ':');
    if (range_sep)
      *range_sep++ = '\0';

    if (mutt_str_atoui(iter->substr_cur, &iter->range_cur) != 0)
      return -1;
    if (range_sep)
    {
      if (mutt_str_atoui(range_sep, &iter->range_end) != 0)
        return -1;
    }
    else
      iter->range_end = iter->range_cur;

    iter->down = (iter->range_end < iter->range_cur);
    iter->in_range = 1;
  }

  *next = iter->range_cur;
  if (iter->down)
    iter->range_cur--;
  else
    iter->range_cur++;

  return 0;
}

Here is the call graph for this function:

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]

ptr

Iterator to free

Definition at line 1159 of file util.c.

{
  if (!ptr || !*ptr)
    return;

  struct SeqsetIterator *iter = *ptr;
  FREE(&iter->full_seqset);
  FREE(ptr);
}

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

a1	First ConnAccount
a2	Second ConnAccount

Return values

true	Accounts match

Definition at line 1049 of file util.c.

{
  if (!a1 || !a2)
    return false;
  if (a1->type != a2->type)
    return false;
  if (!mutt_istr_equal(a1->host, a2->host))
    return false;
  if ((a1->port != 0) && (a2->port != 0) && (a1->port != a2->port))
    return false;
  if (a1->flags & a2->flags & MUTT_ACCT_USER)
    return strcmp(a1->user, a2->user) == 0;

  const char *user = NONULL(Username);

  const char *const c_imap_user = cs_subset_string(NeoMutt->sub, "imap_user");
  if ((a1->type == MUTT_ACCT_TYPE_IMAP) && c_imap_user)
    user = c_imap_user;

  if (a1->flags & MUTT_ACCT_USER)
    return strcmp(a1->user, user) == 0;
  if (a2->flags & MUTT_ACCT_USER)
    return strcmp(a2->user, user) == 0;

  return true;
}

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

mbox	Mailbox whose parent is to be determined
delim	Path delimiter
buf	Buffer for the result
buflen	Length of the buffer

Definition at line 120 of file util.c.

{
  /* Make a copy of the mailbox name, but only if the pointers are different */
  if (mbox != buf)
    mutt_str_copy(buf, mbox, buflen);

  int n = mutt_str_len(buf);

  /* Let's go backwards until the next delimiter
   *
   * If buf[n] is a '/', the first n-- will allow us
   * to ignore it. If it isn't, then buf looks like
   * "/aaaaa/bbbb". There is at least one "b", so we can't skip
   * the "/" after the 'a's.
   *
   * If buf == '/', then n-- => n == 0, so the loop ends
   * immediately */
  for (n--; (n >= 0) && (buf[n] != delim); n--)
    ; // do nothing

  /* We stopped before the beginning. There is a trailing slash.  */
  if (n > 0)
  {
    /* Strip the trailing delimiter.  */
    buf[n] = '\0';
  }
  else
  {
    buf[0] = (n == 0) ? delim : '\0';
  }
}

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]	unicode	true if Unicode is allowed
[out]	s	Email to convert

Definition at line 318 of file utf7.c.

{
  const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
  if (!c_charset || !s || !*s)
    return;

  if (unicode && mutt_ch_is_utf8(c_charset))
  {
    return;
  }

  if (mutt_ch_convert_string(s, c_charset, "utf-8", MUTT_ICONV_NO_FLAGS) != 0)
  {
    FREE(s);
    return;
  }

  if (!unicode)
  {
    char *utf7 = utf8_to_utf7(*s, strlen(*s), NULL, 0);
    FREE(s);
    *s = utf7;
  }
}

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]	unicode	true if Unicode is allowed
[out]	s	Email to convert

Definition at line 348 of file utf7.c.

{
  const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
  if (!c_charset || !s || !*s)
    return;

  if (unicode && mutt_ch_is_utf8(c_charset))
  {
    return;
  }

  if (!unicode)
  {
    char *utf8 = utf7_to_utf8(*s, strlen(*s), 0, 0);
    FREE(s);
    *s = utf8;
  }

  if (mutt_ch_convert_string(s, "utf-8", c_charset, MUTT_ICONV_NO_FLAGS) != 0)
  {
    FREE(s);
  }
}

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

m

Mailbox

Definition at line 1021 of file util.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
    return;
  mdata->reopen |= IMAP_REOPEN_ALLOW;
}

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

m

Mailbox

Definition at line 1034 of file util.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
    return;
  mdata->reopen &= ~IMAP_REOPEN_ALLOW;
}

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

adata	Imap Account data
s	Command string with search results

Definition at line 259 of file search.c.

{
  unsigned int uid;
  struct Email *e = NULL;
  struct ImapMboxData *mdata = adata->mailbox->mdata;

  mutt_debug(LL_DEBUG2, "Handling SEARCH\n");

  while ((s = imap_next_word((char *) s)) && (*s != '\0'))
  {
    if (mutt_str_atoui(s, &uid) < 0)
      continue;
    e = mutt_hash_int_find(mdata->uid_hash, uid);
    if (e)
      e->matched = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: