lib.h File Reference

IMAP network mailbox. More...

#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include <sys/types.h>
#include "core/lib.h"
#include "external.h"

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	imap_init (void)
	Setup feature commands.
int	imap_access (const char *path)
	Check permissions on an IMAP mailbox with a new connection.
enum MxStatus	imap_check_mailbox (struct Mailbox *m, bool force)
	Use the NOOP or IDLE command to poll for new mail.
int	imap_delete_mailbox (struct Mailbox *m, char *path)
	Delete a mailbox.
enum MxStatus	imap_sync_mailbox (struct Mailbox *m, bool expunge, bool close)
	Sync all the changes to the server.
int	imap_path_status (const char *path, bool queue)
	Refresh the number of total and new messages.
int	imap_mailbox_status (struct Mailbox *m, bool queue)
	Refresh the number of total and new messages.
int	imap_subscribe (const char *path, bool subscribe)
	Subscribe to a mailbox.
int	imap_complete (struct Buffer *buf, const char *path)
	Try to complete an IMAP folder path.
int	imap_fast_trash (struct Mailbox *m, const char *dest)
	Use server COPY command to copy deleted messages to trash.
enum MailboxType	imap_path_probe (const char *path, const struct stat *st)
	Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
int	imap_path_canon (struct Buffer *buf)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -.
void	imap_notify_delete_email (struct Mailbox *m, struct Email *e)
	Inform IMAP that an Email has been deleted.
int	imap_browse (const char *path, struct BrowserState *state)
	IMAP hook into the folder browser.
int	imap_mailbox_create (const char *folder)
	Create a new IMAP mailbox.
int	imap_mailbox_rename (const char *path)
	Rename a mailbox.
int	imap_copy_messages (struct Mailbox *m, struct EmailArray *ea, const char *dest, enum MessageSaveOpt save_opt)
	Server COPY messages to another folder.
void	imap_logout_all (void)
	Close all open connections.
int	imap_parse_path (const char *path, struct ConnAccount *cac, char *mailbox, size_t mailboxlen)
	Parse an IMAP mailbox name into ConnAccount, name.
void	imap_pretty_mailbox (char *path, size_t pathlen, const char *folder)
	Prettify an IMAP mailbox name.
int	imap_mxcmp (const char *mx1, const char *mx2)
	Compare mailbox names, giving priority to INBOX.
int	imap_wait_keep_alive (pid_t pid)
	Wait for a process to change state.
void	imap_keep_alive (void)
	Poll the current folder to keep the connection alive.
void	imap_get_parent_path (const char *path, char *buf, size_t buflen)
	Get the path of the parent folder.
void	imap_clean_path (char *path, size_t plen)
	Cleans an IMAP path using imap_fix_path.
bool	imap_search (struct Mailbox *m, const struct PatternList *pat)
	Find messages in mailbox matching a pattern.

Variables
const struct MxOps	MxImapOps
	IMAP Mailbox - Implements MxOps -.

Detailed Description

IMAP network mailbox.

Authors

• Richard Russon
• Pietro Cerutti

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 lib.h.

Function Documentation

imap_init()

void imap_init

(

void

)

Setup feature commands.

Definition at line 95 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:

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 462 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_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 1031 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_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
  if (!force && c_imap_idle && (adata->capabilities & IMAP_CAP_IDLE) &&
      ((adata->state != IMAP_IDLE) || (mutt_date_now() >= adata->lastread + c_imap_keep_alive)))
  {
    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;
 
  if (force)
    m->last_checked = 0; // force a check on the next mx_mbox_check() call
  return check;
}

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

{
  char buf[PATH_MAX + 7];
  char mbox[PATH_MAX] = { 0 };
  struct Url *url = url_parse(path);
  if (!url)
    return -1;
 
  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_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 1470 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))
  {
    struct UidArray uida = ARRAY_HEAD_INITIALIZER;
    select_email_uids(m->emails, m->msg_count, MUTT_DELETED, true, false, &uida);
    ARRAY_SORT(&uida, imap_sort_uid, NULL);
    rc = imap_exec_msg_set(adata, "UID STORE", "+FLAGS.SILENT (\\Deleted)", &uida);
    ARRAY_FREE(&uida);
    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, true);
#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. */
      if (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_mbox(m, e, SAVE_MOVE, TRANSFORM_NONE, m);
        m->append = save_append;
        e->env->changed = false;
      }
    }
  }
 
#ifdef USE_HCACHE
  imap_hcache_close(mdata);
#endif
 
  /* presort here to avoid doing 10 resorts in imap_exec_msg_set */
  emails = MUTT_MEM_MALLOC(m->msg_count, struct Email *);
  memcpy(emails, m->emails, m->msg_count * sizeof(struct Email *));
  mutt_qsort_r(emails, m->msg_count, sizeof(struct Email *), imap_sort_email_uid, NULL);
 
  rc = sync_helper(m, emails, m->msg_count, MUTT_ACL_DELETE, MUTT_DELETED, "\\Deleted");
  if (rc >= 0)
    rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_WRITE, MUTT_FLAG, "\\Flagged");
  if (rc >= 0)
    rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_WRITE, MUTT_OLD, "Old");
  if (rc >= 0)
    rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_SEEN, MUTT_READ, "\\Seen");
  if (rc >= 0)
    rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_WRITE, MUTT_REPLIED, "\\Answered");
 
  FREE(&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 (query_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_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 1171 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 1206 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	(	const 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 1222 of file imap.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
 
  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);
 
  char buf[2048] = { 0 };
  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 };
    size_t len = snprintf(mbox, sizeof(mbox), "%smailboxes ", subscribe ? "" : "un");
    imap_quote_string(mbox + len, sizeof(mbox) - len, path, true);
    struct Buffer *err = buf_pool_get();
    if (parse_rc_line(mbox, err))
      mutt_debug(LL_DEBUG1, "Error adding subscribed mailbox: %s\n", buf_string(err));
    buf_pool_release(&err);
  }
 
  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	(	struct Buffer *	buf,
		const char *	path
	)

Try to complete an IMAP folder path.

Parameters

buf	Buffer for result
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 1274 of file imap.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
  char tmp[2048] = { 0 };
  struct ImapList listresp = { 0 };
  struct Buffer *completion_buf = NULL;
  size_t clen;
  int completions = 0;
  int rc;
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
  {
    buf_strcpy(buf, path);
    return complete_hosts(buf);
  }
 
  /* 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 */
  completion_buf = buf_pool_get();
  buf_strcpy(completion_buf, mdata->name);
  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)
      {
        buf_strcpy(completion_buf, listresp.name);
        completions++;
        continue;
      }
 
      longest_common_prefix(completion_buf, listresp.name, 0);
      completions++;
    }
  } while (rc == IMAP_RES_CONTINUE);
  adata->cmdresult = NULL;
 
  if (completions)
  {
    /* reformat output */
    imap_buf_qualify_path(buf, &adata->conn->account, completion_buf->data);
    buf_pretty_mailbox(buf);
    buf_fix_dptr(buf);
    buf_pool_release(&completion_buf);
    return 0;
  }
 
  buf_pool_release(&completion_buf);
  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 1355 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 = buf_pool_get();
 
  /* 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
  {
    struct UidArray uida = ARRAY_HEAD_INITIALIZER;
    select_email_uids(m->emails, m->msg_count, MUTT_TRASH, false, false, &uida);
    ARRAY_SORT(&uida, imap_sort_uid, NULL);
    rc = imap_exec_msg_set(adata, "UID COPY", dest_mdata->munge_name, &uida);
    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);
    }
    ARRAY_FREE(&uida);
 
    /* 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 &&
          (query_yesorno_help(prompt, MUTT_YES, NeoMutt->sub, "confirm_create") != 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:
  buf_pool_release(&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_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 647 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_browse()

int imap_browse	(	const char *	path,
		struct BrowserState *	state
	)

IMAP hook into the folder browser.

Parameters

path	Current folder
state	BrowserState to populate

Return values

0	Success
-1	Failure

Fill out browser_state, given a current folder to browse

Definition at line 197 of file browse.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapList list = { 0 };
  struct ConnAccount cac = { { 0 } };
  char buf[PATH_MAX + 16];
  char mbox[PATH_MAX] = { 0 };
  char munged_mbox[PATH_MAX] = { 0 };
  const char *list_cmd = NULL;
  int len;
  int n;
  bool showparents = false;
  int rc = -1;
 
  if (imap_parse_path(path, &cac, buf, sizeof(buf)))
  {
    mutt_error(_("%s is an invalid IMAP path"), path);
    return -1;
  }
 
  const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
  cs_subset_str_native_set(NeoMutt->sub, "imap_check_subscribed", false, NULL);
 
  // Pick first mailbox connected to the same server
  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_IMAP);
  struct MailboxNode *np = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    adata = imap_adata_get(np->mailbox);
    // Pick first mailbox connected on the same server
    if (imap_account_match(&adata->conn->account, &cac))
      break;
    adata = NULL;
  }
  neomutt_mailboxlist_clear(&ml);
  if (!adata)
    goto fail;
 
  const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
  if (c_imap_list_subscribed)
  {
    /* RFC3348 section 3 states LSUB is unreliable for hierarchy information.
     * The newer LIST extensions are designed for this.  */
    if (adata->capabilities & IMAP_CAP_LIST_EXTENDED)
      list_cmd = "LIST (SUBSCRIBED RECURSIVEMATCH)";
    else
      list_cmd = "LSUB";
  }
  else
  {
    list_cmd = "LIST";
  }
 
  mutt_message(_("Getting folder list..."));
 
  /* skip check for parents when at the root */
  if (buf[0] == '\0')
  {
    mbox[0] = '\0';
    n = 0;
  }
  else
  {
    imap_fix_path_with_delim(adata->delim, buf, mbox, sizeof(mbox));
    n = mutt_str_len(mbox);
  }
 
  if (n > 0)
  {
    int rc_step;
    mutt_debug(LL_DEBUG3, "mbox: %s\n", mbox);
 
    /* if our target exists and has inferiors, enter it if we
     * aren't already going to */
    imap_munge_mbox_name(adata->unicode, munged_mbox, sizeof(munged_mbox), mbox);
    len = snprintf(buf, sizeof(buf), "%s \"\" %s", list_cmd, munged_mbox);
    if (adata->capabilities & IMAP_CAP_LIST_EXTENDED)
      snprintf(buf + len, sizeof(buf) - len, " RETURN (CHILDREN)");
    imap_cmd_start(adata, buf);
    adata->cmdresult = &list;
    do
    {
      list.name = 0;
      rc_step = imap_cmd_step(adata);
      if ((rc_step == IMAP_RES_CONTINUE) && list.name)
      {
        if (!list.noinferiors && list.name[0] &&
            (imap_mxcmp(list.name, mbox) == 0) && (n < sizeof(mbox) - 1))
        {
          mbox[n++] = list.delim;
          mbox[n] = '\0';
        }
      }
    } while (rc_step == IMAP_RES_CONTINUE);
    adata->cmdresult = NULL;
 
    /* if we're descending a folder, mark it as current in browser_state */
    if (mbox[n - 1] == list.delim)
    {
      showparents = true;
      imap_qualify_path(buf, sizeof(buf), &cac, mbox);
      state->folder = mutt_str_dup(buf);
      n--;
    }
 
    /* Find superiors to list
     * Note: UW-IMAP servers return folder + delimiter when asked to list
     *  folder + delimiter. Cyrus servers don't. So we ask for folder,
     *  and tack on delimiter ourselves.
     * Further note: UW-IMAP servers return nothing when asked for
     *  NAMESPACES without delimiters at the end. Argh! */
    for (n--; n >= 0 && mbox[n] != list.delim; n--)
      ; // do nothing
 
    if (n > 0) /* "aaaa/bbbb/" -> "aaaa" */
    {
      /* forget the check, it is too delicate (see above). Have we ever
       * had the parent not exist? */
      char ctmp = mbox[n];
      mbox[n] = '\0';
 
      if (showparents)
      {
        mutt_debug(LL_DEBUG3, "adding parent %s\n", mbox);
        add_folder(list.delim, mbox, true, false, state, true);
      }
 
      /* if our target isn't a folder, we are in our superior */
      if (!state->folder)
      {
        /* store folder with delimiter */
        mbox[n++] = ctmp;
        ctmp = mbox[n];
        mbox[n] = '\0';
        imap_qualify_path(buf, sizeof(buf), &cac, mbox);
        state->folder = mutt_str_dup(buf);
      }
      mbox[n] = ctmp;
    }
    else
    {
      /* "/bbbb/" -> add  "/", "aaaa/" -> add "" */
      char relpath[2] = { 0 };
      /* folder may be "/" */
      snprintf(relpath, sizeof(relpath), "%c", (n < 0) ? '\0' : adata->delim);
      if (showparents)
        add_folder(adata->delim, relpath, true, false, state, true);
      if (!state->folder)
      {
        imap_qualify_path(buf, sizeof(buf), &cac, relpath);
        state->folder = mutt_str_dup(buf);
      }
    }
  }
 
  /* no namespace, no folder: set folder to host only */
  if (!state->folder)
  {
    imap_qualify_path(buf, sizeof(buf), &cac, NULL);
    state->folder = mutt_str_dup(buf);
  }
 
  mutt_debug(LL_DEBUG3, "Quoting mailbox scan: %s -> ", mbox);
  snprintf(buf, sizeof(buf), "%s%%", mbox);
  imap_munge_mbox_name(adata->unicode, munged_mbox, sizeof(munged_mbox), buf);
  mutt_debug(LL_DEBUG3, "%s\n", munged_mbox);
  len = snprintf(buf, sizeof(buf), "%s \"\" %s", list_cmd, munged_mbox);
  if (adata->capabilities & IMAP_CAP_LIST_EXTENDED)
    snprintf(buf + len, sizeof(buf) - len, " RETURN (CHILDREN)");
  if (browse_add_list_result(adata, buf, state, false))
    goto fail;
 
  if (ARRAY_EMPTY(&state->entry))
  {
    // L10N: (%s) is the name / path of the folder we were trying to browse
    mutt_error(_("No such folder: %s"), path);
    goto fail;
  }
 
  mutt_clear_error();
  rc = 0;
 
fail:
  cs_subset_str_native_set(NeoMutt->sub, "imap_check_subscribed",
                           c_imap_check_subscribed, NULL);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mailbox_create()

int imap_mailbox_create

(

const char *

path

)

Create a new IMAP mailbox.

Parameters

path	Mailbox to create

Return values

0	Success
-1	Failure

Prompt for a new mailbox name, and try to create it

Definition at line 394 of file browse.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
  struct Buffer *name = buf_pool_get();
  int rc = -1;
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
  {
    mutt_debug(LL_DEBUG1, "Couldn't find open connection to %s\n", path);
    goto done;
  }
 
  /* append a delimiter if necessary */
  const size_t n = buf_strcpy(name, mdata->real_name);
  if ((n != 0) && (name->data[n - 1] != adata->delim))
  {
    buf_addch(name, adata->delim);
  }
 
  struct FileCompletionData cdata = { false, NULL, NULL, NULL };
  if (mw_get_field(_("Create mailbox: "), name, MUTT_COMP_NO_FLAGS, HC_MAILBOX,
                   &CompleteMailboxOps, &cdata) != 0)
  {
    goto done;
  }
 
  if (buf_is_empty(name))
  {
    mutt_error(_("Mailbox must have a name"));
    goto done;
  }
 
  if (imap_create_mailbox(adata, buf_string(name)) < 0)
    goto done;
 
  imap_mdata_free((void *) &mdata);
  mutt_message(_("Mailbox created"));
  mutt_sleep(0);
  rc = 0;
 
done:
  imap_mdata_free((void *) &mdata);
  buf_pool_release(&name);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mailbox_rename()

int imap_mailbox_rename

(

const char *

path

)

Rename a mailbox.

Parameters

path	Mailbox to rename

Return values

0	Success
-1	Failure

The user will be prompted for a new name.

Definition at line 449 of file browse.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
  struct Buffer *buf = NULL;
  struct Buffer *newname = NULL;
  int rc = -1;
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
  {
    mutt_debug(LL_DEBUG1, "Couldn't find open connection to %s\n", path);
    goto done;
  }
 
  if (mdata->real_name[0] == '\0')
  {
    mutt_error(_("Can't rename root folder"));
    goto done;
  }
 
  buf = buf_pool_get();
  newname = buf_pool_get();
 
  buf_printf(buf, _("Rename mailbox %s to: "), mdata->name);
  buf_strcpy(newname, mdata->name);
 
  struct FileCompletionData cdata = { false, NULL, NULL, NULL };
  if (mw_get_field(buf_string(buf), newname, MUTT_COMP_NO_FLAGS, HC_MAILBOX,
                   &CompleteMailboxOps, &cdata) != 0)
  {
    goto done;
  }
 
  if (buf_is_empty(newname))
  {
    mutt_error(_("Mailbox must have a name"));
    goto done;
  }
 
  imap_fix_path_with_delim(adata->delim, buf_string(newname), buf->data, buf->dsize);
 
  if (imap_rename_mailbox(adata, mdata->name, buf_string(buf)) < 0)
  {
    mutt_error(_("Rename failed: %s"), imap_get_qualifier(adata->buf));
    goto done;
  }
 
  mutt_message(_("Mailbox renamed"));
  mutt_sleep(0);
  rc = 0;
 
done:
  imap_mdata_free((void *) &mdata);
  buf_pool_release(&buf);
  buf_pool_release(&newname);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_copy_messages()

int imap_copy_messages	(	struct Mailbox *	m,
		struct EmailArray *	ea,
		const char *	dest,
		enum MessageSaveOpt	save_opt
	)

Server COPY messages to another folder.

Parameters

m	Mailbox
ea	Array of Emails to copy
dest	Destination folder
save_opt	Copy or move, e.g. SAVE_MOVE

Return values

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

Definition at line 1687 of file message.c.

{
  if (!m || !ea || ARRAY_EMPTY(ea) || !dest)
    return -1;
 
  char buf[PATH_MAX] = { 0 };
  char mbox[PATH_MAX] = { 0 };
  char mmbox[PATH_MAX] = { 0 };
  char prompt[PATH_MAX + 64];
  int rc;
  struct ConnAccount cac = { { 0 } };
  enum QuadOption err_continue = MUTT_NO;
  int triedcreate = 0;
  struct Email *e_cur = *ARRAY_GET(ea, 0);
  bool single = (ARRAY_SIZE(ea) == 1);
  struct ImapAccountData *adata = imap_adata_get(m);
 
  if (single && e_cur->attach_del)
  {
    mutt_debug(LL_DEBUG3, "#1 Message contains attachments to be deleted\n");
    return 1;
  }
 
  if (imap_parse_path(dest, &cac, buf, sizeof(buf)))
  {
    mutt_debug(LL_DEBUG1, "bad destination %s\n", dest);
    return -1;
  }
 
  /* check that the save-to folder is in the same account */
  if (!imap_account_match(&adata->conn->account, &cac))
  {
    mutt_debug(LL_DEBUG3, "%s not same server as %s\n", dest, mailbox_path(m));
    return 1;
  }
 
  imap_fix_path_with_delim(adata->delim, buf, mbox, sizeof(mbox));
  if (*mbox == '\0')
    mutt_str_copy(mbox, "INBOX", sizeof(mbox));
  imap_munge_mbox_name(adata->unicode, mmbox, sizeof(mmbox), mbox);
 
  /* loop in case of TRYCREATE */
  struct Buffer *cmd = buf_pool_get();
  struct Buffer *sync_cmd = buf_pool_get();
  do
  {
    buf_reset(sync_cmd);
    buf_reset(cmd);
 
    if (single)
    {
      mutt_message(_("Copying message %d to %s..."), e_cur->index + 1, mbox);
      buf_add_printf(cmd, "UID COPY %u %s", imap_edata_get(e_cur)->uid, mmbox);
 
      if (e_cur->active && e_cur->changed)
      {
        rc = imap_sync_message_for_copy(m, e_cur, sync_cmd, &err_continue);
        if (rc < 0)
        {
          mutt_debug(LL_DEBUG1, "#2 could not sync\n");
          goto out;
        }
      }
      rc = imap_exec(adata, buf_string(cmd), IMAP_CMD_QUEUE);
      if (rc != IMAP_EXEC_SUCCESS)
      {
        mutt_debug(LL_DEBUG1, "#2 could not queue copy\n");
        goto out;
      }
    }
    else /* copy tagged messages */
    {
      /* if any messages have attachments to delete, fall through to FETCH
       * and APPEND. TODO: Copy what we can with COPY, fall through for the
       * remainder. */
      struct Email **ep = NULL;
      ARRAY_FOREACH(ep, ea)
      {
        struct Email *e = *ep;
        if (e->attach_del)
        {
          mutt_debug(LL_DEBUG3, "#2 Message contains attachments to be deleted\n");
          rc = 1;
          goto out;
        }
 
        if (e->active && e->changed)
        {
          rc = imap_sync_message_for_copy(m, e, sync_cmd, &err_continue);
          if (rc < 0)
          {
            mutt_debug(LL_DEBUG1, "#1 could not sync\n");
            goto out;
          }
        }
      }
 
      struct UidArray uida = ARRAY_HEAD_INITIALIZER;
      emails_to_uid_array(ea, &uida);
      rc = imap_exec_msg_set(adata, "UID COPY", mmbox, &uida);
      ARRAY_FREE(&uida);
 
      if (rc == 0)
      {
        mutt_debug(LL_DEBUG1, "No messages tagged\n");
        rc = -1;
        goto out;
      }
      else if (rc < 0)
      {
        mutt_debug(LL_DEBUG1, "#1 could not queue copy\n");
        goto out;
      }
      else
      {
        mutt_message(ngettext("Copying %d message to %s...", "Copying %d messages to %s...", rc),
                     rc, mbox);
      }
    }
 
    /* 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", mbox);
        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?"), mbox);
      const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
      if (c_confirm_create &&
          (query_yesorno_help(prompt, MUTT_YES, NeoMutt->sub, "confirm_create") != MUTT_YES))
      {
        mutt_clear_error();
        goto out;
      }
      if (imap_create_mailbox(adata, mbox) < 0)
        break;
      triedcreate = 1;
    }
  } while (rc == IMAP_EXEC_ERROR);
 
  if (rc != 0)
  {
    imap_error("imap_copy_messages", adata->buf);
    goto out;
  }
 
  /* cleanup */
  if (save_opt == SAVE_MOVE)
  {
    struct Email **ep = NULL;
    ARRAY_FOREACH(ep, ea)
    {
      struct Email *e = *ep;
      mutt_set_flag(m, e, MUTT_DELETE, true, true);
      mutt_set_flag(m, e, MUTT_PURGE, true, true);
    }
  }
 
  rc = 0;
 
out:
  buf_pool_release(&cmd);
  buf_pool_release(&sync_cmd);
 
  return (rc < 0) ? -1 : rc;
}

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 553 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_parse_path()

int imap_parse_path	(	const char *	path,
		struct ConnAccount *	cac,
		char *	mailbox,
		size_t	mailboxlen
	)

Parse an IMAP mailbox name into ConnAccount, name.

Parameters

path	Mailbox path to parse
cac	Account credentials
mailbox	Buffer for mailbox name
mailboxlen	Length of buffer

Return values

0	Success
-1	Failure

Given an IMAP mailbox name, return host, port and a path IMAP servers will recognize.

Definition at line 477 of file util.c.

{
  static unsigned short ImapPort = 0;
  static unsigned short ImapsPort = 0;
 
  if (ImapPort == 0)
  {
    struct servent *service = getservbyname("imap", "tcp");
    if (service)
      ImapPort = ntohs(service->s_port);
    else
      ImapPort = IMAP_PORT;
    mutt_debug(LL_DEBUG3, "Using default IMAP port %d\n", ImapPort);
  }
 
  if (ImapsPort == 0)
  {
    struct servent *service = getservbyname("imaps", "tcp");
    if (service)
      ImapsPort = ntohs(service->s_port);
    else
      ImapsPort = IMAP_SSL_PORT;
    mutt_debug(LL_DEBUG3, "Using default IMAPS port %d\n", ImapsPort);
  }
 
  /* Defaults */
  cac->port = ImapPort;
  cac->type = MUTT_ACCT_TYPE_IMAP;
  cac->service = "imap";
  cac->get_field = imap_get_field;
 
  struct Url *url = url_parse(path);
  if (!url)
    return -1;
 
  if ((url->scheme != U_IMAP) && (url->scheme != U_IMAPS))
  {
    url_free(&url);
    return -1;
  }
 
  if ((account_from_url(cac, url) < 0) || (cac->host[0] == '\0'))
  {
    url_free(&url);
    return -1;
  }
 
  if (url->scheme == U_IMAPS)
    cac->flags |= MUTT_ACCT_SSL;
 
  mutt_str_copy(mailbox, url->path, mailboxlen);
 
  url_free(&url);
 
  if ((cac->flags & MUTT_ACCT_SSL) && !(cac->flags & MUTT_ACCT_PORT))
    cac->port = ImapsPort;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_pretty_mailbox()

void imap_pretty_mailbox	(	char *	path,
		size_t	pathlen,
		const char *	folder
	)

Prettify an IMAP mailbox name.

Parameters

path	Mailbox name to be tidied
pathlen	Length of path
folder	Path to use for '+' abbreviations

Called by mutt_pretty_mailbox() to make IMAP paths look nice.

Definition at line 584 of file util.c.

{
  struct ConnAccount cac_target = { { 0 } };
  struct ConnAccount cac_home = { { 0 } };
  struct Url url = { 0 };
  const char *delim = NULL;
  int tlen;
  int hlen = 0;
  bool home_match = false;
  char target_mailbox[1024] = { 0 };
  char home_mailbox[1024] = { 0 };
 
  if (imap_parse_path(path, &cac_target, target_mailbox, sizeof(target_mailbox)) < 0)
    return;
 
  if (imap_path_probe(folder, NULL) != MUTT_IMAP)
    goto fallback;
 
  if (imap_parse_path(folder, &cac_home, home_mailbox, sizeof(home_mailbox)) < 0)
    goto fallback;
 
  tlen = mutt_str_len(target_mailbox);
  hlen = mutt_str_len(home_mailbox);
 
  /* check whether we can do '+' substitution */
  if (tlen && imap_account_match(&cac_home, &cac_target) &&
      mutt_strn_equal(home_mailbox, target_mailbox, hlen))
  {
    const char *const c_imap_delim_chars = cs_subset_string(NeoMutt->sub, "imap_delim_chars");
    if (hlen == 0)
    {
      home_match = true;
    }
    else if (c_imap_delim_chars)
    {
      for (delim = c_imap_delim_chars; *delim != '\0'; delim++)
        if (target_mailbox[hlen] == *delim)
          home_match = true;
    }
  }
 
  /* do the '+' substitution */
  if (home_match)
  {
    *path++ = '+';
    /* copy remaining path, skipping delimiter */
    if (hlen != 0)
      hlen++;
    memcpy(path, target_mailbox + hlen, tlen - hlen);
    path[tlen - hlen] = '\0';
    return;
  }
 
fallback:
  account_to_url(&cac_target, &url);
  url.path = target_mailbox;
  url_tostring(&url, path, pathlen, U_NO_FLAGS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mxcmp()

int imap_mxcmp	(	const char *	mx1,
		const char *	mx2
	)

Compare mailbox names, giving priority to INBOX.

Parameters

mx1	First mailbox name
mx2	Second mailbox name

Return values

<0	First mailbox precedes Second mailbox
0	Mailboxes are the same
>0	Second mailbox precedes First mailbox

Like a normal sort function except that "INBOX" will be sorted to the beginning of the list.

Definition at line 548 of file util.c.

{
  char *b1 = NULL;
  char *b2 = NULL;
  int rc;
 
  if (!mx1 || (*mx1 == '\0'))
    mx1 = "INBOX";
  if (!mx2 || (*mx2 == '\0'))
    mx2 = "INBOX";
  if (mutt_istr_equal(mx1, "INBOX") && mutt_istr_equal(mx2, "INBOX"))
  {
    return 0;
  }
 
  b1 = MUTT_MEM_MALLOC(strlen(mx1) + 1, char);
  b2 = MUTT_MEM_MALLOC(strlen(mx2) + 1, char);
 
  imap_fix_path(mx1, b1, strlen(mx1) + 1);
  imap_fix_path(mx2, b2, strlen(mx2) + 1);
 
  rc = mutt_str_cmp(b1, b2);
  FREE(&b1);
  FREE(&b2);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_wait_keep_alive()

int imap_wait_keep_alive

(

pid_t

pid

)

Wait for a process to change state.

Parameters

pid	Process ID to listen to

Return values

num	'wstatus' from waitpid()

Definition at line 1018 of file util.c.

{
  struct sigaction oldalrm = { 0 };
  struct sigaction act = { 0 };
  sigset_t oldmask = { 0 };
  int rc;
 
  const bool c_imap_passive = cs_subset_bool(NeoMutt->sub, "imap_passive");
  cs_subset_str_native_set(NeoMutt->sub, "imap_passive", true, NULL);
  OptKeepQuiet = true;
 
  sigprocmask(SIG_SETMASK, NULL, &oldmask);
 
  sigemptyset(&act.sa_mask);
  act.sa_handler = mutt_sig_empty_handler;
#ifdef SA_INTERRUPT
  act.sa_flags = SA_INTERRUPT;
#else
  act.sa_flags = 0;
#endif
 
  sigaction(SIGALRM, &act, &oldalrm);
 
  const short c_imap_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
  alarm(c_imap_keep_alive);
  while ((waitpid(pid, &rc, 0) < 0) && (errno == EINTR))
  {
    alarm(0); /* cancel a possibly pending alarm */
    imap_keep_alive();
    alarm(c_imap_keep_alive);
  }
 
  alarm(0); /* cancel a possibly pending alarm */
 
  sigaction(SIGALRM, &oldalrm, NULL);
  sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
  OptKeepQuiet = false;
  cs_subset_str_native_set(NeoMutt->sub, "imap_passive", c_imap_passive, NULL);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_keep_alive()

void imap_keep_alive

(

void

)

Poll the current folder to keep the connection alive.

Definition at line 994 of file util.c.

{
  time_t now = mutt_date_now();
  struct Account *np = NULL;
  const short c_imap_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    if (np->type != MUTT_IMAP)
      continue;
 
    struct ImapAccountData *adata = np->adata;
    if (!adata || !adata->mailbox)
      continue;
 
    if ((adata->state >= IMAP_AUTHENTICATED) && (now >= (adata->lastread + c_imap_keep_alive)))
      imap_check_mailbox(adata->mailbox, true);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_get_parent_path()

void imap_get_parent_path	(	const char *	path,
		char *	buf,
		size_t	buflen
	)

Get the path of the parent folder.

Parameters

path	Mailbox whose parent is to be determined
buf	Buffer for the result
buflen	Length of the buffer

Provided an imap path, returns in buf the parent directory if existent. Else returns the same path.

Definition at line 164 of file util.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
  char mbox[1024] = { 0 };
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
  {
    mutt_str_copy(buf, path, buflen);
    return;
  }
 
  /* Gets the parent mbox in mbox */
  imap_get_parent(mdata->name, adata->delim, mbox, sizeof(mbox));
 
  /* Returns a fully qualified IMAP url */
  imap_qualify_path(buf, buflen, &adata->conn->account, mbox);
  imap_mdata_free((void *) &mdata);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_clean_path()

void imap_clean_path	(	char *	path,
		size_t	plen
	)

Cleans an IMAP path using imap_fix_path.

Parameters

path	Path to be cleaned
plen	Length of the buffer

Does it in place.

Definition at line 191 of file util.c.

{
  struct ImapAccountData *adata = NULL;
  struct ImapMboxData *mdata = NULL;
 
  if (imap_adata_find(path, &adata, &mdata) < 0)
    return;
 
  /* Returns a fully qualified IMAP url */
  imap_qualify_path(path, plen, &adata->conn->account, mdata->name);
  imap_mdata_free((void *) &mdata);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_search()

bool imap_search	(	struct Mailbox *	m,
		const struct PatternList *	pat
	)

Find messages in mailbox matching a pattern.

Parameters

m	Mailbox
pat	Pattern to match

Return values

true	Success
false	Failure

Definition at line 227 of file search.c.

{
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    e->matched = false;
  }
 
  if (check_pattern_list(pat) == 0)
    return true;
 
  struct Buffer *buf = buf_pool_get();
  buf_addstr(buf, "UID SEARCH ");
 
  struct ImapAccountData *adata = imap_adata_get(m);
  const bool ok = compile_search(adata, SLIST_FIRST(pat), buf) &&
                  (imap_exec(adata, buf_string(buf), IMAP_CMD_NO_FLAGS) == IMAP_EXEC_SUCCESS);
 
  buf_pool_release(&buf);
  return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function: