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