agent,dirmngr: Tiny restructuring.
[gnupg.git] / dirmngr / dirmngr.c
1 /* dirmngr.c - Keyserver and X.509 LDAP access
2  * Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2010, 2011 g10 Code GmbH
4  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stddef.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <assert.h>
31 #include <time.h>
32 #include <fcntl.h>
33 #ifndef HAVE_W32_SYSTEM
34 #include <sys/socket.h>
35 #include <sys/un.h>
36 #endif
37 #include <sys/stat.h>
38 #include <unistd.h>
39 #ifdef HAVE_SIGNAL_H
40 # include <signal.h>
41 #endif
42 #ifdef HAVE_INOTIFY_INIT
43 # include <sys/inotify.h>
44 #endif /*HAVE_INOTIFY_INIT*/
45 #include <npth.h>
46
47 #include "dirmngr-err.h"
48
49 #if  HTTP_USE_NTBTLS
50 # include <ntbtls.h>
51 #elif HTTP_USE_GNUTLS
52 # include <gnutls/gnutls.h>
53 #endif /*HTTP_USE_GNUTLS*/
54
55
56 #define GNUPG_COMMON_NEED_AFLOCAL
57 #include "dirmngr.h"
58
59 #include <assuan.h>
60
61 #include "certcache.h"
62 #include "crlcache.h"
63 #include "crlfetch.h"
64 #include "misc.h"
65 #if USE_LDAP
66 # include "ldapserver.h"
67 #endif
68 #include "asshelp.h"
69 #if USE_LDAP
70 # include "ldap-wrapper.h"
71 #endif
72 #include "../common/init.h"
73 #include "gc-opt-flags.h"
74 #include "dns-stuff.h"
75
76 #ifndef ENAMETOOLONG
77 # define ENAMETOOLONG EINVAL
78 #endif
79
80
81 enum cmd_and_opt_values {
82   aNull = 0,
83   oCsh            = 'c',
84   oQuiet          = 'q',
85   oSh             = 's',
86   oVerbose        = 'v',
87   oNoVerbose = 500,
88
89   aServer,
90   aDaemon,
91   aSupervised,
92   aListCRLs,
93   aLoadCRL,
94   aFetchCRL,
95   aShutdown,
96   aFlush,
97   aGPGConfList,
98   aGPGConfTest,
99
100   oOptions,
101   oDebug,
102   oDebugAll,
103   oDebugWait,
104   oDebugLevel,
105   oGnutlsDebug,
106   oNoGreeting,
107   oNoOptions,
108   oHomedir,
109   oNoDetach,
110   oLogFile,
111   oBatch,
112   oDisableHTTP,
113   oDisableLDAP,
114   oIgnoreLDAPDP,
115   oIgnoreHTTPDP,
116   oIgnoreOCSPSvcUrl,
117   oHonorHTTPProxy,
118   oHTTPProxy,
119   oLDAPProxy,
120   oOnlyLDAPProxy,
121   oLDAPFile,
122   oLDAPTimeout,
123   oLDAPAddServers,
124   oOCSPResponder,
125   oOCSPSigner,
126   oOCSPMaxClockSkew,
127   oOCSPMaxPeriod,
128   oOCSPCurrentPeriod,
129   oMaxReplies,
130   oHkpCaCert,
131   oFakedSystemTime,
132   oForce,
133   oAllowOCSP,
134   oAllowVersionCheck,
135   oSocketName,
136   oLDAPWrapperProgram,
137   oHTTPWrapperProgram,
138   oIgnoreCertExtension,
139   oUseTor,
140   oKeyServer,
141   oNameServer,
142   oDisableCheckOwnSocket,
143   aTest
144 };
145
146
147
148 static ARGPARSE_OPTS opts[] = {
149
150   ARGPARSE_group (300, N_("@Commands:\n ")),
151
152   ARGPARSE_c (aServer,   "server",  N_("run in server mode (foreground)") ),
153   ARGPARSE_c (aDaemon,   "daemon",  N_("run in daemon mode (background)") ),
154 #ifndef HAVE_W32_SYSTEM
155   ARGPARSE_c (aSupervised,  "supervised", N_("run in supervised mode")),
156 #endif
157   ARGPARSE_c (aListCRLs, "list-crls", N_("list the contents of the CRL cache")),
158   ARGPARSE_c (aLoadCRL,  "load-crl",  N_("|FILE|load CRL from FILE into cache")),
159   ARGPARSE_c (aFetchCRL, "fetch-crl", N_("|URL|fetch a CRL from URL")),
160   ARGPARSE_c (aShutdown, "shutdown",  N_("shutdown the dirmngr")),
161   ARGPARSE_c (aFlush,    "flush",     N_("flush the cache")),
162   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
163   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
164
165   ARGPARSE_group (301, N_("@\nOptions:\n ")),
166
167   ARGPARSE_s_n (oVerbose,  "verbose",   N_("verbose")),
168   ARGPARSE_s_n (oQuiet,    "quiet",     N_("be somewhat more quiet")),
169   ARGPARSE_s_n (oSh,       "sh",        N_("sh-style command output")),
170   ARGPARSE_s_n (oCsh,      "csh",       N_("csh-style command output")),
171   ARGPARSE_s_s (oOptions,  "options",   N_("|FILE|read options from FILE")),
172   ARGPARSE_s_s (oDebugLevel, "debug-level",
173                 N_("|LEVEL|set the debugging level to LEVEL")),
174   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
175   ARGPARSE_s_s (oLogFile,  "log-file",
176                 N_("|FILE|write server mode logs to FILE")),
177   ARGPARSE_s_n (oBatch,    "batch",       N_("run without asking a user")),
178   ARGPARSE_s_n (oForce,    "force",       N_("force loading of outdated CRLs")),
179   ARGPARSE_s_n (oAllowOCSP, "allow-ocsp", N_("allow sending OCSP requests")),
180   ARGPARSE_s_n (oAllowVersionCheck, "allow-version-check",
181                 N_("allow online software version check")),
182   ARGPARSE_s_n (oDisableHTTP, "disable-http", N_("inhibit the use of HTTP")),
183   ARGPARSE_s_n (oDisableLDAP, "disable-ldap", N_("inhibit the use of LDAP")),
184   ARGPARSE_s_n (oIgnoreHTTPDP,"ignore-http-dp",
185                 N_("ignore HTTP CRL distribution points")),
186   ARGPARSE_s_n (oIgnoreLDAPDP,"ignore-ldap-dp",
187                 N_("ignore LDAP CRL distribution points")),
188   ARGPARSE_s_n (oIgnoreOCSPSvcUrl, "ignore-ocsp-service-url",
189                 N_("ignore certificate contained OCSP service URLs")),
190
191   ARGPARSE_s_s (oHTTPProxy,  "http-proxy",
192                 N_("|URL|redirect all HTTP requests to URL")),
193   ARGPARSE_s_s (oLDAPProxy,  "ldap-proxy",
194                 N_("|HOST|use HOST for LDAP queries")),
195   ARGPARSE_s_n (oOnlyLDAPProxy, "only-ldap-proxy",
196                 N_("do not use fallback hosts with --ldap-proxy")),
197
198   ARGPARSE_s_s (oLDAPFile, "ldapserverlist-file",
199                 N_("|FILE|read LDAP server list from FILE")),
200   ARGPARSE_s_n (oLDAPAddServers, "add-servers",
201                 N_("add new servers discovered in CRL distribution"
202                    " points to serverlist")),
203   ARGPARSE_s_i (oLDAPTimeout, "ldaptimeout",
204                 N_("|N|set LDAP timeout to N seconds")),
205
206   ARGPARSE_s_s (oOCSPResponder, "ocsp-responder",
207                 N_("|URL|use OCSP responder at URL")),
208   ARGPARSE_s_s (oOCSPSigner, "ocsp-signer",
209                 N_("|FPR|OCSP response signed by FPR")),
210   ARGPARSE_s_i (oOCSPMaxClockSkew, "ocsp-max-clock-skew", "@"),
211   ARGPARSE_s_i (oOCSPMaxPeriod,    "ocsp-max-period", "@"),
212   ARGPARSE_s_i (oOCSPCurrentPeriod, "ocsp-current-period", "@"),
213
214   ARGPARSE_s_i (oMaxReplies, "max-replies",
215                 N_("|N|do not return more than N items in one query")),
216
217   ARGPARSE_s_s (oNameServer, "nameserver", "@"),
218   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
219   ARGPARSE_s_s (oHkpCaCert, "hkp-cacert",
220                 N_("|FILE|use the CA certificates in FILE for HKP over TLS")),
221
222   ARGPARSE_s_n (oUseTor, "use-tor", N_("route all network traffic via Tor")),
223
224   ARGPARSE_s_s (oSocketName, "socket-name", "@"),  /* Only for debugging.  */
225
226   ARGPARSE_s_u (oFakedSystemTime, "faked-system-time", "@"), /*(epoch time)*/
227   ARGPARSE_s_s (oDebug,    "debug", "@"),
228   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
229   ARGPARSE_s_i (oGnutlsDebug, "gnutls-debug", "@"),
230   ARGPARSE_s_i (oGnutlsDebug, "tls-debug", "@"),
231   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
232   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
233   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
234   ARGPARSE_s_s (oHomedir, "homedir", "@"),
235   ARGPARSE_s_s (oLDAPWrapperProgram, "ldap-wrapper-program", "@"),
236   ARGPARSE_s_s (oHTTPWrapperProgram, "http-wrapper-program", "@"),
237   ARGPARSE_s_n (oHonorHTTPProxy, "honor-http-proxy", "@"),
238   ARGPARSE_s_s (oIgnoreCertExtension,"ignore-cert-extension", "@"),
239
240   ARGPARSE_group (302,N_("@\n(See the \"info\" manual for a complete listing "
241                          "of all commands and options)\n")),
242
243   ARGPARSE_end ()
244 };
245
246 /* The list of supported debug flags.  */
247 static struct debug_flags_s debug_flags [] =
248   {
249     { DBG_X509_VALUE   , "x509"    },
250     { DBG_CRYPTO_VALUE , "crypto"  },
251     { DBG_MEMORY_VALUE , "memory"  },
252     { DBG_CACHE_VALUE  , "cache"   },
253     { DBG_MEMSTAT_VALUE, "memstat" },
254     { DBG_HASHING_VALUE, "hashing" },
255     { DBG_IPC_VALUE    , "ipc"     },
256     { DBG_LOOKUP_VALUE , "lookup"  },
257     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
258   };
259
260 #define DEFAULT_MAX_REPLIES 10
261 #define DEFAULT_LDAP_TIMEOUT 100 /* arbitrary large timeout */
262
263 /* For the cleanup handler we need to keep track of the socket's name.  */
264 static const char *socket_name;
265 /* If the socket has been redirected, this is the name of the
266    redirected socket..  */
267 static const char *redir_socket_name;
268
269 /* We need to keep track of the server's nonces (these are dummies for
270    POSIX systems). */
271 static assuan_sock_nonce_t socket_nonce;
272
273 /* Only if this flag has been set will we remove the socket file.  */
274 static int cleanup_socket;
275
276 /* Keep track of the current log file so that we can avoid updating
277    the log file after a SIGHUP if it didn't changed. Malloced. */
278 static char *current_logfile;
279
280 /* Helper to implement --debug-level. */
281 static const char *debug_level;
282
283 /* Helper to set the NTBTLS or GNUTLS log level.  */
284 static int opt_gnutls_debug = -1;
285
286 /* Flag indicating that a shutdown has been requested.  */
287 static volatile int shutdown_pending;
288
289 /* Flags to indicate that we shall not watch our own socket. */
290 static int disable_check_own_socket;
291
292 /* Counter for the active connections.  */
293 static int active_connections;
294
295 /* This flag is set by any network access and used by the housekeeping
296  * thread to run background network tasks.  */
297 static int network_activity_seen;
298
299 /* The timer tick used for housekeeping stuff.  */
300 #define TIMERTICK_INTERVAL         (60)
301
302 /* How oft to run the housekeeping.  */
303 #define HOUSEKEEPING_INTERVAL      (600)
304
305
306 /* This union is used to avoid compiler warnings in case a pointer is
307    64 bit and an int 32 bit.  We store an integer in a pointer and get
308    it back later (npth_getspecific et al.).  */
309 union int_and_ptr_u
310 {
311   int  aint;
312   assuan_fd_t afd;
313   void *aptr;
314 };
315
316
317
318 /* The key used to store the current file descriptor in the thread
319    local storage.  We use this in conjunction with the
320    log_set_pid_suffix_cb feature.  */
321 #ifndef HAVE_W32_SYSTEM
322 static int my_tlskey_current_fd;
323 #endif
324
325 /* Prototypes. */
326 static void cleanup (void);
327 #if USE_LDAP
328 static ldap_server_t parse_ldapserver_file (const char* filename);
329 #endif /*USE_LDAP*/
330 static fingerprint_list_t parse_ocsp_signer (const char *string);
331 static void netactivity_action (void);
332 static void handle_connections (assuan_fd_t listen_fd);
333
334 /* NPth wrapper function definitions. */
335 ASSUAN_SYSTEM_NPTH_IMPL;
336
337 static const char *
338 my_strusage( int level )
339 {
340   const char *p;
341   switch ( level )
342     {
343     case 11: p = "@DIRMNGR@ (@GNUPG@)";
344       break;
345     case 13: p = VERSION; break;
346     case 17: p = PRINTABLE_OS_NAME; break;
347       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
348          reporting address.  This is so that we can change the
349          reporting address without breaking the translations.  */
350     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
351     case 49: p = PACKAGE_BUGREPORT; break;
352     case 1:
353     case 40: p = _("Usage: @DIRMNGR@ [options] (-h for help)");
354       break;
355     case 41: p = _("Syntax: @DIRMNGR@ [options] [command [args]]\n"
356                    "Keyserver, CRL, and OCSP access for @GNUPG@\n");
357       break;
358
359     default: p = NULL;
360     }
361   return p;
362 }
363
364
365 /* Callback from libksba to hash a provided buffer.  Our current
366    implementation does only allow SHA-1 for hashing. This may be
367    extended by mapping the name, testing for algorithm availibility
368    and adjust the length checks accordingly. */
369 static gpg_error_t
370 my_ksba_hash_buffer (void *arg, const char *oid,
371                      const void *buffer, size_t length, size_t resultsize,
372                      unsigned char *result, size_t *resultlen)
373 {
374   (void)arg;
375
376   if (oid && strcmp (oid, "1.3.14.3.2.26"))
377     return gpg_error (GPG_ERR_NOT_SUPPORTED);
378   if (resultsize < 20)
379     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
380   gcry_md_hash_buffer (2, result, buffer, length);
381   *resultlen = 20;
382   return 0;
383 }
384
385
386 /* GNUTLS log function callback.  */
387 #ifdef HTTP_USE_GNUTLS
388 static void
389 my_gnutls_log (int level, const char *text)
390 {
391   int n;
392
393   n = strlen (text);
394   while (n && text[n-1] == '\n')
395     n--;
396
397   log_debug ("gnutls:L%d: %.*s\n", level, n, text);
398 }
399 #endif /*HTTP_USE_GNUTLS*/
400
401 /* Setup the debugging.  With a LEVEL of NULL only the active debug
402    flags are propagated to the subsystems.  With LEVEL set, a specific
403    set of debug flags is set; thus overriding all flags already
404    set. */
405 static void
406 set_debug (void)
407 {
408   int numok = (debug_level && digitp (debug_level));
409   int numlvl = numok? atoi (debug_level) : 0;
410
411   if (!debug_level)
412     ;
413   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
414     opt.debug = 0;
415   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
416     opt.debug = DBG_IPC_VALUE;
417   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
418     opt.debug = (DBG_IPC_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE);
419   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
420     opt.debug = (DBG_IPC_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE
421                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
422   else if (!strcmp (debug_level, "guru") || numok)
423     {
424       opt.debug = ~0;
425       /* Unless the "guru" string has been used we don't want to allow
426          hashing debugging.  The rationale is that people tend to
427          select the highest debug value and would then clutter their
428          disk with debug files which may reveal confidential data.  */
429       if (numok)
430         opt.debug &= ~(DBG_HASHING_VALUE);
431     }
432   else
433     {
434       log_error (_("invalid debug-level '%s' given\n"), debug_level);
435       log_info (_("valid debug levels are: %s\n"),
436                 "none, basic, advanced, expert, guru");
437       opt.debug = 0; /* Reset debugging, so that prior debug
438                         statements won't have an undesired effect. */
439     }
440
441
442   if (opt.debug && !opt.verbose)
443     {
444       opt.verbose = 1;
445       gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
446     }
447   if (opt.debug && opt.quiet)
448     opt.quiet = 0;
449
450   if (opt.debug & DBG_CRYPTO_VALUE )
451     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
452
453 #if HTTP_USE_NTBTLS
454   if (opt_gnutls_debug >= 0)
455     {
456       ntbtls_set_debug (opt_gnutls_debug, NULL, NULL);
457     }
458 #elif HTTP_USE_GNUTLS
459   if (opt_gnutls_debug >= 0)
460     {
461       gnutls_global_set_log_function (my_gnutls_log);
462       gnutls_global_set_log_level (opt_gnutls_debug);
463     }
464 #endif /*HTTP_USE_GNUTLS*/
465
466   if (opt.debug)
467     parse_debug_flag (NULL, &opt.debug, debug_flags);
468 }
469
470
471 static void
472 set_tor_mode (void)
473 {
474   if (opt.use_tor)
475     {
476       if (assuan_sock_set_flag (ASSUAN_INVALID_FD, "tor-mode", 1))
477         {
478           log_error ("error enabling Tor mode: %s\n", strerror (errno));
479           log_info ("(is your Libassuan recent enough?)\n");
480         }
481     }
482 }
483
484
485 static void
486 wrong_args (const char *text)
487 {
488   es_fprintf (es_stderr, _("usage: %s [options] "), DIRMNGR_NAME);
489   es_fputs (text, es_stderr);
490   es_putc ('\n', es_stderr);
491   dirmngr_exit (2);
492 }
493
494
495 /* Helper to stop the reaper thread for the ldap wrapper.  */
496 static void
497 shutdown_reaper (void)
498 {
499 #if USE_LDAP
500   ldap_wrapper_wait_connections ();
501 #endif
502 }
503
504
505 /* Handle options which are allowed to be reset after program start.
506    Return true if the current option in PARGS could be handled and
507    false if not.  As a special feature, passing a value of NULL for
508    PARGS, resets the options to the default.  REREAD should be set
509    true if it is not the initial option parsing. */
510 static int
511 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
512 {
513   if (!pargs)
514     { /* Reset mode. */
515       opt.quiet = 0;
516       opt.verbose = 0;
517       opt.debug = 0;
518       opt.ldap_wrapper_program = NULL;
519       opt.disable_http = 0;
520       opt.disable_ldap = 0;
521       opt.honor_http_proxy = 0;
522       opt.http_proxy = NULL;
523       opt.ldap_proxy = NULL;
524       opt.only_ldap_proxy = 0;
525       opt.ignore_http_dp = 0;
526       opt.ignore_ldap_dp = 0;
527       opt.ignore_ocsp_service_url = 0;
528       opt.allow_ocsp = 0;
529       opt.allow_version_check = 0;
530       opt.ocsp_responder = NULL;
531       opt.ocsp_max_clock_skew = 10 * 60;      /* 10 minutes.  */
532       opt.ocsp_max_period = 90 * 86400;       /* 90 days.  */
533       opt.ocsp_current_period = 3 * 60 * 60;  /* 3 hours. */
534       opt.max_replies = DEFAULT_MAX_REPLIES;
535       while (opt.ocsp_signer)
536         {
537           fingerprint_list_t tmp = opt.ocsp_signer->next;
538           xfree (opt.ocsp_signer);
539           opt.ocsp_signer = tmp;
540         }
541       FREE_STRLIST (opt.ignored_cert_extensions);
542       http_register_tls_ca (NULL);
543       FREE_STRLIST (opt.keyserver);
544       /* Note: We do not allow resetting of opt.use_tor at runtime.  */
545       disable_check_own_socket = 0;
546       return 1;
547     }
548
549   switch (pargs->r_opt)
550     {
551     case oQuiet:   opt.quiet = 1; break;
552     case oVerbose: opt.verbose++; break;
553     case oDebug:
554       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
555       break;
556     case oDebugAll: opt.debug = ~0; break;
557     case oDebugLevel: debug_level = pargs->r.ret_str; break;
558     case oGnutlsDebug: opt_gnutls_debug = pargs->r.ret_int; break;
559
560     case oLogFile:
561       if (!reread)
562         return 0; /* Not handled. */
563       if (!current_logfile || !pargs->r.ret_str
564           || strcmp (current_logfile, pargs->r.ret_str))
565         {
566           log_set_file (pargs->r.ret_str);
567           xfree (current_logfile);
568           current_logfile = xtrystrdup (pargs->r.ret_str);
569         }
570       break;
571
572     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
573
574     case oLDAPWrapperProgram:
575       opt.ldap_wrapper_program = pargs->r.ret_str;
576       break;
577     case oHTTPWrapperProgram:
578       opt.http_wrapper_program = pargs->r.ret_str;
579       break;
580
581     case oDisableHTTP: opt.disable_http = 1; break;
582     case oDisableLDAP: opt.disable_ldap = 1; break;
583     case oHonorHTTPProxy: opt.honor_http_proxy = 1; break;
584     case oHTTPProxy: opt.http_proxy = pargs->r.ret_str; break;
585     case oLDAPProxy: opt.ldap_proxy = pargs->r.ret_str; break;
586     case oOnlyLDAPProxy: opt.only_ldap_proxy = 1; break;
587     case oIgnoreHTTPDP: opt.ignore_http_dp = 1; break;
588     case oIgnoreLDAPDP: opt.ignore_ldap_dp = 1; break;
589     case oIgnoreOCSPSvcUrl: opt.ignore_ocsp_service_url = 1; break;
590
591     case oAllowOCSP: opt.allow_ocsp = 1; break;
592     case oAllowVersionCheck: opt.allow_version_check = 1; break;
593     case oOCSPResponder: opt.ocsp_responder = pargs->r.ret_str; break;
594     case oOCSPSigner:
595       opt.ocsp_signer = parse_ocsp_signer (pargs->r.ret_str);
596       break;
597     case oOCSPMaxClockSkew: opt.ocsp_max_clock_skew = pargs->r.ret_int; break;
598     case oOCSPMaxPeriod: opt.ocsp_max_period = pargs->r.ret_int; break;
599     case oOCSPCurrentPeriod: opt.ocsp_current_period = pargs->r.ret_int; break;
600
601     case oMaxReplies: opt.max_replies = pargs->r.ret_int; break;
602
603     case oHkpCaCert:
604       {
605         char *tmpname;
606
607         /* Do tilde expansion and make path absolute.  */
608         tmpname = make_absfilename (pargs->r.ret_str, NULL);
609         http_register_tls_ca (tmpname);
610         xfree (tmpname);
611       }
612       break;
613
614     case oIgnoreCertExtension:
615       add_to_strlist (&opt.ignored_cert_extensions, pargs->r.ret_str);
616       break;
617
618     case oUseTor: opt.use_tor = 1; break;
619
620     case oKeyServer:
621       if (*pargs->r.ret_str)
622         add_to_strlist (&opt.keyserver, pargs->r.ret_str);
623       break;
624
625     case oNameServer:
626       set_dns_nameserver (pargs->r.ret_str);
627       break;
628
629     default:
630       return 0; /* Not handled. */
631     }
632
633   return 1; /* Handled. */
634 }
635
636
637 #ifndef HAVE_W32_SYSTEM
638 static int
639 pid_suffix_callback (unsigned long *r_suffix)
640 {
641   union int_and_ptr_u value;
642
643   memset (&value, 0, sizeof value);
644   value.aptr = npth_getspecific (my_tlskey_current_fd);
645   *r_suffix = value.aint;
646   return (*r_suffix != -1);  /* Use decimal representation.  */
647 }
648 #endif /*!HAVE_W32_SYSTEM*/
649
650
651 static void
652 thread_init (void)
653 {
654   npth_init ();
655   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
656
657   /* Now with NPth running we can set the logging callback.  Our
658      windows implementation does not yet feature the NPth TLS
659      functions.  */
660 #ifndef HAVE_W32_SYSTEM
661   if (npth_key_create (&my_tlskey_current_fd, NULL) == 0)
662     if (npth_setspecific (my_tlskey_current_fd, NULL) == 0)
663       log_set_pid_suffix_cb (pid_suffix_callback);
664 #endif /*!HAVE_W32_SYSTEM*/
665 }
666
667
668 int
669 main (int argc, char **argv)
670 {
671   enum cmd_and_opt_values cmd = 0;
672   ARGPARSE_ARGS pargs;
673   int orig_argc;
674   char **orig_argv;
675   FILE *configfp = NULL;
676   char *configname = NULL;
677   const char *shell;
678   unsigned configlineno;
679   int parse_debug = 0;
680   int default_config =1;
681   int greeting = 0;
682   int nogreeting = 0;
683   int nodetach = 0;
684   int csh_style = 0;
685   char *logfile = NULL;
686 #if USE_LDAP
687   char *ldapfile = NULL;
688 #endif /*USE_LDAP*/
689   int debug_wait = 0;
690   int rc;
691   struct assuan_malloc_hooks malloc_hooks;
692
693   early_system_init ();
694   set_strusage (my_strusage);
695   log_set_prefix (DIRMNGR_NAME, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
696
697   /* Make sure that our subsystems are ready.  */
698   i18n_init ();
699   init_common_subsystems (&argc, &argv);
700
701   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
702
703  /* Check that the libraries are suitable.  Do it here because
704     the option parsing may need services of the libraries. */
705   if (!ksba_check_version (NEED_KSBA_VERSION) )
706     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
707                NEED_KSBA_VERSION, ksba_check_version (NULL) );
708
709   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
710   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
711
712   /* Init TLS library.  */
713 #if HTTP_USE_NTBTLS
714   if (!ntbtls_check_version (NEED_NTBTLS_VERSION) )
715     log_fatal( _("%s is too old (need %s, have %s)\n"), "ntbtls",
716                NEED_NTBTLS_VERSION, ntbtls_check_version (NULL) );
717 #elif HTTP_USE_GNUTLS
718   rc = gnutls_global_init ();
719   if (rc)
720     log_fatal ("gnutls_global_init failed: %s\n", gnutls_strerror (rc));
721 #endif /*HTTP_USE_GNUTLS*/
722
723   /* Init Assuan. */
724   malloc_hooks.malloc = gcry_malloc;
725   malloc_hooks.realloc = gcry_realloc;
726   malloc_hooks.free = gcry_free;
727   assuan_set_malloc_hooks (&malloc_hooks);
728   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
729   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
730   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
731   assuan_sock_init ();
732   setup_libassuan_logging (&opt.debug, dirmngr_assuan_log_monitor);
733
734   setup_libgcrypt_logging ();
735
736   /* Setup defaults. */
737   shell = getenv ("SHELL");
738   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
739     csh_style = 1;
740
741   /* Reset rereadable options to default values. */
742   parse_rereadable_options (NULL, 0);
743
744   /* LDAP defaults.  */
745   opt.add_new_ldapservers = 0;
746   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
747
748   /* Other defaults.  */
749
750   /* Check whether we have a config file given on the commandline */
751   orig_argc = argc;
752   orig_argv = argv;
753   pargs.argc = &argc;
754   pargs.argv = &argv;
755   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
756   while (arg_parse( &pargs, opts))
757     {
758       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
759         parse_debug++;
760       else if (pargs.r_opt == oOptions)
761         { /* Yes there is one, so we do not try the default one, but
762              read the option file when it is encountered at the
763              commandline */
764           default_config = 0;
765         }
766       else if (pargs.r_opt == oNoOptions)
767         default_config = 0; /* --no-options */
768       else if (pargs.r_opt == oHomedir)
769         {
770           gnupg_set_homedir (pargs.r.ret_str);
771         }
772     }
773
774   socket_name = dirmngr_socket_name ();
775   if (default_config)
776     configname = make_filename (gnupg_homedir (), DIRMNGR_NAME".conf", NULL );
777
778   argc = orig_argc;
779   argv = orig_argv;
780   pargs.argc = &argc;
781   pargs.argv = &argv;
782   pargs.flags= 1;  /* do not remove the args */
783  next_pass:
784   if (configname)
785     {
786       configlineno = 0;
787       configfp = fopen (configname, "r");
788       if (!configfp)
789         {
790           if (default_config)
791             {
792               if( parse_debug )
793                 log_info (_("Note: no default option file '%s'\n"),
794                           configname );
795             }
796           else
797             {
798               log_error (_("option file '%s': %s\n"),
799                          configname, strerror(errno) );
800               exit(2);
801             }
802           xfree (configname);
803           configname = NULL;
804         }
805       if (parse_debug && configname )
806         log_info (_("reading options from '%s'\n"), configname );
807       default_config = 0;
808     }
809
810   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
811     {
812       if (parse_rereadable_options (&pargs, 0))
813         continue; /* Already handled */
814       switch (pargs.r_opt)
815         {
816         case aServer:
817         case aDaemon:
818         case aSupervised:
819         case aShutdown:
820         case aFlush:
821         case aListCRLs:
822         case aLoadCRL:
823         case aFetchCRL:
824         case aGPGConfList:
825         case aGPGConfTest:
826           cmd = pargs.r_opt;
827           break;
828
829         case oQuiet: opt.quiet = 1; break;
830         case oVerbose: opt.verbose++; break;
831         case oBatch: opt.batch=1; break;
832
833         case oDebugWait: debug_wait = pargs.r.ret_int; break;
834
835         case oOptions:
836           /* Config files may not be nested (silently ignore them) */
837           if (!configfp)
838             {
839                 xfree(configname);
840                 configname = xstrdup(pargs.r.ret_str);
841                 goto next_pass;
842             }
843           break;
844         case oNoGreeting: nogreeting = 1; break;
845         case oNoVerbose: opt.verbose = 0; break;
846         case oNoOptions: break; /* no-options */
847         case oHomedir: /* Ignore this option here. */; break;
848         case oNoDetach: nodetach = 1; break;
849         case oLogFile: logfile = pargs.r.ret_str; break;
850         case oCsh: csh_style = 1; break;
851         case oSh: csh_style = 0; break;
852         case oLDAPFile:
853 #        if USE_LDAP
854           ldapfile = pargs.r.ret_str;
855 #        endif /*USE_LDAP*/
856           break;
857         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
858         case oLDAPTimeout:
859           opt.ldaptimeout = pargs.r.ret_int;
860           break;
861
862         case oFakedSystemTime:
863           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
864           break;
865
866         case oForce: opt.force = 1; break;
867
868         case oSocketName: socket_name = pargs.r.ret_str; break;
869
870         default : pargs.err = configfp? 1:2; break;
871         }
872     }
873   if (configfp)
874     {
875       fclose (configfp);
876       configfp = NULL;
877       /* Keep a copy of the name so that it can be read on SIGHUP. */
878       opt.config_filename = configname;
879       configname = NULL;
880       goto next_pass;
881     }
882   xfree (configname);
883   configname = NULL;
884   if (log_get_errorcount(0))
885     exit(2);
886   if (nogreeting )
887     greeting = 0;
888
889   if (!opt.homedir_cache)
890     opt.homedir_cache = xstrdup (gnupg_homedir ());
891
892   if (greeting)
893     {
894       es_fprintf (es_stderr, "%s %s; %s\n",
895                   strusage(11), strusage(13), strusage(14) );
896       es_fprintf (es_stderr, "%s\n", strusage(15) );
897     }
898
899 #ifdef IS_DEVELOPMENT_VERSION
900   log_info ("NOTE: this is a development version!\n");
901 #endif
902
903   if (opt.use_tor)
904     {
905       log_info ("WARNING: ***************************************\n");
906       log_info ("WARNING: Tor mode (--use-tor) MAY NOT FULLY WORK!\n");
907       log_info ("WARNING: ***************************************\n");
908     }
909
910   /* Print a warning if an argument looks like an option.  */
911   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
912     {
913       int i;
914
915       for (i=0; i < argc; i++)
916         if (argv[i][0] == '-' && argv[i][1] == '-')
917           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
918     }
919
920   if (!access ("/etc/"DIRMNGR_NAME, F_OK)
921       && !strncmp (gnupg_homedir (), "/etc/", 5))
922     log_info
923       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
924        " other directory names changed.  Please check that no other version"
925        " of dirmngr is still installed.  To disable this warning, remove the"
926        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
927
928   if (gnupg_faked_time_p ())
929     {
930       gnupg_isotime_t tbuf;
931
932       log_info (_("WARNING: running with faked system time: "));
933       gnupg_get_isotime (tbuf);
934       dump_isotime (tbuf);
935       log_printf ("\n");
936     }
937
938   set_debug ();
939   set_tor_mode ();
940
941   /* Get LDAP server list from file. */
942 #if USE_LDAP
943   if (!ldapfile)
944     {
945       ldapfile = make_filename (gnupg_homedir (),
946                                 "dirmngr_ldapservers.conf",
947                                 NULL);
948       opt.ldapservers = parse_ldapserver_file (ldapfile);
949       xfree (ldapfile);
950     }
951   else
952       opt.ldapservers = parse_ldapserver_file (ldapfile);
953 #endif /*USE_LDAP*/
954
955 #ifndef HAVE_W32_SYSTEM
956   /* We need to ignore the PIPE signal because the we might log to a
957      socket and that code handles EPIPE properly.  The ldap wrapper
958      also requires us to ignore this silly signal. Assuan would set
959      this signal to ignore anyway.*/
960   signal (SIGPIPE, SIG_IGN);
961 #endif
962
963   /* Ready.  Now to our duties. */
964   if (!cmd)
965     cmd = aServer;
966   rc = 0;
967
968   if (cmd == aServer)
969     {
970       /* Note that this server mode is mainly useful for debugging.  */
971       if (argc)
972         wrong_args ("--server");
973
974       if (logfile)
975         {
976           log_set_file (logfile);
977           log_set_prefix (NULL, GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
978         }
979
980       if (debug_wait)
981         {
982           log_debug ("waiting for debugger - my pid is %u .....\n",
983                      (unsigned int)getpid());
984           gnupg_sleep (debug_wait);
985           log_debug ("... okay\n");
986         }
987
988
989       thread_init ();
990       cert_cache_init ();
991       crl_cache_init ();
992       http_register_netactivity_cb (netactivity_action);
993       start_command_handler (ASSUAN_INVALID_FD);
994       shutdown_reaper ();
995     }
996 #ifndef HAVE_W32_SYSTEM
997   else if (cmd == aSupervised)
998     {
999       /* In supervised mode, we expect file descriptor 3 to be an
1000          already opened, listening socket.
1001
1002          We will also not detach from the controlling process or close
1003          stderr; the supervisor should handle all of that.  */
1004       struct stat statbuf;
1005       if (fstat (3, &statbuf) == -1 && errno == EBADF)
1006         {
1007           log_error ("file descriptor 3 must be validin --supervised mode\n");
1008           dirmngr_exit (1);
1009         }
1010       socket_name = gnupg_get_socket_name (3);
1011
1012       /* Now start with logging to a file if this is desired. */
1013       if (logfile)
1014         {
1015           log_set_file (logfile);
1016           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1017                                  |GPGRT_LOG_WITH_TIME
1018                                  |GPGRT_LOG_WITH_PID));
1019           current_logfile = xstrdup (logfile);
1020         }
1021       else
1022         log_set_prefix (NULL, 0);
1023
1024       thread_init ();
1025       cert_cache_init ();
1026       crl_cache_init ();
1027       http_register_netactivity_cb (netactivity_action);
1028       handle_connections (3);
1029       shutdown_reaper ();
1030     }
1031 #endif /*HAVE_W32_SYSTEM*/
1032   else if (cmd == aDaemon)
1033     {
1034       assuan_fd_t fd;
1035       pid_t pid;
1036       int len;
1037       struct sockaddr_un serv_addr;
1038
1039       if (argc)
1040         wrong_args ("--daemon");
1041
1042       /* Now start with logging to a file if this is desired. */
1043       if (logfile)
1044         {
1045           log_set_file (logfile);
1046           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1047                                  |GPGRT_LOG_WITH_TIME
1048                                  |GPGRT_LOG_WITH_PID));
1049           current_logfile = xstrdup (logfile);
1050         }
1051
1052 #ifndef HAVE_W32_SYSTEM
1053       if (strchr (socket_name, ':'))
1054         {
1055           log_error (_("colons are not allowed in the socket name\n"));
1056           dirmngr_exit (1);
1057         }
1058 #endif
1059       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1060       if (fd == ASSUAN_INVALID_FD)
1061         {
1062           log_error (_("can't create socket: %s\n"), strerror (errno));
1063           cleanup ();
1064           dirmngr_exit (1);
1065         }
1066
1067       {
1068         int redirected;
1069
1070         if (assuan_sock_set_sockaddr_un (socket_name,
1071                                          (struct sockaddr*)&serv_addr,
1072                                          &redirected))
1073           {
1074             if (errno == ENAMETOOLONG)
1075               log_error (_("socket name '%s' is too long\n"), socket_name);
1076             else
1077               log_error ("error preparing socket '%s': %s\n",
1078                          socket_name,
1079                          gpg_strerror (gpg_error_from_syserror ()));
1080             dirmngr_exit (1);
1081           }
1082         if (redirected)
1083           {
1084             redir_socket_name = xstrdup (serv_addr.sun_path);
1085             if (opt.verbose)
1086               log_info ("redirecting socket '%s' to '%s'\n",
1087                         socket_name, redir_socket_name);
1088           }
1089       }
1090
1091       len = SUN_LEN (&serv_addr);
1092
1093       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1094       if (rc == -1
1095           && (errno == EADDRINUSE
1096 #ifdef HAVE_W32_SYSTEM
1097               || errno == EEXIST
1098 #endif
1099               ))
1100         {
1101           /* Fixme: We should test whether a dirmngr is already running. */
1102           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1103           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1104         }
1105       if (rc != -1
1106           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1107         log_error (_("error getting nonce for the socket\n"));
1108       if (rc == -1)
1109         {
1110           log_error (_("error binding socket to '%s': %s\n"),
1111                      serv_addr.sun_path,
1112                      gpg_strerror (gpg_error_from_errno (errno)));
1113           assuan_sock_close (fd);
1114           dirmngr_exit (1);
1115         }
1116       cleanup_socket = 1;
1117
1118       if (gnupg_chmod (serv_addr.sun_path, "-rwx"))
1119         log_error (_("can't set permissions of '%s': %s\n"),
1120                    serv_addr.sun_path, strerror (errno));
1121
1122       if (listen (FD2INT (fd), 5) == -1)
1123         {
1124           log_error (_("listen() failed: %s\n"), strerror (errno));
1125           assuan_sock_close (fd);
1126           dirmngr_exit (1);
1127         }
1128
1129       if (opt.verbose)
1130         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1131
1132       es_fflush (NULL);
1133
1134       /* Note: We keep the dirmngr_info output only for the sake of
1135          existing scripts which might use this to detect a successful
1136          start of the dirmngr.  */
1137 #ifdef HAVE_W32_SYSTEM
1138       (void)csh_style;
1139       (void)nodetach;
1140
1141       pid = getpid ();
1142       es_printf ("set %s=%s;%lu;1\n",
1143                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1144 #else
1145       pid = fork();
1146       if (pid == (pid_t)-1)
1147         {
1148           log_fatal (_("error forking process: %s\n"), strerror (errno));
1149           dirmngr_exit (1);
1150         }
1151
1152       if (pid)
1153         { /* We are the parent */
1154           char *infostr;
1155
1156           /* Don't let cleanup() remove the socket - the child is
1157              responsible for doing that.  */
1158           cleanup_socket = 0;
1159
1160           close (fd);
1161
1162           /* Create the info string: <name>:<pid>:<protocol_version> */
1163           if (asprintf (&infostr, "%s=%s:%lu:1",
1164                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1165             {
1166               log_error (_("out of core\n"));
1167               kill (pid, SIGTERM);
1168               dirmngr_exit (1);
1169             }
1170           /* Print the environment string, so that the caller can use
1171              shell's eval to set it.  But see above.  */
1172           if (csh_style)
1173             {
1174               *strchr (infostr, '=') = ' ';
1175               es_printf ( "setenv %s;\n", infostr);
1176             }
1177           else
1178             {
1179               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1180             }
1181           free (infostr);
1182           exit (0);
1183           /*NEVER REACHED*/
1184         } /* end parent */
1185
1186
1187       /*
1188          This is the child
1189        */
1190
1191       /* Detach from tty and put process into a new session */
1192       if (!nodetach )
1193         {
1194           int i;
1195           unsigned int oldflags;
1196
1197           /* Close stdin, stdout and stderr unless it is the log stream */
1198           for (i=0; i <= 2; i++)
1199             {
1200               if (!log_test_fd (i) && i != fd )
1201                 {
1202                   if ( !close (i)
1203                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1204                     {
1205                       log_error ("failed to open '%s': %s\n",
1206                                  "/dev/null", strerror (errno));
1207                       cleanup ();
1208                       dirmngr_exit (1);
1209                     }
1210                 }
1211             }
1212
1213           if (setsid() == -1)
1214             {
1215               log_error ("setsid() failed: %s\n", strerror(errno) );
1216               dirmngr_exit (1);
1217             }
1218
1219           log_get_prefix (&oldflags);
1220           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1221           opt.running_detached = 1;
1222
1223           if (chdir("/"))
1224             {
1225               log_error ("chdir to / failed: %s\n", strerror (errno));
1226               dirmngr_exit (1);
1227             }
1228         }
1229 #endif
1230
1231       thread_init ();
1232       cert_cache_init ();
1233       crl_cache_init ();
1234       http_register_netactivity_cb (netactivity_action);
1235       handle_connections (fd);
1236       shutdown_reaper ();
1237     }
1238   else if (cmd == aListCRLs)
1239     {
1240       /* Just list the CRL cache and exit. */
1241       if (argc)
1242         wrong_args ("--list-crls");
1243       crl_cache_init ();
1244       crl_cache_list (es_stdout);
1245     }
1246   else if (cmd == aLoadCRL)
1247     {
1248       struct server_control_s ctrlbuf;
1249
1250       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1251       dirmngr_init_default_ctrl (&ctrlbuf);
1252
1253       thread_init ();
1254       cert_cache_init ();
1255       crl_cache_init ();
1256       if (!argc)
1257         rc = crl_cache_load (&ctrlbuf, NULL);
1258       else
1259         {
1260           for (; !rc && argc; argc--, argv++)
1261             rc = crl_cache_load (&ctrlbuf, *argv);
1262         }
1263       dirmngr_deinit_default_ctrl (&ctrlbuf);
1264     }
1265   else if (cmd == aFetchCRL)
1266     {
1267       ksba_reader_t reader;
1268       struct server_control_s ctrlbuf;
1269
1270       if (argc != 1)
1271         wrong_args ("--fetch-crl URL");
1272
1273       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1274       dirmngr_init_default_ctrl (&ctrlbuf);
1275
1276       thread_init ();
1277       cert_cache_init ();
1278       crl_cache_init ();
1279       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1280       if (rc)
1281         log_error (_("fetching CRL from '%s' failed: %s\n"),
1282                      argv[0], gpg_strerror (rc));
1283       else
1284         {
1285           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1286           if (rc)
1287             log_error (_("processing CRL from '%s' failed: %s\n"),
1288                        argv[0], gpg_strerror (rc));
1289           crl_close_reader (reader);
1290         }
1291       dirmngr_deinit_default_ctrl (&ctrlbuf);
1292     }
1293   else if (cmd == aFlush)
1294     {
1295       /* Delete cache and exit. */
1296       if (argc)
1297         wrong_args ("--flush");
1298       rc = crl_cache_flush();
1299     }
1300   else if (cmd == aGPGConfTest)
1301     dirmngr_exit (0);
1302   else if (cmd == aGPGConfList)
1303     {
1304       unsigned long flags = 0;
1305       char *filename;
1306       char *filename_esc;
1307
1308       /* First the configuration file.  This is not an option, but it
1309          is vital information for GPG Conf.  */
1310       if (!opt.config_filename)
1311         opt.config_filename = make_filename (gnupg_homedir (),
1312                                              "dirmngr.conf", NULL );
1313
1314       filename = percent_escape (opt.config_filename, NULL);
1315       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1316               GC_OPT_FLAG_DEFAULT, filename);
1317       xfree (filename);
1318
1319       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1320       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1321       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1322       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1323       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1324
1325       /* --csh and --sh are mutually exclusive, something we can not
1326          express in GPG Conf.  --options is only usable from the
1327          command line, really.  --debug-all interacts with --debug,
1328          and having both of them is thus problematic.  --no-detach is
1329          also only usable on the command line.  --batch is unused.  */
1330
1331       filename = make_filename (gnupg_homedir (),
1332                                 "dirmngr_ldapservers.conf",
1333                                 NULL);
1334       filename_esc = percent_escape (filename, NULL);
1335       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1336               filename_esc);
1337       xfree (filename_esc);
1338       xfree (filename);
1339
1340       es_printf ("ldaptimeout:%lu:%u\n",
1341               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1342       es_printf ("max-replies:%lu:%u\n",
1343               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1344       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1345       es_printf ("allow-version-check:%lu:\n", flags | GC_OPT_FLAG_NONE);
1346       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1347       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1348
1349       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1350       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1351
1352       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1353       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1354       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1355       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1356       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1357       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1358       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1359       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1360       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1361       /* Note: The next one is to fix a typo in gpgconf - should be
1362          removed eventually. */
1363       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1364
1365       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1366       es_printf ("keyserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1367     }
1368   cleanup ();
1369   return !!rc;
1370 }
1371
1372
1373 static void
1374 cleanup (void)
1375 {
1376   crl_cache_deinit ();
1377   cert_cache_deinit (1);
1378
1379 #if USE_LDAP
1380   ldapserver_list_free (opt.ldapservers);
1381 #endif /*USE_LDAP*/
1382   opt.ldapservers = NULL;
1383
1384   if (cleanup_socket)
1385     {
1386       cleanup_socket = 0;
1387       if (redir_socket_name)
1388         gnupg_remove (redir_socket_name);
1389       else if (socket_name && *socket_name)
1390         gnupg_remove (socket_name);
1391     }
1392 }
1393
1394
1395 void
1396 dirmngr_exit (int rc)
1397 {
1398   cleanup ();
1399   exit (rc);
1400 }
1401
1402
1403 void
1404 dirmngr_init_default_ctrl (ctrl_t ctrl)
1405 {
1406   if (opt.http_proxy)
1407     ctrl->http_proxy = xstrdup (opt.http_proxy);
1408 }
1409
1410
1411 void
1412 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1413 {
1414   if (!ctrl)
1415     return;
1416   xfree (ctrl->http_proxy);
1417   ctrl->http_proxy = NULL;
1418 }
1419
1420
1421 /* Create a list of LDAP servers from the file FILENAME. Returns the
1422    list or NULL in case of errors.
1423
1424    The format fo such a file is line oriented where empty lines and
1425    lines starting with a hash mark are ignored.  All other lines are
1426    assumed to be colon seprated with these fields:
1427
1428    1. field: Hostname
1429    2. field: Portnumber
1430    3. field: Username
1431    4. field: Password
1432    5. field: Base DN
1433
1434 */
1435 #if USE_LDAP
1436 static ldap_server_t
1437 parse_ldapserver_file (const char* filename)
1438 {
1439   char buffer[1024];
1440   char *p;
1441   ldap_server_t server, serverstart, *serverend;
1442   int c;
1443   unsigned int lineno = 0;
1444   estream_t fp;
1445
1446   fp = es_fopen (filename, "r");
1447   if (!fp)
1448     {
1449       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1450       return NULL;
1451     }
1452
1453   serverstart = NULL;
1454   serverend = &serverstart;
1455   while (es_fgets (buffer, sizeof buffer, fp))
1456     {
1457       lineno++;
1458       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1459         {
1460           if (*buffer && es_feof (fp))
1461             ; /* Last line not terminated - continue. */
1462           else
1463             {
1464               log_error (_("%s:%u: line too long - skipped\n"),
1465                          filename, lineno);
1466               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1467                 ; /* Skip until end of line. */
1468               continue;
1469             }
1470         }
1471       /* Skip empty and comment lines.*/
1472       for (p=buffer; spacep (p); p++)
1473         ;
1474       if (!*p || *p == '\n' || *p == '#')
1475         continue;
1476
1477       /* Parse the colon separated fields. */
1478       server = ldapserver_parse_one (buffer, filename, lineno);
1479       if (server)
1480         {
1481           *serverend = server;
1482           serverend = &server->next;
1483         }
1484     }
1485
1486   if (es_ferror (fp))
1487     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1488   es_fclose (fp);
1489
1490   return serverstart;
1491 }
1492 #endif /*USE_LDAP*/
1493
1494 static fingerprint_list_t
1495 parse_ocsp_signer (const char *string)
1496 {
1497   gpg_error_t err;
1498   char *fname;
1499   estream_t fp;
1500   char line[256];
1501   char *p;
1502   fingerprint_list_t list, *list_tail, item;
1503   unsigned int lnr = 0;
1504   int c, i, j;
1505   int errflag = 0;
1506
1507
1508   /* Check whether this is not a filename and treat it as a direct
1509      fingerprint specification.  */
1510   if (!strpbrk (string, "/.~\\"))
1511     {
1512       item = xcalloc (1, sizeof *item);
1513       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1514         if ( string[i] != ':' )
1515           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1516       item->hexfpr[j] = 0;
1517       if (j != 40 || !(spacep (string+i) || !string[i]))
1518         {
1519           log_error (_("%s:%u: invalid fingerprint detected\n"),
1520                      "--ocsp-signer", 0);
1521           xfree (item);
1522           return NULL;
1523         }
1524       return item;
1525     }
1526
1527   /* Well, it is a filename.  */
1528   if (*string == '/' || (*string == '~' && string[1] == '/'))
1529     fname = make_filename (string, NULL);
1530   else
1531     {
1532       if (string[0] == '.' && string[1] == '/' )
1533         string += 2;
1534       fname = make_filename (gnupg_homedir (), string, NULL);
1535     }
1536
1537   fp = es_fopen (fname, "r");
1538   if (!fp)
1539     {
1540       err = gpg_error_from_syserror ();
1541       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1542       xfree (fname);
1543       return NULL;
1544     }
1545
1546   list = NULL;
1547   list_tail = &list;
1548   for (;;)
1549     {
1550       if (!es_fgets (line, DIM(line)-1, fp) )
1551         {
1552           if (!es_feof (fp))
1553             {
1554               err = gpg_error_from_syserror ();
1555               log_error (_("%s:%u: read error: %s\n"),
1556                          fname, lnr, gpg_strerror (err));
1557               errflag = 1;
1558             }
1559           es_fclose (fp);
1560           if (errflag)
1561             {
1562               while (list)
1563                 {
1564                   fingerprint_list_t tmp = list->next;
1565                   xfree (list);
1566                   list = tmp;
1567                 }
1568             }
1569           xfree (fname);
1570           return list; /* Ready.  */
1571         }
1572
1573       lnr++;
1574       if (!*line || line[strlen(line)-1] != '\n')
1575         {
1576           /* Eat until end of line. */
1577           while ( (c=es_getc (fp)) != EOF && c != '\n')
1578             ;
1579           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1580                            /* */: GPG_ERR_INCOMPLETE_LINE);
1581           log_error (_("%s:%u: read error: %s\n"),
1582                      fname, lnr, gpg_strerror (err));
1583           errflag = 1;
1584           continue;
1585         }
1586
1587       /* Allow for empty lines and spaces */
1588       for (p=line; spacep (p); p++)
1589         ;
1590       if (!*p || *p == '\n' || *p == '#')
1591         continue;
1592
1593       item = xcalloc (1, sizeof *item);
1594       *list_tail = item;
1595       list_tail = &item->next;
1596
1597       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1598         if ( p[i] != ':' )
1599           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1600       item->hexfpr[j] = 0;
1601       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1602         {
1603           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1604           errflag = 1;
1605         }
1606       i++;
1607       while (spacep (p+i))
1608         i++;
1609       if (p[i] && p[i] != '\n')
1610         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1611     }
1612   /*NOTREACHED*/
1613 }
1614
1615
1616
1617 \f
1618 /*
1619    Stuff used in daemon mode.
1620  */
1621
1622
1623
1624 /* Reread parts of the configuration.  Note, that this function is
1625    obviously not thread-safe and should only be called from the NPTH
1626    signal handler.
1627
1628    Fixme: Due to the way the argument parsing works, we create a
1629    memory leak here for all string type arguments.  There is currently
1630    no clean way to tell whether the memory for the argument has been
1631    allocated or points into the process' original arguments.  Unless
1632    we have a mechanism to tell this, we need to live on with this. */
1633 static void
1634 reread_configuration (void)
1635 {
1636   ARGPARSE_ARGS pargs;
1637   FILE *fp;
1638   unsigned int configlineno = 0;
1639   int dummy;
1640
1641   if (!opt.config_filename)
1642     return; /* No config file. */
1643
1644   fp = fopen (opt.config_filename, "r");
1645   if (!fp)
1646     {
1647       log_error (_("option file '%s': %s\n"),
1648                  opt.config_filename, strerror(errno) );
1649       return;
1650     }
1651
1652   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1653
1654   memset (&pargs, 0, sizeof pargs);
1655   dummy = 0;
1656   pargs.argc = &dummy;
1657   pargs.flags = 1;  /* do not remove the args */
1658   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1659     {
1660       if (pargs.r_opt < -1)
1661         pargs.err = 1; /* Print a warning. */
1662       else /* Try to parse this option - ignore unchangeable ones. */
1663         parse_rereadable_options (&pargs, 1);
1664     }
1665   fclose (fp);
1666
1667   set_debug ();
1668   set_tor_mode ();
1669 }
1670
1671
1672 /* A global function which allows us to trigger the reload stuff from
1673    other places.  */
1674 void
1675 dirmngr_sighup_action (void)
1676 {
1677   log_info (_("SIGHUP received - "
1678               "re-reading configuration and flushing caches\n"));
1679   reread_configuration ();
1680   cert_cache_deinit (0);
1681   crl_cache_deinit ();
1682   cert_cache_init ();
1683   crl_cache_init ();
1684 }
1685
1686
1687 /* This function is called if some network activity was done.  At this
1688  * point we know the we have a network and we can decide whether to
1689  * run scheduled background tasks soon.  The function should return
1690  * quickly and only trigger actions for another thread. */
1691 static void
1692 netactivity_action (void)
1693 {
1694   network_activity_seen = 1;
1695 }
1696
1697
1698 /* The signal handler. */
1699 #ifndef HAVE_W32_SYSTEM
1700 static void
1701 handle_signal (int signo)
1702 {
1703   switch (signo)
1704     {
1705     case SIGHUP:
1706       dirmngr_sighup_action ();
1707       break;
1708
1709     case SIGUSR1:
1710       cert_cache_print_stats ();
1711       break;
1712
1713     case SIGUSR2:
1714       log_info (_("SIGUSR2 received - no action defined\n"));
1715       break;
1716
1717     case SIGTERM:
1718       if (!shutdown_pending)
1719         log_info (_("SIGTERM received - shutting down ...\n"));
1720       else
1721         log_info (_("SIGTERM received - still %d active connections\n"),
1722                   active_connections);
1723       shutdown_pending++;
1724       if (shutdown_pending > 2)
1725         {
1726           log_info (_("shutdown forced\n"));
1727           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1728           cleanup ();
1729           dirmngr_exit (0);
1730         }
1731       break;
1732
1733     case SIGINT:
1734       log_info (_("SIGINT received - immediate shutdown\n"));
1735       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1736       cleanup ();
1737       dirmngr_exit (0);
1738       break;
1739
1740     default:
1741       log_info (_("signal %d received - no action defined\n"), signo);
1742     }
1743 }
1744 #endif /*!HAVE_W32_SYSTEM*/
1745
1746
1747 /* Thread to do the housekeeping.  */
1748 static void *
1749 housekeeping_thread (void *arg)
1750 {
1751   static int sentinel;
1752   time_t curtime;
1753   struct server_control_s ctrlbuf;
1754
1755   (void)arg;
1756
1757   curtime = gnupg_get_time ();
1758   if (sentinel)
1759     {
1760       log_info ("housekeeping is already going on\n");
1761       return NULL;
1762     }
1763   sentinel++;
1764   if (opt.verbose > 1)
1765     log_info ("starting housekeeping\n");
1766
1767   memset (&ctrlbuf, 0, sizeof ctrlbuf);
1768   dirmngr_init_default_ctrl (&ctrlbuf);
1769
1770   ks_hkp_housekeeping (curtime);
1771   if (network_activity_seen)
1772     {
1773       network_activity_seen = 0;
1774       if (opt.use_tor || opt.allow_version_check)
1775         dirmngr_load_swdb (&ctrlbuf, 0);
1776     }
1777
1778   dirmngr_deinit_default_ctrl (&ctrlbuf);
1779
1780   if (opt.verbose > 1)
1781     log_info ("ready with housekeeping\n");
1782   sentinel--;
1783   return NULL;
1784
1785 }
1786
1787
1788 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1789 # pragma GCC push_options
1790 # pragma GCC optimize ("no-strict-overflow")
1791 #endif
1792 static int
1793 time_for_housekeeping_p (time_t curtime)
1794 {
1795   static time_t last_housekeeping;
1796
1797   if (!last_housekeeping)
1798     last_housekeeping = curtime;
1799
1800   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1801       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1802     {
1803       last_housekeeping = curtime;
1804       return 1;
1805     }
1806   return 0;
1807 }
1808 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1809 # pragma GCC pop_options
1810 #endif
1811
1812
1813 /* This is the worker for the ticker.  It is called every few seconds
1814    and may only do fast operations. */
1815 static void
1816 handle_tick (void)
1817 {
1818   if (time_for_housekeeping_p (gnupg_get_time ()))
1819     {
1820       npth_t thread;
1821       npth_attr_t tattr;
1822       int err;
1823
1824       err = npth_attr_init (&tattr);
1825       if (err)
1826         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
1827       else
1828         {
1829           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1830           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
1831           if (err)
1832             log_error ("error spawning housekeeping thread: %s\n",
1833                        strerror (err));
1834           npth_attr_destroy (&tattr);
1835         }
1836     }
1837 }
1838
1839
1840 /* Check the nonce on a new connection.  This is a NOP unless we are
1841    using our Unix domain socket emulation under Windows.  */
1842 static int
1843 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1844 {
1845   if (assuan_sock_check_nonce (fd, nonce))
1846     {
1847       log_info (_("error reading nonce on fd %d: %s\n"),
1848                 FD2INT (fd), strerror (errno));
1849       assuan_sock_close (fd);
1850       return -1;
1851     }
1852   else
1853     return 0;
1854 }
1855
1856
1857 /* Helper to call a connection's main function. */
1858 static void *
1859 start_connection_thread (void *arg)
1860 {
1861   union int_and_ptr_u argval;
1862   gnupg_fd_t fd;
1863
1864   memset (&argval, 0, sizeof argval);
1865   argval.aptr = arg;
1866   fd = argval.afd;
1867
1868   if (check_nonce (fd, &socket_nonce))
1869     {
1870       log_error ("handler nonce check FAILED\n");
1871       return NULL;
1872     }
1873
1874 #ifndef HAVE_W32_SYSTEM
1875   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1876 #endif
1877
1878   active_connections++;
1879   if (opt.verbose)
1880     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1881
1882   start_command_handler (fd);
1883
1884   if (opt.verbose)
1885     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1886   active_connections--;
1887
1888 #ifndef HAVE_W32_SYSTEM
1889   argval.afd = ASSUAN_INVALID_FD;
1890   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1891 #endif
1892
1893   return NULL;
1894 }
1895
1896
1897 #ifdef HAVE_INOTIFY_INIT
1898 /* Read an inotify event and return true if it matches NAME.  */
1899 static int
1900 my_inotify_is_name (int fd, const char *name)
1901 {
1902   union {
1903     struct inotify_event ev;
1904     char _buf[sizeof (struct inotify_event) + 100 + 1];
1905   } buf;
1906   int n;
1907   const char *s;
1908
1909   s = strrchr (name, '/');
1910   if (s && s[1])
1911     name = s + 1;
1912
1913   n = npth_read (fd, &buf, sizeof buf);
1914   if (n < sizeof (struct inotify_event))
1915     return 0;
1916   if (buf.ev.len < strlen (name)+1)
1917     return 0;
1918   if (strcmp (buf.ev.name, name))
1919     return 0; /* Not the desired file.  */
1920
1921   return 1; /* Found.  */
1922 }
1923 #endif /*HAVE_INOTIFY_INIT*/
1924
1925
1926 /* Main loop in daemon mode.  Note that LISTEN_FD will be owned by
1927  * this function. */
1928 static void
1929 handle_connections (assuan_fd_t listen_fd)
1930 {
1931   npth_attr_t tattr;
1932 #ifndef HAVE_W32_SYSTEM
1933   int signo;
1934 #endif
1935   struct sockaddr_un paddr;
1936   socklen_t plen = sizeof( paddr );
1937   gnupg_fd_t fd;
1938   int nfd, ret;
1939   fd_set fdset, read_fdset;
1940   struct timespec abstime;
1941   struct timespec curtime;
1942   struct timespec timeout;
1943   int saved_errno;
1944   int my_inotify_fd = -1;
1945
1946   npth_attr_init (&tattr);
1947   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1948
1949 #ifndef HAVE_W32_SYSTEM /* FIXME */
1950   npth_sigev_init ();
1951   npth_sigev_add (SIGHUP);
1952   npth_sigev_add (SIGUSR1);
1953   npth_sigev_add (SIGUSR2);
1954   npth_sigev_add (SIGINT);
1955   npth_sigev_add (SIGTERM);
1956   npth_sigev_fini ();
1957 #endif
1958
1959 #ifdef HAVE_INOTIFY_INIT
1960   if (disable_check_own_socket)
1961     my_inotify_fd = -1;
1962   else if ((my_inotify_fd = inotify_init ()) == -1)
1963     log_info ("error enabling fast daemon termination: %s\n",
1964               strerror (errno));
1965   else
1966     {
1967       /* We need to watch the directory for the file because there
1968        * won't be an IN_DELETE_SELF for a socket file.  */
1969       char *slash = strrchr (socket_name, '/');
1970       log_assert (slash && slash[1]);
1971       *slash = 0;
1972       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
1973         {
1974           close (my_inotify_fd);
1975           my_inotify_fd = -1;
1976         }
1977       *slash = '/';
1978     }
1979 #endif /*HAVE_INOTIFY_INIT*/
1980
1981
1982   /* Setup the fdset.  It has only one member.  This is because we use
1983      pth_select instead of pth_accept to properly sync timeouts with
1984      to full second.  */
1985   FD_ZERO (&fdset);
1986   FD_SET (FD2INT (listen_fd), &fdset);
1987   nfd = FD2INT (listen_fd);
1988   if (my_inotify_fd != -1)
1989     {
1990       FD_SET (my_inotify_fd, &fdset);
1991       if (my_inotify_fd > nfd)
1992         nfd = my_inotify_fd;
1993     }
1994
1995   npth_clock_gettime (&abstime);
1996   abstime.tv_sec += TIMERTICK_INTERVAL;
1997
1998   /* Main loop.  */
1999   for (;;)
2000     {
2001       /* Shutdown test.  */
2002       if (shutdown_pending)
2003         {
2004           if (!active_connections)
2005             break; /* ready */
2006
2007           /* Do not accept new connections but keep on running the
2008            * loop to cope with the timer events.
2009            *
2010            * Note that we do not close the listening socket because a
2011            * client trying to connect to that socket would instead
2012            * restart a new dirmngr instance - which is unlikely the
2013            * intention of a shutdown. */
2014           /* assuan_sock_close (listen_fd); */
2015           /* listen_fd = -1; */
2016           FD_ZERO (&fdset);
2017           nfd = -1;
2018           if (my_inotify_fd != -1)
2019             {
2020               FD_SET (my_inotify_fd, &fdset);
2021               nfd = my_inotify_fd;
2022             }
2023         }
2024
2025       /* Take a copy of the fdset.  */
2026       read_fdset = fdset;
2027
2028       npth_clock_gettime (&curtime);
2029       if (!(npth_timercmp (&curtime, &abstime, <)))
2030         {
2031           /* Timeout.  */
2032           handle_tick ();
2033           npth_clock_gettime (&abstime);
2034           abstime.tv_sec += TIMERTICK_INTERVAL;
2035         }
2036       npth_timersub (&abstime, &curtime, &timeout);
2037
2038 #ifndef HAVE_W32_SYSTEM
2039       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout, npth_sigev_sigmask());
2040       saved_errno = errno;
2041
2042       while (npth_sigev_get_pending(&signo))
2043         handle_signal (signo);
2044 #else
2045       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2046       saved_errno = errno;
2047 #endif
2048
2049       if (ret == -1 && saved_errno != EINTR)
2050         {
2051           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2052                      strerror (saved_errno));
2053           npth_sleep (1);
2054           continue;
2055         }
2056
2057       if (ret <= 0)
2058         {
2059           /* Interrupt or timeout.  Will be handled when calculating the
2060              next timeout.  */
2061           continue;
2062         }
2063
2064       if (shutdown_pending)
2065         {
2066           /* Do not anymore accept connections.  */
2067           continue;
2068         }
2069
2070 #ifdef HAVE_INOTIFY_INIT
2071       if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2072           && my_inotify_is_name (my_inotify_fd, socket_name))
2073         {
2074           shutdown_pending = 1;
2075           log_info ("socket file has been removed - shutting down\n");
2076         }
2077 #endif /*HAVE_INOTIFY_INIT*/
2078
2079       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
2080         {
2081           plen = sizeof paddr;
2082           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2083                                     (struct sockaddr *)&paddr, &plen));
2084           if (fd == GNUPG_INVALID_FD)
2085             {
2086               log_error ("accept failed: %s\n", strerror (errno));
2087             }
2088           else
2089             {
2090               char threadname[50];
2091               union int_and_ptr_u argval;
2092               npth_t thread;
2093
2094               memset (&argval, 0, sizeof argval);
2095               argval.afd = fd;
2096               snprintf (threadname, sizeof threadname,
2097                         "conn fd=%d", FD2INT(fd));
2098
2099               ret = npth_create (&thread, &tattr,
2100                                  start_connection_thread, argval.aptr);
2101               if (ret)
2102                 {
2103                   log_error ("error spawning connection handler: %s\n",
2104                              strerror (ret) );
2105                   assuan_sock_close (fd);
2106                 }
2107               npth_setname_np (thread, threadname);
2108             }
2109           fd = GNUPG_INVALID_FD;
2110         }
2111     }
2112
2113 #ifdef HAVE_INOTIFY_INIT
2114   if (my_inotify_fd != -1)
2115     close (my_inotify_fd);
2116 #endif /*HAVE_INOTIFY_INIT*/
2117   npth_attr_destroy (&tattr);
2118   if (listen_fd != -1)
2119     assuan_sock_close (fd);
2120   cleanup ();
2121   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2122 }
2123
2124 const char*
2125 dirmngr_get_current_socket_name (void)
2126 {
2127   if (socket_name)
2128     return socket_name;
2129   else
2130     return dirmngr_socket_name ();
2131 }