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