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