notmuch.c File Reference

Notmuch virtual mailbox type. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <notmuch.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.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 "mutt.h"
#include "lib.h"
#include "editor/lib.h"
#include "hcache/lib.h"
#include "history/lib.h"
#include "index/lib.h"
#include "progress/lib.h"
#include "adata.h"
#include "commands.h"
#include "edata.h"
#include "maildir/shared.h"
#include "mdata.h"
#include "mutt_thread.h"
#include "mx.h"
#include "protos.h"
#include "query.h"
#include "tag.h"
#include <libintl.h>

Include dependency graph for notmuch.c:

Go to the source code of this file.

Functions
void	nm_init (void)
	Setup feature commands.
static struct HeaderCache *	nm_hcache_open (struct Mailbox *m)
	Open a header cache.
static void	nm_hcache_close (struct HeaderCache **ptr)
	Close the header cache.
static char *	nm_get_default_url (void)
	Create a Mailbox with default Notmuch settings.
static struct NmMboxData *	nm_get_default_data (void)
	Create a Mailbox with default Notmuch settings.
static int	init_mailbox (struct Mailbox *m)
	Add Notmuch data to the Mailbox.
static char *	email_get_id (struct Email *e)
	Get the unique Notmuch Id.
static char *	email_get_fullpath (struct Email *e, char *buf, size_t buflen)
	Get the full path of an email.
static void	query_window_reset (void)
	Restore vfolder's search window to its original position.
static bool	windowed_query_from_query (const char *query, char *buf, size_t buflen)
	Transforms a vfolder search query into a windowed one.
static char *	get_query_string (struct NmMboxData *mdata, bool window)
	Builds the notmuch vfolder search string.
static int	get_limit (struct NmMboxData *mdata)
	Get the database limit.
static void	apply_exclude_tags (notmuch_query_t *query)
	Exclude the configured tags.
static notmuch_query_t *	get_query (struct Mailbox *m, bool writable)
	Create a new query.
static int	update_email_tags (struct Email *e, notmuch_message_t *msg)
	Update the Email's tags from Notmuch.
static int	update_message_path (struct Email *e, const char *path)
	Set the path for a message.
static char *	get_folder_from_path (const char *path)
	Find an email's folder from its path.
static char *	nm2mutt_message_id (const char *id)
	Converts notmuch message Id to neomutt message Id.
static int	init_email (struct Email *e, const char *path, notmuch_message_t *msg)
	Set up an email's Notmuch data.
static const char *	get_message_last_filename (notmuch_message_t *msg)
	Get a message's last filename.
static void	progress_setup (struct Mailbox *m)
	Set up the Progress Bar.
static void	nm_progress_update (struct Mailbox *m)
	Update the progress counter.
static struct Email *	get_mutt_email (struct Mailbox *m, notmuch_message_t *msg)
	Get the Email of a Notmuch message.
static void	append_message (struct HeaderCache *hc, struct Mailbox *m, notmuch_message_t *msg, bool dedup)
	Associate a message.
static void	append_replies (struct HeaderCache *hc, struct Mailbox *m, notmuch_query_t *q, notmuch_message_t *top, bool dedup)
	Add all the replies to a given messages into the display.
static void	append_thread (struct HeaderCache *hc, struct Mailbox *m, notmuch_query_t *q, notmuch_thread_t *thread, bool dedup)
	Add each top level reply in the thread.
static notmuch_messages_t *	get_messages (notmuch_query_t *query)
	Load messages for a query.
static bool	read_mesgs_query (struct Mailbox *m, notmuch_query_t *q, bool dedup)
	Search for matching messages.
static notmuch_threads_t *	get_threads (notmuch_query_t *query)
	Load threads for a query.
static bool	read_threads_query (struct Mailbox *m, notmuch_query_t *q, bool dedup, int limit)
	Perform a query with threads.
static notmuch_message_t *	get_nm_message (notmuch_database_t *db, struct Email *e)
	Find a Notmuch message.
static bool	nm_message_has_tag (notmuch_message_t *msg, char *tag)
	Does a message have this tag?
static void	sync_email_path_with_nm (struct Email *e, notmuch_message_t *msg)
	Synchronize Neomutt's Email path with notmuch.
static int	update_tags (notmuch_message_t *msg, const char *tag_str)
	Update the tags on a message.
static int	update_email_flags (struct Mailbox *m, struct Email *e, const char *tag_str)
	Update the Email's flags.
static int	rename_maildir_filename (const char *old, char *buf, size_t buflen, struct Email *e)
	Rename a Maildir file.
static int	remove_filename (struct Mailbox *m, const char *path)
	Delete a file.
static int	rename_filename (struct Mailbox *m, const char *old_file, const char *new_file, struct Email *e)
	Rename the file.
static unsigned int	count_query (notmuch_database_t *db, const char *qstr, int limit)
	Count the results of a query.
char *	nm_email_get_folder (struct Email *e)
	Get the folder for a Email.
char *	nm_email_get_folder_rel_db (struct Mailbox *m, struct Email *e)
	Get the folder for a Email from the same level as the notmuch database.
int	nm_read_entire_thread (struct Mailbox *m, struct Email *e)
	Get the entire thread of an email.
char *	nm_url_from_query (struct Mailbox *m, char *buf, size_t buflen)
	Turn a query into a URL.
bool	nm_query_window_available (void)
	Are windowed queries enabled for use?
void	nm_query_window_forward (void)
	Function to move the current search window forward in time.
void	nm_query_window_backward (void)
	Function to move the current search window backward in time.
void	nm_query_window_reset (void)
	Resets the vfolder window position to the present.
bool	nm_message_is_still_queried (struct Mailbox *m, struct Email *e)
	Is a message still visible in the query?
int	nm_update_filename (struct Mailbox *m, const char *old_file, const char *new_file, struct Email *e)
	Change the filename.
static enum MxStatus	nm_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
static struct Mailbox *	get_default_mailbox (void)
	Get Mailbox for notmuch without any parameters.
int	nm_record_message (struct Mailbox *m, char *path, struct Email *e)
	Add a message to the Notmuch database.
int	nm_get_all_tags (struct Mailbox *m, const char **tag_list, int *tag_count)
	Fill a list with all notmuch tags.
static bool	nm_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
static bool	nm_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -.
static enum MxOpenReturns	nm_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static enum MxStatus	nm_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	nm_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	nm_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static bool	nm_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static int	nm_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() -.
static int	nm_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() -.
static int	nm_tags_edit (struct Mailbox *m, const char *tags, struct Buffer *buf)
	Prompt and validate new messages tags - Implements MxOps::tags_edit() -.
static int	nm_tags_commit (struct Mailbox *m, struct Email *e, const char *buf)
	Save the tags to a message - Implements MxOps::tags_commit() -.
enum MailboxType	nm_path_probe (const char *path, const struct stat *st)
	Is this a Notmuch Mailbox? - Implements MxOps::path_probe() -.
static int	nm_path_canon (struct Buffer *path)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -.

Variables
static const struct Command	NmCommands []
	Notmuch Commands.
const char	NmUrlProtocol [] = "notmuch://"
	Protocol string for Notmuch URLs.
const int	NmUrlProtocolLen = sizeof(NmUrlProtocol) - 1
	Length of NmUrlProtocol string.
const struct MxOps	MxNotmuchOps
	Notmuch Mailbox - Implements MxOps -.

Detailed Description

Notmuch virtual mailbox type.

Authors

• Karel Zak
• Kevin Velghe
• Richard Russon
• Bernard Pratz
• Bryan Bennett
• Julian Andres Klode
• William Pettersson
• Austin Ray
• Pietro Cerutti
• Federico Kircheis
• Ian Zimmerman
• Reto Brunner
• Dennis Schön

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

Function Documentation

nm_init()

void nm_init

(

void

)

Setup feature commands.

Definition at line 109 of file notmuch.c.

{
  commands_register(&NeoMutt->commands, NmCommands);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_hcache_open()

static struct HeaderCache * nm_hcache_open ( struct Mailbox *  m )

static

Open a header cache.

Parameters

m

Mailbox

Return values

ptr	Header cache handle

Definition at line 119 of file notmuch.c.

{
#ifdef USE_HCACHE
  const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  return hcache_open(c_header_cache, mailbox_path(m), NULL, true);
#else
  return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_hcache_close()

static void nm_hcache_close ( struct HeaderCache **  ptr )

static

Close the header cache.

Parameters

ptr	Header cache handle

Definition at line 133 of file notmuch.c.

{
#ifdef USE_HCACHE
  hcache_close(ptr);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_get_default_url()

static char * nm_get_default_url ( void  )

static

Create a Mailbox with default Notmuch settings.

Return values

ptr	Mailbox with default Notmuch settings
NULL	Error, it's impossible to create an NmMboxData

Definition at line 145 of file notmuch.c.

{
  // path to DB + query + url "decoration"
  size_t len = PATH_MAX + 1024 + 32;
  char *url = MUTT_MEM_MALLOC(len, char);
 
  // Try to use `$nm_default_url` or `$folder`.
  // If neither are set, it is impossible to create a Notmuch URL.
  const char *const c_nm_default_url = cs_subset_string(NeoMutt->sub, "nm_default_url");
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  if (c_nm_default_url)
  {
    snprintf(url, len, "%s", c_nm_default_url);
  }
  else if (c_folder)
  {
    snprintf(url, len, "notmuch://%s", c_folder);
  }
  else
  {
    FREE(&url);
    return NULL;
  }
 
  return url;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_get_default_data()

static struct NmMboxData * nm_get_default_data ( void  )

static

Create a Mailbox with default Notmuch settings.

Return values

ptr	Mailbox with default Notmuch settings
NULL	Error, it's impossible to create an NmMboxData

Definition at line 177 of file notmuch.c.

{
  // path to DB + query + url "decoration"
  char *url = nm_get_default_url();
  if (!url)
    return NULL;
 
  struct NmMboxData *default_data = nm_mdata_new(url);
  FREE(&url);
 
  return default_data;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_mailbox()

static int init_mailbox ( struct Mailbox *  m )

static

Add Notmuch data to the Mailbox.

Parameters

m

Mailbox

Return values

0	Success
-1	Error Bad format

Create a new NmMboxData struct and add it Mailbox::data. Notmuch-specific data will be stored in this struct. This struct can be freed using nm_mdata_free().

Definition at line 200 of file notmuch.c.

{
  if (!m || (m->type != MUTT_NOTMUCH))
    return -1;
 
  if (m->mdata)
    return 0;
 
  m->mdata = nm_mdata_new(mailbox_path(m));
  if (!m->mdata)
    return -1;
 
  m->mdata_free = nm_mdata_free;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

email_get_id()

static char * email_get_id ( struct Email *  e )

static

Get the unique Notmuch Id.

Parameters

e

Email

Return values

ptr	ID string
NULL	Error

Definition at line 222 of file notmuch.c.

{
  struct NmEmailData *edata = nm_edata_get(e);
  if (!edata)
    return NULL;
 
  return edata->virtual_id;
}

Here is the call graph for this function:

Here is the caller graph for this function:

email_get_fullpath()

static char * email_get_fullpath ( struct Email *  e, char *  buf, size_t  buflen  )

static

Get the full path of an email.

Parameters

e	Email
buf	Buffer for the path
buflen	Length of the buffer

Return values

ptr	Path string

Definition at line 238 of file notmuch.c.

{
  snprintf(buf, buflen, "%s/%s", nm_email_get_folder(e), e->path);
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_window_reset()

static void query_window_reset ( void  )

static

Restore vfolder's search window to its original position.

After moving a vfolder search window backward and forward, calling this function will reset the search position to its original value, setting to 0 the user settable variable:

nm_query_window_current_position

Definition at line 253 of file notmuch.c.

{
  mutt_debug(LL_DEBUG2, "entering\n");
  cs_subset_str_native_set(NeoMutt->sub, "nm_query_window_current_position", 0, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

windowed_query_from_query()

static bool windowed_query_from_query ( const char *  query, char *  buf, size_t  buflen  )

static

Transforms a vfolder search query into a windowed one.

Parameters

[in]	query	vfolder search string
[out]	buf	allocated string buffer to receive the modified search query
[in]	buflen	allocated maximum size of the buf string buffer

Return values

true	Transformed search query is available as a string in buf
false	Search query shall not be transformed

Creates a date: search term window from the following user settings:

• nm_query_window_enable (only required for nm_query_window_duration = 0)
• nm_query_window_duration
• nm_query_window_timebase
• nm_query_window_current_position

The window won't be applied:

• If the duration of the search query is set to 0 this function will be disabled unless a user explicitly enables windowed queries.
• If the timebase is invalid, it will show an error message and do nothing.

If there's no search registered in nm_query_window_current_search or this is a new search, it will reset the window and do the search.

Definition at line 283 of file notmuch.c.

{
  mutt_debug(LL_DEBUG2, "nm: %s\n", query);
 
  const bool c_nm_query_window_enable = cs_subset_bool(NeoMutt->sub, "nm_query_window_enable");
  const short c_nm_query_window_duration = cs_subset_number(NeoMutt->sub, "nm_query_window_duration");
  const short c_nm_query_window_current_position = cs_subset_number(NeoMutt->sub, "nm_query_window_current_position");
  const char *const c_nm_query_window_current_search = cs_subset_string(NeoMutt->sub, "nm_query_window_current_search");
  const char *const c_nm_query_window_timebase = cs_subset_string(NeoMutt->sub, "nm_query_window_timebase");
  const char *const c_nm_query_window_or_terms = cs_subset_string(NeoMutt->sub, "nm_query_window_or_terms");
 
  /* if the query has changed, reset the window position */
  if (!c_nm_query_window_current_search || !mutt_str_equal(query, c_nm_query_window_current_search))
  {
    query_window_reset();
  }
 
  enum NmWindowQueryRc rc = nm_windowed_query_from_query(
      buf, buflen, c_nm_query_window_enable, c_nm_query_window_duration,
      c_nm_query_window_current_position, c_nm_query_window_current_search,
      c_nm_query_window_timebase, c_nm_query_window_or_terms);
 
  switch (rc)
  {
    case NM_WINDOW_QUERY_SUCCESS:
    {
      mutt_debug(LL_DEBUG2, "nm: %s -> %s\n", query, buf);
      break;
    }
    case NM_WINDOW_QUERY_INVALID_DURATION:
    {
      query_window_reset();
      return false;
    }
    case NM_WINDOW_QUERY_INVALID_TIMEBASE:
    {
      mutt_message(
          // L10N: The values 'hour', 'day', 'week', 'month', 'year' are literal.
          //       They should not be translated.
          _("Invalid nm_query_window_timebase value (valid values are: hour, day, week, month, year)"));
      mutt_debug(LL_DEBUG2, "Invalid nm_query_window_timebase value\n");
      return false;
    }
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_query_string()

static char * get_query_string ( struct NmMboxData *  mdata, bool  window  )

static

Builds the notmuch vfolder search string.

Parameters

mdata	Notmuch Mailbox data
window	If true enable application of the window on the search string

Return values

ptr	String containing a notmuch search query
NULL	None can be generated

This function parses the internal representation of a search, and returns a search query string ready to be fed to the notmuch API, given the search is valid.

Note

The window parameter here is here to decide contextually whether we want to return a search query with window applied (for the actual search result in mailbox) or not (for the count in the sidebar). It is not aimed at enabling/disabling the feature.

Definition at line 347 of file notmuch.c.

{
  mutt_debug(LL_DEBUG2, "nm: %s\n", window ? "true" : "false");
 
  if (!mdata)
    return NULL;
  if (mdata->db_query && !window)
    return mdata->db_query;
 
  const char *const c_nm_query_type = cs_subset_string(NeoMutt->sub, "nm_query_type");
  mdata->query_type = nm_string_to_query_type(c_nm_query_type); /* user's default */
 
  struct UrlQuery *item = NULL;
  STAILQ_FOREACH(item, &mdata->db_url->query_strings, entries)
  {
    if (!item->value || !item->name)
      continue;
 
    if (mutt_str_equal(item->name, "limit"))
    {
      if (!mutt_str_atoi_full(item->value, &mdata->db_limit))
      {
        mutt_error(_("failed to parse notmuch limit: %s"), item->value);
      }
    }
    else if (mutt_str_equal(item->name, "type"))
    {
      mdata->query_type = nm_string_to_query_type(item->value);
    }
    else if (mutt_str_equal(item->name, "query"))
    {
      mutt_str_replace(&mdata->db_query, item->value);
    }
  }
 
  if (!mdata->db_query)
    return NULL;
 
  if (window)
  {
    char buf[1024] = { 0 };
    cs_subset_str_string_set(NeoMutt->sub, "nm_query_window_current_search",
                             mdata->db_query, NULL);
 
    /* if a date part is defined, do not apply windows (to avoid the risk of
     * having a non-intersected date frame). A good improvement would be to
     * accept if they intersect */
    if (!strstr(mdata->db_query, "date:") &&
        windowed_query_from_query(mdata->db_query, buf, sizeof(buf)))
    {
      mutt_str_replace(&mdata->db_query, buf);
    }
 
    mutt_debug(LL_DEBUG2, "nm: query (windowed) '%s'\n", mdata->db_query);
  }
  else
  {
    mutt_debug(LL_DEBUG2, "nm: query '%s'\n", mdata->db_query);
  }
 
  return mdata->db_query;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_limit()

static int get_limit ( struct NmMboxData *  mdata )

static

Get the database limit.

Parameters

mdata

Notmuch Mailbox data

Return values

num	Current limit

Definition at line 415 of file notmuch.c.

{
  return mdata ? mdata->db_limit : 0;
}

Here is the caller graph for this function:

apply_exclude_tags()

static void apply_exclude_tags ( notmuch_query_t *  query )

static

Exclude the configured tags.

Parameters

query

Notmuch query

Definition at line 424 of file notmuch.c.

{
  const char *const c_nm_exclude_tags = cs_subset_string(NeoMutt->sub, "nm_exclude_tags");
  if (!c_nm_exclude_tags || !query)
    return;
 
  struct NmTags tags = nm_tag_str_to_tags(c_nm_exclude_tags);
 
  char **tag = NULL;
  ARRAY_FOREACH(tag, &tags.tags)
  {
    mutt_debug(LL_DEBUG2, "nm: query exclude tag '%s'\n", *tag);
    notmuch_query_add_tag_exclude(query, *tag);
  }
 
  notmuch_query_set_omit_excluded(query, 1);
  nm_tag_array_free(&tags);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_query()

static notmuch_query_t * get_query ( struct Mailbox *  m, bool  writable  )

static

Create a new query.

Parameters

m	Mailbox
writable	Should the query be updateable?

Return values

ptr	Notmuch query
NULL	Error

Definition at line 450 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return NULL;
 
  notmuch_database_t *db = nm_db_get(m, writable);
  const char *str = get_query_string(mdata, true);
 
  if (!db || !str)
    goto err;
 
  notmuch_query_t *q = notmuch_query_create(db, str);
  if (!q)
    goto err;
 
  apply_exclude_tags(q);
  notmuch_query_set_sort(q, NOTMUCH_SORT_NEWEST_FIRST);
  mutt_debug(LL_DEBUG2, "nm: query successfully initialized (%s)\n", str);
  return q;
err:
  nm_db_release(m);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_email_tags()

static int update_email_tags ( struct Email *  e, notmuch_message_t *  msg  )

static

Update the Email's tags from Notmuch.

Parameters

e	Email
msg	Notmuch message

Return values

0	Success
1	Tags unchanged

Definition at line 482 of file notmuch.c.

{
  struct NmEmailData *edata = nm_edata_get(e);
  struct Buffer *new_tags = buf_pool_get();
  struct Buffer *old_tags = buf_pool_get();
 
  mutt_debug(LL_DEBUG2, "nm: tags update requested (%s)\n", edata->virtual_id);
 
  for (notmuch_tags_t *tags = notmuch_message_get_tags(msg);
       tags && notmuch_tags_valid(tags); notmuch_tags_move_to_next(tags))
  {
    const char *t = notmuch_tags_get(tags);
    if (!t || (*t == '\0'))
      continue;
 
    buf_join_str(new_tags, t, ' ');
  }
 
  driver_tags_get(&e->tags, old_tags);
 
  if (!buf_is_empty(new_tags) && !buf_is_empty(old_tags) &&
      (buf_str_equal(old_tags, new_tags)))
  {
    buf_pool_release(&new_tags);
    buf_pool_release(&old_tags);
    mutt_debug(LL_DEBUG2, "nm: tags unchanged\n");
    return 1;
  }
  buf_pool_release(&old_tags);
 
  /* new version */
  driver_tags_replace(&e->tags, buf_string(new_tags));
  buf_reset(new_tags);
 
  driver_tags_get_transformed(&e->tags, new_tags);
  mutt_debug(LL_DEBUG2, "nm: new tags transformed: '%s'\n", buf_string(new_tags));
  buf_reset(new_tags);
 
  driver_tags_get(&e->tags, new_tags);
  mutt_debug(LL_DEBUG2, "nm: new tag: '%s'\n", buf_string(new_tags));
  buf_pool_release(&new_tags);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_message_path()

static int update_message_path ( struct Email *  e, const char *  path  )

static

Set the path for a message.

Parameters

e	Email
path	Path

Return values

0	Success
1	Failure

Definition at line 534 of file notmuch.c.

{
  struct NmEmailData *edata = nm_edata_get(e);
 
  mutt_debug(LL_DEBUG2, "nm: path update requested path=%s, (%s)\n", path, edata->virtual_id);
 
  char *p = strrchr(path, '/');
  if (p && ((p - path) > 3) &&
      (mutt_strn_equal(p - 3, "cur", 3) || mutt_strn_equal(p - 3, "new", 3) ||
       mutt_strn_equal(p - 3, "tmp", 3)))
  {
    edata->type = MUTT_MAILDIR;
 
    FREE(&e->path);
    FREE(&edata->folder);
 
    p -= 3; /* skip subfolder (e.g. "new") */
    if (cs_subset_bool(NeoMutt->sub, "mark_old"))
    {
      e->old = mutt_str_startswith(p, "cur");
    }
    e->path = mutt_str_dup(p);
 
    for (; (p > path) && (*(p - 1) == '/'); p--)
      ; // do nothing
 
    edata->folder = mutt_strn_dup(path, p - path);
 
    mutt_debug(LL_DEBUG2, "nm: folder='%s', file='%s'\n", edata->folder, e->path);
 
    // We _might_ be looking at a different file (with the same message-id)
    // so reparse it from scratch.
 
    // Preserve the message-id as it's used in the Email HashTable
    mutt_debug(LL_DEBUG1, "nm: reparse the message\n");
    char *message_id = e->env->message_id;
    e->env->message_id = NULL;
 
    mutt_body_free(&e->body);
    mutt_env_free(&e->env);
    maildir_parse_message(path, e->old, e);
    ASSERT(e->body);
    ASSERT(e->env);
 
    FREE(&e->env->message_id);
    e->env->message_id = message_id;
    message_id = NULL;
 
    return 0;
  }
 
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_folder_from_path()

static char * get_folder_from_path ( const char *  path )

static

Find an email's folder from its path.

Parameters

path

Path

Return values

ptr	Path string
NULL	Error

Definition at line 594 of file notmuch.c.

{
  char *p = strrchr(path, '/');
 
  if (p && ((p - path) > 3) &&
      (mutt_strn_equal(p - 3, "cur", 3) || mutt_strn_equal(p - 3, "new", 3) ||
       mutt_strn_equal(p - 3, "tmp", 3)))
  {
    p -= 3;
    for (; (p > path) && (*(p - 1) == '/'); p--)
      ; // do nothing
 
    return mutt_strn_dup(path, p - path);
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm2mutt_message_id()

static char * nm2mutt_message_id ( const char *  id )

static

Converts notmuch message Id to neomutt message Id.

Parameters

id	Notmuch ID to convert

Return values

ptr	NeoMutt message ID

Caller must free the NeoMutt Message ID

Definition at line 619 of file notmuch.c.

{
  if (!id)
    return NULL;
 
  char *mid = NULL;
  mutt_str_asprintf(&mid, "<%s>", id);
  return mid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_email()

static int init_email ( struct Email *  e, const char *  path, notmuch_message_t *  msg  )

static

Set up an email's Notmuch data.

Parameters

e	Email
path	Path to email
msg	Notmuch message

Return values

0	Success
-1	Failure

Definition at line 637 of file notmuch.c.

{
  if (nm_edata_get(e))
    return 0;
 
  struct NmEmailData *edata = nm_edata_new();
  e->nm_edata = edata;
 
  /* Notmuch ensures that message Id exists (if not notmuch Notmuch will
   * generate an ID), so it's more safe than use neomutt Email->env->id */
  const char *id = notmuch_message_get_message_id(msg);
  edata->virtual_id = mutt_str_dup(id);
 
  mutt_debug(LL_DEBUG2, "nm: [e=%p, edata=%p] (%s)\n", (void *) e, (void *) edata, id);
 
  char *nm_msg_id = nm2mutt_message_id(id);
  if (!e->env->message_id)
  {
    e->env->message_id = nm_msg_id;
  }
  else if (!mutt_str_equal(e->env->message_id, nm_msg_id))
  {
    FREE(&e->env->message_id);
    e->env->message_id = nm_msg_id;
  }
  else
  {
    FREE(&nm_msg_id);
  }
 
  if (update_message_path(e, path) != 0)
    return -1;
 
  update_email_tags(e, msg);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_message_last_filename()

static const char * get_message_last_filename ( notmuch_message_t *  msg )

static

Get a message's last filename.

Parameters

msg	Notmuch message

Return values

ptr	Filename
NULL	Error

Definition at line 681 of file notmuch.c.

{
  const char *name = NULL;
 
  for (notmuch_filenames_t *ls = notmuch_message_get_filenames(msg);
       ls && notmuch_filenames_valid(ls); notmuch_filenames_move_to_next(ls))
  {
    name = notmuch_filenames_get(ls);
  }
 
  return name;
}

Here is the caller graph for this function:

progress_setup()

static void progress_setup ( struct Mailbox *  m )

static

Set up the Progress Bar.

Parameters

m

Mailbox

Definition at line 698 of file notmuch.c.

{
  if (!m->verbose)
    return;
 
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return;
 
  mdata->oldmsgcount = m->msg_count;
  mdata->ignmsgcount = 0;
  mdata->progress = progress_new(MUTT_PROGRESS_READ, mdata->oldmsgcount);
  progress_set_message(mdata->progress, _("Reading messages..."));
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_progress_update()

static void nm_progress_update ( struct Mailbox *  m )

static

Update the progress counter.

Parameters

m

Mailbox

Definition at line 717 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
 
  if (!m->verbose || !mdata || !mdata->progress)
    return;
 
  progress_update(mdata->progress, m->msg_count + mdata->ignmsgcount, -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_mutt_email()

static struct Email * get_mutt_email ( struct Mailbox *  m, notmuch_message_t *  msg  )

static

Get the Email of a Notmuch message.

Parameters

m	Mailbox
msg	Notmuch message

Return values

ptr	Email
NULL	Error

Definition at line 734 of file notmuch.c.

{
  if (!m || !msg)
    return NULL;
 
  const char *id = notmuch_message_get_message_id(msg);
  if (!id)
    return NULL;
 
  mutt_debug(LL_DEBUG2, "nm: neomutt email, id='%s'\n", id);
 
  if (!m->id_hash)
  {
    mutt_debug(LL_DEBUG2, "nm: init hash\n");
    m->id_hash = mutt_make_id_hash(m);
    if (!m->id_hash)
      return NULL;
  }
 
  char *mid = nm2mutt_message_id(id);
  mutt_debug(LL_DEBUG2, "nm: neomutt id='%s'\n", mid);
 
  struct Email *e = mutt_hash_find(m->id_hash, mid);
  FREE(&mid);
  return e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

append_message()

static void append_message ( struct HeaderCache *  hc, struct Mailbox *  m, notmuch_message_t *  msg, bool  dedup  )

static

Associate a message.

Parameters

hc	Header cache handle
m	Mailbox
msg	Notmuch message
dedup	De-duplicate results

Definition at line 768 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return;
 
  char *newpath = NULL;
  struct Email *e = NULL;
 
  /* deduplicate */
  if (dedup && get_mutt_email(m, msg))
  {
    mdata->ignmsgcount++;
    nm_progress_update(m);
    mutt_debug(LL_DEBUG2, "nm: ignore id=%s, already in the m\n",
               notmuch_message_get_message_id(msg));
    return;
  }
 
  const char *path = get_message_last_filename(msg);
  if (!path)
    return;
 
  mutt_debug(LL_DEBUG2, "nm: appending message, i=%d, id=%s, path=%s\n",
             m->msg_count, notmuch_message_get_message_id(msg), path);
 
  mx_alloc_memory(m, m->msg_count);
 
#ifdef USE_HCACHE
  e = hcache_fetch_email(hc, path, mutt_str_len(path), 0).email;
  if (!e)
#endif
  {
    if (access(path, F_OK) == 0)
    {
      /* We pass is_old=false as argument here, but e->old will be updated later
       * by update_message_path() (called by init_email() below).  */
      e = maildir_email_new();
      if (!maildir_parse_message(path, false, e))
        email_free(&e);
    }
    else
    {
      /* maybe moved try find it... */
      char *folder = get_folder_from_path(path);
 
      if (folder)
      {
        FILE *fp = maildir_open_find_message(folder, path, &newpath);
        if (fp)
        {
          e = maildir_email_new();
          if (!maildir_parse_stream(fp, newpath, false, e))
            email_free(&e);
          mutt_file_fclose(&fp);
 
          mutt_debug(LL_DEBUG1, "nm: not up-to-date: %s -> %s\n", path, newpath);
        }
      }
      FREE(&folder);
    }
 
    if (!e)
    {
      mutt_debug(LL_DEBUG1, "nm: failed to parse message: %s\n", path);
      goto done;
    }
 
#ifdef USE_HCACHE
    hcache_store_email(hc, newpath ? newpath : path,
                       mutt_str_len(newpath ? newpath : path), e, 0);
#endif
  }
 
  if (init_email(e, newpath ? newpath : path, msg) != 0)
  {
    email_free(&e);
    mutt_debug(LL_DEBUG1, "nm: failed to append email!\n");
    goto done;
  }
 
  e->active = true;
  e->index = m->msg_count;
  mailbox_size_add(m, e);
  m->emails[m->msg_count] = e;
  m->msg_count++;
 
  if (newpath)
  {
    /* remember that file has been moved -- nm_mbox_sync() will update the DB */
    struct NmEmailData *edata = nm_edata_get(e);
    if (edata)
    {
      mutt_debug(LL_DEBUG1, "nm: remember obsolete path: %s\n", path);
      edata->oldpath = mutt_str_dup(path);
    }
  }
  nm_progress_update(m);
done:
  FREE(&newpath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

append_replies()

static void append_replies ( struct HeaderCache *  hc, struct Mailbox *  m, notmuch_query_t *  q, notmuch_message_t *  top, bool  dedup  )

static

Add all the replies to a given messages into the display.

Parameters

hc	Header cache handle
m	Mailbox
q	Notmuch query
top	Notmuch message
dedup	De-duplicate the results

Careful, this calls itself recursively to make sure we get everything.

Definition at line 881 of file notmuch.c.

{
  notmuch_messages_t *msgs = NULL;
 
  for (msgs = notmuch_message_get_replies(top); notmuch_messages_valid(msgs);
       notmuch_messages_move_to_next(msgs))
  {
    notmuch_message_t *nm = notmuch_messages_get(msgs);
    append_message(hc, m, nm, dedup);
    /* recurse through all the replies to this message too */
    append_replies(hc, m, q, nm, dedup);
    notmuch_message_destroy(nm);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

append_thread()

static void append_thread ( struct HeaderCache *  hc, struct Mailbox *  m, notmuch_query_t *  q, notmuch_thread_t *  thread, bool  dedup  )

static

Add each top level reply in the thread.

Parameters

hc	Header cache handle
m	Mailbox
q	Notmuch query
thread	Notmuch thread
dedup	De-duplicate the results

add each top level reply in the thread, and then add each reply to the top level replies

Definition at line 908 of file notmuch.c.

{
  notmuch_messages_t *msgs = NULL;
 
  for (msgs = notmuch_thread_get_toplevel_messages(thread);
       notmuch_messages_valid(msgs); notmuch_messages_move_to_next(msgs))
  {
    notmuch_message_t *nm = notmuch_messages_get(msgs);
    append_message(hc, m, nm, dedup);
    append_replies(hc, m, q, nm, dedup);
    notmuch_message_destroy(nm);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_messages()

static notmuch_messages_t * get_messages ( notmuch_query_t *  query )

static

Load messages for a query.

Parameters

query

Notmuch query

Return values

ptr	Messages matching query
NULL	Error occurred

This helper method is to be the single point for retrieving messages. It handles version specific calls, which will make maintenance easier.

Definition at line 932 of file notmuch.c.

{
  if (!query)
    return NULL;
 
  notmuch_messages_t *msgs = NULL;
 
#if LIBNOTMUCH_CHECK_VERSION(5, 0, 0)
  if (notmuch_query_search_messages(query, &msgs) != NOTMUCH_STATUS_SUCCESS)
    return NULL;
#elif LIBNOTMUCH_CHECK_VERSION(4, 3, 0)
  if (notmuch_query_search_messages_st(query, &msgs) != NOTMUCH_STATUS_SUCCESS)
    return NULL;
#else
  msgs = notmuch_query_search_messages(query);
#endif
 
  return msgs;
}

Here is the caller graph for this function:

read_mesgs_query()

static bool read_mesgs_query ( struct Mailbox *  m, notmuch_query_t *  q, bool  dedup  )

static

Search for matching messages.

Parameters

m	Mailbox
q	Notmuch query
dedup	De-duplicate the results

Return values

true	Success
false	Failure

Definition at line 960 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return false;
 
  int limit = get_limit(mdata);
 
  notmuch_messages_t *msgs = get_messages(q);
 
  if (!msgs)
    return false;
 
  struct HeaderCache *hc = nm_hcache_open(m);
 
  for (; notmuch_messages_valid(msgs) && ((limit == 0) || (m->msg_count < limit));
       notmuch_messages_move_to_next(msgs))
  {
    if (SigInt)
    {
      nm_hcache_close(&hc);
      SigInt = false;
      return false;
    }
    notmuch_message_t *nm = notmuch_messages_get(msgs);
    append_message(hc, m, nm, dedup);
    notmuch_message_destroy(nm);
  }
 
  nm_hcache_close(&hc);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_threads()

static notmuch_threads_t * get_threads ( notmuch_query_t *  query )

static

Load threads for a query.

Parameters

query

Notmuch query

Return values

ptr	Threads matching query
NULL	Error occurred

This helper method is to be the single point for retrieving messages. It handles version specific calls, which will make maintenance easier.

Definition at line 1002 of file notmuch.c.

{
  if (!query)
    return NULL;
 
  notmuch_threads_t *threads = NULL;
#if LIBNOTMUCH_CHECK_VERSION(5, 0, 0)
  if (notmuch_query_search_threads(query, &threads) != NOTMUCH_STATUS_SUCCESS)
    return NULL;
#elif LIBNOTMUCH_CHECK_VERSION(4, 3, 0)
  if (notmuch_query_search_threads_st(query, &threads) != NOTMUCH_STATUS_SUCCESS)
    return NULL;
#else
  threads = notmuch_query_search_threads(query);
#endif
 
  return threads;
}

Here is the caller graph for this function:

read_threads_query()

static bool read_threads_query ( struct Mailbox *  m, notmuch_query_t *  q, bool  dedup, int  limit  )

static

Perform a query with threads.

Parameters

m	Mailbox
q	Query type
dedup	Should the results be de-duped?
limit	Maximum number of results

Return values

true	Success
false	Failure

Definition at line 1030 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return false;
 
  notmuch_threads_t *threads = get_threads(q);
  if (!threads)
    return false;
 
  struct HeaderCache *hc = nm_hcache_open(m);
 
  for (; notmuch_threads_valid(threads) && ((limit == 0) || (m->msg_count < limit));
       notmuch_threads_move_to_next(threads))
  {
    if (SigInt)
    {
      nm_hcache_close(&hc);
      SigInt = false;
      return false;
    }
    notmuch_thread_t *thread = notmuch_threads_get(threads);
    append_thread(hc, m, q, thread, dedup);
    notmuch_thread_destroy(thread);
  }
 
  nm_hcache_close(&hc);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_nm_message()

static notmuch_message_t * get_nm_message ( notmuch_database_t *  db, struct Email *  e  )

static

Find a Notmuch message.

Parameters

db	Notmuch database
e	Email

Return values

ptr	Handle to the Notmuch message
NULL	Error occurred

Definition at line 1067 of file notmuch.c.

{
  notmuch_message_t *msg = NULL;
  char *id = email_get_id(e);
 
  mutt_debug(LL_DEBUG2, "nm: find message (%s)\n", id);
 
  if (id && db)
    notmuch_database_find_message(db, id, &msg);
 
  return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_message_has_tag()

static bool nm_message_has_tag ( notmuch_message_t *  msg, char *  tag  )

static

Does a message have this tag?

Parameters

msg	Notmuch message
tag	Tag

Return values

true

It does

Definition at line 1086 of file notmuch.c.

{
  const char *possible_match_tag = NULL;
  notmuch_tags_t *tags = NULL;
 
  for (tags = notmuch_message_get_tags(msg); notmuch_tags_valid(tags);
       notmuch_tags_move_to_next(tags))
  {
    possible_match_tag = notmuch_tags_get(tags);
    if (mutt_str_equal(possible_match_tag, tag))
    {
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sync_email_path_with_nm()

static void sync_email_path_with_nm ( struct Email *  e, notmuch_message_t *  msg  )

static

Synchronize Neomutt's Email path with notmuch.

Parameters

e	Email in Neomutt
msg	Email from notmuch

Definition at line 1108 of file notmuch.c.

{
  const char *new_file = get_message_last_filename(msg);
  char old_file[PATH_MAX] = { 0 };
  email_get_fullpath(e, old_file, sizeof(old_file));
 
  if (!mutt_str_equal(old_file, new_file))
    update_message_path(e, new_file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_tags()

static int update_tags ( notmuch_message_t *  msg, const char *  tag_str  )

static

Update the tags on a message.

Parameters

msg	Notmuch message
tag_str	String of tags (space separated)

Return values

0	Success
-1	Failure

Definition at line 1125 of file notmuch.c.

{
  if (!tag_str)
    return -1;
 
  notmuch_message_freeze(msg);
 
  struct NmTags tags = nm_tag_str_to_tags(tag_str);
  char **tag_elem = NULL;
  ARRAY_FOREACH(tag_elem, &tags.tags)
  {
    char *tag = *tag_elem;
 
    if (tag[0] == '-')
    {
      mutt_debug(LL_DEBUG1, "nm: remove tag: '%s'\n", tag + 1);
      notmuch_message_remove_tag(msg, tag + 1);
    }
    else if (tag[0] == '!')
    {
      mutt_debug(LL_DEBUG1, "nm: toggle tag: '%s'\n", tag + 1);
      if (nm_message_has_tag(msg, tag + 1))
      {
        notmuch_message_remove_tag(msg, tag + 1);
      }
      else
      {
        notmuch_message_add_tag(msg, tag + 1);
      }
    }
    else
    {
      mutt_debug(LL_DEBUG1, "nm: add tag: '%s'\n", (tag[0] == '+') ? tag + 1 : tag);
      notmuch_message_add_tag(msg, (tag[0] == '+') ? tag + 1 : tag);
    }
  }
 
  notmuch_message_thaw(msg);
  nm_tag_array_free(&tags);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_email_flags()

static int update_email_flags ( struct Mailbox *  m, struct Email *  e, const char *  tag_str  )

static

Update the Email's flags.

Parameters

m	Mailbox
e	Email
tag_str	String of tags (space separated)

Return values

0	Success
-1	Failure

TODO: join update_email_tags and update_email_flags, which are given an array of tags.

Definition at line 1179 of file notmuch.c.

{
  if (!tag_str)
    return -1;
 
  const char *const c_nm_unread_tag = cs_subset_string(NeoMutt->sub, "nm_unread_tag");
  const char *const c_nm_replied_tag = cs_subset_string(NeoMutt->sub, "nm_replied_tag");
  const char *const c_nm_flagged_tag = cs_subset_string(NeoMutt->sub, "nm_flagged_tag");
 
  struct NmTags tags = nm_tag_str_to_tags(tag_str);
  char **tag_elem = NULL;
  ARRAY_FOREACH(tag_elem, &tags.tags)
  {
    char *tag = *tag_elem;
 
    if (tag[0] == '-')
    {
      tag++;
      if (mutt_str_equal(tag, c_nm_unread_tag))
        mutt_set_flag(m, e, MUTT_READ, true, true);
      else if (mutt_str_equal(tag, c_nm_replied_tag))
        mutt_set_flag(m, e, MUTT_REPLIED, false, true);
      else if (mutt_str_equal(tag, c_nm_flagged_tag))
        mutt_set_flag(m, e, MUTT_FLAG, false, true);
    }
    else
    {
      tag = (tag[0] == '+') ? tag + 1 : tag;
      if (mutt_str_equal(tag, c_nm_unread_tag))
        mutt_set_flag(m, e, MUTT_READ, false, true);
      else if (mutt_str_equal(tag, c_nm_replied_tag))
        mutt_set_flag(m, e, MUTT_REPLIED, true, true);
      else if (mutt_str_equal(tag, c_nm_flagged_tag))
        mutt_set_flag(m, e, MUTT_FLAG, true, true);
    }
  }
 
  nm_tag_array_free(&tags);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rename_maildir_filename()

static int rename_maildir_filename ( const char *  old, char *  buf, size_t  buflen, struct Email *  e  )

static

Rename a Maildir file.

Parameters

old	Old path
buf	Buffer for new path
buflen	Length of buffer
e	Email

Return values

0	Success, renamed
1	Success, no change
-1	Failure

Definition at line 1231 of file notmuch.c.

{
  char filename[PATH_MAX] = { 0 };
  char suffix[PATH_MAX] = { 0 };
  char folder[PATH_MAX] = { 0 };
 
  mutt_str_copy(folder, old, sizeof(folder));
  char *p = strrchr(folder, '/');
  if (p)
  {
    *p = '\0';
    p++;
  }
  else
  {
    p = folder;
  }
 
  mutt_str_copy(filename, p, sizeof(filename));
 
  /* remove (new,cur,...) from folder path */
  p = strrchr(folder, '/');
  if (p)
    *p = '\0';
 
  /* remove old flags from filename */
  const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
  p = strchr(filename, c_maildir_field_delimiter);
  if (p)
    *p = '\0';
 
  /* compose new flags */
  maildir_gen_flags(suffix, sizeof(suffix), e);
 
  snprintf(buf, buflen, "%s/%s/%s%s", folder,
           (e->read || e->old) ? "cur" : "new", filename, suffix);
 
  if (mutt_str_equal(old, buf))
    return 1;
 
  if (rename(old, buf) != 0)
  {
    mutt_debug(LL_DEBUG1, "nm: rename(2) failed %s -> %s\n", old, buf);
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

remove_filename()

static int remove_filename ( struct Mailbox *  m, const char *  path  )

static

Delete a file.

Parameters

m	Mailbox
path	Path of file

Return values

0	Success
-1	Failure

Definition at line 1287 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return -1;
 
  mutt_debug(LL_DEBUG2, "nm: remove filename '%s'\n", path);
 
  notmuch_database_t *db = nm_db_get(m, true);
  if (!db)
    return -1;
 
  notmuch_message_t *msg = NULL;
  notmuch_status_t st = notmuch_database_find_message_by_filename(db, path, &msg);
  if (st || !msg)
    return -1;
 
  int trans = nm_db_trans_begin(m);
  if (trans < 0)
    return -1;
 
  /* note that unlink() is probably unnecessary here, it's already removed
   * by mh_sync_mailbox_message(), but for sure...  */
  notmuch_filenames_t *ls = NULL;
  st = notmuch_database_remove_message(db, path);
  switch (st)
  {
    case NOTMUCH_STATUS_SUCCESS:
      mutt_debug(LL_DEBUG2, "nm: remove success, call unlink\n");
      unlink(path);
      break;
    case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
      mutt_debug(LL_DEBUG2, "nm: remove success (duplicate), call unlink\n");
      unlink(path);
      for (ls = notmuch_message_get_filenames(msg);
           ls && notmuch_filenames_valid(ls); notmuch_filenames_move_to_next(ls))
      {
        path = notmuch_filenames_get(ls);
 
        mutt_debug(LL_DEBUG2, "nm: remove duplicate: '%s'\n", path);
        unlink(path);
        notmuch_database_remove_message(db, path);
      }
      break;
    default:
      mutt_debug(LL_DEBUG1, "nm: failed to remove '%s' [st=%d]\n", path, (int) st);
      break;
  }
 
  notmuch_message_destroy(msg);
  if (trans)
    nm_db_trans_end(m);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rename_filename()

static int rename_filename ( struct Mailbox *  m, const char *  old_file, const char *  new_file, struct Email *  e  )

static

Rename the file.

Parameters

m	Notmuch Mailbox data
old_file	Old filename
new_file	New filename
e	Email

Return values

0	Success
-1	Failure

Definition at line 1351 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return -1;
 
  notmuch_database_t *db = nm_db_get(m, true);
  if (!db || !new_file || !old_file || (access(new_file, F_OK) != 0))
    return -1;
 
  int rc = -1;
  notmuch_status_t st;
  notmuch_filenames_t *ls = NULL;
  notmuch_message_t *msg = NULL;
 
  mutt_debug(LL_DEBUG1, "nm: rename filename, %s -> %s\n", old_file, new_file);
  int trans = nm_db_trans_begin(m);
  if (trans < 0)
    return -1;
 
  mutt_debug(LL_DEBUG2, "nm: rename: add '%s'\n", new_file);
#if LIBNOTMUCH_CHECK_VERSION(5, 1, 0)
  st = notmuch_database_index_file(db, new_file, NULL, &msg);
#else
  st = notmuch_database_add_message(db, new_file, &msg);
#endif
 
  if ((st != NOTMUCH_STATUS_SUCCESS) && (st != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID))
  {
    mutt_debug(LL_DEBUG1, "nm: failed to add '%s' [st=%d]\n", new_file, (int) st);
    goto done;
  }
 
  mutt_debug(LL_DEBUG2, "nm: rename: rem '%s'\n", old_file);
  st = notmuch_database_remove_message(db, old_file);
  switch (st)
  {
    case NOTMUCH_STATUS_SUCCESS:
      break;
    case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
      mutt_debug(LL_DEBUG2, "nm: rename: syncing duplicate filename\n");
      notmuch_message_destroy(msg);
      msg = NULL;
      notmuch_database_find_message_by_filename(db, new_file, &msg);
 
      for (ls = notmuch_message_get_filenames(msg);
           msg && ls && notmuch_filenames_valid(ls); notmuch_filenames_move_to_next(ls))
      {
        const char *path = notmuch_filenames_get(ls);
        char newpath[PATH_MAX] = { 0 };
 
        if (mutt_str_equal(new_file, path))
          continue;
 
        mutt_debug(LL_DEBUG2, "nm: rename: syncing duplicate: %s\n", path);
 
        if (rename_maildir_filename(path, newpath, sizeof(newpath), e) == 0)
        {
          mutt_debug(LL_DEBUG2, "nm: rename dup %s -> %s\n", path, newpath);
          notmuch_database_remove_message(db, path);
#if LIBNOTMUCH_CHECK_VERSION(5, 1, 0)
          notmuch_database_index_file(db, newpath, NULL, NULL);
#else
          notmuch_database_add_message(db, newpath, NULL);
#endif
        }
      }
      notmuch_message_destroy(msg);
      msg = NULL;
      notmuch_database_find_message_by_filename(db, new_file, &msg);
      st = NOTMUCH_STATUS_SUCCESS;
      break;
    default:
      mutt_debug(LL_DEBUG1, "nm: failed to remove '%s' [st=%d]\n", old_file, (int) st);
      break;
  }
 
  if ((st == NOTMUCH_STATUS_SUCCESS) && e && msg)
  {
    notmuch_message_maildir_flags_to_tags(msg);
    update_email_tags(e, msg);
 
    struct Buffer *tags = buf_pool_get();
    driver_tags_get(&e->tags, tags);
    update_tags(msg, buf_string(tags));
    buf_pool_release(&tags);
  }
 
  rc = 0;
done:
  if (msg)
    notmuch_message_destroy(msg);
  if (trans)
    nm_db_trans_end(m);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

count_query()

static unsigned int count_query ( notmuch_database_t *  db, const char *  qstr, int  limit  )

static

Count the results of a query.

Parameters

db	Notmuch database
qstr	Query to execute
limit	Maximum number of results

Return values

num	Number of results

Definition at line 1456 of file notmuch.c.

{
  notmuch_query_t *q = notmuch_query_create(db, qstr);
  if (!q)
    return 0;
 
  unsigned int res = 0;
 
  apply_exclude_tags(q);
#if LIBNOTMUCH_CHECK_VERSION(5, 0, 0)
  if (notmuch_query_count_messages(q, &res) != NOTMUCH_STATUS_SUCCESS)
    res = 0; /* may not be defined on error */
#elif LIBNOTMUCH_CHECK_VERSION(4, 3, 0)
  if (notmuch_query_count_messages_st(q, &res) != NOTMUCH_STATUS_SUCCESS)
    res = 0; /* may not be defined on error */
#else
  res = notmuch_query_count_messages(q);
#endif
  notmuch_query_destroy(q);
  mutt_debug(LL_DEBUG1, "nm: count '%s', result=%d\n", qstr, res);
 
  if ((limit > 0) && (res > limit))
    res = limit;
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_email_get_folder()

char * nm_email_get_folder

(

struct Email *

e

)

Get the folder for a Email.

Parameters

e

Email

Return values

ptr	Folder containing email
NULL	Error

Definition at line 1489 of file notmuch.c.

{
  struct NmEmailData *edata = nm_edata_get(e);
  if (!edata)
    return NULL;
 
  return edata->folder;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_email_get_folder_rel_db()

char * nm_email_get_folder_rel_db	(	struct Mailbox *	m,
		struct Email *	e
	)

Get the folder for a Email from the same level as the notmuch database.

Parameters

m	Mailbox containing Email
e	Email

Return values

ptr	Folder containing email from the same level as the notmuch db
NULL	Error

Instead of returning a path like /var/mail/account/Inbox, this returns account/Inbox. If wanting the full path, use nm_email_get_folder().

Definition at line 1508 of file notmuch.c.

{
  char *full_folder = nm_email_get_folder(e);
  if (!full_folder)
    return NULL;
 
  const char *db_path = nm_db_get_filename(m);
  if (!db_path)
    return NULL;
 
  size_t prefix = mutt_str_startswith(full_folder, db_path);
 
  char *path = full_folder + prefix;
  if (*path == '/')
    path++;
 
  return path;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_read_entire_thread()

int nm_read_entire_thread	(	struct Mailbox *	m,
		struct Email *	e
	)

Get the entire thread of an email.

Parameters

m	Mailbox
e	Email

Return values

0	Success
-1	Failure

Definition at line 1534 of file notmuch.c.

{
  if (!m)
    return -1;
 
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return -1;
 
  notmuch_query_t *q = NULL;
  notmuch_database_t *db = NULL;
  notmuch_message_t *msg = NULL;
  int rc = -1;
 
  if (!(db = nm_db_get(m, false)) || !(msg = get_nm_message(db, e)))
    goto done;
 
  mutt_debug(LL_DEBUG1, "nm: reading entire-thread messages...[current count=%d]\n",
             m->msg_count);
 
  progress_setup(m);
  const char *id = notmuch_message_get_thread_id(msg);
  if (!id)
    goto done;
 
  struct Buffer *qstr = buf_pool_get();
  buf_printf(qstr, "thread:%s", id);
  q = notmuch_query_create(db, buf_string(qstr));
  buf_pool_release(&qstr);
  if (!q)
    goto done;
  apply_exclude_tags(q);
  notmuch_query_set_sort(q, NOTMUCH_SORT_NEWEST_FIRST);
 
  read_threads_query(m, q, true, 0);
  mdata->mtime.tv_sec = mutt_date_now();
  mdata->mtime.tv_nsec = 0;
  rc = 0;
 
  if (m->msg_count > mdata->oldmsgcount)
    mailbox_changed(m, NT_MAILBOX_INVALID);
done:
  if (q)
    notmuch_query_destroy(q);
 
  nm_db_release(m);
 
  if (m->msg_count == mdata->oldmsgcount)
    mutt_message(_("No more messages in the thread"));
 
  mdata->oldmsgcount = 0;
  mutt_debug(LL_DEBUG1, "nm: reading entire-thread messages... done [rc=%d, count=%d]\n",
             rc, m->msg_count);
  progress_free(&mdata->progress);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_url_from_query()

char * nm_url_from_query	(	struct Mailbox *	m,
		char *	buf,
		size_t	buflen
	)

Turn a query into a URL.

Parameters

m	Mailbox
buf	Buffer for URL
buflen	Length of buffer

Return values

ptr	Query as a URL
NULL	Error

Definition at line 1599 of file notmuch.c.

{
  mutt_debug(LL_DEBUG2, "(%s)\n", buf);
  struct NmMboxData *mdata = nm_mdata_get(m);
  char url[PATH_MAX + 1024 + 32]; /* path to DB + query + URL "decoration" */
  int added;
  bool using_default_data = false;
 
  // No existing data. Try to get a default NmMboxData.
  if (!mdata)
  {
    mdata = nm_get_default_data();
 
    // Failed to get default data.
    if (!mdata)
      return NULL;
 
    using_default_data = true;
  }
 
  enum NmQueryType query_type = nm_string_to_query_type(
      cs_subset_string(NeoMutt->sub, "nm_query_type"));
  mdata->query_type = nm_parse_type_from_query(buf, query_type);
 
  const short c_nm_db_limit = cs_subset_number(NeoMutt->sub, "nm_db_limit");
  if (get_limit(mdata) == c_nm_db_limit)
  {
    added = snprintf(url, sizeof(url), "%s%s?type=%s&query=", NmUrlProtocol,
                     nm_db_get_filename(m), nm_query_type_to_string(mdata->query_type));
  }
  else
  {
    added = snprintf(url, sizeof(url), "%s%s?type=%s&limit=%d&query=", NmUrlProtocol,
                     nm_db_get_filename(m),
                     nm_query_type_to_string(mdata->query_type), get_limit(mdata));
  }
 
  if (added >= sizeof(url))
  {
    // snprintf output was truncated, so can't create URL
    return NULL;
  }
 
  url_pct_encode(&url[added], sizeof(url) - added, buf);
 
  mutt_str_copy(buf, url, buflen);
  buf[buflen - 1] = '\0';
 
  if (using_default_data)
    nm_mdata_free((void **) &mdata);
 
  mutt_debug(LL_DEBUG1, "nm: url from query '%s'\n", buf);
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_query_window_available()

bool nm_query_window_available

(

void

)

Are windowed queries enabled for use?

Return values

true	Windowed queries in use

Definition at line 1658 of file notmuch.c.

{
  const short c_nm_query_window_duration = cs_subset_number(NeoMutt->sub, "nm_query_window_duration");
  const bool c_nm_query_window_enable = cs_subset_bool(NeoMutt->sub, "nm_query_window_enable");
 
  return c_nm_query_window_enable || (c_nm_query_window_duration > 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_query_window_forward()

void nm_query_window_forward

(

void

)

Function to move the current search window forward in time.

Updates nm_query_window_current_position by decrementing it by 1, or does nothing if the current window already is set to 0.

The lower the value of nm_query_window_current_position is, the more recent the result will be.

Definition at line 1675 of file notmuch.c.

{
  const short c_nm_query_window_current_position = cs_subset_number(NeoMutt->sub, "nm_query_window_current_position");
  if (c_nm_query_window_current_position != 0)
  {
    cs_subset_str_native_set(NeoMutt->sub, "nm_query_window_current_position",
                             c_nm_query_window_current_position - 1, NULL);
  }
 
  mutt_debug(LL_DEBUG2, "(%d)\n", c_nm_query_window_current_position - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_query_window_backward()

void nm_query_window_backward

(

void

)

Function to move the current search window backward in time.

Updates nm_query_window_current_position by incrementing it by 1

The higher the value of nm_query_window_current_position is, the less recent the result will be.

Definition at line 1695 of file notmuch.c.

{
  const short c_nm_query_window_current_position = cs_subset_number(NeoMutt->sub, "nm_query_window_current_position");
  cs_subset_str_native_set(NeoMutt->sub, "nm_query_window_current_position",
                           c_nm_query_window_current_position + 1, NULL);
  mutt_debug(LL_DEBUG2, "(%d)\n", c_nm_query_window_current_position + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_query_window_reset()

void nm_query_window_reset

(

void

)

Resets the vfolder window position to the present.

Definition at line 1706 of file notmuch.c.

{
  cs_subset_str_native_set(NeoMutt->sub, "nm_query_window_current_position", 0, NULL);
  mutt_debug(LL_DEBUG2, "Reset nm_query_window_current_position to 0\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_message_is_still_queried()

bool nm_message_is_still_queried	(	struct Mailbox *	m,
		struct Email *	e
	)

Is a message still visible in the query?

Parameters

m	Mailbox
e	Email

Return values

true	Message is still in query

Definition at line 1718 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return false;
 
  notmuch_database_t *db = nm_db_get(m, false);
  char *orig_str = get_query_string(mdata, true);
 
  if (!db || !orig_str)
    return false;
 
  char *new_str = NULL;
  bool rc = false;
  if (mutt_str_asprintf(&new_str, "id:%s and (%s)", email_get_id(e), orig_str) < 0)
    return false;
 
  mutt_debug(LL_DEBUG2, "nm: checking if message is still queried: %s\n", new_str);
 
  notmuch_query_t *q = notmuch_query_create(db, new_str);
 
  switch (mdata->query_type)
  {
    case NM_QUERY_TYPE_UNKNOWN: // UNKNOWN should never occur, but MESGS is default
    case NM_QUERY_TYPE_MESGS:
    {
      notmuch_messages_t *messages = get_messages(q);
 
      if (!messages)
        return false;
 
      rc = notmuch_messages_valid(messages);
      notmuch_messages_destroy(messages);
      break;
    }
    case NM_QUERY_TYPE_THREADS:
    {
      notmuch_threads_t *threads = get_threads(q);
 
      if (!threads)
        return false;
 
      rc = notmuch_threads_valid(threads);
      notmuch_threads_destroy(threads);
      break;
    }
  }
 
  notmuch_query_destroy(q);
 
  mutt_debug(LL_DEBUG2, "nm: checking if message is still queried: %s = %s\n",
             new_str, rc ? "true" : "false");
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_update_filename()

int nm_update_filename	(	struct Mailbox *	m,
		const char *	old_file,
		const char *	new_file,
		struct Email *	e
	)

Change the filename.

Parameters

m	Mailbox
old_file	Old filename
new_file	New filename
e	Email

Return values

0	Success
-1	Failure

Definition at line 1783 of file notmuch.c.

{
  char buf[PATH_MAX] = { 0 };
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata || !new_file)
    return -1;
 
  if (!old_file && nm_edata_get(e))
  {
    email_get_fullpath(e, buf, sizeof(buf));
    old_file = buf;
  }
 
  int rc = rename_filename(m, old_file, new_file, e);
 
  nm_db_release(m);
  mdata->mtime.tv_sec = mutt_date_now();
  mdata->mtime.tv_nsec = 0;
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_default_mailbox()

static struct Mailbox * get_default_mailbox ( void  )

static

Get Mailbox for notmuch without any parameters.

Return values

ptr	Mailbox pointer

Definition at line 1893 of file notmuch.c.

{
  // Create a new notmuch mailbox from scratch and add plumbing for DB access.
  char *default_url = nm_get_default_url();
  struct Mailbox *m = mx_path_resolve(default_url);
 
  FREE(&default_url);
 
  // These are no-ops for an initialized mailbox.
  init_mailbox(m);
  mx_mbox_ac_link(m);
 
  return m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_record_message()

int nm_record_message	(	struct Mailbox *	m,
		char *	path,
		struct Email *	e
	)

Add a message to the Notmuch database.

Parameters

m	Mailbox
path	Path of the email
e	Email

Return values

0	Success
-1	Failure

Definition at line 1916 of file notmuch.c.

{
  notmuch_database_t *db = NULL;
  notmuch_status_t st;
  notmuch_message_t *msg = NULL;
  int rc = -1;
 
  struct NmMboxData *mdata = nm_mdata_get(m);
 
  // If no notmuch data, fall back to the default mailbox.
  //
  // IMPORTANT: DO NOT FREE THIS MAILBOX. Two reasons:
  // 1) If user has default mailbox in config, we'll be removing it. That's not
  //    good program behavior!
  // 2) If not in user's config, keep mailbox around for future nm_record calls.
  //    It saves NeoMutt from allocating/deallocating repeatedly.
  if (!mdata)
  {
    mutt_debug(LL_DEBUG1, "nm: non-nm mailbox. trying the default nm mailbox.\n");
    m = get_default_mailbox();
    mdata = nm_mdata_get(m);
  }
 
  if (!path || !mdata || (access(path, F_OK) != 0))
    return 0;
  db = nm_db_get(m, true);
  if (!db)
    return -1;
 
  mutt_debug(LL_DEBUG1, "nm: record message: %s\n", path);
  int trans = nm_db_trans_begin(m);
  if (trans < 0)
    goto done;
 
#if LIBNOTMUCH_CHECK_VERSION(5, 1, 0)
  st = notmuch_database_index_file(db, path, NULL, &msg);
#else
  st = notmuch_database_add_message(db, path, &msg);
#endif
 
  if ((st != NOTMUCH_STATUS_SUCCESS) && (st != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID))
  {
    mutt_debug(LL_DEBUG1, "nm: failed to add '%s' [st=%d]\n", path, (int) st);
    goto done;
  }
 
  if ((st == NOTMUCH_STATUS_SUCCESS) && msg)
  {
    notmuch_message_maildir_flags_to_tags(msg);
    if (e)
    {
      struct Buffer *tags = buf_pool_get();
      driver_tags_get(&e->tags, tags);
      update_tags(msg, buf_string(tags));
      buf_pool_release(&tags);
    }
    const char *const c_nm_record_tags = cs_subset_string(NeoMutt->sub, "nm_record_tags");
    if (c_nm_record_tags)
      update_tags(msg, c_nm_record_tags);
  }
 
  rc = 0;
done:
  if (msg)
    notmuch_message_destroy(msg);
  if (trans == 1)
    nm_db_trans_end(m);
 
  nm_db_release(m);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nm_get_all_tags()

int nm_get_all_tags	(	struct Mailbox *	m,
		const char **	tag_list,
		int *	tag_count
	)

Fill a list with all notmuch tags.

Parameters

[in]	m	Mailbox
[out]	tag_list	List of tags
[out]	tag_count	Number of tags

Return values

0	Success
-1	Failure

If tag_list is NULL, just count the tags.

Definition at line 1999 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  if (!mdata)
    return -1;
 
  notmuch_database_t *db = NULL;
  notmuch_tags_t *tags = NULL;
  const char *tag = NULL;
  int rc = -1;
 
  if (!(db = nm_db_get(m, false)) || !(tags = notmuch_database_get_all_tags(db)))
    goto done;
 
  *tag_count = 0;
  mutt_debug(LL_DEBUG1, "nm: get all tags\n");
 
  while (notmuch_tags_valid(tags))
  {
    tag = notmuch_tags_get(tags);
    /* Skip empty string */
    if (*tag)
    {
      if (tag_list)
        tag_list[*tag_count] = mutt_str_dup(tag);
      (*tag_count)++;
    }
    notmuch_tags_move_to_next(tags);
  }
 
  rc = 0;
done:
  if (tags)
    notmuch_tags_destroy(tags);
 
  nm_db_release(m);
 
  mutt_debug(LL_DEBUG1, "nm: get all tags done [rc=%d tag_count=%u]\n", rc, *tag_count);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

NmCommands

const struct Command NmCommands[]

static

Initial value:

= {
  
  { "unvirtual-mailboxes", parse_unmailboxes, 0 },
  { "virtual-mailboxes",   parse_mailboxes,   MUTT_NAMED },
  { NULL, NULL, 0 },
  
}

Notmuch Commands.

Definition at line 93 of file notmuch.c.

NmUrlProtocol

const char NmUrlProtocol[] = "notmuch://"

Protocol string for Notmuch URLs.

Definition at line 102 of file notmuch.c.

NmUrlProtocolLen

const int NmUrlProtocolLen = sizeof(NmUrlProtocol) - 1

Length of NmUrlProtocol string.

Definition at line 104 of file notmuch.c.