def _generate_config_bpdu(self, flags):
src_mac = self.ofport.hw_addr
dst_mac = bpdu.BRIDGE_GROUP_ADDRESS
length = (bpdu.bpdu._PACK_LEN + bpdu.ConfigurationBPDUs.PACK_LEN +
llc.llc._PACK_LEN + llc.ControlFormatU._PACK_LEN)
e = ethernet.ethernet(dst_mac, src_mac, length)
l = llc.llc(llc.SAP_BPDU, llc.SAP_BPDU, llc.ControlFormatU())
b = bpdu.ConfigurationBPDUs(
flags=flags,
root_priority=self.port_priority.root_id.priority,
root_mac_address=self.port_priority.root_id.mac_addr,
root_path_cost=self.port_priority.root_path_cost + self.path_cost,
bridge_priority=self.bridge_id.priority,
bridge_mac_address=self.bridge_id.mac_addr,
port_priority=self.port_id.priority,
port_number=self.ofport.port_no,
message_age=self.port_times.message_age + 1,
max_age=self.port_times.max_age,
hello_time=self.port_times.hello_time,
forward_delay=self.port_times.forward_delay)
pkt = packet.Packet()
pkt.add_protocol(e)
pkt.add_protocol(l)
pkt.add_protocol(b)
pkt.serialize()
return pkt.data
def __call__(self, policy, rule, port_thread, buf):
pkt = packet.Packet(buf)
raise Exception("Packet {} raised exception on port: {}: {}".format(
str(pkt),
(port_thread.port.subnet.subnet_id, port_thread.port.port_id),
self.message,
))
def lldp_parse(data):
pkt = packet.Packet(data)
i = iter(pkt)
eth_pkt = six.next(i)
assert type(eth_pkt) == ethernet.ethernet
lldp_pkt = six.next(i)
if type(lldp_pkt) != lldp.lldp:
raise LLDPPacket.LLDPUnknownFormat()
tlv_chassis_id = lldp_pkt.tlvs[0]
if tlv_chassis_id.subtype != lldp.ChassisID.SUB_LOCALLY_ASSIGNED:
raise LLDPPacket.LLDPUnknownFormat(
msg='unknown chassis id subtype %d' % tlv_chassis_id.subtype)
chassis_id = tlv_chassis_id.chassis_id.decode('utf-8')
if not chassis_id.startswith(LLDPPacket.CHASSIS_ID_PREFIX):
raise LLDPPacket.LLDPUnknownFormat(
msg='unknown chassis id format %s' % chassis_id)
src_dpid = str_to_dpid(chassis_id[LLDPPacket.CHASSIS_ID_PREFIX_LEN:])
tlv_port_id = lldp_pkt.tlvs[1]
if tlv_port_id.subtype != lldp.PortID.SUB_PORT_COMPONENT:
raise LLDPPacket.LLDPUnknownFormat(
msg='unknown port id subtype %d' % tlv_port_id.subtype)
port_id = tlv_port_id.port_id
if len(port_id) != LLDPPacket.PORT_ID_SIZE:
raise LLDPPacket.LLDPUnknownFormat(msg='unknown port id %d' %
port_id)
(src_port_no, ) = struct.unpack(LLDPPacket.PORT_ID_STR, port_id)
return src_dpid, src_port_no
def __call__(self, buf):
pkt = packet.Packet(buf)
pkt_dhcp_protocol = pkt.get_protocol(dhcp.dhcp)
if not pkt_dhcp_protocol:
return False
dhcp_type = _get_dhcp_message_type_opt(pkt_dhcp_protocol)
return dhcp_type == self.get_dhcp_packet_type()
def test_serialize(self):
pkt = packet.Packet()
eth_pkt = ethernet.ethernet('b0:a8:6e:18:b8:08', '64:87:88:e9:cb:c8')
pkt.add_protocol(eth_pkt)
ip_pkt = ipv4.ipv4(src='172.28.3.1',
dst='172.28.3.2',
tos=192,
identification=26697,
proto=inet.IPPROTO_UDP)
pkt.add_protocol(ip_pkt)
udp_pkt = udp.udp(49152, 3784)
pkt.add_protocol(udp_pkt)
bfd_pkt = bfd.bfd(ver=1,
diag=bfd.BFD_DIAG_CTRL_DETECT_TIME_EXPIRED,
state=bfd.BFD_STATE_UP,
detect_mult=3,
my_discr=6,
your_discr=7,
desired_min_tx_interval=60000,
required_min_rx_interval=60000,
required_min_echo_rx_interval=0)
pkt.add_protocol(bfd_pkt)
eq_(len(pkt.protocols), 4)
pkt.serialize()
eq_(pkt.data, self.data)
def test_serialize(self):
pkt = packet.Packet()
dst = lldp.LLDP_MAC_NEAREST_BRIDGE
src = '00:04:96:1f:a7:26'
ethertype = ether.ETH_TYPE_LLDP
eth_pkt = ethernet.ethernet(dst, src, ethertype)
pkt.add_protocol(eth_pkt)
tlv_chassis_id = lldp.ChassisID(
subtype=lldp.ChassisID.SUB_MAC_ADDRESS,
chassis_id=addrconv.mac.text_to_bin(src))
tlv_port_id = lldp.PortID(subtype=lldp.PortID.SUB_INTERFACE_NAME,
port_id=b'1/3')
tlv_ttl = lldp.TTL(ttl=120)
tlv_end = lldp.End()
tlvs = (tlv_chassis_id, tlv_port_id, tlv_ttl, tlv_end)
lldp_pkt = lldp.lldp(tlvs)
pkt.add_protocol(lldp_pkt)
eq_(len(pkt.protocols), 2)
pkt.serialize()
# Note: If ethernet frame is less than 60 bytes length,
# ethernet.ethernet() appends padding to the payload.
# So, we splits the serialized data to compare.
data_len = len(self.data)
pkt_data_lldp = pkt.data[:data_len]
pkt_data_pad = pkt.data[data_len:]
eq_(b'\x00' * (60 - data_len), pkt_data_pad)
eq_(self.data, pkt_data_lldp)
def __packet_in_filter(self, ev):
pkt = packet.Packet(ev.msg.data)
if not packet_in_handler.pkt_in_filter.filter(pkt):
if logging:
LOG.debug('The packet is discarded by %s: %s', cls, pkt)
return
return packet_in_handler(self, ev)
def test_create_packet(self):
primary_ip = '192.168.0.2'
p0 = self.vrrpv3.create_packet(primary_ip)
p0.serialize()
p1 = packet.Packet(six.binary_type(p0.data))
p1.serialize()
eq_(p0.data, p1.data)
def _handle_invalid_dest(self, msg):
"""
Handle a packet sent to the router interface (by IP). Since only ping
and ARP are supported, everything else is responded to with a
Destination Unreachable message.
:param msg: Packet in message
:type msg: os_ken.ofproto.ofproto_v<version>_parser.OFPPacketIn
"""
# If the destination is router interface, the unique key of router
# interface will be set to reg7 before sending to local controller.
# Code will hit here only when the router interface is not
# concrete.
if self.port_icmp_unreach_respond_rate_limit():
LOG.warning(
"Get more than %(rate)s packets to router port "
"per second at table %(table)s",
{'rate': self.conf.router_port_unreach_max_rate,
'table': const.L3_LOOKUP_TABLE})
return
# Response icmp unreachable to udp or tcp.
pkt = packet.Packet(msg.data)
tcp_pkt = pkt.get_protocol(tcp.tcp)
udp_pkt = pkt.get_protocol(udp.udp)
if tcp_pkt or udp_pkt:
icmp_dst_unreach = icmp_error_generator.generate(
icmp.ICMP_DEST_UNREACH, icmp.ICMP_PORT_UNREACH_CODE,
msg.data, pkt=pkt)
unique_key = msg.match.get('reg6')
self.dispatch_packet(icmp_dst_unreach, unique_key)
def _create_test_dhcp6_packet(self, zero_time=False):
ret_pkt = packet.Packet()
ret_pkt.add_protocol(
ethernet.ethernet(
ethertype=ether_types.ETH_TYPE_IPV6,
dst='33:33:00:01:00:02',
src=self.port_info['mac_address']))
ret_pkt.add_protocol(
ipv6.ipv6(
src='fe80::f816:3eff:fe60:714b',
dst='ff02::1:2',
nxt=inet.IPPROTO_UDP))
ret_pkt.add_protocol(
udp.udp(
src_port=constants.DHCPV6_RESPONSE_PORT,
dst_port=constants.DHCPV6_CLIENT_PORT))
options = [dhcp6.option(
code=1,
data=b"\x00\x01\x00\x01",
length=4)]
if zero_time:
options.append(dhcp6.option(
code=3,
data=b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
length=12))
else:
options.append(dhcp6.option(
code=3,
data=b"\x01\x02\x03\x04\x05\x06\x07\x08\x0a\x0b\x0c\x0d",
length=12))
ret_pkt.add_protocol(dhcp6.dhcp6(
dhcp6.DHCPV6_REQUEST, dhcp6.options(option_list=options)))
return ret_pkt
def _create_test_dhcp_request_packet(self):
option_list = []
bin_server = addrconv.ipv4.text_to_bin('192.168.1.1')
option_list.append(
dhcp.option(tag=dhcp.DHCP_SERVER_IDENTIFIER_OPT, value=bin_server))
option_list.append(
dhcp.option(tag=dhcp.DHCP_MESSAGE_TYPE_OPT, value=b'\x03'))
options = dhcp.options(option_list=option_list)
ret_pkt = packet.Packet()
ret_pkt.add_protocol(
ethernet.ethernet(dst="ff:ff:ff:ff:ff:ff",
src=self.port_info['mac_address']))
ret_pkt.add_protocol(
ipv4.ipv4(dst="255.255.255.255",
src="0.0.0.0",
proto=inet.IPPROTO_UDP))
ret_pkt.add_protocol(
udp.udp(src_port=constants.DHCP_CLIENT_PORT,
dst_port=constants.DHCP_RESPONSE_PORT))
ret_pkt.add_protocol(
dhcp.dhcp(op=dhcp.DHCP_BOOT_REQUEST,
chaddr=self.port_info['mac_address'],
siaddr='0.0.0.0',
xid=3454038351,
options=options))
return ret_pkt
def test_parse(self):
buf = self.data
pkt = packet.Packet(buf)
i = iter(pkt)
eq_(type(next(i)), ethernet.ethernet)
eq_(type(next(i)), lldp.lldp)
def lldp_packet(dpid, port_no, dl_addr, ttl):
pkt = packet.Packet()
dst = lldp.LLDP_MAC_NEAREST_BRIDGE
src = dl_addr
ethertype = ETH_TYPE_LLDP
eth_pkt = ethernet.ethernet(dst, src, ethertype)
pkt.add_protocol(eth_pkt)
tlv_chassis_id = lldp.ChassisID(
subtype=lldp.ChassisID.SUB_LOCALLY_ASSIGNED,
chassis_id=(LLDPPacket.CHASSIS_ID_FMT %
dpid_to_str(dpid)).encode('ascii'))
tlv_port_id = lldp.PortID(subtype=lldp.PortID.SUB_PORT_COMPONENT,
port_id=struct.pack(LLDPPacket.PORT_ID_STR,
port_no))
tlv_ttl = lldp.TTL(ttl=ttl)
tlv_end = lldp.End()
tlvs = (tlv_chassis_id, tlv_port_id, tlv_ttl, tlv_end)
lldp_pkt = lldp.lldp(tlvs)
pkt.add_protocol(lldp_pkt)
pkt.serialize()
return pkt.data
def __call__(self, buf):
pkt = packet.Packet(buf)
vlan_pkt = pkt.get_protocol(vlan.vlan)
if not vlan_pkt:
return False
if self.tag and self.tag != vlan_pkt.vid:
return False
return True
def _build_itag(self):
b_src_mac = '00:07:0d:af:f4:54'
b_dst_mac = '00:00:00:00:00:00'
b_ethertype = ether.ETH_TYPE_8021AD
e1 = ethernet.ethernet(b_dst_mac, b_src_mac, b_ethertype)
b_pcp = 0
b_cfi = 0
b_vid = 32
b_ethertype = ether.ETH_TYPE_8021Q
bt = vlan.svlan(b_pcp, b_cfi, b_vid, b_ethertype)
c_src_mac = '11:11:11:11:11:11'
c_dst_mac = 'aa:aa:aa:aa:aa:aa'
c_ethertype = ether.ETH_TYPE_8021AD
e2 = ethernet.ethernet(c_dst_mac, c_src_mac, c_ethertype)
s_pcp = 0
s_cfi = 0
s_vid = 32
s_ethertype = ether.ETH_TYPE_8021Q
st = vlan.svlan(s_pcp, s_cfi, s_vid, s_ethertype)
c_pcp = 0
c_cfi = 0
c_vid = 32
c_ethertype = ether.ETH_TYPE_IP
ct = vlan.vlan(c_pcp, c_cfi, c_vid, c_ethertype)
version = 4
header_length = 20
tos = 0
total_length = 24
identification = 0x8a5d
flags = 0
offset = 1480
ttl = 64
proto = inet.IPPROTO_ICMP
csum = 0xa7f2
src = '131.151.32.21'
dst = '131.151.32.129'
option = b'TEST'
ip = ipv4.ipv4(version, header_length, tos, total_length,
identification, flags, offset, ttl, proto, csum, src,
dst, option)
p = packet.Packet()
p.add_protocol(e1)
p.add_protocol(bt)
p.add_protocol(self.it)
p.add_protocol(e2)
p.add_protocol(st)
p.add_protocol(ct)
p.add_protocol(ip)
p.serialize()
return p
def send_arp_request(self, src_mac, src_ip, dst_ip, port_key):
arp_request_pkt = packet.Packet()
arp_request_pkt.add_protocol(
ethernet.ethernet(ethertype=ether.ETH_TYPE_ARP, src=src_mac))
arp_request_pkt.add_protocol(
arp.arp(src_mac=src_mac, src_ip=src_ip, dst_ip=dst_ip))
self.dispatch_packet(arp_request_pkt, port_key)
def test_parse(self):
buf = self.data
pkt = packet.Packet(buf)
i = iter(pkt)
eq_(type(next(i)), ethernet.ethernet)
eq_(type(next(i)), ipv4.ipv4)
eq_(type(next(i)), udp.udp)
eq_(type(bfd.bfd.parser(next(i))[0]), bfd.bfd)
def __call__(self, buf):
pkt = packet.Packet(buf)
if self.ethertype == n_const.IPv4:
pkt_icmp_protocol = pkt.get_protocol(icmp.icmp)
else:
pkt_icmp_protocol = pkt.get_protocol(icmpv6.icmpv6)
if not pkt_icmp_protocol:
return False
return self.filter_icmp(pkt, pkt_icmp_protocol)
def bfd_packet(src_mac,
dst_mac,
src_ip,
dst_ip,
ipv4_id,
src_port,
dst_port,
diag=0,
state=0,
flags=0,
detect_mult=0,
my_discr=0,
your_discr=0,
desired_min_tx_interval=0,
required_min_rx_interval=0,
required_min_echo_rx_interval=0,
auth_cls=None):
"""
Generate BFD packet with Ethernet/IPv4/UDP encapsulated.
"""
# Generate ethernet header first.
pkt = packet.Packet()
eth_pkt = ethernet.ethernet(dst_mac, src_mac, ETH_TYPE_IP)
pkt.add_protocol(eth_pkt)
# IPv4 encapsulation
# set ToS to 192 (Network control/CS6)
# set TTL to 255 (RFC5881 Section 5.)
ipv4_pkt = ipv4.ipv4(proto=inet.IPPROTO_UDP,
src=src_ip,
dst=dst_ip,
tos=192,
identification=ipv4_id,
ttl=255)
pkt.add_protocol(ipv4_pkt)
# UDP encapsulation
udp_pkt = udp.udp(src_port=src_port, dst_port=dst_port)
pkt.add_protocol(udp_pkt)
# BFD payload
bfd_pkt = bfd.bfd(
ver=1,
diag=diag,
state=state,
flags=flags,
detect_mult=detect_mult,
my_discr=my_discr,
your_discr=your_discr,
desired_min_tx_interval=desired_min_tx_interval,
required_min_rx_interval=required_min_rx_interval,
required_min_echo_rx_interval=required_min_echo_rx_interval,
auth_cls=auth_cls)
pkt.add_protocol(bfd_pkt)
pkt.serialize()
return pkt.data
def packet_in_handler(self, event):
if event.msg.match['in_port'] != FAKEPORT:
return
pkt = packet.Packet(event.msg.data)
eth_protocol = pkt.get_protocol(ethernet.ethernet)
vlan_protocol = pkt.get_protocol(vlan.vlan)
ipv6_protocol = pkt.get_protocol(ipv6.ipv6)
icmpv6_protocol = pkt.get_protocol(icmpv6.icmpv6)
if not (eth_protocol and vlan_protocol and ipv6_protocol
and icmpv6_protocol):
return
if icmpv6_protocol.type_ != icmpv6.ND_NEIGHBOR_SOLICIT:
return
if int(ipaddress.ip_address(ipv6_protocol.src)) == 0:
return
src_ip = ipaddress.ip_address(icmpv6_protocol.data.dst)
if src_ip.is_reserved:
return
eth_dst = eth_protocol.src
dst_ip = ipv6_protocol.src
eth_src = FAKECLIENTMAC
vid = vlan_protocol.vid
reply = packet.Packet()
for protocol in (ethernet.ethernet(eth_dst, eth_src,
ether.ETH_TYPE_8021Q),
vlan.vlan(vid=vid, ethertype=ether.ETH_TYPE_IPV6),
ipv6.ipv6(src=src_ip,
dst=dst_ip,
nxt=socket.IPPROTO_ICMPV6,
hop_limit=255),
icmpv6.icmpv6(
type_=icmpv6.ND_NEIGHBOR_ADVERT,
data=icmpv6.nd_neighbor(
dst=src_ip,
option=icmpv6.nd_option_tla(hw_src=eth_src),
res=7))):
reply.add_protocol(protocol)
reply.serialize()
out = parser.OFPPacketOut(datapath=event.msg.datapath,
buffer_id=ofp.OFP_NO_BUFFER,
in_port=ofp.OFPP_CONTROLLER,
actions=[parser.OFPActionOutput(FAKEPORT)],
data=reply.data)
self.send_mods(event.msg.datapath, [out])
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
dst = eth.dst
src = eth.src
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)
# learn a mac address to avoid FLOOD next time.
self.mac_to_port[dpid][src] = in_port
if dst in self.mac_to_port[dpid]:
out_port = self.mac_to_port[dpid][dst]
else:
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
# install a flow to avoid packet_in next time
if out_port != ofproto.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
# verify if we have a valid buffer_id, if yes avoid to send both
# flow_mod & packet_out
if msg.buffer_id != ofproto.OFP_NO_BUFFER:
self.add_flow(datapath, 1, match, actions, msg.buffer_id)
return
else:
self.add_flow(datapath, 1, match, actions)
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
out = parser.OFPPacketOut(datapath=datapath,
buffer_id=msg.buffer_id,
in_port=in_port,
actions=actions,
data=data)
datapath.send_msg(out)
def __call__(self, buf):
pkt = packet.Packet(buf)
pkt_arp_protocol = pkt.get_protocol(arp.arp)
if (not pkt_arp_protocol) or (pkt_arp_protocol.opcode !=
arp.ARP_REQUEST):
return False
if self.arp_tpa is not None:
return pkt_arp_protocol.dst_ip == self.arp_tpa
return True
def packet_in_handler(self, evt):
"""PacketIn event handler. when the received packet was LACP,
proceed it. otherwise, send a event."""
req_pkt = packet.Packet(evt.msg.data)
if slow.lacp in req_pkt:
(req_lacp, ) = req_pkt.get_protocols(slow.lacp)
(req_eth, ) = req_pkt.get_protocols(ethernet.ethernet)
self._do_lacp(req_lacp, req_eth.src, evt.msg)
else:
self.send_event_to_observers(EventPacketIn(evt.msg))
def test_create_packet(self):
primary_ip = '2001:db8:2000::3'
p0 = self.vrrpv3.create_packet(primary_ip)
p0.serialize()
print(len(p0.data), p0.data)
p1 = packet.Packet(six.binary_type(p0.data))
p1.serialize()
print(len(p0.data), p0.data)
print(len(p1.data), p1.data)
eq_(p0.data, p1.data)
def _packet_in_handler(self, event):
msg = event.msg
datapath = msg.datapath
ofproto = datapath.ofproto
if msg.reason != ofproto.OFPR_ACTION:
LOG.debug("DHCP Controller only handle the packet which "
"match the rules and the action is send to the "
"controller.")
return
of_in_port = msg.match['in_port']
LOG.info("DHCP Controller packet in OF port: %s", of_in_port)
pkt = packet.Packet(data=msg.data)
LOG.debug(
'DHCP Controller packet received: '
'buffer_id=%x total_len=%d reason=ACTION '
'table_id=%d cookie=%d match=%s pkt=%s', msg.buffer_id,
msg.total_len, msg.table_id, msg.cookie, msg.match, pkt)
if self.version == IPV4_STR:
ip_protocol = ipv4.ipv4
dhcp_protocol = dhcp.dhcp
else:
ip_protocol = ipv6.ipv6
dhcp_protocol = dhcp6.dhcp6
ip_header = pkt.get_protocol(ip_protocol)
if not ip_header:
LOG.warning(
"DHCP Controller received packet "
"is not an IP%s packet", self.version)
return
dhcp_pkt = pkt.get_protocol(dhcp_protocol)
if not dhcp_pkt:
LOG.warning(
"DHCP Controller received packet "
"is not a DHCP%s packet", self.version)
return
eth_pkt = pkt.get_protocol(ethernet.ethernet)
port_id = self.get_port_id_from_br(of_in_port, eth_pkt.src)
LOG.debug(
"DHCP Controller received DHCP%s packet's neutron port "
"id: %s", self.version, port_id)
port_info = self.ext_api.get_port_info(port_id)
LOG.debug(
"DHCP Controller received DHCP%s packet's neutron port "
"info: %s", self.version, port_info)
if not port_info:
return
self.handle_dhcp(datapath, of_in_port, pkt, port_info)
def _create_response(self, datapath, port, req):
"""create a packet including LACP."""
src = datapath.ports[port].hw_addr
res_ether = ethernet.ethernet(slow.SLOW_PROTOCOL_MULTICAST, src,
ether.ETH_TYPE_SLOW)
res_lacp = self._create_lacp(datapath, port, req)
res_pkt = packet.Packet()
res_pkt.add_protocol(res_ether)
res_pkt.add_protocol(res_lacp)
res_pkt.serialize()
return res_pkt
def __call__(self, buf):
pkt = packet.Packet(buf)
pkt_udp = pkt.get_protocol(udp.udp)
if pkt_udp is None:
return False
if self._dst_port is not None and pkt_udp.dst_port != self._dst_port:
return False
return True
def __call__(self, buf):
pkt = packet.Packet(buf)
pkt_mpls = pkt.get_protocol(mpls.mpls)
if pkt_mpls is None:
return False
if self._label is not None and pkt_mpls.label != self._label:
return False
return True
def _do_leave(self, leave, in_port, msg):
"""the process when the snooper received a LEAVE message."""
datapath = msg.datapath
dpid = datapath.id
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# check whether the querier port has been specified.
if not self._to_querier.get(dpid):
self.logger.info("no querier exists.")
return
# save this LEAVE message and reset the condition of the port
# that received this message.
self._to_hosts.setdefault(dpid, {})
self._to_hosts[dpid].setdefault(leave.address, {
'replied': False,
'leave': None,
'ports': {}
})
self._to_hosts[dpid][leave.address]['leave'] = msg
self._to_hosts[dpid][leave.address]['ports'][in_port] = {
'out': False,
'in': False
}
# create a specific query.
timeout = igmp.LAST_MEMBER_QUERY_INTERVAL
res_igmp = igmp.igmp(msgtype=igmp.IGMP_TYPE_QUERY,
maxresp=timeout * 10,
csum=0,
address=leave.address)
res_ipv4 = ipv4.ipv4(total_length=len(ipv4.ipv4()) + len(res_igmp),
proto=inet.IPPROTO_IGMP,
ttl=1,
src=self._to_querier[dpid]['ip'],
dst=igmp.MULTICAST_IP_ALL_HOST)
res_ether = ethernet.ethernet(dst=igmp.MULTICAST_MAC_ALL_HOST,
src=self._to_querier[dpid]['mac'],
ethertype=ether.ETH_TYPE_IP)
res_pkt = packet.Packet()
res_pkt.add_protocol(res_ether)
res_pkt.add_protocol(res_ipv4)
res_pkt.add_protocol(res_igmp)
res_pkt.serialize()
# send a specific query to the host that sent this message.
actions = [parser.OFPActionOutput(ofproto.OFPP_IN_PORT)]
self._do_packet_out(datapath, res_pkt.data, in_port, actions)
# wait for REPORT messages.
hub.spawn(self._do_timeout_for_leave, timeout, datapath, leave.address,
in_port)
def packet_in_handler(self, ev):
msg = ev.msg
cookie_id = msg.cookie
pkt = packet.Packet(msg.data)
try:
cookie_entry = self._get_cookie_by_id(cookie_id)
LOG.info(
"action=%s project_id=%s log_resource_ids=%s vm_port=%s "
"pkt=%s", cookie_entry.action, cookie_entry.project,
list(cookie_entry.log_object_refs), cookie_entry.port, pkt)
except log_exc.CookieNotFound:
LOG.warning("Unknown cookie=%s packet_in pkt=%s", cookie_id, pkt)
