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 int get_command(assuan_context_t ctx, char *line)
1440 {
1441     struct client_s *client = assuan_get_pointer(ctx);
1442     gchar **req;
1443     gpg_error_t rc;
1444     xmlNodePtr n;
1445     gint sent = 0, to_send;
1446     gint total;
1447
1448     rc = file_modified(client);
1449
1450     if (rc)
1451         return send_error(ctx, rc);
1452
1453     req = split_input_line(line, "\t", -1);
1454
1455     if (!req || !*req) {
1456         g_strfreev(req);
1457         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1458     }
1459
1460     n = find_account(client->doc, &req, &rc, NULL, 0);
1461
1462     if (!n) {
1463         g_strfreev(req);
1464         return send_error(ctx, rc);
1465     }
1466
1467     if (req[1])
1468         n = find_elements(client->doc, n->children, req+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL);
1469
1470     g_strfreev(req);
1471
1472     if (rc)
1473         return send_error(ctx, rc);
1474
1475     if (!n || !n->children)
1476         return send_error(ctx, EPWMD_EMPTY_ELEMENT);
1477
1478     n = find_text_node(n->children);
1479
1480     if (!n || !n->content || !*n->content)
1481         return send_error(ctx, EPWMD_EMPTY_ELEMENT);
1482
1483     pth_cancel_point();
1484
1485     total = xmlStrlen(n->content);
1486
1487     if (total < ASSUAN_LINELENGTH)
1488         to_send = total;
1489     else
1490         to_send = ASSUAN_LINELENGTH;
1491
1492     do {
1493         if (sent + to_send > total)
1494             to_send = total - sent;
1495
1496         rc = assuan_send_data(ctx, n->content+sent, to_send);
1497
1498         if (!rc) {
1499             sent += to_send;
1500             rc = send_status(ctx, STATUS_XFER, "%li %li", sent, total);
1501         }
1502     } while (!rc && sent < total);
1503
1504     pth_cancel_point();
1505     return send_error(ctx, rc);
1506 }
1507
1508 static xmlNodePtr realpath_elements_cb(xmlNodePtr node, gchar **target,
1509         gpg_error_t *rc, gchar **req_orig, void *data)
1510 {
1511     gchar *path = *(gchar **)data;
1512     gchar *tmp = NULL, *result;
1513
1514     if (path) {
1515         g_free(path);
1516         *(gchar **)data = NULL;
1517     }
1518
1519     path = g_strjoinv("\t", target);
1520
1521     if (!path) {
1522         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1523         *rc = gpg_error_from_errno(ENOMEM);
1524         return NULL;
1525     }
1526
1527     if (req_orig) {
1528         tmp = g_strjoinv("\t", req_orig);
1529
1530         if (!tmp) {
1531             g_free(path);
1532             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1533             *rc = gpg_error_from_errno(ENOMEM);
1534             return NULL;
1535         }
1536     }
1537
1538     if (tmp && *tmp)
1539         result = g_strdup_printf("%s\t%s", path, tmp);
1540     else
1541         result = g_strdup(path);
1542
1543     if (!result) {
1544         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1545         *rc = gpg_error_from_errno(ENOMEM);
1546         g_free(path);
1547         g_free(tmp);
1548         return NULL;
1549     }
1550
1551     g_free(path);
1552     g_free(tmp);
1553     *(gchar **)data = result;
1554     return node;
1555 }
1556
1557 static void list_command_cleanup1(void *arg);
1558 static int realpath_command(assuan_context_t ctx, char *line)
1559 {
1560     gpg_error_t rc;
1561     struct client_s *client = assuan_get_pointer(ctx);
1562     gchar **req;
1563     gchar *t;
1564     gint i;
1565     xmlNodePtr n;
1566     GString *string;
1567     gchar *rp = NULL;
1568
1569     rc = file_modified(client);
1570
1571     if (rc)
1572         return send_error(ctx, rc);
1573
1574     if (strchr(line, '\t') != NULL) {
1575         if ((req = split_input_line(line, "\t", 0)) == NULL)
1576             return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1577     }
1578     else {
1579         if ((req = split_input_line(line, " ", 0)) == NULL)
1580             return send_error(ctx, EPWMD_COMMAND_SYNTAX);
1581     }
1582
1583     n = find_account(client->doc, &req, &rc, NULL, 0);
1584
1585     if (!n) {
1586         g_strfreev(req);
1587         return send_error(ctx, rc);
1588     }
1589
1590     rp = g_strjoinv("\t", req);
1591
1592     if (!rp) {
1593         g_strfreev(req);
1594         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1595         return send_syserror(ctx, ENOMEM);
1596     }
1597
1598     if (req[1]) {
1599         n = find_elements(client->doc, n->children, req+1, &rc,
1600                 NULL, realpath_elements_cb, NULL, FALSE, 0, &rp);
1601
1602         if (!n) {
1603             g_free(rp);
1604             g_strfreev(req);
1605             return send_error(ctx, rc);
1606         }
1607     }
1608
1609     string = g_string_new(rp);
1610     g_free(rp);
1611     g_strfreev(req);
1612
1613     if (!string) {
1614         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1615         return send_syserror(ctx, ENOMEM);
1616     }
1617
1618 again:
1619     for (i = 0, t = string->str + i; *t; t++, i++) {
1620         if ((!i && *t != '!') || (*t == '\t' && *(t+1) && *(t+1) != '!')) {
1621             string = g_string_insert_c(string, !i ? i++ : ++i, '!');
1622             goto again;
1623         }
1624     }
1625
1626     rc = assuan_send_data(ctx, string->str, string->len);
1627     list_command_cleanup1(string);
1628     return send_error(ctx, rc);
1629 }
1630
1631 static void list_command_cleanup1(void *arg)
1632 {
1633     g_string_free((GString *)arg, TRUE);
1634 }
1635
1636 static void list_command_cleanup2(void *arg)
1637 {
1638     struct element_list_s *elements = arg;
1639
1640     if (elements) {
1641         gint total = g_slist_length(elements->list);
1642         gint i;
1643
1644         for (i = 0; i < total; i++) {
1645             gchar *tmp = g_slist_nth_data(elements->list, i);
1646             g_free(tmp);
1647         }
1648
1649         g_slist_free(elements->list);
1650
1651         if (elements->prefix)
1652             g_free(elements->prefix);
1653
1654         g_free(elements);
1655     }
1656 }
1657
1658 static int list_command(assuan_context_t ctx, char *line)
1659 {
1660     struct client_s *client = assuan_get_pointer(ctx);
1661     gpg_error_t rc;
1662     struct element_list_s *elements = NULL;
1663     gchar *tmp;
1664
1665     if (disable_list_and_dump == TRUE)
1666         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
1667
1668     rc = file_modified(client);
1669
1670     if (rc)
1671         return send_error(ctx, rc);
1672
1673     if (!*line) {
1674         GString *str;
1675
1676         rc = list_accounts(client->doc, &str);
1677
1678         if (rc)
1679             return send_error(ctx, rc);
1680
1681         rc = assuan_send_data(ctx, str->str, str->len);
1682         list_command_cleanup1(str);
1683         return send_error(ctx, rc);
1684     }
1685
1686     elements = g_malloc0(sizeof(struct element_list_s));
1687
1688     if (!elements) {
1689         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1690         rc = gpg_err_code_from_errno(ENOMEM);
1691         goto fail;
1692     }
1693
1694     rc = create_path_list(client->doc, elements, line);
1695
1696     if (rc)
1697         goto fail;
1698
1699     if (elements) {
1700         gint total = g_slist_length(elements->list);
1701         gint i;
1702         GString *str;
1703
1704         if (!total) {
1705             rc = EPWMD_EMPTY_ELEMENT;
1706             goto fail;
1707         }
1708
1709         str = g_string_new(NULL);
1710
1711         if (!str) {
1712             rc = gpg_err_code_from_errno(ENOMEM);
1713             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1714             goto fail;
1715         }
1716
1717         for (i = 0; i < total; i++) {
1718             tmp = g_slist_nth_data(elements->list, i);
1719             g_string_append_printf(str, "%s%s", tmp, i+1 == total ? "" : "\n");
1720         }
1721
1722         rc = assuan_send_data(ctx, str->str, str->len);
1723         list_command_cleanup1(str);
1724     }
1725     else
1726         rc = EPWMD_EMPTY_ELEMENT;
1727
1728 fail:
1729     list_command_cleanup2(elements);
1730     return send_error(ctx, rc);
1731 }
1732
1733 static gpg_error_t add_attribute(xmlNodePtr node, const gchar *name,
1734         const gchar *value)
1735 {
1736     xmlAttrPtr a;
1737
1738     if ((a = xmlHasProp(node, (xmlChar *)name)) == NULL) {
1739         a = xmlNewProp(node, (xmlChar *)name, (xmlChar *)value);
1740
1741         if (!a)
1742             return EPWMD_LIBXML_ERROR;
1743     }
1744     else
1745         xmlNodeSetContent(a->children, (xmlChar *)value);
1746
1747     return 0;
1748 }
1749
1750 /*
1751  * req[0] - element path
1752  */
1753 static int attribute_list(assuan_context_t ctx, gchar **req)
1754 {
1755     struct client_s *client = assuan_get_pointer(ctx);
1756     gchar **attrlist = NULL;
1757     gint i = 0;
1758     gchar **path = NULL;
1759     xmlAttrPtr a;
1760     xmlNodePtr n, an;
1761     gchar *line;
1762     gpg_error_t rc;
1763
1764     if (!req || !req[0])
1765         return EPWMD_COMMAND_SYNTAX;
1766
1767     if ((path = split_input_line(req[0], "\t", 0)) == NULL) {
1768         /*
1769          * The first argument may be only an account.
1770          */
1771         if ((path = split_input_line(req[0], " ", 0)) == NULL)
1772             return EPWMD_COMMAND_SYNTAX;
1773     }
1774
1775     n = find_account(client->doc, &path, &rc, NULL, 0);
1776
1777     if (!n) {
1778         g_strfreev(path);
1779         return rc;
1780     }
1781
1782     if (path[1]) {
1783         n = find_elements(client->doc, n->children, path+1, &rc,
1784                 NULL, NULL, NULL, FALSE, 0, NULL);
1785
1786         if (!n) {
1787             g_strfreev(path);
1788             return rc;
1789         }
1790     }
1791
1792     g_strfreev(path);
1793
1794     for (a = n->properties; a; a = a->next) {
1795         gchar **pa;
1796
1797         if ((pa = g_realloc(attrlist, (i + 2) * sizeof(gchar *))) == NULL) {
1798             if (attrlist)
1799                 g_strfreev(attrlist);
1800
1801             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1802             return gpg_error_from_errno(ENOMEM);
1803         }
1804
1805         attrlist = pa;
1806         an = a->children;
1807         attrlist[i] = g_strdup_printf("%s %s", (gchar *)a->name, (gchar *)an->content);
1808
1809         if (!attrlist[i]) {
1810             g_strfreev(attrlist);
1811             log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1812             return gpg_error_from_errno(ENOMEM);
1813         }
1814
1815         attrlist[++i] = NULL;
1816     }
1817
1818     if (!attrlist)
1819         return EPWMD_EMPTY_ELEMENT;
1820
1821     line = g_strjoinv("\n", attrlist);
1822
1823     if (!line) {
1824         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1825         g_strfreev(attrlist);
1826         return gpg_error_from_errno(ENOMEM);
1827     }
1828
1829     rc = assuan_send_data(ctx, line, strlen(line));
1830     g_free(line);
1831     req_cleanup(attrlist);
1832     return rc;
1833 }
1834
1835 /*
1836  * req[0] - attribute
1837  * req[1] - element path
1838  */
1839 static int attribute_delete(struct client_s *client, gchar **req)
1840 {
1841     xmlAttrPtr a;
1842     xmlNodePtr n;
1843     gchar **path = NULL;
1844     gpg_error_t rc;
1845
1846     if (!req || !req[0] || !req[1])
1847         return EPWMD_COMMAND_SYNTAX;
1848
1849     if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
1850         /*
1851          * The first argument may be only an account.
1852          */
1853         if ((path = split_input_line(req[1], " ", 0)) == NULL)
1854             return EPWMD_COMMAND_SYNTAX;
1855     }
1856
1857     /*
1858      * Don't remove the "name" attribute for the account element. To remove an
1859      * account use DELETE <account>.
1860      */
1861     if (!path[1] && xmlStrEqual((xmlChar *)req[0], (xmlChar *)"name")) {
1862         rc = EPWMD_ATTR_SYNTAX;
1863         goto fail;
1864     }
1865
1866     n = find_account(client->doc, &path, &rc, NULL, 0);
1867
1868     if (!n)
1869         goto fail;
1870
1871     if (path[1]) {
1872         n = find_elements(client->doc, n->children, path+1, &rc,
1873                 NULL, NULL, NULL, FALSE, 0, NULL);
1874
1875         if (!n)
1876             goto fail;
1877     }
1878
1879     g_strfreev(path);
1880
1881     if ((a = xmlHasProp(n, (xmlChar *)req[0])) == NULL)
1882         return EPWMD_ATTR_NOT_FOUND;
1883
1884     if (xmlRemoveProp(a) == -1)
1885         return EPWMD_LIBXML_ERROR;
1886
1887     return 0;
1888
1889 fail:
1890     g_strfreev(path);
1891     return rc;
1892 }
1893
1894 static xmlNodePtr create_element_path(struct client_s *client, gchar ***path,
1895         gpg_error_t *rc)
1896 {
1897     gchar **src = *path;
1898     gchar **src_orig = g_strdupv(src);
1899     xmlNodePtr n = NULL;
1900
1901     *rc = 0;
1902
1903     if (!src_orig) {
1904         *rc = gpg_error_from_errno(ENOMEM);
1905         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
1906         goto fail;
1907     }
1908
1909 again:
1910     n = find_account(client->doc, &src, rc, NULL, 0);
1911
1912     if (!n) {
1913         if (*rc == EPWMD_ELEMENT_NOT_FOUND) {
1914             *rc = new_account(client->doc, src[0]);
1915
1916             if (*rc)
1917                 goto fail;
1918
1919             goto again;
1920         }
1921         else
1922             goto fail;
1923     }
1924
1925     if (src[1]) {
1926         if (!n->children)
1927             n = create_target_elements_cb(n, src+1, rc, NULL);
1928         else
1929             n = find_elements(client->doc, n->children, src+1, rc,
1930                     NULL, NULL, create_target_elements_cb, FALSE, 0, NULL);
1931
1932         if (!n)
1933             goto fail;
1934
1935         /*
1936          * Reset the position of the element tree now that the elements
1937          * have been created.
1938          */
1939         g_strfreev(src);
1940         src = src_orig;
1941         src_orig = NULL;
1942         n = find_account(client->doc, &src, rc, NULL, 0);
1943
1944         if (!n)
1945             goto fail;
1946
1947         n = find_elements(client->doc, n->children, src+1, rc,
1948                 NULL, NULL, NULL, FALSE, 0, NULL);
1949
1950         if (!n)
1951             goto fail;
1952     }
1953
1954 fail:
1955     if (src_orig)
1956         g_strfreev(src_orig);
1957
1958     *path = src;
1959     return n;
1960 }
1961
1962 /*
1963  * Creates a "target" attribute. When other commands encounter an element with
1964  * this attribute, the element path is modified to the target value. If the
1965  * source element path doesn't exist when using 'ATTR SET target', it is
1966  * created, but the destination element path must exist.
1967  *
1968  * req[0] - source element path
1969  * req[1] - destination element path
1970  */
1971 static gpg_error_t target_attribute(struct client_s *client, gchar **req)
1972 {
1973     gchar **src, **dst, *line = NULL;
1974     gpg_error_t rc;
1975     xmlNodePtr n;
1976
1977     if (!req || !req[0] || !req[1])
1978         return EPWMD_COMMAND_SYNTAX;
1979
1980     if ((src = split_input_line(req[0], "\t", 0)) == NULL) {
1981         /*
1982          * The first argument may be only an account.
1983          */
1984         if ((src = split_input_line(req[0], " ", 0)) == NULL)
1985             return EPWMD_COMMAND_SYNTAX;
1986     }
1987
1988     if (valid_element_path(src, FALSE) == FALSE) {
1989         g_strfreev(src);
1990         return EPWMD_INVALID_ELEMENT;
1991     }
1992
1993     if ((dst = split_input_line(req[1], "\t", 0)) == NULL) {
1994         /*
1995          * The first argument may be only an account.
1996          */
1997         if ((dst = split_input_line(req[1], " ", 0)) == NULL) {
1998             rc = EPWMD_COMMAND_SYNTAX;
1999             goto fail;
2000         }
2001     }
2002
2003     n = find_account(client->doc, &dst, &rc, NULL, 0);
2004
2005     /*
2006      * Make sure the destination element path exists.
2007      */
2008     if (!n)
2009         goto fail;
2010
2011     if (dst[1]) {
2012         n = find_elements(client->doc, n->children, dst+1, &rc,
2013                 NULL, NULL, NULL, FALSE, 0, NULL);
2014
2015         if (!n)
2016             goto fail;
2017     }
2018
2019     n = create_element_path(client, &src, &rc);
2020
2021     if (rc)
2022         goto fail;
2023
2024     line = g_strjoinv("\t", dst);
2025
2026     if (!line) {
2027         rc = gpg_error_from_errno(ENOMEM);
2028         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2029         goto fail;
2030     }
2031
2032     rc = add_attribute(n, "target", line);
2033
2034 fail:
2035     g_free(line);
2036     g_strfreev(src);
2037     g_strfreev(dst);
2038     return rc;
2039 }
2040
2041 /*
2042  * req[0] - account name
2043  * req[1] - new name
2044  */
2045 static gpg_error_t name_attribute(struct client_s *client, gchar **req)
2046 {
2047     gpg_error_t rc;
2048     gchar **tmp;
2049     xmlNodePtr n;
2050
2051     tmp = g_strdupv(req);
2052
2053     if (!tmp) {
2054         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2055         return gpg_error_from_errno(ENOMEM);
2056     }
2057
2058     n = find_account(client->doc, &tmp, &rc, NULL, 0);
2059     g_strfreev(tmp);
2060
2061     if (!n)
2062         return rc;
2063
2064     if (g_utf8_collate(req[0], req[1]) == 0)
2065         return 0;
2066
2067     /*
2068      * Will not overwrite an existing account.
2069      */
2070     tmp = g_strdupv(req+1);
2071
2072     if (!tmp) {
2073         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2074         return gpg_error_from_errno(ENOMEM);
2075     }
2076
2077     n = find_account(client->doc, &tmp, &rc, NULL, 0);
2078     g_strfreev(tmp);
2079
2080     if (rc && rc != EPWMD_ELEMENT_NOT_FOUND)
2081         return rc;
2082
2083     if (n)
2084         return EPWMD_ACCOUNT_EXISTS;
2085
2086     /*
2087      * Whitespace not allowed in account names.
2088      */
2089     if (contains_whitespace(req[1]) == TRUE)
2090         return EPWMD_ATTR_SYNTAX;
2091
2092     tmp = g_strdupv(req);
2093
2094     if (!tmp) {
2095         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2096         return gpg_error_from_errno(ENOMEM);
2097     }
2098
2099     n = find_account(client->doc, &tmp, &rc, NULL, 0);
2100     g_strfreev(tmp);
2101
2102     if (!n)
2103         return EPWMD_ELEMENT_NOT_FOUND;
2104
2105     return add_attribute(n, "name", req[1]);
2106 }
2107
2108 /*
2109  * req[0] - attribute
2110  * req[1] - element path
2111  */
2112 static int attribute_get(assuan_context_t ctx, gchar **req)
2113 {
2114     struct client_s *client = assuan_get_pointer(ctx);
2115     xmlNodePtr n;
2116     xmlChar *a;
2117     gchar **path= NULL;
2118     gpg_error_t rc;
2119
2120     if (!req || !req[0] || !req[1])
2121         return EPWMD_COMMAND_SYNTAX;
2122
2123     if (strchr(req[1], '\t')) {
2124         if ((path = split_input_line(req[1], "\t", 0)) == NULL)
2125             return EPWMD_COMMAND_SYNTAX;
2126     }
2127     else {
2128         if ((path = split_input_line(req[1], " ", 0)) == NULL)
2129             return EPWMD_COMMAND_SYNTAX;
2130     }
2131
2132     n = find_account(client->doc, &path, &rc, NULL, 0);
2133
2134     if (!n)
2135         goto fail;
2136
2137     if (path[1]) {
2138         n = find_elements(client->doc, n->children, path+1, &rc,
2139                 NULL, NULL, NULL, FALSE, 0, NULL);
2140
2141         if (!n)
2142             goto fail;
2143     }
2144
2145     g_strfreev(path);
2146
2147     if ((a = xmlGetProp(n, (xmlChar *)req[0])) == NULL)
2148         return EPWMD_ATTR_NOT_FOUND;
2149
2150     rc = assuan_send_data(ctx, a, xmlStrlen(a));
2151     xmlFree(a);
2152     return rc;
2153
2154 fail:
2155     g_strfreev(path);
2156     return rc;
2157 }
2158
2159 /*
2160  * req[0] - attribute
2161  * req[1] - element path
2162  * req[2] - value
2163  */
2164 static int attribute_set(struct client_s *client, gchar **req)
2165 {
2166     gchar **path = NULL;
2167     gpg_error_t rc;
2168     xmlNodePtr n;
2169
2170     if (!req || !req[0] || !req[1] || !req[2])
2171         return EPWMD_COMMAND_SYNTAX;
2172
2173     /*
2174      * Reserved attribute names.
2175      */
2176     if (g_utf8_collate(req[0], "name") == 0) {
2177         /*
2178          * Only reserved for the account element. Not the rest of the
2179          * document.
2180          */
2181         if (strchr(req[1], '\t') == NULL)
2182             return name_attribute(client, req + 1);
2183     }
2184     else if (g_utf8_collate(req[0], "target") == 0)
2185         return target_attribute(client, req + 1);
2186
2187     if ((path = split_input_line(req[1], "\t", 0)) == NULL) {
2188         /*
2189          * The first argument may be only an account.
2190          */
2191         if ((path = split_input_line(req[1], " ", 0)) == NULL)
2192             return EPWMD_COMMAND_SYNTAX;
2193     }
2194
2195     n = find_account(client->doc, &path, &rc, NULL, 0);
2196
2197     if (!n)
2198         goto fail;
2199
2200     if (path[1]) {
2201         n = find_elements(client->doc, n->children, path+1, &rc,
2202                 NULL, NULL, NULL, FALSE, 0, NULL);
2203
2204         if (!n)
2205             goto fail;
2206     }
2207
2208     g_strfreev(path);
2209     return add_attribute(n, req[0], req[2]);
2210
2211 fail:
2212     g_strfreev(path);
2213     return rc;
2214 }
2215
2216 /*
2217  * req[0] - command
2218  * req[1] - attribute name or element path if command is LIST
2219  * req[2] - element path
2220  * req[2] - element path or value
2221  */
2222 static int attr_command(assuan_context_t ctx, char *line)
2223 {
2224     struct client_s *client = assuan_get_pointer(ctx);
2225     gchar **req;
2226     gpg_error_t rc = 0;
2227
2228     rc = file_modified(client);
2229
2230     if (rc)
2231         return send_error(ctx, rc);
2232
2233     req = split_input_line(line, " ", 4);
2234
2235     if (!req || !req[0] || !req[1]) {
2236         g_strfreev(req);
2237         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2238     }
2239
2240     if (g_ascii_strcasecmp(req[0], "SET") == 0)
2241         rc = attribute_set(client, req+1);
2242     else if (g_ascii_strcasecmp(req[0], "GET") == 0)
2243         rc = attribute_get(ctx, req+1);
2244     else if (g_ascii_strcasecmp(req[0], "DELETE") == 0)
2245         rc = attribute_delete(client, req+1);
2246     else if (g_ascii_strcasecmp(req[0], "LIST") == 0)
2247         rc = attribute_list(ctx, req+1);
2248     else
2249         rc = EPWMD_COMMAND_SYNTAX;
2250
2251     req_cleanup(req);
2252     return send_error(ctx, rc);
2253 }
2254
2255 static int iscached_command(assuan_context_t ctx, char *line)
2256 {
2257     gchar **req = split_input_line(line, " ", 0);
2258     guchar md5file[16];
2259     gchar *path, *tmp;
2260
2261     if (!req || !*req) {
2262         g_strfreev(req);
2263         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2264     }
2265
2266     if (!valid_filename(req[0])) {
2267         g_strfreev(req);
2268         return EPWMD_INVALID_FILENAME;
2269     }
2270
2271     tmp = get_key_file_string("global", "data_directory");
2272
2273     if (!tmp) {
2274         g_strfreev(req);
2275         return gpg_error_from_errno(ENOMEM);
2276     }
2277
2278     path = expand_homedir(tmp);
2279
2280     if (!path) {
2281         g_strfreev(req);
2282         g_free(tmp);
2283         return gpg_error_from_errno(ENOMEM);
2284     }
2285
2286     g_free(tmp);
2287     tmp = path;
2288     path = g_strdup_printf("%s/%s", tmp, req[0]);
2289     g_free(tmp);
2290
2291     if (!path) {
2292         g_strfreev(req);
2293         return gpg_error_from_errno(ENOMEM);
2294     }
2295
2296     if (access(path, R_OK) == -1) {
2297         gpg_error_t rc = gpg_error_from_syserror();
2298
2299         g_free(path);
2300         g_strfreev(req);
2301         return send_error(ctx, rc);
2302     }
2303
2304     g_free(path);
2305     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
2306     g_strfreev(req);
2307     CACHE_LOCK(ctx);
2308
2309     if (cache_iscached(md5file) == FALSE) {
2310         CACHE_UNLOCK;
2311         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2312     }
2313
2314     CACHE_UNLOCK;
2315     return send_error(ctx, 0);
2316 }
2317
2318 static int clearcache_command(assuan_context_t ctx, char *line)
2319 {
2320     struct client_s *client = assuan_get_pointer(ctx);
2321     gchar **req = split_input_line(line, " ", 0);
2322     guchar md5file[16];
2323
2324     CACHE_LOCK(ctx);
2325
2326     if (!req || !*req) {
2327         g_strfreev(req);
2328         cache_clear(client->md5file, 2);
2329         CACHE_UNLOCK;
2330         return send_error(ctx, 0);
2331     }
2332
2333     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[0], strlen(req[0]));
2334     g_strfreev(req);
2335
2336     if (cache_clear(md5file, 1) == FALSE) {
2337         CACHE_UNLOCK;
2338         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2339     }
2340
2341     CACHE_UNLOCK;
2342     return send_error(ctx, 0);
2343 }
2344
2345 static int cachetimeout_command(assuan_context_t ctx, char *line)
2346 {
2347     guchar md5file[16];
2348     glong timeout;
2349     gchar **req = split_input_line(line, " ", 0);
2350     gchar *p;
2351
2352     if (!req || !*req || !req[1]) {
2353         g_strfreev(req);
2354         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2355     }
2356
2357     errno = 0;
2358     timeout = strtol(req[0], &p, 10);
2359
2360     if (errno != 0 || *p != 0) {
2361         g_strfreev(req);
2362         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2363     }
2364
2365     gcry_md_hash_buffer(GCRY_MD_MD5, md5file, req[1], strlen(req[1]));
2366     CACHE_LOCK(client->ctx);
2367
2368     if (cache_set_timeout(md5file, timeout) == FALSE) {
2369         CACHE_UNLOCK;
2370         return send_error(ctx, EPWMD_CACHE_NOT_FOUND);
2371     }
2372
2373     CACHE_UNLOCK;
2374     return send_error(ctx, 0);
2375 }
2376
2377 static int dump_command(assuan_context_t ctx, char *line)
2378 {
2379     xmlChar *xml;
2380     gssize len;
2381     struct client_s *client = assuan_get_pointer(ctx);
2382     gpg_error_t rc;
2383
2384     if (disable_list_and_dump == TRUE)
2385         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
2386
2387     rc = file_modified(client);
2388
2389     if (rc)
2390         return send_error(ctx, rc);
2391
2392     xmlDocDumpFormatMemory(client->doc, &xml, &len, 1);
2393
2394     if (!xml) {
2395         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2396         return send_syserror(ctx, ENOMEM);
2397     }
2398
2399     rc = assuan_send_data(ctx, xml, len);
2400     xmlFree(xml);
2401     return send_error(ctx, rc);
2402 }
2403
2404 static int getconfig_command(assuan_context_t ctx, gchar *line)
2405 {
2406     struct client_s *client = assuan_get_pointer(ctx);
2407     gpg_error_t rc = 0;
2408     gchar filename[255]={0}, param[747]={0};
2409     gchar *p, *tmp, *fp = client->filename, *paramp = line;
2410
2411     if (strchr(line, ' ')) {
2412         sscanf(line, " %254[^ ] %746c", filename, param);
2413         fp = filename;
2414         paramp = param;
2415     }
2416
2417     if (fp && !valid_filename(fp))
2418         return send_error(ctx, EPWMD_INVALID_FILENAME);
2419
2420     paramp = g_ascii_strdown(paramp, -1);
2421
2422     if (!paramp) {
2423         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2424         return send_syserror(ctx, ENOMEM);
2425     }
2426
2427     p = get_key_file_string(fp ? fp : "global", paramp);
2428     g_free(paramp);
2429
2430     if (!p)
2431         return send_error(ctx, GPG_ERR_NO_VALUE);
2432
2433     tmp = expand_homedir(p);
2434     g_free(p);
2435
2436     if (!tmp) {
2437         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2438         return send_syserror(ctx, ENOMEM);
2439     }
2440
2441     p = tmp;
2442     rc = assuan_send_data(ctx, p, strlen(p));
2443     g_free(p);
2444     return send_error(ctx, rc);
2445 }
2446
2447 struct xpath_s {
2448     xmlXPathContextPtr xp;
2449     xmlXPathObjectPtr result;
2450     xmlBufferPtr buf;
2451     gchar **req;
2452 };
2453
2454 static void xpath_command_cleanup(void *arg)
2455 {
2456     struct xpath_s *xpath = arg;
2457
2458     req_cleanup(xpath->req);
2459
2460     if (xpath->buf)
2461         xmlBufferFree(xpath->buf);
2462
2463     if (xpath->result)
2464         xmlXPathFreeObject(xpath->result);
2465
2466     if (xpath->xp)
2467         xmlXPathFreeContext(xpath->xp);
2468 }
2469
2470 static int xpath_command(assuan_context_t ctx, gchar *line)
2471 {
2472     struct client_s *client = assuan_get_pointer(ctx);
2473     gpg_error_t rc;
2474     struct xpath_s xpath;
2475
2476     if (disable_list_and_dump == TRUE)
2477         return send_error(ctx, GPG_ERR_NOT_IMPLEMENTED);
2478
2479     rc = file_modified(client);
2480
2481     if (rc)
2482         return send_error(ctx, rc);
2483
2484     if (!line || !*line)
2485         return send_error(ctx, EPWMD_COMMAND_SYNTAX);
2486
2487     memset(&xpath, 0, sizeof(struct xpath_s));
2488
2489     if ((xpath.req = split_input_line(line, "\t", 2)) == NULL) {
2490         if (strv_printf(&xpath.req, "%s", line) == FALSE)
2491             return send_syserror(ctx, ENOMEM);
2492     }
2493
2494     xpath.xp = xmlXPathNewContext(client->doc);
2495
2496     if (!xpath.xp) {
2497         xpath_command_cleanup(&xpath);
2498         return send_error(ctx, EPWMD_LIBXML_ERROR);
2499     }
2500
2501     xpath.result = xmlXPathEvalExpression((xmlChar *)xpath.req[0], xpath.xp);
2502
2503     if (!xpath.result) {
2504         xpath_command_cleanup(&xpath);
2505         return send_error(ctx, EPWMD_LIBXML_ERROR);
2506     }
2507
2508     if (xmlXPathNodeSetIsEmpty(xpath.result->nodesetval)) {
2509         rc = EPWMD_EMPTY_ELEMENT;
2510         goto fail;
2511     }
2512
2513     rc = recurse_xpath_nodeset(client->doc, xpath.result->nodesetval,
2514             (xmlChar *)xpath.req[1], &xpath.buf);
2515
2516     if (rc)
2517         goto fail;
2518     else if (!xpath.req[1] && !xmlBufferLength(xpath.buf)) {
2519         rc = EPWMD_EMPTY_ELEMENT;
2520         goto fail;
2521     }
2522     else if (xpath.req[1])
2523         goto fail;
2524
2525     pth_cancel_point();
2526     rc = assuan_send_data(ctx, xmlBufferContent(xpath.buf),
2527             xmlBufferLength(xpath.buf));
2528     pth_cancel_point();
2529
2530 fail:
2531     xpath_command_cleanup(&xpath);
2532     return send_error(ctx, rc);
2533 }
2534
2535 static int import_command_finalize(gpointer data, gint assuan_rc, guchar *line,
2536         gsize len)
2537 {
2538     struct client_s *client = assuan_get_pointer((assuan_context_t)data);
2539     gpg_error_t rc = file_modified(client);
2540     gchar **req, **path = NULL, **path_orig = NULL, *content;
2541     xmlDocPtr doc;
2542     xmlNodePtr n, root, copy;
2543
2544     if (assuan_rc || rc) {
2545         if (line)
2546             xfree(line);
2547         return assuan_rc ? assuan_rc : rc;
2548     }
2549
2550     req = split_input_line((gchar *)line, " ", 2);
2551     xfree(line);
2552
2553     if (!req || !*req)
2554         return EPWMD_COMMAND_SYNTAX;
2555
2556     if ((path = split_input_line(req[0], "\t", 0)) == NULL) {
2557         if ((path = split_input_line(req[0], " ", 0)) == NULL)
2558             return EPWMD_COMMAND_SYNTAX;
2559     }
2560
2561     content = req[1];
2562
2563     if (!content || !*content) {
2564         rc = EPWMD_COMMAND_SYNTAX;
2565         goto fail;
2566     }
2567
2568     if (valid_xml_element((xmlChar *)*path) == FALSE) {
2569         rc = EPWMD_INVALID_ELEMENT;
2570         goto fail;
2571     }
2572
2573     if (valid_element_path(path+1, FALSE) == FALSE) {
2574         rc = EPWMD_INVALID_ELEMENT;
2575         goto fail;
2576     }
2577
2578     doc = xmlReadDoc((xmlChar *)content, NULL, "UTF-8", XML_PARSE_NOBLANKS);
2579
2580     if (!doc) {
2581         rc = EPWMD_LIBXML_ERROR;
2582         goto fail;
2583     }
2584
2585     root = xmlDocGetRootElement(doc);
2586     path_orig = g_strdupv(path);
2587
2588     if (!path_orig) {
2589         xmlFreeDoc(doc);
2590         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2591         rc = gpg_error_from_errno(ENOMEM);
2592         goto fail;
2593     }
2594
2595     if (strv_printf(&path, "%s", (gchar *)root->name) == FALSE) {
2596         g_strfreev(path_orig);
2597         xmlFreeDoc(doc);
2598         rc = gpg_error_from_errno(ENOMEM);
2599         goto fail;
2600     }
2601
2602     n = find_account(client->doc, &path, &rc, NULL, 0);
2603
2604     if (rc && rc != EPWMD_ELEMENT_NOT_FOUND) {
2605         g_strfreev(path_orig);
2606         xmlFreeDoc(doc);
2607         goto fail;
2608     }
2609     else if (!rc) {
2610         n = find_elements(client->doc, n->children, path+1, &rc, NULL, NULL, NULL, FALSE, 0, NULL);
2611
2612         if (rc && rc != EPWMD_ELEMENT_NOT_FOUND) {
2613             g_strfreev(path_orig);
2614             xmlFreeDoc(doc);
2615             goto fail;
2616         }
2617         else if (!rc) {
2618             xmlNodePtr parent = n->parent;
2619
2620             xmlUnlinkNode(n);
2621             xmlFreeNode(n);
2622             n = parent;
2623         }
2624     }
2625
2626     g_strfreev(path);
2627     path = path_orig;
2628
2629     if (rc == EPWMD_ELEMENT_NOT_FOUND) {
2630         n = create_element_path(client, &path, &rc);
2631
2632         if (rc) {
2633             xmlFreeDoc(doc);
2634             goto fail;
2635         }
2636     }
2637
2638     copy = xmlCopyNode(root, 1);
2639     n = xmlAddChild(n, copy);
2640     xmlFreeDoc(doc);
2641
2642     if (!n)
2643         rc = EPWMD_LIBXML_ERROR;
2644
2645 fail:
2646     g_strfreev(path);
2647     g_strfreev(req);
2648     client->inquire_status = INQUIRE_DONE;
2649     return rc;
2650 }
2651
2652 static int import_command(assuan_context_t ctx, gchar *line)
2653 {
2654     gpg_error_t rc;
2655     struct client_s *client = assuan_get_pointer(ctx);
2656
2657     rc = file_modified(client);
2658
2659     if (rc)
2660         return send_error(ctx, rc);
2661
2662     pth_cancel_point();
2663     rc = assuan_inquire_ext(ctx, "IMPORT", 0, import_command_finalize, ctx);
2664     pth_cancel_point();
2665
2666     if (rc)
2667         return send_error(ctx, rc);
2668
2669     /* Don't return with assuan_process_done() here. This is an INQUIRE. */
2670     client->inquire_status = INQUIRE_BUSY;
2671     return 0;
2672 }
2673
2674 static int lock_command(assuan_context_t ctx, gchar *line)
2675 {
2676     gpg_error_t rc;
2677     struct client_s *client = assuan_get_pointer(ctx);
2678
2679     rc = file_modified(client);
2680
2681     if (rc)
2682         return send_error(ctx, rc);
2683
2684     rc = lock_file_mutex(client);
2685
2686     if (!rc)
2687         client->is_lock_cmd = TRUE;
2688
2689     return send_error(ctx, rc);
2690 }
2691
2692 static int unlock_command(assuan_context_t ctx, gchar *line)
2693 {
2694     struct client_s *client = assuan_get_pointer(ctx);
2695     gpg_error_t rc = file_modified(client);
2696
2697     if (rc)
2698         return send_error(ctx, rc);
2699
2700     unlock_file_mutex(client);
2701     return send_error(ctx, 0);
2702 }
2703
2704 static int getpid_command(assuan_context_t ctx, gchar *line)
2705 {
2706     gpg_error_t rc;
2707     gchar buf[32];
2708     pid_t pid = getpid();
2709
2710     print_fmt(buf, sizeof(buf), "%i", pid);
2711     pth_cancel_point();
2712     rc = assuan_send_data(ctx, buf, strlen(buf));
2713     pth_cancel_point();
2714     return send_error(ctx, rc);
2715 }
2716
2717 static int version_command(assuan_context_t ctx, gchar *line)
2718 {
2719     gpg_error_t rc;
2720     gchar buf[32];
2721
2722     print_fmt(buf, sizeof(buf), "%s", PACKAGE_VERSION);
2723     pth_cancel_point();
2724     rc = assuan_send_data(ctx, buf, strlen(buf));
2725     pth_cancel_point();
2726     return send_error(ctx, rc);
2727 }
2728
2729 static void bye_notify(assuan_context_t ctx)
2730 {
2731     struct client_s *cl = assuan_get_pointer(ctx);
2732
2733     /* This will let assuan_process_next() return. */
2734     fcntl(cl->thd->fd, F_SETFL, O_NONBLOCK);
2735 }
2736
2737 static void reset_notify(assuan_context_t ctx)
2738 {
2739     struct client_s *cl = assuan_get_pointer(ctx);
2740
2741     if (cl)
2742         cleanup_client(cl);
2743 }
2744
2745 static gpg_error_t parse_client_option(assuan_context_t ctx, const gchar *line)
2746 {
2747     gchar name[32] = {0}, value[256] = {0};
2748     struct client_s *cl = assuan_get_pointer(ctx);
2749
2750     if (sscanf(line, " %31[a-zA-Z] = %255c", name, value) != 2)
2751         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_SYNTAX);
2752
2753     if (g_strcasecmp(name, (gchar *)"NAME") == 0) {
2754         pth_attr_t attr = pth_attr_of(pth_self());
2755         gchar buf[41];
2756
2757         if (!strcmp(value, "NULL")) {
2758             pth_attr_set(attr, PTH_ATTR_NAME, NULL);
2759             pth_attr_destroy(attr);
2760             return 0;
2761         }
2762
2763         print_fmt(buf, sizeof(buf), "%s", value);
2764         pth_attr_set(attr, PTH_ATTR_NAME, buf);
2765         pth_attr_destroy(attr);
2766 #ifdef WITH_PINENTRY
2767         if (cl->pinentry->name)
2768             g_free(cl->pinentry->name);
2769
2770         cl->pinentry->name = g_strdup(buf);
2771 #endif
2772         log_write("OPTION CLIENT %s=%s", name, buf);
2773     }
2774     else
2775         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_UNKNOWN_OPTION);
2776
2777     return 0;
2778 }
2779
2780 static void set_option_value(gchar **opt, const gchar *val)
2781 {
2782     if (opt)
2783         g_free(*opt);
2784
2785     *opt = NULL;
2786
2787     if (val && strcmp(val, "NULL"))
2788         *opt = g_strdup(val);
2789 }
2790
2791 static int option_handler(assuan_context_t ctx, const gchar *name,
2792         const gchar *value)
2793 {
2794     struct client_s *client = assuan_get_pointer(ctx);
2795
2796     if (!value || !*value)
2797         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2798
2799     if (g_strcasecmp(name, (gchar *)"client") == 0)
2800         return parse_client_option(ctx, value);
2801
2802     if (g_strcasecmp(name, (gchar *)"iterations") == 0) {
2803         long n;
2804         gchar *p = NULL;
2805
2806         errno = 0;
2807         n = strtol(value, &p, 10);
2808
2809         if (errno || (p && *p) || n < 0)
2810             return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2811
2812         MUTEX_LOCK(&rcfile_mutex);
2813         g_key_file_set_integer(keyfileh, client->filename ? client->filename : "global", "iterations", (guint)n);
2814         MUTEX_UNLOCK(&rcfile_mutex);
2815         send_status_all(STATUS_CONFIG);
2816     }
2817 #ifdef WITH_PINENTRY
2818     else if (g_strcasecmp(name, (gchar *)"lc_messages") == 0)
2819         set_option_value(&client->pinentry->lcmessages, value);
2820     else if (g_strcasecmp(name, (gchar *)"lc_ctype") == 0)
2821         set_option_value(&client->pinentry->lcctype, value);
2822     else if (g_strcasecmp(name, (gchar *)"ttyname") == 0)
2823         set_option_value(&client->pinentry->ttyname, value);
2824     else if (g_strcasecmp(name, (gchar *)"ttytype") == 0)
2825         set_option_value(&client->pinentry->ttytype, value);
2826     else if (g_strcasecmp(name, (gchar *)"display") == 0)
2827         set_option_value(&client->pinentry->display, value);
2828     else if (g_strcasecmp(name, (gchar *)"path") == 0)
2829         set_option_value(&client->pinentry->path, value);
2830     else if (g_strcasecmp(name, (gchar *)"title") == 0)
2831         set_option_value(&client->pinentry->title, value);
2832     else if (g_strcasecmp(name, (gchar *)"prompt") == 0)
2833         set_option_value(&client->pinentry->prompt, value);
2834     else if (g_strcasecmp(name, (gchar *)"desc") == 0)
2835         set_option_value(&client->pinentry->desc, value);
2836     /*
2837      * Look at client_thread() to see how this works.
2838      */
2839     else if (g_strcasecmp(name, (gchar *)"timeout") == 0) {
2840         gchar *p = NULL;
2841         gint n = strtol(value, &p, 10);
2842
2843         if (*p || n < 0)
2844             return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2845
2846         client->pinentry->timeout = n;
2847     }
2848     else if (g_strcasecmp(name, (gchar *)"pinentry") == 0) {
2849         gchar *p = NULL;
2850         gint n = strtol(value, &p, 10);
2851
2852         if (*p || n < 0 || n > 1)
2853             return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_INV_VALUE);
2854
2855         client->pinentry->enable = n == 0 ? FALSE : TRUE;
2856     }
2857 #endif
2858     else
2859         return gpg_err_make(PWMD_ERR_SOURCE, GPG_ERR_UNKNOWN_OPTION);
2860
2861     log_write("OPTION %s=%s", name, value);
2862     return 0;
2863 }
2864
2865 gpg_error_t register_commands(assuan_context_t ctx)
2866 {
2867     static struct {
2868         const gchar *name;
2869         gint (*handler)(assuan_context_t, gchar *line);
2870     } table[] = {
2871         { "OPEN", open_command },
2872         { "SAVE", save_command },
2873         { "LIST", list_command },
2874         { "REALPATH", realpath_command },
2875         { "STORE", store_command },
2876         { "DELETE", delete_command },
2877         { "GET", get_command },
2878         { "ATTR", attr_command },
2879         { "ISCACHED", iscached_command },
2880         { "CLEARCACHE", clearcache_command },
2881         { "CACHETIMEOUT", cachetimeout_command },
2882         { "GETCONFIG", getconfig_command },
2883         { "DUMP", dump_command },
2884         { "XPATH", xpath_command },
2885         { "IMPORT", import_command },
2886         { "LOCK", lock_command },
2887         { "UNLOCK", unlock_command },
2888         { "GETPID", getpid_command },
2889         { "VERSION", version_command },
2890         { "INPUT", NULL },
2891         { "OUTPUT", NULL },
2892         { NULL, NULL }
2893     };
2894     gint i, rc;
2895
2896     for (i=0; table[i].name; i++) {
2897         rc = assuan_register_command (ctx, table[i].name, table[i].handler);
2898
2899         if (rc)
2900             return rc;
2901     }
2902
2903     rc = assuan_register_bye_notify(ctx, bye_notify);
2904
2905     if (rc)
2906         return rc;
2907
2908     rc = assuan_register_option_handler(ctx, option_handler);
2909
2910     if (rc)
2911         return rc;
2912
2913     rc = assuan_register_reset_notify(ctx, reset_notify);
2914
2915     if (rc)
2916         return rc;
2917
2918     return assuan_register_post_cmd_notify(ctx, command_finalize);
2919 }
2920
2921 gpg_error_t try_xml_decrypt(assuan_context_t ctx, guchar *key,
2922         struct client_crypto_s *crypto, gpointer *dst, goffset *dst_len)
2923 {
2924     goffset insize, len;
2925     struct client_s *client = ctx ? assuan_get_pointer(ctx) : NULL;
2926     guint64 iter = 0, n_iter = 0, iter_progress = 0;
2927     gint zrc = 0;
2928     gulong outsize = 0;
2929     gpg_error_t rc;
2930     gsize fh_size = crypto->fh->v1 ? sizeof(crypto->fh->fh1) : sizeof(crypto->fh->fh2);
2931     guint64 fh_iter = crypto->fh->v1 ? crypto->fh->fh1.iter : crypto->fh->fh2.iter;
2932
2933     lseek(crypto->fh->fd, fh_size, SEEK_SET);
2934     insize = crypto->fh->st.st_size - fh_size;
2935     crypto->iv = gcry_malloc(gcryblocksize);
2936
2937     if (!crypto->iv) {
2938         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2939         return gpg_error_from_errno(ENOMEM);
2940     }
2941
2942     /* No encryption iterations. This is a plain (gzipped) file. */
2943     if ((crypto->fh->v1 && fh_iter < 0) || (!crypto->fh->v1 && fh_iter <= 0)) {
2944         /*
2945          * cache_file_count() needs both .used == TRUE and a valid key in
2946          * order for it to count as a used cache entry. Fixes CACHE status
2947          * messages.
2948          */
2949         memset(key, '!', gcrykeysize);
2950     }
2951
2952     if (crypto->fh->v1)
2953         memcpy(crypto->iv, crypto->fh->fh1.iv, gcryblocksize);
2954     else
2955         memcpy(crypto->iv, crypto->fh->fh2.iv, gcryblocksize);
2956
2957     crypto->inbuf = gcry_malloc(insize);
2958
2959     if (!crypto->inbuf) {
2960         log_write("%s(%i): %s", __FILE__, __LINE__, strerror(ENOMEM));
2961         return gpg_error_from_errno(ENOMEM);
2962     }
2963
2964     crypto->insize = insize;
2965     len = pth_read(crypto->fh->fd, crypto->inbuf, crypto->insize);
2966     pth_cancel_point();
2967
2968     if (len != crypto->insize)
2969         return GPG_ERR_INV_LENGTH;
2970
2971     if ((crypto->fh->v1 && fh_iter < 0) || (!crypto->fh->v1 && fh_iter <= 0))
2972         goto decompress;
2973
2974     if ((rc = gcry_cipher_setiv(crypto->gh, crypto->iv, gcryblocksize))) {
2975         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
2976         return rc;
2977     }
2978
2979     if ((rc = gcry_cipher_setkey(crypto->gh, key, gcrykeysize))) {
2980         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
2981         return rc;
2982     }
2983
2984     iter_progress = (guint64)get_key_file_integer(client && client->filename ?
2985             client->filename : "global", "iteration_progress");
2986
2987     if (iter_progress > 0 && fh_iter >= iter_progress) {
2988         rc = send_status(ctx, STATUS_DECRYPT, "0 %llu", fh_iter);
2989         pth_cancel_point();
2990
2991         if (rc)
2992             return rc;
2993     }
2994
2995     rc = iterate_crypto_once(client, crypto, STATUS_DECRYPT);
2996
2997     if (rc)
2998         return rc;
2999
3000     crypto->tkey = gcry_malloc(gcrykeysize);
3001
3002     if (!crypto->tkey) {
3003         log_write("%s(%i): %s", __FUNCTION__, __LINE__, strerror(ENOMEM));
3004         return gpg_error_from_errno(ENOMEM);
3005     }
3006
3007     memcpy(crypto->tkey, key, gcrykeysize);
3008     guchar *tkey = crypto->tkey;
3009     tkey[0] ^= 1;
3010
3011     if ((rc = gcry_cipher_setkey(crypto->gh, crypto->tkey, gcrykeysize))) {
3012         log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
3013         return rc;
3014     }
3015
3016     while (iter < (crypto->fh->v1 ? fh_iter : fh_iter-1)) {
3017         if (iter_progress > 0 && iter >= iter_progress) {
3018             if (!(iter % iter_progress)) {
3019                 rc = send_status(ctx, STATUS_DECRYPT, "%llu %llu",
3020                         ++n_iter * iter_progress, fh_iter);
3021                 pth_cancel_point();
3022
3023                 if (rc)
3024                     return rc;
3025             }
3026         }
3027
3028         if ((rc = gcry_cipher_setiv(crypto->gh, crypto->iv, gcryblocksize))) {
3029             log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
3030             return rc;
3031         }
3032
3033         rc = iterate_crypto_once(client, crypto, STATUS_DECRYPT);
3034
3035         if (rc) {
3036             log_write("%s(%i): %s", __FUNCTION__, __LINE__, _gpg_strerror(rc));
3037             return rc;
3038         }
3039
3040         iter++;
3041     }
3042
3043     if (iter_progress && fh_iter >= iter_progress) {
3044         rc = send_status(ctx, STATUS_DECRYPT, "%llu %llu", fh_iter, fh_iter);
3045         pth_cancel_point();
3046
3047         if (rc)
3048             return rc;
3049     }
3050
3051 decompress:
3052     if (do_decompress(ctx, crypto->inbuf, crypto->insize,
3053                 (gpointer *)&crypto->outbuf, &outsize, &zrc) == FALSE) {
3054         if (zrc == Z_MEM_ERROR)
3055             return gpg_error_from_errno(ENOMEM);
3056         else
3057             return EPWMD_BADKEY; // Not a valid gzip header. Must be a bad key.
3058     }
3059
3060     if (g_strncasecmp(crypto->outbuf, "<?xml version=", 14) != 0) {
3061         gcry_free(crypto->outbuf);
3062         crypto->outbuf = NULL;
3063         return EPWMD_BADKEY;
3064     }
3065
3066     if (ctx) {
3067         client->xml = crypto->outbuf;
3068         client->len = outsize;
3069         crypto->outbuf = NULL;
3070     }
3071     else if (dst) {
3072         *dst = crypto->outbuf;
3073         *dst_len = outsize;
3074         crypto->outbuf = NULL;
3075     }
3076
3077     /* The calling function should free the crypto struct. */
3078     return 0;
3079 }
3080
3081 /*
3082  * This is called after every Assuan command.
3083  */
3084 void command_finalize(assuan_context_t ctx, gint rc)
3085 {
3086     struct client_s *client = assuan_get_pointer(ctx);
3087
3088     if (!client->is_lock_cmd)
3089         unlock_file_mutex(client);
3090 }