stafrexxservice.cpp

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

        RXSTRING initArgs[3] = { 0 };

        // XXX: Check use of pInfo->parms here

        STAFStringBufferPtr serviceName = pData->fName.toCurrentCodePage();
        STAFStringBufferPtr initParms =
                            STAFString(pInfo->parms).toCurrentCodePage();
        STAFStringBufferPtr command = pData->fCommand.toCurrentCodePage();

        initArgs[0].strptr = const_cast<char *>(serviceName->buffer());
        initArgs[0].strlength = serviceName->length();
        initArgs[1].strptr = const_cast<char *>(initParms->buffer());
        initArgs[1].strlength = initParms->length();
        initArgs[2].strptr = const_cast<char *>(command->buffer());
        initArgs[2].strlength = command->length();

        if (pData->fInterfaceLevel == 30)
            rc = callRexx(pData, "STAFServiceInit", 30, initArgs, result);

        if (rc) *pErrorBuffer = result.adoptImpl();

        return rc;
    }
    catch (STAFException &e)
    { e.trace(); }
    catch (...)
    { /* Do Nothing */ }

    return kSTAFUnknownError;
}


unsigned int STAFServiceAcceptRequest(STAFServiceHandle_t serviceHandle,
                                      void *pRequestInfo, unsigned int reqLevel,
                                      STAFString_t *pResultBuffer)
{
    try
    {
        if (reqLevel != 30) return kSTAFInvalidAPILevel;

        RexxServiceData *pData =
                        reinterpret_cast<RexxServiceData *>(serviceHandle);
        STAFServiceRequestLevel30 *pInfo =
            reinterpret_cast<STAFServiceRequestLevel30 *>(pRequestInfo);
        STAFString result;    
        unsigned int rc = kSTAFUnknownError;

        STAFStringBufferPtr serviceName = pData->fName.toCurrentCodePage();
        STAFStringBufferPtr client =
                            STAFString(pInfo->machine).toCurrentCodePage();
        STAFStringBufferPtr machineNickname =
            STAFString(pInfo->machineNickname).toCurrentCodePage();
        STAFStringBufferPtr clientTrustLevel =
                            STAFString(pInfo->trustLevel).toCurrentCodePage();
        STAFStringBufferPtr handleName =
                            STAFString(pInfo->handleName).toCurrentCodePage();
        STAFStringBufferPtr handleString =
                            STAFString(pInfo->handle).toCurrentCodePage();
        STAFStringBufferPtr request =
                            STAFString(pInfo->request).toCurrentCodePage();

        if (pData->fInterfaceLevel == 30)
        {
            // XXX: Changed to remove localMachine and changed effective
            //      machine to machineNickname.  Still need to add user,
            //      endpoint, stafInstanceUUID, isLocalRequest, and
            //      physicalInterfaceID fields and then change whatever
            //      uses these requestArgs to use the new indexes for fields.
            RXSTRING requestArgs[7] = { 0 };

            requestArgs[0].strptr = const_cast<char *>(serviceName->buffer());
            requestArgs[0].strlength = serviceName->length();
            requestArgs[1].strptr = const_cast<char *>(client->buffer());
            requestArgs[1].strlength = client->length();
            requestArgs[2].strptr =
                const_cast<char *>(machineNickname->buffer());
            requestArgs[2].strlength = machineNickname->length();
            requestArgs[3].strptr =
                const_cast<char *>(clientTrustLevel->buffer());
            requestArgs[3].strlength = clientTrustLevel->length();
            requestArgs[4].strptr = const_cast<char *>(handleName->buffer());
            requestArgs[4].strlength = handleName->length();
            requestArgs[5].strptr = const_cast<char *>(handleString->buffer());
            requestArgs[5].strlength = handleString->length();
            requestArgs[6].strptr = const_cast<char *>(request->buffer());
            requestArgs[6].strlength = request->length();

            rc = callRexx(pData, "STAFServiceAcceptRequest", 8, requestArgs,
                          result);
        }

        *pResultBuffer = result.adoptImpl();

        return rc;
    }
    catch (STAFException &e)
    { e.trace(); }
    catch (...)
    { /* Do Nothing */ }

    return kSTAFUnknownError;
}


unsigned int STAFServiceTerm(STAFServiceHandle_t serviceHandle,
                             void *pTermInfo, unsigned int termLevel,
                             STAFString_t *pErrorBuffer)
{
    try
    {
        if (termLevel != 0) return kSTAFInvalidAPILevel;

        STAFString result;
        RXSTRING termArgs[1] = { 0 };
        RexxServiceData *pData =
                        reinterpret_cast<RexxServiceData *>(serviceHandle);
        STAFStringBufferPtr serviceName = pData->fName.toCurrentCodePage();

        termArgs[0].strptr = const_cast<char *>(serviceName->buffer());
        termArgs[0].strlength = serviceName->length();

        return callRexx(pData, "STAFServiceTerm", 1, termArgs, result);
    }
    catch (STAFException &e)
    { e.trace(); }
    catch (...)
    { /* Do Nothing */ }

    return kSTAFUnknownError;
}


unsigned int STAFServiceDestruct(STAFServiceHandle_t *serviceHandle,
                                 void *pDestructInfo,
                                 unsigned int destructLevel,
                                 STAFString_t *pErrorBuffer)
{
    try
    {
        if (destructLevel != 0) return kSTAFInvalidAPILevel;

        // XXX: Should we accept a pointer to the handle here, so that we can 0
        //      it out after the delete?

        RexxServiceData *pData =
            reinterpret_cast<RexxServiceData *>(*serviceHandle);

        delete pData;
        *serviceHandle = 0;

        return 0;
    }
    catch (STAFException &e)
    { e.trace(); }
    catch (...)
    { /* Do Nothing */ }

    return kSTAFUnknownError;
}


unsigned int callRexx(RexxServiceData *pData, std::string function,
                      unsigned int numParms, RXSTRING *parms,
                      STAFString &result)
{
    SHORT rexxRC = 0;
    LONG rc = 0;
    RXSTRING rexxResult = { 0 };
    RXSTRING inStore[2] = { 0 };

    if (pData->fDebugMode)
    {
        // First open the file

        ifstream sourceFile(pData->fCommand.toCurrentCodePage()->buffer(),
                            ios::binary | ios::in);
        if (!sourceFile)
        {
            result = "Error opening file: " + pData->fCommand;
            return kSTAFFileOpenError;
        }

        // Figure out how big it is

        sourceFile.seekg(0, ios::end);
        unsigned int fileLength = (unsigned int)sourceFile.tellg();

        // Initialize the source buffer

        inStore[0].strlength = fileLength;
        inStore[0].strptr = new char[fileLength];
        sourceFile.seekg(0, std::ios::beg);
        sourceFile.read(inStore[0].strptr, fileLength);
    }
    else
    {
        inStore[1].strptr = const_cast<char *>(pData->fTokenImage.data());
        inStore[1].strlength = pData->fTokenImage.length();
    }

    rc = RexxStart(numParms, parms, const_cast<char *>(function.c_str()),
                   inStore, 0, RXFUNCTION, 0, &rexxRC, &rexxResult);

    if (pData->fDebugMode)
    {
        // Free up the source image

        delete [] inStore[0].strptr;

        // Free up the sytem memory for the tokenized image

        STAFUtilFreeSystemMemory(inStore[1].strptr);
    }

    std::string resultString(rexxResult.strptr,
                             (unsigned int)rexxResult.strlength);

    if (rexxResult.strptr != 0)
        STAFUtilFreeSystemMemory(rexxResult.strptr);

    // XXX: We might want/need to add a STAFString constructor which takes
    //      a signed int

    if (rc != 0) result = STAFString(rc);

    // XXX: Not sure what to do about tracing

    if (rc < 0)
    {
        result = "-" + STAFString(static_cast<unsigned int>(-rc));

        return kSTAFREXXError;
    }
    else if (rc > 0)
    {
        result = STAFString(static_cast<unsigned int>(rc));

        return kSTAFBaseOSError;
    }
    else if (resultString.length() < 4)
    {
        return kSTAFInvalidServiceResult;
    }

    result = STAFString(&resultString.data()[4],
                        resultString.length() - 4);

    unsigned int realRC = *reinterpret_cast<unsigned int *>(
                          const_cast<char *>(resultString.substr(0,4).data()));

    // REXX Services assume the byte ordering is little-endian

    return STAFUtilConvertLEUIntToNative(realRC);
}