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