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