d8b891e5ffc5586f80c2523fa463d965c0d83c61
[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
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, "ssh-support", 0, N_("enable secure 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
462   set_strusage (my_strusage);
463   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
464   /* Please note that we may running SUID(ROOT), so be very CAREFUL
465      when adding any stuff between here and the call to INIT_SECMEM()
466      somewhere after the option parsing */
467   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID); 
468
469   /* Try to auto set the character set.  */
470   set_native_charset (NULL); 
471
472   i18n_init ();
473
474   /* Libgcrypt requires us to register the threading model first.
475      Note that this will also do the pth_init. */
476 #ifdef USE_GNU_PTH
477   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
478   if (err)
479     {
480       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
481                  gpg_strerror (err));
482     }
483 #endif /*USE_GNU_PTH*/
484
485
486   /* Check that the libraries are suitable.  Do it here because
487      the option parsing may need services of the library. */
488   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
489     {
490       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
491                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
492     }
493
494   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
495   assuan_set_assuan_log_stream (log_get_stream ());
496   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
497
498   gcry_set_log_handler (my_gcry_logger, NULL);
499   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
500
501   may_coredump = disable_core_dumps ();
502
503   /* Set default options.  */
504   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
505 #ifdef HAVE_W32_SYSTEM
506   standard_socket = 1;  /* Under Windows we always use a standard
507                            socket.  */
508 #endif
509   
510   shell = getenv ("SHELL");
511   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
512     csh_style = 1;
513
514   opt.homedir = default_homedir ();
515
516
517   /* Check whether we have a config file on the commandline */
518   orig_argc = argc;
519   orig_argv = argv;
520   pargs.argc = &argc;
521   pargs.argv = &argv;
522   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
523   while (arg_parse( &pargs, opts))
524     {
525       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
526         parse_debug++;
527       else if (pargs.r_opt == oOptions)
528         { /* yes there is one, so we do not try the default one, but
529              read the option file when it is encountered at the
530              commandline */
531           default_config = 0;
532         }
533         else if (pargs.r_opt == oNoOptions)
534           default_config = 0; /* --no-options */
535         else if (pargs.r_opt == oHomedir)
536           opt.homedir = pargs.r.ret_str;
537     }
538
539   /* initialize the secure memory. */
540   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
541   maybe_setuid = 0;
542
543   /* 
544      Now we are now working under our real uid 
545   */
546
547   if (default_config)
548     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
549   
550   argc = orig_argc;
551   argv = orig_argv;
552   pargs.argc = &argc;
553   pargs.argv = &argv;
554   pargs.flags=  1;  /* do not remove the args */
555  next_pass:
556   if (configname)
557     {
558       configlineno = 0;
559       configfp = fopen (configname, "r");
560       if (!configfp)
561         {
562           if (default_config)
563             {
564               if( parse_debug )
565                 log_info (_("NOTE: no default option file `%s'\n"),
566                           configname );
567             }
568           else
569             {
570               log_error (_("option file `%s': %s\n"),
571                          configname, strerror(errno) );
572               exit(2);
573             }
574           xfree (configname); 
575           configname = NULL;
576         }
577       if (parse_debug && configname )
578         log_info (_("reading options from `%s'\n"), configname );
579       default_config = 0;
580     }
581
582   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
583     {
584       if (parse_rereadable_options (&pargs, 0))
585         continue; /* Already handled */
586       switch (pargs.r_opt)
587         {
588         case aGPGConfList: gpgconf_list = 1; break;
589         case oBatch: opt.batch=1; break;
590
591         case oDebugWait: debug_wait = pargs.r.ret_int; break;
592
593         case oOptions:
594           /* config files may not be nested (silently ignore them) */
595           if (!configfp)
596             {
597                 xfree(configname);
598                 configname = xstrdup(pargs.r.ret_str);
599                 goto next_pass;
600             }
601           break;
602         case oNoGreeting: nogreeting = 1; break;
603         case oNoVerbose: opt.verbose = 0; break;
604         case oNoOptions: break; /* no-options */
605         case oHomedir: opt.homedir = pargs.r.ret_str; break;
606         case oNoDetach: nodetach = 1; break;
607         case oLogFile: logfile = pargs.r.ret_str; break;
608         case oCsh: csh_style = 1; break;
609         case oSh: csh_style = 0; break;
610         case oServer: pipe_server = 1; break;
611         case oDaemon: is_daemon = 1; break;
612         case oDisablePth: disable_pth = 1; break;
613
614         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
615         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
616         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
617         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
618         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
619           break;
620
621         case oUseStandardSocket: standard_socket = 1; break;
622         case oNoUseStandardSocket: standard_socket = 0; break;
623
624         case oKeepTTY: opt.keep_tty = 1; break;
625         case oKeepDISPLAY: opt.keep_display = 1; break;
626
627         case oSSHSupport:
628           opt.ssh_support = 1;
629           opt.keep_tty  = 1;
630           opt.keep_display = 1;
631           break;
632
633         default : pargs.err = configfp? 1:2; break;
634         }
635     }
636   if (configfp)
637     {
638       fclose( configfp );
639       configfp = NULL;
640       /* Keep a copy of the name so that it can be read on SIGHUP. */
641       config_filename = configname;
642       configname = NULL;
643       goto next_pass;
644     }
645   xfree (configname);
646   configname = NULL;
647   if (log_get_errorcount(0))
648     exit(2);
649   if (nogreeting )
650     greeting = 0;
651
652   if (greeting)
653     {
654       fprintf (stderr, "%s %s; %s\n",
655                  strusage(11), strusage(13), strusage(14) );
656       fprintf (stderr, "%s\n", strusage(15) );
657     }
658 #ifdef IS_DEVELOPMENT_VERSION
659   /* We don't want to print it here because gpg-agent is useful of its
660      own and quite matured.  */
661   /*log_info ("NOTE: this is a development version!\n");*/
662 #endif
663
664   set_debug ();
665   
666   if (atexit (cleanup))
667     {
668       log_error ("atexit failed\n");
669       cleanup ();
670       exit (1);
671     }
672
673   initialize_module_query ();
674   initialize_module_call_scd ();
675   
676   /* Try to create missing directories. */
677   create_directories ();
678
679   if (debug_wait && pipe_server)
680     {
681       log_debug ("waiting for debugger - my pid is %u .....\n",
682                  (unsigned int)getpid());
683       sleep (debug_wait);
684       log_debug ("... okay\n");
685     }
686   
687   if (gpgconf_list)
688     {
689       char *filename;
690
691       /* List options and default values in the GPG Conf format.  */
692
693       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
694       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
695          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
696 #define GC_OPT_FLAG_NONE        0UL
697       /* The RUNTIME flag for an option indicates that the option can be
698          changed at runtime.  */
699 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
700       /* The DEFAULT flag for an option indicates that the option has a
701          default value.  */
702 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
703       /* The DEF_DESC flag for an option indicates that the option has a
704          default, which is described by the value of the default field.  */
705 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
706       /* The NO_ARG_DESC flag for an option indicates that the argument has
707          a default, which is described by the value of the ARGDEF field.  */
708 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
709
710       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
711       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
712               GC_OPT_FLAG_DEFAULT, filename);
713       xfree (filename);
714
715       printf ("verbose:%lu:\n"
716               "quiet:%lu:\n"
717               "debug-level:%lu:\"none:\n"
718               "log-file:%lu:\n",
719               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
720               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
721               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
722               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
723       printf ("default-cache-ttl:%lu:%d:\n",
724               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
725       printf ("no-grab:%lu:\n", 
726               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
727       printf ("ignore-cache-for-signing:%lu:\n",
728               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
729       printf ("allow-mark-trusted:%lu:\n",
730               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
731
732       agent_exit (0);
733     }
734
735   /* If this has been called without any options, we merely check
736      whether an agent is already running.  We do this here so that we
737      don't clobber a logfile but print it directly to stderr. */
738   if (!pipe_server && !is_daemon)
739     {
740       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
741       check_for_running_agent (0);
742       agent_exit (0);
743     }
744   
745 #ifdef ENABLE_NLS
746   /* gpg-agent usually does not output any messages because it runs in
747      the background.  For log files it is acceptable to have messages
748      always encoded in utf-8.  We switch here to utf-8, so that
749      commands like --help still give native messages.  It is far
750      easier to switch only once instead of for every message and it
751      actually helps when more then one thread is active (avoids an
752      extra copy step). */
753     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
754 #endif
755
756   /* Now start with logging to a file if this is desired. */
757   if (logfile)
758     {
759       log_set_file (logfile);
760       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
761                              |JNLIB_LOG_WITH_TIME
762                              |JNLIB_LOG_WITH_PID));
763       current_logfile = xstrdup (logfile);
764     }
765
766   /* Make sure that we have a default ttyname. */
767   if (!default_ttyname && ttyname (1))
768     default_ttyname = xstrdup (ttyname (1));
769   if (!default_ttytype && getenv ("TERM"))
770     default_ttytype = xstrdup (getenv ("TERM"));
771
772
773   if (pipe_server)
774     { /* this is the simple pipe based server */
775       start_command_handler (-1, -1);
776     }
777   else if (!is_daemon)
778     ; /* NOTREACHED */
779   else
780     { /* Regular server mode */
781       int fd;
782       int fd_ssh;
783       pid_t pid;
784
785       /* Remove the DISPLAY variable so that a pinentry does not
786          default to a specific display.  There is still a default
787          display when gpg-agent weas started using --display or a
788          client requested this using an OPTION command. */
789 #ifndef HAVE_W32_SYSTEM
790       if (!opt.keep_display)
791         unsetenv ("DISPLAY");
792 #endif
793
794
795       /* Create the sockets.  */
796       socket_name = create_socket_name (standard_socket,
797                                         "S.gpg-agent",
798                                         "/tmp/gpg-XXXXXX/S.gpg-agent");
799       if (opt.ssh_support)
800         socket_name_ssh = create_socket_name (standard_socket, 
801                                             "S.gpg-agent.ssh",
802                                             "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
803
804       fd = create_server_socket (standard_socket, socket_name);
805       if (opt.ssh_support)
806         fd_ssh = create_server_socket (standard_socket, socket_name_ssh);
807       else
808         fd_ssh = -1;
809
810
811       fflush (NULL);
812 #ifdef HAVE_W32_SYSTEM
813       pid = getpid ();
814       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
815 #else /*!HAVE_W32_SYSTEM*/
816       pid = fork ();
817       if (pid == (pid_t)-1) 
818         {
819           log_fatal ("fork failed: %s\n", strerror (errno) );
820           exit (1);
821         }
822       else if (pid) 
823         { /* We are the parent */
824           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
825           
826           close (fd);
827           
828           /* Create the info string: <name>:<pid>:<protocol_version> */
829           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
830                         socket_name, (ulong)pid ) < 0)
831             {
832               log_error ("out of core\n");
833               kill (pid, SIGTERM);
834               exit (1);
835             }
836           if (opt.ssh_support)
837             {
838               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
839                             socket_name_ssh) < 0)
840                 {
841                   log_error ("out of core\n");
842                   kill (pid, SIGTERM);
843                   exit (1);
844                 }
845               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
846                             pid) < 0)
847                 {
848                   log_error ("out of core\n");
849                   kill (pid, SIGTERM);
850                   exit (1);
851                 }
852             }
853
854           *socket_name = 0; /* Don't let cleanup() remove the socket -
855                                the child should do this from now on */
856           if (opt.ssh_support)
857             *socket_name_ssh = 0;
858
859
860           if (argc) 
861             { /* Run the program given on the commandline.  */
862               if (putenv (infostr))
863                 {
864                   log_error ("failed to set environment: %s\n",
865                              strerror (errno) );
866                   kill (pid, SIGTERM );
867                   exit (1);
868                 }
869               if (putenv (infostr_ssh_sock))
870                 {
871                   log_error ("failed to set environment: %s\n",
872                              strerror (errno) );
873                   kill (pid, SIGTERM );
874                   exit (1);
875                 }
876               if (putenv (infostr_ssh_pid))
877                 {
878                   log_error ("failed to set environment: %s\n",
879                              strerror (errno) );
880                   kill (pid, SIGTERM );
881                   exit (1);
882                 }
883               execvp (argv[0], argv);
884               log_error ("failed to run the command: %s\n", strerror (errno));
885               kill (pid, SIGTERM);
886               exit (1);
887             }
888           else
889             {
890               /* Print the environment string, so that the caller can use
891                  shell's eval to set it */
892               if (csh_style)
893                 {
894                   *strchr (infostr, '=') = ' ';
895                   printf ("setenv %s\n", infostr);
896                   if (opt.ssh_support)
897                     {
898                       *strchr (infostr_ssh_sock, '=') = ' ';
899                       printf ("setenv %s\n", infostr_ssh_sock);
900                       *strchr (infostr_ssh_pid, '=') = ' ';
901                       printf ("setenv %s\n", infostr_ssh_pid);
902                     }
903                 }
904               else
905                 {
906                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
907                   if (opt.ssh_support)
908                     {
909                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
910                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
911                     }
912                 }
913               /* Note: teh standard free is here correct.  */
914               free (infostr);
915               if (opt.ssh_support)
916                 {
917                   free (infostr_ssh_sock);
918                   free (infostr_ssh_pid);
919                 }
920               exit (0); 
921             }
922           /*NOTREACHED*/
923         } /* End parent */
924
925       /* 
926          This is the child
927        */
928
929       /* Detach from tty and put process into a new session */
930       if (!nodetach )
931         { 
932           int i;
933           unsigned int oldflags;
934
935           /* Close stdin, stdout and stderr unless it is the log stream */
936           for (i=0; i <= 2; i++) 
937             {
938               if (!log_test_fd (i) && i != fd )
939                 close (i);
940             }
941           if (setsid() == -1)
942             {
943               log_error ("setsid() failed: %s\n", strerror(errno) );
944               cleanup ();
945               exit (1);
946             }
947
948           log_get_prefix (&oldflags);
949           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
950           opt.running_detached = 1;
951         }
952
953       if (chdir("/"))
954         {
955           log_error ("chdir to / failed: %s\n", strerror (errno));
956           exit (1);
957         }
958
959 #endif /*!HAVE_W32_SYSTEM*/
960
961
962 #ifdef USE_GNU_PTH
963       if (!disable_pth)
964         {
965 #ifndef HAVE_W32_SYSTEM  /* FIXME */
966           struct sigaction sa;
967
968           sa.sa_handler = SIG_IGN;
969           sigemptyset (&sa.sa_mask);
970           sa.sa_flags = 0;
971           sigaction (SIGPIPE, &sa, NULL);
972 #endif
973           handle_connections (fd, opt.ssh_support ? fd_ssh : -1);
974         }
975       else
976 #endif /*!USE_GNU_PTH*/
977       /* setup signals */
978         {
979 #ifndef HAVE_W32_SYSTEM  /* FIXME */
980           struct sigaction oact, nact;
981           
982           nact.sa_handler = cleanup_sh;
983           sigemptyset (&nact.sa_mask);
984           nact.sa_flags = 0;
985           
986           sigaction (SIGHUP, NULL, &oact);
987           if (oact.sa_handler != SIG_IGN)
988             sigaction (SIGHUP, &nact, NULL);
989           sigaction( SIGTERM, NULL, &oact );
990           if (oact.sa_handler != SIG_IGN)
991             sigaction (SIGTERM, &nact, NULL);
992           nact.sa_handler = SIG_IGN;
993           sigaction (SIGPIPE, &nact, NULL);
994           sigaction (SIGINT, &nact, NULL);
995 #endif
996           start_command_handler (fd, -1);
997         }
998       close (fd);
999     }
1000   
1001   return 0;
1002 }
1003
1004 void
1005 agent_exit (int rc)
1006 {
1007   /*FIXME: update_random_seed_file();*/
1008 #if 1
1009   /* at this time a bit annoying */
1010   if (opt.debug & DBG_MEMSTAT_VALUE)
1011     {
1012       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1013       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1014     }
1015   if (opt.debug)
1016     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1017 #endif
1018   gcry_control (GCRYCTL_TERM_SECMEM );
1019   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1020   exit (rc);
1021 }
1022
1023
1024 void
1025 agent_init_default_ctrl (struct server_control_s *ctrl)
1026 {
1027   ctrl->connection_fd = -1;
1028
1029   /* Note we ignore malloc errors because we can't do much about it
1030      and the request will fail anyway shortly after this
1031      initialization. */
1032   if (ctrl->display)
1033     free (ctrl->display);
1034   ctrl->display = default_display? strdup (default_display) : NULL;
1035
1036   if (ctrl->ttyname)
1037     free (ctrl->ttyname);
1038   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
1039
1040   if (ctrl->ttytype)
1041     free (ctrl->ttytype);
1042   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1043
1044   if (ctrl->lc_ctype)
1045     free (ctrl->lc_ctype);
1046   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1047
1048   if (ctrl->lc_messages)
1049     free (ctrl->lc_messages);
1050   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1051 }
1052
1053
1054 /* Reread parts of the configuration.  Note, that this function is
1055    obviously not thread-safe and should only be called from the PTH
1056    signal handler. 
1057
1058    Fixme: Due to the way the argument parsing works, we create a
1059    memory leak here for all string type arguments.  There is currently
1060    no clean way to tell whether the memory for the argument has been
1061    allocated or points into the process' original arguments.  Unless
1062    we have a mechanism to tell this, we need to live on with this. */
1063 static void
1064 reread_configuration (void)
1065 {
1066   ARGPARSE_ARGS pargs;
1067   FILE *fp;
1068   unsigned int configlineno = 0;
1069   int dummy;
1070
1071   if (!config_filename)
1072     return; /* No config file. */
1073
1074   fp = fopen (config_filename, "r");
1075   if (!fp)
1076     {
1077       log_error (_("option file `%s': %s\n"),
1078                  config_filename, strerror(errno) );
1079       return;
1080     }
1081
1082   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1083
1084   memset (&pargs, 0, sizeof pargs);
1085   dummy = 0;
1086   pargs.argc = &dummy;
1087   pargs.flags = 1;  /* do not remove the args */
1088   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1089     {
1090       if (pargs.r_opt < -1)
1091         pargs.err = 1; /* Print a warning. */
1092       else /* Try to parse this option - ignore unchangeable ones. */
1093         parse_rereadable_options (&pargs, 1);
1094     }
1095   fclose (fp);
1096   set_debug ();
1097 }
1098
1099
1100
1101
1102 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1103    true ising STANDARD_NAME in the home directory or if given has
1104    false from the mkdir type name TEMPLATE.  In the latter case a
1105    unique name in a unique new directory will be created.  In both
1106    cases check for valid characters as well as against a maximum
1107    allowed length for a unix domain socket is done.  The function
1108    terminates the process in case of an error.  Retunrs: Pointer to an
1109    allcoated string with the absolute name of the socket used.  */
1110 static char *
1111 create_socket_name (int use_standard_socket,
1112                     char *standard_name, char *template)
1113 {
1114   char *name, *p;
1115
1116   if (use_standard_socket)
1117     name = make_filename (opt.homedir, standard_name, NULL);
1118   else
1119     {
1120       name = xstrdup (template);
1121       p = strrchr (name, '/');
1122       if (!p)
1123         BUG ();
1124       *p = 0;
1125       if (!mkdtemp (name))
1126         {
1127           log_error (_("can't create directory `%s': %s\n"),
1128                      name, strerror (errno));
1129           agent_exit (2);
1130         }
1131       *p = '/';
1132     }
1133
1134   if (strchr (name, PATHSEP_C))
1135     {
1136       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1137       agent_exit (2);
1138     }
1139   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1140     {
1141       log_error (_("name of socket too long\n"));
1142       agent_exit (2);
1143     }
1144   return name;
1145 }
1146
1147
1148
1149 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1150    whether a non-random socket is used.  Returns the filedescriptor or
1151    terminates the process in case of an error. */
1152 static int
1153 create_server_socket (int is_standard_name, const char *name)
1154 {
1155   struct sockaddr_un *serv_addr;
1156   socklen_t len;
1157   int fd;
1158   int rc;
1159
1160 #ifdef HAVE_W32_SYSTEM
1161   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
1162 #else
1163   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1164 #endif
1165   if (fd == -1)
1166     {
1167       log_error (_("can't create socket: %s\n"), strerror (errno));
1168       agent_exit (2);
1169     }
1170
1171
1172   memset (serv_addr, 0, sizeof *serv_addr);
1173   serv_addr->sun_family = AF_UNIX;
1174   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
1175   strcpy (serv_addr->sun_path, name);
1176   len = (offsetof (struct sockaddr_un, sun_path)
1177          + strlen (serv_addr->sun_path) + 1);
1178
1179 #ifdef HAVE_W32_SYSTEM
1180   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1181   if (is_standard_name && rc == -1 )
1182     {
1183       remove (name);
1184       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1185     }
1186 #else
1187   rc = bind (fd, (struct sockaddr*) serv_addr, len);
1188   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1189     {
1190       remove (name);
1191       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1192     }
1193 #endif
1194   if (rc == -1)
1195     {
1196       log_error (_("error binding socket to `%s': %s\n"),
1197                  serv_addr->sun_path, strerror (errno));
1198       close (fd);
1199       agent_exit (2);
1200     }
1201
1202   if (listen (fd, 5 ) == -1)
1203     {
1204       log_error (_("listen() failed: %s\n"), strerror (errno));
1205       close (fd);
1206       agent_exit (2);
1207     }
1208           
1209   if (opt.verbose)
1210     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1211
1212   return fd;
1213 }
1214
1215
1216 /* Check that the directory for storing the private keys exists and
1217    create it if not.  This function won't fail as it is only a
1218    convenience function and not strictly necessary.  */
1219 static void
1220 create_private_keys_directory (const char *home)
1221 {
1222   char *fname;
1223   struct stat statbuf;
1224
1225   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1226   if (stat (fname, &statbuf) && errno == ENOENT)
1227     {
1228 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1229       if (!CreateDirectory (fname, NULL))
1230         log_error (_("can't create directory `%s': %s\n"),
1231                    fname, w32_strerror (-1) );
1232 #else
1233       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1234         log_error (_("can't create directory `%s': %s\n"),
1235                    fname, strerror (errno) );
1236 #endif
1237       else if (!opt.quiet)
1238         log_info (_("directory `%s' created\n"), fname);
1239     }
1240   xfree (fname);
1241 }
1242
1243 /* Create the directory only if the supplied directory name is the
1244    same as the default one.  This way we avoid to create arbitrary
1245    directories when a non-default home directory is used.  To cope
1246    with HOME, we compare only the suffix if we see that the default
1247    homedir does start with a tilde.  We don't stop here in case of
1248    problems because other functions will throw an error anyway.*/
1249 static void
1250 create_directories (void)
1251 {
1252   struct stat statbuf;
1253   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1254   char *home;
1255
1256   home = make_filename (opt.homedir, NULL);
1257   if ( stat (home, &statbuf) )
1258     {
1259       if (errno == ENOENT)
1260         {
1261           if ( (*defhome == '~'
1262                 && (strlen (home) >= strlen (defhome+1)
1263                     && !strcmp (home + strlen(home)
1264                                 - strlen (defhome+1), defhome+1)))
1265                || (*defhome != '~' && !strcmp (home, defhome) )
1266                )
1267             {
1268 #ifdef HAVE_W32_SYSTEM
1269               if (!CreateDirectory (home, NULL))
1270                 log_error (_("can't create directory `%s': %s\n"),
1271                            home, w32_strerror (-1) );
1272 #else
1273               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1274                 log_error (_("can't create directory `%s': %s\n"),
1275                            home, strerror (errno) );
1276 #endif
1277               else 
1278                 {
1279                   if (!opt.quiet)
1280                     log_info (_("directory `%s' created\n"), home);
1281                   create_private_keys_directory (home);
1282                 }
1283             }
1284         }
1285       else
1286         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1287     }
1288   else if ( !S_ISDIR(statbuf.st_mode))
1289     {
1290       log_error (_("can't use `%s' as home directory\n"), home);
1291     }
1292   else /* exists and is a directory. */
1293     {
1294       create_private_keys_directory (home);
1295     }
1296   xfree (home);
1297 }
1298
1299
1300
1301 #ifdef USE_GNU_PTH
1302 static void
1303 handle_signal (int signo)
1304 {
1305   switch (signo)
1306     {
1307 #ifndef HAVE_W32_SYSTEM
1308     case SIGHUP:
1309       log_info ("SIGHUP received - "
1310                 "re-reading configuration and flushing cache\n");
1311       agent_flush_cache ();
1312       reread_configuration ();
1313       agent_reload_trustlist ();
1314       break;
1315       
1316     case SIGUSR1:
1317       log_info ("SIGUSR1 received - no action defined\n");
1318       break;
1319       
1320     case SIGUSR2:
1321       log_info ("SIGUSR2 received - checking smartcard status\n");
1322       break;
1323
1324     case SIGTERM:
1325       if (!shutdown_pending)
1326         log_info ("SIGTERM received - shutting down ...\n");
1327       else
1328         log_info ("SIGTERM received - still %ld running threads\n",
1329                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1330       shutdown_pending++;
1331       if (shutdown_pending > 2)
1332         {
1333           log_info ("shutdown forced\n");
1334           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1335           cleanup ();
1336           agent_exit (0);
1337         }
1338       break;
1339         
1340     case SIGINT:
1341       log_info ("SIGINT received - immediate shutdown\n");
1342       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1343       cleanup ();
1344       agent_exit (0);
1345       break;
1346 #endif
1347     default:
1348       log_info ("signal %d received - no action defined\n", signo);
1349     }
1350 }
1351
1352
1353 /* This is the standard connection thread's main function.  */
1354 static void *
1355 start_connection_thread (void *arg)
1356 {
1357   int fd = (int)arg;
1358
1359   if (opt.verbose)
1360     log_info (_("handler for fd %d started\n"), fd);
1361
1362   /* FIXME: Move this housekeeping into a ticker function.  Calling it
1363      for each connection should work but won't work anymore if our
1364      clients start to keep connections. */
1365   agent_trustlist_housekeeping ();
1366
1367   start_command_handler (-1, fd);
1368   if (opt.verbose)
1369     log_info (_("handler for fd %d terminated\n"), fd);
1370   
1371   return NULL;
1372 }
1373
1374
1375 /* This is the ssh connection thread's main function.  */
1376 static void *
1377 start_connection_thread_ssh (void *arg)
1378 {
1379   int fd = (int)arg;
1380
1381   if (opt.verbose)
1382     log_info (_("ssh handler for fd %d started\n"), fd);
1383
1384   agent_trustlist_housekeeping ();
1385
1386   start_command_handler_ssh (fd);
1387   if (opt.verbose)
1388     log_info (_("ssh handler for fd %d terminated\n"), fd);
1389   
1390   return NULL;
1391 }
1392
1393
1394 /* Connection handler loop.  Wait for coecntion requests and spawn a
1395    thread after accepting a connection.  */
1396 static void
1397 handle_connections (int listen_fd, int listen_fd_ssh)
1398 {
1399   pth_attr_t tattr;
1400   pth_event_t ev;
1401   sigset_t sigs;
1402   int signo;
1403   struct sockaddr_un paddr;
1404   socklen_t plen;
1405   fd_set fdset, read_fdset;
1406   int ret;
1407   int fd;
1408
1409   tattr = pth_attr_new();
1410   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1411   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1412   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1413
1414 #ifndef HAVE_W32_SYSTEM /* fixme */
1415   sigemptyset (&sigs );
1416   sigaddset (&sigs, SIGHUP);
1417   sigaddset (&sigs, SIGUSR1);
1418   sigaddset (&sigs, SIGUSR2);
1419   sigaddset (&sigs, SIGINT);
1420   sigaddset (&sigs, SIGTERM);
1421   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1422 #else
1423   ev = NULL;
1424 #endif
1425
1426   FD_ZERO (&fdset);
1427   FD_SET (listen_fd, &fdset);
1428   if (listen_fd_ssh != -1)
1429     FD_SET (listen_fd_ssh, &fdset);
1430
1431   for (;;)
1432     {
1433       if (shutdown_pending)
1434         {
1435           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1436             break; /* ready */
1437
1438           /* Do not accept anymore connections and wait for existing
1439              connections to terminate */
1440           signo = 0;
1441           pth_wait (ev);
1442           if (pth_event_occurred (ev) && signo)
1443             handle_signal (signo);
1444           continue;
1445         }
1446
1447       /* POSIX says that fd_set should be implemented as a structure,
1448          thus a simple assignment is fine to copy the entire set.  */
1449       read_fdset = fdset;
1450
1451       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1452       if (ret == -1)
1453         {
1454           log_error (_("pth_select failed: %s - waiting 1s\n"),
1455                      strerror (errno));
1456           pth_sleep (1);
1457           continue;
1458         }
1459
1460       if (pth_event_occurred (ev))
1461         {
1462           handle_signal (signo);
1463         }
1464
1465       if (FD_ISSET (listen_fd, &read_fdset))
1466         {
1467           plen = sizeof paddr;
1468           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1469           if (fd == -1)
1470             {
1471               log_error ("accept failed: %s\n", strerror (errno));
1472             }
1473           else if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1474             {
1475               log_error ("error spawning connection handler: %s\n",
1476                          strerror (errno) );
1477               close (fd);
1478             }
1479           fd = -1;
1480         }
1481
1482       if (listen_fd_ssh != -1 && FD_ISSET (listen_fd_ssh, &read_fdset))
1483         {
1484           plen = sizeof paddr;
1485           fd = pth_accept (listen_fd_ssh, (struct sockaddr *)&paddr, &plen);
1486           if (fd == -1)
1487             {
1488               log_error ("accept failed for ssh: %s\n", strerror (errno));
1489             }
1490           else if (!pth_spawn (tattr, start_connection_thread_ssh, (void*)fd))
1491             {
1492               log_error ("error spawning ssh connection handler: %s\n",
1493                          strerror (errno) );
1494               close (fd);
1495             }
1496           fd = -1;
1497         }
1498     }
1499
1500   pth_event_free (ev, PTH_FREE_ALL);
1501   cleanup ();
1502   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1503 }
1504 #endif /*USE_GNU_PTH*/
1505
1506
1507 /* Figure out whether an agent is available and running. Prints an
1508    error if not.  Usually started with MODE 0. */
1509 static int
1510 check_for_running_agent (int mode)
1511 {
1512   int rc;
1513   char *infostr, *p;
1514   assuan_context_t ctx;
1515   int prot, pid;
1516
1517   if (!mode)
1518     {
1519       infostr = getenv ("GPG_AGENT_INFO");
1520       if (!infostr || !*infostr)
1521         {
1522           if (!check_for_running_agent (1))
1523             return 0; /* Okay, its running on the standard socket. */
1524           log_error (_("no gpg-agent running in this session\n"));
1525           return -1;
1526         }
1527
1528       infostr = xstrdup (infostr);
1529       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1530         {
1531           xfree (infostr);
1532           if (!check_for_running_agent (1))
1533             return 0; /* Okay, its running on the standard socket. */
1534           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1535           return -1;
1536         }
1537
1538       *p++ = 0;
1539       pid = atoi (p);
1540       while (*p && *p != PATHSEP_C)
1541         p++;
1542       prot = *p? atoi (p+1) : 0;
1543       if (prot != 1)
1544         {
1545           xfree (infostr);
1546           log_error (_("gpg-agent protocol version %d is not supported\n"),
1547                      prot);
1548           if (!check_for_running_agent (1))
1549             return 0; /* Okay, its running on the standard socket. */
1550           return -1;
1551         }
1552     }
1553   else /* MODE != 0 */
1554     {
1555       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1556       pid = (pid_t)(-1);
1557     }
1558
1559
1560   rc = assuan_socket_connect (&ctx, infostr, pid);
1561   xfree (infostr);
1562   if (rc)
1563     {
1564       if (!mode && !check_for_running_agent (1))
1565         return 0; /* Okay, its running on the standard socket. */
1566
1567       if (!mode)
1568         log_error ("can't connect to the agent: %s\n", assuan_strerror (rc));
1569       return -1;
1570     }
1571
1572   if (!opt.quiet)
1573     log_info ("gpg-agent running and available\n");
1574
1575   assuan_disconnect (ctx);
1576   return 0;
1577 }