agent: Set assuan system hooks before call of assuan_sock_init.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000-2007, 2009-2010 Free Software Foundation, Inc.
3  * Copyright (C) 2000-2016 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG 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 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <assert.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #include <sys/stat.h>
33 #ifdef HAVE_W32_SYSTEM
34 # ifndef WINVER
35 #  define WINVER 0x0500  /* Same as in common/sysutils.c */
36 # endif
37 # ifdef HAVE_WINSOCK2_H
38 #  include <winsock2.h>
39 # endif
40 # include <aclapi.h>
41 # include <sddl.h>
42 #else /*!HAVE_W32_SYSTEM*/
43 # include <sys/socket.h>
44 # include <sys/un.h>
45 #endif /*!HAVE_W32_SYSTEM*/
46 #include <unistd.h>
47 #ifdef HAVE_SIGNAL_H
48 # include <signal.h>
49 #endif
50 #include <npth.h>
51
52 #define GNUPG_COMMON_NEED_AFLOCAL
53 #include "agent.h"
54 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
55
56 #include "../common/i18n.h"
57 #include "../common/sysutils.h"
58 #include "../common/gc-opt-flags.h"
59 #include "../common/exechelp.h"
60 #include "../common/asshelp.h"
61 #include "../common/init.h"
62
63
64 enum cmd_and_opt_values
65 { aNull = 0,
66   oCsh            = 'c',
67   oQuiet          = 'q',
68   oSh             = 's',
69   oVerbose        = 'v',
70
71   oNoVerbose = 500,
72   aGPGConfList,
73   aGPGConfTest,
74   aUseStandardSocketP,
75   oOptions,
76   oDebug,
77   oDebugAll,
78   oDebugLevel,
79   oDebugWait,
80   oDebugQuickRandom,
81   oDebugPinentry,
82   oNoGreeting,
83   oNoOptions,
84   oHomedir,
85   oNoDetach,
86   oGrab,
87   oNoGrab,
88   oLogFile,
89   oServer,
90   oDaemon,
91   oSupervised,
92   oBatch,
93
94   oPinentryProgram,
95   oPinentryTouchFile,
96   oPinentryInvisibleChar,
97   oPinentryTimeout,
98   oDisplay,
99   oTTYname,
100   oTTYtype,
101   oLCctype,
102   oLCmessages,
103   oXauthority,
104   oScdaemonProgram,
105   oDefCacheTTL,
106   oDefCacheTTLSSH,
107   oMaxCacheTTL,
108   oMaxCacheTTLSSH,
109   oEnforcePassphraseConstraints,
110   oMinPassphraseLen,
111   oMinPassphraseNonalpha,
112   oCheckPassphrasePattern,
113   oMaxPassphraseDays,
114   oEnablePassphraseHistory,
115   oEnableExtendedKeyFormat,
116   oUseStandardSocket,
117   oNoUseStandardSocket,
118   oExtraSocket,
119   oBrowserSocket,
120   oFakedSystemTime,
121
122   oIgnoreCacheForSigning,
123   oAllowMarkTrusted,
124   oNoAllowMarkTrusted,
125   oAllowPresetPassphrase,
126   oAllowLoopbackPinentry,
127   oNoAllowLoopbackPinentry,
128   oNoAllowExternalCache,
129   oAllowEmacsPinentry,
130   oKeepTTY,
131   oKeepDISPLAY,
132   oSSHSupport,
133   oSSHFingerprintDigest,
134   oPuttySupport,
135   oDisableScdaemon,
136   oDisableCheckOwnSocket,
137   oS2KCount,
138   oAutoExpandSecmem,
139
140   oWriteEnvFile
141 };
142
143
144 #ifndef ENAMETOOLONG
145 # define ENAMETOOLONG EINVAL
146 #endif
147
148
149 static ARGPARSE_OPTS opts[] = {
150
151   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
152   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
153   ARGPARSE_c (aUseStandardSocketP, "use-standard-socket-p", "@"),
154
155   ARGPARSE_group (301, N_("@Options:\n ")),
156
157   ARGPARSE_s_n (oDaemon,  "daemon", N_("run in daemon mode (background)")),
158   ARGPARSE_s_n (oServer,  "server", N_("run in server mode (foreground)")),
159 #ifndef HAVE_W32_SYSTEM
160   ARGPARSE_s_n (oSupervised,  "supervised", N_("run in supervised mode")),
161 #endif
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
168   ARGPARSE_s_s (oDebug,      "debug",       "@"),
169   ARGPARSE_s_n (oDebugAll,   "debug-all",   "@"),
170   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
171   ARGPARSE_s_i (oDebugWait,  "debug-wait",  "@"),
172   ARGPARSE_s_n (oDebugQuickRandom, "debug-quick-random", "@"),
173   ARGPARSE_s_n (oDebugPinentry, "debug-pinentry", "@"),
174
175   ARGPARSE_s_n (oNoDetach,  "no-detach", N_("do not detach from the console")),
176   ARGPARSE_s_n (oGrab,      "grab",      "@"),
177                 /* FIXME: Add the below string for 2.3 */
178                 /* N_("let PIN-Entry grab keyboard and mouse")), */
179   ARGPARSE_s_n (oNoGrab,    "no-grab",   "@"),
180   ARGPARSE_s_s (oLogFile,   "log-file",  N_("use a log file for the server")),
181   ARGPARSE_s_s (oPinentryProgram, "pinentry-program",
182                 /* */             N_("|PGM|use PGM as the PIN-Entry program")),
183   ARGPARSE_s_s (oPinentryTouchFile, "pinentry-touch-file", "@"),
184   ARGPARSE_s_s (oPinentryInvisibleChar, "pinentry-invisible-char", "@"),
185   ARGPARSE_s_u (oPinentryTimeout, "pinentry-timeout", "@"),
186   ARGPARSE_s_s (oScdaemonProgram, "scdaemon-program",
187                 /* */             N_("|PGM|use PGM as the SCdaemon program") ),
188   ARGPARSE_s_n (oDisableScdaemon, "disable-scdaemon",
189                 /* */             N_("do not use the SCdaemon") ),
190   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
191
192   ARGPARSE_s_s (oExtraSocket, "extra-socket",
193                 /* */       N_("|NAME|accept some commands via NAME")),
194
195   ARGPARSE_s_s (oBrowserSocket, "browser-socket", "@"),
196
197   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
198
199   ARGPARSE_s_n (oBatch,      "batch",        "@"),
200   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
201
202   ARGPARSE_s_s (oDisplay,    "display",     "@"),
203   ARGPARSE_s_s (oTTYname,    "ttyname",     "@"),
204   ARGPARSE_s_s (oTTYtype,    "ttytype",     "@"),
205   ARGPARSE_s_s (oLCctype,    "lc-ctype",    "@"),
206   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
207   ARGPARSE_s_s (oXauthority, "xauthority",  "@"),
208   ARGPARSE_s_n (oKeepTTY,    "keep-tty",
209                 /* */        N_("ignore requests to change the TTY")),
210   ARGPARSE_s_n (oKeepDISPLAY, "keep-display",
211                 /* */        N_("ignore requests to change the X display")),
212
213   ARGPARSE_s_u (oDefCacheTTL,    "default-cache-ttl",
214                                  N_("|N|expire cached PINs after N seconds")),
215   ARGPARSE_s_u (oDefCacheTTLSSH, "default-cache-ttl-ssh", "@" ),
216   ARGPARSE_s_u (oMaxCacheTTL,    "max-cache-ttl",         "@" ),
217   ARGPARSE_s_u (oMaxCacheTTLSSH, "max-cache-ttl-ssh",     "@" ),
218
219   ARGPARSE_s_n (oEnforcePassphraseConstraints, "enforce-passphrase-constraints",
220                 /* */                          "@"),
221   ARGPARSE_s_u (oMinPassphraseLen,        "min-passphrase-len", "@"),
222   ARGPARSE_s_u (oMinPassphraseNonalpha,   "min-passphrase-nonalpha", "@"),
223   ARGPARSE_s_s (oCheckPassphrasePattern,  "check-passphrase-pattern", "@"),
224   ARGPARSE_s_u (oMaxPassphraseDays,       "max-passphrase-days", "@"),
225   ARGPARSE_s_n (oEnablePassphraseHistory, "enable-passphrase-history", "@"),
226
227   ARGPARSE_s_n (oIgnoreCacheForSigning, "ignore-cache-for-signing",
228                 /* */    N_("do not use the PIN cache when signing")),
229   ARGPARSE_s_n (oNoAllowExternalCache,  "no-allow-external-cache",
230                 /* */    N_("disallow the use of an external password cache")),
231   ARGPARSE_s_n (oNoAllowMarkTrusted, "no-allow-mark-trusted",
232                 /* */    N_("disallow clients to mark keys as \"trusted\"")),
233   ARGPARSE_s_n (oAllowMarkTrusted,   "allow-mark-trusted", "@"),
234   ARGPARSE_s_n (oAllowPresetPassphrase, "allow-preset-passphrase",
235                 /* */                    N_("allow presetting passphrase")),
236   ARGPARSE_s_n (oNoAllowLoopbackPinentry, "no-allow-loopback-pinentry",
237                                 N_("disallow caller to override the pinentry")),
238   ARGPARSE_s_n (oAllowLoopbackPinentry, "allow-loopback-pinentry", "@"),
239   ARGPARSE_s_n (oAllowEmacsPinentry,  "allow-emacs-pinentry",
240                 /* */    N_("allow passphrase to be prompted through Emacs")),
241
242   ARGPARSE_s_n (oSSHSupport,   "enable-ssh-support", N_("enable ssh support")),
243   ARGPARSE_s_s (oSSHFingerprintDigest, "ssh-fingerprint-digest",
244                 N_("|ALGO|use ALGO to show ssh fingerprints")),
245   ARGPARSE_s_n (oPuttySupport, "enable-putty-support",
246 #ifdef HAVE_W32_SYSTEM
247                 /* */           N_("enable putty support")
248 #else
249                 /* */           "@"
250 #endif
251                 ),
252   ARGPARSE_s_n (oEnableExtendedKeyFormat, "enable-extended-key-format", "@"),
253
254   ARGPARSE_s_u (oS2KCount, "s2k-count", "@"),
255
256   ARGPARSE_op_u (oAutoExpandSecmem, "auto-expand-secmem", "@"),
257
258   /* Dummy options for backward compatibility.  */
259   ARGPARSE_o_s (oWriteEnvFile, "write-env-file", "@"),
260   ARGPARSE_s_n (oUseStandardSocket, "use-standard-socket", "@"),
261   ARGPARSE_s_n (oNoUseStandardSocket, "no-use-standard-socket", "@"),
262
263   ARGPARSE_end () /* End of list */
264 };
265
266
267 /* The list of supported debug flags.  */
268 static struct debug_flags_s debug_flags [] =
269   {
270     { DBG_MPI_VALUE    , "mpi"     },
271     { DBG_CRYPTO_VALUE , "crypto"  },
272     { DBG_MEMORY_VALUE , "memory"  },
273     { DBG_CACHE_VALUE  , "cache"   },
274     { DBG_MEMSTAT_VALUE, "memstat" },
275     { DBG_HASHING_VALUE, "hashing" },
276     { DBG_IPC_VALUE    , "ipc"     },
277     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
278   };
279
280
281
282 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
283 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
284 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
285 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
286 #define MIN_PASSPHRASE_LEN    (8)
287 #define MIN_PASSPHRASE_NONALPHA (1)
288 #define MAX_PASSPHRASE_DAYS   (0)
289
290 /* The timer tick used for housekeeping stuff.  Note that on Windows
291  * we use a SetWaitableTimer seems to signal earlier than about 2
292  * seconds.  Thus we use 4 seconds on all platforms except for
293  * Windowsce.  CHECK_OWN_SOCKET_INTERVAL defines how often we check
294  * our own socket in standard socket mode.  If that value is 0 we
295  * don't check at all.  All values are in seconds. */
296 #if defined(HAVE_W32CE_SYSTEM)
297 # define TIMERTICK_INTERVAL         (60)
298 # define CHECK_OWN_SOCKET_INTERVAL   (0)  /* Never */
299 #else
300 # define TIMERTICK_INTERVAL          (4)
301 # define CHECK_OWN_SOCKET_INTERVAL  (60)
302 #endif
303
304
305 /* Flag indicating that the ssh-agent subsystem has been enabled.  */
306 static int ssh_support;
307
308 #ifdef HAVE_W32_SYSTEM
309 /* Flag indicating that support for Putty has been enabled.  */
310 static int putty_support;
311 /* A magic value used with WM_COPYDATA.  */
312 #define PUTTY_IPC_MAGIC 0x804e50ba
313 /* To avoid surprises we limit the size of the mapped IPC file to this
314    value.  Putty currently (0.62) uses 8k, thus 16k should be enough
315    for the foreseeable future.  */
316 #define PUTTY_IPC_MAXLEN 16384
317 #endif /*HAVE_W32_SYSTEM*/
318
319 /* The list of open file descriptors at startup.  Note that this list
320  * has been allocated using the standard malloc.  */
321 #ifndef HAVE_W32_SYSTEM
322 static int *startup_fd_list;
323 #endif
324
325 /* The signal mask at startup and a flag telling whether it is valid.  */
326 #ifdef HAVE_SIGPROCMASK
327 static sigset_t startup_signal_mask;
328 static int startup_signal_mask_valid;
329 #endif
330
331 /* Flag to indicate that a shutdown was requested.  */
332 static int shutdown_pending;
333
334 /* Counter for the currently running own socket checks.  */
335 static int check_own_socket_running;
336
337 /* Flags to indicate that check_own_socket shall not be called.  */
338 static int disable_check_own_socket;
339
340 /* Flag indicating that we are in supervised mode.  */
341 static int is_supervised;
342
343 /* Flag to inhibit socket removal in cleanup.  */
344 static int inhibit_socket_removal;
345
346 /* It is possible that we are currently running under setuid permissions */
347 static int maybe_setuid = 1;
348
349 /* Name of the communication socket used for native gpg-agent
350    requests. The second variable is either NULL or a malloced string
351    with the real socket name in case it has been redirected.  */
352 static char *socket_name;
353 static char *redir_socket_name;
354
355 /* Name of the optional extra socket used for native gpg-agent requests.  */
356 static char *socket_name_extra;
357 static char *redir_socket_name_extra;
358
359 /* Name of the optional browser socket used for native gpg-agent requests.  */
360 static char *socket_name_browser;
361 static char *redir_socket_name_browser;
362
363 /* Name of the communication socket used for ssh-agent protocol.  */
364 static char *socket_name_ssh;
365 static char *redir_socket_name_ssh;
366
367 /* We need to keep track of the server's nonces (these are dummies for
368    POSIX systems). */
369 static assuan_sock_nonce_t socket_nonce;
370 static assuan_sock_nonce_t socket_nonce_extra;
371 static assuan_sock_nonce_t socket_nonce_browser;
372 static assuan_sock_nonce_t socket_nonce_ssh;
373
374
375 /* Default values for options passed to the pinentry. */
376 static char *default_display;
377 static char *default_ttyname;
378 static char *default_ttytype;
379 static char *default_lc_ctype;
380 static char *default_lc_messages;
381 static char *default_xauthority;
382
383 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
384 static char *config_filename;
385
386 /* Helper to implement --debug-level */
387 static const char *debug_level;
388
389 /* Keep track of the current log file so that we can avoid updating
390    the log file after a SIGHUP if it didn't changed. Malloced. */
391 static char *current_logfile;
392
393 /* The handle_tick() function may test whether a parent is still
394  * running.  We record the PID of the parent here or -1 if it should
395  * be watched.  */
396 static pid_t parent_pid = (pid_t)(-1);
397
398 /* This flag is true if the inotify mechanism for detecting the
399  * removal of the homedir is active.  This flag is used to disable the
400  * alternative but portable stat based check.  */
401 static int have_homedir_inotify;
402
403 /* Depending on how gpg-agent was started, the homedir inotify watch
404  * may not be reliable.  This flag is set if we assume that inotify
405  * works reliable.  */
406 static int reliable_homedir_inotify;
407
408 /* Number of active connections.  */
409 static int active_connections;
410
411 /* This object is used to dispatch progress messages from Libgcrypt to
412  * the right thread.  Given that we will have at max only a few dozen
413  * connections at a time, using a linked list is the easiest way to
414  * handle this. */
415 struct progress_dispatch_s
416 {
417   struct progress_dispatch_s *next;
418   /* The control object of the connection.  If this is NULL no
419    * connection is associated with this item and it is free for reuse
420    * by new connections.  */
421   ctrl_t ctrl;
422
423   /* The thread id of (npth_self) of the connection.  */
424   npth_t tid;
425
426   /* The callback set by the connection.  This is similar to the
427    * Libgcrypt callback but with the control object passed as the
428    * first argument.  */
429   void (*cb)(ctrl_t ctrl,
430              const char *what, int printchar,
431              int current, int total);
432 };
433 struct progress_dispatch_s *progress_dispatch_list;
434
435
436
437 \f
438 /*
439    Local prototypes.
440  */
441
442 static char *create_socket_name (char *standard_name, int with_homedir);
443 static gnupg_fd_t create_server_socket (char *name, int primary, int cygwin,
444                                         char **r_redir_name,
445                                         assuan_sock_nonce_t *nonce);
446 static void create_directories (void);
447
448 static void agent_libgcrypt_progress_cb (void *data, const char *what,
449                                          int printchar,
450                                          int current, int total);
451 static void agent_init_default_ctrl (ctrl_t ctrl);
452 static void agent_deinit_default_ctrl (ctrl_t ctrl);
453
454 static void handle_connections (gnupg_fd_t listen_fd,
455                                 gnupg_fd_t listen_fd_extra,
456                                 gnupg_fd_t listen_fd_browser,
457                                 gnupg_fd_t listen_fd_ssh);
458 static void check_own_socket (void);
459 static int check_for_running_agent (int silent);
460
461 /* Pth wrapper function definitions. */
462 ASSUAN_SYSTEM_NPTH_IMPL;
463
464 \f
465 /*
466    Functions.
467  */
468
469 /* Allocate a string describing a library version by calling a GETFNC.
470    This function is expected to be called only once.  GETFNC is
471    expected to have a semantic like gcry_check_version ().  */
472 static char *
473 make_libversion (const char *libname, const char *(*getfnc)(const char*))
474 {
475   const char *s;
476   char *result;
477
478   if (maybe_setuid)
479     {
480       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
481       maybe_setuid = 0;
482     }
483   s = getfnc (NULL);
484   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
485   strcpy (stpcpy (stpcpy (result, libname), " "), s);
486   return result;
487 }
488
489 /* Return strings describing this program.  The case values are
490    described in common/argparse.c:strusage.  The values here override
491    the default values given by strusage.  */
492 static const char *
493 my_strusage (int level)
494 {
495   static char *ver_gcry;
496   const char *p;
497
498   switch (level)
499     {
500     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
501       break;
502     case 13: p = VERSION; break;
503     case 17: p = PRINTABLE_OS_NAME; break;
504       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
505          reporting address.  This is so that we can change the
506          reporting address without breaking the translations.  */
507     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
508
509     case 20:
510       if (!ver_gcry)
511         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
512       p = ver_gcry;
513       break;
514
515     case 1:
516     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
517       break;
518     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
519                     "Secret key management for @GNUPG@\n");
520     break;
521
522     default: p = NULL;
523     }
524   return p;
525 }
526
527
528
529 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
530    only the active debug flags are propagated to the subsystems.  With
531    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
532    all flags already set. Note that we don't fail here, because it is
533    important to keep gpg-agent running even after re-reading the
534    options due to a SIGHUP. */
535 static void
536 set_debug (void)
537 {
538   int numok = (debug_level && digitp (debug_level));
539   int numlvl = numok? atoi (debug_level) : 0;
540
541   if (!debug_level)
542     ;
543   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
544     opt.debug = 0;
545   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
546     opt.debug = DBG_IPC_VALUE;
547   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
548     opt.debug = DBG_IPC_VALUE;
549   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
550     opt.debug = (DBG_IPC_VALUE | DBG_CACHE_VALUE);
551   else if (!strcmp (debug_level, "guru") || numok)
552     {
553       opt.debug = ~0;
554       /* Unless the "guru" string has been used we don't want to allow
555          hashing debugging.  The rationale is that people tend to
556          select the highest debug value and would then clutter their
557          disk with debug files which may reveal confidential data.  */
558       if (numok)
559         opt.debug &= ~(DBG_HASHING_VALUE);
560     }
561   else
562     {
563       log_error (_("invalid debug-level '%s' given\n"), debug_level);
564       opt.debug = 0; /* Reset debugging, so that prior debug
565                         statements won't have an undesired effect. */
566     }
567
568   if (opt.debug && !opt.verbose)
569     opt.verbose = 1;
570   if (opt.debug && opt.quiet)
571     opt.quiet = 0;
572
573   if (opt.debug & DBG_MPI_VALUE)
574     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
575   if (opt.debug & DBG_CRYPTO_VALUE )
576     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
577   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
578
579   if (opt.debug)
580     parse_debug_flag (NULL, &opt.debug, debug_flags);
581 }
582
583
584 /* Helper for cleanup to remove one socket with NAME.  REDIR_NAME is
585    the corresponding real name if the socket has been redirected.  */
586 static void
587 remove_socket (char *name, char *redir_name)
588 {
589   if (name && *name)
590     {
591       if (redir_name)
592         name = redir_name;
593
594       gnupg_remove (name);
595       *name = 0;
596     }
597 }
598
599
600 /* Discover which inherited file descriptors correspond to which
601  * services/sockets offered by gpg-agent, using the LISTEN_FDS and
602  * LISTEN_FDNAMES convention.  The understood labels are "ssh",
603  * "extra", and "browser".  "std" or other labels will be interpreted
604  * as the standard socket.
605  *
606  * This function is designed to log errors when the expected file
607  * descriptors don't make sense, but to do its best to continue to
608  * work even in the face of minor misconfigurations.
609  *
610  * For more information on the LISTEN_FDS convention, see
611  * sd_listen_fds(3) on certain Linux distributions.
612  */
613 #ifndef HAVE_W32_SYSTEM
614 static void
615 map_supervised_sockets (gnupg_fd_t *r_fd,
616                         gnupg_fd_t *r_fd_extra,
617                         gnupg_fd_t *r_fd_browser,
618                         gnupg_fd_t *r_fd_ssh)
619 {
620   struct {
621     const char *label;
622     int **fdaddr;
623     char **nameaddr;
624   } tbl[] = {
625     { "ssh",     &r_fd_ssh,     &socket_name_ssh },
626     { "browser", &r_fd_browser, &socket_name_browser },
627     { "extra",   &r_fd_extra,   &socket_name_extra },
628     { "std",     &r_fd,         &socket_name }  /* (Must be the last item.)  */
629   };
630   const char *envvar;
631   char **fdnames;
632   int nfdnames;
633   int fd_count;
634
635   *r_fd = *r_fd_extra = *r_fd_browser = *r_fd_ssh = -1;
636
637   /* Print a warning if LISTEN_PID does not match outr pid.  */
638   envvar = getenv ("LISTEN_PID");
639   if (!envvar)
640     log_error ("no LISTEN_PID environment variable found in "
641                "--supervised mode (ignoring)\n");
642   else if (strtoul (envvar, NULL, 10) != (unsigned long)getpid ())
643     log_error ("environment variable LISTEN_PID (%lu) does not match"
644                " our pid (%lu) in --supervised mode (ignoring)\n",
645                (unsigned long)strtoul (envvar, NULL, 10),
646                (unsigned long)getpid ());
647
648   /* Parse LISTEN_FDNAMES into the array FDNAMES.  */
649   envvar = getenv ("LISTEN_FDNAMES");
650   if (envvar)
651     {
652       fdnames = strtokenize (envvar, ":");
653       if (!fdnames)
654         {
655           log_error ("strtokenize failed: %s\n",
656                      gpg_strerror (gpg_error_from_syserror ()));
657           agent_exit (1);
658         }
659       for (nfdnames=0; fdnames[nfdnames]; nfdnames++)
660         ;
661     }
662   else
663     {
664       fdnames = NULL;
665       nfdnames = 0;
666     }
667
668   /* Parse LISTEN_FDS into fd_count or provide a replacement.  */
669   envvar = getenv ("LISTEN_FDS");
670   if (envvar)
671     fd_count = atoi (envvar);
672   else if (fdnames)
673     {
674       log_error ("no LISTEN_FDS environment variable found in --supervised"
675                  " mode (relying on LISTEN_FDNAMES instead)\n");
676       fd_count = nfdnames;
677     }
678   else
679     {
680       log_error ("no LISTEN_FDS or LISTEN_FDNAMES environment variables "
681                 "found in --supervised mode"
682                 " (assuming 1 active descriptor)\n");
683       fd_count = 1;
684     }
685
686   if (fd_count < 1)
687     {
688       log_error ("--supervised mode expects at least one file descriptor"
689                  " (was told %d, carrying on as though it were 1)\n",
690                  fd_count);
691       fd_count = 1;
692     }
693
694   /* Assign the descriptors to the return values.  */
695   if (!fdnames)
696     {
697       struct stat statbuf;
698
699       if (fd_count != 1)
700         log_error ("no LISTEN_FDNAMES and LISTEN_FDS (%d) != 1"
701                    " in --supervised mode."
702                    " (ignoring all sockets but the first one)\n",
703                    fd_count);
704       if (fstat (3, &statbuf) == -1 && errno ==EBADF)
705         log_fatal ("file descriptor 3 must be valid in --supervised mode"
706                    " if LISTEN_FDNAMES is not set\n");
707       *r_fd = 3;
708       socket_name = gnupg_get_socket_name (3);
709     }
710   else if (fd_count != nfdnames)
711     {
712       log_fatal ("number of items in LISTEN_FDNAMES (%d) does not match "
713                  "LISTEN_FDS (%d) in --supervised mode\n",
714                  nfdnames, fd_count);
715     }
716   else
717     {
718       int i, j, fd;
719       char *name;
720
721       for (i = 0; i < nfdnames; i++)
722         {
723           for (j = 0; j < DIM (tbl); j++)
724             {
725               if (!strcmp (fdnames[i], tbl[j].label) || j == DIM(tbl)-1)
726                 {
727                   fd = 3 + i;
728                   if (**tbl[j].fdaddr == -1)
729                     {
730                       name = gnupg_get_socket_name (fd);
731                       if (name)
732                         {
733                           **tbl[j].fdaddr = fd;
734                           *tbl[j].nameaddr = name;
735                           log_info ("using fd %d for %s socket (%s)\n",
736                                     fd, tbl[j].label, name);
737                         }
738                       else
739                         {
740                           log_error ("cannot listen on fd %d for %s socket\n",
741                                      fd, tbl[j].label);
742                           close (fd);
743                         }
744                     }
745                   else
746                     {
747                       log_error ("cannot listen on more than one %s socket\n",
748                                  tbl[j].label);
749                       close (fd);
750                     }
751                   break;
752                 }
753             }
754         }
755     }
756
757   xfree (fdnames);
758 }
759 #endif /*!HAVE_W32_SYSTEM*/
760
761
762 /* Cleanup code for this program.  This is either called has an atexit
763    handler or directly.  */
764 static void
765 cleanup (void)
766 {
767   static int done;
768
769   if (done)
770     return;
771   done = 1;
772   deinitialize_module_cache ();
773   if (!is_supervised && !inhibit_socket_removal)
774     {
775       remove_socket (socket_name, redir_socket_name);
776       if (opt.extra_socket > 1)
777         remove_socket (socket_name_extra, redir_socket_name_extra);
778       if (opt.browser_socket > 1)
779         remove_socket (socket_name_browser, redir_socket_name_browser);
780       remove_socket (socket_name_ssh, redir_socket_name_ssh);
781     }
782 }
783
784
785
786 /* Handle options which are allowed to be reset after program start.
787    Return true when the current option in PARGS could be handled and
788    false if not.  As a special feature, passing a value of NULL for
789    PARGS, resets the options to the default.  REREAD should be set
790    true if it is not the initial option parsing. */
791 static int
792 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
793 {
794   int i;
795
796   if (!pargs)
797     { /* reset mode */
798       opt.quiet = 0;
799       opt.verbose = 0;
800       opt.debug = 0;
801       opt.no_grab = 1;
802       opt.debug_pinentry = 0;
803       opt.pinentry_program = NULL;
804       opt.pinentry_touch_file = NULL;
805       xfree (opt.pinentry_invisible_char);
806       opt.pinentry_invisible_char = NULL;
807       opt.pinentry_timeout = 0;
808       opt.scdaemon_program = NULL;
809       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
810       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
811       opt.max_cache_ttl = MAX_CACHE_TTL;
812       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
813       opt.enforce_passphrase_constraints = 0;
814       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
815       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
816       opt.check_passphrase_pattern = NULL;
817       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
818       opt.enable_passphrase_history = 0;
819       opt.enable_extended_key_format = 0;
820       opt.ignore_cache_for_signing = 0;
821       opt.allow_mark_trusted = 1;
822       opt.allow_external_cache = 1;
823       opt.allow_loopback_pinentry = 1;
824       opt.allow_emacs_pinentry = 0;
825       opt.disable_scdaemon = 0;
826       disable_check_own_socket = 0;
827       /* Note: When changing the next line, change also gpgconf_list.  */
828       opt.ssh_fingerprint_digest = GCRY_MD_MD5;
829       opt.s2k_count = 0;
830       return 1;
831     }
832
833   switch (pargs->r_opt)
834     {
835     case oQuiet: opt.quiet = 1; break;
836     case oVerbose: opt.verbose++; break;
837
838     case oDebug:
839       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
840       break;
841     case oDebugAll: opt.debug = ~0; break;
842     case oDebugLevel: debug_level = pargs->r.ret_str; break;
843     case oDebugPinentry: opt.debug_pinentry = 1; break;
844
845     case oLogFile:
846       if (!reread)
847         return 0; /* not handeld */
848       if (!current_logfile || !pargs->r.ret_str
849           || strcmp (current_logfile, pargs->r.ret_str))
850         {
851           log_set_file (pargs->r.ret_str);
852           xfree (current_logfile);
853           current_logfile = xtrystrdup (pargs->r.ret_str);
854         }
855       break;
856
857     case oNoGrab: opt.no_grab |= 1; break;
858     case oGrab: opt.no_grab |= 2; break;
859
860     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
861     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
862     case oPinentryInvisibleChar:
863       xfree (opt.pinentry_invisible_char);
864       opt.pinentry_invisible_char = xtrystrdup (pargs->r.ret_str); break;
865       break;
866     case oPinentryTimeout: opt.pinentry_timeout = pargs->r.ret_ulong; break;
867     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
868     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
869     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
870
871     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
872     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
873     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
874     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
875
876     case oEnforcePassphraseConstraints:
877       opt.enforce_passphrase_constraints=1;
878       break;
879     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
880     case oMinPassphraseNonalpha:
881       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
882       break;
883     case oCheckPassphrasePattern:
884       opt.check_passphrase_pattern = pargs->r.ret_str;
885       break;
886     case oMaxPassphraseDays:
887       opt.max_passphrase_days = pargs->r.ret_ulong;
888       break;
889     case oEnablePassphraseHistory:
890       opt.enable_passphrase_history = 1;
891       break;
892
893     case oEnableExtendedKeyFormat:
894       opt.enable_extended_key_format = 1;
895       break;
896
897     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
898
899     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
900     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
901
902     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
903
904     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
905     case oNoAllowLoopbackPinentry: opt.allow_loopback_pinentry = 0; break;
906
907     case oNoAllowExternalCache: opt.allow_external_cache = 0;
908       break;
909
910     case oAllowEmacsPinentry: opt.allow_emacs_pinentry = 1;
911       break;
912
913     case oSSHFingerprintDigest:
914       i = gcry_md_map_name (pargs->r.ret_str);
915       if (!i)
916         log_error (_("selected digest algorithm is invalid\n"));
917       else
918         opt.ssh_fingerprint_digest = i;
919       break;
920
921     case oS2KCount:
922       opt.s2k_count = pargs->r.ret_ulong;
923       break;
924
925     default:
926       return 0; /* not handled */
927     }
928
929   return 1; /* handled */
930 }
931
932
933 /* Fixup some options after all have been processed.  */
934 static void
935 finalize_rereadable_options (void)
936 {
937   /* Hack to allow --grab to override --no-grab.  */
938   if ((opt.no_grab & 2))
939     opt.no_grab = 0;
940 }
941
942
943 static void
944 thread_init_once (void)
945 {
946   static int npth_initialized = 0;
947
948   if (!npth_initialized)
949     {
950       npth_initialized++;
951       npth_init ();
952     }
953   gpgrt_set_syscall_clamp (npth_unprotect, npth_protect);
954   /* Now that we have set the syscall clamp we need to tell Libgcrypt
955    * that it should get them from libgpg-error.  Note that Libgcrypt
956    * has already been initialized but at that point nPth was not
957    * initialized and thus Libgcrypt could not set its system call
958    * clamp.  */
959 #if GCRYPT_VERSION_NUMBER >= 0x010800 /* 1.8.0 */
960   gcry_control (GCRYCTL_REINIT_SYSCALL_CLAMP, 0, 0);
961 #endif
962 }
963
964
965 static void
966 initialize_modules (void)
967 {
968   thread_init_once ();
969   initialize_module_cache ();
970   initialize_module_call_pinentry ();
971   initialize_module_call_scd ();
972   initialize_module_trustlist ();
973 }
974
975
976 /* The main entry point.  */
977 int
978 main (int argc, char **argv )
979 {
980   ARGPARSE_ARGS pargs;
981   int orig_argc;
982   char **orig_argv;
983   FILE *configfp = NULL;
984   char *configname = NULL;
985   const char *shell;
986   unsigned configlineno;
987   int parse_debug = 0;
988   int default_config =1;
989   int pipe_server = 0;
990   int is_daemon = 0;
991   int nodetach = 0;
992   int csh_style = 0;
993   char *logfile = NULL;
994   int debug_wait = 0;
995   int gpgconf_list = 0;
996   gpg_error_t err;
997   struct assuan_malloc_hooks malloc_hooks;
998
999   early_system_init ();
1000
1001   /* Before we do anything else we save the list of currently open
1002      file descriptors and the signal mask.  This info is required to
1003      do the exec call properly.  We don't need it on Windows.  */
1004 #ifndef HAVE_W32_SYSTEM
1005   startup_fd_list = get_all_open_fds ();
1006 #endif /*!HAVE_W32_SYSTEM*/
1007 #ifdef HAVE_SIGPROCMASK
1008   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
1009     startup_signal_mask_valid = 1;
1010 #endif /*HAVE_SIGPROCMASK*/
1011
1012   /* Set program name etc.  */
1013   set_strusage (my_strusage);
1014   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1015   /* Please note that we may running SUID(ROOT), so be very CAREFUL
1016      when adding any stuff between here and the call to INIT_SECMEM()
1017      somewhere after the option parsing */
1018   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
1019
1020   /* Make sure that our subsystems are ready.  */
1021   i18n_init ();
1022   init_common_subsystems (&argc, &argv);
1023
1024   malloc_hooks.malloc = gcry_malloc;
1025   malloc_hooks.realloc = gcry_realloc;
1026   malloc_hooks.free = gcry_free;
1027   assuan_set_malloc_hooks (&malloc_hooks);
1028   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
1029   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
1030   assuan_sock_init ();
1031   setup_libassuan_logging (&opt.debug, NULL);
1032
1033   setup_libgcrypt_logging ();
1034   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1035   gcry_set_progress_handler (agent_libgcrypt_progress_cb, NULL);
1036
1037   disable_core_dumps ();
1038
1039   /* Set default options.  */
1040   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
1041
1042   shell = getenv ("SHELL");
1043   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
1044     csh_style = 1;
1045
1046   /* Record some of the original environment strings. */
1047   {
1048     const char *s;
1049     int idx;
1050     static const char *names[] =
1051       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
1052
1053     err = 0;
1054     opt.startup_env = session_env_new ();
1055     if (!opt.startup_env)
1056       err = gpg_error_from_syserror ();
1057     for (idx=0; !err && names[idx]; idx++)
1058       {
1059         s = getenv (names[idx]);
1060         if (s)
1061           err = session_env_setenv (opt.startup_env, names[idx], s);
1062       }
1063     if (!err)
1064       {
1065         s = gnupg_ttyname (0);
1066         if (s)
1067           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
1068       }
1069     if (err)
1070       log_fatal ("error recording startup environment: %s\n",
1071                  gpg_strerror (err));
1072
1073     /* Fixme: Better use the locale function here.  */
1074     opt.startup_lc_ctype = getenv ("LC_CTYPE");
1075     if (opt.startup_lc_ctype)
1076       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
1077     opt.startup_lc_messages = getenv ("LC_MESSAGES");
1078     if (opt.startup_lc_messages)
1079       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
1080   }
1081
1082   /* Check whether we have a config file on the commandline */
1083   orig_argc = argc;
1084   orig_argv = argv;
1085   pargs.argc = &argc;
1086   pargs.argv = &argv;
1087   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1088   while (arg_parse( &pargs, opts))
1089     {
1090       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
1091         parse_debug++;
1092       else if (pargs.r_opt == oOptions)
1093         { /* yes there is one, so we do not try the default one, but
1094              read the option file when it is encountered at the
1095              commandline */
1096           default_config = 0;
1097         }
1098         else if (pargs.r_opt == oNoOptions)
1099           default_config = 0; /* --no-options */
1100         else if (pargs.r_opt == oHomedir)
1101           gnupg_set_homedir (pargs.r.ret_str);
1102         else if (pargs.r_opt == oDebugQuickRandom)
1103           {
1104             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1105           }
1106
1107     }
1108
1109   /* Initialize the secure memory. */
1110   gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0);
1111   maybe_setuid = 0;
1112
1113   /*
1114      Now we are now working under our real uid
1115   */
1116
1117   if (default_config)
1118     configname = make_filename (gnupg_homedir (),
1119                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1120
1121   argc = orig_argc;
1122   argv = orig_argv;
1123   pargs.argc = &argc;
1124   pargs.argv = &argv;
1125   pargs.flags=  1;  /* do not remove the args */
1126  next_pass:
1127   if (configname)
1128     {
1129       configlineno = 0;
1130       configfp = fopen (configname, "r");
1131       if (!configfp)
1132         {
1133           if (default_config)
1134             {
1135               if( parse_debug )
1136                 log_info (_("Note: no default option file '%s'\n"),
1137                           configname );
1138               /* Save the default conf file name so that
1139                  reread_configuration is able to test whether the
1140                  config file has been created in the meantime.  */
1141               xfree (config_filename);
1142               config_filename = configname;
1143               configname = NULL;
1144             }
1145           else
1146             {
1147               log_error (_("option file '%s': %s\n"),
1148                          configname, strerror(errno) );
1149               exit(2);
1150             }
1151           xfree (configname);
1152           configname = NULL;
1153         }
1154       if (parse_debug && configname )
1155         log_info (_("reading options from '%s'\n"), configname );
1156       default_config = 0;
1157     }
1158
1159   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
1160     {
1161       if (parse_rereadable_options (&pargs, 0))
1162         continue; /* Already handled */
1163       switch (pargs.r_opt)
1164         {
1165         case aGPGConfList: gpgconf_list = 1; break;
1166         case aGPGConfTest: gpgconf_list = 2; break;
1167         case aUseStandardSocketP: gpgconf_list = 3; break;
1168         case oBatch: opt.batch=1; break;
1169
1170         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1171
1172         case oOptions:
1173           /* config files may not be nested (silently ignore them) */
1174           if (!configfp)
1175             {
1176                 xfree(configname);
1177                 configname = xstrdup(pargs.r.ret_str);
1178                 goto next_pass;
1179             }
1180           break;
1181         case oNoGreeting: /* Dummy option.  */ break;
1182         case oNoVerbose: opt.verbose = 0; break;
1183         case oNoOptions: break; /* no-options */
1184         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
1185         case oNoDetach: nodetach = 1; break;
1186         case oLogFile: logfile = pargs.r.ret_str; break;
1187         case oCsh: csh_style = 1; break;
1188         case oSh: csh_style = 0; break;
1189         case oServer: pipe_server = 1; break;
1190         case oDaemon: is_daemon = 1; break;
1191         case oSupervised: is_supervised = 1; break;
1192
1193         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
1194         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
1195         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
1196         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
1197         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
1198           break;
1199         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
1200           break;
1201
1202         case oUseStandardSocket:
1203         case oNoUseStandardSocket:
1204           obsolete_option (configname, configlineno, "use-standard-socket");
1205           break;
1206
1207         case oFakedSystemTime:
1208           {
1209             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1210             if (faked_time == (time_t)(-1))
1211               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1212             gnupg_set_time (faked_time, 0);
1213           }
1214           break;
1215
1216         case oKeepTTY: opt.keep_tty = 1; break;
1217         case oKeepDISPLAY: opt.keep_display = 1; break;
1218
1219         case oSSHSupport:
1220           ssh_support = 1;
1221           break;
1222
1223         case oPuttySupport:
1224 #        ifdef HAVE_W32_SYSTEM
1225           putty_support = 1;
1226 #        endif
1227           break;
1228
1229         case oExtraSocket:
1230           opt.extra_socket = 1;  /* (1 = points into argv)  */
1231           socket_name_extra = pargs.r.ret_str;
1232           break;
1233
1234         case oBrowserSocket:
1235           opt.browser_socket = 1;  /* (1 = points into argv)  */
1236           socket_name_browser = pargs.r.ret_str;
1237           break;
1238
1239         case oAutoExpandSecmem:
1240           /* Try to enable this option.  It will officially only be
1241            * supported by Libgcrypt 1.9 but 1.8.2 already supports it
1242            * on the quiet and thus we use the numeric value value.  */
1243           gcry_control (78 /*GCRYCTL_AUTO_EXPAND_SECMEM*/,
1244                         (unsigned int)pargs.r.ret_ulong,  0);
1245           break;
1246
1247         case oDebugQuickRandom:
1248           /* Only used by the first stage command line parser.  */
1249           break;
1250
1251         case oWriteEnvFile:
1252           obsolete_option (configname, configlineno, "write-env-file");
1253           break;
1254
1255         default : pargs.err = configfp? 1:2; break;
1256         }
1257     }
1258   if (configfp)
1259     {
1260       fclose( configfp );
1261       configfp = NULL;
1262       /* Keep a copy of the name so that it can be read on SIGHUP. */
1263       if (config_filename != configname)
1264         {
1265           xfree (config_filename);
1266           config_filename = configname;
1267         }
1268       configname = NULL;
1269       goto next_pass;
1270     }
1271
1272   xfree (configname);
1273   configname = NULL;
1274   if (log_get_errorcount(0))
1275     exit(2);
1276
1277   finalize_rereadable_options ();
1278
1279   /* Print a warning if an argument looks like an option.  */
1280   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1281     {
1282       int i;
1283
1284       for (i=0; i < argc; i++)
1285         if (argv[i][0] == '-' && argv[i][1] == '-')
1286           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1287     }
1288
1289 #ifdef ENABLE_NLS
1290   /* gpg-agent usually does not output any messages because it runs in
1291      the background.  For log files it is acceptable to have messages
1292      always encoded in utf-8.  We switch here to utf-8, so that
1293      commands like --help still give native messages.  It is far
1294      easier to switch only once instead of for every message and it
1295      actually helps when more then one thread is active (avoids an
1296      extra copy step). */
1297     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1298 #endif
1299
1300   if (!pipe_server && !is_daemon && !gpgconf_list && !is_supervised)
1301     {
1302      /* We have been called without any command and thus we merely
1303         check whether an agent is already running.  We do this right
1304         here so that we don't clobber a logfile with this check but
1305         print the status directly to stderr. */
1306       opt.debug = 0;
1307       set_debug ();
1308       check_for_running_agent (0);
1309       agent_exit (0);
1310     }
1311
1312   if (is_supervised)
1313     ;
1314   else if (!opt.extra_socket)
1315     opt.extra_socket = 1;
1316   else if (socket_name_extra
1317            && (!strcmp (socket_name_extra, "none")
1318                || !strcmp (socket_name_extra, "/dev/null")))
1319     {
1320       /* User requested not to create this socket.  */
1321       opt.extra_socket = 0;
1322       socket_name_extra = NULL;
1323     }
1324
1325   if (is_supervised)
1326     ;
1327   else if (!opt.browser_socket)
1328     opt.browser_socket = 1;
1329   else if (socket_name_browser
1330            && (!strcmp (socket_name_browser, "none")
1331                || !strcmp (socket_name_browser, "/dev/null")))
1332     {
1333       /* User requested not to create this socket.  */
1334       opt.browser_socket = 0;
1335       socket_name_browser = NULL;
1336     }
1337
1338   set_debug ();
1339
1340   if (atexit (cleanup))
1341     {
1342       log_error ("atexit failed\n");
1343       cleanup ();
1344       exit (1);
1345     }
1346
1347   /* Try to create missing directories. */
1348   create_directories ();
1349
1350   if (debug_wait && pipe_server)
1351     {
1352       thread_init_once ();
1353       log_debug ("waiting for debugger - my pid is %u .....\n",
1354                  (unsigned int)getpid());
1355       gnupg_sleep (debug_wait);
1356       log_debug ("... okay\n");
1357     }
1358
1359   if (gpgconf_list == 3)
1360     {
1361       /* We now use the standard socket always - return true for
1362          backward compatibility.  */
1363       agent_exit (0);
1364     }
1365   else if (gpgconf_list == 2)
1366     agent_exit (0);
1367   else if (gpgconf_list)
1368     {
1369       char *filename;
1370       char *filename_esc;
1371
1372       /* List options and default values in the GPG Conf format.  */
1373       filename = make_filename (gnupg_homedir (),
1374                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1375       filename_esc = percent_escape (filename, NULL);
1376
1377       es_printf ("%s-%s.conf:%lu:\"%s\n",
1378                  GPGCONF_NAME, GPG_AGENT_NAME,
1379                  GC_OPT_FLAG_DEFAULT, filename_esc);
1380       xfree (filename);
1381       xfree (filename_esc);
1382
1383       es_printf ("verbose:%lu:\n"
1384               "quiet:%lu:\n"
1385               "debug-level:%lu:\"none:\n"
1386               "log-file:%lu:\n",
1387               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1388               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1389               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1390               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1391       es_printf ("default-cache-ttl:%lu:%d:\n",
1392               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1393       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1394               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1395       es_printf ("max-cache-ttl:%lu:%d:\n",
1396               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1397       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1398               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1399       es_printf ("enforce-passphrase-constraints:%lu:\n",
1400               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1401       es_printf ("min-passphrase-len:%lu:%d:\n",
1402               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1403       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1404               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1405               MIN_PASSPHRASE_NONALPHA);
1406       es_printf ("check-passphrase-pattern:%lu:\n",
1407               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1408       es_printf ("max-passphrase-days:%lu:%d:\n",
1409               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1410               MAX_PASSPHRASE_DAYS);
1411       es_printf ("enable-passphrase-history:%lu:\n",
1412               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1413       es_printf ("no-grab:%lu:\n",
1414               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1415       es_printf ("ignore-cache-for-signing:%lu:\n",
1416               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1417       es_printf ("no-allow-external-cache:%lu:\n",
1418               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1419       es_printf ("no-allow-mark-trusted:%lu:\n",
1420               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1421       es_printf ("disable-scdaemon:%lu:\n",
1422               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1423       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1424       es_printf ("ssh-fingerprint-digest:%lu:\"%s:\n",
1425                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, "md5");
1426 #ifdef HAVE_W32_SYSTEM
1427       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1428 #endif
1429       es_printf ("no-allow-loopback-pinentry:%lu:\n",
1430               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1431       es_printf ("allow-emacs-pinentry:%lu:\n",
1432                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1433       es_printf ("pinentry-timeout:%lu:0:\n",
1434                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1435       es_printf ("enable-extended-key-format:%lu:\n",
1436                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1437       es_printf ("grab:%lu:\n",
1438                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1439
1440       agent_exit (0);
1441     }
1442
1443   /* Now start with logging to a file if this is desired. */
1444   if (logfile)
1445     {
1446       log_set_file (logfile);
1447       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1448                              | GPGRT_LOG_WITH_TIME
1449                              | GPGRT_LOG_WITH_PID));
1450       current_logfile = xstrdup (logfile);
1451     }
1452
1453   /* Make sure that we have a default ttyname. */
1454   if (!default_ttyname && gnupg_ttyname (1))
1455     default_ttyname = xstrdup (gnupg_ttyname (1));
1456   if (!default_ttytype && getenv ("TERM"))
1457     default_ttytype = xstrdup (getenv ("TERM"));
1458
1459
1460   if (pipe_server)
1461     {
1462       /* This is the simple pipe based server */
1463       ctrl_t ctrl;
1464
1465       initialize_modules ();
1466
1467       ctrl = xtrycalloc (1, sizeof *ctrl);
1468       if (!ctrl)
1469         {
1470           log_error ("error allocating connection control data: %s\n",
1471                      strerror (errno) );
1472           agent_exit (1);
1473         }
1474       ctrl->session_env = session_env_new ();
1475       if (!ctrl->session_env)
1476         {
1477           log_error ("error allocating session environment block: %s\n",
1478                      strerror (errno) );
1479           xfree (ctrl);
1480           agent_exit (1);
1481         }
1482       agent_init_default_ctrl (ctrl);
1483       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1484       agent_deinit_default_ctrl (ctrl);
1485       xfree (ctrl);
1486     }
1487   else if (is_supervised)
1488     {
1489 #ifndef HAVE_W32_SYSTEM
1490       gnupg_fd_t fd, fd_extra, fd_browser, fd_ssh;
1491
1492       initialize_modules ();
1493
1494       /* when supervised and sending logs to stderr, the process
1495          supervisor should handle log entry metadata (pid, name,
1496          timestamp) */
1497       if (!logfile)
1498         log_set_prefix (NULL, 0);
1499
1500       log_info ("%s %s starting in supervised mode.\n",
1501                 strusage(11), strusage(13) );
1502
1503       /* See below in "regular server mode" on why we remove certain
1504        * envvars.  */
1505       if (!opt.keep_display)
1506         gnupg_unsetenv ("DISPLAY");
1507       gnupg_unsetenv ("INSIDE_EMACS");
1508
1509       /* Virtually create the sockets.  Note that we use -1 here
1510        * because the whole thing works only on Unix. */
1511       map_supervised_sockets (&fd, &fd_extra, &fd_browser, &fd_ssh);
1512       if (fd == -1)
1513         log_fatal ("no standard socket provided\n");
1514
1515 #ifdef HAVE_SIGPROCMASK
1516       if (startup_signal_mask_valid)
1517         {
1518           if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1519             log_error ("error restoring signal mask: %s\n",
1520                        strerror (errno));
1521         }
1522       else
1523         log_info ("no saved signal mask\n");
1524 #endif /*HAVE_SIGPROCMASK*/
1525
1526       log_info ("listening on: std=%d extra=%d browser=%d ssh=%d\n",
1527                 fd, fd_extra, fd_browser, fd_ssh);
1528       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1529 #endif /*!HAVE_W32_SYSTEM*/
1530     }
1531   else if (!is_daemon)
1532     ; /* NOTREACHED */
1533   else
1534     { /* Regular server mode */
1535       gnupg_fd_t fd;
1536       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1537       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1538       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1539 #ifndef HAVE_W32_SYSTEM
1540       pid_t pid;
1541 #endif
1542
1543       /* Remove the DISPLAY variable so that a pinentry does not
1544          default to a specific display.  There is still a default
1545          display when gpg-agent was started using --display or a
1546          client requested this using an OPTION command.  Note, that we
1547          don't do this when running in reverse daemon mode (i.e. when
1548          exec the program given as arguments). */
1549 #ifndef HAVE_W32_SYSTEM
1550       if (!opt.keep_display && !argc)
1551         gnupg_unsetenv ("DISPLAY");
1552 #endif
1553
1554       /* Remove the INSIDE_EMACS variable so that a pinentry does not
1555          always try to interact with Emacs.  The variable is set when
1556          a client requested this using an OPTION command.  */
1557       gnupg_unsetenv ("INSIDE_EMACS");
1558
1559       /* Create the sockets.  */
1560       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1561       fd = create_server_socket (socket_name, 1, 0,
1562                                  &redir_socket_name, &socket_nonce);
1563
1564       if (opt.extra_socket)
1565         {
1566           if (socket_name_extra)
1567             socket_name_extra = create_socket_name (socket_name_extra, 0);
1568           else
1569             socket_name_extra = create_socket_name
1570               /**/                (GPG_AGENT_EXTRA_SOCK_NAME, 1);
1571           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1572           fd_extra = create_server_socket (socket_name_extra, 0, 0,
1573                                            &redir_socket_name_extra,
1574                                            &socket_nonce_extra);
1575         }
1576
1577       if (opt.browser_socket)
1578         {
1579           if (socket_name_browser)
1580             socket_name_browser = create_socket_name (socket_name_browser, 0);
1581           else
1582             socket_name_browser= create_socket_name
1583               /**/                 (GPG_AGENT_BROWSER_SOCK_NAME, 1);
1584           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1585           fd_browser = create_server_socket (socket_name_browser, 0, 0,
1586                                              &redir_socket_name_browser,
1587                                              &socket_nonce_browser);
1588         }
1589
1590       socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1591       fd_ssh = create_server_socket (socket_name_ssh, 0, 1,
1592                                      &redir_socket_name_ssh,
1593                                      &socket_nonce_ssh);
1594
1595       /* If we are going to exec a program in the parent, we record
1596          the PID, so that the child may check whether the program is
1597          still alive. */
1598       if (argc)
1599         parent_pid = getpid ();
1600
1601       fflush (NULL);
1602
1603 #ifdef HAVE_W32_SYSTEM
1604
1605       (void)csh_style;
1606       (void)nodetach;
1607       initialize_modules ();
1608
1609 #else /*!HAVE_W32_SYSTEM*/
1610
1611       pid = fork ();
1612       if (pid == (pid_t)-1)
1613         {
1614           log_fatal ("fork failed: %s\n", strerror (errno) );
1615           exit (1);
1616         }
1617       else if (pid)
1618         { /* We are the parent */
1619           char *infostr_ssh_sock, *infostr_ssh_valid;
1620
1621           /* Close the socket FD. */
1622           close (fd);
1623
1624           /* The signal mask might not be correct right now and thus
1625              we restore it.  That is not strictly necessary but some
1626              programs falsely assume a cleared signal mask.  */
1627
1628 #ifdef HAVE_SIGPROCMASK
1629           if (startup_signal_mask_valid)
1630             {
1631               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1632                 log_error ("error restoring signal mask: %s\n",
1633                            strerror (errno));
1634             }
1635           else
1636             log_info ("no saved signal mask\n");
1637 #endif /*HAVE_SIGPROCMASK*/
1638
1639           /* Create the SSH info string if enabled. */
1640           if (ssh_support)
1641             {
1642               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1643                             socket_name_ssh) < 0)
1644                 {
1645                   log_error ("out of core\n");
1646                   kill (pid, SIGTERM);
1647                   exit (1);
1648                 }
1649               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1650                             (unsigned long)getpid()) < 0)
1651                 {
1652                   log_error ("out of core\n");
1653                   kill (pid, SIGTERM);
1654                   exit (1);
1655                 }
1656             }
1657
1658           *socket_name = 0; /* Don't let cleanup() remove the socket -
1659                                the child should do this from now on */
1660           if (opt.extra_socket)
1661             *socket_name_extra = 0;
1662           if (opt.browser_socket)
1663             *socket_name_browser = 0;
1664           *socket_name_ssh = 0;
1665
1666           if (argc)
1667             { /* Run the program given on the commandline.  */
1668               if (ssh_support && (putenv (infostr_ssh_sock)
1669                                   || putenv (infostr_ssh_valid)))
1670                 {
1671                   log_error ("failed to set environment: %s\n",
1672                              strerror (errno) );
1673                   kill (pid, SIGTERM );
1674                   exit (1);
1675                 }
1676
1677               /* Close all the file descriptors except the standard
1678                  ones and those open at startup.  We explicitly don't
1679                  close 0,1,2 in case something went wrong collecting
1680                  them at startup.  */
1681               close_all_fds (3, startup_fd_list);
1682
1683               /* Run the command.  */
1684               execvp (argv[0], argv);
1685               log_error ("failed to run the command: %s\n", strerror (errno));
1686               kill (pid, SIGTERM);
1687               exit (1);
1688             }
1689           else
1690             {
1691               /* Print the environment string, so that the caller can use
1692                  shell's eval to set it */
1693               if (csh_style)
1694                 {
1695                   if (ssh_support)
1696                     {
1697                       *strchr (infostr_ssh_sock, '=') = ' ';
1698                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1699                     }
1700                 }
1701               else
1702                 {
1703                   if (ssh_support)
1704                     {
1705                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1706                                  infostr_ssh_sock);
1707                     }
1708                 }
1709               if (ssh_support)
1710                 {
1711                   xfree (infostr_ssh_sock);
1712                   xfree (infostr_ssh_valid);
1713                 }
1714               exit (0);
1715             }
1716           /*NOTREACHED*/
1717         } /* End parent */
1718
1719       /*
1720          This is the child
1721        */
1722
1723       initialize_modules ();
1724
1725       /* Detach from tty and put process into a new session */
1726       if (!nodetach )
1727         {
1728           int i;
1729           unsigned int oldflags;
1730
1731           /* Close stdin, stdout and stderr unless it is the log stream */
1732           for (i=0; i <= 2; i++)
1733             {
1734               if (!log_test_fd (i) && i != fd )
1735                 {
1736                   if ( ! close (i)
1737                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1738                     {
1739                       log_error ("failed to open '%s': %s\n",
1740                                  "/dev/null", strerror (errno));
1741                       cleanup ();
1742                       exit (1);
1743                     }
1744                 }
1745             }
1746           if (setsid() == -1)
1747             {
1748               log_error ("setsid() failed: %s\n", strerror(errno) );
1749               cleanup ();
1750               exit (1);
1751             }
1752
1753           log_get_prefix (&oldflags);
1754           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1755           opt.running_detached = 1;
1756
1757           /* Unless we are running with a program given on the command
1758            * line we can assume that the inotify things works and thus
1759            * we can avoid tye regular stat calls.  */
1760           if (!argc)
1761             reliable_homedir_inotify = 1;
1762         }
1763
1764       {
1765         struct sigaction sa;
1766
1767         sa.sa_handler = SIG_IGN;
1768         sigemptyset (&sa.sa_mask);
1769         sa.sa_flags = 0;
1770         sigaction (SIGPIPE, &sa, NULL);
1771       }
1772 #endif /*!HAVE_W32_SYSTEM*/
1773
1774       if (gnupg_chdir (gnupg_daemon_rootdir ()))
1775         {
1776           log_error ("chdir to '%s' failed: %s\n",
1777                      gnupg_daemon_rootdir (), strerror (errno));
1778           exit (1);
1779         }
1780
1781       log_info ("%s %s started\n", strusage(11), strusage(13) );
1782       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1783       assuan_sock_close (fd);
1784     }
1785
1786   return 0;
1787 }
1788
1789
1790 /* Exit entry point.  This function should be called instead of a
1791    plain exit.  */
1792 void
1793 agent_exit (int rc)
1794 {
1795   /*FIXME: update_random_seed_file();*/
1796
1797   /* We run our cleanup handler because that may close cipher contexts
1798      stored in secure memory and thus this needs to be done before we
1799      explicitly terminate secure memory.  */
1800   cleanup ();
1801
1802 #if 1
1803   /* at this time a bit annoying */
1804   if (opt.debug & DBG_MEMSTAT_VALUE)
1805     {
1806       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1807       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1808     }
1809   if (opt.debug)
1810     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1811 #endif
1812   gcry_control (GCRYCTL_TERM_SECMEM );
1813   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1814   exit (rc);
1815 }
1816
1817
1818 /* This is our callback function for gcrypt progress messages.  It is
1819    set once at startup and dispatches progress messages to the
1820    corresponding threads of the agent.  */
1821 static void
1822 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1823                              int current, int total)
1824 {
1825   struct progress_dispatch_s *dispatch;
1826   npth_t mytid = npth_self ();
1827
1828   (void)data;
1829
1830   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1831     if (dispatch->ctrl && dispatch->tid == mytid)
1832       break;
1833   if (dispatch && dispatch->cb)
1834     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1835
1836   /* Libgcrypt < 1.8 does not know about nPth and thus when it reads
1837    * from /dev/random this will block the process.  To mitigate this
1838    * problem we yield the thread when Libgcrypt tells us that it needs
1839    * more entropy.  This way other threads have chance to run.  */
1840 #if GCRYPT_VERSION_NUMBER < 0x010800 /* 1.8.0 */
1841   if (what && !strcmp (what, "need_entropy"))
1842     {
1843 #if GPGRT_VERSION_NUMBER < 0x011900 /* 1.25 */
1844       /* In older gpg-error versions gpgrt_yield is buggy for use with
1845        * nPth and thus we need to resort to a sleep call.  */
1846       npth_usleep (1000); /* 1ms */
1847 #else
1848       gpgrt_yield ();
1849 #endif
1850     }
1851 #endif
1852 }
1853
1854
1855 /* If a progress dispatcher callback has been associated with the
1856  * current connection unregister it.  */
1857 static void
1858 unregister_progress_cb (void)
1859 {
1860   struct progress_dispatch_s *dispatch;
1861   npth_t mytid = npth_self ();
1862
1863   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1864     if (dispatch->ctrl && dispatch->tid == mytid)
1865       break;
1866   if (dispatch)
1867     {
1868       dispatch->ctrl = NULL;
1869       dispatch->cb = NULL;
1870     }
1871 }
1872
1873
1874 /* Setup a progress callback CB for the current connection.  Using a
1875  * CB of NULL disables the callback.  */
1876 void
1877 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1878                                   int printchar, int current, int total),
1879                        ctrl_t ctrl)
1880 {
1881   struct progress_dispatch_s *dispatch, *firstfree;
1882   npth_t mytid = npth_self ();
1883
1884   firstfree = NULL;
1885   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1886     {
1887       if (dispatch->ctrl && dispatch->tid == mytid)
1888         break;
1889       if (!dispatch->ctrl && !firstfree)
1890         firstfree = dispatch;
1891     }
1892   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1893     {
1894       if (firstfree)
1895         {
1896           dispatch = firstfree;
1897         }
1898       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1899         {
1900           dispatch->next = progress_dispatch_list;
1901           progress_dispatch_list = dispatch;
1902         }
1903       else
1904         {
1905           log_error ("error allocating new progress dispatcher slot: %s\n",
1906                      gpg_strerror (gpg_error_from_syserror ()));
1907           return;
1908         }
1909       dispatch->ctrl = ctrl;
1910       dispatch->tid = mytid;
1911     }
1912
1913   dispatch->cb = cb;
1914 }
1915
1916
1917 /* Each thread has its own local variables conveyed by a control
1918    structure usually identified by an argument named CTRL.  This
1919    function is called immediately after allocating the control
1920    structure.  Its purpose is to setup the default values for that
1921    structure.  Note that some values may have already been set.  */
1922 static void
1923 agent_init_default_ctrl (ctrl_t ctrl)
1924 {
1925   assert (ctrl->session_env);
1926
1927   /* Note we ignore malloc errors because we can't do much about it
1928      and the request will fail anyway shortly after this
1929      initialization. */
1930   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1931   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1932   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1933   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1934   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1935
1936   if (ctrl->lc_ctype)
1937     xfree (ctrl->lc_ctype);
1938   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1939
1940   if (ctrl->lc_messages)
1941     xfree (ctrl->lc_messages);
1942   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1943                                     /**/ : NULL;
1944   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1945 }
1946
1947
1948 /* Release all resources allocated by default in the control
1949    structure.  This is the counterpart to agent_init_default_ctrl.  */
1950 static void
1951 agent_deinit_default_ctrl (ctrl_t ctrl)
1952 {
1953   unregister_progress_cb ();
1954   session_env_release (ctrl->session_env);
1955
1956   if (ctrl->lc_ctype)
1957     xfree (ctrl->lc_ctype);
1958   if (ctrl->lc_messages)
1959     xfree (ctrl->lc_messages);
1960 }
1961
1962
1963 /* Because the ssh protocol does not send us information about the
1964    current TTY setting, we use this function to use those from startup
1965    or those explicitly set.  This is also used for the restricted mode
1966    where we ignore requests to change the environment.  */
1967 gpg_error_t
1968 agent_copy_startup_env (ctrl_t ctrl)
1969 {
1970   static const char *names[] =
1971     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1972   gpg_error_t err = 0;
1973   int idx;
1974   const char *value;
1975
1976   for (idx=0; !err && names[idx]; idx++)
1977     if ((value = session_env_getenv (opt.startup_env, names[idx])))
1978       err = session_env_setenv (ctrl->session_env, names[idx], value);
1979
1980   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1981     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1982       err = gpg_error_from_syserror ();
1983
1984   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1985     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1986       err = gpg_error_from_syserror ();
1987
1988   if (err)
1989     log_error ("error setting default session environment: %s\n",
1990                gpg_strerror (err));
1991
1992   return err;
1993 }
1994
1995
1996 /* Reread parts of the configuration.  Note, that this function is
1997    obviously not thread-safe and should only be called from the PTH
1998    signal handler.
1999
2000    Fixme: Due to the way the argument parsing works, we create a
2001    memory leak here for all string type arguments.  There is currently
2002    no clean way to tell whether the memory for the argument has been
2003    allocated or points into the process' original arguments.  Unless
2004    we have a mechanism to tell this, we need to live on with this. */
2005 static void
2006 reread_configuration (void)
2007 {
2008   ARGPARSE_ARGS pargs;
2009   FILE *fp;
2010   unsigned int configlineno = 0;
2011   int dummy;
2012
2013   if (!config_filename)
2014     return; /* No config file. */
2015
2016   fp = fopen (config_filename, "r");
2017   if (!fp)
2018     {
2019       log_info (_("option file '%s': %s\n"),
2020                 config_filename, strerror(errno) );
2021       return;
2022     }
2023
2024   parse_rereadable_options (NULL, 1); /* Start from the default values. */
2025
2026   memset (&pargs, 0, sizeof pargs);
2027   dummy = 0;
2028   pargs.argc = &dummy;
2029   pargs.flags = 1;  /* do not remove the args */
2030   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
2031     {
2032       if (pargs.r_opt < -1)
2033         pargs.err = 1; /* Print a warning. */
2034       else /* Try to parse this option - ignore unchangeable ones. */
2035         parse_rereadable_options (&pargs, 1);
2036     }
2037   fclose (fp);
2038   finalize_rereadable_options ();
2039   set_debug ();
2040 }
2041
2042
2043 /* Return the file name of the socket we are using for native
2044    requests.  */
2045 const char *
2046 get_agent_socket_name (void)
2047 {
2048   const char *s = socket_name;
2049
2050   return (s && *s)? s : NULL;
2051 }
2052
2053 /* Return the file name of the socket we are using for SSH
2054    requests.  */
2055 const char *
2056 get_agent_ssh_socket_name (void)
2057 {
2058   const char *s = socket_name_ssh;
2059
2060   return (s && *s)? s : NULL;
2061 }
2062
2063
2064 /* Return the number of active connections. */
2065 int
2066 get_agent_active_connection_count (void)
2067 {
2068   return active_connections;
2069 }
2070
2071
2072 /* Under W32, this function returns the handle of the scdaemon
2073    notification event.  Calling it the first time creates that
2074    event.  */
2075 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
2076 void *
2077 get_agent_scd_notify_event (void)
2078 {
2079   static HANDLE the_event = INVALID_HANDLE_VALUE;
2080
2081   if (the_event == INVALID_HANDLE_VALUE)
2082     {
2083       HANDLE h, h2;
2084       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2085
2086       /* We need to use a manual reset event object due to the way our
2087          w32-pth wait function works: If we would use an automatic
2088          reset event we are not able to figure out which handle has
2089          been signaled because at the time we single out the signaled
2090          handles using WFSO the event has already been reset due to
2091          the WFMO.  */
2092       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2093       if (!h)
2094         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2095       else if (!DuplicateHandle (GetCurrentProcess(), h,
2096                                  GetCurrentProcess(), &h2,
2097                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2098         {
2099           log_error ("setting syncronize for scd notify event failed: %s\n",
2100                      w32_strerror (-1) );
2101           CloseHandle (h);
2102         }
2103       else
2104         {
2105           CloseHandle (h);
2106           the_event = h2;
2107         }
2108     }
2109
2110   return the_event;
2111 }
2112 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2113
2114
2115
2116 /* Create a name for the socket in the home directory as using
2117    STANDARD_NAME.  We also check for valid characters as well as
2118    against a maximum allowed length for a unix domain socket is done.
2119    The function terminates the process in case of an error.  Returns:
2120    Pointer to an allocated string with the absolute name of the socket
2121    used.  */
2122 static char *
2123 create_socket_name (char *standard_name, int with_homedir)
2124 {
2125   char *name;
2126
2127   if (with_homedir)
2128     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2129   else
2130     name = make_filename (standard_name, NULL);
2131   if (strchr (name, PATHSEP_C))
2132     {
2133       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2134       agent_exit (2);
2135     }
2136   return name;
2137 }
2138
2139
2140
2141 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2142    or terminates the process in case of an error.  Note that this
2143    function needs to be used for the regular socket first (indicated
2144    by PRIMARY) and only then for the extra and the ssh sockets.  If
2145    the socket has been redirected the name of the real socket is
2146    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2147    Cygwin compatible socket is created (Windows only). */
2148 static gnupg_fd_t
2149 create_server_socket (char *name, int primary, int cygwin,
2150                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2151 {
2152   struct sockaddr *addr;
2153   struct sockaddr_un *unaddr;
2154   socklen_t len;
2155   gnupg_fd_t fd;
2156   int rc;
2157
2158   xfree (*r_redir_name);
2159   *r_redir_name = NULL;
2160
2161   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2162   if (fd == ASSUAN_INVALID_FD)
2163     {
2164       log_error (_("can't create socket: %s\n"), strerror (errno));
2165       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2166       agent_exit (2);
2167     }
2168
2169   if (cygwin)
2170     assuan_sock_set_flag (fd, "cygwin", 1);
2171
2172   unaddr = xmalloc (sizeof *unaddr);
2173   addr = (struct sockaddr*)unaddr;
2174
2175   {
2176     int redirected;
2177
2178     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2179       {
2180         if (errno == ENAMETOOLONG)
2181           log_error (_("socket name '%s' is too long\n"), name);
2182         else
2183           log_error ("error preparing socket '%s': %s\n",
2184                      name, gpg_strerror (gpg_error_from_syserror ()));
2185         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2186         xfree (unaddr);
2187         agent_exit (2);
2188       }
2189     if (redirected)
2190       {
2191         *r_redir_name = xstrdup (unaddr->sun_path);
2192         if (opt.verbose)
2193           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2194       }
2195   }
2196
2197   len = SUN_LEN (unaddr);
2198   rc = assuan_sock_bind (fd, addr, len);
2199
2200   /* Our error code mapping on W32CE returns EEXIST thus we also test
2201      for this. */
2202   if (rc == -1
2203       && (errno == EADDRINUSE
2204 #ifdef HAVE_W32_SYSTEM
2205           || errno == EEXIST
2206 #endif
2207           ))
2208     {
2209       /* Check whether a gpg-agent is already running.  We do this
2210          test only if this is the primary socket.  For secondary
2211          sockets we assume that a test for gpg-agent has already been
2212          done and reuse the requested socket.  Testing the ssh-socket
2213          is not possible because at this point, though we know the new
2214          Assuan socket, the Assuan server and thus the ssh-agent
2215          server is not yet operational; this would lead to a hang.  */
2216       if (primary && !check_for_running_agent (1))
2217         {
2218           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2219           log_set_file (NULL);
2220           log_error (_("a gpg-agent is already running - "
2221                        "not starting a new one\n"));
2222           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2223           assuan_sock_close (fd);
2224           xfree (unaddr);
2225           agent_exit (2);
2226         }
2227       gnupg_remove (unaddr->sun_path);
2228       rc = assuan_sock_bind (fd, addr, len);
2229     }
2230   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2231     log_error (_("error getting nonce for the socket\n"));
2232   if (rc == -1)
2233     {
2234       /* We use gpg_strerror here because it allows us to get strings
2235          for some W32 socket error codes.  */
2236       log_error (_("error binding socket to '%s': %s\n"),
2237                  unaddr->sun_path,
2238                  gpg_strerror (gpg_error_from_syserror ()));
2239
2240       assuan_sock_close (fd);
2241       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2242       xfree (unaddr);
2243       agent_exit (2);
2244     }
2245
2246   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2247     log_error (_("can't set permissions of '%s': %s\n"),
2248                unaddr->sun_path, strerror (errno));
2249
2250   if (listen (FD2INT(fd), 5 ) == -1)
2251     {
2252       log_error (_("listen() failed: %s\n"), strerror (errno));
2253       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2254       assuan_sock_close (fd);
2255       xfree (unaddr);
2256       agent_exit (2);
2257     }
2258
2259   if (opt.verbose)
2260     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2261
2262   xfree (unaddr);
2263   return fd;
2264 }
2265
2266
2267 /* Check that the directory for storing the private keys exists and
2268    create it if not.  This function won't fail as it is only a
2269    convenience function and not strictly necessary.  */
2270 static void
2271 create_private_keys_directory (const char *home)
2272 {
2273   char *fname;
2274   struct stat statbuf;
2275
2276   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2277   if (stat (fname, &statbuf) && errno == ENOENT)
2278     {
2279       if (gnupg_mkdir (fname, "-rwx"))
2280         log_error (_("can't create directory '%s': %s\n"),
2281                    fname, strerror (errno) );
2282       else if (!opt.quiet)
2283         log_info (_("directory '%s' created\n"), fname);
2284     }
2285   if (gnupg_chmod (fname, "-rwx"))
2286     log_error (_("can't set permissions of '%s': %s\n"),
2287                fname, strerror (errno));
2288   xfree (fname);
2289 }
2290
2291
2292 /* Create the directory only if the supplied directory name is the
2293    same as the default one.  This way we avoid to create arbitrary
2294    directories when a non-default home directory is used.  To cope
2295    with HOME, we compare only the suffix if we see that the default
2296    homedir does start with a tilde.  We don't stop here in case of
2297    problems because other functions will throw an error anyway.*/
2298 static void
2299 create_directories (void)
2300 {
2301   struct stat statbuf;
2302   const char *defhome = standard_homedir ();
2303   char *home;
2304
2305   home = make_filename (gnupg_homedir (), NULL);
2306   if ( stat (home, &statbuf) )
2307     {
2308       if (errno == ENOENT)
2309         {
2310           if (
2311 #ifdef HAVE_W32_SYSTEM
2312               ( !compare_filenames (home, defhome) )
2313 #else
2314               (*defhome == '~'
2315                 && (strlen (home) >= strlen (defhome+1)
2316                     && !strcmp (home + strlen(home)
2317                                 - strlen (defhome+1), defhome+1)))
2318                || (*defhome != '~' && !strcmp (home, defhome) )
2319 #endif
2320                )
2321             {
2322               if (gnupg_mkdir (home, "-rwx"))
2323                 log_error (_("can't create directory '%s': %s\n"),
2324                            home, strerror (errno) );
2325               else
2326                 {
2327                   if (!opt.quiet)
2328                     log_info (_("directory '%s' created\n"), home);
2329                   create_private_keys_directory (home);
2330                 }
2331             }
2332         }
2333       else
2334         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2335     }
2336   else if ( !S_ISDIR(statbuf.st_mode))
2337     {
2338       log_error (_("can't use '%s' as home directory\n"), home);
2339     }
2340   else /* exists and is a directory. */
2341     {
2342       create_private_keys_directory (home);
2343     }
2344   xfree (home);
2345 }
2346
2347
2348
2349 /* This is the worker for the ticker.  It is called every few seconds
2350    and may only do fast operations. */
2351 static void
2352 handle_tick (void)
2353 {
2354   static time_t last_minute;
2355   struct stat statbuf;
2356
2357   if (!last_minute)
2358     last_minute = time (NULL);
2359
2360   /* Check whether the scdaemon has died and cleanup in this case. */
2361   agent_scd_check_aliveness ();
2362
2363   /* If we are running as a child of another process, check whether
2364      the parent is still alive and shutdown if not. */
2365 #ifndef HAVE_W32_SYSTEM
2366   if (parent_pid != (pid_t)(-1))
2367     {
2368       if (kill (parent_pid, 0))
2369         {
2370           shutdown_pending = 2;
2371           log_info ("parent process died - shutting down\n");
2372           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2373           cleanup ();
2374           agent_exit (0);
2375         }
2376     }
2377 #endif /*HAVE_W32_SYSTEM*/
2378
2379   /* Code to be run from time to time.  */
2380 #if CHECK_OWN_SOCKET_INTERVAL > 0
2381   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
2382     {
2383       check_own_socket ();
2384       last_minute = time (NULL);
2385     }
2386 #endif
2387
2388   /* Check whether the homedir is still available.  */
2389   if (!shutdown_pending
2390       && (!have_homedir_inotify || !reliable_homedir_inotify)
2391       && stat (gnupg_homedir (), &statbuf) && errno == ENOENT)
2392     {
2393       shutdown_pending = 1;
2394       log_info ("homedir has been removed - shutting down\n");
2395     }
2396 }
2397
2398
2399 /* A global function which allows us to call the reload stuff from
2400    other places too.  This is only used when build for W32.  */
2401 void
2402 agent_sighup_action (void)
2403 {
2404   log_info ("SIGHUP received - "
2405             "re-reading configuration and flushing cache\n");
2406
2407   agent_flush_cache ();
2408   reread_configuration ();
2409   agent_reload_trustlist ();
2410   /* We flush the module name cache so that after installing a
2411      "pinentry" binary that one can be used in case the
2412      "pinentry-basic" fallback was in use.  */
2413   gnupg_module_name_flush_some ();
2414 }
2415
2416
2417 /* A helper function to handle SIGUSR2.  */
2418 static void
2419 agent_sigusr2_action (void)
2420 {
2421   if (opt.verbose)
2422     log_info ("SIGUSR2 received - updating card event counter\n");
2423   /* Nothing to check right now.  We only increment a counter.  */
2424   bump_card_eventcounter ();
2425 }
2426
2427
2428 #ifndef HAVE_W32_SYSTEM
2429 /* The signal handler for this program.  It is expected to be run in
2430    its own thread and not in the context of a signal handler.  */
2431 static void
2432 handle_signal (int signo)
2433 {
2434   switch (signo)
2435     {
2436 #ifndef HAVE_W32_SYSTEM
2437     case SIGHUP:
2438       agent_sighup_action ();
2439       break;
2440
2441     case SIGUSR1:
2442       log_info ("SIGUSR1 received - printing internal information:\n");
2443       /* Fixme: We need to see how to integrate pth dumping into our
2444          logging system.  */
2445       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2446       agent_query_dump_state ();
2447       agent_scd_dump_state ();
2448       break;
2449
2450     case SIGUSR2:
2451       agent_sigusr2_action ();
2452       break;
2453
2454     case SIGTERM:
2455       if (!shutdown_pending)
2456         log_info ("SIGTERM received - shutting down ...\n");
2457       else
2458         log_info ("SIGTERM received - still %i open connections\n",
2459                   active_connections);
2460       shutdown_pending++;
2461       if (shutdown_pending > 2)
2462         {
2463           log_info ("shutdown forced\n");
2464           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2465           cleanup ();
2466           agent_exit (0);
2467         }
2468       break;
2469
2470     case SIGINT:
2471       log_info ("SIGINT received - immediate shutdown\n");
2472       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2473       cleanup ();
2474       agent_exit (0);
2475       break;
2476 #endif
2477     default:
2478       log_info ("signal %d received - no action defined\n", signo);
2479     }
2480 }
2481 #endif
2482
2483 /* Check the nonce on a new connection.  This is a NOP unless we
2484    are using our Unix domain socket emulation under Windows.  */
2485 static int
2486 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2487 {
2488   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2489     {
2490       log_info (_("error reading nonce on fd %d: %s\n"),
2491                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2492       assuan_sock_close (ctrl->thread_startup.fd);
2493       xfree (ctrl);
2494       return -1;
2495     }
2496   else
2497     return 0;
2498 }
2499
2500
2501 #ifdef HAVE_W32_SYSTEM
2502 /* The window message processing function for Putty.  Warning: This
2503    code runs as a native Windows thread.  Use of our own functions
2504    needs to be bracket with pth_leave/pth_enter. */
2505 static LRESULT CALLBACK
2506 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2507 {
2508   int ret = 0;
2509   int w32rc;
2510   COPYDATASTRUCT *cds;
2511   const char *mapfile;
2512   HANDLE maphd;
2513   PSID mysid = NULL;
2514   PSID mapsid = NULL;
2515   void *data = NULL;
2516   PSECURITY_DESCRIPTOR psd = NULL;
2517   ctrl_t ctrl = NULL;
2518
2519   if (msg != WM_COPYDATA)
2520     {
2521       return DefWindowProc (hwnd, msg, wparam, lparam);
2522     }
2523
2524   cds = (COPYDATASTRUCT*)lparam;
2525   if (cds->dwData != PUTTY_IPC_MAGIC)
2526     return 0;  /* Ignore data with the wrong magic.  */
2527   mapfile = cds->lpData;
2528   if (!cds->cbData || mapfile[cds->cbData - 1])
2529     return 0;  /* Ignore empty and non-properly terminated strings.  */
2530
2531   if (DBG_IPC)
2532     {
2533       npth_protect ();
2534       log_debug ("ssh map file '%s'", mapfile);
2535       npth_unprotect ();
2536     }
2537
2538   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2539   if (DBG_IPC)
2540     {
2541       npth_protect ();
2542       log_debug ("ssh map handle %p\n", maphd);
2543       npth_unprotect ();
2544     }
2545
2546   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2547     return 0;
2548
2549   npth_protect ();
2550
2551   mysid = w32_get_user_sid ();
2552   if (!mysid)
2553     {
2554       log_error ("error getting my sid\n");
2555       goto leave;
2556     }
2557
2558   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2559                            OWNER_SECURITY_INFORMATION,
2560                            &mapsid, NULL, NULL, NULL,
2561                            &psd);
2562   if (w32rc)
2563     {
2564       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2565       goto leave;
2566     }
2567
2568   if (DBG_IPC)
2569     {
2570       char *sidstr;
2571
2572       if (!ConvertSidToStringSid (mysid, &sidstr))
2573         sidstr = NULL;
2574       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2575       LocalFree (sidstr);
2576       if (!ConvertSidToStringSid (mapsid, &sidstr))
2577         sidstr = NULL;
2578       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2579       LocalFree (sidstr);
2580     }
2581
2582   if (!EqualSid (mysid, mapsid))
2583     {
2584       log_error ("ssh map file has a non-matching sid\n");
2585       goto leave;
2586     }
2587
2588   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2589   if (DBG_IPC)
2590     log_debug ("ssh IPC buffer at %p\n", data);
2591   if (!data)
2592     goto leave;
2593
2594   /* log_printhex ("request:", data, 20); */
2595
2596   ctrl = xtrycalloc (1, sizeof *ctrl);
2597   if (!ctrl)
2598     {
2599       log_error ("error allocating connection control data: %s\n",
2600                  strerror (errno) );
2601       goto leave;
2602     }
2603   ctrl->session_env = session_env_new ();
2604   if (!ctrl->session_env)
2605     {
2606       log_error ("error allocating session environment block: %s\n",
2607                  strerror (errno) );
2608       goto leave;
2609     }
2610
2611   agent_init_default_ctrl (ctrl);
2612   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2613     ret = 1; /* Valid ssh message has been constructed.  */
2614   agent_deinit_default_ctrl (ctrl);
2615   /* log_printhex ("  reply:", data, 20); */
2616
2617  leave:
2618   xfree (ctrl);
2619   if (data)
2620     UnmapViewOfFile (data);
2621   xfree (mapsid);
2622   if (psd)
2623     LocalFree (psd);
2624   xfree (mysid);
2625   CloseHandle (maphd);
2626
2627   npth_unprotect ();
2628
2629   return ret;
2630 }
2631 #endif /*HAVE_W32_SYSTEM*/
2632
2633
2634 #ifdef HAVE_W32_SYSTEM
2635 /* The thread handling Putty's IPC requests.  */
2636 static void *
2637 putty_message_thread (void *arg)
2638 {
2639   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2640                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2641   HWND hwnd;
2642   MSG msg;
2643
2644   (void)arg;
2645
2646   if (opt.verbose)
2647     log_info ("putty message loop thread started\n");
2648
2649   /* The message loop runs as thread independent from our nPth system.
2650      This also means that we need to make sure that we switch back to
2651      our system before calling any no-windows function.  */
2652   npth_unprotect ();
2653
2654   /* First create a window to make sure that a message queue exists
2655      for this thread.  */
2656   if (!RegisterClass (&wndwclass))
2657     {
2658       npth_protect ();
2659       log_error ("error registering Pageant window class");
2660       return NULL;
2661     }
2662   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2663                          0, 0, 0, 0,
2664                          HWND_MESSAGE,  /* hWndParent */
2665                          NULL,          /* hWndMenu   */
2666                          NULL,          /* hInstance  */
2667                          NULL);         /* lpParm     */
2668   if (!hwnd)
2669     {
2670       npth_protect ();
2671       log_error ("error creating Pageant window");
2672       return NULL;
2673     }
2674
2675   while (GetMessage(&msg, NULL, 0, 0))
2676     {
2677       TranslateMessage(&msg);
2678       DispatchMessage(&msg);
2679     }
2680
2681   /* Back to nPth.  */
2682   npth_protect ();
2683
2684   if (opt.verbose)
2685     log_info ("putty message loop thread stopped\n");
2686   return NULL;
2687 }
2688 #endif /*HAVE_W32_SYSTEM*/
2689
2690
2691 static void *
2692 do_start_connection_thread (ctrl_t ctrl)
2693 {
2694   active_connections++;
2695   agent_init_default_ctrl (ctrl);
2696   if (opt.verbose && !DBG_IPC)
2697     log_info (_("handler 0x%lx for fd %d started\n"),
2698               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2699
2700   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2701   if (opt.verbose && !DBG_IPC)
2702     log_info (_("handler 0x%lx for fd %d terminated\n"),
2703               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2704
2705   agent_deinit_default_ctrl (ctrl);
2706   xfree (ctrl);
2707   active_connections--;
2708   return NULL;
2709 }
2710
2711
2712 /* This is the standard connection thread's main function.  */
2713 static void *
2714 start_connection_thread_std (void *arg)
2715 {
2716   ctrl_t ctrl = arg;
2717
2718   if (check_nonce (ctrl, &socket_nonce))
2719     {
2720       log_error ("handler 0x%lx nonce check FAILED\n",
2721                  (unsigned long) npth_self());
2722       return NULL;
2723     }
2724
2725   return do_start_connection_thread (ctrl);
2726 }
2727
2728
2729 /* This is the extra socket connection thread's main function.  */
2730 static void *
2731 start_connection_thread_extra (void *arg)
2732 {
2733   ctrl_t ctrl = arg;
2734
2735   if (check_nonce (ctrl, &socket_nonce_extra))
2736     {
2737       log_error ("handler 0x%lx nonce check FAILED\n",
2738                  (unsigned long) npth_self());
2739       return NULL;
2740     }
2741
2742   ctrl->restricted = 1;
2743   return do_start_connection_thread (ctrl);
2744 }
2745
2746
2747 /* This is the browser socket connection thread's main function.  */
2748 static void *
2749 start_connection_thread_browser (void *arg)
2750 {
2751   ctrl_t ctrl = arg;
2752
2753   if (check_nonce (ctrl, &socket_nonce_browser))
2754     {
2755       log_error ("handler 0x%lx nonce check FAILED\n",
2756                  (unsigned long) npth_self());
2757       return NULL;
2758     }
2759
2760   ctrl->restricted = 2;
2761   return do_start_connection_thread (ctrl);
2762 }
2763
2764
2765 /* This is the ssh connection thread's main function.  */
2766 static void *
2767 start_connection_thread_ssh (void *arg)
2768 {
2769   ctrl_t ctrl = arg;
2770
2771   if (check_nonce (ctrl, &socket_nonce_ssh))
2772     return NULL;
2773
2774   active_connections++;
2775   agent_init_default_ctrl (ctrl);
2776   if (opt.verbose)
2777     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2778               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2779
2780   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2781   if (opt.verbose)
2782     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2783               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2784
2785   agent_deinit_default_ctrl (ctrl);
2786   xfree (ctrl);
2787   active_connections--;
2788   return NULL;
2789 }
2790
2791
2792 /* Connection handler loop.  Wait for connection requests and spawn a
2793    thread after accepting a connection.  */
2794 static void
2795 handle_connections (gnupg_fd_t listen_fd,
2796                     gnupg_fd_t listen_fd_extra,
2797                     gnupg_fd_t listen_fd_browser,
2798                     gnupg_fd_t listen_fd_ssh)
2799 {
2800   gpg_error_t err;
2801   npth_attr_t tattr;
2802   struct sockaddr_un paddr;
2803   socklen_t plen;
2804   fd_set fdset, read_fdset;
2805   int ret;
2806   gnupg_fd_t fd;
2807   int nfd;
2808   int saved_errno;
2809   struct timespec abstime;
2810   struct timespec curtime;
2811   struct timespec timeout;
2812 #ifdef HAVE_W32_SYSTEM
2813   HANDLE events[2];
2814   unsigned int events_set;
2815 #endif
2816   int sock_inotify_fd = -1;
2817   int home_inotify_fd = -1;
2818   struct {
2819     const char *name;
2820     void *(*func) (void *arg);
2821     gnupg_fd_t l_fd;
2822   } listentbl[] = {
2823     { "std",     start_connection_thread_std   },
2824     { "extra",   start_connection_thread_extra },
2825     { "browser", start_connection_thread_browser },
2826     { "ssh",    start_connection_thread_ssh   }
2827   };
2828
2829
2830   ret = npth_attr_init(&tattr);
2831   if (ret)
2832     log_fatal ("error allocating thread attributes: %s\n",
2833                strerror (ret));
2834   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2835
2836 #ifndef HAVE_W32_SYSTEM
2837   npth_sigev_init ();
2838   npth_sigev_add (SIGHUP);
2839   npth_sigev_add (SIGUSR1);
2840   npth_sigev_add (SIGUSR2);
2841   npth_sigev_add (SIGINT);
2842   npth_sigev_add (SIGTERM);
2843   npth_sigev_fini ();
2844 #else
2845 # ifdef HAVE_W32CE_SYSTEM
2846   /* Use a dummy event. */
2847   sigs = 0;
2848   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2849 # else
2850   events[0] = get_agent_scd_notify_event ();
2851   events[1] = INVALID_HANDLE_VALUE;
2852 # endif
2853 #endif
2854
2855   if (disable_check_own_socket)
2856     sock_inotify_fd = -1;
2857   else if ((err = gnupg_inotify_watch_socket (&sock_inotify_fd, socket_name)))
2858     {
2859       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2860         log_info ("error enabling daemon termination by socket removal: %s\n",
2861                   gpg_strerror (err));
2862     }
2863
2864   if (disable_check_own_socket)
2865     home_inotify_fd = -1;
2866   else if ((err = gnupg_inotify_watch_delete_self (&home_inotify_fd,
2867                                                    gnupg_homedir ())))
2868     {
2869       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
2870         log_info ("error enabling daemon termination by homedir removal: %s\n",
2871                   gpg_strerror (err));
2872     }
2873   else
2874     have_homedir_inotify = 1;
2875
2876   /* On Windows we need to fire up a separate thread to listen for
2877      requests from Putty (an SSH client), so we can replace Putty's
2878      Pageant (its ssh-agent implementation). */
2879 #ifdef HAVE_W32_SYSTEM
2880   if (putty_support)
2881     {
2882       npth_t thread;
2883
2884       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2885       if (ret)
2886         {
2887           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2888         }
2889     }
2890 #endif /*HAVE_W32_SYSTEM*/
2891
2892   /* Set a flag to tell call-scd.c that it may enable event
2893      notifications.  */
2894   opt.sigusr2_enabled = 1;
2895
2896   FD_ZERO (&fdset);
2897   FD_SET (FD2INT (listen_fd), &fdset);
2898   nfd = FD2INT (listen_fd);
2899   if (listen_fd_extra != GNUPG_INVALID_FD)
2900     {
2901       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2902       if (FD2INT (listen_fd_extra) > nfd)
2903         nfd = FD2INT (listen_fd_extra);
2904     }
2905   if (listen_fd_browser != GNUPG_INVALID_FD)
2906     {
2907       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2908       if (FD2INT (listen_fd_browser) > nfd)
2909         nfd = FD2INT (listen_fd_browser);
2910     }
2911   if (listen_fd_ssh != GNUPG_INVALID_FD)
2912     {
2913       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2914       if (FD2INT (listen_fd_ssh) > nfd)
2915         nfd = FD2INT (listen_fd_ssh);
2916     }
2917   if (sock_inotify_fd != -1)
2918     {
2919       FD_SET (sock_inotify_fd, &fdset);
2920       if (sock_inotify_fd > nfd)
2921         nfd = sock_inotify_fd;
2922     }
2923   if (home_inotify_fd != -1)
2924     {
2925       FD_SET (home_inotify_fd, &fdset);
2926       if (home_inotify_fd > nfd)
2927         nfd = home_inotify_fd;
2928     }
2929
2930   listentbl[0].l_fd = listen_fd;
2931   listentbl[1].l_fd = listen_fd_extra;
2932   listentbl[2].l_fd = listen_fd_browser;
2933   listentbl[3].l_fd = listen_fd_ssh;
2934
2935   npth_clock_gettime (&abstime);
2936   abstime.tv_sec += TIMERTICK_INTERVAL;
2937
2938   for (;;)
2939     {
2940       /* Shutdown test.  */
2941       if (shutdown_pending)
2942         {
2943           if (active_connections == 0)
2944             break; /* ready */
2945
2946           /* Do not accept new connections but keep on running the
2947            * loop to cope with the timer events.
2948            *
2949            * Note that we do not close the listening socket because a
2950            * client trying to connect to that socket would instead
2951            * restart a new dirmngr instance - which is unlikely the
2952            * intention of a shutdown. */
2953           FD_ZERO (&fdset);
2954           nfd = -1;
2955           if (sock_inotify_fd != -1)
2956             {
2957               FD_SET (sock_inotify_fd, &fdset);
2958               nfd = sock_inotify_fd;
2959             }
2960           if (home_inotify_fd != -1)
2961             {
2962               FD_SET (home_inotify_fd, &fdset);
2963               if (home_inotify_fd > nfd)
2964                 nfd = home_inotify_fd;
2965             }
2966         }
2967
2968       /* POSIX says that fd_set should be implemented as a structure,
2969          thus a simple assignment is fine to copy the entire set.  */
2970       read_fdset = fdset;
2971
2972       npth_clock_gettime (&curtime);
2973       if (!(npth_timercmp (&curtime, &abstime, <)))
2974         {
2975           /* Timeout.  */
2976           handle_tick ();
2977           npth_clock_gettime (&abstime);
2978           abstime.tv_sec += TIMERTICK_INTERVAL;
2979         }
2980       npth_timersub (&abstime, &curtime, &timeout);
2981
2982 #ifndef HAVE_W32_SYSTEM
2983       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2984                           npth_sigev_sigmask ());
2985       saved_errno = errno;
2986
2987       {
2988         int signo;
2989         while (npth_sigev_get_pending (&signo))
2990           handle_signal (signo);
2991       }
2992 #else
2993       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2994                           events, &events_set);
2995       saved_errno = errno;
2996
2997       /* This is valid even if npth_eselect returns an error.  */
2998       if (events_set & 1)
2999         agent_sigusr2_action ();
3000 #endif
3001
3002       if (ret == -1 && saved_errno != EINTR)
3003         {
3004           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
3005                      strerror (saved_errno));
3006           npth_sleep (1);
3007           continue;
3008         }
3009       if (ret <= 0)
3010         /* Interrupt or timeout.  Will be handled when calculating the
3011            next timeout.  */
3012         continue;
3013
3014       /* The inotify fds are set even when a shutdown is pending (see
3015        * above).  So we must handle them in any case.  To avoid that
3016        * they trigger a second time we close them immediately.  */
3017       if (sock_inotify_fd != -1
3018           && FD_ISSET (sock_inotify_fd, &read_fdset)
3019           && gnupg_inotify_has_name (sock_inotify_fd, GPG_AGENT_SOCK_NAME))
3020         {
3021           shutdown_pending = 1;
3022           close (sock_inotify_fd);
3023           sock_inotify_fd = -1;
3024           log_info ("socket file has been removed - shutting down\n");
3025         }
3026
3027       if (home_inotify_fd != -1
3028           && FD_ISSET (home_inotify_fd, &read_fdset))
3029         {
3030           shutdown_pending = 1;
3031           close (home_inotify_fd);
3032           home_inotify_fd = -1;
3033           log_info ("homedir has been removed - shutting down\n");
3034         }
3035
3036       if (!shutdown_pending)
3037         {
3038           int idx;
3039           ctrl_t ctrl;
3040           npth_t thread;
3041
3042           for (idx=0; idx < DIM(listentbl); idx++)
3043             {
3044               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
3045                 continue;
3046               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
3047                 continue;
3048
3049               plen = sizeof paddr;
3050               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
3051                                         (struct sockaddr *)&paddr, &plen));
3052               if (fd == GNUPG_INVALID_FD)
3053                 {
3054                   log_error ("accept failed for %s: %s\n",
3055                              listentbl[idx].name, strerror (errno));
3056                 }
3057               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
3058                 {
3059                   log_error ("error allocating connection data for %s: %s\n",
3060                              listentbl[idx].name, strerror (errno) );
3061                   assuan_sock_close (fd);
3062                 }
3063               else if ( !(ctrl->session_env = session_env_new ()))
3064                 {
3065                   log_error ("error allocating session env block for %s: %s\n",
3066                              listentbl[idx].name, strerror (errno) );
3067                   xfree (ctrl);
3068                   assuan_sock_close (fd);
3069                 }
3070               else
3071                 {
3072                   ctrl->thread_startup.fd = fd;
3073                   ret = npth_create (&thread, &tattr,
3074                                      listentbl[idx].func, ctrl);
3075                   if (ret)
3076                     {
3077                       log_error ("error spawning connection handler for %s:"
3078                                  " %s\n", listentbl[idx].name, strerror (ret));
3079                       assuan_sock_close (fd);
3080                       xfree (ctrl);
3081                     }
3082                 }
3083             }
3084         }
3085     }
3086
3087   if (sock_inotify_fd != -1)
3088     close (sock_inotify_fd);
3089   if (home_inotify_fd != -1)
3090     close (home_inotify_fd);
3091   cleanup ();
3092   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
3093   npth_attr_destroy (&tattr);
3094 }
3095
3096
3097
3098 /* Helper for check_own_socket.  */
3099 static gpg_error_t
3100 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
3101 {
3102   membuf_t *mb = opaque;
3103   put_membuf (mb, buffer, length);
3104   return 0;
3105 }
3106
3107
3108 /* The thread running the actual check.  We need to run this in a
3109    separate thread so that check_own_thread can be called from the
3110    timer tick.  */
3111 static void *
3112 check_own_socket_thread (void *arg)
3113 {
3114   int rc;
3115   char *sockname = arg;
3116   assuan_context_t ctx = NULL;
3117   membuf_t mb;
3118   char *buffer;
3119
3120   check_own_socket_running++;
3121
3122   rc = assuan_new (&ctx);
3123   if (rc)
3124     {
3125       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
3126       goto leave;
3127     }
3128   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
3129
3130   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3131   if (rc)
3132     {
3133       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3134       goto leave;
3135     }
3136
3137   init_membuf (&mb, 100);
3138   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3139                         NULL, NULL, NULL, NULL);
3140   put_membuf (&mb, "", 1);
3141   buffer = get_membuf (&mb, NULL);
3142   if (rc || !buffer)
3143     {
3144       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3145                  "GETINFO pid", gpg_strerror (rc));
3146       rc = 1;
3147     }
3148   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3149     {
3150       log_error ("socket is now serviced by another server\n");
3151       rc = 1;
3152     }
3153   else if (opt.verbose > 1)
3154     log_error ("socket is still served by this server\n");
3155
3156   xfree (buffer);
3157
3158  leave:
3159   xfree (sockname);
3160   if (ctx)
3161     assuan_release (ctx);
3162   if (rc)
3163     {
3164       /* We may not remove the socket as it is now in use by another
3165          server. */
3166       inhibit_socket_removal = 1;
3167       shutdown_pending = 2;
3168       log_info ("this process is useless - shutting down\n");
3169     }
3170   check_own_socket_running--;
3171   return NULL;
3172 }
3173
3174
3175 /* Check whether we are still listening on our own socket.  In case
3176    another gpg-agent process started after us has taken ownership of
3177    our socket, we would linger around without any real task.  Thus we
3178    better check once in a while whether we are really needed.  */
3179 static void
3180 check_own_socket (void)
3181 {
3182   char *sockname;
3183   npth_t thread;
3184   npth_attr_t tattr;
3185   int err;
3186
3187   if (disable_check_own_socket)
3188     return;
3189
3190   if (check_own_socket_running || shutdown_pending)
3191     return;  /* Still running or already shutting down.  */
3192
3193   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3194   if (!sockname)
3195     return; /* Out of memory.  */
3196
3197   err = npth_attr_init (&tattr);
3198   if (err)
3199     return;
3200   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3201   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3202   if (err)
3203     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3204   npth_attr_destroy (&tattr);
3205 }
3206
3207
3208
3209 /* Figure out whether an agent is available and running. Prints an
3210    error if not.  If SILENT is true, no messages are printed.
3211    Returns 0 if the agent is running. */
3212 static int
3213 check_for_running_agent (int silent)
3214 {
3215   gpg_error_t err;
3216   char *sockname;
3217   assuan_context_t ctx = NULL;
3218
3219   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3220   if (!sockname)
3221     return gpg_error_from_syserror ();
3222
3223   err = assuan_new (&ctx);
3224   if (!err)
3225     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3226   xfree (sockname);
3227   if (err)
3228     {
3229       if (!silent)
3230         log_error (_("no gpg-agent running in this session\n"));
3231
3232       if (ctx)
3233         assuan_release (ctx);
3234       return -1;
3235     }
3236
3237   if (!opt.quiet && !silent)
3238     log_info ("gpg-agent running and available\n");
3239
3240   assuan_release (ctx);
3241   return 0;
3242 }