Fixed --import.

[pwmd.git] / src / commands.c

/* vim:tw=78:ts=8:sw=4:set ft=c:  */
/*
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012
    Ben Kibbey <bjk@luxsci.net>

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

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

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02110-1301  USA
*/
#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 <glib.h>
#include <glib/gstdio.h>
#include <gcrypt.h>
#include <zlib.h>
#include <dirent.h>

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

#include "mem.h"
#include "xml.h"
#include "common.h"

#ifdef WITH_PINENTRY
#include "pinentry.h"
#endif

#include "pwmd_error.h"
#include "cache.h"
#include "misc.h"
#include "commands.h"
#include "mutex.h"
#include "rcfile.h"

struct gz_s {
    z_stream z;
    gpointer out;
    gboolean done;
    status_msg_t which;
};

struct command_table_s {
    const gchar *name;
    gint (*handler)(assuan_context_t, gchar *line);
    const gchar *help;
    gboolean ignore_startup;
};

static struct command_table_s **command_table;
static guchar crypto_magic[5] = "\177PWMD";

static gpg_error_t do_lock_command(struct client_s *client);

static void *z_alloc(void *data, unsigned items, unsigned size)
{
    return gcry_calloc(items, size);
}

static void z_free(void *data, void *p)
{
    gcry_free(p);
}

static gpg_error_t file_modified(struct client_s *client)
{
    struct stat st;
    gpg_error_t rc;

    if (client->state != STATE_OPEN)
        return EPWMD_NO_FILE;

    rc = lock_file_mutex(client);

    if (rc)
        return rc;

    if (g_lstat(client->filename, &st) == 0 && client->mtime) {
        if (client->mtime != st.st_mtime)
            return EPWMD_FILE_MODIFIED;
    }

    pth_cancel_point();
    return 0;
}

static gpg_error_t parse_xml(assuan_context_t ctx)
{
    struct client_s *client = assuan_get_pointer(ctx);

    client->doc = xmlReadMemory(client->xml, client->len, NULL, "UTF-8", XML_PARSE_NOBLANKS);

    if (!client->doc)
        return EPWMD_LIBXML_ERROR;

    if (!client->crypto->fh || client->crypto->fh->ver.fh2.version >= 0x212)
        return 0;

    return convert_elements(client->doc);
}

void unlock_file_mutex(struct client_s *client)
{
    pth_mutex_t *m;

    if (client->has_lock == FALSE)
        return;

    CACHE_LOCK(client->ctx);

    if (cache_get_mutex(client->md5file, &m) == FALSE) {
        CACHE_UNLOCK;
        return;
    }

    CACHE_UNLOCK;
    MUTEX_UNLOCK(m);
    client->has_lock = client->is_lock_cmd = FALSE;
}

gpg_error_t lock_file_mutex(struct client_s *client)
{
    pth_mutex_t *m;
    gpg_error_t rc = 0;

    if (client->has_lock == TRUE)
        return 0;

    CACHE_LOCK(client->ctx);

    if (cache_get_mutex(client->md5file, &m) == FALSE) {
        CACHE_UNLOCK;
        return 0;
    }

    CACHE_UNLOCK;

    if (client->rc_on_locked) {
        if (!pth_mutex_acquire(m, TRUE, NULL))
            return GPG_ERR_LOCKED;
#ifdef MUTEX_DEBUG
        MUTEX_LOCK_DEBUG(m);
#endif
    }
    else
        MUTEX_TRYLOCK(client, m, rc);

    if (!rc)
        client->has_lock = TRUE;

    return rc;
}

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

    if (client->xml)
        gcry_free(client->xml);

    if (client->filename)
        g_free(client->filename);

    if (client->crypto)
        cleanup_crypto(&client->crypto);

    if (client->xml_error)
        xmlResetError(client->xml_error);
}

void cleanup_client(struct client_s *client)
{
    assuan_context_t ctx = client->ctx;
    struct client_thread_s *thd = client->thd;
    gboolean rc_on_locked = client->rc_on_locked;
    gboolean lock_on_open = client->lock_on_open;
#ifdef WITH_PINENTRY
    struct pinentry_s *pin = client->pinentry;
#endif

    unlock_file_mutex(client);
    CACHE_LOCK(client->ctx);
    cache_decr_refcount(client->md5file);

    /*
     * This may be a new file so don't use a cache slot. save_command() will
     * set this to FALSE on success.
     */
    if (client->new == TRUE)
        cache_clear(client->md5file, 1);

    CACHE_UNLOCK;
    free_client(client);
    memset(client, 0, sizeof(struct client_s));
    client->state = STATE_CONNECTED;
    client->ctx = ctx;
    client->thd = thd;
    client->freed = TRUE;
#ifdef WITH_PINENTRY
    client->pinentry = pin;
#endif
    client->rc_on_locked = rc_on_locked;
    client->lock_on_open = lock_on_open;
}

static void gz_cleanup(void *arg)
{
    struct gz_s **gz = (struct gz_s **)arg;

    if (!gz)
        return;

    if (!(*gz)->done && (*gz)->out)
        gcry_free((*gz)->out);

    if ((*gz)->which == STATUS_COMPRESS) {
        if ((*gz)->z.zalloc)
            deflateEnd(&(*gz)->z);
    }
    else {
        if ((*gz)->z.zalloc)
            inflateEnd(&(*gz)->z);
    }

    g_free(*gz);
    *gz = NULL;
}

gpg_error_t do_decompress(assuan_context_t ctx, gpointer in, gulong insize,
        gpointer *out, gulong *outsize)
{
    struct gz_s *gz;
    gz_header h;
    gchar buf[17];
    gpg_error_t rc;
    gint zrc;

    gz = g_malloc0(sizeof(struct gz_s));

    if (!gz)
        return GPG_ERR_ENOMEM;

    pth_cleanup_push(gz_cleanup, &gz);
    gz->which = STATUS_DECOMPRESS;
    gz->z.zalloc = z_alloc;
    gz->z.zfree = z_free;
    gz->z.next_in = in;
    gz->z.avail_in = (uInt)insize;
    gz->z.avail_out = zlib_bufsize;
    gz->z.next_out = gz->out = gcry_malloc(zlib_bufsize);

    if (!gz->out) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        pth_cleanup_pop(1);
        return GPG_ERR_ENOMEM;
    }

    zrc = inflateInit2(&gz->z, 47);

    if (zrc != Z_OK) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
        pth_cleanup_pop(1);
        return zrc == Z_MEM_ERROR ? GPG_ERR_ENOMEM : GPG_ERR_COMPR_ALGO;
    }

    memset(&h, 0, sizeof(gz_header));
    h.comment = (guchar *)buf;
    h.comm_max = sizeof(buf);
    zrc = inflateGetHeader(&gz->z, &h);

    if (zrc != Z_OK) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
        pth_cleanup_pop(1);
        return zrc == Z_MEM_ERROR ? GPG_ERR_ENOMEM : GPG_ERR_COMPR_ALGO;
    }

    zrc = inflate(&gz->z, Z_BLOCK);

    if (zrc != Z_OK) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
        pth_cleanup_pop(1);
        return zrc == Z_MEM_ERROR ? GPG_ERR_ENOMEM : GPG_ERR_COMPR_ALGO;
    }

    if (h.comment)
        insize = strtoul((gchar *)h.comment, NULL, 10);

    do {
        gpointer p;

        zrc = inflate(&gz->z, Z_FINISH);

        switch (zrc) {
            case Z_OK:
                break;
            case Z_BUF_ERROR:
                if (!gz->z.avail_out) {
                    p = gcry_realloc(gz->out, gz->z.total_out + zlib_bufsize);

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

                    gz->out = p;
                    gz->z.next_out = (guchar *)gz->out + gz->z.total_out;
                    gz->z.avail_out = zlib_bufsize;
                    rc = send_status(ctx, STATUS_DECOMPRESS, "%li %li",
                            gz->z.total_out, insize);

                    if (rc)
                        goto fail;
                }
                break;
            case Z_STREAM_END:
                break;
            default:
                log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
                rc = GPG_ERR_COMPR_ALGO;
                goto fail;
                break;
        }
    } while (zrc != Z_STREAM_END);

    rc = send_status(ctx, STATUS_DECOMPRESS, "%li %li", gz->z.total_out,
            insize);

    if (rc)
        goto fail;

    *out = gz->out;
    *outsize = gz->z.total_out;
    gz->done = TRUE;
    pth_cleanup_pop(1);
    return 0;

fail:
    pth_cleanup_pop(1);
    return rc;
}

file_header_internal_t *read_file_header(const gchar *filename, gboolean v1,
        gpg_error_t *rc)
{
    gint fd;
    gsize len;
    file_header_internal_t *fh = g_malloc0(sizeof(file_header_internal_t));
    gsize fh_size;
    gpointer p;

    *rc = 0;

    if (!fh) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        *rc = GPG_ERR_ENOMEM;
        return NULL;
    }

    pth_cleanup_push(g_free, fh);
    fh_size = v1 ? sizeof(fh->ver.fh1) : sizeof(fh->ver.fh2)-8; // salt

    if (g_lstat(filename, &fh->st) == -1) {
        *rc = gpg_error_from_syserror();
        pth_cleanup_pop(1);
        return NULL;
    }

    if (!S_ISREG(fh->st.st_mode)) {
        *rc = GPG_ERR_ENOANO;
        pth_cleanup_pop(1);
        return NULL;
    }

    fd = open(filename, O_RDONLY);

    if (fd == -1) {
        *rc = gpg_error_from_syserror();
        pth_cleanup_pop(1);
        return NULL;
    }

    pth_cleanup_push(cleanup_fd_cb, &fd);
    p = v1 ? (void *)&fh->ver.fh1 : (void *)&fh->ver.fh2;
    len = pth_read(fd, p, fh_size);

    if (len != fh_size) {
        *rc = gpg_error_from_syserror();
        pth_cleanup_pop(1);
        pth_cleanup_pop(1);
        return NULL;
    }

    if (!v1) {
        if (fh->ver.fh2.version >= 0x221) {
            len = pth_read(fd, fh->ver.fh2.salt, sizeof(fh->ver.fh2.salt));
            if (len != sizeof(fh->ver.fh2.salt)) {
                *rc = gpg_error_from_syserror();
                pth_cleanup_pop(1);
                pth_cleanup_pop(1);
                return NULL;
            }
        }
    }

    fh->v1 = v1;
    fh->fd = fd;
    pth_cleanup_pop(0);
    pth_cleanup_pop(0);
    return fh;
}

gpg_error_t hash_key(struct crypto_s *crypto, const guchar *key,
        gsize keylen, gboolean kdf)
{
    gpg_error_t rc = 0;

    if (crypto->key != key) {
        gcry_free(crypto->key);
        crypto->key = gcry_malloc(KEYSIZE);
        if (!crypto->key)
            return GPG_ERR_ENOMEM;
    }

    if (!kdf && crypto->fh->ver.fh2.version < 0x221) {
        gcry_md_hash_buffer(GCRY_MD_SHA256, crypto->key, key, keylen);
    }
    else {
        rc = gcry_kdf_derive(key, keylen, GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
                crypto->fh->ver.fh2.salt, 8, 1000, KEYSIZE, crypto->key);
    }

    return rc;
}

static gpg_error_t open_command_finalize(assuan_context_t ctx, guchar *key,
        gsize len, gboolean cached)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;
    gint timeout;

    if (!client->new && len) {
        rc = hash_key(client->crypto, key, len, FALSE);
        if (rc)
            return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

    /* New file. */
    if (!client->crypto->fh) {
        guchar *tkey = client->crypto->key;

        for (gsize i = 0; i < client->crypto->keysize; i++) {
            if (tkey[i])
                goto update_cache;
        }

        goto done;
    }

    rc = init_client_crypto2(client->filename, client->crypto);

    if (rc) {
        cleanup_client(client);
        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

    rc = try_xml_decrypt(ctx, client->crypto, NULL, NULL);

    if (rc) {
        cleanup_client(client);
        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

update_cache:
    key = client->crypto->key;
    CACHE_LOCK(client->ctx);

    if (cached == FALSE) {
        if (cache_update_key(client->md5file, key) == FALSE) {
            cleanup_client(client);
            CACHE_UNLOCK;
            return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
        }

        timeout = get_key_file_integer(client->filename, "cache_timeout");
        cache_reset_timeout(client->md5file, timeout);
    }
    else
        cache_set_timeout(client->md5file, -2);

    CACHE_UNLOCK;

done:
    rc = parse_xml(ctx);

    if (client->xml) {
        gcry_free(client->xml);
        client->xml = NULL;
    }

    if (!rc) {
        if (client->new == FALSE)
            send_status_all(STATUS_CACHE);

        client->state = STATE_OPEN;
    }

    if (!rc && client->new == FALSE &&
            client->crypto->fh->ver.fh2.iter != get_key_file_uint64(client->filename, "iterations")) {
        gchar *s = g_strdup_printf("%llu", (unsigned long long)client->crypto->fh->ver.fh2.iter);

        MUTEX_LOCK(&rcfile_mutex);
        g_key_file_set_value(keyfileh, client->filename, "iterations", s);
        g_free(s);
        MUTEX_UNLOCK(&rcfile_mutex);
        send_status_all(STATUS_CONFIG);
    }

    if (!rc && !client->new && client->crypto->fh->ver.fh2.version < 0x221)
        client->rehash = TRUE; // For SAVE

    cleanup_crypto(&client->crypto);

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

    if (!rc && client->lock_on_open)
        return do_lock_command(client);

    return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
}

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

    g_strfreev((gchar **)arg);
}

static gpg_error_t parse_open_opt_lock(gpointer data, gpointer value)
{
    struct client_s *client = data;
    const gchar *p = value;

    if (p && *p) {
        gint n = atoi(p);

        if (n < 0 || n > 1)
            return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);

        client->lock_on_open = n ? TRUE : FALSE;
    }
    else if ((!p || !*p) && (client->opts & OPT_LOCK))
        client->lock_on_open = FALSE;
    else
        client->lock_on_open = TRUE;

    return 0;
}

static gpg_error_t parse_opt_pinentry(gpointer data, gpointer value)
{
#ifdef WITH_PINENTRY
    struct client_s *client = data;
    gchar *str = value;
    gint n;

    if (!str || !*str) {
        client->pinentry->enable = -1;
        client->opts &= ~(OPT_PINENTRY);
        return 0;
    }

    n = atoi(str);

    if (n < 0 || n > 1)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);

    client->pinentry->enable = n ? TRUE : FALSE;
    client->opts |= OPT_PINENTRY;
    return 0;
#else
    return GPG_ERR_NOT_IMPLEMENTED;
#endif
}

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

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

static gpg_error_t open_command_common(assuan_context_t ctx, gchar *line)
{
    gboolean cached = FALSE;
    gpg_error_t rc;
    struct client_s *client = assuan_get_pointer(ctx);
    gchar **req;
    gchar *filename = NULL;

    if ((req = split_input_line(line, " ", 2)) != NULL)
        filename = req[0];

    pth_cleanup_push(req_cleanup, req);

    if (!filename || !*filename) {
        pth_cleanup_pop(1);
        return client->opts & OPT_INQUIRE ? GPG_ERR_SYNTAX : send_error(ctx, GPG_ERR_SYNTAX);
    }

    log_write2("ARGS=\"%s\" %s", filename, req[1] ? "<passphrase>" : "");

    if (valid_filename(filename) == FALSE) {
        pth_cleanup_pop(1);
        return client->opts & OPT_INQUIRE ? GPG_ERR_INV_VALUE : send_error(ctx, GPG_ERR_INV_VALUE);
    }

    gcry_md_hash_buffer(GCRY_MD_MD5, client->md5file, filename, strlen(filename));
    CACHE_LOCK(client->ctx);

    if (cache_has_file(client->md5file) == FALSE) {
        if (cache_add_file(client->md5file, NULL) == FALSE) {
            pth_cleanup_pop(1);
            CACHE_UNLOCK;
            return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
        }
    }

    CACHE_UNLOCK;
    rc = lock_file_mutex(client);

    if (rc) {
        pth_cleanup_pop(1);
        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

    client->freed = FALSE;
    CACHE_LOCK(client->ctx);
    cache_incr_refcount(client->md5file);
    CACHE_UNLOCK;
    client->crypto = init_client_crypto();

    if (!client->crypto) {
        pth_cleanup_pop(1);
        cleanup_client(client);
        return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
    }

    client->crypto->key = gcry_malloc(KEYSIZE);

    if (!client->crypto->key) {
        pth_cleanup_pop(1);
        log_write("%s(%i): %s", __FUNCTION__, __LINE__,
                GPG_ERR_ENOMEM);
        cleanup_client(client);
        return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
    }

    memset(client->crypto->key, 0, KEYSIZE);
    client->crypto->fh = read_file_header(filename, FALSE, &rc);

    if (!client->crypto->fh) {
        if (gpg_err_code_to_errno(rc) != ENOENT) {
            log_write("%s: %s", filename, pwmd_strerror(rc));
            pth_cleanup_pop(1);
            cleanup_client(client);
            return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
        }

        /*
         * New files don't need a key.
         */
        if ((client->xml = new_document()) == NULL) {
            log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
            pth_cleanup_pop(1);
            cleanup_client(client);
            return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
        }

        client->len = xmlStrlen(client->xml);
        client->new = TRUE;
        client->filename = g_strdup(filename);

        if (!client->filename) {
            pth_cleanup_pop(1);
            cleanup_client(client);
            log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
            return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
        }

        pth_cleanup_pop(1);
#ifdef WITH_PINENTRY
        client->pinentry->filename = g_strdup(client->filename);

        if (!client->pinentry->filename) {
            log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
            cleanup_client(client);
            return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
        }
#endif
        return open_command_finalize(ctx, (guchar *)req[1],
                req[1] ? strlen(req[1]) : 0, cached);
    }
    else {
        if (!(client->opts & OPT_CIPHER))
            g_key_file_set_string(keyfileh, filename, "cipher",
                    pwmd_cipher_to_str(client->crypto->fh->ver.fh2.flags));

        client->mtime = client->crypto->fh->st.st_mtime;
    }

    client->filename = g_strdup(filename);

    if (!client->filename) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        pth_cleanup_pop(1);
        cleanup_client(client);
        return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
    }

#ifdef WITH_PINENTRY
    if (client->pinentry->filename)
        g_free(client->pinentry->filename);

    client->pinentry->filename = g_strdup(client->filename);

    if (!client->pinentry->filename) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        pth_cleanup_pop(1);
        cleanup_client(client);
        return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
    }
#endif

    if (client->crypto->fh->ver.fh2.iter <= 0ULL) {
        goto done;
    }

    CACHE_LOCK(client->ctx);
    cached = cache_get_key(client->md5file, client->crypto->key);
    CACHE_UNLOCK;

    if (cached == FALSE) {
        gchar *tmp = get_key_file_string(filename, "key_file");

        if (tmp && !(client->opts & OPT_INQUIRE)) {
            g_free(tmp);
            pth_cleanup_pop(1);
            cleanup_client(client);
            return send_error(ctx, GPG_ERR_WRONG_KEY_USAGE);
        }

        if (tmp)
            g_free(tmp);

        /*
         * No key specified and no matching filename found in the cache. Use
         * pinentry to retrieve the key. Cannot return assuan_process_done()
         * here otherwise the command will be interrupted. The event loop in
         * client_thread() will poll the file descriptor waiting for it to
         * become ready to read a pinentry_key_s which will contain the
         * entered key or an error code. It will then call
         * open_command_finalize() to to finish the command.
         */
        if (!req[1] || !*req[1]) {
#ifdef WITH_PINENTRY
            gboolean b = get_key_file_boolean(filename, "enable_pinentry");

            /* From set_pinentry_defaults(). */
            if (client->opts & OPT_INQUIRE ||
                    client->pinentry->enable == FALSE ||
                    (client->pinentry->enable == -1 && b == FALSE)) {
                rc = hash_key(client->crypto, (guchar *)"", 1, FALSE);
                if (rc) {
                    cleanup_client(client);
                    return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
                }

                goto done;
            }

            pth_cleanup_pop(1);
            // To set the keysize.
            rc = init_client_crypto2(filename, client->crypto);
            if (rc) {
                cleanup_client(client);
                return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
            }

            rc = lock_pin_mutex(client);
            if (rc) {
                unlock_pin_mutex(client->pinentry);
                cleanup_client(client);
                return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
            }

            client->pinentry->which = PINENTRY_OPEN;
            rc = pinentry_fork(ctx);

            if (rc) {
                unlock_pin_mutex(client->pinentry);
                cleanup_client(client);
                return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
            }

            // Called from pinentry iterate.
            client->pinentry->cb = open_command_finalize;
            client->pinentry->status = PINENTRY_INIT;
            return 0;
#else
            rc = hash_key(client->crypto, "" , 1, FALSE);
            if (rc) {
                cleanup_client(client);
                return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
            }

            goto done;
#endif
        }

        rc = hash_key(client->crypto, (guchar *)req[1], strlen(req[1]), FALSE);

        if (rc) {
            pth_cleanup_pop(1);
            cleanup_client(client);
            return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
        }
    }
    else if (req && req[1] && *req[1]) {
        rc = hash_key(client->crypto, (guchar *)req[1], strlen(req[1]), FALSE);

        if (rc) {
            pth_cleanup_pop(1);
            cleanup_client(client);
            return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
        }
    }

done:
    pth_cleanup_pop(1);
    return open_command_finalize(ctx, (guchar *)req[1],
            req[1] ? strlen(req[1]) : 0, cached);
}

static gint open_command_inquire_finalize(gpointer data, gint assuan_rc,
        guchar *line, gsize len)
{
    assuan_context_t ctx = data;
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc = file_modified(client);
    guchar *p = line;
    gint i = 0;

    if (assuan_rc || (rc && rc != EPWMD_NO_FILE)) {
        if (line)
            xfree(line);

        return assuan_rc ? assuan_rc : rc;
    }

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

    if (*p && i != len) {
        p = line+i+2;
        len -= i+2;
        has_null_byte(NULL, p, len);
    }

    rc = open_command_common(ctx, (gchar *)line);

    if (line)
        xfree(line);

    client->inquire_status = INQUIRE_DONE;
    return rc;
}

static gint open_command(assuan_context_t ctx, gchar *line)
{
    gpg_error_t rc;
    struct client_s *client = assuan_get_pointer(ctx);
    struct argv_s *args[] = {
        &(struct argv_s) { "lock", OPTION_TYPE_NOARG, parse_open_opt_lock },
        &(struct argv_s) { "pinentry", OPTION_TYPE_OPTARG, parse_opt_pinentry },
        &(struct argv_s) { "inquire", OPTION_TYPE_NOARG, parse_opt_inquire },
        NULL
    };

    if (client->state == STATE_OPEN)
        cleanup_client(client);

    if (!(client->opts & OPT_LOCK))
        client->lock_on_open = FALSE;

    rc = parse_options(&line, args, client);

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

    if ((client->opts & OPT_INQUIRE)) {
        rc = assuan_inquire_ext(ctx, "OPEN", 0, open_command_inquire_finalize,
                ctx);

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

        /* Don't return with assuan_process_done() here. This is an INQUIRE. */
        client->inquire_status = INQUIRE_BUSY;
        return 0;
    }

    return open_command_common(ctx, line);
}

gpg_error_t do_compress(assuan_context_t ctx, gint level, gpointer data,
        guint size, gpointer *out, gulong *outsize)
{
    struct gz_s *gz;
    gz_header h;
    gchar buf[17];
    gint cmd = Z_NO_FLUSH;
    gint zrc;
    gpg_error_t rc;

    gz = g_malloc0(sizeof(struct gz_s));

    if (!gz)
        return GPG_ERR_ENOMEM;

    pth_cleanup_push(gz_cleanup, &gz);
    gz->which = STATUS_COMPRESS;
    gz->z.zalloc = z_alloc;
    gz->z.zfree = z_free;
    gz->z.next_in = data;
    gz->z.avail_in = size < zlib_bufsize ? (uInt)size : (uInt)zlib_bufsize;
    gz->z.avail_out = (uInt)zlib_bufsize;
    gz->z.next_out = gz->out = gcry_malloc(zlib_bufsize);

    if (!gz->out) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        pth_cleanup_pop(1);
        return GPG_ERR_ENOMEM;
    }

    zrc = deflateInit2(&gz->z, level, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY);

    if (zrc != Z_OK) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
        pth_cleanup_pop(1);
        return GPG_ERR_COMPR_ALGO;
    }

    /* Rather than store the size of the uncompressed data in the file header,
     * store it in the comment field of the gzip header. Don't give anyone too
     * much information. Not sure why really, but it seems the right way. :)
     */
    memset(&h, 0, sizeof(gz_header));
    g_snprintf(buf, sizeof(buf), "%u", size);
    h.comment = (guchar *)buf;
    zrc = deflateSetHeader(&gz->z, &h);

    if (zrc != Z_OK) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
        pth_cleanup_pop(1);
        return GPG_ERR_COMPR_ALGO;
    }

    do {
        gpointer p;

        zrc = deflate(&gz->z, cmd);

        switch (zrc) {
            case Z_OK:
                break;
            case Z_BUF_ERROR:
                if (!gz->z.avail_out) {
                    p = gcry_realloc(gz->out, gz->z.total_out + zlib_bufsize);

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

                    gz->out = p;
                    gz->z.next_out = (guchar *)gz->out + gz->z.total_out;
                    gz->z.avail_out = zlib_bufsize;
                }

                if (!gz->z.avail_in && gz->z.total_in < size) {
                    if (gz->z.total_in + zlib_bufsize > size)
                        gz->z.avail_in = size - gz->z.total_in;
                    else
                        gz->z.avail_in = zlib_bufsize;

                    rc = send_status(ctx, STATUS_COMPRESS, "%li %u",
                            gz->z.total_in, size);

                    if (rc)
                        goto fail;
                }

                if (gz->z.total_in >= size)
                    cmd = Z_FINISH;

                break;
            case Z_STREAM_END:
                break;
            default:
                log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
                rc = GPG_ERR_COMPR_ALGO;
                goto fail;
        }
    } while (zrc != Z_STREAM_END);

    rc = send_status(ctx, STATUS_COMPRESS, "%li %u", gz->z.total_in, size);

    if (rc)
        goto fail;

    *out = gz->out;
    *outsize = gz->z.total_out;
    gz->done = TRUE;
    pth_cleanup_pop(1);
    return 0;

fail:
    pth_cleanup_pop(1);
    return rc;
}

#define CRYPTO_BLOCKSIZE(c) (c->blocksize * 1024)

/*
 * Useful for a large amount of data. Rather than doing all of the data in one
 * iteration do it in chunks.  This lets the command be cancelable rather than
 * waiting for it to complete.
 */
static gpg_error_t iterate_crypto_once(struct client_s *client,
        struct crypto_s *crypto, status_msg_t which)
{
    gpg_error_t rc = 0;
    goffset len = CRYPTO_BLOCKSIZE(crypto);
    gpointer p = gcry_malloc(len);
    goffset total = 0;
    gpointer inbuf;

    if (!p)
        return GPG_ERR_ENOMEM;

    if (crypto->insize < CRYPTO_BLOCKSIZE(crypto))
        len = crypto->insize;

    pth_cleanup_push(gcry_free, p);

    for (;;) {
        inbuf = (guchar *)crypto->inbuf + total;
        guchar *tmp;

        if (len + total > crypto->insize)
            len = crypto->blocksize;

        if (which == STATUS_ENCRYPT)
            rc = gcry_cipher_encrypt(crypto->gh, p, len, inbuf, len);
        else
            rc = gcry_cipher_decrypt(crypto->gh, p, len, inbuf, len);
        
        if (rc)
            goto done;

        tmp = (guchar *)crypto->inbuf + total;
        memmove(tmp, p, len);
        total += len;

        if (total >= crypto->insize)
            break;

        pth_cancel_point();
    }

done:
    pth_cleanup_pop(1);
    return rc;
}

/* The crypto struct must be setup for iterations and .key. */
gpg_error_t do_xml_encrypt(struct client_s *client,
        struct crypto_s *crypto, const gchar *filename)
{
    goffset len = crypto->insize;
    gpointer inbuf;
    gchar *p;
    gpg_error_t rc;
    guint64 iter_progress = 0, n_iter = 0, xiter = 0;
    gchar tmp[FILENAME_MAX];
    struct stat st;
    mode_t mode = 0;

    if (!crypto->fh->ver.fh2.iter) {
        /*
         * cache_file_count() needs both .used == TRUE and a valid key in
         * order for it to count as a used cache entry. Fixes CACHE status
         * messages.
         */
        memset(crypto->key, '!', KEYSIZE);
        goto write_file;
    }

    /*
     * Resize the existing xml buffer to the block size required by gcrypt
     * rather than duplicating it and wasting memory.
     */
    crypto->insize += sizeof(crypto_magic);
    len = (crypto->insize / crypto->blocksize) * crypto->blocksize;

    if (crypto->insize % crypto->blocksize)
        len += crypto->blocksize;

    inbuf = gcry_realloc(crypto->inbuf, len);

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

    guchar *tmpbuf = inbuf;
    memmove(&tmpbuf[sizeof(crypto_magic)], tmpbuf, len-sizeof(crypto_magic));
    memcpy(tmpbuf, crypto_magic, sizeof(crypto_magic));
    crypto->inbuf = tmpbuf;
    crypto->insize = len;
    gcry_create_nonce(crypto->fh->ver.fh2.iv, crypto->blocksize);

    if (crypto->tkey)
        gcry_free(crypto->tkey);

    crypto->tkey = gcry_malloc(KEYSIZE);

    if (!crypto->tkey) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        return GPG_ERR_ENOMEM;
    }

    memcpy(crypto->tkey, crypto->key, KEYSIZE);
    guchar *tkey = crypto->tkey;
    tkey[0] ^= 1;

    if ((rc = gcry_cipher_setkey(crypto->gh, crypto->tkey, crypto->keysize))) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    iter_progress = get_key_file_uint64(
            client ? client->filename : "global", "iteration_progress");

    if (iter_progress && crypto->fh->ver.fh2.iter >= iter_progress) {
        rc = send_status(client ? client->ctx : NULL, STATUS_ENCRYPT,
                "0 %llu", crypto->fh->ver.fh2.iter);

        if (rc)
            return rc;
    }

    while (xiter < crypto->fh->ver.fh2.iter-1) {
        if (iter_progress > 0ULL && xiter >= iter_progress) {
            if (!(xiter % iter_progress)) {
                rc = send_status(client ? client->ctx : NULL, STATUS_ENCRYPT,
                        "%llu %llu", ++n_iter * iter_progress,
                        crypto->fh->ver.fh2.iter);

                if (rc)
                    return rc;
            }
        }

        if ((rc = gcry_cipher_setiv(crypto->gh, crypto->fh->ver.fh2.iv,
                        crypto->blocksize))) {
            log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
            return rc;
        }

        rc = iterate_crypto_once(client, crypto, STATUS_ENCRYPT);

        if (rc) {
            log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
            return rc;
        }

        xiter++;
    }

    if ((rc = gcry_cipher_setiv(crypto->gh, crypto->fh->ver.fh2.iv,
                crypto->blocksize))) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    if ((rc = gcry_cipher_setkey(crypto->gh, crypto->key, crypto->keysize))) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    rc = iterate_crypto_once(client, crypto, STATUS_ENCRYPT);

    if (rc)
        return rc;

    if (iter_progress && crypto->fh->ver.fh2.iter >= iter_progress) {
        rc = send_status(client ? client->ctx : NULL, STATUS_ENCRYPT,
                "%llu %llu", crypto->fh->ver.fh2.iter, crypto->fh->ver.fh2.iter);

        if (rc)
            return rc;
    }

write_file:
    tmp[0] = 0;

    if (filename) {
        if (!client && !g_ascii_strcasecmp(filename, "-")) {
            crypto->fh->fd = STDOUT_FILENO;
            goto do_write_file;
        }

        if (g_lstat(filename, &st) == 0) {
            mode = st.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO);

            if (!(mode & S_IWUSR))
                return GPG_ERR_EACCES;
        }
        else if (errno != ENOENT)
            return gpg_error_from_syserror();

        g_snprintf(tmp, sizeof(tmp), "%s.XXXXXX", filename);
#if GLIB_CHECK_VERSION(2, 22, 0)
        crypto->fh->fd = g_mkstemp_full(tmp, O_WRONLY, 0600);
#else
        crypto->fh->fd = mkstemp(tmp);
#endif

        if (crypto->fh->fd == -1) {
            rc = gpg_error_from_syserror();
            p = strrchr(tmp, '/');
            p++;
            log_write("%s: %s", p, pwmd_strerror(rc));
            return rc;
        }

        pth_cleanup_push(cleanup_unlink_cb, tmp);
    }
    else
        /*
         * xml_import() or convert_file() from command line.
         */
        crypto->fh->fd = STDOUT_FILENO;

do_write_file:
    crypto->fh->ver.fh2.magic[0] = '\177';
    crypto->fh->ver.fh2.magic[1] = 'P';
    crypto->fh->ver.fh2.magic[2] = 'W';
    crypto->fh->ver.fh2.magic[3] = 'M';
    crypto->fh->ver.fh2.magic[4] = 'D';
    crypto->fh->ver.fh2.version = VERSION_HEX;
    len = pth_write(crypto->fh->fd, &crypto->fh->ver.fh2, sizeof(crypto->fh->ver.fh2));

    if (len != sizeof(crypto->fh->ver.fh2)) {
        rc = gpg_error_from_syserror();

        if (tmp[0])
            pth_cleanup_pop(1);

        return rc;
    }

    len = pth_write(crypto->fh->fd, crypto->inbuf, crypto->insize);

    if (len != crypto->insize) {
        rc = gpg_error_from_syserror();

        if (tmp[0])
            pth_cleanup_pop(1);

        return rc;
    }

    if (fsync(crypto->fh->fd) == -1) {
        rc = gpg_error_from_syserror();

        if (tmp[0])
            pth_cleanup_pop(1);

        return rc;
    }

    if (tmp[0]) {
#ifdef WITH_LIBACL
        acl_t acl;
#endif
        if (mode && get_key_file_boolean(filename, "backup") == TRUE) {
            gchar tmp2[FILENAME_MAX];

            g_snprintf(tmp2, sizeof(tmp2), "%s.backup", filename);
#ifdef WITH_LIBACL
            acl = acl_get_file(filename, ACL_TYPE_ACCESS);

            if (!acl)
                log_write("ACL: %s: %s", filename, pwmd_strerror(gpg_error_from_syserror()));
#endif

            if (rename(filename, tmp2) == -1) {
                rc = gpg_error_from_syserror();
                pth_cleanup_pop(1);
#ifdef WITH_LIBACL
                if (acl)
                    acl_free(acl);
#endif
                return rc;
            }
        }
#ifdef WITH_LIBACL
        else {
            acl = acl_get_file(".", ACL_TYPE_DEFAULT);

            if (!acl)
                log_write("ACL: %s: %s", filename, pwmd_strerror(gpg_error_from_syserror()));
        }
#endif

        if (rename(tmp, filename) == -1) {
            rc = gpg_error_from_syserror();
            pth_cleanup_pop(1);
#ifdef WITH_LIBACL
            if (acl)
                acl_free(acl);
#endif
            return rc;
        }

        pth_cleanup_pop(0);

        if (mode)
            chmod(filename, mode);

#ifdef WITH_LIBACL
        if (acl && acl_set_file(filename, ACL_TYPE_ACCESS, acl))
            log_write("ACL: %s: %s", filename, pwmd_strerror(gpg_error_from_syserror()));

        if (acl)
            acl_free(acl);
#endif

        /* Be sure the file entry has been written to disk. On FreeBSD I
         * noticed delays causing a following command to return
         * GPG_ERR_CHECKSUM. Recommended from fsync(2) (Linux).
         */
        DIR *dir;
        gchar *path;
        gchar *s = get_key_file_string("global", "data_directory");

        path = expand_homedir(s);
        g_free(s);
        dir = opendir(path);
        g_free(path);
        if (dir) {
            gint fd = dirfd(dir);
            if (fd != -1)
                fsync(fd);
            else
                rc = gpg_error_from_syserror();

            closedir(dir);
        }
        else
            rc = gpg_error_from_syserror();
    }

    if (client && g_lstat(filename, &st) == 0)
        client->mtime = st.st_mtime;

    return rc;
}

gpg_error_t update_save_flags(const gchar *filename,
        struct crypto_s *crypto)
{
    gpg_error_t rc;

    /* New file? */
    if (!crypto->fh) {
        crypto->fh = g_malloc0(sizeof(file_header_internal_t));
        
        if (!crypto->fh)
            return GPG_ERR_ENOMEM;
    }

    rc = init_client_crypto2(filename, crypto);

    if (rc)
        return rc;

    if (filename && !crypto->fh->v1)
        crypto->fh->ver.fh2.iter = get_key_file_uint64(filename, "iterations");

    return 0;
}

static gpg_error_t save_command_finalize(assuan_context_t ctx, guchar *key,
        gsize keylen, gboolean cached)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpointer xmlbuf;
    gulong outsize = 0;
    guint len;
    gint clevel;
    gint timeout;
    gpointer outbuf;
    gpg_error_t rc;

    rc = update_save_flags(client->filename, client->crypto);
    if (rc) {
        cleanup_crypto(&client->crypto);
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(rc));
        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

    if (keylen) {
        gcry_create_nonce(client->crypto->fh->ver.fh2.salt, 8);
        rc = hash_key(client->crypto, key, keylen, TRUE);
        if (rc) {
            cleanup_crypto(&client->crypto);
            return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
        }

        cached = FALSE;
    }

    rc = update_element_mtime(xmlDocGetRootElement(client->doc));

    if (rc) {
        cleanup_crypto(&client->crypto);
        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

    xmlDocDumpFormatMemory(client->doc, (xmlChar **)&xmlbuf, (gint *)&len, 0);
    pth_cleanup_push(xmlFree, xmlbuf);
    clevel = get_key_file_integer(client->filename, "compression_level");

    if (clevel < 0)
        clevel = 0;

    rc = do_compress(ctx, clevel, xmlbuf, len, &outbuf, &outsize);

    if (rc) {
        pth_cleanup_pop(1);
        cleanup_crypto(&client->crypto);

        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }
    else {
        pth_cleanup_pop(1);
        xmlbuf = outbuf;
        len = outsize;
    }

    client->crypto->inbuf = xmlbuf;
    client->crypto->insize = len;
    rc = do_xml_encrypt(client, client->crypto, client->filename);

    if (rc) {
        cleanup_crypto(&client->crypto);
        return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
    }

    timeout = get_key_file_integer(client->filename, "cache_timeout");
    CACHE_LOCK(client->ctx);

    if (cached) {
        cache_reset_timeout(client->md5file, timeout);
        CACHE_UNLOCK;

        if (client->new == TRUE)
            send_status_all(STATUS_CACHE);

        client->new = FALSE;
        cleanup_crypto(&client->crypto);
        return client->opts & OPT_INQUIRE ? 0 : send_error(ctx, 0);
    }

    if (cache_update_key(client->md5file, client->crypto->key) == FALSE) {
        CACHE_UNLOCK;
        cleanup_crypto(&client->crypto);
        return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
    }

    client->new = client->rehash = FALSE;
    cache_reset_timeout(client->md5file, timeout);
    CACHE_UNLOCK;
    send_status_all(STATUS_CACHE);
    cleanup_crypto(&client->crypto);
    return client->opts & OPT_INQUIRE ? 0 : send_error(ctx, 0);
}

static gpg_error_t parse_save_opt_iterations(gpointer data, gpointer v)
{
    struct client_s *client = data;
    guint64 n;
    gchar *value = v;
    gchar *p = NULL;

    if (!client->filename)
        return EPWMD_NO_FILE;

    if (!value || !*value)
        return 0;

    errno = 0;
    n = g_ascii_strtoull(value, &p, 10);

    if (errno || (p && *p) || n == G_MAXUINT64)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_ERANGE);

    MUTEX_LOCK(&rcfile_mutex);
    g_key_file_set_value(keyfileh,
            client->filename ? client->filename : "global", "iterations", value);
    MUTEX_UNLOCK(&rcfile_mutex);

    if (client->filename)
        client->opts |= OPT_ITERATIONS;

    return 0;
}

static gpg_error_t parse_save_opt_cipher(gpointer data, gpointer value)
{
    struct client_s *client = data;
    const gchar *p = value;
    guint64 flags;

    if (!client->filename)
        return EPWMD_NO_FILE;

    if (!p || !*p)
        return 0;

    flags = pwmd_cipher_str_to_cipher(p);

    if (!flags)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);

    MUTEX_LOCK(&rcfile_mutex);
    g_key_file_set_string(keyfileh, client->filename, "cipher", p);
    MUTEX_UNLOCK(&rcfile_mutex);

    if (!value)
        g_free((gchar *)p);

    return 0;
}

static gpg_error_t parse_save_opt_reset(gpointer data, gpointer value)
{
    struct client_s *client = data;

    CACHE_LOCK(client->ctx);
    cache_clear(client->md5file, 1);
    CACHE_UNLOCK;
    return 0;
}

static gpg_error_t save_command_common(assuan_context_t ctx, gchar *line,
        gsize len)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gboolean cached = FALSE;
    gpg_error_t rc;
    gboolean keyfile_rehash = FALSE;

    CACHE_LOCK(ctx);
    // Force rehashing the passphrase to update to the salted header.
    if (client->rehash)
        cache_clear(client->md5file, 1);

    cached = cache_iscached(client->md5file);
    CACHE_UNLOCK;

    /*
     * If a cache entry doesn't exist for this file and the file has a
     * "key_file" or "key" parameter, then it's an error. The reason is that
     * cache expiration would be useless. Unless this is an inquire, then its
     * fine.
     */
    if (cached == FALSE && !client->rehash) {
        gchar *tmp = get_key_file_string(client->filename, "key_file");

        if (tmp && !(client->opts & OPT_INQUIRE)) {
            g_free(tmp);
            return send_error(ctx, GPG_ERR_WRONG_KEY_USAGE);
        }

        g_free(tmp);
    }

    cached = FALSE;

    if (!client->crypto) {
        client->crypto = init_client_crypto();

        if (!client->crypto) {
            log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
            return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
        }

        if (!client->new) {
            client->crypto->fh = read_file_header(client->filename, FALSE, &rc);
            if (rc) {
                cleanup_crypto(&client->crypto);
                return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, rc);
            }
        }
    }

    client->crypto->key = gcry_malloc(KEYSIZE);

    if (!client->crypto->key) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        cleanup_crypto(&client->crypto);
        return client->opts & OPT_INQUIRE ? GPG_ERR_ENOMEM : send_error(ctx, GPG_ERR_ENOMEM);
    }

    memset(client->crypto->key, '!', KEYSIZE);

    if (!get_key_file_uint64(client->filename, "iterations") &&
            (!line || !*line))
        goto done;

    if (!line || !*line) {
        gchar *tmp;

        /* It doesn't make sense to use an --inquire with an empty
         * passphrase. This will prevent a pinentry dialog. */
        if (client->opts & OPT_INQUIRE) {
            cleanup_crypto(&client->crypto);
            return GPG_ERR_WRONG_KEY_USAGE;
        }

        if (client->rehash) {
            tmp = get_key_file_string(client->filename, "key_file");
            if (tmp) {
                gchar *file = expand_homedir(tmp);
                struct stat st;

                g_free(tmp);
                if (!file) {
                    cleanup_crypto(&client->crypto);
                    log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
                    return GPG_ERR_ENOMEM;
                }

                if (stat(file, &st) == -1) {
                    gint n = errno;

                    cleanup_crypto(&client->crypto);
                    return n;
                }

                gint fd = open(file, O_RDONLY);
                if (fd == -1) {
                    gint n = errno;

                    cleanup_crypto(&client->crypto);
                    return n;
                }

                g_free(file);
                line = gcry_malloc(st.st_size);
                if (!line) {
                    cleanup_crypto(&client->crypto);
                    return GPG_ERR_ENOMEM;
                }

                len = pth_read(fd, line, st.st_size);
                close(fd);

                if (len != st.st_size) {
                    gcry_free(line);
                    cleanup_crypto(&client->crypto);
                    return GPG_ERR_INCOMPLETE_LINE;
                }

                keyfile_rehash = TRUE;
                goto done;
            }
        }

        client->crypto->tkey = gcry_malloc(KEYSIZE);

        if (!client->crypto->tkey) {
            log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
            cleanup_crypto(&client->crypto);
            return send_error(ctx, GPG_ERR_ENOMEM);
        }

        memset(client->crypto->tkey, '!', KEYSIZE);
        CACHE_LOCK(ctx);

        if (cache_get_key(client->md5file, client->crypto->key) == FALSE ||
                !memcmp(client->crypto->key, client->crypto->tkey, KEYSIZE)) {
            CACHE_UNLOCK;

#ifdef WITH_PINENTRY
            gpg_error_t rc;

            if (client->pinentry->enable == FALSE ||
                    get_key_file_boolean(client->filename, "enable_pinentry") == FALSE) {
                /* Empty keys are allowed. */
                rc = hash_key(client->crypto, (guchar *)"" , 1, FALSE);
                if (rc) {
                    cleanup_crypto(&client->crypto);
                    return send_error(ctx, rc);
                }

                goto done;
            }

            lock_pin_mutex(client);
            client->pinentry->which = PINENTRY_SAVE;
            rc = pinentry_fork(ctx);

            if (rc) {
                unlock_pin_mutex(client->pinentry);
                cleanup_crypto(&client->crypto);
                return send_error(ctx, rc);
            }

            client->pinentry->cb = save_command_finalize;
            client->pinentry->status = PINENTRY_INIT;
            return 0;
#else
            /* Empty keys are allowed. */
            line = "";
            len = 1;
            goto done;
#endif
        }
        else {
            CACHE_UNLOCK;
            cached = TRUE;
        }
    }
    else {
        gpg_error_t rc;

        if (!get_key_file_uint64(client->filename, "iterations")) {
            guint64 iter = get_key_file_uint64(NULL, "iterations");
            gchar *p;

            if (!iter)
                iter = 1; // default? what about the "global" section?

            MUTEX_LOCK(&rcfile_mutex);
            p = g_strdup_printf("%llu", (unsigned long long)iter);
            g_key_file_set_value(keyfileh, client->filename, "iterations", p);
            g_free(p);
            MUTEX_UNLOCK(&rcfile_mutex);
            client->opts |= OPT_ITERATIONS;
            rc = send_status(ctx, STATUS_CONFIG, NULL);

            if (rc) {
                cleanup_crypto(&client->crypto);
                return client->opts & OPT_INQUIRE ? rc : send_error(ctx, rc);
            }
        }
    }

done:
    rc = save_command_finalize(ctx, (guchar *)line, len, cached);
    if (keyfile_rehash)
        gcry_free(line);

    return rc;
}

static gint save_command_inquire_finalize(gpointer data, gint assuan_rc,
        guchar *line, gsize len)
{
    assuan_context_t ctx = data;
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc = file_modified(client);

    if (assuan_rc || rc) {
        if (line)
            xfree(line);

        return assuan_rc ? assuan_rc : rc;
    }

    rc = save_command_common(ctx, (gchar *)line, len);

    if (line)
        xfree(line);

    client->inquire_status = INQUIRE_DONE;
    return rc;
}

static gint save_command(assuan_context_t ctx, gchar *line)
{
    struct stat st;
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;
    struct argv_s *args[] = {
        &(struct argv_s) { "iterations", OPTION_TYPE_OPTARG, parse_save_opt_iterations },
        &(struct argv_s) { "cipher", OPTION_TYPE_OPTARG, parse_save_opt_cipher },
        &(struct argv_s) { "pinentry", OPTION_TYPE_OPTARG, parse_opt_pinentry },
        &(struct argv_s) { "reset", OPTION_TYPE_NOARG, parse_save_opt_reset },
        &(struct argv_s) { "inquire", OPTION_TYPE_NOARG, parse_opt_inquire },
        NULL
    };

    rc = parse_options(&line, args, client);

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

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

    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);
    }

    if ((client->opts & OPT_INQUIRE)) {
        rc = assuan_inquire_ext(ctx, "SAVE", 0, save_command_inquire_finalize,
                ctx);

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

        /* Don't return with assuan_process_done() here. This is an INQUIRE. */
        client->inquire_status = INQUIRE_BUSY;
        return 0;
    }

    if (line && *line)
        log_write2("ARGS=%s", "<passphrase>");

    return save_command_common(ctx, line, line ? strlen(line) : 0);
}

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

    log_write2("ARGS=\"%s\"", line);

    if (strchr(line, '\t'))
        req = split_input_line(line, "\t", -1);
    else
        req = split_input_line(line, " ", -1);

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

    n = find_root_element(client->doc, &req, &rc, NULL, 0, FALSE);

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

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

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

    n = find_elements(client->doc, n->children, req+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL, FALSE);
    g_strfreev(req);

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

    if (n) {
        rc = unlink_node(n);
        xmlFreeNode(n);
    }

    return send_error(ctx, rc);
}

/*
 * Don't return with assuan_process_done() here. This has been called from
 * assuan_process_next() and the command should be finished in
 * client_thread().
 */
static gint store_command_finalize(gpointer data, gint assuan_rc, guchar *line,
        gsize len)
{
    assuan_context_t ctx = data;
    struct client_s *client = assuan_get_pointer(ctx);
    gchar **req;
    xmlNodePtr n, parent;
    gboolean has_content;
    gchar *content = NULL;
    gpg_error_t rc = file_modified(client);

    if (assuan_rc || rc) {
        if (line)
            xfree(line);
        return assuan_rc ? assuan_rc : rc;
    }

    req = split_input_line((gchar *)line, "\t", 0);
    xfree(line);

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

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

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

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

        goto again;
    }

    if (!n) {
        g_strfreev(req);
        return rc;
    }

    parent = n;

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

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

        update_element_mtime(parent);
    }

    if (has_content)
        req[len-1] = content;

    g_strfreev(req);
    client->inquire_status = INQUIRE_DONE;
    return rc;
}

static gint store_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;

    rc = assuan_inquire_ext(ctx, "STORE", 0, store_command_finalize, ctx);

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

    /* Don't return with assuan_process_done() here. This is an INQUIRE. */
    client->inquire_status = INQUIRE_BUSY;
    return 0;
}

static void *send_data_cb(void *arg)
{
    struct assuan_cmd_s *data = arg;
    gint old;
    gpg_error_t *rc;

    pth_cancel_state(PTH_CANCEL_ENABLE|PTH_CANCEL_ASYNCHRONOUS, &old);
    rc = g_malloc(sizeof(gpg_error_t));
    *rc = assuan_send_data(data->ctx, data->line, data->line_len);
    pth_cancel_state(old, NULL);
    pth_exit(rc);
    return NULL;
}

/* For every assuan command that needs to be sent to the client, a timeout is
 * needed to determine if the client lost the connection. The timeout is the
 * same as the "keepalive" configuration parameter or a default if unset.
 */
gpg_error_t do_assuan_command(assuan_context_t ctx,
        void *(*cb)(void *data), void *data)
{
    pth_attr_t attr = pth_attr_new();
    pth_t tid;
    pth_event_t ev;
    pth_status_t st;
    gpg_error_t rc = 0;
    void *p;

    pth_attr_init(attr);
    pth_attr_set(attr, PTH_ATTR_JOINABLE, TRUE);
    tid = pth_spawn(attr, cb, data);
    rc = gpg_error_from_syserror();
    pth_attr_destroy(attr);

    if (!tid) {
        log_write("%s(%i): pth_spawn(): %s", __FILE__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    pth_cleanup_push(cleanup_cancel_cb, tid);
    ev = pth_event(PTH_EVENT_TID|PTH_UNTIL_TID_DEAD, tid);
    pth_cleanup_push(cleanup_ev_cb, ev);
    pth_yield(tid);
    pth_wait(ev);

    st = pth_event_status(ev);

    if (st == PTH_STATUS_FAILED) {
        pth_cancel(tid);
        pth_join(tid, &p);
        g_free(p);
        rc = GPG_ERR_ASS_WRITE_ERROR;
    }
    else if (st == PTH_STATUS_OCCURRED) {
        pth_join(tid, &p);
        rc = *(gpg_error_t *)p;
        g_free(p);
    }

    pth_cleanup_pop(1);
    pth_cleanup_pop(0);
    return rc;
}

static gpg_error_t xfer_data(assuan_context_t ctx, const gchar *line,
        gint total)
{
    gint to_send;
    gint sent = 0;
    gpg_error_t rc;
    struct assuan_cmd_s data;
    gint progress = get_key_file_integer("global", "xfer_progress");
    gint flush = 0;

    progress = progress>0 ? (progress/ASSUAN_LINELENGTH)*ASSUAN_LINELENGTH : 0;
    to_send = total < ASSUAN_LINELENGTH ? total : ASSUAN_LINELENGTH;
    data.ctx = ctx;
    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;

        data.line = flush ? NULL : (gchar *)line+sent;
        data.line_len = flush ? 0 : to_send;
        rc = do_assuan_command(ctx, send_data_cb, &data);

        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 gint get_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gchar **req;
    gpg_error_t rc;
    xmlNodePtr n;

    log_write2("ARGS=\"%s\"", line);
    req = split_input_line(line, "\t", -1);

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

    n = find_root_element(client->doc, &req, &rc, NULL, 0, FALSE);

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

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

    g_strfreev(req);

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

    if (!n || !n->children)
        return send_error(ctx, GPG_ERR_NO_VALUE);

    n = find_text_node(n->children);

    if (!n || !n->content || !*n->content)
        return send_error(ctx, GPG_ERR_NO_VALUE);

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

static xmlNodePtr realpath_elements_cb(xmlNodePtr node, gchar **target,
        gpg_error_t *rc, gchar **req_orig, void *data)
{
    gchar *path = *(gchar **)data;
    gchar *tmp = NULL, *result;

    if (path) {
        g_free(path);
        *(gchar **)data = NULL;
    }

    path = g_strjoinv("\t", target);

    if (!path) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        *rc = GPG_ERR_ENOMEM;
        return NULL;
    }

    if (req_orig) {
        tmp = g_strjoinv("\t", req_orig);

        if (!tmp) {
            g_free(path);
            log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
            *rc = GPG_ERR_ENOMEM;
            return NULL;
        }
    }

    if (tmp && *tmp)
        result = g_strdup_printf("%s\t%s", path, tmp);
    else
        result = g_strdup(path);

    if (!result) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        *rc = GPG_ERR_ENOMEM;
        g_free(path);
        g_free(tmp);
        return NULL;
    }

    g_free(path);
    g_free(tmp);
    *(gchar **)data = result;
    return node;
}

static void list_command_cleanup1(void *arg);
static gint realpath_command(assuan_context_t ctx, gchar *line)
{
    gpg_error_t rc;
    struct client_s *client = assuan_get_pointer(ctx);
    gchar **req;
    gchar *t;
    gint i;
    xmlNodePtr n;
    GString *string;
    gchar *rp = NULL;

    log_write2("ARGS=\"%s\"", line);

    if (strchr(line, '\t') != NULL) {
        if ((req = split_input_line(line, "\t", 0)) == NULL)
            return send_error(ctx, GPG_ERR_SYNTAX);
    }
    else {
        if ((req = split_input_line(line, " ", 0)) == NULL)
            return send_error(ctx, GPG_ERR_SYNTAX);
    }

    n = find_root_element(client->doc, &req, &rc, NULL, 0, FALSE);

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

    rp = g_strjoinv("\t", req);

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

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

        if (!n) {
            g_free(rp);
            g_strfreev(req);
            return send_error(ctx, rc);
        }
    }

    string = g_string_new(rp);
    g_free(rp);
    g_strfreev(req);

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

again:
    for (i = 0, t = string->str + i; *t; t++, i++) {
        if ((!i && *t != '!') || (*t == '\t' && *(t+1) && *(t+1) != '!')) {
            string = g_string_insert_c(string, !i ? i++ : ++i, '!');
            goto again;
        }
    }

    pth_cleanup_push(list_command_cleanup1, string);
    rc = xfer_data(ctx, string->str, string->len);
    pth_cleanup_pop(1);
    return send_error(ctx, rc);
}

static void list_command_cleanup1(void *arg)
{
    g_string_free((GString *)arg, TRUE);
}

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

    if (elements) {
        if (elements->list) {
            gint total = g_slist_length(elements->list);
            gint i;

            for (i = 0; i < total; i++) {
                gchar *tmp = g_slist_nth_data(elements->list, i);
                g_free(tmp);
            }

            g_slist_free(elements->list);
        }

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

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

        g_free(elements);
    }
}

static gpg_error_t parse_list_opt_norecurse(gpointer data, gpointer value)
{
    struct element_list_s *elements = data;

    elements->recurse = FALSE;
    return 0;
}

static gpg_error_t parse_list_opt_verbose(gpointer data, gpointer value)
{
    struct element_list_s *elements = data;

    elements->verbose = TRUE;
    return 0;
}

static gint list_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;
    struct element_list_s *elements = NULL;
    gchar *tmp;
    struct argv_s *args[] = {
        &(struct argv_s) { "no-recurse", OPTION_TYPE_NOARG, parse_list_opt_norecurse },
        &(struct argv_s) { "verbose", OPTION_TYPE_NOARG, parse_list_opt_verbose },
        NULL
    };

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

    elements = g_malloc0(sizeof(struct element_list_s));

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

    elements->recurse = TRUE; // default
    pth_cleanup_push(list_command_cleanup2, elements);
    rc = parse_options(&line, args, elements);

    if (rc)
        goto fail;

    if (!*line) {
        GString *str;

        rc = list_root_elements(client->doc, &str, elements->verbose);

        if (rc) {
            pth_cleanup_pop(1);
            return send_error(ctx, rc);
        }

        pth_cleanup_push(list_command_cleanup1, str);
        rc = xfer_data(ctx, str->str, str->len);
        pth_cleanup_pop(1);
        pth_cleanup_pop(1);
        return send_error(ctx, rc);
    }

    elements->req = split_input_line(line, " ", 0);

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

    rc = create_path_list(client->doc, elements, *elements->req);

    if (rc)
        goto fail;

    if (elements) {
        gint total = g_slist_length(elements->list);
        gint i;
        GString *str;

        if (!total) {
            rc = GPG_ERR_NO_VALUE;
            goto fail;
        }

        str = g_string_new(NULL);

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

        for (i = 0; i < total; i++) {
            tmp = g_slist_nth_data(elements->list, i);
            g_string_append_printf(str, "%s%s", tmp, i+1 == total ? "" : "\n");
        }

        pth_cleanup_push(list_command_cleanup1, str);
        rc = xfer_data(ctx, str->str, str->len); 
        pth_cleanup_pop(1);
    }
    else
        rc = GPG_ERR_NO_VALUE;

fail:
    pth_cleanup_pop(1);
    return send_error(ctx, rc);
}

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

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

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

    n = find_root_element(client->doc, &path, &rc, NULL, 0, FALSE);

    if (!n) {
        g_strfreev(path);
        return rc;
    }

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

    g_strfreev(path);

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

        if ((pa = g_realloc(attrlist, (i + 2) * sizeof(gchar *))) == NULL) {
            if (attrlist)
                g_strfreev(attrlist);

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

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

        if (!attrlist[i]) {
            g_strfreev(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_VALUE;

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

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

    pth_cleanup_push(g_free, line);
    pth_cleanup_push(req_cleanup, attrlist);
    rc = xfer_data(ctx, line, strlen(line));
    pth_cleanup_pop(1);
    pth_cleanup_pop(1);
    return rc;
}

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

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

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

    /*
     * Don't remove the "_name" attribute for the root element. To remove an
     * root element use DELETE <name>.
     */
    if (!path[1] && xmlStrEqual((xmlChar *)req[0], (xmlChar *)"_name")) {
        rc = GPG_ERR_SYNTAX;
        goto fail;
    }

    n = find_root_element(client->doc, &path, &rc, NULL, 0, FALSE);

    if (!n)
        goto fail;

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

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

fail:
    g_strfreev(path);
    return rc;
}

static xmlNodePtr create_element_path(struct client_s *client,
        gchar ***elements, gpg_error_t *rc, xmlNodePtr parent)
{
    gchar **req = *elements;
    gchar **req_orig = g_strdupv(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->doc, &req, rc, NULL, 0, FALSE);
    if (!n) {
        if (*rc != GPG_ERR_ELEMENT_NOT_FOUND)
            goto fail;

        *rc = new_root_element(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(n, req+1, rc, NULL);
        else
            n = find_elements(client->doc, n->children, req+1, rc, NULL, NULL,
                    create_target_elements_cb, FALSE, 0, parent, FALSE);

        if (!n)
            goto fail;

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

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

fail:
    if (req_orig)
        g_strfreev(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, gchar **req)
{
    gchar **src, **dst, *line = NULL, **odst = NULL;
    gpg_error_t rc;
    xmlNodePtr n;

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

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

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

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

    odst = g_strdupv(dst);

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

    n = find_root_element(client->doc, &dst, &rc, NULL, 0, FALSE);

    /*
     * Make sure the destination element path exists.
     */
    if (!n)
        goto fail;

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

        if (!n)
            goto fail;
    }

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

    if (rc)
        goto fail;

    line = g_strjoinv("\t", odst);

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

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

fail:
    g_free(line);
    g_strfreev(src);
    g_strfreev(dst);
    g_strfreev(odst);
    return rc;
}

/*
 * req[0] - name
 * req[1] - new name
 */
static gpg_error_t name_attribute(struct client_s *client, gchar **req)
{
    gpg_error_t rc;
    gchar **tmp;
    xmlNodePtr n;

    tmp = g_strdupv(req);

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

    n = find_root_element(client->doc, &tmp, &rc, NULL, 0, FALSE);
    g_strfreev(tmp);

    if (!n)
        return rc;

    if (g_utf8_collate(req[0], req[1]) == 0)
        return 0;

    /*
     * Will not overwrite an existing root.
     */
    tmp = g_strdupv(req+1);

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

    n = find_root_element(client->doc, &tmp, &rc, NULL, 0, FALSE);
    g_strfreev(tmp);

    if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
        return rc;

    if (n)
        return GPG_ERR_AMBIGUOUS_NAME;

    if (!valid_xml_element((xmlChar *)req[1]))
        return GPG_ERR_SYNTAX;

    tmp = g_strdupv(req);

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

    n = find_root_element(client->doc, &tmp, &rc, NULL, 0, FALSE);
    g_strfreev(tmp);

    if (!n)
        return GPG_ERR_ELEMENT_NOT_FOUND;

    return add_attribute(n, "_name", req[1]);
}

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

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

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

    n = find_root_element(client->doc, &path, &rc, NULL, 0, FALSE);

    if (!n)
        goto fail;

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

        if (!n)
            goto fail;
    }

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

    pth_cleanup_push(xmlFree, a);

    if (*a)
        rc = xfer_data(ctx, (gchar *)a, xmlStrlen(a));
    else
        rc = GPG_ERR_NO_VALUE;

    pth_cleanup_pop(1);
    return rc;

fail:
    g_strfreev(path);
    return rc;
}

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

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

    /*
     * Reserved attribute names.
     */
    if (!g_strcmp0(req[0], "_name")) {
        /*
         * Only reserved for the root element. Not the rest of the
         * document.
         */
        if (strchr(req[1], '\t') == NULL)
            return name_attribute(client, req + 1);
    }
    else if (!g_strcmp0(req[0], "target"))
        return target_attribute(client, req + 1);
    
    if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
        /*
         * The first argument may be only a root element.
         */
        if ((path = split_input_line(req[1], " ", 0)) == NULL)
            return GPG_ERR_SYNTAX;
    }

    n = find_root_element(client->doc, &path, &rc, NULL, 0, FALSE);

    if (!n)
        goto fail;

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

        if (!n)
            goto fail;
    }

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

fail:
    g_strfreev(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 gint attr_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gchar **req;
    gpg_error_t rc = 0;

    log_write2("ARGS=\"%s\"", line);
    req = split_input_line(line, " ", 4);

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

    pth_cleanup_push(req_cleanup, req);

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

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

static gint iscached_command(assuan_context_t ctx, gchar *line)
{
    gchar **req = split_input_line(line, " ", 0);
    guchar md5file[16];
    gchar *path, *tmp;

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

    log_write2("ARGS=\"%s\"", line);

    if (!valid_filename(req[0])) {
        g_strfreev(req);
        return GPG_ERR_INV_VALUE;
    }

    gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
    CACHE_LOCK(ctx);

    if (cache_iscached(md5file)) {
        g_strfreev(req);
        CACHE_UNLOCK;
        return send_error(ctx, 0);
    }

    CACHE_UNLOCK;
    tmp = get_key_file_string("global", "data_directory");

    if (!tmp) {
        g_strfreev(req);
        return GPG_ERR_ENOMEM;
    }

    path = expand_homedir(tmp);

    if (!path) {
        g_strfreev(req);
        g_free(tmp);
        return GPG_ERR_ENOMEM;
    }

    g_free(tmp);
    tmp = path;
    path = g_strdup_printf("%s/%s", tmp, req[0]);
    g_free(tmp);

    if (!path) {
        g_strfreev(req);
        return GPG_ERR_ENOMEM;
    }

    if (access(path, R_OK) == -1) {
        gpg_error_t rc = gpg_error_from_syserror();

        g_free(path);
        g_strfreev(req);
        return send_error(ctx, rc);
    }

    g_free(path);
    return send_error(ctx, GPG_ERR_NOT_FOUND);
}

static gint clearcache_command(assuan_context_t ctx, gchar *line)
{
    gchar **req = split_input_line(line, " ", 0);
    guchar md5file[16];

    log_write2("ARGS=\"%s\"", line);
    CACHE_LOCK(ctx);

    if (!req || !*req) {
        g_strfreev(req);
        cache_clear(NULL, 2);
        CACHE_UNLOCK;
        return send_error(ctx, 0);
    }
    
    gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
    g_strfreev(req);
    (void)cache_clear(md5file, 1);
    CACHE_UNLOCK;
    return send_error(ctx, 0);
}

static gint cachetimeout_command(assuan_context_t ctx, gchar *line)
{
    guchar md5file[16];
    glong timeout;
    gchar **req = split_input_line(line, " ", 0);
    gchar *p;

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

    errno = 0;
    timeout = strtol(req[1], &p, 10);

    if (errno != 0 || *p != 0 || timeout < -1) {
        g_strfreev(req);
        return send_error(ctx, GPG_ERR_SYNTAX);
    }

    gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
    CACHE_LOCK(client->ctx);

    if (cache_set_timeout(md5file, timeout) == FALSE) {
        CACHE_UNLOCK;
        return send_error(ctx, GPG_ERR_NOT_FOUND);
    }

    CACHE_UNLOCK;
    return send_error(ctx, 0);
}

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

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

    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);
    }

    pth_cleanup_push(xmlFree, xml);
    rc = xfer_data(ctx, (gchar *)xml, len);
    pth_cleanup_pop(1);
    return send_error(ctx, rc);
}

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

    log_write2("ARGS=\"%s\"", 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 = g_ascii_strdown(paramp, -1);

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

    if (fp && !g_ascii_strcasecmp(paramp, "iterations")) {
        if (!(client->opts & OPT_ITERATIONS) || fp != client->filename) {
            file_header_internal_t *fh = read_file_header(fp, FALSE, &rc);

            if (!fh && rc != GPG_ERR_ENOENT)
                return send_error(ctx, rc);

            if (!rc) {
                g_free(paramp);
                p = g_strdup_printf("%llu", (unsigned long long)fh->ver.fh2.iter);
                close_file_header(fh);

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

                goto done;
            }
        }
    }
    else if (!g_ascii_strcasecmp(paramp, "enable_pinentry")) {
#ifdef WITH_PINENTRY
        gboolean n;

        if (fp == client->filename && (client->opts & OPT_PINENTRY))
            n = client->pinentry->enable;
        else
            n = get_key_file_boolean(fp, "enable_pinentry");

        p = g_strdup_printf("%s", n ? "true" : "false");

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

        goto done;
#else
        return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
#endif
    }
    else if (!g_ascii_strcasecmp(paramp, "pinentry_timeout")) {
#ifdef WITH_PINENTRY
        p = g_strdup_printf("%i", get_key_file_integer(fp, "pinentry_timeout"));

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

        goto done;
#else
        return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
#endif
    }

    p = get_key_file_string(fp ? fp : "global", paramp);
    g_free(paramp);

    if (!p)
        return send_error(ctx, GPG_ERR_UNKNOWN_OPTION);

    tmp = expand_homedir(p);
    g_free(p);

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

    p = tmp;
done:
    pth_cleanup_push(g_free, p);
    rc = xfer_data(ctx, p, strlen(p));
    pth_cleanup_pop(1);
    return send_error(ctx, rc);
}

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

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

    req_cleanup(xpath->req);

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

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

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

static gint xpath_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;
    struct xpath_s xpath;

    log_write2("ARGS=\"%s\"", line);

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

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

    memset(&xpath, 0, sizeof(struct xpath_s));

    if ((xpath.req = split_input_line(line, "\t", 2)) == NULL) {
        if (strv_printf(&xpath.req, "%s", line) == FALSE)
            return send_error(ctx, GPG_ERR_ENOMEM);
    }

    xpath.xp = xmlXPathNewContext(client->doc);

    if (!xpath.xp) {
        xpath_command_cleanup(&xpath);
        return send_error(ctx, EPWMD_LIBXML_ERROR);
    }

    xpath.result = xmlXPathEvalExpression((xmlChar *)xpath.req[0], xpath.xp);

    if (!xpath.result) {
        xpath_command_cleanup(&xpath);
        return send_error(ctx, EPWMD_LIBXML_ERROR);
    }

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

    rc = recurse_xpath_nodeset(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_VALUE;
        goto fail;
    }
    else if (xpath.req[1])
        goto fail;

    pth_cleanup_push(xpath_command_cleanup, &xpath);
    rc = xfer_data(ctx, (gchar *)xmlBufferContent(xpath.buf),
            xmlBufferLength(xpath.buf));
    pth_cleanup_pop(0);

fail:
    xpath_command_cleanup(&xpath);
    return send_error(ctx, rc);
}

/* XPATHATTR SET|DELETE <name> <expression>[<TAB>[value]] */
static gint xpathattr_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;
    struct xpath_s xpath;
    gchar **req = NULL;
    gboolean cmd = FALSE; //SET

    log_write2("ARGS=\"%s\"", line);

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

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

    memset(&xpath, 0, sizeof(struct xpath_s));

    if ((req = split_input_line(line, " ", 3)) == NULL)
        return send_error(ctx, GPG_ERR_ENOMEM);

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

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

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

    if ((xpath.req = split_input_line(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 = EPWMD_LIBXML_ERROR;
        goto fail;
    }

    xpath.result = xmlXPathEvalExpression((xmlChar *)xpath.req[0], xpath.xp);

    if (!xpath.result) {
        rc = EPWMD_LIBXML_ERROR;
        goto fail;
    }

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

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

fail:
    g_strfreev(req);
    xpath_command_cleanup(&xpath);
    return send_error(ctx, rc);
}

static gint import_command_finalize(gpointer data, gint assuan_rc, guchar *line,
        gsize len)
{
    struct client_s *client = assuan_get_pointer((assuan_context_t)data);
    gpg_error_t rc = file_modified(client);
    gchar **req, **path = NULL, **path_orig = NULL, *content;
    xmlDocPtr doc = NULL;
    xmlNodePtr n, root, copy;

    if (assuan_rc || rc) {
        if (line)
            xfree(line);
        return assuan_rc ? assuan_rc : rc;
    }

    req = split_input_line((gchar *)line, "\t", 2);
    xfree(line);

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

    content = req[0];
    path = split_input_line(req[1], "\t", 0);

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

    if (path && !valid_element_path(path, FALSE)) {
        rc = GPG_ERR_INV_VALUE;
        goto fail;
    }

    doc = xmlReadDoc((xmlChar *)content, NULL, "UTF-8", XML_PARSE_NOBLANKS);

    if (!doc) {
        rc = EPWMD_LIBXML_ERROR;
        goto fail;
    }

    root = xmlDocGetRootElement(doc);
    rc = validate_import(root);

    if (rc)
        goto fail;

    if (path) {
        path_orig = g_strdupv(path);

        if (!path_orig) {
            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) {
            g_strfreev(path_orig);
            rc = GPG_ERR_ENOMEM;
            goto fail;
        }

        if (strv_printf(&path, "%s", (gchar *)a) == FALSE) {
            xmlFree(a);
            g_strfreev(path_orig);
            rc = GPG_ERR_ENOMEM;
            goto fail;
        }

        xmlFree(a);
        n = find_root_element(client->doc, &path, &rc, NULL, 0, FALSE);

        if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND) {
            g_strfreev(path_orig);
            goto fail;
        }

        if (!rc) {
            n = find_elements(client->doc, n->children, path+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL, TRUE);

            if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND) {
                g_strfreev(path_orig);
                goto fail;
            }
            else if (!rc) {
                xmlNodePtr parent = n->parent;

                xmlUnlinkNode(n);
                xmlFreeNode(n);
                n = parent;
            }
        }

        g_strfreev(path);
        path = path_orig;

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

            if (rc)
                goto fail;
        }

        copy = xmlCopyNodeList(root);
        n = xmlAddChildList(n, copy);

        if (!n)
            rc = EPWMD_LIBXML_ERROR;
    }
    else {
        /* 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;
        }

        gchar *tmp = g_strdup((gchar *)a);
        xmlFree(a);
        gboolean literal = is_literal_element(&tmp);

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

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

        g_free(tmp);
        n = find_root_element(client->doc, &path, &rc, NULL, 0, TRUE);

        if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND) {
            rc = EPWMD_LIBXML_ERROR;
            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);
    }

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

fail:
    if (doc)
        xmlFreeDoc(doc);

    if (path)
        g_strfreev(path);

    g_strfreev(req);
    client->inquire_status = INQUIRE_DONE;
    return rc;
}

static gint import_command(assuan_context_t ctx, gchar *line)
{
    gpg_error_t rc;
    struct client_s *client = assuan_get_pointer(ctx);

    rc = assuan_inquire_ext(ctx, "IMPORT", 0, import_command_finalize, ctx);

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

    /* Don't return with assuan_process_done() here. This is an INQUIRE. */
    client->inquire_status = INQUIRE_BUSY;
    return 0;
}

static gpg_error_t do_lock_command(struct client_s *client)
{
    gpg_error_t rc = lock_file_mutex(client);

    if (!rc)
        client->is_lock_cmd = TRUE;

    return client->opts & OPT_INQUIRE ? rc : send_error(client->ctx, rc);
}

static gint lock_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);

    return do_lock_command(client);
}

static gint unlock_command(assuan_context_t ctx, gchar *line)
{
    struct client_s *client = assuan_get_pointer(ctx);

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

static gint getpid_command(assuan_context_t ctx, gchar *line)
{
    gpg_error_t rc;
    gchar buf[32];
    pid_t pid = getpid();

    print_fmt(buf, sizeof(buf), "%i", pid);
    rc = xfer_data(ctx, buf, strlen(buf));
    return send_error(ctx, rc);
}

static gint version_command(assuan_context_t ctx, gchar *line)
{
    gpg_error_t rc;
    gchar *buf;

    buf = g_strdup_printf("0x%X %s", VERSION_HEX,
#ifdef WITH_PINENTRY
            "PINENTRY "
#endif
#ifdef WITH_QUALITY
            "QUALITY "
#endif
#ifdef WITH_LIBACL
            "ACL "
#endif
            "");
    rc = xfer_data(ctx, buf, strlen(buf));
    g_free(buf);
    return send_error(ctx, rc);
}

#ifdef WITH_PINENTRY
static void set_option_value(gchar **opt, const gchar *value)
{
    if (opt)
        g_free(*opt);

    *opt = NULL;

    if (value)
        *opt = g_strdup(value);
}
#endif

static gint set_unset_common(assuan_context_t ctx, const gchar *name,
        const gchar *value)
{
    struct client_s *client = assuan_get_pointer(ctx);
    gpg_error_t rc;

    if (g_ascii_strcasecmp(name, (gchar *)"log_level") == 0) {
        gint n = 0;

        if (value) {
            n = atoi(value);

            if (n < 0 || n > 2)
                return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
        }

        MUTEX_LOCK(&rcfile_mutex);
        g_key_file_set_integer(keyfileh, "global", "log_level", n);
        MUTEX_UNLOCK(&rcfile_mutex);
        goto done;
    }
    else if (g_ascii_strcasecmp(name, (gchar *)"rc_on_locked") == 0) {
        gint n = 0;

        if (value) {
            n = atoi(value);

            if (n < 0 || n > 1)
                return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
        }

        client->rc_on_locked = n ? TRUE : FALSE;
        goto done;
    }
    else if (g_ascii_strcasecmp(name, (gchar *)"lock_on_open") == 0) {
        rc = parse_open_opt_lock(client, (gpointer)value);

        if (rc)
            return rc;

        client->opts |= OPT_LOCK;
    }
    else if (g_ascii_strcasecmp(name, (gchar *)"cipher") == 0) {
        if (!value) {
            client->opts &= ~(OPT_CIPHER);
            goto done;
        }

        rc = parse_save_opt_cipher(client, (gpointer)value);

        if (rc)
            return rc;

        client->opts |= OPT_CIPHER;
        goto done;
    }
    else if (g_ascii_strcasecmp(name, (gchar *)"iterations") == 0) {
        rc = parse_save_opt_iterations(client, (gpointer)value);

        if (rc)
            return rc;

        goto done;
    }
    else if (g_ascii_strcasecmp(name, (gchar *)"NAME") == 0) {
        pth_attr_t attr = pth_attr_of(pth_self());
        gchar buf[41];

        if (!value) {
            pth_attr_destroy(attr);
            goto done;
        }

        print_fmt(buf, sizeof(buf), "%s", value);
        pth_attr_set(attr, PTH_ATTR_NAME, buf);
        pth_attr_destroy(attr);
#ifdef WITH_PINENTRY
        if (client->pinentry->name)
            g_free(client->pinentry->name);

        client->pinentry->name = g_strdup(buf);

        if (!client->pinentry->name)
            return GPG_ERR_ENOMEM;
#endif

        goto done;
    }
#ifdef WITH_PINENTRY
    else if (g_ascii_strcasecmp(name, (gchar *)"lc_messages") == 0)
        set_option_value(&client->pinentry->lcmessages, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"lc_ctype") == 0)
        set_option_value(&client->pinentry->lcctype, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"ttyname") == 0)
        set_option_value(&client->pinentry->ttyname, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"ttytype") == 0)
        set_option_value(&client->pinentry->ttytype, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"display") == 0)
        set_option_value(&client->pinentry->display, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"pinentry_path") == 0)
        set_option_value(&client->pinentry->path, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"title") == 0)
        set_option_value(&client->pinentry->title, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"prompt") == 0)
        set_option_value(&client->pinentry->prompt, value);
    else if (g_ascii_strcasecmp(name, (gchar *)"desc") == 0)
        set_option_value(&client->pinentry->desc, value);
    else if (g_ascii_strcasecmp(name, "pinentry_timeout") == 0) {
        gchar *p = NULL;
        gint n;
        
        if (!value)
            goto done;

        n = atoi(value);

        if (*p || n < 0)
            return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);

        MUTEX_LOCK(&rcfile_mutex);
        g_key_file_set_integer(keyfileh, client->filename ? client->filename :
                "global", "pinentry_timeout", n);
        MUTEX_UNLOCK(&rcfile_mutex);
        goto done;
    }
    else if (g_ascii_strcasecmp(name, "enable_pinentry") == 0) {
        rc = parse_opt_pinentry(client, (gpointer)value);

        if (rc)
            return rc;

        goto done;
    }
#else
    else if (g_ascii_strcasecmp(name, (gchar *)"lc_messages") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"lc_ctype") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"ttyname") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"ttytype") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"display") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"pinentry_path") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"title") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"prompt") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, (gchar *)"desc") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, "pinentry_timeout") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
    else if (g_ascii_strcasecmp(name, "enable_pinentry") == 0)
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_NOT_IMPLEMENTED);
#endif
    else
        return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_UNKNOWN_OPTION);

done:
    return 0;
}

static gint unset_command(assuan_context_t ctx, gchar *line)
{
    log_write2("ARGS=\"%s\"", line);
    return send_error(ctx, set_unset_common(ctx, line, NULL));
}

static gint set_command(assuan_context_t ctx, gchar *line)
{
    gchar name[64] = {0}, value[256] = {0};

    log_write2("ARGS=\"%s\"", line);

    if (sscanf(line, " %63[_a-zA-Z] = %255c", name, value) != 2)
        return send_error(ctx, gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_SYNTAX));

    return send_error(ctx, set_unset_common(ctx, name, value));
}

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

    log_write2("ARGS=\"%s\"", line);
    req = split_input_line(line, " ", -1);

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

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

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

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

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

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

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

    if (!n)
        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);
    gchar **tmp = NULL;

    if (src[1]) {
        gchar **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->doc, &tmp, &rc, NULL, 0, FALSE);

    if (!ndst && rc && rc != GPG_ERR_ELEMENT_NOT_FOUND) {
        g_strfreev(tmp);
        goto fail;
    }

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

    g_strfreev(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) {
        unlink_node(ndst);
        xmlFreeNodeList(ndst);
    }

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

fail:
    g_strfreev(req);
    g_strfreev(src);
    return send_error(ctx, rc);
}

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

    log_write2("ARGS=\"%s\"", line);
    req = split_input_line(line, " ", -1);

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

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

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

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

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

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

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

    if (!nsrc)
        goto fail;

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

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

    if (!ndst && rc != GPG_ERR_ELEMENT_NOT_FOUND)
        goto fail;
    else if (create) {
        ndst = create_element_path(client, &dst, &rc, NULL);
        if (!ndst)
            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(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(xmlDocGetRootElement(client->doc) ==
                ndst->parent ? ndst : ndst->parent);
    }

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

    if (req)
        g_strfreev(req);

    if (src)
        g_strfreev(src);

    if (dst)
        g_strfreev(dst);

    return send_error(ctx, rc);
}

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

    log_write2("ARGS=\"%s\"", line);
    req = split_input_line(line, " ", -1);

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

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

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

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

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

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

    if (!nsrc)
        goto fail;

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

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

        if (ndst && dst[1])
            ndst = find_elements(client->doc, ndst->children, dst+1, &rc, NULL,
                    NULL, NULL, FALSE, 0, NULL, FALSE);
    }
    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(ndst->children, (gchar *)a, NULL);

        xmlFree(a);

        if (dup) {
            if (dup == nsrc)
                goto fail;
            
            if (ndst == xmlDocGetRootElement(client->doc)) {
                xmlNodePtr n = nsrc;
                gboolean match = FALSE;

                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 = TRUE;
                    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)
                && !g_strcmp0((gchar *)name, *dst)) {
            xmlFree(name);
            rc = GPG_ERR_CONFLICT;
            goto fail;
        }

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

    if (!ndst)
        goto fail;

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

    if (!ndst)
        rc = GPG_ERR_ENOMEM;

    update_element_mtime(ndst->parent);

fail:
    if (req)
        g_strfreev(req);

    if (src)
        g_strfreev(src);

    if (dst)
        g_strfreev(dst);

    return send_error(ctx, rc);
}

static int ls_command(assuan_context_t ctx, gchar *line)
{
    log_write2("ARGS=\"%s\"", line);
    gpg_error_t rc;
    gchar *tmp = g_key_file_get_string(keyfileh, "global", "data_directory", NULL);
    gchar *dir = expand_homedir(tmp);
    DIR *d = opendir(dir);

    rc = gpg_error_from_syserror();
    g_free(tmp);

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

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

    g_free(dir);
    rc = 0;

    while (!readdir_r(d, p, &cur) && cur) {
        if (cur->d_name[0] == '.' && cur->d_name[1] == '\0')
            continue;
        else if (cur->d_name[0] == '.' && cur->d_name[1] == '.' && cur->d_name[2] == '\0')
            continue;

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

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

            rc = GPG_ERR_ENOMEM;
            break;
        }

        g_free(list);
        list = tmp;
    }

    closedir(d);
    g_free(p);

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

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

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

static void bye_notify(assuan_context_t ctx)
{
    struct client_s *cl = assuan_get_pointer(ctx);

    /* This will let assuan_process_next() return. */
    fcntl(cl->thd->fd, F_SETFL, O_NONBLOCK);
    cl->last_rc = 0; // BYE command result
}

static void reset_notify(assuan_context_t ctx)
{
    struct client_s *cl = assuan_get_pointer(ctx);

    if (cl)
        cleanup_client(cl);
}

/* 
 * This is called before every Assuan command.
 */
gint command_startup(assuan_context_t ctx, const gchar *name)
{
    struct client_s *cl = assuan_get_pointer(ctx);
    gpg_error_t rc;

    log_write1("%s", name);

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

#ifdef WITH_PINENTRY
    if (!(cl->opts & OPT_PINENTRY))
        reset_pin_defaults(cl->pinentry);
#endif

    cl->last_rc = rc = file_modified(cl);

    if (rc) {
        if ((rc == EPWMD_NO_FILE || rc == EPWMD_FILE_MODIFIED) &&
                !g_ascii_strcasecmp(name, "OPEN"))
            rc = 0;
    }

    return rc;
}

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

    if (!client->is_lock_cmd)
        unlock_file_mutex(client);

    log_write1(_("command completed (rc=%u)"), client->last_rc);
    client->opts &= ~(OPT_INQUIRE);
}

static gint help_command(assuan_context_t ctx, gchar *line)
{
    gpg_error_t rc;
    gint i;

    if (!line || !*line) {
        gchar *tmp;
        gchar *buf = g_strdup(_(
"Usage: HELP [<COMMAND>]\n"
"    For commands that take an element path as an argument, each element is\n"
"    separated with an ASCII tab character (ASCII 0x09).\n"
"\n"
"    Each element may contain a \"target\" attribute whose value is also an\n"
"    element path. Think of a \"target\" attribute like a symbolic link on a\n"
"    filesystem. When found, the element path of the \"target\" attribute will\n"
"    be used as a prefix for further elements in the current element path. To\n"
"    ignore any \"target\" attribute for the current element, prefix the element\n"
"    with an ! (ASCII 0x21).\n"
"\n"
"    See pwmd(1) for configuration file options which may also set default\n"
"    options for specific data files.\n"
"\n"
"COMMANDS:"));

        for (i = 0; command_table[i]; i++) {
            gchar *p = strrchr(buf, '\n');
            gboolean newline = FALSE;

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

            if (p && strlen(p)+strlen(command_table[i]->name) > 79) {
                tmp = g_strdup_printf("%s\n", buf);
                g_free(buf);
                buf = tmp;
                newline = TRUE;
            }

            tmp = g_strdup_printf("%s%s%s", buf, !newline ? " " : "",
                    command_table[i]->name);
            g_free(buf);
            buf = tmp;
        }

        tmp = g_strdup_printf("%s\n", buf);
        g_free(buf);
        buf = tmp;
        rc = xfer_data(ctx, buf, strlen(buf));
        g_free(buf);
        return send_error(ctx, rc);
    }

    for (i = 0; command_table[i]; i++) {
        if (!g_strcasecmp(line, command_table[i]->name)) {
            if (!command_table[i]->help)
                break;

            gchar *tmp = g_strdup_printf(_("Usage: %s"), command_table[i]->help);
            rc = xfer_data(ctx, tmp, strlen(tmp));
            g_free(tmp);
            return send_error(ctx, rc);
        }
    }

    return send_error(ctx, GPG_ERR_INV_NAME);
}

void new_command(const gchar *name, gboolean ignore,
        gint (*handler)(assuan_context_t, gchar *), const gchar *help)
{
    gint i = 0;

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

    command_table = g_realloc(command_table, (i+2)*sizeof(struct command_table_s *));
    command_table[i] = g_malloc0(sizeof(struct command_table_s));
    command_table[i]->name = name;
    command_table[i]->handler = handler;
    command_table[i]->ignore_startup = ignore;
    command_table[i++]->help = help;
    command_table[i] = NULL;
}

void deinit_commands()
{
    gint i;

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

    g_free(command_table);
}

static gint 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 g_strcmp0((*a)->name, (*b)->name);
}

void init_commands()
{
    /* !BEGIN-HELP-TEXT!
     *
     * This comment is used as a marker to generate the offline documentation
     * for commands found in doc/COMMANDS. 
     */
    new_command("HELP", TRUE, help_command, _(
"HELP [<COMMAND>]\n"
"    Show available commands or command specific help text.\n"
));

    new_command("OPEN", FALSE, open_command, _(
"OPEN [--lock] [--inquire | --pinentry=[0|1]] <filename> [<key>]\n"
"    Opens <filename> using <key>. When the filename is not found on the\n"
"    file-system a new document will be created. If the file is found, it is\n"
"    looked for in the file cache for an existing key. When found and no key\n"
"    was specified, the cached key will be used for decryption (if encrypted).\n"
"    When not found, pinentry(1) will be used to retrieve the key (see the\n"
"    OPTIONS documentation).\n"
"\n"
"    When the --lock option is passed then the file mutex will be locked as if\n"
"    the LOCK command had been sent after the file had been opened.\n"
"\n"
"    The --inquire option disables pinentry usage and uses a server inquire to\n"
"    retrieve the filename and key arguments.\n"
"\n"
"    Using pinentry for passphrase retrieval can be enabled or disabled by\n"
"    specifying the --pinentry option with the value 1 or 0 respectively. When\n"
"    no value is specified then the configuration file value will be used. If\n"
"    the passphrase is invalid then it is up to the client whether to retry or\n"
"    not.  To decrypt an encrypted file with an empty passphrase and avoid the\n"
"    pinentry dialog, use --pinentry=0.\n"
"\n"
"    When a \"key_file\" configuration parameter has been set for the current\n"
"    file and there is no cache entry, then an --inquire must be used to\n"
"    retrieve the key.\n"
));

    new_command("SAVE", FALSE, save_command, _(
"SAVE [--reset] [--inquire | --pinentry=[0|1]] [--cipher=[<string>]]\n"
"     [--iterations=[N]] [<key>]\n"
"    Writes the XML document to disk. The file written to is the file that was\n"
"    opened using the OPEN command. If <key> is not specified then the\n"
"    currently cached key will be used. If the file is a new file or the file\n"
"    is not found in the file cache then <key> will be used. If both <key> is\n"
"    not specified and the file is not cached then pinentry(1) will be used to\n"
"    retrieve the key (see below) unless the configured number of iterations is\n"
"    0 in which case the file will be saved unencrypted.\n"
"\n"
"    Note that when both <key> is specified and the configured number of\n"
"    iterations is 0 the iterations for the current filename will be reset to\n"
"    1. This is to be on the safe side and prevent misuse.\n"
"\n"
"    The --iterations option can be used to change the number of encryption\n"
"    iterations for the opened file. When 0 no encryption will be performed.\n"
"    When this option is either not passed or is specified without a value then\n"
"    the previous setting obtained from the file header will be used.\n"
"\n"
"    You can specify an alternate cipher to encrypt with by specifying a cipher\n"
"    string with the --cipher option. Omitting the string uses the current\n"
"    cipher of the opened file or the default if the file is a new one. The\n"
"    default is specified in the configuration file. See pwmd(1) for available\n"
"    ciphers.\n"
"\n"
"    Using pinentry for passphrase retrieval can be enabled or disabled by\n"
"    specifying the --pinentry option with the value 1 or 0, respectively. When\n"
"    no value is specified then the configuration file value will be used.\n"
"    When enabled and the passphrase confirmation fails, the pinentry process\n"
"    is started over again until either the passphrases match or until the\n"
"    input is canceled by the user.  To save with encryption and with an empty\n"
"    passphrase, use --pinentry=0.\n"
"\n"
"    When --reset is specified then the cached passphrase for the opened file\n"
"    will be cleared before doing the actual SAVE as if the CLEARCACHE command\n"
"    had been sent.\n"
"\n"
"    The --inquire option disables pinentry usage and uses a server inquire to\n"
"    retrieve the key.\n"
"\n"
"    When a \"key_file\" configuration parameter has been set for the current\n"
"    file and there is no cache entry, then an --inquire must be used to\n"
"    retrieve the key.\n"
));

    new_command("ISCACHED", TRUE, iscached_command, _(
"ISCACHED <filename>\n"
"    An OK response is returned if the specified file is found in the file\n"
"    cache. If not found in the cache but exists on the filesystem,\n"
"    GPG_ERR_NOT_FOUND is returned. Otherwise a filesystem error is returned.\n"
));

    new_command("CLEARCACHE", TRUE, clearcache_command, _(
"CLEARCACHE [<filename>]\n"
"    Clears a file cache entry. This will forget the timeout and key for all or\n"
"    the specified file. Always returns an OK response.\n"
));

    new_command("CACHETIMEOUT", TRUE, cachetimeout_command, _(
"CACHETIMEOUT <filename> <seconds>\n"
"    Specify the number of seconds the specified file will be cached. -1 will\n"
"    keep the cache entry forever, 0 will require the key each time the OPEN or\n"
"    SAVE commands are used. Also see the \"cache_timeout\" configuration\n"
"    parameter. Returns ERR if the filename is not cached or if the timeout is\n"
"    invalid. OK otherwise.\n"
));

    new_command("LIST", FALSE, list_command, _(
"LIST [--no-recurse] [--verbose] [[!]element[<TAB>[!]element[...]]]\n"
"    If no element path is given then a newline separated list of root elements\n"
"    is returned with the data response. If given, then all reachable elements\n"
"    for the specified element path are returned unless the --no-recurse option\n"
"    is specified. If specified, only the child elements of the element path\n"
"    are returned without recursing into grandchildren. Each element in the\n"
"    path is prefixed with the literal '!' character when the element contains\n"
"    no \"target\" attribute. Refer to THE TARGET ATTRIBUTE for more information.\n"
"\n"
"    When the --verbose option is passed then each element path returned in the\n"
"    list will have a single space character followed by either a 0 or 1\n"
"    appended to it.  When 0, the element path has no children, otherwise it\n"
"    does have children.  When used with the --no-recurse option this may be\n"
"    useful to limit the amount of data transferred to the client.\n"
));

    new_command("REALPATH", FALSE, realpath_command, _(
"REALPATH [!]element[<TAB>[!]element[...]]\n"
"    Resolves all \"target\" attributes of the specified element path and returns\n"
"    the result with a data response.\n"
));

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

    new_command("RENAME", FALSE, rename_command, _(
"RENAME [!]element[<TAB>[!]element[...]] <value>\n"
"    Renames the specified element to the new value. If an element of the same\n"
"    name as the value exists then it will be overwritten.\n"
));

    new_command("COPY", FALSE, copy_command, _(
"COPY [!]element[<TAB>[!]element[...]] [!]element[<TAB>[!]element[...]]\n"
"    Copies the entire element tree starting from the child node of the source\n"
"    element path, to the destination element path. If the destination element\n"
"    path does not exist then it will be created; otherwise it is overwritten.\n"
"\n"
"    Note that attributes from the source element path are merged into the\n"
"    destination element path when the destination element path exists. When an\n"
"    attribute of the same name exists in both the source and destination\n"
"    element paths then the destination attribute will be updated to the source\n"
"    attribute value.\n"
));

    new_command("MOVE", FALSE, move_command, _(
"MOVE [!]element[<TAB>[!]element[...]] [[!]element[<TAB>[!]element[...]]]\n"
"    Moves the source element path to the destination element path. If the\n"
"    destination is not specified then it will be moved to the root of the\n"
"    document. If the destination is specified and exists then it will be\n"
"    overwritten; otherwise it will be created.\n"
));

    new_command("DELETE", FALSE, delete_command, _(
"DELETE [!]element[<TAB>[!]element[...]]\n"
"    Removes the specified element path and any children from the XML document.\n"
));

    new_command("GET", FALSE, get_command, _(
"GET [!]element[<TAB>[!]element[...]]\n"
"    Retrieves the content or XML text node of the specified element path. The\n"
"    content is returned with a data response.\n"
));

    new_command("ATTR", FALSE, attr_command, _(
"ATTR SET|GET|DELETE|LIST [<attribute>] [!]<arg1> [!][arg2]\n"
"    ATTR SET attribute [!]element[<TAB>[!]element[...]] [attribute_value]\n"
"        Stores or updates an attribute name and optional value of an element\n"
"        path.\n"
"\n"
"    ATTR DELETE attribute [!]element[<TAB>[!]element[...]]\n"
"        Removes an attribute from an element path.\n"
"\n"
"    ATTR LIST [!]element[<TAB>[!]element[...]]\n"
"        Retrieves a newline separated list of attributes names and values from\n"
"        the specified element path. The attribute names and values are space\n"
"        delimited.\n"
"\n"
"    ATTR GET attribute [!]element[<TAB>[!]element[...]]\n"
"        Retrieves the value of an attribute from an element path.\n"
"\n"
"    The \"_name\" attribute (case sensitive) cannot be removed with ATTR DELETE\n"
"    if the element path is the root element. Although it can be SET to change\n"
"    the element name but only if the destination element name doesn't exist.\n"
"    Use the RENAME command for that instead.\n"
"\n"
"    The \"_mtime\" attribute is updated each time an element is modified by\n"
"    either storing content, editing attributes or by deleting a child element.\n"
"\n"
"    Also see THE TARGET ATTRIBUTE.\n"
));

    new_command("XPATH", FALSE, xpath_command, _(
"XPATH <expression>[<TAB>[value]]\n"
"    Evaluates an XPath expression. If no value argument is specified, it is\n"
"    assumed the expression is a request to return a result. Otherwise, the\n"
"    result is set to the value argument and the document is updated. If there\n"
"    is no value after the <TAB> character, the value is assumed to be empty\n"
"    and the document is updated.\n"
));

    new_command("XPATHATTR", FALSE, xpathattr_command, _(
"XPATHATTR SET|DELETE <name> <expression>[<TAB>[<value>]]\n"
"    Like the XPATH command but operates on element attributes and won't return\n"
"    a result. For the SET operation the <value> is optional but the field is\n"
"    required in which case the value will be empty.\n"
));

    new_command("IMPORT", FALSE, import_command, _(
"IMPORT <content>[<TAB>[!]element[<TAB>[!]element[...]]]\n"
"    Like the STORE command (an INQUIRE), but the content argument is raw XML\n"
"    data. The content is created as a child of the specified element path. If\n"
"    an element of the element path does not exist then it is created. If no\n"
"    element path is specified then the content must begin with an pwmd DTD\n"
"    root element.\n"
"\n"
"    Note that the new content must begin with an XML element node. Also note\n"
"    that an existing child node of the same element name as the root node of\n"
"    the imported content will be overwritten.\n"
));

    new_command("DUMP", FALSE, dump_command, _(
"DUMP\n"
"    Shows the in memory XML document with indenting. To dump a specific\n"
"    element tree, use the XPATH command.\n"
));

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

    new_command("UNLOCK", FALSE, unlock_command, _(
"UNLOCK\n"
"    Unlocks the file mutex which was locked with the LOCK command.\n"
));

    new_command("GETPID", TRUE, getpid_command, _(
"GETPID\n"
"    Retrieves the process id of the server.\n"
));

    new_command("GETCONFIG", TRUE, getconfig_command, _(
"GETCONFIG [filename] <parameter>\n"
"    Returns the value of a pwmd configuration variable with a data response.\n"
"    If no file has been opened then the value for the specified file or the\n"
"    default from the \"global\" section will be returned. If a file has been\n"
"    opened and no filename is specified, the value previously set with the SET\n"
"    command, if any, will be returned.\n"
"\n"
"    If there is no such configuration parameter defined, GPG_ERR_UNKNOWN_OPTION\n"
"    is returned.\n"
));

    new_command("VERSION", TRUE, version_command, _(
"VERSION\n"
"    Returns the server version number and compile-time features with a data\n"
"    response with each being space delimited.\n"
));

    new_command("SET", TRUE, set_command, _(
"SET <NAME>=<VALUE>\n"
"    Sets a client option NAME to VALUE. Use the UNSET command to reset an\n"
"    option to its default value.\n"
"\n"
"    NAME             |VALUE     |Description\n"
"    -----------------|----------|----------------------------------------------\n"
"    ENABLE_PINENTRY   0|1        When 0, disable use of pinentry. The default\n"
"                                 is 1.\n"
"\n"
"                                * Deprecated. Pass --pinentry to the OPEN and\n"
"                                SAVE commands instead.\n"
"\n"
"    PINENTRY_TIMEOUT  <integer>  The number of seconds before the pinentry\n"
"                                process will terminate while waiting for a\n"
"                                passphrase. The default is 20, 0 disables.\n"
"\n"
"    PINENTRTY_PATH    <string>   Full path to the pinentry binary. The default\n"
"                                 is specified at compile time.\n"
"\n"
"    TTYNAME           <string>   Same as the --ttyname option to pinentry(1).\n"
"\n"
"    TTYTYPE           <string>   Same as the --ttytype option to pinentry(1).\n"
"\n"
"    DISPLAY           <string>   Same as the --display option to pinentry(1).\n"
"\n"
"    TITLE             <string>   Sets the title string of the pinentry dialog.\n"
"\n"
"    PROMPT            <string>   Sets the prompt string of the pinentry dialog.\n"
"\n"
"    DESC              <string>   Sets the error or description string of the\n"
"                                 pinentry dialog.\n"
"\n"
"    LC_CTYPE          <string>   Same as the --lc-ctype option to pinentry(1).\n"
"\n"
"    LC_MESSAGES       <string>   Same as the --lc-messages option to\n"
"                                 pinentry(1).\n"
"\n"
"    NAME              <string>   Associates the thread ID of the connection\n"
"                                with the specified textual representation.\n"
"                                Useful for debugging log messages.\n"
"\n"
"    CIPHER            <string>   The cipher to use for the next SAVE.\n"
"\n"
"                                * Deprecated. Use --cipher instead.\n"
"\n"
"    ITERATIONS        <integer>  The number of encryption iterations to do\n"
"                                 when the SAVE command is sent. An opened file\n"
"                                 is needed when setting this option. The\n"
"                                 CONFIG status message is sent after receiving\n"
"                                 this command.\n"
"\n"
"                                * Deprecated. Use --iterations instead.\n"
"\n"
"    LOCK_ON_OPEN      0|1        If enabled then the file mutex will be locked\n"
"                                 after a successful OPEN as if the LOCK\n"
"                                 command had been sent.\n"
"\n"
"                                * Deprecated. Use --lock instead.\n"
"\n"
"    RC_ON_LOCKED      0|1        If enabled then return an error code instead\n"
"                                of a status message when the file mutex is\n"
"                                 locked by another client.\n"
));

    new_command("UNSET", TRUE, unset_command, _(
"UNSET <NAME>\n"
"    Resets option NAME to the value specified in the server configuration\n"
"    file. Some options have no default and will be reset to NULL or 0\n"
"    depending on the value type. See the SET command for available options.\n"
));

    new_command("LS", TRUE, ls_command, _(
"LS\n"
"    Lists the contents of the configured data_directory. The result is a\n"
"    newline separated list of filenames.\n"
));

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

    new_command("BYE", TRUE, NULL, _(
"BYE\n"
"    Closes the connection discarding any unsaved changes.\n"
));

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

    /* !END-HELP-TEXT! */
    new_command("CANCEL", TRUE, NULL, NULL);
    new_command("END", TRUE, NULL, NULL);

    gint 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)
{
    gint 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);

        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);
}

gpg_error_t try_xml_decrypt(assuan_context_t ctx,
        struct crypto_s *crypto, gpointer *dst, goffset *dst_len)
{
    goffset insize, len;
    struct client_s *client = ctx ? assuan_get_pointer(ctx) : NULL;
    guint64 iter = 0, n_iter = 0, iter_progress = 0;
    gulong outsize = 0;
    gpg_error_t rc;
    gsize fh_size = crypto->fh->v1 ? sizeof(crypto->fh->ver.fh1) : sizeof(crypto->fh->ver.fh2);
    guint64 fh_iter = crypto->fh->v1 ? crypto->fh->ver.fh1.iter : crypto->fh->ver.fh2.iter;

    if (!crypto->fh->v1 && crypto->fh->ver.fh2.version < 0x221)
        fh_size -= sizeof(crypto->fh->ver.fh2.salt);

    lseek(crypto->fh->fd, fh_size, SEEK_SET);
    insize = crypto->fh->st.st_size - fh_size;
    crypto->iv = gcry_malloc(crypto->blocksize);

    if (!crypto->iv) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        return GPG_ERR_ENOMEM;
    }

    if (crypto->fh->v1)
        memcpy(crypto->iv, crypto->fh->ver.fh1.iv, crypto->blocksize);
    else
        memcpy(crypto->iv, crypto->fh->ver.fh2.iv, crypto->blocksize);

    crypto->inbuf = gcry_malloc(insize);

    if (!crypto->inbuf) {
        log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        return GPG_ERR_ENOMEM;
    }

    crypto->insize = insize;
    len = pth_read(crypto->fh->fd, crypto->inbuf, crypto->insize);

    if (len != crypto->insize)
        return GPG_ERR_INV_LENGTH;

    /* No encryption iterations. This is a plain (gzipped) file. */
    if ((crypto->fh->v1 && (long)fh_iter < 0L) ||
            (!crypto->fh->v1 && fh_iter <= 0L)) {
        /*
         * cache_file_count() needs both .used == TRUE and a valid key in
         * order for it to count as a used cache entry. Fixes CACHE status
         * messages.
         */
        memset(crypto->key, '!', KEYSIZE);
        goto decompress;
    }

    if ((rc = gcry_cipher_setiv(crypto->gh, crypto->iv, crypto->blocksize))) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    if ((rc = gcry_cipher_setkey(crypto->gh, crypto->key, crypto->keysize))) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    iter_progress = get_key_file_uint64(client && client->filename ?
            client->filename : "global", "iteration_progress");

    if (iter_progress > 0 && fh_iter >= iter_progress) {
        rc = send_status(ctx, STATUS_DECRYPT, "0 %llu", fh_iter);
        
        if (rc)
            return rc;
    }

    rc = iterate_crypto_once(client, crypto, STATUS_DECRYPT);

    if (rc)
        return rc;

    crypto->tkey = gcry_malloc(KEYSIZE);

    if (!crypto->tkey) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(GPG_ERR_ENOMEM));
        return GPG_ERR_ENOMEM;
    }

    memcpy(crypto->tkey, crypto->key, KEYSIZE);
    guchar *tkey = crypto->tkey;
    tkey[0] ^= 1;

    if ((rc = gcry_cipher_setkey(crypto->gh, crypto->tkey, crypto->keysize))) {
        log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
        return rc;
    }

    while (iter < (crypto->fh->v1 ? fh_iter : fh_iter-1)) {
        if (iter_progress > 0ULL && iter >= iter_progress) {
            if (!(iter % iter_progress)) {
                rc = send_status(ctx, STATUS_DECRYPT, "%llu %llu",
                        ++n_iter * iter_progress, fh_iter);
        
                if (rc)
                    return rc;
            }
        }

        if ((rc = gcry_cipher_setiv(crypto->gh, crypto->iv, crypto->blocksize))) {
            log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
            return rc;
        }

        rc = iterate_crypto_once(client, crypto, STATUS_DECRYPT);

        if (rc) {
            log_write("%s(%i): %s", __FUNCTION__, __LINE__, pwmd_strerror(rc));
            return rc;
        }

        iter++;
    }

    if (iter_progress && fh_iter >= iter_progress) {
        rc = send_status(ctx, STATUS_DECRYPT, "%llu %llu", fh_iter, fh_iter);

        if (rc)
            return rc;
    }

decompress:
    if (!crypto->fh->v1 && crypto->fh->ver.fh2.version >= 0x218) {
        len = 0;

        if (crypto->fh->ver.fh2.iter > 0ULL) {
            if (memcmp(crypto->inbuf, crypto_magic, sizeof(crypto_magic)))
                return GPG_ERR_INV_PASSPHRASE;

            len = sizeof(crypto_magic);
        }

        rc = do_decompress(ctx, (guchar *)crypto->inbuf+len, crypto->insize-len,
                    (gpointer *)&crypto->outbuf, &outsize);

        if (rc)
            return rc;
    }
    else {
        rc = do_decompress(ctx, crypto->inbuf, crypto->insize,
                    (gpointer *)&crypto->outbuf, &outsize);

        if (rc == GPG_ERR_ENOMEM)
            return rc;
        else if (rc)
            return GPG_ERR_INV_PASSPHRASE; // Not a valid gzip header. Must be a bad key.

        if (g_strncasecmp(crypto->outbuf, "<?xml ", 6) != 0) {
            gcry_free(crypto->outbuf);
            crypto->outbuf = NULL;
            return GPG_ERR_INV_PASSPHRASE;
        }
    }

    if (ctx) {
        client->xml = crypto->outbuf;
        client->len = outsize;
        crypto->outbuf = NULL;
    }
    else if (dst) {
        *dst = crypto->outbuf;
        *dst_len = outsize;
        crypto->outbuf = NULL;
    }

    /* The calling function should free the crypto struct. */
    return 0;
}