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