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