2009-09-23 Marcus Brinkmann <marcus@g10code.de>
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007, 2009 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 #include <signal.h>
39 #include <pth.h>
40
41 #define JNLIB_NEED_LOG_LOGV
42 #define JNLIB_NEED_AFLOCAL
43 #include "agent.h"
44 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
45
46 #include "i18n.h"
47 #include "mkdtemp.h" /* Gnulib replacement. */
48 #include "sysutils.h"
49 #include "setenv.h"
50 #include "gc-opt-flags.h"
51 #include "exechelp.h"
52
53 enum cmd_and_opt_values 
54 { aNull = 0,
55   oCsh            = 'c',
56   oQuiet          = 'q',
57   oSh             = 's',
58   oVerbose        = 'v',
59
60   oNoVerbose = 500,
61   aGPGConfList,
62   aGPGConfTest,
63   oOptions,
64   oDebug,
65   oDebugAll,
66   oDebugLevel,
67   oDebugWait,
68   oNoGreeting,
69   oNoOptions,
70   oHomedir,
71   oNoDetach,
72   oNoGrab,
73   oLogFile,
74   oServer,
75   oDaemon,
76   oBatch,
77
78   oPinentryProgram,
79   oPinentryTouchFile,
80   oDisplay,
81   oTTYname,
82   oTTYtype,
83   oLCctype,
84   oLCmessages,
85   oXauthority,
86   oScdaemonProgram,
87   oDefCacheTTL,
88   oDefCacheTTLSSH,
89   oMaxCacheTTL,
90   oMaxCacheTTLSSH,
91   oEnforcePassphraseConstraints,
92   oMinPassphraseLen,
93   oMinPassphraseNonalpha,
94   oCheckPassphrasePattern,
95   oMaxPassphraseDays,
96   oEnablePassphraseHistory,
97   oUseStandardSocket,
98   oNoUseStandardSocket,
99   oFakedSystemTime,
100
101   oIgnoreCacheForSigning,
102   oAllowMarkTrusted,
103   oAllowPresetPassphrase,
104   oKeepTTY,
105   oKeepDISPLAY,
106   oSSHSupport,
107   oDisableScdaemon,
108   oWriteEnvFile
109 };
110
111
112
113 static ARGPARSE_OPTS opts[] = {
114
115   { aGPGConfList, "gpgconf-list", 256, "@" },
116   { aGPGConfTest, "gpgconf-test", 256, "@" },
117   
118   { 301, NULL, 0, N_("@Options:\n ") },
119
120   { oServer,   "server",     0, N_("run in server mode (foreground)") },
121   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
122   { oVerbose, "verbose",     0, N_("verbose") },
123   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
124   { oSh,        "sh",        0, N_("sh-style command output") },
125   { oCsh,       "csh",       0, N_("csh-style command output") },
126   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
127   { oDebug,     "debug"     ,4|16, "@"},
128   { oDebugAll, "debug-all"     ,0, "@"},
129   { oDebugLevel, "debug-level" ,2, "@"},
130   { oDebugWait,"debug-wait",1, "@"},
131   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
132   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
133   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
134   { oUseStandardSocket, "use-standard-socket", 0,
135                       N_("use a standard location for the socket")},
136   { oNoUseStandardSocket, "no-use-standard-socket", 0, "@"},
137   { oPinentryProgram, "pinentry-program", 2 ,
138                                N_("|PGM|use PGM as the PIN-Entry program") },
139   { oPinentryTouchFile, "pinentry-touch-file", 2 , "@" },
140   { oScdaemonProgram, "scdaemon-program", 2 ,
141                                N_("|PGM|use PGM as the SCdaemon program") },
142   { oDisableScdaemon, "disable-scdaemon", 0, N_("do not use the SCdaemon") },
143   { oFakedSystemTime, "faked-system-time", 2, "@" }, /* (epoch time) */
144
145   { oBatch,      "batch",       0, "@" },
146   { oHomedir,    "homedir",     2, "@"},   
147
148   { oDisplay,    "display",     2, "@" },
149   { oTTYname,    "ttyname",     2, "@" },
150   { oTTYtype,    "ttytype",     2, "@" },
151   { oLCctype,    "lc-ctype",    2, "@" },
152   { oLCmessages, "lc-messages", 2, "@" },
153   { oXauthority, "xauthority",  2, "@" },
154   { oKeepTTY,    "keep-tty",    0,  N_("ignore requests to change the TTY")},
155   { oKeepDISPLAY, "keep-display",
156                           0, N_("ignore requests to change the X display")},
157
158   { oDefCacheTTL, "default-cache-ttl", 4,
159                                N_("|N|expire cached PINs after N seconds")},
160   { oDefCacheTTLSSH, "default-cache-ttl-ssh", 4, "@" },
161   { oMaxCacheTTL, "max-cache-ttl", 4, "@" },
162   { oMaxCacheTTLSSH, "max-cache-ttl-ssh", 4, "@" },
163
164   { oEnforcePassphraseConstraints, "enforce-passphrase-constraints", 0, "@"},
165   { oMinPassphraseLen, "min-passphrase-len", 4, "@" },
166   { oMinPassphraseNonalpha, "min-passphrase-nonalpha", 4, "@" },
167   { oCheckPassphrasePattern, "check-passphrase-pattern", 2, "@" },
168   { oMaxPassphraseDays, "max-passphrase-days", 4, "@" },
169   { oEnablePassphraseHistory, "enable-passphrase-history", 0, "@" },
170
171   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
172                                N_("do not use the PIN cache when signing")},
173   { oAllowMarkTrusted, "allow-mark-trusted", 0,
174                              N_("allow clients to mark keys as \"trusted\"")},
175   { oAllowPresetPassphrase, "allow-preset-passphrase", 0,
176                              N_("allow presetting passphrase")},
177   { oSSHSupport, "enable-ssh-support", 0, N_("enable ssh-agent emulation") },
178   { oWriteEnvFile, "write-env-file", 2|8,
179             N_("|FILE|write environment settings also to FILE")},
180   {0}
181 };
182
183
184 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
185 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
186 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
187 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
188 #define MIN_PASSPHRASE_LEN    (8)      
189 #define MIN_PASSPHRASE_NONALPHA (1)      
190 #define MAX_PASSPHRASE_DAYS   (0)
191
192 /* The timer tick used for housekeeping stuff.  For Windows we use a
193    longer period as the SetWaitableTimer seems to signal earlier than
194    the 2 seconds.  */
195 #ifdef HAVE_W32_SYSTEM
196 #define TIMERTICK_INTERVAL    (4)
197 #else
198 #define TIMERTICK_INTERVAL    (2)    /* Seconds.  */
199 #endif
200
201
202 /* The list of open file descriptors at startup.  Note that this list
203    has been allocated using the standard malloc.  */
204 static int *startup_fd_list;
205
206 /* The signal mask at startup and a flag telling whether it is valid.  */
207 #ifdef HAVE_SIGPROCMASK
208 static sigset_t startup_signal_mask;
209 static int startup_signal_mask_valid;
210 #endif
211
212 /* Flag to indicate that a shutdown was requested.  */
213 static int shutdown_pending;
214
215 /* Counter for the currently running own socket checks.  */
216 static int check_own_socket_running;
217
218 /* True if we are listening on the standard socket.  */
219 static int use_standard_socket;
220
221 /* It is possible that we are currently running under setuid permissions */
222 static int maybe_setuid = 1;
223
224 /* Name of the communication socket used for native gpg-agent requests.  */
225 static char *socket_name;
226
227 /* Name of the communication socket used for ssh-agent-emulation.  */
228 static char *socket_name_ssh;
229
230 /* We need to keep track of the server's nonces (these are dummies for
231    POSIX systems). */
232 static assuan_sock_nonce_t socket_nonce;
233 static assuan_sock_nonce_t socket_nonce_ssh;
234
235
236 /* Default values for options passed to the pinentry. */
237 static char *default_display;
238 static char *default_ttyname;
239 static char *default_ttytype;
240 static char *default_lc_ctype;
241 static char *default_lc_messages;
242 static char *default_xauthority;
243
244 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
245 static char *config_filename;
246
247 /* Helper to implement --debug-level */
248 static const char *debug_level;
249
250 /* Keep track of the current log file so that we can avoid updating
251    the log file after a SIGHUP if it didn't changed. Malloced. */
252 static char *current_logfile;
253
254 /* The handle_tick() function may test whether a parent is still
255    running.  We record the PID of the parent here or -1 if it should be
256    watched. */
257 static pid_t parent_pid = (pid_t)(-1);
258
259 \f
260 /*
261    Local prototypes. 
262  */
263
264 static char *create_socket_name (char *standard_name, char *template);
265 static gnupg_fd_t create_server_socket (char *name, int is_ssh, 
266                                         assuan_sock_nonce_t *nonce);
267 static void create_directories (void);
268
269 static void agent_init_default_ctrl (ctrl_t ctrl);
270 static void agent_deinit_default_ctrl (ctrl_t ctrl);
271
272 static void handle_connections (gnupg_fd_t listen_fd,
273                                 gnupg_fd_t listen_fd_ssh);
274 static void check_own_socket (void);
275 static int check_for_running_agent (int silent, int mode);
276
277 /* Pth wrapper function definitions. */
278 ASSUAN_SYSTEM_PTH_IMPL;
279
280 GCRY_THREAD_OPTION_PTH_IMPL;
281 static int fixed_gcry_pth_init (void)
282 {
283   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
284 }
285
286
287 #ifndef PTH_HAVE_PTH_THREAD_ID
288 static unsigned long pth_thread_id (void)
289 {
290   return (unsigned long)pth_self ();
291 }
292 #endif
293
294
295 \f
296 /*
297    Functions. 
298  */
299
300 static char *
301 make_libversion (const char *libname, const char *(*getfnc)(const char*))
302 {
303   const char *s;
304   char *result;
305   
306   if (maybe_setuid)
307     {
308       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
309       maybe_setuid = 0;
310     }
311   s = getfnc (NULL);
312   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
313   strcpy (stpcpy (stpcpy (result, libname), " "), s);
314   return result;
315 }
316
317
318 static const char *
319 my_strusage (int level)
320 {
321   static char *ver_gcry;
322   const char *p;
323
324   switch (level)
325     {
326     case 11: p = "gpg-agent (GnuPG)";
327       break;
328     case 13: p = VERSION; break;
329     case 17: p = PRINTABLE_OS_NAME; break;
330       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
331          reporting address.  This is so that we can change the
332          reporting address without breaking the translations.  */
333     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
334
335     case 20:
336       if (!ver_gcry)
337         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
338       p = ver_gcry;
339       break;
340
341     case 1:
342     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
343       break;
344     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
345                     "Secret key management for GnuPG\n");
346     break;
347     
348     default: p = NULL;
349     }
350   return p;
351 }
352
353
354
355 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
356    only the active debug flags are propagated to the subsystems.  With
357    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
358    all flags already set. Note that we don't fail here, because it is
359    important to keep gpg-agent running even after re-reading the
360    options due to a SIGHUP. */
361 static void
362 set_debug (void)
363 {
364   int numok = (debug_level && digitp (debug_level));
365   int numlvl = numok? atoi (debug_level) : 0;
366
367   if (!debug_level)
368     ;
369   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
370     opt.debug = 0;
371   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
372     opt.debug = DBG_ASSUAN_VALUE;
373   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
374     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
375   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
376     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
377                  |DBG_CACHE_VALUE);
378   else if (!strcmp (debug_level, "guru") || numok)
379     {
380       opt.debug = ~0;
381       /* Unless the "guru" string has been used we don't want to allow
382          hashing debugging.  The rationale is that people tend to
383          select the highest debug value and would then clutter their
384          disk with debug files which may reveal confidential data.  */ 
385       if (numok)
386         opt.debug &= ~(DBG_HASHING_VALUE);
387     }
388   else
389     {
390       log_error (_("invalid debug-level `%s' given\n"), debug_level);
391       opt.debug = 0; /* Reset debugging, so that prior debug
392                         statements won't have an undesired effect. */
393     }
394
395   if (opt.debug && !opt.verbose)
396     opt.verbose = 1;
397   if (opt.debug && opt.quiet)
398     opt.quiet = 0;
399
400   if (opt.debug & DBG_MPI_VALUE)
401     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
402   if (opt.debug & DBG_CRYPTO_VALUE )
403     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
404   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
405
406   if (opt.debug)
407     log_info ("enabled debug flags:%s%s%s%s%s%s%s%s\n",
408               (opt.debug & DBG_COMMAND_VALUE)? " command":"",    
409               (opt.debug & DBG_MPI_VALUE    )? " mpi":"",    
410               (opt.debug & DBG_CRYPTO_VALUE )? " crypto":"",    
411               (opt.debug & DBG_MEMORY_VALUE )? " memory":"", 
412               (opt.debug & DBG_CACHE_VALUE  )? " cache":"", 
413               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"", 
414               (opt.debug & DBG_HASHING_VALUE)? " hashing":"", 
415               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"");
416 }
417  
418
419 /* Helper for cleanup to remove one socket with NAME.  */
420 static void
421 remove_socket (char *name)
422 {
423   if (name && *name)
424     {
425       char *p;
426
427       remove (name);
428       p = strrchr (name, '/');
429       if (p)
430         {
431           *p = 0;
432           rmdir (name);
433           *p = '/';
434         }
435       *name = 0;
436     }
437 }  
438
439 static void
440 cleanup (void)
441 {
442   remove_socket (socket_name);
443   remove_socket (socket_name_ssh);
444 }
445
446
447
448 /* Handle options which are allowed to be reset after program start.
449    Return true when the current option in PARGS could be handled and
450    false if not.  As a special feature, passing a value of NULL for
451    PARGS, resets the options to the default.  REREAD should be set
452    true if it is not the initial option parsing. */
453 static int
454 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
455 {
456   if (!pargs)
457     { /* reset mode */
458       opt.quiet = 0;
459       opt.verbose = 0;
460       opt.debug = 0;
461       opt.no_grab = 0;
462       opt.pinentry_program = NULL;
463       opt.pinentry_touch_file = NULL;
464       opt.scdaemon_program = NULL;
465       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
466       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
467       opt.max_cache_ttl = MAX_CACHE_TTL;
468       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
469       opt.enforce_passphrase_constraints = 0;
470       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
471       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
472       opt.check_passphrase_pattern = NULL;
473       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
474       opt.enable_passhrase_history = 0;
475       opt.ignore_cache_for_signing = 0;
476       opt.allow_mark_trusted = 0;
477       opt.disable_scdaemon = 0;
478       return 1;
479     }
480
481   switch (pargs->r_opt)
482     {
483     case oQuiet: opt.quiet = 1; break;
484     case oVerbose: opt.verbose++; break;
485
486     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
487     case oDebugAll: opt.debug = ~0; break;
488     case oDebugLevel: debug_level = pargs->r.ret_str; break;
489
490     case oLogFile:
491       if (!reread)
492         return 0; /* not handeld */
493       if (!current_logfile || !pargs->r.ret_str
494           || strcmp (current_logfile, pargs->r.ret_str))
495         {
496           log_set_file (pargs->r.ret_str);
497           if (DBG_ASSUAN)
498             assuan_set_assuan_log_stream (log_get_stream ());
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 ();
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_assuan_log_prefix (log_get_prefix (NULL));
620   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
621   assuan_set_system_hooks (ASSUAN_SYSTEM_PTH);
622   assuan_sock_init ();
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   if (DBG_ASSUAN)
950     assuan_set_assuan_log_stream (log_get_stream ());
951
952   /* Make sure that we have a default ttyname. */
953   if (!default_ttyname && ttyname (1))
954     default_ttyname = xstrdup (ttyname (1));
955   if (!default_ttytype && getenv ("TERM"))
956     default_ttytype = xstrdup (getenv ("TERM"));
957
958
959   if (pipe_server)
960     { 
961       /* This is the simple pipe based server */
962       ctrl_t ctrl;
963
964       ctrl = xtrycalloc (1, sizeof *ctrl);
965       if (!ctrl)
966         {
967           log_error ("error allocating connection control data: %s\n",
968                      strerror (errno) );
969           agent_exit (1);
970         }
971       ctrl->session_env = session_env_new ();
972       if (!ctrl->session_env)
973         {
974           log_error ("error allocating session environment block: %s\n",
975                      strerror (errno) );
976           xfree (ctrl);
977           agent_exit (1);
978         }
979       agent_init_default_ctrl (ctrl);
980       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
981       agent_deinit_default_ctrl (ctrl);
982       xfree (ctrl);
983     }
984   else if (!is_daemon)
985     ; /* NOTREACHED */
986   else
987     { /* Regular server mode */
988       gnupg_fd_t fd;
989       gnupg_fd_t fd_ssh;
990       pid_t pid;
991
992       /* Remove the DISPLAY variable so that a pinentry does not
993          default to a specific display.  There is still a default
994          display when gpg-agent was started using --display or a
995          client requested this using an OPTION command.  Note, that we
996          don't do this when running in reverse daemon mode (i.e. when
997          exec the program given as arguments). */
998 #ifndef HAVE_W32_SYSTEM
999       if (!opt.keep_display && !argc)
1000         unsetenv ("DISPLAY");
1001 #endif
1002
1003
1004       /* Create the sockets.  */
1005       socket_name = create_socket_name 
1006         ("S.gpg-agent", "/tmp/gpg-XXXXXX/S.gpg-agent");
1007       if (opt.ssh_support)
1008         socket_name_ssh = create_socket_name 
1009           ("S.gpg-agent.ssh", "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
1010
1011       fd = create_server_socket (socket_name, 0, &socket_nonce);
1012       if (opt.ssh_support)
1013         fd_ssh = create_server_socket (socket_name_ssh, 1, &socket_nonce_ssh);
1014       else
1015         fd_ssh = GNUPG_INVALID_FD;
1016
1017       /* If we are going to exec a program in the parent, we record
1018          the PID, so that the child may check whether the program is
1019          still alive. */
1020       if (argc)
1021         parent_pid = getpid ();
1022
1023       fflush (NULL);
1024 #ifdef HAVE_W32_SYSTEM
1025       pid = getpid ();
1026       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
1027 #else /*!HAVE_W32_SYSTEM*/
1028       pid = fork ();
1029       if (pid == (pid_t)-1) 
1030         {
1031           log_fatal ("fork failed: %s\n", strerror (errno) );
1032           exit (1);
1033         }
1034       else if (pid) 
1035         { /* We are the parent */
1036           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
1037
1038           /* Close the socket FD. */
1039           close (fd);
1040
1041           /* Note that we used a standard fork so that Pth runs in
1042              both the parent and the child.  The pth_fork would
1043              terminate Pth in the child but that is not the way we
1044              want it.  Thus we use a plain fork and terminate Pth here
1045              in the parent.  The pth_kill may or may not work reliable
1046              but it should not harm to call it.  Because Pth fiddles
1047              with the signal mask the signal mask might not be correct
1048              right now and thus we restore it.  That is not strictly
1049              necessary but some programs falsely assume a cleared
1050              signal mask.  */
1051           if ( !pth_kill () )
1052             log_error ("pth_kill failed in forked process\n");
1053             
1054 #ifdef HAVE_SIGPROCMASK
1055           if (startup_signal_mask_valid)
1056             {
1057               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1058                 log_error ("error restoring signal mask: %s\n",
1059                            strerror (errno));
1060             }
1061           else
1062             log_info ("no saved signal mask\n");
1063 #endif /*HAVE_SIGPROCMASK*/          
1064
1065           /* Create the info string: <name>:<pid>:<protocol_version> */
1066           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
1067                         socket_name, (ulong)pid ) < 0)
1068             {
1069               log_error ("out of core\n");
1070               kill (pid, SIGTERM);
1071               exit (1);
1072             }
1073           if (opt.ssh_support)
1074             {
1075               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1076                             socket_name_ssh) < 0)
1077                 {
1078                   log_error ("out of core\n");
1079                   kill (pid, SIGTERM);
1080                   exit (1);
1081                 }
1082               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
1083                             pid) < 0)
1084                 {
1085                   log_error ("out of core\n");
1086                   kill (pid, SIGTERM);
1087                   exit (1);
1088                 }
1089             }
1090
1091           *socket_name = 0; /* Don't let cleanup() remove the socket -
1092                                the child should do this from now on */
1093           if (opt.ssh_support)
1094             *socket_name_ssh = 0;
1095
1096           if (env_file_name)
1097             {
1098               FILE *fp;
1099               
1100               fp = fopen (env_file_name, "w");
1101               if (!fp)
1102                 log_error (_("error creating `%s': %s\n"),
1103                              env_file_name, strerror (errno));
1104               else
1105                 {
1106                   fputs (infostr, fp);
1107                   putc ('\n', fp);
1108                   if (opt.ssh_support)
1109                     {
1110                       fputs (infostr_ssh_sock, fp);
1111                       putc ('\n', fp);
1112                       fputs (infostr_ssh_pid, fp);
1113                       putc ('\n', fp);
1114                     }
1115                   fclose (fp);
1116                 }
1117             }
1118
1119
1120           if (argc) 
1121             { /* Run the program given on the commandline.  */
1122               if (putenv (infostr))
1123                 {
1124                   log_error ("failed to set environment: %s\n",
1125                              strerror (errno) );
1126                   kill (pid, SIGTERM );
1127                   exit (1);
1128                 }
1129               if (opt.ssh_support && putenv (infostr_ssh_sock))
1130                 {
1131                   log_error ("failed to set environment: %s\n",
1132                              strerror (errno) );
1133                   kill (pid, SIGTERM );
1134                   exit (1);
1135                 }
1136               if (opt.ssh_support && putenv (infostr_ssh_pid))
1137                 {
1138                   log_error ("failed to set environment: %s\n",
1139                              strerror (errno) );
1140                   kill (pid, SIGTERM );
1141                   exit (1);
1142                 }
1143
1144               /* Close all the file descriptors except the standard
1145                  ones and those open at startup.  We explicitly don't
1146                  close 0,1,2 in case something went wrong collecting
1147                  them at startup.  */
1148               close_all_fds (3, startup_fd_list);
1149
1150               /* Run the command.  */
1151               execvp (argv[0], argv);
1152               log_error ("failed to run the command: %s\n", strerror (errno));
1153               kill (pid, SIGTERM);
1154               exit (1);
1155             }
1156           else
1157             {
1158               /* Print the environment string, so that the caller can use
1159                  shell's eval to set it */
1160               if (csh_style)
1161                 {
1162                   *strchr (infostr, '=') = ' ';
1163                   printf ("setenv %s\n", infostr);
1164                   if (opt.ssh_support)
1165                     {
1166                       *strchr (infostr_ssh_sock, '=') = ' ';
1167                       printf ("setenv %s\n", infostr_ssh_sock);
1168                       *strchr (infostr_ssh_pid, '=') = ' ';
1169                       printf ("setenv %s\n", infostr_ssh_pid);
1170                     }
1171                 }
1172               else
1173                 {
1174                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1175                   if (opt.ssh_support)
1176                     {
1177                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
1178                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
1179                     }
1180                 }
1181               xfree (infostr); 
1182               if (opt.ssh_support)
1183                 {
1184                   xfree (infostr_ssh_sock);
1185                   xfree (infostr_ssh_pid);
1186                 }
1187               exit (0); 
1188             }
1189           /*NOTREACHED*/
1190         } /* End parent */
1191
1192       /* 
1193          This is the child
1194        */
1195
1196       /* Detach from tty and put process into a new session */
1197       if (!nodetach )
1198         { 
1199           int i;
1200           unsigned int oldflags;
1201
1202           /* Close stdin, stdout and stderr unless it is the log stream */
1203           for (i=0; i <= 2; i++) 
1204             {
1205               if (!log_test_fd (i) && i != fd )
1206                 {
1207                   if ( ! close (i)
1208                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1209                     {
1210                       log_error ("failed to open `%s': %s\n",
1211                                  "/dev/null", strerror (errno));
1212                       cleanup ();
1213                       exit (1);
1214                     }
1215                 }
1216             }
1217           if (setsid() == -1)
1218             {
1219               log_error ("setsid() failed: %s\n", strerror(errno) );
1220               cleanup ();
1221               exit (1);
1222             }
1223
1224           log_get_prefix (&oldflags);
1225           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1226           opt.running_detached = 1;
1227         }
1228
1229       if (chdir("/"))
1230         {
1231           log_error ("chdir to / failed: %s\n", strerror (errno));
1232           exit (1);
1233         }
1234
1235       {
1236         struct sigaction sa;
1237         
1238         sa.sa_handler = SIG_IGN;
1239         sigemptyset (&sa.sa_mask);
1240         sa.sa_flags = 0;
1241         sigaction (SIGPIPE, &sa, NULL);
1242       }
1243 #endif /*!HAVE_W32_SYSTEM*/
1244
1245       log_info ("%s %s started\n", strusage(11), strusage(13) );
1246       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1247       assuan_sock_close (fd);
1248     }
1249   
1250   return 0;
1251 }
1252
1253
1254 void
1255 agent_exit (int rc)
1256 {
1257   /*FIXME: update_random_seed_file();*/
1258 #if 1
1259   /* at this time a bit annoying */
1260   if (opt.debug & DBG_MEMSTAT_VALUE)
1261     {
1262       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1263       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1264     }
1265   if (opt.debug)
1266     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1267 #endif
1268   gcry_control (GCRYCTL_TERM_SECMEM );
1269   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1270   exit (rc);
1271 }
1272
1273
1274 static void
1275 agent_init_default_ctrl (ctrl_t ctrl)
1276 {
1277   /* Note we ignore malloc errors because we can't do much about it
1278      and the request will fail anyway shortly after this
1279      initialization. */
1280   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1281   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1282   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1283   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1284   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1285   
1286   if (ctrl->lc_ctype)
1287     xfree (ctrl->lc_ctype);
1288   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1289   
1290   if (ctrl->lc_messages)
1291     xfree (ctrl->lc_messages);
1292   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1293                                     /**/ : NULL;
1294
1295 }
1296
1297
1298 static void
1299 agent_deinit_default_ctrl (ctrl_t ctrl)
1300 {
1301   session_env_release (ctrl->session_env);
1302
1303   if (ctrl->lc_ctype)
1304     xfree (ctrl->lc_ctype);
1305   if (ctrl->lc_messages)
1306     xfree (ctrl->lc_messages);
1307 }
1308
1309
1310 /* Reread parts of the configuration.  Note, that this function is
1311    obviously not thread-safe and should only be called from the PTH
1312    signal handler. 
1313
1314    Fixme: Due to the way the argument parsing works, we create a
1315    memory leak here for all string type arguments.  There is currently
1316    no clean way to tell whether the memory for the argument has been
1317    allocated or points into the process' original arguments.  Unless
1318    we have a mechanism to tell this, we need to live on with this. */
1319 static void
1320 reread_configuration (void)
1321 {
1322   ARGPARSE_ARGS pargs;
1323   FILE *fp;
1324   unsigned int configlineno = 0;
1325   int dummy;
1326
1327   if (!config_filename)
1328     return; /* No config file. */
1329
1330   fp = fopen (config_filename, "r");
1331   if (!fp)
1332     {
1333       log_error (_("option file `%s': %s\n"),
1334                  config_filename, strerror(errno) );
1335       return;
1336     }
1337
1338   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1339
1340   memset (&pargs, 0, sizeof pargs);
1341   dummy = 0;
1342   pargs.argc = &dummy;
1343   pargs.flags = 1;  /* do not remove the args */
1344   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1345     {
1346       if (pargs.r_opt < -1)
1347         pargs.err = 1; /* Print a warning. */
1348       else /* Try to parse this option - ignore unchangeable ones. */
1349         parse_rereadable_options (&pargs, 1);
1350     }
1351   fclose (fp);
1352   set_debug ();
1353 }
1354
1355
1356 /* Return the file name of the socket we are using for native
1357    requests.  */
1358 const char *
1359 get_agent_socket_name (void)
1360 {
1361   const char *s = socket_name;
1362
1363   return (s && *s)? s : NULL;
1364 }
1365
1366 /* Return the file name of the socket we are using for SSH
1367    requests.  */
1368 const char *
1369 get_agent_ssh_socket_name (void)
1370 {
1371   const char *s = socket_name_ssh;
1372
1373   return (s && *s)? s : NULL;
1374 }
1375
1376
1377 /* Under W32, this function returns the handle of the scdaemon
1378    notification event.  Calling it the first time creates that
1379    event.  */
1380 #ifdef HAVE_W32_SYSTEM
1381 void *
1382 get_agent_scd_notify_event (void)
1383 {
1384   static HANDLE the_event;
1385
1386   if (!the_event)
1387     {
1388       HANDLE h, h2;
1389       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1390
1391       /* We need to use manual reset evet object due to the way our
1392          w32-pth wait function works: If we would use an automatic
1393          reset event we are not able to figure out which handle has
1394          been signaled because at the time we single out the signaled
1395          handles using WFSO the event has already been reset due to
1396          the WFMO.  */
1397       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1398       if (!h)
1399         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1400       else if (!DuplicateHandle (GetCurrentProcess(), h,
1401                                  GetCurrentProcess(), &h2,
1402                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0)) 
1403         {
1404           log_error ("setting syncronize for scd notify event failed: %s\n",
1405                      w32_strerror (-1) );
1406           CloseHandle (h);
1407         }
1408       else
1409         {
1410           CloseHandle (h);
1411           the_event = h2;
1412         }
1413     }
1414
1415   log_debug  ("returning notify handle %p\n", the_event);
1416   return the_event;
1417 }
1418 #endif /*HAVE_W32_SYSTEM*/
1419
1420
1421
1422 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1423    true using STANDARD_NAME in the home directory or if given as
1424    false from the mkdir type name TEMPLATE.  In the latter case a
1425    unique name in a unique new directory will be created.  In both
1426    cases check for valid characters as well as against a maximum
1427    allowed length for a unix domain socket is done.  The function
1428    terminates the process in case of an error.  Returns: Pointer to an
1429    allocated string with the absolute name of the socket used.  */
1430 static char *
1431 create_socket_name (char *standard_name, char *template)
1432 {
1433   char *name, *p;
1434
1435   if (use_standard_socket)
1436     name = make_filename (opt.homedir, standard_name, NULL);
1437   else
1438     {
1439       name = xstrdup (template);
1440       p = strrchr (name, '/');
1441       if (!p)
1442         BUG ();
1443       *p = 0;
1444       if (!mkdtemp (name))
1445         {
1446           log_error (_("can't create directory `%s': %s\n"),
1447                      name, strerror (errno));
1448           agent_exit (2);
1449         }
1450       *p = '/';
1451     }
1452
1453   if (strchr (name, PATHSEP_C))
1454     {
1455       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1456       agent_exit (2);
1457     }
1458   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1459     {
1460       log_error (_("name of socket too long\n"));
1461       agent_exit (2);
1462     }
1463   return name;
1464 }
1465
1466
1467
1468 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1469    or terminates the process in case of an error.  Not that this
1470    function needs to be used for the regular socket first and only
1471    then for the ssh socket.  */
1472 static gnupg_fd_t
1473 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1474 {
1475   struct sockaddr_un *serv_addr;
1476   socklen_t len;
1477   gnupg_fd_t fd;
1478   int rc;
1479
1480   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1481   if (fd == ASSUAN_INVALID_FD)
1482     {
1483       log_error (_("can't create socket: %s\n"), strerror (errno));
1484       agent_exit (2);
1485     }
1486
1487   serv_addr = xmalloc (sizeof (*serv_addr)); 
1488   memset (serv_addr, 0, sizeof *serv_addr);
1489   serv_addr->sun_family = AF_UNIX;
1490   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1491     {
1492       log_error (_("socket name `%s' is too long\n"), name);
1493       agent_exit (2);
1494     }
1495   strcpy (serv_addr->sun_path, name);
1496   len = SUN_LEN (serv_addr);
1497   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1498   if (use_standard_socket && rc == -1 && errno == EADDRINUSE)
1499     {
1500       /* Check whether a gpg-agent is already running on the standard
1501          socket.  We do this test only if this is not the ssh socket.
1502          For ssh we assume that a test for gpg-agent has already been
1503          done and reuse the requested ssh socket.  Testing the
1504          ssh-socket is not possible because at this point, though we
1505          know the new Assuan socket, the Assuan server and thus the
1506          ssh-agent server is not yet operational.  This would lead to
1507          a hang.  */
1508       if (!is_ssh && !check_for_running_agent (1, 1))
1509         {
1510           log_error (_("a gpg-agent is already running - "
1511                        "not starting a new one\n"));
1512           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1513           assuan_sock_close (fd);
1514           agent_exit (2);
1515         }
1516       remove (name);
1517       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1518     }
1519   if (rc != -1 
1520       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1521     log_error (_("error getting nonce for the socket\n"));
1522   if (rc == -1)
1523     {
1524       /* We use gpg_strerror here because it allows us to get strings
1525          for some W32 socket error codes.  */
1526       log_error (_("error binding socket to `%s': %s\n"),
1527                  serv_addr->sun_path, 
1528                  gpg_strerror (gpg_error_from_errno (errno)));
1529       
1530       assuan_sock_close (fd);
1531       if (use_standard_socket)
1532         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1533       agent_exit (2);
1534     }
1535
1536   if (listen (FD2INT(fd), 5 ) == -1)
1537     {
1538       log_error (_("listen() failed: %s\n"), strerror (errno));
1539       assuan_sock_close (fd);
1540       agent_exit (2);
1541     }
1542           
1543   if (opt.verbose)
1544     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1545
1546   return fd;
1547 }
1548
1549
1550 /* Check that the directory for storing the private keys exists and
1551    create it if not.  This function won't fail as it is only a
1552    convenience function and not strictly necessary.  */
1553 static void
1554 create_private_keys_directory (const char *home)
1555 {
1556   char *fname;
1557   struct stat statbuf;
1558
1559   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1560   if (stat (fname, &statbuf) && errno == ENOENT)
1561     {
1562 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1563       if (!CreateDirectory (fname, NULL))
1564         log_error (_("can't create directory `%s': %s\n"),
1565                    fname, w32_strerror (-1) );
1566 #else
1567       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1568         log_error (_("can't create directory `%s': %s\n"),
1569                    fname, strerror (errno) );
1570 #endif
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 #ifdef HAVE_W32_SYSTEM
1608               if (!CreateDirectory (home, NULL))
1609                 log_error (_("can't create directory `%s': %s\n"),
1610                            home, w32_strerror (-1) );
1611 #else
1612               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1613                 log_error (_("can't create directory `%s': %s\n"),
1614                            home, strerror (errno) );
1615 #endif
1616               else 
1617                 {
1618                   if (!opt.quiet)
1619                     log_info (_("directory `%s' created\n"), home);
1620                   create_private_keys_directory (home);
1621                 }
1622             }
1623         }
1624       else
1625         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1626     }
1627   else if ( !S_ISDIR(statbuf.st_mode))
1628     {
1629       log_error (_("can't use `%s' as home directory\n"), home);
1630     }
1631   else /* exists and is a directory. */
1632     {
1633       create_private_keys_directory (home);
1634     }
1635   xfree (home);
1636 }
1637
1638
1639
1640 /* This is the worker for the ticker.  It is called every few seconds
1641    and may only do fast operations. */
1642 static void
1643 handle_tick (void)
1644 {
1645   static time_t last_minute;
1646
1647   if (!last_minute)
1648     last_minute = time (NULL);
1649
1650   /* Check whether the scdaemon has died and cleanup in this case. */
1651   agent_scd_check_aliveness ();
1652
1653   /* If we are running as a child of another process, check whether
1654      the parent is still alive and shutdown if not. */
1655 #ifndef HAVE_W32_SYSTEM
1656   if (parent_pid != (pid_t)(-1))
1657     {
1658       if (kill (parent_pid, 0))
1659         {
1660           shutdown_pending = 2;
1661           log_info ("parent process died - shutting down\n");
1662           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1663           cleanup ();
1664           agent_exit (0);
1665         }
1666     }
1667 #endif /*HAVE_W32_SYSTEM*/
1668   
1669   /* Code to be run every minute.  */
1670   if (last_minute + 60 <= time (NULL))
1671     {
1672       check_own_socket ();
1673       last_minute = time (NULL);
1674     }
1675
1676 }
1677
1678
1679 /* A global function which allows us to call the reload stuff from
1680    other places too.  This is only used when build for W32.  */
1681 void
1682 agent_sighup_action (void)
1683 {
1684   log_info ("SIGHUP received - "
1685             "re-reading configuration and flushing cache\n");
1686   agent_flush_cache ();
1687   reread_configuration ();
1688   agent_reload_trustlist ();
1689 }
1690
1691
1692 static void
1693 agent_sigusr2_action (void)
1694 {
1695   if (opt.verbose)
1696     log_info ("SIGUSR2 received - updating card event counter\n");
1697   /* Nothing to check right now.  We only increment a counter.  */
1698   bump_card_eventcounter ();
1699 }
1700
1701
1702 static void
1703 handle_signal (int signo)
1704 {
1705   switch (signo)
1706     {
1707 #ifndef HAVE_W32_SYSTEM
1708     case SIGHUP:
1709       agent_sighup_action ();
1710       break;
1711       
1712     case SIGUSR1:
1713       log_info ("SIGUSR1 received - printing internal information:\n");
1714       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1715       agent_query_dump_state ();
1716       agent_scd_dump_state ();
1717       break;
1718       
1719     case SIGUSR2:
1720       agent_sigusr2_action ();
1721       break;
1722
1723     case SIGTERM:
1724       if (!shutdown_pending)
1725         log_info ("SIGTERM received - shutting down ...\n");
1726       else
1727         log_info ("SIGTERM received - still %ld running threads\n",
1728                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1729       shutdown_pending++;
1730       if (shutdown_pending > 2)
1731         {
1732           log_info ("shutdown forced\n");
1733           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1734           cleanup ();
1735           agent_exit (0);
1736         }
1737       break;
1738         
1739     case SIGINT:
1740       log_info ("SIGINT received - immediate shutdown\n");
1741       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1742       cleanup ();
1743       agent_exit (0);
1744       break;
1745 #endif
1746     default:
1747       log_info ("signal %d received - no action defined\n", signo);
1748     }
1749 }
1750
1751
1752 /* Check the nonce on a new connection.  This is a NOP unless we we
1753    are using our Unix domain socket emulation under Windows.  */
1754 static int 
1755 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1756 {
1757   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1758     {
1759       log_info (_("error reading nonce on fd %d: %s\n"), 
1760                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1761       assuan_sock_close (ctrl->thread_startup.fd);
1762       xfree (ctrl);
1763       return -1;
1764     }
1765   else
1766     return 0;
1767 }
1768
1769
1770 /* This is the standard connection thread's main function.  */
1771 static void *
1772 start_connection_thread (void *arg)
1773 {
1774   ctrl_t ctrl = arg;
1775
1776   if (check_nonce (ctrl, &socket_nonce))
1777     return NULL;
1778
1779   agent_init_default_ctrl (ctrl);
1780   if (opt.verbose)
1781     log_info (_("handler 0x%lx for fd %d started\n"), 
1782               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1783
1784   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1785   if (opt.verbose)
1786     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1787               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1788   
1789   agent_deinit_default_ctrl (ctrl);
1790   xfree (ctrl);
1791   return NULL;
1792 }
1793
1794
1795 /* This is the ssh connection thread's main function.  */
1796 static void *
1797 start_connection_thread_ssh (void *arg)
1798 {
1799   ctrl_t ctrl = arg;
1800
1801   if (check_nonce (ctrl, &socket_nonce_ssh))
1802     return NULL;
1803
1804   agent_init_default_ctrl (ctrl);
1805   if (opt.verbose)
1806     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1807               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1808
1809   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1810   if (opt.verbose)
1811     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1812               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1813   
1814   agent_deinit_default_ctrl (ctrl);
1815   xfree (ctrl);
1816   return NULL;
1817 }
1818
1819
1820 /* Connection handler loop.  Wait for connection requests and spawn a
1821    thread after accepting a connection.  */
1822 static void
1823 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1824 {
1825   pth_attr_t tattr;
1826   pth_event_t ev, time_ev;
1827   sigset_t sigs;
1828   int signo;
1829   struct sockaddr_un paddr;
1830   socklen_t plen;
1831   fd_set fdset, read_fdset;
1832   int ret;
1833   gnupg_fd_t fd;
1834   int nfd;
1835
1836   tattr = pth_attr_new();
1837   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1838   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1839
1840 #ifndef HAVE_W32_SYSTEM /* fixme */
1841   /* Make sure that the signals we are going to handle are not blocked
1842      and create an event object for them.  We also set the default
1843      action to ignore because we use an Pth event to get notified
1844      about signals.  This avoids that the default action is taken in
1845      case soemthing goes wrong within Pth.  The problem might also be
1846      a Pth bug.  */
1847   sigemptyset (&sigs );
1848   {
1849     static const int mysigs[] = { SIGHUP, SIGUSR1, SIGUSR2, SIGINT, SIGTERM };
1850     struct sigaction sa;
1851     int i;
1852
1853     for (i=0; i < DIM (mysigs); i++)
1854       {
1855         sigemptyset (&sa.sa_mask);
1856         sa.sa_handler = SIG_IGN;
1857         sa.sa_flags = 0;
1858         sigaction (mysigs[i], &sa, NULL);
1859         
1860         sigaddset (&sigs, mysigs[i]);
1861       }
1862   }
1863
1864   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1865   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1866 #else
1867 # ifdef PTH_EVENT_HANDLE
1868   sigs = 0;
1869   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1870   signo = 0;
1871 # else
1872   /* Use a dummy event. */
1873   sigs = 0;
1874   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1875 # endif
1876 #endif
1877   time_ev = NULL;
1878
1879   FD_ZERO (&fdset);
1880   FD_SET (FD2INT (listen_fd), &fdset);
1881   nfd = FD2INT (listen_fd);
1882   if (listen_fd_ssh != GNUPG_INVALID_FD)
1883     {
1884       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1885       if (FD2INT (listen_fd_ssh) > nfd)
1886         nfd = FD2INT (listen_fd_ssh);
1887     }
1888
1889   for (;;)
1890     {
1891       /* Make sure that our signals are not blocked.  */
1892       pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1893
1894       /* Shutdown test.  */
1895       if (shutdown_pending)
1896         {
1897           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1898             break; /* ready */
1899
1900           /* Do not accept new connections but keep on running the
1901              loop to cope with the timer events.  */
1902           FD_ZERO (&fdset);
1903         }
1904
1905       /* Create a timeout event if needed.  To help with power saving
1906          we syncronize the ticks to the next full second.  */
1907       if (!time_ev)
1908         {
1909           pth_time_t nexttick;
1910
1911           nexttick = pth_timeout (TIMERTICK_INTERVAL, 0);
1912           if (nexttick.tv_usec > 10)  /* Use a 10 usec threshhold.  */
1913             {
1914               nexttick.tv_sec++;
1915               nexttick.tv_usec = 0;
1916             }
1917           time_ev = pth_event (PTH_EVENT_TIME, nexttick);
1918         }
1919
1920       /* POSIX says that fd_set should be implemented as a structure,
1921          thus a simple assignment is fine to copy the entire set.  */
1922       read_fdset = fdset;
1923
1924       if (time_ev)
1925         pth_event_concat (ev, time_ev, NULL);
1926       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1927       if (time_ev)
1928         pth_event_isolate (time_ev);
1929
1930       if (ret == -1)
1931         {
1932           if (pth_event_occurred (ev)
1933               || (time_ev && pth_event_occurred (time_ev)))
1934             {
1935               if (pth_event_occurred (ev))
1936                 {
1937 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1938                   agent_sigusr2_action ();
1939 #else
1940                   handle_signal (signo);
1941 #endif
1942                 }
1943               if (time_ev && pth_event_occurred (time_ev))
1944                 {
1945                   pth_event_free (time_ev, PTH_FREE_ALL);
1946                   time_ev = NULL;
1947                   handle_tick ();
1948                 }
1949               continue;
1950             }
1951           log_error (_("pth_select failed: %s - waiting 1s\n"),
1952                      strerror (errno));
1953           pth_sleep (1);
1954           continue;
1955         }
1956
1957       if (pth_event_occurred (ev))
1958         {
1959 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1960           agent_sigusr2_action ();
1961 #else
1962           handle_signal (signo);
1963 #endif
1964         }
1965
1966       if (time_ev && pth_event_occurred (time_ev))
1967         {
1968           pth_event_free (time_ev, PTH_FREE_ALL);
1969           time_ev = NULL;
1970           handle_tick ();
1971         }
1972
1973
1974       /* We now might create new threads and because we don't want any
1975          signals (as we are handling them here) to be delivered to a
1976          new thread.  Thus we need to block those signals. */
1977       pth_sigmask (SIG_BLOCK, &sigs, NULL);
1978
1979       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
1980         {
1981           ctrl_t ctrl;
1982
1983           plen = sizeof paddr;
1984           fd = INT2FD (pth_accept (FD2INT(listen_fd),
1985                                    (struct sockaddr *)&paddr, &plen));
1986           if (fd == GNUPG_INVALID_FD)
1987             {
1988               log_error ("accept failed: %s\n", strerror (errno));
1989             }
1990           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1991             {
1992               log_error ("error allocating connection control data: %s\n",
1993                          strerror (errno) );
1994               assuan_sock_close (fd);
1995             }
1996           else if ( !(ctrl->session_env = session_env_new ()) )
1997             {
1998               log_error ("error allocating session environment block: %s\n",
1999                          strerror (errno) );
2000               xfree (ctrl);
2001               assuan_sock_close (fd);
2002             }
2003           else 
2004             {
2005               char threadname[50];
2006
2007               snprintf (threadname, sizeof threadname-1,
2008                         "conn fd=%d (gpg)", FD2INT(fd));
2009               threadname[sizeof threadname -1] = 0;
2010               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2011               ctrl->thread_startup.fd = fd;
2012               if (!pth_spawn (tattr, start_connection_thread, ctrl))
2013                 {
2014                   log_error ("error spawning connection handler: %s\n",
2015                              strerror (errno) );
2016                   assuan_sock_close (fd);
2017                   xfree (ctrl);
2018                 }
2019             }
2020           fd = GNUPG_INVALID_FD;
2021         }
2022
2023       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD 
2024           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2025         {
2026           ctrl_t ctrl;
2027
2028           plen = sizeof paddr;
2029           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
2030                                   (struct sockaddr *)&paddr, &plen));
2031           if (fd == GNUPG_INVALID_FD)
2032             {
2033               log_error ("accept failed for ssh: %s\n", strerror (errno));
2034             }
2035           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2036             {
2037               log_error ("error allocating connection control data: %s\n",
2038                          strerror (errno) );
2039               assuan_sock_close (fd);
2040             }
2041           else if ( !(ctrl->session_env = session_env_new ()) )
2042             {
2043               log_error ("error allocating session environment block: %s\n",
2044                          strerror (errno) );
2045               xfree (ctrl);
2046               assuan_sock_close (fd);
2047             }
2048           else
2049             {
2050               char threadname[50];
2051
2052               agent_init_default_ctrl (ctrl);
2053               snprintf (threadname, sizeof threadname-1,
2054                         "conn fd=%d (ssh)", FD2INT(fd));
2055               threadname[sizeof threadname -1] = 0;
2056               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2057               ctrl->thread_startup.fd = fd;
2058               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
2059                 {
2060                   log_error ("error spawning ssh connection handler: %s\n",
2061                              strerror (errno) );
2062                   assuan_sock_close (fd);
2063                   xfree (ctrl);
2064                 }
2065             }
2066           fd = GNUPG_INVALID_FD;
2067         }
2068     }
2069
2070   pth_event_free (ev, PTH_FREE_ALL);
2071   if (time_ev)
2072     pth_event_free (time_ev, PTH_FREE_ALL);
2073   cleanup ();
2074   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2075 }
2076
2077
2078
2079 /* Helper for check_own_socket.  */
2080 static gpg_error_t
2081 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2082 {
2083   membuf_t *mb = opaque;
2084   put_membuf (mb, buffer, length);
2085   return 0;
2086 }
2087
2088
2089 /* The thread running the actual check.  We need to run this in a
2090    separate thread so that check_own_thread can be called from the
2091    timer tick.  */
2092 static void *
2093 check_own_socket_thread (void *arg)
2094 {
2095   int rc;
2096   char *sockname = arg;
2097   assuan_context_t ctx = NULL;
2098   membuf_t mb;
2099   char *buffer;
2100
2101   check_own_socket_running++;
2102
2103   rc = assuan_new (&ctx);
2104   xfree (sockname);
2105   if (rc)
2106     {
2107       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2108       goto leave;
2109     }
2110
2111   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2112   if (rc)
2113     {
2114       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2115       goto leave;
2116     }
2117  
2118   init_membuf (&mb, 100);
2119   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2120                         NULL, NULL, NULL, NULL);
2121   put_membuf (&mb, "", 1);
2122   buffer = get_membuf (&mb, NULL);
2123   if (rc || !buffer)
2124     {
2125       log_error ("sending command \"%s\" to my own socket failed: %s\n", 
2126                  "GETINFO pid", gpg_strerror (rc));
2127       rc = 1;
2128     }
2129   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2130     {
2131       log_error ("socket is now serviced by another server\n");
2132       rc = 1;
2133     }
2134   else if (opt.verbose > 1)
2135     log_error ("socket is still served by this server\n");
2136     
2137   xfree (buffer);
2138
2139  leave:
2140   if (ctx)
2141     assuan_release (ctx);
2142   if (rc)
2143     {
2144       /* We may not remove the socket as it is now in use by another
2145          server.  Setting the name to empty does this.  */
2146       if (socket_name)
2147         *socket_name = 0;
2148       if (socket_name_ssh)
2149         *socket_name_ssh = 0;
2150       shutdown_pending = 2;
2151       log_info ("this process is useless - shutting down\n");
2152     }
2153   check_own_socket_running--;
2154   return NULL;
2155 }
2156
2157
2158 /* Check whether we are still listening on our own socket.  In case
2159    another gpg-agent process started after us has taken ownership of
2160    our socket, we woul linger around without any real taks.  Thus we
2161    better check once in a while whether we are really needed.  */
2162 static void
2163 check_own_socket (void)
2164 {
2165   char *sockname;
2166   pth_attr_t tattr;
2167
2168   if (!use_standard_socket)
2169     return; /* This check makes only sense in standard socket mode.  */
2170
2171   if (check_own_socket_running || shutdown_pending)
2172     return;  /* Still running or already shutting down.  */
2173
2174   sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
2175   if (!sockname)
2176     return; /* Out of memory.  */
2177
2178   tattr = pth_attr_new();
2179   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
2180   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
2181   pth_attr_set (tattr, PTH_ATTR_NAME, "check-own-socket");
2182
2183   if (!pth_spawn (tattr, check_own_socket_thread, sockname))
2184       log_error ("error spawning check_own_socket_thread: %s\n",
2185                  strerror (errno) );
2186   pth_attr_destroy (tattr);
2187 }
2188
2189
2190
2191 /* Figure out whether an agent is available and running. Prints an
2192    error if not.  If SILENT is true, no messages are printed.  Usually
2193    started with MODE 0.  Returns 0 if the agent is running. */
2194 static int
2195 check_for_running_agent (int silent, int mode)
2196 {
2197   int rc;
2198   char *infostr, *p;
2199   assuan_context_t ctx = NULL;
2200   int prot, pid;
2201
2202   if (!mode)
2203     {
2204       infostr = getenv ("GPG_AGENT_INFO");
2205       if (!infostr || !*infostr)
2206         {
2207           if (!check_for_running_agent (silent, 1))
2208             return 0; /* Okay, its running on the standard socket. */
2209           if (!silent)
2210             log_error (_("no gpg-agent running in this session\n"));
2211           return -1;
2212         }
2213
2214       infostr = xstrdup (infostr);
2215       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2216         {
2217           xfree (infostr);
2218           if (!check_for_running_agent (silent, 1))
2219             return 0; /* Okay, its running on the standard socket. */
2220           if (!silent)
2221             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
2222           return -1;
2223         }
2224
2225       *p++ = 0;
2226       pid = atoi (p);
2227       while (*p && *p != PATHSEP_C)
2228         p++;
2229       prot = *p? atoi (p+1) : 0;
2230       if (prot != 1)
2231         {
2232           xfree (infostr);
2233           if (!silent)
2234             log_error (_("gpg-agent protocol version %d is not supported\n"),
2235                        prot);
2236           if (!check_for_running_agent (silent, 1))
2237             return 0; /* Okay, its running on the standard socket. */
2238           return -1;
2239         }
2240     }
2241   else /* MODE != 0 */
2242     {
2243       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
2244       pid = (pid_t)(-1);
2245     }
2246
2247   rc = assuan_new (&ctx);
2248   if (! rc)
2249     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2250   xfree (infostr);
2251   if (rc)
2252     {
2253       if (!mode && !check_for_running_agent (silent, 1))
2254         return 0; /* Okay, its running on the standard socket. */
2255
2256       if (!mode && !silent)
2257         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2258
2259       if (ctx)
2260         assuan_release (ctx);
2261       return -1;
2262     }
2263
2264   if (!opt.quiet && !silent)
2265     log_info ("gpg-agent running and available\n");
2266
2267   assuan_release (ctx);
2268   return 0;
2269 }