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