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