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