def create_eth_packet_with_vlan(pktlen=60,
dl_src=None,
dl_dst=None,
dl_vlan=0,
dl_vlan_pcp=2,
dl_vlan_cfi=0):
print "fields are: dst: %s, src: %s, prio: %d, id: %d, vlan: %d" % (
dl_dst, dl_src, dl_vlan_pcp, dl_vlan_cfi, dl_vlan)
if dl_dst is None or dl_src is None:
return None
if MINSIZE > pktlen:
pktlen = MINSIZE
pkt = scapy.Ether(type=0x800,
dst='ff:ff:ff:ff:ff:ff',
src='00:00:00:00:00:01') / scapy.Dot1Q(
vlan=int(dl_vlan)) / scapy.Dot1Q(
vlan=int(dl_vlan)) / "TEST!!!!!!!!"
# create the packet data (junk data)
pkt = pkt / ("v" * (pktlen - len(pkt)))
print "send the following vlan packet: %s" % (str(
scapy.Ether(str(pkt)).show()))
print pkt.payload
return pkt
def qinq_tcp_packet(pktlen=100,
eth_dst='00:01:02:03:04:05',
eth_src='00:06:07:08:09:0a',
dl_vlan_outer=20,
dl_vlan_pcp_outer=0,
dl_vlan_cfi_outer=0,
vlan_vid=10,
vlan_pcp=0,
dl_vlan_cfi=0,
ip_src='192.168.0.1',
ip_dst='192.168.0.2',
ip_tos=0,
ip_ttl=64,
tcp_sport=1234,
tcp_dport=80,
ip_ihl=None,
ip_options=False):
"""
Return a doubly tagged dataplane TCP packet
Supports a few parameters:
@param len Length of packet in bytes w/o CRC
@param eth_dst Destinatino MAC
@param eth_src Source MAC
@param dl_vlan_outer Outer VLAN ID
@param dl_vlan_pcp_outer Outer VLAN priority
@param dl_vlan_cfi_outer Outer VLAN cfi bit
@param vlan_vid Inner VLAN ID
@param vlan_pcp VLAN priority
@param dl_vlan_cfi VLAN cfi bit
@param ip_src IP source
@param ip_dst IP destination
@param ip_tos IP ToS
@param tcp_dport TCP destination port
@param ip_sport TCP source port
Generates a TCP request. Users
shouldn't assume anything about this packet other than that
it is a valid ethernet/IP/TCP frame.
"""
if MINSIZE > pktlen:
pktlen = MINSIZE
# Note Dot1Q.id is really CFI
pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \
scapy.Dot1Q(prio=dl_vlan_pcp_outer, id=dl_vlan_cfi_outer, vlan=dl_vlan_outer)/ \
scapy.Dot1Q(prio=vlan_pcp, id=dl_vlan_cfi, vlan=vlan_vid)/ \
scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ttl=ip_ttl, ihl=ip_ihl)/ \
scapy.TCP(sport=tcp_sport, dport=tcp_dport)
pkt = pkt / ("D" * (pktlen - len(pkt)))
return pkt
def simple_tcp_packet(pktlen=100,
dl_dst='00:01:02:03:04:05',
dl_src='00:06:07:08:09:0a',
dl_vlan_enable=False,
dl_vlan=0,
dl_vlan_pcp=0,
dl_vlan_cfi=0,
ip_src='192.168.0.1',
ip_dst='192.168.0.2',
ip_tos=0,
tcp_sport=1234,
tcp_dport=80,
ip_ihl=None,
ip_options=False):
"""
Return a simple dataplane TCP packet
Supports a few parameters:
@param len Length of packet in bytes w/o CRC
@param dl_dst Destinatino MAC
@param dl_src Source MAC
@param dl_vlan_enable True if the packet is with vlan, False otherwise
@param dl_vlan VLAN ID
@param dl_vlan_pcp VLAN priority
@param ip_src IP source
@param ip_dst IP destination
@param ip_tos IP ToS
@param tcp_dport TCP destination port
@param ip_sport TCP source port
Generates a simple TCP request. Users
shouldn't assume anything about this packet other than that
it is a valid ethernet/IP/TCP frame.
"""
if MINSIZE > pktlen:
pktlen = MINSIZE
# Note Dot1Q.id is really CFI
if (dl_vlan_enable):
pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan)/ \
scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl)/ \
scapy.TCP(sport=tcp_sport, dport=tcp_dport)
else:
if not ip_options:
pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl)/ \
scapy.TCP(sport=tcp_sport, dport=tcp_dport)
else:
pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl, options=ip_options)/ \
scapy.TCP(sport=tcp_sport, dport=tcp_dport)
pkt = pkt / ("D" * (pktlen - len(pkt)))
#print pkt.show()
#print scapy.Ether(str(pkt)).show()
return pkt
def addVlanToPacket(self, pkt, vlanValue):
"""
This function push the received vlan tag to the received packet
"""
# gets the first layer of the current packet
layer = pkt.firstlayer()
# loop over the layers
while not isinstance(layer, scapy.NoPayload):
if 'chksum' in layer.default_fields:
del layer.chksum
if (type(layer) is scapy.Ether):
# adjust ether type
layer.type = 33024 # 0x8100
# add 802.1q layer between Ether and IP
dot1q = scapy.Dot1Q(vlan=vlanValue)
dot1q.add_payload(layer.payload)
layer.remove_payload()
layer.add_payload(dot1q)
layer = dot1q
# advance to the next layer
layer = layer.payload
def simple_ipv6_packet(pktlen=100,
dl_dst='00:01:02:03:04:05',
dl_src='00:06:07:08:09:0a',
dl_vlan_enable=False,
dl_vlan=0,
dl_vlan_pcp=0,
dl_vlan_cfi=0,
ip_src='fe80::2420:52ff:fe8f:5189',
ip_dst='fe80::2420:52ff:fe8f:5190',
ip_tos=0,
tcp_sport=0,
tcp_dport=0,
EH = False,
EHpkt = scapy.IPv6ExtHdrDestOpt()
):
"""
Return a simple dataplane IPv6 packet
Supports a few parameters:
@param len Length of packet in bytes w/o CRC
@param dl_dst Destinatino MAC
@param dl_src Source MAC
@param dl_vlan_enable True if the packet is with vlan, False otherwise
@param dl_vlan VLAN ID
@param dl_vlan_pcp VLAN priority
@param ip_src IPv6 source
@param ip_dst IPv6 destination
@param ip_tos IP ToS
@param tcp_dport TCP destination port
@param ip_sport TCP source port
Generates a simple TCP request. Users
shouldn't assume anything about this packet other than that
it is a valid ethernet/IP/TCP frame.
"""
# Note Dot1Q.id is really CFI
if (dl_vlan_enable):
pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan)/ \
scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos)
else:
pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
scapy.IPv6(src=ip_src, dst=ip_dst)
# Add IPv6 Extension Headers
if EH:
pkt = pkt / EHpkt
if (tcp_sport >0 and tcp_dport >0):
pkt = pkt / scapy.TCP(sport=tcp_sport, dport=tcp_dport)
pktlen = len(pkt) # why??
pkt = pkt/("D" * (pktlen - len(pkt)))
return pkt
def make_VLAN_hdr(vlan=None, id=None, prio=None, **kwargs):
hdr = scapy.Dot1Q()
if vlan:
hdr.vlan = vlan
if id:
hdr.id = id
if prio:
hdr.prio = prio
return hdr
def gen_packet(vid):
eth = scapy.Ether(src='02:1e:67:9f:4d:ae', dst='06:16:3e:1b:72:32')
vlan1 = scapy.Dot1AD(vlan=vid)
vlan2 = scapy.Dot1Q(vlan=vid)
ip = scapy.IP()
udp = scapy.UDP(sport=10001, dport=10002)
payload = 'truculence'
single_tag = eth / vlan2 / ip / udp / payload
double_tag = eth / vlan1 / vlan2 / ip / udp / payload
return single_tag, double_tag
def get_packet(self, vlan):
normal_data = 'Nailgun:{iface} 1'.format(iface=self.iface)
p = scapy.Ether(src='64:0b:36:0e:0a:b7', dst="ff:ff:ff:ff:ff:ff")
if int(vlan) > 0:
p = p / scapy.Dot1Q(vlan=int(vlan))
message_len = len(normal_data) + 8
p = p / scapy.IP(src=self.config['src'], dst=self.config['dst'])
p = p / scapy.UDP(sport=self.config['sport'],
dport=self.config['dport'],
len=message_len) / normal_data
return p
def simple_icmp_packet(pktlen=60,
eth_dst='00:01:02:03:04:05',
eth_src='00:06:07:08:09:0a',
dl_vlan_enable=False,
vlan_vid=0,
vlan_pcp=0,
ip_src='192.168.0.1',
ip_dst='192.168.0.2',
ip_tos=0,
ip_ttl=64,
icmp_type=8,
icmp_code=0):
"""
Return a simple ICMP packet
Supports a few parameters:
@param len Length of packet in bytes w/o CRC
@param eth_dst Destinatino MAC
@param eth_src Source MAC
@param dl_vlan_enable True if the packet is with vlan, False otherwise
@param vlan_vid VLAN ID
@param vlan_pcp VLAN priority
@param ip_src IP source
@param ip_dst IP destination
@param ip_tos IP ToS
@param ip_ttl IP TTL
@param icmp_type ICMP type
@param icmp_code ICMP code
Generates a simple ICMP ECHO REQUEST. Users
shouldn't assume anything about this packet other than that
it is a valid ethernet/ICMP frame.
"""
if MINSIZE > pktlen:
pktlen = MINSIZE
if (dl_vlan_enable):
pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \
scapy.Dot1Q(prio=vlan_pcp, id=0, vlan=vlan_vid)/ \
scapy.IP(src=ip_src, dst=ip_dst, ttl=ip_ttl, tos=ip_tos)/ \
scapy.ICMP(type=icmp_type, code=icmp_code)
else:
pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \
scapy.IP(src=ip_src, dst=ip_dst, ttl=ip_ttl, tos=ip_tos)/ \
scapy.ICMP(type=icmp_type, code=icmp_code)
pkt = pkt / ("0" * (pktlen - len(pkt)))
return pkt
def _sendp(self, iface, vlan):
try:
data = str(''.join((self.config['cookie'], iface, ' ',
self.config['uid'])))
p = scapy.Ether(src=self._get_iface_mac(iface),
dst="ff:ff:ff:ff:ff:ff")
if vlan > 0:
p = p / scapy.Dot1Q(vlan=vlan)
p = p / scapy.IP(src=self.config['src'], dst=self.config['dst'])
p = p / scapy.UDP(sport=self.config['sport'],
dport=self.config['dport']) / data
scapy.sendp(p, iface=iface)
except socket.error as e:
self.logger.error("Socket error: %s, %s", e, iface)
def PrepareHALRequestSpec(self, req_spec):
#
# For now we only have Ah Requests. In future we need to make sure what kind
# of spec it is.
#
if not self.lqp.svc == 3: return
logger.info("PrepareHALRequestSpec:: RDMA Session: %s Session: %s "
"Remote QP: %s Local QP: %s" %\
(self.GID(), self.session.GID(), self.rqp.GID(), self.lqp.GID()))
if (GlobalOptions.dryrun): return
logger.info("RdmaAhCreate:: src_ip: %s dst_ip: %s src_mac: %s dst_mac: %s proto: %s "
"sport: %s dport: %s ah_handle: %d isipv6: %d" %\
(self.session.initiator.addr.get(), self.session.responder.addr.get(),
self.session.initiator.ep.macaddr.get(), self.session.responder.ep.macaddr.get(),
self.session.iflow.proto, self.session.iflow.sport, self.session.iflow.dport,
self.ah_handle, self.session.IsIPV6()))
EthHdr = scapy.Ether(src=self.session.initiator.ep.macaddr.get(),
dst=self.session.responder.ep.macaddr.get())
Dot1qHdr = scapy.Dot1Q(
vlan=self.session.initiator.ep.intf.encap_vlan_id,
prio=self.session.iflow.txqos.cos)
if self.session.IsIPV6():
IpHdr = scapy.IPv6(src=self.session.initiator.addr.get(),
dst=self.session.responder.addr.get(),
tc=self.session.iflow.txqos.dscp,
plen=0)
else:
IpHdr = scapy.IP(
src=self.session.initiator.addr.get(),
dst=self.session.responder.addr.get(),
tos=0, # keep tos = 0 to not trigger ecn mark
len=0,
chksum=0)
UdpHdr = scapy.UDP(sport=self.session.iflow.sport,
dport=self.session.iflow.dport,
len=0,
chksum=0)
req_spec.hw_lif_id = self.lqp.pd.ep.intf.lif.hw_lif_id
req_spec.header_template = bytes(EthHdr / Dot1qHdr / IpHdr / UdpHdr)
req_spec.ahid = self.ah_handle
return
def gen_packet(proto,
src_ip,
dst_ip,
src_port=10001,
dst_port=10002,
src_mac='02:1e:67:9f:4d:ae',
dst_mac='ae:34:2e:16:b8:cd',
vlan_tci=None):
eth = scapy.Ether(src=src_mac, dst=dst_mac)
ip = scapy.IP(src=src_ip, dst=dst_ip)
udp = proto(sport=src_port, dport=dst_port)
payload = 'helloworld'
if vlan_tci is None:
pkt = eth / ip / udp / payload
else:
dotq = scapy.Dot1Q(vlan=vlan_tci)
pkt = eth / dotq / ip / udp / payload
return bytes(pkt)
def test_vlan(self):
import loxi.of12 as ofp
self.maxDiff = None
pkt = scapy.Ether(dst='00:01:02:03:04:05', src='00:06:07:08:09:0a')/ \
scapy.Dot1Q(vlan=50, prio=5)/ \
scapy.IP(src='192.168.0.1', dst='192.168.0.2', tos=2 | (32 << 2), ttl=64)/ \
scapy.TCP(sport=1234, dport=80)
expected = [
ofp.oxm.eth_dst([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]),
ofp.oxm.eth_src([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]),
ofp.oxm.eth_type(0x0800),
ofp.oxm.vlan_vid(50),
ofp.oxm.vlan_pcp(5),
ofp.oxm.ip_proto(6),
ofp.oxm.ip_dscp(32),
ofp.oxm.ip_ecn(2),
ofp.oxm.ipv4_src(0xc0a80001),
ofp.oxm.ipv4_dst(0xc0a80002),
ofp.oxm.tcp_src(1234),
ofp.oxm.tcp_dst(80)
]
result = parse.packet_to_flow_match_v3(pkt).oxm_list
self.assertEquals([x.show() for x in expected],
[x.show() for x in result])
def simplePacket(pktlen=100,
dl_dst='00:01:02:03:04:05',
dl_src='00:06:07:08:09:0a',
dl_vlan=0xffff,
dl_vlan_pcp=0,
dl_vlan_cfi=0,
dl_type=ETHERTYPE_IP,
nw_src='192.168.0.1',
nw_dst='192.168.0.2',
nw_tos=0,
nw_proto=socket.IPPROTO_TCP,
tp_src=1234,
tp_dst=80):
"""
Return a simple packet
Users shouldn't assume anything about this packet other than that
it is a valid ethernet/IP/TCP frame.
It generates a packet in a shape of TCP, UDP, ICMP, ARP, IP,
Raw ethernet, with or without a VLAN tag.
If dl_type is other than IP or ARP, the upper layer parameters will be ignored
If nw_proto is other than TCP, UDP or ICMP, the upper layer parameters will be ignored
Supports a few parameters
@param pktlen Length of packet in bytes w/o CRC
@param dl_dst Destination MAC
@param dl_src Source MAC
@param dl_vlan VLAN ID, No VLAN tags if the value is 0xffff
@param dl_vlan_pcp VLAN priority. Valid only dl_vlan is in a valid range
@param dl_vlan_cfi VLAN CFI
@param dl_type Type of L3
@param nw_src IP source
@param nw_dst IP destination
@param nw_tos IP ToS
@param nw_proto L4 protocol When ARP is specified in dl_type, it is used for op code
@param tp_dst UDP/TCP destination port
@param tp_src UDP/TCP source port
@return valid packet
"""
# Note Dot1Q.id is really CFI
if (dl_vlan == 0xffff):
pkt = scapy.Ether(dst=dl_dst, src=dl_src)
else:
dl_vlan = dl_vlan & 0x0fff
pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \
scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan)
if (dl_type == ETHERTYPE_IP):
pkt = pkt / scapy.IP(src=nw_src, dst=nw_dst, tos=nw_tos)
if (nw_proto == socket.IPPROTO_TCP):
pkt = pkt / scapy.TCP(sport=tp_src, dport=tp_dst)
elif (nw_proto == socket.IPPROTO_UDP):
pkt = pkt / scapy.UDP(sport=tp_src, dport=tp_dst)
elif (nw_proto == socket.IPPROTO_ICMP):
pkt = pkt / scapy.ICMP(type=tp_src, code=tp_dst)
elif (dl_type == ETHERTYPE_ARP):
pkt = pkt / scapy.ARP(
op=nw_proto, hwsrc=dl_src, psrc=nw_src, hwdst=dl_dst, pdst=nw_dst)
return pkt
pkt = pkt / ("D" * (pktlen - len(pkt)))
return pkt
def generate_and_verify_balancing_traffic(duthost, ptfhost, ptfadapter,
src_port, dst_port, ip_src, ip_dst,
pktlen, ttl):
"""
Send TCP packets and verify balancing range between sub-ports.
Args:
duthost: DUT host object
ptfhost: PTF host object
ptfadapter: PTF adapter
src_port: Port of PTF
dst_port: Port of DUT
ip_src: Source IP address of PTF
ip_dst: Destination IP address of DUT
pkt_action: Packet action (forwarded or drop)
pktlen: packet length
ttl: Time to live
"""
router_mac = duthost.facts['router_mac']
src_port_number = int(get_port_number(src_port))
src_mac = ptfadapter.dataplane.get_mac(0, src_port_number)
ip_src = '10.0.0.1'
ip_dst = ip_dst.split('/')[0]
vlan_vid = None
dl_vlan_enable = False
send_pkt_length = pktlen
if constants.VLAN_SUB_INTERFACE_SEPARATOR in src_port:
vlan_vid = int(
src_port.split(constants.VLAN_SUB_INTERFACE_SEPARATOR)[1])
dl_vlan_enable = True
send_pkt_length += len(scapyall.Dot1Q())
pkt = create_packet(eth_src=src_mac,
eth_dst=router_mac,
ip_src=ip_src,
ip_dst=ip_dst,
vlan_vid=vlan_vid,
dl_vlan_enable=dl_vlan_enable,
tr_type='TCP',
ttl=64,
pktlen=send_pkt_length)
ptfadapter.dataplane.flush()
time.sleep(2)
for _ in range(BALANCING_TEST_TIMES * len(dst_port)):
testutils.send_packet(ptfadapter, src_port_number, pkt)
pkt['IP'].src = str(
ipaddress.ip_address(pkt['IP'].src.encode().decode()) + 1)
exp_pkt = create_packet(eth_src=router_mac,
eth_dst=src_mac,
ip_src=ip_src,
ip_dst=ip_dst,
vlan_vid=None,
dl_vlan_enable=False,
tr_type='TCP',
ttl=ttl,
pktlen=pktlen)
ifaces_map = ptfhost.host.options['variable_manager'].extra_vars[
'ifaces_map']
config_port_indices = {v: k for k, v in ifaces_map.items()}
dst_port_numbers = [
config_port_indices[k] for k in config_port_indices if k in dst_port
]
ignore_fields = [("Ether", "dst"), ("IP", "src"), ("IP", "chksum"),
("TCP", "chksum")]
if dl_vlan_enable:
ignore_fields.append(("Ether", "type"))
pkt_filter = FilterPktBuffer(ptfadapter=ptfadapter,
exp_pkt=exp_pkt,
dst_port_numbers=dst_port_numbers,
match_fields=[("Ethernet", "src"),
("IP", "dst"),
('TCP', "dport")],
ignore_fields=ignore_fields)
pkt_in_buffer = pkt_filter.filter_pkt_in_buffer()
pytest_assert(pkt_in_buffer is True,
"Expected packet not available:\n{}".format(pkt_in_buffer))
pytest_assert(check_balancing(pkt_filter.matched_index),
"Balancing error:\n{}".format(pkt_filter.matched_index))
sai_remove_acl_table_group $acl_table_group
back
vlan
sai_remove_vlan_member $memtap0
sai_remove_vlan_member $memtap1
sai_remove_vlan $vlan75
back
bridge
sai_remove_bridge_port $brgportlag
back
lag
sai_remove_lag_member $mem30
sai_remove_lag $lag0
back
home
'''
packet_info = scapy_t.Ether(
src="00:00:11:00:11:00",
dst="00:00:11:00:11:23") / scapy_t.Dot1Q(vlan=75) / scapy_t.IP(
src="100.1.1.1", dst="100.1.1.2") / scapy_t.TCP(sport=2567, dport=2569)
#
#expectedData: This dictionary expected egress stream for each egress port.
#
expectedData = {
'expect1': '',
}
def ConfigureHeaderTemplate(self, rdma_session, initiator, responder, flow,
isipv6, forward, ah_handle):
logger.info("rdma_session: %s" % rdma_session.GID())
logger.info("session: %s" % rdma_session.session.GID())
logger.info("flow_ep1: %s ep1: %s" \
%(initiator.GID(), initiator.ep.GID()))
logger.info("flow_ep2: %s ep2: %s" \
%(responder.GID(), responder.ep.GID()))
logger.info("src_ip: %s" % initiator.addr.get())
logger.info("dst_ip: %s" % responder.addr.get())
logger.info("src_mac: %s" % initiator.ep.macaddr.get())
logger.info("dst_mac: %s" % responder.ep.macaddr.get())
logger.info("proto: %s" % flow.proto)
logger.info("sport: %s" % flow.sport)
logger.info("dport: %s" % flow.dport)
logger.info("ah_handle: %d" % ah_handle)
if forward:
logger.info("src_qp: %d pd: %s" %
(rdma_session.lqp.id, rdma_session.lqp.pd.GID()))
logger.info("dst_qp: %d pd: %s" %
(rdma_session.rqp.id, rdma_session.rqp.pd.GID()))
else:
logger.info("src_qp: %d pd: %s" %
(rdma_session.rqp.id, rdma_session.rqp.pd.GID()))
logger.info("dst_qp: %d pd: %s" %
(rdma_session.lqp.id, rdma_session.lqp.pd.GID()))
logger.info("isipv6: %d" % (isipv6))
logger.info("isVXLAN: %d" % (rdma_session.IsVXLAN))
EthHdr = scapy.Ether(src=initiator.ep.macaddr.get(),
dst=responder.ep.macaddr.get())
Dot1qHdr = scapy.Dot1Q(vlan=initiator.ep.intf.encap_vlan_id,
prio=flow.txqos.cos)
if isipv6:
IpHdr = scapy.IPv6(src=initiator.addr.get(),
dst=responder.addr.get(),
tc=flow.txqos.dscp,
plen=0)
else:
IpHdr = scapy.IP(
src=initiator.addr.get(),
dst=responder.addr.get(),
tos=0, # keep tos = 0 to not trigger ecn mark
len=0,
chksum=0)
if forward:
UdpHdr = scapy.UDP(sport=flow.sport,
dport=flow.dport,
len=0,
chksum=0)
else:
UdpHdr = scapy.UDP(sport=flow.dport,
dport=flow.sport,
len=0,
chksum=0)
self.HdrTemplate = EthHdr / Dot1qHdr / IpHdr / UdpHdr
self.ah_handle = ah_handle
# header_template size is 66. The address is maintained only to calculate
# dcqcn_cb address.
# 200 = [ 66 (header_template_t) + 1 (ah_size) + 64 (dcqcncb_t) + 64 (rome_receiver_cb_t)] 8 byte aligned
self.header_temp_addr = self.lif.rdma_at_base_addr + (ah_handle * 200)
self.modify_qp_oper |= 1 << rdma_pb2.RDMA_UPDATE_QP_OPER_SET_AV
logger.info(" RdmaQpUpdate Oper: SET_AV ah_handle: %d " %
(self.ah_handle))
if (GlobalOptions.dryrun): return
resmgr.HostMemoryAllocator.write(self.hdr_slab.mem_handle,
bytes(self.HdrTemplate))
#adminapi.ModifyQps(self.lif, [self])
#self.modify_qp_oper = 0
return
def traffic_sender(linkid, vlanid):
payload = s.Ether() / s.Dot1Q(vlan=int(vlanid)) / s.IP() / s.ICMP()
s.sendp(payload, iface=linkid, count=number_of_packets)
def simple_udp_packet(pktlen=100,
dl_dst='48:d2:24:0f:60:52',
dl_src='00:1b:21:02:d1:57',
dl_vlan_enable=False,
dl_vlan=0,
dl_vlan_pcp=0,
dl_vlan_cfi=0,
ip_src='1.1.1.5',
ip_dst='1.1.1.125',
ip_tos=0,
udp_sport=4567,
udp_dport=9,
ip_ihl=None,
ip_options=False
):
"""
Return a simple dataplane UDP packet
Supports a few parameters:
@param len Length of packet in bytes w/o CRC
@param dl_dst Destinatino MAC
@param dl_src Source MAC
@param dl_vlan_enable True if the packet is with vlan, False otherwise
@param dl_vlan VLAN ID
@param dl_vlan_pcp VLAN priority
@param ip_src IP source
@param ip_dst IP destination
@param ip_tos IP ToS
@param udp_dport UDP destination port
@param udp_sport UDP source port
Generates a simple UDP packet. Users
shouldn't assume anything about this packet other than that
it is a valid ethernet/IP/UDP frame.
"""
if 0 > pktlen:
pktlen = MINSIZE
# create udp header
udp = scapy.UDP(sport=udp_sport, dport=udp_dport)
# create ip header
if not ip_options:
ip = scapy.IP(src=ip_src, dst= ip_dst, tos=ip_tos, ihl=ip_ihl)
else:
ip = scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl, options=ip_options)
# create ethernet header
ether = scapy.Ether(dst=dl_dst, src=dl_src)
# add the vlan header if if is enabled and create the pkt.
if dl_vlan_enable :
dot1q = scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan)
pkt = ether/ dot1q / ip / udp
else:
pkt = ether/ ip / udp
pkt = pkt/("D" * (pktlen - len(pkt)))
#print pkt.show()
return pkt
import scapy.all as scapy
__author__ = 'J.Carlos Romero'
__license__ = 'GPLv3'
interface = scapy.get_if_list()[-1]
src_mac = '60:50:40:30:20:10'
# broadcast MAC
dst_mac = 'ff:ff:ff:ff:ff:ff'
src_ip = '1.1.1.1'
dst_ip = '255.255.255.255'
native_vlan = 1
hop_vlan = 2
payload = scapy.ICMP()
packet = (scapy.Ether(src=src_mac, dst=dst_mac) /
scapy.Dot1Q(vlan=native_vlan) / scapy.Dot1Q(vlan=hop_vlan) /
scapy.IP(src=src_ip, dst=dst_ip))
scapy.sendp(packet / payload, iface=interface)
packet.show()
packet.pdfdump(layer_shift=1)
