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