faf9787d6f172204bad57e855c818e1b59feff40
[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. */
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, "Software\\GNU\\GnuPG",
225                                               "HomeDir");
226               if (tmp && !*tmp)
227                 {
228                   xfree (tmp);
229                   tmp = NULL;
230                 }
231               if (tmp)
232                 saved_dir = tmp;
233             }
234
235           if (!saved_dir)
236             saved_dir = standard_homedir ();
237         }
238       dir = saved_dir;
239     }
240 #endif /*HAVE_W32_SYSTEM*/
241   if (!dir || !*dir)
242     dir = GNUPG_DEFAULT_HOMEDIR;
243
244   return dir;
245 }
246
247
248 #ifdef HAVE_W32_SYSTEM
249 /* Check whether gpgconf is installed and if so read the gpgconf.ctl
250    file. */
251 static void
252 check_portable_app (const char *dir)
253 {
254   char *fname;
255
256   fname = xstrconcat (dir, DIRSEP_S "gpgconf.exe", NULL);
257   if (access (fname, F_OK))
258     log_error ("required binary '%s' is not installed\n", fname);
259   else
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 | JNLIB_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
291 #ifdef HAVE_W32CE_SYSTEM
292       {
293         wchar_t wdir [MAX_PATH+5];
294         rc = GetModuleFileName (NULL, wdir, MAX_PATH);
295         if (rc && WideCharToMultiByte (CP_UTF8, 0, wdir, -1, dir, MAX_PATH-4,
296                                        NULL, NULL) < 0)
297           rc = 0;
298       }
299 #else
300       rc = GetModuleFileName (NULL, dir, MAX_PATH);
301 #endif
302       if (!rc)
303         {
304           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (0));
305           *dir = 0;
306         }
307       got_dir = 1;
308       p = strrchr (dir, DIRSEP_C);
309       if (p)
310         {
311           *p = 0;
312
313           check_portable_app (dir);
314
315           /* If we are installed below "bin" we strip that and use
316              the top directory instead.  */
317           p = strrchr (dir, DIRSEP_C);
318           if (p && !strcmp (p+1, "bin"))
319             {
320               *p = 0;
321               w32_bin_is_bin = 1;
322             }
323         }
324       if (!p)
325         {
326           log_debug ("bad filename '%s' returned for this process\n", dir);
327           *dir = 0;
328         }
329     }
330
331   if (*dir)
332     return dir;
333   /* Fallback to the hardwired value. */
334   return GNUPG_LIBEXECDIR;
335 }
336
337 static const char *
338 w32_commondir (void)
339 {
340   static char *dir;
341
342   if (!dir)
343     {
344       const char *rdir;
345       char path[MAX_PATH];
346
347       /* Make sure that w32_rootdir has been called so that we are
348          able to check the portable application flag.  The common dir
349          is the identical to the rootdir.  In that case there is also
350          no need to strdup its value.  */
351       rdir = w32_rootdir ();
352       if (w32_portable_app)
353         return rdir;
354
355       if (w32_shgetfolderpath (NULL, CSIDL_COMMON_APPDATA,
356                                NULL, 0, path) >= 0)
357         {
358           char *tmp = xmalloc (strlen (path) + 4 +1);
359           strcpy (stpcpy (tmp, path), "\\GNU");
360           dir = tmp;
361           /* No auto create of the directory.  Either the installer or
362              the admin has to create these directories.  */
363         }
364       else
365         {
366           /* Ooops: Not defined - probably an old Windows version.
367              Use the installation directory instead.  */
368           dir = xstrdup (rdir);
369         }
370     }
371
372   return dir;
373 }
374 #endif /*HAVE_W32_SYSTEM*/
375
376
377
378
379 /* Return the name of the sysconfdir.  This is a static string.  This
380    function is required because under Windows we can't simply compile
381    it in.  */
382 const char *
383 gnupg_sysconfdir (void)
384 {
385 #ifdef HAVE_W32_SYSTEM
386   static char *name;
387
388   if (!name)
389     {
390       const char *s1, *s2;
391       s1 = w32_commondir ();
392       s2 = DIRSEP_S "etc" DIRSEP_S "gnupg";
393       name = xmalloc (strlen (s1) + strlen (s2) + 1);
394       strcpy (stpcpy (name, s1), s2);
395     }
396   return name;
397 #else /*!HAVE_W32_SYSTEM*/
398   return GNUPG_SYSCONFDIR;
399 #endif /*!HAVE_W32_SYSTEM*/
400 }
401
402
403 const char *
404 gnupg_bindir (void)
405 {
406 #if defined (HAVE_W32CE_SYSTEM)
407   static char *name;
408
409   if (!name)
410     name = xstrconcat (w32_rootdir (), DIRSEP_S "bin", NULL);
411   return name;
412 #elif defined(HAVE_W32_SYSTEM)
413   const char *rdir;
414
415   rdir = w32_rootdir ();
416   if (w32_bin_is_bin)
417     {
418       static char *name;
419
420       if (!name)
421         name = xstrconcat (rdir, DIRSEP_S "bin", NULL);
422       return name;
423     }
424   else
425     return rdir;
426 #else /*!HAVE_W32_SYSTEM*/
427   return GNUPG_BINDIR;
428 #endif /*!HAVE_W32_SYSTEM*/
429 }
430
431
432 /* Return the name of the libexec directory.  The name is allocated in
433    a static area on the first use.  This function won't fail. */
434 const char *
435 gnupg_libexecdir (void)
436 {
437 #ifdef HAVE_W32_SYSTEM
438   return gnupg_bindir ();
439 #else /*!HAVE_W32_SYSTEM*/
440   return GNUPG_LIBEXECDIR;
441 #endif /*!HAVE_W32_SYSTEM*/
442 }
443
444 const char *
445 gnupg_libdir (void)
446 {
447 #ifdef HAVE_W32_SYSTEM
448   static char *name;
449
450   if (!name)
451     name = xstrconcat (w32_rootdir (), DIRSEP_S "lib" DIRSEP_S "gnupg", NULL);
452   return name;
453 #else /*!HAVE_W32_SYSTEM*/
454   return GNUPG_LIBDIR;
455 #endif /*!HAVE_W32_SYSTEM*/
456 }
457
458 const char *
459 gnupg_datadir (void)
460 {
461 #ifdef HAVE_W32_SYSTEM
462   static char *name;
463
464   if (!name)
465     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "gnupg", NULL);
466   return name;
467 #else /*!HAVE_W32_SYSTEM*/
468   return GNUPG_DATADIR;
469 #endif /*!HAVE_W32_SYSTEM*/
470 }
471
472
473 const char *
474 gnupg_localedir (void)
475 {
476 #ifdef HAVE_W32_SYSTEM
477   static char *name;
478
479   if (!name)
480     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "locale",
481                        NULL);
482   return name;
483 #else /*!HAVE_W32_SYSTEM*/
484   return LOCALEDIR;
485 #endif /*!HAVE_W32_SYSTEM*/
486 }
487
488
489 /* Return the name of the cache directory.  The name is allocated in a
490    static area on the first use.  Windows only: If the directory does
491    not exist it is created.  */
492 const char *
493 gnupg_cachedir (void)
494 {
495 #ifdef HAVE_W32_SYSTEM
496   static const char *dir;
497
498   if (!dir)
499     {
500       const char *rdir;
501
502       rdir = w32_rootdir ();
503       if (w32_portable_app)
504         {
505           dir = xstrconcat (rdir,
506                             DIRSEP_S, "var",
507                             DIRSEP_S, "cache",
508                             DIRSEP_S, "gnupg", NULL);
509         }
510       else
511         {
512           char path[MAX_PATH];
513           const char *s1[] = { "GNU", "cache", "gnupg", NULL };
514           int s1_len;
515           const char **comp;
516
517           s1_len = 0;
518           for (comp = s1; *comp; comp++)
519             s1_len += 1 + strlen (*comp);
520
521           if (w32_shgetfolderpath (NULL, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE,
522                                    NULL, 0, path) >= 0)
523             {
524               char *tmp = xmalloc (strlen (path) + s1_len + 1);
525               char *p;
526
527               p = stpcpy (tmp, path);
528               for (comp = s1; *comp; comp++)
529                 {
530                   p = stpcpy (p, "\\");
531                   p = stpcpy (p, *comp);
532
533                   if (access (tmp, F_OK))
534                     w32_try_mkdir (tmp);
535                 }
536
537               dir = tmp;
538             }
539           else
540             {
541               dir = "c:\\temp\\cache\\gnupg";
542 #ifdef HAVE_W32CE_SYSTEM
543               dir += 2;
544               w32_try_mkdir ("\\temp\\cache");
545               w32_try_mkdir ("\\temp\\cache\\gnupg");
546 #endif
547             }
548         }
549     }
550   return dir;
551 #else /*!HAVE_W32_SYSTEM*/
552   return GNUPG_LOCALSTATEDIR "/cache/" PACKAGE_NAME;
553 #endif /*!HAVE_W32_SYSTEM*/
554 }
555
556
557 /* Return the default socket name used by DirMngr. */
558 const char *
559 dirmngr_socket_name (void)
560 {
561 #ifdef HAVE_W32_SYSTEM
562   static char *name;
563
564   if (!name)
565     {
566       char *p;
567 # ifdef HAVE_W32CE_SYSTEM
568       const char *s1, *s2;
569
570       s1 = default_homedir ();
571 # else
572       char s1buf[MAX_PATH];
573       const char *s1, *s2;
574
575       s1 = default_homedir ();
576       if (!w32_portable_app)
577         {
578           /* We need something akin CSIDL_COMMON_PROGRAMS, but local
579              (non-roaming).  This is because the file needs to be on
580              the local machine and makes only sense on that machine.
581              CSIDL_WINDOWS seems to be the only location which
582              guarantees that. */
583           if (w32_shgetfolderpath (NULL, CSIDL_WINDOWS, NULL, 0, s1buf) < 0)
584             strcpy (s1buf, "C:\\WINDOWS");
585           s1 = s1buf;
586         }
587 # endif
588       s2 = DIRSEP_S "S.dirmngr";
589       name = xmalloc (strlen (s1) + strlen (s2) + 1);
590       strcpy (stpcpy (name, s1), s2);
591       for (p=name; *p; p++)
592         if (*p == '/')
593           *p = '\\';
594     }
595   return name;
596 #else /*!HAVE_W32_SYSTEM*/
597   return GNUPG_LOCALSTATEDIR "/run/" PACKAGE_NAME "/S.dirmngr";
598 #endif /*!HAVE_W32_SYSTEM*/
599 }
600
601
602
603 /* Return the file name of a helper tool.  WHICH is one of the
604    GNUPG_MODULE_NAME_foo constants.  */
605 const char *
606 gnupg_module_name (int which)
607 {
608 #define X(a,b) do {                                                     \
609     static char *name;                                                  \
610     if (!name)                                                          \
611       name = xstrconcat (gnupg_ ## a (), DIRSEP_S b EXEEXT_S, NULL);    \
612     return name;                                                        \
613   } while (0)
614
615   switch (which)
616     {
617     case GNUPG_MODULE_NAME_AGENT:
618 #ifdef GNUPG_DEFAULT_AGENT
619       return GNUPG_DEFAULT_AGENT;
620 #else
621       X(bindir, "gpg-agent");
622 #endif
623
624     case GNUPG_MODULE_NAME_PINENTRY:
625 #ifdef GNUPG_DEFAULT_PINENTRY
626       return GNUPG_DEFAULT_PINENTRY;
627 #else
628       X(bindir, "pinentry");
629 #endif
630
631     case GNUPG_MODULE_NAME_SCDAEMON:
632 #ifdef GNUPG_DEFAULT_SCDAEMON
633       return GNUPG_DEFAULT_SCDAEMON;
634 #else
635       X(libexecdir, "scdaemon");
636 #endif
637
638     case GNUPG_MODULE_NAME_DIRMNGR:
639 #ifdef GNUPG_DEFAULT_DIRMNGR
640       return GNUPG_DEFAULT_DIRMNGR;
641 #else
642       X(bindir, "dirmngr");
643 #endif
644
645     case GNUPG_MODULE_NAME_PROTECT_TOOL:
646 #ifdef GNUPG_DEFAULT_PROTECT_TOOL
647       return GNUPG_DEFAULT_PROTECT_TOOL;
648 #else
649       X(libexecdir, "gpg-protect-tool");
650 #endif
651
652     case GNUPG_MODULE_NAME_DIRMNGR_LDAP:
653 #ifdef GNUPG_DEFAULT_DIRMNGR_LDAP
654       return GNUPG_DEFAULT_DIRMNGR_LDAP;
655 #else
656       X(libexecdir, "dirmngr_ldap");
657 #endif
658
659     case GNUPG_MODULE_NAME_CHECK_PATTERN:
660       X(libexecdir, "gpg-check-pattern");
661
662     case GNUPG_MODULE_NAME_GPGSM:
663       X(bindir, "gpgsm");
664
665     case GNUPG_MODULE_NAME_GPG:
666       X(bindir, NAME_OF_INSTALLED_GPG);
667
668     case GNUPG_MODULE_NAME_CONNECT_AGENT:
669       X(bindir, "gpg-connect-agent");
670
671     case GNUPG_MODULE_NAME_GPGCONF:
672       X(bindir, "gpgconf");
673
674     default:
675       BUG ();
676     }
677 #undef X
678 }