1932 lines
69 KiB
Python
1932 lines
69 KiB
Python
# Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
|
|
import logging
|
|
import numbers
|
|
import socket
|
|
import struct
|
|
|
|
import json
|
|
|
|
from os_ken.app.wsgi import ControllerBase
|
|
from os_ken.app.wsgi import Response
|
|
from os_ken.app.wsgi import WSGIApplication
|
|
from os_ken.base import app_manager
|
|
from os_ken.controller import dpset
|
|
from os_ken.controller import ofp_event
|
|
from os_ken.controller.handler import set_ev_cls
|
|
from os_ken.controller.handler import MAIN_DISPATCHER
|
|
from os_ken.exception import OFPUnknownVersion
|
|
from os_ken.exception import RyuException
|
|
from os_ken.lib import dpid as dpid_lib
|
|
from os_ken.lib import hub
|
|
from os_ken.lib import mac as mac_lib
|
|
from os_ken.lib import addrconv
|
|
from os_ken.lib.packet import arp
|
|
from os_ken.lib.packet import ethernet
|
|
from os_ken.lib.packet import icmp
|
|
from os_ken.lib.packet import ipv4
|
|
from os_ken.lib.packet import packet
|
|
from os_ken.lib.packet import packet_base
|
|
from os_ken.lib.packet import tcp
|
|
from os_ken.lib.packet import udp
|
|
from os_ken.lib.packet import vlan
|
|
from os_ken.ofproto import ether
|
|
from os_ken.ofproto import inet
|
|
from os_ken.ofproto import ofproto_v1_0
|
|
from os_ken.ofproto import ofproto_v1_2
|
|
from os_ken.ofproto import ofproto_v1_3
|
|
|
|
|
|
# =============================
|
|
# REST API
|
|
# =============================
|
|
#
|
|
# Note: specify switch and vlan group, as follows.
|
|
# {switch_id} : 'all' or switchID
|
|
# {vlan_id} : 'all' or vlanID
|
|
#
|
|
|
|
# 1. get address data and routing data.
|
|
#
|
|
# * get data of no vlan
|
|
# GET /router/{switch_id}
|
|
#
|
|
# * get data of specific vlan group
|
|
# GET /router/{switch_id}/{vlan_id}
|
|
#
|
|
|
|
# 2. set address data or routing data.
|
|
#
|
|
# * set data of no vlan
|
|
# POST /router/{switch_id}
|
|
#
|
|
# * set data of specific vlan group
|
|
# POST /router/{switch_id}/{vlan_id}
|
|
#
|
|
# case1: set address data.
|
|
# parameter = {"address": "A.B.C.D/M"}
|
|
# case2-1: set static route.
|
|
# parameter = {"destination": "A.B.C.D/M", "gateway": "E.F.G.H"}
|
|
# case2-2: set default route.
|
|
# parameter = {"gateway": "E.F.G.H"}
|
|
#
|
|
|
|
# 3. delete address data or routing data.
|
|
#
|
|
# * delete data of no vlan
|
|
# DELETE /router/{switch_id}
|
|
#
|
|
# * delete data of specific vlan group
|
|
# DELETE /router/{switch_id}/{vlan_id}
|
|
#
|
|
# case1: delete address data.
|
|
# parameter = {"address_id": "<int>"} or {"address_id": "all"}
|
|
# case2: delete routing data.
|
|
# parameter = {"route_id": "<int>"} or {"route_id": "all"}
|
|
#
|
|
#
|
|
|
|
|
|
UINT16_MAX = 0xffff
|
|
UINT32_MAX = 0xffffffff
|
|
UINT64_MAX = 0xffffffffffffffff
|
|
|
|
ETHERNET = ethernet.ethernet.__name__
|
|
VLAN = vlan.vlan.__name__
|
|
IPV4 = ipv4.ipv4.__name__
|
|
ARP = arp.arp.__name__
|
|
ICMP = icmp.icmp.__name__
|
|
TCP = tcp.tcp.__name__
|
|
UDP = udp.udp.__name__
|
|
|
|
MAX_SUSPENDPACKETS = 50 # Threshold of the packet suspends thread count.
|
|
|
|
ARP_REPLY_TIMER = 2 # sec
|
|
OFP_REPLY_TIMER = 1.0 # sec
|
|
CHK_ROUTING_TBL_INTERVAL = 1800 # sec
|
|
|
|
SWITCHID_PATTERN = dpid_lib.DPID_PATTERN + r'|all'
|
|
VLANID_PATTERN = r'[0-9]{1,4}|all'
|
|
|
|
VLANID_NONE = 0
|
|
VLANID_MIN = 2
|
|
VLANID_MAX = 4094
|
|
|
|
COOKIE_DEFAULT_ID = 0
|
|
COOKIE_SHIFT_VLANID = 32
|
|
COOKIE_SHIFT_ROUTEID = 16
|
|
|
|
DEFAULT_ROUTE = '0.0.0.0/0'
|
|
IDLE_TIMEOUT = 1800 # sec
|
|
DEFAULT_TTL = 64
|
|
|
|
REST_COMMAND_RESULT = 'command_result'
|
|
REST_RESULT = 'result'
|
|
REST_DETAILS = 'details'
|
|
REST_OK = 'success'
|
|
REST_NG = 'failure'
|
|
REST_ALL = 'all'
|
|
REST_SWITCHID = 'switch_id'
|
|
REST_VLANID = 'vlan_id'
|
|
REST_NW = 'internal_network'
|
|
REST_ADDRESSID = 'address_id'
|
|
REST_ADDRESS = 'address'
|
|
REST_ROUTEID = 'route_id'
|
|
REST_ROUTE = 'route'
|
|
REST_DESTINATION = 'destination'
|
|
REST_GATEWAY = 'gateway'
|
|
|
|
PRIORITY_VLAN_SHIFT = 1000
|
|
PRIORITY_NETMASK_SHIFT = 32
|
|
|
|
PRIORITY_NORMAL = 0
|
|
PRIORITY_ARP_HANDLING = 1
|
|
PRIORITY_DEFAULT_ROUTING = 1
|
|
PRIORITY_MAC_LEARNING = 2
|
|
PRIORITY_STATIC_ROUTING = 2
|
|
PRIORITY_IMPLICIT_ROUTING = 3
|
|
PRIORITY_L2_SWITCHING = 4
|
|
PRIORITY_IP_HANDLING = 5
|
|
|
|
PRIORITY_TYPE_ROUTE = 'priority_route'
|
|
|
|
|
|
def get_priority(priority_type, vid=0, route=None):
|
|
log_msg = None
|
|
priority = priority_type
|
|
|
|
if priority_type == PRIORITY_TYPE_ROUTE:
|
|
assert route is not None
|
|
if route.dst_ip:
|
|
priority_type = PRIORITY_STATIC_ROUTING
|
|
priority = priority_type + route.netmask
|
|
log_msg = 'static routing'
|
|
else:
|
|
priority_type = PRIORITY_DEFAULT_ROUTING
|
|
priority = priority_type
|
|
log_msg = 'default routing'
|
|
|
|
if vid or priority_type == PRIORITY_IP_HANDLING:
|
|
priority += PRIORITY_VLAN_SHIFT
|
|
|
|
if priority_type > PRIORITY_STATIC_ROUTING:
|
|
priority += PRIORITY_NETMASK_SHIFT
|
|
|
|
if log_msg is None:
|
|
return priority
|
|
else:
|
|
return priority, log_msg
|
|
|
|
|
|
def get_priority_type(priority, vid):
|
|
if vid:
|
|
priority -= PRIORITY_VLAN_SHIFT
|
|
return priority
|
|
|
|
|
|
class NotFoundError(RyuException):
|
|
message = 'Router SW is not connected. : switch_id=%(switch_id)s'
|
|
|
|
|
|
class CommandFailure(RyuException):
|
|
pass
|
|
|
|
|
|
class RestRouterAPI(app_manager.RyuApp):
|
|
|
|
OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION,
|
|
ofproto_v1_2.OFP_VERSION,
|
|
ofproto_v1_3.OFP_VERSION]
|
|
|
|
_CONTEXTS = {'dpset': dpset.DPSet,
|
|
'wsgi': WSGIApplication}
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(RestRouterAPI, self).__init__(*args, **kwargs)
|
|
|
|
# logger configure
|
|
RouterController.set_logger(self.logger)
|
|
|
|
wsgi = kwargs['wsgi']
|
|
self.waiters = {}
|
|
self.data = {'waiters': self.waiters}
|
|
|
|
mapper = wsgi.mapper
|
|
wsgi.registory['RouterController'] = self.data
|
|
requirements = {'switch_id': SWITCHID_PATTERN,
|
|
'vlan_id': VLANID_PATTERN}
|
|
|
|
# For no vlan data
|
|
path = '/router/{switch_id}'
|
|
mapper.connect('router', path, controller=RouterController,
|
|
requirements=requirements,
|
|
action='get_data',
|
|
conditions=dict(method=['GET']))
|
|
mapper.connect('router', path, controller=RouterController,
|
|
requirements=requirements,
|
|
action='set_data',
|
|
conditions=dict(method=['POST']))
|
|
mapper.connect('router', path, controller=RouterController,
|
|
requirements=requirements,
|
|
action='delete_data',
|
|
conditions=dict(method=['DELETE']))
|
|
# For vlan data
|
|
path = '/router/{switch_id}/{vlan_id}'
|
|
mapper.connect('router', path, controller=RouterController,
|
|
requirements=requirements,
|
|
action='get_vlan_data',
|
|
conditions=dict(method=['GET']))
|
|
mapper.connect('router', path, controller=RouterController,
|
|
requirements=requirements,
|
|
action='set_vlan_data',
|
|
conditions=dict(method=['POST']))
|
|
mapper.connect('router', path, controller=RouterController,
|
|
requirements=requirements,
|
|
action='delete_vlan_data',
|
|
conditions=dict(method=['DELETE']))
|
|
|
|
@set_ev_cls(dpset.EventDP, dpset.DPSET_EV_DISPATCHER)
|
|
def datapath_handler(self, ev):
|
|
if ev.enter:
|
|
RouterController.register_router(ev.dp)
|
|
else:
|
|
RouterController.unregister_router(ev.dp)
|
|
|
|
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
|
|
def packet_in_handler(self, ev):
|
|
RouterController.packet_in_handler(ev.msg)
|
|
|
|
def _stats_reply_handler(self, ev):
|
|
msg = ev.msg
|
|
dp = msg.datapath
|
|
|
|
if (dp.id not in self.waiters
|
|
or msg.xid not in self.waiters[dp.id]):
|
|
return
|
|
event, msgs = self.waiters[dp.id][msg.xid]
|
|
msgs.append(msg)
|
|
|
|
if ofproto_v1_3.OFP_VERSION == dp.ofproto.OFP_VERSION:
|
|
more = dp.ofproto.OFPMPF_REPLY_MORE
|
|
else:
|
|
more = dp.ofproto.OFPSF_REPLY_MORE
|
|
if msg.flags & more:
|
|
return
|
|
del self.waiters[dp.id][msg.xid]
|
|
event.set()
|
|
|
|
# for OpenFlow version1.0
|
|
@set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
|
|
def stats_reply_handler_v1_0(self, ev):
|
|
self._stats_reply_handler(ev)
|
|
|
|
# for OpenFlow version1.2/1.3
|
|
@set_ev_cls(ofp_event.EventOFPStatsReply, MAIN_DISPATCHER)
|
|
def stats_reply_handler_v1_2(self, ev):
|
|
self._stats_reply_handler(ev)
|
|
|
|
# TODO: Update routing table when port status is changed.
|
|
|
|
|
|
# REST command template
|
|
def rest_command(func):
|
|
def _rest_command(*args, **kwargs):
|
|
try:
|
|
msg = func(*args, **kwargs)
|
|
return Response(content_type='application/json',
|
|
body=json.dumps(msg))
|
|
|
|
except SyntaxError as e:
|
|
status = 400
|
|
details = e.msg
|
|
except (ValueError, NameError) as e:
|
|
status = 400
|
|
details = e.message
|
|
|
|
except NotFoundError as msg:
|
|
status = 404
|
|
details = str(msg)
|
|
|
|
msg = {REST_RESULT: REST_NG,
|
|
REST_DETAILS: details}
|
|
return Response(status=status, body=json.dumps(msg))
|
|
|
|
return _rest_command
|
|
|
|
|
|
class RouterController(ControllerBase):
|
|
|
|
_ROUTER_LIST = {}
|
|
_LOGGER = None
|
|
|
|
def __init__(self, req, link, data, **config):
|
|
super(RouterController, self).__init__(req, link, data, **config)
|
|
self.waiters = data['waiters']
|
|
|
|
@classmethod
|
|
def set_logger(cls, logger):
|
|
cls._LOGGER = logger
|
|
cls._LOGGER.propagate = False
|
|
hdlr = logging.StreamHandler()
|
|
fmt_str = '[RT][%(levelname)s] switch_id=%(sw_id)s: %(message)s'
|
|
hdlr.setFormatter(logging.Formatter(fmt_str))
|
|
cls._LOGGER.addHandler(hdlr)
|
|
|
|
@classmethod
|
|
def register_router(cls, dp):
|
|
dpid = {'sw_id': dpid_lib.dpid_to_str(dp.id)}
|
|
try:
|
|
router = Router(dp, cls._LOGGER)
|
|
except OFPUnknownVersion as message:
|
|
cls._LOGGER.error(str(message), extra=dpid)
|
|
return
|
|
cls._ROUTER_LIST.setdefault(dp.id, router)
|
|
cls._LOGGER.info('Join as router.', extra=dpid)
|
|
|
|
@classmethod
|
|
def unregister_router(cls, dp):
|
|
if dp.id in cls._ROUTER_LIST:
|
|
cls._ROUTER_LIST[dp.id].delete()
|
|
del cls._ROUTER_LIST[dp.id]
|
|
|
|
dpid = {'sw_id': dpid_lib.dpid_to_str(dp.id)}
|
|
cls._LOGGER.info('Leave router.', extra=dpid)
|
|
|
|
@classmethod
|
|
def packet_in_handler(cls, msg):
|
|
dp_id = msg.datapath.id
|
|
if dp_id in cls._ROUTER_LIST:
|
|
router = cls._ROUTER_LIST[dp_id]
|
|
router.packet_in_handler(msg)
|
|
|
|
# GET /router/{switch_id}
|
|
@rest_command
|
|
def get_data(self, req, switch_id, **_kwargs):
|
|
return self._access_router(switch_id, VLANID_NONE,
|
|
'get_data', req)
|
|
|
|
# GET /router/{switch_id}/{vlan_id}
|
|
@rest_command
|
|
def get_vlan_data(self, req, switch_id, vlan_id, **_kwargs):
|
|
return self._access_router(switch_id, vlan_id,
|
|
'get_data', req)
|
|
|
|
# POST /router/{switch_id}
|
|
@rest_command
|
|
def set_data(self, req, switch_id, **_kwargs):
|
|
return self._access_router(switch_id, VLANID_NONE,
|
|
'set_data', req)
|
|
|
|
# POST /router/{switch_id}/{vlan_id}
|
|
@rest_command
|
|
def set_vlan_data(self, req, switch_id, vlan_id, **_kwargs):
|
|
return self._access_router(switch_id, vlan_id,
|
|
'set_data', req)
|
|
|
|
# DELETE /router/{switch_id}
|
|
@rest_command
|
|
def delete_data(self, req, switch_id, **_kwargs):
|
|
return self._access_router(switch_id, VLANID_NONE,
|
|
'delete_data', req)
|
|
|
|
# DELETE /router/{switch_id}/{vlan_id}
|
|
@rest_command
|
|
def delete_vlan_data(self, req, switch_id, vlan_id, **_kwargs):
|
|
return self._access_router(switch_id, vlan_id,
|
|
'delete_data', req)
|
|
|
|
def _access_router(self, switch_id, vlan_id, func, req):
|
|
rest_message = []
|
|
routers = self._get_router(switch_id)
|
|
try:
|
|
param = req.json if req.body else {}
|
|
except ValueError:
|
|
raise SyntaxError('invalid syntax %s', req.body)
|
|
for router in routers.values():
|
|
function = getattr(router, func)
|
|
data = function(vlan_id, param, self.waiters)
|
|
rest_message.append(data)
|
|
|
|
return rest_message
|
|
|
|
def _get_router(self, switch_id):
|
|
routers = {}
|
|
|
|
if switch_id == REST_ALL:
|
|
routers = self._ROUTER_LIST
|
|
else:
|
|
sw_id = dpid_lib.str_to_dpid(switch_id)
|
|
if sw_id in self._ROUTER_LIST:
|
|
routers = {sw_id: self._ROUTER_LIST[sw_id]}
|
|
|
|
if routers:
|
|
return routers
|
|
else:
|
|
raise NotFoundError(switch_id=switch_id)
|
|
|
|
|
|
class Router(dict):
|
|
def __init__(self, dp, logger):
|
|
super(Router, self).__init__()
|
|
self.dp = dp
|
|
self.dpid_str = dpid_lib.dpid_to_str(dp.id)
|
|
self.sw_id = {'sw_id': self.dpid_str}
|
|
self.logger = logger
|
|
|
|
self.port_data = PortData(dp.ports)
|
|
|
|
ofctl = OfCtl.factory(dp, logger)
|
|
cookie = COOKIE_DEFAULT_ID
|
|
|
|
# Set SW config: TTL error packet in (for OFPv1.2/1.3)
|
|
ofctl.set_sw_config_for_ttl()
|
|
|
|
# Set flow: ARP handling (packet in)
|
|
priority = get_priority(PRIORITY_ARP_HANDLING)
|
|
ofctl.set_packetin_flow(cookie, priority, dl_type=ether.ETH_TYPE_ARP)
|
|
self.logger.info('Set ARP handling (packet in) flow [cookie=0x%x]',
|
|
cookie, extra=self.sw_id)
|
|
|
|
# Set flow: L2 switching (normal)
|
|
priority = get_priority(PRIORITY_NORMAL)
|
|
ofctl.set_normal_flow(cookie, priority)
|
|
self.logger.info('Set L2 switching (normal) flow [cookie=0x%x]',
|
|
cookie, extra=self.sw_id)
|
|
|
|
# Set VlanRouter for vid=None.
|
|
vlan_router = VlanRouter(VLANID_NONE, dp, self.port_data, logger)
|
|
self[VLANID_NONE] = vlan_router
|
|
|
|
# Start cyclic routing table check.
|
|
self.thread = hub.spawn(self._cyclic_update_routing_tbl)
|
|
self.logger.info('Start cyclic routing table update.',
|
|
extra=self.sw_id)
|
|
|
|
def delete(self):
|
|
hub.kill(self.thread)
|
|
self.thread.wait()
|
|
self.logger.info('Stop cyclic routing table update.',
|
|
extra=self.sw_id)
|
|
|
|
def _get_vlan_router(self, vlan_id):
|
|
vlan_routers = []
|
|
|
|
if vlan_id == REST_ALL:
|
|
vlan_routers = list(self.values())
|
|
else:
|
|
vlan_id = int(vlan_id)
|
|
if (vlan_id != VLANID_NONE and
|
|
(vlan_id < VLANID_MIN or VLANID_MAX < vlan_id)):
|
|
msg = 'Invalid {vlan_id} value. Set [%d-%d]'
|
|
raise ValueError(msg % (VLANID_MIN, VLANID_MAX))
|
|
elif vlan_id in self:
|
|
vlan_routers = [self[vlan_id]]
|
|
|
|
return vlan_routers
|
|
|
|
def _add_vlan_router(self, vlan_id):
|
|
vlan_id = int(vlan_id)
|
|
if vlan_id not in self:
|
|
vlan_router = VlanRouter(vlan_id, self.dp, self.port_data,
|
|
self.logger)
|
|
self[vlan_id] = vlan_router
|
|
return self[vlan_id]
|
|
|
|
def _del_vlan_router(self, vlan_id, waiters):
|
|
# Remove unnecessary VlanRouter.
|
|
if vlan_id == VLANID_NONE:
|
|
return
|
|
|
|
vlan_router = self[vlan_id]
|
|
if (len(vlan_router.address_data) == 0
|
|
and len(vlan_router.routing_tbl) == 0):
|
|
vlan_router.delete(waiters)
|
|
del self[vlan_id]
|
|
|
|
def get_data(self, vlan_id, dummy1, dummy2):
|
|
vlan_routers = self._get_vlan_router(vlan_id)
|
|
if vlan_routers:
|
|
msgs = [vlan_router.get_data() for vlan_router in vlan_routers]
|
|
else:
|
|
msgs = [{REST_VLANID: vlan_id}]
|
|
|
|
return {REST_SWITCHID: self.dpid_str,
|
|
REST_NW: msgs}
|
|
|
|
def set_data(self, vlan_id, param, waiters):
|
|
vlan_routers = self._get_vlan_router(vlan_id)
|
|
if not vlan_routers:
|
|
vlan_routers = [self._add_vlan_router(vlan_id)]
|
|
|
|
msgs = []
|
|
for vlan_router in vlan_routers:
|
|
try:
|
|
msg = vlan_router.set_data(param)
|
|
msgs.append(msg)
|
|
if msg[REST_RESULT] == REST_NG:
|
|
# Data setting is failure.
|
|
self._del_vlan_router(vlan_router.vlan_id, waiters)
|
|
except ValueError as err_msg:
|
|
# Data setting is failure.
|
|
self._del_vlan_router(vlan_router.vlan_id, waiters)
|
|
raise err_msg
|
|
|
|
return {REST_SWITCHID: self.dpid_str,
|
|
REST_COMMAND_RESULT: msgs}
|
|
|
|
def delete_data(self, vlan_id, param, waiters):
|
|
msgs = []
|
|
vlan_routers = self._get_vlan_router(vlan_id)
|
|
if vlan_routers:
|
|
for vlan_router in vlan_routers:
|
|
msg = vlan_router.delete_data(param, waiters)
|
|
if msg:
|
|
msgs.append(msg)
|
|
# Check unnecessary VlanRouter.
|
|
self._del_vlan_router(vlan_router.vlan_id, waiters)
|
|
if not msgs:
|
|
msgs = [{REST_RESULT: REST_NG,
|
|
REST_DETAILS: 'Data is nothing.'}]
|
|
|
|
return {REST_SWITCHID: self.dpid_str,
|
|
REST_COMMAND_RESULT: msgs}
|
|
|
|
def packet_in_handler(self, msg):
|
|
pkt = packet.Packet(msg.data)
|
|
# TODO: Packet library convert to string
|
|
# self.logger.debug('Packet in = %s', str(pkt), self.sw_id)
|
|
header_list = dict((p.protocol_name, p)
|
|
for p in pkt.protocols
|
|
if isinstance(p, packet_base.PacketBase))
|
|
if header_list:
|
|
# Check vlan-tag
|
|
vlan_id = VLANID_NONE
|
|
if VLAN in header_list:
|
|
vlan_id = header_list[VLAN].vid
|
|
|
|
# Event dispatch
|
|
if vlan_id in self:
|
|
self[vlan_id].packet_in_handler(msg, header_list)
|
|
else:
|
|
self.logger.debug('Drop unknown vlan packet. [vlan_id=%d]',
|
|
vlan_id, extra=self.sw_id)
|
|
|
|
def _cyclic_update_routing_tbl(self):
|
|
while True:
|
|
# send ARP to all gateways.
|
|
for vlan_router in self.values():
|
|
vlan_router.send_arp_all_gw()
|
|
hub.sleep(1)
|
|
|
|
hub.sleep(CHK_ROUTING_TBL_INTERVAL)
|
|
|
|
|
|
class VlanRouter(object):
|
|
def __init__(self, vlan_id, dp, port_data, logger):
|
|
super(VlanRouter, self).__init__()
|
|
self.vlan_id = vlan_id
|
|
self.dp = dp
|
|
self.sw_id = {'sw_id': dpid_lib.dpid_to_str(dp.id)}
|
|
self.logger = logger
|
|
|
|
self.port_data = port_data
|
|
self.address_data = AddressData()
|
|
self.routing_tbl = RoutingTable()
|
|
self.packet_buffer = SuspendPacketList(self.send_icmp_unreach_error)
|
|
self.ofctl = OfCtl.factory(dp, logger)
|
|
|
|
# Set flow: default route (drop)
|
|
self._set_defaultroute_drop()
|
|
|
|
def delete(self, waiters):
|
|
# Delete flow.
|
|
msgs = self.ofctl.get_all_flow(waiters)
|
|
for msg in msgs:
|
|
for stats in msg.body:
|
|
vlan_id = VlanRouter._cookie_to_id(REST_VLANID, stats.cookie)
|
|
if vlan_id == self.vlan_id:
|
|
self.ofctl.delete_flow(stats)
|
|
|
|
assert len(self.packet_buffer) == 0
|
|
|
|
@staticmethod
|
|
def _cookie_to_id(id_type, cookie):
|
|
if id_type == REST_VLANID:
|
|
rest_id = cookie >> COOKIE_SHIFT_VLANID
|
|
elif id_type == REST_ADDRESSID:
|
|
rest_id = cookie & UINT32_MAX
|
|
else:
|
|
assert id_type == REST_ROUTEID
|
|
rest_id = (cookie & UINT32_MAX) >> COOKIE_SHIFT_ROUTEID
|
|
|
|
return rest_id
|
|
|
|
def _id_to_cookie(self, id_type, rest_id):
|
|
vid = self.vlan_id << COOKIE_SHIFT_VLANID
|
|
|
|
if id_type == REST_VLANID:
|
|
cookie = rest_id << COOKIE_SHIFT_VLANID
|
|
elif id_type == REST_ADDRESSID:
|
|
cookie = vid + rest_id
|
|
else:
|
|
assert id_type == REST_ROUTEID
|
|
cookie = vid + (rest_id << COOKIE_SHIFT_ROUTEID)
|
|
|
|
return cookie
|
|
|
|
def _get_priority(self, priority_type, route=None):
|
|
return get_priority(priority_type, vid=self.vlan_id, route=route)
|
|
|
|
def _response(self, msg):
|
|
if msg and self.vlan_id:
|
|
msg.setdefault(REST_VLANID, self.vlan_id)
|
|
return msg
|
|
|
|
def get_data(self):
|
|
address_data = self._get_address_data()
|
|
routing_data = self._get_routing_data()
|
|
|
|
data = {}
|
|
if address_data[REST_ADDRESS]:
|
|
data.update(address_data)
|
|
if routing_data[REST_ROUTE]:
|
|
data.update(routing_data)
|
|
|
|
return self._response(data)
|
|
|
|
def _get_address_data(self):
|
|
address_data = []
|
|
for value in self.address_data.values():
|
|
default_gw = ip_addr_ntoa(value.default_gw)
|
|
address = '%s/%d' % (default_gw, value.netmask)
|
|
data = {REST_ADDRESSID: value.address_id,
|
|
REST_ADDRESS: address}
|
|
address_data.append(data)
|
|
return {REST_ADDRESS: address_data}
|
|
|
|
def _get_routing_data(self):
|
|
routing_data = []
|
|
for key, value in self.routing_tbl.items():
|
|
if value.gateway_mac is not None:
|
|
gateway = ip_addr_ntoa(value.gateway_ip)
|
|
data = {REST_ROUTEID: value.route_id,
|
|
REST_DESTINATION: key,
|
|
REST_GATEWAY: gateway}
|
|
routing_data.append(data)
|
|
return {REST_ROUTE: routing_data}
|
|
|
|
def set_data(self, data):
|
|
details = None
|
|
|
|
try:
|
|
# Set address data
|
|
if REST_ADDRESS in data:
|
|
address = data[REST_ADDRESS]
|
|
address_id = self._set_address_data(address)
|
|
details = 'Add address [address_id=%d]' % address_id
|
|
# Set routing data
|
|
elif REST_GATEWAY in data:
|
|
gateway = data[REST_GATEWAY]
|
|
if REST_DESTINATION in data:
|
|
destination = data[REST_DESTINATION]
|
|
else:
|
|
destination = DEFAULT_ROUTE
|
|
route_id = self._set_routing_data(destination, gateway)
|
|
details = 'Add route [route_id=%d]' % route_id
|
|
|
|
except CommandFailure as err_msg:
|
|
msg = {REST_RESULT: REST_NG, REST_DETAILS: str(err_msg)}
|
|
return self._response(msg)
|
|
|
|
if details is not None:
|
|
msg = {REST_RESULT: REST_OK, REST_DETAILS: details}
|
|
return self._response(msg)
|
|
else:
|
|
raise ValueError('Invalid parameter.')
|
|
|
|
def _set_address_data(self, address):
|
|
address = self.address_data.add(address)
|
|
|
|
cookie = self._id_to_cookie(REST_ADDRESSID, address.address_id)
|
|
|
|
# Set flow: host MAC learning (packet in)
|
|
priority = self._get_priority(PRIORITY_MAC_LEARNING)
|
|
self.ofctl.set_packetin_flow(cookie, priority,
|
|
dl_type=ether.ETH_TYPE_IP,
|
|
dl_vlan=self.vlan_id,
|
|
dst_ip=address.nw_addr,
|
|
dst_mask=address.netmask)
|
|
log_msg = 'Set host MAC learning (packet in) flow [cookie=0x%x]'
|
|
self.logger.info(log_msg, cookie, extra=self.sw_id)
|
|
|
|
# set Flow: IP handling(PacketIn)
|
|
priority = self._get_priority(PRIORITY_IP_HANDLING)
|
|
self.ofctl.set_packetin_flow(cookie, priority,
|
|
dl_type=ether.ETH_TYPE_IP,
|
|
dl_vlan=self.vlan_id,
|
|
dst_ip=address.default_gw)
|
|
self.logger.info('Set IP handling (packet in) flow [cookie=0x%x]',
|
|
cookie, extra=self.sw_id)
|
|
|
|
# Set flow: L2 switching (normal)
|
|
outport = self.ofctl.dp.ofproto.OFPP_NORMAL
|
|
priority = self._get_priority(PRIORITY_L2_SWITCHING)
|
|
self.ofctl.set_routing_flow(
|
|
cookie, priority, outport, dl_vlan=self.vlan_id,
|
|
nw_src=address.nw_addr, src_mask=address.netmask,
|
|
nw_dst=address.nw_addr, dst_mask=address.netmask)
|
|
self.logger.info('Set L2 switching (normal) flow [cookie=0x%x]',
|
|
cookie, extra=self.sw_id)
|
|
|
|
# Send GARP
|
|
self.send_arp_request(address.default_gw, address.default_gw)
|
|
|
|
return address.address_id
|
|
|
|
def _set_routing_data(self, destination, gateway):
|
|
err_msg = 'Invalid [%s] value.' % REST_GATEWAY
|
|
dst_ip = ip_addr_aton(gateway, err_msg=err_msg)
|
|
address = self.address_data.get_data(ip=dst_ip)
|
|
if address is None:
|
|
msg = 'Gateway=%s\'s address is not registered.' % gateway
|
|
raise CommandFailure(msg=msg)
|
|
elif dst_ip == address.default_gw:
|
|
msg = 'Gateway=%s is used as default gateway of address_id=%d'\
|
|
% (gateway, address.address_id)
|
|
raise CommandFailure(msg=msg)
|
|
else:
|
|
src_ip = address.default_gw
|
|
route = self.routing_tbl.add(destination, gateway)
|
|
self._set_route_packetin(route)
|
|
self.send_arp_request(src_ip, dst_ip)
|
|
return route.route_id
|
|
|
|
def _set_defaultroute_drop(self):
|
|
cookie = self._id_to_cookie(REST_VLANID, self.vlan_id)
|
|
priority = self._get_priority(PRIORITY_DEFAULT_ROUTING)
|
|
outport = None # for drop
|
|
self.ofctl.set_routing_flow(cookie, priority, outport,
|
|
dl_vlan=self.vlan_id)
|
|
self.logger.info('Set default route (drop) flow [cookie=0x%x]',
|
|
cookie, extra=self.sw_id)
|
|
|
|
def _set_route_packetin(self, route):
|
|
cookie = self._id_to_cookie(REST_ROUTEID, route.route_id)
|
|
priority, log_msg = self._get_priority(PRIORITY_TYPE_ROUTE,
|
|
route=route)
|
|
self.ofctl.set_packetin_flow(cookie, priority,
|
|
dl_type=ether.ETH_TYPE_IP,
|
|
dl_vlan=self.vlan_id,
|
|
dst_ip=route.dst_ip,
|
|
dst_mask=route.netmask)
|
|
self.logger.info('Set %s (packet in) flow [cookie=0x%x]', log_msg,
|
|
cookie, extra=self.sw_id)
|
|
|
|
def delete_data(self, data, waiters):
|
|
if REST_ROUTEID in data:
|
|
route_id = data[REST_ROUTEID]
|
|
msg = self._delete_routing_data(route_id, waiters)
|
|
elif REST_ADDRESSID in data:
|
|
address_id = data[REST_ADDRESSID]
|
|
msg = self._delete_address_data(address_id, waiters)
|
|
else:
|
|
raise ValueError('Invalid parameter.')
|
|
|
|
return self._response(msg)
|
|
|
|
def _delete_address_data(self, address_id, waiters):
|
|
if address_id != REST_ALL:
|
|
try:
|
|
address_id = int(address_id)
|
|
except ValueError as e:
|
|
err_msg = 'Invalid [%s] value. %s'
|
|
raise ValueError(err_msg % (REST_ADDRESSID, e.message))
|
|
|
|
skip_ids = self._chk_addr_relation_route(address_id)
|
|
|
|
# Get all flow.
|
|
delete_list = []
|
|
msgs = self.ofctl.get_all_flow(waiters)
|
|
max_id = UINT16_MAX
|
|
for msg in msgs:
|
|
for stats in msg.body:
|
|
vlan_id = VlanRouter._cookie_to_id(REST_VLANID, stats.cookie)
|
|
if vlan_id != self.vlan_id:
|
|
continue
|
|
addr_id = VlanRouter._cookie_to_id(REST_ADDRESSID,
|
|
stats.cookie)
|
|
if addr_id in skip_ids:
|
|
continue
|
|
elif address_id == REST_ALL:
|
|
if addr_id <= COOKIE_DEFAULT_ID or max_id < addr_id:
|
|
continue
|
|
elif address_id != addr_id:
|
|
continue
|
|
delete_list.append(stats)
|
|
|
|
delete_ids = []
|
|
for flow_stats in delete_list:
|
|
# Delete flow
|
|
self.ofctl.delete_flow(flow_stats)
|
|
address_id = VlanRouter._cookie_to_id(REST_ADDRESSID,
|
|
flow_stats.cookie)
|
|
|
|
del_address = self.address_data.get_data(addr_id=address_id)
|
|
if del_address is not None:
|
|
# Clean up suspend packet threads.
|
|
self.packet_buffer.delete(del_addr=del_address)
|
|
|
|
# Delete data.
|
|
self.address_data.delete(address_id)
|
|
if address_id not in delete_ids:
|
|
delete_ids.append(address_id)
|
|
|
|
msg = {}
|
|
if delete_ids:
|
|
delete_ids = ','.join(str(addr_id) for addr_id in delete_ids)
|
|
details = 'Delete address [address_id=%s]' % delete_ids
|
|
msg = {REST_RESULT: REST_OK, REST_DETAILS: details}
|
|
|
|
if skip_ids:
|
|
skip_ids = ','.join(str(addr_id) for addr_id in skip_ids)
|
|
details = 'Skip delete (related route exist) [address_id=%s]'\
|
|
% skip_ids
|
|
if msg:
|
|
msg[REST_DETAILS] += ', %s' % details
|
|
else:
|
|
msg = {REST_RESULT: REST_NG, REST_DETAILS: details}
|
|
|
|
return msg
|
|
|
|
def _delete_routing_data(self, route_id, waiters):
|
|
if route_id != REST_ALL:
|
|
try:
|
|
route_id = int(route_id)
|
|
except ValueError as e:
|
|
err_msg = 'Invalid [%s] value. %s'
|
|
raise ValueError(err_msg % (REST_ROUTEID, e.message))
|
|
|
|
# Get all flow.
|
|
msgs = self.ofctl.get_all_flow(waiters)
|
|
|
|
delete_list = []
|
|
for msg in msgs:
|
|
for stats in msg.body:
|
|
vlan_id = VlanRouter._cookie_to_id(REST_VLANID, stats.cookie)
|
|
if vlan_id != self.vlan_id:
|
|
continue
|
|
rt_id = VlanRouter._cookie_to_id(REST_ROUTEID, stats.cookie)
|
|
if route_id == REST_ALL:
|
|
if rt_id == COOKIE_DEFAULT_ID:
|
|
continue
|
|
elif route_id != rt_id:
|
|
continue
|
|
delete_list.append(stats)
|
|
|
|
# Delete flow.
|
|
delete_ids = []
|
|
for flow_stats in delete_list:
|
|
self.ofctl.delete_flow(flow_stats)
|
|
route_id = VlanRouter._cookie_to_id(REST_ROUTEID,
|
|
flow_stats.cookie)
|
|
self.routing_tbl.delete(route_id)
|
|
if route_id not in delete_ids:
|
|
delete_ids.append(route_id)
|
|
|
|
# case: Default route deleted. -> set flow (drop)
|
|
route_type = get_priority_type(flow_stats.priority,
|
|
vid=self.vlan_id)
|
|
if route_type == PRIORITY_DEFAULT_ROUTING:
|
|
self._set_defaultroute_drop()
|
|
|
|
msg = {}
|
|
if delete_ids:
|
|
delete_ids = ','.join(str(route_id) for route_id in delete_ids)
|
|
details = 'Delete route [route_id=%s]' % delete_ids
|
|
msg = {REST_RESULT: REST_OK, REST_DETAILS: details}
|
|
|
|
return msg
|
|
|
|
def _chk_addr_relation_route(self, address_id):
|
|
# Check exist of related routing data.
|
|
relate_list = []
|
|
gateways = self.routing_tbl.get_gateways()
|
|
for gateway in gateways:
|
|
address = self.address_data.get_data(ip=gateway)
|
|
if address is not None:
|
|
if (address_id == REST_ALL
|
|
and address.address_id not in relate_list):
|
|
relate_list.append(address.address_id)
|
|
elif address.address_id == address_id:
|
|
relate_list = [address_id]
|
|
break
|
|
return relate_list
|
|
|
|
def packet_in_handler(self, msg, header_list):
|
|
# Check invalid TTL (for OpenFlow V1.2/1.3)
|
|
ofproto = self.dp.ofproto
|
|
if ofproto.OFP_VERSION == ofproto_v1_2.OFP_VERSION or \
|
|
ofproto.OFP_VERSION == ofproto_v1_3.OFP_VERSION:
|
|
if msg.reason == ofproto.OFPR_INVALID_TTL:
|
|
self._packetin_invalid_ttl(msg, header_list)
|
|
return
|
|
|
|
# Analyze event type.
|
|
if ARP in header_list:
|
|
self._packetin_arp(msg, header_list)
|
|
return
|
|
|
|
if IPV4 in header_list:
|
|
rt_ports = self.address_data.get_default_gw()
|
|
if header_list[IPV4].dst in rt_ports:
|
|
# Packet to router's port.
|
|
if ICMP in header_list:
|
|
if header_list[ICMP].type == icmp.ICMP_ECHO_REQUEST:
|
|
self._packetin_icmp_req(msg, header_list)
|
|
return
|
|
elif TCP in header_list or UDP in header_list:
|
|
self._packetin_tcp_udp(msg, header_list)
|
|
return
|
|
else:
|
|
# Packet to internal host or gateway router.
|
|
self._packetin_to_node(msg, header_list)
|
|
return
|
|
|
|
def _packetin_arp(self, msg, header_list):
|
|
src_addr = self.address_data.get_data(ip=header_list[ARP].src_ip)
|
|
if src_addr is None:
|
|
return
|
|
|
|
# case: Receive ARP from the gateway
|
|
# Update routing table.
|
|
# case: Receive ARP from an internal host
|
|
# Learning host MAC.
|
|
gw_flg = self._update_routing_tbl(msg, header_list)
|
|
if gw_flg is False:
|
|
self._learning_host_mac(msg, header_list)
|
|
|
|
# ARP packet handling.
|
|
in_port = self.ofctl.get_packetin_inport(msg)
|
|
src_ip = header_list[ARP].src_ip
|
|
dst_ip = header_list[ARP].dst_ip
|
|
srcip = ip_addr_ntoa(src_ip)
|
|
dstip = ip_addr_ntoa(dst_ip)
|
|
rt_ports = self.address_data.get_default_gw()
|
|
|
|
if src_ip == dst_ip:
|
|
# GARP -> packet forward (normal)
|
|
output = self.ofctl.dp.ofproto.OFPP_NORMAL
|
|
self.ofctl.send_packet_out(in_port, output, msg.data)
|
|
|
|
self.logger.info('Receive GARP from [%s].', srcip,
|
|
extra=self.sw_id)
|
|
self.logger.info('Send GARP (normal).', extra=self.sw_id)
|
|
|
|
elif dst_ip not in rt_ports:
|
|
dst_addr = self.address_data.get_data(ip=dst_ip)
|
|
if (dst_addr is not None and
|
|
src_addr.address_id == dst_addr.address_id):
|
|
# ARP from internal host -> packet forward (normal)
|
|
output = self.ofctl.dp.ofproto.OFPP_NORMAL
|
|
self.ofctl.send_packet_out(in_port, output, msg.data)
|
|
|
|
self.logger.info('Receive ARP from an internal host [%s].',
|
|
srcip, extra=self.sw_id)
|
|
self.logger.info('Send ARP (normal)', extra=self.sw_id)
|
|
else:
|
|
if header_list[ARP].opcode == arp.ARP_REQUEST:
|
|
# ARP request to router port -> send ARP reply
|
|
src_mac = self.port_data[in_port].mac
|
|
dst_mac = header_list[ARP].src_mac
|
|
arp_target_mac = dst_mac
|
|
output = in_port
|
|
in_port = self.ofctl.dp.ofproto.OFPP_CONTROLLER
|
|
|
|
self.ofctl.send_arp(arp.ARP_REPLY, self.vlan_id,
|
|
src_mac, dst_mac, dst_ip, src_ip,
|
|
arp_target_mac, in_port, output)
|
|
|
|
log_msg = 'Receive ARP request from [%s] to router port [%s].'
|
|
self.logger.info(log_msg, srcip, dstip, extra=self.sw_id)
|
|
self.logger.info('Send ARP reply to [%s]', srcip,
|
|
extra=self.sw_id)
|
|
|
|
elif header_list[ARP].opcode == arp.ARP_REPLY:
|
|
# ARP reply to router port -> suspend packets forward
|
|
log_msg = 'Receive ARP reply from [%s] to router port [%s].'
|
|
self.logger.info(log_msg, srcip, dstip, extra=self.sw_id)
|
|
|
|
packet_list = self.packet_buffer.get_data(src_ip)
|
|
if packet_list:
|
|
# stop ARP reply wait thread.
|
|
for suspend_packet in packet_list:
|
|
self.packet_buffer.delete(pkt=suspend_packet)
|
|
|
|
# send suspend packet.
|
|
output = self.ofctl.dp.ofproto.OFPP_TABLE
|
|
for suspend_packet in packet_list:
|
|
self.ofctl.send_packet_out(suspend_packet.in_port,
|
|
output,
|
|
suspend_packet.data)
|
|
self.logger.info('Send suspend packet to [%s].',
|
|
srcip, extra=self.sw_id)
|
|
|
|
def _packetin_icmp_req(self, msg, header_list):
|
|
# Send ICMP echo reply.
|
|
in_port = self.ofctl.get_packetin_inport(msg)
|
|
self.ofctl.send_icmp(in_port, header_list, self.vlan_id,
|
|
icmp.ICMP_ECHO_REPLY,
|
|
icmp.ICMP_ECHO_REPLY_CODE,
|
|
icmp_data=header_list[ICMP].data)
|
|
|
|
srcip = ip_addr_ntoa(header_list[IPV4].src)
|
|
dstip = ip_addr_ntoa(header_list[IPV4].dst)
|
|
log_msg = 'Receive ICMP echo request from [%s] to router port [%s].'
|
|
self.logger.info(log_msg, srcip, dstip, extra=self.sw_id)
|
|
self.logger.info('Send ICMP echo reply to [%s].', srcip,
|
|
extra=self.sw_id)
|
|
|
|
def _packetin_tcp_udp(self, msg, header_list):
|
|
# Send ICMP port unreach error.
|
|
in_port = self.ofctl.get_packetin_inport(msg)
|
|
self.ofctl.send_icmp(in_port, header_list, self.vlan_id,
|
|
icmp.ICMP_DEST_UNREACH,
|
|
icmp.ICMP_PORT_UNREACH_CODE,
|
|
msg_data=msg.data)
|
|
|
|
srcip = ip_addr_ntoa(header_list[IPV4].src)
|
|
dstip = ip_addr_ntoa(header_list[IPV4].dst)
|
|
self.logger.info('Receive TCP/UDP from [%s] to router port [%s].',
|
|
srcip, dstip, extra=self.sw_id)
|
|
self.logger.info('Send ICMP destination unreachable to [%s].', srcip,
|
|
extra=self.sw_id)
|
|
|
|
def _packetin_to_node(self, msg, header_list):
|
|
if len(self.packet_buffer) >= MAX_SUSPENDPACKETS:
|
|
self.logger.info('Packet is dropped, MAX_SUSPENDPACKETS exceeded.',
|
|
extra=self.sw_id)
|
|
return
|
|
|
|
# Send ARP request to get node MAC address.
|
|
in_port = self.ofctl.get_packetin_inport(msg)
|
|
src_ip = None
|
|
dst_ip = header_list[IPV4].dst
|
|
srcip = ip_addr_ntoa(header_list[IPV4].src)
|
|
dstip = ip_addr_ntoa(dst_ip)
|
|
|
|
address = self.address_data.get_data(ip=dst_ip)
|
|
if address is not None:
|
|
log_msg = 'Receive IP packet from [%s] to an internal host [%s].'
|
|
self.logger.info(log_msg, srcip, dstip, extra=self.sw_id)
|
|
src_ip = address.default_gw
|
|
else:
|
|
route = self.routing_tbl.get_data(dst_ip=dst_ip)
|
|
if route is not None:
|
|
log_msg = 'Receive IP packet from [%s] to [%s].'
|
|
self.logger.info(log_msg, srcip, dstip, extra=self.sw_id)
|
|
gw_address = self.address_data.get_data(ip=route.gateway_ip)
|
|
if gw_address is not None:
|
|
src_ip = gw_address.default_gw
|
|
dst_ip = route.gateway_ip
|
|
|
|
if src_ip is not None:
|
|
self.packet_buffer.add(in_port, header_list, msg.data)
|
|
self.send_arp_request(src_ip, dst_ip, in_port=in_port)
|
|
self.logger.info('Send ARP request (flood)', extra=self.sw_id)
|
|
|
|
def _packetin_invalid_ttl(self, msg, header_list):
|
|
# Send ICMP TTL error.
|
|
srcip = ip_addr_ntoa(header_list[IPV4].src)
|
|
self.logger.info('Receive invalid ttl packet from [%s].', srcip,
|
|
extra=self.sw_id)
|
|
|
|
in_port = self.ofctl.get_packetin_inport(msg)
|
|
src_ip = self._get_send_port_ip(header_list)
|
|
if src_ip is not None:
|
|
self.ofctl.send_icmp(in_port, header_list, self.vlan_id,
|
|
icmp.ICMP_TIME_EXCEEDED,
|
|
icmp.ICMP_TTL_EXPIRED_CODE,
|
|
msg_data=msg.data, src_ip=src_ip)
|
|
self.logger.info('Send ICMP time exceeded to [%s].', srcip,
|
|
extra=self.sw_id)
|
|
|
|
def send_arp_all_gw(self):
|
|
gateways = self.routing_tbl.get_gateways()
|
|
for gateway in gateways:
|
|
address = self.address_data.get_data(ip=gateway)
|
|
self.send_arp_request(address.default_gw, gateway)
|
|
|
|
def send_arp_request(self, src_ip, dst_ip, in_port=None):
|
|
# Send ARP request from all ports.
|
|
for send_port in self.port_data.values():
|
|
if in_port is None or in_port != send_port.port_no:
|
|
src_mac = send_port.mac
|
|
dst_mac = mac_lib.BROADCAST_STR
|
|
arp_target_mac = mac_lib.DONTCARE_STR
|
|
inport = self.ofctl.dp.ofproto.OFPP_CONTROLLER
|
|
output = send_port.port_no
|
|
self.ofctl.send_arp(arp.ARP_REQUEST, self.vlan_id,
|
|
src_mac, dst_mac, src_ip, dst_ip,
|
|
arp_target_mac, inport, output)
|
|
|
|
def send_icmp_unreach_error(self, packet_buffer):
|
|
# Send ICMP host unreach error.
|
|
self.logger.info('ARP reply wait timer was timed out.',
|
|
extra=self.sw_id)
|
|
src_ip = self._get_send_port_ip(packet_buffer.header_list)
|
|
if src_ip is not None:
|
|
self.ofctl.send_icmp(packet_buffer.in_port,
|
|
packet_buffer.header_list,
|
|
self.vlan_id,
|
|
icmp.ICMP_DEST_UNREACH,
|
|
icmp.ICMP_HOST_UNREACH_CODE,
|
|
msg_data=packet_buffer.data,
|
|
src_ip=src_ip)
|
|
|
|
dstip = ip_addr_ntoa(packet_buffer.dst_ip)
|
|
self.logger.info('Send ICMP destination unreachable to [%s].',
|
|
dstip, extra=self.sw_id)
|
|
|
|
def _update_routing_tbl(self, msg, header_list):
|
|
# Set flow: routing to gateway.
|
|
out_port = self.ofctl.get_packetin_inport(msg)
|
|
src_mac = header_list[ARP].src_mac
|
|
dst_mac = self.port_data[out_port].mac
|
|
src_ip = header_list[ARP].src_ip
|
|
|
|
gateway_flg = False
|
|
for key, value in self.routing_tbl.items():
|
|
if value.gateway_ip == src_ip:
|
|
gateway_flg = True
|
|
if value.gateway_mac == src_mac:
|
|
continue
|
|
self.routing_tbl[key].gateway_mac = src_mac
|
|
|
|
cookie = self._id_to_cookie(REST_ROUTEID, value.route_id)
|
|
priority, log_msg = self._get_priority(PRIORITY_TYPE_ROUTE,
|
|
route=value)
|
|
self.ofctl.set_routing_flow(cookie, priority, out_port,
|
|
dl_vlan=self.vlan_id,
|
|
src_mac=dst_mac,
|
|
dst_mac=src_mac,
|
|
nw_dst=value.dst_ip,
|
|
dst_mask=value.netmask,
|
|
dec_ttl=True)
|
|
self.logger.info('Set %s flow [cookie=0x%x]', log_msg, cookie,
|
|
extra=self.sw_id)
|
|
return gateway_flg
|
|
|
|
def _learning_host_mac(self, msg, header_list):
|
|
# Set flow: routing to internal Host.
|
|
out_port = self.ofctl.get_packetin_inport(msg)
|
|
src_mac = header_list[ARP].src_mac
|
|
dst_mac = self.port_data[out_port].mac
|
|
src_ip = header_list[ARP].src_ip
|
|
|
|
gateways = self.routing_tbl.get_gateways()
|
|
if src_ip not in gateways:
|
|
address = self.address_data.get_data(ip=src_ip)
|
|
if address is not None:
|
|
cookie = self._id_to_cookie(REST_ADDRESSID, address.address_id)
|
|
priority = self._get_priority(PRIORITY_IMPLICIT_ROUTING)
|
|
self.ofctl.set_routing_flow(cookie, priority,
|
|
out_port, dl_vlan=self.vlan_id,
|
|
src_mac=dst_mac, dst_mac=src_mac,
|
|
nw_dst=src_ip,
|
|
idle_timeout=IDLE_TIMEOUT,
|
|
dec_ttl=True)
|
|
self.logger.info('Set implicit routing flow [cookie=0x%x]',
|
|
cookie, extra=self.sw_id)
|
|
|
|
def _get_send_port_ip(self, header_list):
|
|
try:
|
|
src_mac = header_list[ETHERNET].src
|
|
if IPV4 in header_list:
|
|
src_ip = header_list[IPV4].src
|
|
else:
|
|
src_ip = header_list[ARP].src_ip
|
|
except KeyError:
|
|
self.logger.debug('Receive unsupported packet.', extra=self.sw_id)
|
|
return None
|
|
|
|
address = self.address_data.get_data(ip=src_ip)
|
|
if address is not None:
|
|
return address.default_gw
|
|
else:
|
|
route = self.routing_tbl.get_data(gw_mac=src_mac)
|
|
if route is not None:
|
|
address = self.address_data.get_data(ip=route.gateway_ip)
|
|
if address is not None:
|
|
return address.default_gw
|
|
|
|
self.logger.debug('Receive packet from unknown IP[%s].',
|
|
ip_addr_ntoa(src_ip), extra=self.sw_id)
|
|
return None
|
|
|
|
|
|
class PortData(dict):
|
|
def __init__(self, ports):
|
|
super(PortData, self).__init__()
|
|
for port in ports.values():
|
|
data = Port(port.port_no, port.hw_addr)
|
|
self[port.port_no] = data
|
|
|
|
|
|
class Port(object):
|
|
def __init__(self, port_no, hw_addr):
|
|
super(Port, self).__init__()
|
|
self.port_no = port_no
|
|
self.mac = hw_addr
|
|
|
|
|
|
class AddressData(dict):
|
|
def __init__(self):
|
|
super(AddressData, self).__init__()
|
|
self.address_id = 1
|
|
|
|
def add(self, address):
|
|
err_msg = 'Invalid [%s] value.' % REST_ADDRESS
|
|
nw_addr, mask, default_gw = nw_addr_aton(address, err_msg=err_msg)
|
|
|
|
# Check overlaps
|
|
for other in self.values():
|
|
other_mask = mask_ntob(other.netmask)
|
|
add_mask = mask_ntob(mask, err_msg=err_msg)
|
|
if (other.nw_addr == ipv4_apply_mask(default_gw, other.netmask) or
|
|
nw_addr == ipv4_apply_mask(other.default_gw, mask,
|
|
err_msg)):
|
|
msg = 'Address overlaps [address_id=%d]' % other.address_id
|
|
raise CommandFailure(msg=msg)
|
|
|
|
address = Address(self.address_id, nw_addr, mask, default_gw)
|
|
ip_str = ip_addr_ntoa(nw_addr)
|
|
key = '%s/%d' % (ip_str, mask)
|
|
self[key] = address
|
|
|
|
self.address_id += 1
|
|
self.address_id &= UINT32_MAX
|
|
if self.address_id == COOKIE_DEFAULT_ID:
|
|
self.address_id = 1
|
|
|
|
return address
|
|
|
|
def delete(self, address_id):
|
|
for key, value in self.items():
|
|
if value.address_id == address_id:
|
|
del self[key]
|
|
return
|
|
|
|
def get_default_gw(self):
|
|
return [address.default_gw for address in self.values()]
|
|
|
|
def get_data(self, addr_id=None, ip=None):
|
|
for address in self.values():
|
|
if addr_id is not None:
|
|
if addr_id == address.address_id:
|
|
return address
|
|
else:
|
|
assert ip is not None
|
|
if ipv4_apply_mask(ip, address.netmask) == address.nw_addr:
|
|
return address
|
|
return None
|
|
|
|
|
|
class Address(object):
|
|
def __init__(self, address_id, nw_addr, netmask, default_gw):
|
|
super(Address, self).__init__()
|
|
self.address_id = address_id
|
|
self.nw_addr = nw_addr
|
|
self.netmask = netmask
|
|
self.default_gw = default_gw
|
|
|
|
def __contains__(self, ip):
|
|
return bool(ipv4_apply_mask(ip, self.netmask) == self.nw_addr)
|
|
|
|
|
|
class RoutingTable(dict):
|
|
def __init__(self):
|
|
super(RoutingTable, self).__init__()
|
|
self.route_id = 1
|
|
|
|
def add(self, dst_nw_addr, gateway_ip):
|
|
err_msg = 'Invalid [%s] value.'
|
|
|
|
if dst_nw_addr == DEFAULT_ROUTE:
|
|
dst_ip = 0
|
|
netmask = 0
|
|
else:
|
|
dst_ip, netmask, dummy = nw_addr_aton(
|
|
dst_nw_addr, err_msg=err_msg % REST_DESTINATION)
|
|
|
|
gateway_ip = ip_addr_aton(gateway_ip, err_msg=err_msg % REST_GATEWAY)
|
|
|
|
# Check overlaps
|
|
overlap_route = None
|
|
if dst_nw_addr == DEFAULT_ROUTE:
|
|
if DEFAULT_ROUTE in self:
|
|
overlap_route = self[DEFAULT_ROUTE].route_id
|
|
elif dst_nw_addr in self:
|
|
overlap_route = self[dst_nw_addr].route_id
|
|
|
|
if overlap_route is not None:
|
|
msg = 'Destination overlaps [route_id=%d]' % overlap_route
|
|
raise CommandFailure(msg=msg)
|
|
|
|
routing_data = Route(self.route_id, dst_ip, netmask, gateway_ip)
|
|
ip_str = ip_addr_ntoa(dst_ip)
|
|
key = '%s/%d' % (ip_str, netmask)
|
|
self[key] = routing_data
|
|
|
|
self.route_id += 1
|
|
self.route_id &= UINT32_MAX
|
|
if self.route_id == COOKIE_DEFAULT_ID:
|
|
self.route_id = 1
|
|
|
|
return routing_data
|
|
|
|
def delete(self, route_id):
|
|
for key, value in self.items():
|
|
if value.route_id == route_id:
|
|
del self[key]
|
|
return
|
|
|
|
def get_gateways(self):
|
|
return [routing_data.gateway_ip for routing_data in self.values()]
|
|
|
|
def get_data(self, gw_mac=None, dst_ip=None):
|
|
if gw_mac is not None:
|
|
for route in self.values():
|
|
if gw_mac == route.gateway_mac:
|
|
return route
|
|
return None
|
|
|
|
elif dst_ip is not None:
|
|
get_route = None
|
|
mask = 0
|
|
for route in self.values():
|
|
if ipv4_apply_mask(dst_ip, route.netmask) == route.dst_ip:
|
|
# For longest match
|
|
if mask < route.netmask:
|
|
get_route = route
|
|
mask = route.netmask
|
|
|
|
if get_route is None:
|
|
get_route = self.get(DEFAULT_ROUTE, None)
|
|
return get_route
|
|
else:
|
|
return None
|
|
|
|
|
|
class Route(object):
|
|
def __init__(self, route_id, dst_ip, netmask, gateway_ip):
|
|
super(Route, self).__init__()
|
|
self.route_id = route_id
|
|
self.dst_ip = dst_ip
|
|
self.netmask = netmask
|
|
self.gateway_ip = gateway_ip
|
|
self.gateway_mac = None
|
|
|
|
|
|
class SuspendPacketList(list):
|
|
def __init__(self, timeout_function):
|
|
super(SuspendPacketList, self).__init__()
|
|
self.timeout_function = timeout_function
|
|
|
|
def add(self, in_port, header_list, data):
|
|
suspend_pkt = SuspendPacket(in_port, header_list, data,
|
|
self.wait_arp_reply_timer)
|
|
self.append(suspend_pkt)
|
|
|
|
def delete(self, pkt=None, del_addr=None):
|
|
if pkt is not None:
|
|
del_list = [pkt]
|
|
else:
|
|
assert del_addr is not None
|
|
del_list = [pkt for pkt in self if pkt.dst_ip in del_addr]
|
|
|
|
for pkt in del_list:
|
|
self.remove(pkt)
|
|
hub.kill(pkt.wait_thread)
|
|
pkt.wait_thread.wait()
|
|
|
|
def get_data(self, dst_ip):
|
|
return [pkt for pkt in self if pkt.dst_ip == dst_ip]
|
|
|
|
def wait_arp_reply_timer(self, suspend_pkt):
|
|
hub.sleep(ARP_REPLY_TIMER)
|
|
if suspend_pkt in self:
|
|
self.timeout_function(suspend_pkt)
|
|
self.delete(pkt=suspend_pkt)
|
|
|
|
|
|
class SuspendPacket(object):
|
|
def __init__(self, in_port, header_list, data, timer):
|
|
super(SuspendPacket, self).__init__()
|
|
self.in_port = in_port
|
|
self.dst_ip = header_list[IPV4].dst
|
|
self.header_list = header_list
|
|
self.data = data
|
|
# Start ARP reply wait timer.
|
|
self.wait_thread = hub.spawn(timer, self)
|
|
|
|
|
|
class OfCtl(object):
|
|
_OF_VERSIONS = {}
|
|
|
|
@staticmethod
|
|
def register_of_version(version):
|
|
def _register_of_version(cls):
|
|
OfCtl._OF_VERSIONS.setdefault(version, cls)
|
|
return cls
|
|
return _register_of_version
|
|
|
|
@staticmethod
|
|
def factory(dp, logger):
|
|
of_version = dp.ofproto.OFP_VERSION
|
|
if of_version in OfCtl._OF_VERSIONS:
|
|
ofctl = OfCtl._OF_VERSIONS[of_version](dp, logger)
|
|
else:
|
|
raise OFPUnknownVersion(version=of_version)
|
|
|
|
return ofctl
|
|
|
|
def __init__(self, dp, logger):
|
|
super(OfCtl, self).__init__()
|
|
self.dp = dp
|
|
self.sw_id = {'sw_id': dpid_lib.dpid_to_str(dp.id)}
|
|
self.logger = logger
|
|
|
|
def set_sw_config_for_ttl(self):
|
|
# OpenFlow v1_2/1_3.
|
|
pass
|
|
|
|
def set_flow(self, cookie, priority, dl_type=0, dl_dst=0, dl_vlan=0,
|
|
nw_src=0, src_mask=32, nw_dst=0, dst_mask=32,
|
|
nw_proto=0, idle_timeout=0, actions=None):
|
|
# Abstract method
|
|
raise NotImplementedError()
|
|
|
|
def send_arp(self, arp_opcode, vlan_id, src_mac, dst_mac,
|
|
src_ip, dst_ip, arp_target_mac, in_port, output):
|
|
# Generate ARP packet
|
|
if vlan_id != VLANID_NONE:
|
|
ether_proto = ether.ETH_TYPE_8021Q
|
|
pcp = 0
|
|
cfi = 0
|
|
vlan_ether = ether.ETH_TYPE_ARP
|
|
v = vlan.vlan(pcp, cfi, vlan_id, vlan_ether)
|
|
else:
|
|
ether_proto = ether.ETH_TYPE_ARP
|
|
hwtype = 1
|
|
arp_proto = ether.ETH_TYPE_IP
|
|
hlen = 6
|
|
plen = 4
|
|
|
|
pkt = packet.Packet()
|
|
e = ethernet.ethernet(dst_mac, src_mac, ether_proto)
|
|
a = arp.arp(hwtype, arp_proto, hlen, plen, arp_opcode,
|
|
src_mac, src_ip, arp_target_mac, dst_ip)
|
|
pkt.add_protocol(e)
|
|
if vlan_id != VLANID_NONE:
|
|
pkt.add_protocol(v)
|
|
pkt.add_protocol(a)
|
|
pkt.serialize()
|
|
|
|
# Send packet out
|
|
self.send_packet_out(in_port, output, pkt.data, data_str=str(pkt))
|
|
|
|
def send_icmp(self, in_port, protocol_list, vlan_id, icmp_type,
|
|
icmp_code, icmp_data=None, msg_data=None, src_ip=None):
|
|
# Generate ICMP reply packet
|
|
csum = 0
|
|
offset = ethernet.ethernet._MIN_LEN
|
|
|
|
if vlan_id != VLANID_NONE:
|
|
ether_proto = ether.ETH_TYPE_8021Q
|
|
pcp = 0
|
|
cfi = 0
|
|
vlan_ether = ether.ETH_TYPE_IP
|
|
v = vlan.vlan(pcp, cfi, vlan_id, vlan_ether)
|
|
offset += vlan.vlan._MIN_LEN
|
|
else:
|
|
ether_proto = ether.ETH_TYPE_IP
|
|
|
|
eth = protocol_list[ETHERNET]
|
|
e = ethernet.ethernet(eth.src, eth.dst, ether_proto)
|
|
|
|
ip = protocol_list[IPV4]
|
|
|
|
if icmp_data is None and msg_data is not None:
|
|
# RFC 4884 says that we should send "at least 128 octets"
|
|
# if we are using the ICMP Extension Structure.
|
|
# We're not using the extension structure, but let's send
|
|
# up to 128 bytes of the original msg_data.
|
|
#
|
|
# RFC 4884 also states that the length field is interpreted in
|
|
# 32 bit units, so the length calculated in bytes needs to first
|
|
# be divided by 4, then increased by 1 if the modulus is non-zero.
|
|
#
|
|
# Finally, RFC 4884 says, if we're specifying the length, we MUST
|
|
# zero pad to the next 32 bit boundary.
|
|
end_of_data = offset + len(ip) + 128
|
|
ip_datagram = bytearray()
|
|
ip_datagram += msg_data[offset:end_of_data]
|
|
data_len = int(len(ip_datagram) / 4)
|
|
length_modulus = int(len(ip_datagram) % 4)
|
|
if length_modulus:
|
|
data_len += 1
|
|
ip_datagram += bytearray([0] * (4 - length_modulus))
|
|
if icmp_type == icmp.ICMP_DEST_UNREACH:
|
|
icmp_data = icmp.dest_unreach(data_len=data_len,
|
|
data=ip_datagram)
|
|
elif icmp_type == icmp.ICMP_TIME_EXCEEDED:
|
|
icmp_data = icmp.TimeExceeded(data_len=data_len,
|
|
data=ip_datagram)
|
|
|
|
ic = icmp.icmp(icmp_type, icmp_code, csum, data=icmp_data)
|
|
|
|
if src_ip is None:
|
|
src_ip = ip.dst
|
|
ip_total_length = ip.header_length * 4 + ic._MIN_LEN
|
|
if ic.data is not None:
|
|
ip_total_length += ic.data._MIN_LEN
|
|
if ic.data.data is not None:
|
|
ip_total_length += + len(ic.data.data)
|
|
i = ipv4.ipv4(ip.version, ip.header_length, ip.tos,
|
|
ip_total_length, ip.identification, ip.flags,
|
|
ip.offset, DEFAULT_TTL, inet.IPPROTO_ICMP, csum,
|
|
src_ip, ip.src)
|
|
|
|
pkt = packet.Packet()
|
|
pkt.add_protocol(e)
|
|
if vlan_id != VLANID_NONE:
|
|
pkt.add_protocol(v)
|
|
pkt.add_protocol(i)
|
|
pkt.add_protocol(ic)
|
|
pkt.serialize()
|
|
|
|
# Send packet out
|
|
self.send_packet_out(in_port, self.dp.ofproto.OFPP_IN_PORT,
|
|
pkt.data, data_str=str(pkt))
|
|
|
|
def send_packet_out(self, in_port, output, data, data_str=None):
|
|
actions = [self.dp.ofproto_parser.OFPActionOutput(output, 0)]
|
|
self.dp.send_packet_out(buffer_id=UINT32_MAX, in_port=in_port,
|
|
actions=actions, data=data)
|
|
# TODO: Packet library convert to string
|
|
# if data_str is None:
|
|
# data_str = str(packet.Packet(data))
|
|
# self.logger.debug('Packet out = %s', data_str, extra=self.sw_id)
|
|
|
|
def set_normal_flow(self, cookie, priority):
|
|
out_port = self.dp.ofproto.OFPP_NORMAL
|
|
actions = [self.dp.ofproto_parser.OFPActionOutput(out_port, 0)]
|
|
self.set_flow(cookie, priority, actions=actions)
|
|
|
|
def set_packetin_flow(self, cookie, priority, dl_type=0, dl_dst=0,
|
|
dl_vlan=0, dst_ip=0, dst_mask=32, nw_proto=0):
|
|
miss_send_len = UINT16_MAX
|
|
actions = [self.dp.ofproto_parser.OFPActionOutput(
|
|
self.dp.ofproto.OFPP_CONTROLLER, miss_send_len)]
|
|
self.set_flow(cookie, priority, dl_type=dl_type, dl_dst=dl_dst,
|
|
dl_vlan=dl_vlan, nw_dst=dst_ip, dst_mask=dst_mask,
|
|
nw_proto=nw_proto, actions=actions)
|
|
|
|
def send_stats_request(self, stats, waiters):
|
|
self.dp.set_xid(stats)
|
|
waiters_per_dp = waiters.setdefault(self.dp.id, {})
|
|
event = hub.Event()
|
|
msgs = []
|
|
waiters_per_dp[stats.xid] = (event, msgs)
|
|
self.dp.send_msg(stats)
|
|
|
|
try:
|
|
event.wait(timeout=OFP_REPLY_TIMER)
|
|
except hub.Timeout:
|
|
del waiters_per_dp[stats.xid]
|
|
|
|
return msgs
|
|
|
|
|
|
@OfCtl.register_of_version(ofproto_v1_0.OFP_VERSION)
|
|
class OfCtl_v1_0(OfCtl):
|
|
|
|
def __init__(self, dp, logger):
|
|
super(OfCtl_v1_0, self).__init__(dp, logger)
|
|
|
|
def get_packetin_inport(self, msg):
|
|
return msg.in_port
|
|
|
|
def get_all_flow(self, waiters):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
|
|
match = ofp_parser.OFPMatch(ofp.OFPFW_ALL, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0)
|
|
stats = ofp_parser.OFPFlowStatsRequest(self.dp, 0, match,
|
|
0xff, ofp.OFPP_NONE)
|
|
return self.send_stats_request(stats, waiters)
|
|
|
|
def set_flow(self, cookie, priority, dl_type=0, dl_dst=0, dl_vlan=0,
|
|
nw_src=0, src_mask=32, nw_dst=0, dst_mask=32,
|
|
nw_proto=0, idle_timeout=0, actions=None):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
cmd = ofp.OFPFC_ADD
|
|
|
|
# Match
|
|
wildcards = ofp.OFPFW_ALL
|
|
if dl_type:
|
|
wildcards &= ~ofp.OFPFW_DL_TYPE
|
|
if dl_dst:
|
|
wildcards &= ~ofp.OFPFW_DL_DST
|
|
if dl_vlan:
|
|
wildcards &= ~ofp.OFPFW_DL_VLAN
|
|
if nw_src:
|
|
v = (32 - src_mask) << ofp.OFPFW_NW_SRC_SHIFT | \
|
|
~ofp.OFPFW_NW_SRC_MASK
|
|
wildcards &= v
|
|
nw_src = ipv4_text_to_int(nw_src)
|
|
if nw_dst:
|
|
v = (32 - dst_mask) << ofp.OFPFW_NW_DST_SHIFT | \
|
|
~ofp.OFPFW_NW_DST_MASK
|
|
wildcards &= v
|
|
nw_dst = ipv4_text_to_int(nw_dst)
|
|
if nw_proto:
|
|
wildcards &= ~ofp.OFPFW_NW_PROTO
|
|
|
|
match = ofp_parser.OFPMatch(wildcards, 0, 0, dl_dst, dl_vlan, 0,
|
|
dl_type, 0, nw_proto,
|
|
nw_src, nw_dst, 0, 0)
|
|
actions = actions or []
|
|
|
|
m = ofp_parser.OFPFlowMod(self.dp, match, cookie, cmd,
|
|
idle_timeout=idle_timeout,
|
|
priority=priority, actions=actions)
|
|
self.dp.send_msg(m)
|
|
|
|
def set_routing_flow(self, cookie, priority, outport, dl_vlan=0,
|
|
nw_src=0, src_mask=32, nw_dst=0, dst_mask=32,
|
|
src_mac=0, dst_mac=0, idle_timeout=0, **dummy):
|
|
ofp_parser = self.dp.ofproto_parser
|
|
|
|
dl_type = ether.ETH_TYPE_IP
|
|
|
|
# Decrement TTL value is not supported at OpenFlow V1.0
|
|
actions = []
|
|
if src_mac:
|
|
actions.append(ofp_parser.OFPActionSetDlSrc(
|
|
mac_lib.haddr_to_bin(src_mac)))
|
|
if dst_mac:
|
|
actions.append(ofp_parser.OFPActionSetDlDst(
|
|
mac_lib.haddr_to_bin(dst_mac)))
|
|
if outport is not None:
|
|
actions.append(ofp_parser.OFPActionOutput(outport))
|
|
|
|
self.set_flow(cookie, priority, dl_type=dl_type, dl_vlan=dl_vlan,
|
|
nw_src=nw_src, src_mask=src_mask,
|
|
nw_dst=nw_dst, dst_mask=dst_mask,
|
|
idle_timeout=idle_timeout, actions=actions)
|
|
|
|
def delete_flow(self, flow_stats):
|
|
match = flow_stats.match
|
|
cookie = flow_stats.cookie
|
|
cmd = self.dp.ofproto.OFPFC_DELETE_STRICT
|
|
priority = flow_stats.priority
|
|
actions = []
|
|
|
|
flow_mod = self.dp.ofproto_parser.OFPFlowMod(
|
|
self.dp, match, cookie, cmd, priority=priority, actions=actions)
|
|
self.dp.send_msg(flow_mod)
|
|
self.logger.info('Delete flow [cookie=0x%x]', cookie, extra=self.sw_id)
|
|
|
|
|
|
class OfCtl_after_v1_2(OfCtl):
|
|
|
|
def __init__(self, dp, logger):
|
|
super(OfCtl_after_v1_2, self).__init__(dp, logger)
|
|
|
|
def set_sw_config_for_ttl(self):
|
|
pass
|
|
|
|
def get_packetin_inport(self, msg):
|
|
in_port = self.dp.ofproto.OFPP_ANY
|
|
for match_field in msg.match.fields:
|
|
if match_field.header == self.dp.ofproto.OXM_OF_IN_PORT:
|
|
in_port = match_field.value
|
|
break
|
|
return in_port
|
|
|
|
def get_all_flow(self, waiters):
|
|
pass
|
|
|
|
def set_flow(self, cookie, priority, dl_type=0, dl_dst=0, dl_vlan=0,
|
|
nw_src=0, src_mask=32, nw_dst=0, dst_mask=32,
|
|
nw_proto=0, idle_timeout=0, actions=None):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
cmd = ofp.OFPFC_ADD
|
|
|
|
# Match
|
|
match = ofp_parser.OFPMatch()
|
|
if dl_type:
|
|
match.set_dl_type(dl_type)
|
|
if dl_dst:
|
|
match.set_dl_dst(dl_dst)
|
|
if dl_vlan:
|
|
match.set_vlan_vid(dl_vlan)
|
|
if nw_src:
|
|
match.set_ipv4_src_masked(ipv4_text_to_int(nw_src),
|
|
mask_ntob(src_mask))
|
|
if nw_dst:
|
|
match.set_ipv4_dst_masked(ipv4_text_to_int(nw_dst),
|
|
mask_ntob(dst_mask))
|
|
if nw_proto:
|
|
if dl_type == ether.ETH_TYPE_IP:
|
|
match.set_ip_proto(nw_proto)
|
|
elif dl_type == ether.ETH_TYPE_ARP:
|
|
match.set_arp_opcode(nw_proto)
|
|
|
|
# Instructions
|
|
actions = actions or []
|
|
inst = [ofp_parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
|
|
actions)]
|
|
|
|
m = ofp_parser.OFPFlowMod(self.dp, cookie, 0, 0, cmd, idle_timeout,
|
|
0, priority, UINT32_MAX, ofp.OFPP_ANY,
|
|
ofp.OFPG_ANY, 0, match, inst)
|
|
self.dp.send_msg(m)
|
|
|
|
def set_routing_flow(self, cookie, priority, outport, dl_vlan=0,
|
|
nw_src=0, src_mask=32, nw_dst=0, dst_mask=32,
|
|
src_mac=0, dst_mac=0, idle_timeout=0, dec_ttl=False):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
|
|
dl_type = ether.ETH_TYPE_IP
|
|
|
|
actions = []
|
|
if dec_ttl:
|
|
actions.append(ofp_parser.OFPActionDecNwTtl())
|
|
if src_mac:
|
|
actions.append(ofp_parser.OFPActionSetField(eth_src=src_mac))
|
|
if dst_mac:
|
|
actions.append(ofp_parser.OFPActionSetField(eth_dst=dst_mac))
|
|
if outport is not None:
|
|
actions.append(ofp_parser.OFPActionOutput(outport, 0))
|
|
|
|
self.set_flow(cookie, priority, dl_type=dl_type, dl_vlan=dl_vlan,
|
|
nw_src=nw_src, src_mask=src_mask,
|
|
nw_dst=nw_dst, dst_mask=dst_mask,
|
|
idle_timeout=idle_timeout, actions=actions)
|
|
|
|
def delete_flow(self, flow_stats):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
|
|
cmd = ofp.OFPFC_DELETE
|
|
cookie = flow_stats.cookie
|
|
cookie_mask = UINT64_MAX
|
|
match = ofp_parser.OFPMatch()
|
|
inst = []
|
|
|
|
flow_mod = ofp_parser.OFPFlowMod(self.dp, cookie, cookie_mask, 0, cmd,
|
|
0, 0, 0, UINT32_MAX, ofp.OFPP_ANY,
|
|
ofp.OFPG_ANY, 0, match, inst)
|
|
self.dp.send_msg(flow_mod)
|
|
self.logger.info('Delete flow [cookie=0x%x]', cookie, extra=self.sw_id)
|
|
|
|
|
|
@OfCtl.register_of_version(ofproto_v1_2.OFP_VERSION)
|
|
class OfCtl_v1_2(OfCtl_after_v1_2):
|
|
|
|
def __init__(self, dp, logger):
|
|
super(OfCtl_v1_2, self).__init__(dp, logger)
|
|
|
|
def set_sw_config_for_ttl(self):
|
|
flags = self.dp.ofproto.OFPC_INVALID_TTL_TO_CONTROLLER
|
|
miss_send_len = UINT16_MAX
|
|
m = self.dp.ofproto_parser.OFPSetConfig(self.dp, flags,
|
|
miss_send_len)
|
|
self.dp.send_msg(m)
|
|
self.logger.info('Set SW config for TTL error packet in.',
|
|
extra=self.sw_id)
|
|
|
|
def get_all_flow(self, waiters):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
|
|
match = ofp_parser.OFPMatch()
|
|
stats = ofp_parser.OFPFlowStatsRequest(self.dp, 0, ofp.OFPP_ANY,
|
|
ofp.OFPG_ANY, 0, 0, match)
|
|
return self.send_stats_request(stats, waiters)
|
|
|
|
|
|
@OfCtl.register_of_version(ofproto_v1_3.OFP_VERSION)
|
|
class OfCtl_v1_3(OfCtl_after_v1_2):
|
|
|
|
def __init__(self, dp, logger):
|
|
super(OfCtl_v1_3, self).__init__(dp, logger)
|
|
|
|
def set_sw_config_for_ttl(self):
|
|
packet_in_mask = (1 << self.dp.ofproto.OFPR_ACTION |
|
|
1 << self.dp.ofproto.OFPR_INVALID_TTL)
|
|
port_status_mask = (1 << self.dp.ofproto.OFPPR_ADD |
|
|
1 << self.dp.ofproto.OFPPR_DELETE |
|
|
1 << self.dp.ofproto.OFPPR_MODIFY)
|
|
flow_removed_mask = (1 << self.dp.ofproto.OFPRR_IDLE_TIMEOUT |
|
|
1 << self.dp.ofproto.OFPRR_HARD_TIMEOUT |
|
|
1 << self.dp.ofproto.OFPRR_DELETE)
|
|
m = self.dp.ofproto_parser.OFPSetAsync(
|
|
self.dp, [packet_in_mask, 0], [port_status_mask, 0],
|
|
[flow_removed_mask, 0])
|
|
self.dp.send_msg(m)
|
|
self.logger.info('Set SW config for TTL error packet in.',
|
|
extra=self.sw_id)
|
|
|
|
def get_all_flow(self, waiters):
|
|
ofp = self.dp.ofproto
|
|
ofp_parser = self.dp.ofproto_parser
|
|
|
|
match = ofp_parser.OFPMatch()
|
|
stats = ofp_parser.OFPFlowStatsRequest(self.dp, 0, 0, ofp.OFPP_ANY,
|
|
ofp.OFPG_ANY, 0, 0, match)
|
|
return self.send_stats_request(stats, waiters)
|
|
|
|
|
|
def ip_addr_aton(ip_str, err_msg=None):
|
|
try:
|
|
return addrconv.ipv4.bin_to_text(socket.inet_aton(ip_str))
|
|
except (struct.error, socket.error) as e:
|
|
if err_msg is not None:
|
|
e.message = '%s %s' % (err_msg, e.message)
|
|
raise ValueError(e.message)
|
|
|
|
|
|
def ip_addr_ntoa(ip):
|
|
return socket.inet_ntoa(addrconv.ipv4.text_to_bin(ip))
|
|
|
|
|
|
def mask_ntob(mask, err_msg=None):
|
|
try:
|
|
return (UINT32_MAX << (32 - mask)) & UINT32_MAX
|
|
except ValueError:
|
|
msg = 'illegal netmask'
|
|
if err_msg is not None:
|
|
msg = '%s %s' % (err_msg, msg)
|
|
raise ValueError(msg)
|
|
|
|
|
|
def ipv4_apply_mask(address, prefix_len, err_msg=None):
|
|
import itertools
|
|
|
|
assert isinstance(address, str)
|
|
address_int = ipv4_text_to_int(address)
|
|
return ipv4_int_to_text(address_int & mask_ntob(prefix_len, err_msg))
|
|
|
|
|
|
def ipv4_int_to_text(ip_int):
|
|
assert isinstance(ip_int, numbers.Integral)
|
|
return addrconv.ipv4.bin_to_text(struct.pack('!I', ip_int))
|
|
|
|
|
|
def ipv4_text_to_int(ip_text):
|
|
if ip_text == 0:
|
|
return ip_text
|
|
assert isinstance(ip_text, str)
|
|
return struct.unpack('!I', addrconv.ipv4.text_to_bin(ip_text))[0]
|
|
|
|
|
|
def nw_addr_aton(nw_addr, err_msg=None):
|
|
ip_mask = nw_addr.split('/')
|
|
default_route = ip_addr_aton(ip_mask[0], err_msg=err_msg)
|
|
netmask = 32
|
|
if len(ip_mask) == 2:
|
|
try:
|
|
netmask = int(ip_mask[1])
|
|
except ValueError as e:
|
|
if err_msg is not None:
|
|
e.message = '%s %s' % (err_msg, e.message)
|
|
raise ValueError(e.message)
|
|
if netmask < 0:
|
|
msg = 'illegal netmask'
|
|
if err_msg is not None:
|
|
msg = '%s %s' % (err_msg, msg)
|
|
raise ValueError(msg)
|
|
nw_addr = ipv4_apply_mask(default_route, netmask, err_msg)
|
|
return nw_addr, netmask, default_route
|