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