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