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