util.c File Reference

IMAP helper functions. More...

#include "config.h"
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <netdb.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.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 "lib.h"
#include "bcache/lib.h"
#include "question/lib.h"
#include "adata.h"
#include "edata.h"
#include "globals.h"
#include "mdata.h"
#include "msn.h"
#include "mutt_account.h"
#include "hcache/lib.h"

Include dependency graph for util.c:

Go to the source code of this file.

Functions
int	imap_adata_find (const char *path, struct ImapAccountData **adata, struct ImapMboxData **mdata)
	Find the Account data for this path. More...
void	imap_mdata_cache_reset (struct ImapMboxData *mdata)
	Release and clear cache data of ImapMboxData structure. More...
void	imap_get_parent (const char *mbox, char delim, char *buf, size_t buflen)
	Get an IMAP folder's parent. More...
void	imap_get_parent_path (const char *path, char *buf, size_t buflen)
	Get the path of the parent folder. More...
void	imap_clean_path (char *path, size_t plen)
	Cleans an IMAP path using imap_fix_path. More...
static const char *	imap_get_field (enum ConnAccountField field, void *gf_data)
	Get connection login credentials - Implements ConnAccount::get_field() More...
static void	imap_msn_index_to_uid_seqset (struct Buffer *buf, struct ImapMboxData *mdata)
	Convert MSN index of UIDs to Seqset. More...
static void	imap_hcache_namer (const char *path, struct Buffer *dest)
	Generate a filename for the header cache - Implements hcache_namer_t -. More...
void	imap_hcache_open (struct ImapAccountData *adata, struct ImapMboxData *mdata)
	Open a header cache. More...
void	imap_hcache_close (struct ImapMboxData *mdata)
	Close the header cache. More...
struct Email *	imap_hcache_get (struct ImapMboxData *mdata, unsigned int uid)
	Get a header cache entry by its UID. More...
int	imap_hcache_put (struct ImapMboxData *mdata, struct Email *e)
	Add an entry to the header cache. More...
int	imap_hcache_del (struct ImapMboxData *mdata, unsigned int uid)
	Delete an item from the header cache. More...
int	imap_hcache_store_uid_seqset (struct ImapMboxData *mdata)
	Store a UID Sequence Set in the header cache. More...
int	imap_hcache_clear_uid_seqset (struct ImapMboxData *mdata)
	Delete a UID Sequence Set from the header cache. More...
char *	imap_hcache_get_uid_seqset (struct ImapMboxData *mdata)
	Get a UID Sequence Set from the header cache. More...
int	imap_parse_path (const char *path, struct ConnAccount *cac, char *mailbox, size_t mailboxlen)
	Parse an IMAP mailbox name into ConnAccount, name. More...
int	imap_mxcmp (const char *mx1, const char *mx2)
	Compare mailbox names, giving priority to INBOX. More...
void	imap_pretty_mailbox (char *path, size_t pathlen, const char *folder)
	Prettify an IMAP mailbox name. More...
enum QuadOption	imap_continue (const char *msg, const char *resp)
	Display a message and ask the user if they want to go on. More...
void	imap_error (const char *where, const char *msg)
	Show an error and abort. More...
char *	imap_fix_path (char delim, const char *mailbox, char *path, size_t plen)
	Fix up the imap path. More...
void	imap_cachepath (char delim, const char *mailbox, struct Buffer *dest)
	Generate a cache path for a mailbox. More...
int	imap_get_literal_count (const char *buf, unsigned int *bytes)
	Write number of bytes in an IMAP literal into bytes. More...
char *	imap_get_qualifier (char *buf)
	Get the qualifier from a tagged response. More...
char *	imap_next_word (char *s)
	Find where the next IMAP word begins. More...
void	imap_qualify_path (char *buf, size_t buflen, struct ConnAccount *cac, char *path)
	Make an absolute IMAP folder target. More...
void	imap_quote_string (char *dest, size_t dlen, const char *src, bool quote_backtick)
	Quote string according to IMAP rules. More...
void	imap_unquote_string (char *s)
	Equally stupid unquoting routine. More...
void	imap_munge_mbox_name (bool unicode, char *dest, size_t dlen, const char *src)
	Quote awkward characters in a mailbox name. More...
void	imap_unmunge_mbox_name (bool unicode, char *s)
	Remove quoting from a mailbox name. More...
void	imap_keepalive (void)
	Poll the current folder to keep the connection alive. More...
int	imap_wait_keepalive (pid_t pid)
	Wait for a process to change state. More...
void	imap_allow_reopen (struct Mailbox *m)
	Allow re-opening a folder upon expunge. More...
void	imap_disallow_reopen (struct Mailbox *m)
	Disallow re-opening a folder upon expunge. More...
bool	imap_account_match (const struct ConnAccount *a1, const struct ConnAccount *a2)
	Compare two Accounts. More...
struct SeqsetIterator *	mutt_seqset_iterator_new (const char *seqset)
	Create a new Sequence Set Iterator. More...
int	mutt_seqset_iterator_next (struct SeqsetIterator *iter, unsigned int *next)
	Get the next UID from a Sequence Set. More...
void	mutt_seqset_iterator_free (struct SeqsetIterator **ptr)
	Free a Sequence Set Iterator. More...

Detailed Description

IMAP helper functions.

Authors

• Michael R. Elkins
• Brandon Long
• Brendan Cully
• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file util.c.

Function Documentation

imap_adata_find()

int imap_adata_find	(	const char *	path,
		struct ImapAccountData **	adata,
		struct ImapMboxData **	mdata
	)

Find the Account data for this path.

Parameters

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

Return values

0	Success
-1	Failure

Definition at line 71 of file util.c.

{
  struct ConnAccount cac = { { 0 } };
  struct ImapAccountData *tmp_adata = NULL;
  char tmp[1024] = { 0 };
 
  if (imap_parse_path(path, &cac, tmp, sizeof(tmp)) < 0)
    return -1;
 
  struct Account *np = NULL;
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    if (np->type != MUTT_IMAP)
      continue;
 
    tmp_adata = np->adata;
    if (!tmp_adata)
      continue;
    if (imap_account_match(&tmp_adata->conn->account, &cac))
    {
      *mdata = imap_mdata_new(tmp_adata, tmp);
      *adata = tmp_adata;
      return 0;
    }
  }
  mutt_debug(LL_DEBUG3, "no ImapAccountData found\n");
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mdata_cache_reset()

void imap_mdata_cache_reset

(

struct ImapMboxData *

mdata

)

Release and clear cache data of ImapMboxData structure.

Parameters

mdata

Imap Mailbox data

Definition at line 105 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_get_parent()

void imap_get_parent	(	const char *	mbox,
		char	delim,
		char *	buf,
		size_t	buflen
	)

Get an IMAP folder's parent.

Parameters

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

Definition at line 119 of file util.c.

{
  /* Make a copy of the mailbox name, but only if the pointers are different */
  if (mbox != buf)
    mutt_str_copy(buf, mbox, buflen);
 
  int n = mutt_str_len(buf);
 
  /* Let's go backwards until the next delimiter
   *
   * If buf[n] is a '/', the first n-- will allow us
   * to ignore it. If it isn't, then buf looks like
   * "/aaaaa/bbbb". There is at least one "b", so we can't skip
   * the "/" after the 'a's.
   *
   * If buf == '/', then n-- => n == 0, so the loop ends
   * immediately */
  for (n--; (n >= 0) && (buf[n] != delim); n--)
    ; // do nothing
 
  /* We stopped before the beginning. There is a trailing slash.  */
  if (n > 0)
  {
    /* Strip the trailing delimiter.  */
    buf[n] = '\0';
  }
  else
  {
    buf[0] = (n == 0) ? delim : '\0';
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 160 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 187 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_get_field()

static const char * imap_get_field ( enum ConnAccountField  field, void *  gf_data  )

static

Get connection login credentials - Implements ConnAccount::get_field()

Definition at line 203 of file util.c.

{
  switch (field)
  {
    case MUTT_CA_LOGIN:
      return cs_subset_string(NeoMutt->sub, "imap_login");
    case MUTT_CA_USER:
      return cs_subset_string(NeoMutt->sub, "imap_user");
    case MUTT_CA_PASS:
      return cs_subset_string(NeoMutt->sub, "imap_pass");
    case MUTT_CA_OAUTH_CMD:
      return cs_subset_string(NeoMutt->sub, "imap_oauth_refresh_command");
    case MUTT_CA_HOST:
    default:
      return NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_msn_index_to_uid_seqset()

static void imap_msn_index_to_uid_seqset ( struct Buffer *  buf, struct ImapMboxData *  mdata  )

static

Convert MSN index of UIDs to Seqset.

Parameters

buf	Buffer for the result
mdata	Imap Mailbox data

Generates a seqseq of the UIDs in msn_index to persist in the header cache. Empty spots are stored as 0.

Definition at line 230 of file util.c.

{
  int first = 1, state = 0;
  unsigned int cur_uid = 0, last_uid = 0;
  unsigned int range_begin = 0, range_end = 0;
  const size_t max_msn = imap_msn_highest(&mdata->msn);
 
  for (unsigned int msn = 1; msn <= max_msn + 1; msn++)
  {
    bool match = false;
    if (msn <= max_msn)
    {
      struct Email *e_cur = imap_msn_get(&mdata->msn, msn - 1);
      cur_uid = e_cur ? imap_edata_get(e_cur)->uid : 0;
      if (!state || (cur_uid && ((cur_uid - 1) == last_uid)))
        match = true;
      last_uid = cur_uid;
    }
 
    if (match)
    {
      switch (state)
      {
        case 1: /* single: convert to a range */
          state = 2;
          /* fall through */
        case 2: /* extend range ending */
          range_end = cur_uid;
          break;
        default:
          state = 1;
          range_begin = cur_uid;
          break;
      }
    }
    else if (state)
    {
      if (first)
        first = 0;
      else
        mutt_buffer_addch(buf, ',');
 
      if (state == 1)
        mutt_buffer_add_printf(buf, "%u", range_begin);
      else if (state == 2)
        mutt_buffer_add_printf(buf, "%u:%u", range_begin, range_end);
 
      state = 1;
      range_begin = cur_uid;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_open()

void imap_hcache_open	(	struct ImapAccountData *	adata,
		struct ImapMboxData *	mdata
	)

Open a header cache.

Parameters

adata	Imap Account data
mdata	Imap Mailbox data

Definition at line 296 of file util.c.

{
  if (!adata || !mdata)
    return;
 
  if (mdata->hcache)
    return;
 
  struct HeaderCache *hc = NULL;
  struct Buffer *mbox = mutt_buffer_pool_get();
  struct Buffer *cachepath = mutt_buffer_pool_get();
 
  imap_cachepath(adata->delim, mdata->name, mbox);
 
  if (strstr(mutt_buffer_string(mbox), "/../") ||
      mutt_str_equal(mutt_buffer_string(mbox), "..") ||
      mutt_strn_equal(mutt_buffer_string(mbox), "../", 3))
  {
    goto cleanup;
  }
  size_t len = mutt_buffer_len(mbox);
  if ((len > 3) && (strcmp(mutt_buffer_string(mbox) + len - 3, "/..") == 0))
    goto cleanup;
 
  struct Url url = { 0 };
  mutt_account_tourl(&adata->conn->account, &url);
  url.path = mbox->data;
  url_tobuffer(&url, cachepath, U_PATH);
 
  const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  hc = mutt_hcache_open(c_header_cache, mutt_buffer_string(cachepath), imap_hcache_namer);
 
cleanup:
  mutt_buffer_pool_release(&mbox);
  mutt_buffer_pool_release(&cachepath);
  mdata->hcache = hc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_close()

void imap_hcache_close

(

struct ImapMboxData *

mdata

)

Close the header cache.

Parameters

mdata

Imap Mailbox data

Definition at line 338 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_get()

struct Email * imap_hcache_get	(	struct ImapMboxData *	mdata,
		unsigned int	uid
	)

Get a header cache entry by its UID.

Parameters

mdata	Imap Mailbox data
uid	UID to find

Return values

ptr	Email
NULL	Failure

Definition at line 354 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_put()

int imap_hcache_put	(	struct ImapMboxData *	mdata,
		struct Email *	e
	)

Add an entry to the header cache.

Parameters

mdata	Imap Mailbox data
e	Email

Return values

0	Success
-1	Failure

Definition at line 379 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  char key[16] = { 0 };
 
  sprintf(key, "/%u", imap_edata_get(e)->uid);
  return mutt_hcache_store(mdata->hcache, key, mutt_str_len(key), e, mdata->uidvalidity);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_del()

int imap_hcache_del	(	struct ImapMboxData *	mdata,
		unsigned int	uid
	)

Delete an item from the header cache.

Parameters

mdata	Imap Mailbox data
uid	UID of entry to delete

Return values

0	Success
-1	Failure

Definition at line 397 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  char key[16] = { 0 };
 
  sprintf(key, "/%u", uid);
  return mutt_hcache_delete_record(mdata->hcache, key, mutt_str_len(key));
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_store_uid_seqset()

int imap_hcache_store_uid_seqset

(

struct ImapMboxData *

mdata

)

Store a UID Sequence Set in the header cache.

Parameters

mdata

Imap Mailbox data

Return values

0	Success
-1	Error

Definition at line 414 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  /* The seqset is likely large.  Preallocate to reduce reallocs */
  struct Buffer buf = mutt_buffer_make(8192);
  imap_msn_index_to_uid_seqset(&buf, mdata);
 
  int rc = mutt_hcache_store_raw(mdata->hcache, "/UIDSEQSET", 10, buf.data,
                                 mutt_buffer_len(&buf) + 1);
  mutt_debug(LL_DEBUG3, "Stored /UIDSEQSET %s\n", buf.data);
  mutt_buffer_dealloc(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_clear_uid_seqset()

int imap_hcache_clear_uid_seqset

(

struct ImapMboxData *

mdata

)

Delete a UID Sequence Set from the header cache.

Parameters

mdata

Imap Mailbox data

Return values

0	Success
-1	Error

Definition at line 436 of file util.c.

{
  if (!mdata->hcache)
    return -1;
 
  return mutt_hcache_delete_record(mdata->hcache, "/UIDSEQSET", 10);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_hcache_get_uid_seqset()

char * imap_hcache_get_uid_seqset

(

struct ImapMboxData *

mdata

)

Get a UID Sequence Set from the header cache.

Parameters

mdata

Imap Mailbox data

Return values

ptr	UID Sequence Set
NULL	Error

Definition at line 450 of file util.c.

{
  if (!mdata->hcache)
    return NULL;
 
  char *seqset = mutt_hcache_fetch_str(mdata->hcache, "/UIDSEQSET", 10);
  mutt_debug(LL_DEBUG3, "Retrieved /UIDSEQSET %s\n", NONULL(seqset));
 
  return seqset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_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 474 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 ((mutt_account_fromurl(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_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 545 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);
  b2 = mutt_mem_malloc(strlen(mx2) + 1);
 
  imap_fix_path('\0', mx1, b1, strlen(mx1) + 1);
  imap_fix_path('\0', 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_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 581 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:
  mutt_account_tourl(&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_continue()

enum QuadOption imap_continue	(	const char *	msg,
		const char *	resp
	)

Display a message and ask the user if they want to go on.

Parameters

msg	Location of the error
resp	Message for user

Return values

QuadOption

Result, e.g. MUTT_NO

Definition at line 644 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_error()

void imap_error	(	const char *	where,
		const char *	msg
	)

Show an error and abort.

Parameters

where	Location of the error
msg	Message for user

Definition at line 655 of file util.c.

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

Here is the caller graph for this function:

imap_fix_path()

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

Fix up the imap path.

Parameters

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

Return values

ptr	Fixed-up path

Note

if delim is '\0', the first character in mailbox matching any of the characters in $imap_delim_chars is used as a delimiter.

This is necessary because the rest of neomutt assumes a hierarchy delimiter of '/', which is not necessarily true in IMAP. Additionally, the filesystem converts multiple hierarchy delimiters into a single one, ie "///" is equal to "/". IMAP servers are not required to do this. Moreover, IMAP servers may dislike the path ending with the delimiter.

Definition at line 677 of file util.c.

{
  int i = 0;
  for (; mailbox && *mailbox && (i < plen - 1); i++)
  {
    const char *const c_imap_delim_chars = cs_subset_string(NeoMutt->sub, "imap_delim_chars");
    if (*mailbox == delim || (!delim && strchr(NONULL(c_imap_delim_chars), *mailbox)))
    {
      delim = *mailbox;
      /* Skip multiple occurrences of delim */
      while (*mailbox && *(mailbox + 1) == delim)
        mailbox++;
    }
    path[i] = *mailbox++;
  }
 
  /* Do not terminate with a delimiter */
  if (i && path[i - 1] == delim)
    i--;
 
  /* Ensure null termination */
  path[i] = '\0';
  return path;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_cachepath()

void imap_cachepath	(	char	delim,
		const char *	mailbox,
		struct Buffer *	dest
	)

Generate a cache path for a mailbox.

Parameters

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

Definition at line 708 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_get_literal_count()

int imap_get_literal_count	(	const char *	buf,
		unsigned int *	bytes
	)

Write number of bytes in an IMAP literal into bytes.

Parameters

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

Return values

0	Success
-1	Failure

Definition at line 737 of file util.c.

{
  char *pc = NULL;
  char *pn = NULL;
 
  if (!buf || !(pc = strchr(buf, '{')))
    return -1;
 
  pc++;
  pn = pc;
  while (isdigit((unsigned char) *pc))
    pc++;
  *pc = '\0';
  if (!mutt_str_atoui(pn, bytes))
    return -1;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_get_qualifier()

char * imap_get_qualifier

(

char *

buf

)

Get the qualifier from a tagged response.

Parameters

buf	Command string to process

Return values

ptr	Start of the qualifier

In a tagged response, skip tag and status for the qualifier message. Used by imap_copy_message for TRYCREATE

Definition at line 764 of file util.c.

{
  char *s = buf;
 
  /* skip tag */
  s = imap_next_word(s);
  /* skip OK/NO/BAD response */
  s = imap_next_word(s);
 
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_next_word()

char * imap_next_word

(

char *

s

)

Find where the next IMAP word begins.

Parameters

s	Command string to process

Return values

ptr	Next IMAP word

Definition at line 781 of file util.c.

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

Here is the caller graph for this function:

imap_qualify_path()

void imap_qualify_path	(	char *	buf,
		size_t	buflen,
		struct ConnAccount *	cac,
		char *	path
	)

Make an absolute IMAP folder target.

Parameters

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

Definition at line 812 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_quote_string()

void imap_quote_string	(	char *	dest,
		size_t	dlen,
		const char *	src,
		bool	quote_backtick
	)

Quote string according to IMAP rules.

Parameters

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

Surround string with quotes, escape " and \ with backslash

Definition at line 829 of file util.c.

{
  const char *quote = "`\"\\";
  if (!quote_backtick)
    quote++;
 
  char *pt = dest;
  const char *s = src;
 
  *pt++ = '"';
  /* save room for quote-chars */
  dlen -= 3;
 
  for (; *s && dlen; s++)
  {
    if (strchr(quote, *s))
    {
      if (dlen < 2)
        break;
      dlen -= 2;
      *pt++ = '\\';
      *pt++ = *s;
    }
    else
    {
      *pt++ = *s;
      dlen--;
    }
  }
  *pt++ = '"';
  *pt = '\0';
}

Here is the caller graph for this function:

imap_unquote_string()

void imap_unquote_string

(

char *

s

)

Equally stupid unquoting routine.

Parameters

s	String to be unquoted

Definition at line 866 of file util.c.

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

Here is the caller graph for this function:

imap_munge_mbox_name()

void imap_munge_mbox_name	(	bool	unicode,
		char *	dest,
		size_t	dlen,
		const char *	src
	)

Quote awkward characters in a mailbox name.

Parameters

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

Definition at line 903 of file util.c.

{
  char *buf = mutt_str_dup(src);
  imap_utf_encode(unicode, &buf);
 
  imap_quote_string(dest, dlen, buf, false);
 
  FREE(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_unmunge_mbox_name()

void imap_unmunge_mbox_name	(	bool	unicode,
		char *	s
	)

Remove quoting from a mailbox name.

Parameters

unicode	true if Unicode is allowed
s	Mailbox name

The string will be altered in-place.

Definition at line 920 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_keepalive()

void imap_keepalive

(

void

)

Poll the current folder to keep the connection alive.

Definition at line 937 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_wait_keepalive()

int imap_wait_keepalive

(

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

{
  struct sigaction oldalrm;
  struct sigaction act;
  sigset_t oldmask;
  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_keepalive = cs_subset_number(NeoMutt->sub, "imap_keepalive");
  alarm(c_imap_keepalive);
  while ((waitpid(pid, &rc, 0) < 0) && (errno == EINTR))
  {
    alarm(0); /* cancel a possibly pending alarm */
    imap_keepalive();
    alarm(c_imap_keepalive);
  }
 
  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_allow_reopen()

void imap_allow_reopen

(

struct Mailbox *

m

)

Allow re-opening a folder upon expunge.

Parameters

m

Mailbox

Definition at line 1008 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_disallow_reopen()

void imap_disallow_reopen

(

struct Mailbox *

m

)

Disallow re-opening a folder upon expunge.

Parameters

m

Mailbox

Definition at line 1021 of file util.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

imap_account_match()

bool imap_account_match	(	const struct ConnAccount *	a1,
		const struct ConnAccount *	a2
	)

Compare two Accounts.

Parameters

a1	First ConnAccount
a2	Second ConnAccount

Return values

true	Accounts match

Definition at line 1036 of file util.c.

{
  if (!a1 || !a2)
    return false;
  if (a1->type != a2->type)
    return false;
  if (!mutt_istr_equal(a1->host, a2->host))
    return false;
  if ((a1->port != 0) && (a2->port != 0) && (a1->port != a2->port))
    return false;
  if (a1->flags & a2->flags & MUTT_ACCT_USER)
    return strcmp(a1->user, a2->user) == 0;
 
  const char *user = NONULL(Username);
 
  const char *const c_imap_user = cs_subset_string(NeoMutt->sub, "imap_user");
  if ((a1->type == MUTT_ACCT_TYPE_IMAP) && c_imap_user)
    user = c_imap_user;
 
  if (a1->flags & MUTT_ACCT_USER)
    return strcmp(a1->user, user) == 0;
  if (a2->flags & MUTT_ACCT_USER)
    return strcmp(a2->user, user) == 0;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_seqset_iterator_new()

struct SeqsetIterator * mutt_seqset_iterator_new

(

const char *

seqset

)

Create a new Sequence Set Iterator.

Parameters

seqset

Source Sequence Set

Return values

ptr	Newly allocated Sequence Set Iterator

Definition at line 1068 of file util.c.

{
  if (!seqset || (*seqset == '\0'))
    return NULL;
 
  struct SeqsetIterator *iter = mutt_mem_calloc(1, sizeof(struct SeqsetIterator));
  iter->full_seqset = mutt_str_dup(seqset);
  iter->eostr = strchr(iter->full_seqset, '\0');
  iter->substr_cur = iter->substr_end = iter->full_seqset;
 
  return iter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_seqset_iterator_next()

int mutt_seqset_iterator_next	(	struct SeqsetIterator *	iter,
		unsigned int *	next
	)

Get the next UID from a Sequence Set.

Parameters

[in]	iter	Sequence Set Iterator
[out]	next	Next UID in set

Return values

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

Definition at line 1089 of file util.c.

{
  if (!iter || !next)
    return -1;
 
  if (iter->in_range)
  {
    if ((iter->down && (iter->range_cur == (iter->range_end - 1))) ||
        (!iter->down && (iter->range_cur == (iter->range_end + 1))))
    {
      iter->in_range = 0;
    }
  }
 
  if (!iter->in_range)
  {
    iter->substr_cur = iter->substr_end;
    if (iter->substr_cur == iter->eostr)
      return 1;
 
    iter->substr_end = strchr(iter->substr_cur, ',');
    if (!iter->substr_end)
      iter->substr_end = iter->eostr;
    else
      *(iter->substr_end++) = '\0';
 
    char *range_sep = strchr(iter->substr_cur, ':');
    if (range_sep)
      *range_sep++ = '\0';
 
    if (!mutt_str_atoui_full(iter->substr_cur, &iter->range_cur))
      return -1;
    if (range_sep)
    {
      if (!mutt_str_atoui_full(range_sep, &iter->range_end))
        return -1;
    }
    else
      iter->range_end = iter->range_cur;
 
    iter->down = (iter->range_end < iter->range_cur);
    iter->in_range = 1;
  }
 
  *next = iter->range_cur;
  if (iter->down)
    iter->range_cur--;
  else
    iter->range_cur++;
 
  return 0;
}

Here is the caller graph for this function:

mutt_seqset_iterator_free()

void mutt_seqset_iterator_free

(

struct SeqsetIterator **

ptr

)

Free a Sequence Set Iterator.

Parameters

[out]

ptr

Iterator to free

Definition at line 1146 of file util.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct SeqsetIterator *iter = *ptr;
  FREE(&iter->full_seqset);
  FREE(ptr);
}

Here is the caller graph for this function: