cas.c

EMU_FTAbox_ref441328_code_source ali m3327

	api_cas_send_msg(CAS_MSG_ECM, (UINT32)ecm_buffer);
}

static void emm_processor(UINT8 *emm_buf, UINT16 length)
{
	UINT16 emm_length;
#if 0
	UINT8 temp_emm[]=
		{
		0x82, 0x71,0x17,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B,0x4E,0x01,0x2A,0x3D,0xB7,0x18, 
		0x23, 0x70,0x58,0x00, 0x00,0x10,0x00, 0x0,0x40, 0x4B
	};
#endif
	emm_length=(emm_buf[1]&0x0F)<<8|emm_buf[2]+3;
	if(emm_buf == NULL)
	{
		api_cas_send_msg(CAS_MSG_TIMEOUT, 0);
		CAS_ERROR_PRINTF("Get emm time out\n");
		return;
	}

//#ifdef CAS_DEBUG
#if 0
	CAS_DEBUG_PRINTF("EMM info>>>>>>:emm_length=0x%x+3\n",emm_length-3);
	if(emm_length>=300)
		{
		CAS_DEBUG_PRINTF("EMM info is too long,only print 300\n");
		CAS_DUMP(emm_buf,300);
		}
	else
		CAS_DUMP(emm_buf,emm_length);
#endif
	MEMCPY(emm_buffer, emm_buf, emm_length);
	//MEMCPY(emm_buffer, temp_emm, 0x117);
	api_cas_send_msg(CAS_MSG_EMM, (UINT32)emm_buffer);
}


static void write_cw(struct dmx_device *dmx_dev, UINT8 *dcw, UINT8 resend)
{
#ifdef _Patch
	UINT8 i;
	static UINT8 last_even_cw[8], last_odd_cw[8];
	
	for(i=0; i<16; i+=4) dcw[i+3] = dcw[i] + dcw[i+1] + dcw[i+2];

	if(resend || MEMCMP(&dcw[0], last_even_cw, 8))
	{
		MEMCPY(last_even_cw, &dcw[0], 8);
		dmx_cfg_cw(dmx_dev, DES_VIDEO, 2, (UINT32 *)last_even_cw);
		dmx_cfg_cw(dmx_dev, DES_AUDIO, 2, (UINT32 *)last_even_cw);
	}

	if(resend || MEMCMP(&dcw[8], last_odd_cw, 8))
	{
		MEMCPY(last_odd_cw, &dcw[8], 8);
		dmx_cfg_cw(dmx_dev, DES_VIDEO, 3, (UINT32 *)last_odd_cw);
		dmx_cfg_cw(dmx_dev, DES_AUDIO, 3, (UINT32 *)last_odd_cw);

	}
#endif
}


void cas_set_dcw(unsigned char *dcw)
{
	/* fix me */
	/*set_descrambler_key(dcw);*/

	if (cas_get_debug_level() >= 1)
	{
		cas_print("dcw : ");
		cas_print_buf(dcw, 16);
	}
}

unsigned char *cas_get_tps_key_address(void)
{
	return tpsbin;
}


int do_ecm_2(UINT8 *ecm, UINT8 *cw,UINT16 ca_system_id)
{

	int result=0;
	unsigned char dcw[16];
	
	 
	 char	buffer[100];
	
	int		buffer_size,section_length,version_number;
	

	section_length = ((ecm[1] & 0x3)<<8) + ecm[2];	
	cur_provide_id=0;
#if 0
	CAS_ERROR_PRINTF("do_ecm_2<<<<<<<<<<>>>>>>:\n");	
	CAS_DUMP(ecm,section_length);
#endif
////////////////////////////////////////////////// hk_patch	
	//PATCH_PRINTF("@@@@@@@@@@do_ecm_2     ca_system_id=%x \n",ca_system_id);	
	if(ca_system_id==CA_SYSTEM_BISS)
	{
		PATCH_PRINTF("current CA system:CA_SYSTEM_BISS\n");
		result = cas_handle_biss(4, dcw);
		if (result)
		{
			/* dcw : 18 AA 00 C2 C2 D3 28 BD 18 AA 00 C2 C2 D3 28 BD */
			/* set dcw */
			PATCH_PRINTF("Happy!!!CA system open success,ca_system_id=0x%x\n",ca_system_id);
			cas_set_dcw(dcw);
			memcpy(cw, dcw, 16);	
		}	
		else
			PATCH_PRINTF("Sorry!!!Cannot open current CA system,ca_system_id=0x%x\n",ca_system_id);
		
	}
	else
	{
	//to print current is which system,no use
		switch(ca_system_id&0xFF00)
			{
			PATCH_PRINTF("ca_system_id&&0xFF00=0x%x\n",ca_system_id&0xFF00);
			case CA_SYSTEM_NAGRA:
				cur_provide_id=ecm[5]<<8|ecm[6];				
				PATCH_PRINTF("current CA system:CA_SYSTEM_NAGRA\n");
				//CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			case CA_SYSTEM_VIACCESS:
				cur_provide_id=ecm[9]<<16|ecm[10]<<8|ecm[11];	
				PATCH_PRINTF("current CA system:CA_SYSTEM_VIACCESS\n");
				//CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			case CA_SYSTEM_SECA:
				
				PATCH_PRINTF("current CA system:CA_SYSTEM_SECA\n");
				CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			case CA_SYSTEM_IRDETO:
				PATCH_PRINTF("current CA system:CA_SYSTEM_IRDETO\n");
				CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			case CA_SYSTEM_BETA:
				PATCH_PRINTF("current CA system:CA_SYSTEM_BETA\n");
				CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			case CA_SYSTEM_BISS:
				PATCH_PRINTF("current CA system:CA_SYSTEM_BISS\n");
				CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;				
			case CA_SYSTEM_CONAX:
				PATCH_PRINTF("current CA system:CA_SYSTEM_CONAX\n");
				CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			case CA_SYSTEM_CRYPTOWORKS:
				PATCH_PRINTF("current CA system:CA_SYSTEM_CRYPTOWORKS\n");
				CAS_ERROR_PRINTF("cur_provide_id=0x%x\n",cur_provide_id);
				break;
			default:
				if((ca_system_id&0xff01)==CA_SYSTEM_NAGRA2)
					PATCH_PRINTF("current CA system:CA_SYSTEM_NAGRA2\n");
				else
					PATCH_PRINTF("current CA system:Unknow CA system!!!!!!!!!!\n");
			break;
			}
		result = cas_handle_ecm(0,ecm, 0x100, ca_system_id, dcw);
		if(result)
			{
			PATCH_PRINTF("Happy!!!CA system open success,ca_system_id=0x%x\n",ca_system_id);
			cas_set_dcw(dcw);
			memcpy(cw, dcw, 16);	
			}
		else
			{
			PATCH_PRINTF("Sorry!!!CA system open failed,ca_system_id=0x%x\n",ca_system_id);
			}
		
	}		
	return result;
}

int do_emm_2(UINT8 *emm, UINT8 id,UINT16 ca_system_id)
{
	
	 int		section_length;
	section_length = ((emm[1] & 0x3)<<8) + emm[2];

	cas_handle_emm(emm, emm_caid);

	return 1;
}



// 00:  D3 38 7C B7 B2 FC BD 28
void decrypt_ecm(struct dmx_device *dmx_dev, UINT8 *buffer, UINT16 ca_system_id, UINT32 provide_id)
{

	static   	UINT8 data1=0;	
	static UINT8 	dcw[16];
	int result;
	if(data1>4)
		return;
	if(ecm_tab_id != buffer[0])
	{
		result=do_ecm_2(buffer,dcw,ca_system_id);
		if(result == 1)
		{
			ecm_tab_id = buffer[0];
			write_cw(dmx_dev, dcw, 1);
		}
		else /*error sk*/
		{
			ecm_tab_id = 0xFF;
		}
	}	
}



void decrypt_emm(cas_filter_id  filter_id, UINT8 *buffer, UINT16 ca_system_id, UINT32 provide_id)
{

	UINT8 ca_sys = 0;
    	do_emm_2(buffer, ca_sys,ca_system_id);

}




/******************************************************************************/
static void cas_main_thread(UINT32 param1, UINT32 param2)
{
	struct dmx_device *dmx_dev;
	cas_msg_t cas_msg;
	UINT32 msg_len;
	ecm_info_t *current_cas_info = NULL;
	UINT16 emm_pid;

	struct restrict filter_restrict;
	cas_filter_id cat_filter_id = ERROR_FILTER_ID;
	cas_filter_id ecm_filter_id = ERROR_FILTER_ID;
	cas_filter_id emm_filter_id = ERROR_FILTER_ID;	
	
	dmx_dev = (struct dmx_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_DMX);
	if(dmx_dev == NULL)
	{
		CAS_ERROR_PRINTF("Dev_get_by_type error!\n");
		ASSERT(0);
	}

	cas_ecm_info_init();
	cas_filter_init();

	dmx_io_control(dmx_dev, DMX_BYPASS_CSA, 0);
	
	while (1)
	{
		cas_msg.type = CAS_MSG_NULL;
		if (osal_msgqueue_receive(&cas_msg, &msg_len, cas.msgque_id, 100) != RET_SUCCESS)
		{
#ifndef USE_SIAE
			cas_filter_poll(dmx_dev);
#endif
			continue;
		}
		switch (cas_msg.type)
		{
			case CAS_MSG_START:
				PATCH_PRINTF("Got message CAS_MSG_START\n");
				
				current_cas_info = cas_ecm_info_get_active();
				if(current_cas_info == NULL)	//maybe unknow ca_system
				{
					break;
				}
				ecm_tab_id = 0xFF;
				CAS_DEBUG_PRINTF("\n set current_cas_info->ecm_pid==%04x\n",current_cas_info->ecm_pid);
				ecm_filter_id = cas_filter_create(current_cas_info->ecm_pid, ecm_processor);
				if(ecm_filter_id == ERROR_FILTER_ID)
					CAS_ERROR_PRINTF("Can not get ecm_filter\n");
				cas_filter_setfilterparams(ecm_filter_id, FILTER_MASK_ECM, FILTER_VALUE_ECM);
				cas_filter_start(dmx_dev, ecm_filter_id);

				cat_filter_id = cas_filter_create(0x01, cat_processor);
				if(cat_filter_id == ERROR_FILTER_ID)
					CAS_ERROR_PRINTF("Can not get cat_filter\n");
				cas_filter_setfilterparams(cat_filter_id, FILTER_MASK_CAT, FILTER_VALUE_CAT);
				cas_filter_start(dmx_dev, cat_filter_id);

				cas.state = CAS_STATE_RUN;
				break;
			case CAS_MSG_STOP:
				PATCH_PRINTF("Got message CASE_MSG_STOP\n");
				cas_ecm_info_delete_all();
				if(ecm_filter_id != ERROR_FILTER_ID)
				{
					cas_filter_stop(dmx_dev, ecm_filter_id);
					cas_filter_close(ecm_filter_id);
					ecm_filter_id = ERROR_FILTER_ID;
				}
				if(emm_filter_id != ERROR_FILTER_ID)
				{
					cas_filter_stop(dmx_dev, emm_filter_id);
					cas_filter_close(emm_filter_id);
					emm_filter_id = ERROR_FILTER_ID;
				}
				if(cat_filter_id != ERROR_FILTER_ID)
				{
					cas_filter_stop(dmx_dev, cat_filter_id);
					cas_filter_close(cat_filter_id);
					cat_filter_id = ERROR_FILTER_ID;
				}
				cas.state = CAS_STATE_IDLE;
				break;
			case CAS_MSG_CAT:
				PATCH_PRINTF("Got message CAS_MSG_CAT\n");
				CAS_DEBUG_PRINTF(">>>>>>>current_cas_info->provide_id=0x%x\n",current_cas_info->provide_id);

				{

					{
						emm_pid = parse_cat((UINT8 *) cas_msg.param, current_cas_info->ca_system_id, current_cas_info->provide_id);
					}	
				}
				if(emm_pid == 0)
				{
					CAS_ERROR_PRINTF("Can not get %4x emm_pid\n", current_cas_info->ca_system_id);
					break;
				}
				cas_filter_stop(dmx_dev, cat_filter_id);
				cas_filter_close(cat_filter_id);
				cat_filter_id = ERROR_FILTER_ID;

				emm_filter_id = cas_filter_create(emm_pid, emm_processor);
				if(emm_filter_id == ERROR_FILTER_ID)
					CAS_ERROR_PRINTF("Can not get emm_filter\n");
				cas_set_emm_mask_value(emm_filter_id, current_cas_info->ca_system_id, current_cas_info->provide_id);
				//cas_filter_setfilterparams(emm_filter_id, FILTER_MASK_EMM_8ALL, FILTER_VALUE_EMM_8ALL);
				cas_filter_start(dmx_dev, emm_filter_id);
				break;
			case CAS_MSG_ECM:
				PATCH_PRINTF("cas_main_thread  ECM: %2x \n", *((UINT8 *)cas_msg.param));
				decrypt_ecm(dmx_dev,(UINT8 *)cas_msg.param, current_cas_info->ca_system_id, current_cas_info->provide_id);
				break;
			case CAS_MSG_EMM:
//				PATCH_PRINTF("EMM: %2x \n", *((UINT8 *)cas_msg.param));		
				//CAS_DEBUG_PRINTF("cas_handlw_emm start running!\n");
				cas_handle_emm((UINT8 *)cas_msg.param, emm_caid);
				//CAS_DEBUG_PRINTF("cas_handlw_emm end!!!!\n");
#if 0
				if(current_cas_info->ca_system_id != CA_SYSTEM_VIACCESS)
				{
					decrypt_emm(emm_filter_id, (UINT8 *)cas_msg.param, current_cas_info->ca_system_id, current_cas_info->provide_id);
				}
				else
				{
					cas_filter_stop(dmx_dev, emm_filter_id);
//					decrypt_emm(emm_filter_id, (UINT8 *)cas_msg.param, current_cas_info->ca_system_id, current_cas_info->provide_id);
					if(*((UINT8 *)cas_msg.param)  == 0x8C)
					{
//						decrypt viac 0x8C table
//						set mask value for 0x8D table
						cas_filter_setfilterparams(emm_filter_id, FILTER_VALUE_EMM_V8D, FILTER_MASK_EMM_V8D);
					}
					else if(*((UINT8 *)cas_msg.param)  == 0x8D)
					{
//						decrypt viac 0x8D table
//						set mask value for 0x8E table
						cas_filter_setfilterparams(emm_filter_id, FILTER_VALUE_EMM_V8E, FILTER_MASK_EMM_V8E);
					}
					else if(*((UINT8 *)cas_msg.param)  == 0x8E)
					{
//						decrypt viac 0x8E table
//						set mask value for 0x8C table
						cas_filter_setfilterparams(emm_filter_id, FILTER_VALUE_EMM_V8C, FILTER_MASK_EMM_V8C);
					}
					cas_filter_start(dmx_dev, emm_filter_id);
				}
#endif
				break;
			case CAS_MSG_TIMEOUT:
				
				break;
			case CAS_MSG_UPKEY:
				//api_cas_mem_write(cas_buff, 0x1000);
				break;
			default:
				CAS_ERROR_PRINTF("Got unknow type message\n");
				break;
		}
	}
}