--- /dev/null
+/******************************************************************************
+###############################################################################
+# Copyright (c) [2017-2020] [ICT/CAS] #
+# Licensed under the ORAN Software License v1.0 (License) #
+###############################################################################
+******************************************************************************/
+#include "vos_types.h"
+#include "vos_string.h"
+#include "vos_lib.h"
+#include "pdcpu.h"
+#include "pdcpuCore.h"
+#include "pdcpCommon.h"
+#include "cuupCommon.h"
+#include "cuModuleInterface.h"
+#include "pdcpComprohc.h"
+#include "cuupTest.h"
+#include "cuupUeIdTransf.h"
+#include "upcContext.h"
+
+extern PdcpuUeInfo_t *gPdcpuUeInfo[MAX_UE_NUM];
+ULONG gPdcpuModuleId;
+CuupUeIdxTable_t gPdcpuUeIdxTable;
+
+
+/*******************************************************************************
+* To
+* INPUT:
+* :
+* OUTPUT:
+* 0:success
+* -1:fail
+*******************************************************************************/
+INT32 pdcpuInit(ULONG userModuleId)
+{
+ /* get pdcpu moduleId */
+ gPdcpuModuleId = userModuleId;
+
+ /* init ueIdx table */
+ UINT8 i = 0;
+ for(i=0; i<MAX_UE_NUM; i++)
+ {
+ gPdcpuUeIdxTable.ueIdxInfo[i].isUsed = FALSE;
+ }
+
+ /* init ue info */
+ for(i=0; i<MAX_UE_NUM; i++)
+ {
+ gPdcpuUeInfo[i] = NULL;
+ }
+
+ return VOS_OK;
+}
+
+
+INT32 pdcpuFreeSecInfo(UINT16 ueIdx)
+{
+ PdcpuSecInfo_t *pDrbSecInfo = gPdcpuUeInfo[ueIdx]->secInfo;
+ if(NULL != pDrbSecInfo)
+ {
+ VOS_Free(pDrbSecInfo);
+ gPdcpuUeInfo[ueIdx]->secInfo = NULL;
+ }
+
+ return VOS_OK;
+}
+
+/*******************************************************************************
+* To deal with security indication
+* Security Result indicates whether the security policy indicated as "preferred"
+* in the Security Indication IE is performed or not.
+* INPUT:
+* ueE1apId : UE E1AP ID
+* pduSessionId : pdu session id
+* pSecInd : security indication
+* pSecResult : security result
+* OUTPUT:
+* 0:success
+* -1:fail
+*******************************************************************************/
+INT32 pdcpuDealSecurityInd(PdcpuSecInfo_t *pSec, PdcpuSecEnableInfo_t *pEnableInfo, SecuInd_t *pSecInd, PdcpuCfgResult_t *pResult)
+{
+ /* get security enable information global variable */
+ pdcpuNullCheck(pSec);
+ pdcpuNullCheck(pEnableInfo);
+ pdcpuNullCheck(pSecInd);
+
+ /* for integrity protection */
+ if(ACTIVE_INT_STATE == pSec->intActiveFlag)
+ {
+ /* integrity protection is active for the UE, apply the indication */
+ if(IP_REQUIRED == pSecInd->IPIndication)
+ {
+ pEnableInfo->integrityEnableFlag = TRUE;
+ pEnableInfo->maxIPDataRate = pSecInd->maxIPdataRate;
+ pResult->secResPresent = FALSE;
+
+ }else if(IP_PREFERRED == pSecInd->IPIndication)
+ {
+ pEnableInfo->integrityEnableFlag = TRUE;
+ pEnableInfo->maxIPDataRate = pSecInd->maxIPdataRate;
+ pResult->secResPresent = TRUE;
+ pResult->secuResult.integrityProtectionResult= IP_RESULT_PERFORMED;
+
+ }else
+ {
+ pEnableInfo->integrityEnableFlag = FALSE;
+ pResult->secResPresent = FALSE;
+
+ }
+
+ }else
+ {
+ /* integrity protection is inactive for the UE */
+ pEnableInfo->integrityEnableFlag = FALSE;
+ if(IP_PREFERRED == pSecInd->IPIndication)
+ {
+ pResult->secResPresent = TRUE;
+ pResult->secuResult.integrityProtectionResult= IP_RESULT_NOT_PERFORMED;
+ }
+ }
+
+ /* for ciphering */
+ if(ACTIVE_ENC_STATE == pSec->encActiveFlag)
+ {
+ /* ciphering is active for the UE, apply the indication */
+ if(CP_REQUIRED == pSecInd->CPIndication)
+ {
+ pEnableInfo->cipherEnableFlag = TRUE;
+ pResult->secResPresent = FALSE;
+
+ }else if(CP_PREFERRED == pSecInd->CPIndication)
+ {
+ pEnableInfo->cipherEnableFlag = TRUE;
+ pResult->secResPresent = TRUE;
+ pResult->secuResult.confidentialityProtectionResult = CP_RESULT_PERFORMED;
+
+ }else
+ {
+ pEnableInfo->cipherEnableFlag = FALSE;
+ pResult->secResPresent = FALSE;
+
+ }
+
+ }else
+ {
+ /* ciphering is inactive for the UE */
+ pEnableInfo->cipherEnableFlag = FALSE;
+ if(CP_PREFERRED == pSecInd->CPIndication)
+ {
+ pResult->secResPresent = TRUE;
+ pResult->secuResult.confidentialityProtectionResult= CP_RESULT_NOT_PERFORMED;
+ }
+ }
+
+ return VOS_OK;
+}
+
+INT32 pdcpuRetFailResult(UpcCfgType_e cfgType, upcTempSessInfo_t *pCfgInfo, PdcpuCfgResult_t *pResult)
+{
+ pdcpuLog(LOG_ERR,"[PDCPU] pdu session config failed\n");
+
+ UINT8 i = 0;
+ if(PDU_SESSION_ADD == cfgType)
+ {
+ /* drb to setup list */
+ for(i=0; i<pCfgInfo->drbSetupNum; i++)
+ {
+ pResult->drbSetupFailedArray[i].drbId = pCfgInfo->pTempDrbSetupList[i].drbId;
+ pResult->drbSetupFailedArray[i].cause = RNL_UNSPECIFIED;
+ }
+ pResult->drbSetupFailNum = pCfgInfo->drbSetupNum;
+ pResult->pduSessionCause = RNL_UNSPECIFIED;
+
+ }
+
+
+ return VOS_ERROR;
+}
+
+/*******************************************************************************
+* To deal with PDU session to setup config
+* INPUT:
+* ueE1apId : UE E1AP ID
+* pPduSessionCfg : PDU session to setup config
+* pResult : PDU session to setup result
+* OUTPUT:
+* none
+*******************************************************************************/
+INT32 pdcpuSessionAddProc(UINT64 ueE1apId, VOID *pCfgInfo, PdcpuCfgResult_t *pResult)
+{
+ upcTempSessInfo_t *pSetupInfo = (upcTempSessInfo_t *)pCfgInfo;
+ upcTempDrbInfo_t *pDrbTemp = NULL;
+ PdcpuSecInfo_t *pSec = NULL;
+ PdcpuSecEnableInfo_t *pEnableInfo = NULL;
+
+ UINT16 pduSessionId = pSetupInfo->pduSessId;
+ pResult->pduSessionId = pduSessionId;
+
+ /* get ueIdx */
+ UINT16 ueIdx;
+ if(VOS_ERROR == cuupAddUeE1apid(ueE1apId, &ueIdx, &gPdcpuUeIdxTable))
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] add ueE1apId failed\n");
+ return pdcpuRetFailResult(PDU_SESSION_ADD,pCfgInfo,pResult);
+ }
+
+ /* check ue and security context block */
+ if((NULL == gPdcpuUeInfo[ueIdx]) || (NULL == gPdcpuUeInfo[ueIdx]->secInfo))
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] ue and security context block not exist\n");
+ return pdcpuRetFailResult(PDU_SESSION_ADD,pCfgInfo,pResult);
+ }
+ pSec = gPdcpuUeInfo[ueIdx]->secInfo;
+
+ /* alloc pdu session information */
+ pEnableInfo = gPdcpuUeInfo[ueIdx]->secEnableInfo[pduSessionId];
+ if(NULL == pEnableInfo)
+ {
+ pEnableInfo = VOS_Malloc(sizeof(PdcpuSecEnableInfo_t), gPdcpuModuleId);
+ if(NULL == pEnableInfo)
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] vos_malloc failed\n");
+ return pdcpuRetFailResult(PDU_SESSION_ADD,pCfgInfo,pResult);
+ }
+ VOS_MemZero(pEnableInfo, sizeof(PdcpuSecEnableInfo_t));
+ gPdcpuUeInfo[ueIdx]->secEnableInfo[pduSessionId] = pEnableInfo;
+ }
+ pEnableInfo->pduSessionId = pduSessionId;
+
+ /* deal with security indication */
+ if(VOS_ERROR == pdcpuDealSecurityInd(pSec, pEnableInfo, &pSetupInfo->secuIndi, pResult))
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] deal security indication failed\n");
+ return pdcpuRetFailResult(PDU_SESSION_ADD,pCfgInfo,pResult);
+ }
+
+ /* create pdcp entity */
+ UINT8 i = 0;
+ for(i = 0; i < pSetupInfo->drbSetupNum; i++)
+ {
+ pDrbTemp = &pSetupInfo->pTempDrbSetupList[i];
+
+ if((NULL == pDrbTemp) || (FALSE == pDrbTemp->drbSetupAllowed))
+ {
+ continue;
+ }
+
+ if(VOS_OK == pdcpuCreateEntity(ueE1apId, ueIdx, pduSessionId, pDrbTemp))
+ {
+ pResult->drbSetupSuccessArray[pResult->drbSetupSuccessNum] = pDrbTemp->drbId;
+ pResult->drbSetupSuccessNum += 1;
+ }else
+ {
+ pResult->drbSetupFailedArray[pResult->drbSetupFailNum].drbId = pDrbTemp->drbId;
+ pResult->drbSetupFailedArray[pResult->drbSetupFailNum].cause = RNL_PDCP_CONFIG_NOT_SUPPORT;
+ pResult->drbSetupFailNum += 1;
+
+ }
+ }
+
+ /* return */
+ if(0 != pResult->drbSetupSuccessNum)
+ {
+ return VOS_OK;
+ }else
+ {
+ pResult->pduSessionCause = RNL_UNSPECIFIED;
+ pdcpuLog(LOG_ERR,"[PDCPU] all drbs setup failed\n");
+ return VOS_ERROR;
+ }
+}
+
+/*******************************************************************************
+ * To manage pdcp-u entity
+ * INPUT:
+ * ueE1apId : UE E1AP ID
+ * pPduSessionCfg : PDU Session Resource to setup item
+ * cfgType : configuration type
+ * pResult : result which will return to upc
+ * OUTPUT:
+ * result: PDCP config result
+ *******************************************************************************/
+INT32 pdcpuConfig(UINT64 ueE1apId, VOID *pCfgInfo, UpcCfgType_e cfgType, PdcpuCfgResult_t *pResult)
+{
+ switch(cfgType)
+ {
+ case PDU_SESSION_ADD:
+ {
+ pdcpuNullCheck(pCfgInfo);
+ pdcpuNullCheck(pResult);
+ VOS_MemZero(pResult, sizeof(PdcpuCfgResult_t));
+ pResult->cfgType = cfgType;
+ return pdcpuSessionAddProc(ueE1apId, pCfgInfo, pResult);
+ }
+ default:
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] cfgType error\n");
+ return VOS_ERROR;
+ }
+ }
+
+}
+
+
+/*******************************************************************************
+ * To get ue security information pointer
+ * INPUT:
+ * ueIdx: UE index
+ * OUTPUT:
+ * pDrbSecInfo: ue security information pointer
+ *******************************************************************************/
+PdcpuSecInfo_t *pdcpuAllocUeSecInfo(UINT16 ueIdx)
+{
+ PdcpuSecInfo_t *pSecInfo = NULL;
+ PdcpuUeInfo_t *pPdcpUeInfo = NULL;
+
+ //check ue
+ if(NULL == gPdcpuUeInfo[ueIdx])
+ {
+ pPdcpUeInfo = VOS_Malloc(sizeof(PdcpuUeInfo_t), gPdcpuModuleId);
+ pdcpuNullCheckRp(pPdcpUeInfo);
+ VOS_MemZero(pPdcpUeInfo, sizeof(PdcpuUeInfo_t));
+ gPdcpuUeInfo[ueIdx] = pPdcpUeInfo;
+ }else
+ {
+ pPdcpUeInfo = gPdcpuUeInfo[ueIdx];
+ }
+ //check secInfo
+ if(NULL == pPdcpUeInfo->secInfo)
+ {
+ pSecInfo = VOS_Malloc(sizeof(PdcpuSecInfo_t), gPdcpuModuleId);
+ pdcpuNullCheckRp(pSecInfo);
+ VOS_MemZero(pSecInfo, sizeof(PdcpuSecInfo_t));
+ pPdcpUeInfo->secInfo = pSecInfo;
+ }else
+ {
+ pSecInfo = pPdcpUeInfo->secInfo;
+ }
+
+ VOS_MemZero(pSecInfo, sizeof(PdcpuSecInfo_t));
+
+ return pSecInfo;
+}
+
+
+/*******************************************************************************
+ * To set ue security parameters. When receiving security information,
+ * pdcp-u shall save AS keys, AS algorithm and active integrity and ciphering.
+ * INPUT:
+ * ueE1apId: UE E1AP ID
+ * secInfo: security information
+ * OUTPUT:
+ * 0: success
+ * -1:failed
+ *******************************************************************************/
+INT32 pdcpuSetSecParam(UINT64 ueE1apId, SecuInfo_t *secInfo)
+{
+ pdcpuNullCheck(secInfo);
+
+ UINT16 ueIdx;
+ if(VOS_ERROR == cuupAddUeE1apid(ueE1apId, &ueIdx, &gPdcpuUeIdxTable))
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] add ueE1apId failed\n");
+ return VOS_ERROR;
+ }
+
+ /* find ue security struct */
+ PdcpuSecInfo_t *pDrbSecInfo = pdcpuAllocUeSecInfo(ueIdx);
+ pdcpuNullCheck(pDrbSecInfo);
+
+ /* activate integrity */
+ if(secInfo->secuAlgorithm.bitMask & SECURITY_ALGORITHM_INTERGRITY_PROTECTION_ALGORITHM)
+ {
+ UINT8 intAlgorithm = secInfo->secuAlgorithm.integrityProtectionAlgorithm;
+ UINT8 *pIntKey = secInfo->upSecukey.integrityProtectionKey.buffer;
+ UINT8 intKeyLen = secInfo->upSecukey.integrityProtectionKey.size; /* 128 bits */
+
+ if(intKeyLen < AS_KEY_LEN)
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] integrity parameter is wrong!\n");
+ pdcpuFreeSecInfo(ueIdx);
+ return VOS_ERROR;
+ }
+
+ pDrbSecInfo->intActiveFlag = ACTIVE_INT_STATE; /* 0-inactive, 1-active */
+ if(intAlgorithm == NIA0 || intAlgorithm == NIA1 || intAlgorithm == NIA2)
+ {
+ pDrbSecInfo->intAlgorithm = intAlgorithm;
+ VOS_MemCpy(pDrbSecInfo->kUpInt, pIntKey, AS_KEY_LEN); /* 128 bits */
+ }else
+ {
+ pDrbSecInfo->intActiveFlag = INACTIVE_INT_STATE;
+ pdcpuLog(LOG_ERR,"[PDCPU] integrity algorithm is %d, not supported!\n",intAlgorithm);
+ pdcpuFreeSecInfo(ueIdx);
+ return VOS_ERROR;
+ }
+ }else
+ {
+ pDrbSecInfo->intActiveFlag = INACTIVE_INT_STATE;
+ pdcpuLog(LOG_INFO,"[PDCPU] integrity is not config\n");
+ }
+
+ /* activate encryption */
+ UINT8 encAlgorithm = secInfo->secuAlgorithm.cipheringAlgorithm;
+ UINT8 *pEncKey = secInfo->upSecukey.encryptionKey.buffer;
+ UINT8 encKeyLen = secInfo->upSecukey.encryptionKey.size; /* 128 bits */
+
+ if(encKeyLen < AS_KEY_LEN)
+ {
+ pdcpuLog(LOG_ERR,"[PDCPU] encryption parameter is wrong!\n");
+ pdcpuFreeSecInfo(ueIdx);
+ return VOS_ERROR;
+ }
+
+ pDrbSecInfo->encActiveFlag = ACTIVE_ENC_STATE; /* 0-inactive, 1-active */
+ if(encAlgorithm == NEA0 || encAlgorithm == NEA1 || encAlgorithm == NEA2)
+ {
+ pDrbSecInfo->encAlgorithm = encAlgorithm;
+ VOS_MemCpy(pDrbSecInfo->kUpEnc, pEncKey, AS_KEY_LEN); /* 128 bits */
+ }else
+ {
+ pDrbSecInfo->encActiveFlag = INACTIVE_ENC_STATE;
+ pdcpuLog(LOG_ERR,"[PDCPU] encryption algorithm:%d, is not supported!\n", encAlgorithm);
+ pdcpuFreeSecInfo(ueIdx);
+ return VOS_ERROR;
+ }
+
+ pDrbSecInfo->ueE1apId = ueE1apId;
+ pDrbSecInfo->ueIdx = ueIdx;
+ pDrbSecInfo->nhInd = FALSE;
+
+ return VOS_OK;
+}
+
Code Review / scp / ocu / 5gnr.git / blobdiff