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