Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 653 insertions, 0 deletions

diff --git a/toolkit/components/remote/nsXRemoteClient.cpp b/toolkit/components/remote/nsXRemoteClient.cpp
new file mode 100644
index 0000000000..198f7f70c2
--- /dev/null
+++ b/toolkit/components/remote/nsXRemoteClient.cpp
@@ -0,0 +1,653 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=8:
+ */
+/* vim:set ts=8 sw=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsDebug.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/Unused.h"
+#include "nsXRemoteClient.h"
+#include "RemoteUtils.h"
+#include "prsystem.h"
+#include "mozilla/Logging.h"
+#include "prenv.h"
+#include "prdtoa.h"
+#include <X11/Xatom.h>
+#include <limits.h>
+#include <poll.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define MOZILLA_VERSION_PROP "_MOZILLA_VERSION"
+#define MOZILLA_LOCK_PROP "_MOZILLA_LOCK"
+#define MOZILLA_COMMANDLINE_PROP "_MOZILLA_COMMANDLINE"
+#define MOZILLA_RESPONSE_PROP "_MOZILLA_RESPONSE"
+#define MOZILLA_USER_PROP "_MOZILLA_USER"
+#define MOZILLA_PROFILE_PROP "_MOZILLA_PROFILE"
+#define MOZILLA_PROGRAM_PROP "_MOZILLA_PROGRAM"
+
+#ifdef IS_BIG_ENDIAN
+#  define TO_LITTLE_ENDIAN32(x)                           \
+    ((((x)&0xff000000) >> 24) | (((x)&0x00ff0000) >> 8) | \
+     (((x)&0x0000ff00) << 8) | (((x)&0x000000ff) << 24))
+#else
+#  define TO_LITTLE_ENDIAN32(x) (x)
+#endif
+
+#ifndef MAX_PATH
+#  ifdef PATH_MAX
+#    define MAX_PATH PATH_MAX
+#  else
+#    define MAX_PATH 1024
+#  endif
+#endif
+
+using mozilla::LogLevel;
+using mozilla::Unused;
+
+static mozilla::LazyLogModule sRemoteLm("nsXRemoteClient");
+
+static int (*sOldHandler)(Display*, XErrorEvent*);
+static bool sGotBadWindow;
+
+nsXRemoteClient::nsXRemoteClient() {
+  mDisplay = 0;
+  mInitialized = false;
+  mMozVersionAtom = 0;
+  mMozLockAtom = 0;
+  mMozCommandLineAtom = 0;
+  mMozResponseAtom = 0;
+  mMozWMStateAtom = 0;
+  mMozUserAtom = 0;
+  mMozProfileAtom = 0;
+  mMozProgramAtom = 0;
+  mLockData = 0;
+  MOZ_LOG(sRemoteLm, LogLevel::Debug, ("nsXRemoteClient::nsXRemoteClient"));
+}
+
+nsXRemoteClient::~nsXRemoteClient() {
+  MOZ_LOG(sRemoteLm, LogLevel::Debug, ("nsXRemoteClient::~nsXRemoteClient"));
+  if (mInitialized) Shutdown();
+}
+
+// Minimize the roundtrips to the X-server
+static const char* XAtomNames[] = {
+    MOZILLA_VERSION_PROP, MOZILLA_LOCK_PROP,       MOZILLA_RESPONSE_PROP,
+    "WM_STATE",           MOZILLA_USER_PROP,       MOZILLA_PROFILE_PROP,
+    MOZILLA_PROGRAM_PROP, MOZILLA_COMMANDLINE_PROP};
+static Atom XAtoms[MOZ_ARRAY_LENGTH(XAtomNames)];
+
+nsresult nsXRemoteClient::Init() {
+  MOZ_LOG(sRemoteLm, LogLevel::Debug, ("nsXRemoteClient::Init"));
+
+  if (mInitialized) return NS_OK;
+
+  // try to open the display
+  mDisplay = XOpenDisplay(0);
+  if (!mDisplay) return NS_ERROR_FAILURE;
+
+  // get our atoms
+  XInternAtoms(mDisplay, const_cast<char**>(XAtomNames),
+               MOZ_ARRAY_LENGTH(XAtomNames), False, XAtoms);
+
+  int i = 0;
+  mMozVersionAtom = XAtoms[i++];
+  mMozLockAtom = XAtoms[i++];
+  mMozResponseAtom = XAtoms[i++];
+  mMozWMStateAtom = XAtoms[i++];
+  mMozUserAtom = XAtoms[i++];
+  mMozProfileAtom = XAtoms[i++];
+  mMozProgramAtom = XAtoms[i++];
+  mMozCommandLineAtom = XAtoms[i];
+
+  mInitialized = true;
+
+  return NS_OK;
+}
+
+void nsXRemoteClient::Shutdown(void) {
+  MOZ_LOG(sRemoteLm, LogLevel::Debug, ("nsXRemoteClient::Shutdown"));
+
+  if (!mInitialized) return;
+
+  // shut everything down
+  XCloseDisplay(mDisplay);
+  mDisplay = 0;
+  mInitialized = false;
+  if (mLockData) {
+    free(mLockData);
+    mLockData = 0;
+  }
+}
+
+static int HandleBadWindow(Display* display, XErrorEvent* event) {
+  if (event->error_code == BadWindow) {
+    sGotBadWindow = true;
+    return 0;  // ignored
+  }
+
+  return (*sOldHandler)(display, event);
+}
+
+nsresult nsXRemoteClient::SendCommandLine(
+    const char* aProgram, const char* aProfile, int32_t argc, char** argv,
+    const char* aStartupToken, char** aResponse, bool* aWindowFound) {
+  NS_ENSURE_TRUE(aProgram, NS_ERROR_INVALID_ARG);
+
+  MOZ_LOG(sRemoteLm, LogLevel::Debug, ("nsXRemoteClient::SendCommandLine"));
+
+  *aWindowFound = false;
+
+  // FindBestWindow() iterates down the window hierarchy, so catch X errors
+  // when windows get destroyed before being accessed.
+  sOldHandler = XSetErrorHandler(HandleBadWindow);
+
+  Window w = FindBestWindow(aProgram, aProfile);
+
+  nsresult rv = NS_OK;
+
+  if (w) {
+    // ok, let the caller know that we at least found a window.
+    *aWindowFound = true;
+
+    // Ignore BadWindow errors up to this point.  The last request from
+    // FindBestWindow() was a synchronous XGetWindowProperty(), so no need to
+    // Sync.  Leave the error handler installed to detect if w gets destroyed.
+    sGotBadWindow = false;
+
+    // make sure we get the right events on that window
+    XSelectInput(mDisplay, w, (PropertyChangeMask | StructureNotifyMask));
+
+    bool destroyed = false;
+
+    // get the lock on the window
+    rv = GetLock(w, &destroyed);
+
+    if (NS_SUCCEEDED(rv)) {
+      // send our command
+      rv = DoSendCommandLine(w, argc, argv, aStartupToken, aResponse,
+                             &destroyed);
+
+      // if the window was destroyed, don't bother trying to free the
+      // lock.
+      if (!destroyed) FreeLock(w);  // doesn't really matter what this returns
+    }
+  }
+
+  XSetErrorHandler(sOldHandler);
+
+  MOZ_LOG(sRemoteLm, LogLevel::Debug,
+          ("SendCommandInternal returning 0x%" PRIx32 "\n",
+           static_cast<uint32_t>(rv)));
+
+  return rv;
+}
+
+Window nsXRemoteClient::CheckWindow(Window aWindow) {
+  Atom type = None;
+  int format;
+  unsigned long nitems, bytesafter;
+  unsigned char* data;
+  Window innerWindow;
+
+  XGetWindowProperty(mDisplay, aWindow, mMozWMStateAtom, 0, 0, False,
+                     AnyPropertyType, &type, &format, &nitems, &bytesafter,
+                     &data);
+
+  if (type) {
+    XFree(data);
+    return aWindow;
+  }
+
+  // didn't find it here so check the children of this window
+  innerWindow = CheckChildren(aWindow);
+
+  if (innerWindow) return innerWindow;
+
+  return aWindow;
+}
+
+Window nsXRemoteClient::CheckChildren(Window aWindow) {
+  Window root, parent;
+  Window* children;
+  unsigned int nchildren;
+  unsigned int i;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  unsigned char* data;
+  Window retval = None;
+
+  if (!XQueryTree(mDisplay, aWindow, &root, &parent, &children, &nchildren))
+    return None;
+
+  // scan the list first before recursing into the list of windows
+  // which can get quite deep.
+  for (i = 0; !retval && (i < nchildren); i++) {
+    XGetWindowProperty(mDisplay, children[i], mMozWMStateAtom, 0, 0, False,
+                       AnyPropertyType, &type, &format, &nitems, &after, &data);
+    if (type) {
+      XFree(data);
+      retval = children[i];
+    }
+  }
+
+  // otherwise recurse into the list
+  for (i = 0; !retval && (i < nchildren); i++) {
+    retval = CheckChildren(children[i]);
+  }
+
+  if (children) XFree((char*)children);
+
+  return retval;
+}
+
+nsresult nsXRemoteClient::GetLock(Window aWindow, bool* aDestroyed) {
+  bool locked = false;
+  bool waited = false;
+  *aDestroyed = false;
+
+  nsresult rv = NS_OK;
+
+  if (!mLockData) {
+    char pidstr[32];
+    char sysinfobuf[SYS_INFO_BUFFER_LENGTH];
+    SprintfLiteral(pidstr, "pid%d@", getpid());
+    PRStatus status;
+    status =
+        PR_GetSystemInfo(PR_SI_HOSTNAME, sysinfobuf, SYS_INFO_BUFFER_LENGTH);
+    if (status != PR_SUCCESS) {
+      return NS_ERROR_FAILURE;
+    }
+
+    // allocate enough space for the string plus the terminating
+    // char
+    mLockData = (char*)malloc(strlen(pidstr) + strlen(sysinfobuf) + 1);
+    if (!mLockData) return NS_ERROR_OUT_OF_MEMORY;
+
+    strcpy(mLockData, pidstr);
+    if (!strcat(mLockData, sysinfobuf)) return NS_ERROR_FAILURE;
+  }
+
+  do {
+    int result;
+    Atom actual_type;
+    int actual_format;
+    unsigned long nitems, bytes_after;
+    unsigned char* data = 0;
+
+    XGrabServer(mDisplay);
+
+    result = XGetWindowProperty(
+        mDisplay, aWindow, mMozLockAtom, 0, (65536 / sizeof(long)),
+        False, /* don't delete */
+        XA_STRING, &actual_type, &actual_format, &nitems, &bytes_after, &data);
+
+    // aWindow may have been destroyed before XSelectInput was processed, in
+    // which case there may not be any DestroyNotify event in the queue to
+    // tell us.  XGetWindowProperty() was synchronous so error responses have
+    // now been processed, setting sGotBadWindow.
+    if (sGotBadWindow) {
+      *aDestroyed = true;
+      rv = NS_ERROR_FAILURE;
+    } else if (result != Success || actual_type == None) {
+      /* It's not now locked - lock it. */
+      XChangeProperty(mDisplay, aWindow, mMozLockAtom, XA_STRING, 8,
+                      PropModeReplace, (unsigned char*)mLockData,
+                      strlen(mLockData));
+      locked = True;
+    }
+
+    XUngrabServer(mDisplay);
+    XFlush(mDisplay);  // ungrab now!
+
+    if (!locked && !NS_FAILED(rv)) {
+      /* We tried to grab the lock this time, and failed because someone
+         else is holding it already.  So, wait for a PropertyDelete event
+         to come in, and try again. */
+      MOZ_LOG(sRemoteLm, LogLevel::Debug,
+              ("window 0x%x is locked by %s; waiting...\n",
+               (unsigned int)aWindow, data));
+      waited = True;
+      while (true) {
+        XEvent event;
+        int poll_retval;
+        struct pollfd pfd;
+
+        pfd.fd = ConnectionNumber(mDisplay);
+        pfd.events = POLLIN;
+
+        poll_retval = poll(&pfd, 1, 10 * 1000);
+        // did we time out?
+        if (poll_retval == 0) {
+          MOZ_LOG(sRemoteLm, LogLevel::Debug,
+                  ("timed out waiting for window\n"));
+          rv = NS_ERROR_FAILURE;
+          break;
+        }
+        MOZ_LOG(sRemoteLm, LogLevel::Debug, ("xevent...\n"));
+        // FIXME check the return value from this?
+        XNextEvent(mDisplay, &event);
+        if (event.xany.type == DestroyNotify &&
+            event.xdestroywindow.window == aWindow) {
+          *aDestroyed = true;
+          rv = NS_ERROR_FAILURE;
+          break;
+        }
+        if (event.xany.type == PropertyNotify &&
+            event.xproperty.state == PropertyDelete &&
+            event.xproperty.window == aWindow &&
+            event.xproperty.atom == mMozLockAtom) {
+          /* Ok!  Someone deleted their lock, so now we can try
+             again. */
+          MOZ_LOG(
+              sRemoteLm, LogLevel::Debug,
+              ("(0x%x unlocked, trying again...)\n", (unsigned int)aWindow));
+          break;
+        }
+      }
+    }
+    if (data) XFree(data);
+  } while (!locked && !NS_FAILED(rv));
+
+  if (waited && locked) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug, ("obtained lock.\n"));
+  } else if (*aDestroyed) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug,
+            ("window 0x%x unexpectedly destroyed.\n", (unsigned int)aWindow));
+  }
+
+  return rv;
+}
+
+Window nsXRemoteClient::FindBestWindow(const char* aProgram,
+                                       const char* aProfile) {
+  Window root = RootWindowOfScreen(DefaultScreenOfDisplay(mDisplay));
+  Window bestWindow = 0;
+  Window root2, parent, *kids;
+  unsigned int nkids;
+
+  // Get a list of the children of the root window, walk the list
+  // looking for the best window that fits the criteria.
+  if (!XQueryTree(mDisplay, root, &root2, &parent, &kids, &nkids)) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug,
+            ("XQueryTree failed in nsXRemoteClient::FindBestWindow"));
+    return 0;
+  }
+
+  if (!(kids && nkids)) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug, ("root window has no children"));
+    return 0;
+  }
+
+  // We'll walk the list of windows looking for a window that best
+  // fits the criteria here.
+
+  for (unsigned int i = 0; i < nkids; i++) {
+    Atom type;
+    int format;
+    unsigned long nitems, bytesafter;
+    unsigned char* data_return = 0;
+    Window w;
+    w = kids[i];
+    // find the inner window with WM_STATE on it
+    w = CheckWindow(w);
+
+    int status = XGetWindowProperty(
+        mDisplay, w, mMozVersionAtom, 0, (65536 / sizeof(long)), False,
+        XA_STRING, &type, &format, &nitems, &bytesafter, &data_return);
+
+    if (!data_return) continue;
+
+    double version = PR_strtod((char*)data_return, nullptr);
+    XFree(data_return);
+
+    if (!(version >= 5.1 && version < 6)) continue;
+
+    data_return = 0;
+
+    if (status != Success || type == None) continue;
+
+    // Check that this window is from the right program.
+    Unused << XGetWindowProperty(
+        mDisplay, w, mMozProgramAtom, 0, (65536 / sizeof(long)), False,
+        XA_STRING, &type, &format, &nitems, &bytesafter, &data_return);
+
+    // If the return name is not the same as this program name, we don't want
+    // this window.
+    if (data_return) {
+      if (strcmp(aProgram, (const char*)data_return)) {
+        XFree(data_return);
+        continue;
+      }
+
+      // This is actually the success condition.
+      XFree(data_return);
+    } else {
+      // Doesn't support the protocol, even though the user
+      // requested it.  So we're not going to use this window.
+      continue;
+    }
+
+    // Check to see if it has the user atom on that window.  If there
+    // is then we need to make sure that it matches what we have.
+    const char* username = PR_GetEnv("LOGNAME");
+
+    if (username) {
+      Unused << XGetWindowProperty(
+          mDisplay, w, mMozUserAtom, 0, (65536 / sizeof(long)), False,
+          XA_STRING, &type, &format, &nitems, &bytesafter, &data_return);
+
+      // if there's a username compare it with what we have
+      if (data_return) {
+        // If the IDs aren't equal, we don't want this window.
+        if (strcmp(username, (const char*)data_return)) {
+          XFree(data_return);
+          continue;
+        }
+
+        XFree(data_return);
+      }
+    }
+
+    // Check to see if there's a profile name on this window.  If
+    // there is, then we need to make sure it matches what someone
+    // passed in.
+    Unused << XGetWindowProperty(
+        mDisplay, w, mMozProfileAtom, 0, (65536 / sizeof(long)), False,
+        XA_STRING, &type, &format, &nitems, &bytesafter, &data_return);
+
+    // If there's a profile compare it with what we have
+    if (data_return) {
+      // If the profiles aren't equal, we don't want this window.
+      if (strcmp(aProfile, (const char*)data_return)) {
+        XFree(data_return);
+        continue;
+      }
+
+      XFree(data_return);
+    } else {
+      // This isn't the window for this profile.
+      continue;
+    }
+
+    // Check to see if the window supports the new command-line passing
+    // protocol, if that is requested.
+
+    // If we got this far, this is the best window.  It passed
+    // all the tests.
+    bestWindow = w;
+    break;
+  }
+
+  if (kids) XFree((char*)kids);
+
+  return bestWindow;
+}
+
+nsresult nsXRemoteClient::FreeLock(Window aWindow) {
+  int result;
+  Atom actual_type;
+  int actual_format;
+  unsigned long nitems, bytes_after;
+  unsigned char* data = 0;
+
+  result = XGetWindowProperty(
+      mDisplay, aWindow, mMozLockAtom, 0, (65536 / sizeof(long)),
+      True, /* atomic delete after */
+      XA_STRING, &actual_type, &actual_format, &nitems, &bytes_after, &data);
+  if (result != Success) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug,
+            ("unable to read and delete " MOZILLA_LOCK_PROP " property\n"));
+    return NS_ERROR_FAILURE;
+  }
+  if (!data || !*data) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug,
+            ("invalid data on " MOZILLA_LOCK_PROP " of window 0x%x.\n",
+             (unsigned int)aWindow));
+    return NS_ERROR_FAILURE;
+  } else if (strcmp((char*)data, mLockData)) {
+    MOZ_LOG(sRemoteLm, LogLevel::Debug,
+            (MOZILLA_LOCK_PROP " was stolen!  Expected \"%s\", saw \"%s\"!\n",
+             mLockData, data));
+    return NS_ERROR_FAILURE;
+  }
+
+  if (data) XFree(data);
+  return NS_OK;
+}
+
+nsresult nsXRemoteClient::DoSendCommandLine(Window aWindow, int32_t argc,
+                                            char** argv,
+                                            const char* aStartupToken,
+                                            char** aResponse,
+                                            bool* aDestroyed) {
+  *aDestroyed = false;
+
+  int commandLineLength;
+  char* commandLine =
+      ConstructCommandLine(argc, argv, aStartupToken, &commandLineLength);
+  XChangeProperty(mDisplay, aWindow, mMozCommandLineAtom, XA_STRING, 8,
+                  PropModeReplace, (unsigned char*)commandLine,
+                  commandLineLength);
+  free(commandLine);
+
+  if (!WaitForResponse(aWindow, aResponse, aDestroyed, mMozCommandLineAtom))
+    return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+bool nsXRemoteClient::WaitForResponse(Window aWindow, char** aResponse,
+                                      bool* aDestroyed, Atom aCommandAtom) {
+  bool done = false;
+  bool accepted = false;
+
+  while (!done) {
+    XEvent event;
+    XNextEvent(mDisplay, &event);
+    if (event.xany.type == DestroyNotify &&
+        event.xdestroywindow.window == aWindow) {
+      /* Print to warn user...*/
+      MOZ_LOG(sRemoteLm, LogLevel::Debug,
+              ("window 0x%x was destroyed.\n", (unsigned int)aWindow));
+      *aResponse = strdup("Window was destroyed while reading response.");
+      *aDestroyed = true;
+      return false;
+    }
+    if (event.xany.type == PropertyNotify &&
+        event.xproperty.state == PropertyNewValue &&
+        event.xproperty.window == aWindow &&
+        event.xproperty.atom == mMozResponseAtom) {
+      Atom actual_type;
+      int actual_format;
+      unsigned long nitems, bytes_after;
+      unsigned char* data = 0;
+      Bool result;
+      result = XGetWindowProperty(mDisplay, aWindow, mMozResponseAtom, 0,
+                                  (65536 / sizeof(long)),
+                                  True, /* atomic delete after */
+                                  XA_STRING, &actual_type, &actual_format,
+                                  &nitems, &bytes_after, &data);
+      if (result != Success) {
+        MOZ_LOG(
+            sRemoteLm, LogLevel::Debug,
+            ("failed reading " MOZILLA_RESPONSE_PROP " from window 0x%0x.\n",
+             (unsigned int)aWindow));
+        *aResponse = strdup("Internal error reading response from window.");
+        done = true;
+      } else if (!data || strlen((char*)data) < 5) {
+        MOZ_LOG(sRemoteLm, LogLevel::Debug,
+                ("invalid data on " MOZILLA_RESPONSE_PROP
+                 " property of window 0x%0x.\n",
+                 (unsigned int)aWindow));
+        *aResponse = strdup("Server returned invalid data in response.");
+        done = true;
+      } else if (*data == '1') { /* positive preliminary reply */
+        MOZ_LOG(sRemoteLm, LogLevel::Debug, ("%s\n", data + 4));
+        /* keep going */
+        done = false;
+      }
+
+      else if (!strncmp((char*)data, "200", 3)) { /* positive completion */
+        *aResponse = strdup((char*)data);
+        accepted = true;
+        done = true;
+      }
+
+      else if (*data == '2') { /* positive completion */
+        MOZ_LOG(sRemoteLm, LogLevel::Debug, ("%s\n", data + 4));
+        *aResponse = strdup((char*)data);
+        accepted = true;
+        done = true;
+      }
+
+      else if (*data == '3') { /* positive intermediate reply */
+        MOZ_LOG(sRemoteLm, LogLevel::Debug,
+                ("internal error: "
+                 "server wants more information?  (%s)\n",
+                 data));
+        *aResponse = strdup((char*)data);
+        done = true;
+      }
+
+      else if (*data == '4' || /* transient negative completion */
+               *data == '5') { /* permanent negative completion */
+        MOZ_LOG(sRemoteLm, LogLevel::Debug, ("%s\n", data + 4));
+        *aResponse = strdup((char*)data);
+        done = true;
+      }
+
+      else {
+        MOZ_LOG(
+            sRemoteLm, LogLevel::Debug,
+            ("unrecognised " MOZILLA_RESPONSE_PROP " from window 0x%x: %s\n",
+             (unsigned int)aWindow, data));
+        *aResponse = strdup((char*)data);
+        done = true;
+      }
+
+      if (data) XFree(data);
+    }
+
+    else if (event.xany.type == PropertyNotify &&
+             event.xproperty.window == aWindow &&
+             event.xproperty.state == PropertyDelete &&
+             event.xproperty.atom == aCommandAtom) {
+      MOZ_LOG(sRemoteLm, LogLevel::Debug,
+              ("(server 0x%x has accepted " MOZILLA_COMMANDLINE_PROP ".)\n",
+               (unsigned int)aWindow));
+    }
+  }
+
+  return accepted;
+}