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