diff options
Diffstat (limited to 'nx-X11/programs/Xserver/hw/nxagent/Atoms.c')
| -rw-r--r-- | nx-X11/programs/Xserver/hw/nxagent/Atoms.c | 788 |
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 |