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