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