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