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, 2016 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 <https://www.gnu.org/licenses/>.
  29  */
  30
  31 #include <config.h>
  32 #include <stdlib.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36
  37 #ifdef HAVE_W32_SYSTEM
  38 #include <winsock2.h>   /* Due to the stupid mingw64 requirement to
  39                            include this header before windows.h which
  40                            is often implicitly included.  */
  41 #include <shlobj.h>
  42 #ifndef CSIDL_APPDATA
  43 #define CSIDL_APPDATA 0x001a
  44 #endif
  45 #ifndef CSIDL_LOCAL_APPDATA
  46 #define CSIDL_LOCAL_APPDATA 0x001c
  47 #endif
  48 #ifndef CSIDL_COMMON_APPDATA
  49 #define CSIDL_COMMON_APPDATA 0x0023
  50 #endif
  51 #ifndef CSIDL_FLAG_CREATE
  52 #define CSIDL_FLAG_CREATE 0x8000
  53 #endif
  54 #endif /*HAVE_W32_SYSTEM*/
  55
  56 #ifdef HAVE_STAT
  57 #include <sys/stat.h> /* for stat() */
  58 #endif
  59
  60
  61
  62 #include "util.h"
  63 #include "sysutils.h"
  64 #include "zb32.h"
  65
  66 /* The GnuPG homedir.  This is only accessed by the functions
  67  * gnupg_homedir and gnupg_set_homedir.  Malloced.  */
  68 static char *the_gnupg_homedir;
  69
  70 /* Flag indicating that home directory is not the default one.  */
  71 static byte non_default_homedir;
  72
  73
  74 #ifdef HAVE_W32_SYSTEM
  75 /* A flag used to indicate that a control file for gpgconf has been
  76    detected.  Under Windows the presence of this file indicates a
  77    portable installations and triggers several changes:
  78
  79    - The GNUGHOME directory is fixed relative to installation
  80      directory.  All other means to set the home directory are ignore.
  81
  82    - All registry variables will be ignored.
  83
  84    This flag is not used on Unix systems.
  85  */
  86 static byte w32_portable_app;
  87 #endif /*HAVE_W32_SYSTEM*/
  88
  89 #ifdef HAVE_W32_SYSTEM
  90 /* This flag is true if this process' binary has been installed under
  91    bin and not in the root directory as often used before GnuPG 2.1. */
  92 static byte w32_bin_is_bin;
  93 #endif /*HAVE_W32_SYSTEM*/
  94
  95
  96 #ifdef HAVE_W32_SYSTEM
  97 static const char *w32_rootdir (void);
  98 #endif
  99
 100
 101
 102 #ifdef HAVE_W32_SYSTEM
 103 static void
 104 w32_try_mkdir (const char *dir)
 105 {
 106 #ifdef HAVE_W32CE_SYSTEM
 107   wchar_t *wdir = utf8_to_wchar (dir);
 108   if (wdir)
 109     {
 110       CreateDirectory (wdir, NULL);
 111       xfree (wdir);
 112     }
 113 #else
 114   CreateDirectory (dir, NULL);
 115 #endif
 116 }
 117 #endif
 118
 119
 120 /* This is a helper function to load a Windows function from either of
 121    one DLLs. */
 122 #ifdef HAVE_W32_SYSTEM
 123 static HRESULT
 124 w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
 125 {
 126   static int initialized;
 127   static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
 128
 129   if (!initialized)
 130     {
 131       static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
 132       void *handle;
 133       int i;
 134
 135       initialized = 1;
 136
 137       for (i=0, handle = NULL; !handle && dllnames[i]; i++)
 138         {
 139           handle = dlopen (dllnames[i], RTLD_LAZY);
 140           if (handle)
 141             {
 142               func = dlsym (handle, "SHGetFolderPathA");
 143               if (!func)
 144                 {
 145                   dlclose (handle);
 146                   handle = NULL;
 147                 }
 148             }
 149         }
 150     }
 151
 152   if (func)
 153     return func (a,b,c,d,e);
 154   else
 155     return -1;
 156 }
 157 #endif /*HAVE_W32_SYSTEM*/
 158
 159
 160 /* Check whether DIR is the default homedir.  */
 161 static int
 162 is_gnupg_default_homedir (const char *dir)
 163 {
 164   int result;
 165   char *a = make_absfilename (dir, NULL);
 166   char *b = make_absfilename (GNUPG_DEFAULT_HOMEDIR, NULL);
 167   result = !compare_filenames (a, b);
 168   xfree (b);
 169   xfree (a);
 170   return result;
 171 }
 172
 173
 174 /* Get the standard home directory.  In general this function should
 175    not be used as it does not consider a registry value (under W32) or
 176    the GNUPGHOME environment variable.  It is better to use
 177    default_homedir(). */
 178 const char *
 179 standard_homedir (void)
 180 {
 181 #ifdef HAVE_W32_SYSTEM
 182   static const char *dir;
 183
 184   if (!dir)
 185     {
 186       const char *rdir;
 187
 188       rdir = w32_rootdir ();
 189       if (w32_portable_app)
 190         {
 191           dir = xstrconcat (rdir, DIRSEP_S "home", NULL);
 192         }
 193       else
 194         {
 195           char path[MAX_PATH];
 196
 197           /* It might be better to use LOCAL_APPDATA because this is
 198              defined as "non roaming" and thus more likely to be kept
 199              locally.  For private keys this is desired.  However,
 200              given that many users copy private keys anyway forth and
 201              back, using a system roaming services might be better
 202              than to let them do it manually.  A security conscious
 203              user will anyway use the registry entry to have better
 204              control.  */
 205           if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE,
 206                                    NULL, 0, path) >= 0)
 207             {
 208               char *tmp = xmalloc (strlen (path) + 6 +1);
 209               strcpy (stpcpy (tmp, path), "\\gnupg");
 210               dir = tmp;
 211
 212               /* Try to create the directory if it does not yet exists.  */
 213               if (access (dir, F_OK))
 214                 w32_try_mkdir (dir);
 215             }
 216           else
 217             dir = GNUPG_DEFAULT_HOMEDIR;
 218         }
 219     }
 220   return dir;
 221 #else/*!HAVE_W32_SYSTEM*/
 222   return GNUPG_DEFAULT_HOMEDIR;
 223 #endif /*!HAVE_W32_SYSTEM*/
 224 }
 225
 226 /* Set up the default home directory.  The usual --homedir option
 227    should be parsed later. */
 228 const char *
 229 default_homedir (void)
 230 {
 231   const char *dir;
 232
 233 #ifdef HAVE_W32_SYSTEM
 234   /* For a portable application we only use the standard homedir.  */
 235   w32_rootdir ();
 236   if (w32_portable_app)
 237     return standard_homedir ();
 238 #endif /*HAVE_W32_SYSTEM*/
 239
 240   dir = getenv ("GNUPGHOME");
 241 #ifdef HAVE_W32_SYSTEM
 242   if (!dir || !*dir)
 243     {
 244       static const char *saved_dir;
 245
 246       if (!saved_dir)
 247         {
 248           if (!dir || !*dir)
 249             {
 250               char *tmp;
 251
 252               tmp = read_w32_registry_string (NULL,
 253                                               GNUPG_REGISTRY_DIR,
 254                                               "HomeDir");
 255               if (tmp && !*tmp)
 256                 {
 257                   xfree (tmp);
 258                   tmp = NULL;
 259                 }
 260               if (tmp)
 261                 saved_dir = tmp;
 262             }
 263
 264           if (!saved_dir)
 265             saved_dir = standard_homedir ();
 266         }
 267       dir = saved_dir;
 268     }
 269 #endif /*HAVE_W32_SYSTEM*/
 270   if (!dir || !*dir)
 271     dir = GNUPG_DEFAULT_HOMEDIR;
 272   else if (!is_gnupg_default_homedir (dir))
 273     non_default_homedir = 1;
 274
 275   return dir;
 276 }
 277
 278
 279 #ifdef HAVE_W32_SYSTEM
 280 /* Check whether gpgconf is installed and if so read the gpgconf.ctl
 281    file. */
 282 static void
 283 check_portable_app (const char *dir)
 284 {
 285   char *fname;
 286
 287   fname = xstrconcat (dir, DIRSEP_S "gpgconf.exe", NULL);
 288   if (!access (fname, F_OK))
 289     {
 290       strcpy (fname + strlen (fname) - 3, "ctl");
 291       if (!access (fname, F_OK))
 292         {
 293           /* gpgconf.ctl file found.  Record this fact.  */
 294           w32_portable_app = 1;
 295           {
 296             unsigned int flags;
 297             log_get_prefix (&flags);
 298             log_set_prefix (NULL, (flags | GPGRT_LOG_NO_REGISTRY));
 299           }
 300           /* FIXME: We should read the file to detect special flags
 301              and print a warning if we don't understand them  */
 302         }
 303     }
 304   xfree (fname);
 305 }
 306
 307
 308 /* Determine the root directory of the gnupg installation on Windows.  */
 309 static const char *
 310 w32_rootdir (void)
 311 {
 312   static int got_dir;
 313   static char dir[MAX_PATH+5];
 314
 315   if (!got_dir)
 316     {
 317       char *p;
 318       int rc;
 319       wchar_t wdir [MAX_PATH+5];
 320
 321       rc = GetModuleFileNameW (NULL, wdir, MAX_PATH);
 322       if (rc && WideCharToMultiByte (CP_UTF8, 0, wdir, -1, dir, MAX_PATH-4,
 323                                      NULL, NULL) < 0)
 324         rc = 0;
 325       if (!rc)
 326         {
 327           log_debug ("GetModuleFileName failed: %s\n", w32_strerror (-1));
 328           *dir = 0;
 329         }
 330       got_dir = 1;
 331       p = strrchr (dir, DIRSEP_C);
 332       if (p)
 333         {
 334           *p = 0;
 335
 336           check_portable_app (dir);
 337
 338           /* If we are installed below "bin" we strip that and use
 339              the top directory instead.  */
 340           p = strrchr (dir, DIRSEP_C);
 341           if (p && !strcmp (p+1, "bin"))
 342             {
 343               *p = 0;
 344               w32_bin_is_bin = 1;
 345             }
 346         }
 347       if (!p)
 348         {
 349           log_debug ("bad filename '%s' returned for this process\n", dir);
 350           *dir = 0;
 351         }
 352     }
 353
 354   if (*dir)
 355     return dir;
 356   /* Fallback to the hardwired value. */
 357   return GNUPG_LIBEXECDIR;
 358 }
 359
 360 static const char *
 361 w32_commondir (void)
 362 {
 363   static char *dir;
 364
 365   if (!dir)
 366     {
 367       const char *rdir;
 368       char path[MAX_PATH];
 369
 370       /* Make sure that w32_rootdir has been called so that we are
 371          able to check the portable application flag.  The common dir
 372          is the identical to the rootdir.  In that case there is also
 373          no need to strdup its value.  */
 374       rdir = w32_rootdir ();
 375       if (w32_portable_app)
 376         return rdir;
 377
 378       if (w32_shgetfolderpath (NULL, CSIDL_COMMON_APPDATA,
 379                                NULL, 0, path) >= 0)
 380         {
 381           char *tmp = xmalloc (strlen (path) + 4 +1);
 382           strcpy (stpcpy (tmp, path), "\\GNU");
 383           dir = tmp;
 384           /* No auto create of the directory.  Either the installer or
 385              the admin has to create these directories.  */
 386         }
 387       else
 388         {
 389           /* Ooops: Not defined - probably an old Windows version.
 390              Use the installation directory instead.  */
 391           dir = xstrdup (rdir);
 392         }
 393     }
 394
 395   return dir;
 396 }
 397 #endif /*HAVE_W32_SYSTEM*/
 398
 399
 400 /* Change the homedir.  Some care must be taken to set this early
 401  * enough because previous calls to gnupg_homedir may else return a
 402  * different string.  */
 403 void
 404 gnupg_set_homedir (const char *newdir)
 405 {
 406   if (!newdir || !*newdir)
 407     newdir = default_homedir ();
 408   else if (!is_gnupg_default_homedir (newdir))
 409     non_default_homedir = 1;
 410   xfree (the_gnupg_homedir);
 411   the_gnupg_homedir = make_absfilename (newdir, NULL);;
 412 }
 413
 414
 415 /* Return the homedir.  The returned string is valid until another
 416  * gnupg-set-homedir call.  This is always an absolute directory name.
 417  * The function replaces the former global var opt.homedir.  */
 418 const char *
 419 gnupg_homedir (void)
 420 {
 421   /* If a homedir has not been set, set it to the default.  */
 422   if (!the_gnupg_homedir)
 423     the_gnupg_homedir = make_absfilename (default_homedir (), NULL);
 424   return the_gnupg_homedir;
 425 }
 426
 427
 428 /* Return whether the home dir is the default one.  */
 429 int
 430 gnupg_default_homedir_p (void)
 431 {
 432   return !non_default_homedir;
 433 }
 434
 435
 436 /* Helper for gnupg-socketdir.  This is a global function, so that
 437  * gpgconf can use it for its --create-socketdir command.  If
 438  * SKIP_CHECKS is set permission checks etc. are not done.  The
 439  * function always returns a malloced directory name and stores these
 440  * bit flags at R_INFO:
 441  *
 442  *   1 := Internal error, stat failed, out of core, etc.
 443  *   2 := No /run/user directory.
 444  *   4 := Directory not owned by the user, not a directory
 445  *        or wrong permissions.
 446  *   8 := Same as 4 but for the subdir.
 447  *  16 := mkdir failed
 448  *  32 := Non default homedir; checking subdir.
 449  *  64 := Subdir does not exist.
 450  * 128 := Using homedir as fallback.
 451  */
 452 char *
 453 _gnupg_socketdir_internal (int skip_checks, unsigned *r_info)
 454 {
 455 #if defined(HAVE_W32_SYSTEM) || !defined(HAVE_STAT)
 456
 457   char *name;
 458
 459   (void)skip_checks;
 460   *r_info = 0;
 461   name = xstrdup (gnupg_homedir ());
 462
 463 #else /* Unix and stat(2) available. */
 464
 465   static const char * const bases[] = { "/run", "/var/run", NULL};
 466   int i;
 467   struct stat sb;
 468   char prefix[13 + 1 + 20 + 6 + 1];
 469   const char *s;
 470   char *name = NULL;
 471
 472   *r_info = 0;
 473
 474   /* First make sure that non_default_homedir can be set.  */
 475   gnupg_homedir ();
 476
 477   /* It has been suggested to first check XDG_RUNTIME_DIR envvar.
 478    * However, the specs state that the lifetime of the directory MUST
 479    * be bound to the user being logged in.  Now GnuPG may also be run
 480    * as a background process with no (desktop) user logged in.  Thus
 481    * we better don't do that.  */
 482
 483   /* Check whether we have a /run/user dir.  */
 484   for (i=0; bases[i]; i++)
 485     {
 486       snprintf (prefix, sizeof prefix, "%s/user/%u",
 487                 bases[i], (unsigned int)getuid ());
 488       if (!stat (prefix, &sb) && S_ISDIR(sb.st_mode))
 489         break;
 490     }
 491   if (!bases[i])
 492     {
 493       *r_info |= 2; /* No /run/user directory.  */
 494       goto leave;
 495     }
 496
 497   if (sb.st_uid != getuid ())
 498     {
 499       *r_info |= 4; /* Not owned by the user.  */
 500       if (!skip_checks)
 501         goto leave;
 502     }
 503
 504   if (strlen (prefix) + 7 >= sizeof prefix)
 505     {
 506       *r_info |= 1; /* Ooops: Buffer too short to append "/gnupg".  */
 507       goto leave;
 508     }
 509   strcat (prefix, "/gnupg");
 510
 511   /* Check whether the gnupg sub directory has proper permissions.  */
 512   if (stat (prefix, &sb))
 513     {
 514       if (errno != ENOENT)
 515         {
 516           *r_info |= 1; /* stat failed.  */
 517           goto leave;
 518         }
 519
 520       /* Try to create the directory and check again.  */
 521       if (gnupg_mkdir (prefix, "-rwx"))
 522         {
 523           *r_info |= 16; /* mkdir failed.  */
 524           goto leave;
 525         }
 526       if (stat (prefix, &sb))
 527         {
 528           *r_info |= 1; /* stat failed.  */
 529           goto leave;
 530         }
 531     }
 532   /* Check that it is a directory, owned by the user, and only the
 533    * user has permissions to use it.  */
 534   if (!S_ISDIR(sb.st_mode)
 535       || sb.st_uid != getuid ()
 536       || (sb.st_mode & (S_IRWXG|S_IRWXO)))
 537     {
 538       *r_info |= 4; /* Bad permissions or not a directory. */
 539       if (!skip_checks)
 540         goto leave;
 541     }
 542
 543   /* If a non default homedir is used, we check whether an
 544    * corresponding sub directory below the socket dir is available
 545    * and use that.  We hash the non default homedir to keep the new
 546    * subdir short enough.  */
 547   if (non_default_homedir)
 548     {
 549       char sha1buf[20];
 550       char *suffix;
 551
 552       *r_info |= 32; /* Testing subdir.  */
 553       s = gnupg_homedir ();
 554       gcry_md_hash_buffer (GCRY_MD_SHA1, sha1buf, s, strlen (s));
 555       suffix = zb32_encode (sha1buf, 8*15);
 556       if (!suffix)
 557         {
 558           *r_info |= 1; /* Out of core etc. */
 559           goto leave;
 560         }
 561       name = strconcat (prefix, "/d.", suffix, NULL);
 562       xfree (suffix);
 563       if (!name)
 564         {
 565           *r_info |= 1; /* Out of core etc. */
 566           goto leave;
 567         }
 568
 569       /* Stat that directory and check constraints.
 570        * The command
 571        *    gpgconf --remove-socketdir
 572        * can be used to remove that directory.  */
 573       if (stat (name, &sb))
 574         {
 575           if (errno != ENOENT)
 576             *r_info |= 1; /* stat failed. */
 577           else if (!skip_checks)
 578             {
 579               /* Try to create the directory and check again.  */
 580               if (gnupg_mkdir (name, "-rwx"))
 581                 *r_info |= 16; /* mkdir failed.  */
 582               else if (stat (prefix, &sb))
 583                 {
 584                   if (errno != ENOENT)
 585                     *r_info |= 1; /* stat failed. */
 586                   else
 587                     *r_info |= 64; /* Subdir does not exist.  */
 588                 }
 589               else
 590                 goto leave; /* Success!  */
 591             }
 592           else
 593             *r_info |= 64; /* Subdir does not exist.  */
 594           if (!skip_checks)
 595             {
 596               xfree (name);
 597               name = NULL;
 598               goto leave;
 599             }
 600         }
 601       else if (!S_ISDIR(sb.st_mode)
 602                || sb.st_uid != getuid ()
 603                || (sb.st_mode & (S_IRWXG|S_IRWXO)))
 604         {
 605           *r_info |= 8; /* Bad permissions or subdir is not a directory.  */
 606           if (!skip_checks)
 607             {
 608               xfree (name);
 609               name = NULL;
 610               goto leave;
 611             }
 612         }
 613     }
 614   else
 615     name = xstrdup (prefix);
 616
 617  leave:
 618   /* If nothing works fall back to the homedir.  */
 619   if (!name)
 620     {
 621       *r_info |= 128; /* Fallback.  */
 622       name = xstrdup (gnupg_homedir ());
 623     }
 624
 625 #endif /* Unix */
 626
 627   return name;
 628 }
 629
 630
 631 /*
 632  * Return the name of the socket dir.  That is the directory used for
 633  * the IPC local sockets.  This is an absolute directory name.
 634  */
 635 const char *
 636 gnupg_socketdir (void)
 637 {
 638   static char *name;
 639
 640   if (!name)
 641     {
 642       unsigned int dummy;
 643       name = _gnupg_socketdir_internal (0, &dummy);
 644     }
 645
 646   return name;
 647 }
 648
 649
 650 /* Return the name of the sysconfdir.  This is a static string.  This
 651    function is required because under Windows we can't simply compile
 652    it in.  */
 653 const char *
 654 gnupg_sysconfdir (void)
 655 {
 656 #ifdef HAVE_W32_SYSTEM
 657   static char *name;
 658
 659   if (!name)
 660     {
 661       const char *s1, *s2;
 662       s1 = w32_commondir ();
 663       s2 = DIRSEP_S "etc" DIRSEP_S "gnupg";
 664       name = xmalloc (strlen (s1) + strlen (s2) + 1);
 665       strcpy (stpcpy (name, s1), s2);
 666     }
 667   return name;
 668 #else /*!HAVE_W32_SYSTEM*/
 669   return GNUPG_SYSCONFDIR;
 670 #endif /*!HAVE_W32_SYSTEM*/
 671 }
 672
 673
 674 const char *
 675 gnupg_bindir (void)
 676 {
 677 #if defined (HAVE_W32CE_SYSTEM)
 678   static char *name;
 679
 680   if (!name)
 681     name = xstrconcat (w32_rootdir (), DIRSEP_S "bin", NULL);
 682   return name;
 683 #elif defined(HAVE_W32_SYSTEM)
 684   const char *rdir;
 685
 686   rdir = w32_rootdir ();
 687   if (w32_bin_is_bin)
 688     {
 689       static char *name;
 690
 691       if (!name)
 692         name = xstrconcat (rdir, DIRSEP_S "bin", NULL);
 693       return name;
 694     }
 695   else
 696     return rdir;
 697 #else /*!HAVE_W32_SYSTEM*/
 698   return GNUPG_BINDIR;
 699 #endif /*!HAVE_W32_SYSTEM*/
 700 }
 701
 702
 703 /* Return the name of the libexec directory.  The name is allocated in
 704    a static area on the first use.  This function won't fail. */
 705 const char *
 706 gnupg_libexecdir (void)
 707 {
 708 #ifdef HAVE_W32_SYSTEM
 709   return gnupg_bindir ();
 710 #else /*!HAVE_W32_SYSTEM*/
 711   return GNUPG_LIBEXECDIR;
 712 #endif /*!HAVE_W32_SYSTEM*/
 713 }
 714
 715 const char *
 716 gnupg_libdir (void)
 717 {
 718 #ifdef HAVE_W32_SYSTEM
 719   static char *name;
 720
 721   if (!name)
 722     name = xstrconcat (w32_rootdir (), DIRSEP_S "lib" DIRSEP_S "gnupg", NULL);
 723   return name;
 724 #else /*!HAVE_W32_SYSTEM*/
 725   return GNUPG_LIBDIR;
 726 #endif /*!HAVE_W32_SYSTEM*/
 727 }
 728
 729 const char *
 730 gnupg_datadir (void)
 731 {
 732 #ifdef HAVE_W32_SYSTEM
 733   static char *name;
 734
 735   if (!name)
 736     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "gnupg", NULL);
 737   return name;
 738 #else /*!HAVE_W32_SYSTEM*/
 739   return GNUPG_DATADIR;
 740 #endif /*!HAVE_W32_SYSTEM*/
 741 }
 742
 743
 744 const char *
 745 gnupg_localedir (void)
 746 {
 747 #ifdef HAVE_W32_SYSTEM
 748   static char *name;
 749
 750   if (!name)
 751     name = xstrconcat (w32_rootdir (), DIRSEP_S "share" DIRSEP_S "locale",
 752                        NULL);
 753   return name;
 754 #else /*!HAVE_W32_SYSTEM*/
 755   return LOCALEDIR;
 756 #endif /*!HAVE_W32_SYSTEM*/
 757 }
 758
 759
 760 /* Return the name of the cache directory.  The name is allocated in a
 761    static area on the first use.  Windows only: If the directory does
 762    not exist it is created.  */
 763 const char *
 764 gnupg_cachedir (void)
 765 {
 766 #ifdef HAVE_W32_SYSTEM
 767   static const char *dir;
 768
 769   if (!dir)
 770     {
 771       const char *rdir;
 772
 773       rdir = w32_rootdir ();
 774       if (w32_portable_app)
 775         {
 776           dir = xstrconcat (rdir,
 777                             DIRSEP_S, "var",
 778                             DIRSEP_S, "cache",
 779                             DIRSEP_S, "gnupg", NULL);
 780         }
 781       else
 782         {
 783           char path[MAX_PATH];
 784           const char *s1[] = { "GNU", "cache", "gnupg", NULL };
 785           int s1_len;
 786           const char **comp;
 787
 788           s1_len = 0;
 789           for (comp = s1; *comp; comp++)
 790             s1_len += 1 + strlen (*comp);
 791
 792           if (w32_shgetfolderpath (NULL, CSIDL_LOCAL_APPDATA|CSIDL_FLAG_CREATE,
 793                                    NULL, 0, path) >= 0)
 794             {
 795               char *tmp = xmalloc (strlen (path) + s1_len + 1);
 796               char *p;
 797
 798               p = stpcpy (tmp, path);
 799               for (comp = s1; *comp; comp++)
 800                 {
 801                   p = stpcpy (p, "\\");
 802                   p = stpcpy (p, *comp);
 803
 804                   if (access (tmp, F_OK))
 805                     w32_try_mkdir (tmp);
 806                 }
 807
 808               dir = tmp;
 809             }
 810           else
 811             {
 812               dir = "c:\\temp\\cache\\gnupg";
 813 #ifdef HAVE_W32CE_SYSTEM
 814               dir += 2;
 815               w32_try_mkdir ("\\temp\\cache");
 816               w32_try_mkdir ("\\temp\\cache\\gnupg");
 817 #endif
 818             }
 819         }
 820     }
 821   return dir;
 822 #else /*!HAVE_W32_SYSTEM*/
 823   return GNUPG_LOCALSTATEDIR "/cache/" PACKAGE_NAME;
 824 #endif /*!HAVE_W32_SYSTEM*/
 825 }
 826
 827
 828 /* Return the user socket name used by DirMngr.  */
 829 const char *
 830 dirmngr_socket_name (void)
 831 {
 832   static char *name;
 833
 834   if (!name)
 835     name = make_filename (gnupg_socketdir (), DIRMNGR_SOCK_NAME, NULL);
 836   return name;
 837 }
 838
 839
 840 /* Return the default pinentry name.  If RESET is true the internal
 841    cache is first flushed.  */
 842 static const char *
 843 get_default_pinentry_name (int reset)
 844 {
 845   static struct {
 846     const char *(*rfnc)(void);
 847     const char *name;
 848   } names[] = {
 849     /* The first entry is what we return in case we found no
 850        other pinentry.  */
 851     { gnupg_bindir, DIRSEP_S "pinentry" EXEEXT_S },
 852 #ifdef HAVE_W32_SYSTEM
 853     /* Try Gpg4win directory (with bin and without.) */
 854     { w32_rootdir, "\\..\\Gpg4win\\bin\\pinentry.exe" },
 855     { w32_rootdir, "\\..\\Gpg4win\\pinentry.exe" },
 856     /* Try old Gpgwin directory.  */
 857     { w32_rootdir, "\\..\\GNU\\GnuPG\\pinentry.exe" },
 858     /* Try a Pinentry from the common GNU dir.  */
 859     { w32_rootdir, "\\..\\GNU\\bin\\pinentry.exe" },
 860 #endif
 861     /* Last chance is a pinentry-basic (which comes with the
 862        GnuPG 2.1 Windows installer).  */
 863     { gnupg_bindir, DIRSEP_S "pinentry-basic" EXEEXT_S }
 864   };
 865   static char *name;
 866
 867   if (reset)
 868     {
 869       xfree (name);
 870       name = NULL;
 871     }
 872
 873   if (!name)
 874     {
 875       int i;
 876
 877       for (i=0; i < DIM(names); i++)
 878         {
 879           char *name2;
 880
 881           name2 = xstrconcat (names[i].rfnc (), names[i].name, NULL);
 882           if (!access (name2, F_OK))
 883             {
 884               /* Use that pinentry.  */
 885               xfree (name);
 886               name = name2;
 887               break;
 888             }
 889           if (!i) /* Store the first as fallback return.  */
 890             name = name2;
 891           else
 892             xfree (name2);
 893         }
 894     }
 895
 896   return name;
 897 }
 898
 899
 900 /* If set, 'gnupg_module_name' returns modules from that build
 901  * directory.  */
 902 static char *gnupg_build_directory;
 903
 904 /* For sanity checks.  */
 905 static int gnupg_module_name_called;
 906
 907
 908 /* Set NEWDIR as the new build directory.  This will make
 909  * 'gnupg_module_name' return modules from that build directory.  Must
 910  * be called before any invocation of 'gnupg_module_name', and must
 911  * not be called twice.  It can be used by test suites to make sure
 912  * the components from the build directory are used instead of
 913  * potentially outdated installed ones.  */
 914 void
 915 gnupg_set_builddir (const char *newdir)
 916 {
 917   log_assert (! gnupg_module_name_called);
 918   log_assert (! gnupg_build_directory);
 919   gnupg_build_directory = xtrystrdup (newdir);
 920 }
 921
 922
 923 /* If no build directory has been configured, try to set it from the
 924  * environment.  We only do this in development builds to avoid
 925  * increasing the set of influential environment variables and hence
 926  * the attack surface of production builds.  */
 927 static void
 928 gnupg_set_builddir_from_env (void)
 929 {
 930 #ifdef IS_DEVELOPMENT_VERSION
 931   if (gnupg_build_directory)
 932     return;
 933
 934   gnupg_build_directory = getenv ("GNUPG_BUILDDIR");
 935 #endif
 936 }
 937
 938
 939 /* Return the file name of a helper tool.  WHICH is one of the
 940    GNUPG_MODULE_NAME_foo constants.  */
 941 const char *
 942 gnupg_module_name (int which)
 943 {
 944   gnupg_set_builddir_from_env ();
 945   gnupg_module_name_called = 1;
 946
 947 #define X(a,b,c) do {                                                   \
 948     static char *name;                                                  \
 949     if (!name)                                                          \
 950       name = gnupg_build_directory                                      \
 951         ? xstrconcat (gnupg_build_directory,                            \
 952                       DIRSEP_S b DIRSEP_S c EXEEXT_S, NULL)             \
 953         : xstrconcat (gnupg_ ## a (), DIRSEP_S c EXEEXT_S, NULL);       \
 954     return name;                                                        \
 955   } while (0)
 956
 957   switch (which)
 958     {
 959     case GNUPG_MODULE_NAME_AGENT:
 960 #ifdef GNUPG_DEFAULT_AGENT
 961       return GNUPG_DEFAULT_AGENT;
 962 #else
 963       X(bindir, "agent", "gpg-agent");
 964 #endif
 965
 966     case GNUPG_MODULE_NAME_PINENTRY:
 967 #ifdef GNUPG_DEFAULT_PINENTRY
 968       return GNUPG_DEFAULT_PINENTRY;  /* (Set by a configure option) */
 969 #else
 970       return get_default_pinentry_name (0);
 971 #endif
 972
 973     case GNUPG_MODULE_NAME_SCDAEMON:
 974 #ifdef GNUPG_DEFAULT_SCDAEMON
 975       return GNUPG_DEFAULT_SCDAEMON;
 976 #else
 977       X(libexecdir, "scd", "scdaemon");
 978 #endif
 979
 980     case GNUPG_MODULE_NAME_DIRMNGR:
 981 #ifdef GNUPG_DEFAULT_DIRMNGR
 982       return GNUPG_DEFAULT_DIRMNGR;
 983 #else
 984       X(bindir, "dirmngr", DIRMNGR_NAME);
 985 #endif
 986
 987     case GNUPG_MODULE_NAME_PROTECT_TOOL:
 988 #ifdef GNUPG_DEFAULT_PROTECT_TOOL
 989       return GNUPG_DEFAULT_PROTECT_TOOL;
 990 #else
 991       X(libexecdir, "agent", "gpg-protect-tool");
 992 #endif
 993
 994     case GNUPG_MODULE_NAME_DIRMNGR_LDAP:
 995 #ifdef GNUPG_DEFAULT_DIRMNGR_LDAP
 996       return GNUPG_DEFAULT_DIRMNGR_LDAP;
 997 #else
 998       X(libexecdir, "dirmngr", "dirmngr_ldap");
 999 #endif
1000
1001     case GNUPG_MODULE_NAME_CHECK_PATTERN:
1002       X(libexecdir, "tools", "gpg-check-pattern");
1003
1004     case GNUPG_MODULE_NAME_GPGSM:
1005       X(bindir, "sm", "gpgsm");
1006
1007     case GNUPG_MODULE_NAME_GPG:
1008 #if USE_GPG2_HACK
1009       if (! gnupg_build_directory)
1010         X(bindir, "g10", GPG_NAME "2");
1011       else
1012 #endif
1013         X(bindir, "g10", GPG_NAME);
1014
1015     case GNUPG_MODULE_NAME_GPGV:
1016 #if USE_GPG2_HACK
1017       if (! gnupg_build_directory)
1018         X(bindir, "g10", GPG_NAME "v2");
1019       else
1020 #endif
1021         X(bindir, "g10", GPG_NAME "v");
1022
1023     case GNUPG_MODULE_NAME_CONNECT_AGENT:
1024       X(bindir, "tools", "gpg-connect-agent");
1025
1026     case GNUPG_MODULE_NAME_GPGCONF:
1027       X(bindir, "tools", "gpgconf");
1028
1029     default:
1030       BUG ();
1031     }
1032 #undef X
1033 }
1034
1035
1036 /* Flush some of the cached module names.  This is for example used by
1037    gpg-agent to allow configuring a different pinentry.  */
1038 void
1039 gnupg_module_name_flush_some (void)
1040 {
1041   (void)get_default_pinentry_name (1);
1042 }