(file) Return to JMPIProviderManager.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI

Diff for /pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIProviderManager.cpp between version 1.28 and 1.59.4.1

version 1.28, 2005/06/02 20:36:40 version 1.59.4.1, 2007/04/04 11:04:51
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author:      Adrian Schuur, schuur@de.ibm.com  
 //  
 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135  
 //              Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for PEP#101  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "JMPIProviderManager.h" #include "JMPIProviderManager.h"
Line 45 
Line 42 
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/MessageLoader.h> //l10n #include <Pegasus/Common/MessageLoader.h> //l10n
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
   #include <Pegasus/Common/FileSystem.h>
   #include <Pegasus/Common/ArrayInternal.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
 #include <Pegasus/ProviderManager2/ProviderName.h> #include <Pegasus/ProviderManager2/ProviderName.h>
 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h> #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h> #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>
 #include <Pegasus/ProviderManager2/ProviderManagerService.h>  
   
 #include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>  
   
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 67 
Line 62 
 #define DDD(x) #define DDD(x)
 #endif #endif
  
   // request->localOnly is replaced with JMPI_LOCALONLY for getInstance () and enumerateInstances ()
   #define JMPI_LOCALONLY false
   
   /* Fix for 4092 */
   // request->includeQualifiers is replaced with JMPI_INCLUDE_QUALIFIERS for getInstance (),
   //    setInstance (), enumerateInstances (), associators (), and references ()
   #define JMPI_INCLUDE_QUALIFIERS false
   
 #include "Convert.h" #include "Convert.h"
  
 void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc) void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc)
 { {
    // cd ${PEGAUSE_HOME}/src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/tests/JMPI_TestPropertyTypes    // cd ${PEGAUSE_HOME}/src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/tests/JMPI_TestPropertyTypes
    // javap -s -p JMPI_TestPropertyTypes    // javap -s -p JMPI_TestPropertyTypes
    static const char *methodNames[][2] = {     static const char *methodNames[][3] = {
       // CIMProvider       // CIMProvider
       //   cimom-2003-11-24/org/snia/wbem/provider/CIMProvider.java       //   cimom-2003-11-24/org/snia/wbem/provider/CIMProvider.java
       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMProvider.java       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMProvider.java
       {"initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"},        {"snia 2.0","initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"},
       {"cleanup","()V"},        {"snia 2.0","cleanup","()V"},
       // InstanceProvider       // InstanceProvider
       //   cimom-2003-11-24/org/snia/wbem/provider/InstanceProvider.java       //   cimom-2003-11-24/org/snia/wbem/provider/InstanceProvider.java
       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMInstanceProvider.java       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMInstanceProvider.java
       {"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},        {"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},
       {"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},        {"pegasus 2.4","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},
       {"getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"},        /* Begin Fix for 4189 */
       {"createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"},        {"pegasus 2.5","enumerateInstances","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
       {"setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},        /* End Fix for 4189 */
       {"deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"},        {"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
       {"execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},        {"pegasus 2.4","enumerateInstanceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;"},
         {"pegasus 2.5","enumerateInstanceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
         {"snia 2.0","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"},
         {"pegasus 2.4","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;"},
         /* Begin Fix for 4238 */
         {"pegasus 2.5","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"},
         /* End Fix for 4238 */
         {"snia 2.0","createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"},
         {"snia 2.0","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},
         {"pegasus 2.4","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V"},
         {"snia 2.0","deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"},
         {"snia 2.0","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
         {"pegasus 2.4","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},
         {"pegasus 2.5","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
       // MethodProvider       // MethodProvider
       //   cimom-2003-11-24/org/snia/wbem/provider/MethodProvider.java       //   cimom-2003-11-24/org/snia/wbem/provider/MethodProvider.java
       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMMethodProvider.java       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMMethodProvider.java
       {"invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},        {"snia 2.0","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},
         {"pegasus 2.4","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;"},
       // PropertyProvider       // PropertyProvider
       //   cimom-2003-11-24/org/snia/wbem/provider/PropertyProvider.java       //   cimom-2003-11-24/org/snia/wbem/provider/PropertyProvider.java
         //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/PropertyProvider.java
         {"snia 2.0","getPropertyValue","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;"},
         {"snia 2.0","setPropertyValue","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V"},
       // AssociatorProvider       // AssociatorProvider
       //   cimom-2003-11-24/org/snia/wbem/provider20/AssociatorProvider.java       //   cimom-2003-11-24/org/snia/wbem/provider20/AssociatorProvider.java
       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMAssociationProvider.java        //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/AssociatorProvider.java
         {"snia 2.0","associators","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
         {"pegasus 2.4","associators","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
         {"snia 2.0","associatorNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
         {"pegasus 2.4","associatorNames","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
         {"snia 2.0","references","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
         {"pegasus 2.4","references","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
         {"snia 2.0","referenceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"},
         {"pegasus 2.4","referenceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"},
       // CIMProviderRouter       // CIMProviderRouter
       //   cimom-2003-11-24/org/snia/wbem/provider20/CIMProviderRouter.java       //   cimom-2003-11-24/org/snia/wbem/provider20/CIMProviderRouter.java
       // EventProvider       // EventProvider
       //   cimom-2003-11-24/org/snia/wbem/provider20/EventProvider.java       //   cimom-2003-11-24/org/snia/wbem/provider20/EventProvider.java
       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/EventProvider.java       //   src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/EventProvider.java
       {"authorizeFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)V"},        {"snia 2.0","activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
       {"mustPoll","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;)Z"},        {"snia 2.0","deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
       {"activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},  
       {"deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},  
       // IndicationHandler       // IndicationHandler
       //   cimom-2003-11-24/org/snia/wbem/provider20/IndicationHandler.java       //   cimom-2003-11-24/org/snia/wbem/provider20/IndicationHandler.java
       // ProviderAdapter       // ProviderAdapter
       //   cimom-2003-11-24/org/snia/wbem/provider20/ProviderAdapter.java       //   cimom-2003-11-24/org/snia/wbem/provider20/ProviderAdapter.java
       // JMPI_TestPropertyTypes       // JMPI_TestPropertyTypes
       {"findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"},        {"JMPI_TestPropertyTypes","findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"},
       {"testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"}        {"JMPI_TestPropertyTypes","testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"}
    };    };
  
    if (!env)    if (!env)
Line 129 
Line 155 
  
    for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++)    for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++)
    {    {
       jmethodID id = env->GetMethodID(jc,methodNames[i][0], methodNames[i][1]);        jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]);
       DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", id = "<<PEGASUS_STD(hex)<<(int)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));        DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", "<<methodNames[i][1]<<", id = "<<PEGASUS_STD(hex)<<(long)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
         env->ExceptionClear();
      }
   
      env->ExceptionClear();
   }
   
   void
   debugIntrospectJavaObject (JNIEnv *env, jobject jInst)
   {
      jclass       jInstClass             = env->GetObjectClass(jInst);
      jclass       jInstSuperClass        = env->GetSuperclass(jInstClass);
      jmethodID    jmidGetDeclaredMethods = env->GetMethodID(jInstClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");
   
      if (!jmidGetDeclaredMethods)
      {
         env->ExceptionClear();
         jmidGetDeclaredMethods = env->GetMethodID(jInstSuperClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");
      }
   
      if (jmidGetDeclaredMethods)
      {
         jobjectArray jarrayDeclaredMethods  = (jobjectArray)env->CallObjectMethod(jInstClass,
                                                                                   jmidGetDeclaredMethods);
   
         if (jarrayDeclaredMethods)
         {
            for (int i = 0, iLen = env->GetArrayLength (jarrayDeclaredMethods); i < iLen; i++)
            {
               JMPIjvm::checkException(env);
   
               jobject jDeclaredMethod      = env->GetObjectArrayElement (jarrayDeclaredMethods, i);
               jclass  jDeclaredMethodClass = env->GetObjectClass (jDeclaredMethod);
   
               JMPIjvm::checkException(env);
   
               jmethodID   jmidToString  = env->GetMethodID (jDeclaredMethodClass, "toString", "()Ljava/lang/String;");
               jstring     jstringResult = (jstring)env->CallObjectMethod (jDeclaredMethod, jmidToString);
               const char *pszResult     = env->GetStringUTFChars(jstringResult, 0);
   
               PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: "<<pszResult<<PEGASUS_STD(endl);
   
               env->ReleaseStringUTFChars (jstringResult, pszResult);
            }
         }
      }
   
   
      env->ExceptionClear();
   }
   
   void
   debugDumpJavaObject (JNIEnv *env, jobject jInst)
   {
      jclass      jInstClass      = env->GetObjectClass(jInst);
      jclass      jInstSuperClass = env->GetSuperclass(jInstClass);
      jmethodID   jmidToString1   = env->GetMethodID(jInstClass,      "toString", "()Ljava/lang/String;");
      jmethodID   jmidToString2   = env->GetMethodID(jInstSuperClass, "toString", "()Ljava/lang/String;");
      if (!jmidToString1 || !jmidToString2)
      {
         env->ExceptionClear();
         return;
      }
      jstring     jstringResult1  = (jstring)env->CallObjectMethod(jInstClass,      jmidToString1);
      jstring     jstringResult2  = (jstring)env->CallObjectMethod(jInstSuperClass, jmidToString2);
      jstring     jstringResult3  = (jstring)env->CallObjectMethod(jInst,           jmidToString1);
      const char *pszResult1      = env->GetStringUTFChars(jstringResult1, 0);
      const char *pszResult2      = env->GetStringUTFChars(jstringResult2, 0);
      const char *pszResult3      = env->GetStringUTFChars(jstringResult3, 0);
   
      jmethodID jmidCInst = env->GetMethodID(env->GetObjectClass(jInst),JMPIjvm::jv.instanceMethodNames[22].methodName, JMPIjvm::jv.instanceMethodNames[22].signature);
   
      PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: jInstClass = "<<jInstClass<<", jInstSuperClass = "<<jInstSuperClass<<", jClassShouldBe = "<<JMPIjvm::jv.classRefs[18]<<", jmidCInst = "<<jmidCInst<<PEGASUS_STD(endl);
      PEGASUS_STD(cout)<<"pszResult1 = "<<pszResult1<<PEGASUS_STD(endl);
      PEGASUS_STD(cout)<<"pszResult2 = "<<pszResult2<<PEGASUS_STD(endl);
      PEGASUS_STD(cout)<<"pszResult3 = "<<pszResult3<<PEGASUS_STD(endl);
   
      env->ReleaseStringUTFChars (jstringResult1, pszResult1);
      env->ReleaseStringUTFChars (jstringResult2, pszResult2);
      env->ReleaseStringUTFChars (jstringResult3, pszResult3);
   
       env->ExceptionClear();       env->ExceptionClear();
    }    }
   
   bool JMPIProviderManager::getInterfaceType (ProviderIdContainer pidc,
                                               String&             interfaceType,
                                               String&             interfaceVersion)
   {
   ///CIMInstance ciProvider       = pidc.getProvider ();
      CIMInstance ciProviderModule = pidc.getModule ();
      Uint32      idx;
      bool        fRet             = true;
   
   ///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProvider       = "<<ciProvider.getPath ().toString ()<<PEGASUS_STD(endl);
   ///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProviderModule = "<<ciProviderModule.getPath ().toString ()<<PEGASUS_STD(endl);
   
      idx = ciProviderModule.findProperty ("InterfaceType");
   
      if (idx != PEG_NOT_FOUND)
      {
         CIMValue itValue;
   
         itValue = ciProviderModule.getProperty (idx).getValue ();
   
         itValue.get (interfaceType);
   
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceType = "<<interfaceType<<PEGASUS_STD(endl));
      }
      else
      {
         fRet = false;
      }
   
      idx = ciProviderModule.findProperty ("InterfaceVersion");
   
      if (idx != PEG_NOT_FOUND)
      {
         CIMValue itValue;
   
         itValue = ciProviderModule.getProperty (idx).getValue ();
   
         itValue.get (interfaceVersion);
   
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceVersion = "<<interfaceVersion<<PEGASUS_STD(endl));
      }
      else
      {
         fRet = false;
      }
   
      return fRet;
   }
   
   bool JMPIProviderManager::interfaceIsUsed (JNIEnv  *env,
                                              jobject  jObject,
                                              String   searchInterfaceName)
   {
      jobjectArray jInterfaces       = 0;
      jsize        jInterfacesLength = 0;
      bool         fFound            = false;
   
      if (!jObject)
      {
         return false;
      }
   
      jInterfaces = (jobjectArray)env->CallObjectMethod (env->GetObjectClass (jObject),
                                                         JMPIjvm::jv.ClassGetInterfaces);
   
      if (!jInterfaces)
      {
         return false;
      }
   
      jInterfacesLength = env->GetArrayLength (jInterfaces);
   
      for (jsize i = 0; !fFound && i < jInterfacesLength; i++)
      {
         jobject jInterface = env->GetObjectArrayElement (jInterfaces, i);
   
         if (jInterface)
         {
            jstring jInterfaceName = (jstring)env->CallObjectMethod (jInterface,
                                                                     JMPIjvm::jv.ClassGetName);
   
            if (jInterfaceName)
            {
               const char *pszInterfaceName = env->GetStringUTFChars (jInterfaceName,
                                                                      0);
               String      interfaceName    = pszInterfaceName;
   
               if (String::equal (interfaceName, searchInterfaceName))
               {
                  fFound = true;
               }
   
               env->ReleaseStringUTFChars (jInterfaceName, pszInterfaceName);
            }
         }
      }
   
      return fFound;
 } }
  
 JMPIProviderManager::IndProvTab    JMPIProviderManager::provTab; JMPIProviderManager::IndProvTab    JMPIProviderManager::provTab;
   Mutex                              JMPIProviderManager::mutexProvTab;
 JMPIProviderManager::IndSelectTab  JMPIProviderManager::selxTab; JMPIProviderManager::IndSelectTab  JMPIProviderManager::selxTab;
   Mutex                              JMPIProviderManager::mutexSelxTab;
 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
   Mutex                              JMPIProviderManager::mutexProvReg;
  
 JMPIProviderManager::JMPIProviderManager(Mode m)  JMPIProviderManager::JMPIProviderManager()
 { {
    mode=m;  
    _subscriptionInitComplete = false;    _subscriptionInitComplete = false;
  
 #ifdef PEGASUS_DEBUG #ifdef PEGASUS_DEBUG
Line 165 
Line 372 
  
     DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl));     DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl));
  
     return provReg.insert(key,name);      Boolean ret = false;
   
       {
          AutoMutex lock (mutexProvReg);
   
          ret = provReg.insert(key,name);
       }
   
       return ret;
 } }
  
 Message * JMPIProviderManager::processMessage(Message * request) throw() Message * JMPIProviderManager::processMessage(Message * request) throw()
Line 303 
Line 518 
 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL) #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
  
  
 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \  #define HandlerIntroBase(type,type1,message,request,response,handler) \
     CIM##type##RequestMessage * request = \     CIM##type##RequestMessage * request = \
         dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \         dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
     PEGASUS_ASSERT(request != 0); \     PEGASUS_ASSERT(request != 0); \
     CIM##type##ResponseMessage * response = \     CIM##type##ResponseMessage * response = \
         new CIM##type##ResponseMessage( \          dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \
         request->messageId, \  
         CIMException(), \  
         request->queueIds.copyAndPop() \  
         respType \  
     PEGASUS_ASSERT(response != 0); \     PEGASUS_ASSERT(response != 0); \
     response->setKey(request->getKey()); \      type1##ResponseHandler handler(request, response, _responseChunkCallback);
     response->setHttpMethod(request->getHttpMethod()); \  
     type1##ResponseHandler handler(request, response);  
   
 #define VOIDINTRO );  
 #define NOVOIDINTRO(type) ,type);  
 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );  
   
   
 #define HandlerIntroVoid(type,message,request,response,handler) \  
      HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)  
   
 #define HandlerIntroMethod(type,message,request,response,handler) \  
      HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)  
  
 #define HandlerIntroInd(type,message,request,response,handler) \ #define HandlerIntroInd(type,message,request,response,handler) \
      HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)       HandlerIntroBase(type,Operation,message,request,response,handler)
  
 #define HandlerIntroInit(type,message,request,response,handler) \ #define HandlerIntroInit(type,message,request,response,handler) \
      HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)       HandlerIntroBase(type,Operation,message,request,response,handler)
  
 #define HandlerIntro(type,message,request,response,handler,respType) \  #define HandlerIntro(type,message,request,response,handler) \
      HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))       HandlerIntroBase(type,type,message,request,response,handler)
  
 #define HandlerCatch(handler) \ #define HandlerCatch(handler) \
     catch(CIMException & e)  \     catch(CIMException & e)  \
Line 350 
Line 548 
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
     } \     } \
     catch(...) \     catch(...) \
     { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \      { PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
                 "Exception: Unknown"); \                 "Exception: Unknown"); \
         handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \         handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
     }     }
Line 374 
Line 572 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest");
  
     HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());      HandlerIntro(GetInstance,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMINSTANCEPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_INSTANCEPROVIDER,
          METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 408 
Line 607 
                                    name.getLogicalName());                                    name.getLogicalName());
         OperationContext context;         OperationContext context;
  
           context.insert(request->operationContext.get(IdentityContainer::NAME));
           context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
           context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
   
         // forward request         // forward request
         JMPIProvider &pr=ph.GetProvider();         JMPIProvider &pr=ph.GetProvider();
  
Line 419 
Line 622 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;  ////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
  
         // public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,          if (interfaceType == "JMPI")
           {
              // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,
         //                                                           org.pegasus.jmpi.CIMClass      cimClass,         //                                                           org.pegasus.jmpi.CIMClass      cimClass,
         //                                                           boolean                        localOnly)         //                                                           boolean                        localOnly)
         //        throws org.pegasus.jmpi.CIMException         //        throws org.pegasus.jmpi.CIMException
Line 435 
Line 655 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_INSTANCEPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
Line 456 
Line 676 
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                     eMethodFound = METHOD_CIMINSTANCEPROVIDER;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              /* Fix for 4238 */
              // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.OperationContext oc
              //                                                  org.pegasus.jmpi.CIMObjectPath    cop,
              //                                                  org.pegasus.jmpi.CIMClass         cimClass,
              //                                                  boolean                           includeQualifiers,
              //                                                  boolean                           includeClassOrigin,
              //                                                  String                            propertyList[])
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "getInstance",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
             }             }
              /* Fix for 4238 */
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_PEGASUS_24:          case METHOD_CIMINSTANCEPROVIDER:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              jobject jop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jopRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,              CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                       request->nameSpace,                                                       request->nameSpace,
                                                       request->instanceName.getClassName(),                                                       request->instanceName.getClassName(),
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
             CIMClass *pcls = new CIMClass (cls);             CIMClass *pcls = new CIMClass (cls);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jObj = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
             jobject jCc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);             jobjectArray jPropertyList = getList(jv,env,request->propertyList);
  
             jobject inst = env->CallObjectMethod((jobject)pr.jProvider,              StatProviderTimeMeasurement providerTime(response);
   
               jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                  id,                                                  id,
                                                  jRef,                                                     jop,
                                                  request->localOnly,                                                     JMPI_LOCALONLY,
                                                  request->includeQualifiers,                                                     JMPI_INCLUDE_QUALIFIERS,
                                                  request->includeClassOrigin,                                                  request->includeClassOrigin,
                                                  jPropertyList,                                                  jPropertyList,
                                                  jCc);                                                     jcimClass);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
  
             if (inst) {              if (jciRet) {
                jint         jCi = env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst);                 jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                 CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
  
                handler.deliver(*ci);                 handler.deliver(*ciRet);
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          /* Fix for 4238 */
           case METHOD_INSTANCEPROVIDER2:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jopRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,              CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                       request->nameSpace,                                                       request->nameSpace,
                                                       request->instanceName.getClassName(),                                                       request->instanceName.getClassName(),
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
             CIMClass *pcls = new CIMClass (cls);             CIMClass *pcls = new CIMClass (cls);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jObj = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
             jobject jCc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobject inst = env->CallObjectMethod((jobject)pr.jProvider,              jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject      jciRet        = env->CallObjectMethod((jobject)pr.jProvider,
                                                  id,                                                  id,
                                                  jRef,                                                                 joc,
                                                  jCc,                                                                 jop,
                                                  true);                                                                 jcimClass,
                                                                  JMPI_INCLUDE_QUALIFIERS,
                                                                  request->includeClassOrigin,
                                                                  jPropertyList);
   
               JMPIjvm::checkException(env);
   
               if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
   
               handler.processing();
   
               if (jciRet) {
                  jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                  CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                  handler.deliver(*ciRet);
               }
               handler.complete();
               break;
           }
           /* Fix for 4238 */
   
           case METHOD_INSTANCEPROVIDER:
           {
               jlong   jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jopRef);
   
               JMPIjvm::checkException(env);
   
               CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->instanceName.getClassName(),
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               // Modified for Bugzilla# 3679
               jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                      id,
                                                      jop,
                                                      jcimClass,
                                                      JMPI_LOCALONLY);
   
               JMPIjvm::checkException(env);
  
             handler.processing();             handler.processing();
  
             if (inst) {              if (jciRet) {
                jint         jCi = env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst);                 jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                 CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
  
                handler.deliver(*ci);                 handler.deliver(*ciRet);
             }             }
             handler.complete();             handler.complete();
             break;             break;
Line 582 
Line 941 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest");
  
     HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>());      HandlerIntro(EnumerateInstances,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMINSTANCEPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_CIMINSTANCEPROVIDER2,
          METHOD_INSTANCEPROVIDER,
          METHOD_INSTANCEPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 611 
Line 972 
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),                                                                           name.getLogicalName(),
                String::EMPTY);                String::EMPTY);
  
         // convert arguments         // convert arguments
Line 633 
Line 994 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
  
         STAT_GETSTARTTIME;              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
  
           if (interfaceType == "JMPI")
           {
         // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,         // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
         //                                                 boolean                        deep,         //                                                 boolean                        deep,
         //                                                 org.pegasus.jmpi.CIMClass      cimClass,         //                                                 org.pegasus.jmpi.CIMClass      cimClass,
Line 650 
Line 1026 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_INSTANCEPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             env->ExceptionClear();             env->ExceptionClear();
  
             // public org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.CIMObjectPath op,                 // public org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.CIMObjectPath cop,
             //                                                           boolean                        localOnly,             //                                                           boolean                        localOnly,
             //                                                           boolean                        includeQualifiers,             //                                                           boolean                        includeQualifiers,
             //                                                           boolean                        includeClassOrigin,             //                                                           boolean                        includeClassOrigin,
             //                                                           java.lang.String[]             propertyList,             //                                                           java.lang.String[]             propertyList,
             //                                                           org.pegasus.jmpi.CIMClass      cc)                 //                                                           org.pegasus.jmpi.CIMClass      cimClass)
             //         throws org.pegasus.jmpi.CIMException             //         throws org.pegasus.jmpi.CIMException
             id = env->GetMethodID((jclass)pr.jProviderClass,             id = env->GetMethodID((jclass)pr.jProviderClass,
                                   "enumerateInstances",                                   "enumerateInstances",
Line 671 
Line 1047 
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                     eMethodFound = METHOD_CIMINSTANCEPROVIDER;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
                  }
             }             }
         }         }
           else if (interfaceType == "JMPIExperimental")
           {
              /* Fix for 4189 */
              // public abstract java.util.Vector enumerateInstances (org.pegasus.jmpi.OperationContext oc
              //                                                      org.pegasus.jmpi.CIMObjectPath    cop,
              //                                                      org.pegasus.jmpi.CIMClass         cimClass,
              //                                                      boolean                           includeQualifiers,
              //                                                      boolean                           includeClassOrigin,
              //                                                      java.lang.String[]                propertyList)
              //         throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "enumerateInstances",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
              }
              /* Fix for 4189 */
  
         JMPIjvm::checkException(env);             if (id == NULL)
              {
                  env->ExceptionClear();
  
         switch (eMethodFound)                 // public abstract org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.OperationContext oc
                  //                                                                    org.pegasus.jmpi.CIMObjectPath    cop,
                  //                                                                    org.pegasus.jmpi.CIMClass         cimClass,
                  //                                                                    boolean                           includeQualifiers,
                  //                                                                    boolean                           includeClassOrigin,
                  //                                                                    java.lang.String[]                propertyList)
                  //         throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "enumerateInstances",
                                        "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
   
                  if (id != NULL)
         {         {
         case METHOD_PEGASUS_24:                     eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));
                  }
              }
           }
   
           if (id == NULL)
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: No method found!"<<PEGASUS_STD(endl));
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);  
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
           }
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,          switch (eMethodFound)
                                                       request->nameSpace,          {
           case METHOD_CIMINSTANCEPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                       request->className,                                                       request->className,
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
             CIMClass *pcls = new CIMClass (cls);             CIMClass *pcls = new CIMClass (cls);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jObj = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jlong   jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcc    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef);
             jobject jCc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);             jobjectArray jPropertyList = getList(jv,env,request->propertyList);
  
               StatProviderTimeMeasurement providerTime(response);
   
             jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,             jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                    id,                                                                    id,
                                                                    jRef,                                                                               jcop,
                                                                    request->localOnly,                                                                               JMPI_LOCALONLY,
                                                                    request->includeQualifiers,                                                                               JMPI_INCLUDE_QUALIFIERS,
                                                                    request->includeClassOrigin,                                                                    request->includeClassOrigin,
                                                                    jPropertyList,                                                                    jPropertyList,
                                                                    jCc);                                                                               jcc);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
             if (jAr) {             if (jAr) {
                 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {                 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jAr,i);                      jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint         jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);                      jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                     CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                      CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       /* Fix for 4237 */
                       CIMClass cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op  = ciRet->getPath();
                       CIMObjectPath        iop = ciRet->buildPath(cls);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*ci);                      handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_CIMINSTANCEPROVIDER2:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,              CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                       request->nameSpace,                                                       request->nameSpace,
                                                       request->className,                                                       request->className,
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
             CIMClass *pcls = new CIMClass (cls);             CIMClass *pcls = new CIMClass (cls);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jObj = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jlong   jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcc    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef);
             jobject jCc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,              jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr           = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                  id,                                                  id,
                                                  jRef,                                                                               joc,
                                                  false,                                                                               jcop,
                                                  jCc,                                                                               jcc,
                                                  true);                                                                               JMPI_INCLUDE_QUALIFIERS,
                                                                                request->includeClassOrigin,
                                                                                jPropertyList);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
  
             handler.processing();  
             if (jVec) {  
                 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
               }
  
                     jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);              handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint         jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);                      jobject jciRet = env->GetObjectArrayElement(jAr,i);
                     CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);  
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*ci);                      jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                 }                      CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
             }  
             handler.complete();  
             break;  
         }  
  
         case METHOD_UNKNOWN:                      /* Fix for 4237 */
                       CIMClass cls;
   
                       try
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl));                         DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
             break;                         AutoMutex lock (pr._cimomMutex);
         }  
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
         }         }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
     }     }
     HandlerCatch(handler);  
  
     if (env) JMPIjvm::detachThread();                      const CIMObjectPath& op  = ciRet->getPath();
                       CIMObjectPath        iop = ciRet->buildPath(cls);
  
     PEG_METHOD_EXIT();                      JMPIjvm::checkException(env);
  
     return(response);                      handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
 } }
  
 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()          /* Fix for 4189 */
           case METHOD_INSTANCEPROVIDER2:
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
  
     HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>());              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
     typedef enum {              JMPIjvm::checkException(env);
        METHOD_UNKNOWN = 0,  
        METHOD_PEGASUS_24,  
        METHOD_SNIA_PROVIDER20,  
     } METHOD_VERSION;  
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;  
     JNIEnv          *env           = NULL;  
  
     try {              CIMClass cls;
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->className.getString());  
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));              try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
  
         // make target object path                 cls = pr._cimom_handle->getClass (context,
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),  
                                                        request->nameSpace,                                                        request->nameSpace,
                                                        request->className);                                                   request->className,
                                                    false,
         // resolve provider name                                                   true,
         ProviderName name = _resolveProviderName(                                                   true,
             request->operationContext.get(ProviderIdContainer::NAME));                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
         // get cached or load new provider module              }
         JMPIProvider::OpProviderHolder ph =              catch (CIMException e)
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());              {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
         // convert arguments                 throw;
         OperationContext context;              }
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
   
         JMPIProvider &pr = ph.GetProvider();  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstanceNames: " + pr.getName());  
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames"<<pr.getName()<<PEGASUS_STD(endl));              CIMClass *pcls = new CIMClass (cls);
  
         JvmVector *jv = 0;              JMPIjvm::checkException(env);
  
         env = JMPIjvm::attachThread(&jv);              jlong   jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcc    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);              JMPIjvm::checkException(env);
  
         STAT_GETSTARTTIME;              jobjectArray jPropertyList = getList(jv,env,request->propertyList);
  
         jmethodID id = NULL;              StatProviderTimeMeasurement providerTime(response);
  
         // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,              jobject      jVec          = env->CallObjectMethod((jobject)pr.jProvider,
         //                                                 boolean                        deep,                                                                 id,
         //                                                 org.pegasus.jmpi.CIMClass      cimClass)                                                                 joc,
         //        throws org.pegasus.jmpi.CIMException                                                                 jcop,
         id = env->GetMethodID((jclass)pr.jProviderClass,                                                                 jcc,
                               "enumInstances",                                                                 JMPI_INCLUDE_QUALIFIERS,
                               "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");                                                                 request->includeClassOrigin,
                                                                  jPropertyList);
  
         if (id != NULL)              JMPIjvm::checkException(env);
         {  
             eMethodFound = METHOD_SNIA_PROVIDER20;  
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));  
         }  
  
         if (id == NULL)              if (joc)
         {         {
             env->ExceptionClear();                 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
             // public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath op,  
             //                                                                 org.pegasus.jmpi.CIMClass      cc)  
             //         throws org.pegasus.jmpi.CIMException  
             id = env->GetMethodID((jclass)pr.jProviderClass,  
                                   "enumerateInstanceNames",  
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");  
  
             if (id != NULL)                 JMPIjvm::checkException(env);
             {  
                 eMethodFound = METHOD_PEGASUS_24;  
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));  
             }  
         }         }
  
               handler.processing();
               if (jVec) {
                   for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)                      jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
         {  
         case METHOD_PEGASUS_24:  
         {  
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);  
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,                      jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                       CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       /* Fix for 4237 */
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                       request->nameSpace,                                                       request->nameSpace,
                                                       request->className,                                                          ciRet->getClassName(),
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
             CIMClass *pcls = new CIMClass (cls);                         DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
             JMPIjvm::checkException(env);                      catch (CIMException e)
                       {
             jObj = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);                         DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
             jobject jCc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);                      }
   
             JMPIjvm::checkException(env);  
   
             jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,  
                                                                    id,  
                                                                    jRef,  
                                                                    jCc);  
   
             JMPIjvm::checkException(env);  
   
             STAT_PMS_PROVIDEREND;  
  
             handler.processing();                      const CIMObjectPath& op  = ciRet->getPath();
             if (jAr) {                      CIMObjectPath        iop = ciRet->buildPath(cls);
                 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {  
                     JMPIjvm::checkException(env);  
  
                     jobject inst=env->GetObjectArrayElement(jAr,i);  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint           jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst);                      iop.setNameSpace(op.getNameSpace());
                     CIMObjectPath *cop  = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);  
  
                     JMPIjvm::checkException(env);                      ciRet->setPath(iop);
                       /* Fix for 4237*/
  
                     handler.deliver(*cop);                      handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
           /* Fix for 4189 */
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_INSTANCEPROVIDER:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,              CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                       request->nameSpace,                                                       request->nameSpace,
                                                       request->className,                                                       request->className,
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
             CIMClass *pcls = new CIMClass (cls);             CIMClass *pcls = new CIMClass (cls);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jObj = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jlong   jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcc    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef);
             jobject jCc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
               StatProviderTimeMeasurement providerTime(response);
   
               // Modified for Bugzilla# 3679
             jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,             jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
                                                  id,                                                  id,
                                                  jRef,                                                   jcop,
                                                  true,                                                   request->deepInheritance,
                                                  jCc);                                                   jcc,
                                                    JMPI_LOCALONLY);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {                 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject inst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);                      jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
   
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint           jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst);                      jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                     CIMObjectPath *cop  = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);                      CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       /* Fix for 4237 */
                       CIMClass cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op  = ciRet->getPath();
                       CIMObjectPath        iop = ciRet->buildPath(cls);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*cop);                      iop.setNameSpace(op.getNameSpace());
   
                       ciRet->setPath(iop);
                       /* Fix for 4237*/
   
                       handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
Line 1014 
Line 1542 
  
         case METHOD_UNKNOWN:         case METHOD_UNKNOWN:
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl));
             break;             break;
         }         }
         }         }
Line 1028 
Line 1556 
     return(response);     return(response);
 } }
  
 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()  Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
  
     HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());      HandlerIntro(EnumerateInstanceNames,message,request,response, handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_SNIA_PROVIDER20,         METHOD_CIMINSTANCEPROVIDER,
          METHOD_CIMINSTANCEPROVIDER2,
          METHOD_INSTANCEPROVIDER,
          METHOD_INSTANCEPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
  
     try {     try {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
             "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0  Name space: $1  Class name: $2",              "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0  Name space: $1  Class name: $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             request->newInstance.getPath().getClassName().getString());              request->className.getString());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->newInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
  
         // make target object path         // make target object path
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
                                                        request->nameSpace,                                                        request->nameSpace,
                                                        request->newInstance.getPath().getClassName(),                                                         request->className);
                                                        request->newInstance.getPath().getKeyBindings());  
  
         // resolve provider name         // resolve provider name
         ProviderName name = _resolveProviderName(         ProviderName name = _resolveProviderName(
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),                                                                           name.getLogicalName());
               String::EMPTY);  
   
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
Line 1072 
Line 1601 
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         // forward request  
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());          PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstanceNames: " + pr.getName());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames: "<<pr.getName()<<PEGASUS_STD(endl));
  
         JvmVector *jv = 0;         JvmVector *jv = 0;
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
         // public abstract org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,          getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
         //                                                                org.pegasus.jmpi.CIMInstance   cimInstance)                            interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
              //                                                 boolean                        deep,
              //                                                 org.pegasus.jmpi.CIMClass      cimClass)
         //        throws org.pegasus.jmpi.CIMException         //        throws org.pegasus.jmpi.CIMException
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "createInstance",                                   "enumInstances",
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");                                   "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath op,
                  //                                                                 org.pegasus.jmpi.CIMClass      cc)
                  //         throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "enumerateInstanceNames",
                                        "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMINSTANCEPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract java.util.Vector enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc
              //                                                          org.pegasus.jmpi.CIMObjectPath    cop,
              //                                                          org.pegasus.jmpi.CIMClass         cimClass)
              //         throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "enumerateInstanceNames",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public abstract org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc
                  //                                                                          org.pegasus.jmpi.CIMObjectPath    cop,
                  //                                                                          org.pegasus.jmpi.CIMClass         cimClass)
                  //         throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "enumerateInstanceNames",
                                        "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                     eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));
                  }
              }
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_SNIA_PROVIDER20:          case METHOD_CIMINSTANCEPROVIDER:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             CIMInstance *cInst = new CIMInstance (request->newInstance);              CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
  
             jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, cInst);              JMPIjvm::checkException(env);
  
             jobject jInst = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj);              jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jRef = "<<jRef<<", jInst = "<<jInst<<PEGASUS_STD(endl));              StatProviderTimeMeasurement providerTime(response);
  
             jobject inst = env->CallObjectMethod((jobject)pr.jProvider,              jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                  id,                                                  id,
                                                  jRef,                                                                     jcop,
                                                  jInst);                                                                     jcimClass);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jcopRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                       CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
  
             if (inst) {                      JMPIjvm::checkException(env);
                 jint           jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst);  
                 CIMObjectPath *cop  = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);  
  
                 handler.deliver(*cop);                      handler.deliver(*copRet);
                   }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_UNKNOWN:          case METHOD_CIMINSTANCEPROVIDER2:
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             break;              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
         }  
         }  
     }  
     HandlerCatch(handler);  
  
     if (env) JMPIjvm::detachThread();              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
     PEG_METHOD_EXIT();              JMPIjvm::checkException(env);
  
     return(response);              CIMClass cls;
 }  
  
 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()              try
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");                 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
     HandlerIntroVoid(ModifyInstance,message,request,response,handler);  
   
     typedef enum {  
        METHOD_UNKNOWN = 0,  
        METHOD_PEGASUS_24,  
        METHOD_SNIA_PROVIDER20,  
     } METHOD_VERSION;  
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;  
     JNIEnv          *env           = NULL;  
   
     try {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->modifiedInstance.getPath().getClassName().getString());  
   
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->modifiedInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));  
  
         // make target object path                 cls = pr._cimom_handle->getClass(context,
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),  
                                                        request->nameSpace,                                                        request->nameSpace,
                                                        request->modifiedInstance.getPath ().getClassName(),                                                  request->className,
                                                        request->modifiedInstance.getPath ().getKeyBindings());                                                  false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
  
         // resolve provider name              CIMClass *pcls = new CIMClass (cls);
         ProviderName name = _resolveProviderName(  
             request->operationContext.get(ProviderIdContainer::NAME));  
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));              JMPIjvm::checkException(env);
  
         // get cached or load new provider module              jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
         JMPIProvider::OpProviderHolder ph =              jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
  
         // convert arguments              JMPIjvm::checkException(env);
         OperationContext context;  
  
         context.insert(request->operationContext.get(IdentityContainer::NAME));              StatProviderTimeMeasurement providerTime(response);
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
  
         // forward request              jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
         JMPIProvider &pr = ph.GetProvider();                                                                     id,
                                                                      joc,
                                                                      jcop,
                                                                      jcimClass);
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());              JMPIjvm::checkException(env);
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: Calling provider "<<PEGASUS_STD(hex)<<(int)&pr<<PEGASUS_STD(dec)<<", name = "<<pr.getName ()<<", module = "<<pr.getModule()<<" modifyInstance: "<<pr.getName()<<PEGASUS_STD(endl));              if (joc)
 ////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));              {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
  
         JvmVector *jv = 0;                 JMPIjvm::checkException(env);
               }
  
         env = JMPIjvm::attachThread(&jv);              handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);                      jobject jcopRet = env->GetObjectArrayElement(jAr,i);
  
         STAT_GETSTARTTIME;                      JMPIjvm::checkException(env);
  
         jmethodID id = NULL;                      jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                       CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
  
         // public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,                      JMPIjvm::checkException(env);
         //                                   org.pegasus.jmpi.CIMInstance   cimInstance)  
         //        org.pegasus.jmpi.throws CIMException  
         id = env->GetMethodID((jclass)pr.jProviderClass,  
                               "setInstance",  
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");  
  
         if (id != NULL)                      handler.deliver(*copRet);
         {                  }
             eMethodFound = METHOD_SNIA_PROVIDER20;              }
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));              handler.complete();
               break;
         }         }
  
         if (id == NULL)          case METHOD_INSTANCEPROVIDER2:
         {         {
             env->ExceptionClear();              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
             // public void setInstance (org.pegasus.jmpi.CIMObjectPath op,  
             //                          org.pegasus.jmpi.CIMInstance   ci,  
             //                          boolean                        includeQualifiers,  
             //                          java.lang.String[]             propertyList)  
             //        throws org.pegasus.jmpi.CIMException  
             id = env->GetMethodID((jclass)pr.jProviderClass,  
                                   "setInstance",  
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");  
  
             if (id != NULL)              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             {              jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
                 eMethodFound = METHOD_PEGASUS_24;  
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));  
             }  
         }  
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)              CIMClass cls;
         {  
         case METHOD_PEGASUS_24:              try
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);                 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);                 AutoMutex lock (pr._cimomMutex);
  
             JMPIjvm::checkException(env);                 cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
  
             CIMInstance *cInst = new CIMInstance (request->modifiedInstance);              CIMClass *pcls = new CIMClass (cls);
  
             jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, cInst);              JMPIjvm::checkException(env);
  
             jobject jInst = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj);              jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);              StatProviderTimeMeasurement providerTime(response);
  
             env->CallVoidMethod((jobject)pr.jProvider,              jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
                                 id,                                 id,
                                 jRef,                                                   joc,
                                 jInst,                                                   jcop,
                                 jPropertyList);                                                   jcimClass);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
             break;  
         }  
   
         case METHOD_SNIA_PROVIDER20:  
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);                 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
               }
  
             CIMInstance *cInst = new CIMInstance (request->modifiedInstance);              handler.processing();
               if (jVec) {
             jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, cInst);                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                       JMPIjvm::checkException(env);
  
             jobject jInst = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj);                      jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             env->CallVoidMethod((jobject)pr.jProvider,                      jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                                 id,                      CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
                                 jRef,  
                                 jInst);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;                      handler.deliver(*copRet);
             break;  
         }  
   
         case METHOD_UNKNOWN:  
         {  
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));  
             break;  
         }         }
         }         }
               handler.complete();
               break;
     }     }
     HandlerCatch(handler);  
  
     if (env) JMPIjvm::detachThread();          case METHOD_INSTANCEPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
     PEG_METHOD_EXIT();              JMPIjvm::checkException(env);
  
     return(response);              CIMClass cls;
 }  
  
 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()              try
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");                 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
     HandlerIntroVoid(DeleteInstance,message,request,response,handler);  
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
   
               JMPIjvm::checkException(env);
   
               jlong   jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
               jobject jcimClass    = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
                                                    id,
                                                    jcop,
                                                    true,
                                                    jcimClass);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
               if (jVec) {
                   for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                       CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
   
                       JMPIjvm::checkException(env);
   
                       handler.deliver(*copRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_UNKNOWN:
           {
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
               break;
           }
           }
       }
       HandlerCatch(handler);
   
       if (env) JMPIjvm::detachThread();
   
       PEG_METHOD_EXIT();
   
       return(response);
   }
   
   Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");
   
       HandlerIntro(CreateInstance,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_SNIA_PROVIDER20,         METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER
          METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
  
     try {     try {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
             "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0  Name space: $1  Class name: $2",              "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0  Name space: $1  Class name: $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             request->instanceName.getClassName().getString());              request->newInstance.getPath().getClassName().getString());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->newInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));
  
         // make target object path         // make target object path
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
                                                        request->nameSpace,                                                        request->nameSpace,
                                                        request->instanceName.getClassName(),                                                         request->newInstance.getPath().getClassName(),
                                                        request->instanceName.getKeyBindings());                                                         request->newInstance.getPath().getKeyBindings());
  
         // resolve provider name         // resolve provider name
         ProviderName name = _resolveProviderName(         ProviderName name = _resolveProviderName(
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
         // convert arguments  
         OperationContext context;  
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
  
         // forward request         // forward request
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());          PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));
  
         JvmVector *jv = 0;         JvmVector *jv = 0;
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
         // public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)          getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,
              //                                                       org.pegasus.jmpi.CIMInstance   cimInstance)
         //        throws org.pegasus.jmpi.CIMException         //        throws org.pegasus.jmpi.CIMException
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "deleteInstance",                                   "createInstance",
                               "(Lorg/pegasus/jmpi/CIMObjectPath;)V");                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.OperationContext oc
              //                                                       org.pegasus.jmpi.CIMObjectPath    cop,
              //                                                       org.pegasus.jmpi.CIMInstance      cimInstance)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "createInstance",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_INSTANCEPROVIDER2;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
              }
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_SNIA_PROVIDER20:          case METHOD_INSTANCEPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               CIMInstance *ci     = new CIMInstance (request->newInstance);
               jlong        jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
               jobject      jci    = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef);
   
               JMPIjvm::checkException(env);
   
               DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                       id,
                                                       jcop,
                                                       jci);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
   
               if (jcopRet) {
                   jlong          jCopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                   CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCopRetRef);
   
                   handler.deliver(*copRet);
               }
               handler.complete();
               break;
           }
   
           case METHOD_INSTANCEPROVIDER2:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               CIMInstance *ci     = new CIMInstance (request->newInstance);
               jlong        jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
               jobject      jci    = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef);
   
               JMPIjvm::checkException(env);
   
               DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                       id,
                                                       joc,
                                                       jcop,
                                                       jci);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             env->CallVoidMethod((jobject)pr.jProvider,id,jRef);              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
               }
   
               handler.processing();
  
             STAT_PMS_PROVIDEREND;              if (jcopRet) {
                   jlong          jCopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                   CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCopRetRef);
   
                   handler.deliver(*copRet);
               }
               handler.complete();
             break;             break;
         }         }
  
         case METHOD_UNKNOWN:         case METHOD_UNKNOWN:
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
             break;             break;
         }         }
         }         }
Line 1439 
Line 2240 
     return(response);     return(response);
 } }
  
 Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()  Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");
  
     HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>());      HandlerIntro(ModifyInstance,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMINSTANCEPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_INSTANCEPROVIDER,
          METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
  
     try {     try {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
             "JMPIProviderManager::handleExecQueryRequest - Host name: $0  Name space: $1  Class name: $2",              "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0  Name space: $1  Class name: $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             request->className.getString());              request->modifiedInstance.getPath().getClassName().getString());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->modifiedInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));
  
         // make target object path         // make target object path
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
                                                        request->nameSpace,                                                        request->nameSpace,
                                                        request->className);                                                         request->modifiedInstance.getPath ().getClassName(),
                                                          request->modifiedInstance.getPath ().getKeyBindings());
  
         // resolve provider name         // resolve provider name
         ProviderName name = _resolveProviderName(         ProviderName name = _resolveProviderName(
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));
         JMPIProvider::OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
  
         context.insert(request->operationContext.get(IdentityContainer::NAME));          // get cached or load new provider module
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
  
         // forward request         // forward request
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());          PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Calling provider execQuery: "<<pr.getName()<<", queryLanguage: "<<request->queryLanguage<<", query: "<<request->query<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: Calling provider "<<PEGASUS_STD(hex)<<(long)&pr<<PEGASUS_STD(dec)<<", name = "<<pr.getName ()<<", module = "<<pr.getModule()<<" modifyInstance: "<<pr.getName()<<PEGASUS_STD(endl));
  
         JvmVector *jv = 0;         JvmVector *jv = 0;
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
  
         STAT_GETSTARTTIME;              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
         // public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,          getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
         //                                             java.lang.String               queryStatement,                            interfaceType,
         //                                             int                            ql,                            interfaceVersion);
         //                                             org.pegasus.jmpi.CIMClass      cimClass)  
         //        throws org.pegasus.jmpi.CIMException          if (interfaceType == "JMPI")
         //          {
              // public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,
              //                                   org.pegasus.jmpi.CIMInstance   cimInstance)
              //        org.pegasus.jmpi.throws CIMException
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "execQuery",                                   "setInstance",
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_INSTANCEPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             env->ExceptionClear();             env->ExceptionClear();
  
             // public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath op,                 // public void setInstance (org.pegasus.jmpi.CIMObjectPath op,
             //                                                          java.lang.String               query,                 //                          org.pegasus.jmpi.CIMInstance   ci,
             //                                                          java.lang.String               ql,                 //                          boolean                        includeQualifiers,
             //                                                          org.pegasus.jmpi.CIMClass      cc)                 //                          java.lang.String[]             propertyList)
             //        throws org.pegasus.jmpi.CIMException             //        throws org.pegasus.jmpi.CIMException
             id = env->GetMethodID((jclass)pr.jProviderClass,             id = env->GetMethodID((jclass)pr.jProviderClass,
                                   "execQuery",                                       "setInstance",
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");                                       "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMINSTANCEPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract void setInstance (org.pegasus.jmpi.OperationContext oc,
              //                                   org.pegasus.jmpi.CIMObjectPath    op,
              //                                   org.pegasus.jmpi.CIMInstance      cimInstance);
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "setInstance",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                 eMethodFound = METHOD_INSTANCEPROVIDER2;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
             }             }
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_PEGASUS_24:          case METHOD_INSTANCEPROVIDER2:
         {         {
             jint    jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
  
             JMPIjvm::checkException(env);              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
             jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());              JMPIjvm::checkException(env);
             jstring jquery         = env->NewStringUTF(request->query.getCString());  
  
             CIMClass cls = pr._cimom_handle->getClass(context,              CIMInstance *ci     = new CIMInstance (request->modifiedInstance);
                                                       request->nameSpace,              jlong        jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
                                                       request->className,              jobject      jci    = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef);
                                                       false,  
                                                       true,  
                                                       true,  
                                                       CIMPropertyList());  
             CIMClass *pcls = new CIMClass (cls);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
             jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);  
  
             JMPIjvm::checkException(env);              StatProviderTimeMeasurement providerTime(response);
  
             jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,              env->CallVoidMethod((jobject)pr.jProvider,
                                                                    id,                                                                    id,
                                   joc,
                                                                    jcop,                                                                    jcop,
                                                                    jquery,                                  jci);
                                                                    jqueryLanguage,  
                                                                    jCc);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
  
             handler.processing();                 JMPIjvm::checkException(env);
               }
               break;
           }
   
           case METHOD_CIMINSTANCEPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               CIMInstance *ci     = new CIMInstance (request->modifiedInstance);
               jlong        jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
               jobject      jci    = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef);
   
               JMPIjvm::checkException(env);
   
               jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod((jobject)pr.jProvider,
                                   id,
                                   jcop,
                                   jci,
                                   JMPI_INCLUDE_QUALIFIERS,
                                   jPropertyList);
   
               JMPIjvm::checkException(env);
               break;
           }
   
           case METHOD_INSTANCEPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               CIMInstance *ci     = new CIMInstance (request->modifiedInstance);
               jlong        jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
               jobject      jci    = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod((jobject)pr.jProvider,
                                   id,
                                   jcop,
                                   jci);
   
               JMPIjvm::checkException(env);
               break;
           }
   
           case METHOD_UNKNOWN:
           {
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
               break;
           }
           }
       }
       HandlerCatch(handler);
   
       if (env) JMPIjvm::detachThread();
   
       PEG_METHOD_EXIT();
   
       return(response);
   }
   
   Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");
   
       HandlerIntro(DeleteInstance,message,request,response,handler);
   
       typedef enum {
          METHOD_UNKNOWN = 0,
          METHOD_INSTANCEPROVIDER,  // same as METHOD_CIMINSTANCEPROVIDER
          METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
       } METHOD_VERSION;
       METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
       JNIEnv          *env           = NULL;
   
       try {
           Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
               "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0  Name space: $1  Class name: $2",
               System::getHostName(),
               request->nameSpace.getString(),
               request->instanceName.getClassName().getString());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl));
   
           // make target object path
           CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
                                                          request->nameSpace,
                                                          request->instanceName.getClassName(),
                                                          request->instanceName.getKeyBindings());
   
           // resolve provider name
           ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
   
           // get cached or load new provider module
           JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
                                                                            name.getLogicalName(),
                                                                            String::EMPTY);
   
           // forward request
           JMPIProvider &pr = ph.GetProvider();
   
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));
   
           JvmVector *jv = 0;
   
           env = JMPIjvm::attachThread(&jv);
   
           if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
   
           jmethodID id               = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "deleteInstance",
                                    "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract void deleteInstance (org.pegasus.jmpi.OperationContext oc,
              //                                      org.pegasus.jmpi.CIMObjectPath    cop)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "deleteInstance",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;)V");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
              }
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
           }
   
           JMPIjvm::checkException(env);
   
           switch (eMethodFound)
           {
           case METHOD_INSTANCEPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod((jobject)pr.jProvider,
                                   id,
                                   joc,
                                   jcop);
   
               JMPIjvm::checkException(env);
   
               if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
               break;
           }
   
           case METHOD_INSTANCEPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod((jobject)pr.jProvider,
                                   id,
                                   jcop);
   
               JMPIjvm::checkException(env);
               break;
           }
   
           case METHOD_UNKNOWN:
           {
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
               break;
           }
           }
       }
       HandlerCatch(handler);
   
       if (env) JMPIjvm::detachThread();
   
       PEG_METHOD_EXIT();
   
       return(response);
   }
   
   Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");
   
       HandlerIntro(ExecQuery,message,request,response,handler);
   
       typedef enum {
          METHOD_UNKNOWN = 0,
          METHOD_CIMINSTANCEPROVIDER,
          METHOD_CIMINSTANCEPROVIDER2,
          METHOD_INSTANCEPROVIDER,
          METHOD_INSTANCEPROVIDER2,
       } METHOD_VERSION;
       METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
       JNIEnv          *env           = NULL;
   
       try {
           Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
               "JMPIProviderManager::handleExecQueryRequest - Host name: $0  Name space: $1  Class name: $2",
               System::getHostName(),
               request->nameSpace.getString(),
               request->className.getString());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
   
           // make target object path
           CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
                                                          request->nameSpace,
                                                          request->className);
   
           // resolve provider name
           ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
   
           // get cached or load new provider module
           JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
                                                                            name.getLogicalName(),
                                                                            String::EMPTY);
   
           // convert arguments
           OperationContext context;
   
           context.insert(request->operationContext.get(IdentityContainer::NAME));
           context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
           context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
   
           // forward request
           JMPIProvider &pr = ph.GetProvider();
   
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Calling provider execQuery: "<<pr.getName()<<", queryLanguage: "<<request->queryLanguage<<", query: "<<request->query<<PEGASUS_STD(endl));
   
           JvmVector *jv = 0;
   
           env = JMPIjvm::attachThread(&jv);
   
           if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
   
           jmethodID id               = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,
              //                                             java.lang.String               queryStatement,
              //                                             int                            ql,
              //                                             org.pegasus.jmpi.CIMClass      cimClass)
              //        throws org.pegasus.jmpi.CIMException
              //
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "execQuery",
                                    "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath cop,
                  //                                                          java.lang.String               query,
                  //                                                          java.lang.String               ql,
                  //                                                          org.pegasus.jmpi.CIMClass      cimClass)
                  //        throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "execQuery",
                                        "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMINSTANCEPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract java.util.Vector execQuery (org.pegasus.jmpi.OperationContext oc,
              //                                             org.pegasus.jmpi.CIMObjectPath    cop,
              //                                             org.pegasus.jmpi.CIMClass         cimClass,
              //                                             java.lang.String                  queryStatement,
              //                                             java.lang.String                  queryLanguage)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "execQuery",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_INSTANCEPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public abstract org.pegasus.jmpi.CIMInstance[] execQuery (org.pegasus.jmpi.OperationContext oc,
                  //                                                           org.pegasus.jmpi.CIMObjectPath    cop,
                  //                                                           org.pegasus.jmpi.CIMClass         cimClass,
                  //                                                           java.lang.String                  queryStatement,
                  //                                                           java.lang.String                  queryLanguage)
                  //        throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "execQuery",
                                        "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));
                  }
              }
           }
   
           if (id == NULL)
           {
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
           }
   
           JMPIjvm::checkException(env);
   
           switch (eMethodFound)
           {
           case METHOD_CIMINSTANCEPROVIDER:
           {
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
   
               JMPIjvm::checkException(env);
   
               jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
               jstring jquery         = env->NewStringUTF(request->query.getCString());
   
               CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
   
               JMPIjvm::checkException(env);
   
               jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
   
               jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                      id,
                                                                      jcop,
                                                                      jquery,
                                                                      jqueryLanguage,
                                                                      jCc);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                       CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       JMPIjvm::checkException(env);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_CIMINSTANCEPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
   
               JMPIjvm::checkException(env);
   
               jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
               jstring jquery         = env->NewStringUTF(request->query.getCString());
   
               CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
   
               JMPIjvm::checkException(env);
   
               jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
   
               jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                      id,
                                                                      joc,
                                                                      jcop,
                                                                      jquery,
                                                                      jqueryLanguage,
                                                                      jCc);
   
               JMPIjvm::checkException(env);
   
               if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
   
               handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                       CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       JMPIjvm::checkException(env);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_INSTANCEPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
   
               JMPIjvm::checkException(env);
   
               jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
               jstring jquery         = env->NewStringUTF(request->query.getCString());
   
               CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
   
               jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
   
               jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider,
                                                     id,
                                                     joc,
                                                     jcop,
                                                     jCc,
                                                     jquery,
                                                     jqueryLanguage);
   
               JMPIjvm::checkException(env);
   
               if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
   
               handler.processing();
               if (jVec)
               {
                   for (int i = 0, m = env->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < m; i++)
                   {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
                       DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: jciRet = "<<jciRet<<PEGASUS_STD(endl));
   
                       JMPIjvm::checkException(env);
   
                       jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                       CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       JMPIjvm::checkException(env);
   
                       handler.deliver(*ciRet);
                   }
               }
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: done!"<<PEGASUS_STD(endl));
               handler.complete();
               break;
           }
   
           case METHOD_INSTANCEPROVIDER:
           {
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
   
               JMPIjvm::checkException(env);
   
               jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
               jstring jquery         = env->NewStringUTF(request->query.getCString());
   
               CIMClass cls;
   
               try
               {
                  DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
                  AutoMutex lock (pr._cimomMutex);
   
                  cls = pr._cimom_handle->getClass(context,
                                                   request->nameSpace,
                                                   request->className,
                                                   false,
                                                   true,
                                                   true,
                                                   CIMPropertyList());
                  DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
               }
               catch (CIMException e)
               {
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                  throw;
               }
   
               CIMClass *pcls = new CIMClass (cls);
   
               JMPIjvm::checkException(env);
   
               jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
   
               jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls);
   
               JMPIjvm::checkException(env);
   
               jlong jql = 0; // @BUG - how to convert?
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider,
                                                     id,
                                                     jcop,
                                                     jquery,
                                                     jql,
                                                     jCc);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
               if (jVec) {
                   for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong        jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                       CIMInstance *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
   
                       JMPIjvm::checkException(env);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_UNKNOWN:
           {
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));
               break;
           }
           }
       }
       HandlerCatch(handler);
   
       if (env) JMPIjvm::detachThread();
   
       PEG_METHOD_EXIT();
   
       return(response);
   }
   
   Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");
   
       HandlerIntro(Associators,message,request,response,handler);
   
       typedef enum {
          METHOD_UNKNOWN = 0,
          METHOD_CIMASSOCIATORPROVIDER,
          METHOD_CIMASSOCIATORPROVIDER2,
          METHOD_ASSOCIATORPROVIDER,
          METHOD_ASSOCIATORPROVIDER2,
       } METHOD_VERSION;
       METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
       JNIEnv          *env           = NULL;
   
       try {
           Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
               "JMPIProviderManager::handleAssociatorsRequest - Host name: $0  Name space: $1  Class name: $2",
               System::getHostName(),
               request->nameSpace.getString(),
               request->objectName.getClassName().getString());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));
   
           // make target object path
           CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
                                                          request->nameSpace,
                                                          request->objectName.getClassName(),
                                                          request->objectName.getKeyBindings());
           CIMObjectPath *assocPath  = new CIMObjectPath (System::getHostName(),
                                                          request->nameSpace,
                                                          request->assocClass.getString());
   
           // resolve provider name
           ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
   
           // get cached or load new provider module
           JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
                                                                            name.getLogicalName(),
                                                                            String::EMPTY);
   
           // convert arguments
           OperationContext context;
   
           context.insert(request->operationContext.get(IdentityContainer::NAME));
           context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
           context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
   
           // forward request
           JMPIProvider &pr = ph.GetProvider();
   
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
   
           JvmVector *jv = 0;
   
           env = JMPIjvm::attachThread(&jv);
   
           if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
   
           jmethodID id               = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
              //                                      org.pegasus.jmpi.CIMObjectPath pathName,
              //                                      java.lang.String               resultClass,
              //                                      java.lang.String               role,
              //                                      java.lang.String               resultRole,
              //                                      boolean                        includeQualifiers,
              //                                      boolean                        includeClassOrigin,
              //                                      java.lang.String[]             propertyList)
              //        throws org.pegasus.jmpi.CIMException
              //
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "associators",
                                    "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_ASSOCIATORPROVIDER;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.CIMObjectPath assocName,
                  //                                                    org.pegasus.jmpi.CIMObjectPath pathName,
                  //                                                    java.lang.String               resultClass,
                  //                                                    java.lang.String               role,
                  //                                                    java.lang.String               resultRole,
                  //                                                    boolean                        includeQualifiers,
                  //                                                    boolean                        includeClassOrigin,
                  //                                                    java.lang.String[]             propertyList)
                  //        throws org.pegasus.jmpi.CIMException
                  //
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "associators",
                                        "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public java.util.Vector associators (org.pegasus.jmpi.OperationContext oc,
              //                                      org.pegasus.jmpi.CIMObjectPath    assocName,
              //                                      org.pegasus.jmpi.CIMObjectPath    pathName,
              //                                      java.lang.String                  resultClass,
              //                                      java.lang.String                  role,
              //                                      java.lang.String                  resultRole,
              //                                      boolean                           includeQualifiers,
              //                                      boolean                           includeClassOrigin,
              //                                      java.lang.String[]                propertyList)
              //        throws org.pegasus.jmpi.CIMException
              //
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "associators",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_ASSOCIATORPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.OperationContext oc,
                  //                                                    org.pegasus.jmpi.CIMObjectPath assocName,
                  //                                                    org.pegasus.jmpi.CIMObjectPath pathName,
                  //                                                    java.lang.String               resultClass,
                  //                                                    java.lang.String               role,
                  //                                                    java.lang.String               resultRole,
                  //                                                    boolean                        includeQualifiers,
                  //                                                    boolean                        includeClassOrigin,
                  //                                                    java.lang.String[]             propertyList)
                  //        throws org.pegasus.jmpi.CIMException
                  //
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "associators",
                                        "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
                  }
              }
           }
   
           if (id == NULL)
           {
               DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
           }
   
           JMPIjvm::checkException(env);
   
           switch (eMethodFound)
           {
           case METHOD_CIMASSOCIATORPROVIDER:
           {
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
   
               jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
               jstring jRole        = env->NewStringUTF(request->role.getCString());
               jstring jResultRole  = env->NewStringUTF(request->resultRole.getCString());
   
               JMPIjvm::checkException(env);
   
               jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName          = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName           = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass        = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole         = "<<request->resultRole<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     jAssociationName,
                                                                     jPathName,
                                                                     jResultClass,
                                                                     jRole,
                                                                     jResultRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                     jPropertyList);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
             if (jAr) {             if (jAr) {
                 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {                 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject inst=env->GetObjectArrayElement(jAr,i);                      jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
   
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint         jCi = env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst);                      CIMInstance         *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                     CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                      CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op    = ciRet->getPath();
                       CIMObjectPath        iop   = ciRet->buildPath(cls);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*ci);                      iop.setNameSpace(op.getNameSpace());
                       ciRet->setPath(iop);
   
                       handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_CIMASSOCIATORPROVIDER2:
         {         {
             jint    jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jstring jquery         = env->NewStringUTF(request->query.getCString());              jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
  
             CIMClass cls = pr._cimom_handle->getClass(context,              jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
               jstring jRole        = env->NewStringUTF(request->role.getCString());
               jstring jResultRole  = env->NewStringUTF(request->resultRole.getCString());
   
               JMPIjvm::checkException(env);
   
               jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName          = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName           = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass        = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole         = "<<request->resultRole<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     joc,
                                                                     jAssociationName,
                                                                     jPathName,
                                                                     jResultClass,
                                                                     jRole,
                                                                     jResultRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                     jPropertyList);
   
               JMPIjvm::checkException(env);
   
               if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
   
               handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
   
                       JMPIjvm::checkException(env);
   
                       CIMInstance         *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                       request->nameSpace,                                                       request->nameSpace,
                                                       request->className,                                                          ciRet->getClassName(),
                                                       false,                                                       false,
                                                       true,                                                       true,
                                                       true,                                                       true,
                                                       CIMPropertyList());                                                       CIMPropertyList());
             CIMClass *pcls = new CIMClass (cls);                         DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op    = ciRet->getPath();
                       CIMObjectPath        iop   = ciRet->buildPath(cls);
   
                       JMPIjvm::checkException(env);
   
                       iop.setNameSpace(op.getNameSpace());
                       ciRet->setPath(iop);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_ASSOCIATORPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
   
               jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
               jstring jRole        = env->NewStringUTF(request->role.getCString());
               jstring jResultRole  = env->NewStringUTF(request->resultRole.getCString());
   
               JMPIjvm::checkException(env);
   
               jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName          = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName           = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass        = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole         = "<<request->resultRole<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     joc,
                                                                     jAssociationName,
                                                                     jPathName,
                                                                     jResultClass,
                                                                     jRole,
                                                                     jResultRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                     jPropertyList);
   
               JMPIjvm::checkException(env);
   
               if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
   
               handler.processing();
               if (jVec) {
                   for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
   
                       JMPIjvm::checkException(env);
   
                       CIMInstance         *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op    = ciRet->getPath();
                       CIMObjectPath        iop   = ciRet->buildPath(cls);
   
                       JMPIjvm::checkException(env);
   
                       iop.setNameSpace(op.getNameSpace());
                       ciRet->setPath(iop);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_ASSOCIATORPROVIDER:
           {
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
  
             jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);              jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
               jstring jRole        = env->NewStringUTF(request->role.getCString());
               jstring jResultRole  = env->NewStringUTF(request->resultRole.getCString());
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint jql = 0; // @BUG - how to convert?              jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName          = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName           = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass        = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole         = "<<request->resultRole<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
  
             jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,             jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,                                                                     id,
                                                                     jcop,                                                                    jAssociationName,
                                                                     jquery,                                                                    jPathName,
                                                                     jql,                                                                    jResultClass,
                                                                     jCc);                                                                    jRole,
                                                                     jResultRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                     jPropertyList);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject inst=env->GetObjectArrayElement(jVec,i);                      jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
   
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint         jCi = env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst);                      jlong                jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                     CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                      CIMInstance         *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op        = ciRet->getPath();
                       CIMObjectPath        iop       = ciRet->buildPath(cls);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*ci);                      iop.setNameSpace(op.getNameSpace());
                       ciRet->setPath(iop);
   
                       handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
Line 1664 
Line 3761 
  
         case METHOD_UNKNOWN:         case METHOD_UNKNOWN:
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
             break;             break;
         }         }
         }         }
Line 1678 
Line 3775 
     return(response);     return(response);
 } }
  
 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()  Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");
  
     HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());      HandlerIntro(AssociatorNames,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMASSOCIATORPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_CIMASSOCIATORPROVIDER2,
          METHOD_ASSOCIATORPROVIDER,
          METHOD_ASSOCIATORPROVIDER2
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
  
     try {     try {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
             "JMPIProviderManager::handleAssociatorsRequest - Host name: $0  Name space: $1  Class name: $2",              "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0  Name space: $1  Class name: $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             request->objectName.getClassName().getString());             request->objectName.getClassName().getString());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", assocName = "<<request->assocClass.getString()<<PEGASUS_STD(endl));
  
         // make target object path         // make target object path
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
Line 1715 
Line 3814 
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
         // convert arguments  
         OperationContext context;  
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
  
         // forward request         // forward request
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());          PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
  
         JvmVector *jv = 0;         JvmVector *jv = 0;
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
         // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,          getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
         //                                               org.pegasus.jmpi.CIMObjectPath pathName,         //                                               org.pegasus.jmpi.CIMObjectPath pathName,
         //                                               java.lang.String               resultClass,         //                                               java.lang.String               resultClass,
         //                                               java.lang.String               role,         //                                               java.lang.String               role,
         //                                               java.lang.String               resultRole,             //                                          java.lang.String               resultRole)
         //                                               boolean                        includeQualifiers,  
         //                                               boolean                        includeClassOrigin,  
         //                                               java.lang.String[]             propertyList)  
         //        throws org.pegasus.jmpi.CIMException         //        throws org.pegasus.jmpi.CIMException
         //  
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "associators",                                   "associatorNames",
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
 //@BUG was:                   "(Lorg/pegasus/jmpi/CIMObjectPath;                                Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"  
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_ASSOCIATORPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             env->ExceptionClear();             env->ExceptionClear();
  
             // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,                 // public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
                  //                                                          org.pegasus.jmpi.CIMObjectPath pathName,
             //                                               java.lang.String               resultClass,             //                                               java.lang.String               resultClass,
             //                                               java.lang.String               role,             //                                               java.lang.String               role,
             //                                               java.lang.String               resultRole,                 //                                                          java.lang.String               resultRole)
             //                                               boolean                        includeQualifiers,  
             //                                               boolean                        includeClassOrigin,  
             //                                               java.lang.String[]             propertyList)  
             //        throws org.pegasus.jmpi.CIMException             //        throws org.pegasus.jmpi.CIMException
             //  
             id = env->GetMethodID((jclass)pr.jProviderClass,             id = env->GetMethodID((jclass)pr.jProviderClass,
                                   "associators",                                       "associatorNames",
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");                                       "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
 //@BUG was:                       "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"  
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public java.util.Vector associatorNames (org.pegasus.jmpi.OperationContext oc,
              //                                          org.pegasus.jmpi.CIMObjectPath    assocName,
              //                                          org.pegasus.jmpi.CIMObjectPath    pathName,
              //                                          java.lang.String                  resultClass,
              //                                          java.lang.String                  role,
              //                                          java.lang.String                  resultRole)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "associatorNames",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_ASSOCIATORPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.OperationContext oc,
                  //                                                          org.pegasus.jmpi.CIMObjectPath    assocName,
                  //                                                          org.pegasus.jmpi.CIMObjectPath    pathName,
                  //                                                          java.lang.String                  resultClass,
                  //                                                          java.lang.String                  role,
                  //                                                          java.lang.String                  resultRole)
                  //        throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "associatorNames",
                                        "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                     eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
                  }
             }             }
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_PEGASUS_24:          case METHOD_CIMASSOCIATORPROVIDER:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 1810 
Line 3962 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);  #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName   = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role        = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole  = "<<request->resultRole<<PEGASUS_STD(endl));
   #endif
  
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,              StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                     jPathName,
                                                                   jResultClass,                                                                   jResultClass,
                                                                   jRole,                                                                   jRole,
                                                                   jResultRole,                                                                    jResultRole);
                                                                   false,  
                                                                   false,  
                                                                   jPropertyList);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
             if (jVec) {              if (jAr) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                     JMPIjvm::checkException(env);  
   
                     jobject jInst=env->GetObjectArrayElement(jVec,i);  
   
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);                      jobject jcopRet = env->GetObjectArrayElement(jAr,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     CIMInstance         *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                      jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                     CIMClass             cls = pr._cimom_handle->getClass(context,request->nameSpace,ci->getClassName(),false,true,true,CIMPropertyList());                      CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
                     const CIMObjectPath& op  = ci->getPath();  
                     CIMObjectPath        iop = ci->buildPath(cls);  
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     iop.setNameSpace(op.getNameSpace());                      handler.deliver(*copRet);
                     ci->setPath(iop);  
   
                     handler.deliver(*ci);  
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_CIMASSOCIATORPROVIDER2:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint    jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);              jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 1874 
Line 4022 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);  #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName   = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role        = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole  = "<<request->resultRole<<PEGASUS_STD(endl));
   #endif
  
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,              StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                  id,                                                                  id,
                                                                     joc,
                                                                  jAssociationName,                                                                  jAssociationName,
                                                                  jPathName,                                                                  jPathName,
                                                                  jResultClass,                                                                  jResultClass,
                                                                  jRole,                                                                  jRole,
                                                                  jResultRole,                                                                    jResultRole);
                                                                  false,  
                                                                  false,  
                                                                  jPropertyList);  
   
             JMPIjvm::checkException(env);  
   
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();  
             if (jVec) {  
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {  
                     JMPIjvm::checkException(env);  
   
                     jobject jInst=env->GetObjectArrayElement(jVec,i);  
   
                     JMPIjvm::checkException(env);  
   
                     jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);  
   
                     JMPIjvm::checkException(env);  
   
                     CIMInstance         *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);  
                     CIMClass             cls = pr._cimom_handle->getClass(context,request->nameSpace,ci->getClassName(),false,true,true,CIMPropertyList());  
                     const CIMObjectPath& op  = ci->getPath();  
                     CIMObjectPath        iop = ci->buildPath(cls);  
   
                     JMPIjvm::checkException(env);  
   
                     iop.setNameSpace(op.getNameSpace());  
                     ci->setPath(iop);  
   
                     handler.deliver(*ci);  
                 }  
             }  
             handler.complete();  
             break;  
         }  
   
         case METHOD_UNKNOWN:  
         {  
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));  
             break;  
         }  
         }  
     }  
     HandlerCatch(handler);  
   
     if (env) JMPIjvm::detachThread();  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");  
   
     HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());  
   
     typedef enum {  
        METHOD_UNKNOWN = 0,  
        METHOD_PEGASUS_24,  
        METHOD_SNIA_PROVIDER20  
     } METHOD_VERSION;  
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;  
     JNIEnv          *env           = NULL;  
   
     try {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->objectName.getClassName().getString());  
   
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));  
   
         // make target object path  
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),  
                                                        request->nameSpace,  
                                                        request->objectName.getClassName(),  
                                                        request->objectName.getKeyBindings());  
         CIMObjectPath *assocPath  = new CIMObjectPath (System::getHostName(),  
                                                        request->nameSpace,  
                                                        request->assocClass.getString());  
   
         // resolve provider name  
         ProviderName name = _resolveProviderName(  
             request->operationContext.get(ProviderIdContainer::NAME));  
   
         // get cached or load new provider module  
         JMPIProvider::OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
   
         // forward request  
         JMPIProvider &pr = ph.GetProvider();  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());  
   
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));  
   
         JvmVector *jv = 0;  
  
         env = JMPIjvm::attachThread(&jv);              JMPIjvm::checkException(env);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
  
         STAT_GETSTARTTIME;                 JMPIjvm::checkException(env);
               }
  
         jmethodID id = NULL;              handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
  
         // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,                      jobject jcopRet = env->GetObjectArrayElement(jAr,i);
         //                                                   org.pegasus.jmpi.CIMObjectPath pathName,  
         //                                                   java.lang.String               resultClass,  
         //                                                   java.lang.String               role,  
         //                                                   java.lang.String               resultRole)  
         //        throws org.pegasus.jmpi.CIMException  
         id = env->GetMethodID((jclass)pr.jProviderClass,  
                               "associatorNames",  
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");  
 //@BUG was:                   "(Lorg/pegasus/jmpi/CIMObjectPath;                                Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"  
  
         if (id != NULL)                      JMPIjvm::checkException(env);
         {  
             eMethodFound = METHOD_SNIA_PROVIDER20;  
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));  
         }  
  
         if (id == NULL)                      jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
         {                      CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
             env->ExceptionClear();  
  
             // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,                      JMPIjvm::checkException(env);
             //                                                   java.lang.String               resultClass,  
             //                                                   java.lang.String               role,  
             //                                                   java.lang.String               resultRole)  
             //        throws org.pegasus.jmpi.CIMException  
             id = env->GetMethodID((jclass)pr.jProviderClass,  
                                   "associatorNames",  
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");  
 //@BUG was:                       "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"  
  
             if (id != NULL)                      handler.deliver(*copRet);
             {                  }
                 eMethodFound = METHOD_PEGASUS_24;  
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));  
             }             }
               handler.complete();
               break;
         }         }
  
         if (id == NULL)          case METHOD_ASSOCIATORPROVIDER:
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));              jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
         }              jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
         {              jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
         case METHOD_PEGASUS_24:  
         {  
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);  
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);  
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2061 
Line 4088 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName   = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName    = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role        = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole  = "<<request->resultRole<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                     jPathName,
                                                                   jResultClass,                                                                   jResultClass,
                                                                   jRole,                                                                   jRole,
                                                                   jResultRole);                                                                   jResultRole);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;  
   
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jVec,i);                      jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint           jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);                      jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                     CIMObjectPath *cop  = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);                      CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*cop);                      handler.deliver(*copRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_ASSOCIATORPROVIDER2:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint    jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);              jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2111 
Line 4150 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName   = "<<assocPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName    = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role        = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole  = "<<request->resultRole<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                     joc,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                   jPathNameRef,                                                                    jPathName,
                                                                   jResultClass,                                                                   jResultClass,
                                                                   jRole,                                                                   jRole,
                                                                   jResultRole);                                                                   jResultRole);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jVec,i);                      jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint           jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);                      jlong          jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
                     CIMObjectPath *cop  = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);                      CIMObjectPath *copRet     = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     handler.deliver(*cop);                      handler.deliver(*copRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
Line 2164 
Line 4219 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");
  
     HandlerIntro(References,message,request,response,handler,Array<CIMObject>());      HandlerIntro(References,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMASSOCIATORPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_CIMASSOCIATORPROVIDER2,
          METHOD_ASSOCIATORPROVIDER,
          METHOD_ASSOCIATORPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 2181 
Line 4238 
             request->nameSpace.getString(),             request->nameSpace.getString(),
             request->objectName.getClassName().getString());             request->objectName.getClassName().getString());
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", result = "<<request->resultClass.getString()<<PEGASUS_STD(endl));
  
         // make target object path         // make target object path
         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),         CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
Line 2197 
Line 4254 
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
Line 2218 
Line 4276 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
  
         STAT_GETSTARTTIME;              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
  
         // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,          if (interfaceType == "JMPI")
           {
              // public java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
         //                                              org.pegasus.jmpi.CIMObjectPath pathName,         //                                              org.pegasus.jmpi.CIMObjectPath pathName,
         //                                              java.lang.String               role,         //                                              java.lang.String               role,
         //                                              boolean                        includeQualifiers,         //                                              boolean                        includeQualifiers,
Line 2234 
Line 4307 
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "references",                               "references",
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
 //@BUG was:                   "(Lorg/pegasus/jmpi/CIMObjectPath;                                Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"  
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_ASSOCIATORPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMInstance[] references (org.pegasus.jmpi.CIMObjectPath assocName,
                  //                                                   org.pegasus.jmpi.CIMObjectPath pathName,
                  //                                                   java.lang.String               role,
                  //                                                   boolean                        includeQualifiers,
                  //                                                   boolean                        includeClassOrigin,
                  //                                                   java.lang.String[]             propertyList)
                  //        throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "references",
                                        "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public java.util.Vector references (org.pegasus.jmpi.OperationContext oc,
              //                                     org.pegasus.jmpi.CIMObjectPath    assocName,
              //                                     org.pegasus.jmpi.CIMObjectPath    pathName,
              //                                     java.lang.String                  role,
              //                                     boolean                           includeQualifiers,
              //                                     boolean                           includeClassOrigin,
              //                                     java.lang.String[]                propertyList)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "references",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_ASSOCIATORPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             env->ExceptionClear();             env->ExceptionClear();
  
             // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,                 // public org.pegasus.jmpi.CIMInstance[] references (org.pegasus.jmpi.OperationContext oc,
                  //                                                   org.pegasus.jmpi.CIMObjectPath    assocName,
                  //                                                   org.pegasus.jmpi.CIMObjectPath    pathName,
             //                                              java.lang.String               role,             //                                              java.lang.String               role,
             //                                              boolean                        includeQualifiers,             //                                              boolean                        includeQualifiers,
             //                                              boolean                        includeClassOrigin,             //                                              boolean                        includeClassOrigin,
Line 2254 
Line 4370 
             //        throws org.pegasus.jmpi.CIMException             //        throws org.pegasus.jmpi.CIMException
             id = env->GetMethodID((jclass)pr.jProviderClass,             id = env->GetMethodID((jclass)pr.jProviderClass,
                                   "references",                                   "references",
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");                                       "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
 //@BUG was:                       "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"  
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                     eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
                  }
             }             }
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl));             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_PEGASUS_24:          case METHOD_CIMASSOCIATORPROVIDER:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2286 
Line 4413 
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);             jobjectArray jPropertyList = getList(jv,env,request->propertyList);
  
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,  #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName          = "<<resultPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                     jPathName,
                                                                   jRole,                                                                   jRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                     jPropertyList);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
   
                       JMPIjvm::checkException(env);
   
                       CIMInstance         *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                                   false,                                                                   false,
                                                                   false,                                                          true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op    = ciRet->getPath();
                       CIMObjectPath        iop   = ciRet->buildPath(cls);
   
                       JMPIjvm::checkException(env);
   
                       iop.setNameSpace(op.getNameSpace());
                       ciRet->setPath(iop);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_CIMASSOCIATORPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
   
               jstring jRole = env->NewStringUTF(request->role.getCString());
   
               JMPIjvm::checkException(env);
   
               jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName          = "<<resultPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     joc,
                                                                     jAssociationName,
                                                                     jPathName,
                                                                     jRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                   jPropertyList);                                                                   jPropertyList);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
             if (jVec) {              if (jAr) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jciRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
   
                       JMPIjvm::checkException(env);
   
                       CIMInstance         *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                           request->nameSpace,
                                                           ciRet->getClassName(),
                                                           false,
                                                           true,
                                                           true,
                                                           CIMPropertyList());
                          DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                       }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op    = ciRet->getPath();
                       CIMObjectPath        iop   = ciRet->buildPath(cls);
   
                       JMPIjvm::checkException(env);
   
                       iop.setNameSpace(op.getNameSpace());
                       ciRet->setPath(iop);
   
                       handler.deliver(*ciRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_ASSOCIATORPROVIDER:
           {
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
   
               jstring jRole = env->NewStringUTF(request->role.getCString());
   
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jVec,i);              jobjectArray jPropertyList = getList(jv,env,request->propertyList);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName          = "<<resultPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName           = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     jAssociationName,
                                                                     jPathName,
                                                                     jRole,
                                                                     JMPI_INCLUDE_QUALIFIERS,
                                                                     request->includeClassOrigin,
                                                                     jPropertyList);
   
               JMPIjvm::checkException(env);
  
               handler.processing();
               if (jVec) {
                   for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);                      jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     CIMInstance         *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                      jlong                jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                     CIMClass             cls = pr._cimom_handle->getClass(context,                      CIMInstance         *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
   
                       try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
   
                          cls = pr._cimom_handle->getClass(context,
                                                                           request->nameSpace,                                                                           request->nameSpace,
                                                                           ci->getClassName(),                                                          ciRet->getClassName(),
                                                                           false,                                                                           false,
                                                                           true,                                                                           true,
                                                                           true,                                                                           true,
                                                                           CIMPropertyList());                                                                           CIMPropertyList());
                     const CIMObjectPath& op  = ci->getPath();                         DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                     CIMObjectPath        iop = ci->buildPath(cls);                      }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op        = ciRet->getPath();
                       CIMObjectPath        iop       = ciRet->buildPath(cls);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     iop.setNameSpace(op.getNameSpace());                     iop.setNameSpace(op.getNameSpace());
                     ci->setPath(iop);                      ciRet->setPath(iop);
  
                     handler.deliver(*ci);                      handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_ASSOCIATORPROVIDER2:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint    jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);              jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2352 
Line 4692 
  
             jobjectArray jPropertyList = getList(jv,env,request->propertyList);             jobjectArray jPropertyList = getList(jv,env,request->propertyList);
  
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName          = "<<resultPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName           = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers  = "<<false<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                     joc,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                   jPathName,                                                                   jPathName,
                                                                   jRole,                                                                   jRole,
                                                                   false,                                                                    JMPI_INCLUDE_QUALIFIERS,
                                                                   false,                                                                    request->includeClassOrigin,
                                                                   jPropertyList);                                                                   jPropertyList);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jVec,i);                      jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);                      jlong                jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
                       CIMInstance         *ciRet     = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef);
                       CIMClass             cls;
  
                     JMPIjvm::checkException(env);                      try
                       {
                          DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                          AutoMutex lock (pr._cimomMutex);
  
                     CIMInstance         *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);                         cls = pr._cimom_handle->getClass(context,
                     CIMClass             cls = pr._cimom_handle->getClass(context,  
                                                                           request->nameSpace,                                                                           request->nameSpace,
                                                                           ci->getClassName(),                                                          ciRet->getClassName(),
                                                                           false,                                                                           false,
                                                                           true,                                                                           true,
                                                                           true,                                                                           true,
                                                                           CIMPropertyList());                                                                           CIMPropertyList());
                     const CIMObjectPath& op  = ci->getPath();                         DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
                     CIMObjectPath        iop = ci->buildPath(cls);                      }
                       catch (CIMException e)
                       {
                          DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
                          throw;
                       }
   
                       const CIMObjectPath& op        = ciRet->getPath();
                       CIMObjectPath        iop       = ciRet->buildPath(cls);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     iop.setNameSpace(op.getNameSpace());                     iop.setNameSpace(op.getNameSpace());
                     ci->setPath(iop);                      ciRet->setPath(iop);
  
                     handler.deliver(*ci);                      handler.deliver(*ciRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
Line 2421 
Line 4789 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");
  
     HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>());      HandlerIntro(ReferenceNames,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMASSOCIATORPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_CIMASSOCIATORPROVIDER2,
          METHOD_ASSOCIATORPROVIDER,
          METHOD_ASSOCIATORPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 2454 
Line 4824 
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
         // convert arguments  
         OperationContext context;  
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
  
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
  
Line 2474 
Line 4838 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
         // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,          getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
              // public java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
         //                                                  org.pegasus.jmpi.CIMObjectPath pathName,         //                                                  org.pegasus.jmpi.CIMObjectPath pathName,
         //                                                  java.lang.String               role)         //                                                  java.lang.String               role)
         //        throws org.pegasus.jmpi.CIMException         //        throws org.pegasus.jmpi.CIMException
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "referenceNames",                               "referenceNames",
                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");                               "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
 //@BUG was:                   "(Lorg/pegasus/jmpi/CIMObjectPath;                                Ljava/lang/String;)Ljava/util/Vector;"  
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_ASSOCIATORPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
                  //                                                         org.pegasus.jmpi.CIMObjectPath pathName,
                  //                                                         java.lang.String               role)
                  //        throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "referenceNames",
                                        "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public java.util.Vector referenceNames (org.pegasus.jmpi.OperationContext oc,
              //                                         org.pegasus.jmpi.CIMObjectPath    assocName,
              //                                         org.pegasus.jmpi.CIMObjectPath    pathName,
              //                                         java.lang.String                  role)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "referenceNames",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_ASSOCIATORPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             env->ExceptionClear();             env->ExceptionClear();
  
             // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,                 // public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.OperationContext oc,
                  //                                                         org.pegasus.jmpi.CIMObjectPath    assocName,
                  //                                                         org.pegasus.jmpi.CIMObjectPath    pathName,
             //                                                  java.lang.String               role)             //                                                  java.lang.String               role)
             //        throws org.pegasus.jmpi.CIMException             //        throws org.pegasus.jmpi.CIMException
             id = env->GetMethodID((jclass)pr.jProviderClass,             id = env->GetMethodID((jclass)pr.jProviderClass,
                                   "referenceNames",                                   "referenceNames",
                                   "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");                                       "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
 //@BUG was:                       "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"  
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                     eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
                  }
             }             }
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl));             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_PEGASUS_24:          case METHOD_CIMASSOCIATORPROVIDER:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2534 
Line 4961 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,  #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName          = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     jPathName,
                                                                     jAssociationName,
                                                                     jRole);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jcopRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
   
                       JMPIjvm::checkException(env);
   
                       CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
   
                       handler.deliver(*copRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_CIMASSOCIATORPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
   
               jstring jRole = env->NewStringUTF(request->role.getCString());
   
               JMPIjvm::checkException(env);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName          = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                     joc,
                                                                     jPathName,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                   jRole);                                                                   jRole);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
   
               handler.processing();
               if (jAr) {
                   for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
                       JMPIjvm::checkException(env);
   
                       jobject jcopRet = env->GetObjectArrayElement(jAr,i);
   
                       JMPIjvm::checkException(env);
   
                       jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
   
                       JMPIjvm::checkException(env);
   
                       CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
   
                       handler.deliver(*copRet);
                   }
               }
               handler.complete();
               break;
           }
   
           case METHOD_ASSOCIATORPROVIDER:
           {
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
   
               JMPIjvm::checkException(env);
   
               jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
   
               JMPIjvm::checkException(env);
   
               jstring jRole = env->NewStringUTF(request->role.getCString());
   
               JMPIjvm::checkException(env);
   
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName          = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName           = "<<resultPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                     id,
                                                                     jAssociationName,
                                                                     jPathName,
                                                                     jRole);
   
               JMPIjvm::checkException(env);
  
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jVec,i);                      jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);                      jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);                      CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
  
                     handler.deliver(*cop);                      handler.deliver(*copRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_ASSOCIATORPROVIDER2:
         {         {
             jint    jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath);
               jobject jAssociationName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint    jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);              jlong   jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
             jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);              jobject jPathName    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2581 
Line 5135 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
   #ifdef PEGASUS_DEBUG
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName          = "<<objectPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName           = "<<resultPath->toString ()<<PEGASUS_STD(endl));
               DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role               = "<<request->role<<PEGASUS_STD(endl));
   #endif
   
               StatProviderTimeMeasurement providerTime(response);
   
             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,             jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
                                                                   id,                                                                   id,
                                                                     joc,
                                                                   jAssociationName,                                                                   jAssociationName,
                                                                   jPathName,                                                                   jPathName,
                                                                   jRole);                                                                   jRole);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
             if (jVec) {             if (jVec) {
                 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {                  for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jobject jInst=env->GetObjectArrayElement(jVec,i);                      jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);                      jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
  
                     JMPIjvm::checkException(env);                     JMPIjvm::checkException(env);
  
                     CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);                      CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef);
  
                     handler.deliver(*cop);                      handler.deliver(*copRet);
                 }                 }
             }             }
             handler.complete();             handler.complete();
Line 2633 
Line 5201 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest");
  
     HandlerIntro(GetProperty,message,request,response,handler,CIMValue());      HandlerIntro(GetProperty,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_SNIA_PROVIDER20,         METHOD_PROPERTYPROVIDER,
          METHOD_PROPERTYPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 2662 
Line 5231 
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
         // convert arguments  
         OperationContext context;  
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
  
         // forward request         // forward request
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
Line 2683 
Line 5246 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
  
         STAT_GETSTARTTIME;              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
  
           if (interfaceType == "JMPI")
           {
         // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,         // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
         //                                                             java.lang.String               oclass,         //                                                             java.lang.String               oclass,
         //                                                             java.lang.String               pName)         //                                                             java.lang.String               pName)
Line 2700 
Line 5278 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_PROPERTYPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.OperationContext oc,
              //                                                             org.pegasus.jmpi.CIMObjectPath    cop,
              //                                                             java.lang.String                  oclass,
              //                                                             java.lang.String                  pName)
              //        throws org.pegasus.jmpi.CIMException
              //
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "getPropertyValue",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_PROPERTYPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));
              }
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl));             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_SNIA_PROVIDER20:          case METHOD_PROPERTYPROVIDER:
           {
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
   
               JMPIjvm::checkException(env);
   
               jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
   
               JMPIjvm::checkException(env);
   
               jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
                                                        id,
                                                        jcop,
                                                        joclass,
                                                        jpName);
   
               JMPIjvm::checkException(env);
   
               handler.processing();
   
               if (jvalRet)
               {
                  jlong     jvalRetRef = env->CallLongMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
                  CIMValue *valRet     = DEBUG_ConvertJavaToC (jlong, CIMValue*, jvalRetRef);
   
                  JMPIjvm::checkException(env);
   
                  handler.deliver(*valRet);
               }
               handler.complete();
               break;
           }
   
           case METHOD_PROPERTYPROVIDER2:
         {         {
             jint    jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2728 
Line 5374 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_GETSTARTTIME;              StatProviderTimeMeasurement providerTime(response);
  
             jobject jval = env->CallObjectMethod ((jobject)pr.jProvider,              jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
                                                   id,                                                   id,
                                                        joc,
                                                   jcop,                                                   jcop,
                                                   joclass,                                                   joclass,
                                                   jpName);                                                   jpName);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
  
             if (jval)              if (jvalRet)
             {             {
                jint      jvalref = env->CallIntMethod(jval,JMPIjvm::jv.CIMValueCInst);                 jlong     jvalRetRef = env->CallLongMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
                CIMValue *cv      = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalref);                 CIMValue *valRet     = DEBUG_ConvertJavaToC (jlong, CIMValue*, jvalRetRef);
  
                JMPIjvm::checkException(env);                JMPIjvm::checkException(env);
  
                handler.deliver(*cv);                 handler.deliver(*valRet);
             }             }
             handler.complete();             handler.complete();
             break;             break;
Line 2775 
Line 5427 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");
  
     HandlerIntroVoid(SetProperty,message,request,response,handler);      HandlerIntro(SetProperty,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_SNIA_PROVIDER20,         METHOD_PROPERTYPROVIDER,
          METHOD_PROPERTYPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 2800 
Line 5453 
                                                        request->instanceName.getKeyBindings());                                                        request->instanceName.getKeyBindings());
  
         // resolve provider name         // resolve provider name
         ProviderName name = _resolveProviderName(          ProviderName name = _resolveProviderName(
             request->operationContext.get(ProviderIdContainer::NAME));              request->operationContext.get(ProviderIdContainer::NAME));
   
         // get cached or load new provider module  
         JMPIProvider::OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
  
         context.insert(request->operationContext.get(IdentityContainer::NAME));          // get cached or load new provider module
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
  
         // forward request         // forward request
         JMPIProvider &pr = ph.GetProvider();         JMPIProvider &pr = ph.GetProvider();
Line 2825 
Line 5472 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
  
         STAT_GETSTARTTIME;              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
   
           JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
  
           if (interfaceType == "JMPI")
           {
         // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,         // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
         //                                        java.lang.String               oclass,         //                                        java.lang.String               oclass,
         //                                        java.lang.String               pName,         //                                        java.lang.String               pName,
Line 2843 
Line 5505 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_PROPERTYPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract void setPropertyValue (org.pegasus.jmpi.OperationContext oc,
              //                                        org.pegasus.jmpi.CIMObjectPath    cop,
              //                                        java.lang.String                  oclass,
              //                                        java.lang.String                  pName,
              //                                        org.pegasus.jmpi.CIMValue         val)
              //        throws org.pegasus.jmpi.CIMException
              //
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "setPropertyValue",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_PROPERTYPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));
              }
         }         }
  
         if (id == NULL)         if (id == NULL)
         {         {
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
   
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                  "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_SNIA_PROVIDER20:          case METHOD_PROPERTYPROVIDER:
           {
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
   
               JMPIjvm::checkException(env);
   
               jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
   
               JMPIjvm::checkException(env);
   
               jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
   
               JMPIjvm::checkException(env);
   
               CIMValue *val = new CIMValue (request->newValue);
   
               JMPIjvm::checkException(env);
   
               jlong   jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
               jobject jval    = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewJ, jvalref);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod ((jobject)pr.jProvider,
                                    id,
                                    jcop,
                                    joclass,
                                    jpName,
                                    jval);
   
               JMPIjvm::checkException(env);
               break;
           }
   
           case METHOD_PROPERTYPROVIDER2:
         {         {
             jint    jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
             jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);              jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 2875 
Line 5603 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jint    jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);              jlong   jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
             jobject jval    = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);              jobject jval    = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewJ, jvalref);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_GETSTARTTIME;              StatProviderTimeMeasurement providerTime(response);
  
             env->CallVoidMethod ((jobject)pr.jProvider,             env->CallVoidMethod ((jobject)pr.jProvider,
                                  id,                                  id,
                                    joc,
                                  jcop,                                  jcop,
                                  joclass,                                  joclass,
                                  jpName,                                  jpName,
Line 2891 
Line 5620 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
             break;             break;
         }         }
  
Line 2915 
Line 5649 
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");
  
     HandlerIntroMethod(InvokeMethod,message,request,response,handler);      HandlerIntro(InvokeMethod,message,request,response,handler);
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_PEGASUS_24,         METHOD_CIMMETHODPROVIDER,
        METHOD_SNIA_PROVIDER20,         METHOD_CIMMETHODPROVIDER2,
          METHOD_METHODPROVIDER,
          METHOD_METHODPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
Line 2945 
Line 5681 
             request->operationContext.get(ProviderIdContainer::NAME));             request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);                                                                           name.getLogicalName(),
                                                                            String::EMPTY);
         // convert arguments  
         OperationContext context;  
   
         context.insert(request->operationContext.get(IdentityContainer::NAME));  
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
  
         JMPIProvider &pr=ph.GetProvider();         JMPIProvider &pr=ph.GetProvider();
  
Line 2965 
Line 5695 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
         // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,         // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,
         //                                                         java.lang.String               name,         //                                                         java.lang.String               name,
         //                                                         java.util.Vector               in,         //                                                         java.util.Vector               in,
Line 2982 
Line 5727 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_METHODPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER."<<PEGASUS_STD(endl));
         }         }
  
         if (id == NULL)         if (id == NULL)
Line 3001 
Line 5746 
  
             if (id != NULL)             if (id != NULL)
             {             {
                 eMethodFound = METHOD_PEGASUS_24;                     eMethodFound = METHOD_CIMMETHODPROVIDER;
                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));                     DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER."<<PEGASUS_STD(endl));
                  }
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,
              //                                                         org.pegasus.jmpi.CIMObjectPath    cop,
              //                                                         java.lang.String                  name,
              //                                                         java.util.Vector                  in,
              //                                                         java.util.Vector                  out)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "invokeMethod",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_METHODPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER2."<<PEGASUS_STD(endl));
              }
   
              if (id == NULL)
              {
                  env->ExceptionClear();
   
                  // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,
                  //                                                org.pegasus.jmpi.CIMObjectPath    op,
                  //                                                java.lang.String                  methodName,
                  //                                                org.pegasus.jmpi.CIMArgument[]    inArgs,
                  //                                                org.pegasus.jmpi.CIMArgument[]    outArgs)
                  //        throws org.pegasus.jmpi.CIMException
                  id = env->GetMethodID((jclass)pr.jProviderClass,
                                        "invokeMethod",
                                        "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
   
                  if (id != NULL)
                  {
                      eMethodFound = METHOD_CIMMETHODPROVIDER2;
                      DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER2."<<PEGASUS_STD(endl));
             }             }
         }         }
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
           }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_PEGASUS_24:          case METHOD_CIMMETHODPROVIDER:
           {
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
   
               JMPIjvm::checkException(env);
   
               Uint32 m=request->inParameters.size();
   
               jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
   
               for (Uint32 i=0; i<m; i++) {
                 CIMParamValue *parm    = new CIMParamValue(request->inParameters[i]);
                 jlong          jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);
                 jobject        jArg    = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewJ,jArgRef);
   
                 env->SetObjectArrayElement(jArIn,i,jArg);
               }
   
               jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
   
               StatProviderTimeMeasurement providerTime(response);
   
               jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                         id,
                                                         jcop,
                                                         jMethod,
                                                         jArIn,
                                                         jArOut);
               JMPIjvm::checkException(env);
   
               handler.processing();
   
               jlong     jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
               CIMValue *valueRet     = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);
   
               handler.deliver(*valueRet);
   
               for (int i=0; i<24; i++) {
                   jobject jArg = env->GetObjectArrayElement(jArOut,i);
   
                   JMPIjvm::checkException(env);
   
                   if (jArg==NULL)
                      break;
   
                   jlong          jpRef = env->CallLongMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
                   CIMParamValue *p     = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jpRef);
   
                   JMPIjvm::checkException(env);
   
                   handler.deliverParamValue(*p);
               }
   
               handler.complete();
               break;
           }
   
           case METHOD_CIMMETHODPROVIDER2:
         {         {
             jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
             jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());             jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());
   
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             Uint32 m=request->inParameters.size();             Uint32 m=request->inParameters.size();
  
             jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);             jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
   
             for (Uint32 i=0; i<m; i++) {             for (Uint32 i=0; i<m; i++) {
               CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);               CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
               jint           jObj = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);                jlong          jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);
               jobject        jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jObj);                jobject        jArg    = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewJ,jArgRef);
  
               env->SetObjectArrayElement(jArIn,i,jArg);               env->SetObjectArrayElement(jArIn,i,jArg);
             }             }
  
             jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);             jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
  
             jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jArIn,jArOut);              StatProviderTimeMeasurement providerTime(response);
   
               jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                         id,
                                                         joc,
                                                         jcop,
                                                         jMethod,
                                                         jArIn,
                                                         jArOut);
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
  
             jint      jv = env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst);              jlong     jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
             CIMValue *v  = DEBUG_ConvertJavaToC (jint, CIMValue*, jv);              CIMValue *valueRet     = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);
  
             handler.deliver(*v);              handler.deliver(*valueRet);
  
             for (int i=0; i<24; i++) {             for (int i=0; i<24; i++) {
                 jobject jArg=env->GetObjectArrayElement(jArOut,i);                 jobject jArg=env->GetObjectArrayElement(jArOut,i);
   
                 JMPIjvm::checkException(env);                 JMPIjvm::checkException(env);
  
                 if (jArg==NULL) break;                  if (jArg==NULL)
                      break;
  
                 jint           jp = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);                  jlong          jpRef = env->CallLongMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
                 CIMParamValue *p  = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);                  CIMParamValue *p     = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jpRef);
  
                 JMPIjvm::checkException(env);                 JMPIjvm::checkException(env);
  
Line 3063 
Line 5941 
             break;             break;
         }         }
  
         case METHOD_SNIA_PROVIDER20:          case METHOD_METHODPROVIDER:
         {         {
             jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);              jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
  
             jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());             jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());
   
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew);             jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew);
   
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
             for (int i=0,m=request->inParameters.size(); i<m; i++) {  
               for (int i=0,m=request->inParameters.size(); i<m; i++)
               {
                 const CIMParamValue &parm = request->inParameters[i];                 const CIMParamValue &parm = request->inParameters[i];
                 const CIMValue       v    = parm.getValue();                 const CIMValue       v    = parm.getValue();
                 CIMProperty         *p    = new CIMProperty(parm.getParameterName(),v,v.getArraySize());                 CIMProperty         *p    = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
                 jint                 jObj = DEBUG_ConvertCToJava (CIMProperty*, jint, p);                  jlong                jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
                   jobject              jp    = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewJ,jpRef);
   
                   env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
                }
   
               jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
  
                 jobject prop=env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jObj);              jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                         id,
                                                         jcop,
                                                         jMethod,
                                                         jVecIn,
                                                         jVecOut);
               JMPIjvm::checkException(env);
   
               handler.processing();
   
               jlong     jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
               CIMValue *valueRet     = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);
   
               handler.deliver(*valueRet);
   
               for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
               {
                   JMPIjvm::checkException(env);
   
                   jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
   
                   JMPIjvm::checkException(env);
   
                   jlong        jpRef = env->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
                   CIMProperty *p     = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jpRef);
   
                   JMPIjvm::checkException(env);
   
                   handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
               }
   
               handler.complete();
               break;
           }
   
           case METHOD_METHODPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
   
               jlong   jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);
               jobject jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
   
               JMPIjvm::checkException(env);
   
               jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
   
               JMPIjvm::checkException(env);
   
               for (int i=0,m=request->inParameters.size(); i<m; i++)
               {
                   const CIMParamValue &parm  = request->inParameters[i];
                   const CIMValue       v     = parm.getValue();
                   CIMProperty         *p     = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
                   jlong                jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
                   jobject              jp    = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewJ,jpRef);
  
                 env->CallVoidMethod(jVecIn,jv->VectorAddElement,prop);                  env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
              }              }
  
             jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);             jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jVecIn,jVecOut);              StatProviderTimeMeasurement providerTime(response);
   
               jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
                                                         id,
                                                         joc,
                                                         jcop,
                                                         jMethod,
                                                         jVecIn,
                                                         jVecOut);
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             STAT_PMS_PROVIDEREND;              if (joc)
               {
                  env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
   
                  JMPIjvm::checkException(env);
               }
  
             handler.processing();             handler.processing();
  
             jint      jv = env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst);              jlong     jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
             CIMValue *v  = DEBUG_ConvertJavaToC (jint, CIMValue*, jv);              CIMValue *valueRet     = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);
  
             handler.deliver(*v);              handler.deliver(*valueRet);
  
             for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++) {              for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
               {
                 JMPIjvm::checkException(env);                 JMPIjvm::checkException(env);
  
                 jobject jProp=env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);                 jobject jProp=env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
   
                 JMPIjvm::checkException(env);                 JMPIjvm::checkException(env);
  
                 jint         jp = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);                  jlong        jpRef = env->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
                 CIMProperty *p  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);                  CIMProperty *p     = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jpRef);
  
                 JMPIjvm::checkException(env);                 JMPIjvm::checkException(env);
  
Line 3138 
Line 6103 
 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance, int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
                                   String& providerName, String& location)                                   String& providerName, String& location)
 { {
     Uint32 pos = pInstance.findProperty(CIMName ("Name"));      Uint32 pos = pInstance.findProperty(CIMName ("Name"));
     pInstance.getProperty(pos).getValue().get(providerName);      pInstance.getProperty(pos).getValue().get(providerName);
   
       pos = pmInstance.findProperty(CIMName ("Location"));
       pmInstance.getProperty(pos).getValue().get(location);
       return 0;
   }
   
   WQLSelectStatement *
   newSelectExp (String& query,
                 String& queryLanguage)
   {
      WQLSelectStatement *stmt = new WQLSelectStatement (queryLanguage, query);
   
      try
      {
         WQLParser::parse (query, *stmt);
      }
      catch (const Exception &e)
      {
         cerr << "Error: newSelectExp caught: " << e.getMessage () << endl;
      }
  
     pos = pmInstance.findProperty(CIMName ("Location"));     return stmt;
     pmInstance.getProperty(pos).getValue().get(location);  
     return 0;  
 } }
  
 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
Line 3154 
Line 6137 
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_SNIA_PROVIDER20,         METHOD_EVENTPROVIDER,
          METHOD_EVENTPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
  
     try {     try {
         String               providerName,          String               fileName,
                                providerName,
                              providerLocation;                              providerLocation;
         CIMInstance          req_provider,         CIMInstance          req_provider,
                              req_providerModule;                              req_providerModule;
   
         ProviderIdContainer  pidc                = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);         ProviderIdContainer  pidc                = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
  
         req_provider       = pidc.getProvider();         req_provider       = pidc.getProvider();
         req_providerModule = pidc.getModule();         req_providerModule = pidc.getModule();
  
         LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);          LocateIndicationProviderNames (req_provider,
                                          req_providerModule,
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,                                         providerName,
                                          providerLocation);
   
           fileName = resolveFileName (providerLocation);
   
           Logger::put (Logger::STANDARD_LOG,
                        System::CIMSERVER,
                        Logger::TRACE,
             "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0  Name space: $1  Provider name(s): $2",             "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0  Name space: $1  Provider name(s): $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             providerName);             providerName);
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "
                                <<System::getHostName()
         String fileName = resolveFileName(providerLocation);                               <<", namespace = "
                                <<request->nameSpace.getString()
                                <<", providername = "
                                <<providerName
                                <<", fileName = "
                                <<fileName
                                <<PEGASUS_STD(endl));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,
             providerManager.getProvider(fileName, providerName, String::EMPTY);                                                                           providerName,
                                                                            String::EMPTY);
   
           //
           //  Save the provider instance from the request
           //
           ph.GetProvider ().setProviderInstance (req_provider);
   
           JMPIProvider &pr = ph.GetProvider ();
   
           //
           //  Increment count of current subscriptions for this provider
           //
           pr.testIfZeroAndIncrementSubscriptions ();
  
           SubscriptionFilterConditionContainer  sub_cntr = request->operationContext.get (SubscriptionFilterConditionContainer::NAME);
         indProvRecord *prec = NULL;         indProvRecord *prec = NULL;
           bool                                  fNewPrec = false;
   
           {
              AutoMutex lock (mutexProvTab);
  
         provTab.lookup(providerName,prec);         provTab.lookup(providerName,prec);
  
         if (prec)             if (!prec)
         {  
             prec->count++;  
         }  
         else  
         {         {
                  fNewPrec = true;
   
             prec=new indProvRecord();             prec=new indProvRecord();
             provTab.insert(providerName,prec);  
         }  
  
         //                 // convert arguments
         //  Save the provider instance from the request                 prec->ctx = new OperationContext ();
         //  
         ph.GetProvider ().setProviderInstance (req_provider);  
  
         indSelectRecord     *srec  = new indSelectRecord();                 prec->ctx->insert (request->operationContext.get (IdentityContainer::NAME));
         const CIMObjectPath &sPath = request->subscriptionInstance.getPath();                 prec->ctx->insert (request->operationContext.get (AcceptLanguageListContainer::NAME));
                  prec->ctx->insert (request->operationContext.get (ContentLanguageListContainer::NAME));
                  prec->ctx->insert (request->operationContext.get (SubscriptionInstanceContainer::NAME));
                  prec->ctx->insert (request->operationContext.get (SubscriptionFilterConditionContainer::NAME));
  
         selxTab.insert(sPath.toString(),srec);                 prec->enabled = true;
  
         // convert arguments                 prec->handler = new EnableIndicationsResponseHandler (0,
         OperationContext *context=new OperationContext();                                                                       0,
                                                                        req_provider,
                                                                        _indicationCallback,
                                                                        _responseChunkCallback);
  
         if (prec->ctx==NULL)                 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to provTab "<<providerName<<PEGASUS_STD(endl));
         {  
             prec->ctx=context;                 provTab.insert (providerName, prec);
              }
         }         }
  
         context->insert(request->operationContext.get(IdentityContainer::NAME));          {
         context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));             AutoMutex lock (prec->mutex);
         context->insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
         context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));  
         context->insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));  
         context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));  
  
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();             prec->count++;
           }
  
         SubscriptionFilterConditionContainer sub_cntr =  request->operationContext.get          // Add a selection record for JNI CIMOMHandle deliverEvent calls
                 (SubscriptionFilterConditionContainer::NAME);          indSelectRecord *srec = new indSelectRecord ();
  
         JMPIProvider &pr = ph.GetProvider();          {
              srec->query         = request->query;
              srec->queryLanguage = sub_cntr.getQueryLanguage ();
              srec->propertyList  = request->propertyList;
  
         CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),             CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()),
                                                                       *pr._cimom_handle);                                                                       *pr._cimom_handle);
              srec->qContext = qContext;
  
         CMPI_SelectExp *eSelx = new CMPI_SelectExp(*context,             CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ());
                                                    qcontext,  
                                                    request->query,  
                                                    sub_cntr.getQueryLanguage());  
  
         srec->eSelx=eSelx;             sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ());
         srec->qContext=qcontext;  
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());             AutoMutex lock (mutexSelxTab);
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));             DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to selxTab "<<sPath.toString ()<<PEGASUS_STD(endl));
  
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {             selxTab.insert (sPath.toString (), srec);
             CIMObjectPath className(  
                 System::getHostName(),  
                 request->nameSpace,  
                 request->classNames[i]);  
             eSelx->classNames.append(className);  
         }  
  
         CIMPropertyList propertyList = request->propertyList;             DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: For selxTab "<<sPath.toString ()<<", srec = "<<PEGASUS_STD(hex)<<(long)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(long)qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
         if (!propertyList.isNull()) {  
            Array<CIMName> p=propertyList.getPropertyNameArray();  
            int pCount=p.size();  
            eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));  
            for (int i=0; i<pCount; i++) {  
               eSelx->props[i]=strdup(p[i].getString().getCString());  
             }  
            eSelx->props[pCount]=NULL;  
         }         }
  
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());
   
           DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
   
         JvmVector *jv = 0;         JvmVector *jv = 0;
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
   
           getInterfaceType (pidc,
                             interfaceType,
                             interfaceVersion);
  
         // public void authorizeFilter (org.pegasus.jmpi.SelectExp     filter,          if (interfaceType == "JMPI")
           {
              // public void activateFilter (org.pegasus.jmpi.SelectExp     filter,
         //                              java.lang.String               eventType,         //                              java.lang.String               eventType,
         //                              org.pegasus.jmpi.CIMObjectPath classPath,         //                              org.pegasus.jmpi.CIMObjectPath classPath,
         //                              java.lang.String               owner)             //                             boolean                        firstActivation)
         //        throws org.pegasus.jmpi.CIMException         //        throws org.pegasus.jmpi.CIMException
         id = env->GetMethodID((jclass)pr.jProviderClass,         id = env->GetMethodID((jclass)pr.jProviderClass,
                               "activateFilter",                               "activateFilter",
Line 3287 
Line 6305 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_EVENTPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public void activateFilter (org.pegasus.jmpi.OperationContext oc,
              //                             org.pegasus.jmpi.SelectExp        filter,
              //                             java.lang.String                  eventType,
              //                             org.pegasus.jmpi.CIMObjectPath    classPath,
              //                             boolean                           firstActivation)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID ((jclass)pr.jProviderClass,
                                     "activateFilter",
                                     "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_EVENTPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));
              }
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_SNIA_PROVIDER20:          case METHOD_EVENTPROVIDER:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);              WQLSelectStatement *stmt       = newSelectExp (srec->query,
             jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);                                                             srec->queryLanguage);
               jlong               jStmtRef   = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);
               jobject             jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);
   
               JMPIjvm::checkException(env);
   
               jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
   
               JMPIjvm::checkException(env);
   
               CIMObjectPath *cop     = new CIMObjectPath (System::getHostName(),
                                                           request->nameSpace,
                                                           request->classNames[0]);
               jlong          jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
               jobject        jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod ((jobject)pr.jProvider,
                                    id,
                                    jSelectExp,
                                    jType,
                                    jcop,
                                    (jboolean)fNewPrec);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
               break;
           }
  
             jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);          case METHOD_EVENTPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
  
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              WQLSelectStatement *stmt       = newSelectExp (srec->query,
                                                              srec->queryLanguage);
               jlong               jStmtRef   = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);
               jobject             jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 3312 
Line 6393 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
               CIMObjectPath *cop     = new CIMObjectPath (System::getHostName(),
                                                           request->nameSpace,
                                                           request->classNames[0]);
               jlong          jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
               jobject        jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
             env->CallVoidMethod((jobject)pr.jProvider,             env->CallVoidMethod((jobject)pr.jProvider,
                                 id,                                 id,
                                 jSel,                                   joc,
                                    jSelectExp,
                                 jType,                                 jType,
                                 jRef,                                   jcop,
                                 (jboolean)0);                                   (jboolean)fNewPrec);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             //              if (joc)
             //  Increment count of current subscriptions for this provider  
             //  
             if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())  
             {  
                 //  
                 //  If there were no current subscriptions before the increment,  
                 //  the first subscription has been created  
                 //  Call the provider's enableIndications method  
                 //  
                 if (_subscriptionInitComplete)  
                 {                 {
                     prec->enabled = true;                 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
                     CIMRequestMessage * request = 0;  
                     CIMResponseMessage * response = 0;  
                     prec->handler = new EnableIndicationsResponseHandler  
                         (request, response, req_provider, _indicationCallback);  
                 }  
             }  
  
             STAT_PMS_PROVIDEREND;                 JMPIjvm::checkException(env);
               }
             break;             break;
         }         }
  
Line 3351 
Line 6428 
             break;             break;
         }         }
         }         }
   
     }     }
     HandlerCatch(handler);     HandlerCatch(handler);
  
Line 3370 
Line 6446 
  
     typedef enum {     typedef enum {
        METHOD_UNKNOWN = 0,        METHOD_UNKNOWN = 0,
        METHOD_SNIA_PROVIDER20,         METHOD_EVENTPROVIDER,
          METHOD_EVENTPROVIDER2,
     } METHOD_VERSION;     } METHOD_VERSION;
     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;     METHOD_VERSION   eMethodFound  = METHOD_UNKNOWN;
     JNIEnv          *env           = NULL;     JNIEnv          *env           = NULL;
       bool                     fFreePrec    = false;
       indProvRecord           *prec         = NULL;
       indSelectRecord         *srec         = NULL;
  
     try {     try {
         String              providerName,          String              fileName,
                               providerName,
                             providerLocation;                             providerLocation;
         CIMInstance         req_provider,         CIMInstance         req_provider,
                             req_providerModule;                             req_providerModule;
Line 3385 
Line 6466 
         req_provider       = pidc.getProvider();         req_provider       = pidc.getProvider();
         req_providerModule = pidc.getModule();         req_providerModule = pidc.getModule();
  
         LocateIndicationProviderNames(req_provider, req_providerModule, providerName,providerLocation);          LocateIndicationProviderNames (req_provider,
                                          req_providerModule,
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,                                         providerName,
                                          providerLocation);
   
           fileName = resolveFileName (providerLocation);
   
           Logger::put (Logger::STANDARD_LOG,
                        System::CIMSERVER,
                        Logger::TRACE,
             "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0  Name space: $1  Provider name(s): $2",             "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0  Name space: $1  Provider name(s): $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             providerName);             providerName);
  
         DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));          DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "
                                <<System::getHostName()
         String fileName = resolveFileName(providerLocation);                               <<", namespace = "
                                <<request->nameSpace.getString()
                                <<", providername = "
                                <<providerName
                                <<", fileName = "
                                <<fileName
                                <<PEGASUS_STD(endl));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,
             providerManager.getProvider(fileName, providerName, String::EMPTY);                                                                           providerName,
                                                                            String::EMPTY);
  
         indProvRecord *prec = NULL;          JMPIProvider &pr = ph.GetProvider ();
   
           {
              AutoMutex lock (mutexProvTab);
  
         provTab.lookup(providerName,prec);         provTab.lookup(providerName,prec);
           }
   
           {
              AutoMutex lock (prec->mutex);
   
         if (--prec->count <= 0)         if (--prec->count <= 0)
         {         {
                  DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing provTab "<<providerName<<PEGASUS_STD(endl));
   
             provTab.remove(providerName);             provTab.remove(providerName);
             prec=NULL;  
                  fFreePrec = true;
              }
         }         }
  
         indSelectRecord     *srec        = NULL;          {
         const CIMObjectPath &sPath       = request->subscriptionInstance.getPath();             CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ());
         String               sPathString = sPath.toString();  
  
         selxTab.lookup(sPathString,srec);             sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ());
  
         CMPI_SelectExp          *eSelx    = srec->eSelx;             String sPathString = sPath.toString ();
         CIMOMHandleQueryContext *qContext = srec->qContext;  
  
         selxTab.remove(sPathString);             AutoMutex lock (mutexSelxTab);
  
         // convert arguments             DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl));
         OperationContext context;  
  
         context.insert(request->operationContext.get(IdentityContainer::NAME));             selxTab.lookup (sPathString, srec);
         context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));  
         context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));  
         context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));  
  
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();             DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: For selxTab "<<sPathString<<", srec = "<<PEGASUS_STD(hex)<<(long)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(long)srec->qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
  
         JMPIProvider & pr=ph.GetProvider();             selxTab.remove (sPathString);
           }
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());
  
Line 3442 
Line 6543 
  
         env = JMPIjvm::attachThread(&jv);         env = JMPIjvm::attachThread(&jv);
  
         JMPIProvider::pm_service_op_lock op_lock(&pr);          if (!env)
           {
               PEG_METHOD_EXIT();
   
               throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                              MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
                                                                 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
           }
  
         STAT_GETSTARTTIME;          JMPIProvider::pm_service_op_lock op_lock(&pr);
  
         jmethodID id = NULL;         jmethodID id = NULL;
           String    interfaceType;
           String    interfaceVersion;
  
           getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
                             interfaceType,
                             interfaceVersion);
   
           if (interfaceType == "JMPI")
           {
         // public void deActivateFilter (org.pegasus.jmpi.SelectExp    filter,         // public void deActivateFilter (org.pegasus.jmpi.SelectExp    filter,
         //                              java.lang.String               eventType,         //                              java.lang.String               eventType,
         //                              org.pegasus.jmpi.CIMObjectPath classPath,         //                              org.pegasus.jmpi.CIMObjectPath classPath,
Line 3459 
Line 6575 
  
         if (id != NULL)         if (id != NULL)
         {         {
             eMethodFound = METHOD_SNIA_PROVIDER20;                 eMethodFound = METHOD_EVENTPROVIDER;
             DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));                 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));
              }
           }
           else if (interfaceType == "JMPIExperimental")
           {
              // public void deActivateFilter (org.pegasus.jmpi.OperationContext oc,
              //                               org.pegasus.jmpi.SelectExp        filter,
              //                               java.lang.String                  eventType,
              //                               org.pegasus.jmpi.CIMObjectPath    classPath,
              //                               boolean                           lastActivation)
              //        throws org.pegasus.jmpi.CIMException
              id = env->GetMethodID((jclass)pr.jProviderClass,
                                    "deActivateFilter",
                                    "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
   
              if (id != NULL)
              {
                  eMethodFound = METHOD_EVENTPROVIDER2;
                  DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));
              }
           }
   
           if (id == NULL)
           {
              DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));
   
              PEG_METHOD_EXIT();
   
              throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
                                             MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
                                                                 "Could not find a method for the provider based on InterfaceType."));
         }         }
  
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
         switch (eMethodFound)         switch (eMethodFound)
         {         {
         case METHOD_SNIA_PROVIDER20:          case METHOD_EVENTPROVIDER:
         {         {
             jint    jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);              WQLSelectStatement *stmt       = newSelectExp (srec->query,
             jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);                                                             srec->queryLanguage);
               jlong               jStmtRef   = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);
               jobject             jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);
   
               JMPIjvm::checkException(env);
   
               jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);              CIMObjectPath *cop     = new CIMObjectPath (System::getHostName(),
                                                           request->nameSpace,
                                                           request->classNames[0]);
               jlong          jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
               jobject        jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
               env->CallVoidMethod ((jobject)pr.jProvider,
                                    id,
                                    jSelectExp,
                                    jType,
                                    jcop,
                                    (jboolean)fFreePrec);
   
               JMPIjvm::checkException(env);
               break;
           }
   
           case METHOD_EVENTPROVIDER2:
           {
               jlong   jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);
               jobject joc    = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);
  
             jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);              WQLSelectStatement *stmt       = newSelectExp (srec->query,
                                                              srec->queryLanguage);
               jlong               jStmtRef   = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);
               jobject             jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
Line 3484 
Line 6663 
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
               CIMObjectPath *cop     = new CIMObjectPath (System::getHostName(),
                                                           request->nameSpace,
                                                           request->classNames[0]);
               jlong          jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
               jobject        jcop    = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);
   
               JMPIjvm::checkException(env);
   
               StatProviderTimeMeasurement providerTime(response);
   
             env->CallVoidMethod((jobject)pr.jProvider,             env->CallVoidMethod((jobject)pr.jProvider,
                                 id,                                 id,
                                 jSel,                                   joc,
                                    jSelectExp,
                                 jType,                                 jType,
                                 jRef,                                   jcop,
                                 (jboolean)(prec==NULL));                                   (jboolean)fFreePrec);
  
             JMPIjvm::checkException(env);             JMPIjvm::checkException(env);
  
             //              if (joc)
             //  Decrement count of current subscriptions for this provider  
             //  
             if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())  
             {             {
                 //                 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
                 //  If there are no current subscriptions after the decrement,  
                 //  the last subscription has been deleted  
                 //  Call the provider's disableIndications method  
                 //  
                 if (_subscriptionInitComplete)  
                 {  
                     prec->enabled = false;  
                     if (prec->handler) delete prec->handler;  
                     prec->handler = NULL;  
                 }  
             }  
   
             STAT_PMS_PROVIDEREND;  
  
             delete eSelx;                 JMPIjvm::checkException(env);
             delete qContext;              }
             delete srec;  
             break;             break;
         }         }
  
Line 3525 
Line 6698 
             break;             break;
         }         }
         }         }
   
           //
           //  Decrement count of current subscriptions for this provider
           //
           pr.decrementSubscriptionsAndTestIfZero ();
     }     }
     HandlerCatch(handler);     HandlerCatch(handler);
  
       if (srec)
       {
          delete srec->qContext;
       }
       delete srec;
   
       if (fFreePrec)
       {
          delete prec->ctx;
          delete prec->handler;
          delete prec;
       }
   
     if (env) JMPIjvm::detachThread();     if (env) JMPIjvm::detachThread();
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 3574 
Line 6765 
  
     PEGASUS_ASSERT(response != 0);     PEGASUS_ASSERT(response != 0);
  
     // preserve message key  
     response->setKey(request->getKey());  
   
     //     //
     //  Set HTTP method in response from request     //  Set HTTP method in response from request
     //     //
Line 3608 
Line 6796 
  
     PEGASUS_ASSERT(response != 0);     PEGASUS_ASSERT(response != 0);
  
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request     //  Set HTTP method in response from request
     response->setHttpMethod (request->getHttpMethod ());     response->setHttpMethod (request->getHttpMethod ());
  
Line 3636 
Line 6821 
  
     PEGASUS_ASSERT(response != 0);     PEGASUS_ASSERT(response != 0);
  
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request     //  Set HTTP method in response from request
     response->setHttpMethod (request->getHttpMethod ());     response->setHttpMethod (request->getHttpMethod ());
  
Line 3663 
Line 6845 
            request->operationContext.get(ProviderIdContainer::NAME));            request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         JMPIProvider::OpProviderHolder ph =          JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
             providerManager.getProvider(name.getPhysicalName(),                                                                           name.getLogicalName(),
                name.getLogicalName(), String::EMPTY);                                                                           String::EMPTY);
  
     }     }
     HandlerCatch(handler);     HandlerCatch(handler);
Line 3702 
Line 6884 
     //  provider's enableIndications method     //  provider's enableIndications method
     //     //
     Array <JMPIProvider *> enableProviders;     Array <JMPIProvider *> enableProviders;
   
     enableProviders = providerManager.getIndicationProvidersToEnable ();     enableProviders = providerManager.getIndicationProvidersToEnable ();
  
     Uint32 numProviders = enableProviders.size ();     Uint32 numProviders = enableProviders.size ();
   
       DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: numProviders = "<<numProviders<<PEGASUS_STD(endl));
   
   #if 0
     for (Uint32 i = 0; i < numProviders; i++)     for (Uint32 i = 0; i < numProviders; i++)
     {     {
         try         try
         {         {
             CIMInstance provider;             CIMInstance provider;
   
             provider = enableProviders [i]->getProviderInstance ();             provider = enableProviders [i]->getProviderInstance ();
  
               DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: name = "<<enableProviders[i]->getName ()<<PEGASUS_STD(endl));
   
             //             //
             //  Get cached or load new provider module             //  Get cached or load new provider module
             //             //
             JMPIProvider::OpProviderHolder ph = providerManager.getProvider              JMPIProvider::OpProviderHolder  ph   = providerManager.getProvider (enableProviders[i]->getModule ()->getFileName (),
                 (enableProviders [i]->getModule ()->getFileName (),  
                  enableProviders [i]->getName ());                  enableProviders [i]->getName ());
   
             indProvRecord * prec = NULL;             indProvRecord * prec = NULL;
             provTab.lookup (enableProviders [i]->getName (), prec);  
             if (prec)  
             {             {
                 prec->enabled = true;                 AutoMutex lock (mutexProvTab);
                 CIMRequestMessage * request = 0;  
                 CIMResponseMessage * response = 0;                 provTab.lookup (enableProviders[i]->getName (), prec);
                 prec->handler = new EnableIndicationsResponseHandler  
                     (request, response, provider, _indicationCallback);  
             }             }
         }         }
         catch (CIMException & e)         catch (CIMException & e)
Line 3742 
Line 6927 
         }         }
         catch(...)         catch(...)
         {         {
             PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                 "Unknown error in handleSubscriptionInitCompleteRequest");                 "Unknown error in handleSubscriptionInitCompleteRequest");
         }         }
     }     }
   #endif
  
     PEG_METHOD_EXIT ();     PEG_METHOD_EXIT ();
     return (response);     return (response);
Line 3794 
Line 6980 
  
 String JMPIProviderManager::resolveFileName(String fileName) String JMPIProviderManager::resolveFileName(String fileName)
 { {
     String name;      String name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
     #if defined(PEGASUS_OS_TYPE_WINDOWS)      // physfilename = everything up to the delimiter pointing at class start
     name = fileName; // + String(".dll");      // in case there is no delimiter anymore, it takes the entire filename
     #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)      String physfilename = fileName.subString(0, fileName.find(":"));
     name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));      // look in all(multiple) homed pathes for the physical file
     name.append(String("/") + fileName); // + String(".sl"));      name = FileSystem::getAbsoluteFileName(name, physfilename);
     #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)      // construct back the fully specified jar:<classname> provider name
     name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));      name = FileSystem::extractFilePath(name) + fileName;
     name.append(String("/") + fileName); // + String(".so"));  
     #elif defined(PEGASUS_OS_OS400)  
     name = filrName;  
     #else  
     name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
     name.append(String("/") + fileName); // + String(".so"));  
     #endif  
     return name;     return name;
 } }
  

Legend:
Removed from v.1.28  
changed lines
  Added in v.1.59.4.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2