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