cas_cch.c

EMU_FTAbox_ref441328_code_source ali m3327

                            memcpy(pTempKey->keys, pFlash, pTempCAS->key_size);
            			pFlash += pTempCAS->key_size;
            		}
            	}
            }
        }
        
    }
    else{
#ifdef CAS_CCH_DEBUG
	cas_print("RearrangeCASEditDBFromFlash::Unknown patch file format <length check>!\r\n");
#endif
	return CAS_FALSE;        
    }


#ifdef CAS_CCH_DEBUG

{
    char tempStr[100];
    sprintf(tempStr, "RearrangeCASEditDBFromFlash -->  0x%x  (>= %d k) memory alloced\r\n",memory_alloced, memory_alloced/1024);
    cas_print(tempStr);
}

#endif

    if(g_nCASEditCount == 0){
#ifdef CAS_CCH_DEBUG
        cas_print("RearrangeCASEditDBFromFlash :: CAS count == 0    read patch data failed\r\n");
#endif
        return FALSE;
    }
    
#ifdef CAS_CCH_DEBUG
    cas_print("RearrangeCASEditDBFromFlash :: succeed\r\n");
#endif

    return CAS_TRUE;
}

CAS_BOOL ConvertCASEditDBToFlash(unsigned char *pFlash, unsigned long int nMaxFlashDataSizeForPatch)
{
    CAS_BYTE *pHeader = pFlash;
    unsigned long int dataLength = 0;
    int w;
    unsigned long int crc32Data;
    int i,j,k,mm,nn;
    CAS_BYTE nNameLength;
    cas_edit_cas_db *pTempCAS;
    cas_edit_provider_db *pTempProvider;
    cas_edit_key_db *pTempKey;

#ifdef CAS_CCH_DEBUG
cas_print("ConvertCASEditDBToFlash :: started\r\n");
#endif

    pFlash += 16;//skip the header

    pFlash += 4;//data length ,,we will fiil it after all the converted

    memset(pHeader+16, 0, nMaxFlashDataSizeForPatch-16);//clear the data

    //convert data
    pFlash[0] = g_nCASEditCount;//CAS 数量
    pFlash ++;

    for( i=0 ; i<g_nCASEditCount ; i++){
       pTempCAS =  g_CASEditDB[i];
       pFlash[0] =  cas_strlen(pTempCAS->cas_name);//cas 名称长度 一个字节
    	nNameLength = pFlash[0];
    	pFlash ++;
   
    	pFlash[0] = pTempCAS->key_type;//cas 对应key类型 一个字节
    	pFlash ++;

    	for(mm = 0 ; mm<nNameLength; mm++){//如果cas 名称有定义 加上字节数
    		pFlash[0] = pTempCAS->cas_name[mm];
    		pFlash ++;
    	}

    	for(nn=0 ; nn<MAX_CAS_ID_LENGTH ; nn++){//CAS ID
    	       pFlash[0] = ((pTempCAS->ca_id >> (MAX_CAS_ID_LENGTH-nn-1)*8) & 0xff);
    		pFlash ++;
    	}

       pFlash[0] = pTempCAS->key_size;//cas 对应下面 key的长度 8/16/....  一个字节
    	pFlash ++;

    	pFlash[0] = pTempCAS->provider_count;//CAS 对应的 provider 数量，一个字节
    	pFlash ++;

    	for(j=0 ; j<pTempCAS->provider_count ; j++){
              pTempProvider = pTempCAS->pCasEditProviderDb[j];
              
              pFlash[0] = cas_strlen(pTempProvider->provider_name);//provider 名称长度 一个字节
    		nNameLength = pFlash[0];
    		pFlash ++;
          
    		for(mm = 0 ; mm<nNameLength ; mm++){//如果provider 名称有定义 加上字节数
    			pFlash[0] = pTempProvider->provider_name[mm];
    			pFlash ++;
    		}

        	for(nn=0 ; nn<MAX_PROVIDER_ID_LENGTH ; nn++){//provider ID
        	       pFlash[0] = ((pTempProvider->provider_id >> (MAX_PROVIDER_ID_LENGTH-nn-1)*8) & 0xff);
        		pFlash ++;        	
        	}

    		pFlash[0] = pTempProvider->key_count;//provider 对应的 key 数量，一个字节
    		pFlash ++;

    		for( k=0; k<pTempProvider->key_count ; k++){       
                    pTempKey = pTempProvider->pCasEditKeyDb[k];
                    
                    pFlash[0] = pTempKey->key_id;//key ID    一个字节
    		      pFlash ++;

                    memcpy(pFlash, pTempKey->keys, pTempCAS->key_size);
    		      pFlash += pTempCAS->key_size;
    		}
    	}
    }

 //convert data ended
//fill the data length content
    dataLength = (unsigned long int)(pFlash - pHeader);

    dataLength +=4;//add the length of CRC32
    
    pFlash = pHeader + 16;//
    for( w=0 ; w<4; w++){//文件长度
    	pFlash[w] = (CAS_BYTE)((dataLength >> (4-w-1)*8) & 0xff);
    }
    
//compute CRC32 and fill it
    crc32Data = cas_computeCRC32(pHeader, dataLength-4);

    pFlash = pHeader + dataLength -4;
    for( w=0 ; w<4; w++){//写入CRC32
    	pFlash[w] = (CAS_BYTE)((crc32Data >> (4-w-1)*8) & 0xff);
    }

#ifdef CAS_CCH_DEBUG
    cas_print("ConvertCASEditDBToFlash :: ended\r\n");
#endif
    return CAS_TRUE;
}

CAS_BOOL ConvertCASEditDBToPatchLib(unsigned char *pData, unsigned long nPatchLibSize, unsigned long uUndateKeyFlag)
{
    int i,j,k;
    cas_key_db *pTempCasKeyDb = (cas_key_db*)pData;
    cas_edit_cas_db *pTempCAS;
    cas_edit_provider_db *pTempProvider;
    cas_edit_key_db *pTempKey;

#ifdef CAS_CCH_DEBUG
cas_print("ConvertCASEditDBToPatchLib :: started\r\n");
#endif

    memset(pData, 0xff, nPatchLibSize);

    //convert data
    for( i=0 ; i<g_nCASEditCount ; i++){
        pTempCAS = g_CASEditDB[i];

        for(j=0 ; j<pTempCAS->provider_count ; j++){
            pTempProvider = pTempCAS->pCasEditProviderDb[j];

            for( k=0; k<pTempProvider->key_count ; k++){      
                pTempKey = pTempProvider->pCasEditKeyDb[k];

                pTempCasKeyDb->ca_id = pTempCAS->ca_id;
                pTempCasKeyDb->key_type = pTempCAS->key_type;
                
                pTempCasKeyDb->provider = pTempProvider->provider_id;
                
                memset(pTempCasKeyDb->key, 0, 16);
                memcpy(pTempCasKeyDb->key, pTempKey->keys, pTempCAS->key_size);

                pTempCasKeyDb->index = pTempKey->key_id;
                
                pTempCasKeyDb ++;
                
                if(((unsigned char *)pTempCasKeyDb - pData) >=  nPatchLibSize-2*sizeof(cas_key_db)){
                     //out of the memory range
#ifdef CAS_CCH_DEBUG
                     cas_print("out of the memory range    goto END_CONVERT\r\n");
#endif
                     goto END_CONVERT;
                }
            }
        }
    }

END_CONVERT:

//add the last item

/* provider of end_key_db is version of key db */
/* if version is updated, then reset key db automatically */

    if(g_nCASEditCount > 0){
        memcpy((void*)pTempCasKeyDb, (void*)(&end_key_db), sizeof(cas_key_db));
        
        pTempCasKeyDb->provider = uUndateKeyFlag;
    }
    else{//not any available CAS, use the default database
#ifdef CAS_CCH_DEBUG
        cas_print("ConvertCASEditDBToPatchLib :: not any available CAS, use the default database\r\n");
#endif
        
        memcpy((void*)pData, (void*)init_cas_key_db, sizeof(init_cas_key_db));

        pTempCasKeyDb = (cas_key_db*)(pData + sizeof(init_cas_key_db));

        memcpy((void*)pTempCasKeyDb, (void*)(&end_key_db), sizeof(cas_key_db));        
    }

#ifdef CAS_CCH_DEBUG
    cas_print("ConvertCASEditDBToPatchLib :: ended\r\n");
#endif
    return CAS_TRUE;

}

CAS_BOOL UpdateCASEditDBFromPatchLib(unsigned char *pData, unsigned long nPatchLibSize)
{
    int i,j,k;
    cas_key_db *pTempCasKeyDb = (cas_key_db*)pData;
    cas_edit_cas_db *pTempCAS;
    cas_edit_provider_db *pTempProvider;
    cas_edit_key_db *pTempKey;

#ifdef CAS_CCH_DEBUG
cas_print("UpdateCASEditDBFromPatchLib :: started\r\n");
#endif

    //convert data
    for( i=0 ; i<g_nCASEditCount ; i++){
        pTempCAS = g_CASEditDB[i];

        for(j=0 ; j<pTempCAS->provider_count ; j++){
            pTempProvider = pTempCAS->pCasEditProviderDb[j];

            for( k=0; k<pTempProvider->key_count ; k++){      
                pTempKey = pTempProvider->pCasEditKeyDb[k];

                memset(pTempKey->keys, 0, 16);
                memcpy(pTempKey->keys, pTempCasKeyDb->key, pTempCAS->key_size);
                
                pTempCasKeyDb ++;
                
                if(((unsigned char *)pTempCasKeyDb - pData) >=  nPatchLibSize-2*sizeof(cas_key_db)){
                     //out of the memory range  //this should never happended,  abnormally otherwise
#ifdef CAS_CCH_DEBUG
                     cas_print("out of the memory range    goto END_CONVERT\r\n");
#endif
                     goto END_UPDATE;
                }
            }
        }
    }

    if(g_nCASEditCount == 0){
#ifdef CAS_CCH_DEBUG
        cas_print("UpdateCASEditDBFromPatchLib :: not cas to updated\r\n");         #endif
    }

END_UPDATE:

#ifdef CAS_CCH_DEBUG
    cas_print("UpdateCASEditDBFromPatchLib :: ended\r\n");
#endif
    return CAS_TRUE;

}

//
//for OSD operation

static cas_key_for_osd *pCASKeyForOSD =  CAS_NULL;
static int nCurrentCASIndexForOSD = 0;
static int nItemCountForOSD = 0;
static CAS_BOOL bNeedSaveForOSD = CAS_FALSE;
static int nCountByOneKeyForOSD = 0;

static int CAS_OSD_Compute_ItemCount(int nCASIndex);
static void CAS_OSD_ReleaseData(void);

int CAS_OSD_Compute_ItemCount(int nCASIndex)
{
    cas_edit_cas_db *pTempCAS;
    cas_edit_provider_db *pTempProvider;
    int j;

    int nItemCount = 0;

    pTempCAS = g_CASEditDB[nCASIndex];

    for(j=0 ; j<pTempCAS->provider_count ; j++){
        pTempProvider = pTempCAS->pCasEditProviderDb[j];

        nItemCount += pTempProvider->key_count;
    }

    nItemCount *= pTempCAS->key_size;
    nItemCount /= CAS_KEY_OSD_PER_ROW_KEYS;

    return nItemCount;
}

void CAS_OSD_ReleaseData(void)
{
    if(pCASKeyForOSD != CAS_NULL){
        cas_free((void*)pCASKeyForOSD);

#ifdef CAS_CCH_DEBUG
        cas_print("CAS_OSD_ReleaseData -- > dealloc memory\r\n");
#endif       

        pCASKeyForOSD = CAS_NULL;        
    }

    nItemCountForOSD = 0;         
    bNeedSaveForOSD = CAS_FALSE;
    nCountByOneKeyForOSD = 0;    
}



int CAS_OSD_GetCASCount(void)
{
    return g_nCASEditCount;
}

char* CAS_OSD_GetCASName(int nCASIndex)
{
    return g_CASEditDB[nCASIndex]->cas_name;
}

char* CAS_OSD_GetCurrentCASName(void)
{
    return g_CASEditDB[nCurrentCASIndexForOSD]->cas_name;
}

int CAS_OSD_GetCASId(int nCASIndex)
{
    return g_CASEditDB[nCASIndex]->ca_id;
}

int CAS_OSD_GetCurrentCASId(void)
{
    return g_CASEditDB[nCurrentCASIndexForOSD]->ca_id;
}

char *CAS_OSD_GetProviderName(int nCASIndex, int nProviderIndex)
{
    return g_CASEditDB[nCASIndex]->pCasEditProviderDb[nProviderIndex]->provider_name;
}

char *CAS_OSD_GetProviderNameByItemIndex(int nItemIndex)
{
    return g_CASEditDB[nCurrentCASIndexForOSD]->pCasEditProviderDb[pCASKeyForOSD[nItemIndex].nProviderIndex]->provider_name;
}

int CAS_OSD_GetProviderId(int nCASIndex, int nProviderIndex)
{
    return g_CASEditDB[nCASIndex]->pCasEditProviderDb[nProviderIndex]->provider_id;
}

void CAS_OSD_SetCurrentCASIndex(int nCASIndex)
{
    nCurrentCASIndexForOSD = nCASIndex;
}

int CAS_OSD_GetCurrentCASIndex(void)
{
    return nCurrentCASIndexForOSD;
}

int CAS_OSD_GetItemCount(void)
{
    return nItemCountForOSD;
}

void CAS_OSD_ENTERED(void)
{
    nCurrentCASIndexForOSD = 0;
    nItemCountForOSD = 0;         
    bNeedSaveForOSD = CAS_FALSE;
    nCountByOneKeyForOSD = 0;
}

void CAS_OSD_EXITED(void)
{
    CAS_OSD_ReleaseData();
}

CAS_BOOL CAS_OSD_InitData(void)
{
    int i,j,k;
    cas_edit_cas_db *pTempCAS;
    cas_edit_provider_db *pTempProvider;
    cas_edit_key_db *pTempKey;
    cas_key_for_osd *pTempCASKeyForOSD;


    CAS_OSD_ReleaseData();
    
    nItemCountForOSD = CAS_OSD_Compute_ItemCount(nCurrentCASIndexForOSD);
    
    pCASKeyForOSD = (cas_key_for_osd*)cas_malloc(nItemCountForOSD*sizeof(cas_key_for_osd));

#ifdef CAS_CCH_DEBUG
    if(pCASKeyForOSD == CAS_NULL){
        cas_print("CAS_OSD_InitData -- > alloc memory error\r\n");
        return CAS_FALSE;
    }
    else{
        char tempStr[100];
        sprintf(tempStr, "CAS_OSD_InitData -- >  0x%x (>= %d k) memory alloced\r\n",nItemCountForOSD*sizeof(cas_key_for_osd),  (nItemCountForOSD*sizeof(cas_key_for_osd))/1024);
        cas_print(tempStr);
    }
#endif

    pTempCASKeyForOSD = pCASKeyForOSD;
        
    pTempCAS = g_CASEditDB[nCurrentCASIndexForOSD];

    nCountByOneKeyForOSD = pTempCAS->key_size/CAS_KEY_OSD_PER_ROW_KEYS;

    for(j=0 ; j<pTempCAS->provider_count ; j++){
        pTempProvider = pTempCAS->pCasEditProviderDb[j];

        for( k=0; k<pTempProvider->key_count ; k++){      
            pTempKey = pTempProvider->pCasEditKeyDb[k];

            for( i=0 ; i<nCountByOneKeyForOSD; i++){
                pTempCASKeyForOSD->nProviderIndex = j;
                pTempCASKeyForOSD->nKeyIndex = pTempKey->key_id;
                
                memcpy(pTempCASKeyForOSD->Keys, pTempKey->keys+(i*CAS_KEY_OSD_PER_ROW_KEYS), CAS_KEY_OSD_PER_ROW_KEYS);                

                pTempCASKeyForOSD ++;                
            }
        }
    }

    return CAS_TRUE;
}

void CAS_OSD_SetItemKeyOneChar(int nItemIndex, int nItemKeyIndex, char key)
{     
    pCASKeyForOSD[nItemIndex].Keys[nItemKeyIndex] = key;    
    bNeedSaveForOSD = CAS_TRUE;
}

void CAS_OSD_SetItemKeys(int nItemIndex, char *keys)
{
    memcpy(pCASKeyForOSD[nItemIndex].Keys, keys, CAS_KEY_OSD_PER_ROW_KEYS);    
    bNeedSaveForOSD = CAS_TRUE;
}

char CAS_OSD_GetItemKeyOneChar(int nItemIndex, int nItemKeyIndex)
{
    return pCASKeyForOSD[nItemIndex].Keys[nItemKeyIndex];
}

char CAS_OSD_GetItemKeyIndex(int nItemIndex)
{
    return pCASKeyForOSD[nItemIndex].nKeyIndex;
}

char CAS_OSD_GetItemProviderId(int nItemIndex, int nProviderSubIndex)
{
    char c;
        
    int nProviderIndex = pCASKeyForOSD[nItemIndex].nProviderIndex;
    
    unsigned long nProviderId = g_CASEditDB[nCurrentCASIndexForOSD]->pCasEditProviderDb[nProviderIndex]->provider_id;

    c = ((nProviderId >> (MAX_PROVIDER_ID_LENGTH-nProviderSubIndex-1)*8) & 0xff);    
    
    return c;
}


CAS_BOOL CAS_OSD_IsNeedSave(void)
{
    return bNeedSaveForOSD;
}

CAS_BOOL CAS_OSD_SaveData(void)
{
    int i,j,k;
    cas_edit_cas_db *pTempCAS;
    cas_edit_provider_db *pTempProvider;
    cas_edit_key_db *pTempKey;
    cas_key_for_osd *pTempCASKeyForOSD =  pCASKeyForOSD;
 
    pTempCAS = g_CASEditDB[nCurrentCASIndexForOSD];

    for(j=0 ; j<pTempCAS->provider_count ; j++){
        pTempProvider = pTempCAS->pCasEditProviderDb[j];

        for( k=0; k<pTempProvider->key_count ; k++){      
            pTempKey = pTempProvider->pCasEditKeyDb[k];

            for( i=0 ; i<nCountByOneKeyForOSD; i++){                
                memcpy(pTempKey->keys+(i*CAS_KEY_OSD_PER_ROW_KEYS), pTempCASKeyForOSD->Keys, CAS_KEY_OSD_PER_ROW_KEYS);                

                pTempCASKeyForOSD ++;                
            }
        }
    }

    cas_write_data_to_flash();

    cas_read_key_db();//enable the patch lib to read key data from current CAS Edit DB

    bNeedSaveForOSD = CAS_FALSE;

    return CAS_TRUE;
}