void setInstQualifiers(CMPIInstance *ci, XtokQualifiers *qs)
{
XtokQualifier *nq = NULL,*q = qs ? qs->first : NULL;
CMPIValue val;
int rc;
while (q) {
if (q->type & CMPI_ARRAY) {
CMPIType type=q->type&~CMPI_ARRAY;
CMPIArray *arr = newCMPIArray(0, type, NULL);
int i;
if (q->data.array.max) {
for (i = 0; i < q->data.array.next; ++i) {
val = str2CMPIValue(type, q->data.array.values[i], NULL);
CMSetArrayElementAt(arr, i, &val, type);
native_release_CMPIValue(type,&val);
}
rc = addInstQualifier(ci, q->name, (CMPIValue*)&arr, q->type);
native_release_CMPIValue(q->type,(CMPIValue*)&arr);
}
}
else {
val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
rc = addInstQualifier(ci, q->name, &val, q->type);
native_release_CMPIValue( q->type,&val);
}
nq = q->next;
q = nq;
}
if (qs) {
qs->first = qs->last = NULL;
}
}
ResponseHdr scanCimXmlResponse(const char *xmlData, CMPIObjectPath *cop)
{
pthread_mutex_lock(&scan_mutex);
ParserControl control;
#if DEBUG
extern int do_debug;
if (do_debug)
fprintf(stderr,"*** CIMOM response: %s\n", xmlData);
#endif
memset(&control,0,sizeof(control));
XmlBuffer *xmb = newXmlBuffer(xmlData);
control.xmb = xmb;
control.respHdr.xmlBuffer = xmb;
control.respHdr.rvArray=newCMPIArray(0,0,NULL);
control.requestObjectPath = cop;
control.heap = parser_heap_init();
control.respHdr.rc = startParsing(&control);
parser_heap_term(control.heap);
releaseXmlBuffer(xmb);
pthread_mutex_unlock(&scan_mutex);
return control.respHdr;
}
void setClassProperties(CMPIConstClass *cls, XtokProperties *ps)
{
XtokProperty *np = NULL,*p = ps ? ps->first : NULL;
CMPIValue val;
CMPIArray *arr = NULL;
XtokQualifier *nq,*q;
XtokQualifiers *qs;
int rc, n;
val.uint64=0l;
while (p) {
switch (p->propType) {
case typeProperty_Value:
addClassProperty(cls, p->name, &val, p->valueType, CMPI_nullValue);
break;
case typeProperty_Reference:
addClassProperty(cls, p->name, &val, CMPI_ref, CMPI_nullValue);
break;
case typeProperty_Array:
val.array = arr;
addClassProperty(cls, p->name, &val,
p->valueType | CMPI_ARRAY, CMPI_nullValue);
break;
}
qs=&p->val.qualifiers;
q=qs ? qs->first : NULL;
n=0;
while (q) {
if (q->type & CMPI_ARRAY) {
CMPIType type=q->type&~CMPI_ARRAY;
arr = newCMPIArray(0, type, NULL);
int i;
if (q->data.array.max) {
for (i = 0; i < q->data.array.next; ++i) {
val = str2CMPIValue(type, q->data.array.values[i], NULL);
CMSetArrayElementAt(arr, i, &val, type);
native_release_CMPIValue(type,&val);
}
}
val.array = arr;
rc = addClassPropertyQualifier(cls, p->name, q->name, &val, q->type);
native_release_CMPIValue(q->type,(CMPIValue*)&arr);
}
else {
val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
rc= addClassPropertyQualifier(cls, p->name, q->name, &val, q->type);
native_release_CMPIValue(q->type,&val);
}
nq = q->next;
q = nq;
}
np = p->next;
p = np;
}
if (ps) ps->first = ps->last = NULL;
}
void setClassMethods(CMPIConstClass *cls, XtokMethods *ms)
{
XtokMethod *nm = NULL,*m = ms ? ms->first : NULL;
CMPIValue val;
CMPIArray *arr = NULL;
XtokQualifier *nq,*q;
XtokQualifiers *qs;
XtokParam *np,*p;
XtokParams *ps;
int rc, n;
val.uint64=0l;
while (m) {
addClassMethod(cls, m->name, &val, m->type, CMPI_nullValue);
qs=&m->qualifiers;
q=qs ? qs->first : NULL;
n=0;
while (q) {
if (q->type & CMPI_ARRAY) {
CMPIType type=q->type&~CMPI_ARRAY;
arr = newCMPIArray(0, type, NULL);
int i;
if (q->data.array.max) {
for (i = 0; i < q->data.array.next; ++i) {
val = str2CMPIValue(type, q->data.array.values[i], NULL);
CMSetArrayElementAt(arr, i, &val, type);
native_release_CMPIValue(type,&val);
}
}
val.array = arr;
rc = addClassMethodQualifier(cls, m->name, q->name, &val, q->type);
native_release_CMPIValue(q->type,(CMPIValue*)&arr);
}
else {
val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
rc= addClassMethodQualifier(cls, m->name, q->name, &val, q->type);
native_release_CMPIValue(q->type,&val);
}
nq = q->next;
q = nq;
}
ps=&m->params;
p=ps ? ps->first : NULL;
n=0;
while (p) {
rc= addClassMethodParameter(cls, m->name, p->name, p->type);
np = p->next;
p = np;
}
nm = m->next;
m = nm;
}
if (ms) ms->first = ms->last = NULL;
}
void setClassQualifiers(CMPIConstClass *cls, XtokQualifiers *qs)
{
XtokQualifier *nq = NULL,*q = qs ? qs->first : NULL;
CMPIValue val;
int rc;
while (q) {
if (q->type & CMPI_ARRAY) {
CMPIType type=q->type&~CMPI_ARRAY;
CMPIArray *arr = newCMPIArray(0, type, NULL);
int i;
if (q->data.array.max > 0) {
for (i = 0; i < q->data.array.next; ++i) {
char *valStr = q->data.array.values[i];
if (type == CMPI_string || type == CMPI_chars)
{
char *charsStr = XmlToAsciiStr(valStr);
val = str2CMPIValue(type, charsStr, NULL);
free (charsStr);
}
else
val = str2CMPIValue(type, valStr, NULL);
CMSetArrayElementAt(arr, i, &val, type);
native_release_CMPIValue(type,&val);
}
rc = addClassQualifier(cls, q->name, (CMPIValue*)&arr, q->type);
native_release_CMPIValue(q->type,(CMPIValue*)&arr);
}
}
else {
char *valStr = q->data.value.data.value;
if (q->type == CMPI_string || q->type == CMPI_chars)
{
char *charsStr = XmlToAsciiStr(valStr);
val = str2CMPIValue(q->type, charsStr, NULL);
free (charsStr);
}
else
val = str2CMPIValue(q->type, valStr, NULL);
rc = addClassQualifier(cls, q->name, &val, q->type);
native_release_CMPIValue( q->type,&val);
}
nq = q->next;
q = nq;
}
if (qs) {
qs->first = qs->last = NULL;
}
}
void setInstProperties(CMPIInstance *ci, XtokProperties *ps)
{
XtokProperty *np = NULL,*p = ps ? ps->first : NULL;
CMPIValue val;
CMPIObjectPath *op;
CMPIStatus status;
CMPIType type = CMPI_null;
XtokQualifier *nq = NULL,*q;
XtokQualifiers *qs;
int rc, n, setq;
while (p) {
setq=1;
switch (p->propType) {
case typeProperty_Value:
type = p->valueType;
if (p->val.value.data.value != NULL && p->val.null==0) {
if (type == CMPI_string || type == CMPI_chars) {
char *charsStr = XmlToAsciiStr(p->val.value.data.value);
val = str2CMPIValue(type, charsStr, NULL);
free (charsStr);
}
else
val = str2CMPIValue(type, p->val.value.data.value, NULL);
CMSetProperty(ci, p->name, &val, type);
native_release_CMPIValue(type, &val);
}
else {
CMSetProperty(ci, p->name, NULL, type);
setq = 0;
}
break;
case typeProperty_Reference:
val=str2CMPIValue(CMPI_ref, NULL, &p->val.ref);
CMSetProperty(ci, p->name, &val.ref, CMPI_ref);
CMRelease(val.ref);
break;
case typeProperty_Array:
type = p->valueType;
if (p->val.array.next > 0) {
CMPIArray *arr = newCMPIArray(0, type, &status);
if (p->val.array.max > 0) {
int i;
for (i = 0; i < p->val.array.next; ++i)
{
char *valStr = p->val.array.values[i];
if (type == CMPI_string || type == CMPI_chars) {
char *charsStr = XmlToAsciiStr(valStr);
val = str2CMPIValue(type, charsStr, NULL);
free (charsStr);
}
else
val = str2CMPIValue(type, valStr, NULL);
CMSetArrayElementAt(arr, i, &val, type);
native_release_CMPIValue(type, &val);
}
}
val.array = arr;
CMSetProperty(ci, p->name, &val, type | CMPI_ARRAY);
CMRelease(arr); /* cloned in property */
}
else {
CMSetProperty(ci, p->name, NULL, p->valueType | CMPI_ARRAY);
setq = 0;
}
break;
}
if (setq) {
qs=&p->val.qualifiers;
q=qs ? qs->first : NULL;
n=0;
while (q) {
if (q->type & CMPI_ARRAY) {
CMPIArray *arr = NULL;
arr = newCMPIArray(0, type, NULL);
type = q->type & ~CMPI_ARRAY;
int i;
if (q->data.array.max) {
for (i = 0; i < q->data.array.next; ++i) {
val = str2CMPIValue(type, q->data.array.values[i], NULL);
CMSetArrayElementAt(arr, i, &val, type);
native_release_CMPIValue(type,&val);
}
}
rc = addInstPropertyQualifier(ci, p->name, q->name,
(CMPIValue *)&arr, q->type);
native_release_CMPIValue(q->type,(CMPIValue*)&arr);
}
else {
val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
rc= addInstPropertyQualifier(ci, p->name, q->name, &val, q->type);
native_release_CMPIValue(q->type,&val);
}
nq = q->next;
q = nq;
}
}
np = p->next;
p = np;
}
if (ps)
ps->first = ps->last = NULL;
}
void * enumScanThrd(struct native_enum *NatEnum)
{
CMCIConnection * con = NatEnum->econ ; /* enumeration */
CMPIObjectPath * cop = NatEnum->ecop ; /* enumeration */
struct timespec tp ;
int rc = 0 ;
ParserControl control;
struct native_enum *local_enmp ;
memset(&control,0,sizeof(control));
/*
* get the data array and save a copy of address in enumeration
*/
XmlBuffer *xmb = newXmlBuffer(NULL);
control.xmb = xmb;
control.respHdr.xmlBuffer = xmb;
control.respHdr.rvArray=newCMPIArray(0,0,NULL);
local_enmp = con->asynRCntl.enmp ;
local_enmp->data = control.respHdr.rvArray ;
control.requestObjectPath = cop;
control.heap = parser_heap_init();
control.econ = con ;
if(rc = setjmp(save_env)) {
printf(" we had a timeout , we are going to exit from here \n") ;
con->asynRCntl.escanInfo.parsestate = PARSTATE_SERVER_TIMEOUT ;
con->asynRCntl.xfer_state = XFER_ERROR ;
return ;
}
/*
* wait for first data block received or xfer complete
* we need to have some data before starting
*/
while((con->asynRCntl.xfer_state != XFER_DATA_RECVD )&&
(con->asynRCntl.xfer_state != XFER_COMPLETE)){
usleep(100000) ;
}
control.respHdr.rc = startParsing(&control);
/*
* releaseXmlBuffer free's that last con->asynRCntl.escanInfo.section
* we clear out that pointer just to be safe
*/
releaseXmlBuffer(xmb);
con->asynRCntl.escanInfo.section = 0 ;
parser_heap_term(control.heap);
con->asynRCntl.escanInfo.parsestate = PARSTATE_COMPLETE ;
}
