?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Lock the data file mutex before the advisory lock.
[pwmd.git] / src / commands.c
blobf458c48039e36f44b3d7281bd2cc8302fe1ea751
1 /*
2 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015
3 Ben Kibbey <bjk@luxsci.net>
4
5 This file is part of pwmd.
6
7 Pwmd is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 2 of the License, or
10 (at your option) any later version.
11
12 Pwmd is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Pwmd. If not, see <http://www.gnu.org/licenses/>.
19 */
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <err.h>
28 #include <errno.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <fcntl.h>
32 #include <ctype.h>
33 #include <dirent.h>
34 #include <pthread.h>
35 #include <stdint.h>
36
37 #ifdef WITH_LIBACL
38 #include <sys/acl.h>
39 #endif
40
41 #include "pwmd-error.h"
42 #include <gcrypt.h>
43
44 #include "mem.h"
45 #include "xml.h"
46 #include "util-misc.h"
47 #include "common.h"
48 #include "rcfile.h"
49 #include "cache.h"
50 #include "commands.h"
51 #include "mutex.h"
52 #include "crypto.h"
53 #include "pinentry.h"
54
55 /* These are command option flags. */
56 #define OPT_INQUIRE 0x0001
57 #define OPT_NO_PASSPHRASE 0x0002
58 #define OPT_RESET 0x0004
59 #define OPT_LIST_RECURSE 0x0008
60 #define OPT_VERBOSE 0x0010
61 #define OPT_LOCK 0x0020
62 #define OPT_LOCK_ON_OPEN 0x0040
63 #define OPT_SIGN 0x0080
64 #define OPT_LIST_ALL 0x0100
65 #define OPT_LIST_WITH_TARGET 0x0200
66 #define OPT_DATA 0x0400
67 #define OPT_NO_AGENT 0x0800
68 #define OPT_ASK 0x1000
69
70 #ifdef WITH_AGENT
71 /* The GETCONFIG command, for example, may fail because pwmd lost the
72 * gpg-agent connection. Update the recovered agent ctx. */
73 #define UPDATE_AGENT_CTX(client, crypto) do { \
74 if (crypto && crypto->agent && crypto->agent->did_restart \
75 && client->crypto && client->crypto->agent \
76 && client->crypto->agent->ctx && \
77 crypto->agent->ctx != client->crypto->agent->ctx) \
78 { \
79 client->crypto->agent->ctx = crypto->agent->ctx; \
80 crypto->agent->ctx = NULL; \
81 } \
82 } while (0)
83 #else
84 #define UPDATE_AGENT_CTX(client, crypto)
85 #endif
86
87 #define FLOCK_TYPE_NONE 0
88 #define FLOCK_TYPE_SH 0x0001
89 #define FLOCK_TYPE_EX 0x0002
90 #define FLOCK_TYPE_KEEP 0x0004
91
92 struct command_table_s
93 {
94 const char *name;
95 gpg_error_t (*handler) (assuan_context_t, char *line);
96 const char *help;
97 int ignore_startup;
98 int unlock; // unlock the file mutex after validating the checksum
99 uint32_t flock_type;
100 };
101
102 static struct command_table_s **command_table;
103
104 static gpg_error_t do_lock (struct client_s *client, int add);
105 static gpg_error_t validate_checksum (struct client_s *,
106 struct cache_data_s *);
107 static gpg_error_t update_checksum (struct client_s *client);
108
109 /* When 'status' is true the 'self' field of the status line will be false
110 * because we never send the STATE status message to the same client that
111 * initiated it. */
112 static char *
113 build_client_info_line (struct client_thread_s *thd, int status)
114 {
115 MUTEX_LOCK (&cn_mutex);
116 int with_state = config_get_boolean ("global", "send_state");
117 char *uid, *username = NULL;
118 char *line;
119
120 #ifdef WITH_GNUTLS
121 if (thd->remote)
122 uid = str_asprintf("#%s", thd->tls->fp);
123 else
124 {
125 uid = str_asprintf("%u", thd->peer->uid);
126 username = get_username (thd->peer->uid);
127 }
128 #else
129 uid = str_asprintf("%u", thd->peer->uid);
130 username = get_username (thd->peer->uid);
131 #endif
132 line = str_asprintf ("%p %s %s %s %u %u %u %s %s",
133 thd->tid,
134 thd->name ? thd->name : "-",
135 thd->cl && thd->cl->filename
136 && (thd->cl->flags & FLAG_OPEN)
137 ? thd->cl->filename : "/",
138 #ifdef WITH_GNUTLS
139 thd->remote ? thd->peeraddr : "-",
140 #else
141 "-",
142 #endif
143 thd->cl && thd->cl->flags & FLAG_HAS_LOCK ? 1 : 0,
144 !status && pthread_equal (pthread_self (), thd->tid) ? 1 : 0,
145 with_state ? thd->state : CLIENT_STATE_UNKNOWN, uid,
146 #ifdef WITH_GNUTLS
147 thd->remote ? "" : username
148 #else
149 username
150 #endif
151 );
152
153 xfree (username);
154 xfree (uid);
155 MUTEX_UNLOCK (&cn_mutex);
156 return line;
157 }
158
159 void
160 update_client_state (struct client_s *client, unsigned s)
161 {
162 client->thd->state = s;
163 int n = config_get_boolean ("global", "send_state");
164
165 if (n && client->thd->state != CLIENT_STATE_UNKNOWN)
166 {
167 char *line = build_client_info_line (client->thd, 1);
168
169 if (line)
170 send_status_all_not_self (n == 2, STATUS_STATE, "%s", line);
171 }
172 }
173
174 static gpg_error_t
175 unlock_file_mutex (struct client_s *client, int remove)
176 {
177 gpg_error_t rc = 0;
178
179 // OPEN: keep the lock for the same file being reopened.
180 if (client->flags & FLAG_KEEP_LOCK && client->flags & FLAG_HAS_LOCK)
181 return 0;
182
183 if (!(client->flags & FLAG_HAS_LOCK))
184 return GPG_ERR_NOT_LOCKED;
185
186 rc = cache_unlock_mutex (client->md5file, remove);
187 if (rc)
188 rc = GPG_ERR_INV_STATE;
189 else
190 client->flags &= ~(FLAG_HAS_LOCK | FLAG_LOCK_CMD);
191
192 return rc;
193 }
194
195 static gpg_error_t
196 lock_file_mutex (struct client_s *client, int add)
197 {
198 gpg_error_t rc = 0;
199 int timeout = config_get_integer (client->filename, "cache_timeout");
200
201 if (client->flags & FLAG_HAS_LOCK)
202 return 0;
203
204 rc = cache_lock_mutex (client->ctx, client->md5file,
205 client->lock_timeout, add, timeout);
206 if (!rc)
207 client->flags |= FLAG_HAS_LOCK;
208
209 return rc;
210 }
211
212 static gpg_error_t
213 file_modified (struct client_s *client, struct command_table_s *cmd)
214 {
215 gpg_error_t rc = 0;
216 int type = !cmd->flock_type || (cmd->flock_type & FLOCK_TYPE_SH)
217 ? LOCK_SH : LOCK_EX;
218
219 if (!(client->flags & FLAG_OPEN))
220 return GPG_ERR_INV_STATE;
221
222 rc = lock_file_mutex (client, 0);
223 if (rc && rc != GPG_ERR_NO_DATA)
224 return rc;
225
226 rc = lock_flock (client->ctx, client->filename, type, &client->flock_fd);
227 if (!rc)
228 {
229 rc = validate_checksum (client, NULL);
230 if (gpg_err_code (rc) == GPG_ERR_ENOENT && (client->flags & FLAG_NEW))
231 rc = 0;
232 else if (rc)
233 log_write ("%s: %s", client->filename, pwmd_strerror (rc));
234 }
235 else if (gpg_err_code(rc) == GPG_ERR_ENOENT)
236 rc = 0;
237
238 if ((cmd->unlock && !(client->flags & FLAG_HAS_LOCK)) || rc)
239 unlock_file_mutex (client, 0);
240
241 if (rc || !(cmd->flock_type & FLOCK_TYPE_KEEP))
242 unlock_flock (&client->flock_fd);
243
244 return rc;
245 }
246
247 static gpg_error_t
248 parse_xml (assuan_context_t ctx, int new)
249 {
250 struct client_s *client = assuan_get_pointer (ctx);
251 int cached = client->doc != NULL;
252 gpg_error_t rc = 0;
253
254 if (new)
255 {
256 client->doc = new_document ();
257 if (client->doc)
258 {
259 xmlChar *result;
260 int len;
261
262 xmlDocDumpFormatMemory (client->doc, &result, &len, 0);
263 client->crypto->plaintext = result;
264 client->crypto->plaintext_len = len;
265 if (!client->crypto->plaintext)
266 {
267 xmlFreeDoc (client->doc);
268 client->doc = NULL;
269 rc = GPG_ERR_ENOMEM;
270 }
271 }
272 else
273 rc = GPG_ERR_ENOMEM;
274 }
275 else if (!cached)
276 rc = parse_doc ((char *) client->crypto->plaintext,
277 client->crypto->plaintext_len, (xmlDocPtr *)&client->doc);
278
279 return rc;
280 }
281
282 static void
283 free_client (struct client_s *client)
284 {
285 if (client->doc)
286 xmlFreeDoc (client->doc);
287
288 xfree (client->crc);
289 xfree (client->filename);
290 xfree (client->last_error);
291
292 if (client->crypto)
293 {
294 cleanup_crypto_stage2 (client->crypto);
295 if (client->crypto->pkey_sexp)
296 gcry_sexp_release (client->crypto->pkey_sexp);
297
298 if (client->crypto->sigpkey_sexp)
299 gcry_sexp_release (client->crypto->sigpkey_sexp);
300
301 client->crypto->pkey_sexp = NULL;
302 client->crypto->sigpkey_sexp = NULL;
303 memset (client->crypto->sign_grip, 0,
304 sizeof (client->crypto->sign_grip));
305 memset (client->crypto->grip, 0, sizeof(client->crypto->grip));
306 }
307 }
308
309 void
310 cleanup_client (struct client_s *client)
311 {
312 assuan_context_t ctx = client->ctx;
313 struct client_thread_s *thd = client->thd;
314 struct crypto_s *crypto = client->crypto;
315 long lock_timeout = client->lock_timeout;
316 int no_pinentry = (client->flags & FLAG_NO_PINENTRY);
317 struct pinentry_option_s pin_opts;
318 xmlErrorPtr xml_error = client->xml_error;
319 int flock_fd = client->flock_fd;
320 #ifdef WITH_AGENT
321 struct pinentry_option_s agent_pin_opts;
322
323 if (crypto && crypto->agent)
324 memcpy (&agent_pin_opts, &crypto->agent->pinentry_opts,
325 sizeof(struct pinentry_option_s));
326 #endif
327
328 memcpy (&pin_opts, &client->pinentry_opts, sizeof(struct pinentry_option_s));
329 unlock_file_mutex (client, client->flags & FLAG_NEW);
330 free_client (client);
331 memset (client, 0, sizeof (struct client_s));
332 client->flock_fd = flock_fd;
333 client->xml_error = xml_error;
334 client->crypto = crypto;
335 client->ctx = ctx;
336 client->thd = thd;
337 client->lock_timeout = lock_timeout;
338 memcpy (&client->pinentry_opts, &pin_opts, sizeof(struct pinentry_option_s));
339 client->flags |= no_pinentry ? FLAG_NO_PINENTRY : 0;
340 #ifdef WITH_AGENT
341 if (crypto && crypto->agent)
342 memcpy (&crypto->agent->pinentry_opts, &agent_pin_opts,
343 sizeof(struct pinentry_option_s));
344 #endif
345 }
346
347 static gpg_error_t
348 open_finalize (assuan_context_t ctx, char *key, size_t keylen)
349 {
350 struct client_s *client = assuan_get_pointer (ctx);
351 gpg_error_t rc = 0;
352 struct cache_data_s *cdata = cache_get_data (client->md5file);
353 int cached = 0, keyarg = key ? 1 : 0;
354 size_t keysize;
355 unsigned char *salted_key = NULL;
356 int algo;
357 int pin_try = 1;
358 int pin_tries = 3;
359 char *pin_title = client->pinentry_opts.title;
360
361 client->crypto->filename = str_dup (client->filename);
362 if (cdata || client->flags & FLAG_NEW)
363 {
364 if (cdata && !(client->flags & FLAG_NEW))
365 {
366 rc = decrypt_cache (client->crypto, cdata->doc, cdata->doclen);
367 if (rc)
368 return rc;
369 }
370
371 cached = cdata != NULL;
372 goto done;
373 }
374
375 if (!key && !IS_PKI (client->crypto)
376 && !(client->crypto->hdr.flags & PWMD_FLAG_NO_PASSPHRASE))
377 {
378 if (client->flags & FLAG_NO_PINENTRY)
379 {
380 rc = inquire_passphrase (ctx, "PASSPHRASE", (unsigned char **)&key,
381 &keylen);
382 if (rc)
383 return rc;
384 }
385 else
386 {
387 client->pinentry_opts.timeout = config_get_integer (client->filename,
388 "pinentry_timeout");
389 pin_again:
390 rc = getpin_common (client->ctx, client->filename, PINENTRY_OPEN,
391 &key, &keylen);
392 if (rc)
393 return rc;
394 }
395 }
396
397 if (!IS_PKI (client->crypto))
398 {
399 if (client->crypto->hdr.flags & PWMD_FLAG_NO_PASSPHRASE)
400 {
401 keylen = 1;
402 key = gcry_malloc (keylen);
403 memset (key, 0, keylen);
404 }
405
406 algo = cipher_to_gcrypt (client->crypto->hdr.flags);
407 rc = hash_key (algo, client->crypto->hdr.salt,
408 sizeof(client->crypto->hdr.salt), key, keylen,
409 (void **)&salted_key, &keysize,
410 client->crypto->hdr.version <= 0x03000e ? COMPAT_KDFS2K_ITERATIONS : client->crypto->hdr.s2k_count);
411 if (!keyarg)
412 gcry_free (key);
413
414 if (!rc)
415 {
416 rc = decrypt_data (client->ctx, client->crypto, salted_key, keysize);
417 if (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
418 && ++pin_try <= pin_tries && !(client->flags & FLAG_NO_PINENTRY))
419 {
420 gcry_free (salted_key);
421 salted_key = NULL;
422 key = NULL;
423 keylen = 0;
424 client->pinentry_opts.title = str_asprintf (_ ("Bad passphrase (try %i of %i)"), pin_try, pin_tries);
425 goto pin_again;
426 }
427 }
428
429 if (client->pinentry_opts.title != pin_title)
430 xfree (client->pinentry_opts.title);
431
432 client->pinentry_opts.title = pin_title;
433 if (rc)
434 {
435 gcry_free (salted_key);
436 return rc;
437 }
438
439 cdata = xcalloc (1, sizeof (struct cache_data_s));
440 if (!cdata)
441 {
442 gcry_free (salted_key);
443 return GPG_ERR_ENOMEM;
444 }
445
446 cdata->key = salted_key;
447 cdata->keylen = keysize;
448 }
449 else
450 #ifdef WITH_AGENT
451 rc = decrypt_data (client->ctx, client->crypto, NULL, 0);
452 #else
453 rc = GPG_ERR_NOT_IMPLEMENTED;
454 #endif
455
456 done:
457 if (!rc)
458 {
459 rc = parse_xml (ctx, client->flags & FLAG_NEW);
460 if (rc && !cached)
461 free_cache_data_once (cdata);
462
463 if (!rc)
464 {
465 int timeout = config_get_integer (client->filename,
466 "cache_timeout");
467
468 if (!cached)
469 {
470 if (!cdata)
471 cdata = xcalloc (1, sizeof (struct cache_data_s));
472
473 rc = encrypt_xml (NULL, cache_key, cache_keysize,
474 GCRY_CIPHER_AES, client->crypto->plaintext,
475 client->crypto->plaintext_len, &cdata->doc,
476 &cdata->doclen, &cache_iv, &cache_blocksize);
477 if (!rc && !(client->flags & FLAG_NEW) && IS_PKI (client->crypto))
478 {
479 rc = gcry_sexp_build ((gcry_sexp_t *) & cdata->pubkey, NULL,
480 "%S", client->crypto->pkey_sexp);
481 }
482 }
483
484 if (cdata->sigkey)
485 gcry_sexp_release (cdata->sigkey);
486
487 cdata->sigkey = NULL;
488 if (!rc && IS_PKI (client->crypto))
489 rc = gcry_sexp_build ((gcry_sexp_t *) &cdata->sigkey, NULL,
490 "%S", client->crypto->sigpkey_sexp);
491
492 if (!rc)
493 {
494 rc = cache_add_file (client->md5file,
495 (client->flags & FLAG_NEW) ? NULL
496 : client->crypto->grip, cdata, timeout);
497 if (rc)
498 {
499 if (!cached)
500 {
501 free_cache_data_once (cdata);
502 xmlFreeDoc (client->doc);
503 client->doc = NULL;
504 }
505 }
506 }
507
508 if (!rc)
509 client->flags |= FLAG_OPEN;
510 }
511 }
512
513 if (!rc)
514 {
515 rc = update_checksum (client);
516 if (gpg_err_code (rc) == GPG_ERR_ENOENT)
517 rc = 0;
518 }
519
520 if (!rc && (client->opts & OPT_LOCK_ON_OPEN))
521 rc = do_lock (client, 0);
522
523 return rc;
524 }
525
526 static void
527 req_cleanup (void *arg)
528 {
529 if (!arg)
530 return;
531
532 strv_free ((char **) arg);
533 }
534
535 static gpg_error_t
536 parse_open_opt_lock (void *data, void *value)
537 {
538 struct client_s *client = data;
539
540 client->opts |= OPT_LOCK_ON_OPEN;
541 return 0;
542 }
543
544 static gpg_error_t
545 parse_save_opt_inquire (void *data, void *value)
546 {
547 struct client_s *client = data;
548 gpg_error_t rc;
549
550 if (!(client->flags & FLAG_NEW))
551 {
552 rc = peer_is_invoker (client);
553 if (rc == GPG_ERR_EACCES)
554 return rc;
555 }
556
557 (void) value;
558 client->opts |= OPT_INQUIRE;
559 return 0;
560 }
561
562 static gpg_error_t
563 parse_opt_inquire (void *data, void *value)
564 {
565 struct client_s *client = data;
566
567 (void) value;
568 client->opts |= OPT_INQUIRE;
569 return 0;
570 }
571
572 static gpg_error_t
573 update_checksum (struct client_s *client)
574 {
575 unsigned char *crc;
576 size_t len;
577 struct cache_data_s *cdata;
578 gpg_error_t rc = get_checksum (client->filename, &crc, &len);
579
580 if (rc)
581 return rc;
582
583 xfree (client->crc);
584 client->crc = crc;
585 cdata = cache_get_data (client->md5file);
586 if (cdata)
587 {
588 xfree (cdata->crc);
589 cdata->crc = xmalloc (len);
590 memcpy (cdata->crc, crc, len);
591 }
592
593 return 0;
594 }
595
596 static gpg_error_t
597 validate_checksum (struct client_s *client, struct cache_data_s *cdata)
598 {
599 unsigned char *crc;
600 size_t len;
601 gpg_error_t rc;
602 int n = 0;
603
604 if (cdata && !cdata->crc)
605 return GPG_ERR_CHECKSUM;
606
607 rc = get_checksum (client->filename, &crc, &len);
608 if (rc)
609 return rc;
610
611 if (cdata)
612 n = memcmp (cdata->crc, crc, len);
613 else if (client->crc)
614 n = memcmp (client->crc, crc, len);
615
616 xfree (crc);
617 return n ? GPG_ERR_CHECKSUM : 0;
618 }
619
620 static gpg_error_t
621 do_open (assuan_context_t ctx, const char *password)
622 {
623 struct client_s *client = assuan_get_pointer (ctx);
624 struct cache_data_s *cdata;
625 gpg_error_t rc = 0;
626 int done = 0;
627
628 // Cached document?
629 cdata = cache_get_data (client->md5file);
630 if (cdata && cdata->doc)
631 {
632 int defer = 0;
633
634 /* This will check that the key is cached in the agent which needs to
635 * be determined for files that share a keygrip. */
636 if (!rc)
637 {
638 rc = cache_iscached (client->filename, &defer);
639 if ((!rc || rc == GPG_ERR_ENOENT) && defer)
640 rc = GPG_ERR_KEY_EXPIRED;
641 }
642
643 if (!rc && !(client->flags & FLAG_NEW))
644 rc = validate_checksum (client, cdata);
645
646 #ifdef WITH_GNUTLS
647 if (!rc && client->thd->remote
648 && config_get_boolean (client->filename, "tcp_require_key"))
649 rc = GPG_ERR_KEY_EXPIRED;
650 #endif
651
652 if (!rc && !password)
653 {
654 rc = read_data_header (client->filename, &client->crypto->hdr,
655 NULL, NULL);
656 if (!rc)
657 {
658 if (IS_PKI (client->crypto))
659 {
660 gcry_sexp_build (&client->crypto->pkey_sexp, NULL, "%S",
661 cdata->pubkey);
662 gcry_pk_get_keygrip (client->crypto->pkey_sexp,
663 client->crypto->grip);
664 gcry_sexp_build (&client->crypto->sigpkey_sexp, NULL, "%S",
665 cdata->sigkey);
666 gcry_pk_get_keygrip (client->crypto->sigpkey_sexp,
667 client->crypto->sign_grip);
668 }
669
670 if (!rc)
671 {
672 rc = open_finalize (ctx, NULL, 0);
673 done = 1;
674 }
675 }
676 }
677
678 /* There was an error accessing the file so clear the cache entry. The
679 * real error will be returned from read_data_file() since the file
680 * may have only disappeared. */
681 if (!done)
682 {
683 log_write ("%s: %s", client->filename, pwmd_strerror (rc));
684 rc = cache_clear (client->md5file);
685 send_status_all (STATUS_CACHE, NULL);
686 }
687 }
688
689 if (done || rc)
690 return rc;
691
692 rc = read_data_file (client->filename, client->crypto);
693 if (rc)
694 {
695 if (gpg_err_source (rc) != GPG_ERR_SOURCE_DEFAULT ||
696 gpg_err_code (rc) != GPG_ERR_ENOENT)
697 {
698 log_write ("%s: %s", client->filename, pwmd_strerror (rc));
699 return rc;
700 }
701
702 client->flags |= FLAG_NEW;
703 memset (client->crypto->grip, 0, sizeof (client->crypto->grip));
704 memset (client->crypto->sign_grip, 0,
705 sizeof (client->crypto->sign_grip));
706 rc = open_finalize (ctx, NULL, 0);
707 return rc;
708 }
709
710 if (password && IS_PKI (client->crypto))
711 {
712 #ifdef WITH_AGENT
713 rc = set_agent_passphrase (client->crypto, password, strlen (password));
714 if (rc)
715 return rc;
716 #endif
717 }
718
719 rc = open_finalize (ctx, (char *)password, password ? strlen (password) : 0);
720 return rc;
721 }
722
723 static gpg_error_t
724 open_command (assuan_context_t ctx, char *line)
725 {
726 gpg_error_t rc;
727 struct client_s *client = assuan_get_pointer (ctx);
728 char **req, *filename;
729 unsigned char md5file[16];
730 int same_file = 0;
731 assuan_peercred_t peer;
732 struct argv_s *args[] = {
733 &(struct argv_s) {"lock", OPTION_TYPE_NOARG, parse_open_opt_lock},
734 NULL
735 };
736
737 rc = parse_options (&line, args, client, 1);
738 if (rc)
739 return send_error (ctx, rc);
740
741 req = str_split (line, " ", 2);
742 if (!req)
743 return send_error (ctx, GPG_ERR_SYNTAX);
744
745 rc = do_validate_peer (ctx, req[0], &peer);
746 if (rc)
747 {
748 strv_free (req);
749 return send_error (ctx, rc);
750 }
751
752 filename = req[0];
753 if (!valid_filename (filename))
754 {
755 strv_free (req);
756 return send_error (ctx, GPG_ERR_INV_VALUE);
757 }
758
759 pthread_cleanup_push (req_cleanup, req);
760 gcry_md_hash_buffer (GCRY_MD_MD5, md5file, filename, strlen (filename));
761 /* This client may have locked a different file with ISCACHED --lock than
762 * the current filename. This will remove that lock. */
763 same_file = !memcmp (md5file, client->md5file, 16) ? 1 : 0;
764 if (client->flags & FLAG_OPEN ||
765 (client->flags & FLAG_HAS_LOCK && !same_file))
766 {
767 uint32_t opts = client->opts;
768 uint32_t flags = client->flags;
769
770 if (same_file)
771 client->flags |= FLAG_KEEP_LOCK;
772 else if (client->flags & FLAG_NEW)
773 cache_clear (client->md5file);
774
775 cleanup_client (client);
776 client->opts = opts;
777 client->flags |= flags;
778 client->flags &= ~(FLAG_LOCK_CMD);
779 if (!same_file)
780 client->flags &= ~(FLAG_HAS_LOCK | FLAG_NEW);
781 }
782
783 /* Need to lock the mutex here because file_modified() cannot without
784 * knowing the filename. */
785 memcpy (client->md5file, md5file, 16);
786 rc = lock_file_mutex (client, 1);
787 if (rc)
788 client->flags &= ~FLAG_OPEN;
789
790 if (!rc)
791 {
792 rc = lock_flock (ctx, filename, LOCK_SH, &client->flock_fd);
793 if (!rc || gpg_err_code (rc) == GPG_ERR_ENOENT)
794 {
795 rc = 0;
796 client->filename = str_dup (filename);
797 if (!client->filename)
798 rc = GPG_ERR_ENOMEM;
799 }
800 }
801
802 if (!rc)
803 {
804 char *password = req[1] && *req[1] ? req[1] : NULL;
805
806 #ifdef WITH_AGENT
807 if (IS_PKI (client->crypto))
808 rc = set_pinentry_mode (client->crypto->agent,
809 (client->flags & FLAG_NO_PINENTRY) ? "loopback"
810 : "ask");
811 #endif
812 if (!rc)
813 {
814 rc = do_open (ctx, password);
815 if (rc)
816 cleanup_client (client);
817
818 cleanup_crypto_stage1 (client->crypto);
819 }
820 }
821
822 pthread_cleanup_pop (1);
823
824 if (!rc && client->flags & FLAG_NEW)
825 rc = send_status (ctx, STATUS_NEWFILE, NULL);
826
827 #ifdef WITH_AGENT
828 (void) kill_scd (client->crypto->agent);
829 #endif
830
831 return send_error (ctx, rc);
832 }
833
834 static gpg_error_t
835 parse_opt_no_passphrase (void *data, void *value)
836 {
837 struct client_s *client = data;
838
839 (void) value;
840 client->opts |= OPT_NO_PASSPHRASE;
841 return 0;
842 }
843
844 static gpg_error_t
845 parse_save_opt_no_agent (void *data, void *value)
846 {
847 struct client_s *client = data;
848
849 client->opts |= OPT_NO_AGENT;
850 return 0;
851 }
852
853 static gpg_error_t
854 parse_save_opt_cipher (void *data, void *value)
855 {
856 struct client_s *client = data;
857 int algo = cipher_string_to_gcrypt ((char *) value);
858 file_header_t *hdr = &client->crypto->save.hdr;
859 gpg_error_t rc = 0;
860
861 if (algo == -1)
862 return GPG_ERR_INV_VALUE;
863
864 if (!(client->flags & FLAG_NEW))
865 {
866 rc = peer_is_invoker (client);
867 if (rc == GPG_ERR_EACCES)
868 {
869 uint64_t flags = 0;
870
871 flags &= ((uint16_t) ((uint32_t) (flags & 0xFFFFFFFF)));
872 if (!(client->crypto->hdr.flags & gcrypt_to_cipher (algo)))
873 return rc;
874
875 rc = 0;
876 }
877 else if (rc)
878 return rc;
879 }
880
881 if (!rc)
882 hdr->flags = set_cipher_flag (hdr->flags, algo);
883
884 return rc;
885 }
886
887 #ifdef WITH_AGENT
888 static gpg_error_t
889 permitted_to_save (struct client_s *client, const unsigned char *grip,
890 size_t size, const char *value)
891 {
892 char *hexgrip;
893 gpg_error_t rc = 0;
894
895 if (!(client->flags & FLAG_NEW))
896 {
897 hexgrip = bin2hex (grip, size);
898 rc = !strcmp (hexgrip, (char *)value) ? 0 : GPG_ERR_EACCES;
899 xfree (hexgrip);
900 if (rc)
901 rc = peer_is_invoker (client);
902 }
903
904 return rc;
905 }
906 #endif
907
908 static gpg_error_t
909 parse_save_opt_keygrip (void *data, void *value)
910 {
911 #ifdef WITH_AGENT
912 struct client_s *client = data;
913 gpg_error_t rc = permitted_to_save (client, client->crypto->grip,
914 sizeof (client->crypto->grip),
915 value);
916
917 if (!IS_PKI (client->crypto))
918 return GPG_ERR_INV_ARG;
919
920 if (rc)
921 return rc;
922
923 if (client->crypto->save.pkey)
924 gcry_sexp_release (client->crypto->save.pkey);
925
926 client->crypto->save.pkey = NULL;
927 return get_pubkey (client->crypto, value, &client->crypto->save.pkey);
928 #else
929 return GPG_ERR_INV_ARG;
930 #endif
931 }
932
933 static gpg_error_t
934 parse_save_opt_sign_keygrip (void *data, void *value)
935 {
936 #ifdef WITH_AGENT
937 struct client_s *client = data;
938 gpg_error_t rc = permitted_to_save (client, client->crypto->sign_grip,
939 sizeof (client->crypto->sign_grip),
940 value);
941
942 if (!IS_PKI (client->crypto))
943 return GPG_ERR_INV_ARG;
944
945 if (rc)
946 return rc;
947
948 if (client->crypto->save.sigpkey)
949 gcry_sexp_release (client->crypto->save.sigpkey);
950
951 client->crypto->save.sigpkey = NULL;
952 return get_pubkey (client->crypto, value, &client->crypto->save.sigpkey);
953 #else
954 return GPG_ERR_INV_ARG;
955 #endif
956 }
957
958 static gpg_error_t
959 parse_opt_s2k_count (void *data, void *value)
960 {
961 struct client_s *client = data;
962 char *v = value, *p;
963 uint64_t n;
964
965 if (!v || !*v)
966 return GPG_ERR_INV_VALUE;
967
968 errno = 0;
969 n = strtoull (v, &p, 10);
970 if (n == UINT64_MAX && errno)
971 return gpg_error_from_errno (errno);
972 else if (p && *p)
973 return GPG_ERR_INV_VALUE;
974
975 if (!(client->flags & FLAG_NEW))
976 {
977 gpg_error_t rc = peer_is_invoker (client);
978
979 if (rc == GPG_ERR_EACCES)
980 {
981 if (n && client->crypto->hdr.s2k_count != n)
982 return rc;
983
984 rc = 0;
985 }
986 else if (rc)
987 return rc;
988 }
989
990 // Keep compatibility with libpwmd passing --s2k-count=0. If somehow
991 // s2k_count == 0 it will be set to DEFAULT_KDFS2K_ITERATIONS in
992 // save_command().
993 if (n)
994 client->crypto->save.hdr.s2k_count = n;
995
996 return 0;
997 }
998
999 static gpg_error_t
1000 save_finalize (assuan_context_t ctx)
1001 {
1002 struct client_s *client = assuan_get_pointer (ctx);
1003 gpg_error_t rc = 0;
1004 xmlChar *xmlbuf = NULL;
1005 int xmlbuflen;
1006 void *key = NULL;
1007 size_t keylen = 0;
1008
1009 xmlDocDumpFormatMemory (client->doc, &xmlbuf, &xmlbuflen, 0);
1010 if (!xmlbuf)
1011 return GPG_ERR_ENOMEM;
1012
1013 pthread_cleanup_push (xmlFree, xmlbuf);
1014
1015 if (!use_agent || ((client->flags & FLAG_NEW)
1016 && (client->opts & OPT_NO_AGENT))
1017 || !(client->crypto->hdr.flags & PWMD_FLAG_PKI))
1018 {
1019 rc = export_common (ctx, client->flags & FLAG_NO_PINENTRY,
1020 client->crypto, xmlbuf, xmlbuflen, client->filename,
1021 NULL, &key, &keylen, 1, 1,
1022 (client->opts & OPT_NO_PASSPHRASE));
1023 }
1024 #ifdef WITH_AGENT
1025 else
1026 {
1027 gcry_sexp_t pubkey = client->crypto->save.pkey;
1028 gcry_sexp_t sigkey = client->crypto->save.sigpkey;
1029
1030 if (!pubkey)
1031 pubkey = client->crypto->pkey_sexp;
1032
1033 if (!sigkey)
1034 {
1035 sigkey = client->crypto->sigpkey_sexp;
1036 if (!sigkey)
1037 {
1038 gcry_sexp_build (&client->crypto->save.sigpkey, 0, "%S", pubkey);
1039 sigkey = client->crypto->save.sigpkey;
1040 }
1041 }
1042
1043 rc = encrypt_data_file (client->ctx, client->crypto, pubkey, sigkey,
1044 client->filename, xmlbuf, xmlbuflen);
1045 if (pubkey == client->crypto->save.pkey)
1046 {
1047 if (!rc)
1048 {
1049 gcry_sexp_release (client->crypto->pkey_sexp);
1050 client->crypto->pkey_sexp = client->crypto->save.pkey;
1051 gcry_pk_get_keygrip (client->crypto->pkey_sexp,
1052 client->crypto->grip);
1053 }
1054 else
1055 gcry_sexp_release (pubkey);
1056
1057 client->crypto->save.pkey = NULL;
1058 }
1059
1060 if (!rc)
1061 gcry_pk_get_keygrip (sigkey, client->crypto->sign_grip);
1062
1063 if (sigkey == client->crypto->save.sigpkey)
1064 {
1065 if (!rc)
1066 {
1067 if (client->crypto->sigpkey_sexp)
1068 gcry_sexp_release (client->crypto->sigpkey_sexp);
1069
1070 client->crypto->sigpkey_sexp = client->crypto->save.sigpkey;
1071 gcry_pk_get_keygrip (client->crypto->sigpkey_sexp,
1072 client->crypto->sign_grip);
1073 }
1074 else
1075 gcry_sexp_release (sigkey);
1076
1077 client->crypto->save.sigpkey = NULL;
1078 }
1079 }
1080 #endif
1081
1082 if (!rc)
1083 {
1084 int cached;
1085
1086 rc = save_common (client->filename, client->crypto, xmlbuf, xmlbuflen,
1087 key, keylen, &cached, client->opts & OPT_NO_AGENT);
1088 gcry_free (key);
1089
1090 if (!rc && (!cached || (client->flags & FLAG_NEW)))
1091 send_status_all (STATUS_CACHE, NULL);
1092
1093 if (!rc)
1094 {
1095 rc = update_checksum (client);
1096 client->flags &= ~(FLAG_NEW);
1097 }
1098 }
1099
1100 pthread_cleanup_pop (1); // xmlFree
1101 return rc;
1102 }
1103
1104 static gpg_error_t
1105 parse_opt_reset (void *data, void *value)
1106 {
1107 struct client_s *client = data;
1108
1109 (void) value;
1110 client->opts |= OPT_RESET;
1111 return 0;
1112 }
1113
1114 static gpg_error_t
1115 parse_opt_ask (void *data, void *value)
1116 {
1117 struct client_s *client = data;
1118
1119 (void) value;
1120 client->opts |= OPT_ASK;
1121 return 0;
1122 }
1123
1124 static gpg_error_t
1125 save_command (assuan_context_t ctx, char *line)
1126 {
1127 struct client_s *client = assuan_get_pointer (ctx);
1128 gpg_error_t rc;
1129 struct stat st;
1130 struct argv_s *args[] = {
1131 &(struct argv_s) {"no-passphrase", OPTION_TYPE_NOARG,
1132 parse_opt_no_passphrase},
1133 &(struct argv_s) {"cipher", OPTION_TYPE_ARG, parse_save_opt_cipher},
1134 &(struct argv_s) {"inquire-keyparam", OPTION_TYPE_NOARG,
1135 parse_save_opt_inquire},
1136 &(struct argv_s) {"keygrip", OPTION_TYPE_ARG, parse_save_opt_keygrip},
1137 &(struct argv_s) {"sign-keygrip", OPTION_TYPE_ARG,
1138 parse_save_opt_sign_keygrip},
1139 &(struct argv_s) {"s2k-count", OPTION_TYPE_ARG, parse_opt_s2k_count},
1140 &(struct argv_s) {"reset", OPTION_TYPE_NOARG, parse_opt_reset},
1141 &(struct argv_s) {"cipher-iterations", OPTION_TYPE_ARG,
1142 parse_opt_s2k_count},
1143 &(struct argv_s) {"no-agent", OPTION_TYPE_NOARG,
1144 parse_save_opt_no_agent},
1145 &(struct argv_s) {"ask", OPTION_TYPE_NOARG,
1146 parse_opt_ask},
1147 NULL
1148 };
1149
1150 cleanup_save (&client->crypto->save);
1151 memcpy (&client->crypto->save.hdr, &client->crypto->hdr,
1152 sizeof (file_header_t));
1153
1154 rc = parse_options (&line, args, client, 0);
1155 if (rc)
1156 return send_error (ctx, rc);
1157
1158 if (!(client->flags & FLAG_NEW))
1159 client->opts &= ~OPT_NO_AGENT;
1160 else if (client->opts & OPT_NO_AGENT)
1161 {
1162 client->crypto->save.hdr.flags &= ~PWMD_FLAG_PKI;
1163 client->crypto->hdr.flags &= ~PWMD_FLAG_PKI;
1164 }
1165
1166 /* Update to the default hash iteration count for data file
1167 * versions <= 3.0.14. */
1168 #ifdef WITH_AGENT
1169 if ((!IS_PKI (client->crypto) && client->crypto->hdr.version <= 0x03000e
1170 && client->crypto->save.hdr.s2k_count < DEFAULT_KDFS2K_ITERATIONS)
1171 || (!IS_PKI (client->crypto) && !client->crypto->save.hdr.s2k_count))
1172 #else
1173 if ((client->crypto->hdr.version <= 0x03000e
1174 && client->crypto->save.hdr.s2k_count < DEFAULT_KDFS2K_ITERATIONS)
1175 || !client->crypto->save.hdr.s2k_count)
1176 #endif
1177 {
1178 client->crypto->save.hdr.s2k_count =
1179 config_get_ulonglong (client->filename, "s2k_count");
1180 if (!client->crypto->save.hdr.s2k_count)
1181 client->crypto->save.hdr.s2k_count = DEFAULT_KDFS2K_ITERATIONS;
1182 }
1183
1184 /* Deal with the hashed vs non-hashed cached key mess by clearing the cached
1185 * key entry. */
1186 if (client->crypto->hdr.version <= 0x03000e && !IS_PKI (client->crypto))
1187 client->opts |= OPT_RESET;
1188 else if (!IS_PKI (client->crypto) && !(client->flags & FLAG_NEW)
1189 && client->crypto->hdr.s2k_count !=
1190 client->crypto->save.hdr.s2k_count)
1191 client->opts |= OPT_RESET;
1192
1193 if ((client->opts & OPT_NO_PASSPHRASE) && !(client->flags & FLAG_NEW)
1194 && !(client->opts & OPT_INQUIRE))
1195 return send_error (ctx, GPG_ERR_WRONG_KEY_USAGE);
1196
1197 if (lstat (client->filename, &st) == -1 && errno != ENOENT)
1198 return send_error (ctx, gpg_error_from_errno (errno));
1199
1200 if (errno != ENOENT && !S_ISREG (st.st_mode))
1201 {
1202 log_write ("%s: %s", client->filename, pwmd_strerror (GPG_ERR_ENOANO));
1203 return send_error (ctx, GPG_ERR_ENOANO);
1204 }
1205
1206 int defer = 0;
1207 rc = cache_iscached (client->filename, &defer);
1208 if (gpg_err_code (rc) == GPG_ERR_ENOENT && client->flags & FLAG_NEW)
1209 rc = 0;
1210 else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
1211 rc = 0;
1212
1213 if ((!rc && defer))
1214 client->opts |= OPT_RESET;
1215 else if (config_get_boolean ("global", "require_save_key"))
1216 client->opts |= OPT_ASK;
1217
1218 if (!rc && (client->opts & OPT_RESET))
1219 {
1220 rc = cache_clear (client->md5file);
1221 if (rc)
1222 return send_error (ctx, rc);
1223
1224 log_write ("%s: %s", client->filename,
1225 pwmd_strerror (GPG_ERR_KEY_EXPIRED));
1226 send_status_all (STATUS_CACHE, NULL);
1227 }
1228
1229 if (!rc && client->opts & OPT_ASK)
1230 rc = crypto_try_decrypt (ctx, client->flags & FLAG_NO_PINENTRY,
1231 client->filename, NULL, NULL, NULL);
1232
1233 if (!rc)
1234 rc = update_element_mtime (client, xmlDocGetRootElement (client->doc));
1235
1236 if (rc)
1237 return send_error (ctx, rc);
1238
1239 #ifdef WITH_AGENT
1240 if (!rc && use_agent && !client->crypto->save.pkey &&
1241 (client->flags & FLAG_NEW || client->opts & OPT_INQUIRE)
1242 && !(client->opts & OPT_NO_AGENT))
1243 {
1244 rc = set_pinentry_mode (client->crypto->agent,
1245 (client->flags & FLAG_NO_PINENTRY) ? "loopback"
1246 : "ask");
1247
1248 if (!(client->flags & FLAG_NEW))
1249 {
1250 struct crypto_s *crypto;
1251 void *key = NULL;
1252 size_t keylen = 0;
1253
1254 /* Wanting to generate a new key. Require the key to open the
1255 current file before proceeding reguardless of the
1256 require_save_key configuration parameter. */
1257 rc = cache_clear (client->md5file);
1258 if (!rc)
1259 {
1260 rc = init_client_crypto (&crypto);
1261 if (!rc)
1262 crypto->client_ctx = client->ctx;
1263 }
1264
1265 if (!rc)
1266 rc = decrypt_common (client->ctx, client->opts&OPT_INQUIRE, crypto,
1267 client->filename, &key, &keylen, NULL, NULL);
1268
1269 xfree (key);
1270 cleanup_crypto (&crypto);
1271 }
1272
1273 if (!rc)
1274 rc = send_status (client->ctx, STATUS_GENKEY, NULL);
1275
1276 if (!rc)
1277 {
1278 struct inquire_data_s idata = { 0 };
1279 char *params = client->opts & OPT_INQUIRE
1280 ? NULL : default_key_params (client->crypto);
1281
1282 pthread_cleanup_push (xfree, params);
1283 idata.crypto = client->crypto;
1284
1285 if (params)
1286 {
1287 idata.line = params;
1288 idata.len = strlen (params);
1289 }
1290 else
1291 idata.preset = 1;
1292
1293 client->crypto->agent->inquire_data = &idata;
1294 client->crypto->agent->inquire_cb = NULL;
1295 rc = generate_key (client->crypto, params,
1296 (client->opts & OPT_NO_PASSPHRASE), 1);
1297 pthread_cleanup_pop (1);
1298 }
1299 }
1300 #endif
1301
1302 if (!rc)
1303 rc = save_finalize (ctx);
1304
1305 cleanup_crypto_stage1 (client->crypto);
1306 #ifdef WITH_AGENT
1307 (void) kill_scd (client->crypto->agent);
1308 #endif
1309 return send_error (ctx, rc);
1310 }
1311
1312 static gpg_error_t
1313 do_delete (assuan_context_t ctx, char *line)
1314 {
1315 struct client_s *client = assuan_get_pointer (ctx);
1316 gpg_error_t rc;
1317 char **req;
1318 xmlNodePtr n;
1319
1320 if (strchr (line, '\t'))
1321 req = str_split (line, "\t", 0);
1322 else
1323 req = str_split (line, " ", 0);
1324
1325 if (!req || !*req)
1326 return GPG_ERR_SYNTAX;
1327
1328 n = find_root_element (client, client->doc, &req, &rc, NULL, 0, 0);
1329 if (!n || rc)
1330 {
1331 strv_free (req);
1332 return rc;
1333 }
1334
1335 /*
1336 * No sub-node defined. Remove the entire node (root element).
1337 */
1338 if (!req[1])
1339 {
1340 if (n)
1341 {
1342 rc = is_element_owner (client, n);
1343 if (!rc)
1344 {
1345 rc = unlink_node (client, n);
1346 xmlFreeNode (n);
1347 }
1348 }
1349
1350 strv_free (req);
1351 return rc;
1352 }
1353
1354 n = find_elements (client, client->doc, n->children, req + 1, &rc, NULL,
1355 NULL, NULL, 0, 0, NULL, 0);
1356 strv_free (req);
1357 if (!n || rc)
1358 return rc;
1359
1360 rc = is_element_owner (client, n);
1361 if (!rc)
1362 {
1363 rc = unlink_node (client, n);
1364 xmlFreeNode (n);
1365 }
1366
1367 return rc;
1368 }
1369
1370 static gpg_error_t
1371 delete_command (assuan_context_t ctx, char *line)
1372 {
1373 struct client_s *client = assuan_get_pointer (ctx);
1374 gpg_error_t rc;
1375 struct argv_s *args[] = {
1376 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
1377 NULL
1378 };
1379
1380 rc = parse_options (&line, args, client, 1);
1381 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
1382 rc = GPG_ERR_SYNTAX;
1383 if (rc)
1384 return send_error (ctx, rc);
1385
1386 if (client->opts & OPT_INQUIRE)
1387 {
1388 unsigned char *result;
1389 size_t len;
1390
1391 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
1392 if (rc)
1393 return send_error (ctx, rc);
1394
1395 pthread_cleanup_push (xfree, result);
1396 rc = do_delete (ctx, (char *)result);
1397 pthread_cleanup_pop (1);
1398 }
1399 else
1400 rc = do_delete (ctx, line);
1401
1402 return send_error (ctx, rc);
1403 }
1404
1405 static gpg_error_t
1406 store_command (assuan_context_t ctx, char *line)
1407 {
1408 struct client_s *client = assuan_get_pointer (ctx);
1409 gpg_error_t rc;
1410 size_t len;
1411 unsigned char *result;
1412 char **req;
1413 xmlNodePtr n, parent;
1414 int has_content;
1415 char *content = NULL;
1416
1417 if (line && *line)
1418 return send_error (ctx, GPG_ERR_SYNTAX);
1419
1420 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
1421 if (rc)
1422 return send_error (ctx, rc);
1423
1424 req = str_split ((char *) result, "\t", 0);
1425 xfree (result);
1426
1427 if (!req || !*req)
1428 return send_error (ctx, GPG_ERR_SYNTAX);
1429
1430 len = strv_length (req);
1431 has_content = line[strlen (line) - 1] != '\t' && len > 1;
1432 if (*(req + 1) && !valid_element_path (req, has_content))
1433 {
1434 strv_free (req);
1435 return send_error (ctx, GPG_ERR_INV_VALUE);
1436 }
1437
1438 if (has_content || !*req[len - 1])
1439 {
1440 has_content = 1;
1441 content = req[len - 1];
1442 req[len - 1] = NULL;
1443 }
1444
1445 again:
1446 n = find_root_element (client, client->doc, &req, &rc, NULL, 0, 0);
1447 if (rc && rc == GPG_ERR_ELEMENT_NOT_FOUND)
1448 {
1449 rc = new_root_element (client, client->doc, *req);
1450 if (rc)
1451 {
1452 strv_free (req);
1453 return send_error (ctx, rc);
1454 }
1455
1456 goto again;
1457 }
1458
1459 if (!n || rc)
1460 {
1461 strv_free (req);
1462 return send_error (ctx, rc);
1463 }
1464
1465 parent = n;
1466
1467 if (req[1] && *req[1])
1468 {
1469 if (!n->children)
1470 parent = create_elements_cb (client, 1, n, req + 1, &rc, NULL);
1471 else
1472 parent = find_elements (client, client->doc, n->children, req + 1, &rc,
1473 NULL, NULL, create_elements_cb, 0, 0, NULL,
1474 0);
1475 }
1476
1477 if (!rc && len > 1)
1478 {
1479 rc = is_element_owner (client, parent);
1480 if (!rc)
1481 {
1482 n = find_text_node (parent->children);
1483 if (n)
1484 xmlNodeSetContent (n, (xmlChar *) content);
1485 else
1486 xmlNodeAddContent (parent, (xmlChar *) content);
1487
1488 update_element_mtime (client, parent);
1489 }
1490 }
1491
1492 xfree (content);
1493 strv_free (req);
1494 return send_error (ctx, rc);
1495 }
1496
1497 static gpg_error_t
1498 xfer_data (assuan_context_t ctx, const char *line, int total)
1499 {
1500 int to_send;
1501 int sent = 0;
1502 gpg_error_t rc;
1503 int progress = config_get_integer ("global", "xfer_progress");
1504 int flush = 0;
1505
1506 progress =
1507 progress > 0 ? (progress / ASSUAN_LINELENGTH) * ASSUAN_LINELENGTH : 0;
1508 to_send = total < ASSUAN_LINELENGTH ? total : ASSUAN_LINELENGTH;
1509 rc = send_status (ctx, STATUS_XFER, "%li %li", sent, total);
1510
1511 if (rc)
1512 return rc;
1513
1514 again:
1515 do
1516 {
1517 if (sent + to_send > total)
1518 to_send = total - sent;
1519
1520 rc = assuan_send_data (ctx, flush ? NULL : (char *) line + sent,
1521 flush ? 0 : to_send);
1522 if (!rc)
1523 {
1524 sent += flush ? 0 : to_send;
1525
1526 if ((progress && !(sent % progress) && sent != total) ||
1527 (sent == total && flush))
1528 rc = send_status (ctx, STATUS_XFER, "%li %li", sent, total);
1529
1530 if (!flush && !rc && sent == total)
1531 {
1532 flush = 1;
1533 goto again;
1534 }
1535 }
1536 }
1537 while (!rc && sent < total);
1538
1539 return rc;
1540 }
1541
1542 static gpg_error_t
1543 do_get (assuan_context_t ctx, char *line)
1544 {
1545 struct client_s *client = assuan_get_pointer (ctx);
1546 gpg_error_t rc;
1547 char **req;
1548 xmlNodePtr n;
1549
1550 req = str_split (line, "\t", 0);
1551
1552 if (!req || !*req)
1553 {
1554 strv_free (req);
1555 return GPG_ERR_SYNTAX;
1556 }
1557
1558 n = find_root_element (client, client->doc, &req, &rc, NULL, 0, 0);
1559 if (!n || rc)
1560 {
1561 strv_free (req);
1562 return rc;
1563 }
1564
1565 if (req[1])
1566 n = find_elements (client, client->doc, n->children, req + 1, &rc,
1567 NULL, NULL, NULL, 0, 0, NULL, 0);
1568
1569 strv_free (req);
1570 if (rc)
1571 return rc;
1572
1573 if (!n || !n->children)
1574 return GPG_ERR_NO_DATA;
1575
1576 n = find_text_node (n->children);
1577 if (!n || !n->content || !*n->content)
1578 return GPG_ERR_NO_DATA;
1579
1580 rc = xfer_data (ctx, (char *) n->content, xmlStrlen (n->content));
1581 return rc;
1582 }
1583
1584 static gpg_error_t
1585 get_command (assuan_context_t ctx, char *line)
1586 {
1587 struct client_s *client = assuan_get_pointer (ctx);
1588 gpg_error_t rc;
1589 struct argv_s *args[] = {
1590 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
1591 NULL
1592 };
1593
1594 rc = parse_options (&line, args, client, 1);
1595 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
1596 rc = GPG_ERR_SYNTAX;
1597 if (rc)
1598 return send_error (ctx, rc);
1599
1600 if (client->opts & OPT_INQUIRE)
1601 {
1602 unsigned char *result;
1603 size_t len;
1604
1605 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
1606 if (rc)
1607 return send_error (ctx, rc);
1608
1609 pthread_cleanup_push (xfree, result);
1610 rc = do_get (ctx, (char *)result);
1611 pthread_cleanup_pop (1);
1612 }
1613 else
1614 rc = do_get (ctx, line);
1615
1616 return send_error (ctx, rc);
1617 }
1618
1619 static void list_command_cleanup1 (void *arg);
1620 static gpg_error_t
1621 realpath_command (assuan_context_t ctx, char *line)
1622 {
1623 struct string_s *string = NULL;
1624 gpg_error_t rc;
1625 struct client_s *client = assuan_get_pointer (ctx);
1626 struct argv_s *args[] = {
1627 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
1628 NULL
1629 };
1630
1631 rc = parse_options (&line, args, client, 1);
1632 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
1633 rc = GPG_ERR_SYNTAX;
1634 if (rc)
1635 return send_error (ctx, rc);
1636
1637 if (client->opts & OPT_INQUIRE)
1638 {
1639 unsigned char *result;
1640 size_t len;
1641
1642 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
1643 if (rc)
1644 return send_error (ctx, rc);
1645
1646 pthread_cleanup_push (xfree, result);
1647 rc = build_realpath (client, client->doc, (char *)result, &string);
1648 pthread_cleanup_pop (1);
1649 }
1650 else
1651 rc = build_realpath (client, client->doc, line, &string);
1652
1653 if (!rc)
1654 {
1655 pthread_cleanup_push (list_command_cleanup1, string);
1656 rc = xfer_data (ctx, string->str, string->len);
1657 pthread_cleanup_pop (1);
1658 }
1659
1660 return send_error (ctx, rc);
1661 }
1662
1663 static void
1664 list_command_cleanup1 (void *arg)
1665 {
1666 if (arg)
1667 string_free ((struct string_s *) arg, 1);
1668 }
1669
1670 static void
1671 list_command_cleanup2 (void *arg)
1672 {
1673 struct element_list_s *elements = arg;
1674
1675 if (elements)
1676 {
1677 if (elements->list)
1678 {
1679 int total = slist_length (elements->list);
1680 int i;
1681
1682 for (i = 0; i < total; i++)
1683 {
1684 char *tmp = slist_nth_data (elements->list, i);
1685 xfree (tmp);
1686 }
1687
1688 slist_free (elements->list);
1689 }
1690
1691 if (elements->prefix)
1692 xfree (elements->prefix);
1693
1694 if (elements->req)
1695 strv_free (elements->req);
1696
1697 xfree (elements);
1698 }
1699 }
1700
1701 static gpg_error_t
1702 parse_list_opt_norecurse (void *data, void *value)
1703 {
1704 struct client_s *client = data;
1705
1706 client->opts &= ~(OPT_LIST_RECURSE);
1707 return 0;
1708 }
1709
1710 static gpg_error_t
1711 parse_opt_verbose (void *data, void *value)
1712 {
1713 struct client_s *client = data;
1714
1715 client->opts |= OPT_VERBOSE;
1716 return 0;
1717 }
1718
1719 static gpg_error_t
1720 parse_list_opt_target (void *data, void *value)
1721 {
1722 struct client_s *client = data;
1723
1724 client->opts |= OPT_LIST_WITH_TARGET;
1725 return 0;
1726 }
1727
1728 static gpg_error_t
1729 parse_list_opt_all (void *data, void *value)
1730 {
1731 struct client_s *client = data;
1732
1733 client->opts |= OPT_LIST_ALL;
1734 return 0;
1735 }
1736
1737 static gpg_error_t
1738 list_path_once (struct client_s *client, char *line,
1739 struct element_list_s *elements, struct string_s *result)
1740 {
1741 gpg_error_t rc;
1742
1743 elements->req = str_split (line, " ", 0);
1744 if (!elements->req)
1745 strv_printf (&elements->req, "%s", line);
1746
1747 rc = create_path_list (client, client->doc, elements, *elements->req);
1748 if ((rc == GPG_ERR_ELOOP || rc == GPG_ERR_EACCES) && elements->verbose)
1749 rc = 0;
1750
1751 if (!rc)
1752 {
1753 int total = slist_length (elements->list);
1754
1755 if (total)
1756 {
1757 int i;
1758
1759 for (i = 0; i < total; i++)
1760 {
1761 char *tmp = slist_nth_data (elements->list, i);
1762
1763 string_append_printf (result, "%s%s", tmp,
1764 i + 1 == total ? "" : "\n");
1765 }
1766 }
1767 else
1768 rc = GPG_ERR_NO_DATA;
1769 }
1770
1771 return rc;
1772 }
1773
1774 static int
1775 has_list_flag (char *path, char *flags)
1776 {
1777 char *p = path;
1778
1779 while (*p && *++p != ' ');
1780
1781 if (!*p)
1782 return 0;
1783
1784 for (; *p; p++)
1785 {
1786 char *f;
1787
1788 for (f = flags; *f && *f != ' '; f++)
1789 {
1790 if (*p == *f)
1791 return 1;
1792 }
1793 }
1794
1795 return 0;
1796 }
1797
1798 static gpg_error_t
1799 do_list (assuan_context_t ctx, char *line)
1800 {
1801 struct client_s *client = assuan_get_pointer (ctx);
1802 gpg_error_t rc;
1803 struct element_list_s *elements = NULL;
1804
1805 elements = xcalloc (1, sizeof (struct element_list_s));
1806 if (!elements)
1807 return GPG_ERR_ENOMEM;
1808
1809 elements->recurse = client->opts & OPT_LIST_RECURSE;
1810 elements->verbose =
1811 (client->opts & OPT_VERBOSE) | (client->opts & OPT_LIST_WITH_TARGET);
1812 elements->with_target = client->opts & OPT_LIST_WITH_TARGET;
1813
1814 if (!line || !*line)
1815 {
1816 struct string_s *str = NULL;
1817
1818 pthread_cleanup_push (list_command_cleanup2, elements);
1819 rc = list_root_elements (client, client->doc, &str, elements->verbose,
1820 elements->with_target);
1821 pthread_cleanup_pop (1);
1822 pthread_cleanup_push (list_command_cleanup1, str);
1823
1824 if (!rc)
1825 {
1826 if (client->opts & OPT_LIST_ALL)
1827 {
1828 char **roots = str_split (str->str, "\n", 0);
1829 char **p;
1830
1831 pthread_cleanup_push (req_cleanup, roots);
1832 string_truncate (str, 0);
1833
1834 for (p = roots; *p; p++)
1835 {
1836 if (strchr (*p, ' '))
1837 {
1838 if (has_list_flag (*p, "EOP"))
1839 {
1840 string_append_printf (str, "%s%s", *p,
1841 *(p + 1) ? "\n" : "");
1842 continue;
1843 }
1844 }
1845
1846 elements = xcalloc (1, sizeof (struct element_list_s));
1847 if (!elements)
1848 {
1849 rc = GPG_ERR_ENOMEM;
1850 break;
1851 }
1852
1853 elements->recurse = client->opts & OPT_LIST_RECURSE;
1854 elements->verbose =
1855 (client->opts & OPT_VERBOSE) | (client->opts &
1856 OPT_LIST_WITH_TARGET);
1857 elements->with_target = client->opts & OPT_LIST_WITH_TARGET;
1858 pthread_cleanup_push (list_command_cleanup2, elements);
1859 rc = list_path_once (client, *p, elements, str);
1860 pthread_cleanup_pop (1);
1861 if (rc)
1862 break;
1863
1864 if (*(p + 1))
1865 string_append (str, "\n");
1866 }
1867
1868 pthread_cleanup_pop (1);
1869 }
1870
1871 if (!rc)
1872 rc = xfer_data (ctx, str->str, str->len);
1873 }
1874
1875 pthread_cleanup_pop (1);
1876 return rc;
1877 }
1878
1879 pthread_cleanup_push (list_command_cleanup2, elements);
1880 struct string_s *str = string_new (NULL);
1881 pthread_cleanup_push (list_command_cleanup1, str);
1882 rc = list_path_once (client, line, elements, str);
1883 if (!rc)
1884 rc = xfer_data (ctx, str->str, str->len);
1885
1886 pthread_cleanup_pop (1);
1887 pthread_cleanup_pop (1);
1888 return rc;
1889 }
1890
1891 static gpg_error_t
1892 list_command (assuan_context_t ctx, char *line)
1893 {
1894 struct client_s *client = assuan_get_pointer (ctx);
1895 gpg_error_t rc;
1896 struct argv_s *args[] = {
1897 &(struct argv_s) {"no-recurse", OPTION_TYPE_NOARG,
1898 parse_list_opt_norecurse},
1899 &(struct argv_s) {"verbose", OPTION_TYPE_NOARG, parse_opt_verbose},
1900 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
1901 &(struct argv_s) {"with-target", OPTION_TYPE_NOARG,
1902 parse_list_opt_target},
1903 &(struct argv_s) {"all", OPTION_TYPE_NOARG, parse_list_opt_all},
1904 NULL
1905 };
1906
1907 if (disable_list_and_dump == 1)
1908 return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);
1909
1910 client->opts |= OPT_LIST_RECURSE;
1911 rc = parse_options (&line, args, client, 1);
1912 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
1913 rc = GPG_ERR_SYNTAX;
1914 if (rc)
1915 return send_error (ctx, rc);
1916
1917 if (client->opts & OPT_LIST_ALL)
1918 client->opts |= OPT_LIST_RECURSE | OPT_VERBOSE;
1919
1920 if (client->opts & OPT_INQUIRE)
1921 {
1922 unsigned char *result;
1923 size_t len;
1924
1925 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
1926 if (rc)
1927 return send_error (ctx, rc);
1928
1929 pthread_cleanup_push (xfree, result);
1930 rc = do_list (ctx, (char *)result);
1931 pthread_cleanup_pop (1);
1932 }
1933 else
1934 rc = do_list (ctx, line);
1935
1936 return send_error (ctx, rc);
1937 }
1938
1939 /*
1940 * req[0] - element path
1941 */
1942 static gpg_error_t
1943 attribute_list (assuan_context_t ctx, char **req)
1944 {
1945 struct client_s *client = assuan_get_pointer (ctx);
1946 char **attrlist = NULL;
1947 int i = 0;
1948 char **path = NULL;
1949 xmlAttrPtr a;
1950 xmlNodePtr n, an;
1951 char *line;
1952 gpg_error_t rc;
1953
1954 if (!req || !req[0])
1955 return GPG_ERR_SYNTAX;
1956
1957 client->flags |= FLAG_ACL_IGNORE;
1958
1959 if ((path = str_split (req[0], "\t", 0)) == NULL)
1960 {
1961 /*
1962 * The first argument may be only a root element.
1963 */
1964 if ((path = str_split (req[0], " ", 0)) == NULL)
1965 return GPG_ERR_SYNTAX;
1966 }
1967
1968 n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
1969 if (!n || rc)
1970 {
1971 strv_free (path);
1972 return rc;
1973 }
1974
1975 if (client->flags & FLAG_ACL_ERROR)
1976 {
1977 client->flags &= ~FLAG_ACL_IGNORE;
1978 if (path[1])
1979 {
1980 strv_free (path);
1981 return GPG_ERR_EACCES;
1982 }
1983
1984 client->flags &= ~FLAG_ACL_ERROR;
1985 }
1986
1987 if (path[1])
1988 {
1989 n = find_elements (client, client->doc, n->children, path + 1, &rc,
1990 NULL, NULL, NULL, 0, 0, NULL, 0);
1991 if (!n || rc)
1992 {
1993 strv_free (path);
1994 return rc;
1995 }
1996 }
1997
1998 strv_free (path);
1999
2000 for (a = n->properties; a; a = a->next)
2001 {
2002 char **pa;
2003
2004 if ((pa = xrealloc (attrlist, (i + 2) * sizeof (char *))) == NULL)
2005 {
2006 if (attrlist)
2007 strv_free (attrlist);
2008
2009 log_write ("%s(%i): %s", __FILE__, __LINE__,
2010 pwmd_strerror (GPG_ERR_ENOMEM));
2011 return GPG_ERR_ENOMEM;
2012 }
2013
2014 attrlist = pa;
2015 an = a->children;
2016 attrlist[i] = str_asprintf ("%s %s", (char *) a->name,
2017 an
2018 && an->content ? (char *) an->content : "");
2019
2020 if (!attrlist[i])
2021 {
2022 strv_free (attrlist);
2023 log_write ("%s(%i): %s", __FILE__, __LINE__,
2024 pwmd_strerror (GPG_ERR_ENOMEM));
2025 return GPG_ERR_ENOMEM;
2026 }
2027
2028 attrlist[++i] = NULL;
2029 }
2030
2031 if (!attrlist)
2032 return GPG_ERR_NO_DATA;
2033
2034 line = strv_join ("\n", attrlist);
2035
2036 if (!line)
2037 {
2038 log_write ("%s(%i): %s", __FILE__, __LINE__,
2039 pwmd_strerror (GPG_ERR_ENOMEM));
2040 strv_free (attrlist);
2041 return GPG_ERR_ENOMEM;
2042 }
2043
2044 pthread_cleanup_push (xfree, line);
2045 pthread_cleanup_push (req_cleanup, attrlist);
2046 rc = xfer_data (ctx, line, strlen (line));
2047 pthread_cleanup_pop (1);
2048 pthread_cleanup_pop (1);
2049 return rc;
2050 }
2051
2052 /*
2053 * req[0] - attribute
2054 * req[1] - element path
2055 */
2056 static gpg_error_t
2057 attribute_delete (struct client_s *client, char **req)
2058 {
2059 xmlNodePtr n;
2060 char **path = NULL;
2061 gpg_error_t rc;
2062
2063 if (!req || !req[0] || !req[1])
2064 return GPG_ERR_SYNTAX;
2065
2066 if (!strcmp (req[0], "_name"))
2067 return GPG_ERR_INV_ATTR;
2068
2069 if ((path = str_split (req[1], "\t", 0)) == NULL)
2070 {
2071 /*
2072 * The first argument may be only a root element.
2073 */
2074 if ((path = str_split (req[1], " ", 0)) == NULL)
2075 return GPG_ERR_SYNTAX;
2076 }
2077
2078 n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
2079 if (!n || rc)
2080 goto fail;
2081
2082 if (path[1])
2083 {
2084 n = find_elements (client, client->doc, n->children, path + 1, &rc,
2085 NULL, NULL, NULL, 0, 0, NULL, 0);
2086 if (!n || rc)
2087 goto fail;
2088 }
2089
2090 if (!strcmp (req[0], (char *) "_acl"))
2091 {
2092 rc = is_element_owner (client, n);
2093 if (rc)
2094 goto fail;
2095 }
2096
2097 rc = delete_attribute (client, n, (xmlChar *) req[0]);
2098
2099 fail:
2100 strv_free (path);
2101 return rc;
2102 }
2103
2104 static xmlNodePtr
2105 create_element_path (struct client_s *client,
2106 char ***elements, gpg_error_t * rc, xmlNodePtr parent)
2107 {
2108 char **req = *elements;
2109 char **req_orig = strv_dup (req);
2110 xmlNodePtr n = NULL;
2111
2112 *rc = 0;
2113
2114 if (!req_orig)
2115 {
2116 *rc = GPG_ERR_ENOMEM;
2117 log_write ("%s(%i): %s", __FILE__, __LINE__,
2118 pwmd_strerror (GPG_ERR_ENOMEM));
2119 goto fail;
2120 }
2121
2122 again:
2123 n = find_root_element (client, client->doc, &req, rc, NULL, 0, 0);
2124 if (!n)
2125 {
2126 if (*rc != GPG_ERR_ELEMENT_NOT_FOUND)
2127 goto fail;
2128
2129 *rc = new_root_element (client, client->doc, req[0]);
2130 if (*rc)
2131 goto fail;
2132
2133 goto again;
2134 }
2135 else if (n == parent)
2136 {
2137 *rc = GPG_ERR_CONFLICT;
2138 goto fail;
2139 }
2140
2141 if (req[1])
2142 {
2143 if (!n->children)
2144 n = create_target_elements_cb (client, 1, n, req + 1, rc, NULL);
2145 else
2146 n = find_elements (client, client->doc, n->children, req + 1, rc,
2147 NULL, NULL, create_target_elements_cb, 0, 0,
2148 parent, 0);
2149
2150 if (!n)
2151 goto fail;
2152
2153 /*
2154 * Reset the position of the element tree now that the elements
2155 * have been created.
2156 */
2157 strv_free (req);
2158 req = req_orig;
2159 req_orig = NULL;
2160 n = find_root_element (client, client->doc, &req, rc, NULL, 0, 0);
2161 if (!n)
2162 goto fail;
2163
2164 n = find_elements (client, client->doc, n->children, req + 1, rc,
2165 NULL, NULL, NULL, 0, 0, NULL, 0);
2166 if (!n)
2167 goto fail;
2168 }
2169
2170 fail:
2171 if (req_orig)
2172 strv_free (req_orig);
2173
2174 *elements = req;
2175 return n;
2176 }
2177
2178 /*
2179 * Creates a "target" attribute. When other commands encounter an element with
2180 * this attribute, the element path is modified to the target value. If the
2181 * source element path doesn't exist when using 'ATTR SET target', it is
2182 * created, but the destination element path must exist.
2183 *
2184 * req[0] - source element path
2185 * req[1] - destination element path
2186 */
2187 static gpg_error_t
2188 target_attribute (struct client_s *client, char **req)
2189 {
2190 char **src, **dst, *line = NULL, **odst = NULL;
2191 gpg_error_t rc;
2192 xmlNodePtr n;
2193
2194 if (!req || !req[0] || !req[1])
2195 return GPG_ERR_SYNTAX;
2196
2197 if ((src = str_split (req[0], "\t", 0)) == NULL)
2198 {
2199 /*
2200 * The first argument may be only a root element.
2201 */
2202 if ((src = str_split (req[0], " ", 0)) == NULL)
2203 return GPG_ERR_SYNTAX;
2204 }
2205
2206 if (!valid_element_path (src, 0))
2207 return GPG_ERR_INV_VALUE;
2208
2209 if ((dst = str_split (req[1], "\t", 0)) == NULL)
2210 {
2211 /*
2212 * The first argument may be only a root element.
2213 */
2214 if ((dst = str_split (req[1], " ", 0)) == NULL)
2215 {
2216 rc = GPG_ERR_SYNTAX;
2217 goto fail;
2218 }
2219 }
2220
2221 odst = strv_dup (dst);
2222 if (!odst)
2223 {
2224 rc = GPG_ERR_ENOMEM;
2225 goto fail;
2226 }
2227
2228 n = find_root_element (client, client->doc, &dst, &rc, NULL, 0, 0);
2229 /*
2230 * Make sure the destination element path exists.
2231 */
2232 if (rc && rc != GPG_ERR_EACCES)
2233 goto fail;
2234
2235 rc = 0;
2236 if (dst[1])
2237 {
2238 n = find_elements (client, client->doc, n->children, dst + 1, &rc,
2239 NULL, NULL, NULL, 0, 0, NULL, 0);
2240 if (rc && rc != GPG_ERR_EACCES)
2241 goto fail;
2242 }
2243
2244 rc = validate_target_attribute (client, client->doc, req[0], n);
2245 if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
2246 goto fail;
2247
2248 n = create_element_path (client, &src, &rc, NULL);
2249 if (rc)
2250 goto fail;
2251
2252 line = strv_join ("\t", odst);
2253 if (!line)
2254 {
2255 rc = GPG_ERR_ENOMEM;
2256 goto fail;
2257 }
2258
2259 rc = add_attribute (client, n, "target", line);
2260
2261 fail:
2262 xfree (line);
2263 strv_free (src);
2264 strv_free (dst);
2265 strv_free (odst);
2266 return rc;
2267 }
2268
2269 /*
2270 * req[0] - attribute
2271 * req[1] - element path
2272 */
2273 static gpg_error_t
2274 attribute_get (assuan_context_t ctx, char **req)
2275 {
2276 struct client_s *client = assuan_get_pointer (ctx);
2277 xmlNodePtr n;
2278 xmlChar *a;
2279 char **path = NULL;
2280 gpg_error_t rc;
2281
2282 if (!req || !req[0] || !req[1])
2283 return GPG_ERR_SYNTAX;
2284
2285 if (strchr (req[1], '\t'))
2286 {
2287 if ((path = str_split (req[1], "\t", 0)) == NULL)
2288 return GPG_ERR_SYNTAX;
2289 }
2290 else
2291 {
2292 if ((path = str_split (req[1], " ", 0)) == NULL)
2293 return GPG_ERR_SYNTAX;
2294 }
2295
2296 n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
2297 if (!n || rc)
2298 goto fail;
2299
2300 if (path[1])
2301 {
2302 n = find_elements (client, client->doc, n->children, path + 1, &rc,
2303 NULL, NULL, NULL, 0, 0, NULL, 0);
2304 if (!n || rc)
2305 goto fail;
2306 }
2307
2308 strv_free (path);
2309
2310 if ((a = xmlGetProp (n, (xmlChar *) req[0])) == NULL)
2311 return GPG_ERR_NOT_FOUND;
2312
2313 pthread_cleanup_push (xmlFree, a);
2314
2315 if (*a)
2316 rc = xfer_data (ctx, (char *) a, xmlStrlen (a));
2317 else
2318 rc = GPG_ERR_NO_DATA;
2319
2320 pthread_cleanup_pop (1);
2321 return rc;
2322
2323 fail:
2324 strv_free (path);
2325 return rc;
2326 }
2327
2328 /*
2329 * req[0] - attribute
2330 * req[1] - element path
2331 * req[2] - value
2332 */
2333 static gpg_error_t
2334 attribute_set (struct client_s *client, char **req)
2335 {
2336 char **path = NULL;
2337 gpg_error_t rc;
2338 xmlNodePtr n;
2339
2340 if (!req || !req[0] || !req[1])
2341 return GPG_ERR_SYNTAX;
2342
2343 /*
2344 * Reserved attribute names.
2345 */
2346 if (!strcmp (req[0], "_name"))
2347 return GPG_ERR_INV_ATTR;
2348 else if (!strcmp (req[0], "target"))
2349 return target_attribute (client, req + 1);
2350 else if (!valid_xml_attribute (req[0]))
2351 return GPG_ERR_INV_VALUE;
2352
2353 if ((path = str_split (req[1], "\t", 0)) == NULL)
2354 {
2355 /*
2356 * The first argument may be only a root element.
2357 */
2358 if ((path = str_split (req[1], " ", 0)) == NULL)
2359 return GPG_ERR_SYNTAX;
2360 }
2361
2362 n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
2363 if (!n || rc)
2364 goto fail;
2365
2366 if (path[1])
2367 {
2368 n = find_elements (client, client->doc, n->children, path + 1, &rc,
2369 NULL, NULL, NULL, 0, 0, NULL, 0);
2370 if (!n || rc)
2371 goto fail;
2372 }
2373
2374 if (!strcmp (req[0], (char *) "_acl"))
2375 {
2376 rc = is_element_owner (client, n);
2377 if (rc)
2378 goto fail;
2379 }
2380
2381 rc = add_attribute (client, n, req[0], req[2]);
2382
2383 fail:
2384 strv_free (path);
2385 return rc;
2386 }
2387
2388 /*
2389 * req[0] - command
2390 * req[1] - attribute name or element path if command is LIST
2391 * req[2] - element path
2392 * req[2] - element path or value
2393 */
2394
2395 static gpg_error_t
2396 do_attr (assuan_context_t ctx, char *line)
2397 {
2398 struct client_s *client = assuan_get_pointer (ctx);
2399 gpg_error_t rc = 0;
2400 char **req;
2401
2402 req = str_split (line, " ", 4);
2403 if (!req || !req[0] || !req[1])
2404 {
2405 strv_free (req);
2406 return GPG_ERR_SYNTAX;
2407 }
2408
2409 pthread_cleanup_push (req_cleanup, req);
2410
2411 if (strcasecmp (req[0], "SET") == 0)
2412 rc = attribute_set (client, req + 1);
2413 else if (strcasecmp (req[0], "GET") == 0)
2414 rc = attribute_get (ctx, req + 1);
2415 else if (strcasecmp (req[0], "DELETE") == 0)
2416 rc = attribute_delete (client, req + 1);
2417 else if (strcasecmp (req[0], "LIST") == 0)
2418 rc = attribute_list (ctx, req + 1);
2419 else
2420 rc = GPG_ERR_SYNTAX;
2421
2422 client->flags &= ~(FLAG_ACL_IGNORE|FLAG_ACL_ERROR);
2423 pthread_cleanup_pop (1);
2424 return rc;
2425 }
2426
2427 static gpg_error_t
2428 attr_command (assuan_context_t ctx, char *line)
2429 {
2430 struct client_s *client = assuan_get_pointer (ctx);
2431 gpg_error_t rc;
2432 struct argv_s *args[] = {
2433 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
2434 NULL
2435 };
2436
2437 rc = parse_options (&line, args, client, 1);
2438 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
2439 rc = GPG_ERR_SYNTAX;
2440 if (rc)
2441 return send_error (ctx, rc);
2442
2443 if (client->opts & OPT_INQUIRE)
2444 {
2445 unsigned char *result;
2446 size_t len;
2447
2448 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
2449 if (rc)
2450 return send_error (ctx, rc);
2451
2452 pthread_cleanup_push (xfree, result);
2453 rc = do_attr (ctx, (char *)result);
2454 pthread_cleanup_pop (1);
2455 }
2456 else
2457 rc = do_attr (ctx, line);
2458
2459 return send_error (ctx, rc);
2460 }
2461
2462 static gpg_error_t
2463 parse_iscached_opt_lock (void *data, void *value)
2464 {
2465 struct client_s *client = data;
2466
2467 (void) value;
2468 client->opts |= OPT_LOCK;
2469 return 0;
2470 }
2471
2472 static gpg_error_t
2473 iscached_command (assuan_context_t ctx, char *line)
2474 {
2475 struct client_s *client = assuan_get_pointer (ctx);
2476 gpg_error_t rc;
2477 struct argv_s *args[] = {
2478 &(struct argv_s) {"lock", OPTION_TYPE_NOARG, parse_iscached_opt_lock},
2479 NULL
2480 };
2481
2482 if (!line || !*line)
2483 return send_error (ctx, GPG_ERR_SYNTAX);
2484
2485 rc = parse_options (&line, args, client, 1);
2486 if (rc)
2487 return send_error (ctx, rc);
2488 else if (!valid_filename (line))
2489 return send_error (ctx, GPG_ERR_INV_VALUE);
2490
2491 rc = cache_iscached (line, NULL);
2492 if (client->opts & OPT_LOCK
2493 && (!rc || gpg_err_code (rc) == GPG_ERR_NO_DATA))
2494 {
2495 unsigned char md5file[16];
2496 gpg_error_t trc = rc;
2497
2498 gcry_md_hash_buffer (GCRY_MD_MD5, md5file, line, strlen (line));
2499 if (memcmp (md5file, client->md5file, 16))
2500 cleanup_client (client);
2501
2502 memcpy (client->md5file, md5file, 16);
2503 rc = do_lock (client, 1);
2504 if (!rc)
2505 rc = trc;
2506 }
2507
2508 return send_error (ctx, rc);
2509 }
2510
2511 static gpg_error_t
2512 clearcache_command (assuan_context_t ctx, char *line)
2513 {
2514 gpg_error_t rc = 0, all_rc = 0;
2515 unsigned char md5file[16];
2516 int i;
2517 int t;
2518 int all = 0;
2519 struct client_thread_s *once = NULL;
2520
2521 cache_lock ();
2522 MUTEX_LOCK (&cn_mutex);
2523 pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
2524
2525 if (!line || !*line)
2526 all = 1;
2527
2528 t = slist_length (cn_thread_list);
2529
2530 for (i = 0; i < t; i++)
2531 {
2532 struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
2533 assuan_peercred_t peer;
2534
2535 if (!thd->cl)
2536 continue;
2537
2538 /* Lock each connected clients' file mutex to prevent any other client
2539 * from accessing the cache entry (the file mutex is locked upon
2540 * command startup). The cache for the entry is not cleared if the
2541 * file mutex is locked by another client to prevent this function
2542 * from blocking.
2543 */
2544 if (all)
2545 {
2546 if (thd->cl->filename)
2547 {
2548 rc = do_validate_peer (ctx, thd->cl->filename, &peer);
2549 all_rc = !all_rc ? rc : all_rc;
2550 if (rc)
2551 {
2552 rc = 0;
2553 continue;
2554 }
2555 }
2556
2557 rc = cache_lock_mutex (thd->cl->ctx, thd->cl->md5file, -1, 0, -1);
2558 if (gpg_err_code (rc) == GPG_ERR_LOCKED)
2559 {
2560 if (pthread_equal (pthread_self (), thd->tid))
2561 rc = 0;
2562 else
2563 {
2564 if (!thd->cl->filename ||
2565 cache_iscached (thd->cl->filename,
2566 NULL) == GPG_ERR_NO_DATA)
2567 {
2568 rc = 0;
2569 continue;
2570 }
2571
2572 cache_defer_clear (thd->cl->md5file);
2573 }
2574 }
2575 else if (gpg_err_code (rc) == GPG_ERR_NO_DATA)
2576 {
2577 rc = 0;
2578 continue;
2579 }
2580
2581 if (!rc)
2582 {
2583 rc = cache_clear (thd->cl->md5file);
2584 cache_unlock_mutex (thd->cl->md5file, 0);
2585 }
2586
2587 if (rc)
2588 all_rc = rc;
2589
2590 rc = 0;
2591 }
2592 /* A single data filename was specified. Lock only this data file
2593 * mutex and free the cache entry. */
2594 else
2595 {
2596 gcry_md_hash_buffer (GCRY_MD_MD5, md5file, line, strlen (line));
2597 rc = do_validate_peer (ctx, line, &peer);
2598
2599 if (!rc && !memcmp (thd->cl->md5file, md5file, sizeof (md5file)))
2600 {
2601 rc = cache_lock_mutex (thd->cl->ctx, thd->cl->md5file, -1, 0,
2602 -1);
2603 if (gpg_err_code (rc) == GPG_ERR_LOCKED)
2604 {
2605 if (pthread_equal (pthread_self (), thd->tid))
2606 rc = 0;
2607 }
2608
2609 if (!rc)
2610 {
2611 once = thd;
2612 rc = cache_clear (thd->cl->md5file);
2613 cache_unlock_mutex (thd->cl->md5file, 0);
2614 }
2615 else
2616 {
2617 cache_defer_clear (thd->cl->md5file);
2618 }
2619
2620 break;
2621 }
2622 }
2623 }
2624
2625 /* Only connected clients' cache entries have been cleared. Now clear any
2626 * remaining cache entries without clients but only if there wasn't an
2627 * error from above since this would defeat the locking check of the
2628 * remaining entries. */
2629 if (!all_rc && all)
2630 {
2631 cache_clear (NULL);
2632 }
2633
2634 /* No clients are using the specified file. */
2635 else if (!all_rc && !rc && !once)
2636 {
2637 gcry_md_hash_buffer (GCRY_MD_MD5, md5file, line, strlen (line));
2638 rc = cache_clear (md5file);
2639 }
2640
2641 /* Release the connection mutex. */
2642 pthread_cleanup_pop (1);
2643 cache_unlock ();
2644
2645 if (!rc)
2646 send_status_all (STATUS_CACHE, NULL);
2647
2648 /* One or more files were locked while clearing all cache entries. */
2649 if (all_rc)
2650 rc = all_rc;
2651
2652 return send_error (ctx, rc);
2653 }
2654
2655 static gpg_error_t
2656 cachetimeout_command (assuan_context_t ctx, char *line)
2657 {
2658 int timeout;
2659 char **req = str_split (line, " ", 0);
2660 char *p;
2661 gpg_error_t rc = 0;
2662 assuan_peercred_t peer;
2663
2664 if (!req || !*req || !req[1])
2665 {
2666 strv_free (req);
2667 return send_error (ctx, GPG_ERR_SYNTAX);
2668 }
2669
2670 errno = 0;
2671 timeout = (int) strtol (req[1], &p, 10);
2672 if (errno != 0 || *p || timeout < -1)
2673 {
2674 strv_free (req);
2675 return send_error (ctx, GPG_ERR_SYNTAX);
2676 }
2677
2678 rc = do_validate_peer (ctx, req[0], &peer);
2679 if (!rc)
2680 {
2681 unsigned char md5file[16];
2682
2683 gcry_md_hash_buffer (GCRY_MD_MD5, md5file, req[0], strlen (req[0]));
2684 rc = cache_set_timeout (md5file, timeout);
2685 if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
2686 {
2687 rc = 0;
2688 MUTEX_LOCK (&rcfile_mutex);
2689 config_set_int_param (&global_config, req[0], "cache_timeout",
2690 req[1]);
2691 MUTEX_UNLOCK (&rcfile_mutex);
2692 }
2693 }
2694
2695 strv_free (req);
2696 return send_error (ctx, rc);
2697 }
2698
2699 static gpg_error_t
2700 dump_command (assuan_context_t ctx, char *line)
2701 {
2702 xmlChar *xml;
2703 int len;
2704 struct client_s *client = assuan_get_pointer (ctx);
2705 gpg_error_t rc;
2706
2707 if (disable_list_and_dump == 1)
2708 return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);
2709
2710 if (line && *line)
2711 return send_error (ctx, GPG_ERR_SYNTAX);
2712
2713 rc = peer_is_invoker(client);
2714 if (rc)
2715 return send_error (ctx, rc);
2716
2717 xmlDocDumpFormatMemory (client->doc, &xml, &len, 1);
2718
2719 if (!xml)
2720 {
2721 log_write ("%s(%i): %s", __FILE__, __LINE__,
2722 pwmd_strerror (GPG_ERR_ENOMEM));
2723 return send_error (ctx, GPG_ERR_ENOMEM);
2724 }
2725
2726 pthread_cleanup_push (xmlFree, xml);
2727 rc = xfer_data (ctx, (char *) xml, len);
2728 pthread_cleanup_pop (1);
2729 return send_error (ctx, rc);
2730 }
2731
2732 static gpg_error_t
2733 getconfig_command (assuan_context_t ctx, char *line)
2734 {
2735 struct client_s *client = assuan_get_pointer (ctx);
2736 gpg_error_t rc = 0;
2737 char filename[255] = { 0 }, param[747] = { 0 };
2738 char *p, *tmp = NULL, *fp = client->filename, *paramp = line;
2739
2740 if (!line || !*line)
2741 return send_error (ctx, GPG_ERR_SYNTAX);
2742
2743 if (strchr (line, ' '))
2744 {
2745 sscanf (line, " %254[^ ] %746c", filename, param);
2746 paramp = param;
2747 fp = filename;
2748 }
2749
2750 if (fp && !valid_filename (fp))
2751 return send_error (ctx, GPG_ERR_INV_VALUE);
2752
2753 paramp = str_down (paramp);
2754 if (!strcmp (paramp, "cipher") && fp)
2755 {
2756 struct crypto_s *crypto = NULL;
2757
2758 rc = init_client_crypto (&crypto);
2759 if (!rc)
2760 {
2761 rc = read_data_header (fp, &crypto->hdr, NULL, NULL);
2762 if (!rc)
2763 {
2764 const char *t =
2765 gcry_cipher_algo_name (cipher_to_gcrypt (crypto->hdr.flags));
2766 if (t)
2767 {
2768 tmp = str_dup (t);
2769 if (tmp)
2770 str_down (tmp);
2771 }
2772 }
2773 }
2774
2775 UPDATE_AGENT_CTX (client, crypto);
2776 cleanup_crypto (&crypto);
2777 if (rc && gpg_err_code (rc) != GPG_ERR_ENOENT)
2778 return send_error (ctx, rc);
2779
2780 if (!rc && tmp)
2781 goto done;
2782 }
2783 else if (!strcmp (paramp, "cipher_iterations") && fp)
2784 {
2785 struct crypto_s *crypto = NULL;
2786
2787 rc = init_client_crypto (&crypto);
2788 if (!rc)
2789 {
2790 rc = read_data_header (fp, &crypto->hdr, NULL, NULL);
2791 if (!rc)
2792 {
2793 tmp = str_asprintf ("%llu",
2794 (unsigned long long) crypto->hdr.s2k_count);
2795 if (!tmp)
2796 rc = GPG_ERR_ENOMEM;
2797 }
2798 }
2799
2800 UPDATE_AGENT_CTX (client, crypto);
2801 cleanup_crypto (&crypto);
2802 if (rc && gpg_err_code (rc) != GPG_ERR_ENOENT)
2803 return send_error (ctx, rc);
2804
2805 if (!rc && tmp)
2806 goto done;
2807 }
2808 else if (!strcmp (paramp, "passphrase"))
2809 return send_error (ctx, GPG_ERR_UNKNOWN_OPTION);
2810
2811 p = config_get_value (fp ? fp : "global", paramp);
2812 if (!p)
2813 return send_error (ctx, GPG_ERR_UNKNOWN_OPTION);
2814
2815 tmp = expand_homedir (p);
2816 xfree (p);
2817 if (!tmp)
2818 {
2819 log_write ("%s(%i): %s", __FILE__, __LINE__,
2820 pwmd_strerror (GPG_ERR_ENOMEM));
2821 return send_error (ctx, GPG_ERR_ENOMEM);
2822 }
2823
2824 done:
2825 p = tmp;
2826 pthread_cleanup_push (xfree, p);
2827 rc = xfer_data (ctx, p, strlen (p));
2828 pthread_cleanup_pop (1);
2829 return send_error (ctx, rc);
2830 }
2831
2832 struct xpath_s
2833 {
2834 xmlXPathContextPtr xp;
2835 xmlXPathObjectPtr result;
2836 xmlBufferPtr buf;
2837 char **req;
2838 };
2839
2840 static void
2841 xpath_command_cleanup (void *arg)
2842 {
2843 struct xpath_s *xpath = arg;
2844
2845 if (!xpath)
2846 return;
2847
2848 req_cleanup (xpath->req);
2849
2850 if (xpath->buf)
2851 xmlBufferFree (xpath->buf);
2852
2853 if (xpath->result)
2854 xmlXPathFreeObject (xpath->result);
2855
2856 if (xpath->xp)
2857 xmlXPathFreeContext (xpath->xp);
2858 }
2859
2860 static gpg_error_t
2861 do_xpath (assuan_context_t ctx, char *line)
2862 {
2863 gpg_error_t rc;
2864 struct client_s *client = assuan_get_pointer (ctx);
2865 struct xpath_s _x = { 0 };
2866 struct xpath_s *xpath = &_x;
2867
2868 if (!line || !*line)
2869 return GPG_ERR_SYNTAX;
2870
2871 if ((xpath->req = str_split (line, "\t", 2)) == NULL)
2872 {
2873 if (strv_printf (&xpath->req, "%s", line) == 0)
2874 return GPG_ERR_ENOMEM;
2875 }
2876
2877 xpath->xp = xmlXPathNewContext (client->doc);
2878 if (!xpath->xp)
2879 {
2880 rc = GPG_ERR_BAD_DATA;
2881 goto fail;
2882 }
2883
2884 xpath->result =
2885 xmlXPathEvalExpression ((xmlChar *) xpath->req[0], xpath->xp);
2886 if (!xpath->result)
2887 {
2888 rc = GPG_ERR_BAD_DATA;
2889 goto fail;
2890 }
2891
2892 if (xmlXPathNodeSetIsEmpty (xpath->result->nodesetval))
2893 {
2894 rc = GPG_ERR_ELEMENT_NOT_FOUND;
2895 goto fail;
2896 }
2897
2898 rc = recurse_xpath_nodeset (client, client->doc, xpath->result->nodesetval,
2899 (xmlChar *) xpath->req[1], &xpath->buf, 0,
2900 NULL);
2901 if (rc)
2902 goto fail;
2903 else if (!xpath->req[1] && !xmlBufferLength (xpath->buf))
2904 {
2905 rc = GPG_ERR_NO_DATA;
2906 goto fail;
2907 }
2908 else if (xpath->req[1])
2909 {
2910 rc = 0;
2911 goto fail;
2912 }
2913
2914 pthread_cleanup_push (xpath_command_cleanup, &xpath);
2915 rc = xfer_data (ctx, (char *) xmlBufferContent (xpath->buf),
2916 xmlBufferLength (xpath->buf));
2917 pthread_cleanup_pop (0);
2918 fail:
2919 xpath_command_cleanup (xpath);
2920 return rc;
2921 }
2922
2923 static gpg_error_t
2924 xpath_command (assuan_context_t ctx, char *line)
2925 {
2926 struct client_s *client = assuan_get_pointer (ctx);
2927 gpg_error_t rc;
2928 struct argv_s *args[] = {
2929 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
2930 NULL
2931 };
2932
2933 if (disable_list_and_dump == 1)
2934 return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);
2935
2936 rc = peer_is_invoker(client);
2937 if (rc)
2938 return send_error (ctx, rc);
2939
2940 rc = parse_options (&line, args, client, 1);
2941 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
2942 rc = GPG_ERR_SYNTAX;
2943 if (rc)
2944 return send_error (ctx, rc);
2945
2946 if (client->opts & OPT_INQUIRE)
2947 {
2948 unsigned char *result;
2949 size_t len;
2950
2951 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
2952 if (rc)
2953 return send_error (ctx, rc);
2954
2955 pthread_cleanup_push (xfree, result);
2956 rc = do_xpath (ctx, (char *)result);
2957 pthread_cleanup_pop (1);
2958 }
2959 else
2960 rc = do_xpath (ctx, line);
2961
2962 return send_error (ctx, rc);
2963 }
2964
2965 static gpg_error_t
2966 do_xpathattr (assuan_context_t ctx, char *line)
2967 {
2968 struct client_s *client = assuan_get_pointer (ctx);
2969 gpg_error_t rc;
2970 char **req = NULL;
2971 int cmd = 0; //SET
2972 struct xpath_s _x = { 0 };
2973 struct xpath_s *xpath = &_x;
2974
2975 if (!line || !*line)
2976 return GPG_ERR_SYNTAX;
2977
2978 if ((req = str_split (line, " ", 3)) == NULL)
2979 return GPG_ERR_ENOMEM;
2980
2981 if (!req[0])
2982 {
2983 rc = GPG_ERR_SYNTAX;
2984 goto fail;
2985 }
2986
2987 if (!strcasecmp (req[0], "SET"))
2988 cmd = 0;
2989 else if (!strcasecmp (req[0], "DELETE"))
2990 cmd = 1;
2991 else
2992 {
2993 rc = GPG_ERR_SYNTAX;
2994 goto fail;
2995 }
2996
2997 if (!req[1] || !req[2])
2998 {
2999 rc = GPG_ERR_SYNTAX;
3000 goto fail;
3001 }
3002
3003 if ((xpath->req = str_split (req[2], "\t", 3)) == NULL)
3004 {
3005 rc = GPG_ERR_ENOMEM;
3006 goto fail;
3007 }
3008
3009 if (!xpath->req[0] || (!xpath->req[1] && !cmd) || (xpath->req[1] && cmd))
3010 {
3011 rc = GPG_ERR_SYNTAX;
3012 goto fail;
3013 }
3014
3015 xpath->xp = xmlXPathNewContext (client->doc);
3016 if (!xpath->xp)
3017 {
3018 rc = GPG_ERR_BAD_DATA;
3019 goto fail;
3020 }
3021
3022 xpath->result = xmlXPathEvalExpression ((xmlChar *) xpath->req[0], xpath->xp);
3023 if (!xpath->result)
3024 {
3025 rc = GPG_ERR_BAD_DATA;
3026 goto fail;
3027 }
3028
3029 if (xmlXPathNodeSetIsEmpty (xpath->result->nodesetval))
3030 {
3031 rc = GPG_ERR_ELEMENT_NOT_FOUND;
3032 goto fail;
3033 }
3034
3035 rc = recurse_xpath_nodeset (client, client->doc, xpath->result->nodesetval,
3036 (xmlChar *) xpath->req[1], &xpath->buf, cmd,
3037 (xmlChar *) req[1]);
3038
3039 fail:
3040 xpath_command_cleanup (xpath);
3041 strv_free (req);
3042 return rc;
3043 }
3044
3045 /* XPATHATTR SET|DELETE <name> <expression>[<TAB>[value]] */
3046 static gpg_error_t
3047 xpathattr_command (assuan_context_t ctx, char *line)
3048 {
3049 struct client_s *client = assuan_get_pointer (ctx);
3050 gpg_error_t rc;
3051 struct argv_s *args[] = {
3052 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
3053 NULL
3054 };
3055
3056 if (disable_list_and_dump == 1)
3057 return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);
3058
3059 rc = peer_is_invoker(client);
3060 if (rc)
3061 return send_error (ctx, rc);
3062
3063 rc = parse_options (&line, args, client, 1);
3064 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
3065 rc = GPG_ERR_SYNTAX;
3066 if (rc)
3067 return send_error (ctx, rc);
3068
3069 if (client->opts & OPT_INQUIRE)
3070 {
3071 unsigned char *result;
3072 size_t len;
3073
3074 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
3075 if (rc)
3076 return send_error (ctx, rc);
3077
3078 pthread_cleanup_push (xfree, result);
3079 rc = do_xpathattr (ctx, (char *)result);
3080 pthread_cleanup_pop (1);
3081 }
3082 else
3083 rc = do_xpathattr (ctx, line);
3084
3085 return send_error (ctx, rc);
3086 }
3087
3088 static gpg_error_t
3089 do_import (struct client_s *client, const char *root_element,
3090 unsigned char *content)
3091 {
3092 char **dst_path = NULL;
3093 xmlDocPtr doc = NULL;
3094 xmlNodePtr n, root, copy;
3095 gpg_error_t rc;
3096
3097 if (!content || !*content)
3098 {
3099 xfree (content);
3100 return GPG_ERR_SYNTAX;
3101 }
3102
3103 if (root_element)
3104 dst_path = str_split (root_element, "\t", 0);
3105
3106 if (dst_path && !valid_element_path (dst_path, 0))
3107 {
3108 if (dst_path)
3109 strv_free (dst_path);
3110
3111 return GPG_ERR_INV_VALUE;
3112 }
3113
3114 struct string_s *str = string_new_content ((char *)content);
3115 str = string_prepend (str, "<pwmd>");
3116 str = string_append (str, "</pwmd>");
3117 doc = xmlReadDoc ((xmlChar *) str->str, NULL, "UTF-8", XML_PARSE_NOBLANKS);
3118 string_free (str, 1);
3119 if (!doc)
3120 {
3121 rc = GPG_ERR_BAD_DATA;
3122 goto fail;
3123 }
3124
3125 root = xmlDocGetRootElement (doc);
3126 xmlNodePtr root_orig = root->children;
3127 root = root->children;
3128 rc = validate_import (client, root);
3129 if (rc)
3130 goto fail;
3131
3132 do
3133 {
3134 again:
3135 if (dst_path)
3136 {
3137 char **path = strv_dup (dst_path);
3138 if (!path)
3139 {
3140 log_write ("%s(%i): %s", __FILE__, __LINE__,
3141 pwmd_strerror (GPG_ERR_ENOMEM));
3142 rc = GPG_ERR_ENOMEM;
3143 goto fail;
3144 }
3145
3146 xmlChar *a = xmlGetProp (root, (xmlChar *) "_name");
3147 if (!a)
3148 {
3149 strv_free (path);
3150 rc = GPG_ERR_INV_VALUE;
3151 goto fail;
3152 }
3153
3154 if (strv_printf (&path, "%s", (char *) a) == 0)
3155 {
3156 xmlFree (a);
3157 rc = GPG_ERR_ENOMEM;
3158 goto fail;
3159 }
3160
3161 xmlFree (a);
3162 n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 0);
3163 if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
3164 {
3165 strv_free (path);
3166 goto fail;
3167 }
3168
3169 if (!rc)
3170 {
3171 n = find_elements (client, client->doc, n->children, path + 1, &rc,
3172 NULL, NULL, NULL, 0, 0, NULL, 1);
3173 if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
3174 {
3175 strv_free (path);
3176 goto fail;
3177 }
3178 else if (!rc)
3179 {
3180 xmlUnlinkNode (n);
3181 xmlFreeNode (n);
3182 strv_free (path);
3183 path = NULL;
3184 goto again;
3185 }
3186 }
3187
3188 if (rc == GPG_ERR_ELEMENT_NOT_FOUND)
3189 {
3190 n = create_element_path (client, &path, &rc, NULL);
3191 if (rc)
3192 goto fail;
3193 }
3194
3195 if (root->children)
3196 {
3197 copy = xmlCopyNodeList (root->children);
3198 n = xmlAddChildList (n, copy);
3199 if (!n)
3200 rc = GPG_ERR_ENOMEM;
3201 }
3202
3203 strv_free (path);
3204 }
3205 else
3206 {
3207 char **path = NULL;
3208
3209 /* Check if the content root element can create a DTD root element. */
3210 if (!xmlStrEqual ((xmlChar *) "element", root->name))
3211 {
3212 rc = GPG_ERR_SYNTAX;
3213 goto fail;
3214 }
3215
3216 xmlChar *a;
3217
3218 if ((a = xmlGetProp (root, (xmlChar *) "_name")) == NULL)
3219 {
3220 rc = GPG_ERR_SYNTAX;
3221 goto fail;
3222 }
3223
3224 char *tmp = str_dup ((char *) a);
3225 xmlFree (a);
3226 int literal = is_literal_element (&tmp);
3227
3228 if (!valid_xml_element ((xmlChar *) tmp) || literal)
3229 {
3230 xfree (tmp);
3231 rc = GPG_ERR_INV_VALUE;
3232 goto fail;
3233 }
3234
3235 if (strv_printf (&path, "%s", tmp) == 0)
3236 {
3237 xfree (tmp);
3238 rc = GPG_ERR_ENOMEM;
3239 goto fail;
3240 }
3241
3242 xfree (tmp);
3243 n = find_root_element (client, client->doc, &path, &rc, NULL, 0, 1);
3244 if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
3245 {
3246 rc = GPG_ERR_BAD_DATA;
3247 goto fail;
3248 }
3249
3250 /* Overwriting the existing tree. */
3251 if (!rc)
3252 {
3253 xmlUnlinkNode (n);
3254 xmlFreeNodeList (n);
3255 }
3256
3257 rc = 0;
3258 xmlSetProp (root, (xmlChar *) "_name", (xmlChar *) path[0]);
3259 n = xmlCopyNode (root, 1);
3260 n = xmlAddChildList (xmlDocGetRootElement (client->doc), n);
3261 strv_free (path);
3262 }
3263
3264 if (n && !rc)
3265 rc = update_element_mtime (client, n->parent);
3266
3267 for (root = root_orig->next; root; root = root->next)
3268 {
3269 if (root->type == XML_ELEMENT_NODE)
3270 break;
3271 }
3272
3273 root_orig = root;
3274 }
3275 while (root);
3276
3277 fail:
3278 if (doc)
3279 xmlFreeDoc (doc);
3280
3281 if (dst_path)
3282 strv_free (dst_path);
3283
3284 return rc;
3285 }
3286
3287 static gpg_error_t
3288 parse_import_opt_root (void *data, void *value)
3289 {
3290 struct client_s *client = data;
3291
3292 client->import_root = str_dup (value);
3293 return client->import_root ? 0 : GPG_ERR_ENOMEM;
3294 }
3295
3296 static gpg_error_t
3297 import_command (assuan_context_t ctx, char *line)
3298 {
3299 gpg_error_t rc;
3300 struct client_s *client = assuan_get_pointer (ctx);
3301 unsigned char *result;
3302 size_t len;
3303 struct argv_s *args[] = {
3304 &(struct argv_s) {"root", OPTION_TYPE_ARG, parse_import_opt_root},
3305 NULL
3306 };
3307
3308 xfree (client->import_root);
3309 client->import_root = NULL;
3310 rc = parse_options (&line, args, client, 0);
3311 if (rc)
3312 return send_error (ctx, rc);
3313
3314 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
3315 if (rc)
3316 {
3317 xfree (client->import_root);
3318 client->import_root = NULL;
3319 return send_error (ctx, rc);
3320 }
3321
3322 rc = do_import (client, client->import_root, result);
3323 xfree (client->import_root);
3324 client->import_root = NULL;
3325 return send_error (ctx, rc);
3326 }
3327
3328 static gpg_error_t
3329 do_lock (struct client_s *client, int add)
3330 {
3331 gpg_error_t rc = lock_file_mutex (client, add);
3332
3333 if (!rc)
3334 client->flags |= FLAG_LOCK_CMD;
3335
3336 return rc;
3337 }
3338
3339 static gpg_error_t
3340 lock_command (assuan_context_t ctx, char *line)
3341 {
3342 struct client_s *client = assuan_get_pointer (ctx);
3343 gpg_error_t rc;
3344
3345 if (line && *line)
3346 return send_error (ctx, GPG_ERR_SYNTAX);
3347
3348 rc = do_lock (client, 0);
3349 return send_error (ctx, rc);
3350 }
3351
3352 static gpg_error_t
3353 unlock_command (assuan_context_t ctx, char *line)
3354 {
3355 struct client_s *client = assuan_get_pointer (ctx);
3356 gpg_error_t rc;
3357
3358 if (line && *line)
3359 return send_error (ctx, GPG_ERR_SYNTAX);
3360
3361 rc = unlock_file_mutex (client, 0);
3362 return send_error (ctx, rc);
3363 }
3364
3365 static gpg_error_t
3366 option_command (assuan_context_t ctx, char *line)
3367 {
3368 struct client_s *client = assuan_get_pointer (ctx);
3369 gpg_error_t rc = 0;
3370 struct pinentry_option_s *pin_opts = &client->pinentry_opts;
3371 #ifdef WITH_AGENT
3372 struct agent_s *agent = client->crypto->agent;
3373 #endif
3374 char namebuf[255] = { 0 };
3375 char *name = namebuf;
3376 char *value = NULL, *p, *tmp = NULL;
3377
3378 p = strchr (line, '=');
3379 if (!p)
3380 {
3381 strncpy (namebuf, line, sizeof(namebuf));
3382 namebuf[sizeof(namebuf)-1] = 0;
3383 }
3384 else
3385 {
3386 strncpy (namebuf, line, strlen (line)-strlen (p));
3387 namebuf[sizeof(namebuf)-1] = 0;
3388 value = p+1;
3389 }
3390
3391 log_write1 ("OPTION name='%s' value='%s'", name, value);
3392
3393 if (strcasecmp (name, (char *) "lock-timeout") == 0)
3394 {
3395 long n = 0;
3396
3397 if (value)
3398 {
3399 n = strtol (value, &tmp, 10);
3400 if (tmp && *tmp)
3401 return send_error (ctx, GPG_ERR_INV_VALUE);
3402 }
3403
3404 client->lock_timeout = n;
3405 goto done;
3406 }
3407 else if (strcasecmp (name, (char *) "NAME") == 0)
3408 {
3409 if (value && strchr (value, ' '))
3410 rc = GPG_ERR_INV_VALUE;
3411 else
3412 {
3413 tmp = pthread_getspecific (thread_name_key);
3414 xfree (tmp);
3415 MUTEX_LOCK (&cn_mutex);
3416 xfree (client->thd->name);
3417 client->thd->name = NULL;
3418
3419 if (!value || !*value)
3420 pthread_setspecific (thread_name_key, str_dup (""));
3421 else
3422 {
3423 client->thd->name = str_dup (value);
3424 pthread_setspecific (thread_name_key, str_dup (value));
3425 }
3426
3427 MUTEX_UNLOCK (&cn_mutex);
3428 }
3429 goto done;
3430 }
3431 else if (strcasecmp (name, (char *) "lc-messages") == 0)
3432 {
3433 xfree (pin_opts->lc_messages);
3434 pin_opts->lc_messages = NULL;
3435 if (value && *value)
3436 pin_opts->lc_messages = str_dup (value);
3437 #ifdef WITH_AGENT
3438 if (use_agent)
3439 rc = set_agent_option (client->crypto->agent, "lc-messages", value);
3440 #endif
3441 }
3442 else if (strcasecmp (name, (char *) "lc-ctype") == 0)
3443 {
3444 xfree (pin_opts->lc_ctype);
3445 pin_opts->lc_ctype = NULL;
3446 if (value && *value)
3447 pin_opts->lc_ctype = str_dup (value);
3448 #ifdef WITH_AGENT
3449 if (use_agent)
3450 rc = set_agent_option (client->crypto->agent, "lc-ctype", value);
3451 #endif
3452 }
3453 else if (strcasecmp (name, (char *) "ttyname") == 0)
3454 {
3455 xfree (pin_opts->ttyname);
3456 pin_opts->ttyname = NULL;
3457 if (value && *value)
3458 pin_opts->ttyname = str_dup (value);
3459 #ifdef WITH_AGENT
3460 if (use_agent)
3461 rc = set_agent_option (client->crypto->agent, "ttyname", value);
3462 #endif
3463 }
3464 else if (strcasecmp (name, (char *) "ttytype") == 0)
3465 {
3466 xfree (pin_opts->ttytype);
3467 pin_opts->ttytype = NULL;
3468 if (value && *value)
3469 pin_opts->ttytype = str_dup (value);
3470 #ifdef WITH_AGENT
3471 if (use_agent)
3472 rc = set_agent_option (client->crypto->agent, "ttytype", value);
3473 #endif
3474 }
3475 else if (strcasecmp (name, (char *) "display") == 0)
3476 {
3477 xfree (pin_opts->display);
3478 pin_opts->display = NULL;
3479 if (value && *value)
3480 pin_opts->display = str_dup (value);
3481 #ifdef WITH_AGENT
3482 if (use_agent)
3483 rc = set_agent_option (client->crypto->agent, "display", value);
3484 #endif
3485 }
3486 else if (strcasecmp (name, (char *) "pinentry-desc") == 0)
3487 {
3488 xfree (pin_opts->desc);
3489 pin_opts->desc = NULL;
3490 if (value && *value)
3491 pin_opts->desc = str_dup (value);
3492 }
3493 else if (strcasecmp (name, (char *) "pinentry-title") == 0)
3494 {
3495 xfree (pin_opts->title);
3496 pin_opts->title = NULL;
3497 if (value && *value)
3498 pin_opts->title = str_dup (value);
3499 }
3500 else if (strcasecmp (name, (char *) "pinentry-prompt") == 0)
3501 {
3502 xfree (pin_opts->prompt);
3503 pin_opts->prompt = NULL;
3504 if (value && *value)
3505 pin_opts->prompt = str_dup (value);
3506 }
3507
3508 else if (strcasecmp (name, "pinentry-timeout") == 0)
3509 {
3510 char *p = NULL;
3511 int n;
3512
3513 if (!value)
3514 goto done;
3515
3516 n = (int) strtol (value, &p, 10);
3517
3518 if (*p || n < 0)
3519 return send_error (ctx, GPG_ERR_INV_VALUE);
3520
3521 pin_opts->timeout = n;
3522 MUTEX_LOCK (&rcfile_mutex);
3523 config_set_int_param (&global_config,
3524 client->filename ? client->filename : "global",
3525 "pinentry_timeout", value);
3526 MUTEX_UNLOCK (&rcfile_mutex);
3527 goto done;
3528 }
3529 else if (strcasecmp (name, "disable-pinentry") == 0)
3530 {
3531 int n = 1;
3532
3533 if (value && *value)
3534 {
3535 n = (int) strtol (value, &tmp, 10);
3536 if (*tmp || n < 0 || n > 1)
3537 return send_error (ctx, GPG_ERR_INV_VALUE);
3538 }
3539
3540 if (n)
3541 client->flags |= FLAG_NO_PINENTRY;
3542 else
3543 client->flags &= ~FLAG_NO_PINENTRY;
3544
3545 #ifdef WITH_AGENT
3546 if (use_agent)
3547 {
3548 if (client->flags & FLAG_NO_PINENTRY)
3549 rc = set_agent_option (client->crypto->agent, "pinentry-mode",
3550 "loopback");
3551 else
3552 rc = set_agent_option (client->crypto->agent, "pinentry-mode",
3553 "ask");
3554
3555 if (rc)
3556 return send_error (ctx, rc);
3557 }
3558 #endif
3559 }
3560 else
3561 return send_error (ctx, GPG_ERR_UNKNOWN_OPTION);
3562
3563 done:
3564 #ifdef WITH_AGENT
3565 if (!rc && use_agent && agent)
3566 {
3567 rc = pinentry_merge_options (&client->crypto->agent->pinentry_opts,
3568 pin_opts);
3569 }
3570 #endif
3571
3572 return send_error (ctx, rc);
3573 }
3574
3575 static gpg_error_t
3576 do_rename (assuan_context_t ctx, char *line)
3577 {
3578 struct client_s *client = assuan_get_pointer (ctx);
3579 gpg_error_t rc;
3580 char **req, **src, *dst;
3581 xmlNodePtr n, ndst;
3582
3583 req = str_split (line, " ", 0);
3584
3585 if (!req || !req[0] || !req[1])
3586 {
3587 strv_free (req);
3588 return GPG_ERR_SYNTAX;
3589 }
3590
3591 dst = req[1];
3592 is_literal_element (&dst);
3593
3594 if (!valid_xml_element ((xmlChar *) dst))
3595 {
3596 strv_free (req);
3597 return GPG_ERR_INV_VALUE;
3598 }
3599
3600 if (strchr (req[0], '\t'))
3601 src = str_split (req[0], "\t", 0);
3602 else
3603 src = str_split (req[0], " ", 0);
3604
3605 if (!src || !*src)
3606 {
3607 rc = GPG_ERR_SYNTAX;
3608 goto fail;
3609 }
3610
3611 n = find_root_element (client, client->doc, &src, &rc, NULL, 0, 0);
3612 if (rc)
3613 goto fail;
3614
3615 if (src[1] && n)
3616 n = find_elements (client, client->doc, n->children, src + 1, &rc, NULL, NULL,
3617 NULL, 0, 0, NULL, 0);
3618
3619 if (!n || rc)
3620 goto fail;
3621
3622 rc = is_element_owner (client, n);
3623 if (rc)
3624 goto fail;
3625
3626 xmlChar *a = xmlGetProp (n, (xmlChar *) "_name");
3627 if (!a)
3628 {
3629 rc = GPG_ERR_ENOMEM;
3630 goto fail;
3631 }
3632
3633 /* To prevent unwanted effects:
3634 *
3635 * <root name="a"><b/></root>
3636 *
3637 * RENAME a<TAB>b b
3638 */
3639 if (xmlStrEqual (a, (xmlChar *) dst))
3640 {
3641 xmlFree (a);
3642 rc = GPG_ERR_AMBIGUOUS_NAME;
3643 goto fail;
3644 }
3645
3646 xmlFree (a);
3647 char **tmp = NULL;
3648 if (src[1])
3649 {
3650 char **p;
3651
3652 for (p = src; *p; p++)
3653 {
3654 if (!*(p + 1))
3655 break;
3656 strv_printf (&tmp, "%s", *p);
3657 }
3658 }
3659
3660 strv_printf (&tmp, "!%s", dst);
3661 ndst = find_root_element (client, client->doc, &tmp, &rc, NULL, 0, 0);
3662 if (!ndst && rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
3663 {
3664 strv_free (tmp);
3665 goto fail;
3666 }
3667
3668 if (tmp[1] && ndst)
3669 ndst = find_elements (client, client->doc, ndst->children, tmp + 1, &rc, NULL,
3670 NULL, NULL, 0, 0, NULL, 0);
3671
3672 strv_free (tmp);
3673 if (!ndst && rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
3674 goto fail;
3675
3676 rc = 0;
3677
3678 /* Target may exist:
3679 *
3680 * <root name="a"/>
3681 * <root name="b" target="a"/>
3682 *
3683 * RENAME b a
3684 *
3685 * Would need to do:
3686 * RENAME !b a
3687 */
3688 if (ndst == n)
3689 {
3690 rc = GPG_ERR_AMBIGUOUS_NAME;
3691 goto fail;
3692 }
3693
3694 if (ndst)
3695 {
3696 rc = is_element_owner (client, ndst);
3697 if (rc)
3698 goto fail;
3699
3700 unlink_node (client, ndst);
3701 xmlFreeNodeList (ndst);
3702 }
3703
3704 rc = add_attribute (client, n, "_name", dst);
3705
3706 fail:
3707 strv_free (req);
3708 strv_free (src);
3709 return rc;
3710 }
3711
3712 static gpg_error_t
3713 rename_command (assuan_context_t ctx, char *line)
3714 {
3715 struct client_s *client = assuan_get_pointer (ctx);
3716 gpg_error_t rc;
3717 struct argv_s *args[] = {
3718 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
3719 NULL
3720 };
3721
3722 rc = parse_options (&line, args, client, 1);
3723 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
3724 rc = GPG_ERR_SYNTAX;
3725 if (rc)
3726 return send_error (ctx, rc);
3727
3728 if (client->opts & OPT_INQUIRE)
3729 {
3730 unsigned char *result;
3731 size_t len;
3732
3733 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
3734 if (rc)
3735 return send_error (ctx, rc);
3736
3737 pthread_cleanup_push (xfree, result);
3738 rc = do_rename (ctx, (char *)result);
3739 pthread_cleanup_pop (1);
3740 }
3741 else
3742 rc = do_rename (ctx, line);
3743
3744 return send_error (ctx, rc);
3745 }
3746
3747 static gpg_error_t
3748 do_copy (assuan_context_t ctx, char *line)
3749 {
3750 struct client_s *client = assuan_get_pointer (ctx);
3751 gpg_error_t rc;
3752 char **req, **src = NULL, **dst = NULL;
3753 xmlNodePtr nsrc, ndst, new = NULL;
3754
3755 req = str_split (line, " ", 0);
3756 if (!req || !req[0] || !req[1])
3757 {
3758 strv_free (req);
3759 return GPG_ERR_SYNTAX;
3760 }
3761
3762 if (strchr (req[0], '\t'))
3763 src = str_split (req[0], "\t", 0);
3764 else
3765 src = str_split (req[0], " ", 0);
3766
3767 if (!src || !*src)
3768 {
3769 rc = GPG_ERR_SYNTAX;
3770 goto fail;
3771 }
3772
3773 if (strchr (req[1], '\t'))
3774 dst = str_split (req[1], "\t", 0);
3775 else
3776 dst = str_split (req[1], " ", 0);
3777
3778 if (!dst || !*dst)
3779 {
3780 rc = GPG_ERR_SYNTAX;
3781 goto fail;
3782 }
3783
3784 if (!valid_element_path (dst, 0))
3785 {
3786 rc = GPG_ERR_INV_VALUE;
3787 goto fail;
3788 }
3789
3790 nsrc = find_root_element (client, client->doc, &src, &rc, NULL, 0, 0);
3791 if (rc)
3792 goto fail;
3793
3794 if (nsrc && src[1])
3795 nsrc = find_elements (client, client->doc, nsrc->children, src + 1, &rc, NULL,
3796 NULL, NULL, 0, 0, NULL, 0);
3797
3798 if (!nsrc || rc)
3799 goto fail;
3800
3801 new = xmlCopyNodeList (nsrc);
3802 if (!new)
3803 {
3804 rc = GPG_ERR_ENOMEM;
3805 goto fail;
3806 }
3807
3808 int create = 0;
3809 ndst = find_root_element (client, client->doc, &dst, &rc, NULL, 0, 0);
3810 if (rc == GPG_ERR_EACCES)
3811 goto fail;
3812
3813 if (ndst && dst[1])
3814 {
3815 if (ndst->children)
3816 ndst = find_elements (client, client->doc, ndst->children, dst + 1, &rc, NULL,
3817 NULL, create_target_elements_cb, 0, 0, NULL, 0);
3818 else
3819 create = 1;
3820 }
3821 else
3822 create = 1;
3823
3824 if (!ndst && rc != GPG_ERR_ELEMENT_NOT_FOUND)
3825 goto fail;
3826 else if (!ndst || create)
3827 {
3828 ndst = create_element_path (client, &dst, &rc, NULL);
3829 if (!ndst || rc)
3830 goto fail;
3831 }
3832
3833 rc = is_element_owner (client, ndst);
3834 if (rc)
3835 goto fail;
3836
3837 /* Merge any attributes from the src node to the initial dst node. */
3838 for (xmlAttrPtr attr = new->properties; attr; attr = attr->next)
3839 {
3840 if (xmlStrEqual (attr->name, (xmlChar *) "_name"))
3841 continue;
3842
3843 xmlAttrPtr a = xmlHasProp (ndst, attr->name);
3844 if (a)
3845 xmlRemoveProp (a);
3846
3847 xmlChar *tmp = xmlNodeGetContent (attr->children);
3848 xmlNewProp (ndst, attr->name, tmp);
3849 xmlFree (tmp);
3850 rc = add_attribute (client, ndst, NULL, NULL);
3851 }
3852
3853 xmlNodePtr n = ndst->children;
3854 xmlUnlinkNode (n);
3855 xmlFreeNodeList (n);
3856 ndst->children = NULL;
3857
3858 if (new->children)
3859 {
3860 n = xmlCopyNodeList (new->children);
3861 if (!n)
3862 {
3863 rc = GPG_ERR_ENOMEM;
3864 goto fail;
3865 }
3866
3867 n = xmlAddChildList (ndst, n);
3868 if (!n)
3869 {
3870 rc = GPG_ERR_ENOMEM;
3871 goto fail;
3872 }
3873
3874 rc = update_element_mtime (client, xmlDocGetRootElement (client->doc) ==
3875 ndst->parent ? ndst : ndst->parent);
3876 }
3877
3878 fail:
3879 if (new)
3880 {
3881 xmlUnlinkNode (new);
3882 xmlFreeNodeList (new);
3883 }
3884
3885 if (req)
3886 strv_free (req);
3887
3888 if (src)
3889 strv_free (src);
3890
3891 if (dst)
3892 strv_free (dst);
3893
3894 return rc;
3895 }
3896
3897 static gpg_error_t
3898 copy_command (assuan_context_t ctx, char *line)
3899 {
3900 struct client_s *client = assuan_get_pointer (ctx);
3901 gpg_error_t rc;
3902 struct argv_s *args[] = {
3903 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
3904 NULL
3905 };
3906
3907 rc = parse_options (&line, args, client, 1);
3908 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
3909 rc = GPG_ERR_SYNTAX;
3910 if (rc)
3911 return send_error (ctx, rc);
3912
3913 if (client->opts & OPT_INQUIRE)
3914 {
3915 unsigned char *result;
3916 size_t len;
3917
3918 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
3919 if (rc)
3920 return send_error (ctx, rc);
3921
3922 pthread_cleanup_push (xfree, result);
3923 rc = do_copy (ctx, (char *)result);
3924 pthread_cleanup_pop (1);
3925 }
3926 else
3927 rc = do_copy (ctx, line);
3928
3929 return send_error (ctx, rc);
3930 }
3931
3932 static gpg_error_t
3933 do_move (assuan_context_t ctx, char *line)
3934 {
3935 struct client_s *client = assuan_get_pointer (ctx);
3936 gpg_error_t rc;
3937 char **req, **src = NULL, **dst = NULL;
3938 xmlNodePtr nsrc, ndst = NULL;
3939
3940 req = str_split (line, " ", 0);
3941
3942 if (!req || !req[0] || !req[1])
3943 {
3944 strv_free (req);
3945 return GPG_ERR_SYNTAX;
3946 }
3947
3948 if (strchr (req[0], '\t'))
3949 src = str_split (req[0], "\t", 0);
3950 else
3951 src = str_split (req[0], " ", 0);
3952
3953 if (!src || !*src)
3954 {
3955 rc = GPG_ERR_SYNTAX;
3956 goto fail;
3957 }
3958
3959 if (strchr (req[1], '\t'))
3960 dst = str_split (req[1], "\t", 0);
3961 else
3962 dst = str_split (req[1], " ", 0);
3963
3964 nsrc = find_root_element (client, client->doc, &src, &rc, NULL, 0, 0);
3965 if (rc)
3966 goto fail;
3967
3968 if (nsrc && src[1])
3969 nsrc = find_elements (client, client->doc, nsrc->children, src + 1, &rc,
3970 NULL, NULL, NULL, 0, 0, NULL, 0);
3971
3972 if (!nsrc)
3973 goto fail;
3974
3975 rc = is_element_owner (client, nsrc);
3976 if (rc)
3977 goto fail;
3978
3979 if (dst)
3980 {
3981 if (!valid_element_path (dst, 0))
3982 {
3983 rc = GPG_ERR_INV_VALUE;
3984 goto fail;
3985 }
3986
3987 ndst = find_root_element (client, client->doc, &dst, &rc, NULL, 0, 0);
3988 if (rc)
3989 goto fail;
3990
3991 if (ndst && dst[1])
3992 ndst = find_elements (client, client->doc, ndst->children, dst + 1,
3993 &rc, NULL, NULL, NULL, 0, 0, NULL, 0);
3994 }
3995 else
3996 ndst = xmlDocGetRootElement (client->doc);
3997
3998 for (xmlNodePtr n = ndst; n; n = n->parent)
3999 {
4000 if (n == nsrc)
4001 {
4002 rc = GPG_ERR_CONFLICT;
4003 goto fail;
4004 }
4005 }
4006
4007 if (rc && rc != GPG_ERR_ELEMENT_NOT_FOUND)
4008 goto fail;
4009
4010 rc = 0;
4011
4012 if (ndst)
4013 {
4014 xmlChar *a = node_has_attribute (nsrc, (xmlChar *) "_name");
4015
4016 xmlNodePtr dup = find_element (client, ndst->children, (char *) a,
4017 NULL, &rc);
4018 xmlFree (a);
4019
4020 if (rc)
4021 goto fail;
4022
4023 if (dup)
4024 {
4025 if (dup == nsrc)
4026 goto fail;
4027
4028 if (ndst == xmlDocGetRootElement (client->doc))
4029 {
4030 xmlNodePtr n = nsrc;
4031 int match = 0;
4032
4033 while (n->parent && n->parent != ndst)
4034 n = n->parent;
4035
4036 xmlChar *a = node_has_attribute (n, (xmlChar *) "_name");
4037 xmlChar *b = node_has_attribute (nsrc, (xmlChar *) "_name");
4038
4039 if (xmlStrEqual (a, b))
4040 {
4041 match = 1;
4042 xmlUnlinkNode (nsrc);
4043 xmlUnlinkNode (n);
4044 xmlFreeNodeList (n);
4045 }
4046
4047 xmlFree (a);
4048 xmlFree (b);
4049
4050 if (!match)
4051 {
4052 xmlUnlinkNode (dup);
4053 xmlFreeNodeList (dup);
4054 }
4055 }
4056 else
4057 xmlUnlinkNode (dup);
4058 }
4059 }
4060
4061 if (!ndst && dst)
4062 {
4063 xmlChar *name = node_has_attribute (nsrc, (xmlChar *) "_name");
4064
4065 if (nsrc->parent == xmlDocGetRootElement (client->doc)
4066 && !strcmp ((char *) name, *dst))
4067 {
4068 xmlFree (name);
4069 rc = GPG_ERR_CONFLICT;
4070 goto fail;
4071 }
4072
4073 xmlFree (name);
4074 ndst = create_element_path (client, &dst, &rc, nsrc);
4075 if (rc)
4076 goto fail;
4077 }
4078
4079 if (!ndst)
4080 goto fail;
4081
4082 update_element_mtime (client, nsrc->parent);
4083 xmlUnlinkNode (nsrc);
4084 ndst = xmlAddChildList (ndst, nsrc);
4085
4086 if (!ndst)
4087 rc = GPG_ERR_ENOMEM;
4088 else
4089 update_element_mtime (client, ndst->parent);
4090
4091 fail:
4092 if (req)
4093 strv_free (req);
4094
4095 if (src)
4096 strv_free (src);
4097
4098 if (dst)
4099 strv_free (dst);
4100
4101 return rc;
4102 }
4103
4104 static gpg_error_t
4105 move_command (assuan_context_t ctx, char *line)
4106 {
4107 struct client_s *client = assuan_get_pointer (ctx);
4108 gpg_error_t rc;
4109 struct argv_s *args[] = {
4110 &(struct argv_s) {"inquire", OPTION_TYPE_NOARG, parse_opt_inquire},
4111 NULL
4112 };
4113
4114 rc = parse_options (&line, args, client, 1);
4115 if (!rc && (client->opts & OPT_INQUIRE) && line && *line)
4116 rc = GPG_ERR_SYNTAX;
4117 if (rc)
4118 return send_error (ctx, rc);
4119
4120 if (client->opts & OPT_INQUIRE)
4121 {
4122 unsigned char *result;
4123 size_t len;
4124
4125 rc = assuan_inquire (ctx, "DATA", &result, &len, 0);
4126 if (rc)
4127 return send_error (ctx, rc);
4128
4129 pthread_cleanup_push (xfree, result);
4130 rc = do_move (ctx, (char *)result);
4131 pthread_cleanup_pop (1);
4132 }
4133 else
4134 rc = do_move (ctx, line);
4135
4136 return send_error (ctx, rc);
4137 }
4138
4139 static gpg_error_t
4140 ls_command (assuan_context_t ctx, char *line)
4141 {
4142 gpg_error_t rc;
4143 char *tmp;
4144 char *dir;
4145 DIR *d;
4146
4147 if (line && *line)
4148 return send_error (ctx, GPG_ERR_SYNTAX);
4149
4150 tmp = str_asprintf ("%s/data", homedir);
4151 dir = expand_homedir (tmp);
4152 xfree (tmp);
4153 d = opendir (dir);
4154 rc = gpg_error_from_errno (errno);
4155
4156 if (!d)
4157 {
4158 xfree (dir);
4159 return send_error (ctx, rc);
4160 }
4161
4162 size_t len =
4163 offsetof (struct dirent, d_name) +pathconf (dir, _PC_NAME_MAX) + 1;
4164 struct dirent *p = xmalloc (len), *cur = NULL;
4165 char *list = NULL;
4166
4167 xfree (dir);
4168 pthread_cleanup_push (xfree, p);
4169 pthread_cleanup_push ((void *)(void *)closedir, d);
4170 rc = 0;
4171
4172 while (!readdir_r (d, p, &cur) && cur)
4173 {
4174 if (cur->d_name[0] == '.' && cur->d_name[1] == '\0')
4175 continue;
4176 else if (cur->d_name[0] == '.' && cur->d_name[1] == '.'
4177 && cur->d_name[2] == '\0')
4178 continue;
4179
4180 tmp = str_asprintf ("%s%s\n", list ? list : "", cur->d_name);
4181
4182 if (!tmp)
4183 {
4184 if (list)
4185 xfree (list);
4186
4187 rc = GPG_ERR_ENOMEM;
4188 break;
4189 }
4190
4191 xfree (list);
4192 list = tmp;
4193 }
4194
4195 pthread_cleanup_pop (1); // closedir (d)
4196 pthread_cleanup_pop (1); // xfree (p)
4197
4198 if (rc)
4199 return send_error (ctx, rc);
4200
4201 if (!list)
4202 return send_error (ctx, GPG_ERR_NO_DATA);
4203
4204 list[strlen (list) - 1] = 0;
4205 pthread_cleanup_push (xfree, list);
4206 rc = xfer_data (ctx, list, strlen (list));
4207 pthread_cleanup_pop (1);
4208 return send_error (ctx, rc);
4209 }
4210
4211 static gpg_error_t
4212 bye_notify (assuan_context_t ctx, char *line)
4213 {
4214 struct client_s *cl = assuan_get_pointer (ctx);
4215
4216 cl->thd->state = CLIENT_STATE_DISCON;
4217
4218 #ifdef WITH_GNUTLS
4219 if (cl->thd->remote)
4220 {
4221 int rc;
4222
4223 do
4224 {
4225 struct timeval tv = { 0, 50000 };
4226
4227 rc = gnutls_bye (cl->thd->tls->ses, GNUTLS_SHUT_RDWR);
4228 if (rc == GNUTLS_E_AGAIN)
4229 select (0, NULL, NULL, NULL, &tv);
4230 }
4231 while (rc == GNUTLS_E_AGAIN);
4232 }
4233 #endif
4234
4235 /* This will let assuan_process_next() return. */
4236 if (fcntl (cl->thd->fd, F_SETFL, O_NONBLOCK) == -1)
4237 {
4238 cl->last_rc = gpg_error_from_errno (errno);
4239 return cl->last_rc;
4240 }
4241
4242 cl->last_rc = 0; // BYE command result
4243 return 0;
4244 }
4245
4246 static gpg_error_t
4247 reset_notify (assuan_context_t ctx, char *line)
4248 {
4249 struct client_s *client = assuan_get_pointer (ctx);
4250
4251 if (client)
4252 cleanup_client (client);
4253
4254 return 0;
4255 }
4256
4257 /*
4258 * This is called before every Assuan command.
4259 */
4260 static gpg_error_t
4261 command_startup (assuan_context_t ctx, const char *name)
4262 {
4263 struct client_s *client = assuan_get_pointer (ctx);
4264 gpg_error_t rc;
4265 struct command_table_s *cmd = NULL;
4266
4267 log_write1 ("command='%s'", name);
4268 client->last_rc = client->opts = 0;
4269
4270 for (int i = 0; command_table[i]; i++)
4271 {
4272 if (!strcasecmp (name, command_table[i]->name))
4273 {
4274 if (command_table[i]->ignore_startup)
4275 return 0;
4276 cmd = command_table[i];
4277 break;
4278 }
4279 }
4280
4281 if (!cmd)
4282 return GPG_ERR_UNKNOWN_COMMAND;
4283
4284 client->last_rc = rc = gpg_error (file_modified (client, cmd));
4285 if (!rc)
4286 update_client_state (client, CLIENT_STATE_COMMAND);
4287
4288 return rc;
4289 }
4290
4291 /*
4292 * This is called after every Assuan command.
4293 */
4294 static void
4295 command_finalize (assuan_context_t ctx, gpg_error_t rc)
4296 {
4297 struct client_s *client = assuan_get_pointer (ctx);
4298
4299 if (!(client->flags & FLAG_LOCK_CMD))
4300 unlock_file_mutex (client, 0);
4301
4302 unlock_flock (&client->flock_fd);
4303 log_write1 (_("command completed: rc=%u"), rc ? rc : client->last_rc);
4304 client->last_rc = gpg_error (GPG_ERR_UNKNOWN_COMMAND);
4305 #ifdef WITH_GNUTLS
4306 client->thd->buffer_timeout = client->thd->last_buffer_size = 0;
4307 #endif
4308 update_client_state (client, CLIENT_STATE_IDLE);
4309 }
4310
4311 static gpg_error_t
4312 help_command (assuan_context_t ctx, char *line)
4313 {
4314 gpg_error_t rc;
4315 int i;
4316
4317 if (!line || !*line)
4318 {
4319 char *tmp;
4320 char *help = str_dup (_("Usage: HELP [<COMMAND>]\n"
4321 "For commands that take an element path as an argument, each element is "
4322 "separated with an ASCII @key{TAB} character (ASCII 0x09)."
4323 "\n" "COMMANDS:"));
4324
4325 for (i = 0; command_table[i]; i++)
4326 {
4327 if (!command_table[i]->help)
4328 continue;
4329
4330 tmp = str_asprintf ("%s %s", help, command_table[i]->name);
4331 xfree (help);
4332 help = tmp;
4333 }
4334
4335 tmp = strip_texi_and_wrap (help);
4336 xfree (help);
4337 pthread_cleanup_push (xfree, tmp);
4338 rc = xfer_data (ctx, tmp, strlen (tmp));
4339 pthread_cleanup_pop (1);
4340 return send_error (ctx, rc);
4341 }
4342
4343 for (i = 0; command_table[i]; i++)
4344 {
4345 if (!strcasecmp (line, command_table[i]->name))
4346 {
4347 char *help, *tmp;
4348
4349 if (!command_table[i]->help)
4350 break;
4351
4352 help = strip_texi_and_wrap (command_table[i]->help);
4353 tmp = str_asprintf (_("Usage: %s"), help);
4354 xfree (help);
4355 pthread_cleanup_push (xfree, tmp);
4356 rc = xfer_data (ctx, tmp, strlen (tmp));
4357 pthread_cleanup_pop (1);
4358 return send_error (ctx, rc);
4359 }
4360 }
4361
4362 return send_error (ctx, GPG_ERR_INV_NAME);
4363 }
4364
4365 static void
4366 new_command (const char *name, int ignore, int unlock, int flock_type,
4367 gpg_error_t (*handler) (assuan_context_t, char *),
4368 const char *help)
4369 {
4370 int i = 0;
4371
4372 if (command_table)
4373 for (i = 0; command_table[i]; i++);
4374
4375 command_table =
4376 xrealloc (command_table, (i + 2) * sizeof (struct command_table_s *));
4377 command_table[i] = xcalloc (1, sizeof (struct command_table_s));
4378 command_table[i]->name = name;
4379 command_table[i]->handler = handler;
4380 command_table[i]->ignore_startup = ignore;
4381 command_table[i]->unlock = unlock;
4382 command_table[i]->flock_type = flock_type;
4383 command_table[i++]->help = help;
4384 command_table[i] = NULL;
4385 }
4386
4387 void
4388 deinit_commands ()
4389 {
4390 int i;
4391
4392 for (i = 0; command_table[i]; i++)
4393 xfree (command_table[i]);
4394
4395 xfree (command_table);
4396 }
4397
4398 static int
4399 sort_commands (const void *arg1, const void *arg2)
4400 {
4401 struct command_table_s *const *a = arg1;
4402 struct command_table_s *const *b = arg2;
4403
4404 if (!*a || !*b)
4405 return 0;
4406 else if (*a && !*b)
4407 return 1;
4408 else if (!*a && *b)
4409 return -1;
4410
4411 return strcmp ((*a)->name, (*b)->name);
4412 }
4413
4414 static gpg_error_t
4415 passwd_command (assuan_context_t ctx, char *line)
4416 {
4417 struct client_s *client = assuan_get_pointer (ctx);
4418 gpg_error_t rc;
4419 struct argv_s *args[] = {
4420 &(struct argv_s) {"reset", OPTION_TYPE_NOARG, parse_opt_reset},
4421 &(struct argv_s) {"s2k-count", OPTION_TYPE_ARG, parse_opt_s2k_count},
4422 &(struct argv_s) {"no-passphrase", OPTION_TYPE_NOARG, parse_opt_no_passphrase},
4423 NULL
4424 };
4425
4426 rc = peer_is_invoker (client);
4427 if (rc == GPG_ERR_EACCES)
4428 return send_error (ctx, rc);
4429
4430 if (client->flags & FLAG_NEW)
4431 return send_error (ctx, GPG_ERR_INV_STATE);
4432
4433 client->crypto->save.hdr.s2k_count =
4434 config_get_ulonglong (client->filename, "s2k_count");
4435 rc = parse_options (&line, args, client, 0);
4436 if (rc)
4437 return send_error (ctx, rc);
4438
4439 if (!rc && client->opts & OPT_RESET)
4440 {
4441 rc = cache_clear (client->md5file);
4442 if (!rc)
4443 send_status_all (STATUS_CACHE, NULL);
4444 }
4445
4446 if (!rc)
4447 {
4448 if (!IS_PKI (client->crypto))
4449 {
4450 struct crypto_s *crypto;
4451
4452 xfree (client->crypto->filename);
4453 client->crypto->filename = str_dup (client->filename);
4454 rc = change_passwd (ctx, client->filename,
4455 client->flags & FLAG_NO_PINENTRY, &crypto,
4456 (client->opts & OPT_NO_PASSPHRASE));
4457 if (!rc)
4458 {
4459 cleanup_crypto (&client->crypto);
4460 client->crypto = crypto;
4461 update_checksum (client);
4462 cleanup_crypto_stage1 (client->crypto);
4463 }
4464 }
4465 #ifdef WITH_AGENT
4466 else
4467 {
4468 if (client->crypto->save.hdr.s2k_count)
4469 rc = send_to_agent (client->crypto->agent, NULL, NULL,
4470 "OPTION s2k-count=%lu",
4471 client->crypto->save.hdr.s2k_count);
4472
4473 if (!rc)
4474 rc = agent_passwd (client->crypto);
4475
4476 (void) kill_scd (client->crypto->agent);
4477 }
4478 #endif
4479 }
4480
4481 return send_error (ctx, rc);
4482 }
4483
4484 static gpg_error_t
4485 parse_keygrip_opt_sign (void *data, void *value)
4486 {
4487 struct client_s *client = data;
4488
4489 (void) value;
4490 client->opts |= OPT_SIGN;
4491 return 0;
4492 }
4493
4494 static gpg_error_t
4495 keygrip_command (assuan_context_t ctx, char *line)
4496 {
4497 struct client_s *client = assuan_get_pointer (ctx);
4498 gpg_error_t rc;
4499 struct crypto_s *crypto = NULL;
4500 struct argv_s *args[] = {
4501 &(struct argv_s) {"sign", OPTION_TYPE_NOARG, parse_keygrip_opt_sign},
4502 NULL
4503 };
4504
4505 if (!line || !*line)
4506 return send_error (ctx, GPG_ERR_SYNTAX);
4507
4508 rc = parse_options (&line, args, client, 1);
4509 if (rc)
4510 return send_error (ctx, rc);
4511
4512 if (!valid_filename (line))
4513 return send_error (ctx, GPG_ERR_INV_VALUE);
4514
4515 rc = init_client_crypto (&crypto);
4516 if (rc)
4517 return send_error (ctx, rc);
4518
4519 rc = read_data_file (line, crypto);
4520 if (!rc)
4521 {
4522 char *hexgrip = NULL;
4523
4524 if (!IS_PKI (crypto))
4525 {
4526 cleanup_crypto (&crypto);
4527 return send_error (ctx, GPG_ERR_NOT_SUPPORTED);
4528 }
4529
4530 if (client->opts & OPT_SIGN)
4531 {
4532 if (valid_keygrip (crypto->sign_grip, sizeof (crypto->sign_grip)))
4533 hexgrip = bin2hex (crypto->sign_grip, sizeof (crypto->sign_grip));
4534 }
4535
4536 if (!hexgrip)
4537 hexgrip = bin2hex (crypto->grip, sizeof (crypto->grip));
4538
4539 if (!hexgrip)
4540 rc = GPG_ERR_ENOMEM;
4541 else
4542 rc = xfer_data (ctx, hexgrip, strlen (hexgrip));
4543
4544 xfree (hexgrip);
4545 }
4546
4547 UPDATE_AGENT_CTX (client, crypto);
4548 cleanup_crypto (&crypto);
4549 return send_error (ctx, rc);
4550 }
4551
4552 static gpg_error_t
4553 parse_opt_data (void *data, void *value)
4554 {
4555 struct client_s *client = data;
4556
4557 (void) value;
4558 client->opts |= OPT_DATA;
4559 return 0;
4560 }
4561
4562 static gpg_error_t
4563 send_client_list (assuan_context_t ctx)
4564 {
4565 struct client_s *client = assuan_get_pointer (ctx);
4566 gpg_error_t rc = 0;
4567 char buf[ASSUAN_LINELENGTH];
4568
4569 if (client->opts & OPT_VERBOSE)
4570 {
4571 unsigned i, t;
4572 char **list = NULL;
4573 char *line;
4574
4575 MUTEX_LOCK (&cn_mutex);
4576 pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
4577 t = slist_length (cn_thread_list);
4578
4579 for (i = 0; i < t; i++)
4580 {
4581 struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
4582 char *tmp;
4583
4584 if (thd->state == CLIENT_STATE_UNKNOWN)
4585 continue;
4586
4587 tmp = build_client_info_line (thd, 0);
4588 if (tmp)
4589 {
4590 char **l = strv_cat (list, tmp);
4591 if (!l)
4592 rc = GPG_ERR_ENOMEM;
4593 else
4594 list = l;
4595 }
4596 else
4597 rc = GPG_ERR_ENOMEM;
4598
4599 if (rc)
4600 {
4601 strv_free (list);
4602 break;
4603 }
4604 }
4605
4606 pthread_cleanup_pop (1);
4607 if (rc)
4608 return rc;
4609
4610 line = strv_join ("\n", list);
4611 strv_free (list);
4612 pthread_cleanup_push (xfree, line);
4613 rc = xfer_data (ctx, line, strlen (line));
4614 pthread_cleanup_pop (1);
4615 return rc;
4616 }
4617
4618 if (client->opts & OPT_DATA)
4619 {
4620 MUTEX_LOCK (&cn_mutex);
4621 pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
4622 snprintf (buf, sizeof (buf), "%i", slist_length (cn_thread_list));
4623 pthread_cleanup_pop (1);
4624 rc = xfer_data (ctx, buf, strlen (buf));
4625 }
4626 else
4627 rc = send_status (ctx, STATUS_CLIENTS, NULL);
4628
4629 return rc;
4630 }
4631
4632 static gpg_error_t
4633 getinfo_command (assuan_context_t ctx, char *line)
4634 {
4635 struct client_s *client = assuan_get_pointer (ctx);
4636 gpg_error_t rc;
4637 char buf[ASSUAN_LINELENGTH];
4638 struct argv_s *args[] = {
4639 &(struct argv_s) {"data", OPTION_TYPE_NOARG, parse_opt_data},
4640 &(struct argv_s) {"verbose", OPTION_TYPE_NOARG, parse_opt_verbose},
4641 NULL
4642 };
4643
4644 rc = parse_options (&line, args, client, 1);
4645 if (rc)
4646 return send_error (ctx, rc);
4647
4648 if (!strcasecmp (line, "clients"))
4649 {
4650 rc = send_client_list (ctx);
4651 }
4652 else if (!strcasecmp (line, "cache"))
4653 {
4654 if (client->opts & OPT_DATA)
4655 {
4656 snprintf (buf, sizeof (buf), "%u", cache_file_count ());
4657 rc = xfer_data (ctx, buf, strlen (buf));
4658 }
4659 else
4660 rc = send_status (ctx, STATUS_CACHE, NULL);
4661 }
4662 else if (!strcasecmp (line, "pid"))
4663 {
4664 char buf[32];
4665 pid_t pid = getpid ();
4666
4667 snprintf (buf, sizeof (buf), "%i", pid);
4668 rc = xfer_data (ctx, buf, strlen (buf));
4669 }
4670 else if (!strcasecmp (line, "version"))
4671 {
4672 char *buf = str_asprintf ("0x%06x %s%s", VERSION_HEX,
4673 #ifdef WITH_LIBACL
4674 "ACL "
4675 #endif
4676 #ifdef WITH_GNUTLS
4677 "GNUTLS "
4678 #endif
4679 #ifdef WITH_QUALITY
4680 "QUALITY "
4681 #endif
4682 "", use_agent ? "AGENT" : "");
4683 rc = xfer_data (ctx, buf, strlen (buf));
4684 xfree (buf);
4685 }
4686 else if (!strcasecmp (line, "last_error"))
4687 {
4688 if (client->last_error)
4689 rc = xfer_data (ctx, client->last_error, strlen (client->last_error));
4690 else
4691 rc = GPG_ERR_NO_DATA;
4692 }
4693 else if (!strcasecmp (line, "user"))
4694 {
4695 char *user = NULL;
4696
4697 #ifdef WITH_GNUTLS
4698 if (client->thd->remote)
4699 user = str_asprintf ("#%s", client->thd->tls->fp);
4700 else
4701 user = get_username (client->thd->peer->uid);
4702 #else
4703 user = get_username (client->thd->peer->uid);
4704 #endif
4705 if (user)
4706 {
4707 pthread_cleanup_push (xfree, user);
4708 rc = xfer_data (ctx, user, strlen (user));
4709 pthread_cleanup_pop (1);
4710 }
4711 else
4712 rc = GPG_ERR_NO_DATA;
4713 }
4714 else
4715 rc = gpg_error (GPG_ERR_SYNTAX);
4716
4717 return send_error (ctx, rc);
4718 }
4719
4720 #ifdef WITH_AGENT
4721 static gpg_error_t
4722 send_data_cb (void *user, const void *buf, size_t len)
4723 {
4724 assuan_context_t ctx = user;
4725
4726 return assuan_send_data (ctx, buf, len);
4727 }
4728
4729 static gpg_error_t
4730 send_status_cb (void *user, const char *line)
4731 {
4732 assuan_context_t ctx = user;
4733 char keyword[200], *k;
4734 const char *p;
4735
4736 for (p = line, k = keyword; *p; p++)
4737 {
4738 if (isspace (*p))
4739 break;
4740
4741 *k++ = *p;
4742 }
4743
4744 *k = 0;
4745 if (*p == '#')
4746 p++;
4747
4748 while (isspace (*p))
4749 p++;
4750
4751 return assuan_write_status (ctx, keyword, *p ? p : NULL);
4752 }
4753 #endif
4754
4755 static gpg_error_t
4756 kill_command (assuan_context_t ctx, char *line)
4757 {
4758 struct client_s *client = assuan_get_pointer (ctx);
4759 gpg_error_t rc;
4760 unsigned i, t;
4761
4762 if (!line || !*line)
4763 return send_error (ctx, GPG_ERR_SYNTAX);
4764
4765 MUTEX_LOCK (&cn_mutex);
4766 pthread_cleanup_push (cleanup_mutex_cb, &cn_mutex);
4767 t = slist_length (cn_thread_list);
4768 rc = GPG_ERR_ESRCH;
4769
4770 for (i = 0; i < t; i++)
4771 {
4772 struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
4773 char *tmp = str_asprintf ("%p", thd->tid);
4774
4775 if (strcmp (line, tmp))
4776 {
4777 xfree (tmp);
4778 continue;
4779 }
4780
4781 xfree (tmp);
4782 rc = peer_is_invoker (client);
4783 if (!rc)
4784 {
4785 #ifdef HAVE_PTHREAD_CANCEL
4786 rc = pthread_cancel (thd->tid);
4787 #else
4788 close (thd->fd);
4789 thd->fd = -1;
4790 #endif
4791 break;
4792 }
4793
4794 rc = GPG_ERR_EACCES;
4795 if (config_get_boolean ("global", "strict_kill"))
4796 break;
4797
4798 #ifdef WITH_GNUTLS
4799 if (client->thd->remote && thd->remote)
4800 {
4801 if (!strcmp (client->thd->tls->fp, thd->tls->fp))
4802 {
4803 #ifdef HAVE_PTHREAD_CANCEL
4804 rc = pthread_cancel (thd->tid);
4805 #else
4806 close (thd->fd);
4807 thd->fd = -1;
4808 #endif
4809 break;
4810 }
4811 }
4812 else if (!client->thd->remote && !thd->remote)
4813 #endif
4814 {
4815 if (client->thd->peer->uid == thd->peer->uid)
4816 {
4817 #ifdef HAVE_PTHREAD_CANCEL
4818 rc = pthread_cancel (thd->tid);
4819 #else
4820 close (thd->fd);
4821 thd->fd = -1;
4822 #endif
4823 }
4824 }
4825 break;
4826 }
4827
4828 pthread_cleanup_pop (1);
4829 return send_error (ctx, rc);
4830 }
4831
4832 static gpg_error_t
4833 agent_command (assuan_context_t ctx, char *line)
4834 {
4835 gpg_error_t rc = 0;
4836
4837 if (!use_agent)
4838 return send_error (ctx, GPG_ERR_NOT_IMPLEMENTED);
4839
4840 #ifdef WITH_AGENT
4841 struct client_s *client = assuan_get_pointer (ctx);
4842
4843 if (!line || !*line)
4844 return send_error (ctx, GPG_ERR_SYNTAX);
4845
4846 assuan_set_flag (client->crypto->agent->ctx, ASSUAN_CONVEY_COMMENTS, 1);
4847 rc = assuan_transact (client->crypto->agent->ctx, line, send_data_cb,
4848 client->ctx, agent_loopback_cb, client->crypto,
4849 send_status_cb, client->ctx);
4850 if (gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
4851 {
4852 char *line;
4853 size_t len;
4854
4855 rc = assuan_write_line (client->crypto->agent->ctx, "CAN");
4856 if (!rc)
4857 {
4858 rc = assuan_read_line (client->crypto->agent->ctx, &line, &len);
4859 if (!rc)
4860 rc = gpg_error (GPG_ERR_ASS_CANCELED);
4861 }
4862 }
4863
4864 assuan_set_flag (client->crypto->agent->ctx, ASSUAN_CONVEY_COMMENTS, 0);
4865 #endif
4866 return send_error (ctx, rc);
4867 }
4868
4869 void
4870 init_commands ()
4871 {
4872 /* !BEGIN-HELP-TEXT!
4873 *
4874 * This comment is used as a marker to generate the offline documentation
4875 * found in doc/pwmd.info. The indentation needs to be kept for the awk
4876 * script to determine where commands begin and end.
4877 */
4878 new_command("HELP", 1, 1, 0, help_command, _(
4879 "HELP [<COMMAND>]\n"
4880 "Show available commands or command specific help text."
4881 ));
4882
4883 new_command("AGENT", 1, 1, 0, agent_command, _(
4884 "AGENT <command>\n"
4885 "Send a @command{gpg-agent} protocol @var{command} directly to the "
4886 "@command{gpg-agent}."
4887 ));
4888
4889 new_command("KILL", 1, 0, 0, kill_command, _(
4890 "KILL <thread_id>\n"
4891 "Terminates the client identified by @var{thread_id} and releases any file "
4892 "lock or other resources it has held. See @code{GETINFO} (@pxref{GETINFO}) "
4893 "for details about listing connected clients. The @code{invoking_user} "
4894 "(@pxref{Configuration}) may kill any client while others may only kill "
4895 "clients of the same @code{UID} or @abbr{TLS} fingerprint.\n"
4896 ));
4897
4898 new_command("GETINFO", 1, 1, 0, getinfo_command, _(
4899 "GETINFO [--data] [--verbose] CACHE | CLIENTS | PID | USER | LAST_ERROR | VERSION\n"
4900 "Get server and other information: @var{CACHE} returns the number of cached "
4901 "documents via a status message. @var{CLIENTS} returns the number of "
4902 "connected clients via a status message or a list of connected clients when "
4903 "the @option{--verbose} parameter is used. The list contains space delimited "
4904 "fields: the thread ID, client name, opened file (@code{/} if none opened), "
4905 "file lock status, whether the current client is self, client state, "
4906 "user ID or TLS fingerprint of the connected client and username if the "
4907 "client is a local one. "
4908 "Client state @code{0} is an unknown client state, @code{1} indicates the "
4909 "client has connected but hasn't completed initializing, @code{2} indicates "
4910 "that the client is idle, @code{3} means the "
4911 "client is in a command and @code{4} means the client is disconnecting. This "
4912 "line is always returned with a data response. @var{PID} returns the process "
4913 "ID number of the server via a data response. @var{VERSION} returns the server "
4914 "version number and compile-time features with a data response with each "
4915 "being space delimited. @var{LAST_ERROR} returns a detailed description of "
4916 "the last failed command when available. @var{USER} returns the username or "
4917 "@abbr{TLS} hash of the connected client. @xref{Status Messages}. "
4918 "\n"
4919 "When the @option{--data} option is specified then the result will be sent "
4920 "via a data response rather than a status message."
4921 ));
4922
4923 new_command("PASSWD", 0, 0, FLOCK_TYPE_EX|FLOCK_TYPE_KEEP, passwd_command, _(
4924 "PASSWD [--reset] [--s2k-count=N] [--no-passphrase]\n"
4925 "Changes the passphrase of the secret key required to open the current "
4926 "file or the passphrase of a symmetrically encrypted data file. When the "
4927 "@option{--reset} option is passed then the cache entry for the current "
4928 "file will be reset and the passphrase, if any, will be required during the "
4929 "next @code{OPEN} (@pxref{OPEN})."
4930 "\n"
4931 "The @option{--s2k-count} option sets or changes (@pxref{SAVE}) the number "
4932 "of hash iterations for a passphrase and must be either @code{0} to use "
4933 "the calibrated count of the machine (the default), or a value greater than "
4934 "or equal to @code{65536}. This option has no effect for symmetrically "
4935 "encrypted data files."
4936 "\n"
4937 "The @option{--no-passphrase} option will prevent requiring a passphrase for "
4938 "the data file, although a passphrase may be required when changing it."
4939 "\n"
4940 "This command is not available for non-invoking clients "
4941 "(@pxref{Access Control})."
4942 ));
4943
4944 new_command("KEYGRIP", 1, 1, FLOCK_TYPE_SH|FLOCK_TYPE_KEEP, keygrip_command, _(
4945 "KEYGRIP [--sign] <filename>\n"
4946 "Returns the hex encoded keygrip of the specified @var{filename} with a "
4947 "data response."
4948 "\n"
4949 "When the @option{--sign} option is specified then the key used for signing "
4950 "of the specified @var{filename} will be returned."
4951 "\n"
4952 "For symmetrically encrypted data files this command returns the error "
4953 "GPG_ERR_NOT_SUPPORTED."
4954 ));
4955
4956 new_command("OPEN", 1, 1, FLOCK_TYPE_SH|FLOCK_TYPE_KEEP, open_command, _(
4957 "OPEN [--lock] <filename> [<passphrase>]\n"
4958 "Opens @var{filename} using @var{passphrase}. When the filename is not "
4959 "found on the file-system then a new document will be created. If the file "
4960 "is found, it is looked for in the file cache. If cached and no "
4961 "@var{passphrase} was specified then the cached document is opened. When not "
4962 "cached, @cite{pinentry(1)} will be used to retrieve the passphrase to use "
4963 "for decryption unless @option{disable-pinentry} (@pxref{OPTION}) was "
4964 "specified."
4965 "\n"
4966 "When the @option{--lock} option is passed then the file mutex will be "
4967 "locked as if the @code{LOCK} command (@pxref{LOCK}) had been sent after the "
4968 "file has been opened."
4969 ));
4970
4971 new_command("SAVE", 0, 0, FLOCK_TYPE_EX|FLOCK_TYPE_KEEP, save_command, _(
4972 "SAVE [--no-passphrase] [--reset] [--ask] [--no-agent] [--s2k-count=N] [--cipher=<algo>] [--cipher-iterations=N] [--inquire-keyparam] [--keygrip=hexstring] [--sign-keygrip=hexstring]\n"
4973 "Writes the @abbr{XML} document to disk. The file written to is the file that "
4974 "was opened using the @code{OPEN} command (@pxref{OPEN}). If the file is a "
4975 "new one or the option @option{--inquire-keyparam} was passed, then a new "
4976 "keypair will be generated and a pinentry will be used to prompt for the "
4977 "passphrase to encrypt with unless the @option{--no-passphrase} option was "
4978 "passed in which case the data file will not be passphrase protected. "
4979 "\n"
4980 "The @option{--no-agent} option disables use of @command{gpg-agent} for "
4981 "passphrase retrieval and caching of new files when @command{gpg-agent} "
4982 "use is enabled. The datafile will be symmetrically encrypted and will not "
4983 "use or generate any keypair."
4984 "\n"
4985 "The @option{--reset} option will clear the cache entry for the current file "
4986 "and require a passphrase, if needed, before saving."
4987 "\n"
4988 "The @option{--ask} option will prompt for the passphrase of the current file, "
4989 "if needed, before saving. This differs from the @option{--reset} option by "
4990 "keeping the cache entry in case of an invalid passphrase or some other failure "
4991 "which may otherwise cause a denial of service for other clients."
4992 "\n"
4993 "The @option{--cipher} option can be used to encrypt the @abbr{XML} data to "
4994 "an alternate cipher. The default is @code{aes256}. See the Configuration "
4995 "(@pxref{Configuration}) for available ciphers."
4996 "\n"
4997 "The @option{--cipher-iterations} option specifies the number of times to "
4998 "hash the passphrase before encrypting the XML data. The default is "
4999 "@code{5000000}. This option is an alias for @option{--s2k-count} since "
5000 "version @var{3.0.15} of @command{pwmd}."
5001 "\n"
5002 "The @option{--inquire-keyparam} option will send a server @emph{INQUIRE} to "
5003 "the client to obtain the key paramaters to use when generating a new "
5004 "keypair. The inquired data is expected to be an S-expression. If not "
5005 "specified then an @samp{RSA} key of @samp{2048} bits will be generated "
5006 "unless otherwise set in the configuration file (@pxref{Configuration}). Note "
5007 "that when this option is specified a new keypair will be generated "
5008 "reguardless if the file is a new one and that if the data file is protected "
5009 "the passphrase to open it will be required before generating the new "
5010 "keypair. This option is not available for non-invoking clients "
5011 "(@pxref{Access Control})."
5012 "\n"
5013 "You can encrypt the data file to a public key other than the one that it "
5014 "was originally encrypted with by passing the @option{--keygrip} option with "
5015 "the hex encoded keygrip of the public key as its argument. The keygrip may "
5016 "be of any key that @command{gpg-agent} knows about. The "
5017 "@option{--sign-keygrip} option may also be used to sign with an alternate "
5018 "secret key. Use the @code{KEYGRIP} (@pxref{KEYGRIP}) command to obtain the "
5019 "keygrip of an existing data file. This option may be needed when using a "
5020 "smartcard. This option has no effect with symmetrically encrypted data "
5021 "files. These options are not available for non-invoking clients "
5022 "(@pxref{Access Control})."
5023 "\n"
5024 "The @option{--s2k-count} option sets number of hash iterations for a "
5025 "passphrase. A value less-than @code{65536} will use the machine calibrated "
5026 "value and is the default when using @command{gpg-agent}. This setting only "
5027 "affects new files when using @command{gpg-agent}. To change the setting use "
5028 "the @code{PASSWD} command (@pxref{PASSWD}). This option is an alias for "
5029 "option @option{--cipher-iterations} when not using @command{gpg-agent}."
5030 ));
5031
5032 new_command("ISCACHED", 1, 0, 0, iscached_command, _(
5033 "ISCACHED [--lock] <filename>\n"
5034 "An @emph{OK} response is returned if the specified @var{filename} is found "
5035 "in the file cache. If not found in the cache but exists on the filesystem "
5036 "then @var{GPG_ERR_NO_DATA} is returned. Otherwise a filesystem error is "
5037 "returned."
5038 "\n"
5039 "The @option{lock} option will lock the file mutex of @var{filename} when the "
5040 "file exists; it does not need to be opened nor cached. The lock will be "
5041 "released when the client exits or sends the @code{UNLOCK} (@pxref{UNLOCK}) "
5042 "command."
5043 ));
5044
5045 new_command("CLEARCACHE", 1, 1, 0, clearcache_command, _(
5046 "CLEARCACHE [<filename>]\n"
5047 "Clears a file cache entry for all or the specified @var{filename}."
5048 ));
5049
5050 new_command("CACHETIMEOUT", 1, 1, 0, cachetimeout_command, _(
5051 "CACHETIMEOUT <filename> <seconds>\n"
5052 "The time in @var{seconds} until @var{filename} will be removed from the "
5053 "cache. @code{-1} will keep the cache entry forever, @code{0} will require "
5054 "the passphrase for each @code{OPEN} or @code{SAVE} command (@pxref{OPEN}, "
5055 "@pxref{SAVE}). @xref{Configuration}, and the @code{cache_timeout} "
5056 "parameter."
5057 ));
5058
5059 new_command("LIST", 0, 1, 0, list_command, _(
5060 "LIST [--inquire] [--no-recurse] [--verbose] [--with-target] [--all] [[!]element[<TAB>[!]child[..]]]\n"
5061 "If no element path is given then a newline separated list of root elements "
5062 "is returned with a data response. If given, then all reachable elements "
5063 "of the specified element path are returned unless the @option{--no-recurse} "
5064 "option is specified. If specified, only the child elements of the element "
5065 "path are returned without recursing into grandchildren. Each resulting "
5066 "element is prefixed with the literal @code{!} character when the element "
5067 "contains no @code{target} attribute. @xref{Target Attribute}, for details."
5068 "\n"
5069 "When the @option{--verbose} option is passed then each element path "
5070 "returned will have zero or more flags appened to it. These flags are "
5071 "delimited from the element path by a single space character. A flag itself "
5072 "is a single character. Flag @code{P} indicates that access to the element "
5073 "is denied. Flag @code{+} indicates that there are child nodes of "
5074 "the current element path. Flag @code{E} indicates that an element of an "
5075 "element path contained in a @var{target} attribute could not be found. Flag "
5076 "@code{O} indicates that a @var{target} attribute recursion limit was reached "
5077 "(@pxref{Configuration}). Flag @code{T} will append the resolved element path "
5078 "of the @var{target} attribute contained in the current element (see below)."
5079 "\n"
5080 "The @option{--with-target} option implies @option{--verbose} and will append "
5081 "an additional flag @code{T} followed by a single space then an element path. "
5082 "The appended element path is the resolved path (@pxref{REALPATH}) of the "
5083 "current element when it contains a @var{target} attribute. When no "
5084 "@var{target} attribute is found then no flag will be appended."
5085 "\n"
5086 "The @option{--no-recurse} option limits the amount of data returned to only "
5087 "the listing of children of the specified element path and not any "
5088 "grandchildren."
5089 "\n"
5090 "The @option{--all} option lists the entire element tree for each root "
5091 "element. This option also implies option @option{--verbose}."
5092 "\n"
5093 "When the @option{--inquire} option is passed then all remaining non-option "
5094 "arguments are retrieved via a server @emph{INQUIRE}."
5095 ));
5096
5097 new_command("REALPATH", 0, 1, 0, realpath_command, _(
5098 "REALPATH [--inquire] [!]element[<TAB>[!]child[..]]\n"
5099 "Resolves all @code{target} attributes of the specified element path and "
5100 "returns the result with a data response. @xref{Target Attribute}, for details."
5101 "\n"
5102 "When the @option{--inquire} option is passed then all remaining non-option "
5103 "arguments are retrieved via a server @emph{INQUIRE}."
5104 ));
5105
5106 new_command("STORE", 0, 1, 0, store_command, _(
5107 "STORE [!]element[<TAB>[!]child[..]]<TAB>[content]\n"
5108 "This command uses a server @emph{INQUIRE} to retrieve data from the client."
5109 "\n"
5110 "Creates a new element path or modifies the @var{content} of an existing "
5111 "element. If only a single element is specified then a new root element is "
5112 "created. Otherwise, elements are @key{TAB} delimited and the content will be "
5113 "set to the final @key{TAB} delimited element. If no @var{content} is "
5114 "specified after the final @key{TAB}, then the content of an existing "
5115 "element will be removed; or empty when creating a new element."
5116 "\n"
5117 "The only restriction of an element name is that it not contain whitespace "
5118 "or begin with the literal element character @code{!} unless specifying a "
5119 "literal element (@pxref{Target Attribute}). There is no whitespace between "
5120 "the @key{TAB} delimited elements. It is recommended that the content of an "
5121 "element be base64 encoded when it contains control or @key{TAB} characters "
5122 "to prevent @abbr{XML} parsing and @command{pwmd} syntax errors."
5123 ));
5124
5125 new_command("RENAME", 0, 1, 0, rename_command, _(
5126 "RENAME [--inquire] [!]element[<TAB>[!]child[..]] <value>\n"
5127 "Renames the specified @var{element} to the new @var{value}. If an element of "
5128 "the same name as the @var{value} already exists it will be overwritten."
5129 "\n"
5130 "When the @option{--inquire} option is passed then all remaining non-option "
5131 "arguments are retrieved via a server @emph{INQUIRE}."
5132 ));
5133
5134 new_command("COPY", 0, 1, 0, copy_command, _(
5135 "COPY [--inquire] [!]source[<TAB>[!]child[..]] [!]dest[<TAB>[!]child[..]]\n"
5136 "Copies the entire element tree starting from the child node of the source "
5137 "element, to the destination element path. If the destination element path "
5138 "does not exist then it will be created; otherwise it is overwritten."
5139 "\n"
5140 "Note that attributes from the source element are merged into the "
5141 "destination element when the destination element path exists. When an "
5142 "attribute of the same name exists in both the source and destination "
5143 "elements then the destination attribute will be updated to the source "
5144 "attribute value."
5145 "\n"
5146 "When the @option{--inquire} option is passed then all remaining non-option "
5147 "arguments are retrieved via a server @emph{INQUIRE}."
5148 ));
5149
5150 new_command("MOVE", 0, 1, 0, move_command, _(
5151 "MOVE [--inquire] [!]source[<TAB>[!]child[..]] [[!]dest[<TAB>[!]child[..]]]\n"
5152 "Moves the source element path to the destination element path. If the "
5153 "destination is not specified then it will be moved to the root node of the "
5154 "document. If the destination is specified and exists then it will be "
5155 "overwritten; otherwise non-existing elements of the destination element "
5156 "path will be created."
5157 "\n"
5158 "When the @option{--inquire} option is passed then all remaining non-option "
5159 "arguments are retrieved via a server @emph{INQUIRE}."
5160 ));
5161
5162 new_command("DELETE", 0, 1, 0, delete_command, _(
5163 "DELETE [--inquire] [!]element[<TAB>[!]child[..]]\n"
5164 "Removes the specified element path and all of its children. This may break "
5165 "an element with a @code{target} attribute (@pxref{Target Attribute}) that "
5166 "refers to this element or any of its children."
5167 "\n"
5168 "When the @option{--inquire} option is passed then all remaining non-option "
5169 "arguments are retrieved via a server @emph{INQUIRE}."
5170 ));
5171
5172 new_command("GET", 0, 1, 0, get_command, _(
5173 "GET [--inquire] [!]element[<TAB>[!]child[..]]\n"
5174 "Retrieves the content of the specified element. The content is returned "
5175 "with a data response."
5176 "\n"
5177 "When the @option{--inquire} option is passed then all remaining non-option "
5178 "arguments are retrieved via a server @emph{INQUIRE}."
5179 ));
5180
5181 new_command("ATTR", 0, 1, 0, attr_command, _(
5182 "ATTR [--inquire] SET|GET|DELETE|LIST [<attribute>] [!]element[<TAB>[!]child[..]] ..\n"
5183 "@table @asis\n"
5184 "@item ATTR SET attribute [!]element[<TAB>[!]child[..]] [value]\n"
5185 "\n"
5186 " Stores or updates an @var{attribute} name and optional @var{value} of an "
5187 "element. When no @var{value} is specified any existing value will be removed."
5188 "\n"
5189 "@item ATTR DELETE attribute [!]element[<TAB>[!]child[..]]\n"
5190 "\n"
5191 " Removes an @var{attribute} from an element."
5192 "\n"
5193 "@item ATTR LIST [!]element[<TAB>[!]child[..]]\n"
5194 "\n"
5195 " Retrieves a newline separated list of attributes names and values "
5196 "from the specified element. Each attribute name and value is space delimited."
5197 "\n"
5198 "@item ATTR GET attribute [!]element[<TAB>[!]child[..]]\n"
5199 "\n"
5200 " Retrieves the value of an @var{attribute} from an element."
5201 "@end table\n"
5202 "\n"
5203 "The @code{_name} attribute (case sensitive) cannot be removed nor modified. "
5204 "Use the @code{DELETE} (@pxref{DELETE}) or @code{RENAME} (@pxref{RENAME}) "
5205 "commands instead."
5206 "\n"
5207 "The @code{_mtime} attribute is updated each time an element is modified by "
5208 "either storing content, editing attributes or by deleting a child element. "
5209 "The @code{_ctime} attribute is created for each new element in an element "
5210 "path."
5211 "\n"
5212 "When the @option{--inquire} option is passed then all remaining non-option "
5213 "arguments are retrieved via a server @emph{INQUIRE}."
5214 "\n"
5215 "@xref{Target Attribute}, for details about this special attribute."
5216 ));
5217
5218 new_command("XPATH", 0, 1, 0, xpath_command, _(
5219 "XPATH [--inquire] <expression>[<TAB>[value]]\n"
5220 "Evaluates an XPath @var{expression}. If no @var{value} argument is "
5221 "specified it is assumed the expression is a request to return a result. "
5222 "Otherwise, the result is set to the @var{value} argument and the document is "
5223 "updated. If there is no @var{value} after the @key{TAB} character, the value "
5224 "is assumed to be empty and the document is updated. For example:"
5225 "@sp 1\n"
5226 "@example\n"
5227 "XPATH //element[@@_name='password']@key{TAB}\n"
5228 "@end example\n"
5229 "@sp 1"
5230 "would clear the content of all @code{password} elements in the data file "
5231 "while leaving off the trailing @key{TAB} would return all @code{password} "
5232 "elements in @abbr{XML} format."
5233 "\n"
5234 "When the @option{--inquire} option is passed then all remaining non-option "
5235 "arguments are retrieved via a server @emph{INQUIRE}."
5236 "\n"
5237 "See @url{http://www.w3schools.com/xpath/xpath_syntax.asp} for @abbr{XPATH} "
5238 "expression syntax."
5239 ));
5240
5241 new_command("XPATHATTR", 0, 1, 0, xpathattr_command, _(
5242 "XPATHATTR [--inquire] SET|DELETE <name> <expression>[<TAB>[<value>]]\n"
5243 "Like the @code{XPATH} command (@pxref{XPATH}) but operates on element "
5244 "attributes and does not return a result. For the @var{SET} operation the "
5245 "@var{value} is optional but the field is required. If not specified then "
5246 "the attribute value will be empty. For example:"
5247 "@sp 1"
5248 "@example\n"
5249 "XPATHATTR SET password //element[@@_name='password']@key{TAB}\n"
5250 "@end example\n"
5251 "@sp 1"
5252 "would create an @code{password} attribute for each @code{password} element "
5253 "found in the document. The attribute value will be empty but still exist."
5254 "\n"
5255 "When the @option{--inquire} option is passed then all remaining non-option "
5256 "arguments are retrieved via a server @emph{INQUIRE}."
5257 "\n"
5258 "See @url{http://www.w3schools.com/xpath/xpath_syntax.asp} for @abbr{XPATH} "
5259 "expression syntax."
5260 ));
5261
5262 new_command("IMPORT", 0, 1, 0, import_command, _(
5263 "IMPORT [--root=[!]element[<TAB>[!]child[..]]] <content>\n"
5264 "This command uses a server @emph{INQUIRE} to retrieve data from the client."
5265 "\n"
5266 "Like the @code{STORE} command (@pxref{STORE}), but the @var{content} "
5267 "argument is raw @abbr{XML} data. The content is created as a child of "
5268 "the element path specified with the @option{--root} option or at the "
5269 "document root when not specified. Existing elements of the same name will "
5270 "be overwritten."
5271 "\n"
5272 "The content must begin with an @abbr{XML} element node. @xref{Introduction}, "
5273 "for details."
5274 ));
5275
5276 new_command("DUMP", 0, 1, 0, dump_command, _(
5277 "DUMP\n"
5278 "Shows the in memory @abbr{XML} document with indenting. @xref{XPATH}, for "
5279 "dumping a specific node."
5280 ));
5281
5282 new_command("LOCK", 0, 0, 0, lock_command, _(
5283 "LOCK\n"
5284 "Locks the mutex associated with the opened file. This prevents other clients "
5285 "from sending commands to the same opened file until the client "
5286 "that sent this command either disconnects or sends the @code{UNLOCK} "
5287 "command. @xref{UNLOCK}."
5288 ));
5289
5290 new_command("UNLOCK", 1, 0, 0, unlock_command, _(
5291 "UNLOCK\n"
5292 "Unlocks the file mutex which was locked with the @code{LOCK} command or "
5293 "a commands' @option{--lock} option (@pxref{LOCK}, @pxref{OPEN}, "
5294 "@pxref{ISCACHED})."
5295 ));
5296
5297 new_command("GETCONFIG", 1, 1, FLOCK_TYPE_SH|FLOCK_TYPE_KEEP, getconfig_command, _(
5298 "GETCONFIG [filename] <parameter>\n"
5299 "Returns the value of a @command{pwmd} configuration @var{parameter} with a "
5300 "data response. If no file has been opened then the value for @var{filename} "
5301 "or the default from the @samp{global} section will be returned. If a file "
5302 "has been opened and no @var{filename} is specified, a value previously "
5303 "set with the @code{OPTION} command (@pxref{OPTION}) will be returned."
5304 ));
5305
5306 new_command("OPTION", 1, 1, 0, option_command, _(
5307 "OPTION <NAME>=<VALUE>\n"
5308 "Sets a client option @var{name} to @var{value}. The value for an option is "
5309 "kept for the duration of the connection."
5310 "\n"
5311 "@table @asis\n"
5312 "@item DISABLE-PINENTRY\n"
5313 "Disable use of @command{pinentry} for passphrase retrieval. When set, a "
5314 "server inquire is sent to the client to obtain the passphrase. This option "
5315 "may be set as needed before the @code{OPEN} (@pxref{OPEN}), @code{PASSWD} "
5316 "(@pxref{PASSWD}) and @code{SAVE} (@pxref{SAVE}) commands."
5317 "\n"
5318 "@item PINENTRY-TIMEOUT\n"
5319 "Sets the number of seconds before a pinentry prompt will return an error "
5320 "while waiting for user input."
5321 "\n"
5322 "@item TTYNAME\n"
5323 "Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
5324 "\n"
5325 "@item TTYTYPE\n"
5326 "Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
5327 "\n"
5328 "@item DISPLAY\n"
5329 "Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
5330 "\n"
5331 "@item PINENTRY-DESC\n"
5332 "Sets the description string of the @command{gpg-agent} and @command{pinentry} dialog."
5333 "\n"
5334 "@item PINENTRY-TITLE\n"
5335 "Sets the title string of the @command{gpg-agent} and @command{pinentry} dialog."
5336 "\n"
5337 "@item PINENTRY-PROMPT\n"
5338 "Sets the prompt string of the @command{gpg-agent} and @command{pinentry} dialog."
5339 "\n"
5340 "@item LC-CTYPE\n"
5341 "Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
5342 "\n"
5343 "@item LC-MESSAGES\n"
5344 "Passed to the @command{gpg-agent} and used for the @command{pinentry} dialog."
5345 "\n"
5346 "@item NAME\n"
5347 "Associates the thread ID of the connection with the specified textual "
5348 "representation. Useful for debugging log messages. May not contain whitespace."
5349 "\n"
5350 "@item LOCK-TIMEOUT\n"
5351 "When not @code{0}, the duration in tenths of a second to wait for the file "
5352 "mutex which has been locked by another thread to be released before returning "
5353 "an error. When @code{-1}, then an error will be returned immediately."
5354 "@end table\n"
5355 ));
5356
5357 new_command("LS", 1, 1, 0, ls_command, _(
5358 "LS\n"
5359 "Lists the available data files stored in the data directory "
5360 "(@file{~/.pwmd/data}). The result is a newline separated list of filenames."
5361 ));
5362
5363 new_command("RESET", 1, 1, 0, NULL, _(
5364 "RESET\n"
5365 "Closes the currently opened file but keeps any previously set client options."
5366 ));
5367
5368 new_command("NOP", 1, 1, 0, NULL, _(
5369 "NOP\n"
5370 "Does nothing. Always returns successfully."
5371 ));
5372
5373 /* !END-HELP-TEXT! */
5374 new_command ("CANCEL", 1, 1, 0, NULL, NULL);
5375 new_command ("END", 1, 1, 0, NULL, NULL);
5376 new_command ("BYE", 1, 1, 0, NULL, NULL);
5377
5378 int i;
5379 for (i = 0; command_table[i]; i++);
5380 qsort (command_table, i - 1, sizeof (struct command_table_s *),
5381 sort_commands);
5382 }
5383
5384 gpg_error_t
5385 register_commands (assuan_context_t ctx)
5386 {
5387 int i = 0, rc;
5388
5389 for (; command_table[i]; i++)
5390 {
5391 if (!command_table[i]->handler)
5392 continue;
5393
5394 rc = assuan_register_command (ctx, command_table[i]->name,
5395 command_table[i]->handler,
5396 command_table[i]->help);
5397 if (rc)
5398 return rc;
5399 }
5400
5401 rc = assuan_register_bye_notify (ctx, bye_notify);
5402 if (rc)
5403 return rc;
5404
5405 rc = assuan_register_reset_notify (ctx, reset_notify);
5406 if (rc)
5407 return rc;
5408
5409 rc = assuan_register_pre_cmd_notify (ctx, command_startup);
5410 if (rc)
5411 return rc;
5412
5413 return assuan_register_post_cmd_notify (ctx, command_finalize);
5414 }
A server for managing passphrases and anything else.