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