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