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