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