.
[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                 close (i);
1011             }
1012           if (setsid() == -1)
1013             {
1014               log_error ("setsid() failed: %s\n", strerror(errno) );
1015               cleanup ();
1016               exit (1);
1017             }
1018
1019           log_get_prefix (&oldflags);
1020           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1021           opt.running_detached = 1;
1022         }
1023
1024       if (chdir("/"))
1025         {
1026           log_error ("chdir to / failed: %s\n", strerror (errno));
1027           exit (1);
1028         }
1029
1030       {
1031         struct sigaction sa;
1032         
1033         sa.sa_handler = SIG_IGN;
1034         sigemptyset (&sa.sa_mask);
1035         sa.sa_flags = 0;
1036         sigaction (SIGPIPE, &sa, NULL);
1037       }
1038 #endif /*!HAVE_W32_SYSTEM*/
1039
1040       handle_connections (fd, opt.ssh_support ? fd_ssh : -1);
1041       close (fd);
1042     }
1043   
1044   return 0;
1045 }
1046
1047 void
1048 agent_exit (int rc)
1049 {
1050   /*FIXME: update_random_seed_file();*/
1051 #if 1
1052   /* at this time a bit annoying */
1053   if (opt.debug & DBG_MEMSTAT_VALUE)
1054     {
1055       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1056       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1057     }
1058   if (opt.debug)
1059     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1060 #endif
1061   gcry_control (GCRYCTL_TERM_SECMEM );
1062   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1063   exit (rc);
1064 }
1065
1066
1067 void
1068 agent_init_default_ctrl (struct server_control_s *ctrl)
1069 {
1070   ctrl->connection_fd = -1;
1071
1072   /* Note we ignore malloc errors because we can't do much about it
1073      and the request will fail anyway shortly after this
1074      initialization. */
1075   if (ctrl->display)
1076     free (ctrl->display);
1077   ctrl->display = default_display? strdup (default_display) : NULL;
1078
1079   if (ctrl->ttyname)
1080     free (ctrl->ttyname);
1081   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
1082
1083   if (ctrl->ttytype)
1084     free (ctrl->ttytype);
1085   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1086
1087   if (ctrl->lc_ctype)
1088     free (ctrl->lc_ctype);
1089   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1090
1091   if (ctrl->lc_messages)
1092     free (ctrl->lc_messages);
1093   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1094 }
1095
1096
1097 /* Reread parts of the configuration.  Note, that this function is
1098    obviously not thread-safe and should only be called from the PTH
1099    signal handler. 
1100
1101    Fixme: Due to the way the argument parsing works, we create a
1102    memory leak here for all string type arguments.  There is currently
1103    no clean way to tell whether the memory for the argument has been
1104    allocated or points into the process' original arguments.  Unless
1105    we have a mechanism to tell this, we need to live on with this. */
1106 static void
1107 reread_configuration (void)
1108 {
1109   ARGPARSE_ARGS pargs;
1110   FILE *fp;
1111   unsigned int configlineno = 0;
1112   int dummy;
1113
1114   if (!config_filename)
1115     return; /* No config file. */
1116
1117   fp = fopen (config_filename, "r");
1118   if (!fp)
1119     {
1120       log_error (_("option file `%s': %s\n"),
1121                  config_filename, strerror(errno) );
1122       return;
1123     }
1124
1125   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1126
1127   memset (&pargs, 0, sizeof pargs);
1128   dummy = 0;
1129   pargs.argc = &dummy;
1130   pargs.flags = 1;  /* do not remove the args */
1131   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1132     {
1133       if (pargs.r_opt < -1)
1134         pargs.err = 1; /* Print a warning. */
1135       else /* Try to parse this option - ignore unchangeable ones. */
1136         parse_rereadable_options (&pargs, 1);
1137     }
1138   fclose (fp);
1139   set_debug ();
1140 }
1141
1142
1143
1144
1145 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1146    true using STANDARD_NAME in the home directory or if given has
1147    false from the mkdir type name TEMPLATE.  In the latter case a
1148    unique name in a unique new directory will be created.  In both
1149    cases check for valid characters as well as against a maximum
1150    allowed length for a unix domain socket is done.  The function
1151    terminates the process in case of an error.  Returns: Pointer to an
1152    allcoated string with the absolute name of the socket used.  */
1153 static char *
1154 create_socket_name (int use_standard_socket,
1155                     char *standard_name, char *template)
1156 {
1157   char *name, *p;
1158
1159   if (use_standard_socket)
1160     name = make_filename (opt.homedir, standard_name, NULL);
1161   else
1162     {
1163       name = xstrdup (template);
1164       p = strrchr (name, '/');
1165       if (!p)
1166         BUG ();
1167       *p = 0;
1168       if (!mkdtemp (name))
1169         {
1170           log_error (_("can't create directory `%s': %s\n"),
1171                      name, strerror (errno));
1172           agent_exit (2);
1173         }
1174       *p = '/';
1175     }
1176
1177   if (strchr (name, PATHSEP_C))
1178     {
1179       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1180       agent_exit (2);
1181     }
1182   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1183     {
1184       log_error (_("name of socket too long\n"));
1185       agent_exit (2);
1186     }
1187   return name;
1188 }
1189
1190
1191
1192 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1193    whether a non-random socket is used.  Returns the filedescriptor or
1194    terminates the process in case of an error. */
1195 static int
1196 create_server_socket (int is_standard_name, const char *name)
1197 {
1198   struct sockaddr_un *serv_addr;
1199   socklen_t len;
1200   int fd;
1201   int rc;
1202
1203 #ifdef HAVE_W32_SYSTEM
1204   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
1205 #else
1206   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1207 #endif
1208   if (fd == -1)
1209     {
1210       log_error (_("can't create socket: %s\n"), strerror (errno));
1211       agent_exit (2);
1212     }
1213
1214   serv_addr = xmalloc (sizeof (*serv_addr)); 
1215   memset (serv_addr, 0, sizeof *serv_addr);
1216   serv_addr->sun_family = AF_UNIX;
1217   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
1218   strcpy (serv_addr->sun_path, name);
1219   len = (offsetof (struct sockaddr_un, sun_path)
1220          + strlen (serv_addr->sun_path) + 1);
1221
1222 #ifdef HAVE_W32_SYSTEM
1223   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1224   if (is_standard_name && rc == -1 )
1225     {
1226       remove (name);
1227       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1228     }
1229 #else
1230   rc = bind (fd, (struct sockaddr*) serv_addr, len);
1231   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1232     {
1233       remove (name);
1234       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1235     }
1236 #endif
1237   if (rc == -1)
1238     {
1239       log_error (_("error binding socket to `%s': %s\n"),
1240                  serv_addr->sun_path, strerror (errno));
1241       close (fd);
1242       agent_exit (2);
1243     }
1244
1245   if (listen (fd, 5 ) == -1)
1246     {
1247       log_error (_("listen() failed: %s\n"), strerror (errno));
1248       close (fd);
1249       agent_exit (2);
1250     }
1251           
1252   if (opt.verbose)
1253     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1254
1255   return fd;
1256 }
1257
1258
1259 /* Check that the directory for storing the private keys exists and
1260    create it if not.  This function won't fail as it is only a
1261    convenience function and not strictly necessary.  */
1262 static void
1263 create_private_keys_directory (const char *home)
1264 {
1265   char *fname;
1266   struct stat statbuf;
1267
1268   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1269   if (stat (fname, &statbuf) && errno == ENOENT)
1270     {
1271 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1272       if (!CreateDirectory (fname, NULL))
1273         log_error (_("can't create directory `%s': %s\n"),
1274                    fname, w32_strerror (-1) );
1275 #else
1276       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1277         log_error (_("can't create directory `%s': %s\n"),
1278                    fname, strerror (errno) );
1279 #endif
1280       else if (!opt.quiet)
1281         log_info (_("directory `%s' created\n"), fname);
1282     }
1283   xfree (fname);
1284 }
1285
1286 /* Create the directory only if the supplied directory name is the
1287    same as the default one.  This way we avoid to create arbitrary
1288    directories when a non-default home directory is used.  To cope
1289    with HOME, we compare only the suffix if we see that the default
1290    homedir does start with a tilde.  We don't stop here in case of
1291    problems because other functions will throw an error anyway.*/
1292 static void
1293 create_directories (void)
1294 {
1295   struct stat statbuf;
1296   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1297   char *home;
1298
1299   home = make_filename (opt.homedir, NULL);
1300   if ( stat (home, &statbuf) )
1301     {
1302       if (errno == ENOENT)
1303         {
1304           if ( (*defhome == '~'
1305                 && (strlen (home) >= strlen (defhome+1)
1306                     && !strcmp (home + strlen(home)
1307                                 - strlen (defhome+1), defhome+1)))
1308                || (*defhome != '~' && !strcmp (home, defhome) )
1309                )
1310             {
1311 #ifdef HAVE_W32_SYSTEM
1312               if (!CreateDirectory (home, NULL))
1313                 log_error (_("can't create directory `%s': %s\n"),
1314                            home, w32_strerror (-1) );
1315 #else
1316               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1317                 log_error (_("can't create directory `%s': %s\n"),
1318                            home, strerror (errno) );
1319 #endif
1320               else 
1321                 {
1322                   if (!opt.quiet)
1323                     log_info (_("directory `%s' created\n"), home);
1324                   create_private_keys_directory (home);
1325                 }
1326             }
1327         }
1328       else
1329         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1330     }
1331   else if ( !S_ISDIR(statbuf.st_mode))
1332     {
1333       log_error (_("can't use `%s' as home directory\n"), home);
1334     }
1335   else /* exists and is a directory. */
1336     {
1337       create_private_keys_directory (home);
1338     }
1339   xfree (home);
1340 }
1341
1342
1343
1344 /* This is the worker for the ticker.  It is called every few seconds
1345    and may only do fast operations. */
1346 static void
1347 handle_tick (void)
1348 {
1349   /* Check whether the scdaemon has died and cleanup in this case. */
1350   agent_scd_check_aliveness ();
1351
1352   /* If we are running as a child of another process, check whether
1353      the parent is still alive and shutdown if not. */
1354 #ifndef HAVE_W32_SYSTEM
1355   if (parent_pid != (pid_t)(-1))
1356     {
1357       if (kill (parent_pid, 0))
1358         {
1359           shutdown_pending = 2;
1360           log_info ("parent process died - shutting down\n");
1361           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1362           cleanup ();
1363           agent_exit (0);
1364         }
1365     }
1366 #endif /*HAVE_W32_SYSTEM*/
1367 }
1368
1369
1370 static void
1371 handle_signal (int signo)
1372 {
1373   switch (signo)
1374     {
1375 #ifndef HAVE_W32_SYSTEM
1376     case SIGHUP:
1377       log_info ("SIGHUP received - "
1378                 "re-reading configuration and flushing cache\n");
1379       agent_flush_cache ();
1380       reread_configuration ();
1381       agent_reload_trustlist ();
1382       break;
1383       
1384     case SIGUSR1:
1385       log_info ("SIGUSR1 received - printing internal information:\n");
1386       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1387       agent_query_dump_state ();
1388       agent_scd_dump_state ();
1389       break;
1390       
1391     case SIGUSR2:
1392       if (opt.verbose)
1393         log_info ("SIGUSR2 received - checking smartcard status\n");
1394       break;
1395
1396     case SIGTERM:
1397       if (!shutdown_pending)
1398         log_info ("SIGTERM received - shutting down ...\n");
1399       else
1400         log_info ("SIGTERM received - still %ld running threads\n",
1401                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1402       shutdown_pending++;
1403       if (shutdown_pending > 2)
1404         {
1405           log_info ("shutdown forced\n");
1406           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1407           cleanup ();
1408           agent_exit (0);
1409         }
1410       break;
1411         
1412     case SIGINT:
1413       log_info ("SIGINT received - immediate shutdown\n");
1414       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1415       cleanup ();
1416       agent_exit (0);
1417       break;
1418 #endif
1419     default:
1420       log_info ("signal %d received - no action defined\n", signo);
1421     }
1422 }
1423
1424
1425 /* This is the standard connection thread's main function.  */
1426 static void *
1427 start_connection_thread (void *arg)
1428 {
1429   int fd = (int)arg;
1430
1431   if (opt.verbose)
1432     log_info (_("handler 0x%lx for fd %d started\n"), 
1433               (long)pth_self (), fd);
1434
1435   start_command_handler (-1, fd);
1436   if (opt.verbose)
1437     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1438               (long)pth_self (), fd);
1439   
1440   return NULL;
1441 }
1442
1443
1444 /* This is the ssh connection thread's main function.  */
1445 static void *
1446 start_connection_thread_ssh (void *arg)
1447 {
1448   int fd = (int)arg;
1449
1450   if (opt.verbose)
1451     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1452               (long)pth_self (), fd);
1453
1454   start_command_handler_ssh (fd);
1455   if (opt.verbose)
1456     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1457               (long)pth_self (), fd);
1458   
1459   return NULL;
1460 }
1461
1462
1463 /* Connection handler loop.  Wait for coecntion requests and spawn a
1464    thread after accepting a connection.  */
1465 static void
1466 handle_connections (int listen_fd, int listen_fd_ssh)
1467 {
1468   pth_attr_t tattr;
1469   pth_event_t ev, time_ev;
1470   sigset_t sigs;
1471   int signo;
1472   struct sockaddr_un paddr;
1473   socklen_t plen;
1474   fd_set fdset, read_fdset;
1475   int ret;
1476   int fd;
1477
1478   tattr = pth_attr_new();
1479   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1480   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1481
1482 #ifndef HAVE_W32_SYSTEM /* fixme */
1483   /* Make sure that the signals we are going to handle are not blocked
1484      and create an event object for them. */
1485   sigemptyset (&sigs );
1486   sigaddset (&sigs, SIGHUP);
1487   sigaddset (&sigs, SIGUSR1);
1488   sigaddset (&sigs, SIGUSR2);
1489   sigaddset (&sigs, SIGINT);
1490   sigaddset (&sigs, SIGTERM);
1491   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1492   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1493 #else
1494   ev = NULL;
1495 #endif
1496   time_ev = NULL;
1497
1498   FD_ZERO (&fdset);
1499   FD_SET (listen_fd, &fdset);
1500   if (listen_fd_ssh != -1)
1501     FD_SET (listen_fd_ssh, &fdset);
1502
1503   for (;;)
1504     {
1505       sigset_t oldsigs;
1506
1507       if (shutdown_pending)
1508         {
1509           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1510             break; /* ready */
1511
1512           /* Do not accept anymore connections and wait for existing
1513              connections to terminate */
1514           signo = 0;
1515           pth_wait (ev);
1516           if (pth_event_occurred (ev) && signo)
1517             handle_signal (signo);
1518           continue;
1519         }
1520
1521       /* Create a timeout event if needed. */
1522       if (!time_ev)
1523         time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
1524
1525       /* POSIX says that fd_set should be implemented as a structure,
1526          thus a simple assignment is fine to copy the entire set.  */
1527       read_fdset = fdset;
1528
1529       if (time_ev)
1530         pth_event_concat (ev, time_ev, NULL);
1531       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1532       if (time_ev)
1533         pth_event_isolate (time_ev);
1534
1535       if (ret == -1)
1536         {
1537           if (pth_event_occurred (ev)
1538               || (time_ev && pth_event_occurred (time_ev)))
1539             {
1540               if (pth_event_occurred (ev))
1541                 handle_signal (signo);
1542               if (time_ev && pth_event_occurred (time_ev))
1543                 {
1544                   pth_event_free (time_ev, PTH_FREE_ALL);
1545                   time_ev = NULL;
1546                   handle_tick ();
1547                 }
1548               continue;
1549             }
1550           log_error (_("pth_select failed: %s - waiting 1s\n"),
1551                      strerror (errno));
1552           pth_sleep (1);
1553           continue;
1554         }
1555
1556       if (pth_event_occurred (ev))
1557         {
1558           handle_signal (signo);
1559         }
1560
1561       if (time_ev && pth_event_occurred (time_ev))
1562         {
1563           pth_event_free (time_ev, PTH_FREE_ALL);
1564           time_ev = NULL;
1565           handle_tick ();
1566         }
1567
1568       
1569       /* We now might create new threads and because we don't want any
1570          signals - we are handling here - to be delivered to a new
1571          thread. Thus we need to block those signals. */
1572       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1573
1574       if (FD_ISSET (listen_fd, &read_fdset))
1575         {
1576           plen = sizeof paddr;
1577           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1578           if (fd == -1)
1579             {
1580               log_error ("accept failed: %s\n", strerror (errno));
1581             }
1582           else 
1583             {
1584               char threadname[50];
1585               snprintf (threadname, sizeof threadname-1,
1586                         "conn fd=%d (gpg)", fd);
1587               threadname[sizeof threadname -1] = 0;
1588               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1589               if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1590                 {
1591                   log_error ("error spawning connection handler: %s\n",
1592                              strerror (errno) );
1593                   close (fd);
1594                 }
1595             }
1596           fd = -1;
1597         }
1598
1599       if (listen_fd_ssh != -1 && FD_ISSET (listen_fd_ssh, &read_fdset))
1600         {
1601           plen = sizeof paddr;
1602           fd = pth_accept (listen_fd_ssh, (struct sockaddr *)&paddr, &plen);
1603           if (fd == -1)
1604             {
1605               log_error ("accept failed for ssh: %s\n", strerror (errno));
1606             }
1607           else
1608             {
1609               char threadname[50];
1610               snprintf (threadname, sizeof threadname-1,
1611                         "conn fd=%d (ssh)", fd);
1612               threadname[sizeof threadname -1] = 0;
1613               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1614
1615               if (!pth_spawn (tattr, start_connection_thread_ssh, (void*)fd))
1616                 {
1617                   log_error ("error spawning ssh connection handler: %s\n",
1618                              strerror (errno) );
1619                   close (fd);
1620                 }
1621             }
1622           fd = -1;
1623         }
1624
1625       /* Restore the signal mask. */
1626       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1627
1628     }
1629
1630   pth_event_free (ev, PTH_FREE_ALL);
1631   if (time_ev)
1632     pth_event_free (time_ev, PTH_FREE_ALL);
1633   cleanup ();
1634   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1635 }
1636
1637
1638 /* Figure out whether an agent is available and running. Prints an
1639    error if not.  Usually started with MODE 0. */
1640 static int
1641 check_for_running_agent (int mode)
1642 {
1643   int rc;
1644   char *infostr, *p;
1645   assuan_context_t ctx;
1646   int prot, pid;
1647
1648   if (!mode)
1649     {
1650       infostr = getenv ("GPG_AGENT_INFO");
1651       if (!infostr || !*infostr)
1652         {
1653           if (!check_for_running_agent (1))
1654             return 0; /* Okay, its running on the standard socket. */
1655           log_error (_("no gpg-agent running in this session\n"));
1656           return -1;
1657         }
1658
1659       infostr = xstrdup (infostr);
1660       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1661         {
1662           xfree (infostr);
1663           if (!check_for_running_agent (1))
1664             return 0; /* Okay, its running on the standard socket. */
1665           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1666           return -1;
1667         }
1668
1669       *p++ = 0;
1670       pid = atoi (p);
1671       while (*p && *p != PATHSEP_C)
1672         p++;
1673       prot = *p? atoi (p+1) : 0;
1674       if (prot != 1)
1675         {
1676           xfree (infostr);
1677           log_error (_("gpg-agent protocol version %d is not supported\n"),
1678                      prot);
1679           if (!check_for_running_agent (1))
1680             return 0; /* Okay, its running on the standard socket. */
1681           return -1;
1682         }
1683     }
1684   else /* MODE != 0 */
1685     {
1686       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1687       pid = (pid_t)(-1);
1688     }
1689
1690
1691   rc = assuan_socket_connect (&ctx, infostr, pid);
1692   xfree (infostr);
1693   if (rc)
1694     {
1695       if (!mode && !check_for_running_agent (1))
1696         return 0; /* Okay, its running on the standard socket. */
1697
1698       if (!mode)
1699         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
1700       return -1;
1701     }
1702
1703   if (!opt.quiet)
1704     log_info ("gpg-agent running and available\n");
1705
1706   assuan_disconnect (ctx);
1707   return 0;
1708 }