response.cpp

手机RILGSM实现的源代码

    virtual void Dump() const
    {
#ifdef DEBUG
        _tprintf(TEXT("---RILSIMRESPONSE[0x%04x]----------"), m_dwAddress);
        ATCmd::Dump();
        if ( m_prsr != NULL )
        {
            _tprintf(TEXT("cbSize        [%u]"), m_prsr->cbSize);
            _tprintf(TEXT("dwParams      [%u]"), m_prsr->dwParams);
            if ( m_prsr->dwParams & RIL_PARAM_SR_STATUSWORD1 )
            {
                _tprintf(TEXT("dwStatusWord1 [%u]"), m_prsr->dwStatusWord1);
            }
            if ( m_prsr->dwParams & RIL_PARAM_SR_STATUSWORD2 )
            {
                _tprintf(TEXT("dwStatusWord2 [%u]"), m_prsr->dwStatusWord2);
            }
            if ( m_prsr->dwParams & RIL_PARAM_SR_RESPONSE )
            {
                _tprintf(TEXT("record length [%u]"), m_prsr->cbSize-sizeof(RILSIMRESPONSE));
            }
        }
        _tprintf(TEXT("---RILSIMRESPONSE[0x%04x]----------"), m_dwAddress);
#endif
    }
protected:
    virtual HRESULT Parse( LPCSTR szRsp )
    {
        void *pBlob = NULL;
        UINT cbBlob = 0;

        HRESULT hr = ParseSendRestrictedSimCmd( szRsp, pBlob, cbBlob );
        if ( SUCCEEDED( hr ) && pBlob != NULL && cbBlob >= sizeof(RILSIMRESPONSE) )
        {
            m_prsr = static_cast<RILSIMRESPONSE*>( pBlob );
        }

        return hr;
    }
private:
    DWORD m_dwAddress;
    DWORD m_dwSize;
    DWORD m_dwCmd;
    DWORD m_dwIndex;
    RILSIMRESPONSE *m_prsr;
};
#ifdef DISPLAY_SPN
class SPNStatus : public ATCmd
{
public:
    SPNStatus( DWORD dwAddress )
    {
        m_dwAddress = dwAddress;
        memset( &m_rsrs, 0, sizeof(m_rsrs) );
        m_rsrs.dwSize = sizeof(m_rsrs);
    }
    virtual ~SPNStatus()
    {
    }
    HRESULT Read()
    {
        HRESULT hr = E_FAIL;

        char *szCmd = NULL;
        char buf[128];

        /* based on misc.cpp:RILDrv_GetSimRecordStatus() */
        /* simplied for use in the CPHS context */

        _snprintfz( buf, ARRAY_LENGTH(buf), "AT+CRSM=%u,%u,%u,%u,%u",
#ifdef OEM1_DRIVER
                    192,
#else
                    242,
#endif
                    m_dwAddress, 0, 0, 15 );

        BOOL fOk = ComposeCmdWithByteArray( buf, NULL, 0, "\r", szCmd );
        if ( fOk )
        {
            hr = Execute( szCmd );
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        if ( szCmd != NULL )
        {
            delete[] szCmd;
            szCmd = NULL;
        }

        return hr;
    }
    RILSIMRECORDSTATUS GetStatus() const
    {
        return m_rsrs;
    }
    virtual void Dump() const
    {
#ifdef DEBUG
        _tprintf(TEXT("---RILSIMRECORDSTATUS[0x%04x]----------"), m_dwAddress);
        ATCmd::Dump();
        _tprintf(TEXT("cbSize       [%u]"), m_rsrs.cbSize);
        _tprintf(TEXT("dwParams     [%u]"), m_rsrs.dwParams);
        if ( m_rsrs.dwParams & RIL_PARAM_SRS_RECORDTYPE )
        {
            _tprintf(TEXT("dwRecordType [%u]"), m_rsrs.dwRecordType);
        }
        if ( m_rsrs.dwParams & RIL_PARAM_SRS_ITEMCOUNT )
        {
            _tprintf(TEXT("dwItemCount  [%u]"), m_rsrs.dwItemCount);
        }
        if ( m_rsrs.dwParams & RIL_PARAM_SRS_SIZE )
        {
            _tprintf(TEXT("dwSize       [%u]"), m_rsrs.dwSize);
        }
        _tprintf(TEXT("---RILSIMRECORDSTATUS[0x%04x]----------"), m_dwAddress);
#endif
    }
protected:
    virtual HRESULT Parse( LPCSTR szRsp )
    {
        void *pBlob = NULL;
        UINT cbBlob = 0;

        HRESULT hr = ParseGetSimRecordStatus( szRsp, pBlob, cbBlob );
        if ( SUCCEEDED( hr ) && pBlob != NULL && cbBlob == sizeof(m_rsrs) )
        {
            memcpy( &m_rsrs, pBlob, sizeof(m_rsrs) );
        }

        if ( pBlob != NULL )
        {
            FreeBlob( pBlob );
            pBlob = NULL;
        }

        return hr;
    }
private:
    DWORD m_dwAddress;
    RILSIMRECORDSTATUS m_rsrs;
};

class SPNRecord : public ATCmd
{
public:
    enum
    {
        READ_BINARY = 176,
        READ_RECORD = 178
    };
    enum
    {
        ABSOLUTE_MODE = 4
    };

    SPNRecord(
        DWORD dwAddress,
        DWORD dwSize,
        DWORD dwCmd,
        DWORD dwIndex)
    {
        m_dwAddress = dwAddress;
        m_dwSize = dwSize;
        m_dwCmd = dwCmd;
        m_dwIndex = dwIndex;
        m_prsr = NULL;
    }

    SPNRecord(
        DWORD dwAddress,
        DWORD dwSize)
    {
        m_dwAddress = dwAddress;
        m_dwSize = dwSize;
        m_dwCmd = READ_BINARY;
        m_dwIndex = 0;
        m_prsr = NULL;
    }

    virtual ~SPNRecord()
    {
        if ( m_prsr != NULL )
        {
            FreeBlob( m_prsr );
            m_prsr = NULL;
        }
    }
    HRESULT Read()
    {
        HRESULT hr = E_FAIL;

#ifdef WAVECOM_DRIVER
        /* WaveCom hardware doesnt support AT+CRSM */
        hr = E_NOTIMPL;
#else
        char *szCmd = NULL;
        char buf[128];
        DWORD dwMode = 0;

        /* based on misc.cpp:RILDrv_SendRestrictedSimCmd() */
        /* based on simrecrd.cpp:ReadRecord() */
        /* simplied for use in the CPHS context */

        if (READ_RECORD == m_dwCmd)
        {
            dwMode = ABSOLUTE_MODE;
        }
        _snprintfz( buf, ARRAY_LENGTH(buf), "AT+CRSM=%u,%u,%u,%u,%u",
                    m_dwCmd, m_dwAddress, m_dwIndex, dwMode, m_dwSize );

        BOOL fOk = ComposeCmdWithByteArray( buf, NULL, 0, "\r", szCmd );
        if ( fOk )
        {
            hr = Execute( szCmd );
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        if ( szCmd != NULL )
        {
            delete[] szCmd;
            szCmd = NULL;
        }
#endif

        return hr;
    }
    RILSIMRESPONSE GetResponse() const
    {
        RILSIMRESPONSE rsr;
        memset( &rsr, 0, sizeof(rsr) );
        if ( m_prsr != NULL )
        {
            memcpy( &rsr, m_prsr, sizeof(rsr) );
        }
        return rsr;
    }
    BOOL GetRecord( __out_ecount(cbData) BYTE *pData, DWORD& cbData ) const
    {
        BOOL fOk = FALSE;
        if ( m_prsr != NULL && pData != NULL && cbData > 0 )
        {
            int totalsize = (int)m_prsr->cbSize;
            int responsesize = (int)sizeof(RILSIMRESPONSE);
            int recordsize = ( totalsize - responsesize );
            if ( totalsize > 0 && recordsize > 0 && cbData >= (DWORD)recordsize )
            {
                BYTE *pPtr = (BYTE*)m_prsr;

                memset( pData, 0, cbData );

                memcpy( pData, pPtr+responsesize, recordsize );
                cbData = (DWORD)recordsize;

                fOk = TRUE;
            }
        }
        return fOk;
    }
    virtual void Dump() const
    {
#ifdef DEBUG
        _tprintf(TEXT("---RILSIMRESPONSE[0x%04x]----------"), m_dwAddress);
        ATCmd::Dump();
        if ( m_prsr != NULL )
        {
            _tprintf(TEXT("cbSize        [%u]"), m_prsr->cbSize);
            _tprintf(TEXT("dwParams      [%u]"), m_prsr->dwParams);
            if ( m_prsr->dwParams & RIL_PARAM_SR_STATUSWORD1 )
            {
                _tprintf(TEXT("dwStatusWord1 [%u]"), m_prsr->dwStatusWord1);
            }
            if ( m_prsr->dwParams & RIL_PARAM_SR_STATUSWORD2 )
            {
                _tprintf(TEXT("dwStatusWord2 [%u]"), m_prsr->dwStatusWord2);
            }
            if ( m_prsr->dwParams & RIL_PARAM_SR_RESPONSE )
            {
                _tprintf(TEXT("record length [%u]"), m_prsr->cbSize-sizeof(RILSIMRESPONSE));
            }
        }
        _tprintf(TEXT("---RILSIMRESPONSE[0x%04x]----------"), m_dwAddress);
#endif
    }
protected:
    virtual HRESULT Parse( LPCSTR szRsp )
    {
        void *pBlob = NULL;
        UINT cbBlob = 0;

        HRESULT hr = ParseSendRestrictedSimCmd( szRsp, pBlob, cbBlob );
        if ( SUCCEEDED( hr ) && pBlob != NULL && cbBlob >= sizeof(RILSIMRESPONSE) )
        {
            m_prsr = static_cast<RILSIMRESPONSE*>( pBlob );
        }

        return hr;
    }
private:
    DWORD m_dwAddress;
    DWORD m_dwSize;
    DWORD m_dwCmd;
    DWORD m_dwIndex;
    RILSIMRESPONSE *m_prsr;
};
#endif
/*** end of helper ATCmd ****************************************************/
/****************************************************************************/

BOOL ParsePnnNameRecord(
    const CPHSRecord& record,
    __out_ecount(dwSize)
    char* szOut,
    DWORD dwSize)
{
    const BYTE MIN_EF_PNN_RECORD_SIZE = 3;
    const BYTE EF_PNN_NETWORK_NAME_IEI = 0x43;
    const BYTE EF_PNN_CODING_GSM = 0x00;
    const BYTE EF_PNN_CODING_UCS2 = 0x01;
    BOOL fRet = FALSE;
    BYTE rgbData[255];
    DWORD cbSize = ARRAY_LENGTH(rgbData);
    WCHAR* wszText = NULL;

    // Check parameters and data size. 255 is a close estimate of the max size.
    if (NULL == szOut ||
        0 == dwSize ||
        cbSize < dwSize)
    {
        goto Exit;
    }

    if (!record.GetRecord(rgbData, cbSize))
    {
        goto Exit;
    }

    if (MIN_EF_PNN_RECORD_SIZE > cbSize)
    {
        goto Exit;
    }

    // See 3GPP 24.008 section 10.5.3.5a for more info
    // Country Initials are ignored.

    // Check Network Name IEI
    if (EF_PNN_NETWORK_NAME_IEI != rgbData[0])
    {
        goto Exit;
    }

    BYTE bLength = rgbData[1];
    if (1 >= bLength || cbSize - 2 < bLength)
    {
        // No text available
        goto Exit;
    }

    // bLength is text length + 1.
    wszText = new WCHAR[bLength];
    if (NULL == wszText)
    {
        goto Exit;
    }

    BOOL fConvertSucceeded = FALSE;
    BYTE bCodingScheme = (rgbData[2] & 0x70) >> 4;
    const LPCSTR szBufferStart = (LPCSTR) &rgbData[3];
    UINT cbBufferLen = (UINT) bLength - 1;    // BufLen - 1 for coding scheme
    UINT cchTextLen = bLength;
    UINT cchUsed = 0;

    if (EF_PNN_CODING_GSM == bCodingScheme)
    {
        fConvertSucceeded = ConvertUnpackedGSMToUnicode(
            szBufferStart,
            cbBufferLen,
            wszText,
            cchTextLen,
            cchUsed);
    }
    else if (EF_PNN_CODING_UCS2 == bCodingScheme)
    {
        fConvertSucceeded = ConvertUCS2ToUnicode(
            szBufferStart,
            cbBufferLen,
            wszText,
            cchTextLen,