common: Implicitly do a gpgconf --create-socketdir.
[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 <https://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 #ifdef HAVE_STAT
57 #include <sys/stat.h> /* for stat() */
58 #endif
59
60
61
62 #include "util.h"
63 #include "sysutils.h"
64 #include "zb32.h"
65
66 /* The GnuPG homedir.  This is only accessed by the functions
67  * gnupg_homedir and gnupg_set_homedir.  Malloced.  */
68 static char *the_gnupg_homedir;
69
70 /* Flag indicating that home directory is not the default one.  */
71 static byte non_default_homedir;
72
73
74 #ifdef HAVE_W32_SYSTEM
75 /* A flag used to indicate that a control file for gpgconf has been
76    detected.  Under Windows the presence of this file indicates a
77    portable installations and triggers several changes:
78
79    - The GNUGHOME directory is fixed relative to installation
80      directory.  All other means to set the home directory are ignore.
81
82    - All registry variables will be ignored.
83
84    This flag is not used on Unix systems.
85  */
86 static byte w32_portable_app;
87 #endif /*HAVE_W32_SYSTEM*/
88
89 #ifdef HAVE_W32_SYSTEM
90 /* This flag is true if this process' binary has been installed under
91    bin and not in the root directory as often used before GnuPG 2.1. */
92 static byte w32_bin_is_bin;
93 #endif /*HAVE_W32_SYSTEM*/
94
95
96 #ifdef HAVE_W32_SYSTEM
97 static const char *w32_rootdir (void);
98 #endif
99
100
101
102 #ifdef HAVE_W32_SYSTEM
103 static void
104 w32_try_mkdir (const char *dir)
105 {
106 #ifdef HAVE_W32CE_SYSTEM
107   wchar_t *wdir = utf8_to_wchar (dir);
108   if (wdir)
109     {
110       CreateDirectory (wdir, NULL);
111       xfree (wdir);
112     }
113 #else
114   CreateDirectory (dir, NULL);
115 #endif
116 }
117 #endif
118
119
120 /* This is a helper function to load a Windows function from either of
121    one DLLs. */
122 #ifdef HAVE_W32_SYSTEM
123 static HRESULT
124 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
125 {
126   static int initialized;
127   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
128
129   if (!initialized)
130     {
131       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
132       void *handle;
133       int i;
134
135       initialized = 1;
136
137       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
138         {
139           handle = dlopen (dllnames[i], RTLD_LAZY);
140           if (handle)
141             {
142               func = dlsym (handle, "SHGetFolderPathA");
143               if (!func)
144                 {
145                   dlclose (handle);
146                   handle = NULL;
147                 }
148             }
149         }
150     }
151
152   if (func)
153     return func (a,b,c,d,e);
154   else
155     return -1;
156 }
157 #endif /*HAVE_W32_SYSTEM*/
158
159
160 /* Check whether DIR is the default homedir.  */
161 static int
162 is_gnupg_default_homedir (const char *dir)
163 {
164   int result;
165   char *a = make_absfilename (dir, NULL);
166   char *b = make_absfilename (GNUPG_DEFAULT_HOMEDIR, NULL);
167   result = !compare_filenames (a, b);
168   xfree (b);
169   xfree (a);
170   return result;
171 }
172
173
174 /* Get the standard home directory.  In general this function should
175    not be used as it does not consider a registry value (under W32) or
176    the GNUPGHOME environment variable.  It is better to use
177    default_homedir(). */
178 const char *
179 standard_homedir (void)
180 {
181 #ifdef HAVE_W32_SYSTEM
182   static const char *dir;
183
184   if (!dir)
185     {
186       const char *rdir;
187
188       rdir = w32_rootdir ();
189       if (w32_portable_app)
190         {
191           dir = xstrconcat (rdir, DIRSEP_S "home", NULL);
192         }
193       else
194         {
195           char path[MAX_PATH];
196
197           /* It might be better to use LOCAL_APPDATA because this is
198              defined as "non roaming" and thus more likely to be kept
199              locally.  For private keys this is desired.  However,
200              given that many users copy private keys anyway forth and
201              back, using a system roaming services might be better
202              than to let them do it manually.  A security conscious
203              user will anyway use the registry entry to have better
204              control.  */
205           if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
206                                    NULL, 0, path) >= 0)
207             {
208               char *tmp = xmalloc (strlen (path) + 6 +1);
209               strcpy (stpcpy (tmp, path), "\\gnupg");
210               dir = tmp;
211
212               /* Try to create the directory if it does not yet exists.  */
213               if (access (dir, F_OK))
214                 w32_try_mkdir (dir);
215             }
216           else
217             dir = GNUPG_DEFAULT_HOMEDIR;
218         }
219     }
220   return dir;
221 #else/*!HAVE_W32_SYSTEM*/
222   return GNUPG_DEFAULT_HOMEDIR;
223 #endif /*!HAVE_W32_SYSTEM*/
224 }
225
226 /* Set up the default home directory.  The usual --homedir option
227    should be parsed later. */
228 const char *
229 default_homedir (void)
230 {
231   const char *dir;
232
233 #ifdef HAVE_W32_SYSTEM
234   /* For a portable application we only use the standard homedir.  */
235   w32_rootdir ();
236   if (w32_portable_app)
237     return standard_homedir ();
238 #endif /*HAVE_W32_SYSTEM*/
239
240   dir = getenv ("GNUPGHOME");
241 #ifdef HAVE_W32_SYSTEM
242   if (!dir || !*dir)
243     {
244       static const char *saved_dir;
245
246       if (!saved_dir)
247         {
248           if (!dir || !*dir)
249             {
250               char *tmp;
251
252               tmp = read_w32_registry_string (NULL,
253                                               GNUPG_REGISTRY_DIR,
254                                               "HomeDir");
255               if (tmp && !*tmp)
256                 {
257                   xfree (tmp);
258                   tmp = NULL;
259                 }
260               if (tmp)
261                 saved_dir = tmp;
262             }
263
264           if (!saved_dir)
265             saved_dir = standard_homedir ();
266         }
267       dir = saved_dir;
268     }
269 #endif /*HAVE_W32_SYSTEM*/
270   if (!dir || !*dir)
271     dir = GNUPG_DEFAULT_HOMEDIR;
272   else if (!is_gnupg_default_homedir (dir))
273     non_default_homedir = 1;
274
275   return dir;
276 }
277
278
279 #ifdef HAVE_W32_SYSTEM
280 /* Check whether gpgconf is installed and if so read the gpgconf.ctl
281    file. */
282 static void
283 check_portable_app (const char *dir)
284 {
285   char *fname;
286
287   fname = xstrconcat (dir, DIRSEP_S "gpgconf.exe", NULL);
288   if (!access (fname, F_OK))
289     {
290       strcpy (fname + strlen (fname) - 3, "ctl");
291       if (!access (fname, F_OK))
292         {
293           /* gpgconf.ctl file found.  Record this fact.  */
294           w32_portable_app = 1;
295           {
296             unsigned int flags;
297             log_get_prefix (&flags);
298             log_set_prefix (NULL, (flags | GPGRT_LOG_NO_REGISTRY));
299           }
300           /* FIXME: We should read the file to detect special flags
301              and print a warning if we don't understand them  */
302         }
303     }
304   xfree (fname);
305 }
306
307
308 /* Determine the root directory of the gnupg installation on Windows.  */
309 static const char *
310 w32_rootdir (void)
311 {
312   static int got_dir;
313   static char dir[MAX_PATH+5];
314
315   if (!got_dir)
316     {
317       char *p;
318       int rc;
319       wchar_t wdir [MAX_PATH+5];
320
321       rc = GetModuleFileNameW (NULL, wdir, MAX_PATH);
322       if (rc && WideCharToMultiByte (CP_UTF8, 0, wdir, -1, dir, MAX_PATH-4,
323                                      NULL, NULL) < 0)
324         rc = 0;
325       if (!rc)
326         {
327           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (-1));
328           *dir = 0;
329         }
330       got_dir = 1;
331       p = strrchr (dir, DIRSEP_C);
332       if (p)
333         {
334           *p = 0;
335
336           check_portable_app (dir);
337
338           /* If we are installed below "bin" we strip that and use
339              the top directory instead.  */
340           p = strrchr (dir, DIRSEP_C);
341           if (p && !strcmp (p+1, "bin"))
342             {
343               *p = 0;
344               w32_bin_is_bin = 1;
345             }
346         }
347       if (!p)
348         {
349           log_debug ("bad filename '%s' returned for this process\n", dir);
350           *dir = 0;
351         }
352     }
353
354   if (*dir)
355     return dir;
356   /* Fallback to the hardwired value. */
357   return GNUPG_LIBEXECDIR;
358 }
359
360 static const char *
361 w32_commondir (void)
362 {
363   static char *dir;
364
365   if (!dir)
366     {
367       const char *rdir;
368       char path[MAX_PATH];
369
370       /* Make sure that w32_rootdir has been called so that we are
371          able to check the portable application flag.  The common dir
372          is the identical to the rootdir.  In that case there is also
373          no need to strdup its value.  */
374       rdir = w32_rootdir ();
375       if (w32_portable_app)
376         return rdir;
377
378       if (w32_shgetfolderpath (NULL, CSIDL_COMMON_APPDATA,
379                                NULL, 0, path) >= 0)
380         {
381           char *tmp = xmalloc (strlen (path) + 4 +1);
382           strcpy (stpcpy (tmp, path), "\\GNU");
383           dir = tmp;
384           /* No auto create of the directory.  Either the installer or
385              the admin has to create these directories.  */
386         }
387       else
388         {
389           /* Ooops: Not defined - probably an old Windows version.
390              Use the installation directory instead.  */
391           dir = xstrdup (rdir);
392         }
393     }
394
395   return dir;
396 }
397 #endif /*HAVE_W32_SYSTEM*/
398
399
400 /* Change the homedir.  Some care must be taken to set this early
401  * enough because previous calls to gnupg_homedir may else return a
402  * different string.  */
403 void
404 gnupg_set_homedir (const char *newdir)
405 {
406   if (!newdir || !*newdir)
407     newdir = default_homedir ();
408   else if (!is_gnupg_default_homedir (newdir))
409     non_default_homedir = 1;
410   xfree (the_gnupg_homedir);
411   the_gnupg_homedir = make_absfilename (newdir, NULL);;
412 }
413
414
415 /* Return the homedir.  The returned string is valid until another
416  * gnupg-set-homedir call.  This is always an absolute directory name.
417  * The function replaces the former global var opt.homedir.  */
418 const char *
419 gnupg_homedir (void)
420 {
421   /* If a homedir has not been set, set it to the default.  */
422   if (!the_gnupg_homedir)
423     the_gnupg_homedir = make_absfilename (default_homedir (), NULL);
424   return the_gnupg_homedir;
425 }
426
427
428 /* Return whether the home dir is the default one.  */
429 int
430 gnupg_default_homedir_p (void)
431 {
432   return !non_default_homedir;
433 }
434
435
436 /* Helper for gnupg-socketdir.  This is a global function, so that
437  * gpgconf can use it for its --create-socketdir command.  If
438  * SKIP_CHECKS is set permission checks etc. are not done.  The
439  * function always returns a malloced directory name and stores these
440  * bit flags at R_INFO:
441  *
442  *   1 := Internal error, stat failed, out of core, etc.
443  *   2 := No /run/user directory.
444  *   4 := Directory not owned by the user, not a directory
445  *        or wrong permissions.
446  *   8 := Same as 4 but for the subdir.
447  *  16 := mkdir failed
448  *  32 := Non default homedir; checking subdir.
449  *  64 := Subdir does not exist.
450  * 128 := Using homedir as fallback.
451  */
452 char *
453 _gnupg_socketdir_internal (int skip_checks, unsigned *r_info)
454 {
455 #if defined(HAVE_W32_SYSTEM) || !defined(HAVE_STAT)
456
457   char *name;
458
459   (void)skip_checks;
460   *r_info = 0;
461   name = xstrdup (gnupg_homedir ());
462
463 #else /* Unix and stat(2) available. */
464
465   static const char * const bases[] = { "/run", "/var/run", NULL};
466   int i;
467   struct stat sb;
468   char prefix[13 + 1 + 20 + 6 + 1];
469   const char *s;
470   char *name = NULL;
471
472   *r_info = 0;
473
474   /* First make sure that non_default_homedir can be set.  */
475   gnupg_homedir ();
476
477   /* It has been suggested to first check XDG_RUNTIME_DIR envvar.
478    * However, the specs state that the lifetime of the directory MUST
479    * be bound to the user being logged in.  Now GnuPG may also be run
480    * as a background process with no (desktop) user logged in.  Thus
481    * we better don't do that.  */
482
483   /* Check whether we have a /run/user dir.  */
484   for (i=0; bases[i]; i++)
485     {
486       snprintf (prefix, sizeof prefix, "%s/user/%u",
487                 bases[i], (unsigned int)getuid ());
488       if (!stat (prefix, &sb) && S_ISDIR(sb.st_mode))
489         break;
490     }
491   if (!bases[i])
492     {
493       *r_info |= 2; /* No /run/user directory.  */
494       goto leave;
495     }
496
497   if (sb.st_uid != getuid ())
498     {
499       *r_info |= 4; /* Not owned by the user.  */
500       if (!skip_checks)
501         goto leave;
502     }
503
504   if (strlen (prefix) + 7 >= sizeof prefix)
505     {
506       *r_info |= 1; /* Ooops: Buffer too short to append "/gnupg".  */
507       goto leave;
508     }
509   strcat (prefix, "/gnupg");
510
511   /* Check whether the gnupg sub directory has proper permissions.  */
512   if (stat (prefix, &sb))
513     {
514       if (errno != ENOENT)
515         {
516           *r_info |= 1; /* stat failed.  */
517           goto leave;
518         }
519
520       /* Try to create the directory and check again.  */
521       if (gnupg_mkdir (prefix, "-rwx"))
522         {
523           *r_info |= 16; /* mkdir failed.  */
524           goto leave;
525         }
526       if (stat (prefix, &sb))
527         {
528           *r_info |= 1; /* stat failed.  */
529           goto leave;
530         }
531     }
532   /* Check that it is a directory, owned by the user, and only the
533    * user has permissions to use it.  */
534   if (!S_ISDIR(sb.st_mode)
535       || sb.st_uid != getuid ()
536       || (sb.st_mode & (S_IRWXG|S_IRWXO)))
537     {
538       *r_info |= 4; /* Bad permissions or not a directory. */
539       if (!skip_checks)
540         goto leave;
541     }
542
543   /* If a non default homedir is used, we check whether an
544    * corresponding sub directory below the socket dir is available
545    * and use that.  We hash the non default homedir to keep the new
546    * subdir short enough.  */
547   if (non_default_homedir)
548     {
549       char sha1buf[20];
550       char *suffix;
551
552       *r_info |= 32; /* Testing subdir.  */
553       s = gnupg_homedir ();
554       gcry_md_hash_buffer (GCRY_MD_SHA1, sha1buf, s, strlen (s));
555       suffix = zb32_encode (sha1buf, 8*15);
556       if (!suffix)
557         {
558           *r_info |= 1; /* Out of core etc. */
559           goto leave;
560         }
561       name = strconcat (prefix, "/d.", suffix, NULL);
562       xfree (suffix);
563       if (!name)
564         {
565           *r_info |= 1; /* Out of core etc. */
566           goto leave;
567         }
568
569       /* Stat that directory and check constraints.
570        * The command
571        *    gpgconf --remove-socketdir
572        * can be used to remove that directory.  */
573       if (stat (name, &sb))
574         {
575           if (errno != ENOENT)
576             *r_info |= 1; /* stat failed. */
577           else if (!skip_checks)
578             {
579               /* Try to create the directory and check again.  */
580               if (gnupg_mkdir (name, "-rwx"))
581                 *r_info |= 16; /* mkdir failed.  */
582               else if (stat (prefix, &sb))
583                 {
584                   if (errno != ENOENT)
585                     *r_info |= 1; /* stat failed. */
586                   else
587                     *r_info |= 64; /* Subdir does not exist.  */
588                 }
589             }
590           else
591             *r_info |= 64; /* Subdir does not exist.  */
592           if (!skip_checks)
593             {
594               xfree (name);
595               name = NULL;
596               goto leave;
597             }
598         }
599       else if (!S_ISDIR(sb.st_mode)
600                || sb.st_uid != getuid ()
601                || (sb.st_mode & (S_IRWXG|S_IRWXO)))
602         {
603           *r_info |= 8; /* Bad permissions or subdir is not a directory.  */
604           if (!skip_checks)
605             {
606               xfree (name);
607               name = NULL;
608               goto leave;
609             }
610         }
611     }
612   else
613     name = xstrdup (prefix);
614
615  leave:
616   /* If nothing works fall back to the homedir.  */
617   if (!name)
618     {
619       *r_info |= 128; /* Fallback.  */
620       name = xstrdup (gnupg_homedir ());
621     }
622
623 #endif /* Unix */
624
625   return name;
626 }
627
628
629 /*
630  * Return the name of the socket dir.  That is the directory used for
631  * the IPC local sockets.  This is an absolute directory name.
632  */
633 const char *
634 gnupg_socketdir (void)
635 {
636   static char *name;
637
638   if (!name)
639     {
640       unsigned int dummy;
641       name = _gnupg_socketdir_internal (0, &dummy);
642     }
643
644   return name;
645 }
646
647
648 /* Return the name of the sysconfdir.  This is a static string.  This
649    function is required because under Windows we can't simply compile
650    it in.  */
651 const char *
652 gnupg_sysconfdir (void)
653 {
654 #ifdef HAVE_W32_SYSTEM
655   static char *name;
656
657   if (!name)
658     {
659       const char *s1, *s2;
660       s1 = w32_commondir ();
661       s2 = DIRSEP_S "etc" DIRSEP_S "gnupg";
662       name = xmalloc (strlen (s1) + strlen (s2) + 1);
663       strcpy (stpcpy (name, s1), s2);
664     }
665   return name;
666 #else /*!HAVE_W32_SYSTEM*/
667   return GNUPG_SYSCONFDIR;
668 #endif /*!HAVE_W32_SYSTEM*/
669 }
670
671
672 const char *
673 gnupg_bindir (void)
674 {
675 #if defined (HAVE_W32CE_SYSTEM)
676   static char *name;
677
678   if (!name)
679     name = xstrconcat (w32_rootdir (), DIRSEP_S "bin", NULL);
680   return name;
681 #elif defined(HAVE_W32_SYSTEM)
682   const char *rdir;
683
684   rdir = w32_rootdir ();
685   if (w32_bin_is_bin)
686     {
687       static char *name;
688
689       if (!name)
690         name = xstrconcat (rdir, DIRSEP_S "bin", NULL);
691       return name;
692     }
693   else
694     return rdir;
695 #else /*!HAVE_W32_SYSTEM*/
696   return GNUPG_BINDIR;
697 #endif /*!HAVE_W32_SYSTEM*/
698 }
699
700
701 /* Return the name of the libexec directory.  The name is allocated in
702    a static area on the first use.  This function won't fail. */
703 const char *
704 gnupg_libexecdir (void)
705 {
706 #ifdef HAVE_W32_SYSTEM
707   return gnupg_bindir ();
708 #else /*!HAVE_W32_SYSTEM*/
709   return GNUPG_LIBEXECDIR;
710 #endif /*!HAVE_W32_SYSTEM*/
711 }
712
713 const char *
714 gnupg_libdir (void)
715 {
716 #ifdef HAVE_W32_SYSTEM
717   static char *name;
718
719   if (!name)
720     name = xstrconcat (w32_rootdir (), DIRSEP_S "lib" DIRSEP_S "gnupg", NULL);
721   return name;
722 #else /*!HAVE_W32_SYSTEM*/
723   return GNUPG_LIBDIR;
724 #endif /*!HAVE_W32_SYSTEM*/
725 }
726
727 const char *
728 gnupg_datadir (void)
729 {
730 #ifdef HAVE_W32_SYSTEM
731   static char *name;
732
733   if (!name)
734     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "gnupg", NULL);
735   return name;
736 #else /*!HAVE_W32_SYSTEM*/
737   return GNUPG_DATADIR;
738 #endif /*!HAVE_W32_SYSTEM*/
739 }
740
741
742 const char *
743 gnupg_localedir (void)
744 {
745 #ifdef HAVE_W32_SYSTEM
746   static char *name;
747
748   if (!name)
749     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "locale",
750                        NULL);
751   return name;
752 #else /*!HAVE_W32_SYSTEM*/
753   return LOCALEDIR;
754 #endif /*!HAVE_W32_SYSTEM*/
755 }
756
757
758 /* Return the name of the cache directory.  The name is allocated in a
759    static area on the first use.  Windows only: If the directory does
760    not exist it is created.  */
761 const char *
762 gnupg_cachedir (void)
763 {
764 #ifdef HAVE_W32_SYSTEM
765   static const char *dir;
766
767   if (!dir)
768     {
769       const char *rdir;
770
771       rdir = w32_rootdir ();
772       if (w32_portable_app)
773         {
774           dir = xstrconcat (rdir,
775                             DIRSEP_S, "var",
776                             DIRSEP_S, "cache",
777                             DIRSEP_S, "gnupg", NULL);
778         }
779       else
780         {
781           char path[MAX_PATH];
782           const char *s1[] = { "GNU", "cache", "gnupg", NULL };
783           int s1_len;
784           const char **comp;
785
786           s1_len = 0;
787           for (comp = s1; *comp; comp++)
788             s1_len += 1 + strlen (*comp);
789
790           if (w32_shgetfolderpath (NULL, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE,
791                                    NULL, 0, path) >= 0)
792             {
793               char *tmp = xmalloc (strlen (path) + s1_len + 1);
794               char *p;
795
796               p = stpcpy (tmp, path);
797               for (comp = s1; *comp; comp++)
798                 {
799                   p = stpcpy (p, "\\");
800                   p = stpcpy (p, *comp);
801
802                   if (access (tmp, F_OK))
803                     w32_try_mkdir (tmp);
804                 }
805
806               dir = tmp;
807             }
808           else
809             {
810               dir = "c:\\temp\\cache\\gnupg";
811 #ifdef HAVE_W32CE_SYSTEM
812               dir += 2;
813               w32_try_mkdir ("\\temp\\cache");
814               w32_try_mkdir ("\\temp\\cache\\gnupg");
815 #endif
816             }
817         }
818     }
819   return dir;
820 #else /*!HAVE_W32_SYSTEM*/
821   return GNUPG_LOCALSTATEDIR "/cache/" PACKAGE_NAME;
822 #endif /*!HAVE_W32_SYSTEM*/
823 }
824
825
826 /* Return the user socket name used by DirMngr.  */
827 const char *
828 dirmngr_socket_name (void)
829 {
830   static char *name;
831
832   if (!name)
833     name = make_filename (gnupg_socketdir (), DIRMNGR_SOCK_NAME, NULL);
834   return name;
835 }
836
837
838 /* Return the default pinentry name.  If RESET is true the internal
839    cache is first flushed.  */
840 static const char *
841 get_default_pinentry_name (int reset)
842 {
843   static struct {
844     const char *(*rfnc)(void);
845     const char *name;
846   } names[] = {
847     /* The first entry is what we return in case we found no
848        other pinentry.  */
849     { gnupg_bindir, DIRSEP_S "pinentry" EXEEXT_S },
850 #ifdef HAVE_W32_SYSTEM
851     /* Try Gpg4win directory (with bin and without.) */
852     { w32_rootdir, "\\..\\Gpg4win\\bin\\pinentry.exe" },
853     { w32_rootdir, "\\..\\Gpg4win\\pinentry.exe" },
854     /* Try old Gpgwin directory.  */
855     { w32_rootdir, "\\..\\GNU\\GnuPG\\pinentry.exe" },
856     /* Try a Pinentry from the common GNU dir.  */
857     { w32_rootdir, "\\..\\GNU\\bin\\pinentry.exe" },
858 #endif
859     /* Last chance is a pinentry-basic (which comes with the
860        GnuPG 2.1 Windows installer).  */
861     { gnupg_bindir, DIRSEP_S "pinentry-basic" EXEEXT_S }
862   };
863   static char *name;
864
865   if (reset)
866     {
867       xfree (name);
868       name = NULL;
869     }
870
871   if (!name)
872     {
873       int i;
874
875       for (i=0; i < DIM(names); i++)
876         {
877           char *name2;
878
879           name2 = xstrconcat (names[i].rfnc (), names[i].name, NULL);
880           if (!access (name2, F_OK))
881             {
882               /* Use that pinentry.  */
883               xfree (name);
884               name = name2;
885               break;
886             }
887           if (!i) /* Store the first as fallback return.  */
888             name = name2;
889           else
890             xfree (name2);
891         }
892     }
893
894   return name;
895 }
896
897
898 /* If set, 'gnupg_module_name' returns modules from that build
899  * directory.  */
900 static char *gnupg_build_directory;
901
902 /* For sanity checks.  */
903 static int gnupg_module_name_called;
904
905
906 /* Set NEWDIR as the new build directory.  This will make
907  * 'gnupg_module_name' return modules from that build directory.  Must
908  * be called before any invocation of 'gnupg_module_name', and must
909  * not be called twice.  It can be used by test suites to make sure
910  * the components from the build directory are used instead of
911  * potentially outdated installed ones.  */
912 void
913 gnupg_set_builddir (const char *newdir)
914 {
915   log_assert (! gnupg_module_name_called);
916   log_assert (! gnupg_build_directory);
917   gnupg_build_directory = xtrystrdup (newdir);
918 }
919
920
921 /* If no build directory has been configured, try to set it from the
922  * environment.  We only do this in development builds to avoid
923  * increasing the set of influential environment variables and hence
924  * the attack surface of production builds.  */
925 static void
926 gnupg_set_builddir_from_env (void)
927 {
928 #if defined(IS_DEVELOPMENT_VERSION) || defined(ENABLE_GNUPG_BUILDDIR_ENVVAR)
929   if (gnupg_build_directory)
930     return;
931
932   gnupg_build_directory = getenv ("GNUPG_BUILDDIR");
933 #endif
934 }
935
936
937 /* Return the file name of a helper tool.  WHICH is one of the
938    GNUPG_MODULE_NAME_foo constants.  */
939 const char *
940 gnupg_module_name (int which)
941 {
942   gnupg_set_builddir_from_env ();
943   gnupg_module_name_called = 1;
944
945 #define X(a,b,c) do {                                                   \
946     static char *name;                                                  \
947     if (!name)                                                          \
948       name = gnupg_build_directory                                      \
949         ? xstrconcat (gnupg_build_directory,                            \
950                       DIRSEP_S b DIRSEP_S c EXEEXT_S, NULL)             \
951         : xstrconcat (gnupg_ ## a (), DIRSEP_S c EXEEXT_S, NULL);       \
952     return name;                                                        \
953   } while (0)
954
955   switch (which)
956     {
957     case GNUPG_MODULE_NAME_AGENT:
958 #ifdef GNUPG_DEFAULT_AGENT
959       return GNUPG_DEFAULT_AGENT;
960 #else
961       X(bindir, "agent", "gpg-agent");
962 #endif
963
964     case GNUPG_MODULE_NAME_PINENTRY:
965 #ifdef GNUPG_DEFAULT_PINENTRY
966       return GNUPG_DEFAULT_PINENTRY;  /* (Set by a configure option) */
967 #else
968       return get_default_pinentry_name (0);
969 #endif
970
971     case GNUPG_MODULE_NAME_SCDAEMON:
972 #ifdef GNUPG_DEFAULT_SCDAEMON
973       return GNUPG_DEFAULT_SCDAEMON;
974 #else
975       X(libexecdir, "scd", "scdaemon");
976 #endif
977
978     case GNUPG_MODULE_NAME_DIRMNGR:
979 #ifdef GNUPG_DEFAULT_DIRMNGR
980       return GNUPG_DEFAULT_DIRMNGR;
981 #else
982       X(bindir, "dirmngr", DIRMNGR_NAME);
983 #endif
984
985     case GNUPG_MODULE_NAME_PROTECT_TOOL:
986 #ifdef GNUPG_DEFAULT_PROTECT_TOOL
987       return GNUPG_DEFAULT_PROTECT_TOOL;
988 #else
989       X(libexecdir, "agent", "gpg-protect-tool");
990 #endif
991
992     case GNUPG_MODULE_NAME_DIRMNGR_LDAP:
993 #ifdef GNUPG_DEFAULT_DIRMNGR_LDAP
994       return GNUPG_DEFAULT_DIRMNGR_LDAP;
995 #else
996       X(libexecdir, "dirmngr", "dirmngr_ldap");
997 #endif
998
999     case GNUPG_MODULE_NAME_CHECK_PATTERN:
1000       X(libexecdir, "tools", "gpg-check-pattern");
1001
1002     case GNUPG_MODULE_NAME_GPGSM:
1003       X(bindir, "sm", "gpgsm");
1004
1005     case GNUPG_MODULE_NAME_GPG:
1006 #if USE_GPG2_HACK
1007       if (! gnupg_build_directory)
1008         X(bindir, "g10", GPG_NAME "2");
1009       else
1010 #endif
1011         X(bindir, "g10", GPG_NAME);
1012
1013     case GNUPG_MODULE_NAME_GPGV:
1014 #if USE_GPG2_HACK
1015       if (! gnupg_build_directory)
1016         X(bindir, "g10", GPG_NAME "v2");
1017       else
1018 #endif
1019         X(bindir, "g10", GPG_NAME "v");
1020
1021     case GNUPG_MODULE_NAME_CONNECT_AGENT:
1022       X(bindir, "tools", "gpg-connect-agent");
1023
1024     case GNUPG_MODULE_NAME_GPGCONF:
1025       X(bindir, "tools", "gpgconf");
1026
1027     default:
1028       BUG ();
1029     }
1030 #undef X
1031 }
1032
1033
1034 /* Flush some of the cached module names.  This is for example used by
1035    gpg-agent to allow configuring a different pinentry.  */
1036 void
1037 gnupg_module_name_flush_some (void)
1038 {
1039   (void)get_default_pinentry_name (1);
1040 }