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