0ebba1e1302e8e12518dc11c99b01bf14a6d837e
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000-2007, 2009-2010 Free Software Foundation, Inc.
3  * Copyright (C) 2000-2016 Werner Koch
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 #ifdef HAVE_W32_SYSTEM
34 # ifndef WINVER
35 #  define WINVER 0x0500  /* Same as in common/sysutils.c */
36 # endif
37 # ifdef HAVE_WINSOCK2_H
38 #  include <winsock2.h>
39 # endif
40 # include <aclapi.h>
41 # include <sddl.h>
42 #else /*!HAVE_W32_SYSTEM*/
43 # include <sys/socket.h>
44 # include <sys/un.h>
45 #endif /*!HAVE_W32_SYSTEM*/
46 #include <unistd.h>
47 #ifdef HAVE_SIGNAL_H
48 # include <signal.h>
49 #endif
50 #ifdef HAVE_INOTIFY_INIT
51 # include <sys/inotify.h>
52 #endif /*HAVE_INOTIFY_INIT*/
53 #include <npth.h>
54
55 #define GNUPG_COMMON_NEED_AFLOCAL
56 #include "agent.h"
57 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
58
59 #include "i18n.h"
60 #include "sysutils.h"
61 #include "gc-opt-flags.h"
62 #include "exechelp.h"
63 #include "asshelp.h"
64 #include "../common/init.h"
65
66
67 enum cmd_and_opt_values
68 { aNull = 0,
69   oCsh            = 'c',
70   oQuiet          = 'q',
71   oSh             = 's',
72   oVerbose        = 'v',
73
74   oNoVerbose = 500,
75   aGPGConfList,
76   aGPGConfTest,
77   aUseStandardSocketP,
78   oOptions,
79   oDebug,
80   oDebugAll,
81   oDebugLevel,
82   oDebugWait,
83   oDebugQuickRandom,
84   oDebugPinentry,
85   oNoGreeting,
86   oNoOptions,
87   oHomedir,
88   oNoDetach,
89   oNoGrab,
90   oLogFile,
91   oServer,
92   oDaemon,
93   oSupervised,
94   oBatch,
95
96   oPinentryProgram,
97   oPinentryTouchFile,
98   oPinentryInvisibleChar,
99   oPinentryTimeout,
100   oDisplay,
101   oTTYname,
102   oTTYtype,
103   oLCctype,
104   oLCmessages,
105   oXauthority,
106   oScdaemonProgram,
107   oDefCacheTTL,
108   oDefCacheTTLSSH,
109   oMaxCacheTTL,
110   oMaxCacheTTLSSH,
111   oEnforcePassphraseConstraints,
112   oMinPassphraseLen,
113   oMinPassphraseNonalpha,
114   oCheckPassphrasePattern,
115   oMaxPassphraseDays,
116   oEnablePassphraseHistory,
117   oUseStandardSocket,
118   oNoUseStandardSocket,
119   oExtraSocket,
120   oBrowserSocket,
121   oFakedSystemTime,
122
123   oIgnoreCacheForSigning,
124   oAllowMarkTrusted,
125   oNoAllowMarkTrusted,
126   oAllowPresetPassphrase,
127   oAllowLoopbackPinentry,
128   oNoAllowLoopbackPinentry,
129   oNoAllowExternalCache,
130   oAllowEmacsPinentry,
131   oKeepTTY,
132   oKeepDISPLAY,
133   oSSHSupport,
134   oPuttySupport,
135   oDisableScdaemon,
136   oDisableCheckOwnSocket,
137   oWriteEnvFile
138 };
139
140
141 #ifndef ENAMETOOLONG
142 # define ENAMETOOLONG EINVAL
143 #endif
144
145
146 static ARGPARSE_OPTS opts[] = {
147
148   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
149   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
150   ARGPARSE_c (aUseStandardSocketP, "use-standard-socket-p", "@"),
151
152   ARGPARSE_group (301, N_("@Options:\n ")),
153
154   ARGPARSE_s_n (oDaemon,  "daemon", N_("run in daemon mode (background)")),
155   ARGPARSE_s_n (oServer,  "server", N_("run in server mode (foreground)")),
156 #ifndef HAVE_W32_SYSTEM
157   ARGPARSE_s_n (oSupervised,  "supervised", N_("run in supervised mode")),
158 #endif
159   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
160   ARGPARSE_s_n (oQuiet,   "quiet",     N_("be somewhat more quiet")),
161   ARGPARSE_s_n (oSh,      "sh",        N_("sh-style command output")),
162   ARGPARSE_s_n (oCsh,     "csh",       N_("csh-style command output")),
163   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
164
165   ARGPARSE_s_s (oDebug,      "debug",       "@"),
166   ARGPARSE_s_n (oDebugAll,   "debug-all",   "@"),
167   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
168   ARGPARSE_s_i (oDebugWait,"  debug-wait",  "@"),
169   ARGPARSE_s_n (oDebugQuickRandom, "debug-quick-random", "@"),
170   ARGPARSE_s_n (oDebugPinentry, "debug-pinentry", "@"),
171
172   ARGPARSE_s_n (oNoDetach,  "no-detach", N_("do not detach from the console")),
173   ARGPARSE_s_n (oNoGrab,    "no-grab",   N_("do not grab keyboard and mouse")),
174   ARGPARSE_s_s (oLogFile,   "log-file",  N_("use a log file for the server")),
175   ARGPARSE_s_s (oPinentryProgram, "pinentry-program",
176                 /* */             N_("|PGM|use PGM as the PIN-Entry program")),
177   ARGPARSE_s_s (oPinentryTouchFile, "pinentry-touch-file", "@"),
178   ARGPARSE_s_s (oPinentryInvisibleChar, "pinentry-invisible-char", "@"),
179   ARGPARSE_s_u (oPinentryTimeout, "pinentry-timeout", "@"),
180   ARGPARSE_s_s (oScdaemonProgram, "scdaemon-program",
181                 /* */             N_("|PGM|use PGM as the SCdaemon program") ),
182   ARGPARSE_s_n (oDisableScdaemon, "disable-scdaemon",
183                 /* */             N_("do not use the SCdaemon") ),
184   ARGPARSE_s_n (oDisableCheckOwnSocket, "disable-check-own-socket", "@"),
185
186   ARGPARSE_s_s (oExtraSocket, "extra-socket",
187                 /* */       N_("|NAME|accept some commands via NAME")),
188
189   ARGPARSE_s_s (oBrowserSocket, "browser-socket", "@"),
190
191   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
192
193   ARGPARSE_s_n (oBatch,      "batch",        "@"),
194   ARGPARSE_s_s (oHomedir,    "homedir",      "@"),
195
196   ARGPARSE_s_s (oDisplay,    "display",     "@"),
197   ARGPARSE_s_s (oTTYname,    "ttyname",     "@"),
198   ARGPARSE_s_s (oTTYtype,    "ttytype",     "@"),
199   ARGPARSE_s_s (oLCctype,    "lc-ctype",    "@"),
200   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
201   ARGPARSE_s_s (oXauthority, "xauthority",  "@"),
202   ARGPARSE_s_n (oKeepTTY,    "keep-tty",
203                 /* */        N_("ignore requests to change the TTY")),
204   ARGPARSE_s_n (oKeepDISPLAY, "keep-display",
205                 /* */        N_("ignore requests to change the X display")),
206
207   ARGPARSE_s_u (oDefCacheTTL,    "default-cache-ttl",
208                                  N_("|N|expire cached PINs after N seconds")),
209   ARGPARSE_s_u (oDefCacheTTLSSH, "default-cache-ttl-ssh", "@" ),
210   ARGPARSE_s_u (oMaxCacheTTL,    "max-cache-ttl",         "@" ),
211   ARGPARSE_s_u (oMaxCacheTTLSSH, "max-cache-ttl-ssh",     "@" ),
212
213   ARGPARSE_s_n (oEnforcePassphraseConstraints, "enforce-passphrase-constraints",
214                 /* */                          "@"),
215   ARGPARSE_s_u (oMinPassphraseLen,        "min-passphrase-len", "@"),
216   ARGPARSE_s_u (oMinPassphraseNonalpha,   "min-passphrase-nonalpha", "@"),
217   ARGPARSE_s_s (oCheckPassphrasePattern,  "check-passphrase-pattern", "@"),
218   ARGPARSE_s_u (oMaxPassphraseDays,       "max-passphrase-days", "@"),
219   ARGPARSE_s_n (oEnablePassphraseHistory, "enable-passphrase-history", "@"),
220
221   ARGPARSE_s_n (oIgnoreCacheForSigning, "ignore-cache-for-signing",
222                 /* */    N_("do not use the PIN cache when signing")),
223   ARGPARSE_s_n (oNoAllowExternalCache,  "no-allow-external-cache",
224                 /* */    N_("disallow the use of an external password cache")),
225   ARGPARSE_s_n (oNoAllowMarkTrusted, "no-allow-mark-trusted",
226                 /* */    N_("disallow clients to mark keys as \"trusted\"")),
227   ARGPARSE_s_n (oAllowMarkTrusted,   "allow-mark-trusted", "@"),
228   ARGPARSE_s_n (oAllowPresetPassphrase, "allow-preset-passphrase",
229                 /* */                    N_("allow presetting passphrase")),
230   ARGPARSE_s_n (oNoAllowLoopbackPinentry, "no-allow-loopback-pinentry",
231                                 N_("disallow caller to override the pinentry")),
232   ARGPARSE_s_n (oAllowLoopbackPinentry, "allow-loopback-pinentry", "@"),
233   ARGPARSE_s_n (oAllowEmacsPinentry,  "allow-emacs-pinentry",
234                 /* */    N_("allow passphrase to be prompted through Emacs")),
235
236   ARGPARSE_s_n (oSSHSupport,   "enable-ssh-support", N_("enable ssh support")),
237   ARGPARSE_s_n (oPuttySupport, "enable-putty-support",
238 #ifdef HAVE_W32_SYSTEM
239                 /* */           N_("enable putty support")
240 #else
241                 /* */           "@"
242 #endif
243                 ),
244
245   /* Dummy options for backward compatibility.  */
246   ARGPARSE_o_s (oWriteEnvFile, "write-env-file", "@"),
247   ARGPARSE_s_n (oUseStandardSocket, "use-standard-socket", "@"),
248   ARGPARSE_s_n (oNoUseStandardSocket, "no-use-standard-socket", "@"),
249
250   {0} /* End of list */
251 };
252
253
254 /* The list of supported debug flags.  */
255 static struct debug_flags_s debug_flags [] =
256   {
257     { DBG_COMMAND_VALUE, "command"  },
258     { DBG_MPI_VALUE    , "mpi"     },
259     { DBG_CRYPTO_VALUE , "crypto"  },
260     { DBG_MEMORY_VALUE , "memory"  },
261     { DBG_CACHE_VALUE  , "cache"   },
262     { DBG_MEMSTAT_VALUE, "memstat" },
263     { DBG_HASHING_VALUE, "hashing" },
264     { DBG_IPC_VALUE    , "ipc"     },
265     { 77, NULL } /* 77 := Do not exit on "help" or "?".  */
266   };
267
268
269
270 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
271 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
272 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
273 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
274 #define MIN_PASSPHRASE_LEN    (8)
275 #define MIN_PASSPHRASE_NONALPHA (1)
276 #define MAX_PASSPHRASE_DAYS   (0)
277
278 /* The timer tick used for housekeeping stuff.  For Windows we use a
279    longer period as the SetWaitableTimer seems to signal earlier than
280    the 2 seconds.  CHECK_OWN_SOCKET_INTERVAL defines how often we
281    check our own socket in standard socket mode.  If that value is 0
282    we don't check at all.   All values are in seconds. */
283 #if defined(HAVE_W32CE_SYSTEM)
284 # define TIMERTICK_INTERVAL         (60)
285 # define CHECK_OWN_SOCKET_INTERVAL   (0)  /* Never */
286 #elif defined(HAVE_W32_SYSTEM)
287 # define TIMERTICK_INTERVAL          (4)
288 # define CHECK_OWN_SOCKET_INTERVAL  (60)
289 #else
290 # define TIMERTICK_INTERVAL          (2)
291 # define CHECK_OWN_SOCKET_INTERVAL  (60)
292 #endif
293
294
295 /* Flag indicating that the ssh-agent subsystem has been enabled.  */
296 static int ssh_support;
297
298 #ifdef HAVE_W32_SYSTEM
299 /* Flag indicating that support for Putty has been enabled.  */
300 static int putty_support;
301 /* A magic value used with WM_COPYDATA.  */
302 #define PUTTY_IPC_MAGIC 0x804e50ba
303 /* To avoid surprises we limit the size of the mapped IPC file to this
304    value.  Putty currently (0.62) uses 8k, thus 16k should be enough
305    for the foreseeable future.  */
306 #define PUTTY_IPC_MAXLEN 16384
307 #endif /*HAVE_W32_SYSTEM*/
308
309 /* The list of open file descriptors at startup.  Note that this list
310    has been allocated using the standard malloc.  */
311 static int *startup_fd_list;
312
313 /* The signal mask at startup and a flag telling whether it is valid.  */
314 #ifdef HAVE_SIGPROCMASK
315 static sigset_t startup_signal_mask;
316 static int startup_signal_mask_valid;
317 #endif
318
319 /* Flag to indicate that a shutdown was requested.  */
320 static int shutdown_pending;
321
322 /* Counter for the currently running own socket checks.  */
323 static int check_own_socket_running;
324
325 /* Flags to indicate that check_own_socket shall not be called.  */
326 static int disable_check_own_socket;
327
328 /* Flag indicating that we are in supervised mode.  */
329 static int is_supervised;
330
331 /* Flag to inhibit socket removal in cleanup.  */
332 static int inhibit_socket_removal;
333
334 /* It is possible that we are currently running under setuid permissions */
335 static int maybe_setuid = 1;
336
337 /* Name of the communication socket used for native gpg-agent
338    requests. The second variable is either NULL or a malloced string
339    with the real socket name in case it has been redirected.  */
340 static char *socket_name;
341 static char *redir_socket_name;
342
343 /* Name of the optional extra socket used for native gpg-agent requests.  */
344 static char *socket_name_extra;
345 static char *redir_socket_name_extra;
346
347 /* Name of the optional browser socket used for native gpg-agent requests.  */
348 static char *socket_name_browser;
349 static char *redir_socket_name_browser;
350
351 /* Name of the communication socket used for ssh-agent-emulation.  */
352 static char *socket_name_ssh;
353 static char *redir_socket_name_ssh;
354
355 /* We need to keep track of the server's nonces (these are dummies for
356    POSIX systems). */
357 static assuan_sock_nonce_t socket_nonce;
358 static assuan_sock_nonce_t socket_nonce_extra;
359 static assuan_sock_nonce_t socket_nonce_browser;
360 static assuan_sock_nonce_t socket_nonce_ssh;
361
362
363 /* Default values for options passed to the pinentry. */
364 static char *default_display;
365 static char *default_ttyname;
366 static char *default_ttytype;
367 static char *default_lc_ctype;
368 static char *default_lc_messages;
369 static char *default_xauthority;
370
371 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
372 static char *config_filename;
373
374 /* Helper to implement --debug-level */
375 static const char *debug_level;
376
377 /* Keep track of the current log file so that we can avoid updating
378    the log file after a SIGHUP if it didn't changed. Malloced. */
379 static char *current_logfile;
380
381 /* The handle_tick() function may test whether a parent is still
382    running.  We record the PID of the parent here or -1 if it should be
383    watched. */
384 static pid_t parent_pid = (pid_t)(-1);
385
386 /* Number of active connections.  */
387 static int active_connections;
388
389 /* This object is used to dispatch progress messages from Libgcrypt to
390  * the right thread.  Given that we won't have at max a few dozen
391  * connections at the same time using a linked list is the easiest way
392  * to handle this. */
393 struct progress_dispatch_s
394 {
395   struct progress_dispatch_s *next;
396   /* The control object of the connection.  If this is NULL no
397    * connection is associated with this item and it is free for reuse
398    * by new connections.  */
399   ctrl_t ctrl;
400
401   /* The thread id of (npth_self) of the connection.  */
402   npth_t tid;
403
404   /* The callback set by the connection.  This is similar to the
405    * Libgcrypt callback but with the control object passed as the
406    * first argument.  */
407   void (*cb)(ctrl_t ctrl,
408              const char *what, int printchar,
409              int current, int total);
410 };
411 struct progress_dispatch_s *progress_dispatch_list;
412
413
414
415 \f
416 /*
417    Local prototypes.
418  */
419
420 static char *create_socket_name (char *standard_name, int with_homedir);
421 static gnupg_fd_t create_server_socket (char *name, int primary, int cygwin,
422                                         char **r_redir_name,
423                                         assuan_sock_nonce_t *nonce);
424 static void create_directories (void);
425
426 static void agent_libgcrypt_progress_cb (void *data, const char *what,
427                                          int printchar,
428                                          int current, int total);
429 static void agent_init_default_ctrl (ctrl_t ctrl);
430 static void agent_deinit_default_ctrl (ctrl_t ctrl);
431
432 static void handle_connections (gnupg_fd_t listen_fd,
433                                 gnupg_fd_t listen_fd_extra,
434                                 gnupg_fd_t listen_fd_browser,
435                                 gnupg_fd_t listen_fd_ssh);
436 static void check_own_socket (void);
437 static int check_for_running_agent (int silent);
438
439 /* Pth wrapper function definitions. */
440 ASSUAN_SYSTEM_NPTH_IMPL;
441
442 \f
443 /*
444    Functions.
445  */
446
447 /* Allocate a string describing a library version by calling a GETFNC.
448    This function is expected to be called only once.  GETFNC is
449    expected to have a semantic like gcry_check_version ().  */
450 static char *
451 make_libversion (const char *libname, const char *(*getfnc)(const char*))
452 {
453   const char *s;
454   char *result;
455
456   if (maybe_setuid)
457     {
458       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
459       maybe_setuid = 0;
460     }
461   s = getfnc (NULL);
462   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
463   strcpy (stpcpy (stpcpy (result, libname), " "), s);
464   return result;
465 }
466
467 /* Return strings describing this program.  The case values are
468    described in common/argparse.c:strusage.  The values here override
469    the default values given by strusage.  */
470 static const char *
471 my_strusage (int level)
472 {
473   static char *ver_gcry;
474   const char *p;
475
476   switch (level)
477     {
478     case 11: p = "@GPG_AGENT@ (@GNUPG@)";
479       break;
480     case 13: p = VERSION; break;
481     case 17: p = PRINTABLE_OS_NAME; break;
482       /* TRANSLATORS: @EMAIL@ will get replaced by the actual bug
483          reporting address.  This is so that we can change the
484          reporting address without breaking the translations.  */
485     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
486
487     case 20:
488       if (!ver_gcry)
489         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
490       p = ver_gcry;
491       break;
492
493     case 1:
494     case 40: p =  _("Usage: @GPG_AGENT@ [options] (-h for help)");
495       break;
496     case 41: p =  _("Syntax: @GPG_AGENT@ [options] [command [args]]\n"
497                     "Secret key management for @GNUPG@\n");
498     break;
499
500     default: p = NULL;
501     }
502   return p;
503 }
504
505
506
507 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
508    only the active debug flags are propagated to the subsystems.  With
509    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
510    all flags already set. Note that we don't fail here, because it is
511    important to keep gpg-agent running even after re-reading the
512    options due to a SIGHUP. */
513 static void
514 set_debug (void)
515 {
516   int numok = (debug_level && digitp (debug_level));
517   int numlvl = numok? atoi (debug_level) : 0;
518
519   if (!debug_level)
520     ;
521   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
522     opt.debug = 0;
523   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
524     opt.debug = DBG_IPC_VALUE;
525   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
526     opt.debug = DBG_IPC_VALUE|DBG_COMMAND_VALUE;
527   else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
528     opt.debug = (DBG_IPC_VALUE|DBG_COMMAND_VALUE
529                  |DBG_CACHE_VALUE);
530   else if (!strcmp (debug_level, "guru") || numok)
531     {
532       opt.debug = ~0;
533       /* Unless the "guru" string has been used we don't want to allow
534          hashing debugging.  The rationale is that people tend to
535          select the highest debug value and would then clutter their
536          disk with debug files which may reveal confidential data.  */
537       if (numok)
538         opt.debug &= ~(DBG_HASHING_VALUE);
539     }
540   else
541     {
542       log_error (_("invalid debug-level '%s' given\n"), debug_level);
543       opt.debug = 0; /* Reset debugging, so that prior debug
544                         statements won't have an undesired effect. */
545     }
546
547   if (opt.debug && !opt.verbose)
548     opt.verbose = 1;
549   if (opt.debug && opt.quiet)
550     opt.quiet = 0;
551
552   if (opt.debug & DBG_MPI_VALUE)
553     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
554   if (opt.debug & DBG_CRYPTO_VALUE )
555     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
556   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
557
558   if (opt.debug)
559     parse_debug_flag (NULL, &opt.debug, debug_flags);
560 }
561
562
563 /* Helper for cleanup to remove one socket with NAME.  REDIR_NAME is
564    the corresponding real name if the socket has been redirected.  */
565 static void
566 remove_socket (char *name, char *redir_name)
567 {
568   if (name && *name)
569     {
570       if (redir_name)
571         name = redir_name;
572
573       gnupg_remove (name);
574       *name = 0;
575     }
576 }
577
578
579 /* Cleanup code for this program.  This is either called has an atexit
580    handler or directly.  */
581 static void
582 cleanup (void)
583 {
584   static int done;
585
586   if (done)
587     return;
588   done = 1;
589   deinitialize_module_cache ();
590   if (!is_supervised && !inhibit_socket_removal)
591     {
592       remove_socket (socket_name, redir_socket_name);
593       if (opt.extra_socket > 1)
594         remove_socket (socket_name_extra, redir_socket_name_extra);
595       if (opt.browser_socket > 1)
596         remove_socket (socket_name_browser, redir_socket_name_browser);
597       remove_socket (socket_name_ssh, redir_socket_name_ssh);
598     }
599 }
600
601
602
603 /* Handle options which are allowed to be reset after program start.
604    Return true when the current option in PARGS could be handled and
605    false if not.  As a special feature, passing a value of NULL for
606    PARGS, resets the options to the default.  REREAD should be set
607    true if it is not the initial option parsing. */
608 static int
609 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
610 {
611   if (!pargs)
612     { /* reset mode */
613       opt.quiet = 0;
614       opt.verbose = 0;
615       opt.debug = 0;
616       opt.no_grab = 0;
617       opt.debug_pinentry = 0;
618       opt.pinentry_program = NULL;
619       opt.pinentry_touch_file = NULL;
620       xfree (opt.pinentry_invisible_char);
621       opt.pinentry_invisible_char = NULL;
622       opt.pinentry_timeout = 0;
623       opt.scdaemon_program = NULL;
624       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
625       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
626       opt.max_cache_ttl = MAX_CACHE_TTL;
627       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
628       opt.enforce_passphrase_constraints = 0;
629       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
630       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
631       opt.check_passphrase_pattern = NULL;
632       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
633       opt.enable_passhrase_history = 0;
634       opt.ignore_cache_for_signing = 0;
635       opt.allow_mark_trusted = 1;
636       opt.allow_external_cache = 1;
637       opt.allow_loopback_pinentry = 1;
638       opt.allow_emacs_pinentry = 0;
639       opt.disable_scdaemon = 0;
640       disable_check_own_socket = 0;
641       return 1;
642     }
643
644   switch (pargs->r_opt)
645     {
646     case oQuiet: opt.quiet = 1; break;
647     case oVerbose: opt.verbose++; break;
648
649     case oDebug:
650       parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags);
651       break;
652     case oDebugAll: opt.debug = ~0; break;
653     case oDebugLevel: debug_level = pargs->r.ret_str; break;
654     case oDebugPinentry: opt.debug_pinentry = 1; break;
655
656     case oLogFile:
657       if (!reread)
658         return 0; /* not handeld */
659       if (!current_logfile || !pargs->r.ret_str
660           || strcmp (current_logfile, pargs->r.ret_str))
661         {
662           log_set_file (pargs->r.ret_str);
663           xfree (current_logfile);
664           current_logfile = xtrystrdup (pargs->r.ret_str);
665         }
666       break;
667
668     case oNoGrab: opt.no_grab = 1; break;
669
670     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
671     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
672     case oPinentryInvisibleChar:
673       xfree (opt.pinentry_invisible_char);
674       opt.pinentry_invisible_char = xtrystrdup (pargs->r.ret_str); break;
675       break;
676     case oPinentryTimeout: opt.pinentry_timeout = pargs->r.ret_ulong; break;
677     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
678     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
679     case oDisableCheckOwnSocket: disable_check_own_socket = 1; break;
680
681     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
682     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
683     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
684     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
685
686     case oEnforcePassphraseConstraints:
687       opt.enforce_passphrase_constraints=1;
688       break;
689     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
690     case oMinPassphraseNonalpha:
691       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
692       break;
693     case oCheckPassphrasePattern:
694       opt.check_passphrase_pattern = pargs->r.ret_str;
695       break;
696     case oMaxPassphraseDays:
697       opt.max_passphrase_days = pargs->r.ret_ulong;
698       break;
699     case oEnablePassphraseHistory:
700       opt.enable_passhrase_history = 1;
701       break;
702
703     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
704
705     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
706     case oNoAllowMarkTrusted: opt.allow_mark_trusted = 0; break;
707
708     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
709
710     case oAllowLoopbackPinentry: opt.allow_loopback_pinentry = 1; break;
711     case oNoAllowLoopbackPinentry: opt.allow_loopback_pinentry = 0; break;
712
713     case oNoAllowExternalCache: opt.allow_external_cache = 0;
714       break;
715
716     case oAllowEmacsPinentry: opt.allow_emacs_pinentry = 1;
717       break;
718
719     default:
720       return 0; /* not handled */
721     }
722
723   return 1; /* handled */
724 }
725
726
727 /* Fixup some options after all have been processed.  */
728 static void
729 finalize_rereadable_options (void)
730 {
731 }
732
733
734 static void
735 thread_init_once (void)
736 {
737   static int npth_initialized = 0;
738
739   if (!npth_initialized)
740     {
741       npth_initialized++;
742       npth_init ();
743     }
744 }
745
746
747 static void
748 initialize_modules (void)
749 {
750   thread_init_once ();
751   assuan_set_system_hooks (ASSUAN_SYSTEM_NPTH);
752   initialize_module_cache ();
753   initialize_module_call_pinentry ();
754   initialize_module_call_scd ();
755   initialize_module_trustlist ();
756 }
757
758
759 /* return a malloc'ed string that is the path to the passed unix-domain socket
760    (or return NULL if this is not a valid unix-domain socket) */
761 static char *
762 get_socket_path (gnupg_fd_t fd)
763 {
764 #ifdef HAVE_W32_SYSTEM
765   return NULL;
766 #else
767   struct sockaddr_un un;
768   socklen_t len = sizeof(un);
769   char *ret = NULL;
770
771   if (fd == GNUPG_INVALID_FD)
772     return NULL;
773
774   if (getsockname (fd, (struct sockaddr*)&un, &len) != 0)
775     log_error ("could not getsockname(%d) -- error %d (%s)\n", fd,
776                errno, strerror(errno));
777   else if (un.sun_family != AF_UNIX)
778     log_error ("file descriptor %d is not a unix-domain socket\n", fd);
779   else if (len <= offsetof (struct sockaddr_un, sun_path))
780     log_error ("socket path not present for file descriptor %d\n", fd);
781   else if (len > sizeof(un))
782     log_error ("socket path for file descriptor %d was truncated "
783                "(passed %lu bytes, wanted %u)\n", fd, sizeof(un), len);
784   else
785     {
786       log_debug ("file descriptor %d has path %s (%lu octets)\n", fd,
787                  un.sun_path, len - offsetof (struct sockaddr_un, sun_path));
788       ret = malloc(len - offsetof (struct sockaddr_un, sun_path));
789       if (ret == NULL)
790         log_error ("failed to allocate memory for path to file "
791                    "descriptor %d\n", fd);
792       else
793         memcpy (ret, un.sun_path, len);
794     }
795   return ret;
796 #endif /* HAVE_W32_SYSTEM */
797 }
798
799
800 /* Discover which inherited file descriptors correspond to which
801    services/sockets offered by gpg-agent, using the LISTEN_FDS and
802    LISTEN_FDNAMES convention.  The understood labels are "ssh",
803    "extra", and "browser".  Any other label will be interpreted as the
804    standard socket.
805
806    This function is designed to log errors when the expected file
807    descriptors don't make sense, but to do its best to continue to
808    work even in the face of minor misconfigurations.
809
810    For more information on the LISTEN_FDS convention, see
811    sd_listen_fds(3).
812  */
813 static void
814 map_supervised_sockets (gnupg_fd_t *fd,
815                         gnupg_fd_t *fd_extra,
816                         gnupg_fd_t *fd_browser,
817                         gnupg_fd_t *fd_ssh)
818 {
819   const char *listen_pid = NULL;
820   const char *listen_fds = NULL;
821   const char *listen_fdnames = NULL;
822   int listen_fd_count = -1;
823   int listen_fdnames_colons = 0;
824   const char *fdnamep = NULL;
825
826   listen_pid = getenv ("LISTEN_PID");
827   listen_fds = getenv ("LISTEN_FDS");
828   listen_fdnames = getenv ("LISTEN_FDNAMES");
829
830   if (!listen_pid)
831     log_error ("no $LISTEN_PID environment variable found in "
832                "--supervised mode (ignoring).\n");
833   else if (atoi (listen_pid) != getpid ())
834     log_error ("$LISTEN_PID (%d) does not match process ID (%d) "
835                "in --supervised mode (ignoring).\n",
836                atoi (listen_pid), getpid ());
837   else
838     log_debug ("$LISTEN_PID matches process ID (%d)\n",
839                getpid());
840
841   if (listen_fdnames)
842     for (fdnamep = listen_fdnames; *fdnamep; fdnamep++)
843       if (*fdnamep == ':')
844         listen_fdnames_colons++;
845   log_debug ("%d colon(s) in $LISTEN_FDNAMES: (%s)\n", listen_fdnames_colons, listen_fdnames);
846
847   if (!listen_fds)
848     {
849       if (!listen_fdnames)
850         {
851           log_error ("no LISTEN_FDS or LISTEN_FDNAMES environment variables "
852                      "found in --supervised mode (assuming 1 active descriptor).\n");
853           listen_fd_count = 1;
854         }
855       else
856         {
857           log_error ("no LISTEN_FDS environment variable found in --supervised "
858                      " mode (relying on colons in LISTEN_FDNAMES instead)\n");
859           listen_fd_count = listen_fdnames_colons + 1;
860         }
861     }
862   else
863     listen_fd_count = atoi (listen_fds);
864
865   if (listen_fd_count < 1)
866     {
867       log_error ("--supervised mode expects at least one file descriptor (was told %d) "
868                  "(carrying on as though it were 1)\n", listen_fd_count);
869       listen_fd_count = 1;
870     }
871
872   if (!listen_fdnames)
873     {
874       if (listen_fd_count != 1)
875         log_error ("no LISTEN_FDNAMES and LISTEN_FDS (%d) != 1 in --supervised mode. "
876                    "(ignoring all sockets but the first one)\n", listen_fd_count);
877       *fd = 3;
878     }
879   else
880     {
881       int i;
882       if (listen_fd_count != listen_fdnames_colons + 1)
883         {
884           log_fatal ("number of items in LISTEN_FDNAMES (%d) does not match "
885                      "LISTEN_FDS (%d) in --supervised mode\n",
886                      listen_fdnames_colons + 1, listen_fd_count);
887           exit (1);
888         }
889
890       for (i = 3; i < 3 + listen_fd_count; i++)
891         {
892           int found = 0;
893           char *next = strchrnul(listen_fdnames, ':');
894           *next = '\0';
895 #define match_socket(var) if (!found && strcmp (listen_fdnames, #var) == 0) \
896             {                                                           \
897               found = 1;                                                \
898               if (*fd_ ## var == GNUPG_INVALID_FD)                      \
899                 {                                                       \
900                   *fd_ ## var = i;                                      \
901                   log_info (#var " socket on fd %d\n", i);              \
902                 }                                                       \
903               else                                                      \
904                 {                                                       \
905                   log_error ("cannot listen on more than one " #var " socket. (closing fd %d)\n", i); \
906                   close (i);                                            \
907                 }                                                       \
908             }
909           match_socket(ssh);
910           match_socket(browser);
911           match_socket(extra);
912 #undef match_socket
913           if (!found)
914             {
915               if (*fd == GNUPG_INVALID_FD)
916                 {
917                   *fd = i;
918                   log_info ("standard socket (\"%s\") on fd %d\n",
919                             listen_fdnames, i);
920                 }
921               else
922                 {
923                   log_error ("cannot listen on more than one standard socket. (closing fd %d)\n", i);
924                   close (i);
925                 }
926             }
927           listen_fdnames = next + 1;
928         }
929     }
930 }
931
932
933 /* The main entry point.  */
934 int
935 main (int argc, char **argv )
936 {
937   ARGPARSE_ARGS pargs;
938   int orig_argc;
939   char **orig_argv;
940   FILE *configfp = NULL;
941   char *configname = NULL;
942   const char *shell;
943   unsigned configlineno;
944   int parse_debug = 0;
945   int default_config =1;
946   int pipe_server = 0;
947   int is_daemon = 0;
948   int nodetach = 0;
949   int csh_style = 0;
950   char *logfile = NULL;
951   int debug_wait = 0;
952   int gpgconf_list = 0;
953   gpg_error_t err;
954   struct assuan_malloc_hooks malloc_hooks;
955
956   early_system_init ();
957
958   /* Before we do anything else we save the list of currently open
959      file descriptors and the signal mask.  This info is required to
960      do the exec call properly. */
961   startup_fd_list = get_all_open_fds ();
962 #ifdef HAVE_SIGPROCMASK
963   if (!sigprocmask (SIG_UNBLOCK, NULL, &startup_signal_mask))
964     startup_signal_mask_valid = 1;
965 #endif /*HAVE_SIGPROCMASK*/
966
967   /* Set program name etc.  */
968   set_strusage (my_strusage);
969   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
970   /* Please note that we may running SUID(ROOT), so be very CAREFUL
971      when adding any stuff between here and the call to INIT_SECMEM()
972      somewhere after the option parsing */
973   log_set_prefix (GPG_AGENT_NAME, GPGRT_LOG_WITH_PREFIX|GPGRT_LOG_WITH_PID);
974
975   /* Make sure that our subsystems are ready.  */
976   i18n_init ();
977   init_common_subsystems (&argc, &argv);
978
979   malloc_hooks.malloc = gcry_malloc;
980   malloc_hooks.realloc = gcry_realloc;
981   malloc_hooks.free = gcry_free;
982   assuan_set_malloc_hooks (&malloc_hooks);
983   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
984   assuan_sock_init ();
985   setup_libassuan_logging (&opt.debug, NULL);
986
987   setup_libgcrypt_logging ();
988   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
989   gcry_set_progress_handler (agent_libgcrypt_progress_cb, NULL);
990
991   disable_core_dumps ();
992
993   /* Set default options.  */
994   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
995
996   shell = getenv ("SHELL");
997   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
998     csh_style = 1;
999
1000   /* Record some of the original environment strings. */
1001   {
1002     const char *s;
1003     int idx;
1004     static const char *names[] =
1005       { "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
1006
1007     err = 0;
1008     opt.startup_env = session_env_new ();
1009     if (!opt.startup_env)
1010       err = gpg_error_from_syserror ();
1011     for (idx=0; !err && names[idx]; idx++)
1012       {
1013         s = getenv (names[idx]);
1014         if (s)
1015           err = session_env_setenv (opt.startup_env, names[idx], s);
1016       }
1017     if (!err)
1018       {
1019         s = gnupg_ttyname (0);
1020         if (s)
1021           err = session_env_setenv (opt.startup_env, "GPG_TTY", s);
1022       }
1023     if (err)
1024       log_fatal ("error recording startup environment: %s\n",
1025                  gpg_strerror (err));
1026
1027     /* Fixme: Better use the locale function here.  */
1028     opt.startup_lc_ctype = getenv ("LC_CTYPE");
1029     if (opt.startup_lc_ctype)
1030       opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
1031     opt.startup_lc_messages = getenv ("LC_MESSAGES");
1032     if (opt.startup_lc_messages)
1033       opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
1034   }
1035
1036   /* Check whether we have a config file on the commandline */
1037   orig_argc = argc;
1038   orig_argv = argv;
1039   pargs.argc = &argc;
1040   pargs.argv = &argv;
1041   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1042   while (arg_parse( &pargs, opts))
1043     {
1044       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
1045         parse_debug++;
1046       else if (pargs.r_opt == oOptions)
1047         { /* yes there is one, so we do not try the default one, but
1048              read the option file when it is encountered at the
1049              commandline */
1050           default_config = 0;
1051         }
1052         else if (pargs.r_opt == oNoOptions)
1053           default_config = 0; /* --no-options */
1054         else if (pargs.r_opt == oHomedir)
1055           gnupg_set_homedir (pargs.r.ret_str);
1056         else if (pargs.r_opt == oDebugQuickRandom)
1057           {
1058             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1059           }
1060
1061     }
1062
1063   /* Initialize the secure memory. */
1064   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1065   maybe_setuid = 0;
1066
1067   /*
1068      Now we are now working under our real uid
1069   */
1070
1071   if (default_config)
1072     configname = make_filename (gnupg_homedir (),
1073                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1074
1075   argc = orig_argc;
1076   argv = orig_argv;
1077   pargs.argc = &argc;
1078   pargs.argv = &argv;
1079   pargs.flags=  1;  /* do not remove the args */
1080  next_pass:
1081   if (configname)
1082     {
1083       configlineno = 0;
1084       configfp = fopen (configname, "r");
1085       if (!configfp)
1086         {
1087           if (default_config)
1088             {
1089               if( parse_debug )
1090                 log_info (_("Note: no default option file '%s'\n"),
1091                           configname );
1092               /* Save the default conf file name so that
1093                  reread_configuration is able to test whether the
1094                  config file has been created in the meantime.  */
1095               xfree (config_filename);
1096               config_filename = configname;
1097               configname = NULL;
1098             }
1099           else
1100             {
1101               log_error (_("option file '%s': %s\n"),
1102                          configname, strerror(errno) );
1103               exit(2);
1104             }
1105           xfree (configname);
1106           configname = NULL;
1107         }
1108       if (parse_debug && configname )
1109         log_info (_("reading options from '%s'\n"), configname );
1110       default_config = 0;
1111     }
1112
1113   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
1114     {
1115       if (parse_rereadable_options (&pargs, 0))
1116         continue; /* Already handled */
1117       switch (pargs.r_opt)
1118         {
1119         case aGPGConfList: gpgconf_list = 1; break;
1120         case aGPGConfTest: gpgconf_list = 2; break;
1121         case aUseStandardSocketP: gpgconf_list = 3; break;
1122         case oBatch: opt.batch=1; break;
1123
1124         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1125
1126         case oOptions:
1127           /* config files may not be nested (silently ignore them) */
1128           if (!configfp)
1129             {
1130                 xfree(configname);
1131                 configname = xstrdup(pargs.r.ret_str);
1132                 goto next_pass;
1133             }
1134           break;
1135         case oNoGreeting: /* Dummy option.  */ break;
1136         case oNoVerbose: opt.verbose = 0; break;
1137         case oNoOptions: break; /* no-options */
1138         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
1139         case oNoDetach: nodetach = 1; break;
1140         case oLogFile: logfile = pargs.r.ret_str; break;
1141         case oCsh: csh_style = 1; break;
1142         case oSh: csh_style = 0; break;
1143         case oServer: pipe_server = 1; break;
1144         case oDaemon: is_daemon = 1; break;
1145         case oSupervised: is_supervised = 1; break;
1146
1147         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
1148         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
1149         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
1150         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
1151         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
1152           break;
1153         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
1154           break;
1155
1156         case oUseStandardSocket:
1157         case oNoUseStandardSocket:
1158           obsolete_option (configname, configlineno, "use-standard-socket");
1159           break;
1160
1161         case oFakedSystemTime:
1162           {
1163             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1164             if (faked_time == (time_t)(-1))
1165               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1166             gnupg_set_time (faked_time, 0);
1167           }
1168           break;
1169
1170         case oKeepTTY: opt.keep_tty = 1; break;
1171         case oKeepDISPLAY: opt.keep_display = 1; break;
1172
1173         case oSSHSupport:
1174           ssh_support = 1;
1175           break;
1176         case oPuttySupport:
1177 #        ifdef HAVE_W32_SYSTEM
1178           putty_support = 1;
1179 #        endif
1180           break;
1181
1182         case oExtraSocket:
1183           opt.extra_socket = 1;  /* (1 = points into argv)  */
1184           socket_name_extra = pargs.r.ret_str;
1185           break;
1186
1187         case oBrowserSocket:
1188           opt.browser_socket = 1;  /* (1 = points into argv)  */
1189           socket_name_browser = pargs.r.ret_str;
1190           break;
1191
1192         case oDebugQuickRandom:
1193           /* Only used by the first stage command line parser.  */
1194           break;
1195
1196         case oWriteEnvFile:
1197           obsolete_option (configname, configlineno, "write-env-file");
1198           break;
1199
1200         default : pargs.err = configfp? 1:2; break;
1201         }
1202     }
1203   if (configfp)
1204     {
1205       fclose( configfp );
1206       configfp = NULL;
1207       /* Keep a copy of the name so that it can be read on SIGHUP. */
1208       if (config_filename != configname)
1209         {
1210           xfree (config_filename);
1211           config_filename = configname;
1212         }
1213       configname = NULL;
1214       goto next_pass;
1215     }
1216
1217   xfree (configname);
1218   configname = NULL;
1219   if (log_get_errorcount(0))
1220     exit(2);
1221
1222   finalize_rereadable_options ();
1223
1224   /* Print a warning if an argument looks like an option.  */
1225   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1226     {
1227       int i;
1228
1229       for (i=0; i < argc; i++)
1230         if (argv[i][0] == '-' && argv[i][1] == '-')
1231           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1232     }
1233
1234 #ifdef ENABLE_NLS
1235   /* gpg-agent usually does not output any messages because it runs in
1236      the background.  For log files it is acceptable to have messages
1237      always encoded in utf-8.  We switch here to utf-8, so that
1238      commands like --help still give native messages.  It is far
1239      easier to switch only once instead of for every message and it
1240      actually helps when more then one thread is active (avoids an
1241      extra copy step). */
1242     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
1243 #endif
1244
1245   if (!pipe_server && !is_daemon && !gpgconf_list && !is_supervised)
1246     {
1247      /* We have been called without any command and thus we merely
1248         check whether an agent is already running.  We do this right
1249         here so that we don't clobber a logfile with this check but
1250         print the status directly to stderr. */
1251       opt.debug = 0;
1252       set_debug ();
1253       check_for_running_agent (0);
1254       agent_exit (0);
1255     }
1256
1257   if (is_supervised)
1258     ;
1259   else if (!opt.extra_socket)
1260     opt.extra_socket = 1;
1261   else if (socket_name_extra
1262            && (!strcmp (socket_name_extra, "none")
1263                || !strcmp (socket_name_extra, "/dev/null")))
1264     {
1265       /* User requested not to create this socket.  */
1266       opt.extra_socket = 0;
1267       socket_name_extra = NULL;
1268     }
1269
1270   if (is_supervised)
1271     ;
1272   else if (!opt.browser_socket)
1273     opt.browser_socket = 1;
1274   else if (socket_name_browser
1275            && (!strcmp (socket_name_browser, "none")
1276                || !strcmp (socket_name_browser, "/dev/null")))
1277     {
1278       /* User requested not to create this socket.  */
1279       opt.browser_socket = 0;
1280       socket_name_browser = NULL;
1281     }
1282
1283   set_debug ();
1284
1285   if (atexit (cleanup))
1286     {
1287       log_error ("atexit failed\n");
1288       cleanup ();
1289       exit (1);
1290     }
1291
1292   /* Try to create missing directories. */
1293   create_directories ();
1294
1295   if (debug_wait && pipe_server)
1296     {
1297       thread_init_once ();
1298       log_debug ("waiting for debugger - my pid is %u .....\n",
1299                  (unsigned int)getpid());
1300       gnupg_sleep (debug_wait);
1301       log_debug ("... okay\n");
1302     }
1303
1304   if (gpgconf_list == 3)
1305     {
1306       /* We now use the standard socket always - return true for
1307          backward compatibility.  */
1308       agent_exit (0);
1309     }
1310   else if (gpgconf_list == 2)
1311     agent_exit (0);
1312   else if (gpgconf_list)
1313     {
1314       char *filename;
1315       char *filename_esc;
1316
1317       /* List options and default values in the GPG Conf format.  */
1318       filename = make_filename (gnupg_homedir (),
1319                                 GPG_AGENT_NAME EXTSEP_S "conf", NULL);
1320       filename_esc = percent_escape (filename, NULL);
1321
1322       es_printf ("%s-%s.conf:%lu:\"%s\n",
1323                  GPGCONF_NAME, GPG_AGENT_NAME,
1324                  GC_OPT_FLAG_DEFAULT, filename_esc);
1325       xfree (filename);
1326       xfree (filename_esc);
1327
1328       es_printf ("verbose:%lu:\n"
1329               "quiet:%lu:\n"
1330               "debug-level:%lu:\"none:\n"
1331               "log-file:%lu:\n",
1332               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1333               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
1334               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1335               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
1336       es_printf ("default-cache-ttl:%lu:%d:\n",
1337               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
1338       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
1339               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
1340       es_printf ("max-cache-ttl:%lu:%d:\n",
1341               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
1342       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
1343               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
1344       es_printf ("enforce-passphrase-constraints:%lu:\n",
1345               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1346       es_printf ("min-passphrase-len:%lu:%d:\n",
1347               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
1348       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
1349               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1350               MIN_PASSPHRASE_NONALPHA);
1351       es_printf ("check-passphrase-pattern:%lu:\n",
1352               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1353       es_printf ("max-passphrase-days:%lu:%d:\n",
1354               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
1355               MAX_PASSPHRASE_DAYS);
1356       es_printf ("enable-passphrase-history:%lu:\n",
1357               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1358       es_printf ("no-grab:%lu:\n",
1359               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1360       es_printf ("ignore-cache-for-signing:%lu:\n",
1361               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1362       es_printf ("no-allow-external-cache:%lu:\n",
1363               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1364       es_printf ("no-allow-mark-trusted:%lu:\n",
1365               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1366       es_printf ("disable-scdaemon:%lu:\n",
1367               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1368       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1369 #ifdef HAVE_W32_SYSTEM
1370       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1371 #endif
1372       es_printf ("no-allow-loopback-pinentry:%lu:\n",
1373               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1374       es_printf ("allow-emacs-pinentry:%lu:\n",
1375                  GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1376       es_printf ("pinentry-timeout:%lu:0:\n",
1377                  GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
1378
1379       agent_exit (0);
1380     }
1381
1382   /* Now start with logging to a file if this is desired. */
1383   if (logfile)
1384     {
1385       log_set_file (logfile);
1386       log_set_prefix (NULL, (GPGRT_LOG_WITH_PREFIX
1387                              | GPGRT_LOG_WITH_TIME
1388                              | GPGRT_LOG_WITH_PID));
1389       current_logfile = xstrdup (logfile);
1390     }
1391
1392   /* Make sure that we have a default ttyname. */
1393   if (!default_ttyname && gnupg_ttyname (1))
1394     default_ttyname = xstrdup (gnupg_ttyname (1));
1395   if (!default_ttytype && getenv ("TERM"))
1396     default_ttytype = xstrdup (getenv ("TERM"));
1397
1398
1399   if (pipe_server)
1400     {
1401       /* This is the simple pipe based server */
1402       ctrl_t ctrl;
1403
1404       initialize_modules ();
1405
1406       ctrl = xtrycalloc (1, sizeof *ctrl);
1407       if (!ctrl)
1408         {
1409           log_error ("error allocating connection control data: %s\n",
1410                      strerror (errno) );
1411           agent_exit (1);
1412         }
1413       ctrl->session_env = session_env_new ();
1414       if (!ctrl->session_env)
1415         {
1416           log_error ("error allocating session environment block: %s\n",
1417                      strerror (errno) );
1418           xfree (ctrl);
1419           agent_exit (1);
1420         }
1421       agent_init_default_ctrl (ctrl);
1422       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1423       agent_deinit_default_ctrl (ctrl);
1424       xfree (ctrl);
1425     }
1426   else if (is_supervised)
1427     {
1428       gnupg_fd_t fd = GNUPG_INVALID_FD;
1429       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1430       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1431       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1432
1433       /* when supervised and sending logs to stderr, the process
1434          supervisor should handle log entry metadata (pid, name,
1435          timestamp) */
1436       if (!logfile)
1437         log_set_prefix (NULL, 0);
1438
1439       log_info ("%s %s starting in supervised mode.\n",
1440                 strusage(11), strusage(13) );
1441
1442       /* See below on why we remove certain envvars.  */
1443 #ifndef HAVE_W32_SYSTEM
1444       if (!opt.keep_display)
1445         gnupg_unsetenv ("DISPLAY");
1446 #endif
1447       gnupg_unsetenv ("INSIDE_EMACS");
1448
1449       /* Virtually create the sockets.  */
1450       map_supervised_sockets (&fd, &fd_extra, &fd_browser, &fd_ssh);
1451       if (fd == GNUPG_INVALID_FD)
1452         {
1453           log_error ("no standard socket provided\n");
1454           agent_exit (1);
1455         }
1456       /* record socket names where possible: */
1457       socket_name = get_socket_path (fd);
1458       socket_name_extra = get_socket_path (fd_extra);
1459       if (socket_name_extra)
1460         opt.extra_socket = 2;
1461       socket_name_browser = get_socket_path (fd_browser);
1462       if (socket_name_browser)
1463         opt.browser_socket = 2;
1464       socket_name_ssh = get_socket_path (fd_ssh);
1465
1466 #ifdef HAVE_SIGPROCMASK
1467       if (startup_signal_mask_valid)
1468         {
1469           if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1470             log_error ("error restoring signal mask: %s\n",
1471                        strerror (errno));
1472         }
1473       else
1474         log_info ("no saved signal mask\n");
1475 #endif /*HAVE_SIGPROCMASK*/
1476
1477       log_info ("listening on: std=%d extra=%d browser=%d ssh=%d\n",
1478                 fd, fd_extra, fd_browser, fd_ssh);
1479       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1480       assuan_sock_close (fd);
1481     }
1482   else if (!is_daemon)
1483     ; /* NOTREACHED */
1484   else
1485     { /* Regular server mode */
1486       gnupg_fd_t fd;
1487       gnupg_fd_t fd_extra = GNUPG_INVALID_FD;
1488       gnupg_fd_t fd_browser = GNUPG_INVALID_FD;
1489       gnupg_fd_t fd_ssh = GNUPG_INVALID_FD;
1490 #ifndef HAVE_W32_SYSTEM
1491       pid_t pid;
1492 #endif
1493
1494       initialize_modules ();
1495
1496       /* Remove the DISPLAY variable so that a pinentry does not
1497          default to a specific display.  There is still a default
1498          display when gpg-agent was started using --display or a
1499          client requested this using an OPTION command.  Note, that we
1500          don't do this when running in reverse daemon mode (i.e. when
1501          exec the program given as arguments). */
1502 #ifndef HAVE_W32_SYSTEM
1503       if (!opt.keep_display && !argc)
1504         gnupg_unsetenv ("DISPLAY");
1505 #endif
1506
1507       /* Remove the INSIDE_EMACS variable so that a pinentry does not
1508          always try to interact with Emacs.  The variable is set when
1509          a client requested this using an OPTION command.  */
1510       gnupg_unsetenv ("INSIDE_EMACS");
1511
1512       /* Create the sockets.  */
1513       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME, 1);
1514       fd = create_server_socket (socket_name, 1, 0,
1515                                  &redir_socket_name, &socket_nonce);
1516
1517       if (opt.extra_socket)
1518         {
1519           if (socket_name_extra)
1520             socket_name_extra = create_socket_name (socket_name_extra, 0);
1521           else
1522             socket_name_extra = create_socket_name
1523               /**/                (GPG_AGENT_EXTRA_SOCK_NAME, 1);
1524           opt.extra_socket = 2; /* Indicate that it has been malloced.  */
1525           fd_extra = create_server_socket (socket_name_extra, 0, 0,
1526                                            &redir_socket_name_extra,
1527                                            &socket_nonce_extra);
1528         }
1529
1530       if (opt.browser_socket)
1531         {
1532           if (socket_name_browser)
1533             socket_name_browser = create_socket_name (socket_name_browser, 0);
1534           else
1535             socket_name_browser= create_socket_name
1536               /**/                 (GPG_AGENT_BROWSER_SOCK_NAME, 1);
1537           opt.browser_socket = 2; /* Indicate that it has been malloced.  */
1538           fd_browser = create_server_socket (socket_name_browser, 0, 0,
1539                                              &redir_socket_name_browser,
1540                                              &socket_nonce_browser);
1541         }
1542
1543       socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME, 1);
1544       fd_ssh = create_server_socket (socket_name_ssh, 0, 1,
1545                                      &redir_socket_name_ssh,
1546                                      &socket_nonce_ssh);
1547
1548       /* If we are going to exec a program in the parent, we record
1549          the PID, so that the child may check whether the program is
1550          still alive. */
1551       if (argc)
1552         parent_pid = getpid ();
1553
1554       fflush (NULL);
1555 #ifdef HAVE_W32_SYSTEM
1556       (void)csh_style;
1557       (void)nodetach;
1558 #else /*!HAVE_W32_SYSTEM*/
1559       pid = fork ();
1560       if (pid == (pid_t)-1)
1561         {
1562           log_fatal ("fork failed: %s\n", strerror (errno) );
1563           exit (1);
1564         }
1565       else if (pid)
1566         { /* We are the parent */
1567           char *infostr_ssh_sock, *infostr_ssh_valid;
1568
1569           /* Close the socket FD. */
1570           close (fd);
1571
1572           /* The signal mask might not be correct right now and thus
1573              we restore it.  That is not strictly necessary but some
1574              programs falsely assume a cleared signal mask.  */
1575
1576 #ifdef HAVE_SIGPROCMASK
1577           if (startup_signal_mask_valid)
1578             {
1579               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1580                 log_error ("error restoring signal mask: %s\n",
1581                            strerror (errno));
1582             }
1583           else
1584             log_info ("no saved signal mask\n");
1585 #endif /*HAVE_SIGPROCMASK*/
1586
1587           /* Create the SSH info string if enabled. */
1588           if (ssh_support)
1589             {
1590               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1591                             socket_name_ssh) < 0)
1592                 {
1593                   log_error ("out of core\n");
1594                   kill (pid, SIGTERM);
1595                   exit (1);
1596                 }
1597               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1598                             (unsigned long)getpid()) < 0)
1599                 {
1600                   log_error ("out of core\n");
1601                   kill (pid, SIGTERM);
1602                   exit (1);
1603                 }
1604             }
1605
1606           *socket_name = 0; /* Don't let cleanup() remove the socket -
1607                                the child should do this from now on */
1608           if (opt.extra_socket)
1609             *socket_name_extra = 0;
1610           if (opt.browser_socket)
1611             *socket_name_browser = 0;
1612           *socket_name_ssh = 0;
1613
1614           if (argc)
1615             { /* Run the program given on the commandline.  */
1616               if (ssh_support && (putenv (infostr_ssh_sock)
1617                                   || putenv (infostr_ssh_valid)))
1618                 {
1619                   log_error ("failed to set environment: %s\n",
1620                              strerror (errno) );
1621                   kill (pid, SIGTERM );
1622                   exit (1);
1623                 }
1624
1625               /* Close all the file descriptors except the standard
1626                  ones and those open at startup.  We explicitly don't
1627                  close 0,1,2 in case something went wrong collecting
1628                  them at startup.  */
1629               close_all_fds (3, startup_fd_list);
1630
1631               /* Run the command.  */
1632               execvp (argv[0], argv);
1633               log_error ("failed to run the command: %s\n", strerror (errno));
1634               kill (pid, SIGTERM);
1635               exit (1);
1636             }
1637           else
1638             {
1639               /* Print the environment string, so that the caller can use
1640                  shell's eval to set it */
1641               if (csh_style)
1642                 {
1643                   if (ssh_support)
1644                     {
1645                       *strchr (infostr_ssh_sock, '=') = ' ';
1646                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1647                     }
1648                 }
1649               else
1650                 {
1651                   if (ssh_support)
1652                     {
1653                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1654                                  infostr_ssh_sock);
1655                     }
1656                 }
1657               if (ssh_support)
1658                 {
1659                   xfree (infostr_ssh_sock);
1660                   xfree (infostr_ssh_valid);
1661                 }
1662               exit (0);
1663             }
1664           /*NOTREACHED*/
1665         } /* End parent */
1666
1667       /*
1668          This is the child
1669        */
1670
1671       initialize_modules ();
1672
1673       /* Detach from tty and put process into a new session */
1674       if (!nodetach )
1675         {
1676           int i;
1677           unsigned int oldflags;
1678
1679           /* Close stdin, stdout and stderr unless it is the log stream */
1680           for (i=0; i <= 2; i++)
1681             {
1682               if (!log_test_fd (i) && i != fd )
1683                 {
1684                   if ( ! close (i)
1685                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1686                     {
1687                       log_error ("failed to open '%s': %s\n",
1688                                  "/dev/null", strerror (errno));
1689                       cleanup ();
1690                       exit (1);
1691                     }
1692                 }
1693             }
1694           if (setsid() == -1)
1695             {
1696               log_error ("setsid() failed: %s\n", strerror(errno) );
1697               cleanup ();
1698               exit (1);
1699             }
1700
1701           log_get_prefix (&oldflags);
1702           log_set_prefix (NULL, oldflags | GPGRT_LOG_RUN_DETACHED);
1703           opt.running_detached = 1;
1704         }
1705
1706       if (chdir("/"))
1707         {
1708           log_error ("chdir to / failed: %s\n", strerror (errno));
1709           exit (1);
1710         }
1711
1712       {
1713         struct sigaction sa;
1714
1715         sa.sa_handler = SIG_IGN;
1716         sigemptyset (&sa.sa_mask);
1717         sa.sa_flags = 0;
1718         sigaction (SIGPIPE, &sa, NULL);
1719       }
1720 #endif /*!HAVE_W32_SYSTEM*/
1721
1722       log_info ("%s %s started\n", strusage(11), strusage(13) );
1723       handle_connections (fd, fd_extra, fd_browser, fd_ssh);
1724       assuan_sock_close (fd);
1725     }
1726
1727   return 0;
1728 }
1729
1730
1731 /* Exit entry point.  This function should be called instead of a
1732    plain exit.  */
1733 void
1734 agent_exit (int rc)
1735 {
1736   /*FIXME: update_random_seed_file();*/
1737
1738   /* We run our cleanup handler because that may close cipher contexts
1739      stored in secure memory and thus this needs to be done before we
1740      explicitly terminate secure memory.  */
1741   cleanup ();
1742
1743 #if 1
1744   /* at this time a bit annoying */
1745   if (opt.debug & DBG_MEMSTAT_VALUE)
1746     {
1747       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1748       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1749     }
1750   if (opt.debug)
1751     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1752 #endif
1753   gcry_control (GCRYCTL_TERM_SECMEM );
1754   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1755   exit (rc);
1756 }
1757
1758
1759 /* This is our callback function for gcrypt progress messages.  It is
1760    set once at startup and dispatches progress messages to the
1761    corresponding threads of the agent.  */
1762 static void
1763 agent_libgcrypt_progress_cb (void *data, const char *what, int printchar,
1764                              int current, int total)
1765 {
1766   struct progress_dispatch_s *dispatch;
1767   npth_t mytid = npth_self ();
1768
1769   (void)data;
1770
1771   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1772     if (dispatch->ctrl && dispatch->tid == mytid)
1773       break;
1774   if (dispatch && dispatch->cb)
1775     dispatch->cb (dispatch->ctrl, what, printchar, current, total);
1776 }
1777
1778
1779 /* If a progress dispatcher callback has been associated with the
1780  * current connection unregister it.  */
1781 static void
1782 unregister_progress_cb (void)
1783 {
1784   struct progress_dispatch_s *dispatch;
1785   npth_t mytid = npth_self ();
1786
1787   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1788     if (dispatch->ctrl && dispatch->tid == mytid)
1789       break;
1790   if (dispatch)
1791     {
1792       dispatch->ctrl = NULL;
1793       dispatch->cb = NULL;
1794     }
1795 }
1796
1797
1798 /* Setup a progress callback CB for the current connection.  Using a
1799  * CB of NULL disables the callback.  */
1800 void
1801 agent_set_progress_cb (void (*cb)(ctrl_t ctrl, const char *what,
1802                                   int printchar, int current, int total),
1803                        ctrl_t ctrl)
1804 {
1805   struct progress_dispatch_s *dispatch, *firstfree;
1806   npth_t mytid = npth_self ();
1807
1808   firstfree = NULL;
1809   for (dispatch = progress_dispatch_list; dispatch; dispatch = dispatch->next)
1810     {
1811       if (dispatch->ctrl && dispatch->tid == mytid)
1812         break;
1813       if (!dispatch->ctrl && !firstfree)
1814         firstfree = dispatch;
1815     }
1816   if (!dispatch) /* None allocated: Reuse or allocate a new one.  */
1817     {
1818       if (firstfree)
1819         {
1820           dispatch = firstfree;
1821         }
1822       else if ((dispatch = xtrycalloc (1, sizeof *dispatch)))
1823         {
1824           dispatch->next = progress_dispatch_list;
1825           progress_dispatch_list = dispatch;
1826         }
1827       else
1828         {
1829           log_error ("error allocating new progress dispatcher slot: %s\n",
1830                      gpg_strerror (gpg_error_from_syserror ()));
1831           return;
1832         }
1833       dispatch->ctrl = ctrl;
1834       dispatch->tid = mytid;
1835     }
1836
1837   dispatch->cb = cb;
1838 }
1839
1840
1841 /* Each thread has its own local variables conveyed by a control
1842    structure usually identified by an argument named CTRL.  This
1843    function is called immediately after allocating the control
1844    structure.  Its purpose is to setup the default values for that
1845    structure.  Note that some values may have already been set.  */
1846 static void
1847 agent_init_default_ctrl (ctrl_t ctrl)
1848 {
1849   assert (ctrl->session_env);
1850
1851   /* Note we ignore malloc errors because we can't do much about it
1852      and the request will fail anyway shortly after this
1853      initialization. */
1854   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1855   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1856   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1857   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1858   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1859
1860   if (ctrl->lc_ctype)
1861     xfree (ctrl->lc_ctype);
1862   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1863
1864   if (ctrl->lc_messages)
1865     xfree (ctrl->lc_messages);
1866   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1867                                     /**/ : NULL;
1868   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1869 }
1870
1871
1872 /* Release all resources allocated by default in the control
1873    structure.  This is the counterpart to agent_init_default_ctrl.  */
1874 static void
1875 agent_deinit_default_ctrl (ctrl_t ctrl)
1876 {
1877   unregister_progress_cb ();
1878   session_env_release (ctrl->session_env);
1879
1880   if (ctrl->lc_ctype)
1881     xfree (ctrl->lc_ctype);
1882   if (ctrl->lc_messages)
1883     xfree (ctrl->lc_messages);
1884 }
1885
1886
1887 /* Because the ssh protocol does not send us information about the
1888    current TTY setting, we use this function to use those from startup
1889    or those explicitly set.  This is also used for the restricted mode
1890    where we ignore requests to change the environment.  */
1891 gpg_error_t
1892 agent_copy_startup_env (ctrl_t ctrl)
1893 {
1894   static const char *names[] =
1895     {"GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL};
1896   gpg_error_t err = 0;
1897   int idx;
1898   const char *value;
1899
1900   for (idx=0; !err && names[idx]; idx++)
1901       if ((value = session_env_getenv (opt.startup_env, names[idx])))
1902       err = session_env_setenv (ctrl->session_env, names[idx], value);
1903
1904   if (!err && !ctrl->lc_ctype && opt.startup_lc_ctype)
1905     if (!(ctrl->lc_ctype = xtrystrdup (opt.startup_lc_ctype)))
1906       err = gpg_error_from_syserror ();
1907
1908   if (!err && !ctrl->lc_messages && opt.startup_lc_messages)
1909     if (!(ctrl->lc_messages = xtrystrdup (opt.startup_lc_messages)))
1910       err = gpg_error_from_syserror ();
1911
1912   if (err)
1913     log_error ("error setting default session environment: %s\n",
1914                gpg_strerror (err));
1915
1916   return err;
1917 }
1918
1919
1920 /* Reread parts of the configuration.  Note, that this function is
1921    obviously not thread-safe and should only be called from the PTH
1922    signal handler.
1923
1924    Fixme: Due to the way the argument parsing works, we create a
1925    memory leak here for all string type arguments.  There is currently
1926    no clean way to tell whether the memory for the argument has been
1927    allocated or points into the process' original arguments.  Unless
1928    we have a mechanism to tell this, we need to live on with this. */
1929 static void
1930 reread_configuration (void)
1931 {
1932   ARGPARSE_ARGS pargs;
1933   FILE *fp;
1934   unsigned int configlineno = 0;
1935   int dummy;
1936
1937   if (!config_filename)
1938     return; /* No config file. */
1939
1940   fp = fopen (config_filename, "r");
1941   if (!fp)
1942     {
1943       log_info (_("option file '%s': %s\n"),
1944                 config_filename, strerror(errno) );
1945       return;
1946     }
1947
1948   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1949
1950   memset (&pargs, 0, sizeof pargs);
1951   dummy = 0;
1952   pargs.argc = &dummy;
1953   pargs.flags = 1;  /* do not remove the args */
1954   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1955     {
1956       if (pargs.r_opt < -1)
1957         pargs.err = 1; /* Print a warning. */
1958       else /* Try to parse this option - ignore unchangeable ones. */
1959         parse_rereadable_options (&pargs, 1);
1960     }
1961   fclose (fp);
1962   finalize_rereadable_options ();
1963   set_debug ();
1964 }
1965
1966
1967 /* Return the file name of the socket we are using for native
1968    requests.  */
1969 const char *
1970 get_agent_socket_name (void)
1971 {
1972   const char *s = socket_name;
1973
1974   return (s && *s)? s : NULL;
1975 }
1976
1977 /* Return the file name of the socket we are using for SSH
1978    requests.  */
1979 const char *
1980 get_agent_ssh_socket_name (void)
1981 {
1982   const char *s = socket_name_ssh;
1983
1984   return (s && *s)? s : NULL;
1985 }
1986
1987
1988 /* Return the number of active connections. */
1989 int
1990 get_agent_active_connection_count (void)
1991 {
1992   return active_connections;
1993 }
1994
1995
1996 /* Under W32, this function returns the handle of the scdaemon
1997    notification event.  Calling it the first time creates that
1998    event.  */
1999 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
2000 void *
2001 get_agent_scd_notify_event (void)
2002 {
2003   static HANDLE the_event = INVALID_HANDLE_VALUE;
2004
2005   if (the_event == INVALID_HANDLE_VALUE)
2006     {
2007       HANDLE h, h2;
2008       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
2009
2010       /* We need to use a manual reset event object due to the way our
2011          w32-pth wait function works: If we would use an automatic
2012          reset event we are not able to figure out which handle has
2013          been signaled because at the time we single out the signaled
2014          handles using WFSO the event has already been reset due to
2015          the WFMO.  */
2016       h = CreateEvent (&sa, TRUE, FALSE, NULL);
2017       if (!h)
2018         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
2019       else if (!DuplicateHandle (GetCurrentProcess(), h,
2020                                  GetCurrentProcess(), &h2,
2021                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
2022         {
2023           log_error ("setting syncronize for scd notify event failed: %s\n",
2024                      w32_strerror (-1) );
2025           CloseHandle (h);
2026         }
2027       else
2028         {
2029           CloseHandle (h);
2030           the_event = h2;
2031         }
2032     }
2033
2034   return the_event;
2035 }
2036 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
2037
2038
2039
2040 /* Create a name for the socket in the home directory as using
2041    STANDARD_NAME.  We also check for valid characters as well as
2042    against a maximum allowed length for a unix domain socket is done.
2043    The function terminates the process in case of an error.  Returns:
2044    Pointer to an allocated string with the absolute name of the socket
2045    used.  */
2046 static char *
2047 create_socket_name (char *standard_name, int with_homedir)
2048 {
2049   char *name;
2050
2051   if (with_homedir)
2052     name = make_filename (gnupg_socketdir (), standard_name, NULL);
2053   else
2054     name = make_filename (standard_name, NULL);
2055   if (strchr (name, PATHSEP_C))
2056     {
2057       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
2058       agent_exit (2);
2059     }
2060   return name;
2061 }
2062
2063
2064
2065 /* Create a Unix domain socket with NAME.  Returns the file descriptor
2066    or terminates the process in case of an error.  Note that this
2067    function needs to be used for the regular socket first (indicated
2068    by PRIMARY) and only then for the extra and the ssh sockets.  If
2069    the socket has been redirected the name of the real socket is
2070    stored as a malloced string at R_REDIR_NAME.  If CYGWIN is set a
2071    Cygwin compatible socket is created (Windows only). */
2072 static gnupg_fd_t
2073 create_server_socket (char *name, int primary, int cygwin,
2074                       char **r_redir_name, assuan_sock_nonce_t *nonce)
2075 {
2076   struct sockaddr *addr;
2077   struct sockaddr_un *unaddr;
2078   socklen_t len;
2079   gnupg_fd_t fd;
2080   int rc;
2081
2082   xfree (*r_redir_name);
2083   *r_redir_name = NULL;
2084
2085   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
2086   if (fd == ASSUAN_INVALID_FD)
2087     {
2088       log_error (_("can't create socket: %s\n"), strerror (errno));
2089       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2090       agent_exit (2);
2091     }
2092
2093   if (cygwin)
2094     assuan_sock_set_flag (fd, "cygwin", 1);
2095
2096   unaddr = xmalloc (sizeof *unaddr);
2097   addr = (struct sockaddr*)unaddr;
2098
2099   {
2100     int redirected;
2101
2102     if (assuan_sock_set_sockaddr_un (name, addr, &redirected))
2103       {
2104         if (errno == ENAMETOOLONG)
2105           log_error (_("socket name '%s' is too long\n"), name);
2106         else
2107           log_error ("error preparing socket '%s': %s\n",
2108                      name, gpg_strerror (gpg_error_from_syserror ()));
2109         *name = 0; /* Inhibit removal of the socket by cleanup(). */
2110         agent_exit (2);
2111       }
2112     if (redirected)
2113       {
2114         *r_redir_name = xstrdup (unaddr->sun_path);
2115         if (opt.verbose)
2116           log_info ("redirecting socket '%s' to '%s'\n", name, *r_redir_name);
2117       }
2118   }
2119
2120   len = SUN_LEN (unaddr);
2121   rc = assuan_sock_bind (fd, addr, len);
2122
2123   /* Our error code mapping on W32CE returns EEXIST thus we also test
2124      for this. */
2125   if (rc == -1
2126       && (errno == EADDRINUSE
2127 #ifdef HAVE_W32_SYSTEM
2128           || errno == EEXIST
2129 #endif
2130           ))
2131     {
2132       /* Check whether a gpg-agent is already running.  We do this
2133          test only if this is the primary socket.  For secondary
2134          sockets we assume that a test for gpg-agent has already been
2135          done and reuse the requested socket.  Testing the ssh-socket
2136          is not possible because at this point, though we know the new
2137          Assuan socket, the Assuan server and thus the ssh-agent
2138          server is not yet operational; this would lead to a hang.  */
2139       if (primary && !check_for_running_agent (1))
2140         {
2141           log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX);
2142           log_set_file (NULL);
2143           log_error (_("a gpg-agent is already running - "
2144                        "not starting a new one\n"));
2145           *name = 0; /* Inhibit removal of the socket by cleanup(). */
2146           assuan_sock_close (fd);
2147           agent_exit (2);
2148         }
2149       gnupg_remove (unaddr->sun_path);
2150       rc = assuan_sock_bind (fd, addr, len);
2151     }
2152   if (rc != -1 && (rc=assuan_sock_get_nonce (addr, len, nonce)))
2153     log_error (_("error getting nonce for the socket\n"));
2154   if (rc == -1)
2155     {
2156       /* We use gpg_strerror here because it allows us to get strings
2157          for some W32 socket error codes.  */
2158       log_error (_("error binding socket to '%s': %s\n"),
2159                  unaddr->sun_path,
2160                  gpg_strerror (gpg_error_from_syserror ()));
2161
2162       assuan_sock_close (fd);
2163       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2164       agent_exit (2);
2165     }
2166
2167   if (gnupg_chmod (unaddr->sun_path, "-rwx"))
2168     log_error (_("can't set permissions of '%s': %s\n"),
2169                unaddr->sun_path, strerror (errno));
2170
2171   if (listen (FD2INT(fd), 5 ) == -1)
2172     {
2173       log_error (_("listen() failed: %s\n"), strerror (errno));
2174       *name = 0; /* Inhibit removal of the socket by cleanup(). */
2175       assuan_sock_close (fd);
2176       agent_exit (2);
2177     }
2178
2179   if (opt.verbose)
2180     log_info (_("listening on socket '%s'\n"), unaddr->sun_path);
2181
2182   return fd;
2183 }
2184
2185
2186 /* Check that the directory for storing the private keys exists and
2187    create it if not.  This function won't fail as it is only a
2188    convenience function and not strictly necessary.  */
2189 static void
2190 create_private_keys_directory (const char *home)
2191 {
2192   char *fname;
2193   struct stat statbuf;
2194
2195   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
2196   if (stat (fname, &statbuf) && errno == ENOENT)
2197     {
2198       if (gnupg_mkdir (fname, "-rwx"))
2199         log_error (_("can't create directory '%s': %s\n"),
2200                    fname, strerror (errno) );
2201       else if (!opt.quiet)
2202         log_info (_("directory '%s' created\n"), fname);
2203     }
2204   if (gnupg_chmod (fname, "-rwx"))
2205     log_error (_("can't set permissions of '%s': %s\n"),
2206                fname, strerror (errno));
2207   xfree (fname);
2208 }
2209
2210
2211 /* Create the directory only if the supplied directory name is the
2212    same as the default one.  This way we avoid to create arbitrary
2213    directories when a non-default home directory is used.  To cope
2214    with HOME, we compare only the suffix if we see that the default
2215    homedir does start with a tilde.  We don't stop here in case of
2216    problems because other functions will throw an error anyway.*/
2217 static void
2218 create_directories (void)
2219 {
2220   struct stat statbuf;
2221   const char *defhome = standard_homedir ();
2222   char *home;
2223
2224   home = make_filename (gnupg_homedir (), NULL);
2225   if ( stat (home, &statbuf) )
2226     {
2227       if (errno == ENOENT)
2228         {
2229           if (
2230 #ifdef HAVE_W32_SYSTEM
2231               ( !compare_filenames (home, defhome) )
2232 #else
2233               (*defhome == '~'
2234                 && (strlen (home) >= strlen (defhome+1)
2235                     && !strcmp (home + strlen(home)
2236                                 - strlen (defhome+1), defhome+1)))
2237                || (*defhome != '~' && !strcmp (home, defhome) )
2238 #endif
2239                )
2240             {
2241               if (gnupg_mkdir (home, "-rwx"))
2242                 log_error (_("can't create directory '%s': %s\n"),
2243                            home, strerror (errno) );
2244               else
2245                 {
2246                   if (!opt.quiet)
2247                     log_info (_("directory '%s' created\n"), home);
2248                   create_private_keys_directory (home);
2249                 }
2250             }
2251         }
2252       else
2253         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
2254     }
2255   else if ( !S_ISDIR(statbuf.st_mode))
2256     {
2257       log_error (_("can't use '%s' as home directory\n"), home);
2258     }
2259   else /* exists and is a directory. */
2260     {
2261       create_private_keys_directory (home);
2262     }
2263   xfree (home);
2264 }
2265
2266
2267
2268 /* This is the worker for the ticker.  It is called every few seconds
2269    and may only do fast operations. */
2270 static void
2271 handle_tick (void)
2272 {
2273   static time_t last_minute;
2274
2275   if (!last_minute)
2276     last_minute = time (NULL);
2277
2278   /* Check whether the scdaemon has died and cleanup in this case. */
2279   agent_scd_check_aliveness ();
2280
2281   /* If we are running as a child of another process, check whether
2282      the parent is still alive and shutdown if not. */
2283 #ifndef HAVE_W32_SYSTEM
2284   if (parent_pid != (pid_t)(-1))
2285     {
2286       if (kill (parent_pid, 0))
2287         {
2288           shutdown_pending = 2;
2289           log_info ("parent process died - shutting down\n");
2290           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2291           cleanup ();
2292           agent_exit (0);
2293         }
2294     }
2295 #endif /*HAVE_W32_SYSTEM*/
2296
2297   /* Code to be run from time to time.  */
2298 #if CHECK_OWN_SOCKET_INTERVAL > 0
2299   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
2300     {
2301       check_own_socket ();
2302       last_minute = time (NULL);
2303     }
2304 #endif
2305
2306 }
2307
2308
2309 /* A global function which allows us to call the reload stuff from
2310    other places too.  This is only used when build for W32.  */
2311 void
2312 agent_sighup_action (void)
2313 {
2314   log_info ("SIGHUP received - "
2315             "re-reading configuration and flushing cache\n");
2316
2317   agent_flush_cache ();
2318   reread_configuration ();
2319   agent_reload_trustlist ();
2320   /* We flush the module name cache so that after installing a
2321      "pinentry" binary that one can be used in case the
2322      "pinentry-basic" fallback was in use.  */
2323   gnupg_module_name_flush_some ();
2324 }
2325
2326
2327 /* A helper function to handle SIGUSR2.  */
2328 static void
2329 agent_sigusr2_action (void)
2330 {
2331   if (opt.verbose)
2332     log_info ("SIGUSR2 received - updating card event counter\n");
2333   /* Nothing to check right now.  We only increment a counter.  */
2334   bump_card_eventcounter ();
2335 }
2336
2337
2338 #ifndef HAVE_W32_SYSTEM
2339 /* The signal handler for this program.  It is expected to be run in
2340    its own trhead and not in the context of a signal handler.  */
2341 static void
2342 handle_signal (int signo)
2343 {
2344   switch (signo)
2345     {
2346 #ifndef HAVE_W32_SYSTEM
2347     case SIGHUP:
2348       agent_sighup_action ();
2349       break;
2350
2351     case SIGUSR1:
2352       log_info ("SIGUSR1 received - printing internal information:\n");
2353       /* Fixme: We need to see how to integrate pth dumping into our
2354          logging system.  */
2355       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
2356       agent_query_dump_state ();
2357       agent_scd_dump_state ();
2358       break;
2359
2360     case SIGUSR2:
2361       agent_sigusr2_action ();
2362       break;
2363
2364     case SIGTERM:
2365       if (!shutdown_pending)
2366         log_info ("SIGTERM received - shutting down ...\n");
2367       else
2368         log_info ("SIGTERM received - still %i open connections\n",
2369                   active_connections);
2370       shutdown_pending++;
2371       if (shutdown_pending > 2)
2372         {
2373           log_info ("shutdown forced\n");
2374           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
2375           cleanup ();
2376           agent_exit (0);
2377         }
2378       break;
2379
2380     case SIGINT:
2381       log_info ("SIGINT received - immediate shutdown\n");
2382       log_info( "%s %s stopped\n", strusage(11), strusage(13));
2383       cleanup ();
2384       agent_exit (0);
2385       break;
2386 #endif
2387     default:
2388       log_info ("signal %d received - no action defined\n", signo);
2389     }
2390 }
2391 #endif
2392
2393 /* Check the nonce on a new connection.  This is a NOP unless we we
2394    are using our Unix domain socket emulation under Windows.  */
2395 static int
2396 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
2397 {
2398   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
2399     {
2400       log_info (_("error reading nonce on fd %d: %s\n"),
2401                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
2402       assuan_sock_close (ctrl->thread_startup.fd);
2403       xfree (ctrl);
2404       return -1;
2405     }
2406   else
2407     return 0;
2408 }
2409
2410
2411 #ifdef HAVE_W32_SYSTEM
2412 /* The window message processing function for Putty.  Warning: This
2413    code runs as a native Windows thread.  Use of our own functions
2414    needs to be bracket with pth_leave/pth_enter. */
2415 static LRESULT CALLBACK
2416 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2417 {
2418   int ret = 0;
2419   int w32rc;
2420   COPYDATASTRUCT *cds;
2421   const char *mapfile;
2422   HANDLE maphd;
2423   PSID mysid = NULL;
2424   PSID mapsid = NULL;
2425   void *data = NULL;
2426   PSECURITY_DESCRIPTOR psd = NULL;
2427   ctrl_t ctrl = NULL;
2428
2429   if (msg != WM_COPYDATA)
2430     {
2431       return DefWindowProc (hwnd, msg, wparam, lparam);
2432     }
2433
2434   cds = (COPYDATASTRUCT*)lparam;
2435   if (cds->dwData != PUTTY_IPC_MAGIC)
2436     return 0;  /* Ignore data with the wrong magic.  */
2437   mapfile = cds->lpData;
2438   if (!cds->cbData || mapfile[cds->cbData - 1])
2439     return 0;  /* Ignore empty and non-properly terminated strings.  */
2440
2441   if (DBG_IPC)
2442     {
2443       npth_protect ();
2444       log_debug ("ssh map file '%s'", mapfile);
2445       npth_unprotect ();
2446     }
2447
2448   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
2449   if (DBG_IPC)
2450     {
2451       npth_protect ();
2452       log_debug ("ssh map handle %p\n", maphd);
2453       npth_unprotect ();
2454     }
2455
2456   if (!maphd || maphd == INVALID_HANDLE_VALUE)
2457     return 0;
2458
2459   npth_protect ();
2460
2461   mysid = w32_get_user_sid ();
2462   if (!mysid)
2463     {
2464       log_error ("error getting my sid\n");
2465       goto leave;
2466     }
2467
2468   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
2469                            OWNER_SECURITY_INFORMATION,
2470                            &mapsid, NULL, NULL, NULL,
2471                            &psd);
2472   if (w32rc)
2473     {
2474       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
2475       goto leave;
2476     }
2477
2478   if (DBG_IPC)
2479     {
2480       char *sidstr;
2481
2482       if (!ConvertSidToStringSid (mysid, &sidstr))
2483         sidstr = NULL;
2484       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
2485       LocalFree (sidstr);
2486       if (!ConvertSidToStringSid (mapsid, &sidstr))
2487         sidstr = NULL;
2488       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
2489       LocalFree (sidstr);
2490     }
2491
2492   if (!EqualSid (mysid, mapsid))
2493     {
2494       log_error ("ssh map file has a non-matching sid\n");
2495       goto leave;
2496     }
2497
2498   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
2499   if (DBG_IPC)
2500     log_debug ("ssh IPC buffer at %p\n", data);
2501   if (!data)
2502     goto leave;
2503
2504   /* log_printhex ("request:", data, 20); */
2505
2506   ctrl = xtrycalloc (1, sizeof *ctrl);
2507   if (!ctrl)
2508     {
2509       log_error ("error allocating connection control data: %s\n",
2510                  strerror (errno) );
2511       goto leave;
2512     }
2513   ctrl->session_env = session_env_new ();
2514   if (!ctrl->session_env)
2515     {
2516       log_error ("error allocating session environment block: %s\n",
2517                  strerror (errno) );
2518       goto leave;
2519     }
2520
2521   agent_init_default_ctrl (ctrl);
2522   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
2523     ret = 1; /* Valid ssh message has been constructed.  */
2524   agent_deinit_default_ctrl (ctrl);
2525   /* log_printhex ("  reply:", data, 20); */
2526
2527  leave:
2528   xfree (ctrl);
2529   if (data)
2530     UnmapViewOfFile (data);
2531   xfree (mapsid);
2532   if (psd)
2533     LocalFree (psd);
2534   xfree (mysid);
2535   CloseHandle (maphd);
2536
2537   npth_unprotect ();
2538
2539   return ret;
2540 }
2541 #endif /*HAVE_W32_SYSTEM*/
2542
2543
2544 #ifdef HAVE_W32_SYSTEM
2545 /* The thread handling Putty's IPC requests.  */
2546 static void *
2547 putty_message_thread (void *arg)
2548 {
2549   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
2550                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
2551   HWND hwnd;
2552   MSG msg;
2553
2554   (void)arg;
2555
2556   if (opt.verbose)
2557     log_info ("putty message loop thread started\n");
2558
2559   /* The message loop runs as thread independent from our nPth system.
2560      This also means that we need to make sure that we switch back to
2561      our system before calling any no-windows function.  */
2562   npth_unprotect ();
2563
2564   /* First create a window to make sure that a message queue exists
2565      for this thread.  */
2566   if (!RegisterClass (&wndwclass))
2567     {
2568       npth_protect ();
2569       log_error ("error registering Pageant window class");
2570       return NULL;
2571     }
2572   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
2573                          0, 0, 0, 0,
2574                          HWND_MESSAGE,  /* hWndParent */
2575                          NULL,          /* hWndMenu   */
2576                          NULL,          /* hInstance  */
2577                          NULL);         /* lpParm     */
2578   if (!hwnd)
2579     {
2580       npth_protect ();
2581       log_error ("error creating Pageant window");
2582       return NULL;
2583     }
2584
2585   while (GetMessage(&msg, NULL, 0, 0))
2586     {
2587       TranslateMessage(&msg);
2588       DispatchMessage(&msg);
2589     }
2590
2591   /* Back to nPth.  */
2592   npth_protect ();
2593
2594   if (opt.verbose)
2595     log_info ("putty message loop thread stopped\n");
2596   return NULL;
2597 }
2598 #endif /*HAVE_W32_SYSTEM*/
2599
2600
2601 static void *
2602 do_start_connection_thread (ctrl_t ctrl)
2603 {
2604   active_connections++;
2605   agent_init_default_ctrl (ctrl);
2606   if (opt.verbose && !DBG_IPC)
2607     log_info (_("handler 0x%lx for fd %d started\n"),
2608               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2609
2610   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
2611   if (opt.verbose && !DBG_IPC)
2612     log_info (_("handler 0x%lx for fd %d terminated\n"),
2613               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2614
2615   agent_deinit_default_ctrl (ctrl);
2616   xfree (ctrl);
2617   active_connections--;
2618   return NULL;
2619 }
2620
2621
2622 /* This is the standard connection thread's main function.  */
2623 static void *
2624 start_connection_thread_std (void *arg)
2625 {
2626   ctrl_t ctrl = arg;
2627
2628   if (check_nonce (ctrl, &socket_nonce))
2629     {
2630       log_error ("handler 0x%lx nonce check FAILED\n",
2631                  (unsigned long) npth_self());
2632       return NULL;
2633     }
2634
2635   return do_start_connection_thread (ctrl);
2636 }
2637
2638
2639 /* This is the extra socket connection thread's main function.  */
2640 static void *
2641 start_connection_thread_extra (void *arg)
2642 {
2643   ctrl_t ctrl = arg;
2644
2645   if (check_nonce (ctrl, &socket_nonce_extra))
2646     {
2647       log_error ("handler 0x%lx nonce check FAILED\n",
2648                  (unsigned long) npth_self());
2649       return NULL;
2650     }
2651
2652   ctrl->restricted = 1;
2653   return do_start_connection_thread (ctrl);
2654 }
2655
2656
2657 /* This is the browser socket connection thread's main function.  */
2658 static void *
2659 start_connection_thread_browser (void *arg)
2660 {
2661   ctrl_t ctrl = arg;
2662
2663   if (check_nonce (ctrl, &socket_nonce_browser))
2664     {
2665       log_error ("handler 0x%lx nonce check FAILED\n",
2666                  (unsigned long) npth_self());
2667       return NULL;
2668     }
2669
2670   ctrl->restricted = 2;
2671   return do_start_connection_thread (ctrl);
2672 }
2673
2674
2675 /* This is the ssh connection thread's main function.  */
2676 static void *
2677 start_connection_thread_ssh (void *arg)
2678 {
2679   ctrl_t ctrl = arg;
2680
2681   if (check_nonce (ctrl, &socket_nonce_ssh))
2682     return NULL;
2683
2684   active_connections++;
2685   agent_init_default_ctrl (ctrl);
2686   if (opt.verbose)
2687     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2688               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2689
2690   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2691   if (opt.verbose)
2692     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2693               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2694
2695   agent_deinit_default_ctrl (ctrl);
2696   xfree (ctrl);
2697   active_connections--;
2698   return NULL;
2699 }
2700
2701
2702 #ifdef HAVE_INOTIFY_INIT
2703 /* Read an inotify event and return true if it matches NAME.  */
2704 static int
2705 my_inotify_is_name (int fd, const char *name)
2706 {
2707   union {
2708     struct inotify_event ev;
2709     char _buf[sizeof (struct inotify_event) + 100 + 1];
2710   } buf;
2711   int n;
2712
2713   n = npth_read (fd, &buf, sizeof buf);
2714   if (n < sizeof (struct inotify_event))
2715     return 0;
2716   if (buf.ev.len < strlen (name)+1)
2717     return 0;
2718   if (strcmp (buf.ev.name, name))
2719     return 0; /* Not the desired file.  */
2720
2721   return 1; /* Found.  */
2722 }
2723 #endif /*HAVE_INOTIFY_INIT*/
2724
2725
2726
2727 /* Connection handler loop.  Wait for connection requests and spawn a
2728    thread after accepting a connection.  */
2729 static void
2730 handle_connections (gnupg_fd_t listen_fd,
2731                     gnupg_fd_t listen_fd_extra,
2732                     gnupg_fd_t listen_fd_browser,
2733                     gnupg_fd_t listen_fd_ssh)
2734 {
2735   npth_attr_t tattr;
2736   struct sockaddr_un paddr;
2737   socklen_t plen;
2738   fd_set fdset, read_fdset;
2739   int ret;
2740   gnupg_fd_t fd;
2741   int nfd;
2742   int saved_errno;
2743   struct timespec abstime;
2744   struct timespec curtime;
2745   struct timespec timeout;
2746 #ifdef HAVE_W32_SYSTEM
2747   HANDLE events[2];
2748   unsigned int events_set;
2749 #endif
2750 #ifdef HAVE_INOTIFY_INIT
2751   int my_inotify_fd;
2752 #endif /*HAVE_INOTIFY_INIT*/
2753   struct {
2754     const char *name;
2755     void *(*func) (void *arg);
2756     gnupg_fd_t l_fd;
2757   } listentbl[] = {
2758     { "std",     start_connection_thread_std   },
2759     { "extra",   start_connection_thread_extra },
2760     { "browser", start_connection_thread_browser },
2761     { "ssh",    start_connection_thread_ssh   }
2762   };
2763
2764
2765   ret = npth_attr_init(&tattr);
2766   if (ret)
2767     log_fatal ("error allocating thread attributes: %s\n",
2768                strerror (ret));
2769   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2770
2771 #ifndef HAVE_W32_SYSTEM
2772   npth_sigev_init ();
2773   npth_sigev_add (SIGHUP);
2774   npth_sigev_add (SIGUSR1);
2775   npth_sigev_add (SIGUSR2);
2776   npth_sigev_add (SIGINT);
2777   npth_sigev_add (SIGTERM);
2778   npth_sigev_fini ();
2779 #else
2780 # ifdef HAVE_W32CE_SYSTEM
2781   /* Use a dummy event. */
2782   sigs = 0;
2783   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2784 # else
2785   events[0] = get_agent_scd_notify_event ();
2786   events[1] = INVALID_HANDLE_VALUE;
2787 # endif
2788 #endif
2789
2790 #ifdef HAVE_INOTIFY_INIT
2791   if (disable_check_own_socket)
2792     my_inotify_fd = -1;
2793   else if ((my_inotify_fd = inotify_init ()) == -1)
2794     log_info ("error enabling fast daemon termination: %s\n",
2795               strerror (errno));
2796   else
2797     {
2798       /* We need to watch the directory for the file because there
2799        * won't be an IN_DELETE_SELF for a socket file.  */
2800       char *slash = strrchr (socket_name, '/');
2801       log_assert (slash && slash[1]);
2802       *slash = 0;
2803       if (inotify_add_watch (my_inotify_fd, socket_name, IN_DELETE) == -1)
2804         {
2805           close (my_inotify_fd);
2806           my_inotify_fd = -1;
2807         }
2808       *slash = '/';
2809     }
2810 #endif /*HAVE_INOTIFY_INIT*/
2811
2812   /* On Windows we need to fire up a separate thread to listen for
2813      requests from Putty (an SSH client), so we can replace Putty's
2814      Pageant (its ssh-agent implementation). */
2815 #ifdef HAVE_W32_SYSTEM
2816   if (putty_support)
2817     {
2818       npth_t thread;
2819
2820       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2821       if (ret)
2822         {
2823           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2824         }
2825     }
2826 #endif /*HAVE_W32_SYSTEM*/
2827
2828   /* Set a flag to tell call-scd.c that it may enable event
2829      notifications.  */
2830   opt.sigusr2_enabled = 1;
2831
2832   FD_ZERO (&fdset);
2833   FD_SET (FD2INT (listen_fd), &fdset);
2834   nfd = FD2INT (listen_fd);
2835   if (listen_fd_extra != GNUPG_INVALID_FD)
2836     {
2837       FD_SET ( FD2INT(listen_fd_extra), &fdset);
2838       if (FD2INT (listen_fd_extra) > nfd)
2839         nfd = FD2INT (listen_fd_extra);
2840     }
2841   if (listen_fd_browser != GNUPG_INVALID_FD)
2842     {
2843       FD_SET ( FD2INT(listen_fd_browser), &fdset);
2844       if (FD2INT (listen_fd_browser) > nfd)
2845         nfd = FD2INT (listen_fd_browser);
2846     }
2847   if (listen_fd_ssh != GNUPG_INVALID_FD)
2848     {
2849       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2850       if (FD2INT (listen_fd_ssh) > nfd)
2851         nfd = FD2INT (listen_fd_ssh);
2852     }
2853 #ifdef HAVE_INOTIFY_INIT
2854   if (my_inotify_fd != -1)
2855     {
2856       FD_SET (my_inotify_fd, &fdset);
2857       if (my_inotify_fd > nfd)
2858         nfd = my_inotify_fd;
2859     }
2860 #endif /*HAVE_INOTIFY_INIT*/
2861
2862   listentbl[0].l_fd = listen_fd;
2863   listentbl[1].l_fd = listen_fd_extra;
2864   listentbl[2].l_fd = listen_fd_browser;
2865   listentbl[3].l_fd = listen_fd_ssh;
2866
2867   npth_clock_gettime (&abstime);
2868   abstime.tv_sec += TIMERTICK_INTERVAL;
2869
2870   for (;;)
2871     {
2872       /* Shutdown test.  */
2873       if (shutdown_pending)
2874         {
2875           if (active_connections == 0)
2876             break; /* ready */
2877
2878           /* Do not accept new connections but keep on running the
2879              loop to cope with the timer events.  */
2880           FD_ZERO (&fdset);
2881         }
2882
2883       /* POSIX says that fd_set should be implemented as a structure,
2884          thus a simple assignment is fine to copy the entire set.  */
2885       read_fdset = fdset;
2886
2887       npth_clock_gettime (&curtime);
2888       if (!(npth_timercmp (&curtime, &abstime, <)))
2889         {
2890           /* Timeout.  */
2891           handle_tick ();
2892           npth_clock_gettime (&abstime);
2893           abstime.tv_sec += TIMERTICK_INTERVAL;
2894         }
2895       npth_timersub (&abstime, &curtime, &timeout);
2896
2897 #ifndef HAVE_W32_SYSTEM
2898       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2899                           npth_sigev_sigmask ());
2900       saved_errno = errno;
2901
2902       {
2903         int signo;
2904         while (npth_sigev_get_pending (&signo))
2905           handle_signal (signo);
2906       }
2907 #else
2908       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2909                           events, &events_set);
2910       saved_errno = errno;
2911
2912       /* This is valid even if npth_eselect returns an error.  */
2913       if (events_set & 1)
2914         agent_sigusr2_action ();
2915 #endif
2916
2917       if (ret == -1 && saved_errno != EINTR)
2918         {
2919           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2920                      strerror (saved_errno));
2921           npth_sleep (1);
2922           continue;
2923         }
2924       if (ret <= 0)
2925         /* Interrupt or timeout.  Will be handled when calculating the
2926            next timeout.  */
2927         continue;
2928
2929       if (!shutdown_pending)
2930         {
2931           int idx;
2932           ctrl_t ctrl;
2933           npth_t thread;
2934
2935 #ifdef HAVE_INOTIFY_INIT
2936           if (my_inotify_fd != -1 && FD_ISSET (my_inotify_fd, &read_fdset)
2937               && my_inotify_is_name (my_inotify_fd, GPG_AGENT_SOCK_NAME))
2938             {
2939               shutdown_pending = 1;
2940               log_info ("socket file has been removed - shutting down\n");
2941             }
2942 #endif /*HAVE_INOTIFY_INIT*/
2943
2944           for (idx=0; idx < DIM(listentbl); idx++)
2945             {
2946               if (listentbl[idx].l_fd == GNUPG_INVALID_FD)
2947                 continue;
2948               if (!FD_ISSET (FD2INT (listentbl[idx].l_fd), &read_fdset))
2949                 continue;
2950
2951               plen = sizeof paddr;
2952               fd = INT2FD (npth_accept (FD2INT(listentbl[idx].l_fd),
2953                                         (struct sockaddr *)&paddr, &plen));
2954               if (fd == GNUPG_INVALID_FD)
2955                 {
2956                   log_error ("accept failed for %s: %s\n",
2957                              listentbl[idx].name, strerror (errno));
2958                 }
2959               else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)))
2960                 {
2961                   log_error ("error allocating connection data for %s: %s\n",
2962                              listentbl[idx].name, strerror (errno) );
2963                   assuan_sock_close (fd);
2964                 }
2965               else if ( !(ctrl->session_env = session_env_new ()))
2966                 {
2967                   log_error ("error allocating session env block for %s: %s\n",
2968                              listentbl[idx].name, strerror (errno) );
2969                   xfree (ctrl);
2970                   assuan_sock_close (fd);
2971                 }
2972               else
2973                 {
2974                   ctrl->thread_startup.fd = fd;
2975                   ret = npth_create (&thread, &tattr,
2976                                      listentbl[idx].func, ctrl);
2977                   if (ret)
2978                     {
2979                       log_error ("error spawning connection handler for %s:"
2980                                  " %s\n", listentbl[idx].name, strerror (ret));
2981                       assuan_sock_close (fd);
2982                       xfree (ctrl);
2983                     }
2984                 }
2985               fd = GNUPG_INVALID_FD;
2986             }
2987         }
2988     }
2989
2990 #ifdef HAVE_INOTIFY_INIT
2991   if (my_inotify_fd != -1)
2992     close (my_inotify_fd);
2993 #endif /*HAVE_INOTIFY_INIT*/
2994   cleanup ();
2995   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2996   npth_attr_destroy (&tattr);
2997 }
2998
2999
3000
3001 /* Helper for check_own_socket.  */
3002 static gpg_error_t
3003 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
3004 {
3005   membuf_t *mb = opaque;
3006   put_membuf (mb, buffer, length);
3007   return 0;
3008 }
3009
3010
3011 /* The thread running the actual check.  We need to run this in a
3012    separate thread so that check_own_thread can be called from the
3013    timer tick.  */
3014 static void *
3015 check_own_socket_thread (void *arg)
3016 {
3017   int rc;
3018   char *sockname = arg;
3019   assuan_context_t ctx = NULL;
3020   membuf_t mb;
3021   char *buffer;
3022
3023   check_own_socket_running++;
3024
3025   rc = assuan_new (&ctx);
3026   if (rc)
3027     {
3028       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
3029       goto leave;
3030     }
3031   assuan_set_flag (ctx, ASSUAN_NO_LOGGING, 1);
3032
3033   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3034   if (rc)
3035     {
3036       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
3037       goto leave;
3038     }
3039
3040   init_membuf (&mb, 100);
3041   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
3042                         NULL, NULL, NULL, NULL);
3043   put_membuf (&mb, "", 1);
3044   buffer = get_membuf (&mb, NULL);
3045   if (rc || !buffer)
3046     {
3047       log_error ("sending command \"%s\" to my own socket failed: %s\n",
3048                  "GETINFO pid", gpg_strerror (rc));
3049       rc = 1;
3050     }
3051   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
3052     {
3053       log_error ("socket is now serviced by another server\n");
3054       rc = 1;
3055     }
3056   else if (opt.verbose > 1)
3057     log_error ("socket is still served by this server\n");
3058
3059   xfree (buffer);
3060
3061  leave:
3062   xfree (sockname);
3063   if (ctx)
3064     assuan_release (ctx);
3065   if (rc)
3066     {
3067       /* We may not remove the socket as it is now in use by another
3068          server. */
3069       inhibit_socket_removal = 1;
3070       shutdown_pending = 2;
3071       log_info ("this process is useless - shutting down\n");
3072     }
3073   check_own_socket_running--;
3074   return NULL;
3075 }
3076
3077
3078 /* Check whether we are still listening on our own socket.  In case
3079    another gpg-agent process started after us has taken ownership of
3080    our socket, we would linger around without any real task.  Thus we
3081    better check once in a while whether we are really needed.  */
3082 static void
3083 check_own_socket (void)
3084 {
3085   char *sockname;
3086   npth_t thread;
3087   npth_attr_t tattr;
3088   int err;
3089
3090   if (disable_check_own_socket)
3091     return;
3092
3093   if (check_own_socket_running || shutdown_pending)
3094     return;  /* Still running or already shutting down.  */
3095
3096   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3097   if (!sockname)
3098     return; /* Out of memory.  */
3099
3100   err = npth_attr_init (&tattr);
3101   if (err)
3102     return;
3103   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
3104   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
3105   if (err)
3106     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
3107   npth_attr_destroy (&tattr);
3108 }
3109
3110
3111
3112 /* Figure out whether an agent is available and running. Prints an
3113    error if not.  If SILENT is true, no messages are printed.
3114    Returns 0 if the agent is running. */
3115 static int
3116 check_for_running_agent (int silent)
3117 {
3118   gpg_error_t err;
3119   char *sockname;
3120   assuan_context_t ctx = NULL;
3121
3122   sockname = make_filename_try (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
3123   if (!sockname)
3124     return gpg_error_from_syserror ();
3125
3126   err = assuan_new (&ctx);
3127   if (!err)
3128     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
3129   xfree (sockname);
3130   if (err)
3131     {
3132       if (!silent)
3133         log_error (_("no gpg-agent running in this session\n"));
3134
3135       if (ctx)
3136         assuan_release (ctx);
3137       return -1;
3138     }
3139
3140   if (!opt.quiet && !silent)
3141     log_info ("gpg-agent running and available\n");
3142
3143   assuan_release (ctx);
3144   return 0;
3145 }