pegasus/src/Pegasus/ControlProviders/InteropProvider/InteropProvider.cpp - diff

Return to InteropProvider.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ControlProviders / InteropProvider

Diff for /pegasus/src/Pegasus/ControlProviders/InteropProvider/InteropProvider.cpp between version 1.46 and 1.88.2.1

version 1.46, 2005/06/05 23:35:20

version 1.88.2.1, 2011/10/11 18:18:16

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the "Software"),

// Permission is hereby granted, free of charge, to any person obtaining a copy

// to deal in the Software without restriction, including without limitation

// of this software and associated documentation files (the "Software"), to

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// deal in the Software without restriction, including without limitation the

// and/or sell copies of the Software, and to permit persons to whom the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// Software is furnished to do so, subject to the following conditions:

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

//////////////////////////////////////////////////////////////////////////

// Author: Karl Schopmeyer (k.schopmeyer@opengroup.org)

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Karl Schopmeyer - Created Cim_Namespace capabilities.

// Karl Schopmeyer - added objectmanager and communication classes

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3194

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3659

//%////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////

// Interop Provider - This provider services those classes from the

// DMTF Interop schema association with the CIMOM itself

// DMTF Interop schema in an implementation compliant with the SMI-S v1.1

// Server Profile

// This provider services the following classes:

// Please see PG_ServerProfile20.mof in the directory

// CIMObjectManager

// $(PEGASUS_ROOT)/Schemas/Pegasus/InterOp/VER20 for retails regarding the

// CIM_ObjectManagerCommunicationMechanism

// classes supported by this control provider.

// CIM_CIMXMLCommunicationMechanism

// CIM_ProtocolAdapter (Note: Removed because deprecated class in cim 2.9)

// Interop forces all creates to the PEGASUS_NAMESPACENAME_INTEROP

// CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace.

// namespace. There is a test on each operation that returns

// the Invalid Class CIMDError

// PG_Namespace - Pegasus particular subclass of CIM_Namespace that

// add the parameters for shared namespaces

// PG_CIMXMLCommunicationMechanism - Pegasus subclass of

// CIM_CIMXMLCommunicationMechanism that adds support for passing

// additional communication parameters (ie. port, https vs. http, etc.)

// It also services the Interop associations tied to these classes

// including:

// CIM_NamespaceInManager

// ...

// This is a control provider and as such uses the Tracer functions

// for data and function traces. Since we do not expect high volume

// use we added a number of traces to help diagnostics.

///////////////////////////////////////////////////////////////////////////////

/* TODO LIST:

1. Finish the association functions

2. UUID generation should become a system function since it will be used

by many providers, etc. as part of id generation.

3. Review the key parameters on create, etc. to be sort out which are

required from user and which we can supply. I think we are asking too

much of the user right now.

4. Review deletion of _buildObjectPath, _reference, etc.

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/PegasusVersion.h>

Line 86

Line 53

#include <iostream>

#include "InteropProvider.h"

#include "Guid.h"

#include "InteropProviderUtils.h"

#include <Pegasus/Common/String.h>

#include "InteropConstants.h"

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/ArrayInternal.h>

#include <Pegasus/Common/CIMName.h>

#include <Pegasus/Common/CIMType.h>

#include <Pegasus/Common/CIMInstance.h>

#include <Pegasus/Common/CIMObjectPath.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/CIMStatusCode.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Common/OperationContext.h>

#include <Pegasus/Config/ConfigManager.h>

#include <Pegasus/Common/XmlWriter.h>

#include <Pegasus/Config/ConfigManager.h>

#include <Pegasus/Common/StatisticalData.h>

#include <Pegasus/Common/HashTable.h>

#include <stdlib.h>

#include <Pegasus/Common/StatisticalData.h>

#include <Pegasus/Common/StringConversion.h>

//The following include is needed for gethostbyname

#include <Pegasus/Common/ArrayIterator.h>

#if defined(PEGASUS_OS_TYPE_WINDOWS)

#include <objbase.h>

#else

#include <netdb.h>

#include <arpa/inet.h>

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

#define CDEBUG(X)

/*****************************************************************************

#define LDEBUG()

//#define CDEBUG(X) PEGASUS_STD(cout) << "InteropProvider (" << __LINE__ << ") " << X << PEGASUS_STD(endl)

* The following are constants representing property names for the classes

//#define LDEBUG(X) Logger::put (Logger::DEBUG_LOG, "InteropProvider", Logger::TRACE, "$0", X)

* managed by the Interop Provider. Where multiple classes have properties of

* the same name, there will be a common CIMName object defined, and a macro

//**************************************************************************

* defined that points to the common CIMName object, but whose macro name

* reflects the class in which the property is used.

// Constants representing the class names processed

*****************************************************************************/

//**************************************************************************

const char * thisProvider = "InteropProvider";

// Constructor for the InteropProvider control provider

// The following should be moved to somewhere like constants.

static const String PegasusInstanceIDGlobalPrefix = "PEG";

InteropProvider::InteropProvider(

CIMRepository * rep,

/**

ProviderRegistrationManager *provRegManager):

The constants representing the class names we process

repository(rep),

providerRegistrationManager(provRegManager),

static const CIMName CIM_NAMESPACE_CLASSNAME = CIMName ("CIM_Namespace");

hostName(System::getHostName()),

static const CIMName PG_NAMESPACE_CLASSNAME = CIMName ("PG_Namespace");

providerInitialized(false),

updateProfileCache(0),

static const CIMName CIM_OBJECTMANAGER_CLASSNAME = CIMName ("CIM_ObjectManager");

profileIds(Array<String>()),

static const CIMName CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME =

conformingElements(Array<CIMNameArray>()),

CIMName ("CIM_ObjectManagerCommunicationMechanism");

elementNamespaces(Array<CIMNamespaceArray>())

static const CIMName PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME =

CIMName ("PG_CIMXMLCommunicationMechanism");

static const CIMName CIM_COMMMECHANISMFORMANAGER_CLASSNAME =

CIMName ("CIM_CommMechanismForManager");

static const CIMName CIM_NAMESPACEINMANAGER_CLASSNAME =

CIMName ("CIM_NamespaceInManager");

// Property Names for CIM_Namespace Class

static const CIMName NAMESPACE_PROPERTYNAME = CIMName ("Name");

// Root Namespace Name for test.

static const CIMNamespaceName ROOTNS = CIMNamespaceName ("root");

// Property names for CIM_ObjectManager Class

static const CIMName OM_GATHERSTATISTICALDATA =

CIMName ("GatherStatisticalData");

// Property for the slp template.

static const CIMName OM_DESCRIPTIONPROPERTY =

CIMName("Description");

// Property Names for ObjectManagerCommunicationMechanism Class

static const CIMName OM_COMMUNICATIONMECHANISM =

CIMName ("CommunicationMechanism");

static const CIMName OM_FUNCTIONALPROFILESSUPPORTED =

CIMName ("FunctionalProfilesSupported");

static const CIMName OM_FUNCTIONALPROFILEDESCRIPTIONS =

CIMName ("FunctionalProfileDescriptions");

static const CIMName OM_AUTHENTICATIONMECHANISMSSUPPORTED =

CIMName ("AuthenticationMechanismsSupported");

static const CIMName OM_AUTHENTICATIONMECHANISMDESCRIPTIONS =

CIMName ("AuthenticationMechanismDescriptions");

static const CIMName OM_MULTIPLEOPERATIONSSUPPORTED =

CIMName ("MultipleOperationsSupported");

static const CIMName OM_VERSION =

CIMName ("Version");

// Property Names for CIMXML CommunicationMechanism

static const CIMName CIMVALIDATED =

CIMName ("CIMValidated");

static const String CIMXMLProtocolVersion = "1.0";

// Property names for CIM_Namespace Class

static const CIMName CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME =

CIMName ("SystemCreationClassName");

static const CIMName CIM_NAMESPACE_PROPERTY_SYSTEMNAME =

CIMName ("SystemName");

static const CIMName CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME =

CIMName ("ObjectManagerCreationClassName");

static const CIMName CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME =

CIMName ("ObjectManagerName");

static const CIMName CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME =

CIMName ("CreationClassName");

static const CIMName CIM_NAMESPACE_PROPERTY_NAME = CIMName ("Name");

static const CIMName CIM_NAMESPACE_PROPERTY_CLASSINFO =

CIMName ("ClassInfo");

static const CIMName CIM_NAMESPACE_PROPERTY_DESCRIPTIONOFCLASSINFO =

CIMName ("DescriptionOfClassInfo");

// Additional Property names for PG_Namespace Class

static const CIMName PG_NAMESPACE_PROPERTY_SCHEMAUPDATESALLOWED =

CIMName ("SchemaUpdatesAllowed");

static const CIMName PG_NAMESPACE_PROPERTY_ISSHAREABLE =

CIMName ("IsShareable");

static const CIMName PG_NAMESPACE_PROPERTY_PARENTNAMESPACE =

CIMName ("ParentNamespace");

static const CIMName PG_NAMESPACE_PROPERTY_NAME =

CIMName ("Name");

// Defines to serve as the ENUM for class selection for instance

// operations.

enum targetClass{

PG_NAMESPACE = 1,

CIM_OBJECTMANAGER = 2,

PG_CIMXMLCOMMUNICATIONMECHANISM = 3,

CIM_NAMESPACEINMANAGERINST =4,

CIM_COMMMECHANISMFORMANAGERINST=5,

CIM_NAMESPACEINMANAGER=6

};

enum targetAssocClass{

CIM_NAMESPACEINMANAGERASSOC = 1,

CIM_COMMMECHANISMFORMANAGERASSOC=2

};

String _showPathArray(Array<CIMObjectPath>& p)

{

String rtn;

for (Uint32 i = 0 ; i < p.size() ; i++)

{

if (i > 0)

rtn.append(" ");

rtn.append(p[i].toString());

}

return(rtn);

}

void _printInstance(String& message, CIMInstance& instance)

{

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s %s\npath: %s\n %s",thisProvider, message.getCString(),

(instance.getPath().toString().getCString()),

( ( CIMObject) instance).toString().getCString());

}

//*************************************************************

// Constructor

//**********************************************************

InteropProvider::InteropProvider(CIMRepository* repository)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,"InteropProvider::InteropProvider");

_repository = repository;

//***********************************************

// This is a tempory fix untill there is a method created for the InteropProvider to

// do it's inalization work. This fix sets StatisticalData::CopyGSD, enabling the

//statistical gathering function.

ConfigManager *configManager = ConfigManager::getInstance();

#ifdef PEGASUS_ENABLE_SLP

enableSLP = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("slp"));

#else

enableSLP = false;

#endif

Boolean InstancesExists = true;

httpPort = configManager->getCurrentValue("httpPort");

Array<CIMInstance> instance;

if (httpPort.size() == 0)

try

{

instance = repository->enumerateInstances(CIMNamespaceName("root/cimv2"),

Uint32 portNumberHttp = System::lookupPort(

CIMName ("CIM_ObjectManager"));

WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);

char buffer[32];

Uint32 n;

const char *output = Uint32ToString(buffer, portNumberHttp, n);

httpPort.assign(output, n);

}

catch(Exception e)

httpsPort = configManager->getCurrentValue("httpsPort");

if (httpsPort.size() == 0)

{

InstancesExists = false;

Uint32 portNumberHttps = System::lookupPort(

WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);

char buffer[32];

Uint32 n;

const char *output = Uint32ToString(buffer, portNumberHttps, n);

httpsPort.assign(output, n);

}

/* When Bug 3696 is fixed the following try block will replace the try block above. But for

now if no instances of the CIM_ObjectManager class are found in the root/cimv2 name space

#ifndef PEGASUS_DISABLE_PERFINST

the root/PG_InterOp name space will be checked

if(!InstancesExists)

{

try

{

instance = repository->enumerateInstances(CIMNamespaceName("root/PG_InterOp"),

initProvider();

CIMName ("CIM_ObjectManager"));

}

catch(Exception e)

catch(const Exception &)

{

InstancesExists = false;

// Provider initialization may fail if the repository is not

}

// populated

}

#endif

if(instance.size() > 0 && InstancesExists)

{

Boolean output = false;

Uint32 pos;

if ((pos = instance[0].findProperty(CIMName("GatherStatisticalData"))) != PEG_NOT_FOUND)

{

CIMConstProperty p1 = instance[0].getProperty(pos);

if (p1.getType() == CIMTYPE_BOOLEAN)

{

CIMValue v1 = p1.getValue();

if (!v1.isNull())

{

v1.get(output);

if (v1 == true)

{

StatisticalData* sd = StatisticalData::current();

sd->setCopyGSD(true);

}

//******************************************* end of temporary fix

PEG_METHOD_EXIT();

}

//***************************************************************

// Provider Utility Functions

// Local version of getInstance to be used by other functions in the the

//***************************************************************

// provider. Returns a single instance. Note that it always returns an

// instance. If none was found, it is uninialitized.

CIMInstance InteropProvider::localGetInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const CIMPropertyList & propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance");

PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s getInstance. instanceName= %s , PropertyList= %s",

thisProvider,

(const char *)instanceName.toString().getCString(),

(const char *)propertyListToString(propertyList).getCString()));

String _showBool(Boolean x)

// Test if we're looking for something outside of our namespace. This will

// happen during associators calls from PG_RegisteredProfile instances

// through the PG_ElementConformsToProfile association

CIMNamespaceName opNamespace = instanceName.getNameSpace();

CIMName opClass = instanceName.getClassName();

if((opNamespace != PEGASUS_NAMESPACENAME_INTEROP &&

opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE)

// Get CIM_IndicationService instance from IndicationService.

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

|| opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE

#endif

)

{

return(x? "true" : "false");

AutoMutex mut(interopMut);

CIMInstance gotInstance = cimomHandle.getInstance(

context,

opNamespace,

instanceName,

false,

propertyList);

PEG_METHOD_EXIT();

return gotInstance;

}

static String _toStringPropertyList(const CIMPropertyList& pl)

TARGET_CLASS classEnum = translateClassInput(opClass);

CIMInstance retInstance;

switch(classEnum)

{

String tmp;

case PG_SOFTWAREIDENTITY:

for (Uint32 i = 0; i < pl.size() ; i++)

{

if (i > 0)

retInstance = getSoftwareIdentityInstance(instanceName);

tmp.append(", ");

normalizeInstance(

tmp.append(pl[i].getString());

retInstance, instanceName, false, false, propertyList);

}

return(tmp);

break;

case PG_NAMESPACE:

{

retInstance = getNameSpaceInstance(instanceName);

normalizeInstance(

retInstance, instanceName, false, false, propertyList);

}

break;

// ATTN: Implement getIntstance for all other classes. Currently

// this method calls localEnumerateInstances() to select instance

// which is too expensive.

default:

{

// Create reference from host, namespace, class components of

// instance name

CIMObjectPath ref;

ref.setHost(instanceName.getHost());

ref.setClassName(opClass);

ref.setNameSpace(opNamespace);

// Enumerate instances for this class. Returns all instances

// Note that this returns paths setup and instances already

// filtered per the input criteria.

Array<CIMInstance> instances = localEnumerateInstances(

context,

ref,

propertyList);

ConstArrayIterator<CIMInstance> instancesIter(instances);

/* set the hostname and namespace fields into the cimobjectpath

// deliver a single instance if found.

of the defined instance

bool found = false;

for(Uint32 i = 0; i < instancesIter.size(); i++)

{

void _setCompleteInstancePath(CIMInstance& instance,

CIMObjectPath currentInstRef = instancesIter[i].getPath();

const CIMObjectPath& inputPath)

currentInstRef.setHost(instanceName.getHost());

currentInstRef.setNameSpace(instanceName.getNameSpace());

if(instanceName == currentInstRef)

{

CIMObjectPath p = instance.getPath();

retInstance = instancesIter[i];

p.setHost(inputPath.getHost());

found = true;

p.setNameSpace(inputPath.getNameSpace());

break;

}

instance.setPath(p);

PEG_METHOD_EXIT();

if (!found)

{

throw CIMObjectNotFoundException(instanceName.toString());

}

/* complete the instance by setting the complete path into the instance

return retInstance;

and executing the instance filter to set the qualifiers, classorigin and

}

propertylist in accordance with the input. Note that this can only remove

characteristics, except for the path completion so that it expects instances

with qualifiers included, class origin included and a complete property

list.

Array<CIMInstance> InteropProvider::getReferencedInstances(

const Array<CIMInstance> &refs,

const String targetRole,

const OperationContext & context,

const CIMPropertyList & propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::getReferencedObjects");

void _finishInstance(CIMInstance& instance, const CIMObjectPath& path, Boolean includeQualifiers,

Array<CIMInstance> referencedInstances;

Boolean includeClassOrigin, const CIMPropertyList& propertyList)

Array<CIMInstance> classInstances;

CIMName prevClassName;

ConstArrayIterator<CIMInstance> refsIter(refs);

for(Uint32 i = 0; i < refsIter.size(); i++)

{

CIMInstance thisRef = refsIter[i];

CIMObjectPath thisTarget = getRequiredValue<CIMObjectPath>(

thisRef,

targetRole);

// Test if we're looking for something outside of our namespace. This

// will happen during associators calls from PG_RegisteredProfile

// instances through the PG_ElementConformsToProfile association

CIMNamespaceName opNamespace = thisTarget.getNameSpace();

CIMName opClass = thisTarget.getClassName();

if((opNamespace != PEGASUS_NAMESPACENAME_INTEROP &&

opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE)

// Get CIM_IndicationService instance from IndicationService.

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

|| opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE

#endif

)

{

_setCompleteInstancePath( instance, path);

AutoMutex mut(interopMut);

instance.filter(includeQualifiers,

CIMInstance gotInstance = cimomHandle.getInstance(

includeClassOrigin,

context,

opNamespace,

thisTarget,

false,

propertyList );

referencedInstances.append(gotInstance);

continue;

}

static String _showPropertyList(const CIMPropertyList& pl)

{

if (pl.isNull())

return("NULL");

String tmp;

TARGET_CLASS classEnum = translateClassInput(opClass);

CIMInstance retInstance;

tmp.append((pl.size() == 0) ? "Empty" : _toStringPropertyList(pl));

switch(classEnum)

return(tmp);

{

case PG_SOFTWAREIDENTITY:

{

CIMInstance retInstance =

getSoftwareIdentityInstance(thisTarget);

normalizeInstance(

retInstance, thisTarget, false, false, propertyList);

retInstance.setPath(thisTarget);

referencedInstances.append(retInstance);

}

break;

/** get one string property from an instance. Note that these functions simply

case PG_NAMESPACE:

return the default value if the property cannot be found or is of the wrong

{

type thus, in reality being a maintenance problem since there is no

CIMInstance retInstance = getNameSpaceInstance(thisTarget);

error indication.

normalizeInstance(

@param instance CIMInstance from which we get property value

retInstance, thisTarget, false, false, propertyList);

@param propertyName String name of the property containing the value

retInstance.setPath(thisTarget);

@param default String optional parameter that is substituted if the property does

referencedInstances.append(retInstance);

not exist, is Null, or is not a string type. The substitute is String::EMPTY

}

@return String value found or defaultValue.

break;

default:

String _getPropertyValue(const CIMInstance& instance, const CIMName& propertyName, const String& defaultValue)

{

String output = defaultValue;

if( opClass != prevClassName )

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

{

CIMConstProperty p1 = instance.getProperty(pos);

CIMObjectPath ref;

if (p1.getType() == CIMTYPE_STRING)

ref.setHost(thisTarget.getHost());

ref.setClassName(thisTarget.getClassName());

ref.setNameSpace(thisTarget.getNameSpace());

classInstances = localEnumerateInstances(

context,

ref,

propertyList);

ArrayIterator<CIMInstance> instsIter(classInstances);

for(Uint32 n = 0; n < instsIter.size(); n++)

{

CIMValue v1 = p1.getValue();

CIMObjectPath tmpInst = instsIter[n].getPath();

tmpInst.setHost(thisTarget.getHost());

if (!v1.isNull())

tmpInst.setNameSpace(thisTarget.getNameSpace());

v1.get(output);

instsIter[n].setPath(tmpInst);

}

return(output);

prevClassName = opClass;

}

ConstArrayIterator<CIMInstance> instsConstIter(classInstances);

// Overload of _getPropertyValue for boolean type

for(Uint32 j = 0; j < instsConstIter.size(); j++)

Boolean _getPropertyValue(const CIMInstance& instance, const CIMName& propertyName, const Boolean defaultValue)

{

Boolean output = defaultValue;

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

{

CIMConstProperty p1 = instance.getProperty(pos);

if(thisTarget == instsConstIter[j].getPath())

if (p1.getType() == CIMTYPE_BOOLEAN)

{

CIMValue v1 = p1.getValue();

referencedInstances.append(instsConstIter[j]);

break;

if (!v1.isNull())

v1.get(output);

}

return(output);

}

break;

}

PEG_METHOD_EXIT();

return referencedInstances;

}

/** get Host IP address from host name. If the

host name is not provided, uses internal function.

// Local version of enumerateInstances to be used by other functions in the

If everything fails, gets the definition normally

// provider. Note that this delivers instances as a group rather than one

used for localhost (127.0.0.1).

// at a time. This design point may need to be revisited if this provider

// is used in environments such that returning segmented responses would have

@param hostName String with the name of the host

// significant performance advantages. For now, that doesn't seem to be the

@param namespaceType - Uint32 representing the

// case.

access protocol for this request. This is exactly

the definition in the PG_CIMXMLCommunicationMechanism

Array<CIMInstance> InteropProvider::localEnumerateInstances(

mof for the property namespaceAccessProtocol.

const OperationContext & context,

@return String with the IP address to be used. This must

const CIMObjectPath & ref,

be the complete address sufficient to access the

const CIMPropertyList& propertyList)

IP address. Therefore, it includes the port number.

String _getHostAddress(String & hostName, Uint32 namespaceType)

{

String ipAddress;

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::localEnumerateInstances()");

const CIMName & className = ref.getClassName();

PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s enumerateInstances. referenc= %s , PropertyList= %s",

thisProvider,

(const char *)className.getString().getCString(),

(const char *)propertyListToString(propertyList).getCString()));

if (hostName == String::EMPTY)

// Verify that ClassName is correct and get its enum value

hostName = System::getHostName();

TARGET_CLASS classEnum = translateClassInput(className);

if ((ipAddress = System::getHostIP(hostName)) == String::EMPTY)

Array<CIMInstance> instances;

switch(classEnum)

{

// set default address if everything else failed

case PG_OBJECTMANAGER:

ipAddress = String("127.0.0.1");

}

// Question: is there a case where we leave off the port number.

// Code to get the property service_location_tcp ( which is equivalent to "IP address:5988")

// Need to tie these two together.

Uint32 portNumber;

/********************** Drop this

ConfigManager* configManager = ConfigManager::getInstance();

Boolean enableHttpConnection = String::equal(

configManager->getCurrentValue("enableHttpConnection"), "true");

Boolean enableHttpsConnection = String::equal(

configManager->getCurrentValue("enableHttpsConnection"), "true");

***********************/

// ATTN: The following is incorrect and must be modified as part

// of bug 1857 and possibly other bug reports. KS. This is 2.5 mustfix.

// Match the protocol and port number from internal information.

if (namespaceType == 3)

portNumber = System::lookupPort(WBEM_HTTPS_SERVICE_NAME,

WBEM_DEFAULT_HTTPS_PORT);

else if (namespaceType == 2)

{

portNumber = System::lookupPort(WBEM_HTTP_SERVICE_NAME,

instances.append(getObjectManagerInstance());

WBEM_DEFAULT_HTTP_PORT);

break;

}

else

portNumber = 0;

// convert portNumber to ascii

char buffer[32];

sprintf(buffer, ":%u", portNumber);

if (portNumber != 0)

ipAddress.append(buffer);

// now fillout the serviceIDAttribute from the object manager instance name property.

// This is a key field so must have a value.

//String strUUID = _getPropertyValue( instance_ObjMgr, namePropertyName, "DefaultEmptyUUID");

return ipAddress;

}

case PG_CIMXMLCOMMUNICATIONMECHANISM:

Array<String> _getFunctionalProfiles(Array<Uint16> & profiles)

{

Array<String> profileDescriptions;

instances = enumCIMXMLCommunicationMechanismInstances();

profiles.append(2); profileDescriptions.append("Basic Read");

break;

profiles.append(3); profileDescriptions.append("Basic Write");

profiles.append(4); profileDescriptions.append("Schema Manipulation");

profiles.append(5); profileDescriptions.append("Instance Manipulation");

profiles.append(6); profileDescriptions.append("Association Traversal");

profiles.append(8); profileDescriptions.append("Qualifier Declaration");

profiles.append(9); profileDescriptions.append("Indications");

return(profileDescriptions);

}

case PG_NAMESPACEINMANAGER:

/* get the prefix that will be part of the cimom identification

This can be either the default PEG or if the environment

variable PEGASUS_TRADEMARK_PREFIX is defined this is used.

NOTE: getting from the environment variable is a hack until

we can come up with a better source.

@return String containing the unique name for the CIMOM ID

String getTrademarkCIMOMIDPrefix()

{

instances = enumNamespaceInManagerInstances();

char * trademark;

break;

trademark = getenv("PEGASUS_TRADEMARK_PREFIX");

return((trademark)? trademark : PegasusInstanceIDGlobalPrefix);

}

/** Builds the UUID string for this CIMOM.

case PG_COMMMECHANISMFORMANAGER:

**/

String getUUIDString()

{

return(Guid::getGuid());

instances = enumCommMechanismForManagerInstances();

break;

}

case PG_NAMESPACE:

/* Test the keys in the CIM_Namespace for valid values

This includes all of the keys above the name key.

THis is a dummy for now.

ATTN: KS Extend and finish this function.

Boolean _validateProperties(const CIMObjectPath& path)

{

return true;

instances = enumNamespaceInstances();

break;

}

case PG_REGISTEREDPROFILE:

Boolean _validateProperties(const CIMInstance& instance)

{

return true;

instances = enumRegisteredProfileInstances();

break;

}

case PG_REGISTEREDSUBPROFILE:

/* Validate that the property exists, is string type and

optionally the value itself. Note processes only String

properties.

@param Instance to search for property.

@param CIMName containing property Name

@value String containing value. If not String::EMPTY, compare to

value in the property

@return True if passes all tests

Boolean _validateRequiredProperty(const CIMInstance& instance,

const CIMName& propertyName,

const String& value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_validateRequiredProperty()");

Uint32 pos;

if ((pos = instance.findProperty (propertyName)) == PEG_NOT_FOUND)

{

PEG_METHOD_EXIT();

instances = enumRegisteredSubProfileInstances();

return(false);

break;

}

case PG_REFERENCEDPROFILE:

// Get the property

CIMConstProperty theProperty = instance.getProperty(pos);

const CIMValue theValue = theProperty.getValue ();

// ATTN: Required property must have a non-null value

if ((theValue.getType() != CIMTYPE_STRING) || (theValue.isNull()))

{

PEG_METHOD_EXIT();

instances = enumReferencedProfileInstances();

return(false);

break;

}

case PG_ELEMENTCONFORMSTOPROFILE:

String valueField;

theValue.get(valueField);

if ((value == String::EMPTY) || (valueField == value))

{

PEG_METHOD_EXIT();

instances = enumElementConformsToProfileInstances(context,

return(true);

ref.getNameSpace());

break;

}

PEG_METHOD_EXIT();

case PG_ELEMENTCONFORMSTOPROFILE_RP_RP:

return(false);

{

instances = enumElementConformsToProfileRPRPInstances(

context,

ref.getNameSpace());

break;

}

case PG_SUBPROFILEREQUIRESPROFILE:

Boolean _validateRequiredProperty(const CIMInstance& instance,

const CIMName& propertyName,

const Uint16& value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

instances = enumSubProfileRequiresProfileInstances();

"InteropProvider::_validateRequiredProperty()");

break;

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, "Validate "

case PG_SOFTWAREIDENTITY:

+ propertyName.getString());

Uint32 pos;

if ((pos = instance.findProperty (propertyName)) == PEG_NOT_FOUND)

{

PEG_METHOD_EXIT();

instances = enumSoftwareIdentityInstances();

return(false);

break;

}

case PG_ELEMENTSOFTWAREIDENTITY:

// Get the property

CIMConstProperty theProperty = instance.getProperty(pos);

CIMValue theValue = theProperty.getValue ();

// ATTN:Required property must have a non-null value

if ((theValue.getType() != CIMTYPE_UINT16)

|| (theValue.isNull()) )

{

PEG_METHOD_EXIT();

instances = enumElementSoftwareIdentityInstances();

return(false);

break;

}

PEG_METHOD_EXIT();

case PG_INSTALLEDSOFTWAREIDENTITY:

return(true);

{

instances = enumInstalledSoftwareIdentityInstances(context);

break;

}

case PG_COMPUTERSYSTEM:

Boolean _validateRequiredProperty(const CIMObjectPath& objectPath,

const CIMName& propertyName,

const String value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

instances.append(getComputerSystemInstance(context));

"InteropProvider::_validateRequiedProperty()");

break;

Array<CIMKeyBinding> kbArray = objectPath.getKeyBindings();

}

case PG_HOSTEDOBJECTMANAGER:

// find the correct key binding

for (Uint32 i = 0; i < kbArray.size(); i++)

{

if (kbArray[i].getName() == propertyName)

instances.append(getHostedObjectManagerInstance(context));

break;

}

case PG_HOSTEDACCESSPOINT:

{

if (value != String::EMPTY)

instances = enumHostedAccessPointInstances(context);

break;

}

//We don't support enumerate CIM_Namespace instances. PG_Namespace is

//supported.

case CIM_NAMESPACE:

{

if (value !=kbArray[i].getValue())

break;

}

case PG_PROVIDERPROFILECAPABILITIES:

{

PEG_METHOD_EXIT();

instances = enumProviderProfileCapabilityInstances(false);

return(true);

break;

}

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

case PG_ELEMENTCAPABILITIES:

{

instances = enumElementCapabilityInstances(context);

break;

}

case PG_HOSTEDINDICATIONSERVICE:

{

instances = enumHostedIndicationServiceInstances(context);

break;

}

case PG_SERVICEAFFECTSELEMENT:

{

instances = enumServiceAffectsElementInstances(context);

break;

}

#endif

default:

PEG_METHOD_EXIT();

return(true);

throw CIMNotSupportedException(className.getString() +

" not supported by Interop Provider enumerate");

}

/* Query the repository for array of all namespacenames

// Filter and deliver the resulting instances

@return Array<CIMNamespaceName> with all namespaces

for (Uint32 i = 0 ; i < instances.size() ; i++)

@exception Passes all exception that repository may generate.

Array<CIMNamespaceName> InteropProvider::_enumerateNameSpaces()

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

normalizeInstance(instances[i], ref, false,

"InteropProvider::_enumerateNameSpaces()");

false, propertyList);

}

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _repository->enumerateNameSpaces();

PEG_METHOD_EXIT();

return(namespaceNames);

return instances;

}

/* get a class defintion. Gets the class defined by

the parameters. Generates exception of class not defined.

// Class that determines whether or not the origin class in an association

@param namespace in which to look for the class.

// operation is valid for the given association class, and also determines

@param name of class to get.

// the origin and target "roles". These values generally correspond to the

@return the CIMClass object

// role and resultRole parameter of an associators/associatorNames operation.

@Exceptions any repository exceptions if class not found.

bool InteropProvider::validAssocClassForObject(

CIMClass InteropProvider::_getClass(const CIMObjectPath& objectPath,

const OperationContext & context,

const CIMName& className)

const CIMName & assocClass,

const CIMObjectPath & objectName,

const CIMNamespaceName & opNamespace,

String & originProperty,

String & targetProperty)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::validAssocClassForObject()");

TARGET_CLASS assocClassEnum = translateClassInput(assocClass);

TARGET_CLASS originClassEnum = NOCLASS;

CIMName originClass = objectName.getClassName();

// If the association class is PG_ElementConformsToProfile, we'll have to

// do some special processing in case the origin instance for the operation

// is managed by another provider.

if(assocClassEnum == PG_ELEMENTCONFORMSTOPROFILE)

{

// Test if the origin is an element managed by another provider

// that has implemented a registered profile.

if(opNamespace != PEGASUS_NAMESPACENAME_INTEROP ||

(originClass != PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE &&

originClass != PEGASUS_CLASSNAME_PG_OBJECTMANAGER ))

{

// Search the cached conformingElements list for the originClass,

// returning false if it is not found

bool found = false;

PEGASUS_ASSERT(conformingElements.size() ==

elementNamespaces.size());

for(Uint32 i = 0, n = conformingElements.size(); i < n; ++i)

{

CIMNameArray & elementList = conformingElements[i];

CIMNamespaceArray & namespaceList = elementNamespaces[i];

PEGASUS_ASSERT(elementList.size() == namespaceList.size());

for(Uint32 j = 0, m = elementList.size(); j < m; ++j)

{

CIMName & curElement = elementList[j];

if((curElement == originClass ||

curElement.getString().find(PEGASUS_DYNAMIC) == 0) &&

opNamespace == namespaceList[j])

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

found = true;

"InteropProvider::_getClass");

break;

}

CIMClass myClass = _repository->getClass(objectPath.getNameSpace(), className,

}

false,true,true);

if(found)

PEG_METHOD_EXIT();

break;

return myClass;

}

/* Verify that this is one of the legal classnames and

if(!found)

return indicator which.

@param - Classname

@return - Uint32 indicating type

@Exceptions - throws CIMNotSupportedException if invalid class.

static targetClass _verifyValidClassInput(const CIMName& className)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_verifyValidClassInput");

if (className.equal(CIM_OBJECTMANAGER_CLASSNAME))

return CIM_OBJECTMANAGER;

if (className.equal(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME))

return PG_CIMXMLCOMMUNICATIONMECHANISM;

if (className.equal(CIM_NAMESPACEINMANAGER_CLASSNAME))

return CIM_NAMESPACEINMANAGER;

// Last entry, reverse test and return OK if PG_Namespace

// Note: Changed to PG_Namespace for CIM 2.4

if (!className.equal(PG_NAMESPACE_CLASSNAME))

throw CIMNotSupportedException

(className.getString() + " not supported by Interop Provider");

PEG_METHOD_EXIT();

return PG_NAMESPACE;

return false;

}

static targetAssocClass _verifyValidAssocClassInput(const CIMName& className)

}

else

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

// Otherwise, just get the enum value representing the origin class

"InteropProvider::_verifyValidAssocClassInput");

// for this operation

if (className.equal(CIM_NAMESPACEINMANAGER_CLASSNAME))

originClassEnum = translateClassInput(originClass);

return CIM_NAMESPACEINMANAGERASSOC;

// Last entry, reverse test and return OK if CIM_CommMech....

if (!className.equal(CIM_COMMMECHANISMFORMANAGER_CLASSNAME))

throw CIMNotSupportedException

(className.getString() + " not supported by Interop Provider");

PEG_METHOD_EXIT();

return CIM_COMMMECHANISMFORMANAGERASSOC;

}

/* validate the authorization of the user name against the namespace.

CIMName expectedTargetRole;

CIMName expectedOriginRole;

String _validateUserID(const OperationContext & context)

Array<CIMName> propNames;

String profileName;

CIMPropertyList propertyList;

CIMInstance tmpInstance;

Uint32 index;

propNames.clear();

// Set the target and origin role values. Note that if these values are

// not set following the switch block, that implies that the origin class

// is not valid for the supplied association class.

switch(assocClassEnum)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

case PG_NAMESPACEINMANAGER:

"InteropProvider::_validateUserID");

if(originClassEnum == PG_OBJECTMANAGER)

//ATTN-DME-P3-20020522: ADD AUTHORIZATION CHECK TO __NAMESPACE PROVIDER

String userName;

try

{

IdentityContainer container = context.get(IdentityContainer::NAME);

expectedTargetRole = PROPERTY_DEPENDENT;

userName = container.getUserName();

expectedOriginRole = PROPERTY_ANTECEDENT;

}

else if(originClassEnum == PG_NAMESPACE)

catch (...)

{

userName = String::EMPTY;

expectedTargetRole = PROPERTY_ANTECEDENT;

expectedOriginRole = PROPERTY_DEPENDENT;

}

break;

PEG_METHOD_EXIT();

case PG_COMMMECHANISMFORMANAGER:

return userName;

if(originClassEnum == PG_OBJECTMANAGER)

}

/** Set the value of a property defined by property name in the instance provided.

Sets a String into the value field unless the property name cannot be found.

If the property cannot be found, it simply returns.

ATTN: This function does not pass an error back if property not found.

@param instance CIMInstance in which to set property value

@param propertyName CIMName of property in which value will be set.

@param value String value to set into property

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const String& value)

{

Uint32 pos;

expectedTargetRole = PROPERTY_DEPENDENT;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

expectedOriginRole = PROPERTY_ANTECEDENT;

instance.getProperty(pos).setValue(CIMValue(value));

}

else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Boolean& value)

{

Uint32 pos;

expectedTargetRole = PROPERTY_ANTECEDENT;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

expectedOriginRole = PROPERTY_DEPENDENT;

instance.getProperty(pos).setValue(CIMValue(value));

}

break;

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Uint16& value)

case PG_ELEMENTCONFORMSTOPROFILE:

if(originClass.equal(PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE))

{

Uint32 pos;

expectedTargetRole =

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

instance.getProperty(pos).setValue(CIMValue(value));

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

}

else

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Array<String>& value)

{

Uint32 pos;

expectedTargetRole =

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

instance.getProperty(pos).setValue(CIMValue(value));

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

}

break;

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Array<Uint16>& value)

case PG_ELEMENTCONFORMSTOPROFILE_RP_RP:

propNames.append(CIMName("RegisteredName"));

propertyList = CIMPropertyList(propNames);

try

{

Uint32 pos;

tmpInstance = localGetInstance(

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

context,

instance.getProperty(pos).setValue(CIMValue(value));

objectName,

propertyList);

}

catch (CIMException &e)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const CIMObjectPath& value)

{

Uint32 pos;

PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL2,

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

"CIMException while getting instance of Registered Profile "

instance.getProperty(pos).setValue(CIMValue(value));

": %s",

(const char*)e.getMessage().getCString()));

}

if (!tmpInstance.isUninitialized())

/** add the correct values to the common keys defined for all of the classes. This is

systemcreationclassname and systemname

Note that if the properties do not exist, we simply ignore them.

void _fixInstanceCommonKeys(CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

index = tmpInstance.findProperty("RegisteredName");

"InteropProvider::_fixInstanceCommonKeys()");

if (index != PEG_NOT_FOUND)

String SystemCreationClassName = System::getSystemCreationClassName ();

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

SystemCreationClassName);

// Add property SystemName

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

System::getFullyQualifiedHostName());

PEG_METHOD_EXIT();

}

/** builds one instance of the class named className. Gets Class defintion and f

fills in the correct properties from the class. This requires a repository

getclass request for each instance built. The skeleton is built by

creating the instance and copying qualifiers and properties from

the class. Finally the instance is cloned to separate it from the

original objects.

NOTE: This is very inefficient for anything larger than a few instances.

We should separate the get from the createSkeleton.

@param className CIMName of the class for which the instance is to be built

@return CIMInstance of this class with properties complete.

@exception passes on any exceptions received from the repository request.

CIMInstance InteropProvider::_buildInstanceSkeleton(const CIMObjectPath & objectPath,

const CIMName& className,

CIMClass& returnedClass)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

const CIMValue &tmpVal =

"InteropProvider::_buildInstanceSkeleton()");

tmpInstance.getProperty(index).getValue();

// get class with lo = false, qualifier = true classorig = true

if (!tmpVal.isNull())

CIMClass myClass = _repository->getClass(objectPath.getNameSpace(),

className, false, true, true);

returnedClass = myClass;

CIMInstance skeleton = myClass.buildInstance(true,true,CIMPropertyList());

PEG_METHOD_EXIT();

return(skeleton);

}

/* build a single instance of the cimxmlcommunicationmechanism class

using the parameter provided as the name property.

Builds the complete instance and sets the path into it.

@parm name String representing the name to be used for this object.

@return CIMInstance of the class

CIMInstance InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism(

const CIMObjectPath& objectPath,

const String& namespaceType,

const Uint16& accessProtocol,

const String& IPAddress)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

tmpVal.get(profileName);

"InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism()");

CIMClass targetClass;

CIMInstance instance = _buildInstanceSkeleton(objectPath,

PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME,

targetClass);

_fixInstanceCommonKeys(instance);

//CreationClassName

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString());

//Name, this CommunicationMechanism. We need to make it unique. To do this

// we simply append the commtype to the classname since we have max of two right

// now.

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,

(String("PEGASUSCOMM") + namespaceType));

// CommunicationMechanism Property - Force to 2.

_setPropertyValue(instance, OM_COMMUNICATIONMECHANISM, Uint16(2));

//Functional Profiles Supported Property.

Array<Uint16> profiles;

Array<String> profileDescriptions = _getFunctionalProfiles(profiles);

// Set functional profiles in instance

_setPropertyValue(instance, OM_FUNCTIONALPROFILESSUPPORTED, profiles);

_setPropertyValue(instance, OM_FUNCTIONALPROFILEDESCRIPTIONS, profileDescriptions);

// Multiple OperationsSupported Property

_setPropertyValue(instance, OM_MULTIPLEOPERATIONSSUPPORTED, false);

// AuthenticationMechanismsSupported Property

Array<Uint16> authentications;

Array<String> authenticationDescriptions;

//TODO - get from system.

authentications.append(3); authenticationDescriptions.append("Basic");

_setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMSSUPPORTED, authentications);

_setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMDESCRIPTIONS, authenticationDescriptions);

_setPropertyValue(instance, OM_VERSION, CIMXMLProtocolVersion);

// Obsolete function

_setPropertyValue(instance, "namespaceType", namespaceType);

_setPropertyValue(instance, "namespaceAccessProtocol", accessProtocol);

_setPropertyValue(instance, "IPAddress", IPAddress);

// build the instance path and set into instance

instance.setPath(instance.buildPath(targetClass));

PEG_METHOD_EXIT();

return(instance);

}

Array<CIMInstance> InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism(

const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism");

// This is a temporary hack to get the multiple connections.

// This is based on the configmanager being the source of what

// protocols are available, http and https.

ConfigManager* configManager = ConfigManager::getInstance();

Boolean enableHttpConnection = String::equal(

configManager->getCurrentValue("enableHttpConnection"), "true");

Boolean enableHttpsConnection = String::equal(

configManager->getCurrentValue("enableHttpsConnection"), "true");

Array<CIMInstance> instances;

Uint32 namespaceAccessProtocol;

String namespaceType;

// for each type, create the instance if that type is defined.

String hostName = System::getHostName();

if (enableHttpConnection)

{

namespaceAccessProtocol = 2;

namespaceType = "http";

CIMInstance instance =

_buildInstancePGCIMXMLCommunicationMechanism(

objectPath,

namespaceType,

namespaceAccessProtocol,

_getHostAddress(hostName, namespaceAccessProtocol));

instances.append(instance);

}

if (enableHttpsConnection)

{

namespaceAccessProtocol = 3;

namespaceType = "https";

CIMInstance instance =

_buildInstancePGCIMXMLCommunicationMechanism(

objectPath,

namespaceType,

namespaceAccessProtocol,

_getHostAddress(hostName, namespaceAccessProtocol));

instances.append(instance);

}

PEG_METHOD_EXIT();

return(instances);

}

if (String::compareNoCase(profileName, String("SMI-S")) == 0)

/* Gets the value for the CIMObjectManager name. This is a key

property with the following characteristics.

1. It is persistent. This must be persistent through CIMOM

restarts. We will save it in the instance database to achieve this.

2. It must be unique. We cannot create duplicate CIMOM names

3. It is based on the DMTF description of how unique InstanceIds

are defined (Trademark/etc followed by unique identification.

Use the Global constant PegasusInstanceIDGlobalPrefix as the

prefix allowing this to be changed.

String buildObjectManagerName()

{

return(getTrademarkCIMOMIDPrefix() + ":" + getUUIDString());

}

/** get either the local or disk CIMObjectmanager instance.

@return Boolean true if already exists. False if

not initialized. Also returns with the current version set

into local parameter.

ATTN: Probably should get rid of the local parameter since

this is used so infrequently, waste of space.

Boolean InteropProvider::_getInstanceFromRepositoryCIMObjectManager(

const CIMObjectPath& objectPath,

CIMInstance& rtnInstance,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_getInstanceCIMObjectManager");

// Try to get persistent instance from repository

Array<CIMInstance> instances;

try

{

instances = _repository->enumerateInstances(

expectedTargetRole =

objectPath.getNameSpace(),

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers,

expectedOriginRole =

includeClassOrigin, propertyList);

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

if (instances.size() >= 1)

{

// set this instance into global variable.

rtnInstance = instances[0];

// log entry if there is more than one instance.

// Some day we may support multiple entries to see other CIMOMs but

// for now this should be illegal and represent an internal error.

// but we will still continue to use the first entry.

if (instances.size() > 1)

{

Logger::put(Logger::ERROR_LOG,

System::CIMSERVER, Logger::INFORMATION,

"Error. Multiple definitons of : $0",

CIM_OBJECTMANAGER_CLASSNAME.getString());

}

return(true);

}

else

{

return(false);

expectedTargetRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

}

break;

catch(const CIMException&)

case PG_SUBPROFILEREQUIRESPROFILE:

if(originClassEnum == PG_REGISTEREDPROFILE)

{

Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

expectedTargetRole = PROPERTY_DEPENDENT;

"Error. Cannot access $0 in repository",

expectedOriginRole = PROPERTY_ANTECEDENT;

CIM_OBJECTMANAGER_CLASSNAME.getString());

PEG_METHOD_EXIT();

throw;

}

catch(const Exception&)

else if(originClassEnum == PG_REGISTEREDSUBPROFILE)

{

Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

expectedTargetRole = PROPERTY_ANTECEDENT;

"Error. Cannot access $0 in repository",

expectedOriginRole = PROPERTY_DEPENDENT;

CIM_OBJECTMANAGER_CLASSNAME.getString());

PEG_METHOD_EXIT();

throw;

}

break;

/** build an instance of the CIM_ObjectManager class filling out

case PG_REFERENCEDPROFILE:

the required properties if one does not already exist in the

if (originClassEnum == PG_REGISTEREDSUBPROFILE)

repository. This function will either return an instance

or throw an exception.

@param includeQualifiers Boolean

@param includeClassOrigin Boolean

@param propertylist CIMPropertyList

@return CIMInstance with a single built instance of the class

@exception repository instances if exception to enumerateInstances

for this class.

CIMInstance InteropProvider::_getInstanceCIMObjectManager(

const CIMObjectPath& objectPath,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

expectedTargetRole = PROPERTY_ANTECEDENT;

"InteropProvider::_buildInstanceCIMObjectManager");

expectedOriginRole = PROPERTY_DEPENDENT;

}

// Try to get the current object. If true then it is already created.

else if (originClassEnum == PG_REGISTEREDPROFILE)

CIMInstance instance;

if (!_getInstanceFromRepositoryCIMObjectManager(objectPath,

instance, includeQualifiers,includeClassOrigin,propertyList))

{

if ((targetProperty.size() != 0) &&

// No instance in the repository. Build new instance and save it.

(originProperty.size() != 0) &&

String::equalNoCase(targetProperty, originProperty))

CIMClass targetClass;

instance = _buildInstanceSkeleton(objectPath, CIM_OBJECTMANAGER_CLASSNAME,

targetClass);

_fixInstanceCommonKeys(instance);

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString());

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,buildObjectManagerName());

_setPropertyValue(instance, CIMName("ElementName"), String("Pegasus"));

//Description property this object manager instance

// default is Pegasus CIM_Server Version. Get from

// fields defined in PegasusVersion.

// TODO. Add as an alternative the capability to get this

// from config parameters.

// If PEGASUS_CIMOM_DESCRIPTION is non-zero length, use it.

// Otherwise build form the components below.

String description = (String(PEGASUS_CIMOM_DESCRIPTION).size() != 0) ?

String(PEGASUS_CIMOM_DESCRIPTION)

String(PEGASUS_CIMOM_GENERIC_NAME) + " " +

String(PEGASUS_PRODUCT_NAME) + " Version " +

String(PEGASUS_PRODUCT_VERSION) + " " +

String(PEGASUS_PRODUCT_STATUS);

_setPropertyValue(instance, CIMName("Description"), description);

//Property GatherStatisticalData. Initially this is set to false

// and can then be modified by a modify instance on the instance.

Boolean gatherStatDataFlag = false;

_setPropertyValue(instance, OM_GATHERSTATISTICALDATA, Boolean(gatherStatDataFlag));

// ATTN: This one is a problem KS rethink this.

// the following is a temporary hack to set the value of the statistics

// gathering function dynamically. We simply get the correct value

// and call the internal method to set it each time this object is

// built.

#ifndef PEGASUS_DISABLE_PERFINST

StatisticalData* sd = StatisticalData::current();

sd->setCopyGSD(gatherStatDataFlag);

#endif

// write instance to the repository

CIMObjectPath instancePath;

try

{

instancePath = _repository->createInstance(objectPath.getNameSpace(),

return false;

instance );

}

catch(const CIMException&)

if (targetProperty.size() != 0)

{

// TODO ATTN: KS generate log error if this not possible

if (!(String::equalNoCase(targetProperty, "Antecedent") ||

PEG_METHOD_EXIT();

String::equalNoCase(targetProperty, "Dependent") ))

throw;

}

catch(const Exception&)

{

// ATTN: Generate log error.

return false;

PEG_METHOD_EXIT();

throw;

}

instance.setPath(instancePath);

}

PEG_METHOD_EXIT();

return(instance);

}

if (originProperty.size() != 0)

/** Get the instances of CIM_Namespace. Gets all instances of the namespace from

the repository namespace management functions. Builds instances that

match all of the request attributes.

Array<CIMInstance> InteropProvider::_getInstancesCIMNamespace(

const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

if (!(String::equalNoCase(originProperty, "Antecedent") ||

"InteropProvider::_getInstancesCIMNamespace()");

String::equalNoCase(originProperty, "Dependent") ))

Array<CIMNamespaceName> namespaceNames = _enumerateNameSpaces();

Array<CIMInstance> instanceArray;

// Build instances of PG namespace since that is the leaf class

for (Uint32 i = 0; i < namespaceNames.size(); i++)

{

instanceArray.append( _buildInstancePGNamespace(objectPath, namespaceNames[i]));

return false;

}

PEG_METHOD_EXIT();

return(instanceArray);

}

if (String::equalNoCase(originProperty, "Antecedent") &&

/** get the instance of namespace defined by the input parameter which is the object path

targetProperty.size() == 0)

for the instance required.

ATTN: Note that this is incorrect. We are supplying the namespace name and need to supply

the objectpath

@param objectPath CIMObjectPath from request

@param nameSpace CIMNamespaceName for instance to get

@return CIMInstance with the found instance or CIMInstance() if nothing found.

CIMInstance InteropProvider::_getInstanceCIMNamespace(const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

targetProperty = String("Dependent");

"InteropProvider::_getInstancesCIMNamespace()");

}

if (String::equalNoCase(originProperty, "Dependent") &&

Array<CIMInstance> instances = _getInstancesCIMNamespace(objectPath);

targetProperty.size() == 0)

CIMNamespaceName nameSpace = objectPath.getNameSpace();

// search the instances for one with the name property value = input parameter.

for (Uint32 i = 0 ; i < instances.size() ; i++)

{

if (_getPropertyValue(instances[i], CIMName("name"), String::EMPTY) == nameSpace.getString())

targetProperty = String("Antecedent");

}

if (String::equalNoCase(targetProperty, "Antecedent") &&

originProperty.size() == 0)

{

PEG_METHOD_EXIT();

originProperty = String("Dependent");

return(instances[i]);

}

if (String::equalNoCase(targetProperty, "Dependent") &&

originProperty.size() == 0)

{

originProperty = String("Antecedent");

}

PEG_METHOD_EXIT();

return true;

CIMInstance nullInstance;

return(nullInstance);

}

/* build the full instances set of of the association class NamespacInManager.

break;

case PG_ELEMENTSOFTWAREIDENTITY:

NOTE: THe input object path is not really use at this point.

if(originClassEnum == PG_SOFTWAREIDENTITY)

Array<CIMInstance> InteropProvider::_buildInstancesNamespaceInManager(

const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

expectedTargetRole = PROPERTY_DEPENDENT;

"InteropProvider::_buildInstancesNamespaceInManager");

expectedOriginRole = PROPERTY_ANTECEDENT;

}

Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(objectPath);

else if(originClassEnum == PG_REGISTEREDPROFILE ||

originClassEnum == PG_REGISTEREDSUBPROFILE)

CIMInstance instanceObjMgr = _getInstanceCIMObjectManager(objectPath,

true, true, CIMPropertyList());

CIMObjectPath refObjMgr = instanceObjMgr.getPath();

refObjMgr.setHost(objectPath.getHost());

refObjMgr.setNameSpace(objectPath.getNameSpace());

Array<CIMInstance> assocInstances;

CIMClass targetClass;

CIMInstance instanceskel = _buildInstanceSkeleton(objectPath,

CIM_NAMESPACEINMANAGER_CLASSNAME,

targetClass);

// Build and instance for each namespace instance.

for (Uint32 i = 0 ; i < namespaceInstances.size() ; i++)

{

CIMInstance instance = instanceskel.clone();

expectedTargetRole = PROPERTY_ANTECEDENT;

_setPropertyValue(instance, CIMName("Antecedent"), refObjMgr);

expectedOriginRole = PROPERTY_DEPENDENT;

CIMObjectPath temp = namespaceInstances[i].getPath();

temp.setHost(objectPath.getHost());

temp.setNameSpace(objectPath.getNameSpace());

_setPropertyValue(instance, CIMName("Dependent"), temp);

instance.setPath(instance.buildPath(targetClass));

assocInstances.append(instance);

}

PEG_METHOD_EXIT();

break;

return(assocInstances);

case PG_INSTALLEDSOFTWAREIDENTITY:

if(originClassEnum == PG_SOFTWAREIDENTITY)

{

expectedTargetRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;

expectedOriginRole =

INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;

}

else if(originClassEnum == PG_COMPUTERSYSTEM)

{

expectedTargetRole =

INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;

expectedOriginRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;

}

/* build the instances of the defined association.

break;

case PG_HOSTEDACCESSPOINT:

Array<CIMInstance> InteropProvider::_buildInstancesCommMechanismForManager(

if(originClassEnum == PG_COMPUTERSYSTEM)

const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

expectedTargetRole = PROPERTY_DEPENDENT;

"InteropProvider::_buildInstancesCommMechanismForManager");

expectedOriginRole = PROPERTY_ANTECEDENT;

}

Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(

else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

objectPath);

CIMInstance instanceObjMgr = _getInstanceCIMObjectManager(objectPath,

true, true, CIMPropertyList());

CIMObjectPath refObjMgr = instanceObjMgr.getPath();

Array<CIMInstance> assocInstances;

CIMClass targetClass;

CIMInstance instanceskel = _buildInstanceSkeleton(objectPath,

CIM_NAMESPACEINMANAGER_CLASSNAME, targetClass);

for (Uint32 i = 0 ; i < commInstances.size() ; i++)

{

CIMInstance instance = instanceskel.clone();

expectedTargetRole = PROPERTY_ANTECEDENT;

expectedOriginRole = PROPERTY_DEPENDENT;

_setPropertyValue(instance, CIMName("Antecedent"), refObjMgr);

_setPropertyValue(instance, CIMName("Dependent"), commInstances[i].getPath());

instance.setPath(instance.buildPath(targetClass));

assocInstances.append(instance);

}

case PG_HOSTEDOBJECTMANAGER:

PEG_METHOD_EXIT();

if(originClassEnum == PG_COMPUTERSYSTEM)

return(assocInstances);

{

expectedTargetRole = PROPERTY_DEPENDENT;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

else if(originClassEnum == PG_OBJECTMANAGER)

/* generate one instance of the CIM_Namespace class with the

properties

NOTE: CIM 2.4 - Changed to build PG namespace

@param objectPath

@param namespace name to put into the class

@exceptions - exceptions carried forward from create instance

and addProperty.

CIMInstance InteropProvider::_buildInstancePGNamespace(const CIMObjectPath& objectPath,

CIMNamespaceName& nameSpace)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

expectedTargetRole = PROPERTY_ANTECEDENT;

"InteropProvider::_buildInstancePGNamespace");

expectedOriginRole = PROPERTY_DEPENDENT;

}

// ATTN: KS need to get the real objectManager name from elsewhere. the only place

break;

// this exists is through the objectmanager object.

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

// ATTN: Should we be saving the objectmanager name somewhere internally either in

case PG_HOSTEDINDICATIONSERVICE:

// interop or more generally somewhere within the system for common access.

if(originClassEnum == PG_COMPUTERSYSTEM)

String ObjectManagerName = "ObjectManagerNameValue";

{

expectedTargetRole = PROPERTY_DEPENDENT;

CIMClass targetClass;

expectedOriginRole = PROPERTY_ANTECEDENT;

CIMInstance instance = _buildInstanceSkeleton(objectPath, PG_NAMESPACE_CLASSNAME,

}

targetClass);

break;

#endif

_fixInstanceCommonKeys(instance);

default:

break;

//ObjectManagerCreationClassName

}

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME, CIM_OBJECTMANAGER_CLASSNAME.getString());

//ObjectManagerName

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME, ObjectManagerName);

//CreationClassName

// Class in which this was created,

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME, CIM_NAMESPACE_CLASSNAME.getString());

//Name

// This is the namespace name itself

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME, nameSpace.getString());

//ClassInfo

// Set the classinfo to unknown and the description to namespace.

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CLASSINFO, Uint16(0));

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_DESCRIPTIONOFCLASSINFO, String("namespace"));

// Everything above was commmon to CIM Namespace. The following is PG_Namespace Properties

// The rest of this method checks to see if target role and origin roles

// were found for the association and origin class combination and, if

// found, checks against the input target and origin roles if provided.

// Failure for any of these tests points to an invalid association

// traversal request.

// ATTN: KS Get the correct values for these entities from repository interface.

if(expectedTargetRole.isNull() ||

expectedOriginRole.isNull())

CIMRepository::NameSpaceAttributes attributes;

_repository->getNameSpaceAttributes(nameSpace.getString(), attributes);

String parent="";

String name = "";

Boolean shareable=false;

Boolean updatesAllowed=true;

for (CIMRepository::NameSpaceAttributes::Iterator i = attributes.start(); i; i++)

{

String key=i.key();

String value = i.value();

if (String::equalNoCase(key,"shareable"))

{

if (String::equalNoCase(value,"true"))

PEG_METHOD_EXIT();

shareable=true;

return false;

}

else if (String::equalNoCase(key,"updatesAllowed"))

if(targetProperty.size() == 0)

{

if (String::equalNoCase(value,"false"))

targetProperty = expectedTargetRole.getString();

updatesAllowed=false;

}

// Test to be sure we are returning proper namespace name

else if(!expectedTargetRole.equal(targetProperty))

else if (String::equalNoCase(key,"name"))

{

if (!String::equalNoCase(value, nameSpace.getString()))

{

PEG_METHOD_EXIT();

// This is poor exception since it reflects internal error. Do error log

return false;

throw PEGASUS_CIM_EXCEPTION (CIM_ERR_NOT_SUPPORTED,

"Namespace attribute rtnd error for key " + key + "expected " +

nameSpace.getString()+ value + " in " + String(thisProvider));

}

name = value;

if(originProperty.size() == 0)

}

else if (String::equalNoCase(key,"parent"))

{

parent=value;

originProperty = expectedOriginRole.getString();

}

else

else if(!expectedOriginRole.equal(originProperty))

{

PEG_METHOD_EXIT();

// Poor error definition since it reflects internal error. do error log

return false;

throw PEGASUS_CIM_EXCEPTION (CIM_ERR_NOT_SUPPORTED, nameSpace.getString()+

" namespace attribute " + key + " option not supported in"+ String(thisProvider));

}

_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_SCHEMAUPDATESALLOWED, updatesAllowed);

_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_ISSHAREABLE, shareable);

_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, parent);

_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_NAME, name);

instance.setPath(instance.buildPath(targetClass));

PEG_METHOD_EXIT();

return(instance);

return true;

}

void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath)

// Local version of the references operation. It validates the input

// parameters, setting the origin and target property values if not set

// already, and then performs an enumeration on the association class. It then

// filters the results of that enumeration to see if one of the reference

// properties matches the objectName parameter passed into the method. If so,

// then it is added to the array of association instances to be returned.

Array<CIMInstance> InteropProvider::localReferences(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & assocClass,

String & originProperty,

String & targetProperty,

const CIMPropertyList & propertyList,

const CIMName & targetClass)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_validateCIMNamespaceKeys");

"InteropProvider::localReferences()");

Boolean valid = true;

Array<CIMInstance> instances;

CIMName propertyName;

CIMName originClass = objectName.getClassName();

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

Array<CIMName> targetSubclasses;

System::getSystemCreationClassName ()))

CIMNamespaceName lastTargetNamespace;

CIMNamespaceName originNamespace(objectName.getNameSpace());

// Check that the association traversal request is valid

if (validAssocClassForObject(

context,

assocClass,

objectName,

originNamespace,

originProperty,

targetProperty))

{

// retrieve all of the association class instances

Array<CIMInstance> localInstances = localEnumerateInstances(context,

CIMObjectPath(hostName, originNamespace,

assocClass));

// Filter the association class instances based on the origin instance

// and other input parameters.

for(Uint32 i = 0, n = localInstances.size(); i < n; ++i)

{

CIMInstance & currentInstance = localInstances[i];

CIMObjectPath originPath = getRequiredValue<CIMObjectPath>(

currentInstance, originProperty);

originPath.setNameSpace(objectName.getNameSpace());

originPath.setHost(objectName.getHost());

// Only include instances where the origin instance is present in

// the association.

if(originPath.identical(objectName))

{

if(!targetClass.isNull())

{

// Have to check if the target reference is of the

// targetClass type. We first must determine all the

// possible subclasses of the targetClass in the target

// namespace.

CIMObjectPath targetPath = getRequiredValue<CIMObjectPath>(

currentInstance, targetProperty);

CIMNamespaceName targetNamespace(

targetPath.getNameSpace());

if(targetNamespace.isNull())

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

targetNamespace = originNamespace;

valid = false;

targetPath.setNameSpace(targetNamespace);

}

if (!_validateRequiredProperty(objectPath,

if(targetNamespace != lastTargetNamespace)

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

System::getFullyQualifiedHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

try

valid = false;

}

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString()))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

targetSubclasses = repository->enumerateClassNames(

valid = false;

targetNamespace, targetClass, true);

}

catch(...)

// ATTN: This one still a problem. We have to get the name first

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

// If an exception was thrown during enumeration,

valid = false;

// then the base class didn't exist in the

// namespace, so the target instance retrieved

// must not match the targetClass parameter.

continue;

}

if (!_validateRequiredProperty(objectPath,

targetSubclasses.append(targetClass);

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

lastTargetNamespace = targetNamespace;

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

valid = false;

}

if (!_validateRequiredProperty(objectPath,

// Try to find the targetPath's class in the search space

CIM_NAMESPACE_PROPERTY_NAME,

CIMName targetPathClass = targetPath.getClassName();

String::EMPTY))

for(Uint32 j = 0, m = targetSubclasses.size(); j < m; ++j)

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

if(targetPathClass == targetSubclasses[j])

valid = false;

}

if (false)

{

PEG_METHOD_EXIT();

instances.append(currentInstance);

throw CIMInvalidParameterException(

break;

"Invalid key property: " + propertyName.getString());

}

PEG_METHOD_EXIT();

}

/** completes a property in the defined instance either

by adding the complete property if it does not exist

or by adding the value if the property does exist.

Used to make sure that key properties for things

like systemcreationclass are included in the

creation of new instances and that the

values are logical for the CIMOM.

Boolean _completeProperty(CIMInstance& instance,

const CIMName& propertyName,

const String& value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_completeProperty()");

Uint32 pos;

if (!_validateRequiredProperty(instance,

propertyName,

value))

{

if ((pos = instance.findProperty (propertyName)) == PEG_NOT_FOUND)

{

// Add the property. Should be from the class.

PEG_METHOD_EXIT();

return(false);

}

else

{

_setPropertyValue(instance, propertyName, value);

instances.append(currentInstance);

}

PEG_METHOD_EXIT();

return(true);

return instances;

}

Boolean _completeCIMNamespaceKeys(CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_completeCIMNamespaceKeys");

Boolean valid = true;

CIMName propertyName;

if (!_completeProperty(instance,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

// Builds an instance of the class named className. Gets Class defintion and

System::getSystemCreationClassName ()))

// fills in the correct properties from the class. This requires a repository

// getClass request for each instance built. The skeleton is built by

// creating the instance and copying qualifiers and properties from

// the class. Finally the instance is cloned to separate it from the

// original objects.

// NOTE: This is very inefficient for anything larger than a few instances.

// We should separate the get from the createSkeleton.

// @param className CIMName of the class for which the instance is to be built

// @return CIMInstance of this class with properties complete.

// @exception passes on any exceptions received from the repository request.

CIMInstance InteropProvider::buildInstanceSkeleton(

const CIMNamespaceName & nameSpace,

const CIMName& className,

Boolean includeQualifiers,

CIMClass& returnedClass)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceSkeleton()");

// get class with lo = false, qualifier = true classorig = true

returnedClass = repository->getClass(nameSpace,

className, false, true, true);

CIMInstance skeleton = returnedClass.buildInstance(

includeQualifiers, true, CIMPropertyList());

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

PEG_METHOD_EXIT();

valid = false;

return skeleton;

}

if (!_completeProperty(instance,

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

System::getFullyQualifiedHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

valid = false;

}

if (!_completeProperty(instance,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString()))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

valid = false;

}

if (!_completeProperty(instance,

CIMInstance InteropProvider::buildDependencyInstance(

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

const String & antecedentId,

String::EMPTY))

const CIMName & antecedentClass,

{

const String & dependentId,

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

const CIMName & dependentClass,

valid = false;

const CIMClass & dependencyClass)

}

if (!_completeProperty(instance,

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

Array<CIMKeyBinding> dependentKeys;

valid = false;

}

if (!_completeProperty(instance,

dependentKeys.append(CIMKeyBinding(

CIM_NAMESPACE_PROPERTY_NAME,

COMMON_PROPERTY_INSTANCEID,

String::EMPTY))

dependentId,CIMKeyBinding::STRING));

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

valid = false;

}

if (!valid)

return buildDependencyInstanceFromPaths(

{

buildDependencyReference(hostName, antecedentId, antecedentClass),

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

buildDependencyReference(hostName, dependentId, dependentClass),

"Invalid CIM_Namespace Key Property " + propertyName.getString());

dependencyClass);

PEG_METHOD_EXIT();

throw CIMInvalidParameterException(

"Invalid CIM_Namespace key property: " + propertyName.getString());

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, "CIM_Namespace Keys Valid");

PEG_METHOD_EXIT();

return(valid);

}

void InteropProvider::initProvider()

void _validateCIMNamespaceKeys(const CIMInstance& instance)

{

if(providerInitialized)

return;

// Placed METHOD_ENTER trace statement after checking whether the

// provider is initialized because this method will be called for every

// operation through the InteropProvider, and this method is only

// interesting the first time it is successfully run.

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_validateCIMNamespaceKeys");

"InteropProvider::initProvider()");

Boolean valid = true;

CIMName propertyName;

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

System::getSystemCreationClassName ()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

valid = false;

}

if (!_validateRequiredProperty(instance,

AutoMutex lock(interopMut);

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

if(!providerInitialized)

System::getFullyQualifiedHostName ()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

valid = false;

// Initialize the object manager instance for the CIM Server, and

}

// retrieve the object manager's name property. This is retrieved once

// and stored for use in constructing other instances requiring its

// value.

CIMInstance objectManager = getObjectManagerInstance();

objectManager.getProperty(objectManager.findProperty(

OM_PROPERTY_NAME)).getValue().get(objectManagerName);

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

// Determine whether the CIMOM should be gathering statistical data

CIM_OBJECTMANAGER_CLASSNAME.getString()))

// based on the GatherStatisticalData property in the object manager.

Uint32 gatherDataIndex = objectManager.findProperty(

OM_PROPERTY_GATHERSTATISTICALDATA);

if(gatherDataIndex != PEG_NOT_FOUND)

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

CIMConstProperty gatherDataProp =

valid = false;

objectManager.getProperty(gatherDataIndex);

}

if (gatherDataProp.getType() == CIMTYPE_BOOLEAN)

// ATTN: This one still a problem. We have to get the name first

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

CIMValue gatherDataVal = gatherDataProp.getValue();

valid = false;

if (!gatherDataVal.isNull())

}

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

Boolean gatherData;

valid = false;

gatherDataVal.get(gatherData);

}

if (gatherData == true)

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_NAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

StatisticalData* sd = StatisticalData::current();

valid = false;

sd->setCopyGSD(true);

}

if (false)

{

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Invalid CIM_Namespace Key Property " + propertyName.getString());

PEG_METHOD_EXIT();

throw CIMInvalidParameterException(

"Invalid CIM_Namespace key property: " + propertyName.getString());

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, "CIM_Namespace Keys Valid");

PEG_METHOD_EXIT();

}

/** builds complete object path from instance and classinfo by building the full path

with host and namespace names included.

CIMObjectPath InteropProvider::_buildObjectPath(const CIMObjectPath& objectPath,

const CIMName& className,

const CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildObjectPath");

CIMObjectPath rtnObjectPath;

rtnObjectPath = _buildInstancePath(objectPath,className,instance);

rtnObjectPath.setHost(objectPath.getHost());

rtnObjectPath.setNameSpace(objectPath.getNameSpace());

PEG_METHOD_EXIT();

return(rtnObjectPath);

}

/* Given a class and instance build the instance path for a

// Cache this class definition for use later.

the object. This builds all components of the path

profileCapabilitiesClass = repository->getClass(

@param namespace name to build

PEGASUS_NAMESPACENAME_INTEROP,

@return CIMObjectPath containing namespace, class and keybinding

PEGASUS_CLASSNAME_PG_PROVIDERPROFILECAPABILITIES,

components of path

false,

@exceptions - Passes repository exceptions.

true,

false);

CIMObjectPath InteropProvider::_buildInstancePath(const CIMObjectPath& objectPath,

providerClassifications.append(Uint16(5)); // "Instrumentation"

const CIMName& className,

const CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancePath");

// get the class to use in building path

// initialize namespaces.

// Exception if Class does not exist in this namespace

initializeNamespaces();

CIMClass thisClass = _getClass(objectPath, className);

CIMObjectPath ref = instance.buildPath(thisClass);

// Now cache the Registration info used for ElementConformsToProfile

cacheProfileRegistrationInfo();

providerInitialized = true;

}

PEG_METHOD_EXIT();

return(ref);

}

//**************************************************************

// Overloaded functions to get key value with different params

// Initialize the namespaces so that all namespaces with the

//**************************************************************

// CIM_ElementConformsToProfile class also have the

// PG_ElementConformsToProfile class. Needed in order to implement

/* find the name key in the keybindings and return the value.

// the cross-namespace ElementConformsToProfile association in both

Executes exception if the key not found

// directions.

@param object path we will search

@param keyName - Name of the key to find.

void InteropProvider::initializeNamespaces()

@return value of name property

@exceptions CIMInvalidParameterException

String _getKeyValue(const CIMObjectPath& instanceName, const CIMName& keyName)

{

Array<CIMKeyBinding> kbArray = instanceName.getKeyBindings();

// find the correct key binding

for (Uint32 i = 0; i < kbArray.size(); i++)

{

if (kbArray[i].getName() == keyName)

return (kbArray[i].getValue());

}

throw CIMInvalidParameterException("Invalid key property: " + keyName.getString());

}

String _getKeyValue(const CIMInstance& instance, const CIMName& keyName)

{

Uint32 pos;

CIMValue propertyValue;

pos = instance.findProperty(keyName);

if (pos == PEG_NOT_FOUND)

throw CIMPropertyNotFoundException

(NAMESPACE_PROPERTYNAME.getString());

propertyValue = instance.getProperty(pos).getValue();

if (propertyValue.getType() != CIMTYPE_STRING)

throw CIMInvalidParameterException("Invalid type for property: "

+ NAMESPACE_PROPERTYNAME.getString());

String name;

propertyValue.get(name);

return(name);

}

/** Test for valid CIMReferences from an association instance. If there is a role

property, tests if there is a match for this role and the target object.

Confirms that this role and this reference exist in the target instance.

@param target - The target path for the association. Localization assumed.

@param instance - The association class instance we are searching for references

@param role - The role we require. I there is no role, this is String::EMPTY

@return - returns Boolean true if target is found in a reference that is

the same role

Boolean _isInstanceValidReference(const CIMObjectPath& target,

const CIMInstance& instance,

const String& role)

{

// Test if role parameter is valid property.

Uint32 pos;

if (role != String::EMPTY)

{

// Test if property with this role exists.

if ((pos = instance.findProperty(role)) == PEG_NOT_FOUND)

throw CIMException(CIM_ERR_INVALID_PARAMETER);

// Check to be sure this is a reference property

// This test may not be necessary. Combine it into the loop.

if (instance.getProperty(pos).getType() != CIMTYPE_REFERENCE)

throw CIMException(CIM_ERR_INVALID_PARAMETER);

}

//Search instance for all reference properties

for (Uint32 j = 0; j < instance.getPropertyCount() ; j++)

{

const CIMConstProperty p = instance.getProperty(j);

if (p.getType() == CIMTYPE_REFERENCE)

{

// If there is no role or the role is the same as this property name

CIMValue v = p.getValue();

CIMObjectPath path;

v.get(path);

// if no role or role ==this role and target = this path, rtn true.

if ((role == String::EMPTY) || (role == p.getName().getString()))

{

if (target.identical(path))

return(true);

}

return( false );

}

/** Filters the input of instances (which contain path info)

using the assocClassName, assocRole, ResultClassName and

resultRole. Removes any instances from the list that

do not match the filters.

@instances Array<CIMInstance to filter.

* TODO - Shouldn't we remove rather than copy??? faster.

* TODO - why extra check for no resultClass??

Array<CIMObject> _filterReferenceInstances(Array<CIMInstance>& instances,

const CIMObjectPath& targetobjectName,

const CIMName& resultClass,

const String& resultRole)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"_filterReferenceInstances()");

CIMObjectPath targetReference = CIMObjectPath(

String(),

CIMNamespaceName(),

targetobjectName.getClassName(),

targetobjectName.getKeyBindings());

Array<CIMObject> rtnObjects;

for (Uint32 i = 0 ; i < instances.size() ; i++)

{

if (resultClass.isNull() || resultClass.equal(instances[i].getClassName()))

{

// if this association instance has this role in targetReference, true

if (_isInstanceValidReference(targetobjectName, instances[i], resultRole))

{

rtnObjects.append(instances[i]);

}

PEG_METHOD_EXIT();

return( rtnObjects );

}

//***************************************************************************

// The following section is the Instance Operation processors

//***************************************************************************

// createInstance

//***************************************************************************

void InteropProvider::createInstance(

const OperationContext & context,

const CIMObjectPath & instanceReference,

const CIMInstance& myInstance,

ObjectPathResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::createInstance()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s createInstance. InstanceReference= %s",

thisProvider,

(const char *) instanceReference.toString().getCString());

handler.processing();

// operation namespace needed internally to get class.

// KS_TEMP _operationNamespace = instanceReference.getNameSpace();

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(instanceReference.getClassName());

String userName = _validateUserID(context);

CIMObjectPath newInstanceReference;

CIMNamespaceName newNamespaceName;

if (classEnum == PG_NAMESPACE)

{

#ifdef PEGASUS_OS_OS400

MessageLoaderParms mparms(

"ControlProviders.InteropProvider.CREATE_INSTANCE_NOT_ALLOWED",

"Create instance operation not allowed by Interop Provider for class $0.",

PG_NAMESPACE_CLASSNAME.getString());

throw CIMNotSupportedException(mparms);

#else

// Create local instance to complete any keys.

CIMInstance localInstance = myInstance.clone();

_completeCIMNamespaceKeys(localInstance);

// Validate that keys are as required. Does its own exception.

newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME);

newInstanceReference = _buildInstancePath(instanceReference,

PG_NAMESPACE_CLASSNAME, localInstance);

#endif

}

else if ((classEnum == CIM_OBJECTMANAGER) ||

(classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))

{

PEG_METHOD_EXIT();

Array<CIMNamespaceName> namespaceNames = repository->enumerateNameSpaces();

throw CIMNotSupportedException("InteropProvider, Create Not allowed");

// get the PG_ElementConformstoProfile class without the qualifiers

}

// and then add just the required ASSOCIATION qualifier, so that

// resolveclass doesn't fail for the test/EmbeddedInstance/Dynamic

else // Invalid class for the create functions.

// namespace, which uses the CIM25 schema that doesn't include any

// of the new qualifiers added to this class in later versions of

// the CIMSchema.

CIMClass conformsClass = repository->getClass(

PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE,

true,

false);

conformsClass.addQualifier(

CIMQualifier(CIMName("ASSOCIATION"), CIMValue(true)));

CIMClass profileClass = repository->getClass(

PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE,

true,

false);

for(Uint32 i = 0, n = namespaceNames.size(); i < n; ++i)

{

PEGASUS_ASSERT(false);

// Check if the PG_ElementConformsToProfile class is present

}

CIMNamespaceName & currentNamespace = namespaceNames[i];

CIMClass tmpCimClass;

// Create the new namespace

CIMClass tmpPgClass;

CIMClass tmpPgProfileClass;

try

{

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

// Look for these classes in the same try-block since the

"Namespace = " + newNamespaceName.getString() +

// second depends on the first

" to be created.");

tmpCimClass = repository->getClass(

Boolean updatesAllowed = false;

currentNamespace,

Boolean shareable = false;

PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE);

String parent = String::EMPTY;

tmpPgClass = repository->getClass(

currentNamespace,

CIMRepository::NameSpaceAttributes attributes;

PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE);

// optional property. Set false if not found.

// ATTN: Should set to class default.

if (myInstance.findProperty(PG_NAMESPACE_PROPERTY_ISSHAREABLE) != PEG_NOT_FOUND)

{

if (_getPropertyValue(myInstance, PG_NAMESPACE_PROPERTY_ISSHAREABLE, false))

{

attributes.insert("shareable","true");

shareable = true;

}

else

attributes.insert("shareable", "false");

}

else

attributes.insert("shareable", "false");

// Optional property. Set false if not found.

if (myInstance.findProperty(PG_NAMESPACE_PROPERTY_SCHEMAUPDATESALLOWED) != PEG_NOT_FOUND)

{

if (_getPropertyValue(myInstance, PG_NAMESPACE_PROPERTY_SCHEMAUPDATESALLOWED, false))

{

attributes.insert("updatesAllowed","true");

updatesAllowed = true;

}

else

attributes.insert("updatesAllowed", "false");

}

else

attributes.insert("updatesAllowed", "false");

// ATTN: Need to reflect and dependencies between these properties. Right now

// this lets anything happen.

if (myInstance.findProperty(PG_NAMESPACE_PROPERTY_PARENTNAMESPACE) != PEG_NOT_FOUND)

{

String parent = _getPropertyValue(myInstance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, String::EMPTY);

if (parent != String::EMPTY)

attributes.insert("parent",parent);

}

_repository->createNameSpace(newNamespaceName, attributes);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + newNamespaceName.getString() +

" successfully created.");

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

"Create Namespace: Shareable = $0, Updates allowed: $1, Parent: $2",

newNamespaceName.getString(), shareable?

"true" : "false", shareable? "true" : "false", parent );

}

catch(const CIMException&)

{

PEG_METHOD_EXIT();

throw;

}

catch(const Exception&)

{

PEG_METHOD_EXIT();

throw;

}

// begin processing the request

handler.deliver(newInstanceReference);

// complete processing the request

handler.complete();

PEG_METHOD_EXIT();

return;

}

//***************************************************************************

// deleteInstance

//***************************************************************************

void InteropProvider::deleteInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

ResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::deleteInstance");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s deleteInstance. instanceName= %s",

thisProvider,

(const char *) instanceName.toString().getCString());

// KS_TEMP _operationNamespace = instanceName.getNameSpace();

handler.processing();

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(instanceName.getClassName());

String userName = _validateUserID(context);

// Delete the instance since it may be in persistent storage

if ((classEnum == CIM_OBJECTMANAGER))

{

try

{

_repository->deleteInstance(instanceName.getNameSpace(),instanceName);

tmpPgProfileClass = repository->getClass(

}

currentNamespace,

catch(const CIMException&)

PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);

{

PEG_METHOD_EXIT();

throw;

}

else if (classEnum == PG_NAMESPACE)

{

CIMNamespaceName deleteNamespaceName;

#ifdef PEGASUS_OS_OS400

MessageLoaderParms mparms(

"ControlProviders.InteropProvider.DELETE_INSTANCE_NOT_ALLOWED",

"Delete instance operation not allowed by Interop Provider for class $0.",

PG_NAMESPACE_CLASSNAME.getString());

throw CIMNotSupportedException(mparms);

#else

// validate requred keys. Exception out if not valid

_validateCIMNamespaceKeys(instanceName);

deleteNamespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);

#endif

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _enumerateNameSpaces();

if (deleteNamespaceName.equal (ROOTNS))

{

throw CIMNotSupportedException("root namespace cannot be deleted.");

}

_repository->deleteNameSpace(deleteNamespaceName);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + deleteNamespaceName.getString() +

" successfully deleted.");

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

"Interop Provider Delete Namespace: $0",

deleteNamespaceName.getString());

}

else

{

throw CIMNotSupportedException("Delete Not allowed for " + instanceName.getClassName().getString());

}

handler.complete();

PEG_METHOD_EXIT();

return ;

}

/** Local version of getInstance to be used by other functions in the

the provider. Returns a single instance. Note that it always

returns an instance. If none was found, it is unitinialitized.

CIMInstance InteropProvider::localGetInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s getInstance. instanceName= %s , includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)instanceName.toString().getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(instanceName.getClassName());

String userName = _validateUserID(context);

// create reference from host, namespace, class components of

// instance name

CIMObjectPath ref;

ref.setHost(instanceName.getHost());

ref.setClassName(instanceName.getClassName());

ref.setNameSpace(instanceName.getNameSpace());

// Enumerate instances for this class. Returns all instances

// Note that this returns paths setup and instances already

// filtered per the input criteria.

Array<CIMInstance> instances = localEnumerateInstances(

context,

ref,

includeQualifiers,

includeClassOrigin,

propertyList);

// deliver a single instance if found.

CIMInstance rtnInstance;

for (Uint32 i = 0 ; i < instances.size() ; i++)

{

if (instanceName == instances[i].getPath())

{

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s getInstance return instance number %u\npath: %s\n %s\n",thisProvider, i,

(instances[i].getPath().toString().getCString()),

( ( CIMObject) instances[i]).toString().getCString());

rtnInstance = instances[i];

break;

// TODO Add test for duplicates somewhere.

}

PEG_METHOD_EXIT();

return(rtnInstance);

}

//***************************************************************************

// getInstance

//***************************************************************************

void InteropProvider::getInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

InstanceResponseHandler & handler)

{

handler.processing();

CIMInstance myInstance = localGetInstance(

context,

instanceName,

includeQualifiers,

includeClassOrigin,

propertyList);

if (!myInstance.isUninitialized())

handler.deliver(myInstance);

handler.complete();

}

//*****************************************************************************************

// localEnumerateInstances

// EnumerateInstances equivalent to external but returns instances

// Used by other operations to build instances for processing

// Note that this delivers instances as a group rather than incrementally.

// This technique should only be used for small groups of instances.

//****************************************************************************************

Array<CIMInstance> InteropProvider::localEnumerateInstances(

const OperationContext & context,

const CIMObjectPath & ref,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localEnumerateInstances()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s enumerateInstances. referenc= %s , includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)ref.toString().getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(ref.getClassName());

//String userName = _validateUserID(context);

Array<CIMInstance> instances;

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _getInstanceCIMObjectManager(

ref,

includeQualifiers,

includeClassOrigin,

propertyList);

instances.append(instance);

}

else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

{

instances = _buildInstancesPGCIMXMLCommunicationMechanism(

ref);

}

else if (classEnum == CIM_NAMESPACEINMANAGER)

{

instances = _buildInstancesNamespaceInManager(ref);

}

else if (classEnum == CIM_NAMESPACEINMANAGER)

{

instances = _buildInstancesCommMechanismForManager(ref);

}

else if (classEnum == PG_NAMESPACE)

{

instances = _getInstancesCIMNamespace(ref);

}

else

{

PEG_METHOD_EXIT();

throw CIMNotSupportedException

(ref.getClassName().getString() + " not supported by Interop Provider");

}

// Filter and deliver the resulting instances

for (Uint32 i = 0 ; i < instances.size() ; i++)

{

_finishInstance(instances[i],

ref,

includeQualifiers,

includeClassOrigin,

propertyList );

// Debug Trace of the Instances generated

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s enumerateInstances return instance number %u\npath: %s\n %s\n",thisProvider, i,

(instances[i].getPath().toString().getCString()),

( ( CIMObject) instances[i]).toString().getCString());

//****/

}

return(instances);

PEG_METHOD_EXIT();

}

//***************************************************************************

// enumerateInstances - External Operation call

// Delivers instances back through response handler.

//***************************************************************************

void InteropProvider::enumerateInstances(

const OperationContext & context,

const CIMObjectPath & ref,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList,

InstanceResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::enumerateInstances()");

handler.processing();

// Call the internal enumerateInstances to generate instances of defined

// class. This expects the instances to be returned complete including

// complete path.

Array<CIMInstance> instances = localEnumerateInstances(

context,

ref,

includeQualifiers,

includeClassOrigin,

propertyList);

handler.deliver(instances);

handler.complete();

PEG_METHOD_EXIT();

}

void InteropProvider::modifyObjectManagerInstance(const OperationContext & context,

const CIMObjectPath & instanceReference,

const CIMInstance& modifiedIns,

const Boolean includeQualifiers,

const CIMPropertyList& propertyList,

ResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::modifyInstanceManagerInstance");

// the only allowed modification is this one property, statistical data

if (modifiedIns.findProperty(OM_GATHERSTATISTICALDATA) != PEG_NOT_FOUND)

{

// the following is a temporary hack to set the value of the statistics

// gathering function dynamically. We simply get the value from input

// and call the internal method to set it each time this object is

// built.

#ifndef PEGASUS_DISABLE_PERFINST

Boolean statisticsFlag = _getPropertyValue(modifiedIns,

OM_GATHERSTATISTICALDATA, false);

CIMInstance instance;

instance = _getInstanceCIMObjectManager(instanceReference,

true, true, CIMPropertyList());

if (statisticsFlag != _getPropertyValue(instance, OM_GATHERSTATISTICALDATA, false))

{

// set the changed property into the

_setPropertyValue(instance, OM_GATHERSTATISTICALDATA, statisticsFlag);

// Modify the object on disk

try

{

_repository->modifyInstance(instanceReference.getNameSpace(),

instance );

}

catch(const CIMException&)

{

// ATTN: KS generate log error if this not possible

PEG_METHOD_EXIT();

throw;

}

catch(const Exception&)

{

// ATTN: Generate log error.

// Note: if any of the above three classes aren't found,

PEG_METHOD_EXIT();

// an exception will be thrown, which we can ignore since it's

throw;

// an expected case

}

// TBD: Log trace message?

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

}

"Interop Provider Set Statistics gathering in CIM_ObjectManager: $0",

(statisticsFlag? "true" : "false"));

// If the CIM_ElementConformsToProfile class is present, but

StatisticalData* sd = StatisticalData::current();

// the PG_ElementConformsToProfile or PG_RegisteredProfile

sd->setCopyGSD(statisticsFlag);

// class is not, then add it to that namespace.

}

return;

// Note that we don't have to check for the

#endif

// CIM_RegisteredProfile class because if the

// CIM_ElementConformsToProfile class is present, the

}

// CIM_RegisteredProfile class must also be present.

PEG_METHOD_EXIT();

if(!tmpCimClass.isUninitialized())

// ATTN Expand this definition to be more precise since it allows only mod of

{

// one property and that property MUST be in the instance to be modifiable.

if(tmpPgClass.isUninitialized())

throw CIMNotSupportedException

{

(OM_GATHERSTATISTICALDATA.getString() +

CIMClass newclass = conformsClass.clone();

" modify operation not supported by Interop Provider");

CIMObjectPath newPath = conformsClass.getPath();

}

newPath.setNameSpace(currentNamespace);

//***************************************************************************

newclass.setPath(newPath);

//***************************************************************************

repository->createClass(

// modifyInstance

currentNamespace,

//***************************************************************************

newclass);

//***************************************************************************

}

void InteropProvider::modifyInstance(const OperationContext & context,

if(tmpPgProfileClass.isUninitialized())

const CIMObjectPath & instanceReference,

{

const CIMInstance& modifiedIns,

CIMClass newclass = profileClass.clone();

const Boolean includeQualifiers,

CIMObjectPath newPath = profileClass.getPath();

const CIMPropertyList& propertyList,

newPath.setNameSpace(currentNamespace);

ResponseHandler & handler)

newclass.setPath(newPath);

{

repository->createClass(

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

currentNamespace,

"InteropProvider::modifyInstance");

newclass);

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s modifyInstance. instanceReference= %s, includeQualifiers= %s, PropertyList= %s",

thisProvider,

(const char *) instanceReference.toString().getCString(),

(const char *) _showBool(includeQualifiers).getCString(),

(const char *) _showPropertyList(propertyList).getCString());

// ATTN: KS 31 August 2004. This must test for privileged user.

CIMName className = instanceReference.getClassName();

targetClass classEnum = _verifyValidClassInput(className);

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

if (classEnum == CIM_OBJECTMANAGER)

{

modifyObjectManagerInstance(context, instanceReference,modifiedIns,

includeQualifiers, propertyList, handler);

// for the moment allow modification of the statistics property only

}

else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

{

PEG_METHOD_EXIT();

throw CIMNotSupportedException

(className.getString() + " not supported by Interop Provider");

}

else if (classEnum == PG_NAMESPACE)

{

#ifdef PEGASUS_OS_OS400

MessageLoaderParms mparms(

"ControlProviders.InteropProvider.MODIFY_INSTANCE_NOT_ALLOWED",

"Modify instance operation not allowed by Interop Provider for class $0.",

PG_NAMESPACE_CLASSNAME.getString());

throw CIMNotSupportedException(mparms);

#else

// for the moment allow modification of the statistics property only

PEG_METHOD_EXIT();

throw CIMNotSupportedException

(className.getString() + " not supported by Interop Provider");

#endif

}

else

{

PEG_METHOD_EXIT();

throw CIMNotSupportedException(

className.getString() + " not supported by Interop Provider");

}

handler.complete();

PEG_METHOD_EXIT();

return;

}

//***************************************************************************

// enumerateInstanceNames

//***************************************************************************

void InteropProvider::enumerateInstanceNames(

const OperationContext & context,

const CIMObjectPath & classReference,

ObjectPathResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::enumerateInstanceNames()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s enumerateInstanceNames. classReference= %s",

thisProvider,

(const char *) classReference.toString().getCString());

targetClass classEnum =

_verifyValidClassInput(classReference.getClassName());

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

Boolean includeQualifiers = true;

Boolean includeClassOrigin = true;

Array<CIMInstance> instances = localEnumerateInstances(

context,

classReference,

includeQualifiers,

includeClassOrigin,

CIMPropertyList());

for (Uint32 i = 0 ; i < instances.size() ; i++)

{

handler.deliver(instances[i].getPath());

}

handler.complete();

PEG_METHOD_EXIT();

}

//**************************************************************

// Association Functions

//**************************************************************

/** _filterInstancesToTargetPaths - Filters one associaton and returns references that represent the result of

filtering on resultclass and role. Any reference that matches the resultclass and role

and not the target is returned

@param assocInstance - The association instance being processed.

@param targetObjectPath - The original target. This is required since this is the one reference

we don't want.

@resultClass - The resultClass we want to filter on

@resultRole - The result role we want to filter on

@return - returns the CIMObjectPaths that represent the other side of the association that pass

the resultClass and resultRole filters.

// TODO convert the CIMOBjectPath back to const.

Array<CIMObjectPath> _filterAssocInstanceToTargetPaths(const CIMObject& assocInstance,

const CIMObjectPath& targetObjectPath,

const CIMName resultClass,

const String resultRole)

{

Array<CIMObjectPath> returnPaths;

// get all reference properties except for target.

for (Uint32 i = 0 ; i < assocInstance.getPropertyCount() ; i++)

{

CIMConstProperty p = assocInstance.getProperty(i);

if (p.getType() == CIMTYPE_REFERENCE)

{

CIMValue v = p.getValue();

CIMObjectPath path;

v.get(path);

if (!targetObjectPath.identical(path))

{

if (resultClass.isNull() || resultClass == path.getClassName())

{

if (resultRole == String::EMPTY || p.getName().getString() == resultRole)

{

returnPaths.append(path);

}

CDEBUG("_filterAssoc PathsReturned. Count = " << returnPaths.size()

<< "\n" << _showPathArray(returnPaths));

return( returnPaths );

}

//**************************************************************

// Associators Operation Call

//**************************************************************

void InteropProvider::associators(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & associationClass,

const CIMName & resultClass,

const String & role,

const String & resultRole,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ObjectResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::associatorNames()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s associatorNames. objectName= %s , assocClass= %s resultClass= %s role= %s resultRole %includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)associationClass.getString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)resultRole.getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

handler.processing();

// Get references for this object. Note that this

// uses the associationClass as resultClass.

Array<CIMObject> referenceObjects = localReferences(

context,

objectName,

associationClass,

role,

includeQualifiers,

includeClassOrigin,

propertyList);

// Note that Result Class is not always there. We need to account for

// both case where it exists and where it does not exist.

// enumerate all reference instances of the resultClass (i.e. the association)

// create path for resultClass

// for each reference object, get all non-target references

Array<CIMObjectPath> resultPaths;

for (Uint32 i = 0 ; i < referenceObjects.size() ; i++)

{

// get Other references from each reference object.

Array<CIMObjectPath> tempPath =

_filterAssocInstanceToTargetPaths(

referenceObjects[i],

objectName,

resultClass,

resultRole);

for (Uint32 i = 0 ; i < tempPath.size() ; i++)

{

resultPaths.append(tempPath[i]);

}

// get the instance using getInstance.

for (Uint32 i = 0 ; i < resultPaths.size() ; i++)

{

CIMInstance thisInstance = localGetInstance(context, resultPaths[i],

includeQualifiers,

includeClassOrigin, propertyList);

if (!thisInstance.isUninitialized())

{

handler.deliver(thisInstance);

}

handler.processing();

handler.complete();

PEG_METHOD_EXIT();

}

//**************************************************************

// AssociatorNames Operation Function

//**************************************************************

void InteropProvider::associatorNames(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & associationClass,

const CIMName & resultClass,

const String & role,

const String & resultRole,

ObjectPathResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::associatorNames()");

//throw CIMNotSupportedException("AssociationProvider::associatorNames");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s associatorNames. objectName= %s , assocClass= %s resultClass= %s role= %s resultRole",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)associationClass.getString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)resultRole.getCString());

handler.processing();

// Get references for this object. Note that this

// uses the associationClass as resultClass.

Array<CIMObject> referenceObjects = localReferences(

context,

objectName,

associationClass,

role,

false,

CIMPropertyList());

// Note that Result Class is not always there. We need to account for

// both case where it exists and where it does not exist.

// enumerate all reference instances of the resultClass (i.e. the association)

// create path for resultClass

// for each reference object, get all non-target references

Array<CIMObjectPath> resultPaths;

for (Uint32 i = 0 ; i < referenceObjects.size() ; i++)

{

// get Other references from each association object.

Array<CIMObjectPath> tempPath =

_filterAssocInstanceToTargetPaths(referenceObjects[i],

objectName, resultClass, resultRole);

for (Uint32 i = 0 ; i < tempPath.size() ; i++)

{

resultPaths.append(tempPath[i]);

}

handler.deliver(resultPaths);

handler.processing();

handler.complete();

PEG_METHOD_EXIT();

}

Array<CIMObject> InteropProvider::localReferences(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::references()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s references. objectName= %s , resultClass= %s role= %s includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

Array<CIMInstance> rtnInstances;

// operation namespace needed internally to get class.

String userName = _validateUserID(context);

// determine if valid class result class

CIMName targetAssocClassName = resultClass;

targetAssocClass classEnum = _verifyValidAssocClassInput(targetAssocClassName);

// resultClass should NEVER be NULL in Pegasus.

assert(!resultClass.isNull());

// enumerate all reference instances of the resultClass (i.e. the association)

CIMObjectPath classReference(objectName.getHost(), objectName.getNameSpace(),

resultClass);

Array<CIMInstance> assocInstances =

localEnumerateInstances(context,

classReference,

true, true, CIMPropertyList());

Array<CIMObject> rtnObjects = _filterReferenceInstances(

assocInstances, objectName, resultClass, role);

PEG_METHOD_EXIT();

return(rtnObjects);

}

void InteropProvider::references(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ObjectResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::references()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s references. objectName= %s , resultClass= %s role= %s includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

handler.processing();

Array<CIMObject> rtnObjects =

localReferences(context,

objectName,

resultClass,

role,

includeQualifiers,

includeClassOrigin,

propertyList);

handler.deliver(rtnObjects);

handler.complete();

PEG_METHOD_EXIT();

}

void InteropProvider::referenceNames(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

ObjectPathResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::referenceNames()");

CDEBUG("::referenceNames(): object= " << objectName.toString() << " result Class= " << resultClass.getString());

// operation namespace needed internally to get class.

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

Array<CIMObject> rtnObjects =

localReferences(context,

objectName,

resultClass,

role,

true,

CIMPropertyList());

for (Uint32 i = 0 ; i < rtnObjects.size() ; i++ )

{

CIMObjectPath ref = rtnObjects[i].getPath();

CDEBUG("referenceNames returns: " << ref.toString());

handler.deliver(ref);

}

handler.complete();

PEG_METHOD_EXIT();

}

PEGASUS_NAMESPACE_END

// END_OF_FILE

// END OF FILE

Legend:

Removed from v.1.46
changed lines
	Added in v.1.88.2.1

No CVS admin address has been configured