imap.c File Reference

IMAP network mailbox. More...

#include "config.h"
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "conn/lib.h"
#include "mutt.h"
#include "lib.h"
#include "enter/lib.h"
#include "parse/lib.h"
#include "progress/lib.h"
#include "question/lib.h"
#include "adata.h"
#include "auth.h"
#include "commands.h"
#include "edata.h"
#include "external.h"
#include "hook.h"
#include "mdata.h"
#include "msn.h"
#include "mutt_logging.h"
#include "mutt_socket.h"
#include "muttlib.h"
#include "mx.h"
#include "sort.h"
#include <libintl.h>

Include dependency graph for imap.c:

Go to the source code of this file.

Functions
void	imap_init (void)
	Setup feature commands. More...
static int	check_capabilities (struct ImapAccountData *adata)
	Make sure we can log in to this server. More...
static char *	get_flags (struct ListHead *hflags, char *s)
	Make a simple list out of a FLAGS response. More...
static void	set_flag (struct Mailbox *m, AclFlags aclflag, bool flag, const char *str, char *flags, size_t flsize)
	Append str to flags if we currently have permission according to aclflag. More...
static int	make_msg_set (struct Mailbox *m, struct Buffer *buf, enum MessageType flag, bool changed, bool invert, int *pos)
	Make a message set. More...
static bool	compare_flags_for_copy (struct Email *e)
	Compare local flags against the server. More...
static int	sync_helper (struct Mailbox *m, AclFlags right, enum MessageType flag, const char *name)
	Sync flag changes to the server. More...
static size_t	longest_common_prefix (char *dest, const char *src, size_t start, size_t dlen)
	Find longest prefix common to two strings. More...
static int	complete_hosts (char *buf, size_t buflen)
	Look for completion matches for mailboxes. More...
int	imap_create_mailbox (struct ImapAccountData *adata, const char *mailbox)
	Create a new mailbox. More...
int	imap_access (const char *path)
	Check permissions on an IMAP mailbox with a new connection. More...
int	imap_rename_mailbox (struct ImapAccountData *adata, char *oldname, const char *newname)
	Rename a mailbox. More...
int	imap_delete_mailbox (struct Mailbox *m, char *path)
	Delete a mailbox. More...
static void	imap_logout (struct ImapAccountData *adata)
	Gracefully log out of server. More...
void	imap_logout_all (void)
	Close all open connections. More...
int	imap_read_literal (FILE *fp, struct ImapAccountData *adata, unsigned long bytes, struct Progress *progress)
	Read bytes bytes from server into file. More...
void	imap_notify_delete_email (struct Mailbox *m, struct Email *e)
	Inform IMAP that an Email has been deleted. More...
void	imap_expunge_mailbox (struct Mailbox *m, bool resort)
	Purge messages from the server. 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...
bool	imap_has_flag (struct ListHead *flag_list, const char *flag)
	Does the flag exist in the list. More...
static int	compare_uid (const void *a, const void *b)
	Compare two Emails by UID - Implements sort_t -. 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_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...
enum MxStatus	imap_check_mailbox (struct Mailbox *m, bool force)
	Use the NOOP or IDLE command to poll for new mail. More...
static int	imap_status (struct ImapAccountData *adata, struct ImapMboxData *mdata, bool queue)
	Refresh the number of total and new messages. More...
static enum MxStatus	imap_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -. More...
int	imap_path_status (const char *path, bool queue)
	Refresh the number of total and new messages. More...
int	imap_mailbox_status (struct Mailbox *m, bool queue)
	Refresh the number of total and new messages. More...
int	imap_subscribe (char *path, bool subscribe)
	Subscribe to a mailbox. More...
int	imap_complete (char *buf, size_t buflen, const char *path)
	Try to complete an IMAP folder path. More...
int	imap_fast_trash (struct Mailbox *m, const char *dest)
	Use server COPY command to copy deleted messages to trash. More...
enum MxStatus	imap_sync_mailbox (struct Mailbox *m, bool expunge, bool close)
	Sync all the changes to the server. More...
static bool	imap_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -. More...
static bool	imap_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -. More...
static void	imap_mbox_select (struct Mailbox *m)
	Select a Mailbox. More...
int	imap_login (struct ImapAccountData *adata)
	Open an IMAP connection. More...
static enum MxOpenReturns	imap_mbox_open (struct Mailbox *m)
	Open a mailbox - Implements MxOps::mbox_open() -. More...
static bool	imap_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -. More...
static enum MxStatus	imap_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -. More...
static enum MxStatus	imap_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -. More...
static bool	imap_msg_open_new (struct Mailbox *m, struct Message *msg, const struct Email *e)
	Open a new message in a Mailbox - Implements MxOps::msg_open_new() -. More...
static int	imap_tags_edit (struct Mailbox *m, const char *tags, struct Buffer *buf)
	Prompt and validate new messages tags - Implements MxOps::tags_edit() -. More...
static int	imap_tags_commit (struct Mailbox *m, struct Email *e, const char *buf)
	Save the tags to a message - Implements MxOps::tags_commit() -. More...
enum MailboxType	imap_path_probe (const char *path, const struct stat *st)
	Is this an IMAP Mailbox? - Implements MxOps::path_probe() -. More...
int	imap_path_canon (char *buf, size_t buflen)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -. More...
int	imap_expand_path (struct Buffer *buf)
	Buffer wrapper around imap_path_canon() More...
static int	imap_path_pretty (char *buf, size_t buflen, const char *folder)
	Abbreviate a Mailbox path - Implements MxOps::path_pretty() -. More...
static int	imap_path_parent (char *buf, size_t buflen)
	Find the parent of a Mailbox path - Implements MxOps::path_parent() -. More...
static int	imap_path_is_empty (const char *path)
	Is the mailbox empty - Implements MxOps::path_is_empty() -. More...

Variables
static const struct Command	ImapCommands []
	Imap Commands. More...
struct MxOps	MxImapOps
	IMAP Mailbox - Implements MxOps -. More...

Detailed Description

IMAP network mailbox.

Authors

• Michael R. Elkins
• 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 imap.c.

Function Documentation

imap_init()

void imap_init

(

void

)

Setup feature commands.

Definition at line 86 of file imap.c.

{
  commands_register(ImapCommands, mutt_array_size(ImapCommands));
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_capabilities()

static int check_capabilities ( struct ImapAccountData *  adata )

static

Make sure we can log in to this server.

Parameters

adata

Imap Account data

Return values

0	Success
-1	Failure

Definition at line 97 of file imap.c.

{
  if (imap_exec(adata, "CAPABILITY", IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
  {
    imap_error("check_capabilities", adata->buf);
    return -1;
  }
 
  if (!((adata->capabilities & IMAP_CAP_IMAP4) || (adata->capabilities & IMAP_CAP_IMAP4REV1)))
  {
    mutt_error(_("This IMAP server is ancient. NeoMutt does not work with it."));
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_flags()

static char * get_flags ( struct ListHead *  hflags, char *  s  )

static

Make a simple list out of a FLAGS response.

Parameters

hflags	List to store flags
s	String containing flags

Return values

ptr	End of the flags
NULL	Failure

return stream following FLAGS response

Definition at line 123 of file imap.c.

{
  /* sanity-check string */
  const size_t plen = mutt_istr_startswith(s, "FLAGS");
  if (plen == 0)
  {
    mutt_debug(LL_DEBUG1, "not a FLAGS response: %s\n", s);
    return NULL;
  }
  s += plen;
  SKIPWS(s);
  if (*s != '(')
  {
    mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
    return NULL;
  }
 
  /* update caller's flags handle */
  while (*s && (*s != ')'))
  {
    s++;
    SKIPWS(s);
    const char *flag_word = s;
    while (*s && (*s != ')') && !IS_SPACE(*s))
      s++;
    const char ctmp = *s;
    *s = '\0';
    if (*flag_word)
      mutt_list_insert_tail(hflags, mutt_str_dup(flag_word));
    *s = ctmp;
  }
 
  /* note bad flags response */
  if (*s != ')')
  {
    mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
    mutt_list_free(hflags);
 
    return NULL;
  }
 
  s++;
 
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_flag()

static void set_flag ( struct Mailbox *  m, AclFlags  aclflag, bool  flag, const char *  str, char *  flags, size_t  flsize  )

static

Append str to flags if we currently have permission according to aclflag.

Parameters

[in]	m	Selected Imap Mailbox
[in]	aclflag	Permissions, see AclFlags
[in]	flag	Does the email have the flag set?
[in]	str	Server flag name
[out]	flags	Buffer for server command
[in]	flsize	Length of buffer

Definition at line 178 of file imap.c.

{
  if (m->rights & aclflag)
    if (flag && imap_has_flag(&imap_mdata_get(m)->flags, str))
      mutt_str_cat(flags, flsize, str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_msg_set()

static int make_msg_set ( struct Mailbox *  m, struct Buffer *  buf, enum MessageType  flag, bool  changed, bool  invert, int *  pos  )

static

Make a message set.

Parameters

[in]	m	Selected Imap Mailbox
[in]	buf	Buffer to store message set
[in]	flag	Flags to match, e.g. MUTT_DELETED
[in]	changed	Matched messages that have been altered
[in]	invert	Flag matches should be inverted
[out]	pos	Cursor used for multiple calls to this function

Return values

num	Messages in the set

Note

Headers must be in SORT_ORDER. See imap_exec_msgset() for args. Pos is an opaque pointer a la strtok(). It should be 0 at first call.

Definition at line 199 of file imap.c.

{
  int count = 0;             /* number of messages in message set */
  unsigned int setstart = 0; /* start of current message range */
  int n;
  bool started = false;
 
  struct ImapAccountData *adata = imap_adata_get(m);
  if (!adata || (adata->mailbox != m))
    return -1;
 
  for (n = *pos; (n < m->msg_count) && (mutt_buffer_len(buf) < IMAP_MAX_CMDLEN); n++)
  {
    struct Email *e = m->emails[n];
    if (!e)
      break;
    bool match = false; /* whether current message matches flag condition */
    /* don't include pending expunged messages.
     *
     * TODO: can we unset active in cmd_parse_expunge() and
     * cmd_parse_vanished() instead of checking for index != INT_MAX. */
    if (e->active && (e->index != INT_MAX))
    {
      switch (flag)
      {
        case MUTT_DELETED:
          if (e->deleted != imap_edata_get(e)->deleted)
            match = invert ^ e->deleted;
          break;
        case MUTT_FLAG:
          if (e->flagged != imap_edata_get(e)->flagged)
            match = invert ^ e->flagged;
          break;
        case MUTT_OLD:
          if (e->old != imap_edata_get(e)->old)
            match = invert ^ e->old;
          break;
        case MUTT_READ:
          if (e->read != imap_edata_get(e)->read)
            match = invert ^ e->read;
          break;
        case MUTT_REPLIED:
          if (e->replied != imap_edata_get(e)->replied)
            match = invert ^ e->replied;
          break;
        case MUTT_TAG:
          if (e->tagged)
            match = true;
          break;
        case MUTT_TRASH:
          if (e->deleted && !e->purge)
            match = true;
          break;
        default:
          break;
      }
    }
 
    if (match && (!changed || e->changed))
    {
      count++;
      if (setstart == 0)
      {
        setstart = imap_edata_get(e)->uid;
        if (started)
        {
          mutt_buffer_add_printf(buf, ",%u", imap_edata_get(e)->uid);
        }
        else
        {
          mutt_buffer_add_printf(buf, "%u", imap_edata_get(e)->uid);
          started = true;
        }
      }
      /* tie up if the last message also matches */
      else if (n == (m->msg_count - 1))
        mutt_buffer_add_printf(buf, ":%u", imap_edata_get(e)->uid);
    }
    /* End current set if message doesn't match. */
    else if (setstart)
    {
      if (imap_edata_get(m->emails[n - 1])->uid > setstart)
        mutt_buffer_add_printf(buf, ":%u", imap_edata_get(m->emails[n - 1])->uid);
      setstart = 0;
    }
  }
 
  *pos = n;
 
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compare_flags_for_copy()

static bool compare_flags_for_copy ( struct Email *  e )

static

Compare local flags against the server.

Parameters

e

Email

Return values

true	Flags have changed
false	Flags match cached server flags

The comparison of flags EXCLUDES the deleted flag.

Definition at line 300 of file imap.c.

{
  struct ImapEmailData *edata = e->edata;
 
  if (e->read != edata->read)
    return true;
  if (e->old != edata->old)
    return true;
  if (e->flagged != edata->flagged)
    return true;
  if (e->replied != edata->replied)
    return true;
 
  return false;
}

Here is the caller graph for this function:

sync_helper()

static int sync_helper ( struct Mailbox *  m, AclFlags  right, enum MessageType  flag, const char *  name  )

static

Sync flag changes to the server.

Parameters

m	Selected Imap Mailbox
right	ACL, see AclFlags
flag	NeoMutt flag, e.g. MUTT_DELETED
name	Name of server flag

Return values

>=0	Success, number of messages
-1	Failure

Definition at line 325 of file imap.c.

{
  int count = 0;
  int rc;
  char buf[1024] = { 0 };
 
  if (!m)
    return -1;
 
  if ((m->rights & right) == 0)
    return 0;
 
  if ((right == MUTT_ACL_WRITE) && !imap_has_flag(&imap_mdata_get(m)->flags, name))
    return 0;
 
  snprintf(buf, sizeof(buf), "+FLAGS.SILENT (%s)", name);
  rc = imap_exec_msgset(m, "UID STORE", buf, flag, true, false);
  if (rc < 0)
    return rc;
  count += rc;
 
  buf[0] = '-';
  rc = imap_exec_msgset(m, "UID STORE", buf, flag, true, true);
  if (rc < 0)
    return rc;
  count += rc;
 
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

longest_common_prefix()

static size_t longest_common_prefix ( char *  dest, const char *  src, size_t  start, size_t  dlen  )

static

Find longest prefix common to two strings.

Parameters

dest	Destination buffer
src	Source buffer
start	Starting offset into string
dlen	Destination buffer length

Return values

num	Length of the common string

Trim dest to the length of the longest prefix it shares with src.

Definition at line 366 of file imap.c.

{
  size_t pos = start;
 
  while ((pos < dlen) && dest[pos] && (dest[pos] == src[pos]))
    pos++;
  dest[pos] = '\0';
 
  return pos;
}

Here is the caller graph for this function:

complete_hosts()

static int complete_hosts ( char *  buf, size_t  buflen  )

static

Look for completion matches for mailboxes.

Parameters

buf	Partial mailbox name to complete
buflen	Length of buffer

Return values

0	Success
-1	Failure

look for IMAP URLs to complete from defined mailboxes. Could be extended to complete over open connections and account/folder hooks too.

Definition at line 387 of file imap.c.

{
  // struct Connection *conn = NULL;
  int rc = -1;
  size_t matchlen;
 
  matchlen = mutt_str_len(buf);
  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    if (!mutt_str_startswith(mailbox_path(np->mailbox), buf))
      continue;
 
    if (rc)
    {
      mutt_str_copy(buf, mailbox_path(np->mailbox), buflen);
      rc = 0;
    }
    else
    {
      longest_common_prefix(buf, mailbox_path(np->mailbox), matchlen, buflen);
    }
  }
  neomutt_mailboxlist_clear(&ml);
 
#if 0
  TAILQ_FOREACH(conn, mutt_socket_head(), entries)
  {
    struct Url url = { 0 };
    char urlstr[1024] = { 0 };
 
    if (conn->account.type != MUTT_ACCT_TYPE_IMAP)
      continue;
 
    mutt_account_tourl(&conn->account, &url);
    /* FIXME: how to handle multiple users on the same host? */
    url.user = NULL;
    url.path = NULL;
    url_tostring(&url, urlstr, sizeof(urlstr), U_NO_FLAGS);
    if (mutt_strn_equal(buf, urlstr, matchlen))
    {
      if (rc)
      {
        mutt_str_copy(buf, urlstr, buflen);
        rc = 0;
      }
      else
      {
        longest_common_prefix(buf, urlstr, matchlen, buflen);
      }
    }
  }
#endif
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 453 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_access()

int imap_access

(

const char *

path

)

Check permissions on an IMAP mailbox with a new connection.

Parameters

path	Mailbox path

Return values

0	Success
<0	Failure

TODO: ACL checks. Right now we assume if it exists we can mess with it. TODO: This method should take a Mailbox as parameter to be able to reuse the existing connection.

Definition at line 479 of file imap.c.

{
  if (imap_path_status(path, false) >= 0)
    return 0;
  return -1;
}

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 494 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 = 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_delete_mailbox()

int imap_delete_mailbox	(	struct Mailbox *	m,
		char *	path
	)

Delete a mailbox.

Parameters

m	Mailbox
path	name of the mailbox to delete

Return values

0	Success
-1	Failure

Definition at line 521 of file imap.c.

{
  char buf[PATH_MAX + 7];
  char mbox[PATH_MAX] = { 0 };
  struct Url *url = url_parse(path);
 
  struct ImapAccountData *adata = imap_adata_get(m);
  imap_munge_mbox_name(adata->unicode, mbox, sizeof(mbox), url->path);
  url_free(&url);
  snprintf(buf, sizeof(buf), "DELETE %s", mbox);
  if (imap_exec(m->account->adata, buf, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
    return -1;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_logout()

static void imap_logout ( struct ImapAccountData *  adata )

static

Gracefully log out of server.

Parameters

adata

Imap Account data

Definition at line 541 of file imap.c.

{
  /* we set status here to let imap_handle_untagged know we _expect_ to
   * receive a bye response (so it doesn't freak out and close the conn) */
  if (adata->state == IMAP_DISCONNECTED)
  {
    return;
  }
 
  adata->status = IMAP_BYE;
  imap_cmd_start(adata, "LOGOUT");
  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))
  {
    while (imap_cmd_step(adata) == IMAP_RES_CONTINUE)
      ; // do nothing
  }
  mutt_socket_close(adata->conn);
  adata->state = IMAP_DISCONNECTED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_logout_all()

void imap_logout_all

(

void

)

Close all open connections.

Quick and dirty until we can make sure we've got all the context we need.

Definition at line 568 of file imap.c.

{
  struct Account *np = NULL;
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    if (np->type != MUTT_IMAP)
      continue;
 
    struct ImapAccountData *adata = np->adata;
    if (!adata)
      continue;
 
    struct Connection *conn = adata->conn;
    if (!conn || (conn->fd < 0))
      continue;
 
    mutt_message(_("Closing connection to %s..."), conn->account.host);
    imap_logout(np->adata);
    mutt_clear_error();
  }
}

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 604 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 + 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;
 
      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 (progress && !(pos % 1024))
      progress_update(progress, 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_notify_delete_email()

void imap_notify_delete_email	(	struct Mailbox *	m,
		struct Email *	e
	)

Inform IMAP that an Email has been deleted.

Parameters

m	Mailbox
e	Email

Definition at line 662 of file imap.c.

{
  struct ImapMboxData *mdata = imap_mdata_get(m);
  struct ImapEmailData *edata = imap_edata_get(e);
 
  if (!mdata || !edata)
    return;
 
  imap_msn_remove(&mdata->msn, edata->msn - 1);
  edata->msn = 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 683 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);
  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_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 755 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 863 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_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 888 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_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 940 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 mv 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_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 1017 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  if (!adata || (adata->mailbox != m))
    return -1;
 
  char flags[1024] = { 0 };
  char *tags = NULL;
  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);
  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_check_mailbox()

enum MxStatus imap_check_mailbox	(	struct Mailbox *	m,
		bool	force
	)

Use the NOOP or IDLE command to poll for new mail.

Parameters

m	Mailbox
force	Don't wait

Return values

num

MxStatus

Definition at line 1118 of file imap.c.

{
  if (!m || !m->account)
    return MX_STATUS_ERROR;
 
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
 
  /* overload keyboard timeout to avoid many mailbox checks in a row.
   * Most users don't like having to wait exactly when they press a key. */
  int rc = 0;
 
  /* try IDLE first, unless force is set */
  const bool c_imap_idle = cs_subset_bool(NeoMutt->sub, "imap_idle");
  const short c_imap_keepalive = cs_subset_number(NeoMutt->sub, "imap_keepalive");
  if (!force && c_imap_idle && (adata->capabilities & IMAP_CAP_IDLE) &&
      ((adata->state != IMAP_IDLE) || (mutt_date_now() >= adata->lastread + c_imap_keepalive)))
  {
    if (imap_cmd_idle(adata) < 0)
      return MX_STATUS_ERROR;
  }
  if (adata->state == IMAP_IDLE)
  {
    while ((rc = mutt_socket_poll(adata->conn, 0)) > 0)
    {
      if (imap_cmd_step(adata) != IMAP_RES_CONTINUE)
      {
        mutt_debug(LL_DEBUG1, "Error reading IDLE response\n");
        return MX_STATUS_ERROR;
      }
    }
    if (rc < 0)
    {
      mutt_debug(LL_DEBUG1, "Poll failed, disabling IDLE\n");
      adata->capabilities &= ~IMAP_CAP_IDLE; // Clear the flag
    }
  }
 
  const short c_timeout = cs_subset_number(NeoMutt->sub, "timeout");
  if ((force || ((adata->state != IMAP_IDLE) && (mutt_date_now() >= adata->lastread + c_timeout))) &&
      (imap_exec(adata, "NOOP", IMAP_CMD_POLL) != IMAP_EXEC_SUCCESS))
  {
    return MX_STATUS_ERROR;
  }
 
  /* We call this even when we haven't run NOOP in case we have pending
   * changes to process, since we can reopen here. */
  imap_cmd_finish(adata);
 
  enum MxStatus check = MX_STATUS_OK;
  if (mdata->check_status & IMAP_EXPUNGE_PENDING)
    check = MX_STATUS_REOPENED;
  else if (mdata->check_status & IMAP_NEWMAIL_PENDING)
    check = MX_STATUS_NEW_MAIL;
  else if (mdata->check_status & IMAP_FLAGS_PENDING)
    check = MX_STATUS_FLAGS;
  else if (rc < 0)
    check = MX_STATUS_ERROR;
 
  mdata->check_status = IMAP_OPEN_NO_FLAGS;
 
  return check;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_status()

static int imap_status ( struct ImapAccountData *  adata, struct ImapMboxData *  mdata, bool  queue  )

static

Refresh the number of total and new messages.

Parameters

adata	IMAP Account data
mdata	IMAP Mailbox data
queue	Queue the STATUS command

Return values

num	Total number of messages

Definition at line 1189 of file imap.c.

{
  char *uidvalidity_flag = NULL;
  char cmd[2048] = { 0 };
 
  if (!adata || !mdata)
    return -1;
 
  /* Don't issue STATUS on the selected mailbox, it will be NOOPed or
   * IDLEd elsewhere.
   * adata->mailbox may be NULL for connections other than the current
   * mailbox's. */
  if (adata->mailbox && (adata->mailbox->mdata == mdata))
  {
    adata->mailbox->has_new = false;
    return mdata->messages;
  }
 
  if (adata->capabilities & IMAP_CAP_IMAP4REV1)
    uidvalidity_flag = "UIDVALIDITY";
  else if (adata->capabilities & IMAP_CAP_STATUS)
    uidvalidity_flag = "UID-VALIDITY";
  else
  {
    mutt_debug(LL_DEBUG2, "Server doesn't support STATUS\n");
    return -1;
  }
 
  snprintf(cmd, sizeof(cmd), "STATUS %s (UIDNEXT %s UNSEEN RECENT MESSAGES)",
           mdata->munge_name, uidvalidity_flag);
 
  int rc = imap_exec(adata, cmd, queue ? IMAP_CMD_QUEUE : IMAP_CMD_NO_FLAGS | IMAP_CMD_POLL);
  if (rc < 0)
  {
    mutt_debug(LL_DEBUG1, "Error queueing command\n");
    return rc;
  }
  return mdata->messages;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_path_status()

int imap_path_status	(	const char *	path,
		bool	queue
	)

Refresh the number of total and new messages.

Parameters

path	Mailbox path
queue	Queue the STATUS command

Return values

num	Total number of messages

Definition at line 1249 of file imap.c.

{
  struct Mailbox *m = mx_mbox_find2(path);
 
  const bool is_temp = !m;
  if (is_temp)
  {
    m = mx_path_resolve(path);
    if (!mx_mbox_ac_link(m))
    {
      mailbox_free(&m);
      return 0;
    }
  }
 
  int rc = imap_mailbox_status(m, queue);
 
  if (is_temp)
  {
    mx_ac_remove(m, false);
    mailbox_free(&m);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mailbox_status()

int imap_mailbox_status	(	struct Mailbox *	m,
		bool	queue
	)

Refresh the number of total and new messages.

Parameters

m	Mailbox
queue	Queue the STATUS command

Return values

num	Total number of messages
-1	Error

Note

Prepare the mailbox if we are not connected

Definition at line 1284 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || !mdata)
    return -1;
  return imap_status(adata, mdata, queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_subscribe()

int imap_subscribe	(	char *	path,
		bool	subscribe
	)

Subscribe to a mailbox.

Parameters

path	Mailbox path
subscribe	True: subscribe, false: unsubscribe

Return values

0	Success
-1	Failure

Definition at line 1300 of file imap.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
  char buf[2048] = { 0 };
  struct Buffer err;
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
    return -1;
 
  if (subscribe)
    mutt_message(_("Subscribing to %s..."), mdata->name);
  else
    mutt_message(_("Unsubscribing from %s..."), mdata->name);
 
  snprintf(buf, sizeof(buf), "%sSUBSCRIBE %s", subscribe ? "" : "UN", mdata->munge_name);
 
  if (imap_exec(adata, buf, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
  {
    imap_mdata_free((void *) &mdata);
    return -1;
  }
 
  const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
  if (c_imap_check_subscribed)
  {
    char mbox[1024] = { 0 };
    mutt_buffer_init(&err);
    err.dsize = 256;
    err.data = mutt_mem_malloc(err.dsize);
    size_t len = snprintf(mbox, sizeof(mbox), "%smailboxes ", subscribe ? "" : "un");
    imap_quote_string(mbox + len, sizeof(mbox) - len, path, true);
    if (parse_rc_line(mbox, &err))
      mutt_debug(LL_DEBUG1, "Error adding subscribed mailbox: %s\n", err.data);
    FREE(&err.data);
  }
 
  if (subscribe)
    mutt_message(_("Subscribed to %s"), mdata->name);
  else
    mutt_message(_("Unsubscribed from %s"), mdata->name);
  imap_mdata_free((void *) &mdata);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_complete()

int imap_complete	(	char *	buf,
		size_t	buflen,
		const char *	path
	)

Try to complete an IMAP folder path.

Parameters

buf	Buffer for result
buflen	Length of buffer
path	Partial mailbox name to complete

Return values

0	Success
-1	Failure

Given a partial IMAP folder path, return a string which adds as much to the path as is unique

Definition at line 1356 of file imap.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
  char tmp[2048] = { 0 };
  struct ImapList listresp = { 0 };
  char completion[1024] = { 0 };
  size_t clen;
  size_t matchlen = 0;
  int completions = 0;
  int rc;
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
  {
    mutt_str_copy(buf, path, buflen);
    return complete_hosts(buf, buflen);
  }
 
  /* fire off command */
  const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
  snprintf(tmp, sizeof(tmp), "%s \"\" \"%s%%\"",
           c_imap_list_subscribed ? "LSUB" : "LIST", mdata->real_name);
 
  imap_cmd_start(adata, tmp);
 
  /* and see what the results are */
  mutt_str_copy(completion, mdata->name, sizeof(completion));
  imap_mdata_free((void *) &mdata);
 
  adata->cmdresult = &listresp;
  do
  {
    listresp.name = NULL;
    rc = imap_cmd_step(adata);
 
    if ((rc == IMAP_RES_CONTINUE) && listresp.name)
    {
      /* if the folder isn't selectable, append delimiter to force browse
       * to enter it on second tab. */
      if (listresp.noselect)
      {
        clen = strlen(listresp.name);
        listresp.name[clen++] = listresp.delim;
        listresp.name[clen] = '\0';
      }
      /* copy in first word */
      if (!completions)
      {
        mutt_str_copy(completion, listresp.name, sizeof(completion));
        matchlen = strlen(completion);
        completions++;
        continue;
      }
 
      matchlen = longest_common_prefix(completion, listresp.name, 0, matchlen);
      completions++;
    }
  } while (rc == IMAP_RES_CONTINUE);
  adata->cmdresult = NULL;
 
  if (completions)
  {
    /* reformat output */
    imap_qualify_path(buf, buflen, &adata->conn->account, completion);
    mutt_pretty_mailbox(buf, buflen);
    return 0;
  }
 
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_fast_trash()

int imap_fast_trash	(	struct Mailbox *	m,
		const char *	dest
	)

Use server COPY command to copy deleted messages to trash.

Parameters

m	Mailbox
dest	Mailbox to move to

Return values

-1	Error
0	Success
1	Non-fatal error - try fetch/append

Definition at line 1435 of file imap.c.

{
  char prompt[1024] = { 0 };
  int rc = -1;
  bool triedcreate = false;
  enum QuadOption err_continue = MUTT_NO;
 
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapAccountData *dest_adata = NULL;
  struct ImapMboxData *dest_mdata = NULL;
 
  if (imap_adata_find(dest, &dest_adata, &dest_mdata) < 0)
    return -1;
 
  struct Buffer sync_cmd = mutt_buffer_make(0);
 
  /* check that the save-to folder is in the same account */
  if (!imap_account_match(&(adata->conn->account), &(dest_adata->conn->account)))
  {
    mutt_debug(LL_DEBUG3, "%s not same server as %s\n", dest, mailbox_path(m));
    goto out;
  }
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    if (e->active && e->changed && e->deleted && !e->purge)
    {
      rc = imap_sync_message_for_copy(m, e, &sync_cmd, &err_continue);
      if (rc < 0)
      {
        mutt_debug(LL_DEBUG1, "could not sync\n");
        goto out;
      }
    }
  }
 
  /* loop in case of TRYCREATE */
  do
  {
    rc = imap_exec_msgset(m, "UID COPY", dest_mdata->munge_name, MUTT_TRASH, false, false);
    if (rc == 0)
    {
      mutt_debug(LL_DEBUG1, "No messages to trash\n");
      rc = -1;
      goto out;
    }
    else if (rc < 0)
    {
      mutt_debug(LL_DEBUG1, "could not queue copy\n");
      goto out;
    }
    else if (m->verbose)
    {
      mutt_message(ngettext("Copying %d message to %s...", "Copying %d messages to %s...", rc),
                   rc, dest_mdata->name);
    }
 
    /* let's get it on */
    rc = imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS);
    if (rc == IMAP_EXEC_ERROR)
    {
      if (triedcreate)
      {
        mutt_debug(LL_DEBUG1, "Already tried to create mailbox %s\n", dest_mdata->name);
        break;
      }
      /* bail out if command failed for reasons other than nonexistent target */
      if (!mutt_istr_startswith(imap_get_qualifier(adata->buf), "[TRYCREATE]"))
        break;
      mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
      snprintf(prompt, sizeof(prompt), _("Create %s?"), dest_mdata->name);
      const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
      if (c_confirm_create && (mutt_yesorno(prompt, MUTT_YES) != MUTT_YES))
      {
        mutt_clear_error();
        goto out;
      }
      if (imap_create_mailbox(adata, dest_mdata->name) < 0)
        break;
      triedcreate = true;
    }
  } while (rc == IMAP_EXEC_ERROR);
 
  if (rc != IMAP_EXEC_SUCCESS)
  {
    imap_error("imap_fast_trash", adata->buf);
    goto out;
  }
 
  rc = IMAP_EXEC_SUCCESS;
 
out:
  mutt_buffer_dealloc(&sync_cmd);
  imap_mdata_free((void *) &dest_mdata);
 
  return ((rc == IMAP_EXEC_SUCCESS) ? 0 : -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_sync_mailbox()

enum MxStatus imap_sync_mailbox	(	struct Mailbox *	m,
		bool	expunge,
		bool	close
	)

Sync all the changes to the server.

Parameters

m	Mailbox
expunge	if true do expunge
close	if true we move imap state to CLOSE

Return values

enum

MxStatus

Note

The flag retvals come from a call to imap_check_mailbox()

Definition at line 1545 of file imap.c.

{
  if (!m)
    return -1;
 
  struct Email **emails = NULL;
  int rc;
 
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
 
  if (adata->state < IMAP_SELECTED)
  {
    mutt_debug(LL_DEBUG2, "no mailbox selected\n");
    return -1;
  }
 
  /* This function is only called when the calling code expects the context
   * to be changed. */
  imap_allow_reopen(m);
 
  enum MxStatus check = imap_check_mailbox(m, false);
  if (check == MX_STATUS_ERROR)
    return check;
 
  /* if we are expunging anyway, we can do deleted messages very quickly... */
  if (expunge && (m->rights & MUTT_ACL_DELETE))
  {
    rc = imap_exec_msgset(m, "UID STORE", "+FLAGS.SILENT (\\Deleted)",
                          MUTT_DELETED, true, false);
    if (rc < 0)
    {
      mutt_error(_("Expunge failed"));
      return rc;
    }
 
    if (rc > 0)
    {
      /* mark these messages as unchanged so second pass ignores them. Done
       * here so BOGUS UW-IMAP 4.7 SILENT FLAGS updates are ignored. */
      for (int i = 0; i < m->msg_count; i++)
      {
        struct Email *e = m->emails[i];
        if (!e)
          break;
        if (e->deleted && e->changed)
          e->active = false;
      }
      if (m->verbose)
      {
        mutt_message(ngettext("Marking %d message deleted...",
                              "Marking %d messages deleted...", rc),
                     rc);
      }
    }
  }
 
#ifdef USE_HCACHE
  imap_hcache_open(adata, mdata);
#endif
 
  /* save messages with real (non-flag) changes */
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (e->deleted)
    {
      imap_cache_del(m, e);
#ifdef USE_HCACHE
      imap_hcache_del(mdata, imap_edata_get(e)->uid);
#endif
    }
 
    if (e->active && e->changed)
    {
#ifdef USE_HCACHE
      imap_hcache_put(mdata, e);
#endif
      /* if the message has been rethreaded or attachments have been deleted
       * we delete the message and reupload it.
       * This works better if we're expunging, of course. */
      /* TODO: why the e->env check? */
      if ((e->env && e->env->changed) || e->attach_del)
      {
        /* L10N: The plural is chosen by the last %d, i.e. the total number */
        if (m->verbose)
        {
          mutt_message(ngettext("Saving changed message... [%d/%d]",
                                "Saving changed messages... [%d/%d]", m->msg_count),
                       i + 1, m->msg_count);
        }
        bool save_append = m->append;
        m->append = true;
        mutt_save_message_ctx(m, e, SAVE_MOVE, TRANSFORM_NONE, m);
        m->append = save_append;
        /* TODO: why the check for e->env?  Is this possible? */
        if (e->env)
          e->env->changed = 0;
      }
    }
  }
 
#ifdef USE_HCACHE
  imap_hcache_close(mdata);
#endif
 
  /* presort here to avoid doing 10 resorts in imap_exec_msgset */
  const short c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  if (c_sort != SORT_ORDER)
  {
    emails = m->emails;
    m->emails = mutt_mem_malloc(m->msg_count * sizeof(struct Email *));
    memcpy(m->emails, emails, m->msg_count * 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);
  }
 
  rc = sync_helper(m, MUTT_ACL_DELETE, MUTT_DELETED, "\\Deleted");
  if (rc >= 0)
    rc |= sync_helper(m, MUTT_ACL_WRITE, MUTT_FLAG, "\\Flagged");
  if (rc >= 0)
    rc |= sync_helper(m, MUTT_ACL_WRITE, MUTT_OLD, "Old");
  if (rc >= 0)
    rc |= sync_helper(m, MUTT_ACL_SEEN, MUTT_READ, "\\Seen");
  if (rc >= 0)
    rc |= sync_helper(m, MUTT_ACL_WRITE, MUTT_REPLIED, "\\Answered");
 
  if (c_sort != SORT_ORDER)
  {
    cs_subset_str_native_set(NeoMutt->sub, "sort", c_sort, NULL);
    FREE(&m->emails);
    m->emails = emails;
  }
 
  /* Flush the queued flags if any were changed in sync_helper. */
  if (rc > 0)
    if (imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
      rc = -1;
 
  if (rc < 0)
  {
    if (close)
    {
      if (mutt_yesorno(_("Error saving flags. Close anyway?"), MUTT_NO) == MUTT_YES)
      {
        adata->state = IMAP_AUTHENTICATED;
        return 0;
      }
    }
    else
    {
      mutt_error(_("Error saving flags"));
    }
    return -1;
  }
 
  /* Update local record of server state to reflect the synchronization just
   * completed.  imap_read_headers always overwrites hcache-origin flags, so
   * there is no need to mutate the hcache after flag-only changes. */
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    struct ImapEmailData *edata = imap_edata_get(e);
    edata->deleted = e->deleted;
    edata->flagged = e->flagged;
    edata->old = e->old;
    edata->read = e->read;
    edata->replied = e->replied;
    e->changed = false;
  }
  m->changed = false;
 
  /* We must send an EXPUNGE command if we're not closing. */
  if (expunge && !close && (m->rights & MUTT_ACL_DELETE))
  {
    if (m->verbose)
      mutt_message(_("Expunging messages from server..."));
    /* Set expunge bit so we don't get spurious reopened messages */
    mdata->reopen |= IMAP_EXPUNGE_EXPECTED;
    if (imap_exec(adata, "EXPUNGE", IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
    {
      mdata->reopen &= ~IMAP_EXPUNGE_EXPECTED;
      imap_error(_("imap_sync_mailbox: EXPUNGE failed"), adata->buf);
      return -1;
    }
    mdata->reopen &= ~IMAP_EXPUNGE_EXPECTED;
  }
 
  if (expunge && close)
  {
    adata->closing = true;
    imap_exec(adata, "CLOSE", IMAP_CMD_NO_FLAGS);
    adata->state = IMAP_AUTHENTICATED;
  }
 
  const bool c_message_cache_clean = cs_subset_bool(NeoMutt->sub, "message_cache_clean");
  if (c_message_cache_clean)
    imap_cache_clean(m);
 
  return check;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mbox_select()

static void imap_mbox_select ( struct Mailbox *  m )

static

Select a Mailbox.

Parameters

m

Mailbox

Definition at line 1828 of file imap.c.

{
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || !mdata)
    return;
 
  const char *condstore = NULL;
#ifdef USE_HCACHE
  const bool c_imap_condstore = cs_subset_bool(NeoMutt->sub, "imap_condstore");
  if ((adata->capabilities & IMAP_CAP_CONDSTORE) && c_imap_condstore)
    condstore = " (CONDSTORE)";
  else
#endif
    condstore = "";
 
  char buf[PATH_MAX] = { 0 };
  snprintf(buf, sizeof(buf), "%s %s%s", m->readonly ? "EXAMINE" : "SELECT",
           mdata->munge_name, condstore);
 
  adata->state = IMAP_SELECTED;
 
  imap_cmd_start(adata, buf);
}

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 1861 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 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_expand_path()

int imap_expand_path

(

struct Buffer *

buf

)

Buffer wrapper around imap_path_canon()

Parameters

buf	Path to expand

Return values

0	Success
-1	Failure

Note

The path is expanded in place

Definition at line 2465 of file imap.c.

{
  mutt_buffer_alloc(buf, PATH_MAX);
  return imap_path_canon(buf->data, PATH_MAX);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ImapCommands

const struct Command ImapCommands[]

static

Initial value:

= {
  
  { "subscribe-to",     parse_subscribe_to,     0 },
  { "unsubscribe-from", parse_unsubscribe_from, 0 },
  
}

Imap Commands.

Definition at line 76 of file imap.c.