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