4b03cfe5caaec9935b7f7ebca32c0e111ff71d7d
[gnupg.git] / common / homedir.c
1 /* homedir.c - Setup the home directory.
2  * Copyright (C) 2004, 2006, 2007 Free Software Foundation, Inc.
3  * Copyright (C) 2013 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <errno.h>
24 #include <fcntl.h>
25
26 #ifdef HAVE_W32_SYSTEM
27 # ifdef HAVE_WINSOCK2_H
28 #  include <winsock2.h>
29 # endif
30 #include <shlobj.h>
31 #ifndef CSIDL_APPDATA
32 #define CSIDL_APPDATA 0x001a
33 #endif
34 #ifndef CSIDL_LOCAL_APPDATA
35 #define CSIDL_LOCAL_APPDATA 0x001c
36 #endif
37 #ifndef CSIDL_COMMON_APPDATA
38 #define CSIDL_COMMON_APPDATA 0x0023
39 #endif
40 #ifndef CSIDL_FLAG_CREATE
41 #define CSIDL_FLAG_CREATE 0x8000
42 #endif
43 #endif /*HAVE_W32_SYSTEM*/
44
45
46
47 #include "util.h"
48 #include "sysutils.h"
49
50
51 #ifdef HAVE_W32_SYSTEM
52 /* A flag used to indicate that a control file for gpgconf has been
53    detected.  Under Windows the presence of this file indicates a
54    portable installations and triggers several changes:
55
56    - The GNUGHOME directory is fixed relative to installation
57      directory.  All other means to set the home directory are
58      ignored.
59
60    - All registry variables are ignored.
61
62    This flag is not used on Unix systems.
63  */
64 static int w32_portable_app;
65
66 /* This flag is true if this process' binary has been installed under
67    bin and not in the root directory. */
68 static int w32_bin_is_bin;
69
70 /* Just a little prototype.  */
71 static const char *w32_rootdir (void);
72
73 #endif /*HAVE_W32_SYSTEM*/
74
75
76
77
78 /* This is a helper function to load a Windows function from either of
79    one DLLs. */
80 #ifdef HAVE_W32_SYSTEM
81 static HRESULT
82 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
83 {
84   static int initialized;
85   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
86
87   if (!initialized)
88     {
89       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
90       void *handle;
91       int i;
92
93       initialized = 1;
94
95       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
96         {
97           handle = dlopen (dllnames[i], RTLD_LAZY);
98           if (handle)
99             {
100               func = dlsym (handle, "SHGetFolderPathA");
101               if (!func)
102                 {
103                   dlclose (handle);
104                   handle = NULL;
105                 }
106             }
107         }
108     }
109
110   if (func)
111     return func (a,b,c,d,e);
112   else
113     return -1;
114 }
115 #endif /*HAVE_W32_SYSTEM*/
116
117
118 /* Get the standard home directory.  In general this function should
119    not be used as it does not consider a registry value (under W32) or
120    the GNUPGHOME environment variable.  It is better to use
121    default_homedir(). */
122 const char *
123 standard_homedir (void)
124 {
125 #ifdef HAVE_W32_SYSTEM
126   static const char *dir;
127
128   if (!dir)
129     {
130       const char *rdir;
131
132       rdir = w32_rootdir ();
133       if (w32_portable_app)
134         {
135           dir = xstrconcat (rdir, DIRSEP_S "home", NULL);
136         }
137       else
138         {
139           char path[MAX_PATH];
140
141           /* It might be better to use LOCAL_APPDATA because this is
142              defined as "non roaming" and thus more likely to be kept
143              locally.  For private keys this is desired.  However,
144              given that many users copy private keys anyway forth and
145              back, using a system roaming services might be better
146              than to let them do it manually.  A security conscious
147              user will anyway use the registry entry to have better
148              control.  */
149           if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
150                                    NULL, 0, path) >= 0)
151             {
152               char *tmp = xmalloc (strlen (path) + 6 +1);
153               strcpy (stpcpy (tmp, path), "\\gnupg");
154               dir = tmp;
155
156               /* Try to create the directory if it does not yet exists.  */
157               if (access (dir, F_OK))
158                 CreateDirectory (dir, NULL);
159             }
160           else
161             dir = GNUPG_DEFAULT_HOMEDIR;
162         }
163     }
164   return dir;
165 #else/*!HAVE_W32_SYSTEM*/
166   return GNUPG_DEFAULT_HOMEDIR;
167 #endif /*!HAVE_W32_SYSTEM*/
168 }
169
170 /* Set up the default home directory.  The usual --homedir option
171    should be parsed later. */
172 const char *
173 default_homedir (void)
174 {
175   const char *dir;
176
177 #ifdef HAVE_W32_SYSTEM
178   /* For a portable application we only use the standard homedir.  */
179   w32_rootdir ();
180   if (w32_portable_app)
181     return standard_homedir ();
182 #endif /*HAVE_W32_SYSTEM*/
183
184   dir = getenv ("GNUPGHOME");
185 #ifdef HAVE_W32_SYSTEM
186   if (!dir || !*dir)
187     {
188       static const char *saved_dir;
189
190       if (!saved_dir)
191         {
192           if (!dir || !*dir)
193             {
194               char *tmp;
195
196               tmp = read_w32_registry_string (NULL, "Software\\GNU\\GnuPG",
197                                               "HomeDir");
198               if (tmp && !*tmp)
199                 {
200                   xfree (tmp);
201                   tmp = NULL;
202                 }
203               if (tmp)
204                 saved_dir = tmp;
205             }
206
207           if (!saved_dir)
208             saved_dir = standard_homedir ();
209         }
210       dir = saved_dir;
211     }
212 #endif /*HAVE_W32_SYSTEM*/
213   if (!dir || !*dir)
214     dir = GNUPG_DEFAULT_HOMEDIR;
215
216   return dir;
217 }
218
219
220 #ifdef HAVE_W32_SYSTEM
221 /* Check whether gpgconf is installed and if so read the gpgconf.ctl
222    file. */
223 static void
224 check_portable_app (const char *dir)
225 {
226   char *fname;
227
228   fname = xstrconcat (dir, DIRSEP_S "gpgconf.exe", NULL);
229   if (access (fname, F_OK))
230     log_error ("required binary '%s' is not installed\n", fname);
231   else
232     {
233       strcpy (fname + strlen (fname) - 3, "ctl");
234       if (!access (fname, F_OK))
235         {
236           /* gpgconf.ctl file found.  Record this fact.  */
237           w32_portable_app = 1;
238
239           /* FIXME: We should read the file to detect special flags
240              and print a warning if we don't understand them.  */
241         }
242     }
243   xfree (fname);
244 }
245
246 static const char *
247 w32_rootdir (void)
248 {
249   static int got_dir;
250   static char dir[MAX_PATH+5];
251
252   if (!got_dir)
253     {
254       char *p;
255
256       if ( !GetModuleFileName ( NULL, dir, MAX_PATH) )
257         {
258           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (0));
259           *dir = 0;
260         }
261       got_dir = 1;
262       p = strrchr (dir, DIRSEP_C);
263       if (p)
264         {
265           *p = 0;
266
267           check_portable_app (dir);
268
269           /* If we are installed below "bin" we strip that and use
270              the top directory instead.  */
271           p = strrchr (dir, DIRSEP_C);
272
273           if (p && !strcmp (p+1, "bin"))
274             {
275               *p = 0;
276               w32_bin_is_bin = 1;
277             }
278         }
279       if (!p)
280         {
281           log_debug ("bad filename `%s' returned for this process\n", dir);
282           *dir = 0;
283         }
284     }
285
286   if (*dir)
287     return dir;
288   /* Fallback to the hardwired value. */
289   return GNUPG_LIBEXECDIR;
290 }
291
292 static const char *
293 w32_commondir (void)
294 {
295   static char *dir;
296
297   if (!dir)
298     {
299       const char *rdir;
300       char path[MAX_PATH];
301
302       /* Make sure that w32_rootdir has been called so that we are
303          able to check the portable application flag.  The common dir
304          is identical to the rootdir.  In that case there is also no
305          need to strdup its value.  */
306       rdir = w32_rootdir ();
307       if (w32_portable_app)
308         return rdir;
309
310       if (w32_shgetfolderpath (NULL, CSIDL_COMMON_APPDATA,
311                                NULL, 0, path) >= 0)
312         {
313           char *tmp = xmalloc (strlen (path) + 4 +1);
314           strcpy (stpcpy (tmp, path), "\\GNU");
315           dir = tmp;
316           /* No auto create of the directory.  Either the installer or
317              the admin has to create these directories.  */
318         }
319       else
320         {
321           /* Ooops: Not defined - probably an old Windows version.
322              Use the installation directory instead.  */
323           dir = xstrdup (rdir);
324         }
325     }
326
327   return dir;
328 }
329 #endif /*HAVE_W32_SYSTEM*/
330
331
332 /* Return the name of the sysconfdir.  This is a static string.  This
333    function is required because under Windows we can't simply compile
334    it in.  */
335 const char *
336 gnupg_sysconfdir (void)
337 {
338 #ifdef HAVE_W32_SYSTEM
339   static char *name;
340
341   if (!name)
342     {
343       const char *s1, *s2;
344       s1 = w32_commondir ();
345       s2 = DIRSEP_S "etc" DIRSEP_S "gnupg";
346       name = xmalloc (strlen (s1) + strlen (s2) + 1);
347       strcpy (stpcpy (name, s1), s2);
348     }
349   return name;
350 #else /*!HAVE_W32_SYSTEM*/
351   return GNUPG_SYSCONFDIR;
352 #endif /*!HAVE_W32_SYSTEM*/
353 }
354
355
356 const char *
357 gnupg_bindir (void)
358 {
359 #ifdef HAVE_W32_SYSTEM
360   const char *rdir;
361
362   rdir = w32_rootdir ();
363   if (w32_bin_is_bin)
364     {
365       static char *name;
366
367       if (!name)
368         name = xstrconcat (rdir, DIRSEP_S "bin", NULL);
369       return name;
370     }
371   else
372     return rdir;
373 #else /*!HAVE_W32_SYSTEM*/
374   return GNUPG_BINDIR;
375 #endif /*!HAVE_W32_SYSTEM*/
376 }
377
378
379 /* Return the name of the libexec directory.  The name is allocated in
380    a static area on the first use.  This function won't fail. */
381 const char *
382 gnupg_libexecdir (void)
383 {
384 #ifdef HAVE_W32_SYSTEM
385   return gnupg_bindir ();
386 #else /*!HAVE_W32_SYSTEM*/
387   return GNUPG_LIBEXECDIR;
388 #endif /*!HAVE_W32_SYSTEM*/
389 }
390
391 const char *
392 gnupg_libdir (void)
393 {
394 #ifdef HAVE_W32_SYSTEM
395   static char *name;
396
397   if (!name)
398     {
399       const char *s1, *s2;
400       s1 = w32_rootdir ();
401       s2 = DIRSEP_S "lib" DIRSEP_S "gnupg";
402       name = xmalloc (strlen (s1) + strlen (s2) + 1);
403       strcpy (stpcpy (name, s1), s2);
404     }
405   return name;
406 #else /*!HAVE_W32_SYSTEM*/
407   return GNUPG_LIBDIR;
408 #endif /*!HAVE_W32_SYSTEM*/
409 }
410
411 const char *
412 gnupg_datadir (void)
413 {
414 #ifdef HAVE_W32_SYSTEM
415   static char *name;
416
417   if (!name)
418     {
419       const char *s1, *s2;
420       s1 = w32_rootdir ();
421       s2 = DIRSEP_S "share" DIRSEP_S "gnupg";
422       name = xmalloc (strlen (s1) + strlen (s2) + 1);
423       strcpy (stpcpy (name, s1), s2);
424     }
425   return name;
426 #else /*!HAVE_W32_SYSTEM*/
427   return GNUPG_DATADIR;
428 #endif /*!HAVE_W32_SYSTEM*/
429 }
430
431
432 const char *
433 gnupg_localedir (void)
434 {
435 #ifdef HAVE_W32_SYSTEM
436   static char *name;
437
438   if (!name)
439     {
440       const char *s1, *s2;
441       s1 = w32_rootdir ();
442       s2 = DIRSEP_S "share" DIRSEP_S "locale";
443       name = xmalloc (strlen (s1) + strlen (s2) + 1);
444       strcpy (stpcpy (name, s1), s2);
445     }
446   return name;
447 #else /*!HAVE_W32_SYSTEM*/
448   return LOCALEDIR;
449 #endif /*!HAVE_W32_SYSTEM*/
450 }
451
452
453 /* Return the default socket name used by DirMngr. */
454 const char *
455 dirmngr_socket_name (void)
456 {
457 #ifdef HAVE_W32_SYSTEM
458   static char *name;
459
460   if (!name)
461     {
462       char s1[MAX_PATH];
463       const char *s2;
464
465       /* We need something akin CSIDL_COMMON_PROGRAMS, but local
466          (non-roaming).  */
467       if (w32_shgetfolderpath (NULL, CSIDL_WINDOWS, NULL, 0, s1) < 0)
468         strcpy (s1, "C:\\WINDOWS");
469       s2 = DIRSEP_S "S.dirmngr";
470       name = xmalloc (strlen (s1) + strlen (s2) + 1);
471       strcpy (stpcpy (name, s1), s2);
472     }
473   return name;
474 #else /*!HAVE_W32_SYSTEM*/
475   return "/var/run/dirmngr/socket";
476 #endif /*!HAVE_W32_SYSTEM*/
477 }
478
479
480
481 /* Return the file name of a helper tool.  WHICH is one of the
482    GNUPG_MODULE_NAME_foo constants.  */
483 const char *
484 gnupg_module_name (int which)
485 {
486   const char *s, *s2;
487
488 #define X(a,b) do {                                          \
489         static char *name;                                   \
490         if (!name)                                           \
491           {                                                  \
492             s = gnupg_ ## a ();                              \
493             s2 = DIRSEP_S b EXEEXT_S;                        \
494             name = xmalloc (strlen (s) + strlen (s2) + 1);   \
495             strcpy (stpcpy (name, s), s2);                   \
496           }                                                  \
497         return name;                                         \
498       } while (0)
499
500   switch (which)
501     {
502     case GNUPG_MODULE_NAME_AGENT:
503 #ifdef GNUPG_DEFAULT_AGENT
504       return GNUPG_DEFAULT_AGENT;
505 #else
506       X(bindir, "gpg-agent");
507 #endif
508
509     case GNUPG_MODULE_NAME_PINENTRY:
510 #ifdef GNUPG_DEFAULT_PINENTRY
511       return GNUPG_DEFAULT_PINENTRY;
512 #else
513       X(bindir, "pinentry");
514 #endif
515
516     case GNUPG_MODULE_NAME_SCDAEMON:
517 #ifdef GNUPG_DEFAULT_SCDAEMON
518       return GNUPG_DEFAULT_SCDAEMON;
519 #else
520       X(libexecdir, "scdaemon");
521 #endif
522
523     case GNUPG_MODULE_NAME_DIRMNGR:
524 #ifdef GNUPG_DEFAULT_DIRMNGR
525       return GNUPG_DEFAULT_DIRMNGR;
526 #else
527       X(bindir, "dirmngr");
528 #endif
529
530     case GNUPG_MODULE_NAME_PROTECT_TOOL:
531 #ifdef GNUPG_DEFAULT_PROTECT_TOOL
532       return GNUPG_DEFAULT_PROTECT_TOOL;
533 #else
534       X(libexecdir, "gpg-protect-tool");
535 #endif
536
537     case GNUPG_MODULE_NAME_CHECK_PATTERN:
538       X(libexecdir, "gpg-check-pattern");
539
540     case GNUPG_MODULE_NAME_GPGSM:
541       X(bindir, "gpgsm");
542
543     case GNUPG_MODULE_NAME_GPG:
544       X(bindir, "gpg2");
545
546     case GNUPG_MODULE_NAME_CONNECT_AGENT:
547       X(bindir, "gpg-connect-agent");
548
549     case GNUPG_MODULE_NAME_GPGCONF:
550       X(bindir, "gpgconf");
551
552     default:
553       BUG ();
554     }
555 #undef X
556 }