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