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