aa0a407161257186e072ca9c55a5d2f83d41481e
[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   if (use_standard_socket && rc == -1 && errno == EADDRINUSE)
1497     {
1498       /* Check whether a gpg-agent is already running on the standard
1499          socket.  We do this test only if this is not the ssh socket.
1500          For ssh we assume that a test for gpg-agent has already been
1501          done and reuse the requested ssh socket.  Testing the
1502          ssh-socket is not possible because at this point, though we
1503          know the new Assuan socket, the Assuan server and thus the
1504          ssh-agent server is not yet operational.  This would lead to
1505          a hang.  */
1506       if (!is_ssh && !check_for_running_agent (1, 1))
1507         {
1508           log_error (_("a gpg-agent is already running - "
1509                        "not starting a new one\n"));
1510           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1511           assuan_sock_close (fd);
1512           agent_exit (2);
1513         }
1514       gnupg_remove (name);
1515       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1516     }
1517   if (rc != -1 
1518       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1519     log_error (_("error getting nonce for the socket\n"));
1520   if (rc == -1)
1521     {
1522       /* We use gpg_strerror here because it allows us to get strings
1523          for some W32 socket error codes.  */
1524       log_error (_("error binding socket to `%s': %s\n"),
1525                  serv_addr->sun_path, 
1526                  gpg_strerror (gpg_error_from_errno (errno)));
1527       
1528       assuan_sock_close (fd);
1529       if (use_standard_socket)
1530         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1531       agent_exit (2);
1532     }
1533
1534   if (listen (FD2INT(fd), 5 ) == -1)
1535     {
1536       log_error (_("listen() failed: %s\n"), strerror (errno));
1537       assuan_sock_close (fd);
1538       agent_exit (2);
1539     }
1540           
1541   if (opt.verbose)
1542     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1543
1544   return fd;
1545 }
1546
1547
1548 /* Check that the directory for storing the private keys exists and
1549    create it if not.  This function won't fail as it is only a
1550    convenience function and not strictly necessary.  */
1551 static void
1552 create_private_keys_directory (const char *home)
1553 {
1554   char *fname;
1555   struct stat statbuf;
1556
1557   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1558   if (stat (fname, &statbuf) && errno == ENOENT)
1559     {
1560       if (gnupg_mkdir (fname, "-rwx"))
1561         log_error (_("can't create directory `%s': %s\n"),
1562                    fname, strerror (errno) );
1563       else if (!opt.quiet)
1564         log_info (_("directory `%s' created\n"), fname);
1565     }
1566   xfree (fname);
1567 }
1568
1569 /* Create the directory only if the supplied directory name is the
1570    same as the default one.  This way we avoid to create arbitrary
1571    directories when a non-default home directory is used.  To cope
1572    with HOME, we compare only the suffix if we see that the default
1573    homedir does start with a tilde.  We don't stop here in case of
1574    problems because other functions will throw an error anyway.*/
1575 static void
1576 create_directories (void)
1577 {
1578   struct stat statbuf;
1579   const char *defhome = standard_homedir ();
1580   char *home;
1581
1582   home = make_filename (opt.homedir, NULL);
1583   if ( stat (home, &statbuf) )
1584     {
1585       if (errno == ENOENT)
1586         {
1587           if (
1588 #ifdef HAVE_W32_SYSTEM
1589               ( !compare_filenames (home, defhome) )
1590 #else
1591               (*defhome == '~'
1592                 && (strlen (home) >= strlen (defhome+1)
1593                     && !strcmp (home + strlen(home)
1594                                 - strlen (defhome+1), defhome+1)))
1595                || (*defhome != '~' && !strcmp (home, defhome) )
1596 #endif
1597                )
1598             {
1599               if (gnupg_mkdir (home, "-rwx"))
1600                 log_error (_("can't create directory `%s': %s\n"),
1601                            home, strerror (errno) );
1602               else 
1603                 {
1604                   if (!opt.quiet)
1605                     log_info (_("directory `%s' created\n"), home);
1606                   create_private_keys_directory (home);
1607                 }
1608             }
1609         }
1610       else
1611         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1612     }
1613   else if ( !S_ISDIR(statbuf.st_mode))
1614     {
1615       log_error (_("can't use `%s' as home directory\n"), home);
1616     }
1617   else /* exists and is a directory. */
1618     {
1619       create_private_keys_directory (home);
1620     }
1621   xfree (home);
1622 }
1623
1624
1625
1626 /* This is the worker for the ticker.  It is called every few seconds
1627    and may only do fast operations. */
1628 static void
1629 handle_tick (void)
1630 {
1631   static time_t last_minute;
1632
1633   if (!last_minute)
1634     last_minute = time (NULL);
1635
1636   /* Check whether the scdaemon has died and cleanup in this case. */
1637   agent_scd_check_aliveness ();
1638
1639   /* If we are running as a child of another process, check whether
1640      the parent is still alive and shutdown if not. */
1641 #ifndef HAVE_W32_SYSTEM
1642   if (parent_pid != (pid_t)(-1))
1643     {
1644       if (kill (parent_pid, 0))
1645         {
1646           shutdown_pending = 2;
1647           log_info ("parent process died - shutting down\n");
1648           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1649           cleanup ();
1650           agent_exit (0);
1651         }
1652     }
1653 #endif /*HAVE_W32_SYSTEM*/
1654   
1655   /* Code to be run every minute.  */
1656   if (last_minute + 60 <= time (NULL))
1657     {
1658       check_own_socket ();
1659       last_minute = time (NULL);
1660     }
1661
1662 }
1663
1664
1665 /* A global function which allows us to call the reload stuff from
1666    other places too.  This is only used when build for W32.  */
1667 void
1668 agent_sighup_action (void)
1669 {
1670   log_info ("SIGHUP received - "
1671             "re-reading configuration and flushing cache\n");
1672   agent_flush_cache ();
1673   reread_configuration ();
1674   agent_reload_trustlist ();
1675 }
1676
1677
1678 static void
1679 agent_sigusr2_action (void)
1680 {
1681   if (opt.verbose)
1682     log_info ("SIGUSR2 received - updating card event counter\n");
1683   /* Nothing to check right now.  We only increment a counter.  */
1684   bump_card_eventcounter ();
1685 }
1686
1687
1688 static void
1689 handle_signal (int signo)
1690 {
1691   switch (signo)
1692     {
1693 #ifndef HAVE_W32_SYSTEM
1694     case SIGHUP:
1695       agent_sighup_action ();
1696       break;
1697       
1698     case SIGUSR1:
1699       log_info ("SIGUSR1 received - printing internal information:\n");
1700       /* Fixme: We need to see how to integrate pth dumping into our
1701          logging system.  */
1702       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1703       agent_query_dump_state ();
1704       agent_scd_dump_state ();
1705       break;
1706       
1707     case SIGUSR2:
1708       agent_sigusr2_action ();
1709       break;
1710
1711     case SIGTERM:
1712       if (!shutdown_pending)
1713         log_info ("SIGTERM received - shutting down ...\n");
1714       else
1715         log_info ("SIGTERM received - still %ld running threads\n",
1716                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1717       shutdown_pending++;
1718       if (shutdown_pending > 2)
1719         {
1720           log_info ("shutdown forced\n");
1721           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1722           cleanup ();
1723           agent_exit (0);
1724         }
1725       break;
1726         
1727     case SIGINT:
1728       log_info ("SIGINT received - immediate shutdown\n");
1729       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1730       cleanup ();
1731       agent_exit (0);
1732       break;
1733 #endif
1734     default:
1735       log_info ("signal %d received - no action defined\n", signo);
1736     }
1737 }
1738
1739
1740 /* Check the nonce on a new connection.  This is a NOP unless we we
1741    are using our Unix domain socket emulation under Windows.  */
1742 static int 
1743 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1744 {
1745   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1746     {
1747       log_info (_("error reading nonce on fd %d: %s\n"), 
1748                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1749       assuan_sock_close (ctrl->thread_startup.fd);
1750       xfree (ctrl);
1751       return -1;
1752     }
1753   else
1754     return 0;
1755 }
1756
1757
1758 /* This is the standard connection thread's main function.  */
1759 static void *
1760 start_connection_thread (void *arg)
1761 {
1762   ctrl_t ctrl = arg;
1763
1764   if (check_nonce (ctrl, &socket_nonce))
1765     return NULL;
1766
1767   agent_init_default_ctrl (ctrl);
1768   if (opt.verbose)
1769     log_info (_("handler 0x%lx for fd %d started\n"), 
1770               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1771
1772   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1773   if (opt.verbose)
1774     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1775               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1776   
1777   agent_deinit_default_ctrl (ctrl);
1778   xfree (ctrl);
1779   return NULL;
1780 }
1781
1782
1783 /* This is the ssh connection thread's main function.  */
1784 static void *
1785 start_connection_thread_ssh (void *arg)
1786 {
1787   ctrl_t ctrl = arg;
1788
1789   if (check_nonce (ctrl, &socket_nonce_ssh))
1790     return NULL;
1791
1792   agent_init_default_ctrl (ctrl);
1793   if (opt.verbose)
1794     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1795               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1796
1797   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1798   if (opt.verbose)
1799     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1800               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1801   
1802   agent_deinit_default_ctrl (ctrl);
1803   xfree (ctrl);
1804   return NULL;
1805 }
1806
1807
1808 /* Connection handler loop.  Wait for connection requests and spawn a
1809    thread after accepting a connection.  */
1810 static void
1811 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1812 {
1813   pth_attr_t tattr;
1814   pth_event_t ev, time_ev;
1815   sigset_t sigs;
1816   int signo;
1817   struct sockaddr_un paddr;
1818   socklen_t plen;
1819   fd_set fdset, read_fdset;
1820   int ret;
1821   gnupg_fd_t fd;
1822   int nfd;
1823
1824   tattr = pth_attr_new();
1825   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1826   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1827
1828 #ifndef HAVE_W32_SYSTEM /* fixme */
1829   /* Make sure that the signals we are going to handle are not blocked
1830      and create an event object for them.  We also set the default
1831      action to ignore because we use an Pth event to get notified
1832      about signals.  This avoids that the default action is taken in
1833      case soemthing goes wrong within Pth.  The problem might also be
1834      a Pth bug.  */
1835   sigemptyset (&sigs );
1836   {
1837     static const int mysigs[] = { SIGHUP, SIGUSR1, SIGUSR2, SIGINT, SIGTERM };
1838     struct sigaction sa;
1839     int i;
1840
1841     for (i=0; i < DIM (mysigs); i++)
1842       {
1843         sigemptyset (&sa.sa_mask);
1844         sa.sa_handler = SIG_IGN;
1845         sa.sa_flags = 0;
1846         sigaction (mysigs[i], &sa, NULL);
1847         
1848         sigaddset (&sigs, mysigs[i]);
1849       }
1850   }
1851
1852   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1853   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1854 #else
1855 # ifdef HAVE_W32CE_SYSTEM
1856   /* Use a dummy event. */
1857   sigs = 0;
1858   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1859 # else
1860   sigs = 0;
1861   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1862   signo = 0;
1863 # endif
1864 #endif
1865   time_ev = NULL;
1866
1867   FD_ZERO (&fdset);
1868   FD_SET (FD2INT (listen_fd), &fdset);
1869   nfd = FD2INT (listen_fd);
1870   if (listen_fd_ssh != GNUPG_INVALID_FD)
1871     {
1872       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1873       if (FD2INT (listen_fd_ssh) > nfd)
1874         nfd = FD2INT (listen_fd_ssh);
1875     }
1876
1877   for (;;)
1878     {
1879       /* Make sure that our signals are not blocked.  */
1880       pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1881
1882       /* Shutdown test.  */
1883       if (shutdown_pending)
1884         {
1885           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1886             break; /* ready */
1887
1888           /* Do not accept new connections but keep on running the
1889              loop to cope with the timer events.  */
1890           FD_ZERO (&fdset);
1891         }
1892
1893       /* Create a timeout event if needed.  To help with power saving
1894          we syncronize the ticks to the next full second.  */
1895       if (!time_ev)
1896         {
1897           pth_time_t nexttick;
1898
1899           nexttick = pth_timeout (TIMERTICK_INTERVAL, 0);
1900           if (nexttick.tv_usec > 10)  /* Use a 10 usec threshhold.  */
1901             {
1902               nexttick.tv_sec++;
1903               nexttick.tv_usec = 0;
1904             }
1905           time_ev = pth_event (PTH_EVENT_TIME, nexttick);
1906         }
1907
1908       /* POSIX says that fd_set should be implemented as a structure,
1909          thus a simple assignment is fine to copy the entire set.  */
1910       read_fdset = fdset;
1911
1912       if (time_ev)
1913         pth_event_concat (ev, time_ev, NULL);
1914       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1915       if (time_ev)
1916         pth_event_isolate (time_ev);
1917
1918       if (ret == -1)
1919         {
1920           if (pth_event_occurred (ev)
1921               || (time_ev && pth_event_occurred (time_ev)))
1922             {
1923               if (pth_event_occurred (ev))
1924                 {
1925 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1926                   agent_sigusr2_action ();
1927 #else
1928                   handle_signal (signo);
1929 #endif
1930                 }
1931               if (time_ev && pth_event_occurred (time_ev))
1932                 {
1933                   pth_event_free (time_ev, PTH_FREE_ALL);
1934                   time_ev = NULL;
1935                   handle_tick ();
1936                 }
1937               continue;
1938             }
1939           log_error (_("pth_select failed: %s - waiting 1s\n"),
1940                      strerror (errno));
1941           pth_sleep (1);
1942           continue;
1943         }
1944
1945       if (pth_event_occurred (ev))
1946         {
1947 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1948           agent_sigusr2_action ();
1949 #else
1950           handle_signal (signo);
1951 #endif
1952         }
1953
1954       if (time_ev && pth_event_occurred (time_ev))
1955         {
1956           pth_event_free (time_ev, PTH_FREE_ALL);
1957           time_ev = NULL;
1958           handle_tick ();
1959         }
1960
1961
1962       /* We now might create new threads and because we don't want any
1963          signals (as we are handling them here) to be delivered to a
1964          new thread.  Thus we need to block those signals. */
1965       pth_sigmask (SIG_BLOCK, &sigs, NULL);
1966
1967       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
1968         {
1969           ctrl_t ctrl;
1970
1971           plen = sizeof paddr;
1972           fd = INT2FD (pth_accept (FD2INT(listen_fd),
1973                                    (struct sockaddr *)&paddr, &plen));
1974           if (fd == GNUPG_INVALID_FD)
1975             {
1976               log_error ("accept failed: %s\n", strerror (errno));
1977             }
1978           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1979             {
1980               log_error ("error allocating connection control data: %s\n",
1981                          strerror (errno) );
1982               assuan_sock_close (fd);
1983             }
1984           else if ( !(ctrl->session_env = session_env_new ()) )
1985             {
1986               log_error ("error allocating session environment block: %s\n",
1987                          strerror (errno) );
1988               xfree (ctrl);
1989               assuan_sock_close (fd);
1990             }
1991           else 
1992             {
1993               char threadname[50];
1994
1995               snprintf (threadname, sizeof threadname-1,
1996                         "conn fd=%d (gpg)", FD2INT(fd));
1997               threadname[sizeof threadname -1] = 0;
1998               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1999               ctrl->thread_startup.fd = fd;
2000               if (!pth_spawn (tattr, start_connection_thread, ctrl))
2001                 {
2002                   log_error ("error spawning connection handler: %s\n",
2003                              strerror (errno) );
2004                   assuan_sock_close (fd);
2005                   xfree (ctrl);
2006                 }
2007             }
2008           fd = GNUPG_INVALID_FD;
2009         }
2010
2011       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD 
2012           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2013         {
2014           ctrl_t ctrl;
2015
2016           plen = sizeof paddr;
2017           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
2018                                   (struct sockaddr *)&paddr, &plen));
2019           if (fd == GNUPG_INVALID_FD)
2020             {
2021               log_error ("accept failed for ssh: %s\n", strerror (errno));
2022             }
2023           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2024             {
2025               log_error ("error allocating connection control data: %s\n",
2026                          strerror (errno) );
2027               assuan_sock_close (fd);
2028             }
2029           else if ( !(ctrl->session_env = session_env_new ()) )
2030             {
2031               log_error ("error allocating session environment block: %s\n",
2032                          strerror (errno) );
2033               xfree (ctrl);
2034               assuan_sock_close (fd);
2035             }
2036           else
2037             {
2038               char threadname[50];
2039
2040               agent_init_default_ctrl (ctrl);
2041               snprintf (threadname, sizeof threadname-1,
2042                         "conn fd=%d (ssh)", FD2INT(fd));
2043               threadname[sizeof threadname -1] = 0;
2044               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2045               ctrl->thread_startup.fd = fd;
2046               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
2047                 {
2048                   log_error ("error spawning ssh connection handler: %s\n",
2049                              strerror (errno) );
2050                   assuan_sock_close (fd);
2051                   xfree (ctrl);
2052                 }
2053             }
2054           fd = GNUPG_INVALID_FD;
2055         }
2056     }
2057
2058   pth_event_free (ev, PTH_FREE_ALL);
2059   if (time_ev)
2060     pth_event_free (time_ev, PTH_FREE_ALL);
2061   cleanup ();
2062   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2063 }
2064
2065
2066
2067 /* Helper for check_own_socket.  */
2068 static gpg_error_t
2069 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2070 {
2071   membuf_t *mb = opaque;
2072   put_membuf (mb, buffer, length);
2073   return 0;
2074 }
2075
2076
2077 /* The thread running the actual check.  We need to run this in a
2078    separate thread so that check_own_thread can be called from the
2079    timer tick.  */
2080 static void *
2081 check_own_socket_thread (void *arg)
2082 {
2083   int rc;
2084   char *sockname = arg;
2085   assuan_context_t ctx = NULL;
2086   membuf_t mb;
2087   char *buffer;
2088
2089   check_own_socket_running++;
2090
2091   rc = assuan_new (&ctx);
2092   xfree (sockname);
2093   if (rc)
2094     {
2095       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2096       goto leave;
2097     }
2098
2099   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2100   if (rc)
2101     {
2102       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2103       goto leave;
2104     }
2105  
2106   init_membuf (&mb, 100);
2107   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2108                         NULL, NULL, NULL, NULL);
2109   put_membuf (&mb, "", 1);
2110   buffer = get_membuf (&mb, NULL);
2111   if (rc || !buffer)
2112     {
2113       log_error ("sending command \"%s\" to my own socket failed: %s\n", 
2114                  "GETINFO pid", gpg_strerror (rc));
2115       rc = 1;
2116     }
2117   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2118     {
2119       log_error ("socket is now serviced by another server\n");
2120       rc = 1;
2121     }
2122   else if (opt.verbose > 1)
2123     log_error ("socket is still served by this server\n");
2124     
2125   xfree (buffer);
2126
2127  leave:
2128   if (ctx)
2129     assuan_release (ctx);
2130   if (rc)
2131     {
2132       /* We may not remove the socket as it is now in use by another
2133          server.  Setting the name to empty does this.  */
2134       if (socket_name)
2135         *socket_name = 0;
2136       if (socket_name_ssh)
2137         *socket_name_ssh = 0;
2138       shutdown_pending = 2;
2139       log_info ("this process is useless - shutting down\n");
2140     }
2141   check_own_socket_running--;
2142   return NULL;
2143 }
2144
2145
2146 /* Check whether we are still listening on our own socket.  In case
2147    another gpg-agent process started after us has taken ownership of
2148    our socket, we woul linger around without any real taks.  Thus we
2149    better check once in a while whether we are really needed.  */
2150 static void
2151 check_own_socket (void)
2152 {
2153   char *sockname;
2154   pth_attr_t tattr;
2155
2156   if (!use_standard_socket)
2157     return; /* This check makes only sense in standard socket mode.  */
2158
2159   if (check_own_socket_running || shutdown_pending)
2160     return;  /* Still running or already shutting down.  */
2161
2162   sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
2163   if (!sockname)
2164     return; /* Out of memory.  */
2165
2166   tattr = pth_attr_new();
2167   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
2168   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
2169   pth_attr_set (tattr, PTH_ATTR_NAME, "check-own-socket");
2170
2171   if (!pth_spawn (tattr, check_own_socket_thread, sockname))
2172       log_error ("error spawning check_own_socket_thread: %s\n",
2173                  strerror (errno) );
2174   pth_attr_destroy (tattr);
2175 }
2176
2177
2178
2179 /* Figure out whether an agent is available and running. Prints an
2180    error if not.  If SILENT is true, no messages are printed.  Usually
2181    started with MODE 0.  Returns 0 if the agent is running. */
2182 static int
2183 check_for_running_agent (int silent, int mode)
2184 {
2185   int rc;
2186   char *infostr, *p;
2187   assuan_context_t ctx = NULL;
2188   int prot, pid;
2189
2190   if (!mode)
2191     {
2192       infostr = getenv ("GPG_AGENT_INFO");
2193       if (!infostr || !*infostr)
2194         {
2195           if (!check_for_running_agent (silent, 1))
2196             return 0; /* Okay, its running on the standard socket. */
2197           if (!silent)
2198             log_error (_("no gpg-agent running in this session\n"));
2199           return -1;
2200         }
2201
2202       infostr = xstrdup (infostr);
2203       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2204         {
2205           xfree (infostr);
2206           if (!check_for_running_agent (silent, 1))
2207             return 0; /* Okay, its running on the standard socket. */
2208           if (!silent)
2209             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
2210           return -1;
2211         }
2212
2213       *p++ = 0;
2214       pid = atoi (p);
2215       while (*p && *p != PATHSEP_C)
2216         p++;
2217       prot = *p? atoi (p+1) : 0;
2218       if (prot != 1)
2219         {
2220           xfree (infostr);
2221           if (!silent)
2222             log_error (_("gpg-agent protocol version %d is not supported\n"),
2223                        prot);
2224           if (!check_for_running_agent (silent, 1))
2225             return 0; /* Okay, its running on the standard socket. */
2226           return -1;
2227         }
2228     }
2229   else /* MODE != 0 */
2230     {
2231       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
2232       pid = (pid_t)(-1);
2233     }
2234
2235   rc = assuan_new (&ctx);
2236   if (! rc)
2237     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2238   xfree (infostr);
2239   if (rc)
2240     {
2241       if (!mode && !check_for_running_agent (silent, 1))
2242         return 0; /* Okay, its running on the standard socket. */
2243
2244       if (!mode && !silent)
2245         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2246
2247       if (ctx)
2248         assuan_release (ctx);
2249       return -1;
2250     }
2251
2252   if (!opt.quiet && !silent)
2253     log_info ("gpg-agent running and available\n");
2254
2255   assuan_release (ctx);
2256   return 0;
2257 }