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