Change dirmngr timer under W32CE.
[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 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 <pth.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 (pth_key_getdata 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 /* Pth wrapper function definitions. */
281 ASSUAN_SYSTEM_PTH_IMPL;
282
283 GCRY_THREAD_OPTION_PTH_IMPL;
284 static int fixed_gcry_pth_init (void)
285 {
286   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
287 }
288
289 static const char *
290 my_strusage( int level )
291 {
292   const char *p;
293   switch ( level ) 
294     {
295     case 11: p = "dirmngr (GnuPG)";
296       break;
297     case 13: p = VERSION; break;
298     case 17: p = PRINTABLE_OS_NAME; break;
299       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
300          reporting address.  This is so that we can change the
301          reporting address without breaking the translations.  */
302     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
303     case 49: p = PACKAGE_BUGREPORT; break;
304     case 1:
305     case 40: p = _("Usage: dirmngr [options] (-h for help)");
306       break;
307     case 41: p = _("Syntax: dirmngr [options] [command [args]]\n"
308                    "LDAP and OCSP access for GnuPG\n");
309       break;
310       
311     default: p = NULL;
312     }
313   return p;
314 }
315
316
317 /* Callback from libksba to hash a provided buffer.  Our current
318    implementation does only allow SHA-1 for hashing. This may be
319    extended by mapping the name, testing for algorithm availibility
320    and adjust the length checks accordingly. */
321 static gpg_error_t 
322 my_ksba_hash_buffer (void *arg, const char *oid,
323                      const void *buffer, size_t length, size_t resultsize,
324                      unsigned char *result, size_t *resultlen)
325 {
326   (void)arg;
327
328   if (oid && strcmp (oid, "1.3.14.3.2.26")) 
329     return gpg_error (GPG_ERR_NOT_SUPPORTED); 
330   if (resultsize < 20)
331     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
332   gcry_md_hash_buffer (2, result, buffer, length); 
333   *resultlen = 20;
334   return 0;
335 }
336
337
338 /* Setup the debugging.  With a LEVEL of NULL only the active debug
339    flags are propagated to the subsystems.  With LEVEL set, a specific
340    set of debug flags is set; thus overriding all flags already
341    set. */
342 static void
343 set_debug (void)
344 {
345   int numok = (debug_level && digitp (debug_level));
346   int numlvl = numok? atoi (debug_level) : 0;
347
348   if (!debug_level)
349     ;
350   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
351     opt.debug = 0;
352   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
353     opt.debug = DBG_ASSUAN_VALUE;
354   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
355     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE);
356   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
357     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE|DBG_LOOKUP_VALUE
358                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
359   else if (!strcmp (debug_level, "guru") || numok)
360     {
361       opt.debug = ~0;
362       /* Unless the "guru" string has been used we don't want to allow
363          hashing debugging.  The rationale is that people tend to
364          select the highest debug value and would then clutter their
365          disk with debug files which may reveal confidential data.  */ 
366       if (numok)
367         opt.debug &= ~(DBG_HASHING_VALUE);
368     }
369   else
370     {
371       log_error (_("invalid debug-level `%s' given\n"), debug_level);
372       log_info (_("valid debug levels are: %s\n"),
373                 "none, basic, advanced, expert, guru");
374       opt.debug = 0; /* Reset debugging, so that prior debug
375                         statements won't have an undesired effect. */
376     }
377
378
379   if (opt.debug && !opt.verbose)
380     {
381       opt.verbose = 1;
382       gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
383     }
384   if (opt.debug && opt.quiet)
385     opt.quiet = 0;
386
387   if (opt.debug & DBG_CRYPTO_VALUE )
388     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
389 }
390  
391
392 static void
393 wrong_args (const char *text)
394 {
395   es_fputs (_("usage: dirmngr [options] "), es_stderr);
396   es_fputs (text, es_stderr);
397   es_putc ('\n', es_stderr);
398   dirmngr_exit (2);
399 }
400
401
402 /* Helper to stop the reaper thread for the ldap wrapper.  */
403 static void
404 shutdown_reaper (void)
405 {
406   ldap_wrapper_wait_connections ();
407 }
408
409
410 /* Handle options which are allowed to be reset after program start.
411    Return true if the current option in PARGS could be handled and
412    false if not.  As a special feature, passing a value of NULL for
413    PARGS, resets the options to the default.  REREAD should be set
414    true if it is not the initial option parsing. */
415 static int
416 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
417 {
418   if (!pargs)
419     { /* Reset mode. */
420       opt.quiet = 0;
421       opt.verbose = 0;
422       opt.debug = 0;
423       opt.ldap_wrapper_program = NULL;
424       opt.disable_http = 0;
425       opt.disable_ldap = 0; 
426       opt.honor_http_proxy = 0; 
427       opt.http_proxy = NULL; 
428       opt.ldap_proxy = NULL; 
429       opt.only_ldap_proxy = 0;
430       opt.ignore_http_dp = 0;
431       opt.ignore_ldap_dp = 0;
432       opt.ignore_ocsp_service_url = 0;
433       opt.allow_ocsp = 0;
434       opt.ocsp_responder = NULL;
435       opt.ocsp_max_clock_skew = 10 * 60;      /* 10 minutes.  */
436       opt.ocsp_max_period = 90 * 86400;       /* 90 days.  */
437       opt.ocsp_current_period = 3 * 60 * 60;  /* 3 hours. */
438       opt.max_replies = DEFAULT_MAX_REPLIES;
439       while (opt.ocsp_signer)
440         {
441           fingerprint_list_t tmp = opt.ocsp_signer->next;
442           xfree (opt.ocsp_signer);
443           opt.ocsp_signer = tmp;
444         }
445       FREE_STRLIST (opt.ignored_cert_extensions);
446       return 1;
447     }
448
449   switch (pargs->r_opt)
450     {
451     case oQuiet:   opt.quiet = 1; break;
452     case oVerbose: opt.verbose++; break;
453     case oDebug:   opt.debug |= pargs->r.ret_ulong; break;
454     case oDebugAll: opt.debug = ~0; break;
455     case oDebugLevel: debug_level = pargs->r.ret_str; break;
456
457     case oLogFile:
458       if (!reread)
459         return 0; /* Not handled. */
460       if (!current_logfile || !pargs->r.ret_str
461           || strcmp (current_logfile, pargs->r.ret_str))
462         {
463           log_set_file (pargs->r.ret_str);
464           xfree (current_logfile);
465           current_logfile = xtrystrdup (pargs->r.ret_str);
466         }
467       break;
468
469     case oLDAPWrapperProgram:
470       opt.ldap_wrapper_program = pargs->r.ret_str;
471       break;
472     case oHTTPWrapperProgram:
473       opt.http_wrapper_program = pargs->r.ret_str;
474       break;
475
476     case oDisableHTTP: opt.disable_http = 1; break;
477     case oDisableLDAP: opt.disable_ldap = 1; break;
478     case oHonorHTTPProxy: opt.honor_http_proxy = 1; break;
479     case oHTTPProxy: opt.http_proxy = pargs->r.ret_str; break;
480     case oLDAPProxy: opt.ldap_proxy = pargs->r.ret_str; break;
481     case oOnlyLDAPProxy: opt.only_ldap_proxy = 1; break;
482     case oIgnoreHTTPDP: opt.ignore_http_dp = 1; break;
483     case oIgnoreLDAPDP: opt.ignore_ldap_dp = 1; break;
484     case oIgnoreOCSPSvcUrl: opt.ignore_ocsp_service_url = 1; break;
485
486     case oAllowOCSP: opt.allow_ocsp = 1; break;
487     case oOCSPResponder: opt.ocsp_responder = pargs->r.ret_str; break;
488     case oOCSPSigner: 
489       opt.ocsp_signer = parse_ocsp_signer (pargs->r.ret_str);
490       break;
491     case oOCSPMaxClockSkew: opt.ocsp_max_clock_skew = pargs->r.ret_int; break;
492     case oOCSPMaxPeriod: opt.ocsp_max_period = pargs->r.ret_int; break;
493     case oOCSPCurrentPeriod: opt.ocsp_current_period = pargs->r.ret_int; break;
494
495     case oMaxReplies: opt.max_replies = pargs->r.ret_int; break;
496
497     case oIgnoreCertExtension:
498       add_to_strlist (&opt.ignored_cert_extensions, pargs->r.ret_str);
499       break;
500
501     default:
502       return 0; /* Not handled. */
503     }
504
505   return 1; /* Handled. */
506 }
507
508
509 #ifdef USE_W32_SERVICE
510 /* The global status of our service.  */
511 SERVICE_STATUS_HANDLE service_handle;
512 SERVICE_STATUS service_status;
513
514 DWORD WINAPI
515 w32_service_control (DWORD control, DWORD event_type, LPVOID event_data,
516                      LPVOID 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 = pth_key_getdata (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", 1|4); 
609
610   /* Make sure that our subsystems are ready.  */
611   i18n_init ();
612   init_common_subsystems (&argc, &argv);
613
614   /* Libgcrypt requires us to register the threading model first.
615      Note that this will also do the pth_init.  */
616   gcry_threads_pth.init = fixed_gcry_pth_init;
617   rc = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
618   if (rc)
619     {
620       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
621                  gpg_strerror (rc));
622     }
623   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
624  
625  /* Check that the libraries are suitable.  Do it here because
626     the option parsing may need services of the libraries. */
627
628   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
629     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
630                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
631   if (!ksba_check_version (NEED_KSBA_VERSION) )
632     log_fatal( _("%s is too old (need %s, have %s)\n"), "libksba",
633                NEED_KSBA_VERSION, ksba_check_version (NULL) );
634
635   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
636   ksba_set_hash_buffer_function (my_ksba_hash_buffer, NULL);
637
638
639   /* Init Assuan. */
640   malloc_hooks.malloc = gcry_malloc;
641   malloc_hooks.realloc = gcry_realloc;
642   malloc_hooks.free = gcry_free;
643   assuan_set_malloc_hooks (&malloc_hooks);
644   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
645   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
646   assuan_set_system_hooks (ASSUAN_SYSTEM_PTH);
647   assuan_sock_init ();
648   setup_libassuan_logging (&opt.debug);
649
650   setup_libgcrypt_logging ();
651
652   /* Setup defaults. */
653   shell = getenv ("SHELL");
654   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
655     csh_style = 1;
656
657   opt.homedir = default_homedir ();
658
659   /* Now with Pth running we can set the logging callback.  Our
660      windows implementation does not yet feature the Pth TLS
661      functions.  */
662 #ifndef HAVE_W32_SYSTEM
663   if (pth_key_create (&my_tlskey_current_fd, NULL))
664     if (pth_key_setdata (my_tlskey_current_fd, NULL))
665       log_set_pid_suffix_cb (pid_suffix_callback);
666 #endif /*!HAVE_W32_SYSTEM*/
667   
668   /* Reset rereadable options to default values. */
669   parse_rereadable_options (NULL, 0); 
670
671   /* LDAP defaults.  */
672   opt.add_new_ldapservers = 0;
673   opt.ldaptimeout = DEFAULT_LDAP_TIMEOUT;
674
675   /* Other defaults.  */
676   socket_name = dirmngr_socket_name ();
677
678   /* Check whether we have a config file given on the commandline */
679   orig_argc = argc;
680   orig_argv = argv;
681   pargs.argc = &argc;
682   pargs.argv = &argv;
683   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
684   while (arg_parse( &pargs, opts))
685     {
686       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
687         parse_debug++;
688       else if (pargs.r_opt == oOptions)
689         { /* Yes there is one, so we do not try the default one, but
690              read the option file when it is encountered at the
691              commandline */
692           default_config = 0;
693         }
694       else if (pargs.r_opt == oNoOptions)
695         default_config = 0; /* --no-options */
696       else if (pargs.r_opt == oHomedir)
697         {
698           opt.homedir = pargs.r.ret_str;
699           homedir_seen = 1;
700         }
701       else if (pargs.r_opt == aDaemon)
702         opt.system_daemon = 1;
703       else if (pargs.r_opt == aService)
704         {
705           /* Redundant.  The main function takes care of it.  */
706           opt.system_service = 1;
707           opt.system_daemon = 1;
708         }
709 #ifdef HAVE_W32_SYSTEM
710       else if (pargs.r_opt == aGPGConfList || pargs.r_opt == aGPGConfTest)
711         /* We set this so we switch to the system configuration
712            directory below.  This is a crutch to solve the problem
713            that the user configuration is never used on Windows.  Also
714            see below at aGPGConfList.  */
715         opt.system_daemon = 1;
716 #endif
717     }
718
719   /* If --daemon has been given on the command line but not --homedir,
720      we switch to /etc/dirmngr as default home directory.  Note, that
721      this also overrides the GNUPGHOME environment variable.  */
722   if (opt.system_daemon && !homedir_seen)
723     {
724       opt.homedir = gnupg_sysconfdir ();
725       opt.homedir_data = gnupg_datadir ();
726       opt.homedir_cache = gnupg_cachedir ();
727     }
728
729   if (default_config)
730     configname = make_filename (opt.homedir, "dirmngr.conf", NULL );
731   
732   argc = orig_argc;
733   argv = orig_argv;
734   pargs.argc = &argc;
735   pargs.argv = &argv;
736   pargs.flags= 1;  /* do not remove the args */
737  next_pass:
738   if (configname)
739     {
740       configlineno = 0;
741       configfp = fopen (configname, "r");
742       if (!configfp)
743         {
744           if (default_config)
745             {
746               if( parse_debug )
747                 log_info (_("NOTE: no default option file `%s'\n"),
748                           configname );
749             }
750           else
751             {
752               log_error (_("option file `%s': %s\n"),
753                          configname, strerror(errno) );
754               exit(2);
755             }
756           xfree (configname); 
757           configname = NULL;
758         }
759       if (parse_debug && configname )
760         log_info (_("reading options from `%s'\n"), configname );
761       default_config = 0;
762     }
763
764   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
765     {
766       if (parse_rereadable_options (&pargs, 0))
767         continue; /* Already handled */
768       switch (pargs.r_opt)
769         {
770         case aServer: 
771         case aDaemon:
772         case aService:
773         case aShutdown: 
774         case aFlush: 
775         case aListCRLs: 
776         case aLoadCRL: 
777         case aFetchCRL:
778         case aGPGConfList:
779         case aGPGConfTest:
780           cmd = pargs.r_opt;
781           break;
782
783         case oQuiet: opt.quiet = 1; break;
784         case oVerbose: opt.verbose++; break;
785         case oBatch: opt.batch=1; break;
786
787         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
788         case oDebugAll: opt.debug = ~0; break;
789         case oDebugLevel: debug_level = pargs.r.ret_str; break;
790         case oDebugWait: debug_wait = pargs.r.ret_int; break;
791
792         case oOptions:
793           /* Config files may not be nested (silently ignore them) */
794           if (!configfp)
795             {
796                 xfree(configname);
797                 configname = xstrdup(pargs.r.ret_str);
798                 goto next_pass;
799             }
800           break;
801         case oNoGreeting: nogreeting = 1; break;
802         case oNoVerbose: opt.verbose = 0; break;
803         case oNoOptions: break; /* no-options */
804         case oHomedir: /* Ignore this option here. */; break;
805         case oNoDetach: nodetach = 1; break;
806         case oLogFile: logfile = pargs.r.ret_str; break;
807         case oCsh: csh_style = 1; break;
808         case oSh: csh_style = 0; break;
809         case oLDAPFile: ldapfile = pargs.r.ret_str; break;
810         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
811         case oLDAPTimeout: 
812           opt.ldaptimeout = pargs.r.ret_int; 
813           break;
814
815         case oFakedSystemTime:
816           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
817           break;
818
819         case oForce: opt.force = 1; break;
820
821         case oSocketName: socket_name = pargs.r.ret_str; break;
822
823         default : pargs.err = configfp? 1:2; break;
824         }
825     }
826   if (configfp)
827     {
828       fclose (configfp);
829       configfp = NULL;
830       /* Keep a copy of the name so that it can be read on SIGHUP. */
831       opt.config_filename = configname;
832       configname = NULL;
833       goto next_pass;
834     }
835   xfree (configname);
836   configname = NULL;
837   if (log_get_errorcount(0))
838     exit(2);
839   if (nogreeting )
840     greeting = 0;
841
842   if (!opt.homedir_data)
843     opt.homedir_data = opt.homedir;
844   if (!opt.homedir_cache)
845     opt.homedir_cache = opt.homedir;
846
847   if (greeting)
848     {
849       es_fprintf (es_stderr, "%s %s; %s\n",
850                   strusage(11), strusage(13), strusage(14) );
851       es_fprintf (es_stderr, "%s\n", strusage(15) );
852     }
853
854 #ifdef IS_DEVELOPMENT_VERSION
855   log_info ("NOTE: this is a development version!\n");
856 #endif
857
858   if (!access ("/etc/dirmngr", F_OK) && !strncmp (opt.homedir, "/etc/", 5))
859     log_info 
860       ("NOTE: DirMngr is now a proper part of GnuPG.  The configuration and"
861        " other directory names changed.  Please check that no other version"
862        " of dirmngr is still installed.  To disable this warning, remove the"
863        " directory `/etc/dirmngr'.\n");
864   
865   if (gnupg_faked_time_p ())
866     {
867       gnupg_isotime_t tbuf;
868
869       log_info (_("WARNING: running with faked system time: "));
870       gnupg_get_isotime (tbuf);
871       dump_isotime (tbuf);
872       log_printf ("\n");
873     }
874
875   set_debug ();
876
877   /* Get LDAP server list from file. */
878   if (!ldapfile) 
879     {
880       ldapfile = make_filename (opt.homedir,
881                                 opt.system_daemon?
882                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
883                                 NULL);
884       opt.ldapservers = parse_ldapserver_file (ldapfile);
885       xfree (ldapfile);
886     }
887   else
888       opt.ldapservers = parse_ldapserver_file (ldapfile);
889
890 #ifndef HAVE_W32_SYSTEM
891   /* We need to ignore the PIPE signal because the we might log to a
892      socket and that code handles EPIPE properly.  The ldap wrapper
893      also requires us to ignore this silly signal. Assuan would set
894      this signal to ignore anyway.*/
895   signal (SIGPIPE, SIG_IGN);
896 #endif
897
898   /* Ready.  Now to our duties. */
899   if (!cmd && opt.system_service)
900     cmd = aDaemon;
901   else if (!cmd)
902     cmd = aServer;
903   rc = 0;
904
905   if (cmd == aServer)
906     {
907       /* Note that this server mode is maily useful for debugging.  */
908       if (argc)
909         wrong_args ("--server");
910
911       if (logfile)
912         {
913           log_set_file (logfile);
914           log_set_prefix (NULL, 2|4);
915         }
916        
917       if (debug_wait)
918         {
919           log_debug ("waiting for debugger - my pid is %u .....\n",
920                      (unsigned int)getpid());
921           gnupg_sleep (debug_wait);
922           log_debug ("... okay\n");
923         }
924
925       ldap_wrapper_launch_thread ();
926       cert_cache_init ();
927       crl_cache_init ();
928       start_command_handler (ASSUAN_INVALID_FD);
929       shutdown_reaper ();
930     }
931   else if (cmd == aDaemon)
932     {
933       assuan_fd_t fd;
934       pid_t pid;
935       int len;
936       struct sockaddr_un serv_addr;
937
938       if (argc)
939         wrong_args ("--daemon");
940       
941       /* Now start with logging to a file if this is desired. */
942       if (logfile)
943         {
944           log_set_file (logfile);
945           log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
946                                  |JNLIB_LOG_WITH_TIME
947                                  |JNLIB_LOG_WITH_PID));
948           current_logfile = xstrdup (logfile);
949         }
950
951 #ifndef HAVE_W32_SYSTEM
952       if (strchr (socket_name, ':'))
953         {
954           log_error (_("colons are not allowed in the socket name\n"));
955           dirmngr_exit (1);
956         }
957 #endif
958       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
959         {
960           log_error (_("name of socket too long\n"));
961           dirmngr_exit (1);
962         }
963     
964       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
965       if (fd == ASSUAN_INVALID_FD)
966         {
967           log_error (_("can't create socket: %s\n"), strerror (errno));
968           cleanup ();
969           dirmngr_exit (1);
970         }
971
972       memset (&serv_addr, 0, sizeof serv_addr);
973       serv_addr.sun_family = AF_UNIX;
974       strcpy (serv_addr.sun_path, socket_name);
975       len = SUN_LEN (&serv_addr);
976
977       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
978       if (rc == -1 
979           && (errno == EADDRINUSE
980 #ifdef HAVE_W32_SYSTEM
981               || errno == EEXIST
982 #endif
983               ))
984         {
985           /* Fixme: We should test whether a dirmngr is already running. */
986           gnupg_remove (socket_name);
987           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
988         }
989       if (rc != -1 
990           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
991         log_error (_("error getting nonce for the socket\n"));
992       if (rc == -1)
993         {
994           log_error (_("error binding socket to `%s': %s\n"),
995                      serv_addr.sun_path, gpg_strerror (gpg_error_from_errno (errno)));
996           assuan_sock_close (fd);
997           dirmngr_exit (1);
998         }
999       cleanup_socket = 1;
1000   
1001       if (listen (FD2INT (fd), 5) == -1)
1002         {
1003           log_error (_("listen() failed: %s\n"), strerror (errno));
1004           assuan_sock_close (fd);
1005           dirmngr_exit (1);
1006         }
1007
1008       if (opt.verbose)
1009         log_info (_("listening on socket `%s'\n"), socket_name );
1010
1011       es_fflush (NULL);
1012
1013       /* Note: We keep the dirmngr_info output only for the sake of
1014          existing scripts which might use this to detect a successful
1015          start of the dirmngr.  */
1016 #ifdef HAVE_W32_SYSTEM
1017       pid = getpid ();
1018       printf ("set DIRMNGR_INFO=%s;%lu;1\n", socket_name, (ulong) pid);
1019 #else
1020       pid = pth_fork ();
1021       if (pid == (pid_t)-1) 
1022         {
1023           log_fatal (_("error forking process: %s\n"), strerror (errno));
1024           dirmngr_exit (1);
1025         }
1026
1027       if (pid) 
1028         { /* We are the parent */
1029           char *infostr;
1030           
1031           /* Don't let cleanup() remove the socket - the child is
1032              responsible for doing that.  */
1033           cleanup_socket = 0;
1034
1035           close (fd);
1036           
1037           /* Create the info string: <name>:<pid>:<protocol_version> */
1038           if (asprintf (&infostr, "DIRMNGR_INFO=%s:%lu:1",
1039                         socket_name, (ulong)pid ) < 0)
1040             {
1041               log_error (_("out of core\n"));
1042               kill (pid, SIGTERM);
1043               dirmngr_exit (1);
1044             }
1045           /* Print the environment string, so that the caller can use
1046              shell's eval to set it.  But see above.  */
1047           if (csh_style)
1048             {
1049               *strchr (infostr, '=') = ' ';
1050               printf ( "setenv %s\n", infostr);
1051             }
1052           else
1053             {
1054               printf ( "%s; export DIRMNGR_INFO;\n", infostr);
1055             }
1056           free (infostr);
1057           exit (0); 
1058           /*NEVER REACHED*/
1059         } /* end parent */
1060       
1061       
1062       /* 
1063          This is the child
1064        */
1065
1066       /* Detach from tty and put process into a new session */
1067       if (!nodetach )
1068         { 
1069           int i;
1070           unsigned int oldflags;
1071
1072           /* Close stdin, stdout and stderr unless it is the log stream */
1073           for (i=0; i <= 2; i++)
1074             {
1075               if (!log_test_fd (i) && i != fd )
1076                 close (i);
1077             }
1078           if (setsid() == -1)
1079             {
1080               log_error ("setsid() failed: %s\n", strerror(errno) );
1081               dirmngr_exit (1);
1082             }
1083
1084           log_get_prefix (&oldflags);
1085           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1086           opt.running_detached = 1;
1087
1088           if (chdir("/"))
1089             {
1090               log_error ("chdir to / failed: %s\n", strerror (errno));
1091               dirmngr_exit (1);
1092             }
1093         }
1094 #endif
1095
1096       ldap_wrapper_launch_thread ();
1097       cert_cache_init ();
1098       crl_cache_init ();
1099 #ifdef USE_W32_SERVICE
1100       if (opt.system_service)
1101         {
1102           service_status.dwCurrentState = SERVICE_RUNNING;
1103           SetServiceStatus (service_handle, &service_status);
1104         }
1105 #endif
1106       handle_connections (fd);
1107       assuan_sock_close (fd);
1108       shutdown_reaper ();
1109 #ifdef USE_W32_SERVICE
1110       if (opt.system_service)
1111         {
1112           service_status.dwCurrentState = SERVICE_STOPPED;
1113           SetServiceStatus (service_handle, &service_status);
1114         }
1115 #endif
1116     }
1117   else if (cmd == aListCRLs)
1118     {
1119       /* Just list the CRL cache and exit. */
1120       if (argc)
1121         wrong_args ("--list-crls");
1122       ldap_wrapper_launch_thread ();
1123       crl_cache_init ();
1124       crl_cache_list (es_stdout);
1125     }
1126   else if (cmd == aLoadCRL)
1127     {
1128       struct server_control_s ctrlbuf;
1129
1130       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1131       dirmngr_init_default_ctrl (&ctrlbuf);
1132
1133       ldap_wrapper_launch_thread ();
1134       cert_cache_init ();
1135       crl_cache_init ();
1136       if (!argc)
1137         rc = crl_cache_load (&ctrlbuf, NULL);
1138       else
1139         {
1140           for (; !rc && argc; argc--, argv++)
1141             rc = crl_cache_load (&ctrlbuf, *argv);
1142         }
1143     }
1144   else if (cmd == aFetchCRL)
1145     {
1146       ksba_reader_t reader;
1147       struct server_control_s ctrlbuf;
1148
1149       if (argc != 1)
1150         wrong_args ("--fetch-crl URL");
1151
1152       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1153       dirmngr_init_default_ctrl (&ctrlbuf);
1154
1155       ldap_wrapper_launch_thread ();
1156       cert_cache_init ();
1157       crl_cache_init ();
1158       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1159       if (rc)
1160         log_error (_("fetching CRL from `%s' failed: %s\n"),
1161                      argv[0], gpg_strerror (rc));
1162       else
1163         {
1164           rc = crl_cache_insert (&ctrlbuf, argv[0], reader); 
1165           if (rc)
1166             log_error (_("processing CRL from `%s' failed: %s\n"),
1167                        argv[0], gpg_strerror (rc));
1168           crl_close_reader (reader);
1169         }
1170     }
1171   else if (cmd == aFlush)
1172     {
1173       /* Delete cache and exit. */
1174       if (argc)
1175         wrong_args ("--flush");
1176       rc = crl_cache_flush();
1177     }
1178   else if (cmd == aGPGConfTest)
1179     dirmngr_exit (0);
1180   else if (cmd == aGPGConfList)
1181     {
1182       unsigned long flags = 0;
1183       char *filename;
1184       char *filename_esc;
1185
1186       /* List options and default values in the GPG Conf format.  */
1187
1188 /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1189 /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1190    FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1191 #define GC_OPT_FLAG_NONE        0UL
1192 /* The DEFAULT flag for an option indicates that the option has a
1193    default value.  */
1194 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1195 /* The DEF_DESC flag for an option indicates that the option has a
1196    default, which is described by the value of the default field.  */
1197 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1198 /* The NO_ARG_DESC flag for an option indicates that the argument has
1199    a default, which is described by the value of the ARGDEF field.  */
1200 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1201 #define GC_OPT_FLAG_NO_CHANGE   (1UL <<7)
1202
1203 #ifdef HAVE_W32_SYSTEM
1204       /* On Windows systems, dirmngr always runs as system daemon, and
1205          the per-user configuration is never used.  So we short-cut
1206          everything to use the global system configuration of dirmngr
1207          above, and here we set the no change flag to make these
1208          read-only.  */
1209       flags |= GC_OPT_FLAG_NO_CHANGE;
1210 #endif
1211
1212       /* First the configuration file.  This is not an option, but it
1213          is vital information for GPG Conf.  */
1214       if (!opt.config_filename)
1215         opt.config_filename = make_filename (opt.homedir,
1216                                              "dirmngr.conf", NULL );
1217
1218       filename = percent_escape (opt.config_filename, NULL);
1219       printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1220               GC_OPT_FLAG_DEFAULT, filename);
1221       xfree (filename);
1222
1223       printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1224       printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1225       printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1226       printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1227       printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1228
1229       /* --csh and --sh are mutually exclusive, something we can not
1230          express in GPG Conf.  --options is only usable from the
1231          command line, really.  --debug-all interacts with --debug,
1232          and having both of them is thus problematic.  --no-detach is
1233          also only usable on the command line.  --batch is unused.  */
1234
1235       filename = make_filename (opt.homedir, 
1236                                 opt.system_daemon?
1237                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
1238                                 NULL);
1239       filename_esc = percent_escape (filename, NULL);
1240       printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1241               filename_esc);
1242       xfree (filename_esc);
1243       xfree (filename);
1244
1245       printf ("ldaptimeout:%lu:%u\n",
1246               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1247       printf ("max-replies:%lu:%u\n",
1248               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1249       printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1250       printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1251       printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1252
1253       printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1254       printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1255
1256       printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1257       printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1258       printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1259       printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1260       printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1261       printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1262       printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1263       printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1264       printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1265       /* Note: The next one is to fix a typo in gpgconf - should be
1266          removed eventually. */
1267       printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1268     }
1269   cleanup ();
1270   return !!rc;
1271 }
1272
1273
1274 #ifdef USE_W32_SERVICE
1275 int
1276 main (int argc, char *argv[])
1277 {
1278   int i;
1279
1280   /* Find out if we run in daemon mode or on the command line.  */
1281   for (i = 1; i < argc; i++)
1282     if (!strcmp (argv[i], "--service"))
1283       {
1284         opt.system_service = 1;
1285         opt.system_daemon = 1;
1286         break;
1287       }
1288
1289   if (!opt.system_service)
1290     return real_main (argc, argv);
1291   else
1292     {
1293       SERVICE_TABLE_ENTRY DispatchTable [] =
1294         {
1295           /* Ignore warning.  */
1296           { "DirMngr", &real_main },
1297           { NULL, NULL }
1298         };
1299
1300       if (!StartServiceCtrlDispatcher (DispatchTable))
1301         return 1;
1302       return 0;
1303     }
1304 }
1305 #endif /*USE_W32_SERVICE*/
1306
1307
1308 static void
1309 cleanup (void)
1310 {
1311   crl_cache_deinit ();
1312   cert_cache_deinit (1);
1313
1314   ldapserver_list_free (opt.ldapservers);
1315   opt.ldapservers = NULL;
1316
1317   if (cleanup_socket)
1318     {
1319       cleanup_socket = 0;
1320       if (socket_name && *socket_name)
1321         gnupg_remove (socket_name);
1322     }
1323 }
1324
1325
1326 void 
1327 dirmngr_exit (int rc)
1328 {
1329   cleanup ();
1330   exit (rc);
1331 }
1332
1333
1334 void
1335 dirmngr_init_default_ctrl (ctrl_t ctrl)
1336 {
1337   (void)ctrl;
1338
1339   /* Nothing for now. */
1340 }
1341
1342
1343 /* Create a list of LDAP servers from the file FILENAME. Returns the
1344    list or NULL in case of errors. 
1345
1346    The format fo such a file is line oriented where empty lines and
1347    lines starting with a hash mark are ignored.  All other lines are
1348    assumed to be colon seprated with these fields:
1349
1350    1. field: Hostname
1351    2. field: Portnumber
1352    3. field: Username 
1353    4. field: Password
1354    5. field: Base DN
1355
1356 */
1357 static ldap_server_t
1358 parse_ldapserver_file (const char* filename)
1359 {
1360   char buffer[1024];
1361   char *p;
1362   ldap_server_t server, serverstart, *serverend;
1363   int c;
1364   unsigned int lineno = 0;
1365   estream_t fp;
1366
1367   fp = es_fopen (filename, "r");
1368   if (!fp)
1369     {
1370       log_error (_("error opening `%s': %s\n"), filename, strerror (errno));
1371       return NULL;
1372     }
1373
1374   serverstart = NULL;
1375   serverend = &serverstart;
1376   while (es_fgets (buffer, sizeof buffer, fp))
1377     {
1378       lineno++;
1379       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1380         {
1381           if (*buffer && es_feof (fp))
1382             ; /* Last line not terminated - continue. */
1383           else
1384             {
1385               log_error (_("%s:%u: line too long - skipped\n"),
1386                          filename, lineno);
1387               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1388                 ; /* Skip until end of line. */
1389               continue;
1390             }
1391         }
1392       /* Skip empty and comment lines.*/
1393       for (p=buffer; spacep (p); p++)
1394         ;
1395       if (!*p || *p == '\n' || *p == '#')
1396         continue;
1397
1398       /* Parse the colon separated fields. */
1399       server = ldapserver_parse_one (buffer, filename, lineno);
1400       if (server)
1401         {
1402           *serverend = server;
1403           serverend = &server->next;
1404         }
1405     } 
1406   
1407   if (es_ferror (fp))
1408     log_error (_("error reading `%s': %s\n"), filename, strerror (errno));
1409   es_fclose (fp);
1410
1411   return serverstart;
1412 }
1413
1414
1415 static fingerprint_list_t
1416 parse_ocsp_signer (const char *string)
1417 {
1418   gpg_error_t err;
1419   char *fname;
1420   estream_t fp;
1421   char line[256];
1422   char *p;
1423   fingerprint_list_t list, *list_tail, item;
1424   unsigned int lnr = 0;
1425   int c, i, j;
1426   int errflag = 0;
1427
1428
1429   /* Check whether this is not a filename and treat it as a direct
1430      fingerprint specification.  */
1431   if (!strpbrk (string, "/.~\\"))
1432     {
1433       item = xcalloc (1, sizeof *item);
1434       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1435         if ( string[i] != ':' )
1436           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1437       item->hexfpr[j] = 0;
1438       if (j != 40 || !(spacep (string+i) || !string[i]))
1439         {
1440           log_error (_("%s:%u: invalid fingerprint detected\n"), 
1441                      "--ocsp-signer", 0);
1442           xfree (item);
1443           return NULL;
1444         }
1445       return item;
1446     }
1447   
1448   /* Well, it is a filename.  */
1449   if (*string == '/' || (*string == '~' && string[1] == '/'))
1450     fname = make_filename (string, NULL);
1451   else
1452     {
1453       if (string[0] == '.' && string[1] == '/' )
1454         string += 2;
1455       fname = make_filename (opt.homedir, string, NULL);
1456     }
1457
1458   fp = es_fopen (fname, "r");
1459   if (!fp)
1460     {
1461       err = gpg_error_from_syserror ();
1462       log_error (_("can't open `%s': %s\n"), fname, gpg_strerror (err));
1463       xfree (fname);
1464       return NULL;
1465     }
1466
1467   list = NULL;
1468   list_tail = &list;
1469   for (;;)
1470     {
1471       if (!es_fgets (line, DIM(line)-1, fp) )
1472         {
1473           if (!es_feof (fp))
1474             {
1475               err = gpg_error_from_syserror ();
1476               log_error (_("%s:%u: read error: %s\n"),
1477                          fname, lnr, gpg_strerror (err));
1478               errflag = 1;
1479             }
1480           es_fclose (fp);
1481           if (errflag)
1482             {
1483               while (list)
1484                 {
1485                   fingerprint_list_t tmp = list->next;
1486                   xfree (list);
1487                   list = tmp;
1488                 }
1489             }
1490           xfree (fname);
1491           return list; /* Ready.  */
1492         }
1493
1494       lnr++;
1495       if (!*line || line[strlen(line)-1] != '\n')
1496         {
1497           /* Eat until end of line. */
1498           while ( (c=es_getc (fp)) != EOF && c != '\n')
1499             ;
1500           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1501                            /* */: GPG_ERR_INCOMPLETE_LINE);
1502           log_error (_("%s:%u: read error: %s\n"), 
1503                      fname, lnr, gpg_strerror (err));
1504           errflag = 1;
1505           continue;
1506         }
1507
1508       /* Allow for empty lines and spaces */
1509       for (p=line; spacep (p); p++)
1510         ;
1511       if (!*p || *p == '\n' || *p == '#')
1512         continue;
1513
1514       item = xcalloc (1, sizeof *item);
1515       *list_tail = item;
1516       list_tail = &item->next;
1517
1518       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1519         if ( p[i] != ':' )
1520           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1521       item->hexfpr[j] = 0;
1522       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1523         {
1524           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1525           errflag = 1;
1526         }
1527       i++;
1528       while (spacep (p+i))
1529         i++;
1530       if (p[i] && p[i] != '\n')
1531         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1532     }
1533   /*NOTREACHED*/
1534 }
1535
1536
1537
1538 \f
1539 /*
1540    Stuff used in daemon mode.  
1541  */
1542
1543
1544
1545 /* Reread parts of the configuration.  Note, that this function is
1546    obviously not thread-safe and should only be called from the PTH
1547    signal handler. 
1548
1549    Fixme: Due to the way the argument parsing works, we create a
1550    memory leak here for all string type arguments.  There is currently
1551    no clean way to tell whether the memory for the argument has been
1552    allocated or points into the process' original arguments.  Unless
1553    we have a mechanism to tell this, we need to live on with this. */
1554 static void
1555 reread_configuration (void)
1556 {
1557   ARGPARSE_ARGS pargs;
1558   FILE *fp;
1559   unsigned int configlineno = 0;
1560   int dummy;
1561
1562   if (!opt.config_filename)
1563     return; /* No config file. */
1564
1565   fp = fopen (opt.config_filename, "r");
1566   if (!fp)
1567     {
1568       log_error (_("option file `%s': %s\n"),
1569                  opt.config_filename, strerror(errno) );
1570       return;
1571     }
1572
1573   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1574
1575   memset (&pargs, 0, sizeof pargs);
1576   dummy = 0;
1577   pargs.argc = &dummy;
1578   pargs.flags = 1;  /* do not remove the args */
1579   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1580     {
1581       if (pargs.r_opt < -1)
1582         pargs.err = 1; /* Print a warning. */
1583       else /* Try to parse this option - ignore unchangeable ones. */
1584         parse_rereadable_options (&pargs, 1);
1585     }
1586   fclose (fp);
1587
1588   set_debug ();
1589 }
1590
1591
1592 /* A global function which allows us to trigger the reload stuff from
1593    other places.  */
1594 void
1595 dirmngr_sighup_action (void)
1596 {
1597   log_info (_("SIGHUP received - "
1598               "re-reading configuration and flushing caches\n"));
1599   reread_configuration ();
1600   cert_cache_deinit (0);
1601   crl_cache_deinit ();
1602   cert_cache_init ();
1603   crl_cache_init ();
1604 }
1605
1606
1607
1608 /* The signal handler. */
1609 static void
1610 handle_signal (int signo)
1611 {
1612   switch (signo)
1613     {
1614 #ifndef HAVE_W32_SYSTEM
1615     case SIGHUP:
1616       dirmngr_sighup_action ();
1617       break;
1618       
1619     case SIGUSR1:
1620       cert_cache_print_stats ();
1621       break;
1622       
1623     case SIGUSR2:
1624       log_info (_("SIGUSR2 received - no action defined\n"));
1625       break;
1626
1627     case SIGTERM:
1628       if (!shutdown_pending)
1629         log_info (_("SIGTERM received - shutting down ...\n"));
1630       else
1631         log_info (_("SIGTERM received - still %d active connections\n"),
1632                   active_connections);
1633       shutdown_pending++;
1634       if (shutdown_pending > 2)
1635         {
1636           log_info (_("shutdown forced\n"));
1637           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1638           cleanup ();
1639           dirmngr_exit (0);
1640         }
1641       break;
1642         
1643     case SIGINT:
1644       log_info (_("SIGINT received - immediate shutdown\n"));
1645       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1646       cleanup ();
1647       dirmngr_exit (0);
1648       break;
1649 #endif
1650     default:
1651       log_info (_("signal %d received - no action defined\n"), signo);
1652     }
1653 }
1654
1655
1656 /* This is the worker for the ticker.  It is called every few seconds
1657    and may only do fast operations. */
1658 static void
1659 handle_tick (void)
1660 {
1661   /* Nothing real to do right now.  Actually we need the timeout only
1662      for W32 where we don't use signals and need a way for the loop to
1663      check for the shutdown flag. */
1664 #ifdef HAVE_W32_SYSTEM
1665   if (shutdown_pending)
1666     log_info (_("SIGTERM received - shutting down ...\n"));
1667   if (shutdown_pending > 2)
1668     {
1669       log_info (_("shutdown forced\n"));
1670       log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1671       cleanup ();
1672       dirmngr_exit (0);
1673     }
1674 #endif /*HAVE_W32_SYSTEM*/
1675 }
1676
1677
1678 /* Check the nonce on a new connection.  This is a NOP unless we we
1679    are using our Unix domain socket emulation under Windows.  */
1680 static int 
1681 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1682 {
1683   if (assuan_sock_check_nonce (fd, nonce))
1684     {
1685       log_info (_("error reading nonce on fd %d: %s\n"), 
1686                 FD2INT (fd), strerror (errno));
1687       assuan_sock_close (fd);
1688       return -1;
1689     }
1690   else
1691     return 0;
1692 }
1693
1694
1695 /* Helper to call a connection's main fucntion. */
1696 static void *
1697 start_connection_thread (void *arg)
1698 {
1699   union int_and_ptr_u argval;
1700   assuan_fd_t fd;
1701
1702   argval.aptr = arg;
1703   fd = argval.afd;
1704
1705   if (check_nonce (fd, &socket_nonce))
1706     return NULL;
1707
1708 #ifndef HAVE_W32_SYSTEM
1709   pth_key_setdata (my_tlskey_current_fd, argval.aptr);
1710 #endif
1711
1712   active_connections++;
1713   if (opt.verbose)
1714     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1715
1716   start_command_handler (fd);
1717
1718   if (opt.verbose)
1719     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1720   active_connections--;
1721
1722 #ifndef HAVE_W32_SYSTEM
1723   argval.afd = ASSUAN_INVALID_FD;
1724   pth_key_setdata (my_tlskey_current_fd, argval.aptr);
1725 #endif
1726   
1727   return NULL;
1728 }
1729
1730
1731 /* Main loop in daemon mode. */
1732 static void
1733 handle_connections (assuan_fd_t listen_fd)
1734 {
1735   pth_attr_t tattr;
1736   pth_event_t ev, time_ev;
1737   sigset_t sigs, oldsigs;
1738   int signo;
1739   struct sockaddr_un paddr;
1740   socklen_t plen = sizeof( paddr );
1741   assuan_fd_t fd;
1742
1743   tattr = pth_attr_new();
1744   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1745   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 1024*1024);
1746   pth_attr_set (tattr, PTH_ATTR_NAME, "dirmngr");
1747
1748 #ifndef HAVE_W32_SYSTEM /* FIXME */
1749   sigemptyset (&sigs );
1750   sigaddset (&sigs, SIGHUP);
1751   sigaddset (&sigs, SIGUSR1);
1752   sigaddset (&sigs, SIGUSR2);
1753   sigaddset (&sigs, SIGINT);
1754   sigaddset (&sigs, SIGTERM);
1755   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1756 #else
1757   sigs = 0;
1758   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1759 #endif
1760   time_ev = NULL;
1761
1762   for (;;)
1763     {
1764       if (shutdown_pending)
1765         {
1766           if (!active_connections)
1767             break; /* ready */
1768
1769           /* Do not accept anymore connections but wait for existing
1770              connections to terminate.  */
1771           signo = 0;
1772           pth_wait (ev);
1773           if (pth_event_occurred (ev) && signo)
1774             handle_signal (signo);
1775           continue;
1776         }
1777
1778       if (!time_ev)
1779         time_ev = pth_event (PTH_EVENT_TIME, 
1780                              pth_timeout (TIMERTICK_INTERVAL, 0));
1781
1782       if (time_ev)
1783         pth_event_concat (ev, time_ev, NULL);
1784       fd = (assuan_fd_t) pth_accept_ev (FD2INT (listen_fd), (struct sockaddr *)&paddr, &plen, ev);
1785       if (time_ev)
1786         pth_event_isolate (time_ev);
1787
1788       if (fd == ASSUAN_INVALID_FD)
1789         {
1790           if (pth_event_occurred (ev)
1791               || (time_ev && pth_event_occurred (time_ev)) )
1792             {
1793               if (pth_event_occurred (ev))
1794                 handle_signal (signo);
1795               if (time_ev && pth_event_occurred (time_ev))
1796                 {
1797                   pth_event_free (time_ev, PTH_FREE_ALL);
1798                   time_ev = NULL;
1799                   handle_tick ();
1800                 }
1801               continue;
1802             }
1803           log_error (_("accept failed: %s - waiting 1s\n"), strerror (errno));
1804           pth_sleep (1);
1805           continue;
1806         }
1807
1808       if (pth_event_occurred (ev))
1809         {
1810           handle_signal (signo);
1811         }
1812
1813       if (time_ev && pth_event_occurred (time_ev))
1814         {
1815           pth_event_free (time_ev, PTH_FREE_ALL);
1816           time_ev = NULL;
1817           handle_tick ();
1818         }
1819
1820
1821       /* We now might create a new thread and because we don't want
1822          any signals (as we are handling them here) to be delivered to
1823          a new thread we need to block those signals. */
1824       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1825
1826       /* Create thread to handle this connection.  */
1827       {
1828         union int_and_ptr_u argval;
1829
1830         argval.afd = fd;
1831         if (!pth_spawn (tattr, start_connection_thread, argval.aptr))
1832           {
1833             log_error (_("error spawning connection handler: %s\n"),
1834                        strerror (errno) );
1835             assuan_sock_close (fd);
1836           }
1837       }
1838
1839       /* Restore the signal mask. */
1840       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1841     }
1842   
1843   pth_event_free (ev, PTH_FREE_ALL);
1844   if (time_ev)
1845     pth_event_free (time_ev, PTH_FREE_ALL);
1846   pth_attr_destroy (tattr);
1847   cleanup ();
1848   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1849 }