c264ba3c38bd03d3c0373ad7841456b7b211d742
[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           break;
821         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
822           break;
823
824         case oUseStandardSocket:   opt.use_standard_socket = 1; break;
825         case oNoUseStandardSocket: opt.use_standard_socket = 0; break;
826
827         case oFakedSystemTime:
828           {
829             time_t faked_time = isotime2epoch (pargs.r.ret_str);
830             if (faked_time == (time_t)(-1))
831               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
832             gnupg_set_time (faked_time, 0);
833           }
834           break;
835
836         case oKeepTTY: opt.keep_tty = 1; break;
837         case oKeepDISPLAY: opt.keep_display = 1; break;
838
839         case oSSHSupport:  opt.ssh_support = 1; break;
840         case oWriteEnvFile:
841           if (pargs.r_type)
842             env_file_name = pargs.r.ret_str;
843           else
844             env_file_name = make_filename ("~/.gpg-agent-info", NULL);
845           break;
846
847         default : pargs.err = configfp? 1:2; break;
848         }
849     }
850   if (configfp)
851     {
852       fclose( configfp );
853       configfp = NULL;
854       /* Keep a copy of the name so that it can be read on SIGHUP. */
855       if (config_filename != configname)
856         {
857           xfree (config_filename);
858           config_filename = configname;
859         }
860       configname = NULL;
861       goto next_pass;
862     }
863
864   xfree (configname);
865   configname = NULL;
866   if (log_get_errorcount(0))
867     exit(2);
868   if (nogreeting )
869     greeting = 0;
870
871   if (greeting)
872     {
873       es_fprintf (es_stderr, "%s %s; %s\n",
874                   strusage(11), strusage(13), strusage(14) );
875       es_fprintf (es_stderr, "%s\n", strusage(15) );
876     }
877 #ifdef IS_DEVELOPMENT_VERSION
878   /* We don't want to print it here because gpg-agent is useful of its
879      own and quite matured.  */
880   /*log_info ("NOTE: this is a development version!\n");*/
881 #endif
882
883 #ifdef ENABLE_NLS
884   /* gpg-agent usually does not output any messages because it runs in
885      the background.  For log files it is acceptable to have messages
886      always encoded in utf-8.  We switch here to utf-8, so that
887      commands like --help still give native messages.  It is far
888      easier to switch only once instead of for every message and it
889      actually helps when more then one thread is active (avoids an
890      extra copy step). */
891     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
892 #endif
893
894   if (!pipe_server && !is_daemon && !gpgconf_list)
895     {
896      /* We have been called without any options and thus we merely
897         check whether an agent is already running.  We do this right
898         here so that we don't clobber a logfile with this check but
899         print the status directly to stderr. */
900       opt.debug = 0;
901       set_debug ();
902       check_for_running_agent (0, 0);
903       agent_exit (0);
904     }
905
906   set_debug ();
907
908   if (atexit (cleanup))
909     {
910       log_error ("atexit failed\n");
911       cleanup ();
912       exit (1);
913     }
914
915   initialize_module_cache ();
916   initialize_module_call_pinentry ();
917   initialize_module_call_scd ();
918   initialize_module_trustlist ();
919
920   /* Try to create missing directories. */
921   create_directories ();
922
923   if (debug_wait && pipe_server)
924     {
925       log_debug ("waiting for debugger - my pid is %u .....\n",
926                  (unsigned int)getpid());
927       gnupg_sleep (debug_wait);
928       log_debug ("... okay\n");
929     }
930
931   if (gpgconf_list == 3)
932     {
933       if (opt.use_standard_socket && !opt.quiet)
934         log_info ("configured to use the standard socket\n");
935       agent_exit (!opt.use_standard_socket);
936     }
937   else if (gpgconf_list == 2)
938     agent_exit (0);
939   else if (gpgconf_list)
940     {
941       char *filename;
942       char *filename_esc;
943
944       /* List options and default values in the GPG Conf format.  */
945       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
946       filename_esc = percent_escape (filename, NULL);
947
948       es_printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
949               GC_OPT_FLAG_DEFAULT, filename_esc);
950       xfree (filename);
951       xfree (filename_esc);
952
953       es_printf ("verbose:%lu:\n"
954               "quiet:%lu:\n"
955               "debug-level:%lu:\"none:\n"
956               "log-file:%lu:\n",
957               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
958               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
959               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
960               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
961       es_printf ("default-cache-ttl:%lu:%d:\n",
962               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
963       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
964               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
965       es_printf ("max-cache-ttl:%lu:%d:\n",
966               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
967       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
968               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
969       es_printf ("enforce-passphrase-constraints:%lu:\n",
970               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
971       es_printf ("min-passphrase-len:%lu:%d:\n",
972               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
973       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
974               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
975               MIN_PASSPHRASE_NONALPHA);
976       es_printf ("check-passphrase-pattern:%lu:\n",
977               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
978       es_printf ("max-passphrase-days:%lu:%d:\n",
979               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
980               MAX_PASSPHRASE_DAYS);
981       es_printf ("enable-passphrase-history:%lu:\n",
982               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
983       es_printf ("no-grab:%lu:\n",
984               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
985       es_printf ("ignore-cache-for-signing:%lu:\n",
986               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
987       es_printf ("allow-mark-trusted:%lu:\n",
988               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
989       es_printf ("disable-scdaemon:%lu:\n",
990               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
991
992       agent_exit (0);
993     }
994
995   /* Now start with logging to a file if this is desired. */
996   if (logfile)
997     {
998       log_set_file (logfile);
999       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1000                              |JNLIB_LOG_WITH_TIME
1001                              |JNLIB_LOG_WITH_PID));
1002       current_logfile = xstrdup (logfile);
1003     }
1004
1005   /* Make sure that we have a default ttyname. */
1006   if (!default_ttyname && ttyname (1))
1007     default_ttyname = xstrdup (ttyname (1));
1008   if (!default_ttytype && getenv ("TERM"))
1009     default_ttytype = xstrdup (getenv ("TERM"));
1010
1011
1012   if (pipe_server)
1013     {
1014       /* This is the simple pipe based server */
1015       ctrl_t ctrl;
1016
1017       ctrl = xtrycalloc (1, sizeof *ctrl);
1018       if (!ctrl)
1019         {
1020           log_error ("error allocating connection control data: %s\n",
1021                      strerror (errno) );
1022           agent_exit (1);
1023         }
1024       ctrl->session_env = session_env_new ();
1025       if (!ctrl->session_env)
1026         {
1027           log_error ("error allocating session environment block: %s\n",
1028                      strerror (errno) );
1029           xfree (ctrl);
1030           agent_exit (1);
1031         }
1032       agent_init_default_ctrl (ctrl);
1033       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1034       agent_deinit_default_ctrl (ctrl);
1035       xfree (ctrl);
1036     }
1037   else if (!is_daemon)
1038     ; /* NOTREACHED */
1039   else
1040     { /* Regular server mode */
1041       gnupg_fd_t fd;
1042       gnupg_fd_t fd_ssh;
1043       pid_t pid;
1044
1045       /* Remove the DISPLAY variable so that a pinentry does not
1046          default to a specific display.  There is still a default
1047          display when gpg-agent was started using --display or a
1048          client requested this using an OPTION command.  Note, that we
1049          don't do this when running in reverse daemon mode (i.e. when
1050          exec the program given as arguments). */
1051 #ifndef HAVE_W32_SYSTEM
1052       if (!opt.keep_display && !argc)
1053         gnupg_unsetenv ("DISPLAY");
1054 #endif
1055
1056
1057       /* Create the sockets.  */
1058       socket_name = create_socket_name
1059         ("S.gpg-agent", "gpg-XXXXXX/S.gpg-agent");
1060       if (opt.ssh_support)
1061         socket_name_ssh = create_socket_name
1062           ("S.gpg-agent.ssh", "gpg-XXXXXX/S.gpg-agent.ssh");
1063
1064       fd = create_server_socket (socket_name, 0, &socket_nonce);
1065       if (opt.ssh_support)
1066         fd_ssh = create_server_socket (socket_name_ssh, 1, &socket_nonce_ssh);
1067       else
1068         fd_ssh = GNUPG_INVALID_FD;
1069
1070       /* If we are going to exec a program in the parent, we record
1071          the PID, so that the child may check whether the program is
1072          still alive. */
1073       if (argc)
1074         parent_pid = getpid ();
1075
1076       fflush (NULL);
1077 #ifdef HAVE_W32_SYSTEM
1078       pid = getpid ();
1079       es_printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
1080 #else /*!HAVE_W32_SYSTEM*/
1081       pid = fork ();
1082       if (pid == (pid_t)-1)
1083         {
1084           log_fatal ("fork failed: %s\n", strerror (errno) );
1085           exit (1);
1086         }
1087       else if (pid)
1088         { /* We are the parent */
1089           char *infostr, *infostr_ssh_sock;
1090
1091           /* Close the socket FD. */
1092           close (fd);
1093
1094           /* Note that we used a standard fork so that Pth runs in
1095              both the parent and the child.  The pth_fork would
1096              terminate Pth in the child but that is not the way we
1097              want it.  Thus we use a plain fork and terminate Pth here
1098              in the parent.  The pth_kill may or may not work reliable
1099              but it should not harm to call it.  Because Pth fiddles
1100              with the signal mask the signal mask might not be correct
1101              right now and thus we restore it.  That is not strictly
1102              necessary but some programs falsely assume a cleared
1103              signal mask.  */
1104 #warning need to do something about pth_kill - see bug#1320
1105           if ( !pth_kill () )
1106             log_error ("pth_kill failed in forked process\n");
1107
1108 #ifdef HAVE_SIGPROCMASK
1109           if (startup_signal_mask_valid)
1110             {
1111               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1112                 log_error ("error restoring signal mask: %s\n",
1113                            strerror (errno));
1114             }
1115           else
1116             log_info ("no saved signal mask\n");
1117 #endif /*HAVE_SIGPROCMASK*/
1118
1119           /* Create the info string: <name>:<pid>:<protocol_version> */
1120           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
1121                         socket_name, (ulong)pid ) < 0)
1122             {
1123               log_error ("out of core\n");
1124               kill (pid, SIGTERM);
1125               exit (1);
1126             }
1127           if (opt.ssh_support)
1128             {
1129               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1130                             socket_name_ssh) < 0)
1131                 {
1132                   log_error ("out of core\n");
1133                   kill (pid, SIGTERM);
1134                   exit (1);
1135                 }
1136             }
1137
1138           *socket_name = 0; /* Don't let cleanup() remove the socket -
1139                                the child should do this from now on */
1140           if (opt.ssh_support)
1141             *socket_name_ssh = 0;
1142
1143           if (env_file_name)
1144             {
1145               estream_t fp;
1146
1147               fp = es_fopen (env_file_name, "w,mode=-rw");
1148               if (!fp)
1149                 log_error (_("error creating `%s': %s\n"),
1150                              env_file_name, strerror (errno));
1151               else
1152                 {
1153                   es_fputs (infostr, fp);
1154                   es_putc ('\n', fp);
1155                   if (opt.ssh_support)
1156                     {
1157                       es_fputs (infostr_ssh_sock, fp);
1158                       es_putc ('\n', fp);
1159                     }
1160                   es_fclose (fp);
1161                 }
1162             }
1163
1164
1165           if (argc)
1166             { /* Run the program given on the commandline.  */
1167               if (putenv (infostr))
1168                 {
1169                   log_error ("failed to set environment: %s\n",
1170                              strerror (errno) );
1171                   kill (pid, SIGTERM );
1172                   exit (1);
1173                 }
1174               if (opt.ssh_support && putenv (infostr_ssh_sock))
1175                 {
1176                   log_error ("failed to set environment: %s\n",
1177                              strerror (errno) );
1178                   kill (pid, SIGTERM );
1179                   exit (1);
1180                 }
1181
1182               /* Close all the file descriptors except the standard
1183                  ones and those open at startup.  We explicitly don't
1184                  close 0,1,2 in case something went wrong collecting
1185                  them at startup.  */
1186               close_all_fds (3, startup_fd_list);
1187
1188               /* Run the command.  */
1189               execvp (argv[0], argv);
1190               log_error ("failed to run the command: %s\n", strerror (errno));
1191               kill (pid, SIGTERM);
1192               exit (1);
1193             }
1194           else
1195             {
1196               /* Print the environment string, so that the caller can use
1197                  shell's eval to set it */
1198               if (csh_style)
1199                 {
1200                   *strchr (infostr, '=') = ' ';
1201                   es_printf ("setenv %s;\n", infostr);
1202                   if (opt.ssh_support)
1203                     {
1204                       *strchr (infostr_ssh_sock, '=') = ' ';
1205                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1206                     }
1207                 }
1208               else
1209                 {
1210                   es_printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1211                   if (opt.ssh_support)
1212                     {
1213                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1214                                  infostr_ssh_sock);
1215                     }
1216                 }
1217               xfree (infostr);
1218               if (opt.ssh_support)
1219                 {
1220                   xfree (infostr_ssh_sock);
1221                 }
1222               exit (0);
1223             }
1224           /*NOTREACHED*/
1225         } /* End parent */
1226
1227       /*
1228          This is the child
1229        */
1230
1231       /* Detach from tty and put process into a new session */
1232       if (!nodetach )
1233         {
1234           int i;
1235           unsigned int oldflags;
1236
1237           /* Close stdin, stdout and stderr unless it is the log stream */
1238           for (i=0; i <= 2; i++)
1239             {
1240               if (!log_test_fd (i) && i != fd )
1241                 {
1242                   if ( ! close (i)
1243                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1244                     {
1245                       log_error ("failed to open `%s': %s\n",
1246                                  "/dev/null", strerror (errno));
1247                       cleanup ();
1248                       exit (1);
1249                     }
1250                 }
1251             }
1252           if (setsid() == -1)
1253             {
1254               log_error ("setsid() failed: %s\n", strerror(errno) );
1255               cleanup ();
1256               exit (1);
1257             }
1258
1259           log_get_prefix (&oldflags);
1260           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1261           opt.running_detached = 1;
1262         }
1263
1264       if (chdir("/"))
1265         {
1266           log_error ("chdir to / failed: %s\n", strerror (errno));
1267           exit (1);
1268         }
1269
1270       {
1271         struct sigaction sa;
1272
1273         sa.sa_handler = SIG_IGN;
1274         sigemptyset (&sa.sa_mask);
1275         sa.sa_flags = 0;
1276         sigaction (SIGPIPE, &sa, NULL);
1277       }
1278 #endif /*!HAVE_W32_SYSTEM*/
1279
1280       log_info ("%s %s started\n", strusage(11), strusage(13) );
1281       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1282       assuan_sock_close (fd);
1283     }
1284
1285   return 0;
1286 }
1287
1288
1289 /* Exit entry point.  This function should be called instead of a
1290    plain exit.  */
1291 void
1292 agent_exit (int rc)
1293 {
1294   /*FIXME: update_random_seed_file();*/
1295
1296   /* We run our cleanup handler because that may close cipher contexts
1297      stored in secure memory and thus this needs to be done before we
1298      explicitly terminate secure memory.  */
1299   cleanup ();
1300
1301 #if 1
1302   /* at this time a bit annoying */
1303   if (opt.debug & DBG_MEMSTAT_VALUE)
1304     {
1305       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1306       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1307     }
1308   if (opt.debug)
1309     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1310 #endif
1311   gcry_control (GCRYCTL_TERM_SECMEM );
1312   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1313   exit (rc);
1314 }
1315
1316
1317 /* Each thread has its own local variables conveyed by a control
1318    structure usually identified by an argument named CTRL.  This
1319    function is called immediately after allocating the control
1320    structure.  Its purpose is to setup the default values for that
1321    structure.  */
1322 static void
1323 agent_init_default_ctrl (ctrl_t ctrl)
1324 {
1325   /* Note we ignore malloc errors because we can't do much about it
1326      and the request will fail anyway shortly after this
1327      initialization. */
1328   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1329   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1330   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1331   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1332   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1333
1334   if (ctrl->lc_ctype)
1335     xfree (ctrl->lc_ctype);
1336   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1337
1338   if (ctrl->lc_messages)
1339     xfree (ctrl->lc_messages);
1340   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1341                                     /**/ : NULL;
1342
1343   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1344 }
1345
1346
1347 /* Release all resources allocated by default in the control
1348    structure.  This is the counterpart to agent_init_default_ctrl.  */
1349 static void
1350 agent_deinit_default_ctrl (ctrl_t ctrl)
1351 {
1352   session_env_release (ctrl->session_env);
1353
1354   if (ctrl->lc_ctype)
1355     xfree (ctrl->lc_ctype);
1356   if (ctrl->lc_messages)
1357     xfree (ctrl->lc_messages);
1358 }
1359
1360
1361 /* Reread parts of the configuration.  Note, that this function is
1362    obviously not thread-safe and should only be called from the PTH
1363    signal handler.
1364
1365    Fixme: Due to the way the argument parsing works, we create a
1366    memory leak here for all string type arguments.  There is currently
1367    no clean way to tell whether the memory for the argument has been
1368    allocated or points into the process' original arguments.  Unless
1369    we have a mechanism to tell this, we need to live on with this. */
1370 static void
1371 reread_configuration (void)
1372 {
1373   ARGPARSE_ARGS pargs;
1374   FILE *fp;
1375   unsigned int configlineno = 0;
1376   int dummy;
1377
1378   if (!config_filename)
1379     return; /* No config file. */
1380
1381   fp = fopen (config_filename, "r");
1382   if (!fp)
1383     {
1384       log_info (_("option file `%s': %s\n"),
1385                 config_filename, strerror(errno) );
1386       return;
1387     }
1388
1389   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1390
1391   memset (&pargs, 0, sizeof pargs);
1392   dummy = 0;
1393   pargs.argc = &dummy;
1394   pargs.flags = 1;  /* do not remove the args */
1395   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1396     {
1397       if (pargs.r_opt < -1)
1398         pargs.err = 1; /* Print a warning. */
1399       else /* Try to parse this option - ignore unchangeable ones. */
1400         parse_rereadable_options (&pargs, 1);
1401     }
1402   fclose (fp);
1403   set_debug ();
1404 }
1405
1406
1407 /* Return the file name of the socket we are using for native
1408    requests.  */
1409 const char *
1410 get_agent_socket_name (void)
1411 {
1412   const char *s = socket_name;
1413
1414   return (s && *s)? s : NULL;
1415 }
1416
1417 /* Return the file name of the socket we are using for SSH
1418    requests.  */
1419 const char *
1420 get_agent_ssh_socket_name (void)
1421 {
1422   const char *s = socket_name_ssh;
1423
1424   return (s && *s)? s : NULL;
1425 }
1426
1427
1428 /* Under W32, this function returns the handle of the scdaemon
1429    notification event.  Calling it the first time creates that
1430    event.  */
1431 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1432 void *
1433 get_agent_scd_notify_event (void)
1434 {
1435   static HANDLE the_event;
1436
1437   if (!the_event)
1438     {
1439       HANDLE h, h2;
1440       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1441
1442       /* We need to use a manual reset event object due to the way our
1443          w32-pth wait function works: If we would use an automatic
1444          reset event we are not able to figure out which handle has
1445          been signaled because at the time we single out the signaled
1446          handles using WFSO the event has already been reset due to
1447          the WFMO.  */
1448       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1449       if (!h)
1450         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1451       else if (!DuplicateHandle (GetCurrentProcess(), h,
1452                                  GetCurrentProcess(), &h2,
1453                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1454         {
1455           log_error ("setting syncronize for scd notify event failed: %s\n",
1456                      w32_strerror (-1) );
1457           CloseHandle (h);
1458         }
1459       else
1460         {
1461           CloseHandle (h);
1462           the_event = h2;
1463         }
1464     }
1465
1466   return the_event;
1467 }
1468 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1469
1470
1471
1472 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1473    true using STANDARD_NAME in the home directory or if given as
1474    false from the mkdir type name TEMPLATE.  In the latter case a
1475    unique name in a unique new directory will be created.  In both
1476    cases check for valid characters as well as against a maximum
1477    allowed length for a unix domain socket is done.  The function
1478    terminates the process in case of an error.  Returns: Pointer to an
1479    allocated string with the absolute name of the socket used.  */
1480 static char *
1481 create_socket_name (char *standard_name, char *template)
1482 {
1483   char *name, *p;
1484
1485   if (opt.use_standard_socket)
1486     name = make_filename (opt.homedir, standard_name, NULL);
1487   else
1488     {
1489       /* Prepend the tmp directory to the template.  */
1490       p = getenv ("TMPDIR");
1491       if (!p || !*p)
1492         p = "/tmp";
1493       if (p[strlen (p) - 1] == '/')
1494         name = xstrconcat (p, template, NULL);
1495       else
1496         name = xstrconcat (p, "/", template, NULL);
1497
1498       p = strrchr (name, '/');
1499       if (!p)
1500         BUG ();
1501       *p = 0;
1502       if (!mkdtemp (name))
1503         {
1504           log_error (_("can't create directory `%s': %s\n"),
1505                      name, strerror (errno));
1506           agent_exit (2);
1507         }
1508       *p = '/';
1509     }
1510
1511   if (strchr (name, PATHSEP_C))
1512     {
1513       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1514       agent_exit (2);
1515     }
1516   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1517     {
1518       log_error (_("name of socket too long\n"));
1519       agent_exit (2);
1520     }
1521   return name;
1522 }
1523
1524
1525
1526 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1527    or terminates the process in case of an error.  Not that this
1528    function needs to be used for the regular socket first and only
1529    then for the ssh socket.  */
1530 static gnupg_fd_t
1531 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1532 {
1533   struct sockaddr_un *serv_addr;
1534   socklen_t len;
1535   gnupg_fd_t fd;
1536   int rc;
1537
1538   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1539   if (fd == ASSUAN_INVALID_FD)
1540     {
1541       log_error (_("can't create socket: %s\n"), strerror (errno));
1542       agent_exit (2);
1543     }
1544
1545   serv_addr = xmalloc (sizeof (*serv_addr));
1546   memset (serv_addr, 0, sizeof *serv_addr);
1547   serv_addr->sun_family = AF_UNIX;
1548   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1549     {
1550       log_error (_("socket name `%s' is too long\n"), name);
1551       agent_exit (2);
1552     }
1553   strcpy (serv_addr->sun_path, name);
1554   len = SUN_LEN (serv_addr);
1555   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1556
1557   /* Our error code mapping on W32CE returns EEXIST thus we also test
1558      for this. */
1559   if (opt.use_standard_socket && rc == -1
1560       && (errno == EADDRINUSE
1561 #ifdef HAVE_W32_SYSTEM
1562           || errno == EEXIST
1563 #endif
1564           ))
1565     {
1566       /* Check whether a gpg-agent is already running on the standard
1567          socket.  We do this test only if this is not the ssh socket.
1568          For ssh we assume that a test for gpg-agent has already been
1569          done and reuse the requested ssh socket.  Testing the
1570          ssh-socket is not possible because at this point, though we
1571          know the new Assuan socket, the Assuan server and thus the
1572          ssh-agent server is not yet operational.  This would lead to
1573          a hang.  */
1574       if (!is_ssh && !check_for_running_agent (1, 1))
1575         {
1576           log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
1577           log_set_file (NULL);
1578           log_error (_("a gpg-agent is already running - "
1579                        "not starting a new one\n"));
1580           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1581           assuan_sock_close (fd);
1582           agent_exit (2);
1583         }
1584       gnupg_remove (name);
1585       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1586     }
1587   if (rc != -1
1588       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1589     log_error (_("error getting nonce for the socket\n"));
1590   if (rc == -1)
1591     {
1592       /* We use gpg_strerror here because it allows us to get strings
1593          for some W32 socket error codes.  */
1594       log_error (_("error binding socket to `%s': %s\n"),
1595                  serv_addr->sun_path,
1596                  gpg_strerror (gpg_error_from_errno (errno)));
1597
1598       assuan_sock_close (fd);
1599       if (opt.use_standard_socket)
1600         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1601       agent_exit (2);
1602     }
1603
1604   if (listen (FD2INT(fd), 5 ) == -1)
1605     {
1606       log_error (_("listen() failed: %s\n"), strerror (errno));
1607       assuan_sock_close (fd);
1608       agent_exit (2);
1609     }
1610
1611   if (opt.verbose)
1612     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1613
1614   return fd;
1615 }
1616
1617
1618 /* Check that the directory for storing the private keys exists and
1619    create it if not.  This function won't fail as it is only a
1620    convenience function and not strictly necessary.  */
1621 static void
1622 create_private_keys_directory (const char *home)
1623 {
1624   char *fname;
1625   struct stat statbuf;
1626
1627   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1628   if (stat (fname, &statbuf) && errno == ENOENT)
1629     {
1630       if (gnupg_mkdir (fname, "-rwx"))
1631         log_error (_("can't create directory `%s': %s\n"),
1632                    fname, strerror (errno) );
1633       else if (!opt.quiet)
1634         log_info (_("directory `%s' created\n"), fname);
1635     }
1636   xfree (fname);
1637 }
1638
1639 /* Create the directory only if the supplied directory name is the
1640    same as the default one.  This way we avoid to create arbitrary
1641    directories when a non-default home directory is used.  To cope
1642    with HOME, we compare only the suffix if we see that the default
1643    homedir does start with a tilde.  We don't stop here in case of
1644    problems because other functions will throw an error anyway.*/
1645 static void
1646 create_directories (void)
1647 {
1648   struct stat statbuf;
1649   const char *defhome = standard_homedir ();
1650   char *home;
1651
1652   home = make_filename (opt.homedir, NULL);
1653   if ( stat (home, &statbuf) )
1654     {
1655       if (errno == ENOENT)
1656         {
1657           if (
1658 #ifdef HAVE_W32_SYSTEM
1659               ( !compare_filenames (home, defhome) )
1660 #else
1661               (*defhome == '~'
1662                 && (strlen (home) >= strlen (defhome+1)
1663                     && !strcmp (home + strlen(home)
1664                                 - strlen (defhome+1), defhome+1)))
1665                || (*defhome != '~' && !strcmp (home, defhome) )
1666 #endif
1667                )
1668             {
1669               if (gnupg_mkdir (home, "-rwx"))
1670                 log_error (_("can't create directory `%s': %s\n"),
1671                            home, strerror (errno) );
1672               else
1673                 {
1674                   if (!opt.quiet)
1675                     log_info (_("directory `%s' created\n"), home);
1676                   create_private_keys_directory (home);
1677                 }
1678             }
1679         }
1680       else
1681         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1682     }
1683   else if ( !S_ISDIR(statbuf.st_mode))
1684     {
1685       log_error (_("can't use `%s' as home directory\n"), home);
1686     }
1687   else /* exists and is a directory. */
1688     {
1689       create_private_keys_directory (home);
1690     }
1691   xfree (home);
1692 }
1693
1694
1695
1696 /* This is the worker for the ticker.  It is called every few seconds
1697    and may only do fast operations. */
1698 static void
1699 handle_tick (void)
1700 {
1701   static time_t last_minute;
1702
1703   if (!last_minute)
1704     last_minute = time (NULL);
1705
1706   /* Check whether the scdaemon has died and cleanup in this case. */
1707   agent_scd_check_aliveness ();
1708
1709   /* If we are running as a child of another process, check whether
1710      the parent is still alive and shutdown if not. */
1711 #ifndef HAVE_W32_SYSTEM
1712   if (parent_pid != (pid_t)(-1))
1713     {
1714       if (kill (parent_pid, 0))
1715         {
1716           shutdown_pending = 2;
1717           log_info ("parent process died - shutting down\n");
1718           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1719           cleanup ();
1720           agent_exit (0);
1721         }
1722     }
1723 #endif /*HAVE_W32_SYSTEM*/
1724
1725   /* Code to be run from time to time.  */
1726 #if CHECK_OWN_SOCKET_INTERVAL > 0
1727   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1728     {
1729       check_own_socket ();
1730       last_minute = time (NULL);
1731     }
1732 #endif
1733
1734 }
1735
1736
1737 /* A global function which allows us to call the reload stuff from
1738    other places too.  This is only used when build for W32.  */
1739 void
1740 agent_sighup_action (void)
1741 {
1742   log_info ("SIGHUP received - "
1743             "re-reading configuration and flushing cache\n");
1744   agent_flush_cache ();
1745   reread_configuration ();
1746   agent_reload_trustlist ();
1747 }
1748
1749
1750 /* A helper function to handle SIGUSR2.  */
1751 static void
1752 agent_sigusr2_action (void)
1753 {
1754   if (opt.verbose)
1755     log_info ("SIGUSR2 received - updating card event counter\n");
1756   /* Nothing to check right now.  We only increment a counter.  */
1757   bump_card_eventcounter ();
1758 }
1759
1760
1761 /* The signal handler for this program.  It is expected to be run in
1762    its own trhead and not in the context of a signal handler.  */
1763 static void
1764 handle_signal (int signo)
1765 {
1766   switch (signo)
1767     {
1768 #ifndef HAVE_W32_SYSTEM
1769     case SIGHUP:
1770       agent_sighup_action ();
1771       break;
1772
1773     case SIGUSR1:
1774       log_info ("SIGUSR1 received - printing internal information:\n");
1775       /* Fixme: We need to see how to integrate pth dumping into our
1776          logging system.  */
1777       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1778       agent_query_dump_state ();
1779       agent_scd_dump_state ();
1780       break;
1781
1782     case SIGUSR2:
1783       agent_sigusr2_action ();
1784       break;
1785
1786     case SIGTERM:
1787       if (!shutdown_pending)
1788         log_info ("SIGTERM received - shutting down ...\n");
1789       else
1790         log_info ("SIGTERM received - still %ld running threads\n",
1791                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1792       shutdown_pending++;
1793       if (shutdown_pending > 2)
1794         {
1795           log_info ("shutdown forced\n");
1796           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1797           cleanup ();
1798           agent_exit (0);
1799         }
1800       break;
1801
1802     case SIGINT:
1803       log_info ("SIGINT received - immediate shutdown\n");
1804       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1805       cleanup ();
1806       agent_exit (0);
1807       break;
1808 #endif
1809     default:
1810       log_info ("signal %d received - no action defined\n", signo);
1811     }
1812 }
1813
1814
1815 /* Check the nonce on a new connection.  This is a NOP unless we we
1816    are using our Unix domain socket emulation under Windows.  */
1817 static int
1818 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1819 {
1820   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1821     {
1822       log_info (_("error reading nonce on fd %d: %s\n"),
1823                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1824       assuan_sock_close (ctrl->thread_startup.fd);
1825       xfree (ctrl);
1826       return -1;
1827     }
1828   else
1829     return 0;
1830 }
1831
1832
1833 /* This is the standard connection thread's main function.  */
1834 static void *
1835 start_connection_thread (void *arg)
1836 {
1837   ctrl_t ctrl = arg;
1838
1839   if (check_nonce (ctrl, &socket_nonce))
1840     {
1841       log_error ("handler 0x%lx nonce check FAILED\n", pth_thread_id ());
1842       return NULL;
1843     }
1844
1845   agent_init_default_ctrl (ctrl);
1846   if (opt.verbose)
1847     log_info (_("handler 0x%lx for fd %d started\n"),
1848               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1849
1850   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1851   if (opt.verbose)
1852     log_info (_("handler 0x%lx for fd %d terminated\n"),
1853               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1854
1855   agent_deinit_default_ctrl (ctrl);
1856   xfree (ctrl);
1857   return NULL;
1858 }
1859
1860
1861 /* This is the ssh connection thread's main function.  */
1862 static void *
1863 start_connection_thread_ssh (void *arg)
1864 {
1865   ctrl_t ctrl = arg;
1866
1867   if (check_nonce (ctrl, &socket_nonce_ssh))
1868     return NULL;
1869
1870   agent_init_default_ctrl (ctrl);
1871   if (opt.verbose)
1872     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1873               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1874
1875   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1876   if (opt.verbose)
1877     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1878               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1879
1880   agent_deinit_default_ctrl (ctrl);
1881   xfree (ctrl);
1882   return NULL;
1883 }
1884
1885
1886 /* Connection handler loop.  Wait for connection requests and spawn a
1887    thread after accepting a connection.  */
1888 static void
1889 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1890 {
1891   pth_attr_t tattr;
1892   pth_event_t ev, time_ev;
1893   sigset_t sigs;
1894   int signo;
1895   struct sockaddr_un paddr;
1896   socklen_t plen;
1897   fd_set fdset, read_fdset;
1898   int ret;
1899   gnupg_fd_t fd;
1900   int nfd;
1901
1902   tattr = pth_attr_new();
1903   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1904   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1905
1906 #ifndef HAVE_W32_SYSTEM /* fixme */
1907   /* Make sure that the signals we are going to handle are not blocked
1908      and create an event object for them.  We also set the default
1909      action to ignore because we use an Pth event to get notified
1910      about signals.  This avoids that the default action is taken in
1911      case soemthing goes wrong within Pth.  The problem might also be
1912      a Pth bug.  */
1913   sigemptyset (&sigs );
1914   {
1915     static const int mysigs[] = { SIGHUP, SIGUSR1, SIGUSR2, SIGINT, SIGTERM };
1916     struct sigaction sa;
1917     int i;
1918
1919     for (i=0; i < DIM (mysigs); i++)
1920       {
1921         sigemptyset (&sa.sa_mask);
1922         sa.sa_handler = SIG_IGN;
1923         sa.sa_flags = 0;
1924         sigaction (mysigs[i], &sa, NULL);
1925
1926         sigaddset (&sigs, mysigs[i]);
1927       }
1928   }
1929
1930   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1931   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1932 #else
1933 # ifdef HAVE_W32CE_SYSTEM
1934   /* Use a dummy event. */
1935   sigs = 0;
1936   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1937 # else
1938   sigs = 0;
1939   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1940   signo = 0;
1941 # endif
1942 #endif
1943   time_ev = NULL;
1944
1945   /* Set a flag to tell call-scd.c that it may enable event
1946      notifications.  */
1947   opt.sigusr2_enabled = 1;
1948
1949   FD_ZERO (&fdset);
1950   FD_SET (FD2INT (listen_fd), &fdset);
1951   nfd = FD2INT (listen_fd);
1952   if (listen_fd_ssh != GNUPG_INVALID_FD)
1953     {
1954       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1955       if (FD2INT (listen_fd_ssh) > nfd)
1956         nfd = FD2INT (listen_fd_ssh);
1957     }
1958
1959   for (;;)
1960     {
1961       /* Make sure that our signals are not blocked.  */
1962       pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1963
1964       /* Shutdown test.  */
1965       if (shutdown_pending)
1966         {
1967           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1968             break; /* ready */
1969
1970           /* Do not accept new connections but keep on running the
1971              loop to cope with the timer events.  */
1972           FD_ZERO (&fdset);
1973         }
1974
1975       /* Create a timeout event if needed.  To help with power saving
1976          we syncronize the ticks to the next full second.  */
1977       if (!time_ev)
1978         {
1979           pth_time_t nexttick;
1980
1981           nexttick = pth_timeout (TIMERTICK_INTERVAL, 0);
1982           if (nexttick.tv_usec > 10)  /* Use a 10 usec threshhold.  */
1983             {
1984               nexttick.tv_sec++;
1985               nexttick.tv_usec = 0;
1986             }
1987           time_ev = pth_event (PTH_EVENT_TIME, nexttick);
1988         }
1989
1990       /* POSIX says that fd_set should be implemented as a structure,
1991          thus a simple assignment is fine to copy the entire set.  */
1992       read_fdset = fdset;
1993
1994       if (time_ev)
1995         pth_event_concat (ev, time_ev, NULL);
1996
1997       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1998       if (time_ev)
1999         pth_event_isolate (time_ev);
2000
2001       if (ret == -1)
2002         {
2003           if (pth_event_occurred (ev)
2004               || (time_ev && pth_event_occurred (time_ev)))
2005             {
2006               if (pth_event_occurred (ev))
2007                 {
2008 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
2009                   agent_sigusr2_action ();
2010 #else
2011                   handle_signal (signo);
2012 #endif
2013                 }
2014               if (time_ev && pth_event_occurred (time_ev))
2015                 {
2016                   pth_event_free (time_ev, PTH_FREE_ALL);
2017                   time_ev = NULL;
2018                   handle_tick ();
2019                 }
2020               continue;
2021             }
2022           log_error (_("pth_select failed: %s - waiting 1s\n"),
2023                      strerror (errno));
2024           pth_sleep (1);
2025           continue;
2026         }
2027
2028       if (pth_event_occurred (ev))
2029         {
2030 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
2031           agent_sigusr2_action ();
2032 #else
2033           handle_signal (signo);
2034 #endif
2035         }
2036
2037       if (time_ev && pth_event_occurred (time_ev))
2038         {
2039           pth_event_free (time_ev, PTH_FREE_ALL);
2040           time_ev = NULL;
2041           handle_tick ();
2042         }
2043
2044
2045       /* We now might create new threads and because we don't want any
2046          signals (as we are handling them here) to be delivered to a
2047          new thread.  Thus we need to block those signals. */
2048       pth_sigmask (SIG_BLOCK, &sigs, NULL);
2049
2050       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2051         {
2052           ctrl_t ctrl;
2053
2054           plen = sizeof paddr;
2055           fd = INT2FD (pth_accept (FD2INT(listen_fd),
2056                                    (struct sockaddr *)&paddr, &plen));
2057           if (fd == GNUPG_INVALID_FD)
2058             {
2059               log_error ("accept failed: %s\n", strerror (errno));
2060             }
2061           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2062             {
2063               log_error ("error allocating connection control data: %s\n",
2064                          strerror (errno) );
2065               assuan_sock_close (fd);
2066             }
2067           else if ( !(ctrl->session_env = session_env_new ()) )
2068             {
2069               log_error ("error allocating session environment block: %s\n",
2070                          strerror (errno) );
2071               xfree (ctrl);
2072               assuan_sock_close (fd);
2073             }
2074           else
2075             {
2076               char threadname[50];
2077
2078               snprintf (threadname, sizeof threadname-1,
2079                         "conn fd=%d (gpg)", FD2INT(fd));
2080               threadname[sizeof threadname -1] = 0;
2081               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2082               ctrl->thread_startup.fd = fd;
2083               if (!pth_spawn (tattr, start_connection_thread, ctrl))
2084                 {
2085                   log_error ("error spawning connection handler: %s\n",
2086                              strerror (errno) );
2087                   assuan_sock_close (fd);
2088                   xfree (ctrl);
2089                 }
2090             }
2091           fd = GNUPG_INVALID_FD;
2092         }
2093
2094       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD
2095           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2096         {
2097           ctrl_t ctrl;
2098
2099           plen = sizeof paddr;
2100           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
2101                                   (struct sockaddr *)&paddr, &plen));
2102           if (fd == GNUPG_INVALID_FD)
2103             {
2104               log_error ("accept failed for ssh: %s\n", strerror (errno));
2105             }
2106           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2107             {
2108               log_error ("error allocating connection control data: %s\n",
2109                          strerror (errno) );
2110               assuan_sock_close (fd);
2111             }
2112           else if ( !(ctrl->session_env = session_env_new ()) )
2113             {
2114               log_error ("error allocating session environment block: %s\n",
2115                          strerror (errno) );
2116               xfree (ctrl);
2117               assuan_sock_close (fd);
2118             }
2119           else
2120             {
2121               char threadname[50];
2122
2123               agent_init_default_ctrl (ctrl);
2124               snprintf (threadname, sizeof threadname-1,
2125                         "conn fd=%d (ssh)", FD2INT(fd));
2126               threadname[sizeof threadname -1] = 0;
2127               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2128               ctrl->thread_startup.fd = fd;
2129               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
2130                 {
2131                   log_error ("error spawning ssh connection handler: %s\n",
2132                              strerror (errno) );
2133                   assuan_sock_close (fd);
2134                   xfree (ctrl);
2135                 }
2136             }
2137           fd = GNUPG_INVALID_FD;
2138         }
2139     }
2140
2141   pth_event_free (ev, PTH_FREE_ALL);
2142   if (time_ev)
2143     pth_event_free (time_ev, PTH_FREE_ALL);
2144   cleanup ();
2145   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2146 }
2147
2148
2149
2150 /* Helper for check_own_socket.  */
2151 static gpg_error_t
2152 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2153 {
2154   membuf_t *mb = opaque;
2155   put_membuf (mb, buffer, length);
2156   return 0;
2157 }
2158
2159
2160 /* The thread running the actual check.  We need to run this in a
2161    separate thread so that check_own_thread can be called from the
2162    timer tick.  */
2163 static void *
2164 check_own_socket_thread (void *arg)
2165 {
2166   int rc;
2167   char *sockname = arg;
2168   assuan_context_t ctx = NULL;
2169   membuf_t mb;
2170   char *buffer;
2171
2172   check_own_socket_running++;
2173
2174   rc = assuan_new (&ctx);
2175   if (rc)
2176     {
2177       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2178       goto leave;
2179     }
2180
2181   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2182   if (rc)
2183     {
2184       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2185       goto leave;
2186     }
2187
2188   init_membuf (&mb, 100);
2189   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2190                         NULL, NULL, NULL, NULL);
2191   put_membuf (&mb, "", 1);
2192   buffer = get_membuf (&mb, NULL);
2193   if (rc || !buffer)
2194     {
2195       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2196                  "GETINFO pid", gpg_strerror (rc));
2197       rc = 1;
2198     }
2199   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2200     {
2201       log_error ("socket is now serviced by another server\n");
2202       rc = 1;
2203     }
2204   else if (opt.verbose > 1)
2205     log_error ("socket is still served by this server\n");
2206
2207   xfree (buffer);
2208
2209  leave:
2210   xfree (sockname);
2211   if (ctx)
2212     assuan_release (ctx);
2213   if (rc)
2214     {
2215       /* We may not remove the socket as it is now in use by another
2216          server.  Setting the name to empty does this.  */
2217       if (socket_name)
2218         *socket_name = 0;
2219       if (socket_name_ssh)
2220         *socket_name_ssh = 0;
2221       shutdown_pending = 2;
2222       log_info ("this process is useless - shutting down\n");
2223     }
2224   check_own_socket_running--;
2225   return NULL;
2226 }
2227
2228
2229 /* Check whether we are still listening on our own socket.  In case
2230    another gpg-agent process started after us has taken ownership of
2231    our socket, we would linger around without any real task.  Thus we
2232    better check once in a while whether we are really needed.  */
2233 static void
2234 check_own_socket (void)
2235 {
2236   char *sockname;
2237   pth_attr_t tattr;
2238
2239   if (!opt.use_standard_socket)
2240     return; /* This check makes only sense in standard socket mode.  */
2241
2242   if (check_own_socket_running || shutdown_pending)
2243     return;  /* Still running or already shutting down.  */
2244
2245   sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
2246   if (!sockname)
2247     return; /* Out of memory.  */
2248
2249   tattr = pth_attr_new();
2250   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
2251   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
2252   pth_attr_set (tattr, PTH_ATTR_NAME, "check-own-socket");
2253
2254   if (!pth_spawn (tattr, check_own_socket_thread, sockname))
2255       log_error ("error spawning check_own_socket_thread: %s\n",
2256                  strerror (errno) );
2257   pth_attr_destroy (tattr);
2258 }
2259
2260
2261
2262 /* Figure out whether an agent is available and running. Prints an
2263    error if not.  If SILENT is true, no messages are printed.  Usually
2264    started with MODE 0.  Returns 0 if the agent is running. */
2265 static int
2266 check_for_running_agent (int silent, int mode)
2267 {
2268   int rc;
2269   char *infostr, *p;
2270   assuan_context_t ctx = NULL;
2271   int prot, pid;
2272
2273   if (!mode)
2274     {
2275       infostr = getenv ("GPG_AGENT_INFO");
2276       if (!infostr || !*infostr)
2277         {
2278           if (!check_for_running_agent (silent, 1))
2279             return 0; /* Okay, its running on the standard socket. */
2280           if (!silent)
2281             log_error (_("no gpg-agent running in this session\n"));
2282           return -1;
2283         }
2284
2285       infostr = xstrdup (infostr);
2286       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2287         {
2288           xfree (infostr);
2289           if (!check_for_running_agent (silent, 1))
2290             return 0; /* Okay, its running on the standard socket. */
2291           if (!silent)
2292             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
2293           return -1;
2294         }
2295
2296       *p++ = 0;
2297       pid = atoi (p);
2298       while (*p && *p != PATHSEP_C)
2299         p++;
2300       prot = *p? atoi (p+1) : 0;
2301       if (prot != 1)
2302         {
2303           xfree (infostr);
2304           if (!silent)
2305             log_error (_("gpg-agent protocol version %d is not supported\n"),
2306                        prot);
2307           if (!check_for_running_agent (silent, 1))
2308             return 0; /* Okay, its running on the standard socket. */
2309           return -1;
2310         }
2311     }
2312   else /* MODE != 0 */
2313     {
2314       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
2315       pid = (pid_t)(-1);
2316     }
2317
2318   rc = assuan_new (&ctx);
2319   if (! rc)
2320     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2321   xfree (infostr);
2322   if (rc)
2323     {
2324       if (!mode && !check_for_running_agent (silent, 1))
2325         return 0; /* Okay, its running on the standard socket. */
2326
2327       if (!mode && !silent)
2328         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2329
2330       if (ctx)
2331         assuan_release (ctx);
2332       return -1;
2333     }
2334
2335   if (!opt.quiet && !silent)
2336     log_info ("gpg-agent running and available\n");
2337
2338   assuan_release (ctx);
2339   return 0;
2340 }
2341
2342 /* TODO: it is also in misc, which is not linked with the agent */
2343 /* FIXME: The agent should not know about openpgp internals - weel
2344    except for some stuff in cvt-openpgp.  */
2345 int
2346 map_pk_openpgp_to_gcry (int algo)
2347 {
2348   return (algo==PUBKEY_ALGO_ECDSA ? GCRY_PK_ECDSA : (algo==PUBKEY_ALGO_ECDH ? GCRY_PK_ECDH : algo));
2349 }