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