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