Change --dameon home directory to /gnupg under Wince
[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 #ifdef HAVE_W32CE_SYSTEM
725       opt.homedir == DIRSEP_S "gnupg";
726 #else
727       opt.homedir = gnupg_sysconfdir ();
728 #endif
729       opt.homedir_data = gnupg_datadir ();
730       opt.homedir_cache = gnupg_cachedir ();
731     }
732
733   if (default_config)
734     configname = make_filename (opt.homedir, "dirmngr.conf", NULL );
735   
736   argc = orig_argc;
737   argv = orig_argv;
738   pargs.argc = &argc;
739   pargs.argv = &argv;
740   pargs.flags= 1;  /* do not remove the args */
741  next_pass:
742   if (configname)
743     {
744       configlineno = 0;
745       configfp = fopen (configname, "r");
746       if (!configfp)
747         {
748           if (default_config)
749             {
750               if( parse_debug )
751                 log_info (_("NOTE: no default option file `%s'\n"),
752                           configname );
753             }
754           else
755             {
756               log_error (_("option file `%s': %s\n"),
757                          configname, strerror(errno) );
758               exit(2);
759             }
760           xfree (configname); 
761           configname = NULL;
762         }
763       if (parse_debug && configname )
764         log_info (_("reading options from `%s'\n"), configname );
765       default_config = 0;
766     }
767
768   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
769     {
770       if (parse_rereadable_options (&pargs, 0))
771         continue; /* Already handled */
772       switch (pargs.r_opt)
773         {
774         case aServer: 
775         case aDaemon:
776         case aService:
777         case aShutdown: 
778         case aFlush: 
779         case aListCRLs: 
780         case aLoadCRL: 
781         case aFetchCRL:
782         case aGPGConfList:
783         case aGPGConfTest:
784           cmd = pargs.r_opt;
785           break;
786
787         case oQuiet: opt.quiet = 1; break;
788         case oVerbose: opt.verbose++; break;
789         case oBatch: opt.batch=1; break;
790
791         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
792         case oDebugAll: opt.debug = ~0; break;
793         case oDebugLevel: debug_level = pargs.r.ret_str; break;
794         case oDebugWait: debug_wait = pargs.r.ret_int; break;
795
796         case oOptions:
797           /* Config files may not be nested (silently ignore them) */
798           if (!configfp)
799             {
800                 xfree(configname);
801                 configname = xstrdup(pargs.r.ret_str);
802                 goto next_pass;
803             }
804           break;
805         case oNoGreeting: nogreeting = 1; break;
806         case oNoVerbose: opt.verbose = 0; break;
807         case oNoOptions: break; /* no-options */
808         case oHomedir: /* Ignore this option here. */; break;
809         case oNoDetach: nodetach = 1; break;
810         case oLogFile: logfile = pargs.r.ret_str; break;
811         case oCsh: csh_style = 1; break;
812         case oSh: csh_style = 0; break;
813         case oLDAPFile: ldapfile = pargs.r.ret_str; break;
814         case oLDAPAddServers: opt.add_new_ldapservers = 1; break;
815         case oLDAPTimeout: 
816           opt.ldaptimeout = pargs.r.ret_int; 
817           break;
818
819         case oFakedSystemTime:
820           gnupg_set_time ((time_t)pargs.r.ret_ulong, 0);
821           break;
822
823         case oForce: opt.force = 1; break;
824
825         case oSocketName: socket_name = pargs.r.ret_str; break;
826
827         default : pargs.err = configfp? 1:2; break;
828         }
829     }
830   if (configfp)
831     {
832       fclose (configfp);
833       configfp = NULL;
834       /* Keep a copy of the name so that it can be read on SIGHUP. */
835       opt.config_filename = configname;
836       configname = NULL;
837       goto next_pass;
838     }
839   xfree (configname);
840   configname = NULL;
841   if (log_get_errorcount(0))
842     exit(2);
843   if (nogreeting )
844     greeting = 0;
845
846   if (!opt.homedir_data)
847     opt.homedir_data = opt.homedir;
848   if (!opt.homedir_cache)
849     opt.homedir_cache = opt.homedir;
850
851   if (greeting)
852     {
853       es_fprintf (es_stderr, "%s %s; %s\n",
854                   strusage(11), strusage(13), strusage(14) );
855       es_fprintf (es_stderr, "%s\n", strusage(15) );
856     }
857
858 #ifdef IS_DEVELOPMENT_VERSION
859   log_info ("NOTE: this is a development version!\n");
860 #endif
861
862   if (!access ("/etc/dirmngr", F_OK) && !strncmp (opt.homedir, "/etc/", 5))
863     log_info 
864       ("NOTE: DirMngr is now a proper part of GnuPG.  The configuration and"
865        " other directory names changed.  Please check that no other version"
866        " of dirmngr is still installed.  To disable this warning, remove the"
867        " directory `/etc/dirmngr'.\n");
868   
869   if (gnupg_faked_time_p ())
870     {
871       gnupg_isotime_t tbuf;
872
873       log_info (_("WARNING: running with faked system time: "));
874       gnupg_get_isotime (tbuf);
875       dump_isotime (tbuf);
876       log_printf ("\n");
877     }
878
879   set_debug ();
880
881   /* Get LDAP server list from file. */
882   if (!ldapfile) 
883     {
884       ldapfile = make_filename (opt.homedir,
885                                 opt.system_daemon?
886                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
887                                 NULL);
888       opt.ldapservers = parse_ldapserver_file (ldapfile);
889       xfree (ldapfile);
890     }
891   else
892       opt.ldapservers = parse_ldapserver_file (ldapfile);
893
894 #ifndef HAVE_W32_SYSTEM
895   /* We need to ignore the PIPE signal because the we might log to a
896      socket and that code handles EPIPE properly.  The ldap wrapper
897      also requires us to ignore this silly signal. Assuan would set
898      this signal to ignore anyway.*/
899   signal (SIGPIPE, SIG_IGN);
900 #endif
901
902   /* Ready.  Now to our duties. */
903   if (!cmd && opt.system_service)
904     cmd = aDaemon;
905   else if (!cmd)
906     cmd = aServer;
907   rc = 0;
908
909   if (cmd == aServer)
910     {
911       /* Note that this server mode is maily useful for debugging.  */
912       if (argc)
913         wrong_args ("--server");
914
915       if (logfile)
916         {
917           log_set_file (logfile);
918           log_set_prefix (NULL, 2|4);
919         }
920        
921       if (debug_wait)
922         {
923           log_debug ("waiting for debugger - my pid is %u .....\n",
924                      (unsigned int)getpid());
925           gnupg_sleep (debug_wait);
926           log_debug ("... okay\n");
927         }
928
929       ldap_wrapper_launch_thread ();
930       cert_cache_init ();
931       crl_cache_init ();
932       start_command_handler (ASSUAN_INVALID_FD);
933       shutdown_reaper ();
934     }
935   else if (cmd == aDaemon)
936     {
937       assuan_fd_t fd;
938       pid_t pid;
939       int len;
940       struct sockaddr_un serv_addr;
941
942       if (argc)
943         wrong_args ("--daemon");
944       
945       /* Now start with logging to a file if this is desired. */
946       if (logfile)
947         {
948           log_set_file (logfile);
949           log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
950                                  |JNLIB_LOG_WITH_TIME
951                                  |JNLIB_LOG_WITH_PID));
952           current_logfile = xstrdup (logfile);
953         }
954
955 #ifndef HAVE_W32_SYSTEM
956       if (strchr (socket_name, ':'))
957         {
958           log_error (_("colons are not allowed in the socket name\n"));
959           dirmngr_exit (1);
960         }
961 #endif
962       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
963         {
964           log_error (_("name of socket too long\n"));
965           dirmngr_exit (1);
966         }
967     
968       fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
969       if (fd == ASSUAN_INVALID_FD)
970         {
971           log_error (_("can't create socket: %s\n"), strerror (errno));
972           cleanup ();
973           dirmngr_exit (1);
974         }
975
976       memset (&serv_addr, 0, sizeof serv_addr);
977       serv_addr.sun_family = AF_UNIX;
978       strcpy (serv_addr.sun_path, socket_name);
979       len = SUN_LEN (&serv_addr);
980
981       rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
982       if (rc == -1 
983           && (errno == EADDRINUSE
984 #ifdef HAVE_W32_SYSTEM
985               || errno == EEXIST
986 #endif
987               ))
988         {
989           /* Fixme: We should test whether a dirmngr is already running. */
990           gnupg_remove (socket_name);
991           rc = assuan_sock_bind (fd, (struct sockaddr*) &serv_addr, len);
992         }
993       if (rc != -1 
994           && (rc = assuan_sock_get_nonce ((struct sockaddr*) &serv_addr, len, &socket_nonce)))
995         log_error (_("error getting nonce for the socket\n"));
996       if (rc == -1)
997         {
998           log_error (_("error binding socket to `%s': %s\n"),
999                      serv_addr.sun_path, gpg_strerror (gpg_error_from_errno (errno)));
1000           assuan_sock_close (fd);
1001           dirmngr_exit (1);
1002         }
1003       cleanup_socket = 1;
1004   
1005       if (listen (FD2INT (fd), 5) == -1)
1006         {
1007           log_error (_("listen() failed: %s\n"), strerror (errno));
1008           assuan_sock_close (fd);
1009           dirmngr_exit (1);
1010         }
1011
1012       if (opt.verbose)
1013         log_info (_("listening on socket `%s'\n"), socket_name );
1014
1015       es_fflush (NULL);
1016
1017       /* Note: We keep the dirmngr_info output only for the sake of
1018          existing scripts which might use this to detect a successful
1019          start of the dirmngr.  */
1020 #ifdef HAVE_W32_SYSTEM
1021       pid = getpid ();
1022       printf ("set DIRMNGR_INFO=%s;%lu;1\n", socket_name, (ulong) pid);
1023 #else
1024       pid = pth_fork ();
1025       if (pid == (pid_t)-1) 
1026         {
1027           log_fatal (_("error forking process: %s\n"), strerror (errno));
1028           dirmngr_exit (1);
1029         }
1030
1031       if (pid) 
1032         { /* We are the parent */
1033           char *infostr;
1034           
1035           /* Don't let cleanup() remove the socket - the child is
1036              responsible for doing that.  */
1037           cleanup_socket = 0;
1038
1039           close (fd);
1040           
1041           /* Create the info string: <name>:<pid>:<protocol_version> */
1042           if (asprintf (&infostr, "DIRMNGR_INFO=%s:%lu:1",
1043                         socket_name, (ulong)pid ) < 0)
1044             {
1045               log_error (_("out of core\n"));
1046               kill (pid, SIGTERM);
1047               dirmngr_exit (1);
1048             }
1049           /* Print the environment string, so that the caller can use
1050              shell's eval to set it.  But see above.  */
1051           if (csh_style)
1052             {
1053               *strchr (infostr, '=') = ' ';
1054               printf ( "setenv %s\n", infostr);
1055             }
1056           else
1057             {
1058               printf ( "%s; export DIRMNGR_INFO;\n", infostr);
1059             }
1060           free (infostr);
1061           exit (0); 
1062           /*NEVER REACHED*/
1063         } /* end parent */
1064       
1065       
1066       /* 
1067          This is the child
1068        */
1069
1070       /* Detach from tty and put process into a new session */
1071       if (!nodetach )
1072         { 
1073           int i;
1074           unsigned int oldflags;
1075
1076           /* Close stdin, stdout and stderr unless it is the log stream */
1077           for (i=0; i <= 2; i++)
1078             {
1079               if (!log_test_fd (i) && i != fd )
1080                 close (i);
1081             }
1082           if (setsid() == -1)
1083             {
1084               log_error ("setsid() failed: %s\n", strerror(errno) );
1085               dirmngr_exit (1);
1086             }
1087
1088           log_get_prefix (&oldflags);
1089           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1090           opt.running_detached = 1;
1091
1092           if (chdir("/"))
1093             {
1094               log_error ("chdir to / failed: %s\n", strerror (errno));
1095               dirmngr_exit (1);
1096             }
1097         }
1098 #endif
1099
1100       ldap_wrapper_launch_thread ();
1101       cert_cache_init ();
1102       crl_cache_init ();
1103 #ifdef USE_W32_SERVICE
1104       if (opt.system_service)
1105         {
1106           service_status.dwCurrentState = SERVICE_RUNNING;
1107           SetServiceStatus (service_handle, &service_status);
1108         }
1109 #endif
1110       handle_connections (fd);
1111       assuan_sock_close (fd);
1112       shutdown_reaper ();
1113 #ifdef USE_W32_SERVICE
1114       if (opt.system_service)
1115         {
1116           service_status.dwCurrentState = SERVICE_STOPPED;
1117           SetServiceStatus (service_handle, &service_status);
1118         }
1119 #endif
1120     }
1121   else if (cmd == aListCRLs)
1122     {
1123       /* Just list the CRL cache and exit. */
1124       if (argc)
1125         wrong_args ("--list-crls");
1126       ldap_wrapper_launch_thread ();
1127       crl_cache_init ();
1128       crl_cache_list (es_stdout);
1129     }
1130   else if (cmd == aLoadCRL)
1131     {
1132       struct server_control_s ctrlbuf;
1133
1134       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1135       dirmngr_init_default_ctrl (&ctrlbuf);
1136
1137       ldap_wrapper_launch_thread ();
1138       cert_cache_init ();
1139       crl_cache_init ();
1140       if (!argc)
1141         rc = crl_cache_load (&ctrlbuf, NULL);
1142       else
1143         {
1144           for (; !rc && argc; argc--, argv++)
1145             rc = crl_cache_load (&ctrlbuf, *argv);
1146         }
1147     }
1148   else if (cmd == aFetchCRL)
1149     {
1150       ksba_reader_t reader;
1151       struct server_control_s ctrlbuf;
1152
1153       if (argc != 1)
1154         wrong_args ("--fetch-crl URL");
1155
1156       memset (&ctrlbuf, 0, sizeof ctrlbuf);
1157       dirmngr_init_default_ctrl (&ctrlbuf);
1158
1159       ldap_wrapper_launch_thread ();
1160       cert_cache_init ();
1161       crl_cache_init ();
1162       rc = crl_fetch (&ctrlbuf, argv[0], &reader);
1163       if (rc)
1164         log_error (_("fetching CRL from `%s' failed: %s\n"),
1165                      argv[0], gpg_strerror (rc));
1166       else
1167         {
1168           rc = crl_cache_insert (&ctrlbuf, argv[0], reader); 
1169           if (rc)
1170             log_error (_("processing CRL from `%s' failed: %s\n"),
1171                        argv[0], gpg_strerror (rc));
1172           crl_close_reader (reader);
1173         }
1174     }
1175   else if (cmd == aFlush)
1176     {
1177       /* Delete cache and exit. */
1178       if (argc)
1179         wrong_args ("--flush");
1180       rc = crl_cache_flush();
1181     }
1182   else if (cmd == aGPGConfTest)
1183     dirmngr_exit (0);
1184   else if (cmd == aGPGConfList)
1185     {
1186       unsigned long flags = 0;
1187       char *filename;
1188       char *filename_esc;
1189
1190       /* List options and default values in the GPG Conf format.  */
1191
1192 /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1193 /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1194    FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1195 #define GC_OPT_FLAG_NONE        0UL
1196 /* The DEFAULT flag for an option indicates that the option has a
1197    default value.  */
1198 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1199 /* The DEF_DESC flag for an option indicates that the option has a
1200    default, which is described by the value of the default field.  */
1201 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1202 /* The NO_ARG_DESC flag for an option indicates that the argument has
1203    a default, which is described by the value of the ARGDEF field.  */
1204 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1205 #define GC_OPT_FLAG_NO_CHANGE   (1UL <<7)
1206
1207 #ifdef HAVE_W32_SYSTEM
1208       /* On Windows systems, dirmngr always runs as system daemon, and
1209          the per-user configuration is never used.  So we short-cut
1210          everything to use the global system configuration of dirmngr
1211          above, and here we set the no change flag to make these
1212          read-only.  */
1213       flags |= GC_OPT_FLAG_NO_CHANGE;
1214 #endif
1215
1216       /* First the configuration file.  This is not an option, but it
1217          is vital information for GPG Conf.  */
1218       if (!opt.config_filename)
1219         opt.config_filename = make_filename (opt.homedir,
1220                                              "dirmngr.conf", NULL );
1221
1222       filename = percent_escape (opt.config_filename, NULL);
1223       printf ("gpgconf-dirmngr.conf:%lu:\"%s\n",
1224               GC_OPT_FLAG_DEFAULT, filename);
1225       xfree (filename);
1226
1227       printf ("verbose:%lu:\n", flags | GC_OPT_FLAG_NONE);
1228       printf ("quiet:%lu:\n", flags | GC_OPT_FLAG_NONE);
1229       printf ("debug-level:%lu:\"none\n", flags | GC_OPT_FLAG_DEFAULT);
1230       printf ("log-file:%lu:\n", flags | GC_OPT_FLAG_NONE);
1231       printf ("force:%lu:\n", flags | GC_OPT_FLAG_NONE);
1232
1233       /* --csh and --sh are mutually exclusive, something we can not
1234          express in GPG Conf.  --options is only usable from the
1235          command line, really.  --debug-all interacts with --debug,
1236          and having both of them is thus problematic.  --no-detach is
1237          also only usable on the command line.  --batch is unused.  */
1238
1239       filename = make_filename (opt.homedir, 
1240                                 opt.system_daemon?
1241                                 "ldapservers.conf":"dirmngr_ldapservers.conf",
1242                                 NULL);
1243       filename_esc = percent_escape (filename, NULL);
1244       printf ("ldapserverlist-file:%lu:\"%s\n", flags | GC_OPT_FLAG_DEFAULT,
1245               filename_esc);
1246       xfree (filename_esc);
1247       xfree (filename);
1248
1249       printf ("ldaptimeout:%lu:%u\n",
1250               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_LDAP_TIMEOUT);
1251       printf ("max-replies:%lu:%u\n",
1252               flags | GC_OPT_FLAG_DEFAULT, DEFAULT_MAX_REPLIES);
1253       printf ("allow-ocsp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1254       printf ("ocsp-responder:%lu:\n", flags | GC_OPT_FLAG_NONE);
1255       printf ("ocsp-signer:%lu:\n", flags | GC_OPT_FLAG_NONE);
1256
1257       printf ("faked-system-time:%lu:\n", flags | GC_OPT_FLAG_NONE);
1258       printf ("no-greeting:%lu:\n", flags | GC_OPT_FLAG_NONE);
1259
1260       printf ("disable-http:%lu:\n", flags | GC_OPT_FLAG_NONE);
1261       printf ("disable-ldap:%lu:\n", flags | GC_OPT_FLAG_NONE);
1262       printf ("honor-http-proxy:%lu\n", flags | GC_OPT_FLAG_NONE);
1263       printf ("http-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1264       printf ("ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1265       printf ("only-ldap-proxy:%lu:\n", flags | GC_OPT_FLAG_NONE);
1266       printf ("ignore-ldap-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1267       printf ("ignore-http-dp:%lu:\n", flags | GC_OPT_FLAG_NONE);
1268       printf ("ignore-ocsp-service-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1269       /* Note: The next one is to fix a typo in gpgconf - should be
1270          removed eventually. */
1271       printf ("ignore-ocsp-servic-url:%lu:\n", flags | GC_OPT_FLAG_NONE);
1272     }
1273   cleanup ();
1274   return !!rc;
1275 }
1276
1277
1278 #ifdef USE_W32_SERVICE
1279 int
1280 main (int argc, char *argv[])
1281 {
1282   int i;
1283
1284   /* Find out if we run in daemon mode or on the command line.  */
1285   for (i = 1; i < argc; i++)
1286     if (!strcmp (argv[i], "--service"))
1287       {
1288         opt.system_service = 1;
1289         opt.system_daemon = 1;
1290         break;
1291       }
1292
1293   if (!opt.system_service)
1294     return real_main (argc, argv);
1295   else
1296     {
1297       SERVICE_TABLE_ENTRY DispatchTable [] =
1298         {
1299           /* Ignore warning.  */
1300           { "DirMngr", &real_main },
1301           { NULL, NULL }
1302         };
1303
1304       if (!StartServiceCtrlDispatcher (DispatchTable))
1305         return 1;
1306       return 0;
1307     }
1308 }
1309 #endif /*USE_W32_SERVICE*/
1310
1311
1312 static void
1313 cleanup (void)
1314 {
1315   crl_cache_deinit ();
1316   cert_cache_deinit (1);
1317
1318   ldapserver_list_free (opt.ldapservers);
1319   opt.ldapservers = NULL;
1320
1321   if (cleanup_socket)
1322     {
1323       cleanup_socket = 0;
1324       if (socket_name && *socket_name)
1325         gnupg_remove (socket_name);
1326     }
1327 }
1328
1329
1330 void 
1331 dirmngr_exit (int rc)
1332 {
1333   cleanup ();
1334   exit (rc);
1335 }
1336
1337
1338 void
1339 dirmngr_init_default_ctrl (ctrl_t ctrl)
1340 {
1341   (void)ctrl;
1342
1343   /* Nothing for now. */
1344 }
1345
1346
1347 /* Create a list of LDAP servers from the file FILENAME. Returns the
1348    list or NULL in case of errors. 
1349
1350    The format fo such a file is line oriented where empty lines and
1351    lines starting with a hash mark are ignored.  All other lines are
1352    assumed to be colon seprated with these fields:
1353
1354    1. field: Hostname
1355    2. field: Portnumber
1356    3. field: Username 
1357    4. field: Password
1358    5. field: Base DN
1359
1360 */
1361 static ldap_server_t
1362 parse_ldapserver_file (const char* filename)
1363 {
1364   char buffer[1024];
1365   char *p;
1366   ldap_server_t server, serverstart, *serverend;
1367   int c;
1368   unsigned int lineno = 0;
1369   estream_t fp;
1370
1371   fp = es_fopen (filename, "r");
1372   if (!fp)
1373     {
1374       log_error (_("error opening `%s': %s\n"), filename, strerror (errno));
1375       return NULL;
1376     }
1377
1378   serverstart = NULL;
1379   serverend = &serverstart;
1380   while (es_fgets (buffer, sizeof buffer, fp))
1381     {
1382       lineno++;
1383       if (!*buffer || buffer[strlen(buffer)-1] != '\n')
1384         {
1385           if (*buffer && es_feof (fp))
1386             ; /* Last line not terminated - continue. */
1387           else
1388             {
1389               log_error (_("%s:%u: line too long - skipped\n"),
1390                          filename, lineno);
1391               while ( (c=es_fgetc (fp)) != EOF && c != '\n')
1392                 ; /* Skip until end of line. */
1393               continue;
1394             }
1395         }
1396       /* Skip empty and comment lines.*/
1397       for (p=buffer; spacep (p); p++)
1398         ;
1399       if (!*p || *p == '\n' || *p == '#')
1400         continue;
1401
1402       /* Parse the colon separated fields. */
1403       server = ldapserver_parse_one (buffer, filename, lineno);
1404       if (server)
1405         {
1406           *serverend = server;
1407           serverend = &server->next;
1408         }
1409     } 
1410   
1411   if (es_ferror (fp))
1412     log_error (_("error reading `%s': %s\n"), filename, strerror (errno));
1413   es_fclose (fp);
1414
1415   return serverstart;
1416 }
1417
1418
1419 static fingerprint_list_t
1420 parse_ocsp_signer (const char *string)
1421 {
1422   gpg_error_t err;
1423   char *fname;
1424   estream_t fp;
1425   char line[256];
1426   char *p;
1427   fingerprint_list_t list, *list_tail, item;
1428   unsigned int lnr = 0;
1429   int c, i, j;
1430   int errflag = 0;
1431
1432
1433   /* Check whether this is not a filename and treat it as a direct
1434      fingerprint specification.  */
1435   if (!strpbrk (string, "/.~\\"))
1436     {
1437       item = xcalloc (1, sizeof *item);
1438       for (i=j=0; (string[i] == ':' || hexdigitp (string+i)) && j < 40; i++)
1439         if ( string[i] != ':' )
1440           item->hexfpr[j++] = string[i] >= 'a'? (string[i] & 0xdf): string[i];
1441       item->hexfpr[j] = 0;
1442       if (j != 40 || !(spacep (string+i) || !string[i]))
1443         {
1444           log_error (_("%s:%u: invalid fingerprint detected\n"), 
1445                      "--ocsp-signer", 0);
1446           xfree (item);
1447           return NULL;
1448         }
1449       return item;
1450     }
1451   
1452   /* Well, it is a filename.  */
1453   if (*string == '/' || (*string == '~' && string[1] == '/'))
1454     fname = make_filename (string, NULL);
1455   else
1456     {
1457       if (string[0] == '.' && string[1] == '/' )
1458         string += 2;
1459       fname = make_filename (opt.homedir, string, NULL);
1460     }
1461
1462   fp = es_fopen (fname, "r");
1463   if (!fp)
1464     {
1465       err = gpg_error_from_syserror ();
1466       log_error (_("can't open `%s': %s\n"), fname, gpg_strerror (err));
1467       xfree (fname);
1468       return NULL;
1469     }
1470
1471   list = NULL;
1472   list_tail = &list;
1473   for (;;)
1474     {
1475       if (!es_fgets (line, DIM(line)-1, fp) )
1476         {
1477           if (!es_feof (fp))
1478             {
1479               err = gpg_error_from_syserror ();
1480               log_error (_("%s:%u: read error: %s\n"),
1481                          fname, lnr, gpg_strerror (err));
1482               errflag = 1;
1483             }
1484           es_fclose (fp);
1485           if (errflag)
1486             {
1487               while (list)
1488                 {
1489                   fingerprint_list_t tmp = list->next;
1490                   xfree (list);
1491                   list = tmp;
1492                 }
1493             }
1494           xfree (fname);
1495           return list; /* Ready.  */
1496         }
1497
1498       lnr++;
1499       if (!*line || line[strlen(line)-1] != '\n')
1500         {
1501           /* Eat until end of line. */
1502           while ( (c=es_getc (fp)) != EOF && c != '\n')
1503             ;
1504           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
1505                            /* */: GPG_ERR_INCOMPLETE_LINE);
1506           log_error (_("%s:%u: read error: %s\n"), 
1507                      fname, lnr, gpg_strerror (err));
1508           errflag = 1;
1509           continue;
1510         }
1511
1512       /* Allow for empty lines and spaces */
1513       for (p=line; spacep (p); p++)
1514         ;
1515       if (!*p || *p == '\n' || *p == '#')
1516         continue;
1517
1518       item = xcalloc (1, sizeof *item);
1519       *list_tail = item;
1520       list_tail = &item->next;
1521
1522       for (i=j=0; (p[i] == ':' || hexdigitp (p+i)) && j < 40; i++)
1523         if ( p[i] != ':' )
1524           item->hexfpr[j++] = p[i] >= 'a'? (p[i] & 0xdf): p[i];
1525       item->hexfpr[j] = 0;
1526       if (j != 40 || !(spacep (p+i) || p[i] == '\n'))
1527         {
1528           log_error (_("%s:%u: invalid fingerprint detected\n"), fname, lnr);
1529           errflag = 1;
1530         }
1531       i++;
1532       while (spacep (p+i))
1533         i++;
1534       if (p[i] && p[i] != '\n')
1535         log_info (_("%s:%u: garbage at end of line ignored\n"), fname, lnr);
1536     }
1537   /*NOTREACHED*/
1538 }
1539
1540
1541
1542 \f
1543 /*
1544    Stuff used in daemon mode.  
1545  */
1546
1547
1548
1549 /* Reread parts of the configuration.  Note, that this function is
1550    obviously not thread-safe and should only be called from the PTH
1551    signal handler. 
1552
1553    Fixme: Due to the way the argument parsing works, we create a
1554    memory leak here for all string type arguments.  There is currently
1555    no clean way to tell whether the memory for the argument has been
1556    allocated or points into the process' original arguments.  Unless
1557    we have a mechanism to tell this, we need to live on with this. */
1558 static void
1559 reread_configuration (void)
1560 {
1561   ARGPARSE_ARGS pargs;
1562   FILE *fp;
1563   unsigned int configlineno = 0;
1564   int dummy;
1565
1566   if (!opt.config_filename)
1567     return; /* No config file. */
1568
1569   fp = fopen (opt.config_filename, "r");
1570   if (!fp)
1571     {
1572       log_error (_("option file `%s': %s\n"),
1573                  opt.config_filename, strerror(errno) );
1574       return;
1575     }
1576
1577   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1578
1579   memset (&pargs, 0, sizeof pargs);
1580   dummy = 0;
1581   pargs.argc = &dummy;
1582   pargs.flags = 1;  /* do not remove the args */
1583   while (optfile_parse (fp, opt.config_filename, &configlineno, &pargs, opts) )
1584     {
1585       if (pargs.r_opt < -1)
1586         pargs.err = 1; /* Print a warning. */
1587       else /* Try to parse this option - ignore unchangeable ones. */
1588         parse_rereadable_options (&pargs, 1);
1589     }
1590   fclose (fp);
1591
1592   set_debug ();
1593 }
1594
1595
1596 /* A global function which allows us to trigger the reload stuff from
1597    other places.  */
1598 void
1599 dirmngr_sighup_action (void)
1600 {
1601   log_info (_("SIGHUP received - "
1602               "re-reading configuration and flushing caches\n"));
1603   reread_configuration ();
1604   cert_cache_deinit (0);
1605   crl_cache_deinit ();
1606   cert_cache_init ();
1607   crl_cache_init ();
1608 }
1609
1610
1611
1612 /* The signal handler. */
1613 static void
1614 handle_signal (int signo)
1615 {
1616   switch (signo)
1617     {
1618 #ifndef HAVE_W32_SYSTEM
1619     case SIGHUP:
1620       dirmngr_sighup_action ();
1621       break;
1622       
1623     case SIGUSR1:
1624       cert_cache_print_stats ();
1625       break;
1626       
1627     case SIGUSR2:
1628       log_info (_("SIGUSR2 received - no action defined\n"));
1629       break;
1630
1631     case SIGTERM:
1632       if (!shutdown_pending)
1633         log_info (_("SIGTERM received - shutting down ...\n"));
1634       else
1635         log_info (_("SIGTERM received - still %d active connections\n"),
1636                   active_connections);
1637       shutdown_pending++;
1638       if (shutdown_pending > 2)
1639         {
1640           log_info (_("shutdown forced\n"));
1641           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1642           cleanup ();
1643           dirmngr_exit (0);
1644         }
1645       break;
1646         
1647     case SIGINT:
1648       log_info (_("SIGINT received - immediate shutdown\n"));
1649       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1650       cleanup ();
1651       dirmngr_exit (0);
1652       break;
1653 #endif
1654     default:
1655       log_info (_("signal %d received - no action defined\n"), signo);
1656     }
1657 }
1658
1659
1660 /* This is the worker for the ticker.  It is called every few seconds
1661    and may only do fast operations. */
1662 static void
1663 handle_tick (void)
1664 {
1665   /* Nothing real to do right now.  Actually we need the timeout only
1666      for W32 where we don't use signals and need a way for the loop to
1667      check for the shutdown flag. */
1668 #ifdef HAVE_W32_SYSTEM
1669   if (shutdown_pending)
1670     log_info (_("SIGTERM received - shutting down ...\n"));
1671   if (shutdown_pending > 2)
1672     {
1673       log_info (_("shutdown forced\n"));
1674       log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1675       cleanup ();
1676       dirmngr_exit (0);
1677     }
1678 #endif /*HAVE_W32_SYSTEM*/
1679 }
1680
1681
1682 /* Check the nonce on a new connection.  This is a NOP unless we we
1683    are using our Unix domain socket emulation under Windows.  */
1684 static int 
1685 check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce)
1686 {
1687   if (assuan_sock_check_nonce (fd, nonce))
1688     {
1689       log_info (_("error reading nonce on fd %d: %s\n"), 
1690                 FD2INT (fd), strerror (errno));
1691       assuan_sock_close (fd);
1692       return -1;
1693     }
1694   else
1695     return 0;
1696 }
1697
1698
1699 /* Helper to call a connection's main fucntion. */
1700 static void *
1701 start_connection_thread (void *arg)
1702 {
1703   union int_and_ptr_u argval;
1704   assuan_fd_t fd;
1705
1706   argval.aptr = arg;
1707   fd = argval.afd;
1708
1709   if (check_nonce (fd, &socket_nonce))
1710     return NULL;
1711
1712 #ifndef HAVE_W32_SYSTEM
1713   pth_key_setdata (my_tlskey_current_fd, argval.aptr);
1714 #endif
1715
1716   active_connections++;
1717   if (opt.verbose)
1718     log_info (_("handler for fd %d started\n"), FD2INT (fd));
1719
1720   start_command_handler (fd);
1721
1722   if (opt.verbose)
1723     log_info (_("handler for fd %d terminated\n"), FD2INT (fd));
1724   active_connections--;
1725
1726 #ifndef HAVE_W32_SYSTEM
1727   argval.afd = ASSUAN_INVALID_FD;
1728   pth_key_setdata (my_tlskey_current_fd, argval.aptr);
1729 #endif
1730   
1731   return NULL;
1732 }
1733
1734
1735 /* Main loop in daemon mode. */
1736 static void
1737 handle_connections (assuan_fd_t listen_fd)
1738 {
1739   pth_attr_t tattr;
1740   pth_event_t ev, time_ev;
1741   sigset_t sigs, oldsigs;
1742   int signo;
1743   struct sockaddr_un paddr;
1744   socklen_t plen = sizeof( paddr );
1745   assuan_fd_t fd;
1746
1747   tattr = pth_attr_new();
1748   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1749   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 1024*1024);
1750   pth_attr_set (tattr, PTH_ATTR_NAME, "dirmngr");
1751
1752 #ifndef HAVE_W32_SYSTEM /* FIXME */
1753   sigemptyset (&sigs );
1754   sigaddset (&sigs, SIGHUP);
1755   sigaddset (&sigs, SIGUSR1);
1756   sigaddset (&sigs, SIGUSR2);
1757   sigaddset (&sigs, SIGINT);
1758   sigaddset (&sigs, SIGTERM);
1759   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1760 #else
1761   sigs = 0;
1762   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1763 #endif
1764   time_ev = NULL;
1765
1766   for (;;)
1767     {
1768       if (shutdown_pending)
1769         {
1770           if (!active_connections)
1771             break; /* ready */
1772
1773           /* Do not accept anymore connections but wait for existing
1774              connections to terminate.  */
1775           signo = 0;
1776           pth_wait (ev);
1777           if (pth_event_occurred (ev) && signo)
1778             handle_signal (signo);
1779           continue;
1780         }
1781
1782       if (!time_ev)
1783         time_ev = pth_event (PTH_EVENT_TIME, 
1784                              pth_timeout (TIMERTICK_INTERVAL, 0));
1785
1786       if (time_ev)
1787         pth_event_concat (ev, time_ev, NULL);
1788       fd = (assuan_fd_t) pth_accept_ev (FD2INT (listen_fd), (struct sockaddr *)&paddr, &plen, ev);
1789       if (time_ev)
1790         pth_event_isolate (time_ev);
1791
1792       if (fd == ASSUAN_INVALID_FD)
1793         {
1794           if (pth_event_occurred (ev)
1795               || (time_ev && pth_event_occurred (time_ev)) )
1796             {
1797               if (pth_event_occurred (ev))
1798                 handle_signal (signo);
1799               if (time_ev && pth_event_occurred (time_ev))
1800                 {
1801                   pth_event_free (time_ev, PTH_FREE_ALL);
1802                   time_ev = NULL;
1803                   handle_tick ();
1804                 }
1805               continue;
1806             }
1807           log_error (_("accept failed: %s - waiting 1s\n"), strerror (errno));
1808           pth_sleep (1);
1809           continue;
1810         }
1811
1812       if (pth_event_occurred (ev))
1813         {
1814           handle_signal (signo);
1815         }
1816
1817       if (time_ev && pth_event_occurred (time_ev))
1818         {
1819           pth_event_free (time_ev, PTH_FREE_ALL);
1820           time_ev = NULL;
1821           handle_tick ();
1822         }
1823
1824
1825       /* We now might create a new thread and because we don't want
1826          any signals (as we are handling them here) to be delivered to
1827          a new thread we need to block those signals. */
1828       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1829
1830       /* Create thread to handle this connection.  */
1831       {
1832         union int_and_ptr_u argval;
1833
1834         argval.afd = fd;
1835         if (!pth_spawn (tattr, start_connection_thread, argval.aptr))
1836           {
1837             log_error (_("error spawning connection handler: %s\n"),
1838                        strerror (errno) );
1839             assuan_sock_close (fd);
1840           }
1841       }
1842
1843       /* Restore the signal mask. */
1844       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1845     }
1846   
1847   pth_event_free (ev, PTH_FREE_ALL);
1848   if (time_ev)
1849     pth_event_free (time_ev, PTH_FREE_ALL);
1850   pth_attr_destroy (tattr);
1851   cleanup ();
1852   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1853 }