static os_boolean
in_ddsiStreamReaderImplProcessHeartbeat(
in_ddsiStreamReaderImpl _this,
in_ddsiSubmessageDeserializer submessageDeserializer)
{
os_boolean result = OS_TRUE;
OS_STRUCT(in_ddsiHeartbeat) heartbeat;
if (!_this->callbackTable->processHeartbeat) {
IN_TRACE(Receive,2,"callback 'processHeartbeat' not defined, heartbeat will be ignored");
result = OS_TRUE; /* continue buffer scan */
} else
{
in_ddsiDeserializer deserializer;
in_ddsiSubmessageHeader preparsedHeader;
in_long nofOctets;
deserializer = OS_SUPER(submessageDeserializer);
preparsedHeader = &(submessageDeserializer->submessageHeader);
nofOctets = in_ddsiSubmessageHeartbeatInitFromBuffer(
OS_SUPER(&heartbeat),
preparsedHeader,
deserializer);
if (nofOctets < 0)
{
result = OS_FALSE;
} else
{
in_result retVal;
retVal = _this->callbackTable->processHeartbeat(
_this->callbackArg,
&heartbeat,
&(_this->receiver));
result = (retVal==IN_RESULT_OK);
}
}
return result;
}
static os_boolean
in_ddsiStreamReaderImplProcessAppdefData(
in_ddsiStreamReaderImpl _this,
in_ddsiSubmessageData submessage)
{
in_connectivityPeerWriter peerWriter;
v_message messageObject = NULL;
os_boolean result = OS_TRUE;
in_result payloadResult;
/* if the callback is undefined, avoid further parsing and processing,
* but return with TRUE, so that scanner continues with following
* submessages */
if (!(_this->callbackTable->processData)) {
IN_TRACE(Receive,2,"callback 'processData' not defined, AppeDef Data ignored");
} else
{
/* peerWriter's refcounter is not incremented */
peerWriter = getPeerWriter(_this,
&(_this->receiver.sourceGuidPrefix[0]),
&(submessage->writerId));
if (!peerWriter)
{
IN_REPORT_WARNING(IN_SPOT,
"ignoring message from unknown peer writer");
/* continue with succeeding messages in same buffer */
} else
{
if(in_ddsiSubmessageHasFlagD((in_ddsiSubmessage)submessage))
{
/* Deserialize data.*/
payloadResult = in_ddsiStreamReaderImplProcessAppdefDataPayload(
_this,
submessage,
peerWriter,
&messageObject);
if (payloadResult != IN_RESULT_OK)
{
IN_REPORT_WARNING(IN_SPOT, "message deserialization failed");
result = OS_FALSE; /* abort processing this buffer */
} else if (messageObject==NULL)
{
/* paranoid check */
IN_REPORT_WARNING(IN_SPOT,
"message parsing succeeded, but message object empty");
result = OS_FALSE; /* abort processing this buffer */
}
} else if(in_ddsiSubmessageHasFlagQ((in_ddsiSubmessage)submessage))
{
/* Lookup StatusInfo, KeyHash and QoS parameters if available.*/
payloadResult = in_ddsiStreamReaderImplProcessAppdefDataPayloadNoData(
_this,
submessage,
peerWriter,
&messageObject);
if (payloadResult != IN_RESULT_OK)
{
IN_REPORT_WARNING(IN_SPOT, "message deserialization failed");
result = OS_FALSE; /* abort processing this buffer */
} else if (messageObject==NULL)
{
/* paranoid check */
IN_REPORT_WARNING(IN_SPOT,
"message parsing succeeded, but message object empty");
result = OS_FALSE; /* abort processing this buffer */
}
}
if(result && messageObject)
{
payloadResult = _this->callbackTable->processData(
_this->callbackArg, messageObject, peerWriter,
&(_this->receiver));
c_free(messageObject);
if(payloadResult != IN_RESULT_OK)
{
result = OS_FALSE;
}
} else
{
result = OS_FALSE;
/* TODO: report error*/
}
in_connectivityPeerWriterFree(peerWriter);
}
}
return result;
}
static os_boolean
in_ddsiStreamReaderImplProcessBuiltinWriterData(
in_ddsiStreamReaderImpl _this,
in_ddsiSubmessageData submessage)
{
os_boolean result = OS_FALSE;
/* if the callback is undefined, avoid further parsing and processing,
* but return with TRUE, so that scanner continues with following
* submessages */
if (!(_this->callbackTable->processPeerEntity)) {
IN_TRACE(Receive,2,"callback 'processPeerEntity' not defined, BuiltinWriterData ignored");
result = OS_TRUE; /* continue buffer scan */
} else {
in_ddsiDiscoveredWriterData discoveredData = NULL;
in_ddsiSerializedData seriallizedPayload =
&(submessage->serializedPayload);
/** codec must be either PL_CDR_BE or PL_CDR_LE */
OS_STRUCT(in_ddsiParameterList) parameterList;
if (!in_ddsiParameterListInitFromEncapsulation(
¶meterList,
seriallizedPayload)) {
IN_REPORT_WARNING_1(IN_SPOT, "unknown codec %d",
seriallizedPayload->codecId);
result = OS_FALSE;
} else {
/* TODO, no fragmentation supported yet */
discoveredData = in_ddsiDiscoveredWriterDataNew();
if (!discoveredData) {
/* TODO handle out-of-memory */
result = OS_FALSE;
} else {
const in_result parseResult =
/* TODO, to handle fragments, add
* newBuffer-callback to decode operation */
in_ddsiParameterListForWriterParse(
¶meterList,
discoveredData,
in_plugKernelGetBase(_this->plugKernel));
if (parseResult!=IN_RESULT_OK) {
/* TODO handle out-of-memory */
result = OS_FALSE;
} else {
in_connectivityPeerWriter newPeer =
in_connectivityPeerWriterNew(discoveredData);
/* in any case release the data object, which should be
* refcounted by peer-object now */
in_ddsiDiscoveredWriterDataFree(discoveredData);
if (!newPeer) {
/* TODO handle out-of-memory */
result = OS_FALSE;
} else {
in_result processResult;
OS_STRUCT(in_discoveredPeer) discoveredPeer;
discoveredPeer.readerId = &(submessage->readerId);
discoveredPeer.writerId = &(submessage->writerId);
discoveredPeer.sequenceNumber = &(submessage->writerSN);
discoveredPeer.discoveredPeerEntity =
in_connectivityPeerEntity(newPeer);
/* TODO verify if builtin-topic writer is reliable and
* requires ackNacks */
processResult =
_this->callbackTable->processPeerEntity(
_this->callbackArg, /* object */
&discoveredPeer); /* method parameter */
/* cleanup the dynamic object, decrement refcount */
in_connectivityPeerWriterFree(newPeer);
if (processResult!=IN_RESULT_OK && processResult!=IN_RESULT_ALREADY_EXISTS) {
result = OS_FALSE;
} else {
result = OS_TRUE;
}
}
}
}
}
}
return result;
}
void
in_serviceMain(
const os_char* serviceName,
const os_char* uri)
{
u_service service;
in_config config;
in_result result;
u_serviceManager serviceManager;
in_controller controller;
v_duration leasePeriod;
os_time sleepTime;
os_boolean terminate = OS_FALSE;
in_connectivityAdmin admin;
assert(serviceName);
assert(uri);
/* Create networking service with kernel */
service = u_serviceNew(
uri,
IN_ATTACH_TIMEOUT,
serviceName,
NULL,
U_SERVICE_NETWORKING,
NULL);
assert(service);
/* Initialize configuration */
config = in_configGetInstance();
result = in_configConvertDomTree(config, uri, service);
if(result == IN_RESULT_OK)
{
/* Ask service manager for splicedaemon state */
serviceManager = u_serviceManagerNew(u_participant(service));
admin = in_connectivityAdminGetInstance();
/* Create the controller which starts the updating */
controller = in_controllerNew(service);
if (controller)
{
/* Start the actual engine */
IN_REPORT_INFO(1, "DDSI networking started");
IN_TRACE(Mainloop, 1, "DDSI networking started");
in_controllerStart(controller);
/* Change state for spliced */
u_serviceChangeState(service, STATE_INITIALISING);
u_serviceChangeState(service, STATE_OPERATIONAL);
/* Get sleeptime from configuration */
in_retrieveLeaseSettings(&leasePeriod, &sleepTime);
u_serviceRenewLease(service, leasePeriod);
/* Loop until termination is requested */
u_serviceWatchSpliceDaemon(
service,
in_splicedaemonListener,
&terminate);
/* terminate flag is modified by the splice deamon listener thread*/
while (!terminate)
{
/* Assert my liveliness and the Splicedaemon's liveliness */
u_serviceRenewLease(service, leasePeriod);
/* Wait before renewing again */
os_nanoSleep(sleepTime);
}
leasePeriod.seconds = 20;
u_serviceRenewLease(service, leasePeriod);
u_serviceChangeState(service, STATE_TERMINATING);
in_controllerStop(controller);
in_controllerFree(controller);
IN_REPORT_INFO(1, "DDSI networking stopped");
IN_TRACE(Mainloop, 1, "DDSI networking stopped");
}
u_serviceChangeState(service, STATE_TERMINATED);
u_serviceManagerFree(serviceManager);
in_objectFree(in_object(admin));
}
/* Clean up */
in_configFree(config);
u_serviceFree(service);
}
