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