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