Merge branch 'STABLE-BRANCH-2-2' into master
[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, *p;
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                 {
262                   /* Strip trailing backslashes.  */
263                   p = tmp + strlen (tmp) - 1;
264                   while (p > tmp && *p == '\\')
265                     *p-- = 0;
266                   saved_dir = tmp;
267                 }
268             }
269
270           if (!saved_dir)
271             saved_dir = standard_homedir ();
272         }
273       dir = saved_dir;
274     }
275 #endif /*HAVE_W32_SYSTEM*/
276
277   if (!dir || !*dir)
278     dir = GNUPG_DEFAULT_HOMEDIR;
279   else
280     {
281       /* Strip trailing slashes if any.  */
282       if (dir[strlen (dir)-1] == '/')
283         {
284           char *tmp, *p;
285
286           tmp = xstrdup (dir);
287           p = tmp + strlen (tmp) - 1;
288           while (p > tmp && *p == '/')
289             *p-- = 0;
290
291           dir = tmp;
292         }
293
294       if (!is_gnupg_default_homedir (dir))
295         non_default_homedir = 1;
296     }
297
298   return dir;
299 }
300
301
302 #ifdef HAVE_W32_SYSTEM
303 /* Check whether gpgconf is installed and if so read the gpgconf.ctl
304    file. */
305 static void
306 check_portable_app (const char *dir)
307 {
308   char *fname;
309
310   fname = xstrconcat (dir, DIRSEP_S "gpgconf.exe", NULL);
311   if (!access (fname, F_OK))
312     {
313       strcpy (fname + strlen (fname) - 3, "ctl");
314       if (!access (fname, F_OK))
315         {
316           /* gpgconf.ctl file found.  Record this fact.  */
317           w32_portable_app = 1;
318           {
319             unsigned int flags;
320             log_get_prefix (&flags);
321             log_set_prefix (NULL, (flags | GPGRT_LOG_NO_REGISTRY));
322           }
323           /* FIXME: We should read the file to detect special flags
324              and print a warning if we don't understand them  */
325         }
326     }
327   xfree (fname);
328 }
329
330
331 /* Determine the root directory of the gnupg installation on Windows.  */
332 static const char *
333 w32_rootdir (void)
334 {
335   static int got_dir;
336   static char dir[MAX_PATH+5];
337
338   if (!got_dir)
339     {
340       char *p;
341       int rc;
342       wchar_t wdir [MAX_PATH+5];
343
344       rc = GetModuleFileNameW (NULL, wdir, MAX_PATH);
345       if (rc && WideCharToMultiByte (CP_UTF8, 0, wdir, -1, dir, MAX_PATH-4,
346                                      NULL, NULL) < 0)
347         rc = 0;
348       if (!rc)
349         {
350           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (-1));
351           *dir = 0;
352         }
353       got_dir = 1;
354       p = strrchr (dir, DIRSEP_C);
355       if (p)
356         {
357           *p = 0;
358
359           check_portable_app (dir);
360
361           /* If we are installed below "bin" we strip that and use
362              the top directory instead.  */
363           p = strrchr (dir, DIRSEP_C);
364           if (p && !strcmp (p+1, "bin"))
365             {
366               *p = 0;
367               w32_bin_is_bin = 1;
368             }
369         }
370       if (!p)
371         {
372           log_debug ("bad filename '%s' returned for this process\n", dir);
373           *dir = 0;
374         }
375     }
376
377   if (*dir)
378     return dir;
379   /* Fallback to the hardwired value. */
380   return GNUPG_LIBEXECDIR;
381 }
382
383 static const char *
384 w32_commondir (void)
385 {
386   static char *dir;
387
388   if (!dir)
389     {
390       const char *rdir;
391       char path[MAX_PATH];
392
393       /* Make sure that w32_rootdir has been called so that we are
394          able to check the portable application flag.  The common dir
395          is the identical to the rootdir.  In that case there is also
396          no need to strdup its value.  */
397       rdir = w32_rootdir ();
398       if (w32_portable_app)
399         return rdir;
400
401       if (w32_shgetfolderpath (NULL, CSIDL_COMMON_APPDATA,
402                                NULL, 0, path) >= 0)
403         {
404           char *tmp = xmalloc (strlen (path) + 4 +1);
405           strcpy (stpcpy (tmp, path), "\\GNU");
406           dir = tmp;
407           /* No auto create of the directory.  Either the installer or
408              the admin has to create these directories.  */
409         }
410       else
411         {
412           /* Ooops: Not defined - probably an old Windows version.
413              Use the installation directory instead.  */
414           dir = xstrdup (rdir);
415         }
416     }
417
418   return dir;
419 }
420 #endif /*HAVE_W32_SYSTEM*/
421
422
423 /* Change the homedir.  Some care must be taken to set this early
424  * enough because previous calls to gnupg_homedir may else return a
425  * different string.  */
426 void
427 gnupg_set_homedir (const char *newdir)
428 {
429   char *tmp = NULL;
430
431   if (!newdir || !*newdir)
432     newdir = default_homedir ();
433   else
434     {
435       /* Remove trailing slashes from NEWSDIR.  */
436       if (newdir[strlen (newdir)-1] == '/'
437 #ifdef HAVE_W32_SYSTEM
438           || newdir[strlen (newdir)-1] == '\\'
439 #endif
440           )
441         {
442           char *p;
443
444           tmp = xstrdup (newdir);
445           p = tmp + strlen (tmp) - 1;
446           while (p > tmp
447                  && (*p == '/'
448 #ifdef HAVE_W32_SYSTEM
449                      || *p == '\\'
450 #endif
451                      )
452                  )
453             *p-- = 0;
454
455           newdir = tmp;
456         }
457       if (!is_gnupg_default_homedir (newdir))
458         non_default_homedir = 1;
459     }
460   xfree (the_gnupg_homedir);
461   the_gnupg_homedir = make_absfilename (newdir, NULL);;
462   xfree (tmp);
463 }
464
465
466 /* Return the homedir.  The returned string is valid until another
467  * gnupg-set-homedir call.  This is always an absolute directory name.
468  * The function replaces the former global var opt.homedir.  */
469 const char *
470 gnupg_homedir (void)
471 {
472   /* If a homedir has not been set, set it to the default.  */
473   if (!the_gnupg_homedir)
474     the_gnupg_homedir = make_absfilename (default_homedir (), NULL);
475   return the_gnupg_homedir;
476 }
477
478
479 /* Return whether the home dir is the default one.  */
480 int
481 gnupg_default_homedir_p (void)
482 {
483   return !non_default_homedir;
484 }
485
486
487 /* Return the directory name used by daemons for their current working
488  * directory.  */
489 const char *
490 gnupg_daemon_rootdir (void)
491 {
492 #ifdef HAVE_W32_SYSTEM
493   static char *name;
494
495   if (!name)
496     {
497       char path[MAX_PATH];
498       size_t n;
499
500       n = GetSystemDirectoryA (path, sizeof path);
501       if (!n || n >= sizeof path)
502         name = xstrdup ("/"); /* Error - use the curret top dir instead.  */
503       else
504         name = xstrdup (path);
505     }
506
507   return name;
508
509 #else /*!HAVE_W32_SYSTEM*/
510   return "/";
511 #endif /*!HAVE_W32_SYSTEM*/
512 }
513
514
515 /* Helper for gnupg-socketdir.  This is a global function, so that
516  * gpgconf can use it for its --create-socketdir command.  If
517  * SKIP_CHECKS is set permission checks etc. are not done.  The
518  * function always returns a malloced directory name and stores these
519  * bit flags at R_INFO:
520  *
521  *   1 := Internal error, stat failed, out of core, etc.
522  *   2 := No /run/user directory.
523  *   4 := Directory not owned by the user, not a directory
524  *        or wrong permissions.
525  *   8 := Same as 4 but for the subdir.
526  *  16 := mkdir failed
527  *  32 := Non default homedir; checking subdir.
528  *  64 := Subdir does not exist.
529  * 128 := Using homedir as fallback.
530  */
531 char *
532 _gnupg_socketdir_internal (int skip_checks, unsigned *r_info)
533 {
534 #if defined(HAVE_W32_SYSTEM) || !defined(HAVE_STAT)
535
536   char *name;
537
538   (void)skip_checks;
539   *r_info = 0;
540   name = xstrdup (gnupg_homedir ());
541
542 #else /* Unix and stat(2) available. */
543
544   static const char * const bases[] = {
545 #ifdef USE_RUN_GNUPG_USER_SOCKET
546     "/run/gnupg",
547 #endif
548     "/run",
549 #ifdef USE_RUN_GNUPG_USER_SOCKET
550     "/var/run/gnupg",
551 #endif
552     "/var/run",
553     NULL
554   };
555   int i;
556   struct stat sb;
557   char prefix[19 + 1 + 20 + 6 + 1];
558   const char *s;
559   char *name = NULL;
560
561   *r_info = 0;
562
563   /* First make sure that non_default_homedir can be set.  */
564   gnupg_homedir ();
565
566   /* It has been suggested to first check XDG_RUNTIME_DIR envvar.
567    * However, the specs state that the lifetime of the directory MUST
568    * be bound to the user being logged in.  Now GnuPG may also be run
569    * as a background process with no (desktop) user logged in.  Thus
570    * we better don't do that.  */
571
572   /* Check whether we have a /run/[gnupg/]user dir.  */
573   for (i=0; bases[i]; i++)
574     {
575       snprintf (prefix, sizeof prefix, "%s/user/%u",
576                 bases[i], (unsigned int)getuid ());
577       if (!stat (prefix, &sb) && S_ISDIR(sb.st_mode))
578         break;
579     }
580   if (!bases[i])
581     {
582       *r_info |= 2; /* No /run/user directory.  */
583       goto leave;
584     }
585
586   if (sb.st_uid != getuid ())
587     {
588       *r_info |= 4; /* Not owned by the user.  */
589       if (!skip_checks)
590         goto leave;
591     }
592
593   if (strlen (prefix) + 7 >= sizeof prefix)
594     {
595       *r_info |= 1; /* Ooops: Buffer too short to append "/gnupg".  */
596       goto leave;
597     }
598   strcat (prefix, "/gnupg");
599
600   /* Check whether the gnupg sub directory has proper permissions.  */
601   if (stat (prefix, &sb))
602     {
603       if (errno != ENOENT)
604         {
605           *r_info |= 1; /* stat failed.  */
606           goto leave;
607         }
608
609       /* Try to create the directory and check again.  */
610       if (gnupg_mkdir (prefix, "-rwx"))
611         {
612           *r_info |= 16; /* mkdir failed.  */
613           goto leave;
614         }
615       if (stat (prefix, &sb))
616         {
617           *r_info |= 1; /* stat failed.  */
618           goto leave;
619         }
620     }
621   /* Check that it is a directory, owned by the user, and only the
622    * user has permissions to use it.  */
623   if (!S_ISDIR(sb.st_mode)
624       || sb.st_uid != getuid ()
625       || (sb.st_mode & (S_IRWXG|S_IRWXO)))
626     {
627       *r_info |= 4; /* Bad permissions or not a directory. */
628       if (!skip_checks)
629         goto leave;
630     }
631
632   /* If a non default homedir is used, we check whether an
633    * corresponding sub directory below the socket dir is available
634    * and use that.  We hash the non default homedir to keep the new
635    * subdir short enough.  */
636   if (non_default_homedir)
637     {
638       char sha1buf[20];
639       char *suffix;
640
641       *r_info |= 32; /* Testing subdir.  */
642       s = gnupg_homedir ();
643       gcry_md_hash_buffer (GCRY_MD_SHA1, sha1buf, s, strlen (s));
644       suffix = zb32_encode (sha1buf, 8*15);
645       if (!suffix)
646         {
647           *r_info |= 1; /* Out of core etc. */
648           goto leave;
649         }
650       name = strconcat (prefix, "/d.", suffix, NULL);
651       xfree (suffix);
652       if (!name)
653         {
654           *r_info |= 1; /* Out of core etc. */
655           goto leave;
656         }
657
658       /* Stat that directory and check constraints.
659        * The command
660        *    gpgconf --remove-socketdir
661        * can be used to remove that directory.  */
662       if (stat (name, &sb))
663         {
664           if (errno != ENOENT)
665             *r_info |= 1; /* stat failed. */
666           else if (!skip_checks)
667             {
668               /* Try to create the directory and check again.  */
669               if (gnupg_mkdir (name, "-rwx"))
670                 *r_info |= 16; /* mkdir failed.  */
671               else if (stat (prefix, &sb))
672                 {
673                   if (errno != ENOENT)
674                     *r_info |= 1; /* stat failed. */
675                   else
676                     *r_info |= 64; /* Subdir does not exist.  */
677                 }
678               else
679                 goto leave; /* Success!  */
680             }
681           else
682             *r_info |= 64; /* Subdir does not exist.  */
683           if (!skip_checks)
684             {
685               xfree (name);
686               name = NULL;
687               goto leave;
688             }
689         }
690       else if (!S_ISDIR(sb.st_mode)
691                || sb.st_uid != getuid ()
692                || (sb.st_mode & (S_IRWXG|S_IRWXO)))
693         {
694           *r_info |= 8; /* Bad permissions or subdir is not a directory.  */
695           if (!skip_checks)
696             {
697               xfree (name);
698               name = NULL;
699               goto leave;
700             }
701         }
702     }
703   else
704     name = xstrdup (prefix);
705
706  leave:
707   /* If nothing works fall back to the homedir.  */
708   if (!name)
709     {
710       *r_info |= 128; /* Fallback.  */
711       name = xstrdup (gnupg_homedir ());
712     }
713
714 #endif /* Unix */
715
716   return name;
717 }
718
719
720 /*
721  * Return the name of the socket dir.  That is the directory used for
722  * the IPC local sockets.  This is an absolute directory name.
723  */
724 const char *
725 gnupg_socketdir (void)
726 {
727   static char *name;
728
729   if (!name)
730     {
731       unsigned int dummy;
732       name = _gnupg_socketdir_internal (0, &dummy);
733     }
734
735   return name;
736 }
737
738
739 /* Return the name of the sysconfdir.  This is a static string.  This
740    function is required because under Windows we can't simply compile
741    it in.  */
742 const char *
743 gnupg_sysconfdir (void)
744 {
745 #ifdef HAVE_W32_SYSTEM
746   static char *name;
747
748   if (!name)
749     {
750       const char *s1, *s2;
751       s1 = w32_commondir ();
752       s2 = DIRSEP_S "etc" DIRSEP_S "gnupg";
753       name = xmalloc (strlen (s1) + strlen (s2) + 1);
754       strcpy (stpcpy (name, s1), s2);
755     }
756   return name;
757 #else /*!HAVE_W32_SYSTEM*/
758   return GNUPG_SYSCONFDIR;
759 #endif /*!HAVE_W32_SYSTEM*/
760 }
761
762
763 const char *
764 gnupg_bindir (void)
765 {
766 #if defined (HAVE_W32CE_SYSTEM)
767   static char *name;
768
769   if (!name)
770     name = xstrconcat (w32_rootdir (), DIRSEP_S "bin", NULL);
771   return name;
772 #elif defined(HAVE_W32_SYSTEM)
773   const char *rdir;
774
775   rdir = w32_rootdir ();
776   if (w32_bin_is_bin)
777     {
778       static char *name;
779
780       if (!name)
781         name = xstrconcat (rdir, DIRSEP_S "bin", NULL);
782       return name;
783     }
784   else
785     return rdir;
786 #else /*!HAVE_W32_SYSTEM*/
787   return GNUPG_BINDIR;
788 #endif /*!HAVE_W32_SYSTEM*/
789 }
790
791
792 /* Return the name of the libexec directory.  The name is allocated in
793    a static area on the first use.  This function won't fail. */
794 const char *
795 gnupg_libexecdir (void)
796 {
797 #ifdef HAVE_W32_SYSTEM
798   return gnupg_bindir ();
799 #else /*!HAVE_W32_SYSTEM*/
800   return GNUPG_LIBEXECDIR;
801 #endif /*!HAVE_W32_SYSTEM*/
802 }
803
804 const char *
805 gnupg_libdir (void)
806 {
807 #ifdef HAVE_W32_SYSTEM
808   static char *name;
809
810   if (!name)
811     name = xstrconcat (w32_rootdir (), DIRSEP_S "lib" DIRSEP_S "gnupg", NULL);
812   return name;
813 #else /*!HAVE_W32_SYSTEM*/
814   return GNUPG_LIBDIR;
815 #endif /*!HAVE_W32_SYSTEM*/
816 }
817
818 const char *
819 gnupg_datadir (void)
820 {
821 #ifdef HAVE_W32_SYSTEM
822   static char *name;
823
824   if (!name)
825     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "gnupg", NULL);
826   return name;
827 #else /*!HAVE_W32_SYSTEM*/
828   return GNUPG_DATADIR;
829 #endif /*!HAVE_W32_SYSTEM*/
830 }
831
832
833 const char *
834 gnupg_localedir (void)
835 {
836 #ifdef HAVE_W32_SYSTEM
837   static char *name;
838
839   if (!name)
840     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "locale",
841                        NULL);
842   return name;
843 #else /*!HAVE_W32_SYSTEM*/
844   return LOCALEDIR;
845 #endif /*!HAVE_W32_SYSTEM*/
846 }
847
848
849 /* Return the name of the cache directory.  The name is allocated in a
850    static area on the first use.  Windows only: If the directory does
851    not exist it is created.  */
852 const char *
853 gnupg_cachedir (void)
854 {
855 #ifdef HAVE_W32_SYSTEM
856   static const char *dir;
857
858   if (!dir)
859     {
860       const char *rdir;
861
862       rdir = w32_rootdir ();
863       if (w32_portable_app)
864         {
865           dir = xstrconcat (rdir,
866                             DIRSEP_S, "var",
867                             DIRSEP_S, "cache",
868                             DIRSEP_S, "gnupg", NULL);
869         }
870       else
871         {
872           char path[MAX_PATH];
873           const char *s1[] = { "GNU", "cache", "gnupg", NULL };
874           int s1_len;
875           const char **comp;
876
877           s1_len = 0;
878           for (comp = s1; *comp; comp++)
879             s1_len += 1 + strlen (*comp);
880
881           if (w32_shgetfolderpath (NULL, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE,
882                                    NULL, 0, path) >= 0)
883             {
884               char *tmp = xmalloc (strlen (path) + s1_len + 1);
885               char *p;
886
887               p = stpcpy (tmp, path);
888               for (comp = s1; *comp; comp++)
889                 {
890                   p = stpcpy (p, "\\");
891                   p = stpcpy (p, *comp);
892
893                   if (access (tmp, F_OK))
894                     w32_try_mkdir (tmp);
895                 }
896
897               dir = tmp;
898             }
899           else
900             {
901               dir = "c:\\temp\\cache\\gnupg";
902 #ifdef HAVE_W32CE_SYSTEM
903               dir += 2;
904               w32_try_mkdir ("\\temp\\cache");
905               w32_try_mkdir ("\\temp\\cache\\gnupg");
906 #endif
907             }
908         }
909     }
910   return dir;
911 #else /*!HAVE_W32_SYSTEM*/
912   return GNUPG_LOCALSTATEDIR "/cache/" PACKAGE_NAME;
913 #endif /*!HAVE_W32_SYSTEM*/
914 }
915
916
917 /* Return the user socket name used by DirMngr.  */
918 const char *
919 dirmngr_socket_name (void)
920 {
921   static char *name;
922
923   if (!name)
924     name = make_filename (gnupg_socketdir (), DIRMNGR_SOCK_NAME, NULL);
925   return name;
926 }
927
928
929 /* Return the default pinentry name.  If RESET is true the internal
930    cache is first flushed.  */
931 static const char *
932 get_default_pinentry_name (int reset)
933 {
934   static struct {
935     const char *(*rfnc)(void);
936     const char *name;
937   } names[] = {
938     /* The first entry is what we return in case we found no
939        other pinentry.  */
940     { gnupg_bindir, DIRSEP_S "pinentry" EXEEXT_S },
941 #ifdef HAVE_W32_SYSTEM
942     /* Try Gpg4win directory (with bin and without.) */
943     { w32_rootdir, "\\..\\Gpg4win\\bin\\pinentry.exe" },
944     { w32_rootdir, "\\..\\Gpg4win\\pinentry.exe" },
945     /* Try old Gpgwin directory.  */
946     { w32_rootdir, "\\..\\GNU\\GnuPG\\pinentry.exe" },
947     /* Try a Pinentry from the common GNU dir.  */
948     { w32_rootdir, "\\..\\GNU\\bin\\pinentry.exe" },
949 #endif
950     /* Last chance is a pinentry-basic (which comes with the
951        GnuPG 2.1 Windows installer).  */
952     { gnupg_bindir, DIRSEP_S "pinentry-basic" EXEEXT_S }
953   };
954   static char *name;
955
956   if (reset)
957     {
958       xfree (name);
959       name = NULL;
960     }
961
962   if (!name)
963     {
964       int i;
965
966       for (i=0; i < DIM(names); i++)
967         {
968           char *name2;
969
970           name2 = xstrconcat (names[i].rfnc (), names[i].name, NULL);
971           if (!access (name2, F_OK))
972             {
973               /* Use that pinentry.  */
974               xfree (name);
975               name = name2;
976               break;
977             }
978           if (!i) /* Store the first as fallback return.  */
979             name = name2;
980           else
981             xfree (name2);
982         }
983     }
984
985   return name;
986 }
987
988
989 /* If set, 'gnupg_module_name' returns modules from that build
990  * directory.  */
991 static char *gnupg_build_directory;
992
993 /* For sanity checks.  */
994 static int gnupg_module_name_called;
995
996
997 /* Set NEWDIR as the new build directory.  This will make
998  * 'gnupg_module_name' return modules from that build directory.  Must
999  * be called before any invocation of 'gnupg_module_name', and must
1000  * not be called twice.  It can be used by test suites to make sure
1001  * the components from the build directory are used instead of
1002  * potentially outdated installed ones.  */
1003 void
1004 gnupg_set_builddir (const char *newdir)
1005 {
1006   log_assert (! gnupg_module_name_called);
1007   log_assert (! gnupg_build_directory);
1008   gnupg_build_directory = xtrystrdup (newdir);
1009 }
1010
1011
1012 /* If no build directory has been configured, try to set it from the
1013  * environment.  We only do this in development builds to avoid
1014  * increasing the set of influential environment variables and hence
1015  * the attack surface of production builds.  */
1016 static void
1017 gnupg_set_builddir_from_env (void)
1018 {
1019 #if defined(IS_DEVELOPMENT_VERSION) || defined(ENABLE_GNUPG_BUILDDIR_ENVVAR)
1020   if (gnupg_build_directory)
1021     return;
1022
1023   gnupg_build_directory = getenv ("GNUPG_BUILDDIR");
1024 #endif
1025 }
1026
1027
1028 /* Return the file name of a helper tool.  WHICH is one of the
1029    GNUPG_MODULE_NAME_foo constants.  */
1030 const char *
1031 gnupg_module_name (int which)
1032 {
1033   gnupg_set_builddir_from_env ();
1034   gnupg_module_name_called = 1;
1035
1036 #define X(a,b,c) do {                                                   \
1037     static char *name;                                                  \
1038     if (!name)                                                          \
1039       name = gnupg_build_directory                                      \
1040         ? xstrconcat (gnupg_build_directory,                            \
1041                       DIRSEP_S b DIRSEP_S c EXEEXT_S, NULL)             \
1042         : xstrconcat (gnupg_ ## a (), DIRSEP_S c EXEEXT_S, NULL);       \
1043     return name;                                                        \
1044   } while (0)
1045
1046   switch (which)
1047     {
1048     case GNUPG_MODULE_NAME_AGENT:
1049 #ifdef GNUPG_DEFAULT_AGENT
1050       return GNUPG_DEFAULT_AGENT;
1051 #else
1052       X(bindir, "agent", "gpg-agent");
1053 #endif
1054
1055     case GNUPG_MODULE_NAME_PINENTRY:
1056 #ifdef GNUPG_DEFAULT_PINENTRY
1057       return GNUPG_DEFAULT_PINENTRY;  /* (Set by a configure option) */
1058 #else
1059       return get_default_pinentry_name (0);
1060 #endif
1061
1062     case GNUPG_MODULE_NAME_SCDAEMON:
1063 #ifdef GNUPG_DEFAULT_SCDAEMON
1064       return GNUPG_DEFAULT_SCDAEMON;
1065 #else
1066       X(libexecdir, "scd", "scdaemon");
1067 #endif
1068
1069     case GNUPG_MODULE_NAME_DIRMNGR:
1070 #ifdef GNUPG_DEFAULT_DIRMNGR
1071       return GNUPG_DEFAULT_DIRMNGR;
1072 #else
1073       X(bindir, "dirmngr", DIRMNGR_NAME);
1074 #endif
1075
1076     case GNUPG_MODULE_NAME_PROTECT_TOOL:
1077 #ifdef GNUPG_DEFAULT_PROTECT_TOOL
1078       return GNUPG_DEFAULT_PROTECT_TOOL;
1079 #else
1080       X(libexecdir, "agent", "gpg-protect-tool");
1081 #endif
1082
1083     case GNUPG_MODULE_NAME_DIRMNGR_LDAP:
1084 #ifdef GNUPG_DEFAULT_DIRMNGR_LDAP
1085       return GNUPG_DEFAULT_DIRMNGR_LDAP;
1086 #else
1087       X(libexecdir, "dirmngr", "dirmngr_ldap");
1088 #endif
1089
1090     case GNUPG_MODULE_NAME_CHECK_PATTERN:
1091       X(libexecdir, "tools", "gpg-check-pattern");
1092
1093     case GNUPG_MODULE_NAME_GPGSM:
1094       X(bindir, "sm", "gpgsm");
1095
1096     case GNUPG_MODULE_NAME_GPG:
1097 #if USE_GPG2_HACK
1098       if (! gnupg_build_directory)
1099         X(bindir, "g10", GPG_NAME "2");
1100       else
1101 #endif
1102         X(bindir, "g10", GPG_NAME);
1103
1104     case GNUPG_MODULE_NAME_GPGV:
1105 #if USE_GPG2_HACK
1106       if (! gnupg_build_directory)
1107         X(bindir, "g10", GPG_NAME "v2");
1108       else
1109 #endif
1110         X(bindir, "g10", GPG_NAME "v");
1111
1112     case GNUPG_MODULE_NAME_CONNECT_AGENT:
1113       X(bindir, "tools", "gpg-connect-agent");
1114
1115     case GNUPG_MODULE_NAME_GPGCONF:
1116       X(bindir, "tools", "gpgconf");
1117
1118     default:
1119       BUG ();
1120     }
1121 #undef X
1122 }
1123
1124
1125 /* Flush some of the cached module names.  This is for example used by
1126    gpg-agent to allow configuring a different pinentry.  */
1127 void
1128 gnupg_module_name_flush_some (void)
1129 {
1130   (void)get_default_pinentry_name (1);
1131 }