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