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