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

Example 41 with Ethernet

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

the class Dhcp4HandlerImpl method processDhcpPacket.

@Override
public void processDhcpPacket(PacketContext context, BasePacket payload) {
    checkNotNull(payload, "DHCP payload can't be null");
    checkState(payload instanceof DHCP, "Payload is not a DHCP");
    DHCP dhcpPayload = (DHCP) payload;
    if (!configured()) {
        log.warn("Missing default DHCP relay server config. Abort packet processing");
        return;
    }
    ConnectPoint inPort = context.inPacket().receivedFrom();
    checkNotNull(dhcpPayload, "Can't find DHCP payload");
    Ethernet packet = context.inPacket().parsed();
    DHCP.MsgType incomingPacketType = dhcpPayload.getOptions().stream().filter(dhcpOption -> dhcpOption.getCode() == OptionCode_MessageType.getValue()).map(DhcpOption::getData).map(data -> DHCP.MsgType.getType(data[0])).findFirst().orElse(null);
    checkNotNull(incomingPacketType, "Can't get message type from DHCP payload {}", dhcpPayload);
    Set<Interface> receivingInterfaces = interfaceService.getInterfacesByPort(inPort);
    // ignore the packets if dhcp client interface is not configured on onos.
    if (receivingInterfaces.isEmpty()) {
        log.warn("Virtual interface is not configured on {}", inPort);
        return;
    }
    switch(incomingPacketType) {
        case DHCPDISCOVER:
            // Add the gateway IP as virtual interface IP for server to understand
            // the lease to be assigned and forward the packet to dhcp server.
            List<InternalPacket> ethernetClientPacket = processDhcpPacketFromClient(context, packet, receivingInterfaces);
            for (InternalPacket internalPacket : ethernetClientPacket) {
                log.debug("DHCPDISCOVER from {} Forward to server", inPort);
                writeRequestDhcpRecord(inPort, packet, dhcpPayload);
                forwardPacket(internalPacket);
            }
            break;
        case DHCPOFFER:
            // reply to dhcp client.
            InternalPacket ethernetPacketOffer = processDhcpPacketFromServer(context, packet);
            if (ethernetPacketOffer != null) {
                writeResponseDhcpRecord(ethernetPacketOffer.getPacket(), dhcpPayload);
                sendResponseToClient(ethernetPacketOffer, dhcpPayload);
            }
            break;
        case DHCPREQUEST:
            // add the gateway ip as virtual interface ip for server to understand
            // the lease to be assigned and forward the packet to dhcp server.
            List<InternalPacket> ethernetPacketRequest = processDhcpPacketFromClient(context, packet, receivingInterfaces);
            for (InternalPacket internalPacket : ethernetPacketRequest) {
                log.debug("DHCPDISCOVER from {} Forward to server", inPort);
                writeRequestDhcpRecord(inPort, packet, dhcpPayload);
                forwardPacket(internalPacket);
            }
            break;
        case DHCPDECLINE:
            break;
        case DHCPACK:
            // reply to dhcp client.
            InternalPacket ethernetPacketAck = processDhcpPacketFromServer(context, packet);
            if (ethernetPacketAck != null) {
                writeResponseDhcpRecord(ethernetPacketAck.getPacket(), dhcpPayload);
                handleDhcpAck(ethernetPacketAck.getPacket(), dhcpPayload);
                sendResponseToClient(ethernetPacketAck, dhcpPayload);
            }
            break;
        case DHCPNAK:
            break;
        case DHCPRELEASE:
            // TODO: release the ip address from client
            break;
        case DHCPINFORM:
            break;
        case DHCPFORCERENEW:
            break;
        case DHCPLEASEQUERY:
            handleLeaseQueryMsg(context, packet, dhcpPayload);
            break;
        case DHCPLEASEACTIVE:
            handleLeaseQueryActivateMsg(packet, dhcpPayload);
            break;
        case DHCPLEASEUNASSIGNED:
        case DHCPLEASEUNKNOWN:
            handleLeaseQueryUnknown(packet, dhcpPayload);
            break;
        default:
            break;
    }
}

Example 42 with Ethernet

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

the class Dhcp4HandlerImpl method removeRelayAgentOption.

/**
 * Removes DHCP relay agent information option (option 82) from DHCP payload.
 * Also reset giaddr to 0
 *
 * @param ethPacket the Ethernet packet to be processed
 * @return Ethernet packet processed
 */
private Ethernet removeRelayAgentOption(Ethernet ethPacket) {
    Ethernet ethernet = (Ethernet) ethPacket.duplicate();
    IPv4 ipv4 = (IPv4) ethernet.getPayload();
    UDP udp = (UDP) ipv4.getPayload();
    DHCP dhcpPayload = (DHCP) udp.getPayload();
    // removes relay agent information option
    List<DhcpOption> options = dhcpPayload.getOptions();
    options = options.stream().filter(option -> option.getCode() != OptionCode_CircuitID.getValue()).collect(Collectors.toList());
    dhcpPayload.setOptions(options);
    dhcpPayload.setGatewayIPAddress(0);
    udp.setPayload(dhcpPayload);
    ipv4.setPayload(udp);
    ethernet.setPayload(ipv4);
    return ethernet;
}

Example 43 with Ethernet

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

the class Dhcp6HandlerUtil method processLQ6PacketFromServer.

/**
 * process the LQ reply packet from dhcp server.
 *
 * @param defaultServerInfoList default server list
 * @param indirectServerInfoList default indirect server list
 * @param serverInterface server interface
 * @param interfaceService interface service
 * @param hostService host service
 * @param context packet context
 * @param receivedPacket server ethernet packet
 * @param recevingInterfaces set of server side interfaces
 * @return a packet ready to be sent to relevant output interface
 */
public static InternalPacket processLQ6PacketFromServer(List<DhcpServerInfo> defaultServerInfoList, List<DhcpServerInfo> indirectServerInfoList, Interface serverInterface, InterfaceService interfaceService, HostService hostService, PacketContext context, Ethernet receivedPacket, Set<Interface> recevingInterfaces) {
    // get dhcp6 header.
    Ethernet etherReply = (Ethernet) receivedPacket.clone();
    IPv6 ipv6Packet = (IPv6) etherReply.getPayload();
    UDP udpPacket = (UDP) ipv6Packet.getPayload();
    DHCP6 lq6Reply = (DHCP6) udpPacket.getPayload();
    // TODO: refactor
    ConnectPoint receivedFrom = context.inPacket().receivedFrom();
    DeviceId receivedFromDevice = receivedFrom.deviceId();
    DhcpServerInfo serverInfo;
    Ip6Address dhcpServerIp = null;
    ConnectPoint dhcpServerConnectPoint = null;
    MacAddress dhcpConnectMac = null;
    VlanId dhcpConnectVlan = null;
    Ip6Address dhcpGatewayIp = null;
    // todo: refactor
    Ip6Address indirectDhcpServerIp = null;
    ConnectPoint indirectDhcpServerConnectPoint = null;
    MacAddress indirectDhcpConnectMac = null;
    VlanId indirectDhcpConnectVlan = null;
    Ip6Address indirectDhcpGatewayIp = null;
    Ip6Address indirectRelayAgentIpFromCfg = null;
    if (!defaultServerInfoList.isEmpty()) {
        serverInfo = defaultServerInfoList.get(0);
        dhcpConnectMac = serverInfo.getDhcpConnectMac().orElse(null);
        dhcpGatewayIp = serverInfo.getDhcpGatewayIp6().orElse(null);
        dhcpServerIp = serverInfo.getDhcpServerIp6().orElse(null);
        dhcpServerConnectPoint = serverInfo.getDhcpServerConnectPoint().orElse(null);
        dhcpConnectVlan = serverInfo.getDhcpConnectVlan().orElse(null);
    }
    if (!indirectServerInfoList.isEmpty()) {
        serverInfo = indirectServerInfoList.get(0);
        indirectDhcpConnectMac = serverInfo.getDhcpConnectMac().orElse(null);
        indirectDhcpGatewayIp = serverInfo.getDhcpGatewayIp6().orElse(null);
        indirectDhcpServerIp = serverInfo.getDhcpServerIp6().orElse(null);
        indirectDhcpServerConnectPoint = serverInfo.getDhcpServerConnectPoint().orElse(null);
        indirectDhcpConnectVlan = serverInfo.getDhcpConnectVlan().orElse(null);
        indirectRelayAgentIpFromCfg = serverInfo.getRelayAgentIp6(receivedFromDevice).orElse(null);
    }
    Boolean directConnFlag = directlyConnected(lq6Reply);
    ConnectPoint inPort = context.inPacket().receivedFrom();
    if ((directConnFlag || indirectDhcpServerIp == null) && !inPort.equals(dhcpServerConnectPoint)) {
        log.warn("Receiving port {} is not the same as server connect point {} for direct or indirect-null", inPort, dhcpServerConnectPoint);
        return null;
    }
    if (!directConnFlag && indirectDhcpServerIp != null && !inPort.equals(indirectDhcpServerConnectPoint)) {
        log.warn("Receiving port {} is not the same as server connect point {} for indirect", inPort, indirectDhcpServerConnectPoint);
        return null;
    }
    Ip6Address nextHopIP = Ip6Address.valueOf(ipv6Packet.getDestinationAddress());
    // use hosts store to find out the next hop mac and connection point
    Set<Host> hosts = hostService.getHostsByIp(nextHopIP);
    Host host;
    if (!hosts.isEmpty()) {
        host = hosts.iterator().next();
    } else {
        log.warn("Host {} is not in store", nextHopIP);
        return null;
    }
    HostLocation hl = host.location();
    // iterator().next());
    String clientConnectionPointStr = hl.toString();
    ConnectPoint clientConnectionPoint = ConnectPoint.deviceConnectPoint(clientConnectionPointStr);
    VlanId originalPacketVlanId = VlanId.vlanId(etherReply.getVlanID());
    Interface iface;
    iface = interfaceService.getInterfacesByPort(clientConnectionPoint).stream().filter(iface1 -> interfaceContainsVlan(iface1, originalPacketVlanId)).findFirst().orElse(null);
    etherReply.setSourceMACAddress(iface.mac());
    etherReply.setDestinationMACAddress(host.mac());
    // workaround for a bug where core sends src port as 547 (server)
    udpPacket.setDestinationPort(UDP.DHCP_V6_SERVER_PORT);
    udpPacket.setPayload(lq6Reply);
    udpPacket.resetChecksum();
    ipv6Packet.setPayload(udpPacket);
    etherReply.setPayload(ipv6Packet);
    return InternalPacket.internalPacket(etherReply, clientConnectionPoint);
}

Example 44 with Ethernet

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

the class Dhcp6HandlerUtil method buildDhcp6PacketFromClient.

/**
 * build the DHCP6 solicit/request packet with gatewayip.
 *
 * @param context packet context
 * @param clientPacket client ethernet packet
 * @param clientInterfaces set of client side interfaces
 * @param serverInfo target server which a packet is generated for
 * @param serverInterface target server interface
 * @return ethernet packet with dhcp6 packet info
 */
public static Ethernet buildDhcp6PacketFromClient(PacketContext context, Ethernet clientPacket, Set<Interface> clientInterfaces, DhcpServerInfo serverInfo, Interface serverInterface) {
    ConnectPoint receivedFrom = context.inPacket().receivedFrom();
    DeviceId receivedFromDevice = receivedFrom.deviceId();
    Ip6Address relayAgentIp = 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());
        return null;
    }
    IPv6 clientIpv6 = (IPv6) clientPacket.getPayload();
    UDP clientUdp = (UDP) clientIpv6.getPayload();
    DHCP6 clientDhcp6 = (DHCP6) clientUdp.getPayload();
    boolean directConnFlag = directlyConnected(clientDhcp6);
    Ip6Address serverIpFacing = getFirstIpFromInterface(serverInterface);
    if (serverIpFacing == null || serverInterface.mac() == null) {
        log.warn("No IP v6 address for server Interface {}", serverInterface);
        return null;
    }
    Ethernet etherReply = clientPacket.duplicate();
    etherReply.setSourceMACAddress(serverInterface.mac());
    // set default info and replace with indirect if available later on.
    if (serverInfo.getDhcpConnectMac().isPresent()) {
        etherReply.setDestinationMACAddress(serverInfo.getDhcpConnectMac().get());
    }
    if (serverInfo.getDhcpConnectVlan().isPresent()) {
        etherReply.setVlanID(serverInfo.getDhcpConnectVlan().get().toShort());
    }
    IPv6 ipv6Packet = (IPv6) etherReply.getPayload();
    byte[] peerAddress = clientIpv6.getSourceAddress();
    ipv6Packet.setSourceAddress(serverIpFacing.toOctets());
    ipv6Packet.setDestinationAddress(serverInfo.getDhcpServerIp6().get().toOctets());
    UDP udpPacket = (UDP) ipv6Packet.getPayload();
    udpPacket.setSourcePort(UDP.DHCP_V6_SERVER_PORT);
    DHCP6 dhcp6Packet = (DHCP6) udpPacket.getPayload();
    byte[] dhcp6PacketByte = dhcp6Packet.serialize();
    DHCP6 dhcp6Relay = new DHCP6();
    dhcp6Relay.setMsgType(DHCP6.MsgType.RELAY_FORW.value());
    if (directConnFlag) {
        dhcp6Relay.setLinkAddress(relayAgentIp.toOctets());
    } else {
        if (isServerIpEmpty(serverInfo)) {
            log.warn("indirect DhcpServerIp empty... use default server ");
        } else {
            // Check if mac is obtained for valid server ip
            if (isConnectMacEmpty(serverInfo, clientInterfaces)) {
                log.warn("indirect Dhcp ConnectMac empty ...");
                return null;
            }
            etherReply.setDestinationMACAddress(serverInfo.getDhcpConnectMac().get());
            etherReply.setVlanID(serverInfo.getDhcpConnectVlan().get().toShort());
            ipv6Packet.setDestinationAddress(serverInfo.getDhcpServerIp6().get().toOctets());
        }
        if (!serverInfo.getRelayAgentIp6(receivedFromDevice).isPresent()) {
            log.debug("indirect connection: relayAgentIp NOT availale from config file! Use dynamic. {}", HexString.toHexString(relayAgentIp.toOctets(), ":"));
            serverIpFacing = relayAgentIp;
        } else {
            serverIpFacing = serverInfo.getRelayAgentIp6(receivedFromDevice).get();
        }
        log.debug("Source IP address set as relay agent IP with value: {}", serverIpFacing);
        dhcp6Relay.setLinkAddress(serverIpFacing.toOctets());
        ipv6Packet.setSourceAddress(serverIpFacing.toOctets());
    }
    // peer address: address of the client or relay agent from which the message to be relayed was received.
    dhcp6Relay.setPeerAddress(peerAddress);
    // directly connected case, hop count is zero; otherwise, hop count + 1
    if (directConnFlag) {
        dhcp6Relay.setHopCount((byte) 0);
    } else {
        dhcp6Relay.setHopCount((byte) (dhcp6Packet.getHopCount() + 1));
    }
    List<Dhcp6Option> options = new ArrayList<>();
    addDhcp6OptionsFromClient(options, dhcp6PacketByte, context, clientPacket);
    dhcp6Relay.setOptions(options);
    udpPacket.setPayload(dhcp6Relay);
    udpPacket.resetChecksum();
    ipv6Packet.setPayload(udpPacket);
    ipv6Packet.setHopLimit((byte) 64);
    etherReply.setPayload(ipv6Packet);
    return etherReply;
}

Example 45 with Ethernet

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

the class KubevirtFloatingIpHandler method processGarpPacketForFloatingIp.

private void processGarpPacketForFloatingIp(KubevirtFloatingIp floatingIp, KubevirtNode electedGw) {
    if (floatingIp == null) {
        return;
    }
    KubevirtPort kubevirtPort = getKubevirtPortByFloatingIp(floatingIp);
    if (kubevirtPort == null) {
        return;
    }
    Ethernet ethernet = buildGarpPacket(kubevirtPort.macAddress(), floatingIp.floatingIp());
    if (ethernet == null) {
        return;
    }
    TrafficTreatment treatment = DefaultTrafficTreatment.builder().setOutput(externalPatchPortNum(deviceService, electedGw)).build();
    packetService.emit(new DefaultOutboundPacket(electedGw.intgBridge(), treatment, ByteBuffer.wrap(ethernet.serialize())));
}