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