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