/* ****************************************************************************** * INTERPEAK SOURCE FILE * * Document no: @(#) $Name: VXWORKS_ITER40_2019102207 $ $RCSfile: sec_dcl_ipfreescale.c,v $ $Revision: 1.7.12.1 $ * $Source: /home/interpeak/CVSRoot/ipfreescale/sec4/sec_dcl_ipfreescale.c,v $ * $Author: jsheng $ * $State: Exp $ $Locker: $ * * INTERPEAK_COPYRIGHT_STRING ****************************************************************************** */ /* * Ipfreescale extensions to the Freescale Netcomm SEC/DCL library. */ #include #include #include #include #include #include #include void PrintDecodeDescriptor(uint32_t* buffer, char* tag); void PrintDecodePDB(uint32_t* buf_p, uint32_t pdbType); extern t_Handle h_Sec4; #define __ERR_MODULE__ MODULE_SEC t_Handle SEC_DCL_InitJobDesc(t_Handle h_SecDcl, t_JobDescParam *param) { t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl; t_Handle* h_Desc; uint32_t length; uint32_t buffer[MAX_DESC_LENGTH]; /* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */ SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE); SANITY_CHECK_EXIT(param,E_NULL_POINTER); switch(param->jobTypeId) { case e_DCL_JOB_RANDNUM: length = InitRandNumJobDesc(buffer, p_SecDcl->ptrSize, param->outDataBytes, param->outData); break; case e_DCL_JOB_MD5_DIGEST: length = InitMd5DigestJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->outDataBytes, param->inData, param->outData); break; case e_DCL_JOB_SHA1_DIGEST: length = InitSha1DigestJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->outDataBytes, param->inData, param->outData); break; case e_DCL_JOB_MD5_HMAC: length = InitMd5HmacJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_SHA1_HMAC: length = InitSha1HmacJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_DES_CBC_ENCRYPT: length = InitDesCbcEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->inCtxData, param->outData); break; case e_DCL_JOB_DES_CBC_DECRYPT: length = InitDesCbcDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->inCtxData, param->outData); break; case e_DCL_JOB_DES_ECB_ENCRYPT: length = InitDesEcbEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_DES_ECB_DECRYPT: length = InitDesEcbDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_TDES_CBC_ENCRYPT: length = InitTdesCbcEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->inCtxData, param->outData); break; case e_DCL_JOB_TDES_CBC_DECRYPT: length = InitTdesCbcDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->inCtxData, param->outData); break; case e_DCL_JOB_TDES_ECB_ENCRYPT: length = InitTdesEcbEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_TDES_ECB_DECRYPT: length = InitTdesEcbDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_AES_CBC_ENCRYPT: length = InitAesCbcEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outCtxDataBytes, param->inData, param->keyData, param->inCtxData, param->outData, param->outCtxData); break; case e_DCL_JOB_AES_CBC_DECRYPT: length = InitAesCbcDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outCtxDataBytes, param->inData, param->keyData, param->inCtxData, param->outData, param->outCtxData); break; case e_DCL_JOB_AES_ECB_ENCRYPT: length = InitAesEcbEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_AES_ECB_DECRYPT: length = InitAesEcbDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->outDataBytes, param->inData, param->keyData, param->outData); break; case e_DCL_JOB_RC4_ENCRYPT: length = InitRc4EncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outCtxDataBytes, param->inData, param->keyData, param->inCtxData, param->outData, param->outCtxData); break; case e_DCL_JOB_MODEXP: length = InitModExpJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->modDataBytes, param->outDataBytes, param->inData, param->keyData, param->modData, param->outData); break; case e_DCL_JOB_CCMP_ENCRYPT: length = InitCcmpEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->AADDataBytes, param->MICDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->AADData, param->inMICData, param->inCtxData, param->outData); break; case e_DCL_JOB_CHKSUM_CRC: length = InitCRCJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->inData, param->outDataBytes, param->outData, param->inCtxDataBytes, param->inCtxData, param->keyData, param->options); break; case e_DCL_JOB_MOVE_DATA: length = InitMoveDataJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->inData, param->outData, param->options); break; case e_DCL_JOB_AESCCM_ENCRYPT: length = InitAesCcmEncryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->AADDataBytes, param->MICDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->AADData, param->inMICData, param->outMICData, param->inCtxData, param->outData, param->options); break; case e_DCL_JOB_AESCCM_DECRYPT: length = InitAesCcmDecryptJobDesc(buffer, p_SecDcl->ptrSize, param->inDataBytes, param->keyDataBytes, param->AADDataBytes, param->MICDataBytes, param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData, param->AADData, param->inMICData, param->outMICData, param->inCtxData, param->outData, param->options); break; default: /* Not supported jobId */ return NULL; } h_Desc = CreateDescObject(p_SecDcl,length,buffer); return h_Desc; } t_Handle SEC_DCL_InitIpsecJobDesc(t_Handle h_SecDcl, t_IpsecJobDescParam *param) { t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl; uint32_t length; uint32_t buffer[MAX_DESC_LENGTH]; /* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */ SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE); SANITY_CHECK_EXIT(param,E_NULL_POINTER); length = InitIpsecJobDesc(buffer, p_SecDcl->ptrSize, param); return CreateDescObject(p_SecDcl,length,buffer); } #ifdef DBG #define PRINT_DATA_LIMIT 128 /* Limit print of data referenced by descriptors to this many bytes */ /* * Prints descriptor starting at buffer. * An optional tag (string) is prepended each decoded descriptor word. */ void PrintDecodeDescriptor(uint32_t* buffer, char* tag) { int i,j; uint32_t ctype, opType, opId, descLen, aai; int next_data_is_pointer=0; int next_data_is_immediate=0; int next_data_is_pdb=0; int next_data_is_sgt=0; int next_data_size=0; int startIndex=0; int pdbIndex=0; uint32_t pdbType=0; int ptrSize; uint32_t shr_desc_addr = NULL; char printBuf[(2 * PRINT_DATA_LIMIT) + 128]; int printBufIx=0; /* Pointers can be 1 or 2 words */ ptrSize = (int) SEC_GetPtrSize(h_Sec4) / sizeof(uint32_t); descLen = JOB_DESC_HDR_LENGTH_GET(buffer[0]); printf("\n"); for(i=0;i> 27; /* Command type */ switch (ctype) { case CMD_JOB_DESC_HDR: printf("CMD_JOB_DESC_HDR: "); printf("(DESC_LEN=%d)", descLen); startIndex = (buffer[i] >> 16) & 0x3f; /* Check if it uses a shared descriptor */ if((buffer[i] & JOB_DESC_HDR_SHR) == JOB_DESC_HDR_SHR) { if (buffer[i] & JOB_DESC_HDR_REO) printf("(REO)"); printf("(SHR_DESC_LEN=%d)", startIndex); next_data_is_pointer = ptrSize; next_data_size = startIndex * sizeof(uint32_t); /* Decode the shared descriptor that is pointed out in next word(s)*/ shr_desc_addr = (uint32_t *)XX_PhysToVirt((physAddress_t) (*(buffer + i + 2))); /* TODO use correct actual ptr length */ PrintDecodeDescriptor(shr_desc_addr, " shrDesc"); } else { /* This descriptor doesn't use shared descriptor */ printf("startIndex=%d ", startIndex); if(startIndex > 1) { next_data_is_pdb = startIndex-1; /* Remember pdbIndex to decode once we now how */ pdbIndex = i+1; } } break; case CMD_SHR_DESC_HDR: printf("CMD_SHR_DESC_HDR: "); startIndex = (buffer[i] >> 16) & 0x3f; printf("startIndex=%d ", startIndex); if(startIndex > 1) { next_data_is_pdb = startIndex-1; /* Remember pdbIndex to decode once we now how */ pdbIndex = i+1; } printf("desclen=%d", descLen); break; case CMD_SEQ_IN_PTR: printf("CMD_SEQ_IN_PTR:"); if (buffer[i] & SEQ_IN_PTR_RBS) printf("(RBS)"); if (buffer[i] & SEQ_IN_PTR_INL) printf("(INL)"); if (buffer[i] & SEQ_IN_PTR_SGT) printf("(SGT)"); if (buffer[i] & SEQ_IN_PTR_PRE) printf("(PRE)"); if (buffer[i] & SEQ_IN_PTR_EXT) printf("(EXT)"); if (buffer[i] & SEQ_IN_PTR_RTO) printf("(RTO)"); if (buffer[i] & SEQ_IN_PTR_JRD) printf("(JRD)"); if (!(buffer[i] & SEQ_IN_PTR_RTO) && !(buffer[i] & SEQ_IN_PTR_PRE)) { next_data_is_pointer = ptrSize; next_data_size = SEQ_IN_PTR_LENGTH(buffer[i]); } printf("(length = 0x%x)", SEQ_IN_PTR_LENGTH(buffer[i])); break; case CMD_SEQ_OUT_PTR: printf("CMD_SEQ_OUT_PTR:"); if (buffer[i] & SEQ_OUT_PTR_SGT) printf("(SGT)"); if (buffer[i] & SEQ_OUT_PTR_PRE) printf("(PRE)"); if (buffer[i] & SEQ_OUT_PTR_EXT) printf("(EXT)"); if (buffer[i] & SEQ_OUT_PTR_RTO) printf("(RTO)"); if (!(buffer[i] & SEQ_OUT_PTR_RTO)) { next_data_is_pointer = ptrSize; next_data_size = SEQ_OUT_PTR_LENGTH(buffer[i]); } printf("(length = 0x%x)", SEQ_OUT_PTR_LENGTH(buffer[i])); break; case CMD_KEY: printf("CMD_KEY: "); switch (buffer[i] & KEY_CLASS_DST_MASK) { case KEY_CLASS_1_DST_REGISTER: printf("(KEY_CLASS_1_DST_REGISTER)"); break; case KEY_CLASS_2_DST_REGISTER: printf("(KEY_CLASS_2_DST_REGISTER)"); break; case KEY_CLASS_1_DST_PKHA_E_MEM: printf("(KEY_CLASS_1_DST_PKHA_E_MEM)"); break; case KEY_CLASS_1_DST_AFHA_SBOX: printf("(KEY_CLASS_1_DST_AFHA_SBOX)"); break; case KEY_CLASS_1_DST_MDHA_SPLIT: printf("(KEY_CLASS_1_DST_MDHA_SPLIT)"); break; case KEY_CLASS_2_DST_MDHA_SPLIT: printf("(KEY_CLASS_2_DST_MDHA_SPLIT)"); break; default: printf("(undecoded destination)"); break; } /* Black key info */ switch(buffer[i] & KEY_ENC_EKT_TK_MASK) { case KEY_ENC_ON_EKT_AES_CCM_TK_ON: printf("(KEY_ENC_ON_EKT_AES_CCM_TK_ON)"); break; case KEY_ENC_ON_EKT_AES_ECB_TK_ON: printf("(KEY_ENC_ON_EKT_AES_ECB_TK_ON)"); break; case KEY_ENC_ON_EKT_AES_ECB_TK_OFF: printf("(KEY_ENC_ON_EKT_AES_ECB_TK_OFF)"); break; case KEY_ENC_ON_EKT_AES_CCM_TK_OFF: printf("(KEY_ENC_ON_EKT_AES_CCM_TK_OFF)"); break; case KEY_ENC_OFF_EKT_UNUSED_TK_UNUSED: printf("(KEY_ENC_OFF_EKT_UNUSED_TK_UNUSED)"); break; default: printf("(undecoded black key info)"); break; } if((buffer[i] & KEY_NWB) != 0) printf("(KEY_NWB)"); /* Immediate data? */ if (!(buffer[i] & KEY_IMM)) { next_data_is_pointer=ptrSize; next_data_size = KEY_LENGTH(buffer[i]); } else { printf("(IMM data)"); next_data_is_immediate = ((KEY_LENGTH(buffer[i])) / sizeof(uint32_t)) + (((KEY_LENGTH(buffer[i])) % sizeof(uint32_t))?1:0); next_data_size = next_data_is_immediate * sizeof(uint32_t); } break; case CMD_OPERATION: opType = buffer[i] & ALG_OP_TYPE_MASK; opId = buffer[i] & ALG_OP_ID_MASK; aai = buffer[i] & ALG_OP_AAI_MASK; printf("CMD_OPERATION: "); switch(opType) { case PKHA_OP_TYPE: switch (buffer[i] & PKHA_OP_MODE_MASK) { case PKHA_OP_MODE_MOD_EXP_IM_B: printf("(PKHA_OP_MODE_MOD_EXP_IM_B)"); break; case PKHA_OP_MODE_MOD_EXP_B: printf("(PKHA_OP_MODE_MOD_EXP_B)"); break; default: printf("Undecoded PKHA_OP_MODE)"); break; } break; case ALG_OP_TYPE_CLASS_1: switch(opId) { case ALG_OP_ID_RNG: printf("(ALG_OP_ID_RNG) "); break; case ALG_OP_ID_DES: printf("(ALG_OP_ID_DES) "); switch(aai) { case ALG_OP_AAI_DES_CBC: printf("(ALG_OP_AAI_DES_CBC)"); break; case ALG_OP_AAI_DES_ECB: printf("(ALG_OP_AAI_DES_ECB)"); break; default: printf("(Undecoded AAI)"); break; } break; case ALG_OP_ID_3DES: printf("(ALG_OP_ID_3DES) "); switch(aai) { case ALG_OP_AAI_DES_CBC: printf("(ALG_OP_AAI_DES_CBC)"); break; case ALG_OP_AAI_DES_ECB: printf("(ALG_OP_AAI_DES_ECB)"); break; default: printf("(Undecoded AAI)"); break; } break; case ALG_OP_ID_AES: printf("(ALG_OP_ID_AES) "); switch(aai) { case ALG_OP_AAI_AES_CBC: printf("(ALG_OP_AAI_AES_CBC)"); break; case ALG_OP_AAI_AES_ECB: printf("(ALG_OP_AAI_AES_ECB)"); break; case ALG_OP_AAI_AES_CCM: printf("(ALG_OP_AAI_AES_CCM)"); break; default: printf("(Undecoded AAI)"); break; } break; case ALG_OP_ID_ARC4: printf("(ALG_OP_ID_ARC4) "); break; default: printf("(undecoded ALG_OP_TYPE_CLASS_1)"); } /* Encrypt/decrypt */ switch (buffer[i] & ALG_OP_DIR_MASK) { case ALG_OP_DIR_ENC: printf("(ALG_OP_DIR_ENC)"); break; case ALG_OP_DIR_DEC: printf("(ALG_OP_DIR_DEC)"); break; } /* Algorithm State */ switch(buffer[i] & ALG_OP_AS_MASK) { case ALG_OP_AS_INIT: printf("(ALG_OP_AS_INIT)"); break; case ALG_OP_AS_UPDATE: printf("(ALG_OP_AS_UPDATE)"); break; case ALG_OP_AS_FINALIZE: printf("(ALG_OP_AS_FINALIZE)"); break; case ALG_OP_AS_INITFINAL: printf("(ALG_OP_AS_INITFINAL)"); break; default: break; } /* Check ICV */ if(buffer[i] & ALG_OP_ICV) printf("(ALG_OP_ICV)"); break; case ALG_OP_TYPE_CLASS_2: switch(opId) { case ALG_OP_ID_MD5: case ALG_OP_ID_SHA1: if(ctype == ALG_OP_ID_MD5) printf("(ALG_OP_ID_MD5)"); if(ctype == ALG_OP_ID_SHA1) printf("(ALG_OP_ID_SHA1)"); switch(aai) { case ALG_OP_AAI_MDS_SHA_HMAC: printf("(ALG_OP_AAI_MDS_SHA_HMAC)"); break; case ALG_OP_AAI_MDS_SHA_SMAC: printf("(ALG_OP_AAI_MDS_SHA_SMAC)"); break; case ALG_OP_AAI_MDS_SHA_HMAC_PRECOMP: printf("(ALG_OP_AAI_MDS_SHA_HMAC_PRECOMP)"); break; default: printf("(Undecoded AAI)"); break; } if(buffer[i] & ALG_OP_ICV) printf("(ALG_OP_ICV)"); break; case ALG_OP_ID_CRC: printf("(ALG_OP_ID_CRC) "); switch(aai) { case ALG_OP_AAI_CRC_IEEE_802: printf("(ALG_OP_AAI_CRC_IEEE_802) "); break; case ALG_OP_AAI_CRC_IETF_3385: printf("(ALG_OP_AAI_CRC_IETF_3385) "); break; case ALG_OP_AAI_CRC_CUST_POLY: printf("(ALG_OP_AAI_CRC_CUST_POLY) "); break; case ALG_OP_AAI_CRC_DIS_IEEE_802: printf("(ALG_OP_AAI_CRC_DIS_IEEE_802) "); break; case ALG_OP_AAI_CRC_DIS_IETF_3385: printf("(ALG_OP_AAI_CRC_DIS_IETF_3385) "); break; case ALG_OP_AAI_CRC_DIS_CUST_POLY: printf("(ALG_OP_AAI_CRC_DIS_CUST_POLY) "); break; case ALG_OP_AAI_CRC_DOS_IETF_3385: printf("(ALG_OP_AAI_CRC_DOS_IETF_3385) "); break; case ALG_OP_AAI_CRC_DOS_CUST_POLY: printf("(ALG_OP_AAI_CRC_DOS_CUST_POLY) "); break; case ALG_OP_AAI_CRC_DOS_IEEE_802: printf("(ALG_OP_AAI_CRC_DOS_IEEE_802) "); break; case ALG_OP_AAI_CRC_DOC_IEEE_802: printf("(ALG_OP_AAI_CRC_DOC_IEEE_802) "); break; case ALG_OP_AAI_CRC_DOC_IETF_3385: printf("(ALG_OP_AAI_CRC_DOC_IETF_3385) "); break; case ALG_OP_AAI_CRC_DOC_CUST_POLY: printf("(ALG_OP_AAI_CRC_DOC_CUST_POLY) "); break; case ALG_OP_AAI_CRC_IVZ_IEEE_802: printf("(ALG_OP_AAI_CRC_IVZ_IEEE_802) "); break; case ALG_OP_AAI_CRC_IVZ_IETF_3385: printf("(ALG_OP_AAI_CRC_IVZ_IETF_3385) "); break; case ALG_OP_AAI_CRC_IVZ_CUST_POLY: printf("(ALG_OP_AAI_CRC_IVZ_CUST_POLY) "); break; default: printf("(undecoded AAI) "); break; } break; default: printf("(undecoded ALG_OP_TYPE_CLASS_2)"); break; } break; default: /* Ok, not class1, class2 or pkha operation */ /* Check if protocol operation. (Is decoded a bit differently) */ switch(buffer[i] & PCL_OP_TYPE_ID_MASK) { case PCL_OP_TYPE_ENCAP_ID_IPSEC: case PCL_OP_TYPE_DECAP_ID_IPSEC: /* Do switch again for what isn't common between the two */ switch(buffer[i] & PCL_OP_TYPE_ID_MASK) { case PCL_OP_TYPE_ENCAP_ID_IPSEC: pdbType = PCL_OP_TYPE_ENCAP_ID_IPSEC; printf("(PCL_OP_TYPE_ENCAP_ID_IPSEC)"); break; case PCL_OP_TYPE_DECAP_ID_IPSEC: pdbType = PCL_OP_TYPE_DECAP_ID_IPSEC; printf("(PCL_OP_TYPE_DECAP_ID_IPSEC)"); break; default: break; } /* Common for both PCL_OP_TYPE_DECAP_ID_IPSEC and PCL_OP_TYPE_ENCAP_ID_IPSEC */ switch(buffer[i] & 0xff00) /* PCL_OP_INFO_MASK is for IPsec really [cryptoAlg,AuthAlg] */ { case PCL_OP_INFO_IPSEC_DES: printf("(PCL_OP_INFO_IPSEC_DES)"); break; case PCL_OP_INFO_IPSEC_3DES: printf("(PCL_OP_INFO_IPSEC_3DES)"); break; case PCL_OP_INFO_IPSEC_NULL_ENC: printf("(PCL_OP_INFO_IPSEC_NULL_ENC)"); break; case PCL_OP_INFO_IPSEC_AES_CBC: printf("(PCL_OP_INFO_IPSEC_AES_CBC)"); break; case PCL_OP_INFO_IPSEC_AES_CTR: printf("(PCL_OP_INFO_IPSEC_AES_CTR)"); break; default: printf("(Undecoded PCL_OP_INFO crypto alg)"); break; } switch(buffer[i] & 0xff) /* PCL_OP_INFO_MASK is for IPsec really [cryptoAlg,AuthAlg] */ { case PCL_OP_INFO_IPSEC_HMAC_MD5_96: printf("(PCL_OP_INFO_IPSEC_HMAC_MD5_96)"); break; case PCL_OP_INFO_IPSEC_HMAC_SHA1_96: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA1_96)"); break; case PCL_OP_INFO_IPSEC_AES_XCBC_MAC_96: printf("(PCL_OP_INFO_IPSEC_AES_XCBC_MAC_96)"); break; case PCL_OP_INFO_IPSEC_HMAC_MD5_128: printf("(PCL_OP_INFO_IPSEC_HMAC_MD5_128)"); break; case PCL_OP_INFO_IPSEC_HMAC_SHA1_160: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA1_160)"); break; case PCL_OP_INFO_IPSEC_AES_CMAC_96: printf("(PCL_OP_INFO_IPSEC_AES_CMAC_96)"); break; case PCL_OP_INFO_IPSEC_HMAC_SHA2_256_128: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA2_256_128)"); break; case PCL_OP_INFO_IPSEC_HMAC_SHA2_384_192: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA2_384_192)"); break; case PCL_OP_INFO_IPSEC_HMAC_SHA2_512_256: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA2_512_256)"); break; default: printf("(Undecoded PCL_OP_INFO auth alg)"); break; } break; default: printf("(Undecoded PCL_OP_TYPE)"); break; } } break; case CMD_MATH: printf("CMD_MATH: "); switch(buffer[i] & MATH_FUNC_MASK) { case MATH_FUNC_ADD: printf("(MATH_FUNC_ADD)"); break; case MATH_FUNC_ADD_W_CARRY: printf("(MATH_FUNC_ADD_W_CARRY)"); break; case MATH_FUNC_SUB: printf("(MATH_FUNC_SUB)"); break; case MATH_FUNC_SUB_W_BORROW: printf("(MATH_FUNC_SUB_W_BORROW)"); break; case MATH_FUNC_OR: printf("(MATH_FUNC_OR)"); break; case MATH_FUNC_AND: printf("(MATH_FUNC_AND)"); break; case MATH_FUNC_XOR: printf("(MATH_FUNC_XOR)"); break; case MATH_FUNC_SHIFT_L: printf("(MATH_FUNC_SHIFT_L)"); break; case MATH_FUNC_SHIFT_R: printf("(MATH_FUNC_SHIFT_R)"); break; case MATH_FUNC_SHLD: printf("(MATH_FUNC_SHLD)"); break; case MATH_FUNC_ZBYT: printf("(MATH_FUNC_ZBYT)"); break; } switch(buffer[i] & MATH_SRC0_MASK) { case MATH_SRC0_REG0: printf("(MATH_SRC0_REG0)"); break; case MATH_SRC0_REG1: printf("(MATH_SRC0_REG1)"); break; case MATH_SRC0_REG2: printf("(MATH_SRC0_REG2)"); break; case MATH_SRC0_REG3: printf("(MATH_SRC0_REG3)"); break; case MATH_SRC0_IMM: printf("(MATH_SRC0_IMM)"); next_data_is_immediate = 1; next_data_size = next_data_is_immediate * sizeof(uint32_t); break; case MATH_SRC0_SIL: printf("(MATH_SRC0_SIL)"); break; case MATH_SRC0_SOL: printf("(MATH_SRC0_SOL)"); break; case MATH_SRC0_VSIL: printf("(MATH_SRC0_VSIL)"); break; case MATH_SRC0_VSOL: printf("(MATH_SRC0_VSOL)"); break; case MATH_SRC0_ZERO: printf("(MATH_SRC0_ZERO)"); break; case MATH_SRC0_MASK: printf("(MATH_SRC0_MASK)"); break; } switch(buffer[i] & MATH_SRC1_MASK) { case MATH_SRC1_REG0: printf("(MATH_SRC1_REG0)"); break; case MATH_SRC1_REG1: printf("(MATH_SRC1_REG1)"); break; case MATH_SRC1_REG2: printf("(MATH_SRC1_REG2)"); break; case MATH_SRC1_REG3: printf("(MATH_SRC1_REG3)"); break; case MATH_SRC1_IMM: printf("(MATH_SRC1_IMM)"); next_data_is_immediate = 1; next_data_size = next_data_is_immediate * sizeof(uint32_t); break; case MATH_SRC1_IFIFO: printf("(MATH_SRC1_IFIFO)"); break; case MATH_SRC1_OFIFO: printf("(MATH_SRC1_OFIFO)"); break; case MATH_SRC1_ONE: printf("(MATH_SRC1_ONE)"); break; case MATH_SRC1_JOB: printf("(MATH_SRC1_JOB)"); break; case MATH_SRC1_ZERO: printf("(MATH_SRC1_ZERO)"); break; } switch(buffer[i] & MATH_DST_MASK) { case MATH_DST_REG0: printf("(MATH_DST_REG0)"); break; case MATH_DST_REG1: printf("(MATH_DST_REG1)"); break; case MATH_DST_REG2: printf("(MATH_DST_REG2)"); break; case MATH_DST_REG3: printf("(MATH_DST_REG3)"); break; case MATH_DST_IMM: printf("(MATH_DST_IMM)"); break; case MATH_DST_SIL: printf("(MATH_DST_SIL)"); break; case MATH_DST_SOL: printf("(MATH_DST_SOL)"); break; case MATH_DST_VSIL: printf("(MATH_DST_VSIL)"); break; case MATH_DST_VSOL: printf("(MATH_DST_VSOL)"); break; case MATH_DST_NONE: printf("(MATH_DST_NONE)"); break; } switch(buffer[i] & MATH_LEN_MASK) { case MATH_LEN_1_BYTE: printf("(MATH_LEN_1_BYTE)"); break; case MATH_LEN_2_BYTE: printf("(MATH_LEN_2_BYTE)"); break; case MATH_LEN_4_BYTE: printf("(MATH_LEN_4_BYTE)"); break; case MATH_LEN_8_BYTE: printf("(MATH_LEN_8_BYTE)"); break; } if(buffer[i] & MATH_IFB(1)) printf("(MATH_IFB)"); if(buffer[i] & MATH_NFU) printf("(MATH_NFU)"); if(buffer[i] & MATH_STL) printf("(MATH_STL)"); break; case CMD_MOVE: #define MOVE_GET_OFFSET(n) (((n)&0xFF00) >> 8) printf("CMD_MOVE: "); if(buffer[i] & MOVE_WC) { printf("(MOVE_WC)"); } switch(buffer[i] & MOVE_AUX_SRC_DST_MASK) { case MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO: printf("(MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO)"); break; default: printf("(Undecoded src & dst)"); break; } printf("(offset = 0x%x)", MOVE_GET_OFFSET(buffer[i])); printf("(length = 0x%x)", MOVE_LENGTH(buffer[i])); break; case CMD_FIFO_STORE + 1: printf("SEQ "); case CMD_FIFO_STORE: printf("CMD_FIFO_STORE: "); if (0 != (buffer[i] & FIFO_STORE_VLF)) printf("(SGF)"); if (0 != (buffer[i] & FIFO_STORE_CONT)) printf("(CONT)"); if (0 != (buffer[i] & FIFO_STORE_EXT)) printf("(EXT)"); switch(buffer[i] & FIFO_STORE_CLASS_TYPE_MASK) { case FIFO_STORE_CLASS_UNUSED_TYPE_MSG: printf("(FIFO_STORE_CLASS_UNUSED_TYPE_MSG)"); break; case FIFO_STORE_CLASS_UNUSED_TYPE_SKIP: printf("(FIFO_STORE_CLASS_UNUSED_TYPE_SKIP)"); break; case FIFO_STORE_CLASS_1_TYPE_PKHA_B: printf("(FIFO_STORE_CLASS_1_TYPE_PKHA_B)"); break; case FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_JKEK: printf("(FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_JKEK)"); break; case FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_TKEK: printf("(FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_TKEK)"); break; case FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_ECB_JKEK: printf("(FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_ECB_JKEK)"); break; case FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_JKEK: printf("(FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_JKEK)"); break; case FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_TKEK: printf("(FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_TKEK)"); break; case FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_JKEK: printf("(FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_JKEK)"); break; case FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_JKEK: printf("(FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_JKEK)"); break; case FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_TKEK: printf("(FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_TKEK)"); break; case FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_TKEK: printf("(FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_TKEK)"); break; default: printf("(undecoded Fifo Store src 0x%x) ", buffer[i] & FIFO_STORE_CLASS_TYPE_MASK); break; } if(ctype == CMD_FIFO_STORE) { if (buffer[i] & FIFO_STORE_SGT) { printf("(FIFO_STORE_SGT)"); next_data_is_sgt = ptrSize; /* Next word contains pointer to Scatter gather table */ } else { next_data_is_pointer=ptrSize; next_data_size=FIFO_STORE_LENGTH(buffer[i]); } } else { /* SEQ CMD_FIFO_STORE */ printf("(Output sequence data)"); if (buffer[i] & FIFO_STORE_VLF) printf("(FIFO_STORE_VLF)"); } printf("(length = 0x%x)", FIFO_STORE_LENGTH(buffer[i])); break; case CMD_FIFO_LOAD + 1: /* Sequence FIFO LOAD*/ printf("SEQ "); case CMD_FIFO_LOAD: printf("CMD_FIFO_LOAD: "); switch(buffer[i] & FIFO_LOAD_CLASS_TYPE_MASK) { case FIFO_LOAD_CLASS_SKIP_TYPE_UNUSED: printf("(FIFO_LOAD_CLASS_SKIP_TYPE_UNUSED)"); break; case FIFO_LOAD_CLASS_1_TYPE_AAD_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_AAD_F1)"); break; case FIFO_LOAD_CLASS_1_TYPE_MSG: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG)"); break; case FIFO_LOAD_CLASS_1_TYPE_MSG_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG_F1)"); break; case FIFO_LOAD_CLASS_1_TYPE_MSG_L1: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG_L1)"); break; case FIFO_LOAD_CLASS_1_TYPE_MSG_L1_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG_L1_F1)"); break; case FIFO_LOAD_CLASS_1_TYPE_IV: printf("(FIFO_LOAD_CLASS_1_TYPE_IV)"); break; case FIFO_LOAD_CLASS_1_TYPE_IV_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_IV_F1)"); break; case FIFO_LOAD_CLASS_1_TYPE_IV_L1: printf("(FIFO_LOAD_CLASS_1_TYPE_IV_L1)"); break; case FIFO_LOAD_CLASS_1_TYPE_IV_L1_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_IV_L1_F1)"); break; case FIFO_LOAD_CLASS_1_TYPE_PKHA_A: printf("(FIFO_LOAD_CLASS_1_TYPE_PKHA_A)"); break; case FIFO_LOAD_CLASS_1_TYPE_PKHA_B: printf("(FIFO_LOAD_CLASS_1_TYPE_PKHA_B)"); break; case FIFO_LOAD_CLASS_1_TYPE_PKHA_N: printf("(FIFO_LOAD_CLASS_1_TYPE_PKHA_N)"); break; case FIFO_LOAD_CLASS_2_TYPE_MSG: printf("(FIFO_LOAD_CLASS_2_TYPE_MSG)"); break; case FIFO_LOAD_CLASS_2_TYPE_MSG_L2: printf("(FIFO_LOAD_CLASS_2_TYPE_MSG_L2)"); break; case FIFO_LOAD_CLASS_1_TYPE_ICV: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV)"); break; case FIFO_LOAD_CLASS_1_TYPE_ICV_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV_F1)"); break; case FIFO_LOAD_CLASS_1_TYPE_ICV_L1: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV_L1)"); break; case FIFO_LOAD_CLASS_1_TYPE_ICV_L1_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV_L1_F1)"); break; case FIFO_LOAD_CLASS_2_TYPE_ICV: printf("(FIFO_LOAD_CLASS_2_TYPE_ICV)"); break; case FIFO_LOAD_CLASS_2_TYPE_ICV_L2: printf("(FIFO_LOAD_CLASS_2_TYPE_ICV_L2)"); break; default: printf("(undecoded load type)"); break; } if (!(buffer[i] & FIFO_LOAD_IMM) && !(buffer[i] & FIFO_LOAD_SGT) && (ctype == CMD_FIFO_LOAD)) { next_data_is_pointer = ptrSize; next_data_size = FIFO_LOAD_LENGTH(buffer[i]); } else if (buffer[i] & FIFO_LOAD_IMM) { printf("(IMM data)"); if(FIFO_LOAD_LENGTH(buffer[i]) > 0) { next_data_is_immediate = 2; next_data_size = next_data_is_immediate * sizeof(uint32_t); } else { printf("(0 length data)"); } } else if ((buffer[i] & FIFO_LOAD_SGT) && (ctype == CMD_FIFO_LOAD)) { printf("(FIFO_LOAD_SGT)"); next_data_is_sgt = ptrSize; /* Next word contains pointer to Scatter gather table */ } else if (buffer[i] & FIFO_LOAD_VLF && (ctype == CMD_FIFO_LOAD + 1)) { printf("(VLF)"); } printf("(length = 0x%x)", FIFO_LOAD_LENGTH(buffer[i])); break; case CMD_STORE: next_data_is_pointer=ptrSize; next_data_size = STORE_LENGTH(buffer[i]); case CMD_STORE + 1: /* SEQ STORE */ if(ctype == CMD_STORE) { printf("CMD_STORE: "); } else { printf("SEQ CMD_STORE: "); } switch(buffer[i] & STORE_CLASS_SRC_MASK) { case STORE_CLASS_1_SRC_CTX: printf("(STORE_CLASS_1_SRC_CTX)"); break; case STORE_CLASS_2_SRC_CTX: printf("(STORE_CLASS_2_SRC_CTX)"); break; default: printf("(undecoded src)"); break; } printf("(LENGTH=0x%x)", STORE_LENGTH(buffer[i])); if ((buffer[i] & STORE_OFFSET(0xff)) != 0) { printf("(OFFSET=0x%x)", (buffer[i] & STORE_OFFSET(0xff)) >> 8); } if(buffer[i] & STORE_VLF) printf("(STORE_VLF)"); //if(buffer[i] & STORE_SGT) printf("(STORE_SGT)"); /*TODO*/ if(buffer[i] & STORE_IMM) printf("(STORE_IMM)"); break; case CMD_LOAD + 1: /* Sequential load command */ printf("SEQ "); case CMD_LOAD: printf("CMD_LOAD: "); switch(buffer[i] & LOAD_CLASS_DST_MASK) { case DCTRL_LOAD_CLASS_DECO_IMM_DST_REG & ~LOAD_IMM: if(buffer[i] & LOAD_IMM) { printf("(DCTRL_LOAD_CLASS_DECO_IMM_DST_REG)"); switch(buffer[i] & DCTRL_LOAD_AUTO_IFIFO_MASK) { case DCTRL_LOAD_AUTO_IFIFO_DISABLED: printf("(DCTRL_LOAD_AUTO_IFIFO_DISABLED)"); break; case DCTRL_LOAD_AUTO_IFIFO_ENABLED: printf("(DCTRL_LOAD_AUTO_IFIFO_ENABLED)"); break; } } break; case LOAD_CLASS_1_DST_IVSZ: printf("(LOAD_CLASS_1_DST_IVSZ)"); break; case LOAD_CLASS_1_DST_CTX: printf("(LOAD_CLASS_1_DST_CTX)"); break; case LOAD_CLASS_2_DST_CTX: printf("(LOAD_CLASS_2_DST_CTX)"); break; default: printf("(undecoded load dst)"); break; } printf("(LENGTH=0x%x)", LOAD_LENGTH(buffer[i])); if ((buffer[i] & LOAD_OFFSET(0xff)) != 0) { printf("(OFFSET=0x%x)", (buffer[i] & LOAD_OFFSET(0xff)) >> 8); } if(ctype == CMD_LOAD) { if (!(buffer[i] & LOAD_IMM)) { next_data_is_pointer = ptrSize; next_data_size = LOAD_LENGTH(buffer[i]); } else if((buffer[i] & LOAD_CLASS_DST_MASK) != (DCTRL_LOAD_CLASS_DECO_IMM_DST_REG & ~LOAD_IMM)) { printf("(IMM data)"); next_data_is_immediate = 1; /*TODO fix size. This is only for "word length" commands*/ } } if(buffer[i] & LOAD_VLF) printf("(LOAD_VLF)"); if(buffer[i] & LOAD_SGT) printf("(LOAD_SGT)"); if(buffer[i] & LOAD_IMM) printf("(LOAD_IMM)"); break; case CMD_JUMP: printf("CMD_JUMP: "); switch(buffer[i] & JUMP_CLASS_MASK) { case JUMP_CLASS_BOTH: printf("(JUMP_CLASS_BOTH)"); break; default: printf("(Undecoded jump class)"); break; } switch(buffer[i] & JUMP_TYPE_MASK) { case JUMP_TYPE_LOCAL: printf("(JUMP_TYPE_LOCAL)"); break; case JUMP_TYPE_NON_LOCAL: printf("(JUMP_TYPE_NON_LOCAL)"); next_data_is_immediate = 1; /* Pointer to another descriptor word */ next_data_size = ptrSize; break; case JUMP_TYPE_HALT_TEST_STATUS: printf("(JUMP_TYPE_HALT_TEST_STATUS)"); break; case JUMP_TYPE_HALT_USER_STATUS: printf("(JUMP_TYPE_HALT_USER_STATUS)"); break; default: printf("(Undecoded jump class)"); break; } switch(buffer[i] & JUMP_TEST_MASK) { case JUMP_TEST_ANY_MISMATCH: printf("(JUMP_TEST_ANY_MISMATCH)"); break; case JUMP_TEST_ANY_MATCH: printf("(JUMP_TEST_ANY_MATCH)"); break; case JUMP_TEST_ALL_MISMATCH: printf("(JUMP_TEST_ALL_MISMATCH)"); break; case JUMP_TEST_ALL_MATCH: printf("(JUMP_TEST_ALL_MATCH)"); break; default: printf("undecoded JUMP_TEST"); break; } switch(buffer[i] & (JUMP_COND_MASK | JUMP_SL_MASK)) { /* Dual meanings depending on other as well */ case JUMP_SL_0 | JUMP_COND_SL_0_MATH_NV: printf("(JUMP_COND_SL_0_MATH_NV)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_NCP: printf("(JUMP_COND_SL_1_NCP)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_MATH_C: printf("(JUMP_COND_SL_0_MATH_C)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_NOP: printf("(JUMP_COND_SL_1_NOP)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_MATH_Z: printf("(JUMP_COND_SL_0_MATH_Z)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_NIFP: printf("(JUMP_COND_SL_1_NIFP)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_MATH_N: printf("(JUMP_COND_SL_0_MATH_N)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_NIP: printf("(JUMP_COND_SL_1_NIP)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_NOT_USED: printf("(JUMP_COND_SL_0_NOT_USED)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_CALM: printf("(JUMP_COND_SL_1_CALM)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_PKHA_IS_PRIME: printf("(JUMP_COND_SL_0_PKHA_IS_PRIME)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_SELF: printf("(JUMP_COND_SL_1_SELF)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_PKHA_GCD_ONE: printf("(JUMP_COND_SL_0_PKHA_GCD_ONE)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_SHRD: printf("(JUMP_COND_SL_1_SHRD)"); break; case JUMP_SL_0 | JUMP_COND_SL_0_PKHA_IS_ZERO: printf("(JUMP_COND_SL_0_PKHA_IS_ZERO)"); break; case JUMP_SL_1 | JUMP_COND_SL_1_JQP: printf("(JUMP_COND_SL_1_JQP)"); break; default: printf("(Undecoded JUMP_COND)"); } printf("(localOffset=0x%x)", JUMP_LOCAL_OFFSET(buffer[i])); break; default: printf("undecoded ctype"); break; } printf("\n"); } else /* immediate data, data pointer, SGT or pdb*/ { if (next_data_is_pointer != 0) { next_data_is_pointer--; printf("(data pointer word %d)\n", next_data_is_pointer); /* print pointer data if any */ if((next_data_is_pointer == 0) && (next_data_size > 0)) { printBufIx = sprintf(printBuf," ----> 0x"); for(j=0;j= (PRINT_DATA_LIMIT-1)) && (((next_data_size - 1) - j) > 4)) { printBufIx += sprintf(&printBuf[printBufIx]," ... ... ", PRINT_DATA_LIMIT); j = next_data_size - 4 - 1; } } printBufIx += sprintf(&printBuf[printBufIx],"\0"); printf("%s\n",printBuf); next_data_size = 0; } } else if(next_data_is_immediate != 0) /* immediate data */ { next_data_is_immediate--; printf("(immediate data word %d)\n", next_data_is_immediate); } else if(next_data_is_sgt != 0) /* Scatter gather table */ { next_data_is_sgt--; printf("(SGT pointer word %d)\n", next_data_is_sgt); if(next_data_is_sgt == 0) { int sgt_entry_is_last = 0; t_SGTEntry *sgt_entry = (t_SGTEntry *)XX_PhysToVirt((physAddress_t *)(buffer[i])); /*TODO: do according to ptr size */; /* Print Scatter gather table */ printf(" ----> Scatter Gather Table\n"); while(sgt_entry_is_last == 0) { printf("\t0x"); for(j=0; j < (sizeof(t_SGTEntry)/sizeof(uint32_t)); j++) /*SGT size is 16 bytes */ { printf("%08x ", ((uint32_t *)sgt_entry)[j]); /* See if this is last entry in SGT */ if((j == 2) && (sgt_entry->final == 1)) { sgt_entry_is_last = 1; } } /* Print data */ printf(" ----> "); for(int k=0; k < sgt_entry->length; k++) { if((k & 0x3) == 0) printf(" "); printf("%02x", ((uint8_t *)XX_PhysToVirt((physAddress_t)(sgt_entry->address + (uint16_t)sgt_entry->offset)))[k] ); /*TODO: do according to ptr size */ if((k >= (PRINT_DATA_LIMIT-1)) && (((sgt_entry->length - 1) - k) > 4)) { printf(" ... ... ", PRINT_DATA_LIMIT); k = sgt_entry->length - 4 - 1; } } printf("\n"); sgt_entry++; } } } else /* pdb (protocol descriptor block) data */ { next_data_is_pdb--; printf("(pdb data word %d)\n", startIndex-next_data_is_pdb); } } } /* Now when all is decoded we know how to decode the PDB if there is one */ if(pdbType != 0) PrintDecodePDB(&(buffer[pdbIndex]), pdbType); } void PrintDecodePDB(uint32_t* buf_p, uint32_t pdbType) { union pdb { t_IpsecEncapPdb *ipsecEncapPdb; t_IpsecDecapPdb *ipsecDecapPdb; } pdb; printf(" Decoded PDB block: "); switch(pdbType) { case PCL_OP_TYPE_ENCAP_ID_IPSEC: printf("PCL_OP_TYPE_ENCAP_ID_IPSEC\n"); pdb.ipsecEncapPdb = (t_IpsecEncapPdb *) buf_p; printf("\tNextHeader=0x%x\n", pdb.ipsecEncapPdb->nextHdr); printf("\tnhOffset=0x%x\n", pdb.ipsecEncapPdb->nhOffset); printf("\tseqNum=0x%x\n", pdb.ipsecEncapPdb->seqNum); printf("\toptions=0x%x\n", pdb.ipsecEncapPdb->options); printf("\t SPI=0x%x\n", pdb.ipsecEncapPdb->spi); printf("\t DF bit copy=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_HMO_DFC) == 0 ? 0 : 1); printf("\t Decrease TTL=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_HMO_DTTL) == 0 ? 0 : 1); printf("\t Checksum update=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_CKSM) == 0 ? 0 : 1); printf("\t Diffserv copy=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_DSC) == 0 ? 0 : 1); printf("\t IV src=%s \n",(pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_IVSRC) == 0 ? "pdb" : "rng"); printf("\t ESN=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_ESN) == 0 ? 0 : 1); printf("\t IP Header src=%s\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_SRC) == 0 ? "frame" : "pdb"); printf("\t Prepend IPHdr=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_INC) == 0 ? 0 : 1); printf("\t IP version=%s\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_IPV6) == 0 ? "v4" : "v6"); printf("\t Mode=%s\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_TUNNEL) == 0 ? "transport" : "tunnel"); break; case PCL_OP_TYPE_DECAP_ID_IPSEC: printf("PCL_OP_TYPE_DECAP_ID_IPSEC\n"); pdb.ipsecDecapPdb = (t_IpsecDecapPdb *) buf_p; printf("\tipHdrLen=%d\n", pdb.ipsecDecapPdb->ipHdrLen); printf("\tnhOffset=0x%x\n", pdb.ipsecDecapPdb->nhOffset); printf("\tseqNum=0x%x\n", pdb.ipsecDecapPdb->seqNum); printf("\toptions=0x%x\n", pdb.ipsecDecapPdb->options); printf("\t Decrease TTL=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_HMO_DTTL) == 0 ? 0 : 1); printf("\t Diffserv copy=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_HMO_DSC) == 0 ? 0 : 1); printf("\t ARS64=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_ARS64) == 0 ? 0 : 1); printf("\t ARS32=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_ARS32) == 0 ? 0 : 1); printf("\t Checksum verification=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_CKSM) == 0 ? 0 : 1); printf("\t ESN=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_ESN) == 0 ? 0 : 1); printf("\t Outframe format (FMT)=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_FMT) == 0 ? 0 : 1); printf("\t IP version=%s\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_IPV6) == 0 ? "v4" : "v6"); printf("\t Mode=%s\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_TUNNEL) == 0 ? "transport" : "tunnel"); break; default: printf("(undecoded PDB type)\n"); break; } } void SEC_DCL_DebugPrintDescriptor(t_Desc* jobDescHandle) { uint32_t descLen; printf("Job descriptor @ 0x%x\n", (uint32_t) jobDescHandle); printf(" p_Prefix = 0x%x\n", (uint32_t) jobDescHandle->p_Prefix); printf(" p_Postfix = 0x%x\n", (uint32_t) jobDescHandle->p_Postfix); printf(" p_Mem = 0x%x\n", (uint32_t) jobDescHandle->p_Mem); printf(" p_Buffer = 0x%x\n", (uint32_t) jobDescHandle->p_Buffer); printf(" BufSize = 0x%x\n", jobDescHandle->bufferSize); descLen = ((uint32_t *)jobDescHandle->p_Buffer)[0] & 0x7f; PrintDecodeDescriptor((uint32_t *)jobDescHandle->p_Buffer, NULL); } #ifdef SEC4_USE_QI void SEC_DCL_DebugPrintPreHeader(t_SecPreHeader* preHeader) { printf("SEC4 pre header @ 0x%x\n", preHeader); printf("\tRSLS=%d, ", SEC_PH_GET_RSLS(preHeader)); printf("SDLEN=%d, ", SEC_PH_GET_SDLEN(preHeader)); printf("FSGT=%d, ", SEC_PH_GET_FSGT(preHeader)); printf("LONG=%d, ", SEC_PH_GET_LONG(preHeader)); printf("OFFSET=%d, ", SEC_PH_GET_OFFSET(preHeader)); printf("ABS=%d, ", SEC_PH_GET_ABS(preHeader)); printf("ADDBUF=%d, ", SEC_PH_GET_ADDBUF(preHeader)); printf("POOLID=%d, ", SEC_PH_GET_POOLID(preHeader)); printf("BUFSIZE=%d\n", SEC_PH_GET_BUFSIZE(preHeader)); } #endif /* #ifdef SEC4_USE_QI */ #endif /* #ifdef DBG */