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