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