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