v_cmsoap
v_cmsoapNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos)
{
v_kernel k;
v_cmsoap s;
v_participantQos q;
assert(C_TYPECHECK(manager, v_serviceManager));
assert(name != NULL);
k = v_objectKernel(manager);
q = v_participantQosNew(k, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_cmsoapNew", 0,
"CMSoap service not created: inconsistent qos");
s = NULL;
} else {
s = v_cmsoap(v_objectNew(k, K_CMSOAP));
v_serviceInit(v_service(s), manager, name, extStateName, q, v_statistics(v_cmsoapStatisticsNew(k)));
c_free(q);
/* always add, even when s->state==NULL, since v_participantFree always
removes the participant.*/
v_addParticipant(k, v_participant(s));
if (v_service(s)->state == NULL) {
v_serviceFree(v_service(s));
s = NULL;
}
}
return s;
}
v_networking
v_networkingNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos)
{
v_kernel k;
v_networking s;
v_participantQos q;
v_networkingStatistics ns;
assert(C_TYPECHECK(manager, v_serviceManager));
assert(name != NULL);
k = v_objectKernel(manager);
q = v_participantQosNew(k, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_networkingNew", 0,
"Networking service not created: inconsistent qos");
s = NULL;
} else {
s = v_networking(v_objectNew(k, K_NETWORKING));
if (v_isEnabledStatistics(k, V_STATCAT_NETWORKING)) {
ns = v_networkingStatistics(v_networkingStatisticsNew(k));
} else {
ns = NULL;
}
v_serviceInit(v_service(s),
manager,
name,
extStateName,
q,
v_statistics(ns));
c_free(q);
/* always add, even when s->state==NULL,
* since v_participantFree always removes the participant.
*/
v_addParticipant(k, v_participant(s));
if (v_service(s)->state == NULL) {
v_serviceFree(v_service(s));
s = NULL;
}
}
return s;
}
void
v_durabilityFree(
v_durability du)
{
assert(C_TYPECHECK(du, v_durability));
v_serviceFree(v_service(du));
}
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;
}
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);
}
void
v_cmsoapFree(
v_cmsoap cms)
{
assert(C_TYPECHECK(cms, v_cmsoap));
v_serviceFree(v_service(cms));
}
static void
freeKernelServiceObject (
v_entity e,
c_voidp argument)
{
v_serviceFree(v_service(e));
}
void
v_networkingFree(
v_networking nw)
{
assert(C_TYPECHECK(nw, v_networking));
v_serviceFree(v_service(nw));
}
void
v_rnrFree(
v_rnr _this)
{
assert(C_TYPECHECK(_this, v_rnr));
v_serviceFree(v_service(_this));
}
v_durability
v_durabilityNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos)
{
v_kernel k;
v_durability s;
v_participantQos q;
v_durabilityStatistics dStat;
assert(C_TYPECHECK(manager, v_serviceManager));
assert(name != NULL);
k = v_objectKernel(manager);
q = v_participantQosNew(k, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_durabilityNew", 0,
"Durability service not created: inconsistent qos");
s = NULL;
} else {
s = v_durability(v_objectNew(k, K_DURABILITY));
if (v_isEnabledStatistics(k, V_STATCAT_DURABILITY)) {
dStat = v_durabilityStatisticsNew(k);
} else {
dStat = NULL;
}
v_serviceInit(v_service(s), manager, name, extStateName, q, v_statistics(dStat));
c_free(q);
/* always add, even when s->state==NULL, since v_participantFree always
removes the participant.*/
v_addParticipant(k, v_participant(s));
if (v_service(s)->state == NULL) {
v_serviceFree(v_service(s));
s = NULL;
}
}
return s;
}
c_char*
cmx_serviceInit(
v_service entity)
{
char buf[512];
v_service service;
service = v_service(entity);
os_sprintf(buf, "<kind>SERVICE</kind>");
return (c_char*)(os_strdup(buf));
}
void
cmx_serviceAction(
v_entity service,
c_voidp args)
{
assert( (v_object(service)->kind == K_SERVICE) ||
(v_object(service)->kind == K_SPLICED) ||
(v_object(service)->kind == K_NETWORKING) ||
(v_object(service)->kind == K_DURABILITY) ||
(v_object(service)->kind == K_CMSOAP));
cmx_entityNewFromAction(v_entity(v_service(service)->state), args);
}
v_rnr
v_rnrNew(
v_kernel kernel,
const c_char *name,
const c_char *extStateName,
v_participantQos qos,
c_bool enable)
{
v_rnr _this;
v_participantQos q;
assert(C_TYPECHECK(kernel, v_kernel));
assert(name != NULL);
q = v_participantQosNew(kernel, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_rnrNew", V_RESULT_ILL_PARAM,
"Record and Replay service not created: inconsistent qos");
_this = NULL;
} else {
_this = v_rnr(v_objectNew(kernel, K_RNR));
_this->statistics = v_rnrStatisticsNew (kernel, name);
v_serviceInit(v_service(_this), name, extStateName, V_SERVICETYPE_RECORD_REPLAY, q, enable);
c_free(q);
/* always add, even when s->state==NULL, since v_participantFree always
* removes the participant.
*/
v_addParticipant(kernel, v_participant(_this));
if (v_service(_this)->state == NULL) {
v_serviceFree(v_service(_this));
_this = NULL;
} else {
OSPL_ADD_OBSERVER(kernel, _this, V_EVENT_NEW_GROUP, NULL);
}
}
return _this;
}
static void
cms_serviceActionGroups(
v_entity e,
c_voidp args)
{
v_service s;
c_iter groups;
v_group group;
OS_UNUSED_ARG(args);
s = v_service(e);
groups = v_serviceTakeNewGroups(s);
group = v_group(c_iterTakeFirst(groups));
while(group != NULL) {
c_free(group);
group = v_group(c_iterTakeFirst(groups));
}
c_iterFree(groups);
}
/**************************************************************
* constructor/destructor
**************************************************************/
v_service
v_serviceNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos,
v_statistics stats)
{
v_kernel k;
v_service s;
v_participantQos q;
assert(C_TYPECHECK(manager, v_serviceManager));
/* Do not C_TYPECHECK qos parameter, since it might be allocated on heap! */
assert(name != NULL);
k = v_objectKernel(manager);
/* do no use cast method on qos parameter,
* it is most likely allocated on heap! */
q = v_participantQosNew(k, (v_participantQos)qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_serviceNew", 0,
"Service not created: inconsistent qos");
s = NULL;
} else {
s = v_service(v_objectNew(k, K_SERVICE));
v_serviceInit(s, manager, name, extStateName, q, stats);
c_free(q);
/* always add, even when s->state==NULL, since v_participantFree always
removes the participant.*/
v_addParticipant(k, v_participant(s));
if (s->state == NULL) {
v_serviceFree(s);
s = NULL;
}
}
return s;
}
void
cmx_serviceActionGetState(
v_public service,
c_voidp args)
{
v_serviceState state;
c_char** result;
char *special;
assert( (v_object(service)->kind == K_SERVICE) ||
(v_object(service)->kind == K_SPLICED) ||
(v_object(service)->kind == K_NETWORKING) ||
(v_object(service)->kind == K_DURABILITY) ||
(v_object(service)->kind == K_NWBRIDGE) ||
(v_object(service)->kind == K_RNR) ||
(v_object(service)->kind == K_CMSOAP) ||
(v_object(service)->kind == K_DBMSCONNECT));
result = (c_char**)args;
assert(result);
state = (v_service(service))->state;
assert(state);
special = cmx_serviceStateInit(state);
assert(special);
/*
* C&M thinks that the ServiceState is an Entity. Simulate that.
*/
*result = cmx_entityXml((c_string) NULL,
(c_address) NULL,
(v_handle*) &((v_public(state))->handle),
(c_bool) TRUE,
(c_string) special);
os_free(special);
}
/**************************************************************
* constructor/destructor
**************************************************************/
u_service
u_serviceNew(
const c_char *uri,
c_long timeout,
const c_char *name,
const c_char *extendedStateName,
u_serviceKind kind,
v_qos qos)
{
u_domain domain;
v_kernel kk;
v_service ks;
v_serviceManager sm;
u_service s;
u_result r;
os_result osr;
c_bool serviceTermHandlerRequired = FALSE;
ks = NULL;
r = u_domainOpen(&domain, uri, timeout);
if (r != U_RESULT_OK) {
OS_REPORT_1(OS_ERROR,"u_serviceNew",0,
"Failure to open the kernel - return code %d", r);
return NULL;
}
s = NULL;
if (domain != NULL) {
r = u_entityWriteClaim(u_entity(domain),(v_entity*)(&kk));
if (r == U_RESULT_OK) {
assert(kk);
sm = v_getServiceManager(kk);
if (sm != NULL) {
#ifndef INTEGRITY
if (lockPages(kk, name)) {
osr = os_procMLockAll(OS_MEMLOCK_CURRENT|OS_MEMLOCK_FUTURE);
} else {
osr = os_resultSuccess;
}
if (osr == os_resultSuccess) {
#endif
switch(kind){
case U_SERVICE_DDSI:
case U_SERVICE_DDSIE:
case U_SERVICE_NETWORKING:
ks = v_service(v_networkingNew(sm, name,
extendedStateName,
(v_participantQos)qos));
serviceTermHandlerRequired = TRUE;
break;
case U_SERVICE_DURABILITY:
ks = v_service(v_durabilityNew(sm, name,
extendedStateName,
(v_participantQos)qos));
serviceTermHandlerRequired = TRUE;
break;
case U_SERVICE_CMSOAP:
ks = v_service(v_cmsoapNew(sm, name,
extendedStateName,
(v_participantQos)qos));
serviceTermHandlerRequired = TRUE;
break;
case U_SERVICE_RNR:
ks = v_service(v_rnrNew(sm, name,
extendedStateName,
(v_participantQos)qos));
serviceTermHandlerRequired = TRUE;
break;
case U_SERVICE_DBMSCONNECT:
case U_SERVICE_INCOGNITO:
ks = v_serviceNew(sm, name,
extendedStateName,
(v_participantQos)qos, NULL);
serviceTermHandlerRequired = TRUE;
break;
case U_SERVICE_SPLICED:
break;
default:
OS_REPORT(OS_WARNING,"u_serviceNew",0,
"Failed to start an unknown service kind");
break;
}
} else {
OS_REPORT(OS_ERROR,"u_serviceNew",0,
"Failed to lock memory pages for current process");
}
/* Install the service signal handlers if spliced is not within this
* same process. i.e. only do this if each service is in its own
* process so signal handlers won't interfere */
if (serviceTermHandlerRequired && !u_splicedInProcess()) {
os_procSetTerminationHandler(serviceTermHandler);
}
#ifndef INTEGRITY
} else {
OS_REPORT(OS_ERROR,"u_serviceNew",0,
"Failed to retrieve the Service Manager");
}
#endif
if (ks != NULL) {
s = u_entityAlloc(NULL,u_service,ks,TRUE);
r = u_serviceInit(s, kind, domain);
if (r != U_RESULT_OK) {
OS_REPORT_1(OS_ERROR,"u_serviceNew",0,
"Failed to initialize service: %s", name);
u_serviceFree(s);
s = NULL;
}
callbackService = s;
(void) os_signalHandlerSetExceptionCallback(u__serviceExceptionCallbackWrapper);
} else {
OS_REPORT(OS_WARNING,"u_serviceNew",0,
"Failed to retrieve the Service Manager");
}
r = u_entityRelease(u_entity(domain));
}
}
return s;
}
/**
* PRE: v_observerLock has been called.
*
* When the text 'intentionally no break' is set after a case label
* the class specified by the label has not implemented the notify
* method.
*/
void
v_observerNotify(
v_observer _this,
v_event event,
c_voidp userData)
{
/* This Notify method is part of the observer-observable pattern.
* It is designed to be invoked when _this object as observer receives
* an event from an observable object.
* It must be possible to pass the event to the subclass of itself by
* calling <subclass>Notify(_this, event, userData).
* This implies that _this cannot be locked within any Notify method
* to avoid deadlocks.
* For consistency _this must be locked by v_observerLock(_this) before
* calling this method.
*/
c_ulong trigger;
assert(_this != NULL);
assert(C_TYPECHECK(_this,v_observer));
/* The observer will be made insensitive to event as soon as the
* observer is deinitialized. However it may be that destruction
* of the observer has started before the deinit of the observer
* is called. In that case the V_EVENT_OBJECT_DESTROYED flag will
* be set to avoid processing of incomming events.
*/
if ((_this->eventFlags & V_EVENT_OBJECT_DESTROYED) == 0) {
/* The observer is valid so the event can be processed.
*/
if (event != NULL ) {
trigger = event->kind & _this->eventMask;
} else {
/* NULL-event always notifies observers */
trigger = V_EVENT_TRIGGER;
}
/* The following code invokes the observers subclass specific
* notification method.
* This is a bit strange that the observer has knowledge about
* the subclass notification methods, a better model is that
* subclasses register the notification method to the observer
* instead. The reason for this model is that registering a
* function pointer is only valid in the process scope and this
* method will typically be called from another process.
*/
if (trigger != 0) {
switch (v_objectKind(_this)) {
case K_DATAREADER:
v_dataReaderNotify(v_dataReader(_this), event, userData);
break;
case K_WAITSET:
v_waitsetNotify(v_waitset(_this), event, userData);
break;
case K_PARTICIPANT:
v_participantNotify(v_participant(_this), event, userData);
break;
case K_TOPIC:
v_topicNotify(v_topic(_this), event, userData);
break;
case K_QUERY:
/* v_queryNotify(v_query(_this), event, userData); */
break;
case K_SPLICED: /* intentionally no break */
case K_SERVICE:
case K_NETWORKING:
case K_DURABILITY:
case K_CMSOAP:
v_serviceNotify(v_service(_this), event, userData);
break;
case K_SERVICEMANAGER:
v_serviceManagerNotify(v_serviceManager(_this), event, userData);
break;
case K_WRITER: /* no action for the following observers */
case K_PUBLISHER:
case K_SUBSCRIBER:
case K_GROUPQUEUE:
break;
default:
OS_REPORT_1(OS_INFO,"Kernel Observer",0,
"Notify an unknown observer type: %d",
v_objectKind(_this));
break;
}
/*
* Only trigger condition variable if at least
* one thread is waiting AND the event is seen for the first time.
*/
if ((_this->waitCount > 0) &&
((trigger == V_EVENT_TRIGGER) || (~_this->eventFlags & trigger)))
{
_this->eventFlags |= trigger; /* store event */
c_condBroadcast(&_this->cv);
} else {
_this->eventFlags |= trigger; /* store event */
}
}
} /* else observer object destroyed, skip notification */
}
void
v_serviceInit(
v_service service,
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos,
v_statistics stats)
{
c_char *typeName;
v_duration lp = {300, 0};
v_kernel kernel;
assert(service != NULL);
assert(C_TYPECHECK(service, v_service));
assert(C_TYPECHECK(qos, v_participantQos));
assert(name != NULL);
kernel = v_objectKernel(service);
v_participantInit(v_participant(service), name, qos, stats, TRUE);
service->state = v_serviceManagerRegister(manager, service, extStateName);
service->lease = v_leaseNew(kernel, lp);
if(service->lease)
{
v_result result;
result = v_leaseManagerRegister(
kernel->livelinessLM,
service->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(service->state),
FALSE/*do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT_1(OS_ERROR, "v_service", 0,
"A fatal error was detected when trying to register the liveliness lease "
"to the liveliness lease manager of the kernel. The result code was %d.", result);
}
} else
{
OS_REPORT(OS_ERROR, "v_service", 0,
"Unable to create a liveliness lease! Most likely not enough shared "
"memory available to complete the operation.");
}
if(service->lease)/* aka everything is ok so far */
{
v_result result;
c_iter participants;
v_participant splicedParticipant;
participants = v_resolveParticipants(kernel, V_SPLICED_NAME);
assert(c_iterLength(participants) == 1 || 0 == strcmp(name, V_SPLICED_NAME));
splicedParticipant = v_participant(c_iterTakeFirst(participants));
if(splicedParticipant)
{
result = v_leaseManagerRegister(
v_participant(service)->leaseManager,
v_service(splicedParticipant)->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(v_service(splicedParticipant)->state),
FALSE /* only observing, do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT_3(OS_ERROR, "v_service", 0,
"A fatal error was detected when trying to register the spliced's liveliness lease "
"to the lease manager of participant %p (%s). The result code was %d.", service, name, result);
}
}
c_iterFree(participants);
}
if (service->state != NULL) {
/* check if state has correct type */
typeName = c_metaScopedName(c_metaObject(c_getType(c_object(service->state))));
if (extStateName == NULL) {
extStateName = VSERVICESTATE_NAME;
}
if (strcmp(typeName, extStateName) == 0) {
if (strcmp(name, V_SPLICED_NAME) != 0) {
/* Splicedaemon may not observer itself! */
v_serviceWatchSplicedaemon(service);
}
} else {
OS_REPORT_2(OS_ERROR, "v_service",
0, "Requested state type (%s) differs with existing state type (%s)",
extStateName, typeName);
c_free(service->state);
service->state = NULL;
}
os_free(typeName);
}
}
void
v_serviceInit(
v_service service,
const c_char *name,
const c_char *extStateName,
v_serviceType serviceType,
v_participantQos qos,
c_bool enable)
{
c_char *typeName;
os_duration lp = 300*OS_DURATION_SECOND;
v_kernel kernel;
v_serviceManager manager;
assert(service != NULL);
assert(serviceType != V_SERVICETYPE_NONE);
assert(C_TYPECHECK(service, v_service));
assert(C_TYPECHECK(qos, v_participantQos));
assert(name != NULL);
kernel = v_objectKernel(service);
manager = v_getServiceManager(kernel);
/* v_participantInit writes the DCPSParticipant and CMParticipant topics, but
* it downcasts to v_service to extract serviceType, and hence needs it available.
*/
service->serviceType = serviceType;
v_participantInit(v_participant(service), name, qos);
if(enable) {
(void)v_entityEnable(v_entity(service));
}
service->state = v_serviceManagerRegister(manager, service, extStateName);
service->lease = v_leaseMonotonicNew(kernel, lp);
service->newGroups = NULL;
if(service->lease)
{
v_result result;
result = v_leaseManagerRegister(
kernel->livelinessLM,
service->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(service->state),
FALSE/*do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT(OS_FATAL, "v_service", result,
"A fatal error was detected when trying to register the liveliness lease "
"to the liveliness lease manager of the kernel. The result code was %d.", result);
}
} else
{
OS_REPORT(OS_FATAL, "v_service", V_RESULT_INTERNAL_ERROR,
"Unable to create a liveliness lease! Most likely not enough shared "
"memory available to complete the operation.");
}
if(service->lease)/* aka everything is ok so far */
{
v_result result;
c_iter participants;
v_participant splicedParticipant;
participants = v_resolveParticipants(kernel, V_SPLICED_NAME);
assert(c_iterLength(participants) == 1 || 0 == strcmp(name, V_SPLICED_NAME));
splicedParticipant = v_participant(c_iterTakeFirst(participants));
if(splicedParticipant)
{
result = v_leaseManagerRegister(
v_participant(service)->leaseManager,
v_service(splicedParticipant)->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(v_service(splicedParticipant)->state),
FALSE /* only observing, do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT(OS_FATAL, "v_service", result,
"A fatal error was detected when trying to register the spliced's liveliness lease "
"to the lease manager of participant %p (%s). The result code was %d.", (void*)service, name, result);
}
c_free(splicedParticipant);
}
c_iterFree(participants);
}
if (service->state != NULL) {
/* check if state has correct type */
typeName = c_metaScopedName(c_metaObject(c_getType(c_object(service->state))));
if (extStateName == NULL) {
extStateName = VSERVICESTATE_NAME;
}
if (strcmp(typeName, extStateName) == 0) {
/* Splicedaemon may not observer itself! */
if (strcmp(name, V_SPLICED_NAME) != 0) {
v_serviceState splicedState;
splicedState = v_serviceManagerGetServiceState(manager, V_SPLICED_NAME);
(void)OSPL_ADD_OBSERVER(splicedState, service, V_EVENT_SERVICESTATE_CHANGED, NULL);
}
} else {
OS_REPORT(OS_ERROR, "v_service",
V_RESULT_ILL_PARAM, "Requested state type (%s) differs with existing state type (%s)",
extStateName, typeName);
c_free(service->state);
service->state = NULL;
}
os_free(typeName);
}
}