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