diff --git a/lang/cpp/src/global.h b/lang/cpp/src/global.h
index 7d9f9d66..d7430e2b 100644
--- a/lang/cpp/src/global.h
+++ b/lang/cpp/src/global.h
@@ -1,226 +1,226 @@
 /*
   global.h - global gpgme functions and enums
   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_GLOBAL_H__
 #define __GPGMEPP_GLOBAL_H__
 
 #include "gpgmefw.h"
 #include "gpgmepp_export.h"
 
 #include <iosfwd>
 #include <cstring>
 
 namespace GpgME
 {
 class Error;
 class EngineInfo;
 class Context;
 }
 
 struct _GIOChannel;
 typedef struct _GIOChannel      GIOChannel;
 class QIODevice;
 
 namespace GpgME
 {
 
 GPGMEPP_EXPORT void initializeLibrary();
 /*!
   Initializes the library, returns Error::code() ==
   GPG_ERR_USER_1 if underlying gpgme is too old.
 */
 GPGMEPP_EXPORT Error initializeLibrary(int);
 
 enum Protocol { OpenPGP, CMS, UnknownProtocol };
 
 enum Engine { GpgEngine, GpgSMEngine, GpgConfEngine, UnknownEngine, AssuanEngine, G13Engine, SpawnEngine };
 
 enum KeyListMode {
     Local = 0x1,
     Extern = 0x2,
     Locate = 0x3,
     Signatures = 0x4,
     SignatureNotations = 0x8,
     Validate = 0x10,
     Ephemeral = 0x20,
     WithTofu = 0x40,
     WithKeygrip = 0x80,
     WithSecret = 0x100
 };
 
 enum SignatureMode { NormalSignatureMode, Detached, Clearsigned };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Protocol proto);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Engine eng);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, KeyListMode mode);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, SignatureMode mode);
 
 GPGMEPP_EXPORT Error setDefaultLocale(int category, const char *value);
 
 GPGMEPP_EXPORT Context *wait(Error &e, bool hang = true);
 typedef void (*IdleFunction)(void);
 GPGMEPP_EXPORT IdleFunction registerIdleFunction(IdleFunction idleFunction);
 
 typedef void (*IOCallback)(void *data, int fd);
 
 GPGMEPP_EXPORT EngineInfo engineInfo(Protocol proto);
 GPGMEPP_EXPORT EngineInfo engineInfo(Engine engine);
 /** Wrapper around gpgme_get_dirinfo. What can be:
 homedir, sysconfdir, bindir, libexecdir, libdir,
 datadir, localedir, agent-socket, agent-ssh-socket,
 dirmngr-socket, uiserver-socket, gpgconf-name, gpg-name,
-gpgsm-name, g13-name
+gpgsm-name, g13-name, socketdir.
 
 This may be extended in the future.
 */
 GPGMEPP_EXPORT const char *dirInfo(const char *what);
 
 GPGMEPP_EXPORT Error checkEngine(Protocol proto);
 GPGMEPP_EXPORT Error checkEngine(Engine engine);
 
 /* Wrapper for gpgme_set_global_flag */
 GPGMEPP_EXPORT int setGlobalFlag(const char *name, const char *value);
 
 GPGMEPP_EXPORT GIOChannel *getGIOChannel(int fd);
 GPGMEPP_EXPORT QIODevice   *getQIODevice(int fd);
 
 enum Feature {
     ValidatingKeylistModeFeature               = 0x00000001,
     CancelOperationFeature                     = 0x00000002,
     WrongKeyUsageFeature                       = 0x00000004,
     DefaultCertificateInclusionFeature         = 0x00000008,
 
     GetSetEngineInfoFeature                    = 0x00000010,
     EngineInfoHomeDirFeature                   = 0x00000020,
     NoEncryptToEncryptionFlagFeature           = 0x00000040,
     EphemeralKeylistModeFeature                = 0x00000080,
 
     SetDataFileNameFeeature                    = 0x00000100,
     VerificationResultFileNameFeature          = 0x00000200,
     DecryptionResultFileNameFeature            = 0x00000400,
     DecryptionResultRecipientsFeature          = 0x00000800,
 
     AuditLogFeature                            = 0x00001000,
     GpgConfEngineFeature                       = 0x00002000,
     CancelOperationAsyncFeature                = 0x00004000,
     AssuanEngineFeature                        = 0x00008000,
 
     ClearAddGetSignatureNotationsFeature       = 0x00010000,
     SignatureNotationsKeylistModeFeature       = 0x00020000,
     KeySignatureNotationsFeature               = 0x00040000,
     SignatureNotationsFlagsFeature             = 0x00080000,
     SignatureNotationsCriticalFlagFeature      = 0x00100000,
     SignatureNotationsHumanReadableFlagFeature = 0x00200000,
     CardKeyFeature                             = 0x00400000,
     ImportFromKeyserverFeature                 = 0x00800000,
 
     KeyIsQualifiedFeature                      = 0x01000200,
     SubkeyIsQualifiedFeature                   = 0x02000000,
     SignaturePkaFieldsFeature                  = 0x04000000,
     SignatureAlgorithmFieldsFeature            = 0x08000000,
 
     FdPointerFeature                           = 0x10000000,
     G13VFSFeature                              = 0x20000000,
     PasswdFeature                              = 0x40000000, // gpgme >= 1.3.0
     // unusable (max value)
 
     FeatureMaxValue                            = 0x80000000
 };
 enum Feature2 {
     BinaryAndFineGrainedIdentify               = 0x00000001, // gpgme >= 1.7.0
     Feature2MaxValue                           = 0x80000000
 };
 
 // use hasFeature( unsigned long, unsigned long ) instead
 GPGMEPP_DEPRECATED_EXPORT bool hasFeature(unsigned long feature);
 GPGMEPP_EXPORT bool hasFeature(unsigned long feature, unsigned long feature2);
 
 } // namespace GpgME
 
 # ifndef GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION
 #  define GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION( Class ) \
     namespace std { template <> inline void swap< GpgME::Class >( GpgME::Class & lhs, GpgME::Class & rhs ) { lhs.swap( rhs ); } }
 # endif
 
 # ifndef GPGMEPP_MAKE_SAFE_BOOL_OPERATOR
 #  define GPGMEPP_MAKE_SAFE_BOOL_OPERATOR( Cond ) \
     private: \
     struct __safe_bool_dummy__ { void nonnull() {} }; \
     typedef void ( __safe_bool_dummy__::*unspecified_bool_type )(); \
     public: \
     operator unspecified_bool_type() const { return ( Cond ) ? &__safe_bool_dummy__::nonnull : nullptr; }
 # endif
 
 inline int _gpgmepp_strcmp(const char *s1, const char *s2)
 {
     return s1 ? s2 ? std::strcmp(s1, s2) : 1 : s2 ? -1 : 0;
 }
 
 #define _GPGMEPP_MAKE_STRCMP( Name, expr, cmp )                     \
     template <template <typename U> class Op>                           \
     struct Name {                                                       \
         typedef bool result_type;                                       \
         \
         bool operator()( const char * lhs, const char * rhs ) const {   \
             return Op<int>()( cmp, 0 );                                 \
         }                                                               \
         \
         bool operator()( const std::string & lhs, const std::string & rhs ) const { \
             return operator()( lhs.c_str(), rhs.c_str() );              \
         }                                                               \
         bool operator()( const char * lhs, const std::string & rhs ) const { \
             return operator()( lhs, rhs.c_str() );                      \
         }                                                               \
         bool operator()( const std::string & lhs, const char * rhs ) const { \
             return operator()( lhs.c_str(), rhs );                      \
         }                                                               \
         \
         template <typename T>                                           \
         bool operator()( const T & lhs, const T & rhs ) const {         \
             return operator()( (lhs expr), (rhs expr) );                \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const T & lhs, const char * rhs ) const {      \
             return operator()( (lhs expr), rhs );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const char * lhs, const T & rhs ) const {      \
             return operator()( lhs, (rhs expr) );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const T & lhs, const std::string & rhs ) const { \
             return operator()( (lhs expr), rhs );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const std::string & lhs, const T & rhs ) const {    \
             return operator()( lhs, (rhs expr) );                       \
         }                                                               \
     }
 
 #define GPGMEPP_MAKE_STRCMP( Name, expr )                          \
     _GPGMEPP_MAKE_STRCMP( Name, expr, _gpgmepp_strcmp( lhs, rhs ) )
 
 
 #endif // __GPGMEPP_GLOBAL_H__
diff --git a/src/dirinfo.c b/src/dirinfo.c
index c4f0e4a0..c6b7d718 100644
--- a/src/dirinfo.c
+++ b/src/dirinfo.c
@@ -1,481 +1,492 @@
 /* dirinfo.c - Get directory information
  * Copyright (C) 2009, 2013 g10 Code GmbH
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <https://gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #if HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "gpgme.h"
 #include "util.h"
 #include "priv-io.h"
 #include "debug.h"
 #include "sema.h"
 #include "sys-util.h"
 
 DEFINE_STATIC_LOCK (dirinfo_lock);
 
 /* Constants used internally to select the data.  */
 enum
   {
     WANT_HOMEDIR,
     WANT_SYSCONFDIR,
     WANT_BINDIR,
     WANT_LIBEXECDIR,
     WANT_LIBDIR,
     WANT_DATADIR,
     WANT_LOCALEDIR,
+    WANT_SOCKETDIR,
     WANT_AGENT_SOCKET,
     WANT_AGENT_SSH_SOCKET,
     WANT_DIRMNGR_SOCKET,
     WANT_UISRV_SOCKET,
     WANT_GPGCONF_NAME,
     WANT_GPG_NAME,
     WANT_GPGSM_NAME,
     WANT_G13_NAME,
     WANT_GPG_WKS_CLIENT_NAME,
     WANT_GPG_ONE_MODE
   };
 
 /* Values retrieved via gpgconf and cached here.  */
 static struct {
   int  valid;         /* Cached information is valid.  */
   int  disable_gpgconf;
   char *homedir;
   char *sysconfdir;
   char *bindir;
   char *libexecdir;
   char *libdir;
   char *datadir;
   char *localedir;
+  char *socketdir;
   char *agent_socket;
   char *agent_ssh_socket;
   char *dirmngr_socket;
   char *uisrv_socket;
   char *gpgconf_name;
   char *gpg_name;
   char *gpgsm_name;
   char *g13_name;
   char *gpg_wks_client_name;
   int  gpg_one_mode;  /* System is in gpg1 mode.  */
 } dirinfo;
 
 
 
 /* Helper function to be used only by gpgme_set_global_flag.  */
 void
 _gpgme_dirinfo_disable_gpgconf (void)
 {
   dirinfo.disable_gpgconf = 1;
 }
 
 
 /* Return the length of the directory part including the trailing
  * slash of NAME.  */
 static size_t
 dirname_len (const char *name)
 {
   return _gpgme_get_basename (name) - name;
 }
 
 
 /* Parse the output of "gpgconf --list-dirs".  This function expects
    that DIRINFO_LOCK is held by the caller.  If COMPONENTS is set, the
    output of --list-components is expected. */
 static void
 parse_output (char *line, int components)
 {
   char *value, *p;
   size_t n;
 
   value = strchr (line, ':');
   if (!value)
     return;
   *value++ = 0;
   if (components)
     {
       /* Skip the second field.  */
       value = strchr (value, ':');
       if (!value)
         return;
       *value++ = 0;
     }
   p = strchr (value, ':');
   if (p)
     *p = 0;
   if (_gpgme_decode_percent_string (value, &value, strlen (value)+1, 0))
     return;
   if (!*value)
     return;
 
   if (components)
     {
       if (!strcmp (line, "gpg") && !dirinfo.gpg_name)
         dirinfo.gpg_name = strdup (value);
       else if (!strcmp (line, "gpgsm") && !dirinfo.gpgsm_name)
         dirinfo.gpgsm_name = strdup (value);
       else if (!strcmp (line, "g13") && !dirinfo.g13_name)
         dirinfo.g13_name = strdup (value);
     }
   else
     {
       if (!strcmp (line, "homedir") && !dirinfo.homedir)
         dirinfo.homedir = strdup (value);
       else if (!strcmp (line, "sysconfdir") && !dirinfo.sysconfdir)
         dirinfo.sysconfdir = strdup (value);
       else if (!strcmp (line, "bindir") && !dirinfo.bindir)
         dirinfo.bindir = strdup (value);
       else if (!strcmp (line, "libexecdir") && !dirinfo.libexecdir)
         dirinfo.libexecdir = strdup (value);
       else if (!strcmp (line, "libdir") && !dirinfo.libdir)
         dirinfo.libdir = strdup (value);
       else if (!strcmp (line, "datadir") && !dirinfo.datadir)
         dirinfo.datadir = strdup (value);
       else if (!strcmp (line, "localedir") && !dirinfo.localedir)
         dirinfo.localedir = strdup (value);
+      else if (!strcmp (line, "socketdir") && !dirinfo.socketdir)
+        dirinfo.socketdir = strdup (value);
       else if (!strcmp (line, "agent-socket") && !dirinfo.agent_socket)
         {
           const char name[] = "S.uiserver";
           char *buffer;
 
           dirinfo.agent_socket = strdup (value);
           if (dirinfo.agent_socket)
             {
               n = dirname_len (dirinfo.agent_socket);
               buffer = malloc (n + strlen (name) + 1);
               if (buffer)
                 {
                   strncpy (buffer, dirinfo.agent_socket, n);
                   strcpy (buffer + n, name);
                   dirinfo.uisrv_socket = buffer;
                 }
             }
         }
       else if (!strcmp (line, "dirmngr-socket") && !dirinfo.dirmngr_socket)
         dirinfo.dirmngr_socket = strdup (value);
       else if (!strcmp (line, "agent-ssh-socket") && !dirinfo.agent_ssh_socket)
         dirinfo.agent_ssh_socket = strdup (value);
     }
 }
 
 
 /* Read the directory information from gpgconf.  This function expects
    that DIRINFO_LOCK is held by the caller.  PGNAME is the name of the
    gpgconf binary. If COMPONENTS is set, not the directories bit the
    name of the componeNts are read. */
 static void
 read_gpgconf_dirs (const char *pgmname, int components)
 {
   char linebuf[1024] = {0};
   int linelen = 0;
   char * argv[3];
   int rp[2];
   struct spawn_fd_item_s cfd[] = { {-1, 1 /* STDOUT_FILENO */, -1, 0},
 				   {-1, -1} };
   int status;
   int nread;
   char *mark = NULL;
 
   argv[0] = (char *)pgmname;
   argv[1] = (char*)(components? "--list-components" : "--list-dirs");
   argv[2] = NULL;
 
   if (_gpgme_io_pipe (rp, 1) < 0)
     return;
 
   cfd[0].fd = rp[1];
 
   status = _gpgme_io_spawn (pgmname, argv, IOSPAWN_FLAG_DETACHED,
                             cfd, NULL, NULL, NULL);
   if (status < 0)
     {
       _gpgme_io_close (rp[0]);
       _gpgme_io_close (rp[1]);
       return;
     }
 
   do
     {
       nread = _gpgme_io_read (rp[0],
                               linebuf + linelen,
                               sizeof linebuf - linelen - 1);
       if (nread > 0)
 	{
           char *line;
           const char *lastmark = NULL;
           size_t nused;
 
 	  linelen += nread;
 	  linebuf[linelen] = '\0';
 
 	  for (line=linebuf; (mark = strchr (line, '\n')); line = mark+1 )
 	    {
               lastmark = mark;
 	      if (mark > line && mark[-1] == '\r')
 		mark[-1] = '\0';
               else
                 mark[0] = '\0';
 
               parse_output (line, components);
 	    }
 
           nused = lastmark? (lastmark + 1 - linebuf) : 0;
           memmove (linebuf, linebuf + nused, linelen - nused);
           linelen -= nused;
 	}
     }
   while (nread > 0 && linelen < sizeof linebuf - 1);
 
   _gpgme_io_close (rp[0]);
 }
 
 
 static const char *
 get_gpgconf_item (int what)
 {
   const char *result = NULL;
 
   LOCK (dirinfo_lock);
   if (!dirinfo.valid)
     {
       char *pgmname;
 
       pgmname = dirinfo.disable_gpgconf? NULL : _gpgme_get_gpgconf_path ();
       if (pgmname && _gpgme_access (pgmname, F_OK))
         {
           _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                         "gpgme-dinfo: gpgconf='%s' [not installed]\n", pgmname);
           free (pgmname);
           pgmname = NULL; /* Not available.  */
         }
       else
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo: gpgconf='%s'\n",
                       pgmname? pgmname : "[null]");
       if (!pgmname)
         {
           /* Probably gpgconf is not installed.  Assume we are using
              GnuPG-1.  */
           dirinfo.gpg_one_mode = 1;
           pgmname = _gpgme_get_gpg_path ();
           if (pgmname)
             dirinfo.gpg_name = pgmname;
         }
       else
         {
           dirinfo.gpg_one_mode = 0;
           read_gpgconf_dirs (pgmname, 0);
           read_gpgconf_dirs (pgmname, 1);
           dirinfo.gpgconf_name = pgmname;
         }
       /* Even if the reading of the directories failed (e.g. due to an
          too old version gpgconf or no gpgconf at all), we need to
          mark the entries as valid so that we won't try over and over
          to read them.  Note further that we are not able to change
          the read values later because they are practically statically
          allocated.  */
       dirinfo.valid = 1;
       if (dirinfo.gpg_name)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo:     gpg='%s'\n",
                       dirinfo.gpg_name);
       if (dirinfo.g13_name)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo:     g13='%s'\n",
                       dirinfo.g13_name);
       if (dirinfo.gpgsm_name)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo:   gpgsm='%s'\n",
                       dirinfo.gpgsm_name);
       if (dirinfo.homedir)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo: homedir='%s'\n",
                       dirinfo.homedir);
+      if (dirinfo.socketdir)
+        _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
+                      "gpgme-dinfo: sockdir='%s'\n",
+                      dirinfo.socketdir);
       if (dirinfo.agent_socket)
         _gpgme_debug (NULL,DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo:   agent='%s'\n",
                       dirinfo.agent_socket);
       if (dirinfo.agent_ssh_socket)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo:     ssh='%s'\n",
                       dirinfo.agent_ssh_socket);
       if (dirinfo.dirmngr_socket)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo: dirmngr='%s'\n",
                       dirinfo.dirmngr_socket);
       if (dirinfo.uisrv_socket)
         _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                       "gpgme-dinfo:   uisrv='%s'\n",
                       dirinfo.uisrv_socket);
     }
   switch (what)
     {
     case WANT_HOMEDIR:    result = dirinfo.homedir; break;
     case WANT_SYSCONFDIR: result = dirinfo.sysconfdir; break;
     case WANT_BINDIR:     result = dirinfo.bindir; break;
     case WANT_LIBEXECDIR: result = dirinfo.libexecdir; break;
     case WANT_LIBDIR:     result = dirinfo.libdir; break;
     case WANT_DATADIR:    result = dirinfo.datadir; break;
     case WANT_LOCALEDIR:  result = dirinfo.localedir; break;
+    case WANT_SOCKETDIR:  result = dirinfo.socketdir; break;
     case WANT_AGENT_SOCKET: result = dirinfo.agent_socket; break;
     case WANT_AGENT_SSH_SOCKET: result = dirinfo.agent_ssh_socket; break;
     case WANT_DIRMNGR_SOCKET: result = dirinfo.dirmngr_socket; break;
     case WANT_GPGCONF_NAME: result = dirinfo.gpgconf_name; break;
     case WANT_GPG_NAME:   result = dirinfo.gpg_name; break;
     case WANT_GPGSM_NAME: result = dirinfo.gpgsm_name; break;
     case WANT_G13_NAME:   result = dirinfo.g13_name; break;
     case WANT_UISRV_SOCKET:  result = dirinfo.uisrv_socket; break;
     case WANT_GPG_ONE_MODE: result = dirinfo.gpg_one_mode? "1":NULL; break;
     case WANT_GPG_WKS_CLIENT_NAME:
       if (!dirinfo.gpg_wks_client_name && dirinfo.libexecdir)
         dirinfo.gpg_wks_client_name = _gpgme_strconcat (dirinfo.libexecdir,
                                                         "/",
                                                         "gpg-wks-client",
                                                         NULL);
       result = dirinfo.gpg_wks_client_name;
       break;
     }
   UNLOCK (dirinfo_lock);
   return result;
 }
 
 
 /* Return the default home directory.   Returns NULL if not known.  */
 const char *
 _gpgme_get_default_homedir (void)
 {
   return get_gpgconf_item (WANT_HOMEDIR);
 }
 
 /* Return the default gpg-agent socket name.  Returns NULL if not known.  */
 const char *
 _gpgme_get_default_agent_socket (void)
 {
   return get_gpgconf_item (WANT_AGENT_SOCKET);
 }
 
 /* Return the default gpg file name.  Returns NULL if not known.  */
 const char *
 _gpgme_get_default_gpg_name (void)
 {
   return get_gpgconf_item (WANT_GPG_NAME);
 }
 
 /* Return the default gpgsm file name.  Returns NULL if not known.  */
 const char *
 _gpgme_get_default_gpgsm_name (void)
 {
   return get_gpgconf_item (WANT_GPGSM_NAME);
 }
 
 /* Return the default g13 file name.  Returns NULL if not known.  */
 const char *
 _gpgme_get_default_g13_name (void)
 {
   return get_gpgconf_item (WANT_G13_NAME);
 }
 
 /* Return the default gpgconf file name.  Returns NULL if not known.  */
 const char *
 _gpgme_get_default_gpgconf_name (void)
 {
   return get_gpgconf_item (WANT_GPGCONF_NAME);
 }
 
 /* Return the default UI-server socket name.  Returns NULL if not
    known.  */
 const char *
 _gpgme_get_default_uisrv_socket (void)
 {
   return get_gpgconf_item (WANT_UISRV_SOCKET);
 }
 
 /* Return true if we are in GnuPG-1 mode - ie. no gpgconf and agent
    being optional.  */
 int
 _gpgme_in_gpg_one_mode (void)
 {
   return !!get_gpgconf_item (WANT_GPG_ONE_MODE);
 }
 
 
 
 /* Helper function to return the basename of the passed filename.  */
 const char *
 _gpgme_get_basename (const char *name)
 {
   const char *s;
 
   if (!name || !*name)
     return name;
   for (s = name + strlen (name) -1; s >= name; s--)
     if (*s == '/'
 #ifdef HAVE_W32_SYSTEM
         || *s == '\\' || *s == ':'
 #endif
         )
       return s+1;
   return name;
 }
 
 
 /* Return default values for various directories and file names.  */
 const char *
 gpgme_get_dirinfo (const char *what)
 {
   if (!what)
     return NULL;
   else if (!strcmp (what, "homedir"))
     return get_gpgconf_item (WANT_HOMEDIR);
   else if (!strcmp (what, "agent-socket"))
     return get_gpgconf_item (WANT_AGENT_SOCKET);
   else if (!strcmp (what, "uiserver-socket"))
     return get_gpgconf_item (WANT_UISRV_SOCKET);
   else if (!strcmp (what, "gpgconf-name"))
     return get_gpgconf_item (WANT_GPGCONF_NAME);
   else if (!strcmp (what, "gpg-name"))
     return get_gpgconf_item (WANT_GPG_NAME);
   else if (!strcmp (what, "gpgsm-name"))
     return get_gpgconf_item (WANT_GPGSM_NAME);
   else if (!strcmp (what, "g13-name"))
     return get_gpgconf_item (WANT_G13_NAME);
   else if (!strcmp (what, "gpg-wks-client-name"))
     return get_gpgconf_item (WANT_GPG_WKS_CLIENT_NAME);
   else if (!strcmp (what, "agent-ssh-socket"))
     return get_gpgconf_item (WANT_AGENT_SSH_SOCKET);
   else if (!strcmp (what, "dirmngr-socket"))
     return get_gpgconf_item (WANT_DIRMNGR_SOCKET);
   else if (!strcmp (what, "sysconfdir"))
     return get_gpgconf_item (WANT_SYSCONFDIR);
   else if (!strcmp (what, "bindir"))
     return get_gpgconf_item (WANT_BINDIR);
   else if (!strcmp (what, "libexecdir"))
     return get_gpgconf_item (WANT_LIBEXECDIR);
   else if (!strcmp (what, "libdir"))
     return get_gpgconf_item (WANT_LIBDIR);
   else if (!strcmp (what, "datadir"))
     return get_gpgconf_item (WANT_DATADIR);
   else if (!strcmp (what, "localedir"))
     return get_gpgconf_item (WANT_LOCALEDIR);
+  else if (!strcmp (what, "socketdir"))
+    return get_gpgconf_item (WANT_SOCKETDIR);
   else
     return NULL;
 }
diff --git a/src/w32-util.c b/src/w32-util.c
index 2631ae7c..e4757a21 100644
--- a/src/w32-util.c
+++ b/src/w32-util.c
@@ -1,911 +1,912 @@
 /* w32-util.c - Utility functions for the W32 API
  * Copyright (C) 1999 Free Software Foundation, Inc
  * Copyright (C) 2001 Werner Koch (dd9jn)
  * Copyright (C) 2001, 2002, 2003, 2004, 2007, 2013 g10 Code GmbH
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <https://gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <stdint.h>
 #ifdef HAVE_SYS_TIME_H
 # include <sys/time.h>
 #endif
 #ifdef HAVE_SYS_TYPES_H
 # include <sys/types.h>
 #endif
 #ifdef HAVE_SYS_STAT_H
 # include <sys/stat.h>
 #endif
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 #include <fcntl.h>
 #include <io.h>
 
 #if __MINGW64_VERSION_MAJOR >= 2
 # define _WIN32_IE 0x0501 /* Required by mingw64 toolkit.  */
 #else
 # define _WIN32_IE 0x0400 /* Required for SHGetSpecialFolderPathA.  */
 #endif
 
 /* We need to include the windows stuff here prior to shlobj.h so that
    we get the right winsock version.  This is usually done in util.h
    but that header also redefines some Windows functions which we need
    to avoid unless having included shlobj.h.  */
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <windows.h>
 #include <shlobj.h>
 
 #include "util.h"
 #include "ath.h"
 #include "sema.h"
 #include "debug.h"
 #include "sys-util.h"
 
 
 #define HAVE_ALLOW_SET_FOREGROUND_WINDOW 1
 #ifndef F_OK
 # define F_OK 0
 #endif
 
 /* The Registry key used by GNUPG.  */
 #ifdef _WIN64
 # define GNUPG_REGKEY_2  "Software\\Wow6432Node\\GNU\\GnuPG"
 #else
 # define GNUPG_REGKEY_2  "Software\\GNU\\GnuPG"
 #endif
 #ifdef _WIN64
 # define GNUPG_REGKEY_3  "Software\\Wow6432Node\\GnuPG"
 #else
 # define GNUPG_REGKEY_3  "Software\\GnuPG"
 #endif
 
 DEFINE_STATIC_LOCK (get_path_lock);
 
 /* The module handle of this DLL.  If we are linked statically,
    dllmain does not exists and thus the value of my_hmodule will be
    NULL.  The effect is that a GetModuleFileName always returns the
    file name of the DLL or executable which contains the gpgme code.  */
 static HMODULE my_hmodule;
 
 /* These variables store the malloced name of alternative default
    binaries.  The are set only once by gpgme_set_global_flag.  */
 static char *default_gpg_name;
 static char *default_gpgconf_name;
 /* If this variable is not NULL the value is assumed to be the
    installation directory.  The variable may only be set once by
    gpgme_set_global_flag and accessed by _gpgme_get_inst_dir.  */
 static char *override_inst_dir;
 
 #define RTLD_LAZY 0
 
 static GPG_ERR_INLINE void *
 dlopen (const char * name, int flag)
 {
   void * hd = LoadLibrary (name);
 
   (void)flag;
   return hd;
 }
 
 static GPG_ERR_INLINE void *
 dlsym (void * hd, const char * sym)
 {
   if (hd && sym)
     {
       void * fnc = GetProcAddress (hd, sym);
       if (!fnc)
         return NULL;
       return fnc;
     }
   return NULL;
 }
 
 static GPG_ERR_INLINE int
 dlclose (void * hd)
 {
   if (hd)
     {
       FreeLibrary (hd);
       return 0;
     }
   return -1;
 }
 
 
 /* Return a malloced string encoded in UTF-8 from the wide char input
    string STRING.  Caller must free this value.  Returns NULL and sets
    ERRNO on failure.  Calling this function with STRING set to NULL is
    not defined.  */
 static char *
 wchar_to_utf8 (const wchar_t *string)
 {
   int n;
   char *result;
 
   n = WideCharToMultiByte (CP_UTF8, 0, string, -1, NULL, 0, NULL, NULL);
   if (n < 0)
     {
       gpg_err_set_errno (EINVAL);
       return NULL;
     }
 
   result = malloc (n+1);
   if (!result)
     return NULL;
 
   n = WideCharToMultiByte (CP_UTF8, 0, string, -1, result, n, NULL, NULL);
   if (n < 0)
     {
       free (result);
       gpg_err_set_errno (EINVAL);
       result = NULL;
     }
   return result;
 }
 
 
 /* Return a malloced wide char string from an UTF-8 encoded input
    string STRING.  Caller must free this value. On failure returns
    NULL; caller may use GetLastError to get the actual error number.
    Calling this function with STRING set to NULL is not defined. */
 static wchar_t *
 utf8_to_wchar (const char *string)
 {
   int n;
   wchar_t *result;
 
 
   n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
   if (n < 0)
     return NULL;
 
   result = (wchar_t *) malloc ((n+1) * sizeof *result);
   if (!result)
     return NULL;
 
   n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
   if (n < 0)
     {
       free (result);
       return NULL;
     }
   return result;
 }
 
 
 /* Same as utf8_to_wchar but calling it with NULL returns
    NULL.  So a return value of NULL only indicates failure
    if STRING is not set to NULL. */
 static wchar_t *
 utf8_to_wchar0 (const char *string)
 {
   if (!string)
     return NULL;
 
   return utf8_to_wchar (string);
 }
 
 
 /* Replace all forward slashes by backslashes.  */
 static void
 replace_slashes (char *string)
 {
   for (; *string; string++)
     if (*string == '/')
       *string = '\\';
 }
 
 
 /* Get the base name of NAME.  Returns a pointer into NAME right after
    the last slash or backslash or to NAME if no slash or backslash
    exists.  */
 static const char *
 get_basename (const char *name)
 {
   const char *mark, *s;
 
   for (mark=NULL, s=name; *s; s++)
     if (*s == '/' || *s == '\\')
       mark = s;
 
   return mark? mark+1 : name;
 }
 
 
 void
 _gpgme_allow_set_foreground_window (pid_t pid)
 {
 #ifdef HAVE_ALLOW_SET_FOREGROUND_WINDOW
   static int initialized;
   static BOOL (WINAPI * func)(DWORD);
   void *handle;
 
   if (!initialized)
     {
       /* Available since W2000; thus we dynload it.  */
       initialized = 1;
       handle = dlopen ("user32.dll", RTLD_LAZY);
       if (handle)
         {
           func = dlsym (handle, "AllowSetForegroundWindow");
           if (!func)
             {
               dlclose (handle);
               handle = NULL;
             }
         }
     }
 
   if (!pid || pid == (pid_t)(-1))
     {
       TRACE (DEBUG_ENGINE, "gpgme:AllowSetForegroundWindow", NULL,
 	      "no action for pid %d", (int)pid);
     }
   else if (func)
     {
       int rc = func (pid);
       TRACE (DEBUG_ENGINE, "gpgme:AllowSetForegroundWindow", NULL,
 	      "called for pid %d; result=%d", (int)pid, rc);
 
     }
   else
     {
       TRACE (DEBUG_ENGINE, "gpgme:AllowSetForegroundWindow", NULL,
 	      "function not available");
     }
 #endif /* HAVE_ALLOW_SET_FOREGROUND_WINDOW */
 }
 
 
 /* Wrapper around CancelSynchronousIo which is only available since
  * Vista.  */
 void
 _gpgme_w32_cancel_synchronous_io (HANDLE thread)
 {
   static int initialized;
   static BOOL (WINAPI * func)(DWORD);
   void *handle;
 
   if (!initialized)
     {
       /* Available since Vista; thus we dynload it.  */
       initialized = 1;
       handle = dlopen ("kernel32.dll", RTLD_LAZY);
       if (handle)
         {
           func = dlsym (handle, "CancelSynchronousIo");
           if (!func)
             {
               dlclose (handle);
               handle = NULL;
             }
         }
     }
 
   if (func)
     {
       if (!func ((DWORD)thread) && GetLastError() != ERROR_NOT_FOUND)
         {
           TRACE (DEBUG_ENGINE, "gpgme:CancelSynchronousIo", NULL,
                  "called for thread %p: ec=%u",
                  thread, (unsigned int)GetLastError ());
         }
     }
   else
     {
       TRACE (DEBUG_ENGINE, "gpgme:CancelSynchronousIo", NULL,
 	      "function not available");
     }
 }
 
 
 /* Return a string from the W32 Registry or NULL in case of error.
    Caller must release the return value.  A NULL for root is an alias
    for HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE in turn. */
 static char *
 read_w32_registry_string (const char *root, const char *dir, const char *name)
 {
   HKEY root_key, key_handle;
   DWORD n1, nbytes, type;
   char *result = NULL;
 
   if (!root)
     root_key = HKEY_CURRENT_USER;
   else if (!strcmp( root, "HKEY_CLASSES_ROOT"))
     root_key = HKEY_CLASSES_ROOT;
   else if (!strcmp( root, "HKEY_CURRENT_USER"))
     root_key = HKEY_CURRENT_USER;
   else if (!strcmp( root, "HKEY_LOCAL_MACHINE"))
     root_key = HKEY_LOCAL_MACHINE;
   else if (!strcmp( root, "HKEY_USERS"))
     root_key = HKEY_USERS;
   else if (!strcmp( root, "HKEY_PERFORMANCE_DATA"))
     root_key = HKEY_PERFORMANCE_DATA;
   else if (!strcmp( root, "HKEY_CURRENT_CONFIG"))
     root_key = HKEY_CURRENT_CONFIG;
   else
     return NULL;
 
   if (RegOpenKeyExA (root_key, dir, 0, KEY_READ, &key_handle))
     {
       if (root)
         return NULL; /* no need for a RegClose, so return direct */
       /* It seems to be common practise to fall back to HKLM. */
       if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, dir, 0, KEY_READ, &key_handle))
         return NULL; /* still no need for a RegClose, so return direct */
     }
 
   nbytes = 1;
   if (RegQueryValueExA (key_handle, name, 0, NULL, NULL, &nbytes))
     {
       if (root)
         goto leave;
       /* Try to fallback to HKLM also vor a missing value.  */
       RegCloseKey (key_handle);
       if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, dir, 0, KEY_READ, &key_handle))
         return NULL; /* Nope.  */
       if (RegQueryValueExA (key_handle, name, 0, NULL, NULL, &nbytes))
         goto leave;
     }
   n1 = nbytes + 1;
   result = malloc (n1);
   if (!result)
     goto leave;
   if (RegQueryValueExA (key_handle, name, 0, &type, (LPBYTE) result, &n1))
     {
       free (result);
       result = NULL;
       goto leave;
     }
   result[nbytes] = 0; /* Make sure it is really a string.  */
 
  leave:
   RegCloseKey (key_handle);
   return result;
 }
 
 
 /* Return the name of the directory with the gpgme DLL or the EXE (if
    statically linked).  May return NULL on severe errors. */
 const char *
 _gpgme_get_inst_dir (void)
 {
   static char *inst_dir;
 
   if (override_inst_dir)
     return override_inst_dir;
 
   LOCK (get_path_lock);
   if (!inst_dir)
     {
       wchar_t *moddir;
 
       moddir = malloc ((MAX_PATH+5) * sizeof *moddir);
       if (moddir)
         {
           if (!GetModuleFileNameW (my_hmodule, moddir, MAX_PATH))
             *moddir = 0;
           if (!*moddir)
             gpg_err_set_errno (ENOENT);
           else
             {
               inst_dir = wchar_to_utf8 (moddir);
               if (inst_dir)
                 {
                   char *p = strrchr (inst_dir, '\\');
                   if (p)
                     *p = 0;
                 }
             }
           free (moddir);
         }
     }
   UNLOCK (get_path_lock);
   return inst_dir;
 }
 
 
 static char *
 find_program_in_dir (const char *dir, const char *name)
 {
   char *result;
 
   result = _gpgme_strconcat (dir, "\\", name, NULL);
   if (!result)
     return NULL;
 
   if (_gpgme_access (result, F_OK))
     {
       free (result);
       return NULL;
     }
 
   return result;
 }
 
 
 static char *
 find_program_at_standard_place (const char *name)
 {
   wchar_t path[MAX_PATH];
   char *result = NULL;
 
   /* See https://wiki.tcl-lang.org/page/Getting+Windows+%22special+folders%22+with+Ffidl for details on compatibility.
 
      We First try the generic place and then fallback to the x86
      (i.e. 32 bit) place.  This will prefer a 64 bit of the program
      over a 32 bit version on 64 bit Windows if installed.  */
   if (SHGetSpecialFolderPathW (NULL, path, CSIDL_PROGRAM_FILES, 0))
     {
       char *utf8_path = wchar_to_utf8 (path);
       result = _gpgme_strconcat (utf8_path, "\\", name, NULL);
       free (utf8_path);
       if (result && _gpgme_access (result, F_OK))
         {
           free (result);
           result = NULL;
         }
     }
   if (!result
       && SHGetSpecialFolderPathW (NULL, path, CSIDL_PROGRAM_FILESX86, 0))
     {
       char *utf8_path = wchar_to_utf8 (path);
       result = _gpgme_strconcat (utf8_path, "\\", name, NULL);
       free (utf8_path);
       if (result && _gpgme_access (result, F_OK))
         {
           free (result);
           result = NULL;
         }
     }
   return result;
 }
 
 
 /* Set the default name for the gpg binary.  This function may only be
    called by gpgme_set_global_flag.  Returns 0 on success.  */
 int
 _gpgme_set_default_gpg_name (const char *name)
 {
   if (!default_gpg_name)
     {
       default_gpg_name = _gpgme_strconcat (name, ".exe", NULL);
       if (default_gpg_name)
         replace_slashes (default_gpg_name);
     }
   return !default_gpg_name;
 }
 
 /* Set the default name for the gpgconf binary.  This function may only be
    called by gpgme_set_global_flag.  Returns 0 on success.  */
 int
 _gpgme_set_default_gpgconf_name (const char *name)
 {
   if (!default_gpgconf_name)
     {
       default_gpgconf_name = _gpgme_strconcat (name, ".exe", NULL);
       if (default_gpgconf_name)
         replace_slashes (default_gpgconf_name);
     }
   return !default_gpgconf_name;
 }
 
 
 /* Set the override installation directory.  This function may only be
    called by gpgme_set_global_flag.  Returns 0 on success.  */
 int
 _gpgme_set_override_inst_dir (const char *dir)
 {
   if (!override_inst_dir)
     {
       override_inst_dir = strdup (dir);
       if (override_inst_dir)
         {
           replace_slashes (override_inst_dir);
           /* Remove a trailing slash.  */
           if (*override_inst_dir
               && override_inst_dir[strlen (override_inst_dir)-1] == '\\')
             override_inst_dir[strlen (override_inst_dir)-1] = 0;
         }
     }
   return !override_inst_dir;
 }
 
 
 /* Return the full file name of the GPG binary.  This function is used
    iff gpgconf was not found and thus it can be assumed that gpg2 is
    not installed.  This function is only called by get_gpgconf_item
    and may not be called concurrently. */
 char *
 _gpgme_get_gpg_path (void)
 {
   char *gpg = NULL;
   const char *name, *inst_dir;
 
   name = default_gpg_name? get_basename (default_gpg_name) : "gpg.exe";
 
   /* 1. Try to find gpg.exe in the installation directory of gpgme.  */
   inst_dir = _gpgme_get_inst_dir ();
   if (inst_dir)
     {
       gpg = find_program_in_dir (inst_dir, name);
     }
 
   /* 2. Try to find gpg.exe using that ancient registry key.  */
   if (!gpg)
     {
       char *dir;
 
       dir = read_w32_registry_string ("HKEY_LOCAL_MACHINE",
                                       GNUPG_REGKEY_2,
                                       "Install Directory");
       if (dir)
         {
           gpg = find_program_in_dir (dir, name);
           free (dir);
         }
     }
 
   /* 3. Try to find gpg.exe below CSIDL_PROGRAM_FILES.  */
   if (!gpg)
     {
       name = default_gpg_name? default_gpg_name : "GNU\\GnuPG\\gpg.exe";
       gpg = find_program_at_standard_place (name);
     }
 
   /* 4. Print a debug message if not found.  */
   if (!gpg)
     _gpgme_debug (NULL, DEBUG_ENGINE, -1, NULL, NULL, NULL,
                   "_gpgme_get_gpg_path: '%s' not found", name);
 
   return gpg;
 }
 
 
 /* This function is only called by get_gpgconf_item and may not be
    called concurrently.  */
 char *
 _gpgme_get_gpgconf_path (void)
 {
   char *gpgconf = NULL;
   const char *inst_dir, *name;
 
   name = default_gpgconf_name? get_basename(default_gpgconf_name):"gpgconf.exe";
 
   /* 1. Try to find gpgconf.exe in the installation directory of gpgme.  */
   inst_dir = _gpgme_get_inst_dir ();
   if (inst_dir)
     {
       gpgconf = find_program_in_dir (inst_dir, name);
     }
 
   /* 2. Try to find gpgconf.exe from GnuPG >= 2.1 below CSIDL_PROGRAM_FILES. */
   if (!gpgconf)
     {
       const char *name2 = (default_gpgconf_name ? default_gpgconf_name
                            /**/                 : "GnuPG\\bin\\gpgconf.exe");
       gpgconf = find_program_at_standard_place (name2);
     }
 
   /* 3. Try to find gpgconf.exe using the Windows registry. */
   if (!gpgconf)
     {
       char *dir;
 
       dir = read_w32_registry_string (NULL,
                                       GNUPG_REGKEY_2,
                                       "Install Directory");
       if (!dir)
         {
           char *tmp = read_w32_registry_string (NULL,
                                                 GNUPG_REGKEY_3,
                                                 "Install Directory");
           if (tmp)
             {
               dir = _gpgme_strconcat (tmp, "\\bin", NULL);
               free (tmp);
               if (!dir)
                 return NULL;
             }
         }
       if (dir)
         {
           gpgconf = find_program_in_dir (dir, name);
           free (dir);
         }
     }
 
   /* 4. Try to find gpgconf.exe from Gpg4win below CSIDL_PROGRAM_FILES.  */
   if (!gpgconf)
     {
       gpgconf = find_program_at_standard_place ("GNU\\GnuPG\\gpgconf.exe");
     }
 
   /* 5. Try to find gpgconf.exe relative to us.  */
   if (!gpgconf && inst_dir)
     {
       char *dir = _gpgme_strconcat (inst_dir, "\\..\\..\\GnuPG\\bin", NULL);
       gpgconf = find_program_in_dir (dir, name);
       free (dir);
     }
 
   /* 5. Print a debug message if not found.  */
   if (!gpgconf)
     _gpgme_debug (NULL, DEBUG_ENGINE, -1, NULL, NULL, NULL,
                   "_gpgme_get_gpgconf_path: '%s' not found",name);
 
   return gpgconf;
 }
 
 
 const char *
 _gpgme_get_w32spawn_path (void)
 {
   static char *w32spawn_program;
   const char *inst_dir;
 
   inst_dir = _gpgme_get_inst_dir ();
   LOCK (get_path_lock);
   if (!w32spawn_program)
     w32spawn_program = find_program_in_dir (inst_dir, "gpgme-w32spawn.exe");
   UNLOCK (get_path_lock);
   return w32spawn_program;
 }
 
 
 /* Return an integer value from gpgme specific configuration
    entries. VALUE receives that value; function returns true if a value
    has been configured and false if not. */
 int
 _gpgme_get_conf_int (const char *key, int *value)
 {
   char *tmp = read_w32_registry_string (NULL, "Software\\GNU\\gpgme", key);
   if (!tmp)
     return 0;
   *value = atoi (tmp);
   free (tmp);
   return 1;
 }
 
 
 
 /* mkstemp extracted from libc/sysdeps/posix/tempname.c.  Copyright
    (C) 1991-1999, 2000, 2001, 2006 Free Software Foundation, Inc.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.  */
 
 static const char letters[] =
 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
 /* Generate a temporary file name based on TMPL.  TMPL must match the
    rules for mk[s]temp (i.e. end in "XXXXXX").  The name constructed
    does not exist at the time of the call to mkstemp.  TMPL is
    overwritten with the result.  */
 static int
 my_mkstemp (char *tmpl)
 {
   int len;
   char *XXXXXX;
   static uint64_t value;
   uint64_t random_time_bits;
   unsigned int count;
   int fd = -1;
   int save_errno = errno;
 
   /* A lower bound on the number of temporary files to attempt to
      generate.  The maximum total number of temporary file names that
      can exist for a given template is 62**6.  It should never be
      necessary to try all these combinations.  Instead if a reasonable
      number of names is tried (we define reasonable as 62**3) fail to
      give the system administrator the chance to remove the problems.  */
 #define ATTEMPTS_MIN (62 * 62 * 62)
 
   /* The number of times to attempt to generate a temporary file.  To
      conform to POSIX, this must be no smaller than TMP_MAX.  */
 #if ATTEMPTS_MIN < TMP_MAX
   unsigned int attempts = TMP_MAX;
 #else
   unsigned int attempts = ATTEMPTS_MIN;
 #endif
 
   len = strlen (tmpl);
   if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
     {
       gpg_err_set_errno (EINVAL);
       return -1;
     }
 
   /* This is where the Xs start.  */
   XXXXXX = &tmpl[len - 6];
 
   /* Get some more or less random data.  */
   {
     FILETIME ft;
 
     GetSystemTimeAsFileTime (&ft);
     random_time_bits = (((uint64_t)ft.dwHighDateTime << 32)
                         | (uint64_t)ft.dwLowDateTime);
   }
   value += random_time_bits ^ ath_self ();
 
   for (count = 0; count < attempts; value += 7777, ++count)
     {
       uint64_t v = value;
 
       /* Fill in the random bits.  */
       XXXXXX[0] = letters[v % 62];
       v /= 62;
       XXXXXX[1] = letters[v % 62];
       v /= 62;
       XXXXXX[2] = letters[v % 62];
       v /= 62;
       XXXXXX[3] = letters[v % 62];
       v /= 62;
       XXXXXX[4] = letters[v % 62];
       v /= 62;
       XXXXXX[5] = letters[v % 62];
 
       fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
       if (fd >= 0)
 	{
 	  gpg_err_set_errno (save_errno);
 	  return fd;
 	}
       else if (errno != EEXIST)
 	return -1;
     }
 
   /* We got out of the loop because we ran out of combinations to try.  */
   gpg_err_set_errno (EEXIST);
   return -1;
 }
 
 
 int
 _gpgme_mkstemp (int *fd, char **name)
 {
   char tmp[MAX_PATH + 2];
   char *tmpname;
   int err;
 
   *fd = -1;
   *name = NULL;
 
   err = GetTempPathA (MAX_PATH + 1, tmp);
   if (err == 0 || err > MAX_PATH + 1)
     strcpy (tmp,"c:\\windows\\temp");
   else
     {
       int len = strlen(tmp);
 
       /* GetTempPath may return with \ on the end */
       while(len > 0 && tmp[len - 1] == '\\')
 	{
 	  tmp[len-1] = '\0';
 	  len--;
 	}
     }
 
   tmpname = _gpgme_strconcat (tmp, "\\gpgme-XXXXXX", NULL);
   if (!tmpname)
     return -1;
   *fd = my_mkstemp (tmpname);
   if (*fd < 0)
     {
       free (tmpname);
       return -1;
     }
 
   *name = tmpname;
   return 0;
 }
 
 
 /* Like access but using windows _waccess */
 int
 _gpgme_access (const char *path, int mode)
 {
   wchar_t *u16 = utf8_to_wchar0 (path);
   int r = _waccess (u16, mode);
 
   free(u16);
   return r;
 }
 
 
 /* Like CreateProcessA but mapping the arguments to wchar API */
-int _gpgme_create_process_utf8 (const char *application_name_utf8,
-                                char *command_line_utf8,
-                                LPSECURITY_ATTRIBUTES lpProcessAttributes,
-                                LPSECURITY_ATTRIBUTES lpThreadAttributes,
-                                BOOL bInheritHandles,
-                                DWORD dwCreationFlags,
-                                void *lpEnvironment,
-                                char *working_directory_utf8,
-                                LPSTARTUPINFOA si,
-                                LPPROCESS_INFORMATION lpProcessInformation)
+int
+_gpgme_create_process_utf8 (const char *application_name_utf8,
+                            char *command_line_utf8,
+                            LPSECURITY_ATTRIBUTES lpProcessAttributes,
+                            LPSECURITY_ATTRIBUTES lpThreadAttributes,
+                            BOOL bInheritHandles,
+                            DWORD dwCreationFlags,
+                            void *lpEnvironment,
+                            char *working_directory_utf8,
+                            LPSTARTUPINFOA si,
+                            LPPROCESS_INFORMATION lpProcessInformation)
 {
   BOOL ret;
   wchar_t *application_name = utf8_to_wchar0 (application_name_utf8);
   wchar_t *command_line = utf8_to_wchar0 (command_line_utf8);
   wchar_t *working_directory = utf8_to_wchar0 (working_directory_utf8);
 
   STARTUPINFOW siw;
   memset (&siw, 0, sizeof siw);
   if (si)
     {
       siw.cb = sizeof (siw);
       siw.dwFlags = si->dwFlags;
       siw.wShowWindow = si->wShowWindow;
       siw.hStdInput = si->hStdInput;
       siw.hStdOutput = si->hStdOutput;
       siw.hStdError = si->hStdError;
       siw.dwX = si->dwX;
       siw.dwY = si->dwY;
       siw.dwXSize = si->dwXSize;
       siw.dwYSize = si->dwYSize;
       siw.dwXCountChars = si->dwXCountChars;
       siw.dwYCountChars = si->dwYCountChars;
       siw.dwFillAttribute = si->dwFillAttribute;
       siw.lpDesktop = utf8_to_wchar0 (si->lpDesktop);
       siw.lpTitle = utf8_to_wchar0 (si->lpTitle);
     }
 
   ret = CreateProcessW (application_name,
                         command_line,
                         lpProcessAttributes,
                         lpThreadAttributes,
                         bInheritHandles,
                         dwCreationFlags,
                         lpEnvironment,
                         working_directory,
                         si ? &siw : NULL,
                         lpProcessInformation);
   free (siw.lpTitle);
   free (siw.lpDesktop);
   free (application_name);
   free (command_line);
   free (working_directory);
   return ret;
 }
 
 /* Entry point called by the DLL loader.  */
 #ifdef DLL_EXPORT
 int WINAPI
 DllMain (HINSTANCE hinst, DWORD reason, LPVOID reserved)
 {
   (void)reserved;
 
   if (reason == DLL_PROCESS_ATTACH)
     my_hmodule = hinst;
 
   return TRUE;
 }
 #endif /*DLL_EXPORT*/
diff --git a/tests/t-engine-info.c b/tests/t-engine-info.c
index db46bf86..654cf843 100644
--- a/tests/t-engine-info.c
+++ b/tests/t-engine-info.c
@@ -1,148 +1,149 @@
 /* t-engine-info.c - Regression test for gpgme_get_engine_info.
  * Copyright (C) 2003, 2004, 2007 g10 Code GmbH
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <https://gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <gpgme.h>
 
 #define PGM "t-engine-info"
 
 static int verbose;
 
 
 
 
 #define fail_if_err(err)					\
   do								\
     {								\
       if (err)							\
         {							\
           fprintf (stderr, "%s:%d: gpgme_error_t %s\n",		\
                    __FILE__, __LINE__, gpgme_strerror (err));   \
           exit (1);						\
         }							\
     }								\
   while (0)
 
 
 int
 main (int argc, char **argv )
 {
   int last_argc = -1;
   gpgme_engine_info_t info;
   gpgme_error_t err;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: " PGM " [options]\n"
                  "Options:\n"
                  "  --set-global-flag KEY VALUE\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--set-global-flag"))
         {
           argc--; argv++;
           if (argc < 2)
             {
               fprintf (stderr, PGM ": not enough arguments for option\n");
               exit (1);
             }
           if (gpgme_set_global_flag (argv[0], argv[1]))
             {
               fprintf (stderr, PGM ": gpgme_set_global_flag failed\n");
               exit (1);
             }
           argc--; argv++;
           argc--; argv++;
         }
       else if (!strncmp (*argv, "--", 2))
         {
           fprintf (stderr, PGM ": unknown option '%s'\n", *argv);
           exit (1);
         }
     }
 
   if (argc)
     {
       fprintf (stderr, PGM ": unexpected arguments\n");
       exit (1);
     }
 
   gpgme_check_version (NULL);
 
   {
     const char *keys[] = {"homedir",
                           "sysconfdir",
                           "bindir",
                           "libexecdir",
                           "libdir",
                           "datadir",
                           "localedir",
+                          "socketdir",
                           "agent-socket",
                           "agent-ssh-socket",
                           "dirmngr-socket",
                           "uiserver-socket",
                           "gpgconf-name",
                           "gpg-name",
                           "gpgsm-name",
                           "g13-name",
                           "gpg-wks-client-name",
                           NULL };
     const char *s;
     int i;
 
     for (i=0; keys[i]; i++)
       if ((s = gpgme_get_dirinfo (keys[i])))
         fprintf (stderr, "dirinfo: %s='%s'\n", keys[i], s);
   }
 
   err = gpgme_get_engine_info (&info);
   fail_if_err (err);
 
   for (; info; info = info->next)
     fprintf (stdout, "protocol=%d engine='%s' v='%s' (min='%s') home='%s'\n",
              info->protocol, info->file_name, info->version, info->req_version,
              info->home_dir? info->home_dir : "[default]");
 
   return 0;
 }