src/commands.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2009 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  02110-1301  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 <gcrypt.h>
  30 #include <zlib.h>
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35
  36 #include "mem.h"
  37 #include "xml.h"
  38 #include "common.h"
  39
  40 #ifdef WITH_PINENTRY
  41 #include "pinentry.h"
  42 #endif
  43
  44 #include "pwmd_error.h"
  45 #include "cache.h"
  46 #include "misc.h"
  47 #include "commands.h"
  48 #include "lock.h"
  49
  50 struct gz_s {
  51     z_stream z;
  52     gpointer out;
  53     gboolean done;
  54     status_msg_t which;
  55 };
  56
  57 static void *z_alloc(void *data, unsigned items, unsigned size)
  58 {
  59     return gcry_calloc(items, size);
  60 }
  61
  62 static void z_free(void *data, void *p)
  63 {
  64     gcry_free(p);
  65 }
  66
  67 static gpg_error_t file_modified(struct client_s *client)
  68 {
  69     struct stat st;
  70     gpg_error_t rc;
  71
  72     if (client->state != STATE_OPEN)
  73         return EPWMD_NO_FILE;
  74
  75     rc = lock_file_mutex(client);
  76
  77     if (rc)
  78         return rc;
  79
  80     if (lstat(client->filename, &st) == 0 && client->mtime) {
  81         if (client->mtime != st.st_mtime)
  82             return EPWMD_FILE_MODIFIED;
  83     }
  84
  85     pth_cancel_point();
  86     return 0;
  87 }
  88
  89 static gpg_error_t parse_xml(assuan_context_t ctx)
  90 {
  91     struct client_s *client = assuan_get_pointer(ctx);
  92
  93     client->doc = xmlReadMemory(client->xml, client->len, NULL, "UTF-8", XML_PARSE_NOBLANKS);
  94
  95     if (!client->doc)
  96         return EPWMD_LIBXML_ERROR;
  97
  98     return 0;
  99 }
 100
 101 void unlock_file_mutex(struct client_s *client)
 102 {
 103     pth_mutex_t *m;
 104
 105 #ifdef WITH_PINENTRY
 106     if (client->has_lock == FALSE || client->pinentry->status != PINENTRY_NONE)
 107 #else
 108     if (client->has_lock == FALSE)
 109 #endif
 110         return;
 111
 112     CACHE_LOCK(client->ctx);
 113
 114     if (cache_get_mutex(client->md5file, &m) == FALSE) {
 115         CACHE_UNLOCK;
 116         return;
 117     }
 118
 119     CACHE_UNLOCK;
 120     MUTEX_UNLOCK(m);
 121     client->has_lock = client->is_lock_cmd = FALSE;
 122 }
 123
 124 gpg_error_t lock_file_mutex(struct client_s *client)
 125 {
 126     pth_mutex_t *m;
 127     gpg_error_t rc = 0;
 128
 129     if (client->has_lock == TRUE)
 130         return 0;
 131
 132     CACHE_LOCK(client->ctx);
 133
 134     if (cache_get_mutex(client->md5file, &m) == FALSE) {
 135         CACHE_UNLOCK;
 136         return 0;
 137     }
 138
 139     CACHE_UNLOCK;
 140     MUTEX_TRYLOCK(client->ctx, m, rc);
 141
 142     if (!rc)
 143         client->has_lock = TRUE;
 144
 145     return rc;
 146 }
 147
 148 void free_client(struct client_s *client)
 149 {
 150     if (client->doc)
 151         xmlFreeDoc(client->doc);
 152
 153     if (client->xml)
 154         gcry_free(client->xml);
 155
 156     if (client->filename)
 157         g_free(client->filename);
 158
 159     if (client->crypto)
 160         cleanup_crypto(&client->crypto);
 161
 162     if (client->xml_error)
 163         xmlResetError(client->xml_error);
 164 }
 165
 166 void cleanup_client(struct client_s *client)
 167 {
 168     assuan_context_t ctx = client->ctx;
 169     struct client_thread_s *thd = client->thd;
 170     gboolean has_lock = client->has_lock;
 171 #ifdef WITH_PINENTRY
 172     struct pinentry_s *pin = client->pinentry;
 173 #endif
 174
 175     unlock_file_mutex(client);
 176     CACHE_LOCK(client->ctx);
 177     cache_decr_refcount(client->md5file);
 178
 179     /*
 180      * This may be a new file so don't use a cache slot. save_command() will
 181      * set this to FALSE on success.
 182      */
 183     if (client->new == TRUE)
 184         cache_clear(client->md5file, 1);
 185
 186     CACHE_UNLOCK;
 187     free_client(client);
 188     memset(client, 0, sizeof(struct client_s));
 189     client->state = STATE_CONNECTED;
 190     client->ctx = ctx;
 191     client->thd = thd;
 192     client->freed = TRUE;
 193 #ifdef WITH_PINENTRY
 194     client->pinentry = pin;
 195 #endif
 196     client->has_lock = has_lock;
 197 }
 198
 199 static void gz_cleanup(void *arg)
 200 {
 201     struct gz_s **gz = (struct gz_s **)arg;
 202
 203     if (!gz)
 204         return;
 205
 206     if (!(*gz)->done && (*gz)->out)
 207         gcry_free((*gz)->out);
 208
 209
 210     if ((*gz)->which == STATUS_COMPRESS) {
 211         if ((*gz)->z.zalloc)
 212             deflateEnd(&(*gz)->z);
 213     }
 214     else {
 215         if ((*gz)->z.zalloc)
 216             inflateEnd(&(*gz)->z);
 217     }
 218
 219     g_free(*gz);
 220     *gz = NULL;
 221 }
 222
 223 gboolean do_decompress(assuan_context_t ctx, gpointer in, gulong insize,
 224         gpointer *out, gulong *outsize, gint *rc)
 225 {
 226     struct gz_s *gz;
 227     gz_header h;
 228     gchar buf[17];
 229
 230     gz = g_malloc0(sizeof(struct gz_s));
 231
 232     if (!gz) {
 233         *rc = gpg_error_from_errno(ENOMEM);
 234         return FALSE;
 235     }
 236
 237     gz->which = STATUS_DECOMPRESS;
 238     gz->z.zalloc = z_alloc;
 239     gz->z.zfree = z_free;
 240     gz->z.next_in = in;
 241     gz->z.avail_in = (uInt)insize;
 242     gz->z.avail_out = zlib_bufsize;
 243     gz->z.next_out = gz->out = gcry_malloc(zlib_bufsize);
 244
 245     if (!gz->out) {
 246         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 247         *rc = Z_MEM_ERROR;
 248         gz_cleanup(&gz);
 249         return FALSE;
 250     }
 251
 252     *rc = inflateInit2(&gz->z, 47);
 253
 254     if (*rc != Z_OK) {
 255         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 256         gz_cleanup(&gz);
 257         return FALSE;
 258     }
 259
 260     memset(&h, 0, sizeof(gz_header));
 261     h.comment = (guchar *)buf;
 262     h.comm_max = sizeof(buf);
 263     *rc = inflateGetHeader(&gz->z, &h);
 264
 265     if (*rc != Z_OK) {
 266         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 267         gz_cleanup(&gz);
 268         return FALSE;
 269     }
 270
 271     *rc = inflate(&gz->z, Z_BLOCK);
 272
 273     if (*rc != Z_OK) {
 274         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 275         gz_cleanup(&gz);
 276         return FALSE;
 277     }
 278
 279     if (h.comment)
 280         insize = (gulong)strtol((gchar *)h.comment, NULL, 10);
 281
 282     do {
 283         gpointer p;
 284
 285         *rc = inflate(&gz->z, Z_FINISH);
 286
 287         switch (*rc) {
 288             case Z_OK:
 289                 break;
 290             case Z_BUF_ERROR:
 291                 if (!gz->z.avail_out) {
 292                     p = gcry_realloc(gz->out, gz->z.total_out + zlib_bufsize);
 293
 294                     if (!p) {
 295                         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 296                         *rc = Z_MEM_ERROR;
 297                         goto fail;
 298                     }
 299
 300                     gz->out = p;
 301                     gz->z.next_out = gz->out + gz->z.total_out;
 302                     gz->z.avail_out = zlib_bufsize;
 303                     *rc = send_status(ctx, STATUS_DECOMPRESS, "%li %li",
 304                             gz->z.total_out, insize);
 305
 306                     if (*rc)
 307                         goto fail;
 308                 }
 309                 break;
 310             case Z_STREAM_END:
 311                 break;
 312             default:
 313                 goto fail;
 314                 break;
 315         }
 316     } while (*rc != Z_STREAM_END);
 317
 318     pth_cancel_point();
 319     *rc = send_status(ctx, STATUS_DECOMPRESS, "%li %li", gz->z.total_out,
 320             insize);
 321     pth_cancel_point();
 322
 323     if (*rc)
 324         goto fail;
 325
 326     *out = gz->out;
 327     *outsize = gz->z.total_out;
 328     gz->done = TRUE;
 329     gz_cleanup(&gz);
 330     *rc = 0;
 331     return TRUE;
 332
 333 fail:
 334     log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 335     gz_cleanup(&gz);
 336     return FALSE;
 337 }
 338
 339 file_header_internal_t *read_file_header(const gchar *filename, gboolean v1,
 340         gpg_error_t *rc)
 341 {
 342     gint fd;
 343     gsize len;
 344     file_header_internal_t *fh = g_malloc0(sizeof(file_header_internal_t));
 345     gsize fh_size;
 346
 347     *rc = 0;
 348
 349     if (!fh) {
 350         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 351         *rc = gpg_error_from_errno(ENOMEM);
 352         return NULL;
 353     }
 354
 355     fh_size = v1 ? sizeof(fh->fh1) : sizeof(fh->fh2);
 356
 357     if (lstat(filename, &fh->st) == -1) {
 358         *rc = gpg_error_from_syserror();
 359         g_free(fh);
 360         return NULL;
 361     }
 362
 363     if (!S_ISREG(fh->st.st_mode)) {
 364         *rc = GPG_ERR_ENOANO;
 365         g_free(fh);
 366         return NULL;
 367     }
 368
 369     fd = open(filename, O_RDONLY);
 370
 371     if (fd == -1) {
 372         *rc = gpg_error_from_errno(errno);
 373         g_free(fh);
 374         return NULL;
 375     }
 376
 377     if (v1)
 378         len = pth_read(fd, &fh->fh1, fh_size);
 379     else
 380         len = pth_read(fd, &fh->fh2, fh_size);
 381
 382     if (len != fh_size) {
 383         gint n = errno;
 384         close(fd);
 385         g_free(fh);
 386         *rc = gpg_error_from_errno(n);
 387         return NULL;
 388     }
 389
 390     fh->v1 = v1;
 391     fh->fd = fd;
 392     return fh;
 393 }
 394
 395 static gpg_error_t open_command_finalize(assuan_context_t ctx, guchar *key,
 396         gboolean cached)
 397 {
 398     struct client_s *client = assuan_get_pointer(ctx);
 399     gpg_error_t rc;
 400     gint timeout;
 401
 402     /* New file. */
 403     if (!client->crypto->fh) {
 404         if (key[0])
 405             goto update_cache;
 406
 407         goto done;
 408     }
 409
 410     rc = try_xml_decrypt(ctx, key, client->crypto, NULL, NULL);
 411
 412     if (rc) {
 413         cleanup_client(client);
 414         return send_error(ctx, rc);
 415     }
 416
 417 update_cache:
 418     CACHE_LOCK(client->ctx);
 419
 420     if (cached == FALSE) {
 421         if (cache_update_key(client->md5file, key) == FALSE) {
 422             cleanup_client(client);
 423             CACHE_UNLOCK;
 424             return send_syserror(ctx, ENOMEM);
 425         }
 426
 427         timeout = get_key_file_integer(client->filename, "cache_timeout");
 428         cache_reset_timeout(client->md5file, timeout);
 429     }
 430     else
 431         cache_set_timeout(client->md5file, -2);
 432
 433     CACHE_UNLOCK;
 434
 435 done:
 436     rc = parse_xml(ctx);
 437
 438     if (client->xml) {
 439         gcry_free(client->xml);
 440         client->xml = NULL;
 441     }
 442
 443     if (!rc) {
 444         if (client->new == FALSE)
 445             send_status_all(STATUS_CACHE);
 446
 447         client->state = STATE_OPEN;
 448     }
 449
 450     if (!rc && client->new == FALSE &&
 451             client->crypto->fh->fh2.iter != (guint64)get_key_file_integer(client->filename, "iterations")) {
 452         MUTEX_LOCK(&rcfile_mutex);
 453         g_key_file_set_integer(keyfileh, client->filename, "iterations",
 454                 client->crypto->fh->fh2.iter);
 455         MUTEX_UNLOCK(&rcfile_mutex);
 456         send_status_all(STATUS_CONFIG);
 457     }
 458
 459     if (!rc)
 460         log_write("OPEN '%s'", client->filename);
 461
 462     cleanup_crypto(&client->crypto);
 463     return send_error(ctx, rc);
 464 }
 465
 466 static void req_cleanup(void *arg)
 467 {
 468     if (!arg)
 469         return;
 470
 471     g_strfreev((gchar **)arg);
 472 }
 473
 474 static int open_command(assuan_context_t ctx, char *line)
 475 {
 476     gboolean cached = FALSE;
 477     gpg_error_t rc;
 478     struct client_s *client = assuan_get_pointer(ctx);
 479     gchar **req;
 480     gchar *filename = NULL;
 481
 482     if ((req = split_input_line(line, " ", 2)) != NULL)
 483         filename = req[0];
 484
 485     if (!filename || !*filename) {
 486         g_strfreev(req);
 487         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
 488     }
 489
 490     if (valid_filename(filename) == FALSE) {
 491         g_strfreev(req);
 492         return send_error(ctx, EPWMD_INVALID_FILENAME);
 493     }
 494
 495     if (client->state == STATE_OPEN)
 496         cleanup_client(client);
 497
 498     gcry_md_hash_buffer(GCRY_MD_MD5, client->md5file, filename, strlen(filename));
 499     CACHE_LOCK(client->ctx);
 500
 501     if (cache_has_file(client->md5file) == FALSE) {
 502         if (cache_add_file(client->md5file, NULL) == FALSE) {
 503             g_strfreev(req);
 504             CACHE_UNLOCK;
 505             return send_syserror(ctx, ENOMEM);
 506         }
 507     }
 508
 509     cache_incr_refcount(client->md5file);
 510     CACHE_UNLOCK;
 511     rc = lock_file_mutex(client);
 512
 513     if (rc) {
 514         g_strfreev(req);
 515         return send_error(ctx, rc);
 516     }
 517
 518     client->freed = FALSE;
 519     client->crypto = init_client_crypto();
 520
 521     if (!client->crypto) {
 522         g_strfreev(req);
 523         cleanup_client(client);
 524         return send_syserror(ctx, ENOMEM);
 525     }
 526
 527     client->crypto->key = gcry_malloc(gcrykeysize);
 528
 529     if (!client->crypto->key) {
 530         g_strfreev(req);
 531         log_write("%s(%i): %s", __FUNCTION__, __LINE__,
 532                 gpg_error_from_errno(ENOMEM));
 533         cleanup_client(client);
 534         return send_syserror(ctx, ENOMEM);
 535     }
 536
 537     memset(client->crypto->key, 0, gcrykeysize);
 538     client->crypto->fh = read_file_header(filename, FALSE, &rc);
 539     pth_cancel_point();
 540
 541     if (!client->crypto->fh) {
 542         if (gpg_err_code_to_errno(rc) != ENOENT) {
 543             log_write("%s: %s", filename, pwmd_strerror(rc));
 544             g_strfreev(req);
 545             cleanup_client(client);
 546             return send_error(ctx, rc);
 547         }
 548
 549         /*
 550          * New files don't need a key.
 551          */
 552         if ((client->xml = new_document()) == NULL) {
 553             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 554             g_strfreev(req);
 555             cleanup_client(client);
 556             return send_syserror(ctx, ENOMEM);
 557         }
 558
 559         client->len = xmlStrlen(client->xml);
 560         client->new = TRUE;
 561         client->filename = g_strdup(filename);
 562
 563         if (!client->filename) {
 564             g_strfreev(req);
 565             cleanup_client(client);
 566             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 567             return send_syserror(ctx, ENOMEM);
 568         }
 569
 570         if (req[1] && *req[1])
 571             gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, req[1],
 572                     strlen(req[1]));
 573
 574         g_strfreev(req);
 575 #ifdef WITH_PINENTRY
 576         client->pinentry->filename = g_strdup(client->filename);
 577
 578         if (!client->pinentry->filename) {
 579             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 580             cleanup_client(client);
 581             return send_syserror(ctx, ENOMEM);
 582         }
 583 #endif
 584         return open_command_finalize(ctx, client->crypto->key, cached);
 585     }
 586     else
 587         client->mtime = client->crypto->fh->st.st_mtime;
 588
 589     client->filename = g_strdup(filename);
 590
 591     if (!client->filename) {
 592         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 593         g_strfreev(req);
 594         cleanup_client(client);
 595         return send_syserror(ctx, ENOMEM);
 596     }
 597
 598 #ifdef WITH_PINENTRY
 599     client->pinentry->filename = g_strdup(client->filename);
 600
 601     if (!client->pinentry->filename) {
 602         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 603         g_strfreev(req);
 604         cleanup_client(client);
 605         return send_syserror(ctx, ENOMEM);
 606     }
 607 #endif
 608
 609     if (client->crypto->fh->fh2.iter <= 0)
 610         goto done;
 611
 612     CACHE_LOCK(client->ctx);
 613     cached = cache_get_key(client->md5file, client->crypto->key);
 614     CACHE_UNLOCK;
 615
 616     if (cached == FALSE) {
 617         gchar *tmp = get_key_file_string(filename, "key_file");
 618
 619         if (tmp) {
 620             g_free(tmp);
 621             cleanup_client(client);
 622             return send_error(ctx, GPG_ERR_WRONG_KEY_USAGE);
 623         }
 624
 625         /*
 626          * No key specified and no matching filename found in the cache. Use
 627          * pinentry to retrieve the key. Cannot return assuan_process_done()
 628          * here otherwise the command will be interrupted. The event loop in
 629          * client_thread() will poll the file descriptor waiting for it to
 630          * become ready to read a pinentry_key_s which will contain the
 631          * entered key or an error code. It will then call
 632          * open_command_finalize() to to finish the command.
 633          */
 634         if (!req[1] || !*req[1]) {
 635 #ifdef WITH_PINENTRY
 636             gboolean b = get_key_file_boolean(filename, "enable_pinentry");
 637
 638             /* From set_pinentry_defaults(). */
 639             if (client->pinentry->enable == FALSE ||
 640                     (client->pinentry->enable == -1 && b == FALSE)) {
 641                 gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, "", 1);
 642                 goto done;
 643             }
 644
 645             g_strfreev(req);
 646             rc = lock_pin_mutex(client);
 647
 648             if (rc) {
 649                 unlock_pin_mutex(client->pinentry);
 650                 cleanup_client(client);
 651                 return send_error(ctx, rc);
 652             }
 653
 654             client->pinentry->which = PINENTRY_OPEN;
 655             rc = pinentry_fork(ctx);
 656
 657             if (rc) {
 658                 unlock_pin_mutex(client->pinentry);
 659                 cleanup_client(client);
 660                 return send_error(ctx, rc);
 661             }
 662
 663             // Called from pinentry iterate.
 664             client->pinentry->cb = open_command_finalize;
 665             client->pinentry->status = PINENTRY_INIT;
 666             return 0;
 667 #else
 668             gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, "", 1);
 669             goto done;
 670 #endif
 671         }
 672
 673         gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, req[1],
 674                 strlen(req[1]));
 675     }
 676
 677 done:
 678     req_cleanup(req);
 679     return open_command_finalize(ctx, client->crypto->key, cached);
 680 }
 681
 682 gboolean do_compress(assuan_context_t ctx, gint level, gpointer data,
 683         gulong size, gpointer *out, gulong *outsize, gint *rc)
 684 {
 685     struct gz_s *gz;
 686     gz_header h;
 687     gchar buf[17];
 688     gint cmd = Z_NO_FLUSH;
 689
 690     gz = g_malloc0(sizeof(struct gz_s));
 691
 692     if (!gz) {
 693         *rc = gpg_error_from_errno(ENOMEM);
 694         return FALSE;
 695     }
 696
 697     gz->which = STATUS_COMPRESS;
 698     gz->z.zalloc = z_alloc;
 699     gz->z.zfree = z_free;
 700     gz->z.next_in = data;
 701     gz->z.avail_in = size < zlib_bufsize ? (uInt)size : (uInt)zlib_bufsize;
 702     gz->z.avail_out = (uInt)zlib_bufsize;
 703     gz->z.next_out = gz->out = gcry_malloc(zlib_bufsize);
 704
 705     if (!gz->out) {
 706         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
 707         *rc = Z_MEM_ERROR;
 708         gz_cleanup(&gz);
 709         return FALSE;
 710     }
 711
 712     *rc = deflateInit2(&gz->z, level, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY);
 713
 714     if (*rc != Z_OK) {
 715         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 716         gz_cleanup(&gz);
 717         return FALSE;
 718     }
 719
 720     /* Rather than store the size of the uncompressed data in the file header,
 721      * store it in the comment field of the gzip header. Don't give anyone too
 722      * much information. Not sure why really, but it seems the right way. :)
 723      */
 724     memset(&h, 0, sizeof(gz_header));
 725     g_snprintf(buf, sizeof(buf), "%li", size);
 726     h.comment = (guchar *)buf;
 727     *rc = deflateSetHeader(&gz->z, &h);
 728
 729     if (*rc != Z_OK) {
 730         log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 731         gz_cleanup(&gz);
 732         return FALSE;
 733     }
 734
 735     do {
 736         gpointer p;
 737
 738         *rc = deflate(&gz->z, cmd);
 739
 740         switch (*rc) {
 741             case Z_OK:
 742                 break;
 743             case Z_BUF_ERROR:
 744                 if (!gz->z.avail_out) {
 745                     p = gcry_realloc(gz->out, gz->z.total_out + zlib_bufsize);
 746
 747                     if (!p) {
 748                         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 749                         *rc = Z_MEM_ERROR;
 750                         goto fail;
 751                     }
 752
 753                     gz->out = p;
 754                     gz->z.next_out = gz->out + gz->z.total_out;
 755                     gz->z.avail_out = zlib_bufsize;
 756                 }
 757
 758                 if (!gz->z.avail_in && gz->z.total_in < size) {
 759                     if (gz->z.total_in + zlib_bufsize > size)
 760                         gz->z.avail_in = size - gz->z.total_in;
 761                     else
 762                         gz->z.avail_in = zlib_bufsize;
 763
 764                     *rc = send_status(ctx, STATUS_COMPRESS, "%li %li",
 765                             gz->z.total_in, size);
 766
 767                     if (*rc)
 768                         goto fail;
 769                 }
 770
 771                 if (gz->z.total_in >= size)
 772                     cmd = Z_FINISH;
 773
 774                 break;
 775             case Z_STREAM_END:
 776                 break;
 777             default:
 778                 goto fail;
 779         }
 780     } while (*rc != Z_STREAM_END);
 781
 782     pth_cancel_point();
 783     *rc = send_status(ctx, STATUS_COMPRESS, "%li %li", gz->z.total_in, size);
 784     pth_cancel_point();
 785
 786     if (*rc)
 787         goto fail;
 788
 789     *out = gz->out;
 790     *outsize = gz->z.total_out;
 791     *rc = 0;
 792     gz->done = TRUE;
 793     gz_cleanup(&gz);
 794     return TRUE;
 795
 796 fail:
 797     log_write("%s(%i): %s", __FUNCTION__, __LINE__, gz->z.msg);
 798     gz_cleanup(&gz);
 799     return FALSE;
 800 }
 801
 802 #define CRYPTO_BLOCKSIZE (gcryblocksize * 1024)
 803
 804 static gpg_error_t iterate_crypto_once(struct client_s *client,
 805         struct client_crypto_s *crypto, status_msg_t which)
 806 {
 807     gpg_error_t rc = 0;
 808     goffset len = CRYPTO_BLOCKSIZE;
 809     gpointer p = gcry_malloc(len);
 810     goffset total = 0;
 811     gpointer inbuf;
 812
 813     if (!p)
 814         return gpg_err_code_from_errno(ENOMEM);
 815
 816     if (crypto->insize < CRYPTO_BLOCKSIZE)
 817         len = crypto->insize;
 818
 819     for (;;) {
 820         inbuf = crypto->inbuf + total;
 821         guchar *tmp;
 822
 823         if (len + total > crypto->insize)
 824             len = gcryblocksize;
 825
 826         if (which == STATUS_ENCRYPT)
 827             rc = gcry_cipher_encrypt(crypto->gh, p, len, inbuf, len);
 828         else
 829             rc = gcry_cipher_decrypt(crypto->gh, p, len, inbuf, len);
 830
 831         if (rc)
 832             goto done;
 833
 834         tmp = crypto->inbuf+total;
 835         memmove(tmp, p, len);
 836         total += len;
 837
 838         if (total >= crypto->insize)
 839             break;
 840
 841         pth_cancel_point();
 842     }
 843
 844 done:
 845     gcry_free(p);
 846     return rc;
 847 }
 848
 849 /* The crypto struct must be setup for iterations and .key. */
 850 gpg_error_t do_xml_encrypt(struct client_s *client,
 851         struct client_crypto_s *crypto, const gchar *filename)
 852 {
 853     goffset len = crypto->insize;
 854     gpointer inbuf;
 855     gchar *p;
 856     gpg_error_t rc;
 857     guint64 iter_progress = 0, n_iter = 0, xiter = 0;
 858     gchar tmp[FILENAME_MAX];
 859     struct stat st;
 860     mode_t mode = 0;
 861
 862     if (!crypto->fh->fh2.iter) {
 863         /*
 864          * cache_file_count() needs both .used == TRUE and a valid key in
 865          * order for it to count as a used cache entry. Fixes CACHE status
 866          * messages.
 867          */
 868         memset(crypto->key, '!', gcrykeysize);
 869         goto write_file;
 870     }
 871
 872     /*
 873      * Resize the existing xml buffer to the block size required by gcrypt
 874      * rather than duplicating it and wasting memory.
 875      */
 876     if (crypto->insize / gcryblocksize) {
 877         len = (crypto->insize / gcryblocksize) * gcryblocksize;
 878
 879         if (crypto->insize % gcryblocksize)
 880             len += gcryblocksize;
 881     }
 882
 883     inbuf = gcry_realloc(crypto->inbuf, len);
 884
 885     if (!inbuf) {
 886         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 887         return gpg_error_from_errno(ENOMEM);
 888     }
 889
 890     crypto->inbuf = inbuf;
 891     crypto->insize = len;
 892     gcry_create_nonce(crypto->fh->fh2.iv, sizeof(crypto->fh->fh2.iv));
 893     crypto->tkey = gcry_malloc(gcrykeysize);
 894
 895     if (!crypto->tkey) {
 896         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
 897         return gpg_error_from_errno(ENOMEM);
 898     }
 899
 900     memcpy(crypto->tkey, crypto->key, gcrykeysize);
 901     guchar *tkey = crypto->tkey;
 902     tkey[0] ^= 1;
 903
 904     if ((rc = gcry_cipher_setkey(crypto->gh, crypto->tkey, gcrykeysize))) {
 905         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
 906         return rc;
 907     }
 908
 909     iter_progress = (guint64)get_key_file_integer(
 910             client ? client->filename : "global", "iteration_progress");
 911
 912     if (iter_progress && crypto->fh->fh2.iter >= iter_progress) {
 913         rc = send_status(client ? client->ctx : NULL, STATUS_ENCRYPT,
 914                 "0 %llu", crypto->fh->fh2.iter);
 915         pth_cancel_point();
 916
 917         if (rc)
 918             return rc;
 919     }
 920
 921     while (xiter < crypto->fh->fh2.iter-1) {
 922         if (iter_progress > 0 && xiter >= iter_progress) {
 923             if (!(xiter % iter_progress)) {
 924                 rc = send_status(client ? client->ctx : NULL, STATUS_ENCRYPT,
 925                         "%llu %llu", ++n_iter * iter_progress,
 926                         crypto->fh->fh2.iter);
 927                 pth_cancel_point();
 928
 929                 if (rc)
 930                     return rc;
 931             }
 932         }
 933
 934         if ((rc = gcry_cipher_setiv(crypto->gh, crypto->fh->fh2.iv,
 935                         sizeof(crypto->fh->fh2.iv)))) {
 936             log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
 937             return rc;
 938         }
 939
 940         rc = iterate_crypto_once(client, crypto, STATUS_ENCRYPT);
 941
 942         if (rc) {
 943             log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
 944             return rc;
 945         }
 946
 947         xiter++;
 948     }
 949
 950     if ((rc = gcry_cipher_setiv(crypto->gh, crypto->fh->fh2.iv,
 951                     sizeof(crypto->fh->fh2.iv)))) {
 952         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
 953         return rc;
 954     }
 955
 956     if ((rc = gcry_cipher_setkey(crypto->gh, crypto->key, gcrykeysize))) {
 957         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
 958         return rc;
 959     }
 960
 961     rc = iterate_crypto_once(client, crypto, STATUS_ENCRYPT);
 962
 963     if (rc)
 964         return rc;
 965
 966     if (iter_progress && crypto->fh->fh2.iter >= iter_progress) {
 967         rc = send_status(client ? client->ctx : NULL, STATUS_ENCRYPT,
 968                 "%llu %llu", crypto->fh->fh2.iter, crypto->fh->fh2.iter);
 969         pth_cancel_point();
 970
 971         if (rc)
 972             return rc;
 973     }
 974
 975 write_file:
 976     if (filename) {
 977         if (!client && !strcmp(filename, "-")) {
 978             crypto->fh->fd = STDOUT_FILENO;
 979             goto do_write_file;
 980         }
 981
 982         if (lstat(filename, &st) == 0) {
 983             pth_cancel_point();
 984             mode = st.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO);
 985
 986             /*
 987              * FIXME What if the file has an ACL?
 988              */
 989             if (!(mode & S_IWUSR))
 990                 return gpg_error_from_errno(EACCES);
 991         }
 992         else {
 993             pth_cancel_point();
 994             if (errno != ENOENT)
 995                 return gpg_error_from_errno(errno);
 996         }
 997
 998         g_snprintf(tmp, sizeof(tmp), "%s.XXXXXX", filename);
 999         crypto->fh->fd = mkstemp(tmp);
1000
1001         if (crypto->fh->fd == -1) {
1002             rc = errno;
1003             p = strrchr(tmp, '/');
1004             p++;
1005             log_write("%s: %s", p, strerror(rc));
1006             return gpg_error_from_errno(rc);
1007         }
1008     }
1009     else
1010         /*
1011          * xml_import() or convert_file() from command line.
1012          */
1013         crypto->fh->fd = STDOUT_FILENO;
1014
1015 do_write_file:
1016     crypto->fh->fh2.version = VERSION_HEX;
1017     len = pth_write(crypto->fh->fd, &crypto->fh->fh2, sizeof(crypto->fh->fh2));
1018     pth_cancel_point();
1019
1020     if (len != sizeof(crypto->fh->fh2)) {
1021         len = errno;
1022
1023         if (filename && strcmp(filename, "-"))
1024             unlink(tmp);
1025
1026         return gpg_error_from_errno(len);
1027     }
1028
1029     len = pth_write(crypto->fh->fd, crypto->inbuf, crypto->insize);
1030     pth_cancel_point();
1031
1032     if (len != crypto->insize) {
1033         pth_cancel_point();
1034         len = errno;
1035
1036         if (filename && strcmp(filename, "-")) {
1037             unlink(tmp);
1038             pth_cancel_point();
1039         }
1040
1041         return gpg_error_from_errno(len);
1042     }
1043
1044     if (fsync(crypto->fh->fd) == -1) {
1045         pth_cancel_point();
1046         len = errno;
1047
1048         if (filename && strcmp(filename, "-"))
1049             unlink(tmp);
1050
1051         return gpg_error_from_errno(len);
1052     }
1053
1054     if (filename && strcmp(filename, "-")) {
1055         if (mode && get_key_file_boolean(filename, "backup") == TRUE) {
1056             gchar tmp2[FILENAME_MAX];
1057
1058             g_snprintf(tmp2, sizeof(tmp2), "%s.backup", filename);
1059
1060             if (rename(filename, tmp2) == -1) {
1061                 pth_cancel_point();
1062                 unlink(tmp);
1063                 len = errno;
1064                 return gpg_error_from_errno(len);
1065             }
1066         }
1067
1068         if (rename(tmp, filename) == -1) {
1069             pth_cancel_point();
1070             len = errno;
1071             unlink(tmp);
1072             return gpg_error_from_errno(len);
1073         }
1074
1075         if (mode) {
1076             chmod(filename, mode);
1077             pth_cancel_point();
1078         }
1079     }
1080
1081     if (client && lstat(filename, &st) == 0)
1082         client->mtime = st.st_mtime;
1083
1084     pth_cancel_point();
1085     return 0;
1086 }
1087
1088 static gpg_error_t save_command_finalize(assuan_context_t ctx, guchar *key,
1089         gboolean cached)
1090 {
1091     struct client_s *client = assuan_get_pointer(ctx);
1092     gpointer xmlbuf;
1093     gulong len, outsize = 0;
1094     guint iter;
1095     gint timeout;
1096     gpointer outbuf;
1097     gint zrc;
1098     gpg_error_t rc;
1099
1100     if (client->crypto->key && client->crypto->key != key)
1101         gcry_free(client->crypto->key);
1102
1103     client->crypto->key = key;
1104     xmlDocDumpFormatMemory(client->doc, (xmlChar **)&xmlbuf, (gint *)&len, 0);
1105     iter = (guint)get_key_file_integer(client->filename, "compression_level");
1106
1107     if (iter < 0)
1108         iter = 0;
1109
1110     if (do_compress(ctx, (gint)iter, xmlbuf, len, &outbuf, &outsize, &zrc)
1111             == FALSE) {
1112         xmlFree(xmlbuf);
1113         cleanup_crypto(&client->crypto);
1114
1115         if (zrc == Z_MEM_ERROR)
1116             return send_syserror(ctx, ENOMEM);
1117         else
1118             return send_error(ctx, GPG_ERR_COMPR_ALGO);
1119     }
1120     else {
1121         gcry_free(xmlbuf);
1122         xmlbuf = outbuf;
1123         len = outsize;
1124     }
1125
1126     client->crypto->fh = g_malloc0(sizeof(file_header_internal_t));
1127
1128     if (!client->crypto->fh) {
1129         cleanup_crypto(&client->crypto);
1130         gcry_free(outbuf);
1131         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1132         return send_syserror(ctx, ENOMEM);
1133     }
1134
1135     iter = get_key_file_integer(client->filename, "iterations");
1136     client->crypto->fh->fh2.iter = iter < 0 ? 0 : iter;
1137     client->crypto->inbuf = xmlbuf;
1138     client->crypto->insize = len;
1139     rc = do_xml_encrypt(client, client->crypto, client->filename);
1140
1141     if (rc) {
1142         cleanup_crypto(&client->crypto);
1143         return send_error(ctx, rc);
1144     }
1145
1146     timeout = get_key_file_integer(client->filename, "cache_timeout");
1147     CACHE_LOCK(client->ctx);
1148
1149     if (cached) {
1150         cache_reset_timeout(client->md5file, timeout);
1151         CACHE_UNLOCK;
1152
1153         if (client->new == TRUE)
1154             send_status_all(STATUS_CACHE);
1155
1156         client->new = FALSE;
1157         cleanup_crypto(&client->crypto);
1158         return send_error(ctx, 0);
1159     }
1160
1161     if (cache_update_key(client->md5file, client->crypto->key) == FALSE) {
1162         CACHE_UNLOCK;
1163         cleanup_crypto(&client->crypto);
1164         return send_syserror(ctx, ENOMEM);
1165     }
1166
1167     client->new = FALSE;
1168     cache_reset_timeout(client->md5file, timeout);
1169     CACHE_UNLOCK;
1170     send_status_all(STATUS_CACHE);
1171     cleanup_crypto(&client->crypto);
1172     return send_error(ctx, 0);
1173 }
1174
1175 static int save_command(assuan_context_t ctx, char *line)
1176 {
1177     gboolean cached = FALSE;
1178     struct stat st;
1179     struct client_s *client = assuan_get_pointer(ctx);
1180     gpg_error_t rc;
1181
1182     rc = lock_file_mutex(client);
1183
1184     if (rc)
1185         return send_error(ctx, rc);
1186
1187     rc = file_modified(client);
1188
1189     if (rc)
1190         return send_error(ctx, rc);
1191
1192     if (lstat(client->filename, &st) == -1 && errno != ENOENT)
1193         return send_syserror(ctx, errno);
1194
1195     if (errno != ENOENT && !S_ISREG(st.st_mode)) {
1196         log_write("%s: %s", client->filename, pwmd_strerror(GPG_ERR_ENOANO));
1197         return send_error(ctx, GPG_ERR_ENOANO);
1198     }
1199
1200     CACHE_LOCK(ctx);
1201     cached = cache_iscached(client->md5file);
1202     CACHE_UNLOCK;
1203
1204     /*
1205      * If a cache entry doesn't exist for this file and the file has a
1206      * "key_file" or "key" parameter, then it's an error. The reason is that
1207      * cache expiration would be useless.
1208      */
1209     if (cached == FALSE) {
1210         gchar *tmp = get_key_file_string(client->filename, "key_file");
1211
1212         if (tmp) {
1213             g_free(tmp);
1214             return send_error(ctx, GPG_ERR_WRONG_KEY_USAGE);
1215         }
1216     }
1217
1218     cached = FALSE;
1219     client->crypto = init_client_crypto();
1220
1221     if (!client->crypto) {
1222         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1223         return send_syserror(ctx, ENOMEM);
1224     }
1225
1226     client->crypto->key = gcry_malloc(gcrykeysize);
1227
1228     if (!client->crypto->key) {
1229         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1230         cleanup_crypto(&client->crypto);
1231         return send_syserror(ctx, ENOMEM);
1232     }
1233
1234     memset(client->crypto->key, '!', gcrykeysize);
1235
1236     if (get_key_file_integer(client->filename, "iterations") <= 0)
1237         goto done;
1238
1239     if (!line || !*line) {
1240         client->crypto->tkey = gcry_malloc(gcrykeysize);
1241
1242         if (!client->crypto->tkey) {
1243             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1244             cleanup_crypto(&client->crypto);
1245             return send_syserror(ctx, ENOMEM);
1246         }
1247
1248         memset(client->crypto->tkey, '!', gcrykeysize);
1249         CACHE_LOCK(ctx);
1250
1251         if (cache_get_key(client->md5file, client->crypto->key) == FALSE ||
1252                 memcmp(client->crypto->key, client->crypto->tkey,
1253                     gcrykeysize) == 0) {
1254             CACHE_UNLOCK;
1255
1256 #ifdef WITH_PINENTRY
1257             if (client->pinentry->enable == FALSE ||
1258                     get_key_file_boolean(client->filename, "enable_pinentry") == FALSE) {
1259                 /* Empty keys are allowed. */
1260                 gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, "", 1);
1261                 goto done;
1262             }
1263
1264             lock_pin_mutex(client);
1265             client->pinentry->which = PINENTRY_SAVE;
1266             rc = pinentry_fork(ctx);
1267
1268             if (rc) {
1269                 unlock_pin_mutex(client->pinentry);
1270                 return send_error(ctx, rc);
1271             }
1272
1273             client->pinentry->cb = save_command_finalize;
1274             client->pinentry->status = PINENTRY_INIT;
1275             return 0;
1276 #else
1277             /* Empty keys are allowed. */
1278             gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, "", 1);
1279             goto done;
1280 #endif
1281         }
1282         else {
1283             CACHE_UNLOCK;
1284             cached = TRUE;
1285         }
1286     }
1287     else {
1288         gcry_md_hash_buffer(GCRY_MD_SHA256, client->crypto->key, line,
1289                 strlen(line));
1290         memset(line, 0, strlen(line));
1291     }
1292
1293 done:
1294     return save_command_finalize(ctx, client->crypto->key, cached);
1295 }
1296
1297 static int delete_command(assuan_context_t ctx, char *line)
1298 {
1299     struct client_s *client = assuan_get_pointer(ctx);
1300     gchar **req;
1301     gpg_error_t rc;
1302     xmlNodePtr n;
1303
1304     rc = file_modified(client);
1305
1306     if (rc)
1307         return send_error(ctx, rc);
1308
1309     if (strchr(line, '\t'))
1310         req = split_input_line(line, "\t", -1);
1311     else
1312         req = split_input_line(line, " ", -1);
1313
1314     if (!req || !*req)
1315         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1316
1317     n = find_account(client->doc, &req, &rc, NULL, 0);
1318
1319     if (!n) {
1320         g_strfreev(req);
1321         return send_error(ctx, rc);
1322     }
1323
1324     /*
1325      * No sub-node defined. Remove the entire node (account).
1326      */
1327     if (!req[1]) {
1328         if (n) {
1329             xmlUnlinkNode(n);
1330             xmlFreeNode(n);
1331         }
1332
1333         g_strfreev(req);
1334         return send_error(ctx, 0);
1335     }
1336
1337     n = find_elements(client->doc, n->children, req+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL);
1338     g_strfreev(req);
1339
1340     if (!n)
1341         return send_error(ctx, rc);
1342
1343     if (n) {
1344         xmlUnlinkNode(n);
1345         xmlFreeNode(n);
1346     }
1347
1348     return send_error(ctx, 0);
1349 }
1350
1351 /*
1352  * Don't return with assuan_process_done() here. This has been called from
1353  * assuan_process_next() and the command should be finished in
1354  * client_thread().
1355  */
1356 static int store_command_finalize(gpointer data, gint assuan_rc, guchar *line,
1357         gsize len)
1358 {
1359     assuan_context_t ctx = data;
1360     struct client_s *client = assuan_get_pointer(ctx);
1361     gchar **req;
1362     xmlNodePtr n;
1363     gpg_error_t rc = file_modified(client);
1364
1365     if (assuan_rc || rc) {
1366         if (line)
1367             xfree(line);
1368         return assuan_rc ? assuan_rc : rc;
1369     }
1370
1371     req = split_input_line((gchar *)line, "\t", 0);
1372     xfree(line);
1373
1374     if (!req || !*req)
1375         return EPWMD_COMMAND_SYNTAX;
1376
1377     if (valid_xml_element((xmlChar *)*req) == FALSE) {
1378         g_strfreev(req);
1379         return EPWMD_INVALID_ELEMENT;
1380     }
1381
1382     if (valid_element_path(req+1, TRUE) == FALSE) {
1383         g_strfreev(req);
1384         return EPWMD_INVALID_ELEMENT;
1385     }
1386
1387 again:
1388     n = find_account(client->doc, &req, &rc, NULL, 0);
1389
1390     if (rc && rc == EPWMD_ELEMENT_NOT_FOUND) {
1391         rc = new_account(client->doc, *req);
1392
1393         if (rc) {
1394             g_strfreev(req);
1395             return rc;
1396         }
1397
1398         goto again;
1399     }
1400
1401     if (!n) {
1402         g_strfreev(req);
1403         return rc;
1404     }
1405
1406     if (req[1]) {
1407         if (!n->children)
1408             create_elements_cb(n, req+1, &rc, NULL);
1409         else
1410             find_elements(client->doc, n->children, req+1, &rc,
1411                     NULL, NULL, create_elements_cb, FALSE, 0, NULL);
1412     }
1413
1414     g_strfreev(req);
1415     client->inquire_status = INQUIRE_DONE;
1416     return rc;
1417 }
1418
1419 static int store_command(assuan_context_t ctx, char *line)
1420 {
1421     struct client_s *client = assuan_get_pointer(ctx);
1422     gpg_error_t rc = file_modified(client);
1423
1424     if (rc)
1425         return send_error(ctx, rc);
1426
1427     pth_cancel_point();
1428     rc = assuan_inquire_ext(ctx, "STORE", 0, store_command_finalize, ctx);
1429     pth_cancel_point();
1430
1431     if (rc)
1432         return send_error(ctx, rc);
1433
1434     /* Don't return with assuan_process_done() here. This is an INQUIRE. */
1435     client->inquire_status = INQUIRE_BUSY;
1436     return 0;
1437 }
1438
1439 static gpg_error_t xfer_data(assuan_context_t ctx, const gchar *line,
1440         gint total)
1441 {
1442     int to_send;
1443     int sent = 0;
1444     gpg_error_t rc;
1445
1446     if (total < ASSUAN_LINELENGTH)
1447         to_send = total;
1448     else
1449         to_send = ASSUAN_LINELENGTH;
1450
1451     do {
1452         if (sent + to_send > total)
1453             to_send = total - sent;
1454
1455         rc = assuan_send_data(ctx, line+sent, to_send);
1456
1457         if (!rc) {
1458             sent += to_send;
1459             rc = send_status(ctx, STATUS_XFER, "%li %li", sent, total);
1460         }
1461     } while (!rc && sent < total);
1462
1463     return rc;
1464 }
1465
1466 static int get_command(assuan_context_t ctx, char *line)
1467 {
1468     struct client_s *client = assuan_get_pointer(ctx);
1469     gchar **req;
1470     gpg_error_t rc;
1471     xmlNodePtr n;
1472
1473     rc = file_modified(client);
1474
1475     if (rc)
1476         return send_error(ctx, rc);
1477
1478     req = split_input_line(line, "\t", -1);
1479
1480     if (!req || !*req) {
1481         g_strfreev(req);
1482         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1483     }
1484
1485     n = find_account(client->doc, &req, &rc, NULL, 0);
1486
1487     if (!n) {
1488         g_strfreev(req);
1489         return send_error(ctx, rc);
1490     }
1491
1492     if (req[1])
1493         n = find_elements(client->doc, n->children, req+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL);
1494
1495     g_strfreev(req);
1496
1497     if (rc)
1498         return send_error(ctx, rc);
1499
1500     if (!n || !n->children)
1501         return send_error(ctx, EPWMD_EMPTY_ELEMENT);
1502
1503     n = find_text_node(n->children);
1504
1505     if (!n || !n->content || !*n->content)
1506         return send_error(ctx, EPWMD_EMPTY_ELEMENT);
1507
1508     pth_cancel_point();
1509     rc = xfer_data(ctx, (gchar *)n->content, xmlStrlen(n->content));
1510     return send_error(ctx, rc);
1511 }
1512
1513 static xmlNodePtr realpath_elements_cb(xmlNodePtr node, gchar **target,
1514         gpg_error_t *rc, gchar **req_orig, void *data)
1515 {
1516     gchar *path = *(gchar **)data;
1517     gchar *tmp = NULL, *result;
1518
1519     if (path) {
1520         g_free(path);
1521         *(gchar **)data = NULL;
1522     }
1523
1524     path = g_strjoinv("\t", target);
1525
1526     if (!path) {
1527         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1528         *rc = gpg_error_from_errno(ENOMEM);
1529         return NULL;
1530     }
1531
1532     if (req_orig) {
1533         tmp = g_strjoinv("\t", req_orig);
1534
1535         if (!tmp) {
1536             g_free(path);
1537             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1538             *rc = gpg_error_from_errno(ENOMEM);
1539             return NULL;
1540         }
1541     }
1542
1543     if (tmp && *tmp)
1544         result = g_strdup_printf("%s\t%s", path, tmp);
1545     else
1546         result = g_strdup(path);
1547
1548     if (!result) {
1549         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1550         *rc = gpg_error_from_errno(ENOMEM);
1551         g_free(path);
1552         g_free(tmp);
1553         return NULL;
1554     }
1555
1556     g_free(path);
1557     g_free(tmp);
1558     *(gchar **)data = result;
1559     return node;
1560 }
1561
1562 static void list_command_cleanup1(void *arg);
1563 static int realpath_command(assuan_context_t ctx, char *line)
1564 {
1565     gpg_error_t rc;
1566     struct client_s *client = assuan_get_pointer(ctx);
1567     gchar **req;
1568     gchar *t;
1569     gint i;
1570     xmlNodePtr n;
1571     GString *string;
1572     gchar *rp = NULL;
1573
1574     rc = file_modified(client);
1575
1576     if (rc)
1577         return send_error(ctx, rc);
1578
1579     if (strchr(line, '\t') != NULL) {
1580         if ((req = split_input_line(line, "\t", 0)) == NULL)
1581             return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1582     }
1583     else {
1584         if ((req = split_input_line(line, " ", 0)) == NULL)
1585             return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1586     }
1587
1588     n = find_account(client->doc, &req, &rc, NULL, 0);
1589
1590     if (!n) {
1591         g_strfreev(req);
1592         return send_error(ctx, rc);
1593     }
1594
1595     rp = g_strjoinv("\t", req);
1596
1597     if (!rp) {
1598         g_strfreev(req);
1599         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1600         return send_syserror(ctx, ENOMEM);
1601     }
1602
1603     if (req[1]) {
1604         n = find_elements(client->doc, n->children, req+1, &rc,
1605                 NULL, realpath_elements_cb, NULL, FALSE, 0, &rp);
1606
1607         if (!n) {
1608             g_free(rp);
1609             g_strfreev(req);
1610             return send_error(ctx, rc);
1611         }
1612     }
1613
1614     string = g_string_new(rp);
1615     g_free(rp);
1616     g_strfreev(req);
1617
1618     if (!string) {
1619         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1620         return send_syserror(ctx, ENOMEM);
1621     }
1622
1623 again:
1624     for (i = 0, t = string->str + i; *t; t++, i++) {
1625         if ((!i && *t != '!') || (*t == '\t' && *(t+1) && *(t+1) != '!')) {
1626             string = g_string_insert_c(string, !i ? i++ : ++i, '!');
1627             goto again;
1628         }
1629     }
1630
1631     rc = assuan_send_data(ctx, string->str, string->len);
1632     list_command_cleanup1(string);
1633     return send_error(ctx, rc);
1634 }
1635
1636 static void list_command_cleanup1(void *arg)
1637 {
1638     g_string_free((GString *)arg, TRUE);
1639 }
1640
1641 static void list_command_cleanup2(void *arg)
1642 {
1643     struct element_list_s *elements = arg;
1644
1645     if (elements) {
1646         gint total = g_slist_length(elements->list);
1647         gint i;
1648
1649         for (i = 0; i < total; i++) {
1650             gchar *tmp = g_slist_nth_data(elements->list, i);
1651             g_free(tmp);
1652         }
1653
1654         g_slist_free(elements->list);
1655
1656         if (elements->prefix)
1657             g_free(elements->prefix);
1658
1659         g_free(elements);
1660     }
1661 }
1662
1663 static int list_command(assuan_context_t ctx, char *line)
1664 {
1665     struct client_s *client = assuan_get_pointer(ctx);
1666     gpg_error_t rc;
1667     struct element_list_s *elements = NULL;
1668     gchar *tmp;
1669
1670     if (disable_list_and_dump == TRUE)
1671         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
1672
1673     rc = file_modified(client);
1674
1675     if (rc)
1676         return send_error(ctx, rc);
1677
1678     if (!*line) {
1679         GString *str;
1680
1681         rc = list_accounts(client->doc, &str);
1682
1683         if (rc)
1684             return send_error(ctx, rc);
1685
1686         rc = xfer_data(ctx, str->str, str->len);
1687         list_command_cleanup1(str);
1688         return send_error(ctx, rc);
1689     }
1690
1691     elements = g_malloc0(sizeof(struct element_list_s));
1692
1693     if (!elements) {
1694         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1695         rc = gpg_err_code_from_errno(ENOMEM);
1696         goto fail;
1697     }
1698
1699     rc = create_path_list(client->doc, elements, line);
1700
1701     if (rc)
1702         goto fail;
1703
1704     if (elements) {
1705         gint total = g_slist_length(elements->list);
1706         gint i;
1707         GString *str;
1708
1709         if (!total) {
1710             rc = EPWMD_EMPTY_ELEMENT;
1711             goto fail;
1712         }
1713
1714         str = g_string_new(NULL);
1715
1716         if (!str) {
1717             rc = gpg_err_code_from_errno(ENOMEM);
1718             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1719             goto fail;
1720         }
1721
1722         for (i = 0; i < total; i++) {
1723             tmp = g_slist_nth_data(elements->list, i);
1724             g_string_append_printf(str, "%s%s", tmp, i+1 == total ? "" : "\n");
1725         }
1726
1727         rc = xfer_data(ctx, str->str, str->len);
1728         list_command_cleanup1(str);
1729     }
1730     else
1731         rc = EPWMD_EMPTY_ELEMENT;
1732
1733 fail:
1734     list_command_cleanup2(elements);
1735     return send_error(ctx, rc);
1736 }
1737
1738 static gpg_error_t add_attribute(xmlNodePtr node, const gchar *name,
1739         const gchar *value)
1740 {
1741     xmlAttrPtr a;
1742
1743     if ((a = xmlHasProp(node, (xmlChar *)name)) == NULL) {
1744         a = xmlNewProp(node, (xmlChar *)name, (xmlChar *)value);
1745
1746         if (!a)
1747             return EPWMD_LIBXML_ERROR;
1748     }
1749     else
1750         xmlNodeSetContent(a->children, (xmlChar *)value);
1751
1752     return 0;
1753 }
1754
1755 /*
1756  * req[0] - element path
1757  */
1758 static int attribute_list(assuan_context_t ctx, gchar **req)
1759 {
1760     struct client_s *client = assuan_get_pointer(ctx);
1761     gchar **attrlist = NULL;
1762     gint i = 0;
1763     gchar **path = NULL;
1764     xmlAttrPtr a;
1765     xmlNodePtr n, an;
1766     gchar *line;
1767     gpg_error_t rc;
1768
1769     if (!req || !req[0])
1770         return EPWMD_COMMAND_SYNTAX;
1771
1772     if ((path = split_input_line(req[0], "\t", 0)) == NULL) {
1773         /*
1774          * The first argument may be only an account.
1775          */
1776         if ((path = split_input_line(req[0], " ", 0)) == NULL)
1777             return EPWMD_COMMAND_SYNTAX;
1778     }
1779
1780     n = find_account(client->doc, &path, &rc, NULL, 0);
1781
1782     if (!n) {
1783         g_strfreev(path);
1784         return rc;
1785     }
1786
1787     if (path[1]) {
1788         n = find_elements(client->doc, n->children, path+1, &rc,
1789                 NULL, NULL, NULL, FALSE, 0, NULL);
1790
1791         if (!n) {
1792             g_strfreev(path);
1793             return rc;
1794         }
1795     }
1796
1797     g_strfreev(path);
1798
1799     for (a = n->properties; a; a = a->next) {
1800         gchar **pa;
1801
1802         if ((pa = g_realloc(attrlist, (i + 2) * sizeof(gchar *))) == NULL) {
1803             if (attrlist)
1804                 g_strfreev(attrlist);
1805
1806             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1807             return gpg_error_from_errno(ENOMEM);
1808         }
1809
1810         attrlist = pa;
1811         an = a->children;
1812         attrlist[i] = g_strdup_printf("%s %s", (gchar *)a->name, (gchar *)an->content);
1813
1814         if (!attrlist[i]) {
1815             g_strfreev(attrlist);
1816             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1817             return gpg_error_from_errno(ENOMEM);
1818         }
1819
1820         attrlist[++i] = NULL;
1821     }
1822
1823     if (!attrlist)
1824         return EPWMD_EMPTY_ELEMENT;
1825
1826     line = g_strjoinv("\n", attrlist);
1827
1828     if (!line) {
1829         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1830         g_strfreev(attrlist);
1831         return gpg_error_from_errno(ENOMEM);
1832     }
1833
1834     rc = assuan_send_data(ctx, line, strlen(line));
1835     g_free(line);
1836     req_cleanup(attrlist);
1837     return rc;
1838 }
1839
1840 /*
1841  * req[0] - attribute
1842  * req[1] - element path
1843  */
1844 static int attribute_delete(struct client_s *client, gchar **req)
1845 {
1846     xmlAttrPtr a;
1847     xmlNodePtr n;
1848     gchar **path = NULL;
1849     gpg_error_t rc;
1850
1851     if (!req || !req[0] || !req[1])
1852         return EPWMD_COMMAND_SYNTAX;
1853
1854     if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
1855         /*
1856          * The first argument may be only an account.
1857          */
1858         if ((path = split_input_line(req[1], " ", 0)) == NULL)
1859             return EPWMD_COMMAND_SYNTAX;
1860     }
1861
1862     /*
1863      * Don't remove the "name" attribute for the account element. To remove an
1864      * account use DELETE <account>.
1865      */
1866     if (!path[1] && xmlStrEqual((xmlChar *)req[0], (xmlChar *)"name")) {
1867         rc = EPWMD_ATTR_SYNTAX;
1868         goto fail;
1869     }
1870
1871     n = find_account(client->doc, &path, &rc, NULL, 0);
1872
1873     if (!n)
1874         goto fail;
1875
1876     if (path[1]) {
1877         n = find_elements(client->doc, n->children, path+1, &rc,
1878                 NULL, NULL, NULL, FALSE, 0, NULL);
1879
1880         if (!n)
1881             goto fail;
1882     }
1883
1884     g_strfreev(path);
1885
1886     if ((a = xmlHasProp(n, (xmlChar *)req[0])) == NULL)
1887         return EPWMD_ATTR_NOT_FOUND;
1888
1889     if (xmlRemoveProp(a) == -1)
1890         return EPWMD_LIBXML_ERROR;
1891
1892     return 0;
1893
1894 fail:
1895     g_strfreev(path);
1896     return rc;
1897 }
1898
1899 static xmlNodePtr create_element_path(struct client_s *client, gchar ***path,
1900         gpg_error_t *rc)
1901 {
1902     gchar **src = *path;
1903     gchar **src_orig = g_strdupv(src);
1904     xmlNodePtr n = NULL;
1905
1906     *rc = 0;
1907
1908     if (!src_orig) {
1909         *rc = gpg_error_from_errno(ENOMEM);
1910         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1911         goto fail;
1912     }
1913
1914 again:
1915     n = find_account(client->doc, &src, rc, NULL, 0);
1916
1917     if (!n) {
1918         if (*rc == EPWMD_ELEMENT_NOT_FOUND) {
1919             *rc = new_account(client->doc, src[0]);
1920
1921             if (*rc)
1922                 goto fail;
1923
1924             goto again;
1925         }
1926         else
1927             goto fail;
1928     }
1929
1930     if (src[1]) {
1931         if (!n->children)
1932             n = create_target_elements_cb(n, src+1, rc, NULL);
1933         else
1934             n = find_elements(client->doc, n->children, src+1, rc,
1935                     NULL, NULL, create_target_elements_cb, FALSE, 0, NULL);
1936
1937         if (!n)
1938             goto fail;
1939
1940         /*
1941          * Reset the position of the element tree now that the elements
1942          * have been created.
1943          */
1944         g_strfreev(src);
1945         src = src_orig;
1946         src_orig = NULL;
1947         n = find_account(client->doc, &src, rc, NULL, 0);
1948
1949         if (!n)
1950             goto fail;
1951
1952         n = find_elements(client->doc, n->children, src+1, rc,
1953                 NULL, NULL, NULL, FALSE, 0, NULL);
1954
1955         if (!n)
1956             goto fail;
1957     }
1958
1959 fail:
1960     if (src_orig)
1961         g_strfreev(src_orig);
1962
1963     *path = src;
1964     return n;
1965 }
1966
1967 /*
1968  * Creates a "target" attribute. When other commands encounter an element with
1969  * this attribute, the element path is modified to the target value. If the
1970  * source element path doesn't exist when using 'ATTR SET target', it is
1971  * created, but the destination element path must exist.
1972  *
1973  * req[0] - source element path
1974  * req[1] - destination element path
1975  */
1976 static gpg_error_t target_attribute(struct client_s *client, gchar **req)
1977 {
1978     gchar **src, **dst, *line = NULL;
1979     gpg_error_t rc;
1980     xmlNodePtr n;
1981
1982     if (!req || !req[0] || !req[1])
1983         return EPWMD_COMMAND_SYNTAX;
1984
1985     if ((src = split_input_line(req[0], "\t", 0)) == NULL) {
1986         /*
1987          * The first argument may be only an account.
1988          */
1989         if ((src = split_input_line(req[0], " ", 0)) == NULL)
1990             return EPWMD_COMMAND_SYNTAX;
1991     }
1992
1993     if (valid_element_path(src, FALSE) == FALSE) {
1994         g_strfreev(src);
1995         return EPWMD_INVALID_ELEMENT;
1996     }
1997
1998     if ((dst = split_input_line(req[1], "\t", 0)) == NULL) {
1999         /*
2000          * The first argument may be only an account.
2001          */
2002         if ((dst = split_input_line(req[1], " ", 0)) == NULL) {
2003             rc = EPWMD_COMMAND_SYNTAX;
2004             goto fail;
2005         }
2006     }
2007
2008     n = find_account(client->doc, &dst, &rc, NULL, 0);
2009
2010     /*
2011      * Make sure the destination element path exists.
2012      */
2013     if (!n)
2014         goto fail;
2015
2016     if (dst[1]) {
2017         n = find_elements(client->doc, n->children, dst+1, &rc,
2018                 NULL, NULL, NULL, FALSE, 0, NULL);
2019
2020         if (!n)
2021             goto fail;
2022     }
2023
2024     n = create_element_path(client, &src, &rc);
2025
2026     if (rc)
2027         goto fail;
2028
2029     line = g_strjoinv("\t", dst);
2030
2031     if (!line) {
2032         rc = gpg_error_from_errno(ENOMEM);
2033         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2034         goto fail;
2035     }
2036
2037     rc = add_attribute(n, "target", line);
2038
2039 fail:
2040     g_free(line);
2041     g_strfreev(src);
2042     g_strfreev(dst);
2043     return rc;
2044 }
2045
2046 /*
2047  * req[0] - account name
2048  * req[1] - new name
2049  */
2050 static gpg_error_t name_attribute(struct client_s *client, gchar **req)
2051 {
2052     gpg_error_t rc;
2053     gchar **tmp;
2054     xmlNodePtr n;
2055
2056     tmp = g_strdupv(req);
2057
2058     if (!tmp) {
2059         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2060         return gpg_error_from_errno(ENOMEM);
2061     }
2062
2063     n = find_account(client->doc, &tmp, &rc, NULL, 0);
2064     g_strfreev(tmp);
2065
2066     if (!n)
2067         return rc;
2068
2069     if (g_utf8_collate(req[0], req[1]) == 0)
2070         return 0;
2071
2072     /*
2073      * Will not overwrite an existing account.
2074      */
2075     tmp = g_strdupv(req+1);
2076
2077     if (!tmp) {
2078         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2079         return gpg_error_from_errno(ENOMEM);
2080     }
2081
2082     n = find_account(client->doc, &tmp, &rc, NULL, 0);
2083     g_strfreev(tmp);
2084
2085     if (rc && rc != EPWMD_ELEMENT_NOT_FOUND)
2086         return rc;
2087
2088     if (n)
2089         return EPWMD_ACCOUNT_EXISTS;
2090
2091     /*
2092      * Whitespace not allowed in account names.
2093      */
2094     if (contains_whitespace(req[1]) == TRUE)
2095         return EPWMD_ATTR_SYNTAX;
2096
2097     tmp = g_strdupv(req);
2098
2099     if (!tmp) {
2100         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2101         return gpg_error_from_errno(ENOMEM);
2102     }
2103
2104     n = find_account(client->doc, &tmp, &rc, NULL, 0);
2105     g_strfreev(tmp);
2106
2107     if (!n)
2108         return EPWMD_ELEMENT_NOT_FOUND;
2109
2110     return add_attribute(n, "name", req[1]);
2111 }
2112
2113 /*
2114  * req[0] - attribute
2115  * req[1] - element path
2116  */
2117 static int attribute_get(assuan_context_t ctx, gchar **req)
2118 {
2119     struct client_s *client = assuan_get_pointer(ctx);
2120     xmlNodePtr n;
2121     xmlChar *a;
2122     gchar **path= NULL;
2123     gpg_error_t rc;
2124
2125     if (!req || !req[0] || !req[1])
2126         return EPWMD_COMMAND_SYNTAX;
2127
2128     if (strchr(req[1], '\t')) {
2129         if ((path = split_input_line(req[1], "\t", 0)) == NULL)
2130             return EPWMD_COMMAND_SYNTAX;
2131     }
2132     else {
2133         if ((path = split_input_line(req[1], " ", 0)) == NULL)
2134             return EPWMD_COMMAND_SYNTAX;
2135     }
2136
2137     n = find_account(client->doc, &path, &rc, NULL, 0);
2138
2139     if (!n)
2140         goto fail;
2141
2142     if (path[1]) {
2143         n = find_elements(client->doc, n->children, path+1, &rc,
2144                 NULL, NULL, NULL, FALSE, 0, NULL);
2145
2146         if (!n)
2147             goto fail;
2148     }
2149
2150     g_strfreev(path);
2151
2152     if ((a = xmlGetProp(n, (xmlChar *)req[0])) == NULL)
2153         return EPWMD_ATTR_NOT_FOUND;
2154
2155     rc = assuan_send_data(ctx, a, xmlStrlen(a));
2156     xmlFree(a);
2157     return rc;
2158
2159 fail:
2160     g_strfreev(path);
2161     return rc;
2162 }
2163
2164 /*
2165  * req[0] - attribute
2166  * req[1] - element path
2167  * req[2] - value
2168  */
2169 static int attribute_set(struct client_s *client, gchar **req)
2170 {
2171     gchar **path = NULL;
2172     gpg_error_t rc;
2173     xmlNodePtr n;
2174
2175     if (!req || !req[0] || !req[1] || !req[2])
2176         return EPWMD_COMMAND_SYNTAX;
2177
2178     /*
2179      * Reserved attribute names.
2180      */
2181     if (g_utf8_collate(req[0], "name") == 0) {
2182         /*
2183          * Only reserved for the account element. Not the rest of the
2184          * document.
2185          */
2186         if (strchr(req[1], '\t') == NULL)
2187             return name_attribute(client, req + 1);
2188     }
2189     else if (g_utf8_collate(req[0], "target") == 0)
2190         return target_attribute(client, req + 1);
2191
2192     if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
2193         /*
2194          * The first argument may be only an account.
2195          */
2196         if ((path = split_input_line(req[1], " ", 0)) == NULL)
2197             return EPWMD_COMMAND_SYNTAX;
2198     }
2199
2200     n = find_account(client->doc, &path, &rc, NULL, 0);
2201
2202     if (!n)
2203         goto fail;
2204
2205     if (path[1]) {
2206         n = find_elements(client->doc, n->children, path+1, &rc,
2207                 NULL, NULL, NULL, FALSE, 0, NULL);
2208
2209         if (!n)
2210             goto fail;
2211     }
2212
2213     g_strfreev(path);
2214     return add_attribute(n, req[0], req[2]);
2215
2216 fail:
2217     g_strfreev(path);
2218     return rc;
2219 }
2220
2221 /*
2222  * req[0] - command
2223  * req[1] - attribute name or element path if command is LIST
2224  * req[2] - element path
2225  * req[2] - element path or value
2226  */
2227 static int attr_command(assuan_context_t ctx, char *line)
2228 {
2229     struct client_s *client = assuan_get_pointer(ctx);
2230     gchar **req;
2231     gpg_error_t rc = 0;
2232
2233     rc = file_modified(client);
2234
2235     if (rc)
2236         return send_error(ctx, rc);
2237
2238     req = split_input_line(line, " ", 4);
2239
2240     if (!req || !req[0] || !req[1]) {
2241         g_strfreev(req);
2242         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2243     }
2244
2245     if (g_ascii_strcasecmp(req[0], "SET") == 0)
2246         rc = attribute_set(client, req+1);
2247     else if (g_ascii_strcasecmp(req[0], "GET") == 0)
2248         rc = attribute_get(ctx, req+1);
2249     else if (g_ascii_strcasecmp(req[0], "DELETE") == 0)
2250         rc = attribute_delete(client, req+1);
2251     else if (g_ascii_strcasecmp(req[0], "LIST") == 0)
2252         rc = attribute_list(ctx, req+1);
2253     else
2254         rc = EPWMD_COMMAND_SYNTAX;
2255
2256     req_cleanup(req);
2257     return send_error(ctx, rc);
2258 }
2259
2260 static int iscached_command(assuan_context_t ctx, char *line)
2261 {
2262     gchar **req = split_input_line(line, " ", 0);
2263     guchar md5file[16];
2264     gchar *path, *tmp;
2265
2266     if (!req || !*req) {
2267         g_strfreev(req);
2268         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2269     }
2270
2271     if (!valid_filename(req[0])) {
2272         g_strfreev(req);
2273         return EPWMD_INVALID_FILENAME;
2274     }
2275
2276     tmp = get_key_file_string("global", "data_directory");
2277
2278     if (!tmp) {
2279         g_strfreev(req);
2280         return gpg_error_from_errno(ENOMEM);
2281     }
2282
2283     path = expand_homedir(tmp);
2284
2285     if (!path) {
2286         g_strfreev(req);
2287         g_free(tmp);
2288         return gpg_error_from_errno(ENOMEM);
2289     }
2290
2291     g_free(tmp);
2292     tmp = path;
2293     path = g_strdup_printf("%s/%s", tmp, req[0]);
2294     g_free(tmp);
2295
2296     if (!path) {
2297         g_strfreev(req);
2298         return gpg_error_from_errno(ENOMEM);
2299     }
2300
2301     if (access(path, R_OK) == -1) {
2302         gpg_error_t rc = gpg_error_from_syserror();
2303
2304         g_free(path);
2305         g_strfreev(req);
2306         return send_error(ctx, rc);
2307     }
2308
2309     g_free(path);
2310     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
2311     g_strfreev(req);
2312     CACHE_LOCK(ctx);
2313
2314     if (cache_iscached(md5file) == FALSE) {
2315         CACHE_UNLOCK;
2316         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2317     }
2318
2319     CACHE_UNLOCK;
2320     return send_error(ctx, 0);
2321 }
2322
2323 static int clearcache_command(assuan_context_t ctx, char *line)
2324 {
2325     struct client_s *client = assuan_get_pointer(ctx);
2326     gchar **req = split_input_line(line, " ", 0);
2327     guchar md5file[16];
2328
2329     CACHE_LOCK(ctx);
2330
2331     if (!req || !*req) {
2332         g_strfreev(req);
2333         cache_clear(client->md5file, 2);
2334         CACHE_UNLOCK;
2335         return send_error(ctx, 0);
2336     }
2337
2338     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
2339     g_strfreev(req);
2340
2341     if (cache_clear(md5file, 1) == FALSE) {
2342         CACHE_UNLOCK;
2343         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2344     }
2345
2346     CACHE_UNLOCK;
2347     return send_error(ctx, 0);
2348 }
2349
2350 static int cachetimeout_command(assuan_context_t ctx, char *line)
2351 {
2352     guchar md5file[16];
2353     glong timeout;
2354     gchar **req = split_input_line(line, " ", 0);
2355     gchar *p;
2356
2357     if (!req || !*req || !req[1]) {
2358         g_strfreev(req);
2359         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2360     }
2361
2362     errno = 0;
2363     timeout = strtol(req[0], &p, 10);
2364
2365     if (errno != 0 || *p != 0) {
2366         g_strfreev(req);
2367         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2368     }
2369
2370     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[1], strlen(req[1]));
2371     CACHE_LOCK(client->ctx);
2372
2373     if (cache_set_timeout(md5file, timeout) == FALSE) {
2374         CACHE_UNLOCK;
2375         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2376     }
2377
2378     CACHE_UNLOCK;
2379     return send_error(ctx, 0);
2380 }
2381
2382 static int dump_command(assuan_context_t ctx, char *line)
2383 {
2384     xmlChar *xml;
2385     gssize len;
2386     struct client_s *client = assuan_get_pointer(ctx);
2387     gpg_error_t rc;
2388
2389     if (disable_list_and_dump == TRUE)
2390         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
2391
2392     rc = file_modified(client);
2393
2394     if (rc)
2395         return send_error(ctx, rc);
2396
2397     xmlDocDumpFormatMemory(client->doc, &xml, &len, 1);
2398
2399     if (!xml) {
2400         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2401         return send_syserror(ctx, ENOMEM);
2402     }
2403
2404     rc = xfer_data(ctx, (gchar *)xml, len);
2405     xmlFree(xml);
2406     return send_error(ctx, rc);
2407 }
2408
2409 static int getconfig_command(assuan_context_t ctx, gchar *line)
2410 {
2411     struct client_s *client = assuan_get_pointer(ctx);
2412     gpg_error_t rc = 0;
2413     gchar filename[255]={0}, param[747]={0};
2414     gchar *p, *tmp, *fp = client->filename, *paramp = line;
2415
2416     if (strchr(line, ' ')) {
2417         sscanf(line, " %254[^ ] %746c", filename, param);
2418         fp = filename;
2419         paramp = param;
2420     }
2421
2422     if (fp && !valid_filename(fp))
2423         return send_error(ctx, EPWMD_INVALID_FILENAME);
2424
2425     paramp = g_ascii_strdown(paramp, -1);
2426
2427     if (!paramp) {
2428         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2429         return send_syserror(ctx, ENOMEM);
2430     }
2431
2432     p = get_key_file_string(fp ? fp : "global", paramp);
2433     g_free(paramp);
2434
2435     if (!p)
2436         return send_error(ctx, GPG_ERR_NO_VALUE);
2437
2438     tmp = expand_homedir(p);
2439     g_free(p);
2440
2441     if (!tmp) {
2442         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2443         return send_syserror(ctx, ENOMEM);
2444     }
2445
2446     p = tmp;
2447     rc = assuan_send_data(ctx, p, strlen(p));
2448     g_free(p);
2449     return send_error(ctx, rc);
2450 }
2451
2452 struct xpath_s {
2453     xmlXPathContextPtr xp;
2454     xmlXPathObjectPtr result;
2455     xmlBufferPtr buf;
2456     gchar **req;
2457 };
2458
2459 static void xpath_command_cleanup(void *arg)
2460 {
2461     struct xpath_s *xpath = arg;
2462
2463     req_cleanup(xpath->req);
2464
2465     if (xpath->buf)
2466         xmlBufferFree(xpath->buf);
2467
2468     if (xpath->result)
2469         xmlXPathFreeObject(xpath->result);
2470
2471     if (xpath->xp)
2472         xmlXPathFreeContext(xpath->xp);
2473 }
2474
2475 static int xpath_command(assuan_context_t ctx, gchar *line)
2476 {
2477     struct client_s *client = assuan_get_pointer(ctx);
2478     gpg_error_t rc;
2479     struct xpath_s xpath;
2480
2481     if (disable_list_and_dump == TRUE)
2482         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
2483
2484     rc = file_modified(client);
2485
2486     if (rc)
2487         return send_error(ctx, rc);
2488
2489     if (!line || !*line)
2490         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2491
2492     memset(&xpath, 0, sizeof(struct xpath_s));
2493
2494     if ((xpath.req = split_input_line(line, "\t", 2)) == NULL) {
2495         if (strv_printf(&xpath.req, "%s", line) == FALSE)
2496             return send_syserror(ctx, ENOMEM);
2497     }
2498
2499     xpath.xp = xmlXPathNewContext(client->doc);
2500
2501     if (!xpath.xp) {
2502         xpath_command_cleanup(&xpath);
2503         return send_error(ctx, EPWMD_LIBXML_ERROR);
2504     }
2505
2506     xpath.result = xmlXPathEvalExpression((xmlChar *)xpath.req[0], xpath.xp);
2507
2508     if (!xpath.result) {
2509         xpath_command_cleanup(&xpath);
2510         return send_error(ctx, EPWMD_LIBXML_ERROR);
2511     }
2512
2513     if (xmlXPathNodeSetIsEmpty(xpath.result->nodesetval)) {
2514         rc = EPWMD_EMPTY_ELEMENT;
2515         goto fail;
2516     }
2517
2518     rc = recurse_xpath_nodeset(client->doc, xpath.result->nodesetval,
2519             (xmlChar *)xpath.req[1], &xpath.buf);
2520
2521     if (rc)
2522         goto fail;
2523     else if (!xpath.req[1] && !xmlBufferLength(xpath.buf)) {
2524         rc = EPWMD_EMPTY_ELEMENT;
2525         goto fail;
2526     }
2527     else if (xpath.req[1])
2528         goto fail;
2529
2530     pth_cancel_point();
2531     rc = xfer_data(ctx, (gchar *)xmlBufferContent(xpath.buf),
2532             xmlBufferLength(xpath.buf));
2533
2534 fail:
2535     xpath_command_cleanup(&xpath);
2536     return send_error(ctx, rc);
2537 }
2538
2539 static int import_command_finalize(gpointer data, gint assuan_rc, guchar *line,
2540         gsize len)
2541 {
2542     struct client_s *client = assuan_get_pointer((assuan_context_t)data);
2543     gpg_error_t rc = file_modified(client);
2544     gchar **req, **path = NULL, **path_orig = NULL, *content;
2545     xmlDocPtr doc;
2546     xmlNodePtr n, root, copy;
2547
2548     if (assuan_rc || rc) {
2549         if (line)
2550             xfree(line);
2551         return assuan_rc ? assuan_rc : rc;
2552     }
2553
2554     req = split_input_line((gchar *)line, " ", 2);
2555     xfree(line);
2556
2557     if (!req || !*req)
2558         return EPWMD_COMMAND_SYNTAX;
2559
2560     if ((path = split_input_line(req[0], "\t", 0)) == NULL) {
2561         if ((path = split_input_line(req[0], " ", 0)) == NULL)
2562             return EPWMD_COMMAND_SYNTAX;
2563     }
2564
2565     content = req[1];
2566
2567     if (!content || !*content) {
2568         rc = EPWMD_COMMAND_SYNTAX;
2569         goto fail;
2570     }
2571
2572     if (valid_xml_element((xmlChar *)*path) == FALSE) {
2573         rc = EPWMD_INVALID_ELEMENT;
2574         goto fail;
2575     }
2576
2577     if (valid_element_path(path+1, FALSE) == FALSE) {
2578         rc = EPWMD_INVALID_ELEMENT;
2579         goto fail;
2580     }
2581
2582     doc = xmlReadDoc((xmlChar *)content, NULL, "UTF-8", XML_PARSE_NOBLANKS);
2583
2584     if (!doc) {
2585         rc = EPWMD_LIBXML_ERROR;
2586         goto fail;
2587     }
2588
2589     root = xmlDocGetRootElement(doc);
2590     path_orig = g_strdupv(path);
2591
2592     if (!path_orig) {
2593         xmlFreeDoc(doc);
2594         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2595         rc = gpg_error_from_errno(ENOMEM);
2596         goto fail;
2597     }
2598
2599     if (strv_printf(&path, "%s", (gchar *)root->name) == FALSE) {
2600         g_strfreev(path_orig);
2601         xmlFreeDoc(doc);
2602         rc = gpg_error_from_errno(ENOMEM);
2603         goto fail;
2604     }
2605
2606     n = find_account(client->doc, &path, &rc, NULL, 0);
2607
2608     if (rc && rc != EPWMD_ELEMENT_NOT_FOUND) {
2609         g_strfreev(path_orig);
2610         xmlFreeDoc(doc);
2611         goto fail;
2612     }
2613     else if (!rc) {
2614         n = find_elements(client->doc, n->children, path+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL);
2615
2616         if (rc && rc != EPWMD_ELEMENT_NOT_FOUND) {
2617             g_strfreev(path_orig);
2618             xmlFreeDoc(doc);
2619             goto fail;
2620         }
2621         else if (!rc) {
2622             xmlNodePtr parent = n->parent;
2623
2624             xmlUnlinkNode(n);
2625             xmlFreeNode(n);
2626             n = parent;
2627         }
2628     }
2629
2630     g_strfreev(path);
2631     path = path_orig;
2632
2633     if (rc == EPWMD_ELEMENT_NOT_FOUND) {
2634         n = create_element_path(client, &path, &rc);
2635
2636         if (rc) {
2637             xmlFreeDoc(doc);
2638             goto fail;
2639         }
2640     }
2641
2642     copy = xmlCopyNode(root, 1);
2643     n = xmlAddChild(n, copy);
2644     xmlFreeDoc(doc);
2645
2646     if (!n)
2647         rc = EPWMD_LIBXML_ERROR;
2648
2649 fail:
2650     g_strfreev(path);
2651     g_strfreev(req);
2652     client->inquire_status = INQUIRE_DONE;
2653     return rc;
2654 }
2655
2656 static int import_command(assuan_context_t ctx, gchar *line)
2657 {
2658     gpg_error_t rc;
2659     struct client_s *client = assuan_get_pointer(ctx);
2660
2661     rc = file_modified(client);
2662
2663     if (rc)
2664         return send_error(ctx, rc);
2665
2666     pth_cancel_point();
2667     rc = assuan_inquire_ext(ctx, "IMPORT", 0, import_command_finalize, ctx);
2668     pth_cancel_point();
2669
2670     if (rc)
2671         return send_error(ctx, rc);
2672
2673     /* Don't return with assuan_process_done() here. This is an INQUIRE. */
2674     client->inquire_status = INQUIRE_BUSY;
2675     return 0;
2676 }
2677
2678 static int lock_command(assuan_context_t ctx, gchar *line)
2679 {
2680     gpg_error_t rc;
2681     struct client_s *client = assuan_get_pointer(ctx);
2682
2683     rc = file_modified(client);
2684
2685     if (rc)
2686         return send_error(ctx, rc);
2687
2688     rc = lock_file_mutex(client);
2689
2690     if (!rc)
2691         client->is_lock_cmd = TRUE;
2692
2693     return send_error(ctx, rc);
2694 }
2695
2696 static int unlock_command(assuan_context_t ctx, gchar *line)
2697 {
2698     struct client_s *client = assuan_get_pointer(ctx);
2699     gpg_error_t rc = file_modified(client);
2700
2701     if (rc)
2702         return send_error(ctx, rc);
2703
2704     unlock_file_mutex(client);
2705     return send_error(ctx, 0);
2706 }
2707
2708 static int getpid_command(assuan_context_t ctx, gchar *line)
2709 {
2710     gpg_error_t rc;
2711     gchar buf[32];
2712     pid_t pid = getpid();
2713
2714     print_fmt(buf, sizeof(buf), "%i", pid);
2715     pth_cancel_point();
2716     rc = assuan_send_data(ctx, buf, strlen(buf));
2717     pth_cancel_point();
2718     return send_error(ctx, rc);
2719 }
2720
2721 static int version_command(assuan_context_t ctx, gchar *line)
2722 {
2723     gpg_error_t rc;
2724     gchar buf[32];
2725
2726     print_fmt(buf, sizeof(buf), "%s", PACKAGE_VERSION);
2727     pth_cancel_point();
2728     rc = assuan_send_data(ctx, buf, strlen(buf));
2729     pth_cancel_point();
2730     return send_error(ctx, rc);
2731 }
2732
2733 static void bye_notify(assuan_context_t ctx)
2734 {
2735     struct client_s *cl = assuan_get_pointer(ctx);
2736
2737     /* This will let assuan_process_next() return. */
2738     fcntl(cl->thd->fd, F_SETFL, O_NONBLOCK);
2739 }
2740
2741 static void reset_notify(assuan_context_t ctx)
2742 {
2743     struct client_s *cl = assuan_get_pointer(ctx);
2744
2745     if (cl)
2746         cleanup_client(cl);
2747 }
2748
2749 static gpg_error_t parse_client_option(assuan_context_t ctx, const gchar *line)
2750 {
2751     gchar name[32] = {0}, value[256] = {0};
2752     struct client_s *cl = assuan_get_pointer(ctx);
2753
2754     if (sscanf(line, " %31[a-zA-Z] = %255c", name, value) != 2)
2755         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_SYNTAX);
2756
2757     if (g_strcasecmp(name, (gchar *)"NAME") == 0) {
2758         pth_attr_t attr = pth_attr_of(pth_self());
2759         gchar buf[41];
2760
2761         if (!strcmp(value, "NULL")) {
2762             pth_attr_set(attr, PTH_ATTR_NAME, NULL);
2763             pth_attr_destroy(attr);
2764             return 0;
2765         }
2766
2767         print_fmt(buf, sizeof(buf), "%s", value);
2768         pth_attr_set(attr, PTH_ATTR_NAME, buf);
2769         pth_attr_destroy(attr);
2770 #ifdef WITH_PINENTRY
2771         if (cl->pinentry->name)
2772             g_free(cl->pinentry->name);
2773
2774         cl->pinentry->name = g_strdup(buf);
2775 #endif
2776         log_write("OPTION CLIENT %s=%s", name, buf);
2777     }
2778     else
2779         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_UNKNOWN_OPTION);
2780
2781     return 0;
2782 }
2783
2784 static void set_option_value(gchar **opt, const gchar *val)
2785 {
2786     if (opt)
2787         g_free(*opt);
2788
2789     *opt = NULL;
2790
2791     if (val && strcmp(val, "NULL"))
2792         *opt = g_strdup(val);
2793 }
2794
2795 static int option_handler(assuan_context_t ctx, const gchar *name,
2796         const gchar *value)
2797 {
2798     struct client_s *client = assuan_get_pointer(ctx);
2799
2800     if (!value || !*value)
2801         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2802
2803     if (g_strcasecmp(name, (gchar *)"client") == 0)
2804         return parse_client_option(ctx, value);
2805
2806     if (g_strcasecmp(name, (gchar *)"iterations") == 0) {
2807         long n;
2808         gchar *p = NULL;
2809
2810         errno = 0;
2811         n = strtol(value, &p, 10);
2812
2813         if (errno || (p && *p) || n < 0)
2814             return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2815
2816         MUTEX_LOCK(&rcfile_mutex);
2817         g_key_file_set_integer(keyfileh, client->filename ? client->filename : "global", "iterations", (guint)n);
2818         MUTEX_UNLOCK(&rcfile_mutex);
2819         send_status_all(STATUS_CONFIG);
2820     }
2821 #ifdef WITH_PINENTRY
2822     else if (g_strcasecmp(name, (gchar *)"lc_messages") == 0)
2823         set_option_value(&client->pinentry->lcmessages, value);
2824     else if (g_strcasecmp(name, (gchar *)"lc_ctype") == 0)
2825         set_option_value(&client->pinentry->lcctype, value);
2826     else if (g_strcasecmp(name, (gchar *)"ttyname") == 0)
2827         set_option_value(&client->pinentry->ttyname, value);
2828     else if (g_strcasecmp(name, (gchar *)"ttytype") == 0)
2829         set_option_value(&client->pinentry->ttytype, value);
2830     else if (g_strcasecmp(name, (gchar *)"display") == 0)
2831         set_option_value(&client->pinentry->display, value);
2832     else if (g_strcasecmp(name, (gchar *)"path") == 0)
2833         set_option_value(&client->pinentry->path, value);
2834     else if (g_strcasecmp(name, (gchar *)"title") == 0)
2835         set_option_value(&client->pinentry->title, value);
2836     else if (g_strcasecmp(name, (gchar *)"prompt") == 0)
2837         set_option_value(&client->pinentry->prompt, value);
2838     else if (g_strcasecmp(name, (gchar *)"desc") == 0)
2839         set_option_value(&client->pinentry->desc, value);
2840     /*
2841      * Look at client_thread() to see how this works.
2842      */
2843     else if (g_strcasecmp(name, (gchar *)"timeout") == 0) {
2844         gchar *p = NULL;
2845         gint n = strtol(value, &p, 10);
2846
2847         if (*p || n < 0)
2848             return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2849
2850         client->pinentry->timeout = n;
2851     }
2852     else if (g_strcasecmp(name, (gchar *)"pinentry") == 0) {
2853         gchar *p = NULL;
2854         gint n = strtol(value, &p, 10);
2855
2856         if (*p || n < 0 || n > 1)
2857             return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2858
2859         client->pinentry->enable = n == 0 ? FALSE : TRUE;
2860     }
2861 #endif
2862     else
2863         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_UNKNOWN_OPTION);
2864
2865     log_write("OPTION %s=%s", name, value);
2866     return 0;
2867 }
2868
2869 gpg_error_t register_commands(assuan_context_t ctx)
2870 {
2871     static struct {
2872         const gchar *name;
2873         gint (*handler)(assuan_context_t, gchar *line);
2874     } table[] = {
2875         { "OPEN", open_command },
2876         { "SAVE", save_command },
2877         { "LIST", list_command },
2878         { "REALPATH", realpath_command },
2879         { "STORE", store_command },
2880         { "DELETE", delete_command },
2881         { "GET", get_command },
2882         { "ATTR", attr_command },
2883         { "ISCACHED", iscached_command },
2884         { "CLEARCACHE", clearcache_command },
2885         { "CACHETIMEOUT", cachetimeout_command },
2886         { "GETCONFIG", getconfig_command },
2887         { "DUMP", dump_command },
2888         { "XPATH", xpath_command },
2889         { "IMPORT", import_command },
2890         { "LOCK", lock_command },
2891         { "UNLOCK", unlock_command },
2892         { "GETPID", getpid_command },
2893         { "VERSION", version_command },
2894         { "INPUT", NULL },
2895         { "OUTPUT", NULL },
2896         { NULL, NULL }
2897     };
2898     gint i, rc;
2899
2900     for (i=0; table[i].name; i++) {
2901         rc = assuan_register_command (ctx, table[i].name, table[i].handler);
2902
2903         if (rc)
2904             return rc;
2905     }
2906
2907     rc = assuan_register_bye_notify(ctx, bye_notify);
2908
2909     if (rc)
2910         return rc;
2911
2912     rc = assuan_register_option_handler(ctx, option_handler);
2913
2914     if (rc)
2915         return rc;
2916
2917     rc = assuan_register_reset_notify(ctx, reset_notify);
2918
2919     if (rc)
2920         return rc;
2921
2922     return assuan_register_post_cmd_notify(ctx, command_finalize);
2923 }
2924
2925 gpg_error_t try_xml_decrypt(assuan_context_t ctx, guchar *key,
2926         struct client_crypto_s *crypto, gpointer *dst, goffset *dst_len)
2927 {
2928     goffset insize, len;
2929     struct client_s *client = ctx ? assuan_get_pointer(ctx) : NULL;
2930     guint64 iter = 0, n_iter = 0, iter_progress = 0;
2931     gint zrc = 0;
2932     gulong outsize = 0;
2933     gpg_error_t rc;
2934     gsize fh_size = crypto->fh->v1 ? sizeof(crypto->fh->fh1) : sizeof(crypto->fh->fh2);
2935     guint64 fh_iter = crypto->fh->v1 ? crypto->fh->fh1.iter : crypto->fh->fh2.iter;
2936
2937     lseek(crypto->fh->fd, fh_size, SEEK_SET);
2938     insize = crypto->fh->st.st_size - fh_size;
2939     crypto->iv = gcry_malloc(gcryblocksize);
2940
2941     if (!crypto->iv) {
2942         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2943         return gpg_error_from_errno(ENOMEM);
2944     }
2945
2946     /* No encryption iterations. This is a plain (gzipped) file. */
2947     if ((crypto->fh->v1 && fh_iter < 0) || (!crypto->fh->v1 && fh_iter <= 0)) {
2948         /*
2949          * cache_file_count() needs both .used == TRUE and a valid key in
2950          * order for it to count as a used cache entry. Fixes CACHE status
2951          * messages.
2952          */
2953         memset(key, '!', gcrykeysize);
2954     }
2955
2956     if (crypto->fh->v1)
2957         memcpy(crypto->iv, crypto->fh->fh1.iv, gcryblocksize);
2958     else
2959         memcpy(crypto->iv, crypto->fh->fh2.iv, gcryblocksize);
2960
2961     crypto->inbuf = gcry_malloc(insize);
2962
2963     if (!crypto->inbuf) {
2964         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2965         return gpg_error_from_errno(ENOMEM);
2966     }
2967
2968     crypto->insize = insize;
2969     len = pth_read(crypto->fh->fd, crypto->inbuf, crypto->insize);
2970     pth_cancel_point();
2971
2972     if (len != crypto->insize)
2973         return GPG_ERR_INV_LENGTH;
2974
2975     if ((crypto->fh->v1 && fh_iter < 0) || (!crypto->fh->v1 && fh_iter <= 0))
2976         goto decompress;
2977
2978     if ((rc = gcry_cipher_setiv(crypto->gh, crypto->iv, gcryblocksize))) {
2979         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
2980         return rc;
2981     }
2982
2983     if ((rc = gcry_cipher_setkey(crypto->gh, key, gcrykeysize))) {
2984         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
2985         return rc;
2986     }
2987
2988     iter_progress = (guint64)get_key_file_integer(client && client->filename ?
2989             client->filename : "global", "iteration_progress");
2990
2991     if (iter_progress > 0 && fh_iter >= iter_progress) {
2992         rc = send_status(ctx, STATUS_DECRYPT, "0 %llu", fh_iter);
2993         pth_cancel_point();
2994
2995         if (rc)
2996             return rc;
2997     }
2998
2999     rc = iterate_crypto_once(client, crypto, STATUS_DECRYPT);
3000
3001     if (rc)
3002         return rc;
3003
3004     crypto->tkey = gcry_malloc(gcrykeysize);
3005
3006     if (!crypto->tkey) {
3007         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
3008         return gpg_error_from_errno(ENOMEM);
3009     }
3010
3011     memcpy(crypto->tkey, key, gcrykeysize);
3012     guchar *tkey = crypto->tkey;
3013     tkey[0] ^= 1;
3014
3015     if ((rc = gcry_cipher_setkey(crypto->gh, crypto->tkey, gcrykeysize))) {
3016         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
3017         return rc;
3018     }
3019
3020     while (iter < (crypto->fh->v1 ? fh_iter : fh_iter-1)) {
3021         if (iter_progress > 0 && iter >= iter_progress) {
3022             if (!(iter % iter_progress)) {
3023                 rc = send_status(ctx, STATUS_DECRYPT, "%llu %llu",
3024                         ++n_iter * iter_progress, fh_iter);
3025                 pth_cancel_point();
3026
3027                 if (rc)
3028                     return rc;
3029             }
3030         }
3031
3032         if ((rc = gcry_cipher_setiv(crypto->gh, crypto->iv, gcryblocksize))) {
3033             log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
3034             return rc;
3035         }
3036
3037         rc = iterate_crypto_once(client, crypto, STATUS_DECRYPT);
3038
3039         if (rc) {
3040             log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
3041             return rc;
3042         }
3043
3044         iter++;
3045     }
3046
3047     if (iter_progress && fh_iter >= iter_progress) {
3048         rc = send_status(ctx, STATUS_DECRYPT, "%llu %llu", fh_iter, fh_iter);
3049         pth_cancel_point();
3050
3051         if (rc)
3052             return rc;
3053     }
3054
3055 decompress:
3056     if (do_decompress(ctx, crypto->inbuf, crypto->insize,
3057                 (gpointer *)&crypto->outbuf, &outsize, &zrc) == FALSE) {
3058         if (zrc == Z_MEM_ERROR)
3059             return gpg_error_from_errno(ENOMEM);
3060         else
3061             return EPWMD_BADKEY; // Not a valid gzip header. Must be a bad key.
3062     }
3063
3064     if (g_strncasecmp(crypto->outbuf, "<?xml version=", 14) != 0) {
3065         gcry_free(crypto->outbuf);
3066         crypto->outbuf = NULL;
3067         return EPWMD_BADKEY;
3068     }
3069
3070     if (ctx) {
3071         client->xml = crypto->outbuf;
3072         client->len = outsize;
3073         crypto->outbuf = NULL;
3074     }
3075     else if (dst) {
3076         *dst = crypto->outbuf;
3077         *dst_len = outsize;
3078         crypto->outbuf = NULL;
3079     }
3080
3081     /* The calling function should free the crypto struct. */
3082     return 0;
3083 }
3084
3085 /*
3086  * This is called after every Assuan command.
3087  */
3088 void command_finalize(assuan_context_t ctx, gint rc)
3089 {
3090     struct client_s *client = assuan_get_pointer(ctx);
3091
3092     if (!client->is_lock_cmd)
3093         unlock_file_mutex(client);
3094 }