version 1.2.2.5, 2009/10/13 13:39:24
|
version 1.3, 2009/12/15 11:39:33
|
|
|
#include <Pegasus/Common/XmlWriter.h> | #include <Pegasus/Common/XmlWriter.h> |
#include <Pegasus/Common/SCMOXmlWriter.h> | #include <Pegasus/Common/SCMOXmlWriter.h> |
#include <Pegasus/Common/XmlReader.h> | #include <Pegasus/Common/XmlReader.h> |
#include <Pegasus/Common/SCMOClassCache.h> |
#include <Pegasus/Common/CIMInternalXmlEncoder.h> |
|
#include <Pegasus/Common/SCMOInternalXmlEncoder.h> |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
| |
|
|
PEGASUS_DEBUG_ASSERT( | PEGASUS_DEBUG_ASSERT( |
(_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS)); | (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS)); |
_resolveToCIM(); | _resolveToCIM(); |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM); |
PEGASUS_DEBUG_ASSERT(_encoding==RESP_ENC_CIM || _encoding == 0); |
return _instanceNames; | return _instanceNames; |
} | } |
| |
|
|
{ | { |
PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE); | PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE); |
_resolveToCIM(); | _resolveToCIM(); |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM); |
if (0 == _instances.size()) |
|
{ |
|
_instances.append(CIMInstance()); |
|
} |
return _instances[0]; | return _instances[0]; |
} | } |
| |
|
|
{ | { |
PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES); | PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES); |
_resolveToCIM(); | _resolveToCIM(); |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM); |
|
return _instances; | return _instances; |
} | } |
| |
|
|
{ | { |
PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS); | PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS); |
_resolveToCIM(); | _resolveToCIM(); |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM); |
|
return _objects; | return _objects; |
} | } |
| |
|
|
Array<SCMOInstance>& CIMResponseData::getSCMO() | Array<SCMOInstance>& CIMResponseData::getSCMO() |
{ | { |
_resolveToSCMO(); | _resolveToSCMO(); |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO); |
|
return _scmoInstances; | return _scmoInstances; |
} | } |
| |
|
void CIMResponseData::setSCMO(const Array<SCMOInstance>& x) |
|
{ |
|
_scmoInstances=x; |
|
_encoding |= RESP_ENC_SCMO; |
|
} |
|
|
|
|
// Binary data is just a data stream | // Binary data is just a data stream |
Array<Uint8>& CIMResponseData::getBinary() | Array<Uint8>& CIMResponseData::getBinary() |
{ | { |
// TODO: Check if the following condition might come true |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY || _encoding == 0); |
// One actually should resolve everything down to binary in here ... |
|
return _binaryData; | return _binaryData; |
} | } |
| |
|
|
| |
bool CIMResponseData::setXml(CIMBuffer& in) | bool CIMResponseData::setXml(CIMBuffer& in) |
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, |
switch (_dataType) |
"CIMResponseData::setXml"); |
{ |
|
case RESP_INSTANCE: |
if (_dataType == RESP_INSTNAMES) |
{ |
|
Array<Sint8> inst; |
|
Array<Sint8> ref; |
|
CIMNamespaceName ns; |
|
String host; |
|
if (!in.getSint8A(inst)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML instance data!"); |
|
return false; |
|
} |
|
_instanceData.insert(0,inst); |
|
if (!in.getSint8A(ref)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML instance data (reference)!"); |
|
return false; |
|
} |
|
_referencesData.insert(0,ref); |
|
if (!in.getString(host)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML instance data (host)!"); |
|
return false; |
|
} |
|
_hostsData.insert(0,host); |
|
if (!in.getNamespaceName(ns)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML instance data (namespace)!"); |
|
return false; |
|
} |
|
_nameSpacesData.insert(0,ns); |
|
break; |
|
} |
|
case RESP_INSTANCES: |
{ | { |
Uint32 count; | Uint32 count; |
|
|
if (!in.getUint32(count)) | if (!in.getUint32(count)) |
{ | { |
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, | PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
"Failed to get XML objectpath data (number of paths)!"); |
"Failed to get XML instance data (number of instance)!"); |
PEG_METHOD_EXIT(); |
|
return false; | return false; |
} | } |
|
|
for (Uint32 i = 0; i < count; i++) | for (Uint32 i = 0; i < count; i++) |
{ | { |
|
Array<Sint8> inst; |
Array<Sint8> ref; | Array<Sint8> ref; |
CIMNamespaceName ns; | CIMNamespaceName ns; |
String host; | String host; |
|
if (!in.getSint8A(inst)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML instance data (instances)!"); |
|
return false; |
|
} |
if (!in.getSint8A(ref)) | if (!in.getSint8A(ref)) |
{ | { |
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, | PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
"Failed to get XML objectpath data (references)!"); |
"Failed to get XML instance data (references)!"); |
PEG_METHOD_EXIT(); |
|
return false; | return false; |
} | } |
|
|
if (!in.getString(host)) | if (!in.getString(host)) |
{ | { |
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, | PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
"Failed to get XML instance data (host)!"); | "Failed to get XML instance data (host)!"); |
PEG_METHOD_EXIT(); |
|
return false; | return false; |
} | } |
|
|
if (!in.getNamespaceName(ns)) | if (!in.getNamespaceName(ns)) |
{ | { |
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, | PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
"Failed to get XML instance data (namespace)!"); | "Failed to get XML instance data (namespace)!"); |
PEG_METHOD_EXIT(); |
|
return false; | return false; |
} | } |
|
_instanceData.append(inst); |
_referencesData.append(ref); | _referencesData.append(ref); |
_hostsData.append(host); | _hostsData.append(host); |
_nameSpacesData.append(ns); | _nameSpacesData.append(ns); |
} | } |
|
break; |
|
} |
|
case RESP_OBJECTS: |
|
{ |
|
Uint32 count; |
|
if (!in.getUint32(count)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML object data (number of objects)!"); |
|
return false; |
|
} |
|
for (Uint32 i = 0; i < count; i++) |
|
{ |
|
Array<Sint8> obj; |
|
Array<Sint8> ref; |
|
CIMNamespaceName ns; |
|
String host; |
|
if (!in.getSint8A(obj)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML object data (object)!"); |
|
return false; |
|
} |
|
if (!in.getSint8A(ref)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML object data (reference)!"); |
|
return false; |
|
} |
|
if (!in.getString(host)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML object data (host)!"); |
|
return false; |
|
} |
|
if (!in.getNamespaceName(ns)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get XML object data (namespace)!"); |
|
return false; |
|
} |
|
_instanceData.append(obj); |
|
_referencesData.append(ref); |
|
_hostsData.append(host); |
|
_nameSpacesData.append(ns); |
|
} |
|
break; |
|
} |
|
// internal xml encoding of instance names and object paths not |
|
// done today |
|
case RESP_INSTNAMES: |
|
case RESP_OBJECTPATHS: |
|
default: |
|
{ |
|
PEGASUS_DEBUG_ASSERT(false); |
|
} |
} | } |
// TODO: Code the left out types |
|
|
|
_encoding |= RESP_ENC_XML; | _encoding |= RESP_ENC_XML; |
PEG_METHOD_EXIT(); |
|
return true; | return true; |
} | } |
| |
|
|
} | } |
if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) | if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) |
{ | { |
// TODO: Set Marker for C++ data |
out.putTypeMarker(BIN_TYPE_MARKER_CPPD); |
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
{ | { |
out.putObjectPathA(_instanceNames, false); |
out.putObjectPathA(_instanceNames); |
break; | break; |
} | } |
case RESP_INSTANCE: | case RESP_INSTANCE: |
{ | { |
if (0 != _instances.size()) |
if (0 == _instances.size()) |
{ | { |
out.putInstance(_instances[0], false, false); |
_instances.append(CIMInstance()); |
} | } |
|
out.putInstance(_instances[0], true, true); |
break; | break; |
} | } |
case RESP_INSTANCES: | case RESP_INSTANCES: |
{ | { |
out.putInstanceA(_instances, false); |
out.putInstanceA(_instances); |
break; | break; |
} | } |
case RESP_OBJECTS: | case RESP_OBJECTS: |
|
|
} | } |
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
{ | { |
// TODO: Determine what to do here |
out.putObjectPathA(_instanceNames); |
break; | break; |
} | } |
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
} | } |
} | } |
if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) | if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) |
{ | { |
// TODO: Set Marker for SCMO data |
out.putTypeMarker(BIN_TYPE_MARKER_SCMO); |
|
out.putSCMOInstanceA(_scmoInstances); |
// Call magic here to transform a SCMO object into binary format |
|
fprintf(stderr, "Watch wat ya do'n! SCMO to binary ? NO OOP yet.\n"); |
|
fflush(stderr); |
|
} | } |
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) | if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
{ | { |
// This actually should not happen following general code logic | // This actually should not happen following general code logic |
PEGASUS_DEBUG_ASSERT(true); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
void CIMResponseData::encodeXmlResponse(Buffer& out) |
void CIMResponseData::completeNamespace(const SCMOInstance * x) |
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, |
const char * ns; |
"CIMResponseData::encodeXmlResponse"); |
Uint32 len; |
|
ns = x->getNameSpace_l(len); |
|
// Both internal XML as well as binary always contain a namespace |
|
// don't have to do anything for those two encodings |
|
if ((RESP_ENC_BINARY == (_encoding&RESP_ENC_BINARY)) && (len != 0)) |
|
{ |
|
_defaultNamespace = CIMNamespaceName(ns); |
|
} |
|
if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) |
|
{ |
|
CIMNamespaceName nsName(ns); |
|
switch (_dataType) |
|
{ |
|
case RESP_INSTANCE: |
|
{ |
|
if (_instances.size() > 0) |
|
{ |
|
const CIMInstance& inst = _instances[0]; |
|
CIMObjectPath& p = |
|
const_cast<CIMObjectPath&>(inst.getPath()); |
|
if (p.getNameSpace().isNull()) |
|
{ |
|
p.setNameSpace(nsName); |
|
} |
|
} |
|
} |
|
case RESP_INSTANCES: |
|
{ |
|
for (Uint32 j = 0, n = _instances.size(); j < n; j++) |
|
{ |
|
const CIMInstance& inst = _instances[j]; |
|
CIMObjectPath& p = |
|
const_cast<CIMObjectPath&>(inst.getPath()); |
|
if (p.getNameSpace().isNull()) |
|
{ |
|
p.setNameSpace(nsName); |
|
} |
|
} |
|
break; |
|
} |
|
case RESP_OBJECTS: |
|
{ |
|
for (Uint32 j = 0, n = _objects.size(); j < n; j++) |
|
{ |
|
const CIMObject& object = _objects[j]; |
|
CIMObjectPath& p = |
|
const_cast<CIMObjectPath&>(object.getPath()); |
|
if (p.getNameSpace().isNull()) |
|
{ |
|
p.setNameSpace(nsName); |
|
} |
|
} |
|
break; |
|
} |
|
case RESP_INSTNAMES: |
|
case RESP_OBJECTPATHS: |
|
{ |
|
for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++) |
|
{ |
|
CIMObjectPath& p = _instanceNames[j]; |
|
if (p.getNameSpace().isNull()) |
|
{ |
|
p.setNameSpace(nsName); |
|
} |
|
} |
|
break; |
|
} |
|
default: |
|
{ |
|
PEGASUS_DEBUG_ASSERT(false); |
|
} |
|
} |
|
} |
|
if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) |
|
{ |
|
for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++) |
|
{ |
|
SCMOInstance & scmoInst=_scmoInstances[j]; |
|
if (0 == scmoInst.getNameSpace()) |
|
{ |
|
scmoInst.setNameSpace_l(ns,len); |
|
} |
|
} |
|
} |
|
} |
| |
fprintf( |
|
stderr, |
|
"encodeXmlResponse(encoding=%X,content=%X)\n", |
|
_encoding, |
|
_dataType); |
|
fflush(stderr); |
|
| |
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
void CIMResponseData::completeHostNameAndNamespace( |
|
const String & hn, |
|
const CIMNamespaceName & ns) |
|
{ |
|
if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
|
{ |
|
// On binary need remember hostname and namespace in case someone |
|
// builds C++ default objects or Xml types from it later on |
|
// -> usage: See resolveBinary() |
|
_defaultNamespace=ns; |
|
_defaultHostname=hn; |
|
} |
|
// InternalXml does not support objectPath calls |
|
if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) && |
|
(RESP_OBJECTS == _dataType)) |
|
{ |
|
for (Uint32 j = 0, n = _referencesData.size(); j < n; j++) |
|
{ |
|
if (0 == _hostsData[j].size()) |
|
{ |
|
_hostsData[j]=hn; |
|
} |
|
if (_nameSpacesData[j].isNull()) |
|
{ |
|
_nameSpacesData[j]=ns; |
|
} |
|
} |
|
} |
|
if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) |
{ | { |
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_INSTNAMES: |
case RESP_OBJECTS: |
{ | { |
const Array<ArraySint8>& a = _referencesData; |
for (Uint32 j = 0, n = _objects.size(); j < n; j++) |
for (Uint32 i = 0, n = a.size(); i < n; i++) |
|
{ | { |
out.append((char*)a[i].getData(), a[i].size() - 1); |
const CIMObject& object = _objects[j]; |
|
CIMObjectPath& p = |
|
const_cast<CIMObjectPath&>(object.getPath()); |
|
if (p.getHost().size()==0) |
|
{ |
|
p.setHost(hn); |
|
} |
|
if (p.getNameSpace().isNull()) |
|
{ |
|
p.setNameSpace(ns); |
|
} |
|
} |
|
break; |
|
} |
|
case RESP_OBJECTPATHS: |
|
{ |
|
for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++) |
|
{ |
|
CIMObjectPath& p = _instanceNames[j]; |
|
if (p.getHost().size() == 0) |
|
p.setHost(hn); |
|
if (p.getNameSpace().isNull()) |
|
p.setNameSpace(ns); |
|
} |
|
break; |
|
} |
|
default: |
|
{ |
|
PEGASUS_DEBUG_ASSERT(false); |
|
} |
|
} |
|
} |
|
if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) |
|
{ |
|
CString hnCString=hn.getCString(); |
|
const char* hnChars = hnCString; |
|
Uint32 hnLen = strlen(hnChars); |
|
CString nsCString=ns.getString().getCString(); |
|
const char* nsChars=nsCString; |
|
Uint32 nsLen = strlen(nsChars); |
|
switch (_dataType) |
|
{ |
|
case RESP_OBJECTS: |
|
case RESP_OBJECTPATHS: |
|
{ |
|
for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++) |
|
{ |
|
SCMOInstance & scmoInst=_scmoInstances[j]; |
|
if (0 == scmoInst.getHostName()) |
|
{ |
|
scmoInst.setHostName_l(hnChars,hnLen); |
|
} |
|
if (0 == scmoInst.getNameSpace()) |
|
{ |
|
scmoInst.setNameSpace_l(nsChars,nsLen); |
|
} |
} | } |
break; | break; |
} | } |
|
default: |
|
{ |
|
PEGASUS_DEBUG_ASSERT(false); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void CIMResponseData::encodeXmlResponse(Buffer& out) |
|
{ |
|
PEG_TRACE((TRC_XML, Tracer::LEVEL3, |
|
"CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n", |
|
_encoding, |
|
_dataType)); |
|
|
|
// already existing Internal XML does not need to be encoded further |
|
// binary input is not actually impossible here, but we have an established |
|
// fallback |
|
if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
|
{ |
|
_resolveBinary(); |
|
} |
|
|
|
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
|
{ |
|
switch (_dataType) |
|
{ |
case RESP_INSTANCE: | case RESP_INSTANCE: |
{ | { |
out.append( |
const Array<ArraySint8>& a = _instanceData; |
(char*)_instanceData.getData(), |
out.append((char*)a[0].getData(), a[0].size() - 1); |
_instanceData.size()-1); |
|
break; | break; |
} | } |
case RESP_INSTANCES: | case RESP_INSTANCES: |
|
|
{ | { |
const Array<ArraySint8>& a = _instanceData; | const Array<ArraySint8>& a = _instanceData; |
const Array<ArraySint8>& b = _referencesData; | const Array<ArraySint8>& b = _referencesData; |
|
|
for (Uint32 i = 0, n = a.size(); i < n; i++) | for (Uint32 i = 0, n = a.size(); i < n; i++) |
{ | { |
out << STRLIT("<VALUE.OBJECTWITHPATH>\n"); | out << STRLIT("<VALUE.OBJECTWITHPATH>\n"); |
out.append((char*)b[i].getData(), b[i].size() - 1); |
out << STRLIT("<INSTANCEPATH>\n"); |
|
XmlWriter::appendNameSpacePathElement( |
|
out, |
|
_hostsData[i], |
|
_nameSpacesData[i]); |
|
// Leave out the surrounding tags "<VALUE.REFERENCE>\n" |
|
// and "</VALUE.REFERENCE>\n" which are 18 and 19 characters |
|
// long |
|
out.append( |
|
((char*)b[i].getData())+18, |
|
b[i].size() - 1 - 18 -19); |
|
out << STRLIT("</INSTANCEPATH>\n"); |
|
// append instance body |
out.append((char*)a[i].getData(), a[i].size() - 1); | out.append((char*)a[i].getData(), a[i].size() - 1); |
out << STRLIT("</VALUE.OBJECTWITHPATH>\n"); | out << STRLIT("</VALUE.OBJECTWITHPATH>\n"); |
} | } |
break; | break; |
} | } |
|
// internal xml encoding of instance names and object paths not |
|
// done today |
|
case RESP_INSTNAMES: |
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
{ |
|
// TODO: Check what to do in this case |
|
const Array<ArraySint8>& a = _instanceData; |
|
const Array<ArraySint8>& b = _referencesData; |
|
|
|
for (Uint32 i = 0, n = a.size(); i < n; i++) |
|
{ |
|
out << STRLIT("<VALUE.OBJECTWITHPATH>\n"); |
|
out.append((char*)b[i].getData(), b[i].size() - 1); |
|
out.append((char*)a[i].getData(), a[i].size() - 1); |
|
out << STRLIT("</VALUE.OBJECTWITHPATH>\n"); |
|
} |
|
} |
|
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
} | } |
} | } |
| |
if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) | if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) |
{ | { |
fprintf(stderr,"Got CIM data...\n"); |
|
fflush(stderr); |
|
// TODO: Set Marker for C++ data |
|
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
|
|
} | } |
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
} | } |
} | } |
if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) | if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) |
{ | { |
/*SCMODump dmp; |
|
dmp.dumpSCMOInstanceKeyBindings(_scmoInstances[i]); |
|
dmp.dumpInstanceProperties(_scmoInstances[i]);*/ |
|
|
|
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
|
|
} | } |
case RESP_INSTANCES: | case RESP_INSTANCES: |
{ | { |
fprintf( |
|
stderr,"encodeXmlResponse(SCMO)=%dinstances...\n", |
|
_scmoInstances.size()); |
|
fflush(stderr); |
|
|
|
for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++) | for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++) |
{ | { |
SCMOXmlWriter::appendValueSCMOInstanceElement( | SCMOXmlWriter::appendValueSCMOInstanceElement( |
|
|
{ | { |
for (Uint32 i = 0; i < _scmoInstances.size(); i++) | for (Uint32 i = 0; i < _scmoInstances.size(); i++) |
{ | { |
/* |
|
SCMOXmlWriter::appendValueObjectWithPathElement( | SCMOXmlWriter::appendValueObjectWithPathElement( |
out, | out, |
_scmoInstances[i]); | _scmoInstances[i]); |
*/ |
|
} | } |
break; | break; |
} | } |
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
{ | { |
|
for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++) |
|
{ |
|
out << "<OBJECTPATH>\n"; |
|
SCMOXmlWriter::appendValueReferenceElement( |
|
out, |
|
_scmoInstances[i], |
|
false); |
|
out << "</OBJECTPATH>\n"; |
|
} |
break; | break; |
} | } |
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
} | } |
/* fprintf( |
|
stderr, |
|
"After XmlWrite()\n%s", |
|
out.getData()); |
|
fflush(stderr);*/ |
|
} | } |
|
|
} | } |
| |
// contrary to encodeXmlResponse this function encodes the Xml in a format | // contrary to encodeXmlResponse this function encodes the Xml in a format |
// not usable by clients | // not usable by clients |
void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out) | void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out) |
{ | { |
// TODO: Implement |
PEG_TRACE((TRC_XML, Tracer::LEVEL3, |
// Need the full switch here again |
"CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)\n", |
// Should use the internal data available SCMO, C++ and InternalXML |
_encoding, |
// to generate the InternalXML by CIMInternalEncoder and SCMOInternalEncoder |
_dataType)); |
fprintf(stderr, "Watch wat ya do'n! SCMO to InternalXml ? NO OOP yet.\n"); |
|
fflush(stderr); |
// For mixed (CIM+SCMO) responses, we need to tell the receiver the |
|
// total number of instances. The totalSize variable is used to keep track |
|
// of this. |
|
Uint32 totalSize = 0; |
|
|
|
// already existing Internal XML does not need to be encoded further |
|
// binary input is not actually impossible here, but we have an established |
|
// fallback |
|
if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
|
{ |
|
_resolveBinary(); |
|
} |
|
if ((0 == _encoding) || |
|
(RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))) |
|
{ |
|
switch (_dataType) |
|
{ |
|
case RESP_INSTANCE: |
|
{ |
|
if (0 == _instances.size()) |
|
{ |
|
_instances.append(CIMInstance()); |
|
} |
|
CIMInternalXmlEncoder::_putXMLInstance(out, _instances[0]); |
|
break; |
|
} |
|
case RESP_INSTANCES: |
|
{ |
|
Uint32 n = _instances.size(); |
|
totalSize = n + _scmoInstances.size(); |
|
out.putUint32(totalSize); |
|
for (Uint32 i = 0; i < n; i++) |
|
{ |
|
CIMInternalXmlEncoder::_putXMLNamedInstance( |
|
out, |
|
_instances[i]); |
|
} |
|
break; |
|
} |
|
case RESP_OBJECTS: |
|
{ |
|
Uint32 n = _objects.size(); |
|
totalSize = n + _scmoInstances.size(); |
|
out.putUint32(totalSize); |
|
for (Uint32 i = 0; i < n; i++) |
|
{ |
|
CIMInternalXmlEncoder::_putXMLObject(out, _objects[i]); |
|
} |
|
break; |
|
} |
|
// internal xml encoding of instance names and object paths not |
|
// done today |
|
case RESP_INSTNAMES: |
|
case RESP_OBJECTPATHS: |
|
default: |
|
{ |
|
PEGASUS_DEBUG_ASSERT(false); |
|
} |
|
} |
|
} |
|
if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) |
|
{ |
|
switch (_dataType) |
|
{ |
|
case RESP_INSTANCE: |
|
{ |
|
if (0 == _scmoInstances.size()) |
|
{ |
|
_scmoInstances.append(SCMOInstance()); |
|
} |
|
SCMOInternalXmlEncoder::_putXMLInstance(out, _scmoInstances[0]); |
|
break; |
|
} |
|
case RESP_INSTANCES: |
|
{ |
|
Uint32 n = _scmoInstances.size(); |
|
// Only put the size when not already done above |
|
if (0==totalSize) |
|
{ |
|
out.putUint32(n); |
|
} |
|
for (Uint32 i = 0; i < n; i++) |
|
{ |
|
SCMOInternalXmlEncoder::_putXMLNamedInstance( |
|
out, |
|
_scmoInstances[i]); |
|
} |
|
break; |
|
} |
|
case RESP_OBJECTS: |
|
{ |
|
Uint32 n = _scmoInstances.size(); |
|
// Only put the size when not already done above |
|
if (0==totalSize) |
|
{ |
|
out.putUint32(n); |
|
} |
|
for (Uint32 i = 0; i < n; i++) |
|
{ |
|
SCMOInternalXmlEncoder::_putXMLObject( |
|
out, |
|
_scmoInstances[i]); |
|
} |
|
break; |
|
} |
|
// internal xml encoding of instance names and object paths not |
|
// done today |
|
case RESP_INSTNAMES: |
|
case RESP_OBJECTPATHS: |
|
default: |
|
{ |
|
PEGASUS_DEBUG_ASSERT(false); |
|
} |
|
} |
|
} |
} | } |
| |
void CIMResponseData::_resolveToCIM() | void CIMResponseData::_resolveToCIM() |
{ | { |
fprintf( |
PEG_TRACE((TRC_XML, Tracer::LEVEL2, |
stderr, |
"CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n", |
"_resolveToCIM(encoding=%X,content=%X)\n", |
|
_encoding, | _encoding, |
_dataType); |
_dataType)); |
fflush(stderr); |
|
| |
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) | if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
{ | { |
|
|
{ | { |
_resolveSCMOToCIM(); | _resolveSCMOToCIM(); |
} | } |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM); |
|
|
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0); |
} | } |
| |
void CIMResponseData::_resolveToSCMO() | void CIMResponseData::_resolveToSCMO() |
{ | { |
fprintf( |
PEG_TRACE((TRC_XML, Tracer::LEVEL2, |
stderr, |
"CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n", |
"_resolveToSCMO(encoding=%X,content=%X)\n", |
|
_encoding, | _encoding, |
_dataType); |
_dataType)); |
fflush(stderr); |
|
| |
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) | if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
{ | { |
|
|
{ | { |
_resolveCIMToSCMO(); | _resolveCIMToSCMO(); |
} | } |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO); |
PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO || _encoding == 0); |
} | } |
| |
// helper functions to transform different formats into one-another | // helper functions to transform different formats into one-another |
|
|
// avoided whenever possible | // avoided whenever possible |
void CIMResponseData::_resolveBinary() | void CIMResponseData::_resolveBinary() |
{ | { |
// Call magic here to resolve binary format |
PEG_METHOD_ENTER(TRC_DISPATCHER, |
fprintf(stderr, "Watch wat ya do'n! binary ? NO OOP yet.\n"); |
"CIMResponseData::_resolveBinary"); |
fflush(stderr); |
|
|
CIMBuffer in((char*)_binaryData.getData(), _binaryData.size()); |
|
|
|
while (in.more()) |
|
{ |
|
Uint32 binaryTypeMarker=0; |
|
if(!in.getTypeMarker(binaryTypeMarker)) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to get type marker for binary objects!"); |
|
PEG_METHOD_EXIT(); |
|
in.release(); |
|
return; |
|
} |
|
|
|
if (BIN_TYPE_MARKER_SCMO==binaryTypeMarker) |
|
{ |
|
if (!in.getSCMOInstanceA(_scmoInstances)) |
|
{ |
|
_encoding &=(~RESP_ENC_BINARY); |
|
in.release(); |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to resolve binary SCMOInstances!"); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
| |
|
_encoding |= RESP_ENC_SCMO; |
|
} |
|
else |
|
{ |
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
|
case RESP_OBJECTPATHS: |
|
{ |
|
if (!in.getObjectPathA(_instanceNames)) |
{ | { |
|
_encoding &=(~RESP_ENC_BINARY); |
|
in.release(); |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to resolve binary CIMObjectPaths!"); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
break; | break; |
} | } |
case RESP_INSTANCE: | case RESP_INSTANCE: |
{ | { |
|
CIMInstance instance; |
|
if (!in.getInstance(instance)) |
|
{ |
|
_encoding &=(~RESP_ENC_BINARY); |
|
_encoding |= RESP_ENC_CIM; |
|
_instances.append(instance); |
|
in.release(); |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to resolve binary instance!"); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
|
|
|
_instances.append(instance); |
break; | break; |
} | } |
case RESP_INSTANCES: | case RESP_INSTANCES: |
{ | { |
|
if (!in.getInstanceA(_instances)) |
|
{ |
|
_encoding &=(~RESP_ENC_BINARY); |
|
in.release(); |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to resolve binary CIMInstances!"); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
break; | break; |
} | } |
case RESP_OBJECTS: | case RESP_OBJECTS: |
{ | { |
break; |
if (!in.getObjectA(_objects)) |
} |
|
case RESP_OBJECTPATHS: |
|
{ | { |
|
in.release(); |
|
_encoding &=(~RESP_ENC_BINARY); |
|
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1, |
|
"Failed to resolve binary CIMObjects!"); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
break; | break; |
} | } |
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
|
} // switch |
|
_encoding |= RESP_ENC_CIM; |
|
} // else SCMO |
} | } |
|
_encoding &=(~RESP_ENC_BINARY); |
|
// fix up the hostname and namespace for objects if defaults |
|
// were set |
|
if (_defaultHostname.size() > 0 && !_defaultNamespace.isNull()) |
|
{ |
|
completeHostNameAndNamespace(_defaultHostname, _defaultNamespace); |
|
} |
|
in.release(); |
|
PEG_METHOD_EXIT(); |
} | } |
| |
void CIMResponseData::_resolveXmlToCIM() | void CIMResponseData::_resolveXmlToCIM() |
{ | { |
switch (_dataType) | switch (_dataType) |
{ | { |
|
// Xml encoding for instance names and object paths not used |
|
case RESP_OBJECTPATHS: |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
{ | { |
for (Uint32 i = 0; i < _referencesData.size(); i++) |
|
{ |
|
CIMObjectPath cop; |
|
// Deserialize path: |
|
{ |
|
XmlParser parser((char*)_referencesData[i].getData()); |
|
|
|
if (XmlReader::getInstanceNameElement(parser, cop)) |
|
{ |
|
if (!_nameSpacesData[i].isNull()) |
|
cop.setNameSpace(_nameSpacesData[i]); |
|
|
|
if (_hostsData[i].size()) |
|
cop.setHost(_hostsData[i]); |
|
} |
|
} |
|
_instanceNames.append(cop); |
|
} |
|
break; | break; |
} | } |
case RESP_INSTANCE: | case RESP_INSTANCE: |
|
|
} | } |
break; | break; |
} | } |
case RESP_OBJECTPATHS: |
|
{ |
|
// TODO: ???? |
|
} |
|
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
} | } |
// Xml was resolved, release Xml content now | // Xml was resolved, release Xml content now |
|
|
_nameSpacesData.clear(); | _nameSpacesData.clear(); |
_instanceData.clear(); | _instanceData.clear(); |
// remove Xml Encoding flag | // remove Xml Encoding flag |
_encoding &=(!RESP_ENC_XML); |
_encoding &=(~RESP_ENC_XML); |
// add CIM Encoding flag | // add CIM Encoding flag |
_encoding |=RESP_ENC_CIM; | _encoding |=RESP_ENC_CIM; |
} | } |
|
|
} | } |
case RESP_INSTANCE: | case RESP_INSTANCE: |
{ | { |
|
if (_scmoInstances.size() > 0) |
|
{ |
CIMInstance newInstance; | CIMInstance newInstance; |
_scmoInstances[0].getCIMInstance(newInstance); | _scmoInstances[0].getCIMInstance(newInstance); |
_instances.append(newInstance); | _instances.append(newInstance); |
|
} |
break; | break; |
} | } |
case RESP_INSTANCES: | case RESP_INSTANCES: |
|
|
} | } |
default: | default: |
{ | { |
// TODO: |
PEGASUS_DEBUG_ASSERT(false); |
// Argl, not nice, but not a problem yet, ignore this |
|
} | } |
} | } |
|
|
_scmoInstances.clear(); | _scmoInstances.clear(); |
// remove CIM Encoding flag | // remove CIM Encoding flag |
_encoding &=(!RESP_ENC_SCMO); |
_encoding &=(~RESP_ENC_SCMO); |
// add SCMO Encoding flag | // add SCMO Encoding flag |
_encoding |=RESP_ENC_CIM; | _encoding |=RESP_ENC_CIM; |
} | } |
| |
void CIMResponseData::_resolveCIMToSCMO() | void CIMResponseData::_resolveCIMToSCMO() |
{ | { |
|
CString nsCString=_defaultNamespace.getString().getCString(); |
|
const char* _defNamespace = nsCString; |
|
Uint32 _defNamespaceLen; |
|
if (_defaultNamespace.isNull()) |
|
{ |
|
_defNamespaceLen=0; |
|
} |
|
else |
|
{ |
|
_defNamespaceLen=strlen(_defNamespace); |
|
} |
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
case RESP_OBJECTPATHS: |
|
{ | { |
for (Uint32 i=0,n=_instanceNames.size();i<n;i++) | for (Uint32 i=0,n=_instanceNames.size();i<n;i++) |
{ | { |
SCMOInstance addme = |
SCMOInstance addme( |
_getSCMOFromCIMObjectPath(_instanceNames[i]); |
_instanceNames[i], |
|
_defNamespace, |
|
_defNamespaceLen); |
_scmoInstances.append(addme); | _scmoInstances.append(addme); |
} | } |
|
_instanceNames.clear(); |
break; | break; |
} | } |
case RESP_INSTANCE: | case RESP_INSTANCE: |
{ | { |
SCMOInstance addme = |
if (_instances.size() > 0) |
_getSCMOFromCIMInstance(_instances[0]); |
{ |
|
SCMOInstance addme( |
|
_instances[0], |
|
_defNamespace, |
|
_defNamespaceLen); |
|
_scmoInstances.clear(); |
_scmoInstances.append(addme); | _scmoInstances.append(addme); |
|
_instances.clear(); |
|
} |
break; | break; |
} | } |
case RESP_INSTANCES: | case RESP_INSTANCES: |
{ | { |
for (Uint32 i=0,n=_instances.size();i<n;i++) | for (Uint32 i=0,n=_instances.size();i<n;i++) |
{ | { |
SCMOInstance addme = |
SCMOInstance addme( |
_getSCMOFromCIMInstance(_instances[i]); |
_instances[i], |
|
_defNamespace, |
|
_defNamespaceLen); |
_scmoInstances.append(addme); | _scmoInstances.append(addme); |
} | } |
|
_instances.clear(); |
break; | break; |
} | } |
case RESP_OBJECTS: | case RESP_OBJECTS: |
{ | { |
// TODO: Implement, but how ??? |
for (Uint32 i=0,n=_objects.size();i<n;i++) |
|
{ |
|
SCMOInstance addme( |
|
_objects[i], |
|
_defNamespace, |
|
_defNamespaceLen); |
|
_scmoInstances.append(addme); |
|
} |
|
_objects.clear(); |
break; | break; |
} | } |
default: |
case RESP_OBJECTPATHS: |
{ | { |
// TODO: |
for (Uint32 i=0,n=_instanceNames.size();i<n;i++) |
// Argl, not nice, but not a problem yet, ignore this |
{ |
break; |
SCMOInstance addme( |
|
_instanceNames[i], |
|
_defNamespace, |
|
_defNamespaceLen); |
|
// TODO: More description about this. |
|
if (0 == _instanceNames[i].getKeyBindings().size()) |
|
{ |
|
// if there is no keybinding, this is a class |
|
addme.setIsClassOnly(true); |
} | } |
|
_scmoInstances.append(addme); |
} | } |
|
_instanceNames.clear(); |
// remove CIM Encoding flag |
break; |
_encoding &=(!RESP_ENC_CIM); |
|
// add SCMO Encoding flag |
|
_encoding |=RESP_ENC_SCMO; |
|
} | } |
|
default: |
|
|
// Function to convert a CIMInstance into an SCMOInstance |
|
SCMOInstance CIMResponseData::_getSCMOFromCIMInstance( |
|
const CIMInstance& cimInst) |
|
{ | { |
const CIMObjectPath& cimPath = cimInst.getPath(); |
PEGASUS_DEBUG_ASSERT(false); |
|
|
const CString nameSpace = cimPath.getNameSpace().getString().getCString(); |
|
const CString className = cimPath.getClassName().getString().getCString(); |
|
// TODO: What do when either or both are 0 ? |
|
|
|
SCMOClass * scmoClass = _getSCMOClass( |
|
(const char*)nameSpace, |
|
(const char*)className); |
|
// TODO: What do when there is no such class ? |
|
|
|
// TODO: Interrogate Thilo about need to call new |
|
SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst); |
|
|
|
return scmoInst; |
|
} | } |
|
|
// Function to convert a CIMObjectPath into an SCMOInstance |
|
SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath( |
|
const CIMObjectPath& cimPath) |
|
{ |
|
CString nameSpace = cimPath.getNameSpace().getString().getCString(); |
|
CString className = cimPath.getClassName().getString().getCString(); |
|
|
|
// TODO: What do when either or both are 0 ? |
|
|
|
SCMOClass * scmoClass = _getSCMOClass( |
|
(const char*)nameSpace, |
|
(const char*)className); |
|
|
|
// TODO: What do when there is no such class ? |
|
|
|
// TODO: Interrogate Thilo about need to call new |
|
SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath); |
|
|
|
return scmoRef; |
|
} | } |
| |
SCMOClass* CIMResponseData::_getSCMOClass( |
// remove CIM Encoding flag |
const char* nameSpace, |
_encoding &=(~RESP_ENC_CIM); |
const char* cls) |
// add SCMO Encoding flag |
{ |
_encoding |=RESP_ENC_SCMO; |
SCMOClassCache* local = SCMOClassCache::getInstance(); |
|
return local->getSCMOClass( |
|
nameSpace, |
|
strlen(nameSpace), |
|
cls, |
|
strlen(cls)); |
|
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |