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