void dispatchSetResData(DATA_MSG_PTR resData, DISPATCH_PTR dispatch)
{
x_ipc_dataMsgFree(dispatch->resData);
dispatch->resData = resData;
if (resData)
(resData->refCount)++;
}
void dispatchSetMsgData(DATA_MSG_PTR msgData, DISPATCH_PTR dispatch)
{
x_ipc_dataMsgFree(dispatch->msgData);
dispatch->msgData = msgData;
if (msgData)
(msgData->refCount)++;
}
void dispatchFree(DISPATCH_PTR dispatch)
{
if (dispatch->refCount <= 0 &&
dispatch->status != UnallocatedDispatch) { /* 5-13-93 reids: Changed */
dispatch->refId = NO_REF;
dispatch->orgId = 0;
dispatch->desId = 0;
dispatch->pRef = NO_REF; /* 9-Jul-90: fedor: change to ROOT_NODE */
dispatch->org = NULL;
dispatch->des = NULL;
dispatch->msg = NULL;
dispatch->hnd = NULL;
dispatch->resource = NULL;
#ifndef NMP_IPC
dispatch->treeNode = NULL;
#endif
dispatch->blockCom = NULL;
dispatch->status = UnallocatedDispatch;
x_ipc_dataMsgFree(dispatch->msgData);
x_ipc_dataMsgFree(dispatch->resData);
dispatch->msgData = NULL;
dispatch->resData = NULL;
/* Command class data is stored in "blockCom"; It has already been freed */
if (dispatch->msg_class != CommandClass)
x_ipc_classDataFree(dispatch->msg_class, dispatch->classData);
dispatch->classData = NULL;
dispatch->msg_class = UNKNOWN;
dispatch->respProc = NULL;
dispatch->respData = NULL;
freeTapInfo(&(dispatch->tapInfo));
dispatch->tapInfo = NULL;
dispatch->refCount = 0;
dispatch->next = GET_S_GLOBAL(dispatchFreeListGlobal);
GET_S_GLOBAL(dispatchFreeListGlobal) = dispatch;
}
}
DATA_MSG_PTR x_ipc_dataMsgReplaceClassData(CONST_FORMAT_PTR classFormat,
void *data,
DATA_MSG_PTR dataMsg,
CONST_FORMAT_PTR msgFormat)
{
#ifdef UNUSED_PRAGMA
#pragma unused(msgFormat)
#endif
DATA_MSG_PTR newDataMsg;
int32 classTotal=0;
if (data && classFormat)
classTotal = x_ipc_bufferSize(classFormat, data);
newDataMsg = x_ipc_dataMsgAlloc(sizeof(DATA_MSG_TYPE)+classTotal);
/* 3-Sep-90: fedor: this should work because class info is in the
dataMsg struture as the last item. */
BCOPY((char *)dataMsg, (char *)newDataMsg, sizeof(DATA_MSG_TYPE));
if (classTotal) {
newDataMsg->classData = ((char *)newDataMsg + sizeof(DATA_MSG_TYPE));
x_ipc_encodeData(classFormat, data, newDataMsg->classData, 0, classTotal);
newDataMsg->classByteOrder = BYTE_ORDER;
}
else
newDataMsg->classData = NULL;
/* reset msgData pointer */
newDataMsg->msgData = dataMsg->msgData;
newDataMsg->dataStruct = dataMsg->dataStruct;
dataMsg->msgData = NULL;
/* Need to copy the vector data. */
if (dataMsg->vec != NULL)
newDataMsg->vec = x_ipc_copyVectorization(dataMsg->vec,0);
else {
X_IPC_MOD_ERROR("Internal Error: Missing data Vector\n");
return NULL;
}
/* set refCount */
newDataMsg->dataRefCountPtr = dataMsg->dataRefCountPtr;
if ( newDataMsg->dataRefCountPtr != NULL)
(*(newDataMsg->dataRefCountPtr))++;
newDataMsg->refCount = 0;
newDataMsg->classTotal = classTotal;
if (x_ipc_dataMsgFree(dataMsg) != NULL)
dataMsg->msgData = newDataMsg->msgData;
return newDataMsg;
}
static void recvReplyMessage (DISPATCH_PTR dispatch)
{
dispatchUpdateAndDisplay(HandledDispatch, dispatch);
resourceRemoveAttending(dispatch);
/* Added for safety, the dispatch message could have been
* freed if there was an error. */
if ((dispatch->msg == NULL) || (dispatch->msg->msgData == NULL))
return;
if (dispatch->msg->msgData->msg_class != MultiQueryClass ||
MULTI_QUERY_MAX(dispatch) > 0) {
deliverResponse(dispatch);
tapAfterReplied(dispatch);
tapAfterHandled(dispatch);
}
#ifndef NMP_IPC
if (dispatch->msg->msgData->msg_class == MultiQueryClass) {
multiQueryUpdate(dispatch, TRUE);
}
#endif
/* 31-Oct-90: fedor: problem with replies that are not simply
replies to standard query messages ...etc. sooo we need to
keep the dispatch around but perhaps not the datamsg.
This just postpones the eventual memory lossage */
x_ipc_dataMsgFree(dispatch->msgData);
x_ipc_dataMsgFree(dispatch->resData);
dispatch->msgData = NULL;
dispatch->resData = NULL;
/* 31-Oct-90: fedor: also need to do free before processing further
otherwise we may loop and never free anything */
resourceProcessPending(dispatch);
/* 02-Jul-91: reid: Centrally handled dispatch queries are
* freed in "processResAttendDeliver"
*/
if (dispatch->des != GET_S_GLOBAL(x_ipcServerModGlobal))
dispatchFree(dispatch);
}
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;
}
static CONST_FORMAT_PTR x_ipc_formatterRecv(int sd)
{
DATA_MSG_PTR dataMsg = NULL;
CONST_FORMAT_PTR *pointerToFormat;
CONST_FORMAT_PTR format;
NAMED_FORMAT_PTR formatFormat;
LOCK_M_MUTEX;
formatFormat = (NAMED_FORMAT_PTR)
x_ipc_hashTableFind("format", GET_M_GLOBAL(formatNamesTable));
UNLOCK_M_MUTEX;
if (!formatFormat) {
X_IPC_MOD_ERROR("ERROR: x_ipc_formatterRecv: no formatFormat");
}
switch(x_ipc_dataMsgRecv(sd, &dataMsg, 0, NULL, 0)){
case StatOK:
pointerToFormat = (CONST_FORMAT_PTR *)
x_ipc_dataMsgDecodeMsg(formatFormat->format, dataMsg, FALSE);
x_ipc_dataMsgFree(dataMsg);
format = *pointerToFormat;
x_ipcFree((void *)pointerToFormat);
return(format);
case StatError:
X_IPC_MOD_ERROR("ERROR: foramatterRecv: x_ipc_dataMsgRecv: StatError:");
/*NOTREACHED*/
break;
case StatEOF:
X_IPC_MOD_ERROR("ERROR: foramatterRecv: x_ipc_dataMsgRecv: StatEOF:");
/*NOTREACHED*/
break;
case StatSendEOF:
case StatSendError:
case StatRecvEOF:
case StatRecvError:
X_IPC_MOD_ERROR("ERROR: foramatterRecv: x_ipc_dataMsgRecv: Unexpected error \n");
break;
#ifndef TEST_CASE_COVERAGE
default:
X_IPC_MOD_ERROR("ERROR: foramatterRecv: x_ipc_dataMsgRecv: UNKNOWN:");
/*NOTREACHED*/
#endif
}
return ( CONST_FORMAT_PTR) NULL;
}
static void formatterSend(int sd, CONST_FORMAT_PTR form)
{
DATA_MSG_PTR dataMsg;
NAMED_FORMAT_PTR formatFormat;
formatFormat =
(NAMED_FORMAT_PTR)x_ipc_hashTableFind("format",
GET_M_GLOBAL(formatNamesTable));
if (!formatFormat) {
X_IPC_ERROR("ERROR: formatterSend: no formatFormat");
}
dataMsg = x_ipc_dataMsgCreate(0, 0, 0, 0, 0, formatFormat->format, (void *)&form,
(FORMAT_PTR)NULL, (void *)NULL);
(void)x_ipc_dataMsgSend(sd, dataMsg);
x_ipc_dataMsgFree(dataMsg);
}
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);
}
X_IPC_RETURN_VALUE_TYPE x_ipc_sendMessage(X_IPC_REF_PTR ref, MSG_PTR msg,
void *msgData, void *classData,
int32 preallocatedRefId)
{
int32 refId, savedRef, i, sd;
DATA_MSG_PTR msgDataMsg;
X_IPC_MSG_CLASS_TYPE msg_class;
CLASS_FORM_PTR classForm;
CONST_FORMAT_PTR classFormat;
X_IPC_RETURN_STATUS_TYPE result;
DIRECT_MSG_HANDLER_PTR direct;
CONNECTION_PTR connection;
classFormat = NULL;
if (!msg) {
X_IPC_MOD_ERROR("ERROR: x_ipc_sendMessage: NULL msg.\n");
}
if (!x_ipc_isValidServerConnection()) {
X_IPC_MOD_ERROR("ERROR: Must be connected to the server to send a message");
return Failure;
}
/* save the message ref to use in case x_ipc_msgFind triggers
a recursive call to x_ipc_sendMessage */
LOCK_CM_MUTEX;
savedRef = (preallocatedRefId != NO_REF ? preallocatedRefId
: x_ipc_nextSendMessageRef());
msg_class = msg->msgData->msg_class;
classForm = GET_CLASS_FORMAT(&msg_class);
if (classForm)
classFormat = classForm->format;
refId = (ref ? ref->refId : NO_REF);
/* RTG For now, only do direct if no logging. */
msgDataMsg = x_ipc_dataMsgCreate(GET_C_GLOBAL(parentRefGlobal), -1,
(int32)msg_class, refId, savedRef,
msg->msgData->msgFormat, msgData,
(FORMAT_PTR)classFormat, classData);
UNLOCK_CM_MUTEX;
if (msgDataMsg == NULL) {
X_IPC_MOD_ERROR1("Unable to send message %s, probably a bad format\n",
msg->msgData->name);
return Failure;
}
if (!msg->direct || !msg->directList || msg->directList->numHandlers == 0) {
msgDataMsg->intent = msg->msgData->refId;
LOCK_CM_MUTEX;
sd = GET_C_GLOBAL(serverWrite);
UNLOCK_CM_MUTEX;
result = x_ipc_dataMsgSend(sd, msgDataMsg);
} else {
/* Send in reverse order (to match what happens within central) */
for (i=msg->directList->numHandlers-1, result=StatOK;
i>=0 && result == StatOK; i--) {
direct = &(msg->directList->handlers[i]);
if (direct->readSd >= 0) {
msgDataMsg->intent = direct->intent;
result = x_ipc_dataMsgSend(direct->writeSd, msgDataMsg);
if (result == StatError && errno == EPIPE) {
fprintf(stderr, "Need to close %d\n", direct->writeSd);
LOCK_CM_MUTEX;
connection = (CONNECTION_PTR)x_ipc_hashTableFind((void *)&direct->writeSd,
GET_C_GLOBAL(moduleConnectionTable));
UNLOCK_CM_MUTEX;
if (connection) {
x_ipcHandleClosedConnection(direct->writeSd, connection);
result = StatOK;
}
}
}
}
}
x_ipc_dataMsgFree(msgDataMsg);
if (result != StatOK)
return Failure;
return Success;
}
