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

Example 66 with MacAddress

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

the class HostMonitor method sendRequest.

/**
 * Sends an ARP or NDP request for the given IP address.
 *
 * @param targetIp IP address to send the request for
 */
private void sendRequest(IpAddress targetIp) {
    interfaceService.getMatchingInterfaces(targetIp).forEach(intf -> {
        Port port = deviceService.getPort(intf.connectPoint());
        if (port == null) {
            log.debug("Aborting probing non-existent port: {}", intf);
            return;
        }
        if (!port.isEnabled()) {
            log.debug("Aborting probing disabled port: {}", intf);
            return;
        }
        if (!edgePortService.isEdgePoint(intf.connectPoint())) {
            log.warn("Aborting probing non-edge port: {}", intf);
            return;
        }
        intf.ipAddressesList().stream().filter(ia -> ia.subnetAddress().contains(targetIp)).forEach(ia -> {
            MacAddress probeMac = intf.mac();
            IpAddress probeIp = !probeMac.equals(MacAddress.ONOS) ? ia.ipAddress() : (ia.ipAddress().isIp4() ? Ip4Address.ZERO : Ip6Address.ZERO);
            sendProbe(intf.connectPoint(), targetIp, probeIp, probeMac, intf.vlan());
            // account for use-cases where tagged-vlan config is used
            if (!intf.vlanTagged().isEmpty()) {
                intf.vlanTagged().forEach(tag -> {
                    sendProbe(intf.connectPoint(), targetIp, probeIp, probeMac, tag);
                });
            }
        });
    });
}

Example 67 with MacAddress

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

the class DeviceDescriptionDiscoveryAristaImpl method getMacAddressesByInterface.

private Map<String, MacAddress> getMacAddressesByInterface() {
    DeviceId deviceId = checkNotNull(handler().data().deviceId());
    Map<String, MacAddress> macAddressMap = new HashMap();
    try {
        Optional<JsonNode> result = AristaUtils.retrieveCommandResult(handler(), SHOW_INTERFACES);
        if (!result.isPresent()) {
            log.warn("{} Device unable to get interface information.", deviceId);
            return macAddressMap;
        }
        JsonNode jsonNode = result.get().findValue(INTERFACES);
        jsonNode.fieldNames().forEachRemaining(name -> {
            JsonNode interfaceNode = jsonNode.get(name);
            JsonNode macAddressNode = interfaceNode.get(BURNED_IN_ADDRESS);
            if (macAddressNode == null) {
                log.debug("Interface does not have {}: {}", BURNED_IN_ADDRESS, name);
                return;
            }
            String macAddress = macAddressNode.asText("");
            if (macAddress.isEmpty()) {
                macAddressNode = interfaceNode.get(PHYSICAL_ADDRESS);
                if (macAddressNode == null) {
                    log.debug("Interface does not have {}: {}", PHYSICAL_ADDRESS, name);
                    return;
                }
                macAddress = macAddressNode.asText("");
                if (macAddress.isEmpty()) {
                    log.debug("Interface does not have any mac address: {}", name);
                    return;
                }
            }
            try {
                macAddressMap.put(name, MacAddress.valueOf(macAddress));
            } catch (IllegalArgumentException e) {
                log.error("Cannot parse macAddress: {}", macAddress);
            }
        });
    } catch (Exception e) {
        log.error("Exception occurred because of {}, trace: {}", e, e.getStackTrace());
    }
    return macAddressMap;
}

Example 68 with MacAddress

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

the class DeviceDescriptionDiscoveryAristaImpl method discoverPortDetails.

@Override
public List<PortDescription> discoverPortDetails() {
    Map<String, MacAddress> macAddressMap = getMacAddressesByInterface();
    List<PortDescription> ports = Lists.newArrayList();
    DeviceId deviceId = checkNotNull(handler().data().deviceId());
    try {
        Optional<JsonNode> result = AristaUtils.retrieveCommandResult(handler(), SHOW_INTERFACES_STATUS);
        if (!result.isPresent()) {
            log.warn("{} Device unable to get interfaces status information.", deviceId);
            return ports;
        }
        JsonNode jsonNode = result.get().findValue(INTERFACE_STATUSES);
        jsonNode.fieldNames().forEachRemaining(name -> {
            JsonNode interfaceNode = jsonNode.get(name);
            Long bandwidth = interfaceNode.path(BANDWIDTH).asLong() / MBPS;
            String macAddress = macAddressMap.containsKey(name) ? macAddressMap.get(name).toString() : "";
            SparseAnnotations annotations = DefaultAnnotations.builder().set(AnnotationKeys.BANDWIDTH, bandwidth.toString()).set(AnnotationKeys.NAME, name).set(AnnotationKeys.PORT_NAME, name).set(AnnotationKeys.PORT_MAC, macAddress).set(LINK_STATUS, interfaceNode.path(LINK_STATUS).asText()).set(LINE_PROTOCOL_STATUS, interfaceNode.path(LINE_PROTOCOL_STATUS).asText()).set(INTERFACE_TYPE, interfaceNode.path(INTERFACE_TYPE).asText()).build();
            int portNumber;
            try {
                portNumber = getPortNumber(name);
            } catch (Exception e) {
                log.debug("Interface does not have port number: {}", name);
                return;
            }
            PortDescription portDescription = DefaultPortDescription.builder().withPortNumber(PortNumber.portNumber(portNumber)).isEnabled(true).type(Port.Type.FIBER).portSpeed(bandwidth).annotations(annotations).build();
            ports.add(portDescription);
        });
    } catch (Exception e) {
        log.error("Exception occurred because of {}, trace: {}", e, e.getStackTrace());
    }
    return ports;
}

Example 69 with MacAddress

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

the class Dhcp6HandlerImpl method processDhcp6PacketFromServer.

/**
 * process the DHCP6 relay-reply packet from dhcp server.
 *
 * @param context packet context
 * @param receivedPacket server ethernet packet
 * @param recevingInterfaces set of server side interfaces
 * @return internalPacket toward client
 */
private InternalPacket processDhcp6PacketFromServer(PacketContext context, Ethernet receivedPacket, Set<Interface> recevingInterfaces) {
    // get dhcp6 header.
    Ethernet etherReply = receivedPacket.duplicate();
    IPv6 ipv6Packet = (IPv6) etherReply.getPayload();
    UDP udpPacket = (UDP) ipv6Packet.getPayload();
    DHCP6 dhcp6Relay = (DHCP6) udpPacket.getPayload();
    Boolean directConnFlag = Dhcp6HandlerUtil.directlyConnected(dhcp6Relay);
    DHCP6 embeddedDhcp6 = dhcp6Relay.getOptions().stream().filter(opt -> opt instanceof Dhcp6RelayOption).map(BasePacket::getPayload).map(pld -> (DHCP6) pld).findFirst().orElse(null);
    ConnectPoint inPort = context.inPacket().receivedFrom();
    DhcpServerInfo foundServerInfo = findServerInfoFromServer(directConnFlag, inPort);
    if (foundServerInfo == null) {
        log.warn("Cannot find server info for {} server, inPort {}", directConnFlag ? "direct" : "indirect", inPort);
        // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_SERVER_INFO);
        return null;
    } else {
        if (Dhcp6HandlerUtil.isServerIpEmpty(foundServerInfo)) {
            log.warn("Cannot find server info's ipaddress");
            // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_SERVER_IP6ADDR);
            return null;
        }
    }
    Dhcp6InterfaceIdOption interfaceIdOption = dhcp6Relay.getOptions().stream().filter(opt -> opt instanceof Dhcp6InterfaceIdOption).map(opt -> (Dhcp6InterfaceIdOption) opt).findFirst().orElse(null);
    if (interfaceIdOption == null) {
        log.warn("Interface Id option is not present, abort packet...");
        // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.OPTION_MISSING_FAIL);
        return null;
    }
    MacAddress peerMac = interfaceIdOption.getMacAddress();
    String clientConnectionPointStr = new String(interfaceIdOption.getInPort());
    ConnectPoint clientConnectionPoint = ConnectPoint.deviceConnectPoint(clientConnectionPointStr);
    VlanId vlanIdInUse = VlanId.vlanId(interfaceIdOption.getVlanId());
    log.debug("processDhcp6PacketFromServer Interface Id Mac {}, port{}, vlan {}", peerMac, clientConnectionPointStr, vlanIdInUse);
    Interface clientInterface = interfaceService.getInterfacesByPort(clientConnectionPoint).stream().filter(iface -> Dhcp6HandlerUtil.interfaceContainsVlan(iface, vlanIdInUse)).findFirst().orElse(null);
    if (clientInterface == null) {
        log.warn("Cannot get client interface for from packet, abort... vlan {}", vlanIdInUse.toString());
        // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_MATCHING_INTF);
        return null;
    }
    etherReply.setVlanID(vlanIdInUse.toShort());
    MacAddress relayAgentMac = clientInterface.mac();
    if (relayAgentMac == null) {
        log.warn("Can not get client interface mac, abort packet..");
        // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_CLIENT_INTF_MAC);
        return null;
    }
    etherReply.setSourceMACAddress(relayAgentMac);
    // find destMac
    MacAddress clientMac;
    Ip6Address peerAddress = Ip6Address.valueOf(dhcp6Relay.getPeerAddress());
    Set<Host> clients = hostService.getHostsByIp(peerAddress);
    if (clients.isEmpty()) {
        log.trace("There's no host found for this address {}", HexString.toHexString(dhcp6Relay.getPeerAddress(), ":"));
        log.trace("Let's look up interfaceId {}", HexString.toHexString(peerMac.toBytes(), ":"));
        clientMac = peerMac;
    } else {
        clientMac = clients.iterator().next().mac();
        if (clientMac == null) {
            log.warn("No client mac address found, abort packet...");
            // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_CLIENT_INTF_MAC);
            return null;
        }
        log.trace("Client mac address found from getHostByIp");
    }
    etherReply.setDestinationMACAddress(clientMac);
    // ip header
    ipv6Packet.setSourceAddress(dhcp6Relay.getLinkAddress());
    ipv6Packet.setDestinationAddress(dhcp6Relay.getPeerAddress());
    // udp header
    udpPacket.setSourcePort(UDP.DHCP_V6_SERVER_PORT);
    if (directConnFlag) {
        udpPacket.setDestinationPort(UDP.DHCP_V6_CLIENT_PORT);
    } else {
        udpPacket.setDestinationPort(UDP.DHCP_V6_SERVER_PORT);
    }
    boolean hostOrRouteAllowed = learnRouteFromLeasequery || Dhcp6HandlerUtil.getDhcp6LeafMessageType(dhcp6Relay) != MsgType.LEASEQUERY_REPLY;
    log.debug("Can add host or route: {}", hostOrRouteAllowed);
    if (hostOrRouteAllowed) {
        // add host or route
        addHostOrRoute(directConnFlag, clientConnectionPoint, dhcp6Relay, embeddedDhcp6, clientMac, clientInterface, vlanIdInUse);
    }
    udpPacket.setPayload(embeddedDhcp6);
    udpPacket.resetChecksum();
    ipv6Packet.setPayload(udpPacket);
    etherReply.setPayload(ipv6Packet);
    return InternalPacket.internalPacket(etherReply, clientConnectionPoint);
}

Example 70 with MacAddress

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

the class Dhcp6HandlerImpl method processDhcp6PacketFromClient.

/**
 * build the DHCP6 solicit/request packet with gatewayip.
 *
 * @param context packet context
 * @param clientPacket client ethernet packet
 * @param clientInterfaces set of client side interfaces
 */
private List<InternalPacket> processDhcp6PacketFromClient(PacketContext context, Ethernet clientPacket, Set<Interface> clientInterfaces) {
    ConnectPoint receivedFrom = context.inPacket().receivedFrom();
    Ip6Address relayAgentIp = Dhcp6HandlerUtil.getRelayAgentIPv6Address(clientInterfaces);
    MacAddress relayAgentMac = clientInterfaces.iterator().next().mac();
    if (relayAgentIp == null || relayAgentMac == null) {
        log.warn("Missing DHCP relay agent interface Ipv6 addr config for " + "packet from client on port: {}. Aborting packet processing", clientInterfaces.iterator().next().connectPoint());
        // dhcpRelayCountersStore.incrementCounter(gCount, DhcpRelayCounters.NO_CLIENT_INTF_MAC);
        return Lists.newArrayList();
    }
    IPv6 clientIpv6 = (IPv6) clientPacket.getPayload();
    UDP clientUdp = (UDP) clientIpv6.getPayload();
    DHCP6 clientDhcp6 = (DHCP6) clientUdp.getPayload();
    boolean directConnFlag = Dhcp6HandlerUtil.directlyConnected(clientDhcp6);
    ConnectPoint clientConnectionPoint = context.inPacket().receivedFrom();
    VlanId vlanIdInUse = VlanId.vlanId(clientPacket.getVlanID());
    Interface clientInterface = interfaceService.getInterfacesByPort(clientConnectionPoint).stream().filter(iface -> Dhcp6HandlerUtil.interfaceContainsVlan(iface, vlanIdInUse)).findFirst().orElse(null);
    List<InternalPacket> internalPackets = new ArrayList<>();
    List<DhcpServerInfo> serverInfoList = findValidServerInfo(directConnFlag);
    List<DhcpServerInfo> copyServerInfoList = new ArrayList<DhcpServerInfo>(serverInfoList);
    for (DhcpServerInfo serverInfo : copyServerInfoList) {
        if (!Dhcp6HandlerUtil.checkDhcpServerConnPt(directConnFlag, serverInfo)) {
            log.warn("Can't get server connect point, ignore");
            continue;
        }
        DhcpServerInfo newServerInfo = getHostInfoForServerInfo(serverInfo, serverInfoList);
        if (newServerInfo == null) {
            log.warn("Can't get server interface with host info resolved, ignore");
            continue;
        }
        Interface serverInterface = getServerInterface(newServerInfo);
        if (serverInterface == null) {
            log.warn("Can't get server interface, ignore");
            continue;
        }
        Ethernet etherReply = Dhcp6HandlerUtil.buildDhcp6PacketFromClient(context, clientPacket, clientInterfaces, newServerInfo, serverInterface);
        removeHostOrRoute(directConnFlag, clientConnectionPoint, clientDhcp6, clientPacket, clientIpv6, clientInterface);
        InternalPacket internalPacket = InternalPacket.internalPacket(etherReply, serverInfo.getDhcpServerConnectPoint().get());
        internalPackets.add(internalPacket);
    }
    log.debug("num of client packets to send is{}", internalPackets.size());
    return internalPackets;
}