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