Se reinstalo ryu para configurar STP y que el restAPI no sea publico(127.0.0.1)
[vsorcdistro/.git] / ryu / ryu / lib / ofctl_utils.py
1 # Copyright (C) 2016 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 base64
17 import logging
18
19 import netaddr
20 import six
21
22 from ryu.lib import dpid
23 from ryu.lib import hub
24 from ryu.ofproto import ofproto_v1_2
25
26
27 LOG = logging.getLogger(__name__)
28 DEFAULT_TIMEOUT = 1.0
29
30 # NOTE(jkoelker) Constants for converting actions
31 OUTPUT = 'OUTPUT'
32 COPY_TTL_OUT = 'COPY_TTL_OUT'
33 COPY_TTL_IN = 'COPY_TTL_IN'
34 SET_MPLS_TTL = 'SET_MPLS_TTL'
35 DEC_MPLS_TTL = 'DEC_MPLS_TTL'
36 PUSH_VLAN = 'PUSH_VLAN'
37 POP_VLAN = 'POP_VLAN'
38 PUSH_MPLS = 'PUSH_MPLS'
39 POP_MPLS = 'POP_MPLS'
40 SET_QUEUE = 'SET_QUEUE'
41 GROUP = 'GROUP'
42 SET_NW_TTL = 'SET_NW_TTL'
43 DEC_NW_TTL = 'DEC_NW_TTL'
44 SET_FIELD = 'SET_FIELD'
45 PUSH_PBB = 'PUSH_PBB'      # OpenFlow 1.3 or later
46 POP_PBB = 'POP_PBB'        # OpenFlow 1.3 or later
47 COPY_FIELD = 'COPY_FIELD'  # OpenFlow 1.5 or later
48 METER = 'METER'            # OpenFlow 1.5 or later
49 EXPERIMENTER = 'EXPERIMENTER'
50
51
52 def get_logger(logger=None):
53     # NOTE(jkoelker) use the logger the calling code wants us to
54     if logger is not None:
55         return logger
56
57     return LOG
58
59
60 def match_vid_to_str(value, mask, ofpvid_present):
61     if mask is not None:
62         return '0x%04x/0x%04x' % (value, mask)
63
64     if value & ofpvid_present:
65         return str(value & ~ofpvid_present)
66
67     return '0x%04x' % value
68
69
70 def to_action(dic, ofp, parser, action_type, util):
71     actions = {COPY_TTL_OUT: parser.OFPActionCopyTtlOut,
72                COPY_TTL_IN: parser.OFPActionCopyTtlIn,
73                DEC_MPLS_TTL: parser.OFPActionDecMplsTtl,
74                POP_VLAN: parser.OFPActionPopVlan,
75                DEC_NW_TTL: parser.OFPActionDecNwTtl}
76     if ofp.OFP_VERSION > ofproto_v1_2.OFP_VERSION:
77         actions[POP_PBB] = parser.OFPActionPopPbb
78
79     need_ethertype = {PUSH_VLAN: parser.OFPActionPushVlan,
80                       PUSH_MPLS: parser.OFPActionPushMpls,
81                       POP_MPLS: parser.OFPActionPopMpls}
82     if ofp.OFP_VERSION > ofproto_v1_2.OFP_VERSION:
83         need_ethertype[PUSH_PBB] = parser.OFPActionPushPbb
84
85     if action_type in actions:
86         return actions[action_type]()
87
88     elif action_type in need_ethertype:
89         ethertype = str_to_int(dic.get('ethertype'))
90         return need_ethertype[action_type](ethertype)
91
92     elif action_type == OUTPUT:
93         out_port = util.ofp_port_from_user(dic.get('port', ofp.OFPP_ANY))
94         max_len = util.ofp_cml_from_user(dic.get('max_len', ofp.OFPCML_MAX))
95         return parser.OFPActionOutput(out_port, max_len)
96
97     elif action_type == SET_MPLS_TTL:
98         mpls_ttl = str_to_int(dic.get('mpls_ttl'))
99         return parser.OFPActionSetMplsTtl(mpls_ttl)
100
101     elif action_type == SET_QUEUE:
102         queue_id = util.ofp_queue_from_user(dic.get('queue_id'))
103         return parser.OFPActionSetQueue(queue_id)
104
105     elif action_type == GROUP:
106         group_id = util.ofp_group_from_user(dic.get('group_id'))
107         return parser.OFPActionGroup(group_id)
108
109     elif action_type == SET_NW_TTL:
110         nw_ttl = str_to_int(dic.get('nw_ttl'))
111         return parser.OFPActionSetNwTtl(nw_ttl)
112
113     elif action_type == SET_FIELD:
114         field = dic.get('field')
115         value = dic.get('value')
116         return parser.OFPActionSetField(**{field: value})
117
118     elif action_type == 'COPY_FIELD':
119         n_bits = str_to_int(dic.get('n_bits'))
120         src_offset = str_to_int(dic.get('src_offset'))
121         dst_offset = str_to_int(dic.get('dst_offset'))
122         oxm_ids = [parser.OFPOxmId(str(dic.get('src_oxm_id'))),
123                    parser.OFPOxmId(str(dic.get('dst_oxm_id')))]
124         return parser.OFPActionCopyField(
125             n_bits, src_offset, dst_offset, oxm_ids)
126
127     elif action_type == 'METER':
128         if hasattr(parser, 'OFPActionMeter'):
129             # OpenFlow 1.5 or later
130             meter_id = str_to_int(dic.get('meter_id'))
131             return parser.OFPActionMeter(meter_id)
132         else:
133             # OpenFlow 1.4 or earlier
134             return None
135
136     elif action_type == EXPERIMENTER:
137         experimenter = str_to_int(dic.get('experimenter'))
138         data_type = dic.get('data_type', 'ascii')
139
140         if data_type not in ('ascii', 'base64'):
141             LOG.error('Unknown data type: %s', data_type)
142             return None
143
144         data = dic.get('data', '')
145         if data_type == 'base64':
146             data = base64.b64decode(data)
147         return parser.OFPActionExperimenterUnknown(experimenter, data)
148
149     return None
150
151
152 def to_match_eth(value):
153     if '/' in value:
154         value = value.split('/')
155         return value[0], value[1]
156
157     return value
158
159
160 def to_match_ip(value):
161     if '/' in value:
162         (ip_addr, ip_mask) = value.split('/')
163
164         if ip_mask.isdigit():
165             ip = netaddr.ip.IPNetwork(value)
166             ip_addr = str(ip.ip)
167             ip_mask = str(ip.netmask)
168
169         return ip_addr, ip_mask
170
171     return value
172
173
174 def to_match_vid(value, ofpvid_present):
175     # NOTE: If "vlan_id" field is described as decimal int value
176     #       (and decimal string value), it is treated as values of
177     #       VLAN tag, and OFPVID_PRESENT(0x1000) bit is automatically
178     #       applied. OTOH, If it is described as hexadecimal string,
179     #       treated as values of oxm_value (including OFPVID_PRESENT
180     #       bit), and OFPVID_PRESENT bit is NOT automatically applied
181     if isinstance(value, six.integer_types):
182         # described as decimal int value
183         return value | ofpvid_present
184
185     else:
186         if '/' in value:
187             val = value.split('/')
188             return str_to_int(val[0]), str_to_int(val[1])
189
190         else:
191             if value.isdigit():
192                 # described as decimal string value
193                 return int(value, 10) | ofpvid_present
194
195             return str_to_int(value)
196
197
198 def to_match_masked_int(value):
199     if isinstance(value, str) and '/' in value:
200         value = value.split('/')
201         return str_to_int(value[0]), str_to_int(value[1])
202
203     return str_to_int(value)
204
205
206 def to_match_packet_type(value):
207     if isinstance(value, (list, tuple)):
208         return str_to_int(value[0]) << 16 | str_to_int(value[1])
209     else:
210         return str_to_int(value)
211
212
213 def send_experimenter(dp, exp, logger=None):
214     experimenter = exp.get('experimenter', 0)
215     exp_type = exp.get('exp_type', 0)
216     data_type = exp.get('data_type', 'ascii')
217
218     data = exp.get('data', '')
219     if data_type == 'base64':
220         data = base64.b64decode(data)
221     elif data_type == 'ascii':
222         data = data.encode('ascii')
223     else:
224         get_logger(logger).error('Unknown data type: %s', data_type)
225         return
226
227     expmsg = dp.ofproto_parser.OFPExperimenter(
228         dp, experimenter, exp_type, data)
229     send_msg(dp, expmsg, logger)
230
231
232 def send_msg(dp, msg, logger=None):
233     if msg.xid is None:
234         dp.set_xid(msg)
235
236     log = get_logger(logger)
237     # NOTE(jkoelker) Prevent unnecessary string formating by including the
238     #                format rules in the log_msg
239     log_msg = ('Sending message with xid(%x) to '
240                'datapath(' + dpid._DPID_FMT + '): %s')
241     log.debug(log_msg, msg.xid, dp.id, msg)
242     dp.send_msg(msg)
243
244
245 def send_stats_request(dp, stats, waiters, msgs, logger=None):
246     dp.set_xid(stats)
247     waiters_per_dp = waiters.setdefault(dp.id, {})
248     lock = hub.Event()
249     previous_msg_len = len(msgs)
250     waiters_per_dp[stats.xid] = (lock, msgs)
251     send_msg(dp, stats, logger)
252
253     lock.wait(timeout=DEFAULT_TIMEOUT)
254     current_msg_len = len(msgs)
255
256     while current_msg_len > previous_msg_len:
257         previous_msg_len = current_msg_len
258         lock.wait(timeout=DEFAULT_TIMEOUT)
259         current_msg_len = len(msgs)
260
261     if not lock.is_set():
262         del waiters_per_dp[stats.xid]
263
264
265 def str_to_int(str_num):
266     return int(str(str_num), 0)
267
268
269 def get_role(dp, waiters, to_user):
270     stats = dp.ofproto_parser.OFPRoleRequest(
271         dp, dp.ofproto.OFPCR_ROLE_NOCHANGE, generation_id=0)
272     msgs = []
273     send_stats_request(dp, stats, waiters, msgs, LOG)
274     descs = []
275
276     for msg in msgs:
277         d = msg.to_jsondict()[msg.__class__.__name__]
278         if to_user:
279             d['role'] = OFCtlUtil(dp.ofproto).ofp_role_to_user(d['role'])
280         descs.append(d)
281
282     return {str(dp.id): descs}
283
284
285 class OFCtlUtil(object):
286
287     def __init__(self, ofproto):
288         self.ofproto = ofproto
289         self.deprecated_value = [
290             'OFPTFPT_EXPERIMENTER_SLAVE',
291             'OFPTFPT_EXPERIMENTER_MASTER',
292             'OFPQCFC_EPERM']
293
294     def _reserved_num_from_user(self, num, prefix):
295         try:
296             return str_to_int(num)
297         except ValueError:
298             try:
299                 if num.startswith(prefix):
300                     return getattr(self.ofproto, num.upper())
301                 else:
302                     return getattr(self.ofproto, prefix + num.upper())
303             except AttributeError:
304                 LOG.warning(
305                     "Cannot convert argument to reserved number: %s", num)
306         return num
307
308     def _reserved_num_to_user(self, num, prefix):
309         for k, v in self.ofproto.__dict__.items():
310             if k not in self.deprecated_value and \
311                k.startswith(prefix) and v == num:
312                 return k.replace(prefix, '')
313         return num
314
315     def ofp_port_features_from_user(self, act):
316         return self._reserved_num_from_user(act, 'OFPPF_')
317
318     def ofp_port_features_to_user(self, act):
319         return self._reserved_num_to_user(act, 'OFPPF_')
320
321     def ofp_port_mod_prop_type_from_user(self, act):
322         return self._reserved_num_from_user(act, 'OFPPMPT_')
323
324     def ofp_port_mod_prop_type_to_user(self, act):
325         return self._reserved_num_to_user(act, 'OFPPMPT_')
326
327     def ofp_port_desc_prop_type_from_user(self, act):
328         return self._reserved_num_from_user(act, 'OFPPDPT_')
329
330     def ofp_port_desc_prop_type_to_user(self, act):
331         return self._reserved_num_to_user(act, 'OFPPDPT_')
332
333     def ofp_action_type_from_user(self, act):
334         return self._reserved_num_from_user(act, 'OFPAT_')
335
336     def ofp_action_type_to_user(self, act):
337         return self._reserved_num_to_user(act, 'OFPAT_')
338
339     def ofp_instruction_type_from_user(self, act):
340         return self._reserved_num_from_user(act, 'OFPIT_')
341
342     def ofp_instruction_type_to_user(self, act):
343         return self._reserved_num_to_user(act, 'OFPIT_')
344
345     def ofp_group_type_from_user(self, act):
346         return self._reserved_num_from_user(act, 'OFPGT_')
347
348     def ofp_group_type_to_user(self, act):
349         return self._reserved_num_to_user(act, 'OFPGT_')
350
351     def ofp_meter_band_type_from_user(self, act):
352         return self._reserved_num_from_user(act, 'OFPMBT_')
353
354     def ofp_meter_band_type_to_user(self, act):
355         return self._reserved_num_to_user(act, 'OFPMBT_')
356
357     def ofp_table_feature_prop_type_from_user(self, act):
358         return self._reserved_num_from_user(act, 'OFPTFPT_')
359
360     def ofp_table_feature_prop_type_to_user(self, act):
361         return self._reserved_num_to_user(act, 'OFPTFPT_')
362
363     def ofp_port_stats_prop_type_from_user(self, act):
364         return self._reserved_num_from_user(act, 'OFPPSPT_')
365
366     def ofp_port_stats_prop_type_to_user(self, act):
367         return self._reserved_num_to_user(act, 'OFPPSPT_')
368
369     def ofp_queue_desc_prop_type_from_user(self, act):
370         return self._reserved_num_from_user(act, 'OFPQDPT_')
371
372     def ofp_queue_desc_prop_type_to_user(self, act):
373         return self._reserved_num_to_user(act, 'OFPQDPT_')
374
375     def ofp_queue_stats_prop_type_from_user(self, act):
376         return self._reserved_num_from_user(act, 'OFPQSPT_')
377
378     def ofp_queue_stats_prop_type_to_user(self, act):
379         return self._reserved_num_to_user(act, 'OFPQSPT_')
380
381     def ofp_meter_flags_from_user(self, act):
382         return self._reserved_num_from_user(act, 'OFPMF_')
383
384     def ofp_meter_flags_to_user(self, act):
385         return self._reserved_num_to_user(act, 'OFPMF_')
386
387     def ofp_port_from_user(self, port):
388         return self._reserved_num_from_user(port, 'OFPP_')
389
390     def ofp_port_to_user(self, port):
391         return self._reserved_num_to_user(port, 'OFPP_')
392
393     def ofp_table_from_user(self, table):
394         return self._reserved_num_from_user(table, 'OFPTT_')
395
396     def ofp_table_to_user(self, table):
397         return self._reserved_num_to_user(table, 'OFPTT_')
398
399     def ofp_cml_from_user(self, max_len):
400         return self._reserved_num_from_user(max_len, 'OFPCML_')
401
402     def ofp_cml_to_user(self, max_len):
403         return self._reserved_num_to_user(max_len, 'OFPCML_')
404
405     def ofp_group_from_user(self, group):
406         return self._reserved_num_from_user(group, 'OFPG_')
407
408     def ofp_group_to_user(self, group):
409         return self._reserved_num_to_user(group, 'OFPG_')
410
411     def ofp_group_capabilities_from_user(self, group):
412         return self._reserved_num_from_user(group, 'OFPGFC_')
413
414     def ofp_group_capabilities_to_user(self, group):
415         return self._reserved_num_to_user(group, 'OFPGFC_')
416
417     def ofp_group_bucket_prop_type_from_user(self, group):
418         return self._reserved_num_from_user(group, 'OFPGBPT_')
419
420     def ofp_group_bucket_prop_type_to_user(self, group):
421         return self._reserved_num_to_user(group, 'OFPGBPT_')
422
423     def ofp_buffer_from_user(self, buffer):
424         if buffer in ['OFP_NO_BUFFER', 'NO_BUFFER']:
425             return self.ofproto.OFP_NO_BUFFER
426         else:
427             return buffer
428
429     def ofp_buffer_to_user(self, buffer):
430         if self.ofproto.OFP_NO_BUFFER == buffer:
431             return 'NO_BUFFER'
432         else:
433             return buffer
434
435     def ofp_meter_from_user(self, meter):
436         return self._reserved_num_from_user(meter, 'OFPM_')
437
438     def ofp_meter_to_user(self, meter):
439         return self._reserved_num_to_user(meter, 'OFPM_')
440
441     def ofp_queue_from_user(self, queue):
442         return self._reserved_num_from_user(queue, 'OFPQ_')
443
444     def ofp_queue_to_user(self, queue):
445         return self._reserved_num_to_user(queue, 'OFPQ_')
446
447     def ofp_role_from_user(self, role):
448         return self._reserved_num_from_user(role, 'OFPCR_ROLE_')
449
450     def ofp_role_to_user(self, role):
451         return self._reserved_num_to_user(role, 'OFPCR_ROLE_')