Examples with IPv4 org.opendaylight.genius.mdsalutil.packet.IPv4 used on opensource projects

Example 1 with IPv4

use of org.opendaylight.genius.mdsalutil.packet.IPv4 in project netvirt by opendaylight.

the class SubnetRoutePacketInHandler method onPacketReceived.

@Override
public void onPacketReceived(PacketReceived notification) {
    short tableId = notification.getTableId().getValue();
    LOG.trace("{} onPacketReceived: Packet punted from table {}", LOGGING_PREFIX, tableId);
    byte[] data = notification.getPayload();
    if (notification.getMatch() == null || notification.getMatch().getMetadata() == null) {
        LOG.error("{} onPacketReceived: Received from table {} where the match or metadata are null", LOGGING_PREFIX, tableId);
        return;
    }
    BigInteger metadata = notification.getMatch().getMetadata().getMetadata();
    Ethernet res = new Ethernet();
    if (tableId == NwConstants.L3_SUBNET_ROUTE_TABLE) {
        LOG.trace("{} onPacketReceived: Some packet received as {}", LOGGING_PREFIX, notification);
        try {
            res.deserialize(data, 0, data.length * NetUtils.NUM_BITS_IN_A_BYTE);
        } catch (PacketException e) {
            LOG.error("{} onPacketReceived: Failed to decode Packet ", LOGGING_PREFIX, e);
            VpnManagerCounters.subnet_route_packet_failed.inc();
            return;
        }
        try {
            Packet pkt = res.getPayload();
            if (pkt instanceof IPv4) {
                IPv4 ipv4 = (IPv4) pkt;
                byte[] srcIp = Ints.toByteArray(ipv4.getSourceAddress());
                byte[] dstIp = Ints.toByteArray(ipv4.getDestinationAddress());
                String dstIpStr = NWUtil.toStringIpAddress(dstIp);
                String srcIpStr = NWUtil.toStringIpAddress(srcIp);
                // It is an ARP request on a configured VPN. So we must
                // attempt to respond.
                long vpnId = MetaDataUtil.getVpnIdFromMetadata(metadata);
                LOG.info("{} onPacketReceived: Processing IPv4 Packet received with Source IP {} and Target IP {}" + " and vpnId {}", LOGGING_PREFIX, srcIpStr, dstIpStr, vpnId);
                Optional<VpnIds> vpnIdsOptional = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId));
                if (!vpnIdsOptional.isPresent()) {
                    // Donot trigger subnetroute logic for packets from
                    // unknown VPNs
                    VpnManagerCounters.subnet_route_packet_ignored.inc();
                    LOG.info("{} onPacketReceived: Ignoring IPv4 packet with destination Ip {} and source Ip {}" + " as it came on unknown VPN with ID {}", LOGGING_PREFIX, dstIpStr, srcIpStr, vpnId);
                    return;
                }
                String vpnIdVpnInstanceName = vpnIdsOptional.get().getVpnInstanceName();
                if (VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker, vpnIdVpnInstanceName, dstIpStr) != null) {
                    VpnManagerCounters.subnet_route_packet_ignored.inc();
                    LOG.info("{} onPacketReceived: IPv4 Packet received with Target IP {} source IP {} vpnId {} " + "is a valid Neutron port,ignoring subnet route processing", LOGGING_PREFIX, dstIpStr, srcIp, vpnId);
                    return;
                }
                if (VpnUtil.getLearntVpnVipToPort(dataBroker, vpnIdVpnInstanceName, dstIpStr) != null) {
                    VpnManagerCounters.subnet_route_packet_ignored.inc();
                    LOG.info("{} onPacketReceived: IPv4 Packet received with Target IP {} source Ip {} vpnId {}" + " is an already discovered IPAddress, ignoring subnet route processing", LOGGING_PREFIX, dstIpStr, srcIp, vpnId);
                    return;
                }
                long elanTag = MetaDataUtil.getElanTagFromMetadata(metadata);
                if (elanTag == 0L) {
                    VpnManagerCounters.subnet_route_packet_failed.inc();
                    LOG.error("{} onPacketReceived: elanTag value from metadata found to be 0, for IPv4 " + " Packet received with Target IP {} src Ip {} vpnId {}", LOGGING_PREFIX, dstIpStr, srcIp, vpnId);
                    return;
                }
                if (!vpnIdsOptional.get().isExternalVpn()) {
                    handleInternalVpnSubnetRoutePacket(metadata, dstIp, srcIpStr, dstIpStr, ipv4.getDestinationAddress(), vpnIdVpnInstanceName, elanTag);
                    return;
                }
                byte[] srcMac = res.getSourceMACAddress();
                handleBgpVpnSubnetRoute(ipv4, srcMac, dstIp, dstIpStr, srcIpStr, elanTag);
            }
        } catch (UnknownHostException | InterruptedException | ExecutionException ex) {
            // Failed to handle packet
            VpnManagerCounters.subnet_route_packet_failed.inc();
            LOG.error("{} onPacketReceived: Failed to handle subnetroute packet.", LOGGING_PREFIX, ex);
        }
        return;
    }
// All Arp responses learning for invisble IPs is handled by
// ArpNotificationHandler
}

Example 2 with IPv4

use of org.opendaylight.genius.mdsalutil.packet.IPv4 in project netvirt by opendaylight.

the class NaptPacketInHandler method onPacketReceived.

@Override
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public void onPacketReceived(PacketReceived packetReceived) {
    String internalIPAddress = "";
    int portNumber = 0;
    long routerId = 0L;
    NAPTEntryEvent.Operation operation = NAPTEntryEvent.Operation.ADD;
    NAPTEntryEvent.Protocol protocol;
    Short tableId = packetReceived.getTableId().getValue();
    LOG.trace("onPacketReceived : packet: {}, tableId {}", packetReceived, tableId);
    if (tableId == NwConstants.OUTBOUND_NAPT_TABLE) {
        LOG.debug("onPacketReceived : NAPTPacketInHandler Packet for Outbound NAPT Table");
        byte[] inPayload = packetReceived.getPayload();
        Ethernet ethPkt = new Ethernet();
        if (inPayload != null) {
            try {
                ethPkt.deserialize(inPayload, 0, inPayload.length * NetUtils.NUM_BITS_IN_A_BYTE);
            } catch (Exception e) {
                LOG.warn("onPacketReceived: Failed to decode Packet", e);
                return;
            }
            if (ethPkt.getPayload() instanceof IPv4) {
                IPv4 ipPkt = (IPv4) ethPkt.getPayload();
                byte[] ipSrc = Ints.toByteArray(ipPkt.getSourceAddress());
                internalIPAddress = NWUtil.toStringIpAddress(ipSrc);
                LOG.trace("onPacketReceived : Retrieved internalIPAddress {}", internalIPAddress);
                if (ipPkt.getPayload() instanceof TCP) {
                    TCP tcpPkt = (TCP) ipPkt.getPayload();
                    portNumber = tcpPkt.getSourcePort();
                    if (portNumber < 0) {
                        portNumber = 32767 + portNumber + 32767 + 2;
                        LOG.trace("onPacketReceived : Retrieved and extracted TCP portNumber {}", portNumber);
                    }
                    protocol = NAPTEntryEvent.Protocol.TCP;
                    LOG.trace("onPacketReceived : Retrieved TCP portNumber {}", portNumber);
                } else if (ipPkt.getPayload() instanceof UDP) {
                    UDP udpPkt = (UDP) ipPkt.getPayload();
                    portNumber = udpPkt.getSourcePort();
                    if (portNumber < 0) {
                        portNumber = 32767 + portNumber + 32767 + 2;
                        LOG.trace("onPacketReceived : Retrieved and extracted UDP portNumber {}", portNumber);
                    }
                    protocol = NAPTEntryEvent.Protocol.UDP;
                    LOG.trace("onPacketReceived : Retrieved UDP portNumber {}", portNumber);
                } else {
                    LOG.error("onPacketReceived : Incoming Packet is neither TCP or UDP packet");
                    return;
                }
            } else {
                LOG.error("onPacketReceived : Incoming Packet is not IPv4 packet");
                return;
            }
            if (internalIPAddress != null) {
                BigInteger metadata = packetReceived.getMatch().getMetadata().getMetadata();
                routerId = MetaDataUtil.getNatRouterIdFromMetadata(metadata);
                if (routerId <= 0) {
                    LOG.error("onPacketReceived : Router ID is invalid");
                    return;
                }
                String sourceIPPortKey = routerId + NatConstants.COLON_SEPARATOR + internalIPAddress + NatConstants.COLON_SEPARATOR + portNumber;
                NatPacketProcessingState state = incomingPacketMap.get(sourceIPPortKey);
                if (state == null) {
                    state = new NatPacketProcessingState(System.currentTimeMillis(), -1);
                    incomingPacketMap.put(sourceIPPortKey, state);
                    LOG.trace("onPacketReceived : Processing new SNAT({}) Packet", sourceIPPortKey);
                    // send to Event Queue
                    NAPTEntryEvent naptEntryEvent = new NAPTEntryEvent(internalIPAddress, portNumber, routerId, operation, protocol, packetReceived, false, state);
                    LOG.info("onPacketReceived : First Packet IN Queue Size : {}", ((ThreadPoolExecutor) firstPacketExecutorService).getQueue().size());
                    firstPacketExecutorService.execute(() -> naptEventHandler.handleEvent(naptEntryEvent));
                } else {
                    LOG.trace("onPacketReceived : SNAT({}) Packet already processed.", sourceIPPortKey);
                    NAPTEntryEvent naptEntryEvent = new NAPTEntryEvent(internalIPAddress, portNumber, routerId, operation, protocol, packetReceived, true, state);
                    LOG.debug("onPacketReceived : Retry Packet IN Queue Size : {}", ((ThreadPoolExecutor) retryPacketExecutorService).getQueue().size());
                    long firstPacketInTime = state.getFirstPacketInTime();
                    retryPacketExecutorService.execute(() -> {
                        if (System.currentTimeMillis() - firstPacketInTime > 4000) {
                            LOG.error("onPacketReceived : Flow not installed even after 4sec." + "Dropping SNAT ({}) Packet", sourceIPPortKey);
                            removeIncomingPacketMap(sourceIPPortKey);
                            return;
                        }
                        naptEventHandler.handleEvent(naptEntryEvent);
                    });
                }
            } else {
                LOG.error("onPacketReceived : Retrived internalIPAddress is NULL");
            }
        }
    } else {
        LOG.trace("onPacketReceived : Packet is not from the Outbound NAPT table");
    }
}

Example 3 with IPv4

use of org.opendaylight.genius.mdsalutil.packet.IPv4 in project netvirt by opendaylight.

the class ElanUtils method getSourceIpAddress.

public Optional<IpAddress> getSourceIpAddress(Ethernet ethernet) {
    Optional<IpAddress> srcIpAddress = Optional.absent();
    if (ethernet.getPayload() == null) {
        return srcIpAddress;
    }
    byte[] ipAddrBytes = null;
    if (ethernet.getPayload() instanceof IPv4) {
        IPv4 ipv4 = (IPv4) ethernet.getPayload();
        ipAddrBytes = Ints.toByteArray(ipv4.getSourceAddress());
    } else if (ethernet.getPayload() instanceof ARP) {
        ipAddrBytes = ((ARP) ethernet.getPayload()).getSenderProtocolAddress();
    }
    if (ipAddrBytes != null) {
        String ipAddr = NWUtil.toStringIpAddress(ipAddrBytes);
        return Optional.of(IpAddressBuilder.getDefaultInstance(ipAddr));
    }
    return srcIpAddress;
}

Example 4 with IPv4

use of org.opendaylight.genius.mdsalutil.packet.IPv4 in project netvirt by opendaylight.

the class DhcpPktHandler method getDhcpPktIn.

private DHCP getDhcpPktIn(Ethernet actualEthernetPacket) {
    Ethernet ethPkt = actualEthernetPacket;
    if (ethPkt.getEtherType() == (short) NwConstants.ETHTYPE_802_1Q) {
        ethPkt = (Ethernet) ethPkt.getPayload();
    }
    // Currently only IPv4 is supported
    if (ethPkt.getPayload() instanceof IPv4) {
        IPv4 ipPkt = (IPv4) ethPkt.getPayload();
        if (ipPkt.getPayload() instanceof UDP) {
            UDP udpPkt = (UDP) ipPkt.getPayload();
            if (udpPkt.getSourcePort() == DhcpMConstants.DHCP_CLIENT_PORT && udpPkt.getDestinationPort() == DhcpMConstants.DHCP_SERVER_PORT) {
                LOG.trace("Matched DHCP_CLIENT_PORT and DHCP_SERVER_PORT");
                byte[] rawDhcpPayload = udpPkt.getRawPayload();
                DHCP reply = new DHCP();
                try {
                    reply.deserialize(rawDhcpPayload, 0, rawDhcpPayload.length);
                } catch (PacketException e) {
                    LOG.warn("Failed to deserialize DHCP pkt");
                    LOG.trace("Reason for failure", e);
                    return null;
                }
                return reply;
            }
        }
    }
    return null;
}

Example 5 with IPv4

use of org.opendaylight.genius.mdsalutil.packet.IPv4 in project netvirt by opendaylight.

the class DhcpPktHandler method getDhcpPacketOut.

// "Consider returning a zero length array rather than null" - the eventual user of the returned byte[] likely
// expects null and it's unclear what the behavior would be if empty array was returned.
@SuppressFBWarnings("PZLA_PREFER_ZERO_LENGTH_ARRAYS")
protected byte[] getDhcpPacketOut(DHCP reply, Ethernet etherPkt, String phyAddrees) {
    if (reply == null) {
        /*
             * DECLINE or RELEASE don't result in reply packet
             */
        return null;
    }
    LOG.trace("Sending DHCP Pkt {}", reply);
    InetAddress serverIp = reply.getOptionInetAddr(DHCPConstants.OPT_SERVER_IDENTIFIER);
    // create UDP pkt
    UDP udpPkt = new UDP();
    byte[] rawPkt;
    try {
        rawPkt = reply.serialize();
    } catch (PacketException e) {
        LOG.warn("Failed to serialize packet", e);
        return null;
    }
    udpPkt.setRawPayload(rawPkt);
    udpPkt.setDestinationPort(DhcpMConstants.DHCP_CLIENT_PORT);
    udpPkt.setSourcePort(DhcpMConstants.DHCP_SERVER_PORT);
    udpPkt.setLength((short) (rawPkt.length + 8));
    // Create IP Pkt
    try {
        rawPkt = udpPkt.serialize();
    } catch (PacketException e) {
        LOG.warn("Failed to serialize packet", e);
        return null;
    }
    short checkSum = 0;
    boolean computeUdpChecksum = true;
    if (computeUdpChecksum) {
        checkSum = computeChecksum(rawPkt, serverIp.getAddress(), NetUtils.intToByteArray4(DhcpMConstants.BCAST_IP));
    }
    udpPkt.setChecksum(checkSum);
    IPv4 ip4Reply = new IPv4();
    ip4Reply.setPayload(udpPkt);
    ip4Reply.setProtocol(IPProtocols.UDP.byteValue());
    ip4Reply.setSourceAddress(serverIp);
    ip4Reply.setDestinationAddress(DhcpMConstants.BCAST_IP);
    ip4Reply.setTotalLength((short) (rawPkt.length + 20));
    ip4Reply.setTtl((byte) 32);
    // create Ethernet Frame
    Ethernet ether = new Ethernet();
    if (etherPkt.getEtherType() == (short) NwConstants.ETHTYPE_802_1Q) {
        IEEE8021Q vlanPacket = (IEEE8021Q) etherPkt.getPayload();
        IEEE8021Q vlanTagged = new IEEE8021Q();
        vlanTagged.setCFI(vlanPacket.getCfi());
        vlanTagged.setPriority(vlanPacket.getPriority());
        vlanTagged.setVlanId(vlanPacket.getVlanId());
        vlanTagged.setPayload(ip4Reply);
        vlanTagged.setEtherType(EtherTypes.IPv4.shortValue());
        ether.setPayload(vlanTagged);
        ether.setEtherType((short) NwConstants.ETHTYPE_802_1Q);
    } else {
        ether.setEtherType(EtherTypes.IPv4.shortValue());
        ether.setPayload(ip4Reply);
    }
    ether.setSourceMACAddress(getServerMacAddress(phyAddrees));
    ether.setDestinationMACAddress(etherPkt.getSourceMACAddress());
    try {
        rawPkt = ether.serialize();
    } catch (PacketException e) {
        LOG.warn("Failed to serialize ethernet reply", e);
        return null;
    }
    return rawPkt;
}