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