def LocalRequest(self):
"""Local request will trigger the session to send a ICRQ to remote,
currently, this function is just for simulator usage.
:return: None
"""
self.logger.debug(
"Got a local request to setup the session, will send a ICRQ to remote"
)
if isinstance(self.fsm, L2tpv3Fsm.L2tpv3SessionRecipientFsm):
self.logger.warn(
"Recipient does not support the local request, do nothing.")
return
if self.fsm.current == L2tpv3Fsm.L2tpv3SessionSenderFsm.StateIdle:
msgAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.ICRQ)
localSessionId = L2tpv3RFC3931AVPs.LocalSessionID(
self.localSessionId)
remoteSessionId = L2tpv3RFC3931AVPs.RemoteSessionID(
self.remoteSessionId)
remote_end_id = L2tpv3RFC3931AVPs.RemoteEndID(
(((0, 3, 0), 0), ((0, 3, 1), 1)))
DepiL2SpecificSublayerSubtype = L2tpv3CableLabsAvps.DepiL2SpecificSublayerSubtype(
3)
icrq = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.connection.remoteConnID,
avps=(msgAvp, localSessionId, remoteSessionId, remote_end_id,
DepiL2SpecificSublayerSubtype))
self.connection.transport.SendPacket(icrq)
self.fsm.localRequest()
def __init__(self, session, resultCode, errCode, errMsg):
connection = session.connection
super(
L2tpv3CDN, self).__init__(L2tpv3RFC3931AVPs.ControlMessageAVP.CDN, connection.remoteConnID,
resultCode, errCode, errMsg)
localSessionID = session.localSessionId
remoteSessionID = session.remoteSessionId
localAvp = L2tpv3RFC3931AVPs.LocalSessionID(localSessionID)
remoteAvp = L2tpv3RFC3931AVPs.RemoteSessionID(remoteSessionID)
self.avps.append(localAvp)
self.avps.append(remoteAvp)
def localRequest(self, addr):
# send a SCCRQ to remote
msgAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.SCCRQ)
assignedAvp = L2tpv3RFC3931AVPs.AssignedControlConnectionID(
self.localConnID)
sccrq = L2tpv3ControlPacket.L2tpv3ControlPacket(0,
avps=(msgAvp,
assignedAvp))
self.transport.SendPacket(sccrq, (addr, 0))
self.fsm.localRequest()
def setUpClass(cls):
# open logger
setup_logging("L2TP")
setup_test_redis()
cls.conn_address = '127.0.0.1'
global_dispatcher = Dispatcher()
dispatcher = L2tpv3Dispatcher(
global_dispatcher, cls.conn_address, False, None)
L2tpv3GlobalSettings.Dispatcher = dispatcher
# setup the halclient
notification_list = list()
notification_list.append(
HalConfigMsg.MsgTypeL2tpv3SessionStatusNotification)
cls.hal_client = L2tpHalClient("L2TP_HAL_CLIENT",
"the HAL client of L2TP feature",
"1.0", tuple(L2tpHalClient.notification_list.keys()), global_dispatcher)
cls.hal_client.handler = dispatcher.receive_hal_message
cls.conn = L2tpConnection(
6661, 6662, cls.conn_address, cls.conn_address)
cls.session = L2tpv3Session(6661, 6662, 'receiver', cls.conn)
cls.conn.addSession(cls.session)
localSessionId = L2tpv3RFC3931AVPs.LocalSessionID(6661)
remoteSessionId = L2tpv3RFC3931AVPs.RemoteSessionID(6662)
remoteEnd = L2tpv3RFC3931AVPs.RemoteEndID(
(((0, 3, 0), 0), ((0, 3, 1), 1), ((0, 3, 2), 2)))
remoteEnd_1 = L2tpv3RFC3931AVPs.RemoteEndID(
(((0, 3, 3), 3), ((0, 3, 4), 4), ((0, 3, 5), 5)))
pw_type = L2tpv3RFC3931AVPs.L2SpecificSublayer(3)
DepiL2SpecificSublayerSubtype = L2tpv3CableLabsAvps.DepiL2SpecificSublayerSubtype(3)
LocalMTUCableLabs = L2tpv3CableLabsAvps.LocalMTUCableLabs(1500)
DepiRemoteMulticastJoin = L2tpv3CableLabsAvps.DepiRemoteMulticastJoin(("5.5.5.1", "229.1.1.255"))
DepiResourceAllocReq = L2tpv3CableLabsAvps.DepiResourceAllocReq(((0, 1), (1, 2)))
UpstreamFlow = L2tpv3CableLabsAvps.UpstreamFlow(((0, 1), (1, 2)))
cls.session.avps_icrq.append(localSessionId)
cls.session.avps_icrq.append(remoteSessionId)
cls.session.avps_icrq.append(remoteEnd)
cls.session.avps_icrq.append(remoteEnd_1)
cls.session.avps_icrq.append(DepiL2SpecificSublayerSubtype)
cls.session.avps_icrq.append(LocalMTUCableLabs)
cls.session.avps_icrq.append(pw_type)
cls.session.avps_icrq.append(DepiRemoteMulticastJoin)
cls.session.avps_icrq.append(DepiResourceAllocReq)
cls.session.avps_icrq.append(UpstreamFlow)
def recvSCCRQ(self, pkt):
"""Receive SCCRQ."""
if L2tpv3GlobalSettings.L2tpv3GlobalSettings.MustAvpsCheck is True:
ret = self.checkMustAvps(
L2tpv3ControlPacket.L2tpv3ControlPacket.SCCRQMandatoryAVPs,
pkt.avps)
if ret is not True:
self.fsm.recvBadSCCRQ()
return L2tpv3ControlPacket.L2tpv3StopCCN(
self, 2, 4, "Avp cannot handled correctly")
sccrpAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.SCCRP)
recvWinSize = ReceiveWinSize(
L2tpv3GlobalSettings.L2tpv3GlobalSettings.ReceiveWindowSize)
sccrp = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.remoteConnID, 0, 0, (sccrpAvp, recvWinSize))
if len(pkt.avps) > 1:
for i in xrange(1, len(pkt.avps)):
avp = pkt.avps[i]
# We got a bad SCCRQ, we should send a CDN
if not avp.handleAvp(pkt, sccrp):
self.fsm.recvBadSCCRQ()
return L2tpv3ControlPacket.L2tpv3StopCCN(
self, 2, 4, "Avp cannot handled correctly")
self.fsm.recvGoodSCCRQ()
return sccrp
def __init__(self, connection, resultCode, errCode, errMsg):
super(
L2tpv3StopCCN, self).__init__(L2tpv3RFC3931AVPs.ControlMessageAVP.StopCCN, connection.remoteConnID,
resultCode, errCode, errMsg)
assignedConnectionAvp = L2tpv3RFC3931AVPs.AssignedControlConnectionID(
connection.localConnID)
self.avps.append(assignedConnectionAvp)
def recvFSQ(self, pkt):
"""Receive a FSQ packet.
:param pkt: Decoded control packet.
:return: FSR.
"""
self.logger.debug("Receive a FSQ message from remote")
if L2tpv3GlobalSettings.L2tpv3GlobalSettings.MustAvpsCheck is True:
ret = self.checkMustAvps(
L2tpv3ControlPacket.L2tpv3ControlPacket.FSQMandatoryAVPs,
pkt.avps)
if ret is not True:
return
fsrAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.FSR)
fsr = L2tpv3ControlPacket.L2tpv3ControlPacket(self.remoteConnID, 0, 0,
(fsrAvp, ))
if len(pkt.avps) > 1:
for i in xrange(1, len(pkt.avps)):
avp = pkt.avps[i]
avp.handleAvp(pkt, fsr)
return fsr
def test_append_VspAvp(self):
print "test_append_VspAvp\n"
vsp_avp_attrType1 = 10
vsp_avp_attrType2 = 20
vsp_avp1 = l2tpv3SampleVendorAvp(DEFAULT_VENDOR_ID,
vsp_avp_attrType1,
attrValue="11111111111")
vsp_avp2 = l2tpv3SampleVendorAvp(DEFAULT_VENDOR_ID,
vsp_avp_attrType2,
notifyVendor=1,
attrValue="222222222222")
# vsp_avp3 has OutCtrlPktList set to L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP, and it will be
# appended to the avps list, and vsp_avp1 will not.
ctrlIdsList = []
ctrlIdsList.append(L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP)
vsp_avp_attrType3 = 30
vsp_avp3_attrValue = "3333333333"
vsp_avp3 = l2tpv3SampleVendorAvp(DEFAULT_VENDOR_ID,
vsp_avp_attrType3,
OutCtrlIds=ctrlIdsList,
attrValue=vsp_avp3_attrValue)
vsp_avps = l2tpv3VspAvps()
self.assertTrue(vsp_avps is not None)
vsp_avps.add_VspAvp(vsp_avp1)
vsp_avps.add_VspAvp(vsp_avp2)
vsp_avps.add_VspAvp(vsp_avp3)
avps = list()
avps.append(
L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP))
avps.append(
L2tpv3RFC3931AVPs.SbfdVccv(L2tpv3RFC3931AVPs.SbfdVccv.VccvValue))
vsp_avps.append_VspAvp(avps, L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP)
# vsp_avp3 should be in avps list now
found_vsp_avp_in_icrp = 0
for avp in avps:
if (isinstance(avp, l2tpv3SampleVendorAvp)
and avp.attrValue == vsp_avp3_attrValue):
found_vsp_avp_in_icrp = 1
self.assertEqual(found_vsp_avp_in_icrp, 1)
def sendSLI(self):
if self.fsm.current == L2tpv3Fsm.L2tpv3SessionRecipientFsm.StateEstablished and\
self.connection and self.connection.transport:
msgAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.SLI)
localSessionId = L2tpv3RFC3931AVPs.LocalSessionID(
self.localSessionId)
remoteSessionId = L2tpv3RFC3931AVPs.RemoteSessionID(
self.remoteSessionId)
circuitstatus = L2tpv3RFC3931AVPs.CircuitStatus(
active=self.local_circuit_status, new=False)
sli = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.connection.remoteConnID,
avps=(msgAvp, localSessionId, remoteSessionId, circuitstatus))
self.connection.transport.SendPacket(sli)
self.logger.info("send SLI status change to remote: " + "local:" +
str(self.localSessionId) + " remote:" +
str(self.remoteSessionId) + " status:" +
str(self.local_circuit_status))
def test_handleAvp(self):
vsp_avp_attrType1 = 10
vsp_avp_attrType2 = 20
vsp_avp1 = l2tpv3SampleVendorAvp(DEFAULT_VENDOR_ID,
vsp_avp_attrType1,
attrValue="11111111111")
vsp_avp2 = l2tpv3SampleVendorAvp(DEFAULT_VENDOR_ID,
vsp_avp_attrType2,
notifyVendor=1,
attrValue="222222222222")
ctrlIdsList = []
ctrlIdsList.append(L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP)
vsp_avp_attrType3 = 30
vsp_avp3_attrValue = "3333333333"
vsp_avp3 = l2tpv3SampleVendorAvp(DEFAULT_VENDOR_ID,
vsp_avp_attrType3,
OutCtrlIds=ctrlIdsList,
attrValue=vsp_avp3_attrValue)
# Receive a good ICRQ, send a ICRP
session_receiver = L2tpv3Session(0, 1, 'receiver')
icrq = L2tpv3ControlPacket.decode(self.icrq_buf)
# append couple VSP AVP
icrq.avps.append(vsp_avp1)
icrq.avps.append(vsp_avp2)
icrq.avps.append(vsp_avp3)
# print icrq
# icrq.SetPktConnection(self.conn)
# icrq.SetPktSession(session_receiver)
#icrp = session_receiver.ReceiveICRQ(icrq)
# Observe that only vsp_avp3 is appended to icrp
# self.assertEqual(
# session_receiver.fsm.current, L2tpv3SessionRecipientFsm.StateWaitConn)
#self.assertEqual(icrp.avps[0].messageType, ControlMessageAVP.ICRP)
avps = list()
avps.append(
L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP))
icrp = L2tpv3ControlPacket(6600, 0, 0, avps)
for avp in icrq.avps:
avp.handleAvp(icrq, icrp)
# vsp_avp3 has non-None OutCtrlIds so it should be moved from icrq to icrp now
found_vsp_avp_in_icrp = 0
for avp in icrp.avps:
if (isinstance(avp, l2tpv3SampleVendorAvp)
and avp.attrValue == vsp_avp3_attrValue):
found_vsp_avp_in_icrp = 1
self.assertEqual(found_vsp_avp_in_icrp, 1)
def queryInactSessions(self):
inActiveSessions = list()
keys = self.sessions.keys()
for sessionId in keys:
session = self.sessions[sessionId]
if session.local_circuit_status != L2tpv3Session.L2tpv3Session.CIRCUIT_STATUS_UP:
self.logger.debug(
"query for inactive session [%d, %d]" %
(session.localSessionId, session.remoteSessionId))
inActiveSessions.append(session)
if inActiveSessions:
fsqAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.FSQ)
fssAvps = tuple()
for ses in inActiveSessions:
fss = L2tpv3RFC3931AVPs.FailoverSessionState(
ses.localSessionId, ses.remoteSessionId)
fssAvps = fssAvps + (fss, )
fsq = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.remoteConnID, 0, 0, (fsqAvp, ) + fssAvps)
self.transport.SendPacket(fsq)
def queryStaleSessions(self):
staleSessions = list()
keys = self.sessions.keys()
for sessionId in keys:
session = self.sessions[sessionId]
if session.stale:
self.logger.debug(
"query for stale session [%d, %d]" %
(session.localSessionId, session.remoteSessionId))
staleSessions.append(session)
if staleSessions:
fsqAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.FSQ)
fssAvps = tuple()
for ses in staleSessions:
fss = L2tpv3RFC3931AVPs.FailoverSessionState(
ses.localSessionId, ses.remoteSessionId)
fssAvps = fssAvps + (fss, )
fsq = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.remoteConnID, 0, 0, (fsqAvp, ) + fssAvps)
self.transport.SendPacket(fsq)
def recvSCCRP(self, pkt):
"""On openRPD, we will behave as an recipient, so we will not receive
SCCRP in normal case.
:param pkt:
:return:
"""
self.logger.debug("Receive a SCCRP packet")
if L2tpv3GlobalSettings.L2tpv3GlobalSettings.MustAvpsCheck is True:
ret = self.checkMustAvps(
L2tpv3ControlPacket.L2tpv3ControlPacket.SCCRPMandatoryAVPs,
pkt.avps)
if ret is not True:
self.fsm.recvBadSCCRP()
return L2tpv3ControlPacket.L2tpv3StopCCN(
self, 2, 4, "Avp cannot handled correctly")
# Get the localAssignedID from the SCCRP
remoteConnID = 0
for avp in pkt.avps:
if isinstance(avp, L2tpv3RFC3931AVPs.AssignedControlConnectionID):
remoteConnID = avp.connectionID
self.remoteConnID = remoteConnID
scccnAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.SCCCN)
scccn = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.remoteConnID, 0, 0, (scccnAvp, ))
if len(pkt.avps) > 1:
for i in xrange(1, len(pkt.avps)):
avp = pkt.avps[i]
# We got a bad ICRQ, we should send a CDN
if not avp.handleAvp(pkt, scccn):
self.fsm.recvBadSCCRP()
return L2tpv3ControlPacket.L2tpv3StopCCN(
self, 2, 4, "Avp cannot handled correctly")
self.fsm.recvGoodSCCRP()
return scccn
def __init__(self, connID):
helloavp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.HELLO)
super(L2tpv3Hello, self).__init__(
remoteConnID=connID, avps=(helloavp,))
def setUpClass(cls):
setupDB()
time.sleep(2)
HalGlobal.gClientMgr = None
HalGlobal.gPoller = None
t = threading.Thread(target=demoHalmain)
t.daemon = True
t.start()
time.sleep(2)
threads_list.append(t)
if not HalGlobal.gClientMgr or not HalGlobal.gPoller:
raise Exception("Cannot start the demo halMain")
t = threading.Thread(target=demoL2tp)
t.daemon = True
t.start()
time.sleep(2)
threads_list.append(t)
t = threading.Thread(target=demoDrvmain)
t.daemon = True
t.start()
threads_list.append(t)
time.sleep(2)
setup_logging('HAL', filename="hal.log", logging_level=logging.DEBUG)
cls.logger = logging.getLogger("L2tpHalDrvVspAvpTest")
cls.logger.info("hello L2tpHalDrvVspAvpTest Log")
cls.stop = False
cls.conn_address = '127.0.0.1'
# Setup connection/session: set it here since global variables are already only after threads are up.
cls.dispatcher = L2tpv3GlobalSettings.Dispatcher
cls.hal_client = L2tpv3GlobalSettings.l2tp_hal_client
# cls.conn = L2tpConnection.L2tpConnection(
# 6661, 6662, cls.conn_address, cls.conn_address)
#cls.session = L2tpv3Session.L2tpv3Session(6661, 6662, 'receiver',cls.conn)
# cls.conn.addSession(cls.session)
localSessionId = L2tpv3RFC3931AVPs.LocalSessionID(6661)
remoteSessionId = L2tpv3RFC3931AVPs.RemoteSessionID(6662)
remoteEnd = L2tpv3RFC3931AVPs.RemoteEndID(
(((0, 3, 0), 0), ((0, 3, 1), 1), ((0, 3, 2), 2)))
remoteEnd_1 = L2tpv3RFC3931AVPs.RemoteEndID(
(((0, 3, 3), 3), ((0, 3, 4), 4), ((0, 3, 5), 5)))
pw_type = L2tpv3RFC3931AVPs.L2SpecificSublayer(3)
DepiL2SpecificSublayerSubtype = L2tpv3CableLabsAvps.DepiL2SpecificSublayerSubtype(
3)
LocalMTUCableLabs = L2tpv3CableLabsAvps.LocalMTUCableLabs(1500)
cls.avps_icrq = []
cls.avps_icrq.append(localSessionId)
cls.avps_icrq.append(remoteSessionId)
cls.avps_icrq.append(remoteEnd)
cls.avps_icrq.append(remoteEnd_1)
cls.avps_icrq.append(DepiL2SpecificSublayerSubtype)
cls.avps_icrq.append(LocalMTUCableLabs)
cls.avps_icrq.append(pw_type)
cls.icrq_buf = struct.pack(
'!206B',
0xc8,
0x03,
0x0,
206,
0x0,
0x0,
0x0,
0x0,
0x0,
0x3,
0x0,
0x4,
0xc,
8,
0x0,
0x0,
0x0,
0x0,
0x0,
10,
0xc,
10,
0x0,
0x0,
0,
15,
0,
0,
0,
0,
0xc,
10,
0x0,
0x0,
0,
63,
0x40,
0x01,
0x00,
0x01,
0xc,
10,
0x0,
0x0,
0,
64,
0x0,
0x0,
0x0,
0x0,
0xc,
40,
0x0,
0x0,
0x0,
66,
0x0,
0x0,
0x00,
0x03,
0x00,
0x00,
0x00,
0x03,
0x01,
0x01,
0x00,
0x03,
0x02,
0x02,
0x00,
0x03,
0x03,
0x03,
0x00,
0x03,
0x04,
0x04,
0x00,
0x03,
0x05,
0x05,
0x00,
0x03,
0x06,
0x06,
0x00,
0x03,
0x07,
0x07,
0xc,
8,
0,
0,
0,
68,
0,
12,
0xc,
8,
0,
0,
0,
69,
0,
3,
0xc,
8,
0,
0,
0,
71,
0,
2,
0xc,
8,
0x11,
0x8b,
0x0,
0x2,
0x1,
0x0,
0xc,
8,
0x11,
0x8b,
0x0,
0x4,
0x7,
0xD0,
0xc,
20,
0x11,
0x8b,
0x0,
15,
0x0,
0x1,
0x0,
0x2,
0x0,
0x3,
0x0,
0x6,
0x0,
0x8,
0x0,
11,
0x0,
13,
0xc,
8,
0x11,
0x8b,
0x0,
16,
0x0,
0x3,
0xc,
8,
0x11,
0x8b,
0x0,
17,
0x0,
0x3,
0xc,
40,
0x11,
0x8b,
0x0,
11,
0,
0,
0x5,
0x6,
0x7,
0x8,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
229,
1,
1,
255,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
)
sessionID = avp.sessionID
break
iccn.ns = 3
iccn.nr = 2
iccn.connectionID = conntionID
for avp in iccn.avps:
if isinstance(avp, L2tpv3RFC3931AVPs.RemoteSessionID):
avp.sessionID = sessionID
# Change the AVPs
print iccn
buf = iccn.encode(True)
s.sendto(buf, ('127.0.0.1', 1))
cdnMsg = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.CDN)
retcode = L2tpv3RFC3931AVPs.ResultCode(
L2tpv3RFC3931AVPs.ControlMessageAVP.StopCCN, 0, 0, "test")
# Get the lcoal session ID
localAvp = None
for avp in iccn.avps:
if isinstance(avp, L2tpv3RFC3931AVPs.LocalSessionID):
lcoalSessionID = avp.sessionID
localAvp = L2tpv3RFC3931AVPs.LocalSessionID(lcoalSessionID)
remoteAvp = L2tpv3RFC3931AVPs.RemoteSessionID(sessionID)
cdn = L2tpv3ControlPacket.L2tpv3ControlPacket(conntionID,
avps=(cdnMsg, retcode, localAvp,
remoteAvp))
cdn.ns = 4
cdn.nr = 2
def ReceiveICRQ(self, pkt):
"""Receive a ICRQ from remote, if it is a good ICRQ, will send a ICRP.
:param pkt: The ICRQ control packet, has been decoded.
:return: ICRP packet or None
"""
if L2tpv3GlobalSettings.L2tpv3GlobalSettings.MustAvpsCheck is True:
ret = self.connection.checkMustAvps(
L2tpv3ControlPacket.L2tpv3ControlPacket.ICRQMandatoryAVPs,
pkt.avps)
if ret is not True:
self.fsm.recvBadICRQ()
return L2tpv3ControlPacket.L2tpv3CDN(
self, 2, 4, "Avp cannot be handled correctly")
self.logger.debug("L2tp session[%d, %d] receives a ICRQ message.",
self.localSessionId, self.remoteSessionId)
avps = list()
avps.append(
L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.ICRP))
avps.append(
L2tpv3RFC3931AVPs.DataSequencing(
L2tpv3RFC3931AVPs.DataSequencing.AllSeq))
# TODO add sbfd support for ipv6
if Convert.is_valid_ipv4_address(self.connection.localAddr):
avps.append(
L2tpv3RFC3931AVPs.SbfdDiscriminator(
int(
socket.inet_aton(
self.connection.localAddr).encode('hex'), 16)))
avps.append(
L2tpv3RFC3931AVPs.SbfdVccv(
L2tpv3RFC3931AVPs.SbfdVccv.VccvValue))
# Need add some Cable labs avp
self.logger.debug(
"Session [%d, %d]sends a ICRP packet to remote, connection:%d",
self.localSessionId, self.remoteSessionId,
pkt.Connection.remoteConnID)
icrp = L2tpv3ControlPacket.L2tpv3ControlPacket(
pkt.Connection.remoteConnID, 0, 0, avps)
del self.avps_icrq[:]
del self.mcast[:]
if len(pkt.avps) > 1:
for i in xrange(1, len(pkt.avps)):
avp = pkt.avps[i]
if isinstance(
avp,
L2tpv3CableLabsAvps.DepiL2SpecificSublayerSubtype):
self.session_l2Sublayer = avp.pw_type
self.avps_icrq.append(avp)
# We got a bad ICRQ, we should send a CDN
if not avp.handleAvp(pkt, icrp):
self.fsm.recvBadICRQ()
return L2tpv3ControlPacket.L2tpv3CDN(
self, 2, 4, "Avp cannot be handled correctly")
self.logger.debug("We got a good ICRQ, send to fsm")
self.fsm.recvGoodICRQ()
return icrp
def ReceiveICRP(self, pkt):
"""Receive a ICRP from remote, if it is a good ICRP, will send a ICCN.
this function will be used for simulator purpose.
:param pkt: The ICRP control packet, has been decoded.
:return:
"""
if L2tpv3GlobalSettings.L2tpv3GlobalSettings.MustAvpsCheck is True:
ret = self.connection.checkMustAvps(
L2tpv3ControlPacket.L2tpv3ControlPacket.ICRPMandatoryAVPs,
pkt.avps)
if ret is not True:
if isinstance(self.fsm, L2tpv3Fsm.L2tpv3SessionSenderFsm):
self.fsm.recvBadICRP()
return L2tpv3ControlPacket.L2tpv3CDN(
self, 2, 4, "Avp cannot be handled correctly")
self.logger.debug("Session [%d, %d] gets a l2tp ICRP message.",
self.localSessionId, self.remoteSessionId)
if isinstance(self.fsm, L2tpv3Fsm.L2tpv3SessionRecipientFsm):
self.logger.debug(
"Recipient session [%d, %d] gets a l2tp ICRP message.",
self.localSessionId, self.remoteSessionId)
self.fsm.recvICRP()
# this event will trigger the recipient state
# machine transferring to idle state.
return
# Find the local session ID
for avp in pkt.avps:
if isinstance(avp, L2tpv3RFC3931AVPs.LocalSessionID):
self.remoteSessionId = avp.sessionID
self.connection.addSession(self)
# If the incoming l2TP ICRP does not contain a local session ID
if not self.remoteSessionId:
self.logger.warn(
"Session[%d, %d] is terminated due to not find the local session ID in ICRP message.",
self.localSessionId, self.remoteSessionId)
self.fsm.recvBadICRP()
return L2tpv3ControlPacket.L2tpv3CDN(self, 2, 5, "")
# send a ICCN
msgAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.ICCN)
iccn = L2tpv3ControlPacket.L2tpv3ControlPacket(
self.connection.remoteConnID, avps=(msgAvp, ))
if len(pkt.avps) > 1:
for i in xrange(1, len(pkt.avps)):
avp = pkt.avps[i]
# We got a bad ICRP, we should send a CDN
if not avp.handleAvp(pkt, iccn):
self.fsm.recvBadICRP()
return L2tpv3ControlPacket.L2tpv3CDN(
self, 2, 4, "Avp cannot be handled correctly")
self.logger.debug(
"Sender session [%d, %d] gets a good l2tp ICRP message.",
self.localSessionId, self.remoteSessionId)
self.fsm.recvGoodICRP()
return iccn
def __init__(self, connID):
ackavp = L2tpv3RFC3931AVPs.ControlMessageAVP(
L2tpv3RFC3931AVPs.ControlMessageAVP.ACK)
super(L2tpv3ACK, self).__init__(
remoteConnID=connID, avps=(ackavp,))
self.isZlb = True
def __init__(self, msgType, connID, resultCode, errCode, errMsg):
stopAvp = L2tpv3RFC3931AVPs.ControlMessageAVP(msgType)
retcode = L2tpv3RFC3931AVPs.ResultCode(
L2tpv3RFC3931AVPs.ControlMessageAVP.StopCCN, resultCode, errCode, errMsg)
super(l2tpV3TerminatePkt, self).__init__(
remoteConnID=connID, avps=(stopAvp, retcode))
