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