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