/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
/* -*-C++-*-
******************************************************************************
*
* File:         LmJavaExceptionReporter.cpp
* Description:  Java Exception Reporting Mechanism
*
* Created:      08/21/2003
* Language:     C++
*
*
******************************************************************************
*/
#include "Platform.h"
  #include "lmjni.h"
#include "LmJavaExceptionReporter.h"
	
LmJavaExceptionReporter::LmJavaExceptionReporter(LmHandle jniEnv,
                                                LmLanguageManagerJava *langMan,
                                                LmResult &result,
                                                ComDiagsArea *diagsArea)
 : jniEnv_(jniEnv),
   langMan_(langMan),
   throwableClass_(NULL),
   throwableToStringId_(NULL),
   throwableGetCauseId_(NULL),
   exSQLClass_(NULL),
   exSQLStateId_(NULL),
   exErrorCodeId_(NULL),
   exNextExceptionId_(NULL),
   exMetValFailedClass_(NULL),
   exGetMethodName_(NULL),
   exGetSignature_(NULL)
{
  if (loadThrowable(diagsArea) == LM_ERR ||
      loadSQLException(diagsArea) == LM_ERR ||
      loadMethodValidationFailedException(diagsArea) == LM_ERR)
  {
    result = LM_ERR;
    return;
  }
}


LmJavaExceptionReporter::~LmJavaExceptionReporter()
{
  JNIEnv *jni = (JNIEnv*) jniEnv_;

  if (throwableClass_)
    jni->DeleteGlobalRef((jobject) throwableClass_);

  if (exSQLClass_)
    jni->DeleteGlobalRef((jobject) exSQLClass_);

  if (exMetValFailedClass_)
    jni->DeleteGlobalRef((jobject) exMetValFailedClass_);
}

//
// loadThrowable: loads java.lang.Throwable and some of its methods.
//
LmResult
LmJavaExceptionReporter::loadThrowable(ComDiagsArea *diagsArea)
{
  JNIEnv *jni = (JNIEnv *) jniEnv_;
  jclass jc = NULL;

  jc = (jclass) jni->FindClass("java/lang/Throwable");
  if (jc != NULL)
  {
    throwableClass_ = (jclass) jni->NewGlobalRef(jc);
    jni->DeleteLocalRef(jc);

    if (throwableClass_ != NULL)
    {
      throwableToStringId_ = jni->GetMethodID((jclass) throwableClass_,
                                              "toString",
                                              "()Ljava/lang/String;");
      throwableGetCauseId_ = jni->GetMethodID((jclass) throwableClass_,
                                              "getCause",
                                              "()Ljava/lang/Throwable;");
     }
  }

  // *** we tolerate throwableGetCauseId_ being NULL because
  // it is a new feature in JDK 1.4. Need to change this when
  // we move to JDK1.4
  if (throwableClass_ == NULL || throwableToStringId_ == NULL)
  {
    *diagsArea << DgSqlCode(-LME_JVM_SYS_CLASS_ERROR)
               << DgString0("java.lang.Throwable");
    return LM_ERR;
  }

  // We may get to this point with a pending exception in the JVM if
  // the getCause() method was not found. We will tolerate that
  // condition, clear the pending exception, and proceed.
  jni->ExceptionClear();
  return LM_OK;
}

//
// loadSQLException: Loads java.sql.SQLException
//
LmResult
LmJavaExceptionReporter::loadSQLException(ComDiagsArea *diagsArea)
{
  jclass jc = NULL;
  JNIEnv *jni = (JNIEnv *) jniEnv_;

  jc = (jclass) jni->FindClass("java/sql/SQLException");
  if (jc != NULL)
  {
    exSQLClass_ = (jclass) jni->NewGlobalRef(jc);
    jni->DeleteLocalRef(jc);

    if (exSQLClass_ != NULL)
    {
      exSQLStateId_ = jni->GetMethodID((jclass) exSQLClass_,
                                       "getSQLState",
                                       "()Ljava/lang/String;");
      exErrorCodeId_ = jni->GetMethodID((jclass) exSQLClass_,
                                        "getErrorCode", "()I");
      exNextExceptionId_ = jni->GetMethodID((jclass) exSQLClass_,
                                            "getNextException",
                                            "()Ljava/sql/SQLException;");
    }
  }

  if (exSQLClass_ == NULL    || exSQLStateId_ == NULL      ||
      exErrorCodeId_ == NULL || exNextExceptionId_ == NULL ||
      jni->ExceptionOccurred())
  {
    insertDiags(diagsArea, -LME_JVM_SYS_CLASS_ERROR, "java.sql.SQLException");
    return LM_ERR;
  }

  return LM_OK;
}

//
// loadMethodValidationFailedException: Loads org.trafodion.sql.udr
//  MethodValidationFailedException class
//
LmResult
LmJavaExceptionReporter::loadMethodValidationFailedException(
  ComDiagsArea *diagsArea)
{
  jclass jc = NULL;
  JNIEnv *jni = (JNIEnv *) jniEnv_;

  jc = (jclass)
        jni->FindClass("org/trafodion/sql/udr/MethodValidationFailedException");

  if (jc != NULL)
  {
    exMetValFailedClass_ = (jclass) jni->NewGlobalRef(jc);
    jni->DeleteLocalRef(jc);

    if (exMetValFailedClass_ != NULL)
    {
      exGetMethodName_ = jni->GetMethodID((jclass) exMetValFailedClass_,
                                          "getMethodName",
                                          "()Ljava/lang/String;");
      exGetSignature_ = jni->GetMethodID((jclass) exMetValFailedClass_,
                                         "getMethodSignature",
                                         "()Ljava/lang/String;");
    }
  }

  if (exGetMethodName_ == NULL || exGetSignature_ == NULL  ||
      jni->ExceptionOccurred())
  {
    insertDiags(diagsArea,
                -LME_JVM_SYS_CLASS_ERROR,
                "org.trafodion.sql.udr.MethodValidationFailedException");
    return LM_ERR;
  }

  return LM_OK;
}

//
// checkJVMException(): Raises an error for JVM's exception
// if there is any and adds a condition for each JVM exception.
// If 'exception' parameter is not NULL that will be used as exception.
//
// Returns: LM_OK  if there is no exception
//          LM_ERR if there is an exception
//
LmResult
LmJavaExceptionReporter::checkJVMException(ComDiagsArea *da,
                                           LmHandle exception)
{
  JNIEnv *jni = (JNIEnv*)jniEnv_;
  jthrowable jex = NULL;
  LmResult result = LM_OK;

  // This boolean will track whether this method owns a reference to
  // the current exception object, or whether the caller owns the
  // reference. This method must release any of its own references
  // before it returns.
  NABoolean callerOwnsTheCurrentException;

  if (exception == NULL)
  {
    jex = jni->ExceptionOccurred();
    callerOwnsTheCurrentException = FALSE;
  }
  else
  {
    jex = (jthrowable) exception;
    callerOwnsTheCurrentException = TRUE;
  }

  if (jex != NULL)
  {
    result = LM_ERR;
  }

  //
  // ExceptionDescribe() prints the exception information including
  // the stack trace to standard error. We want to do this so that
  // user can see the stack. But right now we see two errors if we
  // enable this
  // 1. ":" missing in exception message java.lang.NullPointerException
  //     TEST501
  // 2. 11229 error with message "Exception in thread "main" "
  // So we are commenting calls to ExceptionDescribe().
  //
  // jni->ExceptionDescribe();
  jni->ExceptionClear();

  // Each iteration of this while loop will add a diags condition for
  // the current exception jex, then move jex to point to the next
  // exception in the chain.
  while (jex != NULL)
  {
    addJavaExceptionToDiags(jex, *da);
    jthrowable next = (jthrowable) getNextChainedException(jex);

    if (!callerOwnsTheCurrentException)
    {
      jni->DeleteLocalRef(jex);
    }

    jex = next;
    callerOwnsTheCurrentException = FALSE;
  }

  jni->ExceptionClear();
  return result;
}


//
// checkNewObjectExceptions(): checks for exceptions after a JNI
// call to create a new Java Object, populate diags with exception
// messages.
//
// Returns  LM_OK  if the jobj is not NULL and there is no
//                 exception occurred
//          LM_ERR otherwise
//
LmResult
LmJavaExceptionReporter::checkNewObjectExceptions(LmHandle jobj,
                                                  ComDiagsArea *da)
{
  JNIEnv *jni = (JNIEnv*)jniEnv_;
  jthrowable jt = jni->ExceptionOccurred();
  // jni->ExceptionDescribe();
  jni->ExceptionClear();

  if(jt == NULL)
  {
    if(jobj)
    {
      return LM_OK;
    }
    else
    {
      *da << DgSqlCode(-LME_INTERNAL_ERROR)
          << DgString0(": a JNI error was encountered but no exception was found in the Java Virtual machine.");
      return LM_ERR;
    }
  }
  else
  {
    jstring jstr =
      (jstring) jni->CallObjectMethod(jt, (jmethodID) throwableToStringId_);
    if (jstr)
    {
      const char *msg = jni->GetStringUTFChars(jstr, NULL);
      if ((str_cmp(msg, "java.lang.OutOfMemoryError", 28) == 0))
      {
        *da << DgSqlCode(-LME_JVM_OUT_OF_MEMORY)
            << DgString0(msg);
      }
      else
      {
        *da << DgSqlCode(-LME_JAVA_EXCEPTION)
            << DgString0(msg);
      }

      jni->ReleaseStringUTFChars(jstr, msg);
      jni->DeleteLocalRef(jstr);
    }
    else
    {
      *da << DgSqlCode(-LME_JAVA_EXCEPTION);
    }

    jthrowable next = (jthrowable) getNextChainedException(jt);
    if (next)
    {
      checkJVMException(da, next);
      jni->DeleteLocalRef(next);
    }

    jni->DeleteLocalRef(jt);
    jni->ExceptionClear();
    return LM_ERR;
  }
}


//
// addJavaExceptionToDiags(): Adds a single diags condition
// describing an uncaught Java exception.
//
// Returns  Nothing
//
void
LmJavaExceptionReporter::addJavaExceptionToDiags(LmHandle throwable,
                                                 ComDiagsArea &diags)
{
  JNIEnv *jni = (JNIEnv *) jniEnv_;
  jthrowable t = (jthrowable) throwable;
  const char *msg;

  if (t)
  {
    if (!throwableToStringId_)
    {
      // We should never get here. For some reason the Throwable class
      // and its methods have not been loaded yet.
      msg = ": A Java exception was thrown but the Language Manager was unable to retrieve the message text.";
      diags << DgSqlCode(-LME_INTERNAL_ERROR) << DgString0(msg);
    }
    else
    {
      jstring jstr =
        (jstring) jni->CallObjectMethod(t, (jmethodID) throwableToStringId_);

      if (jstr != NULL)
      {
        msg = jni->GetStringUTFChars(jstr, NULL);
        diags << DgSqlCode(-LME_JVM_EXCEPTION) << DgString0(msg);
        jni->ReleaseStringUTFChars(jstr, msg);
        jni->DeleteLocalRef(jstr);
      }
      else
      {
        // An exception occurred but it contains no message
        msg = ": A Java exception with no message text was thrown.";
        diags << DgSqlCode(-LME_INTERNAL_ERROR) << DgString0(msg);
      }
    }
  }

  jni->ExceptionClear();
}


//
// getNextChainedException(): Return a reference to the
// next chained Java exception. This method attempts to
// avoid method lookups by name if possible, using cached
// class references and method IDs if they have non-NULL values.
//
// Returns LmHandle to next exception
//         NULL if there is no next exception
//
LmHandle
LmJavaExceptionReporter::getNextChainedException(LmHandle throwable)
{
  if (throwable == NULL)
  {
    return NULL;
  }

  JNIEnv *jni = (JNIEnv *) jniEnv_;
  LmHandle result = NULL;
  jthrowable t = (jthrowable) throwable;
  jmethodID methodID;

  jclass classRef = jni->GetObjectClass((jobject) t);
  jni->ExceptionClear();

  if (classRef)
  {
    // 1. Is this a SQLException?
    if (exSQLClass_ != NULL &&
        jni->IsInstanceOf(t, (jclass) exSQLClass_) == JNI_TRUE)
    {
      methodID = (jmethodID) exNextExceptionId_;
    }
    else
    {
      methodID = (jmethodID) jni->GetMethodID(classRef, "getNextException",
                                              "()Ljava/sql/SQLException;");
    }
    jni->ExceptionClear();

    // 2. If not, does this object have a getCause() method?
    //    The getCause() chaining framework is new in JDK 1.4
    if (methodID == NULL)
    {
      if (throwableClass_ != NULL)
      {
        methodID = (jmethodID) throwableGetCauseId_;
      }
      else
      {
        methodID = (jmethodID) jni->GetMethodID(classRef, "getCause",
                                                "()Ljava/lang/Throwable;");
      }
      jni->ExceptionClear();
    }

    // 3. If not, does the object happen to have a getException() method?
    //    Some Throwable subclasses supported this method for exception
    //    chaining before the getCause() framework arrived in JDK 1.4.
    if (methodID == NULL)
    {
      methodID = (jmethodID) jni->GetMethodID(classRef, "getException",
                                              "()Ljava/lang/Throwable;");
      jni->ExceptionClear();
    }

    if (methodID)
    {
      result = (LmHandle) jni->CallObjectMethod(t, methodID);
      jni->ExceptionClear();
    }

    jni->DeleteLocalRef(classRef);

  } // if (classRef)

  jni->ExceptionClear();
  return result;
}

//
// insertDiags() : Inserts conditions into diags area. 
// This method works only with error messages that take string
// parameters. Typically this method is called when the calling
// method wants to insert a condition as main SQLCode and one
// condition for every exception in the exception chain. Currently
// this method can accept at most 2 params to the condition item.
// This method calls checkJVMException() to insert conditions
// for JVM exceptions.
//
// Returns: LM_ERR unconditionally
//
LmResult
LmJavaExceptionReporter::insertDiags(ComDiagsArea *diags,
                                     Int32 errCode,
                                     const char *arg1,
                                     const char *arg2,
                                     LmHandle jt)
{
  Int32 numArgs;

  numArgs = (arg2 == NULL)? ((arg1 == NULL)? 0 : 1) : 2;

  // This is mainSQLCode in the diags area
  switch (numArgs)
  {
    case 0:
    {
      *diags << DgSqlCode(errCode);
       break;
    }

    case 1:
    {
      *diags << DgSqlCode(errCode)
             << DgString0(arg1);
       break;
    }

    case 2:
    {
      *diags << DgSqlCode(errCode)
             << DgString0(arg1)
             << DgString1(arg2);
      break;
    }
  }

  // Insert a diags condition for every exception in exception chain.
  checkJVMException(diags, jt);

  return LM_ERR;
}


//
// checkGetMethodExceptions() : checks for possible exceptions after
// a call to jni GetMethodID(). GetMethodID() can throw
// NoSuchMethodError, ExceptionInInitializerError, or OutOfMemoryError.
//
LmResult
LmJavaExceptionReporter::checkGetMethodExceptions(const char   *routineName,
                                                  const char   *className,
                                                  ComDiagsArea *da)
{
  JNIEnv *jni = (JNIEnv*)jniEnv_;
  jthrowable jt;

  if ((jt = jni->ExceptionOccurred()) == NULL)
  {
    *da << DgSqlCode(-LME_INTERNAL_ERROR)
        << DgString0(": A JNI error was encountered but no exception was found in the Java Virtual Machine.");
     return LM_ERR;
  }

  // jni->ExceptionDescribe();
  jni->ExceptionClear();

  jstring jstr = (jstring)
    jni->CallObjectMethod(jt, (jmethodID) throwableToStringId_);

  if (jstr != NULL)
  {
    const char *msg = jni->GetStringUTFChars(jstr, NULL);

    if ((str_cmp(msg, "java.lang.ExceptionInInitializerError", 37)) == 0)
    {
      insertDiags(da, -LME_CLASS_INIT_FAIL, className, NULL, jt);
    }
    else if ((str_cmp(msg, "java.lang.OutOfMemoryError", 28) == 0))
    {
      insertDiags(da, -LME_JVM_OUT_OF_MEMORY, NULL, NULL, jt);
    }
    else
    {
      insertDiags(da, -LME_ROUTINE_NOT_FOUND, routineName, className, jt);
    }

    jni->ReleaseStringUTFChars(jstr, msg);
    jni->DeleteLocalRef(jstr);
  }
  else
  {
    // Exception occurred, but no message
    *da << DgSqlCode(-LME_INTERNAL_ERROR)
        << DgString0(": Unknown error occurred.");
  }

  jni->DeleteLocalRef(jt);
  jni->ExceptionClear();
  return LM_ERR;
}

//
// processUserException(): Processes possible uncaught Java exceptions.
// If no exception occurred, returns OK. In the event of an exception,
// diagsArea is filled with proper error message.
//
// The SQLSTATE value is set according to section 13 'Status Code' of JRT.
//
// 38000 - For standard java exceptions.
// 38??? - For SQL exceptions(java.sql.Exception) when Class = 38
//         and Subclass != 000. So valid SQLSTATE values from Java method
//         are between 38001 to 38999
// 39001 - For all other SQL exceptions(java.sql.Exception) ie. for
//         SQL exceptions with invalid SQLSTATE value
//
LmResult
LmJavaExceptionReporter::processUserException(LmRoutineJava *routine_handle,
                                              ComDiagsArea *da)
{
  jthrowable jex;
  JNIEnv *jni = (JNIEnv*)jniEnv_;
  char errText[LMJ_ERR_SIZE_512];

  // Get Java exception if one occurred.
  if ((jex = jni->ExceptionOccurred()) == NULL)
    return LM_OK;

  // jni->ExceptionDescribe();
  jni->ExceptionClear();

  jstring jstr = (jstring)
    jni->CallObjectMethod(jex, (jmethodID) throwableToStringId_);

  if (jstr != NULL)
  {
    // Record exception error text.
    const char *msg = jni->GetStringUTFChars(jstr, NULL);

    Int32 len = min(str_len(msg), (LMJ_ERR_SIZE_512 - 1));
    str_cpy_all(errText, msg, len);
    errText[len] = '\0';

    if (str_cmp(errText, "java.sql", 8) == 0 ||
        str_cmp(errText, "com.hp.jdbc.HPT4Exception", 25) == 0)
    {
      reportUserSQLException(jex, errText, da);
    }
    else if (routine_handle->isInternalSPJ())
    {
      reportInternalSPJException(jex, errText, da);
    }
    else
    {
       *da << DgSqlCode(-LME_JAVA_EXCEPTION)
           << DgString0(errText);
    }

    jni->ReleaseStringUTFChars(jstr, msg);
    jni->DeleteLocalRef(jstr);
  }

  // Now insert the remaining error messages into diags
  jthrowable next = (jthrowable) getNextChainedException(jex);
  if (next)
  {
    checkJVMException(da, next);
    jni->DeleteLocalRef(next);
  }

  jni->DeleteLocalRef(jex);
  jni->ExceptionClear();

  return LM_ERR;
}

//
// reportUserSQLException(): populates the diags for SQLException.
// Look at the comments of processUserException().
//
void
LmJavaExceptionReporter::reportUserSQLException(LmHandle jt,
                                                char *errText,
                                                ComDiagsArea *da)
{
  JNIEnv *jni = (JNIEnv*)jniEnv_;
  jthrowable jex = (jthrowable) jt;
  char sqlState[6];

  // Get the error code, SQLState
  Int32 errcode = (Int32) jni->CallIntMethod((jobject)jex,
                                         (jmethodID)exErrorCodeId_);
  jstring jsstate = (jstring)
                    jni->CallObjectMethod(jex, (jmethodID)exSQLStateId_);
  if (jsstate != NULL)
  {
    const char *sstate = jni->GetStringUTFChars(jsstate, NULL);
    // Check for the validity of the SQLSTATE
    if (sstate != NULL &&
        str_len(sstate) >= 5 &&
        str_cmp(&sstate[0],  "38", 2) == 0 &&
        str_cmp(&sstate[2], "000", 3) != 0)
    {
      // Valid sqlstate. Report this as LME_CUSTOM_ERROR
      // with sqlState as SQLSTATE of LME_CUSTOM_ERROR.
      str_cpy_all(sqlState, sstate, 5);
      sqlState[5] = '\0';
      *da << DgSqlCode(-LME_CUSTOM_ERROR)
          << DgString0(errText)
          << DgString1(sqlState)
          << DgCustomSQLState(sqlState);
    }
    else
    {
      // Invalid sqlstate. Report this value wrapped in the message
      // of LME_JAVA_SQL_EXCEPTION_INVALID. The sqlstate of the reported
      // message is 39001.
      Int32 min_len = min(str_len(sstate), 5); // interested only upto 5 chars
      str_cpy_all(sqlState, sstate, min_len);
      sqlState[min_len] = '\0';
      *da << DgSqlCode(-LME_JAVA_SQL_EXCEPTION_INVALID)
          << DgInt0(errcode)
          << DgString0(sqlState)
          << DgString1(errText);
    }

    if (sstate != NULL)
      jni->ReleaseStringUTFChars(jsstate, sstate);
    jni->DeleteLocalRef(jsstate);
  } // if (jsstate != NULL)
  else
  {
    // sqlstate is not specified.
    // LME_JAVA_SQL_EXCEPTION_INVALID is reported
    sqlState[0] = '\0';
    *da << DgSqlCode(-LME_JAVA_SQL_EXCEPTION_INVALID)
        << DgInt0(errcode)
        << DgString0(sqlState)
        << DgString1(errText);
  }

  return;
}

//
// reportInternalSPJException(): populates the diags for
// MethodValidationException. This exception is thrown by
// the internal SPJ VALIDATEROUTINE.
//
void
LmJavaExceptionReporter::reportInternalSPJException(LmHandle jt,
                                                    char *errText,
                                                    ComDiagsArea *da)
{
  JNIEnv *jni = (JNIEnv*)jniEnv_;
  jthrowable jex = (jthrowable) jt;

  jstring metNameStr = NULL;
  jstring metSigStr = NULL;
 
  if (exMetValFailedClass_ != NULL &&
      jni->IsInstanceOf(jex, (jclass) exMetValFailedClass_))
  {
    metNameStr = (jstring)
      jni->CallObjectMethod(jex, (jmethodID) exGetMethodName_);
    metSigStr = (jstring)
      jni->CallObjectMethod(jex, (jmethodID) exGetSignature_);
  }

  if (metNameStr != NULL && metSigStr != NULL)
  {
    const char *metName = jni->GetStringUTFChars(metNameStr, NULL);
    const char *metSig = jni->GetStringUTFChars(metSigStr, NULL);

    LmJavaSignature lmSig(metSig, collHeap());
    ComSInt32 unpackedSigSize = lmSig.getUnpackedSignatureSize();
    ComUInt32 totLen = str_len(metName) + unpackedSigSize;
    char *signature = new (collHeap()) char[totLen + 1];

    sprintf(signature, "%s", metName);
    lmSig.unpackSignature(signature + str_len(metName));
    signature[totLen] = '\0';

    *da << DgSqlCode(-LME_VALIDATION_FAILED)
        << DgString0(signature)
        << DgString1(errText);

    jni->ReleaseStringUTFChars(metNameStr, metName);
    jni->DeleteLocalRef(metNameStr);
    jni->ReleaseStringUTFChars(metSigStr, metSig);
    jni->DeleteLocalRef(metSigStr);

    if (signature) NADELETEBASIC(signature, collHeap());

  }
  else
  {
    *da << DgSqlCode(-LME_JAVA_EXCEPTION)
        << DgString0(errText);

    if (metNameStr) jni->DeleteLocalRef(metNameStr);
    if (metSigStr) jni->DeleteLocalRef(metSigStr);
  }

}

//
// reportJavaObjException(): populates the diags for
// a return status returned in an LmUDRObjMethodInvoke.ReturnInfo
// object used in the Java object interface
void
LmJavaExceptionReporter::processJavaObjException(
     LmHandle returnInfoObj,
     int returnStatus,
     int callPhase,
     const char *errText,
     const char *udrName,
     ComDiagsArea *da)
{
  if (da)
    {
      JNIEnv *jni = (JNIEnv*)jniEnv_;
      const char *sqlState = NULL;
      const char *message = NULL;
      jobject jniResult = (jobject) returnInfoObj;
      jstring returnedSQLState =
        static_cast<jstring>(jni->GetObjectField(
           jniResult, 
           (jfieldID) langMan_->getReturnInfoSQLStateField()));
      jstring returnedMessage =
        static_cast<jstring>(jni->GetObjectField(
           jniResult, 
           (jfieldID) langMan_->getReturnInfoMessageField()));

      if (returnedSQLState != NULL)
        sqlState = jni->GetStringUTFChars(returnedSQLState, NULL);
      if (returnedMessage != NULL)
        message = jni->GetStringUTFChars(returnedMessage, NULL);

      if (sqlState || message)
        {
          const char *diagsMessage =
            (message ? message : "no message provided");
          const char *diagsSQLState =
            (sqlState ? sqlState : "no SQLSTATE provided");

          // Check the returned SQLSTATE value and raise appropriate
          // SQL code. Valid SQLSTATE values begin with "38" except "38000"
          if (sqlState &&
              (strncmp(diagsSQLState, "38", 2) == 0) &&
              (strncmp(diagsSQLState, "38000", 5) != 0))
            {
              *da << DgSqlCode(-LME_CUSTOM_ERROR)
                  << DgString0(diagsMessage)
                  << DgString1(diagsSQLState);
              *da << DgCustomSQLState(diagsSQLState);
            }
          else
            {
              *da << DgSqlCode(-LME_UDF_ERROR)
                  << DgString0(udrName)
                  << DgString1(diagsSQLState)
                  << DgString2(diagsMessage);
            }
        }
      else
        {
          // Report the return status as an internal error, since
          // we didn't get a UDRException. This should be rare, since
          // Java exceptions are caught above.
          char buf1[4];
          snprintf(buf1, sizeof(buf1), "%d", callPhase);
          char buf2[80];
          snprintf(buf2, sizeof(buf2), "Return status %d from JNI call", returnStatus);

          *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
              << DgString0(udrName)
              << DgString1(buf1)
              << DgString2(errText)
              << DgString3(buf2);
        }
      if (sqlState)
        jni->ReleaseStringUTFChars(returnedSQLState, sqlState);
      if (message)
        jni->ReleaseStringUTFChars(returnedMessage, message);
      if (returnedSQLState)
        jni->DeleteLocalRef(returnedSQLState);
      if (returnedMessage)
        jni->DeleteLocalRef(returnedMessage);
    }
}