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