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