dlg_query.c File Reference

Routines for querying an external address book. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "lib.h"
#include "editor/lib.h"
#include "expando/lib.h"
#include "history/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "pattern/lib.h"
#include "send/lib.h"
#include "alias.h"
#include "expando.h"
#include "functions.h"
#include "gui.h"
#include "mutt_logging.h"

Include dependency graph for dlg_query.c:

Go to the source code of this file.

Functions
bool	alias_to_addrlist (struct AddressList *al, struct Alias *alias)
	Turn an Alias into an AddressList.
static int	query_make_entry (struct Menu *menu, int line, int max_cols, struct Buffer *buf)
	Format an Alias for the Menu - Implements Menu::make_entry() -.
static int	query_tag (struct Menu *menu, int sel, int act)
	Tag an entry in the Query Menu - Implements Menu::tag() -.
int	query_run (const char *s, bool verbose, struct AliasList *al, const struct ConfigSubset *sub)
	Run an external program to find Addresses.
static int	query_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
static struct SimpleDialogWindows	query_dialog_new (struct AliasMenuData *mdata, const char *query)
	Create an Query Selection Dialog.
static bool	dlg_query (struct Buffer *buf, struct AliasMenuData *mdata)
	Get the user to enter an Address Query -.
int	query_complete (struct Buffer *buf, struct ConfigSubset *sub)
	Perform auto-complete using an Address Query.
void	query_index (struct Mailbox *m, struct ConfigSubset *sub)
	Perform an Alias Query and display the results.

Variables
static const struct Mapping	QueryHelp []
	Help Bar for the Address Query dialog.

Detailed Description

Routines for querying an external address book.

Authors

• Richard Russon
• Pietro Cerutti
• Dennis Schön
• Tóth János

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

Function Documentation

alias_to_addrlist()

bool alias_to_addrlist	(	struct AddressList *	al,
		struct Alias *	alias )

Turn an Alias into an AddressList.

Parameters

al	AddressList to fill (must be empty)
alias	Alias to use

Return values

true

Success

Definition at line 119 of file dlg_query.c.

{
  if (!al || !TAILQ_EMPTY(al) || !alias)
    return false;
 
  mutt_addrlist_copy(al, &alias->addr, false);
  if (!TAILQ_EMPTY(al))
  {
    struct Address *first = TAILQ_FIRST(al);
    struct Address *second = TAILQ_NEXT(first, entries);
    if (!second && !first->personal)
    {
      first->personal = buf_new(alias->name);
    }
 
    mutt_addrlist_to_intl(al, NULL);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_run()

int query_run	(	const char *	s,
		bool	verbose,
		struct AliasList *	al,
		const struct ConfigSubset *	sub )

Run an external program to find Addresses.

Parameters

s	String to match
verbose	If true, print progress messages
al	Alias list to fill
sub	Config items

Return values

0	Success
-1	Error

Definition at line 188 of file dlg_query.c.

{
  FILE *fp = NULL;
  char *buf = NULL;
  size_t buflen;
  char *msg = NULL;
  size_t msglen = 0;
  char *tok = NULL;
  char *next_tok = NULL;
  struct Buffer *cmd = buf_pool_get();
 
  const char *const c_query_command = cs_subset_string(sub, "query_command");
  buf_file_expand_fmt_quote(cmd, c_query_command, s);
 
  pid_t pid = filter_create(buf_string(cmd), NULL, &fp, NULL, NeoMutt->env);
  if (pid < 0)
  {
    mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", buf_string(cmd));
    buf_pool_release(&cmd);
    return -1;
  }
  buf_pool_release(&cmd);
 
  if (verbose)
    mutt_message(_("Waiting for response..."));
 
  struct Buffer *addr = buf_pool_get();
  /* The query protocol first reads one NL-terminated line. If an error
   * occurs, this is assumed to be an error message. Otherwise it's ignored. */
  msg = mutt_file_read_line(msg, &msglen, fp, NULL, MUTT_RL_NO_FLAGS);
  while ((buf = mutt_file_read_line(buf, &buflen, fp, NULL, MUTT_RL_NO_FLAGS)))
  {
    tok = buf;
    next_tok = strchr(tok, '\t');
    if (next_tok)
      *next_tok++ = '\0';
 
    if (*tok == '\0')
      continue;
 
    struct Alias *alias = alias_new();
 
    if (next_tok)
    {
      tok = next_tok;
      next_tok = strchr(tok, '\t');
      if (next_tok)
        *next_tok++ = '\0';
 
      // The address shouldn't be wrapped with <>s, but historically, this was supported
      if (buf[0] == '<')
        buf_printf(addr, "\"%s\" %s", tok, buf);
      else
        buf_printf(addr, "\"%s\" <%s>", tok, buf);
 
      mutt_addrlist_parse(&alias->addr, buf_string(addr));
 
      parse_alias_comments(alias, next_tok);
    }
    else
    {
      mutt_addrlist_parse(&alias->addr, buf); // Email address
    }
 
    TAILQ_INSERT_TAIL(al, alias, entries);
  }
  buf_pool_release(&addr);
 
  FREE(&buf);
  mutt_file_fclose(&fp);
  if (filter_wait(pid))
  {
    mutt_debug(LL_DEBUG1, "Error: %s\n", msg);
    if (verbose)
      mutt_error("%s", msg);
  }
  else
  {
    if (verbose)
      mutt_message("%s", msg);
  }
  FREE(&msg);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_dialog_new()

static struct SimpleDialogWindows query_dialog_new ( struct AliasMenuData * mdata, const char * query )

static

Create an Query Selection Dialog.

Parameters

mdata	Menu data holding Aliases
query	Initial query string

Return values

obj	SimpleDialogWindows Tuple containing Dialog, SimpleBar and Menu pointers

Definition at line 306 of file dlg_query.c.

{
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_QUERY, WT_DLG_QUERY, QueryHelp);
 
  struct Menu *menu = sdw.menu;
 
  menu->make_entry = query_make_entry;
  menu->tag = query_tag;
  menu->max = ARRAY_SIZE(&mdata->ava);
  mdata->title = mutt_str_dup(_("Query"));
  menu->mdata = mdata;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  struct MuttWindow *win_menu = menu->win;
 
  // Override the Simple Dialog's recalc()
  win_menu->recalc = alias_recalc;
 
  char title[256] = { 0 };
  snprintf(title, sizeof(title), "%s: %s", mdata->title, query);
  sbar_set_title(sdw.sbar, title);
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, alias_config_observer, menu);
  notify_observer_add(win_menu->notify, NT_WINDOW, query_window_observer, win_menu);
 
  return sdw;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_complete()

int query_complete	(	struct Buffer *	buf,
		struct ConfigSubset *	sub )

Perform auto-complete using an Address Query.

Parameters

buf	Buffer for completion
sub	Config item

Return values

0

Always

Definition at line 404 of file dlg_query.c.

{
  struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
  mdata.search_state = search_state_new();
 
  struct AliasList al = TAILQ_HEAD_INITIALIZER(al);
  const char *const c_query_command = cs_subset_string(sub, "query_command");
  if (!c_query_command)
  {
    mutt_warning(_("Query command not defined"));
    goto done;
  }
 
  query_run(buf_string(buf), true, &al, sub);
  if (TAILQ_EMPTY(&al))
    goto done;
 
  mdata.al = &al;
 
  struct Alias *a_first = TAILQ_FIRST(&al);
  if (!TAILQ_NEXT(a_first, entries)) // only one response?
  {
    struct AddressList addr = TAILQ_HEAD_INITIALIZER(addr);
    if (alias_to_addrlist(&addr, a_first))
    {
      mutt_addrlist_to_local(&addr);
      buf_reset(buf);
      mutt_addrlist_write(&addr, buf, false);
      mutt_addrlist_clear(&addr);
      mutt_clear_error();
      buf_addstr(buf, ", ");
    }
    goto done;
  }
 
  struct Alias *np = NULL;
  TAILQ_FOREACH(np, mdata.al, entries)
  {
    alias_array_alias_add(&mdata.ava, np);
  }
 
  /* multiple results, choose from query menu */
  if (!dlg_query(buf, &mdata))
    goto done;
 
  buf_reset(buf);
  buf_alloc(buf, 8192);
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_tagged)
      continue;
 
    struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
    if (alias_to_addrlist(&al_copy, avp->alias))
    {
      mutt_addrlist_to_local(&al_copy);
      mutt_addrlist_write(&al_copy, buf, false);
      mutt_addrlist_clear(&al_copy);
    }
    buf_addstr(buf, ", ");
  }
 
done:
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.title);
  FREE(&mdata.limit);
  search_state_free(&mdata.search_state);
  aliaslist_clear(&al);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_index()

void query_index	(	struct Mailbox *	m,
		struct ConfigSubset *	sub )

Perform an Alias Query and display the results.

Parameters

m	Mailbox
sub	Config item

Definition at line 481 of file dlg_query.c.

{
  const char *const c_query_command = cs_subset_string(sub, "query_command");
  if (!c_query_command)
  {
    mutt_warning(_("Query command not defined"));
    return;
  }
 
  struct AliasList al = TAILQ_HEAD_INITIALIZER(al);
  struct AliasMenuData mdata = { ARRAY_HEAD_INITIALIZER, NULL, sub };
  mdata.al = &al;
  mdata.search_state = search_state_new();
 
  struct Buffer *buf = buf_pool_get();
  if ((mw_get_field(_("Query: "), buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(buf))
  {
    goto done;
  }
 
  query_run(buf_string(buf), false, &al, sub);
  if (TAILQ_EMPTY(&al))
    goto done;
 
  struct Alias *np = NULL;
  TAILQ_FOREACH(np, mdata.al, entries)
  {
    alias_array_alias_add(&mdata.ava, np);
  }
 
  if (!dlg_query(buf, &mdata))
    goto done;
 
  // Prepare the "To:" field of a new email
  struct Email *e = email_new();
  e->env = mutt_env_new();
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata.ava)
  {
    if (!avp->is_tagged)
      continue;
 
    struct AddressList al_copy = TAILQ_HEAD_INITIALIZER(al_copy);
    if (alias_to_addrlist(&al_copy, avp->alias))
    {
      mutt_addrlist_copy(&e->env->to, &al_copy, false);
      mutt_addrlist_clear(&al_copy);
    }
  }
 
  mutt_send_message(SEND_REVIEW_TO, e, NULL, m, NULL, sub);
 
done:
  ARRAY_FREE(&mdata.ava);
  FREE(&mdata.title);
  FREE(&mdata.limit);
  search_state_free(&mdata.search_state);
  aliaslist_clear(&al);
  buf_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

QueryHelp

const struct Mapping QueryHelp[]

static

Initial value:

= {
  
  { N_("Exit"),       OP_EXIT },
  { N_("Mail"),       OP_MAIL },
  { N_("New Query"),  OP_QUERY },
  { N_("Make Alias"), OP_CREATE_ALIAS },
  { N_("Sort"),       OP_SORT },
  { N_("Rev-Sort"),   OP_SORT_REVERSE },
  { N_("Search"),     OP_SEARCH },
  { N_("Help"),       OP_HELP },
  { NULL, 0 },
  
}

Help Bar for the Address Query dialog.

Definition at line 99 of file dlg_query.c.

                                          {
  // clang-format off
  { N_("Exit"),       OP_EXIT },
  { N_("Mail"),       OP_MAIL },
  { N_("New Query"),  OP_QUERY },
  { N_("Make Alias"), OP_CREATE_ALIAS },
  { N_("Sort"),       OP_SORT },
  { N_("Rev-Sort"),   OP_SORT_REVERSE },
  { N_("Search"),     OP_SEARCH },
  { N_("Help"),       OP_HELP },
  { NULL, 0 },
  // clang-format on
};