Replace use of opt.homedir by accessor functions.
[gnupg.git] / common / homedir.c
1 /* homedir.c - Setup the home directory.
2  * Copyright (C) 2004, 2006, 2007, 2010 Free Software Foundation, Inc.
3  * Copyright (C) 2013, 2016 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * This file is free software; you can redistribute it and/or modify
8  * it under the terms of either
9  *
10  *   - the GNU Lesser General Public License as published by the Free
11  *     Software Foundation; either version 3 of the License, or (at
12  *     your option) any later version.
13  *
14  * or
15  *
16  *   - the GNU General Public License as published by the Free
17  *     Software Foundation; either version 2 of the License, or (at
18  *     your option) any later version.
19  *
20  * or both in parallel, as here.
21  *
22  * This file is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, see <http://www.gnu.org/licenses/>.
29  */
30
31 #include <config.h>
32 #include <stdlib.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36
37 #ifdef HAVE_W32_SYSTEM
38 #include <winsock2.h>   /* Due to the stupid mingw64 requirement to
39                            include this header before windows.h which
40                            is often implicitly included.  */
41 #include <shlobj.h>
42 #ifndef CSIDL_APPDATA
43 #define CSIDL_APPDATA 0x001a
44 #endif
45 #ifndef CSIDL_LOCAL_APPDATA
46 #define CSIDL_LOCAL_APPDATA 0x001c
47 #endif
48 #ifndef CSIDL_COMMON_APPDATA
49 #define CSIDL_COMMON_APPDATA 0x0023
50 #endif
51 #ifndef CSIDL_FLAG_CREATE
52 #define CSIDL_FLAG_CREATE 0x8000
53 #endif
54 #endif /*HAVE_W32_SYSTEM*/
55
56
57
58 #include "util.h"
59 #include "sysutils.h"
60
61
62 /* The GnuPG homedir.  This is only accessed by the functions
63  * gnupg_homedir and gnupg_set_homedir.  Malloced.  */
64 static char *the_gnupg_homedir;
65
66
67 #ifdef HAVE_W32_SYSTEM
68 /* A flag used to indicate that a control file for gpgconf has been
69    detected.  Under Windows the presence of this file indicates a
70    portable installations and triggers several changes:
71
72    - The GNUGHOME directory is fixed relative to installation
73      directory.  All other means to set the home directory are ignore.
74
75    - All registry variables will be ignored.
76
77    This flag is not used on Unix systems.
78  */
79 static int w32_portable_app;
80 #endif /*HAVE_W32_SYSTEM*/
81
82 #ifdef HAVE_W32_SYSTEM
83 /* This flag is true if this process' binary has been installed under
84    bin and not in the root directory as often used before GnuPG 2.1. */
85 static int w32_bin_is_bin;
86 #endif /*HAVE_W32_SYSTEM*/
87
88
89 #ifdef HAVE_W32_SYSTEM
90 static const char *w32_rootdir (void);
91 #endif
92
93
94
95 #ifdef HAVE_W32_SYSTEM
96 static void
97 w32_try_mkdir (const char *dir)
98 {
99 #ifdef HAVE_W32CE_SYSTEM
100   wchar_t *wdir = utf8_to_wchar (dir);
101   if (wdir)
102     {
103       CreateDirectory (wdir, NULL);
104       xfree (wdir);
105     }
106 #else
107   CreateDirectory (dir, NULL);
108 #endif
109 }
110 #endif
111
112
113 /* This is a helper function to load a Windows function from either of
114    one DLLs. */
115 #ifdef HAVE_W32_SYSTEM
116 static HRESULT
117 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
118 {
119   static int initialized;
120   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
121
122   if (!initialized)
123     {
124       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
125       void *handle;
126       int i;
127
128       initialized = 1;
129
130       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
131         {
132           handle = dlopen (dllnames[i], RTLD_LAZY);
133           if (handle)
134             {
135               func = dlsym (handle, "SHGetFolderPathA");
136               if (!func)
137                 {
138                   dlclose (handle);
139                   handle = NULL;
140                 }
141             }
142         }
143     }
144
145   if (func)
146     return func (a,b,c,d,e);
147   else
148     return -1;
149 }
150 #endif /*HAVE_W32_SYSTEM*/
151
152
153 /* Get the standard home directory.  In general this function should
154    not be used as it does not consider a registry value (under W32) or
155    the GNUPGHOME environment variable.  It is better to use
156    default_homedir(). */
157 const char *
158 standard_homedir (void)
159 {
160 #ifdef HAVE_W32_SYSTEM
161   static const char *dir;
162
163   if (!dir)
164     {
165       const char *rdir;
166
167       rdir = w32_rootdir ();
168       if (w32_portable_app)
169         {
170           dir = xstrconcat (rdir, DIRSEP_S "home", NULL);
171         }
172       else
173         {
174           char path[MAX_PATH];
175
176           /* It might be better to use LOCAL_APPDATA because this is
177              defined as "non roaming" and thus more likely to be kept
178              locally.  For private keys this is desired.  However,
179              given that many users copy private keys anyway forth and
180              back, using a system roaming services might be better
181              than to let them do it manually.  A security conscious
182              user will anyway use the registry entry to have better
183              control.  */
184           if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
185                                    NULL, 0, path) >= 0)
186             {
187               char *tmp = xmalloc (strlen (path) + 6 +1);
188               strcpy (stpcpy (tmp, path), "\\gnupg");
189               dir = tmp;
190
191               /* Try to create the directory if it does not yet exists.  */
192               if (access (dir, F_OK))
193                 w32_try_mkdir (dir);
194             }
195           else
196             dir = GNUPG_DEFAULT_HOMEDIR;
197         }
198     }
199   return dir;
200 #else/*!HAVE_W32_SYSTEM*/
201   return GNUPG_DEFAULT_HOMEDIR;
202 #endif /*!HAVE_W32_SYSTEM*/
203 }
204
205 /* Set up the default home directory.  The usual --homedir option
206    should be parsed later. */
207 const char *
208 default_homedir (void)
209 {
210   const char *dir;
211
212 #ifdef HAVE_W32_SYSTEM
213   /* For a portable application we only use the standard homedir.  */
214   w32_rootdir ();
215   if (w32_portable_app)
216     return standard_homedir ();
217 #endif /*HAVE_W32_SYSTEM*/
218
219   dir = getenv ("GNUPGHOME");
220 #ifdef HAVE_W32_SYSTEM
221   if (!dir || !*dir)
222     {
223       static const char *saved_dir;
224
225       if (!saved_dir)
226         {
227           if (!dir || !*dir)
228             {
229               char *tmp;
230
231               tmp = read_w32_registry_string (NULL,
232                                               GNUPG_REGISTRY_DIR,
233                                               "HomeDir");
234               if (tmp && !*tmp)
235                 {
236                   xfree (tmp);
237                   tmp = NULL;
238                 }
239               if (tmp)
240                 saved_dir = tmp;
241             }
242
243           if (!saved_dir)
244             saved_dir = standard_homedir ();
245         }
246       dir = saved_dir;
247     }
248 #endif /*HAVE_W32_SYSTEM*/
249   if (!dir || !*dir)
250     dir = GNUPG_DEFAULT_HOMEDIR;
251
252   return dir;
253 }
254
255
256 #ifdef HAVE_W32_SYSTEM
257 /* Check whether gpgconf is installed and if so read the gpgconf.ctl
258    file. */
259 static void
260 check_portable_app (const char *dir)
261 {
262   char *fname;
263
264   fname = xstrconcat (dir, DIRSEP_S "gpgconf.exe", NULL);
265   if (!access (fname, F_OK))
266     {
267       strcpy (fname + strlen (fname) - 3, "ctl");
268       if (!access (fname, F_OK))
269         {
270           /* gpgconf.ctl file found.  Record this fact.  */
271           w32_portable_app = 1;
272           {
273             unsigned int flags;
274             log_get_prefix (&flags);
275             log_set_prefix (NULL, (flags | GPGRT_LOG_NO_REGISTRY));
276           }
277           /* FIXME: We should read the file to detect special flags
278              and print a warning if we don't understand them  */
279         }
280     }
281   xfree (fname);
282 }
283
284
285 /* Determine the root directory of the gnupg installation on Windows.  */
286 static const char *
287 w32_rootdir (void)
288 {
289   static int got_dir;
290   static char dir[MAX_PATH+5];
291
292   if (!got_dir)
293     {
294       char *p;
295       int rc;
296       wchar_t wdir [MAX_PATH+5];
297
298       rc = GetModuleFileNameW (NULL, wdir, MAX_PATH);
299       if (rc && WideCharToMultiByte (CP_UTF8, 0, wdir, -1, dir, MAX_PATH-4,
300                                      NULL, NULL) < 0)
301         rc = 0;
302       if (!rc)
303         {
304           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (-1));
305           *dir = 0;
306         }
307       got_dir = 1;
308       p = strrchr (dir, DIRSEP_C);
309       if (p)
310         {
311           *p = 0;
312
313           check_portable_app (dir);
314
315           /* If we are installed below "bin" we strip that and use
316              the top directory instead.  */
317           p = strrchr (dir, DIRSEP_C);
318           if (p && !strcmp (p+1, "bin"))
319             {
320               *p = 0;
321               w32_bin_is_bin = 1;
322             }
323         }
324       if (!p)
325         {
326           log_debug ("bad filename '%s' returned for this process\n", dir);
327           *dir = 0;
328         }
329     }
330
331   if (*dir)
332     return dir;
333   /* Fallback to the hardwired value. */
334   return GNUPG_LIBEXECDIR;
335 }
336
337 static const char *
338 w32_commondir (void)
339 {
340   static char *dir;
341
342   if (!dir)
343     {
344       const char *rdir;
345       char path[MAX_PATH];
346
347       /* Make sure that w32_rootdir has been called so that we are
348          able to check the portable application flag.  The common dir
349          is the identical to the rootdir.  In that case there is also
350          no need to strdup its value.  */
351       rdir = w32_rootdir ();
352       if (w32_portable_app)
353         return rdir;
354
355       if (w32_shgetfolderpath (NULL, CSIDL_COMMON_APPDATA,
356                                NULL, 0, path) >= 0)
357         {
358           char *tmp = xmalloc (strlen (path) + 4 +1);
359           strcpy (stpcpy (tmp, path), "\\GNU");
360           dir = tmp;
361           /* No auto create of the directory.  Either the installer or
362              the admin has to create these directories.  */
363         }
364       else
365         {
366           /* Ooops: Not defined - probably an old Windows version.
367              Use the installation directory instead.  */
368           dir = xstrdup (rdir);
369         }
370     }
371
372   return dir;
373 }
374 #endif /*HAVE_W32_SYSTEM*/
375
376
377 /* Change the homedir.  Some care must be taken to set this early
378  * enough becuase previous calls to gnupg_homedir may else return a
379  * different string.  */
380 void
381 gnupg_set_homedir (const char *newdir)
382 {
383   if (!newdir || !*newdir)
384     newdir = default_homedir ();
385   xfree (the_gnupg_homedir);
386   the_gnupg_homedir = xstrdup (newdir);
387 }
388
389
390 /* Return the homedir.  The returned string is valid until another
391  * gnupg-set-homedir call.  Note that this may be a relative string.
392  * This function replaced the former global opt.homedir.  */
393 const char *
394 gnupg_homedir (void)
395 {
396   /* If a homedir has not been set, set it to the default.  */
397   if (!the_gnupg_homedir)
398     the_gnupg_homedir = xstrdup (default_homedir ());
399   return the_gnupg_homedir;
400 }
401
402
403 /* Return the name of the sysconfdir.  This is a static string.  This
404    function is required because under Windows we can't simply compile
405    it in.  */
406 const char *
407 gnupg_sysconfdir (void)
408 {
409 #ifdef HAVE_W32_SYSTEM
410   static char *name;
411
412   if (!name)
413     {
414       const char *s1, *s2;
415       s1 = w32_commondir ();
416       s2 = DIRSEP_S "etc" DIRSEP_S "gnupg";
417       name = xmalloc (strlen (s1) + strlen (s2) + 1);
418       strcpy (stpcpy (name, s1), s2);
419     }
420   return name;
421 #else /*!HAVE_W32_SYSTEM*/
422   return GNUPG_SYSCONFDIR;
423 #endif /*!HAVE_W32_SYSTEM*/
424 }
425
426
427 const char *
428 gnupg_bindir (void)
429 {
430 #if defined (HAVE_W32CE_SYSTEM)
431   static char *name;
432
433   if (!name)
434     name = xstrconcat (w32_rootdir (), DIRSEP_S "bin", NULL);
435   return name;
436 #elif defined(HAVE_W32_SYSTEM)
437   const char *rdir;
438
439   rdir = w32_rootdir ();
440   if (w32_bin_is_bin)
441     {
442       static char *name;
443
444       if (!name)
445         name = xstrconcat (rdir, DIRSEP_S "bin", NULL);
446       return name;
447     }
448   else
449     return rdir;
450 #else /*!HAVE_W32_SYSTEM*/
451   return GNUPG_BINDIR;
452 #endif /*!HAVE_W32_SYSTEM*/
453 }
454
455
456 /* Return the name of the libexec directory.  The name is allocated in
457    a static area on the first use.  This function won't fail. */
458 const char *
459 gnupg_libexecdir (void)
460 {
461 #ifdef HAVE_W32_SYSTEM
462   return gnupg_bindir ();
463 #else /*!HAVE_W32_SYSTEM*/
464   return GNUPG_LIBEXECDIR;
465 #endif /*!HAVE_W32_SYSTEM*/
466 }
467
468 const char *
469 gnupg_libdir (void)
470 {
471 #ifdef HAVE_W32_SYSTEM
472   static char *name;
473
474   if (!name)
475     name = xstrconcat (w32_rootdir (), DIRSEP_S "lib" DIRSEP_S "gnupg", NULL);
476   return name;
477 #else /*!HAVE_W32_SYSTEM*/
478   return GNUPG_LIBDIR;
479 #endif /*!HAVE_W32_SYSTEM*/
480 }
481
482 const char *
483 gnupg_datadir (void)
484 {
485 #ifdef HAVE_W32_SYSTEM
486   static char *name;
487
488   if (!name)
489     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "gnupg", NULL);
490   return name;
491 #else /*!HAVE_W32_SYSTEM*/
492   return GNUPG_DATADIR;
493 #endif /*!HAVE_W32_SYSTEM*/
494 }
495
496
497 const char *
498 gnupg_localedir (void)
499 {
500 #ifdef HAVE_W32_SYSTEM
501   static char *name;
502
503   if (!name)
504     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "locale",
505                        NULL);
506   return name;
507 #else /*!HAVE_W32_SYSTEM*/
508   return LOCALEDIR;
509 #endif /*!HAVE_W32_SYSTEM*/
510 }
511
512
513 /* Return the name of the cache directory.  The name is allocated in a
514    static area on the first use.  Windows only: If the directory does
515    not exist it is created.  */
516 const char *
517 gnupg_cachedir (void)
518 {
519 #ifdef HAVE_W32_SYSTEM
520   static const char *dir;
521
522   if (!dir)
523     {
524       const char *rdir;
525
526       rdir = w32_rootdir ();
527       if (w32_portable_app)
528         {
529           dir = xstrconcat (rdir,
530                             DIRSEP_S, "var",
531                             DIRSEP_S, "cache",
532                             DIRSEP_S, "gnupg", NULL);
533         }
534       else
535         {
536           char path[MAX_PATH];
537           const char *s1[] = { "GNU", "cache", "gnupg", NULL };
538           int s1_len;
539           const char **comp;
540
541           s1_len = 0;
542           for (comp = s1; *comp; comp++)
543             s1_len += 1 + strlen (*comp);
544
545           if (w32_shgetfolderpath (NULL, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE,
546                                    NULL, 0, path) >= 0)
547             {
548               char *tmp = xmalloc (strlen (path) + s1_len + 1);
549               char *p;
550
551               p = stpcpy (tmp, path);
552               for (comp = s1; *comp; comp++)
553                 {
554                   p = stpcpy (p, "\\");
555                   p = stpcpy (p, *comp);
556
557                   if (access (tmp, F_OK))
558                     w32_try_mkdir (tmp);
559                 }
560
561               dir = tmp;
562             }
563           else
564             {
565               dir = "c:\\temp\\cache\\gnupg";
566 #ifdef HAVE_W32CE_SYSTEM
567               dir += 2;
568               w32_try_mkdir ("\\temp\\cache");
569               w32_try_mkdir ("\\temp\\cache\\gnupg");
570 #endif
571             }
572         }
573     }
574   return dir;
575 #else /*!HAVE_W32_SYSTEM*/
576   return GNUPG_LOCALSTATEDIR "/cache/" PACKAGE_NAME;
577 #endif /*!HAVE_W32_SYSTEM*/
578 }
579
580
581 /* Return the system socket name used by DirMngr.  */
582 const char *
583 dirmngr_sys_socket_name (void)
584 {
585 #ifdef HAVE_W32_SYSTEM
586   static char *name;
587
588   if (!name)
589     {
590       char *p;
591 # ifdef HAVE_W32CE_SYSTEM
592       const char *s1, *s2;
593
594       s1 = default_homedir ();
595 # else
596       char s1buf[MAX_PATH];
597       const char *s1, *s2;
598
599       s1 = default_homedir ();
600       if (!w32_portable_app)
601         {
602           /* We need something akin CSIDL_COMMON_PROGRAMS, but local
603              (non-roaming).  This is because the file needs to be on
604              the local machine and makes only sense on that machine.
605              CSIDL_WINDOWS seems to be the only location which
606              guarantees that. */
607           if (w32_shgetfolderpath (NULL, CSIDL_WINDOWS, NULL, 0, s1buf) < 0)
608             strcpy (s1buf, "C:\\WINDOWS");
609           s1 = s1buf;
610         }
611 # endif
612       s2 = DIRSEP_S DIRMNGR_SOCK_NAME;
613       name = xmalloc (strlen (s1) + strlen (s2) + 1);
614       strcpy (stpcpy (name, s1), s2);
615       for (p=name; *p; p++)
616         if (*p == '/')
617           *p = '\\';
618     }
619   return name;
620 #else /*!HAVE_W32_SYSTEM*/
621   return GNUPG_LOCALSTATEDIR "/run/" PACKAGE_NAME "/"DIRMNGR_SOCK_NAME;
622 #endif /*!HAVE_W32_SYSTEM*/
623 }
624
625
626 /* Return the user socket name used by DirMngr.  If a user specific
627    dirmngr installation is not supported, NULL is returned.  */
628 const char *
629 dirmngr_user_socket_name (void)
630 {
631   static char *name;
632
633   if (!name)
634     name = make_absfilename (default_homedir (), DIRMNGR_SOCK_NAME, NULL);
635   return name;
636 }
637
638
639 /* Return the default pinentry name.  If RESET is true the internal
640    cache is first flushed.  */
641 static const char *
642 get_default_pinentry_name (int reset)
643 {
644   static struct {
645     const char *(*rfnc)(void);
646     const char *name;
647   } names[] = {
648     /* The first entry is what we return in case we found no
649        other pinentry.  */
650     { gnupg_bindir, DIRSEP_S "pinentry" EXEEXT_S },
651 #ifdef HAVE_W32_SYSTEM
652     /* Try Gpg4win directory (with bin and without.) */
653     { w32_rootdir, "\\..\\Gpg4win\\bin\\pinentry.exe" },
654     { w32_rootdir, "\\..\\Gpg4win\\pinentry.exe" },
655     /* Try old Gpgwin directory.  */
656     { w32_rootdir, "\\..\\GNU\\GnuPG\\pinentry.exe" },
657     /* Try a Pinentry from the common GNU dir.  */
658     { w32_rootdir, "\\..\\GNU\\bin\\pinentry.exe" },
659 #endif
660     /* Last chance is a pinentry-basic (which comes with the
661        GnuPG 2.1 Windows installer).  */
662     { gnupg_bindir, DIRSEP_S "pinentry-basic" EXEEXT_S }
663   };
664   static char *name;
665
666   if (reset)
667     {
668       xfree (name);
669       name = NULL;
670     }
671
672   if (!name)
673     {
674       int i;
675
676       for (i=0; i < DIM(names); i++)
677         {
678           char *name2;
679
680           name2 = xstrconcat (names[i].rfnc (), names[i].name, NULL);
681           if (!access (name2, F_OK))
682             {
683               /* Use that pinentry.  */
684               xfree (name);
685               name = name2;
686               break;
687             }
688           if (!i) /* Store the first as fallback return.  */
689             name = name2;
690           else
691             xfree (name2);
692         }
693     }
694
695   return name;
696 }
697
698
699 /* Return the file name of a helper tool.  WHICH is one of the
700    GNUPG_MODULE_NAME_foo constants.  */
701 const char *
702 gnupg_module_name (int which)
703 {
704 #define X(a,b) do {                                                     \
705     static char *name;                                                  \
706     if (!name)                                                          \
707       name = xstrconcat (gnupg_ ## a (), DIRSEP_S b EXEEXT_S, NULL);    \
708     return name;                                                        \
709   } while (0)
710
711   switch (which)
712     {
713     case GNUPG_MODULE_NAME_AGENT:
714 #ifdef GNUPG_DEFAULT_AGENT
715       return GNUPG_DEFAULT_AGENT;
716 #else
717       X(bindir, "gpg-agent");
718 #endif
719
720     case GNUPG_MODULE_NAME_PINENTRY:
721 #ifdef GNUPG_DEFAULT_PINENTRY
722       return GNUPG_DEFAULT_PINENTRY;  /* (Set by a configure option) */
723 #else
724       return get_default_pinentry_name (0);
725 #endif
726
727     case GNUPG_MODULE_NAME_SCDAEMON:
728 #ifdef GNUPG_DEFAULT_SCDAEMON
729       return GNUPG_DEFAULT_SCDAEMON;
730 #else
731       X(libexecdir, "scdaemon");
732 #endif
733
734     case GNUPG_MODULE_NAME_DIRMNGR:
735 #ifdef GNUPG_DEFAULT_DIRMNGR
736       return GNUPG_DEFAULT_DIRMNGR;
737 #else
738       X(bindir, DIRMNGR_NAME);
739 #endif
740
741     case GNUPG_MODULE_NAME_PROTECT_TOOL:
742 #ifdef GNUPG_DEFAULT_PROTECT_TOOL
743       return GNUPG_DEFAULT_PROTECT_TOOL;
744 #else
745       X(libexecdir, "gpg-protect-tool");
746 #endif
747
748     case GNUPG_MODULE_NAME_DIRMNGR_LDAP:
749 #ifdef GNUPG_DEFAULT_DIRMNGR_LDAP
750       return GNUPG_DEFAULT_DIRMNGR_LDAP;
751 #else
752       X(libexecdir, "dirmngr_ldap");
753 #endif
754
755     case GNUPG_MODULE_NAME_CHECK_PATTERN:
756       X(libexecdir, "gpg-check-pattern");
757
758     case GNUPG_MODULE_NAME_GPGSM:
759       X(bindir, "gpgsm");
760
761     case GNUPG_MODULE_NAME_GPG:
762 #if USE_GPG2_HACK
763       X(bindir, GPG_NAME "2");
764 #else
765       X(bindir, GPG_NAME);
766 #endif
767
768     case GNUPG_MODULE_NAME_CONNECT_AGENT:
769       X(bindir, "gpg-connect-agent");
770
771     case GNUPG_MODULE_NAME_GPGCONF:
772       X(bindir, "gpgconf");
773
774     default:
775       BUG ();
776     }
777 #undef X
778 }
779
780
781 /* Flush some of the cached module names.  This is for example used by
782    gpg-agent to allow configuring a different pinentry.  */
783 void
784 gnupg_module_name_flush_some (void)
785 {
786   (void)get_default_pinentry_name (1);
787 }