Examples with VlanId org.onlab.packet.VlanId used on opensource projects

Example 61 with VlanId

use of org.onlab.packet.VlanId in project onos by opennetworkinglab.

the class ServerInterfaceConfig method getVlanIdListForDevice.

/**
 * Returns a list of VLAN IDs associated with a NIC device.
 *
 * @param nic the NIC device to be queried
 * @return a list of VLAN IDs (if any)
 */
private List<VlanId> getVlanIdListForDevice(NicDevice nic) {
    checkNotNull(nic, MSG_DEVICE_NULL);
    List<VlanId> vlanIds = Lists.newArrayList();
    short vlanIdValue = 0;
    for (RxFilter rxFilter : nic.rxFilterMechanisms().rxFilters()) {
        if (rxFilter == RxFilter.VLAN) {
            vlanIds.add(VlanId.vlanId(vlanIdValue++));
        }
    }
    return ImmutableList.copyOf(vlanIds);
}

Example 62 with VlanId

use of org.onlab.packet.VlanId in project onos by opennetworkinglab.

the class ComponentCodec method decode.

/**
 * Decodes the Component entity from JSON.
 *
 * @param json    JSON to decode
 * @param context decoding context
 * @return decoded Component
 * @throws java.lang.UnsupportedOperationException if the codec does not
 *                                                 support decode operations
 */
@Override
public Component decode(ObjectNode json, CodecContext context) {
    if (json == null || !json.isObject()) {
        return null;
    }
    JsonNode componentNode = json.get(COMPONENT);
    int componentId = nullIsIllegal(componentNode.get(COMPONENT_ID), "component-id is required").asInt();
    Component.ComponentBuilder componentBuilder = DefaultComponent.builder(componentId);
    List<VlanId> vidList = (new VidCodec()).decode((ArrayNode) nullIsIllegal(componentNode.get(VID_LIST), "vid-list is required"), context);
    if (vidList == null || vidList.isEmpty()) {
        throw new IllegalArgumentException("A least one VID is required in component: " + componentId);
    }
    for (VlanId vid : vidList) {
        componentBuilder = componentBuilder.addToVidList(vid);
    }
    if (componentNode.get(TAG_TYPE) != null) {
        componentBuilder = componentBuilder.tagType(Component.TagType.valueOf(componentNode.get(TAG_TYPE).asText()));
    }
    if (componentNode.get(MHF_CREATION_TYPE) != null) {
        componentBuilder = componentBuilder.mhfCreationType(Component.MhfCreationType.valueOf(componentNode.get(MHF_CREATION_TYPE).asText()));
    }
    if (componentNode.get(ID_PERMISSION) != null) {
        componentBuilder = componentBuilder.idPermission(Component.IdPermissionType.valueOf(componentNode.get(ID_PERMISSION).asText()));
    }
    return componentBuilder.build();
}

Example 63 with VlanId

use of org.onlab.packet.VlanId in project onos by opennetworkinglab.

the class Dhcp6HandlerImpl method removeHostOrRoute.

/**
 * remove host or route and update dhcp relay record attributes.
 *
 * @param directConnFlag  flag to show that packet is from directly connected client
 * @param location  client side connect point
 * @param dhcp6Packet the dhcp6 payload
 * @param clientPacket client's ethernet packet
 * @param clientIpv6 client's Ipv6 packet
 * @param clientInterface client interfaces
 */
private void removeHostOrRoute(boolean directConnFlag, ConnectPoint location, DHCP6 dhcp6Packet, Ethernet clientPacket, IPv6 clientIpv6, Interface clientInterface) {
    log.debug("removeHostOrRoute  enters {}", dhcp6Packet);
    VlanId vlanId = clientInterface.vlan();
    // could be gw or host
    MacAddress srcMac = clientPacket.getSourceMAC();
    MacAddress leafClientMac;
    byte leafMsgType;
    log.debug("client mac {} client vlan {}", HexString.toHexString(srcMac.toBytes(), ":"), vlanId);
    Dhcp6ClientIdOption clientIdOption = Dhcp6HandlerUtil.extractClientId(directConnFlag, dhcp6Packet);
    if (clientIdOption != null) {
        if ((clientIdOption.getDuid().getDuidType() == Dhcp6Duid.DuidType.DUID_LLT) || (clientIdOption.getDuid().getDuidType() == Dhcp6Duid.DuidType.DUID_LL)) {
            leafClientMac = MacAddress.valueOf(clientIdOption.getDuid().getLinkLayerAddress());
        } else {
            log.warn("Link-Layer Address not supported in CLIENTID option. No DhcpRelay Record created.");
            // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_LINKLOCAL_FAIL);
            return;
        }
    } else {
        log.warn("CLIENTID option NOT found. Don't create DhcpRelay Record.");
        // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_CLIENTID_FAIL);
        return;
    }
    HostId leafHostId = HostId.hostId(leafClientMac, vlanId);
    DhcpRecord record = dhcpRelayStore.getDhcpRecord(leafHostId).orElse(null);
    if (record == null) {
        record = new DhcpRecord(leafHostId);
    } else {
        record = record.clone();
    }
    Boolean isMsgRelease = Dhcp6HandlerUtil.isDhcp6Release(dhcp6Packet);
    IpAddressInfo ipInfo;
    PdPrefixInfo pdInfo = null;
    if (directConnFlag) {
        // Add to host store if it is connected to network directly
        ipInfo = extractIpAddress(dhcp6Packet);
        if (ipInfo != null) {
            if (isMsgRelease) {
                HostId hostId = HostId.hostId(srcMac, vlanId);
                log.debug("remove Host {} ip for directly connected.", hostId.toString());
                providerService.removeIpFromHost(hostId, ipInfo.ip6Address);
            }
        } else {
            log.debug("ipAddress not found. Do not remove Host {} for directly connected.", HostId.hostId(srcMac, vlanId).toString());
        }
        leafMsgType = dhcp6Packet.getMsgType();
    } else {
        // Remove from route store if it is not connected to network directly
        // pick out the first link-local ip address
        IpAddress nextHopIp = getFirstIpByHost(directConnFlag, srcMac, vlanId);
        if (nextHopIp == null) {
            log.warn("Can't find link-local IP address of gateway mac {} vlanId {}", srcMac, vlanId);
            // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_LINKLOCAL_GW);
            return;
        }
        DHCP6 leafDhcp = Dhcp6HandlerUtil.getDhcp6Leaf(dhcp6Packet);
        ipInfo = extractIpAddress(leafDhcp);
        if (ipInfo == null) {
            log.debug("ip is null");
        } else {
            if (isMsgRelease) {
                Route routeForIP = new Route(Route.Source.DHCP, ipInfo.ip6Address.toIpPrefix(), nextHopIp);
                log.debug("removing route of 128 address for indirectly connected.");
                log.debug("128 ip {}, nexthop {}", HexString.toHexString(ipInfo.ip6Address.toOctets(), ":"), HexString.toHexString(nextHopIp.toOctets(), ":"));
                routeStore.removeRoute(routeForIP);
            }
        }
        pdInfo = extractPrefix(leafDhcp);
        if (pdInfo == null) {
            log.debug("ipPrefix is null ");
        } else {
            if (isMsgRelease) {
                Route routeForPrefix = new Route(Route.Source.DHCP, pdInfo.pdPrefix, nextHopIp);
                log.debug("removing route of PD for indirectly connected.");
                log.debug("pd ip {}, nexthop {}", HexString.toHexString(pdInfo.pdPrefix.address().toOctets(), ":"), HexString.toHexString(nextHopIp.toOctets(), ":"));
                routeStore.removeRoute(routeForPrefix);
                if (this.dhcpFpmEnabled) {
                    dhcpFpmPrefixStore.removeFpmRecord(pdInfo.pdPrefix);
                }
            }
        }
        leafMsgType = leafDhcp.getMsgType();
    }
    if (isMsgRelease) {
        log.debug("DHCP6 RELEASE msg.");
        if (record != null) {
            if (ipInfo != null) {
                log.debug("DhcpRelay Record ip6Address is set to null.");
                record.ip6Address(null);
            }
            if (pdInfo != null) {
                log.debug("DhcpRelay Record pdPrefix is set to null.");
            }
            if (!record.ip6Address().isPresent() && !record.pdPrefix().isPresent()) {
                log.warn("IP6 address and IP6 PD both are null. Remove record.");
            // do not remove a record. Let timer task handler it.
            // dhcpRelayStore.removeDhcpRecord(HostId.hostId(leafClientMac, vlanId));
            }
        }
    }
    if (record != null) {
        record.getV6Counters().incrementCounter(Dhcp6HandlerUtil.getMsgTypeStr(leafMsgType));
        record.addLocation(new HostLocation(location, System.currentTimeMillis()));
        record.ip6Status(DHCP6.MsgType.getType(leafMsgType));
        record.setDirectlyConnected(directConnFlag);
        if (!directConnFlag) {
            // Update gateway mac address if the host is not directly connected
            record.nextHop(srcMac);
        }
        record.updateLastSeen();
    }
    dhcpRelayStore.updateDhcpRecord(leafHostId, record);
/*
        // TODO Use AtomicInteger for the counters
        try {
            recordSemaphore.acquire();
            try {
                dhcpRelayCountersStore.incrementCounter(gCount, Dhcp6HandlerUtil.getMsgTypeStr(leafMsgType));
            } finally {
                // calling release() after a successful acquire()
                recordSemaphore.release();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        */
}

Example 64 with VlanId

use of org.onlab.packet.VlanId in project onos by opennetworkinglab.

the class Dhcp4HandlerImpl method processLeaseQueryFromServer.

/**
 * Build the DHCP offer/ack with proper client port.
 *
 * @param ethernetPacket the original packet comes from server
 * @return new packet which will send to the client
 */
private InternalPacket processLeaseQueryFromServer(Ethernet ethernetPacket) {
    // get dhcp header.
    Ethernet etherReply = (Ethernet) ethernetPacket.clone();
    IPv4 ipv4Packet = (IPv4) etherReply.getPayload();
    UDP udpPacket = (UDP) ipv4Packet.getPayload();
    DHCP dhcpPayload = (DHCP) udpPacket.getPayload();
    // determine the vlanId of the client host - note that this vlan id
    // could be different from the vlan in the packet from the server
    Interface clientInterface = null;
    MacAddress destinationMac = MacAddress.valueOf(dhcpPayload.getClientHardwareAddress());
    if (!learnRouteFromLeasequery) {
        int giaddr = ipv4Packet.getDestinationAddress();
        IpAddress destinationAddress = Ip4Address.valueOf(giaddr);
        log.debug("DHCPLEASEQUERYRESP giaddr: {}({})", giaddr, destinationAddress);
        Host destinationHost = hostService.getHostsByIp(destinationAddress).stream().findFirst().orElse(null);
        if (destinationHost != null) {
            destinationMac = destinationHost.mac();
            log.trace("DHCPLEASEQUERYRESP destination mac is: {}", destinationMac);
            ConnectPoint destinationLocation = destinationHost.location();
            log.trace("Lookup for client interface by destination location {}", destinationLocation);
            clientInterface = interfaceService.getInterfacesByPort(destinationLocation).stream().filter(iface -> interfaceContainsVlan(iface, VlanId.vlanId(etherReply.getVlanID()))).findFirst().orElse(null);
            log.trace("Found Host {} by ip {}", destinationHost, destinationAddress);
            log.debug("DHCPLEASEQUERYRESP Client interface: {}", (clientInterface != null ? clientInterface : "not resolved"));
        }
    } else {
        clientInterface = getClientInterface(ethernetPacket, dhcpPayload).orElse(null);
    }
    if (clientInterface == null) {
        log.warn("Cannot find the interface for the DHCP {}", dhcpPayload);
        return null;
    }
    VlanId vlanId;
    if (clientInterface.vlanTagged().isEmpty()) {
        vlanId = clientInterface.vlan();
    } else {
        // might be multiple vlan in same interface
        vlanId = getVlanIdFromRelayAgentOption(dhcpPayload);
    }
    if (vlanId == null) {
        vlanId = VlanId.NONE;
    }
    etherReply.setVlanID(vlanId.toShort());
    etherReply.setSourceMACAddress(clientInterface.mac());
    if (!directlyConnected(dhcpPayload) && learnRouteFromLeasequery) {
        // if client is indirectly connected, try use next hop mac address
        MacAddress macAddress = MacAddress.valueOf(dhcpPayload.getClientHardwareAddress());
        HostId hostId = HostId.hostId(macAddress, vlanId);
        DhcpRecord record = dhcpRelayStore.getDhcpRecord(hostId).orElse(null);
        if (record != null) {
            // if next hop can be found, use mac address of next hop
            Optional<MacAddress> nextHop = record.nextHopTemp();
            if (!nextHop.isPresent()) {
                nextHop = record.nextHop();
            }
            nextHop.ifPresent(etherReply::setDestinationMACAddress);
        } else {
            // otherwise, discard the packet
            log.warn("Can't find record for host id {}, discard packet", hostId);
            return null;
        }
    } else {
        etherReply.setDestinationMACAddress(destinationMac);
    }
    udpPacket.setSourcePort(UDP.DHCP_SERVER_PORT);
    if (directlyConnected(dhcpPayload)) {
        udpPacket.setDestinationPort(UDP.DHCP_CLIENT_PORT);
    } else {
        udpPacket.setDestinationPort(UDP.DHCP_SERVER_PORT);
    }
    udpPacket.setPayload(dhcpPayload);
    ipv4Packet.setPayload(udpPacket);
    etherReply.setPayload(ipv4Packet);
    udpPacket.resetChecksum();
    return InternalPacket.internalPacket(etherReply, clientInterface.connectPoint());
}

Example 65 with VlanId

use of org.onlab.packet.VlanId in project onos by opennetworkinglab.

the class Dhcp6HandlerImpl method getServerInterface.

/**
 * Gets Interface facing to the server for default host.
 *
 * @param serverInfo server information
 * @return the Interface facing to the server; null if not found
 */
private Interface getServerInterface(DhcpServerInfo serverInfo) {
    Interface serverInterface = null;
    ConnectPoint dhcpServerConnectPoint = serverInfo.getDhcpServerConnectPoint().orElse(null);
    VlanId dhcpConnectVlan = serverInfo.getDhcpConnectVlan().orElse(null);
    if (dhcpServerConnectPoint != null && dhcpConnectVlan != null) {
        serverInterface = interfaceService.getInterfacesByPort(dhcpServerConnectPoint).stream().filter(iface -> Dhcp6HandlerUtil.interfaceContainsVlan(iface, dhcpConnectVlan)).findFirst().orElse(null);
    } else {
        log.warn("DHCP server {} not resolve yet connectPoint {} vlan {}", serverInfo.getDhcpServerIp6(), dhcpServerConnectPoint, dhcpConnectVlan);
    }
    return serverInterface;
}