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