def setUp(self): """Initialize s1ap wrapper and spgw utility """ self._s1ap_wrapper = s1ap_wrapper.TestWrapper( stateless_mode=MagmadUtil.stateless_cmds.ENABLE, ) self._spgw_util = SpgwUtil()
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 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 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 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 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 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 TestAttachDetachWithHE(unittest.TestCase): SPGW_TABLE = 0 HE_TABLE = 4 LOCAL_PORT = "LOCAL" def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._sessionManager_util = SessionManagerUtil() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach_with_he(self): """ Attach/detach + send ReAuth Req to session manager with a single UE along with Header enrichment. This test validates that same data test wotks with HE policy applied. Header enrichment should be as transparent as possible. """ 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) datapath = get_datapath() MAX_NUM_RETRIES = 5 gtp_br_util = GTPBridgeUtils() PROXY_PORT = gtp_br_util.get_proxy_port_no() utils = HeaderEnrichmentUtils() 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() # UL Flow description #1 ulFlow1 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5002, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # Flow list to be configured flow_list = [ ulFlow1, ] # QoS qos = { "qci": 5, # qci value [1 to 9] "priority": 0, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 15, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } policy_id = "ims-voice" print("Sleeping for 5 seconds") time.sleep(5) imsi = "IMSI" + "".join([str(i) for i in req.imsi]) he_domain1 = "192.168.129.42" assert utils.he_count_record_of_imsi_to_domain(imsi, he_domain1) == 0 print( "********************** Sending RAR for ", imsi, ) self._sessionManager_util.send_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id, flow_list, qos, he_urls=HeaderEnrichment(urls=[he_domain1]), ) # Receive Activate dedicated bearer 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, ) print("Sleeping for 5 seconds") time.sleep(5) # Send Activate dedicated bearer accept self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req.bearerId, ) # Check if UL and DL OVS flows are created # UPLINK print("Checking for uplink proxy flow for port: ", PROXY_PORT) # try at least 5 times before failing as gateway # might take some time to install the flows in ovs for i in range(MAX_NUM_RETRIES): uplink_flows = gtp_br_util.get_flows(self.HE_TABLE) if len(uplink_flows) > 1: break time.sleep(1) # sleep for 5 seconds before retrying assert len(uplink_flows) > 1, "HE flow missing for UE" assert utils.he_count_record_of_imsi_to_domain(imsi, he_domain1) == 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, 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") 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) 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], ) time.sleep(20) assert utils.he_count_record_of_imsi_to_domain(imsi, he_domain1) == 0 # Verify that all UL/DL flows are deleted self._s1ap_wrapper.s1_util.verify_flow_rules_deletion()
def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._sessionManager_util = SessionManagerUtil() self._spgw_util = SpgwUtil()
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 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 TestIpv6NonNatDedBearerDlTcp(unittest.TestCase): """Integration Test: TestIpv6NonNatDedBearerDlTcp""" def __init__(self, method_name: str = ...) -> None: """Initialize unittest class""" super().__init__(methodName=method_name) self.magma_utils = MagmadUtil(None) self._sessionManager_util = SessionManagerUtil() self._spgw_util = SpgwUtil() def setUp(self): """Initialize before test case execution""" self.magma_utils.disable_nat(ip_version=6) self._s1ap_wrapper = s1ap_wrapper.TestWrapper(ip_version=6) def tearDown(self): """Cleanup after test case execution""" self._s1ap_wrapper.cleanup() self.magma_utils.enable_nat(ip_version=6) def test_ipv6_non_nat_ded_bearer_dl_tcp(self): """Ipv6 attach/detach with dedicated bearer and DL TCP data test with a single UE""" num_ues = 1 magma_apn = { "apn_name": "magma", # APN-name "qci": 9, # qci "priority": 15, # priority "pre_cap": 1, # preemption-capability "pre_vul": 0, # preemption-vulnerability "mbr_ul": 200000000, # MBR UL "mbr_dl": 100000000, # MBR DL "pdn_type": 1, # PDN Type 0-IPv4,1-IPv6,2-IPv4v6 } wait_for_s1 = True ue_ips = ["fdee::"] apn_list = [magma_apn] self._s1ap_wrapper.configUEDevice(num_ues, [], ue_ips) req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print( "************************* Running End to End attach for ", "UE id ", req.ue_id, ) self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(j) for j in req.imsi]), apn_list, default=False, ) # Now actually complete the attach # PDN type values sent in NAS message are different from # the values used in s6a (APN config) # PDN Type 1-IPv4,2-IPv6,3-IPv4v6 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, pdn_type=2, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Receive Router Advertisement message apn = "magma" 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) default_ipv6 = ipaddress.ip_address(ipv6_addr) self._s1ap_wrapper.s1_util.update_ipv6_address(ue_id, ipv6_addr) print( "********************** Sending RAR for IMSI", "".join([str(i) for i in req.imsi]), ) # QoS qos = { "qci": 1, # qci value [1 to 9] "priority": 1, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 1, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } flow_list = self._spgw_util.create_default_ipv6_flows() policy_id = "magma" self._sessionManager_util.send_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id, flow_list, qos, ) 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, ) # Sleep before verifying flows print("********** Sleeping for 5 seconds") time.sleep(5) num_ul_flows = 2 dl_flow_rules = { default_ipv6: [flow_list], } # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ipv6_non_nat=True, ) print( "************************* Running UE downlink (TCP) for UE id ", req.ue_id, ) with self._s1ap_wrapper.configDownlinkTest(req, duration=1) as test: test.verify() 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, wait_for_s1, ) 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()
def __init__(self, method_name: str = ...) -> None: """Initialize unittest class""" super().__init__(methodName=method_name) self.magma_utils = MagmadUtil(None) self._sessionManager_util = SessionManagerUtil() self._spgw_util = SpgwUtil()
class TestIpv4v6PagingWithDedicatedBearer(unittest.TestCase): """Test ipv4v6 paging""" def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil() self._sessionManager_util = SessionManagerUtil() def tearDown(self): """Cleanup""" self._s1ap_wrapper.cleanup() def test_ipv4v6_paging_with_dedicated_bearer(self): """ IPv4v6 Attach, add dedicated bearer, ue context release, paging request """ # Ground work. self._s1ap_wrapper.configUEDevice(1) # Default apn over-write magma_apn = { "apn_name": "magma", # APN-name "qci": 9, # qci "priority": 15, # priority "pre_cap": 1, # 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 } ue_ctxt_rel = False apn_list = [magma_apn] req = self._s1ap_wrapper.ue_req ue_id = req.ue_id print( "********** Running End to End attach for UE id ", ue_id, ) self._s1ap_wrapper.configAPN( "IMSI" + "".join([str(j) for j in req.imsi]), apn_list, default=False, ) # Now actually complete the attach attach = self._s1ap_wrapper.s1_util.attach( ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t, pdn_type=3, ) addr = attach.esmInfo.pAddr.addrInfo default_ipv4 = ipaddress.ip_address(bytes(addr[8:12])) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() # Delay to ensure S1APTester sends attach complete before sending UE # context release time.sleep(5) # Receive Router Advertisement message apn = "magma" 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) default_ipv6 = ipaddress.ip_address(ipv6_addr) self._s1ap_wrapper.s1_util.update_ipv6_address(ue_id, ipv6_addr) print("********************** Adding dedicated bearer") print( "********************** Sending RAR for IMSI", "".join([str(i) for i in req.imsi]), ) # QoS qos = { "qci": 1, # qci value [1 to 9] "priority": 1, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 1, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } flow_list = self._spgw_util.create_default_ipv6_flows() policy_id = "magma" self._sessionManager_util.send_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id, flow_list, qos, ) 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 = response.cast(s1ap_types.UeActDedBearCtxtReq_t) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_req.bearerId, ) print( "************* Added dedicated bearer", act_ded_ber_req.bearerId, ) # Sleep before verifying flows print("********** Sleeping for 5 seconds") time.sleep(5) # Verify flow rules num_ul_flows = 2 dl_flow_rules = { default_ipv4: [flow_list], default_ipv6: [flow_list], } # Verify if flow rules are created 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 ue_cntxt_rel_req = s1ap_types.ueCntxtRelReq_t() ue_cntxt_rel_req.ue_Id = ue_id ue_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, ue_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("********** UE moved to idle mode") print("********** Sleeping for 5 seconds") time.sleep(5) # Verify paging rules ip_list = [default_ipv4, default_ipv6] self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list) print( "********** Running UE downlink (UDP) for UE id ", ue_id, ) self._s1ap_wrapper.s1_util.run_ipv6_data(default_ipv6) response = self._s1ap_wrapper.s1_util.get_response() self.assertTrue(response, s1ap_types.tfwCmd.UE_PAGING_IND.value) print("********** Received UE_PAGING_IND") # Send service request to reconnect UE ser_req = s1ap_types.ueserviceReq_t() ser_req.ue_Id = ue_id ser_req.ueMtmsi = s1ap_types.ueMtmsi_t() ser_req.ueMtmsi.pres = False ser_req.rrcCause = s1ap_types.Rrc_Cause.TFW_MT_ACCESS.value self._s1ap_wrapper.s1_util.issue_cmd( s1ap_types.tfwCmd.UE_SERVICE_REQUEST, ser_req, ) print("********** Sent UE_SERVICE_REQUEST") response = self._s1ap_wrapper.s1_util.get_response() self.assertEqual( response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value, ) print("********** Received INT_CTX_SETUP_IND") print("********** Sleeping for 5 seconds") time.sleep(5) # Verify flow rules num_ul_flows = 2 dl_flow_rules = { default_ipv4: [flow_list], default_ipv6: [flow_list], } # Verify if flow rules are created self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) # Now detach the UE self._s1ap_wrapper.s1_util.detach( ue_id, s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value, ue_ctxt_rel, )
class TestAttachDetachMultipleRarTcpData(unittest.TestCase): SPGW_TABLE = 0 LOCAL_PORT = "LOCAL" def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._sessionManager_util = SessionManagerUtil() self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_detach_multiple_rar_tcp_data(self): """ attach + send two ReAuth Reqs to session manager with a""" """ single UE + send TCP data + detach""" """ Verify that the data is sent on 2nd dedicated bearer as it has""" """ matching PFs and higher priority""" 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) datapath = get_datapath() MAX_NUM_RETRIES = 5 gtp_br_util = GTPBridgeUtils() GTP_PORT = gtp_br_util.get_gtp_port_no() 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() # UL Flow description #1 ulFlow1 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5002, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # UL Flow description #2 ulFlow2 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5001, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # UL Flow description #3 ulFlow3 = { "ipv4_dst": "192.168.129.64", # IPv4 destination address "tcp_dst_port": 5003, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # UL Flow description #4 ulFlow4 = { "ipv4_dst": "192.168.129.42", # IPv4 destination address "tcp_dst_port": 5001, # TCP dest port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.UPLINK, # Direction } # DL Flow description #1 dlFlow1 = { "ipv4_src": "192.168.129.42", # IPv4 source address "tcp_src_port": 5001, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # DL Flow description #2 dlFlow2 = { "ipv4_src": "192.168.129.64", # IPv4 source address "tcp_src_port": 5002, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # DL Flow description #3 dlFlow3 = { "ipv4_src": "192.168.129.64", # IPv4 source address "tcp_src_port": 5003, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # DL Flow description #4 dlFlow4 = { "ipv4_src": "192.168.129.42", # IPv4 source address "tcp_src_port": 5001, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # Flow lists to be configured flow_list1 = [ ulFlow1, ulFlow2, ulFlow3, dlFlow1, dlFlow2, dlFlow3, ] flow_list2 = [ ulFlow4, dlFlow4, ] # QoS qos1 = { "qci": 5, # qci value [1 to 9] "priority": 5, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 15, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } qos2 = { "qci": 1, # qci value [1 to 9] "priority": 1, # Range [0-255] "max_req_bw_ul": 10000000, # MAX bw Uplink "max_req_bw_dl": 15000000, # MAX bw Downlink "gbr_ul": 1000000, # GBR Uplink "gbr_dl": 2000000, # GBR Downlink "arp_prio": 1, # ARP priority "pre_cap": 1, # pre-emption capability "pre_vul": 1, # pre-emption vulnerability } policy_id1 = "ims-voice" policy_id2 = "internet" print("Sleeping for 5 seconds") time.sleep(5) print( "********************** Sending RAR for IMSI", "".join([str(i) for i in req.imsi]), ) self._sessionManager_util.send_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id1, flow_list1, qos1, ) # Receive Activate dedicated bearer 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_req1 = response.cast( s1ap_types.UeActDedBearCtxtReq_t ) print("Sleeping for 5 seconds") time.sleep(5) # Send Activate dedicated bearer accept self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req1.bearerId ) print( "********************** Sending 2nd RAR for IMSI", "".join([str(i) for i in req.imsi]), ) self._sessionManager_util.send_ReAuthRequest( "IMSI" + "".join([str(i) for i in req.imsi]), policy_id2, flow_list2, qos2, ) # Receive Activate dedicated bearer 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_req2 = response.cast( s1ap_types.UeActDedBearCtxtReq_t ) print("Sleeping for 5 seconds") time.sleep(5) # Send Activate dedicated bearer accept self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_ctxt_req2.bearerId ) # Check if UL and DL OVS flows are created # UPLINK print("Checking for uplink flow") # try at least 5 times before failing as gateway # might take some time to install the flows in ovs for i in range(MAX_NUM_RETRIES): print("Get uplink flows: attempt ", i) uplink_flows = get_flows( datapath, { "table_id": self.SPGW_TABLE, "match": {"in_port": GTP_PORT}, }, ) if len(uplink_flows) > 2: break time.sleep(5) # sleep for 5 seconds before retrying assert len(uplink_flows) > 2, "Uplink flow missing for UE" self.assertIsNotNone( uplink_flows[0]["match"]["tunnel_id"], "Uplink flow missing tunnel id match", ) # DOWNLINK print("Checking for downlink flow") ue_ip = str(self._s1ap_wrapper._s1_util.get_ip(req.ue_id)) # try at least 5 times before failing as gateway # might take some time to install the flows in ovs for i in range(MAX_NUM_RETRIES): print("Get downlink flows: attempt ", i) downlink_flows = get_flows( datapath, { "table_id": self.SPGW_TABLE, "match": { "nw_dst": ue_ip, "eth_type": 2048, "in_port": self.LOCAL_PORT, }, }, ) if len(downlink_flows) > 2: break time.sleep(5) # sleep for 5 seconds before retrying assert len(downlink_flows) > 2, "Downlink flow missing for UE" self.assertEqual( downlink_flows[0]["match"]["ipv4_dst"], ue_ip, "UE IP match missing from downlink flow", ) actions = downlink_flows[0]["instructions"][0]["actions"] has_tunnel_action = any( action for action in actions if action["field"] == "tunnel_id" and action["type"] == "SET_FIELD" ) self.assertTrue( has_tunnel_action, "Downlink flow missing set tunnel action" ) with self._s1ap_wrapper.configUplinkTest(req, duration=1) as test: test.verify() print("Sleeping for 5 seconds") 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]), attach.esmInfo.epsBearerId, act_ded_ber_ctxt_req1.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) 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] ) print("Checking that uplink/downlink flows were deleted") flows = get_flows( datapath, {"table_id": self.SPGW_TABLE, "priority": 0} ) self.assertEqual( len(flows), 2, "There should only be 2 default table 0 flows" )
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 TestAttachNwInitiatedDetachWithMmeRestart(unittest.TestCase): def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper( stateless_mode=MagmadUtil.stateless_cmds.ENABLE, ) self._spgw_util = SpgwUtil() def tearDown(self): self._s1ap_wrapper.cleanup() def test_attach_nw_initiated_detach_with_mme_restart(self): """ The test case validates retransmission of Detach Request after MME restarts Step 1: UE attaches to network Step 2: Send request to delete default bearer, since deletion is invoked for default bearer, MME initaites detach procedure Step 3: MME starts 3422 timer to receive Detach Accept message Step 4: Send command to restart MME service to validate the behavior of 3422 timer, on MME recovery, it sends Detach Request Step 5: S1ap tester shall wait on Detach Request and send Detach Accept message """ 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, ) # Wait on EMM Information from MME self._s1ap_wrapper._s1_util.receive_emm_info() 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( "************************* 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) # 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 second 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 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, )
def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper( stateless_mode=MagmadUtil.stateless_cmds.ENABLE, ) self._spgw_util = SpgwUtil()
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 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 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 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 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)
def setUp(self): self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil()
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()
def setUp(self): """Initialize""" self._s1ap_wrapper = s1ap_wrapper.TestWrapper() self._spgw_util = SpgwUtil()
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, )