a46f736a7a2ad083982256b2fcd313b52b9c6913
[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 JNLIB_NEED_LOG_LOGV
54 #define JNLIB_NEED_AFLOCAL
55 #include "dirmngr.h"
56
57 #include <assuan.h>
58
59 #include "certcache.h"
60 #include "crlcache.h"
61 #include "crlfetch.h"
62 #include "misc.h"
63 #if USE_LDAP
64 # include "ldapserver.h"
65 #endif
66 #include "asshelp.h"
67 #if USE_LDAP
68 # include "ldap-wrapper.h"
69 #endif
70 #include "../common/init.h"
71 #include "gc-opt-flags.h"
72
73 /* The plain Windows version uses the windows service system.  For
74    example to start the service you may use "sc start dirmngr".
75    WindowsCE does not support this; the service system over there is
76    based on a single process with all services being DLLs - we can't
77    support this easily.  */
78 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
79 # define USE_W32_SERVICE 1
80 #endif
81
82 #ifndef ENAMETOOLONG
83 # define ENAMETOOLONG EINVAL
84 #endif
85
86
87 enum cmd_and_opt_values {
88   aNull = 0,
89   oCsh            = 'c',
90   oQuiet          = 'q',
91   oSh             = 's',
92   oVerbose        = 'v',
93   oNoVerbose = 500,
94
95   aServer,
96   aDaemon,
97   aService,
98   aListCRLs,
99   aLoadCRL,
100   aFetchCRL,
101   aShutdown,
102   aFlush,
103   aGPGConfList,
104   aGPGConfTest,
105
106   oOptions,
107   oDebug,
108   oDebugAll,
109   oDebugWait,
110   oDebugLevel,
111   oGnutlsDebug,
112   oNoGreeting,
113   oNoOptions,
114   oHomedir,
115   oNoDetach,
116   oLogFile,
117   oBatch,
118   oDisableHTTP,
119   oDisableLDAP,
120   oIgnoreLDAPDP,
121   oIgnoreHTTPDP,
122   oIgnoreOCSPSvcUrl,
123   oHonorHTTPProxy,
124   oHTTPProxy,
125   oLDAPProxy,
126   oOnlyLDAPProxy,
127   oLDAPFile,
128   oLDAPTimeout,
129   oLDAPAddServers,
130   oOCSPResponder,
131   oOCSPSigner,
132   oOCSPMaxClockSkew,
133   oOCSPMaxPeriod,
134   oOCSPCurrentPeriod,
135   oMaxReplies,
136   oHkpCaCert,
137   oFakedSystemTime,
138   oForce,
139   oAllowOCSP,
140   oSocketName,
141   oLDAPWrapperProgram,
142   oHTTPWrapperProgram,
143   oIgnoreCertExtension,
144   aTest
145 };
146
147
148
149 static ARGPARSE_OPTS opts[] = {
150
151   ARGPARSE_group (300, N_("@Commands:\n ")),
152
153   ARGPARSE_c (aServer,   "server",  N_("run in server mode (foreground)") ),
154   ARGPARSE_c (aDaemon,   "daemon",  N_("run in daemon mode (background)") ),
155 #ifdef USE_W32_SERVICE
156   ARGPARSE_c (aService,  "service", N_("run as windows service (background)")),
157 #endif
158   ARGPARSE_c (aListCRLs, "list-crls", N_("list the contents of the CRL cache")),
159   ARGPARSE_c (aLoadCRL,  "load-crl",  N_("|FILE|load CRL from FILE into cache")),
160   ARGPARSE_c (aFetchCRL, "fetch-crl", N_("|URL|fetch a CRL from URL")),
161   ARGPARSE_c (aShutdown, "shutdown",  N_("shutdown the dirmngr")),
162   ARGPARSE_c (aFlush,    "flush",     N_("flush the cache")),
163   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
164   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
165
166   ARGPARSE_group (301, N_("@\nOptions:\n ")),
167
168   ARGPARSE_s_n (oVerbose,  "verbose",   N_("verbose")),
169   ARGPARSE_s_n (oQuiet,    "quiet",     N_("be somewhat more quiet")),
170   ARGPARSE_s_n (oSh,       "sh",        N_("sh-style command output")),
171   ARGPARSE_s_n (oCsh,      "csh",       N_("csh-style command output")),
172   ARGPARSE_s_s (oOptions,  "options",   N_("|FILE|read options from FILE")),
173   ARGPARSE_s_s (oDebugLevel, "debug-level",
174                 N_("|LEVEL|set the debugging level to LEVEL")),
175   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
176   ARGPARSE_s_s (oLogFile,  "log-file",
177                 N_("|FILE|write server mode logs to FILE")),
178   ARGPARSE_s_n (oBatch,    "batch",       N_("run without asking a user")),
179   ARGPARSE_s_n (oForce,    "force",       N_("force loading of outdated CRLs")),
180   ARGPARSE_s_n (oAllowOCSP, "allow-ocsp", N_("allow sending OCSP requests")),
181   ARGPARSE_s_n (oDisableHTTP, "disable-http", N_("inhibit the use of HTTP")),
182   ARGPARSE_s_n (oDisableLDAP, "disable-ldap", N_("inhibit the use of LDAP")),
183   ARGPARSE_s_n (oIgnoreHTTPDP,"ignore-http-dp",
184                 N_("ignore HTTP CRL distribution points")),
185   ARGPARSE_s_n (oIgnoreLDAPDP,"ignore-ldap-dp",
186                 N_("ignore LDAP CRL distribution points")),
187   ARGPARSE_s_n (oIgnoreOCSPSvcUrl, "ignore-ocsp-service-url",
188                 N_("ignore certificate contained OCSP service URLs")),
189
190   ARGPARSE_s_s (oHTTPProxy,  "http-proxy",
191                 N_("|URL|redirect all HTTP requests to URL")),
192   ARGPARSE_s_s (oLDAPProxy,  "ldap-proxy",
193                 N_("|HOST|use HOST for LDAP queries")),
194   ARGPARSE_s_n (oOnlyLDAPProxy, "only-ldap-proxy",
195                 N_("do not use fallback hosts with --ldap-proxy")),
196
197   ARGPARSE_s_s (oLDAPFile, "ldapserverlist-file",
198                 N_("|FILE|read LDAP server list from FILE")),
199   ARGPARSE_s_n (oLDAPAddServers, "add-servers",
200                 N_("add new servers discovered in CRL distribution"
201                    " points to serverlist")),
202   ARGPARSE_s_i (oLDAPTimeout, "ldaptimeout",
203                 N_("|N|set LDAP timeout to N seconds")),
204
205   ARGPARSE_s_s (oOCSPResponder, "ocsp-responder",
206                 N_("|URL|use OCSP responder at URL")),
207   ARGPARSE_s_s (oOCSPSigner, "ocsp-signer",
208                 N_("|FPR|OCSP response signed by FPR")),
209   ARGPARSE_s_i (oOCSPMaxClockSkew, "ocsp-max-clock-skew", "@"),
210   ARGPARSE_s_i (oOCSPMaxPeriod,    "ocsp-max-period", "@"),
211   ARGPARSE_s_i (oOCSPCurrentPeriod, "ocsp-current-period", "@"),
212
213   ARGPARSE_s_i (oMaxReplies, "max-replies",
214                 N_("|N|do not return more than N items in one query")),
215
216   ARGPARSE_s_s (oHkpCaCert, "hkp-cacert",
217                 N_("|FILE|use the CA certificates in FILE for HKP over TLS")),
218
219
220   ARGPARSE_s_s (oSocketName, "socket-name", "@"),  /* Only for debugging.  */
221
222   ARGPARSE_s_u (oFakedSystemTime, "faked-system-time", "@"), /*(epoch time)*/
223   ARGPARSE_p_u (oDebug,    "debug", "@"),
224   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
225   ARGPARSE_s_i (oGnutlsDebug, "gnutls-debug", "@"),
226   ARGPARSE_s_i (oGnutlsDebug, "tls-debug", "@"),
227   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
228   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
229   ARGPARSE_s_s (oHomedir, "homedir", "@"),
230   ARGPARSE_s_s (oLDAPWrapperProgram, "ldap-wrapper-program", "@"),
231   ARGPARSE_s_s (oHTTPWrapperProgram, "http-wrapper-program", "@"),
232   ARGPARSE_s_n (oHonorHTTPProxy, "honor-http-proxy", "@"),
233   ARGPARSE_s_s (oIgnoreCertExtension,"ignore-cert-extension", "@"),
234
235   ARGPARSE_group (302,N_("@\n(See the \"info\" manual for a complete listing "
236                          "of all commands and options)\n")),
237
238   ARGPARSE_end ()
239 };
240
241 #define DEFAULT_MAX_REPLIES 10
242 #define DEFAULT_LDAP_TIMEOUT 100 /* arbitrary large timeout */
243
244 /* For the cleanup handler we need to keep track of the socket's name.  */
245 static const char *socket_name;
246 /* If the socket has been redirected, this is the name of the
247    redirected socket..  */
248 static const char *redir_socket_name;
249
250 /* We need to keep track of the server's nonces (these are dummies for
251    POSIX systems). */
252 static assuan_sock_nonce_t socket_nonce;
253
254 /* Only if this flag has been set we will remove the socket file.  */
255 static int cleanup_socket;
256
257 /* Keep track of the current log file so that we can avoid updating
258    the log file after a SIGHUP if it didn't changed. Malloced. */
259 static char *current_logfile;
260
261 /* Helper to implement --debug-level. */
262 static const char *debug_level;
263
264 /* Helper to set the NTBTLS or GNUTLS log level.  */
265 static int opt_gnutls_debug = -1;
266
267 /* Flag indicating that a shutdown has been requested.  */
268 static volatile int shutdown_pending;
269
270 /* Counter for the active connections.  */
271 static int active_connections;
272
273 /* The timer tick used for housekeeping stuff.  For Windows we use a
274    longer period as the SetWaitableTimer seems to signal earlier than
275    the 2 seconds.  All values are in seconds. */
276 #if defined(HAVE_W32CE_SYSTEM)
277 # define TIMERTICK_INTERVAL         (60)
278 #elif defined(HAVE_W32_SYSTEM)
279 # define TIMERTICK_INTERVAL          (4)
280 #else
281 # define TIMERTICK_INTERVAL          (2)
282 #endif
283
284 #define HOUSEKEEPING_INTERVAL      (600)
285
286
287 /* This union is used to avoid compiler warnings in case a pointer is
288    64 bit and an int 32 bit.  We store an integer in a pointer and get
289    it back later (npth_getspecific et al.).  */
290 union int_and_ptr_u
291 {
292   int  aint;
293   assuan_fd_t afd;
294   void *aptr;
295 };
296
297
298
299 /* The key used to store the current file descriptor in the thread
300    local storage.  We use this in conjunction with the
301    log_set_pid_suffix_cb feature..  */
302 #ifndef HAVE_W32_SYSTEM
303 static int my_tlskey_current_fd;
304 #endif
305
306 /* Prototypes. */
307 static void cleanup (void);
308 #if USE_LDAP
309 static ldap_server_t parse_ldapserver_file (const char* filename);
310 #endif /*USE_LDAP*/
311 static fingerprint_list_t parse_ocsp_signer (const char *string);
312 static void handle_connections (assuan_fd_t listen_fd);
313
314 /* NPth wrapper function definitions. */
315 ASSUAN_SYSTEM_NPTH_IMPL;
316
317 static const char *
318 my_strusage( int level )
319 {
320   const char *p;
321   switch ( level )
322     {
323     case 11: p = "@DIRMNGR@ (@GNUPG@)";
324       break;
325     case 13: p = VERSION; break;
326     case 17: p = PRINTABLE_OS_NAME; break;
327       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
328          reporting address.  This is so that we can change the
329          reporting address without breaking the translations.  */
330     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
331     case 49: p = PACKAGE_BUGREPORT; break;
332     case 1:
333     case 40: p = _("Usage: @DIRMNGR@ [options] (-h for help)");
334       break;
335     case 41: p = _("Syntax: @DIRMNGR@ [options] [command [args]]\n"
336                    "Keyserver, CRL, and OCSP access for @GNUPG@\n");
337       break;
338
339     default: p = NULL;
340     }
341   return p;
342 }
343
344
345 /* Callback from libksba to hash a provided buffer.  Our current
346    implementation does only allow SHA-1 for hashing. This may be
347    extended by mapping the name, testing for algorithm availibility
348    and adjust the length checks accordingly. */
349 static gpg_error_t
350 my_ksba_hash_buffer (void *arg, const char *oid,
351                      const void *buffer, size_t length, size_t resultsize,
352                      unsigned char *result, size_t *resultlen)
353 {
354   (void)arg;
355
356   if (oid && strcmp (oid, "1.3.14.3.2.26"))
357     return gpg_error (GPG_ERR_NOT_SUPPORTED);
358   if (resultsize < 20)
359     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
360   gcry_md_hash_buffer (2, result, buffer, length);
361   *resultlen = 20;
362   return 0;
363 }
364
365
366 /* GNUTLS log function callback.  */
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
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_ASSUAN_VALUE;
396   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
397     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE);
398   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
399     opt.debug = (DBG_ASSUAN_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_data = gnupg_datadir ();
803       opt.homedir_cache = gnupg_cachedir ();
804       socket_name = dirmngr_sys_socket_name ();
805     }
806   else if (dirmngr_user_socket_name ())
807     socket_name = dirmngr_user_socket_name ();
808   else
809     socket_name = dirmngr_sys_socket_name ();
810
811   if (default_config)
812     configname = make_filename (opt.homedir, DIRMNGR_NAME".conf", NULL );
813
814   argc = orig_argc;
815   argv = orig_argv;
816   pargs.argc = &argc;
817   pargs.argv = &argv;
818   pargs.flags= 1;  /* do not remove the args */
819  next_pass:
820   if (configname)
821     {
822       configlineno = 0;
823       configfp = fopen (configname, "r");
824       if (!configfp)
825         {
826           if (default_config)
827             {
828               if( parse_debug )
829                 log_info (_("Note: no default option file '%s'\n"),
830                           configname );
831             }
832           else
833             {
834               log_error (_("option file '%s': %s\n"),
835                          configname, strerror(errno) );
836               exit(2);
837             }
838           xfree (configname);
839           configname = NULL;
840         }
841       if (parse_debug && configname )
842         log_info (_("reading options from '%s'\n"), configname );
843       default_config = 0;
844     }
845
846   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
847     {
848       if (parse_rereadable_options (&pargs, 0))
849         continue; /* Already handled */
850       switch (pargs.r_opt)
851         {
852         case aServer:
853         case aDaemon:
854         case aService:
855         case aShutdown:
856         case aFlush:
857         case aListCRLs:
858         case aLoadCRL:
859         case aFetchCRL:
860         case aGPGConfList:
861         case aGPGConfTest:
862           cmd = pargs.r_opt;
863           break;
864
865         case oQuiet: opt.quiet = 1; break;
866         case oVerbose: opt.verbose++; break;
867         case oBatch: opt.batch=1; break;
868
869         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
870         case oDebugAll: opt.debug = ~0; break;
871         case oDebugLevel: debug_level = pargs.r.ret_str; break;
872         case oDebugWait: debug_wait = pargs.r.ret_int; break;
873
874         case oOptions:
875           /* Config files may not be nested (silently ignore them) */
876           if (!configfp)
877             {
878                 xfree(configname);
879                 configname = xstrdup(pargs.r.ret_str);
880                 goto next_pass;
881             }
882           break;
883         case oNoGreeting: nogreeting = 1; break;
884         case oNoVerbose: opt.verbose = 0; break;
885         case oNoOptions: break; /* no-options */
886         case oHomedir: /* Ignore this option here. */; break;
887         case oNoDetach: nodetach = 1; break;
888         case oLogFile: logfile = pargs.r.ret_str; break;
889         case oCsh: csh_style = 1; break;
890         case oSh: csh_style = 0; break;
891         case oLDAPFile:
892 #        if USE_LDAP
893           ldapfile = pargs.r.ret_str;
894 #        endif /*USE_LDAP*/
895           break;
896         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
897         case oLDAPTimeout:
898           opt.ldaptimeout = pargs.r.ret_int;
899           break;
900
901         case oFakedSystemTime:
902           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
903           break;
904
905         case oForce: opt.force = 1; break;
906
907         case oSocketName: socket_name = pargs.r.ret_str; break;
908
909         default : pargs.err = configfp? 1:2; break;
910         }
911     }
912   if (configfp)
913     {
914       fclose (configfp);
915       configfp = NULL;
916       /* Keep a copy of the name so that it can be read on SIGHUP. */
917       opt.config_filename = configname;
918       configname = NULL;
919       goto next_pass;
920     }
921   xfree (configname);
922   configname = NULL;
923   if (log_get_errorcount(0))
924     exit(2);
925   if (nogreeting )
926     greeting = 0;
927
928   if (!opt.homedir_data)
929     opt.homedir_data = opt.homedir;
930   if (!opt.homedir_cache)
931     opt.homedir_cache = opt.homedir;
932
933   if (greeting)
934     {
935       es_fprintf (es_stderr, "%s %s; %s\n",
936                   strusage(11), strusage(13), strusage(14) );
937       es_fprintf (es_stderr, "%s\n", strusage(15) );
938     }
939
940 #ifdef IS_DEVELOPMENT_VERSION
941   log_info ("NOTE: this is a development version!\n");
942 #endif
943
944   /* Print a warning if an argument looks like an option.  */
945   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
946     {
947       int i;
948
949       for (i=0; i < argc; i++)
950         if (argv[i][0] == '-' && argv[i][1] == '-')
951           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
952     }
953
954   if (!access ("/etc/"DIRMNGR_NAME, F_OK) && !strncmp (opt.homedir, "/etc/", 5))
955     log_info
956       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
957        " other directory names changed.  Please check that no other version"
958        " of dirmngr is still installed.  To disable this warning, remove the"
959        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
960
961   if (gnupg_faked_time_p ())
962     {
963       gnupg_isotime_t tbuf;
964
965       log_info (_("WARNING: running with faked system time: "));
966       gnupg_get_isotime (tbuf);
967       dump_isotime (tbuf);
968       log_printf ("\n");
969     }
970
971   set_debug ();
972
973   /* Get LDAP server list from file. */
974 #if USE_LDAP
975   if (!ldapfile)
976     {
977       ldapfile = make_filename (opt.homedir,
978                                 opt.system_daemon?
979                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
980                                 NULL);
981       opt.ldapservers = parse_ldapserver_file (ldapfile);
982       xfree (ldapfile);
983     }
984   else
985       opt.ldapservers = parse_ldapserver_file (ldapfile);
986 #endif /*USE_LDAP*/
987
988 #ifndef HAVE_W32_SYSTEM
989   /* We need to ignore the PIPE signal because the we might log to a
990      socket and that code handles EPIPE properly.  The ldap wrapper
991      also requires us to ignore this silly signal. Assuan would set
992      this signal to ignore anyway.*/
993   signal (SIGPIPE, SIG_IGN);
994 #endif
995
996   /* Ready.  Now to our duties. */
997   if (!cmd && opt.system_service)
998     cmd = aDaemon;
999   else if (!cmd)
1000     cmd = aServer;
1001   rc = 0;
1002
1003   if (cmd == aServer)
1004     {
1005       /* Note that this server mode is mainly useful for debugging.  */
1006       if (argc)
1007         wrong_args ("--server");
1008
1009       if (logfile)
1010         {
1011           log_set_file (logfile);
1012           log_set_prefix (NULL, 2|4);
1013         }
1014
1015       if (debug_wait)
1016         {
1017           log_debug ("waiting for debugger - my pid is %u .....\n",
1018                      (unsigned int)getpid());
1019           gnupg_sleep (debug_wait);
1020           log_debug ("... okay\n");
1021         }
1022
1023 #if USE_LDAP
1024       ldap_wrapper_launch_thread ();
1025 #endif /*USE_LDAP*/
1026
1027       cert_cache_init ();
1028       crl_cache_init ();
1029       start_command_handler (ASSUAN_INVALID_FD);
1030       shutdown_reaper ();
1031     }
1032   else if (cmd == aDaemon)
1033     {
1034       assuan_fd_t fd;
1035       pid_t pid;
1036       int len;
1037       struct sockaddr_un serv_addr;
1038
1039       if (argc)
1040         wrong_args ("--daemon");
1041
1042       /* Now start with logging to a file if this is desired. */
1043       if (logfile)
1044         {
1045           log_set_file (logfile);
1046           log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1047                                  |JNLIB_LOG_WITH_TIME
1048                                  |JNLIB_LOG_WITH_PID));
1049           current_logfile = xstrdup (logfile);
1050         }
1051
1052 #ifndef HAVE_W32_SYSTEM
1053       if (strchr (socket_name, ':'))
1054         {
1055           log_error (_("colons are not allowed in the socket name\n"));
1056           dirmngr_exit (1);
1057         }
1058 #endif
1059       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1060       if (fd == ASSUAN_INVALID_FD)
1061         {
1062           log_error (_("can't create socket: %s\n"), strerror (errno));
1063           cleanup ();
1064           dirmngr_exit (1);
1065         }
1066
1067 #if ASSUAN_VERSION_NUMBER >= 0x020104 /* >= 2.1.4 */
1068       {
1069         int redirected;
1070
1071         if (assuan_sock_set_sockaddr_un (socket_name,
1072                                          (struct sockaddr*)&serv_addr,
1073                                          &redirected))
1074           {
1075             if (errno == ENAMETOOLONG)
1076               log_error (_("socket name '%s' is too long\n"), socket_name);
1077             else
1078               log_error ("error preparing socket '%s': %s\n",
1079                          socket_name,
1080                          gpg_strerror (gpg_error_from_syserror ()));
1081             dirmngr_exit (1);
1082           }
1083         if (redirected)
1084           {
1085             redir_socket_name = xstrdup (serv_addr.sun_path);
1086             if (opt.verbose)
1087               log_info ("redirecting socket '%s' to '%s'\n",
1088                         socket_name, redir_socket_name);
1089           }
1090       }
1091 #else /* Assuan < 2.1.4 */
1092       memset (&serv_addr, 0, sizeof serv_addr);
1093       serv_addr.sun_family = AF_UNIX;
1094       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path )
1095         {
1096           log_error (_("socket name '%s' is too long\n"), socket_name);
1097           dirmngr_exit (1);
1098         }
1099       strcpy (serv_addr.sun_path, socket_name);
1100 #endif /* Assuan < 2.1.4 */
1101
1102       len = SUN_LEN (&serv_addr);
1103
1104       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1105       if (rc == -1
1106           && (errno == EADDRINUSE
1107 #ifdef HAVE_W32_SYSTEM
1108               || errno == EEXIST
1109 #endif
1110               ))
1111         {
1112           /* Fixme: We should test whether a dirmngr is already running. */
1113           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1114           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1115         }
1116       if (rc != -1
1117           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1118         log_error (_("error getting nonce for the socket\n"));
1119       if (rc == -1)
1120         {
1121           log_error (_("error binding socket to '%s': %s\n"),
1122                      serv_addr.sun_path,
1123                      gpg_strerror (gpg_error_from_errno (errno)));
1124           assuan_sock_close (fd);
1125           dirmngr_exit (1);
1126         }
1127       cleanup_socket = 1;
1128
1129       if (listen (FD2INT (fd), 5) == -1)
1130         {
1131           log_error (_("listen() failed: %s\n"), strerror (errno));
1132           assuan_sock_close (fd);
1133           dirmngr_exit (1);
1134         }
1135
1136       if (opt.verbose)
1137         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1138
1139       es_fflush (NULL);
1140
1141       /* Note: We keep the dirmngr_info output only for the sake of
1142          existing scripts which might use this to detect a successful
1143          start of the dirmngr.  */
1144 #ifdef HAVE_W32_SYSTEM
1145       (void)csh_style;
1146       (void)nodetach;
1147
1148       pid = getpid ();
1149       es_printf ("set %s=%s;%lu;1\n",
1150                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1151 #else
1152       pid = fork();
1153       if (pid == (pid_t)-1)
1154         {
1155           log_fatal (_("error forking process: %s\n"), strerror (errno));
1156           dirmngr_exit (1);
1157         }
1158
1159       if (pid)
1160         { /* We are the parent */
1161           char *infostr;
1162
1163           /* Don't let cleanup() remove the socket - the child is
1164              responsible for doing that.  */
1165           cleanup_socket = 0;
1166
1167           close (fd);
1168
1169           /* Create the info string: <name>:<pid>:<protocol_version> */
1170           if (asprintf (&infostr, "%s=%s:%lu:1",
1171                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1172             {
1173               log_error (_("out of core\n"));
1174               kill (pid, SIGTERM);
1175               dirmngr_exit (1);
1176             }
1177           /* Print the environment string, so that the caller can use
1178              shell's eval to set it.  But see above.  */
1179           if (csh_style)
1180             {
1181               *strchr (infostr, '=') = ' ';
1182               es_printf ( "setenv %s;\n", infostr);
1183             }
1184           else
1185             {
1186               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1187             }
1188           free (infostr);
1189           exit (0);
1190           /*NEVER REACHED*/
1191         } /* end parent */
1192
1193
1194       /*
1195          This is the child
1196        */
1197
1198       /* Detach from tty and put process into a new session */
1199       if (!nodetach )
1200         {
1201           int i;
1202           unsigned int oldflags;
1203
1204           /* Close stdin, stdout and stderr unless it is the log stream */
1205           for (i=0; i <= 2; i++)
1206             {
1207               if (!log_test_fd (i) && i != fd )
1208                 close (i);
1209             }
1210           if (setsid() == -1)
1211             {
1212               log_error ("setsid() failed: %s\n", strerror(errno) );
1213               dirmngr_exit (1);
1214             }
1215
1216           log_get_prefix (&oldflags);
1217           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1218           opt.running_detached = 1;
1219
1220           if (chdir("/"))
1221             {
1222               log_error ("chdir to / failed: %s\n", strerror (errno));
1223               dirmngr_exit (1);
1224             }
1225         }
1226 #endif
1227
1228 #if USE_LDAP
1229       ldap_wrapper_launch_thread ();
1230 #endif /*USE_LDAP*/
1231
1232       cert_cache_init ();
1233       crl_cache_init ();
1234 #ifdef USE_W32_SERVICE
1235       if (opt.system_service)
1236         {
1237           service_status.dwCurrentState = SERVICE_RUNNING;
1238           SetServiceStatus (service_handle, &service_status);
1239         }
1240 #endif
1241       handle_connections (fd);
1242       assuan_sock_close (fd);
1243       shutdown_reaper ();
1244 #ifdef USE_W32_SERVICE
1245       if (opt.system_service)
1246         {
1247           service_status.dwCurrentState = SERVICE_STOPPED;
1248           SetServiceStatus (service_handle, &service_status);
1249         }
1250 #endif
1251     }
1252   else if (cmd == aListCRLs)
1253     {
1254       /* Just list the CRL cache and exit. */
1255       if (argc)
1256         wrong_args ("--list-crls");
1257 #if USE_LDAP
1258       ldap_wrapper_launch_thread ();
1259 #endif /*USE_LDAP*/
1260       crl_cache_init ();
1261       crl_cache_list (es_stdout);
1262     }
1263   else if (cmd == aLoadCRL)
1264     {
1265       struct server_control_s ctrlbuf;
1266
1267       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1268       dirmngr_init_default_ctrl (&ctrlbuf);
1269
1270 #if USE_LDAP
1271       ldap_wrapper_launch_thread ();
1272 #endif /*USE_LDAP*/
1273       cert_cache_init ();
1274       crl_cache_init ();
1275       if (!argc)
1276         rc = crl_cache_load (&ctrlbuf, NULL);
1277       else
1278         {
1279           for (; !rc && argc; argc--, argv++)
1280             rc = crl_cache_load (&ctrlbuf, *argv);
1281         }
1282     }
1283   else if (cmd == aFetchCRL)
1284     {
1285       ksba_reader_t reader;
1286       struct server_control_s ctrlbuf;
1287
1288       if (argc != 1)
1289         wrong_args ("--fetch-crl URL");
1290
1291       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1292       dirmngr_init_default_ctrl (&ctrlbuf);
1293
1294 #if USE_LDAP
1295       ldap_wrapper_launch_thread ();
1296 #endif /*USE_LDAP*/
1297       cert_cache_init ();
1298       crl_cache_init ();
1299       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1300       if (rc)
1301         log_error (_("fetching CRL from '%s' failed: %s\n"),
1302                      argv[0], gpg_strerror (rc));
1303       else
1304         {
1305           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1306           if (rc)
1307             log_error (_("processing CRL from '%s' failed: %s\n"),
1308                        argv[0], gpg_strerror (rc));
1309           crl_close_reader (reader);
1310         }
1311     }
1312   else if (cmd == aFlush)
1313     {
1314       /* Delete cache and exit. */
1315       if (argc)
1316         wrong_args ("--flush");
1317       rc = crl_cache_flush();
1318     }
1319   else if (cmd == aGPGConfTest)
1320     dirmngr_exit (0);
1321   else if (cmd == aGPGConfList)
1322     {
1323       unsigned long flags = 0;
1324       char *filename;
1325       char *filename_esc;
1326
1327 #ifdef HAVE_W32_SYSTEM
1328       /* On Windows systems, dirmngr always runs as system daemon, and
1329          the per-user configuration is never used.  So we short-cut
1330          everything to use the global system configuration of dirmngr
1331          above, and here we set the no change flag to make these
1332          read-only.  */
1333       flags |= GC_OPT_FLAG_NO_CHANGE;
1334 #endif
1335
1336       /* First the configuration file.  This is not an option, but it
1337          is vital information for GPG Conf.  */
1338       if (!opt.config_filename)
1339         opt.config_filename = make_filename (opt.homedir,
1340                                              "dirmngr.conf", NULL );
1341
1342       filename = percent_escape (opt.config_filename, NULL);
1343       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1344               GC_OPT_FLAG_DEFAULT, filename);
1345       xfree (filename);
1346
1347       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1348       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1349       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1350       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1351       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1352
1353       /* --csh and --sh are mutually exclusive, something we can not
1354          express in GPG Conf.  --options is only usable from the
1355          command line, really.  --debug-all interacts with --debug,
1356          and having both of them is thus problematic.  --no-detach is
1357          also only usable on the command line.  --batch is unused.  */
1358
1359       filename = make_filename (opt.homedir,
1360                                 opt.system_daemon?
1361                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
1362                                 NULL);
1363       filename_esc = percent_escape (filename, NULL);
1364       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1365               filename_esc);
1366       xfree (filename_esc);
1367       xfree (filename);
1368
1369       es_printf ("ldaptimeout:%lu:%u\n",
1370               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1371       es_printf ("max-replies:%lu:%u\n",
1372               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1373       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1374       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1375       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1376
1377       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1378       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1379
1380       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1381       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1382       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1383       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1384       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1385       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1386       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1387       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1388       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1389       /* Note: The next one is to fix a typo in gpgconf - should be
1390          removed eventually. */
1391       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1392     }
1393   cleanup ();
1394   return !!rc;
1395 }
1396
1397
1398 #ifdef USE_W32_SERVICE
1399 static void WINAPI
1400 call_real_main (DWORD argc, LPSTR *argv)
1401 {
1402   real_main (argc, argv);
1403 }
1404
1405 int
1406 main (int argc, char *argv[])
1407 {
1408   int i;
1409
1410   /* Find out if we run in daemon mode or on the command line.  */
1411   for (i = 1; i < argc; i++)
1412     if (!strcmp (argv[i], "--service"))
1413       {
1414         opt.system_service = 1;
1415         opt.system_daemon = 1;
1416         break;
1417       }
1418
1419   if (!opt.system_service)
1420     return real_main (argc, argv);
1421   else
1422     {
1423       SERVICE_TABLE_ENTRY DispatchTable [] =
1424         {
1425           { "DirMngr", &call_real_main },
1426           { NULL, NULL }
1427         };
1428
1429       if (!StartServiceCtrlDispatcher (DispatchTable))
1430         return 1;
1431       return 0;
1432     }
1433 }
1434 #endif /*USE_W32_SERVICE*/
1435
1436
1437 static void
1438 cleanup (void)
1439 {
1440   crl_cache_deinit ();
1441   cert_cache_deinit (1);
1442
1443 #if USE_LDAP
1444   ldapserver_list_free (opt.ldapservers);
1445 #endif /*USE_LDAP*/
1446   opt.ldapservers = NULL;
1447
1448   if (cleanup_socket)
1449     {
1450       cleanup_socket = 0;
1451       if (redir_socket_name)
1452         gnupg_remove (redir_socket_name);
1453       else if (socket_name && *socket_name)
1454         gnupg_remove (socket_name);
1455     }
1456 }
1457
1458
1459 void
1460 dirmngr_exit (int rc)
1461 {
1462   cleanup ();
1463   exit (rc);
1464 }
1465
1466
1467 void
1468 dirmngr_init_default_ctrl (ctrl_t ctrl)
1469 {
1470   (void)ctrl;
1471
1472   /* Nothing for now. */
1473 }
1474
1475
1476 /* Create a list of LDAP servers from the file FILENAME. Returns the
1477    list or NULL in case of errors.
1478
1479    The format fo such a file is line oriented where empty lines and
1480    lines starting with a hash mark are ignored.  All other lines are
1481    assumed to be colon seprated with these fields:
1482
1483    1. field: Hostname
1484    2. field: Portnumber
1485    3. field: Username
1486    4. field: Password
1487    5. field: Base DN
1488
1489 */
1490 #if USE_LDAP
1491 static ldap_server_t
1492 parse_ldapserver_file (const char* filename)
1493 {
1494   char buffer[1024];
1495   char *p;
1496   ldap_server_t server, serverstart, *serverend;
1497   int c;
1498   unsigned int lineno = 0;
1499   estream_t fp;
1500
1501   fp = es_fopen (filename, "r");
1502   if (!fp)
1503     {
1504       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1505       return NULL;
1506     }
1507
1508   serverstart = NULL;
1509   serverend = &serverstart;
1510   while (es_fgets (buffer, sizeof buffer, fp))
1511     {
1512       lineno++;
1513       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1514         {
1515           if (*buffer && es_feof (fp))
1516             ; /* Last line not terminated - continue. */
1517           else
1518             {
1519               log_error (_("%s:%u: line too long - skipped\n"),
1520                          filename, lineno);
1521               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1522                 ; /* Skip until end of line. */
1523               continue;
1524             }
1525         }
1526       /* Skip empty and comment lines.*/
1527       for (p=buffer; spacep (p); p++)
1528         ;
1529       if (!*p || *p == '\n' || *p == '#')
1530         continue;
1531
1532       /* Parse the colon separated fields. */
1533       server = ldapserver_parse_one (buffer, filename, lineno);
1534       if (server)
1535         {
1536           *serverend = server;
1537           serverend = &server->next;
1538         }
1539     }
1540
1541   if (es_ferror (fp))
1542     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1543   es_fclose (fp);
1544
1545   return serverstart;
1546 }
1547 #endif /*USE_LDAP*/
1548
1549 static fingerprint_list_t
1550 parse_ocsp_signer (const char *string)
1551 {
1552   gpg_error_t err;
1553   char *fname;
1554   estream_t fp;
1555   char line[256];
1556   char *p;
1557   fingerprint_list_t list, *list_tail, item;
1558   unsigned int lnr = 0;
1559   int c, i, j;
1560   int errflag = 0;
1561
1562
1563   /* Check whether this is not a filename and treat it as a direct
1564      fingerprint specification.  */
1565   if (!strpbrk (string, "/.~\\"))
1566     {
1567       item = xcalloc (1, sizeof *item);
1568       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1569         if ( string[i] != ':' )
1570           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1571       item->hexfpr[j] = 0;
1572       if (j != 40 || !(spacep (string+i) || !string[i]))
1573         {
1574           log_error (_("%s:%u: invalid fingerprint detected\n"),
1575                      "--ocsp-signer", 0);
1576           xfree (item);
1577           return NULL;
1578         }
1579       return item;
1580     }
1581
1582   /* Well, it is a filename.  */
1583   if (*string == '/' || (*string == '~' && string[1] == '/'))
1584     fname = make_filename (string, NULL);
1585   else
1586     {
1587       if (string[0] == '.' && string[1] == '/' )
1588         string += 2;
1589       fname = make_filename (opt.homedir, string, NULL);
1590     }
1591
1592   fp = es_fopen (fname, "r");
1593   if (!fp)
1594     {
1595       err = gpg_error_from_syserror ();
1596       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1597       xfree (fname);
1598       return NULL;
1599     }
1600
1601   list = NULL;
1602   list_tail = &list;
1603   for (;;)
1604     {
1605       if (!es_fgets (line, DIM(line)-1, fp) )
1606         {
1607           if (!es_feof (fp))
1608             {
1609               err = gpg_error_from_syserror ();
1610               log_error (_("%s:%u: read error: %s\n"),
1611                          fname, lnr, gpg_strerror (err));
1612               errflag = 1;
1613             }
1614           es_fclose (fp);
1615           if (errflag)
1616             {
1617               while (list)
1618                 {
1619                   fingerprint_list_t tmp = list->next;
1620                   xfree (list);
1621                   list = tmp;
1622                 }
1623             }
1624           xfree (fname);
1625           return list; /* Ready.  */
1626         }
1627
1628       lnr++;
1629       if (!*line || line[strlen(line)-1] != '\n')
1630         {
1631           /* Eat until end of line. */
1632           while ( (c=es_getc (fp)) != EOF && c != '\n')
1633             ;
1634           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1635                            /* */: GPG_ERR_INCOMPLETE_LINE);
1636           log_error (_("%s:%u: read error: %s\n"),
1637                      fname, lnr, gpg_strerror (err));
1638           errflag = 1;
1639           continue;
1640         }
1641
1642       /* Allow for empty lines and spaces */
1643       for (p=line; spacep (p); p++)
1644         ;
1645       if (!*p || *p == '\n' || *p == '#')
1646         continue;
1647
1648       item = xcalloc (1, sizeof *item);
1649       *list_tail = item;
1650       list_tail = &item->next;
1651
1652       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1653         if ( p[i] != ':' )
1654           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1655       item->hexfpr[j] = 0;
1656       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1657         {
1658           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1659           errflag = 1;
1660         }
1661       i++;
1662       while (spacep (p+i))
1663         i++;
1664       if (p[i] && p[i] != '\n')
1665         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1666     }
1667   /*NOTREACHED*/
1668 }
1669
1670
1671
1672 \f
1673 /*
1674    Stuff used in daemon mode.
1675  */
1676
1677
1678
1679 /* Reread parts of the configuration.  Note, that this function is
1680    obviously not thread-safe and should only be called from the NPTH
1681    signal handler.
1682
1683    Fixme: Due to the way the argument parsing works, we create a
1684    memory leak here for all string type arguments.  There is currently
1685    no clean way to tell whether the memory for the argument has been
1686    allocated or points into the process' original arguments.  Unless
1687    we have a mechanism to tell this, we need to live on with this. */
1688 static void
1689 reread_configuration (void)
1690 {
1691   ARGPARSE_ARGS pargs;
1692   FILE *fp;
1693   unsigned int configlineno = 0;
1694   int dummy;
1695
1696   if (!opt.config_filename)
1697     return; /* No config file. */
1698
1699   fp = fopen (opt.config_filename, "r");
1700   if (!fp)
1701     {
1702       log_error (_("option file '%s': %s\n"),
1703                  opt.config_filename, strerror(errno) );
1704       return;
1705     }
1706
1707   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1708
1709   memset (&pargs, 0, sizeof pargs);
1710   dummy = 0;
1711   pargs.argc = &dummy;
1712   pargs.flags = 1;  /* do not remove the args */
1713   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1714     {
1715       if (pargs.r_opt < -1)
1716         pargs.err = 1; /* Print a warning. */
1717       else /* Try to parse this option - ignore unchangeable ones. */
1718         parse_rereadable_options (&pargs, 1);
1719     }
1720   fclose (fp);
1721
1722   set_debug ();
1723 }
1724
1725
1726 /* A global function which allows us to trigger the reload stuff from
1727    other places.  */
1728 void
1729 dirmngr_sighup_action (void)
1730 {
1731   log_info (_("SIGHUP received - "
1732               "re-reading configuration and flushing caches\n"));
1733   reread_configuration ();
1734   cert_cache_deinit (0);
1735   crl_cache_deinit ();
1736   cert_cache_init ();
1737   crl_cache_init ();
1738 }
1739
1740
1741
1742 /* The signal handler. */
1743 #ifndef HAVE_W32_SYSTEM
1744 static void
1745 handle_signal (int signo)
1746 {
1747   switch (signo)
1748     {
1749     case SIGHUP:
1750       dirmngr_sighup_action ();
1751       break;
1752
1753     case SIGUSR1:
1754       cert_cache_print_stats ();
1755       break;
1756
1757     case SIGUSR2:
1758       log_info (_("SIGUSR2 received - no action defined\n"));
1759       break;
1760
1761     case SIGTERM:
1762       if (!shutdown_pending)
1763         log_info (_("SIGTERM received - shutting down ...\n"));
1764       else
1765         log_info (_("SIGTERM received - still %d active connections\n"),
1766                   active_connections);
1767       shutdown_pending++;
1768       if (shutdown_pending > 2)
1769         {
1770           log_info (_("shutdown forced\n"));
1771           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1772           cleanup ();
1773           dirmngr_exit (0);
1774         }
1775       break;
1776
1777     case SIGINT:
1778       log_info (_("SIGINT received - immediate shutdown\n"));
1779       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1780       cleanup ();
1781       dirmngr_exit (0);
1782       break;
1783
1784     default:
1785       log_info (_("signal %d received - no action defined\n"), signo);
1786     }
1787 }
1788 #endif /*!HAVE_W32_SYSTEM*/
1789
1790
1791 /* Thread to do the housekeeping.  */
1792 static void *
1793 housekeeping_thread (void *arg)
1794 {
1795   static int sentinel;
1796   time_t curtime;
1797
1798   (void)arg;
1799
1800   curtime = gnupg_get_time ();
1801   if (sentinel)
1802     {
1803       log_info ("housekeeping is already going on\n");
1804       return NULL;
1805     }
1806   sentinel++;
1807   if (opt.verbose)
1808     log_info ("starting housekeeping\n");
1809
1810   ks_hkp_housekeeping (curtime);
1811
1812   if (opt.verbose)
1813     log_info ("ready with housekeeping\n");
1814   sentinel--;
1815   return NULL;
1816
1817 }
1818
1819
1820 #if JNLIB_GCC_HAVE_PUSH_PRAGMA
1821 # pragma GCC push_options
1822 # pragma GCC optimize ("no-strict-overflow")
1823 #endif
1824 static int
1825 time_for_housekeeping_p (time_t curtime)
1826 {
1827   static time_t last_housekeeping;
1828
1829   if (!last_housekeeping)
1830     last_housekeeping = curtime;
1831
1832   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1833       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1834     {
1835       last_housekeeping = curtime;
1836       return 1;
1837     }
1838   return 0;
1839 }
1840 #if JNLIB_GCC_HAVE_PUSH_PRAGMA
1841 # pragma GCC pop_options
1842 #endif
1843
1844
1845 /* This is the worker for the ticker.  It is called every few seconds
1846    and may only do fast operations. */
1847 static void
1848 handle_tick (void)
1849 {
1850   /* Under Windows we don't use signals and need a way for the loop to
1851      check for the shutdown flag.  */
1852 #ifdef HAVE_W32_SYSTEM
1853   if (shutdown_pending)
1854     log_info (_("SIGTERM received - shutting down ...\n"));
1855   if (shutdown_pending > 2)
1856     {
1857       log_info (_("shutdown forced\n"));
1858       log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1859       cleanup ();
1860       dirmngr_exit (0);
1861     }
1862 #endif /*HAVE_W32_SYSTEM*/
1863
1864   if (time_for_housekeeping_p (gnupg_get_time ()))
1865     {
1866       npth_t thread;
1867       npth_attr_t tattr;
1868       int err;
1869
1870       err = npth_attr_init (&tattr);
1871       if (err)
1872         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
1873       else
1874         {
1875           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1876           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
1877           if (err)
1878             log_error ("error spawning housekeeping thread: %s\n",
1879                        strerror (err));
1880           npth_attr_destroy (&tattr);
1881         }
1882     }
1883 }
1884
1885
1886 /* Check the nonce on a new connection.  This is a NOP unless we we
1887    are using our Unix domain socket emulation under Windows.  */
1888 static int
1889 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1890 {
1891   if (assuan_sock_check_nonce (fd, nonce))
1892     {
1893       log_info (_("error reading nonce on fd %d: %s\n"),
1894                 FD2INT (fd), strerror (errno));
1895       assuan_sock_close (fd);
1896       return -1;
1897     }
1898   else
1899     return 0;
1900 }
1901
1902
1903 /* Helper to call a connection's main fucntion. */
1904 static void *
1905 start_connection_thread (void *arg)
1906 {
1907   union int_and_ptr_u argval;
1908   gnupg_fd_t fd;
1909
1910   argval.aptr = arg;
1911   fd = argval.afd;
1912
1913   if (check_nonce (fd, &socket_nonce))
1914     {
1915       log_error ("handler nonce check FAILED\n");
1916       return NULL;
1917     }
1918
1919 #ifndef HAVE_W32_SYSTEM
1920   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1921 #endif
1922
1923   active_connections++;
1924   if (opt.verbose)
1925     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1926
1927   start_command_handler (fd);
1928
1929   if (opt.verbose)
1930     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1931   active_connections--;
1932
1933 #ifndef HAVE_W32_SYSTEM
1934   argval.afd = ASSUAN_INVALID_FD;
1935   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1936 #endif
1937
1938   return NULL;
1939 }
1940
1941
1942 /* Main loop in daemon mode. */
1943 static void
1944 handle_connections (assuan_fd_t listen_fd)
1945 {
1946   npth_attr_t tattr;
1947 #ifndef HAVE_W32_SYSTEM
1948   int signo;
1949 #endif
1950   struct sockaddr_un paddr;
1951   socklen_t plen = sizeof( paddr );
1952   gnupg_fd_t fd;
1953   int nfd, ret;
1954   fd_set fdset, read_fdset;
1955   struct timespec abstime;
1956   struct timespec curtime;
1957   struct timespec timeout;
1958   int saved_errno;
1959
1960   npth_attr_init (&tattr);
1961   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1962
1963 #ifndef HAVE_W32_SYSTEM /* FIXME */
1964   npth_sigev_init ();
1965   npth_sigev_add (SIGHUP);
1966   npth_sigev_add (SIGUSR1);
1967   npth_sigev_add (SIGUSR2);
1968   npth_sigev_add (SIGINT);
1969   npth_sigev_add (SIGTERM);
1970   npth_sigev_fini ();
1971 #endif
1972
1973   /* Setup the fdset.  It has only one member.  This is because we use
1974      pth_select instead of pth_accept to properly sync timeouts with
1975      to full second.  */
1976   FD_ZERO (&fdset);
1977   FD_SET (FD2INT (listen_fd), &fdset);
1978   nfd = FD2INT (listen_fd);
1979
1980   npth_clock_gettime (&abstime);
1981   abstime.tv_sec += TIMERTICK_INTERVAL;
1982
1983   /* Main loop.  */
1984   for (;;)
1985     {
1986       /* Shutdown test.  */
1987       if (shutdown_pending)
1988         {
1989           if (!active_connections)
1990             break; /* ready */
1991
1992           /* Do not accept new connections but keep on running the
1993              loop to cope with the timer events.  */
1994           FD_ZERO (&fdset);
1995         }
1996
1997       /* Take a copy of the fdset.  */
1998       read_fdset = fdset;
1999
2000       npth_clock_gettime (&curtime);
2001       if (!(npth_timercmp (&curtime, &abstime, <)))
2002         {
2003           /* Timeout.  */
2004           handle_tick ();
2005           npth_clock_gettime (&abstime);
2006           abstime.tv_sec += TIMERTICK_INTERVAL;
2007         }
2008       npth_timersub (&abstime, &curtime, &timeout);
2009
2010 #ifndef HAVE_W32_SYSTEM
2011       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout, npth_sigev_sigmask());
2012       saved_errno = errno;
2013
2014       while (npth_sigev_get_pending(&signo))
2015         handle_signal (signo);
2016 #else
2017       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2018       saved_errno = errno;
2019 #endif
2020
2021       if (ret == -1 && saved_errno != EINTR)
2022         {
2023           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2024                      strerror (saved_errno));
2025           npth_sleep (1);
2026           continue;
2027         }
2028
2029       if (ret <= 0)
2030         /* Interrupt or timeout.  Will be handled when calculating the
2031            next timeout.  */
2032         continue;
2033
2034       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2035         {
2036           plen = sizeof paddr;
2037           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2038                                     (struct sockaddr *)&paddr, &plen));
2039           if (fd == GNUPG_INVALID_FD)
2040             {
2041               log_error ("accept failed: %s\n", strerror (errno));
2042             }
2043           else
2044             {
2045               char threadname[50];
2046               union int_and_ptr_u argval;
2047               npth_t thread;
2048
2049               argval.afd = fd;
2050               snprintf (threadname, sizeof threadname-1,
2051                         "conn fd=%d", FD2INT(fd));
2052               threadname[sizeof threadname -1] = 0;
2053
2054               ret = npth_create (&thread, &tattr, start_connection_thread, argval.aptr);
2055               if (ret)
2056                 {
2057                   log_error ("error spawning connection handler: %s\n",
2058                              strerror (ret) );
2059                   assuan_sock_close (fd);
2060                 }
2061               npth_setname_np (thread, threadname);
2062             }
2063           fd = GNUPG_INVALID_FD;
2064         }
2065     }
2066
2067   npth_attr_destroy (&tattr);
2068   cleanup ();
2069   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2070 }