jnlib/
[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       char *filename_esc;
697
698       /* List options and default values in the GPG Conf format.  */
699
700       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
701       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
702          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
703 #define GC_OPT_FLAG_NONE        0UL
704       /* The RUNTIME flag for an option indicates that the option can be
705          changed at runtime.  */
706 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
707       /* The DEFAULT flag for an option indicates that the option has a
708          default value.  */
709 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
710       /* The DEF_DESC flag for an option indicates that the option has a
711          default, which is described by the value of the default field.  */
712 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
713       /* The NO_ARG_DESC flag for an option indicates that the argument has
714          a default, which is described by the value of the ARGDEF field.  */
715 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
716
717       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
718       filename_esc = percent_escape (filename);
719
720       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
721               GC_OPT_FLAG_DEFAULT, filename_esc);
722       xfree (filename);
723       xfree (filename_esc);
724
725       printf ("verbose:%lu:\n"
726               "quiet:%lu:\n"
727               "debug-level:%lu:\"none:\n"
728               "log-file:%lu:\n",
729               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
730               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
731               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
732               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
733       printf ("default-cache-ttl:%lu:%d:\n",
734               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
735       printf ("default-cache-ttl-ssh:%lu:%d:\n",
736               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
737       printf ("max-cache-ttl:%lu:%d:\n",
738               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
739       printf ("max-cache-ttl-ssh:%lu:%d:\n",
740               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
741       printf ("min-passphrase-len:%lu:%d:\n",
742               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
743       printf ("no-grab:%lu:\n", 
744               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
745       printf ("ignore-cache-for-signing:%lu:\n",
746               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
747       printf ("allow-mark-trusted:%lu:\n",
748               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
749       printf ("disable-scdaemon:%lu:\n",
750               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
751
752       agent_exit (0);
753     }
754
755   /* If this has been called without any options, we merely check
756      whether an agent is already running.  We do this here so that we
757      don't clobber a logfile but print it directly to stderr. */
758   if (!pipe_server && !is_daemon)
759     {
760       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
761       check_for_running_agent (0);
762       agent_exit (0);
763     }
764   
765 #ifdef ENABLE_NLS
766   /* gpg-agent usually does not output any messages because it runs in
767      the background.  For log files it is acceptable to have messages
768      always encoded in utf-8.  We switch here to utf-8, so that
769      commands like --help still give native messages.  It is far
770      easier to switch only once instead of for every message and it
771      actually helps when more then one thread is active (avoids an
772      extra copy step). */
773     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
774 #endif
775
776   /* Now start with logging to a file if this is desired. */
777   if (logfile)
778     {
779       log_set_file (logfile);
780       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
781                              |JNLIB_LOG_WITH_TIME
782                              |JNLIB_LOG_WITH_PID));
783       current_logfile = xstrdup (logfile);
784     }
785
786   /* Make sure that we have a default ttyname. */
787   if (!default_ttyname && ttyname (1))
788     default_ttyname = xstrdup (ttyname (1));
789   if (!default_ttytype && getenv ("TERM"))
790     default_ttytype = xstrdup (getenv ("TERM"));
791
792
793   if (pipe_server)
794     { 
795       /* This is the simple pipe based server */
796       ctrl_t ctrl;
797
798       ctrl = xtrycalloc (1, sizeof *ctrl);
799       if (!ctrl)
800         {
801           log_error ("error allocating connection control data: %s\n",
802                      strerror (errno) );
803           agent_exit (1);
804         }
805       agent_init_default_ctrl (ctrl);
806       start_command_handler (ctrl, -1, -1);
807       agent_deinit_default_ctrl (ctrl);
808       xfree (ctrl);
809     }
810   else if (!is_daemon)
811     ; /* NOTREACHED */
812   else
813     { /* Regular server mode */
814       int fd;
815       int fd_ssh;
816       pid_t pid;
817
818       /* Remove the DISPLAY variable so that a pinentry does not
819          default to a specific display.  There is still a default
820          display when gpg-agent was started using --display or a
821          client requested this using an OPTION command.  Note, that we
822          don't do this when running in reverse daemon mode (i.e. when
823          exec the program given as arguments). */
824 #ifndef HAVE_W32_SYSTEM
825       if (!opt.keep_display && !argc)
826         unsetenv ("DISPLAY");
827 #endif
828
829
830       /* Create the sockets.  */
831       socket_name = create_socket_name (standard_socket,
832                                         "S.gpg-agent",
833                                         "/tmp/gpg-XXXXXX/S.gpg-agent");
834       if (opt.ssh_support)
835         socket_name_ssh = create_socket_name (standard_socket, 
836                                             "S.gpg-agent.ssh",
837                                             "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
838
839       fd = create_server_socket (standard_socket, socket_name);
840       if (opt.ssh_support)
841         fd_ssh = create_server_socket (standard_socket, socket_name_ssh);
842       else
843         fd_ssh = -1;
844
845       /* If we are going to exec a program in the parent, we record
846          the PID, so that the child may check whether the program is
847          still alive. */
848       if (argc)
849         parent_pid = getpid ();
850
851       fflush (NULL);
852 #ifdef HAVE_W32_SYSTEM
853       pid = getpid ();
854       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
855       w32_setup_taskbar ();
856 #else /*!HAVE_W32_SYSTEM*/
857       pid = fork ();
858       if (pid == (pid_t)-1) 
859         {
860           log_fatal ("fork failed: %s\n", strerror (errno) );
861           exit (1);
862         }
863       else if (pid) 
864         { /* We are the parent */
865           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
866           
867           close (fd);
868           
869           /* Create the info string: <name>:<pid>:<protocol_version> */
870           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
871                         socket_name, (ulong)pid ) < 0)
872             {
873               log_error ("out of core\n");
874               kill (pid, SIGTERM);
875               exit (1);
876             }
877           if (opt.ssh_support)
878             {
879               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
880                             socket_name_ssh) < 0)
881                 {
882                   log_error ("out of core\n");
883                   kill (pid, SIGTERM);
884                   exit (1);
885                 }
886               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
887                             pid) < 0)
888                 {
889                   log_error ("out of core\n");
890                   kill (pid, SIGTERM);
891                   exit (1);
892                 }
893             }
894
895           *socket_name = 0; /* Don't let cleanup() remove the socket -
896                                the child should do this from now on */
897           if (opt.ssh_support)
898             *socket_name_ssh = 0;
899
900           if (env_file_name)
901             {
902               FILE *fp;
903               
904               fp = fopen (env_file_name, "w");
905               if (!fp)
906                 log_error (_("error creating `%s': %s\n"),
907                              env_file_name, strerror (errno));
908               else
909                 {
910                   fputs (infostr, fp);
911                   putc ('\n', fp);
912                   if (opt.ssh_support)
913                     {
914                       fputs (infostr_ssh_sock, fp);
915                       putc ('\n', fp);
916                       fputs (infostr_ssh_pid, fp);
917                       putc ('\n', fp);
918                     }
919                   fclose (fp);
920                 }
921             }
922
923
924           if (argc) 
925             { /* Run the program given on the commandline.  */
926               if (putenv (infostr))
927                 {
928                   log_error ("failed to set environment: %s\n",
929                              strerror (errno) );
930                   kill (pid, SIGTERM );
931                   exit (1);
932                 }
933               if (opt.ssh_support && putenv (infostr_ssh_sock))
934                 {
935                   log_error ("failed to set environment: %s\n",
936                              strerror (errno) );
937                   kill (pid, SIGTERM );
938                   exit (1);
939                 }
940               if (opt.ssh_support && putenv (infostr_ssh_pid))
941                 {
942                   log_error ("failed to set environment: %s\n",
943                              strerror (errno) );
944                   kill (pid, SIGTERM );
945                   exit (1);
946                 }
947               execvp (argv[0], argv);
948               log_error ("failed to run the command: %s\n", strerror (errno));
949               kill (pid, SIGTERM);
950               exit (1);
951             }
952           else
953             {
954               /* Print the environment string, so that the caller can use
955                  shell's eval to set it */
956               if (csh_style)
957                 {
958                   *strchr (infostr, '=') = ' ';
959                   printf ("setenv %s\n", infostr);
960                   if (opt.ssh_support)
961                     {
962                       *strchr (infostr_ssh_sock, '=') = ' ';
963                       printf ("setenv %s\n", infostr_ssh_sock);
964                       *strchr (infostr_ssh_pid, '=') = ' ';
965                       printf ("setenv %s\n", infostr_ssh_pid);
966                     }
967                 }
968               else
969                 {
970                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
971                   if (opt.ssh_support)
972                     {
973                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
974                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
975                     }
976                 }
977               free (infostr); /* (Note that a vanilla free is here correct.) */
978               if (opt.ssh_support)
979                 {
980                   free (infostr_ssh_sock);
981                   free (infostr_ssh_pid);
982                 }
983               exit (0); 
984             }
985           /*NOTREACHED*/
986         } /* End parent */
987
988       /* 
989          This is the child
990        */
991
992       /* Detach from tty and put process into a new session */
993       if (!nodetach )
994         { 
995           int i;
996           unsigned int oldflags;
997
998           /* Close stdin, stdout and stderr unless it is the log stream */
999           for (i=0; i <= 2; i++) 
1000             {
1001               if (!log_test_fd (i) && i != fd )
1002                 {
1003                   if ( ! close (i)
1004                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1005                     {
1006                       log_error ("failed to open `%s': %s\n",
1007                                  "/dev/null", strerror (errno));
1008                       cleanup ();
1009                       exit (1);
1010                     }
1011                 }
1012             }
1013           if (setsid() == -1)
1014             {
1015               log_error ("setsid() failed: %s\n", strerror(errno) );
1016               cleanup ();
1017               exit (1);
1018             }
1019
1020           log_get_prefix (&oldflags);
1021           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1022           opt.running_detached = 1;
1023         }
1024
1025       if (chdir("/"))
1026         {
1027           log_error ("chdir to / failed: %s\n", strerror (errno));
1028           exit (1);
1029         }
1030
1031       {
1032         struct sigaction sa;
1033         
1034         sa.sa_handler = SIG_IGN;
1035         sigemptyset (&sa.sa_mask);
1036         sa.sa_flags = 0;
1037         sigaction (SIGPIPE, &sa, NULL);
1038       }
1039 #endif /*!HAVE_W32_SYSTEM*/
1040
1041       handle_connections (fd, opt.ssh_support ? fd_ssh : -1);
1042       close (fd);
1043     }
1044   
1045   return 0;
1046 }
1047
1048
1049 void
1050 agent_exit (int rc)
1051 {
1052   /*FIXME: update_random_seed_file();*/
1053 #if 1
1054   /* at this time a bit annoying */
1055   if (opt.debug & DBG_MEMSTAT_VALUE)
1056     {
1057       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1058       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1059     }
1060   if (opt.debug)
1061     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1062 #endif
1063   gcry_control (GCRYCTL_TERM_SECMEM );
1064   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1065   exit (rc);
1066 }
1067
1068 static void
1069 agent_init_default_ctrl (ctrl_t ctrl)
1070 {
1071   ctrl->connection_fd = -1;
1072
1073   /* Note we ignore malloc errors because we can't do much about it
1074      and the request will fail anyway shortly after this
1075      initialization. */
1076   if (ctrl->display)
1077     free (ctrl->display);
1078   ctrl->display = default_display? strdup (default_display) : NULL;
1079
1080   if (ctrl->ttyname)
1081     free (ctrl->ttyname);
1082   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
1083
1084   if (ctrl->ttytype)
1085     free (ctrl->ttytype);
1086   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1087
1088   if (ctrl->lc_ctype)
1089     free (ctrl->lc_ctype);
1090   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1091
1092   if (ctrl->lc_messages)
1093     free (ctrl->lc_messages);
1094   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1095 }
1096
1097
1098 static void
1099 agent_deinit_default_ctrl (ctrl_t ctrl)
1100 {
1101   if (ctrl->display)
1102     free (ctrl->display);
1103   if (ctrl->ttyname)
1104     free (ctrl->ttyname);
1105   if (ctrl->ttytype)
1106     free (ctrl->ttytype);
1107   if (ctrl->lc_ctype)
1108     free (ctrl->lc_ctype);
1109   if (ctrl->lc_messages)
1110     free (ctrl->lc_messages);
1111 }
1112
1113 /* Reread parts of the configuration.  Note, that this function is
1114    obviously not thread-safe and should only be called from the PTH
1115    signal handler. 
1116
1117    Fixme: Due to the way the argument parsing works, we create a
1118    memory leak here for all string type arguments.  There is currently
1119    no clean way to tell whether the memory for the argument has been
1120    allocated or points into the process' original arguments.  Unless
1121    we have a mechanism to tell this, we need to live on with this. */
1122 static void
1123 reread_configuration (void)
1124 {
1125   ARGPARSE_ARGS pargs;
1126   FILE *fp;
1127   unsigned int configlineno = 0;
1128   int dummy;
1129
1130   if (!config_filename)
1131     return; /* No config file. */
1132
1133   fp = fopen (config_filename, "r");
1134   if (!fp)
1135     {
1136       log_error (_("option file `%s': %s\n"),
1137                  config_filename, strerror(errno) );
1138       return;
1139     }
1140
1141   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1142
1143   memset (&pargs, 0, sizeof pargs);
1144   dummy = 0;
1145   pargs.argc = &dummy;
1146   pargs.flags = 1;  /* do not remove the args */
1147   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1148     {
1149       if (pargs.r_opt < -1)
1150         pargs.err = 1; /* Print a warning. */
1151       else /* Try to parse this option - ignore unchangeable ones. */
1152         parse_rereadable_options (&pargs, 1);
1153     }
1154   fclose (fp);
1155   set_debug ();
1156 }
1157
1158
1159 /* Return the file name of the socket we are using for native
1160    requests.  */
1161 const char *
1162 get_agent_socket_name (void)
1163 {
1164   const char *s = socket_name;
1165
1166   return (s && *s)? s : NULL;
1167 }
1168
1169 /* Return the file name of the socket we are using for SSH
1170    requests.  */
1171 const char *
1172 get_agent_ssh_socket_name (void)
1173 {
1174   const char *s = socket_name_ssh;
1175
1176   return (s && *s)? s : NULL;
1177 }
1178
1179
1180
1181 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1182    true using STANDARD_NAME in the home directory or if given as
1183    false from the mkdir type name TEMPLATE.  In the latter case a
1184    unique name in a unique new directory will be created.  In both
1185    cases check for valid characters as well as against a maximum
1186    allowed length for a unix domain socket is done.  The function
1187    terminates the process in case of an error.  Returns: Pointer to an
1188    allocated string with the absolute name of the socket used.  */
1189 static char *
1190 create_socket_name (int use_standard_socket,
1191                     char *standard_name, char *template)
1192 {
1193   char *name, *p;
1194
1195   if (use_standard_socket)
1196     name = make_filename (opt.homedir, standard_name, NULL);
1197   else
1198     {
1199       name = xstrdup (template);
1200       p = strrchr (name, '/');
1201       if (!p)
1202         BUG ();
1203       *p = 0;
1204       if (!mkdtemp (name))
1205         {
1206           log_error (_("can't create directory `%s': %s\n"),
1207                      name, strerror (errno));
1208           agent_exit (2);
1209         }
1210       *p = '/';
1211     }
1212
1213   if (strchr (name, PATHSEP_C))
1214     {
1215       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1216       agent_exit (2);
1217     }
1218   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1219     {
1220       log_error (_("name of socket too long\n"));
1221       agent_exit (2);
1222     }
1223   return name;
1224 }
1225
1226
1227
1228 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1229    whether a non-random socket is used.  Returns the filedescriptor or
1230    terminates the process in case of an error. */
1231 static int
1232 create_server_socket (int is_standard_name, const char *name)
1233 {
1234   struct sockaddr_un *serv_addr;
1235   socklen_t len;
1236   int fd;
1237   int rc;
1238
1239 #ifdef HAVE_W32_SYSTEM
1240   fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
1241 #else
1242   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1243 #endif
1244   if (fd == -1)
1245     {
1246       log_error (_("can't create socket: %s\n"), strerror (errno));
1247       agent_exit (2);
1248     }
1249
1250   serv_addr = xmalloc (sizeof (*serv_addr)); 
1251   memset (serv_addr, 0, sizeof *serv_addr);
1252   serv_addr->sun_family = AF_UNIX;
1253   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
1254   strcpy (serv_addr->sun_path, name);
1255   len = (offsetof (struct sockaddr_un, sun_path)
1256          + strlen (serv_addr->sun_path) + 1);
1257
1258 #ifdef HAVE_W32_SYSTEM
1259   rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1260   if (is_standard_name && rc == -1 )
1261     {
1262       remove (name);
1263       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1264     }
1265 #else
1266   rc = bind (fd, (struct sockaddr*) serv_addr, len);
1267   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1268     {
1269       remove (name);
1270       rc = bind (fd, (struct sockaddr*) serv_addr, len);
1271     }
1272 #endif
1273   if (rc == -1)
1274     {
1275       log_error (_("error binding socket to `%s': %s\n"),
1276                  serv_addr->sun_path, strerror (errno));
1277       close (fd);
1278       agent_exit (2);
1279     }
1280
1281   if (listen (fd, 5 ) == -1)
1282     {
1283       log_error (_("listen() failed: %s\n"), strerror (errno));
1284       close (fd);
1285       agent_exit (2);
1286     }
1287           
1288   if (opt.verbose)
1289     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1290
1291   return fd;
1292 }
1293
1294
1295 /* Check that the directory for storing the private keys exists and
1296    create it if not.  This function won't fail as it is only a
1297    convenience function and not strictly necessary.  */
1298 static void
1299 create_private_keys_directory (const char *home)
1300 {
1301   char *fname;
1302   struct stat statbuf;
1303
1304   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1305   if (stat (fname, &statbuf) && errno == ENOENT)
1306     {
1307 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1308       if (!CreateDirectory (fname, NULL))
1309         log_error (_("can't create directory `%s': %s\n"),
1310                    fname, w32_strerror (-1) );
1311 #else
1312       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1313         log_error (_("can't create directory `%s': %s\n"),
1314                    fname, strerror (errno) );
1315 #endif
1316       else if (!opt.quiet)
1317         log_info (_("directory `%s' created\n"), fname);
1318     }
1319   xfree (fname);
1320 }
1321
1322 /* Create the directory only if the supplied directory name is the
1323    same as the default one.  This way we avoid to create arbitrary
1324    directories when a non-default home directory is used.  To cope
1325    with HOME, we compare only the suffix if we see that the default
1326    homedir does start with a tilde.  We don't stop here in case of
1327    problems because other functions will throw an error anyway.*/
1328 static void
1329 create_directories (void)
1330 {
1331   struct stat statbuf;
1332 #ifdef HAVE_W32_SYSTEM
1333 #warning change it so that it works like in gpg.
1334 #endif
1335   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1336   char *home;
1337
1338   home = make_filename (opt.homedir, NULL);
1339   if ( stat (home, &statbuf) )
1340     {
1341       if (errno == ENOENT)
1342         {
1343           if ( (*defhome == '~'
1344                 && (strlen (home) >= strlen (defhome+1)
1345                     && !strcmp (home + strlen(home)
1346                                 - strlen (defhome+1), defhome+1)))
1347                || (*defhome != '~' && !strcmp (home, defhome) )
1348                )
1349             {
1350 #ifdef HAVE_W32_SYSTEM
1351               if (!CreateDirectory (home, NULL))
1352                 log_error (_("can't create directory `%s': %s\n"),
1353                            home, w32_strerror (-1) );
1354 #else
1355               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1356                 log_error (_("can't create directory `%s': %s\n"),
1357                            home, strerror (errno) );
1358 #endif
1359               else 
1360                 {
1361                   if (!opt.quiet)
1362                     log_info (_("directory `%s' created\n"), home);
1363                   create_private_keys_directory (home);
1364                 }
1365             }
1366         }
1367       else
1368         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1369     }
1370   else if ( !S_ISDIR(statbuf.st_mode))
1371     {
1372       log_error (_("can't use `%s' as home directory\n"), home);
1373     }
1374   else /* exists and is a directory. */
1375     {
1376       create_private_keys_directory (home);
1377     }
1378   xfree (home);
1379 }
1380
1381
1382
1383 /* This is the worker for the ticker.  It is called every few seconds
1384    and may only do fast operations. */
1385 static void
1386 handle_tick (void)
1387 {
1388   /* Check whether the scdaemon has died and cleanup in this case. */
1389   agent_scd_check_aliveness ();
1390
1391   /* If we are running as a child of another process, check whether
1392      the parent is still alive and shutdown if not. */
1393 #ifndef HAVE_W32_SYSTEM
1394   if (parent_pid != (pid_t)(-1))
1395     {
1396       if (kill (parent_pid, 0))
1397         {
1398           shutdown_pending = 2;
1399           log_info ("parent process died - shutting down\n");
1400           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1401           cleanup ();
1402           agent_exit (0);
1403         }
1404     }
1405 #endif /*HAVE_W32_SYSTEM*/
1406 }
1407
1408
1409 static void
1410 handle_signal (int signo)
1411 {
1412   switch (signo)
1413     {
1414 #ifndef HAVE_W32_SYSTEM
1415     case SIGHUP:
1416       log_info ("SIGHUP received - "
1417                 "re-reading configuration and flushing cache\n");
1418       agent_flush_cache ();
1419       reread_configuration ();
1420       agent_reload_trustlist ();
1421       break;
1422       
1423     case SIGUSR1:
1424       log_info ("SIGUSR1 received - printing internal information:\n");
1425       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1426       agent_query_dump_state ();
1427       agent_scd_dump_state ();
1428       break;
1429       
1430     case SIGUSR2:
1431       if (opt.verbose)
1432         log_info ("SIGUSR2 received - checking smartcard status\n");
1433       /* Nothing to check right now.  We only increment a counter.  */
1434       bump_card_eventcounter ();
1435       break;
1436
1437     case SIGTERM:
1438       if (!shutdown_pending)
1439         log_info ("SIGTERM received - shutting down ...\n");
1440       else
1441         log_info ("SIGTERM received - still %ld running threads\n",
1442                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1443       shutdown_pending++;
1444       if (shutdown_pending > 2)
1445         {
1446           log_info ("shutdown forced\n");
1447           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1448           cleanup ();
1449           agent_exit (0);
1450         }
1451       break;
1452         
1453     case SIGINT:
1454       log_info ("SIGINT received - immediate shutdown\n");
1455       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1456       cleanup ();
1457       agent_exit (0);
1458       break;
1459 #endif
1460     default:
1461       log_info ("signal %d received - no action defined\n", signo);
1462     }
1463 }
1464
1465
1466 /* This is the standard connection thread's main function.  */
1467 static void *
1468 start_connection_thread (void *arg)
1469 {
1470   ctrl_t ctrl = arg;
1471
1472   agent_init_default_ctrl (ctrl);
1473   if (opt.verbose)
1474     log_info (_("handler 0x%lx for fd %d started\n"), 
1475               (long)pth_self (), ctrl->thread_startup.fd);
1476
1477   start_command_handler (ctrl, -1, ctrl->thread_startup.fd);
1478   if (opt.verbose)
1479     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1480               (long)pth_self (), ctrl->thread_startup.fd);
1481   
1482   agent_deinit_default_ctrl (ctrl);
1483   xfree (ctrl);
1484   return NULL;
1485 }
1486
1487
1488 /* This is the ssh connection thread's main function.  */
1489 static void *
1490 start_connection_thread_ssh (void *arg)
1491 {
1492   ctrl_t ctrl = arg;
1493
1494   agent_init_default_ctrl (ctrl);
1495   if (opt.verbose)
1496     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1497               (long)pth_self (), ctrl->thread_startup.fd);
1498
1499   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1500   if (opt.verbose)
1501     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1502               (long)pth_self (), ctrl->thread_startup.fd);
1503   
1504   agent_deinit_default_ctrl (ctrl);
1505   xfree (ctrl);
1506   return NULL;
1507 }
1508
1509
1510 /* Connection handler loop.  Wait for connection requests and spawn a
1511    thread after accepting a connection.  */
1512 static void
1513 handle_connections (int listen_fd, int listen_fd_ssh)
1514 {
1515   pth_attr_t tattr;
1516   pth_event_t ev, time_ev;
1517   sigset_t sigs;
1518   int signo;
1519   struct sockaddr_un paddr;
1520   socklen_t plen;
1521   fd_set fdset, read_fdset;
1522   int ret;
1523   int fd;
1524
1525   tattr = pth_attr_new();
1526   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1527   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1528
1529 #ifndef HAVE_W32_SYSTEM /* fixme */
1530   /* Make sure that the signals we are going to handle are not blocked
1531      and create an event object for them. */
1532   sigemptyset (&sigs );
1533   sigaddset (&sigs, SIGHUP);
1534   sigaddset (&sigs, SIGUSR1);
1535   sigaddset (&sigs, SIGUSR2);
1536   sigaddset (&sigs, SIGINT);
1537   sigaddset (&sigs, SIGTERM);
1538   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1539   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1540 #else
1541   ev = NULL;
1542   signo = 0;
1543 #endif
1544   time_ev = NULL;
1545
1546   FD_ZERO (&fdset);
1547   FD_SET (listen_fd, &fdset);
1548   if (listen_fd_ssh != -1)
1549     FD_SET (listen_fd_ssh, &fdset);
1550
1551   for (;;)
1552     {
1553       sigset_t oldsigs;
1554
1555 #ifdef HAVE_W32_SYSTEM
1556       w32_poll_events ();
1557 #endif
1558
1559       if (shutdown_pending)
1560         {
1561           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1562             break; /* ready */
1563
1564           /* Do not accept anymore connections and wait for existing
1565              connections to terminate */
1566           signo = 0;
1567           pth_wait (ev);
1568           if (pth_event_occurred (ev) && signo)
1569             handle_signal (signo);
1570           continue;
1571         }
1572
1573       /* Create a timeout event if needed. */
1574       if (!time_ev)
1575         time_ev = pth_event (PTH_EVENT_TIME, pth_timeout (2, 0));
1576
1577       /* POSIX says that fd_set should be implemented as a structure,
1578          thus a simple assignment is fine to copy the entire set.  */
1579       read_fdset = fdset;
1580
1581       if (time_ev)
1582         pth_event_concat (ev, time_ev, NULL);
1583       ret = pth_select_ev (FD_SETSIZE, &read_fdset, NULL, NULL, NULL, ev);
1584       if (time_ev)
1585         pth_event_isolate (time_ev);
1586
1587       if (ret == -1)
1588         {
1589           if (pth_event_occurred (ev)
1590               || (time_ev && pth_event_occurred (time_ev)))
1591             {
1592               if (pth_event_occurred (ev))
1593                 handle_signal (signo);
1594               if (time_ev && pth_event_occurred (time_ev))
1595                 {
1596                   pth_event_free (time_ev, PTH_FREE_ALL);
1597                   time_ev = NULL;
1598                   handle_tick ();
1599                 }
1600               continue;
1601             }
1602           log_error (_("pth_select failed: %s - waiting 1s\n"),
1603                      strerror (errno));
1604           pth_sleep (1);
1605           continue;
1606         }
1607
1608       if (pth_event_occurred (ev))
1609         {
1610           handle_signal (signo);
1611         }
1612
1613       if (time_ev && pth_event_occurred (time_ev))
1614         {
1615           pth_event_free (time_ev, PTH_FREE_ALL);
1616           time_ev = NULL;
1617           handle_tick ();
1618         }
1619
1620       
1621       /* We now might create new threads and because we don't want any
1622          signals - we are handling here - to be delivered to a new
1623          thread. Thus we need to block those signals. */
1624       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1625
1626       if (FD_ISSET (listen_fd, &read_fdset))
1627         {
1628           ctrl_t ctrl;
1629
1630           plen = sizeof paddr;
1631           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1632           if (fd == -1)
1633             {
1634               log_error ("accept failed: %s\n", strerror (errno));
1635             }
1636           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1637             {
1638               log_error ("error allocating connection control data: %s\n",
1639                          strerror (errno) );
1640               close (fd);
1641             }
1642           else 
1643             {
1644               char threadname[50];
1645
1646               snprintf (threadname, sizeof threadname-1,
1647                         "conn fd=%d (gpg)", fd);
1648               threadname[sizeof threadname -1] = 0;
1649               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1650               ctrl->thread_startup.fd = fd;
1651               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1652                 {
1653                   log_error ("error spawning connection handler: %s\n",
1654                              strerror (errno) );
1655                   close (fd);
1656                   xfree (ctrl);
1657                 }
1658             }
1659           fd = -1;
1660         }
1661
1662       if (listen_fd_ssh != -1 && FD_ISSET (listen_fd_ssh, &read_fdset))
1663         {
1664           ctrl_t ctrl;
1665
1666           plen = sizeof paddr;
1667           fd = pth_accept (listen_fd_ssh, (struct sockaddr *)&paddr, &plen);
1668           if (fd == -1)
1669             {
1670               log_error ("accept failed for ssh: %s\n", strerror (errno));
1671             }
1672           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1673             {
1674               log_error ("error allocating connection control data: %s\n",
1675                          strerror (errno) );
1676               close (fd);
1677             }
1678           else
1679             {
1680               char threadname[50];
1681
1682               agent_init_default_ctrl (ctrl);
1683               snprintf (threadname, sizeof threadname-1,
1684                         "conn fd=%d (ssh)", fd);
1685               threadname[sizeof threadname -1] = 0;
1686               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1687               ctrl->thread_startup.fd = fd;
1688               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
1689                 {
1690                   log_error ("error spawning ssh connection handler: %s\n",
1691                              strerror (errno) );
1692                   close (fd);
1693                   xfree (ctrl);
1694                 }
1695             }
1696           fd = -1;
1697         }
1698
1699       /* Restore the signal mask. */
1700       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1701
1702     }
1703
1704   pth_event_free (ev, PTH_FREE_ALL);
1705   if (time_ev)
1706     pth_event_free (time_ev, PTH_FREE_ALL);
1707   cleanup ();
1708   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1709 }
1710
1711
1712 /* Figure out whether an agent is available and running. Prints an
1713    error if not.  Usually started with MODE 0. */
1714 static int
1715 check_for_running_agent (int mode)
1716 {
1717   int rc;
1718   char *infostr, *p;
1719   assuan_context_t ctx;
1720   int prot, pid;
1721
1722   if (!mode)
1723     {
1724       infostr = getenv ("GPG_AGENT_INFO");
1725       if (!infostr || !*infostr)
1726         {
1727           if (!check_for_running_agent (1))
1728             return 0; /* Okay, its running on the standard socket. */
1729           log_error (_("no gpg-agent running in this session\n"));
1730           return -1;
1731         }
1732
1733       infostr = xstrdup (infostr);
1734       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1735         {
1736           xfree (infostr);
1737           if (!check_for_running_agent (1))
1738             return 0; /* Okay, its running on the standard socket. */
1739           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1740           return -1;
1741         }
1742
1743       *p++ = 0;
1744       pid = atoi (p);
1745       while (*p && *p != PATHSEP_C)
1746         p++;
1747       prot = *p? atoi (p+1) : 0;
1748       if (prot != 1)
1749         {
1750           xfree (infostr);
1751           log_error (_("gpg-agent protocol version %d is not supported\n"),
1752                      prot);
1753           if (!check_for_running_agent (1))
1754             return 0; /* Okay, its running on the standard socket. */
1755           return -1;
1756         }
1757     }
1758   else /* MODE != 0 */
1759     {
1760       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1761       pid = (pid_t)(-1);
1762     }
1763
1764
1765   rc = assuan_socket_connect (&ctx, infostr, pid);
1766   xfree (infostr);
1767   if (rc)
1768     {
1769       if (!mode && !check_for_running_agent (1))
1770         return 0; /* Okay, its running on the standard socket. */
1771
1772       if (!mode)
1773         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
1774       return -1;
1775     }
1776
1777   if (!opt.quiet)
1778     log_info ("gpg-agent running and available\n");
1779
1780   assuan_disconnect (ctx);
1781   return 0;
1782 }