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