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