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