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