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); }