753 lines
21 KiB
C
753 lines
21 KiB
C
/*
|
|
* CDE - Common Desktop Environment
|
|
*
|
|
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
|
*
|
|
* These libraries and programs are free software; you can
|
|
* redistribute them and/or modify them under the terms of the GNU
|
|
* Lesser General Public License as published by the Free Software
|
|
* Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* These libraries and programs are distributed in the hope that
|
|
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU Lesser General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with these libraries and programs; if not, write
|
|
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
* Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
/* $TOG: SmDB.c /main/5 1998/07/23 18:11:31 mgreess $ */
|
|
/*
|
|
* (c) Copyright 1996 Digital Equipment Corporation.
|
|
* (c) Copyright 1996 Hewlett-Packard Company.
|
|
* (c) Copyright 1996 International Business Machines Corp.
|
|
* (c) Copyright 1996 Sun Microsystems, Inc.
|
|
* (c) Copyright 1996 Novell, Inc.
|
|
* (c) Copyright 1996 FUJITSU LIMITED.
|
|
* (c) Copyright 1996 Hitachi.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include "SmDB.h"
|
|
|
|
#define RESOURCE_BUF_SZ 1024
|
|
#define CLIENT_ID_SZ 20
|
|
|
|
typedef struct _ClientDBRec
|
|
{
|
|
XrmDatabase xrmDB; /* Xrm resource database. */
|
|
Boolean openForInput; /* True if input, False if output. */
|
|
|
|
char *xrmDBFileName; /* Filename, for openForInput == False. */
|
|
char *tmpDBFileName;
|
|
FILE *xrmDBFile;
|
|
|
|
/* Below used if openForInput. */
|
|
char **XSMPClients; /* malloc'd array of XSMP client IDs. */
|
|
int nXSMPClients; /* number of XSMP clients. */
|
|
int nextXSMPClientIndex; /* index of next XSMP client to Get;
|
|
* also used as sequence # for Put. */
|
|
|
|
char **proxyClients; /* malloc'd array of Proxy client IDs. */
|
|
int nProxyClients; /* number of Proxy clients. */
|
|
int nextProxyClientIndex; /* index of next Proxy client to Get;
|
|
* also used as sequence # for Put. */
|
|
} ClientDBRec;
|
|
|
|
static Boolean xrmInitialized = False;
|
|
static XrmName XSMPName[2];
|
|
static XrmClass XSMPClass[2];
|
|
static XrmName proxyName[2];
|
|
static XrmClass proxyClass[2];
|
|
static XrmQuark anyQuark;
|
|
static char *resourceBuf = NULL;
|
|
static char *clientIDBuf = NULL;
|
|
|
|
/* Public strings */
|
|
char *versionStr = ".version";
|
|
char *dtsessionIDStr = ".dtsessionID";
|
|
|
|
/* Strings for XSMP clients. */
|
|
static char *clientStr = "!\nClient.%s";
|
|
static char *programStr = "%s.Program";
|
|
static char *cwdStr = "%s.Cwd";
|
|
static char *restartCmdStr = "%s.RestartCommand";
|
|
static char *cloneCmdStr = "%s.CloneCommand";
|
|
static char *discardCmdStr = "%s.DiscardCommand";
|
|
static char *environmentStr = "%s.Environment";
|
|
static char *restartHintStr = "%s.RestartHint";
|
|
static char *sessionIDStr = "%s.SessionID";
|
|
|
|
/* Strings for Proxy clients. */
|
|
static char *proxyStr = "!\nProxyClient.%s";
|
|
static char *commandStr = "%s.Command";
|
|
|
|
/* Common resources (XSMP and Proxy). */
|
|
static char *clientHostStr = "%s.ClientHost";
|
|
static char *screenNumStr = "%s.ScreenNum";
|
|
|
|
static void _initXrm(void);
|
|
static Bool _countProc(XrmDatabase *, XrmBindingList, XrmQuarkList,
|
|
XrmRepresentation *, XrmValue *, XPointer);
|
|
static Bool _fillClientIDProc(XrmDatabase *, XrmBindingList, XrmQuarkList,
|
|
XrmRepresentation *, XrmValue *, XPointer);
|
|
static Bool _fillStringArrayProc(XrmDatabase *, XrmBindingList, XrmQuarkList,
|
|
XrmRepresentation *, XrmValue *, XPointer);
|
|
static Boolean _getStringResource(XrmDatabase, char *,
|
|
char *, char **, char *);
|
|
static Boolean _getIntResource(XrmDatabase, char *, char *, int *, int);
|
|
static Boolean _getStringArrayResource(XrmDatabase, char *, char *,
|
|
char ***, char **);
|
|
static void _freeStringArray(char **);
|
|
static Boolean _putStringResource(ClientDBRec *, char *, char *, char *);
|
|
static Boolean _putIntResource(ClientDBRec *, char *, char *, int);
|
|
static Boolean _putStringArrayResource(ClientDBRec *, char *, char *, char **);
|
|
static char *_tmpFileName(char *);
|
|
|
|
static void
|
|
_initXrm(void)
|
|
{
|
|
if (!xrmInitialized)
|
|
{
|
|
XrmInitialize(); /* Just in case. */
|
|
|
|
anyQuark = XrmStringToQuark("?");
|
|
XSMPName[0] = proxyName[0] = anyQuark;
|
|
XSMPClass[0] = XrmStringToClass("Client");
|
|
proxyClass[0] = XrmStringToClass("ProxyClient");
|
|
XSMPName[1] = XSMPClass[1] =
|
|
proxyName[1] = proxyClass[1] = NULLQUARK;
|
|
xrmInitialized = True;
|
|
}
|
|
}
|
|
|
|
static Bool
|
|
_countProc(XrmDatabase *clientDB, XrmBindingList bindingList,
|
|
XrmQuarkList quarkList, XrmRepresentation *reps,
|
|
XrmValue *value, XPointer uData)
|
|
{
|
|
int *countP = (int *)uData;
|
|
|
|
(*countP)++;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static Bool
|
|
_fillClientIDProc(XrmDatabase *clientDB, XrmBindingList bindingList,
|
|
XrmQuarkList quarkList, XrmRepresentation *reps,
|
|
XrmValue *value, XPointer uData)
|
|
{
|
|
char ***idListPtr = (char ***)uData;
|
|
char **clientIDPtr = *idListPtr;
|
|
|
|
*clientIDPtr = (char *)value->addr;
|
|
(*idListPtr)++;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static Bool
|
|
_fillStringArrayProc(XrmDatabase *clientDB, XrmBindingList bindingList,
|
|
XrmQuarkList quarkList, XrmRepresentation *reps,
|
|
XrmValue *value, XPointer uData)
|
|
{
|
|
char **stringsPtr = (char **)uData;
|
|
char *indexStr;
|
|
|
|
/* Our index into this string array is at quarkList[2]. */
|
|
if ((indexStr = XrmQuarkToString(quarkList[2])) == (char *)NULL)
|
|
return True;
|
|
|
|
if ((stringsPtr[atoi(indexStr)] = XtNewString((char *)value->addr))
|
|
== (char *)NULL)
|
|
return True;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static Boolean
|
|
_getStringResource(XrmDatabase xrmDB, char *fmtStr,
|
|
char *clientID, char **resourcePtr, char *defaultVal)
|
|
{
|
|
char *resourceType;
|
|
XrmValue resourceValue;
|
|
|
|
if (NULL == resourceBuf) resourceBuf = XtMalloc(RESOURCE_BUF_SZ);
|
|
sprintf(resourceBuf, fmtStr, clientID);
|
|
if (XrmGetResource(xrmDB, resourceBuf, resourceBuf,
|
|
&resourceType, &resourceValue))
|
|
{
|
|
if ((*resourcePtr = XtNewString(resourceValue.addr)) == (char *)NULL)
|
|
return False;
|
|
|
|
return True;
|
|
}
|
|
|
|
*resourcePtr = defaultVal;
|
|
return True;
|
|
}
|
|
|
|
static Boolean
|
|
_getIntResource(XrmDatabase xrmDB, char *fmtStr,
|
|
char *clientID, int *resourcePtr, int defaultVal)
|
|
{
|
|
char *resourceType;
|
|
XrmValue resourceValue;
|
|
|
|
if (NULL == resourceBuf) resourceBuf = XtMalloc(RESOURCE_BUF_SZ);
|
|
sprintf(resourceBuf, fmtStr, clientID);
|
|
*resourcePtr = (XrmGetResource(xrmDB, resourceBuf, resourceBuf,
|
|
&resourceType, &resourceValue)) ?
|
|
atoi(resourceValue.addr) : defaultVal;
|
|
|
|
return True;
|
|
}
|
|
|
|
static Boolean
|
|
_getStringArrayResource(XrmDatabase xrmDB, char *fmtStr,
|
|
char *clientID, char ***resourcePtr,
|
|
char **defaultVal)
|
|
{
|
|
XrmQuark resourceName[3];
|
|
XrmQuark resourceClass[3];
|
|
char *resourceType;
|
|
XrmValue resourceValue;
|
|
int nStrings;
|
|
|
|
resourceName[0] = resourceName[1] = anyQuark;
|
|
resourceName[2] = NULLQUARK;
|
|
|
|
if (NULL == resourceBuf) resourceBuf = XtMalloc(RESOURCE_BUF_SZ);
|
|
sprintf(resourceBuf, fmtStr, clientID);
|
|
XrmStringToQuarkList(resourceBuf, resourceClass);
|
|
|
|
nStrings = 0;
|
|
XrmEnumerateDatabase(xrmDB, resourceName, resourceClass,
|
|
XrmEnumOneLevel, _countProc,
|
|
(XPointer)&nStrings);
|
|
|
|
if (nStrings > 0)
|
|
{
|
|
char **stringsPtr;
|
|
int i;
|
|
|
|
if ((stringsPtr = (char **)XtMalloc((nStrings + 1) * sizeof(char *)))
|
|
== (char **)NULL)
|
|
return False;
|
|
|
|
/* Initialize array entries to NULL so free can work. */
|
|
/* NOTE: Final entry (nStrings) will remain NULL. */
|
|
for (i = 0; i <= nStrings; i++)
|
|
stringsPtr[i] = (char *)NULL;
|
|
|
|
if (XrmEnumerateDatabase(xrmDB,
|
|
resourceName, resourceClass,
|
|
XrmEnumOneLevel, _fillStringArrayProc,
|
|
(XPointer)stringsPtr))
|
|
{
|
|
for (i = 0; i < nStrings; i++)
|
|
XtFree(stringsPtr[i]);
|
|
XtFree((char *)stringsPtr);
|
|
return False;
|
|
}
|
|
|
|
*resourcePtr = stringsPtr;
|
|
return True;
|
|
}
|
|
|
|
*resourcePtr = defaultVal;
|
|
return True;
|
|
}
|
|
|
|
static void
|
|
_freeStringArray(char **stringsPtr)
|
|
{
|
|
if (stringsPtr)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; stringsPtr[i] != (char *)NULL; i++)
|
|
XtFree(stringsPtr[i]);
|
|
|
|
XtFree((char *)stringsPtr);
|
|
}
|
|
}
|
|
|
|
static Boolean
|
|
_putStringResource(ClientDBRec *clientDB, char *fmtStr, char *clientID,
|
|
char *resourceVal)
|
|
{
|
|
if (resourceVal != (char *)NULL)
|
|
{
|
|
if (NULL == clientIDBuf) clientIDBuf = XtMalloc(RESOURCE_BUF_SZ);
|
|
sprintf(clientIDBuf, fmtStr, clientID);
|
|
if (fprintf(clientDB->xrmDBFile, "%s: %s\n", clientIDBuf, resourceVal)
|
|
< 0)
|
|
return False;
|
|
}
|
|
|
|
return True;
|
|
}
|
|
|
|
static Boolean
|
|
_putIntResource(ClientDBRec *clientDB, char *fmtStr, char *clientID,
|
|
int resourceVal)
|
|
{
|
|
if (NULL == clientIDBuf) clientIDBuf = XtMalloc(RESOURCE_BUF_SZ);
|
|
sprintf(clientIDBuf, fmtStr, clientID);
|
|
if (fprintf(clientDB->xrmDBFile, "%s: %d\n", clientIDBuf, resourceVal)
|
|
< 0)
|
|
return False;
|
|
|
|
return True;
|
|
}
|
|
|
|
static Boolean
|
|
_putStringArrayResource(ClientDBRec *clientDB, char *fmtStr, char *clientID,
|
|
char **resourceVal)
|
|
{
|
|
int i;
|
|
|
|
if (resourceVal != (char **)NULL)
|
|
{
|
|
for (i = 0; resourceVal[i] != (char *)NULL; i++)
|
|
{
|
|
if (NULL == clientIDBuf) clientIDBuf = XtMalloc(RESOURCE_BUF_SZ);
|
|
sprintf(clientIDBuf, fmtStr, clientID);
|
|
if (fprintf(clientDB->xrmDBFile, "%s.%d: %s\n",
|
|
clientIDBuf, i, resourceVal[i]) < 0)
|
|
return False;
|
|
}
|
|
}
|
|
|
|
return True;
|
|
}
|
|
|
|
static char *
|
|
_tmpFileName(char *fileName)
|
|
{
|
|
int fileNameLen = strlen(fileName);
|
|
char *newFileName =
|
|
(char *)XtMalloc((fileNameLen + 20) * sizeof(char));
|
|
|
|
if (newFileName != (char *)NULL)
|
|
{
|
|
int i;
|
|
char *ptr = &(newFileName[fileNameLen]);
|
|
|
|
strcpy(newFileName, fileName);
|
|
|
|
/* Hm. I suppose if a couple billion versions of this file exist */
|
|
/* we could loop forever, but that's not likely. */
|
|
for (i = 0; ; i++)
|
|
{
|
|
sprintf(ptr, "%d", i);
|
|
if (access(newFileName, F_OK) != 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return newFileName;
|
|
}
|
|
|
|
ClientDB
|
|
OpenInputClientDB(char *fileName,
|
|
char **version,
|
|
char **dtsessionID)
|
|
{
|
|
ClientDBRec *inputDB;
|
|
char **tmpPtr;
|
|
char *resourceType;
|
|
XrmValue resourceValue;
|
|
|
|
*version = (char *)NULL;
|
|
*dtsessionID = (char *)NULL;
|
|
|
|
_initXrm();
|
|
|
|
if ((fileName == (char *)NULL) ||
|
|
((inputDB = (ClientDBRec *)XtMalloc(sizeof(ClientDBRec)))
|
|
== (ClientDBRec *)NULL))
|
|
return (ClientDB)NULL;
|
|
|
|
if ((inputDB->xrmDB = XrmGetFileDatabase(fileName))
|
|
== (XrmDatabase)NULL)
|
|
{
|
|
XtFree((char *)inputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
inputDB->openForInput = True;
|
|
inputDB->XSMPClients = inputDB->proxyClients = (char **)NULL;
|
|
inputDB->nXSMPClients = inputDB->nProxyClients = 0;
|
|
inputDB->nextXSMPClientIndex = inputDB->nextProxyClientIndex = 0;
|
|
|
|
/* Count the number of XSMP and Proxy clients. */
|
|
XrmEnumerateDatabase(inputDB->xrmDB, XSMPName, XSMPClass,
|
|
XrmEnumOneLevel, _countProc,
|
|
(XPointer)&inputDB->nXSMPClients);
|
|
XrmEnumerateDatabase(inputDB->xrmDB, proxyName, proxyClass,
|
|
XrmEnumOneLevel, _countProc,
|
|
(XPointer)&inputDB->nProxyClients);
|
|
|
|
/* Allocate space for the client IDs and fill from database. */
|
|
if (inputDB->nXSMPClients > 0)
|
|
{
|
|
if ((inputDB->XSMPClients =
|
|
(char **)XtMalloc(inputDB->nXSMPClients * sizeof(char *)))
|
|
== (char **)NULL)
|
|
{
|
|
XrmDestroyDatabase(inputDB->xrmDB);
|
|
XtFree((char *)inputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
tmpPtr = inputDB->XSMPClients;
|
|
XrmEnumerateDatabase(inputDB->xrmDB, XSMPName, XSMPClass,
|
|
XrmEnumOneLevel, _fillClientIDProc,
|
|
(XPointer)&tmpPtr);
|
|
}
|
|
if (inputDB->nProxyClients > 0)
|
|
{
|
|
if ((inputDB->proxyClients =
|
|
(char **)XtMalloc(inputDB->nProxyClients * sizeof(char *)))
|
|
== (char **)NULL)
|
|
{
|
|
XrmDestroyDatabase(inputDB->xrmDB);
|
|
XtFree((char *)inputDB->XSMPClients);
|
|
XtFree((char *)inputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
tmpPtr = inputDB->proxyClients;
|
|
XrmEnumerateDatabase(inputDB->xrmDB, proxyName, proxyClass,
|
|
XrmEnumOneLevel, _fillClientIDProc,
|
|
(XPointer)&tmpPtr);
|
|
}
|
|
|
|
if ((!XrmGetResource(inputDB->xrmDB, versionStr, versionStr,
|
|
&resourceType, &resourceValue)) ||
|
|
((*version = XtNewString(resourceValue.addr)) == (char *)NULL) ||
|
|
(!XrmGetResource(inputDB->xrmDB, dtsessionIDStr, dtsessionIDStr,
|
|
&resourceType, &resourceValue)) ||
|
|
((*dtsessionID = XtNewString(resourceValue.addr)) == (char *)NULL))
|
|
{
|
|
if (*version)
|
|
{
|
|
XtFree(*version);
|
|
*version = (char *)NULL;
|
|
}
|
|
XrmDestroyDatabase(inputDB->xrmDB);
|
|
XtFree((char *)inputDB->XSMPClients);
|
|
XtFree((char *)inputDB->proxyClients);
|
|
XtFree((char *)inputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
return (ClientDB)inputDB;
|
|
}
|
|
|
|
ClientDB
|
|
OpenOutputClientDB(char *fileName,
|
|
char *version,
|
|
char *dtsessionID)
|
|
{
|
|
ClientDBRec *outputDB;
|
|
|
|
_initXrm();
|
|
|
|
if ((fileName == (char *)NULL) ||
|
|
(version == (char *)NULL) ||
|
|
(dtsessionID == (char *)NULL) ||
|
|
((outputDB = (ClientDBRec *)XtMalloc(sizeof(ClientDBRec)))
|
|
== (ClientDBRec *)NULL))
|
|
return (ClientDB)NULL;
|
|
|
|
outputDB->xrmDB = (XrmDatabase)NULL;
|
|
outputDB->openForInput = False;
|
|
outputDB->nextXSMPClientIndex = 0;
|
|
outputDB->nextProxyClientIndex = 0;
|
|
|
|
/* Save current DB to tmp file in case we need to restore later. */
|
|
if (((outputDB->xrmDBFileName = XtNewString(fileName)) == (char *)NULL) ||
|
|
((outputDB->tmpDBFileName = _tmpFileName(fileName)) == (char *)NULL))
|
|
{
|
|
if (outputDB->xrmDBFileName != (char *)NULL)
|
|
XtFree(outputDB->xrmDBFileName);
|
|
XtFree((char *)outputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
if ((rename(fileName, outputDB->tmpDBFileName) != 0) &&
|
|
(errno != ENOENT))
|
|
{
|
|
XtFree(outputDB->xrmDBFileName);
|
|
XtFree(outputDB->tmpDBFileName);
|
|
XtFree((char *)outputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
/* Open fileName for writing. */
|
|
if ((outputDB->xrmDBFile = fopen(fileName, "w")) == (FILE *)NULL)
|
|
{
|
|
int rv;
|
|
rv = rename(outputDB->tmpDBFileName, fileName);
|
|
XtFree(outputDB->xrmDBFileName);
|
|
XtFree(outputDB->tmpDBFileName);
|
|
XtFree((char *)outputDB);
|
|
return (ClientDB)NULL;
|
|
}
|
|
|
|
/* Store version and session ID. */
|
|
fprintf(outputDB->xrmDBFile, "! dtsession.db\n!\n%s: %s\n",
|
|
versionStr, version);
|
|
fprintf(outputDB->xrmDBFile, "%s: %s\n", dtsessionIDStr, dtsessionID);
|
|
|
|
return (ClientDB)outputDB;
|
|
}
|
|
|
|
XSMPClientDBRecPtr
|
|
GetXSMPClientDBRec(ClientDB inputDBPtr)
|
|
{
|
|
ClientDBRec *inputDB = (ClientDBRec *)inputDBPtr;
|
|
XSMPClientDBRecPtr clientPtr;
|
|
char *clientID;
|
|
|
|
if ((inputDB == (ClientDBRec *)NULL) ||
|
|
(!inputDB->openForInput) ||
|
|
(inputDB->nextXSMPClientIndex >= inputDB->nXSMPClients) ||
|
|
((clientPtr = (XSMPClientDBRecPtr)XtMalloc(sizeof(XSMPClientDBRec)))
|
|
== (XSMPClientDBRecPtr)NULL))
|
|
{
|
|
return (XSMPClientDBRecPtr)NULL;
|
|
}
|
|
|
|
clientID = inputDB->XSMPClients[inputDB->nextXSMPClientIndex];
|
|
|
|
/* Initialize pointers so Free is easy. */
|
|
clientPtr->clientId = (char *)NULL;
|
|
clientPtr->clientHost = clientPtr->program =
|
|
clientPtr->cwd = (char *)NULL;
|
|
clientPtr->restartCommand = clientPtr->cloneCommand =
|
|
clientPtr->discardCommand = clientPtr->environment = (char **)NULL;
|
|
|
|
/* Retrieve resources from the database. */
|
|
if (!_getStringResource(inputDB->xrmDB, sessionIDStr, clientID,
|
|
&clientPtr->clientId, (char *)NULL) ||
|
|
!_getStringResource(inputDB->xrmDB, clientHostStr, clientID,
|
|
&clientPtr->clientHost, (char *)NULL) ||
|
|
!_getStringResource(inputDB->xrmDB, programStr, clientID,
|
|
&clientPtr->program, (char *)NULL) ||
|
|
!_getStringResource(inputDB->xrmDB, cwdStr, clientID,
|
|
&clientPtr->cwd, (char *)NULL) ||
|
|
!_getIntResource(inputDB->xrmDB, screenNumStr, clientID,
|
|
&clientPtr->screenNum, 0) ||
|
|
!_getStringArrayResource(inputDB->xrmDB, restartCmdStr, clientID,
|
|
&clientPtr->restartCommand, (char **)NULL) ||
|
|
!_getStringArrayResource(inputDB->xrmDB, cloneCmdStr, clientID,
|
|
&clientPtr->cloneCommand, (char **)NULL) ||
|
|
!_getStringArrayResource(inputDB->xrmDB, discardCmdStr, clientID,
|
|
&clientPtr->discardCommand, (char **)NULL) ||
|
|
!_getStringArrayResource(inputDB->xrmDB, environmentStr, clientID,
|
|
&clientPtr->environment, (char **)NULL) ||
|
|
!_getIntResource(inputDB->xrmDB, restartHintStr, clientID,
|
|
(int *)&clientPtr->restartHint, 0))
|
|
{
|
|
FreeXSMPClientDBRec(clientPtr);
|
|
return (XSMPClientDBRecPtr)NULL;
|
|
}
|
|
|
|
clientPtr->next = (XSMPClientDBRec *)NULL;
|
|
|
|
inputDB->nextXSMPClientIndex++;
|
|
|
|
return clientPtr;
|
|
}
|
|
|
|
ProxyClientDBRecPtr
|
|
GetProxyClientDBRec(ClientDB inputDBPtr)
|
|
{
|
|
ClientDBRec *inputDB = (ClientDBRec *)inputDBPtr;
|
|
ProxyClientDBRecPtr clientPtr;
|
|
char *clientID;
|
|
|
|
if ((inputDB == (ClientDBRec *)NULL) ||
|
|
(!inputDB->openForInput) ||
|
|
(inputDB->nextProxyClientIndex >= inputDB->nProxyClients) ||
|
|
((clientPtr = (ProxyClientDBRecPtr)XtMalloc(sizeof(ProxyClientDBRec)))
|
|
== (ProxyClientDBRecPtr)NULL))
|
|
{
|
|
return (ProxyClientDBRecPtr)NULL;
|
|
}
|
|
|
|
clientID = inputDB->proxyClients[inputDB->nextProxyClientIndex];
|
|
|
|
/* Initialize pointers so Free is easy. */
|
|
clientPtr->clientHost = (char *)NULL;
|
|
clientPtr->command = (char **)NULL;
|
|
|
|
/* Retrieve resources from the database. */
|
|
if (!_getStringResource(inputDB->xrmDB, clientHostStr, clientID,
|
|
&clientPtr->clientHost, (char *)NULL) ||
|
|
!_getStringArrayResource(inputDB->xrmDB, commandStr, clientID,
|
|
&clientPtr->command, (char **)NULL) ||
|
|
!_getIntResource(inputDB->xrmDB, screenNumStr, clientID,
|
|
&clientPtr->screenNum, 0))
|
|
{
|
|
FreeProxyClientDBRec(clientPtr);
|
|
return (ProxyClientDBRecPtr)NULL;
|
|
}
|
|
|
|
inputDB->nextProxyClientIndex++;
|
|
|
|
return clientPtr;
|
|
}
|
|
|
|
Boolean
|
|
PutXSMPClientDBRec(ClientDB outputDBPtr,
|
|
XSMPClientDBRecPtr clientPtr)
|
|
{
|
|
ClientDBRec *outputDB = (ClientDBRec *)outputDBPtr;
|
|
char clientID[CLIENT_ID_SZ];
|
|
|
|
if ((outputDB == (ClientDBRec *)NULL) ||
|
|
(outputDB->openForInput) ||
|
|
(clientPtr == (XSMPClientDBRecPtr)NULL) ||
|
|
(clientPtr->clientId == (char *)NULL))
|
|
return False;
|
|
|
|
sprintf(clientID, "C%d", outputDB->nextXSMPClientIndex++);
|
|
|
|
if (!_putStringResource(outputDB, clientStr, clientID, clientID) ||
|
|
!_putStringResource(outputDB, sessionIDStr, clientID,
|
|
clientPtr->clientId) ||
|
|
!_putStringResource(outputDB, clientHostStr, clientID,
|
|
clientPtr->clientHost) ||
|
|
!_putStringResource(outputDB, programStr, clientID,
|
|
clientPtr->program) ||
|
|
!_putStringResource(outputDB, cwdStr, clientID,
|
|
clientPtr->cwd) ||
|
|
!_putIntResource(outputDB, screenNumStr, clientID,
|
|
clientPtr->screenNum) ||
|
|
!_putStringArrayResource(outputDB, restartCmdStr, clientID,
|
|
clientPtr->restartCommand) ||
|
|
!_putStringArrayResource(outputDB, cloneCmdStr, clientID,
|
|
clientPtr->cloneCommand) ||
|
|
!_putStringArrayResource(outputDB, discardCmdStr, clientID,
|
|
clientPtr->discardCommand) ||
|
|
!_putStringArrayResource(outputDB, environmentStr, clientID,
|
|
clientPtr->environment) ||
|
|
!_putIntResource(outputDB, restartHintStr, clientID,
|
|
(int)clientPtr->restartHint))
|
|
return False;
|
|
|
|
return True;
|
|
}
|
|
|
|
Boolean
|
|
PutProxyClientDBRec(ClientDB outputDBPtr,
|
|
ProxyClientDBRecPtr clientPtr)
|
|
{
|
|
ClientDBRec *outputDB = (ClientDBRec *)outputDBPtr;
|
|
char clientID[CLIENT_ID_SZ];
|
|
|
|
if ((outputDB == (ClientDBRec *)NULL) ||
|
|
(outputDB->openForInput) ||
|
|
(clientPtr == (ProxyClientDBRecPtr)NULL))
|
|
return False;
|
|
|
|
sprintf(clientID, "PC%d", outputDB->nextProxyClientIndex++);
|
|
|
|
if (!_putStringResource(outputDB, proxyStr, clientID, clientID) ||
|
|
!_putStringResource(outputDB, clientHostStr, clientID,
|
|
clientPtr->clientHost) ||
|
|
!_putStringArrayResource(outputDB, commandStr, clientID,
|
|
clientPtr->command) ||
|
|
!_putIntResource(outputDB, screenNumStr, clientID,
|
|
clientPtr->screenNum))
|
|
return False;
|
|
|
|
return True;
|
|
}
|
|
|
|
Boolean
|
|
CloseClientDB(ClientDB clientDBPtr, Boolean writeDB)
|
|
{
|
|
ClientDBRec *clientDB = (ClientDBRec *)clientDBPtr;
|
|
|
|
if (clientDB == (ClientDBRec *)NULL)
|
|
return False;
|
|
|
|
/* Input? */
|
|
if (clientDB->openForInput)
|
|
{
|
|
XtFree((char *)clientDB->XSMPClients);
|
|
XtFree((char *)clientDB->proxyClients);
|
|
XrmDestroyDatabase(clientDB->xrmDB);
|
|
XtFree((char *)clientDB);
|
|
|
|
return True;
|
|
}
|
|
|
|
/* Otherwise, output. */
|
|
if (writeDB)
|
|
{
|
|
/* Close file and remove temp DB. */
|
|
fclose(clientDB->xrmDBFile);
|
|
unlink(clientDB->tmpDBFileName);
|
|
}
|
|
else
|
|
{
|
|
int rv;
|
|
/* Close file and remove it; restore original DB. */
|
|
fclose(clientDB->xrmDBFile);
|
|
rv = rename(clientDB->tmpDBFileName, clientDB->xrmDBFileName);
|
|
}
|
|
|
|
XtFree(clientDB->xrmDBFileName);
|
|
XtFree(clientDB->tmpDBFileName);
|
|
XtFree((char *)clientDB);
|
|
|
|
return True;
|
|
}
|
|
|
|
void
|
|
FreeXSMPClientDBRec(XSMPClientDBRecPtr clientPtr)
|
|
{
|
|
if (clientPtr != (XSMPClientDBRecPtr)NULL)
|
|
{
|
|
XtFree(clientPtr->clientId);
|
|
XtFree(clientPtr->clientHost);
|
|
XtFree(clientPtr->program);
|
|
XtFree(clientPtr->cwd);
|
|
|
|
_freeStringArray(clientPtr->restartCommand);
|
|
_freeStringArray(clientPtr->cloneCommand);
|
|
_freeStringArray(clientPtr->discardCommand);
|
|
_freeStringArray(clientPtr->environment);
|
|
|
|
XtFree((char *)clientPtr);
|
|
}
|
|
}
|
|
|
|
void
|
|
FreeProxyClientDBRec(ProxyClientDBRecPtr clientPtr)
|
|
{
|
|
if (clientPtr != (ProxyClientDBRecPtr)NULL)
|
|
{
|
|
XtFree(clientPtr->clientHost);
|
|
|
|
_freeStringArray(clientPtr->command);
|
|
|
|
XtFree((char *)clientPtr);
|
|
}
|
|
}
|