ECC Fixes.
[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   /* Turn the homedir into an absolute one. */
889   opt.homedir = make_absfilename (opt.homedir, NULL);
890
891
892   if (greeting)
893     {
894       es_fprintf (es_stderr, "%s %s; %s\n",
895                   strusage(11), strusage(13), strusage(14) );
896       es_fprintf (es_stderr, "%s\n", strusage(15) );
897     }
898 #ifdef IS_DEVELOPMENT_VERSION
899   /* We don't want to print it here because gpg-agent is useful of its
900      own and quite matured.  */
901   /*log_info ("NOTE: this is a development version!\n");*/
902 #endif
903
904   /* Print a warning if an argument looks like an option.  */
905   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
906     {
907       int i;
908
909       for (i=0; i < argc; i++)
910         if (argv[i][0] == '-' && argv[i][1] == '-')
911           log_info (_("NOTE: '%s' is not considered an option\n"), argv[i]);
912     }
913
914 #ifdef ENABLE_NLS
915   /* gpg-agent usually does not output any messages because it runs in
916      the background.  For log files it is acceptable to have messages
917      always encoded in utf-8.  We switch here to utf-8, so that
918      commands like --help still give native messages.  It is far
919      easier to switch only once instead of for every message and it
920      actually helps when more then one thread is active (avoids an
921      extra copy step). */
922     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
923 #endif
924
925   if (!pipe_server && !is_daemon && !gpgconf_list)
926     {
927      /* We have been called without any options and thus we merely
928         check whether an agent is already running.  We do this right
929         here so that we don't clobber a logfile with this check but
930         print the status directly to stderr. */
931       opt.debug = 0;
932       set_debug ();
933       check_for_running_agent (0, 0);
934       agent_exit (0);
935     }
936
937   set_debug ();
938
939   if (atexit (cleanup))
940     {
941       log_error ("atexit failed\n");
942       cleanup ();
943       exit (1);
944     }
945
946   initialize_module_cache ();
947   initialize_module_call_pinentry ();
948   initialize_module_call_scd ();
949   initialize_module_trustlist ();
950
951   /* Try to create missing directories. */
952   create_directories ();
953
954   if (debug_wait && pipe_server)
955     {
956       log_debug ("waiting for debugger - my pid is %u .....\n",
957                  (unsigned int)getpid());
958       gnupg_sleep (debug_wait);
959       log_debug ("... okay\n");
960     }
961
962   if (gpgconf_list == 3)
963     {
964       if (opt.use_standard_socket && !opt.quiet)
965         log_info ("configured to use the standard socket\n");
966       agent_exit (!opt.use_standard_socket);
967     }
968   else if (gpgconf_list == 2)
969     agent_exit (0);
970   else if (gpgconf_list)
971     {
972       char *filename;
973       char *filename_esc;
974
975       /* List options and default values in the GPG Conf format.  */
976       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
977       filename_esc = percent_escape (filename, NULL);
978
979       es_printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
980               GC_OPT_FLAG_DEFAULT, filename_esc);
981       xfree (filename);
982       xfree (filename_esc);
983
984       es_printf ("verbose:%lu:\n"
985               "quiet:%lu:\n"
986               "debug-level:%lu:\"none:\n"
987               "log-file:%lu:\n",
988               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
989               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
990               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
991               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
992       es_printf ("default-cache-ttl:%lu:%d:\n",
993               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
994       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
995               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
996       es_printf ("max-cache-ttl:%lu:%d:\n",
997               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
998       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
999               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1000       es_printf ("enforce-passphrase-constraints:%lu:\n",
1001               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1002       es_printf ("min-passphrase-len:%lu:%d:\n",
1003               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1004       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1005               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1006               MIN_PASSPHRASE_NONALPHA);
1007       es_printf ("check-passphrase-pattern:%lu:\n",
1008               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1009       es_printf ("max-passphrase-days:%lu:%d:\n",
1010               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1011               MAX_PASSPHRASE_DAYS);
1012       es_printf ("enable-passphrase-history:%lu:\n",
1013               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1014       es_printf ("no-grab:%lu:\n",
1015               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1016       es_printf ("ignore-cache-for-signing:%lu:\n",
1017               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1018       es_printf ("no-allow-mark-trusted:%lu:\n",
1019               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1020       es_printf ("disable-scdaemon:%lu:\n",
1021               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1022 #ifdef HAVE_W32_SYSTEM
1023       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1024 #else
1025       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1026 #endif
1027
1028       agent_exit (0);
1029     }
1030
1031   /* Now start with logging to a file if this is desired. */
1032   if (logfile)
1033     {
1034       log_set_file (logfile);
1035       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1036                              |JNLIB_LOG_WITH_TIME
1037                              |JNLIB_LOG_WITH_PID));
1038       current_logfile = xstrdup (logfile);
1039     }
1040
1041   /* Make sure that we have a default ttyname. */
1042   if (!default_ttyname && gnupg_ttyname (1))
1043     default_ttyname = xstrdup (gnupg_ttyname (1));
1044   if (!default_ttytype && getenv ("TERM"))
1045     default_ttytype = xstrdup (getenv ("TERM"));
1046
1047
1048   if (pipe_server)
1049     {
1050       /* This is the simple pipe based server */
1051       ctrl_t ctrl;
1052
1053       ctrl = xtrycalloc (1, sizeof *ctrl);
1054       if (!ctrl)
1055         {
1056           log_error ("error allocating connection control data: %s\n",
1057                      strerror (errno) );
1058           agent_exit (1);
1059         }
1060       ctrl->session_env = session_env_new ();
1061       if (!ctrl->session_env)
1062         {
1063           log_error ("error allocating session environment block: %s\n",
1064                      strerror (errno) );
1065           xfree (ctrl);
1066           agent_exit (1);
1067         }
1068       agent_init_default_ctrl (ctrl);
1069       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1070       agent_deinit_default_ctrl (ctrl);
1071       xfree (ctrl);
1072     }
1073   else if (!is_daemon)
1074     ; /* NOTREACHED */
1075   else
1076     { /* Regular server mode */
1077       gnupg_fd_t fd;
1078       gnupg_fd_t fd_ssh;
1079       pid_t pid;
1080
1081       /* Remove the DISPLAY variable so that a pinentry does not
1082          default to a specific display.  There is still a default
1083          display when gpg-agent was started using --display or a
1084          client requested this using an OPTION command.  Note, that we
1085          don't do this when running in reverse daemon mode (i.e. when
1086          exec the program given as arguments). */
1087 #ifndef HAVE_W32_SYSTEM
1088       if (!opt.keep_display && !argc)
1089         gnupg_unsetenv ("DISPLAY");
1090 #endif
1091
1092
1093       /* Create the sockets.  */
1094       socket_name = create_socket_name
1095         (GPG_AGENT_SOCK_NAME, "gpg-XXXXXX/"GPG_AGENT_SOCK_NAME);
1096
1097       fd = create_server_socket (socket_name, 0, &socket_nonce);
1098       if (opt.ssh_support)
1099         {
1100           socket_name_ssh = create_socket_name
1101             (GPG_AGENT_SSH_SOCK_NAME, "gpg-XXXXXX/"GPG_AGENT_SSH_SOCK_NAME);
1102           fd_ssh = create_server_socket (socket_name_ssh, 1, &socket_nonce_ssh);
1103         }
1104       else
1105         fd_ssh = GNUPG_INVALID_FD;
1106
1107       /* If we are going to exec a program in the parent, we record
1108          the PID, so that the child may check whether the program is
1109          still alive. */
1110       if (argc)
1111         parent_pid = getpid ();
1112
1113       fflush (NULL);
1114 #ifdef HAVE_W32_SYSTEM
1115       (void)csh_style;
1116       (void)nodetach;
1117       (void)env_file_name;
1118       pid = getpid ();
1119       es_printf ("set %s=%s;%lu;1\n",
1120                  GPG_AGENT_INFO_NAME, socket_name, (ulong)pid);
1121 #else /*!HAVE_W32_SYSTEM*/
1122       pid = fork ();
1123       if (pid == (pid_t)-1)
1124         {
1125           log_fatal ("fork failed: %s\n", strerror (errno) );
1126           exit (1);
1127         }
1128       else if (pid)
1129         { /* We are the parent */
1130           char *infostr, *infostr_ssh_sock, *infostr_ssh_valid;
1131
1132           /* Close the socket FD. */
1133           close (fd);
1134
1135           /* The signal mask might not be correct right now and thus
1136              we restore it.  That is not strictly necessary but some
1137              programs falsely assume a cleared signal mask.  */
1138
1139 #ifdef HAVE_SIGPROCMASK
1140           if (startup_signal_mask_valid)
1141             {
1142               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1143                 log_error ("error restoring signal mask: %s\n",
1144                            strerror (errno));
1145             }
1146           else
1147             log_info ("no saved signal mask\n");
1148 #endif /*HAVE_SIGPROCMASK*/
1149
1150           /* Create the info string: <name>:<pid>:<protocol_version> */
1151           if (asprintf (&infostr, "%s=%s:%lu:1",
1152                         GPG_AGENT_INFO_NAME, socket_name, (ulong)pid ) < 0)
1153             {
1154               log_error ("out of core\n");
1155               kill (pid, SIGTERM);
1156               exit (1);
1157             }
1158           if (opt.ssh_support)
1159             {
1160               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1161                             socket_name_ssh) < 0)
1162                 {
1163                   log_error ("out of core\n");
1164                   kill (pid, SIGTERM);
1165                   exit (1);
1166                 }
1167               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1168                             (unsigned long)getpid()) < 0)
1169                 {
1170                   log_error ("out of core\n");
1171                   kill (pid, SIGTERM);
1172                   exit (1);
1173                 }
1174             }
1175
1176           *socket_name = 0; /* Don't let cleanup() remove the socket -
1177                                the child should do this from now on */
1178           if (opt.ssh_support)
1179             *socket_name_ssh = 0;
1180
1181           if (env_file_name)
1182             {
1183               estream_t fp;
1184
1185               fp = es_fopen (env_file_name, "w,mode=-rw");
1186               if (!fp)
1187                 log_error (_("error creating '%s': %s\n"),
1188                              env_file_name, strerror (errno));
1189               else
1190                 {
1191                   es_fputs (infostr, fp);
1192                   es_putc ('\n', fp);
1193                   if (opt.ssh_support)
1194                     {
1195                       es_fputs (infostr_ssh_sock, fp);
1196                       es_putc ('\n', fp);
1197                     }
1198                   es_fclose (fp);
1199                 }
1200             }
1201
1202
1203           if (argc)
1204             { /* Run the program given on the commandline.  */
1205               if (putenv (infostr))
1206                 {
1207                   log_error ("failed to set environment: %s\n",
1208                              strerror (errno) );
1209                   kill (pid, SIGTERM );
1210                   exit (1);
1211                 }
1212               if (opt.ssh_support && (putenv (infostr_ssh_sock)
1213                                       || putenv (infostr_ssh_valid)))
1214                 {
1215                   log_error ("failed to set environment: %s\n",
1216                              strerror (errno) );
1217                   kill (pid, SIGTERM );
1218                   exit (1);
1219                 }
1220
1221               /* Close all the file descriptors except the standard
1222                  ones and those open at startup.  We explicitly don't
1223                  close 0,1,2 in case something went wrong collecting
1224                  them at startup.  */
1225               close_all_fds (3, startup_fd_list);
1226
1227               /* Run the command.  */
1228               execvp (argv[0], argv);
1229               log_error ("failed to run the command: %s\n", strerror (errno));
1230               kill (pid, SIGTERM);
1231               exit (1);
1232             }
1233           else
1234             {
1235               /* Print the environment string, so that the caller can use
1236                  shell's eval to set it */
1237               if (csh_style)
1238                 {
1239                   *strchr (infostr, '=') = ' ';
1240                   es_printf ("setenv %s;\n", infostr);
1241                   if (opt.ssh_support)
1242                     {
1243                       *strchr (infostr_ssh_sock, '=') = ' ';
1244                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1245                     }
1246                 }
1247               else
1248                 {
1249                   es_printf ( "%s; export %s;\n", infostr, GPG_AGENT_INFO_NAME);
1250                   if (opt.ssh_support)
1251                     {
1252                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1253                                  infostr_ssh_sock);
1254                     }
1255                 }
1256               xfree (infostr);
1257               if (opt.ssh_support)
1258                 {
1259                   xfree (infostr_ssh_sock);
1260                   xfree (infostr_ssh_valid);
1261                 }
1262               exit (0);
1263             }
1264           /*NOTREACHED*/
1265         } /* End parent */
1266
1267       /*
1268          This is the child
1269        */
1270
1271       /* Detach from tty and put process into a new session */
1272       if (!nodetach )
1273         {
1274           int i;
1275           unsigned int oldflags;
1276
1277           /* Close stdin, stdout and stderr unless it is the log stream */
1278           for (i=0; i <= 2; i++)
1279             {
1280               if (!log_test_fd (i) && i != fd )
1281                 {
1282                   if ( ! close (i)
1283                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1284                     {
1285                       log_error ("failed to open '%s': %s\n",
1286                                  "/dev/null", strerror (errno));
1287                       cleanup ();
1288                       exit (1);
1289                     }
1290                 }
1291             }
1292           if (setsid() == -1)
1293             {
1294               log_error ("setsid() failed: %s\n", strerror(errno) );
1295               cleanup ();
1296               exit (1);
1297             }
1298
1299           log_get_prefix (&oldflags);
1300           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1301           opt.running_detached = 1;
1302         }
1303
1304       if (chdir("/"))
1305         {
1306           log_error ("chdir to / failed: %s\n", strerror (errno));
1307           exit (1);
1308         }
1309
1310       {
1311         struct sigaction sa;
1312
1313         sa.sa_handler = SIG_IGN;
1314         sigemptyset (&sa.sa_mask);
1315         sa.sa_flags = 0;
1316         sigaction (SIGPIPE, &sa, NULL);
1317       }
1318 #endif /*!HAVE_W32_SYSTEM*/
1319
1320       log_info ("%s %s started\n", strusage(11), strusage(13) );
1321       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1322       assuan_sock_close (fd);
1323     }
1324
1325   return 0;
1326 }
1327
1328
1329 /* Exit entry point.  This function should be called instead of a
1330    plain exit.  */
1331 void
1332 agent_exit (int rc)
1333 {
1334   /*FIXME: update_random_seed_file();*/
1335
1336   /* We run our cleanup handler because that may close cipher contexts
1337      stored in secure memory and thus this needs to be done before we
1338      explicitly terminate secure memory.  */
1339   cleanup ();
1340
1341 #if 1
1342   /* at this time a bit annoying */
1343   if (opt.debug & DBG_MEMSTAT_VALUE)
1344     {
1345       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1346       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1347     }
1348   if (opt.debug)
1349     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1350 #endif
1351   gcry_control (GCRYCTL_TERM_SECMEM );
1352   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1353   exit (rc);
1354 }
1355
1356
1357 /* Each thread has its own local variables conveyed by a control
1358    structure usually identified by an argument named CTRL.  This
1359    function is called immediately after allocating the control
1360    structure.  Its purpose is to setup the default values for that
1361    structure.  */
1362 static void
1363 agent_init_default_ctrl (ctrl_t ctrl)
1364 {
1365   assert (ctrl->session_env);
1366
1367   /* Note we ignore malloc errors because we can't do much about it
1368      and the request will fail anyway shortly after this
1369      initialization. */
1370   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1371   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1372   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1373   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1374   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1375
1376   if (ctrl->lc_ctype)
1377     xfree (ctrl->lc_ctype);
1378   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1379
1380   if (ctrl->lc_messages)
1381     xfree (ctrl->lc_messages);
1382   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1383                                     /**/ : NULL;
1384   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1385 }
1386
1387
1388 /* Release all resources allocated by default in the control
1389    structure.  This is the counterpart to agent_init_default_ctrl.  */
1390 static void
1391 agent_deinit_default_ctrl (ctrl_t ctrl)
1392 {
1393   session_env_release (ctrl->session_env);
1394
1395   if (ctrl->lc_ctype)
1396     xfree (ctrl->lc_ctype);
1397   if (ctrl->lc_messages)
1398     xfree (ctrl->lc_messages);
1399 }
1400
1401
1402 /* Reread parts of the configuration.  Note, that this function is
1403    obviously not thread-safe and should only be called from the PTH
1404    signal handler.
1405
1406    Fixme: Due to the way the argument parsing works, we create a
1407    memory leak here for all string type arguments.  There is currently
1408    no clean way to tell whether the memory for the argument has been
1409    allocated or points into the process' original arguments.  Unless
1410    we have a mechanism to tell this, we need to live on with this. */
1411 static void
1412 reread_configuration (void)
1413 {
1414   ARGPARSE_ARGS pargs;
1415   FILE *fp;
1416   unsigned int configlineno = 0;
1417   int dummy;
1418
1419   if (!config_filename)
1420     return; /* No config file. */
1421
1422   fp = fopen (config_filename, "r");
1423   if (!fp)
1424     {
1425       log_info (_("option file '%s': %s\n"),
1426                 config_filename, strerror(errno) );
1427       return;
1428     }
1429
1430   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1431
1432   memset (&pargs, 0, sizeof pargs);
1433   dummy = 0;
1434   pargs.argc = &dummy;
1435   pargs.flags = 1;  /* do not remove the args */
1436   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1437     {
1438       if (pargs.r_opt < -1)
1439         pargs.err = 1; /* Print a warning. */
1440       else /* Try to parse this option - ignore unchangeable ones. */
1441         parse_rereadable_options (&pargs, 1);
1442     }
1443   fclose (fp);
1444   set_debug ();
1445 }
1446
1447
1448 /* Return the file name of the socket we are using for native
1449    requests.  */
1450 const char *
1451 get_agent_socket_name (void)
1452 {
1453   const char *s = socket_name;
1454
1455   return (s && *s)? s : NULL;
1456 }
1457
1458 /* Return the file name of the socket we are using for SSH
1459    requests.  */
1460 const char *
1461 get_agent_ssh_socket_name (void)
1462 {
1463   const char *s = socket_name_ssh;
1464
1465   return (s && *s)? s : NULL;
1466 }
1467
1468
1469 /* Under W32, this function returns the handle of the scdaemon
1470    notification event.  Calling it the first time creates that
1471    event.  */
1472 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1473 void *
1474 get_agent_scd_notify_event (void)
1475 {
1476   static HANDLE the_event = INVALID_HANDLE_VALUE;
1477
1478   if (the_event == INVALID_HANDLE_VALUE)
1479     {
1480       HANDLE h, h2;
1481       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1482
1483       /* We need to use a manual reset event object due to the way our
1484          w32-pth wait function works: If we would use an automatic
1485          reset event we are not able to figure out which handle has
1486          been signaled because at the time we single out the signaled
1487          handles using WFSO the event has already been reset due to
1488          the WFMO.  */
1489       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1490       if (!h)
1491         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1492       else if (!DuplicateHandle (GetCurrentProcess(), h,
1493                                  GetCurrentProcess(), &h2,
1494                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1495         {
1496           log_error ("setting syncronize for scd notify event failed: %s\n",
1497                      w32_strerror (-1) );
1498           CloseHandle (h);
1499         }
1500       else
1501         {
1502           CloseHandle (h);
1503           the_event = h2;
1504         }
1505     }
1506
1507   return the_event;
1508 }
1509 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1510
1511
1512
1513 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1514    true using STANDARD_NAME in the home directory or if given as
1515    false from the mkdir type name TEMPLATE.  In the latter case a
1516    unique name in a unique new directory will be created.  In both
1517    cases check for valid characters as well as against a maximum
1518    allowed length for a unix domain socket is done.  The function
1519    terminates the process in case of an error.  Returns: Pointer to an
1520    allocated string with the absolute name of the socket used.  */
1521 static char *
1522 create_socket_name (char *standard_name, char *template)
1523 {
1524   char *name, *p;
1525
1526   if (opt.use_standard_socket)
1527     name = make_filename (opt.homedir, standard_name, NULL);
1528   else
1529     {
1530       /* Prepend the tmp directory to the template.  */
1531       p = getenv ("TMPDIR");
1532       if (!p || !*p)
1533         p = "/tmp";
1534       if (p[strlen (p) - 1] == '/')
1535         name = xstrconcat (p, template, NULL);
1536       else
1537         name = xstrconcat (p, "/", template, NULL);
1538
1539       p = strrchr (name, '/');
1540       if (!p)
1541         BUG ();
1542       *p = 0;
1543       if (!mkdtemp (name))
1544         {
1545           log_error (_("can't create directory '%s': %s\n"),
1546                      name, strerror (errno));
1547           agent_exit (2);
1548         }
1549       *p = '/';
1550     }
1551
1552   if (strchr (name, PATHSEP_C))
1553     {
1554       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1555       agent_exit (2);
1556     }
1557   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1558     {
1559       log_error (_("name of socket too long\n"));
1560       agent_exit (2);
1561     }
1562   return name;
1563 }
1564
1565
1566
1567 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1568    or terminates the process in case of an error.  Not that this
1569    function needs to be used for the regular socket first and only
1570    then for the ssh socket.  */
1571 static gnupg_fd_t
1572 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1573 {
1574   struct sockaddr_un *serv_addr;
1575   socklen_t len;
1576   gnupg_fd_t fd;
1577   int rc;
1578
1579   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1580   if (fd == ASSUAN_INVALID_FD)
1581     {
1582       log_error (_("can't create socket: %s\n"), strerror (errno));
1583       agent_exit (2);
1584     }
1585
1586   serv_addr = xmalloc (sizeof (*serv_addr));
1587   memset (serv_addr, 0, sizeof *serv_addr);
1588   serv_addr->sun_family = AF_UNIX;
1589   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1590     {
1591       log_error (_("socket name '%s' is too long\n"), name);
1592       agent_exit (2);
1593     }
1594   strcpy (serv_addr->sun_path, name);
1595   len = SUN_LEN (serv_addr);
1596   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1597
1598   /* Our error code mapping on W32CE returns EEXIST thus we also test
1599      for this. */
1600   if (opt.use_standard_socket && rc == -1
1601       && (errno == EADDRINUSE
1602 #ifdef HAVE_W32_SYSTEM
1603           || errno == EEXIST
1604 #endif
1605           ))
1606     {
1607       /* Check whether a gpg-agent is already running on the standard
1608          socket.  We do this test only if this is not the ssh socket.
1609          For ssh we assume that a test for gpg-agent has already been
1610          done and reuse the requested ssh socket.  Testing the
1611          ssh-socket is not possible because at this point, though we
1612          know the new Assuan socket, the Assuan server and thus the
1613          ssh-agent server is not yet operational.  This would lead to
1614          a hang.  */
1615       if (!is_ssh && !check_for_running_agent (1, 1))
1616         {
1617           log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
1618           log_set_file (NULL);
1619           log_error (_("a gpg-agent is already running - "
1620                        "not starting a new one\n"));
1621           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1622           assuan_sock_close (fd);
1623           agent_exit (2);
1624         }
1625       gnupg_remove (name);
1626       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1627     }
1628   if (rc != -1
1629       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1630     log_error (_("error getting nonce for the socket\n"));
1631   if (rc == -1)
1632     {
1633       /* We use gpg_strerror here because it allows us to get strings
1634          for some W32 socket error codes.  */
1635       log_error (_("error binding socket to '%s': %s\n"),
1636                  serv_addr->sun_path,
1637                  gpg_strerror (gpg_error_from_errno (errno)));
1638
1639       assuan_sock_close (fd);
1640       if (opt.use_standard_socket)
1641         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1642       agent_exit (2);
1643     }
1644
1645   if (listen (FD2INT(fd), 5 ) == -1)
1646     {
1647       log_error (_("listen() failed: %s\n"), strerror (errno));
1648       assuan_sock_close (fd);
1649       agent_exit (2);
1650     }
1651
1652   if (opt.verbose)
1653     log_info (_("listening on socket '%s'\n"), serv_addr->sun_path);
1654
1655   return fd;
1656 }
1657
1658
1659 /* Check that the directory for storing the private keys exists and
1660    create it if not.  This function won't fail as it is only a
1661    convenience function and not strictly necessary.  */
1662 static void
1663 create_private_keys_directory (const char *home)
1664 {
1665   char *fname;
1666   struct stat statbuf;
1667
1668   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1669   if (stat (fname, &statbuf) && errno == ENOENT)
1670     {
1671       if (gnupg_mkdir (fname, "-rwx"))
1672         log_error (_("can't create directory '%s': %s\n"),
1673                    fname, strerror (errno) );
1674       else if (!opt.quiet)
1675         log_info (_("directory '%s' created\n"), fname);
1676     }
1677   xfree (fname);
1678 }
1679
1680 /* Create the directory only if the supplied directory name is the
1681    same as the default one.  This way we avoid to create arbitrary
1682    directories when a non-default home directory is used.  To cope
1683    with HOME, we compare only the suffix if we see that the default
1684    homedir does start with a tilde.  We don't stop here in case of
1685    problems because other functions will throw an error anyway.*/
1686 static void
1687 create_directories (void)
1688 {
1689   struct stat statbuf;
1690   const char *defhome = standard_homedir ();
1691   char *home;
1692
1693   home = make_filename (opt.homedir, NULL);
1694   if ( stat (home, &statbuf) )
1695     {
1696       if (errno == ENOENT)
1697         {
1698           if (
1699 #ifdef HAVE_W32_SYSTEM
1700               ( !compare_filenames (home, defhome) )
1701 #else
1702               (*defhome == '~'
1703                 && (strlen (home) >= strlen (defhome+1)
1704                     && !strcmp (home + strlen(home)
1705                                 - strlen (defhome+1), defhome+1)))
1706                || (*defhome != '~' && !strcmp (home, defhome) )
1707 #endif
1708                )
1709             {
1710               if (gnupg_mkdir (home, "-rwx"))
1711                 log_error (_("can't create directory '%s': %s\n"),
1712                            home, strerror (errno) );
1713               else
1714                 {
1715                   if (!opt.quiet)
1716                     log_info (_("directory '%s' created\n"), home);
1717                   create_private_keys_directory (home);
1718                 }
1719             }
1720         }
1721       else
1722         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1723     }
1724   else if ( !S_ISDIR(statbuf.st_mode))
1725     {
1726       log_error (_("can't use '%s' as home directory\n"), home);
1727     }
1728   else /* exists and is a directory. */
1729     {
1730       create_private_keys_directory (home);
1731     }
1732   xfree (home);
1733 }
1734
1735
1736
1737 /* This is the worker for the ticker.  It is called every few seconds
1738    and may only do fast operations. */
1739 static void
1740 handle_tick (void)
1741 {
1742   static time_t last_minute;
1743
1744   if (!last_minute)
1745     last_minute = time (NULL);
1746
1747   /* Check whether the scdaemon has died and cleanup in this case. */
1748   agent_scd_check_aliveness ();
1749
1750   /* If we are running as a child of another process, check whether
1751      the parent is still alive and shutdown if not. */
1752 #ifndef HAVE_W32_SYSTEM
1753   if (parent_pid != (pid_t)(-1))
1754     {
1755       if (kill (parent_pid, 0))
1756         {
1757           shutdown_pending = 2;
1758           log_info ("parent process died - shutting down\n");
1759           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1760           cleanup ();
1761           agent_exit (0);
1762         }
1763     }
1764 #endif /*HAVE_W32_SYSTEM*/
1765
1766   /* Code to be run from time to time.  */
1767 #if CHECK_OWN_SOCKET_INTERVAL > 0
1768   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1769     {
1770       check_own_socket ();
1771       last_minute = time (NULL);
1772     }
1773 #endif
1774
1775 }
1776
1777
1778 /* A global function which allows us to call the reload stuff from
1779    other places too.  This is only used when build for W32.  */
1780 void
1781 agent_sighup_action (void)
1782 {
1783   log_info ("SIGHUP received - "
1784             "re-reading configuration and flushing cache\n");
1785   agent_flush_cache ();
1786   reread_configuration ();
1787   agent_reload_trustlist ();
1788 }
1789
1790
1791 /* A helper function to handle SIGUSR2.  */
1792 static void
1793 agent_sigusr2_action (void)
1794 {
1795   if (opt.verbose)
1796     log_info ("SIGUSR2 received - updating card event counter\n");
1797   /* Nothing to check right now.  We only increment a counter.  */
1798   bump_card_eventcounter ();
1799 }
1800
1801
1802 #ifndef HAVE_W32_SYSTEM
1803 /* The signal handler for this program.  It is expected to be run in
1804    its own trhead and not in the context of a signal handler.  */
1805 static void
1806 handle_signal (int signo)
1807 {
1808   switch (signo)
1809     {
1810 #ifndef HAVE_W32_SYSTEM
1811     case SIGHUP:
1812       agent_sighup_action ();
1813       break;
1814
1815     case SIGUSR1:
1816       log_info ("SIGUSR1 received - printing internal information:\n");
1817       /* Fixme: We need to see how to integrate pth dumping into our
1818          logging system.  */
1819       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1820       agent_query_dump_state ();
1821       agent_scd_dump_state ();
1822       break;
1823
1824     case SIGUSR2:
1825       agent_sigusr2_action ();
1826       break;
1827
1828     case SIGTERM:
1829       if (!shutdown_pending)
1830         log_info ("SIGTERM received - shutting down ...\n");
1831       else
1832         log_info ("SIGTERM received - still %i open connections\n",
1833                   active_connections);
1834       shutdown_pending++;
1835       if (shutdown_pending > 2)
1836         {
1837           log_info ("shutdown forced\n");
1838           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1839           cleanup ();
1840           agent_exit (0);
1841         }
1842       break;
1843
1844     case SIGINT:
1845       log_info ("SIGINT received - immediate shutdown\n");
1846       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1847       cleanup ();
1848       agent_exit (0);
1849       break;
1850 #endif
1851     default:
1852       log_info ("signal %d received - no action defined\n", signo);
1853     }
1854 }
1855 #endif
1856
1857 /* Check the nonce on a new connection.  This is a NOP unless we we
1858    are using our Unix domain socket emulation under Windows.  */
1859 static int
1860 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1861 {
1862   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1863     {
1864       log_info (_("error reading nonce on fd %d: %s\n"),
1865                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1866       assuan_sock_close (ctrl->thread_startup.fd);
1867       xfree (ctrl);
1868       return -1;
1869     }
1870   else
1871     return 0;
1872 }
1873
1874
1875 #ifdef HAVE_W32_SYSTEM
1876 /* The window message processing function for Putty.  Warning: This
1877    code runs as a native Windows thread.  Use of our own functions
1878    needs to be bracket with pth_leave/pth_enter. */
1879 static LRESULT CALLBACK
1880 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1881 {
1882   int ret = 0;
1883   int w32rc;
1884   COPYDATASTRUCT *cds;
1885   const char *mapfile;
1886   HANDLE maphd;
1887   PSID mysid = NULL;
1888   PSID mapsid = NULL;
1889   void *data = NULL;
1890   PSECURITY_DESCRIPTOR psd = NULL;
1891   ctrl_t ctrl = NULL;
1892
1893   if (msg != WM_COPYDATA)
1894     {
1895       return DefWindowProc (hwnd, msg, wparam, lparam);
1896     }
1897
1898   cds = (COPYDATASTRUCT*)lparam;
1899   if (cds->dwData != PUTTY_IPC_MAGIC)
1900     return 0;  /* Ignore data with the wrong magic.  */
1901   mapfile = cds->lpData;
1902   if (!cds->cbData || mapfile[cds->cbData - 1])
1903     return 0;  /* Ignore empty and non-properly terminated strings.  */
1904
1905   if (DBG_ASSUAN)
1906     {
1907       npth_protect ();
1908       log_debug ("ssh map file '%s'", mapfile);
1909       npth_unprotect ();
1910     }
1911
1912   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
1913   if (DBG_ASSUAN)
1914     {
1915       npth_protect ();
1916       log_debug ("ssh map handle %p\n", maphd);
1917       npth_unprotect ();
1918     }
1919
1920   if (!maphd || maphd == INVALID_HANDLE_VALUE)
1921     return 0;
1922
1923   npth_protect ();
1924
1925   mysid = w32_get_user_sid ();
1926   if (!mysid)
1927     {
1928       log_error ("error getting my sid\n");
1929       goto leave;
1930     }
1931
1932   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
1933                            OWNER_SECURITY_INFORMATION,
1934                            &mapsid, NULL, NULL, NULL,
1935                            &psd);
1936   if (w32rc)
1937     {
1938       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
1939       goto leave;
1940     }
1941
1942   if (DBG_ASSUAN)
1943     {
1944       char *sidstr;
1945
1946       if (!ConvertSidToStringSid (mysid, &sidstr))
1947         sidstr = NULL;
1948       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
1949       LocalFree (sidstr);
1950       if (!ConvertSidToStringSid (mapsid, &sidstr))
1951         sidstr = NULL;
1952       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
1953       LocalFree (sidstr);
1954     }
1955
1956   if (!EqualSid (mysid, mapsid))
1957     {
1958       log_error ("ssh map file has a non-matching sid\n");
1959       goto leave;
1960     }
1961
1962   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
1963   if (DBG_ASSUAN)
1964     log_debug ("ssh IPC buffer at %p\n", data);
1965   if (!data)
1966     goto leave;
1967
1968   /* log_printhex ("request:", data, 20); */
1969
1970   ctrl = xtrycalloc (1, sizeof *ctrl);
1971   if (!ctrl)
1972     {
1973       log_error ("error allocating connection control data: %s\n",
1974                  strerror (errno) );
1975       goto leave;
1976     }
1977   ctrl->session_env = session_env_new ();
1978   if (!ctrl->session_env)
1979     {
1980       log_error ("error allocating session environment block: %s\n",
1981                  strerror (errno) );
1982       goto leave;
1983     }
1984
1985   agent_init_default_ctrl (ctrl);
1986   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
1987     ret = 1; /* Valid ssh message has been constructed.  */
1988   agent_deinit_default_ctrl (ctrl);
1989   /* log_printhex ("  reply:", data, 20); */
1990
1991  leave:
1992   xfree (ctrl);
1993   if (data)
1994     UnmapViewOfFile (data);
1995   xfree (mapsid);
1996   if (psd)
1997     LocalFree (psd);
1998   xfree (mysid);
1999   CloseHandle (maphd);
2000
2001   npth_unprotect ();
2002
2003   return ret;
2004 }
2005 #endif /*HAVE_W32_SYSTEM*/
2006
2007
2008 #ifdef HAVE_W32_SYSTEM
2009 /* The thread handling Putty's IPC requests.  */
2010 static void *
2011 putty_message_thread (void *arg)
2012 {
2013   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2014                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2015   HWND hwnd;
2016   MSG msg;
2017
2018   (void)arg;
2019
2020   if (opt.verbose)
2021     log_info ("putty message loop thread started\n");
2022
2023   /* The message loop runs as thread independent from our nPth system.
2024      This also means that we need to make sure that we switch back to
2025      our system before calling any no-windows function.  */
2026   npth_unprotect ();
2027
2028   /* First create a window to make sure that a message queue exists
2029      for this thread.  */
2030   if (!RegisterClass (&wndwclass))
2031     {
2032       npth_protect ();
2033       log_error ("error registering Pageant window class");
2034       return NULL;
2035     }
2036   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2037                          0, 0, 0, 0,
2038                          HWND_MESSAGE,  /* hWndParent */
2039                          NULL,          /* hWndMenu   */
2040                          NULL,          /* hInstance  */
2041                          NULL);         /* lpParm     */
2042   if (!hwnd)
2043     {
2044       npth_protect ();
2045       log_error ("error creating Pageant window");
2046       return NULL;
2047     }
2048
2049   while (GetMessage(&msg, NULL, 0, 0))
2050     {
2051       TranslateMessage(&msg);
2052       DispatchMessage(&msg);
2053     }
2054
2055   /* Back to nPth.  */
2056   npth_protect ();
2057
2058   if (opt.verbose)
2059     log_info ("putty message loop thread stopped\n");
2060   return NULL;
2061 }
2062 #endif /*HAVE_W32_SYSTEM*/
2063
2064
2065 /* This is the standard connection thread's main function.  */
2066 static void *
2067 start_connection_thread (void *arg)
2068 {
2069   ctrl_t ctrl = arg;
2070
2071   if (check_nonce (ctrl, &socket_nonce))
2072     {
2073       log_error ("handler 0x%lx nonce check FAILED\n",
2074                  (unsigned long) npth_self());
2075       return NULL;
2076     }
2077
2078   agent_init_default_ctrl (ctrl);
2079   if (opt.verbose)
2080     log_info (_("handler 0x%lx for fd %d started\n"),
2081               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2082
2083   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2084   if (opt.verbose)
2085     log_info (_("handler 0x%lx for fd %d terminated\n"),
2086               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2087
2088   agent_deinit_default_ctrl (ctrl);
2089   xfree (ctrl);
2090   return NULL;
2091 }
2092
2093
2094 /* This is the ssh connection thread's main function.  */
2095 static void *
2096 start_connection_thread_ssh (void *arg)
2097 {
2098   ctrl_t ctrl = arg;
2099
2100   if (check_nonce (ctrl, &socket_nonce_ssh))
2101     return NULL;
2102
2103   agent_init_default_ctrl (ctrl);
2104   if (opt.verbose)
2105     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2106               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2107
2108   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2109   if (opt.verbose)
2110     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2111               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2112
2113   agent_deinit_default_ctrl (ctrl);
2114   xfree (ctrl);
2115   return NULL;
2116 }
2117
2118
2119 /* Connection handler loop.  Wait for connection requests and spawn a
2120    thread after accepting a connection.  */
2121 static void
2122 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
2123 {
2124   npth_attr_t tattr;
2125   struct sockaddr_un paddr;
2126   socklen_t plen;
2127   fd_set fdset, read_fdset;
2128   int ret;
2129   gnupg_fd_t fd;
2130   int nfd;
2131   int saved_errno;
2132   struct timespec abstime;
2133   struct timespec curtime;
2134   struct timespec timeout;
2135 #ifdef HAVE_W32_SYSTEM
2136   HANDLE events[2];
2137   int events_set;
2138 #endif
2139
2140   ret = npth_attr_init(&tattr);
2141   if (ret)
2142     log_fatal ("error allocating thread attributes: %s\n",
2143                strerror (ret));
2144   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2145
2146 #ifndef HAVE_W32_SYSTEM
2147   npth_sigev_init ();
2148   npth_sigev_add (SIGHUP);
2149   npth_sigev_add (SIGUSR1);
2150   npth_sigev_add (SIGUSR2);
2151   npth_sigev_add (SIGINT);
2152   npth_sigev_add (SIGTERM);
2153   npth_sigev_fini ();
2154 #else
2155 # ifdef HAVE_W32CE_SYSTEM
2156   /* Use a dummy event. */
2157   sigs = 0;
2158   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2159 # else
2160   events[0] = get_agent_scd_notify_event ();
2161   events[1] = INVALID_HANDLE_VALUE;
2162 # endif
2163 #endif
2164
2165   /* On Windows we need to fire up a separate thread to listen for
2166      requests from Putty (an SSH client), so we can replace Putty's
2167      Pageant (its ssh-agent implementation). */
2168 #ifdef HAVE_W32_SYSTEM
2169   if (putty_support)
2170     {
2171       npth_t thread;
2172
2173       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2174       if (ret)
2175         {
2176           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2177         }
2178     }
2179 #endif /*HAVE_W32_SYSTEM*/
2180
2181   /* Set a flag to tell call-scd.c that it may enable event
2182      notifications.  */
2183   opt.sigusr2_enabled = 1;
2184
2185   FD_ZERO (&fdset);
2186   FD_SET (FD2INT (listen_fd), &fdset);
2187   nfd = FD2INT (listen_fd);
2188   if (listen_fd_ssh != GNUPG_INVALID_FD)
2189     {
2190       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2191       if (FD2INT (listen_fd_ssh) > nfd)
2192         nfd = FD2INT (listen_fd_ssh);
2193     }
2194
2195   npth_clock_gettime (&abstime);
2196   abstime.tv_sec += TIMERTICK_INTERVAL;
2197
2198   for (;;)
2199     {
2200       /* Shutdown test.  */
2201       if (shutdown_pending)
2202         {
2203           if (active_connections == 0)
2204             break; /* ready */
2205
2206           /* Do not accept new connections but keep on running the
2207              loop to cope with the timer events.  */
2208           FD_ZERO (&fdset);
2209         }
2210
2211       /* POSIX says that fd_set should be implemented as a structure,
2212          thus a simple assignment is fine to copy the entire set.  */
2213       read_fdset = fdset;
2214
2215       npth_clock_gettime (&curtime);
2216       if (!(npth_timercmp (&curtime, &abstime, <)))
2217         {
2218           /* Timeout.  */
2219           handle_tick ();
2220           npth_clock_gettime (&abstime);
2221           abstime.tv_sec += TIMERTICK_INTERVAL;
2222         }
2223       npth_timersub (&abstime, &curtime, &timeout);
2224
2225 #ifndef HAVE_W32_SYSTEM
2226       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2227                           npth_sigev_sigmask ());
2228       saved_errno = errno;
2229
2230       {
2231         int signo;
2232         while (npth_sigev_get_pending (&signo))
2233           handle_signal (signo);
2234       }
2235 #else
2236       events_set = 0;
2237       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2238                           events, &events_set);
2239       saved_errno = errno;
2240
2241       /* This is valid even if npth_eselect returns an error.  */
2242       if (events_set & 1)
2243         agent_sigusr2_action ();
2244 #endif
2245
2246       if (ret == -1 && saved_errno != EINTR)
2247         {
2248           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2249                      strerror (saved_errno));
2250           npth_sleep (1);
2251           continue;
2252         }
2253       if (ret <= 0)
2254         /* Interrupt or timeout.  Will be handled when calculating the
2255            next timeout.  */
2256         continue;
2257
2258       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2259         {
2260           ctrl_t ctrl;
2261
2262           plen = sizeof paddr;
2263           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2264                                     (struct sockaddr *)&paddr, &plen));
2265           if (fd == GNUPG_INVALID_FD)
2266             {
2267               log_error ("accept failed: %s\n", strerror (errno));
2268             }
2269           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2270             {
2271               log_error ("error allocating connection control data: %s\n",
2272                          strerror (errno) );
2273               assuan_sock_close (fd);
2274             }
2275           else if ( !(ctrl->session_env = session_env_new ()) )
2276             {
2277               log_error ("error allocating session environment block: %s\n",
2278                          strerror (errno) );
2279               xfree (ctrl);
2280               assuan_sock_close (fd);
2281             }
2282           else
2283             {
2284               npth_t thread;
2285
2286               ctrl->thread_startup.fd = fd;
2287               ret = npth_create (&thread, &tattr,
2288                                  start_connection_thread, ctrl);
2289               if (ret)
2290                 {
2291                   log_error ("error spawning connection handler: %s\n",
2292                              strerror (ret));
2293                   assuan_sock_close (fd);
2294                   xfree (ctrl);
2295                 }
2296
2297             }
2298           fd = GNUPG_INVALID_FD;
2299         }
2300
2301       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD
2302           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2303         {
2304           ctrl_t ctrl;
2305
2306           plen = sizeof paddr;
2307           fd = INT2FD(npth_accept (FD2INT(listen_fd_ssh),
2308                                    (struct sockaddr *)&paddr, &plen));
2309           if (fd == GNUPG_INVALID_FD)
2310             {
2311               log_error ("accept failed for ssh: %s\n", strerror (errno));
2312             }
2313           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2314             {
2315               log_error ("error allocating connection control data: %s\n",
2316                          strerror (errno) );
2317               assuan_sock_close (fd);
2318             }
2319           else if ( !(ctrl->session_env = session_env_new ()) )
2320             {
2321               log_error ("error allocating session environment block: %s\n",
2322                          strerror (errno) );
2323               xfree (ctrl);
2324               assuan_sock_close (fd);
2325             }
2326           else
2327             {
2328               npth_t thread;
2329
2330               agent_init_default_ctrl (ctrl);
2331               ctrl->thread_startup.fd = fd;
2332               ret = npth_create (&thread, &tattr,
2333                                  start_connection_thread_ssh, ctrl);
2334               if (ret)
2335                 {
2336                   log_error ("error spawning ssh connection handler: %s\n",
2337                              strerror (ret));
2338                   assuan_sock_close (fd);
2339                   xfree (ctrl);
2340                 }
2341             }
2342           fd = GNUPG_INVALID_FD;
2343         }
2344     }
2345
2346   cleanup ();
2347   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2348   npth_attr_destroy (&tattr);
2349 }
2350
2351
2352
2353 /* Helper for check_own_socket.  */
2354 static gpg_error_t
2355 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2356 {
2357   membuf_t *mb = opaque;
2358   put_membuf (mb, buffer, length);
2359   return 0;
2360 }
2361
2362
2363 /* The thread running the actual check.  We need to run this in a
2364    separate thread so that check_own_thread can be called from the
2365    timer tick.  */
2366 static void *
2367 check_own_socket_thread (void *arg)
2368 {
2369   int rc;
2370   char *sockname = arg;
2371   assuan_context_t ctx = NULL;
2372   membuf_t mb;
2373   char *buffer;
2374
2375   check_own_socket_running++;
2376
2377   rc = assuan_new (&ctx);
2378   if (rc)
2379     {
2380       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2381       goto leave;
2382     }
2383
2384   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2385   if (rc)
2386     {
2387       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2388       goto leave;
2389     }
2390
2391   init_membuf (&mb, 100);
2392   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2393                         NULL, NULL, NULL, NULL);
2394   put_membuf (&mb, "", 1);
2395   buffer = get_membuf (&mb, NULL);
2396   if (rc || !buffer)
2397     {
2398       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2399                  "GETINFO pid", gpg_strerror (rc));
2400       rc = 1;
2401     }
2402   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2403     {
2404       log_error ("socket is now serviced by another server\n");
2405       rc = 1;
2406     }
2407   else if (opt.verbose > 1)
2408     log_error ("socket is still served by this server\n");
2409
2410   xfree (buffer);
2411
2412  leave:
2413   xfree (sockname);
2414   if (ctx)
2415     assuan_release (ctx);
2416   if (rc)
2417     {
2418       /* We may not remove the socket as it is now in use by another
2419          server.  Setting the name to empty does this.  */
2420       if (socket_name)
2421         *socket_name = 0;
2422       if (socket_name_ssh)
2423         *socket_name_ssh = 0;
2424       shutdown_pending = 2;
2425       log_info ("this process is useless - shutting down\n");
2426     }
2427   check_own_socket_running--;
2428   return NULL;
2429 }
2430
2431
2432 /* Check whether we are still listening on our own socket.  In case
2433    another gpg-agent process started after us has taken ownership of
2434    our socket, we would linger around without any real task.  Thus we
2435    better check once in a while whether we are really needed.  */
2436 static void
2437 check_own_socket (void)
2438 {
2439   char *sockname;
2440   npth_t thread;
2441   npth_attr_t tattr;
2442   int err;
2443
2444   if (disable_check_own_socket)
2445     return;
2446
2447   if (!opt.use_standard_socket)
2448     return; /* This check makes only sense in standard socket mode.  */
2449
2450   if (check_own_socket_running || shutdown_pending)
2451     return;  /* Still running or already shutting down.  */
2452
2453   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2454   if (!sockname)
2455     return; /* Out of memory.  */
2456
2457   err = npth_attr_init (&tattr);
2458   if (err)
2459     return;
2460   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2461   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2462   if (err)
2463     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2464   npth_attr_destroy (&tattr);
2465 }
2466
2467
2468
2469 /* Figure out whether an agent is available and running. Prints an
2470    error if not.  If SILENT is true, no messages are printed.  Usually
2471    started with MODE 0.  Returns 0 if the agent is running. */
2472 static int
2473 check_for_running_agent (int silent, int mode)
2474 {
2475   int rc;
2476   char *infostr, *p;
2477   assuan_context_t ctx = NULL;
2478   int prot, pid;
2479
2480   if (!mode)
2481     {
2482       infostr = getenv (GPG_AGENT_INFO_NAME);
2483       if (!infostr || !*infostr)
2484         {
2485           if (!check_for_running_agent (silent, 1))
2486             return 0; /* Okay, its running on the standard socket. */
2487           if (!silent)
2488             log_error (_("no gpg-agent running in this session\n"));
2489           return -1;
2490         }
2491
2492       infostr = xstrdup (infostr);
2493       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2494         {
2495           xfree (infostr);
2496           if (!check_for_running_agent (silent, 1))
2497             return 0; /* Okay, its running on the standard socket. */
2498           if (!silent)
2499             log_error (_("malformed %s environment variable\n"),
2500                        GPG_AGENT_INFO_NAME);
2501           return -1;
2502         }
2503
2504       *p++ = 0;
2505       pid = atoi (p);
2506       while (*p && *p != PATHSEP_C)
2507         p++;
2508       prot = *p? atoi (p+1) : 0;
2509       if (prot != 1)
2510         {
2511           xfree (infostr);
2512           if (!silent)
2513             log_error (_("gpg-agent protocol version %d is not supported\n"),
2514                        prot);
2515           if (!check_for_running_agent (silent, 1))
2516             return 0; /* Okay, its running on the standard socket. */
2517           return -1;
2518         }
2519     }
2520   else /* MODE != 0 */
2521     {
2522       infostr = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2523       pid = (pid_t)(-1);
2524     }
2525
2526   rc = assuan_new (&ctx);
2527   if (! rc)
2528     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2529   xfree (infostr);
2530   if (rc)
2531     {
2532       if (!mode && !check_for_running_agent (silent, 1))
2533         return 0; /* Okay, its running on the standard socket. */
2534
2535       if (!mode && !silent)
2536         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2537
2538       if (ctx)
2539         assuan_release (ctx);
2540       return -1;
2541     }
2542
2543   if (!opt.quiet && !silent)
2544     log_info ("gpg-agent running and available\n");
2545
2546   assuan_release (ctx);
2547   return 0;
2548 }