#include <stdlib.h>
#include <stdio.h>
#include <sys/param.h>
#define NEED_EVENTS
#include <X11/Xlibint.h>
#include <X11/Xos.h>
#include "cslibint.h"
#ifdef XXX
#include <X11/Xauth.h>
#include <X11/Xatom.h>
extern int _Xdebug;
extern Display *_XHeadOfDisplayList;
#ifndef lint
static int lock;
#endif
#endif
#include <X11/X.h>
#include <X11/Xproto.h>
#include "DPSCAPClient.h"
#include <DPS/dpsXclient.h>
#include <DPS/dpsNXargs.h>
#include "dpsassert.h"
#include "dpsNXprops.h"
#include "csfindNX.h"
#include "csstartNX.h"
#ifdef DPSLNKL
#include "dpslnkl.inc"
#endif
#define DPY_NUMBER(dpy) ((dpy)->fd)
static xReq _dummy_request = {
0, 0, 0
};
static void OutOfMemory (Display *);
#ifdef XXX
static int xauth_namelen = 0;
static char *xauth_name = NULL;
static int xauth_datalen = 0;
static char *xauth_data = NULL;
void XSetAuthorization (char *name, int namelen, char *data, int datalen)
{
char *tmpname, *tmpdata;
if (xauth_name) Xfree (xauth_name);
if (xauth_data) Xfree (xauth_data);
xauth_name = xauth_data = NULL;
xauth_namelen = xauth_datalen = 0;
if (namelen < 0) namelen = 0;
if (datalen < 0) datalen = 0;
if (namelen > 0) {
tmpname = Xmalloc ((unsigned) namelen);
if (!tmpname) return;
bcopy (name, tmpname, namelen);
} else {
tmpname = NULL;
}
if (datalen > 0) {
tmpdata = Xmalloc ((unsigned) datalen);
if (!tmpdata) {
if (tmpname) (void) Xfree (tmpname);
return;
}
bcopy (data, tmpdata, datalen);
} else {
tmpdata = NULL;
}
xauth_name = tmpname;
xauth_namelen = namelen;
xauth_data = tmpdata;
xauth_datalen = datalen;
return;
}
#endif
XExtData *
DPSCAPOpenAgent(Display *dpy, char *trueDisplayName)
{
register Display *agent;
char *agentHost = (char *)NULL;
register int i;
char display_name[256];
char licMethBuf[256];
char *licMeth = licMethBuf;
char *fullname = NULL;
int idisplay;
char *server_addr = NULL;
int server_addrlen = 0;
int conn_family;
int transport, port;
XExtData *ext;
DPSCAPData my;
char hostname[MAXHOSTNAMELEN];
#ifdef DPSLNKL
extern unsigned ANXPFunc();
#ifdef PSUSEPN
(void) sprintf(licMeth, "%s%s:%d",
LICENSE_METHOD_PREFIX,
ANXVENDOR,
ANXPFunc());
#else
(void) sprintf(licMeth, "%s%s",
LICENSE_METHOD_PREFIX,
ANXVENDOR);
#endif
#else
licMeth = NULL;
#endif
(void) N_XGetHostname(hostname, MAXHOSTNAMELEN);
switch(XDPSNXFindNX(dpy, licMeth, &agentHost, &transport, &port)) {
case findnx_not_found: {
Bool autoLaunch;
XDPSGetNXArg(XDPSNX_AUTO_LAUNCH, (void **) &autoLaunch);
if (autoLaunch == True) {
int requestedTrans;
int requestedPort = 0;
char **args = NULL;
char *additionalArgs[2];
char transportArg[256];
(void) DPSWarnProc(NULL, "Auto-launching DPS NX agent.");
XDPSGetNXArg(XDPSNX_LAUNCHED_AGENT_TRANS, (void **) &requestedTrans);
if (requestedTrans == XDPSNX_USE_BEST) {
XDPSNXSetClientArg(XDPSNX_LAUNCHED_AGENT_TRANS,
(void *)XDPSNX_TRANS_UNIX);
requestedTrans = XDPSNX_TRANS_UNIX;
}
additionalArgs[1] = (char *) NULL;
additionalArgs[0] = transportArg;
XDPSGetNXArg(XDPSNX_LAUNCHED_AGENT_PORT, (void **) &requestedPort);
if (requestedPort == XDPSNX_USE_BEST) {
requestedPort = XDPSNXRecommendPort(requestedTrans);
if (requestedPort < 0) {
DPSWarnProc(NULL, "Auto-launcher can't get a port.");
return(NULL);
}
}
(void) sprintf(transportArg, "%s/%d",
(requestedTrans == XDPSNX_TRANS_DECNET ?
"dec" : "tcp"),
requestedPort);
args = additionalArgs;
if (StartXDPSNX(args) != Success) {
char tb[256], *fs, **as;
(void) XDPSGetNXArg(XDPSNX_EXEC_FILE, (void **) &fs);
(void) XDPSGetNXArg(XDPSNX_EXEC_ARGS, (void **) &as);
(void) sprintf(tb, "FAILED to auto-launch:\n %s", fs);
if (as != NULL)
for (; *as != NULL; as++) {
if ((int) (strlen(*as) + 1 + (i = strlen(tb))) > 256-1) {
if (i > 256-1-4)
strcpy(&(tb[256-1-1-4]), " ...");
else
strcat(tb, " ...");
break;
}
(void) strcat(tb, " ");
(void) strcat(tb, *as);
}
DPSWarnProc(NULL, tb);
return(NULL);
} else {
(void) sprintf(display_name, "%s%s%d", hostname,
(requestedTrans == XDPSNX_TRANS_DECNET ?
"::" : ":"),
requestedPort);
}
} else {
return(NULL);
}
}
break;
case findnx_found: {
(void) sprintf(display_name, "%s%s%d",
(transport == XDPSNX_TRANS_UNIX ?
"unix" : agentHost),
(transport == XDPSNX_TRANS_DECNET ? "::" : ":"),
port);
}
break;
case findnx_error:
return(NULL);
break;
default:
DPSFatalProc(NULL, "Illegal value returned by XDPSNXFindNX");
break;
}
if ((agent = (Display *)Xcalloc(1, sizeof(Display))) == NULL) {
return(NULL);
}
if ((agent->fd = DPSCAPConnect(display_name, &fullname, &idisplay,
&conn_family,
&server_addrlen, &server_addr)) < 0) {
Xfree ((char *) agent);
return(NULL);
}
#ifdef XXX
if (xauth_name && xauth_data) {
conn_auth_namelen = xauth_namelen;
conn_auth_name = xauth_name;
conn_auth_datalen = xauth_datalen;
conn_auth_data = xauth_data;
} else {
char dpynumbuf[40];
(void) sprintf (dpynumbuf, "%d", idisplay);
authptr = XauGetAuthByAddr ((unsigned short) conn_family,
(unsigned short) server_addrlen,
server_addr,
(unsigned short) strlen (dpynumbuf),
dpynumbuf,
(unsigned short) xauth_namelen,
xauth_name);
if (authptr) {
conn_auth_namelen = authptr->name_length;
conn_auth_name = (char *)authptr->name;
conn_auth_datalen = authptr->data_length;
conn_auth_data = (char *)authptr->data;
} else {
conn_auth_namelen = 0;
conn_auth_name = NULL;
conn_auth_datalen = 0;
conn_auth_data = NULL;
}
}
#ifdef HASDES
if (conn_auth_namelen == 19 &&
!strncmp (conn_auth_name, "XDM-AUTHORIZATION-1", 19))
{
static char encrypted_data[192/8];
int i, j;
struct sockaddr_in in_addr;
int addrlen;
long now;
j = 0;
for (i = 0; i < 8; i++)
{
encrypted_data[j] = conn_auth_data[i];
j++;
}
addrlen = sizeof (in_addr);
getsockname (dpy->fd, (struct sockaddr *) &in_addr, &addrlen);
if (in_addr.sin_family == 2)
{
encrypted_data[j] = in_addr.sin_addr.s_net; j++;
encrypted_data[j] = in_addr.sin_addr.s_host; j++;
encrypted_data[j] = in_addr.sin_addr.s_lh; j++;
encrypted_data[j] = in_addr.sin_addr.s_impno; j++;
encrypted_data[j] = (in_addr.sin_port >> 8) & 0xff; j++;
encrypted_data[j] = (in_addr.sin_port) & 0xff; j++;
}
else
{
encrypted_data[j] = 0xff; j++;
encrypted_data[j] = 0xff; j++;
encrypted_data[j] = 0xff; j++;
encrypted_data[j] = 0xff; j++;
i = getpid ();
encrypted_data[j] = (i >> 8) & 0xff; j++;
encrypted_data[j] = (i) & 0xff; j++;
}
time (&now);
for (i = 3; i >= 0; i--)
{
encrypted_data[j] = (now >> (i * 8)) & 0xff;
j++;
}
XdmcpEncrypt (encrypted_data, conn_auth_data + 8,
encrypted_data, 192/8);
conn_auth_data = encrypted_data;
conn_auth_datalen = 192 / 8;
}
#endif
if (server_addr) (void) Xfree (server_addr);
#endif
agent->lock_meaning = NoSymbol;
#ifdef XXX
agent->current = None;
#endif
agent->event_vec[X_Error] = N_XUnknownWireEvent;
agent->event_vec[X_Reply] = N_XUnknownWireEvent;
agent->wire_vec[X_Error] = N_XUnknownNativeEvent;
agent->wire_vec[X_Reply] = N_XUnknownNativeEvent;
for (i = KeyPress; i < 128; i++) {
agent->event_vec[i] = N_XUnknownWireEvent;
agent->wire_vec[i] = N_XUnknownNativeEvent;
}
agent->cursor_font = None;
agent->last_req = (char *)&_dummy_request;
agent->display_name = fullname;
if ((agent->bufptr = agent->buffer = Xmalloc(BUFSIZE)) == NULL) {
OutOfMemory (dpy);
return(NULL);
}
agent->bufmax = agent->buffer + BUFSIZE;
my = DPSCAPCreate(dpy, agent);
if (my == (DPSCAPData)NULL)
{
OutOfMemory(agent);
return(NULL);
}
ext = (XExtData *)Xcalloc(1, sizeof(XExtData));
ext->private_data = (char *)my;
if (agentHost && strcmp(hostname, agentHost))
{
register char *s, *p;
char *dxname;
char nametmp[MAXHOSTNAMELEN];
dxname = DisplayString(dpy);
for (s = dxname, p = nametmp; *s; ++s)
if (*s == ':')
break;
else
*p++ = *s;
*p = '\0';
if (nametmp[0] == '\0'
|| !strcmp(nametmp, "unix")
|| !strcmp(nametmp, "localhost"))
{
strcpy(trueDisplayName, hostname);
if (*s)
strcat(trueDisplayName, s);
else
strcat(trueDisplayName, ":0.0");
}
else
strcpy(trueDisplayName, dxname);
}
else
strcpy(trueDisplayName, DisplayString(dpy));
if (agentHost)
Xfree(agentHost);
return(ext);
}
static void OutOfMemory (Display *dpy)
{
DPSCAPCloseAgent(dpy);
}
#ifdef NEEDFORNX
static void
_XFreeDisplayStructure(register Display *dpy)
{
if (dpy->screens) {
register int i;
for (i = 0; i < dpy->nscreens; i++) {
Screen *sp = &dpy->screens[i];
if (sp->depths) {
register int j;
for (j = 0; j < sp->ndepths; j++) {
Depth *dp = &sp->depths[j];
if (dp->visuals) {
register int k;
for (k = 0; k < dp->nvisuals; k++)
_XFreeExtData (dp->visuals[k].ext_data);
Xfree ((char *) dp->visuals);
}
}
Xfree ((char *) sp->depths);
}
_XFreeExtData (sp->ext_data);
}
Xfree ((char *)dpy->screens);
}
if (dpy->pixmap_format) {
register int i;
for (i = 0; i < dpy->nformats; i++)
_XFreeExtData (dpy->pixmap_format[i].ext_data);
Xfree ((char *)dpy->pixmap_format);
}
if (dpy->display_name)
Xfree (dpy->display_name);
if (dpy->vendor)
Xfree (dpy->vendor);
if (dpy->buffer)
Xfree (dpy->buffer);
if (dpy->atoms)
Xfree ((char *) dpy->atoms);
if (dpy->keysyms)
Xfree ((char *) dpy->keysyms);
if (dpy->modifiermap)
XFreeModifiermap(dpy->modifiermap);
if (dpy->xdefaults)
Xfree (dpy->xdefaults);
if (dpy->key_bindings)
_XFreeKeyBindings(dpy);
while (dpy->ext_procs) {
_XExtension *ext = dpy->ext_procs;
dpy->ext_procs = ext->next;
if (ext->name)
Xfree (ext->name);
Xfree ((char *)ext);
}
_XFreeExtData (dpy->ext_data);
Xfree ((char *)dpy);
}
#endif
void
DPSCAPCloseAgent(Display *agent)
{
if (!agent) return;
N_XDisconnectDisplay(agent->fd);
if (agent->display_name)
Xfree(agent->display_name);
if (agent->buffer)
Xfree(agent->buffer);
Xfree((char *)agent);
}