Esempio n. 1
0
    def test_resume_tunnel_flows(self):

        # Need to delete all default flows in table 0 before
        # install the specific flows test case.
        self.test_detach_default_tunnel_flows()
        ip_flow_dl = IPFlowDL(set_params=0)
        ue_ip_addr = "192.168.128.80"
        self.classifier_controller.resume_tunnel_flows(
            3,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            ip_flow_dl=ip_flow_dl,
        )
        ue_ip_addr = "192.168.128.82"
        self.classifier_controller.resume_tunnel_flows(
            4,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            ip_flow_dl=ip_flow_dl,
        )

        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 2
0
    def testFlowVlanSnapshotMatch2(self):
        fake_inout_setup(self.inout_controller)
        cls = self.__class__
        vlan1 = "21"
        self.setUpNetworkAndController(vlan1)
        vlan2 = "22"
        cls._setup_vlan(vlan2)

        ip_addr = ipaddress.ip_address("10.200.21.211")
        mocked_set_mobilityd_gw_info(
            IPAddress(address=ip_addr.packed, version=IPBlock.IPV4), "", vlan1)

        ip_addr = ipaddress.ip_address("10.200.22.211")
        mocked_set_mobilityd_gw_info(
            IPAddress(address=ip_addr.packed, version=IPBlock.IPV4), "", vlan2)

        hub.sleep(2)
        while gw_info_map[vlan2].mac is None or gw_info_map[vlan2].mac == '':
            threading.Event().wait(.5)

        logging.info("done waiting for vlan: %s", vlan1)
        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
            max_sleep_time=40,
            datapath=cls.inout_controller._datapath,
            try_snapshot=True)

        with snapshot_verifier:
            pass
        self.assertEqual(gw_info_map[vlan1].mac, 'b2:a0:cc:85:80:21')
        self.assertEqual(gw_info_map[vlan2].mac, 'b2:a0:cc:85:80:22')
    def test_resume_tunnel_ip_flow_dl(self):

        dest_ip = IPAddress(
            version=IPAddress.IPV4,
            address=socket.inet_pton(socket.AF_INET, "192.168.128.12"),
        )
        src_ip = IPAddress(
            version=IPAddress.IPV4,
            address=socket.inet_pton(socket.AF_INET, "192.168.129.64"),
        )
        ip_flow_dl = IPFlowDL(
            set_params=71, tcp_dst_port=0,
            tcp_src_port=5002, udp_dst_port=0, udp_src_port=0, ip_proto=6,
            dest_ip=dest_ip, src_ip=src_ip, precedence=65530,
        )

        ue_ip_addr = "192.168.128.30"
        seid1 = 5000
        self.classifier_controller.gtp_handler(
            5, 65525, 1, 100000, self.EnodeB_IP,
            ue_ip_addr,
            seid1, ip_flow_dl=ip_flow_dl,
        )

        snapshot_verifier = SnapshotVerifier(
            self, self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 4
0
def release_ip_handler(client, args):
    try:
        sid_msg = SIDUtils.to_pb(args.sid)
    except ValueError:
        print("Error: invalid SubscriberID format: %s" % args.sid)
        return

    try:
        ip = ipaddress.ip_address(args.ip)
    except ValueError:
        print("Error: invalid IP format: %s" % args.ip)
        return

    ip_msg = IPAddress()
    if ip.version == 4:
        ip_msg.version = IPAddress.IPV4
    elif ip.version == 6:
        ip_msg.version = IPAddress.IPV6
    else:
        print("Error: unknown IP version")
        return

    ip_msg.address = ip.packed

    request = ReleaseIPRequest()
    request.sid.CopyFrom(sid_msg)
    request.ip.CopyFrom(ip_msg)

    client.ReleaseIPAddress(request)
Esempio n. 5
0
    def test_set_gw_info_vlan2(self):
        mac1 = "22:22:c6:d0:02:3c"
        ipaddr1 = ipaddress.ip_address("10.1.1.11")
        gwinfo_msg1 = GWInfo(ip=IPAddress(version=IPAddress.IPV4,
                                          address=ipaddr1.packed),
                             mac=mac1,
                             vlan="1")

        self._stub.SetGatewayInfo(gwinfo_msg1)

        mac2 = "33:22:c6:d0:02:3c"
        ipaddr2 = ipaddress.ip_address("20.1.1.11")
        gwinfo_msg2 = GWInfo(ip=IPAddress(version=IPAddress.IPV4,
                                          address=ipaddr2.packed),
                             mac=mac2,
                             vlan="2")

        self._stub.SetGatewayInfo(gwinfo_msg2)

        gw_info_list = self._stub.ListGatewayInfo(Void())
        count1 = 0
        count2 = 0
        for gw_info in gw_info_list.gw_list:
            if gw_info == gwinfo_msg1:
                count1 = count1 + 1
            if gw_info == gwinfo_msg2:
                count2 = count2 + 1

        self.assertEqual(count1, 1)
        self.assertEqual(count2, 1)
Esempio n. 6
0
    def AllocateIPAddress(self, request, context):
        """ Allocate an IP address from the free IP pool """
        if request.version == AllocateIPRequest.IPV4:
            try:
                ip_addr = IPAddress()
                composite_sid = SIDUtils.to_str(request.sid)
                if request.apn:
                    composite_sid = composite_sid + "." + request.apn

                ip, vlan = self._ipv4_allocator.alloc_ip_address(composite_sid)
                logging.info("Allocated IPv4 %s for sid %s for apn %s"
                             % (ip, SIDUtils.to_str(request.sid), request.apn))
                ip_addr.version = IPAddress.IPV4
                ip_addr.address = ip.packed
                return AllocateIPAddressResponse(ip_addr=ip_addr,
                                                 vlan=str(vlan))
            except NoAvailableIPError:
                context.set_details('No free IPv4 IP available')
                context.set_code(grpc.StatusCode.RESOURCE_EXHAUSTED)
            except DuplicatedIPAllocationError:
                context.set_details('IP has been allocated for this subscriber')
                context.set_code(grpc.StatusCode.ALREADY_EXISTS)
        else:
            self._unimplemented_ip_version_error(context)
        return AllocateIPAddressResponse()
Esempio n. 7
0
    def GetIPForSubscriber(self, request, context):
        logging.debug("Received GetIPForSubscriber")
        self._print_grpc(request)

        composite_sid = SIDUtils.to_str(request.sid)
        if request.apn:
            composite_sid = composite_sid + "." + request.apn

        if request.version == IPAddress.IPV4:
            composite_sid += ",ipv4"
        elif request.version == IPAddress.IPV6:
            composite_sid += ",ipv6"

        ip = self._ip_address_man.get_ip_for_sid(composite_sid)
        if ip is None:
            context.set_details(
                'SID %s not found'
                % SIDUtils.to_str(request.sid),
            )
            context.set_code(grpc.StatusCode.NOT_FOUND)
            resp = IPAddress()
        else:
            version = IPAddress.IPV4 if ip.version == 4 else IPAddress.IPV6
            resp = IPAddress(version=version, address=ip.packed)
        self._print_grpc(resp)
        return resp
Esempio n. 8
0
    def test_attach_tunnel_flows(self):

        # Need to delete all default flows in table 0 before
        # install the specific flows test case.
        self.test_detach_default_tunnel_flows()

        ip_no = hex(socket.htonl(int(ipaddress.ip_address(self.EnodeB_IP))))
        buf = "g_{}".format(ip_no[2:])

        BridgeTools.create_veth_pair(buf, buf + "ns")
        BridgeTools.add_ovs_port(self.BRIDGE, buf, "40")

        seid1 = 5000
        ue_ip_addr = "192.168.128.30"
        self.classifier_controller.add_tunnel_flows(65525, 1, 100000,
                                                    IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')),
                                                    self.EnodeB_IP, seid1)

        seid2 = 5001
        ue_ip_addr = "192.168.128.31"
        self.classifier_controller.add_tunnel_flows(65525, 2,100001,
                                                    IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')),
                                                    self.EnodeB_IP, seid2)

        snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
                                             self.service_manager)
        with snapshot_verifier:
            pass
Esempio n. 9
0
    def testFlowVlanSnapshotMatch_static1(self):
        cls = self.__class__
        # setup network on unused vlan.
        vlan1 = "21"
        self.setUpNetworkAndController(vlan1)
        # statically configured config
        vlan2 = "22"

        ip_addr = ipaddress.ip_address("10.200.21.211")
        mocked_set_mobilityd_gw_info(
            IPAddress(address=ip_addr.packed, version=IPBlock.IPV4),
            "11:33:44:55:66:77", vlan1)

        ip_addr = ipaddress.ip_address("10.200.22.211")
        mocked_set_mobilityd_gw_info(
            IPAddress(address=ip_addr.packed, version=IPBlock.IPV4),
            "22:33:44:55:66:77", vlan2)

        hub.sleep(2)
        while gw_info_map[vlan2].mac is None or gw_info_map[vlan2].mac == '':
            threading.Event().wait(.5)

        logging.info("done waiting for vlan: %s", vlan1)
        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
            max_sleep_time=20,
            datapath=cls.inout_controller._datapath,
            try_snapshot=True)

        with snapshot_verifier:
            pass
        self.assertEqual(gw_info_map[vlan1].mac, 'b2:a0:cc:85:80:21')
        self.assertEqual(gw_info_map[vlan2].mac, '22:33:44:55:66:77')
Esempio n. 10
0
    def test_detach_tunnel_flows_ipv6(self):

        ip_flow_dl = IPFlowDL(set_params=0)
        ue_ip_addr = "2001::1"
        self.classifier_controller.delete_tunnel_flows(
            1,
            None,
            ip_flow_dl=ip_flow_dl,
            ue_ipv6_adr=IPAddress(version=IPAddress.IPV6,
                                  address=ue_ip_addr.encode('utf-8')),
        )

        ue_ip_addr = "2001:db8::1"
        self.classifier_controller.delete_tunnel_flows(
            2,
            None,
            ip_flow_dl=ip_flow_dl,
            ue_ipv6_adr=IPAddress(version=IPAddress.IPV6,
                                  address=ue_ip_addr.encode('utf-8')),
        )

        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 11
0
    def test_discard_tunnel_flows(self):
        ip_flow_dl = IPFlowDL(set_params=0)
        self.classifier_controller._delete_all_flows()
        ue_ip_addr = "192.168.128.80"
        self.classifier_controller.discard_tunnel_flows(
            3,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            ip_flow_dl=ip_flow_dl,
        )

        ue_ip_addr = "192.168.128.82"
        self.classifier_controller.discard_tunnel_flows(
            4,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            ip_flow_dl=ip_flow_dl,
        )

        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 12
0
    def test_detach_tunnel_flows(self):

        ue_ip_addr = "192.168.128.30"
        ip_flow_dl = IPFlowDL(set_params=0)
        self.classifier_controller.delete_tunnel_flows(
            1,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            ip_flow_dl=ip_flow_dl,
        )

        ue_ip_addr = "192.168.128.31"
        self.classifier_controller.delete_tunnel_flows(
            2,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            ip_flow_dl=ip_flow_dl,
        )

        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 13
0
def add_rule(args):
    rule_id = args.rule_id
    policy_dict = PolicyRuleDict()
    arg_list = {
        'ip_proto':
        args.ip_proto,
        'ip_dst':
        IPAddress(version=IPAddress.IPV4,
                  address=args.ipv4_dst.encode('utf-8')),
        'ip_src':
        IPAddress(version=IPAddress.IPV4,
                  address=args.ipv4_src.encode('utf-8')),
        'tcp_dst':
        args.tcp_dst,
        'tcp_src':
        args.tcp_src,
        'udp_dst':
        args.udp_dst,
        'udp_src':
        args.udp_src,
        'direction':
        args.direction
    }
    match = FlowMatch(**arg_list)
    flow = FlowDescription(match=match, action=args.action)
    rule = policy_dict.get(rule_id)
    if not rule or args.overwrite:
        action = 'add'
        rule = PolicyRule(id=rule_id, flow_list=[flow])
    else:
        action = 'edit'
        rule.flow_list.extend([flow])
    policy_dict[rule_id] = rule
    print("Rule '%s' successfully %sed!" % (rule_id, action))
Esempio n. 14
0
    def test_attach_tunnel_flows_ipv6(self):

        # Need to delete all default flows in table 0 before
        # install the specific flows test case.
        self.test_detach_default_tunnel_flows()

        seid1 = 5000
        ue_ip_addr = "2001::1"
        self.classifier_controller.add_tunnel_flows(
            65525, 1, 10000,
            IPAddress(version=IPAddress.IPV6,
                      address=ue_ip_addr.encode('utf-8')), self.EnodeB_IP,
            seid1, True)

        seid2 = 5001
        ue_ip_addr = "2001:db8::1"
        self.classifier_controller.add_tunnel_flows(
            65525, 2, 100001,
            IPAddress(version=IPAddress.IPV6,
                      address=ue_ip_addr.encode('utf-8')), self.EnodeB_IP,
            seid2, True)

        snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
                                             self.service_manager)
        with snapshot_verifier:
            pass
Esempio n. 15
0
    def testFlowVlanSnapshotMatch_static2(self):
        cls = self.__class__
        # setup network on unused vlan.
        self.setUpNetworkAndController("34")
        # statically configured config
        fake_mandatory_controller_setup(cls.ingress_controller)
        fake_mandatory_controller_setup(cls.middle_controller)
        fake_mandatory_controller_setup(cls.egress_controller)

        vlan1 = "31"
        ip_addr = ipaddress.ip_address("10.200.21.100")
        mocked_set_mobilityd_gw_info(
            IPAddress(
                address=ip_addr.packed,
                version=IPBlock.IPV4,
            ),
            "11:33:44:55:66:77", vlan1,
        )

        vlan2 = "32"
        ip_addr = ipaddress.ip_address("10.200.22.200")
        mocked_set_mobilityd_gw_info(
            IPAddress(
                address=ip_addr.packed,
                version=IPBlock.IPV4,
            ),
            "22:33:44:55:66:77", vlan2,
        )

        ip_addr = ipaddress.ip_address("10.200.22.10")
        mocked_set_mobilityd_gw_info(
            IPAddress(
                address=ip_addr.packed,
                version=IPBlock.IPV4,
            ),
            "00:33:44:55:66:77", "",
        )

        check_GW_rec(vlan1)
        check_GW_rec(vlan2)
        check_GW_rec("")

        assert_GW_mac(self, vlan1, '11:33:44:55:66:77')
        assert_GW_mac(self, vlan2, '22:33:44:55:66:77')
        assert_GW_mac(self, "", '00:33:44:55:66:77')

        hub.sleep(2)
        snapshot_verifier = SnapshotVerifier(
            self, self.BRIDGE,
            self.service_manager,
            max_sleep_time=20,
            datapath=cls.ingress_controller._datapath,
            try_snapshot=True,
        )

        with snapshot_verifier:
            pass
Esempio n. 16
0
    def testFlowVlanSnapshotMatch_static2(self):
        fake_inout_setup(self.inout_controller)
        cls = self.__class__
        # setup network on unused vlan.
        self.setUpNetworkAndController("34")
        # statically configured config

        vlan1 = "31"
        ip_addr = ipaddress.ip_address("10.200.21.100")
        mocked_set_mobilityd_gw_info(
            IPAddress(
                address=ip_addr.packed,
                version=IPBlock.IPV4,
            ),
            "11:33:44:55:66:77",
            vlan1,
        )

        vlan2 = "32"
        ip_addr = ipaddress.ip_address("10.200.22.200")
        mocked_set_mobilityd_gw_info(
            IPAddress(
                address=ip_addr.packed,
                version=IPBlock.IPV4,
            ),
            "22:33:44:55:66:77",
            vlan2,
        )

        ip_addr = ipaddress.ip_address("10.200.22.10")
        mocked_set_mobilityd_gw_info(
            IPAddress(
                address=ip_addr.packed,
                version=IPBlock.IPV4,
            ),
            "00:33:44:55:66:77",
            "",
        )

        hub.sleep(2)
        while gw_info_map[vlan2].mac is None or gw_info_map[vlan2].mac == '':
            threading.Event().wait(.5)

        logging.info("done waiting for vlan: %s", vlan1)
        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
            max_sleep_time=20,
            datapath=cls.inout_controller._datapath,
        )

        with snapshot_verifier:
            pass
        self.assertEqual(gw_info_map[vlan1].mac, '11:33:44:55:66:77')
        self.assertEqual(gw_info_map[vlan2].mac, '22:33:44:55:66:77')
        self.assertEqual(gw_info_map[""].mac, '00:33:44:55:66:77')
Esempio n. 17
0
def create_ue_session_entry(tunnel_msg: UESessionSet) -> UESessionSet:
    """Do create named tuple from input message

    Args:
        tunnel_msg: Message from MME

    Returns:
           UESessionSet
    """
    sid = 0
    ue_ipv4_address = None
    ue_ipv6_address = None
    enb_ipv4_address = None
    apn = None

    if tunnel_msg.subscriber_id.id:
        sid = encode_imsi(tunnel_msg.subscriber_id.id)

    if tunnel_msg.ue_ipv4_address.address:
        addr_str = socket.inet_ntop(
            socket.AF_INET,
            tunnel_msg.ue_ipv4_address.address,
        )
        ue_ipv4_address = IPAddress(
            version=tunnel_msg.ue_ipv4_address.version,
            address=addr_str.encode('utf8'),
        )

    if tunnel_msg.ue_ipv6_address.address:
        addr_str = socket.inet_ntop(
            socket.AF_INET6,
            tunnel_msg.ue_ipv6_address.address,
        )
        ue_ipv6_address = IPAddress(
            version=tunnel_msg.ue_ipv6_address.version,
            address=addr_str.encode('utf8'),
        )

    if tunnel_msg.enb_ip_address.address:
        enb_ipv4_address = ipaddress.ip_address(
            tunnel_msg.enb_ip_address.address,
        )

    if tunnel_msg.apn:
        apn = tunnel_msg.apn

    return (
        UESessionEntry(
            sid=sid, precedence=tunnel_msg.precedence,
            ue_ipv4_address=ue_ipv4_address,
            ue_ipv6_address=ue_ipv6_address, enb_ip_address=enb_ipv4_address,
            apn=apn, vlan=tunnel_msg.vlan, in_teid=tunnel_msg.in_teid,
            out_teid=tunnel_msg.out_teid,
            ue_session_state=tunnel_msg.ue_session_state.ue_config_state,
            ip_flow_dl=tunnel_msg.ip_flow_dl,
        )
    )
Esempio n. 18
0
 def GetIPForSubscriber(self, sid, context):
     sid_str = SIDUtils.to_str(sid)
     ip = self._ipv4_allocator.get_ip_for_sid(sid_str)
     if ip is None:
         context.set_details('SID %s not found' % sid)
         context.set_code(grpc.StatusCode.NOT_FOUND)
         return IPAddress()
     version = IPAddress.IPV4 if ip.version == 4 else IPAddress.IPV6
     return IPAddress(version=version, address=ip.packed)
    def test_add_tunnel_ip_flow_dl(self):

        # Need to delete all default flows in table 0 before
        # install the specific flows test case.
        self.test_detach_default_tunnel_flows()

        dest_ip = IPAddress(
            version=IPAddress.IPV4,
            address=socket.inet_pton(socket.AF_INET, "192.168.128.12"),
        )
        src_ip = IPAddress(
            version=IPAddress.IPV4,
            address=socket.inet_pton(socket.AF_INET, "192.168.129.64"),
        )
        ip_flow_dl = IPFlowDL(
            set_params=71, tcp_dst_port=0,
            tcp_src_port=5002, udp_dst_port=0, udp_src_port=0, ip_proto=6,
            dest_ip=dest_ip, src_ip=src_ip, precedence=65530,
        )

        seid1 = 5000
        ue_ip_addr = "192.168.128.30"
        self.classifier_controller.gtp_handler(
            0, 65525, 1, 100000, self.EnodeB_IP,
            ue_ip_addr,
            seid1, ip_flow_dl=ip_flow_dl,
        )

        dest_ip = IPAddress(
            version=IPAddress.IPV4,
            address=socket.inet_pton(socket.AF_INET, "192.168.128.111"),
        )
        src_ip = IPAddress(
            version=IPAddress.IPV4,
            address=socket.inet_pton(socket.AF_INET, "192.168.129.4"),
        )

        ip_flow_dl = IPFlowDL(
            set_params=70, tcp_dst_port=0,
            tcp_src_port=0, udp_dst_port=80, udp_src_port=5060, ip_proto=17,
            dest_ip=dest_ip, src_ip=src_ip, precedence=65525,
        )

        seid2 = 5001
        ue_ip_addr = "192.168.128.31"
        self.classifier_controller.gtp_handler(
            0, 65525, 2, 100001, self.EnodeB_IP,
            ue_ip_addr,
            seid2, ip_flow_dl=ip_flow_dl,
        )

        snapshot_verifier = SnapshotVerifier(
            self, self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 20
0
    def get_flow_match(self, flow_list, flow_match_list):
        """
        Populates flow match list
        """
        for flow in flow_list:
            flow_direction = (FlowMatch.UPLINK if flow["direction"] == "UL"
                              else FlowMatch.DOWNLINK)
            ip_protocol = flow["ip_proto"]
            if ip_protocol == "TCP":
                ip_protocol = FlowMatch.IPPROTO_TCP
                udp_src_port = 0
                udp_dst_port = 0
                tcp_src_port = (int(flow["tcp_src_port"])
                                if "tcp_src_port" in flow else 0)
                tcp_dst_port = (int(flow["tcp_dst_port"])
                                if "tcp_dst_port" in flow else 0)
            elif ip_protocol == "UDP":
                ip_protocol = FlowMatch.IPPROTO_UDP
                tcp_src_port = 0
                tcp_dst_port = 0
                udp_src_port = (int(flow["udp_src_port"])
                                if "udp_src_port" in flow else 0)
                udp_dst_port = (int(flow["udp_dst_port"])
                                if "udp_dst_port" in flow else 0)
            else:
                udp_src_port = 0
                udp_dst_port = 0
                tcp_src_port = 0
                tcp_dst_port = 0

            ipv4_src_addr = None
            if flow.get("ipv4_src", None):
                ipv4_src_addr = IPAddress(
                    version=IPAddress.IPV4,
                    address=flow.get("ipv4_src").encode('utf-8'))
            ipv4_dst_addr = None
            if flow.get("ipv4_dst", None):
                ipv4_dst_addr = IPAddress(
                    version=IPAddress.IPV4,
                    address=flow.get("ipv4_dst").encode('utf-8'))

            flow_match_list.append(
                FlowDescription(
                    match=FlowMatch(
                        ip_dst=ipv4_dst_addr,
                        ip_src=ipv4_src_addr,
                        tcp_src=tcp_src_port,
                        tcp_dst=tcp_dst_port,
                        udp_src=udp_src_port,
                        udp_dst=udp_dst_port,
                        ip_proto=ip_protocol,
                        direction=flow_direction,
                    ),
                    action=FlowDescription.PERMIT,
                ))
Esempio n. 21
0
    def test_detach_tunnel_flows_ipv6(self):

        ue_ip_addr = "2001::1"
        self.classifier_controller.delete_tunnel_flows(1, IPAddress(version=IPAddress.IPV6,address=ue_ip_addr.encode('utf-8')))

        ue_ip_addr = "2001:db8::1"
        self.classifier_controller.delete_tunnel_flows(2, IPAddress(version=IPAddress.IPV6,address=ue_ip_addr.encode('utf-8')))

        snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
                                             self.service_manager)
        with snapshot_verifier:
            pass
Esempio n. 22
0
    def _get_ip_flow_dl_match(self, ip_flow_dl: IPFlowDL, in_port: int):

        dest_ip = None
        src_ip = None

        if ip_flow_dl.dest_ip.address:
            addr_str = socket.inet_ntop(
                socket.AF_INET,
                ip_flow_dl.dest_ip.address,
            )
            dest_ip = IPAddress(
                version=IPAddress.IPV4,
                address=addr_str.encode('utf8'),
            )

        if ip_flow_dl.src_ip.address:
            addr_str = socket.inet_ntop(
                socket.AF_INET,
                ip_flow_dl.src_ip.address,
            )
            src_ip = IPAddress(
                version=IPAddress.IPV4,
                address=addr_str.encode('utf8'),
            )

        ip_match_dst = get_ue_ip_match_args(dest_ip, Direction.IN)
        ip_match_src = get_ue_ip_match_args(src_ip, Direction.OUT)

        if ip_flow_dl.ip_proto == IPPROTO_TCP:
            match = MagmaMatch(
                eth_type=get_eth_type(ip_flow_dl.dest_ip),
                in_port=in_port,
                **ip_match_dst,
                **ip_match_src,
                ip_proto=ip_flow_dl.ip_proto,
                tcp_src=ip_flow_dl.tcp_src_port,
                tcp_dst=ip_flow_dl.tcp_dst_port,
            )

        elif ip_flow_dl.ip_proto == IPPROTO_UDP:
            match = MagmaMatch(
                eth_type=get_eth_type(ip_flow_dl.dest_ip),
                in_port=in_port,
                **ip_match_dst,
                **ip_match_src,
                ip_proto=ip_flow_dl.ip_proto,
                udp_src=ip_flow_dl.udp_src_port,
                udp_dst=ip_flow_dl.udp_dst_port,
            )

        return match
Esempio n. 23
0
    def test_discard_tunnel_flows(self):

        self.classifier_controller._delete_all_flows()
        ue_ip_addr = "192.168.128.80"
        self.classifier_controller._discard_tunnel_flows(65525, 3,
                                                         IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')))

        ue_ip_addr = "192.168.128.82"
        self.classifier_controller._discard_tunnel_flows(65525, 4,
                                                         IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')))
        snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
                                             self.service_manager)
        with snapshot_verifier:
            pass
Esempio n. 24
0
    def GetIPForSubscriber(self, request, context):
        composite_sid = SIDUtils.to_str(request.sid)
        if request.apn:
            composite_sid = composite_sid + "." + request.apn

        ip = self._ipv4_allocator.get_ip_for_sid(composite_sid)
        if ip is None:
            context.set_details('SID %s not found' %
                                SIDUtils.to_str(request.sid))
            context.set_code(grpc.StatusCode.NOT_FOUND)
            return IPAddress()

        version = IPAddress.IPV4 if ip.version == 4 else IPAddress.IPV6
        return IPAddress(version=version, address=ip.packed)
Esempio n. 25
0
    def test_detach_multi_tunnel_flows(self):

        ue_ip_addr = "192.168.128.30"
        self.classifier_controller.delete_tunnel_flows(1, IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')), self.EnodeB_IP)

        ue_ip_addr = "192.168.128.31"
        self.classifier_controller.delete_tunnel_flows(2, IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')), self.EnodeB2_IP)

        ue_ip_addr = "192.168.128.51"
        self.classifier_controller.delete_tunnel_flows(5, IPAddress(version=IPAddress.IPV4,address=ue_ip_addr.encode('utf-8')), self.EnodeB2_IP)

        snapshot_verifier = SnapshotVerifier(self, self.BRIDGE,
                                             self.service_manager)
        with snapshot_verifier:
            pass
Esempio n. 26
0
    def _old_flow_stats(self, stats_msgs):
        """
        Generator function to filter the flow stats that should be deleted from
        the stats messages.
        """
        for flow_stats in stats_msgs:
            for stat in flow_stats:
                if stat.table_id != self.tbl_num:
                    # this update is not intended for policy
                    return

                rule_id = self._get_rule_id(stat)
                sid = _get_sid(stat)
                ipv4_addr_str = _get_ipv4(stat)
                ipv4_addr = None
                if ipv4_addr_str:
                    ipv4_addr = IPAddress(version=IPAddress.IPV4,
                                          address=ipv4_addr_str.encode('utf-8'))
                rule_version = _get_version(stat)
                if rule_id == "":
                    continue

                current_ver = \
                    self._session_rule_version_mapper.get_version(sid,
                                                                  ipv4_addr,
                                                                  rule_id)
                if current_ver != rule_version:
                    yield stat
Esempio n. 27
0
    def test_release_unknown_sid_apn_ip_tuple(self):
        """ releasing unknown sid-apn-ip tuple should raise NOT_FOUND """
        self._stub.AddIPBlock(self._block_msg)

        alloc_request0 = AllocateIPRequest(sid=self._sid0,
                                           version=AllocateIPRequest.IPV4,
                                           apn=self._apn0)
        ip_msg0 = self._stub.AllocateIPAddress(alloc_request0)

        request = ReleaseIPRequest(sid=SIDUtils.to_pb("IMSI12345"),
                                   ip=ip_msg0.ip_list[0],
                                   apn=self._apn0)
        with self.assertRaises(grpc.RpcError) as err:
            self._stub.ReleaseIPAddress(request)
        self.assertEqual(err.exception.code(), grpc.StatusCode.NOT_FOUND)

        ip_bytes = bytes(map(int, '10.0.0.0'.split('.')))
        request.ip.CopyFrom(IPAddress(version=IPAddress.IPV4,
                                      address=ip_bytes))
        with self.assertRaises(grpc.RpcError) as err:
            self._stub.ReleaseIPAddress(request)
        self.assertEqual(err.exception.code(), grpc.StatusCode.NOT_FOUND)

        request = ReleaseIPRequest(sid=self._sid0,
                                   ip=ip_msg0.ip_list[0],
                                   apn=self._apn1)
        with self.assertRaises(grpc.RpcError) as err:
            self._stub.ReleaseIPAddress(request)
        self.assertEqual(err.exception.code(), grpc.StatusCode.NOT_FOUND)
Esempio n. 28
0
    def ListAllocatedIPs(self, ipblock_msg, context):
        """ Return a list of IPs allocated from a IP block

        Args:
            ipblock_msg (IPBlock): ip block to add. ipblock_msg has the
            type IPBlock, a protobuf message type for the gRPC interface.
            Internal representation of ip blocks uses the ipaddress.ip_network
            type and is named as ipblock.
        """
        resp = ListAllocatedIPsResponse()

        ipblock = self._ipblock_msg_to_ipblock(ipblock_msg, context)
        if ipblock is None:
            return resp

        if ipblock_msg.version == IPBlock.IPV4:
            try:
                ips = self._ipv4_allocator.list_allocated_ips(ipblock)
                ip_msg_list = [
                    IPAddress(version=IPAddress.IPV4, address=ip.packed)
                    for ip in ips
                ]

                resp.ip_list.extend(ip_msg_list)
            except IPBlockNotFoundError:
                context.set_details('IP block not found: %s' % ipblock)
                context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
        else:
            self._unimplemented_ip_version_error(context)

        return resp
Esempio n. 29
0
    def test_attach_tunnel_flows(self):

        # Need to delete all default flows in table 0 before
        # install the specific flows test case.
        self.test_detach_default_tunnel_flows()

        seid1 = 5000
        ue_ip_addr = "192.168.128.30"
        ip_flow_dl = IPFlowDL(set_params=0)
        self.classifier_controller.add_tunnel_flows(
            65525,
            1,
            100000,
            self.EnodeB_IP,
            IPAddress(version=IPAddress.IPV4,
                      address=ue_ip_addr.encode('utf-8')),
            seid1,
            True,
            ip_flow_dl=ip_flow_dl,
        )

        snapshot_verifier = SnapshotVerifier(
            self,
            self.BRIDGE,
            self.service_manager,
        )
        with snapshot_verifier:
            pass
Esempio n. 30
0
def _ip_desc_to_proto(desc):
    """
    Convert an IP descriptor to protobuf.

    Args:
        desc (magma.mobilityd.IPDesc): IP descriptor
    Returns:
        proto (protos.keyval_pb2.IPDesc): protobuf of :desc:
    """
    ip = IPAddress(
        version=_ip_version_int_to_proto(desc.ip_block.version),
        address=desc.ip.packed,
    )
    ip_block = IPBlock(
        version=_ip_version_int_to_proto(desc.ip_block.version),
        net_address=desc.ip_block.network_address.packed,
        prefix_len=desc.ip_block.prefixlen,
    )
    state = _desc_state_str_to_proto(desc.state)
    sid = SubscriberID(
        id=desc.sid,
        type=SubscriberID.IMSI,
    )
    proto = IPDesc(ip=ip, ip_block=ip_block, state=state, sid=sid)
    return proto