a32040e7b584240dc5b0baaaeff543ceeaf431c7
[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 wrong_args (const char *text)
470 {
471   es_fprintf (es_stderr, _("usage: %s [options] "), DIRMNGR_NAME);
472   es_fputs (text, es_stderr);
473   es_putc ('\n', es_stderr);
474   dirmngr_exit (2);
475 }
476
477
478 /* Helper to stop the reaper thread for the ldap wrapper.  */
479 static void
480 shutdown_reaper (void)
481 {
482 #if USE_LDAP
483   ldap_wrapper_wait_connections ();
484 #endif
485 }
486
487
488 /* Handle options which are allowed to be reset after program start.
489    Return true if the current option in PARGS could be handled and
490    false if not.  As a special feature, passing a value of NULL for
491    PARGS, resets the options to the default.  REREAD should be set
492    true if it is not the initial option parsing. */
493 static int
494 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
495 {
496   if (!pargs)
497     { /* Reset mode. */
498       opt.quiet = 0;
499       opt.verbose = 0;
500       opt.debug = 0;
501       opt.ldap_wrapper_program = NULL;
502       opt.disable_http = 0;
503       opt.disable_ldap = 0;
504       opt.honor_http_proxy = 0;
505       opt.http_proxy = NULL;
506       opt.ldap_proxy = NULL;
507       opt.only_ldap_proxy = 0;
508       opt.ignore_http_dp = 0;
509       opt.ignore_ldap_dp = 0;
510       opt.ignore_ocsp_service_url = 0;
511       opt.allow_ocsp = 0;
512       opt.ocsp_responder = NULL;
513       opt.ocsp_max_clock_skew = 10 * 60;      /* 10 minutes.  */
514       opt.ocsp_max_period = 90 * 86400;       /* 90 days.  */
515       opt.ocsp_current_period = 3 * 60 * 60;  /* 3 hours. */
516       opt.max_replies = DEFAULT_MAX_REPLIES;
517       while (opt.ocsp_signer)
518         {
519           fingerprint_list_t tmp = opt.ocsp_signer->next;
520           xfree (opt.ocsp_signer);
521           opt.ocsp_signer = tmp;
522         }
523       FREE_STRLIST (opt.ignored_cert_extensions);
524       http_register_tls_ca (NULL);
525       xfree (opt.keyserver);
526       opt.keyserver = NULL;
527       /* Note: We do not allow resetting of opt.use_tor at runtime.  */
528       return 1;
529     }
530
531   switch (pargs->r_opt)
532     {
533     case oQuiet:   opt.quiet = 1; break;
534     case oVerbose: opt.verbose++; break;
535     case oDebug:
536       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
537       break;
538     case oDebugAll: opt.debug = ~0; break;
539     case oDebugLevel: debug_level = pargs->r.ret_str; break;
540     case oGnutlsDebug: opt_gnutls_debug = pargs->r.ret_int; break;
541
542     case oLogFile:
543       if (!reread)
544         return 0; /* Not handled. */
545       if (!current_logfile || !pargs->r.ret_str
546           || strcmp (current_logfile, pargs->r.ret_str))
547         {
548           log_set_file (pargs->r.ret_str);
549           xfree (current_logfile);
550           current_logfile = xtrystrdup (pargs->r.ret_str);
551         }
552       break;
553
554     case oLDAPWrapperProgram:
555       opt.ldap_wrapper_program = pargs->r.ret_str;
556       break;
557     case oHTTPWrapperProgram:
558       opt.http_wrapper_program = pargs->r.ret_str;
559       break;
560
561     case oDisableHTTP: opt.disable_http = 1; break;
562     case oDisableLDAP: opt.disable_ldap = 1; break;
563     case oHonorHTTPProxy: opt.honor_http_proxy = 1; break;
564     case oHTTPProxy: opt.http_proxy = pargs->r.ret_str; break;
565     case oLDAPProxy: opt.ldap_proxy = pargs->r.ret_str; break;
566     case oOnlyLDAPProxy: opt.only_ldap_proxy = 1; break;
567     case oIgnoreHTTPDP: opt.ignore_http_dp = 1; break;
568     case oIgnoreLDAPDP: opt.ignore_ldap_dp = 1; break;
569     case oIgnoreOCSPSvcUrl: opt.ignore_ocsp_service_url = 1; break;
570
571     case oAllowOCSP: opt.allow_ocsp = 1; break;
572     case oOCSPResponder: opt.ocsp_responder = pargs->r.ret_str; break;
573     case oOCSPSigner:
574       opt.ocsp_signer = parse_ocsp_signer (pargs->r.ret_str);
575       break;
576     case oOCSPMaxClockSkew: opt.ocsp_max_clock_skew = pargs->r.ret_int; break;
577     case oOCSPMaxPeriod: opt.ocsp_max_period = pargs->r.ret_int; break;
578     case oOCSPCurrentPeriod: opt.ocsp_current_period = pargs->r.ret_int; break;
579
580     case oMaxReplies: opt.max_replies = pargs->r.ret_int; break;
581
582     case oHkpCaCert:
583       {
584         char *tmpname;
585
586         /* Do tilde expansion and print a warning if the file can't be
587            accessed.  */
588         tmpname = make_absfilename_try (pargs->r.ret_str, NULL);
589         if (!tmpname || access (tmpname, F_OK))
590           log_info (_("can't access '%s': %s\n"),
591                     tmpname? tmpname : pargs->r.ret_str,
592                     gpg_strerror (gpg_error_from_syserror()));
593         else
594           http_register_tls_ca (tmpname);
595         xfree (tmpname);
596       }
597       break;
598
599     case oIgnoreCertExtension:
600       add_to_strlist (&opt.ignored_cert_extensions, pargs->r.ret_str);
601       break;
602
603     case oUseTor: opt.use_tor = 1; break;
604
605     case oKeyServer:
606       xfree (opt.keyserver);
607       opt.keyserver = *pargs->r.ret_str? xtrystrdup (pargs->r.ret_str) : NULL;
608       break;
609
610     default:
611       return 0; /* Not handled. */
612     }
613
614   return 1; /* Handled. */
615 }
616
617
618 #ifdef USE_W32_SERVICE
619 /* The global status of our service.  */
620 SERVICE_STATUS_HANDLE service_handle;
621 SERVICE_STATUS service_status;
622
623 DWORD WINAPI
624 w32_service_control (DWORD control, DWORD event_type, LPVOID event_data,
625                      LPVOID context)
626 {
627   (void)event_type;
628   (void)event_data;
629   (void)context;
630
631   /* event_type and event_data are not used here.  */
632   switch (control)
633     {
634     case SERVICE_CONTROL_SHUTDOWN:
635       /* For shutdown we will try to force termination.  */
636       service_status.dwCurrentState = SERVICE_STOP_PENDING;
637       SetServiceStatus (service_handle, &service_status);
638       shutdown_pending = 3;
639       break;
640
641     case SERVICE_CONTROL_STOP:
642       service_status.dwCurrentState = SERVICE_STOP_PENDING;
643       SetServiceStatus (service_handle, &service_status);
644       shutdown_pending = 1;
645       break;
646
647     default:
648       break;
649     }
650   return 0;
651 }
652 #endif /*USE_W32_SERVICE*/
653
654 #ifndef HAVE_W32_SYSTEM
655 static int
656 pid_suffix_callback (unsigned long *r_suffix)
657 {
658   union int_and_ptr_u value;
659
660   memset (&value, 0, sizeof value);
661   value.aptr = npth_getspecific (my_tlskey_current_fd);
662   *r_suffix = value.aint;
663   return (*r_suffix != -1);  /* Use decimal representation.  */
664 }
665 #endif /*!HAVE_W32_SYSTEM*/
666
667
668 #ifdef USE_W32_SERVICE
669 # define main real_main
670 #endif
671 int
672 main (int argc, char **argv)
673 {
674 #ifdef USE_W32_SERVICE
675 # undef main
676 #endif
677   enum cmd_and_opt_values cmd = 0;
678   ARGPARSE_ARGS pargs;
679   int orig_argc;
680   char **orig_argv;
681   FILE *configfp = NULL;
682   char *configname = NULL;
683   const char *shell;
684   unsigned configlineno;
685   int parse_debug = 0;
686   int default_config =1;
687   int greeting = 0;
688   int nogreeting = 0;
689   int nodetach = 0;
690   int csh_style = 0;
691   char *logfile = NULL;
692 #if USE_LDAP
693   char *ldapfile = NULL;
694 #endif /*USE_LDAP*/
695   int debug_wait = 0;
696   int rc;
697   int homedir_seen = 0;
698   struct assuan_malloc_hooks malloc_hooks;
699
700   early_system_init ();
701
702 #ifdef USE_W32_SERVICE
703   /* The option will be set by main() below if we should run as a
704      system daemon.  */
705   if (opt.system_service)
706     {
707       service_handle
708         = RegisterServiceCtrlHandlerEx ("DirMngr",
709                                         &w32_service_control, NULL /*FIXME*/);
710       if (service_handle == 0)
711         log_error ("failed to register service control handler: ec=%d",
712                    (int) GetLastError ());
713       service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
714       service_status.dwCurrentState = SERVICE_START_PENDING;
715       service_status.dwControlsAccepted
716         = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
717       service_status.dwWin32ExitCode = NO_ERROR;
718       service_status.dwServiceSpecificExitCode = NO_ERROR;
719       service_status.dwCheckPoint = 0;
720       service_status.dwWaitHint = 10000; /* 10 seconds timeout.  */
721       SetServiceStatus (service_handle, &service_status);
722     }
723 #endif /*USE_W32_SERVICE*/
724
725   set_strusage (my_strusage);
726   log_set_prefix (DIRMNGR_NAME, 1|4);
727
728   /* Make sure that our subsystems are ready.  */
729   i18n_init ();
730   init_common_subsystems (&argc, &argv);
731
732   npth_init ();
733
734   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
735
736  /* Check that the libraries are suitable.  Do it here because
737     the option parsing may need services of the libraries. */
738
739   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
740     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
741                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
742   if (!ksba_check_version (NEED_KSBA_VERSION) )
743     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
744                NEED_KSBA_VERSION, ksba_check_version (NULL) );
745
746   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
747   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
748
749   /* Init TLS library.  */
750 #if HTTP_USE_NTBTLS
751   if (!ntbtls_check_version (NEED_NTBTLS_VERSION) )
752     log_fatal( _("%s is too old (need %s, have %s)\n"), "ntbtls",
753                NEED_NTBTLS_VERSION, ntbtls_check_version (NULL) );
754 #elif HTTP_USE_GNUTLS
755   rc = gnutls_global_init ();
756   if (rc)
757     log_fatal ("gnutls_global_init failed: %s\n", gnutls_strerror (rc));
758 #endif /*HTTP_USE_GNUTLS*/
759
760   /* Init Assuan. */
761   malloc_hooks.malloc = gcry_malloc;
762   malloc_hooks.realloc = gcry_realloc;
763   malloc_hooks.free = gcry_free;
764   assuan_set_malloc_hooks (&malloc_hooks);
765   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
766   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
767   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
768   assuan_sock_init ();
769   setup_libassuan_logging (&opt.debug);
770
771   setup_libgcrypt_logging ();
772
773   /* Setup defaults. */
774   shell = getenv ("SHELL");
775   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
776     csh_style = 1;
777
778   opt.homedir = default_homedir ();
779
780   /* Now with NPth running we can set the logging callback.  Our
781      windows implementation does not yet feature the NPth TLS
782      functions.  */
783 #ifndef HAVE_W32_SYSTEM
784   if (npth_key_create (&my_tlskey_current_fd, NULL) == 0)
785     if (npth_setspecific (my_tlskey_current_fd, NULL) == 0)
786       log_set_pid_suffix_cb (pid_suffix_callback);
787 #endif /*!HAVE_W32_SYSTEM*/
788
789   /* Reset rereadable options to default values. */
790   parse_rereadable_options (NULL, 0);
791
792   /* LDAP defaults.  */
793   opt.add_new_ldapservers = 0;
794   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
795
796   /* Other defaults.  */
797
798   /* Check whether we have a config file given on the commandline */
799   orig_argc = argc;
800   orig_argv = argv;
801   pargs.argc = &argc;
802   pargs.argv = &argv;
803   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
804   while (arg_parse( &pargs, opts))
805     {
806       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
807         parse_debug++;
808       else if (pargs.r_opt == oOptions)
809         { /* Yes there is one, so we do not try the default one, but
810              read the option file when it is encountered at the
811              commandline */
812           default_config = 0;
813         }
814       else if (pargs.r_opt == oNoOptions)
815         default_config = 0; /* --no-options */
816       else if (pargs.r_opt == oHomedir)
817         {
818           opt.homedir = pargs.r.ret_str;
819           homedir_seen = 1;
820         }
821       else if (pargs.r_opt == aDaemon)
822         opt.system_daemon = 1;
823       else if (pargs.r_opt == aService)
824         {
825           /* Redundant.  The main function takes care of it.  */
826           opt.system_service = 1;
827           opt.system_daemon = 1;
828         }
829 #ifdef HAVE_W32_SYSTEM
830       else if (pargs.r_opt == aGPGConfList || pargs.r_opt == aGPGConfTest)
831         /* We set this so we switch to the system configuration
832            directory below.  This is a crutch to solve the problem
833            that the user configuration is never used on Windows.  Also
834            see below at aGPGConfList.  */
835         opt.system_daemon = 1;
836 #endif
837     }
838
839   /* If --daemon has been given on the command line but not --homedir,
840      we switch to /etc/gnupg as default home directory.  Note, that
841      this also overrides the GNUPGHOME environment variable.  */
842   if (opt.system_daemon && !homedir_seen)
843     {
844 #ifdef HAVE_W32CE_SYSTEM
845       opt.homedir = DIRSEP_S "gnupg";
846 #else
847       opt.homedir = gnupg_sysconfdir ();
848 #endif
849       opt.homedir_cache = gnupg_cachedir ();
850       socket_name = dirmngr_sys_socket_name ();
851     }
852   else if (dirmngr_user_socket_name ())
853     socket_name = dirmngr_user_socket_name ();
854   else
855     socket_name = dirmngr_sys_socket_name ();
856
857   if (default_config)
858     configname = make_filename (opt.homedir, DIRMNGR_NAME".conf", NULL );
859
860   argc = orig_argc;
861   argv = orig_argv;
862   pargs.argc = &argc;
863   pargs.argv = &argv;
864   pargs.flags= 1;  /* do not remove the args */
865  next_pass:
866   if (configname)
867     {
868       configlineno = 0;
869       configfp = fopen (configname, "r");
870       if (!configfp)
871         {
872           if (default_config)
873             {
874               if( parse_debug )
875                 log_info (_("Note: no default option file '%s'\n"),
876                           configname );
877             }
878           else
879             {
880               log_error (_("option file '%s': %s\n"),
881                          configname, strerror(errno) );
882               exit(2);
883             }
884           xfree (configname);
885           configname = NULL;
886         }
887       if (parse_debug && configname )
888         log_info (_("reading options from '%s'\n"), configname );
889       default_config = 0;
890     }
891
892   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
893     {
894       if (parse_rereadable_options (&pargs, 0))
895         continue; /* Already handled */
896       switch (pargs.r_opt)
897         {
898         case aServer:
899         case aDaemon:
900         case aService:
901         case aShutdown:
902         case aFlush:
903         case aListCRLs:
904         case aLoadCRL:
905         case aFetchCRL:
906         case aGPGConfList:
907         case aGPGConfTest:
908           cmd = pargs.r_opt;
909           break;
910
911         case oQuiet: opt.quiet = 1; break;
912         case oVerbose: opt.verbose++; break;
913         case oBatch: opt.batch=1; break;
914
915         case oDebugWait: debug_wait = pargs.r.ret_int; break;
916
917         case oOptions:
918           /* Config files may not be nested (silently ignore them) */
919           if (!configfp)
920             {
921                 xfree(configname);
922                 configname = xstrdup(pargs.r.ret_str);
923                 goto next_pass;
924             }
925           break;
926         case oNoGreeting: nogreeting = 1; break;
927         case oNoVerbose: opt.verbose = 0; break;
928         case oNoOptions: break; /* no-options */
929         case oHomedir: /* Ignore this option here. */; break;
930         case oNoDetach: nodetach = 1; break;
931         case oLogFile: logfile = pargs.r.ret_str; break;
932         case oCsh: csh_style = 1; break;
933         case oSh: csh_style = 0; break;
934         case oLDAPFile:
935 #        if USE_LDAP
936           ldapfile = pargs.r.ret_str;
937 #        endif /*USE_LDAP*/
938           break;
939         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
940         case oLDAPTimeout:
941           opt.ldaptimeout = pargs.r.ret_int;
942           break;
943
944         case oFakedSystemTime:
945           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
946           break;
947
948         case oForce: opt.force = 1; break;
949
950         case oSocketName: socket_name = pargs.r.ret_str; break;
951
952         default : pargs.err = configfp? 1:2; break;
953         }
954     }
955   if (configfp)
956     {
957       fclose (configfp);
958       configfp = NULL;
959       /* Keep a copy of the name so that it can be read on SIGHUP. */
960       opt.config_filename = configname;
961       configname = NULL;
962       goto next_pass;
963     }
964   xfree (configname);
965   configname = NULL;
966   if (log_get_errorcount(0))
967     exit(2);
968   if (nogreeting )
969     greeting = 0;
970
971   if (!opt.homedir_cache)
972     opt.homedir_cache = opt.homedir;
973
974   if (greeting)
975     {
976       es_fprintf (es_stderr, "%s %s; %s\n",
977                   strusage(11), strusage(13), strusage(14) );
978       es_fprintf (es_stderr, "%s\n", strusage(15) );
979     }
980
981 #ifdef IS_DEVELOPMENT_VERSION
982   log_info ("NOTE: this is a development version!\n");
983 #endif
984
985   if (opt.use_tor)
986     {
987       log_info ("WARNING: ***************************************\n");
988       log_info ("WARNING: TOR mode (--use-tor) DOES NOT YET WORK!\n");
989       log_info ("WARNING: ***************************************\n");
990     }
991
992
993   /* Print a warning if an argument looks like an option.  */
994   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
995     {
996       int i;
997
998       for (i=0; i < argc; i++)
999         if (argv[i][0] == '-' && argv[i][1] == '-')
1000           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1001     }
1002
1003   if (!access ("/etc/"DIRMNGR_NAME, F_OK) && !strncmp (opt.homedir, "/etc/", 5))
1004     log_info
1005       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
1006        " other directory names changed.  Please check that no other version"
1007        " of dirmngr is still installed.  To disable this warning, remove the"
1008        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
1009
1010   if (gnupg_faked_time_p ())
1011     {
1012       gnupg_isotime_t tbuf;
1013
1014       log_info (_("WARNING: running with faked system time: "));
1015       gnupg_get_isotime (tbuf);
1016       dump_isotime (tbuf);
1017       log_printf ("\n");
1018     }
1019
1020   set_debug ();
1021
1022   /* Get LDAP server list from file. */
1023 #if USE_LDAP
1024   if (!ldapfile)
1025     {
1026       ldapfile = make_filename (opt.homedir,
1027                                 opt.system_daemon?
1028                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
1029                                 NULL);
1030       opt.ldapservers = parse_ldapserver_file (ldapfile);
1031       xfree (ldapfile);
1032     }
1033   else
1034       opt.ldapservers = parse_ldapserver_file (ldapfile);
1035 #endif /*USE_LDAP*/
1036
1037 #ifndef HAVE_W32_SYSTEM
1038   /* We need to ignore the PIPE signal because the we might log to a
1039      socket and that code handles EPIPE properly.  The ldap wrapper
1040      also requires us to ignore this silly signal. Assuan would set
1041      this signal to ignore anyway.*/
1042   signal (SIGPIPE, SIG_IGN);
1043 #endif
1044
1045   /* Ready.  Now to our duties. */
1046   if (!cmd && opt.system_service)
1047     cmd = aDaemon;
1048   else if (!cmd)
1049     cmd = aServer;
1050   rc = 0;
1051
1052   if (cmd == aServer)
1053     {
1054       /* Note that this server mode is mainly useful for debugging.  */
1055       if (argc)
1056         wrong_args ("--server");
1057
1058       if (logfile)
1059         {
1060           log_set_file (logfile);
1061           log_set_prefix (NULL, 2|4);
1062         }
1063
1064       if (debug_wait)
1065         {
1066           log_debug ("waiting for debugger - my pid is %u .....\n",
1067                      (unsigned int)getpid());
1068           gnupg_sleep (debug_wait);
1069           log_debug ("... okay\n");
1070         }
1071
1072 #if USE_LDAP
1073       ldap_wrapper_launch_thread ();
1074 #endif /*USE_LDAP*/
1075
1076       cert_cache_init ();
1077       crl_cache_init ();
1078       start_command_handler (ASSUAN_INVALID_FD);
1079       shutdown_reaper ();
1080     }
1081   else if (cmd == aDaemon)
1082     {
1083       assuan_fd_t fd;
1084       pid_t pid;
1085       int len;
1086       struct sockaddr_un serv_addr;
1087
1088       if (argc)
1089         wrong_args ("--daemon");
1090
1091       /* Now start with logging to a file if this is desired. */
1092       if (logfile)
1093         {
1094           log_set_file (logfile);
1095           log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1096                                  |GPGRT_LOG_WITH_TIME
1097                                  |GPGRT_LOG_WITH_PID));
1098           current_logfile = xstrdup (logfile);
1099         }
1100
1101 #ifndef HAVE_W32_SYSTEM
1102       if (strchr (socket_name, ':'))
1103         {
1104           log_error (_("colons are not allowed in the socket name\n"));
1105           dirmngr_exit (1);
1106         }
1107 #endif
1108       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1109       if (fd == ASSUAN_INVALID_FD)
1110         {
1111           log_error (_("can't create socket: %s\n"), strerror (errno));
1112           cleanup ();
1113           dirmngr_exit (1);
1114         }
1115
1116 #if ASSUAN_VERSION_NUMBER >= 0x020104 /* >= 2.1.4 */
1117       {
1118         int redirected;
1119
1120         if (assuan_sock_set_sockaddr_un (socket_name,
1121                                          (struct sockaddr*)&serv_addr,
1122                                          &redirected))
1123           {
1124             if (errno == ENAMETOOLONG)
1125               log_error (_("socket name '%s' is too long\n"), socket_name);
1126             else
1127               log_error ("error preparing socket '%s': %s\n",
1128                          socket_name,
1129                          gpg_strerror (gpg_error_from_syserror ()));
1130             dirmngr_exit (1);
1131           }
1132         if (redirected)
1133           {
1134             redir_socket_name = xstrdup (serv_addr.sun_path);
1135             if (opt.verbose)
1136               log_info ("redirecting socket '%s' to '%s'\n",
1137                         socket_name, redir_socket_name);
1138           }
1139       }
1140 #else /* Assuan < 2.1.4 */
1141       memset (&serv_addr, 0, sizeof serv_addr);
1142       serv_addr.sun_family = AF_UNIX;
1143       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path )
1144         {
1145           log_error (_("socket name '%s' is too long\n"), socket_name);
1146           dirmngr_exit (1);
1147         }
1148       strcpy (serv_addr.sun_path, socket_name);
1149 #endif /* Assuan < 2.1.4 */
1150
1151       len = SUN_LEN (&serv_addr);
1152
1153       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1154       if (rc == -1
1155           && (errno == EADDRINUSE
1156 #ifdef HAVE_W32_SYSTEM
1157               || errno == EEXIST
1158 #endif
1159               ))
1160         {
1161           /* Fixme: We should test whether a dirmngr is already running. */
1162           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1163           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1164         }
1165       if (rc != -1
1166           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1167         log_error (_("error getting nonce for the socket\n"));
1168       if (rc == -1)
1169         {
1170           log_error (_("error binding socket to '%s': %s\n"),
1171                      serv_addr.sun_path,
1172                      gpg_strerror (gpg_error_from_errno (errno)));
1173           assuan_sock_close (fd);
1174           dirmngr_exit (1);
1175         }
1176       cleanup_socket = 1;
1177
1178       if (listen (FD2INT (fd), 5) == -1)
1179         {
1180           log_error (_("listen() failed: %s\n"), strerror (errno));
1181           assuan_sock_close (fd);
1182           dirmngr_exit (1);
1183         }
1184
1185       if (opt.verbose)
1186         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1187
1188       es_fflush (NULL);
1189
1190       /* Note: We keep the dirmngr_info output only for the sake of
1191          existing scripts which might use this to detect a successful
1192          start of the dirmngr.  */
1193 #ifdef HAVE_W32_SYSTEM
1194       (void)csh_style;
1195       (void)nodetach;
1196
1197       pid = getpid ();
1198       es_printf ("set %s=%s;%lu;1\n",
1199                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1200 #else
1201       pid = fork();
1202       if (pid == (pid_t)-1)
1203         {
1204           log_fatal (_("error forking process: %s\n"), strerror (errno));
1205           dirmngr_exit (1);
1206         }
1207
1208       if (pid)
1209         { /* We are the parent */
1210           char *infostr;
1211
1212           /* Don't let cleanup() remove the socket - the child is
1213              responsible for doing that.  */
1214           cleanup_socket = 0;
1215
1216           close (fd);
1217
1218           /* Create the info string: <name>:<pid>:<protocol_version> */
1219           if (asprintf (&infostr, "%s=%s:%lu:1",
1220                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1221             {
1222               log_error (_("out of core\n"));
1223               kill (pid, SIGTERM);
1224               dirmngr_exit (1);
1225             }
1226           /* Print the environment string, so that the caller can use
1227              shell's eval to set it.  But see above.  */
1228           if (csh_style)
1229             {
1230               *strchr (infostr, '=') = ' ';
1231               es_printf ( "setenv %s;\n", infostr);
1232             }
1233           else
1234             {
1235               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1236             }
1237           free (infostr);
1238           exit (0);
1239           /*NEVER REACHED*/
1240         } /* end parent */
1241
1242
1243       /*
1244          This is the child
1245        */
1246
1247       /* Detach from tty and put process into a new session */
1248       if (!nodetach )
1249         {
1250           int i;
1251           unsigned int oldflags;
1252
1253           /* Close stdin, stdout and stderr unless it is the log stream */
1254           for (i=0; i <= 2; i++)
1255             {
1256               if (!log_test_fd (i) && i != fd )
1257                 close (i);
1258             }
1259           if (setsid() == -1)
1260             {
1261               log_error ("setsid() failed: %s\n", strerror(errno) );
1262               dirmngr_exit (1);
1263             }
1264
1265           log_get_prefix (&oldflags);
1266           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1267           opt.running_detached = 1;
1268
1269           if (chdir("/"))
1270             {
1271               log_error ("chdir to / failed: %s\n", strerror (errno));
1272               dirmngr_exit (1);
1273             }
1274         }
1275 #endif
1276
1277 #if USE_LDAP
1278       ldap_wrapper_launch_thread ();
1279 #endif /*USE_LDAP*/
1280
1281       cert_cache_init ();
1282       crl_cache_init ();
1283 #ifdef USE_W32_SERVICE
1284       if (opt.system_service)
1285         {
1286           service_status.dwCurrentState = SERVICE_RUNNING;
1287           SetServiceStatus (service_handle, &service_status);
1288         }
1289 #endif
1290       handle_connections (fd);
1291       assuan_sock_close (fd);
1292       shutdown_reaper ();
1293 #ifdef USE_W32_SERVICE
1294       if (opt.system_service)
1295         {
1296           service_status.dwCurrentState = SERVICE_STOPPED;
1297           SetServiceStatus (service_handle, &service_status);
1298         }
1299 #endif
1300     }
1301   else if (cmd == aListCRLs)
1302     {
1303       /* Just list the CRL cache and exit. */
1304       if (argc)
1305         wrong_args ("--list-crls");
1306 #if USE_LDAP
1307       ldap_wrapper_launch_thread ();
1308 #endif /*USE_LDAP*/
1309       crl_cache_init ();
1310       crl_cache_list (es_stdout);
1311     }
1312   else if (cmd == aLoadCRL)
1313     {
1314       struct server_control_s ctrlbuf;
1315
1316       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1317       dirmngr_init_default_ctrl (&ctrlbuf);
1318
1319 #if USE_LDAP
1320       ldap_wrapper_launch_thread ();
1321 #endif /*USE_LDAP*/
1322       cert_cache_init ();
1323       crl_cache_init ();
1324       if (!argc)
1325         rc = crl_cache_load (&ctrlbuf, NULL);
1326       else
1327         {
1328           for (; !rc && argc; argc--, argv++)
1329             rc = crl_cache_load (&ctrlbuf, *argv);
1330         }
1331       dirmngr_deinit_default_ctrl (&ctrlbuf);
1332     }
1333   else if (cmd == aFetchCRL)
1334     {
1335       ksba_reader_t reader;
1336       struct server_control_s ctrlbuf;
1337
1338       if (argc != 1)
1339         wrong_args ("--fetch-crl URL");
1340
1341       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1342       dirmngr_init_default_ctrl (&ctrlbuf);
1343
1344 #if USE_LDAP
1345       ldap_wrapper_launch_thread ();
1346 #endif /*USE_LDAP*/
1347       cert_cache_init ();
1348       crl_cache_init ();
1349       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1350       if (rc)
1351         log_error (_("fetching CRL from '%s' failed: %s\n"),
1352                      argv[0], gpg_strerror (rc));
1353       else
1354         {
1355           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1356           if (rc)
1357             log_error (_("processing CRL from '%s' failed: %s\n"),
1358                        argv[0], gpg_strerror (rc));
1359           crl_close_reader (reader);
1360         }
1361       dirmngr_deinit_default_ctrl (&ctrlbuf);
1362     }
1363   else if (cmd == aFlush)
1364     {
1365       /* Delete cache and exit. */
1366       if (argc)
1367         wrong_args ("--flush");
1368       rc = crl_cache_flush();
1369     }
1370   else if (cmd == aGPGConfTest)
1371     dirmngr_exit (0);
1372   else if (cmd == aGPGConfList)
1373     {
1374       unsigned long flags = 0;
1375       char *filename;
1376       char *filename_esc;
1377
1378 #ifdef HAVE_W32_SYSTEM
1379       /* On Windows systems, dirmngr always runs as system daemon, and
1380          the per-user configuration is never used.  So we short-cut
1381          everything to use the global system configuration of dirmngr
1382          above, and here we set the no change flag to make these
1383          read-only.  */
1384       flags |= GC_OPT_FLAG_NO_CHANGE;
1385 #endif
1386
1387       /* First the configuration file.  This is not an option, but it
1388          is vital information for GPG Conf.  */
1389       if (!opt.config_filename)
1390         opt.config_filename = make_filename (opt.homedir,
1391                                              "dirmngr.conf", NULL );
1392
1393       filename = percent_escape (opt.config_filename, NULL);
1394       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1395               GC_OPT_FLAG_DEFAULT, filename);
1396       xfree (filename);
1397
1398       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1399       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1400       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1401       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1402       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1403
1404       /* --csh and --sh are mutually exclusive, something we can not
1405          express in GPG Conf.  --options is only usable from the
1406          command line, really.  --debug-all interacts with --debug,
1407          and having both of them is thus problematic.  --no-detach is
1408          also only usable on the command line.  --batch is unused.  */
1409
1410       filename = make_filename (opt.homedir,
1411                                 opt.system_daemon?
1412                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
1413                                 NULL);
1414       filename_esc = percent_escape (filename, NULL);
1415       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1416               filename_esc);
1417       xfree (filename_esc);
1418       xfree (filename);
1419
1420       es_printf ("ldaptimeout:%lu:%u\n",
1421               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1422       es_printf ("max-replies:%lu:%u\n",
1423               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1424       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1425       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1426       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1427
1428       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1429       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1430
1431       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1432       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1433       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1434       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1435       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1436       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1437       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1438       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1439       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1440       /* Note: The next one is to fix a typo in gpgconf - should be
1441          removed eventually. */
1442       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1443
1444       es_printf ("use-tor:%lu:\n", flags | GC_OPT_FLAG_NONE);
1445       es_printf ("keyserver:%lu:\n", flags | GC_OPT_FLAG_NONE);
1446     }
1447   cleanup ();
1448   return !!rc;
1449 }
1450
1451
1452 #ifdef USE_W32_SERVICE
1453 static void WINAPI
1454 call_real_main (DWORD argc, LPSTR *argv)
1455 {
1456   real_main (argc, argv);
1457 }
1458
1459 int
1460 main (int argc, char *argv[])
1461 {
1462   int i;
1463
1464   /* Find out if we run in daemon mode or on the command line.  */
1465   for (i = 1; i < argc; i++)
1466     if (!strcmp (argv[i], "--service"))
1467       {
1468         opt.system_service = 1;
1469         opt.system_daemon = 1;
1470         break;
1471       }
1472
1473   if (!opt.system_service)
1474     return real_main (argc, argv);
1475   else
1476     {
1477       SERVICE_TABLE_ENTRY DispatchTable [] =
1478         {
1479           { "DirMngr", &call_real_main },
1480           { NULL, NULL }
1481         };
1482
1483       if (!StartServiceCtrlDispatcher (DispatchTable))
1484         return 1;
1485       return 0;
1486     }
1487 }
1488 #endif /*USE_W32_SERVICE*/
1489
1490
1491 static void
1492 cleanup (void)
1493 {
1494   crl_cache_deinit ();
1495   cert_cache_deinit (1);
1496
1497 #if USE_LDAP
1498   ldapserver_list_free (opt.ldapservers);
1499 #endif /*USE_LDAP*/
1500   opt.ldapservers = NULL;
1501
1502   if (cleanup_socket)
1503     {
1504       cleanup_socket = 0;
1505       if (redir_socket_name)
1506         gnupg_remove (redir_socket_name);
1507       else if (socket_name && *socket_name)
1508         gnupg_remove (socket_name);
1509     }
1510 }
1511
1512
1513 void
1514 dirmngr_exit (int rc)
1515 {
1516   cleanup ();
1517   exit (rc);
1518 }
1519
1520
1521 void
1522 dirmngr_init_default_ctrl (ctrl_t ctrl)
1523 {
1524   if (opt.http_proxy)
1525     ctrl->http_proxy = xstrdup (opt.http_proxy);
1526 }
1527
1528
1529 void
1530 dirmngr_deinit_default_ctrl (ctrl_t ctrl)
1531 {
1532   if (!ctrl)
1533     return;
1534   xfree (ctrl->http_proxy);
1535   ctrl->http_proxy = NULL;
1536 }
1537
1538
1539 /* Create a list of LDAP servers from the file FILENAME. Returns the
1540    list or NULL in case of errors.
1541
1542    The format fo such a file is line oriented where empty lines and
1543    lines starting with a hash mark are ignored.  All other lines are
1544    assumed to be colon seprated with these fields:
1545
1546    1. field: Hostname
1547    2. field: Portnumber
1548    3. field: Username
1549    4. field: Password
1550    5. field: Base DN
1551
1552 */
1553 #if USE_LDAP
1554 static ldap_server_t
1555 parse_ldapserver_file (const char* filename)
1556 {
1557   char buffer[1024];
1558   char *p;
1559   ldap_server_t server, serverstart, *serverend;
1560   int c;
1561   unsigned int lineno = 0;
1562   estream_t fp;
1563
1564   fp = es_fopen (filename, "r");
1565   if (!fp)
1566     {
1567       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1568       return NULL;
1569     }
1570
1571   serverstart = NULL;
1572   serverend = &serverstart;
1573   while (es_fgets (buffer, sizeof buffer, fp))
1574     {
1575       lineno++;
1576       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1577         {
1578           if (*buffer && es_feof (fp))
1579             ; /* Last line not terminated - continue. */
1580           else
1581             {
1582               log_error (_("%s:%u: line too long - skipped\n"),
1583                          filename, lineno);
1584               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1585                 ; /* Skip until end of line. */
1586               continue;
1587             }
1588         }
1589       /* Skip empty and comment lines.*/
1590       for (p=buffer; spacep (p); p++)
1591         ;
1592       if (!*p || *p == '\n' || *p == '#')
1593         continue;
1594
1595       /* Parse the colon separated fields. */
1596       server = ldapserver_parse_one (buffer, filename, lineno);
1597       if (server)
1598         {
1599           *serverend = server;
1600           serverend = &server->next;
1601         }
1602     }
1603
1604   if (es_ferror (fp))
1605     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1606   es_fclose (fp);
1607
1608   return serverstart;
1609 }
1610 #endif /*USE_LDAP*/
1611
1612 static fingerprint_list_t
1613 parse_ocsp_signer (const char *string)
1614 {
1615   gpg_error_t err;
1616   char *fname;
1617   estream_t fp;
1618   char line[256];
1619   char *p;
1620   fingerprint_list_t list, *list_tail, item;
1621   unsigned int lnr = 0;
1622   int c, i, j;
1623   int errflag = 0;
1624
1625
1626   /* Check whether this is not a filename and treat it as a direct
1627      fingerprint specification.  */
1628   if (!strpbrk (string, "/.~\\"))
1629     {
1630       item = xcalloc (1, sizeof *item);
1631       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1632         if ( string[i] != ':' )
1633           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1634       item->hexfpr[j] = 0;
1635       if (j != 40 || !(spacep (string+i) || !string[i]))
1636         {
1637           log_error (_("%s:%u: invalid fingerprint detected\n"),
1638                      "--ocsp-signer", 0);
1639           xfree (item);
1640           return NULL;
1641         }
1642       return item;
1643     }
1644
1645   /* Well, it is a filename.  */
1646   if (*string == '/' || (*string == '~' && string[1] == '/'))
1647     fname = make_filename (string, NULL);
1648   else
1649     {
1650       if (string[0] == '.' && string[1] == '/' )
1651         string += 2;
1652       fname = make_filename (opt.homedir, string, NULL);
1653     }
1654
1655   fp = es_fopen (fname, "r");
1656   if (!fp)
1657     {
1658       err = gpg_error_from_syserror ();
1659       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1660       xfree (fname);
1661       return NULL;
1662     }
1663
1664   list = NULL;
1665   list_tail = &list;
1666   for (;;)
1667     {
1668       if (!es_fgets (line, DIM(line)-1, fp) )
1669         {
1670           if (!es_feof (fp))
1671             {
1672               err = gpg_error_from_syserror ();
1673               log_error (_("%s:%u: read error: %s\n"),
1674                          fname, lnr, gpg_strerror (err));
1675               errflag = 1;
1676             }
1677           es_fclose (fp);
1678           if (errflag)
1679             {
1680               while (list)
1681                 {
1682                   fingerprint_list_t tmp = list->next;
1683                   xfree (list);
1684                   list = tmp;
1685                 }
1686             }
1687           xfree (fname);
1688           return list; /* Ready.  */
1689         }
1690
1691       lnr++;
1692       if (!*line || line[strlen(line)-1] != '\n')
1693         {
1694           /* Eat until end of line. */
1695           while ( (c=es_getc (fp)) != EOF && c != '\n')
1696             ;
1697           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1698                            /* */: GPG_ERR_INCOMPLETE_LINE);
1699           log_error (_("%s:%u: read error: %s\n"),
1700                      fname, lnr, gpg_strerror (err));
1701           errflag = 1;
1702           continue;
1703         }
1704
1705       /* Allow for empty lines and spaces */
1706       for (p=line; spacep (p); p++)
1707         ;
1708       if (!*p || *p == '\n' || *p == '#')
1709         continue;
1710
1711       item = xcalloc (1, sizeof *item);
1712       *list_tail = item;
1713       list_tail = &item->next;
1714
1715       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1716         if ( p[i] != ':' )
1717           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1718       item->hexfpr[j] = 0;
1719       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1720         {
1721           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1722           errflag = 1;
1723         }
1724       i++;
1725       while (spacep (p+i))
1726         i++;
1727       if (p[i] && p[i] != '\n')
1728         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1729     }
1730   /*NOTREACHED*/
1731 }
1732
1733
1734
1735 \f
1736 /*
1737    Stuff used in daemon mode.
1738  */
1739
1740
1741
1742 /* Reread parts of the configuration.  Note, that this function is
1743    obviously not thread-safe and should only be called from the NPTH
1744    signal handler.
1745
1746    Fixme: Due to the way the argument parsing works, we create a
1747    memory leak here for all string type arguments.  There is currently
1748    no clean way to tell whether the memory for the argument has been
1749    allocated or points into the process' original arguments.  Unless
1750    we have a mechanism to tell this, we need to live on with this. */
1751 static void
1752 reread_configuration (void)
1753 {
1754   ARGPARSE_ARGS pargs;
1755   FILE *fp;
1756   unsigned int configlineno = 0;
1757   int dummy;
1758
1759   if (!opt.config_filename)
1760     return; /* No config file. */
1761
1762   fp = fopen (opt.config_filename, "r");
1763   if (!fp)
1764     {
1765       log_error (_("option file '%s': %s\n"),
1766                  opt.config_filename, strerror(errno) );
1767       return;
1768     }
1769
1770   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1771
1772   memset (&pargs, 0, sizeof pargs);
1773   dummy = 0;
1774   pargs.argc = &dummy;
1775   pargs.flags = 1;  /* do not remove the args */
1776   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1777     {
1778       if (pargs.r_opt < -1)
1779         pargs.err = 1; /* Print a warning. */
1780       else /* Try to parse this option - ignore unchangeable ones. */
1781         parse_rereadable_options (&pargs, 1);
1782     }
1783   fclose (fp);
1784
1785   set_debug ();
1786 }
1787
1788
1789 /* A global function which allows us to trigger the reload stuff from
1790    other places.  */
1791 void
1792 dirmngr_sighup_action (void)
1793 {
1794   log_info (_("SIGHUP received - "
1795               "re-reading configuration and flushing caches\n"));
1796   reread_configuration ();
1797   cert_cache_deinit (0);
1798   crl_cache_deinit ();
1799   cert_cache_init ();
1800   crl_cache_init ();
1801 }
1802
1803
1804
1805 /* The signal handler. */
1806 #ifndef HAVE_W32_SYSTEM
1807 static void
1808 handle_signal (int signo)
1809 {
1810   switch (signo)
1811     {
1812     case SIGHUP:
1813       dirmngr_sighup_action ();
1814       break;
1815
1816     case SIGUSR1:
1817       cert_cache_print_stats ();
1818       break;
1819
1820     case SIGUSR2:
1821       log_info (_("SIGUSR2 received - no action defined\n"));
1822       break;
1823
1824     case SIGTERM:
1825       if (!shutdown_pending)
1826         log_info (_("SIGTERM received - shutting down ...\n"));
1827       else
1828         log_info (_("SIGTERM received - still %d active connections\n"),
1829                   active_connections);
1830       shutdown_pending++;
1831       if (shutdown_pending > 2)
1832         {
1833           log_info (_("shutdown forced\n"));
1834           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1835           cleanup ();
1836           dirmngr_exit (0);
1837         }
1838       break;
1839
1840     case SIGINT:
1841       log_info (_("SIGINT received - immediate shutdown\n"));
1842       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1843       cleanup ();
1844       dirmngr_exit (0);
1845       break;
1846
1847     default:
1848       log_info (_("signal %d received - no action defined\n"), signo);
1849     }
1850 }
1851 #endif /*!HAVE_W32_SYSTEM*/
1852
1853
1854 /* Thread to do the housekeeping.  */
1855 static void *
1856 housekeeping_thread (void *arg)
1857 {
1858   static int sentinel;
1859   time_t curtime;
1860
1861   (void)arg;
1862
1863   curtime = gnupg_get_time ();
1864   if (sentinel)
1865     {
1866       log_info ("housekeeping is already going on\n");
1867       return NULL;
1868     }
1869   sentinel++;
1870   if (opt.verbose)
1871     log_info ("starting housekeeping\n");
1872
1873   ks_hkp_housekeeping (curtime);
1874
1875   if (opt.verbose)
1876     log_info ("ready with housekeeping\n");
1877   sentinel--;
1878   return NULL;
1879
1880 }
1881
1882
1883 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1884 # pragma GCC push_options
1885 # pragma GCC optimize ("no-strict-overflow")
1886 #endif
1887 static int
1888 time_for_housekeeping_p (time_t curtime)
1889 {
1890   static time_t last_housekeeping;
1891
1892   if (!last_housekeeping)
1893     last_housekeeping = curtime;
1894
1895   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1896       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1897     {
1898       last_housekeeping = curtime;
1899       return 1;
1900     }
1901   return 0;
1902 }
1903 #if GPGRT_GCC_HAVE_PUSH_PRAGMA
1904 # pragma GCC pop_options
1905 #endif
1906
1907
1908 /* This is the worker for the ticker.  It is called every few seconds
1909    and may only do fast operations. */
1910 static void
1911 handle_tick (void)
1912 {
1913   /* Under Windows we don't use signals and need a way for the loop to
1914      check for the shutdown flag.  */
1915 #ifdef HAVE_W32_SYSTEM
1916   if (shutdown_pending)
1917     log_info (_("SIGTERM received - shutting down ...\n"));
1918   if (shutdown_pending > 2)
1919     {
1920       log_info (_("shutdown forced\n"));
1921       log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1922       cleanup ();
1923       dirmngr_exit (0);
1924     }
1925 #endif /*HAVE_W32_SYSTEM*/
1926
1927   if (time_for_housekeeping_p (gnupg_get_time ()))
1928     {
1929       npth_t thread;
1930       npth_attr_t tattr;
1931       int err;
1932
1933       err = npth_attr_init (&tattr);
1934       if (err)
1935         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
1936       else
1937         {
1938           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1939           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
1940           if (err)
1941             log_error ("error spawning housekeeping thread: %s\n",
1942                        strerror (err));
1943           npth_attr_destroy (&tattr);
1944         }
1945     }
1946 }
1947
1948
1949 /* Check the nonce on a new connection.  This is a NOP unless we are
1950    using our Unix domain socket emulation under Windows.  */
1951 static int
1952 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1953 {
1954   if (assuan_sock_check_nonce (fd, nonce))
1955     {
1956       log_info (_("error reading nonce on fd %d: %s\n"),
1957                 FD2INT (fd), strerror (errno));
1958       assuan_sock_close (fd);
1959       return -1;
1960     }
1961   else
1962     return 0;
1963 }
1964
1965
1966 /* Helper to call a connection's main fucntion. */
1967 static void *
1968 start_connection_thread (void *arg)
1969 {
1970   union int_and_ptr_u argval;
1971   gnupg_fd_t fd;
1972
1973   memset (&argval, 0, sizeof argval);
1974   argval.aptr = arg;
1975   fd = argval.afd;
1976
1977   if (check_nonce (fd, &socket_nonce))
1978     {
1979       log_error ("handler nonce check FAILED\n");
1980       return NULL;
1981     }
1982
1983 #ifndef HAVE_W32_SYSTEM
1984   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1985 #endif
1986
1987   active_connections++;
1988   if (opt.verbose)
1989     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1990
1991   start_command_handler (fd);
1992
1993   if (opt.verbose)
1994     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1995   active_connections--;
1996
1997 #ifndef HAVE_W32_SYSTEM
1998   argval.afd = ASSUAN_INVALID_FD;
1999   npth_setspecific (my_tlskey_current_fd, argval.aptr);
2000 #endif
2001
2002   return NULL;
2003 }
2004
2005
2006 /* Main loop in daemon mode. */
2007 static void
2008 handle_connections (assuan_fd_t listen_fd)
2009 {
2010   npth_attr_t tattr;
2011 #ifndef HAVE_W32_SYSTEM
2012   int signo;
2013 #endif
2014   struct sockaddr_un paddr;
2015   socklen_t plen = sizeof( paddr );
2016   gnupg_fd_t fd;
2017   int nfd, ret;
2018   fd_set fdset, read_fdset;
2019   struct timespec abstime;
2020   struct timespec curtime;
2021   struct timespec timeout;
2022   int saved_errno;
2023
2024   npth_attr_init (&tattr);
2025   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2026
2027 #ifndef HAVE_W32_SYSTEM /* FIXME */
2028   npth_sigev_init ();
2029   npth_sigev_add (SIGHUP);
2030   npth_sigev_add (SIGUSR1);
2031   npth_sigev_add (SIGUSR2);
2032   npth_sigev_add (SIGINT);
2033   npth_sigev_add (SIGTERM);
2034   npth_sigev_fini ();
2035 #endif
2036
2037   /* Setup the fdset.  It has only one member.  This is because we use
2038      pth_select instead of pth_accept to properly sync timeouts with
2039      to full second.  */
2040   FD_ZERO (&fdset);
2041   FD_SET (FD2INT (listen_fd), &fdset);
2042   nfd = FD2INT (listen_fd);
2043
2044   npth_clock_gettime (&abstime);
2045   abstime.tv_sec += TIMERTICK_INTERVAL;
2046
2047   /* Main loop.  */
2048   for (;;)
2049     {
2050       /* Shutdown test.  */
2051       if (shutdown_pending)
2052         {
2053           if (!active_connections)
2054             break; /* ready */
2055
2056           /* Do not accept new connections but keep on running the
2057              loop to cope with the timer events.  */
2058           FD_ZERO (&fdset);
2059         }
2060
2061       /* Take a copy of the fdset.  */
2062       read_fdset = fdset;
2063
2064       npth_clock_gettime (&curtime);
2065       if (!(npth_timercmp (&curtime, &abstime, <)))
2066         {
2067           /* Timeout.  */
2068           handle_tick ();
2069           npth_clock_gettime (&abstime);
2070           abstime.tv_sec += TIMERTICK_INTERVAL;
2071         }
2072       npth_timersub (&abstime, &curtime, &timeout);
2073
2074 #ifndef HAVE_W32_SYSTEM
2075       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout, npth_sigev_sigmask());
2076       saved_errno = errno;
2077
2078       while (npth_sigev_get_pending(&signo))
2079         handle_signal (signo);
2080 #else
2081       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2082       saved_errno = errno;
2083 #endif
2084
2085       if (ret == -1 && saved_errno != EINTR)
2086         {
2087           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2088                      strerror (saved_errno));
2089           npth_sleep (1);
2090           continue;
2091         }
2092
2093       if (ret <= 0)
2094         /* Interrupt or timeout.  Will be handled when calculating the
2095            next timeout.  */
2096         continue;
2097
2098       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2099         {
2100           plen = sizeof paddr;
2101           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2102                                     (struct sockaddr *)&paddr, &plen));
2103           if (fd == GNUPG_INVALID_FD)
2104             {
2105               log_error ("accept failed: %s\n", strerror (errno));
2106             }
2107           else
2108             {
2109               char threadname[50];
2110               union int_and_ptr_u argval;
2111               npth_t thread;
2112
2113               memset (&argval, 0, sizeof argval);
2114               argval.afd = fd;
2115               snprintf (threadname, sizeof threadname-1,
2116                         "conn fd=%d", FD2INT(fd));
2117               threadname[sizeof threadname -1] = 0;
2118
2119               ret = npth_create (&thread, &tattr,
2120                                  start_connection_thread, argval.aptr);
2121               if (ret)
2122                 {
2123                   log_error ("error spawning connection handler: %s\n",
2124                              strerror (ret) );
2125                   assuan_sock_close (fd);
2126                 }
2127               npth_setname_np (thread, threadname);
2128             }
2129           fd = GNUPG_INVALID_FD;
2130         }
2131     }
2132
2133   npth_attr_destroy (&tattr);
2134   cleanup ();
2135   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2136 }