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 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 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 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 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 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 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 TestAttachDetachMultipleDedicated(unittest.TestCase): """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_attach_detach_multiple_dedicated(self): """attach/detach + multiple dedicated bearer test with a single UE""" num_dedicated_bearers = 3 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() print("Sleeping for 2 seconds") 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], qci_val=i + 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_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 ", "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 3 dedicated bearers dl_flow_rules = { default_ip: flow_lists, } # 1 default UL flow + 3 dedicated bearer UL flows num_ul_flows = 4 self._s1ap_wrapper.s1_util.verify_flow_rules( num_ul_flows, dl_flow_rules, ) for i in range(num_dedicated_bearers): 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") self._s1ap_wrapper.sendDeactDedicatedBearerAccept( req.ue_id, bearer_ids[i], ) print( "********************** Deleted dedicated bearer with " "bearer id", bearer_ids[i], ) print("Sleeping for 5 seconds") time.sleep(5) # Verify if flow rules for dedicated bearers are deleted 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, )
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 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 TestAttachDetachRarTcpDataWithHE(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_rar_tcp_data_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() GTP_PORT = gtp_br_util.get_gtp_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 } # 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": 5004, # 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": 5004, # TCP source port "ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type "direction": FlowMatch.DOWNLINK, # Direction } # Flow list to be configured flow_list = [ ulFlow1, ulFlow2, ulFlow3, ulFlow4, dlFlow1, dlFlow2, dlFlow3, dlFlow4, ] # 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]) print( "********************** Sending RAR for ", imsi, ) he_domain1 = "192.168.128.1" assert utils.he_count_record_of_imsi_to_domain(imsi, he_domain1) == 0 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 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) > 1: break time.sleep(5) # sleep for 5 seconds before retrying assert len(uplink_flows) > 1, "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) > 1: break time.sleep(5) # sleep for 5 seconds before retrying assert len(downlink_flows) > 1, "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", ) print("Sleeping for 5 seconds") time.sleep(5) with self._s1ap_wrapper.configUplinkTest(req, duration=1) as test: test.verify() 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()
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 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 TestAttachNwInitiatedDetachFail(unittest.TestCase): """ S1AP Integration test for Failed Network Initiated Detach """ 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() def tearDown(self): """Clean up utilities and sctp connection """ self._s1ap_wrapper.cleanup() def test_attach_nw_initiated_detach_fail(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 initiates detach procedure Step 3: MME starts 3422 timer to receive Detach Accept message Step 4: S1AP tester ignores and does not send Detach Accept """ 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 for _ in range(5): 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") time.sleep(6)
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 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 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 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 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()
class TestAttachDetachSecondaryPdnWithDedicatedBearerDeactivate( unittest.TestCase): """Test secondary pdn with dedicated bearer deactivation""" 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_secondary_pdn_with_dedicated_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 _ 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 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 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, ) print("Sleeping for 5 seconds") time.sleep(5) # Add dedicated bearer to 2nd PDN print("********************** Adding dedicated bearer to ims PDN") # 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_req_ims_apn = response.cast( s1ap_types.UeActDedBearCtxtReq_t, ) self._s1ap_wrapper.sendActDedicatedBearerAccept( req.ue_id, act_ded_ber_req_ims_apn.bearerId, ) print( "************* Added dedicated bearer", act_ded_ber_req_ims_apn.bearerId, ) print("Sleeping for 5 seconds") time.sleep(5) # 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, ) print("Sleeping for 5 seconds") 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, ) print("Sleeping for 5 seconds") 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]), attach.esmInfo.epsBearerId, 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, ) print("Sleeping for 5 seconds") time.sleep(5) # Verify that flow rules for dedicated bearers are deleted dl_flow_rules = { default_ip: [], sec_ip: [], } # 2 UL flows for default and secondary pdns num_ul_flows = 2 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_SWITCHOFF_DETACH.value, False, )