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