Se reinstalo ryu para configurar STP y que el restAPI no sea publico(127.0.0.1)
[vsorcdistro/.git] / ryu / ryu / lib / ofctl_v1_0.py
1 # Copyright (C) 2012 Nippon Telegraph and Telephone Corporation.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 #    http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12 # implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 import struct
17 import socket
18 import logging
19
20 from ryu.ofproto import ofproto_v1_0
21 from ryu.lib import ofctl_utils
22 from ryu.lib.mac import haddr_to_bin, haddr_to_str
23
24
25 LOG = logging.getLogger('ryu.lib.ofctl_v1_0')
26
27 DEFAULT_TIMEOUT = 1.0   # TODO:XXX
28
29 UTIL = ofctl_utils.OFCtlUtil(ofproto_v1_0)
30 str_to_int = ofctl_utils.str_to_int
31
32
33 def to_actions(dp, acts):
34     actions = []
35     for a in acts:
36         action_type = a.get('type')
37         if action_type == 'OUTPUT':
38             port = UTIL.ofp_port_from_user(
39                 a.get('port', ofproto_v1_0.OFPP_NONE))
40             # NOTE: The reason of this magic number (0xffe5)
41             #       is because there is no good constant in of1.0.
42             #       The same value as OFPCML_MAX of of1.2 and of1.3 is used.
43             max_len = str_to_int(a.get('max_len', 0xffe5))
44             actions.append(dp.ofproto_parser.OFPActionOutput(port, max_len))
45         elif action_type == 'SET_VLAN_VID':
46             vlan_vid = str_to_int(a.get('vlan_vid', 0xffff))
47             actions.append(dp.ofproto_parser.OFPActionVlanVid(vlan_vid))
48         elif action_type == 'SET_VLAN_PCP':
49             vlan_pcp = str_to_int(a.get('vlan_pcp', 0))
50             actions.append(dp.ofproto_parser.OFPActionVlanPcp(vlan_pcp))
51         elif action_type == 'STRIP_VLAN':
52             actions.append(dp.ofproto_parser.OFPActionStripVlan())
53         elif action_type == 'SET_DL_SRC':
54             dl_src = haddr_to_bin(a.get('dl_src'))
55             actions.append(dp.ofproto_parser.OFPActionSetDlSrc(dl_src))
56         elif action_type == 'SET_DL_DST':
57             dl_dst = haddr_to_bin(a.get('dl_dst'))
58             actions.append(dp.ofproto_parser.OFPActionSetDlDst(dl_dst))
59         elif action_type == 'SET_NW_SRC':
60             nw_src = ipv4_to_int(a.get('nw_src'))
61             actions.append(dp.ofproto_parser.OFPActionSetNwSrc(nw_src))
62         elif action_type == 'SET_NW_DST':
63             nw_dst = ipv4_to_int(a.get('nw_dst'))
64             actions.append(dp.ofproto_parser.OFPActionSetNwDst(nw_dst))
65         elif action_type == 'SET_NW_TOS':
66             nw_tos = str_to_int(a.get('nw_tos', 0))
67             actions.append(dp.ofproto_parser.OFPActionSetNwTos(nw_tos))
68         elif action_type == 'SET_TP_SRC':
69             tp_src = str_to_int(a.get('tp_src', 0))
70             actions.append(dp.ofproto_parser.OFPActionSetTpSrc(tp_src))
71         elif action_type == 'SET_TP_DST':
72             tp_dst = str_to_int(a.get('tp_dst', 0))
73             actions.append(dp.ofproto_parser.OFPActionSetTpDst(tp_dst))
74         elif action_type == 'ENQUEUE':
75             port = UTIL.ofp_port_from_user(
76                 a.get('port', ofproto_v1_0.OFPP_NONE))
77             queue_id = UTIL.ofp_queue_from_user(a.get('queue_id', 0))
78             actions.append(dp.ofproto_parser.OFPActionEnqueue(port, queue_id))
79         else:
80             LOG.error('Unknown action type')
81
82     return actions
83
84
85 def actions_to_str(acts):
86     actions = []
87     for a in acts:
88         action_type = a.cls_action_type
89
90         if action_type == ofproto_v1_0.OFPAT_OUTPUT:
91             port = UTIL.ofp_port_to_user(a.port)
92             buf = 'OUTPUT:' + str(port)
93         elif action_type == ofproto_v1_0.OFPAT_SET_VLAN_VID:
94             buf = 'SET_VLAN_VID:' + str(a.vlan_vid)
95         elif action_type == ofproto_v1_0.OFPAT_SET_VLAN_PCP:
96             buf = 'SET_VLAN_PCP:' + str(a.vlan_pcp)
97         elif action_type == ofproto_v1_0.OFPAT_STRIP_VLAN:
98             buf = 'STRIP_VLAN'
99         elif action_type == ofproto_v1_0.OFPAT_SET_DL_SRC:
100             buf = 'SET_DL_SRC:' + haddr_to_str(a.dl_addr)
101         elif action_type == ofproto_v1_0.OFPAT_SET_DL_DST:
102             buf = 'SET_DL_DST:' + haddr_to_str(a.dl_addr)
103         elif action_type == ofproto_v1_0.OFPAT_SET_NW_SRC:
104             buf = 'SET_NW_SRC:' + \
105                   socket.inet_ntoa(struct.pack('!I', a.nw_addr))
106         elif action_type == ofproto_v1_0.OFPAT_SET_NW_DST:
107             buf = 'SET_NW_DST:' + \
108                   socket.inet_ntoa(struct.pack('!I', a.nw_addr))
109         elif action_type == ofproto_v1_0.OFPAT_SET_NW_TOS:
110             buf = 'SET_NW_TOS:' + str(a.tos)
111         elif action_type == ofproto_v1_0.OFPAT_SET_TP_SRC:
112             buf = 'SET_TP_SRC:' + str(a.tp)
113         elif action_type == ofproto_v1_0.OFPAT_SET_TP_DST:
114             buf = 'SET_TP_DST:' + str(a.tp)
115         elif action_type == ofproto_v1_0.OFPAT_ENQUEUE:
116             port = UTIL.ofp_port_to_user(a.port)
117             queue = UTIL.ofp_queue_to_user(a.queue_id)
118             buf = 'ENQUEUE:' + str(port) + ":" + str(queue)
119         elif action_type == ofproto_v1_0.OFPAT_VENDOR:
120             buf = 'VENDOR'
121         else:
122             buf = 'UNKNOWN'
123         actions.append(buf)
124
125     return actions
126
127
128 def ipv4_to_int(addr):
129     ip = addr.split('.')
130     assert len(ip) == 4
131     i = 0
132     for b in ip:
133         b = int(b)
134         i = (i << 8) | b
135     return i
136
137
138 def to_match(dp, attrs):
139     ofp = dp.ofproto
140
141     wildcards = ofp.OFPFW_ALL
142     in_port = 0
143     dl_src = 0
144     dl_dst = 0
145     dl_vlan = 0
146     dl_vlan_pcp = 0
147     dl_type = 0
148     nw_tos = 0
149     nw_proto = 0
150     nw_src = 0
151     nw_dst = 0
152     tp_src = 0
153     tp_dst = 0
154
155     for key, value in attrs.items():
156         if key == 'in_port':
157             in_port = UTIL.ofp_port_from_user(value)
158             wildcards &= ~ofp.OFPFW_IN_PORT
159         elif key == 'dl_src':
160             dl_src = haddr_to_bin(value)
161             wildcards &= ~ofp.OFPFW_DL_SRC
162         elif key == 'dl_dst':
163             dl_dst = haddr_to_bin(value)
164             wildcards &= ~ofp.OFPFW_DL_DST
165         elif key == 'dl_vlan':
166             dl_vlan = str_to_int(value)
167             wildcards &= ~ofp.OFPFW_DL_VLAN
168         elif key == 'dl_vlan_pcp':
169             dl_vlan_pcp = str_to_int(value)
170             wildcards &= ~ofp.OFPFW_DL_VLAN_PCP
171         elif key == 'dl_type':
172             dl_type = str_to_int(value)
173             wildcards &= ~ofp.OFPFW_DL_TYPE
174         elif key == 'nw_tos':
175             nw_tos = str_to_int(value)
176             wildcards &= ~ofp.OFPFW_NW_TOS
177         elif key == 'nw_proto':
178             nw_proto = str_to_int(value)
179             wildcards &= ~ofp.OFPFW_NW_PROTO
180         elif key == 'nw_src':
181             ip = value.split('/')
182             nw_src = struct.unpack('!I', socket.inet_aton(ip[0]))[0]
183             mask = 32
184             if len(ip) == 2:
185                 mask = int(ip[1])
186                 assert 0 < mask <= 32
187             v = (32 - mask) << ofp.OFPFW_NW_SRC_SHIFT | \
188                 ~ofp.OFPFW_NW_SRC_MASK
189             wildcards &= v
190         elif key == 'nw_dst':
191             ip = value.split('/')
192             nw_dst = struct.unpack('!I', socket.inet_aton(ip[0]))[0]
193             mask = 32
194             if len(ip) == 2:
195                 mask = int(ip[1])
196                 assert 0 < mask <= 32
197             v = (32 - mask) << ofp.OFPFW_NW_DST_SHIFT | \
198                 ~ofp.OFPFW_NW_DST_MASK
199             wildcards &= v
200         elif key == 'tp_src':
201             tp_src = str_to_int(value)
202             wildcards &= ~ofp.OFPFW_TP_SRC
203         elif key == 'tp_dst':
204             tp_dst = str_to_int(value)
205             wildcards &= ~ofp.OFPFW_TP_DST
206         else:
207             LOG.error("unknown match name %s, %s, %d", key, value, len(key))
208
209     match = dp.ofproto_parser.OFPMatch(
210         wildcards, in_port, dl_src, dl_dst, dl_vlan, dl_vlan_pcp,
211         dl_type, nw_tos, nw_proto, nw_src, nw_dst, tp_src, tp_dst)
212
213     return match
214
215
216 def match_to_str(m):
217
218     match = {}
219
220     if ~m.wildcards & ofproto_v1_0.OFPFW_IN_PORT:
221         match['in_port'] = UTIL.ofp_port_to_user(m.in_port)
222
223     if ~m.wildcards & ofproto_v1_0.OFPFW_DL_SRC:
224         match['dl_src'] = haddr_to_str(m.dl_src)
225
226     if ~m.wildcards & ofproto_v1_0.OFPFW_DL_DST:
227         match['dl_dst'] = haddr_to_str(m.dl_dst)
228
229     if ~m.wildcards & ofproto_v1_0.OFPFW_DL_VLAN:
230         match['dl_vlan'] = m.dl_vlan
231
232     if ~m.wildcards & ofproto_v1_0.OFPFW_DL_VLAN_PCP:
233         match['dl_vlan_pcp'] = m.dl_vlan_pcp
234
235     if ~m.wildcards & ofproto_v1_0.OFPFW_DL_TYPE:
236         match['dl_type'] = m.dl_type
237
238     if ~m.wildcards & ofproto_v1_0.OFPFW_NW_TOS:
239         match['nw_tos'] = m.nw_tos
240
241     if ~m.wildcards & ofproto_v1_0.OFPFW_NW_PROTO:
242         match['nw_proto'] = m.nw_proto
243
244     if ~m.wildcards & ofproto_v1_0.OFPFW_NW_SRC_ALL:
245         match['nw_src'] = nw_src_to_str(m.wildcards, m.nw_src)
246
247     if ~m.wildcards & ofproto_v1_0.OFPFW_NW_DST_ALL:
248         match['nw_dst'] = nw_dst_to_str(m.wildcards, m.nw_dst)
249
250     if ~m.wildcards & ofproto_v1_0.OFPFW_TP_SRC:
251         match['tp_src'] = m.tp_src
252
253     if ~m.wildcards & ofproto_v1_0.OFPFW_TP_DST:
254         match['tp_dst'] = m.tp_dst
255
256     return match
257
258
259 def nw_src_to_str(wildcards, addr):
260     ip = socket.inet_ntoa(struct.pack('!I', addr))
261     mask = 32 - ((wildcards & ofproto_v1_0.OFPFW_NW_SRC_MASK) >>
262                  ofproto_v1_0.OFPFW_NW_SRC_SHIFT)
263     if mask == 32:
264         mask = 0
265     if mask:
266         ip += '/%d' % mask
267     return ip
268
269
270 def nw_dst_to_str(wildcards, addr):
271     ip = socket.inet_ntoa(struct.pack('!I', addr))
272     mask = 32 - ((wildcards & ofproto_v1_0.OFPFW_NW_DST_MASK) >>
273                  ofproto_v1_0.OFPFW_NW_DST_SHIFT)
274     if mask == 32:
275         mask = 0
276     if mask:
277         ip += '/%d' % mask
278     return ip
279
280
281 def get_desc_stats(dp, waiters):
282     stats = dp.ofproto_parser.OFPDescStatsRequest(dp, 0)
283     msgs = []
284     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
285     s = {}
286
287     for msg in msgs:
288         stats = msg.body
289         s = stats.to_jsondict()[stats.__class__.__name__]
290
291     return {str(dp.id): s}
292
293
294 def get_queue_stats(dp, waiters, port=None, queue_id=None):
295     if port is None:
296         port = dp.ofproto.OFPP_ALL
297     else:
298         port = str_to_int(port)
299
300     if queue_id is None:
301         queue_id = dp.ofproto.OFPQ_ALL
302     else:
303         queue_id = str_to_int(queue_id)
304
305     stats = dp.ofproto_parser.OFPQueueStatsRequest(dp, 0, port,
306                                                    queue_id)
307     msgs = []
308     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
309
310     s = []
311     for msg in msgs:
312         stats = msg.body
313         for stat in stats:
314             s.append({'port_no': stat.port_no,
315                       'queue_id': stat.queue_id,
316                       'tx_bytes': stat.tx_bytes,
317                       'tx_errors': stat.tx_errors,
318                       'tx_packets': stat.tx_packets})
319
320     return {str(dp.id): s}
321
322
323 def get_flow_stats(dp, waiters, flow=None):
324     flow = flow if flow else {}
325     match = to_match(dp, flow.get('match', {}))
326     table_id = UTIL.ofp_table_from_user(
327         flow.get('table_id', 0xff))
328     out_port = UTIL.ofp_port_from_user(
329         flow.get('out_port', dp.ofproto.OFPP_NONE))
330     # Note: OpenFlow does not allow to filter flow entries by priority,
331     # but for efficiency, ofctl provides the way to do it.
332     priority = str_to_int(flow.get('priority', -1))
333
334     stats = dp.ofproto_parser.OFPFlowStatsRequest(
335         dp, 0, match, table_id, out_port)
336
337     msgs = []
338     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
339
340     flows = []
341     for msg in msgs:
342         for stats in msg.body:
343             if 0 <= priority != stats.priority:
344                 continue
345
346             actions = actions_to_str(stats.actions)
347             match = match_to_str(stats.match)
348
349             s = {'priority': stats.priority,
350                  'cookie': stats.cookie,
351                  'idle_timeout': stats.idle_timeout,
352                  'hard_timeout': stats.hard_timeout,
353                  'actions': actions,
354                  'match': match,
355                  'byte_count': stats.byte_count,
356                  'duration_sec': stats.duration_sec,
357                  'duration_nsec': stats.duration_nsec,
358                  'packet_count': stats.packet_count,
359                  'table_id': UTIL.ofp_table_to_user(stats.table_id)}
360             flows.append(s)
361
362     return {str(dp.id): flows}
363
364
365 def get_aggregate_flow_stats(dp, waiters, flow=None):
366     flow = flow if flow else {}
367     match = to_match(dp, flow.get('match', {}))
368     table_id = UTIL.ofp_table_from_user(
369         flow.get('table_id', 0xff))
370     out_port = UTIL.ofp_port_from_user(
371         flow.get('out_port', dp.ofproto.OFPP_NONE))
372
373     stats = dp.ofproto_parser.OFPAggregateStatsRequest(
374         dp, 0, match, table_id, out_port)
375
376     msgs = []
377     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
378
379     flows = []
380     for msg in msgs:
381         stats = msg.body
382         for st in stats:
383             s = {'packet_count': st.packet_count,
384                  'byte_count': st.byte_count,
385                  'flow_count': st.flow_count}
386             flows.append(s)
387
388     return {str(dp.id): flows}
389
390
391 def get_table_stats(dp, waiters):
392     stats = dp.ofproto_parser.OFPTableStatsRequest(dp, 0)
393     ofp = dp.ofproto
394     msgs = []
395     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
396
397     match_convert = {ofp.OFPFW_IN_PORT: 'IN_PORT',
398                      ofp.OFPFW_DL_VLAN: 'DL_VLAN',
399                      ofp.OFPFW_DL_SRC: 'DL_SRC',
400                      ofp.OFPFW_DL_DST: 'DL_DST',
401                      ofp.OFPFW_DL_TYPE: 'DL_TYPE',
402                      ofp.OFPFW_NW_PROTO: 'NW_PROTO',
403                      ofp.OFPFW_TP_SRC: 'TP_SRC',
404                      ofp.OFPFW_TP_DST: 'TP_DST',
405                      ofp.OFPFW_NW_SRC_SHIFT: 'NW_SRC_SHIFT',
406                      ofp.OFPFW_NW_SRC_BITS: 'NW_SRC_BITS',
407                      ofp.OFPFW_NW_SRC_MASK: 'NW_SRC_MASK',
408                      ofp.OFPFW_NW_SRC: 'NW_SRC',
409                      ofp.OFPFW_NW_SRC_ALL: 'NW_SRC_ALL',
410                      ofp.OFPFW_NW_DST_SHIFT: 'NW_DST_SHIFT',
411                      ofp.OFPFW_NW_DST_BITS: 'NW_DST_BITS',
412                      ofp.OFPFW_NW_DST_MASK: 'NW_DST_MASK',
413                      ofp.OFPFW_NW_DST: 'NW_DST',
414                      ofp.OFPFW_NW_DST_ALL: 'NW_DST_ALL',
415                      ofp.OFPFW_DL_VLAN_PCP: 'DL_VLAN_PCP',
416                      ofp.OFPFW_NW_TOS: 'NW_TOS',
417                      ofp.OFPFW_ALL: 'ALL',
418                      ofp.OFPFW_ICMP_TYPE: 'ICMP_TYPE',
419                      ofp.OFPFW_ICMP_CODE: 'ICMP_CODE'}
420
421     tables = []
422     for msg in msgs:
423         stats = msg.body
424         for stat in stats:
425             wildcards = []
426             for k, v in match_convert.items():
427                 if (1 << k) & stat.wildcards:
428                     wildcards.append(v)
429             s = {'table_id': UTIL.ofp_table_to_user(stat.table_id),
430                  'name': stat.name.decode('utf-8'),
431                  'wildcards': wildcards,
432                  'max_entries': stat.max_entries,
433                  'active_count': stat.active_count,
434                  'lookup_count': stat.lookup_count,
435                  'matched_count': stat.matched_count}
436             tables.append(s)
437
438     return {str(dp.id): tables}
439
440
441 def get_port_stats(dp, waiters, port=None):
442     if port is None:
443         port = dp.ofproto.OFPP_NONE
444     else:
445         port = str_to_int(port)
446
447     stats = dp.ofproto_parser.OFPPortStatsRequest(
448         dp, 0, port)
449     msgs = []
450     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
451
452     ports = []
453     for msg in msgs:
454         for stats in msg.body:
455             s = {'port_no': UTIL.ofp_port_to_user(stats.port_no),
456                  'rx_packets': stats.rx_packets,
457                  'tx_packets': stats.tx_packets,
458                  'rx_bytes': stats.rx_bytes,
459                  'tx_bytes': stats.tx_bytes,
460                  'rx_dropped': stats.rx_dropped,
461                  'tx_dropped': stats.tx_dropped,
462                  'rx_errors': stats.rx_errors,
463                  'tx_errors': stats.tx_errors,
464                  'rx_frame_err': stats.rx_frame_err,
465                  'rx_over_err': stats.rx_over_err,
466                  'rx_crc_err': stats.rx_crc_err,
467                  'collisions': stats.collisions}
468             ports.append(s)
469
470     return {str(dp.id): ports}
471
472
473 def get_port_desc(dp, waiters):
474
475     stats = dp.ofproto_parser.OFPFeaturesRequest(dp)
476     msgs = []
477     ofctl_utils.send_stats_request(dp, stats, waiters, msgs, LOG)
478
479     descs = []
480     for msg in msgs:
481         stats = msg.ports
482         for stat in stats.values():
483             d = {'port_no': UTIL.ofp_port_to_user(stat.port_no),
484                  'hw_addr': stat.hw_addr,
485                  'name': stat.name.decode('utf-8'),
486                  'config': stat.config,
487                  'state': stat.state,
488                  'curr': stat.curr,
489                  'advertised': stat.advertised,
490                  'supported': stat.supported,
491                  'peer': stat.peer}
492             descs.append(d)
493
494     return {str(dp.id): descs}
495
496
497 def mod_flow_entry(dp, flow, cmd):
498     cookie = str_to_int(flow.get('cookie', 0))
499     priority = str_to_int(
500         flow.get('priority', dp.ofproto.OFP_DEFAULT_PRIORITY))
501     buffer_id = UTIL.ofp_buffer_from_user(
502         flow.get('buffer_id', dp.ofproto.OFP_NO_BUFFER))
503     out_port = UTIL.ofp_port_from_user(
504         flow.get('out_port', dp.ofproto.OFPP_NONE))
505     flags = str_to_int(flow.get('flags', 0))
506     idle_timeout = str_to_int(flow.get('idle_timeout', 0))
507     hard_timeout = str_to_int(flow.get('hard_timeout', 0))
508     actions = to_actions(dp, flow.get('actions', []))
509     match = to_match(dp, flow.get('match', {}))
510
511     flow_mod = dp.ofproto_parser.OFPFlowMod(
512         datapath=dp, match=match, cookie=cookie,
513         command=cmd, idle_timeout=idle_timeout,
514         hard_timeout=hard_timeout, priority=priority,
515         buffer_id=buffer_id, out_port=out_port,
516         flags=flags,
517         actions=actions)
518
519     ofctl_utils.send_msg(dp, flow_mod, LOG)
520
521
522 def delete_flow_entry(dp):
523     match = dp.ofproto_parser.OFPMatch(
524         dp.ofproto.OFPFW_ALL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
525
526     flow_mod = dp.ofproto_parser.OFPFlowMod(
527         datapath=dp, match=match, cookie=0,
528         command=dp.ofproto.OFPFC_DELETE)
529
530     ofctl_utils.send_msg(dp, flow_mod, LOG)
531
532
533 def mod_port_behavior(dp, port_config):
534     port_no = UTIL.ofp_port_from_user(port_config.get('port_no', 0))
535     hw_addr = str(port_config.get('hw_addr'))
536     config = str_to_int(port_config.get('config', 0))
537     mask = str_to_int(port_config.get('mask', 0))
538     advertise = str_to_int(port_config.get('advertise'))
539
540     port_mod = dp.ofproto_parser.OFPPortMod(
541         dp, port_no, hw_addr, config, mask, advertise)
542
543     ofctl_utils.send_msg(dp, port_mod, LOG)