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