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