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