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