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