Repository navigation
Expand file tree
/
Copy pathcontroller.py
More file actions
348 lines (275 loc) · 12.4 KB
/
Copy pathcontroller.py
File metadata and controls
348 lines (275 loc) · 12.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.topology import event, switches
from ryu.ofproto import ofproto_v1_0
from ryu.lib.packet import packet, ethernet, ether_types, arp
from ryu.lib.packet import dhcp
from ryu.lib.packet import ethernet
from ryu.lib.packet import ipv4
from ryu.lib.packet import packet
from ryu.lib.packet import udp
from ryu.lib.packet import icmp
import rest_firewall
from dhcp import DHCPServer
from mydns import MYDNSServer
def form_id(id):
if id >= 200:
return f"h{id-200}"
return f"s{id-100}"
class NetDevice:
def __init__(self, owner, id):
self.id = id
self.owner = owner
self.adjust = []
self.router_table = {self: (0, self)}
def get_port(self,adj_device):
for dev,port in self.adjust:
if adj_device is dev:
return port
print(f"WARN: cannot find port of this adj_dev: {adj_device.id}!")
print(f"adj size: {len(self.adjust)}")
self.print_info()
def print_info(self):
print(f"=====[Device {form_id(self.id)}]=====")
print(f"adjust info:")
for adj in self.adjust:
print(f"[{form_id(self.id)}] -> {form_id(adj[0].id)} == 1")
print(f"routing table:")
for route in self.router_table.keys():
print(f"[{form_id(self.id)}] -> {form_id(route.id)} == {self.router_table[route][0]} (nxt skip: {form_id(self.router_table[route][1].id)})")
def trace(self,dst):
if dst is self:
print(f"{form_id(self.id)} [success]")
else:
print(f"{form_id(self.id)} -> ",end = "")
if dst in self.router_table.keys():
self.router_table[dst][1].trace(dst)
else:
print(f"X [failed]")
def destroy(self):
self.adjust = None
self.owner = None
self.router_table = None
def is_adjust(self, other_device):
for adj_dev, d in self.adjust:
if other_device is adj_dev:
return True
return False
def add_adjust(self, other_device, port):
self.adjust.append((other_device,port))
self.update_from_adj(other_device,1)
#update the table by giving an adjust device and the distance.
def update_from_adj(self, adj_dev, adj_distance = 1):
if not self.is_adjust(adj_dev):
return
updated = False
for key in adj_dev.router_table:
if key in self.router_table.keys():
if self.router_table[key][0] > adj_dev.router_table[key][0]+adj_distance:
self.router_table[key] = (adj_dev.router_table[key][0]+adj_distance, adj_dev)
updated = True
else:
self.router_table[key] = (adj_dev.router_table[key][0]+adj_distance, adj_dev)
updated = True
if updated:
for dev in self.adjust:
dev[0].update_from_adj(self,1)
# router_entry: destination: (distance, next_skip)
class SwitchDevice(NetDevice):
def __init__(self, owner):
super().__init__(owner, 100+owner.ports[0].dpid)
def destroy(self):
datapath = self.owner.dp
ofp = datapath.ofproto
ofp_parser = datapath.ofproto_parser
for dst in self.router_table.keys():
if dst.is_host():
dst_addr = dst.MAC_addr # target host
match = ofp_parser.OFPMatch(dl_dst = dst_addr)
req = ofp_parser.OFPFlowMod(datapath=datapath, command=ofp.OFPFC_DELETE, buffer_id=0xffffffff,
out_port=ofp.OFPP_NONE, match=match)
datapath.send_msg(req)
pass
super().destroy();
def has_port(self, port):
for sport in self.owner.ports:
if sport.dpid == port.dpid and sport.port_no == port.port_no:
return True
return False
def is_host(self):
return False
def commit(self):
datapath = self.owner.dp
ofp = datapath.ofproto
ofp_parser = datapath.ofproto_parser
# boardcast(default) setting: just only send it to controller~
if True:
actions = [ofp_parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]
# match = ofp_parser.OFPMatch(dl_dst = 'ff:ff:ff:ff:ff:ff')
# req = ofp_parser.OFPFlowMod(datapath=datapath, command=ofp.OFPFC_ADD, buffer_id=0xffffffff,
# priority=9999, flags=0, match=match, out_port = 0, actions=actions)
# datapath.send_msg(req)
match = ofp_parser.OFPMatch()
req = ofp_parser.OFPFlowMod(datapath=datapath, command=ofp.OFPFC_ADD, buffer_id=0xffffffff,
priority=1000, flags=0, match=match, out_port = 0, actions=actions)
datapath.send_msg(req)
# flow setting: send to next flow and controller~
for dst in self.router_table.keys():
if dst.is_host():
next_skip = self.router_table[dst][1]
next_skip_port = self.get_port(next_skip).port_no # port of next skip
dst_addr = dst.MAC_addr # target host
actions = [ofp_parser.OFPActionOutput(next_skip_port), ofp_parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]
match = ofp_parser.OFPMatch(dl_dst = dst_addr)
req = ofp_parser.OFPFlowMod(datapath=datapath, command=ofp.OFPFC_ADD, buffer_id=0xffffffff,
priority=2333, flags=0, match=match, out_port = next_skip_port, actions=actions)
datapath.send_msg(req)
# print(f"Flow commit for {form_id(self.id)}: {dst_addr}({form_id(dst.id)}) -> port{next_skip_port}({form_id(next_skip.id)})")
pass
class HostDevice(NetDevice):
def __init__(self, owner, id):
super().__init__(owner, 200+id)
self.MAC_addr = f'00:00:00:00:00:0{id}'
def is_host(self):
return True
def has_port(self, port):
for sport in [self.owner.port]:
if sport.dpid == port.dpid and sport.port_no == port.port_no:
return True
return False
class ControllerApp(rest_firewall.RestFirewallAPI):
#totaly update when topology changes
switch_dev = []
host_dev = []
OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]
def print_debug_message(self):
for dev in self.switch_dev:
dev.print_info()
for dev in self.host_dev:
dev.print_info()
def traceroute(self,src_mac, dst_mac):
print(f"Tracing {src_mac} -> {dst_mac}:")
src, dst = None, None
for dv in self.host_dev:
if dv.MAC_addr == src_mac:
src = dv
if dv.MAC_addr == dst_mac:
dst = dv
if src == None or dst == None:
print("unknown source or destination.")
return
src.trace(dst)
def topology_update(self):
# clean the old topology
for dev in self.switch_dev:
dev.destroy()
self.switch_dev.clear()
for dev in self.host_dev:
dev.destroy()
self.host_dev.clear()
# translate switches to net point
for id,switch in enumerate(self.send_request(event.EventSwitchRequest(None)).switches):
nd = SwitchDevice(switch)
self.switch_dev.append(nd)
# translate hosts to net point
for id,host in enumerate(self.send_request(event.EventHostRequest(None)).hosts):
nd = HostDevice(host,id+1)
self.host_dev.append(nd)
for sw_dev in self.switch_dev:
if sw_dev.has_port(host.port):
sw_dev.add_adjust(nd,host.port)
nd.add_adjust(sw_dev,host.port)
# translate link to edge in map
for link in self.send_request(event.EventLinkRequest(None)).links:
# print(f"link info: {link.src.dpid},{link.src.port_no}({link.src.hw_addr}) <-> {link.dst.dpid},{link.dst.port_no}({link.dst.hw_addr})")
src = None
dst = None
for dev in self.switch_dev:
if dev.has_port(link.src):
src = dev
if dev.has_port(link.dst):
dst = dev
src.add_adjust(dst,link.src)
for switch in self.switch_dev:
switch.commit()
# self.print_debug_message()
def __init__(self, *args, **kwargs):
super(ControllerApp, self).__init__(*args, **kwargs)
self.arp_table = {
"10.0.0.0": "00:00:00:00:00:00",
# "10.0.0.2": "00:00:00:00:00:02",
# "10.0.0.3": "00:00:00:00:00:03"
}
MYDNSServer.init_db()
@set_ev_cls(event.EventSwitchEnter)
def handle_switch_add(self, ev):
print("new switches added.")
self.topology_update()
@set_ev_cls(event.EventSwitchLeave)
def handle_switch_delete(self, ev):
print("switches deleted.")
self.topology_update()
@set_ev_cls(event.EventHostAdd)
def handle_host_add(self, ev):
print("new host added.")
self.topology_update()
# self.print_debug_message()
@set_ev_cls(event.EventLinkAdd)
def handle_link_add(self, ev):
print("new link added.")
self.topology_update()
@set_ev_cls(event.EventLinkDelete)
def handle_link_delete(self, ev):
print("link deleted.")
self.topology_update()
@set_ev_cls(event.EventPortModify)
def handle_port_modify(self, ev):
print("port modified.")
self.topology_update()
def handle_arp(self, datapath, eth, arp_pkt, in_port):
r = self.arp_table.get(arp_pkt.dst_ip)
if r:
arp_resp = packet.Packet()
arp_resp.add_protocol(ethernet.ethernet(ethertype=eth.ethertype,
dst=eth.src, src=r))
arp_resp.add_protocol(arp.arp(opcode=arp.ARP_REPLY,
src_mac=r, src_ip=arp_pkt.dst_ip,
dst_mac=arp_pkt.src_mac,
dst_ip=arp_pkt.src_ip))
arp_resp.serialize()
parser = datapath.ofproto_parser
actions = [parser.OFPActionOutput(in_port)]
ofproto = datapath.ofproto
out = parser.OFPPacketOut(datapath=datapath, buffer_id=ofproto.OFP_NO_BUFFER,
in_port=ofproto.OFPP_CONTROLLER, actions=actions, data=arp_resp)
datapath.send_msg(out)
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def packet_in_handler(self, ev):
try:
msg = ev.msg
datapath = msg.datapath
pkt = packet.Packet(data=msg.data)
inPort = msg.in_port
# ICMP(ping) is used to debug.
if pkt.get_protocols(icmp.icmp):
eth_pkt = pkt.get_protocol(ethernet.ethernet)
self.traceroute(eth_pkt.src,eth_pkt.dst)
DHCPServer.update_ip_pool(pkt)
if pkt.get_protocols(dhcp.dhcp):
DHCPServer.handle_dhcp(datapath, inPort, pkt)
elif pkt.get_protocols(arp.arp):
arp_pkt = pkt.get_protocol(arp.arp)
if (arp_pkt.src_ip != '0.0.0.0'): # arping, update arp table
self.arp_table[arp_pkt.src_ip] = arp_pkt.src_mac
print(f'arp from {arp_pkt.src_ip} to {arp_pkt.dst_ip} mac from {arp_pkt.src_mac} to {arp_pkt.dst_mac}')
self.handle_arp(datapath, pkt.get_protocol(ethernet.ethernet), arp_pkt, inPort)
elif pkt.get_protocols(udp.udp):
if pkt.get_protocol(udp.udp).dst_port == 53:
print(f'dns request handled.')
MYDNSServer.handle_dns(datapath, pkt, inPort)
else:
pass
except Exception as e:
self.logger.error(e)