def test_attach_detach_disconnect_default_pdn(self): """ Attach a single UE and send PDN disconnect request for the default bearer """ num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print( "************************* Running End to End attach for UE id ", ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() time.sleep(5) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = 5 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req, ) # Receive PDN Disconnect Reject response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REJ.value, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_secondary_pdn_conn_ded_bearer_looped(self): """ Attach a single UE and send standalone PDN Connectivity Request + add dedicated bearer to each default bearer repeat 3 times """ num_ues = 1 loop = 3 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list) print( "********************* Running End to End attach for UE id ", ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() for j in range(loop): print("********************* Iteration - ", j + 1) # Send PDN Connectivity Request print("********************* Sending PDN Connectivity Req") apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context req response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "********************** Sending Activate default EPS " "bearer context accept for UE id ", ue_id, ) # Add dedicated bearer to 2nd PDN print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value, ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId) time.sleep(5) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print("*************** Received deactivate eps bearer context" " request") # Send DeactDedicatedBearerAccept deactv_bearer_req = response.cast( s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId) time.sleep(5) print( "******************** Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_seconday_pdn_conn_ded_bearer(self): """ Attach a single UE and send standalone PDN Connectivity Request + add dedicated bearer to each default bearer """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print( "********************* Running End to End attach for UE id ", ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Add dedicated bearer for default bearer 5 print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), 5 ) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue( response, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId ) time.sleep(5) # Send PDN Connectivity Request apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) # Add dedicated bearer to 2nd PDN print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue( response, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId ) time.sleep(5) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue( response, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value ) print( "******************* Received deactivate eps bearer context" " request" ) # Send DeactDedicatedBearerAccept deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId ) print( "******************** Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_outoforder_erab_setup_rsp_default_bearer(self): """ Attach a single UE and send erab setup rsp message out of order for the secondary pdn""" num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list, ) print( "************************* Running End to End attach for UE id ", ue_id, ) # Attach attach = self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() addr = attach.esmInfo.pAddr.addrInfo default_ip = ipaddress.ip_address(bytes(addr[:4])) # Send indication to delay sending of erab setup rsp delay_erab_setup_resp = s1ap_types.UeDelayErabSetupRsp() delay_erab_setup_resp.ue_Id = ue_id delay_erab_setup_resp.flag = 1 # Timer value in secs to delay erab setup rsp delay_erab_setup_resp.tmrVal = 6000 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SET_DELAY_ERAB_SETUP_RSP, delay_erab_setup_resp, ) print( "Sent UE_SET_DELAY_ERAB_SETUP_RSP with delay value of %d secs" % (delay_erab_setup_resp.tmrVal), ) # Send PDN Connectivity Request apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ip = ipaddress.ip_address(bytes(addr[:4])) print( "************************* Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) # Delay to ensure erab setup rsp is sent out of order print("Sleeping for 10 seconds") time.sleep(10) dl_flow_rules = { default_ip: [], sec_ip: [], } # default bearer + ims bearer num_ul_flows = 2 # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req, ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print( "******************* Received deactivate eps bearer context" " request", ) # Send DeactDedicatedBearerAccept deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, deactv_bearer_req.bearerId, ) print( "************************* Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_seconday_pdn_conn_req_multi_ue(self): """ attach/detach + PDN Connectivity Requests with 4 UEs """ num_ues = 4 ue_ids = [] bearer_ids = [] self._s1ap_wrapper.configUEDevice(num_ues) for _ in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print( "******************* Running End to End attach for UE id ", ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() ue_ids.append(ue_id) self._s1ap_wrapper._ue_idx = 0 for _ in range(num_ues): req = self._s1ap_wrapper.ue_req # Send PDN Connectivity Request apn = "ims" ue_id = req.ue_id self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId) time.sleep(5) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = bearer_ids[i] self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print("******************* Received deactivate eps bearer context" " request") # Send DeactDedicatedBearerAccept self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, bearer_ids[i]) time.sleep(2) # Now detach the UE for ue in ue_ids: print( "******************** Running UE detach (switch-off) for ", "UE id ", ue, ) self._s1ap_wrapper.s1_util.detach( ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_concurrent_secondary_pdn_reject(self): """Attach a single UE and send concurrent standalone PDN Connectivity Requests, verify that the PDN request sent with the APN that is not configured(internet apn) gets rejected """ num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list, ) print( "************************* Running End to End attach for UE id =", ue_id, ) # Attach attach = self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) addr = attach.esmInfo.pAddr.addrInfo default_ip = ipaddress.ip_address(bytes(addr[:4])) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Send PDN Connectivity Request with APN that is not configured apn = "internet" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Send PDN Connectivity Request for ims APN apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN connectivity reject for internet APN response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) # Verify cause pdn_con_rsp = response.cast(s1ap_types.uePdnConRsp_t) self.assertEqual( pdn_con_rsp.m.conRejInfo.cause, s1ap_types.TFW_ESM_CAUSE_MISSING_OR_UNKNOWN_APN, ) print( "************************* Received PDN Connectivity " "reject for UE id =", ue_id, ) # Receive PDN CONN RSP/Activate default EPS bearer context # request for ims APN response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "************************* Received Activate default EPS bearer " "context request for UE id=%d, with bearer id=%d " % ( act_def_bearer_req.ue_Id, act_def_bearer_req.m.pdnInfo.epsBearerId, ), ) addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ip = ipaddress.ip_address(bytes(addr[:4])) print( "************************* Sending Activate default EPS bearer " "context accept for UE id =", act_def_bearer_req.ue_Id, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules are created # No dedicated bearers, so flowlist is empty dl_flow_rules = { default_ip: [], sec_ip: [], } # 1 UL flow is created per bearer num_ul_flows = 2 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = act_def_bearer_req.ue_Id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req, ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) print( "******************* Received deactivate eps bearer context" " request for UE id=%d, with bearer id=%d" % (deactv_bearer_req.ue_Id, deactv_bearer_req.bearerId), ) # Send DeactDedicatedBearerAccept self._s1ap_wrapper.sendDeactDedicatedBearerAccept( deactv_bearer_req.ue_Id, deactv_bearer_req.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify that flow rule is deleted for ims secondary pdn dl_flow_rules = { default_ip: [], } # 1 UL flow is created per bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "************************* Running UE detach (switch-off) for ", "UE id =", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, wait_for_s1_ctxt_release=False, )
def test_secondary_pdn_with_dedicated_bearer_multi_ue(self): """ attach/detach + PDN Connectivity Requests + dedicated bearer for 4 UEs """ num_ues = 4 ue_ids = [] bearer_ids = [] self._s1ap_wrapper.configUEDevice(num_ues) for _ in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list) print( "******************* Running End to End attach for UE id ", ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() ue_ids.append(ue_id) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req # Send PDN Connectivity Request apn = "ims" ue_id = req.ue_id self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) print( "********************** Added IMS PDN with bearer id", act_def_bearer_req.m.pdnInfo.epsBearerId, ) bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId) print("********************* Sleeping for 2 seconds") time.sleep(2) # Add dedicated bearer to IMS PDN print("********************** Adding dedicated bearer to IMS PDN") self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId) print( "********************** Added dedicated bearer", act_ded_ber_ctxt_req.bearerId, ) print("********************* Sleeping for 5 seconds") time.sleep(5) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print("******************* Deleting IMS PDN for ue", ue_id) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = bearer_ids[i] self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print("******************* Received deactivate eps bearer context" " request") # Send DeactDedicatedBearerAccept self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, bearer_ids[i]) print( "******************* Deleted IMS PDN with bearer ID", bearer_ids[i], ) print("********************* Sleeping for 5 seconds") time.sleep(2) # Now detach the UE for ue in ue_ids: print( "******************** Running UE detach (switch-off) for ", "UE id ", ue, ) self._s1ap_wrapper.s1_util.detach( ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_attach_service_with_multi_pdns_and_bearers_mt_data(self): """ Attach a UE + add secondary PDN + add 2 dedicated bearers + UE context release + trigger MT data + service request + PDN disconnect + detach """ self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id ips = [] # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list) # UL Flow description #1 ulFlow1 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5002, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # UL Flow description #2 ulFlow2 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5001, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # UL Flow description #3 ulFlow3 = { "ipv4_dst": "192.168.129.64", # IPv4 destination address "tcp_dst_port": 5003, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # UL Flow description #4 ulFlow4 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5001, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # DL Flow description #1 dlFlow1 = { "ipv4_src": "192.168.129.42", # IPv4 source address "tcp_src_port": 5001, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # DL Flow description #2 dlFlow2 = { "ipv4_src": "192.168.129.64", # IPv4 source address "tcp_src_port": 5002, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # DL Flow description #3 dlFlow3 = { "ipv4_src": "192.168.129.64", # IPv4 source address "tcp_src_port": 5003, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # DL Flow description #4 dlFlow4 = { "ipv4_src": "192.168.129.42", # IPv4 source address "tcp_src_port": 5001, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # Flow lists to be configured flow_list1 = [ ulFlow1, ulFlow2, ulFlow3, dlFlow1, dlFlow2, dlFlow3, ] flow_list2 = [ ulFlow4, dlFlow4, ] # QoS qos1 = { "qci": 1, # qci value [1 to 9] "priority": 1, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 1, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } qos2 = { "qci": 2, # qci value [1 to 9] "priority": 5, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 1, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } policy_id1 = "internet" policy_id2 = "ims" print( "************************* Running End to End attach for UE id ", ue_id, ) # Now actually complete the attach attach = self._s1ap_wrapper._s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) addr = attach.esmInfo.pAddr.addrInfo default_ip = ipaddress.ip_address(bytes(addr[:4])) ips.append(default_ip) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Delay to ensure S1APTester sends attach complete before sending UE # context release print("Sleeping for 5 seconds") time.sleep(5) # Add dedicated bearer for default bearer 5 print("********************** Adding dedicated bearer to magma.ipv4" " PDN") print( "********************** Sending RAR for IMSI", "".join([str(i) for i in req.imsi]), ) self._sessionManager_util.create_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id1, flow_list1, qos1, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value) act_ded_ber_req_oai_apn = response.cast( s1ap_types.UeActDedBearCtxtReq_t) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_req_oai_apn.bearerId) print("Sleeping for 5 seconds") time.sleep(5) # Send PDN Connectivity Request apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ip = ipaddress.ip_address(bytes(addr[:4])) ips.append(sec_ip) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) print("Sleeping for 5 seconds") time.sleep(5) # Add dedicated bearer to 2nd PDN print("********************** Adding dedicated bearer to ims PDN") print( "********************** Sending RAR for IMSI", "".join([str(i) for i in req.imsi]), ) self._sessionManager_util.create_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id2, flow_list2, qos2, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value) act_ded_ber_req_ims_apn = response.cast( s1ap_types.UeActDedBearCtxtReq_t) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_req_ims_apn.bearerId) print( "************* Added dedicated bearer", act_ded_ber_req_ims_apn.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) dl_flow_rules = { default_ip: [flow_list1], sec_ip: [flow_list2], } # 1 UL flow is created per bearer num_ul_flows = 4 # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows, dl_flow_rules) print("*********** Moving UE to idle mode") print( "************* Sending UE context release request ", "for UE id ", ue_id, ) # Send UE context release request to move UE to idle mode rel_req = s1ap_types.ueCntxtRelReq_t() rel_req.ue_Id = ue_id rel_req.cause.causeVal = ( gpp_types.CauseRadioNetwork.USER_INACTIVITY.value) self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, rel_req) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value) # Verify if paging flow rules are created ip_list = [default_ip, sec_ip] self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list) print( "************************* Running UE downlink (UDP) for UE id ", ue_id, ) with self._s1ap_wrapper.configDownlinkTest(req, duration=1, is_udp=True) as test: response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.UE_PAGING_IND.value) # Send service request to reconnect UE print( "************************* Sending Service request for UE id ", ue_id, ) ser_req = s1ap_types.ueserviceReq_t() ser_req.ue_Id = ue_id ser_req.ueMtmsi = s1ap_types.ueMtmsi_t() ser_req.ueMtmsi.pres = False ser_req.rrcCause = s1ap_types.Rrc_Cause.TFW_MT_ACCESS.value self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SERVICE_REQUEST, ser_req) # Wait for INT_CTX_SETUP_IND while response.msg_type == s1ap_types.tfwCmd.UE_PAGING_IND.value: print( "Received Paging Indication for ue-id", ue_id, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value) test.verify() print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows, dl_flow_rules) pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value) print("******************* Received deactivate eps bearer context" " request") # Send DeactDedicatedBearerAccept deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, deactv_bearer_req.bearerId) print("Sleeping for 5 seconds") time.sleep(5) print("************************* Running UE detach for UE id ", ue_id) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, True)
def test_secondary_pdn_conn_ded_bearer(self): """Attach a single UE and send standalone PDN Connectivity Request + add dedicated bearer to each default bearer """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) for _ in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list, ) print( "********************* Running End to End attach for UE id ", ue_id, ) # Attach attach = self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) addr = attach.esmInfo.pAddr.addrInfo default_ip = ipaddress.ip_address(bytes(addr[:4])) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Add dedicated bearer for default bearer 5 print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list1 = self._spgw_util.create_default_ipv4_flows() self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, flow_list1, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value, ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t, ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # Send PDN Connectivity Request apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ip = ipaddress.ip_address(bytes(addr[:4])) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) # Add dedicated bearer to 2nd PDN print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list2 = self._spgw_util.create_default_ipv4_flows() self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, flow_list2, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value, ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t, ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules are created dl_flow_rules = { default_ip: [flow_list1], sec_ip: [flow_list2], } # 2 UL flows for default and secondary pdns # + 2 for dedicated bearers num_ul_flows = 4 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req, ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print( "******************* Received deactivate eps bearer context" " request", ) # Send DeactDedicatedBearerAccept deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules are deleted for secondary pdn dl_flow_rules = { default_ip: [flow_list1], } # 1 UL flow for default bearer + 1 for dedicated bearer num_ul_flows = 2 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "******************** Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_attach_detach_secondary_pdn_with_pcscf_address(self): """ Attach a single UE + add 2 PDN Connections with P-CSCF address """ """ + disconnect """ num_pdns = 2 bearer_ids = [] num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # ims APN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # internet APN internet = { "apn_name": "internet", # APN-name "qci": 9, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims, internet] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list) print( "*********************** Running End to End attach for UE id ", ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() time.sleep(2) # APNs of the secondary PDNs apn = ["internet", "ims"] pcscf_addr_type = ["ipv4", "ipv6"] # PDN Type 1-IPv4,2-IPv6,3-IPv4v6 pdn_type = 1 for i in range(num_pdns): # Send PDN Connectivity Request self._s1ap_wrapper.sendPdnConnectivityReq( ue_id, apn[i], pdn_type=pdn_type, pcscf_addr_type=pcscf_addr_type[i], ) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId) print( "********************** Added default bearer with " "bearer id", act_def_bearer_req.m.pdnInfo.epsBearerId, ) time.sleep(5) for i in range(num_pdns): # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = bearer_ids[i] print( "******************* Sending PDN Disconnect bearer id\n", pdn_disconnect_req.epsBearerId, ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print("******************* Received deactivate eps bearer context" " request") # Send DeactDedicatedBearerAccept self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, bearer_ids[i]) print( "******************* Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_3495_timer_for_default_bearer_with_mme_restart(self): """ Test case validates the functionality of 3495 timer for Default bearer while MME restarts Step1: UE attaches to network Step2: Creates a secondary PDN Step3: Initiates PDN disconnect, as part of which mme sends Deactivate EPS bearer context request and starts 3495 timer Step4: TFW shall not respond to first Deactivate EPS bearer context request message Step5: Send command to Magma to restart mme service Step6: TFW shall receive re-transmitted Deactivate EPS bearer context Request message and send Deactivate EPS bearer Context Accept Step7: TFW shall initiate Detach procedure. """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) req = self._s1ap_wrapper.ue_req # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list ) print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach self._s1ap_wrapper._s1_util.attach( req.ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() time.sleep(5) print("*** Sending PDN connectivity Req ***") # Send PDN Connectivity Request apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(req.ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "************************* Sending Activate default EPS bearer " "context accept for UE id ", req.ue_id, ) time.sleep(5) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = req.ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value ) print( "******************* Received deactivate default eps bearer " "context request" ) # Do not send deactivate eps bearer context accept print("************************* Restarting MME service on", "gateway") self._s1ap_wrapper.magmad_util.restart_services(["mme"]) for j in range(30): print("Waiting for", j, "seconds") time.sleep(1) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value ) deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId ) time.sleep(2) print( "********************** Running UE detach for UE id ", req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_attach_detach_secondary_pdn_multi_ue(self): """attach/detach + PDN Connectivity Requests with 4 UEs""" num_ues = 4 ue_ids = [] bearer_ids = [] default_ips = [] sec_ips = [] self._s1ap_wrapper.configUEDevice(num_ues) # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] for _ in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list, ) print( "******************* Running End to End attach for UE id ", ue_id, ) # Attach attach = self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) addr = attach.esmInfo.pAddr.addrInfo default_ips.append(ipaddress.ip_address(bytes(addr[:4]))) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() ue_ids.append(ue_id) self._s1ap_wrapper._ue_idx = 0 for _ in range(num_ues): req = self._s1ap_wrapper.ue_req # Send PDN Connectivity Request apn = "ims" ue_id = req.ue_id self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) print( "********************** Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId) addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ips.append(ipaddress.ip_address(bytes(addr[:4]))) print("Sleeping for 5 seconds") time.sleep(5) for i in range(num_ues): # Verify if flow rules are created # No dedicated bearers, so flowlist is empty dl_flow_rules = { default_ips[i]: [], sec_ips[i]: [], } # 2 bearers per UE (2* 4 UEs = 8 UL flows) num_ul_flows = 8 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) # Disconnect secondary PDNs self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = bearer_ids[i] self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req, ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print( "******************* Received deactivate eps bearer context" " request", ) # Send DeactDedicatedBearerAccept self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, bearer_ids[i], ) print("Sleeping for 5 seconds") time.sleep(5) # Verify that flow rules are deleted for secondary pdns for i in range(num_ues): # No dedicated bearers, so flowlist is empty dl_flow_rules = { default_ips[i]: [], } # 1 default bearer per UE = 4 UL flows num_ul_flows = 4 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) # Now detach the UE for ue in ue_ids: print( "******************** Running UE detach (switch-off) for ", "UE id ", ue, ) self._s1ap_wrapper.s1_util.detach( ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
def test_secondary_pdn_disconn_invalid_bearer_id(self): """ Attach a single UE + send standalone PDN Connectivity Request + send PDN disconnect with invalid bearer id """ num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list) # Declare an array of len 15 as the bearer id ranges from 5-15 length = 15 bearer_idx = [0] * length print( "************************* Running End to End attach for UE id ", ue_id, ) # Attach attach_accept = self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Set the bearer index to 1 bearer_idx[attach_accept.esmInfo.epsBearerId] = 1 # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Send PDN Connectivity Request apn = "ims" self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value) act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t) # Set the bearer index to 1 bearer_idx[act_def_bearer_req.m.pdnInfo.epsBearerId] = 1 print( "************************* Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) print("********************* Sleeping for 5 seconds") time.sleep(5) # Send PDN Disconnect for a non-existent bearer pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id # Find an unassigned bearer id # Start from 5th index as the bearer id ranges from 5-15 for i in range(5, 15): if bearer_idx[i] == 0: pdn_disconnect_req.epsBearerId = i break print( "****** Sending PDN disconnect for bearer id", pdn_disconnect_req.epsBearerId, ) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive PDN Disconnect reject response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REJ.value) print("************************* Received PDN disconnect reject") print( "************************* Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_attach_detach_two_pdns_with_tcp_traffic(self): """ Attach a single UE, send standalone PDN Connectivity Request, generate TCP traffic for each PDN session """ self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # ims APN ims = { "apn_name": "ims", # APN-name "qci": 5, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL } apn_list = [ims] self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list) print( "************************* Running End to End" " attach for UE id ", ue_id) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() default_apn_ip = self._s1ap_wrapper._s1_util.get_ip(ue_id) time.sleep(2) # Send PDN Connectivity Request apn = "ims" print( "************************* Sending Standalone PDN " "CONNECTIVITY REQUEST for UE id ", ue_id, " APN ", apn, ) self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value) pdn_conn_rsp = response.cast(s1ap_types.uePdnConRsp_t) ims_addr = pdn_conn_rsp.m.pdnInfo.pAddr.addrInfo ims_ip = ipaddress.ip_address(bytes(ims_addr[:4])) print( "************************* Running UE uplink (TCP) for UE id ", req.ue_id, " UE IP addr: ", default_apn_ip, " APN: oai_IPv4", ) with self._s1ap_wrapper._trf_util.generate_traffic_test( [default_apn_ip], is_uplink=True, duration=5, is_udp=False) as test: test.verify() print("Sleeping for 5 seconds...") time.sleep(5) print( "************************* Running UE uplink (TCP) for UE id ", req.ue_id, " ue ip addr: ", ims_ip, " APN: ", apn, ) with self._s1ap_wrapper._trf_util.generate_traffic_test( [ims_ip], is_uplink=True, duration=5, is_udp=False) as test: test.verify() print("Sleeping for 5 seconds...") time.sleep(5) # Send PDN Disconnect print("******************* Sending PDN Disconnect" " request") pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = pdn_conn_rsp.m.pdnInfo.epsBearerId self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value) print("******************* Received deactivate EPS bearer context", " request") deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId) print( "************************* Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_3485_timer_for_default_bearer_with_mme_restart(self): """Test case validates the functionality of 3485 timer for default bearer while MME restarts Step1: UE attaches to network Step2: Send an indication to S1ap stack to drop Activate Default Eps Bearer Context Request message, sent as part of secondary PDN activation procedure. Step3: Initiate activation of secondary PDN Step4: Send an indication to S1ap stack to not to Activate Default Eps Bearer Context Request message, so that re-transmitted message reaches to TFW Step5: Send command to Magma to restart mme service Step6: TFW shall receive the PDN connectivity response Step7: TFW shall initiate de-activation of secondary PDN and then initiate Detach procedure. """ num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDN ims = { 'apn_name': 'ims', # APN-name 'qci': 5, # qci 'priority': 15, # priority 'pre_cap': 0, # preemption-capability 'pre_vul': 0, # preemption-vulnerability 'mbr_ul': 200000000, # MBR UL 'mbr_dl': 100000000, # MBR DL } # APN list to be configured apn_list = [ims] self._s1ap_wrapper.configAPN( 'IMSI' + ''.join([str(idx) for idx in req.imsi]), apn_list, ) print( '************************* Running End to End attach for UE id ', ue_id, ) # Attach self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() print( '*** Sending indication to drop Activate Default EPS bearer Ctxt' ' Req ***', ) drop_acctv_dflt_bearer_req = ( s1ap_types.UeDropActvDefaultEpsBearCtxtReq_t()) drop_acctv_dflt_bearer_req.ue_id = req.ue_id drop_acctv_dflt_bearer_req.dropActDfltEpsBearCtxtReq = True self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DROP_ACTV_DEFAULT_EPS_BEARER_CTXT_REQ, drop_acctv_dflt_bearer_req, ) time.sleep(2) print('*** Sending PDN connectivity Req ***') # Send PDN Connectivity Request apn = 'ims' self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn) # Receive PDN CONN RSP/Activate default EPS bearer context request print('************************* Restarting MME service on gateway') self._s1ap_wrapper.magmad_util.restart_services(['mme']) wait_for_restart = 20 for j in range(wait_for_restart): print('Waiting for', j, 'seconds') time.sleep(1) print( '*** Sending indication to drop Activate Default EPS bearer Ctxt' ' Req ***', ) drop_acctv_dflt_bearer_req = ( s1ap_types.UeDropActvDefaultEpsBearCtxtReq_t()) drop_acctv_dflt_bearer_req.ue_id = req.ue_id drop_acctv_dflt_bearer_req.dropActDfltEpsBearCtxtReq = False self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_DROP_ACTV_DEFAULT_EPS_BEARER_CTXT_REQ, drop_acctv_dflt_bearer_req, ) retransmitted_response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( retransmitted_response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value, ) act_def_bearer_req = retransmitted_response.cast( s1ap_types.uePdnConRsp_t, ) # Send PDN Disconnect pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t() pdn_disconnect_req.ue_Id = ue_id pdn_disconnect_req.epsBearerId = ( act_def_bearer_req.m.pdnInfo.epsBearerId) self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req, ) # Receive UE_DEACTIVATE_BER_REQ response = self._s1ap_wrapper.s1_util.get_response() msg_type = s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value while (response.msg_type != msg_type): response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value, ) print( '******************* Received deactivate eps bearer context' ' request', ) # Send DeactDedicatedBearerAccept deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId, ) print( '************************* Running UE detach (switch-off) for ', 'UE id ', ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, wait_for_s1_ctxt_release=False, )