/*****************************************************************************
*
* FUNCTION: void centralIgnoreVarLogging
*
* DESCRIPTION:
*
* INPUTS:
*
* OUTPUTS: void
*
*****************************************************************************/
void centralIgnoreVarLogging(const char *varName)
{
char *setMsgName;
char *getMsgName;
char *getSetMsgName;
char *watchMsgName;
setMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_SET_PREFIX));
strcpy(setMsgName,VAR_SET_PREFIX);
strcat(setMsgName,varName);
Add_Message_To_Ignore(setMsgName);
x_ipcFree(setMsgName);
getMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_GET_PREFIX));
strcpy(getMsgName,VAR_GET_PREFIX);
strcat(getMsgName,varName);
Add_Message_To_Ignore(getMsgName);
x_ipcFree(getMsgName);
getSetMsgName = (char *)x_ipcMalloc(1+strlen(varName)+
strlen(VAR_GET_SET_PREFIX));
strcpy(getSetMsgName,VAR_GET_SET_PREFIX);
strcat(getSetMsgName,varName);
Add_Message_To_Ignore(getSetMsgName);
x_ipcFree(getSetMsgName);
watchMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_WATCH_PREFIX));
strcpy(watchMsgName,VAR_WATCH_PREFIX);
strcat(watchMsgName,varName);
Add_Message_To_Ignore(watchMsgName);
x_ipcFree(watchMsgName);
}
HASH_TABLE_PTR x_ipc_hashTableCreate(int32 size, HASH_FN hashFunc, EQ_HASH_FN eqFunc)
#endif
{
int32 i;
HASH_ELEM_PTR *table;
HASH_TABLE_PTR hashTable;
#if defined(DBMALLOC)
hashTable = NEW_DB(file,line,HASH_TABLE_TYPE);
table = (HASH_ELEM_PTR *)x_ipcDBMalloc(file,line,
sizeof(HASH_ELEM_PTR)*(unsigned)size);
#else
hashTable = NEW(HASH_TABLE_TYPE);
table = (HASH_ELEM_PTR *)x_ipcMalloc(sizeof(HASH_ELEM_PTR)*(unsigned)size);
#endif
for(i=0;i < size;i++)
table[i] = NULL;
hashTable->size = size;
hashTable->hashFunc = hashFunc;
hashTable->eqFunc = eqFunc;
hashTable->table = table;
return hashTable;
}
static void setVarHnd(DISPATCH_PTR dispatch, void *varValue)
{
GLOBAL_VAR_PTR var=NULL;
const char *msgName = dispatch->msg->msgData->name;
const char *varName;
char *watchMsgName;
varName = &(msgName[strlen(VAR_SET_PREFIX)]);
var = (GLOBAL_VAR_PTR) x_ipc_hashTableFind(varName, GET_S_GLOBAL(varTable));
if (var == NULL) {
/* handle the error here. */
} else {
/* Free the old data if it exists */
if (var->value != NULL)
x_ipcFreeData(msgName,var->value);
/* Store the pointer to the new data */
var->value = varValue;
}
/* Need to do a x_ipcSuccess, if a command. */
/* centralSuccess(dispatch);*/
/* Broadcast the result. */
watchMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_WATCH_PREFIX));
strcpy(watchMsgName,VAR_WATCH_PREFIX);
strcat(watchMsgName,varName);
centralBroadcast(watchMsgName,var->value);
x_ipcFree(watchMsgName);
}
const void *x_ipc_hashTableInsert(const void *key, int32 keySize,
const void *item, HASH_TABLE_PTR table)
{
const char *oldData;
int32 hash, location;
HASH_ELEM_PTR tmp, element;
char *keyPtr=NULL;
hash = (*table->hashFunc)(key);
location = hash % table->size;
tmp = table->table[location];
if (tmp) {
tmp = x_ipc_findElement(table->eqFunc, tmp, key);
if (tmp) {
/* replace item with new information */
oldData = tmp->data;
tmp->data = (const char *)item;
return oldData;
}
}
element = NEW(HASH_ELEM_TYPE);
keyPtr = (char *)x_ipcMalloc((unsigned)keySize);
BCOPY(key, keyPtr, keySize);
element->key = (const char *) keyPtr;
element->data = (const char *)item;
element->next = table->table[location];
table->table[location] = element;
return NULL;
}
void *x_ipcDBMalloc(const char* file, int line, unsigned long amount)
{
#ifdef UNUSED_PRAGMA
#pragma unused(file, line)
#endif
return x_ipcMalloc(amount);
}
static FORMAT_ARRAY_PTR fix_format_array(FORMAT_ARRAY_PTR varFormatArray,
CONST_FORMAT_PTR parentFormat,
CONST_GENERIC_DATA_PTR dataPtr,
int32 DStart)
{
FORMAT_ARRAY_PTR fixed_format_array;
FORMAT_ARRAY_PTR parentStructArray;
int32 arraySize, foundPlace, currentPlace, i, j, sizePlace;
int32 offset=0, size, sizeOffset=0, currentOffset=0;
SIZES_TYPE sizes;
parentStructArray = parentFormat->formatter.a;
foundPlace = 0;
for (currentPlace=1; !foundPlace; currentPlace++)
foundPlace = ((parentStructArray[currentPlace].f->type == VarArrayFMT) &&
(parentStructArray[currentPlace].f->formatter.a
== varFormatArray));
currentPlace--;
arraySize = varFormatArray[0].i;
fixed_format_array = (FORMAT_ARRAY_PTR)x_ipcMalloc((unsigned)arraySize *
sizeof(FORMAT_ARRAY_TYPE));
fixed_format_array[0].i = arraySize;
fixed_format_array[1].f = varFormatArray[1].f;
for (i=2; i<arraySize; i++) {
sizePlace = varFormatArray[i].i;
offset = 0;
sizeOffset = 0;
j=1;
while((j <= sizePlace) || (j <= currentPlace)) {
switch (parentStructArray[j].f->type) {
case VarArrayFMT:
sizes.data = sizeof(GENERIC_DATA_PTR);
break;
default:
sizes = x_ipc_bufferSize1(parentStructArray[j].f,dataPtr,
sizeOffset,parentFormat);
break;
}
offset += sizes.data;
offset = x_ipc_alignField(parentFormat,j,offset);
j++;
if (j <= sizePlace) {
sizeOffset = offset;
}
if (j <= currentPlace) {
currentOffset = offset;
}
}
offset = sizeOffset - currentOffset;
size = *((int32 *)(((char *)dataPtr)+DStart+offset));
fixed_format_array[i].i = size;
}
return fixed_format_array;
}
void *x_ipcReferenceData(X_IPC_REF_PTR ref)
{
int32 refId, sd;
MSG_PTR msg;
char *msgData;
X_IPC_REF_PTR waitRef;
X_IPC_RETURN_VALUE_TYPE returnValue;
msg = x_ipc_msgFind(X_IPC_REF_DATA_QUERY);
if (msg == NULL) return NULL;
if (!ref->msg) {
if (!ref->name) {
/* 17-Jun-91: fedor: start enforcing correct refs */
X_IPC_MOD_ERROR1("ERROR: x_ipcReferenceData: Badly Formed Reference: %d\n",
ref->refId);
return NULL;
}
ref->msg = x_ipc_msgFind(ref->name);
if (ref->msg == NULL) return NULL;
}
/* 17-Jun-91: fedor: check if any message form */
if (!ref->msg->msgData->msgFormat)
return NULL;
refId = x_ipc_nextSendMessageRef();
returnValue = x_ipc_sendMessage((X_IPC_REF_PTR)NULL, msg,
(char *)&ref->refId, (char *)NULL, refId);
if (returnValue != Success) {
X_IPC_MOD_ERROR("ERROR: x_ipcReferenceData: x_ipc_sendMessage Failed.\n");
return NULL;
}
waitRef = x_ipcRefCreate(ref->msg, ref->name, refId);
msgData = (char *)x_ipcMalloc((unsigned)x_ipc_dataStructureSize(ref->msg->msgData->msgFormat));
LOCK_CM_MUTEX;
sd = GET_C_GLOBAL(serverRead);
UNLOCK_CM_MUTEX;
returnValue = x_ipc_waitForReplyFrom(waitRef, msgData, TRUE, WAITFOREVER, sd);
x_ipcRefFree(waitRef);
if (returnValue == NullReply) {
/* 17-Jun-91: fedor: if NullReply then nothing else was malloced. */
x_ipcFree(msgData);
return NULL;
}
else
return msgData;
}
void x_ipcUnwatchVar(const char *varName)
{
char *watchMsgName;
watchMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_WATCH_PREFIX));
strcpy(watchMsgName,VAR_WATCH_PREFIX);
strcat(watchMsgName,varName);
/* Unregister the tap messages and handler */
x_ipcDeregisterHandler(watchMsgName,watchMsgName);
x_ipcFree(watchMsgName);
}
void x_ipcFreeVar(const char *varName, void *varData)
{
char *getMsgName;
getMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_GET_PREFIX));
strcpy(getMsgName,VAR_GET_PREFIX);
strcat(getMsgName,varName);
x_ipcFreeReply(getMsgName, varData);
x_ipcFree(getMsgName);
}
X_IPC_RETURN_VALUE_TYPE centralSendResponse(DISPATCH_PTR dispatch, MSG_PTR msg,
void *resData,
X_IPC_MSG_CLASS_TYPE resClass,
void *resClassData,
int sd)
{
#ifdef UNUSED_PRAGMA
#pragma unused(resClassData, sd)
#endif
int32 intent;
DATA_MSG_PTR dataMsg;
if (msg) {
intent = msg->msgData->refId;
} else {
intent = -1;
if (dispatch) {
if (!dispatch->msg)
dispatch->msg = x_ipc_msgFind(dispatch->msg->msgData->name);
msg = dispatch->msg;
}
}
dataMsg = x_ipc_dataMsgCreate(GET_C_GLOBAL(parentRefGlobal), intent,
(int32)resClass, 0, 0,
dispatch->msg->msgData->resFormat, resData,
(FORMAT_PTR)NULL, (char *)NULL);
if (dataMsg == NULL) return Failure;
/* RTG - must set datastruct to be null so message does not get decoded
* into the same memory location. We also have to copy the message
* buffer if it is the same as the original data structure because
* the original data structure can change, if the message is queued.
*/
if (dataMsg->msgData == resData) {
/* Need to copy the data, in case the messages gets queued. */
char *newCopy = NULL;
newCopy = (char *)x_ipcMalloc(dataMsg->msgTotal);
BCOPY(dataMsg->msgData, newCopy,dataMsg->msgTotal);
dataMsg->msgData = newCopy;
dataMsg->dataStruct = NULL;
} else
dataMsg->dataStruct = NULL;
recvMessageBuild(GET_S_GLOBAL(x_ipcServerModGlobal), dataMsg);
x_ipc_dataMsgFree(dataMsg);
return Success;
}
/*****************************************************************************
*
* FUNCTION: void centralSetVar
*
* DESCRIPTION:
*
* INPUTS:
*
* OUTPUTS: void
*
*****************************************************************************/
void centralSetVar(const char *varName, const char *value)
{
char *setMsgName;
if (!mGlobalp())
return;
setMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_SET_PREFIX));
strcpy(setMsgName,VAR_SET_PREFIX);
strcat(setMsgName,varName);
centralInform(setMsgName, value);
x_ipcFree(setMsgName);
}
X_IPC_RETURN_VALUE_TYPE _x_ipcGetVar(const char *varName, void *value)
{
char *getMsgName;
X_IPC_RETURN_VALUE_TYPE result;
getMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_GET_PREFIX));
strcpy(getMsgName,VAR_GET_PREFIX);
strcat(getMsgName,varName);
result = x_ipcQuery(getMsgName, NULL, value);
x_ipcFree(getMsgName);
return result;
}
static DATA_MSG_PTR x_ipc_dataMsgAlloc(int32 size)
{
DATA_MSG_PTR dataMsg;
dataMsg = (DATA_MSG_PTR)x_ipcMalloc((unsigned)size);
LOCK_M_MUTEX;
(GET_M_GLOBAL(DMTotal))++;
if (size > (GET_M_GLOBAL(DMmax))) (GET_M_GLOBAL(DMmax)) = size;
if (size < (GET_M_GLOBAL(DMmin))) (GET_M_GLOBAL(DMmin)) = size;
UNLOCK_M_MUTEX;
return (dataMsg);
}
X_IPC_RETURN_VALUE_TYPE _x_ipcSetVar(const char *varName, const void *value)
{
char *setMsgName;
X_IPC_RETURN_VALUE_TYPE result;
setMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_SET_PREFIX));
strcpy(setMsgName,VAR_SET_PREFIX);
strcat(setMsgName,varName);
/* x_ipcExecuteCommandAsync(setMsgName, value);*/
result = x_ipcInform(setMsgName, value);
x_ipcFree(setMsgName);
return result;
}
static void strListIncrement(STR_LIST_PTR strList)
{
int newListSize, currentSize;
const char **newList;
currentSize = strList->size;
newListSize = currentSize + STR_LIST_INC;
newList = (const char **)x_ipcMalloc(newListSize*sizeof(char *));
bzero((char *)newList, newListSize*sizeof(char *));
if (currentSize > 0) {
/* Copy Old List */
BCOPY(strList->strings, newList, currentSize*sizeof(char *));
x_ipcFree((char *)strList->strings);
}
strList->size = newListSize;
strList->strings = newList;
}
static void x_ipc_idTableIncrement(ID_TABLE_PTR table)
{
int i, newTableSize, currentSize, newFreeIds;
TELEM_PTR tmp, newTable, oldTable, newFreeList, lastNewFreeBlock;
newFreeIds = table->incSize;
currentSize = table->currentSize;
newTableSize = currentSize+newFreeIds;
oldTable = table->table;
newTable = (TELEM_TYPE *)x_ipcMalloc(sizeof(TELEM_TYPE)*
(unsigned)newTableSize);
i = 0;
if (oldTable) {
/* Copy Old Table */
for (;i<currentSize;i++)
newTable[i] = oldTable[i];
x_ipcFree((char *)oldTable);
}
/* Update Free List and Initialize New Blocks */
newFreeList = NULL;
lastNewFreeBlock = newTable + i;
for (;i<newTableSize;i++) {
tmp = newTable + i;
tmp->data = NULL;
tmp->ref = i;
tmp->next = newFreeList;
newFreeList = tmp;
}
/* Adjust Table Entry */
lastNewFreeBlock->next = table->freeList;
table->freeList = newFreeList;
table->freeTotal += newFreeIds;
table->currentSize = newTableSize;
table->table = newTable;
}
void _x_ipcWatchVar(const char *varName, const char *format, X_IPC_HND_FN watchFn)
{
#ifdef UNUSED_PRAGMA
#pragma unused(format)
#endif
char *watchMsgName;
watchMsgName = (char *)x_ipcMalloc(1+strlen(varName)+strlen(VAR_WATCH_PREFIX));
strcpy(watchMsgName,VAR_WATCH_PREFIX);
strcat(watchMsgName,varName);
/* Check to see if already registered */
LOCK_CM_MUTEX;
HND_KEY_TYPE hndKey; hndKey.num = 0; hndKey.str = watchMsgName;
HND_PTR watchMsgHnd = GET_HANDLER(&hndKey);
UNLOCK_CM_MUTEX;
if (watchMsgHnd == NULL || watchMsgHnd->msg == NULL) {
/* Register the tap messages and handler */
x_ipcRegisterHandler(watchMsgName,watchMsgName,watchFn);
x_ipcLimitPendingMessages(watchMsgName, GET_M_GLOBAL(modNameGlobal), 1);
}
x_ipcFree(watchMsgName);
}
X_IPC_REF_PTR x_ipcRefCreate(MSG_PTR msg, const char *name, int32 refId)
{
X_IPC_REF_PTR x_ipcRef;
int32 length;
LOCK_CM_MUTEX;
if (!x_ipc_listLength(GET_C_GLOBAL(x_ipcRefFreeList)))
x_ipcRef = NEW(X_IPC_REF_TYPE);
else
x_ipcRef = (X_IPC_REF_PTR)x_ipc_listPopItem(GET_C_GLOBAL(x_ipcRefFreeList));
UNLOCK_CM_MUTEX;
x_ipcRef->refId = refId;
x_ipcRef->msg = msg;
if (!name) {
x_ipcRef->name = NULL;
} else {
char *namePtr;
length = strlen(name);
namePtr = (char *)x_ipcMalloc((unsigned)(length+1));
BCOPY(name, namePtr, length);
namePtr[length] = '\0';
x_ipcRef->name = namePtr;
}
x_ipcRef->responseSd = NO_FD;
#ifdef NMP_IPC
x_ipcRef->responded = FALSE;
x_ipcRef->dataLength = 0;
#endif
x_ipcRef->encoding.byteOrder = GET_M_GLOBAL(byteOrder);
x_ipcRef->encoding.alignment = GET_M_GLOBAL(alignment);
return x_ipcRef;
}
void x_ipc_encodeMsgData(CONST_FORMAT_PTR Format, const void *DataStruct,
DATA_MSG_PTR dataMsg, int32 BStart)
{
dataMsg->dataStruct = (const char *)DataStruct;
if (Format == NULL) {
dataMsg->msgData = NULL;
} else {
BOOLEAN isLisp;
LOCK_M_MUTEX;
isLisp = IS_LISP_MODULE();
UNLOCK_M_MUTEX;
if (!isLisp && x_ipc_sameFixedSizeDataBuffer(Format)) {
dataMsg->msgData = (char *)DataStruct;
} else {
dataMsg->msgData = (char *)x_ipcMalloc((unsigned)dataMsg->msgTotal);
x_ipc_encodeData(Format, DataStruct, dataMsg->msgData, BStart,
dataMsg->msgTotal);
}
}
dataMsg->vec = x_ipc_createVectorization(Format,
(const char *)DataStruct,dataMsg->msgData,
dataMsg->msgTotal);
}
JNIEXPORT jlong JNICALL
Java_ipc_java_formatters_createByteArray (JNIEnv *env, jclass theClass, jint length)
{
return (jlong)(size_t)x_ipcMalloc(length);
}
void x_ipc_globalMInit(void)
{
#if defined(VXWORKS)
if (x_ipc_gM == NULL) {
if (taskVarAdd(0, (int *)&x_ipc_gM) != OK) {
printErr("taskVarAdd failed\n");
}
}
#endif
if (mGlobalp() && GET_C_GLOBAL(valid)) {
/* Already initialized, nothing to do. */
return;
} else if (x_ipc_isValidServerConnection()) {
/* Already running, shut down and reinitialize. */
LOCK_CM_MUTEX;
SHUTDOWN_SOCKET(GET_C_GLOBAL(serverRead));
if (GET_C_GLOBAL(serverRead) != GET_C_GLOBAL(serverWrite))
SHUTDOWN_SOCKET(GET_C_GLOBAL(serverWrite));
UNLOCK_CM_MUTEX;
x_ipc_globalMInvalidate();
x_ipc_globalMFree();
} else if (mGlobalp()){
/* Was initialized, but the current values are not valid. */
/* Free some memory and reinitialize. */
x_ipc_globalMFree();
}
/* Never created or has been freed, set the global pointer. */
#if defined(VXWORKS)
x_ipc_gM = (GM_TYPE *)x_ipcMalloc(sizeof(GM_TYPE));
bzero((void *)x_ipc_gM,sizeof(GM_TYPE));
#else
x_ipc_gM_ptr = &x_ipc_gM;
#endif
#ifdef THREADED
initMutex(&GET_M_GLOBAL(mutex));
#endif
GET_M_GLOBAL(currentContext) =
(X_IPC_CONTEXT_PTR)x_ipcMalloc(sizeof(X_IPC_CONTEXT_TYPE));
#ifdef THREADED
initMutex(&GET_C_GLOBAL(mutex));
LOCK_CM_MUTEX;
initMutex(&GET_M_GLOBAL(selectMutex));
initPing(&GET_M_GLOBAL(ping));
initMutex(&GET_C_GLOBAL(ioMutex));
initMutex(&listMutex);
#endif
#if defined(VXWORKS) || defined(NMP_IPC)
GET_M_GLOBAL(enableDistributedResponses) = TRUE;
#else
GET_M_GLOBAL(enableDistributedResponses) = FALSE;
#endif
GET_C_GLOBAL(willListen) = -1;
GET_C_GLOBAL(valid) = FALSE;
GET_M_GLOBAL(byteOrder) = BYTE_ORDER;
GET_M_GLOBAL(alignment) = (ALIGNMENT_TYPE)ALIGN;
GET_C_GLOBAL(serverRead) = NO_SERVER_GLOBAL;
GET_C_GLOBAL(serverWrite) = NO_SERVER_GLOBAL;
GET_C_GLOBAL(directDefault) = FALSE;
GET_M_GLOBAL(pipeBroken) = FALSE;
GET_M_GLOBAL(bufferToAlloc) = NULL;
/* not done */
GET_M_GLOBAL(byteFormat) = NULL;
GET_M_GLOBAL(charFormat) = NULL;
GET_M_GLOBAL(doubleFormat) = NULL;
GET_M_GLOBAL(floatFormat) = NULL;
GET_M_GLOBAL(intFormat) = NULL;
GET_M_GLOBAL(longFormat) = NULL;
GET_M_GLOBAL(shortFormat) = NULL;
GET_M_GLOBAL(classFormatTable) = NULL;
GET_M_GLOBAL(formatNamesTable) = NULL;
GET_C_GLOBAL(handlerTable) = NULL;
GET_C_GLOBAL(messageTable) = NULL;
GET_C_GLOBAL(resourceTable) = NULL;
GET_C_GLOBAL(hndIdTable) = NULL;
GET_C_GLOBAL(msgIdTable) = NULL;
GET_M_GLOBAL(listCellFreeListGlobal) = NULL;
GET_M_GLOBAL(dataMsgBufferList) = NULL;
GET_M_GLOBAL(listFreeListGlobal) = NULL;
GET_C_GLOBAL(moduleConnectionTable) = NULL;
GET_C_GLOBAL(pendingReplies) = NULL;
initMsgQueue(&GET_C_GLOBAL(msgQueue));
GET_C_GLOBAL(queryNotificationList) = NULL;
GET_C_GLOBAL(connectNotifyList) = NULL;
GET_C_GLOBAL(disconnectNotifyList) = NULL;
GET_C_GLOBAL(changeNotifyList) = NULL;
GET_C_GLOBAL(x_ipcRefFreeList) = NULL;
/* GET_M_GLOBAL(x_ipcDefaultTimeGlobal) = {NoTime, {NoInterval, 0}}; */
/* 16-Jan-93 */
/* GET_M_GLOBAL(versionGlobal);*/
#if defined(DBMALLOC)
GET_M_GLOBAL(x_ipcMallocMemHnd) = debug_malloc;
#elif defined(__TURBOC__)
GET_M_GLOBAL(x_ipcMallocMemHnd) = farmalloc;
#else
GET_M_GLOBAL(x_ipcMallocMemHnd) = malloc;
#endif
GET_M_GLOBAL(modNameGlobal) = NULL;
GET_C_GLOBAL(servHostGlobal) = NULL;
FD_ZERO(&(GET_C_GLOBAL(x_ipcConnectionListGlobal)));
FD_ZERO(&(GET_C_GLOBAL(x_ipcListenMaskGlobal)));
#ifdef LISP
GET_M_GLOBAL(lispFlagGlobal) = '\0';
GET_M_GLOBAL(lispRefSaveGlobal) = NULL;
#ifdef CLISP
GET_M_GLOBAL(lispBufferSizeGlobal) = lispbuffersize;
GET_M_GLOBAL(lispDecodeMsgGlobal) = lispdecode;
GET_M_GLOBAL(lispEncodeMsgGlobal) = lispencode;
GET_M_GLOBAL(lispExitGlobal) = lispexit;
#else /* !CLISP */
GET_M_GLOBAL(lispBufferSizeGlobal) = NULL;
GET_M_GLOBAL(lispDecodeMsgGlobal) = NULL;
GET_M_GLOBAL(lispEncodeMsgGlobal) = NULL;
GET_M_GLOBAL(lispExitGlobal) = NULL;
#endif /* !CLISP */
#ifdef NMP_IPC
GET_M_GLOBAL(lispQueryResponseGlobal) = NULL;
#endif
#endif /* LISP */
GET_M_GLOBAL(DMFree) = 0;
GET_M_GLOBAL(DMTotal) =0;
GET_M_GLOBAL(DMmin) = 0;
GET_M_GLOBAL(DMmax) = 0;;
GET_M_GLOBAL(directFlagGlobal) = 0;
GET_M_GLOBAL(expectedWaitGlobal) = FALSE;
GET_M_GLOBAL(freeMemRetryAmount) = 0;
/* not done - only used in behaviors.c does not change */
GET_M_GLOBAL(inconsistentConstraintsGlobal)[0] = (PLAN_FIRST+DELAY_PLANNING);
GET_M_GLOBAL(inconsistentConstraintsGlobal)[1] = 0;
GET_M_GLOBAL(mallocMemRetryAmount) = 1;
GET_C_GLOBAL(parentRefGlobal) = -1;
GET_C_GLOBAL(sendMessageRefGlobal) = 1;
GET_C_GLOBAL(listenPortNum) = 0;
GET_C_GLOBAL(listenPort) = NO_FD;
GET_C_GLOBAL(listenSocket) = NO_FD;
GET_M_GLOBAL(totalMemRequest) = 0;
GET_M_GLOBAL(totalMemBytes) = 0;
GET_M_GLOBAL(indentGlobal) = 0;
GET_M_GLOBAL(dPrintBYTE_FN) = NULL;
GET_M_GLOBAL(dPrintUBYTE_FN) = NULL;
GET_M_GLOBAL(dPrintCHAR_FN) = NULL;
GET_M_GLOBAL(dPrintDOUBLE_FN) = NULL;
GET_M_GLOBAL(dPrintFLOAT_FN) = NULL;
GET_M_GLOBAL(dPrintFORMAT_FN) = NULL;
GET_M_GLOBAL(dPrintINT_FN) = NULL;
GET_M_GLOBAL(dPrintBOOLEAN_FN) = NULL;
GET_M_GLOBAL(dPrintLONG_FN) = NULL;
#ifndef NMP_IPC
GET_M_GLOBAL(dPrintMAP_FN) = NULL;
#endif
GET_M_GLOBAL(dPrintSHORT_FN) = NULL;
GET_M_GLOBAL(dPrintSTR_FN) = NULL;
GET_M_GLOBAL(dPrintX_IPC_FN) = NULL;
GET_M_GLOBAL(dPrintTWOBYTE_FN) = NULL;
GET_M_GLOBAL(dPrintUINT_FN) = NULL;
GET_M_GLOBAL(dPrintUSHORT_FN) = NULL;
GET_M_GLOBAL(dPrintULONG_FN) = NULL;
GET_M_GLOBAL(Message_Ignore_Set) = NULL;
GET_M_GLOBAL(x_ipcExitHnd) = NULL;
GET_M_GLOBAL(x_ipcFreeMemoryHnd) = NULL;
GET_M_GLOBAL(logList)[0] = NULL;
GET_M_GLOBAL(logList)[1] = NULL;
GET_M_GLOBAL(logList)[2] = NULL;
GET_M_GLOBAL(Found_Key) = NULL;/***/
GET_C_GLOBAL(tappedMsgs) = NULL;
GET_C_GLOBAL(broadcastMsgs) = NULL;
GET_C_GLOBAL(maxConnection) = 0;
GET_M_GLOBAL(requiredResources) = x_ipc_strListCreate();
GET_M_GLOBAL(moduleList) = NULL;
#ifdef NMP_IPC
GET_M_GLOBAL(timerList) = x_ipc_listCreate();
#endif
#ifdef LISPWORKS_FFI_HACK
GET_C_GLOBAL(execHndState).state = ExecHnd_Idle;
#endif
UNLOCK_CM_MUTEX;
}
void *createByteArray (int length)
{
return x_ipcMalloc(length);
}
static void registerVarHnd(DISPATCH_PTR dispatch, VAR_REG_PTR varRegData)
{
#ifdef UNUSED_PRAGMA
#pragma unused(dispatch)
#endif
GLOBAL_VAR_PTR var;
CONST_GLOBAL_VAR_PTR old_var;
char *getMsgName, *setMsgName, *getSetMsgName, *watchMsgName;
var = NEW(GLOBAL_VAR_TYPE);
/* Create the data structure to hold information about the variable */
var->varName = varRegData->varName;
var->format = varRegData->format;
var->value = NULL;
/* Create the name strings for the set and get messages.*/
setMsgName = (char *)x_ipcMalloc(1+strlen(var->varName)+
strlen(VAR_SET_PREFIX));
strcpy(setMsgName,VAR_SET_PREFIX);
strcat(setMsgName,var->varName);
getMsgName = (char *)x_ipcMalloc(1+strlen(var->varName)+
strlen(VAR_GET_PREFIX));
strcpy(getMsgName,VAR_GET_PREFIX);
strcat(getMsgName,var->varName);
getSetMsgName = (char *)x_ipcMalloc(1+strlen(var->varName)+
strlen(VAR_GET_SET_PREFIX));
strcpy(getSetMsgName,VAR_GET_SET_PREFIX);
strcat(getSetMsgName,var->varName);
watchMsgName = (char *)x_ipcMalloc(1+strlen(var->varName)+
strlen(VAR_WATCH_PREFIX));
strcpy(watchMsgName,VAR_WATCH_PREFIX);
strcat(watchMsgName,var->varName);
/* Free up the old var, if any */
old_var = (CONST_GLOBAL_VAR_PTR)x_ipc_hashTableInsert((void *)var->varName,
1+strlen(var->varName),
(void *)var,
GET_S_GLOBAL(varTable));
if (old_var != NULL) {
/* The mesage is already registered, just check the format. */
if (strcmp(old_var->format,var->format)) {
X_IPC_ERROR1("ERROR: centralRegisterVar: variable %s already registered"
" with a differnt format.\n", var->varName);
}
/* Free the old var */
if (old_var->value) x_ipcFreeData(setMsgName, old_var->value);
if (old_var->format) x_ipcFree((void *)old_var->format);
x_ipcFree((void *)old_var->varName);
x_ipcFree((void *)old_var);
}
/* Register the functions to set and get the variable value. */
centralRegisterInform(setMsgName, var->format, setVarHnd);
centralRegisterQuery(getMsgName, NULL, var->format, getVarHnd);
centralRegisterQuery(getSetMsgName, var->format, var->format, getSetVarHnd);
centralRegisterBroadcastMessage(watchMsgName, var->format);
x_ipcFree(setMsgName);
x_ipcFree(getMsgName);
x_ipcFree(getSetMsgName);
x_ipcFree(watchMsgName);
/* Just free top level structure -- The strings need to be saved */
x_ipcFree((char *) varRegData);
}
void *x_ipcDBMalloc(const char* file, int line, unsigned long amount)
{
return x_ipcMalloc(amount);
}
X_IPC_RETURN_VALUE_TYPE centralSendMessage(X_IPC_REF_PTR ref, MSG_PTR msg,
void *msgData, void *classData)
{
int32 refId, savedRef;
DATA_MSG_PTR msgDataMsg;
X_IPC_MSG_CLASS_TYPE msg_class;
CLASS_FORM_PTR classForm;
CONST_FORMAT_PTR classFormat;
classFormat = NULL;
if (!msg) {
X_IPC_ERROR("ERROR: x_ipc_sendMessage: NULL msg.\n");
}
/* save the message ref to use in case x_ipc_msgFind triggers
a recursive call to x_ipc_sendMessage */
savedRef = x_ipc_nextSendMessageRef();
msg_class = msg->msgData->msg_class;
classForm = GET_CLASS_FORMAT(&msg_class);
if (classForm)
classFormat = classForm->format;
if (ref)
refId = ref->refId;
else
refId = NO_REF;
/* 8-Oct-90: fedor:
parentRefGlobal problem!!! ** it is initialized to -1 in behaviors.c
so maybe this will not be a problem */
msgDataMsg = x_ipc_dataMsgCreate(GET_C_GLOBAL(parentRefGlobal),
msg->msgData->refId,
(int32)msg_class, refId, savedRef,
msg->msgData->msgFormat,
msgData, classFormat, classData);
if (msgDataMsg == NULL) return Failure;
/* RTG - must set datastruct to be null so message does not get decoded
* into the same memory location. We also have to copy the message
* buffer if it is the same as the original data structure because
* the original data structure can change, if the message is queued.
*/
if (msgDataMsg->msgData == msgData) {
/* Need to copy the data, in case the messages gets queued. */
char *newCopy = NULL;
newCopy = (char *)x_ipcMalloc(msgDataMsg->msgTotal);
BCOPY(msgDataMsg->msgData, newCopy,msgDataMsg->msgTotal);
msgDataMsg->msgData = newCopy;
msgDataMsg->dataStruct = NULL;
} else
msgDataMsg->dataStruct = NULL;
recvMessageBuild(GET_S_GLOBAL(x_ipcServerModGlobal), msgDataMsg);
return Success;
}
DATA_MSG_PTR x_ipc_dataMsgCreate(int32 parentRef, int32 intent, int32 classId,
int32 dispatchRef, int32 msgRef,
CONST_FORMAT_PTR msgFormat,
const void *msgData,
CONST_FORMAT_PTR classFormat,
const void *classData)
{
#ifdef LISP
BUFFER_TYPE buffer;
char *lispDataFlag;
#endif /* LISP */
DATA_MSG_PTR dataMsg;
int32 classTotal, msgTotal;
msgTotal = 0;
if (msgData && msgFormat) {
if (msgFormat->type == BadFormatFMT) return NULL;
#ifdef LISP
LOCK_M_MUTEX;
if (msgData == LISP_DATA_FLAG()) {
(*(GET_M_GLOBAL(lispBufferSizeGlobal)))(&msgTotal, msgFormat);
UNLOCK_M_MUTEX;
} else
UNLOCK_M_MUTEX;
#endif /* LISP */
msgTotal = x_ipc_bufferSize(msgFormat, msgData);
}
if (classData && classFormat)
classTotal = x_ipc_bufferSize(classFormat, classData);
else
classTotal = 0;
dataMsg = x_ipc_dataMsgAlloc(classTotal + sizeof(DATA_MSG_TYPE));
dataMsg->dataRefCountPtr = (int32 *)x_ipcMalloc(sizeof(int32));
*(dataMsg->dataRefCountPtr) = 1;
dataMsg->refCount = 0;
dataMsg->vec = NULL;
dataMsg->msgTotal = msgTotal;
dataMsg->classTotal = classTotal;
dataMsg->parentRef = parentRef;
dataMsg->intent = intent;
dataMsg->classId = classId;
dataMsg->dispatchRef = dispatchRef;
dataMsg->msgRef = msgRef;
#ifdef LISP
LOCK_M_MUTEX;
lispDataFlag = LISP_DATA_FLAG();
UNLOCK_M_MUTEX;
if ((msgTotal != 0) && (msgData == lispDataFlag)) {
dataMsg->msgData = (char *)x_ipcMalloc(msgTotal);
buffer.buffer = dataMsg->msgData;
buffer.bstart = 0;
LOCK_M_MUTEX;
(*(GET_M_GLOBAL(lispEncodeMsgGlobal)))(msgFormat, &buffer);
UNLOCK_M_MUTEX;
dataMsg->vec = x_ipc_createVectorization(msgFormat,
(char *)msgData,dataMsg->msgData,
msgTotal);
} else
#endif
{
x_ipc_encodeMsgData(msgFormat, msgData, dataMsg, 0);
}
if (classTotal) {
dataMsg->classData = (char *)dataMsg + sizeof(DATA_MSG_TYPE);
x_ipc_encodeData(classFormat, classData, dataMsg->classData, 0, classTotal);
}
else
dataMsg->classData = NULL;
/* Include the pointer to the original data. */
dataMsg->dataStruct = (const char *)msgData;
dataMsg->dataByteOrder = BYTE_ORDER;
dataMsg->classByteOrder = BYTE_ORDER;
dataMsg->alignment = (ALIGNMENT_TYPE)ALIGN;
return dataMsg;
}
X_IPC_RETURN_STATUS_TYPE x_ipc_dataMsgRecv(int sd, DATA_MSG_PTR *dataMsg,
int32 replyRef, void *replyBuf,
int32 replyLen)
{
X_IPC_RETURN_STATUS_TYPE status;
DATA_MSG_TYPE header;
*dataMsg = NULL;
LOCK_IO_MUTEX;
status = x_ipc_readNBytes(sd, (char *)&(header.classTotal), HEADER_SIZE());
if (status != StatOK) {
*dataMsg = NULL;
UNLOCK_IO_MUTEX;
return status;
}
NET_INT_TO_INT(header.classTotal);
NET_INT_TO_INT(header.msgTotal);
*dataMsg = x_ipc_dataMsgAlloc(header.classTotal + sizeof(DATA_MSG_TYPE));
**dataMsg = header;
NET_INT_TO_INT((*dataMsg)->parentRef);
NET_INT_TO_INT((*dataMsg)->intent);
NET_INT_TO_INT((*dataMsg)->classId);
NET_INT_TO_INT((*dataMsg)->dispatchRef);
NET_INT_TO_INT((*dataMsg)->msgRef);
if( header.msgTotal > 0) {
(*dataMsg)->dataRefCountPtr = (int32 *)x_ipcMalloc(sizeof(int32));
*((*dataMsg)->dataRefCountPtr) = 1;
} else {
(*dataMsg)->dataRefCountPtr = NULL;
}
(*dataMsg)->refCount = 0;
(*dataMsg)->dataStruct = NULL;
(*dataMsg)->dataByteOrder = GET_DATA_ENDIAN((*dataMsg)->classId);
(*dataMsg)->classByteOrder = GET_CLASS_ENDIAN((*dataMsg)->classId);
(*dataMsg)->alignment = (ALIGNMENT_TYPE)GET_ALIGNMENT((*dataMsg)->classId);
(*dataMsg)->classId = GET_CLASSID((*dataMsg)->classId);
LOCK_M_MUTEX;
GET_M_GLOBAL(byteOrder) = (*dataMsg)->dataByteOrder;
GET_M_GLOBAL(alignment) = (*dataMsg)->alignment;
UNLOCK_M_MUTEX;
if (header.classTotal > 0)
(*dataMsg)->classData = ((char *)*dataMsg + sizeof(DATA_MSG_TYPE));
else
(*dataMsg)->classData = NULL;
/* For now, we only handle packed data. */
if ((*dataMsg)->alignment != ALIGN_PACKED) {
X_IPC_MOD_ERROR("ERROR: received message with data that is not packed.");
UNLOCK_IO_MUTEX;
return StatError;
}
/* Want to be able to use the already allocated buffer, if possible. */
if (((*dataMsg)->msgRef == replyRef) && (replyBuf != NULL) &&
(replyLen == header.msgTotal)) {
(*dataMsg)->msgData = (char *)replyBuf;
(*dataMsg)->dataStruct = (char *)replyBuf;
} else if (header.msgTotal > 0)
(*dataMsg)->msgData = (char *)x_ipcMalloc((unsigned) header.msgTotal);
else
(*dataMsg)->msgData = NULL;
if ((header.msgTotal > 0) && (header.classTotal >0)) {
status = x_ipc_read2Buffers(sd, (*dataMsg)->classData, header.classTotal,
(*dataMsg)->msgData, header.msgTotal);
} else if (header.classTotal > 0) {
status = x_ipc_readNBytes(sd, (*dataMsg)->classData, header.classTotal);
} else if (header.msgTotal > 0) {
status = x_ipc_readNBytes(sd, (*dataMsg)->msgData, header.msgTotal);
}
/* Need to create the vector here. */
(*dataMsg)->vec = (struct iovec *)x_ipcMalloc(2 * sizeof(struct iovec));
(*dataMsg)->vec[0].iov_base = (*dataMsg)->msgData;
(*dataMsg)->vec[0].iov_len = (*dataMsg)->msgTotal;
(*dataMsg)->vec[1].iov_base = NULL;
(*dataMsg)->vec[1].iov_len = 0;
UNLOCK_IO_MUTEX;
return status;
}
