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