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