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