Fix a few cppcheck warnings.

[pwmd.git] / src / commands.c

/*
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015
    Ben Kibbey <bjk@luxsci.net>

    This file is part of pwmd.

    Pwmd 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.

    Pwmd 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 Pwmd.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#include <dirent.h>
#include <pthread.h>
#include <stdint.h>
#include <assert.h>

#ifdef WITH_LIBACL
#include <sys/acl.h>
#endif

#include "pwmd-error.h"
#include <gcrypt.h>

#include "mem.h"
#include "xml.h"
#include "util-misc.h"
#include "common.h"
#include "rcfile.h"
#include "cache.h"
#include "commands.h"
#include "mutex.h"
#include "crypto.h"
#include "pinentry.h"

/* These are command option flags. */
#define OPT_INQUIRE             0x0001
#define OPT_NO_PASSPHRASE       0x0002
#define OPT_RESET               0x0004
#define OPT_LIST_RECURSE        0x0008
#define OPT_VERBOSE             0x0010
#define OPT_LOCK                0x0020
#define OPT_LOCK_ON_OPEN        0x0040
#define OPT_SIGN                0x0080
#define OPT_LIST_ALL            0x0100
#define OPT_LIST_WITH_TARGET    0x0200
#define OPT_DATA                0x0400
#define OPT_NO_AGENT            0x0800
#define OPT_ASK                 0x1000

#ifdef WITH_AGENT
/* The GETCONFIG command, for example, may fail because pwmd lost the
 * gpg-agent connection. Update the recovered agent ctx. */
#define UPDATE_AGENT_CTX(client, crypto)        do {                    \
    if (crypto && crypto->agent && crypto->agent->did_restart           \
        && client->crypto && client->crypto->agent                      \
        && client->crypto->agent->ctx &&                                \
        crypto->agent->ctx != client->crypto->agent->ctx)               \
      {                                                                 \
        client->crypto->agent->ctx = crypto->agent->ctx;                \
        crypto->agent->ctx = NULL;                                      \
      }                                                                 \
  }  while (0)
#else
#define UPDATE_AGENT_CTX(client, crypto)
#endif

#define FLOCK_TYPE_NONE   0
#define FLOCK_TYPE_SH     0x0001
#define FLOCK_TYPE_EX     0x0002
#define FLOCK_TYPE_KEEP   0x0004

struct command_table_s
{
  const char *name;
  gpg_error_t (*handler) (assuan_context_t, char *line);
  const char *help;
  int ignore_startup;
  int unlock;                   // unlock the file mutex after validating the checksum
  uint32_t flock_type;
};

static struct command_table_s **command_table;

static gpg_error_t do_lock (struct client_s *client, int add);
static gpg_error_t validate_checksum (struct client_s *,
                                      struct cache_data_s *);
static gpg_error_t update_checksum (struct client_s *client);

/* When 'status' is true the 'self' field of the status line will be false
 * because we never send the STATE status message to the same client that
 * initiated it. */
static char *
build_client_info_line (struct client_thread_s *thd, int status)
{
  MUTEX_LOCK (&cn_mutex);
  int with_state = config_get_boolean ("global", "send_state");
  char *uid, *username = NULL;
  char *line;

#ifdef WITH_GNUTLS
  if (thd->remote)
    uid = str_asprintf("#%s", thd->tls->fp);
  else
    {
      uid = str_asprintf("%u", thd->peer->uid);
      username = get_username (thd->peer->uid);
    }
#else
  uid = str_asprintf("%u", thd->peer->uid);
  username = get_username (thd->peer->uid);
#endif
  line = str_asprintf ("%p %s %s %s %u %u %u %s %s",
                       thd->tid,
                       thd->name ? thd->name : "-",
                       thd->cl && thd->cl->filename
                       && (thd->cl->flags & FLAG_OPEN)
                       ? thd->cl->filename : "/",
#ifdef WITH_GNUTLS
                       thd->remote ? thd->peeraddr : "-",
#else
                       "-",
#endif
                       thd->cl && thd->cl->flags & FLAG_HAS_LOCK ? 1 : 0,
                       !status &&  pthread_equal (pthread_self (), thd->tid) ? 1 : 0,
                       with_state ? thd->state : CLIENT_STATE_UNKNOWN, uid,
#ifdef WITH_GNUTLS
                       thd->remote ? "" : username
#else
                       username
#endif
  );

  xfree (username);
  xfree (uid);
  MUTEX_UNLOCK (&cn_mutex);
  return line;
}

void
update_client_state (struct client_s *client, unsigned s)
{
  client->thd->state = s;
  int n = config_get_boolean ("global", "send_state");

  if (n && client->thd->state != CLIENT_STATE_UNKNOWN)
    {
      char *line = build_client_info_line (client->thd, 1);

      if (line)
        send_status_all_not_self (n == 2, STATUS_STATE, "%s", line);
    }
}

static gpg_error_t
unlock_file_mutex (struct client_s *client, int remove)
{
  gpg_error_t rc = 0;

  // OPEN: keep the lock for the same file being reopened.
  if (client->flags & FLAG_KEEP_LOCK && client->flags & FLAG_HAS_LOCK)
    return 0;

  if (!(client->flags & FLAG_HAS_LOCK))
    return GPG_ERR_NOT_LOCKED;

  rc = cache_unlock_mutex (client->md5file, remove);
  if (rc)
    rc = GPG_ERR_INV_STATE;
  else
    client->flags &= ~(FLAG_HAS_LOCK | FLAG_LOCK_CMD);

  return rc;
}

static gpg_error_t
lock_file_mutex (struct client_s *client, int add)
{
  gpg_error_t rc = 0;
  int timeout = config_get_integer (client->filename, "cache_timeout");

  if (client->flags & FLAG_HAS_LOCK)
    return 0;

  rc = cache_lock_mutex (client->ctx, client->md5file,
                         client->lock_timeout, add, timeout);
  if (!rc)
    client->flags |= FLAG_HAS_LOCK;

  return rc;
}

static gpg_error_t
file_modified (struct client_s *client, struct command_table_s *cmd)
{
  gpg_error_t rc = 0;
  int type = !cmd->flock_type || (cmd->flock_type & FLOCK_TYPE_SH)
    ? LOCK_SH : LOCK_EX;

  if (!(client->flags & FLAG_OPEN))
    return GPG_ERR_INV_STATE;

  rc = lock_file_mutex (client, 0);
  if (rc && rc != GPG_ERR_NO_DATA)
    return rc;

  rc = lock_flock (client->ctx, client->filename, type, &client->flock_fd);
  if (!rc)
    {
      rc = validate_checksum (client, NULL);
      if (gpg_err_code (rc) == GPG_ERR_ENOENT && (client->flags & FLAG_NEW))
        rc = 0;
      else if (rc)
        log_write ("%s: %s", client->filename, pwmd_strerror (rc));
    }
  else if (gpg_err_code(rc) == GPG_ERR_ENOENT)
    rc = 0;

  if ((cmd->unlock && !(client->flags & FLAG_HAS_LOCK)) || rc)
    unlock_file_mutex (client, 0);

  if (rc || !(cmd->flock_type & FLOCK_TYPE_KEEP))
    unlock_flock (&client->flock_fd);

  return rc;
}

static gpg_error_t
parse_xml (assuan_context_t ctx, int new)
{
  struct client_s *client = assuan_get_pointer (ctx);
  int cached = client->doc != NULL;
  gpg_error_t rc = 0;

  if (new)
    {
      client->doc = new_document ();
      if (client->doc)
        {
          xmlChar *result;
          int len;

          xmlDocDumpFormatMemory (client->doc, &result, &len, 0);
          client->crypto->plaintext = result;
          client->crypto->plaintext_len = len;
          if (!client->crypto->plaintext)
            {
              xmlFreeDoc (client->doc);
              client->doc = NULL;
              rc = GPG_ERR_ENOMEM;
            }
        }
      else
        rc = GPG_ERR_ENOMEM;
    }
  else if (!cached)
    rc = parse_doc ((char *) client->crypto->plaintext,
                    client->crypto->plaintext_len, (xmlDocPtr *)&client->doc);

  return rc;
}

static void
free_client (struct client_s *client)
{
  if (client->doc)
    xmlFreeDoc (client->doc);

  xfree (client->crc);
  xfree (client->filename);
  xfree (client->last_error);

  if (client->crypto)
    {
      cleanup_crypto_stage2 (client->crypto);
      if (client->crypto->pkey_sexp)
        gcry_sexp_release (client->crypto->pkey_sexp);

      if (client->crypto->sigpkey_sexp)
        gcry_sexp_release (client->crypto->sigpkey_sexp);

      client->crypto->pkey_sexp = NULL;
      client->crypto->sigpkey_sexp = NULL;
      memset (client->crypto->sign_grip, 0,
              sizeof (client->crypto->sign_grip));
      memset (client->crypto->grip, 0, sizeof(client->crypto->grip));
    }
}

void
cleanup_client (struct client_s *client)
{
  assuan_context_t ctx = client->ctx;
  struct client_thread_s *thd = client->thd;
  struct crypto_s *crypto = client->crypto;
  long lock_timeout = client->lock_timeout;
  int no_pinentry = (client->flags & FLAG_NO_PINENTRY);
  struct pinentry_option_s pin_opts;
  xmlErrorPtr xml_error = client->xml_error;
  int flock_fd = client->flock_fd;
#ifdef WITH_AGENT
  struct pinentry_option_s agent_pin_opts;

  if (crypto && crypto->agent)
    memcpy (&agent_pin_opts, &crypto->agent->pinentry_opts,
            sizeof(struct pinentry_option_s));
#endif

  memcpy (&pin_opts, &client->pinentry_opts, sizeof(struct pinentry_option_s));
  unlock_file_mutex (client, client->flags & FLAG_NEW);
  free_client (client);
  memset (client, 0, sizeof (struct client_s));
  client->flock_fd = flock_fd;
  client->xml_error = xml_error;
  client->crypto = crypto;
  client->ctx = ctx;
  client->thd = thd;
  client->lock_timeout = lock_timeout;
  memcpy (&client->pinentry_opts, &pin_opts, sizeof(struct pinentry_option_s));
  client->flags |= no_pinentry ? FLAG_NO_PINENTRY : 0;
#ifdef WITH_AGENT
  if (crypto && crypto->agent)
    memcpy (&crypto->agent->pinentry_opts, &agent_pin_opts,
            sizeof(struct pinentry_option_s));
#endif
}

static gpg_error_t
open_finalize (assuan_context_t ctx, char *key, size_t keylen)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc = 0;
  struct cache_data_s *cdata = cache_get_data (client->md5file);
  int cached = 0, keyarg = key ? 1 : 0;
  size_t keysize;
  unsigned char *salted_key = NULL;
  int algo;
  int pin_try = 1;
  int pin_tries = 3;
  char *pin_title = client->pinentry_opts.title;

  client->crypto->filename = str_dup (client->filename);
  if (cdata || client->flags & FLAG_NEW)
    {
      if (cdata && !(client->flags & FLAG_NEW))
        {
          rc = decrypt_cache (client->crypto, cdata->doc, cdata->doclen);
          if (rc)
            return rc;
        }

      cached = cdata != NULL;
      goto done;
    }

  if (!key && !IS_PKI (client->crypto)
      && !(client->crypto->hdr.flags & PWMD_FLAG_NO_PASSPHRASE))
    {
      if (client->flags & FLAG_NO_PINENTRY)
        {
          rc = inquire_passphrase (ctx, "PASSPHRASE", (unsigned char **)&key,
                                   &keylen);
          if (rc)
            return rc;
        }
      else
        {
          client->pinentry_opts.timeout = config_get_integer (client->filename,
                                                              "pinentry_timeout");
        pin_again:
          rc = getpin_common (client->ctx, client->filename, PINENTRY_OPEN,
                              &key, &keylen);
          if (rc)
            return rc;
        }
    }

  if (!IS_PKI (client->crypto))
    {
      if (client->crypto->hdr.flags & PWMD_FLAG_NO_PASSPHRASE)
        {
          keylen = 1;
          key = gcry_malloc (keylen);
          memset (key, 0, keylen);
        }

      algo = cipher_to_gcrypt (client->crypto->hdr.flags);
      rc = hash_key (algo, client->crypto->hdr.salt,
                     sizeof(client->crypto->hdr.salt), key, keylen,
                     (void **)&salted_key, &keysize,
                     client->crypto->hdr.version <= 0x03000e ? COMPAT_KDFS2K_ITERATIONS : client->crypto->hdr.s2k_count);
      if (!keyarg)
        gcry_free (key);

      if (!rc)
        {
          rc = decrypt_data (client->ctx, client->crypto, salted_key, keysize);
          if (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
              && ++pin_try <= pin_tries && !(client->flags & FLAG_NO_PINENTRY))
            {
              gcry_free (salted_key);
              salted_key = NULL;
              key = NULL;
              keylen = 0;
              client->pinentry_opts.title = str_asprintf (_ ("Bad passphrase (try %i of %i)"), pin_try, pin_tries);
              goto pin_again;
            }
        }

      if (client->pinentry_opts.title != pin_title)
        xfree (client->pinentry_opts.title);

      client->pinentry_opts.title = pin_title;
      if (rc)
        {
          gcry_free (salted_key);
          return rc;
        }

      cdata = xcalloc (1, sizeof (struct cache_data_s));
      if (!cdata)
        {
          gcry_free (salted_key);
          return GPG_ERR_ENOMEM;
        }

      cdata->key = salted_key;
      cdata->keylen = keysize;
    }
  else
#ifdef WITH_AGENT
    rc = decrypt_data (client->ctx, client->crypto, NULL, 0);
#else
    rc = GPG_ERR_NOT_IMPLEMENTED;
#endif

 done:
  if (!rc)
    {
      rc = parse_xml (ctx, client->flags & FLAG_NEW);
      if (rc && !cached)
        free_cache_data_once (cdata);

      if (!rc)
        {
          int timeout = config_get_integer (client->filename,
                                            "cache_timeout");

          if (!cached)
            {
              if (!cdata)
                cdata = xcalloc (1, sizeof (struct cache_data_s));

              rc = encrypt_xml (NULL, cache_key, cache_keysize,
                                GCRY_CIPHER_AES, client->crypto->plaintext,
                                client->crypto->plaintext_len, &cdata->doc,
                                &cdata->doclen, &cache_iv, &cache_blocksize);
              if (!rc && !(client->flags & FLAG_NEW) && IS_PKI (client->crypto))
                {
                  rc = gcry_sexp_build ((gcry_sexp_t *) & cdata->pubkey, NULL,
                                        "%S", client->crypto->pkey_sexp);
                }
            }

          if (cdata->sigkey)
            gcry_sexp_release (cdata->sigkey);

          cdata->sigkey = NULL;
          if (!rc && IS_PKI (client->crypto))
            rc = gcry_sexp_build ((gcry_sexp_t *) &cdata->sigkey, NULL,
                                  "%S", client->crypto->sigpkey_sexp);

          if (!rc)
            {
             rc = cache_add_file (client->md5file,
                                      (client->flags & FLAG_NEW) ? NULL
                                      : client->crypto->grip, cdata, timeout);
             if (rc)
               {
                 if (!cached)
                   {
                     free_cache_data_once (cdata);
                     xmlFreeDoc (client->doc);
                     client->doc = NULL;
                   }
               }
            }

          if (!rc)
            client->flags |= FLAG_OPEN;
        }
    }

  if (!rc)
    {
      rc = update_checksum (client);
      if (gpg_err_code (rc) == GPG_ERR_ENOENT)
        rc = 0;
    }

  if (!rc && (client->opts & OPT_LOCK_ON_OPEN))
    rc = do_lock (client, 0);

  return rc;
}

static void
req_cleanup (void *arg)
{
  if (!arg)
    return;

  strv_free ((char **) arg);
}

static gpg_error_t
parse_open_opt_lock (void *data, void *value)
{
  struct client_s *client = data;

  client->opts |= OPT_LOCK_ON_OPEN;
  return 0;
}

static gpg_error_t
parse_save_opt_inquire (void *data, void *value)
{
  struct client_s *client = data;
  gpg_error_t rc;

  if (!(client->flags & FLAG_NEW))
    {
      rc = peer_is_invoker (client);
      if (rc == GPG_ERR_EACCES)
        return rc;
    }

  (void) value;
  client->opts |= OPT_INQUIRE;
  return 0;
}

static gpg_error_t
parse_opt_inquire (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_INQUIRE;
  return 0;
}

static gpg_error_t
update_checksum (struct client_s *client)
{
  unsigned char *crc;
  size_t len;
  struct cache_data_s *cdata;
  gpg_error_t rc = get_checksum (client->filename, &crc, &len);

  if (rc)
    return rc;

  xfree (client->crc);
  client->crc = crc;
  cdata = cache_get_data (client->md5file);
  if (cdata)
    {
      xfree (cdata->crc);
      cdata->crc = xmalloc (len);
      memcpy (cdata->crc, crc, len);
    }

  return 0;
}

static gpg_error_t
validate_checksum (struct client_s *client, struct cache_data_s *cdata)
{
  unsigned char *crc;
  size_t len;
  gpg_error_t rc;
  int n = 0;

  if (cdata && !cdata->crc)
    return GPG_ERR_CHECKSUM;

  rc = get_checksum (client->filename, &crc, &len);
  if (rc)
    return rc;

  if (cdata)
    n = memcmp (cdata->crc, crc, len);
  else if (client->crc)
    n = memcmp (client->crc, crc, len);

  xfree (crc);
  return n ? GPG_ERR_CHECKSUM : 0;
}

static gpg_error_t
do_open (assuan_context_t ctx, const char *password)
{
  struct client_s *client = assuan_get_pointer (ctx);
  struct cache_data_s *cdata;
  gpg_error_t rc = 0;
  int done = 0;

  // Cached document?
  cdata = cache_get_data (client->md5file);
  if (cdata && cdata->doc)
    {
      int defer = 0;

      /* This will check that the key is cached in the agent which needs to
       * be determined for files that share a keygrip. */
      if (!rc)
        {
          rc = cache_iscached (client->filename, &defer);
          if ((!rc || rc == GPG_ERR_ENOENT) && defer)
            rc = GPG_ERR_KEY_EXPIRED;
        }

      if (!rc && !(client->flags & FLAG_NEW))
        rc = validate_checksum (client, cdata);

#ifdef WITH_GNUTLS
      if (!rc && client->thd->remote
          && config_get_boolean (client->filename, "tcp_require_key"))
        rc = crypto_try_decrypt (ctx, client->flags & FLAG_NO_PINENTRY,
                                 client->filename, NULL, NULL, NULL);
#endif

      if (!rc && !password)
        {
          rc = read_data_header (client->filename, &client->crypto->hdr,
                                 NULL, NULL);
          if (!rc)
            {
              if (IS_PKI (client->crypto))
                {
                  gcry_sexp_build (&client->crypto->pkey_sexp, NULL, "%S",
                                   cdata->pubkey);
                  gcry_pk_get_keygrip (client->crypto->pkey_sexp,
                                       client->crypto->grip);
                  gcry_sexp_build (&client->crypto->sigpkey_sexp, NULL, "%S",
                                   cdata->sigkey);
                  gcry_pk_get_keygrip (client->crypto->sigpkey_sexp,
                                       client->crypto->sign_grip);
                }

              if (!rc)
                {
                  rc = open_finalize (ctx, NULL, 0);
                  done = 1;
                }
            }
        }

      /* There was an error accessing the file so clear the cache entry. The
       * real error will be returned from read_data_file() since the file
       * may have only disappeared. */
      if (!done)
        {
          log_write ("%s: %s", client->filename, pwmd_strerror (rc));
          rc = cache_clear (client->md5file);
          send_status_all (STATUS_CACHE, NULL);
        }
    }

  if (done || rc)
    return rc;

  rc = read_data_file (client->filename, client->crypto);
  if (rc)
    {
      if (gpg_err_source (rc) != GPG_ERR_SOURCE_DEFAULT ||
          gpg_err_code (rc) != GPG_ERR_ENOENT)
        {
          log_write ("%s: %s", client->filename, pwmd_strerror (rc));
          return rc;
        }

      client->flags |= FLAG_NEW;
      memset (client->crypto->grip, 0, sizeof (client->crypto->grip));
      memset (client->crypto->sign_grip, 0,
              sizeof (client->crypto->sign_grip));
      rc = open_finalize (ctx, NULL, 0);
      return rc;
    }

  if (password && IS_PKI (client->crypto))
    {
#ifdef WITH_AGENT
      rc = set_agent_passphrase (client->crypto, password, strlen (password));
      if (rc)
        return rc;
#endif
    }

  rc = open_finalize (ctx, (char *)password, password ? strlen (password) : 0);
  return rc;
}

static gpg_error_t
open_command (assuan_context_t ctx, char *line)
{
  gpg_error_t rc;
  struct client_s *client = assuan_get_pointer (ctx);
  char **req, *filename;
  unsigned char md5file[16];
  int same_file = 0;
  assuan_peercred_t peer;
  struct argv_s *args[] = {
    &(struct argv_s) {"lock", OPTION_TYPE_NOARG, parse_open_opt_lock},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (rc)
    return send_error (ctx, rc);

  req = str_split (line, " ", 2);
  if (!req)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = do_validate_peer (ctx, req[0], &peer);
  if (rc)
    {
      strv_free (req);
      return send_error (ctx, rc);
    }

  filename = req[0];
  if (!valid_filename (filename))
    {
      strv_free (req);
      return send_error (ctx, GPG_ERR_INV_VALUE);
    }

  pthread_cleanup_push (req_cleanup, req);
  gcry_md_hash_buffer (GCRY_MD_MD5, md5file, filename, strlen (filename));
  /* This client may have locked a different file with ISCACHED --lock than
   * the current filename. This will remove that lock. */
  same_file = !memcmp (md5file, client->md5file, 16) ? 1 : 0;
  if (client->flags & FLAG_OPEN ||
      (client->flags & FLAG_HAS_LOCK && !same_file))
    {
      uint32_t opts = client->opts;
      uint32_t flags = client->flags;

      if (same_file)
        client->flags |= FLAG_KEEP_LOCK;
      else if (client->flags & FLAG_NEW)
        cache_clear (client->md5file);

      cleanup_client (client);
      client->opts = opts;
      client->flags |= flags;
      client->flags &= ~(FLAG_LOCK_CMD);
      if (!same_file)
        client->flags &= ~(FLAG_HAS_LOCK | FLAG_NEW);
    }

  memcpy (client->md5file, md5file, 16);
  client->filename = str_dup (filename);
  if (!client->filename)
    rc = GPG_ERR_ENOMEM;

  /* Need to lock the mutex here because file_modified() cannot without
   * knowing the filename. */
  if (!rc)
    {
      rc = lock_file_mutex (client, 1);
      if (rc)
        client->flags &= ~FLAG_OPEN;
    }

  if (!rc)
    {
      rc = lock_flock (ctx, filename, LOCK_SH, &client->flock_fd);
      if (!rc || gpg_err_code (rc) == GPG_ERR_ENOENT)
        rc = 0;
    }

  if (!rc)
    {
      struct stat st;

      if (stat (filename, &st) == -1 && errno != ENOENT)
        rc = gpg_error_from_syserror ();
      else if (!errno)
        {
          if (!rc && !S_ISREG (st.st_mode)) // to match LS output
            rc = gpg_error_from_errno (ENOANO);
        }
    }

  if (!rc)
    {
      char *password = req[1] && *req[1] ? req[1] : NULL;

#ifdef WITH_AGENT
      if (IS_PKI (client->crypto))
        rc = set_pinentry_mode (client->crypto->agent,
                                (client->flags & FLAG_NO_PINENTRY) ? "loopback"
                                : "ask");
#endif
      if (!rc)
        {
          rc = do_open (ctx, password);
          if (rc)
            cleanup_client (client);

          cleanup_crypto_stage1 (client->crypto);
        }
    }

  pthread_cleanup_pop (1);

  if (!rc && client->flags & FLAG_NEW)
    rc = send_status (ctx, STATUS_NEWFILE, NULL);

#ifdef WITH_AGENT
  (void) kill_scd (client->crypto->agent);
#endif

  return send_error (ctx, rc);
}

static gpg_error_t
parse_opt_no_passphrase (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_NO_PASSPHRASE;
  return 0;
}

static gpg_error_t
parse_save_opt_no_agent (void *data, void *value)
{
  struct client_s *client = data;

  client->opts |= OPT_NO_AGENT;
  return 0;
}

static gpg_error_t
parse_save_opt_cipher (void *data, void *value)
{
  struct client_s *client = data;
  int algo = cipher_string_to_gcrypt ((char *) value);
  file_header_t *hdr = &client->crypto->save.hdr;
  gpg_error_t rc = 0;

  if (algo == -1)
    return GPG_ERR_INV_VALUE;

  if (!(client->flags & FLAG_NEW))
    {
      rc = peer_is_invoker (client);
      if (rc == GPG_ERR_EACCES)
        {
          uint64_t flags = 0;

          flags &= ((uint16_t) ((uint32_t) (flags & 0xFFFFFFFF)));
          if (!(client->crypto->hdr.flags & gcrypt_to_cipher (algo)))
              return rc;

          rc = 0;
        }
      else if (rc)
        return rc;
    }

  if (!rc)
    hdr->flags = set_cipher_flag (hdr->flags, algo);

  return rc;
}

#ifdef WITH_AGENT
static gpg_error_t
permitted_to_save (struct client_s *client, const unsigned char *grip,
                   size_t size, const char *value)
{
  gpg_error_t rc = 0;

  if (!(client->flags & FLAG_NEW))
    {
      char *hexgrip = bin2hex (grip, size);

      rc = !strcmp (hexgrip, (char *)value) ? 0 : GPG_ERR_EACCES;
      xfree (hexgrip);
      if (rc)
        rc = peer_is_invoker (client);
    }

  return rc;
}
#endif

static gpg_error_t
parse_save_opt_keygrip (void *data, void *value)
{
#ifdef WITH_AGENT
  struct client_s *client = data;
  gpg_error_t rc = permitted_to_save (client, client->crypto->grip,
                                      sizeof (client->crypto->grip),
                                      value);

  if (!IS_PKI (client->crypto))
    return GPG_ERR_INV_ARG;

  if (rc)
    return rc;

  if (client->crypto->save.pkey)
    gcry_sexp_release (client->crypto->save.pkey);

  client->crypto->save.pkey = NULL;
  return get_pubkey (client->crypto, value, &client->crypto->save.pkey);
#else
  return GPG_ERR_INV_ARG;
#endif
}

static gpg_error_t
parse_save_opt_sign_keygrip (void *data, void *value)
{
#ifdef WITH_AGENT
  struct client_s *client = data;
  gpg_error_t rc = permitted_to_save (client, client->crypto->sign_grip,
                                      sizeof (client->crypto->sign_grip),
                                      value);

  if (!IS_PKI (client->crypto))
    return GPG_ERR_INV_ARG;

  if (rc)
    return rc;

  if (client->crypto->save.sigpkey)
    gcry_sexp_release (client->crypto->save.sigpkey);

  client->crypto->save.sigpkey = NULL;
  return get_pubkey (client->crypto, value, &client->crypto->save.sigpkey);
#else
  return GPG_ERR_INV_ARG;
#endif
}

static gpg_error_t
parse_opt_s2k_count (void *data, void *value)
{
  struct client_s *client = data;
  char *v = value, *p;
  uint64_t n;

  if (!v || !*v)
    return GPG_ERR_INV_VALUE;

  errno = 0;
  n = strtoull (v, &p, 10);
  if (n == UINT64_MAX && errno)
    return gpg_error_from_errno (errno);
  else if (p && *p)
    return GPG_ERR_INV_VALUE;

  if (!(client->flags & FLAG_NEW))
    {
      gpg_error_t rc = peer_is_invoker (client);

      if (rc == GPG_ERR_EACCES)
        {
          if (n && client->crypto->hdr.s2k_count != n)
            return rc;

          rc = 0;
        }
      else if (rc)
        return rc;
    }

  // Keep compatibility with libpwmd passing --s2k-count=0. If somehow
  // s2k_count == 0 it will be set to DEFAULT_KDFS2K_ITERATIONS in
  // save_command().
  if (n)
    client->crypto->save.hdr.s2k_count = n;

  return 0;
}

static gpg_error_t
save_finalize (assuan_context_t ctx)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc = 0;
  xmlChar *xmlbuf = NULL;
  int xmlbuflen;
  void *key = NULL;
  size_t keylen = 0;

  xmlDocDumpFormatMemory (client->doc, &xmlbuf, &xmlbuflen, 0);
  if (!xmlbuf)
    return GPG_ERR_ENOMEM;

  pthread_cleanup_push (xmlFree, xmlbuf);

  if (!use_agent || ((client->flags & FLAG_NEW)
                     && (client->opts & OPT_NO_AGENT))
      || !(client->crypto->hdr.flags & PWMD_FLAG_PKI))
    {
      rc = export_common (ctx, client->flags & FLAG_NO_PINENTRY,
                          client->crypto, xmlbuf, xmlbuflen, client->filename,
                          NULL, &key, &keylen, 1, 1,
                          (client->opts & OPT_NO_PASSPHRASE));
    }
#ifdef WITH_AGENT
  else
    {
      gcry_sexp_t pubkey = client->crypto->save.pkey;
      gcry_sexp_t sigkey = client->crypto->save.sigpkey;

      if (!pubkey)
        pubkey = client->crypto->pkey_sexp;

      if (!sigkey)
        {
          sigkey = client->crypto->sigpkey_sexp;
          if (!sigkey)
            {
              gcry_sexp_build (&client->crypto->save.sigpkey, 0, "%S", pubkey);
              sigkey = client->crypto->save.sigpkey;
            }
        }

      rc = encrypt_data_file (client->ctx, client->crypto, pubkey, sigkey,
                              client->filename, xmlbuf, xmlbuflen);
      if (pubkey == client->crypto->save.pkey)
        {
          if (!rc)
            {
              gcry_sexp_release (client->crypto->pkey_sexp);
              client->crypto->pkey_sexp = client->crypto->save.pkey;
              gcry_pk_get_keygrip (client->crypto->pkey_sexp,
                                   client->crypto->grip);
            }
          else
            gcry_sexp_release (pubkey);

          client->crypto->save.pkey = NULL;
        }

      if (!rc)
        gcry_pk_get_keygrip (sigkey, client->crypto->sign_grip);

      if (sigkey == client->crypto->save.sigpkey)
        {
          if (!rc)
            {
              if (client->crypto->sigpkey_sexp)
                gcry_sexp_release (client->crypto->sigpkey_sexp);

              client->crypto->sigpkey_sexp = client->crypto->save.sigpkey;
              gcry_pk_get_keygrip (client->crypto->sigpkey_sexp,
                                   client->crypto->sign_grip);
            }
          else
            gcry_sexp_release (sigkey);

          client->crypto->save.sigpkey = NULL;
        }
    }
#endif

  if (!rc)
    {
      int cached;

      rc = save_common (client->filename, client->crypto, xmlbuf, xmlbuflen,
                        key, keylen, &cached, client->opts & OPT_NO_AGENT);
      gcry_free (key);

      if (!rc && (!cached || (client->flags & FLAG_NEW)))
        send_status_all (STATUS_CACHE, NULL);

      if (!rc)
        {
          rc = update_checksum (client);
          client->flags &= ~(FLAG_NEW);
        }
    }

  pthread_cleanup_pop (1);      // xmlFree
  return rc;
}

static gpg_error_t
parse_opt_reset (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_RESET;
  return 0;
}

static gpg_error_t
parse_opt_ask (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_ASK;
  return 0;
}

static gpg_error_t
save_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct stat st;
  struct argv_s *args[] = {
    &(struct argv_s) {"no-passphrase", OPTION_TYPE_NOARG,
                      parse_opt_no_passphrase},
    &(struct argv_s) {"cipher", OPTION_TYPE_ARG, parse_save_opt_cipher},
    &(struct argv_s) {"inquire-keyparam", OPTION_TYPE_NOARG,
                      parse_save_opt_inquire},
    &(struct argv_s) {"keygrip", OPTION_TYPE_ARG, parse_save_opt_keygrip},
    &(struct argv_s) {"sign-keygrip", OPTION_TYPE_ARG,
                      parse_save_opt_sign_keygrip},
    &(struct argv_s) {"s2k-count", OPTION_TYPE_ARG, parse_opt_s2k_count},
    &(struct argv_s) {"reset", OPTION_TYPE_NOARG, parse_opt_reset},
    &(struct argv_s) {"cipher-iterations", OPTION_TYPE_ARG,
                      parse_opt_s2k_count},
    &(struct argv_s) {"no-agent", OPTION_TYPE_NOARG,
                      parse_save_opt_no_agent},
    &(struct argv_s) {"ask", OPTION_TYPE_NOARG,
                      parse_opt_ask},
    NULL
  };

  cleanup_save (&client->crypto->save);
  memcpy (&client->crypto->save.hdr, &client->crypto->hdr,
          sizeof (file_header_t));

  rc = parse_options (&line, args, client, 0);
  if (rc)
    return send_error (ctx, rc);

  if (!(client->flags & FLAG_NEW))
    client->opts &= ~OPT_NO_AGENT;
  else if (client->opts & OPT_NO_AGENT)
    {
      client->crypto->save.hdr.flags &= ~PWMD_FLAG_PKI;
      client->crypto->hdr.flags &= ~PWMD_FLAG_PKI;
    }

  /* Update to the default hash iteration count for data file
   * versions <= 3.0.14. */
#ifdef WITH_AGENT
  if ((!IS_PKI (client->crypto) && client->crypto->hdr.version <= 0x03000e
      && client->crypto->save.hdr.s2k_count < DEFAULT_KDFS2K_ITERATIONS)
      || (!IS_PKI (client->crypto) && !client->crypto->save.hdr.s2k_count))
#else
  if ((client->crypto->hdr.version <= 0x03000e
       && client->crypto->save.hdr.s2k_count < DEFAULT_KDFS2K_ITERATIONS)
      || !client->crypto->save.hdr.s2k_count)
#endif
    {
      client->crypto->save.hdr.s2k_count =
        config_get_ulonglong (client->filename, "s2k_count");
      if (!client->crypto->save.hdr.s2k_count)
        client->crypto->save.hdr.s2k_count = DEFAULT_KDFS2K_ITERATIONS;
    }

  /* Deal with the hashed vs non-hashed cached key mess by clearing the cached
   * key entry. */
  if (client->crypto->hdr.version <= 0x03000e && !IS_PKI (client->crypto))
    client->opts |= OPT_RESET;
  else if (!IS_PKI (client->crypto) && !(client->flags & FLAG_NEW)
           && client->crypto->hdr.s2k_count !=
           client->crypto->save.hdr.s2k_count)
    client->opts |= OPT_RESET;

  if ((client->opts & OPT_NO_PASSPHRASE) && !(client->flags & FLAG_NEW)
      && !(client->opts & OPT_INQUIRE))
    return send_error (ctx, GPG_ERR_WRONG_KEY_USAGE);

  if (lstat (client->filename, &st) == -1 && errno != ENOENT)
    return send_error (ctx, gpg_error_from_errno (errno));

  if (errno != ENOENT && !S_ISREG (st.st_mode))
    {
      log_write ("%s: %s", client->filename, pwmd_strerror (GPG_ERR_ENOANO));
      return send_error (ctx, GPG_ERR_ENOANO);
    }

  int defer = 0;
  rc = cache_iscached (client->filename, &defer);
  if (gpg_err_code (rc) == GPG_ERR_ENOENT && client->flags & FLAG_NEW)
    rc = 0;
  else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
    rc = 0;

  if ((!rc && defer))
    client->opts |= OPT_RESET;
  else if (config_get_boolean ("global", "require_save_key"))
    client->opts |= OPT_ASK;

  if (!rc && (client->opts & OPT_RESET))
    {
      rc = cache_clear (client->md5file);
      if (rc)
        return send_error (ctx, rc);

      log_write ("%s: %s", client->filename,
                 pwmd_strerror (GPG_ERR_KEY_EXPIRED));
      send_status_all (STATUS_CACHE, NULL);
    }

  if (!rc && client->opts & OPT_ASK)
    rc = crypto_try_decrypt (ctx, client->flags & FLAG_NO_PINENTRY,
                             client->filename, NULL, NULL, NULL);

  if (!rc)
    rc = update_element_mtime (client, xmlDocGetRootElement (client->doc));

  if (rc)
    return send_error (ctx, rc);

#ifdef WITH_AGENT
  if (!rc && use_agent && !client->crypto->save.pkey &&
      (client->flags & FLAG_NEW || client->opts & OPT_INQUIRE)
      && !(client->opts & OPT_NO_AGENT))
    {
      rc = set_pinentry_mode (client->crypto->agent,
                              (client->flags & FLAG_NO_PINENTRY) ? "loopback"
                              : "ask");

      if (!(client->flags & FLAG_NEW))
        {
          struct crypto_s *crypto;
          void *key = NULL;
          size_t keylen = 0;

          /* Wanting to generate a new key. Require the key to open the
             current file before proceeding reguardless of the
             require_save_key configuration parameter. */
          rc = cache_clear (client->md5file);
          if (!rc)
            {
              rc = init_client_crypto (&crypto);
              if (!rc)
                crypto->client_ctx = client->ctx;
            }

          if (!rc)
            rc = decrypt_common (client->ctx, client->opts&OPT_INQUIRE, crypto,
                                 client->filename, &key, &keylen, NULL, NULL);

          xfree (key);
          cleanup_crypto (&crypto);
        }

      if (!rc)
        rc = send_status (client->ctx, STATUS_GENKEY, NULL);

      if (!rc)
        {
          struct inquire_data_s idata = { 0 };
          char *params = (client->opts & OPT_INQUIRE)
            ? NULL : default_key_params (client->crypto);

          pthread_cleanup_push (xfree, params);
          idata.crypto = client->crypto;

          if (params)
            {
              idata.line = params;
              idata.len = strlen (params);
            }
          else
            idata.preset = 1;

          client->crypto->agent->inquire_data = &idata;
          client->crypto->agent->inquire_cb = NULL;
          rc = generate_key (client->crypto, params,
                             (client->opts & OPT_NO_PASSPHRASE), 1);
          pthread_cleanup_pop (1);
        }
    }
#endif

  if (!rc)
    rc = save_finalize (ctx);

  cleanup_crypto_stage1 (client->crypto);
#ifdef WITH_AGENT
  (void) kill_scd (client->crypto->agent);
#endif
  return send_error (ctx, rc);
}

static gpg_error_t
do_delete (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char **req;
  xmlNodePtr n;

  if (strchr (line, '\t'))
    req = str_split (line, "\t", 0);
  else
    req = str_split (line, " ", 0);

  if (!req || !*req)
    return GPG_ERR_SYNTAX;

  n = find_root_element (client, client->doc, &req, &rc, NULL, 0, 0);
  if (!n || rc)
    {
      strv_free (req);
      return rc;
    }

  /*
   * No sub-node defined. Remove the entire node (root element).
   */
  if (!req[1])
    {
      if (n)
        {
          rc = is_element_owner (client, n);
          if (!rc)
            {
              rc = unlink_node (client, n);
              xmlFreeNode (n);
            }
        }

      strv_free (req);
      return rc;
    }

  n = find_elements (client, client->doc, n->children, req + 1, &rc, NULL,
                     NULL, NULL, 0, 0, NULL, 0);
  strv_free (req);
  if (!n || rc)
    return rc;

  rc = is_element_owner (client, n);
  if (!rc)
    {
      rc = unlink_node (client, n);
      xmlFreeNode (n);
    }

  return rc;
}

static gpg_error_t
delete_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_delete (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_delete (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
store_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  size_t len;
  unsigned char *result;
  char **req;
  xmlNodePtr n, parent;
  int has_content;
  char *content = NULL;

  if (line && *line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
  if (rc)
    return send_error (ctx, rc);

  req = str_split ((char *) result, "\t", 0);
  xfree (result);

  if (!req || !*req)
    return send_error (ctx, GPG_ERR_SYNTAX);

  len = strv_length (req);
  has_content = line[strlen (line) - 1] != '\t' && len > 1;
  if (*(req + 1) && !valid_element_path (req, has_content))
    {
      strv_free (req);
      return send_error (ctx, GPG_ERR_INV_VALUE);
    }

  if (has_content || !*req[len - 1])
    {
      has_content = 1;
      content = req[len - 1];
      req[len - 1] = NULL;
    }

again:
  n = find_root_element (client, client->doc, &req, &rc, NULL, 0, 0);
  if (rc && rc == GPG_ERR_ELEMENT_NOT_FOUND)
    {
      rc = new_root_element (client, client->doc, *req);
      if (rc)
        {
          strv_free (req);
          return send_error (ctx, rc);
        }

      goto again;
    }

  if (!n || rc)
    {
      strv_free (req);
      return send_error (ctx, rc);
    }

  parent = n;

  if (req[1] && *req[1])
    {
      if (!n->children)
        parent = create_elements_cb (client, 1, n, req + 1, &rc, NULL);
      else
        parent = find_elements (client, client->doc, n->children, req + 1, &rc,
                                NULL, NULL, create_elements_cb, 0, 0, NULL,
                                0);
    }

  if (!rc && len > 1)
    {
      rc = is_element_owner (client, parent);
      if (!rc)
        {
          n = find_text_node (parent->children);
          if (n)
            xmlNodeSetContent (n, (xmlChar *) content);
          else
            xmlNodeAddContent (parent, (xmlChar *) content);

          update_element_mtime (client, parent);
        }
    }

  xfree (content);
  strv_free (req);
  return send_error (ctx, rc);
}

static gpg_error_t
xfer_data (assuan_context_t ctx, const char *line, int total)
{
  struct client_s *client = assuan_get_pointer (ctx);
  int to_send;
  int sent = 0;
  gpg_error_t rc = 0;
  int progress = config_get_integer ("global", "xfer_progress");
  int flush = 0;

  if (!(client->flags & FLAG_LOCK_CMD))
    rc = unlock_file_mutex (client, 0);
  if (rc && rc != GPG_ERR_NOT_LOCKED)
    return rc;

  progress =
    progress > 0 ? (progress / ASSUAN_LINELENGTH) * ASSUAN_LINELENGTH : 0;
  to_send = total < ASSUAN_LINELENGTH ? total : ASSUAN_LINELENGTH;
  rc = send_status (ctx, STATUS_XFER, "%li %li", sent, total);

  if (rc)
    return rc;

again:
  do
    {
      if (sent + to_send > total)
        to_send = total - sent;

      rc = assuan_send_data (ctx, flush ? NULL : (char *) line + sent,
                             flush ? 0 : to_send);
      if (!rc)
        {
          sent += flush ? 0 : to_send;

          if ((progress && !(sent % progress) && sent != total) ||
              (sent == total && flush))
            rc = send_status (ctx, STATUS_XFER, "%li %li", sent, total);

          if (!flush && !rc && sent == total)
            {
              flush = 1;
              goto again;
            }
        }
    }
  while (!rc && sent < total);

  return rc;
}

static gpg_error_t
do_get (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char **req;
  xmlNodePtr n;

  req = str_split (line, "\t", 0);

  if (!req || !*req)
    {
      strv_free (req);
      return GPG_ERR_SYNTAX;
    }

  n = find_root_element (client, client->doc, &req, &rc, NULL, 0, 0);
  if (!n || rc)
    {
      strv_free (req);
      return rc;
    }

  if (req[1])
    n = find_elements (client, client->doc, n->children, req + 1, &rc,
                       NULL, NULL, NULL, 0, 0, NULL, 0);

  strv_free (req);
  if (rc)
    return rc;

  if (!n || !n->children)
    return GPG_ERR_NO_DATA;

  n = find_text_node (n->children);
  if (!n || !n->content || !*n->content)
    return GPG_ERR_NO_DATA;

  rc = xfer_data (ctx, (char *) n->content, xmlStrlen (n->content));
  return rc;
}

static gpg_error_t
get_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_get (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_get (ctx, line);

  return send_error (ctx, rc);
}

static void list_command_cleanup1 (void *arg);
static gpg_error_t
realpath_command (assuan_context_t ctx, char *line)
{
  struct string_s *string = NULL;
  gpg_error_t rc;
  struct client_s *client = assuan_get_pointer (ctx);
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = build_realpath (client, client->doc, (char *)result, &string);
      pthread_cleanup_pop (1);
    }
  else
    rc = build_realpath (client, client->doc, line, &string);

  if (!rc)
    {
      pthread_cleanup_push (list_command_cleanup1, string);
      rc = xfer_data (ctx, string->str, string->len);
      pthread_cleanup_pop (1);
    }

  return send_error (ctx, rc);
}

static void
list_command_cleanup1 (void *arg)
{
  if (arg)
    string_free ((struct string_s *) arg, 1);
}

static void
list_command_cleanup2 (void *arg)
{
  struct element_list_s *elements = arg;

  if (elements)
    {
      if (elements->list)
        {
          int total = slist_length (elements->list);
          int i;

          for (i = 0; i < total; i++)
            {
              char *tmp = slist_nth_data (elements->list, i);
              xfree (tmp);
            }

          slist_free (elements->list);
        }

      if (elements->prefix)
        xfree (elements->prefix);

      if (elements->req)
        strv_free (elements->req);

      xfree (elements);
    }
}

static gpg_error_t
parse_list_opt_norecurse (void *data, void *value)
{
  struct client_s *client = data;

  client->opts &= ~(OPT_LIST_RECURSE);
  return 0;
}

static gpg_error_t
parse_opt_verbose (void *data, void *value)
{
  struct client_s *client = data;

  client->opts |= OPT_VERBOSE;
  return 0;
}

static gpg_error_t
parse_list_opt_target (void *data, void *value)
{
  struct client_s *client = data;

  client->opts |= OPT_LIST_WITH_TARGET;
  return 0;
}

static gpg_error_t
parse_list_opt_all (void *data, void *value)
{
  struct client_s *client = data;

  client->opts |= OPT_LIST_ALL;
  return 0;
}

static gpg_error_t
list_path_once (struct client_s *client, char *line,
                struct element_list_s *elements, struct string_s *result)
{
  gpg_error_t rc;

  elements->req = str_split (line, " ", 0);
  if (!elements->req)
    strv_printf (&elements->req, "%s", line);

  rc = create_path_list (client, client->doc, elements, *elements->req);
  if ((rc == GPG_ERR_ELOOP || rc == GPG_ERR_EACCES) && elements->verbose)
    rc = 0;

  if (!rc)
    {
      int total = slist_length (elements->list);

      if (total)
        {
          int i;

          for (i = 0; i < total; i++)
            {
              char *tmp = slist_nth_data (elements->list, i);

              string_append_printf (result, "%s%s", tmp,
                                    i + 1 == total ? "" : "\n");
            }
        }
      else
        rc = GPG_ERR_NO_DATA;
    }

  return rc;
}

static int
has_list_flag (char *path, char *flags)
{
  char *p = path;

  while (*p && *++p != ' ');

  if (!*p)
    return 0;

  for (; *p; p++)
    {
      char *f;

      for (f = flags; *f && *f != ' '; f++)
        {
          if (*p == *f)
            return 1;
        }
    }

  return 0;
}

static gpg_error_t
do_list (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct element_list_s *elements = NULL;

  elements = xcalloc (1, sizeof (struct element_list_s));
  if (!elements)
    return GPG_ERR_ENOMEM;

  elements->recurse = client->opts & OPT_LIST_RECURSE;
  elements->verbose =
    (client->opts & OPT_VERBOSE) | (client->opts & OPT_LIST_WITH_TARGET);
  elements->with_target = client->opts & OPT_LIST_WITH_TARGET;

  if (!line || !*line)
    {
      struct string_s *str = NULL;

      pthread_cleanup_push (list_command_cleanup2, elements);
      rc = list_root_elements (client, client->doc, &str, elements->verbose,
                               elements->with_target);
      pthread_cleanup_pop (1);
      pthread_cleanup_push (list_command_cleanup1, str);

      if (!rc)
        {
          if (client->opts & OPT_LIST_ALL)
            {
              char **roots = str_split (str->str, "\n", 0);
              char **p;

              pthread_cleanup_push (req_cleanup, roots);
              string_truncate (str, 0);

              for (p = roots; *p; p++)
                {
                  if (strchr (*p, ' '))
                    {
                      if (has_list_flag (*p, "EOP"))
                        {
                          string_append_printf (str, "%s%s", *p,
                                                *(p + 1) ? "\n" : "");
                          continue;
                        }
                    }

                  elements = xcalloc (1, sizeof (struct element_list_s));
                  if (!elements)
                    {
                      rc = GPG_ERR_ENOMEM;
                      break;
                    }

                  elements->recurse = client->opts & OPT_LIST_RECURSE;
                  elements->verbose =
                    (client->opts & OPT_VERBOSE) | (client->opts &
                                                         OPT_LIST_WITH_TARGET);
                  elements->with_target = client->opts & OPT_LIST_WITH_TARGET;
                  pthread_cleanup_push (list_command_cleanup2, elements);
                  rc = list_path_once (client, *p, elements, str);
                  pthread_cleanup_pop (1);
                  if (rc)
                    break;

                  if (*(p + 1))
                    string_append (str, "\n");
                }

              pthread_cleanup_pop (1);
            }

          if (!rc)
            rc = xfer_data (ctx, str->str, str->len);
        }

      pthread_cleanup_pop (1);
      return rc;
    }

  pthread_cleanup_push (list_command_cleanup2, elements);
  struct string_s *str = string_new (NULL);
  pthread_cleanup_push (list_command_cleanup1, str);
  rc = list_path_once (client, line, elements, str);
  if (!rc)
    rc = xfer_data (ctx, str->str, str->len);

  pthread_cleanup_pop (1);
  pthread_cleanup_pop (1);
  return rc;
}

static gpg_error_t
list_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"no-recurse", OPTION_TYPE_NOARG,
                      parse_list_opt_norecurse},
    &(struct argv_s) {"verbose", OPTION_TYPE_NOARG, parse_opt_verbose},
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    &(struct argv_s) {"with-target", OPTION_TYPE_NOARG,
                      parse_list_opt_target},
    &(struct argv_s) {"all", OPTION_TYPE_NOARG, parse_list_opt_all},
    NULL
  };

  if (disable_list_and_dump == 1)
    return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);

  client->opts |= OPT_LIST_RECURSE;
  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_LIST_ALL)
    client->opts |= OPT_LIST_RECURSE | OPT_VERBOSE;

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_list (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_list (ctx, line);

  return send_error (ctx, rc);
}

/*
 * req[0] - element path
 */
static gpg_error_t
attribute_list (assuan_context_t ctx, char **req)
{
  struct client_s *client = assuan_get_pointer (ctx);
  char **attrlist = NULL;
  int i = 0;
  char **path = NULL;
  xmlAttrPtr a;
  xmlNodePtr n, an;
  char *line;
  gpg_error_t rc;

  if (!req || !req[0])
    return GPG_ERR_SYNTAX;

  client->flags |= FLAG_ACL_IGNORE;

  if ((path = str_split (req[0], "\t", 0)) == NULL)
    {
      /*
       * The first argument may be only a root element.
       */
      if ((path = str_split (req[0], " ", 0)) == NULL)
        return GPG_ERR_SYNTAX;
    }

  n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
  if (!n || rc)
    {
      strv_free (path);
      return rc;
    }

  if (client->flags & FLAG_ACL_ERROR)
    {
      client->flags &= ~FLAG_ACL_IGNORE;
      if (path[1])
        {
          strv_free (path);
          return GPG_ERR_EACCES;
        }

      client->flags &= ~FLAG_ACL_ERROR;
    }

  if (path[1])
    {
      n = find_elements (client, client->doc, n->children, path + 1, &rc,
                         NULL, NULL, NULL, 0, 0, NULL, 0);
      if (!n || rc)
        {
          strv_free (path);
          return rc;
        }
    }

  strv_free (path);

  for (a = n->properties; a; a = a->next)
    {
      char **pa;

      if ((pa = xrealloc (attrlist, (i + 2) * sizeof (char *))) == NULL)
        {
          if (attrlist)
            strv_free (attrlist);

          log_write ("%s(%i): %s", __FILE__, __LINE__,
                     pwmd_strerror (GPG_ERR_ENOMEM));
          return GPG_ERR_ENOMEM;
        }

      attrlist = pa;
      an = a->children;
      attrlist[i] = str_asprintf ("%s %s", (char *) a->name,
                                  an
                                  && an->content ? (char *) an->content : "");

      if (!attrlist[i])
        {
          strv_free (attrlist);
          log_write ("%s(%i): %s", __FILE__, __LINE__,
                     pwmd_strerror (GPG_ERR_ENOMEM));
          return GPG_ERR_ENOMEM;
        }

      attrlist[++i] = NULL;
    }

  if (!attrlist)
    return GPG_ERR_NO_DATA;

  line = strv_join ("\n", attrlist);

  if (!line)
    {
      log_write ("%s(%i): %s", __FILE__, __LINE__,
                 pwmd_strerror (GPG_ERR_ENOMEM));
      strv_free (attrlist);
      return GPG_ERR_ENOMEM;
    }

  pthread_cleanup_push (xfree, line);
  pthread_cleanup_push (req_cleanup, attrlist);
  rc = xfer_data (ctx, line, strlen (line));
  pthread_cleanup_pop (1);
  pthread_cleanup_pop (1);
  return rc;
}

/*
 * req[0] - attribute
 * req[1] - element path
 */
static gpg_error_t
attribute_delete (struct client_s *client, char **req)
{
  xmlNodePtr n;
  char **path = NULL;
  gpg_error_t rc;

  if (!req || !req[0] || !req[1])
    return GPG_ERR_SYNTAX;

  if (!strcmp (req[0], "_name"))
    return GPG_ERR_INV_ATTR;

  if ((path = str_split (req[1], "\t", 0)) == NULL)
    {
      /*
       * The first argument may be only a root element.
       */
      if ((path = str_split (req[1], " ", 0)) == NULL)
        return GPG_ERR_SYNTAX;
    }

  n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
  if (!n || rc)
    goto fail;

  if (path[1])
    {
      n = find_elements (client, client->doc, n->children, path + 1, &rc,
                         NULL, NULL, NULL, 0, 0, NULL, 0);
      if (!n || rc)
        goto fail;
    }

  if (!strcmp (req[0], (char *) "_acl"))
    {
      rc = is_element_owner (client, n);
      if (rc)
        goto fail;
    }

  rc = delete_attribute (client, n, (xmlChar *) req[0]);

fail:
  strv_free (path);
  return rc;
}

static xmlNodePtr
create_element_path (struct client_s *client,
                     char ***elements, gpg_error_t * rc, xmlNodePtr parent)
{
  char **req = *elements;
  char **req_orig = strv_dup (req);
  xmlNodePtr n = NULL;

  *rc = 0;

  if (!req_orig)
    {
      *rc = GPG_ERR_ENOMEM;
      log_write ("%s(%i): %s", __FILE__, __LINE__,
                 pwmd_strerror (GPG_ERR_ENOMEM));
      goto fail;
    }

again:
  n = find_root_element (client, client->doc, &req, rc, NULL, 0, 0);
  if (!n)
    {
      if (*rc != GPG_ERR_ELEMENT_NOT_FOUND)
        goto fail;

      *rc = new_root_element (client, client->doc, req[0]);
      if (*rc)
        goto fail;

      goto again;
    }
  else if (n == parent)
    {
      *rc = GPG_ERR_CONFLICT;
      goto fail;
    }

  if (req[1])
    {
      if (!n->children)
        n = create_target_elements_cb (client, 1, n, req + 1, rc, NULL);
      else
        n = find_elements (client, client->doc, n->children, req + 1, rc,
                           NULL, NULL, create_target_elements_cb, 0, 0,
                           parent, 0);

      if (!n)
        goto fail;

      /*
       * Reset the position of the element tree now that the elements
       * have been created.
       */
      strv_free (req);
      req = req_orig;
      req_orig = NULL;
      n = find_root_element (client, client->doc, &req, rc, NULL, 0, 0);
      if (!n)
        goto fail;

      n = find_elements (client, client->doc, n->children, req + 1, rc,
                         NULL, NULL, NULL, 0, 0, NULL, 0);
      if (!n)
        goto fail;
    }

fail:
  if (req_orig)
    strv_free (req_orig);

  *elements = req;
  return n;
}

/*
 * Creates a "target" attribute. When other commands encounter an element with
 * this attribute, the element path is modified to the target value. If the
 * source element path doesn't exist when using 'ATTR SET target', it is
 * created, but the destination element path must exist.
 *
 * req[0] - source element path
 * req[1] - destination element path
 */
static gpg_error_t
target_attribute (struct client_s *client, char **req)
{
  char **src, **dst, *line = NULL, **odst = NULL;
  gpg_error_t rc;
  xmlNodePtr n;

  if (!req || !req[0] || !req[1])
    return GPG_ERR_SYNTAX;

  if ((src = str_split (req[0], "\t", 0)) == NULL)
    {
      /*
       * The first argument may be only a root element.
       */
      if ((src = str_split (req[0], " ", 0)) == NULL)
        return GPG_ERR_SYNTAX;
    }

  if (!valid_element_path (src, 0))
    return GPG_ERR_INV_VALUE;

  if ((dst = str_split (req[1], "\t", 0)) == NULL)
    {
      /*
       * The first argument may be only a root element.
       */
      if ((dst = str_split (req[1], " ", 0)) == NULL)
        {
          rc = GPG_ERR_SYNTAX;
          goto fail;
        }
    }

  odst = strv_dup (dst);
  if (!odst)
    {
      rc = GPG_ERR_ENOMEM;
      goto fail;
    }

  n = find_root_element (client, client->doc, &dst, &rc, NULL, 0, 0);
  /*
   * Make sure the destination element path exists.
   */
  if (rc && rc != GPG_ERR_EACCES)
    goto fail;

  rc = 0;
  if (dst[1])
    {
      n = find_elements (client, client->doc, n->children, dst + 1, &rc,
                         NULL, NULL, NULL, 0, 0, NULL, 0);
      if (rc && rc != GPG_ERR_EACCES)
        goto fail;
    }

  rc = validate_target_attribute (client, client->doc, req[0], n);
  if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
    goto fail;

  n = create_element_path (client, &src, &rc, NULL);
  if (rc)
    goto fail;

  line = strv_join ("\t", odst);
  if (!line)
    {
      rc = GPG_ERR_ENOMEM;
      goto fail;
    }

  rc = add_attribute (client, n, "target", line);

fail:
  xfree (line);
  strv_free (src);
  strv_free (dst);
  strv_free (odst);
  return rc;
}

/*
 * req[0] - attribute
 * req[1] - element path
 */
static gpg_error_t
attribute_get (assuan_context_t ctx, char **req)
{
  struct client_s *client = assuan_get_pointer (ctx);
  xmlNodePtr n;
  xmlChar *a;
  char **path = NULL;
  gpg_error_t rc;

  if (!req || !req[0] || !req[1])
    return GPG_ERR_SYNTAX;

  if (strchr (req[1], '\t'))
    {
      if ((path = str_split (req[1], "\t", 0)) == NULL)
        return GPG_ERR_SYNTAX;
    }
  else
    {
      if ((path = str_split (req[1], " ", 0)) == NULL)
        return GPG_ERR_SYNTAX;
    }

  n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
  if (!n || rc)
    goto fail;

  if (path[1])
    {
      n = find_elements (client, client->doc, n->children, path + 1, &rc,
                         NULL, NULL, NULL, 0, 0, NULL, 0);
      if (!n || rc)
        goto fail;
    }

  strv_free (path);

  if ((a = xmlGetProp (n, (xmlChar *) req[0])) == NULL)
    return GPG_ERR_NOT_FOUND;

  pthread_cleanup_push (xmlFree, a);

  if (*a)
    rc = xfer_data (ctx, (char *) a, xmlStrlen (a));
  else
    rc = GPG_ERR_NO_DATA;

  pthread_cleanup_pop (1);
  return rc;

fail:
  strv_free (path);
  return rc;
}

/*
 * req[0] - attribute
 * req[1] - element path
 * req[2] - value
 */
static gpg_error_t
attribute_set (struct client_s *client, char **req)
{
  char **path = NULL;
  gpg_error_t rc;
  xmlNodePtr n;

  if (!req || !req[0] || !req[1])
    return GPG_ERR_SYNTAX;

  /*
   * Reserved attribute names.
   */
  if (!strcmp (req[0], "_name"))
    return GPG_ERR_INV_ATTR;
  else if (!strcmp (req[0], "target"))
    return target_attribute (client, req + 1);
  else if (!valid_xml_attribute (req[0]))
    return GPG_ERR_INV_VALUE;

  if (!valid_xml_attribute_value (req[2]))
    return GPG_ERR_INV_VALUE;

  if ((path = str_split (req[1], "\t", 0)) == NULL)
    {
      /*
       * The first argument may be only a root element.
       */
      if ((path = str_split (req[1], " ", 0)) == NULL)
        return GPG_ERR_SYNTAX;
    }

  n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
  if (!n || rc)
    goto fail;

  if (path[1])
    {
      n = find_elements (client, client->doc, n->children, path + 1, &rc,
                         NULL, NULL, NULL, 0, 0, NULL, 0);
      if (!n || rc)
        goto fail;
    }

  if (!strcmp (req[0], (char *) "_acl"))
    {
      rc = is_element_owner (client, n);
      if (rc)
        goto fail;
    }

  rc = add_attribute (client, n, req[0], req[2]);

fail:
  strv_free (path);
  return rc;
}

/*
 * req[0] - command
 * req[1] - attribute name or element path if command is LIST
 * req[2] - element path
 * req[2] - element path or value
 */

static gpg_error_t
do_attr (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc = 0;
  char **req;

  req = str_split (line, " ", 4);
  if (!req || !req[0] || !req[1])
    {
      strv_free (req);
      return GPG_ERR_SYNTAX;
    }

  pthread_cleanup_push (req_cleanup, req);

  if (strcasecmp (req[0], "SET") == 0)
    rc = attribute_set (client, req + 1);
  else if (strcasecmp (req[0], "GET") == 0)
    rc = attribute_get (ctx, req + 1);
  else if (strcasecmp (req[0], "DELETE") == 0)
    rc = attribute_delete (client, req + 1);
  else if (strcasecmp (req[0], "LIST") == 0)
    rc = attribute_list (ctx, req + 1);
  else
    rc = GPG_ERR_SYNTAX;

  client->flags &= ~(FLAG_ACL_IGNORE|FLAG_ACL_ERROR);
  pthread_cleanup_pop (1);
  return rc;
}

static gpg_error_t
attr_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_attr (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_attr (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
parse_iscached_opt_lock (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_LOCK;
  return 0;
}

static gpg_error_t
iscached_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"lock", OPTION_TYPE_NOARG, parse_iscached_opt_lock},
    NULL
  };

  if (!line || !*line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = parse_options (&line, args, client, 1);
  if (rc)
    return send_error (ctx, rc);
  else if (!valid_filename (line))
    return send_error (ctx, GPG_ERR_INV_VALUE);

  rc = cache_iscached (line, NULL);
  if (client->opts & OPT_LOCK
      && (!rc || gpg_err_code (rc) == GPG_ERR_NO_DATA))
    {
      unsigned char md5file[16];
      gpg_error_t trc = rc;

      gcry_md_hash_buffer (GCRY_MD_MD5, md5file, line, strlen (line));
      if (memcmp (md5file, client->md5file, 16))
        cleanup_client (client);

      memcpy (client->md5file, md5file, 16);
      rc = do_lock (client, 1);
      if (!rc)
        rc = trc;
    }

  return send_error (ctx, rc);
}

static gpg_error_t
clearcache_command (assuan_context_t ctx, char *line)
{
  gpg_error_t rc = 0, all_rc = 0;
  unsigned char md5file[16];
  int i;
  int t;
  int all = 0;
  struct client_thread_s *once = NULL;

  cache_lock ();
  MUTEX_LOCK (&cn_mutex);
  pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);

  if (!line || !*line)
    all = 1;

  t = slist_length (cn_thread_list);

  for (i = 0; i < t; i++)
    {
      struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
      assuan_peercred_t peer;

      if (!thd->cl)
        continue;

      /* Lock each connected clients' file mutex to prevent any other client
       * from accessing the cache entry (the file mutex is locked upon
       * command startup). The cache for the entry is not cleared if the
       * file mutex is locked by another client to prevent this function
       * from blocking.
       */
      if (all)
        {
          if (thd->cl->filename)
            {
              rc = do_validate_peer (ctx, thd->cl->filename, &peer);
              all_rc = !all_rc ? rc : all_rc;
              if (rc)
                {
                  rc = 0;
                  continue;
                }
            }

          rc = cache_lock_mutex (thd->cl->ctx, thd->cl->md5file, -1, 0, -1);
          if (gpg_err_code (rc) == GPG_ERR_LOCKED)
            {
              if (pthread_equal (pthread_self (), thd->tid))
                rc = 0;
              else
                {
                  if (!thd->cl->filename ||
                      cache_iscached (thd->cl->filename,
                                      NULL) == GPG_ERR_NO_DATA)
                    {
                      rc = 0;
                      continue;
                    }

                  cache_defer_clear (thd->cl->md5file);
                }
            }
          else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
            {
              rc = 0;
              continue;
            }

          if (!rc)
            {
              rc = cache_clear (thd->cl->md5file);
              cache_unlock_mutex (thd->cl->md5file, 0);
            }

          if (rc)
            all_rc = rc;

          rc = 0;
        }
      /* A single data filename was specified. Lock only this data file
       * mutex and free the cache entry. */
      else
        {
          gcry_md_hash_buffer (GCRY_MD_MD5, md5file, line, strlen (line));
          rc = do_validate_peer (ctx, line, &peer);

          if (!rc && !memcmp (thd->cl->md5file, md5file, sizeof (md5file)))
            {
              rc = cache_lock_mutex (thd->cl->ctx, thd->cl->md5file, -1, 0,
                                     -1);
              if (gpg_err_code (rc) == GPG_ERR_LOCKED)
                {
                  if (pthread_equal (pthread_self (), thd->tid))
                    rc = 0;
                }

              if (!rc)
                {
                  once = thd;
                  rc = cache_clear (thd->cl->md5file);
                  cache_unlock_mutex (thd->cl->md5file, 0);
                }
              else
                {
                  cache_defer_clear (thd->cl->md5file);
                }

              break;
            }
        }
    }

  /* Only connected clients' cache entries have been cleared. Now clear any
   * remaining cache entries without clients but only if there wasn't an
   * error from above since this would defeat the locking check of the
   * remaining entries. */
  if (!all_rc && all)
    {
      cache_clear (NULL);
    }

  /* No clients are using the specified file. */
  else if (!all_rc && !rc && !once)
    {
      gcry_md_hash_buffer (GCRY_MD_MD5, md5file, line, strlen (line));
      rc = cache_clear (md5file);
    }

  /* Release the connection mutex. */
  pthread_cleanup_pop (1);
  cache_unlock ();

  if (!rc)
    send_status_all (STATUS_CACHE, NULL);

  /* One or more files were locked while clearing all cache entries. */
  if (all_rc)
    rc = all_rc;

  return send_error (ctx, rc);
}

static gpg_error_t
cachetimeout_command (assuan_context_t ctx, char *line)
{
  int timeout;
  char **req = str_split (line, " ", 0);
  char *p;
  gpg_error_t rc = 0;
  assuan_peercred_t peer;

  if (!req || !*req || !req[1])
    {
      strv_free (req);
      return send_error (ctx, GPG_ERR_SYNTAX);
    }

  errno = 0;
  timeout = (int) strtol (req[1], &p, 10);
  if (errno != 0 || *p || timeout < -1)
    {
      strv_free (req);
      return send_error (ctx, GPG_ERR_SYNTAX);
    }

  rc = do_validate_peer (ctx, req[0], &peer);
  if (!rc)
    {
      unsigned char md5file[16];

      gcry_md_hash_buffer (GCRY_MD_MD5, md5file, req[0], strlen (req[0]));
      rc = cache_set_timeout (md5file, timeout);
      if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
        {
          rc = 0;
          MUTEX_LOCK (&rcfile_mutex);
          config_set_int_param (&global_config, req[0], "cache_timeout",
                                req[1]);
          MUTEX_UNLOCK (&rcfile_mutex);
        }
    }

  strv_free (req);
  return send_error (ctx, rc);
}

static gpg_error_t
dump_command (assuan_context_t ctx, char *line)
{
  xmlChar *xml;
  int len;
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;

  if (disable_list_and_dump == 1)
    return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);

  if (line && *line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = peer_is_invoker(client);
  if (rc)
    return send_error (ctx, rc);

  xmlDocDumpFormatMemory (client->doc, &xml, &len, 1);

  if (!xml)
    {
      log_write ("%s(%i): %s", __FILE__, __LINE__,
                 pwmd_strerror (GPG_ERR_ENOMEM));
      return send_error (ctx, GPG_ERR_ENOMEM);
    }

  pthread_cleanup_push (xmlFree, xml);
  rc = xfer_data (ctx, (char *) xml, len);
  pthread_cleanup_pop (1);
  return send_error (ctx, rc);
}

static gpg_error_t
getconfig_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc = 0;
  char filename[255] = { 0 }, param[747] = { 0 };
  char *p, *tmp = NULL, *fp = client->filename, *paramp = line;

  if (!line || !*line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  if (strchr (line, ' '))
    {
      sscanf (line, " %254[^ ] %746c", filename, param);
      paramp = param;
      fp = filename;
    }

  if (fp && !valid_filename (fp))
    return send_error (ctx, GPG_ERR_INV_VALUE);

  paramp = str_down (paramp);
  if (!strcmp (paramp, "cipher") && fp)
    {
      struct crypto_s *crypto = NULL;

      rc = init_client_crypto (&crypto);
      if (!rc)
        {
          rc = read_data_header (fp, &crypto->hdr, NULL, NULL);
          if (!rc)
            {
              const char *t =
                gcry_cipher_algo_name (cipher_to_gcrypt (crypto->hdr.flags));
              if (t)
                {
                  tmp = str_dup (t);
                  if (tmp)
                    str_down (tmp);
                }
            }
        }

      UPDATE_AGENT_CTX (client, crypto);
      cleanup_crypto (&crypto);
      if (rc && gpg_err_code (rc) != GPG_ERR_ENOENT)
        return send_error (ctx, rc);

      if (!rc && tmp)
        goto done;
    }
  else if (!strcmp (paramp, "cipher_iterations") && fp)
    {
      struct crypto_s *crypto = NULL;

      rc = init_client_crypto (&crypto);
      if (!rc)
        {
          rc = read_data_header (fp, &crypto->hdr, NULL, NULL);
          if (!rc)
            {
              tmp = str_asprintf ("%llu",
                                  (unsigned long long) crypto->hdr.s2k_count);
              if (!tmp)
                rc = GPG_ERR_ENOMEM;
            }
        }

      UPDATE_AGENT_CTX (client, crypto);
      cleanup_crypto (&crypto);
      if (rc && gpg_err_code (rc) != GPG_ERR_ENOENT)
        return send_error (ctx, rc);

      if (!rc && tmp)
        goto done;
    }
  else if (!strcmp (paramp, "passphrase"))
    return send_error (ctx, GPG_ERR_UNKNOWN_OPTION);

  p = config_get_value (fp ? fp : "global", paramp);
  if (!p)
    return send_error (ctx, GPG_ERR_UNKNOWN_OPTION);

  tmp = expand_homedir (p);
  xfree (p);
  if (!tmp)
    {
      log_write ("%s(%i): %s", __FILE__, __LINE__,
                 pwmd_strerror (GPG_ERR_ENOMEM));
      return send_error (ctx, GPG_ERR_ENOMEM);
    }

done:
  p = tmp;
  pthread_cleanup_push (xfree, p);
  rc = xfer_data (ctx, p, strlen (p));
  pthread_cleanup_pop (1);
  return send_error (ctx, rc);
}

struct xpath_s
{
  xmlXPathContextPtr xp;
  xmlXPathObjectPtr result;
  xmlBufferPtr buf;
  char **req;
};

static void
xpath_command_cleanup (void *arg)
{
  struct xpath_s *xpath = arg;

  if (!xpath)
    return;

  req_cleanup (xpath->req);

  if (xpath->buf)
    xmlBufferFree (xpath->buf);

  if (xpath->result)
    xmlXPathFreeObject (xpath->result);

  if (xpath->xp)
    xmlXPathFreeContext (xpath->xp);
}

static gpg_error_t
do_xpath (assuan_context_t ctx, char *line)
{
  gpg_error_t rc;
  struct client_s *client = assuan_get_pointer (ctx);
  struct xpath_s _x = { 0 };
  struct xpath_s *xpath = &_x;

  if (!line || !*line)
    return GPG_ERR_SYNTAX;

  if ((xpath->req = str_split (line, "\t", 2)) == NULL)
    {
      if (strv_printf (&xpath->req, "%s", line) == 0)
        return GPG_ERR_ENOMEM;
    }

  xpath->xp = xmlXPathNewContext (client->doc);
  if (!xpath->xp)
    {
      rc = GPG_ERR_BAD_DATA;
      goto fail;
    }

  xpath->result =
    xmlXPathEvalExpression ((xmlChar *) xpath->req[0], xpath->xp);
  if (!xpath->result)
    {
      rc = GPG_ERR_BAD_DATA;
      goto fail;
    }

  if (xmlXPathNodeSetIsEmpty (xpath->result->nodesetval))
    {
      rc = GPG_ERR_ELEMENT_NOT_FOUND;
      goto fail;
    }

  rc = recurse_xpath_nodeset (client, client->doc, xpath->result->nodesetval,
                              (xmlChar *) xpath->req[1], &xpath->buf, 0,
                              NULL);
  if (rc)
    goto fail;
  else if (!xpath->req[1] && !xmlBufferLength (xpath->buf))
    {
      rc = GPG_ERR_NO_DATA;
      goto fail;
    }
  else if (xpath->req[1])
    {
      rc = 0;
      goto fail;
    }

  pthread_cleanup_push (xpath_command_cleanup, &xpath);
  rc = xfer_data (ctx, (char *) xmlBufferContent (xpath->buf),
                  xmlBufferLength (xpath->buf));
  pthread_cleanup_pop (0);
fail:
  xpath_command_cleanup (xpath);
  return rc;
}

static gpg_error_t
xpath_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  if (disable_list_and_dump == 1)
    return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);

  rc = peer_is_invoker(client);
  if (rc)
    return send_error (ctx, rc);

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_xpath (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_xpath (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
do_xpathattr (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char **req = NULL;
  int cmd = 0;                  //SET
  struct xpath_s _x = { 0 };
  struct xpath_s *xpath = &_x;

  if (!line || !*line)
    return GPG_ERR_SYNTAX;

  if ((req = str_split (line, " ", 3)) == NULL)
    return GPG_ERR_ENOMEM;

  if (!req[0])
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  if (!strcasecmp (req[0], "SET"))
    cmd = 0;
  else if (!strcasecmp (req[0], "DELETE"))
    cmd = 1;
  else
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  if (!req[1] || !req[2])
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  if ((xpath->req = str_split (req[2], "\t", 3)) == NULL)
    {
      rc = GPG_ERR_ENOMEM;
      goto fail;
    }

  if (!xpath->req[0] || (!xpath->req[1] && !cmd) || (xpath->req[1] && cmd))
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  xpath->xp = xmlXPathNewContext (client->doc);
  if (!xpath->xp)
    {
      rc = GPG_ERR_BAD_DATA;
      goto fail;
    }

  xpath->result = xmlXPathEvalExpression ((xmlChar *) xpath->req[0], xpath->xp);
  if (!xpath->result)
    {
      rc = GPG_ERR_BAD_DATA;
      goto fail;
    }

  if (xmlXPathNodeSetIsEmpty (xpath->result->nodesetval))
    {
      rc = GPG_ERR_ELEMENT_NOT_FOUND;
      goto fail;
    }

  rc = recurse_xpath_nodeset (client, client->doc, xpath->result->nodesetval,
                              (xmlChar *) xpath->req[1], &xpath->buf, cmd,
                              (xmlChar *) req[1]);

fail:
  xpath_command_cleanup (xpath);
  strv_free (req);
  return rc;
}

/* XPATHATTR SET|DELETE <name> <expression>[<TAB>[value]] */
static gpg_error_t
xpathattr_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  if (disable_list_and_dump == 1)
    return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);

  rc = peer_is_invoker(client);
  if (rc)
    return send_error (ctx, rc);

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_xpathattr (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_xpathattr (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
do_import (struct client_s *client, const char *root_element,
           unsigned char *content)
{
  char **dst_path = NULL;
  xmlDocPtr doc = NULL;
  xmlNodePtr n, root, copy;
  gpg_error_t rc;

  if (!content || !*content)
    {
      xfree (content);
      return GPG_ERR_SYNTAX;
    }

  if (root_element)
    dst_path = str_split (root_element, "\t", 0);

  if (dst_path && !valid_element_path (dst_path, 0))
    {
      if (dst_path)
        strv_free (dst_path);

      return GPG_ERR_INV_VALUE;
    }

  struct string_s *str = string_new_content ((char *)content);
  str = string_prepend (str, "<pwmd>");
  str = string_append (str, "</pwmd>");
  doc = xmlReadDoc ((xmlChar *) str->str, NULL, "UTF-8", XML_PARSE_NOBLANKS);
  string_free (str, 1);
  if (!doc)
    {
      rc = GPG_ERR_BAD_DATA;
      goto fail;
    }

  root = xmlDocGetRootElement (doc);
  xmlNodePtr root_orig = root->children;
  root = root->children;
  rc = validate_import (client, root);
  if (rc)
    goto fail;

  do
    {
    again:
      if (dst_path)
        {
          char **path = strv_dup (dst_path);
          if (!path)
            {
              log_write ("%s(%i): %s", __FILE__, __LINE__,
                         pwmd_strerror (GPG_ERR_ENOMEM));
              rc = GPG_ERR_ENOMEM;
              goto fail;
            }

          xmlChar *a = xmlGetProp (root, (xmlChar *) "_name");
          if (!a)
            {
              strv_free (path);
              rc = GPG_ERR_INV_VALUE;
              goto fail;
            }

          if (strv_printf (&path, "%s", (char *) a) == 0)
            {
              xmlFree (a);
              rc = GPG_ERR_ENOMEM;
              goto fail;
            }

          xmlFree (a);
          n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
          if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
            {
              strv_free (path);
              goto fail;
            }

          if (!rc)
            {
              n = find_elements (client, client->doc, n->children, path + 1, &rc,
                                 NULL, NULL, NULL, 0, 0, NULL, 1);
              if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
                {
                  strv_free (path);
                  goto fail;
                }
              else if (!rc)
                {
                  xmlUnlinkNode (n);
                  xmlFreeNode (n);
                  strv_free (path);
                  path = NULL;
                  goto again;
                }
            }

          if (rc == GPG_ERR_ELEMENT_NOT_FOUND)
            {
              n = create_element_path (client, &path, &rc, NULL);
              if (rc)
                goto fail;
            }

          if (root->children)
            {
              copy = xmlCopyNodeList (root->children);
              n = xmlAddChildList (n, copy);
                  if (!n)
                    rc = GPG_ERR_ENOMEM;
            }

          strv_free (path);
        }
      else
        {
          char **path = NULL;

          /* Check if the content root element can create a DTD root element. */
          if (!xmlStrEqual ((xmlChar *) "element", root->name))
            {
              rc = GPG_ERR_SYNTAX;
              goto fail;
            }

          xmlChar *a;

          if ((a = xmlGetProp (root, (xmlChar *) "_name")) == NULL)
            {
              rc = GPG_ERR_SYNTAX;
              goto fail;
            }

          char *tmp = str_dup ((char *) a);
          xmlFree (a);
          int literal = is_literal_element (&tmp);

          if (!valid_xml_element ((xmlChar *) tmp) || literal)
            {
              xfree (tmp);
              rc = GPG_ERR_INV_VALUE;
              goto fail;
            }

          if (strv_printf (&path, "%s", tmp) == 0)
            {
              xfree (tmp);
              rc = GPG_ERR_ENOMEM;
              goto fail;
            }

          xfree (tmp);
          n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 1);
          if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
            {
              rc = GPG_ERR_BAD_DATA;
              goto fail;
            }

          /* Overwriting the existing tree. */
          if (!rc)
            {
              xmlUnlinkNode (n);
              xmlFreeNodeList (n);
            }

          rc = 0;
          xmlSetProp (root, (xmlChar *) "_name", (xmlChar *) path[0]);
          n = xmlCopyNode (root, 1);
          n = xmlAddChildList (xmlDocGetRootElement (client->doc), n);
          strv_free (path);
        }

      if (n && !rc)
        rc = update_element_mtime (client, n->parent);

      for (root = root_orig->next; root; root = root->next)
        {
          if (root->type == XML_ELEMENT_NODE)
            break;
        }

      root_orig = root;
    }
  while (root);

fail:
  if (doc)
    xmlFreeDoc (doc);

  if (dst_path)
    strv_free (dst_path);

  return rc;
}

static gpg_error_t
parse_import_opt_root (void *data, void *value)
{
  struct client_s *client = data;

  client->import_root = str_dup (value);
  return client->import_root ? 0 : GPG_ERR_ENOMEM;
}

static gpg_error_t
import_command (assuan_context_t ctx, char *line)
{
  gpg_error_t rc;
  struct client_s *client = assuan_get_pointer (ctx);
  unsigned char *result;
  size_t len;
    struct argv_s *args[] = {
    &(struct argv_s) {"root", OPTION_TYPE_ARG, parse_import_opt_root},
    NULL
  };

  xfree (client->import_root);
  client->import_root = NULL;
  rc = parse_options (&line, args, client, 0);
  if (rc)
    return send_error (ctx, rc);

  rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
  if (rc)
    {
      xfree (client->import_root);
      client->import_root = NULL;
      return send_error (ctx, rc);
    }

  rc = do_import (client, client->import_root, result);
  xfree (client->import_root);
  client->import_root = NULL;
  return send_error (ctx, rc);
}

static gpg_error_t
do_lock (struct client_s *client, int add)
{
  gpg_error_t rc = lock_file_mutex (client, add);

  if (!rc)
    client->flags |= FLAG_LOCK_CMD;

  return rc;
}

static gpg_error_t
lock_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;

  if (line && *line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = do_lock (client, 0);
  return send_error (ctx, rc);
}

static gpg_error_t
unlock_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;

  if (line && *line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = unlock_file_mutex (client, 0);
  return send_error (ctx, rc);
}

static gpg_error_t
option_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc = 0;
  struct pinentry_option_s *pin_opts = &client->pinentry_opts;
#ifdef WITH_AGENT
  struct agent_s *agent = client->crypto->agent;
#endif
  char namebuf[255] = { 0 };
  char *name = namebuf;
  char *value = NULL, *p, *tmp = NULL;

  p = strchr (line, '=');
  if (!p)
    {
      strncpy (namebuf, line, sizeof(namebuf));
      namebuf[sizeof(namebuf)-1] = 0;
    }
  else
    {
      strncpy (namebuf, line, strlen (line)-strlen (p));
      namebuf[sizeof(namebuf)-1] = 0;
      value = p+1;
    }

  log_write1 ("OPTION name='%s' value='%s'", name, value);

  if (strcasecmp (name, (char *) "lock-timeout") == 0)
    {
      long n = 0;

      if (value)
        {
          n = strtol (value, &tmp, 10);
          if (tmp && *tmp)
            return send_error (ctx, GPG_ERR_INV_VALUE);
        }

      client->lock_timeout = n;
      goto done;
    }
  else if (strcasecmp (name, (char *) "NAME") == 0)
    {
      if (value && strchr (value, ' '))
        rc = GPG_ERR_INV_VALUE;
      else
        {
          tmp = pthread_getspecific (thread_name_key);
          xfree (tmp);
          MUTEX_LOCK (&cn_mutex);
          xfree (client->thd->name);
          client->thd->name = NULL;

          if (!value || !*value)
            pthread_setspecific (thread_name_key, str_dup (""));
          else
            {
              client->thd->name = str_dup (value);
              pthread_setspecific (thread_name_key, str_dup (value));
            }

          MUTEX_UNLOCK (&cn_mutex);
        }
      goto done;
    }
  else if (strcasecmp (name, (char *) "lc-messages") == 0)
    {
      xfree (pin_opts->lc_messages);
      pin_opts->lc_messages = NULL;
      if (value && *value)
        pin_opts->lc_messages = str_dup (value);
#ifdef WITH_AGENT
      if (use_agent)
        rc = set_agent_option (client->crypto->agent, "lc-messages", value);
#endif
    }
  else if (strcasecmp (name, (char *) "lc-ctype") == 0)
    {
      xfree (pin_opts->lc_ctype);
      pin_opts->lc_ctype = NULL;
      if (value && *value)
        pin_opts->lc_ctype = str_dup (value);
#ifdef WITH_AGENT
      if (use_agent)
        rc = set_agent_option (client->crypto->agent, "lc-ctype", value);
#endif
    }
  else if (strcasecmp (name, (char *) "ttyname") == 0)
    {
      xfree (pin_opts->ttyname);
      pin_opts->ttyname = NULL;
      if (value && *value)
        pin_opts->ttyname = str_dup (value);
#ifdef WITH_AGENT
      if (use_agent)
        rc = set_agent_option (client->crypto->agent, "ttyname", value);
#endif
    }
  else if (strcasecmp (name, (char *) "ttytype") == 0)
    {
      xfree (pin_opts->ttytype);
      pin_opts->ttytype = NULL;
      if (value && *value)
        pin_opts->ttytype = str_dup (value);
#ifdef WITH_AGENT
      if (use_agent)
        rc = set_agent_option (client->crypto->agent, "ttytype", value);
#endif
    }
  else if (strcasecmp (name, (char *) "display") == 0)
    {
      xfree (pin_opts->display);
      pin_opts->display = NULL;
      if (value && *value)
        pin_opts->display = str_dup (value);
#ifdef WITH_AGENT
      if (use_agent)
        rc = set_agent_option (client->crypto->agent, "display", value);
#endif
    }
  else if (strcasecmp (name, (char *) "pinentry-desc") == 0)
    {
      xfree (pin_opts->desc);
      pin_opts->desc = NULL;
      if (value && *value)
        pin_opts->desc = str_dup (value);
    }
    else if (strcasecmp (name, (char *) "pinentry-title") == 0)
    {
      xfree (pin_opts->title);
      pin_opts->title = NULL;
      if (value && *value)
        pin_opts->title = str_dup (value);
    }
    else if (strcasecmp (name, (char *) "pinentry-prompt") == 0)
    {
      xfree (pin_opts->prompt);
      pin_opts->prompt = NULL;
      if (value && *value)
        pin_opts->prompt = str_dup (value);
    }

  else if (strcasecmp (name, "pinentry-timeout") == 0)
    {
      char *p = NULL;
      int n;

      if (!value)
        goto done;

      n = (int) strtol (value, &p, 10);

      if (*p || n < 0)
        return send_error (ctx, GPG_ERR_INV_VALUE);

      pin_opts->timeout = n;
      MUTEX_LOCK (&rcfile_mutex);
      config_set_int_param (&global_config,
                            client->filename ? client->filename : "global",
                            "pinentry_timeout", value);
      MUTEX_UNLOCK (&rcfile_mutex);
      goto done;
    }
  else if (strcasecmp (name, "disable-pinentry") == 0)
    {
      int n = 1;

      if (value && *value)
        {
          n = (int) strtol (value, &tmp, 10);
          if (*tmp || n < 0 || n > 1)
            return send_error (ctx, GPG_ERR_INV_VALUE);
        }

      if (n)
        client->flags |= FLAG_NO_PINENTRY;
      else
        client->flags &= ~FLAG_NO_PINENTRY;

#ifdef WITH_AGENT
      if (use_agent)
        {
          if (client->flags & FLAG_NO_PINENTRY)
            rc = set_agent_option (client->crypto->agent, "pinentry-mode",
                                   "loopback");
          else
            rc = set_agent_option (client->crypto->agent, "pinentry-mode",
                                   "ask");

          if (rc)
            return send_error (ctx, rc);
        }
#endif
    }
  else
    return send_error (ctx, GPG_ERR_UNKNOWN_OPTION);

done:
#ifdef WITH_AGENT
  if (!rc && use_agent && agent)
    {
      rc = pinentry_merge_options (&client->crypto->agent->pinentry_opts,
                                   pin_opts);
    }
#endif

  return send_error (ctx, rc);
}

static gpg_error_t
do_rename (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char **req, **src, *dst;
  xmlNodePtr n, ndst;

  req = str_split (line, " ", 0);

  if (!req || !req[0] || !req[1])
    {
      strv_free (req);
      return GPG_ERR_SYNTAX;
    }

  dst = req[1];
  is_literal_element (&dst);

  if (!valid_xml_element ((xmlChar *) dst))
    {
      strv_free (req);
      return GPG_ERR_INV_VALUE;
    }

  if (strchr (req[0], '\t'))
    src = str_split (req[0], "\t", 0);
  else
    src = str_split (req[0], " ", 0);

  if (!src || !*src)
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  n = find_root_element (client, client->doc, &src, &rc, NULL, 0, 0);
  if (rc)
    goto fail;

  if (src[1] && n)
    n = find_elements (client, client->doc, n->children, src + 1, &rc, NULL, NULL,
                       NULL, 0, 0, NULL, 0);

  if (!n || rc)
    goto fail;

  rc = is_element_owner (client, n);
  if (rc)
    goto fail;

  xmlChar *a = xmlGetProp (n, (xmlChar *) "_name");
  if (!a)
    {
      rc = GPG_ERR_ENOMEM;
      goto fail;
    }

  /* To prevent unwanted effects:
   *
   * <root name="a"><b/></root>
   *
   * RENAME a<TAB>b b
   */
  if (xmlStrEqual (a, (xmlChar *) dst))
    {
      xmlFree (a);
      rc = GPG_ERR_AMBIGUOUS_NAME;
      goto fail;
    }

  xmlFree (a);
  char **tmp = NULL;
  if (src[1])
    {
      char **p;

      for (p = src; *p; p++)
        {
          if (!*(p + 1))
            break;
          strv_printf (&tmp, "%s", *p);
        }
    }

  strv_printf (&tmp, "!%s", dst);
  ndst = find_root_element (client, client->doc, &tmp, &rc, NULL, 0, 0);
  if (!ndst && rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
    {
      strv_free (tmp);
      goto fail;
    }

  if (tmp[1] && ndst)
    ndst = find_elements (client, client->doc, ndst->children, tmp + 1, &rc, NULL,
                          NULL, NULL, 0, 0, NULL, 0);

  strv_free (tmp);
  if (!ndst && rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
    goto fail;

  rc = 0;

  /* Target may exist:
   *
   * <root name="a"/>
   * <root name="b" target="a"/>
   *
   * RENAME b a
   *
   * Would need to do:
   * RENAME !b a
   */
  if (ndst == n)
    {
      rc = GPG_ERR_AMBIGUOUS_NAME;
      goto fail;
    }

  if (ndst)
    {
      rc = is_element_owner (client, ndst);
      if (rc)
        goto fail;

      unlink_node (client, ndst);
      xmlFreeNodeList (ndst);
    }

  rc = add_attribute (client, n, "_name", dst);

fail:
  strv_free (req);
  strv_free (src);
  return rc;
}

static gpg_error_t
rename_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_rename (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_rename (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
do_copy (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char **req, **src = NULL, **dst = NULL;
  xmlNodePtr nsrc, ndst, new = NULL;

  req = str_split (line, " ", 0);
  if (!req || !req[0] || !req[1])
    {
      strv_free (req);
      return GPG_ERR_SYNTAX;
    }

  if (strchr (req[0], '\t'))
    src = str_split (req[0], "\t", 0);
  else
    src = str_split (req[0], " ", 0);

  if (!src || !*src)
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  if (strchr (req[1], '\t'))
    dst = str_split (req[1], "\t", 0);
  else
    dst = str_split (req[1], " ", 0);

  if (!dst || !*dst)
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  if (!valid_element_path (dst, 0))
    {
      rc = GPG_ERR_INV_VALUE;
      goto fail;
    }

  nsrc = find_root_element (client, client->doc, &src, &rc, NULL, 0, 0);
  if (rc)
    goto fail;

  if (nsrc && src[1])
    nsrc = find_elements (client, client->doc, nsrc->children, src + 1, &rc, NULL,
                          NULL, NULL, 0, 0, NULL, 0);

  if (!nsrc || rc)
    goto fail;

  new = xmlCopyNodeList (nsrc);
  if (!new)
    {
      rc = GPG_ERR_ENOMEM;
      goto fail;
    }

  int create = 0;
  ndst = find_root_element (client, client->doc, &dst, &rc, NULL, 0, 0);
  if (rc == GPG_ERR_EACCES)
    goto fail;

  if (ndst && dst[1])
    {
      if (ndst->children)
        ndst = find_elements (client, client->doc, ndst->children, dst + 1, &rc, NULL,
                              NULL, create_target_elements_cb, 0, 0, NULL, 0);
      else
        create = 1;
    }
  else
    create = 1;

  if (!ndst && rc != GPG_ERR_ELEMENT_NOT_FOUND)
    goto fail;
  else if (!ndst || create)
    {
      ndst = create_element_path (client, &dst, &rc, NULL);
      if (!ndst || rc)
        goto fail;
    }

  rc = is_element_owner (client, ndst);
  if (rc)
    goto fail;

  /* Merge any attributes from the src node to the initial dst node. */
  for (xmlAttrPtr attr = new->properties; attr; attr = attr->next)
    {
      if (xmlStrEqual (attr->name, (xmlChar *) "_name"))
        continue;

      xmlAttrPtr a = xmlHasProp (ndst, attr->name);
      if (a)
        xmlRemoveProp (a);

      xmlChar *tmp = xmlNodeGetContent (attr->children);
      xmlNewProp (ndst, attr->name, tmp);
      xmlFree (tmp);
      rc = add_attribute (client, ndst, NULL, NULL);
    }

  xmlNodePtr n = ndst->children;
  xmlUnlinkNode (n);
  xmlFreeNodeList (n);
  ndst->children = NULL;

  if (new->children)
    {
      n = xmlCopyNodeList (new->children);
      if (!n)
        {
          rc = GPG_ERR_ENOMEM;
          goto fail;
        }

      n = xmlAddChildList (ndst, n);
      if (!n)
        {
          rc = GPG_ERR_ENOMEM;
          goto fail;
        }

      rc = update_element_mtime (client, xmlDocGetRootElement (client->doc) ==
                                 ndst->parent ? ndst : ndst->parent);
    }

fail:
  if (new)
    {
      xmlUnlinkNode (new);
      xmlFreeNodeList (new);
    }

  if (req)
    strv_free (req);

  if (src)
    strv_free (src);

  if (dst)
    strv_free (dst);

  return rc;
}

static gpg_error_t
copy_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_copy (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_copy (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
do_move (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char **req, **src = NULL, **dst = NULL;
  xmlNodePtr nsrc, ndst = NULL;

  req = str_split (line, " ", 0);

  if (!req || !req[0] || !req[1])
    {
      strv_free (req);
      return GPG_ERR_SYNTAX;
    }

  if (strchr (req[0], '\t'))
    src = str_split (req[0], "\t", 0);
  else
    src = str_split (req[0], " ", 0);

  if (!src || !*src)
    {
      rc = GPG_ERR_SYNTAX;
      goto fail;
    }

  if (strchr (req[1], '\t'))
    dst = str_split (req[1], "\t", 0);
  else
    dst = str_split (req[1], " ", 0);

  nsrc = find_root_element (client, client->doc, &src, &rc, NULL, 0, 0);
  if (rc)
    goto fail;

  if (nsrc && src[1])
    nsrc = find_elements (client, client->doc, nsrc->children, src + 1, &rc,
                          NULL, NULL, NULL, 0, 0, NULL, 0);

  if (!nsrc)
    goto fail;

  rc = is_element_owner (client, nsrc);
  if (rc)
    goto fail;

  if (dst)
    {
      if (!valid_element_path (dst, 0))
        {
          rc = GPG_ERR_INV_VALUE;
          goto fail;
        }

      ndst = find_root_element (client, client->doc, &dst, &rc, NULL, 0, 0);
      if (rc)
        goto fail;

      if (ndst && dst[1])
        ndst = find_elements (client, client->doc, ndst->children, dst + 1,
                              &rc, NULL, NULL, NULL, 0, 0, NULL, 0);
    }
  else
    ndst = xmlDocGetRootElement (client->doc);

  for (xmlNodePtr n = ndst; n; n = n->parent)
    {
      if (n == nsrc)
        {
          rc = GPG_ERR_CONFLICT;
          goto fail;
        }
    }

  if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
    goto fail;

  rc = 0;

  if (ndst)
    {
      xmlChar *a = node_has_attribute (nsrc, (xmlChar *) "_name");

      xmlNodePtr dup = find_element (client, ndst->children, (char *) a,
                                     NULL, &rc);
      xmlFree (a);

      if (rc)
        goto fail;

      if (dup)
        {
          if (dup == nsrc)
            goto fail;

          if (ndst == xmlDocGetRootElement (client->doc))
            {
              xmlNodePtr n = nsrc;
              int match = 0;

              while (n->parent && n->parent != ndst)
                n = n->parent;

              xmlChar *a = node_has_attribute (n, (xmlChar *) "_name");
              xmlChar *b = node_has_attribute (nsrc, (xmlChar *) "_name");

              if (xmlStrEqual (a, b))
                {
                  match = 1;
                  xmlUnlinkNode (nsrc);
                  xmlUnlinkNode (n);
                  xmlFreeNodeList (n);
                }

              xmlFree (a);
              xmlFree (b);

              if (!match)
                {
                  xmlUnlinkNode (dup);
                  xmlFreeNodeList (dup);
                }
            }
          else
            xmlUnlinkNode (dup);
        }
    }

  if (!ndst && dst)
    {
      xmlChar *name = node_has_attribute (nsrc, (xmlChar *) "_name");

      if (nsrc->parent == xmlDocGetRootElement (client->doc)
          && !strcmp ((char *) name, *dst))
        {
          xmlFree (name);
          rc = GPG_ERR_CONFLICT;
          goto fail;
        }

      xmlFree (name);
      ndst = create_element_path (client, &dst, &rc, nsrc);
      if (rc)
        goto fail;
    }

  if (!ndst)
    goto fail;

  update_element_mtime (client, nsrc->parent);
  xmlUnlinkNode (nsrc);
  ndst = xmlAddChildList (ndst, nsrc);

  if (!ndst)
    rc = GPG_ERR_ENOMEM;
  else
    update_element_mtime (client, ndst->parent);

fail:
  if (req)
    strv_free (req);

  if (src)
    strv_free (src);

  if (dst)
    strv_free (dst);

  return rc;
}

static gpg_error_t
move_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
    rc = GPG_ERR_SYNTAX;
  if (rc)
    return send_error (ctx, rc);

  if (client->opts & OPT_INQUIRE)
    {
      unsigned char *result;
      size_t len;

      rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
      if (rc)
        return send_error (ctx, rc);

      pthread_cleanup_push (xfree, result);
      rc = do_move (ctx, (char *)result);
      pthread_cleanup_pop (1);
    }
  else
    rc = do_move (ctx, line);

  return send_error (ctx, rc);
}

static gpg_error_t
ls_command (assuan_context_t ctx, char *line)
{
  gpg_error_t rc;
  char *tmp;
  char *dir;
  DIR *d;

  if (line && *line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  tmp = str_asprintf ("%s/data", homedir);
  dir = expand_homedir (tmp);
  xfree (tmp);
  d = opendir (dir);
  rc = gpg_error_from_errno (errno);

  if (!d)
    {
      xfree (dir);
      return send_error (ctx, rc);
    }

  size_t len =
    offsetof (struct dirent, d_name) +pathconf (dir, _PC_NAME_MAX) + 1;
  struct dirent *p = xmalloc (len), *cur = NULL;
  char *list = NULL;

  xfree (dir);
  pthread_cleanup_push (xfree, p);
  pthread_cleanup_push ((void *)(void *)closedir, d);
  rc = 0;

  while (!readdir_r (d, p, &cur) && cur)
    {
      struct stat st;

      if (stat (cur->d_name, &st) == -1 || !S_ISREG (st.st_mode))
        continue;

      tmp = str_asprintf ("%s%s\n", list ? list : "", cur->d_name);

      if (!tmp)
        {
          if (list)
            xfree (list);

          rc = GPG_ERR_ENOMEM;
          break;
        }

      xfree (list);
      list = tmp;
    }

  pthread_cleanup_pop (1); // closedir (d)
  pthread_cleanup_pop (1); // xfree (p)

  if (rc)
    return send_error (ctx, rc);

  if (!list)
    return send_error (ctx, GPG_ERR_NO_DATA);

  list[strlen (list) - 1] = 0;
  pthread_cleanup_push (xfree, list);
  rc = xfer_data (ctx, list, strlen (list));
  pthread_cleanup_pop (1);
  return send_error (ctx, rc);
}

static gpg_error_t
bye_notify (assuan_context_t ctx, char *line)
{
  struct client_s *cl = assuan_get_pointer (ctx);

  cl->thd->state = CLIENT_STATE_DISCON;

#ifdef WITH_GNUTLS
  if (cl->thd->remote)
    {
      int rc;

      do
        {
          struct timeval tv = { 0, 50000 };

          rc = gnutls_bye (cl->thd->tls->ses, GNUTLS_SHUT_RDWR);
          if (rc == GNUTLS_E_AGAIN)
            select (0, NULL, NULL, NULL, &tv);
        }
      while (rc == GNUTLS_E_AGAIN);
    }
#endif

  /* This will let assuan_process_next() return. */
  if (fcntl (cl->thd->fd, F_SETFL, O_NONBLOCK) == -1)
    {
      cl->last_rc = gpg_error_from_errno (errno);
      return cl->last_rc;
    }

  cl->last_rc = 0;              // BYE command result
  return 0;
}

static gpg_error_t
reset_notify (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);

  if (client)
    cleanup_client (client);

  return 0;
}

/*
 * This is called before every Assuan command.
 */
static gpg_error_t
command_startup (assuan_context_t ctx, const char *name)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct command_table_s *cmd = NULL;

  log_write1 ("command='%s'", name);
  client->last_rc = client->opts = 0;

  for (int i = 0; command_table[i]; i++)
    {
      if (!strcasecmp (name, command_table[i]->name))
        {
          if (command_table[i]->ignore_startup)
            return 0;
          cmd = command_table[i];
          break;
        }
    }

  if (!cmd)
    return GPG_ERR_UNKNOWN_COMMAND;

  client->last_rc = rc = gpg_error (file_modified (client, cmd));
  if (!rc)
    update_client_state (client, CLIENT_STATE_COMMAND);

  return rc;
}

/*
 * This is called after every Assuan command.
 */
static void
command_finalize (assuan_context_t ctx, gpg_error_t rc)
{
  struct client_s *client = assuan_get_pointer (ctx);

  if (!(client->flags & FLAG_LOCK_CMD))
    unlock_file_mutex (client, 0);

  unlock_flock (&client->flock_fd);
  log_write1 (_("command completed: rc=%u"),  rc ? rc : client->last_rc);
  client->last_rc = gpg_error (GPG_ERR_UNKNOWN_COMMAND);
#ifdef WITH_GNUTLS
  client->thd->buffer_timeout = client->thd->last_buffer_size = 0;
#endif
  update_client_state (client, CLIENT_STATE_IDLE);
}

static gpg_error_t
help_command (assuan_context_t ctx, char *line)
{
  gpg_error_t rc;
  int i;

  if (!line || !*line)
    {
      char *tmp;
      char *help = str_dup (_("Usage: HELP [<COMMAND>]\n"
                              "For commands that take an element path as an argument, each element is "
                              "separated with an ASCII @key{TAB} character (ASCII 0x09)."
                              "\n" "COMMANDS:"));

      for (i = 0; command_table[i]; i++)
        {
          if (!command_table[i]->help)
            continue;

          tmp = str_asprintf ("%s %s", help, command_table[i]->name);
          xfree (help);
          help = tmp;
        }

      tmp = strip_texi_and_wrap (help);
      xfree (help);
      pthread_cleanup_push (xfree, tmp);
      rc = xfer_data (ctx, tmp, strlen (tmp));
      pthread_cleanup_pop (1);
      return send_error (ctx, rc);
    }

  for (i = 0; command_table[i]; i++)
    {
      if (!strcasecmp (line, command_table[i]->name))
        {
          char *help, *tmp;

          if (!command_table[i]->help)
            break;

          help = strip_texi_and_wrap (command_table[i]->help);
          tmp = str_asprintf (_("Usage: %s"), help);
          xfree (help);
          pthread_cleanup_push (xfree, tmp);
          rc = xfer_data (ctx, tmp, strlen (tmp));
          pthread_cleanup_pop (1);
          return send_error (ctx, rc);
        }
    }

  return send_error (ctx, GPG_ERR_INV_NAME);
}

static void
new_command (const char *name, int ignore, int unlock, int flock_type,
             gpg_error_t (*handler) (assuan_context_t, char *),
             const char *help)
{
  struct command_table_s **tmp;
  int i = 0;

  if (command_table)
    for (i = 0; command_table[i]; i++);

  tmp = xrealloc (command_table, (i + 2) * sizeof (struct command_table_s *));
  assert (tmp);
  command_table = tmp;
  command_table[i] = xcalloc (1, sizeof (struct command_table_s));
  command_table[i]->name = name;
  command_table[i]->handler = handler;
  command_table[i]->ignore_startup = ignore;
  command_table[i]->unlock = unlock;
  command_table[i]->flock_type = flock_type;
  command_table[i++]->help = help;
  command_table[i] = NULL;
}

void
deinit_commands ()
{
  int i;

  for (i = 0; command_table[i]; i++)
    xfree (command_table[i]);

  xfree (command_table);
}

static int
sort_commands (const void *arg1, const void *arg2)
{
  struct command_table_s *const *a = arg1;
  struct command_table_s *const *b = arg2;

  if (!*a || !*b)
    return 0;
  else if (*a && !*b)
    return 1;
  else if (!*a && *b)
    return -1;

  return strcmp ((*a)->name, (*b)->name);
}

static gpg_error_t
passwd_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct argv_s *args[] = {
    &(struct argv_s) {"reset", OPTION_TYPE_NOARG, parse_opt_reset},
    &(struct argv_s) {"s2k-count", OPTION_TYPE_ARG, parse_opt_s2k_count},
    &(struct argv_s) {"no-passphrase", OPTION_TYPE_NOARG, parse_opt_no_passphrase},
    NULL
  };

  rc = peer_is_invoker (client);
  if (rc == GPG_ERR_EACCES)
    return send_error (ctx, rc);

  if (client->flags & FLAG_NEW)
    return send_error (ctx, GPG_ERR_INV_STATE);

  client->crypto->save.hdr.s2k_count =
    config_get_ulonglong (client->filename, "s2k_count");
  rc = parse_options (&line, args, client, 0);
  if (rc)
    return send_error (ctx, rc);

  if (!rc && client->opts & OPT_RESET)
    {
      rc = cache_clear (client->md5file);
      if (!rc)
        send_status_all (STATUS_CACHE, NULL);
    }

  if (!rc)
    {
      if (!IS_PKI (client->crypto))
        {
          struct crypto_s *crypto;

          xfree (client->crypto->filename);
          client->crypto->filename = str_dup (client->filename);
          rc = change_passwd (ctx, client->filename,
                              client->flags & FLAG_NO_PINENTRY, &crypto,
                              (client->opts & OPT_NO_PASSPHRASE));
          if (!rc)
            {
              cleanup_crypto (&client->crypto);
              client->crypto = crypto;
              update_checksum (client);
              cleanup_crypto_stage1 (client->crypto);
            }
        }
#ifdef WITH_AGENT
      else
        {
          if (client->crypto->save.hdr.s2k_count)
            rc = send_to_agent (client->crypto->agent, NULL, NULL,
                                "OPTION s2k-count=%lu",
                                client->crypto->save.hdr.s2k_count);

          if (!rc)
            rc = agent_passwd (client->crypto);

          (void) kill_scd (client->crypto->agent);
        }
#endif
    }

  return send_error (ctx, rc);
}

static gpg_error_t
parse_keygrip_opt_sign (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_SIGN;
  return 0;
}

static gpg_error_t
keygrip_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  struct crypto_s *crypto = NULL;
  struct argv_s *args[] = {
    &(struct argv_s) {"sign", OPTION_TYPE_NOARG, parse_keygrip_opt_sign},
    NULL
  };

  if (!line || !*line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  rc = parse_options (&line, args, client, 1);
  if (rc)
    return send_error (ctx, rc);

  if (!valid_filename (line))
    return send_error (ctx, GPG_ERR_INV_VALUE);

  rc = init_client_crypto (&crypto);
  if (rc)
    return send_error (ctx, rc);

  rc = read_data_file (line, crypto);
  if (!rc)
    {
      char *hexgrip = NULL;

      if (!IS_PKI (crypto))
        {
          cleanup_crypto (&crypto);
          return send_error (ctx, GPG_ERR_NOT_SUPPORTED);
        }

      if (client->opts & OPT_SIGN)
        {
          if (valid_keygrip (crypto->sign_grip, sizeof (crypto->sign_grip)))
            hexgrip = bin2hex (crypto->sign_grip, sizeof (crypto->sign_grip));
        }

      if (!hexgrip)
        hexgrip = bin2hex (crypto->grip, sizeof (crypto->grip));

      if (!hexgrip)
        rc = GPG_ERR_ENOMEM;
      else
        rc = xfer_data (ctx, hexgrip, strlen (hexgrip));

      xfree (hexgrip);
    }

  UPDATE_AGENT_CTX (client, crypto);
  cleanup_crypto (&crypto);
  return send_error (ctx, rc);
}

static gpg_error_t
parse_opt_data (void *data, void *value)
{
  struct client_s *client = data;

  (void) value;
  client->opts |= OPT_DATA;
  return 0;
}

static gpg_error_t
send_client_list (assuan_context_t ctx)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc = 0;

  if (client->opts & OPT_VERBOSE)
    {
      unsigned i, t;
      char **list = NULL;
      char *line;

      MUTEX_LOCK (&cn_mutex);
      pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
      t = slist_length (cn_thread_list);

      for (i = 0; i < t; i++)
        {
          struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
          char *tmp;

          if (thd->state == CLIENT_STATE_UNKNOWN)
            continue;

          tmp = build_client_info_line (thd, 0);
          if (tmp)
            {
              char **l = strv_cat (list, tmp);
              if (!l)
                rc = GPG_ERR_ENOMEM;
              else
                list = l;
            }
          else
            rc = GPG_ERR_ENOMEM;

          if (rc)
            {
              strv_free (list);
              break;
            }
        }

      pthread_cleanup_pop (1);
      if (rc)
        return rc;

      line = strv_join ("\n", list);
      strv_free (list);
      pthread_cleanup_push (xfree, line);
      rc = xfer_data (ctx, line, strlen (line));
      pthread_cleanup_pop (1);
      return rc;
    }

  if (client->opts & OPT_DATA)
    {
      char buf[ASSUAN_LINELENGTH];

      MUTEX_LOCK (&cn_mutex);
      pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
      snprintf (buf, sizeof (buf), "%u", slist_length (cn_thread_list));
      pthread_cleanup_pop (1);
      rc = xfer_data (ctx, buf, strlen (buf));
    }
  else
    rc = send_status (ctx, STATUS_CLIENTS, NULL);

  return rc;
}

static gpg_error_t
getinfo_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  char buf[ASSUAN_LINELENGTH];
  struct argv_s *args[] = {
    &(struct argv_s) {"data", OPTION_TYPE_NOARG, parse_opt_data},
    &(struct argv_s) {"verbose", OPTION_TYPE_NOARG, parse_opt_verbose},
    NULL
  };

  rc = parse_options (&line, args, client, 1);
  if (rc)
    return send_error (ctx, rc);

  if (!strcasecmp (line, "clients"))
    {
      rc = send_client_list (ctx);
    }
  else if (!strcasecmp (line, "cache"))
    {
      if (client->opts & OPT_DATA)
        {
          snprintf (buf, sizeof (buf), "%u", cache_file_count ());
          rc = xfer_data (ctx, buf, strlen (buf));
        }
      else
        rc = send_status (ctx, STATUS_CACHE, NULL);
    }
  else if (!strcasecmp (line, "pid"))
    {
      char buf[32];
      pid_t pid = getpid ();

      snprintf (buf, sizeof (buf), "%i", pid);
      rc = xfer_data (ctx, buf, strlen (buf));
    }
  else if (!strcasecmp (line, "version"))
    {
      char *buf = str_asprintf ("0x%06x %s%s", VERSION_HEX,
#ifdef WITH_LIBACL
                                "ACL "
#endif
#ifdef WITH_GNUTLS
                                "GNUTLS "
#endif
#ifdef WITH_QUALITY
                                "QUALITY "
#endif
                                "", use_agent ? "AGENT" : "");
      rc = xfer_data (ctx, buf, strlen (buf));
      xfree (buf);
    }
  else if (!strcasecmp (line, "last_error"))
    {
      if (client->last_error)
        rc = xfer_data (ctx, client->last_error, strlen (client->last_error));
      else
        rc = GPG_ERR_NO_DATA;
    }
  else if (!strcasecmp (line, "user"))
    {
      char *user = NULL;

#ifdef WITH_GNUTLS
      if (client->thd->remote)
        user = str_asprintf ("#%s", client->thd->tls->fp);
      else
        user = get_username (client->thd->peer->uid);
#else
      user = get_username (client->thd->peer->uid);
#endif
      if (user)
        {
          pthread_cleanup_push (xfree, user);
          rc = xfer_data (ctx, user, strlen (user));
          pthread_cleanup_pop (1);
        }
      else
        rc = GPG_ERR_NO_DATA;
    }
  else
    rc = gpg_error (GPG_ERR_SYNTAX);

  return send_error (ctx, rc);
}

#ifdef WITH_AGENT
static gpg_error_t
send_data_cb (void *user, const void *buf, size_t len)
{
  assuan_context_t ctx = user;

  return assuan_send_data (ctx, buf, len);
}

static gpg_error_t
send_status_cb (void *user, const char *line)
{
  assuan_context_t ctx = user;
  char keyword[200], *k;
  const char *p;

  for (p = line, k = keyword; *p; p++)
    {
      if (isspace (*p))
        break;

      *k++ = *p;
    }

  *k = 0;
  if (*p == '#')
    p++;

  while (isspace (*p))
    p++;

  return assuan_write_status (ctx, keyword, *p ? p : NULL);
}
#endif

static gpg_error_t
kill_command (assuan_context_t ctx, char *line)
{
  struct client_s *client = assuan_get_pointer (ctx);
  gpg_error_t rc;
  unsigned i, t;

  if (!line || !*line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  MUTEX_LOCK (&cn_mutex);
  pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
  t = slist_length (cn_thread_list);
  rc = GPG_ERR_ESRCH;

  for (i = 0; i < t; i++)
    {
      struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
      char *tmp = str_asprintf ("%p", thd->tid);

      if (strcmp (line, tmp))
        {
          xfree (tmp);
          continue;
        }

      xfree (tmp);
      rc = peer_is_invoker (client);
      if (!rc)
        {
#ifdef HAVE_PTHREAD_CANCEL
          rc = pthread_cancel (thd->tid);
#else
          close (thd->fd);
          thd->fd = -1;
#endif
          break;
        }

      rc = GPG_ERR_EACCES;
      if (config_get_boolean ("global", "strict_kill"))
        break;

#ifdef WITH_GNUTLS
      if (client->thd->remote && thd->remote)
        {
          if (!strcmp (client->thd->tls->fp, thd->tls->fp))
            {
#ifdef HAVE_PTHREAD_CANCEL
              rc = pthread_cancel (thd->tid);
#else
              close (thd->fd);
              thd->fd = -1;
#endif
              break;
            }
        }
      else if (!client->thd->remote && !thd->remote)
#endif
        {
          if (client->thd->peer->uid == thd->peer->uid)
            {
#ifdef HAVE_PTHREAD_CANCEL
              rc = pthread_cancel (thd->tid);
#else
              close (thd->fd);
              thd->fd = -1;
#endif
            }
        }
      break;
    }

  pthread_cleanup_pop (1);
  return send_error (ctx, rc);
}

static gpg_error_t
agent_command (assuan_context_t ctx, char *line)
{
  gpg_error_t rc = 0;

  if (!use_agent)
    return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);

#ifdef WITH_AGENT
  struct client_s *client = assuan_get_pointer (ctx);

  if (!line || !*line)
    return send_error (ctx, GPG_ERR_SYNTAX);

  assuan_set_flag (client->crypto->agent->ctx, ASSUAN_CONVEY_COMMENTS, 1);
  rc = assuan_transact (client->crypto->agent->ctx, line, send_data_cb,
                        client->ctx, agent_loopback_cb, client->crypto,
                        send_status_cb, client->ctx);
  if (gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
    {
      char *line;
      size_t len;

      rc = assuan_write_line (client->crypto->agent->ctx, "CAN");
      if (!rc)
        {
          rc = assuan_read_line (client->crypto->agent->ctx, &line, &len);
          if (!rc)
            rc = gpg_error (GPG_ERR_ASS_CANCELED);
        }
    }

  assuan_set_flag (client->crypto->agent->ctx, ASSUAN_CONVEY_COMMENTS, 0);
#endif
  return send_error (ctx, rc);
}

void
init_commands ()
{
  /* !BEGIN-HELP-TEXT!
   *
   * This comment is used as a marker to generate the offline documentation
   * found in doc/pwmd.info. The indentation needs to be kept for the awk
   * script to determine where commands begin and end.
   */
    new_command("HELP", 1, 1, 0, help_command, _(
"HELP [<COMMAND>]\n"
"Show available commands or command specific help text."
));

    new_command("AGENT", 1, 1, 0, agent_command, _(
"AGENT <command>\n"
"Send a @command{gpg-agent} protocol @var{command} directly to the "
"@command{gpg-agent}."
));

    new_command("KILL", 1, 0, 0, kill_command, _(
"KILL <thread_id>\n"
"Terminates the client identified by @var{thread_id} and releases any file "
"lock or other resources it has held. See @code{GETINFO} (@pxref{GETINFO}) "
"for details about listing connected clients. The @code{invoking_user} "
"(@pxref{Configuration}) may kill any client while others may only kill "
"clients of the same @code{UID} or @abbr{TLS} fingerprint.\n"
));

    new_command("GETINFO", 1, 1, 0, getinfo_command, _(
"GETINFO [--data] [--verbose] CACHE | CLIENTS | PID | USER | LAST_ERROR | VERSION\n"
"Get server and other information: @var{CACHE} returns the number of cached "
"documents via a status message. @var{CLIENTS} returns the number of "
"connected clients via a status message or a list of connected clients when "
"the @option{--verbose} parameter is used. The list contains space delimited "
"fields: the thread ID, client name, opened file (@code{/} if none opened), "
"file lock status, whether the current client is self, client state, "
"user ID or TLS fingerprint of the connected client and username if the "
"client is a local one. "
"Client state @code{0} is an unknown client state, @code{1} indicates the "
"client has connected but hasn't completed initializing, @code{2} indicates "
"that the client is idle, @code{3} means the "
"client is in a command and @code{4} means the client is disconnecting. This "
"line is always returned with a data response. @var{PID} returns the process "
"ID number of the server via a data response. @var{VERSION} returns the server "
"version number and compile-time features with a data response with each "
"being space delimited. @var{LAST_ERROR} returns a detailed description of "
"the last failed command when available. @var{USER} returns the username or "
"@abbr{TLS} hash of the connected client. @xref{Status Messages}. "
"\n"
"When the @option{--data} option is specified then the result will be sent "
"via a data response rather than a status message."
));

    new_command("PASSWD", 0, 0, FLOCK_TYPE_EX|FLOCK_TYPE_KEEP, passwd_command, _(
"PASSWD [--reset] [--s2k-count=N] [--no-passphrase]\n"
"Changes the passphrase of the secret key required to open the current "
"file or the passphrase of a symmetrically encrypted data file. When the "
"@option{--reset} option is passed then the cache entry for the current "
"file will be reset and the passphrase, if any, will be required during the "
"next @code{OPEN} (@pxref{OPEN})."
"\n"
"The @option{--s2k-count} option sets or changes (@pxref{SAVE}) the number "
"of hash iterations for a passphrase and must be either @code{0} to use "
"the calibrated count of the machine (the default), or a value greater than "
"or equal to @code{65536}. This option has no effect for symmetrically "
"encrypted data files."
"\n"
"The @option{--no-passphrase} option will prevent requiring a passphrase for "
"the data file, although a passphrase may be required when changing it."
"\n"
"This command is not available for non-invoking clients "
"(@pxref{Access Control})."
));

    new_command("KEYGRIP", 1, 1, FLOCK_TYPE_SH|FLOCK_TYPE_KEEP, keygrip_command, _(
"KEYGRIP [--sign] <filename>\n"
"Returns the hex encoded keygrip of the specified @var{filename} with a "
"data response."
"\n"
"When the @option{--sign} option is specified then the key used for signing "
"of the specified @var{filename} will be returned."
"\n"
"For symmetrically encrypted data files this command returns the error "
"GPG_ERR_NOT_SUPPORTED."
));

    new_command("OPEN", 1, 1, FLOCK_TYPE_SH|FLOCK_TYPE_KEEP, open_command, _(
"OPEN [--lock] <filename> [<passphrase>]\n"
"Opens @var{filename} using @var{passphrase}. When the filename is not "
"found on the file-system  then a new document will be created. If the file "
"is found, it is looked for in the file cache. If cached and no "
"@var{passphrase} was specified then the cached document is opened. When not "
"cached, @cite{pinentry(1)} will be used to retrieve the passphrase to use "
"for decryption unless @option{disable-pinentry} (@pxref{OPTION}) was "
"specified."
"\n"
"When the @option{--lock} option is passed then the file mutex will be "
"locked as if the @code{LOCK} command (@pxref{LOCK}) had been sent after the "
"file has been opened."
));

    new_command("SAVE", 0, 0, FLOCK_TYPE_EX|FLOCK_TYPE_KEEP,  save_command, _(
"SAVE [--no-passphrase] [--reset] [--ask] [--no-agent] [--s2k-count=N] [--cipher=<algo>] [--cipher-iterations=N] [--inquire-keyparam] [--keygrip=hexstring] [--sign-keygrip=hexstring]\n"
"Writes the @abbr{XML} document to disk. The file written to is the file that "
"was opened using the @code{OPEN} command (@pxref{OPEN}). If the file is a "
"new one or the option @option{--inquire-keyparam} was passed, then a new "
"keypair will be generated and a pinentry will be used to prompt for the "
"passphrase to encrypt with unless the @option{--no-passphrase} option was "
"passed in which case the data file will not be passphrase protected. "
"\n"
"The @option{--no-agent} option disables use of @command{gpg-agent} for "
"passphrase retrieval and caching of new files when @command{gpg-agent} "
"use is enabled. The datafile will be symmetrically encrypted and will not "
"use or generate any keypair."
"\n"
"The @option{--reset} option will clear the cache entry for the current file "
"and require a passphrase, if needed, before saving."
"\n"
"The @option{--ask} option will prompt for the passphrase of the current file, "
"if needed, before saving. This differs from the @option{--reset} option by "
"keeping the cache entry in case of an invalid passphrase or some other failure "
"which may otherwise cause a denial of service for other clients."
"\n"
"The @option{--cipher} option can be used to encrypt the @abbr{XML} data to "
"an alternate cipher. The default is @code{aes256}. See the Configuration "
"(@pxref{Configuration}) for available ciphers."
"\n"
"The @option{--cipher-iterations} option specifies the number of times to "
"hash the passphrase before encrypting the XML data. The default is "
"@code{5000000}. This option is an alias for @option{--s2k-count} since "
"version @var{3.0.15} of @command{pwmd}."
"\n"
"The @option{--inquire-keyparam} option will send a server @emph{INQUIRE} to "
"the client to obtain the key paramaters to use when generating a new "
"keypair. The inquired data is expected to be an S-expression. If not "
"specified then an @samp{RSA} key of @samp{2048} bits will be generated "
"unless otherwise set in the configuration file (@pxref{Configuration}). Note "
"that when this option is specified a new keypair will be generated "
"reguardless if the file is a new one and that if the data file is protected "
"the passphrase to open it will be required before generating the new "
"keypair. This option is not available for non-invoking clients "
"(@pxref{Access Control})."
"\n"
"You can encrypt the data file to a public key other than the one that it "
"was originally encrypted with by passing the @option{--keygrip} option with "
"the hex encoded keygrip of the public key as its argument. The keygrip may "
"be of any key that @command{gpg-agent} knows about. The "
"@option{--sign-keygrip} option may also be used to sign with an alternate "
"secret key. Use the @code{KEYGRIP} (@pxref{KEYGRIP}) command to obtain the "
"keygrip of an existing data file. This option may be needed when using a "
"smartcard. This option has no effect with symmetrically encrypted data "
"files. These options are not available for non-invoking clients "
"(@pxref{Access Control})."
"\n"
"The @option{--s2k-count} option sets number of hash iterations for a "
"passphrase. A value less-than @code{65536} will use the machine calibrated "
"value and is the default when using @command{gpg-agent}. This setting only "
"affects new files when using @command{gpg-agent}. To change the setting use "
"the @code{PASSWD} command (@pxref{PASSWD}). This option is an alias for "
"option @option{--cipher-iterations} when not using @command{gpg-agent}."
));

    new_command("ISCACHED", 1, 0, 0, iscached_command, _(
"ISCACHED [--lock] <filename>\n"
"An @emph{OK} response is returned if the specified @var{filename} is found "
"in the file cache. If not found in the cache but exists on the filesystem "
"then @var{GPG_ERR_NO_DATA} is returned. Otherwise a filesystem error is "
"returned."
"\n"
"The @option{lock} option will lock the file mutex of @var{filename} when the "
"file exists; it does not need to be opened nor cached. The lock will be "
"released when the client exits or sends the @code{UNLOCK} (@pxref{UNLOCK}) "
"command."
));

    new_command("CLEARCACHE", 1, 1, 0, clearcache_command, _(
"CLEARCACHE [<filename>]\n"
"Clears a file cache entry for all or the specified @var{filename}."
));

    new_command("CACHETIMEOUT", 1, 1, 0, cachetimeout_command, _(
"CACHETIMEOUT <filename> <seconds>\n"
"The time in @var{seconds} until @var{filename} will be removed from the "
"cache. @code{-1} will keep the cache entry forever, @code{0} will require "
"the passphrase for each @code{OPEN} or @code{SAVE} command (@pxref{OPEN}, "
"@pxref{SAVE}). @xref{Configuration}, and the @code{cache_timeout} "
"parameter."
));

    new_command("LIST", 0, 1, 0, list_command, _(
"LIST [--inquire] [--no-recurse] [--verbose] [--with-target] [--all] [[!]element[<TAB>[!]child[..]]]\n"
"If no element path is given then a newline separated list of root elements "
"is returned with a data response. If given, then all reachable elements "
"of the specified element path are returned unless the @option{--no-recurse} "
"option is specified. If specified, only the child elements of the element "
"path are returned without recursing into grandchildren. Each resulting "
"element is prefixed with the literal @code{!} character when the element "
"contains no @code{target} attribute. @xref{Target Attribute}, for details."
"\n"
"When the @option{--verbose} option is passed then each element path "
"returned will have zero or more flags appened to it. These flags are "
"delimited from the element path by a single space character. A flag itself "
"is a single character. Flag @code{P} indicates that access to the element "
"is denied. Flag @code{+} indicates that there are child nodes of "
"the current element path. Flag @code{E} indicates that an element of an "
"element path contained in a @var{target} attribute could not be found. Flag "
"@code{O} indicates that a @var{target} attribute recursion limit was reached "
"(@pxref{Configuration}). Flag @code{T} will append the resolved element path "
"of the @var{target} attribute contained in the current element (see below)."
"\n"
"The @option{--with-target} option implies @option{--verbose} and will append "
"an additional flag @code{T} followed by a single space then an element path. "
"The appended element path is the resolved path (@pxref{REALPATH}) of the "
"current element when it contains a @var{target} attribute. When no "
"@var{target} attribute is found then no flag will be appended."
"\n"
"The @option{--no-recurse} option limits the amount of data returned to only "
"the listing of children of the specified element path and not any "
"grandchildren."
"\n"
"The @option{--all} option lists the entire element tree for each root "
"element. This option also implies option @option{--verbose}."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("REALPATH", 0, 1, 0, realpath_command, _(
"REALPATH [--inquire] [!]element[<TAB>[!]child[..]]\n"
"Resolves all @code{target} attributes of the specified element path and "
"returns the result with a data response. @xref{Target Attribute}, for details."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("STORE", 0, 1, 0, store_command, _(
"STORE [!]element[<TAB>[!]child[..]]<TAB>[content]\n"
"This command uses a server @emph{INQUIRE} to retrieve data from the client."
"\n"
"Creates a new element path or modifies the @var{content} of an existing "
"element. If only a single element is specified then a new root element is "
"created. Otherwise, elements are @key{TAB} delimited and the content will be "
"set to the final @key{TAB} delimited element. If no @var{content} is "
"specified after the final @key{TAB}, then the content of an existing "
"element will be removed; or empty when creating a new element."
"\n"
"The only restriction of an element name is that it not contain whitespace "
"or begin with the literal element character @code{!} unless specifying a "
"literal element (@pxref{Target Attribute}). There is no whitespace between "
"the @key{TAB} delimited elements. It is recommended that the content of an "
"element be base64 encoded when it contains control or @key{TAB} characters "
"to prevent @abbr{XML} parsing and @command{pwmd} syntax errors."
));

    new_command("RENAME", 0, 1, 0, rename_command, _(
"RENAME [--inquire] [!]element[<TAB>[!]child[..]] <value>\n"
"Renames the specified @var{element} to the new @var{value}. If an element of "
"the same name as the @var{value} already exists it will be overwritten."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("COPY", 0, 1, 0, copy_command, _(
"COPY [--inquire] [!]source[<TAB>[!]child[..]] [!]dest[<TAB>[!]child[..]]\n"
"Copies the entire element tree starting from the child node of the source "
"element, to the destination element path. If the destination element path "
"does not exist then it will be created; otherwise it is overwritten."
"\n"
"Note that attributes from the source element are merged into the "
"destination element when the destination element path exists. When an "
"attribute of the same name exists in both the source and destination "
"elements then the destination attribute will be updated to the source "
"attribute value."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("MOVE", 0, 1, 0, move_command, _(
"MOVE [--inquire] [!]source[<TAB>[!]child[..]] [[!]dest[<TAB>[!]child[..]]]\n"
"Moves the source element path to the destination element path. If the "
"destination is not specified then it will be moved to the root node of the "
"document. If the destination is specified and exists then it will be "
"overwritten; otherwise non-existing elements of the destination element "
"path will be created."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("DELETE", 0, 1, 0, delete_command, _(
"DELETE [--inquire] [!]element[<TAB>[!]child[..]]\n"
"Removes the specified element path and all of its children. This may break "
"an element with a @code{target} attribute (@pxref{Target Attribute}) that "
"refers to this element or any of its children."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("GET", 0, 1, 0, get_command, _(
"GET [--inquire] [!]element[<TAB>[!]child[..]]\n"
"Retrieves the content of the specified element. The content is returned "
"with a data response."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
));

    new_command("ATTR", 0, 1, 0, attr_command, _(
"ATTR [--inquire] SET|GET|DELETE|LIST [<attribute>] [!]element[<TAB>[!]child[..]] ..\n"
"@table @asis\n"
"@item ATTR SET attribute [!]element[<TAB>[!]child[..]] [value]\n"
"\n"
"    Stores or updates an @var{attribute} name and optional @var{value} of an "
"element. When no @var{value} is specified any existing value will be removed."
"\n"
"@item ATTR DELETE attribute [!]element[<TAB>[!]child[..]]\n"
"\n"
"    Removes an @var{attribute} from an element."
"\n"
"@item ATTR LIST [!]element[<TAB>[!]child[..]]\n"
"\n"
"    Retrieves a newline separated list of attributes names and values "
"from the specified element. Each attribute name and value is space delimited."
"\n"
"@item ATTR GET attribute [!]element[<TAB>[!]child[..]]\n"
"\n"
"    Retrieves the value of an @var{attribute} from an element."
"@end table\n"
"\n"
"The @code{_name} attribute (case sensitive) cannot be removed nor modified. "
"Use the @code{DELETE} (@pxref{DELETE}) or @code{RENAME} (@pxref{RENAME}) "
"commands instead."
"\n"
"The @code{_mtime} attribute is updated each time an element is modified by "
"either storing content, editing attributes or by deleting a child element. "
"The @code{_ctime} attribute is created for each new element in an element "
"path."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
"\n"
"@xref{Target Attribute}, for details about this special attribute."
));

    new_command("XPATH", 0, 1, 0, xpath_command, _(
"XPATH [--inquire] <expression>[<TAB>[value]]\n"
"Evaluates an XPath @var{expression}. If no @var{value} argument is "
"specified it is assumed the expression is a request to return a result. "
"Otherwise, the result is set to the @var{value} argument and the document is "
"updated. If there is no @var{value} after the @key{TAB} character, the value "
"is assumed to be empty and the document is updated. For example:"
"@sp 1\n"
"@example\n"
"XPATH //element[@@_name='password']@key{TAB}\n"
"@end example\n"
"@sp 1"
"would clear the content of all @code{password} elements in the data file "
"while leaving off the trailing @key{TAB} would return all @code{password} "
"elements in @abbr{XML} format."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
"\n"
"See @url{http://www.w3schools.com/xpath/xpath_syntax.asp} for @abbr{XPATH} "
"expression syntax."
));

    new_command("XPATHATTR", 0, 1, 0, xpathattr_command, _(
"XPATHATTR [--inquire] SET|DELETE <name> <expression>[<TAB>[<value>]]\n"
"Like the @code{XPATH} command (@pxref{XPATH}) but operates on element "
"attributes and does not return a result. For the @var{SET} operation the "
"@var{value} is optional but the field is required. If not specified then "
"the attribute value will be empty. For example:"
"@sp 1"
"@example\n"
"XPATHATTR SET password //element[@@_name='password']@key{TAB}\n"
"@end example\n"
"@sp 1"
"would create an @code{password} attribute for each @code{password} element "
"found in the document. The attribute value will be empty but still exist."
"\n"
"When the @option{--inquire} option is passed then all remaining non-option "
"arguments are retrieved via a server @emph{INQUIRE}."
"\n"
"See @url{http://www.w3schools.com/xpath/xpath_syntax.asp} for @abbr{XPATH} "
"expression syntax."
));

    new_command("IMPORT", 0, 1, 0, import_command, _(
"IMPORT [--root=[!]element[<TAB>[!]child[..]]] <content>\n"
"This command uses a server @emph{INQUIRE} to retrieve data from the client."
"\n"
"Like the @code{STORE} command (@pxref{STORE}), but the @var{content} "
"argument is raw @abbr{XML} data. The content is created as a child of "
"the element path specified with the @option{--root} option or at the "
"document root when not specified. Existing elements of the same name will "
"be overwritten."
"\n"
"The content must begin with an @abbr{XML} element node. @xref{Introduction}, "
"for details."
));

    new_command("DUMP", 0, 1, 0, dump_command, _(
"DUMP\n"
"Shows the in memory @abbr{XML} document with indenting. @xref{XPATH}, for "
"dumping a specific node."
));

    new_command("LOCK", 0, 0, 0, lock_command, _(
"LOCK\n"
"Locks the mutex associated with the opened file. This prevents other clients "
"from sending commands to the same opened file until the client "
"that sent this command either disconnects or sends the @code{UNLOCK} "
"command. @xref{UNLOCK}."
));

    new_command("UNLOCK", 1, 0, 0, unlock_command, _(
"UNLOCK\n"
"Unlocks the file mutex which was locked with the @code{LOCK} command or "
"a commands' @option{--lock} option (@pxref{LOCK}, @pxref{OPEN}, "
"@pxref{ISCACHED})."
));

    new_command("GETCONFIG", 1, 1, FLOCK_TYPE_SH|FLOCK_TYPE_KEEP, getconfig_command, _(
"GETCONFIG [filename] <parameter>\n"
"Returns the value of a @command{pwmd} configuration @var{parameter} with a "
"data response. If no file has been opened then the value for @var{filename} "
"or the default from the @samp{global} section will be returned. If a file "
"has been opened and no @var{filename} is specified, a value previously "
"set with the @code{OPTION} command (@pxref{OPTION}) will be returned."
));

    new_command("OPTION", 1, 1, 0, option_command, _(
"OPTION <NAME>=<VALUE>\n"
"Sets a client option @var{name} to @var{value}. The value for an option is "
"kept for the duration of the connection."
"\n"
"@table @asis\n"
"@item DISABLE-PINENTRY\n"
"Disable use of @command{pinentry} for passphrase retrieval. When set, a "
"server inquire is sent to the client to obtain the passphrase. This option "
"may be set as needed before the @code{OPEN} (@pxref{OPEN}), @code{PASSWD} "
"(@pxref{PASSWD}) and @code{SAVE} (@pxref{SAVE}) commands."
"\n"
"@item PINENTRY-TIMEOUT\n"
"Sets the number of seconds before a pinentry prompt will return an error "
"while waiting for user input."
"\n"
"@item TTYNAME\n"
"Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
"\n"
"@item TTYTYPE\n"
"Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
"\n"
"@item DISPLAY\n"
"Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
"\n"
"@item PINENTRY-DESC\n"
"Sets the description string of the @command{gpg-agent} and @command{pinentry} dialog."
"\n"
"@item PINENTRY-TITLE\n"
"Sets the title string of the @command{gpg-agent} and @command{pinentry} dialog."
"\n"
"@item PINENTRY-PROMPT\n"
"Sets the prompt string of the @command{gpg-agent} and @command{pinentry} dialog."
"\n"
"@item LC-CTYPE\n"
"Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
"\n"
"@item LC-MESSAGES\n"
"Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
"\n"
"@item NAME\n"
"Associates the thread ID of the connection with the specified textual "
"representation. Useful for debugging log messages. May not contain whitespace."
"\n"
"@item LOCK-TIMEOUT\n"
"When not @code{0}, the duration in tenths of a second to wait for the file "
"mutex which has been locked by another thread to be released before returning "
"an error. When @code{-1}, then an error will be returned immediately."
"@end table\n"
));

    new_command("LS", 1, 1, 0, ls_command, _(
"LS\n"
"Lists the available data files stored in the data directory "
"(@file{~/.pwmd/data}). The result is a newline separated list of filenames."
));

    new_command("RESET", 1, 1, 0, NULL, _(
"RESET\n"
"Closes the currently opened file but keeps any previously set client options."
));

    new_command("NOP", 1, 1, 0, NULL, _(
"NOP\n"
"Does nothing. Always returns successfully."
));

  /* !END-HELP-TEXT! */
  new_command ("CANCEL", 1, 1, 0, NULL, NULL);
  new_command ("END", 1, 1, 0, NULL, NULL);
  new_command ("BYE", 1, 1, 0, NULL, NULL);

  int i;
  for (i = 0; command_table[i]; i++);
  qsort (command_table, i - 1, sizeof (struct command_table_s *),
         sort_commands);
}

gpg_error_t
register_commands (assuan_context_t ctx)
{
  int i = 0, rc;

  for (; command_table[i]; i++)
    {
      if (!command_table[i]->handler)
        continue;

      rc = assuan_register_command (ctx, command_table[i]->name,
                                    command_table[i]->handler,
                                    command_table[i]->help);
      if (rc)
        return rc;
    }

  rc = assuan_register_bye_notify (ctx, bye_notify);
  if (rc)
    return rc;

  rc = assuan_register_reset_notify (ctx, reset_notify);
  if (rc)
    return rc;

  rc = assuan_register_pre_cmd_notify (ctx, command_startup);
  if (rc)
    return rc;

  return assuan_register_post_cmd_notify (ctx, command_finalize);
}