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