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