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