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