Merge branch 'nxagent'

1 files changed, 788 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/hw/nxagent/Atoms.c b/nx-X11/programs/Xserver/hw/nxagent/Atoms.c
new file mode 100644
index 000000000..578731f07
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/nxagent/Atoms.c
@@ -0,0 +1,788 @@
+/**************************************************************************/
+/*                                                                        */
+/* Copyright (c) 2001, 2011 NoMachine, http://www.nomachine.com/.         */
+/*                                                                        */
+/* NXAGENT, NX protocol compression and NX extensions to this software    */
+/* are copyright of NoMachine. Redistribution and use of the present      */
+/* software is allowed according to terms specified in the file LICENSE   */
+/* which comes in the source distribution.                                */
+/*                                                                        */
+/* Check http://www.nomachine.com/licensing.html for applicability.       */
+/*                                                                        */
+/* NX and NoMachine are trademarks of Medialogic S.p.A.                   */
+/*                                                                        */
+/* All rights reserved.                                                   */
+/*                                                                        */
+/**************************************************************************/
+
+#include "scrnintstr.h"
+#include "Agent.h"
+
+#include "Xutil.h"
+#include "Xatom.h"
+#include "Xlib.h"
+
+#include "misc.h"
+#include "scrnintstr.h"
+#include "resource.h"
+
+#include "NXpack.h"
+
+#include "Atoms.h"
+#include "Args.h"
+#include "Image.h"
+#include "Display.h"
+#include "Screen.h"
+#include "Options.h"
+#include "Agent.h"
+
+/*
+ * Set here the required log level.
+ */
+
+#define PANIC
+#define WARNING
+#undef  TEST
+#undef  DEBUG
+
+/*
+ * These values should be moved in
+ * the option repository.
+ */
+
+Bool nxagentWMIsRunning;
+
+static void startWMDetection(void);
+
+static int nxagentInitAtomMap(char **atomNameList, int count, Atom *atomsRet);
+
+#ifdef DEBUG
+static void nxagentPrintAtomMapInfo(char *message);
+#else
+#define nxagentPrintAtomMapInfo(arg)
+#endif
+
+Atom nxagentAtoms[NXAGENT_NUMBER_OF_ATOMS];
+
+static char *nxagentAtomNames[NXAGENT_NUMBER_OF_ATOMS + 1] =
+{
+  "NX_IDENTITY",                 /* 0  */
+  "WM_PROTOCOLS",                /* 1  */
+  "WM_DELETE_WINDOW",            /* 2  */
+  "WM_NX_READY",                 /* 3  */
+  "MCOPGLOBALS",                 /* 4  */
+  "NX_CUT_BUFFER_SERVER",        /* 5  */
+  "TARGETS",                     /* 6  */
+  "TEXT",                        /* 7  */
+  "NX_AGENT_SIGNATURE",          /* 8  */
+  "NXDARWIN",                    /* 9  */
+  "CLIPBOARD",                   /* 10 */
+  "TIMESTAMP",                   /* 11 */
+  "UTF8_STRING",                 /* 12 */
+  "_NET_WM_STATE",               /* 13 */
+  "_NET_WM_STATE_FULLSCREEN",    /* 14 */
+  NULL,
+  NULL
+};
+
+static XErrorHandler previousErrorHandler = NULL;
+
+static void catchAndRedirect(Display* dpy, XErrorEvent* X)
+{
+  if (X -> error_code == BadAccess &&
+      X -> request_code == X_ChangeWindowAttributes &&
+      X -> resourceid == DefaultRootWindow(dpy))
+  {
+    nxagentWMIsRunning = TRUE;
+  }
+  else
+  {
+    previousErrorHandler(dpy, X);
+  }
+}
+
+static void startWMDetection()
+{
+  /*
+   * We are trying to detect if is there any client
+   * that is listening for 'WM' events on the root
+   * window.
+   */
+
+  nxagentWMIsRunning = FALSE;
+
+  previousErrorHandler = XSetErrorHandler((XErrorHandler)&catchAndRedirect);
+
+  /*
+   * After this request we need to Sync with
+   * the X server to be sure we get any error
+   * that is generated.
+   */
+
+  XSelectInput(nxagentDisplay,
+                   RootWindow (nxagentDisplay, 0),
+                       SubstructureRedirectMask | ResizeRedirectMask | ButtonPressMask);
+}
+
+static void finishWMDetection(Bool verbose)
+{
+  XSetErrorHandler(previousErrorHandler);
+
+  if (nxagentWMIsRunning)
+  {
+    if (verbose == 1)
+    {
+      fprintf(stderr, "Info: Detected window manager running.\n");
+    }
+  }
+  else
+  {
+    if (verbose == 1)
+    {
+      fprintf(stderr, "Info: Not found a window manager running.\n");
+    }
+
+    /*
+     * We are not really interested on root window events.
+     */
+
+    XSelectInput(nxagentDisplay, RootWindow (nxagentDisplay, 0), 0);
+  }
+}
+
+void nxagentWMDetect() 
+{
+  Bool verbose = False;
+  int windowManagerWasRunning = nxagentWMIsRunning;
+
+  startWMDetection();
+
+  XSync(nxagentDisplay, 0);
+
+  if (windowManagerWasRunning != nxagentWMIsRunning)
+  {
+    verbose = False;
+  }
+
+  finishWMDetection(verbose);
+}
+
+int nxagentInitAtoms(WindowPtr pWin)
+{
+  Atom atom;
+
+  /*
+   * Value of nxagentAtoms[8] is "NX_AGENT_SIGNATURE".
+   *
+   * We don't need to save the atom's value. It will
+   * be checked by other agents to find if they are
+   * run nested.
+   */
+
+  atom = MakeAtom(nxagentAtomNames[8], strlen(nxagentAtomNames[8]), 1);
+
+  if (atom == None)
+  {
+    #ifdef PANIC
+    fprintf(stderr, "nxagentInitAtoms: PANIC! Could not create [%s] atom.\n",
+                nxagentAtomNames[8]);
+    #endif
+
+    return -1;
+  }
+
+  return 1;
+}
+
+int nxagentQueryAtoms(ScreenPtr pScreen)
+{
+  int i;
+  static unsigned long atomGeneration = 1;
+
+  int num_of_atoms = NXAGENT_NUMBER_OF_ATOMS;
+  char *names[NXAGENT_NUMBER_OF_ATOMS];
+
+  unsigned long int startingTime = GetTimeInMillis();
+
+  #ifdef TEST
+  fprintf(stderr, "nxagentQueryAtoms: Going to create the intern atoms on real display.\n");
+
+  fprintf(stderr, "nxagentQueryAtoms: Starting time is [%ld].\n", startingTime);
+  #endif
+
+  nxagentPrintAtomMapInfo("nxagentQueryAtoms: Entering");
+
+  for (i = 0; i < num_of_atoms; i++)
+  {
+    names[i] = nxagentAtomNames[i];
+
+    nxagentAtoms[i] = None;
+  }
+
+  if (nxagentSessionId[0])
+  {
+    names[num_of_atoms - 1] = nxagentSessionId;
+  }
+  else
+  {
+    num_of_atoms--;
+  }
+
+  startWMDetection();
+
+  nxagentInitAtomMap(names, num_of_atoms, nxagentAtoms);
+
+  /*
+   * We need to be synchronized with the X server
+   * in order to detect the Window Manager, since
+   * after a reset the XInternAtom could be cached
+   * by Xlib.
+   */
+
+  if (atomGeneration != serverGeneration)
+  {
+    #ifdef WARNING
+    fprintf(stderr, "nxagentQueryAtoms: The nxagent has been reset with server %ld atom %ld.\n",
+                serverGeneration, atomGeneration);
+
+    fprintf(stderr, "nxagentQueryAtoms: Forcing a sync to detect the window manager.\n");
+    #endif
+
+    atomGeneration = serverGeneration;
+
+    XSync(nxagentDisplay, 0);
+  }
+
+  finishWMDetection(False);
+
+  /*
+   * Value of nxagentAtoms[9] is "NXDARWIN".
+   *
+   * We check if it was created by the NX client.
+   */
+
+  if (nxagentAtoms[9] > nxagentAtoms[0])
+  {
+    nxagentAtoms[9] = None;
+  }
+
+  /*
+   * Value of nxagentAtoms[8] is "NX_AGENT_SIGNATURE".
+   *
+   * This atom is created internally by the agent server at
+   * startup to let other agents determine if they are run
+   * nested. If agent is run nested, in fact, at the time it
+   * will create the NX_AGENT_SIGNATURE atom on the real X
+   * server it will find the existing atom with a value less
+   * than any NX_IDENTITY created but itself.
+   */
+
+  if (nxagentAtoms[8] > nxagentAtoms[0])
+  {
+    nxagentAtoms[8] = None;
+  }
+
+  if (nxagentAtoms[8] != None)
+  {
+    /*
+     * We are running nested in another agent
+     * server.
+     */
+
+    nxagentChangeOption(Nested, 1);
+
+    /*
+     * Avoid the image degradation caused by
+     * multiple lossy encoding.
+     */
+
+    fprintf(stderr, "Warning: Disabling use of lossy encoding in nested mode.\n");
+
+    nxagentPackMethod = nxagentPackLossless;
+  }
+
+  #ifdef TEST
+
+  for (i = 0; i < num_of_atoms; i++)
+  {
+    fprintf(stderr, "nxagentQueryAtoms: Created intern atom [%s] with id [%ld].\n",
+                names[i], nxagentAtoms[i]);
+  }
+
+  #endif
+
+  nxagentChangeOption(DisplayLatency, GetTimeInMillis() - startingTime);
+
+  #ifdef TEST
+  fprintf(stderr, "nxagentQueryAtoms: Ending time is [%ld] reference latency is [%d] Ms.\n",
+              GetTimeInMillis(), nxagentOption(DisplayLatency));
+  #endif
+
+  nxagentPrintAtomMapInfo("nxagentQueryAtoms: Exiting");
+
+  return 1;
+}
+
+#define NXAGENT_ATOM_MAP_SIZE_INCREMENT 256
+
+typedef struct {
+    Atom local;
+    Atom remote;
+    char *string;
+    int  length;
+} AtomMap;
+
+static AtomMap *privAtomMap = NULL;
+static unsigned int privAtomMapSize = 0;
+static unsigned int privLastAtom = 0;
+
+static void nxagentExpandCache(void);
+static void nxagentWriteAtom(Atom, Atom, char*, Bool);
+static AtomMap* nxagentFindAtomByRemoteValue(Atom);
+static AtomMap* nxagentFindAtomByLocalValue(Atom);
+static AtomMap* nxagentFindAtomByName(char*, unsigned);
+
+static void nxagentExpandCache(void)
+{
+  privAtomMapSize += NXAGENT_ATOM_MAP_SIZE_INCREMENT;
+
+  privAtomMap = realloc(privAtomMap, privAtomMapSize * sizeof(AtomMap));
+
+  if (privAtomMap == NULL)
+  {
+    FatalError("nxagentExpandCache: realloc failed\n");
+  }
+}
+
+/*
+ * Check if there is space left on the map
+ * and manage the possible consequent allocation,
+ * then cache the atom-couple.
+ */
+
+static void nxagentWriteAtom(Atom local, Atom remote, char *string, Bool duplicate)
+{
+  char *s;
+
+  /*
+   * We could remove this string duplication if
+   * we know for sure that the server will not
+   * reset, since only at reset the dix layer
+   * free all the atom names.
+   */
+
+  if (duplicate)
+  {
+    s = strdup(string);
+
+    #ifdef WARNING
+    if (s == NULL)
+    {
+      fprintf(stderr, "nxagentWriteAtom: Malloc failed.\n");
+    }
+    #endif
+  }
+  else
+  {
+    s = string;
+  }
+
+  if (privLastAtom == privAtomMapSize)
+  {
+    nxagentExpandCache();
+  }
+
+  privAtomMap[privLastAtom].local = local;
+  privAtomMap[privLastAtom].remote = remote;
+  privAtomMap[privLastAtom].string = s;
+  privAtomMap[privLastAtom].length = strlen(s);
+
+  privLastAtom++;
+}
+
+/*
+ * FIXME: We should clean up the atom map
+ * at nxagent reset, in order to cancel 
+ * all the local atoms but still mantaining 
+ * the Xserver values and the atom names.
+ */
+
+void nxagentResetAtomMap()
+{
+  unsigned i;
+
+  nxagentPrintAtomMapInfo("nxagentResetAtomMap: Entering");
+
+  for (i = 0; i < privLastAtom; i++)
+  {
+    privAtomMap[i].local = None;
+  }
+
+  nxagentPrintAtomMapInfo("nxagentResetAtomMap: Exiting");
+}
+
+/*
+ * Init map.
+ * Initializing the atomNameList all in one.
+ */
+
+static int nxagentInitAtomMap(char **atomNameList, int count, Atom *atomsRet)
+{
+  XlibAtom *atom_list;
+  char **name_list;
+  unsigned int i;
+  int ret_value = 0;
+  int list_size = count + privLastAtom;
+
+  nxagentPrintAtomMapInfo("nxagentInitAtomMap: Entering");
+
+  atom_list = malloc((list_size) * sizeof(*atom_list));
+  name_list = malloc((list_size) * sizeof(char*));
+
+  if ((atom_list == NULL) || (name_list == NULL))
+  {
+    FatalError("nxagentInitAtomMap: malloc failed\n");
+  }
+
+  for (i = 0; i < count; i++)
+  {
+    name_list[i] = atomNameList[i];
+    atom_list[i] = None;
+  }
+  
+  for (i = 0; i < privLastAtom; i++)
+  {
+    name_list[count + i] = privAtomMap[i].string;
+    atom_list[count + i] = None;
+  }
+
+  /*
+   * Ask X-Server for ours Atoms
+   * ... if successfull cache them too.
+   */
+
+  ret_value = XInternAtoms(nxagentDisplay, name_list, list_size, False, atom_list);
+
+  if (ret_value == 0)
+  {
+    #ifdef TEST
+    fprintf(stderr, "nxagentInitAtomMap: WARNING! XInternAtoms request failed.\n");
+    #endif
+
+    free(atom_list);
+    free(name_list);
+
+    return 0;
+  }
+
+  for (i = 0; i < list_size; i++)
+  {
+    AtomMap *aMap = nxagentFindAtomByName(name_list[i], strlen(name_list[i]));
+
+    if (aMap == NULL)
+    {
+      Atom local = MakeAtom(name_list[i], strlen(name_list[i]), True);
+
+      if (ValidAtom(local))
+      {
+        nxagentWriteAtom(local, atom_list[i], name_list[i], False);
+      }
+      else
+      {
+        #ifdef WARNING
+        fprintf(stderr, "nxagentInitAtomMap: WARNING MakeAtom failed.\n");
+        #endif
+      }
+    }
+    else
+    {
+      aMap -> remote = atom_list[i];
+
+      if (i < count && aMap -> local == None)
+      {
+        aMap -> local = MakeAtom(name_list[i], strlen(name_list[i]), True);
+      }
+    }
+
+    if (i < count)
+    {
+      atomsRet[i] = atom_list[i];
+    }
+  }
+
+  free(atom_list);
+  free(name_list);
+
+  nxagentPrintAtomMapInfo("nxagentInitAtomMap: Exiting");
+
+  return 1;
+}
+
+/*
+ * If the nxagent has been resetted,
+ * the local value of the atoms stored
+ * in cache could have the value None, 
+ * do not call this function with None.
+ */
+
+static AtomMap* nxagentFindAtomByLocalValue(Atom local)
+{
+  unsigned i;
+
+  if (!ValidAtom(local))
+  {
+    return NULL;
+  }
+
+  for (i = 0; i < privLastAtom; i++)
+  {
+    if (local == privAtomMap[i].local)
+    {
+      return (privAtomMap + i);
+    }
+  }
+
+  return NULL;
+}
+
+static AtomMap* nxagentFindAtomByRemoteValue(Atom remote)
+{
+  unsigned i;
+
+  if (remote == None || remote == BAD_RESOURCE)
+  {
+    return NULL;
+  }
+
+  for (i = 0; i < privLastAtom; i++)
+  {
+    if (remote == privAtomMap[i].remote)
+    {
+      return (privAtomMap + i);
+    }
+  }
+
+  return NULL;
+}
+
+static AtomMap* nxagentFindAtomByName(char *string, unsigned int length)
+{
+  unsigned i;
+
+  for (i = 0; i < privLastAtom; i++)
+  {
+    if ((length == privAtomMap[i].length) && 
+            (strcmp(string, privAtomMap[i].string) == 0))
+    {
+      return (privAtomMap + i);
+    }
+  }
+
+  return NULL;
+}
+
+/*
+ * Convert local atom's name to X-server value.
+ * Reading them from map, if they have been already cached or
+ * really asking to X-server and caching them.
+ * FIXME: I don't really know if is better to allocate
+ *        an automatic variable like ret_value and write it, instead of make all
+ *        these return!, perhaps this way the code is a little bit easyer to read.
+ *        I think this and the 2 .*Find.* are the only functions to look for performances.
+ */
+
+Atom nxagentMakeAtom(char *string, unsigned int length, Bool Makeit)
+{
+  Atom local;
+  AtomMap *current;
+
+  /*
+   * Surely MakeAtom is faster than
+   * our nxagentFindAtomByName.
+   */
+
+  local = MakeAtom(string, length, Makeit);
+
+  if (!ValidAtom(local))
+  {
+    return None;
+  }
+
+  if (local <= XA_LAST_PREDEFINED)
+  {
+    return local;
+  }
+
+  if ((current = nxagentFindAtomByLocalValue(local)))
+  {
+    /*
+     * Found cached by value.
+     */
+
+    return current->remote;
+  }
+
+  if ((current = nxagentFindAtomByName(string, length)))
+  {
+    /*
+     * Found Cached by name.
+     * It means that nxagent has been resetted,
+     * but not the xserver so we still have cached its atoms.
+     */
+
+    current->local = local;
+
+    return current->remote;
+  }
+
+  /*
+   * We really have to ask Xserver for it.
+   */
+
+  {
+    Atom remote;
+
+    remote = XInternAtom(nxagentDisplay, string, !Makeit);
+
+    if (remote == None)
+    {
+      #ifdef WARNING
+      fprintf(stderr, "nxagentMakeAtom: WARNING XInternAtom failed.\n");
+      #endif
+
+      return None;
+    }
+
+    nxagentWriteAtom(local, remote, string, True);
+
+    return remote;
+  }
+}
+
+Atom nxagentLocalToRemoteAtom(Atom local)
+{
+  AtomMap *current;
+  char    *string;
+  Atom    remote;
+
+  if (!ValidAtom(local))
+  {
+    return None;
+  }
+
+  if (local <= XA_LAST_PREDEFINED)
+  {
+    return local;
+  }
+
+  if ((current = nxagentFindAtomByLocalValue(local)))
+  {
+    return current->remote;
+  }
+
+  string = NameForAtom(local);
+
+  remote = XInternAtom(nxagentDisplay, string, False);
+
+  if (remote == None)
+  {
+    #ifdef WARNING
+    fprintf(stderr, "nxagentLocalToRemoteAtom: WARNING XInternAtom failed.\n");
+    #endif
+
+    return None;
+  }
+
+  nxagentWriteAtom(local, remote, string, True);
+
+  return remote;
+}
+
+Atom nxagentRemoteToLocalAtom(Atom remote)
+{
+  AtomMap *current;
+  char    *string;
+  Atom    local;
+
+  if (remote == None || remote == BAD_RESOURCE)
+  {
+    return None;
+  }
+
+  if (remote <= XA_LAST_PREDEFINED)
+  {
+    return remote;
+  }
+
+  if ((current = nxagentFindAtomByRemoteValue(remote)))
+  {
+    if (!ValidAtom(current->local))
+    {
+      local = MakeAtom(current->string, current->length, True);
+
+      if (ValidAtom(local))
+      {
+        current->local = local;
+      }
+      else
+      {
+        #ifdef WARNING
+        fprintf(stderr, "nxagentRemoteToLocalAtom: WARNING MakeAtom failed.\n");
+        #endif
+
+        current->local = None;
+      }
+    }
+
+    return current->local;
+  }
+
+  if ((string = XGetAtomName(nxagentDisplay, remote)))
+  {
+    local = MakeAtom(string, strlen(string), True);
+
+    if (!ValidAtom(local))
+    {
+      #ifdef WARNING
+      fprintf(stderr, "nxagentRemoteToLocalAtom: WARNING MakeAtom failed.\n");
+      #endif
+
+      local = None;
+    }
+
+    nxagentWriteAtom(local, remote, string, True);
+
+    XFree(string);
+
+    return local;
+  }
+
+  #ifdef WARNING
+  fprintf(stderr, "nxagentRemoteToLocalAtom: WARNING failed to get name from remote atom.\n");
+  #endif
+
+  return None;
+}
+
+#ifdef DEBUG
+
+static void nxagentPrintAtomMapInfo(char *message)
+{
+  unsigned i;
+
+  fprintf(stderr, "--------------- Atom map in context [%s] ----------------------\n", message);
+  fprintf(stderr, "nxagentPrintAtomMapInfo: Map at [%p] size [%d] number of entry [%d] auto increment [%d].\n",
+              (void*) privAtomMap, privLastAtom, privAtomMapSize, NXAGENT_ATOM_MAP_SIZE_INCREMENT);
+
+  for (i = 0; i < privLastAtom; i++)
+  {
+    fprintf(stderr, "[%5.1d] local: %6.1lu - remote: %6.1lu - [%p] %s\n", i,
+                privAtomMap[i].local,
+                    privAtomMap[i].remote,
+                        privAtomMap[i].string, validateString(privAtomMap[i].string));
+  }
+
+  fprintf(stderr, "---------------------------------------------\n");
+}
+
+#endif