jmpiimpl.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// 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
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#include "JMPIImpl.h"

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
#include <Pegasus/Common/DynamicLibrary.h>
#else
#include <dlfcn.h>
#endif
#include <iostream>
#include <sstream>

#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/System.h>
#include <Pegasus/Common/CIMClass.h>
#include <Pegasus/Common/CIMInstance.h>
#include <Pegasus/Common/CIMObjectPath.h>
#include <Pegasus/Common/CIMProperty.h>
#include <Pegasus/Common/OperationContext.h>
#include <Pegasus/Provider/CIMOMHandle.h>
#include <Pegasus/Client/CIMClient.h>
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>
#include <Pegasus/WQL/WQLSelectStatement.h>
#include <Pegasus/WQL/WQLParser.h>
#define CALL_SIGN_WQL "WQL"

PEGASUS_USING_STD;
PEGASUS_NAMESPACE_BEGIN

JavaVM *JMPIjvm::jvm=NULL;
JvmVector JMPIjvm::jv;
int JMPIjvm::trace=0;

#ifdef PEGASUS_DEBUG
#define DDD(x) if (JMPIjvm::trace) x;
#else
#define DDD(x)
#endif

#include "Convert.h"

JMPIjvm::ClassTable  JMPIjvm::_classTable;
JMPIjvm::ObjectTable JMPIjvm::_objectTable;

const char* classNames[]={
/*00*/ "java/util/Vector" ,
/*01*/ "java/lang/Boolean",
/*02*/ "java/lang/Byte",
/*03*/ "java/lang/Short",
/*04*/ "java/lang/Integer",
/*05*/ "java/lang/Long",
/*06*/ "java/lang/Float",
/*07*/ "java/lang/Double",
/*08*/ "org/pegasus/jmpi/UnsignedInt8",
/*09*/ "org/pegasus/jmpi/UnsignedInt16",
/*10*/ "org/pegasus/jmpi/UnsignedInt32",
/*11*/ "org/pegasus/jmpi/UnsignedInt64",
/*12*/ "org/pegasus/jmpi/CIMObjectPath",
/*13*/ "org/pegasus/jmpi/CIMException",
/*14*/ "java/math/BigInteger",
/*15*/ "org/pegasus/jmpi/CIMProperty",
/*16*/ "org/pegasus/jmpi/CIMOMHandle",
/*17*/ "org/pegasus/jmpi/CIMClass",
/*18*/ "org/pegasus/jmpi/CIMInstance",
/*19*/ "org/pegasus/jmpi/CIMValue",
/*20*/ "java/lang/Object",
/*21*/ "java/lang/Throwable",
/*22*/ "java/lang/String",
/*23*/ "org/pegasus/jmpi/JarClassLoader",
/*24*/ "org/pegasus/jmpi/CIMDateTime",
/*25*/ "org/pegasus/jmpi/SelectExp",
/*26*/ "org/pegasus/jmpi/CIMQualifier",
/*27*/ "org/pegasus/jmpi/CIMQualifierType",
/*28*/ "org/pegasus/jmpi/CIMFlavor",
/*29*/ "org/pegasus/jmpi/CIMArgument",
/*30*/ "org/pegasus/jmpi/CIMInstanceException",
/*31*/ "org/pegasus/jmpi/CIMObject",
/*32*/ "java/lang/Character",
/*33*/ "org/pegasus/jmpi/OperationContext",
/*34*/ "java/lang/Class",
};

const METHOD_STRUCT instanceMethodNames[]={
/*00 VectorNew                   */ { /*Vector           */ 0, "<init>",          "()V" },
/*01 BooleanNewZ                 */ { /*Boolean          */ 1, "<init>",          "(Z)V" },
/*02 ByteNewB                    */ { /*Byte             */ 2, "<init>",          "(B)V" },
/*03 ShortNewS                   */ { /*Short            */ 3, "<init>",          "(S)V" },
/*04 IntegerNewI                 */ { /*Integer          */ 4, "<init>",          "(I)V" },
/*05 LongNewJ                    */ { /*Long             */ 5, "<init>",          "(J)V" },
/*06 FloatNewF                   */ { /*Float            */ 6, "<init>",          "(F)V" },
/*07 DoubleNewD                  */ { /*Double           */ 7, "<init>",          "(D)V" },
/*08 UnsignedInt8NewS            */ { /*UnsignedInt8     */ 8, "<init>",          "(S)V" },
/*09 UnsignedInt16NewI           */ { /*UnsignedInt16    */ 9, "<init>",          "(I)V" },
/*10 UnsignedInt32NewJ           */ { /*UnsignedInt32    */10, "<init>",          "(J)V" },
/*11 UnsignedInt64NewBi          */ { /*UnsignedInt64    */11, "<init>",          "(Ljava/math/BigInteger;)V" },
/*12 CIMObjectPathNewJ           */ { /*CIMObjectPath    */12, "<init>",          "(J)V" },
/*13 CIMExceptionNewSt           */ { /*CIMException     */13, "<init>",          "(Ljava/lang/String;)V" },
/*14 CIMPropertyNewJ             */ { /*CIMProperty      */15, "<init>",          "(J)V" },
/*15 VectorAddElement            */ { /*Vector           */ 0, "addElement",      "(Ljava/lang/Object;)V" },
/*16 VectorElementAt             */ { /*Vector           */ 0, "elementAt",       "(I)Ljava/lang/Object;" },
/*17 CIMOMHandleNewJSt           */ { /*CIMOMHandle      */16, "<init>",          "(JLjava/lang/String;)V" },
/*18 CIMExceptionNewI            */ { /*CIMException     */13, "<init>",          "(I)V" },
/*19 CIMClassNewJ                */ { /*CIMClass         */17, "<init>",          "(J)V" },
/*20 CIMInstanceNewJ             */ { /*CIMInstance      */18, "<init>",          "(J)V" },
/*21 CIMObjectPathCInst          */ { /*CIMObjectPath    */12, "cInst",           "()J" },
/*22 CIMInstanceCInst            */ { /*CIMInstance      */18, "cInst",           "()J" },
/*23 CIMClassCInst               */ { /*CIMClass         */17, "cInst",           "()J" },
/*24 ObjectToString              */ { /*Object           */20, "toString",        "()Ljava/lang/String;" },
/*25 ThrowableGetMessage         */ { /*Throwable        */21, "getMessage",      "()Ljava/lang/String;" },
/*26 CIMExceptionGetID           */ { /*CIMException     */13, "getID",           "()Ljava/lang/String;" },
/*27 VectorSize                  */ { /*Vector           */ 0, "size",            "()I" },
/*28 CIMPropertyCInst            */ { /*CIMProperty      */15, "cInst",           "()J" },
/*29 CIMOMHandleGetClass         */ { /*CIMOMHandle      */16, "getClass",        "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },
/*30 VectorRemoveElementAt       */ { /*Vector           */ 0, "removeElementAt", "(I)V" },
/*31 CIMValueCInst               */ { /*CIMValue         */19, "cInst",           "()J" },
/*32 CIMExceptionNewISt          */ { /*CIMException     */13, "<init>",          "(ILjava/lang/String;)V" },
/*33 CIMExceptionGetCode         */ { /*CIMException     */13, "getCode",         "()I" },
/*34 CIMDateTimeNewJ             */ { /*CIMDateTime      */24, "<init>",          "(J)V" },
/*35 SelectExpNewJ               */ { /*SelectExp        */25, "<init>",          "(J)V" },
/*36 CIMQualifierNewJ            */ { /*CIMQualifier     */26, "<init>",          "(J)V" },
/*37 CIMFlavorNewI               */ { /*CIMFlavor        */28, "<init>",          "(I)V" },
/*38 CIMFlavorGetFlavor          */ { /*CIMFlavor        */28, "getFlavor",       "()I" },
/*39 CIMArgumentCInst            */ { /*CIMArgument      */29, "cInst",           "()J" },
/*40 CIMArgumentNewJ             */ { /*CIMArgument      */29, "<init>",          "(J)V" },
/*41 CIMExceptionNew             */ { /*CIMException     */13, "<init>",          "()V" },
/*42 CIMExceptionNewStOb         */ { /*CIMException     */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;)V" },
/*43 CIMExceptionNewStObOb       */ { /*CIMException     */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" },
/*44 CIMExceptionNewStObObOb     */ { /*CIMException     */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" },
/*45 CIMValueNewJ                */ { /*CIMValue         */19, "<init>",          "(J)V" },
/*46 CIMObjectNewJZ              */ { /*CIMObject        */31, "<init>",          "(JZ)V" },
/*47 CharacterNewC               */ { /*Character        */32, "<init>",          "(C)V" },
/*48 OperationContextNewJ        */ { /*OperationContext */33, "<init>",          "(J)V" },
/*49 OperationContextUnassociate */ { /*OperationContext */33, "unassociate",     "()V" },
/*50 ClassGetInterfaces          */ { /*Class            */34, "getInterfaces",   "()[Ljava/lang/Class;" },
/*51 ClassGetName                */ { /*Class            */34, "getName",         "()Ljava/lang/String;" },
/*52 UnsignedInt64NewStr         */ { /*UnsignedInt64    */11, "<init>",          "(Ljava/lang/String;)V" }
};

const METHOD_STRUCT staticMethodNames[]={
/*00*/ { 14, "valueOf",         "(J)Ljava/math/BigInteger;" },
/*01*/ { 23, "load",            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },
};

static int methodInitDone=0;

jclass    classRefs[sizeof(classNames)/sizeof(classNames[0])];
jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])];
jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(staticMethodNames[0])];

jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name)
{
  jclass localRefCls = env->FindClass(name);

  if (localRefCls == NULL)
     return JNI_FALSE;

  jclass globalRefCls = (jclass) env->NewGlobalRef(localRefCls);

#if 0
  jmethodID   jmidToString   = env->GetMethodID(globalRefCls, "toString", "()Ljava/lang/String;");
  jstring     jstringResult  = (jstring)env->CallObjectMethod(globalRefCls, jmidToString);
  const char *pszResult      = env->GetStringUTFChars(jstringResult, 0);

  DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(long)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<", pszResult = "<<pszResult<<PEGASUS_STD(endl));

  env->ReleaseStringUTFChars (jstringResult, pszResult);
#else
  DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(long)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl));
#endif

  env->DeleteLocalRef(localRefCls);

  return globalRefCls;
}

JMPIjvm::JMPIjvm()
{
   initJVM ();
}

JMPIjvm::~JMPIjvm()
{
}

int JMPIjvm::cacheIDs(JNIEnv *env)
{
   if (methodInitDone == 1)
      return JNI_TRUE;
   if (methodInitDone == -1)
      return JNI_FALSE;

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));

   methodInitDone = -1;

   for (unsigned i = 0; i<(sizeof(classNames)/sizeof(classNames[0])); i++)
   {
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl));
      if ((classRefs[i] = getGlobalClassRef(env,classNames[i])) == NULL)
      {
         DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error: Count not find global class ref for "<<classNames[i]<<PEGASUS_STD(endl));

         return JNI_FALSE;
      }
   }

   for (unsigned j = 0; j<(sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])); j++)
   {
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<": "<<instanceMethodNames[j].signature<<PEGASUS_STD(endl));
      if ((instanceMethodIDs[j] = env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],
                                                 instanceMethodNames[j].methodName,
                                                 instanceMethodNames[j].signature)) == NULL)
      {
         DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl));
         return 0;
      }
   }

   for (unsigned k = 0; k<(sizeof(staticMethodNames)/sizeof(staticMethodNames[0])); k++)
   {
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<": "<<staticMethodNames[k].signature<<PEGASUS_STD(endl));
      if ((staticMethodIDs[k] = env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex],
                                                     staticMethodNames[k].methodName,
                                                     staticMethodNames[k].signature)) == NULL)
      {
         DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl));
         return 0;
      }
   }

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl));

   jv.env = env;
   jv.classRefs = classRefs;
   jv.instMethodIDs = instanceMethodIDs;
   jv.staticMethodIDs = staticMethodIDs;
   jv.instanceMethodNames = instanceMethodNames;

   methodInitDone = 1;

   return JNI_TRUE;
}

static void throwCIMException (JNIEnv *env, char *e)
{
   JMPIjvm::cacheIDs (env);

   env->ThrowNew (JMPIjvm::jv.CIMExceptionClassRef, e);
}

int JMPIjvm::destroyJVM ()
{
   DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl));

#ifdef JAVA_DESTROY_VM_WORKS
   if (jvm!= NULL)
   {
      JvmVector *jv;

      attachThread(&jv);

      jvm->DestroyJavaVM();

      jvm = NULL;

      return 0;
   }
#endif

   return -1;
}

Mutex JMPIjvm::_initMutex;

int JMPIjvm::initJVM ()
{
   AutoMutex lock (_initMutex);

   if (jvm != NULL)
   {
      return 0;
   }

   JavaVMInitArgs vm_args;
   jint res;
   char *envstring;
   JNIEnv *env;
   JavaVMOption *poptions = 0;
   int maxoption = 0;
   typedef struct _JVMOptions {
      const char *pszEnvName;
      const char *pszPrefix;
      bool        fSplit;
   } JVMOPTIONS;
   Array<std::string> JNIoptions;
   static JVMOPTIONS aEnvOptions[] = {
      { "CLASSPATH",                           "-Djava.class.path=", false },
      { "PEGASUS_JMPI_MAX_HEAP",               "-Xmx"              , false },
      { "PEGASUS_JMPI_INITIAL_HEAP",           "-Xms"              , false },
      { "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss"              , false },
      { "PEGASUS_JMPI_VERBOSE",                "-verbose:"         , true  }
   };
   std::ostringstream oss;

#ifdef PEGASUS_DEBUG
   if (getenv("PEGASUS_JMPI_TRACE"))
      JMPIjvm::trace = 1;
   else
      JMPIjvm::trace = 0;
#else
   JMPIjvm::trace = 0;
#endif

   DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM()" << PEGASUS_STD(endl));

   jv.initRc = 0;

   envstring = getenv("CLASSPATH");
   if (envstring == NULL)
   {
      jv.initRc = 1;

      DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl));

#ifdef PEGASUS_PLATFORM_ZOS_ZSERIES_IBM
      throw PEGASUS_CIM_EXCEPTION_L(
                 CIM_ERR_FAILED,
                 MessageLoaderParms(
                     "ProviderManager2.JMPI.JMPIImpl.GET_CLASSPATH_FAILED.PEGASUS_OS_ZOS",
                     "Could not get CLASSPATH from environment."
                     " Either CLASSPATH is longer than 255 characters"
                     " or not set at all.")
                 );
#else
      throw PEGASUS_CIM_EXCEPTION_L(
                 CIM_ERR_FAILED,
                 MessageLoaderParms(
                     "ProviderManager2.JMPI.JMPIImpl.GET_CLASSPATH_FAILED.STANDARD",
                     "Could not get CLASSPATH from environment.")
                 );
#endif
      return -1;
   }

///JNIoptions.append ("-Djava.compiler=NONE");
///maxoption++;

   for (Uint32 i = 0; i < (int)(sizeof (aEnvOptions)/sizeof (aEnvOptions[0])); i++)
   {
      JVMOPTIONS *pEnvOption = &aEnvOptions[i];

      envstring = getenv (pEnvOption->pszEnvName);
      if (envstring)
      {
         if (pEnvOption->fSplit)
         {
            bool              fCommaFound  = true;
            string            stringValues = envstring;
            string::size_type posStart     = 0;
            string::size_type posEnd       = stringValues.length () - 1;

            while (fCommaFound)
            {
               string            stringValue;
               string::size_type posComma    = stringValues.find (',', posStart);

               if (posComma != string::npos)
               {
                  fCommaFound = true;
                  stringValue = stringValues.substr (posStart, posComma);