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