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