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;
}
IPC_RETURN_TYPE IPC_publish (const char *msgName,
unsigned int length, BYTE_ARRAY content)
{
MSG_PTR msg;
CONST_FORMAT_PTR format;
void *dataToSend;
IPC_VARCONTENT_TYPE vc;
if (!msgName || strlen(msgName) == 0) {
RETURN_ERROR(IPC_Null_Argument);
} else if (!X_IPC_CONNECTED()) {
RETURN_ERROR(IPC_Not_Connected);
} else {
msg = x_ipc_msgFind(msgName);
if (!msg) {
RETURN_ERROR(IPC_Message_Not_Defined);
} else {
format = msg->msgData->msgFormat;
if (ipcDataToSend(format, msgName, length, content, &dataToSend, &vc)
!= IPC_OK) {
PASS_ON_ERROR();
} else {
return ipcReturnValue(x_ipcBroadcast(msgName, dataToSend));
}
}
}
}
IPC_RETURN_TYPE IPC_queryNotify (const char *msgName,
unsigned int length, BYTE_ARRAY content,
HANDLER_TYPE handler, void *clientData)
{
MSG_PTR msg;
void *queryData;
IPC_VARCONTENT_TYPE vc;
if (!msgName || strlen(msgName) == 0) {
RETURN_ERROR(IPC_Null_Argument);
} else if (!X_IPC_CONNECTED()) {
RETURN_ERROR(IPC_Not_Connected);
} else {
msg = x_ipc_msgFind(msgName);
if (msg == NULL) {
RETURN_ERROR(IPC_Message_Not_Defined);
} else if (ipcDataToSend(msg->msgData->msgFormat, msgName,
length, content, &queryData, &vc) != IPC_OK) {
PASS_ON_ERROR();
} else {
return ipcReturnValue(x_ipc_queryNotifySend(msg, msgName, queryData,
(REPLY_HANDLER_FN)handler,
clientData));
}
}
}
IPC_RETURN_TYPE IPC_respond (MSG_INSTANCE msgInstance, const char *msgName,
unsigned int length, BYTE_ARRAY content)
{
MSG_PTR msg;
void *replyData;
IPC_VARCONTENT_TYPE vc;
if (!msgName || strlen(msgName) == 0) {
RETURN_ERROR(IPC_Null_Argument);
} else if (!msgInstance) {
RETURN_ERROR(IPC_Null_Argument);
} else if (!X_IPC_CONNECTED()) {
RETURN_ERROR(IPC_Not_Connected);
} else {
msg = x_ipc_msgFind(msgName);
if (!msg) {
RETURN_ERROR(IPC_Message_Not_Defined);
} else if (ipcDataToSend(msg->msgData->msgFormat, msgName,
length, content, &replyData, &vc) != IPC_OK) {
PASS_ON_ERROR();
} else {
return ipcReturnValue(x_ipc_sendResponse(msgInstance, msg,
(char *)replyData,
ReplyClass, NULL,
msgInstance->responseSd));
}
}
}
X_IPC_REF_PTR x_ipcReserveModResource(const char *modName, const char *resName)
{
int32 refId;
MSG_PTR msg;
X_IPC_REF_PTR ref;
ADD_HND_FORM_TYPE addForm;
addForm.hndName = modName;
addForm.resName = resName;
refId = 0;
if (x_ipcQuery(X_IPC_RESERVE_MOD_RESOURCE_QUERY, (void *)&addForm,
(void *)&refId) != Success)
return NULL;
if (refId < 0) {
X_IPC_MOD_WARNING( "\nWARNING: Ignoring reservation request.\n");
X_IPC_MOD_WARNING2( "%s of module %s is already reserved by this module.\n",
resName, modName);
ref = CREATE_NULL_REF();
}
else {
msg = x_ipc_msgFind(X_IPC_RESERVE_MOD_RESOURCE_QUERY);
if (msg == NULL) return NULL;
ref = x_ipcRefCreate(msg, X_IPC_RESERVE_MOD_RESOURCE_QUERY, refId);
}
return ref;
}
X_IPC_REF_PTR x_ipcReserveResource(const char *resName)
{
int32 refId;
MSG_PTR msg;
X_IPC_REF_PTR ref;
refId = 0;
if (x_ipcQuery(X_IPC_RESERVE_RESOURCE_QUERY, (void *)&resName, (void *)&refId)
!= Success)
return NULL;
if (refId < 0) {
X_IPC_MOD_WARNING( "\nWARNING: Ignoring reservation request.\n");
X_IPC_MOD_WARNING1( "%s is already reserved by this module.\n", resName);
ref = CREATE_NULL_REF();
}
else {
msg = x_ipc_msgFind(X_IPC_RESERVE_RESOURCE_QUERY);
if (msg == NULL) return NULL;
ref = x_ipcRefCreate(msg, X_IPC_RESERVE_RESOURCE_QUERY, refId);
}
return ref;
}
X_IPC_RETURN_VALUE_TYPE centralInform(const char *name, const void *data)
{
MSG_PTR msg;
msg = x_ipc_msgFind(name);
if (msg == NULL) return MsgUndefined;
x_ipc_checkMessageClass(msg, InformClass);
return centralSendMessage((X_IPC_REF_PTR)NULL, msg,
(char *)data, (char *)NULL);
}
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;
}
X_IPC_RETURN_VALUE_TYPE centralBroadcast(const char *name, const void *data)
{
MSG_PTR msg;
msg = x_ipc_msgFind(name);
if (msg == NULL) return MsgUndefined;
x_ipc_checkMessageClass(msg, BroadcastClass);
if ((GET_C_GLOBAL(broadcastMsgs) == NULL) ||
(x_ipc_strListMemberItem(name, GET_C_GLOBAL(broadcastMsgs))))
return centralSendMessage((X_IPC_REF_PTR)NULL, msg,
(char *)data, (char *)NULL);
else
return Success;
}
X_IPC_REF_PTR x_ipcLockResource(const char *resName)
{
int32 refId;
MSG_PTR msg;
X_IPC_REF_PTR ref;
if (x_ipcQuery(X_IPC_LOCK_RESOURCE_QUERY, (void *)&resName, (void *)&refId)
!= Success)
return NULL;
msg = x_ipc_msgFind(X_IPC_LOCK_RESOURCE_QUERY);
if (msg == NULL) return NULL;
ref = x_ipcRefCreate(msg, X_IPC_LOCK_RESOURCE_QUERY, refId);
return ref;
}
X_IPC_REF_PTR x_ipcLockModResource(const char *modName, const char *resName)
{
int32 refId;
MSG_PTR msg;
X_IPC_REF_PTR ref;
ADD_HND_FORM_TYPE addForm;
addForm.hndName = modName;
addForm.resName = resName;
if (x_ipcQuery(X_IPC_LOCK_MOD_RESOURCE_QUERY,
(void *)&addForm, (void *)&refId) != Success)
return NULL;
msg = x_ipc_msgFind(X_IPC_LOCK_MOD_RESOURCE_QUERY);
if (msg == NULL) return NULL;
ref = x_ipcRefCreate(msg, X_IPC_LOCK_MOD_RESOURCE_QUERY, refId);
return ref;
}
X_IPC_RETURN_VALUE_TYPE x_ipc_sendResponse(X_IPC_REF_PTR ref, MSG_PTR msg,
void *resData,
X_IPC_MSG_CLASS_TYPE resClass,
void *resClassData,
int sd)
{
int32 intent=-1, refId,msgId=-1;
CONST_FORMAT_PTR format;
DATA_MSG_PTR dataMsg;
CLASS_FORM_PTR classForm;
CONST_FORMAT_PTR classFormat;
X_IPC_RETURN_STATUS_TYPE result;
#ifdef NMP_IPC
if (ref->responded == TRUE) {
/* Already responded -- something is wrong! */
X_IPC_MOD_ERROR2("x_ipc_sendResponse: Already responed to instance %d (%s)\n",
ref->refId, ref->msg->msgData->name);
}
#endif
classFormat = NULL;
format = NULL;
if (msg) {
#ifndef NMP_IPC
intent = msg->msgData->refId;
format = msg->msgData->resFormat;
#else
/* The only place X_IPC calls this function with "msg" set is in
fireDemon. Since IPC doesn't use that, we should be safe using
"msg" for another reason */
format = msg->msgData->msgFormat;
if (!ref->msg) {
ref->msg = x_ipc_msgFind(ref->name);
if (ref->msg == NULL) return MsgUndefined;
}
if (ref->msg->direct) {
intent = QUERY_REPLY_INTENT;
msgId = ref->refId;
} else {
intent = -1;
}
/* We have to "fool" the receiver of the response into using this
message for encoding/decoding, rather than the query message.
Not pretty, but it works. Depends on the fact that ReplyClass has
no class data. Later, rework central so that it knows how to handle
this case explicitly. */
{ int resClass1 = ExecHndClass;
/* Format for ExecHndClass is "string" -- used to send the message name */
LOCK_M_MUTEX;
classForm = GET_CLASS_FORMAT(&resClass1);
UNLOCK_M_MUTEX;
classFormat = classForm->format;
resClassData = (void *)&(msg->msgData->name);
}
#endif
} else {
if (ref) {
if (!ref->msg) {
ref->msg = x_ipc_msgFind(ref->name);
if (ref->msg == NULL) return MsgUndefined;
}
if (resData != NULL)
format = ref->msg->msgData->resFormat;
msg = ref->msg;
if (msg->direct){
intent = QUERY_REPLY_INTENT;
msgId = ref->refId;
} else {
intent = -1;
}
}
}
LOCK_M_MUTEX;
classForm = GET_CLASS_FORMAT(&resClass);
UNLOCK_M_MUTEX;
if (classForm)
classFormat = classForm->format;
refId = (ref ? ref->refId : NO_REF);
LOCK_CM_MUTEX;
dataMsg = x_ipc_dataMsgCreate(GET_C_GLOBAL(parentRefGlobal), intent,
(int32)resClass,
refId, msgId, (FORMAT_PTR)format, resData,
(FORMAT_PTR)classFormat, resClassData);
UNLOCK_CM_MUTEX;
if (dataMsg == NULL) return Failure;
result = x_ipc_dataMsgSend(sd, dataMsg);
#ifdef NMP_IPC
if (result == StatOK) {
if (ref->responded == -1) {
/* Happening outside of the handler -- nuke the reference */
x_ipcRefFree(ref);
} else
ref->responded = TRUE;
}
#endif
x_ipc_dataMsgFree(dataMsg);
return (result != StatOK ? Failure : Success);
}
