eons.cpp

ril source code for Windows CE

            {
                DEBUGMSG(ZONE_EONS,(TEXT("RILDrv : i : pnn[%d]    short [%hs]\r\n"), i+1, ron.szShortName));
            }
            if ( ron.dwParams & RIL_PARAM_ON_NUMNAME )
            {
                DEBUGMSG(ZONE_EONS,(TEXT("RILDrv : i : pnn[%d]    num [%hs]\r\n"), i+1, ron.szNumName));
            }
            if ( ron.dwParams & RIL_PARAM_ON_COUNTRY_CODE )
            {
                DEBUGMSG(ZONE_EONS,(TEXT("RILDrv : i : pnn[%d]    countrycode [%hs]\r\n"), i+1, ron.szCountryCode));
            }
        }
    }
#endif
}

HRESULT
EONS::Read()
{
    HRESULT hr = E_FAIL;
    {
        SYNCBLOCK( m_cs );
        if ( m_hThread == NULL )
        {
            /* (re)read the data */
            m_hThread = CreateThread( NULL, 0, &EONS::s_ThreadStartCallback, (LPVOID)this, 0, NULL );
            if ( m_hThread != NULL )
            {
                /* reading started */
                hr = S_OK;

                m_fDoneReading = FALSE;
            }
            else
            {
                DEBUGMSG(ZONE_EONS,(TEXT("RILDrv : i : EONS::Read() failed to start the read thread\r\n")));;
            }
        }
        else
        {
            /* reading in progress */
            DEBUGMSG(ZONE_EONS,(TEXT("RILDrv : i : EONS::Read() in progress\r\n")));;
            hr = S_OK;
        }
    }
    return hr;
}

DWORD
EONS::s_ThreadStartCallback( LPVOID lpThreadData )
{
    DWORD dw = 0;

    ASSERT( lpThreadData != NULL );
    if ( lpThreadData != NULL )
    {
        EONS *pEONS = reinterpret_cast<EONS*>( lpThreadData );

        ASSERT( pEONS != NULL );
        if ( pEONS != NULL )
        {
            HRESULT hr = pEONS->ReadData();
        }

        pEONS = NULL;
    }

    return dw;
}

HRESULT
EONS::ReadData()
{
    HRESULT hr = E_FAIL;
    {
        SYNCBLOCK( m_cs );

        m_fDoneReading = FALSE;

        /* clear the storage */
        m_opl.RemoveAllThings();
        m_pnn.RemoveAllThings();

        hr = ReadOPLData();
        if ( SUCCEEDED( hr ) )
        {
            hr = ReadPNNData();
        }

        /* enforce data coherency */
        Validate();

        m_fDoneReading = TRUE;

        /* housekeeping */
        if ( m_hThread != NULL )
        {
            CloseHandle( m_hThread );
        }
        m_hThread = NULL;
    }
    return hr;
}

HRESULT
EONS::ReadOPLData()
{
    /* assumption -- m_cs has been acquired */

    HRESULT hr = E_FAIL;

    CRSMStatus k( EFopl );
    HRESULT hr2 = k.Read();
    k.Dump();
    if ( SUCCEEDED( hr2 ) )
    {
        RILSIMRECORDSTATUS rsrs = k.GetStatus();
        if ( ( rsrs.dwParams & RIL_PARAM_SRS_SIZE && rsrs.dwSize >= 8 ) &&
            ( rsrs.dwParams & RIL_PARAM_SRS_ITEMCOUNT ) )
        {
            const DWORD dwSize = rsrs.dwSize;
            const DWORD dwItemCount = rsrs.dwItemCount;

            char *pBuf = new char[ dwSize ];
            if ( pBuf != NULL )
            {
                for( int i = 1; i <= (int)dwItemCount; i++ )
                {
                    DWORD dw = 0;
                    memset( pBuf, 0, dwSize );

                    CRSMRecord kk( EFopl, i, dwSize );
                    hr2 = kk.Read();
                    kk.Dump();

                    if ( SUCCEEDED( hr2 ) )
                    {
                        dw = dwSize;
                        BOOL fOk = kk.GetRecord( (BYTE*)pBuf, dw );
                        hr2 = ( fOk ? S_OK : E_FAIL );
                    }

                    if ( SUCCEEDED( hr2 ) && pBuf[0] != (char)0xff )
                    {
                        const char *cptr = pBuf;
                   
                        /* 3GPP TS 31.102 version 5.7.0 section 4.2.59 */

                        int b[6];
                        for( int j = 0; j < 3; j++ )
                        {
                            char x = pBuf[j];

                            b[j*2]   = ( 0x0f & ( x >> 4 ) );
                            b[j*2+1] = ( 0x0f & x );
                        }

                        /* BCD offset */
                        int bindex[] = { 1, 0, 3, 5, 4, 2 };

                        BOOL fDeleted = FALSE;

                        char szPLMN[ARRAY_LENGTH(b)+1];
                        for( int j = 0; j < ARRAY_LENGTH(b) && !fDeleted; j++ )
                        {
                            szPLMN[j] = NULL;
                            if ( 0 <= b[bindex[j]] && b[bindex[j]] < 10 )
                            {
                                /* digits 0-9 */
                                szPLMN[j] = ( '0'+b[bindex[j]] );
                            }
                            else if ( b[bindex[j]] == 0x0d )
                            {
                                /* wildcard */
                                szPLMN[j] = WILDCARD;
                            }
                            else if ( b[bindex[j]] == 0x0f )
                            {
                                /* dontcare */
                                szPLMN[j] = DONTCARE;
                            }
                            else
                            {
                                /* deleted entry */
                                fDeleted = TRUE;
                            }
                        }
                        szPLMN[ARRAY_LENGTH(szPLMN)-1] = NULL;

                        OPLStruct opl;
                        memset( &opl, 0, sizeof(opl) );

                        if ( !fDeleted )
                        {
                            long lacA = ( ( 0x0ff & pBuf[3] ) << 8 ) + ( 0x0ff & pBuf[4] );
                            long lacZ = ( ( 0x0ff & pBuf[5] ) << 8 ) + ( 0x0ff & pBuf[6] );
                            long idx  = ( 0x0ff & pBuf[7] );

                            ASSERT( idx > 0 );

                            StringCchCopyA( opl.szPLMN, ARRAY_LENGTH(opl.szPLMN), szPLMN );
                            opl.dwLACa  = lacA;
                            opl.dwLACz  = lacZ;
                            opl.dwIndex = idx;
                        }
                        else
                        {
                            /* index of 0 means deleted entry */
                            opl.dwIndex = 0;
                        }

                        m_opl.AddThing( opl );
                    }
                }

                hr = S_OK;
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }

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

    return hr;
}

HRESULT
EONS::ReadPNNData()
{
    /* assumption -- m_cs has been acquired */

    HRESULT hr = E_FAIL;

    CRSMStatus k( EFpnn );
    HRESULT hr2 = k.Read();
    k.Dump();
    if ( SUCCEEDED( hr2 ) )
    {
        RILSIMRECORDSTATUS rsrs = k.GetStatus();
        if ( ( rsrs.dwParams & RIL_PARAM_SRS_SIZE ) &&
            ( rsrs.dwParams & RIL_PARAM_SRS_ITEMCOUNT ) )
        {
            const DWORD dwSize = rsrs.dwSize;
            const DWORD dwItemCount = rsrs.dwItemCount;

            char *pBuf = new char[ dwSize ];
            if ( pBuf != NULL )
            {
                for( int i = 1; i <= (int)dwItemCount; i++ )
                {
                    DWORD dw = 0;
                    memset( pBuf, 0, dwSize );

                    CRSMRecord kk( EFpnn, i, dwSize );
                    hr2 = kk.Read();
                    kk.Dump();

                    if ( SUCCEEDED( hr2 ) )
                    {
                        dw = dwSize;
                        BOOL fOk = kk.GetRecord( (BYTE*)pBuf, dw );
                        hr2 = ( fOk ? S_OK : E_FAIL );
                    }

                    RILOPERATORNAMES ron;
                    memset( &ron, 0, sizeof(ron) );
                    ron.cbSize = sizeof(ron);

                    if ( SUCCEEDED( hr2 ) && pBuf[0] != (char)0xff )
                    {
                        const char *cptr = pBuf;

                        /* 3GPP TS 31.102 version 5.7.0 section 4.2.58 */

                        const char *Ftlv = NULL;
                        int Fiei = 0;
                        int Flen = 0;

                        if ( cptr != NULL && dw >= 2 )
                        {
                            Fiei = (int)( 0x0ff & cptr[0] );
                            Flen = (int)( 0x0ff & cptr[1] );
                            if ( (int)dw >= 2+Flen )
                            {
                                Ftlv = cptr;

                                cptr += ( 2+Flen );
                                dw   -= ( 2+Flen );
                            }
                            else
                            {
                                cptr = NULL;
                                dw = 0;
                            }
                        }

                        const char *Stlv = NULL;
                        int Siei = 0;
                        int Slen = 0;

                        if ( cptr != NULL && dw >= 2 )
                        {
                            Siei = (int)( 0x0ff & cptr[0] );
                            Slen = (int)( 0x0ff & cptr[1] );
                            if ( (int)dw >= 2+Slen )
                            {
                                Stlv = cptr;
                            }
                        }

                        /* long name */
                        if ( Fiei == IEIfullname && Ftlv != NULL )
                        {
                            BOOL fLong = DecodeNetworkNameTLV( Ftlv, ron.szLongName, ARRAY_LENGTH(ron.szLongName) );
                            if ( fLong )
                            {
                                ron.dwParams |= RIL_PARAM_ON_LONGNAME;
                            }
                        }

                        /* short name */
                        if ( Siei == IEIshortname && Stlv != NULL )
                        {
                            BOOL fShort = DecodeNetworkNameTLV( Stlv, ron.szShortName, ARRAY_LENGTH(ron.szShortName) );
                            if ( fShort )
                            {
                                ron.dwParams |= RIL_PARAM_ON_SHORTNAME;
                            }
                        }
                    }

                    /* add to maintain PNN order regardless of read/parse status */
                    m_pnn.AddThing( ron );
                }

                hr = S_OK;
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }

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

    return hr;
}

BOOL
EONS::DecodeNetworkNameTLV( const char *cptr, __out_ecount(dwOut) char *pszOUT, DWORD dwOut ) const
{
    BOOL fOk = FALSE;
    if ( cptr[0] != (char)0xff && pszOUT != NULL && dwOut > 0 )
    {
        /* 3GPP TS 24.008 version 3.2.1 section 10.5.3.5a */

        int iei = ( 0x07f & cptr[0] );
        int len = ( 0x0ff & cptr[1] );
        int ext = ( 0x01 & ( cptr[2] >> 7 ) );