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