void
v_instanceUnregister (
v_instance instance,
v_registration registration,
c_time timestamp)
{
c_char* metaName;
assert(C_TYPECHECK(instance, v_instance));
switch (v_objectKind(instance)) {
case K_DATAREADERINSTANCE:
v_dataReaderInstanceUnregister(v_dataReaderInstance(instance),
registration, timestamp);
break;
default:
metaName = c_metaName(c_metaObject(c_getType(instance)));
OS_REPORT_1(OS_ERROR,
"v_instanceUnregister",0,
"Unknown instance type <%s>",
metaName);
c_free(metaName);
break;
}
}
c_bool
cmx_readerCopy(
c_object o,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
struct cmx_readerArg *arg;
v_dataReaderSample sample, prev;
arg = (struct cmx_readerArg *)args;
if(o != NULL){
sample = v_dataReaderSample(o);
prev = sample->prev;
sample->prev = NULL;
ser = sd_serializerXMLNewTyped(c_getType(o));
data = sd_serializerSerialize(ser, o);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
sample->prev = prev;
}
return FALSE;
}
v_actionResult
cmx_readerReadCopy(
c_object o,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
v_dataReaderSample sample, newer;
struct cmx_readerArg *arg;
v_actionResult result;
result = 0;
if(o != NULL){
sample = v_dataReaderSample(o);
if(v_stateTest(v_readerSampleState(sample), L_READ)){
v_actionResultSet(result, V_PROCEED);
} else {
sample = v_dataReaderSample(o);
newer = sample->newer;
sample->newer = NULL;
arg = (struct cmx_readerArg *)args;
ser = sd_serializerXMLNewTyped(c_getType(o));
data = sd_serializerSerialize(ser, o);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
sample->newer = newer;
}
}
return result;
}
c_bool
cmx_readerReadCopy(
c_object o,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
v_dataReaderSample sample, prev;
struct cmx_readerArg *arg;
c_bool result;
result = FALSE;
if(o != NULL){
sample = v_dataReaderSample(o);
if(v_stateTest(v_readerSampleState(sample), L_READ)){
result = TRUE;
} else {
sample = v_dataReaderSample(o);
prev = sample->prev;
sample->prev = NULL;
arg = (struct cmx_readerArg *)args;
ser = sd_serializerXMLNewTyped(c_getType(o));
data = sd_serializerSerialize(ser, o);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
sample->prev = prev;
}
}
return result;
}
static void
printWalkHistory (
c_object o,
c_iterActionArg arg)
{
c_type type;
c_char *name, *ename;
if (o) {
type = c_getType(o);
name = c_metaScopedName(c_metaObject(type));
printf("<0x%x> %s",(HEXVALUE)o,name);
if (c_checkType(o, "v_entity") == o) {
ename = v_entityName(o);
if (ename != NULL) {
printf(" /* %s */", ename);
}
} else if (c_checkType(o, "c_metaObject") == o) {
ename = c_metaScopedName(o);
if (ename != NULL) {
printf(" /* %s */", ename);
os_free(ename);
}
}
printf("\n");
} else {
printf("<0x0>\n");
}
}
v_actionResult
cmx_readerCopy(
c_object o,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
struct cmx_readerArg *arg;
v_dataReaderSample sample, older;
v_actionResult result = 0;
v_lifespanSample next;
arg = (struct cmx_readerArg *)args;
if(o != NULL){
sample = v_dataReaderSample(o);
older = sample->older;
next = sample->_parent._parent.next;
sample->older = NULL;
sample->_parent._parent.next = NULL;
ser = sd_serializerXMLNewTyped(c_getType(o));
data = sd_serializerSerialize(ser, o);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
sample->older = older;
sample->_parent._parent.next = next;
}
return result;
}
void
v_messageEOTExtFree (
v_messageEOTExt xmsg)
{
c_type xmsgType = c_getType (xmsg);
memset (xmsg, 0, xmsgType->size);
c_free (xmsg);
}
static void
toolAction (
d_storeMMFKernel kernel,
c_voidp addr)
{
c_base base;
c_type type;
c_char *name;
c_object o;
c_address offset;
c_long size;
struct toolActionData actionData;
actionData.fin = stdin;
actionData.fout = stdout;
actionData.depth = 0;
actionData.stack = NULL;
base = c_getBase(kernel);
o = c_baseCheckPtr(base, addr);
if (o) {
type = c_getType(o);
size = c_typeSize(type);
if (o != addr) {
offset = C_ADDRESS(addr) - C_ADDRESS(o);
if (offset < (c_address)size) {
printf("Warning: address is %lu bytes in %s "
"object starting at 0x"PA_ADDRFMT"\n",
offset, _METANAME(type), (os_address)o);
OBJECT_PUSH(&actionData, o);
tryPrintOffset(o,&actionData,offset);
OBJECT_POP(&actionData);
} else {
printf("Warning: address is %lu bytes in "
"memory starting at 0x"PA_ADDRFMT"\n",
offset, (os_address)o);
}
} else {
name = c_metaScopedName(c_metaObject(type));
printf("Object <0x"PA_ADDRFMT"> refCount=%d size=%d type is: <0x"PA_ADDRFMT"> %s\n",
(os_address)o, c_refCount(o), size, (os_address)type, name);
os_free(name);
OBJECT_PUSH(&actionData, o);
printType(type, &actionData);
printf("\n");
OBJECT_POP(&actionData);
}
} else {
printf("Address <0x"PA_ADDRFMT"> is not a Database Object\n",
(os_address)addr);
}
}
v_message
v_messageExtConvertFromExtType (
c_type msgType,
v_messageExt xmsg)
{
c_type xmsgType = c_getType (xmsg);
v_message vmsg;
vmsg = c_new_s (msgType);
if (vmsg) {
v_messageExtConvertHeaderFromExt (vmsg, xmsg);
memcpy (vmsg + 1, xmsg + 1, xmsgType->size - sizeof (*xmsg));
memset (xmsg, 0, xmsgType->size);
c_free (xmsg);
}
return vmsg;
}
static void
printHistory (
c_iter history,
c_long cursor)
{
c_type type;
c_object o;
c_char *name, *ename;
o = c_iterObject(history,cursor-1);
type = c_getType(o);
name = c_metaScopedName(c_metaObject(type));
printf("<0x%x> %s",(HEXVALUE)o,name);
if (c_checkType(o, "v_entity") == o) {
ename = v_entityName(o);
if (ename != NULL) {
printf(" /* %s */", ename);
}
}
printf("\n");
}
v_messageQos
v_messageQos_copy (
v_messageQos src)
{
v_messageQos _this;
c_ulong size;
c_type type = NULL;
size = c_arraySize(src);
type = c_getType(src);
_this = c_newArray((c_collectionType)type,size);
if (_this) {
memcpy(_this,src,size);
} else {
OS_REPORT(OS_CRITICAL,
"v_messageQos_copy",V_RESULT_INTERNAL_ERROR,
"Failed to allocate messageQos.");
}
return _this;
}
static c_bool
printCollectionAction(
c_object o,
c_voidp arg)
{
c_type type;
toolActionData actionData = (toolActionData)arg;
c_char *name;
if (o != NULL) {
type = c_getType(o);
name = c_metaScopedName(c_metaObject(type));
iprintf("Object <0x%x> type is: <0x%x> %s\n",
(HEXVALUE)o, (HEXVALUE)type, name);
os_free(name);
OBJECT_PUSH(actionData, o);
printType(type, actionData);
printf("\n");
OBJECT_POP(actionData);
}
return TRUE;
}
static void
printCollectionAction(
c_metaObject mo,
c_scopeWalkActionArg arg)
{
c_type type;
c_object o = c_metaObject (mo);
toolActionData actionData = (toolActionData)arg;
c_char *name;
if (o != NULL) {
type = c_getType(o);
name = c_metaScopedName(c_metaObject(type));
iprintf("Object <0x"PA_ADDRFMT"> refCount=%d type is: <0x"PA_ADDRFMT"> %s\n",
(os_address)o, c_refCount(o), (os_address)type, name);
os_free(name);
OBJECT_PUSH(actionData, o);
printType(type, actionData);
printf("\n");
OBJECT_POP(actionData);
}
}
v_writeResult
v_instanceWrite(
v_instance instance,
v_message message)
{
c_char *metaName;
assert(C_TYPECHECK(instance, v_instance));
switch (v_objectKind(instance)) {
case K_DATAREADERINSTANCE:
return v_dataReaderInstanceWrite(v_dataReaderInstance(instance),message);
default:
metaName = c_metaName(c_metaObject(c_getType(instance)));
OS_REPORT_1(OS_ERROR,
"v_instanceWrite",0,
"Unknown instance type <%s>",
metaName);
c_free(metaName);
return V_WRITE_PRE_NOT_MET;
}
}
c_bool
cmx_writerHistoryCopy(
c_object sample,
c_voidp args)
{
struct cmx_writerSnapshotArg* arg;
sd_serializedData data;
c_char* xml;
arg = (struct cmx_writerSnapshotArg*)args;
if(arg->serializer == NULL){
arg->serializer = sd_serializerXMLNewTyped(c_getType(sample));
}
data = sd_serializerSerialize(arg->serializer, sample);
xml = sd_serializerToString(arg->serializer, data);
arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, xml);
sd_serializedDataFree(data);
return TRUE;
}
static void
printCollection(
c_collectionType type,
toolActionData actionData)
{
c_long size, i, offset, esize;
c_object o;
c_voidp p;
c_object arrayElement;
c_type subtype;
c_bool isRef;
o = c_iterObject(actionData->stack, 0);
switch (type->kind) {
case C_ARRAY:
case C_SEQUENCE:
/* Walk over all entries */
switch (type->kind) {
case C_ARRAY:
if (type->maxSize == 0) {
size = c_arraySize((c_array)o);
} else {
size = type->maxSize;
}
break;
case C_SEQUENCE:
size = c_arraySize((c_array)o);
break;
default:
size = 0;
assert(FALSE);
break;
}
if (c_typeIsRef(type->subType)) {
esize = sizeof(c_voidp);
isRef = TRUE;
} else {
esize = type->subType->size;
isRef = FALSE;
}
p = o;
offset = 0;
for (i=0; i<size; i++) {
iprintf("Element (%d) Offset (%d)\n",i,offset);
arrayElement = isRef ? *((c_object *)p) : (c_object) p;
if (arrayElement != NULL) {
OBJECT_PUSH(actionData, arrayElement);
if (isRef) {
subtype = c_getType(arrayElement);
printType(subtype, actionData);
} else {
iprintf(" ");
printType(type->subType, actionData);
}
printf("\n");
OBJECT_POP(actionData);
} else {
iprintf(" <0x0>\n");
}
p = C_DISPLACE(p, esize);
offset += esize;
}
break;
case C_STRING:
printf(" \"%s\"",(c_char *)o);
break;
case C_SET:
case C_LIST:
case C_BAG:
case C_DICTIONARY:
case C_QUERY:
{
if (o != NULL) {
/* Walk over the elements */
c_walk(o, (c_action)printCollectionAction, actionData);
if (c_count(o) == 0) {
iprintf("<EMPTY>");
}
} else {
iprintf("<NULL>");
}
}
break;
case C_SCOPE:
c_scopeWalk(o, printCollectionAction, actionData);
break;
default:
printf("Specified type <0x"PA_ADDRFMT"> is not a valid collection type\n",
(os_address)type);
break;
}
}
void
cmx_readerSnapshotNewAction(
v_entity e,
c_voidp args)
{
v_dataReader reader;
c_iter instances;
v_dataReaderInstance instance;
v_dataReaderSample sample, prev;
v_query query;
c_bool release;
sd_serializer ser;
sd_serializedData data;
struct cmx_readerSnapshotArg* arg;
release = FALSE;
arg = (struct cmx_readerSnapshotArg*)args;
reader = NULL;
instances = NULL;
ser = NULL;
switch(v_object(e)->kind){
case K_DATAREADER:
reader = v_dataReader(e);
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
if(reader->index->objects){
instances = c_select(reader->index->notEmptyList, 0);
}
break;
case K_QUERY:
case K_DATAREADERQUERY:
query = v_query(e);
reader = v_dataReader(v_querySource(query));
if(reader != NULL){
release = TRUE;
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
switch(v_object(query)->kind){
case K_DATAREADERQUERY:
if(v_dataReaderQuery(query)->instanceQ){
instances = c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0);
}
break;
default:
OS_REPORT_1(OS_ERROR, CM_XML_CONTEXT, 0,
"cmx_readerSnapshotNewAction unknown kind (%d).",
v_object(query)->kind);
break;
}
}
break;
default:
break;
}
if(arg->success == TRUE){
arg->snapshot->samples = c_iterNew(NULL);
}
if(instances != NULL){
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
while(instance != NULL){
sample = c_keep(v_dataReaderInstanceHead(instance));
if(sample != NULL){
prev = sample->prev;
sample->prev = NULL;
if(ser == NULL){
ser = sd_serializerXMLNewTyped(c_getType(c_object(sample)));
}
data = sd_serializerSerialize(ser, c_object(sample));
arg->snapshot->samples = c_iterInsert(arg->snapshot->samples,
sd_serializerToString(ser, data));
sd_serializedDataFree(data);
sample->prev = prev;
c_free(sample);
}
c_free(instance);
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
}
c_iterFree(instances);
}
if(reader != NULL){
v_observerUnlock(v_observer(reader));
if(release == TRUE){
c_free(reader);
}
}
if(ser != NULL){
sd_serializerFree(ser);
}
}
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);
}
}
void
cmx_readerSnapshotNewAction(
v_public p,
c_voidp args)
{
v_dataReader reader;
c_iter instances;
v_dataReaderInstance instance;
v_dataReaderSample sample;
v_query query;
c_bool release;
sd_serializer ser;
sd_serializedData data;
struct cmx_readerSnapshotArg* arg;
release = FALSE;
arg = (struct cmx_readerSnapshotArg*)args;
reader = NULL;
instances = NULL;
ser = NULL;
switch(v_object(p)->kind){
case K_DATAREADER:
reader = v_dataReader(p);
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
if(reader->index->objects){
instances = ospl_c_select(reader->index->notEmptyList, 0);
}
break;
case K_QUERY:
case K_DATAREADERQUERY:
query = v_query(p);
reader = v_dataReader(v_querySource(query));
if(reader != NULL){
release = TRUE;
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
switch(v_object(query)->kind){
case K_DATAREADERQUERY:
if(v_dataReaderQuery(query)->instanceQ){
instances = ospl_c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0);
}
break;
default:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0,
"cmx_readerSnapshotNewAction unknown kind (%d).",
v_object(query)->kind);
break;
}
}
break;
default:
break;
}
if(arg->success == TRUE){
arg->snapshot->samples = c_iterNew(NULL);
}
if(instances != NULL){
v_dataReaderSample sampleShallowCopy = NULL;
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
while(instance != NULL){
v_state ivState = instance->_parent._parent.state & (L_DISPOSED | L_NOWRITERS | L_NEW);
sample = v_dataReaderInstanceOldest(instance);
if (sample != NULL) {
do {
v_state state = ivState | ((sample->_parent.sampleState & (L_READ | L_LAZYREAD)) ? L_READ : 0);
if (sampleShallowCopy == NULL) {
sampleShallowCopy = c_new(c_getType(c_object(sample)));
}
memcpy(sampleShallowCopy, sample, c_typeSize(c_getType(sampleShallowCopy)));
sampleShallowCopy->newer = NULL;
sampleShallowCopy->_parent.sampleState &= ~(L_DISPOSED | L_NOWRITERS | L_NEW | L_READ | L_LAZYREAD);
sampleShallowCopy->_parent.sampleState |= state;
if(ser == NULL){
ser = sd_serializerXMLNewTyped(c_getType(c_object(sampleShallowCopy)));
}
data = sd_serializerSerialize(ser, c_object(sampleShallowCopy));
arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, sd_serializerToString(ser, data));
sd_serializedDataFree(data);
sample = sample->newer;
} while (sample != NULL);
}
c_free(instance);
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
}
c_iterFree(instances);
if (sampleShallowCopy != NULL) {
memset(sampleShallowCopy, 0, c_typeSize(c_getType(sampleShallowCopy)));
c_free(sampleShallowCopy);
}
}
if(reader != NULL){
v_observerUnlock(v_observer(reader));
if(release == TRUE){
c_free(reader);
}
}
if(ser != NULL){
sd_serializerFree(ser);
}
}
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);
}
}
