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