INT CL_ThreadUnix::GetPriorityExt()
{
int Priority = 0;
#if defined(_FOR_ANDROID_) || defined (_LINUX)
Priority = getpriority(PRIO_PROCESS, m_dwThreadID);
#elif defined(_FOR_APPLE_)
if (m_dwThreadID != (DWORD)gettid()) return -1;
double macproi = getCurrentThreadPriority();
Priority = 255 - macproi * (255 - 249);
#endif
return Priority;
}
/**
* low level API to decrypt Ekpubrx(Km)
*/
static H2status decryptEKpubKm(unsigned char *message)
{
H2status stat = H2_OK;
static H2_AKENoStoredEkmPayLoad no_stored_km_payload;
memset(&no_stored_km_payload,0x00,sizeof(H2_AKENoStoredEkmPayLoad));
ALOGI("hdcp decryptEKpubKm start\n");
#ifdef DECRYPT_NO_INTERRUPT
int orgThreadPriority=0;
int orgThreadPolicy=0;
// - adjust thread policy and priority
getCurrentThreadPriority(&orgThreadPolicy,&orgThreadPriority);
changeSelfThreadParam(SCHED_FIFO,16);
#endif
memcpy( no_stored_km_payload.EKpub_Km, message, EKPUBKM_SIZE );
stat = hdcp2_SetEKpubKm( no_stored_km_payload.EKpub_Km );
#ifdef DECRYPT_NO_INTERRUPT
// - restore thread policy and priority
changeSelfThreadParam(orgThreadPolicy,orgThreadPriority);
#endif
if ( stat != H2_OK )
{
ALOGI("hdcp decryptEKpubKm 1mDecryption of EKpubKm failed!\n");
}
// km is existence
gKmExistence=1;
ALOGI("hdcp decryptEKpubKm 1mDecryption of EKpubKm success!\n");
return stat;
}
int h2MessageParse( unsigned char *message, unsigned int length )
{
int rc = 0;
do
{
if ( NULL == message )
{
break;
}
unsigned char msgId = *message;
switch( msgId )
{
/**
* TX -> RX messages
*/
case AKE_INIT:
rc = processAkeInit( message, length );
break;
case AKE_NO_STORED_EKM:
{
#ifdef DECRYPT_NO_INTERRUPT
int orgThreadPriority=0;
int orgThreadPolicy=0;
// - adjust thread policy and priority
getCurrentThreadPriority(&orgThreadPolicy,&orgThreadPriority);
changeSelfThreadParam(SCHED_FIFO,16);
#endif
rc = processAkeNoStoredEkm( message, length );
/** Start pairing process */
gPairingState = PAIRING_SEND_HPRIME;
#ifdef DECRYPT_NO_INTERRUPT
// - restore thread policy and priority
changeSelfThreadParam(orgThreadPolicy,orgThreadPriority);
#endif
}
break;
case AKE_STORED_EKM:
rc = processAkeStoredEkm( message, length );
gPairingState = PAIRING_SEND_HPRIME;
break;
case LC_INIT:
{
// 1. Transmitter supports pre-computation && is HDCP 2.1 or HDCP 2.2
// 2. Receiver supports pre-computation && is HDCP 2.1 or HDCP 2.2
if (((getPreComputation()&0x01) == H2_LC_INIT_PRECOMPUTATION) && ((getSelfPreComputation()&0x01) == H2_LC_INIT_PRECOMPUTATION) && IsCapHDCP2Plus())
{
DPRINT(("\033[0;31;31m[DHDCP] process LC_Init, PreCompute mode [%s %d]\033[m\n",
__FILE__,
__LINE__ ));
rc = processLcInitWithPreComputation( message, length );
}
else
{
DPRINT(("\033[0;31;31m[DHDCP] process LC_Init, None-preCompute mode [%s %d]\033[m\n",
__FILE__,
__LINE__ ));
rc = processLcInitWithoutPreComputation( message, length );
}
}
break;
case RTT_CHALLENGE:
rc = processRTTChallenge( message, length );
break;
case AKE_TRANSMITTER_INFO: //for hdcp2.1
rc = processAkeTransmitterInfo( message, length );
break;
case SKE_SEND_EKS:
rc = processSkeSendEks( message, length );
break;
case REP_AUTH_SEND_ACK:
rc = processRepAuthSendAck(message, length);
break;
case REP_AUTH_STREAM_MANAGE:
rc = processRepAuthStreamManage(message, length);
break;
/**
* RX -> TX messages. We should not receive these!
*/
case AKE_SEND_CERT:
case AKE_SEND_RRX:
case AKE_SEND_H_PRIME:
case AKE_SEND_PAIRING_INFO:
case LC_SEND_L_PRIME:
case REP_AUTH_SEND_RXID_LIST:
ALOGI("TX received on RX!\n");
/* TODO: Error handling? */
rc = -1;
break;
default:
ALOGI("HDCP received unknown message\n");
rc = -2;
break;
}
} while( 0 );
return rc;
}
int h2MessagePoll( unsigned char *message, unsigned int length )
{
int rc = 0;
switch ( gPairingState )
{
case PAIRING_INIT:
break;
case PAIRING_SEND_HPRIME:
{
DPRINT(("\033[0;31;31m[DHDCP] PAIRING_SEND_HPRIME start\033[m\n"));
#ifdef SPEED_UP_NO_STORED_KM
if(gKmExistence==0)
{
DPRINT(("\033[0;31;31m[DHDCP] decrypt Ekpubrx(km) before AKE_Send_H_prime\033[m\n"));
H2status stat = decryptEKpubKm(tmpKpubkmBuf);
if ( stat != H2_OK )
{
printf("Decryption of EKpubKm failed!\r\n");
return STATUS_ERROR_DECRYPTION_FAILED; /** No pending message. Timeout will notify TX of an error */
}
}
#endif
H2uint8 Kd_tmp[KD_SIZE]={0};
static H2_AKESendHprimePayLoad sendPayload;
memset(&sendPayload,0x00,sizeof(sendPayload));
/** Make sure there's room for the outgoing message */
if ( length < AKE_MSG_SEND_HPRIME_SIZE )
{
ALOGI("buffer too small for AKE Send Hprime message!\r\n");
rc = STATUS_ERROR_OUTGOING_MSG_TOO_LARGE;
DPRINT(("\033[0;31;31m[DHDCP] PAIRING_SEND_HPRIME end STATUS_ERROR_OUTGOING_MSG_TOO_LARGE\033[m\n"));
break;
}
int modeHDCP22=0;
#ifdef DECRYPT_NO_INTERRUPT
int orgThreadPriority=0;
int orgThreadPolicy=0;
// - adjust thread policy and priority
getCurrentThreadPriority(&orgThreadPolicy,&orgThreadPriority);
changeSelfThreadParam(SCHED_FIFO,16);
#endif
if(getHDCPCAP()==CAP_HDCP2_2 && getRTKHDCPSTR()->transmitterVersion==0x2)
modeHDCP22=1;
// Verbose debug print during QA phase
DPRINT(("\033[0;31;31m[DHDCP] Process compute H' HDCPCap=%d TransmitterVersion=%d protocalBit=%d modeHDCP22=%d [%s %d]\033[m\n",
getHDCPCAP(),
getRTKHDCPSTR()->transmitterVersion,
hdcp22_GetProtocolDescriptorBit(),
modeHDCP22,
__FILE__,
__LINE__ ));
/* Gen Kd = dkey0 || dkey1 */
RCP_HDCP2_GenKd(SRAM_KM_ENTRY, SessionSecrets.rtx, SessionSecrets.rRx,SessionSecrets.rn, SRAM_KD_ENTRY,modeHDCP22);
spu_GetKD(Kd_tmp);
/** Compute HPrime from Kd, RTX, and Repeater */
/** Copy Hprime into the outgoing message */
if(getHDCPCAP()==CAP_HDCP2_2 && getRTKHDCPSTR()->transmitterVersion==0x2 && hdcp22_GetProtocolDescriptorBit()==0x1)
{
ALOGI( "h2MessagePoll[%d] 2.2 case!\r\n",__LINE__);
DPRINT(("\033[0;31;31m[DHDCP] do Compute_Hprime_22\033[m\n"));
Compute_Hprime_22(Kd_tmp,SessionSecrets.rtx,HDCP_REPEATER,
getRTKHDCPSTR()->receiverVersion,getRTKHDCPSTR()->receiverCapMask,
getRTKHDCPSTR()->transmitterVersion,getRTKHDCPSTR()->transmitterCapMask,
SessionSecrets.hPrime);
}
else
{
ALOGI( "h2MessagePoll[%d] 2.0 2.1 case!\r\n",__LINE__);
DPRINT(("\033[0;31;31m[DHDCP] do Compute_Hprime\033[m\n"));
Compute_Hprime(Kd_tmp, SessionSecrets.rtx, HDCP_REPEATER, SessionSecrets.hPrime);
}
memset(Kd_tmp, 0x00, KD_SIZE);
#ifdef DECRYPT_NO_INTERRUPT
// - restore thread policy and priority
changeSelfThreadParam(orgThreadPolicy,orgThreadPriority);
#endif
/** Copy Hprime into the outgoing message */
hdcp2_GethPrime( sendPayload.Hprime, sizeof(sendPayload.Hprime));
/** Pack the message for transmission */
message[0] = AKE_SEND_H_PRIME;
memcpy( message+1, sendPayload.Hprime, H_SIZE );
/** Signal that a message is waiting */
rc = STATUS_OK_PENDING_MSG;
gPairingState = (gbNoStoredEkm ? PAIRING_SEND_PAIRING_INFO : PAIRING_INIT );
DPRINT(("\033[0;31;31m[DHDCP] PAIRING_SEND_HPRIME end ok\033[m\n"));
}
break;
case PAIRING_SEND_PAIRING_INFO:
{
ALOGI( " hdcp processRepAuthSendAck PAIRING_SEND_PAIRING_INFOS!\r\n" );
static H2_AKESendPairingInfoPayLoad sendPayload;
#ifdef DECRYPT_NO_INTERRUPT
int orgThreadPriority=0;
int orgThreadPolicy=0;
// - adjust thread policy and priority
getCurrentThreadPriority(&orgThreadPolicy,&orgThreadPriority);
changeSelfThreadParam(SCHED_FIFO,16);
#endif
hdcp2_GetEKhKm( sendPayload.Ekh_Km, sizeof( sendPayload.Ekh_Km ));
#ifdef DECRYPT_NO_INTERRUPT
// - restore thread policy and priority
changeSelfThreadParam(orgThreadPolicy,orgThreadPriority);
#endif
message[0] = AKE_SEND_PAIRING_INFO;
memcpy( message+1, sendPayload.Ekh_Km, EKHKM_SIZE ); /** Copy rrx */
length = EKHKM_SIZE + 1;
gPairingState = PAIRING_INIT;
rc = STATUS_OK_PENDING_MSG;
DPRINT(("\033[0;31;31m[DHDCP] PAIRING_SEND_PAIRING_INFO end ok\033[m\n"));
}
break;
default:
gPairingState = PAIRING_INIT;
break;
}
return rc;
}