fixeria
/
pycrate
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mobile: rework NAS headers, add proper transaction id parsing, wrap all IEs into proper TypeX structures, plus few other modifications

This commit is contained in:
mitshell 2018-02-09 21:58:36 +01:00
parent e565ef0d01
commit e2a4fab1e3
16 changed files with 1100 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
pycrate_mobile/NAS.py
View File

@ -31,15 +31,20 @@ from pycrate_core.utils import *
if python_version < 3:
from struct import unpack
from .TS24008_IE import *
from .TS24008_MM import *
from .TS24008_CC import *
from .TS24011_PPSMS import *
from .TS24080_SS import *
from .TS44018_RR import *
from .TS24011_PPSMS import *
from .TS23040_SMS import *
from .TS23038 import *
from .TS24008_GMM import *
from .TS24008_SM import *
from .TS24301_IE import *
from .TS24301_EMM import *
from .TS24301_ESM import *
from .NASLTE import *

52
pycrate_mobile/NASLTE.py
View File

@ -74,9 +74,9 @@ def parse_NASLTE_MO(buf, inner=True):
#
if inner and shdr in (1, 3):
# parse clear-text NAS message container
cont, err = parse_NASLTE_MO(Msg[4].get_val(), inner=inner)
cont, err = parse_NASLTE_MO(Msg[3].get_val(), inner=inner)
if cont is not None:
Msg.replace(Msg[4], cont)
Msg.replace(Msg[3], cont)
return Msg, err
else:
return Msg, 0
@ -98,16 +98,16 @@ def parse_NASLTE_MO(buf, inner=True):
# EMM
if python_version < 3:
try:
type = ord(buf[1:2])
typ = ord(buf[1:2])
except:
return None, 111
else:
try:
type = buf[1]
typ = buf[1]
except:
return None, 111
try:
Msg = EMMTypeMOClasses[type]()
Msg = EMMTypeMOClasses[typ]()
except:
# error 97, message type non-existent or not implemented
return None, 97
@ -115,16 +115,16 @@ def parse_NASLTE_MO(buf, inner=True):
# ESM
if python_version < 3:
try:
type = ord(buf[2:3])
typ = ord(buf[2:3])
except:
return None, 111
else:
try:
type = buf[2]
typ = buf[2]
except:
return None, 111
try:
Msg = ESMTypeClasses[type]()
Msg = ESMTypeClasses[typ]()
except:
return None, 97
else:
@ -137,7 +137,7 @@ def parse_NASLTE_MO(buf, inner=True):
return None, 96
#
if inner and pd == 7:
if type in (65, 66, 67, 68, 77):
if typ in (65, 66, 67, 68, 77):
esmc = Msg['ESMContainer']
if not esmc.get_trans():
# ESM Container present in Msg
@ -147,17 +147,17 @@ def parse_NASLTE_MO(buf, inner=True):
else:
esmc.replace(esmc[-1], cont)
#esmc[-2].set_valauto(cont.get_len)
elif type in (98, 99):
elif typ in (98, 99):
# PP-SMS
nasc = Msg['NASContainer']
ppsmsb = nasc[1].get_val()
try:
pd, type = unpack('>BB', ppsmsb[:2])
pd, typ = unpack('>BB', ppsmsb[:2])
except:
return Msg, 111
pd &= 0xF
if pd == 9 and type in (1, 4, 16):
cont = PPSMSCPTypeClasses[type]()
if pd == 9 and typ in (1, 4, 16):
cont = PPSMSCPTypeClasses[typ]()
try:
cont.from_bytes(ppsmsb)
except:
@ -206,9 +206,9 @@ def parse_NASLTE_MT(buf, inner=True):
#
if inner and shdr in (1, 3):
# parse clear-text NAS message container
cont, err = parse_NASLTE_MT(Msg[4].get_val(), inner=inner)
cont, err = parse_NASLTE_MT(Msg[3].get_val(), inner=inner)
if cont is not None:
Msg.replace(Msg[4], cont)
Msg.replace(Msg[3], cont)
return Msg, err
else:
return Msg, 0
@ -230,16 +230,16 @@ def parse_NASLTE_MT(buf, inner=True):
# EMM
if python_version < 3:
try:
type = ord(buf[1])
typ = ord(buf[1])
except:
return None, 111
else:
try:
type = buf[1]
typ = buf[1]
except:
return None, 111
try:
Msg = EMMTypeMTClasses[type]()
Msg = EMMTypeMTClasses[typ]()
except:
# error 97, message type non-existent or not implemented
return None, 97
@ -247,16 +247,16 @@ def parse_NASLTE_MT(buf, inner=True):
# ESM
if python_version < 3:
try:
type = ord(buf[2])
typ = ord(buf[2])
except:
return None, 111
else:
try:
type = buf[2]
typ = buf[2]
except:
return None, 111
try:
Msg = ESMTypeClasses[type]()
Msg = ESMTypeClasses[typ]()
except:
return None, 97
else:
@ -269,7 +269,7 @@ def parse_NASLTE_MT(buf, inner=True):
return None, 96
#
if inner and pd == 7:
if type in (65, 66, 67, 68, 77):
if typ in (65, 66, 67, 68, 77):
# ESM Container
esmc = Msg['ESMContainer']
if not esmc.get_trans():
@ -280,17 +280,17 @@ def parse_NASLTE_MT(buf, inner=True):
else:
esmc.replace(esmc[-1], cont)
#esmc[-2].set_valauto(cont.get_len)
elif type in (98, 99):
elif typ in (98, 99):
# PP-SMS
nasc = Msg['NASContainer']
ppsmsb = nasc[1].get_val()
try:
pd, type = unpack('>BB', ppsmsb[:2])
pd, typ = unpack('>BB', ppsmsb[:2])
except:
return Msg, 111
pd &= 0xF
if pd == 9 and type in (1, 4, 16):
cont = PPSMSCPTypeClasses[type]()
if pd == 9 and typ in (1, 4, 16):
cont = PPSMSCPTypeClasses[typ]()
try:
cont.from_bytes(ppsmsb)
except:

10
pycrate_mobile/TS23038.py
View File

@ -27,6 +27,16 @@
# *--------------------------------------------------------
#*/
__all__ = [
'DCS_7B',
'DCS_8B',
'DCS_UCS',
'SMS_DCS',
'CBS_DCS',
'encode_7b',
'decode_7b'
]
#------------------------------------------------------------------------------#
# 3GPP TS 23.038: Alphabets and language-specific information
# release 13 (d00)

54
pycrate_mobile/TS23040_SMS.py
View File

@ -27,6 +27,30 @@
# *--------------------------------------------------------
#*/
__all__ = [
'SMS_TP',
'TP_OA',
'TP_DA',
'TP_PID',
'TP_DCS',
'TP_SCTS',
'TP_VP',
'TP_VPe',
'TP_DT',
'TP_RA',
'TP_UDH',
'TP_UD',
'TP_PI',
'SMS_DELIVER',
'SMS_DELIVER_REPORT_RP_ERROR',
'SMS_DELIVER_REPORT_RP_ACK',
'SMS_SUBMIT',
'SMS_SUBMIT_REPORT_RP_ERROR',
'SMS_SUBMIT_REPORT_RP_ACK',
'SMS_STATUS_REPORT',
'SMS_COMMAND'
]
#------------------------------------------------------------------------------#
# 3GPP TS 23.040: Technical realization of the Short Message Service (SMS)
# release 13 (d20)
@ -43,8 +67,16 @@ from .TS24008_IE import BufBCD, _BCDType_dict, _NumPlan_dict
from .TS24007 import *
from .TS23038 import *
_str_reserved = 'reserved'
class SMS_TP(Envelope):
"""parent class for all SMS TP messages
"""
pass
#------------------------------------------------------------------------------#
# Address fields
# TS 23.040, section 9.1.2.5
@ -718,6 +750,12 @@ class BufUD(Buf):
# indicator for GSM 7b encoding length
_ENC_BL = 0
def set_val(self, val):
if isinstance(val, bytes_types):
Buf.set_val(self, val)
else:
self.encode(val)
def get_dcs(self):
try:
dcs = self.get_env().get_env()['TP_DCS']
@ -875,7 +913,7 @@ class TP_PI(Envelope):
#------------------------------------------------------------------------------#
# Net -> UE
class SMS_DELIVER(Envelope):
class SMS_DELIVER(SMS_TP):
_GEN = (
Uint('TP_SRI', bl=1, dic=_TP_SRI_dict),
Uint('TP_UDHI', desc='UDH Indicator', bl=1),
@ -898,7 +936,7 @@ class SMS_DELIVER(Envelope):
#------------------------------------------------------------------------------#
# UE -> Net
class SMS_DELIVER_REPORT_RP_ERROR(Envelope):
class SMS_DELIVER_REPORT_RP_ERROR(SMS_TP):
ENV_SEL_TRANS = False
_GEN = (
Uint('spare', bl=1),
@ -924,7 +962,7 @@ class SMS_DELIVER_REPORT_RP_ERROR(Envelope):
#------------------------------------------------------------------------------#
# UE -> Net
class SMS_DELIVER_REPORT_RP_ACK(Envelope):
class SMS_DELIVER_REPORT_RP_ACK(SMS_TP):
ENV_SEL_TRANS = False
_GEN = (
Uint('spare', bl=1),
@ -949,7 +987,7 @@ class SMS_DELIVER_REPORT_RP_ACK(Envelope):
#------------------------------------------------------------------------------#
# UE -> Net
class SMS_SUBMIT(Envelope):
class SMS_SUBMIT(SMS_TP):
ENV_SEL_TRANS = False
_GEN = (
Uint('TP_SRR', bl=1, dic=_TP_SRR_dict),
@ -981,7 +1019,7 @@ class SMS_SUBMIT(Envelope):
#------------------------------------------------------------------------------#
# Net -> UE
class SMS_SUBMIT_REPORT_RP_ERROR(Envelope):
class SMS_SUBMIT_REPORT_RP_ERROR(SMS_TP):
ENV_SEL_TRANS = False
_GEN = (
Uint('spare', bl=1),
@ -1008,7 +1046,7 @@ class SMS_SUBMIT_REPORT_RP_ERROR(Envelope):
#------------------------------------------------------------------------------#
# Net -> UE
class SMS_SUBMIT_REPORT_RP_ACK(Envelope):
class SMS_SUBMIT_REPORT_RP_ACK(SMS_TP):
ENV_SEL_TRANS = False
_GEN = (
Uint('spare', bl=1),
@ -1034,7 +1072,7 @@ class SMS_SUBMIT_REPORT_RP_ACK(Envelope):
#------------------------------------------------------------------------------#
# Net -> UE
class SMS_STATUS_REPORT(Envelope):
class SMS_STATUS_REPORT(SMS_TP):
ENV_SEL_TRANS = False
_GEN = (
Uint('spare', bl=1),
@ -1067,7 +1105,7 @@ class SMS_STATUS_REPORT(Envelope):
#------------------------------------------------------------------------------#
# UE -> Net
class SMS_COMMAND(Envelope):
class SMS_COMMAND(SMS_TP):
_GEN = (
Uint('spare', bl=1),
Uint('TP_UDHI', desc='UDH Indicator', bl=1),

99
pycrate_mobile/TS24007.py
View File

@ -27,6 +27,24 @@
# *--------------------------------------------------------
#*/
__all__ = [
'Layer3',
'Layer3EPS',
'IE',
'Type1V',
'Type1TV',
'Type2',
'Type3V',
'Type3TV',
'Type4LV',
'Type4TLV',
'Type6LVE',
'Type6TLVE',
'TI',
'TIPD',
'ProtDisc_dict'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.007: Mobile radio interface signalling layer 3
# release 13 (d00)
@ -40,6 +58,7 @@ from pycrate_core.base import *
from pycrate_core.repr import *
from pycrate_csn1.csnobj import CSN1Obj
#------------------------------------------------------------------------------#
# Components of a standard L3 message
# TS 24.007, section 11.2.1
@ -151,7 +170,7 @@ class Layer3(Envelope):
L = char.get_uint(8)
V = char.get_bytes(8*L)
log('%s, _dec_unk_ie: unknown Type4TLV IE, T: 0x%x, V: 0x%s' \
% (self._name, T8, hexlify(V)))
% (self._name, T8, hexlify(V).decode('ascii')))
self.append( Type4TLV('_T_%i' % T8, val=[T8, L, V]) )
def repr(self):
@ -390,7 +409,7 @@ class Type3V(IE):
_GEN = (
Buf('V', rep=REPR_HEX),
)
class Type3TV(IE):
"""The Type3_TV IE is an optional IE,
@ -468,6 +487,68 @@ class Type6TLVE(IE):
# TS 24.007, section 11.2.3
#------------------------------------------------------------------------------#
class TI(Envelope):
"""Transaction identifier (extendable)
TS 24.007, section 11.2.3.1.3
"""
#ENV_SEL_TRANS = False
_GEN = (
Uint('TIFlag', bl=1, dic={0: 'allocated by sender', 1: 'allocated by receiver'}),
Uint('TIO', bl=3),
Uint('spare', bl=4),
Uint('Ext', val=1, bl=1, trans=True),
Uint('TIE', bl=7, trans=True),
Uint8('TI', trans=True) # virtual field to get and set the TI value easily
)
def __init__(self, *args, **kwargs):
Envelope.__init__(self, *args, **kwargs)
self[5].set_valauto(self._set_ti)
def _set_ti(self):
tio = self[1].get_val()
if tio == 7 and not self[4].get_trans():
return self[4].get_val()
else:
return tio
def set_val(self, vals):
ti, disp = None, True
if isinstance(vals, integer_types):
ti = vals
disp = False
elif isinstance(vals, dict) and 'TI' in vals:
ti = vals['TI']
if ti is not None:
if 0 <= ti < 7:
self[1].set_val(ti)
self[3].set_trans(True)
self[4].set_trans(True)
self[4].set_val(None)
elif ti < 128:
# extended
self[1].set_val(7)
self[3].set_trans(False)
self[4].set_trans(False)
self[4].set_val(ti)
if disp:
Envelope.set_val(self, vals)
def _from_char(self, char):
self[0]._from_char(char)
self[1]._from_char(char)
self[2]._from_char(char)
if self[1].get_val() == 7 and char.len_byte():
self[3].set_trans(False)
self[3]._from_char(char)
self[4].set_trans(False)
self[4]._from_char(char)
else:
self[3].set_trans(True)
self[4].set_trans(True)
self[4].set_val(None)
ProtDisc_dict = {
0 : 'GCC',
1 : 'BCC',
@ -485,3 +566,17 @@ ProtDisc_dict = {
13: 'extended ProtDisc',
14: 'testing',
}
class TIPD(TI):
"""Transaction identifier (extendable) and protocol discriminator
TS 24.007, section 11.2.3.1
"""
_GEN = (
Uint('TIFlag', bl=1, dic={0: 'allocated by sender', 1: 'allocated by receiver'}),
Uint('TIO', bl=3),
Uint('ProtDisc', bl=4, dic=ProtDisc_dict),
Uint('Ext', val=1, bl=1, trans=True),
Uint('TIE', bl=7, trans=True),
Uint8('TI', trans=True) # virtual field to get and set the TI value easily
)

203
pycrate_mobile/TS24008_CC.py
View File

@ -27,6 +27,57 @@
# *--------------------------------------------------------
#*/
__all__ = [
'CCAlertingMO',
'CCAlertingMT',
'CCCallConfirmed',
'CCCallProceeding',
'CCCongestionControl',
'CCConnectAcknowledge',
'CCConnectMO',
'CCConnectMT',
'CCDisconnectMO',
'CCDisconnectMT',
'CCEmergencySetup',
'CCEstablishmentCCBS',
'CCEstablishmentConfirmedCCBS',
'CCFacilityMO',
'CCFacilityMT',
'CCHold',
'CCHoldAcknowledge',
'CCHoldReject',
'CCModify',
'CCModifyComplete',
'CCModifyReject',
'CCNotify',
'CCProgress',
'CCRecallCCBS',
'CCReleaseCompleteMO',
'CCReleaseCompleteMT',
'CCReleaseMO',
'CCReleaseMT',
'CCRetrieve',
'CCRetrieveAcknowledge',
'CCRetrieveReject',
'CCSetupMO',
'CCSetupMT',
'CCStartCCBS',
'CCStartDTMF',
'CCStartDTMFAcknowledge',
'CCStartDTMFReject',
'CCStatus',
'CCStatusEnquiry',
'CCStopDTMF',
'CCStopDTMFAcknowledge',
'CCUserInformation',
#
'CCTypeMOClasses',
'CCTypeMTClasses',
'get_cc_msg_mo_instances',
'get_cc_msg_mt_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.008: Mobile radio interface layer 3 specification
# release 13 (d90)
@ -86,11 +137,9 @@ _CS_CC_dict = {
class CCHeader(Envelope):
_GEN = (
Uint('TIFlag', bl=1, dic={0: 'initiator', 1: 'responder'}),
Uint('TIO', bl=3),
Uint('ProtDisc', val=3, bl=4, dic=ProtDisc_dict),
TIPD(val={'ProtDisc': 3}),
Uint('Seqn', bl=2),
Uint('Type', val=61, bl=6, dic=_CS_CC_dict),
Uint('Type', val=61, bl=6, dic=_CS_CC_dict)
)
@ -100,7 +149,8 @@ class CCHeader(Envelope):
#------------------------------------------------------------------------------#
class CCAlertingMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':1})._content) + (
_GEN = (
CCHeader(val={'Type':1}),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('ProgressInd', val={'T':0x1E, 'V':b'\x80\x80'}, IE=ProgressInd()),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser())
@ -113,7 +163,8 @@ class CCAlertingMT(Layer3):
#------------------------------------------------------------------------------#
class CCAlertingMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':1})._content) + (
_GEN = (
CCHeader(val={'Type':1}),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser()),
Type4TLV('SSVersion', val={'T':0x7F, 'V':b''}, IE=SSVersion())
@ -126,7 +177,8 @@ class CCAlertingMO(Layer3):
#------------------------------------------------------------------------------#
class CCCallConfirmed(Layer3):
_GEN = tuple(CCHeader(val={'Type':8})._content) + (
_GEN = (
CCHeader(val={'Type':8}),
Type1TV('RepeatInd', val={'T':0xD, 'V':2}, dic=RepeatInd_dict),
Type4TLV('BearerCap1', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('BearerCap2', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
@ -143,7 +195,8 @@ class CCCallConfirmed(Layer3):
#------------------------------------------------------------------------------#
class CCCallProceeding(Layer3):
_GEN = tuple(CCHeader(val={'Type':2})._content) + (
_GEN = (
CCHeader(val={'Type':2}),
Type1TV('RepeatInd', val={'T':0xD, 'V':2}, dic=RepeatInd_dict),
Type4TLV('BearerCap1', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('BearerCap2', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
@ -160,10 +213,11 @@ class CCCallProceeding(Layer3):
#------------------------------------------------------------------------------#
class CCCongestionControl(Layer3):
_GEN = tuple(CCHeader(val={'Type':57})._content) + (
_GEN = (
CCHeader(val={'Type':57}),
Uint('spare', bl=4),
Uint('CongestionLevel', bl=4, dic=CongestionLevel_dict),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type1V('CongestionLevel', dic=CongestionLevel_dict),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause())
)
@ -173,7 +227,8 @@ class CCCongestionControl(Layer3):
#------------------------------------------------------------------------------#
class CCConnectMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':7})._content) + (
_GEN = (
CCHeader(val={'Type':7}),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('ProgressInd', val={'T':0x1E, 'V':b'\x80\x80'}, IE=ProgressInd()),
Type4TLV('ConnectedNumber', val={'T':0x4C, 'V':b'\x91'}, IE=ConnectedNumber()),
@ -188,12 +243,13 @@ class CCConnectMT(Layer3):
#------------------------------------------------------------------------------#
class CCConnectMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':7})._content) + (
_GEN = (
CCHeader(val={'Type':7}),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('ConnectedSubaddress', val={'T':0X4D, 'V':b'\x80'}, IE=ConnectedSubaddress()),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser()),
Type4TLV('SSVersion', val={'T':0x7F, 'V':b''}, IE=SSVersion()),
Type4TLV('StreamIdent', val={'T':0x2D, 'V':b'\0'}, IE=StreamIdent()),
Type4TLV('StreamIdent', val={'T':0x2D, 'V':b'\0'}, IE=StreamIdent())
)
@ -203,7 +259,9 @@ class CCConnectMO(Layer3):
#------------------------------------------------------------------------------#
class CCConnectAcknowledge(Layer3):
_GEN = tuple(CCHeader(val={'Type':15})._content)
_GEN = (
CCHeader(val={'Type':15}),
)
#------------------------------------------------------------------------------#
@ -212,7 +270,8 @@ class CCConnectAcknowledge(Layer3):
#------------------------------------------------------------------------------#
class CCDisconnectMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':37})._content) + (
_GEN = (
CCHeader(val={'Type':37}),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('ProgressInd', val={'T':0x1E, 'V':b'\x80\x80'}, IE=ProgressInd()),
@ -227,7 +286,8 @@ class CCDisconnectMT(Layer3):
#------------------------------------------------------------------------------#
class CCDisconnectMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':37})._content) + (
_GEN = (
CCHeader(val={'Type':37}),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser()),
@ -241,7 +301,8 @@ class CCDisconnectMO(Layer3):
#------------------------------------------------------------------------------#
class CCEmergencySetup(Layer3):
_GEN = tuple(CCHeader(val={'Type':14})._content) + (
_GEN = (
CCHeader(val={'Type':14}),
Type4TLV('BearerCap', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('StreamIdent', val={'T':0x2D, 'V':b'\0'}, IE=StreamIdent()),
Type4TLV('SupportedCodecs', val={'T':0x40, 'V':b'\0\x01\0'}, IE=SupportedCodecs()),
@ -255,7 +316,8 @@ class CCEmergencySetup(Layer3):
#------------------------------------------------------------------------------#
class CCFacilityMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':58})._content) + (
_GEN = (
CCHeader(val={'Type':58}),
Type4LV('Facility', val={'V':b''}),
)
@ -266,7 +328,8 @@ class CCFacilityMT(Layer3):
#------------------------------------------------------------------------------#
class CCFacilityMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':58})._content) + (
_GEN = (
CCHeader(val={'Type':58}),
Type4LV('Facility', val={'V':b''}),
Type4TLV('SSVersion', val={'T':0x7F, 'V':b''}, IE=SSVersion())
)
@ -278,7 +341,9 @@ class CCFacilityMO(Layer3):
#------------------------------------------------------------------------------#
class CCHold(Layer3):
_GEN = tuple(CCHeader(val={'Type':24})._content)
_GEN = (
CCHeader(val={'Type':24}),
)
#------------------------------------------------------------------------------#
@ -287,7 +352,9 @@ class CCHold(Layer3):
#------------------------------------------------------------------------------#
class CCHoldAcknowledge(Layer3):
_GEN = tuple(CCHeader(val={'Type':25})._content)
_GEN = (
CCHeader(val={'Type':25}),
)
#------------------------------------------------------------------------------#
@ -296,7 +363,8 @@ class CCHoldAcknowledge(Layer3):
#------------------------------------------------------------------------------#
class CCHoldReject(Layer3):
_GEN = tuple(CCHeader(val={'Type':26})._content) + (
_GEN = (
CCHeader(val={'Type':26}),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
)
@ -307,7 +375,8 @@ class CCHoldReject(Layer3):
#------------------------------------------------------------------------------#
class CCModify(Layer3):
_GEN = tuple(CCHeader(val={'Type':23})._content) + (
_GEN = (
CCHeader(val={'Type':23}),
Type4LV('BearerCap', val={'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('LowLayerComp', val={'T':0x7C, 'V':b''}),
Type4TLV('HighLayerComp', val={'T':0x7D, 'V':b''}, IE=HighLayerComp()),
@ -322,7 +391,8 @@ class CCModify(Layer3):
#------------------------------------------------------------------------------#
class CCModifyComplete(Layer3):
_GEN = tuple(CCHeader(val={'Type':31})._content) + (
_GEN = (
CCHeader(val={'Type':31}),
Type4LV('BearerCap', val={'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('LowLayerComp', val={'T':0x7C, 'V':b''}),
Type4TLV('HighLayerComp', val={'T':0x7D, 'V':b''}, IE=HighLayerComp()),
@ -336,7 +406,8 @@ class CCModifyComplete(Layer3):
#------------------------------------------------------------------------------#
class CCModifyReject(Layer3):
_GEN = tuple(CCHeader(val={'Type':19})._content) + (
_GEN = (
CCHeader(val={'Type':19}),
Type4LV('BearerCap', val={'V':b'\xa0'}, IE=BearerCap()),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('LowLayerComp', val={'T':0x7C, 'V':b''}),
@ -350,8 +421,9 @@ class CCModifyReject(Layer3):
#------------------------------------------------------------------------------#
class CCNotify(Layer3):
_GEN = tuple(CCHeader(val={'Type':62})._content) + (
NotificationInd(),
_GEN = (
CCHeader(val={'Type':62}),
Type3V('NotificationInd', val={'V':b'\x80'}, bl={'V':8}, IE=NotificationInd()),
)
@ -361,7 +433,8 @@ class CCNotify(Layer3):
#------------------------------------------------------------------------------#
class CCProgress(Layer3):
_GEN = tuple(CCHeader(val={'Type':3})._content) + (
_GEN = (
CCHeader(val={'Type':3}),
Type4LV('ProgressInd', val={'V':b'\x80\x80'}, IE=ProgressInd()),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser())
)
@ -373,7 +446,8 @@ class CCProgress(Layer3):
#------------------------------------------------------------------------------#
class CCEstablishmentCCBS(Layer3):
_GEN = tuple(CCHeader(val={'Type':4})._content) + (
_GEN = (
CCHeader(val={'Type':4}),
Type4LV('SetupContainer', val={'V':b''}),
)
@ -384,7 +458,8 @@ class CCEstablishmentCCBS(Layer3):
#------------------------------------------------------------------------------#
class CCEstablishmentConfirmedCCBS(Layer3):
_GEN = tuple(CCHeader(val={'Type':6})._content) + (
_GEN = (
CCHeader(val={'Type':6}),
Type1TV('RepeatInd', val={'T':0xD, 'V':2}, dic=RepeatInd_dict),
Type4TLV('BearerCap1', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('BearerCap2', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
@ -399,7 +474,8 @@ class CCEstablishmentConfirmedCCBS(Layer3):
#------------------------------------------------------------------------------#
class CCReleaseMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':45})._content) + (
_GEN = (
CCHeader(val={'Type':45}),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('SecondCause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
@ -413,7 +489,8 @@ class CCReleaseMT(Layer3):
#------------------------------------------------------------------------------#
class CCReleaseMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':45})._content) + (
_GEN = (
CCHeader(val={'Type':45}),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('SecondCause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
@ -428,8 +505,9 @@ class CCReleaseMO(Layer3):
#------------------------------------------------------------------------------#
class CCRecallCCBS(Layer3):
_GEN = tuple(CCHeader(val={'Type':11})._content) + (
RecallType(),
_GEN = (
CCHeader(val={'Type':11}),
Type3V('RecallType', val={'V':b'\0'}, bl={'V':8}, IE=RecallType()),
Type4LV('Facility', val={'V':b''})
)
@ -440,7 +518,8 @@ class CCRecallCCBS(Layer3):
#------------------------------------------------------------------------------#
class CCReleaseCompleteMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':42})._content) + (
_GEN = (
CCHeader(val={'Type':42}),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser())
@ -453,7 +532,8 @@ class CCReleaseCompleteMT(Layer3):
#------------------------------------------------------------------------------#
class CCReleaseCompleteMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':42})._content) + (
_GEN = (
CCHeader(val={'Type':42}),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser()),
@ -467,7 +547,9 @@ class CCReleaseCompleteMO(Layer3):
#------------------------------------------------------------------------------#
class CCRetrieve(Layer3):
_GEN = tuple(CCHeader(val={'Type':28})._content)
_GEN = (
CCHeader(val={'Type':28}),
)
#------------------------------------------------------------------------------#
@ -476,7 +558,9 @@ class CCRetrieve(Layer3):
#------------------------------------------------------------------------------#
class CCRetrieveAcknowledge(Layer3):
_GEN = tuple(CCHeader(val={'Type':29})._content)
_GEN = (
CCHeader(val={'Type':29}),
)
#------------------------------------------------------------------------------#
@ -485,7 +569,8 @@ class CCRetrieveAcknowledge(Layer3):
#------------------------------------------------------------------------------#
class CCRetrieveReject(Layer3):
_GEN = tuple(CCHeader(val={'Type':30})._content) + (
_GEN = (
CCHeader(val={'Type':30}),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
)
@ -496,7 +581,8 @@ class CCRetrieveReject(Layer3):
#------------------------------------------------------------------------------#
class CCSetupMT(Layer3):
_GEN = tuple(CCHeader(val={'Type':5})._content) + (
_GEN = (
CCHeader(val={'Type':5}),
Type1TV('RepeatInd', val={'T':0xD, 'V':2}, dic=RepeatInd_dict),
Type4TLV('BearerCap1', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('BearerCap2', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
@ -530,7 +616,8 @@ class CCSetupMT(Layer3):
#------------------------------------------------------------------------------#
class CCSetupMO(Layer3):
_GEN = tuple(CCHeader(val={'Type':5})._content) + (
_GEN = (
CCHeader(val={'Type':5}),
Type1TV('RepeatInd', val={'T':0xD, 'V':2}, dic=RepeatInd_dict),
Type4TLV('BearerCap1', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
Type4TLV('BearerCap2', val={'T':0x4, 'V':b'\xa0'}, IE=BearerCap()),
@ -563,7 +650,8 @@ class CCSetupMO(Layer3):
#------------------------------------------------------------------------------#
class CCStartCCBS(Layer3):
_GEN = tuple(CCHeader(val={'Type':9})._content) + (
_GEN = (
CCHeader(val={'Type':9}),
Type4TLV('CCCap', val={'T':0x15, 'V':b'\x01\0'}, IE=CCCap()),
)
@ -574,7 +662,8 @@ class CCStartCCBS(Layer3):
#------------------------------------------------------------------------------#
class CCStartDTMF(Layer3):
_GEN = tuple(CCHeader(val={'Type':53})._content) + (
_GEN = (
CCHeader(val={'Type':53}),
Type3TV('KeypadFacility', val={'T':0x2C, 'V':b'0'}, bl={'V':8}),
)
@ -585,7 +674,8 @@ class CCStartDTMF(Layer3):
#------------------------------------------------------------------------------#
class CCStartDTMFAcknowledge(Layer3):
_GEN = tuple(CCHeader(val={'Type':54})._content) + (
_GEN = (
CCHeader(val={'Type':54}),
Type3TV('KeypadFacility', val={'T':0x2C, 'V':b'0'}, bl={'V':8}),
)
@ -596,7 +686,8 @@ class CCStartDTMFAcknowledge(Layer3):
#------------------------------------------------------------------------------#
class CCStartDTMFReject(Layer3):
_GEN = tuple(CCHeader(val={'Type':55})._content) + (
_GEN = (
CCHeader(val={'Type':55}),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
)
@ -607,9 +698,10 @@ class CCStartDTMFReject(Layer3):
#------------------------------------------------------------------------------#
class CCStatus(Layer3):
_GEN = tuple(CCHeader(val={'Type':61})._content) + (
_GEN = (
CCHeader(val={'Type':61}),
Type4LV('Cause', val={'V':b'\x80\x80'}, IE=Cause()),
CallState(),
Type3V('CallState', val={'V':b'\0'}, bl={'V':8}, IE=CallState()),
Type4TLV('AuxiliaryStates', val={'T':0x24, 'V':b'\x80'}, IE=AuxiliaryStates())
)
@ -620,7 +712,9 @@ class CCStatus(Layer3):
#------------------------------------------------------------------------------#
class CCStatusEnquiry(Layer3):
_GEN = tuple(CCHeader(val={'Type':52})._content)
_GEN = (
CCHeader(val={'Type':52}),
)
#------------------------------------------------------------------------------#
@ -629,7 +723,9 @@ class CCStatusEnquiry(Layer3):
#------------------------------------------------------------------------------#
class CCStopDTMF(Layer3):
_GEN = tuple(CCHeader(val={'Type':49})._content)
_GEN = (
CCHeader(val={'Type':49}),
)
#------------------------------------------------------------------------------#
@ -638,7 +734,9 @@ class CCStopDTMF(Layer3):
#------------------------------------------------------------------------------#
class CCStopDTMFAcknowledge(Layer3):
_GEN = tuple(CCHeader(val={'Type':50})._content)
_GEN = (
CCHeader(val={'Type':50}),
)
#------------------------------------------------------------------------------#
@ -647,7 +745,8 @@ class CCStopDTMFAcknowledge(Layer3):
#------------------------------------------------------------------------------#
class CCUserInformation(Layer3):
_GEN = tuple(CCHeader(val={'Type':16})._content) + (
_GEN = (
CCHeader(val={'Type':16}),
Type4TLV('UserUser', val={'T':0x7E, 'V':b'\x04'}, IE=UserUser()),
Type2('MoreData', val={'T':0xA0})
)

196
pycrate_mobile/TS24008_GMM.py
View File

@ -27,6 +27,39 @@
# *--------------------------------------------------------
#*/
__all__ = [
'GMMAttachAccept',
'GMMAttachComplete',
'GMMAttachReject',
'GMMAttachRequest',
'GMMAuthenticationCipheringFailure',
'GMMAuthenticationCipheringReject',
'GMMAuthenticationCipheringRequest',
'GMMAuthenticationCipheringResponse',
'GMMDetachAcceptMO',
'GMMDetachAcceptMT',
'GMMDetachRequestMO',
'GMMDetachRequestMT',
'GMMIdentityRequest',
'GMMIdentityResponse',
'GMMInformation',
'GMMPTMSIReallocationCommand',
'GMMPTMSIReallocationComplete',
'GMMRoutingAreaUpdateAccept',
'GMMRoutingAreaUpdateComplete',
'GMMRoutingAreaUpdateReject',
'GMMRoutingAreaUpdateRequest',
'GMMServiceAccept',
'GMMServiceReject',
'GMMServiceRequest',
'GMMStatus',
#
'GMMTypeMOClasses',
'GMMTypeMTClasses',
'get_gmm_msg_mo_instances',
'get_gmm_msg_mt_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.008: Mobile radio interface layer 3 specification
# release 13 (d90)
@ -85,13 +118,14 @@ class GMMHeader(Envelope):
#------------------------------------------------------------------------------#
class GMMAttachRequest(Layer3):
_GEN = tuple(GMMHeader(val={'Type':1})._content) + (
_GEN = (
GMMHeader(val={'Type':1}),
Type4LV('MSNetCap', val={'V':b'\0\0'}, IE=MS_network_capability_value_part),
Uint('CKSN', bl=4, dic=CKSN_dict),
AttachType(),
Type1V('CKSN', dic=CKSN_dict),
Type1V('AttachType', IE=AttachType()),
Type3V('DRXParam', val={'V':b'\0\0'}, bl={'V':16}, IE=DRXParam()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
RAI('OldRAI'),
Type3V('OldRAI', val={'V':b'\0\xf1\x10\0\0\0'}, bl={'V':48}, IE=RAI()),
Type4LV('MSRACap', val={'V':5*b'\0'}, IE=MS_RA_capability_value_part),
Type3TV('OldPTMSISign', val={'T':0x19, 'V':b'\0\0\0'}, bl={'V':24}),
Type3TV('ReqREADYTimer', val={'T':0x17, 'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
@ -122,19 +156,19 @@ class GMMAttachRequest(Layer3):
#------------------------------------------------------------------------------#
class GMMAttachAccept(Layer3):
_GEN = tuple(GMMHeader(val={'Type':2})._content) + (
ForceStdby(),
AttachResult(),
GPRSTimer('PeriodicRAUpdateTimer'),
RadioPriority('RadioPrioForTOM8'),
RadioPriority('RadioPrioForSMS'),
RAI(),
_GEN = (
GMMHeader(val={'Type':2}),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type1V('AttachResult', IE=AttachResult()),
Type3V('PeriodicRAUpdateTimer', val={'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type1V('RadioPriorityTOM8', dic=RadioPrio_dict),
Type1V('RadioPrioritySMS', dic=RadioPrio_dict),
Type3V('RAI', val={'V':b'\0\xf1\x10\0\0\0'}, bl={'V':48}, IE=RAI()),
Type3TV('PTMSISign', val={'T':0x19, 'V':b'\0\0\0'}, bl={'V':24}),
Type3TV('NegoREADYTimer', val={'T':0x17, 'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type4TLV('AllocPTMSI', val={'T':0x18, 'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type4TLV('MSIdent', val={'T':0x23, 'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type3TV('GMMCause', val={'T':0x25, 'V':b'\x11'}, bl={'V':8},
IE=Uint8('GMMCause', val=17, dic=GMMCause_dict)),
Type3TV('GMMCause', val={'T':0x25, 'V':b'\x11'}, bl={'V':8}, IE=GMMCause()),
Type4TLV('T3302', val={'T':0x2A, 'V':b'\0'}, IE=GPRSTimer()),
Type2('CellNotif', val={'T':0x8C}),
Type4TLV('EquivPLMNList', val={'T':0x4A, 'V':3*b'\0'}, IE=PLMNList()),
@ -161,7 +195,8 @@ class GMMAttachAccept(Layer3):
#------------------------------------------------------------------------------#
class GMMAttachComplete(Layer3):
_GEN = tuple(GMMHeader(val={'Type':3})._content) + (
_GEN = (
GMMHeader(val={'Type':3}),
Type4TLV('InterRATHOInfo', val={'T':0x27, 'V':b'\0'}),
Type4TLV('EUTRANInterRATHOInfo', val={'T':0x2B, 'V':b'\0'})
)
@ -173,8 +208,9 @@ class GMMAttachComplete(Layer3):
#------------------------------------------------------------------------------#
class GMMAttachReject(Layer3):
_GEN = tuple(GMMHeader(val={'Type':4})._content) + (
Uint8('GMMCause', val=17, dic=GMMCause_dict),
_GEN = (
GMMHeader(val={'Type':4}),
Type3V('GMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=GMMCause()),
Type4TLV('T3302', val={'T':0x2A, 'V':b'\0'}, IE=GPRSTimer()),
Type4TLV('T3346', val={'T':0x3A, 'V':b'\0'}, IE=GPRSTimer())
)
@ -186,11 +222,11 @@ class GMMAttachReject(Layer3):
#------------------------------------------------------------------------------#
class GMMDetachRequestMT(Layer3):
_GEN = tuple(GMMHeader(val={'Type':5})._content) + (
ForceStdby(),
DetachTypeMT(),
Type3TV('GMMCause', val={'T':0x25, 'V':b'\x11'}, bl={'V':8},
IE=Uint8('GMMCause', val=17, dic=GMMCause_dict))
_GEN = (
GMMHeader(val={'Type':5}),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type1V('DetachType', IE=DetachTypeMT()),
Type3TV('GMMCause', val={'T':0x25, 'V':b'\x11'}, bl={'V':8}, IE=GMMCause())
)
@ -200,9 +236,10 @@ class GMMDetachRequestMT(Layer3):
#------------------------------------------------------------------------------#
class GMMDetachRequestMO(Layer3):
_GEN = tuple(GMMHeader(val={'Type':5})._content) + (
_GEN = (
GMMHeader(val={'Type':5}),
Uint('spare', bl=4),
DetachTypeMO(),
Type1V('DetachType', IE=DetachTypeMO()),
Type4TLV('AllocPTMSI', val={'T':0x18, 'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type4TLV('PTMSISign', val={'T':0x19, 'V':b'\0\0\0'})
)
@ -214,9 +251,10 @@ class GMMDetachRequestMO(Layer3):
#------------------------------------------------------------------------------#
class GMMDetachAcceptMT(Layer3):
_GEN = tuple(GMMHeader(val={'Type':6})._content) + (
_GEN = (
GMMHeader(val={'Type':6}),
Uint('spare', bl=4),
ForceStdby()
Type1V('ForceStdby', dic=ForceStdby_dict)
)
@ -226,7 +264,9 @@ class GMMDetachAcceptMT(Layer3):
#------------------------------------------------------------------------------#
class GMMDetachAcceptMO(Layer3):
_GEN = tuple(GMMHeader(val={'Type':6})._content)
_GEN = (
GMMHeader(val={'Type':6}),
)
#------------------------------------------------------------------------------#
@ -235,11 +275,12 @@ class GMMDetachAcceptMO(Layer3):
#------------------------------------------------------------------------------#
class GMMPTMSIReallocationCommand(Layer3):
_GEN = tuple(GMMHeader(val={'Type':16})._content) + (
_GEN = (
GMMHeader(val={'Type':16}),
Type4LV('AllocPTMSI', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
RAI(),
Type3V('RAI', val={'V':b'\0\xf1\x10\0\0\0'}, bl={'V':48}, IE=RAI()),
Uint('spare', bl=4),
ForceStdby(),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type3TV('PTMSISign', val={'T':0x19, 'V':b'\0\0\0'}, bl={'V':24}),
)
@ -250,7 +291,9 @@ class GMMPTMSIReallocationCommand(Layer3):
#------------------------------------------------------------------------------#
class GMMPTMSIReallocationComplete(Layer3):
_GEN = tuple(GMMHeader(val={'Type':17})._content)
_GEN = (
GMMHeader(val={'Type':17}),
)
#------------------------------------------------------------------------------#
@ -259,11 +302,12 @@ class GMMPTMSIReallocationComplete(Layer3):
#------------------------------------------------------------------------------#
class GMMAuthenticationCipheringRequest(Layer3):
_GEN = tuple(GMMHeader(val={'Type':18})._content) + (
Uint('IMEISVReq', bl=4),
Uint('CiphAlgo', bl=4, dic=CiphAlgo_dict),
Uint('ACRef', bl=4),
ForceStdby(),
_GEN = (
GMMHeader(val={'Type':18}),
Type1V('IMEISVReq'),
Type1V('CiphAlgo', dic=CiphAlgo_dict),
Type1V('ACRef'),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type3TV('RAND', val={'T':0x21, 'V':16*b'\0'}, bl={'V':128}),
Type1TV('CKSN', val={'T':0x8, 'V':0}, dic=CKSN_dict),
Type4TLV('AUTN', val={'T':0x28, 'V':16*b'\0'}, IE=AUTN()),
@ -282,9 +326,10 @@ class GMMAuthenticationCipheringRequest(Layer3):
#------------------------------------------------------------------------------#
class GMMAuthenticationCipheringResponse(Layer3):
_GEN = tuple(GMMHeader(val={'Type':19})._content) + (
_GEN = (
GMMHeader(val={'Type':19}),
Uint('spare', bl=4),
Uint('ACRef', bl=4),
Type1V('ACRef'),
Type3TV('RES', val={'T':0x22, 'V':4*b'\0'}, bl={'V':32}),
Type4TLV('IMEISV', val={'T':0x23, 'V':b'\x03\0\0\0\0\0\0\0\xf0'}, IE=ID()),
Type4TLV('RESExt', val={'T':0x29, 'V':4*b'\0'}),
@ -298,8 +343,9 @@ class GMMAuthenticationCipheringResponse(Layer3):
#------------------------------------------------------------------------------#
class GMMAuthenticationCipheringFailure(Layer3):
_GEN = tuple(GMMHeader(val={'Type':28})._content) + (
Uint8('GMMCause', val=17, dic=GMMCause_dict),
_GEN = (
GMMHeader(val={'Type':28}),
Type3V('GMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=GMMCause()),
Type4TLV('AUTS', val={'T':0x30, 'V':14*b'\0'})
)
@ -310,7 +356,9 @@ class GMMAuthenticationCipheringFailure(Layer3):
#------------------------------------------------------------------------------#
class GMMAuthenticationCipheringReject(Layer3):
_GEN = tuple(GMMHeader(val={'Type':20})._content)
_GEN = (
GMMHeader(val={'Type':20}),
)
#------------------------------------------------------------------------------#
@ -319,9 +367,10 @@ class GMMAuthenticationCipheringReject(Layer3):
#------------------------------------------------------------------------------#
class GMMIdentityRequest(Layer3):
_GEN = tuple(GMMHeader(val={'Type':21})._content) + (
ForceStdby(),
Uint('IDType', val=1, bl=4, dic=IDType_dict)
_GEN = (
GMMHeader(val={'Type':21}),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type1V('IDType', val={'V':IDTYPE_IMSI}, dic=IDType_dict)
)
@ -331,8 +380,9 @@ class GMMIdentityRequest(Layer3):
#------------------------------------------------------------------------------#
class GMMIdentityResponse(Layer3):
_GEN = tuple(GMMHeader(val={'Type':22})._content) + (
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
_GEN = (
GMMHeader(val={'Type':22}),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID())
)
@ -342,10 +392,11 @@ class GMMIdentityResponse(Layer3):
#------------------------------------------------------------------------------#
class GMMRoutingAreaUpdateRequest(Layer3):
_GEN = tuple(GMMHeader(val={'Type':8})._content) + (
Uint('CKSN', bl=4, dic=CKSN_dict),
UpdateType(),
RAI('OldRAI'),
_GEN = (
GMMHeader(val={'Type':8}),
Type1V('CKSN', dic=CKSN_dict),
Type1V('UpdateType', IE=UpdateType()),
Type3V('OldRAI', val={'V':b'\0\xf1\x10\0\0\0'}, bl={'V':48}, IE=RAI()),
Type4LV('MSRACap', val={'V':5*b'\0'}, IE=MS_RA_capability_value_part),
Type3TV('OldPTMSISign', val={'T':0x19, 'V':b'\0\0\0'}, bl={'V':24}),
Type3TV('ReqREADYTimer', val={'T':0x17, 'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
@ -381,19 +432,19 @@ class GMMRoutingAreaUpdateRequest(Layer3):
#------------------------------------------------------------------------------#
class GMMRoutingAreaUpdateAccept(Layer3):
_GEN = tuple(GMMHeader(val={'Type':9})._content) + (
ForceStdby(),
UpdateResult(),
GPRSTimer('PeriodicRAUpdateTimer'),
RAI(),
_GEN = (
GMMHeader(val={'Type':9}),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type1V('UpdateResult', IE=UpdateResult()),
Type3V('PeriodicRAUpdateTimer', val={'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type3V('RAI', val={'V':b'\0\xf1\x10\0\0\0'}, bl={'V':48}, IE=RAI()),
Type3TV('PTMSISign', val={'T':0x19, 'V':b'\0\0\0'}, bl={'V':24}),
Type4TLV('AllocPTMSI', val={'T':0x18, 'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type4TLV('MSIdent', val={'T':0x23, 'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type4TLV('RcvNPDUNumList', val={'T':0x26, 'V':b'\0\0'},
IE=Receive_N_PDU_Number_list_value),
Type3TV('NegoREADYTimer', val={'T':0x17, 'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type3TV('GMMCause', val={'T':0x25, 'V':b'\x11'}, bl={'V':8},
IE=Uint8('GMMCause', val=17, dic=GMMCause_dict)),
Type3TV('GMMCause', val={'T':0x25, 'V':b'\x11'}, bl={'V':8}, IE=GMMCause()),
Type4TLV('T3302', val={'T':0x2A, 'V':b'\0'}, IE=GPRSTimer()),
Type2('CellNotif', val={'T':0x8C}),
Type4TLV('EquivPLMNList', val={'T':0x4A, 'V':3*b'\0'}, IE=PLMNList()),
@ -422,7 +473,8 @@ class GMMRoutingAreaUpdateAccept(Layer3):
#------------------------------------------------------------------------------#
class GMMRoutingAreaUpdateComplete(Layer3):
_GEN = tuple(GMMHeader(val={'Type':10})._content) + (
_GEN = (
GMMHeader(val={'Type':10}),
Type4TLV('RcvNPDUNumList', val={'T':0x26, 'V':b'\0\0'},
IE=Receive_N_PDU_Number_list_value),
Type4TLV('InterRATHOInfo', val={'T':0x27, 'V':b'\0'}),
@ -436,10 +488,11 @@ class GMMRoutingAreaUpdateComplete(Layer3):
#------------------------------------------------------------------------------#
class GMMRoutingAreaUpdateReject(Layer3):
_GEN = tuple(GMMHeader(val={'Type':11})._content) + (
Uint8('GMMCause', val=17, dic=GMMCause_dict),
_GEN = (
GMMHeader(val={'Type':11}),
Type3V('GMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=GMMCause()),
Uint('spare', bl=4),
ForceStdby(),
Type1V('ForceStdby', dic=ForceStdby_dict),
Type4TLV('T3302', val={'T':0x2A, 'V':b'\0'}, IE=GPRSTimer()),
Type4TLV('T3346', val={'T':0x3A, 'V':b'\0'}, IE=GPRSTimer())
)
@ -451,8 +504,9 @@ class GMMRoutingAreaUpdateReject(Layer3):
#------------------------------------------------------------------------------#
class GMMStatus(Layer3):
_GEN = tuple(GMMHeader(val={'Type':32})._content) + (
Uint8('GMMCause', val=17, dic=GMMCause_dict),
_GEN = (
GMMHeader(val={'Type':32}),
Type3V('GMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=GMMCause())
)
@ -462,7 +516,8 @@ class GMMStatus(Layer3):
#------------------------------------------------------------------------------#
class GMMInformation(Layer3):
_GEN = tuple(GMMHeader(val={'Type':33})._content) + (
_GEN = (
GMMHeader(val={'Type':33}),
Type4TLV('NetFullName', val={'T':0x43, 'V':b'\0'}, IE=NetworkName()),
Type4TLV('NetShortName', val={'T':0x45, 'V':b'\0'}, IE=NetworkName()),
Type3TV('LocalTimeZone', val={'T':0x46, 'V':b'\0'}, bl={'V':8}),
@ -479,9 +534,10 @@ class GMMInformation(Layer3):
#------------------------------------------------------------------------------#
class GMMServiceRequest(Layer3):
_GEN = tuple(GMMHeader(val={'Type':12})._content) + (
Uint('ServiceType', bl=4, dic=ServiceType_dict),
Uint('CKSN', bl=4, dic=CKSN_dict),
_GEN = (
GMMHeader(val={'Type':12}),
Type1V('ServiceType', dic=ServiceType_dict),
Type1V('CKSN', dic=CKSN_dict),
Type4LV('PTMSI', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type4TLV('PDPCtxtStat', val={'T':0x32, 'V':b'\0\0'}, IE=PDPCtxtStat()),
Type4TLV('MBMSCtxtStat', val={'T':0x35, 'V':b''}, IE=MBMSCtxtStat()),
@ -496,7 +552,8 @@ class GMMServiceRequest(Layer3):
#------------------------------------------------------------------------------#
class GMMServiceAccept(Layer3):
_GEN = tuple(GMMHeader(val={'Type':13})._content) + (
_GEN = (
GMMHeader(val={'Type':13}),
Type4TLV('PDPCtxtStat', val={'T':0x32, 'V':b'\0\0'}, IE=PDPCtxtStat()),
Type4TLV('MBMSCtxtStat', val={'T':0x35, 'V':b''}, IE=MBMSCtxtStat()),
)
@ -508,8 +565,9 @@ class GMMServiceAccept(Layer3):
#------------------------------------------------------------------------------#
class GMMServiceReject(Layer3):
_GEN = tuple(GMMHeader(val={'Type':14})._content) + (
Uint8('GMMCause', val=17, dic=GMMCause_dict),
_GEN = (
GMMHeader(val={'Type':14}),
Type3V('GMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=GMMCause()),
Type4TLV('T3346', val={'T':0x3A, 'V':b'\0'}, IE=GPRSTimer())
)

57
pycrate_mobile/TS24008_IE.py
View File

@ -44,6 +44,7 @@ from pycrate_core.charpy import Charpy
from .MCC_MNC import MNC_dict
from .PPP import LCP, LCPDataConf, NCP, NCPDataConf, PAP, CHAP
from .TS23038 import *
from .TS24007 import ProtDisc_dict
#------------------------------------------------------------------------------#
# TS 24.008 IE specified with CSN.1
@ -682,6 +683,19 @@ class MSCm2(Envelope):
)
#------------------------------------------------------------------------------#
# PD and SAPI $(CCBS)$
# TS 24.008, 10.5.1.10a
#------------------------------------------------------------------------------#
class PD_SAPI(Envelope):
_GEN = (
Uint('spare', bl=2),
Uint('SAPI', bl=2),
Uint('PD', val=5, bl=4, dic=ProtDisc_dict)
)
#------------------------------------------------------------------------------#
# Priority Level
# TS 24.008, 10.5.1.11
@ -846,7 +860,7 @@ class NetworkName(Envelope):
# TS 24.008, section 10.5.3.6
#------------------------------------------------------------------------------#
RejectCause_dict = {
_RejectCause_dict = {
2:'IMSI unknown in HLR',
3:'Illegal MS',
4:'IMSI unknown in VLR',
@ -877,6 +891,9 @@ RejectCause_dict = {
111:'Protocol error, unspecified'
}
class RejectCause(Uint8):
_dic = _RejectCause_dict
#------------------------------------------------------------------------------#
# Time Zone
@ -2281,7 +2298,7 @@ class DRXParam(Envelope):
# TS 24.008, 10.5.5.7
#------------------------------------------------------------------------------#
_ForceStdby_dict = {
ForceStdby_dict = {
0 : 'Force to standby not indicated',
1 : 'Force to standby indicated'
}
@ -2289,7 +2306,7 @@ _ForceStdby_dict = {
class ForceStdby(Envelope):
_GEN = (
Uint('spare', bl=1),
Uint('Value', bl=3, dic=_ForceStdby_dict)
Uint('Value', bl=3, dic=ForceStdby_dict)
)
@ -2332,6 +2349,9 @@ GMMCause_dict = {
111: 'Protocol error, unspecified'
}
class GMMCause(Uint8):
_dic = GMMCause_dict
#------------------------------------------------------------------------------#
# Routing Area Identifier
@ -2709,7 +2729,8 @@ class PDPAddr(Envelope):
def __init__(self, *args, **kwargs):
Envelope.__init__(self, *args, **kwargs)
self[2].set_dicauto(self._set_pdpt_dic)
self[3].set_blauto(self._set_addr_len)
# Addr can be empty, when PDPAddr is used within a request
#self[3].set_blauto(self._set_addr_len)
def _set_pdpt_dic(self):
to = self[1]()
@ -2720,17 +2741,17 @@ class PDPAddr(Envelope):
else:
return None
def _set_addr_len(self):
to, t = self[1](), self[2]()
if to == 1:
if t == 33:
return 32
elif t == 87:
return 128
elif t == 141:
return 160
return None
#def _set_addr_len(self):
# to, t = self[1](), self[2]()
# if to == 1:
# if t == 33:
# return 32
# elif t == 87:
# return 128
# elif t == 141:
# return 160
# return None
#------------------------------------------------------------------------------#
# Quality of service
# TS 24.008, 10.5.6.5
@ -3025,7 +3046,7 @@ SMCause_dict = {
}
class SMCause(Uint8):
dic = SMCause_dict
_dic = SMCause_dict
#------------------------------------------------------------------------------#
@ -3476,7 +3497,7 @@ class PDPCtxtStat(Envelope):
# TS 24.008, 10.5.7.2 and 10.5.7.5
#------------------------------------------------------------------------------#
_RadioPrio_dict = {
RadioPrio_dict = {
1 : 'priority level 1 (highest)',
2 : 'priority level 2',
3 : 'priority level 3',
@ -3486,7 +3507,7 @@ _RadioPrio_dict = {
class RadioPriority(Envelope):
_GEN = (
Uint('spare', bl=1),
Uint('Value', bl=3, dic=_RadioPrio_dict)
Uint('Value', bl=3, dic=RadioPrio_dict)
)

147
pycrate_mobile/TS24008_MM.py
View File

@ -27,6 +27,34 @@
# *--------------------------------------------------------
#*/
__all__ = [
'MMIMSIDetachIndication',
'MMLocationUpdatingAccept',
'MMLocationUpdatingReject',
'MMLocationUpdatingRequest',
'MMAuthenticationReject',
'MMAuthenticationRequest',
'MMAuthenticationResponse',
'MMAuthenticationFailure',
'MMIdentityRequest',
'MMIdentityResponse',
'MMTMSIReallocationCommand',
'MMTMSIReallocationComplete',
'MMCMServiceAccept',
'MMCMServiceReject',
'MMCMServiceAbort',
'MMCMServiceRequest',
'MMCMServicePrompt',
'MMCMReestablishmentRequest',
'MMAbort',
'MMNull',
'MMStatus',
'MMInformation',
#
'MMTypeClasses',
'get_mm_msg_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.008: Mobile radio interface layer 3 specification
# release 13 (d90)
@ -72,7 +100,7 @@ _CS_MM_dict = {
}
class MMHeader(Envelope):
_GEN = (
_GEN = (
Uint('SkipInd', bl=4),
Uint('ProtDisc', val=5, bl=4, dic=ProtDisc_dict),
Uint('Seqn', bl=2),
@ -86,7 +114,9 @@ class MMHeader(Envelope):
#------------------------------------------------------------------------------#
class MMAuthenticationReject(Layer3):
_GEN = tuple(MMHeader(val={'Type':17})._content)
_GEN = (
MMHeader(val={'Type':17}),
)
#------------------------------------------------------------------------------#
@ -95,10 +125,11 @@ class MMAuthenticationReject(Layer3):
#------------------------------------------------------------------------------#
class MMAuthenticationRequest(Layer3):
_GEN = tuple(MMHeader(val={'Type':18})._content) + (
_GEN = (
MMHeader(val={'Type':18}),
Uint('spare', bl=4),
Uint('CKSN', bl=4, dic=CKSN_dict),
Buf('RAND', val=16*b'\0', bl=128, rep=REPR_HEX),
Type1V('CKSN', dic=CKSN_dict),
Type3V('RAND', val={'V':16*b'\0'}, bl={'V':128}),
Type4TLV('AUTN', val={'T':0x20, 'V':16*b'\0'}, IE=AUTN())
)
@ -109,8 +140,9 @@ class MMAuthenticationRequest(Layer3):
#------------------------------------------------------------------------------#
class MMAuthenticationResponse(Layer3):
_GEN = tuple(MMHeader(val={'Type':20})._content) + (
Buf('RES', val=4*b'\0', bl=32, rep=REPR_HEX),
_GEN = (
MMHeader(val={'Type':20}),
Type3V('RES', val={'V':4*b'\0'}, bl={'V':32}),
Type4TLV('RESExt', val={'T':0x21, 'V':4*b'\0'})
)
@ -121,8 +153,9 @@ class MMAuthenticationResponse(Layer3):
#------------------------------------------------------------------------------#
class MMAuthenticationFailure(Layer3):
_GEN = tuple(MMHeader(val={'Type':28})._content) + (
Uint8('Cause', val=17, dic=RejectCause_dict),
_GEN = (
MMHeader(val={'Type':28}),
Type3V('RejectCause', val={'V':b'\x11'}, bl={'V':8}, IE=RejectCause()),
Type4TLV('AUTS', val={'T':0x22, 'V':16*b'\0'})
)
@ -133,9 +166,10 @@ class MMAuthenticationFailure(Layer3):
#------------------------------------------------------------------------------#
class MMCMReestablishmentRequest(Layer3):
_GEN = tuple(MMHeader(val={'Type':40})._content) + (
_GEN = (
MMHeader(val={'Type':40}),
Uint('spare', bl=4),
Uint('CKSN', bl=4, dic=CKSN_dict),
Type1V('CKSN', dic=CKSN_dict),
Type4LV('MSCm2', val={'V':b'@\0\0'}, IE=MSCm2()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type3TV('LAI', val={'T':0x13, 'V':b'\0\xf1\x10\0\0'}, bl={'V':40}, IE=LAI()),
@ -149,7 +183,9 @@ class MMCMReestablishmentRequest(Layer3):
#------------------------------------------------------------------------------#
class MMCMServiceAccept(Layer3):
_GEN = tuple(MMHeader(val={'Type':33})._content)
_GEN = (
MMHeader(val={'Type':33}),
)
#------------------------------------------------------------------------------#
@ -158,10 +194,9 @@ class MMCMServiceAccept(Layer3):
#------------------------------------------------------------------------------#
class MMCMServicePrompt(Layer3):
_GEN = tuple(MMHeader(val={'Type':37})._content) + (
Uint('spare', bl=2),
Uint('SAPI', bl=2),
Uint('PD', val=5, bl=4, dic=ProtDisc_dict)
_GEN = (
MMHeader(val={'Type':37}),
Type3V('PD_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=PD_SAPI())
)
@ -171,8 +206,9 @@ class MMCMServicePrompt(Layer3):
#------------------------------------------------------------------------------#
class MMCMServiceReject(Layer3):
_GEN = tuple(MMHeader(val={'Type':34})._content) + (
Uint8('Cause', val=17, dic=RejectCause_dict),
_GEN = (
MMHeader(val={'Type':34}),
Type3V('RejectCause', val={'V':b'\x11'}, bl={'V':8}, IE=RejectCause()),
Type4TLV('T3246', val={'T':0x36, 'V':b'\0'})
)
@ -183,7 +219,9 @@ class MMCMServiceReject(Layer3):
#------------------------------------------------------------------------------#
class MMCMServiceAbort(Layer3):
_GEN = tuple(MMHeader(val={'Type':35})._content)
_GEN = (
MMHeader(val={'Type':35}),
)
#------------------------------------------------------------------------------#
@ -192,8 +230,9 @@ class MMCMServiceAbort(Layer3):
#------------------------------------------------------------------------------#
class MMAbort(Layer3):
_GEN = tuple(MMHeader(val={'Type':41})._content) + (
Uint8('Cause', val=17, dic=RejectCause_dict),
_GEN = (
MMHeader(val={'Type':41}),
Type3V('RejectCause', val={'V':b'\x11'}, bl={'V':8}, IE=RejectCause())
)
@ -203,9 +242,10 @@ class MMAbort(Layer3):
#------------------------------------------------------------------------------#
class MMCMServiceRequest(Layer3):
_GEN = tuple(MMHeader(val={'Type':36})._content) + (
Uint('CKSN', bl=4, dic=CKSN_dict),
Uint('Service', val=1, bl=4, dic=CMService_dict),
_GEN = (
MMHeader(val={'Type':36}),
Type1V('CKSN', dic=CKSN_dict),
Type1V('Service', val={'V':1}, dic=CMService_dict),
Type4LV('MSCm2', val={'V':b'@\0\0'}, IE=MSCm2()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type1TV('Priority', val={'T':0x8, 'V':0}, IE=PriorityLevel()),
@ -220,9 +260,10 @@ class MMCMServiceRequest(Layer3):
#------------------------------------------------------------------------------#
class MMIdentityRequest(Layer3):
_GEN = tuple(MMHeader(val={'Type':24})._content) + (
_GEN = (
MMHeader(val={'Type':24}),
Uint('spare', bl=4),
Uint('IDType', val=IDTYPE_IMSI, bl=4, dic=IDType_dict)
Type1V('IDType', val={'V':IDTYPE_IMSI}, dic=IDType_dict)
)
@ -232,7 +273,8 @@ class MMIdentityRequest(Layer3):
#------------------------------------------------------------------------------#
class MMIdentityResponse(Layer3):
_GEN = tuple(MMHeader(val={'Type':25})._content) + (
_GEN = (
MMHeader(val={'Type':25}),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type1TV('PTMSIType', val={'T':0xE, 'V':0}, IE=PTMSIType()),
Type4TLV('RAI', val={'T':0x1B, 'V':b'\0\xf1\x10\0\0\0'}, IE=RAI()),
@ -246,8 +288,9 @@ class MMIdentityResponse(Layer3):
#------------------------------------------------------------------------------#
class MMIMSIDetachIndication(Layer3):
_GEN = tuple(MMHeader(val={'Type':1})._content) + (
MSCm1(),
_GEN = (
MMHeader(val={'Type':1}),
Type3V('MSCm1', val={'V':b'\x40'}, bl={'V':8}, IE=MSCm1()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID())
)
@ -258,8 +301,9 @@ class MMIMSIDetachIndication(Layer3):
#------------------------------------------------------------------------------#
class MMLocationUpdatingAccept(Layer3):
_GEN = tuple(MMHeader(val={'Type':2})._content) + (
LAI(),
_GEN = (
MMHeader(val={'Type':2}),
Type3V('LAI', val={'V': b'\0\xf1\x10\0\0'}, bl={'V':40}, IE=LAI()),
Type4TLV('ID', val={'T':0x17 ,'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type2('FollowOnProceed', val={'T':0xA1}),
Type2('CTSPerm', val={'T':0xA2}),
@ -275,8 +319,9 @@ class MMLocationUpdatingAccept(Layer3):
#------------------------------------------------------------------------------#
class MMLocationUpdatingReject(Layer3):
_GEN = tuple(MMHeader(val={'Type':4})._content) + (
Uint8('Cause', val=17, dic=RejectCause_dict),
_GEN = (
MMHeader(val={'Type':4}),
Type3V('RejectCause', val={'V':b'\x11'}, bl={'V':8}, IE=RejectCause()),
Type4TLV('T3246', val={'T':0x36, 'V':b'\0'}, IE=MMTimer())
)
@ -287,16 +332,17 @@ class MMLocationUpdatingReject(Layer3):
#------------------------------------------------------------------------------#
class MMLocationUpdatingRequest(Layer3):
_GEN = tuple(MMHeader(val={'Type':8})._content) + (
Uint('CKSN', bl=4, dic=CKSN_dict),
LocUpdateType(),
LAI(),
Type3V('MSCm1', val={'V':b'\0'}, bl={'V':8}, IE=MSCm1()),
_GEN = (
MMHeader(val={'Type':8}),
Type1V('CKSN', dic=CKSN_dict),
Type1V('LocUpdateType', IE=LocUpdateType()),
Type3V('LAI', val={'V': b'\0\xf1\x10\0\0'}, bl={'V':40}, IE=LAI()),
Type3V('MSCm1', val={'V':b'\x40'}, bl={'V':8}, IE=MSCm1()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type4TLV('MSCm2', val={'T':0x33, 'V':b'@\0\0'}, IE=MSCm2()),
Type1TV('AddUpdateParams', val={'T':0xC, 'V':0}, IE=AddUpdateParams()),
Type1TV('DeviceProp', val={'T':0xD, 'V':0}, IE=DeviceProp()),
Type1TV('MSNetFeatSupp', val={'T':0xE, 'V':0}, IE=MSNetFeatSupp()),
Type1TV('MSNetFeatSupp', val={'T':0xE, 'V':0}, IE=MSNetFeatSupp())
)
@ -306,7 +352,8 @@ class MMLocationUpdatingRequest(Layer3):
#------------------------------------------------------------------------------#
class MMInformation(Layer3):
_GEN = tuple(MMHeader(val={'Type':50})._content) + (
_GEN = (
MMHeader(val={'Type':50}),
Type4TLV('NetFullName', val={'T':0x43, 'V':b'\0'}, IE=NetworkName()),
Type4TLV('NetShortName', val={'T':0x45, 'V':b'\0'}, IE=NetworkName()),
Type3TV('LocalTimeZone', val={'T':0x46, 'V':b'\0'}, bl={'V':8}, IE=TimeZone()),
@ -323,8 +370,9 @@ class MMInformation(Layer3):
#------------------------------------------------------------------------------#
class MMStatus(Layer3):
_GEN = tuple(MMHeader(val={'Type':49})._content) + (
Uint8('Cause', val=17, dic=RejectCause_dict),
_GEN = (
MMHeader(val={'Type':49}),
Type3V('RejectCause', val={'V':b'\x11'}, bl={'V':8}, IE=RejectCause())
)
@ -334,9 +382,10 @@ class MMStatus(Layer3):
#------------------------------------------------------------------------------#
class MMTMSIReallocationCommand(Layer3):
_GEN = tuple(MMHeader(val={'Type':26})._content) + (
LAI(),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
_GEN = (
MMHeader(val={'Type':26}),
Type3V('LAI', val={'V': b'\0\xf1\x10\0\0'}, bl={'V':40}, IE=LAI()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID())
)
@ -346,7 +395,9 @@ class MMTMSIReallocationCommand(Layer3):
#------------------------------------------------------------------------------#
class MMTMSIReallocationComplete(Layer3):
_GEN = tuple(MMHeader(val={'Type':27})._content)
_GEN = (
MMHeader(val={'Type':27}),
)
#------------------------------------------------------------------------------#
@ -355,7 +406,9 @@ class MMTMSIReallocationComplete(Layer3):
#------------------------------------------------------------------------------#
class MMNull(Layer3):
_GEN = tuple(MMHeader(val={'Type':48})._content)
_GEN = (
MMHeader(val={'Type':48}),
)
#------------------------------------------------------------------------------#

169
pycrate_mobile/TS24008_SM.py
View File

@ -27,6 +27,36 @@
# *--------------------------------------------------------
#*/
__all__ = [
'SMActivateMBMSContextAccept',
'SMActivateMBMSContextReject',
'SMActivateMBMSContextRequest',
'SMActivatePDPContextAccept',
'SMActivatePDPContextReject',
'SMActivatePDPContextRequest',
'SMActivateSecondaryPDPContextAccept',
'SMActivateSecondaryPDPContextReject',
'SMActivateSecondaryPDPContextRequest',
'SMDeactivatePDPContextAccept',
'SMDeactivatePDPContextRequest',
'SMModifyPDPContextAcceptMO',
'SMModifyPDPContextAcceptMT',
'SMModifyPDPContextReject',
'SMModifyPDPContextRequestMO',
'SMModifyPDPContextRequestMT',
'SMNotification',
'SMRequestMBMSContextActivation',
'SMRequestMBMSContextActivationReject',
'SMRequestPDPContextActivation',
'SMRequestPDPContextActivationReject',
'SMRequestSecondaryPDPContextActivation',
'SMRequestSecondaryPDPContextActivationReject',
'SMStatus',
#
'SMTypeClasses',
'get_sm_msg_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.008: Mobile radio interface layer 3 specification
# release 13 (d90)
@ -74,8 +104,7 @@ _PS_SM_dict = {
class SMHeader(Envelope):
_GEN = (
Uint('TransId', val=0, bl=4), # TODO: this may be extended to 12 bits
Uint('ProtDisc', val=10, bl=4, dic=ProtDisc_dict),
TIPD(val={'ProtDisc': 10}),
Uint8('Type', val=85, dic=_PS_SM_dict),
)
@ -85,16 +114,17 @@ class SMHeader(Envelope):
#------------------------------------------------------------------------------#
class SMActivatePDPContextRequest(Layer3):
_GEN = tuple(SMHeader(val={'Type':65})._content) + (
NSAPI(),
LLC_SAPI(),
_GEN = (
SMHeader(val={'Type':65}),
Type3V('NSAPI', val={'V':b'\x05'}, bl={'V':8}, IE=NSAPI()),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4LV('QoS', val={'V':11*b'\x00'}, IE=QoS()),
Type4LV('PDPAddr', val={'V':b'\x00\x01'}, IE=PDPAddr()),
Type4TLV('APN', val={'T':0x28, 'V':b'\x00'}, trans=True),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig(), trans=True),
Type1TV('ReqType', val={'T':0xA, 'V':1}, dic=RequestType_dict, trans=True),
Type1TV('DeviceProp', val={'T':0xC, 'V':0}, IE=DeviceProp(), trans=True),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\x00'}, trans=True)
Type4TLV('APN', val={'T':0x28, 'V':b'\0'}, IE=APN()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type1TV('ReqType', val={'T':0xA, 'V':1}, dic=RequestType_dict),
Type1TV('DeviceProp', val={'T':0xC, 'V':0}, IE=DeviceProp()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\x00'})
)
@ -104,15 +134,16 @@ class SMActivatePDPContextRequest(Layer3):
#------------------------------------------------------------------------------#
class SMActivatePDPContextAccept(Layer3):
_GEN = tuple(SMHeader(val={'Type':66})._content) + (
LLC_SAPI(),
_GEN = (
SMHeader(val={'Type':66}),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4LV('QoS', val={'V':11*b'\0'}, IE=QoS()),
Uint('spare', bl=4),
RadioPriority(),
Type1V('RadioPriority', dic=RadioPrio_dict),
Type4TLV('PDPAddr', val={'T':0x2B, 'V':b'\0\x01'}, IE=PDPAddr()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('PacketFlowId', val={'T':0x34, 'V':b'\0'}, IE=PacketFlowId()),
Type4TLV('SMCause', val={'T':0x39, 'V':b'\0'}, IE=SMCause()),
Type4TLV('SMCause', val={'T':0x39, 'V':b'\x6f'}, IE=SMCause()),
Type1TV('ConType', val={'T':0xB, 'V':0}, dic=ConnectivityType_dict),
Type1TV('WLANOffloadInd', val={'T':0xC, 'V':0}, IE=WLANOffloadAccept()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'})
@ -125,8 +156,9 @@ class SMActivatePDPContextAccept(Layer3):
#------------------------------------------------------------------------------#
class SMActivatePDPContextReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':67})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':67}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd()),
@ -140,11 +172,12 @@ class SMActivatePDPContextReject(Layer3):
#------------------------------------------------------------------------------#
class SMActivateSecondaryPDPContextRequest(Layer3):
_GEN = tuple(SMHeader(val={'Type':77})._content) + (
NSAPI(),
LLC_SAPI(),
_GEN = (
SMHeader(val={'Type':77}),
Type3V('NSAPI', val={'V':b'\x05'}, bl={'V':8}, IE=NSAPI()),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4LV('QoS', val={'V':11*b'\0'}, IE=QoS()),
Type4LV('LinkedTransId', val={'V':b'\0'}, IE=TransId()),
Type4LV('LinkedTI', val={'V':b'\0'}, IE=TI()),
Type4TLV('TFT', val={'T':0x36, 'V':b'\0'}, IE=TFT()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type1TV('DeviceProp', val={'T':0xC, 'V':0}, IE=DeviceProp()),
@ -158,11 +191,12 @@ class SMActivateSecondaryPDPContextRequest(Layer3):
#------------------------------------------------------------------------------#
class SMActivateSecondaryPDPContextAccept(Layer3):
_GEN = tuple(SMHeader(val={'Type':78})._content) + (
LLC_SAPI(),
_GEN = (
SMHeader(val={'Type':78}),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4LV('QoS', val={'V':11*b'\0'}, IE=QoS()),
Uint('spare', bl=4),
RadioPriority(),
Type1V('RadioPriority', dic=RadioPrio_dict),
Type4TLV('PacketFlowId', val={'T':0x34, 'V':b'\0'}, IE=PacketFlowId()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type1TV('WLANOffloadInd', val={'T':0xC, 'V':0}, IE=WLANOffloadAccept()),
@ -176,8 +210,9 @@ class SMActivateSecondaryPDPContextAccept(Layer3):
#------------------------------------------------------------------------------#
class SMActivateSecondaryPDPContextReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':79})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':79}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd()),
@ -191,7 +226,8 @@ class SMActivateSecondaryPDPContextReject(Layer3):
#------------------------------------------------------------------------------#
class SMRequestPDPContextActivation(Layer3):
_GEN = tuple(SMHeader(val={'Type':68})._content) + (
_GEN = (
SMHeader(val={'Type':68}),
Type4LV('PDPAddr', val={'V':b'\0\x01'}, IE=PDPAddr()),
Type4TLV('APN', val={'T':0x28, 'V':b'\0'}, IE=APN()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
@ -204,8 +240,9 @@ class SMRequestPDPContextActivation(Layer3):
#------------------------------------------------------------------------------#
class SMRequestPDPContextActivationReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':69})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':69}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'})
)
@ -216,10 +253,11 @@ class SMRequestPDPContextActivationReject(Layer3):
#------------------------------------------------------------------------------#
class SMModifyPDPContextRequestMT(Layer3):
_GEN = tuple(SMHeader(val={'Type':72})._content) + (
_GEN = (
SMHeader(val={'Type':72}),
Uint('spare', bl=4),
RadioPriority(),
LLC_SAPI(),
Type1V('RadioPriority', dic=RadioPrio_dict),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4LV('QoS', val={'V':11*b'\0'}, IE=QoS()),
Type4TLV('PDPAddr', val={'T':0x2B, 'V':b'\0\x01'}, IE=PDPAddr()),
Type4TLV('PacketFlowId', val={'T':0x34, 'V':b'\0'}, IE=PacketFlowId()),
@ -235,7 +273,8 @@ class SMModifyPDPContextRequestMT(Layer3):
#------------------------------------------------------------------------------#
class SMModifyPDPContextRequestMO(Layer3):
_GEN = tuple(SMHeader(val={'Type':74})._content) + (
_GEN = (
SMHeader(val={'Type':74}),
Type3TV('LLC_SAPI', val={'T':0x32, 'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4TLV('QoS', val={'T':0x30, 'V':11*b'\0'}, IE=QoS()),
Type4TLV('TFT', val={'T':0x31, 'V':b'\0'}, IE=TFT()),
@ -251,7 +290,8 @@ class SMModifyPDPContextRequestMO(Layer3):
#------------------------------------------------------------------------------#
class SMModifyPDPContextAcceptMO(Layer3):
_GEN = tuple(SMHeader(val={'Type':73})._content) + (
_GEN = (
SMHeader(val={'Type':73}),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'})
)
@ -262,7 +302,8 @@ class SMModifyPDPContextAcceptMO(Layer3):
#------------------------------------------------------------------------------#
class SMModifyPDPContextAcceptMT(Layer3):
_GEN = tuple(SMHeader(val={'Type':75})._content) + (
_GEN = (
SMHeader(val={'Type':75}),
Type4TLV('QoS', val={'T':0x30, 'V':11*b'\0'}, IE=QoS()),
Type3TV('LLC_SAPI', val={'T':0x32, 'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type1TV('RadioPriority', val={'T':0x8, 'V':0}, IE=RadioPriority()),
@ -278,8 +319,9 @@ class SMModifyPDPContextAcceptMT(Layer3):
#------------------------------------------------------------------------------#
class SMModifyPDPContextReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':76})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':76}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd()),
@ -292,8 +334,9 @@ class SMModifyPDPContextReject(Layer3):
#------------------------------------------------------------------------------#
class SMDeactivatePDPContextRequest(Layer3):
_GEN = tuple(SMHeader(val={'Type':70})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':70}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type1TV('TearDownInd', val={'T':0x9, 'V':0}, IE=TearDownInd()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('MBMSProtConfig', val={'T':0x35, 'V':b'\0'}),
@ -308,7 +351,8 @@ class SMDeactivatePDPContextRequest(Layer3):
#------------------------------------------------------------------------------#
class SMDeactivatePDPContextAccept(Layer3):
_GEN = tuple(SMHeader(val={'Type':71})._content) + (
_GEN = (
SMHeader(val={'Type':71}),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('MBMSProtConfig', val={'T':0x35, 'V':b'\0'})
)
@ -320,9 +364,10 @@ class SMDeactivatePDPContextAccept(Layer3):
#------------------------------------------------------------------------------#
class SMRequestSecondaryPDPContextActivation(Layer3):
_GEN = tuple(SMHeader(val={'Type':91})._content) + (
_GEN = (
SMHeader(val={'Type':91}),
Type4LV('QoS', val={'V':11*b'\0'}, IE=QoS()),
Type4LV('LinkedTransId', val={'V':b'\0'}, IE=TransId()),
Type4LV('LinkedTI', val={'V':b'\0'}, IE=TI()),
Type4TLV('TFT', val={'T':0x36, 'V':b'\0'}, IE=TFT()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type1TV('WLANOffloadInd', val={'T':0xC, 'V':0}, IE=WLANOffloadAccept()),
@ -336,8 +381,9 @@ class SMRequestSecondaryPDPContextActivation(Layer3):
#------------------------------------------------------------------------------#
class SMRequestSecondaryPDPContextActivationReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':92})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':92}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'})
)
@ -349,8 +395,9 @@ class SMRequestSecondaryPDPContextActivationReject(Layer3):
#------------------------------------------------------------------------------#
class SMNotification(Layer3):
_GEN = tuple(SMHeader(val={'Type':93})._content) + (
Type4LV('NotificationInd', val={'V':b'\0'}, IE=NotificationInd()),
_GEN = (
SMHeader(val={'Type':93}),
Type4LV('NotificationInd', val={'V':b'\0'}, IE=NotificationInd())
)
@ -360,8 +407,9 @@ class SMNotification(Layer3):
#------------------------------------------------------------------------------#
class SMStatus(Layer3):
_GEN = tuple(SMHeader(val={'Type':85})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':85}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause())
)
#------------------------------------------------------------------------------#
@ -370,9 +418,10 @@ class SMStatus(Layer3):
#------------------------------------------------------------------------------#
class SMActivateMBMSContextRequest(Layer3):
_GEN = tuple(SMHeader(val={'Type':86})._content) + (
ENSAPI('MBMS_NSAPI'),
LLC_SAPI(),
_GEN = (
SMHeader(val={'Type':86}),
Type3V('MBMS_NSAPI', val={'V':b'\0'}, bl={'V':8}, IE=ENSAPI()),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4LV('MBMSBearerCap', val={'V':b'\0'}, IE=MBMSBearerCap()),
Type4LV('MCastAddr', val={'V':b'\0\x01'}, IE=PDPAddr()),
Type4LV('APN', val={'V':b'\0'}, IE=APN()),
@ -387,9 +436,10 @@ class SMActivateMBMSContextRequest(Layer3):
#------------------------------------------------------------------------------#
class SMActivateMBMSContextAccept(Layer3):
_GEN = tuple(SMHeader(val={'Type':87})._content) + (
_GEN = (
SMHeader(val={'Type':87}),
Type4LV('TMGI', val={'V':b'\0\0\0'}, IE=TMGI()),
LLC_SAPI(),
Type3V('LLC_SAPI', val={'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type4TLV('MBMSProtConfig', val={'T':0x35, 'V':b'\0'})
)
@ -400,8 +450,9 @@ class SMActivateMBMSContextAccept(Layer3):
#------------------------------------------------------------------------------#
class SMActivateMBMSContextReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':88})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':88}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('MBMSProtConfig', val={'T':0x35, 'V':b'\0'}),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd())
@ -414,8 +465,9 @@ class SMActivateMBMSContextReject(Layer3):
#------------------------------------------------------------------------------#
class SMRequestMBMSContextActivation(Layer3):
_GEN = tuple(SMHeader(val={'Type':89})._content) + (
NSAPI(),
_GEN = (
SMHeader(val={'Type':89}),
Type3V('LinkedNSAPI', val={'V':b'\x05'}, bl={'V':8}, IE=NSAPI()),
Type4LV('MCastAddr', val={'V':b'\0\x01'}, IE=PDPAddr()),
Type4LV('APN', val={'V':b'\0'}, IE=APN()),
Type4TLV('MBMSProtConfig', val={'T':0x35, 'V':b'\0'})
@ -428,8 +480,9 @@ class SMRequestMBMSContextActivation(Layer3):
#------------------------------------------------------------------------------#
class SMRequestMBMSContextActivationReject(Layer3):
_GEN = tuple(SMHeader(val={'Type':90})._content) + (
SMCause(),
_GEN = (
SMHeader(val={'Type':90}),
Type3V('SMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=SMCause()),
Type4TLV('MBMSProtConfig', val={'T':0x35, 'V':b'\0'})
)

70
pycrate_mobile/TS24011_PPSMS.py
View File

@ -27,6 +27,29 @@
# *--------------------------------------------------------
#*/
__all__ = [
'SMS_CP',
'SMS_RP',
#
'CP_DATA',
'CP_ACK',
'CP_ERROR',
#
'PPSMSCPTypeClasses',
'get_ppsmscp_msg_instances',
#
'RP_DATA_MO',
'RP_DATA_MT',
'RP_ACK_MO',
'RP_ACK_MT',
'RP_ERROR_MO',
'RP_ERROR_MT',
'RP_SMMA',
#
'PPSMSRPTypeClasses',
'get_ppsmsrp_msg_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.011: Point-to-Point (PP) Short Message Service (SMS)
# support on mobile radio interface
@ -42,6 +65,18 @@ from .TS24008_IE import BufBCD, _BCDType_dict, _NumPlan_dict
from .TS23040_SMS import *
class SMS_CP(Layer3):
"""parent class for all SMS CP messages
"""
pass
class SMS_RP(Layer3):
"""parent class for all SMS RP messages
"""
pass
#------------------------------------------------------------------------------#
# CP‑messages
# TS 24.011, section 8.1
@ -55,9 +90,7 @@ _SMSPP_CP_dict = {
class CPHeader(Envelope):
_GEN = (
Uint('TIFlag', bl=1, dic={0: 'initiator', 1: 'responder'}),
Uint('TIO', bl=3),
Uint('ProtDisc', val=9, bl=4, dic=ProtDisc_dict),
TIPD(val={'ProtDisc': 9}),
Uint8('Type', val=1, dic=_SMSPP_CP_dict),
)
@ -79,25 +112,29 @@ _CPCause_dict = {
111: 'Protocol error, unspecified',
}
class CPCause(Uint8):
_dic = _CPCause_dict
#------------------------------------------------------------------------------#
# CP‑DATA
# TS 24.011, section 7.2.1
#------------------------------------------------------------------------------#
class CP_DATA(Layer3):
_GEN = tuple(CPHeader(val={'Type':1})._content) + (
Type4LV('CPUserData', val={'V':b''}),
class CP_DATA(SMS_CP):
_GEN = (
CPHeader(val={'Type':1}),
Type4LV('CPUserData', val={'V':b''})
)
def _from_char(self, char):
Layer3._from_char(self, char)
L = self['CPUserData'][0]()
L = self['CPUserData'][0].get_val()
if L:
ccur, clen = char._cur, char._len_bit
char._cur -= 8*L
char._len_bit = char._cur + 8*L
mti = char.to_uint(8) & 0x3
mti = char.to_uint(8) & 0x7
try:
rp = PPSMSRPTypeClasses[mti]()
rp._from_char(char)
@ -128,8 +165,10 @@ class CP_DATA(Layer3):
# TS 24.011, section 7.2.2
#------------------------------------------------------------------------------#
class CP_ACK(Layer3):
_GEN = tuple(CPHeader(val={'Type':4})._content)
class CP_ACK(SMS_CP):
_GEN = (
CPHeader(val={'Type':4}),
)
#------------------------------------------------------------------------------#
@ -137,9 +176,10 @@ class CP_ACK(Layer3):
# TS 24.011, section 7.2.3
#------------------------------------------------------------------------------#
class CP_ERROR(Layer3):
_GEN = tuple(CPHeader(val={'Type':1})._content) + (
Uint8('CPCause', val=17, dic=_CPCause_dict),
class CP_ERROR(SMS_CP):
_GEN = (
CPHeader(val={'Type':16}),
Type3V('CPCause', val={'V':b'\x11'}, bl={'V':8}, IE=CPCause())
)
@ -260,7 +300,7 @@ class RPCause(Envelope):
# TS 24.011, section 7.3.1.1
#------------------------------------------------------------------------------#
class _RP_DATA(Layer3):
class _RP_DATA(SMS_RP):
# provide a single TPDU or a dict of MTI:TPDU according to the type of RP
TPDU = {}
@ -335,7 +375,7 @@ class RP_DATA_MO(_RP_DATA):
# TS 24.011, section 7.3.2
#------------------------------------------------------------------------------#
class RP_SMMA(Layer3):
class RP_SMMA(SMS_RP):
_GEN = tuple(RPHeader(val={'MTI':6})._content)

37
pycrate_mobile/TS24080_SS.py
View File

@ -27,6 +27,17 @@
# *--------------------------------------------------------
#*/
__all__ = [
'SSReleaseComplete',
'SSFacility',
'SSRegisterMO',
'SSRegisterMT',
'SSTypeMOClasses',
'SSTypeMTClasses',
'get_ss_msg_mo_instances',
'get_ss_msg_mt_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.080: Mobile radio interface layer 3
# Supplementary services specification
@ -104,9 +115,7 @@ _SS_dict = {
class SSHeader(Envelope):
_GEN = (
Uint('TIFlag', bl=1, dic={0: 'initiator', 1: 'responder'}),
Uint('TIO', bl=3),
Uint('ProtDisc', val=11, bl=4, dic=ProtDisc_dict),
TIPD(val={'ProtDisc': 11}),
Uint('Seqn', bl=2),
Uint('Type', val=58, bl=6, dic=_SS_dict)
)
@ -118,7 +127,8 @@ class SSHeader(Envelope):
#------------------------------------------------------------------------------#
class SSFacility(Layer3):
_GEN = tuple(SSHeader(val={'Type':58})._content) + (
_GEN = (
SSHeader(val={'Type':58}),
Type4LV('Facility', val={'V':b'\0'}, IE=Facility()),
)
@ -129,8 +139,9 @@ class SSFacility(Layer3):
#------------------------------------------------------------------------------#
class SSRegisterMT(Layer3):
_GEN = tuple(SSHeader(val={'Type':59})._content) + (
Type4TLV('Facility', val={'T':0x1C, 'V':b''}, trans=True),
_GEN = (
SSHeader(val={'Type':59}),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}),
)
@ -140,9 +151,10 @@ class SSRegisterMT(Layer3):
#------------------------------------------------------------------------------#
class SSRegisterMO(Layer3):
_GEN = tuple(SSHeader(val={'Type':59})._content) + (
Type4TLV('Facility', val={'T':0x1C, 'V':b''}, IE=Facility(), trans=True),
Type4TLV('SSVersion', val={'T':0x7F, 'V':b'\0'}, IE=SSVersion(), trans=True)
_GEN = (
SSHeader(val={'Type':59}),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}, IE=Facility()),
Type4TLV('SSVersion', val={'T':0x7F, 'V':b'\0'}, IE=SSVersion())
)
@ -152,9 +164,10 @@ class SSRegisterMO(Layer3):
#------------------------------------------------------------------------------#
class SSReleaseComplete(Layer3):
_GEN = tuple(SSHeader(val={'Type':42})._content) + (
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause(), trans=True),
Type4TLV('Facility', val={'T':0x1C, 'V':b''}, trans=True)
_GEN = (
SSHeader(val={'Type':42}),
Type4TLV('Cause', val={'T':0x8, 'V':b'\x80\x80'}, IE=Cause()),
Type4TLV('Facility', val={'T':0x1C, 'V':b''})
)

280
pycrate_mobile/TS24301_EMM.py
View File

@ -27,6 +27,47 @@
# *--------------------------------------------------------
#*/
__all__ = [
'EMMAttachAccept',
'EMMAttachComplete',
'EMMAttachReject',
'EMMAttachRequest',
'EMMAuthenticationFailure',
'EMMAuthenticationReject',
'EMMAuthenticationRequest',
'EMMAuthenticationResponse',
'EMMCPServiceRequest',
'EMMCSServiceNotification',
'EMMDetachAccept',
'EMMDetachRequestMO',
'EMMDetachRequestMT',
'EMMDLGenericNASTransport',
'EMMDLNASTransport',
'EMMExtServiceRequest',
'EMMGUTIReallocCommand',
'EMMGUTIReallocComplete',
'EMMIdentityRequest',
'EMMIdentityResponse',
'EMMInformation',
'EMMSecurityModeCommand',
'EMMSecurityModeComplete',
'EMMSecurityModeReject',
'EMMServiceAccept',
'EMMServiceReject',
'EMMStatus',
'EMMTrackingAreaUpdateAccept',
'EMMTrackingAreaUpdateComplete',
'EMMTrackingAreaUpdateReject',
'EMMTrackingAreaUpdateRequest',
'EMMULGenericNASTransport',
'EMMULNASTransport',
#
'EMMTypeMOClasses',
'EMMTypeMTClasses',
'get_emm_msg_mo_instances',
'get_emm_msg_mt_instances',
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.301: NAS protocol for EPS
# release 13 (da0)
@ -126,16 +167,32 @@ class EMMHeader(Envelope):
)
class EMMHeaderSec(Envelope):
_GEN = (
Uint('SecHdr', val=1, bl=4, dic=SecHdrType_dict),
Uint('ProtDisc', val=7, bl=4, dic=ProtDisc_dict),
)
class EMMHeaderServ(Envelope):
_GEN = (
Uint('SecHdr', val=1, bl=4, dic=SecHdrType_dict),
Uint('ProtDisc', val=7, bl=4, dic=ProtDisc_dict),
Uint8('Type', val=0, trans=True)
)
#------------------------------------------------------------------------------#
# Attach accept
# TS 24.301, section 8.2.1
#------------------------------------------------------------------------------#
class EMMAttachAccept(Layer3):
_GEN = tuple(EMMHeader(val={'Type':66})._content) + (
_GEN = (
EMMHeader(val={'Type':66}),
Uint('spare', bl=4),
EPSAttachResult(),
GPRSTimer('T3412'),
Type1V('EPSAttachResult', dic=EPSAttRes_dict),
Type3V('T3412', val={'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type4LV('TAIList', val={'V':6*b'\0'}, IE=TAIList()),
Type6LVE('ESMContainer', val={'V':b'\0\0\0'}),
Type4TLV('GUTI', val={'T':0x50, 'V':b'\xf6'+10*b'\0'}, IE=EPSID()),
@ -160,7 +217,8 @@ class EMMAttachAccept(Layer3):
#------------------------------------------------------------------------------#
class EMMAttachComplete(Layer3):
_GEN = tuple(EMMHeader(val={'Type':67})._content) + (
_GEN = (
EMMHeader(val={'Type':67}),
Type6LVE('ESMContainer', val={'V':b'\0\0\0'}),
)
@ -171,8 +229,9 @@ class EMMAttachComplete(Layer3):
#------------------------------------------------------------------------------#
class EMMAttachReject(Layer3):
_GEN = tuple(EMMHeader(val={'Type':68})._content) + (
EMMCause(),
_GEN = (
EMMHeader(val={'Type':68}),
Type3V('EMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=EMMCause()),
Type6TLVE('ESMContainer', val={'T':0x78, 'V':b'\0\0\0'}),
Type4TLV('T3346', val={'T':0x5F, 'V':b'\0'}, IE=GPRSTimer()),
Type4TLV('T3402', val={'T':0x16, 'V':b'\0'}, IE=GPRSTimer()),
@ -186,9 +245,10 @@ class EMMAttachReject(Layer3):
#------------------------------------------------------------------------------#
class EMMAttachRequest(Layer3):
_GEN = tuple(EMMHeader(val={'Type':65})._content) + (
NAS_KSI(),
EPSAttachType(),
_GEN = (
EMMHeader(val={'Type':65}),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type1V('EPSAttachType', dic=EPSAttType_dict),
Type4LV('EPSID', val={'V':b'\xf6'+10*b'\0'}, IE=EPSID()),
Type4LV('UENetCap', val={'V':b'\0\0'}, IE=UENetCap()),
Type6LVE('ESMContainer', val={'V':b'\0\0\0'}),
@ -220,8 +280,9 @@ class EMMAttachRequest(Layer3):
#------------------------------------------------------------------------------#
class EMMAuthenticationFailure(Layer3):
_GEN = tuple(EMMHeader(val={'Type':92})._content) + (
EMMCause(),
_GEN = (
EMMHeader(val={'Type':92}),
Type3V('EMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=EMMCause()),
Type4TLV('AUTS', val={'T':0x30, 'V':14*b'\0'})
)
@ -232,7 +293,9 @@ class EMMAuthenticationFailure(Layer3):
#------------------------------------------------------------------------------#
class EMMAuthenticationReject(Layer3):
_GEN = tuple(EMMHeader(val={'Type':84})._content)
_GEN = (
EMMHeader(val={'Type':84}),
)
#------------------------------------------------------------------------------#
@ -241,11 +304,12 @@ class EMMAuthenticationReject(Layer3):
#------------------------------------------------------------------------------#
class EMMAuthenticationRequest(Layer3):
_GEN = tuple(EMMHeader(val={'Type':82})._content) + (
_GEN = (
EMMHeader(val={'Type':82}),
Uint('spare', bl=4),
NAS_KSI(),
Buf('RAND', val=16* b'\0', bl=128, rep=REPR_HEX),
Type4LV('AUTN', val={'V':16*b'\0'}, IE=AUTN()),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type3V('RAND', val={'V':16*b'\0'}, bl={'V':128}),
Type4LV('AUTN', val={'V':16*b'\0'}, IE=AUTN())
)
@ -255,8 +319,9 @@ class EMMAuthenticationRequest(Layer3):
#------------------------------------------------------------------------------#
class EMMAuthenticationResponse(Layer3):
_GEN = tuple(EMMHeader(val={'Type':83})._content) + (
Type4LV('RES', val={'V':8*b'\0'}),
_GEN = (
EMMHeader(val={'Type':83}),
Type4LV('RES', val={'V':8*b'\0'})
)
@ -266,8 +331,9 @@ class EMMAuthenticationResponse(Layer3):
#------------------------------------------------------------------------------#
class EMMCSServiceNotification(Layer3):
_GEN = tuple(EMMHeader(val={'Type':100})._content) + (
PagingIdentity(),
_GEN = (
EMMHeader(val={'Type':100}),
Type3V('PagingIdentity', val={'V':b'\x01'}, bl={'V':8}, IE=PagingIdentity()),
Type4TLV('CLI', val={'T':0x60, 'V':b'\x91'}, IE=CallingPartyBCDNumber()),
Type3TV('SSCode', val={'T':0x61, 'V':b'\0'}, bl={'V':8}, IE=SSCode()),
Type3TV('LCSInd', val={'T':0x62, 'V':b'\x01'}, bl={'V':8}, IE=LCSInd()),
@ -281,7 +347,9 @@ class EMMCSServiceNotification(Layer3):
#------------------------------------------------------------------------------#
class EMMDetachAccept(Layer3):
_GEN = tuple(EMMHeader(val={'Type':70})._content)
_GEN = (
EMMHeader(val={'Type':70}),
)
#------------------------------------------------------------------------------#
@ -290,9 +358,10 @@ class EMMDetachAccept(Layer3):
#------------------------------------------------------------------------------#
class EMMDetachRequestMO(Layer3):
_GEN = tuple(EMMHeader(val={'Type':69})._content) + (
NAS_KSI(),
EPSDetachTypeMO(),
_GEN = (
EMMHeader(val={'Type':69}),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type1V('EPSDetachType', IE=EPSDetachTypeMO()),
Type4LV('EPSID', val={'V':b'\xf6'+10*b'\0'}, IE=EPSID())
)
@ -303,9 +372,10 @@ class EMMDetachRequestMO(Layer3):
#------------------------------------------------------------------------------#
class EMMDetachRequestMT(Layer3):
_GEN = tuple(EMMHeader(val={'Type':69})._content) + (
_GEN = (
EMMHeader(val={'Type':69}),
Uint('spare', bl=4),
EPSDetachTypeMT(),
Type1V('EPSDetachType', IE=EPSDetachTypeMT()),
Type3TV('EMMCause', val={'T':0x53, 'V':b'\0'}, bl={'V':8}, IE=EMMCause())
)
@ -316,8 +386,9 @@ class EMMDetachRequestMT(Layer3):
#------------------------------------------------------------------------------#
class EMMDLNASTransport(Layer3):
_GEN = tuple(EMMHeader(val={'Type':98})._content) + (
Type4LV('NASContainer', val={'V':b'\0\0'}),
_GEN = (
EMMHeader(val={'Type':98}),
Type4LV('NASContainer', val={'V':b'\0\0'})
)
@ -327,7 +398,8 @@ class EMMDLNASTransport(Layer3):
#------------------------------------------------------------------------------#
class EMMInformation(Layer3):
_GEN = tuple(EMMHeader(val={'Type':97})._content) + (
_GEN = (
EMMHeader(val={'Type':97}),
Type4TLV('NetFullName', val={'T':0x43, 'V':b'\0'}, IE=NetworkName()),
Type4TLV('NetShortName', val={'T':0x45, 'V':b'\0'}, IE=NetworkName()),
Type3TV('LocalTimeZone', val={'T':0x46, 'V':b'\0'}, bl={'V':8}, IE=TimeZone()),
@ -343,8 +415,9 @@ class EMMInformation(Layer3):
#------------------------------------------------------------------------------#
class EMMStatus(Layer3):
_GEN = tuple(EMMHeader(val={'Type':96})._content) + (
EMMCause(),
_GEN = (
EMMHeader(val={'Type':96}),
Type3V('EMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=EMMCause())
)
@ -354,9 +427,10 @@ class EMMStatus(Layer3):
#------------------------------------------------------------------------------#
class EMMExtServiceRequest(Layer3):
_GEN = tuple(EMMHeader(val={'Type':76})._content) + (
NAS_KSI(),
Uint('ServiceType', bl=4, dic=EMMServType_dict),
_GEN = (
EMMHeader(val={'Type':76}),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type1V('ServiceType', dic=EMMServType_dict),
Type4LV('MTMSI', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type1TV('CSFBResponse', val={'T':0xB, 'V':0}, IE=CSFBResponse()),
Type4TLV('EPSBearerCtxtStat', val={'T':0x57, 'V':b'\0\0'}, IE=EPSBearerCtxtStat()),
@ -370,7 +444,8 @@ class EMMExtServiceRequest(Layer3):
#------------------------------------------------------------------------------#
class EMMGUTIReallocCommand(Layer3):
_GEN = tuple(EMMHeader(val={'Type':80})._content) + (
_GEN = (
EMMHeader(val={'Type':80}),
Type4LV('GUTI', val={'V':b'\xf6'+10*b'\0'}, IE=EPSID()),
Type4TLV('TAIList', val={'T':0x54, 'V':6*b'\0'}, IE=TAIList())
)
@ -382,7 +457,9 @@ class EMMGUTIReallocCommand(Layer3):
#------------------------------------------------------------------------------#
class EMMGUTIReallocComplete(Layer3):
_GEN = tuple(EMMHeader(val={'Type':81})._content)
_GEN = (
EMMHeader(val={'Type':81}),
)
#------------------------------------------------------------------------------#
@ -391,9 +468,10 @@ class EMMGUTIReallocComplete(Layer3):
#------------------------------------------------------------------------------#
class EMMIdentityRequest(Layer3):
_GEN = tuple(EMMHeader(val={'Type':85})._content) + (
_GEN = (
EMMHeader(val={'Type':85}),
Uint('spare', bl=4),
Uint('IDType', val=1, bl=4, dic=IDType_dict)
Type1V('IDType', val={'V':IDTYPE_IMSI}, dic=IDType_dict)
)
@ -403,8 +481,9 @@ class EMMIdentityRequest(Layer3):
#------------------------------------------------------------------------------#
class EMMIdentityResponse(Layer3):
_GEN = tuple(EMMHeader(val={'Type':86})._content) + (
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
_GEN = (
EMMHeader(val={'Type':86}),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID())
)
@ -414,10 +493,11 @@ class EMMIdentityResponse(Layer3):
#------------------------------------------------------------------------------#
class EMMSecurityModeCommand(Layer3):
_GEN = tuple(EMMHeader(val={'Type':93})._content) + (
NASSecAlgo(),
_GEN = (
EMMHeader(val={'Type':93}),
Type3V('NASSecAlgo', val={'V':b'\0'}, bl={'V':8}, IE=NASSecAlgo()),
Uint('spare', bl=4),
NAS_KSI(),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type4LV('UESecCap', val={'V':b'\0\0'}, IE=UESecCap()),
Type1TV('IMEISVReq', val={'T':0xC, 'V':0}),
Type3TV('NonceUE', val={'T':0x55, 'V':4*b'\0'}, bl={'V':32}),
@ -431,8 +511,9 @@ class EMMSecurityModeCommand(Layer3):
#------------------------------------------------------------------------------#
class EMMSecurityModeComplete(Layer3):
_GEN = tuple(EMMHeader(val={'Type':94})._content) + (
Type4TLV('IMEISV', val={'T':0x23, 'V':b'\x03\0\0\0\0\0\0\0\xf0'}, IE=ID()),
_GEN = (
EMMHeader(val={'Type':94}),
Type4TLV('IMEISV', val={'T':0x23, 'V':b'\x03\0\0\0\0\0\0\0\xf0'}, IE=ID())
)
@ -442,8 +523,9 @@ class EMMSecurityModeComplete(Layer3):
#------------------------------------------------------------------------------#
class EMMSecurityModeReject(Layer3):
_GEN = tuple(EMMHeader(val={'Type':95})._content) + (
EMMCause(),
_GEN = (
EMMHeader(val={'Type':95}),
Type3V('EMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=EMMCause())
)
@ -456,8 +538,7 @@ if _with_cm:
class EMMSecProtNASMessage(Layer3):
_GEN = (
Uint('SecHdr', val=1, bl=4, dic=SecHdrType_dict),
Uint('ProtDisc', val=7, bl=4, dic=ProtDisc_dict),
EMMHeaderSec(),
Buf('MAC', val=b'\0\0\0\0', bl=32, rep=REPR_HEX),
Uint8('Seqn'),
Buf('NASMessage')
@ -478,7 +559,7 @@ if _with_cm:
"""
if eia == 0:
return True
shdr = self[0].get_val()
shdr = self[0][0].get_val()
if shdr == 0:
return True
elif shdr in (1, 2, 3, 4):
@ -487,8 +568,8 @@ if _with_cm:
except KeyError:
raise(PycrateErr('EMMSecProtNASMessage.mac_verify(): invalid EIA identifier, {0}'\
.format(eia)))
mac = EIA(key, seqnoff + self[3].get_val(), 0, dir, self[3].to_bytes() + self[4].get_val())
return mac == self[2].get_val()
mac = EIA(key, seqnoff + self[2].get_val(), 0, dir, self[2].to_bytes() + self[3].get_val())
return mac == self[1].get_val()
else:
raise(PycrateErr('EMMSecProtNASMessage.mac_verify(): invalid sec hdr value, {0}'\
.format(shdr)))
@ -507,18 +588,19 @@ if _with_cm:
None
"""
if eia == 0:
self[2].set_val(b'\0\0\0\0')
shdr = self[0].get_val()
self[1].set_val(b'\0\0\0\0')
return
shdr = self[0][0].get_val()
if shdr == 0:
self[2].set_val(b'\0\0\0\0')
self[1].set_val(b'\0\0\0\0')
elif shdr in (1, 2, 3, 4):
try:
EIA = _EIA[eia]
except KeyError:
raise(PycrateErr('EMMSecProtNASMessage.mac_compute(): invalid EIA identifier, {0}'\
.format(eia)))
mac = EIA(key, seqnoff + self[3].get_val(), 0, dir, self[3].to_bytes() + self[4].get_val())
self[2].set_val(mac)
mac = EIA(key, seqnoff + self[2].get_val(), 0, dir, self[2].to_bytes() + self[3].get_val())
self[1].set_val(mac)
else:
raise(PycrateErr('EMMSecProtNASMessage.mac_compute(): invalid sec hdr value, {0}'\
.format(shdr)))
@ -537,7 +619,7 @@ if _with_cm:
"""
if eea == 0:
return
shdr = self[0].get_val()
shdr = self[0][0].get_val()
if shdr in (0, 1, 3):
return
elif shdr in (2, 4):
@ -546,9 +628,9 @@ if _with_cm:
except KeyError:
raise(PycrateErr('EMMSecProtNASMessage.encrypt(): invalid EEA identifier, {0}'\
.format(eea)))
self._dec_msg = self[4].to_bytes()
self._enc_msg = EEA(key, seqnoff + self[3].get_val(), 0, dir, self._dec_msg)
self[4].set_val(self._enc_msg)
self._dec_msg = self[3].to_bytes()
self._enc_msg = EEA(key, seqnoff + self[2].get_val(), 0, dir, self._dec_msg)
self[3].set_val(self._enc_msg)
else:
raise(PycrateErr('EMMSecProtNASMessage.encrypt(): invalid sec hdr value, {0}'\
.format(shdr)))
@ -567,7 +649,7 @@ if _with_cm:
"""
if eea == 0:
return
shdr = self[0].get_val()
shdr = self[0][0].get_val()
if shdr in (0, 1, 3):
return
elif shdr in (2, 4):
@ -576,9 +658,9 @@ if _with_cm:
except KeyError:
raise(PycrateErr('EMMSecProtNASMessage.decrypt(): invalid EEA identifier, {0}'\
.format(eea)))
self._enc_msg = self[4].to_bytes()
self._dec_msg = EEA(key, seqnoff + self[3].get_val(), 0, dir, self._enc_msg)
self[4].set_val(self._dec_msg)
self._enc_msg = self[3].to_bytes()
self._dec_msg = EEA(key, seqnoff + self[2].get_val(), 0, dir, self._enc_msg)
self[3].set_val(self._dec_msg)
else:
raise(PycrateErr('EMMSecProtNASMessage.decrypt(): invalid sec hdr value, {0}'\
.format(shdr)))
@ -587,8 +669,7 @@ else:
class EMMSecProtNASMessage(Layer3):
_GEN = (
Uint('SecHdr', val=1, bl=4, dic=SecHdrType_dict),
Uint('ProtDisc', val=7, bl=4, dic=ProtDisc_dict),
EMMHeaderSec(),
Buf('MAC', val=b'\0\0\0\0', bl=32, rep=REPR_HEX),
Uint8('Seqn'),
Buf('NASMessage')
@ -601,8 +682,9 @@ else:
#------------------------------------------------------------------------------#
class EMMServiceReject(Layer3):
_GEN = tuple(EMMHeader(val={'Type':78})._content) + (
EMMCause(),
_GEN = (
EMMHeader(val={'Type':78}),
Type3V('EMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=EMMCause()),
Type3TV('T3442', val={'T':0x5B, 'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type4TLV('T3346', val={'T':0x5C, 'V':b'\0'}, IE=GPRSTimer())
)
@ -617,9 +699,7 @@ if _with_cm:
class EMMServiceRequest(Layer3):
_GEN = (
Uint('SecHdr', val=12, bl=4, dic=SecHdrType_dict),
Uint('ProtDisc', val=7, bl=4, dic=ProtDisc_dict),
Uint8('Type', val=0, trans=True), # transparent field, only to ease message handling
EMMHeaderServ(val={'SecHdr': 12}),
Uint('KSI', bl=3, dic={7:'no key available'}),
Uint('SeqnShort', bl=5),
Buf('MACShort', val=b'\0\0', bl=16, rep=REPR_HEX)
@ -647,7 +727,7 @@ if _with_cm:
raise(PycrateErr('EMMServiceRequest.mac_verify(): invalid EIA identifier, {0}'\
.format(eia)))
msg = self.to_bytes()
mac = EIA(key, seqnoff + self['SeqnShort'].get_val(), 0, dir, msg[:2])
mac = EIA(key, seqnoff + self[2].get_val(), 0, dir, msg[:2])
if mac[2:4] != msg[2:4]:
return False
else:
@ -675,29 +755,30 @@ if _with_cm:
raise(PycrateErr('EMMServiceRequest.mac_compute(): invalid EIA identifier, {0}'\
.format(eia)))
msg = self.to_bytes()
mac = EIA(key, seqnoff + self['SeqnShort'].get_val(), 0, dir, msg[:2])
mac = EIA(key, seqnoff + self[2].get_val(), 0, dir, msg[:2])
self[4].set_val(mac[2:4])
else:
class EMMServiceRequest(Layer3):
_GEN = (
Uint('SecHdr', val=12, bl=4, dic=SecHdrType_dict),
Uint('ProtDisc', val=7, bl=4, dic=ProtDisc_dict),
EMMHeaderServ(val={'SecHdr': 12}),
Uint('KSI', bl=3, dic={7:'no key available'}),
Uint('SeqnShort', bl=5),
Buf('MACShort', val=b'\0\0', bl=16, rep=REPR_HEX)
)
#------------------------------------------------------------------------------#
# Tracking area update accept
# TS 24.301, section 8.2.26
#------------------------------------------------------------------------------#
class EMMTrackingAreaUpdateAccept(Layer3):
_GEN = tuple(EMMHeader(val={'Type':73})._content) + (
_GEN = (
EMMHeader(val={'Type':73}),
Uint('spare', bl=4),
EPSUpdateResult(),
Type1V('EPSUpdateResult', dic=EPSUpdRes_dict),
Type3TV('T3412', val={'T':0x5A, 'V':b'\0'}, bl={'V':8}, IE=GPRSTimer()),
Type4TLV('GUTI', val={'T':0x50, 'V':b'\xf6'+10*b'\0'}, IE=EPSID()),
Type4TLV('TAIList', val={'T':0x54, 'V':6*b'\0'}, IE=TAIList()),
@ -725,7 +806,9 @@ class EMMTrackingAreaUpdateAccept(Layer3):
#------------------------------------------------------------------------------#
class EMMTrackingAreaUpdateComplete(Layer3):
_GEN = tuple(EMMHeader(val={'Type':74})._content)
_GEN = (
EMMHeader(val={'Type':74}),
)
#------------------------------------------------------------------------------#
@ -734,8 +817,9 @@ class EMMTrackingAreaUpdateComplete(Layer3):
#------------------------------------------------------------------------------#
class EMMTrackingAreaUpdateReject(Layer3):
_GEN = tuple(EMMHeader(val={'Type':75})._content) + (
EMMCause(),
_GEN = (
EMMHeader(val={'Type':75}),
Type3V('EMMCause', val={'V':b'\x11'}, bl={'V':8}, IE=EMMCause()),
Type4TLV('T3346', val={'T':0x5F, 'V':b'\0'}, IE=GPRSTimer()),
Type1TV('ExtEMMCause', val={'T':0xA, 'V':0}, IE=ExtEMMCause())
)
@ -747,9 +831,10 @@ class EMMTrackingAreaUpdateReject(Layer3):
#------------------------------------------------------------------------------#
class EMMTrackingAreaUpdateRequest(Layer3):
_GEN = tuple(EMMHeader(val={'Type':72})._content) + (
NAS_KSI(),
EPSUpdateType(),
_GEN = (
EMMHeader(val={'Type':72}),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type1V('EPSUpdateType', IE=EPSUpdateType()),
Type4LV('OldGUTI', val={'V':b'\xf6'+10*b'\0'}, IE=EPSID()),
Type1TV('Native_NAS_KSI', val={'T':0xB, 'V':0}, IE=NAS_KSI()),
Type1TV('GPRS_CKSN', val={'T':0x8, 'V':0}, dic=CKSN_dict),
@ -785,8 +870,9 @@ class EMMTrackingAreaUpdateRequest(Layer3):
#------------------------------------------------------------------------------#
class EMMULNASTransport(Layer3):
_GEN = tuple(EMMHeader(val={'Type':99})._content) + (
Type4LV('NASContainer', val={'V':b'\0\0'}),
_GEN = (
EMMHeader(val={'Type':99}),
Type4LV('NASContainer', val={'V':b'\0\0'})
)
@ -796,8 +882,9 @@ class EMMULNASTransport(Layer3):
#------------------------------------------------------------------------------#
class EMMDLGenericNASTransport(Layer3):
_GEN = tuple(EMMHeader(val={'Type':104})._content) + (
Uint8('GenericContType', dic=GenericContType_dict),
_GEN = (
EMMHeader(val={'Type':104}),
Type3V('GenericContType', val={'V':b'\0'}, bl={'V':8}, IE=GenericContType()),
Type6LVE('GenericContainer', val={'V':b'\0\0'}),
Type4TLV('AddInfo', val={'T':0x65, 'V':b'\0'})
)
@ -809,8 +896,9 @@ class EMMDLGenericNASTransport(Layer3):
#------------------------------------------------------------------------------#
class EMMULGenericNASTransport(Layer3):
_GEN = tuple(EMMHeader(val={'Type':105})._content) + (
Uint8('GenericContType', dic=GenericContType_dict),
_GEN = (
EMMHeader(val={'Type':105}),
Type3V('GenericContType', val={'V':b'\0'}, bl={'V':8}, IE=GenericContType()),
Type6LVE('GenericContainer', val={'V':b'\0\0'}),
Type4TLV('AddInfo', val={'T':0x65, 'V':b'\0'})
)
@ -822,9 +910,10 @@ class EMMULGenericNASTransport(Layer3):
#------------------------------------------------------------------------------#
class EMMCPServiceRequest(Layer3):
_GEN = tuple(EMMHeader(val={'Type':77})._content) + (
NAS_KSI(),
CPServiceType(),
_GEN = (
EMMHeader(val={'Type':77}),
Type1V('NAS_KSI', IE=NAS_KSI()),
Type1V('CPServiceType', IE=CPServiceType()),
Type6TLVE('ESMContainer', val={'T':0x78, 'V':b'\0'}),
Type4TLV('NASContainer', val={'T':0x67, 'V':b'\0\0'}),
Type4TLV('EPSBearerCtxtStat', val={'T':0x57, 'V':b'\0\0'}, IE=EPSBearerCtxtStat()),
@ -838,8 +927,9 @@ class EMMCPServiceRequest(Layer3):
#------------------------------------------------------------------------------#
class EMMServiceAccept(Layer3):
_GEN = tuple(EMMHeader(val={'Type':79})._content) + (
Type4TLV('EPSBearerCtxtStat', val={'T':0x57, 'V':b'\0\0'}, IE=EPSBearerCtxtStat()),
_GEN = (
EMMHeader(val={'Type':79}),
Type4TLV('EPSBearerCtxtStat', val={'T':0x57, 'V':b'\0\0'}, IE=EPSBearerCtxtStat())
)

153
pycrate_mobile/TS24301_ESM.py
View File

@ -27,6 +27,39 @@
# *--------------------------------------------------------
#*/
__all__ = [
'ESMActDediEPSBearerCtxtAccept',
'ESMActDediEPSBearerCtxtReject',
'ESMActDediEPSBearerCtxtRequest',
'ESMActDefaultEPSBearerCtxtAccept',
'ESMActDefaultEPSBearerCtxtReject',
'ESMActDefaultEPSBearerCtxtRequest',
'ESMBearerResourceAllocReject',
'ESMBearerResourceAllocRequest',
'ESMBearerResourceModifReject',
'ESMBearerResourceModifRequest',
'ESMDataTransport',
'ESMDeactEPSBearerCtxtAccept',
'ESMDeactEPSBearerCtxtRequest',
'ESMDummyMessage',
'ESMInformationRequest',
'ESMInformationResponse',
'ESMModifyEPSBearerCtxtAccept',
'ESMModifyEPSBearerCtxtReject',
'ESMModifyEPSBearerCtxtRequest',
'ESMNotification',
'ESMPDNConnectivityReject',
'ESMPDNConnectivityRequest',
'ESMPDNDisconnectReject',
'ESMPDNDisconnectRequest',
'ESMRemoteUEReport',
'ESMRemoteUEResponse',
'ESMStatus',
#
'ESMTypeClasses',
'get_esm_msg_instances'
]
#------------------------------------------------------------------------------#
# 3GPP TS 24.301: NAS protocol for EPS
# release 13 (da0)
@ -101,7 +134,8 @@ class ESMHeader(Envelope):
#------------------------------------------------------------------------------#
class ESMActDediEPSBearerCtxtAccept(Layer3):
_GEN = tuple(ESMHeader(val={'Type':198})._content) + (
_GEN = (
ESMHeader(val={'Type':198}),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'}),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
@ -114,8 +148,9 @@ class ESMActDediEPSBearerCtxtAccept(Layer3):
#------------------------------------------------------------------------------#
class ESMActDediEPSBearerCtxtReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':199})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':199}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'}),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
@ -128,12 +163,13 @@ class ESMActDediEPSBearerCtxtReject(Layer3):
#------------------------------------------------------------------------------#
class ESMActDediEPSBearerCtxtRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':197})._content) + (
_GEN = (
ESMHeader(val={'Type':197}),
Uint('spare', bl=4),
Uint('LinkedEPSBearerId', bl=4),
Type1V('LinkedEPSBearerId'),
Type4LV('EPSQoS', val={'V':b'\x09'}, IE=EPSQoS()),
Type4LV('TFT', val={'V':b'\0'}, IE=TFT()),
Type4TLV('TransId', val={'T':0x5D, 'V':b'\0'}, IE=TransId()),
Type4TLV('TI', val={'T':0x5D, 'V':b'\0'}, IE=TI()),
Type4TLV('QoS', val={'T':0x30, 'V':11*b'\0'}, IE=QoS()),
Type3TV('LLC_SAPI', val={'T':0x32, 'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type1TV('RadioPriority', val={'T':0x8, 'V':0}, IE=RadioPriority()),
@ -151,7 +187,8 @@ class ESMActDediEPSBearerCtxtRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMActDefaultEPSBearerCtxtAccept(Layer3):
_GEN = tuple(ESMHeader(val={'Type':194})._content) + (
_GEN = (
ESMHeader(val={'Type':194}),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
)
@ -163,8 +200,9 @@ class ESMActDefaultEPSBearerCtxtAccept(Layer3):
#------------------------------------------------------------------------------#
class ESMActDefaultEPSBearerCtxtReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':195})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':195}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
)
@ -176,11 +214,12 @@ class ESMActDefaultEPSBearerCtxtReject(Layer3):
#------------------------------------------------------------------------------#
class ESMActDefaultEPSBearerCtxtRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':193})._content) + (
_GEN = (
ESMHeader(val={'Type':193}),
Type4LV('EPSQoS', val={'V':b'\x09'}, IE=EPSQoS()),
Type4LV('APN', val={'V':b'\0'}, IE=APN()),
Type4LV('PDNAddr', val={'V':b'\x01\0\0\0\0',}, IE=PDNAddr()),
Type4TLV('TransId', val={'T':0x5D, 'V':b'\0'}, IE=TransId()),
Type4TLV('TI', val={'T':0x5D, 'V':b'\0'}, IE=TI()),
Type4TLV('QoS', val={'T':0x30, 'V':11*b'\0'}, IE=QoS()),
Type3TV('LLC_SAPI', val={'T':0x32, 'V':b'\0'}, bl={'V':8}, IE=LLC_SAPI()),
Type1TV('RadioPriority', val={'T':0x8, 'V':0}, IE=RadioPriority()),
@ -204,8 +243,9 @@ class ESMActDefaultEPSBearerCtxtRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMBearerResourceAllocReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':213})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':213}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd()),
@ -220,9 +260,10 @@ class ESMBearerResourceAllocReject(Layer3):
#------------------------------------------------------------------------------#
class ESMBearerResourceAllocRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':212})._content) + (
_GEN = (
ESMHeader(val={'Type':212}),
Uint('spare', bl=4),
Uint('LinkedEPSBearerId', bl=4),
Type1V('LinkedEPSBearerId'),
Type4LV('TFAggregate', val={'V':b'\0'}, IE=TFAggregate()),
Type4LV('EPSQoS', val={'V':b'\x09'}, IE=EPSQoS()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
@ -238,8 +279,9 @@ class ESMBearerResourceAllocRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMBearerResourceModifReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':215})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':215}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd()),
@ -254,9 +296,10 @@ class ESMBearerResourceModifReject(Layer3):
#------------------------------------------------------------------------------#
class ESMBearerResourceModifRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':214})._content) + (
_GEN = (
ESMHeader(val={'Type':214}),
Uint('spare', bl=4),
Uint('LinkedEPSBearerId', bl=4),
Type1V('LinkedEPSBearerId'),
Type4LV('TFAggregate', val={'V':b'\0'}, IE=TFAggregate()),
Type4TLV('EPSQoS', val={'T':0x5B, 'V':b'\x09'}, IE=EPSQoS()),
Type3TV('ESMCause', val={'T':0x58, 'V':b'\0'}, bl={'V':8}, IE=ESMCause()),
@ -274,7 +317,8 @@ class ESMBearerResourceModifRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMDeactEPSBearerCtxtAccept(Layer3):
_GEN = tuple(ESMHeader(val={'Type':206})._content) + (
_GEN = (
ESMHeader(val={'Type':206}),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
)
@ -286,8 +330,9 @@ class ESMDeactEPSBearerCtxtAccept(Layer3):
#------------------------------------------------------------------------------#
class ESMDeactEPSBearerCtxtRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':205})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':205}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type1TV('WLANOffloadInd', val={'T':0xC, 'V':0}, IE=WLANOffloadAccept()),
@ -302,7 +347,9 @@ class ESMDeactEPSBearerCtxtRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMDummyMessage(Layer3):
_GEN = tuple(ESMHeader(val={'Type':220})._content)
_GEN = (
ESMHeader(val={'Type':220}),
)
#------------------------------------------------------------------------------#
@ -311,7 +358,9 @@ class ESMDummyMessage(Layer3):
#------------------------------------------------------------------------------#
class ESMInformationRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':217})._content)
_GEN = (
ESMHeader(val={'Type':217}),
)
#------------------------------------------------------------------------------#
@ -320,10 +369,11 @@ class ESMInformationRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMInformationResponse(Layer3):
_GEN = tuple(ESMHeader(val={'Type':218})._content) + (
_GEN = (
ESMHeader(val={'Type':218}),
Type4TLV('APN', val={'T':0x28, 'V':b'\0'}, IE=APN()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'}),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
)
@ -333,8 +383,9 @@ class ESMInformationResponse(Layer3):
#------------------------------------------------------------------------------#
class ESMStatus(Layer3):
_GEN = tuple(ESMHeader(val={'Type':232})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':232}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause())
)
@ -344,7 +395,8 @@ class ESMStatus(Layer3):
#------------------------------------------------------------------------------#
class ESMModifyEPSBearerCtxtAccept(Layer3):
_GEN = tuple(ESMHeader(val={'Type':202})._content) + (
_GEN = (
ESMHeader(val={'Type':202}),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'}),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
@ -357,8 +409,9 @@ class ESMModifyEPSBearerCtxtAccept(Layer3):
#------------------------------------------------------------------------------#
class ESMModifyEPSBearerCtxtReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':203})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':203}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('NBIFOMContainer', val={'T':0x33, 'V':b'\0'}),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
@ -371,7 +424,8 @@ class ESMModifyEPSBearerCtxtReject(Layer3):
#------------------------------------------------------------------------------#
class ESMModifyEPSBearerCtxtRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':201})._content) + (
_GEN = (
ESMHeader(val={'Type':201}),
Type4TLV('EPSQoS', val={'T':0x5B, 'V':b'\x09'}, IE=EPSQoS()),
Type4TLV('TFT', val={'T':0x36, 'V':b'\0'}, IE=TFT()),
Type4TLV('QoS', val={'T':0x30, 'V':11*b'\0'}, IE=QoS()),
@ -393,7 +447,8 @@ class ESMModifyEPSBearerCtxtRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMNotification(Layer3):
_GEN = tuple(ESMHeader(val={'Type':219})._content) + (
_GEN = (
ESMHeader(val={'Type':219}),
Type4LV('NotificationInd', val={'V':b'\0'}, IE=NotificationInd()),
)
@ -404,8 +459,9 @@ class ESMNotification(Layer3):
#------------------------------------------------------------------------------#
class ESMPDNConnectivityReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':209})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':209}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type4TLV('BackOffTimer', val={'T':0x37, 'V':b'\0'}, IE=GPRSTimer3()),
Type4TLV('ReattemptInd', val={'T':0x6B, 'V':b'\0'}, IE=ReattemptInd()),
@ -420,9 +476,10 @@ class ESMPDNConnectivityReject(Layer3):
#------------------------------------------------------------------------------#
class ESMPDNConnectivityRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':208})._content) + (
Uint('PDNType', bl=4, dic=PDNType_dict),
Uint('RequestType', bl=4, dic=RequestType_dict),
_GEN = (
ESMHeader(val={'Type':208}),
Type1V('PDNType', dic=PDNType_dict),
Type1V('RequestType', dic=RequestType_dict),
Type1TV('ESMInfoTransferFlag', val={'T':0xD, 'V':0}, IE=ESMInfoTransferFlag()),
Type4TLV('APN', val={'T':0x28, 'V':b'\0'}, IE=APN()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
@ -439,8 +496,9 @@ class ESMPDNConnectivityRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMPDNDisconnectReject(Layer3):
_GEN = tuple(ESMHeader(val={'Type':211})._content) + (
ESMCause(),
_GEN = (
ESMHeader(val={'Type':211}),
Type3V('ESMCause', val={'V':b'\x6f'}, bl={'V':8}, IE=ESMCause()),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
)
@ -453,9 +511,10 @@ class ESMPDNDisconnectReject(Layer3):
#------------------------------------------------------------------------------#
class ESMPDNDisconnectRequest(Layer3):
_GEN = tuple(ESMHeader(val={'Type':210})._content) + (
_GEN = (
ESMHeader(val={'Type':210}),
Uint('spare', bl=4),
Uint('LinkedEPSBearerId', bl=4),
Type1V('LinkedEPSBearerId'),
Type4TLV('ProtConfig', val={'T':0x27, 'V':b'\x80'}, IE=ProtConfig()),
Type6TLVE('ExtProtConfig', val={'T':0x7B, 'V':b'\0'})
)
@ -467,7 +526,8 @@ class ESMPDNDisconnectRequest(Layer3):
#------------------------------------------------------------------------------#
class ESMRemoteUEReport(Layer3):
_GEN = tuple(ESMHeader(val={'Type':233})._content) + (
_GEN = (
ESMHeader(val={'Type':233}),
Type6TLVE('RemoteUEConnected', val={'T':0x79, 'V':b''}, IE=RemoteUECtxtList()),
Type6TLVE('RemoteUEDisconnected', val={'T':0x7A, 'V':b''}, IE=RemoteUECtxtList()),
Type4TLV('PKMFAddr', val={'T':0x6F, 'V':b'\0'}, IE=PKMFAddr())
@ -480,7 +540,9 @@ class ESMRemoteUEReport(Layer3):
#------------------------------------------------------------------------------#
class ESMRemoteUEResponse(Layer3):
_GEN = tuple(ESMHeader(val={'Type':234})._content)
_GEN = (
ESMHeader(val={'Type':234}),
)
#------------------------------------------------------------------------------#
@ -489,7 +551,8 @@ class ESMRemoteUEResponse(Layer3):
#------------------------------------------------------------------------------#
class ESMDataTransport(Layer3):
_GEN = tuple(ESMHeader(val={'Type':235})._content) + (
_GEN = (
ESMHeader(val={'Type':235}),
Type6LVE('UserData', val={'V':b''}),
Type1TV('ReleaseAssistInd', val={'T':0xD, 'V':0}, IE=ReleaseAssistInd())
)

19
pycrate_mobile/TS24301_IE.py
View File

@ -230,7 +230,7 @@ class EPSDetachTypeMO(Envelope):
class EPSDetachTypeMT(Envelope):
_GEN = (
Uint('SwitchOff', bl=1),
Uint('spare', bl=1),
Uint('Type', bl=3, dic=_EPSDetTypeMT_dict)
)
@ -288,7 +288,7 @@ class EMMCause(Uint8):
# TS 24.301, 9.9.3.10
#------------------------------------------------------------------------------#
_EPSAttRes_dict = {
EPSAttRes_dict = {
1 : 'EPS only',
2 : 'combined EPS / IMSI attach'
}
@ -296,7 +296,7 @@ _EPSAttRes_dict = {
class EPSAttachResult(Envelope):
_GEN = (
Uint('spare', bl=1),
Uint('Value', bl=3, dic=_EPSAttRes_dict)
Uint('Value', bl=3, dic=EPSAttRes_dict)
)
@ -305,7 +305,7 @@ class EPSAttachResult(Envelope):
# TS 24.301, 9.9.3.11
#------------------------------------------------------------------------------#
_EPSAttType_dict = {
EPSAttType_dict = {
1 : 'EPS Attach',
2 : 'combined EPS / IMSI attach',
6 : 'EPS emergency attach',
@ -315,7 +315,7 @@ _EPSAttType_dict = {
class EPSAttachType(Envelope):
_GEN = (
Uint('spare', bl=1),
Uint('Value', bl=3, dic=_EPSAttType_dict)
Uint('Value', bl=3, dic=EPSAttType_dict)
)
@ -526,7 +526,7 @@ class EPSNetFeat(Envelope):
# TS 24.301, 9.9.3.13
#------------------------------------------------------------------------------#
_EPSUpdRes_dict = {
EPSUpdRes_dict = {
0 : 'TA updated',
1 : 'combined TA/LA updated',
4 : 'TA updated and ISR activated',
@ -536,7 +536,7 @@ _EPSUpdRes_dict = {
class EPSUpdateResult(Envelope):
_GEN = (
Uint('spare', bl=1),
Uint('Value', bl=3, dic=_EPSUpdRes_dict)
Uint('Value', bl=3, dic=EPSUpdRes_dict)
)
@ -1126,11 +1126,14 @@ else:
# TS 24.301, 9.9.3.42
#------------------------------------------------------------------------------#
GenericContType_dict = {
_GenericContType_dict = {
1 : 'LTE Positioning Protocol (LPP) message container',
2 : 'Location services message container'
}
class GenericContType(Uint8):
_dic = _GenericContType_dict
#------------------------------------------------------------------------------#
# GUTI type

5
pycrate_mobile/TS44018_RR.py
View File

@ -270,9 +270,10 @@ class RRHeader(Envelope):
#------------------------------------------------------------------------------#
class RRPagingResponse(Envelope):
_GEN = tuple(RRHeader(val={'Type':39})._content) + (
_GEN = (
RRHeader(val={'Type':39}),
Uint('spare', bl=4),
Uint('CKSN', bl=4, dic=CKSN_dict),
Type1V('CKSN', dic=CKSN_dict),
Type4LV('MSCm2', val={'V':b'@\x00\x00'}, IE=MSCm2()),
Type4LV('ID', val={'V':b'\xf4\0\0\0\0'}, IE=ID()),
Type1TV('AddUpdateParams', val={'T':0xC, 'V':0}, IE=AddUpdateParams())