agent: Allow recursive use of pinentry.
[gnupg.git] / agent / call-pinentry.c
1 /* call-pinentry.c - Spawn the pinentry to query stuff from the user
2  * Copyright (C) 2001, 2002, 2004, 2007, 2008,
3  *               2010  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <assert.h>
28 #include <unistd.h>
29 #include <sys/stat.h>
30 #ifndef HAVE_W32_SYSTEM
31 # include <sys/wait.h>
32 # include <sys/types.h>
33 # include <signal.h>
34 # include <sys/utsname.h>
35 #endif
36 #include <npth.h>
37
38 #include "agent.h"
39 #include <assuan.h>
40 #include "../common/sysutils.h"
41 #include "../common/i18n.h"
42
43 #ifdef _POSIX_OPEN_MAX
44 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
45 #else
46 #define MAX_OPEN_FDS 20
47 #endif
48
49
50 /* Because access to the pinentry must be serialized (it is and shall
51    be a global mutually exclusive dialog) we better timeout pending
52    requests after some time.  1 minute seem to be a reasonable
53    time. */
54 #define LOCK_TIMEOUT  (1*60)
55
56 /* The assuan context of the current pinentry. */
57 static assuan_context_t entry_ctx;
58
59 /* A list of features of the current pinentry.  */
60 static struct
61 {
62   /* The Pinentry support RS+US tabbing.  This means that a RS (0x1e)
63    * starts a new tabbing block in which a US (0x1f) followed by a
64    * colon marks a colon.  A pinentry can use this to pretty print
65    * name value pairs.  */
66   unsigned int tabbing:1;
67 } entry_features;
68
69
70 /* The control variable of the connection owning the current pinentry.
71    This is only valid if ENTRY_CTX is not NULL.  Note, that we care
72    only about the value of the pointer and that it should never be
73    dereferenced.  */
74 static ctrl_t entry_owner;
75
76 /* A mutex used to serialize access to the pinentry. */
77 static npth_mutex_t entry_lock;
78
79 /* The thread ID of the popup working thread. */
80 static npth_t  popup_tid;
81
82 /* A flag used in communication between the popup working thread and
83    its stop function. */
84 static int popup_finished;
85
86
87
88 /* Data to be passed to our callbacks, */
89 struct entry_parm_s
90 {
91   int lines;
92   size_t size;
93   unsigned char *buffer;
94 };
95
96
97
98 \f
99 /* This function must be called once to initialize this module.  This
100    has to be done before a second thread is spawned.  We can't do the
101    static initialization because Pth emulation code might not be able
102    to do a static init; in particular, it is not possible for W32. */
103 void
104 initialize_module_call_pinentry (void)
105 {
106   static int initialized;
107
108   if (!initialized)
109     {
110       if (npth_mutex_init (&entry_lock, NULL))
111         initialized = 1;
112     }
113 }
114
115
116
117 /* This function may be called to print information pertaining to the
118    current state of this module to the log. */
119 void
120 agent_query_dump_state (void)
121 {
122   log_info ("agent_query_dump_state: entry_ctx=%p pid=%ld popup_tid=%p\n",
123             entry_ctx, (long)assuan_get_pid (entry_ctx), (void*)popup_tid);
124 }
125
126 /* Called to make sure that a popup window owned by the current
127    connection gets closed. */
128 void
129 agent_reset_query (ctrl_t ctrl)
130 {
131   if (entry_ctx && popup_tid && entry_owner == ctrl)
132     {
133       agent_popup_message_stop (ctrl);
134     }
135 }
136
137
138 /* Unlock the pinentry so that another thread can start one and
139    disconnect that pinentry - we do this after the unlock so that a
140    stalled pinentry does not block other threads.  Fixme: We should
141    have a timeout in Assuan for the disconnect operation. */
142 static gpg_error_t
143 unlock_pinentry (gpg_error_t rc)
144 {
145   assuan_context_t ctx = entry_ctx;
146   int err;
147
148   if (rc)
149     {
150       if (DBG_IPC)
151         log_debug ("error calling pinentry: %s <%s>\n",
152                    gpg_strerror (rc), gpg_strsource (rc));
153
154       /* Change the source of the error to pinentry so that the final
155          consumer of the error code knows that the problem is with
156          pinentry.  For backward compatibility we do not do that for
157          some common error codes.  */
158       switch (gpg_err_code (rc))
159         {
160         case GPG_ERR_NO_PIN_ENTRY:
161         case GPG_ERR_CANCELED:
162         case GPG_ERR_FULLY_CANCELED:
163         case GPG_ERR_ASS_UNKNOWN_INQUIRE:
164         case GPG_ERR_ASS_TOO_MUCH_DATA:
165         case GPG_ERR_NO_PASSPHRASE:
166         case GPG_ERR_BAD_PASSPHRASE:
167         case GPG_ERR_BAD_PIN:
168           break;
169
170         case GPG_ERR_CORRUPTED_PROTECTION:
171           /* This comes from gpg-agent.  */
172           break;
173
174         default:
175           rc = gpg_err_make (GPG_ERR_SOURCE_PINENTRY, gpg_err_code (rc));
176           break;
177         }
178     }
179
180   if (--entry_owner->pinentry_level == 0)
181     {
182       entry_owner = NULL;
183       entry_ctx = NULL;
184       err = npth_mutex_unlock (&entry_lock);
185       if (err)
186         {
187           log_error ("failed to release the entry lock: %s\n", strerror (err));
188           if (!rc)
189             rc = gpg_error_from_errno (err);
190         }
191       assuan_release (ctx);
192     }
193   return rc;
194 }
195
196
197 /* To make sure we leave no secrets in our image after forking of the
198    pinentry, we use this callback. */
199 static void
200 atfork_cb (void *opaque, int where)
201 {
202   ctrl_t ctrl = opaque;
203
204   if (!where)
205     {
206       int iterator = 0;
207       const char *name, *assname, *value;
208
209       gcry_control (GCRYCTL_TERM_SECMEM);
210
211       while ((name = session_env_list_stdenvnames (&iterator, &assname)))
212         {
213           /* For all new envvars (!ASSNAME) and the two medium old
214              ones which do have an assuan name but are conveyed using
215              environment variables, update the environment of the
216              forked process.  */
217           if (!assname
218               || !strcmp (name, "XAUTHORITY")
219               || !strcmp (name, "PINENTRY_USER_DATA"))
220             {
221               value = session_env_getenv (ctrl->session_env, name);
222               if (value)
223                 gnupg_setenv (name, value, 1);
224             }
225         }
226     }
227 }
228
229
230 /* Status line callback for the FEATURES status.  */
231 static gpg_error_t
232 getinfo_features_cb (void *opaque, const char *line)
233 {
234   const char *args;
235   char **tokens;
236   int i;
237
238   (void)opaque;
239
240   if ((args = has_leading_keyword (line, "FEATURES")))
241     {
242       tokens = strtokenize (args, " ");
243       if (!tokens)
244         return gpg_error_from_syserror ();
245       for (i=0; tokens[i]; i++)
246         if (!strcmp (tokens[i], "tabbing"))
247           entry_features.tabbing = 1;
248       xfree (tokens);
249     }
250
251   return 0;
252 }
253
254
255 static gpg_error_t
256 getinfo_pid_cb (void *opaque, const void *buffer, size_t length)
257 {
258   unsigned long *pid = opaque;
259   char pidbuf[50];
260
261   /* There is only the pid in the server's response.  */
262   if (length >= sizeof pidbuf)
263     length = sizeof pidbuf -1;
264   if (length)
265     {
266       strncpy (pidbuf, buffer, length);
267       pidbuf[length] = 0;
268       *pid = strtoul (pidbuf, NULL, 10);
269     }
270   return 0;
271 }
272
273
274 /* Fork off the pin entry if this has not already been done.  Note,
275    that this function must always be used to acquire the lock for the
276    pinentry - we will serialize _all_ pinentry calls.
277  */
278 static gpg_error_t
279 start_pinentry (ctrl_t ctrl)
280 {
281   int rc = 0;
282   const char *full_pgmname;
283   const char *pgmname;
284   assuan_context_t ctx;
285   const char *argv[5];
286   assuan_fd_t no_close_list[3];
287   int i;
288   const char *tmpstr;
289   unsigned long pinentry_pid;
290   const char *value;
291   struct timespec abstime;
292   char *flavor_version;
293   int err;
294
295   if (entry_owner == ctrl)
296     {
297       /* Allow recursive use of pinentry.  */
298       ctrl->pinentry_level++;
299       return 0;
300     }
301
302   npth_clock_gettime (&abstime);
303   abstime.tv_sec += LOCK_TIMEOUT;
304   err = npth_mutex_timedlock (&entry_lock, &abstime);
305   if (err)
306     {
307       if (err == ETIMEDOUT)
308         rc = gpg_error (GPG_ERR_TIMEOUT);
309       else
310         rc = gpg_error_from_errno (rc);
311       log_error (_("failed to acquire the pinentry lock: %s\n"),
312                  gpg_strerror (rc));
313       return rc;
314     }
315
316   entry_owner = ctrl;
317
318   if (entry_ctx)
319     return 0;
320
321   if (opt.verbose)
322     log_info ("starting a new PIN Entry\n");
323
324 #ifdef HAVE_W32_SYSTEM
325   fflush (stdout);
326   fflush (stderr);
327 #endif
328   if (fflush (NULL))
329     {
330 #ifndef HAVE_W32_SYSTEM
331       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
332 #endif
333       log_error ("error flushing pending output: %s\n", strerror (errno));
334       /* At least Windows XP fails here with EBADF.  According to docs
335          and Wine an fflush(NULL) is the same as _flushall.  However
336          the Wine implementation does not flush stdin,stdout and stderr
337          - see above.  Let's try to ignore the error. */
338 #ifndef HAVE_W32_SYSTEM
339       return unlock_pinentry (tmperr);
340 #endif
341     }
342
343   full_pgmname = opt.pinentry_program;
344   if (!full_pgmname || !*full_pgmname)
345     full_pgmname = gnupg_module_name (GNUPG_MODULE_NAME_PINENTRY);
346   if ( !(pgmname = strrchr (full_pgmname, '/')))
347     pgmname = full_pgmname;
348   else
349     pgmname++;
350
351   /* OS X needs the entire file name in argv[0], so that it can locate
352      the resource bundle.  For other systems we stick to the usual
353      convention of supplying only the name of the program.  */
354 #ifdef __APPLE__
355   argv[0] = full_pgmname;
356 #else /*!__APPLE__*/
357   argv[0] = pgmname;
358 #endif /*__APPLE__*/
359
360   if (!opt.keep_display
361       && (value = session_env_getenv (ctrl->session_env, "DISPLAY")))
362     {
363       argv[1] = "--display";
364       argv[2] = value;
365       argv[3] = NULL;
366     }
367   else
368     argv[1] = NULL;
369
370   i=0;
371   if (!opt.running_detached)
372     {
373       if (log_get_fd () != -1)
374         no_close_list[i++] = assuan_fd_from_posix_fd (log_get_fd ());
375       no_close_list[i++] = assuan_fd_from_posix_fd (fileno (stderr));
376     }
377   no_close_list[i] = ASSUAN_INVALID_FD;
378
379   rc = assuan_new (&ctx);
380   if (rc)
381     {
382       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
383       return rc;
384     }
385
386   ctrl->pinentry_level = 1;
387   entry_ctx = ctx;
388
389   /* We don't want to log the pinentry communication to make the logs
390      easier to read.  We might want to add a new debug option to enable
391      pinentry logging.  */
392 #ifdef ASSUAN_NO_LOGGING
393   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, !opt.debug_pinentry);
394 #endif
395
396   /* Connect to the pinentry and perform initial handshaking.  Note
397      that atfork is used to change the environment for pinentry.  We
398      start the server in detached mode to suppress the console window
399      under Windows.  */
400   rc = assuan_pipe_connect (entry_ctx, full_pgmname, argv,
401                             no_close_list, atfork_cb, ctrl,
402                             ASSUAN_PIPE_CONNECT_DETACHED);
403   if (rc)
404     {
405       log_error ("can't connect to the PIN entry module '%s': %s\n",
406                  full_pgmname, gpg_strerror (rc));
407       return unlock_pinentry (gpg_error (GPG_ERR_NO_PIN_ENTRY));
408     }
409
410   if (DBG_IPC)
411     log_debug ("connection to PIN entry established\n");
412
413   value = session_env_getenv (ctrl->session_env, "PINENTRY_USER_DATA");
414   if (value != NULL)
415     {
416       char *optstr;
417       if (asprintf (&optstr, "OPTION pinentry-user-data=%s", value) < 0 )
418         return unlock_pinentry (out_of_core ());
419       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
420                             NULL);
421       xfree (optstr);
422       if (rc && gpg_err_code (rc) != GPG_ERR_UNKNOWN_OPTION)
423         return unlock_pinentry (rc);
424     }
425
426   rc = assuan_transact (entry_ctx,
427                         opt.no_grab? "OPTION no-grab":"OPTION grab",
428                         NULL, NULL, NULL, NULL, NULL, NULL);
429   if (rc)
430     return unlock_pinentry (rc);
431
432   value = session_env_getenv (ctrl->session_env, "GPG_TTY");
433   if (value)
434     {
435       char *optstr;
436       if (asprintf (&optstr, "OPTION ttyname=%s", value) < 0 )
437         return unlock_pinentry (out_of_core ());
438       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
439                             NULL);
440       xfree (optstr);
441       if (rc)
442         return unlock_pinentry (rc);
443     }
444   value = session_env_getenv (ctrl->session_env, "TERM");
445   if (value)
446     {
447       char *optstr;
448       if (asprintf (&optstr, "OPTION ttytype=%s", value) < 0 )
449         return unlock_pinentry (out_of_core ());
450       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
451                             NULL);
452       xfree (optstr);
453       if (rc)
454         return unlock_pinentry (rc);
455     }
456   if (ctrl->lc_ctype)
457     {
458       char *optstr;
459       if (asprintf (&optstr, "OPTION lc-ctype=%s", ctrl->lc_ctype) < 0 )
460         return unlock_pinentry (out_of_core ());
461       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
462                             NULL);
463       xfree (optstr);
464       if (rc)
465         return unlock_pinentry (rc);
466     }
467   if (ctrl->lc_messages)
468     {
469       char *optstr;
470       if (asprintf (&optstr, "OPTION lc-messages=%s", ctrl->lc_messages) < 0 )
471         return unlock_pinentry (out_of_core ());
472       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
473                             NULL);
474       xfree (optstr);
475       if (rc)
476         return unlock_pinentry (rc);
477     }
478
479
480   if (opt.allow_external_cache)
481     {
482       /* Indicate to the pinentry that it may read from an external cache.
483
484          It is essential that the pinentry respect this.  If the
485          cached password is not up to date and retry == 1, then, using
486          a version of GPG Agent that doesn't support this, won't issue
487          another pin request and the user won't get a chance to
488          correct the password.  */
489       rc = assuan_transact (entry_ctx, "OPTION allow-external-password-cache",
490                             NULL, NULL, NULL, NULL, NULL, NULL);
491       if (rc && gpg_err_code (rc) != GPG_ERR_UNKNOWN_OPTION)
492         return unlock_pinentry (rc);
493     }
494
495   if (opt.allow_emacs_pinentry)
496     {
497       /* Indicate to the pinentry that it may read passphrase through
498          Emacs minibuffer, if possible.  */
499       rc = assuan_transact (entry_ctx, "OPTION allow-emacs-prompt",
500                             NULL, NULL, NULL, NULL, NULL, NULL);
501       if (rc && gpg_err_code (rc) != GPG_ERR_UNKNOWN_OPTION)
502         return unlock_pinentry (rc);
503     }
504
505
506   {
507     /* Provide a few default strings for use by the pinentries.  This
508        may help a pinentry to avoid implementing localization code.  */
509     static const struct { const char *key, *value; int what; } tbl[] = {
510       /* TRANSLATORS: These are labels for buttons etc used in
511          Pinentries.  An underscore indicates that the next letter
512          should be used as an accelerator.  Double the underscore for
513          a literal one.  The actual to be translated text starts after
514          the second vertical bar.  Note that gpg-agent has been set to
515          utf-8 so that the strings are in the expected encoding.  */
516       { "ok",     N_("|pinentry-label|_OK") },
517       { "cancel", N_("|pinentry-label|_Cancel") },
518       { "yes",    N_("|pinentry-label|_Yes") },
519       { "no",     N_("|pinentry-label|_No") },
520       { "prompt", N_("|pinentry-label|PIN:") },
521       { "pwmngr", N_("|pinentry-label|_Save in password manager"), 1 },
522       { "cf-visi",N_("Do you really want to make your "
523                      "passphrase visible on the screen?") },
524       { "tt-visi",N_("|pinentry-tt|Make passphrase visible") },
525       { "tt-hide",N_("|pinentry-tt|Hide passphrase") },
526       { NULL, NULL}
527     };
528     char *optstr;
529     int idx;
530     const char *s, *s2;
531
532     for (idx=0; tbl[idx].key; idx++)
533       {
534         if (!opt.allow_external_cache && tbl[idx].what == 1)
535           continue;  /* No need for it.  */
536         s = L_(tbl[idx].value);
537         if (*s == '|' && (s2=strchr (s+1,'|')))
538           s = s2+1;
539         if (asprintf (&optstr, "OPTION default-%s=%s", tbl[idx].key, s) < 0 )
540           return unlock_pinentry (out_of_core ());
541         assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
542                          NULL);
543         xfree (optstr);
544       }
545   }
546
547   /* Tell the pinentry that we would prefer that the given character
548      is used as the invisible character by the entry widget.  */
549   if (opt.pinentry_invisible_char)
550     {
551       char *optstr;
552       if ((optstr = xtryasprintf ("OPTION invisible-char=%s",
553                                   opt.pinentry_invisible_char)))
554         {
555           assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
556                            NULL);
557           /* We ignore errors because this is just a fancy thing and
558              older pinentries do not support this feature.  */
559           xfree (optstr);
560         }
561     }
562
563   if (opt.pinentry_timeout)
564     {
565       char *optstr;
566       if ((optstr = xtryasprintf ("SETTIMEOUT %lu", opt.pinentry_timeout)))
567         {
568           assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
569                            NULL);
570           /* We ignore errors because this is just a fancy thing.  */
571           xfree (optstr);
572         }
573     }
574
575   /* Tell the pinentry the name of a file it shall touch after having
576      messed with the tty.  This is optional and only supported by
577      newer pinentries and thus we do no error checking. */
578   tmpstr = opt.pinentry_touch_file;
579   if (tmpstr && !strcmp (tmpstr, "/dev/null"))
580     tmpstr = NULL;
581   else if (!tmpstr)
582     tmpstr = get_agent_socket_name ();
583   if (tmpstr)
584     {
585       char *optstr;
586
587       if (asprintf (&optstr, "OPTION touch-file=%s", tmpstr ) < 0 )
588         ;
589       else
590         {
591           assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
592                            NULL);
593           xfree (optstr);
594         }
595     }
596
597   /* Tell Pinentry about our client.  */
598   if (ctrl->client_pid)
599     {
600       char *optstr;
601       const char *nodename = "";
602
603 #ifndef HAVE_W32_SYSTEM
604       struct utsname utsbuf;
605       if (!uname (&utsbuf))
606         nodename = utsbuf.nodename;
607 #endif /*!HAVE_W32_SYSTEM*/
608
609       if ((optstr = xtryasprintf ("OPTION owner=%lu %s",
610                                   ctrl->client_pid, nodename)))
611         {
612           assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
613                            NULL);
614           /* We ignore errors because this is just a fancy thing and
615              older pinentries do not support this feature.  */
616           xfree (optstr);
617         }
618     }
619
620
621   /* Ask the pinentry for its version and flavor and store that as a
622    * string in MB.  This information is useful for helping users to
623    * figure out Pinentry problems.  Noet that "flavor" may also return
624    * a status line with the features; we use a dedicated handler for
625    * that.  */
626   {
627     membuf_t mb;
628
629     init_membuf (&mb, 256);
630     if (assuan_transact (entry_ctx, "GETINFO flavor",
631                          put_membuf_cb, &mb,
632                          NULL, NULL,
633                          getinfo_features_cb, NULL))
634       put_membuf_str (&mb, "unknown");
635     put_membuf_str (&mb, " ");
636     if (assuan_transact (entry_ctx, "GETINFO version",
637                          put_membuf_cb, &mb, NULL, NULL, NULL, NULL))
638       put_membuf_str (&mb, "unknown");
639     put_membuf_str (&mb, " ");
640     if (assuan_transact (entry_ctx, "GETINFO ttyinfo",
641                          put_membuf_cb, &mb, NULL, NULL, NULL, NULL))
642       put_membuf_str (&mb, "? ? ?");
643     put_membuf (&mb, "", 1);
644     flavor_version = get_membuf (&mb, NULL);
645   }
646
647
648   /* Now ask the Pinentry for its PID.  If the Pinentry is new enough
649      it will send the pid back and we will use an inquire to notify
650      our client.  The client may answer the inquiry either with END or
651      with CAN to cancel the pinentry. */
652   rc = assuan_transact (entry_ctx, "GETINFO pid",
653                         getinfo_pid_cb, &pinentry_pid,
654                         NULL, NULL, NULL, NULL);
655   if (rc)
656     {
657       log_info ("You may want to update to a newer pinentry\n");
658       rc = 0;
659     }
660   else if (!rc && (pid_t)pinentry_pid == (pid_t)(-1))
661     log_error ("pinentry did not return a PID\n");
662   else
663     {
664       rc = agent_inq_pinentry_launched (ctrl, pinentry_pid, flavor_version);
665       if (gpg_err_code (rc) == GPG_ERR_CANCELED
666           || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
667         return unlock_pinentry (gpg_err_make (GPG_ERR_SOURCE_DEFAULT,
668                                               gpg_err_code (rc)));
669       rc = 0;
670     }
671
672   xfree (flavor_version);
673
674   return rc;
675 }
676
677
678 /* Returns True if the pinentry is currently active. If WAITSECONDS is
679    greater than zero the function will wait for this many seconds
680    before returning.  */
681 int
682 pinentry_active_p (ctrl_t ctrl, int waitseconds)
683 {
684   int err;
685   (void)ctrl;
686
687   if (waitseconds > 0)
688     {
689       struct timespec abstime;
690       int rc;
691
692       npth_clock_gettime (&abstime);
693       abstime.tv_sec += waitseconds;
694       err = npth_mutex_timedlock (&entry_lock, &abstime);
695       if (err)
696         {
697           if (err == ETIMEDOUT)
698             rc = gpg_error (GPG_ERR_TIMEOUT);
699           else
700             rc = gpg_error (GPG_ERR_INTERNAL);
701           return rc;
702         }
703     }
704   else
705     {
706       err = npth_mutex_trylock (&entry_lock);
707       if (err)
708         return gpg_error (GPG_ERR_LOCKED);
709     }
710
711   err = npth_mutex_unlock (&entry_lock);
712   if (err)
713     log_error ("failed to release the entry lock at %d: %s\n", __LINE__,
714                strerror (errno));
715   return 0;
716 }
717
718
719 static gpg_error_t
720 getpin_cb (void *opaque, const void *buffer, size_t length)
721 {
722   struct entry_parm_s *parm = opaque;
723
724   if (!buffer)
725     return 0;
726
727   /* we expect the pin to fit on one line */
728   if (parm->lines || length >= parm->size)
729     return gpg_error (GPG_ERR_ASS_TOO_MUCH_DATA);
730
731   /* fixme: we should make sure that the assuan buffer is allocated in
732      secure memory or read the response byte by byte */
733   memcpy (parm->buffer, buffer, length);
734   parm->buffer[length] = 0;
735   parm->lines++;
736   return 0;
737 }
738
739
740 static int
741 all_digitsp( const char *s)
742 {
743   for (; *s && *s >= '0' && *s <= '9'; s++)
744     ;
745   return !*s;
746 }
747
748
749 /* Return a new malloced string by unescaping the string S.  Escaping
750    is percent escaping and '+'/space mapping.  A binary Nul will
751    silently be replaced by a 0xFF.  Function returns NULL to indicate
752    an out of memory status.  Parsing stops at the end of the string or
753    a white space character. */
754 static char *
755 unescape_passphrase_string (const unsigned char *s)
756 {
757   char *buffer, *d;
758
759   buffer = d = xtrymalloc_secure (strlen ((const char*)s)+1);
760   if (!buffer)
761     return NULL;
762   while (*s && !spacep (s))
763     {
764       if (*s == '%' && s[1] && s[2])
765         {
766           s++;
767           *d = xtoi_2 (s);
768           if (!*d)
769             *d = '\xff';
770           d++;
771           s += 2;
772         }
773       else if (*s == '+')
774         {
775           *d++ = ' ';
776           s++;
777         }
778       else
779         *d++ = *s++;
780     }
781   *d = 0;
782   return buffer;
783 }
784
785
786 /* Estimate the quality of the passphrase PW and return a value in the
787    range 0..100.  */
788 static int
789 estimate_passphrase_quality (const char *pw)
790 {
791   int goodlength = opt.min_passphrase_len + opt.min_passphrase_len/3;
792   int length;
793   const char *s;
794
795   if (goodlength < 1)
796     return 0;
797
798   for (length = 0, s = pw; *s; s++)
799     if (!spacep (s))
800       length ++;
801
802   if (length > goodlength)
803     return 100;
804   return ((length*10) / goodlength)*10;
805 }
806
807
808 /* Handle the QUALITY inquiry. */
809 static gpg_error_t
810 inq_quality (void *opaque, const char *line)
811 {
812   assuan_context_t ctx = opaque;
813   const char *s;
814   char *pin;
815   int rc;
816   int percent;
817   char numbuf[20];
818
819   if ((s = has_leading_keyword (line, "QUALITY")))
820     {
821       pin = unescape_passphrase_string (s);
822       if (!pin)
823         rc = gpg_error_from_syserror ();
824       else
825         {
826           percent = estimate_passphrase_quality (pin);
827           if (check_passphrase_constraints (NULL, pin, NULL))
828             percent = -percent;
829           snprintf (numbuf, sizeof numbuf, "%d", percent);
830           rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
831           xfree (pin);
832         }
833     }
834   else
835     {
836       log_error ("unsupported inquiry '%s' from pinentry\n", line);
837       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
838     }
839
840   return rc;
841 }
842
843
844 /* Helper for agent_askpin and agent_get_passphrase.  */
845 static gpg_error_t
846 setup_qualitybar (ctrl_t ctrl)
847 {
848   int rc;
849   char line[ASSUAN_LINELENGTH];
850   char *tmpstr, *tmpstr2;
851   const char *tooltip;
852
853   (void)ctrl;
854
855   /* TRANSLATORS: This string is displayed by Pinentry as the label
856      for the quality bar.  */
857   tmpstr = try_percent_escape (L_("Quality:"), "\t\r\n\f\v");
858   snprintf (line, DIM(line), "SETQUALITYBAR %s", tmpstr? tmpstr:"");
859   xfree (tmpstr);
860   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
861   if (rc == 103 /*(Old assuan error code)*/
862       || gpg_err_code (rc) == GPG_ERR_ASS_UNKNOWN_CMD)
863     ; /* Ignore Unknown Command from old Pinentry versions.  */
864   else if (rc)
865     return rc;
866
867   tmpstr2 = gnupg_get_help_string ("pinentry.qualitybar.tooltip", 0);
868   if (tmpstr2)
869     tooltip = tmpstr2;
870   else
871     {
872       /* TRANSLATORS: This string is a tooltip, shown by pinentry when
873          hovering over the quality bar.  Please use an appropriate
874          string to describe what this is about.  The length of the
875          tooltip is limited to about 900 characters.  If you do not
876          translate this entry, a default english text (see source)
877          will be used. */
878       tooltip =  L_("pinentry.qualitybar.tooltip");
879       if (!strcmp ("pinentry.qualitybar.tooltip", tooltip))
880         tooltip = ("The quality of the text entered above.\n"
881                    "Please ask your administrator for "
882                    "details about the criteria.");
883     }
884   tmpstr = try_percent_escape (tooltip, "\t\r\n\f\v");
885   xfree (tmpstr2);
886   snprintf (line, DIM(line), "SETQUALITYBAR_TT %s", tmpstr? tmpstr:"");
887   xfree (tmpstr);
888   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
889   if (rc == 103 /*(Old assuan error code)*/
890           || gpg_err_code (rc) == GPG_ERR_ASS_UNKNOWN_CMD)
891     ; /* Ignore Unknown Command from old pinentry versions.  */
892   else if (rc)
893     return rc;
894
895   return 0;
896 }
897
898 enum
899   {
900     PINENTRY_STATUS_CLOSE_BUTTON = 1 << 0,
901     PINENTRY_STATUS_PIN_REPEATED = 1 << 8,
902     PINENTRY_STATUS_PASSWORD_FROM_CACHE = 1 << 9
903   };
904
905 /* Check the button_info line for a close action.  Also check for the
906    PIN_REPEATED flag.  */
907 static gpg_error_t
908 pinentry_status_cb (void *opaque, const char *line)
909 {
910   unsigned int *flag = opaque;
911   const char *args;
912
913   if ((args = has_leading_keyword (line, "BUTTON_INFO")))
914     {
915       if (!strcmp (args, "close"))
916         *flag |= PINENTRY_STATUS_CLOSE_BUTTON;
917     }
918   else if (has_leading_keyword (line, "PIN_REPEATED"))
919     {
920       *flag |= PINENTRY_STATUS_PIN_REPEATED;
921     }
922   else if (has_leading_keyword (line, "PASSWORD_FROM_CACHE"))
923     {
924       *flag |= PINENTRY_STATUS_PASSWORD_FROM_CACHE;
925     }
926
927   return 0;
928 }
929
930
931 /* Build a SETDESC command line.  This is a dedicated function so that
932  * it can remove control characters which are not supported by the
933  * current Pinentry.  */
934 static void
935 build_cmd_setdesc (char *line, size_t linelen, const char *desc)
936 {
937   char *src, *dst;
938
939   snprintf (line, linelen, "SETDESC %s", desc);
940   if (!entry_features.tabbing)
941     {
942       /* Remove RS and US.  */
943       for (src=dst=line; *src; src++)
944         if (!strchr ("\x1e\x1f", *src))
945           *dst++ = *src;
946       *dst = 0;
947     }
948 }
949
950
951 \f
952 /* Call the Entry and ask for the PIN.  We do check for a valid PIN
953    number here and repeat it as long as we have invalid formed
954    numbers.  KEYINFO and CACHE_MODE are used to tell pinentry something
955    about the key. */
956 gpg_error_t
957 agent_askpin (ctrl_t ctrl,
958               const char *desc_text, const char *prompt_text,
959               const char *initial_errtext,
960               struct pin_entry_info_s *pininfo,
961               const char *keyinfo, cache_mode_t cache_mode)
962 {
963   gpg_error_t rc;
964   char line[ASSUAN_LINELENGTH];
965   struct entry_parm_s parm;
966   const char *errtext = NULL;
967   int is_pin = 0;
968   int saveflag;
969   unsigned int pinentry_status;
970
971   if (opt.batch)
972     return 0; /* fixme: we should return BAD PIN */
973
974   if (ctrl->pinentry_mode != PINENTRY_MODE_ASK)
975     {
976       if (ctrl->pinentry_mode == PINENTRY_MODE_CANCEL)
977         return gpg_error (GPG_ERR_CANCELED);
978       if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
979         {
980           unsigned char *passphrase;
981           size_t size;
982
983           *pininfo->pin = 0; /* Reset the PIN. */
984           rc = pinentry_loopback (ctrl, "PASSPHRASE", &passphrase, &size,
985                                   pininfo->max_length - 1);
986           if (rc)
987             return rc;
988
989           memcpy(&pininfo->pin, passphrase, size);
990           xfree(passphrase);
991           pininfo->pin[size] = 0;
992           if (pininfo->check_cb)
993             {
994               /* More checks by utilizing the optional callback. */
995               pininfo->cb_errtext = NULL;
996               rc = pininfo->check_cb (pininfo);
997             }
998           return rc;
999         }
1000       return gpg_error(GPG_ERR_NO_PIN_ENTRY);
1001     }
1002
1003   if (!pininfo || pininfo->max_length < 1)
1004     return gpg_error (GPG_ERR_INV_VALUE);
1005   if (!desc_text && pininfo->min_digits)
1006     desc_text = L_("Please enter your PIN, so that the secret key "
1007                    "can be unlocked for this session");
1008   else if (!desc_text)
1009     desc_text = L_("Please enter your passphrase, so that the secret key "
1010                    "can be unlocked for this session");
1011
1012   if (prompt_text)
1013     is_pin = !!strstr (prompt_text, "PIN");
1014   else
1015     is_pin = desc_text && strstr (desc_text, "PIN");
1016
1017   rc = start_pinentry (ctrl);
1018   if (rc)
1019     return rc;
1020
1021   /* If we have a KEYINFO string and are normal, user, or ssh cache
1022      mode, we tell that the Pinentry so it may use it for own caching
1023      purposes.  Most pinentries won't have this implemented and thus
1024      we do not error out in this case.  */
1025   if (keyinfo && (cache_mode == CACHE_MODE_NORMAL
1026                   || cache_mode == CACHE_MODE_USER
1027                   || cache_mode == CACHE_MODE_SSH))
1028     snprintf (line, DIM(line), "SETKEYINFO %c/%s",
1029               cache_mode == CACHE_MODE_USER? 'u' :
1030               cache_mode == CACHE_MODE_SSH? 's' : 'n',
1031               keyinfo);
1032   else
1033     snprintf (line, DIM(line), "SETKEYINFO --clear");
1034
1035   rc = assuan_transact (entry_ctx, line,
1036                         NULL, NULL, NULL, NULL, NULL, NULL);
1037   if (rc && gpg_err_code (rc) != GPG_ERR_ASS_UNKNOWN_CMD)
1038     return unlock_pinentry (rc);
1039
1040   build_cmd_setdesc (line, DIM(line), desc_text);
1041   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1042   if (rc)
1043     return unlock_pinentry (rc);
1044
1045   snprintf (line, DIM(line), "SETPROMPT %s",
1046             prompt_text? prompt_text : is_pin? L_("PIN:") : L_("Passphrase:"));
1047   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1048   if (rc)
1049     return unlock_pinentry (rc);
1050
1051   /* If a passphrase quality indicator has been requested and a
1052      minimum passphrase length has not been disabled, send the command
1053      to the pinentry.  */
1054   if (pininfo->with_qualitybar && opt.min_passphrase_len )
1055     {
1056       rc = setup_qualitybar (ctrl);
1057       if (rc)
1058         return unlock_pinentry (rc);
1059     }
1060
1061   if (initial_errtext)
1062     {
1063       snprintf (line, DIM(line), "SETERROR %s", initial_errtext);
1064       rc = assuan_transact (entry_ctx, line,
1065                             NULL, NULL, NULL, NULL, NULL, NULL);
1066       if (rc)
1067         return unlock_pinentry (rc);
1068     }
1069
1070   if (pininfo->with_repeat)
1071     {
1072       snprintf (line, DIM(line), "SETREPEATERROR %s",
1073                 L_("does not match - try again"));
1074       rc = assuan_transact (entry_ctx, line,
1075                             NULL, NULL, NULL, NULL, NULL, NULL);
1076       if (rc)
1077         pininfo->with_repeat = 0; /* Pinentry does not support it.  */
1078     }
1079   pininfo->repeat_okay = 0;
1080
1081   for (;pininfo->failed_tries < pininfo->max_tries; pininfo->failed_tries++)
1082     {
1083       memset (&parm, 0, sizeof parm);
1084       parm.size = pininfo->max_length;
1085       *pininfo->pin = 0; /* Reset the PIN. */
1086       parm.buffer = (unsigned char*)pininfo->pin;
1087
1088       if (errtext)
1089         {
1090           /* TRANSLATORS: The string is appended to an error message in
1091              the pinentry.  The %s is the actual error message, the
1092              two %d give the current and maximum number of tries. */
1093           snprintf (line, DIM(line), L_("SETERROR %s (try %d of %d)"),
1094                     errtext, pininfo->failed_tries+1, pininfo->max_tries);
1095           rc = assuan_transact (entry_ctx, line,
1096                                 NULL, NULL, NULL, NULL, NULL, NULL);
1097           if (rc)
1098             return unlock_pinentry (rc);
1099           errtext = NULL;
1100         }
1101
1102       if (pininfo->with_repeat)
1103         {
1104           snprintf (line, DIM(line), "SETREPEAT %s", L_("Repeat:"));
1105           rc = assuan_transact (entry_ctx, line,
1106                                 NULL, NULL, NULL, NULL, NULL, NULL);
1107           if (rc)
1108             return unlock_pinentry (rc);
1109         }
1110
1111       saveflag = assuan_get_flag (entry_ctx, ASSUAN_CONFIDENTIAL);
1112       assuan_begin_confidential (entry_ctx);
1113       pinentry_status = 0;
1114       rc = assuan_transact (entry_ctx, "GETPIN", getpin_cb, &parm,
1115                             inq_quality, entry_ctx,
1116                             pinentry_status_cb, &pinentry_status);
1117       assuan_set_flag (entry_ctx, ASSUAN_CONFIDENTIAL, saveflag);
1118       /* Most pinentries out in the wild return the old Assuan error code
1119          for canceled which gets translated to an assuan Cancel error and
1120          not to the code for a user cancel.  Fix this here. */
1121       if (rc && gpg_err_source (rc)
1122           && gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
1123         rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_CANCELED);
1124
1125
1126       /* Change error code in case the window close button was clicked
1127          to cancel the operation.  */
1128       if ((pinentry_status & PINENTRY_STATUS_CLOSE_BUTTON)
1129           && gpg_err_code (rc) == GPG_ERR_CANCELED)
1130         rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_FULLY_CANCELED);
1131
1132       if (gpg_err_code (rc) == GPG_ERR_ASS_TOO_MUCH_DATA)
1133         errtext = is_pin? L_("PIN too long")
1134                         : L_("Passphrase too long");
1135       else if (rc)
1136         return unlock_pinentry (rc);
1137
1138       if (!errtext && pininfo->min_digits)
1139         {
1140           /* do some basic checks on the entered PIN. */
1141           if (!all_digitsp (pininfo->pin))
1142             errtext = L_("Invalid characters in PIN");
1143           else if (pininfo->max_digits
1144                    && strlen (pininfo->pin) > pininfo->max_digits)
1145             errtext = L_("PIN too long");
1146           else if (strlen (pininfo->pin) < pininfo->min_digits)
1147             errtext = L_("PIN too short");
1148         }
1149
1150       if (!errtext && pininfo->check_cb)
1151         {
1152           /* More checks by utilizing the optional callback. */
1153           pininfo->cb_errtext = NULL;
1154           rc = pininfo->check_cb (pininfo);
1155           if (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
1156               && pininfo->cb_errtext)
1157             errtext = pininfo->cb_errtext;
1158           else if (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
1159                    || gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1160             errtext = (is_pin? L_("Bad PIN") : L_("Bad Passphrase"));
1161           else if (rc)
1162             return unlock_pinentry (rc);
1163         }
1164
1165       if (!errtext)
1166         {
1167           if (pininfo->with_repeat
1168               && (pinentry_status & PINENTRY_STATUS_PIN_REPEATED))
1169             pininfo->repeat_okay = 1;
1170           return unlock_pinentry (0); /* okay, got a PIN or passphrase */
1171         }
1172
1173       if ((pinentry_status & PINENTRY_STATUS_PASSWORD_FROM_CACHE))
1174         /* The password was read from the cache.  Don't count this
1175            against the retry count.  */
1176         pininfo->failed_tries --;
1177     }
1178
1179   return unlock_pinentry (gpg_error (pininfo->min_digits? GPG_ERR_BAD_PIN
1180                           : GPG_ERR_BAD_PASSPHRASE));
1181 }
1182
1183
1184 \f
1185 /* Ask for the passphrase using the supplied arguments.  The returned
1186    passphrase needs to be freed by the caller. */
1187 int
1188 agent_get_passphrase (ctrl_t ctrl,
1189                       char **retpass, const char *desc, const char *prompt,
1190                       const char *errtext, int with_qualitybar,
1191                       const char *keyinfo, cache_mode_t cache_mode)
1192 {
1193
1194   int rc;
1195   char line[ASSUAN_LINELENGTH];
1196   struct entry_parm_s parm;
1197   int saveflag;
1198   unsigned int pinentry_status;
1199
1200   *retpass = NULL;
1201   if (opt.batch)
1202     return gpg_error (GPG_ERR_BAD_PASSPHRASE);
1203
1204   if (ctrl->pinentry_mode != PINENTRY_MODE_ASK)
1205     {
1206       if (ctrl->pinentry_mode == PINENTRY_MODE_CANCEL)
1207         return gpg_error (GPG_ERR_CANCELED);
1208
1209       if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
1210         {
1211           size_t size;
1212
1213           return pinentry_loopback (ctrl, "PASSPHRASE",
1214                                     (unsigned char **)retpass, &size,
1215                                     MAX_PASSPHRASE_LEN);
1216         }
1217       return gpg_error (GPG_ERR_NO_PIN_ENTRY);
1218     }
1219
1220   rc = start_pinentry (ctrl);
1221   if (rc)
1222     return rc;
1223
1224   if (!prompt)
1225     prompt = desc && strstr (desc, "PIN")? L_("PIN:"): L_("Passphrase:");
1226
1227
1228   /* If we have a KEYINFO string and are normal, user, or ssh cache
1229      mode, we tell that the Pinentry so it may use it for own caching
1230      purposes.  Most pinentries won't have this implemented and thus
1231      we do not error out in this case.  */
1232   if (keyinfo && (cache_mode == CACHE_MODE_NORMAL
1233                   || cache_mode == CACHE_MODE_USER
1234                   || cache_mode == CACHE_MODE_SSH))
1235     snprintf (line, DIM(line), "SETKEYINFO %c/%s",
1236               cache_mode == CACHE_MODE_USER? 'u' :
1237               cache_mode == CACHE_MODE_SSH? 's' : 'n',
1238               keyinfo);
1239   else
1240     snprintf (line, DIM(line), "SETKEYINFO --clear");
1241
1242   rc = assuan_transact (entry_ctx, line,
1243                         NULL, NULL, NULL, NULL, NULL, NULL);
1244   if (rc && gpg_err_code (rc) != GPG_ERR_ASS_UNKNOWN_CMD)
1245     return unlock_pinentry (rc);
1246
1247
1248   if (desc)
1249     build_cmd_setdesc (line, DIM(line), desc);
1250   else
1251     snprintf (line, DIM(line), "RESET");
1252   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1253   if (rc)
1254     return unlock_pinentry (rc);
1255
1256   snprintf (line, DIM(line), "SETPROMPT %s", prompt);
1257   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1258   if (rc)
1259     return unlock_pinentry (rc);
1260
1261   if (with_qualitybar && opt.min_passphrase_len)
1262     {
1263       rc = setup_qualitybar (ctrl);
1264       if (rc)
1265         return unlock_pinentry (rc);
1266     }
1267
1268   if (errtext)
1269     {
1270       snprintf (line, DIM(line), "SETERROR %s", errtext);
1271       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1272       if (rc)
1273         return unlock_pinentry (rc);
1274     }
1275
1276   memset (&parm, 0, sizeof parm);
1277   parm.size = ASSUAN_LINELENGTH/2 - 5;
1278   parm.buffer = gcry_malloc_secure (parm.size+10);
1279   if (!parm.buffer)
1280     return unlock_pinentry (out_of_core ());
1281
1282   saveflag = assuan_get_flag (entry_ctx, ASSUAN_CONFIDENTIAL);
1283   assuan_begin_confidential (entry_ctx);
1284   pinentry_status = 0;
1285   rc = assuan_transact (entry_ctx, "GETPIN", getpin_cb, &parm,
1286                         inq_quality, entry_ctx,
1287                         pinentry_status_cb, &pinentry_status);
1288   assuan_set_flag (entry_ctx, ASSUAN_CONFIDENTIAL, saveflag);
1289   /* Most pinentries out in the wild return the old Assuan error code
1290      for canceled which gets translated to an assuan Cancel error and
1291      not to the code for a user cancel.  Fix this here. */
1292   if (rc && gpg_err_source (rc) && gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
1293     rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_CANCELED);
1294   /* Change error code in case the window close button was clicked
1295      to cancel the operation.  */
1296   if ((pinentry_status & PINENTRY_STATUS_CLOSE_BUTTON)
1297       && gpg_err_code (rc) == GPG_ERR_CANCELED)
1298     rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_FULLY_CANCELED);
1299
1300   if (rc)
1301     xfree (parm.buffer);
1302   else
1303     *retpass = parm.buffer;
1304   return unlock_pinentry (rc);
1305 }
1306
1307
1308 \f
1309 /* Pop up the PIN-entry, display the text and the prompt and ask the
1310    user to confirm this.  We return 0 for success, ie. the user
1311    confirmed it, GPG_ERR_NOT_CONFIRMED for what the text says or an
1312    other error.  If WITH_CANCEL it true an extra cancel button is
1313    displayed to allow the user to easily return a GPG_ERR_CANCELED.
1314    if the Pinentry does not support this, the user can still cancel by
1315    closing the Pinentry window.  */
1316 int
1317 agent_get_confirmation (ctrl_t ctrl,
1318                         const char *desc, const char *ok,
1319                         const char *notok, int with_cancel)
1320 {
1321   int rc;
1322   char line[ASSUAN_LINELENGTH];
1323
1324   if (ctrl->pinentry_mode != PINENTRY_MODE_ASK)
1325     {
1326       if (ctrl->pinentry_mode == PINENTRY_MODE_CANCEL)
1327         return gpg_error (GPG_ERR_CANCELED);
1328
1329       return gpg_error (GPG_ERR_NO_PIN_ENTRY);
1330     }
1331
1332   rc = start_pinentry (ctrl);
1333   if (rc)
1334     return rc;
1335
1336   if (desc)
1337     build_cmd_setdesc (line, DIM(line), desc);
1338   else
1339     snprintf (line, DIM(line), "RESET");
1340   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1341   /* Most pinentries out in the wild return the old Assuan error code
1342      for canceled which gets translated to an assuan Cancel error and
1343      not to the code for a user cancel.  Fix this here. */
1344   if (rc && gpg_err_source (rc) && gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
1345     rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_CANCELED);
1346
1347   if (rc)
1348     return unlock_pinentry (rc);
1349
1350   if (ok)
1351     {
1352       snprintf (line, DIM(line), "SETOK %s", ok);
1353       rc = assuan_transact (entry_ctx,
1354                             line, NULL, NULL, NULL, NULL, NULL, NULL);
1355       if (rc)
1356         return unlock_pinentry (rc);
1357     }
1358   if (notok)
1359     {
1360       /* Try to use the newer NOTOK feature if a cancel button is
1361          requested.  If no cancel button is requested we keep on using
1362          the standard cancel.  */
1363       if (with_cancel)
1364         {
1365           snprintf (line, DIM(line), "SETNOTOK %s", notok);
1366           rc = assuan_transact (entry_ctx,
1367                                 line, NULL, NULL, NULL, NULL, NULL, NULL);
1368         }
1369       else
1370         rc = GPG_ERR_ASS_UNKNOWN_CMD;
1371
1372       if (gpg_err_code (rc) == GPG_ERR_ASS_UNKNOWN_CMD)
1373         {
1374           snprintf (line, DIM(line), "SETCANCEL %s", notok);
1375           rc = assuan_transact (entry_ctx, line,
1376                                 NULL, NULL, NULL, NULL, NULL, NULL);
1377         }
1378       if (rc)
1379         return unlock_pinentry (rc);
1380     }
1381
1382   rc = assuan_transact (entry_ctx, "CONFIRM",
1383                         NULL, NULL, NULL, NULL, NULL, NULL);
1384   if (rc && gpg_err_source (rc) && gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
1385     rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_CANCELED);
1386
1387   return unlock_pinentry (rc);
1388 }
1389
1390
1391 \f
1392 /* Pop up the PINentry, display the text DESC and a button with the
1393    text OK_BTN (which may be NULL to use the default of "OK") and wait
1394    for the user to hit this button.  The return value is not
1395    relevant.  */
1396 int
1397 agent_show_message (ctrl_t ctrl, const char *desc, const char *ok_btn)
1398 {
1399   int rc;
1400   char line[ASSUAN_LINELENGTH];
1401
1402   if (ctrl->pinentry_mode != PINENTRY_MODE_ASK)
1403     return gpg_error (GPG_ERR_CANCELED);
1404
1405   rc = start_pinentry (ctrl);
1406   if (rc)
1407     return rc;
1408
1409   if (desc)
1410     build_cmd_setdesc (line, DIM(line), desc);
1411   else
1412     snprintf (line, DIM(line), "RESET");
1413   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1414   /* Most pinentries out in the wild return the old Assuan error code
1415      for canceled which gets translated to an assuan Cancel error and
1416      not to the code for a user cancel.  Fix this here. */
1417   if (rc && gpg_err_source (rc) && gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
1418     rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_CANCELED);
1419
1420   if (rc)
1421     return unlock_pinentry (rc);
1422
1423   if (ok_btn)
1424     {
1425       snprintf (line, DIM(line), "SETOK %s", ok_btn);
1426       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL,
1427                             NULL, NULL, NULL);
1428       if (rc)
1429         return unlock_pinentry (rc);
1430     }
1431
1432   rc = assuan_transact (entry_ctx, "CONFIRM --one-button", NULL, NULL, NULL,
1433                         NULL, NULL, NULL);
1434   if (rc && gpg_err_source (rc) && gpg_err_code (rc) == GPG_ERR_ASS_CANCELED)
1435     rc = gpg_err_make (gpg_err_source (rc), GPG_ERR_CANCELED);
1436
1437   return unlock_pinentry (rc);
1438 }
1439
1440
1441 /* The thread running the popup message. */
1442 static void *
1443 popup_message_thread (void *arg)
1444 {
1445   (void)arg;
1446
1447   /* We use the --one-button hack instead of the MESSAGE command to
1448      allow the use of old Pinentries.  Those old Pinentries will then
1449      show an additional Cancel button but that is mostly a visual
1450      annoyance. */
1451   assuan_transact (entry_ctx, "CONFIRM --one-button",
1452                    NULL, NULL, NULL, NULL, NULL, NULL);
1453   popup_finished = 1;
1454   return NULL;
1455 }
1456
1457
1458 /* Pop up a message window similar to the confirm one but keep it open
1459    until agent_popup_message_stop has been called.  It is crucial for
1460    the caller to make sure that the stop function gets called as soon
1461    as the message is not anymore required because the message is
1462    system modal and all other attempts to use the pinentry will fail
1463    (after a timeout). */
1464 int
1465 agent_popup_message_start (ctrl_t ctrl, const char *desc, const char *ok_btn)
1466 {
1467   int rc;
1468   char line[ASSUAN_LINELENGTH];
1469   npth_attr_t tattr;
1470   int err;
1471
1472   if (ctrl->pinentry_mode != PINENTRY_MODE_ASK)
1473     return gpg_error (GPG_ERR_CANCELED);
1474
1475   rc = start_pinentry (ctrl);
1476   if (rc)
1477     return rc;
1478
1479   if (desc)
1480     build_cmd_setdesc (line, DIM(line), desc);
1481   else
1482     snprintf (line, DIM(line), "RESET");
1483   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1484   if (rc)
1485     return unlock_pinentry (rc);
1486
1487   if (ok_btn)
1488     {
1489       snprintf (line, DIM(line), "SETOK %s", ok_btn);
1490       rc = assuan_transact (entry_ctx, line, NULL,NULL,NULL,NULL,NULL,NULL);
1491       if (rc)
1492         return unlock_pinentry (rc);
1493     }
1494
1495   err = npth_attr_init (&tattr);
1496   if (err)
1497     return unlock_pinentry (gpg_error_from_errno (err));
1498   npth_attr_setdetachstate (&tattr, NPTH_CREATE_JOINABLE);
1499
1500   popup_finished = 0;
1501   err = npth_create (&popup_tid, &tattr, popup_message_thread, NULL);
1502   npth_attr_destroy (&tattr);
1503   if (err)
1504     {
1505       rc = gpg_error_from_errno (err);
1506       log_error ("error spawning popup message handler: %s\n",
1507                  strerror (err) );
1508       return unlock_pinentry (rc);
1509     }
1510   npth_setname_np (popup_tid, "popup-message");
1511
1512   return 0;
1513 }
1514
1515 /* Close a popup window. */
1516 void
1517 agent_popup_message_stop (ctrl_t ctrl)
1518 {
1519   int rc;
1520   pid_t pid;
1521
1522   (void)ctrl;
1523
1524   if (!popup_tid || !entry_ctx)
1525     {
1526       log_debug ("agent_popup_message_stop called with no active popup\n");
1527       return;
1528     }
1529
1530   pid = assuan_get_pid (entry_ctx);
1531   if (pid == (pid_t)(-1))
1532     ; /* No pid available can't send a kill. */
1533   else if (popup_finished)
1534     ; /* Already finished and ready for joining. */
1535 #ifdef HAVE_W32_SYSTEM
1536   /* Older versions of assuan set PID to 0 on Windows to indicate an
1537      invalid value.  */
1538   else if (pid != (pid_t) INVALID_HANDLE_VALUE
1539            && pid != 0)
1540     {
1541       HANDLE process = (HANDLE) pid;
1542
1543       /* Arbitrary error code.  */
1544       TerminateProcess (process, 1);
1545     }
1546 #else
1547   else if (pid && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
1548     { /* The daemon already died.  No need to send a kill.  However
1549          because we already waited for the process, we need to tell
1550          assuan that it should not wait again (done by
1551          unlock_pinentry). */
1552       if (rc == pid)
1553         assuan_set_flag (entry_ctx, ASSUAN_NO_WAITPID, 1);
1554     }
1555   else if (pid > 0)
1556     kill (pid, SIGINT);
1557 #endif
1558
1559   /* Now wait for the thread to terminate. */
1560   rc = npth_join (popup_tid, NULL);
1561   if (rc)
1562     log_debug ("agent_popup_message_stop: pth_join failed: %s\n",
1563                strerror (rc));
1564   /* Thread IDs are opaque, but we try our best here by resetting it
1565      to the same content that a static global variable has.  */
1566   memset (&popup_tid, '\0', sizeof (popup_tid));
1567
1568   /* Now we can close the connection. */
1569   unlock_pinentry (0);
1570 }
1571
1572 int
1573 agent_clear_passphrase (ctrl_t ctrl,
1574                         const char *keyinfo, cache_mode_t cache_mode)
1575 {
1576   int rc;
1577   char line[ASSUAN_LINELENGTH];
1578
1579   if (! (keyinfo && (cache_mode == CACHE_MODE_NORMAL
1580                      || cache_mode == CACHE_MODE_USER
1581                      || cache_mode == CACHE_MODE_SSH)))
1582     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1583
1584   rc = start_pinentry (ctrl);
1585   if (rc)
1586     return rc;
1587
1588   snprintf (line, DIM(line), "CLEARPASSPHRASE %c/%s",
1589             cache_mode == CACHE_MODE_USER? 'u' :
1590             cache_mode == CACHE_MODE_SSH? 's' : 'n',
1591             keyinfo);
1592   rc = assuan_transact (entry_ctx, line,
1593                         NULL, NULL, NULL, NULL, NULL, NULL);
1594
1595   return unlock_pinentry (rc);
1596 }