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