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