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