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