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