def test_attach_detach_disconnect_default_pdn(self):
""" Attach a single UE and send PDN disconnect request
for the default bearer """
num_ue = 1
self._s1ap_wrapper.configUEDevice(num_ue)
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()
time.sleep(5)
# Send PDN Disconnect
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = ue_id
pdn_disconnect_req.epsBearerId = 5
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req,
)
# Receive PDN Disconnect Reject
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REJ.value,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False,
)
def test_secondary_pdn_conn_ded_bearer_looped(self):
""" Attach a single UE and send standalone PDN Connectivity
Request + add dedicated bearer to each default bearer
repeat 3 times """
num_ues = 1
loop = 3
self._s1ap_wrapper.configUEDevice(num_ues)
for i in range(num_ues):
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
# APN of the secondary PDN
ims = {
"apn_name": "ims", # APN-name
"qci": 5, # qci
"priority": 15, # priority
"pre_cap": 0, # preemption-capability
"pre_vul": 0, # preemption-vulnerability
"mbr_ul": 200000000, # MBR UL
"mbr_dl": 100000000, # MBR DL
}
# APN list to be configured
apn_list = [ims]
self._s1ap_wrapper.configAPN(
"IMSI" + "".join([str(i) for i in req.imsi]), apn_list)
print(
"********************* Running End to End attach for UE id ",
ue_id,
)
# Attach
self._s1ap_wrapper.s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
for j in range(loop):
print("********************* Iteration - ", j + 1)
# Send PDN Connectivity Request
print("********************* Sending PDN Connectivity Req")
apn = "ims"
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context req
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value,
)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
print(
"********************** Sending Activate default EPS "
"bearer context accept for UE id ",
ue_id,
)
# Add dedicated bearer to 2nd PDN
print(
"********************** Adding dedicated bearer to IMSI",
"".join([str(i) for i in req.imsi]),
)
self._spgw_util.create_bearer(
"IMSI" + "".join([str(i) for i in req.imsi]),
act_def_bearer_req.m.pdnInfo.epsBearerId,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value,
)
act_ded_ber_ctxt_req = response.cast(
s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_ctxt_req.bearerId)
time.sleep(5)
# Send PDN Disconnect
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = ue_id
pdn_disconnect_req.epsBearerId = (
act_def_bearer_req.m.pdnInfo.epsBearerId)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ,
pdn_disconnect_req)
# Receive UE_DEACTIVATE_BER_REQ
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value,
)
print("*************** Received deactivate eps bearer context"
" request")
# Send DeactDedicatedBearerAccept
deactv_bearer_req = response.cast(
s1ap_types.UeDeActvBearCtxtReq_t)
self._s1ap_wrapper.sendDeactDedicatedBearerAccept(
req.ue_id, deactv_bearer_req.bearerId)
time.sleep(5)
print(
"******************** Running UE detach (switch-off) for ",
"UE id ",
ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
False,
)
def 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,
)
def test_outoforder_erab_setup_rsp_default_bearer(self):
""" Attach a single UE and send erab setup rsp message
out of order for the secondary pdn"""
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
attach = self._s1ap_wrapper.s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
addr = attach.esmInfo.pAddr.addrInfo
default_ip = ipaddress.ip_address(bytes(addr[:4]))
# Send indication to delay sending of erab setup rsp
delay_erab_setup_resp = s1ap_types.UeDelayErabSetupRsp()
delay_erab_setup_resp.ue_Id = ue_id
delay_erab_setup_resp.flag = 1
# Timer value in secs to delay erab setup rsp
delay_erab_setup_resp.tmrVal = 6000
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SET_DELAY_ERAB_SETUP_RSP,
delay_erab_setup_resp,
)
print(
"Sent UE_SET_DELAY_ERAB_SETUP_RSP with delay value of %d secs" %
(delay_erab_setup_resp.tmrVal), )
# 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,
)
# Delay to ensure erab setup rsp is sent out of order
print("Sleeping for 10 seconds")
time.sleep(10)
dl_flow_rules = {
default_ip: [],
sec_ip: [],
}
# default bearer + ims bearer
num_ul_flows = 2
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows,
dl_flow_rules,
)
# 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(
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,
)
def test_seconday_pdn_conn_req_multi_ue(self):
""" attach/detach + PDN Connectivity Requests 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
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()
ue_ids.append(ue_id)
self._s1ap_wrapper._ue_idx = 0
for _ 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,
)
bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId)
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
# 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])
time.sleep(2)
# Now detach the UE
for ue in ue_ids:
print(
"******************** Running UE detach (switch-off) for ",
"UE id ",
ue,
)
self._s1ap_wrapper.s1_util.detach(
ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_concurrent_secondary_pdn_reject(self):
"""Attach a single UE and send concurrent standalone PDN Connectivity
Requests, verify that the PDN request sent with the APN that is not
configured(internet apn) gets rejected
"""
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
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()
# Send PDN Connectivity Request with APN that is not configured
apn = "internet"
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Send PDN Connectivity Request for ims APN
apn = "ims"
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Receive PDN connectivity reject for internet APN
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value,
)
# Verify cause
pdn_con_rsp = response.cast(s1ap_types.uePdnConRsp_t)
self.assertEqual(
pdn_con_rsp.m.conRejInfo.cause,
s1ap_types.TFW_ESM_CAUSE_MISSING_OR_UNKNOWN_APN,
)
print(
"************************* Received PDN Connectivity "
"reject for UE id =",
ue_id,
)
# Receive PDN CONN RSP/Activate default EPS bearer context
# request for ims APN
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(
"************************* Received Activate default EPS bearer "
"context request for UE id=%d, with bearer id=%d "
% (
act_def_bearer_req.ue_Id,
act_def_bearer_req.m.pdnInfo.epsBearerId,
),
)
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 =",
act_def_bearer_req.ue_Id,
)
print("Sleeping for 5 seconds")
time.sleep(5)
# Verify if flow rules are created
# No dedicated bearers, so flowlist is empty
dl_flow_rules = {
default_ip: [],
sec_ip: [],
}
# 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,
)
# Send PDN Disconnect
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = act_def_bearer_req.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,
)
deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t)
print(
"******************* Received deactivate eps bearer context"
" request for UE id=%d, with bearer id=%d"
% (deactv_bearer_req.ue_Id, deactv_bearer_req.bearerId),
)
# Send DeactDedicatedBearerAccept
self._s1ap_wrapper.sendDeactDedicatedBearerAccept(
deactv_bearer_req.ue_Id, deactv_bearer_req.bearerId,
)
print("Sleeping for 5 seconds")
time.sleep(5)
# Verify that flow rule is deleted for ims secondary pdn
dl_flow_rules = {
default_ip: [],
}
# 1 UL flow is created per bearer
num_ul_flows = 1
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_ctxt_release=False,
)
def test_secondary_pdn_with_dedicated_bearer_multi_ue(self):
""" attach/detach + PDN Connectivity Requests + dedicated bearer for 4
UEs """
num_ues = 4
ue_ids = []
bearer_ids = []
self._s1ap_wrapper.configUEDevice(num_ues)
for _ in range(num_ues):
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
# APN of the secondary PDN
ims = {
"apn_name": "ims", # APN-name
"qci": 5, # qci
"priority": 15, # priority
"pre_cap": 0, # preemption-capability
"pre_vul": 0, # preemption-vulnerability
"mbr_ul": 200000000, # MBR UL
"mbr_dl": 100000000, # MBR DL
}
# APN list to be configured
apn_list = [ims]
self._s1ap_wrapper.configAPN(
"IMSI" + "".join([str(i) for i in req.imsi]), apn_list)
print(
"******************* Running End to End attach for UE id ",
ue_id,
)
# Attach
self._s1ap_wrapper.s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
ue_ids.append(ue_id)
self._s1ap_wrapper._ue_idx = 0
for i in range(num_ues):
req = self._s1ap_wrapper.ue_req
# Send PDN Connectivity Request
apn = "ims"
ue_id = req.ue_id
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
print(
"********************** Sending Activate default EPS bearer "
"context accept for UE id ",
ue_id,
)
print(
"********************** Added IMS PDN with bearer id",
act_def_bearer_req.m.pdnInfo.epsBearerId,
)
bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId)
print("********************* Sleeping for 2 seconds")
time.sleep(2)
# Add dedicated bearer to IMS PDN
print("********************** Adding dedicated bearer to IMS PDN")
self._spgw_util.create_bearer(
"IMSI" + "".join([str(i) for i in req.imsi]),
act_def_bearer_req.m.pdnInfo.epsBearerId,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value)
act_ded_ber_ctxt_req = response.cast(
s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_ctxt_req.bearerId)
print(
"********************** Added dedicated bearer",
act_ded_ber_ctxt_req.bearerId,
)
print("********************* Sleeping for 5 seconds")
time.sleep(5)
self._s1ap_wrapper._ue_idx = 0
for i in range(num_ues):
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
print("******************* Deleting IMS PDN for ue", ue_id)
# Send PDN Disconnect
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = ue_id
pdn_disconnect_req.epsBearerId = bearer_ids[i]
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req)
# Receive UE_DEACTIVATE_BER_REQ
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type,
s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value,
)
print("******************* Received deactivate eps bearer context"
" request")
# Send DeactDedicatedBearerAccept
self._s1ap_wrapper.sendDeactDedicatedBearerAccept(
ue_id, bearer_ids[i])
print(
"******************* Deleted IMS PDN with bearer ID",
bearer_ids[i],
)
print("********************* Sleeping for 5 seconds")
time.sleep(2)
# Now detach the UE
for ue in ue_ids:
print(
"******************** Running UE detach (switch-off) for ",
"UE id ",
ue,
)
self._s1ap_wrapper.s1_util.detach(
ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_attach_service_with_multi_pdns_and_bearers_mt_data(self):
"""
Attach a UE + add secondary PDN
+ add 2 dedicated bearers + UE context release
+ trigger MT data + service request
+ PDN disconnect + detach
"""
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
ips = []
# 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)
# UL Flow description #1
ulFlow1 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5002, # TCP dest port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.UPLINK, # Direction
}
# UL Flow description #2
ulFlow2 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5001, # TCP dest port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.UPLINK, # Direction
}
# UL Flow description #3
ulFlow3 = {
"ipv4_dst": "192.168.129.64", # IPv4 destination address
"tcp_dst_port": 5003, # TCP dest port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.UPLINK, # Direction
}
# UL Flow description #4
ulFlow4 = {
"ipv4_dst": "192.168.129.42", # IPv4 destination address
"tcp_dst_port": 5001, # TCP dest port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.UPLINK, # Direction
}
# DL Flow description #1
dlFlow1 = {
"ipv4_src": "192.168.129.42", # IPv4 source address
"tcp_src_port": 5001, # TCP source port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.DOWNLINK, # Direction
}
# DL Flow description #2
dlFlow2 = {
"ipv4_src": "192.168.129.64", # IPv4 source address
"tcp_src_port": 5002, # TCP source port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.DOWNLINK, # Direction
}
# DL Flow description #3
dlFlow3 = {
"ipv4_src": "192.168.129.64", # IPv4 source address
"tcp_src_port": 5003, # TCP source port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.DOWNLINK, # Direction
}
# DL Flow description #4
dlFlow4 = {
"ipv4_src": "192.168.129.42", # IPv4 source address
"tcp_src_port": 5001, # TCP source port
"ip_proto": FlowMatch.IPPROTO_TCP, # Protocol Type
"direction": FlowMatch.DOWNLINK, # Direction
}
# Flow lists to be configured
flow_list1 = [
ulFlow1,
ulFlow2,
ulFlow3,
dlFlow1,
dlFlow2,
dlFlow3,
]
flow_list2 = [
ulFlow4,
dlFlow4,
]
# QoS
qos1 = {
"qci": 1, # qci value [1 to 9]
"priority": 1, # Range [0-255]
"max_req_bw_ul": 10000000, # MAX bw Uplink
"max_req_bw_dl": 15000000, # MAX bw Downlink
"gbr_ul": 1000000, # GBR Uplink
"gbr_dl": 2000000, # GBR Downlink
"arp_prio": 1, # ARP priority
"pre_cap": 1, # pre-emption capability
"pre_vul": 1, # pre-emption vulnerability
}
qos2 = {
"qci": 2, # qci value [1 to 9]
"priority": 5, # Range [0-255]
"max_req_bw_ul": 10000000, # MAX bw Uplink
"max_req_bw_dl": 15000000, # MAX bw Downlink
"gbr_ul": 1000000, # GBR Uplink
"gbr_dl": 2000000, # GBR Downlink
"arp_prio": 1, # ARP priority
"pre_cap": 1, # pre-emption capability
"pre_vul": 1, # pre-emption vulnerability
}
policy_id1 = "internet"
policy_id2 = "ims"
print(
"************************* Running End to End attach for UE id ",
ue_id,
)
# Now actually complete the attach
attach = self._s1ap_wrapper._s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
addr = attach.esmInfo.pAddr.addrInfo
default_ip = ipaddress.ip_address(bytes(addr[:4]))
ips.append(default_ip)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
# Delay to ensure S1APTester sends attach complete before sending UE
# context release
print("Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearer for default bearer 5
print("********************** Adding dedicated bearer to magma.ipv4"
" PDN")
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id1,
flow_list1,
qos1,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value)
act_ded_ber_req_oai_apn = response.cast(
s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_req_oai_apn.bearerId)
print("Sleeping for 5 seconds")
time.sleep(5)
# Send PDN Connectivity Request
apn = "ims"
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo
sec_ip = ipaddress.ip_address(bytes(addr[:4]))
ips.append(sec_ip)
print(
"********************** Sending Activate default EPS bearer "
"context accept for UE id ",
ue_id,
)
print("Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearer to 2nd PDN
print("********************** Adding dedicated bearer to ims PDN")
print(
"********************** Sending RAR for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._sessionManager_util.create_ReAuthRequest(
"IMSI" + "".join([str(i) for i in req.imsi]),
policy_id2,
flow_list2,
qos2,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value)
act_ded_ber_req_ims_apn = response.cast(
s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_req_ims_apn.bearerId)
print(
"************* Added dedicated bearer",
act_ded_ber_req_ims_apn.bearerId,
)
print("Sleeping for 5 seconds")
time.sleep(5)
dl_flow_rules = {
default_ip: [flow_list1],
sec_ip: [flow_list2],
}
# 1 UL flow is created per bearer
num_ul_flows = 4
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows,
dl_flow_rules)
print("*********** Moving UE to idle mode")
print(
"************* Sending UE context release request ",
"for UE id ",
ue_id,
)
# Send UE context release request to move UE to idle mode
rel_req = s1ap_types.ueCntxtRelReq_t()
rel_req.ue_Id = ue_id
rel_req.cause.causeVal = (
gpp_types.CauseRadioNetwork.USER_INACTIVITY.value)
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_CNTXT_REL_REQUEST, rel_req)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_CTX_REL_IND.value)
# Verify if paging flow rules are created
ip_list = [default_ip, sec_ip]
self._s1ap_wrapper.s1_util.verify_paging_flow_rules(ip_list)
print(
"************************* Running UE downlink (UDP) for UE id ",
ue_id,
)
with self._s1ap_wrapper.configDownlinkTest(req,
duration=1,
is_udp=True) as test:
response = self._s1ap_wrapper.s1_util.get_response()
self.assertTrue(response, s1ap_types.tfwCmd.UE_PAGING_IND.value)
# Send service request to reconnect UE
print(
"************************* Sending Service request for UE id ",
ue_id,
)
ser_req = s1ap_types.ueserviceReq_t()
ser_req.ue_Id = ue_id
ser_req.ueMtmsi = s1ap_types.ueMtmsi_t()
ser_req.ueMtmsi.pres = False
ser_req.rrcCause = s1ap_types.Rrc_Cause.TFW_MT_ACCESS.value
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_SERVICE_REQUEST, ser_req)
# Wait for INT_CTX_SETUP_IND
while response.msg_type == s1ap_types.tfwCmd.UE_PAGING_IND.value:
print(
"Received Paging Indication for ue-id",
ue_id,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.INT_CTX_SETUP_IND.value)
test.verify()
print("Sleeping for 5 seconds")
time.sleep(5)
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(num_ul_flows,
dl_flow_rules)
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(
ue_id, deactv_bearer_req.bearerId)
print("Sleeping for 5 seconds")
time.sleep(5)
print("************************* Running UE detach for UE id ", ue_id)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, True)
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,
)
def test_attach_detach_secondary_pdn_with_pcscf_address(self):
""" Attach a single UE + add 2 PDN Connections with P-CSCF address """
""" + disconnect """
num_pdns = 2
bearer_ids = []
num_ue = 1
self._s1ap_wrapper.configUEDevice(num_ue)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
# ims APN
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
internet = {
"apn_name": "internet", # APN-name
"qci": 9, # 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, 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
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()
time.sleep(2)
# APNs of the secondary PDNs
apn = ["internet", "ims"]
pcscf_addr_type = ["ipv4", "ipv6"]
# PDN Type 1-IPv4,2-IPv6,3-IPv4v6
pdn_type = 1
for i in range(num_pdns):
# Send PDN Connectivity Request
self._s1ap_wrapper.sendPdnConnectivityReq(
ue_id,
apn[i],
pdn_type=pdn_type,
pcscf_addr_type=pcscf_addr_type[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,
)
bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId)
print(
"********************** Added default bearer with "
"bearer id",
act_def_bearer_req.m.pdnInfo.epsBearerId,
)
time.sleep(5)
for i in range(num_pdns):
# Send PDN Disconnect
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = ue_id
pdn_disconnect_req.epsBearerId = bearer_ids[i]
print(
"******************* Sending PDN Disconnect bearer id\n",
pdn_disconnect_req.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
self._s1ap_wrapper.sendDeactDedicatedBearerAccept(
ue_id, bearer_ids[i])
print(
"******************* Running UE detach (switch-off) for ",
"UE id ",
ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_3495_timer_for_default_bearer_with_mme_restart(self):
""" Test case validates the functionality of 3495 timer for
Default bearer while MME restarts
Step1: UE attaches to network
Step2: Creates a secondary PDN
Step3: Initiates PDN disconnect, 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)
req = self._s1ap_wrapper.ue_req
# APN of the secondary PDN
ims = {
"apn_name": "ims", # APN-name
"qci": 5, # qci
"priority": 15, # priority
"pre_cap": 0, # preemption-capability
"pre_vul": 0, # preemption-vulnerability
"mbr_ul": 200000000, # MBR UL
"mbr_dl": 100000000, # MBR DL
}
# APN list to be configured
apn_list = [ims]
self._s1ap_wrapper.configAPN(
"IMSI" + "".join([str(i) for i in req.imsi]), apn_list
)
print(
"********************** Running End to End attach for ",
"UE id ",
req.ue_id,
)
# 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("*** Sending PDN connectivity Req ***")
# Send PDN Connectivity Request
apn = "ims"
self._s1ap_wrapper.sendPdnConnectivityReq(req.ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value
)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
print(
"************************* Sending Activate default EPS bearer "
"context accept for UE id ",
req.ue_id,
)
time.sleep(5)
# Send PDN Disconnect
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = req.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 default eps bearer "
"context request"
)
# 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
)
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_SWITCHOFF_DETACH.value,
False,
)
def test_attach_detach_secondary_pdn_multi_ue(self):
"""attach/detach + PDN Connectivity Requests with 4 UEs"""
num_ues = 4
ue_ids = []
bearer_ids = []
default_ips = []
sec_ips = []
self._s1ap_wrapper.configUEDevice(num_ues)
# 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 _ in range(num_ues):
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
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_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(ue_id)
self._s1ap_wrapper._ue_idx = 0
for _ 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,
)
bearer_ids.append(act_def_bearer_req.m.pdnInfo.epsBearerId)
addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo
sec_ips.append(ipaddress.ip_address(bytes(addr[:4])))
print("Sleeping for 5 seconds")
time.sleep(5)
for i in range(num_ues):
# Verify if flow rules are created
# No dedicated bearers, so flowlist is empty
dl_flow_rules = {
default_ips[i]: [],
sec_ips[i]: [],
}
# 2 bearers per UE (2* 4 UEs = 8 UL flows)
num_ul_flows = 8
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows, dl_flow_rules,
)
# Disconnect secondary PDNs
self._s1ap_wrapper._ue_idx = 0
for i in range(num_ues):
req = self._s1ap_wrapper.ue_req
ue_id = req.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("Sleeping for 5 seconds")
time.sleep(5)
# Verify that flow rules are deleted for secondary pdns
for i in range(num_ues):
# No dedicated bearers, so flowlist is empty
dl_flow_rules = {
default_ips[i]: [],
}
# 1 default bearer per UE = 4 UL flows
num_ul_flows = 4
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows, dl_flow_rules,
)
# Now detach the UE
for ue in ue_ids:
print(
"******************** Running UE detach (switch-off) for ",
"UE id ",
ue,
)
self._s1ap_wrapper.s1_util.detach(
ue, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False,
)
def test_secondary_pdn_disconn_invalid_bearer_id(self):
""" Attach a single UE + send standalone PDN Connectivity
Request + send PDN disconnect with invalid bearer id """
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)
# Declare an array of len 15 as the bearer id ranges from 5-15
length = 15
bearer_idx = [0] * length
print(
"************************* Running End to End attach for UE id ",
ue_id,
)
# Attach
attach_accept = 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,
)
# Set the bearer index to 1
bearer_idx[attach_accept.esmInfo.epsBearerId] = 1
# 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_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
# Set the bearer index to 1
bearer_idx[act_def_bearer_req.m.pdnInfo.epsBearerId] = 1
print(
"************************* Sending Activate default EPS bearer "
"context accept for UE id ",
ue_id,
)
print("********************* Sleeping for 5 seconds")
time.sleep(5)
# Send PDN Disconnect for a non-existent bearer
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = ue_id
# Find an unassigned bearer id
# Start from 5th index as the bearer id ranges from 5-15
for i in range(5, 15):
if bearer_idx[i] == 0:
pdn_disconnect_req.epsBearerId = i
break
print(
"****** Sending PDN disconnect for bearer id",
pdn_disconnect_req.epsBearerId,
)
self._s1ap_wrapper._s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REQ, pdn_disconnect_req)
# Receive PDN Disconnect reject
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type,
s1ap_types.tfwCmd.UE_PDN_DISCONNECT_REJ.value)
print("************************* Received PDN disconnect reject")
print(
"************************* Running UE detach (switch-off) for ",
"UE id ",
ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
def test_attach_detach_two_pdns_with_tcp_traffic(self):
""" Attach a single UE, send standalone PDN Connectivity
Request, generate TCP traffic for each PDN session """
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
# ims APN
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 = [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()
default_apn_ip = self._s1ap_wrapper._s1_util.get_ip(ue_id)
time.sleep(2)
# Send PDN Connectivity Request
apn = "ims"
print(
"************************* Sending Standalone PDN "
"CONNECTIVITY REQUEST for UE id ",
ue_id,
" APN ",
apn,
)
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)
pdn_conn_rsp = response.cast(s1ap_types.uePdnConRsp_t)
ims_addr = pdn_conn_rsp.m.pdnInfo.pAddr.addrInfo
ims_ip = ipaddress.ip_address(bytes(ims_addr[:4]))
print(
"************************* Running UE uplink (TCP) for UE id ",
req.ue_id,
" UE IP addr: ",
default_apn_ip,
" APN: oai_IPv4",
)
with self._s1ap_wrapper._trf_util.generate_traffic_test(
[default_apn_ip], is_uplink=True, duration=5,
is_udp=False) as test:
test.verify()
print("Sleeping for 5 seconds...")
time.sleep(5)
print(
"************************* Running UE uplink (TCP) for UE id ",
req.ue_id,
" ue ip addr: ",
ims_ip,
" APN: ",
apn,
)
with self._s1ap_wrapper._trf_util.generate_traffic_test(
[ims_ip], is_uplink=True, duration=5, is_udp=False) as test:
test.verify()
print("Sleeping for 5 seconds...")
time.sleep(5)
# Send PDN Disconnect
print("******************* Sending PDN Disconnect" " request")
pdn_disconnect_req = s1ap_types.uepdnDisconnectReq_t()
pdn_disconnect_req.ue_Id = ue_id
pdn_disconnect_req.epsBearerId = pdn_conn_rsp.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")
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)
def test_3485_timer_for_default_bearer_with_mme_restart(self):
"""Test case validates the functionality of 3485 timer for
default bearer while MME restarts
Step1: UE attaches to network
Step2: Send an indication to S1ap stack to drop Activate Default
Eps Bearer Context Request message, sent as part of secondary PDN
activation procedure.
Step3: Initiate activation of secondary PDN
Step4: Send an indication to S1ap stack to not to Activate Default
Eps Bearer Context Request message, so that re-transmitted message
reaches to TFW
Step5: Send command to Magma to restart mme service
Step6: TFW shall receive the PDN connectivity response
Step7: TFW shall initiate de-activation of secondary PDN and then
initiate Detach procedure.
"""
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(idx) for idx 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()
print(
'*** Sending indication to drop Activate Default EPS bearer Ctxt'
' Req ***', )
drop_acctv_dflt_bearer_req = (
s1ap_types.UeDropActvDefaultEpsBearCtxtReq_t())
drop_acctv_dflt_bearer_req.ue_id = req.ue_id
drop_acctv_dflt_bearer_req.dropActDfltEpsBearCtxtReq = True
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_DROP_ACTV_DEFAULT_EPS_BEARER_CTXT_REQ,
drop_acctv_dflt_bearer_req,
)
time.sleep(2)
print('*** Sending PDN connectivity Req ***')
# Send PDN Connectivity Request
apn = 'ims'
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
# Receive PDN CONN RSP/Activate default EPS bearer context 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)
print(
'*** Sending indication to drop Activate Default EPS bearer Ctxt'
' Req ***', )
drop_acctv_dflt_bearer_req = (
s1ap_types.UeDropActvDefaultEpsBearCtxtReq_t())
drop_acctv_dflt_bearer_req.ue_id = req.ue_id
drop_acctv_dflt_bearer_req.dropActDfltEpsBearCtxtReq = False
self._s1ap_wrapper.s1_util.issue_cmd(
s1ap_types.tfwCmd.UE_DROP_ACTV_DEFAULT_EPS_BEARER_CTXT_REQ,
drop_acctv_dflt_bearer_req,
)
retransmitted_response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
retransmitted_response.msg_type,
s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value,
)
act_def_bearer_req = retransmitted_response.cast(
s1ap_types.uePdnConRsp_t, )
# 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()
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'
' 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,
wait_for_s1_ctxt_release=False,
)
