cas.c

EMU_FTAbox_ref441328_code_source ali m3327

		unsigned short caid;
		unsigned short ecm_pid;
		//unsigned short emm_pid;

	//PATCH_PRINTF("2......section...  %x  %x  %x  %x   %02x  \n",section[12],section[13],section[14],section[15]);

		
//   18 00 E5 DD 02 E0 A1 F0 03 52 01 01 04 E0 54 F0 03 52 01 02 96 34 77 88 FF FF FF		

	if(need_pmt == 0)		return;


///////////////////////////////////////////////////////////////////////
// below for PMT table
		/* If you want to check valid ecm pid, */
		/* You can call this funtion every pmt descriptor */

/*follow is  in CAS_DEMO.C
		//unsigned char pmt_ca_desc_data[] = {0x09,0x0f,0x05,0x00,0x03,0x03,0x10,0x01,0x00,0x13,0x01,0x20,0x14,0x03,0x02,0x12,0x00};
		//unsigned char cat_ca_desc_data[] = {0x09,0x0c,0x05,0x00,0xe3,0xe8,0x13,0x01,0x20,0x14,0x03,0x02,0x00,0x00};
		caid = ((unsigned short)pmt_ca_desc_data[2]<<8) | pmt_ca_desc_data[3];
		ecm_pid = ((unsigned short)pmt_ca_desc_data[4]<<8) | pmt_ca_desc_data[5];
		result = cas_handle_pmt_ca_desc(caid, ecm_pid, pmt_ca_desc_data+6, pmt_ca_desc_data[1]-4);
*/


		caid = ((unsigned short)section[12+2]<<8) | section[12+3];
		ecm_pid = ((unsigned short)section[12+4]<<8) | section[12+5];

		PATCH_PRINTF("caid= %x   ecm_pid=%x\n",caid,ecm_pid);
		result = cas_handle_pmt_ca_desc(caid, ecm_pid, section+6+8, section[1+8]-4);
		if (result)
		{
			CAS_DEBUG_PRINTF("valid ecm pid  ... so start ..  \n");
			/* start ecm */
		}
		else
		{
			CAS_ERROR_PRINTF("invalid ecm pid... so return .44 ..\n");
			// return;
		}
///////////////////////////////////////////////////////////////////////
	

	// PATCH_PRINTF("2......section...  %x  %x  %x  %x   %02x  \n",section[0],section[1],section[2],section[5]);
	
	ca_discriptor_num = 0;
	cas_ecm_info_delete_all();
	
	section_len = ((section[1] & 0x03) << 8)|section[2];
	prog_info_len = ((section[10] & 0x03) << 8)|section[11];
	left_len = section_len -9 -prog_info_len -4;
	
	discriptor_pointer = &section[12];
	discriptor_pointer2 = discriptor_pointer + prog_info_len;

	prg_number = (section[3]<<8) | section[4];

	//first loop, prog_info_length
	PATCH_PRINTF("prog_info_len = %d\n", prog_info_len);
	//setmifilter(section);

	while (prog_info_len > 0)
		
	{
		/*the CA descriptor tag*/
		if (*discriptor_pointer == 0x09)
		{
			ca_discriptor_num++;
			parse_ca_descriptor(&discriptor_pointer[2], discriptor_pointer[1], prg_number);
		}
		prog_info_len -= 2+discriptor_pointer[1];
		discriptor_pointer += 2+discriptor_pointer[1];
	}
	discriptor_pointer = discriptor_pointer2;

	//second loop, N1, es_info_length
	PATCH_PRINTF("left_len = %d\n", left_len);
	while(left_len > 0)
	{
		es_info_len = ((discriptor_pointer[3]&0x03)<<8)  | discriptor_pointer[4];
		loop_length = es_info_len;
		discriptor_pointer += 5;
		
		while(loop_length > 0)
		{
			/*the CA descriptor tag*/
			if (*discriptor_pointer == 0x09)
			{
				ca_discriptor_num++;
				parse_ca_descriptor(&discriptor_pointer[2], discriptor_pointer[1], prg_number);
			}
			loop_length -= 2+discriptor_pointer[1];
			discriptor_pointer += 2+discriptor_pointer[1];
			
		}

		left_len -= 5+es_info_len;

	}

	if(ca_discriptor_num > 0)
	{
		api_cas_send_msg(CAS_MSG_START, 0);
	}
	need_pmt = 0;
	return;
}


INT32 parse_cat_all(UINT8 *buffer)
{
	UINT16 index;
	UINT16 cat_length;
	UINT16 ca_system_id = 0;
	UINT16 provide_id = 0;
	UINT16 emm_pid = 0;

//////////////////////////////////////////   hk_patch

	index = 8;
	ca_system_id = (buffer[index+2] << 8) | buffer[index+3];
	emm_pid = ((buffer[index+4]&0x1F)<<8) | buffer[index+5];			

	PATCH_PRINTF("parse_cat_all = .....emm_pid= %x  ca_system_id= %x \n",emm_pid,ca_system_id&0xFF00);		
	cat_length = (buffer[1]&0x0F) <<8| buffer[2];

	index = 8;
	cat_length -= 9;	/*only length of ca_discriptor*/
	while(cat_length > 0)
	{
		if (buffer[index] == 0x09)
		{
			ca_system_id = (buffer[index+2] << 8) | buffer[index+3];
			emm_pid = ((buffer[index+4]&0x1F)<<8) | buffer[index+5];
			switch(ca_system_id&0xFF00) 
			{		
				case CA_SYSTEM_SECA:
					PATCH_PRINTF("SECA: %04x ", ca_system_id);
					if(buffer[index+1]>4)
					{
						UINT8 i, nn;
						PATCH_PRINTF("Unique emm_pid: %04x ", emm_pid);
						i=index+7;
						for(nn=buffer[index+6]; nn; nn--)
						{
							provide_id = (buffer[i+2] << 8)|buffer[i+3];
							{
								emm_pid = ((buffer[i]&0x1F)<<8)|buffer[i+1];
								PATCH_PRINTF("Provide_id: %06x, Share emm_pid:%04x ", provide_id, emm_pid);
							}
							i+=4;
						}
					}
					PATCH_PRINTF("\n");
					break;
				case CA_SYSTEM_VIACCESS:
					{
						UINT8 i, length;
						PATCH_PRINTF("VIAC: %04x ", ca_system_id);
						if(emm_pid >= 0xAA && emm_pid <= 0xCF) 
						{
							PATCH_PRINTF("dropped \"fake\" ecm pid 0x%04x\n", emm_pid);
							break;
						}
						i = 6;
						length = buffer[index+1];
						while (i < length)
						{
							if (buffer[index+i] == 0x14)
							{
								provide_id = (buffer[index+i+2]<<16)|(buffer[index+i+3]<<8)|(buffer[index+i+4]&0xF0);
								PATCH_PRINTF("provide_id=%06x, ecm_pid=%04x", provide_id, emm_pid);
							}
							i += 2 + buffer[index+i+1];
						}
						PATCH_PRINTF("\n");
						break;
					}
				case CA_SYSTEM_NAGRA:
				case CA_SYSTEM_IRDETO:
				case CA_SYSTEM_BETA:
				case CA_SYSTEM_CONAX:
				case CA_SYSTEM_CRYPTOWORKS:
					PATCH_PRINTF("Ca_system: %04x, prov: %06x, emm_pid: %04x\n", ca_system_id, provide_id, emm_pid);
					break;
				default:
					PATCH_PRINTF("Unknow ca system: %04x, prov: %06x, emm_pid: %04x\n", ca_system_id, provide_id, emm_pid);
					break;
			}
		}
		cat_length -= 2 + buffer[index+1];
		index += 2 + buffer[index+1];
	}
	return RET_SUCCESS;
}



UINT16 parse_cat(UINT8 *buffer, UINT16 ca_system_id, UINT32 provider_id)
{
	UINT16 index;
	UINT16 cat_length;
	UINT16 tmp_pid = 0;
	UINT16 emm_pid = 0;
	UINT16 caid=0;
	int result;
	
	cat_length = (buffer[1]&0x0F)<<8 | buffer[2];				
	cas_handle_cat(buffer, cat_length);



///////////////////////////////////////////////////////////////////////
// below for CAT Table

	/* If you want to check valid emm pid, */
	/* You can call this funtion every cat descriptor */
	caid = ((unsigned short)buffer[2+8]<<8) | buffer[3+8];
	if(caid!=0)
		emm_caid=caid;
		
	//emm_pid = ((unsigned short)buffer[4+8]&0x1F<<8) | buffer[5+8];
	emm_pid = ((buffer[4+8]&0x1F)<<8) | buffer[5+8];
	PATCH_PRINTF("parse_cat    caid=%x  ;      emm_pid=%x\n",caid,emm_pid);
	CAS_DEBUG_PRINTF("Cat buffer:>>>\n");
	CAS_DUMP(buffer,cat_length);
	
	result = cas_handle_cat_ca_desc(caid, emm_pid, buffer+6+8, buffer[1+8]-4);
	if (result)
	{
		CAS_DEBUG_PRINTF("valid emm pid ,So It will start the emm \n");
		/* start emm */
	}
	else
	{
		CAS_DEBUG_PRINTF("invalid emm pid  ,so not need the EMM  \n");
		
	}
///////////////////////////////////////////////////////////////////////



	//parse_cat_all(buffer);	
#if 0
	index = 8;
	cat_length -= 9;	/*only length of ca_discriptor*/
	while(cat_length > 0)
	{
		if (buffer[index] == 0x09)
		{
			if((buffer[index+2] << 8) | buffer[index+3] == ca_system_id)
			{
				if(emm_pid == 0)//modify by zkc
					CAS_ERROR_PRINTF("Error: multi emm pid for one ca system\n");
				tmp_pid = ((buffer[index+4]&0x1F)<<8) | buffer[index+5];
				switch(ca_system_id&0xFF00) 
				{					
					case CA_SYSTEM_SECA:
						if(buffer[index+1]>4)
						{
							UINT8 i, nn;
							tmp_pid = 0;		// can not support Unique emm_pid
							i=index+7;
							for(nn=buffer[index+6]; nn; nn--)
							{
								if((buffer[i+2] << 8)|buffer[i+3] == provider_id)
								{
									if(emm_pid != 0)
										CAS_ERROR_PRINTF("Error: seca: multi emm pid for one provider\n");
									emm_pid = ((buffer[i]&0x1F)<<8)|buffer[i+1];
								}
								i+=4;
							}
						}
						break;
					case CA_SYSTEM_VIACCESS:
						{
							UINT8 i, length;
							if(tmp_pid >= 0xAA && tmp_pid <= 0xCF) 
							{
								PATCH_PRINTF("dropped \"fake\" ecm pid 0x%04x\n", emm_pid);
								break;
							}
							i = 6;
							length = buffer[index+1];
							while (i < length)
							{
								if (buffer[index+i] == 0x14)
								{
									if(provider_id == (UINT32) (buffer[index+i+2]<<16)|(buffer[index+i+3]<<8)|(buffer[index+i+4]&0xF0))
									{
										if(emm_pid != 0)
											CAS_ERROR_PRINTF("Error: via: multi emm pid for one provider\n");
										else
										{
											emm_pid = tmp_pid;
											PATCH_PRINTF("provide_id=%06x, emm_pid=%04x", provider_id, emm_pid);
										}
									}
								}
								i += 2 + buffer[index+i+1];
							}
							PATCH_PRINTF("\n");
							break;
						}
					default:
						emm_pid = tmp_pid;
						PATCH_PRINTF("ca_system: %04x, provide: %06x, emm_pid: %04x\n", ca_system_id, provider_id, emm_pid);	
						break;
				}
			}
		}
		cat_length -= 2 + buffer[index+1];
		index += 2 + buffer[index+1];
	}

#endif
	return emm_pid;
}

static void cat_processor(UINT8 *cat_buff, UINT16 length)
{
	UINT16 cat_length;
	cat_length=(cat_buff[1]&0x0F)<<8|cat_buff[2]+3;
	
	CAS_DEBUG_PRINTF("cat_processor  Cat buffer:>>>>>>>>>>>>>>>>>>>>>>\n");
	CAS_DUMP(cat_buff,cat_length);
	
	if(cat_buff == NULL)
	{
		CAS_ERROR_PRINTF("Get cat timeout\n" );
		api_cas_send_msg(CAS_MSG_TIMEOUT, 0);
		return;
	}
	MEMCPY(cat_buffer, cat_buff, cat_length);
	api_cas_send_msg(CAS_MSG_CAT, (UINT32)cat_buffer);
	return;
}

INT32 cas_set_emm_mask_value(cas_filter_id filter_id, UINT16 ca_system_id, UINT32 provide_id)
{
	switch(ca_system_id&CA_SYSTEM_MASK)
	{
		case CA_SYSTEM_NAGRA:		/*emm_table_id = 0x82*/
			cas_filter_setfilterparams(filter_id, FILTER_MASK_EMM_N, FILTER_VALUE_EMM_N);
			break;
		case CA_SYSTEM_VIACCESS:	/*emm_table_id = 0x8C, 0x8D, 0x8E*/
			//cas_filter_setfilterparams(filter_id, FILTER_MASK_EMM_V8C, FILTER_VALUE_EMM_V8C);
			cas_filter_setfilterparams(filter_id, FILTER_MASK_EMM_V87, FILTER_VALUE_EMM_V87);//only get EMM 0x87
			//cas_filter_setfilterparams(filter_id, FILTER_MASK_EMM_V8ALL, FILTER_VALUE_EMM_V8ALL);//get emm 0x80~0x8F
			break;
		case CA_SYSTEM_SECA:		/*emm_table_id = 0x84*/
			cas_filter_setfilterparams(filter_id, FILTER_MASK_EMM_S, FILTER_VALUE_EMM_S);
			break;
		case CA_SYSTEM_IRDETO:		/*emm_table_id = 0x82*/
		case CA_SYSTEM_BETA:
		case CA_SYSTEM_CRYPTOWORKS://add by zkc
			cas_filter_setfilterparams(filter_id, FILTER_MASK_EMM_I, FILTER_VALUE_EMM_I);			
			break;
		default:
			CAS_ERROR_PRINTF("Not support ca system\n");
			break;
	}	
}

static void ecm_processor(UINT8 *ecm_buf, UINT16 length)
{
	UINT16 ecm_length;
#if 0
	UINT8 temp_ecm[]=
		{
		0x81,0x31,0x07,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15,0x37,0x36,0xfc,0xf9,0x99,0x3e,
		0xee,0x30,0x37,0x03,0x35,0x4f,0x01,0x10,0x31,0x15
		};
#endif
	ecm_length=(ecm_buf[1]&0x0F)<<8|ecm_buf[2]+3;
	if(ecm_buf == NULL)
	{
		api_cas_send_msg(CAS_MSG_TIMEOUT, 0);
		CAS_ERROR_PRINTF("Get ecm time out\n");
		return;
	}

//#ifdef CAS_DEBUG
#if 0
	CAS_DEBUG_PRINTF("Ecm info>>>>>>:ecm_length=0x%x+3\n",ecm_length-3);
	if(ecm_length>=300)
		{
		CAS_DEBUG_PRINTF("ECM  info is too long,only print 300\n");
		CAS_DUMP(ecm_buf,300);
		}
	else
		CAS_DUMP(ecm_buf,ecm_length);
#endif
	MEMCPY(ecm_buffer, ecm_buf, ecm_length);
	//MEMCPY(ecm_buffer, temp_ecm, 0x107);