dirmngr: Fix memory leak.
[gnupg.git] / dirmngr / dirmngr.c
1 /* dirmngr.c - Keyserver and X.509 LDAP access
2  * Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2010, 2011 g10 Code GmbH
4  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stddef.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <assert.h>
31 #include <time.h>
32 #include <fcntl.h>
33 #ifndef HAVE_W32_SYSTEM
34 #include <sys/socket.h>
35 #include <sys/un.h>
36 #endif
37 #include <sys/stat.h>
38 #include <unistd.h>
39 #ifdef HAVE_SIGNAL_H
40 # include <signal.h>
41 #endif
42 #include <npth.h>
43
44 #include "dirmngr-err.h"
45
46 #if  HTTP_USE_NTBTLS
47 # include <ntbtls.h>
48 #elif HTTP_USE_GNUTLS
49 # include <gnutls/gnutls.h>
50 #endif /*HTTP_USE_GNUTLS*/
51
52
53 #define JNLIB_NEED_LOG_LOGV
54 #define JNLIB_NEED_AFLOCAL
55 #include "dirmngr.h"
56
57 #include <assuan.h>
58
59 #include "certcache.h"
60 #include "crlcache.h"
61 #include "crlfetch.h"
62 #include "misc.h"
63 #if USE_LDAP
64 # include "ldapserver.h"
65 #endif
66 #include "asshelp.h"
67 #if USE_LDAP
68 # include "ldap-wrapper.h"
69 #endif
70 #include "../common/init.h"
71 #include "gc-opt-flags.h"
72
73 /* The plain Windows version uses the windows service system.  For
74    example to start the service you may use "sc start dirmngr".
75    WindowsCE does not support this; the service system over there is
76    based on a single process with all services being DLLs - we can't
77    support this easily.  */
78 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
79 # define USE_W32_SERVICE 1
80 #endif
81
82 #ifndef ENAMETOOLONG
83 # define ENAMETOOLONG EINVAL
84 #endif
85
86
87 enum cmd_and_opt_values {
88   aNull = 0,
89   oCsh            = 'c',
90   oQuiet          = 'q',
91   oSh             = 's',
92   oVerbose        = 'v',
93   oNoVerbose = 500,
94
95   aServer,
96   aDaemon,
97   aService,
98   aListCRLs,
99   aLoadCRL,
100   aFetchCRL,
101   aShutdown,
102   aFlush,
103   aGPGConfList,
104   aGPGConfTest,
105
106   oOptions,
107   oDebug,
108   oDebugAll,
109   oDebugWait,
110   oDebugLevel,
111   oGnutlsDebug,
112   oNoGreeting,
113   oNoOptions,
114   oHomedir,
115   oNoDetach,
116   oLogFile,
117   oBatch,
118   oDisableHTTP,
119   oDisableLDAP,
120   oIgnoreLDAPDP,
121   oIgnoreHTTPDP,
122   oIgnoreOCSPSvcUrl,
123   oHonorHTTPProxy,
124   oHTTPProxy,
125   oLDAPProxy,
126   oOnlyLDAPProxy,
127   oLDAPFile,
128   oLDAPTimeout,
129   oLDAPAddServers,
130   oOCSPResponder,
131   oOCSPSigner,
132   oOCSPMaxClockSkew,
133   oOCSPMaxPeriod,
134   oOCSPCurrentPeriod,
135   oMaxReplies,
136   oHkpCaCert,
137   oFakedSystemTime,
138   oForce,
139   oAllowOCSP,
140   oSocketName,
141   oLDAPWrapperProgram,
142   oHTTPWrapperProgram,
143   oIgnoreCertExtension,
144   aTest
145 };
146
147
148
149 static ARGPARSE_OPTS opts[] = {
150
151   ARGPARSE_group (300, N_("@Commands:\n ")),
152
153   ARGPARSE_c (aServer,   "server",  N_("run in server mode (foreground)") ),
154   ARGPARSE_c (aDaemon,   "daemon",  N_("run in daemon mode (background)") ),
155 #ifdef USE_W32_SERVICE
156   ARGPARSE_c (aService,  "service", N_("run as windows service (background)")),
157 #endif
158   ARGPARSE_c (aListCRLs, "list-crls", N_("list the contents of the CRL cache")),
159   ARGPARSE_c (aLoadCRL,  "load-crl",  N_("|FILE|load CRL from FILE into cache")),
160   ARGPARSE_c (aFetchCRL, "fetch-crl", N_("|URL|fetch a CRL from URL")),
161   ARGPARSE_c (aShutdown, "shutdown",  N_("shutdown the dirmngr")),
162   ARGPARSE_c (aFlush,    "flush",     N_("flush the cache")),
163   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
164   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
165
166   ARGPARSE_group (301, N_("@\nOptions:\n ")),
167
168   ARGPARSE_s_n (oVerbose,  "verbose",   N_("verbose")),
169   ARGPARSE_s_n (oQuiet,    "quiet",     N_("be somewhat more quiet")),
170   ARGPARSE_s_n (oSh,       "sh",        N_("sh-style command output")),
171   ARGPARSE_s_n (oCsh,      "csh",       N_("csh-style command output")),
172   ARGPARSE_s_s (oOptions,  "options",   N_("|FILE|read options from FILE")),
173   ARGPARSE_s_s (oDebugLevel, "debug-level",
174                 N_("|LEVEL|set the debugging level to LEVEL")),
175   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
176   ARGPARSE_s_s (oLogFile,  "log-file",
177                 N_("|FILE|write server mode logs to FILE")),
178   ARGPARSE_s_n (oBatch,    "batch",       N_("run without asking a user")),
179   ARGPARSE_s_n (oForce,    "force",       N_("force loading of outdated CRLs")),
180   ARGPARSE_s_n (oAllowOCSP, "allow-ocsp", N_("allow sending OCSP requests")),
181   ARGPARSE_s_n (oDisableHTTP, "disable-http", N_("inhibit the use of HTTP")),
182   ARGPARSE_s_n (oDisableLDAP, "disable-ldap", N_("inhibit the use of LDAP")),
183   ARGPARSE_s_n (oIgnoreHTTPDP,"ignore-http-dp",
184                 N_("ignore HTTP CRL distribution points")),
185   ARGPARSE_s_n (oIgnoreLDAPDP,"ignore-ldap-dp",
186                 N_("ignore LDAP CRL distribution points")),
187   ARGPARSE_s_n (oIgnoreOCSPSvcUrl, "ignore-ocsp-service-url",
188                 N_("ignore certificate contained OCSP service URLs")),
189
190   ARGPARSE_s_s (oHTTPProxy,  "http-proxy",
191                 N_("|URL|redirect all HTTP requests to URL")),
192   ARGPARSE_s_s (oLDAPProxy,  "ldap-proxy",
193                 N_("|HOST|use HOST for LDAP queries")),
194   ARGPARSE_s_n (oOnlyLDAPProxy, "only-ldap-proxy",
195                 N_("do not use fallback hosts with --ldap-proxy")),
196
197   ARGPARSE_s_s (oLDAPFile, "ldapserverlist-file",
198                 N_("|FILE|read LDAP server list from FILE")),
199   ARGPARSE_s_n (oLDAPAddServers, "add-servers",
200                 N_("add new servers discovered in CRL distribution"
201                    " points to serverlist")),
202   ARGPARSE_s_i (oLDAPTimeout, "ldaptimeout",
203                 N_("|N|set LDAP timeout to N seconds")),
204
205   ARGPARSE_s_s (oOCSPResponder, "ocsp-responder",
206                 N_("|URL|use OCSP responder at URL")),
207   ARGPARSE_s_s (oOCSPSigner, "ocsp-signer",
208                 N_("|FPR|OCSP response signed by FPR")),
209   ARGPARSE_s_i (oOCSPMaxClockSkew, "ocsp-max-clock-skew", "@"),
210   ARGPARSE_s_i (oOCSPMaxPeriod,    "ocsp-max-period", "@"),
211   ARGPARSE_s_i (oOCSPCurrentPeriod, "ocsp-current-period", "@"),
212
213   ARGPARSE_s_i (oMaxReplies, "max-replies",
214                 N_("|N|do not return more than N items in one query")),
215
216   ARGPARSE_s_s (oHkpCaCert, "hkp-cacert",
217                 N_("|FILE|use the CA certificates in FILE for HKP over TLS")),
218
219
220   ARGPARSE_s_s (oSocketName, "socket-name", "@"),  /* Only for debugging.  */
221
222   ARGPARSE_s_u (oFakedSystemTime, "faked-system-time", "@"), /*(epoch time)*/
223   ARGPARSE_p_u (oDebug,    "debug", "@"),
224   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
225   ARGPARSE_s_i (oGnutlsDebug, "gnutls-debug", "@"),
226   ARGPARSE_s_i (oGnutlsDebug, "tls-debug", "@"),
227   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
228   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
229   ARGPARSE_s_s (oHomedir, "homedir", "@"),
230   ARGPARSE_s_s (oLDAPWrapperProgram, "ldap-wrapper-program", "@"),
231   ARGPARSE_s_s (oHTTPWrapperProgram, "http-wrapper-program", "@"),
232   ARGPARSE_s_n (oHonorHTTPProxy, "honor-http-proxy", "@"),
233   ARGPARSE_s_s (oIgnoreCertExtension,"ignore-cert-extension", "@"),
234
235   ARGPARSE_group (302,N_("@\n(See the \"info\" manual for a complete listing "
236                          "of all commands and options)\n")),
237
238   ARGPARSE_end ()
239 };
240
241 #define DEFAULT_MAX_REPLIES 10
242 #define DEFAULT_LDAP_TIMEOUT 100 /* arbitrary large timeout */
243
244 /* For the cleanup handler we need to keep track of the socket's name.  */
245 static const char *socket_name;
246 /* If the socket has been redirected, this is the name of the
247    redirected socket..  */
248 static const char *redir_socket_name;
249
250 /* We need to keep track of the server's nonces (these are dummies for
251    POSIX systems). */
252 static assuan_sock_nonce_t socket_nonce;
253
254 /* Only if this flag has been set we will remove the socket file.  */
255 static int cleanup_socket;
256
257 /* Keep track of the current log file so that we can avoid updating
258    the log file after a SIGHUP if it didn't changed. Malloced. */
259 static char *current_logfile;
260
261 /* Helper to implement --debug-level. */
262 static const char *debug_level;
263
264 /* Helper to set the NTBTLS or GNUTLS log level.  */
265 static int opt_gnutls_debug = -1;
266
267 /* Flag indicating that a shutdown has been requested.  */
268 static volatile int shutdown_pending;
269
270 /* Counter for the active connections.  */
271 static int active_connections;
272
273 /* The timer tick used for housekeeping stuff.  For Windows we use a
274    longer period as the SetWaitableTimer seems to signal earlier than
275    the 2 seconds.  All values are in seconds. */
276 #if defined(HAVE_W32CE_SYSTEM)
277 # define TIMERTICK_INTERVAL         (60)
278 #elif defined(HAVE_W32_SYSTEM)
279 # define TIMERTICK_INTERVAL          (4)
280 #else
281 # define TIMERTICK_INTERVAL          (2)
282 #endif
283
284 #define HOUSEKEEPING_INTERVAL      (600)
285
286
287 /* This union is used to avoid compiler warnings in case a pointer is
288    64 bit and an int 32 bit.  We store an integer in a pointer and get
289    it back later (npth_getspecific et al.).  */
290 union int_and_ptr_u
291 {
292   int  aint;
293   assuan_fd_t afd;
294   void *aptr;
295 };
296
297
298
299 /* The key used to store the current file descriptor in the thread
300    local storage.  We use this in conjunction with the
301    log_set_pid_suffix_cb feature..  */
302 #ifndef HAVE_W32_SYSTEM
303 static int my_tlskey_current_fd;
304 #endif
305
306 /* Prototypes. */
307 static void cleanup (void);
308 #if USE_LDAP
309 static ldap_server_t parse_ldapserver_file (const char* filename);
310 #endif /*USE_LDAP*/
311 static fingerprint_list_t parse_ocsp_signer (const char *string);
312 static void handle_connections (assuan_fd_t listen_fd);
313
314 /* NPth wrapper function definitions. */
315 ASSUAN_SYSTEM_NPTH_IMPL;
316
317 static const char *
318 my_strusage( int level )
319 {
320   const char *p;
321   switch ( level )
322     {
323     case 11: p = "@DIRMNGR@ (@GNUPG@)";
324       break;
325     case 13: p = VERSION; break;
326     case 17: p = PRINTABLE_OS_NAME; break;
327       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
328          reporting address.  This is so that we can change the
329          reporting address without breaking the translations.  */
330     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
331     case 49: p = PACKAGE_BUGREPORT; break;
332     case 1:
333     case 40: p = _("Usage: @DIRMNGR@ [options] (-h for help)");
334       break;
335     case 41: p = _("Syntax: @DIRMNGR@ [options] [command [args]]\n"
336                    "Keyserver, CRL, and OCSP access for @GNUPG@\n");
337       break;
338
339     default: p = NULL;
340     }
341   return p;
342 }
343
344
345 /* Callback from libksba to hash a provided buffer.  Our current
346    implementation does only allow SHA-1 for hashing. This may be
347    extended by mapping the name, testing for algorithm availibility
348    and adjust the length checks accordingly. */
349 static gpg_error_t
350 my_ksba_hash_buffer (void *arg, const char *oid,
351                      const void *buffer, size_t length, size_t resultsize,
352                      unsigned char *result, size_t *resultlen)
353 {
354   (void)arg;
355
356   if (oid && strcmp (oid, "1.3.14.3.2.26"))
357     return gpg_error (GPG_ERR_NOT_SUPPORTED);
358   if (resultsize < 20)
359     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
360   gcry_md_hash_buffer (2, result, buffer, length);
361   *resultlen = 20;
362   return 0;
363 }
364
365
366 /* GNUTLS log function callback.  */
367 static void
368 my_gnutls_log (int level, const char *text)
369 {
370   int n;
371
372   n = strlen (text);
373   while (n && text[n-1] == '\n')
374     n--;
375
376   log_debug ("gnutls:L%d: %.*s\n", level, n, text);
377 }
378
379
380 /* Setup the debugging.  With a LEVEL of NULL only the active debug
381    flags are propagated to the subsystems.  With LEVEL set, a specific
382    set of debug flags is set; thus overriding all flags already
383    set. */
384 static void
385 set_debug (void)
386 {
387   int numok = (debug_level && digitp (debug_level));
388   int numlvl = numok? atoi (debug_level) : 0;
389
390   if (!debug_level)
391     ;
392   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
393     opt.debug = 0;
394   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
395     opt.debug = DBG_ASSUAN_VALUE;
396   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
397     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE);
398   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
399     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE
400                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
401   else if (!strcmp (debug_level, "guru") || numok)
402     {
403       opt.debug = ~0;
404       /* Unless the "guru" string has been used we don't want to allow
405          hashing debugging.  The rationale is that people tend to
406          select the highest debug value and would then clutter their
407          disk with debug files which may reveal confidential data.  */
408       if (numok)
409         opt.debug &= ~(DBG_HASHING_VALUE);
410     }
411   else
412     {
413       log_error (_("invalid debug-level '%s' given\n"), debug_level);
414       log_info (_("valid debug levels are: %s\n"),
415                 "none, basic, advanced, expert, guru");
416       opt.debug = 0; /* Reset debugging, so that prior debug
417                         statements won't have an undesired effect. */
418     }
419
420
421   if (opt.debug && !opt.verbose)
422     {
423       opt.verbose = 1;
424       gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
425     }
426   if (opt.debug && opt.quiet)
427     opt.quiet = 0;
428
429   if (opt.debug & DBG_CRYPTO_VALUE )
430     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
431
432 #if HTTP_USE_NTBTLS
433   if (opt_gnutls_debug >= 0)
434     {
435       ntbtls_set_debug (opt_gnutls_debug, NULL, NULL);
436     }
437 #elif HTTP_USE_GNUTLS
438   if (opt_gnutls_debug >= 0)
439     {
440       gnutls_global_set_log_function (my_gnutls_log);
441       gnutls_global_set_log_level (opt_gnutls_debug);
442     }
443 #endif /*HTTP_USE_GNUTLS*/
444 }
445
446
447 static void
448 wrong_args (const char *text)
449 {
450   es_fprintf (es_stderr, _("usage: %s [options] "), DIRMNGR_NAME);
451   es_fputs (text, es_stderr);
452   es_putc ('\n', es_stderr);
453   dirmngr_exit (2);
454 }
455
456
457 /* Helper to stop the reaper thread for the ldap wrapper.  */
458 static void
459 shutdown_reaper (void)
460 {
461 #if USE_LDAP
462   ldap_wrapper_wait_connections ();
463 #endif
464 }
465
466
467 /* Handle options which are allowed to be reset after program start.
468    Return true if the current option in PARGS could be handled and
469    false if not.  As a special feature, passing a value of NULL for
470    PARGS, resets the options to the default.  REREAD should be set
471    true if it is not the initial option parsing. */
472 static int
473 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
474 {
475   if (!pargs)
476     { /* Reset mode. */
477       opt.quiet = 0;
478       opt.verbose = 0;
479       opt.debug = 0;
480       opt.ldap_wrapper_program = NULL;
481       opt.disable_http = 0;
482       opt.disable_ldap = 0;
483       opt.honor_http_proxy = 0;
484       opt.http_proxy = NULL;
485       opt.ldap_proxy = NULL;
486       opt.only_ldap_proxy = 0;
487       opt.ignore_http_dp = 0;
488       opt.ignore_ldap_dp = 0;
489       opt.ignore_ocsp_service_url = 0;
490       opt.allow_ocsp = 0;
491       opt.ocsp_responder = NULL;
492       opt.ocsp_max_clock_skew = 10 * 60;      /* 10 minutes.  */
493       opt.ocsp_max_period = 90 * 86400;       /* 90 days.  */
494       opt.ocsp_current_period = 3 * 60 * 60;  /* 3 hours. */
495       opt.max_replies = DEFAULT_MAX_REPLIES;
496       while (opt.ocsp_signer)
497         {
498           fingerprint_list_t tmp = opt.ocsp_signer->next;
499           xfree (opt.ocsp_signer);
500           opt.ocsp_signer = tmp;
501         }
502       FREE_STRLIST (opt.ignored_cert_extensions);
503       http_register_tls_ca (NULL);
504       return 1;
505     }
506
507   switch (pargs->r_opt)
508     {
509     case oQuiet:   opt.quiet = 1; break;
510     case oVerbose: opt.verbose++; break;
511     case oDebug:   opt.debug |= pargs->r.ret_ulong; break;
512     case oDebugAll: opt.debug = ~0; break;
513     case oDebugLevel: debug_level = pargs->r.ret_str; break;
514     case oGnutlsDebug: opt_gnutls_debug = pargs->r.ret_int; break;
515
516     case oLogFile:
517       if (!reread)
518         return 0; /* Not handled. */
519       if (!current_logfile || !pargs->r.ret_str
520           || strcmp (current_logfile, pargs->r.ret_str))
521         {
522           log_set_file (pargs->r.ret_str);
523           xfree (current_logfile);
524           current_logfile = xtrystrdup (pargs->r.ret_str);
525         }
526       break;
527
528     case oLDAPWrapperProgram:
529       opt.ldap_wrapper_program = pargs->r.ret_str;
530       break;
531     case oHTTPWrapperProgram:
532       opt.http_wrapper_program = pargs->r.ret_str;
533       break;
534
535     case oDisableHTTP: opt.disable_http = 1; break;
536     case oDisableLDAP: opt.disable_ldap = 1; break;
537     case oHonorHTTPProxy: opt.honor_http_proxy = 1; break;
538     case oHTTPProxy: opt.http_proxy = pargs->r.ret_str; break;
539     case oLDAPProxy: opt.ldap_proxy = pargs->r.ret_str; break;
540     case oOnlyLDAPProxy: opt.only_ldap_proxy = 1; break;
541     case oIgnoreHTTPDP: opt.ignore_http_dp = 1; break;
542     case oIgnoreLDAPDP: opt.ignore_ldap_dp = 1; break;
543     case oIgnoreOCSPSvcUrl: opt.ignore_ocsp_service_url = 1; break;
544
545     case oAllowOCSP: opt.allow_ocsp = 1; break;
546     case oOCSPResponder: opt.ocsp_responder = pargs->r.ret_str; break;
547     case oOCSPSigner:
548       opt.ocsp_signer = parse_ocsp_signer (pargs->r.ret_str);
549       break;
550     case oOCSPMaxClockSkew: opt.ocsp_max_clock_skew = pargs->r.ret_int; break;
551     case oOCSPMaxPeriod: opt.ocsp_max_period = pargs->r.ret_int; break;
552     case oOCSPCurrentPeriod: opt.ocsp_current_period = pargs->r.ret_int; break;
553
554     case oMaxReplies: opt.max_replies = pargs->r.ret_int; break;
555
556     case oHkpCaCert:
557       http_register_tls_ca (pargs->r.ret_str);
558       break;
559
560     case oIgnoreCertExtension:
561       add_to_strlist (&opt.ignored_cert_extensions, pargs->r.ret_str);
562       break;
563
564     default:
565       return 0; /* Not handled. */
566     }
567
568   return 1; /* Handled. */
569 }
570
571
572 #ifdef USE_W32_SERVICE
573 /* The global status of our service.  */
574 SERVICE_STATUS_HANDLE service_handle;
575 SERVICE_STATUS service_status;
576
577 DWORD WINAPI
578 w32_service_control (DWORD control, DWORD event_type, LPVOID event_data,
579                      LPVOID context)
580 {
581   (void)event_type;
582   (void)event_data;
583   (void)context;
584
585   /* event_type and event_data are not used here.  */
586   switch (control)
587     {
588     case SERVICE_CONTROL_SHUTDOWN:
589       /* For shutdown we will try to force termination.  */
590       service_status.dwCurrentState = SERVICE_STOP_PENDING;
591       SetServiceStatus (service_handle, &service_status);
592       shutdown_pending = 3;
593       break;
594
595     case SERVICE_CONTROL_STOP:
596       service_status.dwCurrentState = SERVICE_STOP_PENDING;
597       SetServiceStatus (service_handle, &service_status);
598       shutdown_pending = 1;
599       break;
600
601     default:
602       break;
603     }
604   return 0;
605 }
606 #endif /*USE_W32_SERVICE*/
607
608 #ifndef HAVE_W32_SYSTEM
609 static int
610 pid_suffix_callback (unsigned long *r_suffix)
611 {
612   union int_and_ptr_u value;
613
614   value.aptr = npth_getspecific (my_tlskey_current_fd);
615   *r_suffix = value.aint;
616   return (*r_suffix != -1);  /* Use decimal representation.  */
617 }
618 #endif /*!HAVE_W32_SYSTEM*/
619
620
621 #ifdef USE_W32_SERVICE
622 # define main real_main
623 #endif
624 int
625 main (int argc, char **argv)
626 {
627 #ifdef USE_W32_SERVICE
628 # undef main
629 #endif
630   enum cmd_and_opt_values cmd = 0;
631   ARGPARSE_ARGS pargs;
632   int orig_argc;
633   char **orig_argv;
634   FILE *configfp = NULL;
635   char *configname = NULL;
636   const char *shell;
637   unsigned configlineno;
638   int parse_debug = 0;
639   int default_config =1;
640   int greeting = 0;
641   int nogreeting = 0;
642   int nodetach = 0;
643   int csh_style = 0;
644   char *logfile = NULL;
645 #if USE_LDAP
646   char *ldapfile = NULL;
647 #endif /*USE_LDAP*/
648   int debug_wait = 0;
649   int rc;
650   int homedir_seen = 0;
651   struct assuan_malloc_hooks malloc_hooks;
652
653 #ifdef USE_W32_SERVICE
654   /* The option will be set by main() below if we should run as a
655      system daemon.  */
656   if (opt.system_service)
657     {
658       service_handle
659         = RegisterServiceCtrlHandlerEx ("DirMngr",
660                                         &w32_service_control, NULL /*FIXME*/);
661       if (service_handle == 0)
662         log_error ("failed to register service control handler: ec=%d",
663                    (int) GetLastError ());
664       service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
665       service_status.dwCurrentState = SERVICE_START_PENDING;
666       service_status.dwControlsAccepted
667         = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
668       service_status.dwWin32ExitCode = NO_ERROR;
669       service_status.dwServiceSpecificExitCode = NO_ERROR;
670       service_status.dwCheckPoint = 0;
671       service_status.dwWaitHint = 10000; /* 10 seconds timeout.  */
672       SetServiceStatus (service_handle, &service_status);
673     }
674 #endif /*USE_W32_SERVICE*/
675
676   set_strusage (my_strusage);
677   log_set_prefix (DIRMNGR_NAME, 1|4);
678
679   /* Make sure that our subsystems are ready.  */
680   i18n_init ();
681   init_common_subsystems (&argc, &argv);
682
683   npth_init ();
684
685   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
686
687  /* Check that the libraries are suitable.  Do it here because
688     the option parsing may need services of the libraries. */
689
690   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
691     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
692                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
693   if (!ksba_check_version (NEED_KSBA_VERSION) )
694     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
695                NEED_KSBA_VERSION, ksba_check_version (NULL) );
696
697   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
698   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
699
700   /* Init TLS library.  */
701 #if HTTP_USE_NTBTLS
702   if (!ntbtls_check_version (NEED_NTBTLS_VERSION) )
703     log_fatal( _("%s is too old (need %s, have %s)\n"), "ntbtls",
704                NEED_NTBTLS_VERSION, ntbtls_check_version (NULL) );
705 #elif HTTP_USE_GNUTLS
706   rc = gnutls_global_init ();
707   if (rc)
708     log_fatal ("gnutls_global_init failed: %s\n", gnutls_strerror (rc));
709 #endif /*HTTP_USE_GNUTLS*/
710
711   /* Init Assuan. */
712   malloc_hooks.malloc = gcry_malloc;
713   malloc_hooks.realloc = gcry_realloc;
714   malloc_hooks.free = gcry_free;
715   assuan_set_malloc_hooks (&malloc_hooks);
716   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
717   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
718   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
719   assuan_sock_init ();
720   setup_libassuan_logging (&opt.debug);
721
722   setup_libgcrypt_logging ();
723
724   /* Setup defaults. */
725   shell = getenv ("SHELL");
726   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
727     csh_style = 1;
728
729   opt.homedir = default_homedir ();
730
731   /* Now with NPth running we can set the logging callback.  Our
732      windows implementation does not yet feature the NPth TLS
733      functions.  */
734 #ifndef HAVE_W32_SYSTEM
735   if (npth_key_create (&my_tlskey_current_fd, NULL) == 0)
736     if (npth_setspecific (my_tlskey_current_fd, NULL) == 0)
737       log_set_pid_suffix_cb (pid_suffix_callback);
738 #endif /*!HAVE_W32_SYSTEM*/
739
740   /* Reset rereadable options to default values. */
741   parse_rereadable_options (NULL, 0);
742
743   /* LDAP defaults.  */
744   opt.add_new_ldapservers = 0;
745   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
746
747   /* Other defaults.  */
748
749   /* Check whether we have a config file given on the commandline */
750   orig_argc = argc;
751   orig_argv = argv;
752   pargs.argc = &argc;
753   pargs.argv = &argv;
754   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
755   while (arg_parse( &pargs, opts))
756     {
757       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
758         parse_debug++;
759       else if (pargs.r_opt == oOptions)
760         { /* Yes there is one, so we do not try the default one, but
761              read the option file when it is encountered at the
762              commandline */
763           default_config = 0;
764         }
765       else if (pargs.r_opt == oNoOptions)
766         default_config = 0; /* --no-options */
767       else if (pargs.r_opt == oHomedir)
768         {
769           opt.homedir = pargs.r.ret_str;
770           homedir_seen = 1;
771         }
772       else if (pargs.r_opt == aDaemon)
773         opt.system_daemon = 1;
774       else if (pargs.r_opt == aService)
775         {
776           /* Redundant.  The main function takes care of it.  */
777           opt.system_service = 1;
778           opt.system_daemon = 1;
779         }
780 #ifdef HAVE_W32_SYSTEM
781       else if (pargs.r_opt == aGPGConfList || pargs.r_opt == aGPGConfTest)
782         /* We set this so we switch to the system configuration
783            directory below.  This is a crutch to solve the problem
784            that the user configuration is never used on Windows.  Also
785            see below at aGPGConfList.  */
786         opt.system_daemon = 1;
787 #endif
788     }
789
790   /* If --daemon has been given on the command line but not --homedir,
791      we switch to /etc/gnupg as default home directory.  Note, that
792      this also overrides the GNUPGHOME environment variable.  */
793   if (opt.system_daemon && !homedir_seen)
794     {
795 #ifdef HAVE_W32CE_SYSTEM
796       opt.homedir = DIRSEP_S "gnupg";
797 #else
798       opt.homedir = gnupg_sysconfdir ();
799 #endif
800       opt.homedir_data = gnupg_datadir ();
801       opt.homedir_cache = gnupg_cachedir ();
802       socket_name = dirmngr_sys_socket_name ();
803     }
804   else if (dirmngr_user_socket_name ())
805     socket_name = dirmngr_user_socket_name ();
806   else
807     socket_name = dirmngr_sys_socket_name ();
808
809   if (default_config)
810     configname = make_filename (opt.homedir, DIRMNGR_NAME".conf", NULL );
811
812   argc = orig_argc;
813   argv = orig_argv;
814   pargs.argc = &argc;
815   pargs.argv = &argv;
816   pargs.flags= 1;  /* do not remove the args */
817  next_pass:
818   if (configname)
819     {
820       configlineno = 0;
821       configfp = fopen (configname, "r");
822       if (!configfp)
823         {
824           if (default_config)
825             {
826               if( parse_debug )
827                 log_info (_("Note: no default option file '%s'\n"),
828                           configname );
829             }
830           else
831             {
832               log_error (_("option file '%s': %s\n"),
833                          configname, strerror(errno) );
834               exit(2);
835             }
836           xfree (configname);
837           configname = NULL;
838         }
839       if (parse_debug && configname )
840         log_info (_("reading options from '%s'\n"), configname );
841       default_config = 0;
842     }
843
844   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
845     {
846       if (parse_rereadable_options (&pargs, 0))
847         continue; /* Already handled */
848       switch (pargs.r_opt)
849         {
850         case aServer:
851         case aDaemon:
852         case aService:
853         case aShutdown:
854         case aFlush:
855         case aListCRLs:
856         case aLoadCRL:
857         case aFetchCRL:
858         case aGPGConfList:
859         case aGPGConfTest:
860           cmd = pargs.r_opt;
861           break;
862
863         case oQuiet: opt.quiet = 1; break;
864         case oVerbose: opt.verbose++; break;
865         case oBatch: opt.batch=1; break;
866
867         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
868         case oDebugAll: opt.debug = ~0; break;
869         case oDebugLevel: debug_level = pargs.r.ret_str; break;
870         case oDebugWait: debug_wait = pargs.r.ret_int; break;
871
872         case oOptions:
873           /* Config files may not be nested (silently ignore them) */
874           if (!configfp)
875             {
876                 xfree(configname);
877                 configname = xstrdup(pargs.r.ret_str);
878                 goto next_pass;
879             }
880           break;
881         case oNoGreeting: nogreeting = 1; break;
882         case oNoVerbose: opt.verbose = 0; break;
883         case oNoOptions: break; /* no-options */
884         case oHomedir: /* Ignore this option here. */; break;
885         case oNoDetach: nodetach = 1; break;
886         case oLogFile: logfile = pargs.r.ret_str; break;
887         case oCsh: csh_style = 1; break;
888         case oSh: csh_style = 0; break;
889         case oLDAPFile:
890 #        if USE_LDAP
891           ldapfile = pargs.r.ret_str;
892 #        endif /*USE_LDAP*/
893           break;
894         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
895         case oLDAPTimeout:
896           opt.ldaptimeout = pargs.r.ret_int;
897           break;
898
899         case oFakedSystemTime:
900           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
901           break;
902
903         case oForce: opt.force = 1; break;
904
905         case oSocketName: socket_name = pargs.r.ret_str; break;
906
907         default : pargs.err = configfp? 1:2; break;
908         }
909     }
910   if (configfp)
911     {
912       fclose (configfp);
913       configfp = NULL;
914       /* Keep a copy of the name so that it can be read on SIGHUP. */
915       opt.config_filename = configname;
916       configname = NULL;
917       goto next_pass;
918     }
919   xfree (configname);
920   configname = NULL;
921   if (log_get_errorcount(0))
922     exit(2);
923   if (nogreeting )
924     greeting = 0;
925
926   if (!opt.homedir_data)
927     opt.homedir_data = opt.homedir;
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 }