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