Beispiel #1
0
    def runTest(self):
        table_id = testutils.EX_ACL_TABLE
        port_in = exact_port_map.keys()[0]
        egr_port = exact_port_map.keys()[1]
        #"clear swtich;"
        testutils.delete_all_flows(self.controller, self.logger)
        #make packet;
        pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a')
        exp_pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='aa:aa:aa:aa:aa:aa')
        # get match list
        match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = table_id, ing_port = port_in)

        act = action.action_set_field()
        field = match.eth_dst(parse.parse_mac("aa:aa:aa:aa:aa:aa"))
        act.field.add(field)
        exact_table_output(self, table_id, match_ls, actions = [act], egr_port = egr_port)

        testutils.do_barrier(self.controller)

        "send a packet from port_in "
        self.dataplane.send(port_in, str(pkt))
        "poll from the egr_port port"
        (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port, timeout=1)

        self.assertTrue(pkt is not None,"rec none packets")
        self.assertEqual(str(exp_pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
Beispiel #2
0
    def runTest(self):

        of_ports = ipv6_port_map.keys()
        of_ports.sort()
        ing_port = of_ports[0]
        egr_port = of_ports[3]

        # Remove all entries Add entry match all
        rc = testutils.delete_all_flows(self.controller, ipv6_logger)
        self.assertEqual(rc, 0, "Failed to delete all flows")

        # Add entry match

        request = message.flow_mod()
        request.match.type = ofp.OFPMT_OXM
        port = match.in_port(of_ports[0])
        eth_type = match.eth_type(IPV6_ETHERTYPE)
        eth_dst = match.eth_dst(parse.parse_mac("00:01:02:03:04:05"))
        ipv6_src = match.ipv6_src(
            ipaddr.IPv6Address('fe80::2420:52ff:fe8f:5189'))

        request.match_fields.tlvs.append(port)
        request.match_fields.tlvs.append(eth_type)
        request.match_fields.tlvs.append(eth_dst)
        request.match_fields.tlvs.append(ipv6_src)
        act = action.action_output()
        act.port = of_ports[3]
        inst = instruction.instruction_apply_actions()
        inst.actions.add(act)
        request.instructions.add(inst)
        request.buffer_id = 0xffffffff

        request.priority = 1000
        ipv6_logger.debug("Adding flow ")

        rv = self.controller.message_send(request)
        self.assertTrue(rv != -1, "Failed to insert test flow")

        #Send packet
        pkt = testutils.simple_ipv6_packet(dl_dst='00:01:02:03:04:05',
                                           ip_src='fe80::2420:52ff:fe8f:5189')
        ipv6_logger.info("Sending IPv6 packet to " + str(ing_port))
        ipv6_logger.debug("Data: " + str(pkt).encode('hex'))
        self.dataplane.send(ing_port, str(pkt))

        #Receive packet
        exp_pkt = testutils.simple_ipv6_packet()
        testutils.receive_pkt_verify(self, egr_port, exp_pkt)

        #Remove flows
        rc = testutils.delete_all_flows(self.controller, ipv6_logger)
        self.assertEqual(rc, 0, "Failed to delete all flows")
Beispiel #3
0
    def runTest(self):
        
        of_ports = ipv6_port_map.keys()
        of_ports.sort()
        ing_port = of_ports[0]
        egr_port = of_ports[3]
        
        # Remove all entries Add entry match all
        rc = testutils.delete_all_flows(self.controller, ipv6_logger)
        self.assertEqual(rc, 0, "Failed to delete all flows")

        # Add entry match 

        request = message.flow_mod()
        request.match.type = ofp.OFPMT_OXM
        port = match.in_port(of_ports[0])
        eth_type = match.eth_type(IPV6_ETHERTYPE)
        eth_dst = match.eth_dst(parse.parse_mac("00:01:02:03:04:05"))
        ipv6_src = match.ipv6_src(ipaddr.IPv6Address('fe80::2420:52ff:fe8f:5189'))
        
        request.match_fields.tlvs.append(port)
        request.match_fields.tlvs.append(eth_type)
        request.match_fields.tlvs.append(eth_dst)
        request.match_fields.tlvs.append(ipv6_src)
        act = action.action_output()
        act.port = of_ports[3]
        inst = instruction.instruction_apply_actions()
        inst.actions.add(act)
        request.instructions.add(inst)
        request.buffer_id = 0xffffffff
        
        request.priority = 1000
        ipv6_logger.debug("Adding flow ")

        rv = self.controller.message_send(request)
        self.assertTrue(rv != -1, "Failed to insert test flow")

        #Send packet
        pkt = testutils.simple_ipv6_packet(dl_dst='00:01:02:03:04:05',ip_src='fe80::2420:52ff:fe8f:5189')
        ipv6_logger.info("Sending IPv6 packet to " + str(ing_port))
        ipv6_logger.debug("Data: " + str(pkt).encode('hex'))
        self.dataplane.send(ing_port, str(pkt))
        
        #Receive packet
        exp_pkt = testutils.simple_ipv6_packet()
        testutils.receive_pkt_verify(self, egr_port, exp_pkt)

        #Remove flows
        rc = testutils.delete_all_flows(self.controller, ipv6_logger)
        self.assertEqual(rc, 0, "Failed to delete all flows")
Beispiel #4
0
    def runTest(self):
        table_id = testutils.EX_ACL_TABLE
        port_in = exact_port_map.keys()[0]
        egr_port = exact_port_map.keys()[1]
        #"clear swtich;"
        testutils.delete_all_flows(self.controller, self.logger)
        #make packet;
        pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05',
                                          dl_dst='00:06:07:08:09:0a')
        exp_pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05',
                                              dl_dst='aa:aa:aa:aa:aa:aa')
        # get match list
        match_ls = testutils.packet_to_exact_flow_match(pkt=pkt,
                                                        table_id=table_id,
                                                        ing_port=port_in)

        act = action.action_set_field()
        field = match.eth_dst(parse.parse_mac("aa:aa:aa:aa:aa:aa"))
        act.field.add(field)
        exact_table_output(self,
                           table_id,
                           match_ls,
                           actions=[act],
                           egr_port=egr_port)

        testutils.do_barrier(self.controller)

        "send a packet from port_in "
        self.dataplane.send(port_in, str(pkt))
        "poll from the egr_port port"
        (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port,
                                                     timeout=1)

        self.assertTrue(pkt is not None, "rec none packets")
        self.assertEqual(str(exp_pkt), str(pkt_rec),
                         'retruned pkt not equal to the original pkt')
Beispiel #5
0
def packet_to_flow_match(packet):
    """
    Create a flow match that matches packet with the given wildcards

    @param packet The packet to use as a flow template
    @param pkt_format Currently only L2 is supported.  Will indicate the 
    overall packet type for parsing
    @return An ofp_match object if successful.  None if format is not
    recognized.  The wildcards of the match will be cleared for the
    values extracted from the packet.

    @todo check min length of packet
    @todo Check if packet is other than L2 format
    @todo implement other fields covered by OpenFlow 1.2 
    """
    match_ls = match_list()

    if Ether in packet:
        ether = packet[Ether]
        eth_type = match.eth_type(ether.type)
        eth_dst = match.eth_dst(parse_mac(ether.dst))
        eth_src = match.eth_src(parse_mac(ether.src))
        match_ls.add(eth_type)
        match_ls.add(eth_dst)
        match_ls.add(eth_src)
    else:
        return match_ls

    if Dot1Q in packet:
        #TODO: nicer way to get last vlan tag?
        vlan = packet[Dot1Q:0]
        vlan_vid = match.vlan_vid(vlan.vlan)
        vlan_pcp = match.vlan_pcp(vlan.prio)
        match_ls.add(vlan_vid)
        match_ls.add(vlan_pcp)
        vlan_pl = vlan.payload
        while vlan_pl is not None and vlan_pl.name == Dot1Q.name:
            vlan = vlan_pl
            vlan_pl = vlan.payload
        #We need to overwrite the already
        # inserted eth_type
        eth_index = match.tlvs.index()
        eth_type = match.eth_type(vlan.type)
        match_ls.tlvs.insert(vlan.type, eth_index)
    #TODO ARP

    if MPLS in packet:
        mpls = packet[MPLS:0]
        mpls_label = match.mpls_label(mpls.label)
        mpls_tc = match.mpls_tc(mpls.cos)
        match_ls.add(mpls_label)
        match_ls.add(mpls_tc)
        return match_ls

    if IP in packet:
        ip = packet[IP]
        ipv4_src = match.ipv4_src(parse_ip(ip.src))
        ipv4_dst = match.ipv4_dst(parse_ip(ip.dst))
        ip_dscp = match.ip_dscp(ip.tos >> 2)
        ip_ecn = match.ip_ecn(ip.tos & 0x03)
        match_ls.add(ipv4_src)
        match_ls.add(ipv4_dst)
        match_ls.add(ip_dscp)
        match_ls.add(ip_ecn)
    else:
        return match_ls

    if TCP in packet:
        tcp = packet[TCP]
        ip_proto = match.ip_proto(6)
        tcp_src = match.tcp_src(tcp.sport)
        tcp_dst = match.tcp_dst(tcp.dport)
        match_ls.add(ip_proto)
        match_ls.add(tcp_src)
        match_ls.add(tcp_dst)
        return match_ls

    if UDP in packet:
        udp = packet[UDP]
        ip_proto = match.ip_proto(17)
        udp_src = match.tcp_src(udp.sport)
        udp_dst = match.tcp_dst(udp.dport)
        match_ls.add(ip_proto)
        match_ls.add(udp_src)
        match_ls.add(udp_dst)
        returnmatch_ls

    if ICMP in packet:
        icmp = packet[ICMP]
        ip_proto = match.ip_proto(1)
        icmp_type = match.icmp_type(icmp.type)
        icmp_code = match.icmp_code(icmp.code)
        match_ls.add(icmp_type)
        match_ls.add(icmp_code)
        return match_ls

    return match_ls
Beispiel #6
0
def packet_to_flow_match(packet):
    """
    Create a flow match that matches packet with the given wildcards

    @param packet The packet to use as a flow template
    @param pkt_format Currently only L2 is supported.  Will indicate the 
    overall packet type for parsing
    @return An ofp_match object if successful.  None if format is not
    recognized.  The wildcards of the match will be cleared for the
    values extracted from the packet.

    @todo check min length of packet
    @todo Check if packet is other than L2 format
    @todo implement other fields covered by OpenFlow 1.2 
    """
    match_ls = match_list()
    
    if Ether in packet:
        ether = packet[Ether]
        eth_type = match.eth_type(ether.type)
        eth_dst = match.eth_dst(parse_mac(ether.dst))
        eth_src = match.eth_src(parse_mac(ether.src))
        match_ls.add(eth_type)
        match_ls.add(eth_dst)
        match_ls.add(eth_src)
    else:
        return match_ls

    if Dot1Q in packet:
        #TODO: nicer way to get last vlan tag?
        vlan = packet[Dot1Q:0]
        vlan_vid = match.vlan_vid(vlan.vlan)
        vlan_pcp = match.vlan_pcp(vlan.prio)
        match_ls.add(vlan_vid)
        match_ls.add(vlan_pcp)
        vlan_pl = vlan.payload
        while vlan_pl is not None and vlan_pl.name == Dot1Q.name:
            vlan = vlan_pl
            vlan_pl = vlan.payload
        #We need to overwrite the already
        # inserted eth_type    
        eth_index = match.tlvs.index()
        eth_type = match.eth_type(vlan.type)
        match_ls.tlvs.insert(vlan.type,eth_index)
    #TODO ARP

    if MPLS in packet:
        mpls = packet[MPLS:0]
        mpls_label = match.mpls_label(mpls.label)
        mpls_tc =  match.mpls_tc(mpls.cos)
        match_ls.add(mpls_label)
        match_ls.add(mpls_tc)
        return match_ls

    if IP in packet:
        ip = packet[IP]
        ipv4_src = match.ipv4_src(parse_ip(ip.src))
        ipv4_dst = match.ipv4_dst(parse_ip(ip.dst))
        ip_dscp =  match.ip_dscp(ip.tos >> 2) 
        ip_ecn =   match.ip_ecn(ip.tos & 0x03)
        match_ls.add(ipv4_src)
        match_ls.add(ipv4_dst)
        match_ls.add(ip_dscp)
        match_ls.add(ip_ecn)
    else:
        return match_ls
    
    if TCP in packet:
        tcp = packet[TCP]
        ip_proto = match.ip_proto(6)
        tcp_src = match.tcp_src(tcp.sport)
        tcp_dst = match.tcp_dst(tcp.dport)
        match_ls.add(ip_proto)
        match_ls.add(tcp_src)
        match_ls.add(tcp_dst)
        return match_ls

    if UDP in packet:
        udp = packet[UDP]
        ip_proto = match.ip_proto(17)
        udp_src = match.tcp_src(udp.sport)
        udp_dst = match.tcp_dst(udp.dport)
        match_ls.add(ip_proto)
        match_ls.add(udp_src)
        match_ls.add(udp_dst)        
        returnmatch_ls

    if ICMP in packet:
        icmp = packet[ICMP]
        ip_proto = match.ip_proto(1)
        icmp_type = match.icmp_type(icmp.type)
        icmp_code = match.icmp_code(icmp.code)
        match_ls.add(icmp_type)
        match_ls.add(icmp_code)        
        return match_ls

    return match_ls