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