command.c File Reference

Send/receive commands to/from an IMAP server. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.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 "commands/lib.h"
#include "adata.h"
#include "edata.h"
#include "mdata.h"
#include "msn.h"
#include "mx.h"

Include dependency graph for command.c:

Go to the source code of this file.

Macros
#define	IMAP_CMD_BUFSIZE   512
	Default buffer size for IMAP commands.
#define	IMAP_MAX_RETRIES   5
	Maximum number of reconnection attempts before giving up.
#define	IMAP_MAX_BACKOFF   30
	Maximum backoff delay in seconds between reconnection attempts.
#define	IMAP_CONN_STALE_THRESHOLD   300
	Threshold in seconds after which to consider a connection potentially stale.

Functions
static bool	cmd_queue_full (struct ImapAccountData *adata)
	Is the IMAP command queue full?
static struct ImapCommand *	cmd_new (struct ImapAccountData *adata)
	Create and queue a new command control block.
static int	cmd_queue (struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
	Add a IMAP command to the queue.
static void	cmd_handle_fatal (struct ImapAccountData *adata)
	When ImapAccountData is in fatal state, do what we can.
static int	cmd_start (struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
	Start a new IMAP command.
static int	cmd_status (const char *s)
	Parse response line for tagged OK/NO/BAD.
static void	cmd_parse_expunge (struct ImapAccountData *adata, const char *s)
	Parse expunge command.
static void	cmd_parse_vanished (struct ImapAccountData *adata, char *s)
	Parse vanished command.
static void	cmd_parse_fetch (struct ImapAccountData *adata, char *s)
	Load fetch response into ImapAccountData.
static void	cmd_parse_capability (struct ImapAccountData *adata, char *s)
	Set capability bits according to CAPABILITY response.
static void	cmd_parse_list (struct ImapAccountData *adata, char *s)
	Parse a server LIST command (list mailboxes)
static void	cmd_parse_lsub (struct ImapAccountData *adata, char *s)
	Parse a server LSUB (list subscribed mailboxes)
static void	cmd_parse_myrights (struct ImapAccountData *adata, const char *s)
	Set rights bits according to MYRIGHTS response.
static struct Mailbox *	find_mailbox (struct ImapAccountData *adata, const char *name)
	Find a Mailbox by its name.
static void	cmd_parse_status (struct ImapAccountData *adata, char *s)
	Parse status from server.
static void	cmd_parse_enabled (struct ImapAccountData *adata, const char *s)
	Record what the server has enabled.
static void	cmd_parse_exists (struct ImapAccountData *adata, const char *pn)
	Parse EXISTS message from serer.
static int	cmd_handle_untagged (struct ImapAccountData *adata)
	Fallback parser for otherwise unhandled messages.
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.
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.
void	imap_cmd_finish (struct ImapAccountData *adata)
	Attempt to perform cleanup.
int	imap_cmd_idle (struct ImapAccountData *adata)
	Enter the IDLE state.

Variables
static const char *const	Capabilities []
	Server capabilities strings that we understand.

Detailed Description

Send/receive commands to/from an IMAP server.

Authors

• Michael R. Elkins
• Brandon Long
• Brendan Cully
• Richard Russon
• Mehdi Abaakouk
• Pietro Cerutti
• Fabian Groffen
• Federico Kircheis
• Ian Zimmerman
• Thomas Adam
• Thomas Klausner

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 command.c.

Macro Definition Documentation

IMAP_CMD_BUFSIZE

#define IMAP_CMD_BUFSIZE   512

Default buffer size for IMAP commands.

Definition at line 63 of file command.c.

IMAP_MAX_RETRIES

#define IMAP_MAX_RETRIES   5

Maximum number of reconnection attempts before giving up.

Definition at line 66 of file command.c.

IMAP_MAX_BACKOFF

#define IMAP_MAX_BACKOFF   30

Maximum backoff delay in seconds between reconnection attempts.

Definition at line 69 of file command.c.

IMAP_CONN_STALE_THRESHOLD

#define IMAP_CONN_STALE_THRESHOLD   300

Threshold in seconds after which to consider a connection potentially stale.

Definition at line 72 of file command.c.

Function Documentation

cmd_queue_full()

static bool cmd_queue_full ( struct ImapAccountData * adata )

static

Is the IMAP command queue full?

Parameters

adata

Imap Account data

Return values

true	Queue is full

Definition at line 109 of file command.c.

{
  if (((adata->nextcmd + 1) % adata->cmdslots) == adata->lastcmd)
    return true;
 
  return false;
}

Here is the caller graph for this function:

cmd_new()

static struct ImapCommand * cmd_new ( struct ImapAccountData * adata )

static

Create and queue a new command control block.

Parameters

adata

Imap Account data

Return values

NULL	The pipeline is full
ptr	New command

Definition at line 123 of file command.c.

{
  struct ImapCommand *cmd = NULL;
 
  if (cmd_queue_full(adata))
  {
    mutt_debug(LL_DEBUG3, "IMAP command queue full\n");
    return NULL;
  }
 
  cmd = adata->cmds + adata->nextcmd;
  adata->nextcmd = (adata->nextcmd + 1) % adata->cmdslots;
 
  snprintf(cmd->seq, sizeof(cmd->seq), "%c%04u", adata->seqid, adata->seqno++);
  if (adata->seqno > 9999)
    adata->seqno = 0;
 
  cmd->state = IMAP_RES_NEW;
 
  return cmd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_queue()

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

static

Add a IMAP command to the queue.

Parameters

adata	Imap Account data
cmdstr	Command string
flags	Server flags, see ImapCmdFlags

Return values

0	Success
<0	Failure, e.g. IMAP_RES_BAD

If the queue is full, attempts to drain it.

Definition at line 155 of file command.c.

{
  if (cmd_queue_full(adata))
  {
    mutt_debug(LL_DEBUG3, "Draining IMAP command pipeline\n");
 
    const int rc = imap_exec(adata, NULL, flags & IMAP_CMD_POLL);
 
    if (rc == IMAP_EXEC_ERROR)
      return IMAP_RES_BAD;
  }
 
  struct ImapCommand *cmd = cmd_new(adata);
  if (!cmd)
    return IMAP_RES_BAD;
 
  if (buf_add_printf(&adata->cmdbuf, "%s %s\r\n", cmd->seq, cmdstr) < 0)
    return IMAP_RES_BAD;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_handle_fatal()

static void cmd_handle_fatal ( struct ImapAccountData * adata )

static

When ImapAccountData is in fatal state, do what we can.

Parameters

adata

Imap Account data

Attempts to reconnect using exponential backoff (1s, 2s, 4s, 8s... max 30s). Gives up after IMAP_MAX_RETRIES consecutive failures.

Definition at line 184 of file command.c.

{
  adata->status = IMAP_FATAL;
 
  mutt_debug(LL_DEBUG1, "state=%d, status=%d, recovering=%d, retries=%d\n",
             adata->state, adata->status, adata->recovering, adata->retry_count);
  mutt_debug(LL_DEBUG1, "Connection: fd=%d, host=%s\n",
             adata->conn ? adata->conn->fd : -1,
             adata->conn ? adata->conn->account.host : "NULL");
 
  if (!adata->mailbox)
    return;
 
  struct ImapMboxData *mdata = adata->mailbox->mdata;
  if (!mdata)
    return;
 
  if ((adata->state >= IMAP_SELECTED) && (mdata->reopen & IMAP_REOPEN_ALLOW))
  {
    mx_fastclose_mailbox(adata->mailbox, true);
    mutt_error(_("Mailbox %s@%s closed"), adata->conn->account.user,
               adata->conn->account.host);
  }
 
  imap_close_connection(adata);
  if (!adata->recovering)
  {
    adata->recovering = true;
 
    /* Exponential backoff: 1s, 2s, 4s, 8s, 16s, max 30s */
    if (adata->retry_count > 0)
    {
      unsigned int delay = (adata->retry_count < 32) ?
                               (1U << (adata->retry_count - 1)) :
                               IMAP_MAX_BACKOFF;
      if (delay > IMAP_MAX_BACKOFF)
        delay = IMAP_MAX_BACKOFF;
      mutt_message(_("Connection lost. Retrying in %u seconds..."), delay);
      sleep(delay);
    }
 
    mutt_debug(LL_DEBUG1, "Attempting to reconnect to %s (attempt %d)\n",
               adata->conn ? adata->conn->account.host : "NULL", adata->retry_count + 1);
 
    if (imap_login(adata))
    {
      mutt_message(_("Reconnected to %s"), adata->conn->account.host);
      adata->retry_count = 0; // Reset on success
    }
    else
    {
      adata->retry_count++;
      mutt_debug(LL_DEBUG1, "Reconnection failed (attempt %d/%d)\n",
                 adata->retry_count, IMAP_MAX_RETRIES);
 
      if (adata->retry_count >= IMAP_MAX_RETRIES)
      {
        mutt_error(_("Failed to reconnect to %s after %d attempts"),
                   adata->conn->account.host, adata->retry_count);
        adata->retry_count = 0; // Reset for future attempts
      }
      else
      {
        mutt_error(_("Reconnection to %s failed. Will retry automatically."),
                   adata->conn->account.host);
      }
    }
    adata->recovering = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_start()

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

static

Start a new IMAP command.

Parameters

adata	Imap Account data
cmdstr	Command string
flags	Command flags, see ImapCmdFlags

Return values

0	Success
<0	Failure, e.g. IMAP_RES_BAD

Definition at line 263 of file command.c.

{
  int rc;
 
  if (adata->status == IMAP_FATAL)
  {
    cmd_handle_fatal(adata);
    return -1;
  }
 
  if (cmdstr && ((rc = cmd_queue(adata, cmdstr, flags)) < 0))
    return rc;
 
  if (flags & IMAP_CMD_QUEUE)
    return 0;
 
  if (buf_is_empty(&adata->cmdbuf))
    return IMAP_RES_BAD;
 
  rc = mutt_socket_send_d(adata->conn, adata->cmdbuf.data,
                          (flags & IMAP_CMD_PASS) ? IMAP_LOG_PASS : IMAP_LOG_CMD);
  buf_reset(&adata->cmdbuf);
 
  /* unidle when command queue is flushed */
  if (adata->state == IMAP_IDLE)
    adata->state = IMAP_SELECTED;
 
  return (rc < 0) ? IMAP_RES_BAD : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_status()

static int cmd_status ( const char * s )

static

Parse response line for tagged OK/NO/BAD.

Parameters

s	Status string from server

Return values

0	Success
<0	Failure, e.g. IMAP_RES_BAD

Definition at line 299 of file command.c.

{
  s = imap_next_word((char *) s);
 
  if (mutt_istr_startswith(s, "OK"))
    return IMAP_RES_OK;
  if (mutt_istr_startswith(s, "NO"))
    return IMAP_RES_NO;
 
  return IMAP_RES_BAD;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_expunge()

static void cmd_parse_expunge ( struct ImapAccountData * adata, const char * s )

static

Parse expunge command.

Parameters

adata	Imap Account data
s	String containing MSN of message to expunge

cmd_parse_expunge: mark headers with new sequence ID and mark adata to be reopened at our earliest convenience

Definition at line 319 of file command.c.

{
  unsigned int exp_msn = 0;
  struct Email *e = NULL;
 
  mutt_debug(LL_DEBUG2, "Handling EXPUNGE\n");
 
  struct ImapMboxData *mdata = adata->mailbox->mdata;
  if (!mdata)
    return;
 
  if (!mutt_str_atoui(s, &exp_msn) || (exp_msn < 1) ||
      (exp_msn > imap_msn_highest(&mdata->msn)))
  {
    return;
  }
 
  e = imap_msn_get(&mdata->msn, exp_msn - 1);
  if (e)
  {
    /* imap_expunge_mailbox() will rewrite e->index.
     * It needs to resort using EMAIL_SORT_UNSORTED anyway, so setting to INT_MAX
     * makes the code simpler and possibly more efficient. */
    e->index = INT_MAX;
 
    struct ImapEmailData *edata = imap_edata_get(e);
    if (edata)
      edata->msn = 0;
  }
 
  /* decrement seqno of those above. */
  const size_t max_msn = imap_msn_highest(&mdata->msn);
  for (unsigned int cur = exp_msn; cur < max_msn; cur++)
  {
    e = imap_msn_get(&mdata->msn, cur);
    if (e)
    {
      struct ImapEmailData *edata = imap_edata_get(e);
      if (edata)
        edata->msn--;
    }
    imap_msn_set(&mdata->msn, cur - 1, e);
  }
  imap_msn_shrink(&mdata->msn, 1);
 
  mdata->reopen |= IMAP_EXPUNGE_PENDING;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_vanished()

static void cmd_parse_vanished ( struct ImapAccountData * adata, char * s )

static

Parse vanished command.

Parameters

adata	Imap Account data
s	String containing MSN of message to expunge

Handle VANISHED (RFC7162), which is like expunge, but passes a seqset of UIDs. An optional (EARLIER) argument specifies not to decrement subsequent MSNs.

Definition at line 375 of file command.c.

{
  bool earlier = false;
  int rc;
  unsigned int uid = 0;
 
  struct ImapMboxData *mdata = adata->mailbox->mdata;
  if (!mdata)
    return;
 
  mutt_debug(LL_DEBUG2, "Handling VANISHED\n");
 
  if (mutt_istr_startswith(s, "(EARLIER)"))
  {
    /* The RFC says we should not decrement msns with the VANISHED EARLIER tag.
     * My experimentation says that's crap. */
    earlier = true;
    s = imap_next_word(s);
  }
 
  char *end_of_seqset = s;
  while (*end_of_seqset)
  {
    if (!strchr("0123456789:,", *end_of_seqset))
      *end_of_seqset = '\0';
    else
      end_of_seqset++;
  }
 
  struct SeqsetIterator *iter = mutt_seqset_iterator_new(s);
  if (!iter)
  {
    mutt_debug(LL_DEBUG2, "VANISHED: empty seqset [%s]?\n", s);
    return;
  }
 
  while ((rc = mutt_seqset_iterator_next(iter, &uid)) == 0)
  {
    struct Email *e = mutt_hash_int_find(mdata->uid_hash, uid);
    if (!e)
      continue;
 
    unsigned int exp_msn = imap_edata_get(e)->msn;
 
    /* imap_expunge_mailbox() will rewrite e->index.
     * It needs to resort using EMAIL_SORT_UNSORTED anyway, so setting to INT_MAX
     * makes the code simpler and possibly more efficient. */
    e->index = INT_MAX;
    imap_edata_get(e)->msn = 0;
 
    if ((exp_msn < 1) || (exp_msn > imap_msn_highest(&mdata->msn)))
    {
      mutt_debug(LL_DEBUG1, "VANISHED: msn for UID %u is incorrect\n", uid);
      continue;
    }
    if (imap_msn_get(&mdata->msn, exp_msn - 1) != e)
    {
      mutt_debug(LL_DEBUG1, "VANISHED: msn_index for UID %u is incorrect\n", uid);
      continue;
    }
 
    imap_msn_remove(&mdata->msn, exp_msn - 1);
 
    if (!earlier)
    {
      /* decrement seqno of those above. */
      const size_t max_msn = imap_msn_highest(&mdata->msn);
      for (unsigned int cur = exp_msn; cur < max_msn; cur++)
      {
        e = imap_msn_get(&mdata->msn, cur);
        if (e)
          imap_edata_get(e)->msn--;
        imap_msn_set(&mdata->msn, cur - 1, e);
      }
 
      imap_msn_shrink(&mdata->msn, 1);
    }
  }
 
  if (rc < 0)
    mutt_debug(LL_DEBUG1, "VANISHED: illegal seqset %s\n", s);
 
  mdata->reopen |= IMAP_EXPUNGE_PENDING;
 
  mutt_seqset_iterator_free(&iter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_fetch()

static void cmd_parse_fetch ( struct ImapAccountData * adata, char * s )

static

Load fetch response into ImapAccountData.

Parameters

adata	Imap Account data
s	String containing MSN of message to fetch

Currently only handles unanticipated FETCH responses, and only FLAGS data. We get these if another client has changed flags for a mailbox we've selected. Of course, a lot of code here duplicates code in message.c.

Definition at line 471 of file command.c.

{
  unsigned int msn, uid;
  struct Email *e = NULL;
  char *flags = NULL;
  int uid_checked = 0;
  bool server_changes = false;
 
  struct ImapMboxData *mdata = imap_mdata_get(adata->mailbox);
  if (!mdata)
    return;
 
  mutt_debug(LL_DEBUG3, "Handling FETCH\n");
 
  if (!mutt_str_atoui(s, &msn))
  {
    mutt_debug(LL_DEBUG3, "Skipping FETCH response - illegal MSN\n");
    return;
  }
 
  if ((msn < 1) || (msn > imap_msn_highest(&mdata->msn)))
  {
    mutt_debug(LL_DEBUG3, "Skipping FETCH response - MSN %u out of range\n", msn);
    return;
  }
 
  e = imap_msn_get(&mdata->msn, msn - 1);
  if (!e || !e->active)
  {
    mutt_debug(LL_DEBUG3, "Skipping FETCH response - MSN %u not in msn_index\n", msn);
    return;
  }
 
  struct ImapEmailData *edata = imap_edata_get(e);
  if (!edata)
  {
    mutt_debug(LL_DEBUG3, "Skipping FETCH response - MSN %u missing edata\n", msn);
    return;
  }
  /* skip FETCH */
  s = imap_next_word(s);
  s = imap_next_word(s);
 
  if (*s != '(')
  {
    mutt_debug(LL_DEBUG1, "Malformed FETCH response\n");
    return;
  }
  s++;
 
  while (*s)
  {
    SKIPWS(s);
    size_t plen = mutt_istr_startswith(s, "FLAGS");
    if (plen != 0)
    {
      flags = s;
      if (uid_checked)
        break;
 
      s += plen;
      SKIPWS(s);
      if (*s != '(')
      {
        mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
        return;
      }
      s++;
      while (*s && (*s != ')'))
        s++;
      if (*s == ')')
      {
        s++;
      }
      else
      {
        mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
        return;
      }
    }
    else if ((plen = mutt_istr_startswith(s, "UID")))
    {
      s += plen;
      SKIPWS(s);
      if (!mutt_str_atoui(s, &uid))
      {
        mutt_debug(LL_DEBUG1, "Illegal UID.  Skipping update\n");
        return;
      }
      if (uid != edata->uid)
      {
        mutt_debug(LL_DEBUG1, "UID vs MSN mismatch.  Skipping update\n");
        return;
      }
      uid_checked = 1;
      if (flags)
        break;
      s = imap_next_word(s);
    }
    else if ((plen = mutt_istr_startswith(s, "MODSEQ")))
    {
      s += plen;
      SKIPWS(s);
      if (*s != '(')
      {
        mutt_debug(LL_DEBUG1, "bogus MODSEQ response: %s\n", s);
        return;
      }
      s++;
      while (*s && (*s != ')'))
        s++;
      if (*s == ')')
      {
        s++;
      }
      else
      {
        mutt_debug(LL_DEBUG1, "Unterminated MODSEQ response: %s\n", s);
        return;
      }
    }
    else if (*s == ')')
    {
      break; /* end of request */
    }
    else if (*s)
    {
      mutt_debug(LL_DEBUG2, "Only handle FLAGS updates\n");
      break;
    }
  }
 
  if (flags)
  {
    imap_set_flags(adata->mailbox, e, flags, &server_changes);
    if (server_changes)
    {
      /* If server flags could conflict with NeoMutt's flags, reopen the mailbox. */
      if (e->changed)
        mdata->reopen |= IMAP_EXPUNGE_PENDING;
      else
        mdata->check_status |= IMAP_FLAGS_PENDING;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_capability()

static void cmd_parse_capability ( struct ImapAccountData * adata, char * s )

static

Set capability bits according to CAPABILITY response.

Parameters

adata	Imap Account data
s	Command string with capabilities

Definition at line 622 of file command.c.

{
  mutt_debug(LL_DEBUG3, "Handling CAPABILITY\n");
 
  s = imap_next_word(s);
  char *bracket = strchr(s, ']');
  if (bracket)
    *bracket = '\0';
  FREE(&adata->capstr);
  adata->capstr = mutt_str_dup(s);
  adata->capabilities = 0;
 
  while (*s)
  {
    for (size_t i = 0; Capabilities[i]; i++)
    {
      size_t len = mutt_istr_startswith(s, Capabilities[i]);
      if (len != 0 && ((s[len] == '\0') || mutt_isspace(s[len])))
      {
        adata->capabilities |= (1 << i);
        mutt_debug(LL_DEBUG3, " Found capability \"%s\": %zu\n", Capabilities[i], i);
        break;
      }
    }
    s = imap_next_word(s);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_list()

static void cmd_parse_list ( struct ImapAccountData * adata, char * s )

static

Parse a server LIST command (list mailboxes)

Parameters

adata	Imap Account data
s	Command string with folder list

Definition at line 655 of file command.c.

{
  struct ImapList *list = NULL;
  struct ImapList lb = { 0 };
  unsigned int litlen;
 
  if (adata->cmdresult)
    list = adata->cmdresult;
  else
    list = &lb;
 
  memset(list, 0, sizeof(struct ImapList));
 
  /* flags */
  s = imap_next_word(s);
  if (*s != '(')
  {
    mutt_debug(LL_DEBUG1, "Bad LIST response\n");
    return;
  }
  s++;
  while (*s)
  {
    if (mutt_istr_startswith(s, "\\NoSelect"))
      list->noselect = true;
    else if (mutt_istr_startswith(s, "\\NonExistent")) /* rfc5258 */
      list->noselect = true;
    else if (mutt_istr_startswith(s, "\\NoInferiors"))
      list->noinferiors = true;
    else if (mutt_istr_startswith(s, "\\HasNoChildren")) /* rfc5258*/
      list->noinferiors = true;
 
    s = imap_next_word(s);
    if (*(s - 2) == ')')
      break;
  }
 
  /* Delimiter */
  if (!mutt_istr_startswith(s, "NIL"))
  {
    char delimbuf[5] = { 0 }; // worst case: "\\"\0
    snprintf(delimbuf, sizeof(delimbuf), "%s", s);
    imap_unquote_string(delimbuf);
    list->delim = delimbuf[0];
  }
 
  /* Name */
  s = imap_next_word(s);
  /* Notes often responds with literals here. We need a real tokenizer. */
  if (imap_get_literal_count(s, &litlen) == 0)
  {
    if (imap_cmd_step(adata) != IMAP_RES_CONTINUE)
    {
      adata->status = IMAP_FATAL;
      return;
    }
 
    if (strlen(adata->buf) < litlen)
    {
      mutt_debug(LL_DEBUG1, "Error parsing LIST mailbox\n");
      return;
    }
 
    list->name = adata->buf;
    s = list->name + litlen;
    if (s[0] != '\0')
    {
      s[0] = '\0';
      s++;
      SKIPWS(s);
    }
  }
  else
  {
    list->name = s;
    /* Exclude rfc5258 RECURSIVEMATCH CHILDINFO suffix */
    s = imap_next_word(s);
    if (s[0] != '\0')
      s[-1] = '\0';
    imap_unmunge_mbox_name(adata->unicode, list->name);
  }
 
  if (list->name[0] == '\0')
  {
    adata->delim = list->delim;
    mutt_debug(LL_DEBUG3, "Root delimiter: %c\n", adata->delim);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_lsub()

static void cmd_parse_lsub ( struct ImapAccountData * adata, char * s )

static

Parse a server LSUB (list subscribed mailboxes)

Parameters

adata	Imap Account data
s	Command string with folder list

Definition at line 749 of file command.c.

{
  if (adata->cmdresult)
  {
    /* caller will handle response itself */
    cmd_parse_list(adata, s);
    return;
  }
 
  const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
  if (!c_imap_check_subscribed)
    return;
 
  struct ImapList list = { 0 };
 
  adata->cmdresult = &list;
  cmd_parse_list(adata, s);
  adata->cmdresult = NULL;
  /* noselect is for a gmail quirk */
  if (!list.name || list.noselect)
    return;
 
  mutt_debug(LL_DEBUG3, "Subscribing to %s\n", list.name);
 
  struct Buffer *buf = buf_pool_get();
  struct Buffer *err = buf_pool_get();
  struct Url url = { 0 };
 
  account_to_url(&adata->conn->account, &url);
  url.path = list.name;
 
  const char *const c_imap_user = cs_subset_string(NeoMutt->sub, "imap_user");
  if (mutt_str_equal(url.user, c_imap_user))
    url.user = NULL;
  url_tobuffer(&url, buf, U_NO_FLAGS);
 
  if (!mailbox_add_simple(buf_string(buf), err))
    mutt_debug(LL_DEBUG1, "Error adding subscribed mailbox: %s\n", buf_string(err));
 
  buf_pool_release(&buf);
  buf_pool_release(&err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_myrights()

static void cmd_parse_myrights ( struct ImapAccountData * adata, const char * s )

static

Set rights bits according to MYRIGHTS response.

Parameters

adata	Imap Account data
s	Command string with rights info

Definition at line 797 of file command.c.

{
  mutt_debug(LL_DEBUG2, "Handling MYRIGHTS\n");
 
  s = imap_next_word((char *) s);
  s = imap_next_word((char *) s);
 
  /* zero out current rights set */
  adata->mailbox->rights = 0;
 
  while (*s && !mutt_isspace(*s))
  {
    switch (*s)
    {
      case 'a':
        adata->mailbox->rights |= MUTT_ACL_ADMIN;
        break;
      case 'e':
        adata->mailbox->rights |= MUTT_ACL_EXPUNGE;
        break;
      case 'i':
        adata->mailbox->rights |= MUTT_ACL_INSERT;
        break;
      case 'k':
        adata->mailbox->rights |= MUTT_ACL_CREATE;
        break;
      case 'l':
        adata->mailbox->rights |= MUTT_ACL_LOOKUP;
        break;
      case 'p':
        adata->mailbox->rights |= MUTT_ACL_POST;
        break;
      case 'r':
        adata->mailbox->rights |= MUTT_ACL_READ;
        break;
      case 's':
        adata->mailbox->rights |= MUTT_ACL_SEEN;
        break;
      case 't':
        adata->mailbox->rights |= MUTT_ACL_DELETE;
        break;
      case 'w':
        adata->mailbox->rights |= MUTT_ACL_WRITE;
        break;
      case 'x':
        adata->mailbox->rights |= MUTT_ACL_DELMX;
        break;
 
      /* obsolete rights */
      case 'c':
        adata->mailbox->rights |= MUTT_ACL_CREATE | MUTT_ACL_DELMX;
        break;
      case 'd':
        adata->mailbox->rights |= MUTT_ACL_DELETE | MUTT_ACL_EXPUNGE;
        break;
      default:
        mutt_debug(LL_DEBUG1, "Unknown right: %c\n", *s);
    }
    s++;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_mailbox()

static struct Mailbox * find_mailbox ( struct ImapAccountData * adata, const char * name )

static

Find a Mailbox by its name.

Parameters

adata	Imap Account data
name	Mailbox to find

Return values

ptr

Mailbox

Definition at line 865 of file command.c.

{
  if (!adata || !adata->account || !name)
    return NULL;
 
  struct Mailbox **mp = NULL;
  ARRAY_FOREACH(mp, &adata->account->mailboxes)
  {
    struct Mailbox *m = *mp;
 
    struct ImapMboxData *mdata = imap_mdata_get(m);
    if (mdata && mutt_str_equal(name, mdata->name))
      return m;
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_status()

static void cmd_parse_status ( struct ImapAccountData * adata, char * s )

static

Parse status from server.

Parameters

adata	Imap Account data
s	Command string with status info

first cut: just do mailbox update. Later we may wish to cache all mailbox information, even that not desired by mailbox

Definition at line 891 of file command.c.

{
  unsigned int litlen = 0;
 
  char *mailbox = imap_next_word(s);
 
  /* We need a real tokenizer. */
  if (imap_get_literal_count(mailbox, &litlen) == 0)
  {
    if (imap_cmd_step(adata) != IMAP_RES_CONTINUE)
    {
      adata->status = IMAP_FATAL;
      return;
    }
 
    if (strlen(adata->buf) < litlen)
    {
      mutt_debug(LL_DEBUG1, "Error parsing STATUS mailbox\n");
      return;
    }
 
    mailbox = adata->buf;
    s = mailbox + litlen;
    s[0] = '\0';
    s++;
    SKIPWS(s);
  }
  else
  {
    s = imap_next_word(mailbox);
    s[-1] = '\0';
    imap_unmunge_mbox_name(adata->unicode, mailbox);
  }
 
  struct Mailbox *m = find_mailbox(adata, mailbox);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!mdata)
  {
    mutt_debug(LL_DEBUG3, "Received status for an unexpected mailbox: %s\n", mailbox);
    return;
  }
  uint32_t olduv = mdata->uidvalidity;
  unsigned int oldun = mdata->uid_next;
 
  if (*s++ != '(')
  {
    mutt_debug(LL_DEBUG1, "Error parsing STATUS\n");
    return;
  }
  while ((s[0] != '\0') && (s[0] != ')'))
  {
    char *value = imap_next_word(s);
 
    errno = 0;
    const unsigned long ulcount = strtoul(value, &value, 10);
    const bool truncated = ((errno == ERANGE) && (ulcount == ULONG_MAX)) ||
                           ((unsigned int) ulcount != ulcount);
    const unsigned int count = (unsigned int) ulcount;
 
    // we accept truncating a larger value only for UIDVALIDITY, to accommodate
    // IMAP servers that use 64-bits for it. This seems to be what Thunderbird
    // is also doing, see #3830
    if (mutt_str_startswith(s, "UIDVALIDITY"))
    {
      if (truncated)
      {
        mutt_debug(LL_DEBUG1,
                   "UIDVALIDITY [%lu] exceeds 32 bits, "
                   "truncated to [%u]\n",
                   ulcount, count);
      }
      mdata->uidvalidity = count;
    }
    else
    {
      if (truncated)
      {
        mutt_debug(LL_DEBUG1, "Number in [%s] exceeds 32 bits\n", s);
        return;
      }
      else
      {
        if (mutt_str_startswith(s, "MESSAGES"))
          mdata->messages = count;
        else if (mutt_str_startswith(s, "RECENT"))
          mdata->recent = count;
        else if (mutt_str_startswith(s, "UIDNEXT"))
          mdata->uid_next = count;
        else if (mutt_str_startswith(s, "UNSEEN"))
          mdata->unseen = count;
      }
    }
 
    s = value;
    if ((s[0] != '\0') && (*s != ')'))
      s = imap_next_word(s);
  }
  mutt_debug(LL_DEBUG3, "%s (UIDVALIDITY: %u, UIDNEXT: %u) %d messages, %d recent, %d unseen\n",
             mdata->name, mdata->uidvalidity, mdata->uid_next, mdata->messages,
             mdata->recent, mdata->unseen);
 
  mutt_debug(LL_DEBUG3, "Running default STATUS handler\n");
 
  mutt_debug(LL_DEBUG3, "Found %s in mailbox list (OV: %u ON: %u U: %d)\n",
             mailbox, olduv, oldun, mdata->unseen);
 
  bool new_mail = false;
  const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
  if (c_mail_check_recent)
  {
    if ((olduv != 0) && (olduv == mdata->uidvalidity))
    {
      if (oldun < mdata->uid_next)
        new_mail = (mdata->unseen > 0);
    }
    else if ((olduv == 0) && (oldun == 0))
    {
      /* first check per session, use recent. might need a flag for this. */
      new_mail = (mdata->recent > 0);
    }
    else
    {
      new_mail = (mdata->unseen > 0);
    }
  }
  else
  {
    new_mail = (mdata->unseen > 0);
  }
 
  m->has_new = new_mail;
  m->msg_count = mdata->messages;
  m->msg_unread = mdata->unseen;
 
  // force back to keep detecting new mail until the mailbox is opened
  if (m->has_new)
    mdata->uid_next = oldun;
 
  struct EventMailbox ev_m = { m };
  notify_send(m->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_enabled()

static void cmd_parse_enabled ( struct ImapAccountData * adata, const char * s )

static

Record what the server has enabled.

Parameters

adata	Imap Account data
s	Command string containing acceptable encodings

Definition at line 1038 of file command.c.

{
  mutt_debug(LL_DEBUG2, "Handling ENABLED\n");
 
  while ((s = imap_next_word((char *) s)) && (*s != '\0'))
  {
    if (mutt_istr_startswith(s, "UTF8=ACCEPT") || mutt_istr_startswith(s, "UTF8=ONLY"))
    {
      adata->unicode = true;
    }
    if (mutt_istr_startswith(s, "QRESYNC"))
      adata->qresync = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_parse_exists()

static void cmd_parse_exists ( struct ImapAccountData * adata, const char * pn )

static

Parse EXISTS message from serer.

Parameters

adata	Imap Account data
pn	String containing the total number of messages for the selected mailbox

Definition at line 1058 of file command.c.

{
  unsigned int count = 0;
  mutt_debug(LL_DEBUG2, "Handling EXISTS\n");
 
  if (!mutt_str_atoui(pn, &count))
  {
    mutt_debug(LL_DEBUG1, "Malformed EXISTS: '%s'\n", pn);
    return;
  }
 
  struct ImapMboxData *mdata = adata->mailbox->mdata;
  if (!mdata)
    return;
 
  /* new mail arrived */
  if (count < imap_msn_highest(&mdata->msn))
  {
    /* Notes 6.0.3 has a tendency to report fewer messages exist than
     * it should. */
    mutt_debug(LL_DEBUG1, "Message count is out of sync\n");
  }
  else if (count == imap_msn_highest(&mdata->msn))
  {
    /* at least the InterChange server sends EXISTS messages freely,
     * even when there is no new mail */
    mutt_debug(LL_DEBUG3, "superfluous EXISTS message\n");
  }
  else
  {
    mutt_debug(LL_DEBUG2, "New mail in %s - %d messages total\n", mdata->name, count);
    mdata->reopen |= IMAP_NEWMAIL_PENDING;
    mdata->new_mail_count = count;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_handle_untagged()

static int cmd_handle_untagged ( struct ImapAccountData * adata )

static

Fallback parser for otherwise unhandled messages.

Parameters

adata

Imap Account data

Return values

0	Success
-1	Failure

Definition at line 1100 of file command.c.

{
  char *s = imap_next_word(adata->buf);
  char *pn = imap_next_word(s);
 
  const bool c_imap_server_noise = cs_subset_bool(NeoMutt->sub, "imap_server_noise");
  if ((adata->state >= IMAP_SELECTED) && mutt_isdigit(*s))
  {
    /* pn vs. s: need initial seqno */
    pn = s;
    s = imap_next_word(s);
 
    /* EXISTS, EXPUNGE, FETCH are always related to the SELECTED mailbox */
    if (mutt_istr_startswith(s, "EXISTS"))
      cmd_parse_exists(adata, pn);
    else if (mutt_istr_startswith(s, "EXPUNGE"))
      cmd_parse_expunge(adata, pn);
    else if (mutt_istr_startswith(s, "FETCH"))
      cmd_parse_fetch(adata, pn);
  }
  else if ((adata->state >= IMAP_SELECTED) && mutt_istr_startswith(s, "VANISHED"))
  {
    cmd_parse_vanished(adata, pn);
  }
  else if (mutt_istr_startswith(s, "CAPABILITY"))
  {
    cmd_parse_capability(adata, s);
  }
  else if (mutt_istr_startswith(s, "OK [CAPABILITY"))
  {
    cmd_parse_capability(adata, pn);
  }
  else if (mutt_istr_startswith(pn, "OK [CAPABILITY"))
  {
    cmd_parse_capability(adata, imap_next_word(pn));
  }
  else if (mutt_istr_startswith(s, "LIST"))
  {
    cmd_parse_list(adata, s);
  }
  else if (mutt_istr_startswith(s, "LSUB"))
  {
    cmd_parse_lsub(adata, s);
  }
  else if (mutt_istr_startswith(s, "MYRIGHTS"))
  {
    cmd_parse_myrights(adata, s);
  }
  else if (mutt_istr_startswith(s, "SEARCH"))
  {
    cmd_parse_search(adata, s);
  }
  else if (mutt_istr_startswith(s, "STATUS"))
  {
    cmd_parse_status(adata, s);
  }
  else if (mutt_istr_startswith(s, "ENABLED"))
  {
    cmd_parse_enabled(adata, s);
  }
  else if (mutt_istr_startswith(s, "BYE"))
  {
    mutt_debug(LL_DEBUG2, "Handling BYE\n");
 
    /* check if we're logging out */
    if (adata->status == IMAP_BYE)
      return 0;
 
    /* server shut down our connection */
    s += 3;
    SKIPWS(s);
    mutt_error("%s", s);
    cmd_handle_fatal(adata);
 
    return -1;
  }
  else if (c_imap_server_noise && mutt_istr_startswith(s, "NO"))
  {
    mutt_debug(LL_DEBUG2, "Handling untagged NO\n");
 
    /* Display the warning message from the server */
    mutt_error("%s", s + 2);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_cmd_start()

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

Given an IMAP command, send it to the server.

Parameters

adata	Imap Account data
cmdstr	Command string to send

Return values

0	Success
<0	Failure, e.g. IMAP_RES_BAD

If cmdstr is NULL, sends queued commands.

Definition at line 1196 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 1210 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, char);
      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--;
 
    mutt_debug(LL_DEBUG3, "reading from socket (fd=%d, state=%d)\n",
               adata->conn ? adata->conn->fd : -1, adata->state);
    time_t read_start = mutt_date_now();
 
    c = mutt_socket_readln_d(adata->buf + len, adata->blen - len, adata->conn, MUTT_SOCK_LOG_FULL);
 
    time_t read_duration = mutt_date_now() - read_start;
    if (read_duration > 1)
    {
      mutt_debug(LL_DEBUG1, "socket read took %ld seconds\n", (long) read_duration);
    }
 
    if (c <= 0)
    {
      mutt_debug(LL_DEBUG1, "Error reading server response (rc=%d, errno=%d: %s)\n",
                 c, errno, strerror(errno));
      mutt_debug(LL_DEBUG1, "Connection state: fd=%d, state=%d, status=%d\n",
                 adata->conn ? adata->conn->fd : -1, adata->state, adata->status);
      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, char);
    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_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 1352 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 1363 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 1400 of file command.c.

{
  if (!adata)
    return IMAP_EXEC_ERROR;
 
  /* Check connection health before executing command */
  if ((adata->state >= IMAP_AUTHENTICATED) && (adata->last_success > 0))
  {
    time_t now = mutt_date_now();
    time_t idle_time = now - adata->last_success;
 
    if (idle_time > IMAP_CONN_STALE_THRESHOLD)
    {
      mutt_debug(LL_DEBUG2, "Connection idle for %ld seconds, sending NOOP to verify\n",
                 (long) idle_time);
      /* Connection may be stale - let the command proceed and handle any error */
    }
  }
 
  if (flags & IMAP_CMD_SINGLE)
  {
    // Process any existing commands
    if (adata->nextcmd != adata->lastcmd)
      imap_exec(adata, NULL, IMAP_CMD_POLL);
  }
 
  int 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;
  }
 
  /* Track successful command completion for connection health monitoring */
  adata->last_success = mutt_date_now();
 
  return IMAP_EXEC_SUCCESS;
}

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 1483 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_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 1550 of file command.c.

{
  int rc;
 
  mutt_debug(LL_DEBUG2, "Entering IDLE mode for %s\n",
             adata->conn ? adata->conn->account.host : "NULL");
 
  if (cmd_start(adata, "IDLE", IMAP_CMD_POLL) < 0)
  {
    mutt_debug(LL_DEBUG1, "Failed to send IDLE command\n");
    cmd_handle_fatal(adata);
    return -1;
  }
 
  const short c_imap_poll_timeout = cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
  mutt_debug(LL_DEBUG2, "Waiting for IDLE continuation (timeout=%d)\n", c_imap_poll_timeout);
 
  if ((c_imap_poll_timeout > 0) &&
      ((mutt_socket_poll(adata->conn, c_imap_poll_timeout)) == 0))
  {
    mutt_debug(LL_DEBUG1, "IDLE timed out waiting for server continuation response\n");
    mutt_error(_("Connection to %s timed out waiting for IDLE response"),
               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");
    mutt_debug(LL_DEBUG2, "Successfully entered IDLE state\n");
    rc = IMAP_RES_OK;
  }
  if (rc != IMAP_RES_OK)
  {
    mutt_debug(LL_DEBUG1, "IDLE command failed with rc=%d (expected RESPOND=%d)\n",
               rc, IMAP_RES_RESPOND);
    mutt_error(_("IDLE command failed for %s"), adata->conn->account.host);
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

Capabilities

const char* const Capabilities[]

static

Initial value:

= {
  "IMAP4",
  "IMAP4rev1",
  "STATUS",
  "ACL",
  "NAMESPACE",
  "AUTH=CRAM-MD5",
  "AUTH=GSSAPI",
  "AUTH=ANONYMOUS",
  "AUTH=OAUTHBEARER",
  "AUTH=XOAUTH2",
  "STARTTLS",
  "LOGINDISABLED",
  "IDLE",
  "SASL-IR",
  "ENABLE",
  "CONDSTORE",
  "QRESYNC",
  "LIST-EXTENDED",
  "COMPRESS=DEFLATE",
  "X-GM-EXT-1",
  "ID",
  NULL,
}

Server capabilities strings that we understand.

Note

This must be kept in the same order as ImapCaps.

Definition at line 79 of file command.c.

                                          {
  "IMAP4",
  "IMAP4rev1",
  "STATUS",
  "ACL",
  "NAMESPACE",
  "AUTH=CRAM-MD5",
  "AUTH=GSSAPI",
  "AUTH=ANONYMOUS",
  "AUTH=OAUTHBEARER",
  "AUTH=XOAUTH2",
  "STARTTLS",
  "LOGINDISABLED",
  "IDLE",
  "SASL-IR",
  "ENABLE",
  "CONDSTORE",
  "QRESYNC",
  "LIST-EXTENDED",
  "COMPRESS=DEFLATE",
  "X-GM-EXT-1",
  "ID",
  NULL,
};