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