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