src/commands.c

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