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:

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

#define	IMAP_LOG_LTRL 3

#define	IMAP_LOG_PASS 5

#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

#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

#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)
	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 (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 (const 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

Definition at line 48 of file private.h.

◆ IMAP_LOG_LTRL

#define IMAP_LOG_LTRL 3

Definition at line 49 of file private.h.

◆ IMAP_LOG_PASS

#define IMAP_LOG_PASS 5

Definition at line 50 of file private.h.

◆ IMAP_RES_NO

#define IMAP_RES_NO -2

<tag> NO ...

Definition at line 53 of file private.h.

◆ IMAP_RES_BAD

#define IMAP_RES_BAD -1

<tag> BAD ...

Definition at line 54 of file private.h.

◆ IMAP_RES_OK

#define IMAP_RES_OK 0

<tag> OK ...

Definition at line 55 of file private.h.

◆ IMAP_RES_CONTINUE

#define IMAP_RES_CONTINUE 1

* ...

Definition at line 56 of file private.h.

◆ IMAP_RES_RESPOND

#define IMAP_RES_RESPOND 2

+

Definition at line 57 of file private.h.

◆ IMAP_RES_NEW

#define IMAP_RES_NEW 3

ImapCommand.state additions.

Definition at line 58 of file private.h.

◆ SEQ_LEN

#define SEQ_LEN 16

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

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.

{
  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 93 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 102 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,
		const char *	mailbox
	)

Create a new mailbox.

Parameters

adata	Imap Account data
mailbox	Mailbox to create

Return values

0	Success
-1	Failure

Definition at line 437 of file imap.c.

{
  char buf[2048] = { 0 };
  char mbox[1024] = { 0 };
 
  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 479 of file imap.c.

{
  char oldmbox[1024] = { 0 };
  char newmbox[1024] = { 0 };
  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 = buf_pool_get();
  buf_printf(buf, "RENAME %s %s", oldmbox, newmbox);
 
  if (imap_exec(adata, buf_string(buf), IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
    rc = -1;
 
  buf_pool_release(&buf);
 
  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 742 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;
 
      if (c_ssl_force_tls)
      {
        ans = MUTT_YES;
      }
      else if ((ans = query_quadoption(_("Secure connection with TLS?"),
                                       NeoMutt->sub, "ssl_starttls")) == 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) != IMAP_EXEC_SUCCESS)
              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 850 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 *	progress
	)

Read bytes bytes from server into file.

Parameters

fp	File handle for email file
adata	Imap Account data
bytes	Number of bytes to read
progress	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 591 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)
    buf_alloc(&buf, bytes + 1);
 
  mutt_debug(LL_DEBUG2, "reading %lu 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, %lu bytes read\n", pos);
      adata->status = IMAP_FATAL;
 
      buf_dealloc(&buf);
      return -1;
    }
 
    if (r && (c != '\n'))
      fputc('\r', fp);
 
    if (c == '\r')
    {
      r = true;
      continue;
    }
    else
    {
      r = false;
    }
 
    fputc(c, fp);
 
    if ((pos % 1024) == 0)
      progress_update(progress, pos, -1);
    if (c_debug_level >= IMAP_LOG_LTRL)
      buf_addch(&buf, c);
  }
 
  if (c_debug_level >= IMAP_LOG_LTRL)
  {
    mutt_debug(IMAP_LOG_LTRL, "\n%s", buf.data);
    buf_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,
		bool	resort
	)

Purge messages from the server.

Parameters

m	Mailbox
resort	Trigger 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 670 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_msg_set.
       *
       * 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);
  if (resort)
  {
    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 1776 of file imap.c.

{
  if (!adata)
    return -1;
 
  if (adata->state == IMAP_DISCONNECTED)
  {
    buf_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 RFC2971, if the server supports that */
    const bool c_imap_send_id = cs_subset_bool(NeoMutt->sub, "imap_send_id");
    if (c_imap_send_id && (adata->capabilities & IMAP_CAP_ID))
    {
      imap_exec(adata, "ID (\"name\" \"NeoMutt\" \"version\" \"" PACKAGE_VERSION "\")",
                IMAP_CMD_QUEUE);
    }
 
    /* 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 927 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  if (!adata || (adata->mailbox != m))
    return -1;
 
  char flags[1024] = { 0 };
  char uid[11] = { 0 };
 
  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);
  buf_reset(cmd);
  buf_addstr(cmd, "UID STORE ");
  buf_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 */
    struct Buffer *tags = buf_pool_get();
    driver_tags_get_with_hidden(&e->tags, tags);
    if (!buf_is_empty(tags))
    {
      mutt_str_cat(flags, sizeof(flags), buf_string(tags));
    }
    buf_pool_release(&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);
 
    buf_addstr(cmd, " -FLAGS.SILENT (");
  }
  else
  {
    buf_addstr(cmd, " FLAGS.SILENT (");
  }
 
  buf_addstr(cmd, flags);
  buf_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);
  struct Buffer *flags_remote = buf_pool_get();
  driver_tags_get_with_hidden(&e->tags, flags_remote);
  imap_edata_get(e)->flags_remote = buf_strdup(flags_remote);
  buf_pool_release(&flags_remote);
 
  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 875 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 73 of file util.c.

{
  struct ConnAccount cac = { { 0 } };
  struct ImapAccountData *tmp_adata = NULL;
  char tmp[1024] = { 0 };
 
  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

enum	ImapAuthRes, e.g. IMAP_AUTH_SUCCESS

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

Definition at line 115 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(ImapAuthenticators); i++)
      {
        const struct ImapAuth *auth = &ImapAuthenticators[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(ImapAuthenticators); i++)
    {
      rc = ImapAuthenticators[i].authenticate(adata, NULL);
      if (rc == IMAP_AUTH_SUCCESS)
        return rc;
    }
  }
 
  mutt_error(_("No authenticators available or wrong credentials"));
  return rc;
}

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 1118 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 1132 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 %zu 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 %zu bytes\n", adata->blen);
  }
 
  adata->lastread = mutt_date_now();
 
  /* 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 1372 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, true);
      /* 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 %zd to %u\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 1259 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 1270 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 1307 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 1439 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 */
    buf_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 1341 of file message.c.

{
  unsigned int maxuid = 0;
  int rc = -1;
  bool evalhc = false;
 
#ifdef USE_HCACHE
  uint32_t uidvalidity = 0;
  unsigned int uid_next = 0;
  unsigned long long modseq = 0;
  bool has_condstore = false;
  bool has_qresync = false;
  bool eval_condstore = false;
  bool eval_qresync = false;
  char *uid_seqset = NULL;
  const unsigned int msn_begin_save = msn_begin;
#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 */
  mx_alloc_memory(m, msn_end);
  imap_msn_reserve(&mdata->msn, msn_end);
  imap_alloc_uid_hash(adata, msn_end);
 
  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)
  {
    hcache_fetch_raw_obj(mdata->hcache, "UIDVALIDITY", 11, &uidvalidity);
    hcache_fetch_raw_obj(mdata->hcache, "UIDNEXT", 7, &uid_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 && (uidvalidity == mdata->uidvalidity))
    {
      evalhc = true;
      if (hcache_fetch_raw_obj(mdata->hcache, "MODSEQ", 6, &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;
      }
    }
  }
  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) && (modseq != mdata->modseq))
    {
      if (read_headers_condstore_qresync_updates(adata, msn_end, uid_next,
                                                 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;
      modseq = 0;
      maxuid = 0;
      FREE(&uid_seqset);
      uidvalidity = 0;
      uid_next = 0;
      msn_begin = msn_begin_save;
 
      goto retry;
    }
  }
#endif /* USE_HCACHE */
 
  if (maxuid && (mdata->uid_next < maxuid + 1))
    mdata->uid_next = maxuid + 1;
 
#ifdef USE_HCACHE
  hcache_store_raw(mdata->hcache, "UIDVALIDITY", 11, &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)
  {
    hcache_store_raw(mdata->hcache, "UIDNEXT", 7, &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)
    {
      hcache_store_raw(mdata->hcache, "MODSEQ", 6, &mdata->modseq, sizeof(mdata->modseq));
    }
    else
    {
      hcache_delete_raw(mdata->hcache, "MODSEQ", 6);
    }
 
    if (has_qresync)
      imap_hcache_store_uid_seqset(mdata);
    else
      imap_hcache_clear_uid_seqset(mdata);
  }
#endif /* USE_HCACHE */
 
  /* TODO: it's not clear to me why we are calling mx_alloc_memory yet again. */
  mx_alloc_memory(m, m->msg_count);
 
  mdata->reopen |= IMAP_REOPEN_ALLOW;
 
  rc = msn_end;
 
bail:
#ifdef USE_HCACHE
  imap_hcache_close(mdata);
  FREE(&uid_seqset);
#endif /* USE_HCACHE */
 
  return rc;
}

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 1920 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), true); */
  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 1869 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 = imap_bcache_open(m);
  char id[64] = { 0 };
  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 1888 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 = imap_bcache_open(m);
  mutt_bcache_list(mdata->bcache, imap_bcache_delete, 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 1530 of file message.c.

{
  if (!m || !msg)
    return -1;
 
  FILE *fp = NULL;
  char buf[2048] = { 0 };
  struct Buffer *internaldate = NULL;
  char imap_flags[128] = { 0 };
  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 = mutt_file_fopen(msg->path, "r");
  if (!fp)
  {
    mutt_perror("%s", 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(MUTT_PROGRESS_NET, len);
    progress_set_message(progress, _("Uploading message..."));
  }
 
  internaldate = buf_pool_get();
  mutt_date_make_imap(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, buf_string(internaldate), (unsigned long) len);
  buf_pool_release(&internaldate);
 
  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;
      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 299 of file util.c.

{
  if (!adata || !mdata)
    return;
 
  if (mdata->hcache)
    return;
 
  struct HeaderCache *hc = NULL;
  struct Buffer *mbox = buf_pool_get();
  struct Buffer *cachepath = buf_pool_get();
 
  imap_cachepath(adata->delim, mdata->name, mbox);
 
  if (strstr(buf_string(mbox), "/../") || mutt_str_equal(buf_string(mbox), "..") ||
      mutt_strn_equal(buf_string(mbox), "../", 3))
  {
    goto cleanup;
  }
  size_t len = buf_len(mbox);
  if ((len > 3) && (mutt_str_equal(buf_string(mbox) + len - 3, "/..")))
    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 = hcache_open(c_header_cache, buf_string(cachepath), imap_hcache_namer);
 
cleanup:
  buf_pool_release(&mbox);
  buf_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;
 
  hcache_close(&mdata->hcache);
}

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 355 of file util.c.

{
  if (!mdata->hcache)
    return NULL;
 
  char key[16] = { 0 };
 
  snprintf(key, sizeof(key), "%u", uid);
  struct HCacheEntry hce = hcache_fetch_email(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 380 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  char key[16] = { 0 };
 
  snprintf(key, sizeof(key), "%u", imap_edata_get(e)->uid);
  return hcache_store_email(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 398 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  char key[16] = { 0 };
 
  snprintf(key, sizeof(key), "%u", uid);
  return hcache_delete_email(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 415 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  struct Buffer *buf = buf_pool_get();
  buf_alloc(buf, 8192); // The seqset is likely large.  Preallocate to reduce reallocs
  imap_msn_index_to_uid_seqset(buf, mdata);
 
  int rc = hcache_store_raw(mdata->hcache, "UIDSEQSET", 9, buf->data, buf_len(buf) + 1);
  mutt_debug(LL_DEBUG3, "Stored UIDSEQSET %s\n", buf_string(buf));
  buf_pool_release(&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 436 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  return hcache_delete_raw(mdata->hcache, "UIDSEQSET", 9);
}

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 450 of file util.c.

{
  if (!mdata->hcache)
    return NULL;
 
  char *seqset = hcache_fetch_raw_str(mdata->hcache, "UIDSEQSET", 9);
  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 646 of file util.c.

{
  imap_error(msg, resp);
  return query_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 657 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 107 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 679 of file util.c.

{
  int i = 0;
  const char *const c_imap_delim_chars = cs_subset_string(NeoMutt->sub, "imap_delim_chars");
  for (; mailbox && *mailbox && (i < (plen - 1)); i++)
  {
    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 != 0) && (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 710 of file util.c.

{
  const char *p = mailbox;
  buf_reset(dest);
  if (!p)
    return;
 
  while (*p)
  {
    if (p[0] == delim)
    {
      buf_addch(dest, '/');
      /* simple way to avoid collisions with UIDs */
      if ((p[1] >= '0') && (p[1] <= '9'))
        buf_addch(dest, '_');
    }
    else
    {
      buf_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 741 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))
    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 768 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 785 of file util.c.

{
  bool quoted = false;
 
  while (*s)
  {
    if (*s == '\\')
    {
      s++;
      if (*s)
        s++;
      continue;
    }
    if (*s == '\"')
      quoted = !quoted;
    if (!quoted && isspace(*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 816 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_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

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

Definition at line 830 of file util.c.

{
  struct Url url = { 0 };
  mutt_account_tourl(cac, &url);
  url.path = path;
  url_tobuffer(&url, buf, 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 847 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 884 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 921 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 938 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 1086 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 1107 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_full(iter->substr_cur, &iter->range_cur))
      return -1;
    if (range_sep)
    {
      if (!mutt_str_atoui_full(range_sep, &iter->range_end))
        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 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 1166 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 1054 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 mutt_str_equal(a1->user, a2->user);
 
  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 mutt_str_equal(a1->user, user);
  if (a2->flags & MUTT_ACCT_USER)
    return mutt_str_equal(a2->user, user);
 
  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 121 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 397 of file utf7.c.

{
  if (!s || !*s)
    return;
 
  const char *c_charset = cc_charset();
  if (!c_charset)
    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 430 of file utf7.c.

{
  if (!s || !*s)
    return;
 
  const char *c_charset = cc_charset();
  if (!c_charset)
    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 1026 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 1039 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 256 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))
      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:

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ IMAP_PORT

◆ IMAP_SSL_PORT

◆ IMAP_LOG_CMD

◆ IMAP_LOG_LTRL

◆ IMAP_LOG_PASS

◆ IMAP_RES_NO

◆ IMAP_RES_BAD

◆ IMAP_RES_OK

◆ IMAP_RES_CONTINUE

◆ IMAP_RES_RESPOND

◆ IMAP_RES_NEW

◆ SEQ_LEN

◆ IMAP_OPEN_NO_FLAGS

◆ IMAP_REOPEN_ALLOW

◆ IMAP_EXPUNGE_EXPECTED

◆ IMAP_EXPUNGE_PENDING

◆ IMAP_NEWMAIL_PENDING

◆ IMAP_FLAGS_PENDING

◆ IMAP_CMD_NO_FLAGS

◆ IMAP_CMD_PASS

◆ IMAP_CMD_QUEUE

◆ IMAP_CMD_POLL

◆ IMAP_CMD_SINGLE

◆ IMAP_DATELEN

◆ IMAP_CAP_NO_FLAGS

◆ IMAP_CAP_IMAP4

◆ IMAP_CAP_IMAP4REV1

◆ IMAP_CAP_STATUS

◆ IMAP_CAP_ACL

◆ IMAP_CAP_NAMESPACE

◆ IMAP_CAP_AUTH_CRAM_MD5

◆ IMAP_CAP_AUTH_GSSAPI

◆ IMAP_CAP_AUTH_ANONYMOUS

◆ IMAP_CAP_AUTH_OAUTHBEARER

◆ IMAP_CAP_AUTH_XOAUTH2

◆ IMAP_CAP_STARTTLS

◆ IMAP_CAP_LOGINDISABLED

◆ IMAP_CAP_IDLE

◆ IMAP_CAP_SASL_IR

◆ IMAP_CAP_ENABLE

◆ IMAP_CAP_CONDSTORE

◆ IMAP_CAP_QRESYNC

◆ IMAP_CAP_LIST_EXTENDED

◆ IMAP_CAP_COMPRESS

◆ IMAP_CAP_X_GM_EXT_1

◆ IMAP_CAP_ID

◆ IMAP_CAP_ALL

Typedef Documentation

◆ ImapOpenFlags

◆ ImapCmdFlags

◆ ImapCapFlags

Enumeration Type Documentation

◆ ImapExecResult

◆ ImapFlags

◆ ImapState

Function Documentation

◆ imap_create_mailbox()

◆ imap_rename_mailbox()

◆ imap_open_connection()

◆ imap_close_connection()

◆ imap_read_literal()

◆ imap_expunge_mailbox()

◆ imap_login()

◆ imap_sync_message_for_copy()

◆ imap_has_flag()

◆ imap_adata_find()

◆ imap_authenticate()

◆ imap_cmd_start()

◆ imap_cmd_step()

◆ imap_cmd_finish()

◆ imap_code()

◆ imap_cmd_trailer()

◆ imap_exec()