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