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