class TestAttachDetachDedicatedDeactInvalidLbi(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach(self): """ attach/detach + dedicated bearer deactivation with invalid LBI test with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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("********************** 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) print("********************** Deleting dedicated bearer for IMSI", ''.join([str(i) for i in req.imsi])) # Invalid LBI - 6 instead of 5 self._spgw_util.delete_bearer( 'IMSI' + ''.join([str(i) for i in req.imsi]), 6, 6) time.sleep(5) print("********************** Running UE detach for UE id ", req.ue_id) # Now detach the UE self._s1ap_wrapper.s1_util.detach(req.ue_id, detach_type[i], wait_for_s1[i])
class TestAttachDetachDedicatedActTmrExp(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach(self): """ attach/detach + dedicated bearer activation timer expiry test with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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( "********************** 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.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value) # Do not send ACT_DED_BER_ACC time.sleep(45) print( "********************** Running UE detach for UE id ", req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach(req.ue_id, detach_type[i], wait_for_s1[i])
class TestAttachDetachDedicatedInvalidlbi(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach(self): """ attach/detach + invalid lbi in dedicated bearer test with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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("********************** Adding dedicated bearer to IMSI", ''.join([str(i) for i in req.imsi])) # Send wrong LBI-6 instead of 5 self._spgw_util.create_bearer( 'IMSI' + ''.join([str(i) for i in req.imsi]), 6) time.sleep(5) print("********************** Running UE detach for UE id ", req.ue_id) # Now detach the UE self._s1ap_wrapper.s1_util.detach(req.ue_id, detach_type[i], wait_for_s1[i])
class TestSecondaryPdnConnWithDedBearerLooped(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() 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, )
class TestSecondaryPdnConnWithDedBearerReq(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() 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, )
class TestAttachDetachNwTriggeredDeleteSecondaryPdn(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach_nw_triggered_delete_secondary_pdn(self): """ Attach a single UE + add secondary PDN + add dedicated bearer to the secondary pdn + delete the secondary pdn + detach""" 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 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() # 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_sec_pdn = response.cast(s1ap_types.uePdnConRsp_t) print( "******************* Sending Activate default EPS bearer " "context accept for UE id ", ue_id, ) # Add dedicated bearer to IMS 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_sec_pdn.m.pdnInfo.epsBearerId, ) # Receive Activate dedicated EPS bearer context request 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) # Send Activate dedicated EPS bearer context accept self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId) print("Sleeping for 5 seconds") time.sleep(5) print( "******************* Deleting default bearer for IMSI", "".join([str(i) for i in req.imsi]), ) # Delete secondary pdn self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_sec_pdn.m.pdnInfo.epsBearerId, act_sec_pdn.m.pdnInfo.epsBearerId, ) # 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") print("******************* Sending deactivate eps bearer context" " accept") # Send Deactivate EPS bearer context accept self._s1ap_wrapper.sendDeactDedicatedBearerAccept( ue_id, deactv_bearer_req.bearerId) print("Sleeping for 5 seconds") 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)
class Test3495TimerForDedicatedBearerWithMmeRestart(unittest.TestCase): """Test case validates the functionality of 3495 timer for dedicated bearer while MME restarts """ def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper( stateless_mode=MagmadUtil.stateless_cmds.ENABLE, ) self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_3495_timer_for_dedicated_bearer_with_mme_restart(self): """Test case validates the functionality of 3495 timer for dedicated bearer while MME restarts Step1: UE attaches to network Step2: Creates a dedicated bearer Step3: Initiates dedicated bearer deletion, 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) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list = 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_list, ) 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_list], } # 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( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, act_ded_ber_ctxt_req.bearerId, ) 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") # 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, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules are deleted for dedicated bearer dl_flow_rules = { default_ip: [], } # 1 UL flow for default bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) 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, )
class TestActivateDeactivateMultipleDedicated(unittest.TestCase): """attach/detach + multiple dedicated bearer test with a single UE""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_activate_deactivate_multiple_dedicated(self): """attach/detach + multiple dedicated bearer test with a single UE""" num_dedicated_bearers = 10 bearer_ids = [] flow_lists = [] self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for UE id", req.ue_id, ) # Now actually complete the attach 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, ) 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() time.sleep(2) for i in range(num_dedicated_bearers): print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) flow_lists.append( self._spgw_util.create_default_ipv4_flows(port_idx=i), ) self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, flow_lists[i], rule_id=str(i), ) 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, ) bearer_ids.append(act_ded_ber_ctxt_req.bearerId) print( "********************** Added dedicated bearer with", "with bearer id", act_ded_ber_ctxt_req.bearerId, ) # Verify if flow rules are created print("Sleeping for 5 seconds") time.sleep(5) # flow_lists for 10 dedicated bearers dl_flow_rules = {default_ip: flow_lists} # 1 default UL flow + 10 dedicated bearer UL flows num_ul_flows = 11 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "********************** Deleting dedicated bearer for IMSI", "".join([str(itr) for itr in req.imsi]), ) self._spgw_util.delete_bearers( "IMSI" + "".join([str(itr) for itr in req.imsi]), attach.esmInfo.epsBearerId, bearer_ids, ) for i in range(num_dedicated_bearers): time.sleep(0.1) 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") self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, bearer_ids[i], ) print( "********************** Deleted dedicated bearer with " "bearer id", bearer_ids[i], ) # Verify if flow rules are deleted for dedicated bearers print("Sleeping for 5 seconds") time.sleep(5) dl_flow_rules = {default_ip: []} # 1 default UL flow num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) 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_NORMAL_DETACH.value, ) # Verify that all UL/DL flows are deleted self._s1ap_wrapper.s1_util.verify_flow_rules_deletion()
class TestAttachDetachDedicatedInvalidlbi(unittest.TestCase): """Invalid lbi in dedicated bearer test with a single UE""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach_dedicated_bearer_activation_invalid_lbi(self): """attach/detach + invalid lbi in dedicated bearer test with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list = self._spgw_util.create_default_ipv4_flows() # Send wrong LBI-6 instead of 5 self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), (attach.esmInfo.epsBearerId + 1), flow_list, ) # Dedicated bearer creation failed because of invalid lbi, so # dl flow should not be created for the dedicated bearer dl_flow_rules = { default_ip: [], } # 1 UL flow for default bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print("Sleeping for 2 seconds") 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, detach_type[i], wait_for_s1[i], )
class TestAttachDetachDedicatedQci0(unittest.TestCase): """Dedicated bearer test with qci 0""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach_dedicated_qci_0(self): """Test attach + create dedicated bearer with QCI, 0 + erab_setup_failed_indication + detach, with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() print("Sleeping for 5 seconds") time.sleep(2) imsi = "".join([str(i) for i in req.imsi]) print( "********************** Adding dedicated bearer to IMSI", imsi, ) # Create default flow list flow_list = self._spgw_util.create_default_ipv4_flows() self._spgw_util.create_bearer( "IMSI" + imsi, attach.esmInfo.epsBearerId, flow_list, qci_val=0, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_FW_ERAB_SETUP_REQ_FAILED_FOR_ERABS.value, ) erab_setup_failed_for_bearers = response.cast( s1ap_types.FwErabSetupFailedTosetup, ) print( "*** Received UE_FW_ERAB_SETUP_REQ_FAILED_FOR_ERABS for " "bearer-id:", erab_setup_failed_for_bearers.failedErablist[0].erabId, end=" ", ) print( " with qci:", erab_setup_failed_for_bearers.failedErablist[0].qci, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify that flow rules are created only for default bearer dl_flow_rules = { default_ip: [], } # 1 UL flow for default bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "********************** Running UE detach for UE id ", req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, detach_type[i], wait_for_s1[i], )
class TestAttachDetachDedicatedQci0(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach_dedicated_qci_0(self): """ test attach + create dedicated bearer with QCI, 0 + erab_setup_failed_indication + detach, with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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(2) imsi = "".join([str(i) for i in req.imsi]) print( "********************** Adding dedicated bearer to IMSI", imsi, ) self._spgw_util.create_bearer("IMSI" + imsi, 5, 0) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_FW_ERAB_SETUP_REQ_FAILED_FOR_ERABS.value, ) erab_setup_failed_for_bearers = response.cast( s1ap_types.FwErabSetupFailedTosetup) print( "*** Received UE_FW_ERAB_SETUP_REQ_FAILED_FOR_ERABS for " "bearer-id:", erab_setup_failed_for_bearers.failedErablist[0].erabId, end=" ", ) print(" with qci:", erab_setup_failed_for_bearers.failedErablist[0].qci) time.sleep(5) print("********************** Running UE detach for UE id ", req.ue_id) # Now detach the UE self._s1ap_wrapper.s1_util.detach(req.ue_id, detach_type[i], wait_for_s1[i])
class TestIPv4v6SecondaryPdnSpgwInitiatedDedBearer(unittest.TestCase): """Test ipv4v6 secondary pdn with spgw initiated dedicated bearer""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_ipv4v6_secondary_pdn_spgw_initiated_ded_bearer(self): """Attach a single UE + add a secondary pdn with IPv4v6 + trigger dedicated bearer from spgw + detach """ num_ue = 1 self._s1ap_wrapper.configUEDevice(num_ue) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id # APN of the secondary PDNs ims_apn = { "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 "pdn_type": 2, # PDN Type 0-IPv4,1-IPv6,2-IPv4v6 } apn_list = [ims_apn] 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, ) print("***** Sleeping for 5 seconds") time.sleep(5) # 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() print("***** Sleeping for 5 seconds") time.sleep(5) apn = "ims" # PDN Type 2 = IPv6, 3 = IPv4v6 pdn_type = 3 # Send PDN Connectivity Request self._s1ap_wrapper.sendPdnConnectivityReq( ue_id, apn, pdn_type=pdn_type, ) # 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) pdn_type = act_def_bearer_req.m.pdnInfo.pAddr.pdnType addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ip_ipv4 = None if pdn_type == 1: sec_ip_ipv4 = ipaddress.ip_address(bytes(addr[:4])) elif pdn_type == 3: sec_ip_ipv4 = ipaddress.ip_address(bytes(addr[8:12])) print( "********************** Sending Activate default EPS bearer " "context accept for APN-%s, UE id-%d" % (apn, ue_id), ) print( "********************** Added default bearer for apn-%s," " bearer id-%d, pdn type-%d" % (apn, act_def_bearer_req.m.pdnInfo.epsBearerId, pdn_type), ) # Receive Router Advertisement message response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ROUTER_ADV_IND.value, ) router_adv = response.cast(s1ap_types.ueRouterAdv_t) print( "******************* Received Router Advertisement for APN-%s" " ,bearer id-%d" % (apn, router_adv.bearerId), ) ipv6_addr = "".join([chr(i) for i in router_adv.ipv6Addr]).rstrip("\x00", ) print("******* UE IPv6 address: ", ipv6_addr) sec_ip_ipv6 = ipaddress.ip_address(ipv6_addr) print("***** Sleeping for 5 seconds") time.sleep(5) # Add dedicated bearer print("********************** Adding dedicated bearer to ims PDN") # Create default ipv4v6 flow list flow_list = self._spgw_util.create_default_ipv4v6_flows() self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, flow_list, ) 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 10 seconds") time.sleep(10) # ipv4 default pdn + ipv4v6(ims) pdn + dedicated bearer for ims pdn num_ul_flows = 3 # For ipv4v6 pdn, pass default_ip, sec_ip_ipv4 and sec_ip_ipv6 if pdn_type == 3: dl_flow_rules = { default_ip: [], sec_ip_ipv4: [flow_list], sec_ip_ipv6: [flow_list], } # For ipv6 pdn, pass default_ip, sec_ip_ipv6 if pdn_type == 2: dl_flow_rules = { default_ip: [], sec_ip_ipv6: [flow_list], } # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, act_ded_ber_ctxt_req.bearerId, ) 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") 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) # ipv4 default pdn + ipv4v6(ims) pdn num_ul_flows = 2 # For ipv4v6 pdn, pass default_ip, sec_ip_ipv4 and sec_ip_ipv6 if pdn_type == 3: dl_flow_rules = { default_ip: [], sec_ip_ipv4: [], sec_ip_ipv6: [], } # For ipv6 pdn, pass default_ip, sec_ip_ipv6 if pdn_type == 2: dl_flow_rules = { default_ip: [], sec_ip_ipv6: [], } # Verify if flow rules are created 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, )
class TestAttachDetachNwTriggeredDeleteLastPdn(unittest.TestCase): """Test network initiated last pdn deletion""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach_nw_triggered_delete_last_pdn(self): """Attach + add dedicated bearer + delete default bearer test with a single UE """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) flow_list = 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_list, ) 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_list], } # 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, ) print( "********************** Deleting default bearer for IMSI", "".join([str(i) for i in req.imsi]), ) # Delete default bearer self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, attach.esmInfo.epsBearerId, ) # Receive NW initiated detach request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_NW_INIT_DETACH_REQUEST.value, ) print("**************** Received NW initiated Detach Req") print("**************** Sending Detach Accept") # Send detach accept detach_accept = s1ap_types.ueTrigDetachAcceptInd_t() detach_accept.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_TRIGGERED_DETACH_ACCEPT, detach_accept, ) # Verify that all UL/DL flows are deleted self._s1ap_wrapper._s1_util.verify_flow_rules_deletion()
class TestAttachDetachDedicatedMultiUe(unittest.TestCase): """Dedicated bearer test with multiple UEs""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach_dedicated_multi_ue(self): """attach/detach + dedicated bearer test with 4 UEs""" num_ues = 4 ue_ids = [] bearer_ids = [] default_ips = [] flow_lists = [] self._s1ap_wrapper.configUEDevice(num_ues) for _ in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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(req.ue_id) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) flow_lists.append(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_lists[i], ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value, ) print( "********************** Received activate dedicated EPS" " bearer context request", ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t, ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId, ) bearer_ids.append(act_ded_ber_ctxt_req.bearerId) # Verify if flow rules are created for i in range(num_ues): dl_flow_rules = { default_ips[i]: [flow_lists[i]], } # 4 default + 4 dedicated bearer UL flows for 4 UEs num_ul_flows = 8 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print("Sleeping for 1 second") time.sleep(1) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, bearer_ids[i], ) 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", ) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, bearer_ids[i], ) print("Sleeping for 2 seconds") time.sleep(2) # Verify if flow rules are deleted for dedicated bearers for i in range(num_ues): dl_flow_rules = { default_ips[i]: [], } # 4 default bearer UL flows for 4 UEs num_ul_flows = 4 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) for ue in ue_ids: print("********************** Running UE detach for UE id ", ue) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue, s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, )
class TestMaximumBearersPerUe(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_max_bearers_per_ue(self): """ Attach a single UE and send standalone PDN Connectivity Request + add 9 dedicated bearers + detach""" num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) # 1 oai PDN + 1 dedicated bearer, 1 ims pdn + 8 dedicated bearers loop = 8 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 oai.ipv4" " PDN") 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_req_oai_apn = response.cast( s1ap_types.UeActDedBearCtxtReq_t) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_req_oai_apn.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 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, ) time.sleep(5) for _ in range(loop): # Add dedicated bearer to 2nd 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.assertTrue(response, 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, ) time.sleep(2) print( "************************ Running UE detach (switch-off) for ", "UE id ", ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
class TestAttachDetachDedicatedLooped(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach(self): """ attach/detach + dedicated bearer test in loop with a single UE """ num_ues = 1 loop = 3 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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() for j in range(loop): time.sleep(2) print("*************************************************") print("********************* Iteration - ", j + 1) print("*************************************************") 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(1) print("*************** Deleting dedicated bearer for IMSI", ''.join([str(i) for i in req.imsi])) self._spgw_util.delete_bearer( 'IMSI' + ''.join([str(i) for i in req.imsi]), 5, act_ded_ber_ctxt_req.bearerId) 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") 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 for UE id ", req.ue_id) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value)
class TestSendErrorIndForErabSetupReq(unittest.TestCase): """Test sending of error indication for erab setup request""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_send_error_ind_for_erab_setup_req(self): """attach/detach + erabsetup req + error ind with a single UE""" num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # attach attach_acc = 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() # Send indication to drop erab setup req print("*** Sending indication to tfw to drop erab setup req***") drop_erab_setup_req = s1ap_types.DropErabSetupReq_t() drop_erab_setup_req.ue_Id = req.ue_id drop_erab_setup_req.flag = 1 self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.DROP_ERAB_SETUP_REQ, drop_erab_setup_req, ) print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list = self._spgw_util.create_default_ipv4_flows() self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach_acc.esmInfo.epsBearerId, flow_list, ) 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, ) # Send error indication for erab setup req error_ind = s1ap_types.fwNbErrIndMsg_t() # isUeAssoc flag to include optional MME_UE_S1AP_ID and # eNB_UE_S1AP_ID error_ind.isUeAssoc = True error_ind.ue_Id = req.ue_id error_ind.cause.pres = True # Radio network causeType = 0 error_ind.cause.causeType = 0 # causeVal- Unknown-pair-ue-s1ap-id error_ind.cause.causeVal = 15 print("*** Sending error indication ***") self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.ENB_ERR_IND_MSG, error_ind, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) print( "************************* Received UE_CTX_REL_IND for UE id ", req.ue_id, ) print( "********************** Running UE detach for UE id ", req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, detach_type[i], wait_for_s1[i], )
class TestAttachDetachDedicatedDeactInvalidLbi(unittest.TestCase): """Dedicated bearer deactivation with invalid LBI test with a single UE """ def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach(self): """attach/detach + dedicated bearer deactivation with invalid LBI test with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list = 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_list, ) 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_list], } # 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( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) # Invalid LBI - 6 instead of 5 self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_ded_ber_ctxt_req.bearerId + 1, act_ded_ber_ctxt_req.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # Deletion of dedicated bearer failed so the flow rule # for dedicated bearer should not be deleted self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "********************** Running UE detach for UE id ", req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, detach_type[i], wait_for_s1[i], )
class TestSecondaryPdnConnWithDedBearerReq(unittest.TestCase): """Test secondary pdn with dedicated bearer""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() 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, )
class TestAttachDetachNwTriggeredDeleteLastPdn(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach_nw_triggered_delete_last_pdn(self): """ attach + add dedicated bearer + delete default bearer """ """ test with a single UE """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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() print("Sleeping for 5 seconds") time.sleep(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]), attach.esmInfo.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("Sleeping for 5 seconds") time.sleep(5) print( "********************** Deleting default bearer for IMSI", "".join([str(i) for i in req.imsi]), ) # Delete default bearer self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, attach.esmInfo.epsBearerId, ) # Receive NW initiated detach request response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_NW_INIT_DETACH_REQUEST.value, ) print("**************** Received NW initiated Detach Req") print("**************** Sending Detach Accept") # Send detach accept detach_accept = s1ap_types.ueTrigDetachAcceptInd_t() detach_accept.ue_Id = req.ue_id self._s1ap_wrapper._s1_util.issue_cmd( s1ap_types.tfwCmd.UE_TRIGGERED_DETACH_ACCEPT, detach_accept)
class TestAttachDetachDedicatedDeactTmrExp(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach(self): """ attach/detach + dedicated bearer deactivation timer expiry test with a single UE """ num_ues = 1 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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( "********************** 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.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) print( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), 5, 6) 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") # Do not send deactivate eps bearer context accept time.sleep(50) 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, )
class TestAttachDetachDedicatedMultiUe(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach(self): """ attach/detach + dedicated bearer test 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 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() ue_ids.append(req.ue_id) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req 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.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value ) print( "********************** Received activate dedicated EPS" " bearer context request" ) act_ded_ber_ctxt_req = response.cast( s1ap_types.UeActDedBearCtxtReq_t ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId ) bearer_ids.append(act_ded_ber_ctxt_req.bearerId) time.sleep(1) self._s1ap_wrapper._ue_idx = 0 for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), 5, bearer_ids[i] ) 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" ) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, bearer_ids[i] ) time.sleep(2) for ue in ue_ids: print("********************** Running UE detach for UE id ", ue) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue, s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value )
class Test3485TimerForDedicatedBearerWithMmeRestart(unittest.TestCase): """Test 3485 timer expiry for dedicated bearer setup while mme restarts""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper( stateless_mode=MagmadUtil.stateless_cmds.ENABLE, ) self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_3485_timer_for_dedicated_bearer_with_mme_restart(self): """Test case validates the functionality of 3485 timer for Dedicated bearer while MME restarts Step1: UE attaches to network Step2: Send an indication to initiate Dedicated bearer activation Step3: Send command to Magma to restart mme service Step4: TFW shall receive re-transmitted Activate Dedicated EPS Bearer Context Request and send Activate Dedicated EPS Bearer Context Accept Step5: TFW shall initiate de-activation of dedicated bearer and then initiate Detach procedure. """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for idx in range(num_ues): req = self._s1ap_wrapper.ue_req print( '********************** Running End to End attach for ', 'UE id ', req.ue_id, ) # Now actually complete the attach 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, ) 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() time.sleep(2) print( '********************** Adding dedicated bearer to IMSI', ''.join([str(idx) for idx in req.imsi]), ) # Create default flow list flow_list = self._spgw_util.create_default_ipv4_flows() self._spgw_util.create_bearer( 'IMSI' + ''.join([str(idx) for idx in req.imsi]), attach.esmInfo.epsBearerId, flow_list, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value, ) print( '*******************Received first Activate dedicated bearer ' '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) response = self._s1ap_wrapper.s1_util.get_response() 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('*******************Send Activate dedicated bearer accept') time.sleep(4) print( '********************** Deleting dedicated bearer for IMSI', ''.join([str(idx) for idx in req.imsi]), ) self._spgw_util.delete_bearer( 'IMSI' + ''.join([str(idx) for idx in req.imsi]), attach.esmInfo.epsBearerId, act_ded_ber_ctxt_req.bearerId, ) # During wait time, mme may send multiple times Activate EPS bearer # context request, after sending response for first message ignore # the subsequent messages 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') deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t) self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId, ) # Verify if the rule for dedicated bearer is deleted dl_flow_rules = { default_ip: [], } # 1 UL flow for default bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) time.sleep(5) print( '********************** Running UE detach for UE id ', req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, detach_type[idx], wait_for_s1[idx], )
class TestSecondaryPdnConnWithDedBearerDeactivateReq(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_secondary_pdn_conn_ded_bearer_deactivate(self): """ Attach a single UE and send standalone PDN Connectivity Request + add dedicated bearer to each default bearer + deactivate dedicated bearers + detach""" 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 # 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() # Add dedicated bearer for default bearer 5 print( "********************** Adding dedicated bearer to magma.ipv4" " PDN") self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), 5) 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) 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, ) time.sleep(5) # Add dedicated bearer to 2nd 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_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, ) time.sleep(5) # Delete dedicated bearer of secondary PDN (ims apn) print("********************** Deleting dedicated bearer for ims" " apn") self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, act_ded_ber_req_ims_apn.bearerId, ) 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) # Send Deactivate dedicated bearer rsp self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId) print( "********************** Deleted dedicated bearer ", deactv_bearer_req.bearerId, ) time.sleep(5) # Delete dedicated bearer of default PDN (magma.ipv4 apn) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), 5, act_ded_ber_req_oai_apn.bearerId, ) 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) # Send Deactivate dedicated bearer rsp self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, deactv_bearer_req.bearerId) print( "********************** Deleted dedicated bearer ", deactv_bearer_req.bearerId, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
class TestAttachDetachDedicatedLooped(unittest.TestCase): """Dedicated bearer test in loop with a single UE""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach(self): """attach/detach + dedicated bearer test in loop with a single UE""" num_ues = 1 loop = 3 self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************* Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() for j in range(loop): time.sleep(2) print("*************************************************") print("********************* Iteration - ", j + 1) print("*************************************************") print( "***************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list = 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_list, ) 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_list], } # 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( "*************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), attach.esmInfo.epsBearerId, act_ded_ber_ctxt_req.bearerId, ) 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") 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 rule is deleted for dedicated bearer dl_flow_rules = { default_ip: [], } # 1 UL flow for default bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) 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_NORMAL_DETACH.value, )
class TestSecondaryPdnWithDedBearerMultiUe(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() 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)
class TestActivateDeactivateMultipleDedicated(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_activate_deactivate_multiplededicated(self): """ attach/detach + multiple dedicated bearer test with a single UE """ num_dedicated_bearers = 10 bearer_ids = [] self._s1ap_wrapper.configUEDevice(1) req = self._s1ap_wrapper.ue_req 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(2) for i in range(num_dedicated_bearers): 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, rule_id=str(i) ) 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 ) bearer_ids.append(act_ded_ber_ctxt_req.bearerId) print( "********************** Added dedicated bearer with", "with bearer id", act_ded_ber_ctxt_req.bearerId, ) time.sleep(2) print( "********************** Deleting dedicated bearer for IMSI", "".join([str(i) for i in req.imsi]), ) self._spgw_util.delete_bearers( "IMSI" + "".join([str(i) for i in req.imsi]), 5, bearer_ids ) for i in range(num_dedicated_bearers): 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") self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, bearer_ids[i] ) print( "********************** Deleted dedicated bearer with" "with bearer id", bearer_ids[i], ) 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_NORMAL_DETACH.value )
class TestEpsBearerContextStatusDedBearerDeact(unittest.TestCase): """Test dedicated bearer deactivation with EPS bearer context status""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_eps_bearer_context_status_multi_ded_bearer_deact(self): """Attach a single UE. Create 2 secondary PDNs and add 2 dedicated bearers to each of the secondary PDNs. Send EPS bearer context status IE in TAU request with all default bearer i.e. bearer ids 5,6 and 9 as active and dedicated bearers 7,8,10 and 11 as inactive. Set active flag to false. """ num_ue = 1 num_pdns = 2 sec_ip = [] flow_list = [] wait_for_s1_context_rel = False 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 } internet = { "apn_name": "internet", # APN-name "qci": 9, # qci "priority": 15, # priority "pre_cap": 0, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 250000000, # MBR UL "mbr_dl": 150000000, # 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 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() # APNs of the secondary PDNs apn = ["ims", "internet"] for i in range(num_pdns): # Send PDN Connectivity Request self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn[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, ) print( "********************** Added default bearer with " "bearer id", act_def_bearer_req.m.pdnInfo.epsBearerId, ) addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo sec_ip.append(ipaddress.ip_address(bytes(addr[:4]))) # Add dedicated bearer for the default bearers print( "********************** Adding 1st dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list.append(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_list[i], ) 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( ue_id, act_ded_ber_ctxt_req.bearerId, ) # Create 2nd dedicated bearer print( "********************** Adding 2nd dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) flow_list.append(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_list[i], ) 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( ue_id, act_ded_ber_ctxt_req.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules are created for i in range(num_pdns): dl_flow_rules = { default_ip: [], sec_ip[i]: [flow_list[i]], } # 1 UL flow is created per bearer num_ul_flows = 7 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print( "************************* Sending UE context release request ", "for UE id ", ue_id, ) # Send UE context release request to move UE to idle mode cntxt_rel_req = s1ap_types.ueCntxtRelReq_t() cntxt_rel_req.ue_Id = ue_id cntxt_rel_req.cause.causeVal = ( gpp_types.CauseRadioNetwork.USER_INACTIVITY.value) self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, cntxt_rel_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value, ) print(" Sleeping for 2 seconds") time.sleep(2) print( "************************* Sending Tracking Area Update ", "request for UE id ", ue_id, ) tau_req = s1ap_types.ueTauReq_t() tau_req.ue_Id = ue_id tau_req.type = s1ap_types.Eps_Updt_Type.TFW_TA_UPDATING.value tau_req.Actv_flag = True # Set default bearers 5,6 and 9 as active and # dedicated bearers 7,8,10 and 11 as inactive # epsBearerCtxSts IE is 16 bits # Ref: 3gpp 24.301 sec-9.9.2.1 tau_req.epsBearerCtxSts = 0x260 tau_req.ueMtmsi.pres = False self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_TAU_REQ, tau_req, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) response = self._s1ap_wrapper.s1_util.get_response() self.assertEquals( response.msg_type, s1ap_types.tfwCmd.UE_TAU_ACCEPT_IND.value, ) tau_acc = response.cast(s1ap_types.ueTauAccept_t) print( "************************* Received Tracking Area Update ", "accept for UE id ", tau_acc.ue_Id, ) # Verify if flow rules are created for i in range(num_pdns): dl_flow_rules = { default_ip: [], sec_ip[i]: [], } # 1 UL flow is created per bearer num_ul_flows = 3 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_context_rel, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify that all UL/DL flows are deleted self._s1ap_wrapper.s1_util.verify_flow_rules_deletion()
class TestMaximumBearersTwoPdnsPerUe(unittest.TestCase): """Test maximum bearers with two pdns""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach_maxbearers_twopdns(self): """Attach a single UE and send standalone PDN Connectivity Request + add 9 dedicated bearers + detach """ num_ues = 1 flow_lists2 = [] self._s1ap_wrapper.configUEDevice(num_ues) # 1 oai PDN + 1 dedicated bearer, 1 ims pdn + 8 dedicated bearers loop = 8 # 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 i in range(num_ues): req = self._s1ap_wrapper.ue_req self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(i) for i in req.imsi]), apn_list, ) ue_id = req.ue_id 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 magma.ipv4" " PDN", ) # 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_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 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) 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, ) print("Sleeping for 5 seconds") time.sleep(5) num_flows_per_bearer = 4 for idx in range(loop): # Add dedicated bearer to 2nd PDN print( "********************** Adding dedicated bearer to ims" " PDN", ) flow_lists2.append( self._spgw_util.create_default_ipv4_flows( port_idx=(idx * num_flows_per_bearer) + 10), ) self._spgw_util.create_bearer( "IMSI" + "".join([str(i) for i in req.imsi]), act_def_bearer_req.m.pdnInfo.epsBearerId, flow_lists2[idx], qci_val=idx + 1, ) 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 2 seconds") time.sleep(2) # Verify if flow rules are created # 1 dedicated bearer for default pdn and 8 dedicated bearers # for secondary pdn dl_flow_rules = { default_ip: [flow_list1], sec_ip: flow_lists2, } # 2 UL flows for default and secondray pdn + # 9 for dedicated bearers num_ul_flows = 11 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( req.ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False, )
class TestAttachDetachDedicatedActTmrExp(unittest.TestCase): """Dedicated bearer activation timer expiry test with a single UE """ def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_attach_detach(self): """attach/detach + dedicated bearer activation timer expiry test with a single UE """ num_ues = 1 detach_type = [ s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, ] wait_for_s1 = [True, False] self._s1ap_wrapper.configUEDevice(num_ues) for i in range(num_ues): req = self._s1ap_wrapper.ue_req print( "********************** Running End to End attach for ", "UE id ", req.ue_id, ) # Now actually complete the attach 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, ) 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() time.sleep(5) print( "********************** Adding dedicated bearer to IMSI", "".join([str(i) for i in req.imsi]), ) # Create default flow list flow_list = 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_list, ) # Do not send ACT_DED_BER_ACC # TODO:Receive retransmissions once support is added # at s1ap tester 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, ) print( "********************** Received UE_ACT_DED_BER_REQ with ebi ", act_ded_ber_ctxt_req.bearerId, ) print("Waiting for timer to expire.Sleeping for 45 seconds") time.sleep(45) # Verify that the flow rule is created only for default bearer dl_flow_rules = { default_ip: [], } # 1 UL flow for default bearer num_ul_flows = 1 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Running UE detach for UE id ", req.ue_id, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( req.ue_id, detach_type[i], wait_for_s1[i], )