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