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