common: Use new function to print status strings.
[gnupg.git] / agent / command.c
1 /* command.c - gpg-agent command handler
2  * Copyright (C) 2001-2011 Free Software Foundation, Inc.
3  * Copyright (C) 2001-2013 Werner Koch
4  * Copyright (C) 2015 g10 Code GmbH.
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 /* FIXME: we should not use the default assuan buffering but setup
23    some buffering in secure mempory to protect session keys etc. */
24
25 #include <config.h>
26
27 #include <errno.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <ctype.h>
32 #include <unistd.h>
33 #include <assert.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <dirent.h>
37
38 #include "agent.h"
39 #include <assuan.h>
40 #include "../common/i18n.h"
41 #include "cvt-openpgp.h"
42 #include "../common/ssh-utils.h"
43 #include "../common/asshelp.h"
44 #include "../common/server-help.h"
45
46
47 /* Maximum allowed size of the inquired ciphertext.  */
48 #define MAXLEN_CIPHERTEXT 4096
49 /* Maximum allowed size of the key parameters.  */
50 #define MAXLEN_KEYPARAM 1024
51 /* Maximum allowed size of key data as used in inquiries (bytes). */
52 #define MAXLEN_KEYDATA 8192
53 /* The size of the import/export KEK key (in bytes).  */
54 #define KEYWRAP_KEYSIZE (128/8)
55
56 /* A shortcut to call assuan_set_error using an gpg_err_code_t and a
57    text string.  */
58 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
59
60 /* Check that the maximum digest length we support has at least the
61    length of the keygrip.  */
62 #if MAX_DIGEST_LEN < 20
63 #error MAX_DIGEST_LEN shorter than keygrip
64 #endif
65
66 /* Data used to associate an Assuan context with local server data.
67    This is this modules local part of the server_control_s struct.  */
68 struct server_local_s
69 {
70   /* Our Assuan context.  */
71   assuan_context_t assuan_ctx;
72
73   /* If this flag is true, the passphrase cache is used for signing
74      operations.  It defaults to true but may be set on a per
75      connection base.  The global option opt.ignore_cache_for_signing
76      takes precedence over this flag.  */
77   unsigned int use_cache_for_signing : 1;
78
79   /* Flag to suppress I/O logging during a command.  */
80   unsigned int pause_io_logging : 1;
81
82   /* Flag indicating that the connection is from ourselves.  */
83   unsigned int connect_from_self : 1;
84
85   /* Helper flag for io_monitor to allow suppressing of our own
86    * greeting in some cases.  See io_monitor for details.  */
87   unsigned int greeting_seen : 1;
88
89   /* If this flag is set to true the agent will be terminated after
90      the end of the current session.  */
91   unsigned int stopme : 1;
92
93   /* Flag indicating whether pinentry notifications shall be done. */
94   unsigned int allow_pinentry_notify : 1;
95
96   /* An allocated description for the next key operation.  This is
97      used if a pinnetry needs to be popped up.  */
98   char *keydesc;
99
100   /* Malloced KEK (Key-Encryption-Key) for the import_key command.  */
101   void *import_key;
102
103   /* Malloced KEK for the export_key command.  */
104   void *export_key;
105
106   /* Client is aware of the error code GPG_ERR_FULLY_CANCELED.  */
107   int allow_fully_canceled;
108
109   /* Last CACHE_NONCE sent as status (malloced).  */
110   char *last_cache_nonce;
111
112   /* Last PASSWD_NONCE sent as status (malloced). */
113   char *last_passwd_nonce;
114 };
115
116
117 /* An entry for the getval/putval commands. */
118 struct putval_item_s
119 {
120   struct putval_item_s *next;
121   size_t off;  /* Offset to the value into DATA.  */
122   size_t len;  /* Length of the value.  */
123   char d[1];   /* Key | Nul | value.  */
124 };
125
126
127 /* A list of key value pairs fpr the getval/putval commands.  */
128 static struct putval_item_s *putval_list;
129
130
131 \f
132 /* To help polling clients, we keep track of the number of certain
133    events.  This structure keeps those counters.  The counters are
134    integers and there should be no problem if they are overflowing as
135    callers need to check only whether a counter changed.  The actual
136    values are not meaningful. */
137 struct
138 {
139   /* Incremented if any of the other counters below changed. */
140   unsigned int any;
141
142   /* Incremented if a key is added or removed from the internal privat
143      key database. */
144   unsigned int key;
145
146   /* Incremented if a change of the card readers stati has been
147      detected. */
148   unsigned int card;
149
150 } eventcounter;
151
152
153 \f
154 /*  Local prototypes.  */
155 static int command_has_option (const char *cmd, const char *cmdopt);
156
157
158
159 \f
160 /* Release the memory buffer MB but first wipe out the used memory. */
161 static void
162 clear_outbuf (membuf_t *mb)
163 {
164   void *p;
165   size_t n;
166
167   p = get_membuf (mb, &n);
168   if (p)
169     {
170       wipememory (p, n);
171       xfree (p);
172     }
173 }
174
175
176 /* Write the content of memory buffer MB as assuan data to CTX and
177    wipe the buffer out afterwards. */
178 static gpg_error_t
179 write_and_clear_outbuf (assuan_context_t ctx, membuf_t *mb)
180 {
181   gpg_error_t ae;
182   void *p;
183   size_t n;
184
185   p = get_membuf (mb, &n);
186   if (!p)
187     return out_of_core ();
188   ae = assuan_send_data (ctx, p, n);
189   memset (p, 0, n);
190   xfree (p);
191   return ae;
192 }
193
194
195 /* Clear the nonces used to enable the passphrase cache for certain
196    multi-command command sequences.  */
197 static void
198 clear_nonce_cache (ctrl_t ctrl)
199 {
200   if (ctrl->server_local->last_cache_nonce)
201     {
202       agent_put_cache (ctrl->server_local->last_cache_nonce,
203                        CACHE_MODE_NONCE, NULL, 0);
204       xfree (ctrl->server_local->last_cache_nonce);
205       ctrl->server_local->last_cache_nonce = NULL;
206     }
207   if (ctrl->server_local->last_passwd_nonce)
208     {
209       agent_put_cache (ctrl->server_local->last_passwd_nonce,
210                        CACHE_MODE_NONCE, NULL, 0);
211       xfree (ctrl->server_local->last_passwd_nonce);
212       ctrl->server_local->last_passwd_nonce = NULL;
213     }
214 }
215
216
217 /* This function is called by Libassuan whenever the client sends a
218    reset.  It has been registered similar to the other Assuan
219    commands.  */
220 static gpg_error_t
221 reset_notify (assuan_context_t ctx, char *line)
222 {
223   ctrl_t ctrl = assuan_get_pointer (ctx);
224
225   (void) line;
226
227   memset (ctrl->keygrip, 0, 20);
228   ctrl->have_keygrip = 0;
229   ctrl->digest.valuelen = 0;
230
231   xfree (ctrl->server_local->keydesc);
232   ctrl->server_local->keydesc = NULL;
233
234   clear_nonce_cache (ctrl);
235
236   return 0;
237 }
238
239
240 /* Replace all '+' by a blank in the string S. */
241 static void
242 plus_to_blank (char *s)
243 {
244   for (; *s; s++)
245     {
246       if (*s == '+')
247         *s = ' ';
248     }
249 }
250
251
252 /* Parse a hex string.  Return an Assuan error code or 0 on success and the
253    length of the parsed string in LEN. */
254 static int
255 parse_hexstring (assuan_context_t ctx, const char *string, size_t *len)
256 {
257   const char *p;
258   size_t n;
259
260   /* parse the hash value */
261   for (p=string, n=0; hexdigitp (p); p++, n++)
262     ;
263   if (*p != ' ' && *p != '\t' && *p)
264     return set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
265   if ((n&1))
266     return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
267   *len = n;
268   return 0;
269 }
270
271
272 /* Parse the keygrip in STRING into the provided buffer BUF.  BUF must
273    provide space for 20 bytes.  BUF is not changed if the function
274    returns an error. */
275 static int
276 parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
277 {
278   int rc;
279   size_t n = 0;
280
281   rc = parse_hexstring (ctx, string, &n);
282   if (rc)
283     return rc;
284   n /= 2;
285   if (n != 20)
286     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of keygrip");
287
288   if (hex2bin (string, buf, 20) < 0)
289     return set_error (GPG_ERR_BUG, "hex2bin");
290
291   return 0;
292 }
293
294
295 /* Write an Assuan status line.  KEYWORD is the first item on the
296  * status line.  The following arguments are all separated by a space
297  * in the output.  The last argument must be a NULL.  Linefeeds and
298  * carriage returns characters (which are not allowed in an Assuan
299  * status line) are silently quoted in C-style.  */
300 gpg_error_t
301 agent_write_status (ctrl_t ctrl, const char *keyword, ...)
302 {
303   gpg_error_t err;
304   va_list arg_ptr;
305   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
306
307   va_start (arg_ptr, keyword);
308   err = vprint_assuan_status_strings (ctx, keyword, arg_ptr);
309   va_end (arg_ptr);
310   return err;
311 }
312
313
314 /* This function is similar to print_assuan_status but takes a CTRL
315    arg instead of an assuan context as first argument.  */
316 gpg_error_t
317 agent_print_status (ctrl_t ctrl, const char *keyword, const char *format, ...)
318 {
319   gpg_error_t err;
320   va_list arg_ptr;
321   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
322
323   va_start (arg_ptr, format);
324   err = vprint_assuan_status (ctx, keyword, format, arg_ptr);
325   va_end (arg_ptr);
326   return err;
327 }
328
329
330 /* Helper to notify the client about a launched Pinentry.  Because
331    that might disturb some older clients, this is only done if enabled
332    via an option.  Returns an gpg error code. */
333 gpg_error_t
334 agent_inq_pinentry_launched (ctrl_t ctrl, unsigned long pid, const char *extra)
335 {
336   char line[256];
337
338   if (!ctrl || !ctrl->server_local
339       || !ctrl->server_local->allow_pinentry_notify)
340     return 0;
341   snprintf (line, DIM(line), "PINENTRY_LAUNCHED %lu%s%s",
342             pid, extra?" ":"", extra? extra:"");
343   return assuan_inquire (ctrl->server_local->assuan_ctx, line, NULL, NULL, 0);
344 }
345
346
347 /* An agent progress callback for Libgcrypt.  This has been registered
348  * to be called via the progress dispatcher mechanism from
349  * gpg-agent.c  */
350 static void
351 progress_cb (ctrl_t ctrl, const char *what, int printchar,
352              int current, int total)
353 {
354   if (!ctrl || !ctrl->server_local || !ctrl->server_local->assuan_ctx)
355     ;
356   else if (printchar == '\n' && what && !strcmp (what, "primegen"))
357     agent_print_status (ctrl, "PROGRESS", "%.20s X 100 100", what);
358   else
359     agent_print_status (ctrl, "PROGRESS", "%.20s %c %d %d",
360                         what, printchar=='\n'?'X':printchar, current, total);
361 }
362
363
364 /* Helper to print a message while leaving a command.  Note that this
365  * function does not call assuan_set_error; the caller may do this
366  * prior to calling us.  */
367 static gpg_error_t
368 leave_cmd (assuan_context_t ctx, gpg_error_t err)
369 {
370   if (err)
371     {
372       const char *name = assuan_get_command_name (ctx);
373       if (!name)
374         name = "?";
375
376       /* Not all users of gpg-agent know about the fully canceled
377          error code; map it back if needed.  */
378       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
379         {
380           ctrl_t ctrl = assuan_get_pointer (ctx);
381
382           if (!ctrl->server_local->allow_fully_canceled)
383             err = gpg_err_make (gpg_err_source (err), GPG_ERR_CANCELED);
384         }
385
386       /* Most code from common/ does not know the error source, thus
387          we fix this here.  */
388       if (gpg_err_source (err) == GPG_ERR_SOURCE_UNKNOWN)
389         err = gpg_err_make (GPG_ERR_SOURCE_DEFAULT, gpg_err_code (err));
390
391       if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
392         log_error ("command '%s' failed: %s\n", name,
393                    gpg_strerror (err));
394       else
395         log_error ("command '%s' failed: %s <%s>\n", name,
396                    gpg_strerror (err), gpg_strsource (err));
397     }
398   return err;
399 }
400
401
402 \f
403 static const char hlp_geteventcounter[] =
404   "GETEVENTCOUNTER\n"
405   "\n"
406   "Return a status line named EVENTCOUNTER with the current values\n"
407   "of all event counters.  The values are decimal numbers in the range\n"
408   "0 to UINT_MAX and wrapping around to 0.  The actual values should\n"
409   "not be relied upon, they shall only be used to detect a change.\n"
410   "\n"
411   "The currently defined counters are:\n"
412   "\n"
413   "ANY  - Incremented with any change of any of the other counters.\n"
414   "KEY  - Incremented for added or removed private keys.\n"
415   "CARD - Incremented for changes of the card readers stati.";
416 static gpg_error_t
417 cmd_geteventcounter (assuan_context_t ctx, char *line)
418 {
419   ctrl_t ctrl = assuan_get_pointer (ctx);
420
421   (void)line;
422
423   if (ctrl->restricted)
424     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
425
426   return agent_print_status (ctrl, "EVENTCOUNTER", "%u %u %u",
427                              eventcounter.any,
428                              eventcounter.key,
429                              eventcounter.card);
430 }
431
432
433 /* This function should be called once for all key removals or
434    additions.  This function is assured not to do any context
435    switches. */
436 void
437 bump_key_eventcounter (void)
438 {
439   eventcounter.key++;
440   eventcounter.any++;
441 }
442
443
444 /* This function should be called for all card reader status
445    changes.  This function is assured not to do any context
446    switches. */
447 void
448 bump_card_eventcounter (void)
449 {
450   eventcounter.card++;
451   eventcounter.any++;
452 }
453
454
455
456 \f
457 static const char hlp_istrusted[] =
458   "ISTRUSTED <hexstring_with_fingerprint>\n"
459   "\n"
460   "Return OK when we have an entry with this fingerprint in our\n"
461   "trustlist";
462 static gpg_error_t
463 cmd_istrusted (assuan_context_t ctx, char *line)
464 {
465   ctrl_t ctrl = assuan_get_pointer (ctx);
466   int rc, n, i;
467   char *p;
468   char fpr[41];
469
470   /* Parse the fingerprint value. */
471   for (p=line,n=0; hexdigitp (p); p++, n++)
472     ;
473   if (*p || !(n == 40 || n == 32))
474     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
475   i = 0;
476   if (n==32)
477     {
478       strcpy (fpr, "00000000");
479       i += 8;
480     }
481   for (p=line; i < 40; p++, i++)
482     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
483   fpr[i] = 0;
484   rc = agent_istrusted (ctrl, fpr, NULL);
485   if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
486     return rc;
487   else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF )
488     return gpg_error (GPG_ERR_NOT_TRUSTED);
489   else
490     return leave_cmd (ctx, rc);
491 }
492
493
494 static const char hlp_listtrusted[] =
495   "LISTTRUSTED\n"
496   "\n"
497   "List all entries from the trustlist.";
498 static gpg_error_t
499 cmd_listtrusted (assuan_context_t ctx, char *line)
500 {
501   ctrl_t ctrl = assuan_get_pointer (ctx);
502   int rc;
503
504   (void)line;
505
506   if (ctrl->restricted)
507     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
508
509   rc = agent_listtrusted (ctx);
510   return leave_cmd (ctx, rc);
511 }
512
513
514 static const char hlp_martrusted[] =
515   "MARKTRUSTED <hexstring_with_fingerprint> <flag> <display_name>\n"
516   "\n"
517   "Store a new key in into the trustlist.";
518 static gpg_error_t
519 cmd_marktrusted (assuan_context_t ctx, char *line)
520 {
521   ctrl_t ctrl = assuan_get_pointer (ctx);
522   int rc, n, i;
523   char *p;
524   char fpr[41];
525   int flag;
526
527   if (ctrl->restricted)
528     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
529
530   /* parse the fingerprint value */
531   for (p=line,n=0; hexdigitp (p); p++, n++)
532     ;
533   if (!spacep (p) || !(n == 40 || n == 32))
534     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
535   i = 0;
536   if (n==32)
537     {
538       strcpy (fpr, "00000000");
539       i += 8;
540     }
541   for (p=line; i < 40; p++, i++)
542     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
543   fpr[i] = 0;
544
545   while (spacep (p))
546     p++;
547   flag = *p++;
548   if ( (flag != 'S' && flag != 'P') || !spacep (p) )
549     return set_error (GPG_ERR_ASS_PARAMETER, "invalid flag - must be P or S");
550   while (spacep (p))
551     p++;
552
553   rc = agent_marktrusted (ctrl, p, fpr, flag);
554   return leave_cmd (ctx, rc);
555 }
556
557
558
559 \f
560 static const char hlp_havekey[] =
561   "HAVEKEY <hexstrings_with_keygrips>\n"
562   "\n"
563   "Return success if at least one of the secret keys with the given\n"
564   "keygrips is available.";
565 static gpg_error_t
566 cmd_havekey (assuan_context_t ctx, char *line)
567 {
568   gpg_error_t err;
569   unsigned char buf[20];
570
571   do
572     {
573       err = parse_keygrip (ctx, line, buf);
574       if (err)
575         return err;
576
577       if (!agent_key_available (buf))
578         return 0; /* Found.  */
579
580       while (*line && *line != ' ' && *line != '\t')
581         line++;
582       while (*line == ' ' || *line == '\t')
583         line++;
584     }
585   while (*line);
586
587   /* No leave_cmd() here because errors are expected and would clutter
588      the log.  */
589   return gpg_error (GPG_ERR_NO_SECKEY);
590 }
591
592
593 static const char hlp_sigkey[] =
594   "SIGKEY <hexstring_with_keygrip>\n"
595   "SETKEY <hexstring_with_keygrip>\n"
596   "\n"
597   "Set the  key used for a sign or decrypt operation.";
598 static gpg_error_t
599 cmd_sigkey (assuan_context_t ctx, char *line)
600 {
601   int rc;
602   ctrl_t ctrl = assuan_get_pointer (ctx);
603
604   rc = parse_keygrip (ctx, line, ctrl->keygrip);
605   if (rc)
606     return rc;
607   ctrl->have_keygrip = 1;
608   return 0;
609 }
610
611
612 static const char hlp_setkeydesc[] =
613   "SETKEYDESC plus_percent_escaped_string\n"
614   "\n"
615   "Set a description to be used for the next PKSIGN, PKDECRYPT, IMPORT_KEY\n"
616   "or EXPORT_KEY operation if this operation requires a passphrase.  If\n"
617   "this command is not used a default text will be used.  Note, that\n"
618   "this description implictly selects the label used for the entry\n"
619   "box; if the string contains the string PIN (which in general will\n"
620   "not be translated), \"PIN\" is used, otherwise the translation of\n"
621   "\"passphrase\" is used.  The description string should not contain\n"
622   "blanks unless they are percent or '+' escaped.\n"
623   "\n"
624   "The description is only valid for the next PKSIGN, PKDECRYPT,\n"
625   "IMPORT_KEY, EXPORT_KEY, or DELETE_KEY operation.";
626 static gpg_error_t
627 cmd_setkeydesc (assuan_context_t ctx, char *line)
628 {
629   ctrl_t ctrl = assuan_get_pointer (ctx);
630   char *desc, *p;
631
632   for (p=line; *p == ' '; p++)
633     ;
634   desc = p;
635   p = strchr (desc, ' ');
636   if (p)
637     *p = 0; /* We ignore any garbage; we might late use it for other args. */
638
639   if (!*desc)
640     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
641
642   /* Note, that we only need to replace the + characters and should
643      leave the other escaping in place because the escaped string is
644      send verbatim to the pinentry which does the unescaping (but not
645      the + replacing) */
646   plus_to_blank (desc);
647
648   xfree (ctrl->server_local->keydesc);
649
650   if (ctrl->restricted)
651     {
652       ctrl->server_local->keydesc = strconcat
653         ((ctrl->restricted == 2
654          ? _("Note: Request from the web browser.")
655          : _("Note: Request from a remote site.")  ), "%0A%0A", desc, NULL);
656     }
657   else
658     ctrl->server_local->keydesc = xtrystrdup (desc);
659   if (!ctrl->server_local->keydesc)
660     return out_of_core ();
661   return 0;
662 }
663
664
665 static const char hlp_sethash[] =
666   "SETHASH (--hash=<name>)|(<algonumber>) <hexstring>\n"
667   "\n"
668   "The client can use this command to tell the server about the data\n"
669   "(which usually is a hash) to be signed.";
670 static gpg_error_t
671 cmd_sethash (assuan_context_t ctx, char *line)
672 {
673   int rc;
674   size_t n;
675   char *p;
676   ctrl_t ctrl = assuan_get_pointer (ctx);
677   unsigned char *buf;
678   char *endp;
679   int algo;
680
681   /* Parse the alternative hash options which may be used instead of
682      the algo number.  */
683   if (has_option_name (line, "--hash"))
684     {
685       if (has_option (line, "--hash=sha1"))
686         algo = GCRY_MD_SHA1;
687       else if (has_option (line, "--hash=sha224"))
688         algo = GCRY_MD_SHA224;
689       else if (has_option (line, "--hash=sha256"))
690         algo = GCRY_MD_SHA256;
691       else if (has_option (line, "--hash=sha384"))
692         algo = GCRY_MD_SHA384;
693       else if (has_option (line, "--hash=sha512"))
694         algo = GCRY_MD_SHA512;
695       else if (has_option (line, "--hash=rmd160"))
696         algo = GCRY_MD_RMD160;
697       else if (has_option (line, "--hash=md5"))
698         algo = GCRY_MD_MD5;
699       else if (has_option (line, "--hash=tls-md5sha1"))
700         algo = MD_USER_TLS_MD5SHA1;
701       else
702         return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
703     }
704   else
705     algo = 0;
706
707   line = skip_options (line);
708
709   if (!algo)
710     {
711       /* No hash option has been given: require an algo number instead  */
712       algo = (int)strtoul (line, &endp, 10);
713       for (line = endp; *line == ' ' || *line == '\t'; line++)
714         ;
715       if (!algo || gcry_md_test_algo (algo))
716         return set_error (GPG_ERR_UNSUPPORTED_ALGORITHM, NULL);
717     }
718   ctrl->digest.algo = algo;
719   ctrl->digest.raw_value = 0;
720
721   /* Parse the hash value. */
722   n = 0;
723   rc = parse_hexstring (ctx, line, &n);
724   if (rc)
725     return rc;
726   n /= 2;
727   if (algo == MD_USER_TLS_MD5SHA1 && n == 36)
728     ;
729   else if (n != 16 && n != 20 && n != 24
730            && n != 28 && n != 32 && n != 48 && n != 64)
731     return set_error (GPG_ERR_ASS_PARAMETER, "unsupported length of hash");
732
733   if (n > MAX_DIGEST_LEN)
734     return set_error (GPG_ERR_ASS_PARAMETER, "hash value to long");
735
736   buf = ctrl->digest.value;
737   ctrl->digest.valuelen = n;
738   for (p=line, n=0; n < ctrl->digest.valuelen; p += 2, n++)
739     buf[n] = xtoi_2 (p);
740   for (; n < ctrl->digest.valuelen; n++)
741     buf[n] = 0;
742   return 0;
743 }
744
745
746 static const char hlp_pksign[] =
747   "PKSIGN [<options>] [<cache_nonce>]\n"
748   "\n"
749   "Perform the actual sign operation.  Neither input nor output are\n"
750   "sensitive to eavesdropping.";
751 static gpg_error_t
752 cmd_pksign (assuan_context_t ctx, char *line)
753 {
754   gpg_error_t err;
755   cache_mode_t cache_mode = CACHE_MODE_NORMAL;
756   ctrl_t ctrl = assuan_get_pointer (ctx);
757   membuf_t outbuf;
758   char *cache_nonce = NULL;
759   char *p;
760
761   line = skip_options (line);
762
763   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
764     ;
765   *p = '\0';
766   if (*line)
767     cache_nonce = xtrystrdup (line);
768
769   if (opt.ignore_cache_for_signing)
770     cache_mode = CACHE_MODE_IGNORE;
771   else if (!ctrl->server_local->use_cache_for_signing)
772     cache_mode = CACHE_MODE_IGNORE;
773
774   init_membuf (&outbuf, 512);
775
776   err = agent_pksign (ctrl, cache_nonce, ctrl->server_local->keydesc,
777                       &outbuf, cache_mode);
778   if (err)
779     clear_outbuf (&outbuf);
780   else
781     err = write_and_clear_outbuf (ctx, &outbuf);
782
783   xfree (cache_nonce);
784   xfree (ctrl->server_local->keydesc);
785   ctrl->server_local->keydesc = NULL;
786   return leave_cmd (ctx, err);
787 }
788
789
790 static const char hlp_pkdecrypt[] =
791   "PKDECRYPT [<options>]\n"
792   "\n"
793   "Perform the actual decrypt operation.  Input is not\n"
794   "sensitive to eavesdropping.";
795 static gpg_error_t
796 cmd_pkdecrypt (assuan_context_t ctx, char *line)
797 {
798   int rc;
799   ctrl_t ctrl = assuan_get_pointer (ctx);
800   unsigned char *value;
801   size_t valuelen;
802   membuf_t outbuf;
803   int padding;
804
805   (void)line;
806
807   /* First inquire the data to decrypt */
808   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_CIPHERTEXT);
809   if (!rc)
810     rc = assuan_inquire (ctx, "CIPHERTEXT",
811                         &value, &valuelen, MAXLEN_CIPHERTEXT);
812   if (rc)
813     return rc;
814
815   init_membuf (&outbuf, 512);
816
817   rc = agent_pkdecrypt (ctrl, ctrl->server_local->keydesc,
818                         value, valuelen, &outbuf, &padding);
819   xfree (value);
820   if (rc)
821     clear_outbuf (&outbuf);
822   else
823     {
824       if (padding != -1)
825         rc = print_assuan_status (ctx, "PADDING", "%d", padding);
826       else
827         rc = 0;
828       if (!rc)
829         rc = write_and_clear_outbuf (ctx, &outbuf);
830     }
831   xfree (ctrl->server_local->keydesc);
832   ctrl->server_local->keydesc = NULL;
833   return leave_cmd (ctx, rc);
834 }
835
836
837 static const char hlp_genkey[] =
838   "GENKEY [--no-protection] [--preset] [--inq-passwd]\n"
839   "       [--passwd-nonce=<s>] [<cache_nonce>]\n"
840   "\n"
841   "Generate a new key, store the secret part and return the public\n"
842   "part.  Here is an example transaction:\n"
843   "\n"
844   "  C: GENKEY\n"
845   "  S: INQUIRE KEYPARAM\n"
846   "  C: D (genkey (rsa (nbits  2048)))\n"
847   "  C: END\n"
848   "  S: D (public-key\n"
849   "  S: D   (rsa (n 326487324683264) (e 10001)))\n"
850   "  S: OK key created\n"
851   "\n"
852   "When the --preset option is used the passphrase for the generated\n"
853   "key will be added to the cache.  When --inq-passwd is used an inquire\n"
854   "with the keyword NEWPASSWD is used to request the passphrase for the\n"
855   "new key.  When a --passwd-nonce is used, the corresponding cached\n"
856   "passphrase is used to protect the new key.";
857 static gpg_error_t
858 cmd_genkey (assuan_context_t ctx, char *line)
859 {
860   ctrl_t ctrl = assuan_get_pointer (ctx);
861   int rc;
862   int no_protection;
863   unsigned char *value;
864   size_t valuelen;
865   unsigned char *newpasswd = NULL;
866   membuf_t outbuf;
867   char *cache_nonce = NULL;
868   char *passwd_nonce = NULL;
869   int opt_preset;
870   int opt_inq_passwd;
871   size_t n;
872   char *p, *pend;
873   int c;
874
875   if (ctrl->restricted)
876     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
877
878   no_protection = has_option (line, "--no-protection");
879   opt_preset = has_option (line, "--preset");
880   opt_inq_passwd = has_option (line, "--inq-passwd");
881   passwd_nonce = option_value (line, "--passwd-nonce");
882   if (passwd_nonce)
883     {
884       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
885         ;
886       c = *pend;
887       *pend = '\0';
888       passwd_nonce = xtrystrdup (passwd_nonce);
889       *pend = c;
890       if (!passwd_nonce)
891         {
892           rc = gpg_error_from_syserror ();
893           goto leave;
894         }
895     }
896   line = skip_options (line);
897
898   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
899     ;
900   *p = '\0';
901   if (*line)
902     cache_nonce = xtrystrdup (line);
903
904   /* First inquire the parameters */
905   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_KEYPARAM);
906   if (!rc)
907     rc = assuan_inquire (ctx, "KEYPARAM", &value, &valuelen, MAXLEN_KEYPARAM);
908   if (rc)
909     return rc;
910
911   init_membuf (&outbuf, 512);
912
913   /* If requested, ask for the password to be used for the key.  If
914      this is not used the regular Pinentry mechanism is used.  */
915   if (opt_inq_passwd && !no_protection)
916     {
917       /* (N is used as a dummy) */
918       assuan_begin_confidential (ctx);
919       rc = assuan_inquire (ctx, "NEWPASSWD", &newpasswd, &n, 256);
920       assuan_end_confidential (ctx);
921       if (rc)
922         goto leave;
923       if (!*newpasswd)
924         {
925           /* Empty password given - switch to no-protection mode.  */
926           xfree (newpasswd);
927           newpasswd = NULL;
928           no_protection = 1;
929         }
930
931     }
932   else if (passwd_nonce)
933     newpasswd = agent_get_cache (passwd_nonce, CACHE_MODE_NONCE);
934
935   rc = agent_genkey (ctrl, cache_nonce, (char*)value, valuelen, no_protection,
936                      newpasswd, opt_preset, &outbuf);
937
938  leave:
939   if (newpasswd)
940     {
941       /* Assuan_inquire does not allow us to read into secure memory
942          thus we need to wipe it ourself.  */
943       wipememory (newpasswd, strlen (newpasswd));
944       xfree (newpasswd);
945     }
946   xfree (value);
947   if (rc)
948     clear_outbuf (&outbuf);
949   else
950     rc = write_and_clear_outbuf (ctx, &outbuf);
951   xfree (cache_nonce);
952   xfree (passwd_nonce);
953   return leave_cmd (ctx, rc);
954 }
955
956
957
958 \f
959 static const char hlp_readkey[] =
960   "READKEY <hexstring_with_keygrip>\n"
961   "        --card <keyid>\n"
962   "\n"
963   "Return the public key for the given keygrip or keyid.\n"
964   "With --card, private key file with card information will be created.";
965 static gpg_error_t
966 cmd_readkey (assuan_context_t ctx, char *line)
967 {
968   ctrl_t ctrl = assuan_get_pointer (ctx);
969   int rc;
970   unsigned char grip[20];
971   gcry_sexp_t s_pkey = NULL;
972   unsigned char *pkbuf = NULL;
973   char *serialno = NULL;
974   size_t pkbuflen;
975   const char *opt_card;
976
977   if (ctrl->restricted)
978     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
979
980   opt_card = has_option_name (line, "--card");
981   line = skip_options (line);
982
983   if (opt_card)
984     {
985       const char *keyid = opt_card;
986
987       rc = agent_card_getattr (ctrl, "SERIALNO", &serialno);
988       if (rc)
989         {
990           log_error (_("error getting serial number of card: %s\n"),
991                      gpg_strerror (rc));
992           goto leave;
993         }
994
995       rc = agent_card_readkey (ctrl, keyid, &pkbuf);
996       if (rc)
997         goto leave;
998       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
999       rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)pkbuf, pkbuflen);
1000       if (rc)
1001         goto leave;
1002
1003       if (!gcry_pk_get_keygrip (s_pkey, grip))
1004         {
1005           rc = gcry_pk_testkey (s_pkey);
1006           if (rc == 0)
1007             rc = gpg_error (GPG_ERR_INTERNAL);
1008
1009           goto leave;
1010         }
1011
1012       rc = agent_write_shadow_key (grip, serialno, keyid, pkbuf, 0);
1013       if (rc)
1014         goto leave;
1015
1016       rc = assuan_send_data (ctx, pkbuf, pkbuflen);
1017     }
1018   else
1019     {
1020       rc = parse_keygrip (ctx, line, grip);
1021       if (rc)
1022         goto leave;
1023
1024       rc = agent_public_key_from_file (ctrl, grip, &s_pkey);
1025       if (!rc)
1026         {
1027           pkbuflen = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1028           log_assert (pkbuflen);
1029           pkbuf = xtrymalloc (pkbuflen);
1030           if (!pkbuf)
1031             rc = gpg_error_from_syserror ();
1032           else
1033             {
1034               gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, pkbuf, pkbuflen);
1035               rc = assuan_send_data (ctx, pkbuf, pkbuflen);
1036             }
1037         }
1038     }
1039
1040  leave:
1041   xfree (serialno);
1042   xfree (pkbuf);
1043   gcry_sexp_release (s_pkey);
1044   return leave_cmd (ctx, rc);
1045 }
1046
1047
1048 \f
1049 static const char hlp_keyinfo[] =
1050   "KEYINFO [--[ssh-]list] [--data] [--ssh-fpr] [--with-ssh] <keygrip>\n"
1051   "\n"
1052   "Return information about the key specified by the KEYGRIP.  If the\n"
1053   "key is not available GPG_ERR_NOT_FOUND is returned.  If the option\n"
1054   "--list is given the keygrip is ignored and information about all\n"
1055   "available keys are returned.  If --ssh-list is given information\n"
1056   "about all keys listed in the sshcontrol are returned.  With --with-ssh\n"
1057   "information from sshcontrol is always added to the info. Unless --data\n"
1058   "is given, the information is returned as a status line using the format:\n"
1059   "\n"
1060   "  KEYINFO <keygrip> <type> <serialno> <idstr> <cached> <protection> <fpr>\n"
1061   "\n"
1062   "KEYGRIP is the keygrip.\n"
1063   "\n"
1064   "TYPE is describes the type of the key:\n"
1065   "    'D' - Regular key stored on disk,\n"
1066   "    'T' - Key is stored on a smartcard (token),\n"
1067   "    'X' - Unknown type,\n"
1068   "    '-' - Key is missing.\n"
1069   "\n"
1070   "SERIALNO is an ASCII string with the serial number of the\n"
1071   "         smartcard.  If the serial number is not known a single\n"
1072   "         dash '-' is used instead.\n"
1073   "\n"
1074   "IDSTR is the IDSTR used to distinguish keys on a smartcard.  If it\n"
1075   "      is not known a dash is used instead.\n"
1076   "\n"
1077   "CACHED is 1 if the passphrase for the key was found in the key cache.\n"
1078   "       If not, a '-' is used instead.\n"
1079   "\n"
1080   "PROTECTION describes the key protection type:\n"
1081   "    'P' - The key is protected with a passphrase,\n"
1082   "    'C' - The key is not protected,\n"
1083   "    '-' - Unknown protection.\n"
1084   "\n"
1085   "FPR returns the formatted ssh-style fingerprint of the key.  It is only\n"
1086   "    printed if the option --ssh-fpr has been used.  It defaults to '-'.\n"
1087   "\n"
1088   "TTL is the TTL in seconds for that key or '-' if n/a.\n"
1089   "\n"
1090   "FLAGS is a word consisting of one-letter flags:\n"
1091   "      'D' - The key has been disabled,\n"
1092   "      'S' - The key is listed in sshcontrol (requires --with-ssh),\n"
1093   "      'c' - Use of the key needs to be confirmed,\n"
1094   "      '-' - No flags given.\n"
1095   "\n"
1096   "More information may be added in the future.";
1097 static gpg_error_t
1098 do_one_keyinfo (ctrl_t ctrl, const unsigned char *grip, assuan_context_t ctx,
1099                 int data, int with_ssh_fpr, int in_ssh,
1100                 int ttl, int disabled, int confirm)
1101 {
1102   gpg_error_t err;
1103   char hexgrip[40+1];
1104   char *fpr = NULL;
1105   int keytype;
1106   unsigned char *shadow_info = NULL;
1107   char *serialno = NULL;
1108   char *idstr = NULL;
1109   const char *keytypestr;
1110   const char *cached;
1111   const char *protectionstr;
1112   char *pw;
1113   int missing_key = 0;
1114   char ttlbuf[20];
1115   char flagsbuf[5];
1116
1117   err = agent_key_info_from_file (ctrl, grip, &keytype, &shadow_info);
1118   if (err)
1119     {
1120       if (in_ssh && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1121         missing_key = 1;
1122       else
1123         goto leave;
1124     }
1125
1126   /* Reformat the grip so that we use uppercase as good style. */
1127   bin2hex (grip, 20, hexgrip);
1128
1129   if (ttl > 0)
1130     snprintf (ttlbuf, sizeof ttlbuf, "%d", ttl);
1131   else
1132     strcpy (ttlbuf, "-");
1133
1134   *flagsbuf = 0;
1135   if (disabled)
1136     strcat (flagsbuf, "D");
1137   if (in_ssh)
1138     strcat (flagsbuf, "S");
1139   if (confirm)
1140     strcat (flagsbuf, "c");
1141   if (!*flagsbuf)
1142     strcpy (flagsbuf, "-");
1143
1144
1145   if (missing_key)
1146     {
1147       protectionstr = "-"; keytypestr = "-";
1148     }
1149   else
1150     {
1151       switch (keytype)
1152         {
1153         case PRIVATE_KEY_CLEAR:
1154         case PRIVATE_KEY_OPENPGP_NONE:
1155           protectionstr = "C"; keytypestr = "D";
1156           break;
1157         case PRIVATE_KEY_PROTECTED: protectionstr = "P"; keytypestr = "D";
1158           break;
1159         case PRIVATE_KEY_SHADOWED: protectionstr = "-"; keytypestr = "T";
1160           break;
1161         default: protectionstr = "-"; keytypestr = "X";
1162           break;
1163         }
1164     }
1165
1166   /* Compute the ssh fingerprint if requested.  */
1167   if (with_ssh_fpr)
1168     {
1169       gcry_sexp_t key;
1170
1171       if (!agent_raw_key_from_file (ctrl, grip, &key))
1172         {
1173           ssh_get_fingerprint_string (key, GCRY_MD_MD5, &fpr);
1174           gcry_sexp_release (key);
1175         }
1176     }
1177
1178   /* Here we have a little race by doing the cache check separately
1179      from the retrieval function.  Given that the cache flag is only a
1180      hint, it should not really matter.  */
1181   pw = agent_get_cache (hexgrip, CACHE_MODE_NORMAL);
1182   cached = pw ? "1" : "-";
1183   xfree (pw);
1184
1185   if (shadow_info)
1186     {
1187       err = parse_shadow_info (shadow_info, &serialno, &idstr, NULL);
1188       if (err)
1189         goto leave;
1190     }
1191
1192   if (!data)
1193     err = agent_write_status (ctrl, "KEYINFO",
1194                               hexgrip,
1195                               keytypestr,
1196                               serialno? serialno : "-",
1197                               idstr? idstr : "-",
1198                               cached,
1199                               protectionstr,
1200                               fpr? fpr : "-",
1201                               ttlbuf,
1202                               flagsbuf,
1203                               NULL);
1204   else
1205     {
1206       char *string;
1207
1208       string = xtryasprintf ("%s %s %s %s %s %s %s %s %s\n",
1209                              hexgrip, keytypestr,
1210                              serialno? serialno : "-",
1211                              idstr? idstr : "-", cached, protectionstr,
1212                              fpr? fpr : "-",
1213                              ttlbuf,
1214                              flagsbuf);
1215       if (!string)
1216         err = gpg_error_from_syserror ();
1217       else
1218         err = assuan_send_data (ctx, string, strlen(string));
1219       xfree (string);
1220     }
1221
1222  leave:
1223   xfree (fpr);
1224   xfree (shadow_info);
1225   xfree (serialno);
1226   xfree (idstr);
1227   return err;
1228 }
1229
1230
1231 /* Entry int for the command KEYINFO.  This function handles the
1232    command option processing.  For details see hlp_keyinfo above.  */
1233 static gpg_error_t
1234 cmd_keyinfo (assuan_context_t ctx, char *line)
1235 {
1236   ctrl_t ctrl = assuan_get_pointer (ctx);
1237   int err;
1238   unsigned char grip[20];
1239   DIR *dir = NULL;
1240   int list_mode;
1241   int opt_data, opt_ssh_fpr, opt_with_ssh;
1242   ssh_control_file_t cf = NULL;
1243   char hexgrip[41];
1244   int disabled, ttl, confirm, is_ssh;
1245
1246   if (ctrl->restricted)
1247     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1248
1249   if (has_option (line, "--ssh-list"))
1250     list_mode = 2;
1251   else
1252     list_mode = has_option (line, "--list");
1253   opt_data = has_option (line, "--data");
1254   opt_ssh_fpr = has_option (line, "--ssh-fpr");
1255   opt_with_ssh = has_option (line, "--with-ssh");
1256   line = skip_options (line);
1257
1258   if (opt_with_ssh || list_mode == 2)
1259     cf = ssh_open_control_file ();
1260
1261   if (list_mode == 2)
1262     {
1263       if (cf)
1264         {
1265           while (!ssh_read_control_file (cf, hexgrip,
1266                                          &disabled, &ttl, &confirm))
1267             {
1268               if (hex2bin (hexgrip, grip, 20) < 0 )
1269                 continue; /* Bad hex string.  */
1270               err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, 1,
1271                                     ttl, disabled, confirm);
1272               if (err)
1273                 goto leave;
1274             }
1275         }
1276       err = 0;
1277     }
1278   else if (list_mode)
1279     {
1280       char *dirname;
1281       struct dirent *dir_entry;
1282
1283       dirname = make_filename_try (gnupg_homedir (),
1284                                    GNUPG_PRIVATE_KEYS_DIR, NULL);
1285       if (!dirname)
1286         {
1287           err = gpg_error_from_syserror ();
1288           goto leave;
1289         }
1290       dir = opendir (dirname);
1291       if (!dir)
1292         {
1293           err = gpg_error_from_syserror ();
1294           xfree (dirname);
1295           goto leave;
1296         }
1297       xfree (dirname);
1298
1299       while ( (dir_entry = readdir (dir)) )
1300         {
1301           if (strlen (dir_entry->d_name) != 44
1302               || strcmp (dir_entry->d_name + 40, ".key"))
1303             continue;
1304           strncpy (hexgrip, dir_entry->d_name, 40);
1305           hexgrip[40] = 0;
1306
1307           if ( hex2bin (hexgrip, grip, 20) < 0 )
1308             continue; /* Bad hex string.  */
1309
1310           disabled = ttl = confirm = is_ssh = 0;
1311           if (opt_with_ssh)
1312             {
1313               err = ssh_search_control_file (cf, hexgrip,
1314                                              &disabled, &ttl, &confirm);
1315               if (!err)
1316                 is_ssh = 1;
1317               else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1318                 goto leave;
1319             }
1320
1321           err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1322                                 ttl, disabled, confirm);
1323           if (err)
1324             goto leave;
1325         }
1326       err = 0;
1327     }
1328   else
1329     {
1330       err = parse_keygrip (ctx, line, grip);
1331       if (err)
1332         goto leave;
1333       disabled = ttl = confirm = is_ssh = 0;
1334       if (opt_with_ssh)
1335         {
1336           err = ssh_search_control_file (cf, line,
1337                                          &disabled, &ttl, &confirm);
1338           if (!err)
1339             is_ssh = 1;
1340           else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1341             goto leave;
1342         }
1343
1344       err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1345                             ttl, disabled, confirm);
1346     }
1347
1348  leave:
1349   ssh_close_control_file (cf);
1350   if (dir)
1351     closedir (dir);
1352   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1353     leave_cmd (ctx, err);
1354   return err;
1355 }
1356
1357
1358 \f
1359 /* Helper for cmd_get_passphrase.  */
1360 static int
1361 send_back_passphrase (assuan_context_t ctx, int via_data, const char *pw)
1362 {
1363   size_t n;
1364   int rc;
1365
1366   assuan_begin_confidential (ctx);
1367   n = strlen (pw);
1368   if (via_data)
1369     rc = assuan_send_data (ctx, pw, n);
1370   else
1371     {
1372       char *p = xtrymalloc_secure (n*2+1);
1373       if (!p)
1374         rc = gpg_error_from_syserror ();
1375       else
1376         {
1377           bin2hex (pw, n, p);
1378           rc = assuan_set_okay_line (ctx, p);
1379           xfree (p);
1380         }
1381     }
1382   return rc;
1383 }
1384
1385
1386 static const char hlp_get_passphrase[] =
1387   "GET_PASSPHRASE [--data] [--check] [--no-ask] [--repeat[=N]]\n"
1388   "               [--qualitybar] <cache_id>\n"
1389   "               [<error_message> <prompt> <description>]\n"
1390   "\n"
1391   "This function is usually used to ask for a passphrase to be used\n"
1392   "for conventional encryption, but may also be used by programs which\n"
1393   "need specal handling of passphrases.  This command uses a syntax\n"
1394   "which helps clients to use the agent with minimum effort.  The\n"
1395   "agent either returns with an error or with a OK followed by the hex\n"
1396   "encoded passphrase.  Note that the length of the strings is\n"
1397   "implicitly limited by the maximum length of a command.\n"
1398   "\n"
1399   "If the option \"--data\" is used the passphrase is returned by usual\n"
1400   "data lines and not on the okay line.\n"
1401   "\n"
1402   "If the option \"--check\" is used the passphrase constraints checks as\n"
1403   "implemented by gpg-agent are applied.  A check is not done if the\n"
1404   "passphrase has been found in the cache.\n"
1405   "\n"
1406   "If the option \"--no-ask\" is used and the passphrase is not in the\n"
1407   "cache the user will not be asked to enter a passphrase but the error\n"
1408   "code GPG_ERR_NO_DATA is returned.  \n"
1409   "\n"
1410   "If the option \"--qualitybar\" is used a visual indication of the\n"
1411   "entered passphrase quality is shown.  (Unless no minimum passphrase\n"
1412   "length has been configured.)";
1413 static gpg_error_t
1414 cmd_get_passphrase (assuan_context_t ctx, char *line)
1415 {
1416   ctrl_t ctrl = assuan_get_pointer (ctx);
1417   int rc;
1418   char *pw;
1419   char *response;
1420   char *cacheid = NULL, *desc = NULL, *prompt = NULL, *errtext = NULL;
1421   const char *desc2 = _("Please re-enter this passphrase");
1422   char *p;
1423   int opt_data, opt_check, opt_no_ask, opt_qualbar;
1424   int opt_repeat = 0;
1425   char *entry_errtext = NULL;
1426
1427   if (ctrl->restricted)
1428     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1429
1430   opt_data = has_option (line, "--data");
1431   opt_check = has_option (line, "--check");
1432   opt_no_ask = has_option (line, "--no-ask");
1433   if (has_option_name (line, "--repeat"))
1434     {
1435       p = option_value (line, "--repeat");
1436       if (p)
1437         opt_repeat = atoi (p);
1438       else
1439         opt_repeat = 1;
1440     }
1441   opt_qualbar = has_option (line, "--qualitybar");
1442   line = skip_options (line);
1443
1444   cacheid = line;
1445   p = strchr (cacheid, ' ');
1446   if (p)
1447     {
1448       *p++ = 0;
1449       while (*p == ' ')
1450         p++;
1451       errtext = p;
1452       p = strchr (errtext, ' ');
1453       if (p)
1454         {
1455           *p++ = 0;
1456           while (*p == ' ')
1457             p++;
1458           prompt = p;
1459           p = strchr (prompt, ' ');
1460           if (p)
1461             {
1462               *p++ = 0;
1463               while (*p == ' ')
1464                 p++;
1465               desc = p;
1466               p = strchr (desc, ' ');
1467               if (p)
1468                 *p = 0; /* Ignore trailing garbage. */
1469             }
1470         }
1471     }
1472   if (!*cacheid || strlen (cacheid) > 50)
1473     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1474   if (!desc)
1475     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1476
1477   if (!strcmp (cacheid, "X"))
1478     cacheid = NULL;
1479   if (!strcmp (errtext, "X"))
1480     errtext = NULL;
1481   if (!strcmp (prompt, "X"))
1482     prompt = NULL;
1483   if (!strcmp (desc, "X"))
1484     desc = NULL;
1485
1486   pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_USER) : NULL;
1487   if (pw)
1488     {
1489       rc = send_back_passphrase (ctx, opt_data, pw);
1490       xfree (pw);
1491     }
1492   else if (opt_no_ask)
1493     rc = gpg_error (GPG_ERR_NO_DATA);
1494   else
1495     {
1496       /* Note, that we only need to replace the + characters and
1497          should leave the other escaping in place because the escaped
1498          string is send verbatim to the pinentry which does the
1499          unescaping (but not the + replacing) */
1500       if (errtext)
1501         plus_to_blank (errtext);
1502       if (prompt)
1503         plus_to_blank (prompt);
1504       if (desc)
1505         plus_to_blank (desc);
1506
1507     next_try:
1508       rc = agent_get_passphrase (ctrl, &response, desc, prompt,
1509                                  entry_errtext? entry_errtext:errtext,
1510                                  opt_qualbar, cacheid, CACHE_MODE_USER);
1511       xfree (entry_errtext);
1512       entry_errtext = NULL;
1513       if (!rc)
1514         {
1515           int i;
1516
1517           if (opt_check
1518               && check_passphrase_constraints (ctrl, response, &entry_errtext))
1519             {
1520               xfree (response);
1521               goto next_try;
1522             }
1523           for (i = 0; i < opt_repeat; i++)
1524             {
1525               char *response2;
1526
1527               if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
1528                 break;
1529
1530               rc = agent_get_passphrase (ctrl, &response2, desc2, prompt,
1531                                          errtext, 0,
1532                                          cacheid, CACHE_MODE_USER);
1533               if (rc)
1534                 break;
1535               if (strcmp (response2, response))
1536                 {
1537                   xfree (response2);
1538                   xfree (response);
1539                   entry_errtext = try_percent_escape
1540                     (_("does not match - try again"), NULL);
1541                   if (!entry_errtext)
1542                     {
1543                       rc = gpg_error_from_syserror ();
1544                       break;
1545                     }
1546                   goto next_try;
1547                 }
1548               xfree (response2);
1549             }
1550           if (!rc)
1551             {
1552               if (cacheid)
1553                 agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
1554               rc = send_back_passphrase (ctx, opt_data, response);
1555             }
1556           xfree (response);
1557         }
1558     }
1559
1560   return leave_cmd (ctx, rc);
1561 }
1562
1563
1564 static const char hlp_clear_passphrase[] =
1565   "CLEAR_PASSPHRASE [--mode=normal] <cache_id>\n"
1566   "\n"
1567   "may be used to invalidate the cache entry for a passphrase.  The\n"
1568   "function returns with OK even when there is no cached passphrase.\n"
1569   "The --mode=normal option is used to clear an entry for a cacheid\n"
1570   "added by the agent.\n";
1571 static gpg_error_t
1572 cmd_clear_passphrase (assuan_context_t ctx, char *line)
1573 {
1574   ctrl_t ctrl = assuan_get_pointer (ctx);
1575   char *cacheid = NULL;
1576   char *p;
1577   int opt_normal;
1578
1579   if (ctrl->restricted)
1580     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1581
1582   opt_normal = has_option (line, "--mode=normal");
1583   line = skip_options (line);
1584
1585   /* parse the stuff */
1586   for (p=line; *p == ' '; p++)
1587     ;
1588   cacheid = p;
1589   p = strchr (cacheid, ' ');
1590   if (p)
1591     *p = 0; /* ignore garbage */
1592   if (!*cacheid || strlen (cacheid) > 50)
1593     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1594
1595   agent_put_cache (cacheid, opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER,
1596                    NULL, 0);
1597
1598   agent_clear_passphrase (ctrl, cacheid,
1599                           opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER);
1600
1601   return 0;
1602 }
1603
1604
1605 static const char hlp_get_confirmation[] =
1606   "GET_CONFIRMATION <description>\n"
1607   "\n"
1608   "This command may be used to ask for a simple confirmation.\n"
1609   "DESCRIPTION is displayed along with a Okay and Cancel button.  This\n"
1610   "command uses a syntax which helps clients to use the agent with\n"
1611   "minimum effort.  The agent either returns with an error or with a\n"
1612   "OK.  Note, that the length of DESCRIPTION is implicitly limited by\n"
1613   "the maximum length of a command. DESCRIPTION should not contain\n"
1614   "any spaces, those must be encoded either percent escaped or simply\n"
1615   "as '+'.";
1616 static gpg_error_t
1617 cmd_get_confirmation (assuan_context_t ctx, char *line)
1618 {
1619   ctrl_t ctrl = assuan_get_pointer (ctx);
1620   int rc;
1621   char *desc = NULL;
1622   char *p;
1623
1624   if (ctrl->restricted)
1625     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1626
1627   /* parse the stuff */
1628   for (p=line; *p == ' '; p++)
1629     ;
1630   desc = p;
1631   p = strchr (desc, ' ');
1632   if (p)
1633     *p = 0; /* We ignore any garbage -may be later used for other args. */
1634
1635   if (!*desc)
1636     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1637
1638   if (!strcmp (desc, "X"))
1639     desc = NULL;
1640
1641   /* Note, that we only need to replace the + characters and should
1642      leave the other escaping in place because the escaped string is
1643      send verbatim to the pinentry which does the unescaping (but not
1644      the + replacing) */
1645   if (desc)
1646     plus_to_blank (desc);
1647
1648   rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
1649   return leave_cmd (ctx, rc);
1650 }
1651
1652
1653 \f
1654 static const char hlp_learn[] =
1655   "LEARN [--send] [--sendinfo] [--force]\n"
1656   "\n"
1657   "Learn something about the currently inserted smartcard.  With\n"
1658   "--sendinfo information about the card is returned; with --send\n"
1659   "the available certificates are returned as D lines; with --force\n"
1660   "private key storage will be updated by the result.";
1661 static gpg_error_t
1662 cmd_learn (assuan_context_t ctx, char *line)
1663 {
1664   ctrl_t ctrl = assuan_get_pointer (ctx);
1665   gpg_error_t err;
1666   int send, sendinfo, force;
1667
1668   send = has_option (line, "--send");
1669   sendinfo = send? 1 : has_option (line, "--sendinfo");
1670   force = has_option (line, "--force");
1671
1672   if (ctrl->restricted)
1673     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1674
1675   err = agent_handle_learn (ctrl, send, sendinfo? ctx : NULL, force);
1676   return leave_cmd (ctx, err);
1677 }
1678
1679
1680 \f
1681 static const char hlp_passwd[] =
1682   "PASSWD [--cache-nonce=<c>] [--passwd-nonce=<s>] [--preset]\n"
1683   "       [--verify] <hexkeygrip>\n"
1684   "\n"
1685   "Change the passphrase/PIN for the key identified by keygrip in LINE.  If\n"
1686   "--preset is used then the new passphrase will be added to the cache.\n"
1687   "If --verify is used the command asks for the passphrase and verifies\n"
1688   "that the passphrase valid.\n";
1689 static gpg_error_t
1690 cmd_passwd (assuan_context_t ctx, char *line)
1691 {
1692   ctrl_t ctrl = assuan_get_pointer (ctx);
1693   gpg_error_t err;
1694   int c;
1695   char *cache_nonce = NULL;
1696   char *passwd_nonce = NULL;
1697   unsigned char grip[20];
1698   gcry_sexp_t s_skey = NULL;
1699   unsigned char *shadow_info = NULL;
1700   char *passphrase = NULL;
1701   char *pend;
1702   int opt_preset, opt_verify;
1703
1704   if (ctrl->restricted)
1705     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1706
1707   opt_preset = has_option (line, "--preset");
1708   cache_nonce = option_value (line, "--cache-nonce");
1709   opt_verify = has_option (line, "--verify");
1710   if (cache_nonce)
1711     {
1712       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
1713         ;
1714       c = *pend;
1715       *pend = '\0';
1716       cache_nonce = xtrystrdup (cache_nonce);
1717       *pend = c;
1718       if (!cache_nonce)
1719         {
1720           err = gpg_error_from_syserror ();
1721           goto leave;
1722         }
1723     }
1724
1725   passwd_nonce = option_value (line, "--passwd-nonce");
1726   if (passwd_nonce)
1727     {
1728       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
1729         ;
1730       c = *pend;
1731       *pend = '\0';
1732       passwd_nonce = xtrystrdup (passwd_nonce);
1733       *pend = c;
1734       if (!passwd_nonce)
1735         {
1736           err = gpg_error_from_syserror ();
1737           goto leave;
1738         }
1739     }
1740
1741   line = skip_options (line);
1742
1743   err = parse_keygrip (ctx, line, grip);
1744   if (err)
1745     goto leave;
1746
1747   ctrl->in_passwd++;
1748   err = agent_key_from_file (ctrl,
1749                              opt_verify? NULL : cache_nonce,
1750                              ctrl->server_local->keydesc,
1751                              grip, &shadow_info, CACHE_MODE_IGNORE, NULL,
1752                              &s_skey, &passphrase);
1753   if (err)
1754     ;
1755   else if (shadow_info)
1756     {
1757       log_error ("changing a smartcard PIN is not yet supported\n");
1758       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1759     }
1760   else if (opt_verify)
1761     {
1762       /* All done.  */
1763       if (passphrase)
1764         {
1765           if (!passwd_nonce)
1766             {
1767               char buf[12];
1768               gcry_create_nonce (buf, 12);
1769               passwd_nonce = bin2hex (buf, 12, NULL);
1770             }
1771           if (passwd_nonce
1772               && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
1773                                    passphrase, CACHE_TTL_NONCE))
1774             {
1775               assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1776               xfree (ctrl->server_local->last_passwd_nonce);
1777               ctrl->server_local->last_passwd_nonce = passwd_nonce;
1778               passwd_nonce = NULL;
1779             }
1780         }
1781     }
1782   else
1783     {
1784       char *newpass = NULL;
1785
1786       if (passwd_nonce)
1787         newpass = agent_get_cache (passwd_nonce, CACHE_MODE_NONCE);
1788       err = agent_protect_and_store (ctrl, s_skey, &newpass);
1789       if (!err && passphrase)
1790         {
1791           /* A passphrase existed on the old key and the change was
1792              successful.  Return a nonce for that old passphrase to
1793              let the caller try to unprotect the other subkeys with
1794              the same key.  */
1795           if (!cache_nonce)
1796             {
1797               char buf[12];
1798               gcry_create_nonce (buf, 12);
1799               cache_nonce = bin2hex (buf, 12, NULL);
1800             }
1801           if (cache_nonce
1802               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
1803                                    passphrase, CACHE_TTL_NONCE))
1804             {
1805               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
1806               xfree (ctrl->server_local->last_cache_nonce);
1807               ctrl->server_local->last_cache_nonce = cache_nonce;
1808               cache_nonce = NULL;
1809             }
1810           if (newpass)
1811             {
1812               /* If we have a new passphrase (which might be empty) we
1813                  store it under a passwd nonce so that the caller may
1814                  send that nonce again to use it for another key. */
1815               if (!passwd_nonce)
1816                 {
1817                   char buf[12];
1818                   gcry_create_nonce (buf, 12);
1819                   passwd_nonce = bin2hex (buf, 12, NULL);
1820                 }
1821               if (passwd_nonce
1822                   && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
1823                                        newpass, CACHE_TTL_NONCE))
1824                 {
1825                   assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1826                   xfree (ctrl->server_local->last_passwd_nonce);
1827                   ctrl->server_local->last_passwd_nonce = passwd_nonce;
1828                   passwd_nonce = NULL;
1829                 }
1830             }
1831         }
1832       if (!err && opt_preset)
1833         {
1834           char hexgrip[40+1];
1835           bin2hex(grip, 20, hexgrip);
1836           err = agent_put_cache (hexgrip, CACHE_MODE_ANY, newpass,
1837                                  ctrl->cache_ttl_opt_preset);
1838         }
1839       xfree (newpass);
1840     }
1841   ctrl->in_passwd--;
1842
1843   xfree (ctrl->server_local->keydesc);
1844   ctrl->server_local->keydesc = NULL;
1845
1846  leave:
1847   xfree (passphrase);
1848   gcry_sexp_release (s_skey);
1849   xfree (shadow_info);
1850   xfree (cache_nonce);
1851   xfree (passwd_nonce);
1852   return leave_cmd (ctx, err);
1853 }
1854
1855
1856 static const char hlp_preset_passphrase[] =
1857   "PRESET_PASSPHRASE [--inquire] <string_or_keygrip> <timeout> [<hexstring>]\n"
1858   "\n"
1859   "Set the cached passphrase/PIN for the key identified by the keygrip\n"
1860   "to passwd for the given time, where -1 means infinite and 0 means\n"
1861   "the default (currently only a timeout of -1 is allowed, which means\n"
1862   "to never expire it).  If passwd is not provided, ask for it via the\n"
1863   "pinentry module unless --inquire is passed in which case the passphrase\n"
1864   "is retrieved from the client via a server inquire.\n";
1865 static gpg_error_t
1866 cmd_preset_passphrase (assuan_context_t ctx, char *line)
1867 {
1868   ctrl_t ctrl = assuan_get_pointer (ctx);
1869   int rc;
1870   char *grip_clear = NULL;
1871   unsigned char *passphrase = NULL;
1872   int ttl;
1873   size_t len;
1874   int opt_inquire;
1875
1876   if (ctrl->restricted)
1877     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1878
1879   if (!opt.allow_preset_passphrase)
1880     return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
1881
1882   opt_inquire = has_option (line, "--inquire");
1883   line = skip_options (line);
1884   grip_clear = line;
1885   while (*line && (*line != ' ' && *line != '\t'))
1886     line++;
1887   if (!*line)
1888     return gpg_error (GPG_ERR_MISSING_VALUE);
1889   *line = '\0';
1890   line++;
1891   while (*line && (*line == ' ' || *line == '\t'))
1892     line++;
1893
1894   /* Currently, only infinite timeouts are allowed.  */
1895   ttl = -1;
1896   if (line[0] != '-' || line[1] != '1')
1897     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1898   line++;
1899   line++;
1900   while (!(*line != ' ' && *line != '\t'))
1901     line++;
1902
1903   /* Syntax check the hexstring.  */
1904   len = 0;
1905   rc = parse_hexstring (ctx, line, &len);
1906   if (rc)
1907     return rc;
1908   line[len] = '\0';
1909
1910   /* If there is a passphrase, use it.  Currently, a passphrase is
1911      required.  */
1912   if (*line)
1913     {
1914       if (opt_inquire)
1915         {
1916           rc = set_error (GPG_ERR_ASS_PARAMETER,
1917                           "both --inquire and passphrase specified");
1918           goto leave;
1919         }
1920
1921       /* Do in-place conversion.  */
1922       passphrase = line;
1923       if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
1924         rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
1925     }
1926   else if (opt_inquire)
1927     {
1928       /* Note that the passphrase will be truncated at any null byte and the
1929        * limit is 480 characters. */
1930       size_t maxlen = 480;
1931
1932       rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", maxlen);
1933       if (!rc)
1934         rc = assuan_inquire (ctx, "PASSPHRASE", &passphrase, &len, maxlen);
1935     }
1936   else
1937     rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
1938
1939   if (!rc)
1940     {
1941       rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1942       if (opt_inquire)
1943         xfree (passphrase);
1944     }
1945
1946 leave:
1947   return leave_cmd (ctx, rc);
1948 }
1949
1950
1951 \f
1952 static const char hlp_scd[] =
1953   "SCD <commands to pass to the scdaemon>\n"
1954   " \n"
1955   "This is a general quote command to redirect everything to the\n"
1956   "SCdaemon.";
1957 static gpg_error_t
1958 cmd_scd (assuan_context_t ctx, char *line)
1959 {
1960   int rc;
1961 #ifdef BUILD_WITH_SCDAEMON
1962   ctrl_t ctrl = assuan_get_pointer (ctx);
1963   if (ctrl->restricted)
1964     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1965
1966   rc = divert_generic_cmd (ctrl, line, ctx);
1967 #else
1968   (void)ctx; (void)line;
1969   rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
1970 #endif
1971   return rc;
1972 }
1973
1974
1975 \f
1976 static const char hlp_keywrap_key[] =
1977   "KEYWRAP_KEY [--clear] <mode>\n"
1978   "\n"
1979   "Return a key to wrap another key.  For now the key is returned\n"
1980   "verbatim and thus makes not much sense because an eavesdropper on\n"
1981   "the gpg-agent connection will see the key as well as the wrapped key.\n"
1982   "However, this function may either be equipped with a public key\n"
1983   "mechanism or not used at all if the key is a pre-shared key.  In any\n"
1984   "case wrapping the import and export of keys is a requirement for\n"
1985   "certain cryptographic validations and thus useful.  The key persists\n"
1986   "until a RESET command but may be cleared using the option --clear.\n"
1987   "\n"
1988   "Supported modes are:\n"
1989   "  --import  - Return a key to import a key into gpg-agent\n"
1990   "  --export  - Return a key to export a key from gpg-agent";
1991 static gpg_error_t
1992 cmd_keywrap_key (assuan_context_t ctx, char *line)
1993 {
1994   ctrl_t ctrl = assuan_get_pointer (ctx);
1995   gpg_error_t err = 0;
1996   int clearopt = has_option (line, "--clear");
1997
1998   if (ctrl->restricted)
1999     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2000
2001   assuan_begin_confidential (ctx);
2002   if (has_option (line, "--import"))
2003     {
2004       xfree (ctrl->server_local->import_key);
2005       if (clearopt)
2006         ctrl->server_local->import_key = NULL;
2007       else if (!(ctrl->server_local->import_key =
2008                  gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
2009         err = gpg_error_from_syserror ();
2010       else
2011         err = assuan_send_data (ctx, ctrl->server_local->import_key,
2012                                 KEYWRAP_KEYSIZE);
2013     }
2014   else if (has_option (line, "--export"))
2015     {
2016       xfree (ctrl->server_local->export_key);
2017       if (clearopt)
2018         ctrl->server_local->export_key = NULL;
2019       else if (!(ctrl->server_local->export_key =
2020             gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
2021         err = gpg_error_from_syserror ();
2022       else
2023         err = assuan_send_data (ctx, ctrl->server_local->export_key,
2024                                 KEYWRAP_KEYSIZE);
2025     }
2026   else
2027     err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for MODE");
2028   assuan_end_confidential (ctx);
2029
2030   return leave_cmd (ctx, err);
2031 }
2032
2033
2034 \f
2035 static const char hlp_import_key[] =
2036   "IMPORT_KEY [--unattended] [--force] [<cache_nonce>]\n"
2037   "\n"
2038   "Import a secret key into the key store.  The key is expected to be\n"
2039   "encrypted using the current session's key wrapping key (cf. command\n"
2040   "KEYWRAP_KEY) using the AESWRAP-128 algorithm.  This function takes\n"
2041   "no arguments but uses the inquiry \"KEYDATA\" to ask for the actual\n"
2042   "key data.  The unwrapped key must be a canonical S-expression.  The\n"
2043   "option --unattended tries to import the key as-is without any\n"
2044   "re-encryption.  Existing key can be overwritten with --force.";
2045 static gpg_error_t
2046 cmd_import_key (assuan_context_t ctx, char *line)
2047 {
2048   ctrl_t ctrl = assuan_get_pointer (ctx);
2049   gpg_error_t err;
2050   int opt_unattended;
2051   int force;
2052   unsigned char *wrappedkey = NULL;
2053   size_t wrappedkeylen;
2054   gcry_cipher_hd_t cipherhd = NULL;
2055   unsigned char *key = NULL;
2056   size_t keylen, realkeylen;
2057   char *passphrase = NULL;
2058   unsigned char *finalkey = NULL;
2059   size_t finalkeylen;
2060   unsigned char grip[20];
2061   gcry_sexp_t openpgp_sexp = NULL;
2062   char *cache_nonce = NULL;
2063   char *p;
2064
2065   if (ctrl->restricted)
2066     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2067
2068   if (!ctrl->server_local->import_key)
2069     {
2070       err = gpg_error (GPG_ERR_MISSING_KEY);
2071       goto leave;
2072     }
2073
2074   opt_unattended = has_option (line, "--unattended");
2075   force = has_option (line, "--force");
2076   line = skip_options (line);
2077
2078   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
2079     ;
2080   *p = '\0';
2081   if (*line)
2082     cache_nonce = xtrystrdup (line);
2083
2084   assuan_begin_confidential (ctx);
2085   err = assuan_inquire (ctx, "KEYDATA",
2086                         &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
2087   assuan_end_confidential (ctx);
2088   if (err)
2089     goto leave;
2090   if (wrappedkeylen < 24)
2091     {
2092       err = gpg_error (GPG_ERR_INV_LENGTH);
2093       goto leave;
2094     }
2095   keylen = wrappedkeylen - 8;
2096   key = xtrymalloc_secure (keylen);
2097   if (!key)
2098     {
2099       err = gpg_error_from_syserror ();
2100       goto leave;
2101     }
2102
2103   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2104                           GCRY_CIPHER_MODE_AESWRAP, 0);
2105   if (err)
2106     goto leave;
2107   err = gcry_cipher_setkey (cipherhd,
2108                             ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
2109   if (err)
2110     goto leave;
2111   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
2112   if (err)
2113     goto leave;
2114   gcry_cipher_close (cipherhd);
2115   cipherhd = NULL;
2116   xfree (wrappedkey);
2117   wrappedkey = NULL;
2118
2119   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
2120   if (!realkeylen)
2121     goto leave; /* Invalid canonical encoded S-expression.  */
2122
2123   err = keygrip_from_canon_sexp (key, realkeylen, grip);
2124   if (err)
2125     {
2126       /* This might be due to an unsupported S-expression format.
2127          Check whether this is openpgp-private-key and trigger that
2128          import code.  */
2129       if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
2130         {
2131           const char *tag;
2132           size_t taglen;
2133
2134           tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
2135           if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
2136             ;
2137           else
2138             {
2139               gcry_sexp_release (openpgp_sexp);
2140               openpgp_sexp = NULL;
2141             }
2142         }
2143       if (!openpgp_sexp)
2144         goto leave; /* Note that ERR is still set.  */
2145     }
2146
2147
2148   if (openpgp_sexp)
2149     {
2150       /* In most cases the key is encrypted and thus the conversion
2151          function from the OpenPGP format to our internal format will
2152          ask for a passphrase.  That passphrase will be returned and
2153          used to protect the key using the same code as for regular
2154          key import. */
2155
2156       xfree (key);
2157       key = NULL;
2158       err = convert_from_openpgp (ctrl, openpgp_sexp, force, grip,
2159                                   ctrl->server_local->keydesc, cache_nonce,
2160                                   &key, opt_unattended? NULL : &passphrase);
2161       if (err)
2162         goto leave;
2163       realkeylen = gcry_sexp_canon_len (key, 0, NULL, &err);
2164       if (!realkeylen)
2165         goto leave; /* Invalid canonical encoded S-expression.  */
2166       if (passphrase)
2167         {
2168           assert (!opt_unattended);
2169           if (!cache_nonce)
2170             {
2171               char buf[12];
2172               gcry_create_nonce (buf, 12);
2173               cache_nonce = bin2hex (buf, 12, NULL);
2174             }
2175           if (cache_nonce
2176               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2177                                    passphrase, CACHE_TTL_NONCE))
2178             assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2179         }
2180     }
2181   else if (opt_unattended)
2182     {
2183       err = set_error (GPG_ERR_ASS_PARAMETER,
2184                        "\"--unattended\" may only be used with OpenPGP keys");
2185       goto leave;
2186     }
2187   else
2188     {
2189       if (!force && !agent_key_available (grip))
2190         err = gpg_error (GPG_ERR_EEXIST);
2191       else
2192         {
2193           char *prompt = xtryasprintf
2194             (_("Please enter the passphrase to protect the "
2195                "imported object within the %s system."), GNUPG_NAME);
2196           if (!prompt)
2197             err = gpg_error_from_syserror ();
2198           else
2199             err = agent_ask_new_passphrase (ctrl, prompt, &passphrase);
2200           xfree (prompt);
2201         }
2202       if (err)
2203         goto leave;
2204     }
2205
2206   if (passphrase)
2207     {
2208       err = agent_protect (key, passphrase, &finalkey, &finalkeylen,
2209                            ctrl->s2k_count, -1);
2210       if (!err)
2211         err = agent_write_private_key (grip, finalkey, finalkeylen, force);
2212     }
2213   else
2214     err = agent_write_private_key (grip, key, realkeylen, force);
2215
2216  leave:
2217   gcry_sexp_release (openpgp_sexp);
2218   xfree (finalkey);
2219   xfree (passphrase);
2220   xfree (key);
2221   gcry_cipher_close (cipherhd);
2222   xfree (wrappedkey);
2223   xfree (cache_nonce);
2224   xfree (ctrl->server_local->keydesc);
2225   ctrl->server_local->keydesc = NULL;
2226   return leave_cmd (ctx, err);
2227 }
2228
2229
2230 \f
2231 static const char hlp_export_key[] =
2232   "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
2233   "\n"
2234   "Export a secret key from the key store.  The key will be encrypted\n"
2235   "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
2236   "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
2237   "prior to using this command.  The function takes the keygrip as argument.\n"
2238   "\n"
2239   "If --openpgp is used, the secret key material will be exported in RFC 4880\n"
2240   "compatible passphrase-protected form.  Without --openpgp, the secret key\n"
2241   "material will be exported in the clear (after prompting the user to unlock\n"
2242   "it, if needed).\n";
2243 static gpg_error_t
2244 cmd_export_key (assuan_context_t ctx, char *line)
2245 {
2246   ctrl_t ctrl = assuan_get_pointer (ctx);
2247   gpg_error_t err;
2248   unsigned char grip[20];
2249   gcry_sexp_t s_skey = NULL;
2250   unsigned char *key = NULL;
2251   size_t keylen;
2252   gcry_cipher_hd_t cipherhd = NULL;
2253   unsigned char *wrappedkey = NULL;
2254   size_t wrappedkeylen;
2255   int openpgp;
2256   char *cache_nonce;
2257   char *passphrase = NULL;
2258   unsigned char *shadow_info = NULL;
2259   char *pend;
2260   int c;
2261
2262   if (ctrl->restricted)
2263     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2264
2265   openpgp = has_option (line, "--openpgp");
2266   cache_nonce = option_value (line, "--cache-nonce");
2267   if (cache_nonce)
2268     {
2269       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
2270         ;
2271       c = *pend;
2272       *pend = '\0';
2273       cache_nonce = xtrystrdup (cache_nonce);
2274       *pend = c;
2275       if (!cache_nonce)
2276         {
2277           err = gpg_error_from_syserror ();
2278           goto leave;
2279         }
2280     }
2281   line = skip_options (line);
2282
2283   if (!ctrl->server_local->export_key)
2284     {
2285       err = set_error (GPG_ERR_MISSING_KEY, "did you run KEYWRAP_KEY ?");
2286       goto leave;
2287     }
2288
2289   err = parse_keygrip (ctx, line, grip);
2290   if (err)
2291     goto leave;
2292
2293   if (agent_key_available (grip))
2294     {
2295       err = gpg_error (GPG_ERR_NO_SECKEY);
2296       goto leave;
2297     }
2298
2299   /* Get the key from the file.  With the openpgp flag we also ask for
2300      the passphrase so that we can use it to re-encrypt it.  */
2301   err = agent_key_from_file (ctrl, cache_nonce,
2302                              ctrl->server_local->keydesc, grip,
2303                              &shadow_info, CACHE_MODE_IGNORE, NULL, &s_skey,
2304                              openpgp ? &passphrase : NULL);
2305   if (err)
2306     goto leave;
2307   if (shadow_info)
2308     {
2309       /* Key is on a smartcard.  */
2310       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2311       goto leave;
2312     }
2313
2314   if (openpgp)
2315     {
2316       /* The openpgp option changes the key format into the OpenPGP
2317          key transfer format.  The result is already a padded
2318          canonical S-expression.  */
2319       if (!passphrase)
2320         {
2321           err = agent_ask_new_passphrase
2322             (ctrl, _("This key (or subkey) is not protected with a passphrase."
2323                      "  Please enter a new passphrase to export it."),
2324              &passphrase);
2325           if (err)
2326             goto leave;
2327         }
2328       err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
2329       if (!err && passphrase)
2330         {
2331           if (!cache_nonce)
2332             {
2333               char buf[12];
2334               gcry_create_nonce (buf, 12);
2335               cache_nonce = bin2hex (buf, 12, NULL);
2336             }
2337           if (cache_nonce
2338               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2339                                    passphrase, CACHE_TTL_NONCE))
2340             {
2341               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2342               xfree (ctrl->server_local->last_cache_nonce);
2343               ctrl->server_local->last_cache_nonce = cache_nonce;
2344               cache_nonce = NULL;
2345             }
2346         }
2347     }
2348   else
2349     {
2350       /* Convert into a canonical S-expression and wrap that.  */
2351       err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
2352     }
2353   if (err)
2354     goto leave;
2355   gcry_sexp_release (s_skey);
2356   s_skey = NULL;
2357
2358   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2359                           GCRY_CIPHER_MODE_AESWRAP, 0);
2360   if (err)
2361     goto leave;
2362   err = gcry_cipher_setkey (cipherhd,
2363                             ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
2364   if (err)
2365     goto leave;
2366
2367   wrappedkeylen = keylen + 8;
2368   wrappedkey = xtrymalloc (wrappedkeylen);
2369   if (!wrappedkey)
2370     {
2371       err = gpg_error_from_syserror ();
2372       goto leave;
2373     }
2374
2375   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
2376   if (err)
2377     goto leave;
2378   xfree (key);
2379   key = NULL;
2380   gcry_cipher_close (cipherhd);
2381   cipherhd = NULL;
2382
2383   assuan_begin_confidential (ctx);
2384   err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
2385   assuan_end_confidential (ctx);
2386
2387
2388  leave:
2389   xfree (cache_nonce);
2390   xfree (passphrase);
2391   xfree (wrappedkey);
2392   gcry_cipher_close (cipherhd);
2393   xfree (key);
2394   gcry_sexp_release (s_skey);
2395   xfree (ctrl->server_local->keydesc);
2396   ctrl->server_local->keydesc = NULL;
2397   xfree (shadow_info);
2398
2399   return leave_cmd (ctx, err);
2400 }
2401
2402
2403 \f
2404 static const char hlp_delete_key[] =
2405   "DELETE_KEY [--force|--stub-only] <hexstring_with_keygrip>\n"
2406   "\n"
2407   "Delete a secret key from the key store.  If --force is used\n"
2408   "and a loopback pinentry is allowed, the agent will not ask\n"
2409   "the user for confirmation.  If --stub-only is used the key will\n"
2410   "only be deleted if it is a reference to a token.";
2411 static gpg_error_t
2412 cmd_delete_key (assuan_context_t ctx, char *line)
2413 {
2414   ctrl_t ctrl = assuan_get_pointer (ctx);
2415   gpg_error_t err;
2416   int force, stub_only;
2417   unsigned char grip[20];
2418
2419   if (ctrl->restricted)
2420     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2421
2422   force = has_option (line, "--force");
2423   stub_only = has_option (line, "--stub-only");
2424   line = skip_options (line);
2425
2426   /* If the use of a loopback pinentry has been disabled, we assume
2427    * that a silent deletion of keys shall also not be allowed.  */
2428   if (!opt.allow_loopback_pinentry)
2429     force = 0;
2430
2431   err = parse_keygrip (ctx, line, grip);
2432   if (err)
2433     goto leave;
2434
2435   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip,
2436                           force, stub_only);
2437   if (err)
2438     goto leave;
2439
2440  leave:
2441   xfree (ctrl->server_local->keydesc);
2442   ctrl->server_local->keydesc = NULL;
2443
2444   return leave_cmd (ctx, err);
2445 }
2446
2447
2448 \f
2449 #if SIZEOF_TIME_T > SIZEOF_UNSIGNED_LONG
2450 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010llu))"
2451 #else
2452 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010lu))"
2453 #endif
2454
2455 static const char hlp_keytocard[] =
2456   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2457   "\n";
2458 static gpg_error_t
2459 cmd_keytocard (assuan_context_t ctx, char *line)
2460 {
2461   ctrl_t ctrl = assuan_get_pointer (ctx);
2462   int force;
2463   gpg_error_t err = 0;
2464   unsigned char grip[20];
2465   gcry_sexp_t s_skey = NULL;
2466   unsigned char *keydata;
2467   size_t keydatalen;
2468   const char *serialno, *timestamp_str, *id;
2469   unsigned char *shadow_info = NULL;
2470   time_t timestamp;
2471
2472   if (ctrl->restricted)
2473     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2474
2475   force = has_option (line, "--force");
2476   line = skip_options (line);
2477
2478   err = parse_keygrip (ctx, line, grip);
2479   if (err)
2480     goto leave;
2481
2482   if (agent_key_available (grip))
2483     {
2484       err =gpg_error (GPG_ERR_NO_SECKEY);
2485       goto leave;
2486     }
2487
2488   /* Fixme: Replace the parsing code by split_fields().  */
2489   line += 40;
2490   while (*line && (*line == ' ' || *line == '\t'))
2491     line++;
2492   serialno = line;
2493   while (*line && (*line != ' ' && *line != '\t'))
2494     line++;
2495   if (!*line)
2496     {
2497       err = gpg_error (GPG_ERR_MISSING_VALUE);
2498       goto leave;
2499     }
2500   *line = '\0';
2501   line++;
2502   while (*line && (*line == ' ' || *line == '\t'))
2503     line++;
2504   id = line;
2505   while (*line && (*line != ' ' && *line != '\t'))
2506     line++;
2507   if (!*line)
2508     {
2509       err = gpg_error (GPG_ERR_MISSING_VALUE);
2510       goto leave;
2511     }
2512   *line = '\0';
2513   line++;
2514   while (*line && (*line == ' ' || *line == '\t'))
2515     line++;
2516   timestamp_str = line;
2517   while (*line && (*line != ' ' && *line != '\t'))
2518     line++;
2519   if (*line)
2520     *line = '\0';
2521
2522   if ((timestamp = isotime2epoch (timestamp_str)) == (time_t)(-1))
2523     {
2524       err = gpg_error (GPG_ERR_INV_TIME);
2525       goto leave;
2526     }
2527
2528   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2529                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2530                              &s_skey, NULL);
2531   if (err)
2532     {
2533       xfree (shadow_info);
2534       goto leave;
2535     }
2536   if (shadow_info)
2537     {
2538       /* Key is on a smartcard already.  */
2539       xfree (shadow_info);
2540       gcry_sexp_release (s_skey);
2541       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2542       goto leave;
2543     }
2544
2545   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2546   keydata = xtrymalloc_secure (keydatalen + 30);
2547   if (keydata == NULL)
2548     {
2549       err = gpg_error_from_syserror ();
2550       gcry_sexp_release (s_skey);
2551       goto leave;
2552     }
2553
2554   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2555   gcry_sexp_release (s_skey);
2556   keydatalen--;                 /* Decrement for last '\0'.  */
2557   /* Add timestamp "created-at" in the private key */
2558   snprintf (keydata+keydatalen-1, 30, KEYTOCARD_TIMESTAMP_FORMAT, timestamp);
2559   keydatalen += 10 + 19 - 1;
2560   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2561   xfree (keydata);
2562
2563  leave:
2564   return leave_cmd (ctx, err);
2565 }
2566
2567
2568 \f
2569 static const char hlp_getval[] =
2570   "GETVAL <key>\n"
2571   "\n"
2572   "Return the value for KEY from the special environment as created by\n"
2573   "PUTVAL.";
2574 static gpg_error_t
2575 cmd_getval (assuan_context_t ctx, char *line)
2576 {
2577   ctrl_t ctrl = assuan_get_pointer (ctx);
2578   int rc = 0;
2579   char *key = NULL;
2580   char *p;
2581   struct putval_item_s *vl;
2582
2583   if (ctrl->restricted)
2584     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2585
2586   for (p=line; *p == ' '; p++)
2587     ;
2588   key = p;
2589   p = strchr (key, ' ');
2590   if (p)
2591     {
2592       *p++ = 0;
2593       for (; *p == ' '; p++)
2594         ;
2595       if (*p)
2596         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2597     }
2598   if (!*key)
2599     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2600
2601
2602   for (vl=putval_list; vl; vl = vl->next)
2603     if ( !strcmp (vl->d, key) )
2604       break;
2605
2606   if (vl) /* Got an entry. */
2607     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2608   else
2609     return gpg_error (GPG_ERR_NO_DATA);
2610
2611   return leave_cmd (ctx, rc);
2612 }
2613
2614
2615 static const char hlp_putval[] =
2616   "PUTVAL <key> [<percent_escaped_value>]\n"
2617   "\n"
2618   "The gpg-agent maintains a kind of environment which may be used to\n"
2619   "store key/value pairs in it, so that they can be retrieved later.\n"
2620   "This may be used by helper daemons to daemonize themself on\n"
2621   "invocation and register them with gpg-agent.  Callers of the\n"
2622   "daemon's service may now first try connect to get the information\n"
2623   "for that service from gpg-agent through the GETVAL command and then\n"
2624   "try to connect to that daemon.  Only if that fails they may start\n"
2625   "an own instance of the service daemon. \n"
2626   "\n"
2627   "KEY is an arbitrary symbol with the same syntax rules as keys\n"
2628   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2629   "corresponding value; they should be similar to the values of\n"
2630   "envronment variables but gpg-agent does not enforce any\n"
2631   "restrictions.  If that value is not given any value under that KEY\n"
2632   "is removed from this special environment.";
2633 static gpg_error_t
2634 cmd_putval (assuan_context_t ctx, char *line)
2635 {
2636   ctrl_t ctrl = assuan_get_pointer (ctx);
2637   int rc = 0;
2638   char *key = NULL;
2639   char *value = NULL;
2640   size_t valuelen = 0;
2641   char *p;
2642   struct putval_item_s *vl, *vlprev;
2643
2644   if (ctrl->restricted)
2645     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2646
2647   for (p=line; *p == ' '; p++)
2648     ;
2649   key = p;
2650   p = strchr (key, ' ');
2651   if (p)
2652     {
2653       *p++ = 0;
2654       for (; *p == ' '; p++)
2655         ;
2656       if (*p)
2657         {
2658           value = p;
2659           p = strchr (value, ' ');
2660           if (p)
2661             *p = 0;
2662           valuelen = percent_plus_unescape_inplace (value, 0);
2663         }
2664     }
2665   if (!*key)
2666     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2667
2668
2669   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2670     if ( !strcmp (vl->d, key) )
2671       break;
2672
2673   if (vl) /* Delete old entry. */
2674     {
2675       if (vlprev)
2676         vlprev->next = vl->next;
2677       else
2678         putval_list = vl->next;
2679       xfree (vl);
2680     }
2681
2682   if (valuelen) /* Add entry. */
2683     {
2684       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2685       if (!vl)
2686         rc = gpg_error_from_syserror ();
2687       else
2688         {
2689           vl->len = valuelen;
2690           vl->off = strlen (key) + 1;
2691           strcpy (vl->d, key);
2692           memcpy (vl->d + vl->off, value, valuelen);
2693           vl->next = putval_list;
2694           putval_list = vl;
2695         }
2696     }
2697
2698   return leave_cmd (ctx, rc);
2699 }
2700
2701
2702
2703 \f
2704 static const char hlp_updatestartuptty[] =
2705   "UPDATESTARTUPTTY\n"
2706   "\n"
2707   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2708   "session.  This command is useful to pull future pinentries to\n"
2709   "another screen.  It is only required because there is no way in the\n"
2710   "ssh-agent protocol to convey this information.";
2711 static gpg_error_t
2712 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2713 {
2714   ctrl_t ctrl = assuan_get_pointer (ctx);
2715   gpg_error_t err = 0;
2716   session_env_t se;
2717   char *lc_ctype = NULL;
2718   char *lc_messages = NULL;
2719   int iterator;
2720   const char *name;
2721
2722   (void)line;
2723
2724   if (ctrl->restricted)
2725     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2726
2727   se = session_env_new ();
2728   if (!se)
2729     err = gpg_error_from_syserror ();
2730
2731   iterator = 0;
2732   while (!err && (name = session_env_list_stdenvnames (&iterator, NULL)))
2733     {
2734       const char *value = session_env_getenv (ctrl->session_env, name);
2735       if (value)
2736         err = session_env_setenv (se, name, value);
2737     }
2738
2739   if (!err && ctrl->lc_ctype)
2740     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2741       err = gpg_error_from_syserror ();
2742
2743   if (!err && ctrl->lc_messages)
2744     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2745       err = gpg_error_from_syserror ();
2746
2747   if (err)
2748     {
2749       session_env_release (se);
2750       xfree (lc_ctype);
2751       xfree (lc_messages);
2752     }
2753   else
2754     {
2755       session_env_release (opt.startup_env);
2756       opt.startup_env = se;
2757       xfree (opt.startup_lc_ctype);
2758       opt.startup_lc_ctype = lc_ctype;
2759       xfree (opt.startup_lc_messages);
2760       opt.startup_lc_messages = lc_messages;
2761     }
2762
2763   return err;
2764 }
2765
2766
2767 \f
2768 static const char hlp_killagent[] =
2769   "KILLAGENT\n"
2770   "\n"
2771   "Stop the agent.";
2772 static gpg_error_t
2773 cmd_killagent (assuan_context_t ctx, char *line)
2774 {
2775   ctrl_t ctrl = assuan_get_pointer (ctx);
2776
2777   (void)line;
2778
2779   if (ctrl->restricted)
2780     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2781
2782   ctrl->server_local->stopme = 1;
2783   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2784   return 0;
2785 }
2786
2787
2788 static const char hlp_reloadagent[] =
2789   "RELOADAGENT\n"
2790   "\n"
2791   "This command is an alternative to SIGHUP\n"
2792   "to reload the configuration.";
2793 static gpg_error_t
2794 cmd_reloadagent (assuan_context_t ctx, char *line)
2795 {
2796   ctrl_t ctrl = assuan_get_pointer (ctx);
2797
2798   (void)line;
2799
2800   if (ctrl->restricted)
2801     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2802
2803   agent_sighup_action ();
2804   return 0;
2805 }
2806
2807
2808 \f
2809 static const char hlp_getinfo[] =
2810   "GETINFO <what>\n"
2811   "\n"
2812   "Multipurpose function to return a variety of information.\n"
2813   "Supported values for WHAT are:\n"
2814   "\n"
2815   "  version         - Return the version of the program.\n"
2816   "  pid             - Return the process id of the server.\n"
2817   "  socket_name     - Return the name of the socket.\n"
2818   "  ssh_socket_name - Return the name of the ssh socket.\n"
2819   "  scd_running     - Return OK if the SCdaemon is already running.\n"
2820   "  s2k_time        - Return the time in milliseconds required for S2K.\n"
2821   "  s2k_count       - Return the standard S2K count.\n"
2822   "  s2k_count_cal   - Return the calibrated S2K count.\n"
2823   "  std_env_names   - List the names of the standard environment.\n"
2824   "  std_session_env - List the standard session environment.\n"
2825   "  std_startup_env - List the standard startup environment.\n"
2826   "  connections     - Return number of active connections.\n"
2827   "  jent_active     - Returns OK if Libgcrypt's JENT is active.\n"
2828   "  restricted      - Returns OK if the connection is in restricted mode.\n"
2829   "  cmd_has_option CMD OPT\n"
2830   "                  - Returns OK if command CMD has option OPT.\n";
2831 static gpg_error_t
2832 cmd_getinfo (assuan_context_t ctx, char *line)
2833 {
2834   ctrl_t ctrl = assuan_get_pointer (ctx);
2835   int rc = 0;
2836
2837   if (!strcmp (line, "version"))
2838     {
2839       const char *s = VERSION;
2840       rc = assuan_send_data (ctx, s, strlen (s));
2841     }
2842   else if (!strncmp (line, "cmd_has_option", 14)
2843            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2844     {
2845       char *cmd, *cmdopt;
2846       line += 14;
2847       while (*line == ' ' || *line == '\t')
2848         line++;
2849       if (!*line)
2850         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2851       else
2852         {
2853           cmd = line;
2854           while (*line && (*line != ' ' && *line != '\t'))
2855             line++;
2856           if (!*line)
2857             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2858           else
2859             {
2860               *line++ = 0;
2861               while (*line == ' ' || *line == '\t')
2862                 line++;
2863               if (!*line)
2864                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2865               else
2866                 {
2867                   cmdopt = line;
2868                   if (!command_has_option (cmd, cmdopt))
2869                     rc = gpg_error (GPG_ERR_GENERAL);
2870                 }
2871             }
2872         }
2873     }
2874   else if (!strcmp (line, "s2k_count"))
2875     {
2876       char numbuf[50];
2877
2878       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2879       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2880     }
2881   else if (!strcmp (line, "restricted"))
2882     {
2883       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2884     }
2885   else if (ctrl->restricted)
2886     {
2887       rc = gpg_error (GPG_ERR_FORBIDDEN);
2888     }
2889   /* All sub-commands below are not allowed in restricted mode.  */
2890   else if (!strcmp (line, "pid"))
2891     {
2892       char numbuf[50];
2893
2894       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2895       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2896     }
2897   else if (!strcmp (line, "socket_name"))
2898     {
2899       const char *s = get_agent_socket_name ();
2900
2901       if (s)
2902         rc = assuan_send_data (ctx, s, strlen (s));
2903       else
2904         rc = gpg_error (GPG_ERR_NO_DATA);
2905     }
2906   else if (!strcmp (line, "ssh_socket_name"))
2907     {
2908       const char *s = get_agent_ssh_socket_name ();
2909
2910       if (s)
2911         rc = assuan_send_data (ctx, s, strlen (s));
2912       else
2913         rc = gpg_error (GPG_ERR_NO_DATA);
2914     }
2915   else if (!strcmp (line, "scd_running"))
2916     {
2917       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2918     }
2919   else if (!strcmp (line, "std_env_names"))
2920     {
2921       int iterator;
2922       const char *name;
2923
2924       iterator = 0;
2925       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2926         {
2927           rc = assuan_send_data (ctx, name, strlen (name)+1);
2928           if (!rc)
2929             rc = assuan_send_data (ctx, NULL, 0);
2930           if (rc)
2931             break;
2932         }
2933     }
2934   else if (!strcmp (line, "std_session_env")
2935            || !strcmp (line, "std_startup_env"))
2936     {
2937       int iterator;
2938       const char *name, *value;
2939       char *string;
2940
2941       iterator = 0;
2942       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2943         {
2944           value = session_env_getenv_or_default
2945             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2946           if (value)
2947             {
2948               string = xtryasprintf ("%s=%s", name, value);
2949               if (!string)
2950                 rc = gpg_error_from_syserror ();
2951               else
2952                 {
2953                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2954                   if (!rc)
2955                     rc = assuan_send_data (ctx, NULL, 0);
2956                 }
2957               if (rc)
2958                 break;
2959             }
2960         }
2961     }
2962   else if (!strcmp (line, "connections"))
2963     {
2964       char numbuf[20];
2965
2966       snprintf (numbuf, sizeof numbuf, "%d",
2967                 get_agent_active_connection_count ());
2968       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2969     }
2970   else if (!strcmp (line, "jent_active"))
2971     {
2972 #if GCRYPT_VERSION_NUMBER >= 0x010800
2973       char *buf;
2974       char *fields[5];
2975
2976       buf = gcry_get_config (0, "rng-type");
2977       if (buf
2978           && split_fields_colon (buf, fields, DIM (fields)) >= 5
2979           && atoi (fields[4]) > 0)
2980         rc = 0;
2981       else
2982         rc = gpg_error (GPG_ERR_FALSE);
2983       gcry_free (buf);
2984 #else
2985       rc = gpg_error (GPG_ERR_FALSE);
2986 #endif
2987     }
2988   else if (!strcmp (line, "s2k_count_cal"))
2989     {
2990       char numbuf[50];
2991
2992       snprintf (numbuf, sizeof numbuf, "%lu", get_calibrated_s2k_count ());
2993       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2994     }
2995   else if (!strcmp (line, "s2k_time"))
2996     {
2997       char numbuf[50];
2998
2999       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_time ());
3000       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
3001     }
3002   else
3003     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
3004   return rc;
3005 }
3006
3007
3008 \f
3009 /* This function is called by Libassuan to parse the OPTION command.
3010    It has been registered similar to the other Assuan commands.  */
3011 static gpg_error_t
3012 option_handler (assuan_context_t ctx, const char *key, const char *value)
3013 {
3014   ctrl_t ctrl = assuan_get_pointer (ctx);
3015   gpg_error_t err = 0;
3016
3017   if (!strcmp (key, "agent-awareness"))
3018     {
3019       /* The value is a version string telling us of which agent
3020          version the caller is aware of.  */
3021       ctrl->server_local->allow_fully_canceled =
3022         gnupg_compare_version (value, "2.1.0");
3023     }
3024   else if (ctrl->restricted)
3025     {
3026       err = gpg_error (GPG_ERR_FORBIDDEN);
3027     }
3028   /* All options below are not allowed in restricted mode.  */
3029   else if (!strcmp (key, "putenv"))
3030     {
3031       /* Change the session's environment to be used for the
3032          Pinentry.  Valid values are:
3033           <NAME>            Delete envvar NAME
3034           <KEY>=            Set envvar NAME to the empty string
3035           <KEY>=<VALUE>     Set envvar NAME to VALUE
3036       */
3037       err = session_env_putenv (ctrl->session_env, value);
3038     }
3039   else if (!strcmp (key, "display"))
3040     {
3041       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
3042     }
3043   else if (!strcmp (key, "ttyname"))
3044     {
3045       if (!opt.keep_tty)
3046         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
3047     }
3048   else if (!strcmp (key, "ttytype"))
3049     {
3050       if (!opt.keep_tty)
3051         err = session_env_setenv (ctrl->session_env, "TERM", value);
3052     }
3053   else if (!strcmp (key, "lc-ctype"))
3054     {
3055       if (ctrl->lc_ctype)
3056         xfree (ctrl->lc_ctype);
3057       ctrl->lc_ctype = xtrystrdup (value);
3058       if (!ctrl->lc_ctype)
3059         return out_of_core ();
3060     }
3061   else if (!strcmp (key, "lc-messages"))
3062     {
3063       if (ctrl->lc_messages)
3064         xfree (ctrl->lc_messages);
3065       ctrl->lc_messages = xtrystrdup (value);
3066       if (!ctrl->lc_messages)
3067         return out_of_core ();
3068     }
3069   else if (!strcmp (key, "xauthority"))
3070     {
3071       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
3072     }
3073   else if (!strcmp (key, "pinentry-user-data"))
3074     {
3075       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
3076     }
3077   else if (!strcmp (key, "use-cache-for-signing"))
3078     ctrl->server_local->use_cache_for_signing = *value? !!atoi (value) : 0;
3079   else if (!strcmp (key, "allow-pinentry-notify"))
3080     ctrl->server_local->allow_pinentry_notify = 1;
3081   else if (!strcmp (key, "pinentry-mode"))
3082     {
3083       int tmp = parse_pinentry_mode (value);
3084       if (tmp == -1)
3085         err = gpg_error (GPG_ERR_INV_VALUE);
3086       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
3087         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3088       else
3089         ctrl->pinentry_mode = tmp;
3090     }
3091   else if (!strcmp (key, "cache-ttl-opt-preset"))
3092     {
3093       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
3094     }
3095   else if (!strcmp (key, "s2k-count"))
3096     {
3097       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
3098       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
3099         {
3100           ctrl->s2k_count = 0;
3101         }
3102     }
3103   else
3104     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
3105
3106   return err;
3107 }
3108
3109
3110
3111 \f
3112 /* Called by libassuan after all commands. ERR is the error from the
3113    last assuan operation and not the one returned from the command. */
3114 static void
3115 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
3116 {
3117   ctrl_t ctrl = assuan_get_pointer (ctx);
3118
3119   (void)err;
3120
3121   /* Switch off any I/O monitor controlled logging pausing. */
3122   ctrl->server_local->pause_io_logging = 0;
3123 }
3124
3125
3126 /* This function is called by libassuan for all I/O.  We use it here
3127    to disable logging for the GETEVENTCOUNTER commands.  This is so
3128    that the debug output won't get cluttered by this primitive
3129    command.  */
3130 static unsigned int
3131 io_monitor (assuan_context_t ctx, void *hook, int direction,
3132             const char *line, size_t linelen)
3133 {
3134   ctrl_t ctrl = assuan_get_pointer (ctx);
3135
3136   (void) hook;
3137
3138   /* We want to suppress all Assuan log messages for connections from
3139    * self.  However, assuan_get_pid works only after
3140    * assuan_accept. Now, assuan_accept already logs a line ending with
3141    * the process id.  We use this hack here to get the peers pid so
3142    * that we can compare it to our pid.  We should add an assuan
3143    * function to return the pid for a file descriptor and use that to
3144    * detect connections to self.  */
3145   if (ctx && !ctrl->server_local->greeting_seen
3146       && direction == ASSUAN_IO_TO_PEER)
3147     {
3148       ctrl->server_local->greeting_seen = 1;
3149       if (linelen > 32
3150           && !strncmp (line, "OK Pleased to meet you, process ", 32)
3151           && strtoul (line+32, NULL, 10) == getpid ())
3152         return ASSUAN_IO_MONITOR_NOLOG;
3153     }
3154
3155
3156   /* Do not log self-connections.  This makes the log cleaner because
3157    * we won't see the check-our-own-socket calls.  */
3158   if (ctx && ctrl->server_local->connect_from_self)
3159     return ASSUAN_IO_MONITOR_NOLOG;
3160
3161   /* Note that we only check for the uppercase name.  This allows the user to
3162      see the logging for debugging if using a non-upercase command
3163      name. */
3164   if (ctx && direction == ASSUAN_IO_FROM_PEER
3165       && linelen >= 15
3166       && !strncmp (line, "GETEVENTCOUNTER", 15)
3167       && (linelen == 15 || spacep (line+15)))
3168     {
3169       ctrl->server_local->pause_io_logging = 1;
3170     }
3171
3172   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3173 }
3174
3175
3176 /* Return true if the command CMD implements the option OPT.  */
3177 static int
3178 command_has_option (const char *cmd, const char *cmdopt)
3179 {
3180   if (!strcmp (cmd, "GET_PASSPHRASE"))
3181     {
3182       if (!strcmp (cmdopt, "repeat"))
3183           return 1;
3184     }
3185
3186   return 0;
3187 }
3188
3189
3190 /* Tell Libassuan about our commands.  Also register the other Assuan
3191    handlers. */
3192 static int
3193 register_commands (assuan_context_t ctx)
3194 {
3195   static struct {
3196     const char *name;
3197     assuan_handler_t handler;
3198     const char * const help;
3199   } table[] = {
3200     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3201     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3202     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3203     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3204     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3205     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3206     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3207     { "SETHASH",        cmd_sethash,   hlp_sethash },
3208     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3209     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3210     { "GENKEY",         cmd_genkey,    hlp_genkey },
3211     { "READKEY",        cmd_readkey,   hlp_readkey },
3212     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3213     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3214     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3215     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3216     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3217     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3218     { "LEARN",          cmd_learn,     hlp_learn },
3219     { "PASSWD",         cmd_passwd,    hlp_passwd },
3220     { "INPUT",          NULL },
3221     { "OUTPUT",         NULL },
3222     { "SCD",            cmd_scd,       hlp_scd },
3223     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3224     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3225     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3226     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3227     { "GETVAL",         cmd_getval,    hlp_getval },
3228     { "PUTVAL",         cmd_putval,    hlp_putval },
3229     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3230     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3231     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3232     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3233     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3234     { NULL }
3235   };
3236   int i, rc;
3237
3238   for (i=0; table[i].name; i++)
3239     {
3240       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3241                                     table[i].help);
3242       if (rc)
3243         return rc;
3244     }
3245   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3246   assuan_register_reset_notify (ctx, reset_notify);
3247   assuan_register_option_handler (ctx, option_handler);
3248   return 0;
3249 }
3250
3251
3252 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3253    simple piper server, otherwise it is a regular server.  CTRL is the
3254    control structure for this connection; it has only the basic
3255    initialization. */
3256 void
3257 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3258 {
3259   int rc;
3260   assuan_context_t ctx = NULL;
3261
3262   if (ctrl->restricted)
3263     {
3264       if (agent_copy_startup_env (ctrl))
3265         return;
3266     }
3267
3268   rc = assuan_new (&ctx);
3269   if (rc)
3270     {
3271       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3272       agent_exit (2);
3273     }
3274
3275   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3276     {
3277       assuan_fd_t filedes[2];
3278
3279       filedes[0] = assuan_fdopen (0);
3280       filedes[1] = assuan_fdopen (1);
3281       rc = assuan_init_pipe_server (ctx, filedes);
3282     }
3283   else if (listen_fd != GNUPG_INVALID_FD)
3284     {
3285       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3286       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3287          this branch is currently not used.  */
3288     }
3289   else
3290     {
3291       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3292     }
3293   if (rc)
3294     {
3295       log_error ("failed to initialize the server: %s\n",
3296                  gpg_strerror(rc));
3297       agent_exit (2);
3298     }
3299   rc = register_commands (ctx);
3300   if (rc)
3301     {
3302       log_error ("failed to register commands with Assuan: %s\n",
3303                  gpg_strerror(rc));
3304       agent_exit (2);
3305     }
3306
3307   assuan_set_pointer (ctx, ctrl);
3308   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3309   ctrl->server_local->assuan_ctx = ctx;
3310   ctrl->server_local->use_cache_for_signing = 1;
3311
3312   ctrl->digest.raw_value = 0;
3313
3314   assuan_set_io_monitor (ctx, io_monitor, NULL);
3315   agent_set_progress_cb (progress_cb, ctrl);
3316
3317   for (;;)
3318     {
3319       pid_t client_pid;
3320
3321       rc = assuan_accept (ctx);
3322       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3323         {
3324           break;
3325         }
3326       else if (rc)
3327         {
3328           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3329           break;
3330         }
3331
3332       client_pid = assuan_get_pid (ctx);
3333       ctrl->server_local->connect_from_self = (client_pid == getpid ());
3334       if (client_pid != ASSUAN_INVALID_PID)
3335         ctrl->client_pid = (unsigned long)client_pid;
3336       else
3337         ctrl->client_pid = 0;
3338
3339       rc = assuan_process (ctx);
3340       if (rc)
3341         {
3342           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3343           continue;
3344         }
3345     }
3346
3347   /* Reset the nonce caches.  */
3348   clear_nonce_cache (ctrl);
3349
3350   /* Reset the SCD if needed. */
3351   agent_reset_scd (ctrl);
3352
3353   /* Reset the pinentry (in case of popup messages). */
3354   agent_reset_query (ctrl);
3355
3356   /* Cleanup.  */
3357   assuan_release (ctx);
3358   xfree (ctrl->server_local->keydesc);
3359   xfree (ctrl->server_local->import_key);
3360   xfree (ctrl->server_local->export_key);
3361   if (ctrl->server_local->stopme)
3362     agent_exit (0);
3363   xfree (ctrl->server_local);
3364   ctrl->server_local = NULL;
3365 }
3366
3367
3368 /* Helper for the pinentry loopback mode.  It merely passes the
3369    parameters on to the client.  */
3370 gpg_error_t
3371 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3372                   unsigned char **buffer, size_t *size,
3373                   size_t max_length)
3374 {
3375   gpg_error_t rc;
3376   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3377
3378   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3379   if (rc)
3380     return rc;
3381
3382   assuan_begin_confidential (ctx);
3383   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3384   assuan_end_confidential (ctx);
3385   return rc;
3386 }