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