00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00036 #include "OW_config.h"
00037 #include "OW_CIMXMLCIMOMHandle.hpp"
00038 #include "OW_HTTPChunkedOStream.hpp"
00039 #include "OW_CIMXMLParser.hpp"
00040 #include "OW_Format.hpp"
00041 #include "OW_XMLEscape.hpp"
00042 #include "OW_CIMInstanceEnumeration.hpp"
00043 #include "OW_CIMNameSpace.hpp"
00044 #include "OW_CIMValue.hpp"
00045 #include "OW_CIMProperty.hpp"
00046 #include "OW_CIMParameter.hpp"
00047 #include "OW_CIMMethod.hpp"
00048 #include "OW_CIMException.hpp"
00049 #include "OW_XMLCIMFactory.hpp"
00050 #include "OW_HTTPChunkedIStream.hpp"
00051 #include "OW_HTTPUtils.hpp"
00052 #include "OW_HTTPDeflateIStream.hpp"
00053 #include "OW_CIMtoXML.hpp"
00054 #include "OW_CIMUrl.hpp"
00055 #include "OW_CIMObjectPath.hpp"
00056 #include "OW_CIMXMLParser.hpp"
00057 #include "OW_CIMParamValue.hpp"
00058 #include "OW_CIMClass.hpp"
00059 #include "OW_CIMQualifierType.hpp"
00060 #include "OW_XMLParseException.hpp"
00061 #include "OW_HTTPClient.hpp"
00062 #include "OW_ResultHandlerIFC.hpp"
00063
00064 #if defined(OW_HAVE_ISTREAM) && defined(OW_HAVE_OSTREAM)
00065 #include <istream>
00066 #include <ostream>
00067 #else
00068 #include <iostream>
00069 #endif
00070
00071
00072 namespace OW_NAMESPACE
00073 {
00074
00075
00076
00077 namespace
00078 {
00079 const String PROTOCOL_VERSION_1_0("1.0");
00080 const String PROTOCOL_VERSION_1_1("1.1");
00081 }
00082
00083 using std::ostream;
00084 using std::iostream;
00085 using std::istream;
00086 using namespace WBEMFlags;
00088 CIMXMLCIMOMHandle::ClientOperation::~ClientOperation()
00089 {
00090 }
00091
00093 CIMXMLCIMOMHandle::CIMXMLCIMOMHandle(const CIMProtocolIFCRef& prot)
00094 : ClientCIMOMHandle()
00095 , m_protocol(prot)
00096 , m_performStrictChecks(true)
00097 {
00098 m_iMessageID = 0;
00099 m_protocol->setContentType("application/xml");
00100 }
00102 CIMProtocolIFCRef
00103 CIMXMLCIMOMHandle::getWBEMProtocolHandler() const
00104 {
00105 return m_protocol;
00106 }
00107
00109 void CIMXMLCIMOMHandle::close()
00110 {
00111 m_protocol->close();
00112 }
00113
00115 void
00116 CIMXMLCIMOMHandle::sendCommonXMLHeader(ostream& ostr, const String& cimProtocolVersion)
00117 {
00118 if (++m_iMessageID > 65535)
00119 {
00120 m_iMessageID = 1;
00121 }
00122 ostr << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>";
00123 ostr << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">";
00124 ostr << "<MESSAGE ID=\"" << m_iMessageID << "\" PROTOCOLVERSION=\"" << cimProtocolVersion << "\">";
00125 ostr << "<SIMPLEREQ>";
00126 }
00128 void
00129 CIMXMLCIMOMHandle::sendIntrinsicXMLHeader( const String &sMethod,
00130 const String& ns,
00131 ostream& ostr,
00132 const String& cimProtocolVersion)
00133 {
00134 sendCommonXMLHeader(ostr, cimProtocolVersion);
00135 CIMNameSpace nameSpace(ns);
00136 ostr << "<IMETHODCALL NAME=\"" << sMethod << "\">";
00137 LocalCIMNameSpacetoXML(nameSpace, ostr);
00138 }
00140 void
00141 CIMXMLCIMOMHandle::sendExtrinsicXMLHeader( const String &sMethod,
00142 const String& ns,
00143 const CIMObjectPath& path,
00144 ostream& ostr,
00145 const String& cimProtocolVersion)
00146 {
00147 sendCommonXMLHeader(ostr, cimProtocolVersion);
00148 CIMNameSpace nameSpace(ns);
00149 ostr << "<METHODCALL NAME=\"" << sMethod << "\">";
00150 if (path.isInstancePath())
00151 {
00152 CIMObjectPath pathWithNs(path);
00153 pathWithNs.setNameSpace(ns);
00154 CIMLocalInstancePathtoXML(pathWithNs,ostr);
00155 }
00156 else
00157 {
00158 ostr << "<LOCALCLASSPATH>";
00159 LocalCIMNameSpacetoXML(nameSpace, ostr);
00160 ostr << "<CLASSNAME NAME=\"" << path.getClassName() << "\"/>";
00161 ostr << "</LOCALCLASSPATH>";
00162 }
00163 }
00165 void
00166 CIMXMLCIMOMHandle::sendXMLTrailer( ostream& ostr, bool intrinsic)
00167 {
00168 if (intrinsic)
00169 {
00170 ostr << "</IMETHODCALL>";
00171 }
00172 else
00173 {
00174 ostr << "</METHODCALL>";
00175 }
00176 ostr << "</SIMPLEREQ>";
00177 ostr << "</MESSAGE>";
00178 ostr << "</CIM>";
00179 ostr << "\r\n";
00180 }
00182 void
00183 CIMXMLCIMOMHandle::doSendRequest(
00184 const Reference<std::iostream>& ostrRef,
00185 const String& methodName,
00186 const String& cimObject,
00187 bool isIntrinsic,
00188 ClientOperation& op,
00189 const String& cimProtocolVersion)
00190 {
00191 CIMProtocolIStreamIFCRef istr = m_protocol->endRequest(
00192 ostrRef, methodName, cimObject, CIMProtocolIFC::E_CIM_OPERATION_REQUEST, cimProtocolVersion);
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204 CIMXMLParser parser(*istr);
00205 try
00206 {
00207 checkNodeForCIMError(parser, methodName, isIntrinsic);
00208 if (isIntrinsic)
00209 {
00210 if (parser.tokenIsId(CIMXMLParser::E_IRETURNVALUE))
00211 {
00212 parser.mustGetNextTag();
00213 op(parser);
00214 parser.mustGetEndTag();
00215 }
00216 }
00217 else
00218 {
00219 op(parser);
00220 }
00221 parser.mustGetEndTag();
00222 parser.mustGetEndTag();
00223 parser.mustGetEndTag();
00224 parser.mustGetEndTag();
00225 HTTPUtils::eatEntity(*istr);
00226 getHTTPTrailers(istr);
00227 istr->checkForError();
00228 }
00229 catch (Exception&)
00230 {
00231 HTTPUtils::eatEntity(*istr);
00232 getHTTPTrailers(istr);
00233 istr->checkForError();
00234 throw;
00235 }
00236 }
00238 void
00239 CIMXMLCIMOMHandle::checkNodeForCIMError(CIMXMLParser& parser,
00240 const String& operation, bool isIntrinsic)
00241 {
00242
00243
00244
00245 if (!parser || !parser.tokenIsId(CIMXMLParser::E_CIM))
00246 {
00247 OW_THROWCIMMSG(CIMException::FAILED, "Invalid XML. <CIM> not found.");
00248 }
00249 if (m_performStrictChecks)
00250 {
00251 String cimattr = parser.mustGetAttribute(CIMXMLParser::A_CIMVERSION);
00252 if (!cimattr.equals(CIMXMLParser::AV_CIMVERSION20_VALUE) &&
00253 !cimattr.equals(CIMXMLParser::AV_CIMVERSION21_VALUE) &&
00254 !cimattr.equals(CIMXMLParser::AV_CIMVERSION22_VALUE))
00255 {
00256 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
00257 String("Return is for CIMVERSION " + cimattr).c_str());
00258 }
00259 cimattr = parser.mustGetAttribute(CIMXMLParser::A_DTDVERSION);
00260 if (!cimattr.equals(CIMXMLParser::AV_DTDVERSION20_VALUE) &&
00261 !cimattr.equals(CIMXMLParser::AV_DTDVERSION21_VALUE))
00262 {
00263 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
00264 String("Return is for DTDVERSION " + cimattr).c_str());
00265 }
00266 }
00267
00268
00269
00270 parser.mustGetChildId(CIMXMLParser::E_MESSAGE);
00271 String cimattr = parser.mustGetAttribute(CIMXMLParser::A_ID);
00272 if (!cimattr.equals(String(m_iMessageID)))
00273 {
00274 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
00275 String("Return messageid="+cimattr+", expected="
00276 +String(m_iMessageID)).c_str());
00277 }
00278 if (m_performStrictChecks)
00279 {
00280 cimattr = parser.mustGetAttribute(CIMXMLParser::A_PROTOCOLVERSION);
00281 if (!cimattr.equals(CIMXMLParser::AV_PROTOCOLVERSION10_VALUE) &&
00282 !cimattr.equals(CIMXMLParser::AV_PROTOCOLVERSION11_VALUE))
00283 {
00284 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
00285 String("Return is for PROTOCOLVERSION "+cimattr).c_str());
00286 }
00287 }
00288
00289
00290
00291 parser.mustGetChildId(CIMXMLParser::E_SIMPLERSP);
00292
00293
00294
00295
00296
00297
00298 parser.mustGetNextId(isIntrinsic ?
00299 CIMXMLParser::E_IMETHODRESPONSE :
00300 CIMXMLParser::E_METHODRESPONSE);
00301 String nameOfMethod = parser.mustGetAttribute("NAME");
00302 if (!nameOfMethod.equalsIgnoreCase(operation))
00303 {
00304 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
00305 String("Called "+operation+" but response was for "+
00306 nameOfMethod).c_str());
00307 }
00308 parser.mustGetNextTag();
00309
00310
00311
00312
00313 if (parser.tokenIsId(CIMXMLParser::E_ERROR))
00314 {
00315 String errCode = parser.mustGetAttribute(
00316 CIMXMLParser::A_CODE);
00317 String description = parser.getAttribute(
00318 CIMXMLParser::A_DESCRIPTION);
00319 Int32 iErrCode;
00320 try
00321 {
00322 iErrCode = errCode.toInt32();
00323 }
00324 catch (const StringConversionException& e)
00325 {
00326 OW_THROWCIMMSG(CIMException::FAILED, Format("Invalid xml. Error code \"%1\" is not an integer",
00327 e.getMessage()).c_str());
00328 }
00329 OW_THROWCIMMSG(CIMException::ErrNoType(errCode.toInt32()), description.c_str());
00330 }
00331
00332
00333
00334
00335 }
00337 namespace
00338 {
00339 class voidRetValOp : public CIMXMLCIMOMHandle::ClientOperation
00340 {
00341 public:
00342 virtual void operator ()(CIMXMLParser &parser)
00343 {
00344 return;
00345 }
00346 };
00347 }
00349 static String
00350 instanceNameToKey(const CIMObjectPath& path,
00351 const String& parameterName)
00352 {
00353 StringBuffer text = "<IPARAMVALUE NAME=\"" + parameterName + "\">";
00354
00355 OStringStream ss;
00356 CIMInstanceNametoXML(path, ss);
00357 text += ss.toString();
00358 text += "</IPARAMVALUE>";
00359 return text.releaseString();
00360 }
00362 namespace
00363 {
00364 struct enumClassNamesOp : public CIMXMLCIMOMHandle::ClientOperation
00365 {
00366 enumClassNamesOp(StringResultHandlerIFC& result_)
00367 : result(result_)
00368 {}
00369 virtual void operator ()(CIMXMLParser &parser)
00370 {
00371 while (parser.tokenIsId(CIMXMLParser::E_CLASSNAME))
00372 {
00373 result.handle(XMLCIMFactory::createObjectPath(parser).getClassName());
00374 }
00375 }
00376 StringResultHandlerIFC& result;
00377 };
00378 }
00380 void
00381 CIMXMLCIMOMHandle::enumClassNames(
00382 const String& ns,
00383 const String& className,
00384 StringResultHandlerIFC& result,
00385 EDeepFlag deep)
00386 {
00387 static const char* const commandName = "EnumerateClassNames";
00388 Array<Param> params;
00389 if (!className.empty())
00390 {
00391 params.push_back(Param(CIMXMLParser::P_ClassName,Param::VALUESET,
00392 "<CLASSNAME NAME=\""+className+"\"/>"));
00393 }
00394 if (deep != E_SHALLOW)
00395 {
00396 params.push_back(Param(CIMXMLParser::P_DeepInheritance,deep));
00397 }
00398 enumClassNamesOp op(result);
00399 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params);
00400 }
00402 namespace
00403 {
00404 struct enumClassOp : public CIMXMLCIMOMHandle::ClientOperation
00405 {
00406 enumClassOp(CIMClassResultHandlerIFC& result_)
00407 : result(result_)
00408 {}
00409 virtual void operator ()(CIMXMLParser &parser)
00410 {
00411 while (parser.tokenIsId(CIMXMLParser::E_CLASS))
00412 {
00413 result.handle(XMLCIMFactory::createClass(parser));
00414 }
00415 }
00416 CIMClassResultHandlerIFC& result;
00417 };
00418 }
00420 void
00421 CIMXMLCIMOMHandle::enumClass(const String& ns,
00422 const String& className,
00423 CIMClassResultHandlerIFC& result,
00424 EDeepFlag deep,
00425 ELocalOnlyFlag localOnly,
00426 EIncludeQualifiersFlag includeQualifiers,
00427 EIncludeClassOriginFlag includeClassOrigin)
00428 {
00429 static const char* const commandName = "EnumerateClasses";
00430 Array<Param> params;
00431 if (!className.empty())
00432 {
00433 params.push_back(Param(CIMXMLParser::P_ClassName,Param::VALUESET,
00434 "<CLASSNAME NAME=\""+className+"\"/>"));
00435 }
00436 if (localOnly != E_LOCAL_ONLY)
00437 {
00438 params.push_back(Param(CIMXMLParser::P_LocalOnly,localOnly));
00439 }
00440 if (deep != E_SHALLOW)
00441 {
00442 params.push_back(Param(CIMXMLParser::P_DeepInheritance,deep));
00443 }
00444 if (includeQualifiers != E_INCLUDE_QUALIFIERS)
00445 {
00446 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
00447 }
00448 if (includeClassOrigin != E_EXCLUDE_CLASS_ORIGIN)
00449 {
00450 params.push_back(Param(CIMXMLParser::P_IncludeClassOrigin, includeClassOrigin));
00451 }
00452 enumClassOp op(result);
00453 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params);
00454 }
00456 namespace
00457 {
00458 struct enumInstanceNamesOp : public CIMXMLCIMOMHandle::ClientOperation
00459 {
00460 enumInstanceNamesOp(CIMObjectPathResultHandlerIFC& result_,
00461 const String& ns_)
00462 : result(result_)
00463 , ns(ns_)
00464 {}
00465 virtual void operator ()(CIMXMLParser &parser)
00466 {
00467 while (parser.tokenIsId(CIMXMLParser::E_INSTANCENAME))
00468 {
00469 CIMObjectPath p = XMLCIMFactory::createObjectPath(parser);
00470 p.setNameSpace(ns);
00471 result.handle(p);
00472 }
00473 }
00474 CIMObjectPathResultHandlerIFC& result;
00475 const String& ns;
00476 };
00477 }
00479 void
00480 CIMXMLCIMOMHandle::enumInstanceNames(
00481 const String& ns,
00482 const String& className,
00483 CIMObjectPathResultHandlerIFC& result)
00484 {
00485 static const char* const commandName = "EnumerateInstanceNames";
00486 Array<Param> params;
00487 if (!className.empty())
00488 {
00489 params.push_back(Param(CIMXMLParser::P_ClassName, Param::VALUESET,
00490 "<CLASSNAME NAME=\""+className+"\"/>"));
00491 }
00492 else
00493 {
00494 OW_THROWCIMMSG(CIMException::NOT_FOUND, "Class was empty in "
00495 "EnumerateInstanceNames");
00496 }
00497 enumInstanceNamesOp op(result, ns);
00498 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params);
00499 }
00501 static inline void generatePropertyListXML(std::ostream& ostr,
00502 const StringArray* propertyList)
00503 {
00504 if (propertyList)
00505 {
00506 ostr << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_PropertyList <<
00507 "\"><VALUE.ARRAY>";
00508 for (size_t i = 0;i < propertyList->size(); i++)
00509 {
00510 ostr << "<VALUE>" << (*propertyList)[i] << "</VALUE>";
00511 }
00512 ostr << "</VALUE.ARRAY></IPARAMVALUE>";
00513 }
00514 }
00516 namespace
00517 {
00518 struct enumInstancesOp : public CIMXMLCIMOMHandle::ClientOperation
00519 {
00520 enumInstancesOp(CIMInstanceResultHandlerIFC& result_,
00521 const String& ns_)
00522 : result(result_)
00523 , ns(ns_)
00524 {}
00525 virtual void operator ()(CIMXMLParser &parser)
00526 {
00527 while (parser.tokenIsId(CIMXMLParser::E_VALUE_NAMEDINSTANCE))
00528 {
00529 parser.mustGetChildId(CIMXMLParser::E_INSTANCENAME);
00530 CIMObjectPath iop(XMLCIMFactory::createObjectPath(parser));
00531 CIMInstance ci = XMLCIMFactory::createInstance(parser);
00532 ci.setKeys(iop.getKeys());
00533 ci.setNameSpace(ns);
00534 result.handle(ci);
00535 parser.mustGetEndTag();
00536 }
00537 }
00538 CIMInstanceResultHandlerIFC& result;
00539 String ns;
00540 };
00541 }
00543 void
00544 CIMXMLCIMOMHandle::enumInstances(
00545 const String& ns,
00546 const String& className,
00547 CIMInstanceResultHandlerIFC& result, EDeepFlag deep,
00548 ELocalOnlyFlag localOnly, EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
00549 const StringArray* propertyList)
00550 {
00551 static const char* const commandName = "EnumerateInstances";
00552 OStringStream extra(1000);
00553 Array<Param> params;
00554 if (className.empty())
00555 {
00556 OW_THROWCIMMSG(CIMException::NOT_FOUND, "Class Name was empty in "
00557 "EnumerateInstances");
00558 }
00559 params.push_back(Param(CIMXMLParser::P_ClassName, Param::VALUESET,
00560 "<CLASSNAME NAME=\""+className+"\"/>"));
00561 if (deep != E_DEEP)
00562 {
00563 params.push_back(Param(CIMXMLParser::P_DeepInheritance, deep));
00564 }
00565 if (localOnly != E_LOCAL_ONLY)
00566 {
00567 params.push_back(Param(CIMXMLParser::P_LocalOnly, localOnly));
00568 }
00569 if (includeQualifiers != E_EXCLUDE_QUALIFIERS)
00570 {
00571 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
00572 }
00573 if (includeClassOrigin != E_EXCLUDE_CLASS_ORIGIN)
00574 {
00575 params.push_back(Param(CIMXMLParser::P_IncludeClassOrigin, includeClassOrigin));
00576 }
00577 generatePropertyListXML(extra,propertyList);
00578 enumInstancesOp op(result, ns);
00579 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params, extra.toString());
00580 }
00582 namespace
00583 {
00584 struct getClassOp : public CIMXMLCIMOMHandle::ClientOperation
00585 {
00586 getClassOp(CIMClass& result_)
00587 : result(result_)
00588 {}
00589 virtual void operator ()(CIMXMLParser &parser)
00590 {
00591 result = XMLCIMFactory::createClass(parser);
00592 }
00593 CIMClass& result;
00594 };
00595 }
00597 CIMClass
00598 CIMXMLCIMOMHandle::getClass(
00599 const String& ns,
00600 const String& className,
00601 ELocalOnlyFlag localOnly,
00602 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
00603 const StringArray* propertyList)
00604 {
00605 static const char* const commandName = "GetClass";
00606 Array<Param> params;
00607 if (!className.empty())
00608 {
00609 params.push_back(Param(CIMXMLParser::P_ClassName,Param::VALUESET,
00610 "<CLASSNAME NAME=\""+className+"\"/>"));
00611 }
00612 else
00613 {
00614 OW_THROWCIMMSG(CIMException::INVALID_CLASS, "no class given for "
00615 "GetClass()");
00616 }
00617 if (localOnly != E_LOCAL_ONLY)
00618 {
00619 params.push_back(Param(CIMXMLParser::P_LocalOnly, localOnly));
00620 }
00621 if (includeQualifiers != E_INCLUDE_QUALIFIERS)
00622 {
00623 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
00624 }
00625 if (includeClassOrigin != E_EXCLUDE_CLASS_ORIGIN)
00626 {
00627 params.push_back(Param(CIMXMLParser::P_IncludeClassOrigin, includeClassOrigin));
00628 }
00629 OStringStream extra;
00630 generatePropertyListXML(extra,propertyList);
00631 CIMClass rval(CIMNULL);
00632 getClassOp op(rval);
00633 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params, extra.toString());
00634 return rval;
00635 }
00637 namespace
00638 {
00639 struct getInstanceOp : public CIMXMLCIMOMHandle::ClientOperation
00640 {
00641 getInstanceOp(CIMInstance& result_, const String& ns_)
00642 : result(result_)
00643 , ns(ns_)
00644 {}
00645 virtual void operator ()(CIMXMLParser &parser)
00646 {
00647 result = XMLCIMFactory::createInstance(parser);
00648 result.setNameSpace(ns);
00649 }
00650 CIMInstance& result;
00651 String ns;
00652 };
00653 }
00655 CIMInstance
00656 CIMXMLCIMOMHandle::getInstance(
00657 const String& ns,
00658 const CIMObjectPath& instanceName,
00659 ELocalOnlyFlag localOnly, EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
00660 const StringArray* propertyList)
00661 {
00662 static const char* const commandName = "GetInstance";
00663 OStringStream extra(1000);
00664 Array<Param> params;
00665 if (localOnly != E_LOCAL_ONLY)
00666 {
00667 params.push_back(Param(CIMXMLParser::P_LocalOnly, localOnly));
00668 }
00669 if (includeQualifiers != E_EXCLUDE_QUALIFIERS)
00670 {
00671 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
00672 }
00673 if (includeClassOrigin != E_EXCLUDE_CLASS_ORIGIN)
00674 {
00675 params.push_back(Param(CIMXMLParser::P_IncludeClassOrigin, includeClassOrigin));
00676 }
00677 CIMObjectPath path(instanceName);
00678 path.setNameSpace(ns);
00679 extra << instanceNameToKey(path, "InstanceName");
00680 generatePropertyListXML(extra,propertyList);
00681 CIMInstance rval(CIMNULL);
00682 getInstanceOp op(rval, ns);
00683 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params, extra.toString());
00684 return rval;
00685 }
00687 namespace
00688 {
00689 struct invokeMethodOp : public CIMXMLCIMOMHandle::ClientOperation
00690 {
00691 invokeMethodOp(CIMValue& result_, CIMParamValueArray& outParams_)
00692 : result(result_)
00693 , outParams(outParams_)
00694 {}
00695 virtual void operator ()(CIMXMLParser &parser)
00696 {
00697
00698
00699
00700 if (parser.tokenIsId(CIMXMLParser::E_RETURNVALUE))
00701 {
00702 String returnType = parser.getAttribute(CIMXMLParser::A_PARAMTYPE);
00703 if (returnType.empty())
00704 {
00705 returnType = "string";
00706 }
00707
00708 XMLCIMFactory::EEmbeddedObjectFlag embeddedObjectType = XMLCIMFactory::getEmbeddedObjectType(parser);
00709
00710 parser.mustGetChild();
00711 if (!parser.tokenIsId(CIMXMLParser::E_VALUE) &&
00712 !parser.tokenIsId(CIMXMLParser::E_VALUE_REFERENCE))
00713 {
00714 OW_THROWCIMMSG(CIMException::FAILED,
00715 "<RETURNVALUE> did not contain a <VALUE> or "
00716 "<VALUE.REFERENCE> element");
00717 }
00718 result = XMLCIMFactory::createValue(parser, returnType, embeddedObjectType);
00719 parser.mustGetEndTag();
00720 }
00721
00722 for (size_t outParamCount = 0;
00723 parser && parser.tokenIsId(CIMXMLParser::E_PARAMVALUE);
00724 ++outParamCount)
00725 {
00726 String name = parser.mustGetAttribute(CIMXMLParser::A_NAME);
00727 String type = parser.getAttribute(CIMXMLParser::A_PARAMTYPE);
00728 if (type.empty())
00729 {
00730 type = "string";
00731 }
00732 XMLCIMFactory::EEmbeddedObjectFlag embeddedObjectType = XMLCIMFactory::getEmbeddedObjectType(parser);
00733 parser.getNextTag();
00734
00735 if (outParams.size() <= outParamCount)
00736 {
00737
00738 outParams.resize(outParamCount + 1);
00739 }
00740
00741 int token = parser.getToken();
00742
00743 if (token != CIMXMLParser::E_VALUE
00744 && token != CIMXMLParser::E_VALUE_REFERENCE
00745 && token != CIMXMLParser::E_VALUE_ARRAY
00746 && token != CIMXMLParser::E_VALUE_REFARRAY
00747 )
00748 {
00749 outParams[outParamCount] = CIMParamValue(name, CIMValue(CIMNULL));
00750 }
00751 else
00752 {
00753 outParams[outParamCount] = CIMParamValue(name, XMLCIMFactory::createValue(parser, type, embeddedObjectType));
00754 }
00755 parser.mustGetEndTag();
00756 }
00757 }
00758 CIMValue& result;
00759 CIMParamValueArray& outParams;
00760 };
00761 }
00763 CIMValue
00764 CIMXMLCIMOMHandle::invokeMethod(
00765 const String& ns,
00766 const CIMObjectPath& path,
00767 const String& methodName,
00768 const CIMParamValueArray& inParams,
00769 CIMParamValueArray& outParams)
00770 {
00771 Reference<std::iostream> iostrRef =
00772 m_protocol->beginRequest(methodName, ns);
00773 std::iostream& tfs = *iostrRef;
00774 sendExtrinsicXMLHeader(methodName, ns, path, tfs, PROTOCOL_VERSION_1_0);
00775 for (size_t i = 0; i < inParams.size(); ++i)
00776 {
00777 tfs << "<PARAMVALUE NAME=\"" << inParams[i].getName() << "\"";
00778 CIMValue v = inParams[i].getValue();
00779 if (v)
00780 {
00781 String type = v.getCIMDataType().toString();
00782 if (type == "REF")
00783 {
00784 type = "reference";
00785 }
00786 tfs << " PARAMTYPE=\"" << type << "\">";
00787 CIMtoXML(inParams[i].getValue(), tfs);
00788 }
00789 else
00790 {
00791 tfs << '>';
00792 }
00793 tfs << "</PARAMVALUE>";
00794 }
00795 sendXMLTrailer(tfs, false);
00796 CIMValue rval(CIMNULL);
00797 invokeMethodOp op(rval, outParams);
00798 doSendRequest(iostrRef, methodName,
00799 ns + ":" + path.modelPath(),
00800 false, op, PROTOCOL_VERSION_1_0);
00801 return rval;
00802 }
00804 namespace
00805 {
00806 struct getQualifierTypeOp : public CIMXMLCIMOMHandle::ClientOperation
00807 {
00808 getQualifierTypeOp(CIMQualifierType& result_)
00809 : result(result_)
00810 {}
00811 virtual void operator ()(CIMXMLParser &parser)
00812 {
00813 XMLQualifier::processQualifierDecl(parser, result);
00814 }
00815 CIMQualifierType& result;
00816 };
00817 }
00819 CIMQualifierType
00820 CIMXMLCIMOMHandle::getQualifierType(const String& ns,
00821 const String& qualifierName)
00822 {
00823 static const char* const commandName = "GetQualifier";
00824 Array<Param> params;
00825 params.push_back(Param(CIMXMLParser::P_QualifierName, qualifierName));
00826 CIMQualifierType rval;
00827 getQualifierTypeOp op(rval);
00828 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params);
00829 return rval;
00830 }
00831 #ifndef OW_DISABLE_QUALIFIER_DECLARATION
00832
00833 void
00834 CIMXMLCIMOMHandle::setQualifierType(const String& ns,
00835 const CIMQualifierType& qt)
00836 {
00837 static const char* const commandName = "SetQualifier";
00838 OStringStream extra;
00839 extra << "<IPARAMVALUE NAME=\"QualifierDeclaration\">";
00840 CIMtoXML(qt, extra);
00841 extra << "</IPARAMVALUE>";
00842 voidRetValOp op;
00843 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, Array<Param>(),
00844 extra.toString());
00845 }
00847 void
00848 CIMXMLCIMOMHandle::deleteQualifierType(const String& ns, const String& qualName)
00849 {
00850 static const char* const commandName = "DeleteQualifier";
00851 Array<Param> params;
00852 params.push_back(Param(CIMXMLParser::P_QualifierName, qualName));
00853 voidRetValOp op;
00854 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params);
00855 }
00857 namespace
00858 {
00859 struct enumQualifierTypesOp : public CIMXMLCIMOMHandle::ClientOperation
00860 {
00861 enumQualifierTypesOp(CIMQualifierTypeResultHandlerIFC& result_)
00862 : result(result_)
00863 {}
00864 virtual void operator ()(CIMXMLParser &parser)
00865 {
00866 while (parser.tokenIsId(CIMXMLParser::E_QUALIFIER_DECLARATION))
00867 {
00868 CIMQualifierType cqt;
00869 XMLQualifier::processQualifierDecl(parser, cqt);
00870 result.handle(cqt);
00871 }
00872 }
00873 CIMQualifierTypeResultHandlerIFC& result;
00874 };
00875 }
00877 void
00878 CIMXMLCIMOMHandle::enumQualifierTypes(
00879 const String& ns,
00880 CIMQualifierTypeResultHandlerIFC& result)
00881 {
00882 static const char* const commandName = "EnumerateQualifiers";
00883 enumQualifierTypesOp op(result);
00884 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0);
00885 }
00886 #endif // #ifndef OW_DISABLE_QUALIFIER_DECLARATION
00887 #ifndef OW_DISABLE_SCHEMA_MANIPULATION
00888
00889 void
00890 CIMXMLCIMOMHandle::modifyClass(const String &ns,
00891 const CIMClass& cc)
00892 {
00893 static const char* const commandName = "ModifyClass";
00894 OStringStream extra(1024);
00895 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ModifiedClass << "\">";
00896 CIMtoXML(cc, extra);
00897 extra << "</IPARAMVALUE>";
00898 voidRetValOp op;
00899 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, Array<Param>(),
00900 extra.toString());
00901 }
00903 void
00904 CIMXMLCIMOMHandle::createClass(const String& ns,
00905 const CIMClass& cc)
00906 {
00907 static const char* const commandName = "CreateClass";
00908 OStringStream ostr;
00909 ostr << "<IPARAMVALUE NAME=\"NewClass\">";
00910 CIMtoXML(cc, ostr);
00911 ostr << "</IPARAMVALUE>";
00912 voidRetValOp op;
00913 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, Array<Param>(),
00914 ostr.toString());
00915 }
00917 void
00918 CIMXMLCIMOMHandle::deleteClass(const String& nameSpace, const String& className)
00919 {
00920 static const char* const commandName = "DeleteClass";
00921 Array<Param> params;
00922 if (!className.empty())
00923 {
00924 params.push_back(Param(CIMXMLParser::P_ClassName,Param::VALUESET,
00925 "<CLASSNAME NAME=\""+className+"\"/>"));
00926 }
00927 else
00928 {
00929 OW_THROWCIMMSG(CIMException::INVALID_CLASS, "No ClassName passed"
00930 " to deleteClass()");
00931 }
00932 voidRetValOp op;
00933 intrinsicMethod(nameSpace, commandName, op, PROTOCOL_VERSION_1_0, params);
00934 }
00935 #endif // #ifndef OW_DISABLE_SCHEMA_MANIPULATION
00936 #ifndef OW_DISABLE_INSTANCE_MANIPULATION
00937
00938 void
00939 CIMXMLCIMOMHandle::modifyInstance(
00940 const String& ns,
00941 const CIMInstance& modifiedInstance,
00942 EIncludeQualifiersFlag includeQualifiers,
00943 const StringArray* propertyList)
00944 {
00945 static const char* const commandName = "ModifyInstance";
00946
00947
00948
00949
00950
00951 OStringStream ostr(1000);
00952 ostr << "<IPARAMVALUE NAME=\"ModifiedInstance\">";
00953 ostr << "<VALUE.NAMEDINSTANCE>";
00954 CIMInstanceNameAndInstancetoXML(modifiedInstance, ostr,
00955 CIMObjectPath(ns, modifiedInstance));
00956 ostr << "</VALUE.NAMEDINSTANCE></IPARAMVALUE>";
00957
00958 Array<Param> params;
00959
00960
00961 String cimProtocolVersion(PROTOCOL_VERSION_1_0);
00962
00963 if (includeQualifiers != E_INCLUDE_QUALIFIERS)
00964 {
00965 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
00966 cimProtocolVersion = PROTOCOL_VERSION_1_1;
00967 }
00968
00969 if (propertyList != 0)
00970 {
00971 generatePropertyListXML(ostr, propertyList);
00972 cimProtocolVersion = PROTOCOL_VERSION_1_1;
00973 }
00974
00975 voidRetValOp op;
00976 intrinsicMethod(ns, commandName, op, cimProtocolVersion, params,
00977 ostr.toString());
00978 }
00980 namespace
00981 {
00982 struct createInstanceOp : public CIMXMLCIMOMHandle::ClientOperation
00983 {
00984 createInstanceOp(CIMObjectPath& result_)
00985 : result(result_)
00986 {}
00987 virtual void operator ()(CIMXMLParser &parser)
00988 {
00989 if (!parser.tokenIsId(CIMXMLParser::E_INSTANCENAME))
00990 {
00991 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER, "Expected but did not get <INSTANCENAME>");
00992 }
00993 result = XMLCIMFactory::createObjectPath(parser);
00994 }
00995 CIMObjectPath& result;
00996 };
00997 }
00999 CIMObjectPath
01000 CIMXMLCIMOMHandle::createInstance(const String& ns,
01001 const CIMInstance& ci)
01002 {
01003 static const char* const commandName = "CreateInstance";
01004
01005
01006
01007
01008
01009
01010
01011 OStringStream ostr;
01012 ostr << "<IPARAMVALUE NAME=\"NewInstance\">";
01013 CIMInstancetoXML(ci, ostr);
01014 ostr << "</IPARAMVALUE>";
01015 CIMObjectPath rval(CIMNULL);
01016 createInstanceOp op(rval);
01017 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, Array<Param>(), ostr.toString());
01018 rval.setNameSpace(ns);
01019 return rval;
01020 }
01022 void
01023 CIMXMLCIMOMHandle::deleteInstance(const String& ns, const CIMObjectPath& inst)
01024 {
01025 static const char* const commandName = "DeleteInstance";
01026 Array<Param> params;
01027 voidRetValOp op;
01028 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params,
01029 instanceNameToKey(inst, "InstanceName"));
01030 }
01031 #if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
01032
01033 void
01034 CIMXMLCIMOMHandle::setProperty(
01035 const String& ns,
01036 const CIMObjectPath& path,
01037 const String& propName,
01038 const CIMValue& cv)
01039 {
01040 static const char* const commandName = "SetProperty";
01041 Array<Param> params;
01042 params.push_back(Param(CIMXMLParser::P_PropertyName, propName));
01043 if (cv)
01044 {
01045 OStringStream ostr;
01046 CIMtoXML(cv, ostr);
01047 params.push_back(Param(CIMXMLParser::P_NewValue, Param::VALUESET, ostr.toString()));
01048 }
01049 voidRetValOp op;
01050 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params,
01051 instanceNameToKey(path,"InstanceName"));
01052 }
01053 #endif // #if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
01054 #endif // #ifndef OW_DISABLE_INSTANCE_MANIPULATION
01055
01056 #if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
01057
01058 namespace
01059 {
01060 struct getPropertyOp : public CIMXMLCIMOMHandle::ClientOperation
01061 {
01062 getPropertyOp(CIMValue& result_)
01063 : result(result_)
01064 {}
01065 virtual void operator ()(CIMXMLParser &parser)
01066 {
01067 if (!parser.tokenIsId(CIMXMLParser::E_IRETURNVALUE))
01068 {
01069
01070 result = XMLCIMFactory::createValue(parser, "string", XMLCIMFactory::E_VALUE_NOT_EMBEDDED_OBJECT);
01071 }
01072
01073 }
01074 CIMValue& result;
01075 };
01076 }
01078 CIMValue
01079 CIMXMLCIMOMHandle::getProperty(
01080 const String& ns,
01081 const CIMObjectPath& path,
01082 const String& propName)
01083 {
01084 static const char* const commandName = "GetProperty";
01085 Array<Param> params;
01086 params.push_back(Param(CIMXMLParser::P_PropertyName, propName));
01087 CIMValue rval(CIMNULL);
01088 getPropertyOp op(rval);
01089 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params,
01090 instanceNameToKey(path,"InstanceName"));
01091 return rval;
01092 }
01093 #endif // #if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
01094
01095 namespace
01096 {
01097 struct objectPathOp : public CIMXMLCIMOMHandle::ClientOperation
01098 {
01099 objectPathOp(CIMObjectPathResultHandlerIFC& result_,
01100 const String& ns_)
01101 : result(result_)
01102 , ns(ns_)
01103 {}
01104 virtual void operator ()(CIMXMLParser &parser)
01105 {
01106 while (!parser.tokenIsId(CIMXMLParser::E_IRETURNVALUE))
01107 {
01108 CIMXMLParser::tokenId token = parser.getToken();
01109 CIMObjectPath cop = XMLCIMFactory::createObjectPath(parser);
01110 switch (token)
01111 {
01112 case CIMXMLParser::E_CLASSNAME:
01113 cop.setNameSpace(ns);
01114 break;
01115 case CIMXMLParser::E_INSTANCENAME:
01116 cop.setNameSpace(ns);
01117 break;
01118 default:
01119 break;
01120 }
01121 result.handle(cop);
01122 }
01123 }
01124 CIMObjectPathResultHandlerIFC& result;
01125 String ns;
01126 };
01128 struct objectWithPathOp : public CIMXMLCIMOMHandle::ClientOperation
01129 {
01130 objectWithPathOp(
01131 CIMInstanceResultHandlerIFC* iresult_,
01132 CIMClassResultHandlerIFC* cresult_,
01133 const String& ns_)
01134 : iresult(iresult_)
01135 , cresult(cresult_)
01136 , ns(ns_)
01137 {}
01138 virtual void operator ()(CIMXMLParser &parser)
01139 {
01140 while (!parser.tokenIsId(CIMXMLParser::E_IRETURNVALUE))
01141 {
01142 CIMInstance ci(CIMNULL);
01143 CIMClass cc(CIMNULL);
01144 CIMObjectPath cop = XMLClass::getObjectWithPath(parser, cc, ci);
01145 if (cop)
01146 {
01147 if (iresult)
01148 {
01149 if (!ci)
01150 {
01151 OW_THROWCIMMSG(CIMException::FAILED, "Server did not send an instance.");
01152 }
01153 ci.setKeys(cop.getKeys());
01154 iresult->handle(ci);
01155 }
01156 if (cresult)
01157 {
01158 if (!cc)
01159 {
01160 OW_THROWCIMMSG(CIMException::FAILED, "Server did not send an class.");
01161 }
01162 cresult->handle(cc);
01163 }
01164 }
01165 }
01166 }
01167 CIMInstanceResultHandlerIFC* iresult;
01168 CIMClassResultHandlerIFC* cresult;
01169 String ns;
01170 };
01171 }
01172 #ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
01173
01174 void
01175 CIMXMLCIMOMHandle::associatorNames(
01176 const String& ns,
01177 const CIMObjectPath& path,
01178 CIMObjectPathResultHandlerIFC& result,
01179 const String& assocClass, const String& resultClass,
01180 const String& role, const String& resultRole)
01181 {
01182 static const char* const commandName = "AssociatorNames";
01183 Array<Param> params;
01184 OStringStream extra(1000);
01185 if (!role.empty())
01186 {
01187 params.push_back(Param(CIMXMLParser::P_Role, role));
01188 }
01189 if (!resultRole.empty())
01190 {
01191 params.push_back(Param(CIMXMLParser::P_ResultRole, resultRole));
01192 }
01193 if (path.isInstancePath())
01194 {
01195 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">";
01196 CIMInstanceNametoXML(path, extra);
01197 extra << "</IPARAMVALUE>";
01198 }
01199 else
01200 {
01201 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">" <<
01202 "<CLASSNAME NAME=\"" << path.getClassName() <<
01203 "\"/></IPARAMVALUE>";
01204 }
01205 if (!assocClass.empty())
01206 {
01207 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_AssocClass << "\">" <<
01208 "<CLASSNAME NAME=\"" << assocClass <<
01209 "\"/></IPARAMVALUE>";
01210 }
01211 if (!resultClass.empty())
01212 {
01213 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ResultClass << "\">" <<
01214 "<CLASSNAME NAME=\"" << resultClass <<
01215 "\"/></IPARAMVALUE>";
01216 }
01217 objectPathOp op(result, ns);
01218 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params,
01219 extra.toString());
01220 }
01222 void
01223 CIMXMLCIMOMHandle::associators(
01224 const String& ns,
01225 const CIMObjectPath& path,
01226 CIMInstanceResultHandlerIFC& result,
01227 const String& assocClass, const String& resultClass,
01228 const String& role, const String& resultRole,
01229 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
01230 const StringArray* propertyList)
01231 {
01232 if (!path.isInstancePath())
01233 {
01234 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
01235 "associators requires an instance path not a class path");
01236 }
01237 associatorsCommon(ns, path, &result, 0, assocClass, resultClass, role,
01238 resultRole, includeQualifiers, includeClassOrigin, propertyList);
01239 }
01241 void
01242 CIMXMLCIMOMHandle::associatorsClasses(
01243 const String& ns,
01244 const CIMObjectPath& path,
01245 CIMClassResultHandlerIFC& result,
01246 const String& assocClass, const String& resultClass,
01247 const String& role, const String& resultRole,
01248 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
01249 const StringArray* propertyList)
01250 {
01251 if (!path.isClassPath())
01252 {
01253 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
01254 "associatorsClasses requires a class path not an instance path");
01255 }
01256 associatorsCommon(ns, path, 0, &result, assocClass, resultClass, role,
01257 resultRole, includeQualifiers, includeClassOrigin, propertyList);
01258 }
01260 void
01261 CIMXMLCIMOMHandle::associatorsCommon(
01262 const String& ns,
01263 const CIMObjectPath& path,
01264 CIMInstanceResultHandlerIFC* iresult,
01265 CIMClassResultHandlerIFC* cresult,
01266 const String& assocClass, const String& resultClass,
01267 const String& role, const String& resultRole,
01268 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
01269 const StringArray* propertyList)
01270 {
01271 static const char* const commandName = "Associators";
01272 Array<Param> params;
01273 OStringStream extra(1000);
01274 if (!role.empty())
01275 {
01276 params.push_back(Param(CIMXMLParser::P_Role, role));
01277 }
01278 if (!resultRole.empty())
01279 {
01280 params.push_back(Param(CIMXMLParser::P_ResultRole, resultRole));
01281 }
01282 if (includeQualifiers != E_EXCLUDE_QUALIFIERS)
01283 {
01284 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
01285 }
01286 if (includeClassOrigin != E_EXCLUDE_CLASS_ORIGIN)
01287 {
01288 params.push_back(Param(CIMXMLParser::P_IncludeClassOrigin, includeClassOrigin));
01289 }
01290 generatePropertyListXML(extra,propertyList);
01291 if (path.isInstancePath())
01292 {
01293 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">";
01294 CIMInstanceNametoXML(path, extra);
01295 extra << "</IPARAMVALUE>";
01296 }
01297 else
01298 {
01299 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">" <<
01300 "<CLASSNAME NAME=\"" << path.getClassName() <<
01301 "\"/></IPARAMVALUE>";
01302 }
01303 if (!assocClass.empty())
01304 {
01305 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_AssocClass << "\">" <<
01306 "<CLASSNAME NAME=\"" << assocClass <<
01307 "\"/></IPARAMVALUE>";
01308 }
01309 if (!resultClass.empty())
01310 {
01311 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ResultClass << "\">" <<
01312 "<CLASSNAME NAME=\"" << resultClass <<
01313 "\"/></IPARAMVALUE>";
01314 }
01315 objectWithPathOp op(iresult, cresult, ns);
01316 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params, extra.toString());
01317 }
01319 void
01320 CIMXMLCIMOMHandle::referenceNames(
01321 const String& ns,
01322 const CIMObjectPath& path,
01323 CIMObjectPathResultHandlerIFC& result,
01324 const String& resultClass,
01325 const String& role)
01326 {
01327 static const char* const commandName = "ReferenceNames";
01328 Array<Param> params;
01329 OStringStream extra(1000);
01330 if (!role.empty())
01331 {
01332 params.push_back(Param(CIMXMLParser::P_Role, role));
01333 }
01334 if (path.isInstancePath())
01335 {
01336 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">";
01337 CIMInstanceNametoXML(path, extra);
01338 extra << "</IPARAMVALUE>";
01339 }
01340 else
01341 {
01342 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">" <<
01343 "<CLASSNAME NAME=\"" << path.getClassName() <<
01344 "\"></CLASSNAME></IPARAMVALUE>";
01345 }
01346 if (!resultClass.empty())
01347 {
01348 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ResultClass << "\">" <<
01349 "<CLASSNAME NAME=\"" << resultClass <<
01350 "\"></CLASSNAME></IPARAMVALUE>";
01351 }
01352 objectPathOp op(result, ns);
01353 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params, extra.toString());
01354 }
01356 void
01357 CIMXMLCIMOMHandle::references(
01358 const String& ns,
01359 const CIMObjectPath& path,
01360 CIMInstanceResultHandlerIFC& result,
01361 const String& resultClass, const String& role,
01362 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
01363 const StringArray* propertyList)
01364 {
01365 if (!path.isInstancePath())
01366 {
01367 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
01368 "references requires an instance path not a class path");
01369 }
01370 referencesCommon(ns, path, &result, 0, resultClass, role, includeQualifiers,
01371 includeClassOrigin, propertyList);
01372 }
01374 void
01375 CIMXMLCIMOMHandle::referencesClasses(
01376 const String& ns,
01377 const CIMObjectPath& path,
01378 CIMClassResultHandlerIFC& result,
01379 const String& resultClass, const String& role,
01380 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
01381 const StringArray* propertyList)
01382 {
01383 if (!path.isClassPath())
01384 {
01385 OW_THROWCIMMSG(CIMException::INVALID_PARAMETER,
01386 "referencesClasses requires a class path not an instance path");
01387 }
01388 referencesCommon(ns, path, 0, &result, resultClass, role, includeQualifiers,
01389 includeClassOrigin, propertyList);
01390 }
01392 void
01393 CIMXMLCIMOMHandle::referencesCommon(
01394 const String& ns,
01395 const CIMObjectPath& path,
01396 CIMInstanceResultHandlerIFC* iresult,
01397 CIMClassResultHandlerIFC* cresult,
01398 const String& resultClass,
01399 const String& role,
01400 EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
01401 const StringArray* propertyList)
01402 {
01403 static const char* const commandName = "References";
01404 Array<Param> params;
01405 OStringStream extra(1000);
01406 if (!role.empty())
01407 {
01408 params.push_back(Param(CIMXMLParser::P_Role, role));
01409 }
01410 if (includeQualifiers != E_EXCLUDE_QUALIFIERS)
01411 {
01412 params.push_back(Param(CIMXMLParser::P_IncludeQualifiers, includeQualifiers));
01413 }
01414 if (includeClassOrigin != E_EXCLUDE_CLASS_ORIGIN)
01415 {
01416 params.push_back(Param(CIMXMLParser::P_IncludeClassOrigin, includeClassOrigin));
01417 }
01418 generatePropertyListXML(extra,propertyList);
01419 if (path.isInstancePath())
01420 {
01421 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">";
01422 CIMInstanceNametoXML(path, extra);
01423 extra << "</IPARAMVALUE>";
01424 }
01425 else
01426 {
01427 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ObjectName << "\">"
01428 << "<CLASSNAME NAME=\"" << path.getClassName()
01429 << "\"></CLASSNAME></IPARAMVALUE>";
01430 }
01431 if (!resultClass.empty())
01432 {
01433 extra << "<IPARAMVALUE NAME=\"" << CIMXMLParser::P_ResultClass << "\">"
01434 << "<CLASSNAME NAME=\"" << resultClass <<
01435 "\"></CLASSNAME></IPARAMVALUE>";
01436 }
01437 objectWithPathOp op(iresult,cresult,ns);
01438 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params, extra.toString());
01439 }
01440 #endif // #ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
01441
01442 CIMInstanceEnumeration
01443 CIMXMLCIMOMHandle::execQuery(
01444 const String& ns,
01445 const String& query, int wqlLevel)
01446 {
01447 return CIMOMHandleIFC::execQueryE(ns, query,
01448 String("WQL") + String(wqlLevel));
01449 }
01451 void
01452 CIMXMLCIMOMHandle::execQuery(
01453 const String& ns,
01454 CIMInstanceResultHandlerIFC& result,
01455 const String& query, const String& queryLanguage)
01456 {
01457 static const char* const commandName = "ExecQuery";
01458 Array<Param> params;
01459 params.push_back(Param(CIMXMLParser::P_QueryLanguage, XMLEscape(queryLanguage)));
01460 params.push_back(Param(CIMXMLParser::P_Query, XMLEscape(query)));
01461 objectWithPathOp op(&result, 0, ns);
01462 intrinsicMethod(ns, commandName, op, PROTOCOL_VERSION_1_0, params);
01463 }
01465 CIMFeatures
01466 CIMXMLCIMOMHandle::getServerFeatures()
01467 {
01468 return m_protocol->getFeatures();
01469 }
01471 void
01472 CIMXMLCIMOMHandle::intrinsicMethod(
01473 const String& ns, const String& operation,
01474 ClientOperation& op,
01475 const String& cimProtocolVersion,
01476 const Array<Param>& params, const String& extra)
01477 {
01478 Reference<std::iostream> iostrRef = m_protocol->beginRequest(operation, ns);
01479 std::iostream& iostr = *iostrRef;
01480 sendIntrinsicXMLHeader(operation, ns, iostr, cimProtocolVersion);
01481 for (size_t i = 0; i < params.size(); i++)
01482 {
01483 iostr << "<IPARAMVALUE NAME=\"" << params[i].getArgName()
01484 << "\">" << params[i].getArgValue() << "</IPARAMVALUE>";
01485 }
01486 if (!extra.empty())
01487 {
01488 iostr << extra;
01489 }
01490 sendXMLTrailer(iostr);
01491 doSendRequest(iostrRef, operation, ns, true, op, cimProtocolVersion);
01492 }
01493
01495 bool
01496 CIMXMLCIMOMHandle::setHTTPRequestHeader(const String& hdrName,
01497 const String& hdrValue)
01498 {
01499 bool cc = false;
01500 IntrusiveReference<HTTPClient> httpClient =
01501 m_protocol.cast_to<HTTPClient>();
01502 if (httpClient)
01503 {
01504 httpClient->addCustomHeader(hdrName, hdrValue);
01505 cc = true;
01506 }
01507 return cc;
01508 }
01509
01511 bool
01512 CIMXMLCIMOMHandle::getHTTPResponseHeader(const String& hdrName,
01513 String& valueOut) const
01514 {
01515 bool cc = false;
01516 IntrusiveReference<HTTPClient> httpClient =
01517 m_protocol.cast_to<HTTPClient>();
01518 if (httpClient)
01519 {
01520 if (!(cc = httpClient->getResponseHeader(hdrName, valueOut)))
01521 {
01522 if (HTTPUtils::headerHasKey(m_trailers, hdrName))
01523 {
01524 cc = true;
01525 valueOut = HTTPUtils::getHeaderValue(m_trailers, hdrName);
01526 }
01527 }
01528 }
01529 return cc;
01530 }
01531
01532 }
01533