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