staflogservice.cpp

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

                       "allowed by the DefaultMaxQueryRecords setting.  "
                       "Use the FIRST <Num> or LAST <Num> option to specify "
                       "the number of records or the ALL option if you "
                       "really want all of the records."));
    }
    catch (STAFException &e)
    {
        *pErrorBuffer = getExceptionString(e,
                        "STAFLogService.cpp: STAFServiceInit").adoptImpl();
    }
    catch (...)
    {
        STAFString error("STAFLogService.cpp: STAFServiceInit: Caught unknown "
                         "exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


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

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        STAFResultPtr result(new STAFResult(), STAFResultPtr::INIT);

        STAFServiceRequestLevel30 *pInfo =
            reinterpret_cast<STAFServiceRequestLevel30 *>(pRequestInfo);

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

        STAFString request(pInfo->request);
        STAFString action = request.subWord(0, 1).toUpperCase();

        if (pData->fRLogMode != 0)
        {
            if (action == sLOG) result = handleRemoteLog(pInfo, pData);
            else if (action == sVERSION)
            {
                result = STAFResultPtr(new STAFResult(kSTAFOk, sVersionInfo),
                                       STAFResultPtr::INIT);
            }
            else if ((action == sLIST) &&
                     (request.subWord(1, 2).toUpperCase() == sSETTINGS))
            {
                result = handleList(pInfo, pData);
            }
            else result = handleRemoteLogGeneral(pInfo, pData);
        }
        else if (action == sLOG)    result = handleLog(pInfo, pData);
        else if (action == sQUERY)  result = handleQuery(pInfo, pData);
        else if (action == sLIST)   result = handleList(pInfo, pData);
        else if (action == sDELETE) result = handleDelete(pInfo, pData);
        else if (action == sPURGE)  result = handlePurge(pInfo, pData);
        else if (action == sSET)    result = handleSet(pInfo, pData);
        else if (action == sHELP)   result = handleHelp(pInfo, pData);
        else if (action == sVERSION)
        {
            result = STAFResultPtr(new STAFResult(kSTAFOk, sVersionInfo),
                                   STAFResultPtr::INIT);
        }
        else
        {
            result = STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                                                  request.subWord(0, 1)),
                                   STAFResultPtr::INIT);
        }

        *pResultBuffer = result->result.adoptImpl();
        retCode = result->rc;
    }
    catch (STAFException &e)
    {
        *pResultBuffer = getExceptionString(e,
                         "STAFLogService.cpp: "
                         "STAFServiceAcceptRequest").adoptImpl();
    }
    catch (...)
    {
        STAFString error("STAFLogService.cpp: STAFServiceAcceptRequest: Caught "
                         "unknown exception in STAFServiceAcceptRequest()");
        *pResultBuffer = error.adoptImpl();
    }

    return retCode;
}


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

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        retCode = kSTAFOk;

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

        // Un-register Help Data

        unregisterHelpData(pData, kSTAFLogInvalidLevel);
        unregisterHelpData(pData, kSTAFLogInvalidFileFormat);
        unregisterHelpData(pData, kSTAFLogPurgeFailure);
    }
    catch (STAFException &e)
    {
        *pErrorBuffer = getExceptionString(e,
                        "STAFLogService.cpp: STAFServiceTerm").adoptImpl();
    }
    catch (...)
    {
        STAFString error("STAFLogService.cpp: STAFServiceTerm: Caught unknown "
                         "exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


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

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        LogServiceData *pData =
            reinterpret_cast<LogServiceData *>(*serviceHandle);
        delete pData;
        *serviceHandle = 0;

        retCode = kSTAFOk;
    }
    catch (STAFException &e)
    {
        *pErrorBuffer = getExceptionString(e,
                        "STAFLogService.cpp: STAFServiceDestruct").adoptImpl();
    }
    catch (...)
    {
        STAFString error("STAFLogService.cpp: STAFServiceDestruct: Caught "
                         "unknown exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


STAFResultPtr handleLog(STAFServiceRequestLevel30 *pInfo, LogServiceData *pData)
{
    // XXX: This routine in particular has serious issues when we add the
    //      ability to resolve remote handle variables.  It relies on functions
    //      which assume that the requestor is in the pInfo structure, which it
    //      may not be if we are a remote log server.

    INIT_TIMES();
    RECORD_TIME("Parsing");

    STAFCommandParseResultPtr parsedResult =
        pData->fLogParser->parse(pInfo->request);

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                             parsedResult->errorBuffer), STAFResultPtr::INIT);
    }

    RECORD_TIME("Check trust");

    // Verify that the requesting machine/user has at least trust level 3

    if (parsedResult->optionTimes(sRMTMACHINE) == 0)
    {
        VALIDATE_TRUST(3, pData->fShortName, "LOG", pData->fLocalMachineName);
    }
    else
    {
        // Verify that the remote log machine/user has at least trust level 3

        STAFString trustRequest(
            sGetMachine + parsedResult->optionValue(sRMTMACHINE) +
            sGetUser + parsedResult->optionValue(sRMTUSER));

        STAFResultPtr trustResult = pData->fHandle->submit(
            sLocal, sTrust, trustRequest);

        unsigned int trustLevel = trustResult->result.asUInt();

        VALIDATE_TRUST3(3, pData->fShortName, "LOG", pData->fLocalMachineName,
                        trustLevel, parsedResult->optionValue(sRMTMACHINE),
                        "", parsedResult->optionValue(sRMTUSER));
    }
    
    // Get log level and log mask and see if we should log

    RECORD_TIME("Check log level");

    STAFResultPtr levelResult = resolveOp(pInfo, pData, parsedResult, sLEVEL);

    if (levelResult->rc != kSTAFOk) return levelResult;

    unsigned int logLevel = 0;

    if (!isValidLogLevel(levelResult->result, logLevel))
    {
        return STAFResultPtr(new STAFResult(kSTAFLogInvalidLevel,
                                            levelResult->result),
                             STAFResultPtr::INIT);
    }

    STAFResultPtr logmaskResult = resolveStr(pInfo, pData,
                                             pData->fResolveLogMaskString);
    if ((logmaskResult->rc != kSTAFOk) &&
        (logmaskResult->rc != kSTAFVariableDoesNotExist))
    {
        return logmaskResult;
    }

    if (logmaskResult->rc == kSTAFVariableDoesNotExist)
        logmaskResult->result = sEverythingLogMask;

    unsigned int logMask = 0;

    if (!convertLogMaskToUInt(logmaskResult->result, logMask))
    {
        return STAFResultPtr(new STAFResult(kSTAFLogInvalidLevel,
                                            logmaskResult->result),
                             STAFResultPtr::INIT);
    }

    if (!(logLevel & logMask))
        return STAFResultPtr(new STAFResult, STAFResultPtr::INIT);

    // Get logname and message

    RECORD_TIME("Get logname and message");

    STAFResultPtr lognameResult = resolveOp(pInfo, pData, parsedResult,
                                            sLOGNAME);

    if (lognameResult->rc != kSTAFOk) return lognameResult;

    // if the user specifies to resolve messages or
    // STAF/Service/Log/ResolveMessage is enabled and set or
    // the default is to resolve messages and the user didn't say not to
    // then resolve the message

    STAFString message = parsedResult->optionValue(sMESSAGE);
    unsigned int resolveMessage = pData->fDefaultResolveMessage;

    if (parsedResult->optionTimes(sRESOLVEMESSAGE) != 0)
    {
        resolveMessage = 1;
    }
    else if (parsedResult->optionTimes(sNORESOLVEMESSAGE) != 0)
    {
        resolveMessage = 0;
    }
    else if (pData->fUseResolveMessageVar != 0)
    {
        STAFResultPtr resolveResult = resolveStr(pInfo, pData,
                                                 pData->fResolveMessageString);
        if (resolveResult->rc == kSTAFOk)
        {
            if (!resolveResult->result.isDigits())
            {
                return STAFResultPtr(new STAFResult(kSTAFInvalidValue,
                                                    resolveResult->result),
                                     STAFResultPtr::INIT);
            }

            if (resolveResult->result.asUInt() != 0)
                resolveMessage = 1;
            else
                resolveMessage = 0;
        }
        else if (resolveResult->rc != kSTAFVariableDoesNotExist)
        {
            return resolveResult;
        }
    }

    if (resolveMessage != 0)
    {
        STAFResultPtr messageResult = resolveOp(pInfo, pData, parsedResult,
                                                sMESSAGE);

        if (messageResult->rc != kSTAFOk) return messageResult;

        message = messageResult->result;
    }

    if (message.length(STAFString::kChar) > pData->fMaxRecordSize)
        message = message.subString(0, pData->fMaxRecordSize, STAFString::kChar);

    // Check for remote logging info

    RECORD_TIME("Check for remote");

    bool isRemote = false;
    STAFString remoteMachine;
    STAFString remoteHandleName;
    STAFString remoteHandle;
    STAFString remoteUser;
    STAFString remoteLogicalMachine;
    STAFString remoteNickname;

    if (parsedResult->optionTimes(sRMTMACHINE) != 0)
    {
        isRemote = true;
        remoteMachine = parsedResult->optionValue(sRMTMACHINE);
        remoteHandleName = parsedResult->optionValue(sRMTNAME);
        remoteHandle = parsedResult->optionVa