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