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