From 74bbc6ecbf10d8426088f8c9520eff1015015e09 Mon Sep 17 00:00:00 2001 From: Sukchan Lee Date: Sat, 11 Dec 2021 17:28:05 +0900 Subject: [PATCH] [MME] Add S1AP debug (#1263) --- src/mme/s1ap-build.c | 56 +- src/mme/s1ap-path.c | 20 +- tests/unit/s1ap-message-test.c | 1215 +++++++++++++++++++++++++++++--- 3 files changed, 1190 insertions(+), 101 deletions(-) diff --git a/src/mme/s1ap-build.c b/src/mme/s1ap-build.c index 23e096daf3..2fd1135664 100644 --- a/src/mme/s1ap-build.c +++ b/src/mme/s1ap-build.c @@ -349,6 +349,9 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( *MME_UE_S1AP_ID = enb_ue->mme_ue_s1ap_id; *ENB_UE_S1AP_ID = enb_ue->enb_ue_s1ap_id; + ogs_debug(" AMBR[DL:%lld,UL:%lld]", + (long long)mme_ue->ambr.downlink, (long long)mme_ue->ambr.uplink); + asn_uint642INTEGER( &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateUL, mme_ue->ambr.uplink); @@ -414,6 +417,10 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( ogs_debug(" EBI[%d] QCI[%d] SGW-S1U-TEID[%d]", bearer->ebi, bearer->qos.index, bearer->sgw_s1u_teid); + ogs_debug(" ARP[%d:%d:%d]", + bearer->qos.arp.priority_level, + bearer->qos.arp.pre_emption_capability, + bearer->qos.arp.pre_emption_vulnerability); e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. priorityLevel = bearer->qos.arp.priority_level; @@ -431,6 +438,13 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( ogs_assert(bearer->qos.gbr.downlink); ogs_assert(bearer->qos.gbr.uplink); + ogs_debug(" MBR[DL:%lld,UL:%lld]", + (long long)bearer->qos.mbr.downlink, + (long long)bearer->qos.mbr.uplink); + ogs_debug(" GBR[DL:%lld,UL:%lld]", + (long long)bearer->qos.gbr.downlink, + (long long)bearer->qos.gbr.uplink); + gbrQosInformation = CALLOC(1, sizeof(struct S1AP_GBR_QosInformation)); asn_uint642INTEGER(&gbrQosInformation->e_RAB_MaximumBitrateDL, @@ -451,9 +465,9 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( ogs_asn_uint32_to_OCTET_STRING( bearer->sgw_s1u_teid, &e_rab->gTP_TEID); - ogs_debug(" EMM[%p] LEN[%d]", emmbuf, emmbuf ? emmbuf->len : 0); - if (emmbuf && emmbuf->len) { + ogs_debug(" NASPdu[%p:%d]", emmbuf, emmbuf->len); + nasPdu = (S1AP_NAS_PDU_t *)CALLOC(1, sizeof(S1AP_NAS_PDU_t)); nasPdu->size = emmbuf->len; nasPdu->buf = CALLOC(nasPdu->size, sizeof(uint8_t)); @@ -461,6 +475,8 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( e_rab->nAS_PDU = nasPdu; ogs_pkbuf_free(emmbuf); + ogs_log_hexdump(OGS_LOG_DEBUG, nasPdu->buf, nasPdu->size); + /* Since Tracking area update accept is used only once, * set emmbuf to NULL as shown below */ emmbuf = NULL; @@ -495,6 +511,10 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( UESecurityCapabilities->encryptionAlgorithms.buf[0] = (mme_ue->ue_network_capability.eea << 1); + ogs_log_hexdump(OGS_LOG_DEBUG, + UESecurityCapabilities->encryptionAlgorithms.buf, + UESecurityCapabilities->encryptionAlgorithms.size); + UESecurityCapabilities->integrityProtectionAlgorithms.size = 2; UESecurityCapabilities->integrityProtectionAlgorithms.buf = CALLOC(UESecurityCapabilities-> @@ -503,6 +523,10 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( UESecurityCapabilities->integrityProtectionAlgorithms.buf[0] = (mme_ue->ue_network_capability.eia << 1); + ogs_log_hexdump(OGS_LOG_DEBUG, + UESecurityCapabilities->integrityProtectionAlgorithms.buf, + UESecurityCapabilities->integrityProtectionAlgorithms.size); + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); @@ -520,8 +544,8 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( SecurityKey->bits_unused = 0; memcpy(SecurityKey->buf, mme_ue->kenb, SecurityKey->size); - ogs_debug(" mme_ue->nas_eps.type[%d:%d]", - mme_ue->nas_eps.type, MME_P_TMSI_IS_AVAILABLE(mme_ue)); + ogs_log_hexdump(OGS_LOG_DEBUG, SecurityKey->buf, SecurityKey->size); + if (mme_ue->nas_eps.type == MME_EPS_TYPE_EXTENDED_SERVICE_REQUEST && MME_P_TMSI_IS_AVAILABLE(mme_ue)) { @@ -563,13 +587,14 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( } - ogs_debug(" mme_ue->ueRadioCapability[%p:%lld]", - mme_ue->ueRadioCapability.buf, - (long long)mme_ue->ueRadioCapability.size); if (mme_ue->ueRadioCapability.buf && mme_ue->ueRadioCapability.size) { /* Set UeRadioCapability if exists */ S1AP_UERadioCapability_t *UERadioCapability = NULL; + ogs_debug(" UERadioCapability[%p:%d]", + mme_ue->ueRadioCapability.buf, + (int)mme_ue->ueRadioCapability.size); + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); @@ -578,13 +603,15 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( ie->value.present = S1AP_InitialContextSetupRequestIEs__value_PR_UERadioCapability; - ogs_debug(" UERadioCapability"); UERadioCapability = &ie->value.choice.UERadioCapability; ogs_assert(UERadioCapability); ogs_s1ap_buffer_to_OCTET_STRING( mme_ue->ueRadioCapability.buf, mme_ue->ueRadioCapability.size, UERadioCapability); + + ogs_log_hexdump(OGS_LOG_DEBUG, + UERadioCapability->buf, UERadioCapability->size); } /* TS23.003 6.2.2 Composition of IMEISV @@ -595,7 +622,6 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( * TAC(8 digits) - SNR(6 digits) - SVN(2 digits) * IMEISV(16 digits) ==> 8bytes */ - ogs_debug(" mme_ue->imeisv_len[%d]", mme_ue->imeisv_len); if (mme_ue->imeisv_len == OGS_MAX_IMEISV_LEN) { ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); @@ -612,10 +638,10 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( Masked_IMEISV->buf = CALLOC(Masked_IMEISV->size, sizeof(uint8_t)); Masked_IMEISV->bits_unused = 0; memcpy(Masked_IMEISV->buf, mme_ue->masked_imeisv, Masked_IMEISV->size); + + ogs_log_hexdump(OGS_LOG_DEBUG, Masked_IMEISV->buf, Masked_IMEISV->size); } - ogs_debug(" mme_ue->ue_additional_security_capability.length[%d]", - mme_ue->ue_additional_security_capability.length); if (mme_ue->ue_additional_security_capability.length) { ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); @@ -635,6 +661,10 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( NRUESecurityCapabilities->nRencryptionAlgorithms.buf[0] = (mme_ue->ue_additional_security_capability.nea << 1); + ogs_log_hexdump(OGS_LOG_DEBUG, + NRUESecurityCapabilities->nRencryptionAlgorithms.buf, + NRUESecurityCapabilities->nRencryptionAlgorithms.size); + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.size = 2; NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf = CALLOC(NRUESecurityCapabilities-> @@ -644,9 +674,11 @@ ogs_pkbuf_t *s1ap_build_initial_context_setup_request( NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf[0] = (mme_ue->ue_additional_security_capability.nia << 1); + ogs_log_hexdump(OGS_LOG_DEBUG, + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf, + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.size); } - ogs_debug(" ogs_s1ap_encode()"); return ogs_s1ap_encode(&pdu); } diff --git a/src/mme/s1ap-path.c b/src/mme/s1ap-path.c index 40f072f96d..8aa8264ded 100644 --- a/src/mme/s1ap-path.c +++ b/src/mme/s1ap-path.c @@ -245,7 +245,7 @@ int s1ap_send_s1_setup_response(mme_enb_t *enb) int rv; ogs_pkbuf_t *s1ap_buffer; - ogs_debug("[MME] S1-Setup response"); + ogs_debug("S1-Setup response"); s1ap_buffer = s1ap_build_setup_rsp(); ogs_expect_or_return_val(s1ap_buffer, OGS_ERROR); @@ -261,7 +261,7 @@ int s1ap_send_s1_setup_failure( int rv; ogs_pkbuf_t *s1ap_buffer; - ogs_debug("[MME] S1-Setup failure"); + ogs_debug("S1-Setup failure"); s1ap_buffer = s1ap_build_setup_failure(group, cause, S1AP_TimeToWait_v10s); ogs_expect_or_return_val(s1ap_buffer, OGS_ERROR); @@ -278,6 +278,7 @@ int s1ap_send_initial_context_setup_request(mme_ue_t *mme_ue) ogs_assert(mme_ue); + ogs_debug("InitialContextSetupRequest"); s1apbuf = s1ap_build_initial_context_setup_request(mme_ue, NULL); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -294,6 +295,7 @@ int s1ap_send_ue_context_modification_request(mme_ue_t *mme_ue) ogs_assert(mme_ue); + ogs_debug("UEContextModificationRequest"); s1apbuf = s1ap_build_ue_context_modification_request(mme_ue); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -312,7 +314,7 @@ int s1ap_send_ue_context_release_command( ogs_assert(enb_ue); - ogs_debug("[MME] UE Context release command"); + ogs_debug("UEContextReleaseCommand"); ogs_debug(" ENB_UE_S1AP_ID[%d] MME_UE_S1AP_ID[%d]", enb_ue->enb_ue_s1ap_id, enb_ue->mme_ue_s1ap_id); @@ -381,6 +383,7 @@ int s1ap_send_mme_configuration_transfer( ogs_assert(target_enb); ogs_assert(SONConfigurationTransfer); + ogs_debug("MMEConfigurationTransfer"); s1apbuf = s1ap_build_mme_configuration_transfer(SONConfigurationTransfer); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -397,6 +400,7 @@ int s1ap_send_e_rab_modification_confirm(mme_ue_t *mme_ue) ogs_assert(mme_ue); + ogs_debug("E-RABModificationConfirm"); s1apbuf = s1ap_build_e_rab_modification_confirm(mme_ue); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -413,6 +417,7 @@ int s1ap_send_path_switch_ack(mme_ue_t *mme_ue) ogs_assert(mme_ue); + ogs_debug("PathSwitchAcknowledge"); s1apbuf = s1ap_build_path_switch_ack(mme_ue); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -429,6 +434,7 @@ int s1ap_send_handover_command(enb_ue_t *source_ue) ogs_assert(source_ue); + ogs_debug("HandoverCommand"); s1apbuf = s1ap_build_handover_command(source_ue); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -447,6 +453,7 @@ int s1ap_send_handover_preparation_failure( ogs_assert(source_ue); ogs_assert(group); + ogs_debug("HandoverPreparationFailure"); s1apbuf = s1ap_build_handover_preparation_failure(source_ue, group, cause); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -463,6 +470,7 @@ int s1ap_send_handover_cancel_ack(enb_ue_t *source_ue) ogs_assert(source_ue); + ogs_debug("HandoverCancelAcknowledge"); s1apbuf = s1ap_build_handover_cancel_ack(source_ue); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -484,8 +492,7 @@ int s1ap_send_handover_request( enb_ue_t *target_ue = NULL; - ogs_info("Handover request"); - + ogs_info("HandoverRequest"); ogs_assert(source_ue); ogs_assert(source_ue->target_ue == NULL); ogs_assert(target_enb); @@ -521,6 +528,7 @@ int s1ap_send_mme_status_transfer( ogs_assert(target_ue); + ogs_info("MMEStatusTransfer"); s1apbuf = s1ap_build_mme_status_transfer(target_ue, enb_statustransfer_transparentContainer); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -542,6 +550,7 @@ int s1ap_send_error_indication( ogs_assert(enb); + ogs_info("ErrorIndication"); s1apbuf = ogs_s1ap_build_error_indication( mme_ue_s1ap_id, enb_ue_s1ap_id, group, cause); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); @@ -587,6 +596,7 @@ int s1ap_send_s1_reset_ack( ogs_assert(enb); + ogs_info("S1-Reset Acknowledge"); s1apbuf = ogs_s1ap_build_s1_reset_ack(partOfS1_Interface); ogs_expect_or_return_val(s1apbuf, OGS_ERROR); diff --git a/tests/unit/s1ap-message-test.c b/tests/unit/s1ap-message-test.c index 9b81f97c04..391ca7de8e 100644 --- a/tests/unit/s1ap-message-test.c +++ b/tests/unit/s1ap-message-test.c @@ -101,86 +101,7 @@ static void s1ap_message_test3(abts_case *tc, void *data) ogs_pkbuf_free(pkbuf); } -#if 0 static void s1ap_message_test4(abts_case *tc, void *data) -{ - ogs_s1ap_message_t message; - int rv; - ogs_pkbuf_t *pkbuf; - int result; - - mme_self()->max_num_of_served_gummei = 1; - mme_self()->served_gummei[0].num_of_plmn_id = 1; - mme_self()->served_gummei[0].num_of_mme_gid = 1; - mme_self()->served_gummei[0].num_of_mme_code = 1; - - pkbuf = s1ap_build_setup_rsp(); - - ABTS_PTR_NOTNULL(tc, pkbuf); - ABTS_PTR_NOTNULL(tc, pkbuf->data); - ABTS_INT_EQUAL(tc, 27, pkbuf->len); - - result = ogs_s1ap_decode(&message, pkbuf); - ABTS_INT_EQUAL(tc, 0, result); - - ogs_s1ap_free(&message); - ogs_pkbuf_free(pkbuf); -} - -static void s1ap_message_test5(abts_case *tc, void *data) -{ - ogs_s1ap_message_t message; - int rv; - ogs_pkbuf_t *pkbuf; - int result; - - pkbuf = test_s1ap_build_s1_setup_request( - S1AP_ENB_ID_PR_macroENB_ID, 0x54f64, 12345, 1, 1, 2); - - ABTS_INT_EQUAL(tc, OGS_OK, rv); - ABTS_PTR_NOTNULL(tc, pkbuf); - ABTS_PTR_NOTNULL(tc, pkbuf->data); - ABTS_INT_EQUAL(tc, 35, pkbuf->len); - - result = ogs_s1ap_decode(&message, pkbuf); - ABTS_INT_EQUAL(tc, 0, result); - - ogs_s1ap_free(&message); - ogs_pkbuf_free(pkbuf); -} - -static void s1ap_message_test6(abts_case *tc, void *data) -{ - int rv; - ogs_pkbuf_t *s1apbuf = NULL; - ogs_pkbuf_t *emmbuf = NULL; - enb_ue_t enb_ue; - int i; - char buffer[1024]; - const char *_result = - "000b4080 8c000003 00000002 00010008 00020001 001a0079 78efefef efefefef" - "efefefef efefefef efefefef efefefef efefefef efefefef efefefef efefefef" - "efefefef efefefef efefefef efefefef efefefef efefefef efefefef efefefef" - "efefefef efefefef efefefef efefefef efefefef efefefef efefefef efefefef" - "efefefef efefefef efefefef efefefef ef"; - - enb_ue.mme_ue_s1ap_id = 1; - enb_ue.enb_ue_s1ap_id = 1; - - emmbuf = ogs_pkbuf_alloc(NULL, 120); - ABTS_PTR_NOTNULL(tc, emmbuf); - ogs_pkbuf_put(emmbuf, 120); - for (i = 0; i < emmbuf->len; i++) - ((char *)emmbuf->data)[i] = 0xef; - - s1apbuf = s1ap_build_downlink_nas_transport(&enb_ue, emmbuf); - ABTS_TRUE(tc, memcmp(OGS_HEX(_result, strlen(_result), buffer), - s1apbuf->data, s1apbuf->len) == 0); - ogs_pkbuf_free(s1apbuf); -} -#endif - -static void s1ap_message_test7(abts_case *tc, void *data) { /* InitialUE(Service Request) */ const char *payload = @@ -206,7 +127,7 @@ static void s1ap_message_test7(abts_case *tc, void *data) ogs_pkbuf_free(pkbuf); } -static void s1ap_message_test8(abts_case *tc, void *data) +static void s1ap_message_test5(abts_case *tc, void *data) { /* ENBDirectInformationTransferRAN-INFORMATION-REQUEST */ const char *payload = @@ -231,7 +152,7 @@ static void s1ap_message_test8(abts_case *tc, void *data) ogs_pkbuf_free(pkbuf); } -static void s1ap_message_test9(abts_case *tc, void *data) +static void s1ap_message_test6(abts_case *tc, void *data) { /* ENBDirectInformationTransferRAN-INFORMATION-REQUEST */ const char *payload = @@ -256,7 +177,7 @@ static void s1ap_message_test9(abts_case *tc, void *data) ogs_pkbuf_free(pkbuf); } -static void s1ap_message_test10(abts_case *tc, void *data) +static void s1ap_message_test7(abts_case *tc, void *data) { /* ENBDirectInformationTransferRAN-INFORMATION-REQUEST */ const char *payload = @@ -281,6 +202,1134 @@ static void s1ap_message_test10(abts_case *tc, void *data) ogs_pkbuf_free(pkbuf); } +static void s1ap_message_test8(abts_case *tc, void *data) +{ + int rv; + ogs_pkbuf_t *s1apbuf = NULL; + + S1AP_S1AP_PDU_t pdu; + S1AP_InitiatingMessage_t *initiatingMessage = NULL; + S1AP_InitialContextSetupRequest_t *InitialContextSetupRequest = NULL; + + S1AP_InitialContextSetupRequestIEs_t *ie = NULL; + S1AP_MME_UE_S1AP_ID_t *MME_UE_S1AP_ID = NULL; + S1AP_ENB_UE_S1AP_ID_t *ENB_UE_S1AP_ID = NULL; + S1AP_UEAggregateMaximumBitrate_t *UEAggregateMaximumBitrate = NULL; + S1AP_E_RABToBeSetupListCtxtSUReq_t *E_RABToBeSetupListCtxtSUReq = NULL; + S1AP_UESecurityCapabilities_t *UESecurityCapabilities = NULL; + S1AP_SecurityKey_t *SecurityKey = NULL; + S1AP_Masked_IMEISV_t *Masked_IMEISV = NULL; + S1AP_NRUESecurityCapabilities_t *NRUESecurityCapabilities = NULL; + + memset(&pdu, 0, sizeof (S1AP_S1AP_PDU_t)); + pdu.present = S1AP_S1AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = CALLOC(1, sizeof(S1AP_InitiatingMessage_t)); + + initiatingMessage = pdu.choice.initiatingMessage; + initiatingMessage->procedureCode = + S1AP_ProcedureCode_id_InitialContextSetup; + initiatingMessage->criticality = S1AP_Criticality_reject; + initiatingMessage->value.present = + S1AP_InitiatingMessage__value_PR_InitialContextSetupRequest; + + InitialContextSetupRequest = + &initiatingMessage->value.choice.InitialContextSetupRequest; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_MME_UE_S1AP_ID; + + MME_UE_S1AP_ID = &ie->value.choice.MME_UE_S1AP_ID; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_ENB_UE_S1AP_ID; + + ENB_UE_S1AP_ID = &ie->value.choice.ENB_UE_S1AP_ID; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_uEaggregateMaximumBitrate; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UEAggregateMaximumBitrate; + + UEAggregateMaximumBitrate = &ie->value.choice.UEAggregateMaximumBitrate; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_E_RABToBeSetupListCtxtSUReq; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_E_RABToBeSetupListCtxtSUReq; + + E_RABToBeSetupListCtxtSUReq = &ie->value.choice.E_RABToBeSetupListCtxtSUReq; + + *MME_UE_S1AP_ID = 215; + *ENB_UE_S1AP_ID = 248; + + asn_uint642INTEGER( + &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateUL, + 1073741824); + asn_uint642INTEGER( + &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateDL, + 1073741824); + + { + S1AP_E_RABToBeSetupItemCtxtSUReqIEs_t *item = NULL; + S1AP_E_RABToBeSetupItemCtxtSUReq_t *e_rab = NULL; + + item = CALLOC(1, sizeof(S1AP_E_RABToBeSetupItemCtxtSUReqIEs_t)); + ASN_SEQUENCE_ADD(&E_RABToBeSetupListCtxtSUReq->list, item); + + item->id = S1AP_ProtocolIE_ID_id_E_RABToBeSetupItemCtxtSUReq; + item->criticality = S1AP_Criticality_reject; + item->value.present = S1AP_E_RABToBeSetupItemCtxtSUReqIEs__value_PR_E_RABToBeSetupItemCtxtSUReq; + + e_rab = &item->value.choice.E_RABToBeSetupItemCtxtSUReq; + + e_rab->e_RAB_ID = 5; + e_rab->e_RABlevelQoSParameters.qCI = 9; + + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + priorityLevel = 8; + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + pre_emptionCapability = 1; + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + pre_emptionVulnerability = 1; + + ogs_ip_t sgw_s1u_ip; + memset(&sgw_s1u_ip, 0, sizeof(sgw_s1u_ip)); + sgw_s1u_ip.ipv4 = 1; + sgw_s1u_ip.addr = inet_addr("10.11.2.6"); + + rv = ogs_asn_ip_to_BIT_STRING( + &sgw_s1u_ip, &e_rab->transportLayerAddress); + ogs_assert(rv == OGS_OK); + ogs_asn_uint32_to_OCTET_STRING( + 4458, &e_rab->gTP_TEID); + } + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_UESecurityCapabilities; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UESecurityCapabilities; + + UESecurityCapabilities = &ie->value.choice.UESecurityCapabilities; + + UESecurityCapabilities->encryptionAlgorithms.size = 2; + UESecurityCapabilities->encryptionAlgorithms.buf = + CALLOC(UESecurityCapabilities->encryptionAlgorithms.size, + sizeof(uint8_t)); + UESecurityCapabilities->encryptionAlgorithms.bits_unused = 0; + UESecurityCapabilities->encryptionAlgorithms.buf[0] = 0xe0; + + UESecurityCapabilities->integrityProtectionAlgorithms.size = 2; + UESecurityCapabilities->integrityProtectionAlgorithms.buf = + CALLOC(UESecurityCapabilities-> + integrityProtectionAlgorithms.size, sizeof(uint8_t)); + UESecurityCapabilities->integrityProtectionAlgorithms.bits_unused = 0; + UESecurityCapabilities->integrityProtectionAlgorithms.buf[0] = 0xe0; + + { + const char *kenb_string = + "46c29ed95831e77a cd7becb5b57d02a7" + "0b542ba0fbfd88a7 36f37f1b4f4b1a6d"; + uint8_t kenb[32]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_SecurityKey; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_SecurityKey; + + SecurityKey = &ie->value.choice.SecurityKey; + + SecurityKey->size = 32; + SecurityKey->buf = CALLOC(SecurityKey->size, sizeof(uint8_t)); + SecurityKey->bits_unused = 0; + OGS_HEX(kenb_string, strlen(kenb_string), kenb); + memcpy(SecurityKey->buf, kenb, SecurityKey->size); + } + + { + /* Set UeRadioCapability if exists */ + S1AP_UERadioCapability_t *UERadioCapability = NULL; + const char *radio_string = +#define TEST8_RADIO_SIZE 2149 + "50400242 40002b40 060010fd 0031b400" + "6d400100 002e400b 00002f40 060099f9" + "100004e3 bfff8eff fe3bfff8 efffe3bf" + "ff8efffe 3bfff8ef ffe3bfff 8efffe3b" + "fffbf06e c4f00141 bc08d480 0000002a" + "77c00000 00bff002 10030030 02801200" + "60060060 84300304 018200c1 00608030" + "4218210c 10860843 04218210 c1006080" + "30421821 0c100608 03042182 10904018" + "200c1006 08030420 82104108 08200c10" + "06080304 018210c1 08608410 42082104" + "10820803 04018200 c1006084 30421821" + "0c108608 43042182 00c10060 84300304" + "21801821 0c108608 43003042 18018400" + "86100218 200c1006 10021840 08608030" + "40184100 61040182 00c20803 08200c20" + "80308010 c2004308 010c2080 308200c2" + "08030801 0c200430 8010c208 41082104" + "20003080 00c20003 08010c20 04308010" + "c2004308 010c2004 308000c2 00030800" + "0c200430 8010c200 4308010c 20043080" + "10c20043 08010c20 04308010 c2004308" + "010c0096 87d54674 040fe061 0002081b" + "60008006 98002000 be1000c7 00040030" + "0001040e 80004103 9c001040 c4000400" + "31800104 0d100040 03480010 00e50004" + "103a4001 040ea000 41070800 10508208" + "18400092 0ed80020 21041056 c2061000" + "2083a600 08084104 15308184 000820af" + "841c2000 4107a000 10508208 2d010708" + "00104167 08384000 820f2800 20a10410" + "59420e10 0020838e 00080841 04147081" + "84000820 e300020a 10410518 20e10002" + "08388000 80841041 44081840 00820e10" + "0020a004 1050820e 00002083 b6000808" + "e10015b0 818e0008 00ed8002 02304105" + "6c206300 02083b60 00808010 415b0818" + "0000820a f841d300 04007940 01054c20" + "02ca1074 c001001d 30004047 0800a984" + "0c700040 074c0010 1182082a 61031800" + "1041d300 04040082 0a9840c0 00041057" + "c20e3000 2082be10 70000104 1e800041" + "470800b4 041c7000 40079400 1051c200" + "2ca1071c 001001c7 00040460 820a3840" + "c6000410 71c00101 0020828e 10300001" + "041e8000 41400820 b4041c00 00410794" + "00105002 082ca107 00001041 c6000414" + "00820a30 41c00004 10710001 01002082" + "88103000 01041c00 00414008 20600002" + "483d0000 82d01040 e8000490 79c00105" + "9c2083ce 000828c1 04167083 8c000820" + "73800248 38c00082 8c1040c6 000490b6" + "c0010108 20a10410 96c20610 0020a104" + "1076c001 01082482 b6103080 01242d30" + "00404208 28410425 30818400 08284104" + "1d300040 420920a9 840c2000 49097c20" + "e9800202 1041097c 20a9840c 20004105" + "7c206100 02485d00 00828e10 1082084d" + "01071c00 10108208 4d01051c 20610002" + "085d0000 80841050 02084d01 03080010" + "5002084d 01010820 e0000208 5ca00082" + "8e101082 084ca107 1c001010 82084ca1" + "051c2061 0002085c a0008084 10500208" + "4ca10308 00105002 084ca101 0820e000" + "02084be1 07080010 5002004b e1050820" + "e0000200 5b600080 8e101082 084b6103" + "1c001010 82084b61 011c2061 0002085b" + "6000808c 10508208 4b610318 00105082" + "084b6101 1820e100 02085b60 00808410" + "5002084b 61030800 10500208 4b610108" + "20e00002 085a6000 808e1010 82084a61" + "031c0010 1082084a 61011c20 61000208" + "5a600080 8c105082 084a6103 18001050" + "82084a61 011820e1 0002085a 60008084" + "10500208 4a610308 00105002 084a6101" + "0820e000 020858e0 00808c10 50820848" + "e1031800 10508208 48e10118 20e10002" + "0858e000 80841050 820848e1 03080010" + "50820858 e0008084 10500208 18402093" + "fc77fff1 dfffc77f ff1dfffc 77fff1df" + "ffc77fff 1dfffc77 fff1dfff c77fff1d" + "fffc77ff f1dfffc7 7fff1dff fc77fff1" + "dfffc77f ff1dfffc 77fff1df ffc77fff" + "1dfffc77 fff1dfff c77fff1d fffc77ff" + "f1dfffc7 7fff1dff fc77fff1 dfffc77f" + "ff1dfffc 77fff1df ffc77fff 1dfffc77" + "fff1dfff c77fff1d fffc77ff f1dfffc7" + "7fff1dff fc77fff1 dfffc77f ff1dfffc" + "77fff1df ffc77fff 1dfffc77 fff1dfff" + "c77fff1d fffc77ff f1dfffc7 7fff1dff" + "fc77fff1 dfffc77f ff1dfffc 77fff1df" + "ffc77fff 1dfffc77 fff1dfff c77fff1d" + "fffc77ff f1dfffc7 7fff1dff fc77fff1" + "dfffc77f ff1dfffc 77fff1df ffc77fff" + "1dfffc77 fff1dfff c77fff1d fffc77ff" + "f1dfffc7 7fff1dff fc77fff1 dfffc77f" + "ff1dfffc 77fff1df ffc77fff 1dfffc77" + "fff1dfff c77fff1d fffc77ff f1dfffc7" + "7fff1dff fc77fff1 dfffc77f ff1dfffc" + "77fff1df ffc77fff 1dfffc77 fff1dfff" + "c77fff1d fffc77ff f1dfffc7 7fff1dff" + "fdf3a000 023fe000 22e87878 78743c3c" + "391fc7f0 f0f27e4f c3c390f0 f0f0f0e4" + "5e2f178b 843c3917 8bc5e2f0 f0e43c3c" + "3c3a1e1e 3f8721e3 f8b80000 000021e1" + "e1c45e2f 1787878f cfc10048 00f1979a" + "040149df ffffffe6 94bbc700 e8005820" + "01149000 02000510 4a9e0600 00100803" + "00e09836 1284e140 982689c2 00100082" + "1800c0c0 00020100 601c1306 c2509c28" + "1304d138 4583e0e9 a0100007 4f5a1302" + "00020140 4824c580 0260d40c 13601873" + "e618f285 81c13008 0c46032a 0d89dac1" + "18434102 0f94022c b64c550d 0e7c471e" + "819f604f 8c73e618 f28581c0 e1e0b800" + "07800e00 01e00038 01c0a836 26eb0461" + "0d04083e 5008b2d9 31543439 f11c7a06" + "7d813e31 cf9863ca 16070387 82e000be" + "0038002f 8000e407 001b2800 02800002" + "a0d899ac 11843410 20f94022 cb64c550" + "d0e7c471 e819f604 f8c73e61 8f28581c" + "0e1e0b80 027800e0 009e0003 801c0e83" + "614606b0 4610d040 83e5008b 2d931543" + "439f11c7 a067d813 e31cf986 3ca16070" + "38782e00 0be00380 02f8000e 00702a0d" + "84fac118 4341020f 94022cb6 4c550d0e" + "7c471e81 9f604f8c 73e618f2 8581c0e1" + "e138002f 800e000b e0003801 c0a83612" + "eb04610d 04083e50 08b2d931 543439f1" + "1c7a067d 813e31cf 9863ca16 07038784" + "e0008000 38002000 00e00702 a0f837ac" + "11843410 20f94022 4b64c550 50e7c471" + "e31cf986 3ca16070 387813fa 000000fe" + "80000003 801c0a83 e09eb046 10d04083" + "e500892d 93"; + uint8_t radio[TEST8_RADIO_SIZE]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_UERadioCapability; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UERadioCapability; + + UERadioCapability = &ie->value.choice.UERadioCapability; + + ogs_assert(UERadioCapability); + OGS_HEX(radio_string, strlen(radio_string), radio); + ogs_s1ap_buffer_to_OCTET_STRING( + radio, TEST8_RADIO_SIZE, UERadioCapability); + } + + { + const char *masked_string = + "86740905 00ffff03"; + uint8_t masked[8]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_Masked_IMEISV; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_Masked_IMEISV; + + Masked_IMEISV = &ie->value.choice.Masked_IMEISV; + + Masked_IMEISV->size = 8; + Masked_IMEISV->buf = CALLOC(Masked_IMEISV->size, sizeof(uint8_t)); + Masked_IMEISV->bits_unused = 0; + OGS_HEX(masked_string, strlen(masked_string), masked); + memcpy(Masked_IMEISV->buf, masked, Masked_IMEISV->size); + } + { + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_NRUESecurityCapabilities; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = S1AP_InitialContextSetupRequestIEs__value_PR_NRUESecurityCapabilities; + + NRUESecurityCapabilities = &ie->value.choice.NRUESecurityCapabilities; + + NRUESecurityCapabilities->nRencryptionAlgorithms.size = 2; + NRUESecurityCapabilities->nRencryptionAlgorithms.buf = + CALLOC(NRUESecurityCapabilities->nRencryptionAlgorithms.size, + sizeof(uint8_t)); + NRUESecurityCapabilities->nRencryptionAlgorithms.bits_unused = 0; + NRUESecurityCapabilities->nRencryptionAlgorithms.buf[0] = 0xe0; + + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.size = 2; + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf = + CALLOC(NRUESecurityCapabilities-> + nRintegrityProtectionAlgorithms.size, sizeof(uint8_t)); + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms. + bits_unused = 0; + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf[0] = + 0xe0; + } + + s1apbuf = ogs_s1ap_encode(&pdu); + ogs_assert(s1apbuf); + ogs_pkbuf_free(s1apbuf); +} + +static void s1ap_message_test9(abts_case *tc, void *data) +{ + int rv; + ogs_pkbuf_t *s1apbuf = NULL; + + S1AP_S1AP_PDU_t pdu; + S1AP_InitiatingMessage_t *initiatingMessage = NULL; + S1AP_InitialContextSetupRequest_t *InitialContextSetupRequest = NULL; + + S1AP_InitialContextSetupRequestIEs_t *ie = NULL; + S1AP_MME_UE_S1AP_ID_t *MME_UE_S1AP_ID = NULL; + S1AP_ENB_UE_S1AP_ID_t *ENB_UE_S1AP_ID = NULL; + S1AP_UEAggregateMaximumBitrate_t *UEAggregateMaximumBitrate = NULL; + S1AP_E_RABToBeSetupListCtxtSUReq_t *E_RABToBeSetupListCtxtSUReq = NULL; + S1AP_UESecurityCapabilities_t *UESecurityCapabilities = NULL; + S1AP_SecurityKey_t *SecurityKey = NULL; + S1AP_Masked_IMEISV_t *Masked_IMEISV = NULL; + S1AP_NRUESecurityCapabilities_t *NRUESecurityCapabilities = NULL; + + memset(&pdu, 0, sizeof (S1AP_S1AP_PDU_t)); + pdu.present = S1AP_S1AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = CALLOC(1, sizeof(S1AP_InitiatingMessage_t)); + + initiatingMessage = pdu.choice.initiatingMessage; + initiatingMessage->procedureCode = + S1AP_ProcedureCode_id_InitialContextSetup; + initiatingMessage->criticality = S1AP_Criticality_reject; + initiatingMessage->value.present = + S1AP_InitiatingMessage__value_PR_InitialContextSetupRequest; + + InitialContextSetupRequest = + &initiatingMessage->value.choice.InitialContextSetupRequest; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_MME_UE_S1AP_ID; + + MME_UE_S1AP_ID = &ie->value.choice.MME_UE_S1AP_ID; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_ENB_UE_S1AP_ID; + + ENB_UE_S1AP_ID = &ie->value.choice.ENB_UE_S1AP_ID; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_uEaggregateMaximumBitrate; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UEAggregateMaximumBitrate; + + UEAggregateMaximumBitrate = &ie->value.choice.UEAggregateMaximumBitrate; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_E_RABToBeSetupListCtxtSUReq; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_E_RABToBeSetupListCtxtSUReq; + + E_RABToBeSetupListCtxtSUReq = &ie->value.choice.E_RABToBeSetupListCtxtSUReq; + + *MME_UE_S1AP_ID = 205; + *ENB_UE_S1AP_ID = 5888; + + asn_uint642INTEGER( + &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateUL, + 1073741824); + asn_uint642INTEGER( + &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateDL, + 1073741824); + + { + S1AP_E_RABToBeSetupItemCtxtSUReqIEs_t *item = NULL; + S1AP_E_RABToBeSetupItemCtxtSUReq_t *e_rab = NULL; + + item = CALLOC(1, sizeof(S1AP_E_RABToBeSetupItemCtxtSUReqIEs_t)); + ASN_SEQUENCE_ADD(&E_RABToBeSetupListCtxtSUReq->list, item); + + item->id = S1AP_ProtocolIE_ID_id_E_RABToBeSetupItemCtxtSUReq; + item->criticality = S1AP_Criticality_reject; + item->value.present = S1AP_E_RABToBeSetupItemCtxtSUReqIEs__value_PR_E_RABToBeSetupItemCtxtSUReq; + + e_rab = &item->value.choice.E_RABToBeSetupItemCtxtSUReq; + + e_rab->e_RAB_ID = 5; + e_rab->e_RABlevelQoSParameters.qCI = 9; + + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + priorityLevel = 8; + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + pre_emptionCapability = 1; + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + pre_emptionVulnerability = 1; + + ogs_ip_t sgw_s1u_ip; + memset(&sgw_s1u_ip, 0, sizeof(sgw_s1u_ip)); + sgw_s1u_ip.ipv4 = 1; + sgw_s1u_ip.addr = inet_addr("10.11.2.6"); + + rv = ogs_asn_ip_to_BIT_STRING( + &sgw_s1u_ip, &e_rab->transportLayerAddress); + ogs_assert(rv == OGS_OK); + ogs_asn_uint32_to_OCTET_STRING( + 4400, &e_rab->gTP_TEID); + } + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_UESecurityCapabilities; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UESecurityCapabilities; + + UESecurityCapabilities = &ie->value.choice.UESecurityCapabilities; + + UESecurityCapabilities->encryptionAlgorithms.size = 2; + UESecurityCapabilities->encryptionAlgorithms.buf = + CALLOC(UESecurityCapabilities->encryptionAlgorithms.size, + sizeof(uint8_t)); + UESecurityCapabilities->encryptionAlgorithms.bits_unused = 0; + UESecurityCapabilities->encryptionAlgorithms.buf[0] = 0xe0; + + UESecurityCapabilities->integrityProtectionAlgorithms.size = 2; + UESecurityCapabilities->integrityProtectionAlgorithms.buf = + CALLOC(UESecurityCapabilities-> + integrityProtectionAlgorithms.size, sizeof(uint8_t)); + UESecurityCapabilities->integrityProtectionAlgorithms.bits_unused = 0; + UESecurityCapabilities->integrityProtectionAlgorithms.buf[0] = 0xe0; + + { + const char *kenb_string = + "1dacef4b 77ca2953 0b9f2076 1125181b" + "11596aba 6a8c38be 2a4e0ead 9fdf2c67"; + uint8_t kenb[32]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_SecurityKey; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_SecurityKey; + + SecurityKey = &ie->value.choice.SecurityKey; + + SecurityKey->size = 32; + SecurityKey->buf = CALLOC(SecurityKey->size, sizeof(uint8_t)); + SecurityKey->bits_unused = 0; + OGS_HEX(kenb_string, strlen(kenb_string), kenb); + memcpy(SecurityKey->buf, kenb, SecurityKey->size); + } + + { + /* Set UeRadioCapability if exists */ + S1AP_UERadioCapability_t *UERadioCapability = NULL; + const char *radio_string = +#define TEST9_RADIO_SIZE 2149 + "04537803 086e5ddb 8050e6c1 073e9c02" + "80818892 26954aa1 c3bfff8e fffe3bff" + "f8efffe3 bfff8eff fe3bfff8 efffe3bf" + "ff8efffe 3bfff8ef ffe3bfff 8efffe3b" + "fffbf06e c4f00141 bc08cc80 0000002a" + "77c00000 00bfe801 20060060 05002200" + "60060060 80304012 08030401 8200c100" + "60843003 04018200 c1086084 30421821" + "0c108608 43040182 00c10860 84304018" + "200c1086 08430420 82104108 20840410" + "06080304 018200c1 08208430 4218210c" + "10860843 00304218 210c1086 08430401" + "8200c108 60843040 18200c10 86006084" + "30030401 8200c108 60060841 04208400" + "86100218 200c1006 10001840 00610001" + "84000610 00184000 61002184 00861002" + "18400861 00218400 86080304 01840086" + "10021840 08610021 84008610 02184008" + "60803040 18200c20 80308200 c2080308" + "010c2004 308010c2 08030820 0c208030" + "8010c200 4308010c 20803082 00c20841" + "08210420 00308000 c2000308 010c2004" + "30025a07 d5467208 0fe06d80 02001840" + "00820638 002000be 1000e700 04103000" + "01040e80 00410310 001000c6 00041034" + "4001000d 20004003 4c001000 e5000410" + "3a400104 0ea00041 076c0010 1082082b" + "61030800 1041db00 04047080 0ad840c7" + "00040076 c0010118 2082b610 31800104" + "1db00040 400820ad 840c0000 41070800" + "10508208 18400092 0e380020 21041051" + "c2061000 2082be10 70800104 1e800041" + "420820b4 041c2000 41059c20 e1000208" + "3ca00082 84104165 08384000 820e9800" + "20210410 54c20610 0020838c 00082841" + "04146083 84000820 e2000202 10410510" + "20610002 08384000 82801041 42083800" + "00820f40 0020a384 005a020e 38002003" + "ca000828 e1001650 838e0008 00e98002" + "02384005 4c206380 020038e0 00808c10" + "41470818 c000820e 38002020 041051c2" + "06000020 82be1074 c0010015 f0838c00" + "0820af84 1c000041 079c0010 59c2083c" + "e000828c 10416708 38c00082 07380024" + "83d00008 28010416 80838000 0820f280" + "020a0041 059420e0 0002083a 60008080" + "10415308 18000082 0e300020 a0041051" + "820e0000 20838800 08080104 14408180" + "000820e0 00020a00 41030000 1241e800" + "04168082 07400024 83a60008 08c10415" + "30818c00 0820e300 020a3041 03180012" + "41e50004 1530800b 2841d300 0400b6c0" + "01010820 a1041096 c2061000 20a10410" + "76c00101 082482b6 10308001 242db000" + "40470808 410425b0 818e0008 08410425" + "b0808e10 30800104 2db00040 47080801" + "0425b081 8e000808 010425b0 808e1030" + "0001042d b0004046 08284104 25b0818c" + "00082841 0425b080 8c107080 01042db0" + "00404608 28010425 b0818c00 08280104" + "25b0808c 10700001 041db000 40460920" + "ad840c60 00490b6c 00101082 0a004109" + "6c206100 020a0041 096c2021 041c0000" + "410b6c00 1010020a 0041096c 20600002" + "0a00410b 1c001010 820a1041 091c2061" + "00020a10 41071c00 10108248 28e10308" + "0012415f 08184000 92174000 20a38404" + "20821340 41c70004 04208213 40414708" + "18400082 17400020 21041400 82134040" + "c2000414 00821340 40420838 00008217" + "280020a3 84042082 132841c7 00040420" + "82132841 47081840 00821728 00202104" + "14008213 2840c200 04140082 13284042" + "08380000 8212f841 d3000404 208212f8" + "41530818 40008212 f841c200 04140080" + "12f84142 08380000 80169800 20238404" + "20821298 40c70004 04208212 98404708" + "18400082 16980020 23041420 82129840" + "c6000414 20820610 0824ff1d fffc77ff" + "f1dfffc7 7fff1dff fc77fff1 dfffc77f" + "ff1dfffc 77fff1df ffc77fff 1dfffc77" + "fff1dfff c77fff1d fffc77ff f1dfffc7" + "7fff1dff fc77fff1 dfffc77f ff1dfffc" + "77fff1df ffc77fff 1dfffc77 fff1dfff" + "c77fff1d fffc77ff f1dfffc7 7fff1dff" + "fc77fff1 dfffc77f ff1dfffc 77fff1df" + "ffc77fff 1dfffc77 fff1dfff c77fff1d" + "fffc77ff f1dfffc7 7fff1dff fc77fff1" + "dfffc77f ff1dfffc 77fff1df ffc77fff" + "1dfffc77 fff1dfff c77fff1d fffc77ff" + "f1dfffc7 7fff1dff fc77fff1 dfffc77f" + "ff1dfffc 77fff1df ffc77fff 1dfffc77" + "fff1dfff c77fff1d fffc77ff f1dfffc7" + "7fff1dff fc77fff1 dfffc77f ff1dfffc" + "77fff1df ffc77fff 1dfffc77 fff1dfff" + "c77fff1d fffc77ff f1dfffc7 7fff1dff" + "fc77fff1 dfffc77f ff1dfffc 77fff1df" + "ffc77fff 1dfffc77 fff1dfff c77fff1d" + "fffc77ff f1dfffc7 7fff1dff fc77fff1" + "dfffc77f ff1dfffc 77fff1df ffc77fff" + "1dfffc77 fff1dfff c77fff7c e800008f" + "f8000878 721e1e1e 1e2e8fe3 f43c3c39" + "0f0f0f0f 27e4fc3c 3c3c3917 8bc5e2f1" + "78bc390e 43c3c384 3c3c3c3a 1e1e3f8b" + "c5e3f8b8 0008bc5e 2f0f0e08 78700000" + "21e1cfc1 004800f9 95e68100 5277ffff" + "fff9a52e f1c03a00 16080045 24000080" + "014412e7 81800004 0200c038 260d84a1" + "38502609 a273c080 04100000 00a32000" + "00008004 00208600 30300000 80401807" + "04c1b094 270a04c1 344e1005 8345e9a0" + "1000074f 5a130200 02014048 24c58002" + "60d40c13 601873e6 18f28581 c130080c" + "47032a0d 89dac118 4341020f 94022cb6" + "4c550d0e 7c471e81 9f604f8c 73e618f2" + "8581c0e1 e0b80007 800e0001 e0003801" + "c0a83626 eb04610d 04083e50 08b2d931" + "543439f1 1c7a067d 813e31cf 9863ca16" + "07038782 e000be00 38002f80 00e40700" + "1b280002 800002a0 d899ac11 84341020" + "f94022cb 64c550d0 e7c471e8 19f604f8" + "c73e618f 28581c0e 1e0b8002 7800e000" + "9e000380 1c0e8361 4606b046 10d04083" + "e5008b2d 93154343 9f11c7a0 67d813e3" + "1cf9863c a1607038 782e000b e0038002" + "f8000e00 702a0d84 fac11843 41020f94" + "022cb64c 550d0e7c 471e819f 604f8c73" + "e618f285 81c0e1e1 38002f80 0e000be0" + "003801c0 a83612eb 04610d04 083e5008" + "b2d93154 3439f11c 7a067d81 3e31cf98" + "63ca1607 038784e0 00800038 00200000" + "e00702a0 f837ac11 84341020 f940224b" + "64c55050 e7c471e3 1cf9863c a1607038" + "7813fa00 0000fe80 00000380 1c0a83e0" + "9eb04610 d0"; + uint8_t radio[TEST9_RADIO_SIZE]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_UERadioCapability; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UERadioCapability; + + UERadioCapability = &ie->value.choice.UERadioCapability; + + ogs_assert(UERadioCapability); + OGS_HEX(radio_string, strlen(radio_string), radio); + ogs_s1ap_buffer_to_OCTET_STRING( + radio, TEST9_RADIO_SIZE, UERadioCapability); + } + + { + const char *masked_string = + "86740905 00ffff03"; + uint8_t masked[8]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_Masked_IMEISV; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_Masked_IMEISV; + + Masked_IMEISV = &ie->value.choice.Masked_IMEISV; + + Masked_IMEISV->size = 8; + Masked_IMEISV->buf = CALLOC(Masked_IMEISV->size, sizeof(uint8_t)); + Masked_IMEISV->bits_unused = 0; + OGS_HEX(masked_string, strlen(masked_string), masked); + memcpy(Masked_IMEISV->buf, masked, Masked_IMEISV->size); + } + { + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_NRUESecurityCapabilities; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = S1AP_InitialContextSetupRequestIEs__value_PR_NRUESecurityCapabilities; + + NRUESecurityCapabilities = &ie->value.choice.NRUESecurityCapabilities; + + NRUESecurityCapabilities->nRencryptionAlgorithms.size = 2; + NRUESecurityCapabilities->nRencryptionAlgorithms.buf = + CALLOC(NRUESecurityCapabilities->nRencryptionAlgorithms.size, + sizeof(uint8_t)); + NRUESecurityCapabilities->nRencryptionAlgorithms.bits_unused = 0; + NRUESecurityCapabilities->nRencryptionAlgorithms.buf[0] = 0xe0; + + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.size = 2; + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf = + CALLOC(NRUESecurityCapabilities-> + nRintegrityProtectionAlgorithms.size, sizeof(uint8_t)); + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms. + bits_unused = 0; + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf[0] = + 0xe0; + } + + s1apbuf = ogs_s1ap_encode(&pdu); + ogs_assert(s1apbuf); + ogs_pkbuf_free(s1apbuf); +} + +static void s1ap_message_test10(abts_case *tc, void *data) +{ + int rv; + ogs_pkbuf_t *s1apbuf = NULL; + + S1AP_S1AP_PDU_t pdu; + S1AP_InitiatingMessage_t *initiatingMessage = NULL; + S1AP_InitialContextSetupRequest_t *InitialContextSetupRequest = NULL; + + S1AP_InitialContextSetupRequestIEs_t *ie = NULL; + S1AP_MME_UE_S1AP_ID_t *MME_UE_S1AP_ID = NULL; + S1AP_ENB_UE_S1AP_ID_t *ENB_UE_S1AP_ID = NULL; + S1AP_UEAggregateMaximumBitrate_t *UEAggregateMaximumBitrate = NULL; + S1AP_E_RABToBeSetupListCtxtSUReq_t *E_RABToBeSetupListCtxtSUReq = NULL; + S1AP_UESecurityCapabilities_t *UESecurityCapabilities = NULL; + S1AP_SecurityKey_t *SecurityKey = NULL; + S1AP_Masked_IMEISV_t *Masked_IMEISV = NULL; + S1AP_NRUESecurityCapabilities_t *NRUESecurityCapabilities = NULL; + + memset(&pdu, 0, sizeof (S1AP_S1AP_PDU_t)); + pdu.present = S1AP_S1AP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage = CALLOC(1, sizeof(S1AP_InitiatingMessage_t)); + + initiatingMessage = pdu.choice.initiatingMessage; + initiatingMessage->procedureCode = + S1AP_ProcedureCode_id_InitialContextSetup; + initiatingMessage->criticality = S1AP_Criticality_reject; + initiatingMessage->value.present = + S1AP_InitiatingMessage__value_PR_InitialContextSetupRequest; + + InitialContextSetupRequest = + &initiatingMessage->value.choice.InitialContextSetupRequest; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_MME_UE_S1AP_ID; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_MME_UE_S1AP_ID; + + MME_UE_S1AP_ID = &ie->value.choice.MME_UE_S1AP_ID; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_eNB_UE_S1AP_ID; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_ENB_UE_S1AP_ID; + + ENB_UE_S1AP_ID = &ie->value.choice.ENB_UE_S1AP_ID; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_uEaggregateMaximumBitrate; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UEAggregateMaximumBitrate; + + UEAggregateMaximumBitrate = &ie->value.choice.UEAggregateMaximumBitrate; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_E_RABToBeSetupListCtxtSUReq; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_E_RABToBeSetupListCtxtSUReq; + + E_RABToBeSetupListCtxtSUReq = &ie->value.choice.E_RABToBeSetupListCtxtSUReq; + + *MME_UE_S1AP_ID = 205; + *ENB_UE_S1AP_ID = 5888; + + asn_uint642INTEGER( + &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateUL, + 1073741824); + asn_uint642INTEGER( + &UEAggregateMaximumBitrate->uEaggregateMaximumBitRateDL, + 1073741824); + + { + S1AP_E_RABToBeSetupItemCtxtSUReqIEs_t *item = NULL; + S1AP_E_RABToBeSetupItemCtxtSUReq_t *e_rab = NULL; + + item = CALLOC(1, sizeof(S1AP_E_RABToBeSetupItemCtxtSUReqIEs_t)); + ASN_SEQUENCE_ADD(&E_RABToBeSetupListCtxtSUReq->list, item); + + item->id = S1AP_ProtocolIE_ID_id_E_RABToBeSetupItemCtxtSUReq; + item->criticality = S1AP_Criticality_reject; + item->value.present = S1AP_E_RABToBeSetupItemCtxtSUReqIEs__value_PR_E_RABToBeSetupItemCtxtSUReq; + + e_rab = &item->value.choice.E_RABToBeSetupItemCtxtSUReq; + + e_rab->e_RAB_ID = 5; + e_rab->e_RABlevelQoSParameters.qCI = 9; + + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + priorityLevel = 8; + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + pre_emptionCapability = 1; + e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. + pre_emptionVulnerability = 1; + + ogs_ip_t sgw_s1u_ip; + memset(&sgw_s1u_ip, 0, sizeof(sgw_s1u_ip)); + sgw_s1u_ip.ipv4 = 1; + sgw_s1u_ip.addr = inet_addr("10.11.2.6"); + + rv = ogs_asn_ip_to_BIT_STRING( + &sgw_s1u_ip, &e_rab->transportLayerAddress); + ogs_assert(rv == OGS_OK); + ogs_asn_uint32_to_OCTET_STRING( + 4400, &e_rab->gTP_TEID); + } + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_UESecurityCapabilities; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UESecurityCapabilities; + + UESecurityCapabilities = &ie->value.choice.UESecurityCapabilities; + + UESecurityCapabilities->encryptionAlgorithms.size = 2; + UESecurityCapabilities->encryptionAlgorithms.buf = + CALLOC(UESecurityCapabilities->encryptionAlgorithms.size, + sizeof(uint8_t)); + UESecurityCapabilities->encryptionAlgorithms.bits_unused = 0; + UESecurityCapabilities->encryptionAlgorithms.buf[0] = 0xe0; + + UESecurityCapabilities->integrityProtectionAlgorithms.size = 2; + UESecurityCapabilities->integrityProtectionAlgorithms.buf = + CALLOC(UESecurityCapabilities-> + integrityProtectionAlgorithms.size, sizeof(uint8_t)); + UESecurityCapabilities->integrityProtectionAlgorithms.bits_unused = 0; + UESecurityCapabilities->integrityProtectionAlgorithms.buf[0] = 0xe0; + + { + const char *kenb_string = + "e9cb2fcf 24cf962c c04ead05 519eed52" + "bf2279a2 0b63f2fa fb515915 82b1e774"; + uint8_t kenb[32]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_SecurityKey; + ie->criticality = S1AP_Criticality_reject; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_SecurityKey; + + SecurityKey = &ie->value.choice.SecurityKey; + + SecurityKey->size = 32; + SecurityKey->buf = CALLOC(SecurityKey->size, sizeof(uint8_t)); + SecurityKey->bits_unused = 0; + OGS_HEX(kenb_string, strlen(kenb_string), kenb); + memcpy(SecurityKey->buf, kenb, SecurityKey->size); + } + + { + /* Set UeRadioCapability if exists */ + S1AP_UERadioCapability_t *UERadioCapability = NULL; + const char *radio_string = +#define TEST10_RADIO_SIZE 2674 + "04537803 086e5ddb 8050e6c1 073e9c02" + "80818892 26954aa1 c3bfff8e fffe3bff" + "f8efffe3 bfff8eff fe3bfff8 efffe3bf" + "ff8efffe 3bfff8ef ffe3bfff 8efffe3b" + "fffbf06e c4f00141 bc08cc80 0000002a" + "77c00000 00bfe801 20060060 05002200" + "60060060 80304012 08030401 8200c100" + "60843003 04018200 c1086084 30421821" + "0c108608 43040182 00c10860 84304018" + "200c1086 08430420 82104108 20840410" + "06080304 018200c1 08208430 4218210c" + "10860843 00304218 210c1086 08430401" + "8200c108 60843040 18200c10 86006084" + "30030401 8200c108 60060841 04208400" + "86100218 200c1006 10001840 00610001" + "84000610 00184000 61002184 00861002" + "18400861 00218400 86080304 01840086" + "10021840 08610021 84008610 02184008" + "60803040 18200c20 80308200 c2080308" + "010c2004 308010c2 08030820 0c208030" + "8010c200 4308010c 20803082 00c20841" + "08210420 00308000 c2000308 010c2004" + "30025a07 d5467208 0fe06d80 02001840" + "00820638 002000be 1000e700 04103000" + "01040e80 00410310 001000c6 00041034" + "4001000d 20004003 4c001000 e5000410" + "3a400104 0ea00041 076c0010 1082082b" + "61030800 1041db00 04047080 0ad840c7" + "00040076 c0010118 2082b610 31800104" + "1db00040 400820ad 840c0000 41070800" + "10508208 18400092 0e380020 21041051" + "c2061000 2082be10 70800104 1e800041" + "420820b4 041c2000 41059c20 e1000208" + "3ca00082 84104165 08384000 820e9800" + "20210410 54c20610 0020838c 00082841" + "04146083 84000820 e2000202 10410510" + "20610002 08384000 82801041 42083800" + "00820f40 0020a384 005a020e 38002003" + "ca000828 e1001650 838e0008 00e98002" + "02384005 4c206380 020038e0 00808c10" + "41470818 c000820e 38002020 041051c2" + "06000020 82be1074 c0010015 f0838c00" + "0820af84 1c000041 079c0010 59c2083c" + "e000828c 10416708 38c00082 07380024" + "83d00008 28010416 80838000 0820f280" + "020a0041 059420e0 0002083a 60008080" + "10415308 18000082 0e300020 a0041051" + "820e0000 20838800 08080104 14408180" + "000820e0 00020a00 41030000 1241e800" + "04168082 07400024 83a60008 08c10415" + "30818c00 0820e300 020a3041 03180012" + "41e50004 1530800b 2841d300 0400b6c0" + "01010820 a1041096 c2061000 20a10410" + "76c00101 082482b6 10308001 242db000" + "40470808 410425b0 818e0008 08410425" + "b0808e10 30800104 2db00040 47080801" + "0425b081 8e000808 010425b0 808e1030" + "0001042d b0004046 08284104 25b0818c" + "00082841 0425b080 8c107080 01042db0" + "00404608 28010425 b0818c00 08280104" + "25b0808c 10700001 041db000 40460920" + "ad840c60 00490b6c 00101082 0a004109" + "6c206100 020a0041 096c2021 041c0000" + "410b6c00 1010020a 0041096c 20600002" + "0a00410b 1c001010 820a1041 091c2061" + "00020a10 41071c00 10108248 28e10308" + "0012415f 08184000 92174000 20a38404" + "20821340 41c70004 04208213 40414708" + "18400082 17400020 21041400 82134040" + "c2000414 00821340 40420838 00008217" + "280020a3 84042082 132841c7 00040420" + "82132841 47081840 00821728 00202104" + "14008213 2840c200 04140082 13284042" + "08380000 8212f841 d3000404 208212f8" + "41530818 40008212 f841c200 04140080" + "12f84142 08380000 80169800 20238404" + "20821298 40c70004 04208212 98404708" + "18400082 16980020 23041420 82129840" + "c6000414 20820610 0824ff1d fffc77ff" + "f1dfffc7 7fff1dff fc77fff1 dfffc77f" + "ff1dfffc 77fff1df ffc77fff 1dfffc77" + "fff1dfff c77fff1d fffc77ff f1dfffc7" + "7fff1dff fc77fff1 dfffc77f ff1dfffc" + "77fff1df ffc77fff 1dfffc77 fff1dfff" + "c77fff1d fffc77ff f1dfffc7 7fff1dff" + "fc77fff1 dfffc77f ff1dfffc 77fff1df" + "ffc77fff 1dfffc77 fff1dfff c77fff1d" + "fffc77ff f1dfffc7 7fff1dff fc77fff1" + "dfffc77f ff1dfffc 77fff1df ffc77fff" + "1dfffc77 fff1dfff c77fff1d fffc77ff" + "f1dfffc7 7fff1dff fc77fff1 dfffc77f" + "ff1dfffc 77fff1df ffc77fff 1dfffc77" + "fff1dfff c77fff1d fffc77ff f1dfffc7" + "7fff1dff fc77fff1 dfffc77f ff1dfffc" + "77fff1df ffc77fff 1dfffc77 fff1dfff" + "c77fff1d fffc77ff f1dfffc7 7fff1dff" + "fc77fff1 dfffc77f ff1dfffc 77fff1df" + "ffc77fff 1dfffc77 fff1dfff c77fff1d" + "fffc77ff f1dfffc7 7fff1dff fc77fff1" + "dfffc77f ff1dfffc 77fff1df ffc77fff" + "1dfffc77 fff1dfff c77fff7c e800008f" + "f8000878 721e1e1e 1e2e8fe3 f43c3c39" + "0f0f0f0f 27e4fc3c 3c3c3917 8bc5e2f1" + "78bc390e 43c3c384 3c3c3c3a 1e1e3f8b" + "c5e3f8b8 0008bc5e 2f0f0e08 78700000" + "21e1cfc1 004800f9 95e68100 5277ffff" + "fff9a52e f1c03a00 16080045 24000080" + "014412e7 81800004 0200c038 260d84a1" + "38502609 a273c080 04100000 00a32000" + "00008004 00208600 30300000 80401807" + "04c1b094 270a04c1 344e1005 8345e9a0" + "1000074f 5a130200 02014048 24c58002" + "60d40c13 601873e6 18f28581 c130080c" + "47032a0d 89dac118 4341020f 94022cb6" + "4c550d0e 7c471e81 9f604f8c 73e618f2" + "8581c0e1 e0b80007 800e0001 e0003801" + "c0a83626 eb04610d 04083e50 08b2d931" + "543439f1 1c7a067d 813e31cf 9863ca16" + "07038782 e000be00 38002f80 00e40700" + "1b280002 800002a0 d899ac11 84341020" + "f94022cb 64c550d0 e7c471e8 19f604f8" + "c73e618f 28581c0e 1e0b8002 7800e000" + "9e000380 1c0e8361 4606b046 10d04083" + "e5008b2d 93154343 9f11c7a0 67d813e3" + "1cf9863c a1607038 782e000b e0038002" + "f8000e00 702a0d84 fac11843 41020f94" + "022cb64c 550d0e7c 471e819f 604f8c73" + "e618f285 81c0e1e1 38002f80 0e000be0" + "003801c0 a83612eb 04610d04 083e5008" + "b2d93154 3439f11c 7a067d81 3e31cf98" + "63ca1607 038784e0 00800038 00200000" + "e00702a0 f837ac11 84341020 f940224b" + "64c55050 e7c471e3 1cf9863c a1607038" + "7813fa00 0000fe80 00000380 1c0a83e0" + "9eb04610 d0"; + uint8_t radio[TEST10_RADIO_SIZE]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_UERadioCapability; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_UERadioCapability; + + UERadioCapability = &ie->value.choice.UERadioCapability; + + ogs_assert(UERadioCapability); + OGS_HEX(radio_string, strlen(radio_string), radio); + ogs_s1ap_buffer_to_OCTET_STRING( + radio, TEST10_RADIO_SIZE, UERadioCapability); + } + + { + const char *masked_string = + "35514310 00ffff07"; + uint8_t masked[8]; + + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_Masked_IMEISV; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = + S1AP_InitialContextSetupRequestIEs__value_PR_Masked_IMEISV; + + Masked_IMEISV = &ie->value.choice.Masked_IMEISV; + + Masked_IMEISV->size = 8; + Masked_IMEISV->buf = CALLOC(Masked_IMEISV->size, sizeof(uint8_t)); + Masked_IMEISV->bits_unused = 0; + OGS_HEX(masked_string, strlen(masked_string), masked); + memcpy(Masked_IMEISV->buf, masked, Masked_IMEISV->size); + } + { + ie = CALLOC(1, sizeof(S1AP_InitialContextSetupRequestIEs_t)); + ASN_SEQUENCE_ADD(&InitialContextSetupRequest->protocolIEs, ie); + + ie->id = S1AP_ProtocolIE_ID_id_NRUESecurityCapabilities; + ie->criticality = S1AP_Criticality_ignore; + ie->value.present = S1AP_InitialContextSetupRequestIEs__value_PR_NRUESecurityCapabilities; + + NRUESecurityCapabilities = &ie->value.choice.NRUESecurityCapabilities; + + NRUESecurityCapabilities->nRencryptionAlgorithms.size = 2; + NRUESecurityCapabilities->nRencryptionAlgorithms.buf = + CALLOC(NRUESecurityCapabilities->nRencryptionAlgorithms.size, + sizeof(uint8_t)); + NRUESecurityCapabilities->nRencryptionAlgorithms.bits_unused = 0; + NRUESecurityCapabilities->nRencryptionAlgorithms.buf[0] = 0xe0; + + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.size = 2; + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf = + CALLOC(NRUESecurityCapabilities-> + nRintegrityProtectionAlgorithms.size, sizeof(uint8_t)); + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms. + bits_unused = 0; + NRUESecurityCapabilities->nRintegrityProtectionAlgorithms.buf[0] = + 0xe0; + } + + s1apbuf = ogs_s1ap_encode(&pdu); + ogs_assert(s1apbuf); + ogs_pkbuf_free(s1apbuf); +} + abts_suite *test_s1ap_message(abts_suite *suite) { suite = ADD_SUITE(suite) @@ -290,11 +1339,9 @@ abts_suite *test_s1ap_message(abts_suite *suite) abts_run_test(suite, s1ap_message_test1, NULL); abts_run_test(suite, s1ap_message_test2, NULL); abts_run_test(suite, s1ap_message_test3, NULL); -#if 0 /* Will remove it in order not to use mme-context.h */ abts_run_test(suite, s1ap_message_test4, NULL); abts_run_test(suite, s1ap_message_test5, NULL); abts_run_test(suite, s1ap_message_test6, NULL); -#endif abts_run_test(suite, s1ap_message_test7, NULL); abts_run_test(suite, s1ap_message_test8, NULL); abts_run_test(suite, s1ap_message_test9, NULL);