Change all quotes in strings and comments to the new GNU standard.
[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 = 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 && 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;
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             }
1108
1109           *socket_name = 0; /* Don't let cleanup() remove the socket -
1110                                the child should do this from now on */
1111           if (opt.ssh_support)
1112             *socket_name_ssh = 0;
1113
1114           if (env_file_name)
1115             {
1116               estream_t fp;
1117
1118               fp = es_fopen (env_file_name, "w,mode=-rw");
1119               if (!fp)
1120                 log_error (_("error creating '%s': %s\n"),
1121                              env_file_name, strerror (errno));
1122               else
1123                 {
1124                   es_fputs (infostr, fp);
1125                   es_putc ('\n', fp);
1126                   if (opt.ssh_support)
1127                     {
1128                       es_fputs (infostr_ssh_sock, fp);
1129                       es_putc ('\n', fp);
1130                     }
1131                   es_fclose (fp);
1132                 }
1133             }
1134
1135
1136           if (argc)
1137             { /* Run the program given on the commandline.  */
1138               if (putenv (infostr))
1139                 {
1140                   log_error ("failed to set environment: %s\n",
1141                              strerror (errno) );
1142                   kill (pid, SIGTERM );
1143                   exit (1);
1144                 }
1145               if (opt.ssh_support && putenv (infostr_ssh_sock))
1146                 {
1147                   log_error ("failed to set environment: %s\n",
1148                              strerror (errno) );
1149                   kill (pid, SIGTERM );
1150                   exit (1);
1151                 }
1152
1153               /* Close all the file descriptors except the standard
1154                  ones and those open at startup.  We explicitly don't
1155                  close 0,1,2 in case something went wrong collecting
1156                  them at startup.  */
1157               close_all_fds (3, startup_fd_list);
1158
1159               /* Run the command.  */
1160               execvp (argv[0], argv);
1161               log_error ("failed to run the command: %s\n", strerror (errno));
1162               kill (pid, SIGTERM);
1163               exit (1);
1164             }
1165           else
1166             {
1167               /* Print the environment string, so that the caller can use
1168                  shell's eval to set it */
1169               if (csh_style)
1170                 {
1171                   *strchr (infostr, '=') = ' ';
1172                   es_printf ("setenv %s;\n", infostr);
1173                   if (opt.ssh_support)
1174                     {
1175                       *strchr (infostr_ssh_sock, '=') = ' ';
1176                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1177                     }
1178                 }
1179               else
1180                 {
1181                   es_printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1182                   if (opt.ssh_support)
1183                     {
1184                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1185                                  infostr_ssh_sock);
1186                     }
1187                 }
1188               xfree (infostr);
1189               if (opt.ssh_support)
1190                 {
1191                   xfree (infostr_ssh_sock);
1192                 }
1193               exit (0);
1194             }
1195           /*NOTREACHED*/
1196         } /* End parent */
1197
1198       /*
1199          This is the child
1200        */
1201
1202       /* Detach from tty and put process into a new session */
1203       if (!nodetach )
1204         {
1205           int i;
1206           unsigned int oldflags;
1207
1208           /* Close stdin, stdout and stderr unless it is the log stream */
1209           for (i=0; i <= 2; i++)
1210             {
1211               if (!log_test_fd (i) && i != fd )
1212                 {
1213                   if ( ! close (i)
1214                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1215                     {
1216                       log_error ("failed to open '%s': %s\n",
1217                                  "/dev/null", strerror (errno));
1218                       cleanup ();
1219                       exit (1);
1220                     }
1221                 }
1222             }
1223           if (setsid() == -1)
1224             {
1225               log_error ("setsid() failed: %s\n", strerror(errno) );
1226               cleanup ();
1227               exit (1);
1228             }
1229
1230           log_get_prefix (&oldflags);
1231           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1232           opt.running_detached = 1;
1233         }
1234
1235       if (chdir("/"))
1236         {
1237           log_error ("chdir to / failed: %s\n", strerror (errno));
1238           exit (1);
1239         }
1240
1241       {
1242         struct sigaction sa;
1243
1244         sa.sa_handler = SIG_IGN;
1245         sigemptyset (&sa.sa_mask);
1246         sa.sa_flags = 0;
1247         sigaction (SIGPIPE, &sa, NULL);
1248       }
1249 #endif /*!HAVE_W32_SYSTEM*/
1250
1251       log_info ("%s %s started\n", strusage(11), strusage(13) );
1252       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1253       assuan_sock_close (fd);
1254     }
1255
1256   return 0;
1257 }
1258
1259
1260 /* Exit entry point.  This function should be called instead of a
1261    plain exit.  */
1262 void
1263 agent_exit (int rc)
1264 {
1265   /*FIXME: update_random_seed_file();*/
1266
1267   /* We run our cleanup handler because that may close cipher contexts
1268      stored in secure memory and thus this needs to be done before we
1269      explicitly terminate secure memory.  */
1270   cleanup ();
1271
1272 #if 1
1273   /* at this time a bit annoying */
1274   if (opt.debug & DBG_MEMSTAT_VALUE)
1275     {
1276       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1277       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1278     }
1279   if (opt.debug)
1280     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1281 #endif
1282   gcry_control (GCRYCTL_TERM_SECMEM );
1283   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1284   exit (rc);
1285 }
1286
1287
1288 /* Each thread has its own local variables conveyed by a control
1289    structure usually identified by an argument named CTRL.  This
1290    function is called immediately after allocating the control
1291    structure.  Its purpose is to setup the default values for that
1292    structure.  */
1293 static void
1294 agent_init_default_ctrl (ctrl_t ctrl)
1295 {
1296   /* Note we ignore malloc errors because we can't do much about it
1297      and the request will fail anyway shortly after this
1298      initialization. */
1299   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1300   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1301   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1302   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1303   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1304
1305   if (ctrl->lc_ctype)
1306     xfree (ctrl->lc_ctype);
1307   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1308
1309   if (ctrl->lc_messages)
1310     xfree (ctrl->lc_messages);
1311   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1312                                     /**/ : NULL;
1313
1314   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1315 }
1316
1317
1318 /* Release all resources allocated by default in the control
1319    structure.  This is the counterpart to agent_init_default_ctrl.  */
1320 static void
1321 agent_deinit_default_ctrl (ctrl_t ctrl)
1322 {
1323   session_env_release (ctrl->session_env);
1324
1325   if (ctrl->lc_ctype)
1326     xfree (ctrl->lc_ctype);
1327   if (ctrl->lc_messages)
1328     xfree (ctrl->lc_messages);
1329 }
1330
1331
1332 /* Reread parts of the configuration.  Note, that this function is
1333    obviously not thread-safe and should only be called from the PTH
1334    signal handler.
1335
1336    Fixme: Due to the way the argument parsing works, we create a
1337    memory leak here for all string type arguments.  There is currently
1338    no clean way to tell whether the memory for the argument has been
1339    allocated or points into the process' original arguments.  Unless
1340    we have a mechanism to tell this, we need to live on with this. */
1341 static void
1342 reread_configuration (void)
1343 {
1344   ARGPARSE_ARGS pargs;
1345   FILE *fp;
1346   unsigned int configlineno = 0;
1347   int dummy;
1348
1349   if (!config_filename)
1350     return; /* No config file. */
1351
1352   fp = fopen (config_filename, "r");
1353   if (!fp)
1354     {
1355       log_info (_("option file '%s': %s\n"),
1356                 config_filename, strerror(errno) );
1357       return;
1358     }
1359
1360   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1361
1362   memset (&pargs, 0, sizeof pargs);
1363   dummy = 0;
1364   pargs.argc = &dummy;
1365   pargs.flags = 1;  /* do not remove the args */
1366   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1367     {
1368       if (pargs.r_opt < -1)
1369         pargs.err = 1; /* Print a warning. */
1370       else /* Try to parse this option - ignore unchangeable ones. */
1371         parse_rereadable_options (&pargs, 1);
1372     }
1373   fclose (fp);
1374   set_debug ();
1375 }
1376
1377
1378 /* Return the file name of the socket we are using for native
1379    requests.  */
1380 const char *
1381 get_agent_socket_name (void)
1382 {
1383   const char *s = socket_name;
1384
1385   return (s && *s)? s : NULL;
1386 }
1387
1388 /* Return the file name of the socket we are using for SSH
1389    requests.  */
1390 const char *
1391 get_agent_ssh_socket_name (void)
1392 {
1393   const char *s = socket_name_ssh;
1394
1395   return (s && *s)? s : NULL;
1396 }
1397
1398
1399 /* Under W32, this function returns the handle of the scdaemon
1400    notification event.  Calling it the first time creates that
1401    event.  */
1402 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1403 void *
1404 get_agent_scd_notify_event (void)
1405 {
1406   static HANDLE the_event = INVALID_HANDLE_VALUE;
1407
1408   if (the_event == INVALID_HANDLE_VALUE)
1409     {
1410       HANDLE h, h2;
1411       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1412
1413       /* We need to use a manual reset event object due to the way our
1414          w32-pth wait function works: If we would use an automatic
1415          reset event we are not able to figure out which handle has
1416          been signaled because at the time we single out the signaled
1417          handles using WFSO the event has already been reset due to
1418          the WFMO.  */
1419       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1420       if (!h)
1421         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1422       else if (!DuplicateHandle (GetCurrentProcess(), h,
1423                                  GetCurrentProcess(), &h2,
1424                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1425         {
1426           log_error ("setting syncronize for scd notify event failed: %s\n",
1427                      w32_strerror (-1) );
1428           CloseHandle (h);
1429         }
1430       else
1431         {
1432           CloseHandle (h);
1433           the_event = h2;
1434         }
1435     }
1436
1437   return the_event;
1438 }
1439 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1440
1441
1442
1443 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1444    true using STANDARD_NAME in the home directory or if given as
1445    false from the mkdir type name TEMPLATE.  In the latter case a
1446    unique name in a unique new directory will be created.  In both
1447    cases check for valid characters as well as against a maximum
1448    allowed length for a unix domain socket is done.  The function
1449    terminates the process in case of an error.  Returns: Pointer to an
1450    allocated string with the absolute name of the socket used.  */
1451 static char *
1452 create_socket_name (char *standard_name, char *template)
1453 {
1454   char *name, *p;
1455
1456   if (opt.use_standard_socket)
1457     name = make_filename (opt.homedir, standard_name, NULL);
1458   else
1459     {
1460       /* Prepend the tmp directory to the template.  */
1461       p = getenv ("TMPDIR");
1462       if (!p || !*p)
1463         p = "/tmp";
1464       if (p[strlen (p) - 1] == '/')
1465         name = xstrconcat (p, template, NULL);
1466       else
1467         name = xstrconcat (p, "/", template, NULL);
1468
1469       p = strrchr (name, '/');
1470       if (!p)
1471         BUG ();
1472       *p = 0;
1473       if (!mkdtemp (name))
1474         {
1475           log_error (_("can't create directory '%s': %s\n"),
1476                      name, strerror (errno));
1477           agent_exit (2);
1478         }
1479       *p = '/';
1480     }
1481
1482   if (strchr (name, PATHSEP_C))
1483     {
1484       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1485       agent_exit (2);
1486     }
1487   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1488     {
1489       log_error (_("name of socket too long\n"));
1490       agent_exit (2);
1491     }
1492   return name;
1493 }
1494
1495
1496
1497 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1498    or terminates the process in case of an error.  Not that this
1499    function needs to be used for the regular socket first and only
1500    then for the ssh socket.  */
1501 static gnupg_fd_t
1502 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1503 {
1504   struct sockaddr_un *serv_addr;
1505   socklen_t len;
1506   gnupg_fd_t fd;
1507   int rc;
1508
1509   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1510   if (fd == ASSUAN_INVALID_FD)
1511     {
1512       log_error (_("can't create socket: %s\n"), strerror (errno));
1513       agent_exit (2);
1514     }
1515
1516   serv_addr = xmalloc (sizeof (*serv_addr));
1517   memset (serv_addr, 0, sizeof *serv_addr);
1518   serv_addr->sun_family = AF_UNIX;
1519   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1520     {
1521       log_error (_("socket name '%s' is too long\n"), name);
1522       agent_exit (2);
1523     }
1524   strcpy (serv_addr->sun_path, name);
1525   len = SUN_LEN (serv_addr);
1526   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1527
1528   /* Our error code mapping on W32CE returns EEXIST thus we also test
1529      for this. */
1530   if (opt.use_standard_socket && rc == -1
1531       && (errno == EADDRINUSE
1532 #ifdef HAVE_W32_SYSTEM
1533           || errno == EEXIST
1534 #endif
1535           ))
1536     {
1537       /* Check whether a gpg-agent is already running on the standard
1538          socket.  We do this test only if this is not the ssh socket.
1539          For ssh we assume that a test for gpg-agent has already been
1540          done and reuse the requested ssh socket.  Testing the
1541          ssh-socket is not possible because at this point, though we
1542          know the new Assuan socket, the Assuan server and thus the
1543          ssh-agent server is not yet operational.  This would lead to
1544          a hang.  */
1545       if (!is_ssh && !check_for_running_agent (1, 1))
1546         {
1547           log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
1548           log_set_file (NULL);
1549           log_error (_("a gpg-agent is already running - "
1550                        "not starting a new one\n"));
1551           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1552           assuan_sock_close (fd);
1553           agent_exit (2);
1554         }
1555       gnupg_remove (name);
1556       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1557     }
1558   if (rc != -1
1559       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1560     log_error (_("error getting nonce for the socket\n"));
1561   if (rc == -1)
1562     {
1563       /* We use gpg_strerror here because it allows us to get strings
1564          for some W32 socket error codes.  */
1565       log_error (_("error binding socket to '%s': %s\n"),
1566                  serv_addr->sun_path,
1567                  gpg_strerror (gpg_error_from_errno (errno)));
1568
1569       assuan_sock_close (fd);
1570       if (opt.use_standard_socket)
1571         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1572       agent_exit (2);
1573     }
1574
1575   if (listen (FD2INT(fd), 5 ) == -1)
1576     {
1577       log_error (_("listen() failed: %s\n"), strerror (errno));
1578       assuan_sock_close (fd);
1579       agent_exit (2);
1580     }
1581
1582   if (opt.verbose)
1583     log_info (_("listening on socket '%s'\n"), serv_addr->sun_path);
1584
1585   return fd;
1586 }
1587
1588
1589 /* Check that the directory for storing the private keys exists and
1590    create it if not.  This function won't fail as it is only a
1591    convenience function and not strictly necessary.  */
1592 static void
1593 create_private_keys_directory (const char *home)
1594 {
1595   char *fname;
1596   struct stat statbuf;
1597
1598   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1599   if (stat (fname, &statbuf) && errno == ENOENT)
1600     {
1601       if (gnupg_mkdir (fname, "-rwx"))
1602         log_error (_("can't create directory '%s': %s\n"),
1603                    fname, strerror (errno) );
1604       else if (!opt.quiet)
1605         log_info (_("directory '%s' created\n"), fname);
1606     }
1607   xfree (fname);
1608 }
1609
1610 /* Create the directory only if the supplied directory name is the
1611    same as the default one.  This way we avoid to create arbitrary
1612    directories when a non-default home directory is used.  To cope
1613    with HOME, we compare only the suffix if we see that the default
1614    homedir does start with a tilde.  We don't stop here in case of
1615    problems because other functions will throw an error anyway.*/
1616 static void
1617 create_directories (void)
1618 {
1619   struct stat statbuf;
1620   const char *defhome = standard_homedir ();
1621   char *home;
1622
1623   home = make_filename (opt.homedir, NULL);
1624   if ( stat (home, &statbuf) )
1625     {
1626       if (errno == ENOENT)
1627         {
1628           if (
1629 #ifdef HAVE_W32_SYSTEM
1630               ( !compare_filenames (home, defhome) )
1631 #else
1632               (*defhome == '~'
1633                 && (strlen (home) >= strlen (defhome+1)
1634                     && !strcmp (home + strlen(home)
1635                                 - strlen (defhome+1), defhome+1)))
1636                || (*defhome != '~' && !strcmp (home, defhome) )
1637 #endif
1638                )
1639             {
1640               if (gnupg_mkdir (home, "-rwx"))
1641                 log_error (_("can't create directory '%s': %s\n"),
1642                            home, strerror (errno) );
1643               else
1644                 {
1645                   if (!opt.quiet)
1646                     log_info (_("directory '%s' created\n"), home);
1647                   create_private_keys_directory (home);
1648                 }
1649             }
1650         }
1651       else
1652         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1653     }
1654   else if ( !S_ISDIR(statbuf.st_mode))
1655     {
1656       log_error (_("can't use '%s' as home directory\n"), home);
1657     }
1658   else /* exists and is a directory. */
1659     {
1660       create_private_keys_directory (home);
1661     }
1662   xfree (home);
1663 }
1664
1665
1666
1667 /* This is the worker for the ticker.  It is called every few seconds
1668    and may only do fast operations. */
1669 static void
1670 handle_tick (void)
1671 {
1672   static time_t last_minute;
1673
1674   if (!last_minute)
1675     last_minute = time (NULL);
1676
1677   /* Check whether the scdaemon has died and cleanup in this case. */
1678   agent_scd_check_aliveness ();
1679
1680   /* If we are running as a child of another process, check whether
1681      the parent is still alive and shutdown if not. */
1682 #ifndef HAVE_W32_SYSTEM
1683   if (parent_pid != (pid_t)(-1))
1684     {
1685       if (kill (parent_pid, 0))
1686         {
1687           shutdown_pending = 2;
1688           log_info ("parent process died - shutting down\n");
1689           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1690           cleanup ();
1691           agent_exit (0);
1692         }
1693     }
1694 #endif /*HAVE_W32_SYSTEM*/
1695
1696   /* Code to be run from time to time.  */
1697 #if CHECK_OWN_SOCKET_INTERVAL > 0
1698   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1699     {
1700       check_own_socket ();
1701       last_minute = time (NULL);
1702     }
1703 #endif
1704
1705 }
1706
1707
1708 /* A global function which allows us to call the reload stuff from
1709    other places too.  This is only used when build for W32.  */
1710 void
1711 agent_sighup_action (void)
1712 {
1713   log_info ("SIGHUP received - "
1714             "re-reading configuration and flushing cache\n");
1715   agent_flush_cache ();
1716   reread_configuration ();
1717   agent_reload_trustlist ();
1718 }
1719
1720
1721 /* A helper function to handle SIGUSR2.  */
1722 static void
1723 agent_sigusr2_action (void)
1724 {
1725   if (opt.verbose)
1726     log_info ("SIGUSR2 received - updating card event counter\n");
1727   /* Nothing to check right now.  We only increment a counter.  */
1728   bump_card_eventcounter ();
1729 }
1730
1731
1732 #ifndef HAVE_W32_SYSTEM
1733 /* The signal handler for this program.  It is expected to be run in
1734    its own trhead and not in the context of a signal handler.  */
1735 static void
1736 handle_signal (int signo)
1737 {
1738   switch (signo)
1739     {
1740 #ifndef HAVE_W32_SYSTEM
1741     case SIGHUP:
1742       agent_sighup_action ();
1743       break;
1744
1745     case SIGUSR1:
1746       log_info ("SIGUSR1 received - printing internal information:\n");
1747       /* Fixme: We need to see how to integrate pth dumping into our
1748          logging system.  */
1749       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1750       agent_query_dump_state ();
1751       agent_scd_dump_state ();
1752       break;
1753
1754     case SIGUSR2:
1755       agent_sigusr2_action ();
1756       break;
1757
1758     case SIGTERM:
1759       if (!shutdown_pending)
1760         log_info ("SIGTERM received - shutting down ...\n");
1761       else
1762         log_info ("SIGTERM received - still %i open connections\n",
1763                   active_connections);
1764       shutdown_pending++;
1765       if (shutdown_pending > 2)
1766         {
1767           log_info ("shutdown forced\n");
1768           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1769           cleanup ();
1770           agent_exit (0);
1771         }
1772       break;
1773
1774     case SIGINT:
1775       log_info ("SIGINT received - immediate shutdown\n");
1776       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1777       cleanup ();
1778       agent_exit (0);
1779       break;
1780 #endif
1781     default:
1782       log_info ("signal %d received - no action defined\n", signo);
1783     }
1784 }
1785 #endif
1786
1787 /* Check the nonce on a new connection.  This is a NOP unless we we
1788    are using our Unix domain socket emulation under Windows.  */
1789 static int
1790 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1791 {
1792   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1793     {
1794       log_info (_("error reading nonce on fd %d: %s\n"),
1795                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1796       assuan_sock_close (ctrl->thread_startup.fd);
1797       xfree (ctrl);
1798       return -1;
1799     }
1800   else
1801     return 0;
1802 }
1803
1804
1805 /* This is the standard connection thread's main function.  */
1806 static void *
1807 start_connection_thread (void *arg)
1808 {
1809   ctrl_t ctrl = arg;
1810
1811   if (check_nonce (ctrl, &socket_nonce))
1812     {
1813       log_error ("handler 0x%lx nonce check FAILED\n",
1814                  (unsigned long) npth_self());
1815       return NULL;
1816     }
1817
1818   agent_init_default_ctrl (ctrl);
1819   if (opt.verbose)
1820     log_info (_("handler 0x%lx for fd %d started\n"),
1821               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
1822
1823   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1824   if (opt.verbose)
1825     log_info (_("handler 0x%lx for fd %d terminated\n"),
1826               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
1827
1828   agent_deinit_default_ctrl (ctrl);
1829   xfree (ctrl);
1830   return NULL;
1831 }
1832
1833
1834 /* This is the ssh connection thread's main function.  */
1835 static void *
1836 start_connection_thread_ssh (void *arg)
1837 {
1838   ctrl_t ctrl = arg;
1839
1840   if (check_nonce (ctrl, &socket_nonce_ssh))
1841     return NULL;
1842
1843   agent_init_default_ctrl (ctrl);
1844   if (opt.verbose)
1845     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1846               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
1847
1848   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1849   if (opt.verbose)
1850     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1851               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
1852
1853   agent_deinit_default_ctrl (ctrl);
1854   xfree (ctrl);
1855   return NULL;
1856 }
1857
1858
1859 /* Connection handler loop.  Wait for connection requests and spawn a
1860    thread after accepting a connection.  */
1861 static void
1862 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1863 {
1864   npth_attr_t tattr;
1865   struct sockaddr_un paddr;
1866   socklen_t plen;
1867   fd_set fdset, read_fdset;
1868   int ret;
1869   gnupg_fd_t fd;
1870   int nfd;
1871   int saved_errno;
1872   struct timespec abstime;
1873   struct timespec curtime;
1874   struct timespec timeout;
1875 #ifdef HAVE_W32_SYSTEM
1876   HANDLE events[2];
1877   int events_set;
1878 #endif
1879
1880   ret = npth_attr_init(&tattr);
1881   if (ret)
1882     log_fatal ("error allocating thread attributes: %s\n",
1883                strerror (ret));
1884   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
1885
1886 #ifndef HAVE_W32_SYSTEM
1887   npth_sigev_init ();
1888   npth_sigev_add (SIGHUP);
1889   npth_sigev_add (SIGUSR1);
1890   npth_sigev_add (SIGUSR2);
1891   npth_sigev_add (SIGINT);
1892   npth_sigev_add (SIGTERM);
1893   npth_sigev_fini ();
1894 #else
1895 # ifdef HAVE_W32CE_SYSTEM
1896   /* Use a dummy event. */
1897   sigs = 0;
1898   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1899 # else
1900   events[0] = get_agent_scd_notify_event ();
1901   events[1] = INVALID_HANDLE_VALUE;
1902 # endif
1903 #endif
1904
1905   /* Set a flag to tell call-scd.c that it may enable event
1906      notifications.  */
1907   opt.sigusr2_enabled = 1;
1908
1909   FD_ZERO (&fdset);
1910   FD_SET (FD2INT (listen_fd), &fdset);
1911   nfd = FD2INT (listen_fd);
1912   if (listen_fd_ssh != GNUPG_INVALID_FD)
1913     {
1914       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1915       if (FD2INT (listen_fd_ssh) > nfd)
1916         nfd = FD2INT (listen_fd_ssh);
1917     }
1918
1919   npth_clock_gettime (&abstime);
1920   abstime.tv_sec += TIMERTICK_INTERVAL;
1921
1922   for (;;)
1923     {
1924       /* Shutdown test.  */
1925       if (shutdown_pending)
1926         {
1927           if (active_connections == 0)
1928             break; /* ready */
1929
1930           /* Do not accept new connections but keep on running the
1931              loop to cope with the timer events.  */
1932           FD_ZERO (&fdset);
1933         }
1934
1935       /* POSIX says that fd_set should be implemented as a structure,
1936          thus a simple assignment is fine to copy the entire set.  */
1937       read_fdset = fdset;
1938
1939       npth_clock_gettime (&curtime);
1940       if (!(npth_timercmp (&curtime, &abstime, <)))
1941         {
1942           /* Timeout.  */
1943           handle_tick ();
1944           npth_clock_gettime (&abstime);
1945           abstime.tv_sec += TIMERTICK_INTERVAL;
1946         }
1947       npth_timersub (&abstime, &curtime, &timeout);
1948
1949 #ifndef HAVE_W32_SYSTEM
1950       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
1951                           npth_sigev_sigmask ());
1952       saved_errno = errno;
1953
1954       {
1955         int signo;
1956         while (npth_sigev_get_pending (&signo))
1957           handle_signal (signo);
1958       }
1959 #else
1960       events_set = 0;
1961       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
1962                           events, &events_set);
1963       saved_errno = errno;
1964
1965       /* This is valid even if npth_eselect returns an error.  */
1966       if (events_set & 1)
1967         agent_sigusr2_action ();
1968 #endif
1969
1970       if (ret == -1 && saved_errno != EINTR)
1971         {
1972           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
1973                      strerror (saved_errno));
1974           npth_sleep (1);
1975           continue;
1976         }
1977       if (ret <= 0)
1978         /* Interrupt or timeout.  Will be handled when calculating the
1979            next timeout.  */
1980         continue;
1981
1982       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
1983         {
1984           ctrl_t ctrl;
1985
1986           plen = sizeof paddr;
1987           fd = INT2FD (npth_accept (FD2INT(listen_fd),
1988                                     (struct sockaddr *)&paddr, &plen));
1989           if (fd == GNUPG_INVALID_FD)
1990             {
1991               log_error ("accept failed: %s\n", strerror (errno));
1992             }
1993           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1994             {
1995               log_error ("error allocating connection control data: %s\n",
1996                          strerror (errno) );
1997               assuan_sock_close (fd);
1998             }
1999           else if ( !(ctrl->session_env = session_env_new ()) )
2000             {
2001               log_error ("error allocating session environment block: %s\n",
2002                          strerror (errno) );
2003               xfree (ctrl);
2004               assuan_sock_close (fd);
2005             }
2006           else
2007             {
2008               npth_t thread;
2009
2010               ctrl->thread_startup.fd = fd;
2011               ret = npth_create (&thread, &tattr,
2012                                  start_connection_thread, ctrl);
2013               if (ret)
2014                 {
2015                   log_error ("error spawning connection handler: %s\n",
2016                              strerror (ret));
2017                   assuan_sock_close (fd);
2018                   xfree (ctrl);
2019                 }
2020
2021             }
2022           fd = GNUPG_INVALID_FD;
2023         }
2024
2025       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD
2026           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2027         {
2028           ctrl_t ctrl;
2029
2030           plen = sizeof paddr;
2031           fd = INT2FD(npth_accept (FD2INT(listen_fd_ssh),
2032                                    (struct sockaddr *)&paddr, &plen));
2033           if (fd == GNUPG_INVALID_FD)
2034             {
2035               log_error ("accept failed for ssh: %s\n", strerror (errno));
2036             }
2037           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2038             {
2039               log_error ("error allocating connection control data: %s\n",
2040                          strerror (errno) );
2041               assuan_sock_close (fd);
2042             }
2043           else if ( !(ctrl->session_env = session_env_new ()) )
2044             {
2045               log_error ("error allocating session environment block: %s\n",
2046                          strerror (errno) );
2047               xfree (ctrl);
2048               assuan_sock_close (fd);
2049             }
2050           else
2051             {
2052               npth_t thread;
2053
2054               agent_init_default_ctrl (ctrl);
2055               ctrl->thread_startup.fd = fd;
2056               ret = npth_create (&thread, &tattr,
2057                                  start_connection_thread_ssh, ctrl);
2058               if (ret)
2059                 {
2060                   log_error ("error spawning ssh connection handler: %s\n",
2061                              strerror (ret));
2062                   assuan_sock_close (fd);
2063                   xfree (ctrl);
2064                 }
2065             }
2066           fd = GNUPG_INVALID_FD;
2067         }
2068     }
2069
2070   cleanup ();
2071   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2072   npth_attr_destroy (&tattr);
2073 }
2074
2075
2076
2077 /* Helper for check_own_socket.  */
2078 static gpg_error_t
2079 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2080 {
2081   membuf_t *mb = opaque;
2082   put_membuf (mb, buffer, length);
2083   return 0;
2084 }
2085
2086
2087 /* The thread running the actual check.  We need to run this in a
2088    separate thread so that check_own_thread can be called from the
2089    timer tick.  */
2090 static void *
2091 check_own_socket_thread (void *arg)
2092 {
2093   int rc;
2094   char *sockname = arg;
2095   assuan_context_t ctx = NULL;
2096   membuf_t mb;
2097   char *buffer;
2098
2099   check_own_socket_running++;
2100
2101   rc = assuan_new (&ctx);
2102   if (rc)
2103     {
2104       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2105       goto leave;
2106     }
2107
2108   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2109   if (rc)
2110     {
2111       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2112       goto leave;
2113     }
2114
2115   init_membuf (&mb, 100);
2116   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2117                         NULL, NULL, NULL, NULL);
2118   put_membuf (&mb, "", 1);
2119   buffer = get_membuf (&mb, NULL);
2120   if (rc || !buffer)
2121     {
2122       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2123                  "GETINFO pid", gpg_strerror (rc));
2124       rc = 1;
2125     }
2126   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2127     {
2128       log_error ("socket is now serviced by another server\n");
2129       rc = 1;
2130     }
2131   else if (opt.verbose > 1)
2132     log_error ("socket is still served by this server\n");
2133
2134   xfree (buffer);
2135
2136  leave:
2137   xfree (sockname);
2138   if (ctx)
2139     assuan_release (ctx);
2140   if (rc)
2141     {
2142       /* We may not remove the socket as it is now in use by another
2143          server.  Setting the name to empty does this.  */
2144       if (socket_name)
2145         *socket_name = 0;
2146       if (socket_name_ssh)
2147         *socket_name_ssh = 0;
2148       shutdown_pending = 2;
2149       log_info ("this process is useless - shutting down\n");
2150     }
2151   check_own_socket_running--;
2152   return NULL;
2153 }
2154
2155
2156 /* Check whether we are still listening on our own socket.  In case
2157    another gpg-agent process started after us has taken ownership of
2158    our socket, we would linger around without any real task.  Thus we
2159    better check once in a while whether we are really needed.  */
2160 static void
2161 check_own_socket (void)
2162 {
2163   char *sockname;
2164   npth_t thread;
2165   npth_attr_t tattr;
2166   int err;
2167
2168   if (!opt.use_standard_socket)
2169     return; /* This check makes only sense in standard socket mode.  */
2170
2171   if (check_own_socket_running || shutdown_pending)
2172     return;  /* Still running or already shutting down.  */
2173
2174   sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
2175   if (!sockname)
2176     return; /* Out of memory.  */
2177
2178   err = npth_attr_init (&tattr);
2179   if (err)
2180     return;
2181   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2182   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2183   if (err)
2184     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2185   npth_attr_destroy (&tattr);
2186 }
2187
2188
2189
2190 /* Figure out whether an agent is available and running. Prints an
2191    error if not.  If SILENT is true, no messages are printed.  Usually
2192    started with MODE 0.  Returns 0 if the agent is running. */
2193 static int
2194 check_for_running_agent (int silent, int mode)
2195 {
2196   int rc;
2197   char *infostr, *p;
2198   assuan_context_t ctx = NULL;
2199   int prot, pid;
2200
2201   if (!mode)
2202     {
2203       infostr = getenv ("GPG_AGENT_INFO");
2204       if (!infostr || !*infostr)
2205         {
2206           if (!check_for_running_agent (silent, 1))
2207             return 0; /* Okay, its running on the standard socket. */
2208           if (!silent)
2209             log_error (_("no gpg-agent running in this session\n"));
2210           return -1;
2211         }
2212
2213       infostr = xstrdup (infostr);
2214       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2215         {
2216           xfree (infostr);
2217           if (!check_for_running_agent (silent, 1))
2218             return 0; /* Okay, its running on the standard socket. */
2219           if (!silent)
2220             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
2221           return -1;
2222         }
2223
2224       *p++ = 0;
2225       pid = atoi (p);
2226       while (*p && *p != PATHSEP_C)
2227         p++;
2228       prot = *p? atoi (p+1) : 0;
2229       if (prot != 1)
2230         {
2231           xfree (infostr);
2232           if (!silent)
2233             log_error (_("gpg-agent protocol version %d is not supported\n"),
2234                        prot);
2235           if (!check_for_running_agent (silent, 1))
2236             return 0; /* Okay, its running on the standard socket. */
2237           return -1;
2238         }
2239     }
2240   else /* MODE != 0 */
2241     {
2242       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
2243       pid = (pid_t)(-1);
2244     }
2245
2246   rc = assuan_new (&ctx);
2247   if (! rc)
2248     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2249   xfree (infostr);
2250   if (rc)
2251     {
2252       if (!mode && !check_for_running_agent (silent, 1))
2253         return 0; /* Okay, its running on the standard socket. */
2254
2255       if (!mode && !silent)
2256         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2257
2258       if (ctx)
2259         assuan_release (ctx);
2260       return -1;
2261     }
2262
2263   if (!opt.quiet && !silent)
2264     log_info ("gpg-agent running and available\n");
2265
2266   assuan_release (ctx);
2267   return 0;
2268 }
2269
2270 /* TODO: it is also in misc, which is not linked with the agent */
2271 /* FIXME: The agent should not know about openpgp internals - weel
2272    except for some stuff in cvt-openpgp.  */
2273 int
2274 map_pk_openpgp_to_gcry (int algo)
2275 {
2276   return (algo==PUBKEY_ALGO_ECDSA ? GCRY_PK_ECDSA : (algo==PUBKEY_ALGO_ECDH ? GCRY_PK_ECDH : algo));
2277 }