class TestAttachServiceWithMultiPdnsAndBearers(unittest.TestCase):
def setUp(self):
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._sessionManager_util = SessionManagerUtil()
def tearDown(self):
self._s1ap_wrapper.cleanup()
def test_attach_service_with_multi_pdns_and_bearers(self):
"""
Test with a single UE attach + add secondary PDN
+ add 2 dedicated bearers + UE context release + service request
+ detach"""
self._s1ap_wrapper.configUEDevice(1)
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,
)
# UL Flow description #1
ulFlow1 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5002, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# UL Flow description #2
ulFlow2 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5001, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# UL Flow description #3
ulFlow3 = {
"ipv4_dst": "192.168.129.64", # IPv4 destination address
"tcp_dst_port": 5003, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# UL Flow description #4
ulFlow4 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5001, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# DL Flow description #1
dlFlow1 = {
"ipv4_src": "192.168.129.42", # IPv4 source address
"tcp_src_port": 5001, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# DL Flow description #2
dlFlow2 = {
"ipv4_src": "192.168.129.64", # IPv4 source address
"tcp_src_port": 5002, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# DL Flow description #3
dlFlow3 = {
"ipv4_src": "192.168.129.64", # IPv4 source address
"tcp_src_port": 5003, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# DL Flow description #4
dlFlow4 = {
"ipv4_src": "192.168.129.42", # IPv4 source address
"tcp_src_port": 5001, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# Flow lists to be configured
flow_list1 = [
ulFlow1,
ulFlow2,
ulFlow3,
dlFlow1,
dlFlow2,
dlFlow3,
]
flow_list2 = [
ulFlow4,
dlFlow4,
]
# QoS
qos1 = {
"qci": 1, # qci value [1 to 9]
"priority": 1, # Range [0-255]
"max_req_bw_ul": 10000000, # MAX bw Uplink
"max_req_bw_dl": 15000000, # MAX bw Downlink
"gbr_ul": 1000000, # GBR Uplink
"gbr_dl": 2000000, # GBR Downlink
"arp_prio": 1, # ARP priority
"pre_cap": 1, # pre-emption capability
"pre_vul": 1, # pre-emption vulnerability
}
qos2 = {
"qci": 2, # qci value [1 to 9]
"priority": 5, # Range [0-255]
"max_req_bw_ul": 10000000, # MAX bw Uplink
"max_req_bw_dl": 15000000, # MAX bw Downlink
"gbr_ul": 1000000, # GBR Uplink
"gbr_dl": 2000000, # GBR Downlink
"arp_prio": 1, # ARP priority
"pre_cap": 1, # pre-emption capability
"pre_vul": 1, # pre-emption vulnerability
}
policy_id1 = "internet"
policy_id2 = "ims"
# Now actually complete the attach
attach = self._s1ap_wrapper._s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
addr = attach.esmInfo.pAddr.addrInfo
default_ip = ipaddress.ip_address(bytes(addr[:4]))
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
# Delay to ensure S1APTester sends attach complete before sending UE
# context release
print("Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearer for default bearer 5
print("********************** Adding dedicated bearer to magma.ipv4"
" PDN")
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id1,
flow_list1,
qos1,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value)
act_ded_ber_req_oai_apn = response.cast(
s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_req_oai_apn.bearerId)
print("Sleeping for 5 seconds")
time.sleep(5)
# Send PDN Connectivity Request
apn = "ims"
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo
sec_ip = ipaddress.ip_address(bytes(addr[:4]))
print(
"********************** Sending Activate default EPS bearer "
"context accept for UE id ",
ue_id,
)
print("Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearer to 2nd PDN
print("********************** Adding dedicated bearer to ims PDN")
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id2,
flow_list2,
qos2,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value)
act_ded_ber_req_ims_apn = response.cast(
s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_req_ims_apn.bearerId)
print(
"************* Added dedicated bearer",
act_ded_ber_req_ims_apn.bearerId,
)
print("Sleeping for 5 seconds")
time.sleep(5)
dl_flow_rules = {
default_ip: [flow_list1],
sec_ip: [flow_list2],
}
# 1 UL flow is created per bearer
num_ul_flows = 4
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows,
dl_flow_rules)
print("*********** Moving UE to idle mode")
print(
"************* Sending UE context release request ",
"for UE id ",
ue_id,
)
# Send UE context release request to move UE to idle mode
req = s1ap_types.ueCntxtRelReq_t()
req.ue_Id = ue_id
req.cause.causeVal = gpp_types.CauseRadioNetwork.USER_INACTIVITY.value
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, 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 5 seconds")
time.sleep(5)
# Verify if paging flow rules are created
ip_list = [default_ip, sec_ip]
self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list)
print(
"************************* Sending Service request for UE id ",
ue_id,
)
# Send service request to reconnect UE
req = s1ap_types.ueserviceReq_t()
req.ue_Id = ue_id
req.ueMtmsi = s1ap_types.ueMtmsi_t()
req.ueMtmsi.pres = False
req.rrcCause = s1ap_types.Rrc_Cause.TFW_MO_SIGNALLING.value
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SERVICE_REQUEST, req)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value)
print("Sleeping for 5 seconds")
time.sleep(5)
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows,
dl_flow_rules)
print("Sleeping for 5 seconds")
time.sleep(5)
print("************************* Running UE detach for UE id ", ue_id)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, True)
class TestDedicatedBearerActivationIdleModePagingTmrExpiry(unittest.TestCase):
def setUp(self):
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._sessionManager_util = SessionManagerUtil()
def tearDown(self):
self._s1ap_wrapper.cleanup()
def test_dedicated_bearer_activation_idle_mode_pag_tmr_exp(self):
"""
Test with a single UE attach + UE context release
+ dedicated bearer activation + page the UE + Paging timer expires
+ send dedicated bearer activation reject to SPGW"""
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
imsi = req.imsi
# Add dedicated bearer for default bearer 5
# UL Flow description #1
ulFlow1 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5002, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# UL Flow description #2
ulFlow2 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5001, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# UL Flow description #3
ulFlow3 = {
"ipv4_dst": "192.168.129.64", # IPv4 destination address
"tcp_dst_port": 5003, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# UL Flow description #4
ulFlow4 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5004, # TCP dest port
"ip_proto": "TCP", # Protocol Type
"direction": "UL", # Direction
}
# DL Flow description #1
dlFlow1 = {
"ipv4_src": "192.168.129.42", # IPv4 source address
"tcp_src_port": 5001, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# DL Flow description #2
dlFlow2 = {
"ipv4_src": "192.168.129.64", # IPv4 source address
"tcp_src_port": 5002, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# DL Flow description #3
dlFlow3 = {
"ipv4_src": "192.168.129.64", # IPv4 source address
"tcp_src_port": 5003, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# DL Flow description #4
dlFlow4 = {
"ipv4_src": "192.168.129.42", # IPv4 source address
"tcp_src_port": 5004, # TCP source port
"ip_proto": "TCP", # Protocol Type
"direction": "DL", # Direction
}
# Flow list to be configured
flow_list = [
ulFlow1,
ulFlow2,
ulFlow3,
ulFlow4,
dlFlow1,
dlFlow2,
dlFlow3,
dlFlow4,
]
# 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
}
policy_id = "internet"
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,
)
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()
# Delay to ensure S1APTester sends attach complete before sending UE
# context release
print("*********** Sleeping for 5 seconds")
time.sleep(5)
print("*********** Moving UE to idle mode")
print(
"*********** Sending UE context release request ",
"for UE id ",
ue_id,
)
# Send UE context release request to move UE to idle mode
req = s1ap_types.ueCntxtRelReq_t()
req.ue_Id = ue_id
req.cause.causeVal = gpp_types.CauseRadioNetwork.USER_INACTIVITY.value
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, req
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value
)
# Verify if paging flow rules are created
ip_list = [default_ip]
self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list)
print("Sleeping for 5 seconds")
time.sleep(5)
print(
"************* Adding dedicated bearer to magma.ipv4"
" PDN in idle mode"
)
print(
"************* Sending RAR for IMSI",
"".join([str(i) for i in imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in imsi]),
policy_id,
flow_list,
qos,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PAGING_IND.value
)
print("*********** Received Paging for UE id ", ue_id)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PAGING_IND.value
)
print("*********** Received second Paging for UE id ", ue_id)
print("*********** Sleeping for 5 seconds")
time.sleep(5)
print("*********** Running UE detach for UE id ", ue_id)
# Now detach the UE
detach_req = s1ap_types.uedetachReq_t()
detach_req.ue_Id = ue_id
detach_req.ueDetType = (
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value
)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_DETACH_REQUEST, detach_req
)
class TestAttachDetachRarTcpData(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(self):
""" attach/detach + send ReAuth Req to session manager 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)
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
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": 15, # 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)
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id,
flow_list,
qos,
)
# 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()
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])
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 TestOutOfOrderErabSetupRspDedicatedBearer(unittest.TestCase):
def setUp(self):
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._sessionManager_util = SessionManagerUtil()
def tearDown(self):
self._s1ap_wrapper.cleanup()
def test_outoforder_erab_setup_rsp_dedicated_bearer(self):
""" Attach a single UE + add dedicated bearer + send erab setup rsp
message out of order for the dedicated bearer"""
num_ue = 1
self._s1ap_wrapper.configUEDevice(num_ue)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
# 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": 1, # qci value [1 to 9]
"priority": 15, # 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 = "internet"
print(
"************************* Running End to End attach for UE id ",
ue_id,
)
# Attach
attach = self._s1ap_wrapper.s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
addr = attach.esmInfo.pAddr.addrInfo
default_ip = ipaddress.ip_address(bytes(addr[:4]))
# Send indication to delay sending of erab setup rsp
delay_erab_setup_resp = s1ap_types.UeDelayErabSetupRsp()
delay_erab_setup_resp.ue_Id = ue_id
delay_erab_setup_resp.flag = 1
# Timer value in secs to delay erab setup rsp
delay_erab_setup_resp.tmrVal = 6000
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SET_DELAY_ERAB_SETUP_RSP,
delay_erab_setup_resp,
)
print(
"Sent UE_SET_DELAY_ERAB_SETUP_RSP with delay value of %d secs"
% (delay_erab_setup_resp.tmrVal)
)
print("Sleeping for 5 seconds")
time.sleep(5)
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id,
flow_list,
qos,
)
# 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(
ue_id, act_ded_ber_ctxt_req.bearerId
)
# Delay to ensure erab setup rsp is sent out of order
print("Sleeping for 10 seconds")
time.sleep(10)
dl_flow_rules = {
default_ip: [flow_list],
}
# ipv4 default bearer + dedicated bearer
num_ul_flows = 2
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows, dl_flow_rules
)
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 TestAttachStandaloneActvDfltBearCtxtRejDedBerActivation(
unittest.TestCase):
def setUp(self):
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._sessionManager_util = SessionManagerUtil()
def tearDown(self):
self._s1ap_wrapper.cleanup()
def test_attach_standalone_act_dflt_ber_ctxt_rej_ded_bearer_activation(
self, ):
""" Attach + PDN connectivity req + activate default
EPS bearer reject for secondary PDN
+ initiate RAR for the secondary PDN + detach"""
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
# APN of the secondary PDN
ims = {
"apn_name": "ims", # APN-name
"qci": 5, # qci
"priority": 15, # priority
"pre_cap": 0, # preemption-capability
"pre_vul": 0, # preemption-vulnerability
"mbr_ul": 200000000, # MBR UL
"mbr_dl": 100000000, # MBR DL
}
# 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": 1, # qci value [1 to 9]
"priority": 15, # 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"
# APN list to be configured
apn_list = [ims]
self._s1ap_wrapper.configAPN(
"IMSI" + "".join([str(i) for i in req.imsi]), apn_list)
print(
"************************* Running End to End attach for UE id ",
req.ue_id,
)
# 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)
# Verify if flow rules are created
# No dedicated bearers, so flow list will be empty
dl_flow_rules = {
default_ip: [],
}
# 1 UL flow for the default bearer
num_ul_flows = 1
self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows,
dl_flow_rules)
print("Sleeping for 5 seconds")
time.sleep(5)
# Trigger Activate Default EPS Bearer Context Reject indication
# so that s1ap tester sends Activate default EPS bearer context reject
# instead of Activate default EPS bearer context accept
def_ber_rej = s1ap_types.ueActvDfltEpsBearerCtxtRej_t()
def_ber_rej.ue_Id = req.ue_id
def_ber_rej.bearerId = attach.esmInfo.epsBearerId
def_ber_rej.cause = s1ap_types.TFW_EMM_CAUSE_PROT_ERR_UNSP
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.
UE_STANDALONE_ACTV_DEFAULT_EPS_BEARER_CNTXT_REJECT,
def_ber_rej,
)
print(
"Sent STANDALONE_ACTV_DEFAULT_EPS_BEARER_CNTXT_REJECT indication")
print("Sleeping for 5 seconds")
time.sleep(5)
# Send PDN Connectivity Request
apn = "ims"
self._s1ap_wrapper.sendPdnConnectivityReq(req.ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
print("************************* Sending Activate default EPS bearer "
"context reject for UE id %d and bearer %d" %
(req.ue_id, act_def_bearer_req.m.pdnInfo.epsBearerId))
print("Sleeping for 5 seconds")
time.sleep(5)
# Dedicated bearer will not be established as the seconday PDN
# establishment failed
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id,
flow_list,
qos,
)
print("Sleeping for 5 seconds")
time.sleep(5)
# Verify that ovs rules are not created for the seconday pdn and
# dedicated bearer as UE rejected the establishment of secondary pdn
self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows,
dl_flow_rules)
print("Sleeping for 5 seconds")
time.sleep(5)
# Now detach the UE
print(
"************************* Running UE detach (switch-off) for ",
"UE id ",
req.ue_id,
)
self._s1ap_wrapper.s1_util.detach(
req.ue_id,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
False,
)
class TestDedicatedBearerActivationIdleMode(unittest.TestCase):
def setUp(self):
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._sessionManager_util = SessionManagerUtil()
def tearDown(self):
self._s1ap_wrapper.cleanup()
def test_dedicated_bearer_activation_idle_mode(self):
"""
Test with a single UE attach + UE context release +
trigger dedicated bearer activation
+ Page the UE + detach"""
# 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 list 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"
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
imsi = req.imsi
print("*********** Running End to End attach for UE id ", ue_id)
# Now actually complete the attach
attach = self._s1ap_wrapper._s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
addr = attach.esmInfo.pAddr.addrInfo
default_ip = ipaddress.ip_address(bytes(addr[:4]))
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
# Delay to ensure S1APTester sends attach complete before sending UE
# context release
print("*********** Sleeping for 5 seconds")
time.sleep(5)
# Move UE to idle mode
print("*********** Moving UE to idle mode")
print(
"*********** Sending UE context release request ",
"for UE id ",
ue_id,
)
# Send UE context release request to move UE to idle mode
rel_req = s1ap_types.ueCntxtRelReq_t()
rel_req.ue_Id = ue_id
rel_req.cause.causeVal = (
gpp_types.CauseRadioNetwork.USER_INACTIVITY.value
)
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, rel_req
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_CTX_REL_IND.value
)
# Verify if paging flow rules are created
ip_list = [default_ip]
self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list)
print("*********** Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearers for default bearer 5
print(
"************* Adding dedicated bearers to magma.ipv4"
" PDN in idle mode for UE",
ue_id,
)
print(
"********************** Sending 1st RAR for IMSI",
"".join([str(i) for i in imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in imsi]),
policy_id1,
flow_list1,
qos1,
)
# Add 2nd dedicated bearer for default bearer 5
print(
"********************** Sending 2nd RAR for IMSI",
"".join([str(i) for i in imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in imsi]),
policy_id2,
flow_list2,
qos2,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PAGING_IND.value
)
print("*********** Received Paging for UE id ", ue_id)
print("*********** Sending Service request for UE id ", ue_id)
# 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_MO_SIGNALLING.value
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SERVICE_REQUEST, ser_req
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value
)
print("*********** Received ICS Request for UE id ", ue_id)
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_apn1 = response.cast(
s1ap_types.UeActDedBearCtxtReq_t
)
print(
"*********** Received Activate dedicated EPS bearer"
" req for bearer ",
act_ded_ber_req_oai_apn1.bearerId,
)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
ue_id, act_ded_ber_req_oai_apn1.bearerId
)
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_apn2 = response.cast(
s1ap_types.UeActDedBearCtxtReq_t
)
print(
"*********** Received Activate dedicated EPS bearer"
" req for bearer ",
act_ded_ber_req_oai_apn2.bearerId,
)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
ue_id, act_ded_ber_req_oai_apn2.bearerId
)
# Verify if flow rules are created
dl_flow_rules = {default_ip: [flow_list1, flow_list2]}
# 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("*********** Sleeping for 5 seconds")
time.sleep(5)
print("*********** Running UE detach for UE id ", ue_id)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, True
)
class TestIPv4v6SecondaryPdnWithDedBearerMultiUe(unittest.TestCase):
def setUp(self):
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._sessionManager_util = SessionManagerUtil()
def tearDown(self):
self._s1ap_wrapper.cleanup()
def test_ipv4v6_secondary_pdn_with_ded_bearer_multi_ue(self):
""" Attach a single UE + add a secondary pdn with
IPv4v6 + add dedicated bearer + detach
Repeat for 4 UEs"""
num_ues = 4
ue_ids = []
default_ip = []
sec_ip_ipv4 = []
sec_ip_ipv6 = []
# APN of the secondary PDN
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
}
# 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 = {
"ipv6_dst": "5e90:db7b:b18e::1556", # IPv6 destination address
"tcp_dst_port": 5003, # 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 = {
"ipv6_src": "6e31:1a95:1e7c::df1", # IPv6 source address
"tcp_src_port": 5003, # TCP source port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.DOWNLINK, # Direction
}
# Flow lists to be configured
flow_list = [
ulFlow1,
ulFlow2,
ulFlow3,
dlFlow1,
dlFlow2,
dlFlow3,
]
# 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
}
policy_id = "ims"
self._s1ap_wrapper.configUEDevice(num_ues)
for i in range(num_ues):
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
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.append(ipaddress.ip_address(bytes(addr[:4])))
ue_ids.append(ue_id)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
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
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)
addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo
sec_ip_ipv4.append(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)
routerAdv = response.cast(s1ap_types.ueRouterAdv_t)
print(
"******************* Received Router Advertisement for APN-%s"
" ,bearer id-%d" % (apn, routerAdv.bearerId))
ipv6_addr = "".join([chr(i)
for i in routerAdv.ipv6Addr]).rstrip("\x00")
print("******* UE IPv6 address: ", ipv6_addr)
sec_ip_ipv6.append(ipaddress.ip_address(ipv6_addr))
print("***** Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearer
print("********************** Adding dedicated bearer to ims PDN")
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_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,
)
print("***** Sleeping for 10 seconds")
time.sleep(10)
# ipv4 default pdn + ipv4v6(ims) pdn +
# dedicated bearer for ims pdn for 4 UEs
num_ul_flows = 12
for i in range(num_ues):
dl_flow_rules = {
default_ip[i]: [],
sec_ip_ipv4[i]: [flow_list],
sec_ip_ipv6[i]: [flow_list],
}
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows, dl_flow_rules)
print("***** Sleeping for 5 seconds")
time.sleep(5)
for ue in ue_ids:
print(
"******************* Running UE detach (switch-off) for ",
"UE id ",
ue,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
