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