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