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