jstaf.cpp

Software Testing Automation Framework (STAF)的开发代码

            return createResultObject(env, kSTAFInvalidValue,
                   "Error getting UTF-8 service string");
        }
        else
        {
            return createResultObject(env, kSTAFInvalidValue,
                   "Error getting UTF-8 request string");
        }
    }

    char *result = 0;
    unsigned int resultLength = 0;
    unsigned int rc = STAFSubmit2UTF8(handle, syncOption, (char *)whereUTF,
                                  (char *)serviceUTF, (char *)requestUTF,
                                  strlen(requestUTF), &result, &resultLength);

    // Now free up the memory from the Java VM

    env->ReleaseStringUTFChars(where, whereUTF);
    env->ReleaseStringUTFChars(service, serviceUTF);
    env->ReleaseStringUTFChars(request, requestUTF);

    // Now, return the result object

    jobject returnResult = createResultObject(env, rc, result, resultLength);

    if (result != 0) STAFFree(handle, result);

    return returnResult;
}

/*
 * Class:     com_ibm_staf_STAFUtil
 * Method:    initialize
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_ibm_staf_STAFUtil_initialize
  (JNIEnv *, jclass)
{
    #if defined(STAF_OS_NAME_HPUX) && !defined(__ia64)
        _main();
    #endif

    initJVMStrings();
}

/*
 * Class:     com_ibm_staf_STAFUtil
 * Method:    STAFUtilAddPrivacyDelimiters
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_ibm_staf_STAFUtil_STAFUtilAddPrivacyDelimiters
  (JNIEnv *env, jclass theObject, jstring data)
{
    // Check if jstring is null because GetStringUTFChars core dumps if
    // pass it a null string.
    if (data == 0) return data;
    
    unsigned int dataUTFLength = env->GetStringUTFLength(data);
    const char *dataUTF = env->GetStringUTFChars(data, 0);
    
    if (dataUTF == 0)
    {
        // We could not get the UTF-8 version of data, so throw an
        // exception

        throwSTAFException(env, kSTAFInvalidValue,
                           "Error getting UTF-8 data string");
        return 0;
    }

    STAFString result;
    jstring javaResult = 0;

    try
    {
        result = STAFHandle::addPrivacyDelimiters(
            STAFString(dataUTF, dataUTFLength, STAFString::kUTF8));

        // Now free up the memory from the Java VM

        env->ReleaseStringUTFChars(data, dataUTF);

        // Now, generate a jstring for the result

        if (result.length() != 0)
        {
            // Convert the result string for Java to handle null chars
            result = result.replace(kUTF8_NULL, kUTF8_NULL2);
            result += kUTF8_NULL;
            javaResult = env->NewStringUTF(
                const_cast<char *>(result.buffer()));
        }
        else
        {
            javaResult = env->NewStringUTF("\00");
        }

        if (javaResult == 0)
        {
            throwSTAFException(env, kSTAFInvalidValue,
                               "Error creating result string");
        }
    }
    catch (STAFException e)
    {
        throwSTAFException(
            env, kSTAFInvalidValue,
            "Error - STAFHandle::addPrivacyDelimiters() failed");
    }
    
    // Now, return the jstring

    return javaResult;
}

/*
 * Class:     com_ibm_staf_STAFUtil
 * Method:    STAFUtilRemovePrivacyDelimiters
 * Signature: (Ljava/lang/String;I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_ibm_staf_STAFUtil_STAFUtilRemovePrivacyDelimiters
  (JNIEnv *env, jclass theObject, jstring data, jint numLevels)
{
    // Check if jstring is null because GetStringUTFChars core dumps if
    // pass it a null string.
    if (data == 0) return data;

    unsigned int dataUTFLength = env->GetStringUTFLength(data);
    const char *dataUTF = env->GetStringUTFChars(data, 0);
    
    if (dataUTF == 0)
    {
        // We could not get the UTF-8 version of data, so throw an
        // exception

        throwSTAFException(env, kSTAFInvalidValue,
                           "Error getting UTF-8 data string");
        return 0;
    }

    STAFString result;
    jstring javaResult = 0;

    try
    {
        result = STAFHandle::removePrivacyDelimiters(
            STAFString(dataUTF, dataUTFLength, STAFString::kUTF8), numLevels);

        // Now free up the memory from the Java VM

        env->ReleaseStringUTFChars(data, dataUTF);

        // Now, generate a jstring for the result

        if (result.length() != 0)
        {
            // Convert the result string for Java to handle null chars
            result = result.replace(kUTF8_NULL, kUTF8_NULL2);
            result += kUTF8_NULL;
            javaResult = env->NewStringUTF(
                const_cast<char *>(result.buffer()));
        }
        else
        {
            javaResult = env->NewStringUTF("\00");
        }

        if (javaResult == 0)
        {
            throwSTAFException(env, kSTAFInvalidValue,
                               "Error creating result string");
        }
    }
    catch (STAFException e)
    {
        throwSTAFException(
            env, kSTAFInvalidValue,
            "Error - STAFHandle::removePrivacyDelimiters() failed");
    }
    
    // Now, return the jstring

    return javaResult;
}

/*
 * Class:     com_ibm_staf_STAFUtil
 * Method:    STAFUtilMaskPrivateData
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_ibm_staf_STAFUtil_STAFUtilMaskPrivateData
  (JNIEnv *env, jclass theObject, jstring data)
{
    // Check if jstring is null because GetStringUTFChars core dumps if
    // pass it a null string.
    if (data == 0) return data;

    unsigned int dataUTFLength = env->GetStringUTFLength(data);
    const char *dataUTF = env->GetStringUTFChars(data, 0);
    
    
    if (dataUTF == 0)
    {
        // We could not get the UTF-8 version of data, so throw an
        // exception

        throwSTAFException(env, kSTAFInvalidValue,
                           "Error getting UTF-8 data string");
        return 0;
    }

    STAFString result;
    jstring javaResult = 0;

    try
    {
        result = STAFHandle::maskPrivateData(
            STAFString(dataUTF, dataUTFLength, STAFString::kUTF8));

        // Now free up the memory from the Java VM

        env->ReleaseStringUTFChars(data, dataUTF);

        // Now, generate a jstring for the result

        if (result.length() != 0)
        {
            // Convert the result string for Java to handle null chars
            result = result.replace(kUTF8_NULL, kUTF8_NULL2);
            result += kUTF8_NULL;
            javaResult = env->NewStringUTF(
                const_cast<char *>(result.buffer()));
        }
        else
        {
            javaResult = env->NewStringUTF("\00");
        }

        if (javaResult == 0)
        {
            throwSTAFException(env, kSTAFInvalidValue,
                               "Error creating result string");
        }
    }
    catch (STAFException e)
    {
        throwSTAFException(
            env, kSTAFInvalidValue,
            "Error - STAFHandle::maskPrivateData() failed");
    }
    
    // Now, return the jstring

    return javaResult;
}

/*
 * Class:     com_ibm_staf_STAFUtil
 * Method:    STAFUtilEscapePrivacyDelimiters
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_ibm_staf_STAFUtil_STAFUtilEscapePrivacyDelimiters
  (JNIEnv *env, jclass theObject, jstring data)
{
    // Check if jstring is null because GetStringUTFChars core dumps if
    // pass it a null string.
    if (data == 0) return data;

    unsigned int dataUTFLength = env->GetStringUTFLength(data);
    const char *dataUTF = env->GetStringUTFChars(data, 0);
    
    if (dataUTF == 0)
    {
        // We could not get the UTF-8 version of data, so throw an
        // exception

        throwSTAFException(env, kSTAFInvalidValue,
                           "Error getting UTF-8 data string");
        return 0;
    }

    STAFString result;
    jstring javaResult = 0;

    try
    {
        result = STAFHandle::escapePrivacyDelimiters(
            STAFString(dataUTF, dataUTFLength, STAFString::kUTF8));

        // Now free up the memory from the Java VM

        env->ReleaseStringUTFChars(data, dataUTF);

        // Now, generate a jstring for the result

        if (result.length() != 0)
        {
            // Convert the result string for Java to handle null chars
            result = result.replace(kUTF8_NULL, kUTF8_NULL2);
            result += kUTF8_NULL;
            javaResult = env->NewStringUTF(
                const_cast<char *>(result.buffer()));
        }
        else
        {
            javaResult = env->NewStringUTF("\00");
        }

        if (javaResult == 0)
        {
            throwSTAFException(env, kSTAFInvalidValue,
                               "Error creating result string");
        }
    }
    catch (STAFException e)
    {
        throwSTAFException(
            env, kSTAFInvalidValue,
            "Error - STAFHandle::escapePrivacyDelimiters() failed");
    }
    
    // Now, return the jstring

    return javaResult;
}


int throwSTAFException(JNIEnv *env, unsigned int rc, const char *utfString)
{
    jclass excClass = env->FindClass(sSTAFExceptionClass);

    if (excClass == 0)
    {
        // The Java VM threw an exception, so just return
        return 1;
    }

    jmethodID excInit = env->GetMethodID(excClass, sJavaConstructorMethod,
                                         sSTAFExceptionConstructorMethodSig);
    if (excInit == 0)
    {
        // The Java VM threw an exception, so just return
        return 1;
    }

    jstring javaString = 0;

    if (utfString != 0)
        javaString = env->NewStringUTF(utfString);
    else
        javaString = env->NewStringUTF("\00");

    // XXX: If javaString can not be created, I think we can create
    //      the exception object ok, but there may be a problem trying
    //      to print it out, as we will try to print out a null string.

    jobject exc = env->NewObject(excClass, excInit, (jint)rc, javaString);

    if (exc == 0)
    {
        // The Java VM threw an exception, so just return
        return 1;
    }

    env->Throw((jthrowable)exc);

    return 0;
}


jobject createResultObject(JNIEnv *env, unsigned int rc, const char *utfString,
                           const unsigned int resultLength)
{
    jclass resultClass = env->FindClass(sSTAFResultClass);

    if (resultClass == 0)
    {
        // The Java VM threw an exception, so just return
        return 0;
    }

    jmethodID resultInit = env->GetMethodID(resultClass, sJavaConstructorMethod,
                                            sSTAFResultConstructorMethodSig);
    if (resultInit == 0)
    {
        // The Java VM threw an exception, so just return
        return 0;
    }

    jstring javaString = 0;

    if (utfString != 0)
    {
        if (resultLength == 0)
        {
            javaString = env->NewStringUTF(utfString);
        }
        else
        {
            // Convert the result string for Java to handle null chars
            STAFString newResult = STAFString(utfString, resultLength,
                                              STAFString::kUTF8);
            newResult = newResult.replace(kUTF8_NULL, kUTF8_NULL2);
            newResult += kUTF8_NULL;

            javaString = env->NewStringUTF(const_cast<char *>
                         (newResult.buffer()));
        }
    }
    else
    {
        javaString = env->NewStringUTF("\00");
    }

    // XXX: If javaString can not be created, I think we can create
    //      the exception object ok, but there may be a problem trying
    //      to print it out, as we will try to print out a null string.

    jobject result = env->NewObject(resultClass, resultInit, (jint)rc,
                                    javaString);

    env->DeleteLocalRef(javaString);

    return result;
}