accountcmd.c File Reference

Connection Credentials External Command. More...

#include "config.h"
#include <assert.h>
#include <stdio.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "accountcmd.h"
#include "connaccount.h"
#include "globals.h"
#include "mutt_account.h"

Include dependency graph for accountcmd.c:

Go to the source code of this file.

Functions
static void	make_cmd (struct Buffer *buf, const struct ConnAccount *cac, const char *cmd)
	Build the command line for the external account command.
static MuttAccountFlags	parse_one (struct ConnAccount *cac, char *line)
	Parse a single line of the response.
static MuttAccountFlags	call_cmd (struct ConnAccount *cac, const struct Buffer *cmd)
	Call the account command.
MuttAccountFlags	mutt_account_call_external_cmd (struct ConnAccount *cac)
	Retrieve account credentials via an external command.

Detailed Description

Connection Credentials External Command.

Authors

• Pietro Cerutti
• 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 accountcmd.c.

Function Documentation

make_cmd()

static void make_cmd ( struct Buffer *  buf, const struct ConnAccount *  cac, const char *  cmd  )

static

Build the command line for the external account command.

Parameters

buf	Buffer to fill with a command line
cac	ConnAccount to read params from
cmd	Account command from the user config

Definition at line 48 of file accountcmd.c.

{
  assert(buf && cac);
 
  buf_addstr(buf, cmd);
  buf_add_printf(buf, " --hostname %s", cac->host);
  if (cac->flags & MUTT_ACCT_USER)
  {
    buf_add_printf(buf, " --username %s", cac->user);
  }
 
  static const char *types[] = { "", "imap", "pop", "smtp", "nntp" };
  assert(sizeof(types) / sizeof(*types) == MUTT_ACCT_TYPE_MAX);
  if (cac->type != MUTT_ACCT_TYPE_NONE)
  {
    buf_add_printf(buf, " --type %s%c", types[cac->type],
                   (cac->flags & MUTT_ACCT_SSL) ? 's' : '\0');
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_one()

static MuttAccountFlags parse_one ( struct ConnAccount *  cac, char *  line  )

static

Parse a single line of the response.

Parameters

cac	ConnAccount to write to
line	Line from the response

Return values

num	MuttAccountFlags that matched
MUTT_ACCT_NO_FLAGS	Failure

Definition at line 75 of file accountcmd.c.

{
  assert(cac && line);
 
  const regmatch_t *match = mutt_prex_capture(PREX_ACCOUNT_CMD, line);
  if (!match)
  {
    mutt_perror(_("Line is malformed: expected <key: val>, got <%s>"), line);
    return MUTT_ACCT_NO_FLAGS;
  }
 
  const regmatch_t *keymatch = &match[PREX_ACCOUNT_CMD_MATCH_KEY];
  const regmatch_t *valmatch = &match[PREX_ACCOUNT_CMD_MATCH_VALUE];
  line[mutt_regmatch_start(keymatch) + mutt_regmatch_len(keymatch)] = '\0';
  const char *key = line + mutt_regmatch_start(keymatch);
  const char *val = line + mutt_regmatch_start(valmatch);
 
  switch (key[0])
  {
    case 'l':
      if (mutt_str_equal(key + 1, "ogin"))
      {
        mutt_str_copy(cac->login, val, sizeof(cac->login));
        return MUTT_ACCT_LOGIN;
      }
      break;
 
    case 'p':
      if (mutt_str_equal(key + 1, "assword"))
      {
        mutt_str_copy(cac->pass, val, sizeof(cac->pass));
        return MUTT_ACCT_PASS;
      }
      break;
 
    case 'u':
      if (mutt_str_equal(key + 1, "sername"))
      {
        mutt_str_copy(cac->user, val, sizeof(cac->user));
        return MUTT_ACCT_USER;
      }
      break;
 
    default:
      break;
  }
 
  mutt_warning(_("Unhandled key in line <%s: %s>"), key, val);
  return MUTT_ACCT_NO_FLAGS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

call_cmd()

static MuttAccountFlags call_cmd ( struct ConnAccount *  cac, const struct Buffer *  cmd  )

static

Call the account command.

Parameters

cac	ConnAccount to write to
cmd	Command line to run

Return values

num	MuttAccountFlags that matched
MUTT_ACCT_NO_FLAGS	Failure

Definition at line 133 of file accountcmd.c.

{
  assert(cac && cmd);
 
  MuttAccountFlags rc = MUTT_ACCT_NO_FLAGS;
 
  FILE *fp = NULL;
  pid_t pid = filter_create(buf_string(cmd), NULL, &fp, NULL, EnvList);
  if (pid < 0)
  {
    mutt_perror(_("Unable to run account command"));
    return rc;
  }
 
  size_t len = 0;
  char *line = NULL;
  while ((line = mutt_file_read_line(NULL, &len, fp, NULL, MUTT_RL_NO_FLAGS)))
  {
    rc |= parse_one(cac, line);
    FREE(&line);
  }
 
  mutt_file_fclose(&fp);
  filter_wait(pid);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_account_call_external_cmd()

MuttAccountFlags mutt_account_call_external_cmd

(

struct ConnAccount *

cac

)

Retrieve account credentials via an external command.

Parameters

cac	ConnAccount to fill

Return values

num	A bitmask of MuttAccountFlags that were retrieved on success
MUTT_ACCT_NO_FLAGS	Failure

Definition at line 166 of file accountcmd.c.

{
  if (!cac || (cac->host[0] == '\0') || (cac->type == MUTT_ACCT_TYPE_NONE))
  {
    return MUTT_ACCT_NO_FLAGS;
  }
 
  const char *c_account_command = cs_subset_string(NeoMutt->sub, "account_command");
  if (!c_account_command)
  {
    return MUTT_ACCT_NO_FLAGS;
  }
 
  MuttAccountFlags rc = MUTT_ACCT_NO_FLAGS;
  struct Buffer *cmd_buf = buf_pool_get();
 
  make_cmd(cmd_buf, cac, c_account_command);
  rc = call_cmd(cac, cmd_buf);
  cac->flags |= rc;
 
  buf_pool_release(&cmd_buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function: