jmpiimpl.cpp

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

                  posStart    = posComma + 1;
               }
               else
               {
                  fCommaFound = false;
                  stringValue = stringValues.substr (posStart, posEnd - posStart + 1);
               }

               DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): fCommaFound = " << fCommaFound << ", posStart = " << posStart << ", posComma = " << posComma << ", posEnd = " << posEnd << "" << PEGASUS_STD(endl));

               maxoption++;

               oss.str ("");
               oss << pEnvOption->pszPrefix << stringValue;

               JNIoptions.append (oss.str ());

               DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found!  Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
            }
         }
         else
         {
            maxoption++;

            oss.str ("");
            oss << pEnvOption->pszPrefix << envstring;

            JNIoptions.append (oss.str ());

            DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found!  Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
         }
      }
   }

   poptions = (JavaVMOption *)calloc (maxoption, sizeof (JavaVMOption));
   if (!poptions)
   {
      jv.initRc = 1;

      DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Could not allocate " << maxoption << " structures of size " << sizeof (JavaVMOption) << PEGASUS_STD(endl));

      return -1;
   }

   for (Uint32 i = 0; i < JNIoptions.size(); i++)
   {
      poptions[i].optionString = (char *)JNIoptions[i].c_str ();

      DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl));
   }

   vm_args.version = JNI_VERSION_1_2;
   vm_args.options = poptions;
   vm_args.nOptions = maxoption;
   vm_args.ignoreUnrecognized = JNI_TRUE;

   res = JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);

   if (poptions)
   {
      free (poptions);
   }

   if (res!= 0)
   {
      jv.initRc = 1;

      DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));

      return -1;
   }

   cacheIDs(env);

   if (env->ExceptionOccurred())
   {
      jv.initRc = 1;

      env->ExceptionDescribe();

#ifdef JAVA_DESTROY_VM_WORKS

      JvmVector *jv = NULL;

      attachThread (&jv);

      jvm->DestroyJavaVM ();

      jvm = NULL;
#endif

      return -1;
   }

   jv.initRc = 1;
   jv.jvm = jvm;

   return res;
}

JNIEnv* JMPIjvm::attachThread (JvmVector **jvp)
{
   JNIEnv* env = NULL;
   int rc;

   if (jvm == NULL)
   {
      rc = initJVM ();

      if ((jvm == NULL) || (rc != 0))
         return NULL;
   }

   jvm->AttachCurrentThread ((void**)&env,NULL);

   *jvp = &jv;

   return env;
}

void JMPIjvm::detachThread ()
{
   jvm->DetachCurrentThread ();
}

jobject JMPIjvm::getProvider (JNIEnv     *env,
                              String      jarName,
                              String      className,
                              const char *pszProviderName,
                              jclass     *pjClass)
{
   jobject   jProviderInstance      = 0;
   jclass    jClassLoaded           = 0;
   jmethodID jId                    = 0;
   jobject   jProviderInstanceLocal = 0;

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jarName = "<<jarName<<", className = "<<className<<", pszProviderName = "<<pszProviderName<<", pjClass = "<<PEGASUS_STD(hex)<<(long)pjClass<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   // CASE #1
   //    className has been loaded previously.
   //    Return saved instance.
   _objectTable.lookup (className, jProviderInstance);
   _classTable.lookup (className, jClassLoaded);

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstance = "<<PEGASUS_STD(hex)<<(long)jProviderInstance<<", jClassLoaded = "<<(long)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (  jProviderInstance
      && jClassLoaded
      )
   {
      if (pjClass)
      {
         *pjClass = jClassLoaded;
      }

      return jProviderInstance;
   }

   // CASE #2
   //    className can be loaded via getGlobalClassRef ().
   //    Load and return the instance.
   // NOTE:
   //    According to http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/functions.html
   //    In JDK 1.1, FindClass searched only local classes in CLASSPATH.

   jClassLoaded = getGlobalClassRef (env,
                                     (const char*)className.getCString ());

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoaded = "<<PEGASUS_STD(hex)<<(long)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (env->ExceptionCheck ())
   {
      // CASE #3
      //    see if the className can be loaded via JarClassLoader.load ().
      //    Load and return the instance.
      jstring jJarName          = 0;
      jstring jClassName        = 0;
      jclass  jClassLoadedLocal = 0;

      env->ExceptionClear ();

      // NOTE: Instances of "packageName/className" will not work with the jar
      //       class loader.  Change the '/' to a '.'.
      String fixedClassName;
      Uint32 idx            = className.find ('/');

      if (idx != PEG_NOT_FOUND)
      {
         fixedClassName = className.subString (0, idx)
                        + "."
                        + className.subString (idx + 1);
      }
      else
      {
         fixedClassName = className;
      }

      DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: fixedClassName = "<<fixedClassName<<PEGASUS_STD(endl));

      jJarName   = env->NewStringUTF ((const char*)jarName.getCString ());
      jClassName = env->NewStringUTF ((const char*)fixedClassName.getCString ());

      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jJarName = "<<PEGASUS_STD(hex)<<(long)jJarName<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassName = "<<PEGASUS_STD(hex)<<(long)jClassName<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

      jClassLoadedLocal = (jclass)env->CallStaticObjectMethod (JMPIjvm::jv.JarClassLoaderClassRef,
                                                               JMPIjvm::jv.JarClassLoaderLoad,
                                                               jJarName,
                                                               jClassName);

      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoadedLocal = "<<PEGASUS_STD(hex)<<(long)jClassLoadedLocal<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

      if (env->ExceptionCheck ())
      {
         DDD (env->ExceptionDescribe ());

         DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

         return 0;
      }

      jClassLoaded = (jclass)env->NewGlobalRef (jClassLoadedLocal);

      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoaded = "<<PEGASUS_STD(hex)<<(long)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

      env->DeleteLocalRef (jClassLoadedLocal);
   }

   if (pjClass)
   {
      *pjClass = jClassLoaded;
   }

   if (!jClassLoaded)
   {
      DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

      return 0;
   }

   jId = env->GetMethodID (jClassLoaded,
                           "<init>",
                           "()V");

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jId = "<<PEGASUS_STD(hex)<<(long)jId<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   jProviderInstanceLocal = env->NewObject (jClassLoaded,
                                            jId);

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstanceLocal = "<<PEGASUS_STD(hex)<<(long)jProviderInstanceLocal<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (!jProviderInstanceLocal)
   {
      DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

      return 0;
   }

   jProviderInstance = (jobject)env->NewGlobalRef (jProviderInstanceLocal);

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstance = "<<PEGASUS_STD(hex)<<(long)jProviderInstance<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (!jProviderInstance)
   {
      DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

      return 0;
   }

   _classTable.insert (className, jClassLoaded);
   _objectTable.insert (className, jProviderInstance);

   return jProviderInstance;
}

jobject JMPIjvm::getProvider (JNIEnv *env, const char *cn, jclass *cls)
{
   String cln = cn;
   jobject gProv = NULL;
   jclass scls = NULL;

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));

   _objectTable.lookup(cln,gProv);
   _classTable.lookup(cln,scls);
   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(long)gProv<<", scls = "<<(long)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (gProv)
   {
      *cls = scls;
      return gProv;
   }

   scls = getGlobalClassRef(env,cn);
   if (env->ExceptionCheck())
   {
      DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));
      DDD(env->ExceptionDescribe());

      return NULL;
   }
   *cls = scls;

   if (scls)
   {
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(long)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      _classTable.insert(cln,scls);
   }

   jmethodID id = env->GetMethodID(*cls,"<init>","()V");
   jobject lProv = env->NewObject(*cls,id);
   gProv = (jobject)env->NewGlobalRef(lProv);
   if (env->ExceptionCheck())
   {
      DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));
      return NULL;
   }

   if (gProv)
   {
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(long)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      _objectTable.insert(cln,gProv);
   }

   return gProv;
}

void JMPIjvm::checkException (JNIEnv *env)
{
   if (env->ExceptionCheck ())
   {
      jstring     jMsg = NULL,
                  jId  = NULL;
      int         code;
      const char *cp;
      String      msg  = String::EMPTY,
                  id   = String::EMPTY;
      jthrowable  err  = env->ExceptionOccurred();

      DDD(env->ExceptionDescribe());

      if (env->IsInstanceOf (err, JMPIjvm::jv.CIMExceptionClassRef))
      {
         env->ExceptionClear ();
         if (err)
         {
            jMsg = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.ThrowableGetMessage);
            code = (int)env->CallIntMethod (err, JMPIjvm::jv.CIMExceptionGetCode);
            jId  = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.CIMExceptionGetID);

            if (jId)
            {
               cp = env->GetStringUTFChars (jId, NULL);
               id = String (cp);
               env->ReleaseStringUTFChars (jId, cp);
            }

            if (jMsg)
            {
               cp  = env->GetStringUTFChars (jMsg, NULL);
               msg = String (cp);
               env->ReleaseStringUTFChars (jMsg, cp);
            }

            DDD(PEGASUS_STD(cerr)<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<PEGASUS_STD(endl));

            throw CIMException ((CIMStatusCode)code, id+" ("+msg+")");
         }
      }
      else
      {
         DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::checkException: exiting..."<<PEGASUS_STD(endl));
         env->ExceptionDescribe();
         exit(13);
      }
   }
}

/**************************************************************************
 * name         - NewPlatformString
 * description  - Returns a new Java string object for the specified
 *                platform string.
 * parameters   - env
 *                s     Platform encoded string
 * returns      - Java string object pointer or null (0)
 **************************************************************************/
jstring JMPIjvm::NewPlatformString (JNIEnv *env, char *s)
{
    size_t     len = strlen(s);
    jclass     cls;
    jmethodID  mid;
    jbyteArray ary;

    NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));
    NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));

    ary = (*env).NewByteArray((jsize)len);
    if (ary != 0)
    {
        jstring str = 0;
        (*env).SetByteArrayRegion (ary,