eons.cpp

windows mobile RIL软件

                ASSERT( strlen(opl.szPLMN) == 6 );
            }

            /* lacA <= lacZ */
            ASSERT( opl.dwLACa <= opl.dwLACz );

            /* lacZ <= 0x0ffff */
            ASSERT( opl.dwLACz <= 0x0ffff );

            /* PLMN should not be all WILDCARDs */
            BOOL fAllWildcards = TRUE;
            for( int j = 0; j < (int)strlen(opl.szPLMN) && fAllWildcards; j++ )
            {
                fAllWildcards = ( opl.szPLMN[j] == WILDCARD );
            }
            ASSERT( !fAllWildcards );

            /* index to PNN list */
            ASSERT( opl.dwIndex <= 256 );
            /* index can only be either 0 (deleted entry) or within [1,num-of-PNN-entry] */
            ASSERT( opl.dwIndex == 0 || ( 1 <= opl.dwIndex && opl.dwIndex <= static_cast<DWORD>( iPNN ) ) );
        }
        for( int i = 0; i < iPNN; i++ )
        {
            RILOPERATORNAMES ron = const_cast<GrowableThingCollection<RILOPERATORNAMES>*>( &m_pnn )->GetThingAtIndex( i );

            /* dont exist */
            ASSERT( ! ( ron.dwParams & RIL_PARAM_ON_COUNTRY_CODE ) );
            ASSERT( ! ( ron.dwParams & RIL_PARAM_ON_NUMNAME ) );
        }
#endif
    }
#endif
}

/****************************************************************************/
/****************************************************************************/

const TCHAR EONSCache::RegistryPath[] = RIL_SECURE_REGISTRY_KEY TEXT("\\EONS.cache");

EONSCache::EONSCache()
{
}

EONSCache::EONSCache( const EONS& ref )
    : EONS(ref)
{
}

EONSCache::~EONSCache()
{
}

HRESULT
EONSCache::Read()
{
    /* override to make the read synchronous */
    HRESULT hr = ReadData();
    return hr;
}

HRESULT
EONSCache::Write()
{
    HRESULT hr = WriteOPLData();
    if ( SUCCEEDED( hr ) )
    {
        hr = WritePNNData();
    }
    return hr;
}

void
EONSCache::Invalidate()
{
    Clear();
}

HRESULT
EONSCache::ReadOPLData()
{
    HRESULT hr = E_FAIL;

    HKEY hkey = NULL;

    StringBuffer key;
    key.Set( RegistryPath );
    key.Append( TEXT("\\opl") );

    LONG lResult = RegOpenKeyEx( RIL_REGISTRY_ROOT, key, 0, 0, &hkey );
    if ( lResult == ERROR_SUCCESS )
    {
        hr = S_OK;
        TCHAR subkey[16];

        BOOL fDone = FALSE;
        for( int i = 1; !fDone; i++ )
        {
            _sntprintfz( subkey, ARRAY_LENGTH(subkey), TEXT("%d"), i );

            HKEY hkey2 = NULL;

            lResult = RegOpenKeyEx( hkey, subkey, 0, 0, &hkey2 );
            if ( lResult == ERROR_SUCCESS )
            {
                OPLStruct opl;
                memset( &opl, 0, sizeof(opl) );

                BOOL fError = FALSE;
                DWORD dwSize = 0;
                DWORD dwType = 0;

                {
                    TCHAR szBuf[ARRAY_LENGTH(opl.szPLMN)];
                    dwSize = sizeof(szBuf);
                    lResult = RegQueryValueEx( hkey2, TEXT("PLMN"), NULL, &dwType, (BYTE*)szBuf, &dwSize );
                    fError = ( lResult != ERROR_SUCCESS || dwType != REG_SZ );
                    if ( !fError )
                    {
                        AnsiString as(szBuf);
                        strncpyz( opl.szPLMN, (const char*)as, ARRAY_LENGTH(opl.szPLMN) );
                    }
                }

                if ( !fError )
                {
                    dwSize = sizeof(opl.dwLACa);
                    lResult = RegQueryValueEx( hkey2, TEXT("start LAC"), NULL, &dwType, (BYTE*)&opl.dwLACa, &dwSize );
                    fError = ( lResult != ERROR_SUCCESS || dwType != REG_DWORD );
                }

                if ( !fError )
                {
                    dwSize = sizeof(opl.dwLACz);
                    lResult = RegQueryValueEx( hkey2, TEXT("end LAC"), NULL, &dwType, (BYTE*)&opl.dwLACz, &dwSize );
                    fError = ( lResult != ERROR_SUCCESS || dwType != REG_DWORD );
                }

                if ( !fError )
                {
                    dwSize = sizeof(opl.dwIndex);
                    lResult = RegQueryValueEx( hkey2, TEXT("index"), NULL, &dwType, (BYTE*)&opl.dwIndex, &dwSize );
                    fError = ( lResult != ERROR_SUCCESS || dwType != REG_DWORD );
                }

                if ( !fError )
                {
                    m_opl.AddThing( opl );
                }
            }
            else if ( lResult == ERROR_FILE_NOT_FOUND )
            {
                fDone = TRUE;
                hr = S_OK;
            }
            else
            {
                fDone = TRUE;
                hr = HRESULT_FROM_WIN32( lResult );
            }

            if ( hkey2 != NULL )
            {
                RegCloseKey( hkey2 );
            }
            hkey2 = NULL;
        }
    }
    else if ( lResult == ERROR_FILE_NOT_FOUND )
    {
        /* cache doesnt exist; treat as no items */
        hr = S_OK;
    }
    else
    {
        hr = HRESULT_FROM_WIN32( lResult );
    }

    if ( hkey != NULL )
    {
        RegCloseKey( hkey );
    }
    hkey = NULL;

    return hr;
}

HRESULT
EONSCache::ReadPNNData()
{
    HRESULT hr = E_FAIL;

    HKEY hkey = NULL;

    StringBuffer key;
    key.Set( RegistryPath );
    key.Append( TEXT("\\pnn") );

    LONG lResult = RegOpenKeyEx( RIL_REGISTRY_ROOT, key, 0, 0, &hkey );
    if ( lResult == ERROR_SUCCESS )
    {
        hr = S_OK;
        TCHAR subkey[16];

        BOOL fDone = FALSE;
        for( int i = 1; !fDone; i++ )
        {
            _sntprintfz( subkey, ARRAY_LENGTH(subkey), TEXT("%d"), i );

            HKEY hkey2 = NULL;

            lResult = RegOpenKeyEx( hkey, subkey, 0, 0, &hkey2 );
            if ( lResult == ERROR_SUCCESS )
            {
                RILOPERATORNAMES ron;
                memset( &ron, 0, sizeof(ron) );
                ron.cbSize = sizeof(ron);

                BOOL fError = FALSE;
                DWORD dwSize = 0;
                DWORD dwType = 0;

                {
                    TCHAR szBuf[ARRAY_LENGTH(ron.szLongName)];
                    dwSize = sizeof(szBuf);
                    lResult = RegQueryValueEx( hkey2, TEXT("long name"), NULL, &dwType, (BYTE*)szBuf, &dwSize );
                    fError = ( lResult != ERROR_SUCCESS || dwType != REG_SZ );
                    if ( !fError )
                    {
                        AnsiString as(szBuf);
                        strncpyz( ron.szLongName, (const char*)as, ARRAY_LENGTH(ron.szLongName) );
                        ron.dwParams |= RIL_PARAM_ON_LONGNAME;
                    }
                }

                if ( !fError )
                {
                    TCHAR szBuf[ARRAY_LENGTH(ron.szShortName)];
                    dwSize = sizeof(szBuf);
                    lResult = RegQueryValueEx( hkey2, TEXT("short name"), NULL, &dwType, (BYTE*)szBuf, &dwSize );
                    if ( lResult == ERROR_SUCCESS && dwType == REG_SZ )
                    {
                        AnsiString as(szBuf);
                        strncpyz( ron.szShortName, (const char*)as, ARRAY_LENGTH(ron.szShortName) );
                        ron.dwParams |= RIL_PARAM_ON_SHORTNAME;
                    }
                    else if ( lResult == ERROR_FILE_NOT_FOUND )
                    {
                        /* ok -- short name is optional */
                    }
                    else
                    {
                        fError = TRUE;
                    }
                }

                if ( !fError )
                {
                    m_pnn.AddThing( ron );
                }
            }
            else if ( lResult == ERROR_FILE_NOT_FOUND )
            {
                fDone = TRUE;
                hr = S_OK;
            }
            else
            {
                fDone = TRUE;
                hr = HRESULT_FROM_WIN32( lResult );
            }

            if ( hkey2 != NULL )
            {
                RegCloseKey( hkey2 );
            }
            hkey2 = NULL;
        }
    }
    else if ( lResult == ERROR_FILE_NOT_FOUND )
    {
        /* cache doesnt exist; treat as no items */
        hr = S_OK;
    }
    else
    {
        hr = HRESULT_FROM_WIN32( lResult );
    }

    if ( hkey != NULL )
    {
        RegCloseKey( hkey );
    }
    hkey = NULL;

    return hr;
}

HRESULT
EONSCache::WriteOPLData()
{
    HRESULT hr = S_OK;

    StringBuffer key;
    key.Set( RegistryPath );
    key.Append( TEXT("\\opl") );

    LONG lResult = RegDeleteKey( RIL_REGISTRY_ROOT, key );

    int c = m_opl.GetSize();
    if ( c > 0 )
    {
        HKEY hkey = NULL;
        DWORD dwDisposition = 0;
        lResult = RegCreateKeyEx( RIL_REGISTRY_ROOT, key, 0, NULL, 0, 0, NULL, &hkey, &dwDisposition );
        if ( lResult == ERROR_SUCCESS )
        {
            TCHAR subkey[16];
            BOOL fError = FALSE;

            for( int i = 0; i < c && !fError; i++ )
            {
                _sntprintfz( subkey, ARRAY_LENGTH(subkey), TEXT("%d"), i+1 );

                HKEY hkey2 = NULL;
                lResult = RegCreateKeyEx( hkey, subkey, 0, NULL, 0, 0, NULL, &hkey2, &dwDisposition );
                if ( lResult == ERROR_SUCCESS )
                {
                    OPLStruct opl = m_opl.GetThingAtIndex( i );

                    DWORD dwSize = 0;

                    {
                        WideString ws( opl.szPLMN );
                        dwSize = ( ( strlen(opl.szPLMN) + 1 ) * sizeof(TCHAR) );
                        lResult = RegSetValueEx( hkey2, TEXT("PLMN"), 0, REG_SZ, (BYTE*)(const TCHAR *)ws, dwSize );
                        if ( lResult != ERROR_SUCCESS )
                        {
                            fError = TRUE;
                            hr = HRESULT_FROM_WIN32( lResult );
                        }
                    }

                    if ( !fError )
                    {
                        dwSize = sizeof(opl.dwLACa);
                        lResult = RegSetValueEx( hkey2, TEXT("start LAC"), 0, REG_DWORD, (BYTE*)&opl.dwLACa, dwSize );
                        if ( lResult != ERROR_SUCCESS )
                        {
                            fError = TRUE;
                            hr = HRESULT_FROM_WIN32( lResult );
                        }
                    }

                    if ( !fError )
                    {
                        dwSize = sizeof(opl.dwLACz);
                        lResult = RegSetValueEx( hkey2, TEXT("end LAC"), 0, REG_DWORD, (BYTE*)&opl.dwLACz, dwSize );
                        if ( lResult != ERROR_SUCCESS )
                        {
                            fError = TRUE;
                            hr = HRESULT_FROM_WIN32( lResult );
                        }
                    }

                    if ( !fError )
                    {
                        dwSize = sizeof(opl.dwIndex);
                        lResult = RegSetValueEx( hkey2, TEXT("index"), 0, REG_DWORD, (BYTE*)&opl.dwIndex, dwSize );
                        if ( lResult != ERROR_SUCCESS )
                        {
                            fError = TRUE;
                            hr = HRESULT_FROM_WIN32( lResult );
                        }
                    }
                }
                else
                {
                    fError = TRUE;
                    hr = HRESULT_FROM_WIN32( lResult );
                }

                if ( hkey2 != NULL )
                {
                    RegCloseKey( hkey2 );
                }
                hkey2 = NULL;
            }
        }
        else
        {
            hr = HRESULT_FROM_WIN32( lResult );
        }

        if ( hkey != NULL )
        {
            RegCloseKey( hkey );
        }
        hkey = NULL;
    }
    
    return hr;
}

HRESULT
EONSCache::WritePNNData()
{
    HRESULT hr = S_OK;

    StringBuffer key;
    key.Set( RegistryPath );
    key.Append( TEXT("\\pnn") );

    LONG lResult = RegDeleteKey( RIL_REGISTRY_ROOT, key );

    int c = m_pnn.GetSize();
    if ( c > 0 )
    {
        HKEY hkey = NULL;
        DWORD dwDisposition = 0;
        lResult = RegCreateKeyEx( RIL_REGISTRY_ROOT, key, 0, NULL, 0, 0, NULL, &hkey, &dwDisposition );
        if ( lResult == ERROR_SUCCESS )
        {
            TCHAR subkey[16];
            BOOL fError = FALSE;

            for( int i = 0; i < c && !fError; i++ )
            {
                _sntprintfz( subkey, ARRAY_LENGTH(subkey), TEXT("%d"), i+1 );

                HKEY hkey2 = NULL;
                lResult = RegCreateKeyEx( hkey, subkey, 0, NULL, 0, 0, NULL, &hkey2, &dwDisposition );
                if ( lResult == ERROR_SUCCESS )
                {
                    RILOPERATORNAMES ron = m_pnn.GetThingAtIndex( i );

                    DWORD dwSize = 0;

                    if ( ron.dwParams & RIL_PARAM_ON_LONGNAME )
                    {
                        WideString ws( ron.szLongName );
                        dwSize = ( ( strlen(ron.szLongName) + 1 ) * sizeof(TCHAR) );
                        lResult = RegSetValueEx( hkey2, TEXT("long name"), 0, REG_SZ, (BYTE*)(const TCHAR *)ws, dwSize );
                        if ( lResult != ERROR_SUCCESS )
                        {
                            fError = TRUE;
                            hr = HRESULT_FROM_WIN32( lResult );
                        }
                    }

                    if ( !fError )
                    {
                        if ( ron.dwParams & RIL_PARAM_ON_SHORTNAME )
                        {
                            WideString ws( ron.szShortName );
                            dwSize = ( ( strlen(ron.szShortName) + 1 ) * sizeof(TCHAR) );
                            lResult = RegSetValueEx( hkey2, TEXT("short name"), 0, REG_SZ, (BYTE*)(const TCHAR *)ws, dwSize );
                            if ( lResult != ERROR_SUCCESS )
                            {
                                fError = TRUE;
                                hr = HRESULT_FROM_WIN32( lResult );
                            }
                        }
                    }
                }
                else
                {
                    fError = TRUE;
                    hr = HRESULT_FROM_WIN32( lResult );
                }

                if ( hkey2 != NULL )
                {
                    RegCloseKey( hkey2 );
                }
                hkey2 = NULL;
            }
        }
        else
        {
            hr = HRESULT_FROM_WIN32( lResult );
        }

        if ( hkey != NULL )
        {
            RegCloseKey( hkey );
        }
        hkey = NULL;
    }
    
    return hr;
}