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