common: New functions gnupg_daemon_rootdir and gnupg_chdir.
[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           if (gnupg_chdir (gnupg_daemon_rootdir ()))
1355             {
1356               log_error ("chdir to '%s' failed: %s\n",
1357                          gnupg_daemon_rootdir (), strerror (errno));
1358               dirmngr_exit (1);
1359             }
1360
1361         }
1362 #endif
1363
1364       thread_init ();
1365       cert_cache_init (hkp_cacert_filenames);
1366       crl_cache_init ();
1367       http_register_netactivity_cb (netactivity_action);
1368       handle_connections (fd);
1369       shutdown_reaper ();
1370     }
1371   else if (cmd == aListCRLs)
1372     {
1373       /* Just list the CRL cache and exit. */
1374       if (argc)
1375         wrong_args ("--list-crls");
1376       crl_cache_init ();
1377       crl_cache_list (es_stdout);
1378     }
1379   else if (cmd == aLoadCRL)
1380     {
1381       struct server_control_s ctrlbuf;
1382
1383       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1384       dirmngr_init_default_ctrl (&ctrlbuf);
1385
1386       thread_init ();
1387       cert_cache_init (hkp_cacert_filenames);
1388       crl_cache_init ();
1389       if (!argc)
1390         rc = crl_cache_load (&ctrlbuf, NULL);
1391       else
1392         {
1393           for (; !rc && argc; argc--, argv++)
1394             rc = crl_cache_load (&ctrlbuf, *argv);
1395         }
1396       dirmngr_deinit_default_ctrl (&ctrlbuf);
1397     }
1398   else if (cmd == aFetchCRL)
1399     {
1400       ksba_reader_t reader;
1401       struct server_control_s ctrlbuf;
1402
1403       if (argc != 1)
1404         wrong_args ("--fetch-crl URL");
1405
1406       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1407       dirmngr_init_default_ctrl (&ctrlbuf);
1408
1409       thread_init ();
1410       cert_cache_init (hkp_cacert_filenames);
1411       crl_cache_init ();
1412       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1413       if (rc)
1414         log_error (_("fetching CRL from '%s' failed: %s\n"),
1415                      argv[0], gpg_strerror (rc));
1416       else
1417         {
1418           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1419           if (rc)
1420             log_error (_("processing CRL from '%s' failed: %s\n"),
1421                        argv[0], gpg_strerror (rc));
1422           crl_close_reader (reader);
1423         }
1424       dirmngr_deinit_default_ctrl (&ctrlbuf);
1425     }
1426   else if (cmd == aFlush)
1427     {
1428       /* Delete cache and exit. */
1429       if (argc)
1430         wrong_args ("--flush");
1431       rc = crl_cache_flush();
1432     }
1433   else if (cmd == aGPGConfTest)
1434     dirmngr_exit (0);
1435   else if (cmd == aGPGConfList)
1436     {
1437       unsigned long flags = 0;
1438       char *filename;
1439       char *filename_esc;
1440
1441       /* First the configuration file.  This is not an option, but it
1442          is vital information for GPG Conf.  */
1443       if (!opt.config_filename)
1444         opt.config_filename = make_filename (gnupg_homedir (),
1445                                              "dirmngr.conf", NULL );
1446
1447       filename = percent_escape (opt.config_filename, NULL);
1448       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1449               GC_OPT_FLAG_DEFAULT, filename);
1450       xfree (filename);
1451
1452       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1453       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1454       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1455       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1456       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1457
1458       /* --csh and --sh are mutually exclusive, something we can not
1459          express in GPG Conf.  --options is only usable from the
1460          command line, really.  --debug-all interacts with --debug,
1461          and having both of them is thus problematic.  --no-detach is
1462          also only usable on the command line.  --batch is unused.  */
1463
1464       filename = make_filename (gnupg_homedir (),
1465                                 "dirmngr_ldapservers.conf",
1466                                 NULL);
1467       filename_esc = percent_escape (filename, NULL);
1468       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1469               filename_esc);
1470       xfree (filename_esc);
1471       xfree (filename);
1472
1473       es_printf ("ldaptimeout:%lu:%u\n",
1474               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1475       es_printf ("max-replies:%lu:%u\n",
1476               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1477       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1478       es_printf ("allow-version-check:%lu:\n", flags | GC_OPT_FLAG_NONE);
1479       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1480       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1481
1482       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1483       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1484
1485       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1486       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1487       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1488       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1489       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1490       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1491       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1492       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1493       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1494       /* Note: The next one is to fix a typo in gpgconf - should be
1495          removed eventually. */
1496       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1497
1498       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1499
1500       filename_esc = percent_escape (get_default_keyserver (0), NULL);
1501       es_printf ("keyserver:%lu:\"%s:\n", flags | GC_OPT_FLAG_DEFAULT,
1502                  filename_esc);
1503       xfree (filename_esc);
1504
1505
1506       es_printf ("nameserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1507       es_printf ("resolver-timeout:%lu:%u\n",
1508                  flags | GC_OPT_FLAG_DEFAULT, 0);
1509     }
1510   cleanup ();
1511   return !!rc;
1512 }
1513
1514
1515 static void
1516 cleanup (void)
1517 {
1518   crl_cache_deinit ();
1519   cert_cache_deinit (1);
1520   reload_dns_stuff (1);
1521
1522 #if USE_LDAP
1523   ldapserver_list_free (opt.ldapservers);
1524 #endif /*USE_LDAP*/
1525   opt.ldapservers = NULL;
1526
1527   if (cleanup_socket)
1528     {
1529       cleanup_socket = 0;
1530       if (redir_socket_name)
1531         gnupg_remove (redir_socket_name);
1532       else if (socket_name && *socket_name)
1533         gnupg_remove (socket_name);
1534     }
1535 }
1536
1537
1538 void
1539 dirmngr_exit (int rc)
1540 {
1541   cleanup ();
1542   exit (rc);
1543 }
1544
1545
1546 void
1547 dirmngr_init_default_ctrl (ctrl_t ctrl)
1548 {
1549   ctrl->magic = SERVER_CONTROL_MAGIC;
1550   if (opt.http_proxy)
1551     ctrl->http_proxy = xstrdup (opt.http_proxy);
1552   ctrl->http_no_crl = 1;
1553   ctrl->timeout = opt.connect_timeout;
1554 }
1555
1556
1557 void
1558 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1559 {
1560   if (!ctrl)
1561     return;
1562   ctrl->magic = 0xdeadbeef;
1563
1564   xfree (ctrl->http_proxy);
1565   ctrl->http_proxy = NULL;
1566 }
1567
1568
1569 /* Create a list of LDAP servers from the file FILENAME. Returns the
1570    list or NULL in case of errors.
1571
1572    The format fo such a file is line oriented where empty lines and
1573    lines starting with a hash mark are ignored.  All other lines are
1574    assumed to be colon seprated with these fields:
1575
1576    1. field: Hostname
1577    2. field: Portnumber
1578    3. field: Username
1579    4. field: Password
1580    5. field: Base DN
1581
1582 */
1583 #if USE_LDAP
1584 static ldap_server_t
1585 parse_ldapserver_file (const char* filename)
1586 {
1587   char buffer[1024];
1588   char *p;
1589   ldap_server_t server, serverstart, *serverend;
1590   int c;
1591   unsigned int lineno = 0;
1592   estream_t fp;
1593
1594   fp = es_fopen (filename, "r");
1595   if (!fp)
1596     {
1597       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1598       return NULL;
1599     }
1600
1601   serverstart = NULL;
1602   serverend = &serverstart;
1603   while (es_fgets (buffer, sizeof buffer, fp))
1604     {
1605       lineno++;
1606       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1607         {
1608           if (*buffer && es_feof (fp))
1609             ; /* Last line not terminated - continue. */
1610           else
1611             {
1612               log_error (_("%s:%u: line too long - skipped\n"),
1613                          filename, lineno);
1614               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1615                 ; /* Skip until end of line. */
1616               continue;
1617             }
1618         }
1619       /* Skip empty and comment lines.*/
1620       for (p=buffer; spacep (p); p++)
1621         ;
1622       if (!*p || *p == '\n' || *p == '#')
1623         continue;
1624
1625       /* Parse the colon separated fields. */
1626       server = ldapserver_parse_one (buffer, filename, lineno);
1627       if (server)
1628         {
1629           *serverend = server;
1630           serverend = &server->next;
1631         }
1632     }
1633
1634   if (es_ferror (fp))
1635     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1636   es_fclose (fp);
1637
1638   return serverstart;
1639 }
1640 #endif /*USE_LDAP*/
1641
1642 static fingerprint_list_t
1643 parse_ocsp_signer (const char *string)
1644 {
1645   gpg_error_t err;
1646   char *fname;
1647   estream_t fp;
1648   char line[256];
1649   char *p;
1650   fingerprint_list_t list, *list_tail, item;
1651   unsigned int lnr = 0;
1652   int c, i, j;
1653   int errflag = 0;
1654
1655
1656   /* Check whether this is not a filename and treat it as a direct
1657      fingerprint specification.  */
1658   if (!strpbrk (string, "/.~\\"))
1659     {
1660       item = xcalloc (1, sizeof *item);
1661       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1662         if ( string[i] != ':' )
1663           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1664       item->hexfpr[j] = 0;
1665       if (j != 40 || !(spacep (string+i) || !string[i]))
1666         {
1667           log_error (_("%s:%u: invalid fingerprint detected\n"),
1668                      "--ocsp-signer", 0);
1669           xfree (item);
1670           return NULL;
1671         }
1672       return item;
1673     }
1674
1675   /* Well, it is a filename.  */
1676   if (*string == '/' || (*string == '~' && string[1] == '/'))
1677     fname = make_filename (string, NULL);
1678   else
1679     {
1680       if (string[0] == '.' && string[1] == '/' )
1681         string += 2;
1682       fname = make_filename (gnupg_homedir (), string, NULL);
1683     }
1684
1685   fp = es_fopen (fname, "r");
1686   if (!fp)
1687     {
1688       err = gpg_error_from_syserror ();
1689       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1690       xfree (fname);
1691       return NULL;
1692     }
1693
1694   list = NULL;
1695   list_tail = &list;
1696   for (;;)
1697     {
1698       if (!es_fgets (line, DIM(line)-1, fp) )
1699         {
1700           if (!es_feof (fp))
1701             {
1702               err = gpg_error_from_syserror ();
1703               log_error (_("%s:%u: read error: %s\n"),
1704                          fname, lnr, gpg_strerror (err));
1705               errflag = 1;
1706             }
1707           es_fclose (fp);
1708           if (errflag)
1709             {
1710               while (list)
1711                 {
1712                   fingerprint_list_t tmp = list->next;
1713                   xfree (list);
1714                   list = tmp;
1715                 }
1716             }
1717           xfree (fname);
1718           return list; /* Ready.  */
1719         }
1720
1721       lnr++;
1722       if (!*line || line[strlen(line)-1] != '\n')
1723         {
1724           /* Eat until end of line. */
1725           while ( (c=es_getc (fp)) != EOF && c != '\n')
1726             ;
1727           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1728                            /* */: GPG_ERR_INCOMPLETE_LINE);
1729           log_error (_("%s:%u: read error: %s\n"),
1730                      fname, lnr, gpg_strerror (err));
1731           errflag = 1;
1732           continue;
1733         }
1734
1735       /* Allow for empty lines and spaces */
1736       for (p=line; spacep (p); p++)
1737         ;
1738       if (!*p || *p == '\n' || *p == '#')
1739         continue;
1740
1741       item = xcalloc (1, sizeof *item);
1742       *list_tail = item;
1743       list_tail = &item->next;
1744
1745       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1746         if ( p[i] != ':' )
1747           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1748       item->hexfpr[j] = 0;
1749       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1750         {
1751           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1752           errflag = 1;
1753         }
1754       i++;
1755       while (spacep (p+i))
1756         i++;
1757       if (p[i] && p[i] != '\n')
1758         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1759     }
1760   /*NOTREACHED*/
1761 }
1762
1763
1764
1765 \f
1766 /*
1767    Stuff used in daemon mode.
1768  */
1769
1770
1771
1772 /* Reread parts of the configuration.  Note, that this function is
1773    obviously not thread-safe and should only be called from the NPTH
1774    signal handler.
1775
1776    Fixme: Due to the way the argument parsing works, we create a
1777    memory leak here for all string type arguments.  There is currently
1778    no clean way to tell whether the memory for the argument has been
1779    allocated or points into the process' original arguments.  Unless
1780    we have a mechanism to tell this, we need to live on with this. */
1781 static void
1782 reread_configuration (void)
1783 {
1784   ARGPARSE_ARGS pargs;
1785   FILE *fp;
1786   unsigned int configlineno = 0;
1787   int dummy;
1788
1789   if (!opt.config_filename)
1790     return; /* No config file. */
1791
1792   fp = fopen (opt.config_filename, "r");
1793   if (!fp)
1794     {
1795       log_error (_("option file '%s': %s\n"),
1796                  opt.config_filename, strerror(errno) );
1797       return;
1798     }
1799
1800   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1801
1802   memset (&pargs, 0, sizeof pargs);
1803   dummy = 0;
1804   pargs.argc = &dummy;
1805   pargs.flags = 1;  /* do not remove the args */
1806   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1807     {
1808       if (pargs.r_opt < -1)
1809         pargs.err = 1; /* Print a warning. */
1810       else /* Try to parse this option - ignore unchangeable ones. */
1811         parse_rereadable_options (&pargs, 1);
1812     }
1813   fclose (fp);
1814
1815   post_option_parsing ();
1816 }
1817
1818
1819 /* A global function which allows us to trigger the reload stuff from
1820    other places.  */
1821 void
1822 dirmngr_sighup_action (void)
1823 {
1824   log_info (_("SIGHUP received - "
1825               "re-reading configuration and flushing caches\n"));
1826   reread_configuration ();
1827   cert_cache_deinit (0);
1828   crl_cache_deinit ();
1829   cert_cache_init (hkp_cacert_filenames);
1830   crl_cache_init ();
1831   reload_dns_stuff (0);
1832   ks_hkp_reload ();
1833 }
1834
1835
1836 /* This function is called if some network activity was done.  At this
1837  * point we know the we have a network and we can decide whether to
1838  * run scheduled background tasks soon.  The function should return
1839  * quickly and only trigger actions for another thread. */
1840 static void
1841 netactivity_action (void)
1842 {
1843   network_activity_seen = 1;
1844 }
1845
1846
1847 /* The signal handler. */
1848 #ifndef HAVE_W32_SYSTEM
1849 static void
1850 handle_signal (int signo)
1851 {
1852   switch (signo)
1853     {
1854     case SIGHUP:
1855       dirmngr_sighup_action ();
1856       break;
1857
1858     case SIGUSR1:
1859       cert_cache_print_stats ();
1860       break;
1861
1862     case SIGUSR2:
1863       log_info (_("SIGUSR2 received - no action defined\n"));
1864       break;
1865
1866     case SIGTERM:
1867       if (!shutdown_pending)
1868         log_info (_("SIGTERM received - shutting down ...\n"));
1869       else
1870         log_info (_("SIGTERM received - still %d active connections\n"),
1871                   active_connections);
1872       shutdown_pending++;
1873       if (shutdown_pending > 2)
1874         {
1875           log_info (_("shutdown forced\n"));
1876           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1877           cleanup ();
1878           dirmngr_exit (0);
1879         }
1880       break;
1881
1882     case SIGINT:
1883       log_info (_("SIGINT received - immediate shutdown\n"));
1884       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1885       cleanup ();
1886       dirmngr_exit (0);
1887       break;
1888
1889     default:
1890       log_info (_("signal %d received - no action defined\n"), signo);
1891     }
1892 }
1893 #endif /*!HAVE_W32_SYSTEM*/
1894
1895
1896 /* Thread to do the housekeeping.  */
1897 static void *
1898 housekeeping_thread (void *arg)
1899 {
1900   static int sentinel;
1901   time_t curtime;
1902   struct server_control_s ctrlbuf;
1903
1904   (void)arg;
1905
1906   curtime = gnupg_get_time ();
1907   if (sentinel)
1908     {
1909       log_info ("housekeeping is already going on\n");
1910       return NULL;
1911     }
1912   sentinel++;
1913   if (opt.verbose > 1)
1914     log_info ("starting housekeeping\n");
1915
1916   memset (&ctrlbuf, 0, sizeof ctrlbuf);
1917   dirmngr_init_default_ctrl (&ctrlbuf);
1918
1919   ks_hkp_housekeeping (curtime);
1920   if (network_activity_seen)
1921     {
1922       network_activity_seen = 0;
1923       if (opt.allow_version_check)
1924         dirmngr_load_swdb (&ctrlbuf, 0);
1925     }
1926
1927   dirmngr_deinit_default_ctrl (&ctrlbuf);
1928
1929   if (opt.verbose > 1)
1930     log_info ("ready with housekeeping\n");
1931   sentinel--;
1932   return NULL;
1933
1934 }
1935
1936
1937 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1938 # pragma GCC push_options
1939 # pragma GCC optimize ("no-strict-overflow")
1940 #endif
1941 static int
1942 time_for_housekeeping_p (time_t curtime)
1943 {
1944   static time_t last_housekeeping;
1945
1946   if (!last_housekeeping)
1947     last_housekeeping = curtime;
1948
1949   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1950       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1951     {
1952       last_housekeeping = curtime;
1953       return 1;
1954     }
1955   return 0;
1956 }
1957 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1958 # pragma GCC pop_options
1959 #endif
1960
1961
1962 /* This is the worker for the ticker.  It is called every few seconds
1963    and may only do fast operations. */
1964 static void
1965 handle_tick (void)
1966 {
1967   if (time_for_housekeeping_p (gnupg_get_time ()))
1968     {
1969       npth_t thread;
1970       npth_attr_t tattr;
1971       int err;
1972
1973       err = npth_attr_init (&tattr);
1974       if (err)
1975         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
1976       else
1977         {
1978           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1979           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
1980           if (err)
1981             log_error ("error spawning housekeeping thread: %s\n",
1982                        strerror (err));
1983           npth_attr_destroy (&tattr);
1984         }
1985     }
1986 }
1987
1988
1989 /* Check the nonce on a new connection.  This is a NOP unless we are
1990    using our Unix domain socket emulation under Windows.  */
1991 static int
1992 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1993 {
1994   if (assuan_sock_check_nonce (fd, nonce))
1995     {
1996       log_info (_("error reading nonce on fd %d: %s\n"),
1997                 FD2INT (fd), strerror (errno));
1998       assuan_sock_close (fd);
1999       return -1;
2000     }
2001   else
2002     return 0;
2003 }
2004
2005
2006 /* Helper to call a connection's main function. */
2007 static void *
2008 start_connection_thread (void *arg)
2009 {
2010   union int_and_ptr_u argval;
2011   gnupg_fd_t fd;
2012
2013   memset (&argval, 0, sizeof argval);
2014   argval.aptr = arg;
2015   fd = argval.afd;
2016
2017   if (check_nonce (fd, &socket_nonce))
2018     {
2019       log_error ("handler nonce check FAILED\n");
2020       return NULL;
2021     }
2022
2023 #ifndef HAVE_W32_SYSTEM
2024   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2025 #endif
2026
2027   active_connections++;
2028   if (opt.verbose)
2029     log_info (_("handler for fd %d started\n"), FD2INT (fd));
2030
2031   start_command_handler (fd);
2032
2033   if (opt.verbose)
2034     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
2035   active_connections--;
2036
2037 #ifndef HAVE_W32_SYSTEM
2038   argval.afd = ASSUAN_INVALID_FD;
2039   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2040 #endif
2041
2042   return NULL;
2043 }
2044
2045
2046 #ifdef HAVE_INOTIFY_INIT
2047 /* Read an inotify event and return true if it matches NAME.  */
2048 static int
2049 my_inotify_is_name (int fd, const char *name)
2050 {
2051   union {
2052     struct inotify_event ev;
2053     char _buf[sizeof (struct inotify_event) + 100 + 1];
2054   } buf;
2055   int n;
2056   const char *s;
2057
2058   s = strrchr (name, '/');
2059   if (s && s[1])
2060     name = s + 1;
2061
2062   n = npth_read (fd, &buf, sizeof buf);
2063   if (n < sizeof (struct inotify_event))
2064     return 0;
2065   if (buf.ev.len < strlen (name)+1)
2066     return 0;
2067   if (strcmp (buf.ev.name, name))
2068     return 0; /* Not the desired file.  */
2069
2070   return 1; /* Found.  */
2071 }
2072 #endif /*HAVE_INOTIFY_INIT*/
2073
2074
2075 /* Main loop in daemon mode.  Note that LISTEN_FD will be owned by
2076  * this function. */
2077 static void
2078 handle_connections (assuan_fd_t listen_fd)
2079 {
2080   npth_attr_t tattr;
2081 #ifndef HAVE_W32_SYSTEM
2082   int signo;
2083 #endif
2084   struct sockaddr_un paddr;
2085   socklen_t plen = sizeof( paddr );
2086   int nfd, ret;
2087   fd_set fdset, read_fdset;
2088   struct timespec abstime;
2089   struct timespec curtime;
2090   struct timespec timeout;
2091   int saved_errno;
2092   int my_inotify_fd = -1;
2093
2094   npth_attr_init (&tattr);
2095   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2096
2097 #ifndef HAVE_W32_SYSTEM /* FIXME */
2098   npth_sigev_init ();
2099   npth_sigev_add (SIGHUP);
2100   npth_sigev_add (SIGUSR1);
2101   npth_sigev_add (SIGUSR2);
2102   npth_sigev_add (SIGINT);
2103   npth_sigev_add (SIGTERM);
2104   npth_sigev_fini ();
2105 #endif
2106
2107 #ifdef HAVE_INOTIFY_INIT
2108   if (disable_check_own_socket)
2109     my_inotify_fd = -1;
2110   else if ((my_inotify_fd = inotify_init ()) == -1)
2111     log_info ("error enabling fast daemon termination: %s\n",
2112               strerror (errno));
2113   else
2114     {
2115       /* We need to watch the directory for the file because there
2116        * won't be an IN_DELETE_SELF for a socket file.  */
2117       char *slash = strrchr (socket_name, '/');
2118       log_assert (slash && slash[1]);
2119       *slash = 0;
2120       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2121         {
2122           close (my_inotify_fd);
2123           my_inotify_fd = -1;
2124         }
2125       *slash = '/';
2126     }
2127 #endif /*HAVE_INOTIFY_INIT*/
2128
2129
2130   /* Setup the fdset.  It has only one member.  This is because we use
2131      pth_select instead of pth_accept to properly sync timeouts with
2132      to full second.  */
2133   FD_ZERO (&fdset);
2134   FD_SET (FD2INT (listen_fd), &fdset);
2135   nfd = FD2INT (listen_fd);
2136   if (my_inotify_fd != -1)
2137     {
2138       FD_SET (my_inotify_fd, &fdset);
2139       if (my_inotify_fd > nfd)
2140         nfd = my_inotify_fd;
2141     }
2142
2143   npth_clock_gettime (&abstime);
2144   abstime.tv_sec += TIMERTICK_INTERVAL;
2145
2146   /* Main loop.  */
2147   for (;;)
2148     {
2149       /* Shutdown test.  */
2150       if (shutdown_pending)
2151         {
2152           if (!active_connections)
2153             break; /* ready */
2154
2155           /* Do not accept new connections but keep on running the
2156            * loop to cope with the timer events.
2157            *
2158            * Note that we do not close the listening socket because a
2159            * client trying to connect to that socket would instead
2160            * restart a new dirmngr instance - which is unlikely the
2161            * intention of a shutdown. */
2162           /* assuan_sock_close (listen_fd); */
2163           /* listen_fd = -1; */
2164           FD_ZERO (&fdset);
2165           nfd = -1;
2166           if (my_inotify_fd != -1)
2167             {
2168               FD_SET (my_inotify_fd, &fdset);
2169               nfd = my_inotify_fd;
2170             }
2171         }
2172
2173       /* Take a copy of the fdset.  */
2174       read_fdset = fdset;
2175
2176       npth_clock_gettime (&curtime);
2177       if (!(npth_timercmp (&curtime, &abstime, <)))
2178         {
2179           /* Timeout.  */
2180           handle_tick ();
2181           npth_clock_gettime (&abstime);
2182           abstime.tv_sec += TIMERTICK_INTERVAL;
2183         }
2184       npth_timersub (&abstime, &curtime, &timeout);
2185
2186 #ifndef HAVE_W32_SYSTEM
2187       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout, npth_sigev_sigmask());
2188       saved_errno = errno;
2189
2190       while (npth_sigev_get_pending(&signo))
2191         handle_signal (signo);
2192 #else
2193       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2194       saved_errno = errno;
2195 #endif
2196
2197       if (ret == -1 && saved_errno != EINTR)
2198         {
2199           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2200                      strerror (saved_errno));
2201           npth_sleep (1);
2202           continue;
2203         }
2204
2205       if (ret <= 0)
2206         {
2207           /* Interrupt or timeout.  Will be handled when calculating the
2208              next timeout.  */
2209           continue;
2210         }
2211
2212       if (shutdown_pending)
2213         {
2214           /* Do not anymore accept connections.  */
2215           continue;
2216         }
2217
2218 #ifdef HAVE_INOTIFY_INIT
2219       if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2220           && my_inotify_is_name (my_inotify_fd, socket_name))
2221         {
2222           shutdown_pending = 1;
2223           log_info ("socket file has been removed - shutting down\n");
2224         }
2225 #endif /*HAVE_INOTIFY_INIT*/
2226
2227       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
2228         {
2229           gnupg_fd_t fd;
2230
2231           plen = sizeof paddr;
2232           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2233                                     (struct sockaddr *)&paddr, &plen));
2234           if (fd == GNUPG_INVALID_FD)
2235             {
2236               log_error ("accept failed: %s\n", strerror (errno));
2237             }
2238           else
2239             {
2240               char threadname[50];
2241               union int_and_ptr_u argval;
2242               npth_t thread;
2243
2244               memset (&argval, 0, sizeof argval);
2245               argval.afd = fd;
2246               snprintf (threadname, sizeof threadname,
2247                         "conn fd=%d", FD2INT(fd));
2248
2249               ret = npth_create (&thread, &tattr,
2250                                  start_connection_thread, argval.aptr);
2251               if (ret)
2252                 {
2253                   log_error ("error spawning connection handler: %s\n",
2254                              strerror (ret) );
2255                   assuan_sock_close (fd);
2256                 }
2257               npth_setname_np (thread, threadname);
2258             }
2259         }
2260     }
2261
2262 #ifdef HAVE_INOTIFY_INIT
2263   if (my_inotify_fd != -1)
2264     close (my_inotify_fd);
2265 #endif /*HAVE_INOTIFY_INIT*/
2266   npth_attr_destroy (&tattr);
2267   if (listen_fd != GNUPG_INVALID_FD)
2268     assuan_sock_close (listen_fd);
2269   cleanup ();
2270   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2271 }
2272
2273 const char*
2274 dirmngr_get_current_socket_name (void)
2275 {
2276   if (socket_name)
2277     return socket_name;
2278   else
2279     return dirmngr_socket_name ();
2280 }