dvb_caservice.c

我国有线电视条件接受标准目前还没有统一

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "custom.h"
#ifdef EEPROM_FLASH_STORE_INFO
#include "flash.h"
#endif
#include "DVB_CADb.h"
#include "DVB_CAService.h"
#include "dvb_ca.h"

//#define DVB_CA_DBG

#ifndef DVB_CA_DBG
	#define ca_printf(f, a...) 	do {} while (0)
#else
	#define ca_printf(f, a...)	 ecos_printf(f, ##a)
#endif

#define	DVB_CA_MAIGC_CODE	0xbeaf

#ifndef EEPROM_FLASH_STORE_INFO
static UINT8 g_ucTempFlash[64 * 1024];
#endif

static ST_SERVICE g_stService;
static int g_iRefresh = 0;


static int DVB_CAService_FlashRead(UINT32 iStartAddr, BYTE *pBuf, UINT32 iLen);
static int DVB_CAService_FlashWrite(UINT32 iStartAddr, BYTE *pBuf, UINT32 iLen);
static int DVB_CAService_FlashEarse(UINT32 uiStartAdd, UINT32 iLen);
static int DVB_CAService_LoadServiceTable(void);
static int DVB_CAService_LoadStbMark(void);
#if defined(SDT_CA_50)
static int DVB_CAService_LoadNetName(void);
static int DVB_CAService_LoadFreqVer(void);
static int DVB_CAService_LoadFaceTime(void);
#endif
static int DVB_CAService_LoadNetwork(void);
static int DVB_CAService_Load(void);
static void DVB_CAService_Save(void);

UINT16 DVB_CAService_GetSuperPassword(void)
{
	UINT16 usDate = 0;
	S_Time stTime;
	UINT8 aucSuperPass[5];
	UINT16 usSuperPass = 0;

	memset(&stTime, 0x0, sizeof(S_Time));
	
	DVB_CADB_Get(CA_DB_CMD_DATE, &usDate);
	Trans2YMD(usDate, &(stTime.YY), &(stTime.MM), &(stTime.DD));
	ecos_printf("%d:%d:%d:%d:%d\n",stTime.YY, stTime.MM, stTime.DD, DVB_CAService_GetNetwork(),usDate);
	memset(aucSuperPass, 0x0, 4);
	lockkey(aucSuperPass, &stTime, DVB_CAService_GetNetwork());
	aucSuperPass[0] -= '0';
	aucSuperPass[1] -= '0';
	aucSuperPass[2] -= '0';
	aucSuperPass[3] -= '0';
	ecos_printf("Super Password:%d:%d:%d:%d\n",aucSuperPass[0],aucSuperPass[1],aucSuperPass[2],aucSuperPass[3]);
	
	usSuperPass = (UINT16)(((aucSuperPass[0] & 0x0F) << 12) | ((aucSuperPass[1] & 0x0F) << 8)
				| ((aucSuperPass[2] & 0x0F) << 4) | ((aucSuperPass[3] & 0x0F)));

	return usSuperPass;
}

UINT32 DVB_CAService_GetNetwork(void)
{
	if(g_stService.uiNetworkID == 0xFFFFFFFF)
		return 0;
	else
		return g_stService.uiNetworkID;
}

void DVB_CAService_Init(void)
{
	#ifndef EEPROM_FLASH_STORE_INFO
//	memset(g_ucTempFlash, 0xFF, 64 * 1024);
	#endif

	if(DVB_CAService_Load() < 0)
		DVB_CAService_Save();

}

void DVB_CAService_Default(void)
{
	DVB_CAService_FlashEarse(DVB_CA_SERVICE_ADDR, 64 * 1024);
	g_stService.uiMagic = DVB_CA_MAIGC_CODE;
	DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_HEAD_OFFSET, (UINT8 *)&g_stService.uiMagic, DVB_CA_SERVICE_HEAD_SIZE);
	DVB_CAService_Init();
}

#if defined(SDT_CA_50)
UINT8 DVB_CAService_GetCtrl(void)
{
	return g_stService.stServiceTable.ucCtrl;
}
int DVB_CAService_SetFreqVer(UINT8 ucFreqVer)
{
	int iResult = 0;
	UINT8 ucLastFreqVer = 0xFF;
	int iPos;
	if(ucFreqVer == 0xFF || ucFreqVer == g_stService.ucFreqVer)
		return iResult;


	g_stService.ucFreqVer = ucFreqVer;
	
	for(iPos = 0; iPos < DVB_CA_SERVICE_FREQVER_TIMES; iPos++)
	{
		UINT8 ucTempFreqVer = 0xFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FREQVER_OFFSET + iPos *sizeof(UINT8) ,&ucTempFreqVer, sizeof(UINT8));
		if(ucTempFreqVer == 0xFF)
			break;
		ucLastFreqVer = ucTempFreqVer;
	}

	if(iPos < DVB_CA_SERVICE_FREQVER_TIMES)
	{
		if(iPos > 0 && ((ucLastFreqVer & ucFreqVer) == ucFreqVer))
			iPos--;
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FREQVER_OFFSET + iPos *sizeof(UINT8) ,(UINT8 *)&ucFreqVer, sizeof(UINT8));
	}
	
	if(iPos >= ((DVB_CA_SERVICE_FREQVER_TIMES * 2) / 3))
	{
		g_iRefresh = 1;
	}		
	iResult = 1;
	return iResult;
}
UINT8 DVB_CAService_GetFreqVer(void)
{
	return g_stService.ucFreqVer;
}
void DVB_CAService_SetFaceTime(UINT8 ucFaceTime)
{
	UINT8 ucLastFaceTime = 0xFF;
	int iPos;
	
	if(ucFaceTime == 0xFF || ucFaceTime == g_stService.ucFaceTime)
		return;

	g_stService.ucFaceTime = ucFaceTime;
	
	for(iPos = 0; iPos < DVB_CA_SERVICE_FACETIME_TIMES; iPos++)
	{
		UINT8 ucTempFaceTime = 0xFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FACETIME_OFFSET+ iPos *sizeof(UINT8) ,&ucTempFaceTime, sizeof(UINT8));
		if(ucTempFaceTime == 0xFF)
			break;
		ucLastFaceTime = ucTempFaceTime;
	}

	if(iPos < DVB_CA_SERVICE_FACETIME_TIMES)
	{
		if(iPos > 0 && ((ucLastFaceTime & ucFaceTime) == ucFaceTime))
			iPos--;
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FACETIME_OFFSET + iPos *sizeof(UINT8) ,(UINT8 *)&ucFaceTime, sizeof(UINT8));
	}
	
	if(iPos >= ((DVB_CA_SERVICE_FACETIME_TIMES * 2) / 3))
	{
		g_iRefresh = 1;
	}		
}

UINT8 DVB_CAService_GetFaceTime(void)
{
	return g_stService.ucFaceTime;
}

void DVB_CAService_SetNetName(UINT8 *pucNetName)
{
	int iPos;
	
	if(strcmp(g_stService.aucNetName, pucNetName) == 0)
		return;

	memset(g_stService.aucNetName, 0x0, NET_NAME_LEN + 1);
	memcpy(g_stService.aucNetName, pucNetName, NET_NAME_LEN);
	
	for(iPos = 0; iPos < DVB_CA_SERVICE_NETNAME_TIMES; iPos++)
	{
		UINT8 aucNetName[NET_NAME_LEN];
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETNAME_OFFSET+ iPos * NET_NAME_LEN,aucNetName, NET_NAME_LEN);
		if(aucNetName[0] == 0xFF)
			break;
	}

	if(iPos < DVB_CA_SERVICE_NETNAME_TIMES)
	{
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETNAME_OFFSET+ iPos * NET_NAME_LEN ,g_stService.aucNetName, NET_NAME_LEN);
	}
	
	if(iPos >= ((DVB_CA_SERVICE_NETNAME_TIMES * 2) / 3))
	{
		g_iRefresh = 1;
	}		
}

void DVB_CAService_GetNetName(UINT8 *pucNetName)
{
	memset(pucNetName, 0x0, NET_NAME_LEN);
	memcpy(pucNetName, g_stService.aucNetName,NET_NAME_LEN);
}

#endif

UINT32 DVB_CAService_GetServiceDate(UINT16 usTsID)
{
	UINT32 uiServiceDate = 0;
	UINT8 ucProductID = 0;
	int i = 0;
	UINT32 uiSmartCardID = 0;
	UINT32 uiStbID = 0x00;

	DVB_CADB_Get(CA_DB_CMD_STB_ID, (void *)&uiStbID);
	DVB_CADB_Get(CA_DB_CMD_SMART_ID, (void *)&uiSmartCardID);

	if(g_stService.stServiceTable.ucEnable == 0x00)
	{
		return uiServiceDate;
	}
	else if(g_stService.stServiceTable.ucEnable == 0x0F)
	{
		return uiServiceDate;
	}

	if(g_stService.ucStbMark == 0x01)
	{
		#if defined(SDT_CA_40)
		if((uiStbID != g_stService.stServiceTable.uiStbID  && g_stService.stServiceTable.uiStbID != 0xFFFFFFFF)
			|| (uiSmartCardID != g_stService.stServiceTable.uiSmartCardID && g_stService.stServiceTable.uiSmartCardID != 0xFFFFFFFF))
		#elif defined(SDT_CA_50)
		if((uiStbID != g_stService.stServiceTable.uiStbID0  && uiStbID != g_stService.stServiceTable.uiStbID1  
			&& uiStbID != g_stService.stServiceTable.uiStbID2  && uiStbID != g_stService.stServiceTable.uiStbID3 
			&& (g_stService.stServiceTable.uiStbID0 != 0xFFFFFFFF) && (g_stService.stServiceTable.uiStbID1 != 0xFFFFFFFF)
			&& (g_stService.stServiceTable.uiStbID2 != 0xFFFFFFFF) && (g_stService.stServiceTable.uiStbID3 != 0xFFFFFFFF))
			|| (uiSmartCardID != g_stService.stServiceTable.uiSmartCardID && g_stService.stServiceTable.uiSmartCardID != 0xFFFFFFFF))
		#endif
		{
			return uiServiceDate;
		}
	}

	if( g_stService.stServiceTable.uiAreaID != 0xFFFFFFFF 
		&& g_stService.stServiceTable.uiAreaID != 0
		&& g_stService.uiDisableAreaNum != 0xFF)
	{
		for(i = 0; i < g_stService.uiDisableAreaNum; i++)
		{
			if(g_stService.stServiceTable.uiAreaID == g_stService.auiDisableArea[i])
			{
				return uiServiceDate;
			}
		}
	}

	for(i = 0; i < g_stService.stServiceTable.ucProductNum && uiServiceDate == 0
		&&g_stService.stServiceTable.ucProductNum != 0xFF; i++)
	{
		if(g_stService.stServiceTable.aucProductID[i] != 0xFF)
		{
			ucProductID = g_stService.stServiceTable.aucProductID[i];	
			if(ucProductID == usTsID)
			{
				uiServiceDate = g_stService.stServiceTable.auiEndTime[i];
			}
		}
	}

	return uiServiceDate;
}

int DVB_CAService_CheckPrograme(UINT16 usTsID)
{
	UINT8 ucProductID = 0;
	int i = 0;
	UINT32 uiCurTime;
	UINT16 usDate, usTime;
	int iResult = CA_SERVICE_INVALID_PROG;
	UINT32 uiSmartCardID = 0;
	UINT32 uiStbID = 0x00;

	DVB_CADB_Get(CA_DB_CMD_STB_ID, (void *)&uiStbID);
	DVB_CADB_Get(CA_DB_CMD_SMART_ID, (void *)&uiSmartCardID);

	if(g_stService.stServiceTable.ucEnable == 0x00)
	{
		ca_printf("Service Tabled unable!\n");
		return CA_SERVICE_STB_INVALID;
	}
	else if(g_stService.stServiceTable.ucEnable == 0x0F)
	{
		ca_printf("Product disable1!\n");
		return CA_SERVICE_INVALID_PROG;
	}
	
	if(g_stService.ucStbMark == 0x01)
	{
#if defined(SDT_CA_40)
		if((uiStbID != g_stService.stServiceTable.uiStbID  && g_stService.stServiceTable.uiStbID != 0xFFFFFFFF)
			|| (uiSmartCardID != g_stService.stServiceTable.uiSmartCardID && g_stService.stServiceTable.uiSmartCardID != 0xFFFFFFFF))
		{
			ca_printf("STB ID ERROF or Smart ID ERROR!\n");
			return CA_SERVICE_REQUEST_STB_MARK;
		}
#elif defined(SDT_CA_50)
		if((uiStbID != g_stService.stServiceTable.uiStbID0  && uiStbID != g_stService.stServiceTable.uiStbID1  
			&& uiStbID != g_stService.stServiceTable.uiStbID2  && uiStbID != g_stService.stServiceTable.uiStbID3 
			&& (g_stService.stServiceTable.uiStbID0 != 0xFFFFFFFF) && (g_stService.stServiceTable.uiStbID1 != 0xFFFFFFFF)
			&& (g_stService.stServiceTable.uiStbID2 != 0xFFFFFFFF) && (g_stService.stServiceTable.uiStbID3 != 0xFFFFFFFF))
			|| (uiSmartCardID != g_stService.stServiceTable.uiSmartCardID && g_stService.stServiceTable.uiSmartCardID != 0xFFFFFFFF))
		{
			ca_printf("STB ID ERROF or Smart ID ERROR:%d:%08x:%08x:%08x:%08x:%08x!\n",g_stService.ucStbMark,
				uiStbID, g_stService.stServiceTable.uiStbID0,g_stService.stServiceTable.uiStbID1,
				g_stService.stServiceTable.uiStbID2,g_stService.stServiceTable.uiStbID3);
			return CA_SERVICE_REQUEST_STB_MARK;
		}
#endif
	}
		
	if( g_stService.stServiceTable.uiAreaID != 0xFFFFFFFF 
		&& g_stService.stServiceTable.uiAreaID != 0
		&& g_stService.uiDisableAreaNum != 0xFF)
	{
		for(i = 0; i < g_stService.uiDisableAreaNum; i++)
		{
			if(g_stService.stServiceTable.uiAreaID == g_stService.auiDisableArea[i])
			{
				ca_printf("Area disable!%x:%x\n",g_stService.stServiceTable.uiAreaID,g_stService.auiDisableArea[i]);
				return CA_SERVICE_DISABLE_AREA;
			}
		}
	}
	
	#if defined(SDT_CA_50)
	if(usTsID == 0xFFFF)
		return 0;
	#endif
	
	DVB_CADB_Get(CA_DB_CMD_DATE, &usDate);
	DVB_CADB_Get(CA_DB_CMD_TIME, &usTime);
	uiCurTime = (usDate << 16 | usTime);
	ca_printf("g_stService.stServiceTable.ucProductNum:%d\n",g_stService.stServiceTable.ucProductNum);
	for(i = 0; i < g_stService.stServiceTable.ucProductNum && iResult == CA_SERVICE_INVALID_PROG
		&&g_stService.stServiceTable.ucProductNum != 0xFF; i++)
	{
		ca_printf("productID%d:%d\n",i,g_stService.stServiceTable.aucProductID[i] );
		if(g_stService.stServiceTable.aucProductID[i] != 0xFF)
		{
			ucProductID = g_stService.stServiceTable.aucProductID[i];

			ca_printf("Service%d:%d:%d:%x:%x:%x\n",i,ucProductID,usTsID,uiCurTime,
				g_stService.stServiceTable.auiEndTime[i],g_stService.stServiceTable.auiStartTime[i]);
			if(ucProductID == usTsID)
			{
				if((uiCurTime == 0xFFFFFFFF) || (uiCurTime <= g_stService.stServiceTable.auiEndTime[i]
					&& uiCurTime >= g_stService.stServiceTable.auiStartTime[i]))
				{
					iResult = CA_SERVICE_SUCCESS;
				}
			}
		}
	}
	if(iResult != CA_SERVICE_SUCCESS)
		ca_printf("Product disable!\n");
	return iResult;
}

void DVB_CAService_SetDisableArea(UINT8  uiDisableAreaNum, UINT32 *puiDisableArea)
{
	if(uiDisableAreaNum > 0)
	{
		g_stService.uiDisableAreaNum = uiDisableAreaNum;		
		memcpy(g_stService.auiDisableArea, puiDisableArea, uiDisableAreaNum * sizeof(UINT32));
	}
	else
	{
		g_stService.uiDisableAreaNum = 0;		
		memset(g_stService.auiDisableArea, 0x0, 256 * sizeof(UINT32));
	}
}

void DVB_CAService_CheckRefresh(void)
{
	if(g_iRefresh == 0)
		return;
	DVB_CAService_Save();
}

int DVB_CAService_SetService(S_EMM *pstService)
{
	int iPos = 0;
	UINT32 uiDays = 0;
	UINT32 uiSmartCardID = 0;
	
	ca_printf("DVB_CAService_SetService\n");
	if(pstService == NULL)
		return -1;

	DVB_CADB_Get(CA_DB_CMD_SMART_ID, (void *)&uiSmartCardID);
	ca_printf("%08x:%08x\n",uiSmartCardID, pstService->card_ID);
	if(uiSmartCardID != pstService->card_ID)
		return -1;
	ca_printf("ver:%x:%x\n",pstService->version_ID , g_stService.stServiceTable.ucVer);
	if(pstService->version_ID == g_stService.stServiceTable.ucVer)
		return -1;
	ca_printf("Smart:%x:%x\n",uiSmartCardID, pstService->card_ID);
	memset(&g_stService.stServiceTable, 0xFF, sizeof(ST_SERVICE_TABLE));
	
	g_stService.stServiceTable.ucVer = pstService->version_ID;
	g_stService.stServiceTable.uiSmartCardID = pstService->card_ID;
	
	#if defined(SDT_CA_40)
	g_stService.stServiceTable.uiStbID = pstService->stbno;
	#elif defined(SDT_CA_50)
	g_stService.stServiceTable.ucEigenvalue = pstService->eigenvalue;
	g_stService.stServiceTable.ucCtrl = pstService->ctrl;
	g_stService.stServiceTable.uiStbID0 = pstService->stbno0;
	g_stService.stServiceTable.uiStbID1 = pstService->stbno1;
	g_stService.stServiceTable.uiStbID2 = pstService->stbno2;
	g_stService.stServiceTable.uiStbID3 = pstService->stbno3;
	#endif
	
	g_stService.stServiceTable.uiAreaID = pstService->areano;
	g_stService.stServiceTable.ucProductNum = pstService->product_sum;
	ca_printf("uiAreaID:%x\n",g_stService.stServiceTable.uiAreaID);
	ca_printf("ucProductNum:%d\n",g_stService.stServiceTable.ucProductNum);
	if(g_stService.stServiceTable.ucProductNum > MAX_PRODUCT_NUM)
		g_stService.stServiceTable.ucProductNum = MAX_PRODUCT_NUM;
	for(iPos = 0; iPos < pstService->product_sum; iPos++)
	{
		ca_printf("Product%d:ID:%d %d/%d/%d %d:%d:%d-%d/%d/%d %d:%d:%d\n",
			iPos, pstService->product_list[iPos].product_ID, pstService->product_list[iPos].start_date.YY,
			pstService->product_list[iPos].start_date.MM,	pstService->product_list[iPos].start_date.DD,
			pstService->product_list[iPos].start_date.HH, pstService->product_list[iPos].start_date.MINUTE,
			pstService->product_list[iPos].start_date.SS, pstService->product_list[iPos].end_date.YY,
			pstService->product_list[iPos].end_date.MM,	pstService->product_list[iPos].end_date.DD,
			pstService->product_list[iPos].end_date.HH, pstService->product_list[iPos].end_date.MINUTE,