void
v_handleServerResume(
v_handleServer server)
{
if (server == NULL) {
OS_REPORT(OS_ERROR,"Kernel HandleServer",0,
"v_handleServerResume: no server specified");
} else {
server->suspended = FALSE;
OS_REPORT(OS_WARNING,"Kernel HandleServer",0,"v_handleServer is resumed.");
}
}
void
v_handleServerSuspend(
v_handleServer server)
{
if (server == NULL) {
OS_REPORT(OS_ERROR,"Kernel HandleServer",0,
"v_handleServerSuspend: no server specified");
} else {
server->suspended = TRUE;
OS_REPORT(OS_WARNING,"Kernel HandleServer",0,"v_handleServer is suspended.");
}
}
c_long
v_handleServerClaims(
v_handleServer server)
{
if (server == NULL) {
OS_REPORT(OS_ERROR,"Kernel HandleServer",0,
"v_handleServerClaims: no server specified");
}
OS_REPORT(OS_WARNING,"Kernel HandleServer",0,
"v_handleServerClaims not yet implemented");
return 0;
}
u_topic
u_topicNew(
const u_participant p,
const os_char *name,
const os_char *typeName,
const os_char *keyList,
u_topicQos qos)
{
u_topic _this = NULL;
v_topicAdapter kt;
v_participant kp;
u_result result;
assert(name != NULL);
assert(typeName != NULL);
assert(p != NULL);
result = u_observableWriteClaim(u_observable(p),(v_public *)(&kp), C_MM_RESERVATION_HIGH);
if (result == U_RESULT_OK) {
assert(kp);
kt = v_topicAdapterNew(kp,name,typeName,keyList,qos);
if (kt != NULL) {
_this = u_objectAlloc(sizeof(*_this), U_TOPIC, u__topicDeinitW, u__topicFreeW);
if (_this != NULL) {
result = u_topicInit(_this,name,kt,p);
if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR, "u_topicNew", result,
"Initialisation failed. "
"For Topic: <%s>", name);
u_objectFree (u_object (_this));
_this = NULL;
}
} else {
OS_REPORT(OS_ERROR, "u_topicNew", U_RESULT_OUT_OF_MEMORY,
"Create user proxy failed. "
"For Topic: <%s>", name);
}
c_free(kt);
} else {
OS_REPORT(OS_WARNING, "u_topicNew", U_RESULT_OUT_OF_MEMORY,
"Create kernel entity failed. "
"For Topic: <%s>", name);
}
u_observableRelease(u_observable(p), C_MM_RESERVATION_HIGH);
} else {
OS_REPORT(OS_WARNING, "u_topicNew", U_RESULT_INTERNAL_ERROR,
"Claim Kernel failed. "
"For Topic: <%s>", name);
}
return _this;
}
u_result
u_dispatcherRemoveListener(
u_dispatcher _this,
u_dispatcherListener listener)
{
u_listener ul;
v_observer ko;
os_threadId tid;
u_result result = U_RESULT_OK;
struct compareArg arg;
if ((_this != NULL) && (listener != NULL)) {
os_mutexLock(&_this->mutex);
arg.listener = listener;
ul = (u_listener) c_iterResolve(_this->listeners, compare, &arg);
tid = _this->threadId;
if (ul != NULL) {
c_iterTake(_this->listeners, ul);
if (c_iterLength(_this->listeners) == 0) {
result = u_entityReadClaim(u_entity(_this), (v_entity*)(&ko));
if(result == U_RESULT_OK) {
assert(ko);
/* Wakeup the dispatch thread */
v_observerLock(ko);
v_observerNotify(ko, NULL, NULL);
v_observerUnlock(ko);
result = u_entityRelease(u_entity(_this));
if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR, "u_dispatcherRemoveListener", 0,
"Release observer failed.");
}
} else {
OS_REPORT(OS_WARNING, "u_dispatcherRemoveListener", 0,
"Failed to claim Dispatcher.");
}
}
u_listenerFree(ul);
}
os_mutexUnlock(&_this->mutex);
if ((c_iterLength(_this->listeners) == 0)
&& (os_threadIdToInteger(tid) != 0U)) {
os_threadWaitExit(tid, NULL);
}
} else {
OS_REPORT(OS_ERROR,"u_dispatcherInsertListener",0,
"Illegal parameter.");
result = U_RESULT_ILL_PARAM;
}
return result;
}
u_result
u_dispatcherInsertListener(
u_dispatcher _this,
u_dispatcherListener listener,
c_voidp userData)
{
u_listener ul;
os_threadAttr attr;
v_observer ke;
u_result result = U_RESULT_OK;
c_char *name;
if ((_this != NULL) && (listener != NULL)) {
os_mutexLock(&_this->mutex);
ul = u_listenerNew(listener,userData);
_this->listeners = c_iterInsert(_this->listeners,ul);
if (os_threadIdToInteger(_this->threadId) == 0U) {
result = u_entityReadClaim(u_entity(_this), (v_entity*)(&ke));
if(result == U_RESULT_OK) {
assert(ke);
name = v_entityName(ke);
if (name == NULL) {
name = "NoName";
}
os_threadAttrInit(&attr);
os_threadCreate(&_this->threadId,
name,
&attr,dispatch,
(void *)_this);
result = u_entityRelease(u_entity(_this));
if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR, "u_dispatcherInsertListener", 0,
"Release observer failed.");
}
} else {
OS_REPORT(OS_WARNING, "u_dispatcherInsertListener", 0,
"Failed to claim Dispatcher.");
}
}
u_entityEnable(u_entity(_this));
os_mutexUnlock(&_this->mutex);
} else {
OS_REPORT(OS_ERROR,"u_dispatcherInsertListener",0,
"Illegal parameter.");
result = U_RESULT_ILL_PARAM;
}
return result;
}
static u_result
u__waitsetDeinitW(
void *_vthis)
{
u_waitset _this;
u_waitsetEntry entry;
u_result result = U_RESULT_OK;
_this = u_waitset(_vthis);
os_mutexLock(&_this->mutex);
_this->alive = FALSE;
while (_this->waitBusy) {
waitset_notify(_this, NULL);
os_condWait(&_this->waitCv, &_this->mutex);
}
entry = c_iterTakeFirst(_this->entries);
while (entry != NULL) {
u_domain domain = u_observableDomain(u_observable(entry));
result = u_domainRemoveWaitset(domain, _this);
if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR,
"u__waitsetDeinitW", result,
"Operation u_domainRemoveWaitset failed: "
"Waitset = 0x%"PA_PRIxADDR", result = %s",
(os_address)_this, u_resultImage(result));
assert(FALSE);
}
result = u_objectFree_s(entry);
if (result == U_RESULT_ALREADY_DELETED) {
result = U_RESULT_OK;
} else if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR,
"u__waitsetDeinitW", result,
"Operation u_waitsetEntryFree failed: "
"Waitset = 0x%"PA_PRIxADDR", result = %s",
(os_address)_this, u_resultImage(result));
result = U_RESULT_OK;
(void)result;
assert(FALSE);
}
entry = c_iterTakeFirst(_this->entries);
}
c_iterFree(_this->entries);
_this->entries = NULL;
os_mutexUnlock(&_this->mutex);
u__objectDeinitW(_this);
return result;
}
c_bool
v_serviceChangeState(
v_service service,
v_serviceStateKind newState)
{
c_bool result;
assert(service != NULL);
assert(C_TYPECHECK(service, v_service));
assert(service->state != NULL);
assert(C_TYPECHECK(service->state, v_serviceState));
result = v_serviceStateChangeState(service->state, newState);
if(result)
{
switch(newState)
{
case STATE_OPERATIONAL:
OS_REPORT(OS_INFO, "v_serviceChangeState", 0,
"++++++++++++++++++++++++++++++++++++++++++++++++" OS_REPORT_NL
"++ The service '%s' is now operational. " OS_REPORT_NL
"++++++++++++++++++++++++++++++++++++++++++++++++",
v_serviceGetName(service));
break;
case STATE_TERMINATED:
OS_REPORT(OS_INFO, "v_serviceChangeState", 0,
"================================================" OS_REPORT_NL
"== The service '%s' has now terminated. "OS_REPORT_NL
"================================================",
v_serviceGetName(service));
break;
case STATE_DIED:
OS_REPORT(OS_INFO, "v_serviceChangeState", 0,
"================================================" OS_REPORT_NL
"== The service '%s' has died. "OS_REPORT_NL
"================================================",
v_serviceGetName(service));
break;
case STATE_NONE:
case STATE_INITIALISING:
case STATE_TERMINATING:
case STATE_INCOMPATIBLE_CONFIGURATION:
default:
/* ignore */
break;
}
}
return result;
}
u_result
u_waitsetDetachFromDomain(
_Inout_ u_waitset _this,
_Inout_ u_domain domain)
{
u_result result;
os_result osr;
u_waitsetEntry entry;
assert(_this != NULL);
assert(domain != NULL);
osr = os_mutexLock_s(&_this->mutex);
if (osr == os_resultSuccess) {
entry = c_iterResolve(_this->entries, compare_domain, domain);
if (entry != NULL) {
_this->notifyDetached = OS_TRUE;
result = u_objectClose(entry);
if (result == U_RESULT_ALREADY_DELETED) {
result = U_RESULT_OK;
}
if (result == U_RESULT_OK) {
/* The entry is already freed but the address value can still
* be used to update the administration because it only removes
* the address value from the list.
*/
c_iterTake(_this->entries, entry);
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR,
"u_waitsetDetachFromDomain", result,
"Operation u_waitsetEntryFree failed: "
"Waitset = 0x%"PA_PRIxADDR", result = %s",
(os_address)_this, u_resultImage(result));
assert(FALSE);
}
} else {
result = U_RESULT_PRECONDITION_NOT_MET;
}
(void)u_domainRemoveWaitset(domain, _this);
os_mutexUnlock(&_this->mutex);
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_WARNING, "u_waitsetDetachFromDomain", result,
"Could not claim waitset.");
}
return result;
}
/** \brief Create a named shared memory area based upon
* POSIX shared memory object
*
* \b os_posix_sharedMemoryCreate gets a database file name for \b name
* by calling \b os_posix_getShmObjName.
*
* When the file already exists, an error is returned.
* Otherwise the file is created with \b shm_open and it's size is set according
* the required database size by calling \b ftruncate.
*
* User credentials are taken into account by setting the correct ownership
* by calling \b chown.
*/
os_result
os_posix_sharedMemoryCreate (
const char *name,
os_sharedAttr *sharedAttr,
os_address size)
{
char *shmname;
int shmfd;
os_result rv = os_resultSuccess;
assert (name != NULL);
assert (sharedAttr != NULL);
/* roundup to page boundaries */
shmname = os_posix_getShmObjName (name, sharedAttr->map_address, size, name);
if (shmname != NULL) {
shmfd = shm_open (shmname, O_CREAT | O_RDWR | O_EXCL, OS_PERMISSION);
if (shmfd == -1) {
OS_REPORT (OS_WARNING, "os_posix_sharedMemoryCreate", 1, "shm_open failed with error %d (%s)", os_getErrno(), name);
rv = os_resultFail;
} else {
#ifdef INTEGRITY
if ( size % getpagesize() != 0 ) {
size += getpagesize() - ( size % getpagesize() );
}
#endif
if (ftruncate (shmfd, size) == -1) {
OS_REPORT (OS_ERROR, "os_posix_sharedMemoryCreate", 1,
"ftruncate failed with error %d (%s)", os_getErrno(), name);
close (shmfd);
rv = os_resultFail;
} else {
if (sharedAttr->userCred.uid != 0 && sharedAttr->userCred.gid != 0) {
if (getuid() == 0 || geteuid() == 0) {
if (chown (shmname, sharedAttr->userCred.uid, sharedAttr->userCred.gid) == -1) {
OS_REPORT (OS_WARNING, "os_posix_sharedMemoryCreate", 1,
"chown failed with error %d (%s)", os_getErrno(), name);
}
} else {
OS_REPORT (OS_WARNING, "os_posix_sharedMemoryCreate", 2,
"Can not change ownership because of privilege problems (%s)", name);
}
}
}
}
close (shmfd);
os_free (shmname);
}
return rv;
}
DDS::TopicDescription_ptr
DDS::DomainParticipant_impl::unprotected_lookup_topicdescription (
const char * name
)
{
gapi_topic handle;
DDS::ccpp_UserData_ptr myUD;
DDS::TopicDescription_ptr result = NULL;
handle = gapi_domainParticipant_lookup_topicdescription(_gapi_self, name);
if (handle)
{
myUD = dynamic_cast<DDS::ccpp_UserData_ptr>((DDS::Object *)gapi_object_get_user_data(handle));
if (myUD)
{
result = dynamic_cast<DDS::TopicDescription_impl_ptr>(myUD->ccpp_object);
if (result)
{
DDS::TopicDescription::_duplicate(result);
}
else
{
OS_REPORT(OS_ERROR, "CCPP", 0, "Invalid Topic Description");
}
}
else
{
// If handle is found in GAPI, but has no UserData, then it has to be a builtin Topic.
// That's how we know that a Topic_impl wrapper needs to be instantiated in this case.
result = new DDS::Topic_impl(handle);
if (result)
{
DDS::ccpp_UserData_ptr myUD;
myUD = new DDS::ccpp_UserData(result, NULL);
if (myUD)
{
gapi_object_set_user_data(handle, (DDS::Object *)myUD,
ccpp_CallBack_DeleteUserData,NULL);
}
else
{
OS_REPORT(OS_ERROR, "CCPP", 0, "Unable to allocate memory");
}
}
}
}
return result;
}
d_groupInfo
d_groupInfoNew (
const d_storeMMFKernel kernel,
const d_topicInfo topic,
const d_group dgroup)
{
d_groupInfo group;
c_base base;
c_char* partition;
c_type instanceType, groupInfoType;
c_char *keyExpr;
if(kernel && topic && dgroup){
base = c_getBase(kernel);
groupInfoType = c_resolve(base,"durabilityModule2::d_groupInfo");
group = d_groupInfo(c_new(groupInfoType));
c_free(groupInfoType);
if (group) {
group->kernel = kernel; /* Unmanaged pointer */
group->topic = c_keep(topic);
partition = d_groupGetPartition(dgroup);
group->partition = c_stringNew(base, partition);
os_free(partition);
group->quality = d_groupGetQuality(dgroup);
group->completeness = d_groupGetCompleteness(dgroup);
instanceType = d_topicInfoGetInstanceType(topic);
keyExpr = d_topicInfoGetInstanceKeyExpr(topic);
group->instances = c_tableNew(instanceType, keyExpr);
c_free(keyExpr);
c_free(instanceType);
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoNew",0,
"Failed to allocate d_groupInfo.");
assert(FALSE);
group = NULL;
}
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoNew",0,
"Illegal constructor parameter.");
group = NULL;
}
return group;
}
u_topic
u_topicNewFromTopicInfo(
u_participant p,
const struct v_topicInfo *info,
c_bool announce)
{
u_topic _this = NULL;
v_topicAdapter kt;
v_participant kp;
u_result result;
assert (p);
assert (info);
result = u_observableWriteClaim(u_observable(p),(v_public*)(&kp), C_MM_RESERVATION_LOW);
if (result == U_RESULT_OK) {
assert(kp);
kt = v_topicAdapterNewFromTopicInfo(kp,info,announce);
if (kt != NULL) {
_this = u_objectAlloc(sizeof(*_this), U_TOPIC, u__topicDeinitW, u__topicFreeW);
if (_this != NULL) {
result = u_topicInit(_this,info->name,kt,p);
if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR, "u_topicNew", result,
"Initialisation failed. "
"For Topic: <%s>", info->name);
u_objectFree (u_object (_this));
_this = NULL;
}
} else {
OS_REPORT(OS_ERROR, "u_topicNew", U_RESULT_OUT_OF_MEMORY,
"Create user proxy failed. "
"For Topic: <%s>", info->name);
}
c_free(kt);
} else {
OS_REPORT(OS_WARNING, "u_topicNewFromTopicInfo", U_RESULT_OUT_OF_MEMORY,
"Create kernel entity failed. "
"For Topic: <%s>", info->name);
}
u_observableRelease(u_observable(p),C_MM_RESERVATION_LOW);
} else {
OS_REPORT(OS_WARNING, "u_topicNewFromTopicInfo", U_RESULT_INTERNAL_ERROR,
"Claim Kernel failed. "
"For Topic: <%s>", info->name);
}
return _this;
}
c_bool
__chromatic_imap_dds_chromatic_imap_command__copyIn(
c_base base,
struct ::chromatic_imap_dds::chromatic_imap_command *from,
struct _chromatic_imap_dds_chromatic_imap_command *to)
{
c_bool result = OS_C_TRUE;
(void) base;
to->session_idx = (c_long)from->session_idx;
to->locale_idx = (c_long)from->locale_idx;
#ifdef OSPL_BOUNDS_CHECK
if(from->moniker){
to->moniker = c_stringNew(base, from->moniker);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.moniker' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->moniker = c_stringNew(base, from->moniker);
#endif
#ifdef OSPL_BOUNDS_CHECK
if(from->command){
if(((unsigned int)strlen(from->command)) <= 32){
to->command = c_stringNew(base, from->command);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.command' of type 'C_STRING<32>' is out of range.");
result = OS_C_FALSE;
}
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.command' of type 'C_STRING<32>' is NULL.");
result = OS_C_FALSE;
}
#else
to->command = c_stringNew(base, from->command);
#endif
#ifdef OSPL_BOUNDS_CHECK
if(from->payload){
to->payload = c_stringNew(base, from->payload);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'chromatic_imap_dds::chromatic_imap_command.payload' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->payload = c_stringNew(base, from->payload);
#endif
return result;
}
u_result
u_serviceDeinit(
u_service service)
{
u_result r;
watchSplicedAdmin admin;
if (service != NULL) {
u_dispatcherRemoveListener(u_dispatcher(service),
u_serviceSpliceListener);
admin = watchSplicedAdmin(service->privateData);
if (admin) {
admin->callback = NULL;
admin->usrData = NULL;
if (admin->serviceManager != NULL) {
u_serviceManagerFree(admin->serviceManager);
}
os_free(admin);
}
service->privateData = NULL;
r = u_participantDeinit(u_participant(service));
} else {
OS_REPORT(OS_ERROR,"u_serviceDeinit",0,
"Illegal parameter.");
r = U_RESULT_ILL_PARAM;
}
return r;
}
void
v_publicDispose(
v_public o)
{
assert(C_TYPECHECK(o,v_public));
if (o == NULL) {
return;
}
switch(v_objectKind(o)) {
case K_PARTICIPANT: v_participantDeinit(v_participant(o)); break;
case K_PUBLISHER: v_publisherDeinit(v_publisher(o)); break;
case K_SUBSCRIBER: v_subscriberDeinit(v_subscriber(o)); break;
case K_WRITER: v_writerDeinit(v_writer(o)); break;
case K_DATAREADER: v_dataReaderDeinit(v_dataReader(o)); break;
case K_DELIVERYSERVICE:v_deliveryServiceDeinit(v_deliveryService(o)); break;
case K_NETWORKREADER: v_networkReaderDeinit(v_networkReader(o)); break;
case K_READER: v_readerDeinit(v_reader(o)); break;
case K_GROUPQUEUE: v_groupQueueDeinit(v_groupQueue(o)); break;
case K_TOPIC: v_topicDeinit(v_topic(o)); break;
case K_ENTITY: break;
case K_DOMAIN: v_partitionDeinit(v_partition(o)); break;
case K_GROUP: v_groupDeinit(v_group(o)); break;
case K_SERVICEMANAGER: /* Is never freed! */ break;
case K_SPLICED: v_splicedDeinit(v_spliced(o)); break;
case K_NETWORKING:
case K_DURABILITY:
case K_CMSOAP:
case K_SERVICE: v_serviceDeinit(v_service(o)); break;
case K_SERVICESTATE: /* Is never freed! */ break;
case K_CONFIGURATION: break;
case K_QUERY:
OS_REPORT(OS_ERROR, "v_publicDispose failure",
0, "deinit of abstract class K_QUERY");
break;
case K_DATAREADERQUERY:
v_dataReaderQueryDeinit(v_dataReaderQuery(o));
break;
case K_DATAVIEWQUERY:
v_dataViewQueryDeinit(v_dataViewQuery(o));
break;
case K_DATAVIEW: v_dataViewDeinit(v_dataView(o)); break;
case K_WAITSET: v_waitsetDeinit(v_waitset(o)); break;
case K_WRITERINSTANCE:
v_writerInstanceDeinit(v_writerInstance(o));
break;
case K_DATAREADERINSTANCE:
v_dataReaderInstanceDeinit(v_dataReaderInstance(o));
break;
case K_DATAVIEWINSTANCE:
v_dataViewInstanceDeinit(v_dataViewInstance(o));
break;
default:
OS_REPORT_1(OS_ERROR,"v_publicDispose failed",0,
"illegal entity kind (%d) specified",v_objectKind(o));
assert(FALSE);
break;
}
c_free(o);
}
static void
issueLowMemoryWarning(
c_voidp arg)
{
#ifdef DDS_1958_CANNOT_CALL_REGISTERED_FUNC_PTR_FROM_DIFF_PROCESS
os_uint32 warningCount;
v_handleServer server;
server = v_handleServer(arg);
/* dds1958: ES: Check if the warning count is 0 at the moment. If so it
* means that no warning has been issued. If the value is not 0 however
* then we do not need to continue and do not need to do any increment
* and safe out on that code in situations where we get the low memory
* warning a lot. The idea is that just doing this check (although not
* a definate yes or no to doing the warning) is in the cases where
* a warning has already been issued much cheaper then doing the
* increment and then checking. Only in the situation where the warning
* is issued for the first time, is this check useless. But that is only
* 1 time vs many times.
*/
if(server->lowMemWarningCount == 0)
{
/* increment the warning count
*/
warningCount = pa_increment(&server->lowMemWarningCount);
if(warningCount == 1)
{
OS_REPORT(OS_WARNING,
"issueLowMemoryWarning",0,
"Shared memory is running very low!");
}
}
#endif
}
static DDS_ReturnCode_t
DDS_QosProviderReadLock (
gapi_handle handle,
_QosProvider *object)
{
_QosProvider qosProvider;
gapi_returnCode_t gapiResult;
DDS_ReturnCode_t result = DDS_RETCODE_OK;
assert (handle != NULL);
assert (object != NULL);
qosProvider = (_QosProvider)
gapi_objectReadClaim (handle, OBJECT_KIND_QOSPROVIDER, &gapiResult);
result = gapiReturnCodeToReturnCode (gapiResult);
if (result != DDS_RETCODE_OK) {
OS_REPORT (OS_ERROR, "DDS_QosProviderReadLock", 0,
"Could not read lock QosProvider");
} else {
*object = qosProvider;
}
return result;
}
d_sample
d_groupInfoSampleNew (
d_groupInfo _this,
d_instance instance,
v_message msg)
{
d_sample sample;
v_message mmfMessage;
sample = d_sample(c_new(_this->topic->sampleType));
if (sample) {
c_cloneIn(_this->topic->messageType, msg, (c_voidp*)&(mmfMessage));
d_sampleTemplate(sample)->message = mmfMessage;
sample->instance = instance;
sample->older = NULL;
sample->newer = NULL;
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoSampleNew",0,
"Failed to allocate sample.");
assert(FALSE);
}
return sample;
}
DDS::Subscriber_impl::~Subscriber_impl()
{
if (os_mutexDestroy(&s_mutex) != os_resultSuccess)
{
OS_REPORT(OS_ERROR, "CCPP", 0, "Unable to destroy mutex");
}
}
v_cache
v_groupCacheNew (
v_kernel kernel,
v_cacheKind kind)
{
c_base base;
c_type type;
v_cache cache;
assert(C_TYPECHECK(kernel,v_kernel));
base = c_getBase(kernel);
type = c_keep(v_kernelType(kernel,K_GROUPCACHEITEM));
cache = v_cacheNew(kernel,type,kind);
c_free(type);
if (!cache) {
OS_REPORT(OS_ERROR,
"v_groupCacheNew",0,
"Failed to allocate group cache.");
}
assert(C_TYPECHECK(cache, v_cache));
return cache;
}
u_result
u_readerGetDeadlineMissedStatus(
u_reader _this,
c_bool reset,
v_statusAction action,
c_voidp arg)
{
v_reader reader;
u_result result;
result = U_RESULT_PRECONDITION_NOT_MET;
if (_this != NULL) {
result = u_entityReadClaim(u_entity(_this), (v_entity*)(&reader));
if (result == U_RESULT_OK){
result = u_resultFromKernel(
v_readerGetDeadlineMissedStatus(reader,
reset,
(v_statusAction)action,
arg));
u_entityRelease(u_entity(_this));
} else {
OS_REPORT(OS_ERROR, "u_readerDeadlineMissedStatus", 0,
"Illegal handle detected");
}
}
return result;
}
u_result
u_serviceRenewLease(
u_service _this,
v_duration leasePeriod)
{
u_result r;
v_service kernelService;
if (_this == NULL) {
r = U_RESULT_ILL_PARAM;
} else {
r = u_entityReadClaim(u_entity(_this), (v_entity*)(&kernelService));
if(r == U_RESULT_OK)
{
assert(kernelService);
v_serviceRenewLease(kernelService, leasePeriod);
r = u_entityRelease(u_entity(_this));
} else {
OS_REPORT(OS_WARNING,
"u_serviceRenewLease", 0,
"Failed to claim service.");
}
}
return r;
}
v_groupCacheItem
v_groupCacheItemNew (
v_groupInstance groupInstance,
v_instance instance)
{
v_groupCacheItem item;
v_cache cache;
assert(groupInstance != NULL);
assert(instance != NULL);
assert(C_TYPECHECK(groupInstance,v_groupInstance));
assert(C_TYPECHECK(instance,v_instance));
cache = groupInstance->targetCache;
item = v_groupCacheItem(v_cacheNodeNew(cache));
if (item) {
v_cacheItem(item)->instance = instance;
item->groupInstance = groupInstance;
item->registrationCount = 1;
item->pendingResends = 0;
} else {
OS_REPORT(OS_ERROR,
"v_groupCacheItemNew",0,
"Failed to allocate group cache item.");
}
assert(C_TYPECHECK(item,v_groupCacheItem));
return item;
}
v_dataViewInstance
v_dataViewInstanceNew(
v_dataView dataView,
v_dataViewSample viewSample)
{
v_dataViewInstance instance;
assert(dataView);
assert(viewSample);
assert(C_TYPECHECK(dataView,v_dataView));
assert(C_TYPECHECK(viewSample,v_dataViewSample));
instance = v_dataViewInstance(c_new(dataView->instanceType));
if (instance) {
v_object(instance)->kernel = v_objectKernel(dataView);
v_objectKind(instance) = K_DATAVIEWINSTANCE;
v_instanceInit(v_instance(instance), v_entity(dataView));
viewSample->next = viewSample;
v_dataViewInstanceTemplate(instance)->sample = viewSample;
instance->sampleCount = 1;
v_stateSet(v_instanceState(instance),L_NEW);
v_stateClear(v_readerSample(viewSample)->sampleState,L_READ);
assert(C_TYPECHECK(instance,v_dataViewInstance));
CHECK_INSTANCE(instance);
} else {
OS_REPORT(OS_FATAL, OS_FUNCTION, V_RESULT_INTERNAL_ERROR,
"Failed to allocate v_dataViewInstance");
assert(FALSE);
}
return instance;
}
DDS::ContentFilteredTopic_impl::~ContentFilteredTopic_impl()
{
if (os_mutexDestroy(&cft_mutex) != os_resultSuccess)
{
OS_REPORT(OS_ERROR, "CCPP", 0, "Unable to destroy mutex");
}
}
DDS::DomainParticipant_impl::~DomainParticipant_impl()
{
if (os_mutexDestroy(&dp_mutex) != os_resultSuccess)
{
OS_REPORT(OS_ERROR, "CCPP", 0, "Unable to destroy mutex");
}
}
DDS::StatusCondition_impl::~StatusCondition_impl( )
{
if (os_mutexDestroy(&sc_mutex) != os_resultSuccess)
{
OS_REPORT(OS_ERROR, "CCPP", 0, "Unable to destroy mutex");
}
}
void
cmx_writerDataTypeAction(
v_entity entity,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
c_type type;
struct cmx_writerTypeArg *arg;
arg = (struct cmx_writerTypeArg *)args;
type = NULL;
switch(v_object(entity)->kind){
case K_WRITER:
type = v_topicDataType(v_writer(entity)->topic);
break;
default:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Trying to resolve dataType of writer that is not a writer.\n");
assert(FALSE);
break;
}
if(type != NULL){
ser = sd_serializerXMLMetadataNew(c_getBase(type));
data = sd_serializerSerialize(ser, type);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
}
}
v_service
v_serviceNew(
v_kernel kernel,
const c_char *name,
const c_char *extStateName,
v_serviceType serviceType,
v_participantQos qos,
c_bool enable)
{
v_service s = NULL;
v_participantQos q;
assert(C_TYPECHECK(kernel, v_kernel));
/* Do not C_TYPECHECK qos parameter, since it might be allocated on heap! */
assert(name != NULL);
if (v_participantQosCheck(qos) == V_RESULT_OK) {
q = v_participantQosNew(kernel, (v_participantQos)qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_serviceNew", V_RESULT_INTERNAL_ERROR,
"Creation of service <%s> failed. Cannot create participant QoS.",
name);
} else {
s = v_service(v_objectNew(kernel, K_SERVICE));
v_serviceInit(s, name, extStateName, serviceType, q, enable);
c_free(q);
if (s->state == NULL) {
v_serviceFree(s);
s = NULL;
}
}
}
return s;
}
