#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif
#include "dmx.h"
#include "dmxprop.h"
#include "dmxlog.h"
#define DMX_ATOMNAME "DMX_NAME"
#define DMX_IDENT "Xdmx"
extern char *display;
static int dmxPropertyErrorHandler(Display *dpy, XErrorEvent *ev)
{
return 0;
}
static const unsigned char *dmxPropertyIdentifier(void)
{
char hostname[256];
static char buf[128];
static int initialized = 0;
if (initialized++) return (unsigned char *)buf;
XmuGetHostname(hostname, sizeof(hostname));
XmuSnprintf(buf, sizeof(buf), "%s:%s:%s", DMX_IDENT, hostname, display);
return (unsigned char *)buf;
}
void *dmxPropertyIterate(DMXScreenInfo *start,
void *(*f)(DMXScreenInfo *dmxScreen, void *),
void *closure)
{
DMXScreenInfo *pt;
if (!start->next) {
if (!start->beDisplay) return NULL;
return f(start, closure);
}
for (pt = start->next; ; pt = pt->next) {
void *retval;
dmxLog(dmxDebug, "pt = %p\n", pt);
dmxLog(dmxDebug, "pt->beDisplay = %p\n", pt->beDisplay);
if (pt->beDisplay && (retval = f(pt, closure))) return retval;
if (pt == start) break;
}
return NULL;
}
static int dmxPropertyCheckOtherServers(DMXScreenInfo *dmxScreen, Atom atom)
{
Display *dpy = dmxScreen->beDisplay;
XTextProperty tp;
XTextProperty tproot;
const char *pt;
int retcode = 0;
char **list = NULL;
int count = 0;
int i;
int (*dmxOldHandler)(Display *, XErrorEvent *);
if (!dpy)
return 0;
if (!XGetTextProperty(dpy, RootWindow(dpy,0), &tproot, atom)
|| !tproot.nitems) return 0;
dmxOldHandler = XSetErrorHandler(dmxPropertyErrorHandler);
for (pt = (const char *)tproot.value; pt && *pt; pt = pt ? pt + 1 : NULL) {
if ((pt = strchr(pt, ','))) {
Window win = strtol(pt+1, NULL, 10);
if (XGetTextProperty(dpy, win, &tp, atom) && tp.nitems) {
if (!strncmp((char *)tp.value, DMX_IDENT, strlen(DMX_IDENT))) {
int flag = 0;
for (i = 0; i < count; i++)
if (!strcmp(list[i], (char *)tp.value)) {
++flag;
break;
}
if (flag) continue;
++retcode;
dmxLogOutputWarning(dmxScreen,
"%s also running on %s\n",
tp.value, dmxScreen->name);
list = realloc(list, ++count * sizeof(*list));
list[count-1] = malloc(tp.nitems + 2);
strncpy(list[count-1], (char *)tp.value, tp.nitems + 1);
}
XFree(tp.value);
}
}
}
XSetErrorHandler(dmxOldHandler);
for (i = 0; i < count; i++) free(list[i]);
free(list);
XFree(tproot.value);
if (!retcode)
dmxLogOutput(dmxScreen, "No Xdmx server running on backend\n");
return retcode;
}
static DMXScreenInfo *dmxPropertyCheckOtherWindows(DMXScreenInfo *dmxScreen,
Atom atom)
{
Display *dpy = dmxScreen->beDisplay;
const unsigned char *id = dmxPropertyIdentifier();
XTextProperty tproot;
XTextProperty tp;
const char *pt;
int (*dmxOldHandler)(Display *, XErrorEvent *);
if (!dpy)
return NULL;
if (!XGetTextProperty(dpy, RootWindow(dpy,0), &tproot, atom)
|| !tproot.nitems) return 0;
dmxOldHandler = XSetErrorHandler(dmxPropertyErrorHandler);
for (pt = (const char *)tproot.value; pt && *pt; pt = pt ? pt + 1 : NULL) {
if ((pt = strchr(pt, ','))) {
Window win = strtol(pt+1, NULL, 10);
if (XGetTextProperty(dpy, win, &tp, atom) && tp.nitems) {
dmxLog(dmxDebug,"On %s/%lu: %s\n",
dmxScreen->name, win, tp.value);
if (!strncmp((char *)tp.value, (char *)id,
strlen((char *)id))) {
int idx;
if (!(pt = strchr((char *)tp.value, ','))) continue;
idx = strtol(pt+1, NULL, 10);
if (idx < 0 || idx >= dmxNumScreens) continue;
if (dmxScreens[idx].scrnWin != win) continue;
XSetErrorHandler(dmxOldHandler);
return &dmxScreens[idx];
}
XFree(tp.value);
}
}
}
XSetErrorHandler(dmxOldHandler);
XFree(tproot.value);
return 0;
}
int dmxPropertyDisplay(DMXScreenInfo *dmxScreen)
{
Atom atom;
const unsigned char *id = dmxPropertyIdentifier();
Display *dpy = dmxScreen->beDisplay;
if (!dpy)
return 0;
atom = XInternAtom(dpy, DMX_ATOMNAME, False);
if (dmxPropertyCheckOtherServers(dmxScreen, atom)) {
dmxScreen->shared = 1;
return 1;
}
XChangeProperty(dpy, RootWindow(dpy,0), atom, XA_STRING, 8,
PropModeReplace, id, strlen((char *)id));
return 0;
}
int dmxPropertySameDisplay(DMXScreenInfo *dmxScreen, const char *name)
{
Display *dpy0 = dmxScreen->beDisplay;
Atom atom0;
XTextProperty tp0;
Display *dpy1 = NULL;
Atom atom1;
XTextProperty tp1;
int retval = 0;
if (!dpy0)
return 0;
tp0.nitems = 0;
tp1.nitems = 0;
if ((atom0 = XInternAtom(dpy0, DMX_ATOMNAME, True)) == None) {
dmxLog(dmxWarning, "No atom on %s\n", dmxScreen->name);
return 0;
}
if (!XGetTextProperty(dpy0, RootWindow(dpy0,0), &tp0, atom0)
|| !tp0.nitems) {
dmxLog(dmxWarning, "No text property on %s\n", dmxScreen->name);
return 0;
}
if (!(dpy1 = XOpenDisplay(name))) {
dmxLog(dmxWarning, "Cannot open %s\n", name);
goto cleanup;
}
atom1 = XInternAtom(dpy1, DMX_ATOMNAME, True);
if (atom1 == None) {
dmxLog(dmxDebug, "No atom on %s\n", name);
goto cleanup;
}
if (!XGetTextProperty(dpy1, RootWindow(dpy1,0), &tp1, atom1)
|| !tp1.nitems) {
dmxLog(dmxDebug, "No text property on %s\n", name);
goto cleanup;
}
if (!strcmp((char *)tp0.value, (char *)tp1.value)) retval = 1;
cleanup:
if (tp0.nitems) XFree(tp0.value);
if (tp1.nitems) XFree(tp1.value);
if (dpy1) XCloseDisplay(dpy1);
return retval;
}
void dmxPropertyWindow(DMXScreenInfo *dmxScreen)
{
Atom atom;
const unsigned char *id = dmxPropertyIdentifier();
Display *dpy = dmxScreen->beDisplay;
Window win = dmxScreen->scrnWin;
DMXScreenInfo *other;
char buf[128];
if (!dpy)
return;
atom = XInternAtom(dpy, DMX_ATOMNAME, False);
if ((other = dmxPropertyCheckOtherWindows(dmxScreen, atom))) {
DMXScreenInfo *tmp = dmxScreen->next;
dmxScreen->next = (other->next ? other->next : other);
other->next = (tmp ? tmp : dmxScreen);
dmxLog(dmxDebug, "%d/%s/%lu and %d/%s/%lu are on the same backend\n",
dmxScreen->index, dmxScreen->name, dmxScreen->scrnWin,
other->index, other->name, other->scrnWin);
}
XmuSnprintf(buf, sizeof(buf), ".%d,%lu", dmxScreen->index,
(long unsigned)win);
XChangeProperty(dpy, RootWindow(dpy,0), atom, XA_STRING, 8,
PropModeAppend, (unsigned char *)buf, strlen(buf));
XmuSnprintf(buf, sizeof(buf), "%s,%d", id, dmxScreen->index);
XChangeProperty(dpy, win, atom, XA_STRING, 8,
PropModeAppend, (unsigned char *)buf, strlen(buf));
}