src/commands.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2007 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <err.h>
  23 #include <errno.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <ctype.h>
  28 #include <glib.h>
  29 #include <glib/gprintf.h>
  30 #include <gcrypt.h>
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35
  36 #ifdef HAVE_ZLIB_H
  37 #include <zlib.h>
  38 #endif
  39
  40 #ifndef MEM_DEBUG
  41 #include "mem.h"
  42 #endif
  43
  44 #include "xml.h"
  45 #include "common.h"
  46 #include "pwmd_error.h"
  47 #include "cache.h"
  48 #include "commands.h"
  49
  50 static void *z_alloc(void *data, unsigned items, unsigned size)
  51 {
  52 #ifndef MEM_DEBUG
  53     return gcry_calloc(items, size);
  54 #else
  55     return calloc(items, size);
  56 #endif
  57 }
  58
  59 static void z_free(void *data, void *p)
  60 {
  61 #ifndef MEM_DEBUG
  62     gcry_free(p);
  63 #else
  64     free(p);
  65 #endif
  66 }
  67
  68 static gpg_error_t file_modified(struct client_s *client)
  69 {
  70     struct stat st;
  71
  72     if (client->state != STATE_OPEN)
  73         return EPWMD_NO_FILE;
  74
  75     if (stat(client->filename, &st) == 0 && client->mtime) {
  76         if (client->mtime != st.st_mtime)
  77             return EPWMD_FILE_MODIFIED;
  78     }
  79
  80     return 0;
  81 }
  82
  83 static gboolean encrypt_xml(gcry_cipher_hd_t gh, void *outbuf, gsize outsize,
  84         void *inbuf, gsize insize)
  85 {
  86     gpg_error_t rc;
  87
  88     if ((rc = gcry_cipher_encrypt(gh, outbuf, outsize, inbuf, insize))) {
  89         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
  90         return FALSE;
  91     }
  92
  93     return TRUE;
  94 }
  95
  96 gpg_error_t decrypt_xml(gcry_cipher_hd_t gh, void *outbuf, gsize outsize,
  97         void *inbuf, gsize insize)
  98 {
  99     gpg_error_t rc;
 100
 101     if ((rc = gcry_cipher_decrypt(gh, outbuf, outsize, inbuf, insize)))
 102         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 103
 104     return rc;
 105 }
 106
 107 static gpg_error_t parse_xml(assuan_context_t ctx)
 108 {
 109     struct client_s *client = assuan_get_pointer(ctx);
 110
 111     client->doc = xmlReadMemory(client->xml, client->len, NULL, "UTF-8", XML_PARSE_NOBLANKS);
 112
 113     if (!client->doc)
 114         return EPWMD_LIBXML_ERROR;
 115
 116     return 0;
 117 }
 118
 119 gboolean valid_filename(const gchar *filename)
 120 {
 121     const gchar *p;
 122
 123     if (!filename || !*filename)
 124         return FALSE;
 125
 126     for (p = filename; *p; p++) {
 127         if (g_ascii_isalnum(*p) == FALSE && *p != '-' && *p != '_' && *p != '.')
 128             return FALSE;
 129     }
 130
 131     return TRUE;
 132 }
 133
 134 gint open_file(const gchar *filename, struct stat *st)
 135 {
 136     gint fd;
 137
 138     if ((fd = open(filename, O_RDONLY)) == -1)
 139         return -1;
 140
 141     if (stat(filename, st) == -1) {
 142         close(fd);
 143         return -1;
 144     }
 145
 146     return fd;
 147 }
 148
 149 void unlock_file_mutex(struct client_s *client)
 150 {
 151     pth_mutex_t *m;
 152
 153     if (client->has_lock == FALSE)
 154         return;
 155
 156     CACHE_LOCK(client->ctx);
 157
 158     if (cache_get_mutex(client->md5file, &m) == FALSE) {
 159         CACHE_UNLOCK;
 160         return;
 161     }
 162
 163     CACHE_UNLOCK;
 164     pth_mutex_release(m);
 165     client->has_lock = FALSE;
 166 }
 167
 168 gpg_error_t lock_file_mutex(struct client_s *client)
 169 {
 170     pth_mutex_t *m;
 171
 172     if (client->has_lock == TRUE)
 173         return 0;
 174
 175     CACHE_LOCK(client->ctx);
 176
 177     if (cache_get_mutex(client->md5file, &m) == FALSE) {
 178         CACHE_UNLOCK;
 179         return 0;
 180     }
 181
 182     CACHE_UNLOCK;
 183
 184     if (pth_mutex_acquire(m, TRUE, NULL) == FALSE) {
 185         if (errno == EBUSY) {
 186             if (client->ctx)
 187                 assuan_write_status(client->ctx, "LOCKED", N_("Waiting for lock"));
 188
 189             pth_mutex_acquire(m, FALSE, NULL);
 190         }
 191         else {
 192             gint e = errno;
 193             log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(errno));
 194             return gpg_error_from_errno(e);
 195         }
 196     }
 197
 198     client->has_lock = TRUE;
 199     return 0;
 200 }
 201
 202 static void cleanup_client(struct client_s *client)
 203 {
 204     assuan_context_t ctx = client->ctx;
 205
 206     unlock_file_mutex(client);
 207     CACHE_LOCK(client->ctx);
 208     cache_decr_refcount(client->md5file);
 209
 210     /*
 211      * This may be a new file so don't use a cache slot. save_command() will
 212      * set this to FALSE on success.
 213      */
 214     if (client->new == TRUE)
 215         cache_clear(client->md5file, 1);
 216
 217     if (client->doc)
 218         xmlFreeDoc(client->doc);
 219
 220     if (client->xml)
 221         gcry_free(client->xml);
 222
 223     if (client->filename)
 224         g_free(client->filename);
 225
 226     if (client->gh)
 227         gcry_cipher_close(client->gh);
 228
 229     memset(client, 0, sizeof(struct client_s));
 230     client->state = STATE_CONNECTED;
 231     client->ctx = ctx;
 232     client->freed = TRUE;
 233     CACHE_UNLOCK;
 234 }
 235
 236 static gchar *print_fmt(const char *fmt, ...)
 237 {
 238     va_list ap;
 239     static gchar buf[ASSUAN_LINELENGTH] = {0};
 240
 241     va_start(ap, fmt);
 242     vsnprintf(buf, sizeof(buf), fmt, ap);
 243     va_end(ap);
 244     return buf;
 245 }
 246
 247 gboolean do_decompress(assuan_context_t ctx, gpointer in, gint insize,
 248         gpointer *out, glong *outsize, gint *error)
 249 {
 250     z_stream z;
 251     gint ret;
 252     gpointer pout;
 253     gz_header h;
 254     gchar buf[17];
 255     gpg_error_t rc;
 256
 257     z.zalloc = z_alloc;
 258     z.zfree = z_free;
 259     z.next_in = in;
 260     z.avail_in = insize;
 261     z.avail_out = zlib_bufsize;
 262     z.next_out = pout = g_malloc(zlib_bufsize);
 263
 264     if (!pout) {
 265         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 266         *error = Z_MEM_ERROR;
 267         return FALSE;
 268     }
 269
 270     ret = inflateInit2(&z, 47);
 271
 272     if (ret != Z_OK) {
 273         log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 274         g_free(pout);
 275         return FALSE;
 276     }
 277
 278     memset(&h, 0, sizeof(gz_header));
 279     h.comment = (guchar *)buf;
 280     h.comm_max = sizeof(buf);
 281     ret = inflateGetHeader(&z, &h);
 282
 283     if (ret != Z_OK) {
 284         log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 285         g_free(pout);
 286         inflateEnd(&z);
 287         return FALSE;
 288     }
 289
 290     ret = inflate(&z, Z_BLOCK);
 291
 292     if (ret != Z_OK) {
 293         log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 294         g_free(pout);
 295         inflateEnd(&z);
 296         return FALSE;
 297     }
 298
 299     if (h.comment)
 300         insize = atoi((gchar *)h.comment);
 301
 302     do {
 303         gpointer p;
 304
 305         ret = inflate(&z, Z_FINISH);
 306
 307         switch (ret) {
 308             case Z_OK:
 309                 break;
 310             case Z_BUF_ERROR:
 311                 if (!z.avail_out) {
 312                     p = g_realloc(pout, z.total_out + zlib_bufsize);
 313
 314                     if (!p) {
 315                         ret = Z_MEM_ERROR;
 316                         goto fail;
 317                     }
 318
 319                     pout = p;
 320                     z.next_out = pout + z.total_out;
 321                     z.avail_out = zlib_bufsize;
 322
 323                     if (ctx) {
 324                         rc = assuan_write_status(ctx, "DECOMPRESS",
 325                                 print_fmt("%i %i", z.total_out, insize));
 326
 327                         if (rc) {
 328                             ret = rc;
 329                             goto fail;
 330                         }
 331                     }
 332                 }
 333                 break;
 334             case Z_STREAM_END:
 335                 break;
 336             default:
 337                 goto fail;
 338                 break;
 339         }
 340
 341         pth_yield(NULL);
 342     } while (ret != Z_STREAM_END);
 343
 344     if (ctx) {
 345         rc = assuan_write_status(ctx, "DECOMPRESS",
 346                 print_fmt("%i %i", z.total_out, insize));
 347
 348         if (rc) {
 349             ret = rc;
 350             goto fail;
 351         }
 352     }
 353
 354     *out = pout;
 355     *outsize = z.total_out;
 356     inflateEnd(&z);
 357     return TRUE;
 358
 359 fail:
 360     log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 361     *error = ret;
 362     g_free(pout);
 363     inflateEnd(&z);
 364     return FALSE;
 365 }
 366
 367 static int open_command(assuan_context_t ctx, char *line)
 368 {
 369     gint fd;
 370     struct stat st;
 371     guchar shakey[gcrykeysize];
 372     gint cached = 0;
 373     gint timeout;
 374     gpg_error_t error;
 375     struct client_s *client = assuan_get_pointer(ctx);
 376     gchar **req;
 377     gchar *filename = NULL;
 378
 379     if ((req = split_input_line(line, " ", 2)) != NULL)
 380         filename = req[0];
 381
 382     if (!filename || !*filename) {
 383         g_strfreev(req);
 384         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
 385     }
 386
 387     if (valid_filename(filename) == FALSE) {
 388         g_strfreev(req);
 389         return send_error(ctx, EPWMD_INVALID_FILENAME);
 390     }
 391
 392     if (client->state == STATE_OPEN)
 393         cleanup_client(client);
 394
 395     gcry_md_hash_buffer(GCRY_MD_MD5, client->md5file, filename, strlen(filename));
 396     CACHE_LOCK(client->ctx);
 397
 398     if (cache_has_file(client->md5file) == FALSE) {
 399         if (cache_add_file(client->md5file, NULL) == FALSE) {
 400             g_strfreev(req);
 401             CACHE_UNLOCK;
 402             return send_error(ctx, EPWMD_MAX_SLOTS);
 403         }
 404     }
 405
 406     cache_incr_refcount(client->md5file);
 407     CACHE_UNLOCK;
 408     error = lock_file_mutex(client);
 409
 410     if (error) {
 411         g_strfreev(req);
 412         return send_error(ctx, error);
 413     }
 414
 415     client->freed = FALSE;
 416
 417     if ((error = gcry_cipher_open(&client->gh, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC, 0))) {
 418         g_strfreev(req);
 419         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
 420         cleanup_client(client);
 421         return send_error(ctx, error);
 422     }
 423
 424     if (stat(filename, &st) == 0) {
 425         if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
 426             log_write("%s: %s", filename, pwmd_strerror(EPWMD_INVALID_FILENAME));
 427             g_strfreev(req);
 428             cleanup_client(client);
 429             return send_error(ctx, EPWMD_INVALID_FILENAME);
 430         }
 431
 432         client->mtime = st.st_mtime;
 433     }
 434
 435     /*
 436      * New files don't need a key.
 437      */
 438     if (access(filename, R_OK|W_OK) != 0) {
 439         if (errno != ENOENT) {
 440             error = errno;
 441             log_write("%s: %s", filename, strerror(errno));
 442             g_strfreev(req);
 443             cleanup_client(client);
 444             return send_syserror(ctx, error);
 445         }
 446 new_doc:
 447         if ((client->xml = new_document()) == NULL) {
 448             log_write("%s", strerror(ENOMEM));
 449             g_strfreev(req);
 450             cleanup_client(client);
 451             return send_syserror(ctx, ENOMEM);
 452         }
 453
 454         client->len = xmlStrlen(client->xml);
 455         client->new = TRUE;
 456         client->filename = g_strdup(filename);
 457
 458         if (!client->filename) {
 459             g_strfreev(req);
 460             cleanup_client(client);
 461             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 462             return send_syserror(ctx, ENOMEM);
 463         }
 464
 465         if (req[1] && *req[1]) {
 466             gcry_md_hash_buffer(GCRY_MD_SHA256, shakey, req[1], strlen(req[1]));
 467             memset(req[1], 0, strlen(req[1]));
 468             goto update_cache;
 469         }
 470
 471         goto done;
 472     }
 473
 474     if ((fd = open_file(filename, &st)) == -1) {
 475         error = errno;
 476         log_write("%s: %s", filename, strerror(errno));
 477         g_strfreev(req);
 478         cleanup_client(client);
 479         return send_syserror(ctx, error);
 480     }
 481
 482     if (st.st_size == 0)
 483         goto new_doc;
 484
 485     CACHE_LOCK(client->ctx);
 486
 487     if (cache_get_key(client->md5file, shakey) == TRUE)
 488         cached = 1;
 489     else {
 490         /*
 491          * No key specified and no matching filename found in the cache.
 492          */
 493         if (!req[1] || !*req[1]) {
 494             close(fd);
 495             g_strfreev(req);
 496             cleanup_client(client);
 497             CACHE_UNLOCK;
 498             return send_error(ctx, EPWMD_KEY);
 499         }
 500     }
 501
 502     CACHE_UNLOCK;
 503
 504     if (!cached) {
 505         gcry_md_hash_buffer(GCRY_MD_SHA256, shakey, req[1], strlen(req[1]));
 506         memset(req[1], 0, strlen(req[1]));
 507     }
 508
 509     error = try_xml_decrypt(ctx, fd, st, shakey);
 510
 511     if (error) {
 512         close(fd);
 513         memset(shakey, 0, sizeof(shakey));
 514         g_strfreev(req);
 515         cleanup_client(client);
 516         return send_error(ctx, error);
 517     }
 518
 519     close(fd);
 520     client->filename = g_strdup(filename);
 521
 522     if (!client->filename) {
 523         memset(shakey, 0, sizeof(shakey));
 524         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 525         g_strfreev(req);
 526         cleanup_client(client);
 527         return send_syserror(ctx, ENOMEM);
 528     }
 529
 530 update_cache:
 531     CACHE_LOCK(client->ctx);
 532
 533     if (!cached) {
 534         if (cache_update_key(client->md5file, shakey) == FALSE) {
 535             memset(shakey, 0, sizeof(shakey));
 536             log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(EPWMD_MAX_SLOTS));
 537             g_strfreev(req);
 538             cleanup_client(client);
 539             CACHE_UNLOCK;
 540             return send_error(ctx, EPWMD_MAX_SLOTS);
 541         }
 542
 543         timeout = get_key_file_integer(client->filename, "cache_timeout");
 544         cache_reset_timeout(client->md5file, timeout);
 545     }
 546     else
 547         cache_set_timeout(client->md5file, -2);
 548
 549     CACHE_UNLOCK;
 550     memset(shakey, 0, sizeof(shakey));
 551
 552 done:
 553     g_strfreev(req);
 554     error = parse_xml(ctx);
 555
 556     if (client->xml) {
 557         gcry_free(client->xml);
 558         client->xml = NULL;
 559     }
 560
 561     if (error == 0) {
 562         if (client->new == FALSE)
 563             send_cache_status_all();
 564
 565         client->state = STATE_OPEN;
 566     }
 567
 568     return send_error(ctx, error);
 569 }
 570
 571 gboolean do_compress(assuan_context_t ctx, gint level, gpointer data,
 572         gint size, gpointer *out, glong *outsize, gint *error)
 573 {
 574     z_stream z;
 575     gpointer pout, pin;
 576     gint ret;
 577     gz_header h;
 578     gchar buf[17];
 579     gint cmd = Z_NO_FLUSH;
 580     gpg_error_t rc;
 581
 582     z.zalloc = z_alloc;
 583     z.zfree = z_free;
 584     z.next_in = pin = data;
 585     z.avail_in = size < zlib_bufsize ? size : zlib_bufsize;
 586     z.avail_out = zlib_bufsize;
 587     z.next_out = pout = g_malloc(zlib_bufsize);
 588
 589     if (!pout) {
 590         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 591         *error = Z_MEM_ERROR;
 592         return FALSE;
 593     }
 594
 595     ret = deflateInit2(&z, level, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY);
 596
 597     if (ret != Z_OK) {
 598         log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 599         *error = ret;
 600         g_free(pout);
 601         return FALSE;
 602     }
 603
 604     memset(&h, 0, sizeof(gz_header));
 605     snprintf(buf, sizeof(buf), "%i", size);
 606     h.comment = (guchar *)buf;
 607     ret = deflateSetHeader(&z, &h);
 608
 609     if (ret != Z_OK) {
 610         log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 611         *error = ret;
 612         g_free(pout);
 613         deflateEnd(&z);
 614         return FALSE;
 615     }
 616
 617     do {
 618         gpointer p;
 619
 620         ret = deflate(&z, cmd);
 621
 622         switch (ret) {
 623             case Z_OK:
 624                 break;
 625             case Z_BUF_ERROR:
 626                 if (!z.avail_out) {
 627                     p = g_realloc(pout, z.total_out + zlib_bufsize);
 628
 629                     if (!p) {
 630                         ret = Z_MEM_ERROR;
 631                         goto fail;
 632                     }
 633
 634                     pout = p;
 635                     z.next_out = pout + z.total_out;
 636                     z.avail_out = zlib_bufsize;
 637                 }
 638
 639                 if (!z.avail_in && z.total_in < size) {
 640                     if (z.total_in + zlib_bufsize > size)
 641                         z.avail_in = size - z.total_in;
 642                     else
 643                         z.avail_in = zlib_bufsize;
 644
 645                     if (ctx) {
 646                         rc = assuan_write_status(ctx, "COMPRESS",
 647                                 print_fmt("%i %i", z.total_in, size));
 648
 649                         if (rc) {
 650                             ret = rc;
 651                             goto fail;
 652                         }
 653                     }
 654                 }
 655
 656                 if (z.total_in >= size)
 657                     cmd = Z_FINISH;
 658
 659                 break;
 660             case Z_STREAM_END:
 661                 break;
 662             default:
 663                 goto fail;
 664         }
 665
 666         pth_yield(NULL);
 667     } while (ret != Z_STREAM_END);
 668
 669     if (ctx) {
 670         rc = assuan_write_status(ctx, "COMPRESS",
 671                 print_fmt("%i %i", z.total_in, size));
 672
 673         if (rc) {
 674             ret = rc;
 675             goto fail;
 676         }
 677     }
 678
 679     *out = pout;
 680     *outsize = z.total_out;
 681     deflateEnd(&z);
 682     return TRUE;
 683
 684 fail:
 685     log_write("%s(%i): %s", __FUNCTION__, __LINE__, z.msg);
 686     *error = ret;
 687     g_free(pout);
 688     deflateEnd(&z);
 689     return FALSE;
 690 }
 691
 692 gpg_error_t do_xml_encrypt(struct client_s *client, gcry_cipher_hd_t gh,
 693         const gchar *filename, gpointer data, size_t insize,
 694         const guchar *shakey, guint iter)
 695 {
 696     gsize len = insize;
 697     gint fd;
 698     gpointer inbuf;
 699     guchar tkey[gcrykeysize];
 700     gchar *p;
 701     gint error;
 702     gpg_error_t rc;
 703     guint iter_progress = 0, n_iter = 0, xiter = 0;
 704     gchar tmp[FILENAME_MAX];
 705     struct file_header_s {
 706         guint iter;
 707         guchar iv[gcryblocksize];
 708     } file_header;
 709
 710     if (insize / gcryblocksize) {
 711         len = (insize / gcryblocksize) * gcryblocksize;
 712
 713         if (insize % gcryblocksize)
 714             len += gcryblocksize;
 715     }
 716
 717     /*
 718      * Resize the existing xml buffer to the block size required by gcrypt
 719      * rather than duplicating it and wasting memory.
 720      */
 721     inbuf = gcry_realloc(data, len);
 722
 723     if (!inbuf)
 724         return gpg_error_from_errno(ENOMEM);
 725
 726     insize = len;
 727     gcry_create_nonce(file_header.iv, sizeof(file_header.iv));
 728     memcpy(tkey, shakey, sizeof(tkey));
 729     tkey[0] ^= 1;
 730
 731     if ((rc = gcry_cipher_setkey(gh, tkey, gcrykeysize))) {
 732         gcry_free(inbuf);
 733         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 734         return rc;
 735     }
 736
 737     file_header.iter = iter;
 738
 739     if (client)
 740         iter_progress = get_key_file_integer("default", "iteration_progress");
 741
 742     if (client && iter_progress && file_header.iter >= iter_progress) {
 743         error = assuan_write_status(client->ctx, "ENCRYPT", "0");
 744
 745         if (error) {
 746             gcry_free(inbuf);
 747             return error;
 748         }
 749     }
 750
 751     while (xiter < file_header.iter) {
 752         if (client && iter_progress > 0 && xiter >= iter_progress) {
 753             if (!(xiter % iter_progress)) {
 754                 error = assuan_write_status(client->ctx, "ENCRYPT", print_fmt("%i",
 755                             ++n_iter * iter_progress));
 756
 757                 if (error) {
 758                     gcry_free(inbuf);
 759                     return error;
 760                 }
 761             }
 762         }
 763
 764         if ((rc = gcry_cipher_setiv(gh, file_header.iv,
 765                         sizeof(file_header.iv)))) {
 766             gcry_free(inbuf);
 767             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 768             return rc;
 769         }
 770
 771         if (encrypt_xml(gh, inbuf, insize, NULL, 0)
 772                 == FALSE) {
 773             gcry_free(inbuf);
 774             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 775             return rc;
 776         }
 777
 778         xiter++;
 779         pth_yield(NULL);
 780     }
 781
 782     if ((rc = gcry_cipher_setiv(gh, file_header.iv,
 783                     sizeof(file_header.iv)))) {
 784         gcry_free(inbuf);
 785         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 786         return rc;
 787     }
 788
 789     if ((rc = gcry_cipher_setkey(gh, shakey, gcrykeysize))) {
 790         gcry_free(inbuf);
 791         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 792         return rc;
 793     }
 794
 795     if (encrypt_xml(gh, inbuf, insize, NULL, 0) == FALSE) {
 796         gcry_free(inbuf);
 797         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(rc));
 798         return rc;
 799     }
 800
 801     if (client && iter_progress && file_header.iter >= iter_progress) {
 802         error = assuan_write_status(client->ctx, "ENCRYPT",
 803                 print_fmt("%i", file_header.iter));
 804
 805         if (error) {
 806             gcry_free(inbuf);
 807             return error;
 808         }
 809     }
 810
 811     if (filename) {
 812         g_snprintf(tmp, sizeof(tmp), ".%s.tmp", filename);
 813
 814         if ((fd = open(tmp, O_WRONLY|O_CREAT|O_TRUNC, 0600)) == -1) {
 815             error = errno;
 816             gcry_free(inbuf);
 817             p = strrchr(tmp, '/');
 818             p++;
 819             log_write("%s: %s", p, strerror(errno));
 820             return gpg_error_from_errno(error);
 821         }
 822     }
 823     else
 824         /*
 825          * xml_import() from command line.
 826          */
 827         fd = STDOUT_FILENO;
 828
 829     len = pth_write(fd, &file_header, sizeof(struct file_header_s));
 830
 831     if (len != sizeof(file_header)) {
 832         len = errno;
 833
 834         if (filename)
 835             close(fd);
 836
 837         gcry_free(inbuf);
 838         return gpg_error_from_errno(len);
 839     }
 840
 841     len = pth_write(fd, inbuf, insize);
 842
 843     if (len != insize) {
 844         len = errno;
 845
 846         if (filename)
 847             close(fd);
 848
 849         gcry_free(inbuf);
 850         return gpg_error_from_errno(len);
 851     }
 852
 853     if (fsync(fd) == -1) {
 854         len = errno;
 855         close(fd);
 856         gcry_free(inbuf);
 857         return gpg_error_from_errno(len);
 858     }
 859
 860     if (filename) {
 861         struct stat st;
 862         mode_t mode = 0;
 863
 864         close(fd);
 865
 866         if (stat(filename, &st) == 0)
 867             mode = st.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO);
 868
 869         if (rename(tmp, filename) == -1) {
 870             len = errno;
 871             gcry_free(inbuf);
 872             return gpg_error_from_errno(len);
 873         }
 874
 875         if (mode)
 876             chmod(filename, mode);
 877     }
 878
 879     gcry_free(inbuf);
 880     return 0;
 881 }
 882
 883 static int save_command(assuan_context_t ctx, char *line)
 884 {
 885     gpointer xmlbuf;
 886     xmlChar *p;
 887     gint len;
 888     gint cached = 0;
 889     guchar shakey[gcrykeysize];
 890     gint iter;
 891     struct stat st;
 892     struct client_s *client = assuan_get_pointer(ctx);
 893     gpg_error_t error;
 894     gint timeout;
 895     gpointer outbuf;
 896     glong outsize = 0;
 897     gint zerror;
 898
 899     error = file_modified(client);
 900
 901     if (error) {
 902         log_write("%s: %s", client->filename ? client->filename : "",
 903                 pwmd_strerror(error));
 904         return send_error(ctx, error);
 905     }
 906
 907     error = lock_file_mutex(client);
 908
 909     if (error)
 910         return send_error(ctx, error);
 911
 912     if (stat(client->filename, &st) == -1 && errno != ENOENT)
 913         return send_syserror(ctx, errno);
 914
 915     if (errno != ENOENT && !S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
 916         log_write("%s: %s", client->filename, pwmd_strerror(EPWMD_INVALID_FILENAME));
 917         return send_error(ctx, EPWMD_INVALID_FILENAME);
 918     }
 919
 920     if (!line || !*line) {
 921         CACHE_LOCK(ctx);
 922
 923         if (cache_get_key(client->md5file, shakey) == FALSE) {
 924             CACHE_UNLOCK;
 925             return send_error(ctx, EPWMD_KEY);
 926         }
 927
 928         CACHE_UNLOCK;
 929         cached = 1;
 930     }
 931     else {
 932         gcry_md_hash_buffer(GCRY_MD_SHA256, shakey, line, strlen(line));
 933         memset(line, 0, strlen(line));
 934     }
 935
 936     xmlDocDumpFormatMemory(client->doc, &p, &len, 0);
 937     xmlbuf = p;
 938
 939     iter = get_key_file_integer(client->filename, "compression_level");
 940
 941     if (iter < 0)
 942         iter = 0;
 943
 944     if (do_compress(ctx, iter, xmlbuf, len, &outbuf, &outsize, &zerror) == FALSE) {
 945         memset(shakey, 0, sizeof(shakey));
 946         xmlFree(xmlbuf);
 947
 948         if (zerror == Z_MEM_ERROR) {
 949             return send_syserror(ctx, ENOMEM);
 950         }
 951         else
 952             return send_error(ctx, GPG_ERR_COMPR_ALGO);
 953     }
 954     else {
 955         gcry_free(xmlbuf);
 956         xmlbuf = outbuf;
 957         len = outsize;
 958     }
 959
 960     if ((iter = get_key_file_integer(client->filename, "iterations")) == -1)
 961         iter = 0;
 962
 963     error = do_xml_encrypt(client, client->gh, client->filename, xmlbuf, len, shakey, iter);
 964
 965     if (error) {
 966         memset(shakey, 0, sizeof(shakey));
 967         return send_error(ctx, error);
 968     }
 969
 970     stat(client->filename, &st);
 971     client->mtime = st.st_mtime;
 972     timeout = get_key_file_integer(client->filename, "cache_timeout");
 973     CACHE_LOCK(client->ctx);
 974
 975     if (cached) {
 976         memset(shakey, 0, sizeof(shakey));
 977         cache_reset_timeout(client->md5file, timeout);
 978         CACHE_UNLOCK;
 979
 980         if (client->new == TRUE)
 981             send_cache_status_all();
 982
 983         client->new = FALSE;
 984         return send_error(ctx, 0);
 985     }
 986
 987     if (cache_update_key(client->md5file, shakey) == FALSE) {
 988         memset(shakey, 0, sizeof(shakey));
 989         log_write("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror(EPWMD_MAX_SLOTS));
 990         CACHE_UNLOCK;
 991         return send_error(ctx, EPWMD_MAX_SLOTS);
 992     }
 993
 994     client->new = FALSE;
 995     memset(shakey, 0, sizeof(shakey));
 996     cache_reset_timeout(client->md5file, timeout);
 997     CACHE_UNLOCK;
 998     send_cache_status_all();
 999     return send_error(ctx, 0);
1000 }
1001
1002 static gboolean contains_whitespace(const gchar *str)
1003 {
1004     const gchar *p = str;
1005     gunichar c;
1006     glong len;
1007
1008     len = g_utf8_strlen(p++, -1) -1;
1009
1010     while (len--) {
1011         c = g_utf8_get_char(p++);
1012
1013         if (g_unichar_isspace(c))
1014             return TRUE;
1015     }
1016
1017     return FALSE;
1018 }
1019
1020 static int delete_command(assuan_context_t ctx, char *line)
1021 {
1022     struct client_s *client = assuan_get_pointer(ctx);
1023     gchar **req;
1024     gpg_error_t error;
1025     xmlNodePtr n;
1026
1027     error = file_modified(client);
1028
1029     if (error) {
1030         log_write("%s: %s", client->filename ? client->filename : "",
1031                 pwmd_strerror(error));
1032         return send_error(ctx, error);
1033     }
1034
1035     if (strchr(line, '\t'))
1036         req = split_input_line(line, "\t", -1);
1037     else
1038         req = split_input_line(line, " ", -1);
1039
1040     if (!req || !*req)
1041         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1042
1043     n = find_account(client->doc, &req, &error, NULL, 0);
1044
1045     if (!n) {
1046         g_strfreev(req);
1047         return send_error(ctx, error);
1048     }
1049
1050     /*
1051      * No sub-node defined. Remove the entire node (account).
1052      */
1053     if (!req[1]) {
1054         if (n) {
1055             xmlUnlinkNode(n);
1056             xmlFreeNode(n);
1057         }
1058
1059         g_strfreev(req);
1060         return send_error(ctx, 0);
1061     }
1062
1063     n = find_elements(client->doc, n->children, req+1, &error, NULL, NULL, NULL, FALSE, 0, NULL);
1064     g_strfreev(req);
1065
1066     if (!n)
1067         return send_error(ctx, error);
1068
1069     if (n) {
1070         xmlUnlinkNode(n);
1071         xmlFreeNode(n);
1072     }
1073
1074     return send_error(ctx, 0);
1075 }
1076
1077 /*
1078  * Don't return with assuan_process_done() here. This has been called from
1079  * assuan_process_next() and the command should be finished in
1080  * client_thread().
1081  */
1082 static int store_command_finalize(gpointer data, gint rc, guchar *line,
1083         gsize len)
1084 {
1085     assuan_context_t ctx = data;
1086     struct client_s *client = assuan_get_pointer(ctx);
1087     gchar **req;
1088     guchar *result = line;
1089     xmlNodePtr n;
1090     gpg_error_t error = file_modified(client);
1091
1092     if (rc) {
1093         if (line)
1094 #ifndef MEM_DEBUG
1095             xfree(line);
1096 #else
1097             free(line);
1098 #endif
1099         return rc;
1100     }
1101
1102     req = split_input_line((gchar *)result, "\t", 0);
1103 #ifndef MEM_DEBUG
1104     xfree(line);
1105 #else
1106     free(line);
1107 #endif
1108
1109     if (rc) {
1110         if (req)
1111             g_strfreev(req);
1112
1113         return rc;
1114     }
1115
1116     if (!req || !*req)
1117         return EPWMD_COMMAND_SYNTAX;
1118
1119     if (valid_xml_element((xmlChar *)*req) == FALSE) {
1120         g_strfreev(req);
1121         return EPWMD_INVALID_ELEMENT;
1122     }
1123
1124     if (valid_element_path(req+1, TRUE) == FALSE) {
1125         g_strfreev(req);
1126         return EPWMD_INVALID_ELEMENT;
1127     }
1128
1129 again:
1130     n = find_account(client->doc, &req, &error, NULL, 0);
1131
1132     if (error && error == EPWMD_ELEMENT_NOT_FOUND) {
1133         error = new_account(client->doc, *req);
1134
1135         if (error) {
1136             g_strfreev(req);
1137             return error;
1138         }
1139
1140         goto again;
1141     }
1142
1143     if (!n) {
1144         g_strfreev(req);
1145         return error;
1146     }
1147
1148     if (req[1]) {
1149         if (!n->children)
1150             create_elements_cb(n, req+1, &error, NULL);
1151         else
1152             find_elements(client->doc, n->children, req+1, &error,
1153                     NULL, NULL, create_elements_cb, FALSE, 0, NULL);
1154     }
1155
1156     g_strfreev(req);
1157     client->inquire_status = INQUIRE_DONE;
1158     return error;
1159 }
1160
1161 static int store_command(assuan_context_t ctx, char *line)
1162 {
1163     struct client_s *client = assuan_get_pointer(ctx);
1164     gpg_error_t error = file_modified(client);
1165
1166     if (error) {
1167         log_write("%s: %s", client->filename ? client->filename : "",
1168                 pwmd_strerror(error));
1169         return send_error(ctx, error);
1170     }
1171
1172     error = assuan_inquire_ext(ctx, "STORE", 0, store_command_finalize, ctx);
1173
1174     if (error)
1175         return send_error(ctx, error);
1176
1177     /* Don't return with assuan_process_done() here. This is an INQUIRE. */
1178     client->inquire_status = INQUIRE_BUSY;
1179     return 0;
1180 }
1181
1182 static int get_command(assuan_context_t ctx, char *line)
1183 {
1184     struct client_s *client = assuan_get_pointer(ctx);
1185     gchar **req;
1186     gpg_error_t error;
1187     xmlNodePtr n;
1188
1189     error = file_modified(client);
1190
1191     if (error) {
1192         log_write("%s: %s", client->filename ? client->filename : "",
1193                 pwmd_strerror(error));
1194         return send_error(ctx, error);
1195     }
1196
1197     req = split_input_line(line, "\t", -1);
1198
1199     if (!req || !*req) {
1200         g_strfreev(req);
1201         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1202     }
1203
1204     n = find_account(client->doc, &req, &error, NULL, 0);
1205
1206     if (!n) {
1207         g_strfreev(req);
1208         return send_error(ctx, error);
1209     }
1210
1211     if (req[1])
1212         n = find_elements(client->doc, n->children, req+1, &error, NULL, NULL, NULL, FALSE, 0, NULL);
1213
1214     g_strfreev(req);
1215
1216     if (error)
1217         return send_error(ctx, error);
1218
1219     if (!n || !n->children)
1220         return send_error(ctx, EPWMD_EMPTY_ELEMENT);
1221
1222     n = n->children;
1223
1224     if (!n || !n->content || !*n->content)
1225         return send_error(ctx, EPWMD_EMPTY_ELEMENT);
1226
1227     error = assuan_send_data(ctx, n->content, xmlStrlen(n->content));
1228     return send_error(ctx, error);
1229 }
1230
1231 static gchar *element_path_to_req(const gchar *account, xmlChar *path)
1232 {
1233     xmlChar *p = path;
1234     gint n;
1235     gchar *buf;
1236
1237     if (!p)
1238         return NULL;
1239
1240     for (n = 0; *p && n < 3; p++) {
1241         if (*p == '/')
1242             n++;
1243     }
1244
1245     if (strstr((gchar *)p, "text()") != NULL)
1246         p[xmlStrlen(p) - 7] = 0;
1247
1248     for (n = 0; p[n]; n++) {
1249         if (p[n] == '/')
1250             p[n] = '\t';
1251     }
1252
1253     buf = g_strdup_printf("%s\t%s", account, p);
1254     return buf;
1255 }
1256
1257 gboolean strv_printf(gchar ***array, const gchar *fmt, ...)
1258 {
1259     gchar **a;
1260     va_list ap;
1261     gchar *buf;
1262     gint len = *array ? g_strv_length(*array) : 0;
1263     gint ret;
1264
1265     if (!fmt)
1266         return FALSE;
1267
1268     if ((a = g_realloc(*array, (len + 2) * sizeof(gchar *))) == NULL)
1269         return FALSE;
1270
1271     va_start(ap, fmt);
1272     ret = g_vasprintf(&buf, fmt, ap);
1273     va_end(ap);
1274
1275     if (ret == -1)
1276         return FALSE;
1277
1278     a[len++] = buf;
1279     a[len] = NULL;
1280     *array = a;
1281     return TRUE;
1282 }
1283
1284 struct realpath_s {
1285     gchar *account;
1286 };
1287
1288 static xmlNodePtr realpath_elements_cb(xmlNodePtr node, gchar **req,
1289         gpg_error_t *error, void *data)
1290 {
1291     struct realpath_s *rp = data;
1292
1293     if (rp->account)
1294         g_free(rp->account);
1295
1296     rp->account = g_strdup(req[0]);
1297
1298     if (!rp->account) {
1299         *error = gpg_error_from_errno(ENOMEM);
1300         return NULL;
1301     }
1302
1303     return node;
1304 }
1305
1306 static int realpath_command(assuan_context_t ctx, char *line)
1307 {
1308     gpg_error_t error;
1309     struct client_s *client = assuan_get_pointer(ctx);
1310     xmlChar *p;
1311     gchar **req;
1312     gchar *result, *t;
1313     gint i;
1314     xmlNodePtr n;
1315     struct realpath_s *rp;
1316     GString *string;
1317
1318     error = file_modified(client);
1319
1320     if (error) {
1321         log_write("%s: %s", client->filename ? client->filename : "",
1322                 pwmd_strerror(error));
1323         return send_error(ctx, error);
1324     }
1325
1326     if (strchr(line, '\t') != NULL) {
1327         if ((req = split_input_line(line, "\t", 0)) == NULL)
1328             return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1329     }
1330     else {
1331         if ((req = split_input_line(line, " ", 0)) == NULL)
1332             return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1333     }
1334
1335     n = find_account(client->doc, &req, &error, NULL, 0);
1336
1337     if (!n) {
1338         g_strfreev(req);
1339         return send_error(ctx, error);
1340     }
1341
1342     rp = g_malloc(sizeof(struct realpath_s));
1343
1344     if (!rp) {
1345         g_strfreev(req);
1346         return send_syserror(ctx, ENOMEM);
1347     }
1348
1349     rp->account = g_strdup(req[0]);
1350
1351     if (!rp->account) {
1352         g_strfreev(req);
1353         return send_syserror(ctx, ENOMEM);
1354     }
1355
1356     if (req[1]) {
1357         n = find_elements(client->doc, n->children, req+1, &error,
1358                 NULL, realpath_elements_cb, NULL, FALSE, 0, rp);
1359
1360         if (!n) {
1361             g_free(rp->account);
1362             g_free(rp);
1363             g_strfreev(req);
1364             return send_error(ctx, error);
1365         }
1366     }
1367
1368     p = xmlGetNodePath(n);
1369     result = element_path_to_req(rp->account, p);
1370
1371     if (!result) {
1372         g_free(result);
1373         g_free(rp->account);
1374         g_free(rp);
1375         g_strfreev(req);
1376         xmlFree(p);
1377         return send_syserror(ctx, ENOMEM);
1378     }
1379
1380     string = g_string_new(result);
1381     g_free(result);
1382     g_free(rp->account);
1383     g_free(rp);
1384     g_strfreev(req);
1385     xmlFree(p);
1386     i = 0;
1387
1388 again:
1389     for (t = string->str + i; *t; t++, i++) {
1390         if (!i || *t == '\t') {
1391             string = g_string_insert_c(string, !i ? i++ : ++i, '!');
1392             goto again;
1393         }
1394     }
1395
1396     error = assuan_send_data(ctx, string->str, string->len);
1397     g_string_free(string, TRUE);
1398     return send_error(ctx, error);
1399 }
1400
1401 struct list_element_s {
1402     GSList *list;
1403     gchar **elements;
1404 };
1405
1406 static gboolean append_to_element_list(struct list_element_s *elements)
1407 {
1408     gchar *tmp;
1409     gint i, total;
1410     gchar *a;
1411     GSList *list;
1412
1413     if (!elements || !elements->elements)
1414         return TRUE;
1415
1416     tmp = g_strjoinv("\t", elements->elements);
1417
1418     if (!tmp)
1419         return FALSE;
1420
1421     g_strfreev(elements->elements);
1422     elements->elements = NULL;
1423     total = g_slist_length(elements->list);
1424     a = g_utf8_collate_key(tmp, -1);
1425
1426     if (!a) {
1427         g_free(tmp);
1428         return FALSE;
1429     }
1430
1431     /*
1432      * Removes duplicate element paths from the list. This is needed when
1433      * appending an element tree from list_command(). The glib docs recommend
1434      * using g_utf8_collate_key() for a large number of strings.
1435      */
1436     for (i = 0; i < total; i++) {
1437         gchar *p = g_slist_nth_data(elements->list, i);
1438         gchar *b = g_utf8_collate_key(p, -1);
1439
1440         if (!b) {
1441             g_free(a);
1442             g_free(tmp);
1443             return FALSE;
1444         }
1445
1446         if (strcmp(a, b) == 0) {
1447             g_free(a);
1448             g_free(b);
1449             g_free(tmp);
1450             return TRUE;
1451         }
1452
1453         g_free(b);
1454     }
1455
1456     g_free(a);
1457     list = g_slist_append(elements->list, tmp);
1458
1459     if (!list)
1460         return FALSE;
1461
1462     elements->list = list;
1463     return TRUE;
1464 }
1465
1466 static gpg_error_t do_list_recurse(xmlDocPtr doc, xmlNodePtr node,
1467         struct list_element_s *elements, gchar *prefix)
1468 {
1469     xmlNodePtr n;
1470     gpg_error_t error;
1471
1472     if (append_to_element_list(elements) == FALSE)
1473         return gpg_error_from_errno(ENOMEM);
1474
1475     for (n = node; n; n = n->next) {
1476         if (n->type == XML_ELEMENT_NODE) {
1477             xmlChar *content = node_has_attribute(n, (xmlChar *)"target");
1478             gchar *tmp;
1479
1480             if (content) {
1481                 if (strv_printf(&elements->elements, "%s\t%s", prefix, n->name) == FALSE)
1482                     return gpg_error_from_errno(ENOMEM);
1483
1484                 if (append_to_element_list(elements) == FALSE)
1485                     return gpg_error_from_errno(ENOMEM);
1486             }
1487
1488             tmp = g_strdup_printf("%s\t!%s", prefix, n->name);
1489
1490             if (!tmp)
1491                 return gpg_error_from_errno(ENOMEM);
1492
1493             if (strv_printf(&elements->elements, "%s", tmp) == FALSE) {
1494                 g_free(tmp);
1495                 return gpg_error_from_errno(ENOMEM);
1496             }
1497
1498             if (n->children) {
1499                 error = do_list_recurse(doc, n->children, elements, tmp);
1500                 g_free(tmp);
1501
1502                 if (error && error != EPWMD_ELEMENT_NOT_FOUND)
1503                     return error;
1504             }
1505             else
1506                 g_free(tmp);
1507
1508             if (append_to_element_list(elements) == FALSE)
1509                 return gpg_error_from_errno(ENOMEM);
1510         }
1511     }
1512
1513     return 0;
1514 }
1515
1516 static gpg_error_t do_list_command(assuan_context_t ctx, xmlDocPtr doc,
1517         struct list_element_s *elements, char *line)
1518 {
1519     gchar *prefix = NULL, *account;
1520     gchar **req = NULL, **oreq = NULL, *tmp;
1521     xmlNodePtr n;
1522     gboolean account_is_literal, account_has_target = FALSE;
1523     gint which = 0;
1524     gchar **p;
1525     gpg_error_t error;
1526
1527     if ((req = split_input_line(line, "\t", 0)) == NULL) {
1528         if ((req = split_input_line(line, " ", 0)) == NULL)
1529             return EPWMD_COMMAND_SYNTAX;
1530     }
1531
1532     prefix = g_strdup(*req);
1533
1534     if (!prefix) {
1535         g_strfreev(req);
1536         return gpg_error_from_errno(ENOMEM);
1537     }
1538
1539     account = g_strdup(*req);
1540
1541     if (!account) {
1542         g_free(prefix);
1543         g_strfreev(req);
1544         return gpg_error_from_errno(ENOMEM);
1545     }
1546
1547     oreq = g_strdupv(req);
1548
1549     if (!oreq) {
1550         g_free(prefix);
1551         g_free(account);
1552         g_strfreev(req);
1553         return gpg_error_from_errno(ENOMEM);
1554     }
1555
1556     p = req;
1557 again:
1558     account_has_target = FALSE;
1559     account_is_literal = is_literal_element_str(prefix);
1560     n = find_account(doc, &p, &error, &account_has_target, 0);
1561
1562     if (which)
1563         oreq = p;
1564     else
1565         req = p;
1566
1567     if (!n)
1568         goto fail;
1569
1570     if (!which && account_is_literal == FALSE && account_has_target == FALSE) {
1571         tmp = g_strdup_printf("!%s", prefix);
1572
1573         if (!tmp) {
1574             error = gpg_error_from_errno(ENOMEM);
1575             goto fail;
1576         }
1577
1578         g_free(prefix);
1579         prefix = tmp;
1580     }
1581
1582     if (*(p+1)) {
1583         gchar *t;
1584
1585         n = find_elements(doc, n->children, p+1, &error, NULL, NULL, NULL,
1586                 TRUE, 0, NULL);
1587
1588         if (error)
1589             goto fail;
1590
1591         tmp = g_strjoinv("\t", p+1);
1592         if (!tmp) {
1593             error = gpg_error_from_errno(ENOMEM);
1594             goto fail;
1595         }
1596
1597         t = g_strdup_printf("%s\t%s", prefix, tmp);
1598         if (!t) {
1599             error = gpg_error_from_errno(ENOMEM);
1600             goto fail;
1601         }
1602
1603         g_free(prefix);
1604         prefix = t;
1605         g_free(tmp);
1606     }
1607
1608     if (strv_printf(&elements->elements, "%s", prefix) == FALSE) {
1609         error = gpg_error_from_errno(ENOMEM);
1610         goto fail;
1611     }
1612
1613     if (node_has_child_element(n->children) == FALSE) {
1614         if (append_to_element_list(elements) == FALSE) {
1615             error = gpg_error_from_errno(ENOMEM);
1616             goto fail;
1617         }
1618     }
1619     else
1620         error = do_list_recurse(doc, n->children, elements, prefix);
1621
1622     if (error)
1623         goto fail;
1624
1625     if (!which++ && !*(p+1) && account_is_literal == FALSE && account_has_target == TRUE) {
1626         g_free(*oreq);
1627         *oreq = g_strdup_printf("!%s", account);
1628
1629         if (!*oreq) {
1630             error = gpg_error_from_errno(ENOMEM);
1631             goto fail;
1632         }
1633
1634         p = oreq;
1635         g_free(prefix);
1636         prefix = g_strdup(*oreq);
1637
1638         if (!prefix) {
1639             error = gpg_error_from_errno(ENOMEM);
1640             goto fail;
1641         }
1642
1643         goto again;
1644     }
1645
1646 fail:
1647     g_free(prefix);
1648     g_free(account);
1649     g_strfreev(req);
1650
1651     if (oreq)
1652         g_strfreev(oreq);
1653
1654     return error;
1655 }
1656
1657 /*
1658  * This could be faster especially when finding "target" attributes.
1659  */
1660 static int list_command(assuan_context_t ctx, char *line)
1661 {
1662     struct client_s *client = assuan_get_pointer(ctx);
1663     gpg_error_t error;
1664     struct list_element_s *elements = NULL;
1665     GString *string;
1666     gchar *tmp;
1667     gint i, total;
1668
1669     if (disable_list_and_dump == TRUE)
1670         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
1671
1672     error = file_modified(client);
1673
1674     if (error) {
1675         log_write("%s: %s", client->filename, pwmd_strerror(error));
1676         return send_error(ctx, error);
1677     }
1678
1679     if (!*line) {
1680         GString *str;
1681
1682         error = list_accounts(client->doc, &str);
1683
1684         if (error)
1685             return send_error(ctx, error);
1686
1687         error = assuan_send_data(ctx, str->str, str->len);
1688         g_string_free(str, TRUE);
1689         return send_error(ctx, error);
1690     }
1691
1692     elements = g_malloc0(sizeof(struct list_element_s));
1693
1694     if (!elements) {
1695         error = gpg_error_from_errno(ENOMEM);
1696         goto fail;
1697     }
1698
1699     error = do_list_command(ctx, client->doc, elements, line);
1700
1701     if (error)
1702         goto fail;
1703
1704     if (!error) {
1705         total = g_slist_length(elements->list);
1706
1707         if (!total) {
1708             error = EPWMD_EMPTY_ELEMENT;
1709             goto fail;
1710         }
1711
1712         /*
1713          * Find element paths with a target and append those element trees to
1714          * the list.
1715          */
1716         for (i = 0; i < total; i++) {
1717             gchar **req;
1718
1719             tmp = g_slist_nth_data(elements->list, i);
1720             req = split_input_line(tmp, "\t", 0);
1721
1722             if (!req) {
1723                 if (g_str_has_prefix(tmp, "!") == TRUE) {
1724                     g_strfreev(req);
1725                     continue;
1726                 }
1727             }
1728             else {
1729                 gchar **p;
1730
1731                 for (p = req; *p; p++) {
1732                     if (g_str_has_prefix(*p, "!") == FALSE)
1733                         break;
1734                 }
1735
1736                 if (!*p) {
1737                     g_strfreev(req);
1738                     continue;
1739                 }
1740             }
1741
1742             g_strfreev(req);
1743             error = do_list_command(ctx, client->doc, elements, tmp);
1744
1745             if (error && error != EPWMD_ELEMENT_NOT_FOUND)
1746                 goto fail;
1747
1748             total = g_slist_length(elements->list);
1749         }
1750     }
1751
1752     string = g_string_new(NULL);
1753
1754     for (i = 0; i < total; i++) {
1755         tmp = g_slist_nth_data(elements->list, i);
1756         g_string_append_printf(string, "%s\n", tmp);
1757         g_free(tmp);
1758     }
1759
1760     string = g_string_truncate(string, string->len - 1);
1761     error = assuan_send_data(ctx, string->str, string->len);
1762     g_string_free(string, TRUE);
1763
1764 fail:
1765     if (elements) {
1766         if (elements->list)
1767             g_slist_free(elements->list);
1768
1769         if (elements->elements)
1770             g_strfreev(elements->elements);
1771
1772         g_free(elements);
1773     }
1774
1775     return send_error(ctx, error);
1776 }
1777
1778 static gpg_error_t add_attribute(xmlNodePtr node, const gchar *name,
1779         const gchar *value)
1780 {
1781     xmlAttrPtr a;
1782
1783     if ((a = xmlHasProp(node, (xmlChar *)name)) == NULL) {
1784         a = xmlNewProp(node, (xmlChar *)name, (xmlChar *)value);
1785
1786         if (!a)
1787             return EPWMD_LIBXML_ERROR;
1788     }
1789     else
1790         xmlNodeSetContent(a->children, (xmlChar *)value);
1791
1792     return 0;
1793 }
1794
1795 /*
1796  * req[0] - element path
1797  */
1798 static int attribute_list(assuan_context_t ctx, gchar **req)
1799 {
1800     struct client_s *client = assuan_get_pointer(ctx);
1801     gchar **attrlist = NULL;
1802     gint i = 0;
1803     gchar **path = NULL;
1804     xmlAttrPtr a;
1805     xmlNodePtr n, an;
1806     gchar *line;
1807     gpg_error_t error;
1808
1809     if (!req || !req[0])
1810         return EPWMD_COMMAND_SYNTAX;
1811
1812     if ((path = split_input_line(req[0], "\t", 0)) == NULL) {
1813         /*
1814          * The first argument may be only an account.
1815          */
1816         if ((path = split_input_line(req[0], " ", 0)) == NULL)
1817             return EPWMD_COMMAND_SYNTAX;
1818     }
1819
1820     n = find_account(client->doc, &path, &error, NULL, 0);
1821
1822     if (!n) {
1823         g_strfreev(path);
1824         return error;
1825     }
1826
1827     if (path[1]) {
1828         n = find_elements(client->doc, n->children, path+1, &error,
1829                 NULL, NULL, NULL, FALSE, 0, NULL);
1830
1831         if (!n) {
1832             g_strfreev(path);
1833             return error;
1834         }
1835     }
1836
1837     g_strfreev(path);
1838
1839     for (a = n->properties; a; a = a->next) {
1840         gchar **pa;
1841
1842         if ((pa = g_realloc(attrlist, (i + 2) * sizeof(gchar *))) == NULL) {
1843             if (attrlist)
1844                 g_strfreev(attrlist);
1845
1846             error = errno;
1847             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(errno));
1848             return gpg_error_from_errno(error);
1849         }
1850
1851         attrlist = pa;
1852         an = a->children;
1853         attrlist[i] = g_strdup_printf("%s\t%s", (gchar *)a->name, (gchar *)an->content);
1854
1855         if (!attrlist[i]) {
1856             g_strfreev(attrlist);
1857             return gpg_error_from_errno(ENOMEM);
1858         }
1859
1860         attrlist[++i] = NULL;
1861     }
1862
1863     if (!attrlist)
1864         return EPWMD_EMPTY_ELEMENT;
1865
1866     line = g_strjoinv("\n", attrlist);
1867
1868     if (!line) {
1869         g_strfreev(attrlist);
1870         return gpg_error_from_errno(ENOMEM);
1871     }
1872
1873     error = assuan_send_data(ctx, line, strlen(line));
1874     g_free(line);
1875     g_strfreev(attrlist);
1876     return error;
1877 }
1878
1879 /*
1880  * req[0] - attribute
1881  * req[1] - element path
1882  */
1883 static int attribute_delete(struct client_s *client, gchar **req)
1884 {
1885     xmlAttrPtr a;
1886     xmlNodePtr n;
1887     gchar **path = NULL;
1888     gpg_error_t error;
1889
1890     if (!req || !req[0] || !req[1])
1891         return EPWMD_COMMAND_SYNTAX;
1892
1893     if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
1894         /*
1895          * The first argument may be only an account.
1896          */
1897         if ((path = split_input_line(req[1], " ", 0)) == NULL)
1898             return EPWMD_COMMAND_SYNTAX;
1899     }
1900
1901     /*
1902      * Don't remove the "name" attribute for the account element. To remove an
1903      * account use DELETE <account>.
1904      */
1905     if (!path[1] && xmlStrEqual((xmlChar *)req[0], (xmlChar *)"name")) {
1906         error = EPWMD_ATTR_SYNTAX;
1907         goto fail;
1908     }
1909
1910     n = find_account(client->doc, &path, &error, NULL, 0);
1911
1912     if (!n)
1913         goto fail;
1914
1915     if (path[1]) {
1916         n = find_elements(client->doc, n->children, path+1, &error,
1917                 NULL, NULL, NULL, FALSE, 0, NULL);
1918
1919         if (!n)
1920             goto fail;
1921     }
1922
1923     g_strfreev(path);
1924
1925     if ((a = xmlHasProp(n, (xmlChar *)req[0])) == NULL)
1926         return EPWMD_ATTR_NOT_FOUND;
1927
1928     if (xmlRemoveProp(a) == -1)
1929         return EPWMD_LIBXML_ERROR;
1930
1931     return 0;
1932
1933 fail:
1934     g_strfreev(path);
1935     return error;
1936 }
1937
1938 /*
1939  * Creates a "target" attribute. When other commands encounter an element with
1940  * this attribute, the element path is modified to the target value. If the
1941  * source element path doesn't exist when using 'ATTR SET target', it is
1942  * created, but the destination element path must exist.
1943  *
1944  * req[0] - source element path
1945  * req[1] - destination element path
1946  */
1947 static gpg_error_t target_attribute(struct client_s *client, gchar **req)
1948 {
1949     gchar **src, **dst, *line;
1950     gpg_error_t error;
1951     xmlNodePtr n;
1952
1953     if (!req || !req[0] || !req[1])
1954         return EPWMD_COMMAND_SYNTAX;
1955
1956     if ((src = split_input_line(req[0], "\t", 0)) == NULL) {
1957         /*
1958          * The first argument may be only an account.
1959          */
1960         if ((src = split_input_line(req[0], " ", 0)) == NULL)
1961             return EPWMD_COMMAND_SYNTAX;
1962     }
1963
1964     if (valid_element_path(src, FALSE) == FALSE) {
1965         g_strfreev(src);
1966         return EPWMD_INVALID_ELEMENT;
1967     }
1968
1969     if ((dst = split_input_line(req[1], "\t", 0)) == NULL) {
1970         /*
1971          * The first argument may be only an account.
1972          */
1973         if ((dst = split_input_line(req[1], " ", 0)) == NULL) {
1974             error = EPWMD_COMMAND_SYNTAX;
1975             goto fail;
1976         }
1977     }
1978
1979     n = find_account(client->doc, &dst, &error, NULL, 0);
1980
1981     /*
1982      * Make sure the destination element path exists.
1983      */
1984     if (!n)
1985         goto fail;
1986
1987     if (dst[1]) {
1988         n = find_elements(client->doc, n->children, dst+1, &error,
1989                 NULL, NULL, NULL, FALSE, 0, NULL);
1990
1991         if (!n)
1992             goto fail;
1993     }
1994
1995 again:
1996     n = find_account(client->doc, &src, &error, NULL, 0);
1997
1998     if (!n) {
1999         if (error == EPWMD_ELEMENT_NOT_FOUND) {
2000             error = new_account(client->doc, src[0]);
2001
2002             if (error)
2003                 goto fail;
2004
2005             goto again;
2006         }
2007         else
2008             goto fail;
2009     }
2010
2011     if (src[1]) {
2012         if (!n->children)
2013             n = create_target_elements_cb(n, src+1, &error, NULL);
2014         else
2015             n = find_elements(client->doc, n->children, src+1, &error,
2016                     NULL, NULL, create_target_elements_cb, FALSE, 0, NULL);
2017
2018         if (!n)
2019             goto fail;
2020
2021         /*
2022          * Reset the position of the element tree now that the elements
2023          * have been created.
2024          */
2025         n = find_account(client->doc, &src, &error, NULL, 0);
2026
2027         if (!n)
2028             goto fail;
2029
2030         n = find_elements(client->doc, n->children, src+1, &error,
2031                 NULL, NULL, NULL, FALSE, 0, NULL);
2032
2033         if (!n)
2034             goto fail;
2035     }
2036
2037     line = g_strjoinv("\t", dst);
2038     error = add_attribute(n, "target", line);
2039
2040     if (error) {
2041         g_free(line);
2042         goto fail;
2043     }
2044
2045     g_free(line);
2046     g_strfreev(src);
2047     g_strfreev(dst);
2048     return 0;
2049
2050 fail:
2051     g_strfreev(src);
2052     g_strfreev(dst);
2053     return error;
2054 }
2055
2056 /*
2057  * req[0] - account name
2058  * req[1] - new name
2059  */
2060 static gpg_error_t name_attribute(struct client_s *client, gchar **req)
2061 {
2062     gpg_error_t error;
2063     gchar **tmp;
2064     xmlNodePtr n;
2065
2066     tmp = g_strdupv(req);
2067
2068     if (!tmp)
2069         return gpg_error_from_errno(ENOMEM);
2070
2071     n = find_account(client->doc, &tmp, &error, NULL, 0);
2072     g_strfreev(tmp);
2073
2074     if (!n)
2075         return error;
2076
2077     if (g_utf8_collate(req[0], req[1]) == 0)
2078         return 0;
2079
2080     /*
2081      * Will not overwrite an existing account.
2082      */
2083     tmp = g_strdupv(req+1);
2084
2085     if (!tmp)
2086         return gpg_error_from_errno(ENOMEM);
2087
2088     n = find_account(client->doc, &tmp, &error, NULL, 0);
2089     g_strfreev(tmp);
2090
2091     if (error && error != EPWMD_ELEMENT_NOT_FOUND)
2092         return error;
2093
2094     if (n)
2095         return EPWMD_ACCOUNT_EXISTS;
2096
2097     /*
2098      * Whitespace not allowed in account names.
2099      */
2100     if (contains_whitespace(req[1]) == TRUE)
2101         return EPWMD_ATTR_SYNTAX;
2102
2103     tmp = g_strdupv(req);
2104
2105     if (!tmp)
2106         return gpg_error_from_errno(ENOMEM);
2107
2108     n = find_account(client->doc, &tmp, &error, NULL, 0);
2109     g_strfreev(tmp);
2110
2111     if (!n)
2112         return EPWMD_ELEMENT_NOT_FOUND;
2113
2114     return add_attribute(n, "name", req[1]);
2115 }
2116
2117 /*
2118  * req[0] - attribute
2119  * req[1] - element path
2120  */
2121 static int attribute_get(assuan_context_t ctx, gchar **req)
2122 {
2123     struct client_s *client = assuan_get_pointer(ctx);
2124     xmlNodePtr n;
2125     xmlChar *a;
2126     gchar **path= NULL;
2127     gpg_error_t error;
2128
2129     if (!req || !req[0] || !req[1])
2130         return EPWMD_COMMAND_SYNTAX;
2131
2132     if (strchr(req[1], '\t')) {
2133         if ((path = split_input_line(req[1], "\t", 0)) == NULL)
2134             return EPWMD_COMMAND_SYNTAX;
2135     }
2136     else {
2137         if ((path = split_input_line(req[1], " ", 0)) == NULL)
2138             return EPWMD_COMMAND_SYNTAX;
2139     }
2140
2141     n = find_account(client->doc, &path, &error, NULL, 0);
2142
2143     if (!n)
2144         goto fail;
2145
2146     if (path[1]) {
2147         n = find_elements(client->doc, n->children, path+1, &error,
2148                 NULL, NULL, NULL, FALSE, 0, NULL);
2149
2150         if (!n)
2151             goto fail;
2152     }
2153
2154     g_strfreev(path);
2155
2156     if ((a = xmlGetProp(n, (xmlChar *)req[0])) == NULL)
2157         return EPWMD_ATTR_NOT_FOUND;
2158
2159     error = assuan_send_data(ctx, a, xmlStrlen(a));
2160     xmlFree(a);
2161     return error;
2162
2163 fail:
2164     g_strfreev(path);
2165     return error;
2166 }
2167
2168 /*
2169  * req[0] - attribute
2170  * req[1] - element path
2171  * req[2] - value
2172  */
2173 static int attribute_set(struct client_s *client, gchar **req)
2174 {
2175     gchar **path = NULL;
2176     gpg_error_t error;
2177     xmlNodePtr n;
2178
2179     if (!req || !req[0] || !req[1] || !req[2])
2180         return EPWMD_COMMAND_SYNTAX;
2181
2182     /*
2183      * Reserved attribute names.
2184      */
2185     if (g_utf8_collate(req[0], "name") == 0) {
2186         /*
2187          * Only reserved for the account element. Not the rest of the
2188          * document.
2189          */
2190         if (strchr(req[1], '\t') == NULL)
2191             return name_attribute(client, req + 1);
2192     }
2193     else if (g_utf8_collate(req[0], "target") == 0)
2194         return target_attribute(client, req + 1);
2195
2196     if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
2197         /*
2198          * The first argument may be only an account.
2199          */
2200         if ((path = split_input_line(req[1], " ", 0)) == NULL)
2201             return EPWMD_COMMAND_SYNTAX;
2202     }
2203
2204     n = find_account(client->doc, &path, &error, NULL, 0);
2205
2206     if (!n)
2207         goto fail;
2208
2209     if (path[1]) {
2210         n = find_elements(client->doc, n->children, path+1, &error,
2211                 NULL, NULL, NULL, FALSE, 0, NULL);
2212
2213         if (!n)
2214             goto fail;
2215     }
2216
2217     g_strfreev(path);
2218     return add_attribute(n, req[0], req[2]);
2219
2220 fail:
2221     g_strfreev(path);
2222     return error;
2223 }
2224
2225 /*
2226  * req[0] - command
2227  * req[1] - attribute name or element path if command is LIST
2228  * req[2] - element path
2229  * req[2] - element path or value
2230  */
2231 static int attr_command(assuan_context_t ctx, char *line)
2232 {
2233     struct client_s *client = assuan_get_pointer(ctx);
2234     gchar **req = split_input_line(line, " ", 4);
2235     gpg_error_t error = 0;
2236
2237     error = file_modified(client);
2238
2239     if (error) {
2240         log_write("%s: %s", client->filename ? client->filename : "",
2241                 pwmd_strerror(error));
2242         g_strfreev(req);
2243         return send_error(ctx, error);
2244     }
2245
2246     if (!req || !req[0] || !req[1]) {
2247         g_strfreev(req);
2248         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2249     }
2250
2251     if (g_ascii_strcasecmp(req[0], "SET") == 0)
2252         error = attribute_set(client, req+1);
2253     else if (g_ascii_strcasecmp(req[0], "GET") == 0)
2254         error = attribute_get(ctx, req+1);
2255     else if (g_ascii_strcasecmp(req[0], "DELETE") == 0)
2256         error = attribute_delete(client, req+1);
2257     else if (g_ascii_strcasecmp(req[0], "LIST") == 0)
2258         error = attribute_list(ctx, req+1);
2259     else
2260         error = EPWMD_COMMAND_SYNTAX;
2261
2262     g_strfreev(req);
2263     return send_error(ctx, error);
2264 }
2265
2266 static int iscached_command(assuan_context_t ctx, char *line)
2267 {
2268     gchar **req = split_input_line(line, " ", 0);
2269     guchar md5file[16];
2270
2271     if (!req || !*req) {
2272         g_strfreev(req);
2273         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2274     }
2275
2276     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
2277     g_strfreev(req);
2278     CACHE_LOCK(ctx);
2279
2280     if (cache_iscached(md5file) == FALSE) {
2281         CACHE_UNLOCK;
2282         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2283     }
2284
2285     CACHE_UNLOCK;
2286     return send_error(ctx, 0);
2287 }
2288
2289 gpg_error_t send_cache_status(assuan_context_t ctx)
2290 {
2291     gchar *tmp;
2292     struct client_s *client = assuan_get_pointer(ctx);
2293
2294     CACHE_LOCK(client->ctx);
2295     tmp = print_fmt("%i %i",
2296                 cache_file_count(),
2297                 (cache_size / sizeof(file_cache_t)) - cache_file_count());
2298     CACHE_UNLOCK;
2299
2300     return assuan_write_status(ctx, "CACHE", tmp);
2301 }
2302
2303 static int clearcache_command(assuan_context_t ctx, char *line)
2304 {
2305     struct client_s *client = assuan_get_pointer(ctx);
2306     gchar **req = split_input_line(line, " ", 0);
2307     guchar md5file[16];
2308
2309     CACHE_LOCK(ctx);
2310
2311     if (!req || !*req) {
2312         g_strfreev(req);
2313         cache_clear(client->md5file, 2);
2314         CACHE_UNLOCK;
2315         return send_error(ctx, 0);
2316     }
2317
2318     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
2319     g_strfreev(req);
2320
2321     if (cache_clear(md5file, 1) == FALSE) {
2322         CACHE_UNLOCK;
2323         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2324     }
2325
2326     CACHE_UNLOCK;
2327     return send_error(ctx, 0);
2328 }
2329
2330 static int cachetimeout_command(assuan_context_t ctx, char *line)
2331 {
2332     guchar md5file[16];
2333     glong timeout;
2334     gchar **req = split_input_line(line, " ", 0);
2335     gchar *p;
2336     struct client_s *client = assuan_get_pointer(ctx);
2337
2338     if (!req || !*req || !req[1]) {
2339         g_strfreev(req);
2340         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2341     }
2342
2343     errno = 0;
2344     timeout = strtol(req[0], &p, 10);
2345
2346     if (errno != 0 || *p != 0) {
2347         g_strfreev(req);
2348         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2349     }
2350
2351     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[1], strlen(req[1]));
2352     g_strfreev(req);
2353     CACHE_LOCK(client->ctx);
2354
2355     if (cache_set_timeout(md5file, timeout) == FALSE) {
2356         CACHE_UNLOCK;
2357         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2358     }
2359
2360     CACHE_UNLOCK;
2361     send_cache_status_all();
2362     return send_error(ctx, 0);
2363 }
2364
2365 static int dump_command(assuan_context_t ctx, char *line)
2366 {
2367     xmlChar *xml;
2368     gssize len;
2369     struct client_s *client = assuan_get_pointer(ctx);
2370     gpg_error_t error;
2371
2372     if (disable_list_and_dump == TRUE)
2373         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
2374
2375     error = file_modified(client);
2376
2377     if (error) {
2378         log_write("%s: %s", client->filename ? client->filename : "",
2379                 pwmd_strerror(error));
2380         return send_error(ctx, error);
2381     }
2382
2383     xmlDocDumpFormatMemory(client->doc, &xml, &len, 1);
2384     error = assuan_send_data(ctx, xml, len);
2385     xmlFree(xml);
2386     return send_error(ctx, error);
2387 }
2388
2389 static int getconfig_command(assuan_context_t ctx, gchar *line)
2390 {
2391     struct client_s *client = assuan_get_pointer(ctx);
2392     gpg_error_t error = 0;
2393     gchar *p, *tmp;
2394
2395     if (strcmp(line, "key") == 0 || strcmp(line, "key_file") == 0)
2396         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
2397
2398     p = get_key_file_string(client->filename ? client->filename : "default", line);
2399
2400     if (!p)
2401         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2402
2403     tmp = expand_homedir(p);
2404     g_free(p);
2405     p = tmp;
2406     error = assuan_send_data(ctx, p, strlen(p));
2407     g_free(p);
2408     return send_error(ctx, error);
2409 }
2410
2411 void cleanup_assuan(assuan_context_t ctx)
2412 {
2413     struct client_s *cl = assuan_get_pointer(ctx);
2414
2415     cleanup_client(cl);
2416 }
2417
2418 static void reset_notify(assuan_context_t ctx)
2419 {
2420     struct client_s *cl = assuan_get_pointer(ctx);
2421
2422     cleanup_client(cl);
2423 }
2424
2425 gpg_error_t register_commands(assuan_context_t ctx)
2426 {
2427     static struct {
2428         const char *name;
2429         int (*handler)(assuan_context_t, char *line);
2430     } table[] = {
2431         { "OPEN", open_command },
2432         { "SAVE", save_command },
2433         { "LIST", list_command },
2434         { "REALPATH", realpath_command },
2435         { "STORE", store_command },
2436         { "DELETE", delete_command },
2437         { "GET", get_command },
2438         { "ATTR", attr_command },
2439         { "ISCACHED", iscached_command },
2440         { "CLEARCACHE", clearcache_command },
2441         { "CACHETIMEOUT", cachetimeout_command },
2442         { "GETCONFIG", getconfig_command },
2443         { "DUMP", dump_command },
2444         { "INPUT", NULL },
2445         { "OUTPUT", NULL },
2446         { NULL, NULL }
2447     };
2448     int i, rc;
2449
2450     for (i=0; table[i].name; i++) {
2451         rc = assuan_register_command (ctx, table[i].name, table[i].handler);
2452
2453         if (rc)
2454             return rc;
2455     }
2456
2457     rc = assuan_register_bye_notify(ctx, cleanup_assuan);
2458     if (rc)
2459         return rc;
2460
2461     return assuan_register_reset_notify(ctx, reset_notify);
2462 }
2463
2464 gpg_error_t try_xml_decrypt(assuan_context_t ctx, gint fd, struct stat st,
2465         guchar *key)
2466 {
2467     guchar *iv;
2468     void *inbuf;
2469     gsize insize, len;
2470     guchar tkey[gcrykeysize];
2471     struct file_header_s {
2472         guint iter;
2473         guchar iv[gcryblocksize];
2474     } file_header;
2475     struct client_s *client = ctx ? assuan_get_pointer(ctx) : NULL;
2476     gcry_cipher_hd_t gh;
2477     guint iter = 0, n_iter = 0;
2478     gint iter_progress;
2479     void *outbuf = NULL;
2480     gint zerror = 0;
2481     glong outsize = 0;
2482     gpg_error_t error;
2483
2484     if (!ctx) {
2485         error = gcry_cipher_open(&gh, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC, 0);
2486
2487         if (error)
2488             return error;
2489     }
2490     else
2491         gh = client->gh;
2492
2493     lseek(fd, 0, SEEK_SET);
2494     insize = st.st_size - sizeof(struct file_header_s);
2495     iv = gcry_malloc(gcryblocksize);
2496
2497     if (!iv) {
2498         if (!ctx)
2499             gcry_cipher_close(gh);
2500
2501         return gpg_error_from_errno(ENOMEM);
2502     }
2503
2504     len = pth_read(fd, &file_header, sizeof(struct file_header_s));
2505
2506     if (len != sizeof(file_header)) {
2507         len = errno;
2508
2509         if (!ctx)
2510             gcry_cipher_close(gh);
2511
2512         gcry_free(iv);
2513         errno = len;
2514         return gpg_error_from_errno(errno);
2515     }
2516
2517     memcpy(iv, &file_header.iv, sizeof(file_header.iv));
2518     inbuf = gcry_malloc(insize);
2519
2520     if (!inbuf) {
2521         if (!ctx)
2522             gcry_cipher_close(gh);
2523
2524         gcry_free(iv);
2525         return gpg_error_from_errno(ENOMEM);
2526     }
2527
2528     len = pth_read(fd, inbuf, insize);
2529
2530     if (len != insize) {
2531         len = errno;
2532
2533         if (!ctx)
2534             gcry_cipher_close(gh);
2535
2536         gcry_free(iv);
2537         errno = len;
2538         return gpg_error_from_errno(errno);
2539     }
2540
2541     memcpy(tkey, key, sizeof(tkey));
2542     tkey[0] ^= 1;
2543
2544     if ((error = gcry_cipher_setiv(gh, iv, gcryblocksize))) {
2545         if (!ctx) {
2546             gcry_cipher_close(gh);
2547             warnx("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2548         }
2549         else
2550             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2551
2552         gcry_free(inbuf);
2553         gcry_free(iv);
2554         return error;
2555     }
2556
2557     if ((error = gcry_cipher_setkey(gh, key, gcrykeysize))) {
2558         if (!ctx) {
2559             gcry_cipher_close(gh);
2560             warnx("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2561         }
2562         else
2563             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2564
2565         gcry_free(inbuf);
2566         gcry_free(iv);
2567
2568         if (!ctx)
2569             gcry_cipher_close(gh);
2570
2571         return error;
2572     }
2573
2574     iter_progress = get_key_file_integer("default", "iteration_progress");
2575
2576     if (ctx && iter_progress > 0 && file_header.iter >= iter_progress) {
2577         error = assuan_write_status(client->ctx, "DECRYPT", "0");
2578
2579         if (error) {
2580             gcry_free(inbuf);
2581             gcry_free(iv);
2582             return error;
2583         }
2584     }
2585
2586     error = decrypt_xml(gh, inbuf, insize, NULL, 0);
2587
2588     if (error) {
2589         gcry_free(inbuf);
2590         gcry_free(iv);
2591         return error;
2592     }
2593
2594     if ((error = gcry_cipher_setkey(gh, tkey, gcrykeysize))) {
2595         if (!ctx) {
2596             gcry_cipher_close(gh);
2597             warnx("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2598         }
2599         else
2600             log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2601
2602         gcry_free(inbuf);
2603         gcry_free(iv);
2604         return error;
2605     }
2606
2607     while (iter < file_header.iter) {
2608         if (ctx && iter_progress > 0 && iter >= iter_progress) {
2609             if (!(iter % iter_progress)) {
2610                 error = assuan_write_status(ctx, "DECRYPT", print_fmt("%i",
2611                             ++n_iter * iter_progress));
2612
2613                 if (error) {
2614                     gcry_free(inbuf);
2615                     gcry_free(iv);
2616                     return error;
2617                 }
2618             }
2619         }
2620
2621         if ((error = gcry_cipher_setiv(gh, iv, gcryblocksize))) {
2622             if (!ctx) {
2623                 gcry_cipher_close(gh);
2624                 warnx("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2625             }
2626             else
2627                 log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2628
2629             gcry_free(inbuf);
2630             gcry_free(iv);
2631             return error;
2632         }
2633
2634         error = decrypt_xml(gh, inbuf, insize, NULL, 0);
2635
2636         if (error) {
2637             if (!ctx) {
2638                 gcry_cipher_close(gh);
2639                 warnx("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2640             }
2641             else
2642                 log_write("%s(%i): %s", __FUNCTION__, __LINE__, gcry_strerror(error));
2643
2644             gcry_free(inbuf);
2645             gcry_free(iv);
2646             return error;
2647         }
2648
2649         iter++;
2650         pth_yield(NULL);
2651     }
2652
2653     if (ctx && iter_progress && file_header.iter >= iter_progress) {
2654         error = assuan_write_status(ctx, "DECRYPT", print_fmt("%i", file_header.iter));
2655
2656         if (error) {
2657             gcry_free(inbuf);
2658             gcry_free(iv);
2659             return error;
2660         }
2661     }
2662
2663     gcry_free(iv);
2664
2665     if (do_decompress(ctx, inbuf, insize, &outbuf, &outsize, &zerror) == FALSE) {
2666         /*
2667          * Z_DATA_ERROR may be returned if this file hasn't been compressed yet.
2668          */
2669         if (zerror == Z_MEM_ERROR) {
2670             gcry_free(inbuf);
2671             return gpg_error_from_errno(ENOMEM);
2672         }
2673         else if (zerror != Z_DATA_ERROR) {
2674             gcry_free(inbuf);
2675
2676             if (!ctx)
2677                 gcry_cipher_close(gh);
2678
2679             return EPWMD_BADKEY;
2680         }
2681     }
2682     else {
2683         gcry_free(inbuf);
2684         inbuf = outbuf;
2685         insize = outsize;
2686     }
2687
2688     if (g_strncasecmp(inbuf, "<?xml version=\"1.0\"?>", 21) != 0) {
2689         gcry_free(inbuf);
2690
2691         if (!ctx)
2692             gcry_cipher_close(gh);
2693
2694         return EPWMD_BADKEY;
2695     }
2696
2697     if (ctx) {
2698         client->xml = inbuf;
2699         client->len = insize;
2700     }
2701     else {
2702         gcry_cipher_close(gh);
2703         gcry_free(inbuf);
2704     }
2705
2706     return 0;
2707 }
2708
2709 /*
2710  * This is called after every Assuan command.
2711  */
2712 void command_finalize(assuan_context_t ctx, gint error)
2713 {
2714     struct client_s *client = assuan_get_pointer(ctx);
2715
2716     unlock_file_mutex(client);
2717 }