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