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