agent: Make --allow-loopback-pinentry gpgconf changeable.
[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 caller to override the pinentry")),
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       es_printf ("allow-loopback-pinentry:%lu:\n",
1064                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1065
1066       agent_exit (0);
1067     }
1068
1069   /* Now start with logging to a file if this is desired. */
1070   if (logfile)
1071     {
1072       log_set_file (logfile);
1073       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1074                              |JNLIB_LOG_WITH_TIME
1075                              |JNLIB_LOG_WITH_PID));
1076       current_logfile = xstrdup (logfile);
1077     }
1078
1079   /* Make sure that we have a default ttyname. */
1080   if (!default_ttyname && gnupg_ttyname (1))
1081     default_ttyname = xstrdup (gnupg_ttyname (1));
1082   if (!default_ttytype && getenv ("TERM"))
1083     default_ttytype = xstrdup (getenv ("TERM"));
1084
1085
1086   if (pipe_server)
1087     {
1088       /* This is the simple pipe based server */
1089       ctrl_t ctrl;
1090
1091       ctrl = xtrycalloc (1, sizeof *ctrl);
1092       if (!ctrl)
1093         {
1094           log_error ("error allocating connection control data: %s\n",
1095                      strerror (errno) );
1096           agent_exit (1);
1097         }
1098       ctrl->session_env = session_env_new ();
1099       if (!ctrl->session_env)
1100         {
1101           log_error ("error allocating session environment block: %s\n",
1102                      strerror (errno) );
1103           xfree (ctrl);
1104           agent_exit (1);
1105         }
1106       agent_init_default_ctrl (ctrl);
1107       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1108       agent_deinit_default_ctrl (ctrl);
1109       xfree (ctrl);
1110     }
1111   else if (!is_daemon)
1112     ; /* NOTREACHED */
1113   else
1114     { /* Regular server mode */
1115       gnupg_fd_t fd;
1116       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1117       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1118       pid_t pid;
1119
1120       /* Remove the DISPLAY variable so that a pinentry does not
1121          default to a specific display.  There is still a default
1122          display when gpg-agent was started using --display or a
1123          client requested this using an OPTION command.  Note, that we
1124          don't do this when running in reverse daemon mode (i.e. when
1125          exec the program given as arguments). */
1126 #ifndef HAVE_W32_SYSTEM
1127       if (!opt.keep_display && !argc)
1128         gnupg_unsetenv ("DISPLAY");
1129 #endif
1130
1131       /* Create the sockets.  */
1132       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1133       fd = create_server_socket (socket_name, 1,
1134                                  &redir_socket_name, &socket_nonce);
1135
1136       if (opt.extra_socket)
1137         {
1138           socket_name_extra = create_socket_name (socket_name_extra, 0);
1139           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1140           fd_extra = create_server_socket (socket_name_extra, 0,
1141                                            &redir_socket_name_extra,
1142                                            &socket_nonce_extra);
1143         }
1144
1145       if (opt.ssh_support)
1146         {
1147           socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1148           fd_ssh = create_server_socket (socket_name_ssh, 0,
1149                                          &redir_socket_name_ssh,
1150                                          &socket_nonce_ssh);
1151         }
1152
1153       /* If we are going to exec a program in the parent, we record
1154          the PID, so that the child may check whether the program is
1155          still alive. */
1156       if (argc)
1157         parent_pid = getpid ();
1158
1159       fflush (NULL);
1160 #ifdef HAVE_W32_SYSTEM
1161       (void)csh_style;
1162       (void)nodetach;
1163       pid = getpid ();
1164 #else /*!HAVE_W32_SYSTEM*/
1165       pid = fork ();
1166       if (pid == (pid_t)-1)
1167         {
1168           log_fatal ("fork failed: %s\n", strerror (errno) );
1169           exit (1);
1170         }
1171       else if (pid)
1172         { /* We are the parent */
1173           char *infostr_ssh_sock, *infostr_ssh_valid;
1174
1175           /* Close the socket FD. */
1176           close (fd);
1177
1178           /* The signal mask might not be correct right now and thus
1179              we restore it.  That is not strictly necessary but some
1180              programs falsely assume a cleared signal mask.  */
1181
1182 #ifdef HAVE_SIGPROCMASK
1183           if (startup_signal_mask_valid)
1184             {
1185               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1186                 log_error ("error restoring signal mask: %s\n",
1187                            strerror (errno));
1188             }
1189           else
1190             log_info ("no saved signal mask\n");
1191 #endif /*HAVE_SIGPROCMASK*/
1192
1193           /* Create the SSH info string if enabled. */
1194           if (opt.ssh_support)
1195             {
1196               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1197                             socket_name_ssh) < 0)
1198                 {
1199                   log_error ("out of core\n");
1200                   kill (pid, SIGTERM);
1201                   exit (1);
1202                 }
1203               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1204                             (unsigned long)getpid()) < 0)
1205                 {
1206                   log_error ("out of core\n");
1207                   kill (pid, SIGTERM);
1208                   exit (1);
1209                 }
1210             }
1211
1212           *socket_name = 0; /* Don't let cleanup() remove the socket -
1213                                the child should do this from now on */
1214           if (opt.extra_socket)
1215             *socket_name_extra = 0;
1216           if (opt.ssh_support)
1217             *socket_name_ssh = 0;
1218
1219           if (argc)
1220             { /* Run the program given on the commandline.  */
1221               if (opt.ssh_support && (putenv (infostr_ssh_sock)
1222                                       || putenv (infostr_ssh_valid)))
1223                 {
1224                   log_error ("failed to set environment: %s\n",
1225                              strerror (errno) );
1226                   kill (pid, SIGTERM );
1227                   exit (1);
1228                 }
1229
1230               /* Close all the file descriptors except the standard
1231                  ones and those open at startup.  We explicitly don't
1232                  close 0,1,2 in case something went wrong collecting
1233                  them at startup.  */
1234               close_all_fds (3, startup_fd_list);
1235
1236               /* Run the command.  */
1237               execvp (argv[0], argv);
1238               log_error ("failed to run the command: %s\n", strerror (errno));
1239               kill (pid, SIGTERM);
1240               exit (1);
1241             }
1242           else
1243             {
1244               /* Print the environment string, so that the caller can use
1245                  shell's eval to set it */
1246               if (csh_style)
1247                 {
1248                   if (opt.ssh_support)
1249                     {
1250                       *strchr (infostr_ssh_sock, '=') = ' ';
1251                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1252                     }
1253                 }
1254               else
1255                 {
1256                   if (opt.ssh_support)
1257                     {
1258                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1259                                  infostr_ssh_sock);
1260                     }
1261                 }
1262               if (opt.ssh_support)
1263                 {
1264                   xfree (infostr_ssh_sock);
1265                   xfree (infostr_ssh_valid);
1266                 }
1267               exit (0);
1268             }
1269           /*NOTREACHED*/
1270         } /* End parent */
1271
1272       /*
1273          This is the child
1274        */
1275
1276       /* Detach from tty and put process into a new session */
1277       if (!nodetach )
1278         {
1279           int i;
1280           unsigned int oldflags;
1281
1282           /* Close stdin, stdout and stderr unless it is the log stream */
1283           for (i=0; i <= 2; i++)
1284             {
1285               if (!log_test_fd (i) && i != fd )
1286                 {
1287                   if ( ! close (i)
1288                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1289                     {
1290                       log_error ("failed to open '%s': %s\n",
1291                                  "/dev/null", strerror (errno));
1292                       cleanup ();
1293                       exit (1);
1294                     }
1295                 }
1296             }
1297           if (setsid() == -1)
1298             {
1299               log_error ("setsid() failed: %s\n", strerror(errno) );
1300               cleanup ();
1301               exit (1);
1302             }
1303
1304           log_get_prefix (&oldflags);
1305           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1306           opt.running_detached = 1;
1307         }
1308
1309       if (chdir("/"))
1310         {
1311           log_error ("chdir to / failed: %s\n", strerror (errno));
1312           exit (1);
1313         }
1314
1315       {
1316         struct sigaction sa;
1317
1318         sa.sa_handler = SIG_IGN;
1319         sigemptyset (&sa.sa_mask);
1320         sa.sa_flags = 0;
1321         sigaction (SIGPIPE, &sa, NULL);
1322       }
1323 #endif /*!HAVE_W32_SYSTEM*/
1324
1325       log_info ("%s %s started\n", strusage(11), strusage(13) );
1326       handle_connections (fd, fd_extra, fd_ssh);
1327       assuan_sock_close (fd);
1328     }
1329
1330   return 0;
1331 }
1332
1333
1334 /* Exit entry point.  This function should be called instead of a
1335    plain exit.  */
1336 void
1337 agent_exit (int rc)
1338 {
1339   /*FIXME: update_random_seed_file();*/
1340
1341   /* We run our cleanup handler because that may close cipher contexts
1342      stored in secure memory and thus this needs to be done before we
1343      explicitly terminate secure memory.  */
1344   cleanup ();
1345
1346 #if 1
1347   /* at this time a bit annoying */
1348   if (opt.debug & DBG_MEMSTAT_VALUE)
1349     {
1350       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1351       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1352     }
1353   if (opt.debug)
1354     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1355 #endif
1356   gcry_control (GCRYCTL_TERM_SECMEM );
1357   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1358   exit (rc);
1359 }
1360
1361
1362 /* Each thread has its own local variables conveyed by a control
1363    structure usually identified by an argument named CTRL.  This
1364    function is called immediately after allocating the control
1365    structure.  Its purpose is to setup the default values for that
1366    structure.  Note that some values may have already been set.  */
1367 static void
1368 agent_init_default_ctrl (ctrl_t ctrl)
1369 {
1370   assert (ctrl->session_env);
1371
1372   /* Note we ignore malloc errors because we can't do much about it
1373      and the request will fail anyway shortly after this
1374      initialization. */
1375   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1376   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1377   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1378   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1379   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1380
1381   if (ctrl->lc_ctype)
1382     xfree (ctrl->lc_ctype);
1383   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1384
1385   if (ctrl->lc_messages)
1386     xfree (ctrl->lc_messages);
1387   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1388                                     /**/ : NULL;
1389   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1390 }
1391
1392
1393 /* Release all resources allocated by default in the control
1394    structure.  This is the counterpart to agent_init_default_ctrl.  */
1395 static void
1396 agent_deinit_default_ctrl (ctrl_t ctrl)
1397 {
1398   session_env_release (ctrl->session_env);
1399
1400   if (ctrl->lc_ctype)
1401     xfree (ctrl->lc_ctype);
1402   if (ctrl->lc_messages)
1403     xfree (ctrl->lc_messages);
1404 }
1405
1406
1407 /* Because the ssh protocol does not send us information about the
1408    current TTY setting, we use this function to use those from startup
1409    or those explictly set.  This is also used for the restricted mode
1410    where we ignore requests to change the environment.  */
1411 gpg_error_t
1412 agent_copy_startup_env (ctrl_t ctrl)
1413 {
1414   static const char *names[] =
1415     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1416   gpg_error_t err = 0;
1417   int idx;
1418   const char *value;
1419
1420   for (idx=0; !err && names[idx]; idx++)
1421       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1422       err = session_env_setenv (ctrl->session_env, names[idx], value);
1423
1424   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1425     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1426       err = gpg_error_from_syserror ();
1427
1428   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1429     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1430       err = gpg_error_from_syserror ();
1431
1432   if (err)
1433     log_error ("error setting default session environment: %s\n",
1434                gpg_strerror (err));
1435
1436   return err;
1437 }
1438
1439
1440 /* Reread parts of the configuration.  Note, that this function is
1441    obviously not thread-safe and should only be called from the PTH
1442    signal handler.
1443
1444    Fixme: Due to the way the argument parsing works, we create a
1445    memory leak here for all string type arguments.  There is currently
1446    no clean way to tell whether the memory for the argument has been
1447    allocated or points into the process' original arguments.  Unless
1448    we have a mechanism to tell this, we need to live on with this. */
1449 static void
1450 reread_configuration (void)
1451 {
1452   ARGPARSE_ARGS pargs;
1453   FILE *fp;
1454   unsigned int configlineno = 0;
1455   int dummy;
1456
1457   if (!config_filename)
1458     return; /* No config file. */
1459
1460   fp = fopen (config_filename, "r");
1461   if (!fp)
1462     {
1463       log_info (_("option file '%s': %s\n"),
1464                 config_filename, strerror(errno) );
1465       return;
1466     }
1467
1468   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1469
1470   memset (&pargs, 0, sizeof pargs);
1471   dummy = 0;
1472   pargs.argc = &dummy;
1473   pargs.flags = 1;  /* do not remove the args */
1474   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1475     {
1476       if (pargs.r_opt < -1)
1477         pargs.err = 1; /* Print a warning. */
1478       else /* Try to parse this option - ignore unchangeable ones. */
1479         parse_rereadable_options (&pargs, 1);
1480     }
1481   fclose (fp);
1482   finalize_rereadable_options ();
1483   set_debug ();
1484 }
1485
1486
1487 /* Return the file name of the socket we are using for native
1488    requests.  */
1489 const char *
1490 get_agent_socket_name (void)
1491 {
1492   const char *s = socket_name;
1493
1494   return (s && *s)? s : NULL;
1495 }
1496
1497 /* Return the file name of the socket we are using for SSH
1498    requests.  */
1499 const char *
1500 get_agent_ssh_socket_name (void)
1501 {
1502   const char *s = socket_name_ssh;
1503
1504   return (s && *s)? s : NULL;
1505 }
1506
1507
1508 /* Under W32, this function returns the handle of the scdaemon
1509    notification event.  Calling it the first time creates that
1510    event.  */
1511 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1512 void *
1513 get_agent_scd_notify_event (void)
1514 {
1515   static HANDLE the_event = INVALID_HANDLE_VALUE;
1516
1517   if (the_event == INVALID_HANDLE_VALUE)
1518     {
1519       HANDLE h, h2;
1520       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1521
1522       /* We need to use a manual reset event object due to the way our
1523          w32-pth wait function works: If we would use an automatic
1524          reset event we are not able to figure out which handle has
1525          been signaled because at the time we single out the signaled
1526          handles using WFSO the event has already been reset due to
1527          the WFMO.  */
1528       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1529       if (!h)
1530         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1531       else if (!DuplicateHandle (GetCurrentProcess(), h,
1532                                  GetCurrentProcess(), &h2,
1533                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1534         {
1535           log_error ("setting syncronize for scd notify event failed: %s\n",
1536                      w32_strerror (-1) );
1537           CloseHandle (h);
1538         }
1539       else
1540         {
1541           CloseHandle (h);
1542           the_event = h2;
1543         }
1544     }
1545
1546   return the_event;
1547 }
1548 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1549
1550
1551
1552 /* Create a name for the socket in the home directory as using
1553    STANDARD_NAME.  We also check for valid characters as well as
1554    against a maximum allowed length for a unix domain socket is done.
1555    The function terminates the process in case of an error.  Returns:
1556    Pointer to an allocated string with the absolute name of the socket
1557    used.  */
1558 static char *
1559 create_socket_name (char *standard_name, int with_homedir)
1560 {
1561   char *name;
1562
1563   if (with_homedir)
1564     name = make_filename (opt.homedir, standard_name, NULL);
1565   else
1566     name = make_filename (standard_name, NULL);
1567   if (strchr (name, PATHSEP_C))
1568     {
1569       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1570       agent_exit (2);
1571     }
1572   return name;
1573 }
1574
1575
1576
1577 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1578    or terminates the process in case of an error.  Note that this
1579    function needs to be used for the regular socket first (indicated
1580    by PRIMARY) and only then for the extra and the ssh sockets.  If
1581    the socket has been redirected the name of the real socket is
1582    stored as a malloced string at R_REDIR_NAME.  */
1583 static gnupg_fd_t
1584 create_server_socket (char *name, int primary,
1585                       char **r_redir_name, assuan_sock_nonce_t *nonce)
1586 {
1587   struct sockaddr *addr;
1588   struct sockaddr_un *unaddr;
1589   socklen_t len;
1590   gnupg_fd_t fd;
1591   int rc;
1592
1593   xfree (*r_redir_name);
1594   *r_redir_name = NULL;
1595
1596   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1597   if (fd == ASSUAN_INVALID_FD)
1598     {
1599       log_error (_("can't create socket: %s\n"), strerror (errno));
1600       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1601       agent_exit (2);
1602     }
1603
1604   unaddr = xmalloc (sizeof *unaddr);
1605   addr = (struct sockaddr*)unaddr;
1606
1607 #if ASSUAN_VERSION_NUMBER >= 0x020104 /* >= 2.1.4 */
1608   {
1609     int redirected;
1610
1611     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
1612       {
1613         if (errno == ENAMETOOLONG)
1614           log_error (_("socket name '%s' is too long\n"), name);
1615         else
1616           log_error ("error preparing socket '%s': %s\n",
1617                      name, gpg_strerror (gpg_error_from_syserror ()));
1618         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1619         agent_exit (2);
1620       }
1621     if (redirected)
1622       {
1623         *r_redir_name = xstrdup (unaddr->sun_path);
1624         if (opt.verbose)
1625           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
1626       }
1627   }
1628 #else /* Assuan < 2.1.4 */
1629   memset (unaddr, 0, sizeof *unaddr);
1630   unaddr->sun_family = AF_UNIX;
1631   if (strlen (name) + 1 >= sizeof (unaddr->sun_path))
1632     {
1633       log_error (_("socket name '%s' is too long\n"), name);
1634       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1635       agent_exit (2);
1636     }
1637   strcpy (unaddr->sun_path, name);
1638 #endif /* Assuan < 2.1.4 */
1639
1640   len = SUN_LEN (unaddr);
1641   rc = assuan_sock_bind (fd, addr, len);
1642
1643   /* Our error code mapping on W32CE returns EEXIST thus we also test
1644      for this. */
1645   if (rc == -1
1646       && (errno == EADDRINUSE
1647 #ifdef HAVE_W32_SYSTEM
1648           || errno == EEXIST
1649 #endif
1650           ))
1651     {
1652       /* Check whether a gpg-agent is already running.  We do this
1653          test only if this is the primary socket.  For secondary
1654          sockets we assume that a test for gpg-agent has already been
1655          done and reuse the requested socket.  Testing the ssh-socket
1656          is not possible because at this point, though we know the new
1657          Assuan socket, the Assuan server and thus the ssh-agent
1658          server is not yet operational; this would lead to a hang.  */
1659       if (primary && !check_for_running_agent (1))
1660         {
1661           log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
1662           log_set_file (NULL);
1663           log_error (_("a gpg-agent is already running - "
1664                        "not starting a new one\n"));
1665           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1666           assuan_sock_close (fd);
1667           agent_exit (2);
1668         }
1669       gnupg_remove (unaddr->sun_path);
1670       rc = assuan_sock_bind (fd, addr, len);
1671     }
1672   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
1673     log_error (_("error getting nonce for the socket\n"));
1674   if (rc == -1)
1675     {
1676       /* We use gpg_strerror here because it allows us to get strings
1677          for some W32 socket error codes.  */
1678       log_error (_("error binding socket to '%s': %s\n"),
1679                  unaddr->sun_path,
1680                  gpg_strerror (gpg_error_from_syserror ()));
1681
1682       assuan_sock_close (fd);
1683       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1684       agent_exit (2);
1685     }
1686
1687   if (listen (FD2INT(fd), 5 ) == -1)
1688     {
1689       log_error (_("listen() failed: %s\n"), strerror (errno));
1690       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1691       assuan_sock_close (fd);
1692       agent_exit (2);
1693     }
1694
1695   if (opt.verbose)
1696     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
1697
1698   return fd;
1699 }
1700
1701
1702 /* Check that the directory for storing the private keys exists and
1703    create it if not.  This function won't fail as it is only a
1704    convenience function and not strictly necessary.  */
1705 static void
1706 create_private_keys_directory (const char *home)
1707 {
1708   char *fname;
1709   struct stat statbuf;
1710
1711   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1712   if (stat (fname, &statbuf) && errno == ENOENT)
1713     {
1714       if (gnupg_mkdir (fname, "-rwx"))
1715         log_error (_("can't create directory '%s': %s\n"),
1716                    fname, strerror (errno) );
1717       else if (!opt.quiet)
1718         log_info (_("directory '%s' created\n"), fname);
1719     }
1720   xfree (fname);
1721 }
1722
1723 /* Create the directory only if the supplied directory name is the
1724    same as the default one.  This way we avoid to create arbitrary
1725    directories when a non-default home directory is used.  To cope
1726    with HOME, we compare only the suffix if we see that the default
1727    homedir does start with a tilde.  We don't stop here in case of
1728    problems because other functions will throw an error anyway.*/
1729 static void
1730 create_directories (void)
1731 {
1732   struct stat statbuf;
1733   const char *defhome = standard_homedir ();
1734   char *home;
1735
1736   home = make_filename (opt.homedir, NULL);
1737   if ( stat (home, &statbuf) )
1738     {
1739       if (errno == ENOENT)
1740         {
1741           if (
1742 #ifdef HAVE_W32_SYSTEM
1743               ( !compare_filenames (home, defhome) )
1744 #else
1745               (*defhome == '~'
1746                 && (strlen (home) >= strlen (defhome+1)
1747                     && !strcmp (home + strlen(home)
1748                                 - strlen (defhome+1), defhome+1)))
1749                || (*defhome != '~' && !strcmp (home, defhome) )
1750 #endif
1751                )
1752             {
1753               if (gnupg_mkdir (home, "-rwx"))
1754                 log_error (_("can't create directory '%s': %s\n"),
1755                            home, strerror (errno) );
1756               else
1757                 {
1758                   if (!opt.quiet)
1759                     log_info (_("directory '%s' created\n"), home);
1760                   create_private_keys_directory (home);
1761                 }
1762             }
1763         }
1764       else
1765         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1766     }
1767   else if ( !S_ISDIR(statbuf.st_mode))
1768     {
1769       log_error (_("can't use '%s' as home directory\n"), home);
1770     }
1771   else /* exists and is a directory. */
1772     {
1773       create_private_keys_directory (home);
1774     }
1775   xfree (home);
1776 }
1777
1778
1779
1780 /* This is the worker for the ticker.  It is called every few seconds
1781    and may only do fast operations. */
1782 static void
1783 handle_tick (void)
1784 {
1785   static time_t last_minute;
1786
1787   if (!last_minute)
1788     last_minute = time (NULL);
1789
1790   /* Check whether the scdaemon has died and cleanup in this case. */
1791   agent_scd_check_aliveness ();
1792
1793   /* If we are running as a child of another process, check whether
1794      the parent is still alive and shutdown if not. */
1795 #ifndef HAVE_W32_SYSTEM
1796   if (parent_pid != (pid_t)(-1))
1797     {
1798       if (kill (parent_pid, 0))
1799         {
1800           shutdown_pending = 2;
1801           log_info ("parent process died - shutting down\n");
1802           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1803           cleanup ();
1804           agent_exit (0);
1805         }
1806     }
1807 #endif /*HAVE_W32_SYSTEM*/
1808
1809   /* Code to be run from time to time.  */
1810 #if CHECK_OWN_SOCKET_INTERVAL > 0
1811   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1812     {
1813       check_own_socket ();
1814       last_minute = time (NULL);
1815     }
1816 #endif
1817
1818 }
1819
1820
1821 /* A global function which allows us to call the reload stuff from
1822    other places too.  This is only used when build for W32.  */
1823 void
1824 agent_sighup_action (void)
1825 {
1826   log_info ("SIGHUP received - "
1827             "re-reading configuration and flushing cache\n");
1828   agent_flush_cache ();
1829   reread_configuration ();
1830   agent_reload_trustlist ();
1831 }
1832
1833
1834 /* A helper function to handle SIGUSR2.  */
1835 static void
1836 agent_sigusr2_action (void)
1837 {
1838   if (opt.verbose)
1839     log_info ("SIGUSR2 received - updating card event counter\n");
1840   /* Nothing to check right now.  We only increment a counter.  */
1841   bump_card_eventcounter ();
1842 }
1843
1844
1845 #ifndef HAVE_W32_SYSTEM
1846 /* The signal handler for this program.  It is expected to be run in
1847    its own trhead and not in the context of a signal handler.  */
1848 static void
1849 handle_signal (int signo)
1850 {
1851   switch (signo)
1852     {
1853 #ifndef HAVE_W32_SYSTEM
1854     case SIGHUP:
1855       agent_sighup_action ();
1856       break;
1857
1858     case SIGUSR1:
1859       log_info ("SIGUSR1 received - printing internal information:\n");
1860       /* Fixme: We need to see how to integrate pth dumping into our
1861          logging system.  */
1862       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1863       agent_query_dump_state ();
1864       agent_scd_dump_state ();
1865       break;
1866
1867     case SIGUSR2:
1868       agent_sigusr2_action ();
1869       break;
1870
1871     case SIGTERM:
1872       if (!shutdown_pending)
1873         log_info ("SIGTERM received - shutting down ...\n");
1874       else
1875         log_info ("SIGTERM received - still %i open connections\n",
1876                   active_connections);
1877       shutdown_pending++;
1878       if (shutdown_pending > 2)
1879         {
1880           log_info ("shutdown forced\n");
1881           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1882           cleanup ();
1883           agent_exit (0);
1884         }
1885       break;
1886
1887     case SIGINT:
1888       log_info ("SIGINT received - immediate shutdown\n");
1889       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1890       cleanup ();
1891       agent_exit (0);
1892       break;
1893 #endif
1894     default:
1895       log_info ("signal %d received - no action defined\n", signo);
1896     }
1897 }
1898 #endif
1899
1900 /* Check the nonce on a new connection.  This is a NOP unless we we
1901    are using our Unix domain socket emulation under Windows.  */
1902 static int
1903 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1904 {
1905   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1906     {
1907       log_info (_("error reading nonce on fd %d: %s\n"),
1908                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1909       assuan_sock_close (ctrl->thread_startup.fd);
1910       xfree (ctrl);
1911       return -1;
1912     }
1913   else
1914     return 0;
1915 }
1916
1917
1918 #ifdef HAVE_W32_SYSTEM
1919 /* The window message processing function for Putty.  Warning: This
1920    code runs as a native Windows thread.  Use of our own functions
1921    needs to be bracket with pth_leave/pth_enter. */
1922 static LRESULT CALLBACK
1923 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1924 {
1925   int ret = 0;
1926   int w32rc;
1927   COPYDATASTRUCT *cds;
1928   const char *mapfile;
1929   HANDLE maphd;
1930   PSID mysid = NULL;
1931   PSID mapsid = NULL;
1932   void *data = NULL;
1933   PSECURITY_DESCRIPTOR psd = NULL;
1934   ctrl_t ctrl = NULL;
1935
1936   if (msg != WM_COPYDATA)
1937     {
1938       return DefWindowProc (hwnd, msg, wparam, lparam);
1939     }
1940
1941   cds = (COPYDATASTRUCT*)lparam;
1942   if (cds->dwData != PUTTY_IPC_MAGIC)
1943     return 0;  /* Ignore data with the wrong magic.  */
1944   mapfile = cds->lpData;
1945   if (!cds->cbData || mapfile[cds->cbData - 1])
1946     return 0;  /* Ignore empty and non-properly terminated strings.  */
1947
1948   if (DBG_ASSUAN)
1949     {
1950       npth_protect ();
1951       log_debug ("ssh map file '%s'", mapfile);
1952       npth_unprotect ();
1953     }
1954
1955   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
1956   if (DBG_ASSUAN)
1957     {
1958       npth_protect ();
1959       log_debug ("ssh map handle %p\n", maphd);
1960       npth_unprotect ();
1961     }
1962
1963   if (!maphd || maphd == INVALID_HANDLE_VALUE)
1964     return 0;
1965
1966   npth_protect ();
1967
1968   mysid = w32_get_user_sid ();
1969   if (!mysid)
1970     {
1971       log_error ("error getting my sid\n");
1972       goto leave;
1973     }
1974
1975   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
1976                            OWNER_SECURITY_INFORMATION,
1977                            &mapsid, NULL, NULL, NULL,
1978                            &psd);
1979   if (w32rc)
1980     {
1981       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
1982       goto leave;
1983     }
1984
1985   if (DBG_ASSUAN)
1986     {
1987       char *sidstr;
1988
1989       if (!ConvertSidToStringSid (mysid, &sidstr))
1990         sidstr = NULL;
1991       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
1992       LocalFree (sidstr);
1993       if (!ConvertSidToStringSid (mapsid, &sidstr))
1994         sidstr = NULL;
1995       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
1996       LocalFree (sidstr);
1997     }
1998
1999   if (!EqualSid (mysid, mapsid))
2000     {
2001       log_error ("ssh map file has a non-matching sid\n");
2002       goto leave;
2003     }
2004
2005   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2006   if (DBG_ASSUAN)
2007     log_debug ("ssh IPC buffer at %p\n", data);
2008   if (!data)
2009     goto leave;
2010
2011   /* log_printhex ("request:", data, 20); */
2012
2013   ctrl = xtrycalloc (1, sizeof *ctrl);
2014   if (!ctrl)
2015     {
2016       log_error ("error allocating connection control data: %s\n",
2017                  strerror (errno) );
2018       goto leave;
2019     }
2020   ctrl->session_env = session_env_new ();
2021   if (!ctrl->session_env)
2022     {
2023       log_error ("error allocating session environment block: %s\n",
2024                  strerror (errno) );
2025       goto leave;
2026     }
2027
2028   agent_init_default_ctrl (ctrl);
2029   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2030     ret = 1; /* Valid ssh message has been constructed.  */
2031   agent_deinit_default_ctrl (ctrl);
2032   /* log_printhex ("  reply:", data, 20); */
2033
2034  leave:
2035   xfree (ctrl);
2036   if (data)
2037     UnmapViewOfFile (data);
2038   xfree (mapsid);
2039   if (psd)
2040     LocalFree (psd);
2041   xfree (mysid);
2042   CloseHandle (maphd);
2043
2044   npth_unprotect ();
2045
2046   return ret;
2047 }
2048 #endif /*HAVE_W32_SYSTEM*/
2049
2050
2051 #ifdef HAVE_W32_SYSTEM
2052 /* The thread handling Putty's IPC requests.  */
2053 static void *
2054 putty_message_thread (void *arg)
2055 {
2056   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2057                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2058   HWND hwnd;
2059   MSG msg;
2060
2061   (void)arg;
2062
2063   if (opt.verbose)
2064     log_info ("putty message loop thread started\n");
2065
2066   /* The message loop runs as thread independent from our nPth system.
2067      This also means that we need to make sure that we switch back to
2068      our system before calling any no-windows function.  */
2069   npth_unprotect ();
2070
2071   /* First create a window to make sure that a message queue exists
2072      for this thread.  */
2073   if (!RegisterClass (&wndwclass))
2074     {
2075       npth_protect ();
2076       log_error ("error registering Pageant window class");
2077       return NULL;
2078     }
2079   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2080                          0, 0, 0, 0,
2081                          HWND_MESSAGE,  /* hWndParent */
2082                          NULL,          /* hWndMenu   */
2083                          NULL,          /* hInstance  */
2084                          NULL);         /* lpParm     */
2085   if (!hwnd)
2086     {
2087       npth_protect ();
2088       log_error ("error creating Pageant window");
2089       return NULL;
2090     }
2091
2092   while (GetMessage(&msg, NULL, 0, 0))
2093     {
2094       TranslateMessage(&msg);
2095       DispatchMessage(&msg);
2096     }
2097
2098   /* Back to nPth.  */
2099   npth_protect ();
2100
2101   if (opt.verbose)
2102     log_info ("putty message loop thread stopped\n");
2103   return NULL;
2104 }
2105 #endif /*HAVE_W32_SYSTEM*/
2106
2107
2108 static void *
2109 start_connection_thread (ctrl_t ctrl)
2110 {
2111   if (check_nonce (ctrl, &socket_nonce))
2112     {
2113       log_error ("handler 0x%lx nonce check FAILED\n",
2114                  (unsigned long) npth_self());
2115       return NULL;
2116     }
2117
2118   agent_init_default_ctrl (ctrl);
2119   if (opt.verbose)
2120     log_info (_("handler 0x%lx for fd %d started\n"),
2121               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2122
2123   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2124   if (opt.verbose)
2125     log_info (_("handler 0x%lx for fd %d terminated\n"),
2126               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2127
2128   agent_deinit_default_ctrl (ctrl);
2129   xfree (ctrl);
2130   return NULL;
2131 }
2132
2133
2134 /* This is the standard connection thread's main function.  */
2135 static void *
2136 start_connection_thread_std (void *arg)
2137 {
2138   ctrl_t ctrl = arg;
2139
2140   return start_connection_thread (ctrl);
2141 }
2142
2143
2144 /* This is the extra socket connection thread's main function.  */
2145 static void *
2146 start_connection_thread_extra (void *arg)
2147 {
2148   ctrl_t ctrl = arg;
2149
2150   ctrl->restricted = 1;
2151   return start_connection_thread (ctrl);
2152 }
2153
2154
2155 /* This is the ssh connection thread's main function.  */
2156 static void *
2157 start_connection_thread_ssh (void *arg)
2158 {
2159   ctrl_t ctrl = arg;
2160
2161   if (check_nonce (ctrl, &socket_nonce_ssh))
2162     return NULL;
2163
2164   agent_init_default_ctrl (ctrl);
2165   if (opt.verbose)
2166     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2167               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2168
2169   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2170   if (opt.verbose)
2171     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2172               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2173
2174   agent_deinit_default_ctrl (ctrl);
2175   xfree (ctrl);
2176   return NULL;
2177 }
2178
2179
2180 /* Connection handler loop.  Wait for connection requests and spawn a
2181    thread after accepting a connection.  */
2182 static void
2183 handle_connections (gnupg_fd_t listen_fd,
2184                     gnupg_fd_t listen_fd_extra,
2185                     gnupg_fd_t listen_fd_ssh)
2186 {
2187   npth_attr_t tattr;
2188   struct sockaddr_un paddr;
2189   socklen_t plen;
2190   fd_set fdset, read_fdset;
2191   int ret;
2192   gnupg_fd_t fd;
2193   int nfd;
2194   int saved_errno;
2195   struct timespec abstime;
2196   struct timespec curtime;
2197   struct timespec timeout;
2198 #ifdef HAVE_W32_SYSTEM
2199   HANDLE events[2];
2200   unsigned int events_set;
2201 #endif
2202   struct {
2203     const char *name;
2204     void *(*func) (void *arg);
2205     gnupg_fd_t l_fd;
2206   } listentbl[] = {
2207     { "std",  start_connection_thread_std   },
2208     { "extra",start_connection_thread_extra },
2209     { "ssh",  start_connection_thread_ssh   }
2210   };
2211
2212
2213   ret = npth_attr_init(&tattr);
2214   if (ret)
2215     log_fatal ("error allocating thread attributes: %s\n",
2216                strerror (ret));
2217   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2218
2219 #ifndef HAVE_W32_SYSTEM
2220   npth_sigev_init ();
2221   npth_sigev_add (SIGHUP);
2222   npth_sigev_add (SIGUSR1);
2223   npth_sigev_add (SIGUSR2);
2224   npth_sigev_add (SIGINT);
2225   npth_sigev_add (SIGTERM);
2226   npth_sigev_fini ();
2227 #else
2228 # ifdef HAVE_W32CE_SYSTEM
2229   /* Use a dummy event. */
2230   sigs = 0;
2231   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2232 # else
2233   events[0] = get_agent_scd_notify_event ();
2234   events[1] = INVALID_HANDLE_VALUE;
2235 # endif
2236 #endif
2237
2238   /* On Windows we need to fire up a separate thread to listen for
2239      requests from Putty (an SSH client), so we can replace Putty's
2240      Pageant (its ssh-agent implementation). */
2241 #ifdef HAVE_W32_SYSTEM
2242   if (putty_support)
2243     {
2244       npth_t thread;
2245
2246       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2247       if (ret)
2248         {
2249           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2250         }
2251     }
2252 #endif /*HAVE_W32_SYSTEM*/
2253
2254   /* Set a flag to tell call-scd.c that it may enable event
2255      notifications.  */
2256   opt.sigusr2_enabled = 1;
2257
2258   FD_ZERO (&fdset);
2259   FD_SET (FD2INT (listen_fd), &fdset);
2260   nfd = FD2INT (listen_fd);
2261   if (listen_fd_extra != GNUPG_INVALID_FD)
2262     {
2263       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2264       if (FD2INT (listen_fd_extra) > nfd)
2265         nfd = FD2INT (listen_fd_extra);
2266     }
2267   if (listen_fd_ssh != GNUPG_INVALID_FD)
2268     {
2269       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2270       if (FD2INT (listen_fd_ssh) > nfd)
2271         nfd = FD2INT (listen_fd_ssh);
2272     }
2273
2274   listentbl[0].l_fd = listen_fd;
2275   listentbl[1].l_fd = listen_fd_extra;
2276   listentbl[2].l_fd = listen_fd_ssh;
2277
2278   npth_clock_gettime (&abstime);
2279   abstime.tv_sec += TIMERTICK_INTERVAL;
2280
2281   for (;;)
2282     {
2283       /* Shutdown test.  */
2284       if (shutdown_pending)
2285         {
2286           if (active_connections == 0)
2287             break; /* ready */
2288
2289           /* Do not accept new connections but keep on running the
2290              loop to cope with the timer events.  */
2291           FD_ZERO (&fdset);
2292         }
2293
2294       /* POSIX says that fd_set should be implemented as a structure,
2295          thus a simple assignment is fine to copy the entire set.  */
2296       read_fdset = fdset;
2297
2298       npth_clock_gettime (&curtime);
2299       if (!(npth_timercmp (&curtime, &abstime, <)))
2300         {
2301           /* Timeout.  */
2302           handle_tick ();
2303           npth_clock_gettime (&abstime);
2304           abstime.tv_sec += TIMERTICK_INTERVAL;
2305         }
2306       npth_timersub (&abstime, &curtime, &timeout);
2307
2308 #ifndef HAVE_W32_SYSTEM
2309       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2310                           npth_sigev_sigmask ());
2311       saved_errno = errno;
2312
2313       {
2314         int signo;
2315         while (npth_sigev_get_pending (&signo))
2316           handle_signal (signo);
2317       }
2318 #else
2319       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2320                           events, &events_set);
2321       saved_errno = errno;
2322
2323       /* This is valid even if npth_eselect returns an error.  */
2324       if (events_set & 1)
2325         agent_sigusr2_action ();
2326 #endif
2327
2328       if (ret == -1 && saved_errno != EINTR)
2329         {
2330           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2331                      strerror (saved_errno));
2332           npth_sleep (1);
2333           continue;
2334         }
2335       if (ret <= 0)
2336         /* Interrupt or timeout.  Will be handled when calculating the
2337            next timeout.  */
2338         continue;
2339
2340       if (!shutdown_pending)
2341         {
2342           int idx;
2343           ctrl_t ctrl;
2344           npth_t thread;
2345
2346           for (idx=0; idx < DIM(listentbl); idx++)
2347             {
2348               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2349                 continue;
2350               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2351                 continue;
2352
2353               plen = sizeof paddr;
2354               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2355                                         (struct sockaddr *)&paddr, &plen));
2356               if (fd == GNUPG_INVALID_FD)
2357                 {
2358                   log_error ("accept failed for %s: %s\n",
2359                              listentbl[idx].name, strerror (errno));
2360                 }
2361               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2362                 {
2363                   log_error ("error allocating connection data for %s: %s\n",
2364                              listentbl[idx].name, strerror (errno) );
2365                   assuan_sock_close (fd);
2366                 }
2367               else if ( !(ctrl->session_env = session_env_new ()))
2368                 {
2369                   log_error ("error allocating session env block for %s: %s\n",
2370                              listentbl[idx].name, strerror (errno) );
2371                   xfree (ctrl);
2372                   assuan_sock_close (fd);
2373                 }
2374               else
2375                 {
2376                   ctrl->thread_startup.fd = fd;
2377                   ret = npth_create (&thread, &tattr,
2378                                      listentbl[idx].func, ctrl);
2379                   if (ret)
2380                     {
2381                       log_error ("error spawning connection handler for %s:"
2382                                  " %s\n", listentbl[idx].name, strerror (ret));
2383                       assuan_sock_close (fd);
2384                       xfree (ctrl);
2385                     }
2386                 }
2387               fd = GNUPG_INVALID_FD;
2388             }
2389         }
2390     }
2391
2392   cleanup ();
2393   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2394   npth_attr_destroy (&tattr);
2395 }
2396
2397
2398
2399 /* Helper for check_own_socket.  */
2400 static gpg_error_t
2401 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2402 {
2403   membuf_t *mb = opaque;
2404   put_membuf (mb, buffer, length);
2405   return 0;
2406 }
2407
2408
2409 /* The thread running the actual check.  We need to run this in a
2410    separate thread so that check_own_thread can be called from the
2411    timer tick.  */
2412 static void *
2413 check_own_socket_thread (void *arg)
2414 {
2415   int rc;
2416   char *sockname = arg;
2417   assuan_context_t ctx = NULL;
2418   membuf_t mb;
2419   char *buffer;
2420
2421   check_own_socket_running++;
2422
2423   rc = assuan_new (&ctx);
2424   if (rc)
2425     {
2426       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2427       goto leave;
2428     }
2429
2430   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2431   if (rc)
2432     {
2433       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2434       goto leave;
2435     }
2436
2437   init_membuf (&mb, 100);
2438   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2439                         NULL, NULL, NULL, NULL);
2440   put_membuf (&mb, "", 1);
2441   buffer = get_membuf (&mb, NULL);
2442   if (rc || !buffer)
2443     {
2444       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2445                  "GETINFO pid", gpg_strerror (rc));
2446       rc = 1;
2447     }
2448   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2449     {
2450       log_error ("socket is now serviced by another server\n");
2451       rc = 1;
2452     }
2453   else if (opt.verbose > 1)
2454     log_error ("socket is still served by this server\n");
2455
2456   xfree (buffer);
2457
2458  leave:
2459   xfree (sockname);
2460   if (ctx)
2461     assuan_release (ctx);
2462   if (rc)
2463     {
2464       /* We may not remove the socket as it is now in use by another
2465          server.  Setting the name to empty does this.  */
2466       if (socket_name)
2467         *socket_name = 0;
2468       if (socket_name_ssh)
2469         *socket_name_ssh = 0;
2470       shutdown_pending = 2;
2471       log_info ("this process is useless - shutting down\n");
2472     }
2473   check_own_socket_running--;
2474   return NULL;
2475 }
2476
2477
2478 /* Check whether we are still listening on our own socket.  In case
2479    another gpg-agent process started after us has taken ownership of
2480    our socket, we would linger around without any real task.  Thus we
2481    better check once in a while whether we are really needed.  */
2482 static void
2483 check_own_socket (void)
2484 {
2485   char *sockname;
2486   npth_t thread;
2487   npth_attr_t tattr;
2488   int err;
2489
2490   if (disable_check_own_socket)
2491     return;
2492
2493   if (check_own_socket_running || shutdown_pending)
2494     return;  /* Still running or already shutting down.  */
2495
2496   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2497   if (!sockname)
2498     return; /* Out of memory.  */
2499
2500   err = npth_attr_init (&tattr);
2501   if (err)
2502     return;
2503   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2504   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2505   if (err)
2506     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2507   npth_attr_destroy (&tattr);
2508 }
2509
2510
2511
2512 /* Figure out whether an agent is available and running. Prints an
2513    error if not.  If SILENT is true, no messages are printed.
2514    Returns 0 if the agent is running. */
2515 static int
2516 check_for_running_agent (int silent)
2517 {
2518   gpg_error_t err;
2519   char *sockname;
2520   assuan_context_t ctx = NULL;
2521
2522   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2523
2524   err = assuan_new (&ctx);
2525   if (!err)
2526     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2527   xfree (sockname);
2528   if (err)
2529     {
2530       if (!silent)
2531         log_error (_("no gpg-agent running in this session\n"));
2532
2533       if (ctx)
2534         assuan_release (ctx);
2535       return -1;
2536     }
2537
2538   if (!opt.quiet && !silent)
2539     log_info ("gpg-agent running and available\n");
2540
2541   assuan_release (ctx);
2542   return 0;
2543 }