/*
* Copyright (C) 2015 NXP Semiconductors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <log/log.h>
#include <Ala.h>
#include <AlaLib.h>
#include <IChannel.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
pAla_Dwnld_Context_t gpAla_Dwnld_Context=NULL;
extern INT32 gTransceiveTimeout;
#ifdef JCOP3_WR
UINT8 Cmd_Buffer[64*1024];
static INT32 cmd_count = 0;
bool islastcmdLoad;
bool SendBack_cmds = false;
UINT8 *pBuffer;
#endif
BOOLEAN mIsInit;
UINT8 Select_Rsp[1024];
UINT8 Jsbl_RefKey[256];
UINT8 Jsbl_keylen;
#if(NXP_LDR_SVC_VER_2 == TRUE)
UINT8 StoreData[22];
#else
UINT8 StoreData[34];
#endif
int Select_Rsp_Len;
#if(NXP_LDR_SVC_VER_2 == TRUE)
UINT8 lsVersionArr[2];
UINT8 tag42Arr[17];
UINT8 tag45Arr[9];
UINT8 lsExecuteResp[4];
UINT8 AID_ARRAY[22];
INT32 resp_len = 0;
FILE *fAID_MEM = NULL;
FILE *fLS_STATUS = NULL;
UINT8 lsGetStatusArr[2];
tJBL_STATUS (*ls_GetStatus_seqhandler[])(Ala_ImageInfo_t *pContext, tJBL_STATUS status, Ala_TranscieveInfo_t *pInfo)=
{
ALA_OpenChannel,
ALA_SelectAla,
ALA_getAppletLsStatus,
ALA_CloseChannel,
NULL
};
#endif
tJBL_STATUS (*Applet_load_seqhandler[])(Ala_ImageInfo_t *pContext, tJBL_STATUS status, Ala_TranscieveInfo_t *pInfo)=
{
ALA_OpenChannel,
ALA_SelectAla,
ALA_StoreData,
ALA_loadapplet,
NULL
};
tJBL_STATUS (*Jsblcer_id_seqhandler[])(Ala_ImageInfo_t *pContext, tJBL_STATUS status, Ala_TranscieveInfo_t *pInfo)=
{
ALA_OpenChannel,
ALA_SelectAla,
ALA_CloseChannel,
NULL
};
/*******************************************************************************
**
** Function: initialize
**
** Description: Initialize all member variables.
** native: Native data.
**
** Returns: True if ok.
**
*******************************************************************************/
BOOLEAN initialize (IChannel_t* channel)
{
static const char fn [] = "Ala_initialize";
ALOGD ("%s: enter", fn);
gpAla_Dwnld_Context = (pAla_Dwnld_Context_t)malloc(sizeof(Ala_Dwnld_Context_t));
if(gpAla_Dwnld_Context != NULL)
{
memset((void *)gpAla_Dwnld_Context, 0, (UINT32)sizeof(Ala_Dwnld_Context_t));
}
else
{
ALOGD("%s: Memory allocation failed", fn);
return (FALSE);
}
gpAla_Dwnld_Context->mchannel = channel;
#ifdef JCOP3_WR
cmd_count = 0;
SendBack_cmds = false;
islastcmdLoad = false;
#endif
#if(NXP_LDR_SVC_VER_2 == TRUE)
fAID_MEM = fopen(AID_MEM_PATH,"r");
if(fAID_MEM == NULL)
{
ALOGD("%s: AID data file does not exists", fn);
memcpy(&ArrayOfAIDs[2][1],&SelectAla[0],sizeof(SelectAla));
ArrayOfAIDs[2][0] = sizeof(SelectAla);
}
else
{
/*Change is required aidLen = 0x00*/
UINT8 aidLen = 0x00;
INT32 wStatus = 0;
while(!(feof(fAID_MEM)))
{
/*the length is not incremented*/
wStatus = FSCANF_BYTE(fAID_MEM,"%2x",&ArrayOfAIDs[2][aidLen++]);
if(wStatus == 0)
{
ALOGE ("%s: exit: Error during read AID data", fn);
fclose(fAID_MEM);
return FALSE;
}
}
ArrayOfAIDs[2][0] = aidLen - 1;
fclose(fAID_MEM);
}
lsExecuteResp[0] = TAG_LSES_RESP;
lsExecuteResp[1] = TAG_LSES_RSPLEN;
lsExecuteResp[2] = LS_ABORT_SW1;
lsExecuteResp[3] = LS_ABORT_SW2;
#endif
#ifdef JCOP3_WR
pBuffer = Cmd_Buffer;
#endif
mIsInit = TRUE;
ALOGD ("%s: exit", fn);
return (TRUE);
}
/*******************************************************************************
**
** Function: finalize
**
** Description: Release all resources.
**
** Returns: None
**
*******************************************************************************/
void finalize ()
{
static const char fn [] = "Ala_finalize";
ALOGD ("%s: enter", fn);
mIsInit = FALSE;
if(gpAla_Dwnld_Context != NULL)
{
gpAla_Dwnld_Context->mchannel = NULL;
free(gpAla_Dwnld_Context);
gpAla_Dwnld_Context = NULL;
}
ALOGD ("%s: exit", fn);
}
/*******************************************************************************
**
** Function: Perform_ALA
**
** Description: Performs the ALA download sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS Perform_ALA(const char *name,const char *dest, const UINT8 *pdata,
UINT16 len, UINT8 *respSW)
#else
tJBL_STATUS Perform_ALA(const char *name, const UINT8 *pdata, UINT16 len)
#endif
{
static const char fn [] = "Perform_ALA";
static const char Ala_path[] = APPLET_PATH;
tJBL_STATUS status = STATUS_FAILED;
ALOGD ("%s: enter; sha-len=%d", fn, len);
if(mIsInit == false)
{
ALOGD ("%s: ALA lib is not initialized", fn);
status = STATUS_FAILED;
}
else if((pdata == NULL) ||
(len == 0x00))
{
ALOGD ("%s: Invalid SHA-data", fn);
}
else
{
StoreData[0] = STORE_DATA_TAG;
StoreData[1] = len;
memcpy(&StoreData[2], pdata, len);
#if(NXP_LDR_SVC_VER_2 == TRUE)
status = ALA_update_seq_handler(Applet_load_seqhandler, name, dest);
if((status != STATUS_OK)&&(lsExecuteResp[2] == 0x90)&&
(lsExecuteResp[3] == 0x00))
{
lsExecuteResp[2] = LS_ABORT_SW1;
lsExecuteResp[3] = LS_ABORT_SW2;
}
memcpy(&respSW[0],&lsExecuteResp[0],4);
ALOGD ("%s: lsExecuteScript Response SW=%2x%2x",fn, lsExecuteResp[2],
lsExecuteResp[3]);
#else
status = ALA_update_seq_handler(Applet_load_seqhandler, name);
#endif
}
ALOGD("%s: exit; status=0x0%x", fn, status);
return status;
}
#if(NXP_LDR_SVC_VER_2 == FALSE)
/*******************************************************************************
**
** Function: GetJsbl_Certificate_ID
**
** Description: Performs the GetJsbl_Certificate_ID sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS GetJsbl_Certificate_Refkey(UINT8 *pKey, INT32 *pKeylen)
{
static const char fn [] = "GetJsbl_Certificate_ID";
tJBL_STATUS status = STATUS_FAILED;
ALOGD ("%s: enter", fn);
if(mIsInit == false)
{
ALOGD ("%s: ALA lib is not initialized", fn);
status = STATUS_FAILED;
}
else
{
status = JsblCerId_seq_handler(Jsblcer_id_seqhandler);
if(status == STATUS_SUCCESS)
{
if(Jsbl_keylen != 0x00)
{
*pKeylen = (INT32)Jsbl_keylen;
memcpy(pKey, Jsbl_RefKey, Jsbl_keylen);
Jsbl_keylen = 0;
}
}
}
ALOGD("%s: exit; status=0x0%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: JsblCerId_seq_handler
**
** Description: Performs get JSBL Certificate Identifier sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS JsblCerId_seq_handler(tJBL_STATUS (*seq_handler[])(Ala_ImageInfo_t* pContext, tJBL_STATUS status, Ala_TranscieveInfo_t* pInfo))
{
static const char fn[] = "JsblCerId_seq_handler";
UINT16 seq_counter = 0;
Ala_ImageInfo_t update_info = (Ala_ImageInfo_t )gpAla_Dwnld_Context->Image_info;
Ala_TranscieveInfo_t trans_info = (Ala_TranscieveInfo_t )gpAla_Dwnld_Context->Transcv_Info;
tJBL_STATUS status = STATUS_FAILED;
ALOGD("%s: enter", fn);
while((seq_handler[seq_counter]) != NULL )
{
status = STATUS_FAILED;
status = (*(seq_handler[seq_counter]))(&update_info, status, &trans_info );
if(STATUS_SUCCESS != status)
{
ALOGE("%s: exiting; status=0x0%X", fn, status);
break;
}
seq_counter++;
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
#else
/*******************************************************************************
**
** Function: GetLs_Version
**
** Description: Performs the GetLs_Version sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS GetLs_Version(UINT8 *pVersion)
{
static const char fn [] = "GetLs_Version";
tJBL_STATUS status = STATUS_FAILED;
ALOGD ("%s: enter", fn);
if(mIsInit == false)
{
ALOGD ("%s: ALA lib is not initialized", fn);
status = STATUS_FAILED;
}
else
{
status = GetVer_seq_handler(Jsblcer_id_seqhandler);
if(status == STATUS_SUCCESS)
{
pVersion[0] = 2;
pVersion[1] = 0;
memcpy(&pVersion[2], lsVersionArr, sizeof(lsVersionArr));
ALOGD("%s: GetLsVersion is =0x0%x%x", fn, lsVersionArr[0],lsVersionArr[1]);
}
}
ALOGD("%s: exit; status=0x0%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: Get_LsAppletStatus
**
** Description: Performs the Get_LsAppletStatus sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS Get_LsAppletStatus(UINT8 *pVersion)
{
static const char fn [] = "GetLs_Version";
tJBL_STATUS status = STATUS_FAILED;
ALOGD ("%s: enter", fn);
if(mIsInit == false)
{
ALOGD ("%s: ALA lib is not initialized", fn);
status = STATUS_FAILED;
}
else
{
status = GetLsStatus_seq_handler(ls_GetStatus_seqhandler);
if(status == STATUS_SUCCESS)
{
pVersion[0] = lsGetStatusArr[0];
pVersion[1] = lsGetStatusArr[1];
ALOGD("%s: GetLsAppletStatus is =0x0%x%x", fn, lsGetStatusArr[0],lsGetStatusArr[1]);
}
}
ALOGD("%s: exit; status=0x0%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: GetVer_seq_handler
**
** Description: Performs GetVer_seq_handler sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS GetVer_seq_handler(tJBL_STATUS (*seq_handler[])(Ala_ImageInfo_t*
pContext, tJBL_STATUS status, Ala_TranscieveInfo_t* pInfo))
{
static const char fn[] = "GetVer_seq_handler";
UINT16 seq_counter = 0;
Ala_ImageInfo_t update_info = (Ala_ImageInfo_t )gpAla_Dwnld_Context->Image_info;
Ala_TranscieveInfo_t trans_info = (Ala_TranscieveInfo_t )gpAla_Dwnld_Context->Transcv_Info;
tJBL_STATUS status = STATUS_FAILED;
ALOGD("%s: enter", fn);
while((seq_handler[seq_counter]) != NULL )
{
status = STATUS_FAILED;
status = (*(seq_handler[seq_counter]))(&update_info, status, &trans_info );
if(STATUS_SUCCESS != status)
{
ALOGE("%s: exiting; status=0x0%X", fn, status);
break;
}
seq_counter++;
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: GetLsStatus_seq_handler
**
** Description: Performs GetVer_seq_handler sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS GetLsStatus_seq_handler(tJBL_STATUS (*seq_handler[])(Ala_ImageInfo_t*
pContext, tJBL_STATUS status, Ala_TranscieveInfo_t* pInfo))
{
static const char fn[] = "ls_GetStatus_seqhandler";
UINT16 seq_counter = 0;
Ala_ImageInfo_t update_info = (Ala_ImageInfo_t )gpAla_Dwnld_Context->Image_info;
Ala_TranscieveInfo_t trans_info = (Ala_TranscieveInfo_t )gpAla_Dwnld_Context->Transcv_Info;
tJBL_STATUS status = STATUS_FAILED;
ALOGD("%s: enter", fn);
while((seq_handler[seq_counter]) != NULL )
{
status = STATUS_FAILED;
status = (*(seq_handler[seq_counter]))(&update_info, status, &trans_info );
if(STATUS_SUCCESS != status)
{
ALOGE("%s: exiting; status=0x0%X", fn, status);
break;
}
seq_counter++;
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
#endif
/*******************************************************************************
**
** Function: ALA_update_seq_handler
**
** Description: Performs the ALA update sequence handler sequence
**
** Returns: Success if ok.
**
*******************************************************************************/
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS ALA_update_seq_handler(tJBL_STATUS (*seq_handler[])
(Ala_ImageInfo_t* pContext, tJBL_STATUS status, Ala_TranscieveInfo_t*
pInfo), const char *name, const char *dest)
#else
tJBL_STATUS ALA_update_seq_handler(tJBL_STATUS (*seq_handler[])(Ala_ImageInfo_t* pContext, tJBL_STATUS status, Ala_TranscieveInfo_t* pInfo), const char *name)
#endif
{
static const char fn[] = "ALA_update_seq_handler";
static const char Ala_path[] = APPLET_PATH;
UINT16 seq_counter = 0;
Ala_ImageInfo_t update_info = (Ala_ImageInfo_t )gpAla_Dwnld_Context->
Image_info;
Ala_TranscieveInfo_t trans_info = (Ala_TranscieveInfo_t )gpAla_Dwnld_Context
->Transcv_Info;
tJBL_STATUS status = STATUS_FAILED;
ALOGD("%s: enter", fn);
#if(NXP_LDR_SVC_VER_2 == TRUE)
if(dest != NULL)
{
strcat(update_info.fls_RespPath, dest);
ALOGD("Loader Service response data path/destination: %s", dest);
update_info.bytes_wrote = 0xAA;
}
else
{
update_info.bytes_wrote = 0x55;
}
if((ALA_UpdateExeStatus(LS_DEFAULT_STATUS))!= TRUE)
{
return FALSE;
}
#endif
//memcpy(update_info.fls_path, (char*)Ala_path, sizeof(Ala_path));
strcat(update_info.fls_path, name);
ALOGD("Selected applet to install is: %s", update_info.fls_path);
while((seq_handler[seq_counter]) != NULL )
{
status = STATUS_FAILED;
status = (*(seq_handler[seq_counter]))(&update_info, status,
&trans_info);
if(STATUS_SUCCESS != status)
{
ALOGE("%s: exiting; status=0x0%X", fn, status);
break;
}
seq_counter++;
}
ALA_CloseChannel(&update_info, STATUS_FAILED, &trans_info);
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_OpenChannel
**
** Description: Creates the logical channel with ala
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_OpenChannel(Ala_ImageInfo_t *Os_info, tJBL_STATUS status,
Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn[] = "ALA_OpenChannel";
bool stat = false;
INT32 recvBufferActualSize = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
Os_info->channel_cnt = 0x00;
ALOGD("%s: enter", fn);
if(Os_info == NULL ||
pTranscv_Info == NULL)
{
ALOGD("%s: Invalid parameter", fn);
}
else
{
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sSendlength = (INT32)sizeof(OpenChannel);
pTranscv_Info->sRecvlength = 1024;//(INT32)sizeof(INT32);
memcpy(pTranscv_Info->sSendData, OpenChannel, pTranscv_Info->sSendlength);
ALOGD("%s: Calling Secure Element Transceive", fn);
stat = mchannel->transceive (pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if(stat != TRUE &&
(recvBufferActualSize < 0x03))
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
if(recvBufferActualSize == 0x02)
memcpy(&lsExecuteResp[2],
&pTranscv_Info->sRecvData[recvBufferActualSize-2],2);
#endif
status = STATUS_FAILED;
ALOGE("%s: SE transceive failed status = 0x%X", fn, status);
}
else if(((pTranscv_Info->sRecvData[recvBufferActualSize-2] != 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] != 0x00)))
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
memcpy(&lsExecuteResp[2],
&pTranscv_Info->sRecvData[recvBufferActualSize-2],2);
#endif
status = STATUS_FAILED;
ALOGE("%s: invalid response = 0x%X", fn, status);
}
else
{
UINT8 cnt = Os_info->channel_cnt;
Os_info->Channel_Info[cnt].channel_id = pTranscv_Info->sRecvData[recvBufferActualSize-3];
Os_info->Channel_Info[cnt].isOpend = true;
Os_info->channel_cnt++;
status = STATUS_OK;
}
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_SelectAla
**
** Description: Creates the logical channel with ala
** Channel_id will be used for any communication with Ala
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_SelectAla(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn[] = "ALA_SelectAla";
bool stat = false;
INT32 recvBufferActualSize = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
#if(NXP_LDR_SVC_VER_2 == TRUE)
UINT8 selectCnt = 3;
#endif
ALOGD("%s: enter", fn);
if(Os_info == NULL ||
pTranscv_Info == NULL)
{
ALOGD("%s: Invalid parameter", fn);
}
else
{
pTranscv_Info->sSendData[0] = Os_info->Channel_Info[0].channel_id;
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sSendlength = (INT32)sizeof(SelectAla);
pTranscv_Info->sRecvlength = 1024;//(INT32)sizeof(INT32);
#if(NXP_LDR_SVC_VER_2 == TRUE)
while((selectCnt--) > 0)
{
memcpy(&(pTranscv_Info->sSendData[1]), &ArrayOfAIDs[selectCnt][2],
((ArrayOfAIDs[selectCnt][0])-1));
pTranscv_Info->sSendlength = (INT32)ArrayOfAIDs[selectCnt][0];
/*If NFC/SPI Deinitialize requested*/
#else
memcpy(&(pTranscv_Info->sSendData[1]), &SelectAla[1], sizeof(SelectAla)-1);
#endif
ALOGD("%s: Calling Secure Element Transceive with Loader service AID", fn);
stat = mchannel->transceive (pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if(stat != TRUE &&
(recvBufferActualSize == 0x00))
{
status = STATUS_FAILED;
ALOGE("%s: SE transceive failed status = 0x%X", fn, status);
#if(NXP_LDR_SVC_VER_2 == TRUE)
break;
#endif
}
else if(((pTranscv_Info->sRecvData[recvBufferActualSize-2] == 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] == 0x00)))
{
status = Process_SelectRsp(pTranscv_Info->sRecvData, (recvBufferActualSize-2));
if(status != STATUS_OK)
{
ALOGE("%s: Select Ala Rsp doesnt have a valid key; status = 0x%X", fn, status);
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*If AID is found which is successfully selected break while loop*/
if(status == STATUS_OK)
{
UINT8 totalLen = ArrayOfAIDs[selectCnt][0];
UINT8 cnt = 0;
INT32 wStatus= 0;
status = STATUS_FAILED;
fAID_MEM = fopen(AID_MEM_PATH,"w+");
if(fAID_MEM == NULL)
{
ALOGE("Error opening AID data file for writing: %s",
strerror(errno));
return status;
}
while(cnt <= totalLen)
{
wStatus = fprintf(fAID_MEM, "%02x",
ArrayOfAIDs[selectCnt][cnt++]);
if(wStatus != 2)
{
ALOGE("%s: Error writing AID data to AID_MEM file: %s",
fn, strerror(errno));
break;
}
}
if(wStatus == 2)
status = STATUS_OK;
fclose(fAID_MEM);
break;
}
#endif
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
else if(((pTranscv_Info->sRecvData[recvBufferActualSize-2] != 0x90)))
{
/*Copy the response SW in failure case*/
memcpy(&lsExecuteResp[2], &(pTranscv_Info->
sRecvData[recvBufferActualSize-2]),2);
}
#endif
else
{
status = STATUS_FAILED;
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
}
#endif
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_StoreData
**
** Description: It is used to provide the ALA with an Unique
** Identifier of the Application that has triggered the ALA script.
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_StoreData(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn[] = "ALA_StoreData";
bool stat = false;
INT32 recvBufferActualSize = 0;
INT32 xx=0, len = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
ALOGD("%s: enter", fn);
if(Os_info == NULL ||
pTranscv_Info == NULL)
{
ALOGD("%s: Invalid parameter", fn);
}
else
{
len = StoreData[1] + 2; //+2 offset is for tag value and length byte
pTranscv_Info->sSendData[xx++] = STORE_DATA_CLA | (Os_info->Channel_Info[0].channel_id);
pTranscv_Info->sSendData[xx++] = STORE_DATA_INS;
pTranscv_Info->sSendData[xx++] = 0x00; //P1
pTranscv_Info->sSendData[xx++] = 0x00; //P2
pTranscv_Info->sSendData[xx++] = len;
memcpy(&(pTranscv_Info->sSendData[xx]), StoreData, len);
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sSendlength = (INT32)(xx + sizeof(StoreData));
pTranscv_Info->sRecvlength = 1024;
ALOGD("%s: Calling Secure Element Transceive", fn);
stat = mchannel->transceive (pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if((stat != TRUE) &&
(recvBufferActualSize == 0x00))
{
status = STATUS_FAILED;
ALOGE("%s: SE transceive failed status = 0x%X", fn, status);
}
else if((pTranscv_Info->sRecvData[recvBufferActualSize-2] == 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] == 0x00))
{
ALOGE("STORE CMD is successful");
status = STATUS_SUCCESS;
}
else
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*Copy the response SW in failure case*/
memcpy(&lsExecuteResp[2], &(pTranscv_Info->sRecvData
[recvBufferActualSize-2]),2);
#endif
status = STATUS_FAILED;
}
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_loadapplet
**
** Description: Reads the script from the file and sent to Ala
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_loadapplet(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn [] = "ALA_loadapplet";
BOOLEAN stat = FALSE;
int wResult, size =0;
INT32 wIndex,wCount=0;
INT32 wLen = 0;
INT32 recvBufferActualSize = 0;
UINT8 temp_buf[1024];
UINT8 len_byte=0, offset =0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
Os_info->bytes_read = 0;
#if(NXP_LDR_SVC_VER_2 == TRUE)
BOOLEAN reachEOFCheck = FALSE;
tJBL_STATUS tag40_found = STATUS_FAILED;
if(Os_info->bytes_wrote == 0xAA)
{
Os_info->fResp = fopen(Os_info->fls_RespPath, "a+");
if(Os_info->fResp == NULL)
{
ALOGE("Error opening response recording file <%s> for reading: %s",
Os_info->fls_path, strerror(errno));
return status;
}
ALOGD("%s: Response OUT FILE path is successfully created", fn);
}
else
{
ALOGD("%s: Response Out file is optional as per input", fn);
}
#endif
ALOGD("%s: enter", fn);
if(Os_info == NULL ||
pTranscv_Info == NULL)
{
ALOGE("%s: invalid parameter", fn);
return status;
}
Os_info->fp = fopen(Os_info->fls_path, "r");
if (Os_info->fp == NULL) {
ALOGE("Error opening OS image file <%s> for reading: %s",
Os_info->fls_path, strerror(errno));
return status;
}
wResult = fseek(Os_info->fp, 0L, SEEK_END);
if (wResult) {
ALOGE("Error seeking end OS image file %s", strerror(errno));
goto exit;
}
Os_info->fls_size = ftell(Os_info->fp);
ALOGE("fls_size=%d", Os_info->fls_size);
if (Os_info->fls_size < 0) {
ALOGE("Error ftelling file %s", strerror(errno));
goto exit;
}
wResult = fseek(Os_info->fp, 0L, SEEK_SET);
if (wResult) {
ALOGE("Error seeking start image file %s", strerror(errno));
goto exit;
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
status = ALA_Check_KeyIdentifier(Os_info, status, pTranscv_Info,
NULL, STATUS_FAILED, 0);
#else
status = ALA_Check_KeyIdentifier(Os_info, status, pTranscv_Info);
#endif
if(status != STATUS_OK)
{
goto exit;
}
while(!feof(Os_info->fp) &&
(Os_info->bytes_read < Os_info->fls_size))
{
len_byte = 0x00;
offset = 0;
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*Check if the certificate/ is verified or not*/
if(status != STATUS_OK)
{
goto exit;
}
#endif
memset(temp_buf, 0, sizeof(temp_buf));
ALOGE("%s; Start of line processing", fn);
status = ALA_ReadScript(Os_info, temp_buf);
if(status != STATUS_OK)
{
goto exit;
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
else if(status == STATUS_OK)
{
/*Reset the flag in case further commands exists*/
reachEOFCheck = FALSE;
}
#endif
if(temp_buf[offset] == TAG_ALA_CMD_ID)
{
/*
* start sending the packet to Ala
* */
offset = offset+1;
len_byte = Numof_lengthbytes(&temp_buf[offset], &wLen);
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*If the len data not present or
* len is less than or equal to 32*/
if((len_byte == 0)||(wLen <= 32))
#else
if((len_byte == 0))
#endif
{
ALOGE("Invalid length zero");
#if(NXP_LDR_SVC_VER_2 == TRUE)
goto exit;
#else
return status;
#endif
}
else
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
tag40_found = STATUS_OK;
#endif
offset = offset+len_byte;
pTranscv_Info->sSendlength = wLen;
memcpy(pTranscv_Info->sSendData, &temp_buf[offset], wLen);
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
status = ALA_SendtoAla(Os_info, status, pTranscv_Info, LS_Comm);
#else
status = ALA_SendtoAla(Os_info, status, pTranscv_Info);
#endif
if(status != STATUS_OK)
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*When the switching of LS 6320 case*/
if(status == STATUS_FILE_NOT_FOUND)
{
/*When 6320 occurs close the existing channels*/
ALA_CloseChannel(Os_info,status,pTranscv_Info);
status = STATUS_FAILED;
status = ALA_OpenChannel(Os_info,status,pTranscv_Info);
if(status == STATUS_OK)
{
ALOGD("SUCCESS:Post Switching LS open channel");
status = STATUS_FAILED;
status = ALA_SelectAla(Os_info,status,pTranscv_Info);
if(status == STATUS_OK)
{
ALOGD("SUCCESS:Post Switching LS select");
status = STATUS_FAILED;
status = ALA_StoreData(Os_info,status,pTranscv_Info);
if(status == STATUS_OK)
{
/*Enable certificate and signature verification*/
tag40_found = STATUS_OK;
lsExecuteResp[2] = 0x90;
lsExecuteResp[3] = 0x00;
reachEOFCheck = TRUE;
continue;
}
ALOGE("Post Switching LS store data failure");
}
ALOGE("Post Switching LS select failure");
}
ALOGE("Post Switching LS failure");
}
ALOGE("Sending packet to ala failed");
goto exit;
#else
return status;
#endif
}
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
else if((temp_buf[offset] == (0x7F))&&(temp_buf[offset+1] == (0x21)))
{
ALOGD("TAGID: Encountered again certificate tag 7F21");
if(tag40_found == STATUS_OK)
{
ALOGD("2nd Script processing starts with reselect");
status = STATUS_FAILED;
status = ALA_SelectAla(Os_info,status,pTranscv_Info);
if(status == STATUS_OK)
{
ALOGD("2nd Script select success next store data command");
status = STATUS_FAILED;
status = ALA_StoreData(Os_info,status,pTranscv_Info);
if(status == STATUS_OK)
{
ALOGD("2nd Script store data success next certificate verification");
offset = offset+2;
len_byte = Numof_lengthbytes(&temp_buf[offset], &wLen);
status = ALA_Check_KeyIdentifier(Os_info, status, pTranscv_Info,
temp_buf, STATUS_OK, wLen+len_byte+2);
}
}
/*If the certificate and signature is verified*/
if(status == STATUS_OK)
{
/*If the certificate is verified for 6320 then new
* script starts*/
tag40_found = STATUS_FAILED;
}
/*If the certificate or signature verification failed*/
else{
goto exit;
}
}
/*Already certificate&Sginature verified previously skip 7f21& tag 60*/
else
{
memset(temp_buf, 0, sizeof(temp_buf));
status = ALA_ReadScript(Os_info, temp_buf);
if(status != STATUS_OK)
{
ALOGE("%s; Next Tag has to TAG 60 not found", fn);
goto exit;
}
if(temp_buf[offset] == TAG_JSBL_HDR_ID)
continue;
else
goto exit;
}
}
#endif
else
{
/*
* Invalid packet received in between stop processing packet
* return failed status
* */
status = STATUS_FAILED;
break;
}
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
if(Os_info->bytes_wrote == 0xAA)
{
fclose(Os_info->fResp);
}
ALA_UpdateExeStatus(LS_SUCCESS_STATUS);
#endif
wResult = fclose(Os_info->fp);
ALOGE("%s exit;End of Load Applet; status=0x%x",fn, status);
return status;
exit:
wResult = fclose(Os_info->fp);
#if(NXP_LDR_SVC_VER_2 == TRUE)
if(Os_info->bytes_wrote == 0xAA)
{
fclose(Os_info->fResp);
}
/*Script ends with SW 6320 and reached END OF FILE*/
if(reachEOFCheck == TRUE)
{
status = STATUS_OK;
ALA_UpdateExeStatus(LS_SUCCESS_STATUS);
}
#endif
ALOGE("%s close fp and exit; status= 0x%X", fn,status);
return status;
}
/*******************************************************************************
**
** Function: ALA_ProcessResp
**
** Description: Process the response packet received from Ala
**
** Returns: Success if ok.
**
*******************************************************************************/
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS ALA_Check_KeyIdentifier(Ala_ImageInfo_t *Os_info, tJBL_STATUS status,
Ala_TranscieveInfo_t *pTranscv_Info, UINT8* temp_buf, tJBL_STATUS flag,
INT32 wNewLen)
#else
tJBL_STATUS ALA_Check_KeyIdentifier(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
#endif
{
static const char fn[] = "ALA_Check_KeyIdentifier";
#if(NXP_LDR_SVC_VER_2 == TRUE)
UINT16 offset = 0x00, len_byte=0;
#else
UINT8 offset = 0x00, len_byte=0;
#endif
tJBL_STATUS key_found = STATUS_FAILED;
status = STATUS_FAILED;
UINT8 read_buf[1024];
bool stat = false;
INT32 wLen, recvBufferActualSize=0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
#if(NXP_LDR_SVC_VER_2 == TRUE)
UINT8 certf_found = STATUS_FAILED;
UINT8 sign_found = STATUS_FAILED;
#endif
ALOGD("%s: enter", fn);
#if(NXP_LDR_SVC_VER_2 == TRUE)
while(!feof(Os_info->fp) &&
(Os_info->bytes_read < Os_info->fls_size))
{
offset = 0x00;
wLen = 0;
if(flag == STATUS_OK)
{
/*If the 7F21 TAG is already read: After TAG 40*/
memcpy(read_buf, temp_buf, wNewLen);
status = STATUS_OK;
flag = STATUS_FAILED;
}
else
{
/*If the 7F21 TAG is not read: Before TAG 40*/
status = ALA_ReadScript(Os_info, read_buf);
}
if(status != STATUS_OK)
return status;
if(STATUS_OK == Check_Complete_7F21_Tag(Os_info,pTranscv_Info,
read_buf, &offset))
{
ALOGD("%s: Certificate is verified", fn);
certf_found = STATUS_OK;
break;
}
/*The Loader Service Client ignores all subsequent commands starting by tag
* �7F21� or tag �60� until the first command starting by tag �40� is found*/
else if(((read_buf[offset] == TAG_ALA_CMD_ID)&&(certf_found != STATUS_OK)))
{
ALOGE("%s: NOT FOUND Root entity identifier's certificate", fn);
status = STATUS_FAILED;
return status;
}
}
#endif
#if(NXP_LDR_SVC_VER_2 == TRUE)
memset(read_buf, 0, sizeof(read_buf));
if(certf_found == STATUS_OK)
{
#else
while(!feof(Os_info->fp))
{
#endif
offset = 0x00;
wLen = 0;
status = ALA_ReadScript(Os_info, read_buf);
if(status != STATUS_OK)
return status;
#if(NXP_LDR_SVC_VER_2 == TRUE)
else
status = STATUS_FAILED;
if((read_buf[offset] == TAG_JSBL_HDR_ID)&&
(certf_found != STATUS_FAILED)&&(sign_found != STATUS_OK))
#else
if(read_buf[offset] == TAG_JSBL_HDR_ID &&
key_found != STATUS_OK)
#endif
{
//TODO check the SElect cmd response and return status accordingly
ALOGD("TAGID: TAG_JSBL_HDR_ID");
offset = offset+1;
len_byte = Numof_lengthbytes(&read_buf[offset], &wLen);
offset = offset + len_byte;
#if(NXP_LDR_SVC_VER_2 == FALSE)
if(read_buf[offset] == TAG_JSBL_KEY_ID)
{
ALOGE("TAGID: TAG_JSBL_KEY_ID");
offset = offset+1;
wLen = read_buf[offset];
offset = offset+1;
key_found = memcmp(&read_buf[offset], Select_Rsp,
Select_Rsp_Len);
if(key_found == STATUS_OK)
{
ALOGE("Key is matched");
offset = offset + wLen;
#endif
if(read_buf[offset] == TAG_SIGNATURE_ID)
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
offset = offset+1;
len_byte = Numof_lengthbytes(&read_buf[offset], &wLen);
offset = offset + len_byte;
#endif
ALOGE("TAGID: TAG_SIGNATURE_ID");
#if(NXP_LDR_SVC_VER_2 == TRUE)
pTranscv_Info->sSendlength = wLen+5;
pTranscv_Info->sSendData[0] = 0x00;
pTranscv_Info->sSendData[1] = 0xA0;
pTranscv_Info->sSendData[2] = 0x00;
pTranscv_Info->sSendData[3] = 0x00;
pTranscv_Info->sSendData[4] = wLen;
memcpy(&(pTranscv_Info->sSendData[5]),
&read_buf[offset], wLen);
#else
offset = offset+1;
wLen = 0;
len_byte = Numof_lengthbytes(&read_buf[offset], &wLen);
if(len_byte == 0)
{
ALOGE("Invalid length zero");
return STATUS_FAILED;
}
else
{
offset = offset+len_byte;
pTranscv_Info->sSendlength = wLen;
memcpy(pTranscv_Info->sSendData, &read_buf[offset],
wLen);
}
#endif
ALOGE("%s: start transceive for length %ld", fn,
pTranscv_Info->sSendlength);
#if(NXP_LDR_SVC_VER_2 == TRUE)
status = ALA_SendtoAla(Os_info, status, pTranscv_Info, LS_Sign);
#else
status = ALA_SendtoAla(Os_info, status, pTranscv_Info);
#endif
if(status != STATUS_OK)
{
return status;
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
else
{
sign_found = STATUS_OK;
}
#endif
}
#if(NXP_LDR_SVC_VER_2 == FALSE)
}
else
{
/*
* Discard the packet and goto next line
* */
}
}
else
{
ALOGE("Invalid Tag ID");
status = STATUS_FAILED;
break;
}
#endif
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
else if(read_buf[offset] != TAG_JSBL_HDR_ID )
{
status = STATUS_FAILED;
}
#else
else if(read_buf[offset] == TAG_ALA_CMD_ID &&
key_found == STATUS_OK)
{
/*Key match is success and start sending the packet to Ala
* return status ok
* */
ALOGE("TAGID: TAG_ALA_CMD_ID");
offset = offset+1;
wLen = 0;
len_byte = Numof_lengthbytes(&read_buf[offset], &wLen);
if(len_byte == 0)
{
ALOGE("Invalid length zero");
return STATUS_FAILED;
}
else
{
offset = offset+len_byte;
pTranscv_Info->sSendlength = wLen;
memcpy(pTranscv_Info->sSendData, &read_buf[offset], wLen);
}
status = ALA_SendtoAla(Os_info, status, pTranscv_Info);
break;
}
else if(read_buf[offset] == TAG_JSBL_HDR_ID &&
key_found == STATUS_OK)
{
/*Key match is success
* Discard the packets untill we found header T=0x40
* */
}
else
{
/*Invalid header*/
status = STATUS_FAILED;
break;
}
#endif
#if(NXP_LDR_SVC_VER_2 == FALSE)
}
#else
}
else
{
ALOGE("%s : Exit certificate verification failed", fn);
}
#endif
ALOGD("%s: exit: status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_ReadScript
**
** Description: Reads the current line if the script
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_ReadScript(Ala_ImageInfo_t *Os_info, UINT8 *read_buf)
{
static const char fn[]="ALA_ReadScript";
INT32 wCount, wLen, wIndex = 0;
UINT8 len_byte = 0;
int wResult = 0;
tJBL_STATUS status = STATUS_FAILED;
INT32 lenOff = 1;
ALOGD("%s: enter", fn);
for(wCount =0; (wCount < 2 && !feof(Os_info->fp)); wCount++, wIndex++)
{
wResult = FSCANF_BYTE(Os_info->fp,"%2X",(unsigned int*)&read_buf[wIndex]);
}
if(wResult == 0)
return STATUS_FAILED;
Os_info->bytes_read = Os_info->bytes_read + (wCount*2);
#if(NXP_LDR_SVC_VER_2 == TRUE)
if((read_buf[0]==0x7f) && (read_buf[1]==0x21))
{
for(wCount =0; (wCount < 1 && !feof(Os_info->fp)); wCount++, wIndex++)
{
wResult = FSCANF_BYTE(Os_info->fp,"%2X",(unsigned int*)&read_buf[wIndex]);
}
if(wResult == 0)
{
ALOGE("%s: Exit Read Script failed in 7F21 ", fn);
return STATUS_FAILED;
}
/*Read_Script from wCount*2 to wCount*1 */
Os_info->bytes_read = Os_info->bytes_read + (wCount*2);
lenOff = 2;
}
else if((read_buf[0] == 0x40)||(read_buf[0] == 0x60))
{
lenOff = 1;
}
/*If TAG is neither 7F21 nor 60 nor 40 then ABORT execution*/
else
{
ALOGE("Invalid TAG 0x%X found in the script", read_buf[0]);
return STATUS_FAILED;
}
#endif
if(read_buf[lenOff] == 0x00)
{
ALOGE("Invalid length zero");
len_byte = 0x00;
return STATUS_FAILED;
}
else if((read_buf[lenOff] & 0x80) == 0x80)
{
len_byte = read_buf[lenOff] & 0x0F;
len_byte = len_byte +1; //1 byte added for byte 0x81
ALOGD("%s: Length byte Read from 0x80 is 0x%x ", fn, len_byte);
if(len_byte == 0x02)
{
for(wCount =0; (wCount < 1 && !feof(Os_info->fp)); wCount++, wIndex++)
{
wResult = FSCANF_BYTE(Os_info->fp,"%2X",(unsigned int*)&read_buf[wIndex]);
}
if(wResult == 0)
{
ALOGE("%s: Exit Read Script failed in length 0x02 ", fn);
return STATUS_FAILED;
}
wLen = read_buf[lenOff+1];
Os_info->bytes_read = Os_info->bytes_read + (wCount*2);
ALOGD("%s: Length of Read Script in len_byte= 0x02 is 0x%lx ", fn, wLen);
}
else if(len_byte == 0x03)
{
for(wCount =0; (wCount < 2 && !feof(Os_info->fp)); wCount++, wIndex++)
{
wResult = FSCANF_BYTE(Os_info->fp,"%2X",(unsigned int*)&read_buf[wIndex]);
}
if(wResult == 0)
{
ALOGE("%s: Exit Read Script failed in length 0x03 ", fn);
return STATUS_FAILED;
}
Os_info->bytes_read = Os_info->bytes_read + (wCount*2);
wLen = read_buf[lenOff+1]; //Length of the packet send to ALA
wLen = ((wLen << 8) | (read_buf[lenOff+2]));
ALOGD("%s: Length of Read Script in len_byte= 0x03 is 0x%lx ", fn, wLen);
}
else
{
/*Need to provide the support if length is more than 2 bytes*/
ALOGE("Length recived is greater than 3");
return STATUS_FAILED;
}
}
else
{
len_byte = 0x01;
wLen = read_buf[lenOff];
ALOGE("%s: Length of Read Script in len_byte= 0x01 is 0x%lx ", fn, wLen);
}
for(wCount =0; (wCount < wLen && !feof(Os_info->fp)); wCount++, wIndex++)
{
wResult = FSCANF_BYTE(Os_info->fp,"%2X",(unsigned int*)&read_buf[wIndex]);
}
if(wResult == 0)
{
ALOGE("%s: Exit Read Script failed in fscanf function ", fn);
return status;
}
else
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
Os_info->bytes_read = Os_info->bytes_read + (wCount*2)+1; //not sure why 2 added
#else
Os_info->bytes_read = Os_info->bytes_read + (wCount*2)+2; //not sure why 2 added
#endif
status = STATUS_OK;
}
ALOGD("%s: exit: status=0x%x; Num of bytes read=%d and index=%ld",
fn, status, Os_info->bytes_read,wIndex);
return status;
}
/*******************************************************************************
**
** Function: ALA_SendtoEse
**
** Description: It is used to send the packet to p61
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_SendtoEse(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn [] = "ALA_SendtoEse";
bool stat =false, chanl_open_cmd = false;
UINT8 xx=0;
status = STATUS_FAILED;
INT32 recvBufferActualSize=0, recv_len = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
ALOGD("%s: enter", fn);
#ifdef JCOP3_WR
/*
* Bufferize_load_cmds function is implemented in JCOP
* */
status = Bufferize_load_cmds(Os_info, status, pTranscv_Info);
if(status != STATUS_FAILED)
{
#endif
if(pTranscv_Info->sSendData[1] == 0x70)
{
if(pTranscv_Info->sSendData[2] == 0x00)
{
ALOGE("Channel open");
chanl_open_cmd = true;
}
else
{
ALOGE("Channel close");
for(UINT8 cnt=0; cnt < Os_info->channel_cnt; cnt++)
{
if(Os_info->Channel_Info[cnt].channel_id == pTranscv_Info->sSendData[3])
{
ALOGE("Closed channel id = 0x0%x", Os_info->Channel_Info[cnt].channel_id);
Os_info->Channel_Info[cnt].isOpend = false;
}
}
}
}
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sRecvlength = 1024;
stat = mchannel->transceive(pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if(stat != TRUE)
{
ALOGE("%s: Transceive failed; status=0x%X", fn, stat);
}
else
{
if(chanl_open_cmd == true)
{
if((recvBufferActualSize == 0x03) &&
((pTranscv_Info->sRecvData[recvBufferActualSize-2] == 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] == 0x00)))
{
ALOGE("open channel success");
UINT8 cnt = Os_info->channel_cnt;
Os_info->Channel_Info[cnt].channel_id = pTranscv_Info->sRecvData[recvBufferActualSize-3];
Os_info->Channel_Info[cnt].isOpend = true;
Os_info->channel_cnt++;
}
else
{
ALOGE("channel open faield");
}
}
status = Process_EseResponse(pTranscv_Info, recvBufferActualSize, Os_info);
}
#ifdef JCOP3_WR
}
else if(SendBack_cmds == false)
{
/*
* Workaround for issue in JCOP
* Send the fake response back
* */
recvBufferActualSize = 0x03;
pTranscv_Info->sRecvData[0] = 0x00;
pTranscv_Info->sRecvData[1] = 0x90;
pTranscv_Info->sRecvData[2] = 0x00;
status = Process_EseResponse(pTranscv_Info, recvBufferActualSize, Os_info);
}
else
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
if(islastcmdLoad == true)
{
status = Send_Backall_Loadcmds(Os_info, status, pTranscv_Info);
SendBack_cmds = false;
}else
{
memset(Cmd_Buffer, 0, sizeof(Cmd_Buffer));
SendBack_cmds = false;
status = STATUS_FAILED;
}
#else
status = Send_Backall_Loadcmds(Os_info, status, pTranscv_Info);
SendBack_cmds = false;
#endif
}
#endif
ALOGD("%s: exit: status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_SendtoAla
**
** Description: It is used to forward the packet to Ala
**
** Returns: Success if ok.
**
*******************************************************************************/
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS ALA_SendtoAla(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info, Ls_TagType tType)
#else
tJBL_STATUS ALA_SendtoAla(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
#endif
{
static const char fn [] = "ALA_SendtoAla";
bool stat =false;
status = STATUS_FAILED;
INT32 recvBufferActualSize = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
ALOGD("%s: enter", fn);
#if(NXP_LDR_SVC_VER_2 == TRUE)
pTranscv_Info->sSendData[0] = (0x80 | Os_info->Channel_Info[0].channel_id);
#else
pTranscv_Info->sSendData[0] = (pTranscv_Info->sSendData[0] | Os_info->Channel_Info[0].channel_id);
#endif
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sRecvlength = 1024;
stat = mchannel->transceive(pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if(stat != TRUE)
{
ALOGE("%s: Transceive failed; status=0x%X", fn, stat);
}
else
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
status = ALA_ProcessResp(Os_info, recvBufferActualSize, pTranscv_Info, tType);
#else
status = ALA_ProcessResp(Os_info, recvBufferActualSize, pTranscv_Info);
#endif
}
ALOGD("%s: exit: status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_CloseChannel
**
** Description: Closes the previously opened logical channel
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS ALA_CloseChannel(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn [] = "ALA_CloseChannel";
status = STATUS_FAILED;
bool stat = false;
UINT8 xx =0;
INT32 recvBufferActualSize = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
UINT8 cnt = 0;
ALOGD("%s: enter",fn);
if(Os_info == NULL ||
pTranscv_Info == NULL)
{
ALOGE("Invalid parameter");
}
else
{
for(cnt =0; (cnt < Os_info->channel_cnt); cnt++)
{
if(Os_info->Channel_Info[cnt].isOpend == false)
continue;
xx = 0;
pTranscv_Info->sSendData[xx++] = Os_info->Channel_Info[cnt].channel_id;
pTranscv_Info->sSendData[xx++] = 0x70;
pTranscv_Info->sSendData[xx++] = 0x80;
pTranscv_Info->sSendData[xx++] = Os_info->Channel_Info[cnt].channel_id;
pTranscv_Info->sSendData[xx++] = 0x00;
pTranscv_Info->sSendlength = xx;
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sRecvlength = 1024;
stat = mchannel->transceive(pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if(stat != TRUE &&
recvBufferActualSize < 2)
{
ALOGE("%s: Transceive failed; status=0x%X", fn, stat);
}
else if((pTranscv_Info->sRecvData[recvBufferActualSize-2] == 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] == 0x00))
{
ALOGE("Close channel id = 0x0%x is success", Os_info->Channel_Info[cnt].channel_id);
status = STATUS_OK;
}
else
{
ALOGE("Close channel id = 0x0%x is failed", Os_info->Channel_Info[cnt].channel_id);
}
}
}
ALOGD("%s: exit; status=0x0%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_ProcessResp
**
** Description: Process the response packet received from Ala
**
** Returns: Success if ok.
**
*******************************************************************************/
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS ALA_ProcessResp(Ala_ImageInfo_t *image_info, INT32 recvlen, Ala_TranscieveInfo_t *trans_info, Ls_TagType tType)
#else
tJBL_STATUS ALA_ProcessResp(Ala_ImageInfo_t *image_info, INT32 recvlen, Ala_TranscieveInfo_t *trans_info)
#endif
{
static const char fn [] = "ALA_ProcessResp";
tJBL_STATUS status = STATUS_FAILED;
static INT32 temp_len = 0;
UINT8* RecvData = trans_info->sRecvData;
UINT8 xx =0;
char sw[2];
ALOGD("%s: enter", fn);
if(RecvData == NULL &&
recvlen == 0x00)
{
ALOGE("%s: Invalid parameter: status=0x%x", fn, status);
return status;
}
else if(recvlen >= 2)
{
sw[0] = RecvData[recvlen-2];
sw[1] = RecvData[recvlen-1];
}
else
{
ALOGE("%s: Invalid response; status=0x%x", fn, status);
return status;
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*Update the Global variable for storing response length*/
resp_len = recvlen;
if((sw[0] != 0x63))
{
lsExecuteResp[2] = sw[0];
lsExecuteResp[3] = sw[1];
ALOGD("%s: Process Response SW; status = 0x%x", fn, sw[0]);
ALOGD("%s: Process Response SW; status = 0x%x", fn, sw[1]);
}
#endif
if((recvlen == 0x02) &&
(sw[0] == 0x90) &&
(sw[1] == 0x00))
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS wStatus = STATUS_FAILED;
ALOGE("%s: Before Write Response", fn);
wStatus = Write_Response_To_OutFile(image_info, RecvData, recvlen, tType);
if(wStatus != STATUS_FAILED)
#endif
status = STATUS_OK;
}
else if((recvlen > 0x02) &&
(sw[0] == 0x90) &&
(sw[1] == 0x00))
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
tJBL_STATUS wStatus = STATUS_FAILED;
ALOGE("%s: Before Write Response", fn);
wStatus = Write_Response_To_OutFile(image_info, RecvData, recvlen, tType);
if(wStatus != STATUS_FAILED)
status = STATUS_OK;
#else
if(temp_len != 0)
{
memcpy((trans_info->sTemp_recvbuf+temp_len), RecvData, (recvlen-2));
trans_info->sSendlength = temp_len + (recvlen-2);
memcpy(trans_info->sSendData, trans_info->sTemp_recvbuf, trans_info->sSendlength);
temp_len = 0;
}
else
{
memcpy(trans_info->sSendData, RecvData, (recvlen-2));
trans_info->sSendlength = recvlen-2;
}
status = ALA_SendtoEse(image_info, status, trans_info);
#endif
}
#if(NXP_LDR_SVC_VER_2 == FALSE)
else if ((recvlen > 0x02) &&
(sw[0] == 0x61))
{
memcpy((trans_info->sTemp_recvbuf+temp_len), RecvData, (recvlen-2));
temp_len = temp_len + recvlen-2;
trans_info->sSendData[xx++] = image_info->Channel_Info[0].channel_id;
trans_info->sSendData[xx++] = 0xC0;
trans_info->sSendData[xx++] = 0x00;
trans_info->sSendData[xx++] = 0x00;
trans_info->sSendData[xx++] = sw[1];
trans_info->sSendlength = xx;
status = ALA_SendtoAla(image_info, status, trans_info);
}
#endif
#if(NXP_LDR_SVC_VER_2 == TRUE)
else if ((recvlen > 0x02) &&
(sw[0] == 0x63) &&
(sw[1] == 0x10))
{
if(temp_len != 0)
{
memcpy((trans_info->sTemp_recvbuf+temp_len), RecvData, (recvlen-2));
trans_info->sSendlength = temp_len + (recvlen-2);
memcpy(trans_info->sSendData, trans_info->sTemp_recvbuf,
trans_info->sSendlength);
temp_len = 0;
}
else
{
memcpy(trans_info->sSendData, RecvData, (recvlen-2));
trans_info->sSendlength = recvlen-2;
}
status = ALA_SendtoEse(image_info, status, trans_info);
}
else if ((recvlen > 0x02) &&
(sw[0] == 0x63) &&
(sw[1] == 0x20))
{
UINT8 respLen = 0;
INT32 wStatus = 0;
AID_ARRAY[0] = recvlen+3;
AID_ARRAY[1] = 00;
AID_ARRAY[2] = 0xA4;
AID_ARRAY[3] = 0x04;
AID_ARRAY[4] = 0x00;
AID_ARRAY[5] = recvlen-2;
memcpy(&AID_ARRAY[6], &RecvData[0],recvlen-2);
memcpy(&ArrayOfAIDs[2][0], &AID_ARRAY[0], recvlen+4);
fAID_MEM = fopen(AID_MEM_PATH,"w");
if (fAID_MEM == NULL) {
ALOGE("Error opening AID data for writing: %s",strerror(errno));
return status;
}
/*Updating the AID_MEM with new value into AID file*/
while(respLen <= (recvlen+4))
{
wStatus = fprintf(fAID_MEM, "%2x", AID_ARRAY[respLen++]);
if(wStatus != 2)
{
ALOGE("%s: Invalid Response during fprintf; status=0x%x",
fn, status);
fclose(fAID_MEM);
break;
}
}
if(wStatus == 2)
{
status = STATUS_FILE_NOT_FOUND;
}
else
{
status = STATUS_FAILED;
}
}
else if((recvlen >= 0x02) &&(
(sw[0] != 0x90) &&
(sw[0] != 0x63)&&(sw[0] != 0x61)))
{
tJBL_STATUS wStatus = STATUS_FAILED;
wStatus = Write_Response_To_OutFile(image_info, RecvData, recvlen, tType);
//if(wStatus != STATUS_FAILED)
//status = STATUS_OK;
}
#endif
ALOGD("%s: exit: status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: ALA_SendtoEse
**
** Description: It is used to process the received response packet from p61
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS Process_EseResponse(Ala_TranscieveInfo_t *pTranscv_Info, INT32 recv_len, Ala_ImageInfo_t *Os_info)
{
static const char fn[] = "Process_EseResponse";
tJBL_STATUS status = STATUS_OK;
UINT8 xx = 0;
ALOGD("%s: enter", fn);
pTranscv_Info->sSendData[xx++] = (CLA_BYTE | Os_info->Channel_Info[0].channel_id);
#if(NXP_LDR_SVC_VER_2 == TRUE)
pTranscv_Info->sSendData[xx++] = 0xA2;
#else
pTranscv_Info->sSendData[xx++] = 0xA0;
#endif
if(recv_len <= 0xFF)
{
#if(NXP_LDR_SVC_VER_2 == TRUE)
pTranscv_Info->sSendData[xx++] = 0x80;
#else
pTranscv_Info->sSendData[xx++] = ONLY_BLOCK;
#endif
pTranscv_Info->sSendData[xx++] = 0x00;
pTranscv_Info->sSendData[xx++] = (UINT8)recv_len;
memcpy(&(pTranscv_Info->sSendData[xx]),pTranscv_Info->sRecvData,recv_len);
pTranscv_Info->sSendlength = xx+ recv_len;
#if(NXP_LDR_SVC_VER_2)
status = ALA_SendtoAla(Os_info, status, pTranscv_Info, LS_Comm);
#else
status = ALA_SendtoAla(Os_info, status, pTranscv_Info);
#endif
}
else
{
while(recv_len > MAX_SIZE)
{
xx = PARAM_P1_OFFSET;
#if(NXP_LDR_SVC_VER_2 == TRUE)
pTranscv_Info->sSendData[xx++] = 0x00;
#else
pTranscv_Info->sSendData[xx++] = FIRST_BLOCK;
#endif
pTranscv_Info->sSendData[xx++] = 0x00;
pTranscv_Info->sSendData[xx++] = MAX_SIZE;
recv_len = recv_len - MAX_SIZE;
memcpy(&(pTranscv_Info->sSendData[xx]),pTranscv_Info->sRecvData,MAX_SIZE);
pTranscv_Info->sSendlength = xx+ MAX_SIZE;
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*Need not store Process eSE response's response in the out file so
* LS_Comm = 0*/
status = ALA_SendtoAla(Os_info, status, pTranscv_Info, LS_Comm);
#else
status = ALA_SendtoAla(Os_info, status, pTranscv_Info);
#endif
if(status != STATUS_OK)
{
ALOGE("Sending packet to Ala failed: status=0x%x", status);
return status;
}
}
xx = PARAM_P1_OFFSET;
pTranscv_Info->sSendData[xx++] = LAST_BLOCK;
pTranscv_Info->sSendData[xx++] = 0x01;
pTranscv_Info->sSendData[xx++] = recv_len;
memcpy(&(pTranscv_Info->sSendData[xx]),pTranscv_Info->sRecvData,recv_len);
pTranscv_Info->sSendlength = xx+ recv_len;
#if(NXP_LDR_SVC_VER_2 == TRUE)
status = ALA_SendtoAla(Os_info, status, pTranscv_Info, LS_Comm);
#else
status = ALA_SendtoAla(Os_info, status, pTranscv_Info);
#endif
}
ALOGD("%s: exit: status=0x%x", fn, status);
return status;
}
/*******************************************************************************
**
** Function: Process_SelectRsp
**
** Description: It is used to process the received response for SELECT ALA cmd
**
** Returns: Success if ok.
**
*******************************************************************************/
tJBL_STATUS Process_SelectRsp(UINT8* Recv_data, INT32 Recv_len)
{
static const char fn[]="Process_SelectRsp";
tJBL_STATUS status = STATUS_FAILED;
int i = 0, len=0;
ALOGE("%s: enter", fn);
if(Recv_data[i] == TAG_SELECT_ID)
{
ALOGD("TAG: TAG_SELECT_ID");
i = i +1;
len = Recv_data[i];
i = i+1;
if(Recv_data[i] == TAG_ALA_ID)
{
ALOGD("TAG: TAG_ALA_ID");
i = i+1;
len = Recv_data[i];
i = i + 1 + len; //points to next tag name A5
#if(NXP_LDR_SVC_VER_2 == TRUE)
//points to TAG 9F08 for LS application version
if((Recv_data[i] == TAG_LS_VER1)&&(Recv_data[i+1] == TAG_LS_VER2))
{
UINT8 lsaVersionLen = 0;
ALOGD("TAG: TAG_LS_APPLICATION_VER");
i = i+2;
lsaVersionLen = Recv_data[i];
//points to TAG 9F08 LS application version
i = i+1;
memcpy(lsVersionArr, &Recv_data[i],lsaVersionLen);
//points to Identifier of the Root Entity key set identifier
i = i+lsaVersionLen;
if(Recv_data[i] == TAG_RE_KEYID)
{
UINT8 rootEntityLen = 0;
i = i+1;
rootEntityLen = Recv_data[i];
i = i+1;
if(Recv_data[i] == TAG_LSRE_ID)
{
UINT8 tag42Len = 0;
i = i+1;
tag42Len = Recv_data[i];
//copy the data including length
memcpy(tag42Arr, &Recv_data[i], tag42Len+1);
i = i+tag42Len+1;
if(Recv_data[i] == TAG_LSRE_SIGNID)
{
UINT8 tag45Len = Recv_data[i+1];
memcpy(tag45Arr, &Recv_data[i+1],tag45Len+1);
status = STATUS_OK;
}
else
{
ALOGE("Invalid Root entity for TAG 45 = 0x%x; "
"status=0x%x", Recv_data[i], status);
return status;
}
}
else
{
ALOGE("Invalid Root entity for TAG 42 = 0x%x; "
"status=0x%x", Recv_data[i], status);
return status;
}
}
else
{
ALOGE("Invalid Root entity key set TAG ID = 0x%x; "
"status=0x%x", Recv_data[i], status);
return status;
}
}
}
else
{
ALOGE("Invalid Loader Service AID TAG ID = 0x%x; status=0x%x",
Recv_data[i], status);
return status;
}
}
else
{
ALOGE("Invalid FCI TAG = 0x%x; status=0x%x", Recv_data[i], status);
return status;
}
#else
if(Recv_data[i] == TAG_PRO_DATA_ID)
{
ALOGE("TAG: TAG_PRO_DATA_ID");
i = i+1;
len = Recv_data[i];
i = i + 1; //points to next tag name 61
}
}
}
else
{
/*
* Invalid start of TAG Name found
* */
ALOGE("Invalid TAG ID = 0x%x; status=0x%x", Recv_data[i], status);
return status;
}
if((i < Recv_len) &&
(Recv_data[i] == TAG_JSBL_KEY_ID))
{
/*
* Valid Key is found
* Copy the data into Select_Rsp
* */
ALOGE("Valid key id is found");
i = i +1;
len = Recv_data[i];
if(len != 0x00)
{
i = i+1;
memcpy(Select_Rsp, &Recv_data[i], len);
Select_Rsp_Len = len;
status = STATUS_OK;
}
/*
* Identifier of the certificate storing
* JSBL encryption key
* */
i = i + len;
if(Recv_data[i] == TAG_JSBL_CER_ID)
{
i = i+1;
len = Recv_data[i];
if(len != 0x00)
{
i = i+1;
Jsbl_keylen = len;
memcpy(Jsbl_RefKey, &Recv_data[i], len);
}
}
}
#endif
ALOGE("%s: Exiting status = 0x%x", fn, status);
return status;
}
#ifdef JCOP3_WR
tJBL_STATUS Bufferize_load_cmds(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn[] = "Bufferize_load_cmds";
UINT8 Param_P2;
status = STATUS_FAILED;
if(cmd_count == 0x00)
{
if((pTranscv_Info->sSendData[1] == INSTAL_LOAD_ID) &&
(pTranscv_Info->sSendData[2] == PARAM_P1_OFFSET) &&
(pTranscv_Info->sSendData[3] == 0x00))
{
ALOGE("BUffer: install for load");
pBuffer[0] = pTranscv_Info->sSendlength;
memcpy(&pBuffer[1], &(pTranscv_Info->sSendData[0]), pTranscv_Info->sSendlength);
pBuffer = pBuffer + pTranscv_Info->sSendlength + 1;
cmd_count++;
}
else
{
/*
* Do not buffer this cmd
* Send this command to eSE
* */
status = STATUS_OK;
}
}
else
{
Param_P2 = cmd_count -1;
if((pTranscv_Info->sSendData[1] == LOAD_CMD_ID) &&
(pTranscv_Info->sSendData[2] == LOAD_MORE_BLOCKS) &&
(pTranscv_Info->sSendData[3] == Param_P2))
{
ALOGE("BUffer: load");
pBuffer[0] = pTranscv_Info->sSendlength;
memcpy(&pBuffer[1], &(pTranscv_Info->sSendData[0]), pTranscv_Info->sSendlength);
pBuffer = pBuffer + pTranscv_Info->sSendlength + 1;
cmd_count++;
}
else if((pTranscv_Info->sSendData[1] == LOAD_CMD_ID) &&
(pTranscv_Info->sSendData[2] == LOAD_LAST_BLOCK) &&
(pTranscv_Info->sSendData[3] == Param_P2))
{
ALOGE("BUffer: last load");
SendBack_cmds = true;
pBuffer[0] = pTranscv_Info->sSendlength;
memcpy(&pBuffer[1], &(pTranscv_Info->sSendData[0]), pTranscv_Info->sSendlength);
pBuffer = pBuffer + pTranscv_Info->sSendlength + 1;
cmd_count++;
islastcmdLoad = true;
}
else
{
ALOGE("BUffer: Not a load cmd");
SendBack_cmds = true;
pBuffer[0] = pTranscv_Info->sSendlength;
memcpy(&pBuffer[1], &(pTranscv_Info->sSendData[0]), pTranscv_Info->sSendlength);
pBuffer = pBuffer + pTranscv_Info->sSendlength + 1;
islastcmdLoad = false;
cmd_count++;
}
}
ALOGE("%s: exit; status=0x%x", fn, status);
return status;
}
tJBL_STATUS Send_Backall_Loadcmds(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn [] = "Send_Backall_Loadcmds";
bool stat =false;
UINT8 xx=0;
status = STATUS_FAILED;
INT32 recvBufferActualSize=0, recv_len = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
ALOGD("%s: enter", fn);
pBuffer = Cmd_Buffer; // Points to start of first cmd to send
if(cmd_count == 0x00)
{
ALOGE("No cmds to stored to send to eSE");
}
else
{
while(cmd_count-- > 0)
{
pTranscv_Info->sSendlength = pBuffer[0];
memcpy(pTranscv_Info->sSendData, &pBuffer[1], pTranscv_Info->sSendlength);
pBuffer = pBuffer + 1 + pTranscv_Info->sSendlength;
stat = mchannel->transceive(pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if(stat != TRUE ||
(recvBufferActualSize < 2))
{
ALOGE("%s: Transceive failed; status=0x%X", fn, stat);
}
else if(cmd_count == 0x00) //Last command in the buffer
{
if (islastcmdLoad == false)
{
status = Process_EseResponse(pTranscv_Info, recvBufferActualSize, Os_info);
}
else if((recvBufferActualSize == 0x02) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-2] == 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] == 0x00))
{
recvBufferActualSize = 0x03;
pTranscv_Info->sRecvData[0] = 0x00;
pTranscv_Info->sRecvData[1] = 0x90;
pTranscv_Info->sRecvData[2] = 0x00;
status = Process_EseResponse(pTranscv_Info, recvBufferActualSize, Os_info);
}
else
{
status = Process_EseResponse(pTranscv_Info, recvBufferActualSize, Os_info);
}
}
else if((recvBufferActualSize == 0x02) &&
(pTranscv_Info->sRecvData[0] == 0x90) &&
(pTranscv_Info->sRecvData[1] == 0x00))
{
/*Do not do anything
* send next command in the buffer*/
}
else if((recvBufferActualSize == 0x03) &&
(pTranscv_Info->sRecvData[0] == 0x00) &&
(pTranscv_Info->sRecvData[1] == 0x90) &&
(pTranscv_Info->sRecvData[2] == 0x00))
{
/*Do not do anything
* Send next cmd in the buffer*/
}
else if((pTranscv_Info->sRecvData[recvBufferActualSize-2] != 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] != 0x00))
{
/*Error condition hence exiting the loop*/
status = Process_EseResponse(pTranscv_Info, recvBufferActualSize, Os_info);
/*If the sending of Load fails reset the count*/
cmd_count=0;
break;
}
}
}
memset(Cmd_Buffer, 0, sizeof(Cmd_Buffer));
pBuffer = Cmd_Buffer; //point back to start of line
cmd_count = 0x00;
ALOGD("%s: exit: status=0x%x", fn, status);
return status;
}
#endif
/*******************************************************************************
**
** Function: Numof_lengthbytes
**
** Description: Checks the number of length bytes and assigns
** length value to wLen.
**
** Returns: Number of Length bytes
**
*******************************************************************************/
UINT8 Numof_lengthbytes(UINT8 *read_buf, INT32 *pLen)
{
static const char fn[]= "Numof_lengthbytes";
UINT8 len_byte=0, i=0;
INT32 wLen = 0;
ALOGE("%s:enter", fn);
if(read_buf[i] == 0x00)
{
ALOGE("Invalid length zero");
len_byte = 0x00;
}
else if((read_buf[i] & 0x80) == 0x80)
{
len_byte = read_buf[i] & 0x0F;
len_byte = len_byte +1; //1 byte added for byte 0x81
}
else
{
len_byte = 0x01;
}
/*
* To get the length of the value field
* */
switch(len_byte)
{
case 0:
wLen = read_buf[0];
break;
case 1:
/*1st byte is the length*/
wLen = read_buf[0];
break;
case 2:
/*2nd byte is the length*/
wLen = read_buf[1];
break;
case 3:
/*1st and 2nd bytes are length*/
wLen = read_buf[1];
wLen = ((wLen << 8) | (read_buf[2]));
break;
case 4:
/*3bytes are the length*/
wLen = read_buf[1];
wLen = ((wLen << 16) | (read_buf[2] << 8));
wLen = (wLen | (read_buf[3]));
break;
default:
ALOGE("default case");
break;
}
*pLen = wLen;
ALOGE("%s:exit; len_bytes=0x0%x, Length=%ld", fn, len_byte, *pLen);
return len_byte;
}
#if(NXP_LDR_SVC_VER_2 == TRUE)
/*******************************************************************************
**
** Function: Write_Response_To_OutFile
**
** Description: Write the response to Out file
** with length recvlen from buffer RecvData.
**
** Returns: Success if OK
**
*******************************************************************************/
tJBL_STATUS Write_Response_To_OutFile(Ala_ImageInfo_t *image_info, UINT8* RecvData,
INT32 recvlen, Ls_TagType tType)
{
INT32 respLen = 0;
tJBL_STATUS wStatus = STATUS_FAILED;
static const char fn [] = "Write_Response_to_OutFile";
INT32 status = 0;
UINT8 tagBuffer[12] = {0x61,0,0,0,0,0,0,0,0,0,0,0};
INT32 tag44Len = 0;
INT32 tag61Len = 0;
UINT8 tag43Len = 1;
UINT8 tag43off = 0;
UINT8 tag44off = 0;
UINT8 ucTag44[3] = {0x00,0x00,0x00};
UINT8 tagLen = 0;
UINT8 tempLen = 0;
/*If the Response out file is NULL or Other than LS commands*/
if((image_info->bytes_wrote == 0x55)||(tType == LS_Default))
{
return STATUS_OK;
}
/*Certificate TAG occupies 2 bytes*/
if(tType == LS_Cert)
{
tag43Len = 2;
}
ALOGE("%s: Enter", fn);
/* |TAG | LEN(BERTLV)| VAL |
* | 61 | XX | TAG | LEN | VAL | TAG | LEN(BERTLV) | VAL |
* | 43 | 1/2 | 7F21/60/40 | 44 | apduRespLen | apduResponse |
**/
if(recvlen < 0x80)
{
tag44Len = 1;
ucTag44[0] = recvlen;
tag61Len = recvlen + 4 + tag43Len;
if(tag61Len&0x80)
{
tagBuffer[1] = 0x81;
tagBuffer[2] = tag61Len;
tag43off = 3;
tag44off = 5+tag43Len;
tagLen = tag44off+2;
}
else
{
tagBuffer[1] = tag61Len;
tag43off = 2;
tag44off = 4+tag43Len;
tagLen = tag44off+2;
}
}
else if((recvlen >= 0x80)&&(recvlen <= 0xFF))
{
ucTag44[0] = 0x81;
ucTag44[1] = recvlen;
tag61Len = recvlen + 5 + tag43Len;
tag44Len = 2;
if((tag61Len&0xFF00) != 0)
{
tagBuffer[1] = 0x82;
tagBuffer[2] = (tag61Len & 0xFF00)>>8;
tagBuffer[3] = (tag61Len & 0xFF);
tag43off = 4;
tag44off = 6+tag43Len;
tagLen = tag44off+3;
}
else
{
tagBuffer[1] = 0x81;
tagBuffer[2] = (tag61Len & 0xFF);
tag43off = 3;
tag44off = 5+tag43Len;
tagLen = tag44off+3;
}
}
else if((recvlen > 0xFF) &&(recvlen <= 0xFFFF))
{
ucTag44[0] = 0x82;
ucTag44[1] = (recvlen&0xFF00)>>8;
ucTag44[2] = (recvlen&0xFF);
tag44Len = 3;
tag61Len = recvlen + 6 + tag43Len;
if((tag61Len&0xFF00) != 0)
{
tagBuffer[1] = 0x82;
tagBuffer[2] = (tag61Len & 0xFF00)>>8;
tagBuffer[3] = (tag61Len & 0xFF);
tag43off = 4;
tag44off = 6+tag43Len;
tagLen = tag44off+4;
}
}
tagBuffer[tag43off] = 0x43;
tagBuffer[tag43off+1] = tag43Len;
tagBuffer[tag44off] = 0x44;
memcpy(&tagBuffer[tag44off+1], &ucTag44[0],tag44Len);
if(tType == LS_Cert)
{
tagBuffer[tag43off+2] = 0x7F;
tagBuffer[tag43off+3] = 0x21;
}
else if(tType == LS_Sign)
{
tagBuffer[tag43off+2] = 0x60;
}
else if(tType == LS_Comm)
{
tagBuffer[tag43off+2] = 0x40;
}
else
{
/*Do nothing*/
}
while(tempLen < tagLen)
{
status = fprintf(image_info->fResp, "%02X", tagBuffer[tempLen++]);
if(status != 2)
{
ALOGE("%s: Invalid Response during fprintf; status=0x%lx", fn, (status));
wStatus = STATUS_FAILED;
break;
}
}
/*Updating the response data into out script*/
while(respLen < recvlen)
{
status = fprintf(image_info->fResp, "%02X", RecvData[respLen++]);
if(status != 2)
{
ALOGE("%s: Invalid Response during fprintf; status=0x%lx", fn, (status));
wStatus = STATUS_FAILED;
break;
}
}
if((status == 2))
{
fprintf(image_info->fResp, "%s\n", "");
ALOGE("%s: SUCCESS Response written to script out file; status=0x%lx", fn, (status));
wStatus = STATUS_OK;
}
return wStatus;
}
/*******************************************************************************
**
** Function: Check_Certificate_Tag
**
** Description: Check certificate Tag presence in script
** by 7F21 .
**
** Returns: Success if Tag found
**
*******************************************************************************/
tJBL_STATUS Check_Certificate_Tag(UINT8 *read_buf, UINT16 *offset1)
{
tJBL_STATUS status = STATUS_FAILED;
UINT16 len_byte = 0;
INT32 wLen, recvBufferActualSize=0;
UINT16 offset = *offset1;
if(((read_buf[offset]<<8|read_buf[offset+1]) == TAG_CERTIFICATE))
{
ALOGD("TAGID: TAG_CERTIFICATE");
offset = offset+2;
len_byte = Numof_lengthbytes(&read_buf[offset], &wLen);
offset = offset + len_byte;
*offset1 = offset;
if(wLen <= MAX_CERT_LEN)
status = STATUS_OK;
}
return status;
}
/*******************************************************************************
**
** Function: Check_SerialNo_Tag
**
** Description: Check Serial number Tag presence in script
** by 0x93 .
**
** Returns: Success if Tag found
**
*******************************************************************************/
tJBL_STATUS Check_SerialNo_Tag(UINT8 *read_buf, UINT16 *offset1)
{
tJBL_STATUS status = STATUS_FAILED;
UINT16 offset = *offset1;
static const char fn[] = "Check_SerialNo_Tag";
if((read_buf[offset] == TAG_SERIAL_NO))
{
ALOGD("TAGID: TAG_SERIAL_NO");
UINT8 serNoLen = read_buf[offset+1];
offset = offset + serNoLen + 2;
*offset1 = offset;
ALOGD("%s: TAG_LSROOT_ENTITY is %x", fn, read_buf[offset]);
status = STATUS_OK;
}
return status;
}
/*******************************************************************************
**
** Function: Check_LSRootID_Tag
**
** Description: Check LS root ID tag presence in script and compare with
** select response root ID value.
**
** Returns: Success if Tag found
**
*******************************************************************************/
tJBL_STATUS Check_LSRootID_Tag(UINT8 *read_buf, UINT16 *offset1)
{
tJBL_STATUS status = STATUS_FAILED;
UINT16 offset = *offset1;
if(read_buf[offset] == TAG_LSRE_ID)
{
ALOGD("TAGID: TAG_LSROOT_ENTITY");
if(tag42Arr[0] == read_buf[offset+1])
{
UINT8 tag42Len = read_buf[offset+1];
offset = offset+2;
status = memcmp(&read_buf[offset],&tag42Arr[1],tag42Arr[0]);
ALOGD("ALA_Check_KeyIdentifier : TAG 42 verified");
if(status == STATUS_OK)
{
ALOGD("ALA_Check_KeyIdentifier : Loader service root entity "
"ID is matched");
offset = offset+tag42Len;
*offset1 = offset;
}
}
}
return status;
}
/*******************************************************************************
**
** Function: Check_CertHoldID_Tag
**
** Description: Check certificate holder ID tag presence in script.
**
** Returns: Success if Tag found
**
*******************************************************************************/
tJBL_STATUS Check_CertHoldID_Tag(UINT8 *read_buf, UINT16 *offset1)
{
tJBL_STATUS status = STATUS_FAILED;
UINT16 offset = *offset1;
if((read_buf[offset]<<8|read_buf[offset+1]) == TAG_CERTFHOLD_ID)
{
UINT8 certfHoldIDLen = 0;
ALOGD("TAGID: TAG_CERTFHOLD_ID");
certfHoldIDLen = read_buf[offset+2];
offset = offset+certfHoldIDLen+3;
if(read_buf[offset] == TAG_KEY_USAGE)
{
UINT8 keyusgLen = 0;
ALOGD("TAGID: TAG_KEY_USAGE");
keyusgLen = read_buf[offset+1];
offset = offset+keyusgLen+2;
*offset1 = offset;
status = STATUS_OK;
}
}
return status;
}
/*******************************************************************************
**
** Function: Check_Date_Tag
**
** Description: Check date tags presence in script.
**
** Returns: Success if Tag found
**
*******************************************************************************/
tJBL_STATUS Check_Date_Tag(UINT8 *read_buf, UINT16 *offset1)
{
tJBL_STATUS status = STATUS_OK;
UINT16 offset = *offset1;
if((read_buf[offset]<<8|read_buf[offset+1]) == TAG_EFF_DATE)
{
UINT8 effDateLen = read_buf[offset+2];
offset = offset+3+effDateLen;
ALOGD("TAGID: TAG_EFF_DATE");
if((read_buf[offset]<<8|read_buf[offset+1]) == TAG_EXP_DATE)
{
UINT8 effExpLen = read_buf[offset+2];
offset = offset+3+effExpLen;
ALOGD("TAGID: TAG_EXP_DATE");
status = STATUS_OK;
}else if(read_buf[offset] == TAG_LSRE_SIGNID)
{
status = STATUS_OK;
}
}
else if((read_buf[offset]<<8|read_buf[offset+1]) == TAG_EXP_DATE)
{
UINT8 effExpLen = read_buf[offset+2];
offset = offset+3+effExpLen;
ALOGD("TAGID: TAG_EXP_DATE");
status = STATUS_OK;
}else if(read_buf[offset] == TAG_LSRE_SIGNID)
{
status = STATUS_OK;
}
else
{
/*STATUS_FAILED*/
}
*offset1 = offset;
return status;
}
/*******************************************************************************
**
** Function: Check_45_Tag
**
** Description: Check 45 tags presence in script and compare the value
** with select response tag 45 value
**
** Returns: Success if Tag found
**
*******************************************************************************/
tJBL_STATUS Check_45_Tag(UINT8 *read_buf, UINT16 *offset1, UINT8 *tag45Len)
{
tJBL_STATUS status = STATUS_FAILED;
UINT16 offset = *offset1;
if(read_buf[offset] == TAG_LSRE_SIGNID)
{
*tag45Len = read_buf[offset+1];
offset = offset+2;
if(tag45Arr[0] == *tag45Len)
{
status = memcmp(&read_buf[offset],&tag45Arr[1],tag45Arr[0]);
if(status == STATUS_OK)
{
ALOGD("ALA_Check_KeyIdentifier : TAG 45 verified");
*offset1 = offset;
}
}
}
return status;
}
/*******************************************************************************
**
** Function: Certificate_Verification
**
** Description: Perform the certificate verification by forwarding it to
** LS applet.
**
** Returns: Success if certificate is verified
**
*******************************************************************************/
tJBL_STATUS Certificate_Verification(Ala_ImageInfo_t *Os_info,
Ala_TranscieveInfo_t *pTranscv_Info, UINT8 *read_buf, UINT16 *offset1,
UINT8 *tag45Len)
{
tJBL_STATUS status = STATUS_FAILED;
UINT16 offset = *offset1;
INT32 wCertfLen = (read_buf[2]<<8|read_buf[3]);
tJBL_STATUS certf_found = STATUS_FAILED;
static const char fn[] = "Certificate_Verification";
UINT8 tag_len_byte = Numof_lengthbytes(&read_buf[2], &wCertfLen);
pTranscv_Info->sSendData[0] = 0x80;
pTranscv_Info->sSendData[1] = 0xA0;
pTranscv_Info->sSendData[2] = 0x01;
pTranscv_Info->sSendData[3] = 0x00;
/*If the certificate is less than 255 bytes*/
if(wCertfLen <= 251)
{
UINT8 tag7f49Off = 0;
UINT8 u7f49Len = 0;
UINT8 tag5f37Len = 0;
ALOGD("Certificate is greater than 255");
offset = offset+*tag45Len;
ALOGD("%s: Before TAG_CCM_PERMISSION = %x",fn, read_buf[offset]);
if(read_buf[offset] == TAG_CCM_PERMISSION)
{
INT32 tag53Len = 0;
UINT8 len_byte = 0;
offset =offset+1;
len_byte = Numof_lengthbytes(&read_buf[offset], &tag53Len);
offset = offset+tag53Len+len_byte;
ALOGD("%s: Verified TAG TAG_CCM_PERMISSION = 0x53",fn);
if((UINT16)(read_buf[offset]<<8|read_buf[offset+1]) == TAG_SIG_RNS_COMP)
{
tag7f49Off = offset;
u7f49Len = read_buf[offset+2];
offset = offset+3+u7f49Len;
if(u7f49Len != 64)
{
return STATUS_FAILED;
}
if((UINT16)(read_buf[offset]<<8|read_buf[offset+1]) == 0x7f49)
{
tag5f37Len = read_buf[offset+2];
if(read_buf[offset+3] != 0x86 || (read_buf[offset+4] != 65))
{
return STATUS_FAILED;
}
}
else
{
return STATUS_FAILED;
}
}
else
{
return STATUS_FAILED;
}
}
else
{
return STATUS_FAILED;
}
pTranscv_Info->sSendData[4] = wCertfLen+2+tag_len_byte;
pTranscv_Info->sSendlength = wCertfLen+7+tag_len_byte;
memcpy(&(pTranscv_Info->sSendData[5]), &read_buf[0], wCertfLen+2+tag_len_byte);
ALOGD("%s: start transceive for length %ld", fn, pTranscv_Info->
sSendlength);
status = ALA_SendtoAla(Os_info, status, pTranscv_Info,LS_Cert);
if(status != STATUS_OK)
{
return status;
}
else
{
certf_found = STATUS_OK;
ALOGD("Certificate is verified");
return status;
}
}
/*If the certificate is more than 255 bytes*/
else
{
UINT8 tag7f49Off = 0;
UINT8 u7f49Len = 0;
UINT8 tag5f37Len = 0;
ALOGD("Certificate is greater than 255");
offset = offset+*tag45Len;
ALOGD("%s: Before TAG_CCM_PERMISSION = %x",fn, read_buf[offset]);
if(read_buf[offset] == TAG_CCM_PERMISSION)
{
INT32 tag53Len = 0;
UINT8 len_byte = 0;
offset =offset+1;
len_byte = Numof_lengthbytes(&read_buf[offset], &tag53Len);
offset = offset+tag53Len+len_byte;
ALOGD("%s: Verified TAG TAG_CCM_PERMISSION = 0x53",fn);
if((UINT16)(read_buf[offset]<<8|read_buf[offset+1]) == TAG_SIG_RNS_COMP)
{
tag7f49Off = offset;
u7f49Len = read_buf[offset+2];
offset = offset+3+u7f49Len;
if(u7f49Len != 64)
{
return STATUS_FAILED;
}
if((UINT16)(read_buf[offset]<<8|read_buf[offset+1]) == 0x7f49)
{
tag5f37Len = read_buf[offset+2];
if(read_buf[offset+3] != 0x86 || (read_buf[offset+4] != 65))
{
return STATUS_FAILED;
}
}
else
{
return STATUS_FAILED;
}
pTranscv_Info->sSendData[4] = tag7f49Off;
memcpy(&(pTranscv_Info->sSendData[5]), &read_buf[0], tag7f49Off);
pTranscv_Info->sSendlength = tag7f49Off+5;
ALOGD("%s: start transceive for length %ld", fn,
pTranscv_Info->sSendlength);
status = ALA_SendtoAla(Os_info, status, pTranscv_Info,LS_Default);
if(status != STATUS_OK)
{
UINT8* RecvData = pTranscv_Info->sRecvData;
Write_Response_To_OutFile(Os_info, RecvData,
resp_len, LS_Cert);
return status;
}
pTranscv_Info->sSendData[2] = 0x00;
pTranscv_Info->sSendData[4] = u7f49Len+tag5f37Len+6;
memcpy(&(pTranscv_Info->sSendData[5]), &read_buf[tag7f49Off],
u7f49Len+tag5f37Len+6);
pTranscv_Info->sSendlength = u7f49Len+tag5f37Len+11;
ALOGD("%s: start transceive for length %ld", fn,
pTranscv_Info->sSendlength);
status = ALA_SendtoAla(Os_info, status, pTranscv_Info,LS_Cert);
if(status != STATUS_OK)
{
return status;
}
else
{
ALOGD("Certificate is verified");
certf_found = STATUS_OK;
return status;
}
}
else
{
return STATUS_FAILED;
}
}
else
{
return STATUS_FAILED;
}
}
return status;
}
/*******************************************************************************
**
** Function: Check_Complete_7F21_Tag
**
** Description: Traverses the 7F21 tag for verification of each sub tag with
** in the 7F21 tag.
**
** Returns: Success if all tags are verified
**
*******************************************************************************/
tJBL_STATUS Check_Complete_7F21_Tag(Ala_ImageInfo_t *Os_info,
Ala_TranscieveInfo_t *pTranscv_Info, UINT8 *read_buf, UINT16 *offset)
{
static const char fn[] = "Check_Complete_7F21_Tag";
UINT8 tag45Len = 0;
if(STATUS_OK == Check_Certificate_Tag(read_buf, offset))
{
if(STATUS_OK == Check_SerialNo_Tag(read_buf, offset))
{
if(STATUS_OK == Check_LSRootID_Tag(read_buf, offset))
{
if(STATUS_OK == Check_CertHoldID_Tag(read_buf, offset))
{
if(STATUS_OK == Check_Date_Tag(read_buf, offset))
{
UINT8 tag45Len = 0;
if(STATUS_OK == Check_45_Tag(read_buf, offset,
&tag45Len))
{
if(STATUS_OK == Certificate_Verification(
Os_info, pTranscv_Info, read_buf, offset,
&tag45Len))
{
return STATUS_OK;
}
}else{
ALOGE("%s: FAILED in Check_45_Tag", fn);}
}else{
ALOGE("%s: FAILED in Check_Date_Tag", fn);}
}else{
ALOGE("%s: FAILED in Check_CertHoldID_Tag", fn);}
}else{
ALOGE("%s: FAILED in Check_LSRootID_Tag", fn);}
}else{
ALOGE("%s: FAILED in Check_SerialNo_Tag", fn);}
}
else
{
ALOGE("%s: FAILED in Check_Certificate_Tag", fn);
}
return STATUS_FAILED;
}
BOOLEAN ALA_UpdateExeStatus(UINT16 status)
{
fLS_STATUS = fopen(LS_STATUS_PATH, "w+");
ALOGD("enter: ALA_UpdateExeStatus");
if(fLS_STATUS == NULL)
{
ALOGE("Error opening LS Status file for backup: %s",strerror(errno));
return FALSE;
}
if((fprintf(fLS_STATUS, "%04x",status)) != 4)
{
ALOGE("Error updating LS Status backup: %s",strerror(errno));
fclose(fLS_STATUS);
return FALSE;
}
ALOGD("exit: ALA_UpdateExeStatus");
fclose(fLS_STATUS);
return TRUE;
}
/*******************************************************************************
**
** Function: ALA_getAppletLsStatus
**
** Description: Interface to fetch Loader service Applet status to JNI, Services
**
** Returns: SUCCESS/FAILURE
**
*******************************************************************************/
tJBL_STATUS ALA_getAppletLsStatus(Ala_ImageInfo_t *Os_info, tJBL_STATUS status, Ala_TranscieveInfo_t *pTranscv_Info)
{
static const char fn[] = "ALA_getAppletLsStatus";
bool stat = false;
INT32 recvBufferActualSize = 0;
IChannel_t *mchannel = gpAla_Dwnld_Context->mchannel;
ALOGD("%s: enter", fn);
if(Os_info == NULL ||
pTranscv_Info == NULL)
{
ALOGD("%s: Invalid parameter", fn);
}
else
{
pTranscv_Info->sSendData[0] = STORE_DATA_CLA | Os_info->Channel_Info[0].channel_id;
pTranscv_Info->timeout = gTransceiveTimeout;
pTranscv_Info->sSendlength = (INT32)sizeof(GetData);
pTranscv_Info->sRecvlength = 1024;//(INT32)sizeof(INT32);
memcpy(&(pTranscv_Info->sSendData[1]), &GetData[1],
((sizeof(GetData))-1));
ALOGD("%s: Calling Secure Element Transceive with GET DATA apdu", fn);
stat = mchannel->transceive (pTranscv_Info->sSendData,
pTranscv_Info->sSendlength,
pTranscv_Info->sRecvData,
pTranscv_Info->sRecvlength,
recvBufferActualSize,
pTranscv_Info->timeout);
if((stat != TRUE) &&
(recvBufferActualSize == 0x00))
{
status = STATUS_FAILED;
ALOGE("%s: SE transceive failed status = 0x%X", fn, status);
}
else if((pTranscv_Info->sRecvData[recvBufferActualSize-2] == 0x90) &&
(pTranscv_Info->sRecvData[recvBufferActualSize-1] == 0x00))
{
ALOGE("STORE CMD is successful");
if((pTranscv_Info->sRecvData[0] == 0x46 )&& (pTranscv_Info->sRecvData[1] == 0x01 ))
{
if((pTranscv_Info->sRecvData[2] == 0x01))
{
lsGetStatusArr[0]=0x63;lsGetStatusArr[1]=0x40;
ALOGE("%s: Script execution status FAILED", fn);
}
else if((pTranscv_Info->sRecvData[2] == 0x00))
{
lsGetStatusArr[0]=0x90;lsGetStatusArr[1]=0x00;
ALOGE("%s: Script execution status SUCCESS", fn);
}
else
{
lsGetStatusArr[0]=0x90;lsGetStatusArr[1]=0x00;
ALOGE("%s: Script execution status UNKNOWN", fn);
}
}
else
{
lsGetStatusArr[0]=0x90;lsGetStatusArr[1]=0x00;
ALOGE("%s: Script execution status UNKNOWN", fn);
}
status = STATUS_SUCCESS;
}
else
{
status = STATUS_FAILED;
}
ALOGE("%s: exit; status=0x%x", fn, status);
}
return status;
}
/*******************************************************************************
**
** Function: Get_LsStatus
**
** Description: Interface to fetch Loader service client status to JNI, Services
**
** Returns: SUCCESS/FAILURE
**
*******************************************************************************/
tJBL_STATUS Get_LsStatus(UINT8 *pStatus)
{
tJBL_STATUS status = STATUS_FAILED;
UINT8 lsStatus[2] = {0x63,0x40};
UINT8 loopcnt = 0;
fLS_STATUS = fopen(LS_STATUS_PATH, "r");
if(fLS_STATUS == NULL)
{
ALOGE("Error opening LS Status file for backup: %s",strerror(errno));
return status;
}
for(loopcnt=0;loopcnt<2;loopcnt++)
{
if((FSCANF_BYTE(fLS_STATUS, "%2x", &lsStatus[loopcnt])) == 0)
{
ALOGE("Error updating LS Status backup: %s",strerror(errno));
fclose(fLS_STATUS);
return status;
}
}
ALOGD("enter: ALA_getLsStatus 0x%X 0x%X",lsStatus[0],lsStatus[1] );
memcpy(pStatus, lsStatus, 2);
fclose(fLS_STATUS);
return STATUS_OK;
}
#endif