void _x_ipcRegisterHandlerL(const char *msgName, const char *hndName,
X_IPC_HND_FN hndProc, HND_LANGUAGE_ENUM hndLanguage)
{
HND_DATA_PTR hndData;
HND_PTR hnd;
if (!hndProc) {
X_IPC_MOD_ERROR1("ERROR: x_ipcRegisterHandler: hndProc for %s is NULL.\n",
hndName);
return;
}
hndData = NEW(HND_DATA_TYPE);
hndData->refId = 0; /* will be updated by selfRegisterHandler */
/* Copy these -- they need to be saved */
hndData->msgName = strdup(msgName);
hndData->hndName = strdup(hndName);
hnd = x_ipc_selfRegisterHnd(0, (MODULE_PTR)NULL, hndData, hndProc);
hnd->hndLanguage = hndLanguage;
if (x_ipcInform(X_IPC_REGISTER_HND_INFORM, (void *)hndData) == Success) {
if (hnd->hndData != hndData) {
x_ipcFree((void *)hndData->msgName);
x_ipcFree((void *)hndData->hndName);
x_ipcFree((void *)hndData);
}
}
}
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_ipcMalloc(size_t amount)
#endif
{
int i, j;
void *mem;
mem = NULL;
if (!mGlobalp() || !GET_M_GLOBAL(x_ipcMallocMemHnd)) {
/* X_IPC_MOD_WARNING1("calling x_ipcMalloc(%d) before initialized\n", amount);*/
#if defined(DBMALLOC)
mem = malloc(file, line, amount);
#else
mem = malloc(amount);
#endif
if (!mem)
X_IPC_MOD_ERROR1("x_ipcMalloc: NULL returned from malloc for request: %d\n",
amount);
return mem;
} else {
LOCK_M_MUTEX;
if (GET_M_GLOBAL(x_ipcMallocMemHnd))
for(i=0;!mem && i < GET_M_GLOBAL(mallocMemRetryAmount);i++) {
#if defined(DBMALLOC)
mem = (*GET_M_GLOBAL(x_ipcMallocMemHnd))(file,line,amount);
#else
mem = (*GET_M_GLOBAL(x_ipcMallocMemHnd))(amount);
#endif
}
if (mem) {
GET_M_GLOBAL(totalMemRequest)++;
GET_M_GLOBAL(totalMemBytes) += amount;
UNLOCK_M_MUTEX;
return(mem);
}
if (GET_M_GLOBAL(x_ipcFreeMemoryHnd))
for(j=0;!mem && j < GET_M_GLOBAL(freeMemRetryAmount);j++) {
(*GET_M_GLOBAL(x_ipcFreeMemoryHnd))(amount);
if (GET_M_GLOBAL(x_ipcMallocMemHnd))
for(i=0;!mem && i < GET_M_GLOBAL(mallocMemRetryAmount);i++) {
#if defined(DBMALLOC)
mem = (*GET_M_GLOBAL(x_ipcMallocMemHnd))(file,line,amount);
#else
mem = (*GET_M_GLOBAL(x_ipcMallocMemHnd))(amount);
#endif
}
}
if (mem) {
GET_M_GLOBAL(totalMemRequest)++;
GET_M_GLOBAL(totalMemBytes) += amount;
UNLOCK_M_MUTEX;
return(mem);
}
UNLOCK_M_MUTEX;
X_IPC_MOD_ERROR1("x_ipcMalloc: NULL returned from malloc for request: %d\n",
amount);
return NULL;
}
}
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;
}
static void Print_Structured_Data(FILE *Stream, Print_Data_Ptr printer,
CONST_FORMAT_PTR Format,
CONST_GENERIC_DATA_PTR Data_Ptr,
int32 DStart,
CONST_FORMAT_PTR parentFormat,
int32 Keep_With_Next)
{
TRANSLATE_FN_DPRINT printProc;
int32 i, last_element_p, next_keep, length, currentDStart;
u_int32 byte;
void *StructPtr, *ArrayPtr;
FORMAT_ARRAY_PTR format_array, fixed_format_array;
currentDStart = DStart;
switch (Format->type) {
case LengthFMT:
length = Format->formatter.i;
printString(Stream, printer, "(", DEFAULT_KEEP);
for (i=0; i<length; i++) {
if (printer->truncatedGlobal) {
return;
} else {
byte = 0;
*(((u_char *)&byte)+sizeof(u_int32)-sizeof(u_char)) =
*(u_char *)(Data_Ptr+currentDStart+i);
printHex(Stream, printer, &byte,
(i == length-1 ? Keep_With_Next+1 : 1));
if (i == length-1) printString(Stream, printer, ")", Keep_With_Next);
else printCommaSpace(Stream, printer);
}
}
break;
case PrimitiveFMT:
printProc = GET_M_GLOBAL(TransTable)[Format->formatter.i].DPrint;
(* printProc)(Data_Ptr, currentDStart, Stream, printer, Keep_With_Next);
break;
case PointerFMT:
StructPtr = REF(GENERIC_DATA_PTR, Data_Ptr, currentDStart);
if (StructPtr) {
printString(Stream, printer, "*", DEFAULT_KEEP);
Print_Structured_Data(Stream, printer,
CHOOSE_PTR_FORMAT(Format, parentFormat),
(CONST_GENERIC_DATA_PTR)StructPtr, 0,
(CONST_FORMAT_PTR)NULL, Keep_With_Next);
}
else
printString(Stream, printer, "NULL", Keep_With_Next);
break;
case StructFMT:
printString(Stream, printer, "{", DEFAULT_KEEP);
format_array = Format->formatter.a;
for (i=1;i<format_array[0].i;i++) {
if (printer->truncatedGlobal)
return;
else {
last_element_p = (i+1 == format_array[0].i);
next_keep = ((last_element_p) ? Keep_With_Next+1 : 1);
Print_Structured_Data(Stream, printer, format_array[i].f,
Data_Ptr+DStart, currentDStart-DStart,
Format, next_keep);
currentDStart += x_ipc_dataStructureSize(format_array[i].f);
currentDStart = x_ipc_alignField(Format, i, currentDStart);
if (last_element_p)
printString(Stream, printer, "}", Keep_With_Next);
else
printCommaSpace(Stream, printer);
}
}
break;
case FixedArrayFMT:
(void)printArrayData(Stream, printer, Format->formatter.a[1].f,
Data_Ptr, currentDStart,
Format->formatter.a, 2, Keep_With_Next, "[", "]");
break;
case VarArrayFMT:
ArrayPtr = REF(GENERIC_DATA_PTR, Data_Ptr, currentDStart);
format_array = Format->formatter.a;
if (ArrayPtr) {
fixed_format_array = fix_format_array(format_array,
parentFormat,
Data_Ptr, currentDStart);
(void)printArrayData(Stream, printer, format_array[1].f, ArrayPtr, 0,
fixed_format_array, 2, Keep_With_Next, "<", ">");
x_ipcFree((char *)fixed_format_array);
}
else
printString(Stream, printer, "NULL", Keep_With_Next);
break;
case NamedFMT:
Print_Structured_Data(Stream, printer,
x_ipc_fmtFind(Format->formatter.name),
Data_Ptr, currentDStart,
parentFormat, Keep_With_Next);
break;
case BadFormatFMT:
printString(Stream, printer, "Bad Format", Keep_With_Next);
case EnumFMT:
{ int32 eVal;
eVal = x_ipc_enumToInt(Format, Data_Ptr, ¤tDStart);
if (Format->formatter.a[0].i > 2 &&
/* enum value within range */
0 <= eVal && eVal <= ENUM_MAX_VAL(Format)) {
printString(Stream, printer,
Format->formatter.a[eVal+2].f->formatter.name,
Keep_With_Next);
} else {
printInt(Stream, printer, &eVal, Keep_With_Next);
}
break;
}
#ifndef TEST_CASE_COVERAGE
default:
X_IPC_MOD_ERROR1("Unknown Print_Structured_Data Type %d", Format->type);
break;
#endif
}
}
static void Print_Formatter1(FILE *stream, Print_Data_Ptr printer,
CONST_FORMAT_PTR format, int32 keepWithNext)
{
int32 i, last_element_p;
FORMAT_ARRAY_PTR format_array;
const char *primFormatName;
switch(format->type) {
case LengthFMT:
printInt(stream, printer, &(format->formatter.i), keepWithNext);
break;
case PrimitiveFMT:
switch(format->formatter.p) {
case INT_FMT: primFormatName = INT_FMT_NAME; break;
case BOOLEAN_FMT: primFormatName = BOOLEAN_FMT_NAME; break;
case FLOAT_FMT: primFormatName = FLOAT_FMT_NAME; break;
case DOUBLE_FMT: primFormatName = DOUBLE_FMT_NAME; break;
case BYTE_FMT: primFormatName = BYTE_FMT_NAME; break;
case TWOBYTE_FMT: primFormatName = TWOBYTE_FMT_NAME; break;
case STR_FMT: primFormatName = STR_FMT_NAME; break;
case FORMAT_FMT: primFormatName = FORMAT_FMT_NAME; break;
case UBYTE_FMT: primFormatName = UBYTE_FMT_NAME; break;
case CMAT_FMT: primFormatName = CMAT_FMT_NAME; break;
case SMAT_FMT: primFormatName = SMAT_FMT_NAME; break;
case IMAT_FMT: primFormatName = IMAT_FMT_NAME; break;
case LMAT_FMT: primFormatName = LMAT_FMT_NAME; break;
case FMAT_FMT: primFormatName = FMAT_FMT_NAME; break;
case DMAT_FMT: primFormatName = DMAT_FMT_NAME; break;
case CHAR_FMT: primFormatName = CHAR_FMT_NAME; break;
case SHORT_FMT: primFormatName = SHORT_FMT_NAME; break;
case LONG_FMT: primFormatName = LONG_FMT_NAME; break;
case UCMAT_FMT: primFormatName = UCMAT_FMT_NAME; break;
case X_IPC_REF_PTR_FMT: primFormatName = X_IPC_REF_PTR_FMT_NAME; break;
case SIUCMAT_FMT: primFormatName = SIUCMAT_FMT_NAME; break;
case SICMAT_FMT: primFormatName = SICMAT_FMT_NAME; break;
case SISMAT_FMT: primFormatName = SISMAT_FMT_NAME; break;
case SIIMAT_FMT: primFormatName = SIIMAT_FMT_NAME; break;
case SILMAT_FMT: primFormatName = SILMAT_FMT_NAME; break;
case SIFMAT_FMT: primFormatName = SIFMAT_FMT_NAME; break;
case SIDMAT_FMT: primFormatName = SIDMAT_FMT_NAME; break;
case USHORT_FMT: primFormatName = USHORT_FMT_NAME; break;
case UINT_FMT: primFormatName = UINT_FMT_NAME; break;
case ULONG_FMT: primFormatName = ULONG_FMT_NAME; break;
#ifndef TEST_CASE_COVERAGE
default: primFormatName = "UNKNOWN"; break;
#endif
}
printString(stream, printer, primFormatName, keepWithNext);
break;
case PointerFMT:
printString(stream, printer, "*", DEFAULT_KEEP);
if (format->formatter.f)
Print_Formatter1(stream, printer, format->formatter.f, keepWithNext);
else
printString(stream, printer, "!", keepWithNext);
break;
case StructFMT:
format_array = format->formatter.a;
printString(stream, printer, "{", DEFAULT_KEEP);
for (i=1; i<format_array[0].i; i++) {
if (printer->truncatedGlobal)
return;
else {
last_element_p = (i+1 == format_array[0].i);
Print_Formatter1(stream, printer, format_array[i].f,
((last_element_p) ? keepWithNext+1 : 1));
if (last_element_p)
printString(stream, printer, "}", keepWithNext);
else
printCommaSpace(stream, printer);
}
}
break;
case FixedArrayFMT:
PrintArrayFormat(stream, printer, "[", format->formatter.a, "]",
keepWithNext);
break;
case VarArrayFMT:
PrintArrayFormat(stream, printer, "<", format->formatter.a, ">",
keepWithNext);
break;
case NamedFMT:
printString(stream, printer, format->formatter.name, keepWithNext);
break;
case BadFormatFMT:
printString(stream, printer, "Bad Format", keepWithNext);
break;
case EnumFMT:
format_array = format->formatter.a;
printString(stream, printer, "{enum ", DEFAULT_KEEP);
if (format_array[0].i == 2) {
printString(stream, printer, ": ", keepWithNext);
printInt(stream, printer, &(format_array[1].i), keepWithNext);
} else {
for (i=2; i<format_array[0].i; i++) {
if (printer->truncatedGlobal)
return;
else {
last_element_p = (i+1 == format_array[0].i);
printString(stream, printer, format_array[i].f->formatter.name,
((last_element_p) ? keepWithNext+1 : 1));
if (!last_element_p) printCommaSpace(stream, printer);
}
}
}
printString(stream, printer, "}", keepWithNext);
break;
#ifndef TEST_CASE_COVERAGE
default:
X_IPC_MOD_ERROR1("Unknown Print_Formatter1 Type %d", format->type);
break;
#endif
}
}
