Examples with Dhcp6InterfaceIdOption org.onlab.packet.dhcp.Dhcp6InterfaceIdOption used on opensource projects

Example 1 with Dhcp6InterfaceIdOption

use of org.onlab.packet.dhcp.Dhcp6InterfaceIdOption in project onos by opennetworkinglab.

the class DhcpRelayManagerTest method buildRelayMsg.

private void buildRelayMsg(DHCP6 dhcp6Relay, byte msgType, Ip6Address linkAddr, Ip6Address peerAddr, byte hop, byte[] interfaceIdBytes, DHCP6 dhcp6Payload) {
    dhcp6Relay.setMsgType(msgType);
    dhcp6Relay.setLinkAddress(linkAddr.toOctets());
    dhcp6Relay.setPeerAddress(peerAddr.toOctets());
    dhcp6Relay.setHopCount(hop);
    List<Dhcp6Option> options = new ArrayList<Dhcp6Option>();
    // interfaceId  option
    Dhcp6Option interfaceId = new Dhcp6Option();
    interfaceId.setCode(DHCP6.OptionCode.INTERFACE_ID.value());
    interfaceId.setData(interfaceIdBytes);
    interfaceId.setLength((short) interfaceIdBytes.length);
    Dhcp6InterfaceIdOption interfaceIdOption = new Dhcp6InterfaceIdOption(interfaceId);
    byte[] optionData = interfaceIdOption.getData();
    ByteBuffer bb = ByteBuffer.wrap(interfaceIdBytes);
    byte[] macAddr = new byte[MacAddress.MAC_ADDRESS_LENGTH];
    byte[] port = new byte[optionData.length - MacAddress.MAC_ADDRESS_LENGTH - VLAN_LEN - SEPARATOR_LEN * 2];
    short vlan;
    bb.get(macAddr);
    // separator
    bb.get();
    bb.get(port);
    // separator
    bb.get();
    vlan = bb.getShort();
    interfaceIdOption.setMacAddress(MacAddress.valueOf(macAddr));
    interfaceIdOption.setInPort(port);
    interfaceIdOption.setVlanId(vlan);
    options.add(interfaceIdOption);
    // relay message option
    Dhcp6Option relayMsgOption = new Dhcp6Option();
    relayMsgOption.setCode(DHCP6.OptionCode.RELAY_MSG.value());
    byte[] dhcp6PayloadByte = dhcp6Payload.serialize();
    relayMsgOption.setLength((short) dhcp6PayloadByte.length);
    relayMsgOption.setPayload(dhcp6Payload);
    Dhcp6RelayOption relayOpt = new Dhcp6RelayOption(relayMsgOption);
    options.add(relayOpt);
    dhcp6Relay.setOptions(options);
}

Example 2 with Dhcp6InterfaceIdOption

use of org.onlab.packet.dhcp.Dhcp6InterfaceIdOption 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);
}