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