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