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