def sendAndReceiveOF_HELLO_OPENFLOWV1(self):
count = 0
# create OF_HEllO message
packed_data = Hello().pack()
while count < self.numberOfRetransmission:
try:
# send OF_HEllO message to contoller
self.s.send(packed_data)
print("Switch ip " + self.switchIp +
" Send OF_HELLO message to controller")
# receive OF_HELLO message from controller
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
if data.header.message_type.name == "OFPT_HELLO":
print("Switch ip " + self.switchIp +
" Receive OF_HELLO message from controller")
return
except Exception as err:
count += 1
print(" 322 Switch ip " + self.switchIp +
" handling run-time error of socket : " + str(err))
print(" Switch ip " + self.switchIp + " terminate")
sys.exit()
def sendAndReceiveOF_FEATURE_OPENFLOWV1(self):
try :
# receive OF_FEATURE_REQUEST message
data = self.receiveDataFromSocket()
print( " 332 Switch ip " + self.switchIp + " Receive OF_FEATURE_REQUEST message from controller")
data = unpack_message(data)
if data.header.message_type.name != "OFPT_FEATURES_REQUEST" :
print( " 336 Switch ip " + self.switchIp + " terminate because switch don't receive OF_FEATURES_REQUEST" )
sys.exit()
# get tranID from OF_FEATURE_REQUEST message
tranID = data.header.xid
#send OF_FEATURE_REPLY message
listPort = self.getActivePortFromSnmpVersion2C( 0 )
print("All active port of switch ip " + self.switchIp + " : ")
for i in listPort:
print("Hw_addr : " + i.hw_addr)
print("Hw_desc : " + i.name)
# find max value of mac address from list mac address
maxPort = "000000000000"
maxIndex = 0
for index , item in enumerate( listPort ):
tempMac = item.hw_addr.replace(":","")
if ( int( tempMac , 16 ) > int( maxPort , 16 ) ):
maxPort = tempMac
maxIndex = index
# create OF_FEATURE_REPLY message
packed_data = FeaRes()
packed_data.header.xid = tranID
# gen datapath_id from hw_addr of first port
packed_data.datapath_id = listPort[maxIndex].hw_addr + ":ff:ff"
#packed_data.datapath_id = '00:00:00:00:00:00:00:02'
packed_data.n_buffers = 256
packed_data.n_tables = 254
packed_data.capabilities = 199
packed_data.actions = 4095
# create port
#port1 = PPort(1, '00:00:00:00:00:02','eth1', 0, 0, 192 ,0,0,0)
#packed_data.ports = [port1]
packed_data.ports = listPort
packed_data = packed_data.pack()
# send OF_FEATURE_REPLY message
self.s.send(packed_data)
print("Send OF_FEATURE_REPLY message to controller")
except Exception as err :
print( " 387 Switch ip " + self.switchIp + " terminate because handling run-time error : " + str( err ) )
sys.exit()
def openflowV1(self):
# OF_HELLO switch <-> controller
self.sendAndReceiveOF_HELLO_OPENFLOWV1()
# OF_FEATURE switch <-> controller
self.sendAndReceiveOF_FEATURE_OPENFLOWV1()
return
"""
port = PPort(100, "ff:ff:ff:ff:ff:00" , "test", 0, 0, 192 ,0,0,0)
port.port_no = 200
print( "add port : " + str(port.port_no))
packed_data = portStatus( reason=portReason.OFPPR_ADD , desc=port )
packed_data = packed_data.pack()
self.s.send( packed_data )
"""
# init value
data = None
while(1):
count = 0
# receive OF_PACKET_OUT message
while count < self.numberOfRetransmission :
try:
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
break
except Exception as err:
count += 1
print( " 431 Switch ip " + self.switchIp + " handling run-time error of socket : " + str( err ) )
if count == self.numberOfRetransmission :
print( " 443 Switch ip " + self.switchIp + " socket don't receive data")
sys.exit()
if data.header.message_type.name == "OFPT_PACKET_OUT":
self.checkStatusOfActivePort()
# OF_PACKET_IN -> controller
check = self.sendLLDPInOF_PACKET_IN_OPENFLOWV1( data )
if not check :
print("send OFPT_ECHO_REQUEST")
packet = echoRequest().pack()
self.s.send(packet)
"""
if data.header.message_type.name == "OFPT_ECHO_REQUEST":
print("Send OFPT_ECHO_REPLY")
packet = echoReply().pack()
self.s.send(packet)
"""
"""
def test_pack_unpack_port_stats(self):
"""Pack and unpack PortStatsRequest."""
body = PortStatsRequest(Port.OFPP_NONE)
req = StatsRequest(16909060,
body_type=StatsTypes.OFPST_PORT,
body=body)
pack = req.pack()
unpacked = unpack_message(pack)
self.assertEqual(req, unpacked)
def openflowV1(self):
# init value
data = None
checkData = None
tempBytes = None
# OF_HELLO switch <-> controller
checkData, tempBytes = self.sendAndReceiveOF_HELLO_OPENFLOWV1()
# OF_FEATURE switch <-> controller
self.sendAndReceiveOF_FEATURE_OPENFLOWV1(checkData, tempBytes)
"""
port = PPort(100, "ff:ff:ff:ff:ff:00" , "test", 0, 0, 192 ,0,0,0)
port.port_no = 200
print( "add port : " + str(port.port_no))
packed_data = portStatus( reason=portReason.OFPPR_ADD , desc=port )
packed_data = packed_data.pack()
self.s.send( packed_data )
"""
while (1):
#init value
indexData = 0
tempData = self.receiveDataFromSocket()
self.checkStatusOfActivePort()
while indexData < len(tempData):
data = unpack_message(tempData[indexData:])
if data.header.message_type.name == "OFPT_PACKET_OUT":
# OF_PACKET_IN -> controller
check = self.sendLLDPInOF_PACKET_IN_OPENFLOWV1(data)
if not check:
print("switch ip " + self.switchIp +
" send OFPT_ECHO_REQUEST")
packet = echoRequest().pack()
self.s.send(packet)
indexData += data.header.length
"""
if data.header.message_type.name == "OFPT_ECHO_REQUEST":
print("Send OFPT_ECHO_REPLY")
packet = echoReply().pack()
self.s.send(packet)
"""
"""
def __init__(self, this_packet):
"""
Instantiate OFMessage class
Args:
self: this class
this_packet: OpenFlow msg in binary format
"""
try:
self.ofp = unpack_message(this_packet)
except:
# if there is a problem with the python-openflow
# just set the self.ofp to 0. It will be ignored
# by the Packet().add_of_msg_to_list
self.ofp = 0
def __init__(self):
self.packet_in_message = PacketIn()
self.packet_in_message.in_port = 1
self.packet_in_message.buffer_id = 1
self.packet_in_message.pad = 0
self.packet_in_message.reason = PacketInReason.OFPR_NO_MATCH
# from cbench
data = b"\x04\x06\x00\xe0\x04\x01\x00\x00\x00\x00\x76\xa9\xd4\x0d\x25\x48\x00\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\xff\x00\x01\x1a\xc1\x51\xff\xef\x8a\x76\x65\x74\x68\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xce\x2f\xa2\x87\xf6\x70\x76\x65\x74\x68\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\xca\x8a\x1e\xf3\x77\xef\x76\x65\x74\x68\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\xfa\xbc\x77\x8d\x7e\x0b\x76\x65\x74\x68\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
self.features_reply_message = unpack_message(data)
# for packet_in messages
self.current_src_mac = 1
def openflowV1(self):
# OF_HELLO switch <-> controller
self.sendAndReceiveOF_HELLO_OPENFLOWV1()
# OF_FEATURE switch <-> controller
self.sendAndReceiveOF_FEATURE_OPENFLOWV1()
# init value
data = None
while(1):
count = 0
# receive OF_PACKET_OUT message
while count < self.numberOfRetransmission :
try:
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
break
except Exception as err:
count += 1
print( " 431 Switch ip " + self.switchIp + " handling run-time error of socket : " + str( err ) )
if count == self.numberOfRetransmission :
print( " 443 Switch ip " + self.switchIp + " socket don't receive data")
sys.exit()
if data.header.message_type.name == "OFPT_PACKET_OUT":
self.receiveRemoteSwitchDataFromSnmpVersion2C()
self.checkStatusOfActivePort()
# OF_PACKET_IN -> controller
check = self.sendLLDPInOF_PACKET_IN_OPENFLOWV1( data )
if not check :
print("send OFPT_ECHO_REQUEST")
packet = echoRequest().pack()
self.s.send(packet)
"""
if data.header.message_type.name == "OFPT_ECHO_REQUEST":
print("Send OFPT_ECHO_REPLY")
packet = echoReply().pack()
self.s.send(packet)
"""
"""
def on_message_received(self, data):
receive_time = self.getCurrentMicroSeconds()
try:
msg = unpack_message(data)
except:
print("received invalid message!")
return
print("received " + str(msg.header.message_type) + " " +
str(msg.header.xid))
if msg.header.message_type == Type.OFPT_PACKET_OUT or msg.header.message_type == Type.OFPT_ECHO_REPLY:
if receive_time - self.start_time > self.warmup_time_s * 1000000 and receive_time < self.should_stop:
self.results.append([receive_time, msg.header.xid])
if not self.throughput_mode and msg.header.xid == self.currentXid:
self.send_next()
elif msg.header.message_type == Type.OFPT_FEATURES_REQUEST:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_features_reply_message(
msg.header.xid, self.dpid)))
elif msg.header.message_type == Type.OFPT_SET_CONFIG:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_config_reply_message(
msg.header.xid, msg.flags, msg.miss_send_len)))
elif msg.header.message_type == Type.OFPT_ECHO_REQUEST:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_echo_reply_message(
msg.header.xid)))
elif msg.header.message_type == Type.OFPT_STATS_REQUEST:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_stats_reply_message()))
elif msg.header.message_type == Type.OFPT_VENDOR:
self.messages_to_send.insert(
0, (msg.header.xid,
self.messageGenerator.generate_vendor_reply_message(
msg.header.xid)))
if msg.header.message_type != Type.OFPT_PACKET_OUT and msg.header.message_type != Type.OFPT_ECHO_REPLY:
print("received " + str(msg.header.message_type) + " after " +
str((self.getCurrentMicroSeconds() - self.start_time) /
1000000) + "s")
def sendAndReceiveOF_HELLO_OPENFLOWV1(self):
#init value
count = 0
tempBytes = None
# create OF_HEllO message
packed_data = Hello().pack()
while count < self.numberOfRetransmission:
try:
# send OF_HEllO message to contoller
self.s.send(packed_data)
print("Switch ip " + self.switchIp +
" Send OF_HELLO message to controller")
# receive OF_HELLO message from controller
data = self.s.recv(self.buffer_size)
print("hello message len : " + str(len(data)))
# temp for byte data
tempBytes = data
data = unpack_message(data)
if data.header.message_type.name == "OFPT_HELLO":
print("Switch ip " + self.switchIp +
" Receive OF_HELLO message from controller")
if len(tempBytes) == 8:
return False, None
else:
print(tempBytes[8:16])
return True, tempBytes[8:16]
except Exception as err:
count += 1
print(" 322 Switch ip " + self.switchIp +
" handling run-time error of socket : " + str(err))
print(" Switch ip " + self.switchIp + " terminate")
sys.exit()
def sendAndReceiveOF_FEATURE_OPENFLOWV1(self, checkData, tempBytes):
try:
# receive OF_FEATURE_REQUEST message
if checkData:
data = tempBytes
else:
data = self.receiveDataFromSocket()
print("Switch ip " + self.switchIp +
" Receive OF_FEATURE_REQUEST message from controller")
data = unpack_message(data)
if data.header.message_type.name != "OFPT_FEATURES_REQUEST":
print(
" 336 Switch ip " + self.switchIp +
" terminate because switch don't receive OF_FEATURES_REQUEST"
)
sys.exit()
# get tranID from OF_FEATURE_REQUEST message
tranID = data.header.xid
#send OF_FEATURE_REPLY message
listPort = []
dictRemoteSwitchData = self.getRemoteSwitchDataFromSnmpVersion2C()
dictPort = self.getPortFromSnmpVersion2C(0)
for snmpPosition in dictPort:
if snmpPosition in dictRemoteSwitchData:
self.dictActivePort[snmpPosition] = dictPort[snmpPosition]
listPort.append(dictPort[snmpPosition])
print("list active port " + self.switchIp + " : ")
for key, port in self.dictActivePort.items():
print("snmp position : " + key + " | hw_addr : " +
str(port.hw_addr) + " | port_no : " + str(port.port_no))
# find max value of mac address from list mac address
maxPort = "000000000000"
maxIndex = 0
for index, item in enumerate(listPort):
tempMac = item.hw_addr.replace(":", "")
if (int(tempMac, 16) > int(maxPort, 16)):
maxPort = tempMac
maxIndex = index
# create OF_FEATURE_REPLY message
packed_data = FeaRes()
packed_data.header.xid = tranID
# gen datapath_id from hw_addr of first port
packed_data.datapath_id = listPort[maxIndex].hw_addr + ":ff:ff"
#packed_data.datapath_id = '00:00:00:00:00:00:00:02'
packed_data.n_buffers = 256
packed_data.n_tables = 254
packed_data.capabilities = 199
packed_data.actions = 4095
# create port
#port1 = PPort(1, '00:00:00:00:00:02','eth1', 0, 0, 192 ,0,0,0)
#packed_data.ports = [port1]
packed_data.ports = listPort
packed_data = packed_data.pack()
# send OF_FEATURE_REPLY message
self.s.send(packed_data)
print("Send OF_FEATURE_REPLY message to controller")
#record datapath id
self.datapathId = listPort[maxIndex].hw_addr + ":ff:ff"
self.datapathId = "dpid:" + self.datapathId.replace(":", "")
"""
tempPortID = i[1][1].prettyPrint()[2:] # 00000001
# change 00000001 to \x00\x00\x00\x01
packer = struct.Struct('bbbb')
secondData = packer.pack( int( tempPortID[0:2] , 16 ) , int( tempPortID[2:4] , 16 ) , int( tempPortID[4:6] , 16 ) , int( tempPortID[6:8] , 16 ))
"""
try:
self.lock.acquire_write()
# add port to dict all active port in tda
for snmpPosition, port in self.dictActivePort.items():
tempPortID = str(port.port_no)
tempPortID = ("0" * (8 - len(tempPortID))) + tempPortID
packer = struct.Struct('bbbb')
tempPortID = packer.pack(int(tempPortID[0:2], 16),
int(tempPortID[2:4], 16),
int(tempPortID[4:6], 16),
int(tempPortID[6:8], 16))
self.dictAllActivePortInTDA[(port.hw_addr, port.name)] = [
self.datapathId, tempPortID
]
self.lock.release()
print(self.dictAllActivePortInTDA)
except Exception as err:
self.lock.release()
print(" 422 Switch ip " + self.switchIp +
" terminate because handling run-time error : " +
str(err))
sys.exit()
except Exception as err:
print(" 426 Switch ip " + self.switchIp +
" terminate because handling run-time error : " + str(err))
sys.exit()
def openflowV1(self):
# OF_HELLO switch <-> controller
self.sendAndReceiveOF_HELLO_OPENFLOWV1()
# OF_FEATURE switch <-> controller
self.sendAndReceiveOF_FEATURE_OPENFLOWV1()
"""
num = input()
port = self.listActivePort["06:fd:e2:ae:ab:60"][2]
print( "delete port : " + str(port.port_no))
packed_data = portStatus( reason=portReason.OFPPR_DELETE , desc=port )
packed_data = packed_data.pack()
self.s.send( packed_data )
num = input()
port.port_no = 10
print( "add port : " + str(port.port_no))
packed_data = portStatus( reason=portReason.OFPPR_ADD , desc=port )
packed_data = packed_data.pack()
self.s.send( packed_data )
return
"""
"""
# receive OF_FLOW_MOD message
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
print(data)
"""
self.receiveRemoteSwitchDataFromSnmpVersion2C()
# init value
data = None
while (1):
count = 0
# receive OF_PACKET_OUT message
while count < self.numberOfRetransmission:
try:
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
break
except Exception as err:
count += 1
print(" 431 Switch ip " + self.switchIp +
" handling run-time error of socket : " + str(err))
if count == self.numberOfRetransmission:
print(" 443 Switch ip " + self.switchIp +
" socket don't receive data")
sys.exit()
if data.header.message_type.name == "OFPT_PACKET_OUT":
#self.receiveRemoteSwitchDataFromSnmpVersion2C()
# ethernet header of lldp
ethernetH = data.data.value
ethernetH = lldp.unpack_ethernet_frame(ethernetH)
# get Src from ethernet header
temp = ethernetH[2] # tuple
temp = list(map(str, temp)) # tuple to list
srcEthernet = ""
hexNumberTemp = ""
for i in temp:
hexNumberTemp = hex(
int(i))[2:] # change number to Hex cut 0x out
if (len(hexNumberTemp) == 1):
srcEthernet += "0" + hexNumberTemp
else:
srcEthernet += hexNumberTemp
srcEthernet += ":"
srcEthernet = srcEthernet[0:len(srcEthernet) -
1] # src ethernet
#print(srcEthernet)
"""
chassis_id = self.listRemoteDataFromPort[self.listActivePort[srcEthernet][0]][0]
port_id = self.listRemoteDataFromPort[self.listActivePort[srcEthernet][0]][1]
in_port = self.listActivePort[srcEthernet][1]
ethernet_data = self.createLLDPPacket( srcEthernet , bytes(chassis_id, encoding='utf-8') , port_id )
self.sendLLDPInOF_PACKET_IN_OPENFLOWV1( ethernet_data , in_port)
"""
# send Packet_IN contain lldp frame
try:
chassis_id = self.listRemoteDataFromPort[
self.listActivePort[srcEthernet][0]][0]
port_id = self.listRemoteDataFromPort[
self.listActivePort[srcEthernet][0]][1]
in_port = self.listActivePort[srcEthernet][1]
ethernet_data = self.createLLDPPacket(
srcEthernet, bytes(chassis_id, encoding='utf-8'),
port_id)
self.sendLLDPInOF_PACKET_IN_OPENFLOWV1(
ethernet_data, in_port)
print(" packet_in ")
except Exception as err:
print(" 514 Switch ip " + self.switchIp +
" handling run-time error : " + str(err))
if data.header.message_type.name == "OFPT_ECHO_REQUEST":
print("OFPT_ECHO_REQUEST")
def initConnectionToController(self):
count = 0
while count < self.numberOfRetransmission:
try:
packed_data = Hello().pack()
# send OF_HEllO message to contoller
self.s.send(packed_data)
print("Switch ip " + self.switchIp +
" Send OF_HELLO message to controller")
# receive OF_HELLO message from controller
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
if data.header.message_type.name == "OFPT_HELLO":
print("Switch ip " + self.switchIp +
" Receive OF_HELLO message from controller")
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
print(
" 428 Switch ip " + self.switchIp +
" Receive OF_FEATURE_REQUEST message from controller")
if data.header.message_type.name == "OFPT_FEATURES_REQUEST":
# get tranID from OF_FEATURE_REQUEST message
tranID = data.header.xid
#send OF_FEATURE_REPLY message
listPort = self.createOFFeatureReplyFromSnmpVersion2C(
1)
print("All active port of switch ip " + self.switchIp +
" : ")
for i in listPort:
print("Hw_addr : " + i.hw_addr)
print("Hw_desc : " + i.name)
# find max value of mac address from list mac address
maxPort = "000000000000"
maxIndex = 0
for index, item in enumerate(listPort):
tempMac = item.hw_addr.replace(":", "")
if (int(tempMac, 16) > int(maxPort, 16)):
maxPort = tempMac
maxIndex = index
# create OF_FEATURE_REPLY message
packed_data = FeaRes()
packed_data.header.xid = tranID
# gen datapath_id from hw_addr of first port
packed_data.datapath_id = listPort[
maxIndex].hw_addr + ":ff:ff"
#packed_data.datapath_id = '00:00:00:00:00:00:00:02'
packed_data.n_buffers = 256
packed_data.n_tables = 254
packed_data.capabilities = 199
packed_data.actions = 4095
# create port
#port1 = PPort(1, '00:00:00:00:00:02','eth1', 0, 0, 192 ,0,0,0)
#packed_data.ports = [port1]
packed_data.ports = listPort
packed_data = packed_data.pack()
# send OF_FEATURE_REPLY message
self.s.send(packed_data)
print("Send OF_FEATURE_REPLY message to controller")
return
except Exception as err:
count += 1
print(" 322 Switch ip " + self.switchIp +
" handling run-time error of socket : " + str(err))
print(" Switch ip " + self.switchIp + " terminate")
sys.exit()
def openflowV1(self):
# OF_HELLO switch <-> controller
self.sendAndReceiveOF_HELLO_OPENFLOWV1()
# OF_FEATURE switch <-> controller
self.sendAndReceiveOF_FEATURE_OPENFLOWV1()
return
"""
packed_data = portStatus( reason=portReason.OFPPR_DELETE , desc=self.listActivePort["08:00:27:40:7e:7f"][2] )
packed_data = packed_data.pack()
self.s.send( packed_data )
"""
"""
# receive OF_FLOW_MOD message
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
print(data)
"""
#self.receiveRemoteSwitchDataFromSnmpVersion2C()
# init value
data = None
while(1):
count = 0
# receive OF_PACKET_OUT message
while count < self.numberOfRetransmission :
try:
data = self.s.recv(self.buffer_size)
data = unpack_message(data)
break
except Exception as err:
count += 1
print( " 431 Switch ip " + self.switchIp + " handling run-time error of socket : " + str( err ) )
if count == self.numberOfRetransmission :
print( " 443 Switch ip " + self.switchIp + " socket don't receive data : " + str( err ) )
sys.exit()
if data.header.message_type.name == "OFPT_PACKET_OUT":
#self.receiveRemoteSwitchDataFromSnmpVersion2C()
# ethernet header of lldp
ethernetH = data.data.value
ethernetH = lldp.unpack_ethernet_frame(ethernetH)
# get Src from ethernet header
temp = ethernetH[2] # tuple
temp = list(map(str, temp)) # tuple to list
srcEthernet = ""
hexNumberTemp = ""
for i in temp:
hexNumberTemp = hex(int(i))[2:] # change number to Hex cut 0x out
if(len(hexNumberTemp) == 1):
srcEthernet += "0" + hexNumberTemp
else:
srcEthernet += hexNumberTemp
srcEthernet += ":"
srcEthernet = srcEthernet[0: len(srcEthernet)-1] # src ethernet
for port in self.listActivePort:
return
#print(srcEthernet)
"""
chassis_id = self.listRemoteDataFromPort[self.listActivePort[srcEthernet][0]][0]
port_id = self.listRemoteDataFromPort[self.listActivePort[srcEthernet][0]][1]
in_port = self.listActivePort[srcEthernet][1]
ethernet_data = self.createLLDPPacket( srcEthernet , bytes(chassis_id, encoding='utf-8') , port_id )
self.sendLLDPInOF_PACKET_IN_OPENFLOWV1( ethernet_data , in_port)
"""
# send Packet_IN contain lldp frame
try :
chassis_id = self.listRemoteDataFromPort[self.listActivePort[srcEthernet][0]][0]
port_id = self.listRemoteDataFromPort[self.listActivePort[srcEthernet][0]][1]
in_port = self.listActivePort[srcEthernet][1]
ethernet_data = self.createLLDPPacket( srcEthernet , bytes(chassis_id, encoding='utf-8') , port_id )
self.sendLLDPInOF_PACKET_IN_OPENFLOWV1( ethernet_data , in_port)
except Exception as err:
print( " 431 Switch ip " + self.switchIp + " handling run-time error : " + str( err ) )
def startConnectToController(self):
# create socket and connection to controller
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sock.setimeout
self.s.settimeout(4)
self.s.connect((self.controllerIp, self.controllerPort))
print("Switch ip " + self.switchIp + " create socket success!!!")
self.openflowV1()
def stopConnectToController(self):
self.s.close()
def run(self):
try:
self.startConnectToController()
finally:
self.stopConnectToController()
# ethernet payload of lldp
"""
ethernetP = ethernetH[4]
ethernetP = lldp.unpack_lldp_frame(ethernetP)
list_TLV = []
for i in ethernetP:
list_TLV.append(i)
print(list_TLV[1])
"""
#self.s.send(self.createLLDPPacket( srcEthernet, bytes('dpid:0000000000000001', encoding='utf-8'), list_TLV[1]))
"""
# ethernet header of lldp
ethernetH = data.data.value
ethernetH = lldp.unpack_ethernet_frame(ethernetH)
# get Src from ethernet header
temp = ethernetH[2] # tuple
temp = list(map(str, temp)) # tuple to list
srcEthernet = ""
hexNumberTemp = ""
for i in temp:
hexNumberTemp = hex(int(i))[2:] # change number to Hex cut 0x out
if(len(hexNumberTemp) == 1):
srcEthernet += 0 + hexNumberTemp
else:
srcEthernet += hexNumberTemp
srcEthernet += ":"
srcEthernet = srcEthernet[0: len(srcEthernet)-1] # src ethernet
print(srcEthernet)
# ethernet payload of lldp
ethernetP = ethernetH[4]
ethernetP = lldp.unpack_lldp_frame(ethernetP)
list_TLV = []
for i in ethernetP:
list_TLV.append(i)
self.s.send(self.createLLDPPacket( srcEthernet, bytes('dpid:0000000000000001', encoding='utf-8'), list_TLV[1]))
"""
"""
while(1):
data = self.s.recv(self.buffer_size)
self.s.send(self.createLLDPPacket( srcEthernet, list_TLV[0], list_TLV[1]))
"""
"""
#b'\x64\x70\x69\x64\x3a\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x33'
# create LLDP message
lldp_data = lldpMsg()
lldp_data.chassis_id = tlvLLDP(1, 7,binaryData(b'dpid:0000000000000001'))
lldp_data.port_id = tlvLLDP(2, 2, binaryData(b'\x00\x00\x00\x01'))
lldp_data = lldp_data.pack()
# create EthernerFrame message
ethernet_data = ethernet()
ethernet_data.destination = "01:80:c2:00:00:0e"
ethernet_data.source = "00:00:00:00:00:01"
ethernet_data.type = 35020
ethernet_data.data = lldp_data
ethernet_data = ethernet_data.pack()
# create OF_PACKET_IN message
packed_data = pI()
packed_data.header.xid = 0
packed_data.buffer_id = 4294967295
packed_data.in_port = 1
packed_data.reason = pIR.OFPR_ACTION
packed_data.data = ethernet_data
packed_data.total_len = packed_data.get_size()-8
packed_data = packed_data.pack()
self.s.send(packed_data)
print('susu')
"""
"""
print(data.data)
print(dir(lldp))
print(dir(data.data))
print(lldp.unpack_ethernet_frame(data.data.value))
"""
"""
def openflowV1(self):
# init value
data = None
checkData = None
tempBytes = None
# OF_HELLO switch <-> controller
checkData, tempBytes = self.sendAndReceiveOF_HELLO_OPENFLOWV1()
# OF_FEATURE switch <-> controller
self.sendAndReceiveOF_FEATURE_OPENFLOWV1(checkData, tempBytes)
"""
port = PPort(100, "ff:ff:ff:ff:ff:00" , "test", 0, 0, 192 ,0,0,0)
port.port_no = 200
print( "add port : " + str(port.port_no))
packed_data = portStatus( reason=portReason.OFPPR_ADD , desc=port )
packed_data = packed_data.pack()
self.s.send( packed_data )
"""
count = 0
while (1):
#init value
indexData = 0
tempData = None
try:
tempData = self.s.recv(self.buffer_size)
except Exception as err:
count += 1
if tempData != None:
self.checkStatusOfActivePort()
while indexData < len(tempData):
data = unpack_message(tempData[indexData:])
if data.header.message_type.name == "OFPT_PACKET_OUT":
# OF_PACKET_IN -> controller
check = self.sendLLDPInOF_PACKET_IN_OPENFLOWV1(data)
#print("send of_packet_in")
if check:
count = 0
else:
count += 1
"""
if not check :
print("switch ip " + self.switchIp + " send OFPT_ECHO_REQUEST")
packet = echoRequest().pack()
self.s.send(packet)
"""
#pox
if data.header.message_type.name == "OFPT_BARRIER_REQUEST":
count = 0
packet = BarReply()
packet.header.xid = data.header.xid
packet = packet.pack()
self.s.send(packet)
indexData += data.header.length
if count == 2:
count = 0
#print("switch ip " + self.switchIp + " send OFPT_ECHO_REQUEST")
packet = echoRequest().pack()
self.s.send(packet)
"""
if data.header.message_type.name == "OFPT_ECHO_REQUEST":
print("Send OFPT_ECHO_REPLY")
packet = echoReply().pack()
self.s.send(packet)
"""
"""
