gpg-agent: Add restricted connection feature.
[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-2014 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 <http://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 JNLIB_NEED_LOG_LOGV
53 #define JNLIB_NEED_AFLOCAL
54 #include "agent.h"
55 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
56
57 #include "i18n.h"
58 #include "sysutils.h"
59 #include "gc-opt-flags.h"
60 #include "exechelp.h"
61 #include "asshelp.h"
62 #include "openpgpdefs.h"  /* for PUBKEY_ALGO_ECDSA, PUBKEY_ALGO_ECDH */
63 #include "../common/init.h"
64
65
66 enum cmd_and_opt_values
67 { aNull = 0,
68   oCsh            = 'c',
69   oQuiet          = 'q',
70   oSh             = 's',
71   oVerbose        = 'v',
72
73   oNoVerbose = 500,
74   aGPGConfList,
75   aGPGConfTest,
76   aUseStandardSocketP,
77   oOptions,
78   oDebug,
79   oDebugAll,
80   oDebugLevel,
81   oDebugWait,
82   oDebugQuickRandom,
83   oNoGreeting,
84   oNoOptions,
85   oHomedir,
86   oNoDetach,
87   oNoGrab,
88   oLogFile,
89   oServer,
90   oDaemon,
91   oBatch,
92
93   oPinentryProgram,
94   oPinentryTouchFile,
95   oDisplay,
96   oTTYname,
97   oTTYtype,
98   oLCctype,
99   oLCmessages,
100   oXauthority,
101   oScdaemonProgram,
102   oDefCacheTTL,
103   oDefCacheTTLSSH,
104   oMaxCacheTTL,
105   oMaxCacheTTLSSH,
106   oEnforcePassphraseConstraints,
107   oMinPassphraseLen,
108   oMinPassphraseNonalpha,
109   oCheckPassphrasePattern,
110   oMaxPassphraseDays,
111   oEnablePassphraseHistory,
112   oUseStandardSocket,
113   oNoUseStandardSocket,
114   oExtraSocket,
115   oFakedSystemTime,
116
117   oIgnoreCacheForSigning,
118   oAllowMarkTrusted,
119   oNoAllowMarkTrusted,
120   oAllowPresetPassphrase,
121   oAllowLoopbackPinentry,
122   oKeepTTY,
123   oKeepDISPLAY,
124   oSSHSupport,
125   oPuttySupport,
126   oDisableScdaemon,
127   oDisableCheckOwnSocket,
128   oWriteEnvFile
129 };
130
131
132
133 static ARGPARSE_OPTS opts[] = {
134
135   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
136   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
137   ARGPARSE_c (aUseStandardSocketP, "use-standard-socket-p", "@"),
138
139   ARGPARSE_group (301, N_("@Options:\n ")),
140
141   ARGPARSE_s_n (oDaemon,  "daemon", N_("run in daemon mode (background)")),
142   ARGPARSE_s_n (oServer,  "server", N_("run in server mode (foreground)")),
143   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
144   ARGPARSE_s_n (oQuiet,   "quiet",     N_("be somewhat more quiet")),
145   ARGPARSE_s_n (oSh,      "sh",        N_("sh-style command output")),
146   ARGPARSE_s_n (oCsh,     "csh",       N_("csh-style command output")),
147   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
148
149   ARGPARSE_s_u (oDebug,      "debug",       "@"),
150   ARGPARSE_s_n (oDebugAll,   "debug-all",   "@"),
151   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
152   ARGPARSE_s_i (oDebugWait,"  debug-wait",  "@"),
153   ARGPARSE_s_n (oDebugQuickRandom, "debug-quick-random", "@"),
154
155   ARGPARSE_s_n (oNoDetach,  "no-detach", N_("do not detach from the console")),
156   ARGPARSE_s_n (oNoGrab,    "no-grab",   N_("do not grab keyboard and mouse")),
157   ARGPARSE_s_s (oLogFile,   "log-file",  N_("use a log file for the server")),
158   ARGPARSE_s_s (oPinentryProgram, "pinentry-program",
159                 /* */             N_("|PGM|use PGM as the PIN-Entry program")),
160   ARGPARSE_s_s (oPinentryTouchFile, "pinentry-touch-file", "@"),
161   ARGPARSE_s_s (oScdaemonProgram, "scdaemon-program",
162                 /* */             N_("|PGM|use PGM as the SCdaemon program") ),
163   ARGPARSE_s_n (oDisableScdaemon, "disable-scdaemon",
164                 /* */             N_("do not use the SCdaemon") ),
165   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
166   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
167
168   ARGPARSE_s_n (oBatch,      "batch",        "@"),
169   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
170
171   ARGPARSE_s_s (oDisplay,    "display",     "@"),
172   ARGPARSE_s_s (oTTYname,    "ttyname",     "@"),
173   ARGPARSE_s_s (oTTYtype,    "ttytype",     "@"),
174   ARGPARSE_s_s (oLCctype,    "lc-ctype",    "@"),
175   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
176   ARGPARSE_s_s (oXauthority, "xauthority",  "@"),
177   ARGPARSE_s_n (oKeepTTY,    "keep-tty",
178                 /* */        N_("ignore requests to change the TTY")),
179   ARGPARSE_s_n (oKeepDISPLAY, "keep-display",
180                 /* */        N_("ignore requests to change the X display")),
181
182   ARGPARSE_s_u (oDefCacheTTL,    "default-cache-ttl",
183                                  N_("|N|expire cached PINs after N seconds")),
184   ARGPARSE_s_u (oDefCacheTTLSSH, "default-cache-ttl-ssh", "@" ),
185   ARGPARSE_s_u (oMaxCacheTTL,    "max-cache-ttl",         "@" ),
186   ARGPARSE_s_u (oMaxCacheTTLSSH, "max-cache-ttl-ssh",     "@" ),
187
188   ARGPARSE_s_n (oEnforcePassphraseConstraints, "enforce-passphrase-constraints",
189                 /* */                          "@"),
190   ARGPARSE_s_u (oMinPassphraseLen,        "min-passphrase-len", "@"),
191   ARGPARSE_s_u (oMinPassphraseNonalpha,   "min-passphrase-nonalpha", "@"),
192   ARGPARSE_s_s (oCheckPassphrasePattern,  "check-passphrase-pattern", "@"),
193   ARGPARSE_s_u (oMaxPassphraseDays,       "max-passphrase-days", "@"),
194   ARGPARSE_s_n (oEnablePassphraseHistory, "enable-passphrase-history", "@"),
195
196   ARGPARSE_s_n (oIgnoreCacheForSigning, "ignore-cache-for-signing",
197                 /* */    N_("do not use the PIN cache when signing")),
198   ARGPARSE_s_n (oNoAllowMarkTrusted, "no-allow-mark-trusted",
199                 /* */    N_("disallow clients to mark keys as \"trusted\"")),
200   ARGPARSE_s_n (oAllowMarkTrusted,   "allow-mark-trusted", "@"),
201   ARGPARSE_s_n (oAllowPresetPassphrase, "allow-preset-passphrase",
202                 /* */                    N_("allow presetting passphrase")),
203   ARGPARSE_s_n (oAllowLoopbackPinentry, "allow-loopback-pinentry",
204                                         N_("allow presetting passphrase")),
205   ARGPARSE_s_n (oSSHSupport,   "enable-ssh-support", N_("enable ssh support")),
206   ARGPARSE_s_n (oPuttySupport, "enable-putty-support",
207 #ifdef HAVE_W32_SYSTEM
208                 /* */           N_("enable putty support")
209 #else
210                 /* */           "@"
211 #endif
212                 ),
213   ARGPARSE_s_s (oExtraSocket, "extra-socket", "@"),
214
215   /* Dummy options for backward compatibility.  */
216   ARGPARSE_o_s (oWriteEnvFile, "write-env-file", "@"),
217   ARGPARSE_s_n (oUseStandardSocket, "use-standard-socket", "@"),
218   ARGPARSE_s_n (oNoUseStandardSocket, "no-use-standard-socket", "@"),
219
220   {0} /* End of list */
221 };
222
223
224 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
225 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
226 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
227 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
228 #define MIN_PASSPHRASE_LEN    (8)
229 #define MIN_PASSPHRASE_NONALPHA (1)
230 #define MAX_PASSPHRASE_DAYS   (0)
231
232 /* The timer tick used for housekeeping stuff.  For Windows we use a
233    longer period as the SetWaitableTimer seems to signal earlier than
234    the 2 seconds.  CHECK_OWN_SOCKET_INTERVAL defines how often we
235    check our own socket in standard socket mode.  If that value is 0
236    we don't check at all.   All values are in seconds. */
237 #if defined(HAVE_W32CE_SYSTEM)
238 # define TIMERTICK_INTERVAL         (60)
239 # define CHECK_OWN_SOCKET_INTERVAL   (0)  /* Never */
240 #elif defined(HAVE_W32_SYSTEM)
241 # define TIMERTICK_INTERVAL          (4)
242 # define CHECK_OWN_SOCKET_INTERVAL  (60)
243 #else
244 # define TIMERTICK_INTERVAL          (2)
245 # define CHECK_OWN_SOCKET_INTERVAL  (60)
246 #endif
247
248
249 #ifdef HAVE_W32_SYSTEM
250 /* Flag indicating that support for Putty has been enabled.  */
251 static int putty_support;
252 /* A magic value used with WM_COPYDATA.  */
253 #define PUTTY_IPC_MAGIC 0x804e50ba
254 /* To avoid surprises we limit the size of the mapped IPC file to this
255    value.  Putty currently (0.62) uses 8k, thus 16k should be enough
256    for the foreseeable future.  */
257 #define PUTTY_IPC_MAXLEN 16384
258 #endif /*HAVE_W32_SYSTEM*/
259
260 /* The list of open file descriptors at startup.  Note that this list
261    has been allocated using the standard malloc.  */
262 static int *startup_fd_list;
263
264 /* The signal mask at startup and a flag telling whether it is valid.  */
265 #ifdef HAVE_SIGPROCMASK
266 static sigset_t startup_signal_mask;
267 static int startup_signal_mask_valid;
268 #endif
269
270 /* Flag to indicate that a shutdown was requested.  */
271 static int shutdown_pending;
272
273 /* Counter for the currently running own socket checks.  */
274 static int check_own_socket_running;
275
276 /* Flags to indicate that check_own_socket shall not be called.  */
277 static int disable_check_own_socket;
278
279 /* It is possible that we are currently running under setuid permissions */
280 static int maybe_setuid = 1;
281
282 /* Name of the communication socket used for native gpg-agent requests.  */
283 static char *socket_name;
284
285 /* Name of the optional extra socket used for native gpg-agent requests.  */
286 static char *socket_name_extra;
287
288 /* Name of the communication socket used for ssh-agent-emulation.  */
289 static char *socket_name_ssh;
290
291 /* We need to keep track of the server's nonces (these are dummies for
292    POSIX systems). */
293 static assuan_sock_nonce_t socket_nonce;
294 static assuan_sock_nonce_t socket_nonce_extra;
295 static assuan_sock_nonce_t socket_nonce_ssh;
296
297
298 /* Default values for options passed to the pinentry. */
299 static char *default_display;
300 static char *default_ttyname;
301 static char *default_ttytype;
302 static char *default_lc_ctype;
303 static char *default_lc_messages;
304 static char *default_xauthority;
305
306 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
307 static char *config_filename;
308
309 /* Helper to implement --debug-level */
310 static const char *debug_level;
311
312 /* Keep track of the current log file so that we can avoid updating
313    the log file after a SIGHUP if it didn't changed. Malloced. */
314 static char *current_logfile;
315
316 /* The handle_tick() function may test whether a parent is still
317    running.  We record the PID of the parent here or -1 if it should be
318    watched. */
319 static pid_t parent_pid = (pid_t)(-1);
320
321 /* Number of active connections.  */
322 static int active_connections;
323
324 \f
325 /*
326    Local prototypes.
327  */
328
329 static char *create_socket_name (char *standard_name, int with_homedir);
330 static gnupg_fd_t create_server_socket (char *name, int primary,
331                                         assuan_sock_nonce_t *nonce);
332 static void create_directories (void);
333
334 static void agent_init_default_ctrl (ctrl_t ctrl);
335 static void agent_deinit_default_ctrl (ctrl_t ctrl);
336
337 static void handle_connections (gnupg_fd_t listen_fd,
338                                 gnupg_fd_t listen_fd_extra,
339                                 gnupg_fd_t listen_fd_ssh);
340 static void check_own_socket (void);
341 static int check_for_running_agent (int silent);
342
343 /* Pth wrapper function definitions. */
344 ASSUAN_SYSTEM_NPTH_IMPL;
345
346 \f
347 /*
348    Functions.
349  */
350
351 /* Allocate a string describing a library version by calling a GETFNC.
352    This function is expected to be called only once.  GETFNC is
353    expected to have a semantic like gcry_check_version ().  */
354 static char *
355 make_libversion (const char *libname, const char *(*getfnc)(const char*))
356 {
357   const char *s;
358   char *result;
359
360   if (maybe_setuid)
361     {
362       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
363       maybe_setuid = 0;
364     }
365   s = getfnc (NULL);
366   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
367   strcpy (stpcpy (stpcpy (result, libname), " "), s);
368   return result;
369 }
370
371 /* Return strings describing this program.  The case values are
372    described in common/argparse.c:strusage.  The values here override
373    the default values given by strusage.  */
374 static const char *
375 my_strusage (int level)
376 {
377   static char *ver_gcry;
378   const char *p;
379
380   switch (level)
381     {
382     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
383       break;
384     case 13: p = VERSION; break;
385     case 17: p = PRINTABLE_OS_NAME; break;
386       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
387          reporting address.  This is so that we can change the
388          reporting address without breaking the translations.  */
389     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
390
391     case 20:
392       if (!ver_gcry)
393         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
394       p = ver_gcry;
395       break;
396
397     case 1:
398     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
399       break;
400     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
401                     "Secret key management for @GNUPG@\n");
402     break;
403
404     default: p = NULL;
405     }
406   return p;
407 }
408
409
410
411 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
412    only the active debug flags are propagated to the subsystems.  With
413    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
414    all flags already set. Note that we don't fail here, because it is
415    important to keep gpg-agent running even after re-reading the
416    options due to a SIGHUP. */
417 static void
418 set_debug (void)
419 {
420   int numok = (debug_level && digitp (debug_level));
421   int numlvl = numok? atoi (debug_level) : 0;
422
423   if (!debug_level)
424     ;
425   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
426     opt.debug = 0;
427   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
428     opt.debug = DBG_ASSUAN_VALUE;
429   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
430     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
431   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
432     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
433                  |DBG_CACHE_VALUE);
434   else if (!strcmp (debug_level, "guru") || numok)
435     {
436       opt.debug = ~0;
437       /* Unless the "guru" string has been used we don't want to allow
438          hashing debugging.  The rationale is that people tend to
439          select the highest debug value and would then clutter their
440          disk with debug files which may reveal confidential data.  */
441       if (numok)
442         opt.debug &= ~(DBG_HASHING_VALUE);
443     }
444   else
445     {
446       log_error (_("invalid debug-level '%s' given\n"), debug_level);
447       opt.debug = 0; /* Reset debugging, so that prior debug
448                         statements won't have an undesired effect. */
449     }
450
451   if (opt.debug && !opt.verbose)
452     opt.verbose = 1;
453   if (opt.debug && opt.quiet)
454     opt.quiet = 0;
455
456   if (opt.debug & DBG_MPI_VALUE)
457     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
458   if (opt.debug & DBG_CRYPTO_VALUE )
459     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
460   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
461
462   if (opt.debug)
463     log_info ("enabled debug flags:%s%s%s%s%s%s%s%s\n",
464               (opt.debug & DBG_COMMAND_VALUE)? " command":"",
465               (opt.debug & DBG_MPI_VALUE    )? " mpi":"",
466               (opt.debug & DBG_CRYPTO_VALUE )? " crypto":"",
467               (opt.debug & DBG_MEMORY_VALUE )? " memory":"",
468               (opt.debug & DBG_CACHE_VALUE  )? " cache":"",
469               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"",
470               (opt.debug & DBG_HASHING_VALUE)? " hashing":"",
471               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"");
472 }
473
474
475 /* Helper for cleanup to remove one socket with NAME.  */
476 static void
477 remove_socket (char *name)
478 {
479   if (name && *name)
480     {
481       char *p;
482
483       gnupg_remove (name);
484       p = strrchr (name, '/');
485       if (p)
486         {
487           *p = 0;
488           rmdir (name);
489           *p = '/';
490         }
491       *name = 0;
492     }
493 }
494
495
496 /* Cleanup code for this program.  This is either called has an atexit
497    handler or directly.  */
498 static void
499 cleanup (void)
500 {
501   static int done;
502
503   if (done)
504     return;
505   done = 1;
506   deinitialize_module_cache ();
507   remove_socket (socket_name);
508   if (opt.extra_socket > 1)
509     remove_socket (socket_name_extra);
510   remove_socket (socket_name_ssh);
511 }
512
513
514
515 /* Handle options which are allowed to be reset after program start.
516    Return true when the current option in PARGS could be handled and
517    false if not.  As a special feature, passing a value of NULL for
518    PARGS, resets the options to the default.  REREAD should be set
519    true if it is not the initial option parsing. */
520 static int
521 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
522 {
523   if (!pargs)
524     { /* reset mode */
525       opt.quiet = 0;
526       opt.verbose = 0;
527       opt.debug = 0;
528       opt.no_grab = 0;
529       opt.pinentry_program = NULL;
530       opt.pinentry_touch_file = NULL;
531       opt.scdaemon_program = NULL;
532       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
533       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
534       opt.max_cache_ttl = MAX_CACHE_TTL;
535       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
536       opt.enforce_passphrase_constraints = 0;
537       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
538       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
539       opt.check_passphrase_pattern = NULL;
540       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
541       opt.enable_passhrase_history = 0;
542       opt.ignore_cache_for_signing = 0;
543       opt.allow_mark_trusted = 1;
544       opt.disable_scdaemon = 0;
545       disable_check_own_socket = 0;
546       return 1;
547     }
548
549   switch (pargs->r_opt)
550     {
551     case oQuiet: opt.quiet = 1; break;
552     case oVerbose: opt.verbose++; break;
553
554     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
555     case oDebugAll: opt.debug = ~0; break;
556     case oDebugLevel: debug_level = pargs->r.ret_str; break;
557
558     case oLogFile:
559       if (!reread)
560         return 0; /* not handeld */
561       if (!current_logfile || !pargs->r.ret_str
562           || strcmp (current_logfile, pargs->r.ret_str))
563         {
564           log_set_file (pargs->r.ret_str);
565           xfree (current_logfile);
566           current_logfile = xtrystrdup (pargs->r.ret_str);
567         }
568       break;
569
570     case oNoGrab: opt.no_grab = 1; break;
571
572     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
573     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
574     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
575     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
576     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
577
578     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
579     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
580     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
581     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
582
583     case oEnforcePassphraseConstraints:
584       opt.enforce_passphrase_constraints=1;
585       break;
586     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
587     case oMinPassphraseNonalpha:
588       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
589       break;
590     case oCheckPassphrasePattern:
591       opt.check_passphrase_pattern = pargs->r.ret_str;
592       break;
593     case oMaxPassphraseDays:
594       opt.max_passphrase_days = pargs->r.ret_ulong;
595       break;
596     case oEnablePassphraseHistory:
597       opt.enable_passhrase_history = 1;
598       break;
599
600     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
601
602     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
603     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
604
605     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
606
607     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
608
609     default:
610       return 0; /* not handled */
611     }
612
613   return 1; /* handled */
614 }
615
616
617 /* The main entry point.  */
618 int
619 main (int argc, char **argv )
620 {
621   ARGPARSE_ARGS pargs;
622   int orig_argc;
623   char **orig_argv;
624   FILE *configfp = NULL;
625   char *configname = NULL;
626   const char *shell;
627   unsigned configlineno;
628   int parse_debug = 0;
629   int default_config =1;
630   int pipe_server = 0;
631   int is_daemon = 0;
632   int nodetach = 0;
633   int csh_style = 0;
634   char *logfile = NULL;
635   int debug_wait = 0;
636   int gpgconf_list = 0;
637   gpg_error_t err;
638   struct assuan_malloc_hooks malloc_hooks;
639
640   /* Before we do anything else we save the list of currently open
641      file descriptors and the signal mask.  This info is required to
642      do the exec call properly. */
643   startup_fd_list = get_all_open_fds ();
644 #ifdef HAVE_SIGPROCMASK
645   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
646     startup_signal_mask_valid = 1;
647 #endif /*HAVE_SIGPROCMASK*/
648
649   /* Set program name etc.  */
650   set_strusage (my_strusage);
651   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
652   /* Please note that we may running SUID(ROOT), so be very CAREFUL
653      when adding any stuff between here and the call to INIT_SECMEM()
654      somewhere after the option parsing */
655   log_set_prefix (GPG_AGENT_NAME, JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID);
656
657   /* Make sure that our subsystems are ready.  */
658   i18n_init ();
659   init_common_subsystems (&argc, &argv);
660
661   npth_init ();
662
663   /* Check that the libraries are suitable.  Do it here because
664      the option parsing may need services of the library. */
665   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
666     {
667       log_fatal( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
668                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
669     }
670
671   malloc_hooks.malloc = gcry_malloc;
672   malloc_hooks.realloc = gcry_realloc;
673   malloc_hooks.free = gcry_free;
674   assuan_set_malloc_hooks (&malloc_hooks);
675   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
676   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
677   assuan_sock_init ();
678   setup_libassuan_logging (&opt.debug);
679
680   setup_libgcrypt_logging ();
681   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
682
683   disable_core_dumps ();
684
685   /* Set default options.  */
686   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
687
688   shell = getenv ("SHELL");
689   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
690     csh_style = 1;
691
692   opt.homedir = default_homedir ();
693
694   /* Record some of the original environment strings. */
695   {
696     const char *s;
697     int idx;
698     static const char *names[] =
699       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
700
701     err = 0;
702     opt.startup_env = session_env_new ();
703     if (!opt.startup_env)
704       err = gpg_error_from_syserror ();
705     for (idx=0; !err && names[idx]; idx++)
706       {
707         s = getenv (names[idx]);
708         if (s)
709           err = session_env_setenv (opt.startup_env, names[idx], s);
710       }
711     if (!err)
712       {
713         s = gnupg_ttyname (0);
714         if (s)
715           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
716       }
717     if (err)
718       log_fatal ("error recording startup environment: %s\n",
719                  gpg_strerror (err));
720
721     /* Fixme: Better use the locale function here.  */
722     opt.startup_lc_ctype = getenv ("LC_CTYPE");
723     if (opt.startup_lc_ctype)
724       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
725     opt.startup_lc_messages = getenv ("LC_MESSAGES");
726     if (opt.startup_lc_messages)
727       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
728   }
729
730   /* Check whether we have a config file on the commandline */
731   orig_argc = argc;
732   orig_argv = argv;
733   pargs.argc = &argc;
734   pargs.argv = &argv;
735   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
736   while (arg_parse( &pargs, opts))
737     {
738       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
739         parse_debug++;
740       else if (pargs.r_opt == oOptions)
741         { /* yes there is one, so we do not try the default one, but
742              read the option file when it is encountered at the
743              commandline */
744           default_config = 0;
745         }
746         else if (pargs.r_opt == oNoOptions)
747           default_config = 0; /* --no-options */
748         else if (pargs.r_opt == oHomedir)
749           opt.homedir = pargs.r.ret_str;
750         else if (pargs.r_opt == oDebugQuickRandom)
751           {
752             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
753           }
754
755     }
756
757   /* Initialize the secure memory. */
758   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
759   maybe_setuid = 0;
760
761   /*
762      Now we are now working under our real uid
763   */
764
765   if (default_config)
766     configname = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
767                                 NULL );
768
769   argc = orig_argc;
770   argv = orig_argv;
771   pargs.argc = &argc;
772   pargs.argv = &argv;
773   pargs.flags=  1;  /* do not remove the args */
774  next_pass:
775   if (configname)
776     {
777       configlineno = 0;
778       configfp = fopen (configname, "r");
779       if (!configfp)
780         {
781           if (default_config)
782             {
783               if( parse_debug )
784                 log_info (_("Note: no default option file '%s'\n"),
785                           configname );
786               /* Save the default conf file name so that
787                  reread_configuration is able to test whether the
788                  config file has been created in the meantime.  */
789               xfree (config_filename);
790               config_filename = configname;
791               configname = NULL;
792             }
793           else
794             {
795               log_error (_("option file '%s': %s\n"),
796                          configname, strerror(errno) );
797               exit(2);
798             }
799           xfree (configname);
800           configname = NULL;
801         }
802       if (parse_debug && configname )
803         log_info (_("reading options from '%s'\n"), configname );
804       default_config = 0;
805     }
806
807   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
808     {
809       if (parse_rereadable_options (&pargs, 0))
810         continue; /* Already handled */
811       switch (pargs.r_opt)
812         {
813         case aGPGConfList: gpgconf_list = 1; break;
814         case aGPGConfTest: gpgconf_list = 2; break;
815         case aUseStandardSocketP: gpgconf_list = 3; break;
816         case oBatch: opt.batch=1; break;
817
818         case oDebugWait: debug_wait = pargs.r.ret_int; break;
819
820         case oOptions:
821           /* config files may not be nested (silently ignore them) */
822           if (!configfp)
823             {
824                 xfree(configname);
825                 configname = xstrdup(pargs.r.ret_str);
826                 goto next_pass;
827             }
828           break;
829         case oNoGreeting: /* Dummy option.  */ break;
830         case oNoVerbose: opt.verbose = 0; break;
831         case oNoOptions: break; /* no-options */
832         case oHomedir: opt.homedir = pargs.r.ret_str; break;
833         case oNoDetach: nodetach = 1; break;
834         case oLogFile: logfile = pargs.r.ret_str; break;
835         case oCsh: csh_style = 1; break;
836         case oSh: csh_style = 0; break;
837         case oServer: pipe_server = 1; break;
838         case oDaemon: is_daemon = 1; break;
839
840         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
841         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
842         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
843         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
844         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
845           break;
846         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
847           break;
848
849         case oUseStandardSocket:   /* dummy */ break;
850         case oNoUseStandardSocket: /* dummy */ break;
851
852         case oFakedSystemTime:
853           {
854             time_t faked_time = isotime2epoch (pargs.r.ret_str);
855             if (faked_time == (time_t)(-1))
856               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
857             gnupg_set_time (faked_time, 0);
858           }
859           break;
860
861         case oKeepTTY: opt.keep_tty = 1; break;
862         case oKeepDISPLAY: opt.keep_display = 1; break;
863
864         case oSSHSupport:  opt.ssh_support = 1; break;
865         case oPuttySupport:
866 #        ifdef HAVE_W32_SYSTEM
867           putty_support = 1;
868           opt.ssh_support = 1;
869 #        endif
870           break;
871
872         case oExtraSocket:
873           opt.extra_socket = 1;  /* (1 = points into argv)  */
874           socket_name_extra = pargs.r.ret_str;
875           break;
876
877         case oDebugQuickRandom:
878           /* Only used by the first stage command line parser.  */
879           break;
880
881         case oWriteEnvFile: /* dummy */ break;
882
883         default : pargs.err = configfp? 1:2; break;
884         }
885     }
886   if (configfp)
887     {
888       fclose( configfp );
889       configfp = NULL;
890       /* Keep a copy of the name so that it can be read on SIGHUP. */
891       if (config_filename != configname)
892         {
893           xfree (config_filename);
894           config_filename = configname;
895         }
896       configname = NULL;
897       goto next_pass;
898     }
899
900   xfree (configname);
901   configname = NULL;
902   if (log_get_errorcount(0))
903     exit(2);
904
905   /* Turn the homedir into an absolute one. */
906   opt.homedir = make_absfilename (opt.homedir, NULL);
907
908   /* Print a warning if an argument looks like an option.  */
909   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
910     {
911       int i;
912
913       for (i=0; i < argc; i++)
914         if (argv[i][0] == '-' && argv[i][1] == '-')
915           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
916     }
917
918 #ifdef ENABLE_NLS
919   /* gpg-agent usually does not output any messages because it runs in
920      the background.  For log files it is acceptable to have messages
921      always encoded in utf-8.  We switch here to utf-8, so that
922      commands like --help still give native messages.  It is far
923      easier to switch only once instead of for every message and it
924      actually helps when more then one thread is active (avoids an
925      extra copy step). */
926     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
927 #endif
928
929   if (!pipe_server && !is_daemon && !gpgconf_list)
930     {
931      /* We have been called without any options and thus we merely
932         check whether an agent is already running.  We do this right
933         here so that we don't clobber a logfile with this check but
934         print the status directly to stderr. */
935       opt.debug = 0;
936       set_debug ();
937       check_for_running_agent (0);
938       agent_exit (0);
939     }
940
941   set_debug ();
942
943   if (atexit (cleanup))
944     {
945       log_error ("atexit failed\n");
946       cleanup ();
947       exit (1);
948     }
949
950   initialize_module_cache ();
951   initialize_module_call_pinentry ();
952   initialize_module_call_scd ();
953   initialize_module_trustlist ();
954
955   /* Try to create missing directories. */
956   create_directories ();
957
958   if (debug_wait && pipe_server)
959     {
960       log_debug ("waiting for debugger - my pid is %u .....\n",
961                  (unsigned int)getpid());
962       gnupg_sleep (debug_wait);
963       log_debug ("... okay\n");
964     }
965
966   if (gpgconf_list == 3)
967     {
968       /* We now use the standard socket always - return true for
969          backward compatibility.  */
970       agent_exit (0);
971     }
972   else if (gpgconf_list == 2)
973     agent_exit (0);
974   else if (gpgconf_list)
975     {
976       char *filename;
977       char *filename_esc;
978
979       /* List options and default values in the GPG Conf format.  */
980       filename = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
981                                 NULL );
982       filename_esc = percent_escape (filename, NULL);
983
984       es_printf ("%s-%s.conf:%lu:\"%s\n",
985                  GPGCONF_NAME, GPG_AGENT_NAME,
986                  GC_OPT_FLAG_DEFAULT, filename_esc);
987       xfree (filename);
988       xfree (filename_esc);
989
990       es_printf ("verbose:%lu:\n"
991               "quiet:%lu:\n"
992               "debug-level:%lu:\"none:\n"
993               "log-file:%lu:\n",
994               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
995               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
996               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
997               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
998       es_printf ("default-cache-ttl:%lu:%d:\n",
999               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1000       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1001               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1002       es_printf ("max-cache-ttl:%lu:%d:\n",
1003               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1004       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1005               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1006       es_printf ("enforce-passphrase-constraints:%lu:\n",
1007               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1008       es_printf ("min-passphrase-len:%lu:%d:\n",
1009               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1010       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1011               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1012               MIN_PASSPHRASE_NONALPHA);
1013       es_printf ("check-passphrase-pattern:%lu:\n",
1014               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1015       es_printf ("max-passphrase-days:%lu:%d:\n",
1016               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1017               MAX_PASSPHRASE_DAYS);
1018       es_printf ("enable-passphrase-history:%lu:\n",
1019               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1020       es_printf ("no-grab:%lu:\n",
1021               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1022       es_printf ("ignore-cache-for-signing:%lu:\n",
1023               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1024       es_printf ("no-allow-mark-trusted:%lu:\n",
1025               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1026       es_printf ("disable-scdaemon:%lu:\n",
1027               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1028 #ifdef HAVE_W32_SYSTEM
1029       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1030 #else
1031       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1032 #endif
1033
1034       agent_exit (0);
1035     }
1036
1037   /* Now start with logging to a file if this is desired. */
1038   if (logfile)
1039     {
1040       log_set_file (logfile);
1041       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1042                              |JNLIB_LOG_WITH_TIME
1043                              |JNLIB_LOG_WITH_PID));
1044       current_logfile = xstrdup (logfile);
1045     }
1046
1047   /* Make sure that we have a default ttyname. */
1048   if (!default_ttyname && gnupg_ttyname (1))
1049     default_ttyname = xstrdup (gnupg_ttyname (1));
1050   if (!default_ttytype && getenv ("TERM"))
1051     default_ttytype = xstrdup (getenv ("TERM"));
1052
1053
1054   if (pipe_server)
1055     {
1056       /* This is the simple pipe based server */
1057       ctrl_t ctrl;
1058
1059       ctrl = xtrycalloc (1, sizeof *ctrl);
1060       if (!ctrl)
1061         {
1062           log_error ("error allocating connection control data: %s\n",
1063                      strerror (errno) );
1064           agent_exit (1);
1065         }
1066       ctrl->session_env = session_env_new ();
1067       if (!ctrl->session_env)
1068         {
1069           log_error ("error allocating session environment block: %s\n",
1070                      strerror (errno) );
1071           xfree (ctrl);
1072           agent_exit (1);
1073         }
1074       agent_init_default_ctrl (ctrl);
1075       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1076       agent_deinit_default_ctrl (ctrl);
1077       xfree (ctrl);
1078     }
1079   else if (!is_daemon)
1080     ; /* NOTREACHED */
1081   else
1082     { /* Regular server mode */
1083       gnupg_fd_t fd;
1084       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1085       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1086       pid_t pid;
1087
1088       /* Remove the DISPLAY variable so that a pinentry does not
1089          default to a specific display.  There is still a default
1090          display when gpg-agent was started using --display or a
1091          client requested this using an OPTION command.  Note, that we
1092          don't do this when running in reverse daemon mode (i.e. when
1093          exec the program given as arguments). */
1094 #ifndef HAVE_W32_SYSTEM
1095       if (!opt.keep_display && !argc)
1096         gnupg_unsetenv ("DISPLAY");
1097 #endif
1098
1099       /* Create the sockets.  */
1100       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1101       fd = create_server_socket (socket_name, 1, &socket_nonce);
1102
1103       if (opt.extra_socket)
1104         {
1105           socket_name_extra = create_socket_name (socket_name_extra, 0);
1106           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1107           fd_extra = create_server_socket (socket_name_extra, 0,
1108                                            &socket_nonce_extra);
1109         }
1110
1111       if (opt.ssh_support)
1112         {
1113           socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1114           fd_ssh = create_server_socket (socket_name_ssh, 0, &socket_nonce_ssh);
1115         }
1116
1117       /* If we are going to exec a program in the parent, we record
1118          the PID, so that the child may check whether the program is
1119          still alive. */
1120       if (argc)
1121         parent_pid = getpid ();
1122
1123       fflush (NULL);
1124 #ifdef HAVE_W32_SYSTEM
1125       (void)csh_style;
1126       (void)nodetach;
1127       pid = getpid ();
1128 #else /*!HAVE_W32_SYSTEM*/
1129       pid = fork ();
1130       if (pid == (pid_t)-1)
1131         {
1132           log_fatal ("fork failed: %s\n", strerror (errno) );
1133           exit (1);
1134         }
1135       else if (pid)
1136         { /* We are the parent */
1137           char *infostr_ssh_sock, *infostr_ssh_valid;
1138
1139           /* Close the socket FD. */
1140           close (fd);
1141
1142           /* The signal mask might not be correct right now and thus
1143              we restore it.  That is not strictly necessary but some
1144              programs falsely assume a cleared signal mask.  */
1145
1146 #ifdef HAVE_SIGPROCMASK
1147           if (startup_signal_mask_valid)
1148             {
1149               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1150                 log_error ("error restoring signal mask: %s\n",
1151                            strerror (errno));
1152             }
1153           else
1154             log_info ("no saved signal mask\n");
1155 #endif /*HAVE_SIGPROCMASK*/
1156
1157           /* Create the SSH info string if enabled. */
1158           if (opt.ssh_support)
1159             {
1160               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1161                             socket_name_ssh) < 0)
1162                 {
1163                   log_error ("out of core\n");
1164                   kill (pid, SIGTERM);
1165                   exit (1);
1166                 }
1167               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1168                             (unsigned long)getpid()) < 0)
1169                 {
1170                   log_error ("out of core\n");
1171                   kill (pid, SIGTERM);
1172                   exit (1);
1173                 }
1174             }
1175
1176           *socket_name = 0; /* Don't let cleanup() remove the socket -
1177                                the child should do this from now on */
1178           if (opt.extra_socket)
1179             *socket_name_extra = 0;
1180           if (opt.ssh_support)
1181             *socket_name_ssh = 0;
1182
1183           if (argc)
1184             { /* Run the program given on the commandline.  */
1185               if (opt.ssh_support && (putenv (infostr_ssh_sock)
1186                                       || putenv (infostr_ssh_valid)))
1187                 {
1188                   log_error ("failed to set environment: %s\n",
1189                              strerror (errno) );
1190                   kill (pid, SIGTERM );
1191                   exit (1);
1192                 }
1193
1194               /* Close all the file descriptors except the standard
1195                  ones and those open at startup.  We explicitly don't
1196                  close 0,1,2 in case something went wrong collecting
1197                  them at startup.  */
1198               close_all_fds (3, startup_fd_list);
1199
1200               /* Run the command.  */
1201               execvp (argv[0], argv);
1202               log_error ("failed to run the command: %s\n", strerror (errno));
1203               kill (pid, SIGTERM);
1204               exit (1);
1205             }
1206           else
1207             {
1208               /* Print the environment string, so that the caller can use
1209                  shell's eval to set it */
1210               if (csh_style)
1211                 {
1212                   if (opt.ssh_support)
1213                     {
1214                       *strchr (infostr_ssh_sock, '=') = ' ';
1215                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1216                     }
1217                 }
1218               else
1219                 {
1220                   if (opt.ssh_support)
1221                     {
1222                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1223                                  infostr_ssh_sock);
1224                     }
1225                 }
1226               if (opt.ssh_support)
1227                 {
1228                   xfree (infostr_ssh_sock);
1229                   xfree (infostr_ssh_valid);
1230                 }
1231               exit (0);
1232             }
1233           /*NOTREACHED*/
1234         } /* End parent */
1235
1236       /*
1237          This is the child
1238        */
1239
1240       /* Detach from tty and put process into a new session */
1241       if (!nodetach )
1242         {
1243           int i;
1244           unsigned int oldflags;
1245
1246           /* Close stdin, stdout and stderr unless it is the log stream */
1247           for (i=0; i <= 2; i++)
1248             {
1249               if (!log_test_fd (i) && i != fd )
1250                 {
1251                   if ( ! close (i)
1252                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1253                     {
1254                       log_error ("failed to open '%s': %s\n",
1255                                  "/dev/null", strerror (errno));
1256                       cleanup ();
1257                       exit (1);
1258                     }
1259                 }
1260             }
1261           if (setsid() == -1)
1262             {
1263               log_error ("setsid() failed: %s\n", strerror(errno) );
1264               cleanup ();
1265               exit (1);
1266             }
1267
1268           log_get_prefix (&oldflags);
1269           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1270           opt.running_detached = 1;
1271         }
1272
1273       if (chdir("/"))
1274         {
1275           log_error ("chdir to / failed: %s\n", strerror (errno));
1276           exit (1);
1277         }
1278
1279       {
1280         struct sigaction sa;
1281
1282         sa.sa_handler = SIG_IGN;
1283         sigemptyset (&sa.sa_mask);
1284         sa.sa_flags = 0;
1285         sigaction (SIGPIPE, &sa, NULL);
1286       }
1287 #endif /*!HAVE_W32_SYSTEM*/
1288
1289       log_info ("%s %s started\n", strusage(11), strusage(13) );
1290       handle_connections (fd, fd_extra, fd_ssh);
1291       assuan_sock_close (fd);
1292     }
1293
1294   return 0;
1295 }
1296
1297
1298 /* Exit entry point.  This function should be called instead of a
1299    plain exit.  */
1300 void
1301 agent_exit (int rc)
1302 {
1303   /*FIXME: update_random_seed_file();*/
1304
1305   /* We run our cleanup handler because that may close cipher contexts
1306      stored in secure memory and thus this needs to be done before we
1307      explicitly terminate secure memory.  */
1308   cleanup ();
1309
1310 #if 1
1311   /* at this time a bit annoying */
1312   if (opt.debug & DBG_MEMSTAT_VALUE)
1313     {
1314       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1315       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1316     }
1317   if (opt.debug)
1318     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1319 #endif
1320   gcry_control (GCRYCTL_TERM_SECMEM );
1321   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1322   exit (rc);
1323 }
1324
1325
1326 /* Each thread has its own local variables conveyed by a control
1327    structure usually identified by an argument named CTRL.  This
1328    function is called immediately after allocating the control
1329    structure.  Its purpose is to setup the default values for that
1330    structure.  Note that some values may have already been set.  */
1331 static void
1332 agent_init_default_ctrl (ctrl_t ctrl)
1333 {
1334   assert (ctrl->session_env);
1335
1336   /* Note we ignore malloc errors because we can't do much about it
1337      and the request will fail anyway shortly after this
1338      initialization. */
1339   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1340   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1341   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1342   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1343   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1344
1345   if (ctrl->lc_ctype)
1346     xfree (ctrl->lc_ctype);
1347   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1348
1349   if (ctrl->lc_messages)
1350     xfree (ctrl->lc_messages);
1351   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1352                                     /**/ : NULL;
1353   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1354 }
1355
1356
1357 /* Release all resources allocated by default in the control
1358    structure.  This is the counterpart to agent_init_default_ctrl.  */
1359 static void
1360 agent_deinit_default_ctrl (ctrl_t ctrl)
1361 {
1362   session_env_release (ctrl->session_env);
1363
1364   if (ctrl->lc_ctype)
1365     xfree (ctrl->lc_ctype);
1366   if (ctrl->lc_messages)
1367     xfree (ctrl->lc_messages);
1368 }
1369
1370
1371 /* Reread parts of the configuration.  Note, that this function is
1372    obviously not thread-safe and should only be called from the PTH
1373    signal handler.
1374
1375    Fixme: Due to the way the argument parsing works, we create a
1376    memory leak here for all string type arguments.  There is currently
1377    no clean way to tell whether the memory for the argument has been
1378    allocated or points into the process' original arguments.  Unless
1379    we have a mechanism to tell this, we need to live on with this. */
1380 static void
1381 reread_configuration (void)
1382 {
1383   ARGPARSE_ARGS pargs;
1384   FILE *fp;
1385   unsigned int configlineno = 0;
1386   int dummy;
1387
1388   if (!config_filename)
1389     return; /* No config file. */
1390
1391   fp = fopen (config_filename, "r");
1392   if (!fp)
1393     {
1394       log_info (_("option file '%s': %s\n"),
1395                 config_filename, strerror(errno) );
1396       return;
1397     }
1398
1399   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1400
1401   memset (&pargs, 0, sizeof pargs);
1402   dummy = 0;
1403   pargs.argc = &dummy;
1404   pargs.flags = 1;  /* do not remove the args */
1405   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1406     {
1407       if (pargs.r_opt < -1)
1408         pargs.err = 1; /* Print a warning. */
1409       else /* Try to parse this option - ignore unchangeable ones. */
1410         parse_rereadable_options (&pargs, 1);
1411     }
1412   fclose (fp);
1413   set_debug ();
1414 }
1415
1416
1417 /* Return the file name of the socket we are using for native
1418    requests.  */
1419 const char *
1420 get_agent_socket_name (void)
1421 {
1422   const char *s = socket_name;
1423
1424   return (s && *s)? s : NULL;
1425 }
1426
1427 /* Return the file name of the socket we are using for SSH
1428    requests.  */
1429 const char *
1430 get_agent_ssh_socket_name (void)
1431 {
1432   const char *s = socket_name_ssh;
1433
1434   return (s && *s)? s : NULL;
1435 }
1436
1437
1438 /* Under W32, this function returns the handle of the scdaemon
1439    notification event.  Calling it the first time creates that
1440    event.  */
1441 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1442 void *
1443 get_agent_scd_notify_event (void)
1444 {
1445   static HANDLE the_event = INVALID_HANDLE_VALUE;
1446
1447   if (the_event == INVALID_HANDLE_VALUE)
1448     {
1449       HANDLE h, h2;
1450       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1451
1452       /* We need to use a manual reset event object due to the way our
1453          w32-pth wait function works: If we would use an automatic
1454          reset event we are not able to figure out which handle has
1455          been signaled because at the time we single out the signaled
1456          handles using WFSO the event has already been reset due to
1457          the WFMO.  */
1458       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1459       if (!h)
1460         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1461       else if (!DuplicateHandle (GetCurrentProcess(), h,
1462                                  GetCurrentProcess(), &h2,
1463                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1464         {
1465           log_error ("setting syncronize for scd notify event failed: %s\n",
1466                      w32_strerror (-1) );
1467           CloseHandle (h);
1468         }
1469       else
1470         {
1471           CloseHandle (h);
1472           the_event = h2;
1473         }
1474     }
1475
1476   return the_event;
1477 }
1478 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1479
1480
1481
1482 /* Create a name for the socket in the home directory as using
1483    STANDARD_NAME.  We also check for valid characters as well as
1484    against a maximum allowed length for a unix domain socket is done.
1485    The function terminates the process in case of an error.  Returns:
1486    Pointer to an allocated string with the absolute name of the socket
1487    used.  */
1488 static char *
1489 create_socket_name (char *standard_name, int with_homedir)
1490 {
1491   char *name;
1492
1493   if (with_homedir)
1494     name = make_filename (opt.homedir, standard_name, NULL);
1495   else
1496     name = make_filename (standard_name, NULL);
1497   if (strchr (name, PATHSEP_C))
1498     {
1499       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1500       agent_exit (2);
1501     }
1502   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1503     {
1504       log_error (_("name of socket too long\n"));
1505       agent_exit (2);
1506     }
1507   return name;
1508 }
1509
1510
1511
1512 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1513    or terminates the process in case of an error.  Note that this
1514    function needs to be used for the regular socket first (indicated
1515    by PRIMARY) and only then for the extra and the ssh sockets.  */
1516 static gnupg_fd_t
1517 create_server_socket (char *name, int primary, assuan_sock_nonce_t *nonce)
1518 {
1519   struct sockaddr_un *serv_addr;
1520   socklen_t len;
1521   gnupg_fd_t fd;
1522   int rc;
1523
1524   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1525   if (fd == ASSUAN_INVALID_FD)
1526     {
1527       log_error (_("can't create socket: %s\n"), strerror (errno));
1528       agent_exit (2);
1529     }
1530
1531   serv_addr = xmalloc (sizeof (*serv_addr));
1532   memset (serv_addr, 0, sizeof *serv_addr);
1533   serv_addr->sun_family = AF_UNIX;
1534   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1535     {
1536       log_error (_("socket name '%s' is too long\n"), name);
1537       agent_exit (2);
1538     }
1539   strcpy (serv_addr->sun_path, name);
1540   len = SUN_LEN (serv_addr);
1541   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1542
1543   /* Our error code mapping on W32CE returns EEXIST thus we also test
1544      for this. */
1545   if (rc == -1
1546       && (errno == EADDRINUSE
1547 #ifdef HAVE_W32_SYSTEM
1548           || errno == EEXIST
1549 #endif
1550           ))
1551     {
1552       /* Check whether a gpg-agent is already running.
1553          We do this test only if this is not the ssh socket.
1554          For ssh we assume that a test for gpg-agent has already been
1555          done and reuse the requested ssh socket.  Testing the
1556          ssh-socket is not possible because at this point, though we
1557          know the new Assuan socket, the Assuan server and thus the
1558          ssh-agent server is not yet operational.  This would lead to
1559          a hang.  */
1560       if (primary && !check_for_running_agent (1))
1561         {
1562           log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
1563           log_set_file (NULL);
1564           log_error (_("a gpg-agent is already running - "
1565                        "not starting a new one\n"));
1566           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1567           assuan_sock_close (fd);
1568           agent_exit (2);
1569         }
1570       gnupg_remove (name);
1571       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1572     }
1573   if (rc != -1
1574       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1575     log_error (_("error getting nonce for the socket\n"));
1576   if (rc == -1)
1577     {
1578       /* We use gpg_strerror here because it allows us to get strings
1579          for some W32 socket error codes.  */
1580       log_error (_("error binding socket to '%s': %s\n"),
1581                  serv_addr->sun_path,
1582                  gpg_strerror (gpg_error_from_errno (errno)));
1583
1584       assuan_sock_close (fd);
1585       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1586       agent_exit (2);
1587     }
1588
1589   if (listen (FD2INT(fd), 5 ) == -1)
1590     {
1591       log_error (_("listen() failed: %s\n"), strerror (errno));
1592       assuan_sock_close (fd);
1593       agent_exit (2);
1594     }
1595
1596   if (opt.verbose)
1597     log_info (_("listening on socket '%s'\n"), serv_addr->sun_path);
1598
1599   return fd;
1600 }
1601
1602
1603 /* Check that the directory for storing the private keys exists and
1604    create it if not.  This function won't fail as it is only a
1605    convenience function and not strictly necessary.  */
1606 static void
1607 create_private_keys_directory (const char *home)
1608 {
1609   char *fname;
1610   struct stat statbuf;
1611
1612   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1613   if (stat (fname, &statbuf) && errno == ENOENT)
1614     {
1615       if (gnupg_mkdir (fname, "-rwx"))
1616         log_error (_("can't create directory '%s': %s\n"),
1617                    fname, strerror (errno) );
1618       else if (!opt.quiet)
1619         log_info (_("directory '%s' created\n"), fname);
1620     }
1621   xfree (fname);
1622 }
1623
1624 /* Create the directory only if the supplied directory name is the
1625    same as the default one.  This way we avoid to create arbitrary
1626    directories when a non-default home directory is used.  To cope
1627    with HOME, we compare only the suffix if we see that the default
1628    homedir does start with a tilde.  We don't stop here in case of
1629    problems because other functions will throw an error anyway.*/
1630 static void
1631 create_directories (void)
1632 {
1633   struct stat statbuf;
1634   const char *defhome = standard_homedir ();
1635   char *home;
1636
1637   home = make_filename (opt.homedir, NULL);
1638   if ( stat (home, &statbuf) )
1639     {
1640       if (errno == ENOENT)
1641         {
1642           if (
1643 #ifdef HAVE_W32_SYSTEM
1644               ( !compare_filenames (home, defhome) )
1645 #else
1646               (*defhome == '~'
1647                 && (strlen (home) >= strlen (defhome+1)
1648                     && !strcmp (home + strlen(home)
1649                                 - strlen (defhome+1), defhome+1)))
1650                || (*defhome != '~' && !strcmp (home, defhome) )
1651 #endif
1652                )
1653             {
1654               if (gnupg_mkdir (home, "-rwx"))
1655                 log_error (_("can't create directory '%s': %s\n"),
1656                            home, strerror (errno) );
1657               else
1658                 {
1659                   if (!opt.quiet)
1660                     log_info (_("directory '%s' created\n"), home);
1661                   create_private_keys_directory (home);
1662                 }
1663             }
1664         }
1665       else
1666         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1667     }
1668   else if ( !S_ISDIR(statbuf.st_mode))
1669     {
1670       log_error (_("can't use '%s' as home directory\n"), home);
1671     }
1672   else /* exists and is a directory. */
1673     {
1674       create_private_keys_directory (home);
1675     }
1676   xfree (home);
1677 }
1678
1679
1680
1681 /* This is the worker for the ticker.  It is called every few seconds
1682    and may only do fast operations. */
1683 static void
1684 handle_tick (void)
1685 {
1686   static time_t last_minute;
1687
1688   if (!last_minute)
1689     last_minute = time (NULL);
1690
1691   /* Check whether the scdaemon has died and cleanup in this case. */
1692   agent_scd_check_aliveness ();
1693
1694   /* If we are running as a child of another process, check whether
1695      the parent is still alive and shutdown if not. */
1696 #ifndef HAVE_W32_SYSTEM
1697   if (parent_pid != (pid_t)(-1))
1698     {
1699       if (kill (parent_pid, 0))
1700         {
1701           shutdown_pending = 2;
1702           log_info ("parent process died - shutting down\n");
1703           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1704           cleanup ();
1705           agent_exit (0);
1706         }
1707     }
1708 #endif /*HAVE_W32_SYSTEM*/
1709
1710   /* Code to be run from time to time.  */
1711 #if CHECK_OWN_SOCKET_INTERVAL > 0
1712   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1713     {
1714       check_own_socket ();
1715       last_minute = time (NULL);
1716     }
1717 #endif
1718
1719 }
1720
1721
1722 /* A global function which allows us to call the reload stuff from
1723    other places too.  This is only used when build for W32.  */
1724 void
1725 agent_sighup_action (void)
1726 {
1727   log_info ("SIGHUP received - "
1728             "re-reading configuration and flushing cache\n");
1729   agent_flush_cache ();
1730   reread_configuration ();
1731   agent_reload_trustlist ();
1732 }
1733
1734
1735 /* A helper function to handle SIGUSR2.  */
1736 static void
1737 agent_sigusr2_action (void)
1738 {
1739   if (opt.verbose)
1740     log_info ("SIGUSR2 received - updating card event counter\n");
1741   /* Nothing to check right now.  We only increment a counter.  */
1742   bump_card_eventcounter ();
1743 }
1744
1745
1746 #ifndef HAVE_W32_SYSTEM
1747 /* The signal handler for this program.  It is expected to be run in
1748    its own trhead and not in the context of a signal handler.  */
1749 static void
1750 handle_signal (int signo)
1751 {
1752   switch (signo)
1753     {
1754 #ifndef HAVE_W32_SYSTEM
1755     case SIGHUP:
1756       agent_sighup_action ();
1757       break;
1758
1759     case SIGUSR1:
1760       log_info ("SIGUSR1 received - printing internal information:\n");
1761       /* Fixme: We need to see how to integrate pth dumping into our
1762          logging system.  */
1763       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1764       agent_query_dump_state ();
1765       agent_scd_dump_state ();
1766       break;
1767
1768     case SIGUSR2:
1769       agent_sigusr2_action ();
1770       break;
1771
1772     case SIGTERM:
1773       if (!shutdown_pending)
1774         log_info ("SIGTERM received - shutting down ...\n");
1775       else
1776         log_info ("SIGTERM received - still %i open connections\n",
1777                   active_connections);
1778       shutdown_pending++;
1779       if (shutdown_pending > 2)
1780         {
1781           log_info ("shutdown forced\n");
1782           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1783           cleanup ();
1784           agent_exit (0);
1785         }
1786       break;
1787
1788     case SIGINT:
1789       log_info ("SIGINT received - immediate shutdown\n");
1790       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1791       cleanup ();
1792       agent_exit (0);
1793       break;
1794 #endif
1795     default:
1796       log_info ("signal %d received - no action defined\n", signo);
1797     }
1798 }
1799 #endif
1800
1801 /* Check the nonce on a new connection.  This is a NOP unless we we
1802    are using our Unix domain socket emulation under Windows.  */
1803 static int
1804 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1805 {
1806   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1807     {
1808       log_info (_("error reading nonce on fd %d: %s\n"),
1809                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1810       assuan_sock_close (ctrl->thread_startup.fd);
1811       xfree (ctrl);
1812       return -1;
1813     }
1814   else
1815     return 0;
1816 }
1817
1818
1819 #ifdef HAVE_W32_SYSTEM
1820 /* The window message processing function for Putty.  Warning: This
1821    code runs as a native Windows thread.  Use of our own functions
1822    needs to be bracket with pth_leave/pth_enter. */
1823 static LRESULT CALLBACK
1824 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1825 {
1826   int ret = 0;
1827   int w32rc;
1828   COPYDATASTRUCT *cds;
1829   const char *mapfile;
1830   HANDLE maphd;
1831   PSID mysid = NULL;
1832   PSID mapsid = NULL;
1833   void *data = NULL;
1834   PSECURITY_DESCRIPTOR psd = NULL;
1835   ctrl_t ctrl = NULL;
1836
1837   if (msg != WM_COPYDATA)
1838     {
1839       return DefWindowProc (hwnd, msg, wparam, lparam);
1840     }
1841
1842   cds = (COPYDATASTRUCT*)lparam;
1843   if (cds->dwData != PUTTY_IPC_MAGIC)
1844     return 0;  /* Ignore data with the wrong magic.  */
1845   mapfile = cds->lpData;
1846   if (!cds->cbData || mapfile[cds->cbData - 1])
1847     return 0;  /* Ignore empty and non-properly terminated strings.  */
1848
1849   if (DBG_ASSUAN)
1850     {
1851       npth_protect ();
1852       log_debug ("ssh map file '%s'", mapfile);
1853       npth_unprotect ();
1854     }
1855
1856   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
1857   if (DBG_ASSUAN)
1858     {
1859       npth_protect ();
1860       log_debug ("ssh map handle %p\n", maphd);
1861       npth_unprotect ();
1862     }
1863
1864   if (!maphd || maphd == INVALID_HANDLE_VALUE)
1865     return 0;
1866
1867   npth_protect ();
1868
1869   mysid = w32_get_user_sid ();
1870   if (!mysid)
1871     {
1872       log_error ("error getting my sid\n");
1873       goto leave;
1874     }
1875
1876   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
1877                            OWNER_SECURITY_INFORMATION,
1878                            &mapsid, NULL, NULL, NULL,
1879                            &psd);
1880   if (w32rc)
1881     {
1882       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
1883       goto leave;
1884     }
1885
1886   if (DBG_ASSUAN)
1887     {
1888       char *sidstr;
1889
1890       if (!ConvertSidToStringSid (mysid, &sidstr))
1891         sidstr = NULL;
1892       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
1893       LocalFree (sidstr);
1894       if (!ConvertSidToStringSid (mapsid, &sidstr))
1895         sidstr = NULL;
1896       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
1897       LocalFree (sidstr);
1898     }
1899
1900   if (!EqualSid (mysid, mapsid))
1901     {
1902       log_error ("ssh map file has a non-matching sid\n");
1903       goto leave;
1904     }
1905
1906   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
1907   if (DBG_ASSUAN)
1908     log_debug ("ssh IPC buffer at %p\n", data);
1909   if (!data)
1910     goto leave;
1911
1912   /* log_printhex ("request:", data, 20); */
1913
1914   ctrl = xtrycalloc (1, sizeof *ctrl);
1915   if (!ctrl)
1916     {
1917       log_error ("error allocating connection control data: %s\n",
1918                  strerror (errno) );
1919       goto leave;
1920     }
1921   ctrl->session_env = session_env_new ();
1922   if (!ctrl->session_env)
1923     {
1924       log_error ("error allocating session environment block: %s\n",
1925                  strerror (errno) );
1926       goto leave;
1927     }
1928
1929   agent_init_default_ctrl (ctrl);
1930   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
1931     ret = 1; /* Valid ssh message has been constructed.  */
1932   agent_deinit_default_ctrl (ctrl);
1933   /* log_printhex ("  reply:", data, 20); */
1934
1935  leave:
1936   xfree (ctrl);
1937   if (data)
1938     UnmapViewOfFile (data);
1939   xfree (mapsid);
1940   if (psd)
1941     LocalFree (psd);
1942   xfree (mysid);
1943   CloseHandle (maphd);
1944
1945   npth_unprotect ();
1946
1947   return ret;
1948 }
1949 #endif /*HAVE_W32_SYSTEM*/
1950
1951
1952 #ifdef HAVE_W32_SYSTEM
1953 /* The thread handling Putty's IPC requests.  */
1954 static void *
1955 putty_message_thread (void *arg)
1956 {
1957   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
1958                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
1959   HWND hwnd;
1960   MSG msg;
1961
1962   (void)arg;
1963
1964   if (opt.verbose)
1965     log_info ("putty message loop thread started\n");
1966
1967   /* The message loop runs as thread independent from our nPth system.
1968      This also means that we need to make sure that we switch back to
1969      our system before calling any no-windows function.  */
1970   npth_unprotect ();
1971
1972   /* First create a window to make sure that a message queue exists
1973      for this thread.  */
1974   if (!RegisterClass (&wndwclass))
1975     {
1976       npth_protect ();
1977       log_error ("error registering Pageant window class");
1978       return NULL;
1979     }
1980   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
1981                          0, 0, 0, 0,
1982                          HWND_MESSAGE,  /* hWndParent */
1983                          NULL,          /* hWndMenu   */
1984                          NULL,          /* hInstance  */
1985                          NULL);         /* lpParm     */
1986   if (!hwnd)
1987     {
1988       npth_protect ();
1989       log_error ("error creating Pageant window");
1990       return NULL;
1991     }
1992
1993   while (GetMessage(&msg, NULL, 0, 0))
1994     {
1995       TranslateMessage(&msg);
1996       DispatchMessage(&msg);
1997     }
1998
1999   /* Back to nPth.  */
2000   npth_protect ();
2001
2002   if (opt.verbose)
2003     log_info ("putty message loop thread stopped\n");
2004   return NULL;
2005 }
2006 #endif /*HAVE_W32_SYSTEM*/
2007
2008
2009 static void *
2010 start_connection_thread (ctrl_t ctrl)
2011 {
2012   if (check_nonce (ctrl, &socket_nonce))
2013     {
2014       log_error ("handler 0x%lx nonce check FAILED\n",
2015                  (unsigned long) npth_self());
2016       return NULL;
2017     }
2018
2019   agent_init_default_ctrl (ctrl);
2020   if (opt.verbose)
2021     log_info (_("handler 0x%lx for fd %d started\n"),
2022               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2023
2024   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2025   if (opt.verbose)
2026     log_info (_("handler 0x%lx for fd %d terminated\n"),
2027               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2028
2029   agent_deinit_default_ctrl (ctrl);
2030   xfree (ctrl);
2031   return NULL;
2032 }
2033
2034
2035 /* This is the standard connection thread's main function.  */
2036 static void *
2037 start_connection_thread_std (void *arg)
2038 {
2039   ctrl_t ctrl = arg;
2040
2041   return start_connection_thread (ctrl);
2042 }
2043
2044
2045 /* This is the extra socket connection thread's main function.  */
2046 static void *
2047 start_connection_thread_extra (void *arg)
2048 {
2049   ctrl_t ctrl = arg;
2050
2051   ctrl->restricted = 1;
2052   return start_connection_thread (ctrl);
2053 }
2054
2055
2056 /* This is the ssh connection thread's main function.  */
2057 static void *
2058 start_connection_thread_ssh (void *arg)
2059 {
2060   ctrl_t ctrl = arg;
2061
2062   if (check_nonce (ctrl, &socket_nonce_ssh))
2063     return NULL;
2064
2065   agent_init_default_ctrl (ctrl);
2066   if (opt.verbose)
2067     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2068               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2069
2070   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2071   if (opt.verbose)
2072     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2073               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2074
2075   agent_deinit_default_ctrl (ctrl);
2076   xfree (ctrl);
2077   return NULL;
2078 }
2079
2080
2081 /* Connection handler loop.  Wait for connection requests and spawn a
2082    thread after accepting a connection.  */
2083 static void
2084 handle_connections (gnupg_fd_t listen_fd,
2085                     gnupg_fd_t listen_fd_extra,
2086                     gnupg_fd_t listen_fd_ssh)
2087 {
2088   npth_attr_t tattr;
2089   struct sockaddr_un paddr;
2090   socklen_t plen;
2091   fd_set fdset, read_fdset;
2092   int ret;
2093   gnupg_fd_t fd;
2094   int nfd;
2095   int saved_errno;
2096   struct timespec abstime;
2097   struct timespec curtime;
2098   struct timespec timeout;
2099 #ifdef HAVE_W32_SYSTEM
2100   HANDLE events[2];
2101   unsigned int events_set;
2102 #endif
2103   struct {
2104     const char *name;
2105     void *(*func) (void *arg);
2106     gnupg_fd_t l_fd;
2107   } listentbl[] = {
2108     { "std",  start_connection_thread_std   },
2109     { "extra",start_connection_thread_extra },
2110     { "ssh",  start_connection_thread_ssh   }
2111   };
2112
2113
2114   ret = npth_attr_init(&tattr);
2115   if (ret)
2116     log_fatal ("error allocating thread attributes: %s\n",
2117                strerror (ret));
2118   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2119
2120 #ifndef HAVE_W32_SYSTEM
2121   npth_sigev_init ();
2122   npth_sigev_add (SIGHUP);
2123   npth_sigev_add (SIGUSR1);
2124   npth_sigev_add (SIGUSR2);
2125   npth_sigev_add (SIGINT);
2126   npth_sigev_add (SIGTERM);
2127   npth_sigev_fini ();
2128 #else
2129 # ifdef HAVE_W32CE_SYSTEM
2130   /* Use a dummy event. */
2131   sigs = 0;
2132   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2133 # else
2134   events[0] = get_agent_scd_notify_event ();
2135   events[1] = INVALID_HANDLE_VALUE;
2136 # endif
2137 #endif
2138
2139   /* On Windows we need to fire up a separate thread to listen for
2140      requests from Putty (an SSH client), so we can replace Putty's
2141      Pageant (its ssh-agent implementation). */
2142 #ifdef HAVE_W32_SYSTEM
2143   if (putty_support)
2144     {
2145       npth_t thread;
2146
2147       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2148       if (ret)
2149         {
2150           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2151         }
2152     }
2153 #endif /*HAVE_W32_SYSTEM*/
2154
2155   /* Set a flag to tell call-scd.c that it may enable event
2156      notifications.  */
2157   opt.sigusr2_enabled = 1;
2158
2159   FD_ZERO (&fdset);
2160   FD_SET (FD2INT (listen_fd), &fdset);
2161   nfd = FD2INT (listen_fd);
2162   if (listen_fd_extra != GNUPG_INVALID_FD)
2163     {
2164       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2165       if (FD2INT (listen_fd_extra) > nfd)
2166         nfd = FD2INT (listen_fd_extra);
2167     }
2168   if (listen_fd_ssh != GNUPG_INVALID_FD)
2169     {
2170       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2171       if (FD2INT (listen_fd_ssh) > nfd)
2172         nfd = FD2INT (listen_fd_ssh);
2173     }
2174
2175   listentbl[0].l_fd = listen_fd;
2176   listentbl[1].l_fd = listen_fd_extra;
2177   listentbl[2].l_fd = listen_fd_ssh;
2178
2179   npth_clock_gettime (&abstime);
2180   abstime.tv_sec += TIMERTICK_INTERVAL;
2181
2182   for (;;)
2183     {
2184       /* Shutdown test.  */
2185       if (shutdown_pending)
2186         {
2187           if (active_connections == 0)
2188             break; /* ready */
2189
2190           /* Do not accept new connections but keep on running the
2191              loop to cope with the timer events.  */
2192           FD_ZERO (&fdset);
2193         }
2194
2195       /* POSIX says that fd_set should be implemented as a structure,
2196          thus a simple assignment is fine to copy the entire set.  */
2197       read_fdset = fdset;
2198
2199       npth_clock_gettime (&curtime);
2200       if (!(npth_timercmp (&curtime, &abstime, <)))
2201         {
2202           /* Timeout.  */
2203           handle_tick ();
2204           npth_clock_gettime (&abstime);
2205           abstime.tv_sec += TIMERTICK_INTERVAL;
2206         }
2207       npth_timersub (&abstime, &curtime, &timeout);
2208
2209 #ifndef HAVE_W32_SYSTEM
2210       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2211                           npth_sigev_sigmask ());
2212       saved_errno = errno;
2213
2214       {
2215         int signo;
2216         while (npth_sigev_get_pending (&signo))
2217           handle_signal (signo);
2218       }
2219 #else
2220       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2221                           events, &events_set);
2222       saved_errno = errno;
2223
2224       /* This is valid even if npth_eselect returns an error.  */
2225       if (events_set & 1)
2226         agent_sigusr2_action ();
2227 #endif
2228
2229       if (ret == -1 && saved_errno != EINTR)
2230         {
2231           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2232                      strerror (saved_errno));
2233           npth_sleep (1);
2234           continue;
2235         }
2236       if (ret <= 0)
2237         /* Interrupt or timeout.  Will be handled when calculating the
2238            next timeout.  */
2239         continue;
2240
2241       if (!shutdown_pending)
2242         {
2243           int idx;
2244           ctrl_t ctrl;
2245           npth_t thread;
2246
2247           for (idx=0; idx < DIM(listentbl); idx++)
2248             {
2249               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2250                 continue;
2251               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2252                 continue;
2253
2254               plen = sizeof paddr;
2255               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2256                                         (struct sockaddr *)&paddr, &plen));
2257               if (fd == GNUPG_INVALID_FD)
2258                 {
2259                   log_error ("accept failed for %s: %s\n",
2260                              listentbl[idx].name, strerror (errno));
2261                 }
2262               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2263                 {
2264                   log_error ("error allocating connection data for %s: %s\n",
2265                              listentbl[idx].name, strerror (errno) );
2266                   assuan_sock_close (fd);
2267                 }
2268               else if ( !(ctrl->session_env = session_env_new ()))
2269                 {
2270                   log_error ("error allocating session env block for %s: %s\n",
2271                              listentbl[idx].name, strerror (errno) );
2272                   xfree (ctrl);
2273                   assuan_sock_close (fd);
2274                 }
2275               else
2276                 {
2277                   ctrl->thread_startup.fd = fd;
2278                   ret = npth_create (&thread, &tattr,
2279                                      listentbl[idx].func, ctrl);
2280                   if (ret)
2281                     {
2282                       log_error ("error spawning connection handler for %s:"
2283                                  " %s\n", listentbl[idx].name, strerror (ret));
2284                       assuan_sock_close (fd);
2285                       xfree (ctrl);
2286                     }
2287                 }
2288               fd = GNUPG_INVALID_FD;
2289             }
2290         }
2291     }
2292
2293   cleanup ();
2294   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2295   npth_attr_destroy (&tattr);
2296 }
2297
2298
2299
2300 /* Helper for check_own_socket.  */
2301 static gpg_error_t
2302 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2303 {
2304   membuf_t *mb = opaque;
2305   put_membuf (mb, buffer, length);
2306   return 0;
2307 }
2308
2309
2310 /* The thread running the actual check.  We need to run this in a
2311    separate thread so that check_own_thread can be called from the
2312    timer tick.  */
2313 static void *
2314 check_own_socket_thread (void *arg)
2315 {
2316   int rc;
2317   char *sockname = arg;
2318   assuan_context_t ctx = NULL;
2319   membuf_t mb;
2320   char *buffer;
2321
2322   check_own_socket_running++;
2323
2324   rc = assuan_new (&ctx);
2325   if (rc)
2326     {
2327       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2328       goto leave;
2329     }
2330
2331   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2332   if (rc)
2333     {
2334       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2335       goto leave;
2336     }
2337
2338   init_membuf (&mb, 100);
2339   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2340                         NULL, NULL, NULL, NULL);
2341   put_membuf (&mb, "", 1);
2342   buffer = get_membuf (&mb, NULL);
2343   if (rc || !buffer)
2344     {
2345       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2346                  "GETINFO pid", gpg_strerror (rc));
2347       rc = 1;
2348     }
2349   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2350     {
2351       log_error ("socket is now serviced by another server\n");
2352       rc = 1;
2353     }
2354   else if (opt.verbose > 1)
2355     log_error ("socket is still served by this server\n");
2356
2357   xfree (buffer);
2358
2359  leave:
2360   xfree (sockname);
2361   if (ctx)
2362     assuan_release (ctx);
2363   if (rc)
2364     {
2365       /* We may not remove the socket as it is now in use by another
2366          server.  Setting the name to empty does this.  */
2367       if (socket_name)
2368         *socket_name = 0;
2369       if (socket_name_ssh)
2370         *socket_name_ssh = 0;
2371       shutdown_pending = 2;
2372       log_info ("this process is useless - shutting down\n");
2373     }
2374   check_own_socket_running--;
2375   return NULL;
2376 }
2377
2378
2379 /* Check whether we are still listening on our own socket.  In case
2380    another gpg-agent process started after us has taken ownership of
2381    our socket, we would linger around without any real task.  Thus we
2382    better check once in a while whether we are really needed.  */
2383 static void
2384 check_own_socket (void)
2385 {
2386   char *sockname;
2387   npth_t thread;
2388   npth_attr_t tattr;
2389   int err;
2390
2391   if (disable_check_own_socket)
2392     return;
2393
2394   if (check_own_socket_running || shutdown_pending)
2395     return;  /* Still running or already shutting down.  */
2396
2397   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2398   if (!sockname)
2399     return; /* Out of memory.  */
2400
2401   err = npth_attr_init (&tattr);
2402   if (err)
2403     return;
2404   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2405   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2406   if (err)
2407     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2408   npth_attr_destroy (&tattr);
2409 }
2410
2411
2412
2413 /* Figure out whether an agent is available and running. Prints an
2414    error if not.  If SILENT is true, no messages are printed.
2415    Returns 0 if the agent is running. */
2416 static int
2417 check_for_running_agent (int silent)
2418 {
2419   gpg_error_t err;
2420   char *sockname;
2421   assuan_context_t ctx = NULL;
2422
2423   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2424
2425   err = assuan_new (&ctx);
2426   if (!err)
2427     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2428   xfree (sockname);
2429   if (err)
2430     {
2431       if (!silent)
2432         log_error (_("no gpg-agent running in this session\n"));
2433
2434       if (ctx)
2435         assuan_release (ctx);
2436       return -1;
2437     }
2438
2439   if (!opt.quiet && !silent)
2440     log_info ("gpg-agent running and available\n");
2441
2442   assuan_release (ctx);
2443   return 0;
2444 }