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