dirmngr: Initialize cache from sysconfig dir
[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_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_cache)
929     opt.homedir_cache = opt.homedir;
930
931   if (greeting)
932     {
933       es_fprintf (es_stderr, "%s %s; %s\n",
934                   strusage(11), strusage(13), strusage(14) );
935       es_fprintf (es_stderr, "%s\n", strusage(15) );
936     }
937
938 #ifdef IS_DEVELOPMENT_VERSION
939   log_info ("NOTE: this is a development version!\n");
940 #endif
941
942   /* Print a warning if an argument looks like an option.  */
943   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
944     {
945       int i;
946
947       for (i=0; i < argc; i++)
948         if (argv[i][0] == '-' && argv[i][1] == '-')
949           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
950     }
951
952   if (!access ("/etc/"DIRMNGR_NAME, F_OK) && !strncmp (opt.homedir, "/etc/", 5))
953     log_info
954       ("NOTE: DirMngr is now a proper part of %s.  The configuration and"
955        " other directory names changed.  Please check that no other version"
956        " of dirmngr is still installed.  To disable this warning, remove the"
957        " directory '/etc/dirmngr'.\n", GNUPG_NAME);
958
959   if (gnupg_faked_time_p ())
960     {
961       gnupg_isotime_t tbuf;
962
963       log_info (_("WARNING: running with faked system time: "));
964       gnupg_get_isotime (tbuf);
965       dump_isotime (tbuf);
966       log_printf ("\n");
967     }
968
969   set_debug ();
970
971   /* Get LDAP server list from file. */
972 #if USE_LDAP
973   if (!ldapfile)
974     {
975       ldapfile = make_filename (opt.homedir,
976                                 opt.system_daemon?
977                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
978                                 NULL);
979       opt.ldapservers = parse_ldapserver_file (ldapfile);
980       xfree (ldapfile);
981     }
982   else
983       opt.ldapservers = parse_ldapserver_file (ldapfile);
984 #endif /*USE_LDAP*/
985
986 #ifndef HAVE_W32_SYSTEM
987   /* We need to ignore the PIPE signal because the we might log to a
988      socket and that code handles EPIPE properly.  The ldap wrapper
989      also requires us to ignore this silly signal. Assuan would set
990      this signal to ignore anyway.*/
991   signal (SIGPIPE, SIG_IGN);
992 #endif
993
994   /* Ready.  Now to our duties. */
995   if (!cmd && opt.system_service)
996     cmd = aDaemon;
997   else if (!cmd)
998     cmd = aServer;
999   rc = 0;
1000
1001   if (cmd == aServer)
1002     {
1003       /* Note that this server mode is mainly useful for debugging.  */
1004       if (argc)
1005         wrong_args ("--server");
1006
1007       if (logfile)
1008         {
1009           log_set_file (logfile);
1010           log_set_prefix (NULL, 2|4);
1011         }
1012
1013       if (debug_wait)
1014         {
1015           log_debug ("waiting for debugger - my pid is %u .....\n",
1016                      (unsigned int)getpid());
1017           gnupg_sleep (debug_wait);
1018           log_debug ("... okay\n");
1019         }
1020
1021 #if USE_LDAP
1022       ldap_wrapper_launch_thread ();
1023 #endif /*USE_LDAP*/
1024
1025       cert_cache_init ();
1026       crl_cache_init ();
1027       start_command_handler (ASSUAN_INVALID_FD);
1028       shutdown_reaper ();
1029     }
1030   else if (cmd == aDaemon)
1031     {
1032       assuan_fd_t fd;
1033       pid_t pid;
1034       int len;
1035       struct sockaddr_un serv_addr;
1036
1037       if (argc)
1038         wrong_args ("--daemon");
1039
1040       /* Now start with logging to a file if this is desired. */
1041       if (logfile)
1042         {
1043           log_set_file (logfile);
1044           log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1045                                  |JNLIB_LOG_WITH_TIME
1046                                  |JNLIB_LOG_WITH_PID));
1047           current_logfile = xstrdup (logfile);
1048         }
1049
1050 #ifndef HAVE_W32_SYSTEM
1051       if (strchr (socket_name, ':'))
1052         {
1053           log_error (_("colons are not allowed in the socket name\n"));
1054           dirmngr_exit (1);
1055         }
1056 #endif
1057       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1058       if (fd == ASSUAN_INVALID_FD)
1059         {
1060           log_error (_("can't create socket: %s\n"), strerror (errno));
1061           cleanup ();
1062           dirmngr_exit (1);
1063         }
1064
1065 #if ASSUAN_VERSION_NUMBER >= 0x020104 /* >= 2.1.4 */
1066       {
1067         int redirected;
1068
1069         if (assuan_sock_set_sockaddr_un (socket_name,
1070                                          (struct sockaddr*)&serv_addr,
1071                                          &redirected))
1072           {
1073             if (errno == ENAMETOOLONG)
1074               log_error (_("socket name '%s' is too long\n"), socket_name);
1075             else
1076               log_error ("error preparing socket '%s': %s\n",
1077                          socket_name,
1078                          gpg_strerror (gpg_error_from_syserror ()));
1079             dirmngr_exit (1);
1080           }
1081         if (redirected)
1082           {
1083             redir_socket_name = xstrdup (serv_addr.sun_path);
1084             if (opt.verbose)
1085               log_info ("redirecting socket '%s' to '%s'\n",
1086                         socket_name, redir_socket_name);
1087           }
1088       }
1089 #else /* Assuan < 2.1.4 */
1090       memset (&serv_addr, 0, sizeof serv_addr);
1091       serv_addr.sun_family = AF_UNIX;
1092       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path )
1093         {
1094           log_error (_("socket name '%s' is too long\n"), socket_name);
1095           dirmngr_exit (1);
1096         }
1097       strcpy (serv_addr.sun_path, socket_name);
1098 #endif /* Assuan < 2.1.4 */
1099
1100       len = SUN_LEN (&serv_addr);
1101
1102       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1103       if (rc == -1
1104           && (errno == EADDRINUSE
1105 #ifdef HAVE_W32_SYSTEM
1106               || errno == EEXIST
1107 #endif
1108               ))
1109         {
1110           /* Fixme: We should test whether a dirmngr is already running. */
1111           gnupg_remove (redir_socket_name? redir_socket_name : socket_name);
1112           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
1113         }
1114       if (rc != -1
1115           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
1116         log_error (_("error getting nonce for the socket\n"));
1117       if (rc == -1)
1118         {
1119           log_error (_("error binding socket to '%s': %s\n"),
1120                      serv_addr.sun_path,
1121                      gpg_strerror (gpg_error_from_errno (errno)));
1122           assuan_sock_close (fd);
1123           dirmngr_exit (1);
1124         }
1125       cleanup_socket = 1;
1126
1127       if (listen (FD2INT (fd), 5) == -1)
1128         {
1129           log_error (_("listen() failed: %s\n"), strerror (errno));
1130           assuan_sock_close (fd);
1131           dirmngr_exit (1);
1132         }
1133
1134       if (opt.verbose)
1135         log_info (_("listening on socket '%s'\n"), serv_addr.sun_path);
1136
1137       es_fflush (NULL);
1138
1139       /* Note: We keep the dirmngr_info output only for the sake of
1140          existing scripts which might use this to detect a successful
1141          start of the dirmngr.  */
1142 #ifdef HAVE_W32_SYSTEM
1143       (void)csh_style;
1144       (void)nodetach;
1145
1146       pid = getpid ();
1147       es_printf ("set %s=%s;%lu;1\n",
1148                  DIRMNGR_INFO_NAME, socket_name, (ulong) pid);
1149 #else
1150       pid = fork();
1151       if (pid == (pid_t)-1)
1152         {
1153           log_fatal (_("error forking process: %s\n"), strerror (errno));
1154           dirmngr_exit (1);
1155         }
1156
1157       if (pid)
1158         { /* We are the parent */
1159           char *infostr;
1160
1161           /* Don't let cleanup() remove the socket - the child is
1162              responsible for doing that.  */
1163           cleanup_socket = 0;
1164
1165           close (fd);
1166
1167           /* Create the info string: <name>:<pid>:<protocol_version> */
1168           if (asprintf (&infostr, "%s=%s:%lu:1",
1169                         DIRMNGR_INFO_NAME, serv_addr.sun_path, (ulong)pid ) < 0)
1170             {
1171               log_error (_("out of core\n"));
1172               kill (pid, SIGTERM);
1173               dirmngr_exit (1);
1174             }
1175           /* Print the environment string, so that the caller can use
1176              shell's eval to set it.  But see above.  */
1177           if (csh_style)
1178             {
1179               *strchr (infostr, '=') = ' ';
1180               es_printf ( "setenv %s;\n", infostr);
1181             }
1182           else
1183             {
1184               es_printf ( "%s; export %s;\n", infostr, DIRMNGR_INFO_NAME);
1185             }
1186           free (infostr);
1187           exit (0);
1188           /*NEVER REACHED*/
1189         } /* end parent */
1190
1191
1192       /*
1193          This is the child
1194        */
1195
1196       /* Detach from tty and put process into a new session */
1197       if (!nodetach )
1198         {
1199           int i;
1200           unsigned int oldflags;
1201
1202           /* Close stdin, stdout and stderr unless it is the log stream */
1203           for (i=0; i <= 2; i++)
1204             {
1205               if (!log_test_fd (i) && i != fd )
1206                 close (i);
1207             }
1208           if (setsid() == -1)
1209             {
1210               log_error ("setsid() failed: %s\n", strerror(errno) );
1211               dirmngr_exit (1);
1212             }
1213
1214           log_get_prefix (&oldflags);
1215           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1216           opt.running_detached = 1;
1217
1218           if (chdir("/"))
1219             {
1220               log_error ("chdir to / failed: %s\n", strerror (errno));
1221               dirmngr_exit (1);
1222             }
1223         }
1224 #endif
1225
1226 #if USE_LDAP
1227       ldap_wrapper_launch_thread ();
1228 #endif /*USE_LDAP*/
1229
1230       cert_cache_init ();
1231       crl_cache_init ();
1232 #ifdef USE_W32_SERVICE
1233       if (opt.system_service)
1234         {
1235           service_status.dwCurrentState = SERVICE_RUNNING;
1236           SetServiceStatus (service_handle, &service_status);
1237         }
1238 #endif
1239       handle_connections (fd);
1240       assuan_sock_close (fd);
1241       shutdown_reaper ();
1242 #ifdef USE_W32_SERVICE
1243       if (opt.system_service)
1244         {
1245           service_status.dwCurrentState = SERVICE_STOPPED;
1246           SetServiceStatus (service_handle, &service_status);
1247         }
1248 #endif
1249     }
1250   else if (cmd == aListCRLs)
1251     {
1252       /* Just list the CRL cache and exit. */
1253       if (argc)
1254         wrong_args ("--list-crls");
1255 #if USE_LDAP
1256       ldap_wrapper_launch_thread ();
1257 #endif /*USE_LDAP*/
1258       crl_cache_init ();
1259       crl_cache_list (es_stdout);
1260     }
1261   else if (cmd == aLoadCRL)
1262     {
1263       struct server_control_s ctrlbuf;
1264
1265       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1266       dirmngr_init_default_ctrl (&ctrlbuf);
1267
1268 #if USE_LDAP
1269       ldap_wrapper_launch_thread ();
1270 #endif /*USE_LDAP*/
1271       cert_cache_init ();
1272       crl_cache_init ();
1273       if (!argc)
1274         rc = crl_cache_load (&ctrlbuf, NULL);
1275       else
1276         {
1277           for (; !rc && argc; argc--, argv++)
1278             rc = crl_cache_load (&ctrlbuf, *argv);
1279         }
1280     }
1281   else if (cmd == aFetchCRL)
1282     {
1283       ksba_reader_t reader;
1284       struct server_control_s ctrlbuf;
1285
1286       if (argc != 1)
1287         wrong_args ("--fetch-crl URL");
1288
1289       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1290       dirmngr_init_default_ctrl (&ctrlbuf);
1291
1292 #if USE_LDAP
1293       ldap_wrapper_launch_thread ();
1294 #endif /*USE_LDAP*/
1295       cert_cache_init ();
1296       crl_cache_init ();
1297       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1298       if (rc)
1299         log_error (_("fetching CRL from '%s' failed: %s\n"),
1300                      argv[0], gpg_strerror (rc));
1301       else
1302         {
1303           rc = crl_cache_insert (&ctrlbuf, argv[0], reader);
1304           if (rc)
1305             log_error (_("processing CRL from '%s' failed: %s\n"),
1306                        argv[0], gpg_strerror (rc));
1307           crl_close_reader (reader);
1308         }
1309     }
1310   else if (cmd == aFlush)
1311     {
1312       /* Delete cache and exit. */
1313       if (argc)
1314         wrong_args ("--flush");
1315       rc = crl_cache_flush();
1316     }
1317   else if (cmd == aGPGConfTest)
1318     dirmngr_exit (0);
1319   else if (cmd == aGPGConfList)
1320     {
1321       unsigned long flags = 0;
1322       char *filename;
1323       char *filename_esc;
1324
1325 #ifdef HAVE_W32_SYSTEM
1326       /* On Windows systems, dirmngr always runs as system daemon, and
1327          the per-user configuration is never used.  So we short-cut
1328          everything to use the global system configuration of dirmngr
1329          above, and here we set the no change flag to make these
1330          read-only.  */
1331       flags |= GC_OPT_FLAG_NO_CHANGE;
1332 #endif
1333
1334       /* First the configuration file.  This is not an option, but it
1335          is vital information for GPG Conf.  */
1336       if (!opt.config_filename)
1337         opt.config_filename = make_filename (opt.homedir,
1338                                              "dirmngr.conf", NULL );
1339
1340       filename = percent_escape (opt.config_filename, NULL);
1341       es_printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1342               GC_OPT_FLAG_DEFAULT, filename);
1343       xfree (filename);
1344
1345       es_printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1346       es_printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1347       es_printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1348       es_printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1349       es_printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1350
1351       /* --csh and --sh are mutually exclusive, something we can not
1352          express in GPG Conf.  --options is only usable from the
1353          command line, really.  --debug-all interacts with --debug,
1354          and having both of them is thus problematic.  --no-detach is
1355          also only usable on the command line.  --batch is unused.  */
1356
1357       filename = make_filename (opt.homedir,
1358                                 opt.system_daemon?
1359                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
1360                                 NULL);
1361       filename_esc = percent_escape (filename, NULL);
1362       es_printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1363               filename_esc);
1364       xfree (filename_esc);
1365       xfree (filename);
1366
1367       es_printf ("ldaptimeout:%lu:%u\n",
1368               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1369       es_printf ("max-replies:%lu:%u\n",
1370               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1371       es_printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1372       es_printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1373       es_printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1374
1375       es_printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1376       es_printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1377
1378       es_printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1379       es_printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1380       es_printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1381       es_printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1382       es_printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1383       es_printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1384       es_printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1385       es_printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1386       es_printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1387       /* Note: The next one is to fix a typo in gpgconf - should be
1388          removed eventually. */
1389       es_printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1390     }
1391   cleanup ();
1392   return !!rc;
1393 }
1394
1395
1396 #ifdef USE_W32_SERVICE
1397 static void WINAPI
1398 call_real_main (DWORD argc, LPSTR *argv)
1399 {
1400   real_main (argc, argv);
1401 }
1402
1403 int
1404 main (int argc, char *argv[])
1405 {
1406   int i;
1407
1408   /* Find out if we run in daemon mode or on the command line.  */
1409   for (i = 1; i < argc; i++)
1410     if (!strcmp (argv[i], "--service"))
1411       {
1412         opt.system_service = 1;
1413         opt.system_daemon = 1;
1414         break;
1415       }
1416
1417   if (!opt.system_service)
1418     return real_main (argc, argv);
1419   else
1420     {
1421       SERVICE_TABLE_ENTRY DispatchTable [] =
1422         {
1423           { "DirMngr", &call_real_main },
1424           { NULL, NULL }
1425         };
1426
1427       if (!StartServiceCtrlDispatcher (DispatchTable))
1428         return 1;
1429       return 0;
1430     }
1431 }
1432 #endif /*USE_W32_SERVICE*/
1433
1434
1435 static void
1436 cleanup (void)
1437 {
1438   crl_cache_deinit ();
1439   cert_cache_deinit (1);
1440
1441 #if USE_LDAP
1442   ldapserver_list_free (opt.ldapservers);
1443 #endif /*USE_LDAP*/
1444   opt.ldapservers = NULL;
1445
1446   if (cleanup_socket)
1447     {
1448       cleanup_socket = 0;
1449       if (redir_socket_name)
1450         gnupg_remove (redir_socket_name);
1451       else if (socket_name && *socket_name)
1452         gnupg_remove (socket_name);
1453     }
1454 }
1455
1456
1457 void
1458 dirmngr_exit (int rc)
1459 {
1460   cleanup ();
1461   exit (rc);
1462 }
1463
1464
1465 void
1466 dirmngr_init_default_ctrl (ctrl_t ctrl)
1467 {
1468   (void)ctrl;
1469
1470   /* Nothing for now. */
1471 }
1472
1473
1474 /* Create a list of LDAP servers from the file FILENAME. Returns the
1475    list or NULL in case of errors.
1476
1477    The format fo such a file is line oriented where empty lines and
1478    lines starting with a hash mark are ignored.  All other lines are
1479    assumed to be colon seprated with these fields:
1480
1481    1. field: Hostname
1482    2. field: Portnumber
1483    3. field: Username
1484    4. field: Password
1485    5. field: Base DN
1486
1487 */
1488 #if USE_LDAP
1489 static ldap_server_t
1490 parse_ldapserver_file (const char* filename)
1491 {
1492   char buffer[1024];
1493   char *p;
1494   ldap_server_t server, serverstart, *serverend;
1495   int c;
1496   unsigned int lineno = 0;
1497   estream_t fp;
1498
1499   fp = es_fopen (filename, "r");
1500   if (!fp)
1501     {
1502       log_error (_("error opening '%s': %s\n"), filename, strerror (errno));
1503       return NULL;
1504     }
1505
1506   serverstart = NULL;
1507   serverend = &serverstart;
1508   while (es_fgets (buffer, sizeof buffer, fp))
1509     {
1510       lineno++;
1511       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1512         {
1513           if (*buffer && es_feof (fp))
1514             ; /* Last line not terminated - continue. */
1515           else
1516             {
1517               log_error (_("%s:%u: line too long - skipped\n"),
1518                          filename, lineno);
1519               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1520                 ; /* Skip until end of line. */
1521               continue;
1522             }
1523         }
1524       /* Skip empty and comment lines.*/
1525       for (p=buffer; spacep (p); p++)
1526         ;
1527       if (!*p || *p == '\n' || *p == '#')
1528         continue;
1529
1530       /* Parse the colon separated fields. */
1531       server = ldapserver_parse_one (buffer, filename, lineno);
1532       if (server)
1533         {
1534           *serverend = server;
1535           serverend = &server->next;
1536         }
1537     }
1538
1539   if (es_ferror (fp))
1540     log_error (_("error reading '%s': %s\n"), filename, strerror (errno));
1541   es_fclose (fp);
1542
1543   return serverstart;
1544 }
1545 #endif /*USE_LDAP*/
1546
1547 static fingerprint_list_t
1548 parse_ocsp_signer (const char *string)
1549 {
1550   gpg_error_t err;
1551   char *fname;
1552   estream_t fp;
1553   char line[256];
1554   char *p;
1555   fingerprint_list_t list, *list_tail, item;
1556   unsigned int lnr = 0;
1557   int c, i, j;
1558   int errflag = 0;
1559
1560
1561   /* Check whether this is not a filename and treat it as a direct
1562      fingerprint specification.  */
1563   if (!strpbrk (string, "/.~\\"))
1564     {
1565       item = xcalloc (1, sizeof *item);
1566       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1567         if ( string[i] != ':' )
1568           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1569       item->hexfpr[j] = 0;
1570       if (j != 40 || !(spacep (string+i) || !string[i]))
1571         {
1572           log_error (_("%s:%u: invalid fingerprint detected\n"),
1573                      "--ocsp-signer", 0);
1574           xfree (item);
1575           return NULL;
1576         }
1577       return item;
1578     }
1579
1580   /* Well, it is a filename.  */
1581   if (*string == '/' || (*string == '~' && string[1] == '/'))
1582     fname = make_filename (string, NULL);
1583   else
1584     {
1585       if (string[0] == '.' && string[1] == '/' )
1586         string += 2;
1587       fname = make_filename (opt.homedir, string, NULL);
1588     }
1589
1590   fp = es_fopen (fname, "r");
1591   if (!fp)
1592     {
1593       err = gpg_error_from_syserror ();
1594       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
1595       xfree (fname);
1596       return NULL;
1597     }
1598
1599   list = NULL;
1600   list_tail = &list;
1601   for (;;)
1602     {
1603       if (!es_fgets (line, DIM(line)-1, fp) )
1604         {
1605           if (!es_feof (fp))
1606             {
1607               err = gpg_error_from_syserror ();
1608               log_error (_("%s:%u: read error: %s\n"),
1609                          fname, lnr, gpg_strerror (err));
1610               errflag = 1;
1611             }
1612           es_fclose (fp);
1613           if (errflag)
1614             {
1615               while (list)
1616                 {
1617                   fingerprint_list_t tmp = list->next;
1618                   xfree (list);
1619                   list = tmp;
1620                 }
1621             }
1622           xfree (fname);
1623           return list; /* Ready.  */
1624         }
1625
1626       lnr++;
1627       if (!*line || line[strlen(line)-1] != '\n')
1628         {
1629           /* Eat until end of line. */
1630           while ( (c=es_getc (fp)) != EOF && c != '\n')
1631             ;
1632           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1633                            /* */: GPG_ERR_INCOMPLETE_LINE);
1634           log_error (_("%s:%u: read error: %s\n"),
1635                      fname, lnr, gpg_strerror (err));
1636           errflag = 1;
1637           continue;
1638         }
1639
1640       /* Allow for empty lines and spaces */
1641       for (p=line; spacep (p); p++)
1642         ;
1643       if (!*p || *p == '\n' || *p == '#')
1644         continue;
1645
1646       item = xcalloc (1, sizeof *item);
1647       *list_tail = item;
1648       list_tail = &item->next;
1649
1650       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1651         if ( p[i] != ':' )
1652           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1653       item->hexfpr[j] = 0;
1654       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1655         {
1656           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1657           errflag = 1;
1658         }
1659       i++;
1660       while (spacep (p+i))
1661         i++;
1662       if (p[i] && p[i] != '\n')
1663         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1664     }
1665   /*NOTREACHED*/
1666 }
1667
1668
1669
1670 \f
1671 /*
1672    Stuff used in daemon mode.
1673  */
1674
1675
1676
1677 /* Reread parts of the configuration.  Note, that this function is
1678    obviously not thread-safe and should only be called from the NPTH
1679    signal handler.
1680
1681    Fixme: Due to the way the argument parsing works, we create a
1682    memory leak here for all string type arguments.  There is currently
1683    no clean way to tell whether the memory for the argument has been
1684    allocated or points into the process' original arguments.  Unless
1685    we have a mechanism to tell this, we need to live on with this. */
1686 static void
1687 reread_configuration (void)
1688 {
1689   ARGPARSE_ARGS pargs;
1690   FILE *fp;
1691   unsigned int configlineno = 0;
1692   int dummy;
1693
1694   if (!opt.config_filename)
1695     return; /* No config file. */
1696
1697   fp = fopen (opt.config_filename, "r");
1698   if (!fp)
1699     {
1700       log_error (_("option file '%s': %s\n"),
1701                  opt.config_filename, strerror(errno) );
1702       return;
1703     }
1704
1705   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1706
1707   memset (&pargs, 0, sizeof pargs);
1708   dummy = 0;
1709   pargs.argc = &dummy;
1710   pargs.flags = 1;  /* do not remove the args */
1711   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1712     {
1713       if (pargs.r_opt < -1)
1714         pargs.err = 1; /* Print a warning. */
1715       else /* Try to parse this option - ignore unchangeable ones. */
1716         parse_rereadable_options (&pargs, 1);
1717     }
1718   fclose (fp);
1719
1720   set_debug ();
1721 }
1722
1723
1724 /* A global function which allows us to trigger the reload stuff from
1725    other places.  */
1726 void
1727 dirmngr_sighup_action (void)
1728 {
1729   log_info (_("SIGHUP received - "
1730               "re-reading configuration and flushing caches\n"));
1731   reread_configuration ();
1732   cert_cache_deinit (0);
1733   crl_cache_deinit ();
1734   cert_cache_init ();
1735   crl_cache_init ();
1736 }
1737
1738
1739
1740 /* The signal handler. */
1741 #ifndef HAVE_W32_SYSTEM
1742 static void
1743 handle_signal (int signo)
1744 {
1745   switch (signo)
1746     {
1747     case SIGHUP:
1748       dirmngr_sighup_action ();
1749       break;
1750
1751     case SIGUSR1:
1752       cert_cache_print_stats ();
1753       break;
1754
1755     case SIGUSR2:
1756       log_info (_("SIGUSR2 received - no action defined\n"));
1757       break;
1758
1759     case SIGTERM:
1760       if (!shutdown_pending)
1761         log_info (_("SIGTERM received - shutting down ...\n"));
1762       else
1763         log_info (_("SIGTERM received - still %d active connections\n"),
1764                   active_connections);
1765       shutdown_pending++;
1766       if (shutdown_pending > 2)
1767         {
1768           log_info (_("shutdown forced\n"));
1769           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1770           cleanup ();
1771           dirmngr_exit (0);
1772         }
1773       break;
1774
1775     case SIGINT:
1776       log_info (_("SIGINT received - immediate shutdown\n"));
1777       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1778       cleanup ();
1779       dirmngr_exit (0);
1780       break;
1781
1782     default:
1783       log_info (_("signal %d received - no action defined\n"), signo);
1784     }
1785 }
1786 #endif /*!HAVE_W32_SYSTEM*/
1787
1788
1789 /* Thread to do the housekeeping.  */
1790 static void *
1791 housekeeping_thread (void *arg)
1792 {
1793   static int sentinel;
1794   time_t curtime;
1795
1796   (void)arg;
1797
1798   curtime = gnupg_get_time ();
1799   if (sentinel)
1800     {
1801       log_info ("housekeeping is already going on\n");
1802       return NULL;
1803     }
1804   sentinel++;
1805   if (opt.verbose)
1806     log_info ("starting housekeeping\n");
1807
1808   ks_hkp_housekeeping (curtime);
1809
1810   if (opt.verbose)
1811     log_info ("ready with housekeeping\n");
1812   sentinel--;
1813   return NULL;
1814
1815 }
1816
1817
1818 #if JNLIB_GCC_HAVE_PUSH_PRAGMA
1819 # pragma GCC push_options
1820 # pragma GCC optimize ("no-strict-overflow")
1821 #endif
1822 static int
1823 time_for_housekeeping_p (time_t curtime)
1824 {
1825   static time_t last_housekeeping;
1826
1827   if (!last_housekeeping)
1828     last_housekeeping = curtime;
1829
1830   if (last_housekeeping + HOUSEKEEPING_INTERVAL <= curtime
1831       || last_housekeeping > curtime /*(be prepared for y2038)*/)
1832     {
1833       last_housekeeping = curtime;
1834       return 1;
1835     }
1836   return 0;
1837 }
1838 #if JNLIB_GCC_HAVE_PUSH_PRAGMA
1839 # pragma GCC pop_options
1840 #endif
1841
1842
1843 /* This is the worker for the ticker.  It is called every few seconds
1844    and may only do fast operations. */
1845 static void
1846 handle_tick (void)
1847 {
1848   /* Under Windows we don't use signals and need a way for the loop to
1849      check for the shutdown flag.  */
1850 #ifdef HAVE_W32_SYSTEM
1851   if (shutdown_pending)
1852     log_info (_("SIGTERM received - shutting down ...\n"));
1853   if (shutdown_pending > 2)
1854     {
1855       log_info (_("shutdown forced\n"));
1856       log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1857       cleanup ();
1858       dirmngr_exit (0);
1859     }
1860 #endif /*HAVE_W32_SYSTEM*/
1861
1862   if (time_for_housekeeping_p (gnupg_get_time ()))
1863     {
1864       npth_t thread;
1865       npth_attr_t tattr;
1866       int err;
1867
1868       err = npth_attr_init (&tattr);
1869       if (err)
1870         log_error ("error preparing housekeeping thread: %s\n", strerror (err));
1871       else
1872         {
1873           npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1874           err = npth_create (&thread, &tattr, housekeeping_thread, NULL);
1875           if (err)
1876             log_error ("error spawning housekeeping thread: %s\n",
1877                        strerror (err));
1878           npth_attr_destroy (&tattr);
1879         }
1880     }
1881 }
1882
1883
1884 /* Check the nonce on a new connection.  This is a NOP unless we we
1885    are using our Unix domain socket emulation under Windows.  */
1886 static int
1887 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1888 {
1889   if (assuan_sock_check_nonce (fd, nonce))
1890     {
1891       log_info (_("error reading nonce on fd %d: %s\n"),
1892                 FD2INT (fd), strerror (errno));
1893       assuan_sock_close (fd);
1894       return -1;
1895     }
1896   else
1897     return 0;
1898 }
1899
1900
1901 /* Helper to call a connection's main fucntion. */
1902 static void *
1903 start_connection_thread (void *arg)
1904 {
1905   union int_and_ptr_u argval;
1906   gnupg_fd_t fd;
1907
1908   argval.aptr = arg;
1909   fd = argval.afd;
1910
1911   if (check_nonce (fd, &socket_nonce))
1912     {
1913       log_error ("handler nonce check FAILED\n");
1914       return NULL;
1915     }
1916
1917 #ifndef HAVE_W32_SYSTEM
1918   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1919 #endif
1920
1921   active_connections++;
1922   if (opt.verbose)
1923     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1924
1925   start_command_handler (fd);
1926
1927   if (opt.verbose)
1928     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1929   active_connections--;
1930
1931 #ifndef HAVE_W32_SYSTEM
1932   argval.afd = ASSUAN_INVALID_FD;
1933   npth_setspecific (my_tlskey_current_fd, argval.aptr);
1934 #endif
1935
1936   return NULL;
1937 }
1938
1939
1940 /* Main loop in daemon mode. */
1941 static void
1942 handle_connections (assuan_fd_t listen_fd)
1943 {
1944   npth_attr_t tattr;
1945 #ifndef HAVE_W32_SYSTEM
1946   int signo;
1947 #endif
1948   struct sockaddr_un paddr;
1949   socklen_t plen = sizeof( paddr );
1950   gnupg_fd_t fd;
1951   int nfd, ret;
1952   fd_set fdset, read_fdset;
1953   struct timespec abstime;
1954   struct timespec curtime;
1955   struct timespec timeout;
1956   int saved_errno;
1957
1958   npth_attr_init (&tattr);
1959   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1960
1961 #ifndef HAVE_W32_SYSTEM /* FIXME */
1962   npth_sigev_init ();
1963   npth_sigev_add (SIGHUP);
1964   npth_sigev_add (SIGUSR1);
1965   npth_sigev_add (SIGUSR2);
1966   npth_sigev_add (SIGINT);
1967   npth_sigev_add (SIGTERM);
1968   npth_sigev_fini ();
1969 #endif
1970
1971   /* Setup the fdset.  It has only one member.  This is because we use
1972      pth_select instead of pth_accept to properly sync timeouts with
1973      to full second.  */
1974   FD_ZERO (&fdset);
1975   FD_SET (FD2INT (listen_fd), &fdset);
1976   nfd = FD2INT (listen_fd);
1977
1978   npth_clock_gettime (&abstime);
1979   abstime.tv_sec += TIMERTICK_INTERVAL;
1980
1981   /* Main loop.  */
1982   for (;;)
1983     {
1984       /* Shutdown test.  */
1985       if (shutdown_pending)
1986         {
1987           if (!active_connections)
1988             break; /* ready */
1989
1990           /* Do not accept new connections but keep on running the
1991              loop to cope with the timer events.  */
1992           FD_ZERO (&fdset);
1993         }
1994
1995       /* Take a copy of the fdset.  */
1996       read_fdset = fdset;
1997
1998       npth_clock_gettime (&curtime);
1999       if (!(npth_timercmp (&curtime, &abstime, <)))
2000         {
2001           /* Timeout.  */
2002           handle_tick ();
2003           npth_clock_gettime (&abstime);
2004           abstime.tv_sec += TIMERTICK_INTERVAL;
2005         }
2006       npth_timersub (&abstime, &curtime, &timeout);
2007
2008 #ifndef HAVE_W32_SYSTEM
2009       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout, npth_sigev_sigmask());
2010       saved_errno = errno;
2011
2012       while (npth_sigev_get_pending(&signo))
2013         handle_signal (signo);
2014 #else
2015       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout, NULL, NULL);
2016       saved_errno = errno;
2017 #endif
2018
2019       if (ret == -1 && saved_errno != EINTR)
2020         {
2021           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2022                      strerror (saved_errno));
2023           npth_sleep (1);
2024           continue;
2025         }
2026
2027       if (ret <= 0)
2028         /* Interrupt or timeout.  Will be handled when calculating the
2029            next timeout.  */
2030         continue;
2031
2032       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2033         {
2034           plen = sizeof paddr;
2035           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2036                                     (struct sockaddr *)&paddr, &plen));
2037           if (fd == GNUPG_INVALID_FD)
2038             {
2039               log_error ("accept failed: %s\n", strerror (errno));
2040             }
2041           else
2042             {
2043               char threadname[50];
2044               union int_and_ptr_u argval;
2045               npth_t thread;
2046
2047               argval.afd = fd;
2048               snprintf (threadname, sizeof threadname-1,
2049                         "conn fd=%d", FD2INT(fd));
2050               threadname[sizeof threadname -1] = 0;
2051
2052               ret = npth_create (&thread, &tattr, start_connection_thread, argval.aptr);
2053               if (ret)
2054                 {
2055                   log_error ("error spawning connection handler: %s\n",
2056                              strerror (ret) );
2057                   assuan_sock_close (fd);
2058                 }
2059               npth_setname_np (thread, threadname);
2060             }
2061           fd = GNUPG_INVALID_FD;
2062         }
2063     }
2064
2065   npth_attr_destroy (&tattr);
2066   cleanup ();
2067   log_info ("%s %s stopped\n", strusage(11), strusage(13));
2068 }