void releaseDispatch(DISPATCH_PTR dispatch)
{
if (dispatch) {
if (dispatch->refCount == 0) {
LOG2("\nWARNING: Releasing an unreserved dispatch %s (%d)\n",
dispatch->msg->msgData->name, dispatch->locId);
} else {
dispatch->refCount--;
}
if (dispatch->refCount <= 0) {
#ifndef NMP_IPC
HandleKillAfterAttendingNodes(dispatch);
if ((dispatch->status == HandledDispatch) && !dispatch->treeNode) {
dispatchFree(dispatch);
#else
if (dispatch->status == HandledDispatch) {
dispatchFree(dispatch);
#endif
}
}
}
}
/******************************************************************************
*
* FUNCTION: void dispatchStats
*
* DESCRIPTION: Print stats about the utilization of dispatches in central
*
* INPUTS:
*
* OUTPUTS:
*
*****************************************************************************/
#if 0
/* No longer used */
void dispatchStats ()
{
int32 i, num=0;
DISPATCH_PTR dispatch;
for (i=0; i<GET_S_GLOBAL(dispatchTable)->currentSize; i++) {
dispatch = (DISPATCH_PTR)idTableItem(i, GET_S_GLOBAL(dispatchTable));
if (dispatch->status != UnallocatedDispatch) {
printf("%d. %s\n", ++num, dispatch->msg->msgData->name);
}
}
}
void x_ipcError(const char *description, ...)
{
if (!GET_S_GLOBAL(terminalLog).quiet)
x_ipcStats(stderr);
if (description) {
va_list args;
char msg[150];
va_start(args, description);
vsprintf(msg, (char *)description, args);
va_end(args);
if (x_ipc_LogMessagesP()) {
LOG1("%s\n", msg);
} else {
fprintf(stderr,"%s\n", msg);
}
}
End_File_Logging();
#if 0
(void)printf("Dump core [y]?\n");
if (getchar() != 'n')
abort();
#endif
serverShutdown();
exit(1);
}
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);
}
static void dispatchIncrementFreeList(void)
{
int32 i;
DISPATCH_PTR newPtr, current; /* JGraham, 8/19/97, changed variable
name, new, to newPtr for g++ */
current = NULL;
for(i=0;i<DISPATCH_FREE_INC;i++) {
newPtr = NEW(DISPATCH_TYPE);
newPtr->refId = NO_REF;
newPtr->orgId = 0;
newPtr->desId = 0;
newPtr->pRef = NO_REF; /* 9-Jul-90: fedor: change to ROOT_NODE */
newPtr->org = NULL;
newPtr->des = NULL;
newPtr->msg = NULL;
newPtr->hnd = NULL;
newPtr->resource = NULL;
newPtr->msgData = NULL;
newPtr->resData = NULL;
#ifndef NMP_IPC
newPtr->treeNode = NULL;
#endif
newPtr->blockCom = NULL;
newPtr->status = UnallocatedDispatch;
newPtr->classData = NULL;
newPtr->msg_class = UNKNOWN;
newPtr->respProc = NULL;
newPtr->respData = NULL;
newPtr->tapInfo = NULL;
newPtr->refCount = 0;
newPtr->locId = x_ipc_idTableInsert((char *)newPtr, GET_S_GLOBAL(dispatchTable));
newPtr->next = current;
current = newPtr;
}
GET_S_GLOBAL(dispatchFreeListGlobal) = current;
}
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;
}
}
DISPATCH_PTR dispatchAllocate(void)
{
DISPATCH_PTR tmp;
if (!GET_S_GLOBAL(dispatchFreeListGlobal))
dispatchIncrementFreeList();
tmp = GET_S_GLOBAL(dispatchFreeListGlobal);
GET_S_GLOBAL(dispatchFreeListGlobal) =
GET_S_GLOBAL(dispatchFreeListGlobal)->next;
tmp->next = NULL;
DISPATCH_SET_STATUS(AllocatedDispatch, tmp);
return tmp;
}
void deliverDispatch(DISPATCH_PTR dispatch)
{
char *data;
DATA_MSG_PTR newDataMsg;
X_IPC_MSG_CLASS_TYPE msg_class;
CLASS_FORM_PTR classForm;
data = NULL;
dispatchUpdateAndDisplay(AttendingDispatch, dispatch);
if (dispatch->des == GET_S_GLOBAL(x_ipcServerModGlobal)) {
if (monitorClass(dispatch->msg->msgData->msg_class)) {
data = dispatch->classData;
} else {
data = (char *)x_ipc_dataMsgDecodeMsg(dispatch->msg->msgData->msgFormat,
DISPATCH_MSG_DATA(dispatch),TRUE);
}
(*dispatch->hnd->hndProc)(dispatch, data);
if (dispatch->msg_class == InformClass) {
dispatchUpdateAndDisplay(HandledDispatch, dispatch);
}
} else {
if (dispatch->hnd->msg != dispatch->msg) {
/* handler to recieve new message */
msg_class = ExecHndClass;
classForm = GET_CLASS_FORMAT(&msg_class);
if (!classForm)
X_IPC_ERROR("ERROR: deliverDispatch: missing ExecHndClass class format.");
newDataMsg =
x_ipc_dataMsgReplaceClassData(classForm->format,
(char*)&dispatch->msg->msgData->name,
dispatch->msgData,
dispatch->msg->msgData->msgFormat
);
/* 31-Oct-90: fedor: the x_ipc_dataMsgReplaceClassData routine calls
x_ipc_dataMsgFree - this avoids calling it twice and gets the
refs correct. blah! */
dispatch->msgData = NULL;
dispatchSetMsgData(newDataMsg, dispatch);
}
else {
/* The datamags may already have old class data.
Since class data follows message data, this
will prevent old class data from being sent. */
dispatch->msgData->classTotal = 0;
}
dispatch->msgData->intent = dispatch->hnd->hndData->refId;
dispatch->msgData->msgRef = dispatch->locId;
(void)x_ipc_dataMsgSend(dispatch->desId, dispatch->msgData);
}
}
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 globalVarInitialize(void)
*
* DESCRIPTION:
*
* INPUTS:
*
* OUTPUTS: void
*
*****************************************************************************/
void globalVarInitialize(void)
{
/* Create the table to hold the information for each global variable. */
GET_S_GLOBAL(varTable) = x_ipc_hashTableCreate(11, (HASH_FN) x_ipc_strHashFunc,
(EQ_HASH_FN)x_ipc_strKeyEqFunc);
/* Register the handler for creating the global variable */
centralRegisterInform(X_IPC_REGISTER_VAR_INFORM,
X_IPC_REGISTER_VAR_INFORM_FORMAT,
registerVarHnd);
Add_Message_To_Ignore(X_IPC_REGISTER_VAR_INFORM);
centralRegisterInform(X_IPC_REGISTER_VAR_INFORM_OLD,
X_IPC_REGISTER_VAR_INFORM_FORMAT,
registerVarHnd);
Add_Message_To_Ignore(X_IPC_REGISTER_VAR_INFORM_OLD);
centralRegisterVar(X_IPC_TERMINAL_LOG_VAR, X_IPC_LOG_VAR_FORMAT);
centralRegisterVar(X_IPC_FILE_LOG_VAR, X_IPC_LOG_VAR_FORMAT);
centralIgnoreVarLogging(X_IPC_TERMINAL_LOG_VAR);
centralIgnoreVarLogging(X_IPC_FILE_LOG_VAR);
centralSetVar(X_IPC_TERMINAL_LOG_VAR, (char *)&GET_S_GLOBAL(terminalLog));
centralSetVar(X_IPC_FILE_LOG_VAR, (char *)&GET_S_GLOBAL(fileLog));
}
void processResAttendDeliver(DISPATCH_PTR dispatch)
{
resourceAttending(dispatch);
#ifndef NMP_IPC
AttendingConstraints(dispatch);
#endif
deliverDispatch(dispatch);
tapWhileHandling(dispatch);
/* 02-Jul-91: Reid:
* Just handled a central query or inform:
* It's OK to free the dispatch here
*/
if (dispatch->msg_class == ReplyClass ||
(dispatch->msg_class == InformClass &&
dispatch->des == GET_S_GLOBAL(x_ipcServerModGlobal)))
dispatchFree(dispatch);
}
static DISPATCH_HND_PTR chooseMsgHandler(MSG_PTR msg)
{
int32 size;
LIST_PTR hndList;
DISPATCH_HND_PTR hnd, nextHnd, retHnd;
hndList = msg->hndList;
size = x_ipc_listLength(hndList);
hnd = (DISPATCH_HND_PTR)x_ipc_listFirst(hndList);
if (!size) {
size = 1;
hnd = NEW(DISPATCH_HND_TYPE);
hnd->sd = 0;
hnd->localId =0;
hnd->msg = NULL;
hnd->hndProc = NULL;
hnd->hndOrg = GET_S_GLOBAL(x_ipcServerModGlobal);
hnd->hndData = NULL;
hnd->msgList = NULL;
hnd->resource = resourceCreate(0, 0, msg->msgData->name, 1);
hnd->resource->capacity = 0;
hnd->hndLanguage = C_LANGUAGE;
#ifdef NMP_IPC
hnd->clientData = NO_CLIENT_DATA;
#endif
x_ipc_listInsertItem((char *)hnd, msg->hndList);
}
if (size > 1) {
retHnd = hnd;
nextHnd = (DISPATCH_HND_PTR)x_ipc_listNext(hndList);
while (nextHnd && nextHnd->hndData &&
STREQ(hnd->hndData->hndName, nextHnd->hndData->hndName)) {
if (resourceAvailableRes(nextHnd->resource))
retHnd = nextHnd;
nextHnd = (DISPATCH_HND_PTR)x_ipc_listNext(hndList);
}
hnd = !nextHnd ? retHnd : NULL;
}
return hnd;
}
static void getVarHnd(DISPATCH_PTR dispatch, void *empty)
{
#ifdef UNUSED_PRAGMA
#pragma unused(empty)
#endif
GLOBAL_VAR_PTR var=NULL;
const char *msgName;
const char *varName;
msgName = dispatch->msg->msgData->name;
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 {
centralReply(dispatch, (char *)var->value);
}
}
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);
}
static void getSetVarHnd(DISPATCH_PTR dispatch, void *varValue)
{
GLOBAL_VAR_PTR var=NULL;
const char *msgName;
const char *varName;
msgName = dispatch->msg->msgData->name;
varName = &(msgName[strlen(VAR_GET_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) {
centralReply(dispatch, (char *)var->value);
x_ipcFreeData(msgName,var->value);
}
/* Store the pointer to the new data */
var->value = varValue;
}
}
DISPATCH_PTR buildDispatchInternal(MSG_PTR msg, DATA_MSG_PTR dataMsg,
void *classData,
DISPATCH_PTR parentDispatch,
RESP_PROC_FN resProc, void *resData)
{
int32 savedRef;
DISPATCH_PTR dispatch;
if (!msg) {
X_IPC_ERROR("ERROR: sendDataMsg: 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();
dispatch = dispatchAllocate();
dispatch->msg = msg;
dispatch->org = GET_S_GLOBAL(x_ipcServerModGlobal);
dispatch->orgId = GET_C_GLOBAL(serverWrite);
dispatch->refId = savedRef;
dispatchSetMsgData(dataMsg, dispatch);
if (resProc) {
dispatch->respProc = resProc;
dispatch->respData = (char *)resData;
}
if (parentDispatch)
dispatch->pRef = parentDispatch->locId;
dispatch->msg_class = msg->msgData->msg_class;
dispatch->classData = (char *)classData;
return dispatch;
}
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;
}
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);
}
static void dispatchUpdateAndDisplay1(DISPATCH_STATUS_TYPE newStatus,
DISPATCH_PTR dispatch)
{
int32 error = FALSE, printed = TRUE;
int32 parentId;
DISPATCH_PTR parent_dispatch;
X_IPC_MSG_CLASS_TYPE msg_class, mclass;
#ifndef NMP_IPC
parent_dispatch = findParentDispatch(dispatch);
#else
parent_dispatch = NULL;
#endif
parentId = (parent_dispatch ? parent_dispatch->locId : dispatch->pRef);
msg_class = dispatch->msg_class;
/* 30Aug93: fedor: Replaced msgName = dispatch->msg->msgData->name
with DISPATCH_MSG_NAME because the message name may not
always be defined for a dispatch. See HandledDispatch - FailureClass */
switch(dispatch->status) {
case AllocatedDispatch:
switch(newStatus) {
case AttendingDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1(": %10s", dispatch->org->modData->modName);
Log_ParentId(parentId, LOGGING_MESSAGE);
LOG_MESSAGE1(" --> %-15s (Sent)", dispatch->des->modData->modName);
break;
case PendingDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1(": %10s", dispatch->org->modData->modName);
Log_ParentId(parentId, LOGGING_MESSAGE);
LOG_MESSAGE1(" --> Resource %-6s (Pending)",
dispatch->hnd->resource->name);
break;
case InactiveDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1(": %10s", dispatch->org->modData->modName);
Log_ParentId(parentId, LOGGING_MESSAGE);
LOG_MESSAGE(" --> ON HOLD (Inactive)");
break;
case HandledDispatch:
if (msg_class == FailureClass) {
LOG_MESSAGE2("Failure %15s: %s",
"*Top Level*", *(char **)dispatch->classData);
}
break;
default:
error = TRUE;
break;
}
break;
case PendingDispatch:
switch(newStatus) {
case AttendingDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE2(": Resource %s --> %-15s (Sent)",
dispatch->hnd->resource->name,
dispatch->des->modData->modName);
break;
default:
error = TRUE;
break;
}
break;
case CentralPendingDispatch:
switch(newStatus) {
case AttendingDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1(": %10s", dispatch->org->modData->modName);
Log_ParentId(parentId, LOGGING_MESSAGE);
LOG_MESSAGE1(" --> %-15s (Sent)", dispatch->des->modData->modName);
break;
default:
error = TRUE;
break;
}
break;
case AttendingDispatch:
switch(newStatus) {
case HandledDispatch:
if (TWO_WAY_MSG(dispatch->msg)) {
LOG_MESSAGE1(" Reply %15s", DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE2(": %10s --> %-15s", dispatch->des->modData->modName,
dispatch->org->modData->modName);
Log_ParentId(parentId, LOGGING_MESSAGE);
if (!dispatch->org->alive) {
LOG_MESSAGE1("\nWARNING: Reply Ignored for dead module: %s",
dispatch->org->modData->modName);
}
} else if (monitorClass(msg_class)) {
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE(": (Completed)");
} else if (msg_class == SuccessClass ||
(msg_class == InformClass &&
dispatch->des == GET_S_GLOBAL(x_ipcServerModGlobal))) {
mclass = dispatch->msg->msgData->msg_class;
if (mclass == InformClass || mclass == BroadcastClass) {
LOG_MESSAGE(" Done ");
} else {
LOG_MESSAGE(" Success ");
}
LOG_MESSAGE1("%15s", DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE(":");
} else if (msg_class == FailureClass) {
LOG_MESSAGE1(" Failure %15s", DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1(": %s", *(char **)dispatch->classData);
} else if (msg_class == ReplyClass) {
LOG_MESSAGE1(" Reply %15s", DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
#ifdef NMP_IPC
LOG_MESSAGE2(": %10s --> %-15s",
dispatch->des->modData->modName,
dispatch->org->modData->modName);
#else
LOG_MESSAGE2(": %10s --> %-15s",
GET_S_GLOBAL(x_ipcServerModGlobal)->modData->modName,
dispatch->org->modData->modName);
#endif
Log_ParentId(parentId, LOGGING_MESSAGE);
} else {
printed = FALSE;
}
break;
case CentralPendingDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1(": %10s", dispatch->org->modData->modName);
Log_ParentId(parentId, LOGGING_MESSAGE);
LOG_MESSAGE1(" --> %-15s (Pending)", dispatch->des->modData->modName);
break;
default:
error = TRUE;
break;
}
break;
case InactiveDispatch:
LOG_MESSAGE2("%-9s %15s", x_ipc_messageClassName(msg_class),
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE(": ON HOLD ");
switch(newStatus) {
case AttendingDispatch:
LOG_MESSAGE1(" --> %-15s (Sent)", dispatch->des->modData->modName);
break;
case PendingDispatch:
LOG_MESSAGE1(" --> Resource %-6s (Pending)",
dispatch->hnd->resource->name);
break;
default:
error = TRUE;
break;
}
break;
default:
error = TRUE;
break;
}
if (error) {
LOG_MESSAGE1("\nWARNING: dispatchUpdateAndDisplay: %s",
DISPATCH_MSG_NAME(dispatch));
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE2(": %s --> %s", dispatchStatusName(dispatch->status),
dispatchStatusName(newStatus));
}
if (printed) {
Log_Time(1);
LOG_MESSAGE("\n");
}
}
void recvMessage(DISPATCH_PTR dispatch, X_IPC_MSG_CLASS_TYPE msg_class,
void *classData)
{
#ifdef UNUSED_PRAGMA
#pragma unused(classData)
#endif
if (GET_S_GLOBAL(x_ipcDebugGlobal)) {
x_ipc_idTablePrintInfo(GET_S_GLOBAL(dispatchTable));
X_IPC_MOD_WARNING("\n");
x_ipcStats(stderr);
}
switch(msg_class) {
case QueryClass:
case InformClass:
tapWhenSent(dispatch);
processActiveMessage(dispatch);
break;
case ReplyClass:
recvReplyMessage(dispatch);
break;
#ifndef NMP_IPC
case GoalClass:
case PointMonitorClass:
case DemonMonitorClass:
case PollingMonitorClass:
case ExceptionClass:
case CommandClass:
recvTaskTreeMessage(dispatch, msg_class, classData);
break;
#endif
case BroadcastClass:
recvBroadcastMessage(dispatch);
break;
#ifndef NMP_IPC
case MultiQueryClass:
recvMultiQueryMessage(dispatch);
break;
#endif
case SuccessClass:
case FailureClass:
recvSuccessFailureMessage(dispatch, msg_class);
break;
#ifndef NMP_IPC
case FireDemonClass:
LOG_MESSAGE2("%-9s %15s [%d]:", "FireDemon",
dispatch->msg->msgData->name, *(int32 *)classData);
Log_RefId(dispatch, LOGGING_MESSAGE);
LOG_MESSAGE1("%10s", dispatch->org->modData->modName);
LOG_MESSAGE1(" --> %-15s (Sent)",
GET_S_GLOBAL(x_ipcServerModGlobal)->modData->modName);
Log_Time(1);
LOG_MESSAGE("\n");
fireDemonHnd(dispatch, (int32 *)classData);
break;
#endif
case HandlerRegClass:
case UNKNOWN:
case ExecHndClass:
#ifndef TEST_CASE_COVERAGE
default:
#endif
X_IPC_ERROR1("ERROR: recvMessage: class not implemented: %d\n", msg_class);
}
}
int main(int argc, char **argv)
#endif
{
int expectedMods = 0;
#ifdef macintosh
doSiouxStuff();
argc = ccommand(&argv);
#endif
/* Added by Bob Goode/Tam Ngo, 5/21/97, for WINSOCK option. */
#ifdef OS2
sock_init();
#elif defined(_WINSOCK_)
startWinsock();
#endif /* Winsock DLL loading */
x_ipcModuleInitialize();
#ifdef VXWORKS
/* Do this only after the socket is set up (in case there is an
old central lying around that needs killed */
centralTID = taskIdSelf();
#endif
globalSInit();
#if !defined(THINK_C) && !defined(macintosh) && !defined(__TURBOC__) && !defined(OS2) && !defined(_WIN95_MSC_) && !defined(WINNT) && !defined(WIN32)
(void)signal(SIGINT, abortCentral);
(void)signal(SIGBUS, abortCentral);
(void)signal(SIGSEGV, abortCentral);
(void)signal(SIGPIPE, pipeClosedHnd);
(void)signal(SIGTERM, abortCentral);
#endif /* !THINK_C && !macintosh */
#ifndef VXWORKS
if ((argc > 1) && (STREQ(argv[1], "-v")))
displayVersion();
else if ((argc > 1) && (STREQ(argv[1], "-h"))) {
displayOptions(argv[0]);
#ifdef macintosh
SIOUXSettings.autocloseonquit = FALSE;
#endif
} else {
parseExpectedMods(argc, argv, &expectedMods);
parseCommandLineOptions(argc, argv);
#else
if ((options!= NULL) && (strstr(options, "-v") || strstr(options, "-V"))) {
displayVersion();
} else if ((options!= NULL) &&
(strstr(options, "-h") || strstr(options, "-H"))) {
displayOptions("central");
} else {
parseOpsFromStr(options, &expectedMods, FALSE);
#endif
if (expectedMods < 1)
expectedMods = 1;
if (!serverInitialize(expectedMods)) {
X_IPC_ERROR("ERROR: Unable to start server, Is one already running?\n");
}
#ifndef VXWORKS
/* Register a method for freeing memory in an emergency. */
x_ipcRegisterFreeMemHnd(centralFreeMemory,3);
if (GET_S_GLOBAL(listenToStdin))
printPrompt();
#endif
#ifndef DEFAULT_OPTIONS
fprintf(stderr, "central running...\n");
#endif
listenLoop();
}
#ifdef _WINSOCK_
WSACleanup();
printf("Socket cleaned up.");
#endif /* Unload Winsock DLL */
#ifndef VXWORKS
return 1;
#endif
}
