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