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