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