* gpg-agent.c (handle_connections): Need to check for events if
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  *      Copyright (C) 2000, 2001, 2002, 2003, 2004,
3  *                    2005 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 2 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stddef.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <assert.h>
31 #include <time.h>
32 #include <fcntl.h>
33 #include <sys/stat.h>
34 #ifndef HAVE_W32_SYSTEM
35 #include <sys/socket.h>
36 #include <sys/un.h>
37 #endif /*HAVE_W32_SYSTEM*/
38 #include <unistd.h>
39 #include <signal.h>
40 #ifdef USE_GNU_PTH
41 # include <pth.h>
42 #endif
43
44 #define JNLIB_NEED_LOG_LOGV
45 #include "agent.h"
46 #include <assuan.h> /* Malloc hooks */
47
48 #include "i18n.h"
49 #include "sysutils.h"
50 #ifdef HAVE_W32_SYSTEM
51 #include "../jnlib/w32-afunix.h"
52 #endif
53
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   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   oDisplay,
81   oTTYname,
82   oTTYtype,
83   oLCctype,
84   oLCmessages,
85   oScdaemonProgram,
86   oDisablePth,
87   oDefCacheTTL,
88   oMaxCacheTTL,
89   oUseStandardSocket,
90   oNoUseStandardSocket,
91
92   oIgnoreCacheForSigning,
93   oAllowMarkTrusted,
94   oAllowPresetPassphrase,
95   oKeepTTY,
96   oKeepDISPLAY,
97   oSSHSupport
98 };
99
100
101
102 static ARGPARSE_OPTS opts[] = {
103
104   { aGPGConfList, "gpgconf-list", 256, "@" },
105   
106   { 301, NULL, 0, N_("@Options:\n ") },
107
108   { oServer,   "server",     0, N_("run in server mode (foreground)") },
109   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
110   { oVerbose, "verbose",     0, N_("verbose") },
111   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
112   { oSh,        "sh",        0, N_("sh-style command output") },
113   { oCsh,       "csh",       0, N_("csh-style command output") },
114   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
115   { oDebug,     "debug"     ,4|16, "@"},
116   { oDebugAll, "debug-all"     ,0, "@"},
117   { oDebugLevel, "debug-level" ,2, "@"},
118   { oDebugWait,"debug-wait",1, "@"},
119   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
120   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
121   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
122   { oDisablePth, "disable-pth", 0, N_("do not allow multiple connections")},
123   { oUseStandardSocket, "use-standard-socket", 0,
124                       N_("use a standard location for the socket")},
125   { oNoUseStandardSocket, "no-use-standard-socket", 0, "@"},
126
127   { oPinentryProgram, "pinentry-program", 2 ,
128                                N_("|PGM|use PGM as the PIN-Entry program") },
129   { oScdaemonProgram, "scdaemon-program", 2 ,
130                                N_("|PGM|use PGM as the SCdaemon program") },
131
132   { oDisplay,    "display",     2, "@" },
133   { oTTYname,    "ttyname",     2, "@" },
134   { oTTYtype,    "ttytype",     2, "@" },
135   { oLCctype,    "lc-ctype",    2, "@" },
136   { oLCmessages, "lc-messages", 2, "@" },
137   { oKeepTTY, "keep-tty", 0,  N_("ignore requests to change the TTY")},
138   { oKeepDISPLAY, "keep-display",
139                           0, N_("ignore requests to change the X display")},
140
141   { oDefCacheTTL, "default-cache-ttl", 4,
142                                N_("|N|expire cached PINs after N seconds")},
143   { oMaxCacheTTL, "max-cache-ttl", 4, "@" },
144   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
145                                N_("do not use the PIN cache when signing")},
146   { oAllowMarkTrusted, "allow-mark-trusted", 0,
147                              N_("allow clients to mark keys as \"trusted\"")},
148   { oAllowPresetPassphrase, "allow-preset-passphrase", 0,
149                              N_("allow presetting passphrase")},
150   { oSSHSupport, "enable-ssh-support", 0, N_("enable ssh-agent emulation") },
151   {0}
152 };
153
154
155 #define DEFAULT_CACHE_TTL (10*60)  /* 10 minutes */
156 #define MAX_CACHE_TTL     (120*60) /* 2 hours */
157
158 static volatile int caught_fatal_sig = 0;
159
160 /* flag to indicate that a shutdown was requested */
161 static int shutdown_pending;
162
163
164 /* It is possible that we are currently running under setuid permissions */
165 static int maybe_setuid = 1;
166
167 /* Name of the communication socket used for native gpg-agent requests.  */
168 static char *socket_name;
169
170 /* Name of the communication socket used for ssh-agent-emulation.  */
171 static char *socket_name_ssh;
172
173 /* Default values for options passed to the pinentry. */
174 static char *default_display;
175 static char *default_ttyname;
176 static char *default_ttytype;
177 static char *default_lc_ctype;
178 static char *default_lc_messages;
179
180 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
181 static char *config_filename;
182
183 /* Helper to implement --debug-level */
184 static const char *debug_level;
185
186 /* Keep track of the current log file so that we can avoid updating
187    the log file after a SIGHUP if it didn't changed. Malloced. */
188 static char *current_logfile;
189
190 /*
191    Local prototypes. 
192  */
193
194 static char *create_socket_name (int use_standard_socket,
195                                  char *standard_name, char *template);
196 static int create_server_socket (int is_standard_name, const char *name);
197 static void create_directories (void);
198
199 #ifdef USE_GNU_PTH
200 static void handle_connections (int listen_fd, int listen_fd_ssh);
201 /* Pth wrapper function definitions. */
202 GCRY_THREAD_OPTION_PTH_IMPL;
203 #endif /*USE_GNU_PTH*/
204
205 static int check_for_running_agent (int);
206
207
208
209
210 /*
211    Functions. 
212  */
213
214
215 static const char *
216 my_strusage (int level)
217 {
218   const char *p;
219   switch (level)
220     {
221     case 11: p = "gpg-agent (GnuPG)";
222       break;
223     case 13: p = VERSION; break;
224     case 17: p = PRINTABLE_OS_NAME; break;
225     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
226       break;
227     case 1:
228     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
229       break;
230     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
231                     "Secret key management for GnuPG\n");
232     break;
233     
234     default: p = NULL;
235     }
236   return p;
237 }
238
239
240
241 static void
242 i18n_init (void)
243 {
244 #ifdef USE_SIMPLE_GETTEXT
245     set_gettext_file( PACKAGE_GT );
246 #else
247 #ifdef ENABLE_NLS
248     setlocale (LC_ALL, "");
249     bindtextdomain (PACKAGE_GT, LOCALEDIR);
250     textdomain (PACKAGE_GT);
251 #endif
252 #endif
253 }
254
255
256
257 /* Used by gcry for logging */
258 static void
259 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
260 {
261   /* translate the log levels */
262   switch (level)
263     {
264     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
265     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
266     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
267     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
268     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
269     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
270     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
271     default:            level = JNLIB_LOG_ERROR; break;  
272     }
273   log_logv (level, fmt, arg_ptr);
274 }
275
276
277 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
278    only the active debug flags are propagated to the subsystems.  With
279    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
280    all flags already set. Note that we don't fail here, because it is
281    important to keep gpg-agent running even after re-reading the
282    options due to a SIGHUP. */
283 static void
284 set_debug (void)
285 {
286   if (!debug_level)
287     ;
288   else if (!strcmp (debug_level, "none"))
289     opt.debug = 0;
290   else if (!strcmp (debug_level, "basic"))
291     opt.debug = DBG_ASSUAN_VALUE;
292   else if (!strcmp (debug_level, "advanced"))
293     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
294   else if (!strcmp (debug_level, "expert"))
295     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
296                  |DBG_CACHE_VALUE);
297   else if (!strcmp (debug_level, "guru"))
298     opt.debug = ~0;
299   else
300     {
301       log_error (_("invalid debug-level `%s' given\n"), debug_level);
302       opt.debug = 0; /* Reset debugging, so that prior debug
303                         statements won't have an undesired effect. */
304     }
305
306   if (opt.debug && !opt.verbose)
307     opt.verbose = 1;
308   if (opt.debug && opt.quiet)
309     opt.quiet = 0;
310
311   if (opt.debug & DBG_MPI_VALUE)
312     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
313   if (opt.debug & DBG_CRYPTO_VALUE )
314     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
315   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
316 }
317  
318
319 /* Helper for cleanup to remove one socket with NAME.  */
320 static void
321 remove_socket (char *name)
322 {
323   if (name && *name)
324     {
325       char *p;
326
327       remove (name);
328       p = strrchr (name, '/');
329       if (p)
330         {
331           *p = 0;
332           rmdir (name);
333           *p = '/';
334         }
335       *name = 0;
336     }
337 }  
338
339 static void
340 cleanup (void)
341 {
342   remove_socket (socket_name);
343   remove_socket (socket_name_ssh);
344 }
345
346
347 static RETSIGTYPE
348 cleanup_sh (int sig)
349 {
350   if (caught_fatal_sig)
351     raise (sig);
352   caught_fatal_sig = 1;
353
354   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
355   cleanup ();
356
357 #ifndef HAVE_DOSISH_SYSTEM
358   {     /* reset action to default action and raise signal again */
359     struct sigaction nact;
360     nact.sa_handler = SIG_DFL;
361     sigemptyset( &nact.sa_mask );
362     nact.sa_flags = 0;
363     sigaction( sig, &nact, NULL);
364   }
365 #endif
366   raise( sig );
367 }
368
369
370 /* Handle options which are allowed to be reset after program start.
371    Return true when the current option in PARGS could be handled and
372    false if not.  As a special feature, passing a value of NULL for
373    PARGS, resets the options to the default.  REREAD should be set
374    true if it is not the initial option parsing. */
375 static int
376 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
377 {
378   if (!pargs)
379     { /* reset mode */
380       opt.quiet = 0;
381       opt.verbose = 0;
382       opt.debug = 0;
383       opt.no_grab = 0;
384       opt.pinentry_program = NULL;
385       opt.scdaemon_program = NULL;
386       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
387       opt.max_cache_ttl = MAX_CACHE_TTL;
388       opt.ignore_cache_for_signing = 0;
389       opt.allow_mark_trusted = 0;
390       return 1;
391     }
392
393   switch (pargs->r_opt)
394     {
395     case oQuiet: opt.quiet = 1; break;
396     case oVerbose: opt.verbose++; break;
397
398     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
399     case oDebugAll: opt.debug = ~0; break;
400     case oDebugLevel: debug_level = pargs->r.ret_str; break;
401
402     case oLogFile:
403       if (!reread)
404         return 0; /* not handeld */
405       if (!current_logfile || !pargs->r.ret_str
406           || strcmp (current_logfile, pargs->r.ret_str))
407         {
408           log_set_file (pargs->r.ret_str);
409           xfree (current_logfile);
410           current_logfile = xtrystrdup (pargs->r.ret_str);
411         }
412       break;
413
414     case oNoGrab: opt.no_grab = 1; break;
415       
416     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
417     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
418
419     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
420     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
421       
422     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
423
424     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
425
426     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
427
428     default:
429       return 0; /* not handled */
430     }
431   return 1; /* handled */
432 }
433
434
435 int
436 main (int argc, char **argv )
437 {
438   ARGPARSE_ARGS pargs;
439   int orig_argc;
440   int may_coredump;
441   char **orig_argv;
442   FILE *configfp = NULL;
443   char *configname = NULL;
444   const char *shell;
445   unsigned configlineno;
446   int parse_debug = 0;
447   int default_config =1;
448   int greeting = 0;
449   int nogreeting = 0;
450   int pipe_server = 0;
451   int is_daemon = 0;
452   int nodetach = 0;
453   int csh_style = 0;
454   char *logfile = NULL;
455   int debug_wait = 0;
456   int disable_pth = 0;
457   int gpgconf_list = 0;
458   int standard_socket = 0;
459   gpg_error_t err;
460
461   set_strusage (my_strusage);
462   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
463   /* Please note that we may running SUID(ROOT), so be very CAREFUL
464      when adding any stuff between here and the call to INIT_SECMEM()
465      somewhere after the option parsing */
466   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID); 
467
468   /* Try to auto set the character set.  */
469   set_native_charset (NULL); 
470
471   i18n_init ();
472
473   /* Libgcrypt requires us to register the threading model first.
474      Note that this will also do the pth_init. */
475 #ifdef USE_GNU_PTH
476   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
477   if (err)
478     {
479       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
480                  gpg_strerror (err));
481     }
482 #endif /*USE_GNU_PTH*/
483
484
485   /* Check that the libraries are suitable.  Do it here because
486      the option parsing may need services of the library. */
487   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
488     {
489       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
490                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
491     }
492
493   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
494   assuan_set_assuan_log_stream (log_get_stream ());
495   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
496
497   gcry_set_log_handler (my_gcry_logger, NULL);
498   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
499
500   may_coredump = disable_core_dumps ();
501
502   /* Set default options.  */
503   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
504 #ifdef HAVE_W32_SYSTEM
505   standard_socket = 1;  /* Under Windows we always use a standard
506                            socket.  */
507 #endif
508   
509   shell = getenv ("SHELL");
510   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
511     csh_style = 1;
512
513   opt.homedir = default_homedir ();
514
515   /* Record the some original Denvironment settings. */
516   opt.startup_display = getenv ("DISPLAY");
517   if (opt.startup_display)
518     opt.startup_display = xstrdup (opt.startup_display);
519   opt.startup_ttyname = ttyname (0);
520   if (opt.startup_ttyname)
521     opt.startup_ttyname = xstrdup (opt.startup_ttyname);
522   opt.startup_ttytype = getenv ("TERM");
523   if (opt.startup_ttytype)
524     opt.startup_ttytype = xstrdup (opt.startup_ttytype);
525   /* Fixme: Neen to use the locale fucntion here.  */
526   opt.startup_lc_ctype = getenv ("LC_CTYPE");
527   if (opt.startup_lc_ctype) 
528     opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
529   opt.startup_lc_messages = getenv ("LC_MESSAGES");
530   if (opt.startup_lc_messages)
531     opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
532
533   /* Check whether we have a config file on the commandline */
534   orig_argc = argc;
535   orig_argv = argv;
536   pargs.argc = &argc;
537   pargs.argv = &argv;
538   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
539   while (arg_parse( &pargs, opts))
540     {
541       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
542         parse_debug++;
543       else if (pargs.r_opt == oOptions)
544         { /* yes there is one, so we do not try the default one, but
545              read the option file when it is encountered at the
546              commandline */
547           default_config = 0;
548         }
549         else if (pargs.r_opt == oNoOptions)
550           default_config = 0; /* --no-options */
551         else if (pargs.r_opt == oHomedir)
552           opt.homedir = pargs.r.ret_str;
553     }
554
555   /* initialize the secure memory. */
556   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
557   maybe_setuid = 0;
558
559   /* 
560      Now we are now working under our real uid 
561   */
562
563   if (default_config)
564     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
565   
566   argc = orig_argc;
567   argv = orig_argv;
568   pargs.argc = &argc;
569   pargs.argv = &argv;
570   pargs.flags=  1;  /* do not remove the args */
571  next_pass:
572   if (configname)
573     {
574       configlineno = 0;
575       configfp = fopen (configname, "r");
576       if (!configfp)
577         {
578           if (default_config)
579             {
580               if( parse_debug )
581                 log_info (_("NOTE: no default option file `%s'\n"),
582                           configname );
583             }
584           else
585             {
586               log_error (_("option file `%s': %s\n"),
587                          configname, strerror(errno) );
588               exit(2);
589             }
590           xfree (configname); 
591           configname = NULL;
592         }
593       if (parse_debug && configname )
594         log_info (_("reading options from `%s'\n"), configname );
595       default_config = 0;
596     }
597
598   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
599     {
600       if (parse_rereadable_options (&pargs, 0))
601         continue; /* Already handled */
602       switch (pargs.r_opt)
603         {
604         case aGPGConfList: gpgconf_list = 1; break;
605         case oBatch: opt.batch=1; break;
606
607         case oDebugWait: debug_wait = pargs.r.ret_int; break;
608
609         case oOptions:
610           /* config files may not be nested (silently ignore them) */
611           if (!configfp)
612             {
613                 xfree(configname);
614                 configname = xstrdup(pargs.r.ret_str);
615                 goto next_pass;
616             }
617           break;
618         case oNoGreeting: nogreeting = 1; break;
619         case oNoVerbose: opt.verbose = 0; break;
620         case oNoOptions: break; /* no-options */
621         case oHomedir: opt.homedir = pargs.r.ret_str; break;
622         case oNoDetach: nodetach = 1; break;
623         case oLogFile: logfile = pargs.r.ret_str; break;
624         case oCsh: csh_style = 1; break;
625         case oSh: csh_style = 0; break;
626         case oServer: pipe_server = 1; break;
627         case oDaemon: is_daemon = 1; break;
628         case oDisablePth: disable_pth = 1; break;
629
630         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
631         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
632         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
633         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
634         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
635           break;
636
637         case oUseStandardSocket: standard_socket = 1; break;
638         case oNoUseStandardSocket: standard_socket = 0; break;
639
640         case oKeepTTY: opt.keep_tty = 1; break;
641         case oKeepDISPLAY: opt.keep_display = 1; break;
642
643         case oSSHSupport:  opt.ssh_support = 1; break;
644
645         default : pargs.err = configfp? 1:2; break;
646         }
647     }
648   if (configfp)
649     {
650       fclose( configfp );
651       configfp = NULL;
652       /* Keep a copy of the name so that it can be read on SIGHUP. */
653       config_filename = configname;
654       configname = NULL;
655       goto next_pass;
656     }
657   xfree (configname);
658   configname = NULL;
659   if (log_get_errorcount(0))
660     exit(2);
661   if (nogreeting )
662     greeting = 0;
663
664   if (greeting)
665     {
666       fprintf (stderr, "%s %s; %s\n",
667                  strusage(11), strusage(13), strusage(14) );
668       fprintf (stderr, "%s\n", strusage(15) );
669     }
670 #ifdef IS_DEVELOPMENT_VERSION
671   /* We don't want to print it here because gpg-agent is useful of its
672      own and quite matured.  */
673   /*log_info ("NOTE: this is a development version!\n");*/
674 #endif
675
676   set_debug ();
677   
678   if (atexit (cleanup))
679     {
680       log_error ("atexit failed\n");
681       cleanup ();
682       exit (1);
683     }
684
685   initialize_module_query ();
686   initialize_module_call_scd ();
687   
688   /* Try to create missing directories. */
689   create_directories ();
690
691   if (debug_wait && pipe_server)
692     {
693       log_debug ("waiting for debugger - my pid is %u .....\n",
694                  (unsigned int)getpid());
695       sleep (debug_wait);
696       log_debug ("... okay\n");
697     }
698   
699   if (gpgconf_list)
700     {
701       char *filename;
702
703       /* List options and default values in the GPG Conf format.  */
704
705       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
706       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
707          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
708 #define GC_OPT_FLAG_NONE        0UL
709       /* The RUNTIME flag for an option indicates that the option can be
710          changed at runtime.  */
711 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
712       /* The DEFAULT flag for an option indicates that the option has a
713          default value.  */
714 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
715       /* The DEF_DESC flag for an option indicates that the option has a
716          default, which is described by the value of the default field.  */
717 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
718       /* The NO_ARG_DESC flag for an option indicates that the argument has
719          a default, which is described by the value of the ARGDEF field.  */
720 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
721
722       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
723       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
724               GC_OPT_FLAG_DEFAULT, filename);
725       xfree (filename);
726
727       printf ("verbose:%lu:\n"
728               "quiet:%lu:\n"
729               "debug-level:%lu:\"none:\n"
730               "log-file:%lu:\n",
731               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
732               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
733               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
734               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
735       printf ("default-cache-ttl:%lu:%d:\n",
736               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
737       printf ("no-grab:%lu:\n", 
738               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
739       printf ("ignore-cache-for-signing:%lu:\n",
740               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
741       printf ("allow-mark-trusted:%lu:\n",
742               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
743
744       agent_exit (0);
745     }
746
747   /* If this has been called without any options, we merely check
748      whether an agent is already running.  We do this here so that we
749      don't clobber a logfile but print it directly to stderr. */
750   if (!pipe_server && !is_daemon)
751     {
752       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
753       check_for_running_agent (0);
754       agent_exit (0);
755     }
756   
757 #ifdef ENABLE_NLS
758   /* gpg-agent usually does not output any messages because it runs in
759      the background.  For log files it is acceptable to have messages
760      always encoded in utf-8.  We switch here to utf-8, so that
761      commands like --help still give native messages.  It is far
762      easier to switch only once instead of for every message and it
763      actually helps when more then one thread is active (avoids an
764      extra copy step). */
765     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
766 #endif
767
768   /* Now start with logging to a file if this is desired. */
769   if (logfile)
770     {
771       log_set_file (logfile);
772       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
773                              |JNLIB_LOG_WITH_TIME
774                              |JNLIB_LOG_WITH_PID));
775       current_logfile = xstrdup (logfile);
776     }
777
778   /* Make sure that we have a default ttyname. */
779   if (!default_ttyname && ttyname (1))
780     default_ttyname = xstrdup (ttyname (1));
781   if (!default_ttytype && getenv ("TERM"))
782     default_ttytype = xstrdup (getenv ("TERM"));
783
784
785   if (pipe_server)
786     { /* this is the simple pipe based server */
787       start_command_handler (-1, -1);
788     }
789   else if (!is_daemon)
790     ; /* NOTREACHED */
791   else
792     { /* Regular server mode */
793       int fd;
794       int fd_ssh;
795       pid_t pid;
796
797       /* Remove the DISPLAY variable so that a pinentry does not
798          default to a specific display.  There is still a default
799          display when gpg-agent was started using --display or a
800          client requested this using an OPTION command. */
801 #ifndef HAVE_W32_SYSTEM
802       if (!opt.keep_display)
803         unsetenv ("DISPLAY");
804 #endif
805
806
807       /* Create the sockets.  */
808       socket_name = create_socket_name (standard_socket,
809                                         "S.gpg-agent",
810                                         "/tmp/gpg-XXXXXX/S.gpg-agent");
811       if (opt.ssh_support)
812         socket_name_ssh = create_socket_name (standard_socket, 
813                                             "S.gpg-agent.ssh",
814                                             "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
815
816       fd = create_server_socket (standard_socket, socket_name);
817       if (opt.ssh_support)
818         fd_ssh = create_server_socket (standard_socket, socket_name_ssh);
819       else
820         fd_ssh = -1;
821
822
823       fflush (NULL);
824 #ifdef HAVE_W32_SYSTEM
825       pid = getpid ();
826       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
827 #else /*!HAVE_W32_SYSTEM*/
828       pid = fork ();
829       if (pid == (pid_t)-1) 
830         {
831           log_fatal ("fork failed: %s\n", strerror (errno) );
832           exit (1);
833         }
834       else if (pid) 
835         { /* We are the parent */
836           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
837           
838           close (fd);
839           
840           /* Create the info string: <name>:<pid>:<protocol_version> */
841           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
842                         socket_name, (ulong)pid ) < 0)
843             {
844               log_error ("out of core\n");
845               kill (pid, SIGTERM);
846               exit (1);
847             }
848           if (opt.ssh_support)
849             {
850               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
851                             socket_name_ssh) < 0)
852                 {
853                   log_error ("out of core\n");
854                   kill (pid, SIGTERM);
855                   exit (1);
856                 }
857               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
858                             pid) < 0)
859                 {
860                   log_error ("out of core\n");
861                   kill (pid, SIGTERM);
862                   exit (1);
863                 }
864             }
865
866           *socket_name = 0; /* Don't let cleanup() remove the socket -
867                                the child should do this from now on */
868           if (opt.ssh_support)
869             *socket_name_ssh = 0;
870
871
872           if (argc) 
873             { /* Run the program given on the commandline.  */
874               if (putenv (infostr))
875                 {
876                   log_error ("failed to set environment: %s\n",
877                              strerror (errno) );
878                   kill (pid, SIGTERM );
879                   exit (1);
880                 }
881               if (putenv (infostr_ssh_sock))
882                 {
883                   log_error ("failed to set environment: %s\n",
884                              strerror (errno) );
885                   kill (pid, SIGTERM );
886                   exit (1);
887                 }
888               if (putenv (infostr_ssh_pid))
889                 {
890                   log_error ("failed to set environment: %s\n",
891                              strerror (errno) );
892                   kill (pid, SIGTERM );
893                   exit (1);
894                 }
895               execvp (argv[0], argv);
896               log_error ("failed to run the command: %s\n", strerror (errno));
897               kill (pid, SIGTERM);
898               exit (1);
899             }
900           else
901             {
902               /* Print the environment string, so that the caller can use
903                  shell's eval to set it */
904               if (csh_style)
905                 {
906                   *strchr (infostr, '=') = ' ';
907                   printf ("setenv %s\n", infostr);
908                   if (opt.ssh_support)
909                     {
910                       *strchr (infostr_ssh_sock, '=') = ' ';
911                       printf ("setenv %s\n", infostr_ssh_sock);
912                       *strchr (infostr_ssh_pid, '=') = ' ';
913                       printf ("setenv %s\n", infostr_ssh_pid);
914                     }
915                 }
916               else
917                 {
918                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
919                   if (opt.ssh_support)
920                     {
921                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
922                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
923                     }
924                 }
925               /* Note: teh standard free is here correct.  */
926               free (infostr);
927               if (opt.ssh_support)
928                 {
929                   free (infostr_ssh_sock);
930                   free (infostr_ssh_pid);
931                 }
932               exit (0); 
933             }
934           /*NOTREACHED*/
935         } /* End parent */
936
937       /* 
938          This is the child
939        */
940
941       /* Detach from tty and put process into a new session */
942       if (!nodetach )
943         { 
944           int i;
945           unsigned int oldflags;
946
947           /* Close stdin, stdout and stderr unless it is the log stream */
948           for (i=0; i <= 2; i++) 
949             {
950               if (!log_test_fd (i) && i != fd )
951                 close (i);
952             }
953           if (setsid() == -1)
954             {
955               log_error ("setsid() failed: %s\n", strerror(errno) );
956               cleanup ();
957               exit (1);
958             }
959
960           log_get_prefix (&oldflags);
961           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
962           opt.running_detached = 1;
963         }
964
965       if (chdir("/"))
966         {
967           log_error ("chdir to / failed: %s\n", strerror (errno));
968           exit (1);
969         }
970
971 #endif /*!HAVE_W32_SYSTEM*/
972
973
974 #ifdef USE_GNU_PTH
975       if (!disable_pth)
976         {
977 #ifndef HAVE_W32_SYSTEM  /* FIXME */
978           struct sigaction sa;
979
980           sa.sa_handler = SIG_IGN;
981           sigemptyset (&sa.sa_mask);
982           sa.sa_flags = 0;
983           sigaction (SIGPIPE, &sa, NULL);
984 #endif
985           handle_connections (fd, opt.ssh_support ? fd_ssh : -1);
986         }
987       else
988 #endif /*!USE_GNU_PTH*/
989       /* setup signals */
990         {
991 #ifndef HAVE_W32_SYSTEM  /* FIXME */
992           struct sigaction oact, nact;
993           
994           nact.sa_handler = cleanup_sh;
995           sigemptyset (&nact.sa_mask);
996           nact.sa_flags = 0;
997           
998           sigaction (SIGHUP, NULL, &oact);
999           if (oact.sa_handler != SIG_IGN)
1000             sigaction (SIGHUP, &nact, NULL);
1001           sigaction( SIGTERM, NULL, &oact );
1002           if (oact.sa_handler != SIG_IGN)
1003             sigaction (SIGTERM, &nact, NULL);
1004           nact.sa_handler = SIG_IGN;
1005           sigaction (SIGPIPE, &nact, NULL);
1006           sigaction (SIGINT, &nact, NULL);
1007 #endif
1008           start_command_handler (fd, -1);
1009         }
1010       close (fd);
1011     }
1012   
1013   return 0;
1014 }
1015
1016 void
1017 agent_exit (int rc)
1018 {
1019   /*FIXME: update_random_seed_file();*/
1020 #if 1
1021   /* at this time a bit annoying */
1022   if (opt.debug & DBG_MEMSTAT_VALUE)
1023     {
1024       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1025       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1026     }
1027   if (opt.debug)
1028     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1029 #endif
1030   gcry_control (GCRYCTL_TERM_SECMEM );
1031   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1032   exit (rc);
1033 }
1034
1035
1036 void
1037 agent_init_default_ctrl (struct server_control_s *ctrl)
1038 {
1039   ctrl->connection_fd = -1;
1040
1041   /* Note we ignore malloc errors because we can't do much about it
1042      and the request will fail anyway shortly after this
1043      initialization. */
1044   if (ctrl->display)
1045     free (ctrl->display);
1046   ctrl->display = default_display? strdup (default_display) : NULL;
1047
1048   if (ctrl->ttyname)
1049     free (ctrl->ttyname);
1050   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
1051
1052   if (ctrl->ttytype)
1053     free (ctrl->ttytype);
1054   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1055
1056   if (ctrl->lc_ctype)
1057     free (ctrl->lc_ctype);
1058   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1059
1060   if (ctrl->lc_messages)
1061     free (ctrl->lc_messages);
1062   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1063 }
1064
1065
1066 /* Reread parts of the configuration.  Note, that this function is
1067    obviously not thread-safe and should only be called from the PTH
1068    signal handler. 
1069
1070    Fixme: Due to the way the argument parsing works, we create a
1071    memory leak here for all string type arguments.  There is currently
1072    no clean way to tell whether the memory for the argument has been
1073    allocated or points into the process' original arguments.  Unless
1074    we have a mechanism to tell this, we need to live on with this. */
1075 static void
1076 reread_configuration (void)
1077 {
1078   ARGPARSE_ARGS pargs;
1079   FILE *fp;
1080   unsigned int configlineno = 0;
1081   int dummy;
1082
1083   if (!config_filename)
1084     return; /* No config file. */
1085
1086   fp = fopen (config_filename, "r");
1087   if (!fp)
1088     {
1089       log_error (_("option file `%s': %s\n"),
1090                  config_filename, strerror(errno) );
1091       return;
1092     }
1093
1094   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1095
1096   memset (&pargs, 0, sizeof pargs);
1097   dummy = 0;
1098   pargs.argc = &dummy;
1099   pargs.flags = 1;  /* do not remove the args */
1100   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1101     {
1102       if (pargs.r_opt < -1)
1103         pargs.err = 1; /* Print a warning. */
1104       else /* Try to parse this option - ignore unchangeable ones. */
1105         parse_rereadable_options (&pargs, 1);
1106     }
1107   fclose (fp);
1108   set_debug ();
1109 }
1110
1111
1112
1113
1114 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1115    true ising STANDARD_NAME in the home directory or if given has
1116    false from the mkdir type name TEMPLATE.  In the latter case a
1117    unique name in a unique new directory will be created.  In both
1118    cases check for valid characters as well as against a maximum
1119    allowed length for a unix domain socket is done.  The function
1120    terminates the process in case of an error.  Retunrs: Pointer to an
1121    allcoated string with the absolute name of the socket used.  */
1122 static char *
1123 create_socket_name (int use_standard_socket,
1124                     char *standard_name, char *template)
1125 {
1126   char *name, *p;
1127
1128   if (use_standard_socket)
1129     name = make_filename (opt.homedir, standard_name, NULL);
1130   else
1131     {
1132       name = xstrdup (template);
1133       p = strrchr (name, '/');
1134       if (!p)
1135         BUG ();
1136       *p = 0;
1137       if (!mkdtemp (name))
1138         {
1139           log_error (_("can't create directory `%s': %s\n"),
1140                      name, strerror (errno));
1141           agent_exit (2);
1142         }
1143       *p = '/';
1144     }
1145
1146   if (strchr (name, PATHSEP_C))
1147     {
1148       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1149       agent_exit (2);
1150     }
1151   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1152     {
1153       log_error (_("name of socket too long\n"));
1154       agent_exit (2);
1155     }
1156   return name;
1157 }
1158
1159
1160
1161 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1162    whether a non-random socket is used.  Returns the filedescriptor or
1163    terminates the process in case of an error. */
1164 static int
1165 create_server_socket (int is_standard_name, const char *name)
1166 {
1167   struct sockaddr_un *serv_addr;
1168   socklen_t len;
1169   int fd;
1170   int rc;
1171
1172 #ifdef HAVE_W32_SYSTEM
1173   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
1174 #else
1175   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1176 #endif
1177   if (fd == -1)
1178     {
1179       log_error (_("can't create socket: %s\n"), strerror (errno));
1180       agent_exit (2);
1181     }
1182
1183   serv_addr = malloc (sizeof (*serv_addr)); /* FIXME. */
1184   memset (serv_addr, 0, sizeof *serv_addr);
1185   serv_addr->sun_family = AF_UNIX;
1186   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
1187   strcpy (serv_addr->sun_path, name);
1188   len = (offsetof (struct sockaddr_un, sun_path)
1189          + strlen (serv_addr->sun_path) + 1);
1190
1191 #ifdef HAVE_W32_SYSTEM
1192   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1193   if (is_standard_name && rc == -1 )
1194     {
1195       remove (name);
1196       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1197     }
1198 #else
1199   rc = bind (fd, (struct sockaddr*) serv_addr, len);
1200   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1201     {
1202       remove (name);
1203       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1204     }
1205 #endif
1206   if (rc == -1)
1207     {
1208       log_error (_("error binding socket to `%s': %s\n"),
1209                  serv_addr->sun_path, strerror (errno));
1210       close (fd);
1211       agent_exit (2);
1212     }
1213
1214   if (listen (fd, 5 ) == -1)
1215     {
1216       log_error (_("listen() failed: %s\n"), strerror (errno));
1217       close (fd);
1218       agent_exit (2);
1219     }
1220           
1221   if (opt.verbose)
1222     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1223
1224   return fd;
1225 }
1226
1227
1228 /* Check that the directory for storing the private keys exists and
1229    create it if not.  This function won't fail as it is only a
1230    convenience function and not strictly necessary.  */
1231 static void
1232 create_private_keys_directory (const char *home)
1233 {
1234   char *fname;
1235   struct stat statbuf;
1236
1237   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1238   if (stat (fname, &statbuf) && errno == ENOENT)
1239     {
1240 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1241       if (!CreateDirectory (fname, NULL))
1242         log_error (_("can't create directory `%s': %s\n"),
1243                    fname, w32_strerror (-1) );
1244 #else
1245       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1246         log_error (_("can't create directory `%s': %s\n"),
1247                    fname, strerror (errno) );
1248 #endif
1249       else if (!opt.quiet)
1250         log_info (_("directory `%s' created\n"), fname);
1251     }
1252   xfree (fname);
1253 }
1254
1255 /* Create the directory only if the supplied directory name is the
1256    same as the default one.  This way we avoid to create arbitrary
1257    directories when a non-default home directory is used.  To cope
1258    with HOME, we compare only the suffix if we see that the default
1259    homedir does start with a tilde.  We don't stop here in case of
1260    problems because other functions will throw an error anyway.*/
1261 static void
1262 create_directories (void)
1263 {
1264   struct stat statbuf;
1265   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1266   char *home;
1267
1268   home = make_filename (opt.homedir, NULL);
1269   if ( stat (home, &statbuf) )
1270     {
1271       if (errno == ENOENT)
1272         {
1273           if ( (*defhome == '~'
1274                 && (strlen (home) >= strlen (defhome+1)
1275                     && !strcmp (home + strlen(home)
1276                                 - strlen (defhome+1), defhome+1)))
1277                || (*defhome != '~' && !strcmp (home, defhome) )
1278                )
1279             {
1280 #ifdef HAVE_W32_SYSTEM
1281               if (!CreateDirectory (home, NULL))
1282                 log_error (_("can't create directory `%s': %s\n"),
1283                            home, w32_strerror (-1) );
1284 #else
1285               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1286                 log_error (_("can't create directory `%s': %s\n"),
1287                            home, strerror (errno) );
1288 #endif
1289               else 
1290                 {
1291                   if (!opt.quiet)
1292                     log_info (_("directory `%s' created\n"), home);
1293                   create_private_keys_directory (home);
1294                 }
1295             }
1296         }
1297       else
1298         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1299     }
1300   else if ( !S_ISDIR(statbuf.st_mode))
1301     {
1302       log_error (_("can't use `%s' as home directory\n"), home);
1303     }
1304   else /* exists and is a directory. */
1305     {
1306       create_private_keys_directory (home);
1307     }
1308   xfree (home);
1309 }
1310
1311
1312
1313 #ifdef USE_GNU_PTH
1314 static void
1315 handle_signal (int signo)
1316 {
1317   switch (signo)
1318     {
1319 #ifndef HAVE_W32_SYSTEM
1320     case SIGHUP:
1321       log_info ("SIGHUP received - "
1322                 "re-reading configuration and flushing cache\n");
1323       agent_flush_cache ();
1324       reread_configuration ();
1325       agent_reload_trustlist ();
1326       break;
1327       
1328     case SIGUSR1:
1329       log_info ("SIGUSR1 received - no action defined\n");
1330       break;
1331       
1332     case SIGUSR2:
1333       log_info ("SIGUSR2 received - checking smartcard status\n");
1334       break;
1335
1336     case SIGTERM:
1337       if (!shutdown_pending)
1338         log_info ("SIGTERM received - shutting down ...\n");
1339       else
1340         log_info ("SIGTERM received - still %ld running threads\n",
1341                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1342       shutdown_pending++;
1343       if (shutdown_pending > 2)
1344         {
1345           log_info ("shutdown forced\n");
1346           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1347           cleanup ();
1348           agent_exit (0);
1349         }
1350       break;
1351         
1352     case SIGINT:
1353       log_info ("SIGINT received - immediate shutdown\n");
1354       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1355       cleanup ();
1356       agent_exit (0);
1357       break;
1358 #endif
1359     default:
1360       log_info ("signal %d received - no action defined\n", signo);
1361     }
1362 }
1363
1364
1365 /* This is the standard connection thread's main function.  */
1366 static void *
1367 start_connection_thread (void *arg)
1368 {
1369   int fd = (int)arg;
1370
1371   if (opt.verbose)
1372     log_info (_("handler for fd %d started\n"), fd);
1373
1374   /* FIXME: Move this housekeeping into a ticker function.  Calling it
1375      for each connection should work but won't work anymore if our
1376      clients start to keep connections. */
1377   agent_trustlist_housekeeping ();
1378
1379   start_command_handler (-1, fd);
1380   if (opt.verbose)
1381     log_info (_("handler for fd %d terminated\n"), fd);
1382   
1383   return NULL;
1384 }
1385
1386
1387 /* This is the ssh connection thread's main function.  */
1388 static void *
1389 start_connection_thread_ssh (void *arg)
1390 {
1391   int fd = (int)arg;
1392
1393   if (opt.verbose)
1394     log_info (_("ssh handler for fd %d started\n"), fd);
1395
1396   agent_trustlist_housekeeping ();
1397
1398   start_command_handler_ssh (fd);
1399   if (opt.verbose)
1400     log_info (_("ssh handler for fd %d terminated\n"), fd);
1401   
1402   return NULL;
1403 }
1404
1405
1406 /* Connection handler loop.  Wait for coecntion requests and spawn a
1407    thread after accepting a connection.  */
1408 static void
1409 handle_connections (int listen_fd, int listen_fd_ssh)
1410 {
1411   pth_attr_t tattr;
1412   pth_event_t ev;
1413   sigset_t sigs;
1414   int signo;
1415   struct sockaddr_un paddr;
1416   socklen_t plen;
1417   fd_set fdset, read_fdset;
1418   int ret;
1419   int fd;
1420
1421   tattr = pth_attr_new();
1422   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1423   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1424   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1425
1426 #ifndef HAVE_W32_SYSTEM /* fixme */
1427   sigemptyset (&sigs );
1428   sigaddset (&sigs, SIGHUP);
1429   sigaddset (&sigs, SIGUSR1);
1430   sigaddset (&sigs, SIGUSR2);
1431   sigaddset (&sigs, SIGINT);
1432   sigaddset (&sigs, SIGTERM);
1433   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1434 #else
1435   ev = NULL;
1436 #endif
1437
1438   FD_ZERO (&fdset);
1439   FD_SET (listen_fd, &fdset);
1440   if (listen_fd_ssh != -1)
1441     FD_SET (listen_fd_ssh, &fdset);
1442
1443   for (;;)
1444     {
1445       if (shutdown_pending)
1446         {
1447           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1448             break; /* ready */
1449
1450           /* Do not accept anymore connections and wait for existing
1451              connections to terminate */
1452           signo = 0;
1453           pth_wait (ev);
1454           if (pth_event_occurred (ev) && signo)
1455             handle_signal (signo);
1456           continue;
1457         }
1458
1459       /* POSIX says that fd_set should be implemented as a structure,
1460          thus a simple assignment is fine to copy the entire set.  */
1461       read_fdset = fdset;
1462
1463       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1464       if (ret == -1)
1465         {
1466           if (pth_event_occurred (ev))
1467             {
1468               handle_signal (signo);
1469               continue;
1470             }
1471           log_error (_("pth_select failed: %s - waiting 1s\n"),
1472                      strerror (errno));
1473           pth_sleep (1);
1474           continue;
1475         }
1476
1477       if (pth_event_occurred (ev))
1478         {
1479           handle_signal (signo);
1480         }
1481
1482       if (FD_ISSET (listen_fd, &read_fdset))
1483         {
1484           plen = sizeof paddr;
1485           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1486           if (fd == -1)
1487             {
1488               log_error ("accept failed: %s\n", strerror (errno));
1489             }
1490           else if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1491             {
1492               log_error ("error spawning connection handler: %s\n",
1493                          strerror (errno) );
1494               close (fd);
1495             }
1496           fd = -1;
1497         }
1498
1499       if (listen_fd_ssh != -1 && FD_ISSET (listen_fd_ssh, &read_fdset))
1500         {
1501           plen = sizeof paddr;
1502           fd = pth_accept (listen_fd_ssh, (struct sockaddr *)&paddr, &plen);
1503           if (fd == -1)
1504             {
1505               log_error ("accept failed for ssh: %s\n", strerror (errno));
1506             }
1507           else if (!pth_spawn (tattr, start_connection_thread_ssh, (void*)fd))
1508             {
1509               log_error ("error spawning ssh connection handler: %s\n",
1510                          strerror (errno) );
1511               close (fd);
1512             }
1513           fd = -1;
1514         }
1515     }
1516
1517   pth_event_free (ev, PTH_FREE_ALL);
1518   cleanup ();
1519   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1520 }
1521 #endif /*USE_GNU_PTH*/
1522
1523
1524 /* Figure out whether an agent is available and running. Prints an
1525    error if not.  Usually started with MODE 0. */
1526 static int
1527 check_for_running_agent (int mode)
1528 {
1529   int rc;
1530   char *infostr, *p;
1531   assuan_context_t ctx;
1532   int prot, pid;
1533
1534   if (!mode)
1535     {
1536       infostr = getenv ("GPG_AGENT_INFO");
1537       if (!infostr || !*infostr)
1538         {
1539           if (!check_for_running_agent (1))
1540             return 0; /* Okay, its running on the standard socket. */
1541           log_error (_("no gpg-agent running in this session\n"));
1542           return -1;
1543         }
1544
1545       infostr = xstrdup (infostr);
1546       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1547         {
1548           xfree (infostr);
1549           if (!check_for_running_agent (1))
1550             return 0; /* Okay, its running on the standard socket. */
1551           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1552           return -1;
1553         }
1554
1555       *p++ = 0;
1556       pid = atoi (p);
1557       while (*p && *p != PATHSEP_C)
1558         p++;
1559       prot = *p? atoi (p+1) : 0;
1560       if (prot != 1)
1561         {
1562           xfree (infostr);
1563           log_error (_("gpg-agent protocol version %d is not supported\n"),
1564                      prot);
1565           if (!check_for_running_agent (1))
1566             return 0; /* Okay, its running on the standard socket. */
1567           return -1;
1568         }
1569     }
1570   else /* MODE != 0 */
1571     {
1572       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1573       pid = (pid_t)(-1);
1574     }
1575
1576
1577   rc = assuan_socket_connect (&ctx, infostr, pid);
1578   xfree (infostr);
1579   if (rc)
1580     {
1581       if (!mode && !check_for_running_agent (1))
1582         return 0; /* Okay, its running on the standard socket. */
1583
1584       if (!mode)
1585         log_error ("can't connect to the agent: %s\n", assuan_strerror (rc));
1586       return -1;
1587     }
1588
1589   if (!opt.quiet)
1590     log_info ("gpg-agent running and available\n");
1591
1592   assuan_disconnect (ctx);
1593   return 0;
1594 }