gpg: Unify the the use of the print_pubkey_info functions.
[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 }
767
768
769 #ifndef HAVE_W32_SYSTEM
770 static int
771 pid_suffix_callback (unsigned long *r_suffix)
772 {
773   union int_and_ptr_u value;
774
775   memset (&value, 0, sizeof value);
776   value.aptr = npth_getspecific (my_tlskey_current_fd);
777   *r_suffix = value.aint;
778   return (*r_suffix != -1);  /* Use decimal representation.  */
779 }
780 #endif /*!HAVE_W32_SYSTEM*/
781
782 #if HTTP_USE_NTBTLS
783 static void
784 my_ntbtls_log_handler (void *opaque, int level, const char *fmt, va_list argv)
785 {
786   (void)opaque;
787
788   if (level == -1)
789     log_logv_prefix (GPGRT_LOGLVL_INFO, "ntbtls: ", fmt, argv);
790   else
791     {
792       char prefix[10+20];
793       snprintf (prefix, sizeof prefix, "ntbtls(%d): ", level);
794       log_logv_prefix (GPGRT_LOGLVL_DEBUG, prefix, fmt, argv);
795     }
796 }
797 #endif
798
799
800 static void
801 thread_init (void)
802 {
803   npth_init ();
804   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
805   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
806
807   /* Now with NPth running we can set the logging callback.  Our
808      windows implementation does not yet feature the NPth TLS
809      functions.  */
810 #ifndef HAVE_W32_SYSTEM
811   if (npth_key_create (&my_tlskey_current_fd, NULL) == 0)
812     if (npth_setspecific (my_tlskey_current_fd, NULL) == 0)
813       log_set_pid_suffix_cb (pid_suffix_callback);
814 #endif /*!HAVE_W32_SYSTEM*/
815 }
816
817
818 int
819 main (int argc, char **argv)
820 {
821   enum cmd_and_opt_values cmd = 0;
822   ARGPARSE_ARGS pargs;
823   int orig_argc;
824   char **orig_argv;
825   FILE *configfp = NULL;
826   char *configname = NULL;
827   const char *shell;
828   unsigned configlineno;
829   int parse_debug = 0;
830   int default_config =1;
831   int greeting = 0;
832   int nogreeting = 0;
833   int nodetach = 0;
834   int csh_style = 0;
835   char *logfile = NULL;
836 #if USE_LDAP
837   char *ldapfile = NULL;
838 #endif /*USE_LDAP*/
839   int debug_wait = 0;
840   int rc;
841   struct assuan_malloc_hooks malloc_hooks;
842
843   early_system_init ();
844   set_strusage (my_strusage);
845   log_set_prefix (DIRMNGR_NAME, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_PID);
846
847   /* Make sure that our subsystems are ready.  */
848   i18n_init ();
849   init_common_subsystems (&argc, &argv);
850
851   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
852
853  /* Check that the libraries are suitable.  Do it here because
854     the option parsing may need services of the libraries. */
855   if (!ksba_check_version (NEED_KSBA_VERSION) )
856     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
857                NEED_KSBA_VERSION, ksba_check_version (NULL) );
858
859   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
860   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
861
862   /* Init TLS library.  */
863 #if HTTP_USE_NTBTLS
864   if (!ntbtls_check_version (NEED_NTBTLS_VERSION) )
865     log_fatal( _("%s is too old (need %s, have %s)\n"), "ntbtls",
866                NEED_NTBTLS_VERSION, ntbtls_check_version (NULL) );
867 #elif HTTP_USE_GNUTLS
868   rc = gnutls_global_init ();
869   if (rc)
870     log_fatal ("gnutls_global_init failed: %s\n", gnutls_strerror (rc));
871 #endif /*HTTP_USE_GNUTLS*/
872
873   /* Init Assuan. */
874   malloc_hooks.malloc = gcry_malloc;
875   malloc_hooks.realloc = gcry_realloc;
876   malloc_hooks.free = gcry_free;
877   assuan_set_malloc_hooks (&malloc_hooks);
878   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
879   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
880   assuan_sock_init ();
881   setup_libassuan_logging (&opt.debug, dirmngr_assuan_log_monitor);
882
883   setup_libgcrypt_logging ();
884
885 #if HTTP_USE_NTBTLS
886   ntbtls_set_log_handler (my_ntbtls_log_handler, NULL);
887 #endif
888
889   /* Setup defaults. */
890   shell = getenv ("SHELL");
891   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
892     csh_style = 1;
893
894   /* Reset rereadable options to default values. */
895   parse_rereadable_options (NULL, 0);
896
897   /* Default TCP timeouts.  */
898   opt.connect_timeout = DEFAULT_CONNECT_TIMEOUT;
899   opt.connect_quick_timeout = DEFAULT_CONNECT_QUICK_TIMEOUT;
900
901   /* LDAP defaults.  */
902   opt.add_new_ldapservers = 0;
903   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
904
905   /* Other defaults.  */
906
907   /* Check whether we have a config file given on the commandline */
908   orig_argc = argc;
909   orig_argv = argv;
910   pargs.argc = &argc;
911   pargs.argv = &argv;
912   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
913   while (arg_parse( &pargs, opts))
914     {
915       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
916         parse_debug++;
917       else if (pargs.r_opt == oOptions)
918         { /* Yes there is one, so we do not try the default one, but
919              read the option file when it is encountered at the
920              commandline */
921           default_config = 0;
922         }
923       else if (pargs.r_opt == oNoOptions)
924         default_config = 0; /* --no-options */
925       else if (pargs.r_opt == oHomedir)
926         {
927           gnupg_set_homedir (pargs.r.ret_str);
928         }
929     }
930
931   socket_name = dirmngr_socket_name ();
932   if (default_config)
933     configname = make_filename (gnupg_homedir (), DIRMNGR_NAME".conf", NULL );
934
935   argc = orig_argc;
936   argv = orig_argv;
937   pargs.argc = &argc;
938   pargs.argv = &argv;
939   pargs.flags= 1;  /* do not remove the args */
940  next_pass:
941   if (configname)
942     {
943       configlineno = 0;
944       configfp = fopen (configname, "r");
945       if (!configfp)
946         {
947           if (default_config)
948             {
949               if( parse_debug )
950                 log_info (_("Note: no default option file '%s'\n"),
951                           configname );
952             }
953           else
954             {
955               log_error (_("option file '%s': %s\n"),
956                          configname, strerror(errno) );
957               exit(2);
958             }
959           xfree (configname);
960           configname = NULL;
961         }
962       if (parse_debug && configname )
963         log_info (_("reading options from '%s'\n"), configname );
964       default_config = 0;
965     }
966
967   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
968     {
969       if (parse_rereadable_options (&pargs, 0))
970         continue; /* Already handled */
971       switch (pargs.r_opt)
972         {
973         case aServer:
974         case aDaemon:
975         case aSupervised:
976         case aShutdown:
977         case aFlush:
978         case aListCRLs:
979         case aLoadCRL:
980         case aFetchCRL:
981         case aGPGConfList:
982         case aGPGConfTest:
983           cmd = pargs.r_opt;
984           break;
985
986         case oQuiet: opt.quiet = 1; break;
987         case oVerbose: opt.verbose++; break;
988         case oBatch: opt.batch=1; break;
989
990         case oDebugWait: debug_wait = pargs.r.ret_int; break;
991
992         case oOptions:
993           /* Config files may not be nested (silently ignore them) */
994           if (!configfp)
995             {
996                 xfree(configname);
997                 configname = xstrdup(pargs.r.ret_str);
998                 goto next_pass;
999             }
1000           break;
1001         case oNoGreeting: nogreeting = 1; break;
1002         case oNoVerbose: opt.verbose = 0; break;
1003         case oNoOptions: break; /* no-options */
1004         case oHomedir: /* Ignore this option here. */; break;
1005         case oNoDetach: nodetach = 1; break;
1006         case oLogFile: logfile = pargs.r.ret_str; break;
1007         case oCsh: csh_style = 1; break;
1008         case oSh: csh_style = 0; break;
1009         case oLDAPFile:
1010 #        if USE_LDAP
1011           ldapfile = pargs.r.ret_str;
1012 #        endif /*USE_LDAP*/
1013           break;
1014         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
1015         case oLDAPTimeout:
1016           opt.ldaptimeout = pargs.r.ret_int;
1017           break;
1018
1019         case oFakedSystemTime:
1020           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
1021           break;
1022
1023         case oForce: opt.force = 1; break;
1024
1025         case oSocketName: socket_name = pargs.r.ret_str; break;
1026
1027         case oListenBacklog:
1028           listen_backlog = pargs.r.ret_int;
1029           break;
1030
1031         default : pargs.err = configfp? 1:2; break;
1032         }
1033     }
1034   if (configfp)
1035     {
1036       fclose (configfp);
1037       configfp = NULL;
1038       /* Keep a copy of the name so that it can be read on SIGHUP. */
1039       opt.config_filename = configname;
1040       configname = NULL;
1041       goto next_pass;
1042     }
1043   xfree (configname);
1044   configname = NULL;
1045   if (log_get_errorcount(0))
1046     exit(2);
1047   if (nogreeting )
1048     greeting = 0;
1049
1050   if (!opt.homedir_cache)
1051     opt.homedir_cache = xstrdup (gnupg_homedir ());
1052
1053   if (greeting)
1054     {
1055       es_fprintf (es_stderr, "%s %s; %s\n",
1056                   strusage(11), strusage(13), strusage(14) );
1057       es_fprintf (es_stderr, "%s\n", strusage(15) );
1058     }
1059
1060 #ifdef IS_DEVELOPMENT_VERSION
1061   log_info ("NOTE: this is a development version!\n");
1062 #endif
1063
1064   /* Print a warning if an argument looks like an option.  */
1065   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1066     {
1067       int i;
1068
1069       for (i=0; i < argc; i++)
1070         if (argv[i][0] == '-' && argv[i][1] == '-')
1071           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1072     }
1073
1074   if (!access ("/etc/"DIRMNGR_NAME, F_OK)
1075       && !strncmp (gnupg_homedir (), "/etc/", 5))
1076     log_info
1077       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
1078        " other directory names changed.  Please check that no other version"
1079        " of dirmngr is still installed.  To disable this warning, remove the"
1080        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
1081
1082   if (gnupg_faked_time_p ())
1083     {
1084       gnupg_isotime_t tbuf;
1085
1086       log_info (_("WARNING: running with faked system time: "));
1087       gnupg_get_isotime (tbuf);
1088       dump_isotime (tbuf);
1089       log_printf ("\n");
1090     }
1091
1092   /* Note that we do not run set_tor_mode in --gpgconf-list mode
1093    * because it will attempt to connect to the tor client and that can
1094    * be time consuming.  */
1095   post_option_parsing ();
1096   if (cmd != aGPGConfTest && cmd != aGPGConfList)
1097     set_tor_mode ();
1098
1099   /* Get LDAP server list from file. */
1100 #if USE_LDAP
1101   if (!ldapfile)
1102     {
1103       ldapfile = make_filename (gnupg_homedir (),
1104                                 "dirmngr_ldapservers.conf",
1105                                 NULL);
1106       opt.ldapservers = parse_ldapserver_file (ldapfile);
1107       xfree (ldapfile);
1108     }
1109   else
1110       opt.ldapservers = parse_ldapserver_file (ldapfile);
1111 #endif /*USE_LDAP*/
1112
1113 #ifndef HAVE_W32_SYSTEM
1114   /* We need to ignore the PIPE signal because the we might log to a
1115      socket and that code handles EPIPE properly.  The ldap wrapper
1116      also requires us to ignore this silly signal. Assuan would set
1117      this signal to ignore anyway.*/
1118   signal (SIGPIPE, SIG_IGN);
1119 #endif
1120
1121   /* Ready.  Now to our duties. */
1122   if (!cmd)
1123     cmd = aServer;
1124   rc = 0;
1125
1126   if (cmd == aServer)
1127     {
1128       /* Note that this server mode is mainly useful for debugging.  */
1129       if (argc)
1130         wrong_args ("--server");
1131
1132       if (logfile)
1133         {
1134           log_set_file (logfile);
1135           log_set_prefix (NULL, GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
1136         }
1137
1138       if (debug_wait)
1139         {
1140           log_debug ("waiting for debugger - my pid is %u .....\n",
1141                      (unsigned int)getpid());
1142           gnupg_sleep (debug_wait);
1143           log_debug ("... okay\n");
1144         }
1145
1146
1147       thread_init ();
1148       cert_cache_init (hkp_cacert_filenames);
1149       crl_cache_init ();
1150       ks_hkp_init ();
1151       http_register_netactivity_cb (netactivity_action);
1152       start_command_handler (ASSUAN_INVALID_FD, 0);
1153       shutdown_reaper ();
1154     }
1155 #ifndef HAVE_W32_SYSTEM
1156   else if (cmd == aSupervised)
1157     {
1158       /* In supervised mode, we expect file descriptor 3 to be an
1159          already opened, listening socket.
1160
1161          We will also not detach from the controlling process or close
1162          stderr; the supervisor should handle all of that.  */
1163       struct stat statbuf;
1164       if (fstat (3, &statbuf) == -1 && errno == EBADF)
1165         {
1166           log_error ("file descriptor 3 must be validin --supervised mode\n");
1167           dirmngr_exit (1);
1168         }
1169       socket_name = gnupg_get_socket_name (3);
1170
1171       /* Now start with logging to a file if this is desired. */
1172       if (logfile)
1173         {
1174           log_set_file (logfile);
1175           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1176                                  |GPGRT_LOG_WITH_TIME
1177                                  |GPGRT_LOG_WITH_PID));
1178           current_logfile = xstrdup (logfile);
1179         }
1180       else
1181         log_set_prefix (NULL, 0);
1182
1183       thread_init ();
1184       cert_cache_init (hkp_cacert_filenames);
1185       crl_cache_init ();
1186       ks_hkp_init ();
1187       http_register_netactivity_cb (netactivity_action);
1188       handle_connections (3);
1189       shutdown_reaper ();
1190     }
1191 #endif /*HAVE_W32_SYSTEM*/
1192   else if (cmd == aDaemon)
1193     {
1194       assuan_fd_t fd;
1195       pid_t pid;
1196       int len;
1197       struct sockaddr_un serv_addr;
1198
1199       if (argc)
1200         wrong_args ("--daemon");
1201
1202       /* Now start with logging to a file if this is desired. */
1203       if (logfile)
1204         {
1205           log_set_file (logfile);
1206           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1207                                  |GPGRT_LOG_WITH_TIME
1208                                  |GPGRT_LOG_WITH_PID));
1209           current_logfile = xstrdup (logfile);
1210         }
1211
1212       if (debug_wait)
1213         {
1214           log_debug ("waiting for debugger - my pid is %u .....\n",
1215                      (unsigned int)getpid());
1216           gnupg_sleep (debug_wait);
1217           log_debug ("... okay\n");
1218         }
1219
1220 #ifndef HAVE_W32_SYSTEM
1221       if (strchr (socket_name, ':'))
1222         {
1223           log_error (_("colons are not allowed in the socket name\n"));
1224           dirmngr_exit (1);
1225         }
1226 #endif
1227       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1228       if (fd == ASSUAN_INVALID_FD)
1229         {
1230           log_error (_("can't create socket: %s\n"), strerror (errno));
1231           cleanup ();
1232           dirmngr_exit (1);
1233         }
1234
1235       {
1236         int redirected;
1237
1238         if (assuan_sock_set_sockaddr_un (socket_name,
1239                                          (struct sockaddr*)&serv_addr,
1240                                          &redirected))
1241           {
1242             if (errno == ENAMETOOLONG)
1243               log_error (_("socket name '%s' is too long\n"), socket_name);
1244             else
1245               log_error ("error preparing socket '%s': %s\n",
1246                          socket_name,
1247                          gpg_strerror (gpg_error_from_syserror ()));
1248             dirmngr_exit (1);
1249           }
1250         if (redirected)
1251           {
1252             redir_socket_name = xstrdup (serv_addr.sun_path);
1253             if (opt.verbose)
1254               log_info ("redirecting socket '%s' to '%s'\n",
1255                         socket_name, redir_socket_name);
1256           }
1257       }
1258
1259       len = SUN_LEN (&serv_addr);
1260
1261       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1262       if (rc == -1
1263           && (errno == EADDRINUSE
1264 #ifdef HAVE_W32_SYSTEM
1265               || errno == EEXIST
1266 #endif
1267               ))
1268         {
1269           /* Fixme: We should test whether a dirmngr is already running. */
1270           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1271           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1272         }
1273       if (rc != -1
1274           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1275         log_error (_("error getting nonce for the socket\n"));
1276       if (rc == -1)
1277         {
1278           log_error (_("error binding socket to '%s': %s\n"),
1279                      serv_addr.sun_path,
1280                      gpg_strerror (gpg_error_from_errno (errno)));
1281           assuan_sock_close (fd);
1282           dirmngr_exit (1);
1283         }
1284       cleanup_socket = 1;
1285
1286       if (gnupg_chmod (serv_addr.sun_path, "-rwx"))
1287         log_error (_("can't set permissions of '%s': %s\n"),
1288                    serv_addr.sun_path, strerror (errno));
1289
1290       if (listen (FD2INT (fd), listen_backlog) == -1)
1291         {
1292           log_error ("listen(fd,%d) failed: %s\n",
1293                      listen_backlog, strerror (errno));
1294           assuan_sock_close (fd);
1295           dirmngr_exit (1);
1296         }
1297
1298       if (opt.verbose)
1299         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1300
1301       es_fflush (NULL);
1302
1303       /* Note: We keep the dirmngr_info output only for the sake of
1304          existing scripts which might use this to detect a successful
1305          start of the dirmngr.  */
1306 #ifdef HAVE_W32_SYSTEM
1307       (void)csh_style;
1308       (void)nodetach;
1309
1310       pid = getpid ();
1311       es_printf ("set %s=%s;%lu;1\n",
1312                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1313 #else
1314       pid = fork();
1315       if (pid == (pid_t)-1)
1316         {
1317           log_fatal (_("error forking process: %s\n"), strerror (errno));
1318           dirmngr_exit (1);
1319         }
1320
1321       if (pid)
1322         { /* We are the parent */
1323           char *infostr;
1324
1325           /* Don't let cleanup() remove the socket - the child is
1326              responsible for doing that.  */
1327           cleanup_socket = 0;
1328
1329           close (fd);
1330
1331           /* Create the info string: <name>:<pid>:<protocol_version> */
1332           if (asprintf (&infostr, "%s=%s:%lu:1",
1333                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1334             {
1335               log_error (_("out of core\n"));
1336               kill (pid, SIGTERM);
1337               dirmngr_exit (1);
1338             }
1339           /* Print the environment string, so that the caller can use
1340              shell's eval to set it.  But see above.  */
1341           if (csh_style)
1342             {
1343               *strchr (infostr, '=') = ' ';
1344               es_printf ( "setenv %s;\n", infostr);
1345             }
1346           else
1347             {
1348               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1349             }
1350           free (infostr);
1351           exit (0);
1352           /*NEVER REACHED*/
1353         } /* end parent */
1354
1355
1356       /*
1357          This is the child
1358        */
1359
1360       /* Detach from tty and put process into a new session */
1361       if (!nodetach )
1362         {
1363           int i;
1364           unsigned int oldflags;
1365
1366           /* Close stdin, stdout and stderr unless it is the log stream */
1367           for (i=0; i <= 2; i++)
1368             {
1369               if (!log_test_fd (i) && i != fd )
1370                 {
1371                   if ( !close (i)
1372                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1373                     {
1374                       log_error ("failed to open '%s': %s\n",
1375                                  "/dev/null", strerror (errno));
1376                       cleanup ();
1377                       dirmngr_exit (1);
1378                     }
1379                 }
1380             }
1381
1382           if (setsid() == -1)
1383             {
1384               log_error ("setsid() failed: %s\n", strerror(errno) );
1385               dirmngr_exit (1);
1386             }
1387
1388           log_get_prefix (&oldflags);
1389           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1390           opt.running_detached = 1;
1391
1392         }
1393 #endif
1394
1395       if (!nodetach )
1396         {
1397           if (gnupg_chdir (gnupg_daemon_rootdir ()))
1398             {
1399               log_error ("chdir to '%s' failed: %s\n",
1400                          gnupg_daemon_rootdir (), strerror (errno));
1401               dirmngr_exit (1);
1402             }
1403         }
1404
1405       thread_init ();
1406       cert_cache_init (hkp_cacert_filenames);
1407       crl_cache_init ();
1408       ks_hkp_init ();
1409       http_register_netactivity_cb (netactivity_action);
1410       handle_connections (fd);
1411       shutdown_reaper ();
1412     }
1413   else if (cmd == aListCRLs)
1414     {
1415       /* Just list the CRL cache and exit. */
1416       if (argc)
1417         wrong_args ("--list-crls");
1418       crl_cache_init ();
1419       crl_cache_list (es_stdout);
1420     }
1421   else if (cmd == aLoadCRL)
1422     {
1423       struct server_control_s ctrlbuf;
1424
1425       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1426       dirmngr_init_default_ctrl (&ctrlbuf);
1427
1428       thread_init ();
1429       cert_cache_init (hkp_cacert_filenames);
1430       crl_cache_init ();
1431       ks_hkp_init ();
1432       if (!argc)
1433         rc = crl_cache_load (&ctrlbuf, NULL);
1434       else
1435         {
1436           for (; !rc && argc; argc--, argv++)
1437             rc = crl_cache_load (&ctrlbuf, *argv);
1438         }
1439       dirmngr_deinit_default_ctrl (&ctrlbuf);
1440     }
1441   else if (cmd == aFetchCRL)
1442     {
1443       ksba_reader_t reader;
1444       struct server_control_s ctrlbuf;
1445
1446       if (argc != 1)
1447         wrong_args ("--fetch-crl URL");
1448
1449       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1450       dirmngr_init_default_ctrl (&ctrlbuf);
1451
1452       thread_init ();
1453       cert_cache_init (hkp_cacert_filenames);
1454       crl_cache_init ();
1455       ks_hkp_init ();
1456       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1457       if (rc)
1458         log_error (_("fetching CRL from '%s' failed: %s\n"),
1459                      argv[0], gpg_strerror (rc));
1460       else
1461         {
1462           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1463           if (rc)
1464             log_error (_("processing CRL from '%s' failed: %s\n"),
1465                        argv[0], gpg_strerror (rc));
1466           crl_close_reader (reader);
1467         }
1468       dirmngr_deinit_default_ctrl (&ctrlbuf);
1469     }
1470   else if (cmd == aFlush)
1471     {
1472       /* Delete cache and exit. */
1473       if (argc)
1474         wrong_args ("--flush");
1475       rc = crl_cache_flush();
1476     }
1477   else if (cmd == aGPGConfTest)
1478     dirmngr_exit (0);
1479   else if (cmd == aGPGConfList)
1480     {
1481       unsigned long flags = 0;
1482       char *filename;
1483       char *filename_esc;
1484
1485       /* First the configuration file.  This is not an option, but it
1486          is vital information for GPG Conf.  */
1487       if (!opt.config_filename)
1488         opt.config_filename = make_filename (gnupg_homedir (),
1489                                              "dirmngr.conf", NULL );
1490
1491       filename = percent_escape (opt.config_filename, NULL);
1492       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1493               GC_OPT_FLAG_DEFAULT, filename);
1494       xfree (filename);
1495
1496       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1497       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1498       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1499       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1500       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1501
1502       /* --csh and --sh are mutually exclusive, something we can not
1503          express in GPG Conf.  --options is only usable from the
1504          command line, really.  --debug-all interacts with --debug,
1505          and having both of them is thus problematic.  --no-detach is
1506          also only usable on the command line.  --batch is unused.  */
1507
1508       filename = make_filename (gnupg_homedir (),
1509                                 "dirmngr_ldapservers.conf",
1510                                 NULL);
1511       filename_esc = percent_escape (filename, NULL);
1512       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1513               filename_esc);
1514       xfree (filename_esc);
1515       xfree (filename);
1516
1517       es_printf ("ldaptimeout:%lu:%u\n",
1518               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1519       es_printf ("max-replies:%lu:%u\n",
1520               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1521       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1522       es_printf ("allow-version-check:%lu:\n", flags | GC_OPT_FLAG_NONE);
1523       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1524       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1525
1526       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1527       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1528
1529       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1530       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1531       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1532       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1533       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1534       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1535       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1536       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1537       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1538       /* Note: The next one is to fix a typo in gpgconf - should be
1539          removed eventually. */
1540       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1541
1542       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1543
1544       filename_esc = percent_escape (get_default_keyserver (0), NULL);
1545       es_printf ("keyserver:%lu:\"%s:\n", flags | GC_OPT_FLAG_DEFAULT,
1546                  filename_esc);
1547       xfree (filename_esc);
1548
1549
1550       es_printf ("nameserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1551       es_printf ("resolver-timeout:%lu:%u\n",
1552                  flags | GC_OPT_FLAG_DEFAULT, 0);
1553     }
1554   cleanup ();
1555   return !!rc;
1556 }
1557
1558
1559 static void
1560 cleanup (void)
1561 {
1562   crl_cache_deinit ();
1563   cert_cache_deinit (1);
1564   reload_dns_stuff (1);
1565
1566 #if USE_LDAP
1567   ldapserver_list_free (opt.ldapservers);
1568 #endif /*USE_LDAP*/
1569   opt.ldapservers = NULL;
1570
1571   if (cleanup_socket)
1572     {
1573       cleanup_socket = 0;
1574       if (redir_socket_name)
1575         gnupg_remove (redir_socket_name);
1576       else if (socket_name && *socket_name)
1577         gnupg_remove (socket_name);
1578     }
1579 }
1580
1581
1582 void
1583 dirmngr_exit (int rc)
1584 {
1585   cleanup ();
1586   exit (rc);
1587 }
1588
1589
1590 void
1591 dirmngr_init_default_ctrl (ctrl_t ctrl)
1592 {
1593   ctrl->magic = SERVER_CONTROL_MAGIC;
1594   if (opt.http_proxy)
1595     ctrl->http_proxy = xstrdup (opt.http_proxy);
1596   ctrl->http_no_crl = 1;
1597   ctrl->timeout = opt.connect_timeout;
1598 }
1599
1600
1601 void
1602 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1603 {
1604   if (!ctrl)
1605     return;
1606   ctrl->magic = 0xdeadbeef;
1607
1608   xfree (ctrl->http_proxy);
1609   ctrl->http_proxy = NULL;
1610 }
1611
1612
1613 /* Create a list of LDAP servers from the file FILENAME. Returns the
1614    list or NULL in case of errors.
1615
1616    The format fo such a file is line oriented where empty lines and
1617    lines starting with a hash mark are ignored.  All other lines are
1618    assumed to be colon seprated with these fields:
1619
1620    1. field: Hostname
1621    2. field: Portnumber
1622    3. field: Username
1623    4. field: Password
1624    5. field: Base DN
1625
1626 */
1627 #if USE_LDAP
1628 static ldap_server_t
1629 parse_ldapserver_file (const char* filename)
1630 {
1631   char buffer[1024];
1632   char *p;
1633   ldap_server_t server, serverstart, *serverend;
1634   int c;
1635   unsigned int lineno = 0;
1636   estream_t fp;
1637
1638   fp = es_fopen (filename, "r");
1639   if (!fp)
1640     {
1641       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1642       return NULL;
1643     }
1644
1645   serverstart = NULL;
1646   serverend = &serverstart;
1647   while (es_fgets (buffer, sizeof buffer, fp))
1648     {
1649       lineno++;
1650       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1651         {
1652           if (*buffer && es_feof (fp))
1653             ; /* Last line not terminated - continue. */
1654           else
1655             {
1656               log_error (_("%s:%u: line too long - skipped\n"),
1657                          filename, lineno);
1658               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1659                 ; /* Skip until end of line. */
1660               continue;
1661             }
1662         }
1663       /* Skip empty and comment lines.*/
1664       for (p=buffer; spacep (p); p++)
1665         ;
1666       if (!*p || *p == '\n' || *p == '#')
1667         continue;
1668
1669       /* Parse the colon separated fields. */
1670       server = ldapserver_parse_one (buffer, filename, lineno);
1671       if (server)
1672         {
1673           *serverend = server;
1674           serverend = &server->next;
1675         }
1676     }
1677
1678   if (es_ferror (fp))
1679     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1680   es_fclose (fp);
1681
1682   return serverstart;
1683 }
1684 #endif /*USE_LDAP*/
1685
1686 static fingerprint_list_t
1687 parse_ocsp_signer (const char *string)
1688 {
1689   gpg_error_t err;
1690   char *fname;
1691   estream_t fp;
1692   char line[256];
1693   char *p;
1694   fingerprint_list_t list, *list_tail, item;
1695   unsigned int lnr = 0;
1696   int c, i, j;
1697   int errflag = 0;
1698
1699
1700   /* Check whether this is not a filename and treat it as a direct
1701      fingerprint specification.  */
1702   if (!strpbrk (string, "/.~\\"))
1703     {
1704       item = xcalloc (1, sizeof *item);
1705       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1706         if ( string[i] != ':' )
1707           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1708       item->hexfpr[j] = 0;
1709       if (j != 40 || !(spacep (string+i) || !string[i]))
1710         {
1711           log_error (_("%s:%u: invalid fingerprint detected\n"),
1712                      "--ocsp-signer", 0);
1713           xfree (item);
1714           return NULL;
1715         }
1716       return item;
1717     }
1718
1719   /* Well, it is a filename.  */
1720   if (*string == '/' || (*string == '~' && string[1] == '/'))
1721     fname = make_filename (string, NULL);
1722   else
1723     {
1724       if (string[0] == '.' && string[1] == '/' )
1725         string += 2;
1726       fname = make_filename (gnupg_homedir (), string, NULL);
1727     }
1728
1729   fp = es_fopen (fname, "r");
1730   if (!fp)
1731     {
1732       err = gpg_error_from_syserror ();
1733       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1734       xfree (fname);
1735       return NULL;
1736     }
1737
1738   list = NULL;
1739   list_tail = &list;
1740   for (;;)
1741     {
1742       if (!es_fgets (line, DIM(line)-1, fp) )
1743         {
1744           if (!es_feof (fp))
1745             {
1746               err = gpg_error_from_syserror ();
1747               log_error (_("%s:%u: read error: %s\n"),
1748                          fname, lnr, gpg_strerror (err));
1749               errflag = 1;
1750             }
1751           es_fclose (fp);
1752           if (errflag)
1753             {
1754               while (list)
1755                 {
1756                   fingerprint_list_t tmp = list->next;
1757                   xfree (list);
1758                   list = tmp;
1759                 }
1760             }
1761           xfree (fname);
1762           return list; /* Ready.  */
1763         }
1764
1765       lnr++;
1766       if (!*line || line[strlen(line)-1] != '\n')
1767         {
1768           /* Eat until end of line. */
1769           while ( (c=es_getc (fp)) != EOF && c != '\n')
1770             ;
1771           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1772                            /* */: GPG_ERR_INCOMPLETE_LINE);
1773           log_error (_("%s:%u: read error: %s\n"),
1774                      fname, lnr, gpg_strerror (err));
1775           errflag = 1;
1776           continue;
1777         }
1778
1779       /* Allow for empty lines and spaces */
1780       for (p=line; spacep (p); p++)
1781         ;
1782       if (!*p || *p == '\n' || *p == '#')
1783         continue;
1784
1785       item = xcalloc (1, sizeof *item);
1786       *list_tail = item;
1787       list_tail = &item->next;
1788
1789       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1790         if ( p[i] != ':' )
1791           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1792       item->hexfpr[j] = 0;
1793       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1794         {
1795           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1796           errflag = 1;
1797         }
1798       i++;
1799       while (spacep (p+i))
1800         i++;
1801       if (p[i] && p[i] != '\n')
1802         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1803     }
1804   /*NOTREACHED*/
1805 }
1806
1807
1808
1809 \f
1810 /*
1811    Stuff used in daemon mode.
1812  */
1813
1814
1815
1816 /* Reread parts of the configuration.  Note, that this function is
1817    obviously not thread-safe and should only be called from the NPTH
1818    signal handler.
1819
1820    Fixme: Due to the way the argument parsing works, we create a
1821    memory leak here for all string type arguments.  There is currently
1822    no clean way to tell whether the memory for the argument has been
1823    allocated or points into the process' original arguments.  Unless
1824    we have a mechanism to tell this, we need to live on with this. */
1825 static void
1826 reread_configuration (void)
1827 {
1828   ARGPARSE_ARGS pargs;
1829   FILE *fp;
1830   unsigned int configlineno = 0;
1831   int dummy;
1832
1833   if (!opt.config_filename)
1834     return; /* No config file. */
1835
1836   fp = fopen (opt.config_filename, "r");
1837   if (!fp)
1838     {
1839       log_error (_("option file '%s': %s\n"),
1840                  opt.config_filename, strerror(errno) );
1841       return;
1842     }
1843
1844   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1845
1846   memset (&pargs, 0, sizeof pargs);
1847   dummy = 0;
1848   pargs.argc = &dummy;
1849   pargs.flags = 1;  /* do not remove the args */
1850   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1851     {
1852       if (pargs.r_opt < -1)
1853         pargs.err = 1; /* Print a warning. */
1854       else /* Try to parse this option - ignore unchangeable ones. */
1855         parse_rereadable_options (&pargs, 1);
1856     }
1857   fclose (fp);
1858
1859   post_option_parsing ();
1860 }
1861
1862
1863 /* A global function which allows us to trigger the reload stuff from
1864    other places.  */
1865 void
1866 dirmngr_sighup_action (void)
1867 {
1868   log_info (_("SIGHUP received - "
1869               "re-reading configuration and flushing caches\n"));
1870   reread_configuration ();
1871   set_tor_mode ();
1872   cert_cache_deinit (0);
1873   crl_cache_deinit ();
1874   cert_cache_init (hkp_cacert_filenames);
1875   crl_cache_init ();
1876   reload_dns_stuff (0);
1877   ks_hkp_reload ();
1878 }
1879
1880
1881 /* This function is called if some network activity was done.  At this
1882  * point we know the we have a network and we can decide whether to
1883  * run scheduled background tasks soon.  The function should return
1884  * quickly and only trigger actions for another thread. */
1885 static void
1886 netactivity_action (void)
1887 {
1888   network_activity_seen = 1;
1889 }
1890
1891
1892 /* The signal handler. */
1893 #ifndef HAVE_W32_SYSTEM
1894 static void
1895 handle_signal (int signo)
1896 {
1897   switch (signo)
1898     {
1899     case SIGHUP:
1900       dirmngr_sighup_action ();
1901       break;
1902
1903     case SIGUSR1:
1904       cert_cache_print_stats ();
1905       domaininfo_print_stats ();
1906       break;
1907
1908     case SIGUSR2:
1909       log_info (_("SIGUSR2 received - no action defined\n"));
1910       break;
1911
1912     case SIGTERM:
1913       if (!shutdown_pending)
1914         log_info (_("SIGTERM received - shutting down ...\n"));
1915       else
1916         log_info (_("SIGTERM received - still %d active connections\n"),
1917                   active_connections);
1918       shutdown_pending++;
1919       if (shutdown_pending > 2)
1920         {
1921           log_info (_("shutdown forced\n"));
1922           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1923           cleanup ();
1924           dirmngr_exit (0);
1925         }
1926       break;
1927
1928     case SIGINT:
1929       log_info (_("SIGINT received - immediate shutdown\n"));
1930       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1931       cleanup ();
1932       dirmngr_exit (0);
1933       break;
1934
1935     default:
1936       log_info (_("signal %d received - no action defined\n"), signo);
1937     }
1938 }
1939 #endif /*!HAVE_W32_SYSTEM*/
1940
1941
1942 /* Thread to do the housekeeping.  */
1943 static void *
1944 housekeeping_thread (void *arg)
1945 {
1946   static int sentinel;
1947   time_t curtime;
1948   struct server_control_s ctrlbuf;
1949
1950   (void)arg;
1951
1952   curtime = gnupg_get_time ();
1953   if (sentinel)
1954     {
1955       log_info ("housekeeping is already going on\n");
1956       return NULL;
1957     }
1958   sentinel++;
1959   if (opt.verbose > 1)
1960     log_info ("starting housekeeping\n");
1961
1962   memset (&ctrlbuf, 0, sizeof ctrlbuf);
1963   dirmngr_init_default_ctrl (&ctrlbuf);
1964
1965   ks_hkp_housekeeping (curtime);
1966   if (network_activity_seen)
1967     {
1968       network_activity_seen = 0;
1969       if (opt.allow_version_check)
1970         dirmngr_load_swdb (&ctrlbuf, 0);
1971       workqueue_run_global_tasks (&ctrlbuf, 1);
1972     }
1973   else
1974     workqueue_run_global_tasks (&ctrlbuf, 0);
1975
1976   dirmngr_deinit_default_ctrl (&ctrlbuf);
1977
1978   if (opt.verbose > 1)
1979     log_info ("ready with housekeeping\n");
1980   sentinel--;
1981   return NULL;
1982
1983 }
1984
1985
1986 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1987 # pragma GCC push_options
1988 # pragma GCC optimize ("no-strict-overflow")
1989 #endif
1990 static int
1991 time_for_housekeeping_p (time_t curtime)
1992 {
1993   static time_t last_housekeeping;
1994
1995   if (!last_housekeeping)
1996     last_housekeeping = curtime;
1997
1998   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1999       || last_housekeeping > curtime /*(be prepared for y2038)*/)
2000     {
2001       last_housekeeping = curtime;
2002       return 1;
2003     }
2004   return 0;
2005 }
2006 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
2007 # pragma GCC pop_options
2008 #endif
2009
2010
2011 /* This is the worker for the ticker.  It is called every few seconds
2012    and may only do fast operations. */
2013 static void
2014 handle_tick (void)
2015 {
2016   struct stat statbuf;
2017
2018   if (time_for_housekeeping_p (gnupg_get_time ()))
2019     {
2020       npth_t thread;
2021       npth_attr_t tattr;
2022       int err;
2023
2024       err = npth_attr_init (&tattr);
2025       if (err)
2026         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
2027       else
2028         {
2029           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2030           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
2031           if (err)
2032             log_error ("error spawning housekeeping thread: %s\n",
2033                        strerror (err));
2034           npth_attr_destroy (&tattr);
2035         }
2036     }
2037
2038   /* Check whether the homedir is still available.  */
2039   if (!shutdown_pending
2040       && stat (gnupg_homedir (), &statbuf) && errno == ENOENT)
2041     {
2042       shutdown_pending = 1;
2043       log_info ("homedir has been removed - shutting down\n");
2044     }
2045 }
2046
2047
2048 /* Check the nonce on a new connection.  This is a NOP unless we are
2049    using our Unix domain socket emulation under Windows.  */
2050 static int
2051 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
2052 {
2053   if (assuan_sock_check_nonce (fd, nonce))
2054     {
2055       log_info (_("error reading nonce on fd %d: %s\n"),
2056                 FD2INT (fd), strerror (errno));
2057       assuan_sock_close (fd);
2058       return -1;
2059     }
2060   else
2061     return 0;
2062 }
2063
2064
2065 /* Helper to call a connection's main function. */
2066 static void *
2067 start_connection_thread (void *arg)
2068 {
2069   static unsigned int last_session_id;
2070   unsigned int session_id;
2071   union int_and_ptr_u argval;
2072   gnupg_fd_t fd;
2073
2074   memset (&argval, 0, sizeof argval);
2075   argval.aptr = arg;
2076   fd = argval.afd;
2077
2078   if (check_nonce (fd, &socket_nonce))
2079     {
2080       log_error ("handler nonce check FAILED\n");
2081       return NULL;
2082     }
2083
2084 #ifndef HAVE_W32_SYSTEM
2085   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2086 #endif
2087
2088   active_connections++;
2089   if (opt.verbose)
2090     log_info (_("handler for fd %d started\n"), FD2INT (fd));
2091
2092   session_id = ++last_session_id;
2093   if (!session_id)
2094     session_id = ++last_session_id;
2095   start_command_handler (fd, session_id);
2096
2097   if (opt.verbose)
2098     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
2099   active_connections--;
2100
2101   workqueue_run_post_session_tasks (session_id);
2102
2103 #ifndef HAVE_W32_SYSTEM
2104   argval.afd = ASSUAN_INVALID_FD;
2105   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2106 #endif
2107
2108   return NULL;
2109 }
2110
2111
2112 #ifdef HAVE_INOTIFY_INIT
2113 /* Read an inotify event and return true if it matches NAME.  */
2114 static int
2115 my_inotify_is_name (int fd, const char *name)
2116 {
2117   union {
2118     struct inotify_event ev;
2119     char _buf[sizeof (struct inotify_event) + 100 + 1];
2120   } buf;
2121   int n;
2122   const char *s;
2123
2124   s = strrchr (name, '/');
2125   if (s && s[1])
2126     name = s + 1;
2127
2128   n = npth_read (fd, &buf, sizeof buf);
2129   if (n < sizeof (struct inotify_event))
2130     return 0;
2131   if (buf.ev.len < strlen (name)+1)
2132     return 0;
2133   if (strcmp (buf.ev.name, name))
2134     return 0; /* Not the desired file.  */
2135
2136   return 1; /* Found.  */
2137 }
2138 #endif /*HAVE_INOTIFY_INIT*/
2139
2140
2141 /* Main loop in daemon mode.  Note that LISTEN_FD will be owned by
2142  * this function. */
2143 static void
2144 handle_connections (assuan_fd_t listen_fd)
2145 {
2146   npth_attr_t tattr;
2147 #ifndef HAVE_W32_SYSTEM
2148   int signo;
2149 #endif
2150   struct sockaddr_un paddr;
2151   socklen_t plen = sizeof( paddr );
2152   int nfd, ret;
2153   fd_set fdset, read_fdset;
2154   struct timespec abstime;
2155   struct timespec curtime;
2156   struct timespec timeout;
2157   int saved_errno;
2158   int my_inotify_fd = -1;
2159
2160   npth_attr_init (&tattr);
2161   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2162
2163 #ifndef HAVE_W32_SYSTEM /* FIXME */
2164   npth_sigev_init ();
2165   npth_sigev_add (SIGHUP);
2166   npth_sigev_add (SIGUSR1);
2167   npth_sigev_add (SIGUSR2);
2168   npth_sigev_add (SIGINT);
2169   npth_sigev_add (SIGTERM);
2170   npth_sigev_fini ();
2171 #endif
2172
2173 #ifdef HAVE_INOTIFY_INIT
2174   if (disable_check_own_socket)
2175     my_inotify_fd = -1;
2176   else if ((my_inotify_fd = inotify_init ()) == -1)
2177     log_info ("error enabling fast daemon termination: %s\n",
2178               strerror (errno));
2179   else
2180     {
2181       /* We need to watch the directory for the file because there
2182        * won't be an IN_DELETE_SELF for a socket file.  */
2183       char *slash = strrchr (socket_name, '/');
2184       log_assert (slash && slash[1]);
2185       *slash = 0;
2186       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2187         {
2188           close (my_inotify_fd);
2189           my_inotify_fd = -1;
2190         }
2191       *slash = '/';
2192     }
2193 #endif /*HAVE_INOTIFY_INIT*/
2194
2195
2196   /* Setup the fdset.  It has only one member.  This is because we use
2197      pth_select instead of pth_accept to properly sync timeouts with
2198      to full second.  */
2199   FD_ZERO (&fdset);
2200   FD_SET (FD2INT (listen_fd), &fdset);
2201   nfd = FD2INT (listen_fd);
2202   if (my_inotify_fd != -1)
2203     {
2204       FD_SET (my_inotify_fd, &fdset);
2205       if (my_inotify_fd > nfd)
2206         nfd = my_inotify_fd;
2207     }
2208
2209   npth_clock_gettime (&abstime);
2210   abstime.tv_sec += TIMERTICK_INTERVAL;
2211
2212   /* Main loop.  */
2213   for (;;)
2214     {
2215       /* Shutdown test.  */
2216       if (shutdown_pending)
2217         {
2218           if (!active_connections)
2219             break; /* ready */
2220
2221           /* Do not accept new connections but keep on running the
2222            * loop to cope with the timer events.
2223            *
2224            * Note that we do not close the listening socket because a
2225            * client trying to connect to that socket would instead
2226            * restart a new dirmngr instance - which is unlikely the
2227            * intention of a shutdown. */
2228           /* assuan_sock_close (listen_fd); */
2229           /* listen_fd = -1; */
2230           FD_ZERO (&fdset);
2231           nfd = -1;
2232           if (my_inotify_fd != -1)
2233             {
2234               FD_SET (my_inotify_fd, &fdset);
2235               nfd = my_inotify_fd;
2236             }
2237         }
2238
2239       /* Take a copy of the fdset.  */
2240       read_fdset = fdset;
2241
2242       npth_clock_gettime (&curtime);
2243       if (!(npth_timercmp (&curtime, &abstime, <)))
2244         {
2245           /* Timeout.  When a shutdown is pending we use a shorter
2246            * interval to handle the shutdown more quickly.  */
2247           handle_tick ();
2248           npth_clock_gettime (&abstime);
2249           abstime.tv_sec += (shutdown_pending
2250                              ? TIMERTICK_INTERVAL_SHUTDOWN
2251                              : TIMERTICK_INTERVAL);
2252         }
2253       npth_timersub (&abstime, &curtime, &timeout);
2254
2255 #ifndef HAVE_W32_SYSTEM
2256       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2257                           npth_sigev_sigmask());
2258       saved_errno = errno;
2259
2260       while (npth_sigev_get_pending(&signo))
2261         handle_signal (signo);
2262 #else
2263       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2264       saved_errno = errno;
2265 #endif
2266
2267       if (ret == -1 && saved_errno != EINTR)
2268         {
2269           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2270                      strerror (saved_errno));
2271           npth_sleep (1);
2272           continue;
2273         }
2274
2275       if (ret <= 0)
2276         {
2277           /* Interrupt or timeout.  Will be handled when calculating the
2278              next timeout.  */
2279           continue;
2280         }
2281
2282       if (shutdown_pending)
2283         {
2284           /* Do not anymore accept connections.  */
2285           continue;
2286         }
2287
2288 #ifdef HAVE_INOTIFY_INIT
2289       if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2290           && my_inotify_is_name (my_inotify_fd, socket_name))
2291         {
2292           shutdown_pending = 1;
2293           log_info ("socket file has been removed - shutting down\n");
2294         }
2295 #endif /*HAVE_INOTIFY_INIT*/
2296
2297       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
2298         {
2299           gnupg_fd_t fd;
2300
2301           plen = sizeof paddr;
2302           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2303                                     (struct sockaddr *)&paddr, &plen));
2304           if (fd == GNUPG_INVALID_FD)
2305             {
2306               log_error ("accept failed: %s\n", strerror (errno));
2307             }
2308           else
2309             {
2310               char threadname[50];
2311               union int_and_ptr_u argval;
2312               npth_t thread;
2313
2314               memset (&argval, 0, sizeof argval);
2315               argval.afd = fd;
2316               snprintf (threadname, sizeof threadname,
2317                         "conn fd=%d", FD2INT(fd));
2318
2319               ret = npth_create (&thread, &tattr,
2320                                  start_connection_thread, argval.aptr);
2321               if (ret)
2322                 {
2323                   log_error ("error spawning connection handler: %s\n",
2324                              strerror (ret) );
2325                   assuan_sock_close (fd);
2326                 }
2327               npth_setname_np (thread, threadname);
2328             }
2329         }
2330     }
2331
2332 #ifdef HAVE_INOTIFY_INIT
2333   if (my_inotify_fd != -1)
2334     close (my_inotify_fd);
2335 #endif /*HAVE_INOTIFY_INIT*/
2336   npth_attr_destroy (&tattr);
2337   if (listen_fd != GNUPG_INVALID_FD)
2338     assuan_sock_close (listen_fd);
2339   cleanup ();
2340   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2341 }
2342
2343 const char*
2344 dirmngr_get_current_socket_name (void)
2345 {
2346   if (socket_name)
2347     return socket_name;
2348   else
2349     return dirmngr_socket_name ();
2350 }