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