response_older.cpp

windows mobile RIL软件

    { RIL_E_OPNOTALLOWED,        2},
    { RIL_E_OPNOTALLOWED,        3},
    { RIL_E_OPNOTALLOWED,        4},
    { RIL_E_INVALIDDIALSTRING,   5},
    { RIL_E_INVALIDDIALSTRING,   6},
    { RIL_E_INVALIDDIALSTRING,   7},
    { RIL_E_INVALIDDIALSTRING,   8},
    { RIL_E_INVALIDDIALSTRING,   9},
    { RIL_E_INVALIDDIALSTRING,  10},
    { RIL_E_INVALIDDIALSTRING,  11},
    { RIL_E_OPNOTALLOWED,       12},
    { RIL_E_OPNOTALLOWED,       13},
    { RIL_E_OPNOTALLOWED,       14},
    { RIL_E_OPNOTALLOWED,       -1},    // unsigned value is highest for binary search
};
#define NUM_EXTERRORS       (sizeof(g_rgemEXTErrors) / sizeof(ERRORMAP))

#endif

//
// CallerID validities
//
static const DWORD g_rgdwValidities[] =
{
    RIL_REMOTEPARTYINFO_VALID,          // 0
    RIL_REMOTEPARTYINFO_WITHHELD,       // 1
    RIL_REMOTEPARTYINFO_UNAVAILABLE,    // 2
};
#define NUM_VALIDITIES      (sizeof(g_rgdwValidities) / sizeof(DWORD))


//
// Supplementary service data status values
//
static const DWORD g_rgdwSupSvcDataStats[] =
{
    RIL_SUPSVCDATASTATUS_NOINFOREQUIRED,        // 0
    RIL_SUPSVCDATASTATUS_FURTHERINFOREQUIRED,   // 1
    RIL_SUPSVCDATASTATUS_TERMINATED,            // 2
    RIL_SUPSVCDATASTATUS_OTHERCLIENTRESPONDED,  // 3
    RIL_SUPSVCDATASTATUS_UNSUPPORTED,           // 4
    RIL_SUPSVCDATASTATUS_TIMEOUT,               // 5
};
#define NUM_SUPSVCDATASTATS     (sizeof(g_rgdwSupSvcDataStats) / sizeof(DWORD))

#ifdef RIL_LAST_ERROR
extern DWORD g_dwLastError;
#endif

#if defined(OEM1_DRIVER) || defined(OEM2_DRIVER) || defined(EMP_DRIVER)
CResponse* g_CachedToolKitNotifs[MAX_TOOLKITNOTIFS];
#endif

#ifdef OEM2_DRIVER
extern HANDLE g_hCPINNEvent;
#endif

#if defined(OEM1_CSQ_NOTIFICATION) || defined(OEM2_DRIVER) || defined(EMP_DRIVER)
RILSIGNALQUALITY g_rsq;
BOOL g_fSignalQualityReceived = FALSE;
#endif

RILLOCATIONINFO g_rliLocationInfo;
BOOL g_fInitialLocationInfoReceived = FALSE;
BOOL g_fLocationInfoReceived = FALSE;
BOOL g_fSuppressRegStatusNotification = FALSE;
BOOL g_fSuppressGPRSRegStatusNotification = FALSE;

//
// Response ctor
//
CResponse::CResponse()
: m_dwCode(0),
m_fUnsolicited(FALSE),
m_fUnrecognized(FALSE),
m_fPotentialBogusResponse(FALSE),
m_pBlob(NULL),
m_cbBlob(0),
m_nOffset(0)
{
    // FUNCTION_TRACE(CResponse::CResponse);
}

//
// copy Response ctor
//
CResponse::CResponse(const CResponse &Rsp)
: m_dwCode(Rsp.m_dwCode),
m_fUnsolicited(Rsp.m_fUnsolicited),
m_fUnrecognized(Rsp.m_fUnrecognized),
m_fPotentialBogusResponse(Rsp.m_fPotentialBogusResponse),
m_pBlob(NULL),
m_cbBlob(0),
m_nOffset(0)
// CBuffer initialized null.
{
}

//
// Response dtor
//
CResponse::~CResponse()
{
    // FUNCTION_TRACE(CResponse::~CResponse);
    FreeBlob(m_pBlob);
    m_pBlob = NULL;
    m_cbBlob = 0;
}


//
// Append data to the response
//
BOOL CResponse::AppendString(const LPCSTR szString, const UINT cbString, LPCSTR& rszRemainder, UINT& rcbRemainder, BOOL fDataOnNotificationPort)
{
    FUNCTION_TRACE(CResponse::AppendString);
    UINT cbNewLength = 0;
    UINT cbOldLength = m_cbLength;
    BOOL fRet = FALSE;

    // Append the new data to the buffer
    if (!Append(szString, cbString))
    {
        goto Error;
    }

    // Parse the data
    if (Parse(cbNewLength, fDataOnNotificationPort))
    {
        DEBUGCHK(cbNewLength != 0);
        DEBUGCHK(cbNewLength <= m_cbLength);

        m_cbLength = cbNewLength;
        rszRemainder = szString + cbNewLength - cbOldLength;
        rcbRemainder = cbString - (rszRemainder - szString);
    }
    else
    {
        rszRemainder = NULL;
        rcbRemainder = 0;
    }
    fRet = TRUE;

    Error:
    return fRet;
}


//
//
//
BOOL CResponse::SetBlob(const void* const pBlob, const UINT cbBlob)
{
    FUNCTION_TRACE(CResponse::SetBlob);
    BOOL fRet = FALSE;

    DEBUGCHK(NULL == m_pBlob && 0 == m_cbBlob);
    FreeBlob(m_pBlob);
    m_cbBlob = 0;

    if (cbBlob)
    {
        DEBUGCHK(NULL != pBlob);

        m_pBlob = AllocBlob(cbBlob);
        if (!m_pBlob)
        {
            // Critically low on memory
            SignalCriticalError(RILLOG_EVENT_LOWMEMORY, __LINE__, __FILE__);
            goto Error;
        }
        memcpy(m_pBlob, pBlob, cbBlob);
    }

    m_cbBlob = cbBlob;
    fRet = TRUE;

    Error:
    return fRet;
}


//
//
//
BOOL CResponse::OKToError(HRESULT hr)
{
    FUNCTION_TRACE(CResponse::OKToError);
    DEBUGCHK(RIL_RESULT_OK == m_dwCode);
    DEBUGCHK(FALSE == m_fUnsolicited);
    return MakeError(hr);
}


//
//
//
BOOL CResponse::MakeError(const HRESULT hrError)
{
    FUNCTION_TRACE(CResponse::MakeError);
    // Get rid of the old blob
    FreeBlob(m_pBlob);
    m_pBlob = NULL;
    m_cbBlob = 0;

    m_fUnsolicited = FALSE;
    m_dwCode = RIL_RESULT_ERROR;
    return SetBlob((void*)&hrError, sizeof(HRESULT));
}


#ifdef OEM2_DRIVER
//
//Check if this is a response for CPINN: SIM PIN (PIN2, PUK, PUK2)
//
BOOL CResponse::FCPINNRsp( )
{
    BOOL fRet = FALSE;
    if(m_pBlob)
    {
        if((RIL_E_SIMPIN2REQUIRED ==*(HRESULT*)m_pBlob) ||(RIL_E_SIMPUK2REQUIRED == *(HRESULT*)m_pBlob)
            ||(RIL_E_SIMPINREQUIRED == *(HRESULT*)m_pBlob) ||(RIL_E_SIMPUKREQUIRED == *(HRESULT*)m_pBlob))
            fRet = TRUE;
    }
    return fRet;
}
#endif


//
// Parse a response
//
BOOL CResponse::Parse(UINT& rcbNewLength, BOOL fDataOnNotificationPort)
{
    FUNCTION_TRACE(CResponse::Parse);
    // NULL-terminate the response string temporarily
    m_szData[m_cbLength] = '\0';

#ifdef DEBUG
    DEBUGMSG(ZONE_INFO, (TEXT("RILDrv : i : Accumulated response: %s\r\n"), TString(PrintableString(m_szData, m_cbLength))));
#else
#ifdef WANT_RETAIL_RILDRV_OUTPUT
    {
        char szPrint[256];
        const char szCR[] = "<cr>";
        const char szLF[] = "<lf>";
        UINT iPrint = 0;
        UINT iChars = 0;
        // convert \r, \n to visible chars.
        while (iChars < m_cbLength && iPrint < (sizeof(szPrint) - sizeof(szLF)))
        {
            if (m_szData[iChars] == '\r')
            {
                strcpy(&szPrint[iPrint], szCR);
                iPrint += (sizeof(szCR) - 1);
            }
            else if (m_szData[iChars] == '\n')
            {
                strcpy(&szPrint[iPrint], szLF);
                iPrint += (sizeof(szLF) - 1);
            }
            else
            {
                szPrint[iPrint] = m_szData[iChars];
                iPrint++;
            }
            iChars++;
        }
        szPrint[iPrint] = '\0';
        NKDbgPrintfW(TEXT("RilDrv: Accumulated response: %a\r\n"), szPrint);
    }
#endif //WANT_RETAIL_RILDRV_OUTPUT
#endif // DEBUG

    return (ParseNotification(rcbNewLength, fDataOnNotificationPort)    ||
            ParseOKOrError(TRUE, rcbNewLength) ||
            ParseOKOrError(FALSE, rcbNewLength));
    // Remove attempts to parse partial responses. Can't be done safely with the current architecture,
    // since we can't safely verify at this point that this isn't a valid partial response.
    //    || ParsePartialResponse(rcbNewLength));
}

// This function searches for strings of the form "+X", where X is a set of at least 2
// uppercase characters. If found, it sets rszPointer to the beginning of the string,
// and returns the number of characters in the string.
int FindNextResponse(LPCSTR szStart, LPCSTR& rszPointer)
{
    FUNCTION_TRACE(FindNextResponse);
    LPCSTR szPointer = szStart;
    LPCSTR szCmd;
    int RespSize;

    while (1)
    {
        // Find the first '+' character
        szPointer = strchr(szPointer, '+');
        if (!szPointer)
        {
            // Didn't find a +, abort
            return 0;
        }

        // We found a '+', now look for some capital letters
        RespSize=1;
        szCmd = szPointer+1;
        while (1)
        {
            UCHAR NextChar = *szCmd;

            // If we hit a NULL in the middle of parsing, abort
            if (NextChar=='\0')
            {
                return 0;
            }
            // Is it a capital letter?
            else if ((NextChar >= 'A') && (NextChar <= 'Z'))
            {
                RespSize++;
                szCmd++;
            }
            // Is it a ':', which ends a response?
            else if (NextChar == ':')
            {
                RespSize++;
                rszPointer=szPointer;
                return RespSize;
            }
            // It's some other character. Keep looking.
            else
            {
                // Remember to increment the initial pointer so we don't try to
                // reparse the same + character in an infinite loop
                szPointer=szCmd;
                break;
            }
        }
    }
}

// This function attempts to weed out invalid responses which were truncated due to comm errors
// Note that if this function thinks there is a partial response, it will throw away
// the partial response up to the '+' character of the next response. This means that it will
// also throw away any leading <cr><lf> prefix on the next call. This works because
// ParseRspPrefix always returns TRUE, even if the <cr><lf> prefix isn't there.
// Note that this function runs after other attempts to recognize notifications, OK, or
// ERROR responses have run. Therefore, it won't mistakenly throw away OEM notifications
// which don't begin with a '+', since they should be caught earlier. However, this code
// does run before parsing of responses to commands, so any such responses which don't
// begin with a '+' may be mistakenly thrown away. So far there are no such responses
// that I know of.
BOOL CResponse::ParsePartialResponse(UINT& rcbNewLength)
{
    FUNCTION_TRACE(CResponse::ParsePartialResponse);
    LPSTR szPointer = m_szData;
    LPSTR szResponse1;
    LPSTR szResponse2;
    int cbResponse1;
    int cbResponse2;

    // Skip initial <cr><lf> if there
    ParseRspPrefix(szPointer, szPointer);

    // Look for the first response in buffer (anything of the form "+X", where X is
    // one or more capital letters). Returns 0 if not found.
    cbResponse1 = FindNextResponse(szPointer, szResponse1);

    // If we didn't find one, abort
    if (cbResponse1==0)
    {
        return FALSE;
    }

    // If the first '+' in the buffer doesn't occur immediately after the prefix (or at the
    // beginning if there wasn't a prefix), treat everything before the '+' as the (junk)
    // response

    // This is somewhat nondeterministic, since this will strip leading data off of
    // valid commands if we haven't received the trailing 0<cr> yet,
    // but won't touch the leading data if we have received the trailing 0<cr> (since this
    // will cause the earlier ParseOKOrError to succeed)

    // The individual command response parsers should really be using MatchStringAnywhere
    // to skip past any initial cruft, but most of them use MatchStringBeginning and are
    // therefore somewhat finicky about the +XXX appearing at the beginning or immediately
    // after the prefix. Someday I should go back and fix that. So far the only ones I've
    // made sure to fix are those for parsing SMS Send & Write, which normally have an
    // extra "<cr><lf>> " prepended which may or may not get thrown away by the code below.
    if (szResponse1!=szPointer)
    {
        rcbNewLength = szResponse1 - m_szData;
        m_fUnrecognized = TRUE;
        return TRUE;
    }

    // Look for the second response in buffer.
    cbResponse2 = FindNextResponse(szResponse1+cbResponse1, szResponse2);
    if (cbResponse2==0)
    {
        // If we didn't find a second response, maybe we're still waiting
        // for the rest of the first, so abort
        return FALSE;
    }

    // If the first & second responses differ,
    // assume the first is a partial response and throw it away
    if ( (cbResponse1!=cbResponse2) || strncmp(szResponse1,szResponse2,cbResponse1) )
    {