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