aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/dps/csfindNX.c
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/lib/dps/csfindNX.c
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/lib/dps/csfindNX.c')
-rw-r--r--nx-X11/lib/dps/csfindNX.c657
1 files changed, 657 insertions, 0 deletions
diff --git a/nx-X11/lib/dps/csfindNX.c b/nx-X11/lib/dps/csfindNX.c
new file mode 100644
index 000000000..63b40acbc
--- /dev/null
+++ b/nx-X11/lib/dps/csfindNX.c
@@ -0,0 +1,657 @@
+/*
+ * csfindNX.c -- DPSCAP client Xlib extension hookup
+ *
+ * (c) Copyright 1992-1994 Adobe Systems Incorporated.
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sublicense this software
+ * and its documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notices appear in all copies and that
+ * both those copyright notices and this permission notice appear in
+ * supporting documentation and that the name of Adobe Systems Incorporated
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission. No trademark license
+ * to use the Adobe trademarks is hereby granted. If the Adobe trademark
+ * "Display PostScript"(tm) is used to describe this software, its
+ * functionality or for any other purpose, such use shall be limited to a
+ * statement that this software works in conjunction with the Display
+ * PostScript system. Proper trademark attribution to reflect Adobe's
+ * ownership of the trademark shall be given whenever any such reference to
+ * the Display PostScript system is made.
+ *
+ * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
+ * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
+ * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE
+ * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT
+ * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
+ *
+ * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
+ * Incorporated which may be registered in certain jurisdictions
+ *
+ * Author: Adobe Systems Incorporated
+ */
+/* $XFree86: xc/lib/dps/csfindNX.c,v 1.7tsi Exp $ */
+
+#include <sys/param.h> /* for MAXHOSTNAMELEN */
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h> /* getuid() */
+#include <string.h>
+#include <pwd.h>
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xlibint.h>
+#include <X11/Xatom.h>
+#include <X11/Xresource.h>
+
+#include "csfindNX.h"
+#include "dpsNXprops.h"
+#include "Xlibnet.h"
+#include "DPS/dpsXclient.h"
+#include "DPS/dpsNXargs.h"
+#include <DPS/XDPSlib.h>
+
+#include "dpsassert.h"
+#include "cslibint.h"
+
+/* ---Defines--- */
+
+#define CANTSTARTAGENT "Unable to start agent.\n"
+
+/* ---Types--- */
+
+typedef struct {
+ Window id;
+ int willingness;
+} Agent, *AgentIdList;
+
+/* ---Globals--- */
+
+static char *XDPSLNXHost = NULL;
+static int XDPSLNXPort = 0; /* default port to be used */
+static int XDPSLNXTrans = XDPSNX_TRANS_UNIX;
+static int gXDPSNXLaunchedAgentTrans = XDPSNX_USE_BEST;
+static int gXDPSNXLaunchedAgentPort = XDPSNX_USE_BEST;
+static char *gXDPSNXExecObj = XDPSNX_DEFAULT_EXEC_NAME; /* NX object file */
+static char **gXDPSNXExecArgs = NULL; /* the args for gXDPSNXExecObj */
+static Bool gWasAgentSet = False;
+static Bool gXDPSNXAutoLaunch = False;
+unsigned char gXDPSNXErrorCode;
+extern int gNXSndBufSize; /* Output buffer size, zero means default */
+
+static char *getHomeDir(char *);
+
+/* ---Private Functions--- */
+
+static int
+TmpErrorHandler(
+ Display *dpy,
+ XErrorEvent *err)
+{
+ gXDPSNXErrorCode = err->error_code;
+ return 0;
+}
+
+
+static int
+GetProperty(
+ Display *dpy,
+ Window w,
+ Atom prop,
+ Atom type,
+ unsigned long *nitems, /* IN: if non-null then RETURN val */
+ char **data) /* RETURN */
+{
+ long largest_len = ((((unsigned long) -1) >> 1) / 4);
+ Atom actual_type;
+ int actual_format;
+ unsigned long actual_number;
+ unsigned long remaining;
+
+ if (type == None) return(!Success); /* We need to have a type */
+ if ((XGetWindowProperty(dpy, w, prop, 0, largest_len, False, type,
+ &actual_type, &actual_format, &actual_number,
+ &remaining, (unsigned char **) data) == Success)
+ && (actual_type == type)) {
+ if (nitems != NULL) *nitems = actual_number;
+ return(Success);
+ } else {
+ if (*nitems != 0) { /* if data returned, clean up */
+ XFree(*data);
+ *data = NULL; /* is this necessary? */
+ *nitems = 0;
+ }
+ return(!Success);
+ }
+}
+
+
+/*
+ GetAgentIdList returns a list of agents advertising on the passed display (dpy),
+ and it returns the number of agents in the list in the parameter nAgents.
+ The returned list is sorted in most to least willing order.
+ GetAgentIdList assumes that it has exclusive access to the server associated with
+ dpy (ie. it assumes that the caller has done an XGrabServer).
+ */
+static AgentIdList
+GetAgentIdList(
+ Display *dpy,
+ unsigned long *nAgents) /* RETURN: number of agents in list */
+{
+ Atom serverListAtom = XInternAtom(dpy, XDPSNX_BILLBOARD_PROP, True);
+ Window *agents = NULL;
+ AgentIdList agentList = NULL;
+ int (*oldErrorHandler)(Display *, XErrorEvent *) = 0; /* the current error handler */
+ unsigned long i, current;
+
+ if (serverListAtom == None) { /* Servers registered on dpy */
+ goto failed;
+ }
+
+ XSync(dpy, False); /* force processing of pending requests */
+
+ if (GetProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+ serverListAtom, XA_WINDOW, nAgents,
+ (char **) &agents) != Success) {
+ goto failed;
+ }
+
+ if ((agentList = (AgentIdList)
+ Xcalloc(*nAgents, (unsigned) sizeof(Agent))) == NULL)
+ goto failed;
+
+ /* let's go through the list and figure out which servers are okay */
+ oldErrorHandler = XSetErrorHandler(TmpErrorHandler);
+ current = 0;
+ for (i=0; i < *nAgents; i++) {
+ unsigned long len;
+ int *agentWillingness;
+ unsigned long k;
+
+ for (k=0; k < i; k++) /* Search for duplicate ids */
+ if (agents[i] == agents[k]) { /* uh oh... */
+ agents[i] = None;
+ break;
+ }
+ if (k == i) { /* No duplicate ids */
+ if (GetProperty(dpy, agents[i],
+ XInternAtom(dpy, XDPSNX_WILLINGNESS_PROP, True),
+ XA_INTEGER, &len, (char **) &agentWillingness)
+ != Success) {
+ /* Assume that Agent i is dead... */
+ /* reap the agent */
+ agents[i] = None;
+ gXDPSNXErrorCode = None;
+ } else {
+ unsigned long j = 0;
+
+ /* insert the agents into agentList in "most to least willing" order */
+ while ((j < current) && (agentList[j].willingness > *agentWillingness))
+ j++;
+ if (j < current)
+ (void) bcopy((char *) &agentList[j], (char *) &agentList[j+1],
+ sizeof(Agent) * (*nAgents - j - 1));
+ agents[current] = agents[i];
+ agentList[j].id = agents[current++];
+ agentList[j].willingness = *agentWillingness;
+ XFree(agentWillingness);
+ }
+ }
+ }
+ (void) XSetErrorHandler(oldErrorHandler);
+ oldErrorHandler = NULL;
+ if (*nAgents != current) { /* agent list changed */
+ if (current > 0) { /* are there living ones? */
+ *nAgents = current;
+ /* write the list back out onto the root window */
+ (void) XChangeProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+ serverListAtom, XA_WINDOW, 32,
+ PropModeReplace, (unsigned char *) agents, *nAgents);
+ } else {
+ (void) XDeleteProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+ serverListAtom);
+ goto failed;
+ }
+ }
+ (void) XFree(agents);
+ return(agentList);
+
+ failed:
+ if (agents != NULL) XFree(agents);
+ if (agentList != NULL) XFree(agentList);
+ if (oldErrorHandler != NULL) (void) XSetErrorHandler(oldErrorHandler);
+ *nAgents = 0;
+ return(NULL);
+}
+
+
+static int
+XDPSNXOnDisplay(
+ Display *dpy,
+ char *licenseMethod,
+ char **host,
+ int *transport,
+ int *port)
+{
+ unsigned long nAgents = 0;
+ AgentIdList agentList = NULL;
+ Bool match = False;
+ unsigned long i = 0;
+ int status = !Success;
+
+#ifdef DPSLNKL
+ extern unsigned ANXKFunc();
+#endif /* DPSLNKL */
+
+ (void) XGrabServer(dpy); /* Can we do this later? */
+ if ((agentList = GetAgentIdList(dpy, &nAgents)) == NULL)
+ goto cleanup;
+ /* NOTE: agentList was sorted most to least willing by GetAgentIdList */
+ if (agentList[i].willingness <= 0) { /* Is there a willing agent? */
+ DPSWarnProc(NULL, "Found agent(s) for display, but none willing to accept connections.\n");
+ goto cleanup;
+ }
+
+#ifdef DPSLNKL
+ /* Masterkey bypass code */
+ if (ANXKFunc() != 0) {
+ /* We have a willing agent and the client has masterkeys so... */
+ match = True;
+ } else /* Search for appropriate agent */
+#endif /* DPSLNKL */
+ {
+ /* need to get licensing info from dpy */
+ Atom desiredLicenseMethod, openLicenseMethod;
+ char openLicenseString[256];
+
+ (void) sprintf(openLicenseString, "%s:%d",
+ LICENSE_METHOD_OPEN,
+ OPEN_LICENSE_VERSION);
+ openLicenseMethod = XInternAtom(dpy, openLicenseString, True);
+
+ if (licenseMethod != NULL)
+ desiredLicenseMethod = XInternAtom(dpy, licenseMethod, True);
+ else
+ desiredLicenseMethod = None;
+
+ if ((desiredLicenseMethod != None) || (openLicenseMethod != None)) {
+ for (i=0;
+ (i < nAgents) && (agentList[i].willingness > 0) && (match == False);
+ i++) {
+ Atom *licenseMethods = NULL;
+ unsigned long nMethods;
+ unsigned long j;
+
+ if (GetProperty(dpy, agentList[i].id,
+ XInternAtom(dpy, XDPSNX_LICENSE_METHOD_PROP, True),
+ XA_ATOM,
+ &nMethods, (char **) &licenseMethods) != Success)
+ goto cleanup;
+
+ /*
+ Check to see if the agent supports either our desired license method or
+ if it is an open service.
+ */
+ j = 0;
+ while((j < nMethods)
+ && (licenseMethods[j] != desiredLicenseMethod)
+ && (licenseMethods[j] != openLicenseMethod)) j++;
+ if (j < nMethods) { /* We found one */
+ match = True;
+ break;
+ }
+ (void) XFree(licenseMethods);
+ }
+ }
+ }
+
+ if (match) { /* We had a match on license method */
+ TransportInfo *transInfo;
+
+ if (GetProperty(dpy, agentList[i].id,
+ XInternAtom(dpy, XDPSNX_TRANSPORT_INFO_PROP, True),
+ XA_INTEGER, NULL, (char **) &transInfo) != Success) {
+ goto cleanup;
+ } else { /* We got one! */
+ *transport = transInfo->transport;
+ *port = transInfo->port;
+ match = True;
+ XFree(transInfo);
+ }
+ if (GetProperty(dpy, agentList[i].id,
+ XInternAtom(dpy, XDPSNX_HOST_NAME_PROP, True), XA_STRING,
+ NULL, (char **) host) == Success) {
+ status = Success;
+ /*
+ * If transport is TCP, but we are on the same host as the agent then
+ * trade-up to the more efficient UNIX transport...
+ */
+ if (*transport == XDPSNX_TRANS_TCP) {
+ char hostname[MAXHOSTNAMELEN];
+ (void) N_XGetHostname(hostname, MAXHOSTNAMELEN);
+ if (strcmp(hostname, *host) == 0)
+ *transport = XDPSNX_TRANS_UNIX;
+ }
+ }
+ }
+ /*
+ * Exit Clauses: status inited to FAILURE. Therefore cleanup "assumes"
+ * a failure unless noted otherwise.
+ */
+ cleanup:
+ (void) XUngrabServer(dpy);
+ (void) XDPSLFlush(dpy); /* Flush the ungrab */
+ if (agentList != NULL) XFree(agentList);
+ return(status);
+}
+
+
+static int
+ParseAgentString(
+ char *string,
+ char **hostname, /* RETURN */
+ int *transport, /* RETURN */
+ int *port) /* RETURN */
+{
+ int dnet = 0;
+ Bool transportSpecified = False;
+ char namebuf[255];
+ char *p;
+
+ (void) strncpy(namebuf, string, strlen(string)+1);
+ p = &namebuf[0];
+ /*
+ * Step 1, find the hostname. This is delimited by a required colon.
+ */
+ for (; *p && *p != ':'; p++);
+ if (!*p) return(!Success); /* There must be a colon */
+
+ if (*(p+1) == ':') {
+ dnet++;
+ *(p++) = '\0';
+ }
+ *(p++) = '\0';
+
+ /*
+ * Step 2, get the port number. It follows the colon(s)
+ */
+ if (*p == '\0') /* No port number specified... */
+ return(!Success);
+
+ *port = atoi(p);
+
+ /*
+ * Step 3, transport?
+ */
+ if (namebuf[0] == '\0') { /* no transport/hostname specified... */
+ if (dnet)
+ (void) strcpy(namebuf, "0");
+ else { /* no hostname, so must be UNIX */
+ *hostname = NULL;
+ *transport = XDPSNX_TRANS_UNIX;
+ return(Success);
+ }
+ } else {
+ /* find the delimiting '/' */
+ for (p = &namebuf[0]; *p && *p != '/'; p++);
+ if (*p == '/') {
+ transportSpecified = True;
+ *p = '\0';
+ p++;
+ } else /* no transport specified */
+ p = &namebuf[0];
+ if ((*hostname = (char *) Xmalloc(strlen(p))) == NULL)
+ return(!Success); /* can't alloc space for hostname */
+ (void) strcpy(*hostname, p);
+
+ /* identify protocol */
+ if (dnet)
+ *transport = XDPSNX_TRANS_DECNET;
+ else if (transportSpecified) {
+ if (strcmp(namebuf, "unix") == 0)
+ *transport = XDPSNX_TRANS_UNIX;
+ else /* assume tcp */
+ *transport = XDPSNX_TRANS_TCP;
+ } else
+ *transport = XDPSNX_TRANS_TCP;
+ }
+ return(Success);
+}
+
+static int
+FindXDPSNXInXrmDatabase(
+ Display *dpy,
+ char **host,
+ int *transport,
+ int *port)
+{
+ XrmDatabase rDB = NULL; /* for merged database */
+ XrmDatabase serverDB;
+ char filenamebuf[1024];
+ char *filename = &filenamebuf[0];
+ char *env, *str_type;
+ char name[255];
+ XrmValue value;
+ int retVal = !Success;
+
+ XrmInitialize();
+ (void) strcpy(name, "/usr/lib/X11/app-defaults/");
+ (void) strcat(name, XDPSNX_X_CLASS_NAME);
+
+ /* try to get application defaults file, if there is any */
+ XrmMergeDatabases(XrmGetFileDatabase(name), &rDB);
+
+ /* try to merge the server defaults. if not defined then use .Xdefaults */
+ if (XResourceManagerString(dpy) != NULL) {
+ serverDB = XrmGetStringDatabase(XResourceManagerString(dpy));
+ } else { /* use the .Xdefaults */
+ (void) getHomeDir(filename);
+ (void) strcat(filename, "/.Xdefaults");
+
+ serverDB = XrmGetFileDatabase(filename);
+ }
+ XrmMergeDatabases(serverDB, &rDB);
+
+ /* try the XENVIRONMENT file, or if not defined, then .Xdefaults */
+ if ((env = getenv("XENVIRONMENT")) == NULL) {
+ int len;
+ env = getHomeDir(filename);
+ (void) strcat(filename, "/.Xdefaults-");
+ len = strlen(env);
+ (void) gethostname(env+len, 1024-len);
+ }
+ XrmMergeDatabases(XrmGetFileDatabase(env), &rDB);
+
+ /* Now that the database is built, try to extract the values we want. */
+
+ if (XrmGetResource(rDB, XDPSNX_X_RESOURCE, XDPSNX_X_CLASS_NAME, &str_type,
+ &value) == True) {
+ retVal = ParseAgentString((char *) value.addr, host, transport, port);
+ }
+ (void) XrmDestroyDatabase(rDB);
+ return(retVal);
+}
+
+
+static char *
+getHomeDir(char *dest)
+{
+ register char *ptr;
+
+ if ((ptr = getenv("HOME")) != NULL) {
+ (void) strcpy(dest, ptr);
+ } else {
+ struct passwd *pw;
+
+ if ((ptr = getenv("USER")) != NULL) {
+ pw = getpwnam(ptr);
+ } else {
+ pw = getpwuid(getuid());
+ }
+ if (pw) {
+ (void) strcpy(dest, pw->pw_dir);
+ } else {
+ *dest = ' ';
+ }
+ }
+ return (dest);
+}
+
+
+
+/* ---Public Functions--- */
+
+int gForceLaunchHack = 0; /* Undocumented way to force autolaunch */
+
+XDPSNXFindNXResult
+XDPSNXFindNX(
+ Display *dpy,
+ char *licenseMethod,
+ char **host,
+ int *transport,
+ int *port)
+{
+ char *agentenv;
+
+ if (gForceLaunchHack)
+ return(findnx_not_found);
+
+ if (gWasAgentSet) { /* check if client set up host */
+ *host = XDPSLNXHost;
+ *transport = XDPSLNXTrans;
+ *port = XDPSLNXPort;
+ return(findnx_found);
+ /* check DPSNXHOST environment variable */
+ } else if ((agentenv = getenv(AGENT_ENV_VAR)) != NULL) {
+ int status = ParseAgentString(agentenv, host, transport, port);
+ if (status != Success) {
+ DPSWarnProc((DPSContext) NULL, "Illegal syntax for DPSNXHOST");
+ return(findnx_error);
+ } else return(findnx_found);
+ /* check advertisements... */
+ } else if (XDPSNXOnDisplay(dpy, licenseMethod, host, transport, port) ==
+ Success) {
+ return(findnx_found);
+ /* check XrmDatabase */
+ } else if (FindXDPSNXInXrmDatabase(dpy, host, transport, port) == Success) {
+ return(findnx_found);
+ }
+ /* Nada */
+ return(findnx_not_found);
+}
+
+
+Status
+XDPSNXSetClientArg(int arg, void *value)
+{
+ Display *dpy;
+
+ if (arg == XDPSNX_AGENT) {
+ gWasAgentSet = True;
+ return(ParseAgentString(value,
+ &XDPSLNXHost, &XDPSLNXTrans, &XDPSLNXPort));
+ }
+ else if (arg == XDPSNX_EXEC_FILE) {
+ if ((gXDPSNXExecObj = Xmalloc(strlen((char *) value) + 1)) == NULL) {
+ return(!Success);
+ }
+ gXDPSNXExecObj = strcpy(gXDPSNXExecObj, (char *) value);
+ } else if (arg == XDPSNX_EXEC_ARGS) {
+ int i;
+ char **cpp, **execInfo;
+
+ execInfo = (char **) value;
+ for(cpp = execInfo, i = 1; *cpp != NULL; i++, cpp++); /* count */
+ gXDPSNXExecArgs = (char **) Xcalloc(i, sizeof(char *));
+ if (gXDPSNXExecArgs == NULL) return(!Success);
+ for(cpp = gXDPSNXExecArgs; *execInfo != NULL;
+ execInfo++, cpp++) {
+ /* copy each entry */
+ if ((*cpp = Xmalloc(strlen(*execInfo) + 1)) == NULL)
+ return(!Success);
+ *cpp = strcpy(*cpp, *execInfo);
+ }
+ } else if (arg == XDPSNX_AUTO_LAUNCH) {
+ gXDPSNXAutoLaunch = (Bool)(long) value;
+ } else if (arg == XDPSNX_LAUNCHED_AGENT_TRANS) {
+ gXDPSNXLaunchedAgentTrans = (long) value;
+ } else if (arg == XDPSNX_LAUNCHED_AGENT_PORT) {
+ gXDPSNXLaunchedAgentPort = (long) value;
+ } else if (arg == XDPSNX_REQUEST_XSYNC) {
+ dpy = (Display *) value;
+ if (dpy == (Display *)NULL)
+ return(Success);
+ XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_SYNC);
+ } else if (arg == XDPSNX_REQUEST_RECONCILE) {
+ dpy = (Display *) value;
+ if (dpy == (Display *)NULL)
+ return(Success);
+ XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_RECONCILE);
+ } else if (arg == XDPSNX_REQUEST_BUFFER) {
+ dpy = (Display *) value;
+ if (dpy == (Display *)NULL)
+ return(Success);
+ XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_BUFFER);
+ } else if (arg == XDPSNX_GC_UPDATES_SLOW) {
+ dpy = (Display *) value;
+ if (dpy == (Display *)NULL)
+ return(Success);
+ XDPSLSetGCFlushMode(dpy, XDPSNX_GC_UPDATES_SLOW);
+ } else if (arg == XDPSNX_GC_UPDATES_FAST) {
+ dpy = (Display *) value;
+ if (dpy == (Display *)NULL)
+ return(Success);
+ XDPSLSetGCFlushMode(dpy, XDPSNX_GC_UPDATES_FAST);
+ } else if (arg == XDPSNX_SEND_BUF_SIZE) {
+ int i = (long)value;
+ if (i >= 4096 && i <= 65536) gNXSndBufSize = i;
+ }
+ return(Success);
+}
+
+
+void
+XDPSGetNXArg(int arg, void **value)
+{
+ static char agentBuffer[255];
+
+ if (arg == XDPSNX_AGENT) {
+ switch(XDPSLNXTrans) {
+ case XDPSNX_TRANS_UNIX:
+ (void) sprintf(agentBuffer, "unix/");
+ break;
+ case XDPSNX_TRANS_TCP:
+ (void) sprintf(agentBuffer, "tcp/");
+ break;
+ case XDPSNX_TRANS_DECNET:
+ (void) sprintf(agentBuffer, "decnet/");
+ break;
+ default:
+ DPSWarnProc(NULL, "Unknown transport passed to XDPSGetNXArg ignored.\n");
+ agentBuffer[0] = '\0';
+ break;
+ }
+ (void) strcat(agentBuffer, XDPSLNXHost);
+ (void) strcat(agentBuffer,
+ (XDPSLNXTrans == XDPSNX_TRANS_DECNET ? "::" : ":"));
+ (void) sprintf(&agentBuffer[strlen(agentBuffer)], "%d", XDPSLNXPort);
+ *value = (void *) agentBuffer;
+ }
+ else if (arg == XDPSNX_EXEC_FILE) {
+ *value = (void *) gXDPSNXExecObj;
+ } else if (arg == XDPSNX_EXEC_ARGS) {
+ *value = (void *) gXDPSNXExecArgs;
+ } else if (arg == XDPSNX_AUTO_LAUNCH) {
+ *value = (void *) (long)gXDPSNXAutoLaunch;
+ } else if (arg == XDPSNX_LAUNCHED_AGENT_TRANS) {
+ *value = (void *) (long)gXDPSNXLaunchedAgentTrans;
+ } else if (arg == XDPSNX_LAUNCHED_AGENT_PORT) {
+ *value = (void *) (long)gXDPSNXLaunchedAgentPort;
+ }
+}