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