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