//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:

response.cpp

Abstract:


Notes:


--*/


#include "precomp.h"
#ifdef RIL_LAST_ERROR
#include "ccoreutl.h"
#endif

#ifndef _PREFAST_
#pragma warning( disable: 4068 )
#endif

CRITICAL_SECTION g_csDeactCringLock;
CRITICAL_SECTION g_csCallStates;
bool g_fCringRcvd = FALSE;
DWORD g_LastCringRcvd = 0;

extern BOOL g_rfExternalCalltypeDetermination;
extern RILCALLTYPECALLBACK g_rlpfExternalCalltypeFunction;

extern RILCALLINFO g_rgfCallStates[RIL_MAX_TRACKED_CALL_ID];

extern BOOL g_rgfCalltypeChecked[RIL_MAX_TRACKED_CALL_ID];
extern DWORD g_rgctCalltype[RIL_MAX_TRACKED_CALL_ID];

extern DIALEDCALLDATA g_rcdDialedCallData;
extern CRITICAL_SECTION g_csDialedCallData;

RINGINGCALLDATA g_rcdRingingCallData;
extern CRITICAL_SECTION g_csRingingCallData;

WAITINGCALLDATA g_rcdWaitingCallData;

extern BOOL SetupCallListEvaluation ();

extern const DWORD g_rgdwRestrictedSIMCmds[];

BOOL g_fSystemChanged = FALSE;
DWORD g_dwSystemType = RIL_SYSTEMTYPE_NONE;
DWORD g_dwSystemCaps = RIL_SYSTEMCAPS_NONE;

/****************************************************************************/
/*** start of helper ATCmd **************************************************/

class CPHSStatus : public ATCmd
{
public:
    CPHSStatus( DWORD dwAddress )
    {
        m_dwAddress = dwAddress;
        memset( &m_rsrs, 0, sizeof(m_rsrs) );
        m_rsrs.dwSize = sizeof(m_rsrs);
    }
    virtual ~CPHSStatus()
    {
    }
    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",
                    g_rgdwRestrictedSIMCmds[ g_rppPDDParams->dwCRSMStatusCommandId ],
                    m_dwAddress, 0, 0, g_rppPDDParams->RestrictedSimAccessSetCmdParam3 );

        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
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : ---RILSIMRECORDSTATUS[0x%04x]----------"), m_dwAddress));
        ATCmd::Dump();
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : cbSize       [%u]"), m_rsrs.cbSize));
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : dwParams     [%u]"), m_rsrs.dwParams));
        if ( m_rsrs.dwParams & RIL_PARAM_SRS_RECORDTYPE )
        {
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : dwRecordType [%u]"), m_rsrs.dwRecordType));
        }
        if ( m_rsrs.dwParams & RIL_PARAM_SRS_ITEMCOUNT )
        {
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : dwItemCount  [%u]"), m_rsrs.dwItemCount));
        }
        if ( m_rsrs.dwParams & RIL_PARAM_SRS_SIZE )
        {
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : dwSize       [%u]"), m_rsrs.dwSize));
        }
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i : ---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 CPHSRecord : public ATCmd
{
public:
    enum
    {
        READ_BINARY = 176,
        READ_RECORD = 178
    };
    enum
    {
        ABSOLUTE_MODE = 4
    };

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

    CPHSRecord(
        DWORD dwAddress,
        DWORD dwSize)
    {
        m_dwAddress = dwAddress;
        m_dwSize = dwSize;
        m_dwCmd = READ_BINARY;
        m_dwIndex = 0;
        m_prsr = NULL;
    }
    virtual ~CPHSRecord()
    {
        if ( m_prsr != NULL )
        {
            FreeBlob( m_prsr );
            m_prsr = NULL;
        }
    }
    HRESULT Read()
    {
        HRESULT hr = E_FAIL;

        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;
        }

        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 )
            {
                const 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
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :---RILSIMRESPONSE[0x%04x]----------"), m_dwAddress));
        ATCmd::Dump();
        if ( m_prsr != NULL )
        {
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :cbSize        [%u]"), m_prsr->cbSize));
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :dwParams      [%u]"), m_prsr->dwParams));
            if ( m_prsr->dwParams & RIL_PARAM_SR_STATUSWORD1 )
            {
                DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :dwStatusWord1 [%u]"), m_prsr->dwStatusWord1));
            }
            if ( m_prsr->dwParams & RIL_PARAM_SR_STATUSWORD2 )
            {
                DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :dwStatusWord2 [%u]"), m_prsr->dwStatusWord2));
            }
            if ( m_prsr->dwParams & RIL_PARAM_SR_RESPONSE )
            {
                DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :record length [%u]"), m_prsr->cbSize-sizeof(RILSIMRESPONSE)));
            }
        }
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : i :---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;
};

/*** end of helper ATCmd ****************************************************/
/****************************************************************************/


static
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,