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